ddd-value-objects 0.2.1.1__tar.gz → 0.2.2.0__tar.gz

{ddd_value_objects-0.2.1.1/src/ddd_value_objects.egg-info → ddd_value_objects-0.2.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ddd-value-objects
-Version: 0.2.1.1
+Version: 0.2.2.0
 Summary: A collection of base classes for Domain-Driven Design (DDD) value objects and entities in Python
 License: MIT
 Requires-Python: >=3.10
@@ -177,7 +177,7 @@ print(product1 == product2) # True (Same identity/ID)
 | Category | Classes |
 | :--- | :--- |
 | **Primitives** | `StringValueObject`, `IntValueObject`, `FloatValueObject`, `BoolValueObject` |
-| **Numeric** | `PositiveIntValueObject`, `PositiveFloatValueObject` |
+| **Numeric** | `PositiveIntValueObject`, `PositiveFloatValueObject`, `PositiveDecimalValueObject`, `NonNegativeIntValueObject`, `NonNegativeFloatValueObject`, `NonNegativeDecimalValueObject` |
 | **Identity** | `UuidValueObject` |
 | **Network** | `EmailValueObject`, `UrlValueObject`, `IpAddressValueObject` |
 | **Communication** | `PhoneNumberValueObject`, `CountryCodeValueObject` (ISO 3166-1 alpha-2) |

{ddd_value_objects-0.2.1.1 → ddd_value_objects-0.2.2.0}/README.md

@@ -167,7 +167,7 @@ print(product1 == product2) # True (Same identity/ID)
 | Category | Classes |
 | :--- | :--- |
 | **Primitives** | `StringValueObject`, `IntValueObject`, `FloatValueObject`, `BoolValueObject` |
-| **Numeric** | `PositiveIntValueObject`, `PositiveFloatValueObject` |
+| **Numeric** | `PositiveIntValueObject`, `PositiveFloatValueObject`, `PositiveDecimalValueObject`, `NonNegativeIntValueObject`, `NonNegativeFloatValueObject`, `NonNegativeDecimalValueObject` |
 | **Identity** | `UuidValueObject` |
 | **Network** | `EmailValueObject`, `UrlValueObject`, `IpAddressValueObject` |
 | **Communication** | `PhoneNumberValueObject`, `CountryCodeValueObject` (ISO 3166-1 alpha-2) |

{ddd_value_objects-0.2.1.1 → ddd_value_objects-0.2.2.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "ddd-value-objects"
-version = "0.2.1.1"
+version = "0.2.2.0"
 description = "A collection of base classes for Domain-Driven Design (DDD) value objects and entities in Python"
 readme = "README.md"
 license = {text = "MIT"}
@@ -24,4 +24,4 @@ dev = [
 ]
 
 [tool.pytest.ini_options]
-addopts = "--cov=src --cov-report=term-missing --cov-fail-under=90"
+addopts = "--cov=src --cov-report=term-missing --cov-fail-under=100"

{ddd_value_objects-0.2.1.1 → ddd_value_objects-0.2.2.0}/src/ddd_value_objects/__init__.py

@@ -11,6 +11,9 @@ from .date_value_object import DateValueObject
 from .positive_int_value_object import PositiveIntValueObject
 from .positive_float_value_object import PositiveFloatValueObject
 from .positive_decimal_value_object import PositiveDecimalValueObject
+from .non_negative_int_value_object import NonNegativeIntValueObject
+from .non_negative_float_value_object import NonNegativeFloatValueObject
+from .non_negative_decimal_value_object import NonNegativeDecimalValueObject
 from .email_value_object import EmailValueObject
 from .phone_number_value_object import PhoneNumberValueObject
 from .currency_value_object import CurrencyValueObject

{ddd_value_objects-0.2.1.1 → ddd_value_objects-0.2.2.0}/src/ddd_value_objects/decimal_value_object.py

@@ -11,6 +11,7 @@ class DecimalValueObject(ValueObject[Decimal]):
     def __post_init__(self):
         super().__post_init__()
         self._ensure_value_is_decimal(self.value)
+        self._ensure_is_finite(self.value)
         self._ensure_is_within_range(self.value)
 
     def _ensure_value_is_decimal(self, value: Decimal) -> None:
@@ -19,6 +20,10 @@ class DecimalValueObject(ValueObject[Decimal]):
                 self.get_invalid_type_error_message(value)
             )
 
+    def _ensure_is_finite(self, value: Decimal) -> None:
+        if not value.is_finite():
+            raise InvalidArgumentError(self.get_non_finite_error_message(value))
+
     def _ensure_is_within_range(self, value: Decimal) -> None:
         min_value = self.min_value()
         max_value = self.max_value()
@@ -35,6 +40,9 @@ class DecimalValueObject(ValueObject[Decimal]):
     def max_value(self) -> Decimal | None:
         return None
 
+    def get_non_finite_error_message(self, value: Decimal) -> str:
+        return f"Value must be finite, got {value}"
+
     def get_invalid_type_error_message(self, value: Any) -> str:
         return f"Value must be a decimal, got {type(value)}"
 

{ddd_value_objects-0.2.1.1 → ddd_value_objects-0.2.2.0}/src/ddd_value_objects/float_value_object.py

@@ -1,4 +1,5 @@
 from typing import Any
+import math
 from dataclasses import dataclass
 
 from .invalid_argument_error import InvalidArgumentError
@@ -10,6 +11,7 @@ class FloatValueObject(ValueObject[float]):
     def __post_init__(self):
         super().__post_init__()
         self._ensure_value_is_float(self.value)
+        self._ensure_is_finite(self.value)
         self._ensure_is_within_range(self.value)
 
     def _ensure_value_is_float(self, value: float) -> None:
@@ -18,6 +20,10 @@ class FloatValueObject(ValueObject[float]):
                 self.get_invalid_type_error_message(value)
             )
 
+    def _ensure_is_finite(self, value: float) -> None:
+        if not math.isfinite(value):
+            raise InvalidArgumentError(self.get_non_finite_error_message(value))
+
     def _ensure_is_within_range(self, value: float) -> None:
         min_value = self.min_value()
         max_value = self.max_value()
@@ -34,6 +40,9 @@ class FloatValueObject(ValueObject[float]):
     def max_value(self) -> float | None:
         return None
 
+    def get_non_finite_error_message(self, value: float) -> str:
+        return f"Value must be finite, got {value}"
+
     def get_invalid_type_error_message(self, value: Any) -> str:
         return f"Value must be a float, got {type(value)}"
 

{ddd_value_objects-0.2.1.1 → ddd_value_objects-0.2.2.0}/src/ddd_value_objects/int_value_object.py

@@ -13,7 +13,7 @@ class IntValueObject(ValueObject[int]):
         self._ensure_is_within_range(self.value)
 
     def _ensure_value_is_integer(self, value: int) -> None:
-        if not isinstance(value, int):
+        if isinstance(value, bool) or not isinstance(value, int):
             raise InvalidArgumentError(
                 self.get_invalid_type_error_message(value)
             )

ddd_value_objects-0.2.1.1/src/ddd_value_objects/positive_decimal_value_object.py → ddd_value_objects-0.2.2.0/src/ddd_value_objects/non_negative_decimal_value_object.py

@@ -5,9 +5,9 @@ from .decimal_value_object import DecimalValueObject
 
 
 @dataclass(frozen=True, slots=True)
-class PositiveDecimalValueObject(DecimalValueObject):
+class NonNegativeDecimalValueObject(DecimalValueObject):
     def min_value(self) -> Decimal | None:
         return Decimal("0")
 
     def get_too_low_error_message(self, value: Decimal, min_value: Decimal) -> str:
-        return f"'{value}' is not a positive decimal"
+        return f"'{value}' is not a non-negative decimal"

ddd_value_objects-0.2.1.1/src/ddd_value_objects/positive_float_value_object.py → ddd_value_objects-0.2.2.0/src/ddd_value_objects/non_negative_float_value_object.py

@@ -4,9 +4,9 @@ from .float_value_object import FloatValueObject
 
 
 @dataclass(frozen=True, slots=True)
-class PositiveFloatValueObject(FloatValueObject):
+class NonNegativeFloatValueObject(FloatValueObject):
     def min_value(self) -> float | None:
         return 0.0
 
     def get_too_low_error_message(self, value: float, min_value: float) -> str:
-        return f"'{value}' is not a positive float"
+        return f"'{value}' is not a non-negative float"

ddd_value_objects-0.2.2.0/src/ddd_value_objects/non_negative_int_value_object.py

@@ -0,0 +1,12 @@
+from dataclasses import dataclass
+
+from .int_value_object import IntValueObject
+
+
+@dataclass(frozen=True, slots=True)
+class NonNegativeIntValueObject(IntValueObject):
+    def min_value(self) -> int | None:
+        return 0
+
+    def get_too_low_error_message(self, value: int, min_value: int) -> str:
+        return f"'{value}' is not a non-negative integer"

ddd_value_objects-0.2.2.0/src/ddd_value_objects/positive_decimal_value_object.py

@@ -0,0 +1,20 @@
+from dataclasses import dataclass
+from decimal import Decimal
+
+from .decimal_value_object import DecimalValueObject
+from .invalid_argument_error import InvalidArgumentError
+
+
+@dataclass(frozen=True, slots=True)
+class PositiveDecimalValueObject(DecimalValueObject):
+    def min_value(self) -> Decimal | None:
+        return Decimal("0")
+
+    def get_too_low_error_message(self, value: Decimal, min_value: Decimal) -> str:
+        return f"'{value}' is not a positive decimal"
+
+    def _ensure_is_within_range(self, value: Decimal) -> None:
+        min_value = self.min_value()
+        if min_value is not None and value <= min_value:
+            raise InvalidArgumentError(self.get_too_low_error_message(value, min_value))
+        super()._ensure_is_within_range(value)

ddd_value_objects-0.2.2.0/src/ddd_value_objects/positive_float_value_object.py

@@ -0,0 +1,19 @@
+from dataclasses import dataclass
+
+from .float_value_object import FloatValueObject
+from .invalid_argument_error import InvalidArgumentError
+
+
+@dataclass(frozen=True, slots=True)
+class PositiveFloatValueObject(FloatValueObject):
+    def min_value(self) -> float | None:
+        return 0.0
+
+    def get_too_low_error_message(self, value: float, min_value: float) -> str:
+        return f"'{value}' is not a positive float"
+
+    def _ensure_is_within_range(self, value: float) -> None:
+        min_value = self.min_value()
+        if min_value is not None and value <= min_value:
+            raise InvalidArgumentError(self.get_too_low_error_message(value, min_value))
+        super()._ensure_is_within_range(value)

{ddd_value_objects-0.2.1.1 → ddd_value_objects-0.2.2.0}/src/ddd_value_objects/positive_int_value_object.py

@@ -6,7 +6,7 @@ from .int_value_object import IntValueObject
 @dataclass(frozen=True, slots=True)
 class PositiveIntValueObject(IntValueObject):
     def min_value(self) -> int | None:
-        return 0
+        return 1
 
     def get_too_low_error_message(self, value: int, min_value: int) -> str:
         return f"'{value}' is not a positive integer"

{ddd_value_objects-0.2.1.1 → ddd_value_objects-0.2.2.0/src/ddd_value_objects.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ddd-value-objects
-Version: 0.2.1.1
+Version: 0.2.2.0
 Summary: A collection of base classes for Domain-Driven Design (DDD) value objects and entities in Python
 License: MIT
 Requires-Python: >=3.10
@@ -177,7 +177,7 @@ print(product1 == product2) # True (Same identity/ID)
 | Category | Classes |
 | :--- | :--- |
 | **Primitives** | `StringValueObject`, `IntValueObject`, `FloatValueObject`, `BoolValueObject` |
-| **Numeric** | `PositiveIntValueObject`, `PositiveFloatValueObject` |
+| **Numeric** | `PositiveIntValueObject`, `PositiveFloatValueObject`, `PositiveDecimalValueObject`, `NonNegativeIntValueObject`, `NonNegativeFloatValueObject`, `NonNegativeDecimalValueObject` |
 | **Identity** | `UuidValueObject` |
 | **Network** | `EmailValueObject`, `UrlValueObject`, `IpAddressValueObject` |
 | **Communication** | `PhoneNumberValueObject`, `CountryCodeValueObject` (ISO 3166-1 alpha-2) |

{ddd_value_objects-0.2.1.1 → ddd_value_objects-0.2.2.0}/src/ddd_value_objects.egg-info/SOURCES.txt

@@ -16,6 +16,9 @@ src/ddd_value_objects/int_value_object.py
 src/ddd_value_objects/invalid_argument_error.py
 src/ddd_value_objects/ip_address_value_object.py
 src/ddd_value_objects/money_value_object.py
+src/ddd_value_objects/non_negative_decimal_value_object.py
+src/ddd_value_objects/non_negative_float_value_object.py
+src/ddd_value_objects/non_negative_int_value_object.py
 src/ddd_value_objects/phone_number_value_object.py
 src/ddd_value_objects/positive_decimal_value_object.py
 src/ddd_value_objects/positive_float_value_object.py
@@ -35,9 +38,11 @@ tests/test_date_time_value_object.py
 tests/test_date_value_object.py
 tests/test_email_value_object.py
 tests/test_enum_value_object.py
+tests/test_float_value_object.py
 tests/test_integrated_validations.py
 tests/test_ip_address_value_object.py
 tests/test_money_value_object.py
+tests/test_non_negative_value_objects.py
 tests/test_phone_number_value_object.py
 tests/test_positive_value_objects.py
 tests/test_primitives.py

ddd_value_objects-0.2.2.0/tests/test_float_value_object.py

@@ -0,0 +1,34 @@
+import pytest
+
+from src.ddd_value_objects import FloatValueObject, InvalidArgumentError
+
+
+def test_float_value_object_rejects_nan():
+    with pytest.raises(InvalidArgumentError, match="Value must be finite"):
+        FloatValueObject(float("nan"))
+
+
+def test_float_value_object_rejects_infinity():
+    with pytest.raises(InvalidArgumentError, match="Value must be finite"):
+        FloatValueObject(float("inf"))
+
+
+def test_float_value_object_rejects_negative_infinity():
+    with pytest.raises(InvalidArgumentError, match="Value must be finite"):
+        FloatValueObject(float("-inf"))
+
+
+def test_float_value_object_accepts_finite_values():
+    assert FloatValueObject(1.5).value == 1.5
+    assert FloatValueObject(0.0).value == 0.0
+
+
+def test_float_value_object_non_finite_error_message():
+    vo = FloatValueObject(1.0)
+    assert vo.get_non_finite_error_message(float("nan")) == "Value must be finite, got nan"
+
+
+def test_float_value_object_error_message_templates():
+    vo = FloatValueObject(1.0)
+    assert vo.get_too_low_error_message_template() == "Value is less than minimum required {min_value}"
+    assert vo.get_too_high_error_message_template() == "Value is greater than maximum allowed {max_value}"

ddd_value_objects-0.2.2.0/tests/test_non_negative_value_objects.py

@@ -0,0 +1,78 @@
+import pytest
+from decimal import Decimal
+
+from src.ddd_value_objects import (
+    NonNegativeIntValueObject,
+    NonNegativeFloatValueObject,
+    NonNegativeDecimalValueObject,
+    InvalidArgumentError,
+)
+
+
+def test_non_negative_int_value_object():
+    vo1 = NonNegativeIntValueObject(10)
+    vo2 = NonNegativeIntValueObject(10)
+    vo3 = NonNegativeIntValueObject(20)
+
+    assert vo1.value == 10
+    assert vo1.equals(vo2)
+    assert not vo1.equals(vo3)
+    assert repr(vo1) == "NonNegativeIntValueObject(value=10)"
+
+
+def test_non_negative_int_value_object_zero():
+    vo = NonNegativeIntValueObject(0)
+    assert vo.value == 0
+
+
+def test_non_negative_int_value_object_invalid():
+    with pytest.raises(InvalidArgumentError, match="is not a non-negative integer"):
+        NonNegativeIntValueObject(-1)
+
+
+def test_non_negative_float_value_object():
+    vo1 = NonNegativeFloatValueObject(10.5)
+    vo2 = NonNegativeFloatValueObject(10.5)
+    vo3 = NonNegativeFloatValueObject(20.5)
+
+    assert vo1.value == 10.5
+    assert vo1.equals(vo2)
+    assert not vo1.equals(vo3)
+    assert repr(vo1) == "NonNegativeFloatValueObject(value=10.5)"
+
+
+def test_non_negative_float_value_object_zero():
+    vo = NonNegativeFloatValueObject(0.0)
+    assert vo.value == 0.0
+
+
+def test_non_negative_float_value_object_invalid():
+    with pytest.raises(InvalidArgumentError, match="is not a non-negative float"):
+        NonNegativeFloatValueObject(-1.5)
+
+
+def test_non_negative_decimal_value_object():
+    vo1 = NonNegativeDecimalValueObject(Decimal("10.5"))
+    assert vo1.value == Decimal("10.5")
+
+
+def test_non_negative_decimal_value_object_zero():
+    vo = NonNegativeDecimalValueObject(Decimal("0"))
+    assert vo.value == Decimal("0")
+
+
+def test_non_negative_decimal_value_object_invalid():
+    with pytest.raises(InvalidArgumentError, match="is not a non-negative decimal"):
+        NonNegativeDecimalValueObject(Decimal("-1.5"))
+
+
+def test_non_negative_int_with_extra_range():
+    class PortNumber(NonNegativeIntValueObject):
+        def max_value(self) -> int:
+            return 65535
+
+    assert PortNumber(8080).value == 8080
+    with pytest.raises(InvalidArgumentError, match="greater than maximum allowed 65535"):
+        PortNumber(70000)
+    with pytest.raises(InvalidArgumentError, match="is not a non-negative integer"):
+        PortNumber(-1)

{ddd_value_objects-0.2.1.1 → ddd_value_objects-0.2.2.0}/tests/test_positive_value_objects.py

@@ -21,9 +21,9 @@ def test_positive_int_value_object_invalid():
     with pytest.raises(InvalidArgumentError, match="is not a positive integer"):
         PositiveIntValueObject(-1)
 
-def test_positive_int_value_object_zero():
-    vo = PositiveIntValueObject(0)
-    assert vo.value == 0
+def test_positive_int_value_object_zero_invalid():
+    with pytest.raises(InvalidArgumentError, match="is not a positive integer"):
+        PositiveIntValueObject(0)
 
 def test_positive_float_value_object():
     vo1 = PositiveFloatValueObject(10.5)
@@ -39,9 +39,9 @@ def test_positive_float_value_object_invalid():
     with pytest.raises(InvalidArgumentError, match="is not a positive float"):
         PositiveFloatValueObject(-1.5)
 
-def test_positive_float_value_object_zero():
-    vo = PositiveFloatValueObject(0.0)
-    assert vo.value == 0.0
+def test_positive_float_value_object_zero_invalid():
+    with pytest.raises(InvalidArgumentError, match="is not a positive float"):
+        PositiveFloatValueObject(0.0)
 
 def test_positive_decimal_value_object():
     vo1 = PositiveDecimalValueObject(Decimal("10.5"))
@@ -51,9 +51,9 @@ def test_positive_decimal_value_object_invalid():
     with pytest.raises(InvalidArgumentError, match="is not a positive decimal"):
         PositiveDecimalValueObject(Decimal("-1.5"))
 
-def test_positive_decimal_value_object_zero():
-    vo = PositiveDecimalValueObject(Decimal("0"))
-    assert vo.value == Decimal("0")
+def test_positive_decimal_value_object_zero_invalid():
+    with pytest.raises(InvalidArgumentError, match="is not a positive decimal"):
+        PositiveDecimalValueObject(Decimal("0"))
 
 def test_positive_int_with_extra_range():
     class RestrictedAge(PositiveIntValueObject):

{ddd_value_objects-0.2.1.1 → ddd_value_objects-0.2.2.0}/tests/test_primitives.py

@@ -139,10 +139,10 @@ def test_positive_decimal_value_object_valid():
     assert vo.value == val
 
 
-def test_positive_decimal_value_object_zero():
+def test_positive_decimal_value_object_zero_invalid():
     val = Decimal("0.00")
-    vo = PositiveDecimalValueObject(val)
-    assert vo.value == val
+    with pytest.raises(InvalidArgumentError, match="is not a positive decimal"):
+        PositiveDecimalValueObject(val)
 
 
 def test_positive_decimal_value_object_invalid():
@@ -190,3 +190,40 @@ def test_decimal_value_object_custom_too_high_message():
 
     with pytest.raises(InvalidArgumentError, match='Too high: 15.0 > 10.0'):
         CustomMessageDecimal(Decimal('15.0'))
+
+
+def test_decimal_value_object_rejects_nan():
+    with pytest.raises(InvalidArgumentError, match="Value must be finite"):
+        DecimalValueObject(Decimal("NaN"))
+
+
+def test_decimal_value_object_rejects_infinity():
+    with pytest.raises(InvalidArgumentError, match="Value must be finite"):
+        DecimalValueObject(Decimal("Infinity"))
+
+
+def test_decimal_value_object_rejects_negative_infinity():
+    with pytest.raises(InvalidArgumentError, match="Value must be finite"):
+        DecimalValueObject(Decimal("-Infinity"))
+
+
+def test_decimal_value_object_accepts_finite_values():
+    assert DecimalValueObject(Decimal("1.5")).value == Decimal("1.5")
+    assert DecimalValueObject(Decimal("0")).value == Decimal("0")
+
+
+def test_decimal_value_object_non_finite_error_message():
+    vo = DecimalValueObject(Decimal("1"))
+    assert vo.get_non_finite_error_message(Decimal("NaN")) == "Value must be finite, got NaN"
+
+
+def test_int_value_object_error_message_templates():
+    vo = IntValueObject(1)
+    assert vo.get_too_low_error_message_template() == "Value is less than minimum required {min_value}"
+    assert vo.get_too_high_error_message_template() == "Value is greater than maximum allowed {max_value}"
+
+
+def test_decimal_value_object_error_message_templates():
+    vo = DecimalValueObject(Decimal("1"))
+    assert vo.get_too_low_error_message_template() == "Value is less than minimum required {min_value}"
+    assert vo.get_too_high_error_message_template() == "Value is greater than maximum allowed {max_value}"

{ddd_value_objects-0.2.1.1 → ddd_value_objects-0.2.2.0}/tests/test_string_length_validations.py

@@ -56,3 +56,9 @@ def test_custom_length_error_messages():
             
     with pytest.raises(InvalidArgumentError, match="Demasiado corto: 4 < 5"):
         CustomMessageString("1234")
+
+
+def test_string_value_object_error_message_templates():
+    vo = StringValueObject("abc")
+    assert vo.get_too_short_error_message_template() == "Value is too short. Minimum length is {min_length}"
+    assert vo.get_too_long_error_message_template() == "Value is too long. Maximum length is {max_length}"