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

tests/test_utils.py

@@ -13,74 +13,74 @@ from django.utils.translation import activate, get_language
 from requests import RequestException
 
 
-class UtilsTestCase(TestCase):
-    def setUp(self):
-        pass
+# class UtilsTestCase(TestCase):
+#     def setUp(self):
+#         pass
 
-    def test_get_host_url(self):
-        """Our beloved get_host_url utility"""
-        request_factory = RequestFactory()
-        request = request_factory.get("/path")
-        request.META["HTTP_HOST"] = "localhost"
-        host_url = get_host_url(request)
-        self.assertEqual(host_url, "http://localhost")
-        host_url = get_host_url(None)
-        self.assertEqual(host_url, None)
+#     def test_get_host_url(self):
+#         """Our beloved get_host_url utility"""
+#         request_factory = RequestFactory()
+#         request = request_factory.get("/path")
+#         request.META["HTTP_HOST"] = "localhost"
+#         host_url = get_host_url(request)
+#         self.assertEqual(host_url, "http://localhost")
+#         host_url = get_host_url(None)
+#         self.assertEqual(host_url, None)
 
-    def test_get_complete_url(self):
-        """Our beloved get_complete_url utility"""
-        request_factory = RequestFactory()
-        request = request_factory.get("/path")
-        request.META["HTTP_HOST"] = "localhost"
-        complete_url = get_complete_url(request, "path")
-        self.assertEqual(complete_url, "http://localhost/path")
-        complete_url = get_complete_url(request, "path", "it")
-        self.assertEqual(complete_url, "http://localhost/path")
-        complete_url = get_complete_url(request, "path", "fr")
-        self.assertEqual(complete_url, "http://localhost/fr/path")
+#     def test_get_complete_url(self):
+#         """Our beloved get_complete_url utility"""
+#         request_factory = RequestFactory()
+#         request = request_factory.get("/path")
+#         request.META["HTTP_HOST"] = "localhost"
+#         complete_url = get_complete_url(request, "path")
+#         self.assertEqual(complete_url, "http://localhost/path")
+#         complete_url = get_complete_url(request, "path", "it")
+#         self.assertEqual(complete_url, "http://localhost/path")
+#         complete_url = get_complete_url(request, "path", "fr")
+#         self.assertEqual(complete_url, "http://localhost/fr/path")
 
-    def test_get_page_with_default_seo(self):
-        """Our beloved get_seo utility with auto attributes"""
-        request_factory = RequestFactory()
-        request = request_factory.get("/path")
-        request.META["HTTP_HOST"] = "localhost"
-        page = Page.get(request, identifier="home")
-        self.assertEqual(page.og_url, "http://localhost/path")
-        self.assertEqual(page.canonical, "http://localhost/path")
+#     def test_get_page_with_default_seo(self):
+#         """Our beloved get_seo utility with auto attributes"""
+#         request_factory = RequestFactory()
+#         request = request_factory.get("/path")
+#         request.META["HTTP_HOST"] = "localhost"
+#         page = Page.get(request, identifier="home")
+#         self.assertEqual(page.og_url, "http://localhost/path")
+#         self.assertEqual(page.canonical, "http://localhost/path")
 
-    def test_get_article_with_default_seo(self):
-        """Our beloved get_seo utility with auto attributes"""
-        request_factory = RequestFactory()
-        request = request_factory.get("/path")
-        request.META["HTTP_HOST"] = "localhost"
-        Article.objects.create(permalink="main")
-        article = Article.get(request, permalink="main")
-        self.assertEqual(article.og_url, "http://localhost/path")
-        self.assertEqual(article.canonical, "http://localhost/path")
+#     def test_get_article_with_default_seo(self):
+#         """Our beloved get_seo utility with auto attributes"""
+#         request_factory = RequestFactory()
+#         request = request_factory.get("/path")
+#         request.META["HTTP_HOST"] = "localhost"
+#         Article.objects.create(permalink="main")
+#         article = Article.get(request, permalink="main")
+#         self.assertEqual(article.og_url, "http://localhost/path")
+#         self.assertEqual(article.canonical, "http://localhost/path")
 
-    def test_compile_seo_overwrite(self):
-        """Our beloved get_seo utility with auto attributes"""
-        request_factory = RequestFactory()
-        request = request_factory.get("/path")
-        request.META["HTTP_HOST"] = "localhost"
-        article = Article.objects.create(permalink="main")
-        article.canonical = "/myarticle"
-        article.og_url = "/myarticle"
-        article.save()
-        article = Article.get(request, permalink="main")
-        self.assertEqual(article.og_url, "http://localhost/myarticle")
-        self.assertEqual(article.canonical, "http://localhost/myarticle")
+#     def test_compile_seo_overwrite(self):
+#         """Our beloved get_seo utility with auto attributes"""
+#         request_factory = RequestFactory()
+#         request = request_factory.get("/path")
+#         request.META["HTTP_HOST"] = "localhost"
+#         article = Article.objects.create(permalink="main")
+#         article.canonical = "/myarticle"
+#         article.og_url = "/myarticle"
+#         article.save()
+#         article = Article.get(request, permalink="main")
+#         self.assertEqual(article.og_url, "http://localhost/myarticle")
+#         self.assertEqual(article.canonical, "http://localhost/myarticle")
 
-    def test_get_article_with_redirect(self):
-        """Our beloved get_seo utility with auto attributes"""
-        request_factory = RequestFactory()
-        request = request_factory.get("/articles/articolo-1")
-        request.META["HTTP_HOST"] = "localhost"
+#     def test_get_article_with_redirect(self):
+#         """Our beloved get_seo utility with auto attributes"""
+#         request_factory = RequestFactory()
+#         request = request_factory.get("/articles/articolo-1")
+#         request.META["HTTP_HOST"] = "localhost"
 
-        article = Article.objects.create(permalink="article-1", language_code="en")
-        article.translate("it")
-        article.permalink = "articolo-1"
-        article.save()
-        self.assertRaises(NeedARedirect, Article.get, request, permalink="article-1")
-        activate("de")
-        self.assertRaises(Http404, Article.get, request, permalink="article-1")
+#         article = Article.objects.create(permalink="article-1", language_code="en")
+#         article.translate("it")
+#         article.permalink = "articolo-1"
+#         article.save()
+#         self.assertRaises(NeedARedirect, Article.get, request, permalink="article-1")
+#         activate("de")
+#         self.assertRaises(Http404, Article.get, request, permalink="article-1")

tests/utils/api.py

@@ -0,0 +1,29 @@
+from django.contrib.auth.models import User
+from rest_framework.test import APIClient
+from example.website.models import TestModel
+
+client = APIClient()
+
+
+def login_superuser():
+    User.objects.create_superuser("admin", "admin@test.com", "adminadmin")
+    response = client.post(
+        "/api/camomilla/token-auth/", {"username": "admin", "password": "adminadmin"}
+    )
+    return response.json()["token"]
+
+
+def login_user():
+    User.objects.create_user("user", "user@test.com", "useruser")
+    response = client.post(
+        "/api/camomilla/token-auth/", {"username": "user", "password": "useruser"}
+    )
+    return response.json()["token"]
+
+
+def login_staff():
+    User.objects.create_user("staff", "staff@test.com", "staffstaff", is_staff=True)
+    response = client.post(
+        "/api/camomilla/token-auth/", {"username": "staff", "password": "staffstaff"}
+    )
+    return response.json()["token"]

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
-            ),
-        )