value-object-pattern 1.0.0__tar.gz → 1.2.0__tar.gz

{value_object_pattern-1.0.0 → value_object_pattern-1.2.0}/PKG-INFO

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

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

{value_object_pattern-1.0.0 → value_object_pattern-1.2.0}/value_object_pattern/decorators/value_object_validation.py

@@ -6,17 +6,22 @@ from functools import wraps
 from typing import Any, Callable
 
 
-def validation(order: int | None = None) -> Callable[[Callable[..., None]], Callable[..., None]]:
+def validation(
+    order: int | None = None,
+    early_process: bool = False,
+) -> Callable[[Callable[..., None]], Callable[..., None]]:
     """
     Decorator for validation the value before the value is created.
 
     Args:
         order (int | None, optional): The order of the validation that will be executed, if None the functions will be
         executed alphabetically. Defaults to None.
+        early_process (bool, optional): If True, the value will be processed before the validation. Defaults to False.
 
     Raises:
         TypeError: If the order is not an integer.
         ValueError: If the order is not equal or greater than 0.
+        TypeError: If early_process is not a boolean.
 
     Returns:
         Callable[[Callable[..., None]], Callable[..., None]]: Wrapper function for the validation.
@@ -48,6 +53,7 @@ def validation(order: int | None = None) -> Callable[[Callable[..., None]], Call
         Raises:
             TypeError: If the order is not an integer.
             ValueError: If the order is not equal or greater than 0.
+            TypeError: If early_process is not a boolean.
 
         Returns:
             Callable[..., None]: Wrapper function for the validation.
@@ -59,8 +65,12 @@ def validation(order: int | None = None) -> Callable[[Callable[..., None]], Call
             if order < 0:
                 raise ValueError(f'Validation order <<<{order}>>> must be equal or greater than 0.')
 
+        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]
 
         @wraps(wrapped=function)
         def wrapper(*args: tuple[Any, ...], **kwargs: dict[str, Any]) -> None:

{value_object_pattern-1.0.0 → value_object_pattern-1.2.0}/value_object_pattern/models/value_object.py

@@ -37,12 +37,13 @@ class ValueObject(ABC, Generic[T]):  # noqa: UP046
     ```
     """
 
-    __slots__ = ('_parameter', '_title', '_value')
-    __match_args__ = ('_parameter', '_title', '_value')
+    __slots__ = ('_early_processed', '_parameter', '_title', '_value')
+    __match_args__ = ('_early_processed', '_parameter', '_title', '_value')
 
     _value: T
     _title: str
     _parameter: str
+    _early_processed: T | None
 
     def __init__(self, *, value: T, title: str | None = None, parameter: str | None = None) -> None:
         """
@@ -103,9 +104,10 @@ class ValueObject(ABC, Generic[T]):  # noqa: UP046
 
         object.__setattr__(self, '_title', title)
         object.__setattr__(self, '_parameter', parameter)
+        object.__setattr__(self, '_early_processed', None)
 
         self._validate(value=value)
-        value = self._process(value=value)
+        value = self._process(value=value) if self._early_processed is None else self._early_processed
 
         object.__setattr__(self, '_value', value)
 
@@ -266,6 +268,10 @@ class ValueObject(ABC, Generic[T]):  # noqa: UP046
             methods = self._gather_decorated_methods(instance=self, attribute_name='_is_validation')
             while methods:
                 method: Callable[..., T] = methods.popleft().__get__(self, self.__class__)
+                if getattr(method, '_early_process', False):
+                    method(value=self.early_process(value=value))
+                    continue
+
                 method(value=value)
 
         except Exception as error:
@@ -362,6 +368,26 @@ class ValueObject(ABC, Generic[T]):  # noqa: UP046
         # sort by class hierarchy, method order attribute, and method name
         return deque([method for _, _, method in sorted(classes_methods, key=sort_key)])
 
+    def early_process(self, value: T) -> T:
+        """
+        This method processes the value object value before validation. This is useful for early processing of the value
+        object value where you need to have a format before validating. If the value object has already been early
+        processed, it returns the already processed value.
+
+        Args:
+            value (T): The value object value.
+
+        Returns:
+            T: The processed value object value.
+        """
+        if self._early_processed is not None:
+            return self._early_processed
+
+        processed_value = self._process(value=value)
+        object.__setattr__(self, '_early_processed', processed_value)
+
+        return processed_value
+
     @property
     def value(self) -> T:
         """

{value_object_pattern-1.0.0 → value_object_pattern-1.2.0}/value_object_pattern/usables/identifiers/world/europe/spain/__init__.py

@@ -1,17 +1,17 @@
-from .car_plate_value_object import CarPlateValueObject
 from .dni_value_object import DniValueObject
 from .nie_value_object import NieValueObject
 from .nif_value_object import NifValueObject
 from .nuss_value_object import NussValueObject
 from .passport_value_object import PassportValueObject
 from .phone_number_value_object import PhoneNumberValueObject
+from .vehicle_plate_value_object import VehiclePlateValueObject
 
 __all__ = (
-    'CarPlateValueObject',
     'DniValueObject',
     'NieValueObject',
     'NifValueObject',
     'NussValueObject',
     'PassportValueObject',
     'PhoneNumberValueObject',
+    'VehiclePlateValueObject',
 )

{value_object_pattern-1.0.0 → value_object_pattern-1.2.0}/value_object_pattern/usables/identifiers/world/europe/spain/dni_value_object.py

@@ -26,8 +26,8 @@ class DniValueObject(NotEmptyStringValueObject, TrimmedStringValueObject):
     ```
     """
 
-    __DNI_VALUE_OBJECT_LETTERS: str = 'TRWAGMYFPDXBNJZSQVHLCKE'
-    __DNI_VALUE_OBJECT_REGEX: Pattern[str] = re_compile(pattern=r'([0-9]{8})([trwagmyfpdxbnjzsqvhlckeTRWAGMYFPDXBNJZSQVHLCKE])')  # noqa: E501  # fmt: skip
+    _DNI_LETTERS: str = 'TRWAGMYFPDXBNJZSQVHLCKE'
+    _IDENTIFICATION_REGEX: Pattern[str] = re_compile(pattern=r'([0-9]{8})[-\s]?([trwagmyfpdxbnjzsqvhlckeTRWAGMYFPDXBNJZSQVHLCKE])')  # noqa: E501  # fmt: skip
 
     @process(order=0)
     def _ensure_value_is_upper(self, value: str) -> str:
@@ -42,38 +42,50 @@ class DniValueObject(NotEmptyStringValueObject, TrimmedStringValueObject):
         """
         return value.upper()
 
-    @validation(order=0)
-    def _ensure_value_is_dni(self, value: str) -> None:
+    @process(order=1)
+    def _ensure_value_is_formatted(self, value: str) -> str:
         """
-        Ensures the value object `value` is a Spanish DNI.
+        Ensures the value object `value` is stored without separators.
 
         Args:
             value (str): The provided value.
 
-        Raises:
-            ValueError: If the `value` is not a Spanish DNI.
+        Returns:
+            str: Formatted value.
         """
-        match = self.__DNI_VALUE_OBJECT_REGEX.fullmatch(string=value)
-        if not match:
-            self._raise_value_is_not_dni(value=value)
+        return self._IDENTIFICATION_REGEX.sub(repl=r'\1\2', string=value)
 
-        number, control_letter = match.groups()
+    @validation(order=0)
+    def _ensure_value_follows_identification_regex(self, value: str) -> None:
+        """
+        Ensures the value object `value` follows the identification regex.
 
-        expected_letter = self._calculate_control_value(number=number)
-        if control_letter.upper() != expected_letter:
+        Args:
+            value (str): The provided value.
+
+        Raises:
+            ValueError: If the `value` does not follow the identification regex.
+        """
+        if not self._IDENTIFICATION_REGEX.fullmatch(string=value):
             self._raise_value_is_not_dni(value=value)
 
-    def _calculate_control_value(self, number: str) -> str:
+    @validation(order=1, early_process=True)
+    def _ensure_value_has_valid_control_letter(self, value: str) -> None:
         """
-        Calculates the control letter for a given number in a Spanish DNI.
+        Ensures the value object `value` has a valid control letter.
 
         Args:
-            number (str): The 8-digit number part of the DNI.
+            value (str): The provided value.
 
-        Returns:
-            str: The calculated control letter.
+        Raises:
+            ValueError: If the `value` does not have a valid control letter.
         """
-        return self.__DNI_VALUE_OBJECT_LETTERS[int(number) % 23]
+        match = self._IDENTIFICATION_REGEX.fullmatch(string=value)
+        number, control_letter = match.groups()  # type: ignore[union-attr]
+
+        expected_letter = self._DNI_LETTERS[int(number) % 23]
+        if control_letter != expected_letter:
+            self._raise_value_is_not_dni(value=value)
 
     def _raise_value_is_not_dni(self, value: str) -> NoReturn:
         """
@@ -86,3 +98,13 @@ class DniValueObject(NotEmptyStringValueObject, TrimmedStringValueObject):
             ValueError: If the `value` is not a Spanish DNI.
         """
         raise ValueError(f'DniValueObject value <<<{value}>>> is not a valid Spanish DNI.')
+
+    @classmethod
+    def regex(cls) -> Pattern[str]:
+        """
+        Returns a list of regex patterns used for validation.
+
+        Returns:
+            Pattern[str]: List of regex patterns.
+        """
+        return cls._IDENTIFICATION_REGEX

{value_object_pattern-1.0.0 → value_object_pattern-1.2.0}/value_object_pattern/usables/identifiers/world/europe/spain/nie_value_object.py

@@ -27,9 +27,9 @@ class NieValueObject(NotEmptyStringValueObject, TrimmedStringValueObject):
     ```
     """
 
-    __NIE_VALUE_OBJECT_LETTERS: str = 'TRWAGMYFPDXBNJZSQVHLCKE'
-    __NIE_VALUE_OBJECT_REGEX: Pattern[str] = re_compile(pattern=r'([xyzXYZ])([0-9]{7})([trwagmyfpdxbnjzsqvhlckeTRWAGMYFPDXBNJZSQVHLCKE])')  # noqa: E501  # fmt: skip
-    __NIE_VALUE_OBJECT_LETTER_TO_NUMBER: ClassVar[dict[str, str]] = {'X': '0', 'Y': '1', 'Z': '2'}
+    _NIE_LETTERS: str = 'TRWAGMYFPDXBNJZSQVHLCKE'
+    _NIE_LETTER_TO_NUMBER: ClassVar[dict[str, str]] = {'X': '0', 'Y': '1', 'Z': '2'}
+    _IDENTIFICATION_REGEX: Pattern[str] = re_compile(pattern=r'([xyzXYZ])[-\s]?([0-9]{7})[-\s]?([trwagmyfpdxbnjzsqvhlckeTRWAGMYFPDXBNJZSQVHLCKE])')  # noqa: E501  # fmt: skip
 
     @process(order=0)
     def _ensure_value_is_upper(self, value: str) -> str:
@@ -44,40 +44,51 @@ class NieValueObject(NotEmptyStringValueObject, TrimmedStringValueObject):
         """
         return value.upper()
 
-    @validation(order=0)
-    def _ensure_value_is_nie(self, value: str) -> None:
+    @process(order=1)
+    def _ensure_value_is_formatted(self, value: str) -> str:
         """
-        Ensures the value object `value` is a Spanish NIE.
+        Ensures the value object `value` is stored without separators.
 
         Args:
             value (str): The provided value.
 
-        Raises:
-            ValueError: If the `value` is not a Spanish NIE.
+        Returns:
+            str: Formatted value.
         """
-        match = self.__NIE_VALUE_OBJECT_REGEX.fullmatch(string=value)
-        if not match:
-            self._raise_value_is_not_nie(value=value)
+        return self._IDENTIFICATION_REGEX.sub(repl=r'\1\2\3', string=value)
+
+    @validation(order=0)
+    def _ensure_value_follows_identification_regex(self, value: str) -> None:
+        """
+        Ensures the value object `value` follows the identification regex.
 
-        first_letter, number, control_letter = match.groups()
+        Args:
+            value (str): The provided value.
 
-        expected_letter = self._calculate_control_value(first_letter=first_letter, number=number)
-        if control_letter.upper() != expected_letter:
+        Raises:
+            ValueError: If the `value` does not follow the identification regex.
+        """
+        if not self._IDENTIFICATION_REGEX.fullmatch(string=value):
             self._raise_value_is_not_nie(value=value)
 
-    def _calculate_control_value(self, first_letter: str, number: str) -> str:
+    @validation(order=1, early_process=True)
+    def _ensure_value_has_valid_control_letter(self, value: str) -> None:
         """
-        Calculates the control letter for a given NIE.
+        Ensures the value object `value` has a valid control letter.
 
         Args:
-            first_letter (str): The first letter of the NIE (X, Y, or Z).
-            number (str): The 7-digit number part of the NIE.
+            value (str): The provided value.
 
-        Returns:
-            str: The expected control letter.
+        Raises:
+            ValueError: If the `value` does not have a valid control letter.
         """
-        number_for_calculation = self.__NIE_VALUE_OBJECT_LETTER_TO_NUMBER[first_letter] + number
-        return self.__NIE_VALUE_OBJECT_LETTERS[int(number_for_calculation) % 23]
+        match = self._IDENTIFICATION_REGEX.fullmatch(string=value)
+        first_letter, number, control_letter = match.groups()  # type: ignore[union-attr]
+
+        number_for_calculation = self._NIE_LETTER_TO_NUMBER[first_letter] + number
+        expected_letter = self._NIE_LETTERS[int(number_for_calculation) % 23]
+        if control_letter.upper() != expected_letter:
+            self._raise_value_is_not_nie(value=value)
 
     def _raise_value_is_not_nie(self, value: str) -> NoReturn:
         """
@@ -90,3 +101,13 @@ class NieValueObject(NotEmptyStringValueObject, TrimmedStringValueObject):
             ValueError: If the `value` is not a Spanish NIE.
         """
         raise ValueError(f'NieValueObject value <<<{value}>>> is not a valid Spanish NIE.')
+
+    @classmethod
+    def regex(cls) -> Pattern[str]:
+        """
+        Returns a list of regex patterns used for validation.
+
+        Returns:
+            Pattern[str]: List of regex patterns.
+        """
+        return cls._IDENTIFICATION_REGEX

{value_object_pattern-1.0.0 → value_object_pattern-1.2.0}/value_object_pattern/usables/identifiers/world/europe/spain/nif_value_object.py

@@ -27,10 +27,10 @@ class NifValueObject(NotEmptyStringValueObject, TrimmedStringValueObject):
     ```
     """
 
-    __NIF_VALUE_OBJECT_REGEX: Pattern[str] = re_compile(pattern=r'([abcdefghjnpqrsuvwABCDEFGHJNPQRSUVW])([0-9]{7})([0-9abcdefghijABCDEFGHIJ])')  # noqa: E501  # fmt: skip
-    __NIF_VALUE_OBJECT_LETTER_CONTROL_LETTERS: ClassVar[list[str]] = ['J', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I']
-    __NIF_VALUE_OBJECT_CONTROL_CHARACTER_LETTERS: ClassVar[set[str]] = {'K', 'P', 'Q', 'S'}
-    __NIF_VALUE_OBJECT_CONTROL_CHARACTER_DIGITS: ClassVar[set[str]] = {'A', 'B', 'E', 'H'}
+    _NIF_LETTER_CONTROL_LETTERS: ClassVar[list[str]] = ['J', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I']
+    _NIF_CONTROL_CHARACTER_LETTERS: ClassVar[set[str]] = {'K', 'P', 'Q', 'S'}
+    _NIF_CONTROL_CHARACTER_DIGITS: ClassVar[set[str]] = {'A', 'B', 'E', 'H'}
+    _IDENTIFICATION_REGEX: Pattern[str] = re_compile(pattern=r'([abcdefghjnpqrsuvwABCDEFGHJNPQRSUVW])[-\s]?([0-9]{7})[-\s]?([0-9abcdefghijABCDEFGHIJ])')  # noqa: E501  # fmt: skip
 
     @process(order=0)
     def _ensure_value_is_upper(self, value: str) -> str:
@@ -45,28 +45,52 @@ class NifValueObject(NotEmptyStringValueObject, TrimmedStringValueObject):
         """
         return value.upper()
 
+    @process(order=1)
+    def _ensure_value_is_formatted(self, value: str) -> str:
+        """
+        Ensures the value object `value` is stored without separators.
+
+        Args:
+            value (str): The provided value.
+
+        Returns:
+            str: Formatted value.
+        """
+        return self._IDENTIFICATION_REGEX.sub(repl=r'\1\2\3', string=value)
+
     @validation(order=0)
-    def _ensure_value_is_nif(self, value: str) -> None:
+    def _ensure_value_follows_identification_regex(self, value: str) -> None:
         """
-        Ensures the value object `value` is a Spanish company NIF.
+        Ensures the value object `value` follows the identification regex.
 
         Args:
             value (str): The provided value.
 
         Raises:
-            ValueError: If the `value` is not a Spanish company NIF.
+            ValueError: If the `value` does not follow the identification regex.
         """
-        match = self.__NIF_VALUE_OBJECT_REGEX.fullmatch(string=value)
-        if not match:
+        if not self._IDENTIFICATION_REGEX.fullmatch(string=value):
             self._raise_value_is_not_nif(value=value)
 
-        first_letter, number, control_character = match.groups()
+    @validation(order=1, early_process=True)
+    def _ensure_value_has_valid_control_letter(self, value: str) -> None:
+        """
+        Ensures the value object `value` has a valid control letter.
+
+        Args:
+            value (str): The provided value.
+
+        Raises:
+            ValueError: If the `value` does not have a valid control letter.
+        """
+        match = self._IDENTIFICATION_REGEX.fullmatch(string=value)
+        first_letter, number, control_character = match.groups()  # type: ignore[union-attr]
 
         expected_number, expected_letter = self._calculate_control_values(number=number)
-        if first_letter.upper() in self.__NIF_VALUE_OBJECT_CONTROL_CHARACTER_DIGITS:
+        if first_letter.upper() in self._NIF_CONTROL_CHARACTER_DIGITS:
             expected = {expected_number}
 
-        elif first_letter.upper() in self.__NIF_VALUE_OBJECT_CONTROL_CHARACTER_LETTERS:
+        elif first_letter.upper() in self._NIF_CONTROL_CHARACTER_LETTERS:
             expected = {expected_letter}
 
         else:
@@ -86,7 +110,7 @@ class NifValueObject(NotEmptyStringValueObject, TrimmedStringValueObject):
             tuple[str, str]: The calculated control digit and letter.
         """
         total = 0
-        for idx, digit in enumerate(number):
+        for idx, digit in enumerate(iterable=number):
             n = int(digit)
             if idx % 2 == 0:
                 n *= 2
@@ -97,7 +121,7 @@ class NifValueObject(NotEmptyStringValueObject, TrimmedStringValueObject):
 
         control_value = (10 - (total % 10)) % 10
 
-        return str(control_value), self.__NIF_VALUE_OBJECT_LETTER_CONTROL_LETTERS[control_value]
+        return str(control_value), self._NIF_LETTER_CONTROL_LETTERS[control_value]
 
     def _raise_value_is_not_nif(self, value: str) -> NoReturn:
         """
@@ -110,3 +134,13 @@ class NifValueObject(NotEmptyStringValueObject, TrimmedStringValueObject):
             ValueError: If the `value` is not a Spanish company NIF.
         """
         raise ValueError(f'NifValueObject value <<<{value}>>> is not a valid Spanish company NIF.')
+
+    @classmethod
+    def regex(cls) -> Pattern[str]:
+        """
+        Returns a list of regex patterns used for validation.
+
+        Returns:
+            Pattern[str]: List of regex patterns.
+        """
+        return cls._IDENTIFICATION_REGEX

{value_object_pattern-1.0.0 → value_object_pattern-1.2.0}/value_object_pattern/usables/identifiers/world/europe/spain/nuss_value_object.py

@@ -26,7 +26,7 @@ class NussValueObject(NotEmptyStringValueObject, TrimmedStringValueObject):
     ```
     """
 
-    __SOCIAL_SECURITY_NUMBER_VALUE_OBJECT_REGEX: Pattern[str] = re_compile(pattern=r'([0-9]{2})[-\s/]?([0-9]{7,8})[-\s/]?([0-9]{2})')  # noqa: E501  # fmt: skip
+    _IDENTIFICATION_REGEX: Pattern[str] = re_compile(pattern=r'([0-9]{2})[-\s/]?([0-9]{7,8})[-\s/]?([0-9]{2})')  # noqa: E501  # fmt: skip
 
     @process(order=0)
     def _ensure_value_is_formatted(self, value: str) -> str:
@@ -39,24 +39,35 @@ class NussValueObject(NotEmptyStringValueObject, TrimmedStringValueObject):
         Returns:
             str: Formatted value.
         """
-        return self.__SOCIAL_SECURITY_NUMBER_VALUE_OBJECT_REGEX.sub(repl=r'\1\2\3', string=value)
+        return self._IDENTIFICATION_REGEX.sub(repl=r'\1\2\3', string=value)
 
     @validation(order=0)
-    def _ensure_value_is_social_security_number(self, value: str) -> None:
+    def _ensure_value_follows_identification_regex(self, value: str) -> None:
         """
-        Ensures the value object `value` is a valid Spanish Social Security Number.
+        Ensures the value object `value` follows the identification regex.
 
         Args:
             value (str): The provided value.
 
         Raises:
-            ValueError: If the `value` is not a valid Spanish Social Security Number.
+            ValueError: If the `value` does not follow the identification regex.
         """
-        match = self.__SOCIAL_SECURITY_NUMBER_VALUE_OBJECT_REGEX.fullmatch(string=value)
-        if not match:
+        if not self._IDENTIFICATION_REGEX.fullmatch(string=value):
             self._raise_value_is_not_social_security_number(value=value)
 
-        province, sequential, control = match.groups()
+    @validation(order=1, early_process=True)
+    def _ensure_value_has_valid_control_letter(self, value: str) -> None:
+        """
+        Ensures the value object `value` has a valid control letter.
+
+        Args:
+            value (str): The provided value.
+
+        Raises:
+            ValueError: If the `value` does not have a valid control letter.
+        """
+        match = self._IDENTIFICATION_REGEX.fullmatch(string=value)
+        province, sequential, control = match.groups()  # type: ignore[union-attr]
 
         expected = self._calculate_control_value(province=province, sequential=sequential)
         if expected != int(control):
@@ -89,3 +100,13 @@ class NussValueObject(NotEmptyStringValueObject, TrimmedStringValueObject):
             ValueError: If the `value` is not a valid Spanish Social Security Number.
         """
         raise ValueError(f'NussValueObject value <<<{value}>>> is not a valid Spanish Social Security Number.')  # noqa: E501  # fmt: skip
+
+    @classmethod
+    def regex(cls) -> Pattern[str]:
+        """
+        Returns a list of regex patterns used for validation.
+
+        Returns:
+            Pattern[str]: List of regex patterns.
+        """
+        return cls._IDENTIFICATION_REGEX

{value_object_pattern-1.0.0 → value_object_pattern-1.2.0}/value_object_pattern/usables/identifiers/world/europe/spain/passport_value_object.py

@@ -26,7 +26,7 @@ class PassportValueObject(NotEmptyStringValueObject, TrimmedStringValueObject):
     ```
     """
 
-    __PASSPORT_VALUE_OBJECT_REGEX: Pattern[str] = re_compile(pattern=r'([a-zA-Z]{2,3})([0-9]{6})')
+    _IDENTIFICATION_REGEX: Pattern[str] = re_compile(pattern=r'([a-zA-Z]{2,3})[-\s]?([0-9]{6})')
 
     @process(order=0)
     def _ensure_value_is_upper(self, value: str) -> str:
@@ -41,19 +41,31 @@ class PassportValueObject(NotEmptyStringValueObject, TrimmedStringValueObject):
         """
         return value.upper()
 
+    @process(order=1)
+    def _ensure_value_is_formatted(self, value: str) -> str:
+        """
+        Ensures the value object `value` is stored without separators.
+
+        Args:
+            value (str): The provided value.
+
+        Returns:
+            str: Formatted value.
+        """
+        return self._IDENTIFICATION_REGEX.sub(repl=r'\1\2', string=value)
+
     @validation(order=0)
-    def _ensure_value_is_passport(self, value: str) -> None:
+    def _ensure_value_follows_identification_regex(self, value: str) -> None:
         """
-        Ensures the value object `value` is a Spanish passport.
+        Ensures the value object `value` follows the identification regex.
 
         Args:
             value (str): The provided value.
 
         Raises:
-            ValueError: If the `value` is not a Spanish passport.
+            ValueError: If the `value` does not follow the identification regex.
         """
-        match = self.__PASSPORT_VALUE_OBJECT_REGEX.fullmatch(string=value)
-        if not match:
+        if not self._IDENTIFICATION_REGEX.fullmatch(string=value):
             self._raise_value_is_not_passport(value=value)
 
     def _raise_value_is_not_passport(self, value: str) -> NoReturn:
@@ -67,3 +79,13 @@ class PassportValueObject(NotEmptyStringValueObject, TrimmedStringValueObject):
             ValueError: If the `value` is not a Spanish passport.
         """
         raise ValueError(f'PassportValueObject value <<<{value}>>> is not a valid Spanish passport.')
+
+    @classmethod
+    def regex(cls) -> Pattern[str]:
+        """
+        Returns a list of regex patterns used for validation.
+
+        Returns:
+            Pattern[str]: List of regex patterns.
+        """
+        return cls._IDENTIFICATION_REGEX