value-object-pattern 0.1.0__py3-none-any.whl

value_object_pattern/usables/primitives/bytes/bytes_value_object.py

@@ -0,0 +1,36 @@
+"""
+BytesValueObject value object.
+"""
+
+from value_object_pattern.decorators import validation
+from value_object_pattern.models import ValueObject
+
+
+class BytesValueObject(ValueObject[bytes]):
+    """
+    BytesValueObject value object ensures the provided value is bytes.
+
+    Example:
+    ```python
+    from value_object_pattern.usables import BytesValueObject
+
+    bytes_ = BytesValueObject(value=b'aad30be7ce99fb0fe411')
+
+    print(repr(bytes_))
+    # >>> BytesValueObject(value=b'aad30be7ce99fb0fe411')
+    ```
+    """
+
+    @validation(order=0)
+    def _ensure_value_is_bytes(self, value: bytes) -> None:
+        """
+        Ensures the value object `value` is bytes.
+
+        Args:
+            value (bytes): The provided value.
+
+        Raises:
+            TypeError: If the `value` is not bytes.
+        """
+        if type(value) is not bytes:
+            raise TypeError(f'BytesValueObject value <<<{str(object=value)}>>> must be bytes. Got <<<{type(value).__name__}>>> type.')  # noqa: E501  # fmt: skip

value_object_pattern/usables/primitives/float/__init__.py

@@ -0,0 +1,9 @@
+from .float_value_object import FloatValueObject
+from .negative_float_value_object import NegativeFloatValueObject
+from .positive_float_value_object import PositiveFloatValueObject
+
+__all__ = (
+    'FloatValueObject',
+    'NegativeFloatValueObject',
+    'PositiveFloatValueObject',
+)

value_object_pattern/usables/primitives/float/float_value_object.py

@@ -0,0 +1,36 @@
+"""
+FloatValueObject value object.
+"""
+
+from value_object_pattern.decorators import validation
+from value_object_pattern.models import ValueObject
+
+
+class FloatValueObject(ValueObject[float]):
+    """
+    FloatValueObject value object ensures the provided value is a float.
+
+    Example:
+    ```python
+    from value_object_pattern.usables import FloatValueObject
+
+    float_ = FloatValueObject(value=0.5)
+
+    print(repr(float_))
+    # >>> FloatValueObject(value=0.5)
+    ```
+    """
+
+    @validation(order=0)
+    def _ensure_value_is_float(self, value: float) -> None:
+        """
+        Ensures the value object `value` is a float.
+
+        Args:
+            value (float): The provided value.
+
+        Raises:
+            TypeError: If the `value` is not a float.
+        """
+        if type(value) is not float:
+            raise TypeError(f'FloatValueObject value <<<{value}>>> must be a float. Got <<<{type(value).__name__}>>> type.')  # noqa: E501  # fmt: skip

value_object_pattern/usables/primitives/float/negative_float_value_object.py

@@ -0,0 +1,37 @@
+"""
+NegativeFloatValueObject value object.
+"""
+
+from value_object_pattern.decorators import validation
+
+from .float_value_object import FloatValueObject
+
+
+class NegativeFloatValueObject(FloatValueObject):
+    """
+    NegativeFloatValueObject value object ensures the provided value is a negative float.
+
+    Example:
+    ```python
+    from value_object_pattern.usables import FloatValueObject
+
+    float_ = FloatValueObject(value=-0.5)
+
+    print(repr(float_))
+    # >>> FloatValueObject(value=-0.5)
+    ```
+    """
+
+    @validation(order=0)
+    def _ensure_value_is_negative_float(self, value: float) -> None:
+        """
+        Ensures the value object `value` is a negative float.
+
+        Args:
+            value (float): The provided value.
+
+        Raises:
+            ValueError: If the `value` is not a negative float.
+        """
+        if value >= 0:
+            raise ValueError(f'NegativeFloatValueObject value <<<{value}>>> must be a negative float.')

value_object_pattern/usables/primitives/float/positive_float_value_object.py

@@ -0,0 +1,37 @@
+"""
+PositiveFloatValueObject value object.
+"""
+
+from value_object_pattern.decorators import validation
+
+from .float_value_object import FloatValueObject
+
+
+class PositiveFloatValueObject(FloatValueObject):
+    """
+    PositiveFloatValueObject value object ensures the provided value is a positive float.
+
+    Example:
+    ```python
+    from value_object_pattern.usables import FloatValueObject
+
+    float_ = FloatValueObject(value=0.5)
+
+    print(repr(float_))
+    # >>> FloatValueObject(value=0.5)
+    ```
+    """
+
+    @validation(order=0)
+    def _ensure_value_is_positive_float(self, value: float) -> None:
+        """
+        Ensures the value object `value` is a positive float.
+
+        Args:
+            value (float): The provided value.
+
+        Raises:
+            ValueError: If the `value` is not a positive float.
+        """
+        if value <= 0:
+            raise ValueError(f'PositiveFloatValueObject value <<<{value}>>> must be a positive float.')

value_object_pattern/usables/primitives/integer/__init__.py

@@ -0,0 +1,13 @@
+from .even_integer_value_object import EvenIntegerValueObject
+from .integer_value_object import IntegerValueObject
+from .negative_integer_value_object import NegativeIntegerValueObject
+from .odd_integer_value_object import OddIntegerValueObject
+from .positive_integer_value_object import PositiveIntegerValueObject
+
+__all__ = (
+    'EvenIntegerValueObject',
+    'IntegerValueObject',
+    'NegativeIntegerValueObject',
+    'OddIntegerValueObject',
+    'PositiveIntegerValueObject',
+)

value_object_pattern/usables/primitives/integer/even_integer_value_object.py

@@ -0,0 +1,37 @@
+"""
+EvenIntegerValueObject value object.
+"""
+
+from value_object_pattern.decorators import validation
+
+from .integer_value_object import IntegerValueObject
+
+
+class EvenIntegerValueObject(IntegerValueObject):
+    """
+    EvenIntegerValueObject value object ensures the provided value is an even integer.
+
+    Example:
+    ```python
+    from value_object_pattern.usables import EvenIntegerValueObject
+
+    integer = EvenIntegerValueObject(value=2)
+
+    print(repr(integer))
+    # >>> EvenIntegerValueObject(value=2)
+    ```
+    """
+
+    @validation(order=0)
+    def _ensure_value_is_even_number(self, value: int) -> None:
+        """
+        Ensures the value object `value` is an even number.
+
+        Args:
+            value (int): The provided value.
+
+        Raises:
+            ValueError: If the `value` is not an even number.
+        """
+        if value % 2 != 0:
+            raise ValueError(f'EvenIntegerValueObject value <<<{value}>>> must be an even number.')

value_object_pattern/usables/primitives/integer/integer_value_object.py

@@ -0,0 +1,36 @@
+"""
+IntegerValueObject value object.
+"""
+
+from value_object_pattern.decorators import validation
+from value_object_pattern.models import ValueObject
+
+
+class IntegerValueObject(ValueObject[int]):
+    """
+    IntegerValueObject value object ensures the provided value is an integer.
+
+    Example:
+    ```python
+    from value_object_pattern.usables import IntegerValueObject
+
+    integer = IntegerValueObject(value=1)
+
+    print(repr(integer))
+    # >>> IntegerValueObject(value=1)
+    ```
+    """
+
+    @validation(order=0)
+    def _ensure_value_is_integer(self, value: int) -> None:
+        """
+        Ensures the value object `value` is an integer.
+
+        Args:
+            value (int): The provided value.
+
+        Raises:
+            TypeError: If the `value` is not an integer.
+        """
+        if type(value) is not int:
+            raise TypeError(f'IntegerValueObject value <<<{value}>>> must be an integer. Got <<<{type(value).__name__}>>> type.')  # noqa: E501  # fmt: skip

value_object_pattern/usables/primitives/integer/negative_integer_value_object.py

@@ -0,0 +1,37 @@
+"""
+NegativeIntegerValueObject value object.
+"""
+
+from value_object_pattern.decorators import validation
+
+from .integer_value_object import IntegerValueObject
+
+
+class NegativeIntegerValueObject(IntegerValueObject):
+    """
+    NegativeIntegerValueObject value object ensures the provided value is a negative integer.
+
+    Example:
+    ```python
+    from value_object_pattern.usables import IntegerValueObject
+
+    integer = IntegerValueObject(value=-1)
+
+    print(repr(integer))
+    # >>> IntegerValueObject(value=-1)
+    ```
+    """
+
+    @validation(order=0)
+    def _ensure_value_is_negative_integer(self, value: int) -> None:
+        """
+        Ensures the value object `value` is a negative integer.
+
+        Args:
+            value (int): The provided value.
+
+        Raises:
+            ValueError: If the `value` is not a negative integer.
+        """
+        if value >= 0:
+            raise ValueError(f'NegativeIntegerValueObject value <<<{value}>>> must be a negative integer.')

value_object_pattern/usables/primitives/integer/odd_integer_value_object.py

@@ -0,0 +1,37 @@
+"""
+OddIntegerValueObject value object.
+"""
+
+from value_object_pattern.decorators import validation
+
+from .integer_value_object import IntegerValueObject
+
+
+class OddIntegerValueObject(IntegerValueObject):
+    """
+    OddIntegerValueObject value object ensures the provided value is an odd integer.
+
+    Example:
+    ```python
+    from value_object_pattern.usables import IntegerValueObject
+
+    integer = IntegerValueObject(value=1)
+
+    print(repr(integer))
+    # >>> IntegerValueObject(value=1)
+    ```
+    """
+
+    @validation(order=0)
+    def _ensure_value_is_odd_number(self, value: int) -> None:
+        """
+        Ensures the value object `value` is an odd number.
+
+        Args:
+            value (int): The provided value.
+
+        Raises:
+            ValueError: If the `value` is not an odd number.
+        """
+        if value % 2 == 0:
+            raise ValueError(f'OddIntegerValueObject value <<<{value}>>> must be an odd number.')

value_object_pattern/usables/primitives/integer/positive_integer_value_object.py

@@ -0,0 +1,37 @@
+"""
+PositiveIntegerValueObject value object.
+"""
+
+from value_object_pattern.decorators import validation
+
+from .integer_value_object import IntegerValueObject
+
+
+class PositiveIntegerValueObject(IntegerValueObject):
+    """
+    PositiveIntegerValueObject value object ensures the provided value is a positive integer.
+
+    Example:
+    ```python
+    from value_object_pattern.usables import PositiveIntegerValueObject
+
+    integer = PositiveIntegerValueObject(value=1)
+
+    print(repr(integer))
+    # >>> PositiveIntegerValueObject(value=1)
+    ```
+    """
+
+    @validation(order=0)
+    def _ensure_value_is_positive_integer(self, value: int) -> None:
+        """
+        Ensures the value object `value` is a positive integer.
+
+        Args:
+            value (int): The provided value.
+
+        Raises:
+            ValueError: If the `value` is not a positive integer.
+        """
+        if value <= 0:
+            raise ValueError(f'PositiveIntegerValueObject value <<<{value}>>> must be a positive integer.')

value_object_pattern/usables/primitives/string/__init__.py

@@ -0,0 +1,21 @@
+from .alpha_value_object import AlphaStringValueObject
+from .alphanumeric_value_object import AlphanumericStringValueObject
+from .digit_value_object import DigitStringValueObject
+from .lowercase_string_value_object import LowercaseStringValueObject
+from .non_empty_string_value_object import NotEmptyStringValueObject
+from .printable_string_value_object import PrintableStringValueObject
+from .string_value_object import StringValueObject
+from .trimmed_string_value_object import TrimmedStringValueObject
+from .uppercase_string_value_object import UppercaseStringValueObject
+
+__all__ = (
+    'AlphaStringValueObject',
+    'AlphanumericStringValueObject',
+    'DigitStringValueObject',
+    'LowercaseStringValueObject',
+    'NotEmptyStringValueObject',
+    'PrintableStringValueObject',
+    'StringValueObject',
+    'TrimmedStringValueObject',
+    'UppercaseStringValueObject',
+)

value_object_pattern/usables/primitives/string/alpha_value_object.py

@@ -0,0 +1,37 @@
+"""
+AlphaStringValueObject value object.
+"""
+
+from value_object_pattern.decorators import validation
+
+from .string_value_object import StringValueObject
+
+
+class AlphaStringValueObject(StringValueObject):
+    """
+    AlphaStringValueObject value object ensures the provided value is alpha.
+
+    Example:
+    ```python
+    from value_object_pattern.usables import AlphaStringValueObject
+
+    string = AlphaStringValueObject(value='abcd')
+
+    print(repr(string))
+    # >>> AlphaStringValueObject(value='abcd')
+    ```
+    """
+
+    @validation(order=0)
+    def _ensure_value_is_alpha(self, value: str) -> None:
+        """
+        Ensures the value object `value` is alpha.
+
+        Args:
+            value (str): The provided value.
+
+        Raises:
+            ValueError: If the `value` is not alpha.
+        """
+        if not value.isalpha():
+            raise ValueError(f'AlphaStringValueObject value <<<{value}>>> contains invalid characters. Only alpha characters are allowed.')  # noqa: E501  # fmt: skip

value_object_pattern/usables/primitives/string/alphanumeric_value_object.py

@@ -0,0 +1,37 @@
+"""
+AlphanumericStringValueObject value object.
+"""
+
+from value_object_pattern.decorators import validation
+
+from .string_value_object import StringValueObject
+
+
+class AlphanumericStringValueObject(StringValueObject):
+    """
+    AlphanumericStringValueObject value object ensures the provided value is alphanumeric.
+
+    Example:
+    ```python
+    from value_object_pattern.usables import AlphanumericStringValueObject
+
+    string = AlphanumericStringValueObject(value='abcd1234')
+
+    print(repr(string))
+    # >>> AlphanumericStringValueObject(value='abcd1234')
+    ```
+    """
+
+    @validation(order=0)
+    def _ensure_value_is_alphanumeric(self, value: str) -> None:
+        """
+        Ensures the value object `value` is alphanumeric.
+
+        Args:
+            value (str): The provided value.
+
+        Raises:
+            ValueError: If the `value` is not alphanumeric.
+        """
+        if not value.isalnum():
+            raise ValueError(f'AlphanumericStringValueObject value <<<{value}>>> contains invalid characters. Only alphanumeric characters are allowed.')  # noqa: E501  # fmt: skip

value_object_pattern/usables/primitives/string/digit_value_object.py

@@ -0,0 +1,37 @@
+"""
+DigitStringValueObject value object.
+"""
+
+from value_object_pattern.decorators import validation
+
+from .string_value_object import StringValueObject
+
+
+class DigitStringValueObject(StringValueObject):
+    """
+    DigitStringValueObject value object ensures the provided value is digit.
+
+    Example:
+    ```python
+    from value_object_pattern.usables import DigitStringValueObject
+
+    string = DigitStringValueObject(value='1234')
+
+    print(repr(string))
+    # >>> DigitStringValueObject(value='1234')
+    ```
+    """
+
+    @validation(order=0)
+    def _ensure_value_is_digit(self, value: str) -> None:
+        """
+        Ensures the value object `value` is digit.
+
+        Args:
+            value (str): The provided value.
+
+        Raises:
+            ValueError: If the `value` is not digit.
+        """
+        if not value.isdigit():
+            raise ValueError(f'DigitStringValueObject value <<<{value}>>> contains invalid characters. Only digit characters are allowed.')  # noqa: E501  # fmt: skip

value_object_pattern/usables/primitives/string/lowercase_string_value_object.py

@@ -0,0 +1,37 @@
+"""
+LowercaseStringValueObject value object.
+"""
+
+from value_object_pattern.decorators import validation
+
+from .string_value_object import StringValueObject
+
+
+class LowercaseStringValueObject(StringValueObject):
+    """
+    LowercaseStringValueObject value object ensures the provided value is lowercase.
+
+    Example:
+    ```python
+    from value_object_pattern.usables import LowercaseStringValueObject
+
+    string = LowercaseStringValueObject(value='abcd1234')
+
+    print(repr(string))
+    # >>> LowercaseStringValueObject(value='abcd1234')
+    ```
+    """
+
+    @validation(order=0)
+    def _ensure_value_is_lowercase(self, value: str) -> None:
+        """
+        Ensures the value object `value` is lowercase.
+
+        Args:
+            value (str): The provided value.
+
+        Raises:
+            ValueError: If the `value` is not lowercase.
+        """
+        if not value.islower():
+            raise ValueError(f'LowercaseStringValueObject value <<<{value}>>> contains uppercase characters. Only lowercase characters are allowed.')  # noqa: E501  # fmt: skip

value_object_pattern/usables/primitives/string/non_empty_string_value_object.py

@@ -0,0 +1,37 @@
+"""
+NotEmptyStringValueObject value object.
+"""
+
+from value_object_pattern.decorators import validation
+
+from .string_value_object import StringValueObject
+
+
+class NotEmptyStringValueObject(StringValueObject):
+    """
+    NotEmptyStringValueObject value object ensures the provided value is not an empty string.
+
+    Example:
+    ```python
+    from value_object_pattern.usables import NotEmptyStringValueObject
+
+    string = NotEmptyStringValueObject(value='abcd1234')
+
+    print(repr(string))
+    # >>> NotEmptyStringValueObject(value='abcd1234')
+    ```
+    """
+
+    @validation(order=0)
+    def _ensure_value_is_not_empty_string(self, value: str) -> None:
+        """
+        Ensures the value object `value` is not an empty string.
+
+        Args:
+            value (str): The provided value.
+
+        Raises:
+            ValueError: If the `value` is an empty string.
+        """
+        if not value:
+            raise ValueError(f'NotEmptyStringValueObject value <<<{value}>>> is an empty string. Only non-empty strings are allowed.')  # noqa: E501  # fmt: skip

value_object_pattern/usables/primitives/string/printable_string_value_object.py

@@ -0,0 +1,37 @@
+"""
+PrintableStringValueObject value object.
+"""
+
+from value_object_pattern.decorators import validation
+
+from .string_value_object import StringValueObject
+
+
+class PrintableStringValueObject(StringValueObject):
+    """
+    PrintableStringValueObject value object ensures the provided value is printable.
+
+    Example:
+    ```python
+    from value_object_pattern.usables import PrintableStringValueObject
+
+    string = PrintableStringValueObject(value='abcd1234')
+
+    print(repr(string))
+    # >>> PrintableStringValueObject(value='abcd1234')
+    ```
+    """
+
+    @validation(order=0)
+    def _ensure_value_is_printable(self, value: str) -> None:
+        """
+        Ensures the value object `value` is printable.
+
+        Args:
+            value (str): The provided value.
+
+        Raises:
+            ValueError: If the `value` is not printable.
+        """
+        if not value.isprintable():
+            raise ValueError(f'PrintableStringValueObject value <<<{value}>>> contains invalid characters. Only printable characters are allowed.')  # noqa: E501  # fmt: skip

value_object_pattern/usables/primitives/string/string_value_object.py

@@ -0,0 +1,36 @@
+"""
+StringValueObject value object.
+"""
+
+from value_object_pattern.decorators import validation
+from value_object_pattern.models import ValueObject
+
+
+class StringValueObject(ValueObject[str]):
+    """
+    StringValueObject value object ensures the provided value is a string.
+
+    Example:
+    ```python
+    from value_object_pattern.usables import StringValueObject
+
+    string = StringValueObject(value='abcd1234')
+
+    print(repr(string))
+    # >>> StringValueObject(value='abcd1234')
+    ```
+    """
+
+    @validation(order=0)
+    def _ensure_value_is_string(self, value: str) -> None:
+        """
+        Ensures the value object `value` is a string.
+
+        Args:
+            value (str): The provided value.
+
+        Raises:
+            TypeError: If the `value` is not a string.
+        """
+        if type(value) is not str:
+            raise TypeError(f'StringValueObject value <<<{value}>>> must be a string. Got <<<{type(value).__name__}>>> type.')  # noqa: E501  # fmt: skip