reformat with black

Author: rednaks

django_async_orm/apps.py

@@ -5,10 +5,10 @@
 
 
 class AsyncOrmConfig(AppConfig):
-    name = 'django_async_orm'
+    name = "django_async_orm"
 
     def ready(self):
-        logging.info('AsyncORM: patching models')
+        logging.info("AsyncORM: patching models")
         for model in apps.get_models(include_auto_created=True):
             patch_manager(model)
             # TODO: patch_model(model)

django_async_orm/manager.py

@@ -1,5 +1,3 @@
-
-
 from django.db.models.manager import BaseManager
 
 from django_async_orm.query import QuerySetAsync

django_async_orm/query.py

@@ -9,7 +9,6 @@
 
 
 class QuerySetAsync(QuerySet):
-
     def __init__(self, model=None, query=None, using=None, hints=None):
         super().__init__(model, query, using, hints)
 
@@ -20,18 +19,24 @@ async def async_create(self, **kwargs):
         return await sync_to_async(self.create, thread_sensitive=True)(**kwargs)
 
     async def async_bulk_create(self, obs, batch_size=None, ignore_conflicts=False):
-        return await sync_to_async(self.bulk_create, thread_sensitive=True)(obs, batch_size=batch_size,
-                                                                            ignore_conflicts=ignore_conflicts)
+        return await sync_to_async(self.bulk_create, thread_sensitive=True)(
+            obs, batch_size=batch_size, ignore_conflicts=ignore_conflicts
+        )
 
     async def async_bulk_update(self, objs, fields, batch_size=None):
-        return await sync_to_async(self.bulk_update, thread_sensitive=True)(objs=objs, fields=fields,
-                                                                            batch_size=batch_size)
+        return await sync_to_async(self.bulk_update, thread_sensitive=True)(
+            objs=objs, fields=fields, batch_size=batch_size
+        )
 
     async def async_get_or_create(self, defaults=None, **kwargs):
-        return await sync_to_async(self.get_or_create, thread_sensitive=True)(defaults=defaults, **kwargs)
+        return await sync_to_async(self.get_or_create, thread_sensitive=True)(
+            defaults=defaults, **kwargs
+        )
 
     async def async_update_or_create(self, defaults=None, **kwargs):
-        return await sync_to_async(self.update_or_create, thread_sensitive=True)(defaults=defaults, **kwargs)
+        return await sync_to_async(self.update_or_create, thread_sensitive=True)(
+            defaults=defaults, **kwargs
+        )
 
     async def async_earliest(self, *fields):
         return await sync_to_async(self.earliest, thread_sensitive=True)(*fields)
@@ -48,8 +53,10 @@ async def async_none(self):
     async def async_last(self):
         return await sync_to_async(self.last, thread_sensitive=True)()
 
-    async def async_in_bulk(self, id_list=None, *_, field_name='pk'):
-        return await sync_to_async(self.in_bulk, thread_sensitive=True)(id_list=id_list, *_, field_name=field_name)
+    async def async_in_bulk(self, id_list=None, *_, field_name="pk"):
+        return await sync_to_async(self.in_bulk, thread_sensitive=True)(
+            id_list=id_list, *_, field_name=field_name
+        )
 
     async def async_delete(self):
         return await sync_to_async(self.delete, thread_sensitive=True)()
@@ -64,11 +71,14 @@ async def async_count(self):
         return await sync_to_async(self.count, thread_sensitive=True)()
 
     async def async_explain(self, *_, format=None, **options):
-        return await sync_to_async(self.explain, thread_sensitive=True)(*_, format=format, **options)
+        return await sync_to_async(self.explain, thread_sensitive=True)(
+            *_, format=format, **options
+        )
 
     async def async_raw(self, raw_query, params=None, translations=None, using=None):
-        return await sync_to_async(self.raw, thread_sensitive=True)(raw_query, params=params, translations=translations,
-                                                                    using=using)
+        return await sync_to_async(self.raw, thread_sensitive=True)(
+            raw_query, params=params, translations=translations, using=using
+        )
 
     def __aiter__(self):
         self._fetch_all()
@@ -78,9 +88,6 @@ def _fetch_all(self):
         with concurrent.futures.ThreadPoolExecutor(max_workers=1) as executor:
             future_fetch_all = executor.submit(super(QuerySetAsync, self)._fetch_all)
 
-
-
-
     ##################################################################
     # PUBLIC METHODS THAT ALTER ATTRIBUTES AND RETURN A NEW QUERYSET #
     ##################################################################
@@ -95,10 +102,14 @@ async def async_exclude(self, *args, **kwargs):
         return await sync_to_async(self.exclude, thread_sensitive=True)(*args, **kwargs)
 
     async def async_complex_filter(self, filter_obj):
-        return await sync_to_async(self.complex_filter, thread_sensitive=True)(filter_obj)
+        return await sync_to_async(self.complex_filter, thread_sensitive=True)(
+            filter_obj
+        )
 
     async def async_union(self, *other_qs, all=False):
-        return await sync_to_async(self.union, thread_sensitive=True)(*other_qs, all=all)
+        return await sync_to_async(self.union, thread_sensitive=True)(
+            *other_qs, all=all
+        )
 
     async def async_intersection(self, *other_qs):
         return await sync_to_async(self.intersection, thread_sensitive=True)(*other_qs)
@@ -107,24 +118,38 @@ async def async_difference(self, *other_qs):
         return await sync_to_async(self.difference, thread_sensitive=True)(*other_qs)
 
     async def async_select_for_update(self, nowait=False, skip_locked=False, of=()):
-        return await sync_to_async(self.select_for_update, thread_sensitive=True)(nowait=nowait,
-                                                                                  skip_locked=skip_locked, of=of)
+        return await sync_to_async(self.select_for_update, thread_sensitive=True)(
+            nowait=nowait, skip_locked=skip_locked, of=of
+        )
 
     async def async_prefetch_related(self, *lookups):
-        return await sync_to_async(self.prefetch_related, thread_sensitive=True)(*lookups)
+        return await sync_to_async(self.prefetch_related, thread_sensitive=True)(
+            *lookups
+        )
 
     async def async_annotate(self, *args, **kwargs):
-        return await sync_to_async(self.annotate, thread_sensitive=True)(*args, **kwargs)
+        return await sync_to_async(self.annotate, thread_sensitive=True)(
+            *args, **kwargs
+        )
 
     async def async_order_by(self, *field_names):
         return await sync_to_async(self.order_by, thread_sensitive=True)(*field_names)
 
     async def async_distinct(self, *field_names):
         return await sync_to_async(self.distinct, thread_sensitive=True)(*field_names)
 
-    async def async_extra(self, select=None, where=None, params=None, tables=None, order_by=None, select_params=None):
-        return await sync_to_async(self.extra, thread_sensitive=True)(select, where, params, tables, order_by,
-                                                                      select_params)
+    async def async_extra(
+        self,
+        select=None,
+        where=None,
+        params=None,
+        tables=None,
+        order_by=None,
+        select_params=None,
+    ):
+        return await sync_to_async(self.extra, thread_sensitive=True)(
+            select, where, params, tables, order_by, select_params
+        )
 
     async def async_reverse(self):
         return await sync_to_async(self.reverse, thread_sensitive=True)()
@@ -139,11 +164,13 @@ async def async_using(self, alias):
         return await sync_to_async(self.using, thread_sensitive=True)(alias)
 
     async def async_resolve_expression(self, *args, **kwargs):
-        return await sync_to_async(self.resolve_expression, thread_sensitive=True)(*args, **kwargs)
+        return await sync_to_async(self.resolve_expression, thread_sensitive=True)(
+            *args, **kwargs
+        )
 
     @property
     async def async_ordered(self):
         def _ordered():
             return super(QuerySetAsync, self).ordered
-        return await sync_to_async(_ordered, thread_sensitive=True)()
 
+        return await sync_to_async(_ordered, thread_sensitive=True)()

django_async_orm/utils.py

@@ -12,8 +12,12 @@ def mixin_async_manager_factory(model):
     """
 
     base_manager_cls = model.objects.__class__
-    if not base_manager_cls.__name__.startswith('MixinAsync'):
-        mixin_async_manager = type(f'MixinAsync{base_manager_cls.__name__}', (AsyncManager, base_manager_cls), dict())
+    if not base_manager_cls.__name__.startswith("MixinAsync"):
+        mixin_async_manager = type(
+            f"MixinAsync{base_manager_cls.__name__}",
+            (AsyncManager, base_manager_cls),
+            dict(),
+        )
         return mixin_async_manager
 
 

django_async_orm/wrappers.py

@@ -4,6 +4,7 @@
 
 def _sync_render(*args, **kwargs):
     from django.shortcuts import render
+
     return render(*args, **kwargs)