valid8r 0.6.3__py3-none-any.whl → 0.7.1__py3-none-any.whl

valid8r/core/maybe.py

@@ -20,7 +20,7 @@ T = TypeVar('T')
 U = TypeVar('U')
 
 
-class Maybe(Generic[T], ABC):
+class Maybe(ABC, Generic[T]):
     """Base class for the Maybe monad."""
 
     @staticmethod

valid8r/core/validators.py

@@ -7,6 +7,7 @@ that either contains the validated value or an error message.
 
 from __future__ import annotations
 
+import re
 from typing import (
     TYPE_CHECKING,
     Generic,
@@ -280,3 +281,285 @@ def length(min_length: int, max_length: int, error_message: str | None = None) -
         return Maybe.failure(error_message or f'String length must be between {min_length} and {max_length}')
 
     return Validator(validator)
+
+
+def matches_regex(pattern: str | re.Pattern[str], error_message: str | None = None) -> Validator[str]:
+    r"""Create a validator that ensures a string matches a regular expression pattern.
+
+    Args:
+        pattern: Regular expression pattern (string or compiled Pattern object)
+        error_message: Optional custom error message
+
+    Returns:
+        Validator[str]: A validator function that checks pattern matching
+
+    Examples:
+        >>> from valid8r.core.validators import matches_regex
+        >>> import re
+        >>> # String pattern
+        >>> validator = matches_regex(r'^\\d{3}-\\d{2}-\\d{4}$')
+        >>> validator('123-45-6789')
+        Success('123-45-6789')
+        >>> validator('invalid').is_failure()
+        True
+        >>> # Compiled regex pattern
+        >>> pattern = re.compile(r'^[A-Z][a-z]+$')
+        >>> validator = matches_regex(pattern)
+        >>> validator('Hello')
+        Success('Hello')
+        >>> validator('hello').is_failure()
+        True
+        >>> # With custom error message
+        >>> validator = matches_regex(r'^\\d{5}$', error_message='Must be a 5-digit ZIP code')
+        >>> validator('1234').error_or('')
+        'Must be a 5-digit ZIP code'
+
+    """
+    compiled_pattern = re.compile(pattern) if isinstance(pattern, str) else pattern
+
+    def validator(value: str) -> Maybe[str]:
+        if compiled_pattern.match(value):
+            return Maybe.success(value)
+        return Maybe.failure(error_message or f'Value must match pattern {compiled_pattern.pattern}')
+
+    return Validator(validator)
+
+
+def in_set(allowed_values: set[T], error_message: str | None = None) -> Validator[T]:
+    """Create a validator that ensures a value is in a set of allowed values.
+
+    Args:
+        allowed_values: Set of allowed values
+        error_message: Optional custom error message
+
+    Returns:
+        Validator[T]: A validator function that checks membership
+
+    Examples:
+        >>> from valid8r.core.validators import in_set
+        >>> # String values
+        >>> validator = in_set({'red', 'green', 'blue'})
+        >>> validator('red')
+        Success('red')
+        >>> validator('yellow').is_failure()
+        True
+        >>> # Numeric values
+        >>> validator = in_set({1, 2, 3, 4, 5})
+        >>> validator(3)
+        Success(3)
+        >>> validator(10).is_failure()
+        True
+        >>> # With custom error message
+        >>> validator = in_set({'small', 'medium', 'large'}, error_message='Size must be S, M, or L')
+        >>> validator('extra-large').error_or('')
+        'Size must be S, M, or L'
+
+    """
+
+    def validator(value: T) -> Maybe[T]:
+        if value in allowed_values:
+            return Maybe.success(value)
+        return Maybe.failure(error_message or f'Value must be one of {allowed_values}')
+
+    return Validator(validator)
+
+
+def non_empty_string(error_message: str | None = None) -> Validator[str]:
+    """Create a validator that ensures a string is not empty.
+
+    Validates that a string contains at least one non-whitespace character.
+    Both empty strings and whitespace-only strings are rejected.
+
+    Args:
+        error_message: Optional custom error message
+
+    Returns:
+        Validator[str]: A validator function that checks for non-empty strings
+
+    Examples:
+        >>> from valid8r.core.validators import non_empty_string
+        >>> validator = non_empty_string()
+        >>> validator('hello')
+        Success('hello')
+        >>> validator('  hello  ')
+        Success('  hello  ')
+        >>> validator('').is_failure()
+        True
+        >>> validator('   ').is_failure()
+        True
+        >>> # With custom error message
+        >>> validator = non_empty_string(error_message='Name is required')
+        >>> validator('').error_or('')
+        'Name is required'
+
+    """
+
+    def validator(value: str) -> Maybe[str]:
+        if value.strip():
+            return Maybe.success(value)
+        return Maybe.failure(error_message or 'String must not be empty')
+
+    return Validator(validator)
+
+
+def unique_items(error_message: str | None = None) -> Validator[list[T]]:
+    """Create a validator that ensures all items in a list are unique.
+
+    Validates that a list contains no duplicate elements by comparing
+    the list length to the set length.
+
+    Args:
+        error_message: Optional custom error message
+
+    Returns:
+        Validator[list[T]]: A validator function that checks for unique items
+
+    Examples:
+        >>> from valid8r.core.validators import unique_items
+        >>> validator = unique_items()
+        >>> validator([1, 2, 3, 4, 5])
+        Success([1, 2, 3, 4, 5])
+        >>> validator([1, 2, 2, 3]).is_failure()
+        True
+        >>> # Works with strings
+        >>> validator(['a', 'b', 'c'])
+        Success(['a', 'b', 'c'])
+        >>> validator(['a', 'b', 'a']).is_failure()
+        True
+        >>> # With custom error message
+        >>> validator = unique_items(error_message='Duplicate items found')
+        >>> validator([1, 1, 2]).error_or('')
+        'Duplicate items found'
+
+    """
+
+    def validator(value: list[T]) -> Maybe[list[T]]:
+        if len(value) == len(set(value)):
+            return Maybe.success(value)
+        return Maybe.failure(error_message or 'All items must be unique')
+
+    return Validator(validator)
+
+
+def subset_of(allowed_set: set[T], error_message: str | None = None) -> Validator[set[T]]:
+    """Create a validator that ensures a set is a subset of allowed values.
+
+    Validates that all elements in the input set are contained within
+    the allowed set. An empty set is always a valid subset.
+
+    Args:
+        allowed_set: The set of allowed values
+        error_message: Optional custom error message
+
+    Returns:
+        Validator[set[T]]: A validator function that checks subset relationship
+
+    Examples:
+        >>> from valid8r.core.validators import subset_of
+        >>> validator = subset_of({1, 2, 3, 4, 5})
+        >>> validator({1, 2, 3})
+        Success({1, 2, 3})
+        >>> validator({1, 2, 3, 4, 5, 6}).is_failure()
+        True
+        >>> # Empty set is valid subset
+        >>> validator(set())
+        Success(set())
+        >>> # With custom error message
+        >>> validator = subset_of({'a', 'b', 'c'}, error_message='Invalid characters')
+        >>> validator({'a', 'd'}).error_or('')
+        'Invalid characters'
+
+    """
+
+    def validator(value: set[T]) -> Maybe[set[T]]:
+        if value.issubset(allowed_set):
+            return Maybe.success(value)
+        return Maybe.failure(error_message or f'Value must be a subset of {allowed_set}')
+
+    return Validator(validator)
+
+
+def superset_of(required_set: set[T], error_message: str | None = None) -> Validator[set[T]]:
+    """Create a validator that ensures a set is a superset of required values.
+
+    Validates that the input set contains all elements from the required set.
+    The input set may contain additional elements beyond those required.
+
+    Args:
+        required_set: The set of required values
+        error_message: Optional custom error message
+
+    Returns:
+        Validator[set[T]]: A validator function that checks superset relationship
+
+    Examples:
+        >>> from valid8r.core.validators import superset_of
+        >>> validator = superset_of({1, 2, 3})
+        >>> validator({1, 2, 3, 4, 5})
+        Success({1, 2, 3, 4, 5})
+        >>> validator({1, 2}).is_failure()
+        True
+        >>> # Exact match is valid
+        >>> validator({1, 2, 3})
+        Success({1, 2, 3})
+        >>> # With custom error message
+        >>> validator = superset_of({'read', 'write'}, error_message='Missing required permissions')
+        >>> validator({'read'}).error_or('')
+        'Missing required permissions'
+
+    """
+
+    def validator(value: set[T]) -> Maybe[set[T]]:
+        if value.issuperset(required_set):
+            return Maybe.success(value)
+        return Maybe.failure(error_message or f'Value must be a superset of {required_set}')
+
+    return Validator(validator)
+
+
+def is_sorted(*, reverse: bool = False, error_message: str | None = None) -> Validator[list[N]]:
+    """Create a validator that ensures a list is sorted.
+
+    Validates that a list is sorted in either ascending or descending order.
+    Uses keyword-only parameters to avoid boolean trap anti-pattern.
+
+    Args:
+        reverse: If True, checks for descending order; otherwise ascending (default)
+        error_message: Optional custom error message
+
+    Returns:
+        Validator[list[N]]: A validator function that checks if list is sorted
+
+    Examples:
+        >>> from valid8r.core.validators import is_sorted
+        >>> # Ascending order (default)
+        >>> validator = is_sorted()
+        >>> validator([1, 2, 3, 4, 5])
+        Success([1, 2, 3, 4, 5])
+        >>> validator([3, 1, 4, 2]).is_failure()
+        True
+        >>> # Descending order
+        >>> validator = is_sorted(reverse=True)
+        >>> validator([5, 4, 3, 2, 1])
+        Success([5, 4, 3, 2, 1])
+        >>> validator([1, 2, 3]).is_failure()
+        True
+        >>> # Works with strings
+        >>> validator = is_sorted()
+        >>> validator(['a', 'b', 'c'])
+        Success(['a', 'b', 'c'])
+        >>> # With custom error message
+        >>> validator = is_sorted(error_message='List must be in order')
+        >>> validator([3, 1, 2]).error_or('')
+        'List must be in order'
+
+    """
+
+    def validator(value: list[N]) -> Maybe[list[N]]:
+        sorted_value = sorted(value, reverse=reverse)
+        if value == sorted_value:
+            return Maybe.success(value)
+        direction = 'descending' if reverse else 'ascending'
+        return Maybe.failure(error_message or f'List must be sorted in {direction} order')
+
+    return Validator(validator)

{valid8r-0.6.3.dist-info → valid8r-0.7.1.dist-info}/METADATA

@@ -1,13 +1,15 @@
 Metadata-Version: 2.4
 Name: valid8r
-Version: 0.6.3
+Version: 0.7.1
 Summary: Clean, flexible input validation for Python applications
+Project-URL: Homepage, https://valid8r.readthedocs.io/
+Project-URL: Repository, https://github.com/mikelane/valid8r
+Project-URL: Documentation, https://valid8r.readthedocs.io/
+Project-URL: Issues, https://github.com/mikelane/valid8r/issues
+Author-email: Mike Lane <mikelane@gmail.com>
 License: MIT
 License-File: LICENSE
-Keywords: validation,input,cli,maybe-monad,parsing,functional-programming
-Author: Mike Lane
-Author-email: mikelane@gmail.com
-Requires-Python: >=3.11,<4.0
+Keywords: cli,functional-programming,input,maybe-monad,parsing,validation
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
@@ -20,13 +22,11 @@ Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Topic :: Software Development :: Quality Assurance
 Classifier: Typing :: Typed
-Requires-Dist: email-validator (>=2.3.0,<3.0.0)
-Requires-Dist: pydantic (>=2.0)
-Requires-Dist: pydantic-core (>=2.27.0,<3.0.0)
-Requires-Dist: uuid-utils (>=0.11.0,<0.12.0)
-Project-URL: Documentation, https://valid8r.readthedocs.io/
-Project-URL: Homepage, https://valid8r.readthedocs.io/
-Project-URL: Repository, https://github.com/mikelane/valid8r
+Requires-Python: >=3.11
+Requires-Dist: email-validator>=2.3.0
+Requires-Dist: pydantic-core>=2.27.0
+Requires-Dist: pydantic>=2.0
+Requires-Dist: uuid-utils>=0.11.0
 Description-Content-Type: text/markdown
 
 # Valid8r
@@ -78,6 +78,30 @@ A clean, flexible input validation library for Python applications.
 - **Enums**: `parse_enum` (type-safe enum parsing)
 - **Custom**: `create_parser`, `make_parser`, `validated_parser` (parser factories)
 
+## Available Validators
+
+### Numeric Validators
+- **`minimum(min_value)`** - Ensures value is at least the minimum (inclusive)
+- **`maximum(max_value)`** - Ensures value is at most the maximum (inclusive)
+- **`between(min_value, max_value)`** - Ensures value is within range (inclusive)
+
+### String Validators
+- **`non_empty_string()`** - Rejects empty strings and whitespace-only strings
+- **`matches_regex(pattern)`** - Validates string matches regex pattern (string or compiled)
+- **`length(min_length, max_length)`** - Validates string length within bounds
+
+### Collection Validators
+- **`in_set(allowed_values)`** - Ensures value is in set of allowed values
+- **`unique_items()`** - Ensures all items in a list are unique
+- **`subset_of(allowed_set)`** - Validates set is subset of allowed values
+- **`superset_of(required_set)`** - Validates set is superset of required values
+- **`is_sorted(reverse=False)`** - Ensures list is sorted (ascending or descending)
+
+### Custom Validators
+- **`predicate(func, error_message)`** - Create custom validator from any predicate function
+
+**Note**: All validators support custom error messages and can be combined using `&` (and), `|` (or), and `~` (not) operators.
+
 ## Installation
 
 **Requirements**: Python 3.11 or higher
@@ -272,4 +296,3 @@ poetry run tox -e bdd
 This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
 
 Copyright (c) 2025 Mike Lane
-

{valid8r-0.6.3.dist-info → valid8r-0.7.1.dist-info}/RECORD

@@ -1,18 +1,18 @@
 valid8r/__init__.py,sha256=2fzSl6XtKX44sdqzf0GBTn4oEaCvhmyGkdsPDMJjZz8,447
 valid8r/core/__init__.py,sha256=ASOdzqCtpZHbHjjYMZkb78Z-nKxtD26ruTY0bd43ImA,520
 valid8r/core/combinators.py,sha256=KvRiDEqoZgH58cBYPO6SW9pdtkyijk0lS8aGSB5DbO4,2349
-valid8r/core/maybe.py,sha256=ifz15tDMwRaQLsYvU3pWGBZBxJ2JyyOW-g5YpOw_-3w,4643
+valid8r/core/maybe.py,sha256=kuD5SsWc6148FkcLBcwmRTPi6D7H4w1dRT8lPrUvYMw,4643
 valid8r/core/parsers.py,sha256=WYAgwCIh8HyrXr0AoZeqa0c43-_iVIK_S3wb2lha73c,67456
-valid8r/core/validators.py,sha256=owzY6s9UWLlC7qZQcu8NmjqzphlxPJpPuaIxujs1YmU,8784
+valid8r/core/validators.py,sha256=e3B_fi7ch5m0Zczg87r8AhrgEdBTcbz-aygrKCvi0dg,18537
 valid8r/prompt/__init__.py,sha256=XYB3NEp-tmqT6fGmETVEeXd7Urj0M4ijlwdRAjj-rG8,175
 valid8r/prompt/basic.py,sha256=fFARuy5nGTE7xM3dB1jpRC3OPNmp4WwaymFMz7BSgdo,7635
-valid8r/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 valid8r/testing/__init__.py,sha256=8mk54zt0Ai2dK0a3GMOTfDPsVQWXaS6uvQJDrkRV9hs,779
 valid8r/testing/assertions.py,sha256=9KGz1JooCoyikyxMX7VuXB9VYAtj-4H_LPYFGdvS-ps,1820
 valid8r/testing/generators.py,sha256=kAV6NRO9x1gPy0BfGs07ETVxjpTIxOZyV9wH2BA1nHA,8791
 valid8r/testing/mock_input.py,sha256=9GRT7h0PCh9Dea-OcQ5Uls7YqhsTdqMWuX6I6ZlW1aw,2334
-valid8r-0.6.3.dist-info/METADATA,sha256=nsJsH6nOR2YwQh4W6jBhFuodpfkODxN8t14Ryyghgf4,9246
-valid8r-0.6.3.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
-valid8r-0.6.3.dist-info/entry_points.txt,sha256=H_24A4zUgnKIXAIRosJliIcntyqMfmcgKh5_Prl7W18,79
-valid8r-0.6.3.dist-info/licenses/LICENSE,sha256=JpEmJvRYOTIUt0UjgvpDrd3U94Wnbt_Grr5z-xU2jtk,1066
-valid8r-0.6.3.dist-info/RECORD,,
+valid8r/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+valid8r-0.7.1.dist-info/METADATA,sha256=O1-f1iS7afFkdqpudNeQvk_lbQ8oAalmh0uzJPhnZgE,10476
+valid8r-0.7.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+valid8r-0.7.1.dist-info/entry_points.txt,sha256=x2MRzcIGcUR5e4GmhLadGdT7YbbohJRMUVubgaR8v_s,82
+valid8r-0.7.1.dist-info/licenses/LICENSE,sha256=JpEmJvRYOTIUt0UjgvpDrd3U94Wnbt_Grr5z-xU2jtk,1066
+valid8r-0.7.1.dist-info/RECORD,,

{valid8r-0.6.3.dist-info → valid8r-0.7.1.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 2.2.1
+Generator: hatchling 1.27.0
 Root-Is-Purelib: true
 Tag: py3-none-any

valid8r-0.7.1.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+docs-build = scripts.docs:build
+docs-serve = scripts.docs:serve

valid8r-0.6.3.dist-info/entry_points.txt

@@ -1,4 +0,0 @@
-[console_scripts]
-docs-build=scripts.docs:build
-docs-serve=scripts.docs:serve
-