Merge pull request #46 from namespace-ee/renewal

supported versions renewal

Author: tonisvain

.travis.yml

@@ -5,11 +5,12 @@ python:
   - "3.6"
   - "3.7"
   - "3.8"
+  - "3.9"
 
 matrix:
   fast_finish: true
   include:
-    - python: 3.7
+    - python: 3.8
       env: TOXENV=lint
 
 # command to install dependencies, e.g. pip install -r requirements.txt --use-mirrors

HISTORY.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## 1.4.0 (2021-04-07)
+
+- Renewed **Python** supported versions `3.6 -> 3.9`
+- Renewed **Django** supported versions `2.2`, `3.1`, `3.2`
+- Renewed **Django-rest-framework** supported versions. `3.9 -> 3.12`
+
 ## 1.3.1 (2021-04-07)
 
 Added support for `django.db.models.Prefetch`

README.md

@@ -6,6 +6,7 @@
 [![Code style Black](https://img.shields.io/badge/code%20style-black-000000.svg?maxAge=2592000)](https://github.com/ambv/black)
 
 :warning: Note that there are major API changes since version 0.1.1 that have to be taken into account when upgrading!
+:warning: Python 2 and Django 1.11 are no longer supported from version 1.4.0!
 
 # Django rest framework sideloading
 
@@ -145,10 +146,11 @@ $ make tox
 
 ```shell
 $ tox --listenvs
-py27-django18-drf34
-py27-django19-drf34
+py37-django22-drf39
+py38-django31-drf311
+py39-django32-drf312
 # ...
-$ tox -e py27-django19-drf34
+$ tox -e py39-django32-drf312
 ```
 
 #### Test coverage

drf_sideloading/__init__.py

@@ -1 +1 @@
-__version__ = "1.3.1"
+__version__ = "1.4.0"

drf_sideloading/mixins.py

@@ -1,8 +1,4 @@
-from __future__ import unicode_literals
-
-import six
 import copy
-
 from itertools import chain
 
 from django.db.models import Prefetch
@@ -31,9 +27,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(
@@ -51,36 +45,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
 
@@ -94,44 +78,33 @@ def get_sideloading_prefetches(self):
                 if not isinstance(v, list):
                     v = [v]
                 for vi in v:
-                    if not isinstance(vi, (six.string_types, Prefetch)):
+                    if not isinstance(vi, (str, Prefetch)):
                         raise RuntimeError("Sideloadable prefetch values must be a list of strings or Prefetch objects")
         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()
@@ -148,17 +121,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)
@@ -174,67 +145,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/manage.py

@@ -1,4 +1,3 @@
-#!/usr/bin/env python
 import os
 import sys
 

example/products/admin.py

@@ -1,4 +1 @@
-# -*- coding: utf-8 -*-
-from __future__ import unicode_literals
-
 from django.contrib import admin

example/products/apps.py

@@ -1,6 +1,3 @@
-# -*- coding: utf-8 -*-
-from __future__ import unicode_literals
-
 from django.apps import AppConfig
 
 

example/products/migrations/0001_initial.py

@@ -1,6 +1,4 @@
-# -*- coding: utf-8 -*-
 # Generated by Django 1.11.3 on 2017-07-26 13:13
-from __future__ import unicode_literals
 
 from django.db import migrations, models
 import django.db.models.deletion