value-object-pattern 1.25.0__tar.gz → 1.26.0__tar.gz

{value_object_pattern-1.25.0 → value_object_pattern-1.26.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: value-object-pattern
-Version: 1.25.0
+Version: 1.26.0
 Summary: The Value Object Pattern is a Python package that streamlines the creation and management of value objects in your projects.
 Project-URL: Homepage, https://github.com/adriamontoto/value-object-pattern
 Project-URL: Repository, https://github.com/adriamontoto/value-object-pattern

{value_object_pattern-1.25.0 → value_object_pattern-1.26.0}/value_object_pattern/__init__.py

@@ -1,11 +1,12 @@
-__version__ = '1.25.0'
+__version__ = '1.26.0'
 
 from .decorators import process, validation
-from .models import BaseModel, EnumerationValueObject, ValueObject
+from .models import BaseModel, EnumerationValueObject, UnionValueObject, ValueObject
 
 __all__ = (
     'BaseModel',
     'EnumerationValueObject',
+    'UnionValueObject',
     'ValueObject',
     'process',
     'validation',

{value_object_pattern-1.25.0 → value_object_pattern-1.26.0}/value_object_pattern/decorators/value_object_process.py

@@ -64,7 +64,7 @@ def process(order: int | None = None) -> Callable[[Callable[..., T]], Callable[.
         function._is_process = True  # type: ignore[attr-defined]
         function._order = function.__name__ if order is None else str(order)  # type: ignore[attr-defined]
 
-        @wraps(wrapped=function)
+        @wraps(function)
         def wrapper(*args: tuple[Any, ...], **kwargs: dict[str, Any]) -> T:
             """
             Wrapper for process.

{value_object_pattern-1.25.0 → value_object_pattern-1.26.0}/value_object_pattern/decorators/value_object_validation.py

@@ -72,7 +72,7 @@ def validation(
         function._order = function.__name__ if order is None else str(order)  # type: ignore[attr-defined]
         function._early_process = early_process  # type: ignore[attr-defined]
 
-        @wraps(wrapped=function)
+        @wraps(function)
         def wrapper(*args: tuple[Any, ...], **kwargs: dict[str, Any]) -> None:
             """
             Wrapper for validation.

{value_object_pattern-1.25.0 → value_object_pattern-1.26.0}/value_object_pattern/models/__init__.py

@@ -1,9 +1,11 @@
 from .base_model import BaseModel
 from .enumeration_value_object import EnumerationValueObject
+from .union_value_object import UnionValueObject
 from .value_object import ValueObject
 
 __all__ = (
     'BaseModel',
     'EnumerationValueObject',
+    'UnionValueObject',
     'ValueObject',
 )

{value_object_pattern-1.25.0 → value_object_pattern-1.26.0}/value_object_pattern/models/base_model.py

@@ -13,11 +13,12 @@ else:
 
 from abc import ABC, abstractmethod
 from copy import deepcopy
-from enum import Enum
 from inspect import Parameter, _empty, signature
-from typing import Any, NoReturn, Self
+from types import UnionType
+from typing import Any, NoReturn, Self, Union, get_args, get_origin, get_type_hints
 
-from .value_object import ValueObject
+from .primitive_conversion import from_primitive, to_primitive
+from .type_matching import matches_expected_type
 
 
 class BaseModel(ABC):
@@ -387,7 +388,83 @@ class BaseModel(ABC):
         if missing or extra:
             cls._raise_value_constructor_parameters_mismatch(primitives=set(primitives), missing=missing, extra=extra)
 
-        return cls(**primitives)
+        constructor_annotations = cls._get_constructor_annotations()
+        converted_primitives: dict[str, Any] = {}
+        for parameter_name in parameters:
+            if parameter_name not in primitives:
+                continue
+
+            expected_type = constructor_annotations.get(parameter_name, parameters[parameter_name].annotation)
+            converted_value = from_primitive(
+                value=primitives[parameter_name],
+                expected_type=expected_type,
+            )
+            if get_origin(tp=expected_type) in (Union, UnionType) and not matches_expected_type(
+                value=converted_value,
+                expected_type=expected_type,
+            ):
+                cls._raise_value_is_not_of_type(
+                    parameter=parameter_name,
+                    value=converted_value,
+                    expected_type=expected_type,
+                )
+
+            converted_primitives[parameter_name] = converted_value
+
+        return cls(**converted_primitives)
+
+    @classmethod
+    def _get_constructor_annotations(cls) -> dict[str, Any]:
+        """
+        Returns resolved constructor annotations when available.
+
+        Returns:
+            dict[str, Any]: Mapping from constructor parameter names to annotations.
+        """
+        try:
+            return get_type_hints(cls.__init__)
+
+        except Exception:
+            return {}
+
+    @classmethod
+    def _raise_value_is_not_of_type(cls, *, parameter: str, value: Any, expected_type: Any) -> NoReturn:
+        """
+        Raises a TypeError when a primitive cannot be converted to the expected type.
+
+        Args:
+            parameter (str): Constructor parameter name.
+            value (Any): Converted value.
+            expected_type (Any): Expected type annotation.
+
+        Raises:
+            TypeError: When value is not of expected type.
+        """
+        raise TypeError(f'{cls.__name__} parameter <<<{parameter}>>> value <<<{value}>>> must be of type <<<{cls._type_label(type=expected_type)}>>> type. Got <<<{type(value).__name__}>>> type.')  # noqa: E501  # fmt: skip
+
+    @staticmethod
+    def _type_label(*, type: Any) -> str:
+        """
+        Returns a readable label for the given type annotation.
+
+        Args:
+            type (Any): Type annotation.
+
+        Returns:
+            str: Formatted type label.
+        """
+        origin = get_origin(tp=type)
+        if origin in (Union, UnionType):
+            parts = [BaseModel._type_label(type=item) for item in get_args(type)]
+            return ' | '.join(parts)
+
+        if type is Any:
+            return 'Any'
+
+        if hasattr(type, '__name__'):
+            return type.__name__  # type: ignore[no-any-return]
+
+        return str(type).replace('typing.', '')
 
     @classmethod
     def _raise_value_is_not_dict_of_strings(cls, value: Any) -> NoReturn:
@@ -457,32 +534,8 @@ class BaseModel(ABC):
         # >>> {'name': 'John Doe', 'birthdate': '1900-01-01T00:00:00+00:00'}
         ```
         """
-        primitive_types: tuple[type, ...] = (int, float, str, bool, bytes, bytearray, memoryview, type(None))
-        collection_types: tuple[type, ...] = (list, dict, tuple, set, frozenset)
-
         dictionary = self._to_dict(ignore_private=True)
         for key, value in dictionary.items():
-            if isinstance(value, BaseModel) or hasattr(value, 'to_primitives'):
-                value = value.to_primitives()
-
-            elif isinstance(value, Enum):
-                value = value.value
-
-            elif isinstance(value, ValueObject) or hasattr(value, 'value'):
-                value = value.value
-
-                if isinstance(value, Enum):
-                    value = value.value
-
-            elif isinstance(value, primitive_types):  # noqa: SIM114
-                pass
-
-            elif isinstance(value, collection_types):
-                pass
-
-            else:
-                value = str(object=value)
-
-            dictionary[key] = value
+            dictionary[key] = to_primitive(value=value)
 
         return dictionary

{value_object_pattern-1.25.0 → value_object_pattern-1.26.0}/value_object_pattern/models/collections/dict_value_object.py

@@ -12,13 +12,14 @@ else:
     from typing_extensions import override  # pragma: no cover
 
 from collections.abc import Iterator
-from enum import Enum
 from inspect import isclass
 from types import UnionType
 from typing import Any, Generic, ItemsView, KeysView, NoReturn, Self, TypeVar, Union, ValuesView, get_args, get_origin
 
 from value_object_pattern.decorators import validation
-from value_object_pattern.models import BaseModel, ValueObject
+from value_object_pattern.models import ValueObject
+from value_object_pattern.models.primitive_conversion import from_primitive, to_primitive
+from value_object_pattern.models.type_matching import matches_expected_type
 
 K = TypeVar('K', bound=Any)
 V = TypeVar('V', bound=Any)
@@ -325,25 +326,8 @@ class DictValueObject(ValueObject[dict[K, V]], Generic[K, V]):  # noqa: UP046
         if self._key_type is Any:
             return
 
-        origin = get_origin(tp=self._key_type)
-        if origin in (Union, UnionType):
-            allowed_types: list[type[Any] | UnionType] = []
-            for allowed in get_args(self._key_type):
-                if allowed is Any:
-                    return
-
-                allowed_origin = get_origin(tp=allowed)
-                allowed_types.append(allowed_origin or allowed)
-
-            for key in value.keys():  # noqa: SIM118
-                if not any(isinstance(key, allowed) for allowed in allowed_types):
-                    self._raise_key_is_not_of_type(value=key)
-
-            return
-
-        expected_type = origin or self._key_type
         for key in value.keys():  # noqa: SIM118
-            if not isinstance(key, expected_type):
+            if not matches_expected_type(value=key, expected_type=self._key_type):
                 self._raise_key_is_not_of_type(value=key)
 
     def _raise_key_is_not_of_type(self, value: Any) -> NoReturn:
@@ -372,25 +356,8 @@ class DictValueObject(ValueObject[dict[K, V]], Generic[K, V]):  # noqa: UP046
         if self._value_type is Any:
             return
 
-        origin = get_origin(tp=self._value_type)
-        if origin in (Union, UnionType):
-            allowed_types: list[type[Any] | UnionType] = []
-            for allowed in get_args(self._value_type):
-                if allowed is Any:
-                    return
-
-                allowed_origin = get_origin(tp=allowed)
-                allowed_types.append(allowed_origin or allowed)
-
-            for item in value.values():
-                if not any(isinstance(item, allowed) for allowed in allowed_types):
-                    self._raise_value_is_not_of_type(value=item)
-
-            return
-
-        expected_type = origin or self._value_type
         for item in value.values():
-            if not isinstance(item, expected_type):
+            if not matches_expected_type(value=item, expected_type=self._value_type):
                 self._raise_value_is_not_of_type(value=item)
 
     def _raise_value_is_not_of_type(self, value: Any) -> NoReturn:
@@ -430,7 +397,7 @@ class DictValueObject(ValueObject[dict[K, V]], Generic[K, V]):  # noqa: UP046
         # >>> 3
         ```
         """
-        if default is not None and not self._is_instance_of_type(value=default, expected_type=self._value_type):
+        if default is not None and not matches_expected_type(value=default, expected_type=self._value_type):
             self._raise_value_is_not_of_type(value=default)
 
         return self._value.get(key, default)
@@ -458,36 +425,6 @@ class DictValueObject(ValueObject[dict[K, V]], Generic[K, V]):  # noqa: UP046
         """
         return not self._value
 
-    @staticmethod
-    def _is_instance_of_type(*, value: Any, expected_type: Any) -> bool:
-        """
-        Checks if the value matches the expected type, supporting unions and Any.
-
-        Args:
-            value (Any): The value to check.
-            expected_type (Any): The expected type or typing annotation.
-
-        Returns:
-            bool: True if the value matches the expected type, otherwise False.
-        """
-        if expected_type is Any:
-            return True
-
-        origin = get_origin(tp=expected_type)
-        if origin in (Union, UnionType):
-            for allowed in get_args(expected_type):
-                if allowed is Any:
-                    return True
-
-                allowed_origin = get_origin(tp=allowed) or allowed
-                if isinstance(value, allowed_origin):
-                    return True
-
-            return False
-
-        expected = origin or expected_type
-        return isinstance(value, expected)
-
     @staticmethod
     def _type_label(*, type: Any) -> str:
         """
@@ -535,50 +472,36 @@ class DictValueObject(ValueObject[dict[K, V]], Generic[K, V]):  # noqa: UP046
 
         Returns:
             Self: The created DictValueObject.
-        """
-        items: dict[Any, Any] = {}
-
-        for key, item in value.items():
-            primitive_key = cls._convert_from_primitives(value=key, expected_type=cls._key_type)
-            primitive_value = cls._convert_from_primitives(value=item, expected_type=cls._value_type)
-            items[primitive_key] = primitive_value
 
-        return cls(value=items)
-
-    @classmethod
-    def _convert_from_primitives(cls, *, value: Any, expected_type: Any) -> Any:
-        """
-        Converts a primitive value to the expected type.
+        Example:
+        ```python
+        from value_object_pattern.models import ValueObject
+        from value_object_pattern.models.collections import DictValueObject
 
-        Args:
-            value (Any): The primitive value to convert.
-            expected_type (Any): The expected type.
 
-        Returns:
-            Any: The converted value.
-        """
-        if expected_type is Any:
-            return value
+        class Age(ValueObject[int]):
+            pass
 
-        origin = get_origin(tp=expected_type)
-        if origin in (Union, UnionType):
-            return value
 
-        if hasattr(expected_type, 'from_primitives'):
-            return expected_type.from_primitives(value)
+        class StrAgeDict(DictValueObject[str, Age]):
+            pass
 
-        if isclass(expected_type) and issubclass(expected_type, Enum):
-            if isinstance(value, expected_type):
-                return value
 
-            return expected_type(value)
+        dictionary = StrAgeDict.from_primitives(value={'john': 30, 'jane': 25})
+        print({key: age.value for key, age in dictionary.items()})
+        # >>> {'john': 30, 'jane': 25}
+        ```
+        """
+        dictionary: dict[Any, Any] = {}
 
-        if hasattr(expected_type, 'value'):
-            return expected_type(value=value)
+        for key, item in value.items():
+            primitive_key = from_primitive(value=key, expected_type=cls._key_type)
+            primitive_value = from_primitive(value=item, expected_type=cls._value_type)
+            dictionary[primitive_key] = primitive_value
 
-        return value
+        return cls(value=dictionary)
 
-    def to_primitives(self) -> dict[Any, Any]:  # noqa: C901
+    def to_primitives(self) -> dict[Any, Any]:
         """
         Returns the dictionary as a dictionary of primitives, recursively converting each key and value.
 
@@ -604,59 +527,10 @@ class DictValueObject(ValueObject[dict[K, V]], Generic[K, V]):  # noqa: UP046
         # >>> {'john': 30, 'jane': 25}
         ```
         """
-        primitive_types: tuple[type, ...] = (int, float, str, bool, bytes, bytearray, memoryview, type(None))
-        collection_types: tuple[type, ...] = (list, dict, tuple, set, frozenset)
-
-        primitives_dict: dict[Any, Any] = {}
+        dictionary: dict[Any, Any] = {}
         for key, value in self._value.items():
-            primitive_key = key
-            if isinstance(key, BaseModel) or hasattr(key, 'to_primitives'):
-                primitive_key = key.to_primitives()  # type: ignore[assignment]
-
-            elif isinstance(key, Enum):
-                primitive_key = key.value
-
-            elif isinstance(key, ValueObject) or hasattr(key, 'value'):
-                key_value = key.value
-
-                if isinstance(key_value, Enum):
-                    key_value = key_value.value
-
-                primitive_key = key_value
-
-            elif isinstance(key, primitive_types):  # noqa: SIM114
-                pass
-
-            elif isinstance(key, collection_types):
-                pass
-
-            else:
-                primitive_key = str(object=key)  # type: ignore[assignment]
-
-            primitive_value = value
-            if isinstance(value, BaseModel) or hasattr(value, 'to_primitives'):
-                primitive_value = value.to_primitives()  # type: ignore[assignment]
-
-            elif isinstance(value, Enum):
-                primitive_value = value.value
-
-            elif isinstance(value, ValueObject) or hasattr(value, 'value'):
-                val_value = value.value
-
-                if isinstance(val_value, Enum):
-                    val_value = val_value.value
-
-                primitive_value = val_value
-
-            elif isinstance(value, primitive_types):  # noqa: SIM114
-                pass
-
-            elif isinstance(value, collection_types):
-                pass
-
-            else:
-                primitive_value = str(object=value)  # type: ignore[assignment]
-
-            primitives_dict[primitive_key] = primitive_value
+            primitive_key = to_primitive(value=key)
+            primitive_value = to_primitive(value=value)
+            dictionary[primitive_key] = primitive_value
 
-        return primitives_dict
+        return dictionary

{value_object_pattern-1.25.0 → value_object_pattern-1.26.0}/value_object_pattern/models/collections/list_value_object.py

@@ -19,6 +19,8 @@ from typing import Any, Generic, NoReturn, Self, TypeVar, Union, get_args, get_o
 
 from value_object_pattern.decorators import validation
 from value_object_pattern.models import BaseModel, ValueObject
+from value_object_pattern.models.primitive_conversion import from_primitive, to_primitive
+from value_object_pattern.models.type_matching import matches_expected_type
 
 T = TypeVar('T', bound=Any)
 
@@ -313,25 +315,8 @@ class ListValueObject(ValueObject[list[T]], Generic[T]):  # noqa: UP046
         if self._type is Any:
             return
 
-        origin = get_origin(tp=self._type)
-        if origin in (Union, UnionType):
-            allowed_types: list[type[Any] | UnionType] = []
-            for allowed in get_args(self._type):
-                if allowed is Any:
-                    return
-
-                allowed_origin = get_origin(tp=allowed)
-                allowed_types.append(allowed_origin or allowed)
-
-            for item in value:
-                if not any(isinstance(item, allowed) for allowed in allowed_types):
-                    self._raise_value_is_not_of_type(value=item)
-
-            return
-
-        expected_type = origin or self._type
         for item in value:
-            if not isinstance(item, expected_type):
+            if not matches_expected_type(value=item, expected_type=self._type):
                 self._raise_value_is_not_of_type(value=item)
 
     def _raise_value_is_not_of_type(self, value: Any) -> NoReturn:
@@ -436,7 +421,7 @@ class ListValueObject(ValueObject[list[T]], Generic[T]):  # noqa: UP046
         # >>> False
         ```
         """
-        item = self._convert_from_primitives(value=item)
+        item = from_primitive(value=item, expected_type=self._type)
 
         return self.add(item=item)
 
@@ -507,7 +492,7 @@ class ListValueObject(ValueObject[list[T]], Generic[T]):  # noqa: UP046
         # >>> False
         ```
         """
-        items = [self._convert_from_primitives(value=item) for item in items]
+        items = [from_primitive(value=item, expected_type=self._type) for item in items]
 
         return self.extend(items=items)
 
@@ -598,7 +583,7 @@ class ListValueObject(ValueObject[list[T]], Generic[T]):  # noqa: UP046
         # >>> False
         ```
         """
-        item = self._convert_from_primitives(value=item)
+        item = from_primitive(value=item, expected_type=self._type)
 
         return self.delete(item=item)
 
@@ -675,31 +660,10 @@ class ListValueObject(ValueObject[list[T]], Generic[T]):  # noqa: UP046
         # >>> False
         ```
         """
-        items = [self._convert_from_primitives(value=item) for item in items]
+        items = [from_primitive(value=item, expected_type=self._type) for item in items]
 
         return self.delete_all(items=items)
 
-    def _convert_from_primitives(self, *, value: Any) -> T:
-        """
-        Converts a primitive value to the appropriate type T.
-
-        Args:
-            value (Any): The primitive value to convert.
-
-        Returns:
-            T: The converted value.
-        """
-        if hasattr(self._type, 'from_primitives'):
-            return self._type.from_primitives(value)  # type: ignore[no-any-return]
-
-        if get_origin(tp=self._type) in (Union, UnionType):
-            return value  # type: ignore[no-any-return]
-
-        if hasattr(self._type, 'value'):
-            return self._type(value=value)  # type: ignore[no-any-return]
-
-        return value  # type: ignore[no-any-return]
-
     def _type_label(self) -> str:
         """
         Returns a readable label for the configured type, including unions.
@@ -743,20 +707,27 @@ class ListValueObject(ValueObject[list[T]], Generic[T]):  # noqa: UP046
 
         Returns:
             Self: The created ListValueObject.
-        """
-        items: list[Any] = []
 
-        for item in value:
-            if hasattr(cls._type, 'from_primitives'):
-                items.append(cls._type.from_primitives(item))  # BaseModel
+        Example:
+        ```python
+        from value_object_pattern.models import ValueObject
+        from value_object_pattern.models.collections import ListValueObject
 
-            elif hasattr(cls._type, 'value'):
-                items.append(cls._type(value=item))  # ValueObject
 
-            else:
-                items.append(item)
+        class Age(ValueObject[int]):
+            pass
 
-        return cls(value=items)
+
+        class AgeListValueObject(ListValueObject[Age]):
+            pass
+
+
+        age_list = AgeListValueObject.from_primitives(value=[10, 20, 30])
+        print([age.value for age in age_list])
+        # >>> [10, 20, 30]
+        ```
+        """
+        return cls(value=[from_primitive(value=item, expected_type=cls._type) for item in value])
 
     def to_primitives(self) -> list[Any]:
         """
@@ -784,32 +755,4 @@ class ListValueObject(ValueObject[list[T]], Generic[T]):  # noqa: UP046
         # >>> [10, 20]
         ```
         """
-        primitive_types: tuple[type, ...] = (int, float, str, bool, bytes, bytearray, memoryview, type(None))
-        collection_types: tuple[type, ...] = (list, dict, tuple, set, frozenset)
-
-        primitives_list: list[Any] = []
-        for item in self._value:
-            if isinstance(item, BaseModel) or hasattr(item, 'to_primitives'):
-                primitives_list.append(item.to_primitives())
-
-            elif isinstance(item, Enum):
-                primitives_list.append(item.value)
-
-            elif isinstance(item, ValueObject) or hasattr(item, 'value'):
-                value = item.value
-
-                if isinstance(value, Enum):
-                    value = value.value
-
-                primitives_list.append(value)
-
-            elif isinstance(item, primitive_types):  # noqa: SIM114
-                primitives_list.append(item)
-
-            elif isinstance(item, collection_types):
-                primitives_list.append(item)
-
-            else:
-                primitives_list.append(str(object=item))
-
-        return primitives_list
+        return [to_primitive(value=item) for item in self._value]