Implement aget, acount, and aexists. (#103)

Author: clokep

CHANGELOG.rst

@@ -16,7 +16,8 @@ Bugfixes
 Improvements
 ------------
 
-* Initial support for `asynchronous queries`_. (`#99 <https://github.com/clokep/django-querysetsequence/pull/99>`_)
+* Initial support for `asynchronous queries`_. (`#99 <https://github.com/clokep/django-querysetsequence/pull/99>`_,
+  `#103 <https://github.com/clokep/django-querysetsequence/pull/103>`_)
 
 .. _asynchronous queries: https://docs.djangoproject.com/en/4.1/topics/db/queries/#async-queries
 

docs/api.rst

@@ -125,7 +125,7 @@ Summary of Supported APIs
       - |check|
       - See [1]_ for information on the ``QuerySet`` lookup: ``'#'``.
     * - |aget|_
-      - |xmark|
+      - |check|
       -
     * - |create|_
       - |xmark|
@@ -161,7 +161,7 @@ Summary of Supported APIs
       - |check|
       -
     * - |acount|_
-      - |xmark|
+      - |check|
       -
     * - |in_bulk|_
       - |xmark|
@@ -213,7 +213,7 @@ Summary of Supported APIs
       - |check|
       -
     * - |aexists|_
-      - |xmark|
+      - |check|
       -
     * - |contains|_
       - |check|

queryset_sequence/__init__.py

@@ -1,3 +1,4 @@
+import asyncio
 import functools
 from collections import defaultdict
 from itertools import dropwhile
@@ -958,7 +959,35 @@ def get(self, **kwargs):
     if django.VERSION >= (4, 1):
 
         async def aget(self, **kwargs):
-            raise NotImplementedError()
+            clone = self.filter(**kwargs)
+
+            awaitables = []
+            for qs in clone._querysets:
+                awaitables.append(qs.aget())
+
+            result = None
+            results = await asyncio.gather(*awaitables, return_exceptions=True)
+            for obj in results:
+                # If the object doesn't exist, hopefully another QuerySet has it.
+                if isinstance(obj, ObjectDoesNotExist):
+                    continue
+
+                # Re-raise a MultipleObjectsReturned() exception.
+                if isinstance(obj, MultipleObjectsReturned):
+                    raise obj
+
+                # If a second object is found, raise an exception.
+                if result:
+                    raise MultipleObjectsReturned()
+
+                result = obj
+
+            # Checked all QuerySets and no object was found.
+            if result is None:
+                raise self.model.DoesNotExist()
+
+            # Return the only result found.
+            return result
 
     def create(self, **kwargs):
         raise NotImplementedError()
@@ -1020,7 +1049,8 @@ def count(self):
     if django.VERSION >= (4, 1):
 
         async def acount(self):
-            raise NotImplementedError()
+            awaitables = [qs.acount() for qs in self._querysets]
+            return sum(await asyncio.gather(*awaitables)) - self._low_mark
 
     def in_bulk(self, id_list=None, *, field_name="pk"):
         raise NotImplementedError()
@@ -1176,7 +1206,8 @@ def exists(self):
     if django.VERSION >= (4, 1):
 
         async def aexists(self):
-            raise NotImplementedError()
+            awaitables = [qs.aexists() for qs in self._querysets]
+            return any(await asyncio.gather(*awaitables, return_exceptions=True))
 
     def contains(self, obj):
         return any(qs.contains(obj) for qs in self._querysets)

tests/test_querysetsequence.py

@@ -119,6 +119,11 @@ def test_count(self):
         with self.assertNumQueries(2):
             self.assertEqual(self.all.count(), 5)
 
+    @skipIf(django.VERSION < (4, 1), "Not supported in Django < 4.1.")
+    async def test_acount(self):
+        # The proper length should be returned via database queries.
+        self.assertEqual(await self.all.acount(), 5)
+
     def test_len(self):
         # Calling len() evaluates the QuerySet.
         with self.assertNumQueries(2):
@@ -138,10 +143,20 @@ def test_slice(self):
         with self.assertNumQueries(4):
             self.assertEqual(len(self.all[1:]), 4)
 
+    @skipIf(django.VERSION < (4, 1), "Not supported in Django < 4.1.")
+    async def test_acount_slice(self):
+        """Ensure the proper length is calculated when a slice is taken."""
+        self.assertEqual(await self.all[1:].acount(), 4)
+
     def test_empty_count(self):
         """An empty QuerySetSequence has a count of 0."""
         self.assertEqual(self.empty.count(), 0)
 
+    @skipIf(django.VERSION < (4, 1), "Not supported in Django < 4.1.")
+    async def test_acount_empty_count(self):
+        """An empty QuerySetSequence has a count of 0."""
+        self.assertEqual(await self.empty.acount(), 0)
+
     def test_empty_len(self):
         """An empty QuerySetSequence has a count of 0."""
         self.assertEqual(len(self.empty), 0)
@@ -1380,45 +1395,95 @@ def test_get(self):
         self.assertEqual(book.title, "Biography")
         self.assertIsInstance(book, Book)
 
+    @skipIf(django.VERSION < (4, 1), "Not supported in Django < 4.1.")
+    async def test_aget(self):
+        """
+        Ensure that aget() returns the expected element or raises DoesNotExist.
+        """
+        # Get a particular item.
+        book = await self.all.aget(title="Biography")
+        self.assertEqual(book.title, "Biography")
+        self.assertIsInstance(book, Book)
+
     def test_not_found(self):
         # An exception is raised if get() is called and nothing is found.
         with self.assertNumQueries(2):
             with self.assertRaises(ObjectDoesNotExist):
                 self.all.get(title="")
 
+    @skipIf(django.VERSION < (4, 1), "Not supported in Django < 4.1.")
+    async def test_aget_not_found(self):
+        with self.assertRaises(ObjectDoesNotExist):
+            await self.all.aget(title="")
+
     def test_multi_found(self):
         """Test multiple found in the same QuerySet."""
         # ...or if get() is called and multiple objects are found.
         with self.assertNumQueries(1):
             with self.assertRaises(MultipleObjectsReturned):
                 self.all.get(author=self.bob)
 
+    @skipIf(django.VERSION < (4, 1), "Not supported in Django < 4.1.")
+    async def test_aget_multi_found(self):
+        """Test multiple found in the same QuerySet."""
+        # ...or if aget() is called and multiple objects are found.
+        with self.assertRaises(MultipleObjectsReturned):
+            await self.all.aget(author=self.bob)
+
+    @skipIf(django.VERSION < (4, 1), "Not supported in Django < 4.1.")
     def test_multi_found_separate_querysets(self):
         """Test one found in each QuerySet."""
         # ...or if get() is called and multiple objects are found.
         with self.assertNumQueries(2):
             with self.assertRaises(MultipleObjectsReturned):
                 self.all.get(title__contains="A")
 
+    @skipIf(django.VERSION < (4, 1), "Not supported in Django < 4.1.")
+    async def test_aget_multi_found_separate_querysets(self):
+        """Test one found in each QuerySet."""
+        # ...or if aget() is called and multiple objects are found.
+        with self.assertRaises(MultipleObjectsReturned):
+            await self.all.aget(title__contains="A")
+
     def test_related_model(self):
         qss = QuerySetSequence(Article.objects.all(), BlogPost.objects.all())
         with self.assertNumQueries(2):
             post = qss.get(publisher__name="Wacky Website")
         self.assertEqual(post.title, "Post")
         self.assertIsInstance(post, BlogPost)
 
+    @skipIf(django.VERSION < (4, 1), "Not supported in Django < 4.1.")
+    async def test_aget_related_model(self):
+        qss = QuerySetSequence(Article.objects.all(), BlogPost.objects.all())
+        post = await qss.aget(publisher__name="Wacky Website")
+        self.assertEqual(post.title, "Post")
+        self.assertIsInstance(post, BlogPost)
+
     def test_queryset_lookup(self):
         """Test using the special QuerySet lookup."""
         with self.assertNumQueries(1):
             article = self.all.get(**{"#": 1, "author": self.bob})
         self.assertEqual(article.title, "Some Article")
         self.assertIsInstance(article, Article)
 
+    @skipIf(django.VERSION < (4, 1), "Not supported in Django < 4.1.")
+    async def test_aget_queryset_lookup(self):
+        """Test using the special QuerySet lookup."""
+        article = await self.all.aget(**{"#": 1, "author": self.bob})
+        self.assertEqual(article.title, "Some Article")
+        self.assertIsInstance(article, Article)
+
     def test_empty(self):
         """Calling get on an empty QuerySetSequence raises ObjectDoesNotExist."""
         with self.assertRaises(ObjectDoesNotExist):
             self.empty.get(pk=1)
 
+    @skipIf(django.VERSION < (4, 1), "Not supported in Django < 4.1.")
+    async def test_aget_empty(self):
+        """Calling get on an empty QuerySetSequence raises ObjectDoesNotExist."""
+        with self.assertRaises(ObjectDoesNotExist):
+            await self.empty.get(pk=1)
+
 
 class TestBoolean(TestBase):
     """Tests related to casting the QuerySetSequence to a boolean."""
@@ -1553,27 +1618,57 @@ def test_exists(self):
         with self.assertNumQueries(1):
             self.assertTrue(self.all.filter(title="Biography").exists())
 
+    @skipIf(django.VERSION < (4, 1), "Not supported in Django < 4.1.")
+    async def test_aexists(self):
+        """
+        Ensure that aexists() returns True if the item is found in the first QuerySet.
+        """
+        self.assertTrue(await self.all.filter(title="Biography").aexists())
+
     def test_exists_second(self):
         """
         Ensure that exists() returns True if the item is found in a subsequent QuerySet.
         """
         with self.assertNumQueries(2):
             self.assertTrue(self.all.filter(title="Alice in Django-land").exists())
 
+    @skipIf(django.VERSION < (4, 1), "Not supported in Django < 4.1.")
+    async def test_aexists_second(self):
+        """
+        Ensure that aexists() returns True if the item is found in a subsequent
+        QuerySet.
+        """
+        self.assertTrue(await self.all.filter(title="Alice in Django-land").aexists())
+
     def test_not_found(self):
         """Ensure that exists() returns False if the item is not found."""
         with self.assertNumQueries(2):
             self.assertFalse(self.all.filter(title="").exists())
 
+    @skipIf(django.VERSION < (4, 1), "Not supported in Django < 4.1.")
+    async def test_aexists_not_found(self):
+        """Ensure that aexists() returns False if the item is not found."""
+        self.assertFalse(await self.all.filter(title="").aexists())
+
     def test_multi_found(self):
         """Ensure that exists() returns True if multiple items are found."""
         with self.assertNumQueries(1):
             self.assertTrue(self.all.filter(author=self.bob).exists())
 
+    @skipIf(django.VERSION < (4, 1), "Not supported in Django < 4.1.")
+    async def test_aexists_multi_found(self):
+        """Ensure that aexists() returns True if multiple items are found."""
+        self.assertTrue(await self.all.filter(author=self.bob).aexists())
+
     def test_empty(self):
         """An empty QuerySetSequence should return False."""
         self.assertFalse(self.empty.exists())
 
+    @skipIf(django.VERSION < (4, 1), "Not supported in Django < 4.1.")
+    async def test_aexists_empty(self):
+        """An empty QuerySetSequence should return False."""
+        self.assertFalse(await self.empty.aexists())
+
 
 @skipIf(django.VERSION < (4, 0), "Not supported in Django < 4.0.")
 class TestContains(TestBase):
@@ -1786,12 +1881,14 @@ def test_raw(self):
         with self.assertRaises(NotImplementedError):
             self.all.raw("")
 
+    @skipIf(django.VERSION >= (4, 1), "aget exists starting on Django 4.1.")
     async def test_aget(self):
-        with self.assertRaises(ImplementedIn41):
+        with self.assertRaises(AttributeError):
             await self.all.aget()
 
+    @skipIf(django.VERSION >= (4, 1), "acount exists starting on Django 4.1.")
     async def test_acount(self):
-        with self.assertRaises(ImplementedIn41):
+        with self.assertRaises(AttributeError):
             await self.all.acount()
 
     async def test_aiterator(self):
@@ -1822,8 +1919,9 @@ async def test_aaggregate(self):
         with self.assertRaises(ImplementedIn41):
             await self.all.aaggregate()
 
+    @skipIf(django.VERSION >= (4, 1), "aexists exists starting on Django 4.1.")
     async def test_aexists(self):
-        with self.assertRaises(ImplementedIn41):
+        with self.assertRaises(AttributeError):
             await self.all.aexists()
 
     async def test_acontains(self):