value-object-pattern 0.9.2__tar.gz → 0.10.0__tar.gz

{value_object_pattern-0.9.2 → value_object_pattern-0.10.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: value-object-pattern
-Version: 0.9.2
+Version: 0.10.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-0.9.2 → value_object_pattern-0.10.0}/value_object_pattern/__init__.py

@@ -1,4 +1,4 @@
-__version__ = '0.9.2'
+__version__ = '0.10.0'
 
 from .decorators import process, validation
 from .models import BaseModel, EnumerationValueObject, ValueObject

{value_object_pattern-0.9.2 → value_object_pattern-0.10.0}/value_object_pattern/models/base_model.py

@@ -11,6 +11,7 @@ else:
 
 from abc import ABC, abstractmethod
 from enum import Enum
+from inspect import Parameter, _empty, signature
 from typing import Any, NoReturn, Self
 
 from .value_object import ValueObject
@@ -267,6 +268,7 @@ class BaseModel(ABC):
 
         Raises:
             TypeError: If the `primitives` is not a dictionary of strings.
+            ValueError: If the `primitives` does not have all the required attributes.
 
         Returns:
             Self: Instance of the class.
@@ -297,6 +299,14 @@ class BaseModel(ABC):
         if not isinstance(primitives, dict) or not all(isinstance(key, str) for key in primitives):  # type: ignore[redundant-expr]
             cls._raise_value_is_not_dict_of_strings(value=primitives)
 
+        constructor_signature = signature(obj=cls.__init__)
+        parameters: dict[str, Parameter] = {parameter.name: parameter for parameter in constructor_signature.parameters.values() if parameter.name != 'self'}  # noqa: E501  # fmt: skip
+        missing = {name for name, parameter in parameters.items() if parameter.default is _empty and name not in primitives}  # noqa: E501  # fmt: skip
+        extra = set(primitives) - parameters.keys()
+
+        if missing or extra:
+            cls._raise_value_constructor_parameters_mismatch(primitives=set(primitives), missing=missing, extra=extra)
+
         return cls(**primitives)
 
     @classmethod
@@ -312,6 +322,30 @@ class BaseModel(ABC):
         """
         raise TypeError(f'{cls.__name__} primitives <<<{value}>>> must be a dictionary of strings. Got <<<{type(value).__name__}>>> type.')  # noqa: E501  # fmt: skip
 
+    @classmethod
+    def _raise_value_constructor_parameters_mismatch(
+        cls,
+        primitives: set[str],
+        missing: set[str],
+        extra: set[str],
+    ) -> NoReturn:
+        """
+        Raises a ValueError if the value object constructor parameters do not match the provided primitives.
+
+        Args:
+            primitives (set[str]): Set of primitives keys. Only the keys are used to not expose private attributes.
+            missing (set[str]): Set of missing parameters.
+            extra (set[str]): Set of extra parameters.
+
+        Raises:
+            ValueError: If the constructor parameters do not match the provided primitives.
+        """
+        primitives_names = ', '.join(sorted(primitives))
+        missing_names = ', '.join(sorted(missing))
+        extra_names = ', '.join(sorted(extra))
+
+        raise ValueError(f'{cls.__name__} primitives <<<{primitives_names}>>> must contain all constructor parameters. Missing parameters: <<<{missing_names}>> and extra parameters: <<<{extra_names}>>>.')  # noqa: E501  # fmt: skip
+
     def to_primitives(self) -> dict[str, Any]:
         """
         Returns the class as a dictionary of its primitives. Private attributes that start with "__" are not included,
@@ -367,7 +401,7 @@ class BaseModel(ABC):
                 pass
 
             else:
-                value = str(value)
+                value = str(object=value)
 
             dictionary[key] = value
 

value_object_pattern-0.10.0/value_object_pattern/models/collections/__init__.py

@@ -0,0 +1,3 @@
+from .list_value_object import ListValueObject
+
+__all__ = ('ListValueObject',)

value_object_pattern-0.10.0/value_object_pattern/models/collections/list_value_object.py

@@ -0,0 +1,376 @@
+"""
+ListValueObject module.
+"""
+
+from sys import version_info
+
+if version_info >= (3, 12):
+    from typing import override  # pragma: no cover
+else:
+    from typing_extensions import override  # pragma: no cover
+
+from collections.abc import Iterator
+from enum import Enum
+from inspect import isclass
+from typing import Any, Generic, NoReturn, Self, TypeVar, get_args, get_origin
+
+from value_object_pattern.decorators import validation
+from value_object_pattern.models import BaseModel, ValueObject
+
+T = TypeVar('T', bound=Any)
+
+
+class ListValueObject(ValueObject[list[T]], Generic[T]):  # noqa: UP046
+    """
+    ListValueObject is a value object that ensures the provided value is from a list.
+
+    Example:
+    ```python
+    from value_object_pattern.models.collections import ListValueObject
+
+
+    class IntListValueObject(ListValueObject[int]):
+        pass
+
+
+    sequence = IntListValueObject(value=[1, 2, 3])
+    print(sequence)
+    # >>> [1, 2, 3]
+    ```
+    """
+
+    _type: T
+
+    @override
+    def __init_subclass__(cls, **kwargs: Any) -> None:
+        """
+        Initializes the class.
+
+        Args:
+            **kwargs (Any): Keyword arguments.
+
+        Raises:
+            TypeError: If the class parameter is not a type.
+            TypeError: If the class is not parameterized.
+        """
+        super().__init_subclass__(**kwargs)
+
+        for base in getattr(cls, '__orig_bases__', ()):
+            if get_origin(tp=base) is ListValueObject:
+                _type, *_ = get_args(tp=base)
+
+                if isinstance(_type, TypeVar):
+                    cls._type = _type
+                    return
+
+                if type(_type) is not type and not isclass(object=_type) and get_origin(tp=_type) is None:
+                    raise TypeError(f'ListValueObject[...] <<<{_type}>>> must be a type. Got <<<{type(_type).__name__}>>> type.')  # noqa: E501  # fmt: skip
+
+                cls._type = _type
+                return
+
+        raise TypeError('ListValueObject must be parameterized, e.g. "class InIntListValueObject(ListValueObject[int])".')  # noqa: E501  # fmt: skip
+
+    def __contains__(self, item: Any) -> bool:
+        """
+        Returns True if the value object value contains the item, otherwise False.
+
+        Args:
+            item (Any): The item to check.
+
+        Returns:
+            bool: True if the value object value contains the item, otherwise False.
+
+        Example:
+        ```python
+        from value_object_pattern.models.collections import ListValueObject
+
+
+        class IntListValueObject(ListValueObject[int]):
+            pass
+
+
+        sequence = IntListValueObject(value=[1, 2, 3])
+        print(1 in sequence)
+        # >>> True
+        ```
+        """
+        return item in self._value
+
+    def __iter__(self) -> Iterator[T]:
+        """
+        Returns an iterator over the value object value.
+
+        Returns:
+            Iterator[T]: An iterator over the value object value.
+
+        Example:
+        ```python
+        from value_object_pattern.models.collections import ListValueObject
+
+
+        class IntListValueObject(ListValueObject[int]):
+            pass
+
+
+        sequence = IntListValueObject(value=[1, 2, 3])
+        print(list(sequence))
+        # >>> [1, 2, 3]
+        ```
+        """
+        return iter(self._value)
+
+    def __len__(self) -> int:
+        """
+        Returns the length of the value object value.
+
+        Returns:
+            int: The length of the value object value.
+
+        Example:
+        ```python
+        from value_object_pattern.models.collections import ListValueObject
+
+
+        class IntListValueObject(ListValueObject[int]):
+            pass
+
+
+        sequence = IntListValueObject(value=[1, 2, 3])
+        print(len(sequence))
+        # >>> 3
+        ```
+        """
+        return len(self._value)
+
+    def __reversed__(self) -> Iterator[T]:
+        """
+        Returns a reversed iterator over the value object value.
+
+        Returns:
+            Iterator[T]: A reversed iterator over the value object value.
+
+        Example:
+        ```python
+        from value_object_pattern.models.collections import ListValueObject
+
+
+        class IntListValueObject(ListValueObject[int]):
+            pass
+
+
+        sequence = IntListValueObject(value=[1, 2, 3])
+        print(list(reversed(sequence)))
+        # >>> [3, 2, 1]
+        ```
+        """
+        return reversed(self._value)
+
+    @override
+    def __repr__(self) -> str:
+        """
+        Returns the string representation of the value object value.
+
+        Returns:
+            str: The string representation of the value object value.
+
+        Example:
+        ```python
+        from value_object_pattern.models.collections import ListValueObject
+
+
+        class IntListValueObject(ListValueObject[int]):
+            pass
+
+
+        sequence = IntListValueObject(value=[1, 2, 3])
+        print(repr(sequence))
+        # >>> [1, 2, 3]
+        ```
+        """
+        primitive_types: tuple[type, ...] = (int, float, str, bool, bytes, bytearray, memoryview, type(None))
+        collection_types: tuple[type, ...] = (list, dict, tuple, set, frozenset)
+
+        list_to_return: list[Any] = []
+        for item in self._value:
+            if isinstance(item, BaseModel):
+                list_to_return.append(repr(item))
+
+            elif isinstance(item, Enum):
+                list_to_return.append(item.value)
+
+            elif isinstance(item, ValueObject) or hasattr(item, 'value'):
+                value = item.value
+
+                if isinstance(value, Enum):
+                    value = value.value
+
+                list_to_return.append(repr(value))
+
+            elif isinstance(item, primitive_types):  # noqa: SIM114
+                list_to_return.append(item)
+
+            elif isinstance(item, collection_types):
+                list_to_return.append(repr(item))
+
+            else:
+                list_to_return.append(repr(item))
+
+        return repr(list_to_return)
+
+    @override
+    def __str__(self) -> str:
+        """
+        Returns the string representation of the value object value.
+
+        Returns:
+            str: The string representation of the value object value.
+
+        Example:
+        ```python
+        from value_object_pattern.models.collections import ListValueObject
+
+
+        class IntListValueObject(ListValueObject[int]):
+            pass
+
+
+        sequence = IntListValueObject(value=[1, 2, 3])
+        print(str(sequence))
+        # >>> [1, 2, 3]
+        ```
+        """
+        primitive_types: tuple[type, ...] = (int, float, str, bool, bytes, bytearray, memoryview, type(None))
+        collection_types: tuple[type, ...] = (list, dict, tuple, set, frozenset)
+
+        list_to_return: list[Any] = []
+        for item in self._value:
+            if isinstance(item, BaseModel):
+                list_to_return.append(str(object=item))
+
+            elif isinstance(item, Enum):
+                list_to_return.append(item.value)
+
+            elif isinstance(item, ValueObject) or hasattr(item, 'value'):
+                value = item.value
+
+                if isinstance(value, Enum):
+                    value = value.value
+
+                list_to_return.append(str(object=value))
+
+            elif isinstance(item, primitive_types):  # noqa: SIM114
+                list_to_return.append(item)
+
+            elif isinstance(item, collection_types):
+                list_to_return.append(str(object=item))
+
+            else:
+                list_to_return.append(str(object=item))
+
+        return str(object=list_to_return)
+
+    @validation(order=0)
+    def _ensure_value_is_from_list(self, value: list[Any]) -> None:
+        """
+        Ensures the value object `value` is a list.
+
+        Args:
+            value (list[Any]): The provided value.
+
+        Raises:
+            TypeError: If the `value` is not a list.
+        """
+        if not isinstance(value, list):
+            self._raise_value_is_not_list(value=value)
+
+    def _raise_value_is_not_list(self, value: Any) -> NoReturn:
+        """
+        Raises a TypeError if the value object `value` is not a list.
+
+        Args:
+            value (Any): The provided value.
+
+        Raises:
+            TypeError: If the `value` is not a list.
+        """
+        raise TypeError(f'ListValueObject value <<<{value}>>> must be a list. Got <<<{type(value).__name__}>>> type.')  # noqa: E501  # fmt: skip
+
+    @validation(order=1)
+    def _ensure_value_is_of_type(self, value: list[T]) -> None:
+        """
+        Ensures the value object `value` is of type `T`.
+
+        Args:
+            value (list[T]): The provided value.
+
+        Raises:
+            TypeError: If the `value` is not of type `T`.
+        """
+        if self._type is Any:
+            return
+
+        expected_type = get_origin(tp=self._type) or self._type
+        for item in value:
+            if not isinstance(item, expected_type):
+                self._raise_value_is_not_of_type(value=item)
+
+    def _raise_value_is_not_of_type(self, value: Any) -> NoReturn:
+        """
+        Raises a TypeError if the value object `value` is not of type `T`.
+
+        Args:
+            value (Any): The provided value.
+
+        Raises:
+            TypeError: If the `value` is not of type `T`.
+        """
+        raise TypeError(f'ListValueObject value <<<{value}>>> must be of type <<<{self._type.__name__}>>> type. Got <<<{type(value).__name__}>>> type.')  # noqa: E501  # fmt: skip
+
+    def is_empty(self) -> bool:
+        """
+        Returns True if the value object value is empty, otherwise False.
+
+        Returns:
+            bool: True if the value object value is empty, otherwise False.
+
+        Example:
+        ```python
+        from value_object_pattern.models.collections import ListValueObject
+
+
+        class IntListValueObject(ListValueObject[int]):
+            pass
+
+
+        sequence = IntListValueObject(value=[1, 2, 3])
+        print(sequence.is_empty())
+        # >>> False
+        ```
+        """
+        return not self._value
+
+    @classmethod
+    def from_primitives(cls, value: list[Any]) -> Self:
+        """
+        Creates a ListValueObject from a list of primitives.
+
+        Args:
+            value (list[Any]): The list of primitives.
+
+        Returns:
+            Self: The created ListValueObject.
+        """
+        items: list[Any] = []
+
+        for primitive in value:
+            if hasattr(cls._type, 'from_primitives'):
+                items.append(cls._type.from_primitives(primitive))  # BaseModel
+
+            elif hasattr(cls._type, 'value'):
+                items.append(cls._type(value=primitive))  # ValueObject
+
+            else:
+                items.append(primitive)
+
+        return cls(value=items)

{value_object_pattern-0.9.2 → value_object_pattern-0.10.0}/value_object_pattern/models/enumeration_value_object.py

@@ -14,7 +14,8 @@ from inspect import isclass
 from typing import Any, Generic, NoReturn, TypeVar, get_args, get_origin
 
 from value_object_pattern.decorators import process, validation
-from value_object_pattern.models.value_object import ValueObject
+
+from .value_object import ValueObject
 
 E = TypeVar('E', bound=Enum)
 
@@ -78,72 +79,6 @@ class EnumerationValueObject(ValueObject[Any | E], Generic[E]):  # noqa: UP046
 
         raise TypeError('EnumerationValueObject must be parameterized, e.g. "class ColorValueObject(EnumerationValueObject[ColorEnumeration])".')  # noqa: E501  # fmt: skip
 
-    @override
-    def __repr__(self) -> str:
-        """
-        Returns a detailed string representation of the value object.
-
-        Returns:
-            str: A string representation of the value object in the format 'ClassName(value=value)'.
-
-        Example:
-        ```python
-        from enum import Enum, unique
-
-        from value_object_pattern import EnumerationValueObject
-
-
-        @unique
-        class ColorEnumeration(Enum):
-            RED = 1
-            GREEN = 2
-            BLUE = 3
-
-
-        class ColorValueObject(EnumerationValueObject[ColorEnumeration]):
-            pass
-
-
-        red = ColorValueObject(value=ColorEnumeration.RED)
-        print(repr(red))
-        # >>> ColorValueObject(value=ColorEnumeration.RED)
-        ```
-        """
-        return f'{self.__class__.__name__}(value={self.value!r})'
-
-    @override
-    def __str__(self) -> str:
-        """
-        Returns a simple string representation of the value object.
-
-        Returns:
-            str: The string representation of the value object value.
-
-        Example:
-        ```python
-        from enum import Enum, unique
-
-        from value_object_pattern import EnumerationValueObject
-
-
-        @unique
-        class ColorEnumeration(Enum):
-            RED = 1
-            GREEN = 2
-            BLUE = 3
-
-
-        class ColorValueObject(EnumerationValueObject[ColorEnumeration]):
-            pass
-
-
-        red = ColorValueObject(value=ColorEnumeration.RED)
-        print(str(red))
-        # >>> 1
-        ```
-        """
-        return str(object=self._value.value)
-
     @process(order=0)
     def _ensure_value_is_stored_as_enumeration(self, value: Any | E) -> E:
         """
@@ -209,16 +144,25 @@ class EnumerationValueObject(ValueObject[Any | E], Generic[E]):  # noqa: UP046
 
         Example:
         ```python
-        from value_object_pattern import ValueObject
+        from enum import Enum, unique
+
+        from value_object_pattern import EnumerationValueObject
+
+
+        @unique
+        class ColorEnumeration(Enum):
+            RED = 1
+            GREEN = 2
+            BLUE = 3
 
 
-        class IntegerValueObject(ValueObject[int]):
+        class ColorValueObject(EnumerationValueObject[ColorEnumeration]):
             pass
 
 
-        integer = IntegerValueObject(value=10)
-        print(integer.value)
-        # >>> 10
+        red = ColorValueObject(value=ColorEnumeration.RED)
+        print(red.value)
+        # >>> ColorEnumeration.RED
         ```
         """
         return self._value

{value_object_pattern-0.9.2 → value_object_pattern-0.10.0}/value_object_pattern/models/value_object.py

@@ -131,7 +131,7 @@ class ValueObject(ABC, Generic[T]):  # noqa: UP046
         # >>> IntegerValueObject(value=10)
         ```
         """
-        return f'{self.__class__.__name__}(value={self._value!r})'
+        return f'{self.__class__.__name__}(value={self.value!r})'
 
     @override
     def __str__(self) -> str:
@@ -155,7 +155,7 @@ class ValueObject(ABC, Generic[T]):  # noqa: UP046
         # >>> 10
         ```
         """
-        return str(object=self._value)
+        return str(object=self.value)
 
     @override
     def __hash__(self) -> int:

value_object_pattern-0.9.2/value_object_pattern/models/collections/__init__.py

@@ -1,11 +0,0 @@
-from .collection_value_object import CollectionValueObject
-from .iterable_value_object import IterableValueObject
-from .not_empty_sequence_value_object import NotEmptySequenceValueObject
-from .sequence_value_object import SequenceValueObject
-
-__all__ = (
-    'CollectionValueObject',
-    'IterableValueObject',
-    'NotEmptySequenceValueObject',
-    'SequenceValueObject',
-)

value_object_pattern-0.9.2/value_object_pattern/models/collections/collection_value_object.py

@@ -1,107 +0,0 @@
-"""
-CollectionValueObject module.
-"""
-
-from collections.abc import Collection
-from typing import Any, NoReturn
-
-from value_object_pattern.decorators import validation
-from value_object_pattern.models.value_object import ValueObject
-
-
-class CollectionValueObject(ValueObject[Collection[Any]]):
-    """
-    CollectionValueObject is a value object that ensures the provided value is from a collection.
-
-    Example:
-    ```python
-    from value_object_pattern.models.collections import CollectionValueObject
-
-    collection = CollectionValueObject(value=[1, 2, 3])
-    print(collection)
-    # >>> [1, 2, 3]
-    ```
-    """
-
-    def __contains__(self, item: Any) -> bool:
-        """
-        Returns True if the value object value contains the item, otherwise False.
-
-        Args:
-            item (Any): The item to check.
-
-        Returns:
-            bool: True if the value object value contains the item, otherwise False.
-
-        Example:
-        ```python
-        from value_object_pattern.models.collections import CollectionValueObject
-
-        collection = CollectionValueObject(value=[1, 2, 3])
-        print(1 in collection)
-        # >>> True
-        ```
-        """
-        return item in self._value
-
-    def __len__(self) -> int:
-        """
-        Returns the length of the value object value.
-
-        Returns:
-            int: The length of the value object value.
-
-        Example:
-        ```python
-        from value_object_pattern.models.collections import CollectionValueObject
-
-        collection = CollectionValueObject(value=[1, 2, 3])
-        print(len(collection))
-        # >>> 3
-        ```
-        """
-        return len(self._value)
-
-    @validation(order=0)
-    def _ensure_value_is_from_collection(self, value: Collection[Any]) -> None:
-        """
-        Ensures the value object `value` is a collection.
-
-        Args:
-            value (Collection[Any]): The provided value.
-
-        Raises:
-            TypeError: If the `value` is not a collection.
-        """
-        if not isinstance(value, Collection):
-            self._raise_value_is_not_collection(value=value)
-
-    def _raise_value_is_not_collection(self, value: Any) -> NoReturn:
-        """
-        Raises a TypeError if the value object `value` is not a collection.
-
-        Args:
-            value (Any): The provided value.
-
-        Raises:
-            TypeError: If the `value` is not a collection.
-        """
-        raise TypeError(f'CollectionValueObject value <<<{value}>>> must be a collection. Got <<<{type(value).__name__}>>> type.')  # noqa: E501  # fmt: skip
-
-    def is_empty(self) -> bool:
-        """
-        Returns True if the value object value is empty, otherwise False.
-
-        Returns:
-            bool: True if the value object value is empty, otherwise False.
-
-        Example:
-        ```python
-        from value_object_pattern.models.collections import CollectionValueObject
-
-        collection = CollectionValueObject(value=[])
-        print(collection.is_empty())
-        # >>> True
-        ```
-        """
-        return not self._value

value_object_pattern-0.9.2/value_object_pattern/models/collections/iterable_value_object.py

@@ -1,71 +0,0 @@
-"""
-IterableValueObject module.
-"""
-
-from collections.abc import Iterable
-from typing import Any, NoReturn
-
-from value_object_pattern.decorators import validation
-from value_object_pattern.models.value_object import ValueObject
-
-
-class IterableValueObject(ValueObject[Iterable[Any]]):
-    """
-    IterableValueObject is a value object that ensures the provided value is from an iterable.
-
-    Example:
-    ```python
-    from value_object_pattern.models.collections import IterableValueObject
-
-    iterable = IterableValueObject(value=[1, 2, 3])
-    print(iterable)
-    # >>> [1, 2, 3]
-    ```
-    """
-
-    def __contains__(self, item: Any) -> bool:
-        """
-        Returns True if the value object value contains the item, otherwise False.
-
-        Args:
-            item (Any): The item to check.
-
-        Returns:
-            bool: True if the value object value contains the item, otherwise False.
-
-        Example:
-        ```python
-        from value_object_pattern.models.collections import IterableValueObject
-
-        iterable = IterableValueObject(value=[1, 2, 3])
-        print(1 in iterable)
-        # >>> True
-        ```
-        """
-        return item in self._value
-
-    @validation(order=0)
-    def _ensure_value_is_from_iterable(self, value: Iterable[Any]) -> None:
-        """
-        Ensures the value object `value` is an iterable.
-
-        Args:
-            value (Iterable[Any]): The provided value.
-
-        Raises:
-            TypeError: If the `value` is not an iterable.
-        """
-        if not isinstance(value, Iterable):
-            self._raise_value_is_not_iterable(value=value)
-
-    def _raise_value_is_not_iterable(self, value: Any) -> NoReturn:
-        """
-        Raises a TypeError if the value object `value` is not an iterable.
-
-        Args:
-            value (Any): The provided value.
-
-        Raises:
-            TypeError: If the `value` is not an iterable.
-        """
-        raise TypeError(f'IterableValueObject value <<<{value}>>> must be an iterable. Got <<<{type(value).__name__}>>> type.')  # noqa: E501  # fmt: skip

value_object_pattern-0.9.2/value_object_pattern/models/collections/not_empty_sequence_value_object.py

@@ -1,51 +0,0 @@
-"""
-NotEmptySequenceValueObject module.
-"""
-
-from collections.abc import Sequence
-from typing import Any, NoReturn
-
-from value_object_pattern.decorators import validation
-
-from .sequence_value_object import SequenceValueObject
-
-
-class NotEmptySequenceValueObject(SequenceValueObject):
-    """
-    NotEmptySequenceValueObject is a value object that ensures the provided value is from a sequence.
-
-    Example:
-    ```python
-    from value_object_pattern.models.collections import NotEmptySequenceValueObject
-
-    sequence = NotEmptySequenceValueObject(value=[1, 2, 3])
-    print(sequence)
-    # >>> [1, 2, 3]
-    ```
-    """
-
-    @validation(order=0)
-    def _ensure_value_is_not_empty_sequence(self, value: Sequence[Any]) -> None:
-        """
-        Ensures the value object `value` is not an empty sequence.
-
-        Args:
-            value (Sequence[Any]): The provided value.
-
-        Raises:
-            TypeError: If the `value` is an empty sequence.
-        """
-        if not value:
-            self._raise_value_is_empty_sequence(value=value)
-
-    def _raise_value_is_empty_sequence(self, value: Any) -> NoReturn:
-        """
-        Raises a TypeError if the value object `value` is an empty sequence.
-
-        Args:
-            value (Any): The provided value.
-
-        Raises:
-            TypeError: If the `value` is an empty sequence.
-        """
-        raise TypeError(f'NotEmptySequenceValueObject value <<<{value}>>> must not be an empty sequence.')

value_object_pattern-0.9.2/value_object_pattern/models/collections/sequence_value_object.py

@@ -1,143 +0,0 @@
-"""
-SequenceValueObject module.
-"""
-
-from collections.abc import Iterator, Sequence
-from typing import Any, NoReturn
-
-from value_object_pattern.decorators import validation
-from value_object_pattern.models.value_object import ValueObject
-
-
-class SequenceValueObject(ValueObject[Sequence[Any]]):
-    """
-    SequenceValueObject is a value object that ensures the provided value is from a sequence.
-
-    Example:
-    ```python
-    from value_object_pattern.models.collections import SequenceValueObject
-
-    sequence = SequenceValueObject(value=[1, 2, 3])
-    print(sequence)
-    # >>> [1, 2, 3]
-    ```
-    """
-
-    def __contains__(self, item: Any) -> bool:
-        """
-        Returns True if the value object value contains the item, otherwise False.
-
-        Args:
-            item (Any): The item to check.
-
-        Returns:
-            bool: True if the value object value contains the item, otherwise False.
-
-        Example:
-        ```python
-        from value_object_pattern.models.collections import SequenceValueObject
-
-        sequence = SequenceValueObject(value=[1, 2, 3])
-        print(1 in sequence)
-        # >>> True
-        ```
-        """
-        return item in self._value
-
-    def __iter__(self) -> Iterator[Any]:
-        """
-        Returns an iterator over the value object value.
-
-        Returns:
-            Iterator[Any]: An iterator over the value object value.
-
-        Example:
-        ```python
-        from value_object_pattern.models.collections import SequenceValueObject
-
-        sequence = SequenceValueObject(value=[1, 2, 3])
-        print(list(sequence))
-        # >>> [1, 2, 3]
-        ```
-        """
-        return iter(self._value)
-
-    def __len__(self) -> int:
-        """
-        Returns the length of the value object value.
-
-        Returns:
-            int: The length of the value object value.
-
-        Example:
-        ```python
-        from value_object_pattern.models.collections import SequenceValueObject
-
-        sequence = SequenceValueObject(value=[1, 2, 3])
-        print(len(sequence))
-        # >>> 3
-        ```
-        """
-        return len(self._value)
-
-    def __reversed__(self) -> Iterator[Any]:
-        """
-        Returns a reversed iterator over the value object value.
-
-        Returns:
-            Iterator[Any]: A reversed iterator over the value object value.
-
-        Example:
-        ```python
-        from value_object_pattern.models.collections import SequenceValueObject
-
-        sequence = SequenceValueObject(value=[1, 2, 3])
-        print(list(reversed(sequence)))
-        # >>> [3, 2, 1]
-        ```
-        """
-        return reversed(self._value)
-
-    @validation(order=0)
-    def _ensure_value_is_from_sequence(self, value: Sequence[Any]) -> None:
-        """
-        Ensures the value object `value` is a sequence.
-
-        Args:
-            value (Sequence[Any]): The provided value.
-
-        Raises:
-            TypeError: If the `value` is not a sequence.
-        """
-        if not isinstance(value, Sequence):
-            self._raise_value_is_not_sequence(value=value)
-
-    def _raise_value_is_not_sequence(self, value: Any) -> NoReturn:
-        """
-        Raises a TypeError if the value object `value` is not a sequence.
-
-        Args:
-            value (Any): The provided value.
-
-        Raises:
-            TypeError: If the `value` is not a sequence.
-        """
-        raise TypeError(f'SequenceValueObject value <<<{value}>>> must be a sequence. Got <<<{type(value).__name__}>>> type.')  # noqa: E501  # fmt: skip
-
-    def is_empty(self) -> bool:
-        """
-        Returns True if the value object value is empty, otherwise False.
-
-        Returns:
-            bool: True if the value object value is empty, otherwise False.
-
-        Example:
-        ```python
-        from value_object_pattern.models.collections import SequenceValueObject
-
-        sequence = SequenceValueObject(value=[])
-        print(sequence.is_empty())
-        # >>> True
-        ```
-        """
-        return not self._value