pydantic-views 0.1.0b0__tar.gz

pydantic_views-0.1.0b0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Alfred Santacatalina Gea
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pydantic_views-0.1.0b0/PKG-INFO

@@ -0,0 +1,18 @@
+Metadata-Version: 2.3
+Name: pydantic-views
+Version: 0.1.0b0
+Summary: View for Pydantic models
+License: LGPL-3.0-or-later
+Author: Alfred Santacatalina
+Author-email: alfred.santacatalinagea@telefonica.com
+Requires-Python: >=3.13,<4.0.0
+Classifier: License :: OSI Approved :: GNU Lesser General Public License v3 or later (LGPLv3+)
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: pydantic (>=2.10.6,<3.0.0)
+Description-Content-Type: text/markdown
+
+# Views for pydantic models
+
+TBD
+

pydantic_views-0.1.0b0/README.md

@@ -0,0 +1,3 @@
+# Views for pydantic models
+
+TBD

pydantic_views-0.1.0b0/pyproject.toml

@@ -0,0 +1,102 @@
+[project]
+name = "pydantic-views"
+version = "0.1.0b0"
+description = "View for Pydantic models"
+authors = [
+    {name = "Alfred Santacatalina",email = "alfred.santacatalinagea@telefonica.com"}
+]
+license = "LGPL-3.0-or-later"
+readme = "README.md"
+requires-python = ">=3.13,<4.0.0"
+dependencies = ["pydantic (>=2.10.6,<3.0.0)"]
+
+
+[build-system]
+requires = ["poetry-core>=2.0.0,<3.0.0"]
+build-backend = "poetry.core.masonry.api"
+
+
+[tool.poetry]
+requires-poetry = ">=2.0"
+packages = [{ from = "src", include = "pydantic_views" }]
+
+[tool.poetry.group.dev.dependencies]
+flake8 = "^7.1.2"
+pytest-cov = "^6.0.0"
+isort = "^5.13.2"
+absolufy-imports = "^0.3.1"
+ruff = "^0.9.9"
+mypy = "^1.15.0"
+pytest = "^8.3.5"
+flake8-pyproject = "^1.2.3"
+autoflake = "^2.3.1"
+
+
+[tool.poetry.group.docs.dependencies]
+sphinx = "^8.2.3"
+autodoc-pydantic = "^2.2.0"
+
+[tool.ruff]
+exclude = [".venv/*"]
+
+[tool.flake8]
+exclude = [".venv/*"]
+max-line-length = 120
+extend-ignore = "E251"
+
+[tool.isort]
+profile = "black"
+src_paths = ["src", "tests"]
+skip_glob = [".venv/*"]
+reverse_relative = true
+split_on_trailing_comma = true
+multi_line_output = 3
+include_trailing_comma = true
+force_grid_wrap = 0
+use_parentheses = true
+ensure_newline_before_comments = true
+
+[tool.mypy]
+files = ["src", "tests"]
+exclude = [".venv/.*", "docs/source/.*"]
+disable_error_code="valid-type,import-untyped"
+
+
+[tool.pydantic-mypy]
+init_forbid_extra = true
+init_typed = true
+warn_required_dynamic_aliases = true
+warn_untyped_fields = true
+
+[tool.coverage.run]
+omit = [".venv/*"]
+branch = true
+relative_files = false
+
+[tool.coverage.report]
+# Regexes for lines to exclude from consideration
+exclude_also = [
+    # Dont complain about missing debug-only code:
+    "def __repr__",
+    "if self\\.debug",
+
+    # Don't complain if tests don't hit defensive assertion code:
+    "raise AssertionError",
+    "raise NotImplementedError",
+
+    # Don't complain if non-runnable code isn't run:
+    "if 0:",
+    "if __name__ == .__main__.:",
+
+    # Don't complain about abstract methods, they aren't run:
+    "@(abc\\.)?abstractmethod",
+
+    # Don't complain type checking imports, they aren't run:
+    "if TYPE_CHECKING",
+
+    # Don't complain overloads, they aren't run:
+    "@overload"
+]
+
+[tool.coverage.paths]
+source = ["src/"]

pydantic_views-0.1.0b0/src/pydantic_views/annotations.py

@@ -0,0 +1,40 @@
+from enum import Enum, auto
+from typing import Annotated, TypeVar
+
+T = TypeVar("T")
+
+
+class AccessMode(Enum):
+    READ_AND_WRITE = auto()
+    READ_ONLY = auto()
+    WRITE_ONLY = auto()
+    READ_ONLY_ON_CREATION = auto()
+    WRITE_ONLY_ON_CREATION = auto()
+    HIDDEN = auto()
+
+
+class FieldAccess:
+    __slots__ = ("_mode",)
+
+    def __init__(self, mode: AccessMode = AccessMode.READ_AND_WRITE):
+        self._mode = mode
+
+    @property
+    def mode(self) -> AccessMode:
+        return self._mode
+
+
+RW = FieldAccess(AccessMode.READ_AND_WRITE)
+RO = FieldAccess(AccessMode.READ_ONLY)
+WO = FieldAccess(AccessMode.WRITE_ONLY)
+ROOC = FieldAccess(AccessMode.READ_ONLY_ON_CREATION)
+WOOC = FieldAccess(AccessMode.WRITE_ONLY_ON_CREATION)
+HIDDEN = FieldAccess(AccessMode.HIDDEN)
+
+
+ReadAndWrite = Annotated[T, RW]
+ReadOnly = Annotated[T, RO]
+WriteOnly = Annotated[T, WO]
+ReadOnlyOnCreation = Annotated[T, ROOC]
+WriteOnlyOnCreation = Annotated[T, WOOC]
+Hidden = Annotated[T, HIDDEN]

pydantic_views-0.1.0b0/src/pydantic_views/builder.py

@@ -0,0 +1,336 @@
+from collections.abc import Iterable, Mapping
+from copy import deepcopy
+from types import NoneType, UnionType
+from typing import Union  # type: ignore[deprecated]
+from typing import (
+    Any,
+    ForwardRef,
+    cast,
+    get_args,
+    get_origin,
+)
+from weakref import ref
+
+from pydantic import BaseModel, RootModel, create_model
+from pydantic.fields import ComputedFieldInfo, FieldInfo
+from pydantic_core import PydanticUndefined
+
+from .annotations import AccessMode, FieldAccess
+from .manager import Manager
+from .view import RootView, View
+
+
+class Builder:
+    def __init__(
+        self,
+        suffix: str,
+        access_modes: tuple[AccessMode, ...],
+        all_optional: bool = False,
+        all_nullable: bool = False,
+        hide_default_null: bool = False,
+        include_computed_fields: bool = False,
+    ) -> None:
+        self.suffix = suffix
+        self.access_modes = access_modes
+        self.all_optional = all_optional
+        self.all_nullable = all_nullable
+        self.hide_default_null = hide_default_null
+        self.include_computed_fields = include_computed_fields
+        self._views: dict[type[BaseModel], type[View[BaseModel]] | ForwardRef] = {}
+
+    def build_view[T: BaseModel](self, model: type[T]) -> type[View[T] | T]:
+        manager = ensure_model_views(model)
+        try:
+            result: type[View[T] | T] = manager[self.suffix]
+        except (KeyError, TypeError):
+            result = manager.build_view(self)
+
+        [
+            v.model_rebuild()  # type: ignore
+            for v in self._views.values()
+            if not isinstance(v, ForwardRef)
+        ]
+
+        return result
+
+    def get_view_ref[T: BaseModel](
+        self, model: type[T]
+    ) -> type[View[T] | T] | ForwardRef:
+        try:
+            return cast(type[View[T]] | ForwardRef, self._views[model])
+        except KeyError:
+            pass
+
+        manager = ensure_model_views(model)
+
+        try:
+            view: type[View[T] | T] = manager[self.suffix]
+        except KeyError:
+            view = manager.build_view(self)
+
+        self._views[model] = cast(type[View[BaseModel]], view)
+
+        return view
+
+    def _filter_field(self, f_info: FieldInfo):
+        am = {m.mode for m in f_info.metadata if isinstance(m, FieldAccess)}
+        return len((am & set(self.access_modes))) == 0 and len(am) > 0
+
+    def _iter_fields[T: BaseModel](self, model: type[T]):
+        for f_name, f_info in model.model_fields.items():
+            if self._filter_field(f_info):
+                continue
+            yield f_name, f_info
+
+    def _filter_computed_field(self, f_info: ComputedFieldInfo) -> bool:
+        return False
+
+    def _iter_computed_fields[T: BaseModel](self, model: type[T]):
+        for f_name, cf_info in model.model_computed_fields.items():
+            if self._filter_computed_field(
+                cf_info
+            ):  # [TODO] does it have sense? #  pragma: no cover
+                continue
+            yield f_name, cf_info
+
+    def build_from_model[T: BaseModel](self, model: type[T]) -> type[View[T] | T]:
+        from pydantic._internal._config import ConfigWrapper
+
+        view_name = model.__name__ + self.suffix[0].upper() + self.suffix[1:]
+        try:
+            view_cache = self._views[model]
+            if not isinstance(view_cache, ForwardRef):
+                return cast(type[View[T] | T], view_cache)
+        except KeyError:
+            self._views[model] = ForwardRef(view_name, module=model.__module__)
+
+        view: type[View[T] | T]
+
+        manager = ensure_model_views(model)
+
+        try:
+            view = manager[self.suffix]
+            self._views[model] = cast(type[View[BaseModel]], view)
+        except KeyError:
+            model_fields: dict[str, tuple[type[Any] | None, FieldInfo]] = {}
+            for f_name, f_info in self._iter_fields(model):
+                model_fields[f_name] = self._map_field_info(
+                    f_info.annotation,
+                    f_info,
+                    ignore_nullable=issubclass(model, RootModel),
+                )
+
+            if self.include_computed_fields:
+                for f_name, cf_info in self._iter_computed_fields(model):
+                    model_fields[f_name] = self._map_computed_field_info(cf_info)
+
+            base_view: type[View[T]] | type[RootView[T]]
+
+            if issubclass(model, RootModel):
+
+                class _RootView(RootView[T]):
+                    model_config = deepcopy(model.model_config)
+
+                    __model_class_root__ = ref(cast(type[T], model))
+
+                base_view = _RootView
+
+            else:
+
+                class _View(View[T]):
+                    model_config = deepcopy(model.model_config)
+
+                    __model_class_root__ = ref(cast(type[T], model))
+
+                _View.model_config["protected_namespaces"] = tuple(
+                    {
+                        *ConfigWrapper(_View.model_config).protected_namespaces,
+                        *ConfigWrapper(View.model_config).protected_namespaces,
+                    }
+                )
+
+                base_view = _View
+
+            params: dict[str, Any] = {
+                "__module__": model.__module__,
+                "__base__": base_view,
+                "__doc__": (
+                    f"View `{self.suffix}` "
+                    f"of model :class:`~{model.__module__}.{model.__qualname__}`"
+                ),
+                **model_fields,
+            }
+
+            view = cast(
+                type[View[T]],
+                create_model(
+                    view_name,
+                    **params,
+                ),
+            )
+
+            self._views[model] = cast(type[View[BaseModel]], view)
+
+        return view
+
+    def _map_field_info(
+        self,
+        annotation: type[Any] | None,
+        f_info: FieldInfo,
+        *,
+        ignore_nullable: bool = False,
+    ) -> tuple[type[Any] | None, FieldInfo]:
+        f_info = FieldInfo.merge_field_infos(
+            f_info,
+            annotation=self._map_annotation(
+                f_info.annotation, ignore_nullable=ignore_nullable
+            ),
+        )
+
+        if self.all_optional:
+            f_info = FieldInfo.merge_field_infos(
+                f_info,
+                default_factory=lambda: PydanticUndefined,
+            )
+            f_info.default = PydanticUndefined
+
+        if self.hide_default_null and f_info.default is None:
+            f_info = FieldInfo.merge_field_infos(
+                f_info,
+                default_factory=lambda: PydanticUndefined,
+            )
+            f_info.default = PydanticUndefined
+
+        return f_info.annotation, f_info
+
+    def _map_annotation(
+        self, annotation: type[Any] | None, *, ignore_nullable: bool = False
+    ) -> type[Any] | ForwardRef | None | UnionType:
+        def finish_annotation(a: type[Any] | None) -> type[Any] | None | UnionType:
+            if not ignore_nullable and self.all_nullable and a is not Ellipsis:  # type: ignore
+                return Union[a, None]  # type: ignore
+
+            return a
+
+        try:
+            if annotation and issubclass(annotation, BaseModel):
+                return finish_annotation(self.get_view_ref(annotation))  # type: ignore
+        except TypeError:
+            pass
+
+        origin = get_origin(annotation)
+        type_args = get_args(annotation)
+
+        if origin is None:
+            return finish_annotation(annotation)
+
+        if origin is not Union and not issubclass(origin, UnionType):  # type: ignore
+            if issubclass(origin, Mapping):
+                return finish_annotation(
+                    origin[  # type: ignore
+                        self._map_annotation(type_args[0], ignore_nullable=True),
+                        self._map_annotation(type_args[1]),
+                    ]
+                )
+            elif issubclass(origin, Iterable):
+                return finish_annotation(
+                    origin[  # type: ignore
+                        *(
+                            self._map_annotation(
+                                t, ignore_nullable=issubclass(origin, (list, set))
+                            )
+                            for t in type_args
+                        )
+                    ]
+                )
+
+        return Union[  # type: ignore
+            *(
+                self._map_annotation(a)
+                for a in type_args
+                if a is not NoneType or not self.hide_default_null
+            )
+        ]
+
+    def _map_computed_field_info(
+        self, cf_info: ComputedFieldInfo
+    ) -> tuple[type[Any] | None, FieldInfo]:
+        return (
+            cf_info.return_type,
+            FieldInfo(
+                annotation=cf_info.return_type,
+                alias=cf_info.alias,
+                default=None,
+                alias_priority=cf_info.alias_priority,
+                serialization_alias=cf_info.title,
+                title=cf_info.title,
+                description=cf_info.title,
+                examples=cf_info.examples,
+                discriminator=cf_info.title,
+                deprecated=cf_info.title,
+                json_schema_extra=cf_info.json_schema_extra,
+                repr=cf_info.repr,
+            ),
+        )
+
+
+def BuilderCreate(suffix: str = "Create") -> Builder:
+    return Builder(
+        suffix,
+        access_modes=(
+            AccessMode.READ_AND_WRITE,
+            AccessMode.WRITE_ONLY,
+            AccessMode.WRITE_ONLY_ON_CREATION,
+        ),
+        hide_default_null=True,
+    )
+
+
+def BuilderCreateResult(suffix: str = "CreateResult") -> Builder:
+    return Builder(
+        suffix,
+        access_modes=(
+            AccessMode.READ_AND_WRITE,
+            AccessMode.READ_ONLY,
+            AccessMode.READ_ONLY_ON_CREATION,
+        ),
+        include_computed_fields=True,
+    )
+
+
+def BuilderUpdate(suffix: str = "Update") -> Builder:
+    return Builder(
+        suffix,
+        access_modes=(AccessMode.READ_AND_WRITE, AccessMode.WRITE_ONLY),
+        all_optional=True,
+    )
+
+
+def BuilderLoad(suffix: str = "Load") -> Builder:
+    return Builder(
+        suffix,
+        access_modes=(
+            AccessMode.READ_AND_WRITE,
+            AccessMode.READ_ONLY,
+        ),
+        include_computed_fields=True,
+    )
+
+
+def ensure_model_views[T: BaseModel](model: type[T]):
+    try:
+        if (
+            manager := cast(Manager[T], getattr(model, "model_views"))
+        ) and manager.model == model:
+            return manager
+    except AttributeError:
+        pass
+
+    manager = Manager(model)
+    setattr(
+        model,
+        "model_views",
+        manager,
+    )
+
+    return manager

pydantic_views-0.1.0b0/src/pydantic_views/manager.py

@@ -0,0 +1,36 @@
+from typing import TYPE_CHECKING
+from weakref import ref
+
+from pydantic import BaseModel
+
+from .view import View
+
+if TYPE_CHECKING:
+    from .builder import Builder
+
+
+class Manager[TModel: BaseModel]:
+    __slots__ = ("_model", "_views")
+
+    def __init__(self, model: type[TModel]):
+        self._model = ref(model)
+        self._views: dict[str, type["View[TModel] | TModel"]] = {}
+
+    @property
+    def model(self) -> type[TModel]:
+        result = self._model()
+        if not result:  # pragma: no cover
+            raise RuntimeError("Model class disappeared")
+        return result
+
+    def __getitem__(self, view_name: str) -> type["View[TModel] | TModel"]:
+        return self._views[view_name]
+
+    def __setitem__(self, view_name: str, view: type["View[TModel] | TModel"]):
+        self._views[view_name] = view
+
+    def build_view(self, builder: "Builder") -> type["View[TModel] | TModel"]:
+        view = builder.build_from_model(self.model)
+        self[builder.suffix] = view
+
+        return view

pydantic_views-0.1.0b0/src/pydantic_views/view.py

@@ -0,0 +1,92 @@
+from collections.abc import Mapping
+from typing import Any, ClassVar, cast, overload
+from weakref import ReferenceType
+
+from pydantic import BaseModel, RootModel
+
+
+class View[T: BaseModel](BaseModel):
+    __model_class_root__: ClassVar[ReferenceType[type[BaseModel]]]
+
+    model_config = {
+        "protected_namespaces": ("view_class_root", "view_build", "view_apply")
+    }
+
+    @classmethod
+    def view_class_root(cls) -> type[T]:
+        root = cls.__model_class_root__()
+
+        if root is None:  # pragma: no cover
+            raise RuntimeError("Root model disappeared")
+
+        return cast(type[T], root)
+
+    @classmethod
+    def view_build_from(cls, model: T):
+        return cls.model_validate(model.model_dump(exclude_unset=True, by_alias=True))
+
+    def view_build_to(self) -> T:
+        return self.view_class_root().model_validate(
+            self.model_dump(exclude_unset=True, exclude_defaults=True, by_alias=True)
+        )
+
+    def view_apply_to(self, model: T) -> T:
+        return model_apply(model, self)
+
+
+class RootView[R](View[RootModel[R]], RootModel[R]):
+    pass
+
+
+def model_apply[T: BaseModel](orig: T, view: View[T] | T) -> T:
+    update_data: dict[str, Any] = {}
+
+    for field in view.model_fields_set:
+        value = _merge_values(
+            getattr(orig, field),
+            getattr(view, field),
+        )
+        update_data[field] = getattr(
+            orig.__pydantic_validator__.validate_assignment(orig, field, value), field
+        )
+    return orig.model_copy(
+        update=update_data,
+        deep=True,
+    )
+
+
+@overload
+def _merge_values[T: BaseModel](
+    orig_value: None, new_value: T
+) -> T | dict[str, Any]: ...
+
+
+@overload
+def _merge_values[T: BaseModel, A](orig_value: None, new_value: A) -> A: ...
+
+
+@overload
+def _merge_values[T: BaseModel, A](
+    orig_value: T, new_value: View[T]
+) -> T | dict[str, Any]: ...
+
+
+def _merge_values[T: BaseModel, A](
+    orig_value: T | None, new_value: View[T] | A
+) -> T | A | dict[str, Any]:
+    if isinstance(new_value, BaseModel):
+        if isinstance(orig_value, BaseModel):
+            return cast(T, model_apply(orig_value, new_value))
+        if isinstance(new_value, View):
+            return cast(View[T], new_value).view_build_to()
+        return new_value.model_dump(
+            exclude_unset=True, exclude_defaults=True, by_alias=True
+        )
+    elif isinstance(new_value, Mapping) and isinstance(orig_value, Mapping):
+        data: dict[str, Any] = dict(cast(Mapping[str, Any], orig_value))
+        for k, v in cast(Mapping[str, Any], new_value).items():
+            data[k] = _merge_values(data.get(k), v)
+
+        return cast(T, cast(Mapping[str, Any], orig_value).__class__(**data))
+    else:
+        return cast(T, new_value)