django-camomilla-cms 6.0.0b15__py2.py3-none-any.whl → 6.0.0b17__py2.py3-none-any.whl

camomilla/serializers/mixins/__init__.py

@@ -1,195 +1,23 @@
-import django
-from django.conf import settings as django_settings
-from django.db.models.aggregates import Max
-from django.db.models.functions import Coalesce
-from django.utils import translation
-from rest_framework import serializers
-from rest_framework.utils import model_meta
-
-from camomilla.models import UrlNode
-from camomilla.fields import ORDERING_ACCEPTED_FIELDS
-from camomilla.serializers.fields.related import RelatedField
-from camomilla.serializers.utils import build_standard_model_serializer
-from camomilla.serializers.validators import UniquePermalinkValidator
-from camomilla.utils import dict_merge
-from camomilla import settings
-
-if django.VERSION >= (4, 0):
-    from django.db.models import JSONField as DjangoJSONField
-else:
-    from django.contrib.postgres.fields import JSONField as DjangoJSONField
-
-from typing import TYPE_CHECKING
-
-if TYPE_CHECKING:
-    from camomilla.models.page import AbstractPage
-
-
-# TODO: decide what to do with LangInfoMixin mixin!
-class LangInfoMixin(metaclass=serializers.SerializerMetaclass):
-    """
-    This mixin adds a "lang_info" field to the serializer.
-    This field contains information about the languages available in the site.
-    """
-    lang_info = serializers.SerializerMethodField("get_lang_info", read_only=True)
-
-    def get_lang_info(self, obj, *args, **kwargs):
-        languages = []
-        for key, language in django_settings.LANGUAGES:
-            languages.append({"id": key, "name": language})
-        return {
-            "default": django_settings.LANGUAGE_CODE,
-            "active": translation.get_language(),
-            "site_languages": languages,
-        }
-
-    def get_default_field_names(self, *args):
-        field_names = super().get_default_field_names(*args)
-        self.action = getattr(
-            self, "action", self.context and self.context.get("action", "list")
-        )
-        if self.action != "retrieve":
-            return [f for f in field_names if f != "lang_info"]
-        return field_names
-
-
-class SetupEagerLoadingMixin:
-    """
-    This mixin allows to use the setup_eager_loading method to optimize the queries.
-    """
-    @staticmethod
-    def setup_eager_loading(queryset):
-        return queryset
-
-
-class OrderingMixin:
-    """
-    This mixin allows to set the default value of an ordering field to the max value + 1.
-    """
-
-    def get_max_order(self, order_field):
-        return self.Meta.model.objects.aggregate(
-            max_order=Coalesce(Max(order_field), 0)
-        )["max_order"]
-
-    def _get_ordering_field_name(self):
-        try:
-            field_name = self.Meta.model._meta.ordering[0]
-            if field_name[0] == "-":
-                field_name = field_name[1:]
-            return field_name
-        except (AttributeError, IndexError):
-            return None
-
-    def build_standard_field(self, field_name, model_field):
-        field_class, field_kwargs = super().build_standard_field(
-            field_name, model_field
-        )
-        if (
-            isinstance(model_field, ORDERING_ACCEPTED_FIELDS)
-            and field_name == self._get_ordering_field_name()
-        ):
-            field_kwargs["default"] = self.get_max_order(field_name) + 1
-        return field_class, field_kwargs
-
-
-class JSONFieldPatchMixin:
-    """
-    This mixin allows to patch JSONField values during partial updates.
-    This means that, if a JSONField is present in the request and the requsest uses PATCH method,
-    the serializer will merge the new data with the old one.
-    """
-
-    def is_json_field(self, attr, value, info):
-        return (
-            attr in info.fields
-            and isinstance(info.fields[attr], DjangoJSONField)
-            and isinstance(value, dict)
-        )
-
-    def update(self, instance, validated_data):
-        if self.partial:
-            info = model_meta.get_field_info(instance)
-            for attr, value in validated_data.items():
-                if self.is_json_field(attr, value, info):
-                    validated_data[attr] = dict_merge(
-                        getattr(instance, attr, {}), value
-                    )
-        return super().update(instance, validated_data)
-
-
-class NestMixin:
-    """
-    This mixin automatically creates nested serializers for relational fields.
-    The depth of the nesting can be set using the "depth" attribute of the Meta class.
-    If the depth is not set, the serializer will use the value coming from the settings.
-
-    CAMOMILLA = { "API": {"NESTING_DEPTH": 10} }
-    """
-
-    def __init__(self, *args, **kwargs):
-        self._depth = kwargs.pop("depth", None)
-        return super().__init__(*args, **kwargs)
-
-    def build_nested_field(self, field_name, relation_info, nested_depth):
-        return self.build_relational_field(field_name, relation_info, nested_depth)
-
-    def build_relational_field(
-        self, field_name, relation_info, nested_depth=settings.API_NESTING_DEPTH + 1
-    ):
-        nested_depth = nested_depth if self._depth is None else self._depth
-        field_class, field_kwargs = super().build_relational_field(
-            field_name, relation_info
-        )
-        if (
-            field_class is RelatedField and nested_depth > 1
-        ):  # stop recursion one step before the jump :P
-            field_kwargs["serializer"] = build_standard_model_serializer(
-                relation_info[1], nested_depth - 1
-            )
-        return field_class, field_kwargs
-
-
-class AbstractPageMixin(serializers.ModelSerializer):
-    """
-    This mixin is needed to serialize AbstractPage models.
-    It provides permalink validation and some extra fields serialization.
-
-    Use it as a base class for your serializer if you need to serialize custom AbstractPage models.
-    """
-
-    breadcrumbs = serializers.SerializerMethodField()
-    routerlink = serializers.CharField(read_only=True)
-    template_file = serializers.SerializerMethodField()
-
-    def get_template_file(self, instance: "AbstractPage"):
-        return instance.get_template_path()
-
-    def get_breadcrumbs(self, instance: "AbstractPage"):
-        return instance.breadcrumbs
-
-    @property
-    def translation_fields(self):
-        return super().translation_fields + ["permalink"]
-
-    def get_default_field_names(self, *args):
-        from camomilla.contrib.rest_framework.serializer import RemoveTranslationsMixin
-
-        if RemoveTranslationsMixin in self.__class__.__bases__:  # noqa: E501
-            return super().get_default_field_names(*args)
-        return (
-            [f for f in super().get_default_field_names(*args) if f != "url_node"]
-            + UrlNode.LANG_PERMALINK_FIELDS
-            + ["permalink"]
-        )
-
-    def build_field(self, field_name, info, model_class, nested_depth):
-        if field_name in UrlNode.LANG_PERMALINK_FIELDS + ["permalink"]:
-            return serializers.CharField, {
-                "required": False,
-                "allow_blank": True,
-            }
-        return super().build_field(field_name, info, model_class, nested_depth)
-
-    def get_validators(self):
-        return super().get_validators() + [UniquePermalinkValidator()]
+from .fields import FieldsOverrideMixin
+from .filter_fields import FilterFieldsMixin
+from .json import JSONFieldPatchMixin
+from .language import LangInfoMixin
+from .nesting import NestMixin
+from .optimize import SetupEagerLoadingMixin
+from .ordering import OrderingMixin
+from .page import AbstractPageMixin
+from .translation import TranslationsMixin, RemoveTranslationsMixin
+
+
+__all__ = [
+    "FieldsOverrideMixin",
+    "FilterFieldsMixin",
+    "JSONFieldPatchMixin",
+    "LangInfoMixin",
+    "NestMixin",
+    "SetupEagerLoadingMixin",
+    "OrderingMixin",
+    "AbstractPageMixin",
+    "TranslationsMixin",
+    "RemoveTranslationsMixin",
+]

camomilla/serializers/mixins/fields.py

@@ -0,0 +1,20 @@
+from django.db import models
+from rest_framework import serializers
+
+from structured.fields import StructuredJSONField as ModelStructuredJSONField
+from camomilla.serializers.fields import FileField, ImageField, RelatedField
+from structured.contrib.restframework import StructuredJSONField
+
+
+class FieldsOverrideMixin:
+    """
+    This mixin automatically overrides the fields of the serializer with camomilla's backed ones.
+    """
+
+    serializer_field_mapping = {
+        **serializers.ModelSerializer.serializer_field_mapping,
+        models.FileField: FileField,
+        models.ImageField: ImageField,
+        ModelStructuredJSONField: StructuredJSONField,
+    }
+    serializer_related_field = RelatedField

camomilla/serializers/mixins/filter_fields.py

@@ -0,0 +1,57 @@
+from rest_framework import serializers
+from camomilla.serializers.fields.related import RelatedField
+from collections import defaultdict
+
+
+class FilterFieldsMixin(serializers.ModelSerializer):
+    """
+    Mixin to filter fields from a serializer, including handling nested fields.
+    """
+
+    def __init__(self, *args, **kwargs):
+        self.inherited_fields_filter = kwargs.pop("inherited_fields_filter", [])
+        return super().__init__(*args, **kwargs)
+
+    inherited_fields_filter = []
+
+    def get_default_field_names(self, *args):
+        field_names = super().get_default_field_names(*args)
+        request = self.context.get("request", None)
+
+        if request is not None and request.method == "GET":
+            fields = request.query_params.get("fields", "").split(",")
+            fields = [f for f in fields if f != ""]
+            if len(self.inherited_fields_filter) > 0:
+                fields = self.inherited_fields_filter
+
+            self.filtered_fields = set()
+            self.childs_fields = defaultdict(set)
+            for field in fields:
+                if "__" in field:
+                    parent_field, child_field = field.split("__", 1)
+                    if parent_field in field_names:
+                        self.filtered_fields.add(parent_field)
+                        self.childs_fields[parent_field].add(child_field)
+                else:
+                    if field in field_names:
+                        self.filtered_fields.add(field)
+
+            if len(self.filtered_fields) > 0:
+                return list(self.filtered_fields)
+            else:
+                return field_names
+
+        return field_names
+
+    def build_field(self, field_name, info, model_class, nested_depth):
+        field_class, field_kwargs = super().build_field(
+            field_name, info, model_class, nested_depth
+        )
+        inherited_fields_filter = (
+            self.childs_fields.get(field_name, [])
+            if hasattr(self, "childs_fields")
+            else []
+        )
+        if len(inherited_fields_filter) > 0 and issubclass(field_class, RelatedField):
+            field_kwargs["inherited_fields_filter"] = list(inherited_fields_filter)
+        return field_class, field_kwargs

camomilla/serializers/mixins/json.py

@@ -0,0 +1,34 @@
+import django
+from rest_framework.utils import model_meta
+
+from camomilla.utils import dict_merge
+
+if django.VERSION >= (4, 0):
+    from django.db.models import JSONField as DjangoJSONField
+else:
+    from django.contrib.postgres.fields import JSONField as DjangoJSONField
+
+
+class JSONFieldPatchMixin:
+    """
+    This mixin allows to patch JSONField values during partial updates.
+    This means that, if a JSONField is present in the request and the requsest uses PATCH method,
+    the serializer will merge the new data with the old one.
+    """
+
+    def is_json_field(self, attr, value, info):
+        return (
+            attr in info.fields
+            and isinstance(info.fields[attr], DjangoJSONField)
+            and isinstance(value, dict)
+        )
+
+    def update(self, instance, validated_data):
+        if self.partial:
+            info = model_meta.get_field_info(instance)
+            for attr, value in validated_data.items():
+                if self.is_json_field(attr, value, info):
+                    validated_data[attr] = dict_merge(
+                        getattr(instance, attr, {}), value
+                    )
+        return super().update(instance, validated_data)

camomilla/serializers/mixins/language.py

@@ -0,0 +1,32 @@
+from django.conf import settings as django_settings
+from django.utils import translation
+from rest_framework import serializers
+
+
+# TODO: decide what to do with LangInfoMixin mixin!
+class LangInfoMixin(metaclass=serializers.SerializerMetaclass):
+    """
+    This mixin adds a "lang_info" field to the serializer.
+    This field contains information about the languages available in the site.
+    """
+
+    lang_info = serializers.SerializerMethodField("get_lang_info", read_only=True)
+
+    def get_lang_info(self, obj, *args, **kwargs):
+        languages = []
+        for key, language in django_settings.LANGUAGES:
+            languages.append({"id": key, "name": language})
+        return {
+            "default": django_settings.LANGUAGE_CODE,
+            "active": translation.get_language(),
+            "site_languages": languages,
+        }
+
+    def get_default_field_names(self, *args):
+        field_names = super().get_default_field_names(*args)
+        self.action = getattr(
+            self, "action", self.context and self.context.get("action", "list")
+        )
+        if self.action != "retrieve":
+            return [f for f in field_names if f != "lang_info"]
+        return field_names

camomilla/serializers/mixins/nesting.py

@@ -0,0 +1,35 @@
+from camomilla.serializers.fields.related import RelatedField
+from camomilla.serializers.utils import build_standard_model_serializer
+from camomilla import settings
+
+
+class NestMixin:
+    """
+    This mixin automatically creates nested serializers for relational fields.
+    The depth of the nesting can be set using the "depth" attribute of the Meta class.
+    If the depth is not set, the serializer will use the value coming from the settings.
+
+    CAMOMILLA = { "API": {"NESTING_DEPTH": 10} }
+    """
+
+    def __init__(self, *args, **kwargs):
+        self._depth = kwargs.pop("depth", None)
+        return super().__init__(*args, **kwargs)
+
+    def build_nested_field(self, field_name, relation_info, nested_depth):
+        return self.build_relational_field(field_name, relation_info, nested_depth)
+
+    def build_relational_field(
+        self, field_name, relation_info, nested_depth=settings.API_NESTING_DEPTH + 1
+    ):
+        nested_depth = nested_depth if self._depth is None else self._depth
+        field_class, field_kwargs = super().build_relational_field(
+            field_name, relation_info
+        )
+        if (
+            field_class is RelatedField and nested_depth > 1
+        ):  # stop recursion one step before the jump :P
+            field_kwargs["serializer"] = build_standard_model_serializer(
+                relation_info[1], nested_depth - 1
+            )
+        return field_class, field_kwargs

camomilla/serializers/mixins/optimize.py

@@ -0,0 +1,91 @@
+from rest_framework.utils import model_meta
+
+
+class Optimizations:
+    only = set()
+    select_related = set()
+    prefetch_related = set()
+
+    def __init__(self):
+        self.only = set()
+        self.select_related = set()
+        self.prefetch_related = set()
+
+    def __str__(self):
+        return f"Optimizations(only={self.only}, select_related={self.select_related}, prefetch_related={self.prefetch_related})"
+
+
+def recursive_extract_optimizations(fields, info, max_depth=100) -> Optimizations:
+    optimizations = Optimizations()
+    if max_depth == 0:
+        return optimizations
+    for field in fields:
+        if "__" in field and field not in info.fields:
+            field_part_1, field_part_2 = field.split("__", 1)
+            if field_part_1 in info.relations:
+                field_info = info.relations[field_part_1]
+                nested_info = model_meta.get_field_info(field_info.related_model)
+                if field_info.to_many:
+                    optimizations.prefetch_related.add(field_part_1)
+                    optimizations.only.add(field_part_1)
+                else:
+                    optimizations.select_related.add(field_part_1)
+                    optimizations.only.add(field_part_1)
+                nested_optimizations = recursive_extract_optimizations(
+                    [field_part_2], nested_info, max_depth - 1
+                )
+
+                for nested_field in nested_optimizations.only:
+                    optimizations.only.add(f"{field_part_1}__{nested_field}")
+                for nested_field in nested_optimizations.select_related:
+                    optimizations.select_related.add(f"{field_part_1}__{nested_field}")
+                for nested_field in nested_optimizations.prefetch_related:
+                    optimizations.prefetch_related.add(
+                        f"{field_part_1}__{nested_field}"
+                    )
+        else:
+            if field in info.relations:
+                if info.relations[field].to_many:
+                    optimizations.prefetch_related.add(field)
+                else:
+                    optimizations.select_related.add(field)
+                optimizations.only.add(field)
+            elif field in info.fields:
+                optimizations.only.add(field)
+    return optimizations
+
+
+class SetupEagerLoadingMixin:
+    """
+    This mixin allows to use the setup_eager_loading method to optimize the queries.
+    """
+
+    @classmethod
+    def optimize_qs(cls, queryset, context=None):
+        if hasattr(cls, "setup_eager_loading"):
+            queryset = cls.setup_eager_loading(queryset, context=context)
+        return cls.auto_optimize_queryset(queryset, context=context)
+
+    @classmethod
+    def auto_optimize_queryset(cls, queryset, context=None):
+        request = context.get("request", None)
+        if request and request.method == "GET":
+            serializer_fields = cls(context=context).fields.keys()
+            filtered_fields = set()
+            for field in request.query_params.get("fields", "").split(","):
+                filtered_fields.add(field)
+            if len(filtered_fields) == 0:
+                filtered_fields = serializer_fields
+            model = getattr(cls.Meta, "model", None)
+            if not model:
+                return queryset
+            optimizations = recursive_extract_optimizations(
+                filtered_fields, model_meta.get_field_info(model)
+            )
+            if len(optimizations.only) > 0:
+                queryset = queryset.only(*optimizations.only)
+            if len(optimizations.select_related) > 0:
+                queryset = queryset.select_related(*optimizations.select_related)
+            if len(optimizations.prefetch_related) > 0:
+                queryset = queryset.prefetch_related(*optimizations.prefetch_related)
+        return queryset

camomilla/serializers/mixins/ordering.py

@@ -0,0 +1,34 @@
+from django.db.models.aggregates import Max
+from django.db.models.functions import Coalesce
+from camomilla.fields import ORDERING_ACCEPTED_FIELDS
+
+
+class OrderingMixin:
+    """
+    This mixin allows to set the default value of an ordering field to the max value + 1.
+    """
+
+    def get_max_order(self, order_field):
+        return self.Meta.model.objects.aggregate(
+            max_order=Coalesce(Max(order_field), 0)
+        )["max_order"]
+
+    def _get_ordering_field_name(self):
+        try:
+            field_name = self.Meta.model._meta.ordering[0]
+            if field_name[0] == "-":
+                field_name = field_name[1:]
+            return field_name
+        except (AttributeError, IndexError):
+            return None
+
+    def build_standard_field(self, field_name, model_field):
+        field_class, field_kwargs = super().build_standard_field(
+            field_name, model_field
+        )
+        if (
+            isinstance(model_field, ORDERING_ACCEPTED_FIELDS)
+            and field_name == self._get_ordering_field_name()
+        ):
+            field_kwargs["default"] = self.get_max_order(field_name) + 1
+        return field_class, field_kwargs

camomilla/serializers/mixins/page.py

@@ -0,0 +1,58 @@
+from rest_framework import serializers
+from camomilla.models import UrlNode
+from camomilla.serializers.validators import UniquePermalinkValidator
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from camomilla.models.page import AbstractPage
+
+
+class AbstractPageMixin(serializers.ModelSerializer):
+    """
+    This mixin is needed to serialize AbstractPage models.
+    It provides permalink validation and some extra fields serialization.
+
+    Use it as a base class for your serializer if you need to serialize custom AbstractPage models.
+    """
+
+    breadcrumbs = serializers.SerializerMethodField()
+    routerlink = serializers.CharField(read_only=True)
+    template_file = serializers.SerializerMethodField()
+
+    def get_template_file(self, instance: "AbstractPage"):
+        return instance.get_template_path()
+
+    def get_breadcrumbs(self, instance: "AbstractPage"):
+        return instance.breadcrumbs
+
+    @property
+    def translation_fields(self):
+        return super().translation_fields + ["permalink"]
+
+    def get_default_field_names(self, *args):
+        from camomilla.serializers.mixins.translation import RemoveTranslationsMixin
+
+        default_fields = super().get_default_field_names(*args)
+        filtered_fields = getattr(self, "filtered_fields", [])
+        if len(filtered_fields) > 0:
+            return filtered_fields
+        if RemoveTranslationsMixin in self.__class__.__bases__:  # noqa: E501
+            return default_fields
+        return list(
+            set(
+                [f for f in default_fields if f != "url_node"]
+                + UrlNode.LANG_PERMALINK_FIELDS
+                + ["permalink"]
+            )
+        )
+
+    def build_field(self, field_name, info, model_class, nested_depth):
+        if field_name in UrlNode.LANG_PERMALINK_FIELDS + ["permalink"]:
+            return serializers.CharField, {
+                "required": False,
+                "allow_blank": True,
+            }
+        return super().build_field(field_name, info, model_class, nested_depth)
+
+    def get_validators(self):
+        return super().get_validators() + [UniquePermalinkValidator()]