value-object-pattern 1.34.0__tar.gz → 1.38.0__tar.gz

{value_object_pattern-1.34.0 → value_object_pattern-1.38.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: value-object-pattern
-Version: 1.34.0
+Version: 1.38.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.34.0 → value_object_pattern-1.38.0}/pyproject.toml

@@ -55,7 +55,7 @@ develop = ['pre-commit>=3.0.0']
 format = ['ruff>=0.11.10']
 lint = [
     'ruff>=0.11.10',
-    'mypy[reports]>=1.0.0',
+    'ty>=0.0.72',
     { include-group = 'test' },
     { include-group = 'types' },
 ]
@@ -80,6 +80,7 @@ all = [
 
 [tool.pytest.ini_options]
 pythonpath = '.'
+testpaths = ['tests']
 addopts = [
     '--strict-config',  # fail if an unregistered option is used
     '--strict-markers', # fail if an unregistered marker is used
@@ -183,15 +184,11 @@ known-first-party = ['value_object_pattern']
 combine-as-imports = true
 
 
-[tool.mypy]
-strict = true
-warn_unreachable = true
-enable_error_code = [
-    'redundant-expr',
-    'possibly-undefined',
-    'truthy-bool',
-    'explicit-override',
-]
+[tool.ty.rules]
+missing-override-decorator = 'error'
+missing-type-argument = 'error'
+possibly-unresolved-reference = 'warn'
+unsound-return-statement = 'error'
 
 
 [tool.semantic_release]

{value_object_pattern-1.34.0 → value_object_pattern-1.38.0}/value_object_pattern/__init__.py

@@ -1,4 +1,4 @@
-__version__ = '1.34.0'
+__version__ = '1.38.0'
 
 from .decorators import process, validation
 from .models import BaseModel, EnumerationValueObject, SecretValueObject, UnionValueObject, ValueObject

{value_object_pattern-1.34.0 → value_object_pattern-1.38.0}/value_object_pattern/decorators/value_object_process.py

@@ -2,8 +2,7 @@
 Decorator used to register value-object processing hooks.
 """
 
-from functools import wraps
-from typing import Any, Callable, TypeVar
+from typing import Callable, TypeVar
 
 T = TypeVar('T')
 
@@ -23,7 +22,7 @@ def process(order: int | None = None) -> Callable[[Callable[..., T]], Callable[.
         ValueError: If the order is not equal or greater than 0.
 
     Returns:
-        Callable[[Callable[..., T]], Callable[..., T]]: Wrapper function for the process.
+        Callable[[Callable[..., T]], Callable[..., T]]: Decorator that marks the process function.
 
     Example:
     ```python
@@ -54,7 +53,7 @@ def process(order: int | None = None) -> Callable[[Callable[..., T]], Callable[.
             ValueError: If the order is not equal or greater than 0.
 
         Returns:
-            Callable[..., T]: Wrapper function for the process.
+            Callable[..., T]: The marked process function.
         """
         if order is not None:
             if type(order) is not int:
@@ -63,23 +62,9 @@ def process(order: int | None = None) -> Callable[[Callable[..., T]], Callable[.
             if order < 0:
                 raise ValueError(f'Process order <<<{order}>>> must be equal or greater than 0.')
 
-        function._is_process = True  # type: ignore[attr-defined]
-        function._order = function.__name__ if order is None else str(order)  # type: ignore[attr-defined]
+        function._is_process = True  # type: ignore[ty:unresolved-attribute]
+        function._order = function.__name__ if order is None else str(order)  # type: ignore[ty:unresolved-attribute]
 
-        @wraps(function)
-        def wrapper(*args: tuple[Any, ...], **kwargs: dict[str, Any]) -> T:
-            """
-            Execute the wrapped processing method.
-
-            Args:
-                *args (tuple[Any, ...]): The arguments for the function.
-                **kwargs (dict[str, Any]): The keyword arguments for the function.
-
-            Returns:
-                T: The return value of the function.
-            """
-            return function(*args, **kwargs)
-
-        return wrapper
+        return function
 
     return decorator

{value_object_pattern-1.34.0 → value_object_pattern-1.38.0}/value_object_pattern/decorators/value_object_validation.py

@@ -2,8 +2,7 @@
 Decorator used to register value-object validation hooks.
 """
 
-from functools import wraps
-from typing import Any, Callable
+from typing import Callable
 
 
 def validation(
@@ -27,7 +26,7 @@ def validation(
         TypeError: If early_process is not a boolean.
 
     Returns:
-        Callable[[Callable[..., None]], Callable[..., None]]: Wrapper function for the validation.
+        Callable[[Callable[..., None]], Callable[..., None]]: Decorator that marks the validation function.
 
     Example:
     ```python
@@ -59,7 +58,7 @@ def validation(
             TypeError: If early_process is not a boolean.
 
         Returns:
-            Callable[..., None]: Wrapper function for the validation.
+            Callable[..., None]: The marked validation function.
         """
         if order is not None:
             if type(order) is not int:
@@ -71,21 +70,10 @@ def validation(
         if type(early_process) is not bool:
             raise TypeError(f'Validation early_process <<<{early_process}>>> must be a boolean. Got <<<{type(early_process).__name__}>>> type.')  # noqa: E501  # fmt: skip
 
-        function._is_validation = True  # type: ignore[attr-defined]
-        function._order = function.__name__ if order is None else str(order)  # type: ignore[attr-defined]
-        function._early_process = early_process  # type: ignore[attr-defined]
+        function._is_validation = True  # type: ignore[ty:unresolved-attribute]
+        function._order = function.__name__ if order is None else str(order)  # type: ignore[ty:unresolved-attribute]
+        function._early_process = early_process  # type: ignore[ty:unresolved-attribute]
 
-        @wraps(function)
-        def wrapper(*args: tuple[Any, ...], **kwargs: dict[str, Any]) -> None:
-            """
-            Execute the wrapped validation method.
-
-            Args:
-                *args (tuple[Any, ...]): The arguments for the function.
-                **kwargs (dict[str, Any]): The keyword arguments for the function.
-            """
-            function(*args, **kwargs)
-
-        return wrapper
+        return function
 
     return decorator

{value_object_pattern-1.34.0 → value_object_pattern-1.38.0}/value_object_pattern/models/base_model.py

@@ -306,7 +306,7 @@ class BaseModel(ABC):
         ```
         """
         if id(self) in memo:
-            return memo[id(self)]  # type: ignore[no-any-return]
+            return memo[id(self)]  # type: ignore[ty:unsound-return-statement]
 
         cls = self.__class__
         clone = cls.__new__(cls)
@@ -385,7 +385,7 @@ class BaseModel(ABC):
         # >>> {'name': 'John Doe', 'birthdate': '1900-01-01T00:00:00+00:00'}
         ```
         """  # noqa: E501
-        if not isinstance(primitives, dict) or not all(isinstance(key, str) for key in primitives):  # type: ignore[redundant-expr]
+        if not isinstance(primitives, dict) or not all(isinstance(key, str) for key in primitives):
             cls._raise_value_is_not_dict_of_strings(value=primitives)
 
         constructor_signature = signature(obj=cls.__init__)
@@ -470,7 +470,7 @@ class BaseModel(ABC):
             return 'Any'
 
         if hasattr(type, '__name__'):
-            return type.__name__  # type: ignore[no-any-return]
+            return type.__name__  # type: ignore[ty:unsound-return-statement]
 
         return str(type).replace('typing.', '')
 

{value_object_pattern-1.34.0 → value_object_pattern-1.38.0}/value_object_pattern/models/collections/dict_value_object.py

@@ -182,7 +182,7 @@ class _DictValueObjectAlias:
             return ' | '.join(_DictValueObjectAlias._format_type_argument(type=allowed) for allowed in get_args(type))
 
         if hasattr(type, '__name__'):
-            return type.__name__  # type: ignore[no-any-return]
+            return type.__name__  # type: ignore[ty:unsound-return-statement]
 
         return str(type).replace('typing.', '')
 
@@ -357,12 +357,12 @@ class DictValueObject(ValueObject[dict[K, V]], Generic[K, V]):  # noqa: UP046
         """
         return len(self._value)
 
-    def __getitem__(self, key: K) -> V:
+    def __getitem__(self, key: Any) -> V:
         """
-        Returns the value for the specified key.
+        Returns the value for the specified key, converting primitive keys when needed.
 
         Args:
-            key (K): The key to get the value for.
+            key (Any): The key or primitive key to get the value for.
 
         Raises:
             KeyError: If the key is not found.
@@ -544,12 +544,12 @@ class DictValueObject(ValueObject[dict[K, V]], Generic[K, V]):  # noqa: UP046
         """
         raise TypeError(f'DictValueObject value <<<{value}>>> must be of type <<<{self._type_label(type=self._value_type)}>>> type. Got <<<{type(value).__name__}>>> type.')  # noqa: E501  # fmt: skip
 
-    def get(self, *, key: K, default: V | None = None) -> V | None:
+    def get(self, *, key: Any, default: V | None = None) -> V | None:
         """
-        Returns the value for the specified key if key is in dictionary, else default.
+        Returns the value for the specified key or primitive key if it is in the dictionary, else default.
 
         Args:
-            key (K): The key to get the value for.
+            key (Any): The key or primitive key to get the value for.
             default (V | None, optional): The default value to return if the key is not found. Defaults to None.
 
         Returns:
@@ -630,7 +630,7 @@ class DictValueObject(ValueObject[dict[K, V]], Generic[K, V]):  # noqa: UP046
             return 'Any'
 
         if hasattr(type, '__name__'):
-            return type.__name__  # type: ignore[no-any-return]
+            return type.__name__  # type: ignore[ty:unsound-return-statement]
 
         return str(type).replace('typing.', '')
 

{value_object_pattern-1.34.0 → value_object_pattern-1.38.0}/value_object_pattern/models/collections/list_value_object.py

@@ -141,7 +141,7 @@ class _ListValueObjectAlias:
             return ' | '.join(_ListValueObjectAlias._format_type_argument(type=allowed) for allowed in get_args(type))
 
         if hasattr(type, '__name__'):
-            return type.__name__  # type: ignore[no-any-return]
+            return type.__name__  # type: ignore[ty:unsound-return-statement]
 
         return str(type).replace('typing.', '')
 
@@ -505,12 +505,12 @@ class ListValueObject(ValueObject[list[T]], Generic[T]):  # noqa: UP046
         """
         return not self._value
 
-    def add(self, *, item: T) -> Self:
+    def add(self, *, item: Any) -> Self:
         """
-        Returns a new ListValueObject with the item added to the end.
+        Returns a new ListValueObject with a typed or primitive item added to the end.
 
         Args:
-            item (T): The item to add.
+            item (Any): The typed or primitive item to convert and add.
 
         Raises:
             TypeError: If the item is not of type T.
@@ -576,12 +576,12 @@ class ListValueObject(ValueObject[list[T]], Generic[T]):  # noqa: UP046
 
         return self.add(item=item)
 
-    def extend(self, *, items: list[T]) -> Self:
+    def extend(self, *, items: list[Any]) -> Self:
         """
-        Returns a new ListValueObject with multiple items added to the end.
+        Returns a new ListValueObject with typed or primitive items added to the end.
 
         Args:
-            items (list[T]): The items to add.
+            items (list[Any]): The typed or primitive items to convert and add.
 
         Raises:
             TypeError: If the items are not of the correct type.
@@ -647,12 +647,12 @@ class ListValueObject(ValueObject[list[T]], Generic[T]):  # noqa: UP046
 
         return self.extend(items=items)
 
-    def delete(self, *, item: T) -> Self:
+    def delete(self, *, item: Any) -> Self:
         """
-        Returns a new ListValueObject with the first occurrence of the item deleted.
+        Returns a new ListValueObject with the first occurrence of a typed or primitive item deleted.
 
         Args:
-            item (T): The item to delete.
+            item (Any): The typed or primitive item to convert and delete.
 
         Raises:
             ValueError: If the item is not in the list.
@@ -844,7 +844,7 @@ class ListValueObject(ValueObject[list[T]], Generic[T]):  # noqa: UP046
             return 'Any'
 
         if hasattr(type, '__name__'):
-            return type.__name__  # type: ignore[no-any-return]
+            return type.__name__  # type: ignore[ty:unsound-return-statement]
 
         return str(type).replace('typing.', '')
 

{value_object_pattern-1.34.0 → value_object_pattern-1.38.0}/value_object_pattern/models/enumeration_value_object.py

@@ -77,7 +77,7 @@ class EnumerationValueObject(ValueObject[Any | E], Generic[E]):  # noqa: UP046
                 if not (isclass(object=enumeration) and issubclass(enumeration, Enum)):
                     raise TypeError(f'EnumerationValueObject[...] <<<{enumeration}>>> must be an Enum subclass. Got <<<{type(enumeration).__name__}>>> type.')  # noqa: E501  # fmt: skip
 
-                cls._enumeration = enumeration  # type: ignore[assignment]
+                cls._enumeration = enumeration
                 return
 
         raise TypeError('EnumerationValueObject must be parameterized, e.g. "class ColorValueObject(EnumerationValueObject[ColorEnumeration])".')  # noqa: E501  # fmt: skip
@@ -168,4 +168,4 @@ class EnumerationValueObject(ValueObject[Any | E], Generic[E]):  # noqa: UP046
         # >>> ColorEnumeration.RED
         ```
         """
-        return self._value
+        return self._value  # type: ignore[ty:unsound-return-statement]

{value_object_pattern-1.34.0 → value_object_pattern-1.38.0}/value_object_pattern/models/union_value_object.py

@@ -141,8 +141,9 @@ class _UnionValueObjectAlias:
         if origin in (Union, UnionType):
             return ' | '.join(_UnionValueObjectAlias._format_type_argument(type=allowed) for allowed in get_args(type))
 
-        if hasattr(type, '__name__'):
-            return type.__name__  # type: ignore[no-any-return]
+        type_name = getattr(type, '__name__', None)
+        if isinstance(type_name, str):
+            return type_name
 
         return str(type).replace('typing.', '')
 
@@ -259,7 +260,7 @@ class UnionValueObject(ValueObject[T], Generic[T]):  # noqa: UP046
 
         for allowed_type in allowed_types:
             try:
-                return self._coerce_value_to_type(value=value, expected_type=allowed_type)  # type: ignore[no-any-return]
+                return self._coerce_value_to_type(value=value, expected_type=allowed_type)
 
             except Exception as error:
                 last_error = error
@@ -407,8 +408,9 @@ class UnionValueObject(ValueObject[T], Generic[T]):  # noqa: UP046
         if type is Any:
             return 'Any'
 
-        if hasattr(type, '__name__'):
-            return type.__name__  # type: ignore[no-any-return]
+        type_name = getattr(type, '__name__', None)
+        if isinstance(type_name, str):
+            return type_name
 
         return str(type).replace('typing.', '')
 

{value_object_pattern-1.34.0 → value_object_pattern-1.38.0}/value_object_pattern/models/value_object.py

@@ -12,9 +12,9 @@ else:
     from typing_extensions import override  # pragma: no cover
 
 from abc import ABC
-from collections import deque
+from builtins import type as builtins_type
 from copy import deepcopy
-from typing import Any, Callable, Generic, TypeVar, get_args
+from typing import Any, Callable, ClassVar, Generic, TypeVar, cast, get_args
 
 T = TypeVar('T')
 
@@ -26,7 +26,8 @@ class ValueObject(ABC, Generic[T]):  # noqa: UP046
     Subclasses declare their wrapped type with `ValueObject[T]`. Validation methods decorated with `@validation` run
     before the value is stored, and processing methods decorated with `@process` can normalize the value after
     validation. Instances compare by concrete class and wrapped value, expose the raw value through `.value`, and reject
-    attribute mutation after construction.
+    attribute mutation after construction. Decorated hooks are cached per concrete class; subclasses that modify hooks
+    at runtime can set `_cache_decorated_methods = False` to rediscover them for each construction.
 
     ***This class is abstract and should not be instantiated directly***.
 
@@ -52,6 +53,9 @@ class ValueObject(ABC, Generic[T]):  # noqa: UP046
     _title: str
     _parameter: str
     _early_processed: T | None
+    _cache_decorated_methods: ClassVar[bool] = True
+    _cached_process_methods: ClassVar[tuple[Callable[..., Any], ...] | None] = None
+    _cached_validation_methods: ClassVar[tuple[Callable[..., Any], ...] | None] = None
 
     def __init__(self, *, value: T, title: str | None = None, parameter: str | None = None) -> None:
         """
@@ -318,7 +322,7 @@ class ValueObject(ABC, Generic[T]):  # noqa: UP046
         ```
         """
         if id(self) in memo:
-            return memo[id(self)]  # type: ignore[no-any-return]
+            return memo[id(self)]  # type: ignore[ty:unsound-return-statement]
 
         clone = self.__class__(
             value=deepcopy(self._value, memo),
@@ -342,9 +346,9 @@ class ValueObject(ABC, Generic[T]):  # noqa: UP046
         Returns:
             T: Processed value.
         """
-        methods = self._gather_decorated_methods(instance=self, attribute_name='_is_process')
-        while methods:
-            method: Callable[..., T] = methods.popleft().__get__(self, self.__class__)
+        methods = self._get_cached_decorated_methods(attribute_name='_is_process')
+        for decorated_method in methods:
+            method: Callable[..., T] = decorated_method.__get__(self, self.__class__)  # type: ignore[ty:unresolved-attribute]
             value = method(value=value)
 
         return value
@@ -360,9 +364,9 @@ class ValueObject(ABC, Generic[T]):  # noqa: UP046
             value (T): Value to validate.
         """
         try:
-            methods = self._gather_decorated_methods(instance=self, attribute_name='_is_validation')
-            while methods:
-                method: Callable[..., T] = methods.popleft().__get__(self, self.__class__)
+            methods = self._get_cached_decorated_methods(attribute_name='_is_validation')
+            for decorated_method in methods:
+                method: Callable[..., T] = decorated_method.__get__(self, self.__class__)  # type: ignore[ty:unresolved-attribute]
                 if getattr(method, '_early_process', False):
                     method(value=value, processed_value=self.early_process(value=value))
                     continue
@@ -409,18 +413,23 @@ class ValueObject(ABC, Generic[T]):  # noqa: UP046
         """
         return callable(getattr(self, '_secret_value_for_display', None))
 
-    def _post_order_dfs_mro(self, cls: type, visited: set[type] | None = None, cut_off: type = object) -> list[type]:
+    def _post_order_dfs_mro(
+        self,
+        cls: builtins_type,
+        visited: set[builtins_type] | None = None,
+        cut_off: builtins_type = object,
+    ) -> list[builtins_type]:
         """
         Computes the Post-Order Depth-First Search (DFS) Method Resolution Order (MRO) of a class.
 
         Args:
-            cls (type): The class to process.
-            visited (set[type] | None, optional): A set of already visited classes (to prevent duplicates). Defaults
-            to None.
-            cut_off (type, optional): The class to stop the search. Defaults to object.
+            cls (builtins_type): The class to process.
+            visited (set[builtins_type] | None, optional): A set of already visited classes (to prevent duplicates).
+            Defaults to None.
+            cut_off (builtins_type, optional): The class to stop the search. Defaults to object.
 
         Returns:
-            list[type]: A list of classes type sorted by post-order DFS MRO.
+            list[builtins_type]: A list of classes type sorted by post-order DFS MRO.
 
         References:
             DFS: https://en.wikipedia.org/wiki/Depth-first_search
@@ -443,17 +452,40 @@ class ValueObject(ABC, Generic[T]):  # noqa: UP046
 
         return result
 
-    def _gather_decorated_methods(self, instance: object, attribute_name: str) -> deque[Callable[..., Any]]:
+    def _get_cached_decorated_methods(self, attribute_name: str) -> tuple[Callable[..., Any], ...]:
+        """
+        Return decorated methods for the concrete value-object class, caching them when enabled.
+
+        Args:
+            attribute_name: Marker attribute used to identify decorated methods.
+
+        Returns:
+            tuple[Callable[..., Any], ...]: Ordered decorated methods.
+        """
+        if not self.__class__._cache_decorated_methods:
+            return self._gather_decorated_methods(instance=self, attribute_name=attribute_name)
+
+        cache_attribute_name = f'_cached_{attribute_name.removeprefix("_is_")}_methods'
+        cached_methods = cast(tuple[Callable[..., Any], ...] | None, self.__class__.__dict__.get(cache_attribute_name))
+        if cached_methods is not None:
+            return cached_methods
+
+        methods = self._gather_decorated_methods(instance=self, attribute_name=attribute_name)
+        setattr(self.__class__, cache_attribute_name, methods)
+
+        return methods
+
+    def _gather_decorated_methods(self, instance: object, attribute_name: str) -> tuple[Callable[..., Any], ...]:
         """
         Gathers decorated methods from instance.__class__ and its parent classes following the post-order DFS MRO,
-        returning them in a deque with the methods sorted by class hierarchy, method order, and method name.
+        returning them in a tuple sorted by class hierarchy, method order, and method name.
 
         Args:
             instance (object): The object instance whose class hierarchy is inspected.
             attribute_name (str): The attribute name used to identify the methods.
 
         Returns
-            deque[Callable[..., Any]]: A deque of methods sorted by class hierarchy, method order, and method name.
+            tuple[Callable[..., Any], ...]: Methods sorted by class hierarchy, method order, and method name.
 
         References:
             DFS: https://en.wikipedia.org/wiki/Depth-first_search
@@ -475,12 +507,12 @@ class ValueObject(ABC, Generic[T]):  # noqa: UP046
             class_index = classes_names.get(class_name, 999)
             order = getattr(method, '_order', method_name)
 
-            return int(class_index), order, method_name
+            return int(class_index), order, method_name  # type: ignore[ty:unsound-return-statement]
 
         classes = self._post_order_dfs_mro(cls=instance.__class__, cut_off=ValueObject)
         classes_names = {cls.__name__: index for index, cls in enumerate(iterable=classes)}
 
-        classes_methods: deque[tuple[str, str, Callable[..., Any]]] = deque()
+        classes_methods: list[tuple[str, str, Callable[..., Any]]] = []
         for cls in classes:
             for method_name, method in cls.__dict__.items():
                 if not callable(method):
@@ -492,7 +524,7 @@ class ValueObject(ABC, Generic[T]):  # noqa: UP046
                 classes_methods.append((method.__qualname__.split('.')[0], method_name, method))
 
         # sort by class hierarchy, method order attribute, and method name
-        return deque([method for _, _, method in sorted(classes_methods, key=sort_key)])
+        return tuple(method for _, _, method in sorted(classes_methods, key=sort_key))
 
     def early_process(self, value: T) -> T:
         """
@@ -588,20 +620,20 @@ class ValueObject(ABC, Generic[T]):  # noqa: UP046
         return self._parameter
 
     @classmethod
-    def type(cls) -> type[T]:
+    def type(cls) -> builtins_type[T]:
         """
         Return the wrapped type declared by the `ValueObject[T]` subclass.
 
         Returns:
             type[T]: Declared wrapped type, or `Any` when it cannot be resolved.
         """
-        for base in cls.__orig_bases__:  # type: ignore[attr-defined]
+        for base in cls.__orig_bases__:  # type: ignore[ty:unresolved-attribute]
             if hasattr(base, '__origin__') and base.__origin__ is Generic:
                 continue
 
             if hasattr(base, '__origin__') and issubclass(base.__origin__, ValueObject):
                 args = get_args(base)
                 if args:
-                    return args[0]  # type: ignore[no-any-return]
+                    return args[0]  # type: ignore[ty:unsound-return-statement]
 
-        return Any  # type: ignore[return-value]
+        return Any  # type: ignore[ty:invalid-return-type]

{value_object_pattern-1.34.0 → value_object_pattern-1.38.0}/value_object_pattern/usables/__init__.py

@@ -25,12 +25,15 @@ from .primitives import (
     NoneValueObject,
     NotEmptyStringValueObject,
     NotNoneValueObject,
+    NumberValueObject,
     OddIntegerValueObject,
     PascalCaseStringValueObject,
     PositiveFloatValueObject,
     PositiveIntegerValueObject,
+    PositiveNumberValueObject,
     PositiveOrZeroFloatValueObject,
     PositiveOrZeroIntegerValueObject,
+    PositiveOrZeroNumberValueObject,
     PrintableStringValueObject,
     ScreamingSnakeCaseStringValueObject,
     SnakeCaseStringValueObject,
@@ -60,30 +63,27 @@ __all__ = (
     'IntegerValueObject',
     'KebabCaseStringValueObject',
     'LowercaseStringValueObject',
-    'LowercaseStringValueObject',
     'NegativeFloatValueObject',
     'NegativeIntegerValueObject',
     'NegativeOrZeroFloatValueObject',
     'NegativeOrZeroIntegerValueObject',
     'NoneValueObject',
     'NotEmptyStringValueObject',
-    'NotEmptyStringValueObject',
     'NotNoneValueObject',
+    'NumberValueObject',
     'OddIntegerValueObject',
     'PascalCaseStringValueObject',
     'PositiveFloatValueObject',
     'PositiveIntegerValueObject',
+    'PositiveNumberValueObject',
     'PositiveOrZeroFloatValueObject',
     'PositiveOrZeroIntegerValueObject',
-    'PrintableStringValueObject',
+    'PositiveOrZeroNumberValueObject',
     'PrintableStringValueObject',
     'ScreamingSnakeCaseStringValueObject',
     'SnakeCaseStringValueObject',
     'StringValueObject',
-    'StringValueObject',
-    'TrimmedStringValueObject',
     'TrimmedStringValueObject',
     'TrueValueObject',
     'UppercaseStringValueObject',
-    'UppercaseStringValueObject',
 )

value_object_pattern-1.38.0/value_object_pattern/usables/dates/__init__.py

@@ -0,0 +1,25 @@
+from .date import DateValueObject, StringDateValueObject
+from .datetime import DatetimeValueObject, StringDatetimeValueObject
+from .duration_value_object import DurationValueObject
+from .negative_duration_value_object import NegativeDurationValueObject
+from .negative_or_zero_duration_value_object import NegativeOrZeroDurationValueObject
+from .positive_duration_value_object import PositiveDurationValueObject
+from .positive_or_zero_duration_value_object import PositiveOrZeroDurationValueObject
+from .time import StringTimeValueObject, TimeValueObject
+from .timezone import StringTimezoneValueObject, TimezoneValueObject
+
+__all__ = (
+    'DateValueObject',
+    'DatetimeValueObject',
+    'DurationValueObject',
+    'NegativeDurationValueObject',
+    'NegativeOrZeroDurationValueObject',
+    'PositiveDurationValueObject',
+    'PositiveOrZeroDurationValueObject',
+    'StringDateValueObject',
+    'StringDatetimeValueObject',
+    'StringTimeValueObject',
+    'StringTimezoneValueObject',
+    'TimeValueObject',
+    'TimezoneValueObject',
+)