[GIT] forgot some files in previous commit

(6952a98f)

dbmigrate.py

+#!/usr/bin/env python
+import sys
+import os
+
+if __name__ == "__main__":
+
+    # Django settings
+    dirname = os.path.dirname(os.path.realpath(__file__))
+    os.environ.setdefault("DJANGO_SETTINGS_MODULE", "gargantext.settings")
+
+    # initialize Django application
+    from django.core.wsgi import get_wsgi_application
+    application = get_wsgi_application()
+
+    # retrieve Django models
+    import django.apps
+    django_models = django.apps.apps.get_models()
+    django_models_names = set(model._meta.db_table for model in django_models)
+
+    # migrate SQLAlchemy models
+    from gargantext import models
+    from gargantext.util.db import Base, engine
+    sqla_models_names = (
+        model for model in Base.metadata.tables.keys()
+        if model not in django_models_names
+    )
+    sqla_models = (
+        Base.metadata.tables[model_name]
+        for model_name in sqla_models_names
+    )
+    print()
+    for model in sqla_models:
+        try:
+            model.create(engine)
+            print('created model: `%s`' % model)
+        except Exception as e:
+            print('could not create model: `%s`, %s' % (model, e))
+        print()

gargantext/models/nodes.py

+from gargantext.util.db import *
+
+from datetime import datetime
+
+from .users import User
+
+
+__all__ = ['NodeType', 'Node']
+
+
+class NodeType(Base):
+    __tablename__ = 'nodetypes'
+    id = Column(Integer, primary_key=True)
+    name = Column(String(255), unique=True)
+
+class Node(Base):
+    __tablename__ = 'nodes'
+    id = Column(Integer, primary_key=True)
+    # foreign keys
+    user_id = Column(Integer, ForeignKey(User.id))
+    type_id = Column(Integer, ForeignKey(NodeType.id))
+    # main data
+    name = Column(String(255), unique=True)
+    date  = Column(DateTime(), default=datetime.now)
+    # metadata
+    hyperdata = Column(JSONB, default={})

gargantext/util/db.py

+from aldjemy.core import get_engine
+from gargantext import settings
+
+
+# get engine, session, etc.
+
+from sqlalchemy.orm import sessionmaker
+from sqlalchemy.ext.declarative import declarative_base
+
+def get_engine():
+    from sqlalchemy import create_engine
+    url = 'postgresql+psycopg2://{USER}:{PASSWORD}@{HOST}:{PORT}/{NAME}'.format(
+        **settings.DATABASES['default']
+    )
+    return create_engine(url, use_native_hstore=True)
+
+engine = get_engine()
+
+Base = declarative_base()
+
+Session = sessionmaker(bind=engine)
+
+
+# tools to build models
+
+from sqlalchemy.orm import aliased
+from sqlalchemy.types import *
+from sqlalchemy.schema import Column, ForeignKey, UniqueConstraint
+from sqlalchemy.dialects.postgresql import JSONB

gargantext/util/db_cache.py

+"""Cache management
+Allows retrieval of an instance from the value of one of its primary or unique
+keys, without querying the database.
+"""
+
+from sqlalchemy import or_
+
+from gargantext.util.db import *
+from gargantext import models
+
+
+class ModelCache(dict):
+
+    def __init__(self, model, preload=False):
+        self._session = Session()
+        self._model = model
+        self._columns = [column for column in model.__table__.columns if column.unique or column.primary_key]
+        self._columns_names = [column.name for column in self._columns]
+        if preload:
+            self.preload()
+
+    def __del__(self):
+        self._session.close()
+
+    def __missing__(self, key):
+        formatted_key = None
+        conditions = []
+        for column in self._columns:
+            try:
+                formatted_key = column.type.python_type(key)
+                conditions.append(column == key)
+            except ValueError as e:
+                continue
+        if formatted_key in self:
+            self[key] = self[formatted_key]
+        else:
+            element = self._session.query(self._model).filter(or_(*conditions)).first()
+            if element is None:
+                raise KeyError
+            self[key] = element
+        return element
+
+    def preload(self):
+        self.clear()
+        for element in self._session.query(self._model).all():
+            for column_name in self._columns_names:
+                key = getattr(element, column_name)
+                self[key] = element
+
+class Cache:
+
+    def __getattr__(self, key):
+        try:
+            model = getattr(models, key)
+        except AttributeError:
+            raise AttributeError('No such model: `%s`' % key)
+        modelcache = ModelCache(model)
+        setattr(self, key, modelcache)
+        return modelcache
+
+cache = Cache()