django-camomilla-cms 6.0.0b2__py2.py3-none-any.whl → 6.0.0b4__py2.py3-none-any.whl

camomilla/structured/cache.py

@@ -0,0 +1,193 @@
+from collections import defaultdict
+from inspect import isclass
+from typing import Any, Dict, Sequence
+from typing_extensions import get_args, get_origin
+from camomilla.settings import STRUCTURED_FIELD_CACHE_ENABLED
+from camomilla.structured.fields import ForeignKey, QuerySet
+from camomilla.structured.models import BaseModel
+from camomilla.structured.utils import _LazyType, get_type, pointed_setter
+
+from camomilla.utils.getters import pointed_getter
+
+# TODO:
+# ::: Actually this is a first draft. 
+# The system should be more type safe. 
+# It should handle initialization made with model instance not only dicts
+# Neet to check if there are problems with different formats for pks (model instaces or string or dicts)
+
+
+class ValueWithCache:
+    def __init__(self, cache, model, value) -> None:
+        self.cache = cache
+        self.value = value
+        self.model = model
+
+    def retrieve(self):
+        cache = self.cache.get(self.model)
+        if isinstance(self.value, Sequence):
+            qs = self.model._default_manager.filter(pk__in=self.value)
+            setattr(
+                qs,
+                "_result_cache",
+                [cache[i] for i in self.value if i in cache] if cache else [],
+            )
+            return qs
+        else:
+            val = cache.get(self.value, None)
+            if val is None:
+                return self.model._default_manager.get(pk=self.value)
+            else:
+                return val
+
+
+class RelInfo:
+    FKField: str = "fk"
+    QSField: str = "qs"
+    RIField: str = "rel"
+    RLField: str = "rel_l"
+
+    def __init__(self, model, type, field) -> None:
+        self.model = model
+        self.type = type
+        self.field = field
+
+
+class CacheBuilder:
+    def __init__(self, related_fields: Dict[str, RelInfo]) -> None:
+        self.__related_fields__ = related_fields
+
+    @classmethod
+    def from_model(cls, model: BaseModel) -> 'CacheBuilder':
+        return cls(related_fields=cls.inspect_related_fields(model))
+
+    @classmethod
+    def inspect_related_fields(cls, model: type[BaseModel]) -> Dict[str, RelInfo]:
+        related = {}
+        for field_name, field in model.model_fields.items():
+            annotation = field.annotation
+            origin = get_origin(annotation)
+            args = get_args(annotation)
+
+            if isclass(origin) and issubclass(origin, ForeignKey):
+                related[field_name] = RelInfo(
+                    get_type(annotation), RelInfo.FKField, field
+                )
+            elif isclass(origin) and issubclass(origin, QuerySet):
+                related[field_name] = RelInfo(
+                    get_type(annotation), RelInfo.QSField, field
+                )
+
+            elif isclass(origin) and issubclass(origin, Sequence):
+                lazy_types = [
+                    _LazyType(arg).evaluate(model)
+                    for arg in args
+                    if isinstance(arg, str)
+                ]
+                subclass = next(
+                    (
+                        c
+                        for c in list(args) + lazy_types
+                        if isclass(c) and issubclass(c, BaseModel)
+                    ),
+                    None,
+                )
+                if isclass(subclass) and issubclass(subclass, BaseModel):
+                    related[field_name] = RelInfo(subclass, RelInfo.RLField, field)
+
+            elif isclass(annotation) and issubclass(annotation, BaseModel):
+                related[field_name] = RelInfo(annotation, RelInfo.RIField, field)
+        return related
+    
+    def get_all_fk_data(self, data):
+        if isinstance(data, Sequence):
+            fk_data = defaultdict(list)
+            for index in range(len(data)):
+                child_fk_data = self.get_all_fk_data(data[index])
+                for model, touples in child_fk_data.items():
+                    fk_data[model] += [(f"{index}.{t[0]}", t[1]) for t in touples]
+            return fk_data
+        return self.get_fk_data(data)
+
+    def get_fk_data(self, data):
+        fk_data = defaultdict(list)
+        if not data:
+            return fk_data
+        for field_name, info in self.__related_fields__.items():
+            if info.type == RelInfo.FKField:
+                value = pointed_getter(data, field_name, None)
+                if value:
+                    if isinstance(value, ValueWithCache): # needed to break recursive cache builds
+                        fk_data = {}
+                        break
+                    fk_data[info.model].append(
+                        (
+                            field_name,
+                            pointed_getter(value, info.model._meta.pk.attname, value),
+                        )
+                    )
+            elif info.type == RelInfo.QSField:
+                value = pointed_getter(data, field_name, [])
+                if isinstance(value, list):
+                    if any(True for v in value if isinstance(v, ValueWithCache)): # needed to break recursive cache builds
+                        fk_data = {}
+                        break
+                    fk_data[info.model].append(
+                        (
+                            field_name,
+                            [
+                                pointed_getter(i, info.model._meta.pk.attname, i)
+                                for i in value
+                                if i
+                            ],
+                        )
+                    )
+
+            elif info.type == RelInfo.RLField:
+                values = pointed_getter(data, field_name, [])
+                if isinstance(values, list):
+                    for index in range(len(values)):
+                        for model, touples in (
+                            self.from_model(info.model)
+                            .get_all_fk_data(values[index])
+                            .items()
+                        ):
+                            fk_data[model] += [
+                                (f"{field_name}.{index}.{t[0]}", t[1]) for t in touples
+                            ]
+            elif info.type == RelInfo.RIField:
+                value = pointed_getter(data, field_name, None)
+                child_fk_data = self.from_model(info.model).get_all_fk_data(value)
+                for model, touples in child_fk_data.items():
+                    fk_data[model] += [(f"{field_name}.{t[0]}", t[1]) for t in touples]
+        return fk_data
+
+    def inject_cache(self, data: Any) -> Any:
+        if not STRUCTURED_FIELD_CACHE_ENABLED:
+            return data
+        fk_data = self.get_all_fk_data(data)
+        plainset = defaultdict(set)
+        for model, touples in fk_data.items():
+            for t in touples:
+                if isinstance(t[1], Sequence):
+                    plainset[model].update(t[1])
+                else:
+                    plainset[model].add(t[1])
+        cache = {}
+        for model, values in plainset.items():
+            models = []
+            pks = []
+            for value in values:
+                if isinstance(value, model):
+                    models.append(value)
+                else:
+                    pks.append(value)
+            models_pks = [m.pk for m in models]
+            pks = [pk for pk in pks if pk not in models_pks]
+            if len(pks):
+                models += list(model.objects.filter(pk__in=pks))
+            cache[model] = {obj.pk: obj for obj in models}
+
+        for model, touples in fk_data.items():
+            for t in touples:
+                pointed_setter(data, t[0], ValueWithCache(cache, model, t[1]))
+        return data

camomilla/structured/fields.py

@@ -1,292 +1,149 @@
-import datetime
-import decimal
+from typing import Any, Callable, Dict, Generic, TypeVar, Union
 
-from django.core import validators
-from django.db import models
-from django.utils.dateparse import parse_duration
-from django.utils.duration import duration_string
-from jsonmodels import fields
-from jsonmodels.validators import ValidationError
-from camomilla.utils.getters import pointed_getter
+from django.db import models as django_models
+from pydantic import SerializationInfo
+from pydantic_core import core_schema as cs
 
+from .utils import get_type
+from devtools import debug
 
-__all__ = [
-    "CharField",
-    "DecimalField",
-    "IntegerField",
-    "FloatField",
-    "BooleanField",
-    "DateTimeField",
-    "DateField",
-    "TimeField",
-    "DurationField",
-    "EmailField",
-    "SlugField",
-    "URLField",
-    "ListField",
-    "DictField",
-    "EmbeddedField",
-    "ForeignKey",
-    "ForeignKeyList",
-]
 
+T = TypeVar("T", bound=django_models.Model)
 
-class Field(fields.BaseField):
-    additional_kwargs = {}
-    additional_validators = []
-    __validators = []
-    parent = None
-
-    def __init__(self, *args, **kwargs):
-        for key, value in self.additional_kwargs.items():
-            setattr(self, key, kwargs.pop(key, value))
-        super(Field, self).__init__(*args, **kwargs)
-
-    @property
-    def validators(self):
-        validators = self.__validators
-        for validator in self.additional_validators:
-            if isinstance(validator, dict):
-                validator_class = validator["validator"]
-                args = [
-                    getattr(self, arg)
-                    for arg in validator.get("args", [])
-                    if getattr(self, arg, fields.NotSet) != fields.NotSet
-                ]
-                kwargs = {
-                    key: getattr(self, value)
-                    for key, value in validator.get("kwargs", {}).items()
-                    if getattr(self, value, fields.NotSet) != fields.NotSet
-                }
-                if len(args) or len(kwargs.keys()):
-                    validators.append(validator_class(*args, **kwargs))
-            else:
-                validators.append(validator)
-        return validators
-
-    @validators.setter
-    def validators(self, value):
-        self.__validators = value
-
-    def bind(self, parent):
-        self.parent = parent
-    
-    @classmethod
-    def to_db_transform(cls, data):
-        return data
 
+class ForeignKey(django_models.Model, Generic[T]):
     @classmethod
-    def from_db_transform(cls, data):
-        return data
-
-
-class CharField(fields.StringField, Field):
-    additional_kwargs = {
-        "max_length": fields.NotSet,
-    }
-    additional_validators = [
-        {"validator": validators.MaxLengthValidator, "args": ["max_length"]}
-    ]
-
-
-class DecimalField(fields.StringField, Field):
-    types = (decimal.Decimal, int, float)
-
-    additional_kwargs = {
-        "max_digits": fields.NotSet,
-        "decimal_places": fields.NotSet,
-    }
-    additional_validators = [
-        {
-            "validator": validators.DecimalValidator,
-            "args": ["max_digits", "decimal_places"],
-        }
-    ]
-
-
-class IntegerField(fields.IntField, Field):
-    additional_kwargs = {
-        "min_value": fields.NotSet,
-        "max_value": fields.NotSet,
-    }
-    additional_validators = [
-        {"validator": validators.MinValueValidator, "args": ["min_value"]},
-        {"validator": validators.MaxValueValidator, "args": ["max_value"]},
-    ]
-
-
-class FloatField(IntegerField):
-    types = (float, int)
-
-
-class BooleanField(fields.BoolField, Field):
-    pass
-
-
-class DateTimeField(fields.DateTimeField, Field):
-    pass
-
-
-class DateField(fields.DateField, Field):
-    pass
-
-
-class TimeField(fields.TimeField, Field):
-    pass
-
-
-class DurationField(fields.StringField, Field):
-    types = (datetime.timedelta,)
-
-    def to_struct(self, value):
-        return value and duration_string(value)
-
-    def parse_value(self, value):
-        if value is None:
-            return value
-        if isinstance(value, datetime.timedelta):
-            return value
-        try:
-            parsed = parse_duration(value)
-        except ValueError:
-            pass
-        else:
-            if parsed is not None:
-                return parsed
-
-        raise fields.ValidationError(
-            "“%(value)s” value has an invalid format. It must be in '[DD] [[HH:]MM:]ss[.uuuuuu] format.'".format(
-                value=value
-            )
+    def __get_pydantic_core_schema__(
+        cls, source: Any, handler: Callable[[Any], cs.CoreSchema]
+    ) -> cs.CoreSchema:
+        from camomilla.structured.cache import ValueWithCache
+
+        model_class = get_type(source)
+
+        def validate_from_pk(pk: Union[int, str]) -> model_class:
+            return model_class._default_manager.get(pk=pk)
+
+        int_str_union = cs.union_schema([cs.str_schema(), cs.int_schema()])
+        from_pk_schema = cs.chain_schema(
+            [
+                int_str_union,
+                cs.no_info_plain_validator_function(validate_from_pk),
+            ]
         )
+        pk_attname = model_class._meta.pk.attname
 
+        def validate_from_dict(data: Dict[str, Union[str, int]]) -> model_class:
+            return validate_from_pk(data[pk_attname])
 
-class EmailField(CharField):
-    additional_validators = [validators.validate_email]
-
-
-class SlugField(CharField):
-    additional_validators = [validators.validate_slug]
-
+        from_dict_schema = cs.chain_schema(
+            [
+                cs.typed_dict_schema({pk_attname: cs.typed_dict_field(int_str_union)}),
+                cs.no_info_plain_validator_function(validate_from_dict),
+            ]
+        )
 
-class URLField(CharField):
-    additional_validators = [validators.URLValidator()]
+        from_cache_schema = cs.chain_schema(
+            [
+                cs.is_instance_schema(ValueWithCache),
+                cs.no_info_plain_validator_function(lambda v: v.retrieve()),
+            ]
+        )
+        
+        def serialize_data(instance, info):
+            from camomilla.serializers.utils import build_standard_model_serializer
+            if info.mode == "python":
+                serializer = build_standard_model_serializer(model_class, depth=1)
+                return serializer(instance=instance).data
+            return instance.pk
+
+        return cs.json_or_python_schema(
+            json_schema=cs.union_schema(
+                [from_cache_schema, from_pk_schema, from_dict_schema]
+            ),
+            python_schema=cs.union_schema(
+                [
+                    cs.is_instance_schema(model_class),
+                    from_cache_schema,
+                    from_pk_schema,
+                    from_dict_schema,
+                ]
+            ),
+            serialization=cs.plain_serializer_function_ser_schema(
+                serialize_data, info_arg=True
+            ),
+        )
 
 
-class ListField(fields.ListField, Field):
-    
-    def parse_value(self, values):
-        """Cast value to proper collection."""
-        result = self.get_default_value()
-        if not values:
-            return result
-        if not isinstance(values, list):
-            return values
-        parent = self.parent
-        return [self._cast_value(value, parent) for value in values]
-    
-    def _cast_value(self, value, parent):
-        if isinstance(value, self.items_types):
-            return value
-        else:
-            main_type = self._get_main_type()
-            from camomilla.structured.models import Model
-            if issubclass(main_type, Model):
-                instance = main_type()
-                relations = instance.prepopulate(**value)
-                instance.bind(parent)
-                instance.populate(**relations)
-                return instance
-            return main_type(**value)
-
-    def _get_main_type(self):
-        if len(self.items_types) != 1:
-            raise ValidationError(
-                'Cannot decide which type to choose from "{items_types}".'.format(
-                    items_types=", ".join([t.__name__ for t in self.items_types])
-                )
+class QuerySet(Generic[T]):
+    @classmethod
+    def __get_pydantic_core_schema__(
+        cls, source: Any, handler: Callable[[Any], cs.CoreSchema]
+    ) -> cs.CoreSchema:
+        from camomilla.structured.cache import ValueWithCache
+
+        model_class = get_type(source)
+
+        def validate_from_pk_list(
+            values: list[Union[int, str]]
+        ) -> django_models.QuerySet:
+            preserved = django_models.Case(
+                *[django_models.When(pk=pk, then=pos) for pos, pk in enumerate(values)]
             )
-        return self.items_types[0]
-    
-class DictField(fields.DictField, Field):
-    pass
-
-
-class EmbeddedField(fields.EmbeddedField, Field):
-    def parse_value(self, value):
-        if not isinstance(value, dict):
-            return value
-        embed_instance = self._get_embed_type()()
-        relations = embed_instance.prepopulate(**value)
-        embed_instance.bind(self.parent)
-        embed_instance.populate(**relations)
-        return embed_instance
-
-
-class ForeignKey(Field):
-    types = (models.Model, int, str)
-
-    def __init__(self, to, *args, **kwargs):
-        self.model = to
-        self.queryset = kwargs.pop("queryset", None)
-        super(ForeignKey, self).__init__(*args, **kwargs)
-
-    def get_queryset(self):
-        return self.queryset or self.model.objects.all()
-
-    def to_struct(self, value):
-        return getattr(value, "pk", value)
-
-    def parse_value(self, value):
-        try:
-            if isinstance(value, bool):
-                raise TypeError
-            if isinstance(value, self.model):
-                return value
-            cache = pointed_getter(self, "parent.get_prefetched_data", lambda: None)()
-            if cache is not None:
-                return cache.get(self.model, {}).get(value)
-            return value and self.get_queryset().get(pk=value)
-        except (TypeError, ValueError):
-            raise fields.ValidationError(
-                "Incorrect type. Expected pk value, received {data_type}.".format(
-                    data_type=type(value).__name__
-                )
+            return model_class._default_manager.filter(pk__in=values).order_by(
+                preserved
             )
 
-
-class ForeignKeyList(ListField):
-    types = (list, models.QuerySet)
-
-    def __init__(self, to, *args, **kwargs):
-        self.inner_model = to
-        self.inner_queryset = kwargs.pop("queryset", None)
-        kwargs["items_types"] = to
-        super(ForeignKeyList, self).__init__(*args, **kwargs)
-
-    def parse_value(self, values):
-        result = self.get_default_value()
-        if not values:
-            return result
-        if not isinstance(values, list):
-            return values
-        cache = pointed_getter(self, "parent.get_prefetched_data", lambda: None)()
-        if cache is not None:
-            data = cache.get(self.inner_model)
-            qs = self.get_inner_queryset().filter(pk__in=values)
-            setattr(
-                qs,
-                "_result_cache",
-                [data[i] for i in values if i in data] if data else [],
-            )
-            return qs
-        preserved = models.Case(
-            *[models.When(pk=pk, then=pos) for pos, pk in enumerate(values)]
+        int_str_union = cs.union_schema([cs.str_schema(), cs.int_schema()])
+        from_pk_list_schema = cs.chain_schema(
+            [
+                cs.list_schema(int_str_union),
+                cs.no_info_plain_validator_function(validate_from_pk_list),
+            ]
+        )
+        pk_attname = model_class._meta.pk.attname
+
+        def validate_from_dict(
+            values: list[Dict[str, Union[str, int]]]
+        ) -> django_models.QuerySet:
+            return validate_from_pk_list([data[pk_attname] for data in values])
+
+        from_dict_list_schema = cs.chain_schema(
+            [
+                cs.list_schema(
+                    cs.typed_dict_schema(
+                        {pk_attname: cs.typed_dict_field(int_str_union)}
+                    )
+                ),
+                cs.no_info_plain_validator_function(validate_from_dict),
+            ]
+        )
+        from_cache_schema = cs.chain_schema(
+            [
+                cs.is_instance_schema(ValueWithCache),
+                cs.no_info_plain_validator_function(lambda v: v.retrieve()),
+            ]
+        )
+    
+        def serialize_data(qs: django_models.QuerySet, info: SerializationInfo):
+            from camomilla.serializers.utils import build_standard_model_serializer
+            if info.mode == "python":
+                serializer = build_standard_model_serializer(model_class, depth=1)
+                return serializer(instance=qs, many=True).data
+            return [x.pk for x in qs]
+
+        return cs.json_or_python_schema(
+            json_schema=cs.union_schema(
+                [from_cache_schema, from_pk_list_schema, from_dict_list_schema]
+            ),
+            python_schema=cs.union_schema(
+                [
+                    cs.is_instance_schema(django_models.QuerySet),
+                    from_cache_schema,
+                    from_pk_list_schema,
+                    from_dict_list_schema,
+                ]
+            ),
+            serialization=cs.plain_serializer_function_ser_schema(
+                serialize_data, info_arg=True
+            ),
         )
-        return self.get_inner_queryset().filter(pk__in=values).order_by(preserved)
-
-    def get_inner_queryset(self):
-        return self.inner_queryset or self.inner_model._default_manager.all()
-
-    def to_struct(self, value):
-        return [getattr(v, "pk", v) for v in value]