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

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)

camomilla/structured/utils.py

@@ -1,114 +0,0 @@
-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