value-object-pattern 1.26.0__tar.gz → 1.28.0__tar.gz

{value_object_pattern-1.26.0 → value_object_pattern-1.28.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: value-object-pattern
-Version: 1.26.0
+Version: 1.28.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.26.0 → value_object_pattern-1.28.0}/pyproject.toml

@@ -50,7 +50,6 @@ Issues = 'https://github.com/adriamontoto/value-object-pattern/issues'
 
 
 [dependency-groups]
-audit = ['pip-audit>=2.9.0']
 coverage = ['coverage[toml]>=7.0.0', 'smokeshow>=0.5.0']
 develop = ['pre-commit>=3.0.0']
 format = ['ruff>=0.11.10']
@@ -69,7 +68,6 @@ test = [
 ]
 types = ['types-python-dateutil>=2.9.0.20241206']
 all = [
-    { include-group = 'audit' },
     { include-group = 'coverage' },
     { include-group = 'develop' },
     { include-group = 'format' },

{value_object_pattern-1.26.0 → value_object_pattern-1.28.0}/value_object_pattern/__init__.py

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

{value_object_pattern-1.26.0 → value_object_pattern-1.28.0}/value_object_pattern/usables/__init__.py

@@ -3,11 +3,13 @@ from .primitives import (
     AlphanumericStringValueObject,
     BooleanValueObject,
     BytesValueObject,
+    CamelCaseStringValueObject,
     DigitStringValueObject,
     EvenIntegerValueObject,
     FalseValueObject,
     FloatValueObject,
     IntegerValueObject,
+    KebabCaseStringValueObject,
     LowercaseStringValueObject,
     NegativeFloatValueObject,
     NegativeIntegerValueObject,
@@ -17,11 +19,14 @@ from .primitives import (
     NotEmptyStringValueObject,
     NotNoneValueObject,
     OddIntegerValueObject,
+    PascalCaseStringValueObject,
     PositiveFloatValueObject,
     PositiveIntegerValueObject,
     PositiveOrZeroFloatValueObject,
     PositiveOrZeroIntegerValueObject,
     PrintableStringValueObject,
+    ScreamingSnakeCaseStringValueObject,
+    SnakeCaseStringValueObject,
     StringValueObject,
     TrimmedStringValueObject,
     TrueValueObject,
@@ -33,12 +38,13 @@ __all__ = (
     'AlphanumericStringValueObject',
     'BooleanValueObject',
     'BytesValueObject',
+    'CamelCaseStringValueObject',
     'DigitStringValueObject',
     'EvenIntegerValueObject',
     'FalseValueObject',
     'FloatValueObject',
-    'HexadecimalStringValueObject',
     'IntegerValueObject',
+    'KebabCaseStringValueObject',
     'LowercaseStringValueObject',
     'LowercaseStringValueObject',
     'NegativeFloatValueObject',
@@ -50,12 +56,15 @@ __all__ = (
     'NotEmptyStringValueObject',
     'NotNoneValueObject',
     'OddIntegerValueObject',
+    'PascalCaseStringValueObject',
     'PositiveFloatValueObject',
     'PositiveIntegerValueObject',
     'PositiveOrZeroFloatValueObject',
     'PositiveOrZeroIntegerValueObject',
     'PrintableStringValueObject',
     'PrintableStringValueObject',
+    'ScreamingSnakeCaseStringValueObject',
+    'SnakeCaseStringValueObject',
     'StringValueObject',
     'StringValueObject',
     'TrimmedStringValueObject',

{value_object_pattern-1.26.0 → value_object_pattern-1.28.0}/value_object_pattern/usables/internet/__init__.py

@@ -7,11 +7,12 @@ from .ipv4_address_value_object import Ipv4AddressValueObject
 from .ipv4_network_value_object import Ipv4NetworkValueObject
 from .ipv6_address_value_object import Ipv6AddressValueObject
 from .ipv6_network_value_object import Ipv6NetworkValueObject
-from .key_value_object import KeyValueObject
+from .keys import KebabCaseKeyValueObject, SnakeCaseKeyValueObject
 from .mac_address_value_object import MacAddressValueObject
 from .port_value_object import PortValueObject
 from .slug_value_object import SlugValueObject
 from .uri import HttpHttpsUrlValueObject, HttpUrlValueObject, HttpsUrlValueObject, UrlValueObject
+from .user_agent_value_object import UserAgentValueObject
 
 __all__ = (
     'AwsCloudRegionValueObject',
@@ -26,9 +27,11 @@ __all__ = (
     'Ipv4NetworkValueObject',
     'Ipv6AddressValueObject',
     'Ipv6NetworkValueObject',
-    'KeyValueObject',
+    'KebabCaseKeyValueObject',
     'MacAddressValueObject',
     'PortValueObject',
     'SlugValueObject',
+    'SnakeCaseKeyValueObject',
     'UrlValueObject',
+    'UserAgentValueObject',
 )

value_object_pattern-1.28.0/value_object_pattern/usables/internet/keys/__init__.py

@@ -0,0 +1,7 @@
+from .kebab_case_key_value_object import KebabCaseKeyValueObject
+from .snake_case_key_value_object import SnakeCaseKeyValueObject
+
+__all__ = (
+    'KebabCaseKeyValueObject',
+    'SnakeCaseKeyValueObject',
+)

value_object_pattern-1.28.0/value_object_pattern/usables/internet/keys/kebab_case_key_value_object.py

@@ -0,0 +1,53 @@
+"""
+KebabCaseKeyValueObject value object.
+"""
+
+from re import Pattern, compile as re_compile
+from typing import NoReturn
+
+from value_object_pattern.decorators import validation
+from value_object_pattern.usables import NotEmptyStringValueObject, TrimmedStringValueObject
+
+
+class KebabCaseKeyValueObject(NotEmptyStringValueObject, TrimmedStringValueObject):
+    """
+    KebabCaseKeyValueObject ensures the provided value is a valid kebab-case dotted key.
+
+    Example:
+    ```python
+    from value_object_pattern.usables.internet.keys import KebabCaseKeyValueObject
+
+    key = KebabCaseKeyValueObject(value='organization.api-keys.rotate-after-days')
+
+    print(repr(key))
+    # >>> KebabCaseKeyValueObject(value='organization.api-keys.rotate-after-days')
+    ```
+    """
+
+    _VALIDATION_REGEX: Pattern[str] = re_compile(pattern=r'^[a-z0-9]+(?:-[a-z0-9]+)*(?:\.[a-z0-9]+(?:-[a-z0-9]+)*)*$')
+
+    @validation(order=0)
+    def _ensure_value_follows_validation_regex(self, value: str) -> None:
+        """
+        Ensures the value object `value` follows the kebab-case dotted key format.
+
+        Args:
+            value (str): The provided value.
+
+        Raises:
+            ValueError: If the `value` has invalid format.
+        """
+        if not self._VALIDATION_REGEX.fullmatch(string=value):
+            self._raise_value_contains_invalid_characters(value=value)
+
+    def _raise_value_contains_invalid_characters(self, value: str) -> NoReturn:
+        """
+        Raises a ValueError if the value object `value` contains invalid characters.
+
+        Args:
+            value (str): The provided value.
+
+        Raises:
+            ValueError: If the `value` has invalid format.
+        """
+        raise ValueError(f'KebabCaseKeyValueObject value <<<{value}>>> has invalid format. Only lowercase letters and digits separated by single hyphens inside dot-separated segments are allowed.')  # noqa: E501  # fmt: skip

value_object_pattern-1.28.0/value_object_pattern/usables/internet/keys/snake_case_key_value_object.py

@@ -0,0 +1,53 @@
+"""
+SnakeCaseKeyValueObject value object.
+"""
+
+from re import Pattern, compile as re_compile
+from typing import NoReturn
+
+from value_object_pattern.decorators import validation
+from value_object_pattern.usables import NotEmptyStringValueObject, TrimmedStringValueObject
+
+
+class SnakeCaseKeyValueObject(NotEmptyStringValueObject, TrimmedStringValueObject):
+    """
+    SnakeCaseKeyValueObject ensures the provided value is a valid snake_case dotted key.
+
+    Example:
+    ```python
+    from value_object_pattern.usables.internet.keys import SnakeCaseKeyValueObject
+
+    key = SnakeCaseKeyValueObject(value='organization.api_keys.rotate_after_days')
+
+    print(repr(key))
+    # >>> SnakeCaseKeyValueObject(value='organization.api_keys.rotate_after_days')
+    ```
+    """
+
+    _VALIDATION_REGEX: Pattern[str] = re_compile(pattern=r'^[a-z0-9]+(?:_[a-z0-9]+)*(?:\.[a-z0-9]+(?:_[a-z0-9]+)*)*$')
+
+    @validation(order=0)
+    def _ensure_value_follows_validation_regex(self, value: str) -> None:
+        """
+        Ensures the value object `value` follows the snake_case dotted key format.
+
+        Args:
+            value (str): The provided value.
+
+        Raises:
+            ValueError: If the `value` has invalid format.
+        """
+        if not self._VALIDATION_REGEX.fullmatch(string=value):
+            self._raise_value_contains_invalid_characters(value=value)
+
+    def _raise_value_contains_invalid_characters(self, value: str) -> NoReturn:
+        """
+        Raises a ValueError if the value object `value` contains invalid characters.
+
+        Args:
+            value (str): The provided value.
+
+        Raises:
+            ValueError: If the `value` has invalid format.
+        """
+        raise ValueError(f'SnakeCaseKeyValueObject value <<<{value}>>> has invalid format. Only lowercase letters and digits separated by single underscores inside dot-separated segments are allowed.')  # noqa: E501  # fmt: skip

{value_object_pattern-1.26.0 → value_object_pattern-1.28.0}/value_object_pattern/usables/internet/slug_value_object.py

@@ -12,6 +12,16 @@ from value_object_pattern.usables import NotEmptyStringValueObject, TrimmedStrin
 class SlugValueObject(NotEmptyStringValueObject, TrimmedStringValueObject):
     """
     SlugValueObject ensures the provided value is a valid slug string.
+
+    Example:
+    ```python
+    from value_object_pattern.usables.internet import SlugValueObject
+
+    slug = SlugValueObject(value='summer-release-2026')
+
+    print(repr(slug))
+    # >>> SlugValueObject(value='summer-release-2026')
+    ```
     """
 
     _VALIDATION_REGEX: Pattern[str] = re_compile(pattern=r'^[a-z0-9]+(?:-[a-z0-9]+)*$')

value_object_pattern-1.28.0/value_object_pattern/usables/internet/user_agent_value_object.py

@@ -0,0 +1,21 @@
+"""
+UserAgentValueObject value object.
+"""
+
+from value_object_pattern.usables import NotEmptyStringValueObject, PrintableStringValueObject, TrimmedStringValueObject
+
+
+class UserAgentValueObject(NotEmptyStringValueObject, PrintableStringValueObject, TrimmedStringValueObject):
+    """
+    UserAgentValueObject ensures the provided value is a non-empty, trimmed, printable user agent string.
+
+    Example:
+    ```python
+    from value_object_pattern.usables.internet import UserAgentValueObject
+
+    user_agent = UserAgentValueObject(value='Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15')
+
+    print(repr(user_agent))
+    # >>> UserAgentValueObject(value='Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15')
+    ```
+    """

{value_object_pattern-1.26.0 → value_object_pattern-1.28.0}/value_object_pattern/usables/internet/utils/tld_domains.txt

@@ -1,4 +1,4 @@
-# This file was automatically updated using "update_lists.py" on 2026-02-15T03:55:23.881612+00:00
+# This file was automatically updated using "update_lists.py" on 2026-04-19T04:07:29.141154+00:00
 
 aaa
 aarp
@@ -742,6 +742,7 @@ meme
 memorial
 men
 menu
+merck
 merckmsd
 mg
 mh

{value_object_pattern-1.26.0 → value_object_pattern-1.28.0}/value_object_pattern/usables/primitives/__init__.py

@@ -20,10 +20,15 @@ from .none import NoneValueObject, NotNoneValueObject
 from .string import (
     AlphaStringValueObject,
     AlphanumericStringValueObject,
+    CamelCaseStringValueObject,
     DigitStringValueObject,
+    KebabCaseStringValueObject,
     LowercaseStringValueObject,
     NotEmptyStringValueObject,
+    PascalCaseStringValueObject,
     PrintableStringValueObject,
+    ScreamingSnakeCaseStringValueObject,
+    SnakeCaseStringValueObject,
     StringValueObject,
     TrimmedStringValueObject,
     UppercaseStringValueObject,
@@ -34,11 +39,13 @@ __all__ = (
     'AlphanumericStringValueObject',
     'BooleanValueObject',
     'BytesValueObject',
+    'CamelCaseStringValueObject',
     'DigitStringValueObject',
     'EvenIntegerValueObject',
     'FalseValueObject',
     'FloatValueObject',
     'IntegerValueObject',
+    'KebabCaseStringValueObject',
     'LowercaseStringValueObject',
     'NegativeFloatValueObject',
     'NegativeIntegerValueObject',
@@ -48,11 +55,14 @@ __all__ = (
     'NotEmptyStringValueObject',
     'NotNoneValueObject',
     'OddIntegerValueObject',
+    'PascalCaseStringValueObject',
     'PositiveFloatValueObject',
     'PositiveIntegerValueObject',
     'PositiveOrZeroFloatValueObject',
     'PositiveOrZeroIntegerValueObject',
     'PrintableStringValueObject',
+    'ScreamingSnakeCaseStringValueObject',
+    'SnakeCaseStringValueObject',
     'StringValueObject',
     'TrimmedStringValueObject',
     'TrueValueObject',

{value_object_pattern-1.26.0 → value_object_pattern-1.28.0}/value_object_pattern/usables/primitives/string/__init__.py

@@ -1,9 +1,14 @@
 from .alpha_value_object import AlphaStringValueObject
 from .alphanumeric_value_object import AlphanumericStringValueObject
+from .camel_case_string_value_object import CamelCaseStringValueObject
 from .digit_value_object import DigitStringValueObject
+from .kebab_case_string_value_object import KebabCaseStringValueObject
 from .lowercase_string_value_object import LowercaseStringValueObject
 from .non_empty_string_value_object import NotEmptyStringValueObject
+from .pascal_case_string_value_object import PascalCaseStringValueObject
 from .printable_string_value_object import PrintableStringValueObject
+from .screaming_snake_case_string_value_object import ScreamingSnakeCaseStringValueObject
+from .snake_case_string_value_object import SnakeCaseStringValueObject
 from .string_value_object import StringValueObject
 from .trimmed_string_value_object import TrimmedStringValueObject
 from .uppercase_string_value_object import UppercaseStringValueObject
@@ -11,10 +16,15 @@ from .uppercase_string_value_object import UppercaseStringValueObject
 __all__ = (
     'AlphaStringValueObject',
     'AlphanumericStringValueObject',
+    'CamelCaseStringValueObject',
     'DigitStringValueObject',
+    'KebabCaseStringValueObject',
     'LowercaseStringValueObject',
     'NotEmptyStringValueObject',
+    'PascalCaseStringValueObject',
     'PrintableStringValueObject',
+    'ScreamingSnakeCaseStringValueObject',
+    'SnakeCaseStringValueObject',
     'StringValueObject',
     'TrimmedStringValueObject',
     'UppercaseStringValueObject',

value_object_pattern-1.28.0/value_object_pattern/usables/primitives/string/camel_case_string_value_object.py

@@ -0,0 +1,55 @@
+"""
+CamelCaseStringValueObject value object.
+"""
+
+from re import Pattern, compile as re_compile
+from typing import NoReturn
+
+from value_object_pattern.decorators import validation
+
+from .non_empty_string_value_object import NotEmptyStringValueObject
+from .trimmed_string_value_object import TrimmedStringValueObject
+
+
+class CamelCaseStringValueObject(NotEmptyStringValueObject, TrimmedStringValueObject):
+    """
+    CamelCaseStringValueObject value object ensures the provided value is camelCase.
+
+    Example:
+    ```python
+    from value_object_pattern.usables import CamelCaseStringValueObject
+
+    string = CamelCaseStringValueObject(value='abcd1234Word')
+
+    print(repr(string))
+    # >>> CamelCaseStringValueObject(value='abcd1234Word')
+    ```
+    """
+
+    _VALIDATION_REGEX: Pattern[str] = re_compile(pattern=r'^[a-z][a-z0-9]*(?:[A-Z][a-z0-9]*)*$')
+
+    @validation(order=0)
+    def _ensure_value_is_camel_case(self, value: str) -> None:
+        """
+        Ensures the value object `value` is camelCase.
+
+        Args:
+            value (str): The provided value.
+
+        Raises:
+            ValueError: If the `value` is not camelCase.
+        """
+        if not self._VALIDATION_REGEX.fullmatch(string=value):
+            self._raise_value_is_not_camel_case(value=value)
+
+    def _raise_value_is_not_camel_case(self, value: str) -> NoReturn:
+        """
+        Raises a ValueError if the value object `value` is not camelCase.
+
+        Args:
+            value (str): The provided value.
+
+        Raises:
+            ValueError: If the `value` is not camelCase.
+        """
+        raise ValueError(f'CamelCaseStringValueObject value <<<{value}>>> has invalid format. Only camelCase strings starting with a lowercase letter and continuing with alphanumeric words are allowed.')  # noqa: E501  # fmt: skip

value_object_pattern-1.28.0/value_object_pattern/usables/primitives/string/kebab_case_string_value_object.py

@@ -0,0 +1,55 @@
+"""
+KebabCaseStringValueObject value object.
+"""
+
+from re import Pattern, compile as re_compile
+from typing import NoReturn
+
+from value_object_pattern.decorators import validation
+
+from .non_empty_string_value_object import NotEmptyStringValueObject
+from .trimmed_string_value_object import TrimmedStringValueObject
+
+
+class KebabCaseStringValueObject(NotEmptyStringValueObject, TrimmedStringValueObject):
+    """
+    KebabCaseStringValueObject value object ensures the provided value is kebab-case.
+
+    Example:
+    ```python
+    from value_object_pattern.usables import KebabCaseStringValueObject
+
+    string = KebabCaseStringValueObject(value='abcd-1234')
+
+    print(repr(string))
+    # >>> KebabCaseStringValueObject(value='abcd-1234')
+    ```
+    """
+
+    _VALIDATION_REGEX: Pattern[str] = re_compile(pattern=r'^[a-z0-9]+(?:-[a-z0-9]+)*$')
+
+    @validation(order=0)
+    def _ensure_value_is_kebab_case(self, value: str) -> None:
+        """
+        Ensures the value object `value` is kebab-case.
+
+        Args:
+            value (str): The provided value.
+
+        Raises:
+            ValueError: If the `value` is not kebab-case.
+        """
+        if not self._VALIDATION_REGEX.fullmatch(string=value):
+            self._raise_value_is_not_kebab_case(value=value)
+
+    def _raise_value_is_not_kebab_case(self, value: str) -> NoReturn:
+        """
+        Raises a ValueError if the value object `value` is not kebab-case.
+
+        Args:
+            value (str): The provided value.
+
+        Raises:
+            ValueError: If the `value` is not kebab-case.
+        """
+        raise ValueError(f'KebabCaseStringValueObject value <<<{value}>>> has invalid format. Only lowercase letters and digits separated by single hyphens are allowed.')  # noqa: E501  # fmt: skip

value_object_pattern-1.28.0/value_object_pattern/usables/primitives/string/pascal_case_string_value_object.py

@@ -0,0 +1,55 @@
+"""
+PascalCaseStringValueObject value object.
+"""
+
+from re import Pattern, compile as re_compile
+from typing import NoReturn
+
+from value_object_pattern.decorators import validation
+
+from .non_empty_string_value_object import NotEmptyStringValueObject
+from .trimmed_string_value_object import TrimmedStringValueObject
+
+
+class PascalCaseStringValueObject(NotEmptyStringValueObject, TrimmedStringValueObject):
+    """
+    PascalCaseStringValueObject value object ensures the provided value is PascalCase.
+
+    Example:
+    ```python
+    from value_object_pattern.usables import PascalCaseStringValueObject
+
+    string = PascalCaseStringValueObject(value='Abcd1234Word')
+
+    print(repr(string))
+    # >>> PascalCaseStringValueObject(value='Abcd1234Word')
+    ```
+    """
+
+    _VALIDATION_REGEX: Pattern[str] = re_compile(pattern=r'^[A-Z][a-z0-9]*(?:[A-Z][a-z0-9]*)*$')
+
+    @validation(order=0)
+    def _ensure_value_is_pascal_case(self, value: str) -> None:
+        """
+        Ensures the value object `value` is PascalCase.
+
+        Args:
+            value (str): The provided value.
+
+        Raises:
+            ValueError: If the `value` is not PascalCase.
+        """
+        if not self._VALIDATION_REGEX.fullmatch(string=value):
+            self._raise_value_is_not_pascal_case(value=value)
+
+    def _raise_value_is_not_pascal_case(self, value: str) -> NoReturn:
+        """
+        Raises a ValueError if the value object `value` is PascalCase.
+
+        Args:
+            value (str): The provided value.
+
+        Raises:
+            ValueError: If the `value` is not PascalCase.
+        """
+        raise ValueError(f'PascalCaseStringValueObject value <<<{value}>>> has invalid format. Only PascalCase strings starting with an uppercase letter and continuing with alphanumeric words are allowed.')  # noqa: E501  # fmt: skip

value_object_pattern-1.28.0/value_object_pattern/usables/primitives/string/screaming_snake_case_string_value_object.py

@@ -0,0 +1,55 @@
+"""
+ScreamingSnakeCaseStringValueObject value object.
+"""
+
+from re import Pattern, compile as re_compile
+from typing import NoReturn
+
+from value_object_pattern.decorators import validation
+
+from .non_empty_string_value_object import NotEmptyStringValueObject
+from .trimmed_string_value_object import TrimmedStringValueObject
+
+
+class ScreamingSnakeCaseStringValueObject(NotEmptyStringValueObject, TrimmedStringValueObject):
+    """
+    ScreamingSnakeCaseStringValueObject value object ensures the provided value is SCREAMING_SNAKE_CASE.
+
+    Example:
+    ```python
+    from value_object_pattern.usables import ScreamingSnakeCaseStringValueObject
+
+    string = ScreamingSnakeCaseStringValueObject(value='ABCD_1234')
+
+    print(repr(string))
+    # >>> ScreamingSnakeCaseStringValueObject(value='ABCD_1234')
+    ```
+    """
+
+    _VALIDATION_REGEX: Pattern[str] = re_compile(pattern=r'^[A-Z0-9]+(?:_[A-Z0-9]+)*$')
+
+    @validation(order=0)
+    def _ensure_value_is_screaming_snake_case(self, value: str) -> None:
+        """
+        Ensures the value object `value` is SCREAMING_SNAKE_CASE.
+
+        Args:
+            value (str): The provided value.
+
+        Raises:
+            ValueError: If the `value` is not SCREAMING_SNAKE_CASE.
+        """
+        if not self._VALIDATION_REGEX.fullmatch(string=value):
+            self._raise_value_is_not_screaming_snake_case(value=value)
+
+    def _raise_value_is_not_screaming_snake_case(self, value: str) -> NoReturn:
+        """
+        Raises a ValueError if the value object `value` is not SCREAMING_SNAKE_CASE.
+
+        Args:
+            value (str): The provided value.
+
+        Raises:
+            ValueError: If the `value` is not SCREAMING_SNAKE_CASE.
+        """
+        raise ValueError(f'ScreamingSnakeCaseStringValueObject value <<<{value}>>> has invalid format. Only uppercase letters and digits separated by single underscores are allowed.')  # noqa: E501  # fmt: skip

value_object_pattern-1.28.0/value_object_pattern/usables/primitives/string/snake_case_string_value_object.py

@@ -0,0 +1,55 @@
+"""
+SnakeCaseStringValueObject value object.
+"""
+
+from re import Pattern, compile as re_compile
+from typing import NoReturn
+
+from value_object_pattern.decorators import validation
+
+from .non_empty_string_value_object import NotEmptyStringValueObject
+from .trimmed_string_value_object import TrimmedStringValueObject
+
+
+class SnakeCaseStringValueObject(NotEmptyStringValueObject, TrimmedStringValueObject):
+    """
+    SnakeCaseStringValueObject value object ensures the provided value is snake_case.
+
+    Example:
+    ```python
+    from value_object_pattern.usables import SnakeCaseStringValueObject
+
+    string = SnakeCaseStringValueObject(value='abcd_1234')
+
+    print(repr(string))
+    # >>> SnakeCaseStringValueObject(value='abcd_1234')
+    ```
+    """
+
+    _VALIDATION_REGEX: Pattern[str] = re_compile(pattern=r'^[a-z0-9]+(?:_[a-z0-9]+)*$')
+
+    @validation(order=0)
+    def _ensure_value_is_snake_case(self, value: str) -> None:
+        """
+        Ensures the value object `value` is snake_case.
+
+        Args:
+            value (str): The provided value.
+
+        Raises:
+            ValueError: If the `value` is not snake_case.
+        """
+        if not self._VALIDATION_REGEX.fullmatch(string=value):
+            self._raise_value_is_not_snake_case(value=value)
+
+    def _raise_value_is_not_snake_case(self, value: str) -> NoReturn:
+        """
+        Raises a ValueError if the value object `value` is not snake_case.
+
+        Args:
+            value (str): The provided value.
+
+        Raises:
+            ValueError: If the `value` is not snake_case.
+        """
+        raise ValueError(f'SnakeCaseStringValueObject value <<<{value}>>> has invalid format. Only lowercase letters and digits separated by single underscores are allowed.')  # noqa: E501  # fmt: skip