pydantic-views 0.1.0__tar.gz

pydantic_views-0.1.0/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.0/PKG-INFO

@@ -0,0 +1,210 @@
+Metadata-Version: 2.3
+Name: pydantic-views
+Version: 0.1.0
+Summary: Views for Pydantic models
+Home-page: https://pydantic-views.readthedocs.io/latest/
+License: MIT
+Keywords: view,pydantic,datamodel,model,REST API
+Author: Alfred Santacatalina
+Author-email: alfred.santacatalinagea@telefonica.com
+Requires-Python: >=3.13,<4.0.0
+Classifier: Development Status :: 4 - Beta
+Classifier: Framework :: Pydantic
+Classifier: Framework :: Pydantic :: 2
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Typing :: Typed
+Requires-Dist: pydantic (>=2.10.6,<3.0.0)
+Project-URL: Documentation, https://pydantic-views.readthedocs.io/latest/
+Project-URL: Issues, https://github.com/alfred82santa/pydantic-views/issues
+Project-URL: Repository, https://github.com/alfred82santa/pydantic-views.git
+Description-Content-Type: text/x-rst
+
+
+.. |docs| image:: https://readthedocs.org/projects/pydantic-views/badge/?version=latest
+    :alt: Documentation Status
+    :target: https://pydantic-views.readthedocs.io/latest/?badge=latest
+
+.. |python-versions| image:: https://img.shields.io/pypi/pyversions/pydantic-views
+   :alt: PyPI - Python Version
+
+.. |typed| image:: https://img.shields.io/pypi/types/pydantic-views
+   :alt: PyPI - Types
+
+.. |license| image:: https://img.shields.io/pypi/l/pydantic-views
+   :alt: PyPI - License
+
+.. |version| image:: https://img.shields.io/pypi/v/pydantic-views
+   :alt: PyPI - Version
+
+
+|docs| |python-versions| |typed| |license| |version|
+
+.. start-doc
+
+======================================
+View for Pydantic models documentation
+======================================
+
+This package provides a simple way to create `views` from `pydantic <https://docs.pydantic.dev/latest/>`_ models. A view is
+another `pydantic <https://docs.pydantic.dev/latest/>`_ models with some of field of original model. So, for example, 
+read only fields does not appears on `Create` or `Update` views.
+
+As rest service definition you could do:
+
+.. code-block:: python
+
+   ExampleModelCreate = BuilderCreate().build_view(ExampleModel)
+   ExampleModelCreateResult = BuilderCreateResult().build_view(ExampleModel)
+   ExampleModelLoad = BuilderLoad().build_view(ExampleModel)
+   ExampleModelUpdate = BuilderUpdate().build_view(ExampleModel)
+
+   def create(input: ExampleModelCreate) -> ExampleModelCreateResult: ...
+   def load(model_id: str) -> ExampleModelLoad: ...
+   def update(model_id: str, input: ExampleModelUpdate) -> ExampleModelLoad: ...
+
+
+--------
+Features
+--------
+
+- Unlimited views per model.
+- Create view for referenced inner models.
+- It is possible to set a view manually.
+- Tested code.
+- Full typed.
+- Opensource.
+  
+
+------------
+Installation
+------------
+
+Using pip:
+
+.. code-block:: bash
+
+   pip install pydantic-views
+
+Using `poetry <https://python-poetry.org/>`_:
+
+.. code-block:: bash
+
+   poetry add pydantic-views
+
+
+----------
+How to use
+----------
+
+When you define a pydantic model you must mark the access model for each field. It means
+you should use our `annotations <https://pydantic-views.readthedocs.io/latest/api.html#field-annotations>`_ to define field typing.
+
+.. code-block:: python
+
+   from typing import Annotated
+   from pydantic import BaseModel, gt
+   from pydantic_views import ReadOnly, ReadOnlyOnCreation, Hidden, AccessMode
+
+   class ExampleModel(BaseModel):
+
+       # No marked fields are treated like ReadAndWrite fields.
+       field_str: str
+
+       # Read only fields are removed on view for create and update views.
+       field_read_only_str: ReadOnly[str]
+
+       # Read only on creation fields are removed on view for create, update and load views. 
+       # But it is shown on create result view.
+       field_api_secret: ReadOnlyOnCreation[str]
+
+       # It is possible to set more than one access mode and to use annotation standard pattern.
+       field_int: Annotated[int, AccessMode.READ_ONLY, AccessMode.WRITE_ONLY_ON_CREATION, gt(5)]
+
+       # Hidden field do not appears in any view.
+       field_hidden_int: Hidden[int]
+
+       # Computed fields only appears on reading views.
+       @computed_field
+       def field_computed_field(self) -> int:
+           return self.field_hidden_int * 5
+
+So, in order to build a `Load` view it is so simple:
+
+.. code-block:: python
+
+   from pydantic_views import BuilderLoad
+
+   ExampleModelLoad = BuilderLoad().build_view(ExampleModel)
+
+It is equivalent to:
+
+
+.. code-block:: python
+
+   from pydantic import gt
+   from pydantic_views import View
+
+   class ExampleModelLoad(View[ExampleModel]):
+       field_str: str
+       field_int: Annotated[int, gt(5)]
+       field_computed_field: int
+
+In same way to build a `Update` view you must do:
+
+.. code-block:: python
+
+   from pydantic_views import BuilderUpdate
+
+   ExampleModelUpdate = BuilderUpdate().build_view(ExampleModel)
+   
+It is equivalent to:
+
+.. code-block:: python
+
+   from pydantic import PydanticUndefined
+   from pydantic_views import View
+
+   class ExampleModelUpdate(View[ExampleModel]):
+       field_str: str = Field(default_factory=lambda: PydanticUndefined)
+
+As you can see, on `Update` view all fields has a default factory returning `PydanticUndefined`
+in order to make them optionals. And when an update view is applied to a given model, the fields that are 
+not set (use default value) will not be applied to the model.
+
+.. code-block:: python
+
+   original_model = ExampleModel(
+       field_str="anything"
+       field_read_only_str="anything"
+       field_api_secret="anything"
+       field_int=10
+       field_hidden_int=33
+   )
+
+   update = ExampleModelUpdate(field_str="new_data")
+
+   updated_model = update.view_apply_to(original_model)
+
+   assert isinstance(updated_model, ExampleModel)
+   assert updated_model.field_str == "new_data"
+
+
+But if a field is not set on update view, the original value is kept.
+
+.. code-block:: python
+
+   original_model = ExampleModel(
+       field_str="anything"
+       field_read_only_str="anything"
+       field_api_secret="anything"
+       field_int=10
+       field_hidden_int=33
+   )
+
+   update = ExampleModelUpdate()
+
+   updated_model = update.view_apply_to(original_model)
+
+   assert isinstance(updated_model, ExampleModel)
+   assert updated_model.field_str == "anything"

pydantic_views-0.1.0/README.rst

@@ -0,0 +1,188 @@
+
+.. |docs| image:: https://readthedocs.org/projects/pydantic-views/badge/?version=latest
+    :alt: Documentation Status
+    :target: https://pydantic-views.readthedocs.io/latest/?badge=latest
+
+.. |python-versions| image:: https://img.shields.io/pypi/pyversions/pydantic-views
+   :alt: PyPI - Python Version
+
+.. |typed| image:: https://img.shields.io/pypi/types/pydantic-views
+   :alt: PyPI - Types
+
+.. |license| image:: https://img.shields.io/pypi/l/pydantic-views
+   :alt: PyPI - License
+
+.. |version| image:: https://img.shields.io/pypi/v/pydantic-views
+   :alt: PyPI - Version
+
+
+|docs| |python-versions| |typed| |license| |version|
+
+.. start-doc
+
+======================================
+View for Pydantic models documentation
+======================================
+
+This package provides a simple way to create `views` from `pydantic <https://docs.pydantic.dev/latest/>`_ models. A view is
+another `pydantic <https://docs.pydantic.dev/latest/>`_ models with some of field of original model. So, for example, 
+read only fields does not appears on `Create` or `Update` views.
+
+As rest service definition you could do:
+
+.. code-block:: python
+
+   ExampleModelCreate = BuilderCreate().build_view(ExampleModel)
+   ExampleModelCreateResult = BuilderCreateResult().build_view(ExampleModel)
+   ExampleModelLoad = BuilderLoad().build_view(ExampleModel)
+   ExampleModelUpdate = BuilderUpdate().build_view(ExampleModel)
+
+   def create(input: ExampleModelCreate) -> ExampleModelCreateResult: ...
+   def load(model_id: str) -> ExampleModelLoad: ...
+   def update(model_id: str, input: ExampleModelUpdate) -> ExampleModelLoad: ...
+
+
+--------
+Features
+--------
+
+- Unlimited views per model.
+- Create view for referenced inner models.
+- It is possible to set a view manually.
+- Tested code.
+- Full typed.
+- Opensource.
+  
+
+------------
+Installation
+------------
+
+Using pip:
+
+.. code-block:: bash
+
+   pip install pydantic-views
+
+Using `poetry <https://python-poetry.org/>`_:
+
+.. code-block:: bash
+
+   poetry add pydantic-views
+
+
+----------
+How to use
+----------
+
+When you define a pydantic model you must mark the access model for each field. It means
+you should use our `annotations <https://pydantic-views.readthedocs.io/latest/api.html#field-annotations>`_ to define field typing.
+
+.. code-block:: python
+
+   from typing import Annotated
+   from pydantic import BaseModel, gt
+   from pydantic_views import ReadOnly, ReadOnlyOnCreation, Hidden, AccessMode
+
+   class ExampleModel(BaseModel):
+
+       # No marked fields are treated like ReadAndWrite fields.
+       field_str: str
+
+       # Read only fields are removed on view for create and update views.
+       field_read_only_str: ReadOnly[str]
+
+       # Read only on creation fields are removed on view for create, update and load views. 
+       # But it is shown on create result view.
+       field_api_secret: ReadOnlyOnCreation[str]
+
+       # It is possible to set more than one access mode and to use annotation standard pattern.
+       field_int: Annotated[int, AccessMode.READ_ONLY, AccessMode.WRITE_ONLY_ON_CREATION, gt(5)]
+
+       # Hidden field do not appears in any view.
+       field_hidden_int: Hidden[int]
+
+       # Computed fields only appears on reading views.
+       @computed_field
+       def field_computed_field(self) -> int:
+           return self.field_hidden_int * 5
+
+So, in order to build a `Load` view it is so simple:
+
+.. code-block:: python
+
+   from pydantic_views import BuilderLoad
+
+   ExampleModelLoad = BuilderLoad().build_view(ExampleModel)
+
+It is equivalent to:
+
+
+.. code-block:: python
+
+   from pydantic import gt
+   from pydantic_views import View
+
+   class ExampleModelLoad(View[ExampleModel]):
+       field_str: str
+       field_int: Annotated[int, gt(5)]
+       field_computed_field: int
+
+In same way to build a `Update` view you must do:
+
+.. code-block:: python
+
+   from pydantic_views import BuilderUpdate
+
+   ExampleModelUpdate = BuilderUpdate().build_view(ExampleModel)
+   
+It is equivalent to:
+
+.. code-block:: python
+
+   from pydantic import PydanticUndefined
+   from pydantic_views import View
+
+   class ExampleModelUpdate(View[ExampleModel]):
+       field_str: str = Field(default_factory=lambda: PydanticUndefined)
+
+As you can see, on `Update` view all fields has a default factory returning `PydanticUndefined`
+in order to make them optionals. And when an update view is applied to a given model, the fields that are 
+not set (use default value) will not be applied to the model.
+
+.. code-block:: python
+
+   original_model = ExampleModel(
+       field_str="anything"
+       field_read_only_str="anything"
+       field_api_secret="anything"
+       field_int=10
+       field_hidden_int=33
+   )
+
+   update = ExampleModelUpdate(field_str="new_data")
+
+   updated_model = update.view_apply_to(original_model)
+
+   assert isinstance(updated_model, ExampleModel)
+   assert updated_model.field_str == "new_data"
+
+
+But if a field is not set on update view, the original value is kept.
+
+.. code-block:: python
+
+   original_model = ExampleModel(
+       field_str="anything"
+       field_read_only_str="anything"
+       field_api_secret="anything"
+       field_int=10
+       field_hidden_int=33
+   )
+
+   update = ExampleModelUpdate()
+
+   updated_model = update.view_apply_to(original_model)
+
+   assert isinstance(updated_model, ExampleModel)
+   assert updated_model.field_str == "anything"

pydantic_views-0.1.0/pyproject.toml

@@ -0,0 +1,117 @@
+[project]
+name = "pydantic-views"
+version = "0.1.0"
+description = "Views for Pydantic models"
+authors = [
+    {name = "Alfred Santacatalina",email = "alfred.santacatalinagea@telefonica.com"}
+]
+license = "MIT"
+readme = "README.rst"
+requires-python = ">=3.13,<4.0.0"
+dependencies = ["pydantic (>=2.10.6,<3.0.0)"]
+keywords = ["view", "pydantic", "datamodel", "model", "REST API"]
+
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Framework :: Pydantic",
+    "Framework :: Pydantic :: 2",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.13",
+    "Typing :: Typed"
+]
+
+[project.urls]
+Homepage = "https://pydantic-views.readthedocs.io/latest/"
+Repository = "https://github.com/alfred82santa/pydantic-views.git"
+Documentation = "https://pydantic-views.readthedocs.io/latest/"
+Issues = "https://github.com/alfred82santa/pydantic-views/issues"
+
+[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.0/src/pydantic_views/__init__.py

@@ -0,0 +1,38 @@
+from .annotations import (
+    AccessMode,
+    Hidden,
+    ReadAndWrite,
+    ReadOnly,
+    ReadOnlyOnCreation,
+    WriteOnly,
+    WriteOnlyOnCreation,
+)
+from .builder import (
+    Builder,
+    BuilderCreate,
+    BuilderCreateResult,
+    BuilderLoad,
+    BuilderUpdate,
+    ensure_model_views,
+)
+from .manager import Manager
+from .view import RootView, View
+
+__all__ = [
+    "AccessMode",
+    "ReadOnly",
+    "ReadAndWrite",
+    "ReadOnlyOnCreation",
+    "WriteOnly",
+    "WriteOnlyOnCreation",
+    "Hidden",
+    "Builder",
+    "BuilderCreate",
+    "BuilderCreateResult",
+    "BuilderUpdate",
+    "BuilderLoad",
+    "ensure_model_views",
+    "Manager",
+    "View",
+    "RootView",
+]

pydantic_views-0.1.0/src/pydantic_views/annotations.py

@@ -0,0 +1,47 @@
+from enum import Enum, auto
+from typing import Annotated, TypeAlias, TypeVar
+
+T = TypeVar("T")
+
+
+class AccessMode(Enum):
+    """
+    Field access mode.
+    """
+
+    #: Read and write mark.
+    READ_AND_WRITE = auto()
+
+    #: Read only mark.
+    READ_ONLY = auto()
+
+    #: Write only mark.
+    WRITE_ONLY = auto()
+
+    #: Read only on creation mark.
+    READ_ONLY_ON_CREATION = auto()
+
+    #: Write only on creation mark.
+    WRITE_ONLY_ON_CREATION = auto()
+
+    #: Hidden mark.
+    HIDDEN = auto()
+
+
+#: Read and write field annotation. Field could be read and written always.
+ReadAndWrite: TypeAlias = Annotated[T, AccessMode.READ_AND_WRITE]
+
+#: Read only field annotation. Field could be read always but never written.
+ReadOnly = Annotated[T, AccessMode.READ_ONLY]
+
+#: Write only field annotation. Field could be written always but never read.
+WriteOnly = Annotated[T, AccessMode.WRITE_ONLY]
+
+#: Read only on creation field annotation. Field could be read only after creation, and never again.
+ReadOnlyOnCreation = Annotated[T, AccessMode.READ_ONLY_ON_CREATION]
+
+#: Write only on creation field annotation. Field could be written only after creation, and never again.
+WriteOnlyOnCreation = Annotated[T, AccessMode.WRITE_ONLY_ON_CREATION]
+
+#: Hidden field annotation. Field could not be read or written.
+Hidden = Annotated[T, AccessMode.HIDDEN]

pydantic_views-0.1.0/src/pydantic_views/builder.py

@@ -0,0 +1,410 @@
+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
+from .manager import Manager
+from .view import RootView, View
+
+
+class Builder:
+    """
+    View builder. It create a view classes from models following given criterias.
+    """
+
+    def __init__(
+        self,
+        view_name: str,
+        access_modes: tuple[AccessMode, ...],
+        all_optional: bool = False,
+        all_nullable: bool = False,
+        hide_default_null: bool = False,
+        include_computed_fields: bool = False,
+    ) -> None:
+        """
+        :param view_name: View name.
+        :param access_modes: Access modes to filter for.
+        :param all_optional: Make all fields optionals. On updates it allows to send just fields you want to change.
+        :param all_nullable: Make all fields nulleables. On some kinds of updates it could meant set default value.
+        :param hide_default_null: Hide :obj:`None` as default value. It produces better examples.
+        :param include_computed_fields: Whether computed fields must be included on view or not.
+        """
+        self.view_name = view_name
+        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]:
+        """
+        Builds a view from model if it does not exist, otherwise it return already created one.
+
+        :param model: Model class.
+        :returns: View of model class.
+        """
+        manager = ensure_model_views(model)
+        try:
+            result: type[View[T] | T] = manager[self.view_name]
+        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:
+        """
+        Returns a view of model or a forward reference to it.
+
+        :param model: Model class.
+        :type model: type[T]
+        :returns: View of model class or reference to it.
+        :rtype: 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.view_name]
+        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 for m in f_info.metadata if isinstance(m, AccessMode)}
+        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]:
+        """
+        Builds a view from model
+
+        :param model: Model class.
+        :returns: View of model class.
+        """
+        from pydantic._internal._config import ConfigWrapper
+
+        view_name = model.__name__ + self.view_name[0].upper() + self.view_name[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.view_name]
+            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(model.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.view_name}` "
+                    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
+            ),
+            metadata=[m for m in f_info.metadata if not isinstance(m, AccessMode)],
+        )
+
+        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(view_name: str = "Create") -> Builder:
+    """
+    Default builder for `Create` view. Views created by it keep fields with
+    :obj:`access mode <pydantic_views.AccessMode>` :obj:`~pydantic_views.AccessMode.READ_AND_WRITE`,
+    :obj:`~pydantic_views.AccessMode.WRITE_ONLY` and :obj:`~pydantic_views.AccessMode.WRITE_ONLY_ON_CREATION`.
+    And hide default :obj:`None` value. It produces a better schema examples.
+
+    :param view_name: View name.
+    :returns: Builder configured for `Create` views.
+    """
+    return Builder(
+        view_name,
+        access_modes=(
+            AccessMode.READ_AND_WRITE,
+            AccessMode.WRITE_ONLY,
+            AccessMode.WRITE_ONLY_ON_CREATION,
+        ),
+        hide_default_null=True,
+    )
+
+
+def BuilderCreateResult(view_name: str = "CreateResult") -> Builder:
+    """
+    Default builder for `CreateResult` view. Views created by it keep fields with
+    :obj:`access mode <pydantic_views.AccessMode>` :obj:`~pydantic_views.AccessMode.READ_AND_WRITE`,
+    :obj:`~pydantic_views.AccessMode.READ_ONLY` and :obj:`~pydantic_views.AccessMode.READ_ONLY_ON_CREATION`.
+    And includes computed fields.
+
+    :param view_name: View name.
+    :returns: Builder configured for `CreateResult` views.
+    """
+    return Builder(
+        view_name,
+        access_modes=(
+            AccessMode.READ_AND_WRITE,
+            AccessMode.READ_ONLY,
+            AccessMode.READ_ONLY_ON_CREATION,
+        ),
+        include_computed_fields=True,
+    )
+
+
+def BuilderUpdate(view_name: str = "Update") -> Builder:
+    """
+    Default builder for `Update` view. Views created by it keep fields with
+    :obj:`access mode <pydantic_views.AccessMode>` :obj:`~pydantic_views.AccessMode.READ_AND_WRITE`
+    and :obj:`~pydantic_views.AccessMode.WRITE_ONLY`. And make all fields optional.
+
+    :param view_name: View name.
+    :returns: Builder configured for `Update` views.
+    """
+    return Builder(
+        view_name,
+        access_modes=(AccessMode.READ_AND_WRITE, AccessMode.WRITE_ONLY),
+        all_optional=True,
+    )
+
+
+def BuilderLoad(view_name: str = "Load") -> Builder:
+    """
+    Default builder for `Load` view. Views created by it keep fields with
+    :obj:`access mode <pydantic_views.AccessMode>` :obj:`~pydantic_views.AccessMode.READ_AND_WRITE`
+    and :obj:`~pydantic_views.AccessMode.READ_ONLY`. And includes computed fields.
+
+    :param view_name: View name.
+    :returns: Builder configured for `Load` views.
+    """
+    return Builder(
+        view_name,
+        access_modes=(
+            AccessMode.READ_AND_WRITE,
+            AccessMode.READ_ONLY,
+        ),
+        include_computed_fields=True,
+    )
+
+
+def ensure_model_views[T: BaseModel](model: type[T]):
+    """
+    Ensures model has a view manager and returns it.
+
+    :param model: Model class.
+    :returns: Views manager for model class.
+    """
+
+    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.0/src/pydantic_views/manager.py

@@ -0,0 +1,64 @@
+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]:
+    """
+    Views manager for a given model class.
+    """
+
+    __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]:
+        """
+        Associated model class.
+
+        :returns: Model class associated.
+        """
+        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"]:
+        """
+        Get a model view.
+
+        :param view_name: Name of view to get.
+        :returns: View of model class.
+        """
+        return self._views[view_name]
+
+    def __setitem__(self, view_name: str, view: type["View[TModel] | TModel"]):
+        """
+        Set a model view.
+
+        :param view_name: Name of view to get.
+        :param view: View of model class.
+        """
+        self._views[view_name] = view
+
+    def build_view(self, builder: "Builder") -> type["View[TModel] | TModel"]:
+        """
+        Build view class for Manager's model.
+
+        :param builder: Builder to use to make the view of model.
+        :returns: View of model class.
+        """
+        view = builder.build_from_model(self.model)
+        self[builder.view_name] = view
+
+        return view

pydantic_views-0.1.0/src/pydantic_views/view.py

@@ -0,0 +1,132 @@
+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):
+    """
+    View of model.
+    """
+
+    __model_class_root__: ClassVar[ReferenceType[type[BaseModel]]]
+
+    model_config = {
+        "protected_namespaces": (
+            "view_class_root",
+            "view_build_to",
+            "view_apply_to",
+            "view_build_from",
+        )
+    }
+
+    @classmethod
+    def view_class_root(cls) -> type[T]:
+        """
+        Returns the class object associated to the view.
+
+        :returns: Associated model class.
+        """
+
+        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):
+        """
+        Build view from given model.
+
+        :param model: Model class to build view from.
+        :returns: View of model class.
+        """
+        return cls.model_validate(model.model_dump(exclude_unset=True, by_alias=True))
+
+    def view_build_to(self) -> T:
+        """
+        Build associated model from view data.
+
+        :returns: Associated model instance with view data.
+        """
+
+        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:
+        """
+        Apply view data to associated model.
+
+        :param model: Model instance to use as base..
+        :returns: Associated model instance with view data merged to given model data.
+        """
+
+        return model_apply(model, self)
+
+
+class RootView[R](View[RootModel[R]], RootModel[R]):
+    """
+    View for root models.
+    """
+
+
+def model_apply[T: BaseModel](orig: T, view: View[T] | T) -> T:
+    """
+    Merge view or model into model
+    """
+
+    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)