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

camomilla/structured/models.py

@@ -1,140 +1,47 @@
-from collections import defaultdict
-from jsonmodels.models import Base
-from jsonmodels.fields import _LazyType
-from jsonmodels.validators import ValidationError
-from camomilla.structured.fields import (
-    ForeignKey,
-    ForeignKeyList,
-    EmbeddedField,
-    ListField,
-)
-from camomilla.utils.getters import pointed_getter
-
-__all__ = ["Model"]
-
-
-class _Cache:
-    instance = None
-    parent = None
-    prefetched_data = {}
-
-    def __init__(self, instance):
-        self.instance = instance
-        self.prefetched_data = {}
-
-    @property
-    def is_root(self):
-        return self.parent == None
-
-    @property
-    def root_node(self):
-        root = self.instance
-        while root._cache.parent is not None:
-            root = root._cache.parent
-        return root
-
-    def get_prefetched_data(self):
-        if self.is_root:
-            return self.prefetched_data
-        return self.root_node.get_prefetched_data()
-
-
-class Model(Base):
-    def __init__(self, **kwargs):
-        self._cache = _Cache(self)
-        for _, field in self.iterate_over_fields():
-            field.bind(self)
-        super(Model, self).__init__(**kwargs)
-
-    def populate(self, **kwargs):
-        relations = self.prepopulate(**kwargs)
-        self.prefetch_related(kwargs)
-        super(Model, self).populate(**relations)
-
-    def prepopulate(self, **kwargs):
-        relations = {}
-        for _, struct_name, field in self.iterate_with_name():
-            if struct_name in kwargs and isinstance(
-                field, (ForeignKey, ForeignKeyList, EmbeddedField, ListField)
-            ):
-                relations[struct_name] = kwargs.pop(struct_name)
-        super(Model, self).populate(**kwargs)
-        return relations
-
-    def bind(self, parent):
-        self._cache.parent = parent
-
-    @classmethod
-    def to_db_transform(cls, data):
-        return data
-
+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 from_db_transform(cls, data):
-        return data
-    
-    @classmethod
-    def get_all_relateds(cls, struct):
-        relateds = defaultdict(set)
-        for _, struct_name, field in cls.iterate_with_name():
-            if isinstance(field, ForeignKey):
-                value = struct.get(struct_name, None)
-                model = getattr(field, "model", None)
-                if value:
-                    relateds[model].add(value)
-            elif isinstance(field, ForeignKeyList):
-                value = pointed_getter(struct, struct_name, [])
-                if isinstance(value, list):
-                    model = getattr(field, "inner_model", None)
-                    relateds[model].update([i for i in value if i])
-            elif isinstance(field, ListField):
-                values = pointed_getter(struct, struct_name, [])
-                if isinstance(values, list):
-                    for val in values:
-                        if isinstance(val, Model):
-                            main_type = val.__class__
-                            val = val.to_struct()
-                        else:
-                            main_type = field._get_main_type()
-                            if isinstance(main_type, _LazyType):
-                                main_type = main_type.evaluate(cls)
-                        if issubclass(main_type, Model):
-                            for model, pks in main_type.get_all_relateds(val).items():
-                                relateds[model].update(pks)
-            elif isinstance(field, EmbeddedField):
-                value = struct.get(struct_name, None)
-                if isinstance(value, Model):
-                    value = value.to_struct()
-                if not isinstance(value, dict):
-                    continue
-                child_relateds = field._get_embed_type().get_all_relateds(value)
-                for model, pks in child_relateds.items():
-                    relateds[model].update(pks)
-        return relateds
-
-    def prefetch_related(self, struct):
-        if struct.keys() and self._cache.is_root:
-            relateds = self.get_all_relateds(struct)
-            for model, pks in relateds.items():
-                self._cache.prefetched_data[model] = (
-                    {obj.pk: obj for obj in build_model_cache(model, pks)}
-                    if len(pks) > 0
-                    else {}
-                )
-
-    def get_prefetched_data(self):
-        return self._cache.get_prefetched_data()
-
+    def build_cache(cls, data: Any) -> Any:
+        from camomilla.structured.cache import CacheBuilder
 
-def build_model_cache(model, values):
-    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))
-    return models
+        return CacheBuilder.from_model(cls).inject_cache(data)

camomilla/structured/utils.py

@@ -0,0 +1,114 @@
+from typing import Any, Generic, Sequence
+from typing_extensions import TypeVar, get_args
+from django.core.exceptions import ImproperlyConfigured
+from camomilla.utils.getters import pointed_getter
+
+
+T = TypeVar("T")
+
+
+class _LazyType:
+    def __init__(self, path):
+        self.path = path
+
+    def evaluate(self, base_cls):
+        module, type_name = self._evaluate_path(self.path, base_cls)
+        return self._import(module, type_name)
+
+    def _evaluate_path(self, relative_path, base_cls):
+        base_module = base_cls.__module__
+
+        modules = self._get_modules(relative_path, base_module)
+
+        type_name = modules.pop()
+        module = ".".join(modules)
+        if not module:
+            module = base_module
+        return module, type_name
+
+    def _get_modules(self, relative_path, base_module):
+        canonical_path = relative_path.lstrip(".")
+        canonical_modules = canonical_path.split(".")
+
+        if not relative_path.startswith("."):
+            return canonical_modules
+
+        parents_amount = len(relative_path) - len(canonical_path)
+        parent_modules = base_module.split(".")
+        parents_amount = max(0, parents_amount - 1)
+        if parents_amount > len(parent_modules):
+            raise ValueError(f"Can't evaluate path '{relative_path}'")
+        return parent_modules[: parents_amount * -1] + canonical_modules
+
+    def _import(self, module_name, type_name):
+        module = __import__(module_name, fromlist=[type_name])
+        try:
+            return getattr(module, type_name)
+        except AttributeError:
+            raise ValueError(f"Can't find type '{module_name}.{type_name}'.")
+
+
+def get_type(source: Generic[T], raise_exception=True) -> T:
+    try:
+        return get_args(source)[0]
+    except IndexError:
+        if raise_exception:
+            raise ImproperlyConfigured(
+                "Must provide a Model class for ForeignKey fields."
+            )
+        else:
+            return None
+
+
+def get_type_eval(source: Generic[T], model: Any, raise_exception=True) -> T:
+    type = get_type(source, raise_exception)
+    if isinstance(type, str):
+        return _LazyType(type).evaluate(model)
+
+
+def set_key(data, key, val):
+    if isinstance(data, Sequence):
+        key = int(key)
+        if key < len(data):
+            data[key] = val
+        else:
+            data.append(val)
+        return data
+    elif isinstance(data, dict):
+        data[key] = val
+    else:
+        setattr(data, key, val)
+    return data
+
+
+def get_key(data, key, default):
+    if isinstance(data, Sequence):
+        try:
+            return data[int(key)]
+        except IndexError:
+            return default
+    return pointed_getter(data, key, default)
+
+
+def pointed_setter(data, path, value):
+    path = path.split(".")
+    key = path.pop(0)
+    if not len(path):
+        return set_key(data, key, value)
+    default = [] if path[0].isdigit() else {}
+    return set_key(
+        data, key, pointed_setter(get_key(data, key, default), ".".join(path), value)
+    )
+
+
+def map_method_aliases(new_cls):
+    method_aliases = {
+        "validate_python": "model_validate",
+        "validate_json": "model_validate_json",
+        # "dump_python": "model_dump",
+        # "dump_json": "model_dump_json",
+        "json_schema": "model_json_schema"
+    }
+    for alias_name, target_name in method_aliases.items():
+        setattr(new_cls, alias_name, getattr(new_cls, target_name))
+    return new_cls

camomilla/templatetags/camomilla_filters.py

@@ -1,5 +1,4 @@
 from django import template
-from django.utils.translation import get_language
 
 
 register = template.Library()

camomilla/theme/__init__.py

@@ -1 +1 @@
-__version__ = "6.0.0-beta.2"
+__version__ = "6.0.0-beta.4"

camomilla/theme/admin.py

@@ -0,0 +1,96 @@
+from ckeditor_uploader.widgets import CKEditorUploadingWidget
+from django import forms
+from django.contrib import admin
+from django.http import HttpResponse
+
+from camomilla import settings
+
+if settings.ENABLE_TRANSLATIONS:
+    from modeltranslation.admin import (
+        TabbedTranslationAdmin as TranslationAwareModelAdmin,
+    )
+else:
+    from django.contrib.admin import ModelAdmin as TranslationAwareModelAdmin
+
+from camomilla.models import Article, Content, Media, MediaFolder, Page, Tag, Menu
+
+
+class AbstractPageAdmin(TranslationAwareModelAdmin):
+    change_form_template = "admin/camomilla/page/change_form.html"
+
+
+class UserProfileAdmin(admin.ModelAdmin):
+    pass
+
+
+class ArticleAdminForm(forms.ModelForm):
+    class Meta:
+        model = Article
+        exclude = ("slug",)
+        widgets = {"content": CKEditorUploadingWidget}
+
+
+class ArticleAdmin(AbstractPageAdmin):
+    filter_horizontal = ("tags",)
+    form = ArticleAdminForm
+
+
+class TagAdmin(TranslationAwareModelAdmin):
+    pass
+
+
+class MediaFolderAdmin(admin.ModelAdmin):
+    readonly_fields = ("path",)
+
+
+class ContentAdminForm(forms.ModelForm):
+    class Meta:
+        model = Content
+        fields = "__all__"
+        widgets = {"content": CKEditorUploadingWidget}
+
+
+class ContentAdmin(TranslationAwareModelAdmin):
+    form = ContentAdminForm
+
+
+class MediaAdmin(TranslationAwareModelAdmin):
+    exclude = (
+        "thumbnail",
+        "size",
+        "image_props",
+    )
+    readonly_fields = ("image_preview", "image_thumb_preview", "mime_type")
+    list_display = (
+        "__str__",
+        "title",
+        "image_thumb_preview",
+    )
+
+    def response_add(self, request, obj):
+        if request.GET.get("_popup", ""):
+            return HttpResponse(
+                """
+               <script type="text/javascript">
+                  opener.dismissAddRelatedObjectPopup(window, %s, '%s');
+               </script>"""
+                % (obj.id, obj.json_repr)
+            )
+        else:
+            return super(MediaAdmin, self).response_add(request, obj)
+
+
+class PageAdmin(AbstractPageAdmin):
+    readonly_fields = ("permalink",)
+    
+    
+class MenuAdmin(TranslationAwareModelAdmin):
+    pass
+
+admin.site.register(Article, ArticleAdmin)
+admin.site.register(MediaFolder, MediaFolderAdmin)
+admin.site.register(Tag, TagAdmin)
+admin.site.register(Content, ContentAdmin)
+admin.site.register(Media, MediaAdmin)
+admin.site.register(Page, PageAdmin)
+admin.site.register(Menu, MenuAdmin)

camomilla/theme/apps.py

@@ -11,6 +11,9 @@ class CamomillaThemeConfig(AppConfig):
     def ready(self):
         installed_apps = getattr(settings, "INSTALLED_APPS", [])
         changed = False
+        if "django_jsonform" not in installed_apps:
+            changed = True
+            installed_apps = ["django_jsonform", *installed_apps]
         if "admin_interface" not in installed_apps:
             changed = True
             installed_apps = ["admin_interface", *installed_apps]
@@ -23,4 +26,12 @@ class CamomillaThemeConfig(AppConfig):
             apps.apps_ready = apps.models_ready = apps.loading = apps.ready = False
             apps.clear_cache()
             apps.populate(settings.INSTALLED_APPS)
-        setattr(settings, "X_FRAME_OPTIONS", getattr(settings, "X_FRAME_OPTIONS", ))
+        setattr(
+            settings,
+            "X_FRAME_OPTIONS",
+            getattr(
+                settings,
+                "X_FRAME_OPTIONS",
+                "SAMEORIGIN"
+            ),
+        )

camomilla/translation.py

@@ -14,9 +14,10 @@ class SeoMixinTranslationOptions(TranslationOptions):
         "canonical",
     )
 
+
 class AbstractPageTranslationOptions(SeoMixinTranslationOptions):
     fields = ("breadcrumbs_title", "slug", "status", "indexable", "template_data")
-    
+
 
 @register(Article)
 class ArticleTranslationOptions(AbstractPageTranslationOptions):
@@ -48,6 +49,7 @@ class PageTranslationOptions(AbstractPageTranslationOptions):
 class UrlNodeTranslationOptions(TranslationOptions):
     fields = ("permalink",)
 
+
 @register(Menu)
 class MenuTranslationOptions(TranslationOptions):
-    fields = ("nodes",)
+    fields = ("nodes",)

camomilla/urls.py

@@ -20,6 +20,7 @@ from camomilla.views import (
     UserViewSet,
     MenuViewSet,
 )
+from camomilla.views.pages import fetch_page
 
 router = routers.DefaultRouter()
 
@@ -36,6 +37,8 @@ router.register(r"menus", MenuViewSet, "camomilla-menus")
 
 urlpatterns = [
     path("", include(router.urls)),
+    path("pages-router/", fetch_page),
+    path("pages-router/<path:permalink>", fetch_page),
     path(
         "profiles/me/", lambda _: redirect("../../users/current/"), name="profiles-me"
     ),
@@ -43,12 +46,16 @@ urlpatterns = [
     path("auth/login/", CamomillaAuthLogin.as_view(), name="login"),
     path("auth/logout/", CamomillaAuthLogout.as_view(), name="logout"),
     path("languages/", LanguageViewSet.as_view(), name="get_languages"),
-    path('openapi', get_schema_view(
-        title="Camomilla",
-        description="API for all things …",
-        version="1.0.0",
-        generator_class=SchemaGenerator
-    ), name='openapi-schema'),
+    path(
+        "openapi",
+        get_schema_view(
+            title="Camomilla",
+            description="API for all things …",
+            version="1.0.0",
+            generator_class=SchemaGenerator,
+        ),
+        name="openapi-schema",
+    ),
 ]
 
 if find_spec("djsuperadmin.urls") is not None:

camomilla/utils/__init__.py

@@ -1,4 +1,4 @@
 from .normalization import *
 from .seo import *
 from .translation import *
-from .templates import *
+from .templates import *

camomilla/utils/getters.py

@@ -1,4 +1,4 @@
-from typing import Any, Union
+from typing import Any, Callable, Union
 
 
 def safe_getter(instance: Union[dict, object], key: str, default: Any = None) -> Any:
@@ -15,3 +15,13 @@ def pointed_getter(
     if len(attrs) == 2:
         data = pointed_getter(data, attrs[1], default)
     return data
+
+
+def find_and_replace_dict(obj: dict, predicate: Callable):
+    result = {}
+    for k, v in obj.items():
+        v = predicate(key=k, value=v)
+        if isinstance(v, dict):
+            v = find_and_replace_dict(v, predicate)
+        result[k] = v
+    return result

camomilla/utils/templates.py

@@ -1,11 +1,11 @@
 from pathlib import Path
-from typing import Iterable
+from typing import Sequence
 
 from django import template as django_template
 from os.path import relpath
 
 
-def get_all_templates_files() -> Iterable[str]:
+def get_all_templates_files() -> Sequence[str]:
     dirs = []
     for engine in django_template.loader.engines.all():
         # Exclude pip installed site package template dirs

camomilla/utils/translation.py

@@ -1,5 +1,5 @@
 import re
-from typing import Any, Iterable, Iterator
+from typing import Any, Sequence, Iterator
 
 from django.db.models import Model, Q
 from django.utils.translation.trans_real import activate, get_language
@@ -8,7 +8,7 @@ from modeltranslation.utils import build_localized_fieldname
 from camomilla.settings import BASE_URL
 
 
-def activate_languages(languages: Iterable[str] = AVAILABLE_LANGUAGES) -> Iterator[str]:
+def activate_languages(languages: Sequence[str] = AVAILABLE_LANGUAGES) -> Iterator[str]:
     old = get_language()
     for language in languages:
         activate(language)
@@ -36,7 +36,7 @@ def url_lang_decompose(url):
     if BASE_URL and url.startswith(BASE_URL):
         url = url[len(BASE_URL):]
     data = {"url": url, "permalink": url, "language": DEFAULT_LANGUAGE}
-    result = re.match(f"^\/?({'|'.join(AVAILABLE_LANGUAGES)})?\/(.*)", url)
+    result = re.match(f"^\/?({'|'.join(AVAILABLE_LANGUAGES)})?\/(.*)", url)  # noqa: W605
     groups = result and result.groups()
     if groups and len(groups) == 2:
         data["language"] = groups[0]
@@ -57,11 +57,14 @@ def lang_fallback_query(**kwargs):
     for lang in AVAILABLE_LANGUAGES:
         query |= Q(**{f"{key}_{lang}": value for key, value in kwargs.items()})
     if current_lang:
-        query = (query & Q(**{f"{key}_{current_lang}__isnull": True for key in kwargs.keys()}))
+        query = query & Q(
+            **{f"{key}_{current_lang}__isnull": True for key in kwargs.keys()}
+        )
         query |= Q(**{f"{key}_{current_lang}": value for key, value in kwargs.items()})
     return query
 
 
-def is_translatable(model:Model) -> bool:
+def is_translatable(model: Model) -> bool:
     from modeltranslation.translator import translator
-    return model in translator.get_registered_models()
+
+    return model in translator.get_registered_models()

camomilla/views/__init__.py

@@ -5,4 +5,4 @@ from .medias import *
 from .pages import *
 from .tags import *
 from .users import *
-from .menus import *
+from .menus import *

camomilla/views/articles.py

@@ -6,7 +6,6 @@ from camomilla.views.mixins import BulkDeleteMixin, GetUserLanguageMixin
 
 
 class ArticleViewSet(GetUserLanguageMixin, BulkDeleteMixin, BaseModelViewset):
-
     queryset = Article.objects.all()
     serializer_class = ArticleSerializer
     permission_classes = (CamomillaBasePermissions,)

camomilla/views/contents.py

@@ -11,7 +11,6 @@ from camomilla.views.mixins import BulkDeleteMixin, GetUserLanguageMixin
 
 
 class ContentViewSet(GetUserLanguageMixin, BulkDeleteMixin, BaseModelViewset):
-
     queryset = Content.objects.all()
     serializer_class = ContentSerializer
     model = Content

camomilla/views/decorators.py

@@ -0,0 +1,26 @@
+import functools
+from django.utils.translation import activate
+from django.conf import settings
+
+
+def active_lang(*args, **kwargs):
+    def decorator(func):
+        @functools.wraps(func)
+        def wrapped_func(*args, **kwargs):
+            if len(args) and hasattr(args[0], "request"):
+                request = args[0].request
+            else:
+                request = args[0] if len(args) else kwargs.get("request", None)
+            lang = settings.LANGUAGE_CODE
+            if request and hasattr(request, "GET"):
+                lang = request.GET.get("lang", request.GET.get("language", lang))
+            if request and hasattr(request, "data"):
+                lang = request.data.pop("lang", request.data.pop("language", lang))
+            if lang and lang in [l[0] for l in settings.LANGUAGES]:
+                activate(lang)
+                request.LANGUAGE_CODE = lang
+            return func(*args, **kwargs)
+
+        return wrapped_func
+
+    return decorator

camomilla/views/medias.py

@@ -45,7 +45,7 @@ class MediaFolderViewSet(
 
     def get_mixed_response(self, request, *args, **kwargs):
         search = self.request.GET.get("search", None)
-        all = self.request.GET.get("all", "false").lower() == 'true'
+        all = self.request.GET.get("all", "false").lower() == "true"
         updir = None if all else kwargs.get("pk", None)
         if not search and all:
             self.search_fields = []
@@ -83,7 +83,6 @@ class MediaViewSet(
     TrigramSearchMixin,
     BaseModelViewset,
 ):
-
     queryset = Media.objects.all()
     serializer_class = MediaSerializer
     permission_classes = (CamomillaBasePermissions,)