ddd-value-objects 0.1.7__tar.gz → 0.2.0__tar.gz

{ddd_value_objects-0.1.7/src/ddd_value_objects.egg-info → ddd_value_objects-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ddd-value-objects
-Version: 0.1.7
+Version: 0.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

{ddd_value_objects-0.1.7 → ddd_value_objects-0.2.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "ddd-value-objects"
-version = "0.1.7"
+version = "0.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"}

{ddd_value_objects-0.1.7 → ddd_value_objects-0.2.0}/src/ddd_value_objects/__init__.py

@@ -19,7 +19,6 @@ from .url_value_object import UrlValueObject
 from .ip_address_value_object import IpAddressValueObject
 from .enum_value_object import EnumValueObject
 from .money_value_object import MoneyValueObject
-from .entity import Entity
 from .invalid_argument_error import InvalidArgumentError
 
 __all__ = [
@@ -44,6 +43,5 @@ __all__ = [
     "IpAddressValueObject",
     "EnumValueObject",
     "MoneyValueObject",
-    "Entity",
     "InvalidArgumentError",
 ]

ddd_value_objects-0.2.0/src/ddd_value_objects/bool_value_object.py

@@ -0,0 +1,21 @@
+from typing import Any
+from dataclasses import dataclass
+
+from .invalid_argument_error import InvalidArgumentError
+from .value_object import ValueObject
+
+
+@dataclass(frozen=True, slots=True)
+class BoolValueObject(ValueObject[bool]):
+    def __post_init__(self):
+        super().__post_init__()
+        self._ensure_value_is_bool(self.value)
+
+    def _ensure_value_is_bool(self, value: bool) -> None:
+        if not isinstance(value, bool):
+            raise InvalidArgumentError(
+                self.get_invalid_type_error_message(value)
+            )
+
+    def get_invalid_type_error_message(self, value: Any) -> str:
+        return f"Value must be a boolean, got {type(value)}"

ddd_value_objects-0.2.0/src/ddd_value_objects/composite_value_object.py

@@ -0,0 +1,25 @@
+from abc import ABC
+from dataclasses import dataclass, fields
+from typing import Any
+
+from .invalid_argument_error import InvalidArgumentError
+
+
+@dataclass(frozen=True, slots=True)
+class CompositeValueObject(ABC):
+    def __post_init__(self):
+        for field in fields(self):
+            field_name = field.name
+            value = getattr(self, field_name)
+            self._ensure_value_is_defined(value, field_name)
+
+    def equals(self, other: Any) -> bool:
+        if other is None or other.__class__ != self.__class__:
+            return False
+        return self == other
+
+    @staticmethod
+    def _ensure_value_is_defined(value: Any, field_name: str = "Value") -> None:
+        if value is None:
+            raise InvalidArgumentError(f"{field_name} must be defined")
+

{ddd_value_objects-0.1.7 → ddd_value_objects-0.2.0}/src/ddd_value_objects/country_code_value_object.py

@@ -1,23 +1,23 @@
 import re
+from dataclasses import dataclass
 
 from .invalid_argument_error import InvalidArgumentError
 from .string_value_object import StringValueObject
 
 
+@dataclass(frozen=True, slots=True)
 class CountryCodeValueObject(StringValueObject):
     """
     Value Object for ISO 3166-1 alpha-2 country codes.
     """
 
-    def __init__(self, value: str):
-        super().__init__(value)
-        self._ensure_is_valid_country_code(value)
+    def __post_init__(self):
+        super().__post_init__()
+        self._ensure_is_valid_country_code(self.value)
 
-    def _ensure_is_valid_country_code(self, value: str) -> None:
+    @staticmethod
+    def _ensure_is_valid_country_code(value: str) -> None:
         if not re.match(r"^[A-Z]{2}$", value):
             raise InvalidArgumentError(
                 f"'{value}' is not a valid ISO 3166-1 alpha-2 country code"
             )
-
-    def __repr__(self):
-        return f"CountryCodeValueObject(value='{self.value}')"

ddd_value_objects-0.2.0/src/ddd_value_objects/currency_value_object.py

@@ -0,0 +1,21 @@
+import re
+from dataclasses import dataclass
+
+from .string_value_object import StringValueObject
+from .invalid_argument_error import InvalidArgumentError
+
+
+@dataclass(frozen=True, slots=True)
+class CurrencyValueObject(StringValueObject):
+    CURRENCY_REGEX = re.compile(r"^[A-Z]{3}$")
+
+    def __post_init__(self):
+        super().__post_init__()
+        self._ensure_is_valid_currency(self.value)
+
+    def _ensure_is_valid_currency(self, value: str) -> None:
+        if not CurrencyValueObject.CURRENCY_REGEX.match(value):
+            raise InvalidArgumentError(self.get_invalid_currency_error_message(value))
+
+    def get_invalid_currency_error_message(self, value: str) -> str:
+        return f"'{value}' is not a valid ISO 4217 currency code"

ddd_value_objects-0.2.0/src/ddd_value_objects/date_time_value_object.py

@@ -0,0 +1,20 @@
+from dataclasses import dataclass
+from datetime import datetime
+from .value_object import ValueObject
+from .invalid_argument_error import InvalidArgumentError
+
+
+@dataclass(frozen=True, slots=True)
+class DateTimeValueObject(ValueObject[int]):
+    def __post_init__(self):
+        super().__post_init__()
+        self._ensure_is_valid_timestamp(self.value)
+
+    def _ensure_is_valid_timestamp(self, value: int) -> None:
+        try:
+            datetime.fromtimestamp(value)
+        except (ValueError, OSError, OverflowError):
+            raise InvalidArgumentError(self.get_invalid_timestamp_error_message(value))
+
+    def get_invalid_timestamp_error_message(self, value: int) -> str:
+        return f"'{value}' is not a valid Unix timestamp"

ddd_value_objects-0.2.0/src/ddd_value_objects/date_value_object.py

@@ -0,0 +1,18 @@
+from dataclasses import dataclass
+from datetime import date, datetime
+from .value_object import ValueObject
+from .invalid_argument_error import InvalidArgumentError
+
+
+@dataclass(frozen=True, slots=True)
+class DateValueObject(ValueObject[int]):
+    def __post_init__(self):
+        super().__post_init__()
+        self._ensure_is_valid_timestamp(self.value)
+
+    @staticmethod
+    def _ensure_is_valid_timestamp(value: int) -> None:
+        try:
+            datetime.fromtimestamp(value)
+        except (ValueError, OSError, OverflowError):
+            raise InvalidArgumentError(f"'{value}' is not a valid Unix timestamp")

ddd_value_objects-0.2.0/src/ddd_value_objects/decimal_value_object.py

@@ -0,0 +1,45 @@
+from typing import Any
+from dataclasses import dataclass
+from decimal import Decimal
+
+from .invalid_argument_error import InvalidArgumentError
+from .value_object import ValueObject
+
+
+@dataclass(frozen=True, slots=True)
+class DecimalValueObject(ValueObject[Decimal]):
+    def __post_init__(self):
+        super().__post_init__()
+        self._ensure_value_is_decimal(self.value)
+        self._ensure_is_within_range(self.value)
+
+    def _ensure_value_is_decimal(self, value: Decimal) -> None:
+        if not isinstance(value, Decimal):
+            raise InvalidArgumentError(
+                self.get_invalid_type_error_message(value)
+            )
+
+    def _ensure_is_within_range(self, value: Decimal) -> None:
+        min_value = self.min_value()
+        max_value = self.max_value()
+
+        if min_value is not None and value < min_value:
+            raise InvalidArgumentError(self.get_too_low_error_message(value, min_value))
+
+        if max_value is not None and value > max_value:
+            raise InvalidArgumentError(self.get_too_high_error_message(value, max_value))
+
+    def min_value(self) -> Decimal | None:
+        return None
+
+    def max_value(self) -> Decimal | None:
+        return None
+
+    def get_invalid_type_error_message(self, value: Any) -> str:
+        return f"Value must be a decimal, got {type(value)}"
+
+    def get_too_low_error_message(self, value: Decimal, min_value: Decimal) -> str:
+        return f"Value {value} is less than minimum required {min_value}"
+
+    def get_too_high_error_message(self, value: Decimal, max_value: Decimal) -> str:
+        return f"Value {value} is greater than maximum allowed {max_value}"

ddd_value_objects-0.2.0/src/ddd_value_objects/email_value_object.py

@@ -0,0 +1,21 @@
+import re
+from dataclasses import dataclass
+
+from .string_value_object import StringValueObject
+from .invalid_argument_error import InvalidArgumentError
+
+
+@dataclass(frozen=True, slots=True)
+class EmailValueObject(StringValueObject):
+    EMAIL_REGEX = re.compile(r"^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+$")
+
+    def __post_init__(self):
+        super().__post_init__()
+        self._ensure_is_valid_email(self.value)
+
+    def _ensure_is_valid_email(self, value: str) -> None:
+        if not EmailValueObject.EMAIL_REGEX.match(value):
+            raise InvalidArgumentError(self.get_invalid_email_error_message(value))
+
+    def get_invalid_email_error_message(self, value: str) -> str:
+        return f"'{value}' is not a valid email address"

ddd_value_objects-0.2.0/src/ddd_value_objects/enum_value_object.py

@@ -0,0 +1,21 @@
+from dataclasses import dataclass
+from typing import List, Any
+
+from .value_object import ValueObject, Primitives
+from .invalid_argument_error import InvalidArgumentError
+
+
+@dataclass(frozen=True, slots=True)
+class EnumValueObject(ValueObject):
+    def __init__(self, value: Primitives, valid_values: List[Primitives]):
+        self._ensure_value_is_valid(value, valid_values)
+        super().__init__(value)
+
+    def _ensure_value_is_valid(self, value: Any, valid_values: List[Any]) -> None:
+        if value not in valid_values:
+            raise InvalidArgumentError(
+                self.get_invalid_enum_error_message(value, valid_values)
+            )
+
+    def get_invalid_enum_error_message(self, value: Any, valid_values: List[Any]) -> str:
+        return f"'{value}' is not a valid value. Allowed values are: {valid_values}"

ddd_value_objects-0.2.0/src/ddd_value_objects/float_value_object.py

@@ -0,0 +1,44 @@
+from typing import Any
+from dataclasses import dataclass
+
+from .invalid_argument_error import InvalidArgumentError
+from .value_object import ValueObject
+
+
+@dataclass(frozen=True, slots=True)
+class FloatValueObject(ValueObject[float]):
+    def __post_init__(self):
+        super().__post_init__()
+        self._ensure_value_is_float(self.value)
+        self._ensure_is_within_range(self.value)
+
+    def _ensure_value_is_float(self, value: float) -> None:
+        if not isinstance(value, float):
+            raise InvalidArgumentError(
+                self.get_invalid_type_error_message(value)
+            )
+
+    def _ensure_is_within_range(self, value: float) -> None:
+        min_value = self.min_value()
+        max_value = self.max_value()
+
+        if min_value is not None and value < min_value:
+            raise InvalidArgumentError(self.get_too_low_error_message(value, min_value))
+
+        if max_value is not None and value > max_value:
+            raise InvalidArgumentError(self.get_too_high_error_message(value, max_value))
+
+    def min_value(self) -> float | None:
+        return None
+
+    def max_value(self) -> float | None:
+        return None
+
+    def get_invalid_type_error_message(self, value: Any) -> str:
+        return f"Value must be a float, got {type(value)}"
+
+    def get_too_low_error_message(self, value: float, min_value: float) -> str:
+        return f"Value {value} is less than minimum required {min_value}"
+
+    def get_too_high_error_message(self, value: float, max_value: float) -> str:
+        return f"Value {value} is greater than maximum allowed {max_value}"

ddd_value_objects-0.2.0/src/ddd_value_objects/int_value_object.py

@@ -0,0 +1,44 @@
+from typing import Any
+from dataclasses import dataclass
+
+from .invalid_argument_error import InvalidArgumentError
+from .value_object import ValueObject
+
+
+@dataclass(frozen=True, slots=True)
+class IntValueObject(ValueObject[int]):
+    def __post_init__(self):
+        super().__post_init__()
+        self._ensure_value_is_integer(self.value)
+        self._ensure_is_within_range(self.value)
+
+    def _ensure_value_is_integer(self, value: int) -> None:
+        if not isinstance(value, int):
+            raise InvalidArgumentError(
+                self.get_invalid_type_error_message(value)
+            )
+
+    def _ensure_is_within_range(self, value: int) -> None:
+        min_value = self.min_value()
+        max_value = self.max_value()
+
+        if min_value is not None and value < min_value:
+            raise InvalidArgumentError(self.get_too_low_error_message(value, min_value))
+
+        if max_value is not None and value > max_value:
+            raise InvalidArgumentError(self.get_too_high_error_message(value, max_value))
+
+    def min_value(self) -> int | None:
+        return None
+
+    def max_value(self) -> int | None:
+        return None
+
+    def get_invalid_type_error_message(self, value: Any) -> str:
+        return f"Value must be a integer, got {type(value)}"
+
+    def get_too_low_error_message(self, value: int, min_value: int) -> str:
+        return f"Value {value} is less than minimum required {min_value}"
+
+    def get_too_high_error_message(self, value: int, max_value: int) -> str:
+        return f"Value {value} is greater than maximum allowed {max_value}"

{ddd_value_objects-0.1.7 → ddd_value_objects-0.2.0}/src/ddd_value_objects/invalid_argument_error.py

@@ -6,6 +6,8 @@ class InvalidArgumentError(Exception):
         super().__init__(self.message)
 
     def __str__(self):
+        if not self.params:
+            return self.message
         return f"{self.message} {self.params}"
 
     def __repr__(self):

ddd_value_objects-0.2.0/src/ddd_value_objects/ip_address_value_object.py

@@ -0,0 +1,21 @@
+import ipaddress
+from dataclasses import dataclass
+
+from .invalid_argument_error import InvalidArgumentError
+from .string_value_object import StringValueObject
+
+
+@dataclass(frozen=True, slots=True)
+class IpAddressValueObject(StringValueObject):
+    def __post_init__(self):
+        super().__post_init__()
+        self._ensure_is_valid_ip(self.value)
+
+    def _ensure_is_valid_ip(self, value: str) -> None:
+        try:
+            ipaddress.ip_address(value)
+        except ValueError:
+            raise InvalidArgumentError(self.get_invalid_ip_error_message(value))
+
+    def get_invalid_ip_error_message(self, value: str) -> str:
+        return f"'{value}' is not a valid IP address"

ddd_value_objects-0.2.0/src/ddd_value_objects/money_value_object.py

@@ -0,0 +1,25 @@
+from dataclasses import dataclass
+from decimal import Decimal
+from .composite_value_object import CompositeValueObject
+from .positive_decimal_value_object import PositiveDecimalValueObject
+from .currency_value_object import CurrencyValueObject
+from .invalid_argument_error import InvalidArgumentError
+
+
+@dataclass(frozen=True, slots=True)
+class MoneyValueObject(CompositeValueObject):
+    amount: Decimal
+    currency: str
+
+    def __post_init__(self):
+        super().__post_init__()
+        PositiveDecimalValueObject(self.amount)
+        CurrencyValueObject(self.currency)
+
+    def add(self, other: 'MoneyValueObject') -> 'MoneyValueObject':
+        if self.currency != other.currency:
+            raise InvalidArgumentError("Cannot add money with different currencies")
+        return MoneyValueObject(self.amount + other.amount, self.currency)
+
+    def __str__(self):
+        return f"{self.amount} {self.currency}"

{ddd_value_objects-0.1.7 → ddd_value_objects-0.2.0}/src/ddd_value_objects/phone_number_value_object.py

@@ -1,25 +1,31 @@
 import re
+from dataclasses import dataclass
 
 from .string_value_object import StringValueObject
 from .invalid_argument_error import InvalidArgumentError
 
 
+@dataclass(frozen=True, slots=True)
 class PhoneNumberValueObject(StringValueObject):
     PHONE_REGEX = re.compile(r"^\+?[1-9]\d{6,14}$")
 
     def __init__(self, value: str):
         clean_value = self._clean_number(value)
         super().__init__(clean_value)
-        self._ensure_is_valid_phone(clean_value)
 
-    def _clean_number(self, value: str) -> str:
+    def __post_init__(self):
+        super().__post_init__()
+        self._ensure_is_valid_phone(self.value)
+
+    @staticmethod
+    def _clean_number(value: str) -> str:
         if not isinstance(value, str):
             return value
         return re.sub(r"[\s\-\(\)]", "", value)
 
     def _ensure_is_valid_phone(self, value: str) -> None:
-        if not self.PHONE_REGEX.match(value):
-            raise InvalidArgumentError(f"'{value}' is not a valid phone number")
+        if not PhoneNumberValueObject.PHONE_REGEX.match(value):
+            raise InvalidArgumentError(self.get_invalid_phone_error_message(value))
 
-    def __repr__(self):
-        return f"PhoneNumberValueObject(value='{self.value}')"
+    def get_invalid_phone_error_message(self, value: str) -> str:
+        return f"'{value}' is not a valid phone number"

ddd_value_objects-0.2.0/src/ddd_value_objects/positive_decimal_value_object.py

@@ -0,0 +1,13 @@
+from dataclasses import dataclass
+from decimal import Decimal
+
+from .decimal_value_object import DecimalValueObject
+
+
+@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"

ddd_value_objects-0.2.0/src/ddd_value_objects/positive_float_value_object.py

@@ -0,0 +1,12 @@
+from dataclasses import dataclass
+
+from .float_value_object import FloatValueObject
+
+
+@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"

ddd_value_objects-0.2.0/src/ddd_value_objects/positive_int_value_object.py

@@ -0,0 +1,12 @@
+from dataclasses import dataclass
+
+from .int_value_object import IntValueObject
+
+
+@dataclass(frozen=True, slots=True)
+class PositiveIntValueObject(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 positive integer"

ddd_value_objects-0.2.0/src/ddd_value_objects/string_value_object.py

@@ -0,0 +1,65 @@
+import re
+from typing import Any
+from dataclasses import dataclass
+
+from .invalid_argument_error import InvalidArgumentError
+from .value_object import ValueObject, Primitives
+
+
+@dataclass(frozen=True, slots=True)
+class StringValueObject(ValueObject[str]):
+    def __post_init__(self):
+        super().__post_init__()
+        self._ensure_value_is_string(self.value)
+        self._ensure_min_length(self.value)
+        self._ensure_max_length(self.value)
+        self._ensure_matches_regex(self.value)
+
+    def _ensure_value_is_string(self, value: str) -> None:
+        if not isinstance(value, str):
+            raise InvalidArgumentError(
+                self.get_invalid_type_error_message(value)
+            )
+
+    def _ensure_min_length(self, value: str) -> None:
+        min_length = self.min_length()
+        if min_length is not None and len(value) < min_length:
+            raise InvalidArgumentError(
+                self.get_too_short_error_message(value, min_length)
+            )
+
+    def _ensure_max_length(self, value: str) -> None:
+        max_length = self.max_length()
+        if max_length is not None and len(value) > max_length:
+            raise InvalidArgumentError(
+                self.get_too_long_error_message(value, max_length)
+            )
+
+    def _ensure_matches_regex(self, value: str) -> None:
+        pattern = self.regex_pattern()
+        if pattern is not None:
+            if not re.match(pattern, value):
+                raise InvalidArgumentError(
+                    self.get_invalid_regex_error_message(value, pattern)
+                )
+
+    def min_length(self) -> int | None:
+        return None
+
+    def max_length(self) -> int | None:
+        return None
+
+    def regex_pattern(self) -> str | None:
+        return None
+
+    def get_invalid_type_error_message(self, value: Any) -> str:
+        return f"Value must be a string, got {type(value)}"
+
+    def get_too_short_error_message(self, value: str, min_length: int) -> str:
+        return f"Value is too short. Minimum length is {min_length}, but got {len(value)}"
+
+    def get_too_long_error_message(self, value: str, max_length: int) -> str:
+        return f"Value is too long. Maximum length is {max_length}, but got {len(value)}"
+
+    def get_invalid_regex_error_message(self, value: str, pattern: str) -> str:
+        return f"Value '{value}' does not match pattern '{pattern}'"

{ddd_value_objects-0.1.7 → ddd_value_objects-0.2.0}/src/ddd_value_objects/url_value_object.py

@@ -1,9 +1,11 @@
 import re
+from dataclasses import dataclass
 
 from .string_value_object import StringValueObject
 from .invalid_argument_error import InvalidArgumentError
 
 
+@dataclass(frozen=True, slots=True)
 class UrlValueObject(StringValueObject):
     URL_REGEX = re.compile(
         r'^(?:http|ftp)s?://'
@@ -13,13 +15,13 @@ class UrlValueObject(StringValueObject):
         r'(?::\d+)?'
         r'(?:/?|[/?]\S+)$', re.IGNORECASE)
 
-    def __init__(self, value: str):
-        super().__init__(value)
-        self._ensure_is_valid_url(value)
+    def __post_init__(self):
+        super().__post_init__()
+        self._ensure_is_valid_url(self.value)
 
     def _ensure_is_valid_url(self, value: str) -> None:
-        if not self.URL_REGEX.match(value):
-            raise InvalidArgumentError(f"'{value}' is not a valid URL")
+        if not UrlValueObject.URL_REGEX.match(value):
+            raise InvalidArgumentError(self.get_invalid_url_error_message(value))
 
-    def __repr__(self):
-        return f"UrlValueObject(value='{self.value}')"
+    def get_invalid_url_error_message(self, value: str) -> str:
+        return f"'{value}' is not a valid URL"

ddd_value_objects-0.2.0/src/ddd_value_objects/uuid_value_object.py

@@ -0,0 +1,21 @@
+import uuid
+from dataclasses import dataclass
+
+from .invalid_argument_error import InvalidArgumentError
+from .value_object import ValueObject, Primitives
+
+
+@dataclass(frozen=True, slots=True)
+class UuidValueObject(ValueObject[str]):
+    def __post_init__(self):
+        super().__post_init__()
+        self._ensure_validate_is_uuid(self.value)
+
+    def _ensure_validate_is_uuid(self, value: str):
+        try:
+            uuid.UUID(value)
+        except ValueError:
+            raise InvalidArgumentError(message=self.get_invalid_uuid_error_message(value))
+
+    def get_invalid_uuid_error_message(self, value: str) -> str:
+        return f"'{value}' is not a valid UUID."

ddd_value_objects-0.2.0/src/ddd_value_objects/value_object.py

@@ -0,0 +1,29 @@
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from decimal import Decimal
+from typing import TypeVar, Generic, Optional, Any
+
+from .invalid_argument_error import InvalidArgumentError
+
+
+Primitives = TypeVar('Primitives', int, str, float, bool, Decimal)
+
+@dataclass(frozen=True, slots=True)
+class ValueObject(ABC, Generic[Primitives]):
+    value: Primitives
+
+    def __post_init__(self):
+        self._ensure_value_is_defined(self.value)
+
+    def equals(self, other: Any) -> bool:
+        if other is None or other.__class__ != self.__class__:
+            return False
+        return self == other
+
+    def __str__(self) -> str:
+        return str(self.value)
+
+    @staticmethod
+    def _ensure_value_is_defined(value: Optional[Primitives]) -> None:
+        if value is None:
+            raise InvalidArgumentError("Value must be defined")

{ddd_value_objects-0.1.7 → ddd_value_objects-0.2.0/src/ddd_value_objects.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ddd-value-objects
-Version: 0.1.7
+Version: 0.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