Change version to dev and fix recursion error with related list sort

Author: frmdstryr

atomdb/sql.py

@@ -197,7 +197,12 @@ class RelatedList(atomclist):
 
         __slots__ = ()
 
-        async def load(self) -> list:
+        def sort(self, *, key=None, reverse=False):
+            # AtomCListHandler calls super(type(self), self).sort which causes a loop
+            # in a loop because we fiddle with the __class__
+            super(atomclist, self).sort(key=key, reverse=reverse)
+
+        async def load(self, inplace: bool = True) -> list:
             """Returns a list of the related values."""
             Model = cast(Type[SQLModel], type(owner))
             ThroughModel = relation.through
@@ -234,38 +239,45 @@ async def load(self) -> list:
                         f"relation between {Model} and through model {ThroughModel}"
                         f": Tried {Model.__backrefs__}"
                     )
-                return [
+                items = [
                     getattr(row, relation_backref.name)
                     for row in await ThroughModel.objects.select_related(
                         relation_backref.name
                     ).filter(**{owner_backref.name: owner})
                 ]
-            # A many to one relation case. For example:
-            #
-            #   class Page(SQLModel):
-            #       comments = Relation(lambda: Comment)
-            #   class Comment(SQLModel):
-            #       page = Instance(Page)
-            #
-            # When we have:
-            #   comments = await page.comments.load()
-            # The page is the owner, and the comments member is the relation.
-            # So inlining it will be the same as the following:
-            #   comments = await Comments.objects.filter(page=page)
-            owner_backref = resolve_backref(Model, RelModel)
-            if owner_backref is None:
-                raise UnresolvableError(
-                    f"relation between {Model} and {RelModel}"
-                    f": Tried {Model.__backrefs__}"
-                )
-            return await RelModel.objects.filter(**{owner_backref.name: owner})
+            else:
+                # A many to one relation case. For example:
+                #
+                #   class Page(SQLModel):
+                #       comments = Relation(lambda: Comment)
+                #   class Comment(SQLModel):
+                #       page = Instance(Page)
+                #
+                # When we have:
+                #   comments = await page.comments.load()
+                # The page is the owner, and the comments member is the relation.
+                # So inlining it will be the same as the following:
+                #   comments = await Comments.objects.filter(page=page)
+                owner_backref = resolve_backref(Model, RelModel)
+                if owner_backref is None:
+                    raise UnresolvableError(
+                        f"relation between {Model} and {RelModel}"
+                        f": Tried {Model.__backrefs__}"
+                    )
+                items = await RelModel.objects.filter(**{owner_backref.name: owner})
+
+            if inplace:
+                for item in items:
+                    if item not in self:
+                        self.append(item)
+            return items
 
         async def save(self, connection=None):
             """Save the current list as the complete set of related items. This
             should only be used for small sets of items.
             """
             current = set(self)
-            saved = set(await self.load())
+            saved = set(await self.load(inplace=False))
             ThroughModel = relation.through
             RelModel = relation.to
             if ThroughModel is not None:

setup.py

@@ -13,7 +13,7 @@
 
 setup(
     name="atom-db",
-    version="0.8.1",
+    version="0.8.1.dev",
     author="CodeLV",
     author_email="[email protected]",
     url="https://github.com/codelv/atom-db",

tests/test_sql.py

@@ -552,12 +552,14 @@ async def test_query_related(db):
     job2 = await Job.objects.create(name="Manager")
 
     await JobRole.objects.create(job=job, name="Cooking")
+    await JobRole.objects.create(job=job, name="Grilling")
+
     await JobRole.objects.create(job=job1, name="Serving")
     role2 = await JobRole.objects.create(job=job2, name="Managing")
 
     roles = await JobRole.objects.filter(job__name__in=[job.name, job2.name])
-    assert len(roles) == 2
-    assert await JobRole.objects.count(job__name__in=[job.name, job2.name]) == 2
+    assert len(roles) == 3
+    assert await JobRole.objects.count(job__name__in=[job.name, job2.name]) == 3
 
     roles = await JobRole.objects.filter(job__name=job2.name)
     assert len(roles) == 1
@@ -570,7 +572,17 @@ async def test_query_related(db):
     assert len(roles) == 1 and roles[0] == role2
 
     roles = await JobRole.objects.filter(job__name__not="none of the above")
-    assert len(roles) == 3
+    assert len(roles) == 4
+
+    # Test related list
+    assert len(job.roles) == 0  # Not loaded
+    await job.roles.load()
+    assert len(job.roles) == 2
+    job.roles.append(JobRole(name="Baking", job=job))
+    job.roles.sort(key=lambda it: it.name)
+    assert [it.name for it in job.roles] == ["Baking", "Cooking", "Grilling"]
+    await job.roles.save()
+    assert await JobRole.objects.filter(job__name=job.name).count() == 3
 
     # Cant do multiple joins
     with pytest.raises(ValueError):