Upgrade to peewee-2.9 and drop our customizations

3 files changed, 9 insertions, 120 deletions

diff --git a/archivist/model.py b/archivist/model.py
index b76783e..e672d29 100644
--- a/archivist/model.py
+++ b/archivist/model.py
@@ -1,14 +1,14 @@
 from peewee import *
 from playhouse.fields import CompressedField as _CompressedField
 from playhouse.hybrid import *
-from playhouse.sqlite_ext import SqliteExtDatabase
+from playhouse.sqlite_ext import SqliteExtDatabase, ClosureTable
 
 import datetime
 from enum import Enum, unique
 from pkg_resources import resource_filename
 
 from .prefixes import query_pseudo_prefix
-from .peewee_ext import ClosureTable, EnumField
+from .peewee_ext import EnumField
  
 db = SqliteExtDatabase('test.db', pragmas=[('foreign_keys', 'ON')])
 db.load_extension(resource_filename(__name__, 'sqlext/closure'))
@@ -162,5 +162,8 @@ class TagImplications(BaseModel):
     def __repr__(self):
         return "<%s %d --> %d>" % (self.__class__.__name__, self.tag_id, self.implies_tag_id)
 
-TagClosure = ClosureTable(Tag, TagImplications, TagImplications.implies_tag, TagImplications.tag)
-table(TagClosure)
+TagClosure = table(ClosureTable(
+        Tag,
+        referencing_class = TagImplications,
+        foreign_key = TagImplications.implies_tag,
+        referencing_key = TagImplications.tag))
diff --git a/archivist/peewee_ext.py b/archivist/peewee_ext.py
index a5a360b..f835dc3 100644
--- a/archivist/peewee_ext.py
+++ b/archivist/peewee_ext.py
@@ -11,30 +11,6 @@ def sqlite_tuple_in(fields, values):
     subqueries = (reduce(op.and_, starmap(op.eq, zip(fields, value_tuple))) for value_tuple in values)
     return reduce(op.or_, subqueries)
 
-def convert_dict_to_node(self, qdict):
-    accum = []
-    joins = []
-    relationship = (ForeignKeyField, ReverseRelationDescriptor)
-    for key, value in sorted(qdict.items()):
-        curr = self.model_class
-        if '__' in key and key.rsplit('__', 1)[1] in DJANGO_MAP:
-            key, op = key.rsplit('__', 1)
-            op = DJANGO_MAP[op]
-        elif value is None:
-            op = OP.IS
-        else:
-            op = OP.EQ
-
-        for piece in key.split('__'):
-            model_attr = getattr(curr, piece)
-            if value is not None and isinstance(model_attr, relationship):
-                curr = model_attr.rel_model
-                joins.append(model_attr)
-        accum.append(Expression(model_attr, op, value))
-    return accum, joins
-
-Query.convert_dict_to_node = convert_dict_to_node
-
 class EnumField(Field):
     db_field = 'enum'
 
@@ -67,93 +43,3 @@ class EnumField(Field):
     def python_value(self, value):
         return value if value is None else self._enum_value(value)
 
-def ClosureTable(model_class, referencing_class = None, foreign_key=None, id_column = None):
-    """Model factory for the transitive closure extension."""
-    if referencing_class is None:
-        referencing_class = model_class
-
-    if foreign_key is None:
-        for field_obj in model_class._meta.rel.values():
-            if field_obj.rel_model is model_class:
-                foreign_key = field_obj
-                break
-        else:
-            raise ValueError('Unable to find self-referential foreign key.')
-
-    primary_key = model_class._meta.primary_key
-
-    if id_column is None:
-        id_column = primary_key
-
-    class BaseClosureTable(VirtualModel):
-        depth = VirtualIntegerField()
-        id = VirtualIntegerField()
-        idcolumn = VirtualCharField()
-        parentcolumn = VirtualCharField()
-        root = VirtualIntegerField()
-        tablename = VirtualCharField()
-
-        class Meta:
-            extension_module = 'transitive_closure'
-
-        @classmethod
-        def descendants(cls, node, depth=None, include_node=False):
-            query = (model_class
-                     .select(model_class, cls.depth.alias('depth'))
-                     .join(cls, on=(primary_key == cls.id))
-                     .where(cls.root == node)
-                     .naive())
-            if depth is not None:
-                query = query.where(cls.depth == depth)
-            elif not include_node:
-                query = query.where(cls.depth > 0)
-            return query
-
-        @classmethod
-        def ancestors(cls, node, depth=None, include_node=False):
-            query = (model_class
-                     .select(model_class, cls.depth.alias('depth'))
-                     .join(cls, on=(primary_key == cls.root))
-                     .where(cls.id == node)
-                     .naive())
-            if depth:
-                query = query.where(cls.depth == depth)
-            elif not include_node:
-                query = query.where(cls.depth > 0)
-            return query
-
-        @classmethod
-        def siblings(cls, node, include_node=False):
-            if referencing_class is model_class:
-                # self-join
-                fk_value = node._data.get(foreign_key.name)
-                query = model_class.select().where(foreign_key == fk_value)
-            else:
-                # siblings as given in reference_class
-                siblings = (referencing_class
-                        .select(id_column)
-                        .join(cls, on=(foreign_key == cls.root))
-                        .where((cls.id == node) & (cls.depth == 1)))
-
-                # the according models
-                query = (model_class
-                     .select()
-                     .where(primary_key << siblings)
-                     .naive())
-
-            if not include_node: 
-                query = query.where(primary_key != node)
-
-            return query
-    
-    class Meta:
-        database = referencing_class._meta.database
-        extension_options = {
-            'tablename': referencing_class._meta.db_table,
-            'idcolumn': id_column.db_column,
-            'parentcolumn': foreign_key.db_column}
-        primary_key = False
-
-    name = '%sClosure' % model_class.__name__
-    return type(name, (BaseClosureTable,), {'Meta': Meta, '__module__': __name__})
-
diff --git a/setup.py b/setup.py
index 44aa32a..f9503d7 100644
--- a/setup.py
+++ b/setup.py
@@ -43,8 +43,8 @@ setup(
     libraries=[('closure', {'sources': ['closure.c']})],
     package_data={'archivist' : ['sqlext/*']},
     install_requires=[
-        'Click',
-        'peewee'
+        'Click>=6.6',
+        'peewee>=2.9.0'
     ],
     entry_points='''
         [console_scripts]