upgrade flask-sqlalchemy

Author: davidism

sopy/__init__.py

@@ -1,19 +1,19 @@
 import logging
 import os
 import sys
+
 import pkg_resources
-from flask import Flask, send_from_directory
-from flask import render_template, url_for, redirect
-from flask_alembic import Alembic
+from flask import (
+    Flask, render_template, send_from_directory, redirect, url_for
+)
 from flask_alembic.cli.click import cli as alembic_cli
 from flask_babel import Babel
-from sopy.ext.sqlalchemy import SQLAlchemy
+
+from sopy.ext.sqlalchemy import db
 
 __version__ = pkg_resources.get_distribution('sopy').version
 
-alembic = Alembic()
 babel = Babel()
-db = SQLAlchemy()
 
 
 def create_app(info=None):
@@ -26,15 +26,17 @@ def create_app(info=None):
     app.jinja_env.trim_blocks = True
     app.jinja_env.lstrip_blocks = True
 
-    alembic.init_app(app)
     babel.init_app(app)
     db.init_app(app)
 
     from sopy.ext import views
 
     views.init_app(app)
 
-    from sopy import auth, tags, se_data, canon, salad, wiki, pages, admin, transcript, spoiler
+    from sopy import (
+        auth, tags, se_data, canon, salad, wiki, pages, admin, transcript,
+        spoiler
+    )
 
     app.register_blueprint(auth.bp, url_prefix='/auth')
     app.register_blueprint(tags.bp, url_prefix='/tags')
@@ -51,8 +53,14 @@ def create_app(info=None):
     def index():
         return render_template('index.html')
 
-    app.add_url_rule('/favicon.ico', None, app.send_static_file, defaults={'filename': 'favicon.ico'})
-    app.add_url_rule('/robots.txt', None, app.send_static_file, defaults={'filename': 'robots.txt'})
+    app.add_url_rule(
+        '/favicon.ico', None, app.send_static_file,
+        defaults={'filename': 'favicon.ico'}
+    )
+    app.add_url_rule(
+        '/robots.txt', None, app.send_static_file,
+        defaults={'filename': 'robots.txt'}
+    )
 
     @app.errorhandler(403)
     def forbidden(e):

sopy/ext/sqlalchemy.py

@@ -1,21 +1,17 @@
 from flask import current_app, g
-from flask_sqlalchemy import SQLAlchemy as BaseSQLAlchemy, _camelcase_re, _QueryProperty, BaseQuery
-from sqlalchemy import inspect, MetaData
-from sqlalchemy.ext.declarative import DeclarativeMeta as BaseDeclarativeMeta, declared_attr, declarative_base
+from flask_alembic import Alembic
+from flask_sqlalchemy import Model as BaseModel, SQLAlchemy as BaseSQLAlchemy
+from sqlalchemy import MetaData, inspect
 from sqlalchemy.orm import was_deleted
 
 
-class EqMixin:
-    """Compare and hash objects by custom values."""
-
+class Model(BaseModel):
     def compare_value(self):
         """Return what will be used to compare instances."""
-
-        return inspect(type(self)).identity
+        return inspect(self).identity
 
     def __eq__(self, other):
         """Instances of same class with equal compare values are equal."""
-
         if not isinstance(other, self.__class__):
             return NotImplemented
 
@@ -31,22 +27,19 @@ def __ne__(self, other):
 
     def __hash__(self):
         """Composite hash of class and compare value."""
-
         return hash(self.__class__) ^ hash(self.compare_value())
 
-
-class UniqueMixin:
-    """Keep a cache of unique instances in memory so new instances can be safely created in bulk before they are committed."""
-
     @classmethod
     def create_unique(cls, session, **kwargs):
         o = cls(**kwargs)
         session.add(o)
         return o
 
-
     @classmethod
     def get_unique(cls, **kwargs):
+        """Keep a cache of unique instances in memory so new instances
+        can be safely created in bulk before they are committed.
+        """
         g._unique_cache = cache = getattr(g, '_unique_cache', {})
         key = (cls, tuple(kwargs.items()))
         o = cache.get(key)
@@ -68,61 +61,24 @@ def get_unique(cls, **kwargs):
         return o
 
 
-class DeclarativeMeta(BaseDeclarativeMeta):
-    def __init__(cls, name, bases, attrs):
-        """Handle Flask-SQLAlchemy's bind_key without setting tablename."""
-
-        bind_key = attrs.pop('__bind_key__', None)
-        BaseDeclarativeMeta.__init__(cls, name, bases, attrs)
-
-        if bind_key is not None:
-            cls.__table__.info['bind_key'] = bind_key
-
-
-class Model(UniqueMixin, EqMixin):
-    query_class = BaseQuery
-
-    @declared_attr
-    def __tablename__(cls):
-        def _join(match):
-            word = match.group()
-
-            if len(word) > 1:
-                return ('_%s_%s' % (word[:-1], word[-1])).lower()
-
-            return '_' + word.lower()
-
-        return _camelcase_re.sub(_join, cls.__name__).lstrip('_')
-
-    def __str__(self):
-        return str(inspect(self).identity)
-
-    def __repr__(self):
-        return '<{0} {1}>'.format(self.__class__.__name__, self)
-
-    def compare_value(self):
-        return inspect(self).identity
-
-
 class SQLAlchemy(BaseSQLAlchemy):
-    def __init__(self, app=None, model=Model, meta=DeclarativeMeta, **kwargs):
-        self.BaseModel = model
-        self.DeclarativeMeta = meta
-        super(SQLAlchemy, self).__init__(app, **kwargs)
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.alembic = Alembic()
 
     def init_app(self, app):
         super(SQLAlchemy, self).init_app(app)
+        self.alembic.init_app(app)
         app.shell_context_processor(lambda: {'db': self})
 
-    def make_declarative_base(self, metadata=None):
-        metadata = MetaData(naming_convention={
-            'pk': 'pk_%(table_name)s',
-            'fk': 'fk_%(table_name)s_%(column_0_name)s_%(referred_table_name)s',
-            'uq': 'uq_%(table_name)s_%(column_0_name)s',
-            'ix': 'ix_%(table_name)s_%(column_0_name)s',
-            'ck': 'ck_%(table_name)s_%(constraint_name)s',
-        })
-        base = declarative_base(metadata=metadata, cls=self.BaseModel, name='Model', metaclass=self.DeclarativeMeta)
-        base.query = _QueryProperty(self)
-        base.db = self
-        return base
+
+db = SQLAlchemy(
+    metadata=MetaData(naming_convention={
+        'pk': 'pk_%(table_name)s',
+        'fk': 'fk_%(table_name)s_%(column_0_name)s_%(referred_table_name)s',
+        'uq': 'uq_%(table_name)s_%(column_0_name)s',
+        'ix': 'ix_%(table_name)s_%(column_0_name)s',
+        'ck': 'ck_%(table_name)s_%(constraint_name)s',
+    }),
+    model_class=Model
+)