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

{django_camomilla_cms-6.0.0b14.dist-info → django_camomilla_cms-6.0.0b15.dist-info}/RECORD

@@ -1,35 +1,35 @@
-camomilla/__init__.py,sha256=QPq2GvO5-zT08-jIOFOjDeg33wtHP-Q3zFfpvPWr-YM,251
+camomilla/__init__.py,sha256=NkhtGSnemCX19_YBz80aKvqoqwSnTGEtwPHHnB-JjcI,251
 camomilla/apps.py,sha256=eUwb9ynyiRAc5OXgt7ZsAdhsCOnPCpNdIFYMheNeN-o,532
 camomilla/authentication.py,sha256=jz6tQT4PPEu-_JLox1LZrOy7EiWBb9MWaObK63MJGus,855
 camomilla/context_processors.py,sha256=cGowjDZ-oDGYn1j2Pj5QDGCqnzXAOdOwp5dmzin_FTc,165
 camomilla/defaults.py,sha256=VNQ_sbxu09AyFGNpUUYypIAyhlBhEORD36BBNj7e73I,1220
-camomilla/dynamic_pages_urls.py,sha256=HBI8gCe0Vd9mE74QrIVP57K4ThWopEW4r7jZnFHulTk,1008
+camomilla/dynamic_pages_urls.py,sha256=14H47KlSxmINoJyrsul0KR7Qvk6-1uoXrD1ReV_W4h8,1056
 camomilla/exceptions.py,sha256=gLniAsK_pmsNNKGMv5Z384LXVbM8oeHcOwz4F91u1LY,111
 camomilla/model_api.py,sha256=VC3tNQucS3-KVtdZNWkkbkJn8vtl_cBKYTcC3QU6PpU,2253
 camomilla/parsers.py,sha256=fL8XGCGPxJIZNZkPdGtnPSbDP-6-yzGOCVMuLPjkx9Y,1975
 camomilla/permissions.py,sha256=9NlBO4JMmg36vXCUjPNyq6uZxhkdrnXyIbJVLtWhGWE,1813
-camomilla/settings.py,sha256=Xxs6_fcx-0b-5yKZL7XqYwan48dxIzQmm2lxuijvld0,3428
+camomilla/settings.py,sha256=GDJXDcEmyobGrP4MmEH3MAt1KBK74gXmmRR8kFuJzp0,3306
 camomilla/sitemap.py,sha256=U2t5TwhB_-sEscmQZ69PZ5st3bIap8NRxzWEvCgB130,786
-camomilla/translation.py,sha256=IDoC48xhH49lFAbOq19kOskgjECv4kRCm7bEI80jOL4,1260
+camomilla/translation.py,sha256=-Y0Toy1D__wxMovipWVIuNx3TrfhDGffrduWYFUmYA4,1269
 camomilla/urls.py,sha256=YFUYcPuvnNSTnfJa_JByRWAPLgc4_R4LgqCMrmkbFpE,2217
 camomilla/contrib/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 camomilla/contrib/modeltranslation/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 camomilla/contrib/modeltranslation/hvad_migration.py,sha256=UanLVSlYYd_ykMC4STtYkkUMJqlFQQYhbWkoV47alM0,5403
 camomilla/contrib/rest_framework/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 camomilla/contrib/rest_framework/serializer.py,sha256=G6SKes-8RkJKDupCNN0B2B1BQuYqS0y820oGYotxPcY,5924
-camomilla/fields/__init__.py,sha256=VTCKK0PsJxpcgWrcqPYtWaSFhOOO2ZL56UIdla2IxF8,400
+camomilla/fields/__init__.py,sha256=gKrJwHvUA3q_wu-OVV0hrRZmFkT4znMHrmZtpriDumw,323
 camomilla/fields/json.py,sha256=tWEDn6kwTP6pNB53djxuVPu2d57m9cIDc4ccCEfUbDQ,1938
 camomilla/management/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 camomilla/management/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 camomilla/management/commands/regenerate_thumbnails.py,sha256=pKToASR8p8TJezGpFfuylsAHtriNueJ7xqJJxq55adY,496
 camomilla/managers/__init__.py,sha256=Zwp28E1RKafIl0FqcUi1YNHxF19IsMIvhlhS-Njg9Mw,60
-camomilla/managers/pages.py,sha256=6L35RPzfJbEntjWfEzw0b9ruhOwoVaITUD-RyxuK5yc,1857
+camomilla/managers/pages.py,sha256=8SXd0iUt2UA59lEn9DzJC41SkeU7Vc_tFe9sJhvfyww,1144
 camomilla/models/__init__.py,sha256=y7Q34AGhQ1weJUKWb6XjiyUbwRnJeylOBGMErU0wqYg,147
 camomilla/models/article.py,sha256=LgkZgRsubtDV6NwBz8E2bIgKD6H3I-1QLAxEan5TYYs,1139
 camomilla/models/content.py,sha256=mIgtifb_WMIt58we5u6qWZemHvuDN1zZaBeCyzHL78A,956
 camomilla/models/media.py,sha256=7TD_0nhNoi8P-Gmsr0Kag4eGaxMXuTfQOFl53Mb03cQ,6854
-camomilla/models/menu.py,sha256=rCq0MfHLGM7-7fDVk--AixQZb6_C1gkWMWffKs6QnK4,2841
-camomilla/models/page.py,sha256=X4Mo4cTbAYyWlpVFtjRjyvI_wE2-zcBU1MR8mm26NQI,15671
+camomilla/models/menu.py,sha256=1eUOjBTZQklPgHXrQTpPsRKjT4QNFSoQ8diUVNRymfc,3589
+camomilla/models/page.py,sha256=O4EGWjzk4cHGzmtkJr2nSWG51qLAlqt5B9fkoyEatrs,17287
 camomilla/models/mixins/__init__.py,sha256=c2NixqvrIX4E9WGRqQbylXlqBWDXEqN9mzs_dpB0hFQ,1248
 camomilla/openapi/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 camomilla/openapi/schema.py,sha256=kYNtIKnLx4SIj893umIE6u-q3HH9hYH9O4zdZCSOe7U,2100
@@ -41,21 +41,16 @@ camomilla/serializers/menu.py,sha256=TdoyXs40PqxNevnRbBbYOOX9rUv9zQGiHFNduspaZnw
 camomilla/serializers/page.py,sha256=NNjEypVYu_9iKqdHV_-61ea37gxiHlDP5gsloV_i6yg,1834
 camomilla/serializers/user.py,sha256=CzrHiVRvYYWNE4eNpCNKtJB7DjVqHHwIcP4NUBXMHSo,3706
 camomilla/serializers/utils.py,sha256=sE6Fe8vgGuEWYTox7_ATC6zwcUZ7t2EqkemuP5tWp00,1001
-camomilla/serializers/validators.py,sha256=QtlmGyJiKaKyMBqBZ1W2VAjCoLi1vhPUnLOo7DvZpsM,1775
+camomilla/serializers/validators.py,sha256=EX-EFg6afFr8viPKq-LHeEtRAKPVtO4kIlEymY1j2HA,2043
 camomilla/serializers/base/__init__.py,sha256=HSDBPXQ3ldX0pixDbNLna5LSUQ_TfFZ4JWKRm6OpWcU,793
-camomilla/serializers/fields/__init__.py,sha256=P3WFxrNGNBKTYqXi-CA4e5HLOYWo6Yt6izQcwyUhBPU,642
+camomilla/serializers/fields/__init__.py,sha256=T_ONowldBTPfgbwFmoefY1r3TQiB2sbWQPpFvBSnzqE,681
 camomilla/serializers/fields/file.py,sha256=yjKMho2ti9TIAzo6nwyLnNPJ6GVUumL2wxhegvYqI2o,800
-camomilla/serializers/fields/json.py,sha256=KHSxklGr1dLS6yd8nkVo_S7BiJKVMJ8Iv8vXyR8aCVQ,1870
+camomilla/serializers/fields/json.py,sha256=LzSVjVXjRR5mbZ94tVq-wdX3_B5yzv0h7pPEFZVOL1s,1874
 camomilla/serializers/fields/related.py,sha256=Lofgk582KAb0EIK20jtds538O_y-yRHo644ND_VlXrM,4747
-camomilla/serializers/mixins/__init__.py,sha256=lvPCwDNZtQwdewIQUVI-D9f2UuwxjVs29TNTozcahzs,7377
+camomilla/serializers/mixins/__init__.py,sha256=prhA91hMrLezm-mIYc3yHJXefM346okZQ8OS8IxxqhI,7114
 camomilla/storages/__init__.py,sha256=ytGgX59Ar8vFfYz7eV8z-j5yO_5FqxdZM25iyLnJuSA,131
 camomilla/storages/optimize.py,sha256=YKbhSbTaWNbTFIRTRWdilD3w8b_LjMLOmE6yk2lrbo4,2745
 camomilla/storages/overwrite.py,sha256=CO_zSZxr321eohYFuzPjDMK7WMFnvvwlIigIPabU_eE,343
-camomilla/structured/__init__.py,sha256=mX0mruLSrovzKlIk4WLBw-eFOuxbFVh9ASA5lR5OVF4,4338
-camomilla/structured/cache.py,sha256=Fi6F3oQzq8XcbGglKes-U1SskFzTnvowZY82S5eeOCU,7845
-camomilla/structured/fields.py,sha256=INjb6G67k4nmeGQibU0WBHUUpRJQbYmcX74sWvBLMUs,5237
-camomilla/structured/models.py,sha256=us03rOU2VtdhH4MMHIGkb11Wr6ItxPmB7ZUL1QepWmg,1790
-camomilla/structured/utils.py,sha256=nJlRFuYkBOgqxMWEpCM5qGu2m7j9TCBHB8SMmZPbCKM,3447
 camomilla/templates/admin/camomilla/page/change_form.html,sha256=ig7rRUtylDZMINBQuVPpZLmeB4sOTV_VtqnTgzAyxEo,251
 camomilla/templates/defaults/base.html,sha256=pklt7Pif3g9d7gwgRxCQj7gniJaHD14ZqZID_xIlC0A,6638
 camomilla/templates/defaults/articles/default.html,sha256=1f89jBvNtTa1mPAbC91yy8CzeAjTWO3hhQsTuQW5OKg,239
@@ -69,8 +64,8 @@ camomilla/templates_context/rendering.py,sha256=GfTR45_gC7WT7zTKPVXkBDwe22uF63A-
 camomilla/templatetags/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 camomilla/templatetags/camomilla_filters.py,sha256=35x0-cWrRHeLhqypSLlJzEFY_fQDcRHiwZQpFgIsspE,692
 camomilla/templatetags/menus.py,sha256=pLFeJ1UAm3flsU9TNo2iQk4otSwZuJPr86Nf408dZ-8,862
-camomilla/theme/__init__.py,sha256=UVNasDCHfmeetQsfJsCQ1TN3YgarCjDERgSZX0OwKT8,30
-camomilla/theme/admin.py,sha256=R3QAfqaF9mhzwfyb_m2_hqTQ2hBcNvQts1MWUX4dUUM,2462
+camomilla/theme/__init__.py,sha256=0q-mhm8VNgYidC6IDdFUN4eArRIb2Wf1Wf1vymdu_Fg,30
+camomilla/theme/admin.py,sha256=7TgNXOfIy4awtV-KkGEKsmai94qhBiykB0uJWwTZy8U,2461
 camomilla/theme/apps.py,sha256=ecqG8ntWdOighYOEHQOMVQpa5g_1WEzzpaaGjnOi9uA,1195
 camomilla/theme/static/admin/css/responsive.css,sha256=yGq6qXrr8xEVsXTnprIBgkX-sMGZrNf0Kkh-xDxf6yE,157
 camomilla/theme/static/admin/img/favicon.ico,sha256=qpKv_2MaGILvyihnD1Vq9Yk-ZXGkxWTW26ciMeBFMYU,15406
@@ -81,6 +76,7 @@ camomilla/utils/__init__.py,sha256=Ui7nzSh45UMMFtCGF1xFHKyJMNWflG_Nx72HAJHJHFM,1
 camomilla/utils/getters.py,sha256=6j18grFAZ8BC70SriycFDTQFxTnudGn0uKGA83_Rclk,798
 camomilla/utils/normalization.py,sha256=RDCZtjwpEEwjvfUjQl2bEWFKw7NxTzkXco72VeO2M9w,255
 camomilla/utils/seo.py,sha256=8p_a_TGgohenpJb094tT4mMxbn2xzW0qDILuTnjNocM,3324
+camomilla/utils/setters.py,sha256=LV57SM65rL1_ZQkVzk9al_Q13lndVywXLkqgfIvgS0Y,915
 camomilla/utils/templates.py,sha256=Lv4-5019cnM30HmdZnYWiU5gxry-eFZVAhwOofGQRDs,598
 camomilla/utils/translation.py,sha256=HG70ki9MTBVTdAYgi6lqqFQtNm30VTvGSYepXpyb3_Y,2477
 camomilla/views/__init__.py,sha256=94QuOnnbfMMb17mruO2ydUt286-8zBmDxEPWrJv5Wog,178
@@ -89,7 +85,7 @@ camomilla/views/contents.py,sha256=JxvnmgeK8JEmCMLzVG8pVq2DwvmjXtgnIdsDnn74tA4,1
 camomilla/views/decorators.py,sha256=hR--nTGQn2mMKDrWn-0Ildzbsvp11OfoWAtedKEzmiA,982
 camomilla/views/languages.py,sha256=Rt_X7s3dbDBv4dxsQ9fnav_u0TAzzo8fGKBBx3esDsg,441
 camomilla/views/medias.py,sha256=S4Ak4JI6XCSu3BCZx8KOotX7TBfrIU82GPXgyP3KcZA,3001
-camomilla/views/menus.py,sha256=wKxBTaLW-YEJrE0RIoi_1oUpymskbBTqQvJh1ZioN5c,3382
+camomilla/views/menus.py,sha256=o2W6oQNiB__jHw5rbGaitEENxuRk1_mRoLCKyb30qPk,3352
 camomilla/views/pages.py,sha256=KrBsKT0Z-rkBha8K3P6fVDt4vArQBxsc9rZ28j8XW9w,994
 camomilla/views/tags.py,sha256=XcYRlcBFSPPY32lt7POb6fWPJL_8HsTo5JcHcAOiOKw,479
 camomilla/views/users.py,sha256=_fvsKOEtep4SJLvMva2_q-HdLQT_1KlFNt4wcl3xCJk,3130
@@ -102,8 +98,8 @@ tests/test_api.py,sha256=DTXtvNNRwvZvxGKi6LyCzhpyU1OzPWGSbBUfRL3-Nck,2101
 tests/test_camomilla_filters.py,sha256=_W9CcwsEyewMBvnNYKk4CVqrkXxRYejle3mjiBS7hqk,1848
 tests/test_models.py,sha256=WJs8lxWZWn1l7X3a_QFVc8fF5LHTsI8bc3uhQe6-o-Q,684
 tests/test_utils.py,sha256=0tdEDBaBkyjAXpbqP0SpFcfgO56MV2TWZmk9xpjR7J0,3613
-django_camomilla_cms-6.0.0b14.dist-info/LICENSE,sha256=kVS7zDrNkav2hLLXbOJwVdonY2ToApTK3khyJagGQoQ,1063
-django_camomilla_cms-6.0.0b14.dist-info/METADATA,sha256=Epgi0FSONdA7m9MZnYCTufligreZhHcNT3OD0jOgKo4,2410
-django_camomilla_cms-6.0.0b14.dist-info/WHEEL,sha256=DZajD4pwLWue70CAfc7YaxT1wLUciNBvN_TTcvXpltE,110
-django_camomilla_cms-6.0.0b14.dist-info/top_level.txt,sha256=G9VIGBmMMqC7JEckoTgXKmC6T2BR75QRkqRnngw1_lo,16
-django_camomilla_cms-6.0.0b14.dist-info/RECORD,,
+django_camomilla_cms-6.0.0b15.dist-info/LICENSE,sha256=kVS7zDrNkav2hLLXbOJwVdonY2ToApTK3khyJagGQoQ,1063
+django_camomilla_cms-6.0.0b15.dist-info/METADATA,sha256=_k6mnVPePkm5V8-NNr4LKbft-k1_vte_CM6lEgTB32U,2390
+django_camomilla_cms-6.0.0b15.dist-info/WHEEL,sha256=TJ49d73sNs10F0aze1W_bTW2P_X7-F4YXOlBqoqA-jY,109
+django_camomilla_cms-6.0.0b15.dist-info/top_level.txt,sha256=G9VIGBmMMqC7JEckoTgXKmC6T2BR75QRkqRnngw1_lo,16
+django_camomilla_cms-6.0.0b15.dist-info/RECORD,,

{django_camomilla_cms-6.0.0b14.dist-info → django_camomilla_cms-6.0.0b15.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.43.0)
+Generator: setuptools (75.2.0)
 Root-Is-Purelib: true
 Tag: py2-none-any
 Tag: py3-none-any

camomilla/structured/__init__.py

@@ -1,125 +0,0 @@
-import json
-from typing import Any, Union, Type, TYPE_CHECKING, List
-
-from django.db.models import JSONField
-from django.db.models.query_utils import DeferredAttribute
-from django_jsonform.models.fields import JSONFormField
-from pydantic import (
-    TypeAdapter,
-    ValidationInfo,
-    ValidatorFunctionWrapHandler,
-    WrapValidator,
-)
-
-from .fields import *
-from .models import *
-
-if TYPE_CHECKING:
-    from pydantic import BaseModel
-    from pydantic.fields import Field
-    from typing_extensions import Annotated
-
-
-class StructuredJSONFormField(JSONFormField):
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        self.encoder = kwargs.get("encoder", None)
-        self.decoder = kwargs.get("decoder", None)
-
-    def prepare_value(self, value):
-        if isinstance(value, list):
-            return json.dumps([v.model_dump() for v in value])
-        return value.model_dump_json()
-
-
-class StructuredDescriptior(DeferredAttribute):
-    field: "StructuredJSONField"
-
-    def __set__(self, instance, value):
-        # TODO: check if it's better to validate here or in __get__ function (performance reasons)
-        # if not self.field.check_type(value):
-        #     value = self.field.schema.validate_python(value)
-        instance.__dict__[self.field.attname] = value
-
-    def __get__(self, instance, cls=None):
-        value = super().__get__(instance, cls)
-        if not self.field.check_type(value):
-            return self.field.schema.validate_python(value)
-        return value
-
-
-class StructuredJSONField(JSONField):
-    # TODO: share cache in querysets of models having this same field
-    # TODO: write queries for prefetch related for models inside the field
-
-    descriptor_class = StructuredDescriptior
-
-    @property
-    def list_data_validator(self):
-        def list_data_validator(
-            value: Any, handler: ValidatorFunctionWrapHandler, info: ValidationInfo
-        ) -> Any:
-            from camomilla.structured.cache import CacheBuilder
-
-            cache = CacheBuilder.from_model(self.orig_schema)
-            if info.mode == "json" and isinstance(value, str):
-                return self.schema.validate_python(
-                    cache.inject_cache(json.loads(value))
-                )
-            return handler(cache.inject_cache(value))
-
-        return list_data_validator
-
-    def __init__(self, schema: Type[BaseModel], *args: Any, **kwargs: Any) -> None:
-        self.orig_schema = schema
-        self.schema = schema
-        default = kwargs.get("default", dict)
-        self.file_handler = kwargs.pop("file_handler", "")
-        self.many = kwargs.pop(
-            "many", isinstance(default() if callable(default) else default, list)
-        )
-        if self.many:
-            self.schema = TypeAdapter(
-                Annotated[
-                    List[self.schema],
-                    Field(default_factory=list),
-                    WrapValidator(self.list_data_validator),
-                ]
-            )
-        return super().__init__(*args, **kwargs)
-
-    def check_type(self, value: Any):
-        if self.many:
-            return isinstance(value, list) and all(
-                isinstance(v, self.orig_schema) for v in value
-            )
-        return isinstance(value, self.orig_schema)
-
-    def get_prep_value(
-        self, value: Union[List[Type[BaseModel]], Type[BaseModel]]
-    ) -> str:
-        if isinstance(value, list) and self.many:
-            return self.schema.dump_json(value, exclude_unset=True).decode()
-        return value.model_dump_json(exclude_unset=True)
-
-    def from_db_value(self, value: Any, expression: Any, connection: Any) -> Any:
-        data = super().from_db_value(value, expression, connection)
-        if isinstance(data, str):
-            return json.loads(data)
-        return data
-
-    def deconstruct(self):
-        name, path, args, kwargs = super().deconstruct()
-        kwargs["schema"] = self.orig_schema
-        return name, path, args, kwargs
-
-    def formfield(self, **kwargs):
-        return super().formfield(
-            **{
-                "form_class": StructuredJSONFormField,
-                "schema": self.schema.json_schema(),
-                "model_name": self.model.__name__,
-                "file_handler": self.file_handler,
-                **kwargs,
-            }
-        )

camomilla/structured/cache.py

@@ -1,202 +0,0 @@
-from collections import defaultdict
-from inspect import isclass
-from typing import Any, Dict, Sequence, Type, Iterable, Union
-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 django.db.models import Model as DjangoModel
-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 Cache(dict):
-    pass
-
-
-class ValueWithCache:
-    def __init__(self, cache, model, value) -> None:
-        self.cache: Cache = cache
-        self.value: Union[Iterable[Union[str, int]], str, int] = value
-        self.model: Type[DjangoModel] = model
-
-    def retrieve(self):
-        cache = self.cache.get(self.model)
-        if hasattr(self.value, '__iter__'):
-            qs = self.model.objects.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 = 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,150 +0,0 @@
-from typing import Any, Callable, Dict, Generic, TypeVar, Union
-
-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
-
-
-T = TypeVar("T", bound=django_models.Model)
-
-
-class ForeignKey(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(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])
-
-        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),
-            ]
-        )
-
-        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 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 model_class._default_manager.filter(pk__in=values).order_by(
-                preserved
-            )
-
-        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
-            ),
-        )

camomilla/structured/models.py

@@ -1,47 +0,0 @@
-from inspect import isclass
-from typing import Any, Dict, Tuple, get_origin
-
-import pydantic._internal._model_construction
-from django.db.models import Model as DjangoModel
-from pydantic import BaseModel as PyDBaseModel
-from pydantic import Field, model_validator
-from typing_extensions import Annotated
-
-from .fields import ForeignKey, QuerySet
-from .utils import get_type, map_method_aliases
-
-
-class BaseModelMeta(pydantic._internal._model_construction.ModelMetaclass):
-    def __new__(
-        mcs, name: str, bases: Tuple[type], namespaces: Dict[str, Any], **kwargs
-    ):
-        annotations: dict = namespaces.get("__annotations__", {})
-        for base in bases:
-            for base_ in base.__mro__:
-                if base_ is PyDBaseModel:
-                    break
-                annotations.update(base_.__annotations__)
-
-        for field in annotations:
-            annotation = annotations[field]
-            origin = get_origin(annotation)
-            if isclass(annotation) and issubclass(annotation, DjangoModel):
-                annotations[field] = ForeignKey[annotation]
-            elif isclass(origin) and issubclass(origin, QuerySet):
-                annotations[field] = Annotated[
-                    annotation,
-                    Field(default_factory=get_type(annotation)._default_manager.none),
-                ]
-        namespaces["__annotations__"] = annotations
-        return map_method_aliases(
-            super().__new__(mcs, name, bases, namespaces, **kwargs)
-        )
-
-
-class BaseModel(PyDBaseModel, metaclass=BaseModelMeta):
-    @model_validator(mode="before")
-    @classmethod
-    def build_cache(cls, data: Any) -> Any:
-        from camomilla.structured.cache import CacheBuilder
-
-        return CacheBuilder.from_model(cls).inject_cache(data)