yaddd-pydantic 0.1.0__tar.gz

yaddd_pydantic-0.1.0/.gitignore

@@ -0,0 +1,165 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/latest/usage/project/#working-with-version-control
+.pdm.toml
+.pdm-python
+.pdm-build/
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# IDE
+.idea
+.vscode/!launch.json
+.vscode/!tasks.json
+
+# OS
+.DS_Store
+
+*_old/

yaddd_pydantic-0.1.0/PKG-INFO

@@ -0,0 +1,32 @@
+Metadata-Version: 2.5
+Name: yaddd-pydantic
+Version: 0.1.0
+Summary: Pydantic v2 integration for yaddd: PydanticVO value objects as first-class model fields
+Project-URL: Homepage, https://github.com/netstuff/yaddd
+Author-email: Yuri Andreev <andreev.jr@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Internet
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.12
+Requires-Dist: pydantic>=2.10
+Requires-Dist: yaddd>=0.1
+Description-Content-Type: text/markdown
+
+# yaddd-pydantic
+Pydantic v2 integration for [yaddd](https://github.com/pyDDD/yaddd).
+
+`PydanticVO[V]` makes yaddd value objects first-class field types in pydantic
+models: pydantic constraints double as VO validation, models accept both raw
+values and VO instances, dumps produce primitives, and JSON Schema shows the
+primitive shape. `SensitiveValueObject` masking is preserved.
+
+Wiring is explicit: subclass `PydanticVO` in your domain, no auto-discovery.
+Conformance is proven by `VoSerializationContract` from `yaddd.testing`.

yaddd_pydantic-0.1.0/README.md

@@ -0,0 +1,10 @@
+# yaddd-pydantic
+Pydantic v2 integration for [yaddd](https://github.com/pyDDD/yaddd).
+
+`PydanticVO[V]` makes yaddd value objects first-class field types in pydantic
+models: pydantic constraints double as VO validation, models accept both raw
+values and VO instances, dumps produce primitives, and JSON Schema shows the
+primitive shape. `SensitiveValueObject` masking is preserved.
+
+Wiring is explicit: subclass `PydanticVO` in your domain, no auto-discovery.
+Conformance is proven by `VoSerializationContract` from `yaddd.testing`.

yaddd_pydantic-0.1.0/pyproject.toml

@@ -0,0 +1,39 @@
+[project]
+name = "yaddd-pydantic"
+description = "Pydantic v2 integration for yaddd: PydanticVO value objects as first-class model fields"
+authors = [
+    {name = "Yuri Andreev", email = "andreev.jr@gmail.com"},
+]
+license = 'MIT'
+license-files = ['LICENSE']
+classifiers = [
+    'Development Status :: 4 - Beta',
+    'Programming Language :: Python',
+    'Programming Language :: Python :: 3.12',
+    'Programming Language :: Python :: 3.13',
+    'Programming Language :: Python :: 3.14',
+    'Intended Audience :: Developers',
+    'Operating System :: OS Independent',
+    'Topic :: Software Development :: Libraries :: Python Modules',
+    'Topic :: Internet',
+]
+requires-python = '>=3.12'
+dependencies = [
+    "yaddd>=0.1",
+    "pydantic>=2.10",
+]
+version = "0.1.0"
+readme = 'README.md'
+
+[project.urls]
+Homepage = 'https://github.com/netstuff/yaddd'
+
+[tool.uv.sources]
+yaddd = { workspace = true }
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/yaddd_pydantic"]

yaddd_pydantic-0.1.0/src/yaddd_pydantic/__init__.py

@@ -0,0 +1,6 @@
+"""Pydantic v2 integration for yaddd."""
+
+from yaddd_pydantic.value_objects import PydanticVO
+
+
+__all__ = ["PydanticVO"]

yaddd_pydantic-0.1.0/src/yaddd_pydantic/value_objects.py

@@ -0,0 +1,90 @@
+"""Pydantic v2 value objects: VOs as first-class field types in pydantic models."""
+
+from typing import Any, ClassVar, Self, cast
+
+from pydantic import GetCoreSchemaHandler, GetJsonSchemaHandler, TypeAdapter
+from pydantic.json_schema import JsonSchemaValue
+from pydantic_core import CoreSchema, core_schema
+from yaddd.domain.value_object import ValueObject
+
+
+__all__ = ["PydanticVO"]
+
+
+class PydanticVO[V](ValueObject[V]):
+    """``ValueObject`` validated and serialized by pydantic v2.
+
+    Subclass and declare ``pydantic_type`` — the type pydantic uses for
+    validation and JSON Schema::
+
+        class PositiveTotal(PydanticVO[int]):
+            pydantic_type = Annotated[int, Field(gt=0)]
+
+    Behavior:
+
+    - ``validate`` runs the ``TypeAdapter(pydantic_type)`` chain, so pydantic
+      constraints double as VO validation — even outside any model;
+    - a VO field in a ``BaseModel`` accepts both a raw value (validated into
+      a VO instance) and an existing VO instance (kept as is);
+    - serialization produces the primitive: ``model_dump()`` and
+      ``model_dump_json()`` contain ``vo.value``, never a VO repr;
+    - JSON Schema (OpenAPI) shows the ``pydantic_type`` shape.
+
+    Combine with ``SensitiveValueObject`` to keep masking::
+
+        class Password(SensitiveValueObject[str], PydanticVO[str]):
+            pydantic_type = Annotated[str, Field(min_length=8)]
+
+    Masking is preserved: the model's ``repr`` uses the VO's masked
+    ``__repr__`` and ``str`` still raises ``SensitiveValueAccessError``.
+    A pydantic dump is an explicit serialization act, so ``model_dump()`` /
+    ``model_dump_json()`` contain the raw value — treat dumped output as
+    sensitive and keep it out of logs.
+    """
+
+    pydantic_type: ClassVar[Any]
+
+    _adapter_instance: ClassVar[TypeAdapter[Any] | None] = None
+
+    @classmethod
+    def validate(cls, value: V) -> V:
+        """Validate the raw value through the ``pydantic_type`` chain."""
+        return cast("V", cls._type_adapter().validate_python(value))
+
+    @classmethod
+    def __get_pydantic_core_schema__(cls, source_type: Any, handler: GetCoreSchemaHandler) -> CoreSchema:
+        """Accept raw values and VO instances; serialize to the primitive."""
+        return core_schema.no_info_plain_validator_function(
+            cls._accept,
+            serialization=core_schema.plain_serializer_function_ser_schema(
+                _serialize,
+                return_schema=cls._type_adapter().core_schema,
+            ),
+        )
+
+    @classmethod
+    def __get_pydantic_json_schema__(cls, schema: CoreSchema, handler: GetJsonSchemaHandler) -> JsonSchemaValue:
+        """JSON Schema comes from ``pydantic_type``: the primitive shape."""
+        json_schema = cls._type_adapter().json_schema()
+        json_schema["title"] = cls.__name__
+        return json_schema
+
+    @classmethod
+    def _type_adapter(cls) -> TypeAdapter[Any]:
+        """Lazily built and cached per concrete VO class."""
+        adapter = cls.__dict__.get("_adapter_instance")
+        if adapter is None:
+            adapter = TypeAdapter(cls.pydantic_type)
+            cls._adapter_instance = adapter
+        return cast("TypeAdapter[Any]", adapter)
+
+    @classmethod
+    def _accept(cls, value: Any) -> Self:
+        """Pass VO instances through; validate raw values into VOs."""
+        if isinstance(value, cls):
+            return value
+        return cls(value)
+
+
+def _serialize(vo: ValueObject[Any]) -> Any:
+    return vo.value

yaddd_pydantic-0.1.0/tests/test_pydantic_vo.py

@@ -0,0 +1,116 @@
+import json
+from collections.abc import Callable
+from typing import Annotated, Any
+
+import pytest
+from pydantic import BaseModel, Field, TypeAdapter, ValidationError
+
+from yaddd.domain import SensitiveValueObject, ValueObject
+from yaddd.testing import VoSerializationContract
+from yaddd_pydantic import PydanticVO
+
+
+class PositiveTotal(PydanticVO[int]):
+    pydantic_type = Annotated[int, Field(gt=0)]
+
+
+class Secret(SensitiveValueObject[str], PydanticVO[str]):
+    pydantic_type = Annotated[str, Field(min_length=8)]
+
+
+class OrderModel(BaseModel):
+    total: PositiveTotal
+
+
+class Credentials(BaseModel):
+    password: Secret
+
+
+def test_raw_input_becomes_vo_instance():
+    model = OrderModel(total=5)
+
+    assert isinstance(model.total, PositiveTotal)
+    assert model.total.value == 5
+
+
+def test_vo_instance_input_is_preserved():
+    total = PositiveTotal(10)
+
+    assert OrderModel(total=total).total is total
+
+
+def test_pydantic_constraint_violation_raises():
+    with pytest.raises(ValidationError):
+        OrderModel(total=-1)
+
+
+def test_vo_construction_outside_model_uses_pydantic_validation():
+    with pytest.raises(ValidationError):
+        PositiveTotal(0)
+
+
+def test_model_dump_contains_primitive():
+    dumped = OrderModel(total=5).model_dump()
+
+    assert dumped["total"] == 5
+    assert not isinstance(dumped["total"], ValueObject)
+
+
+def test_model_dump_json_contains_primitive():
+    assert json.loads(OrderModel(total=5).model_dump_json())["total"] == 5
+
+
+def test_json_schema_shows_primitive_shape():
+    schema = OrderModel.model_json_schema()
+
+    assert schema["properties"]["total"]["type"] == "integer"
+    assert schema["properties"]["total"]["exclusiveMinimum"] == 0
+
+
+def test_sensitive_vo_repr_is_masked():
+    model = Credentials(password="super-secret-1")
+
+    assert "super-secret-1" not in repr(model)
+    assert "MASKED" in repr(model)
+
+
+def test_sensitive_vo_explicit_dump_contains_raw_value():
+    assert Credentials(password="super-secret-1").model_dump()["password"] == "super-secret-1"
+
+
+def test_sensitive_vo_constraint_violation_raises():
+    with pytest.raises(ValidationError):
+        Credentials(password="short")
+
+
+class TestPydanticVoSerialization(VoSerializationContract):
+    """The contract suite proves serialization conformance via pydantic hooks."""
+
+    @pytest.fixture
+    def vo(self) -> ValueObject[Any]:
+        return PositiveTotal(5)
+
+    @pytest.fixture
+    def invalid_raw(self) -> Any:
+        return -1
+
+    @pytest.fixture
+    def dump(self) -> Callable[[ValueObject[Any]], Any]:
+        adapter: TypeAdapter[PositiveTotal] = TypeAdapter(PositiveTotal)
+        return adapter.dump_python
+
+    @pytest.fixture
+    def load(self) -> Callable[[Any], ValueObject[Any]]:
+        adapter: TypeAdapter[PositiveTotal] = TypeAdapter(PositiveTotal)
+        return adapter.validate_python
+
+    @pytest.fixture
+    def sensitive_vo(self) -> ValueObject[Any]:
+        return Secret("super-secret-1")
+
+    @pytest.fixture
+    def container_repr(self) -> Callable[[ValueObject[Any]], str]:
+        def make_repr(vo: ValueObject[Any]) -> str:
+            return repr(Credentials(password=vo))
+
+        return make_repr