black

Author: tonisvain

drf_sideloading/mixins.py

@@ -28,9 +28,7 @@ def __init__(self, **kwargs):
     def check_sideloading_serializer_class(self):
         assert (
             self.sideloading_serializer_class is not None
-        ), "'{}' should either include a `sideloading_serializer_class` attribute, ".format(
-            self.__class__.__name__
-        )
+        ), "'{}' should either include a `sideloading_serializer_class` attribute, ".format(self.__class__.__name__)
         assert issubclass(
             self.sideloading_serializer_class, SideLoadableSerializer
         ), "'{}' `sideloading_serializer_class` must be a SideLoadableSerializer subclass".format(
@@ -48,36 +46,26 @@ def check_sideloading_serializer_class(self):
             self.sideloading_serializer_class.Meta, "primary", None
         ), "Sideloadable serializer must have a Meta attribute called primary!"
         assert (
-            self.sideloading_serializer_class.Meta.primary
-            in self.sideloading_serializer_class._declared_fields
+            self.sideloading_serializer_class.Meta.primary in self.sideloading_serializer_class._declared_fields
         ), "Sideloadable serializer Meta.primary must point to a field in the serializer!"
-        if (
-            getattr(self.sideloading_serializer_class.Meta, "prefetches", None)
-            is not None
-        ):
+        if getattr(self.sideloading_serializer_class.Meta, "prefetches", None) is not None:
             assert isinstance(
                 self.sideloading_serializer_class.Meta.prefetches, dict
             ), "Sideloadable serializer Meta attribute 'prefetches' must be a dict."
 
         # check serializer fields:
         for name, field in self.sideloading_serializer_class._declared_fields.items():
-            assert getattr(
-                field, "many", None
-            ), "SideLoadable field '{}' must be set as many=True".format(name)
+            assert getattr(field, "many", None), "SideLoadable field '{}' must be set as many=True".format(name)
 
         # check serializer fields:
         for name, field in self.sideloading_serializer_class._declared_fields.items():
-            assert getattr(
-                field, "many", None
-            ), "SideLoadable field '{}' must be set as many=True".format(name)
+            assert getattr(field, "many", None), "SideLoadable field '{}' must be set as many=True".format(name)
 
     def get_primary_field_name(self):
         return self.sideloading_serializer_class.Meta.primary
 
     def get_sideloadable_fields(self):
-        sideloadable_fields = copy.deepcopy(
-            self.sideloading_serializer_class._declared_fields
-        )
+        sideloadable_fields = copy.deepcopy(self.sideloading_serializer_class._declared_fields)
         sideloadable_fields.pop(self._primary_field_name, None)
         return sideloadable_fields
 
@@ -96,39 +84,28 @@ def get_sideloading_prefetches(self):
         return cleaned_prefetches
 
     def initialize_request(self, request, *args, **kwargs):
-        request = super(SideloadableRelationsMixin, self).initialize_request(
-            request=request, *args, **kwargs
-        )
+        request = super(SideloadableRelationsMixin, self).initialize_request(request=request, *args, **kwargs)
 
-        sideload_params = self.parse_query_param(
-            sideload_parameter=request.query_params.get(self.query_param_name, "")
-        )
+        sideload_params = self.parse_query_param(sideload_parameter=request.query_params.get(self.query_param_name, ""))
         if request.method == "GET" and sideload_params:
             # When sideloading disable BrowsableAPIForms
             if BrowsableAPIRenderer in self.renderer_classes:
                 renderer_classes = (
-                    list(self.renderer_classes)
-                    if isinstance(self.renderer_classes, tuple)
-                    else self.renderer_classes
+                    list(self.renderer_classes) if isinstance(self.renderer_classes, tuple) else self.renderer_classes
                 )
                 renderer_classes = [
-                    BrowsableAPIRendererWithoutForms if r == BrowsableAPIRenderer else r
-                    for r in renderer_classes
+                    BrowsableAPIRendererWithoutForms if r == BrowsableAPIRenderer else r for r in renderer_classes
                 ]
                 self.renderer_classes = renderer_classes
 
         return request
 
     def list(self, request, *args, **kwargs):
-        sideload_params = self.parse_query_param(
-            sideload_parameter=request.query_params.get(self.query_param_name, "")
-        )
+        sideload_params = self.parse_query_param(sideload_parameter=request.query_params.get(self.query_param_name, ""))
 
         # Do not sideload unless params and GET method
         if request.method != "GET" or not sideload_params:
-            return super(SideloadableRelationsMixin, self).list(
-                request, *args, **kwargs
-            )
+            return super(SideloadableRelationsMixin, self).list(request, *args, **kwargs)
 
         # After this `relations_to_sideload` is safe to use
         queryset = self.get_queryset()
@@ -145,17 +122,15 @@ def list(self, request, *args, **kwargs):
             sideloadable_page = self.get_sideloadable_page(page)
             serializer = self.sideloading_serializer_class(
                 instance=sideloadable_page,
-                fields_to_load=[self._primary_field_name]
-                + list(self.relations_to_sideload),
+                fields_to_load=[self._primary_field_name] + list(self.relations_to_sideload),
                 context={"request": request},
             )
             return self.get_paginated_response(serializer.data)
         else:
             sideloadable_page = self.get_sideloadable_page_from_queryset(queryset)
             serializer = self.sideloading_serializer_class(
                 instance=sideloadable_page,
-                fields_to_load=[self._primary_field_name]
-                + list(self.relations_to_sideload),
+                fields_to_load=[self._primary_field_name] + list(self.relations_to_sideload),
                 context={"request": request},
             )
             return Response(serializer.data)
@@ -171,67 +146,45 @@ def parse_query_param(self, sideload_parameter):
         This function finds string match between requested names and defined relation in view
 
         """
-        self.relations_to_sideload = set(sideload_parameter.split(",")) & set(
-            self._sideloadable_fields.keys()
-        )
+        self.relations_to_sideload = set(sideload_parameter.split(",")) & set(self._sideloadable_fields.keys())
         return self.relations_to_sideload
 
     def get_relevant_prefetches(self):
         if not self._prefetches:
             return set()
-        return set(
-            pf
-            for relation in self.relations_to_sideload
-            for pf in self._prefetches.get(relation, [])
-        )
+        return set(pf for relation in self.relations_to_sideload for pf in self._prefetches.get(relation, []))
 
     def get_sideloadable_page_from_queryset(self, queryset):
         # this works wonders, but can't be used when page is paginated...
         sideloadable_page = {self._primary_field_name: queryset}
         for relation in self.relations_to_sideload:
             if not isinstance(self._sideloadable_fields[relation], ListSerializer):
-                raise RuntimeError(
-                    "SideLoadable field '{}' must be set as many=True".format(relation)
-                )
+                raise RuntimeError("SideLoadable field '{}' must be set as many=True".format(relation))
 
             source = self._sideloadable_fields[relation].source or relation
             rel_model = self._sideloadable_fields[relation].child.Meta.model
-            rel_qs = rel_model.objects.filter(
-                pk__in=queryset.values_list(source, flat=True)
-            )
+            rel_qs = rel_model.objects.filter(pk__in=queryset.values_list(source, flat=True))
             sideloadable_page[source] = rel_qs
         return sideloadable_page
 
     def get_sideloadable_page(self, page):
         sideloadable_page = {self._primary_field_name: page}
         for relation in self.relations_to_sideload:
             if not isinstance(self._sideloadable_fields[relation], ListSerializer):
-                raise RuntimeError(
-                    "SideLoadable field '{}' must be set as many=True".format(relation)
-                )
+                raise RuntimeError("SideLoadable field '{}' must be set as many=True".format(relation))
 
             source = self._sideloadable_fields[relation].source or relation
-            sideloadable_page[source] = self.filter_related_objects(
-                related_objects=page, lookup=source
-            )
+            sideloadable_page[source] = self.filter_related_objects(related_objects=page, lookup=source)
         return sideloadable_page
 
     def filter_related_objects(self, related_objects, lookup):
-        current_lookup, remaining_lookup = (
-            lookup.split("__", 1) if "__" in lookup else (lookup, None)
-        )
+        current_lookup, remaining_lookup = lookup.split("__", 1) if "__" in lookup else (lookup, None)
         related_objects_set = {getattr(r, current_lookup) for r in related_objects} - {None}
-        if related_objects_set and next(
-            iter(related_objects_set)
-        ).__class__.__name__ in ["ManyRelatedManager", "RelatedManager"]:
-            related_objects_set = set(
-                chain(
-                    *[
-                        related_queryset.all()
-                        for related_queryset in related_objects_set
-                    ]
-                )
-            )
+        if related_objects_set and next(iter(related_objects_set)).__class__.__name__ in [
+            "ManyRelatedManager",
+            "RelatedManager",
+        ]:
+            related_objects_set = set(chain(*[related_queryset.all() for related_queryset in related_objects_set]))
         if remaining_lookup:
             return self.filter_related_objects(related_objects_set, remaining_lookup)
         return set(related_objects_set) - {"", None}

drf_sideloading/serializers.py

@@ -8,9 +8,7 @@
 class SideLoadableSerializer(serializers.Serializer):
     def __init__(self, instance=None, data=empty, fields_to_load=None, **kwargs):
         self.fields_to_load = fields_to_load
-        super(SideLoadableSerializer, self).__init__(
-            instance=instance, data=data, **kwargs
-        )
+        super(SideLoadableSerializer, self).__init__(instance=instance, data=data, **kwargs)
 
     def to_representation(self, instance):
         """
@@ -20,9 +18,7 @@ def to_representation(self, instance):
         fields = [
             f
             for f in self.fields.values()
-            if not f.write_only
-            and f.source in instance.keys()
-            and f.field_name in self.fields_to_load
+            if not f.write_only and f.source in instance.keys() and f.field_name in self.fields_to_load
         ]
 
         for field in fields:
@@ -36,9 +32,7 @@ def to_representation(self, instance):
             #
             # For related fields with `use_pk_only_optimization` we need to
             # resolve the pk value.
-            check_for_none = (
-                attribute.pk if isinstance(attribute, PKOnlyObject) else attribute
-            )
+            check_for_none = attribute.pk if isinstance(attribute, PKOnlyObject) else attribute
             if check_for_none is None:
                 ret[field.field_name] = None
             else:

example/products/models.py

@@ -15,10 +15,6 @@ class Partner(models.Model):
 
 class Product(models.Model):
     name = models.CharField(max_length=255)
-    category = models.ForeignKey(
-        Category, on_delete=models.CASCADE, related_name="products"
-    )
-    supplier = models.ForeignKey(
-        Supplier, on_delete=models.CASCADE, related_name="products"
-    )
+    category = models.ForeignKey(Category, on_delete=models.CASCADE, related_name="products")
+    supplier = models.ForeignKey(Supplier, on_delete=models.CASCADE, related_name="products")
     partners = models.ManyToManyField(Partner, related_name="products")

example/settings.py

@@ -90,9 +90,7 @@
 # https://docs.djangoproject.com/en/1.11/ref/settings/#auth-password-validators
 
 AUTH_PASSWORD_VALIDATORS = [
-    {
-        "NAME": "django.contrib.auth.password_validation.UserAttributeSimilarityValidator"
-    },
+    {"NAME": "django.contrib.auth.password_validation.UserAttributeSimilarityValidator"},
     {"NAME": "django.contrib.auth.password_validation.MinimumLengthValidator"},
     {"NAME": "django.contrib.auth.password_validation.CommonPasswordValidator"},
     {"NAME": "django.contrib.auth.password_validation.NumericPasswordValidator"},

pyproject.toml

@@ -0,0 +1,12 @@
+[tool.black]
+line-length = 120
+target-version = ["py37", "py38"]
+include = '\.pyi?$'
+exclude = '''
+/(
+    \.git
+  | build
+  | dist
+
+)/
+'''

tests/mixins.py

@@ -1,6 +1,6 @@
 class OtherMixin(object):
-    """ Mixin for testing purposes
-        Check if `self.action` attribute is availavle
+    """Mixin for testing purposes
+    Check if `self.action` attribute is availavle
     """
 
     def get_serializer_class(self):

tests/models.py

@@ -15,10 +15,6 @@ class Partner(models.Model):
 
 class Product(models.Model):
     name = models.CharField(max_length=255)
-    category = models.ForeignKey(
-        Category, related_name="products", on_delete=models.CASCADE
-    )
-    supplier = models.ForeignKey(
-        Supplier, related_name="products", on_delete=models.CASCADE
-    )
+    category = models.ForeignKey(Category, related_name="products", on_delete=models.CASCADE)
+    supplier = models.ForeignKey(Supplier, related_name="products", on_delete=models.CASCADE)
     partners = models.ManyToManyField(Partner, related_name="products", blank=True)

tests/settings.py

@@ -42,7 +42,4 @@
 
 SITE_ID = 1
 
-if django.VERSION >= (1, 10):
-    MIDDLEWARE = ()
-else:
-    MIDDLEWARE_CLASSES = ()
+MIDDLEWARE = ()