valid8r 1.6.0__py3-none-any.whl

valid8r/__init__.py

@@ -0,0 +1,39 @@
+# valid8r/__init__.py
+"""Valid8r: A clean, flexible input validation library for Python."""
+
+from __future__ import annotations
+
+# Import version from generated file
+try:
+    from valid8r._version import __version__
+except ImportError:
+    __version__ = '1.6.0'
+
+# Public API re-exports for concise imports
+# Modules
+from . import prompt
+from .core import (
+    combinators,
+    parsers,
+    validators,
+)
+from .core.maybe import Maybe
+from .core.parsers import (
+    EmailAddress,
+    PhoneNumber,
+    UrlParts,
+)
+
+# Types
+
+__all__ = [
+    'EmailAddress',
+    'Maybe',
+    'PhoneNumber',
+    'UrlParts',
+    '__version__',
+    'combinators',
+    'parsers',
+    'prompt',
+    'validators',
+]

valid8r/_version.py

@@ -0,0 +1,34 @@
+# file generated by setuptools-scm
+# don't change, don't track in version control
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple
+    from typing import Union
+
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+    COMMIT_ID = Union[str, None]
+else:
+    VERSION_TUPLE = object
+    COMMIT_ID = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+commit_id: COMMIT_ID
+__commit_id__: COMMIT_ID
+
+__version__ = version = '1.6.0'
+__version_tuple__ = version_tuple = (1, 6, 0)
+
+__commit_id__ = commit_id = None

valid8r/core/__init__.py

@@ -0,0 +1,28 @@
+# valid8r/core/__init__.py
+"""Core validation components."""
+
+from __future__ import annotations
+
+from valid8r.core.parsers import (
+    EmailAddress,
+    UrlParts,
+    parse_cidr,
+    parse_email,
+    parse_ip,
+    parse_ipv4,
+    parse_ipv6,
+    parse_url,
+)
+
+__all__ = [
+    'EmailAddress',
+    'UrlParts',
+    'parse_cidr',
+    'parse_email',
+    'parse_ip',
+    # existing exports may be defined elsewhere; explicitly expose IP helpers
+    'parse_ipv4',
+    'parse_ipv6',
+    # URL/Email helpers
+    'parse_url',
+]

valid8r/core/combinators.py

@@ -0,0 +1,89 @@
+"""Combinators for creating complex validation rules.
+
+This module provides functions to combine validators using logical operations like AND, OR, and NOT.
+These combinators allow for creation of complex validation chains.
+"""
+
+from __future__ import annotations
+
+from typing import (
+    TYPE_CHECKING,
+    TypeVar,
+)
+
+from valid8r.core.maybe import (
+    Maybe,
+    Success,
+)
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+T = TypeVar('T')
+
+
+def and_then(first: Callable[[T], Maybe[T]], second: Callable[[T], Maybe[T]]) -> Callable[[T], Maybe[T]]:
+    """Combine two validators with logical AND (both must succeed).
+
+    Args:
+        first: The first validator function
+        second: The second validator function
+
+    Returns:
+        A new validator function that passes only if both validators pass
+
+    """
+
+    def combined_validator(value: T) -> Maybe[T]:
+        result = first(value)
+        match result:
+            case Success(value):
+                return second(value)
+            case _:
+                return result
+
+    return combined_validator
+
+
+def or_else(first: Callable[[T], Maybe[T]], second: Callable[[T], Maybe[T]]) -> Callable[[T], Maybe[T]]:
+    """Combine two validators with logical OR (either can succeed).
+
+    Args:
+        first: The first validator function
+        second: The second validator function
+
+    Returns:
+        A new validator function that passes if either validator passes
+
+    """
+
+    def combined_validator(value: T) -> Maybe[T]:
+        result = first(value)
+        match result:
+            case Success(value):
+                return result
+            case _:
+                return second(value)
+
+    return combined_validator
+
+
+def not_validator(validator: Callable[[T], Maybe[T]], error_message: str) -> Callable[[T], Maybe[T]]:
+    """Negate a validator (success becomes failure and vice versa).
+
+    Args:
+        validator: The validator function to negate
+        error_message: Error message for when the negated validator fails
+
+    Returns:
+        A new validator function that passes if the original validator fails
+
+    """
+
+    def negated_validator(value: T) -> Maybe[T]:
+        result = validator(value)
+        if result.is_failure():
+            return Maybe.success(value)
+        return Maybe.failure(error_message)
+
+    return negated_validator

valid8r/core/maybe.py

@@ -0,0 +1,170 @@
+"""Maybe monad for clean error handling using Success and Failure types."""
+
+from __future__ import annotations
+
+from abc import (
+    ABC,
+    abstractmethod,
+)
+from typing import (
+    TYPE_CHECKING,
+    Generic,
+    TypeVar,
+)
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+
+T = TypeVar('T')
+U = TypeVar('U')
+
+
+class Maybe(ABC, Generic[T]):
+    """Base class for the Maybe monad."""
+
+    @staticmethod
+    def success(value: T) -> Success[T]:
+        """Create a Success containing a value."""
+        return Success(value)
+
+    @staticmethod
+    def failure(error: str) -> Failure[T]:
+        """Create a Failure containing an error message."""
+        return Failure(error)
+
+    @abstractmethod
+    def is_success(self) -> bool:
+        """Check if the Maybe is a Success."""
+
+    @abstractmethod
+    def is_failure(self) -> bool:
+        """Check if the Maybe is a Failure."""
+
+    @abstractmethod
+    def bind(self, f: Callable[[T], Maybe[U]]) -> Maybe[U]:
+        """Chain operations that might fail."""
+
+    @abstractmethod
+    def map(self, f: Callable[[T], U]) -> Maybe[U]:
+        """Transform the value if present."""
+
+    @abstractmethod
+    def value_or(self, default: T) -> T:
+        """Return the contained value or the provided default if this is a Failure."""
+
+    @abstractmethod
+    def error_or(self, default: str) -> str:
+        """Return the error message or the provided default if this is a Success."""
+
+    @abstractmethod
+    def get_error(self) -> str | None:
+        """Get the error message if present, otherwise None."""
+
+
+class Success(Maybe[T]):
+    """Represents a successful computation with a value."""
+
+    __match_args__ = ('value',)
+
+    def __init__(self, value: T) -> None:
+        """Initialize a Success with a value.
+
+        Args:
+            value: The successful result value
+
+        """
+        self.value = value
+
+    def is_success(self) -> bool:
+        """Check if the Maybe is a Success."""
+        return True
+
+    def is_failure(self) -> bool:
+        """Check if the Maybe is a Failure."""
+        return False
+
+    def bind(self, f: Callable[[T], Maybe[U]]) -> Maybe[U]:
+        """Chain operations that might fail."""
+        return f(self.value)
+
+    def map(self, f: Callable[[T], U]) -> Maybe[U]:
+        """Transform the value."""
+        return Success(f(self.value))
+
+    def value_or(self, _default: T) -> T:
+        """Return the contained value (default is ignored for Success)."""
+        return self.value
+
+    def error_or(self, default: str) -> str:
+        """Return the provided default since Success has no error."""
+        return default
+
+    def get_error(self) -> str | None:
+        """Get None since Success has no error."""
+        return None
+
+    def __str__(self) -> str:
+        """Get a string representation."""
+        return f'Success({self.value})'
+
+    def __repr__(self) -> str:
+        """Get a repr representation for debugging and doctests."""
+        return f'Success({self.value!r})'
+
+
+class Failure(Maybe[T]):
+    """Represents a failed computation with an error message."""
+
+    __match_args__ = ('error',)
+
+    def __init__(self, error: str) -> None:
+        """Initialize a Failure with an error message.
+
+        Args:
+            error: The error message explaining the failure
+
+        """
+        self.error = error
+
+    def is_success(self) -> bool:
+        """Check if the Maybe is a Success."""
+        return False
+
+    def is_failure(self) -> bool:
+        """Check if the Maybe is a Failure."""
+        return True
+
+    def bind(self, _f: Callable[[T], Maybe[U]]) -> Maybe[U]:
+        """Chain operations that might fail.
+
+        Function is unused in Failure case as we always propagate the error.
+        """
+        return Failure(self.error)
+
+    def map(self, _f: Callable[[T], U]) -> Maybe[U]:
+        """Transform the value if present.
+
+        Function is unused in Failure case as we always propagate the error.
+        """
+        return Failure(self.error)
+
+    def value_or(self, default: T) -> T:
+        """Return the provided default for Failure."""
+        return default
+
+    def error_or(self, default: str) -> str:
+        """Return the error message for Failure (or provided default if empty)."""
+        return self.error or default
+
+    def get_error(self) -> str | None:
+        """Get the error message."""
+        return self.error
+
+    def __str__(self) -> str:
+        """Get a string representation."""
+        return f'Failure({self.error})'
+
+    def __repr__(self) -> str:
+        """Get a repr representation for debugging and doctests."""
+        return f'Failure({self.error!r})'