valid8r 0.2.0__py3-none-any.whl

valid8r/testing/generators.py

@@ -0,0 +1,283 @@
+"""Generators for test cases and test input data."""
+
+from __future__ import annotations
+
+import random
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    TypeVar,
+)
+
+from valid8r.core.maybe import Success
+
+if TYPE_CHECKING:
+    from collections.abc import Iterable
+    from types import CellType
+
+    from valid8r.core.validators import Validator
+
+T = TypeVar('T')
+
+# Constants for test case generation
+OFFSET_SMALL = 1
+OFFSET_MEDIUM = 5
+OFFSET_LARGE = 10
+OFFSET_XLARGE = 100
+MULTIPLIER_FAR = 2
+
+
+def _extract_numeric_value_from_closure(closure: Iterable[CellType]) -> Any | None:  # noqa: ANN401
+    """Extract a numeric value from a closure."""
+    for cell in closure:
+        value = cell.cell_contents
+        if isinstance(value, int | float):
+            return value
+    return None
+
+
+def _generate_minimum_validator_cases(min_value: float) -> tuple[list[Any], list[Any]]:
+    """Generate test cases for a minimum validator."""
+    valid_cases = [
+        min_value,  # Boundary
+        min_value + OFFSET_SMALL,  # Just above
+        min_value + OFFSET_MEDIUM,  # Above
+        min_value + OFFSET_LARGE,  # Well above
+        min_value * OFFSET_LARGE if min_value > 0 else OFFSET_XLARGE,  # Far above
+    ]
+
+    invalid_cases = [
+        min_value - OFFSET_SMALL,  # Just below
+        min_value - OFFSET_MEDIUM if min_value >= OFFSET_MEDIUM else 0,  # Below
+        min_value - OFFSET_LARGE if min_value >= OFFSET_LARGE else -1,  # Well below
+        -10 if min_value > 0 else min_value - 10,  # Far below
+    ]
+
+    return valid_cases, invalid_cases
+
+
+def _generate_maximum_validator_cases(max_value: float) -> tuple[list[Any], list[Any]]:
+    """Generate test cases for a maximum validator."""
+    valid_cases = [
+        max_value,  # Boundary
+        max_value - OFFSET_SMALL,  # Just below
+        max_value - OFFSET_MEDIUM if max_value >= OFFSET_MEDIUM else 0,  # Below
+        max_value - OFFSET_LARGE if max_value >= OFFSET_LARGE else 0,  # Well below
+        0 if max_value > 0 else max_value // MULTIPLIER_FAR,  # Far below
+    ]
+
+    invalid_cases = [
+        max_value + OFFSET_SMALL,  # Just above
+        max_value + OFFSET_MEDIUM,  # Above
+        max_value + OFFSET_LARGE,  # Well above
+        max_value * MULTIPLIER_FAR,  # Far above
+    ]
+
+    return valid_cases, invalid_cases
+
+
+def _generate_between_validator_cases(min_val: float, max_val: float) -> tuple[list[Any], list[Any]]:
+    """Generate test cases for a between validator."""
+    range_size = max_val - min_val
+    valid_cases = [
+        min_val,  # Min boundary
+        max_val,  # Max boundary
+        (min_val + max_val) // 2,  # Middle
+        min_val + range_size // 4,  # First quarter
+        max_val - range_size // 4,  # Last quarter
+    ]
+
+    invalid_cases = [
+        min_val - 1,  # Just below min
+        max_val + 1,  # Just above max
+        min_val - 10,  # Well below min
+        max_val + 10,  # Well above max
+    ]
+
+    return valid_cases, invalid_cases
+
+
+def _identify_validator_type(validator: Validator[T]) -> tuple[str, Any, Any]:
+    """Identify the type of validator and extract its parameters.
+
+    Returns:
+        A tuple of (validator_type, first_param, second_param)
+
+    """
+    if not hasattr(validator.func, '__closure__') or not validator.func.__closure__:
+        return 'unknown', None, None
+
+    func_str = str(validator.func)
+
+    if 'minimum' in func_str:
+        min_value = _extract_numeric_value_from_closure(validator.func.__closure__)
+        return 'minimum', min_value, None
+
+    if 'maximum' in func_str:
+        max_value = _extract_numeric_value_from_closure(validator.func.__closure__)
+        return 'maximum', max_value, None
+
+    if 'between' in func_str:
+        values = _extract_two_numeric_values(validator.func.__closure__)
+        return 'between', values[0], values[1]
+
+    return 'unknown', None, None
+
+
+def _extract_two_numeric_values(closure: Iterable[CellType]) -> tuple[Any, Any]:
+    """Extract two numeric values from a closure."""
+    values = []
+    for cell in closure:
+        value = cell.cell_contents
+        if isinstance(value, int | float):
+            values.append(value)
+            if len(values) >= 2:  # noqa: PLR2004
+                break
+
+    if len(values) < 2:  # noqa: PLR2004
+        return None, None
+    return values[0], values[1]
+
+
+def generate_test_cases(validator: Validator[T]) -> dict[str, list[Any]]:
+    """Generate test cases for a validator.
+
+    This function analyzes the validator and generates appropriate test cases
+    that should pass and fail the validation.
+
+    Args:
+        validator: The validator to generate test cases for
+
+    Returns:
+        A dictionary with 'valid' and 'invalid' lists of test cases
+
+    Examples:
+        >>> test_cases = generate_test_cases(minimum(10))
+        >>> test_cases
+        {'valid': [10, 11, 15, 20, 100], 'invalid': [9, 5, 0, -10]}
+
+    """
+    # Identify validator type and extract parameters
+    validator_type, param1, param2 = _identify_validator_type(validator)
+
+    # Generate test cases based on validator type
+    valid_cases: list[Any] = []
+    invalid_cases: list[Any] = []
+
+    if validator_type == 'minimum' and param1 is not None:
+        valid_cases, invalid_cases = _generate_minimum_validator_cases(param1)
+
+    elif validator_type == 'maximum' and param1 is not None:
+        valid_cases, invalid_cases = _generate_maximum_validator_cases(param1)
+
+    elif validator_type == 'between' and param1 is not None and param2 is not None:
+        valid_cases, invalid_cases = _generate_between_validator_cases(param1, param2)
+
+    # Use generic cases if we couldn't determine specific ones
+    if not valid_cases:
+        valid_cases = [0, 1, 10, 42, 100]
+    if not invalid_cases:
+        invalid_cases = [-1, -10, -100]
+
+    # Verify categorization against the actual validator
+    actual_valid = []
+    actual_invalid = []
+
+    for case in valid_cases + invalid_cases:
+        result = validator(case)
+        if result.is_success():
+            actual_valid.append(case)
+        else:
+            actual_invalid.append(case)
+
+    return {'valid': actual_valid, 'invalid': actual_invalid}
+
+
+def generate_random_inputs(
+    validator: Validator[T], count: int = 20, range_min: int = -100, range_max: int = 100
+) -> list[T]:
+    """Generate random inputs that include both valid and invalid cases.
+
+    Args:
+        validator: The validator to test against
+        count: Number of inputs to generate
+        range_min: Minimum value for generated integers
+        range_max: Maximum value for generated integers
+
+    Returns:
+        A list of random integers
+
+    Examples:
+        >>> inputs = generate_random_inputs(minimum(0), count=10)
+        >>> len(inputs)
+        10
+
+    """
+    inputs: list[Any] = []
+
+    # Try to make sure we get both valid and invalid cases
+    for _ in range(count):
+        value = random.randint(range_min, range_max)  # noqa: S311
+        inputs.append(value)
+
+    # Verify we have at least one valid and one invalid case
+    has_valid = False
+    has_invalid = False
+
+    for input_val in inputs:
+        result = validator(input_val)
+        match result:
+            case Success(_):
+                has_valid = True
+            case _:
+                has_invalid = True
+
+        if has_valid and has_invalid:
+            break
+
+    # If we're missing either valid or invalid cases, add them explicitly
+    if not has_valid or not has_invalid:
+        # Get test cases that are known to be valid/invalid
+        test_cases = generate_test_cases(validator)
+
+        if not has_valid and test_cases['valid']:
+            # Replace the first item with a valid case
+            inputs[0] = test_cases['valid'][0]
+
+        if not has_invalid and test_cases['invalid']:
+            # Replace the second item with an invalid case
+            inputs[1 if len(inputs) > 1 else 0] = test_cases['invalid'][0]
+
+    return inputs
+
+
+def test_validator_composition(validator: Validator[T]) -> bool:
+    """Test a composed validator with various inputs to verify it works correctly.
+
+    Args:
+        validator: The composed validator to test
+
+    Returns:
+        True if the validator behaves as expected, False otherwise
+
+    Examples:
+        >>> is_valid_age = minimum(0) & maximum(120)
+        >>> test_validator_composition(is_valid_age)  # Returns True
+
+    """
+    # Generate test cases
+    test_cases = generate_test_cases(validator)
+
+    # Check that all valid cases pass
+    for case in test_cases['valid']:
+        result = validator(case)
+        if not result.is_success():
+            return False
+
+    # Check that all invalid cases fail
+    for case in test_cases['invalid']:
+        result = validator(case)
+        if not result.is_failure():
+            return False
+
+    return True

valid8r/testing/mock_input.py

@@ -0,0 +1,84 @@
+"""Utilities for mocking user input during tests."""
+
+from __future__ import annotations
+
+import builtins
+from contextlib import contextmanager
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from collections.abc import Iterator
+
+# Store the original input function
+_original_input = builtins.input
+
+
+@contextmanager
+def MockInputContext(inputs: list[str] | None = None) -> Iterator[None]:  # noqa: N802
+    """Context manager for mocking user input.
+
+    Args:
+        inputs: A list of strings to be returned sequentially by input().
+
+    Yields:
+        None
+
+    Examples:
+        >>> with MockInputContext(["yes", "42"]):
+        ...     answer = input("Continue? ")  # returns "yes"
+        ...     number = input("Enter number: ")  # returns "42"
+
+    """
+    input_values = [] if inputs is None else list(inputs)
+
+    def mock_input(prompt: object = '') -> str:  # noqa: ARG001
+        """Mock implementation of input function.
+
+        Args:
+            prompt: The input prompt (ignored in mock)
+
+        Returns:
+            The next string from the predefined inputs list
+
+        Raises:
+            IndexError: If there are no more inputs available
+
+        """
+        if not input_values:
+            raise IndexError('No more mock inputs available')
+        return input_values.pop(0)
+
+    # Replace the builtin input function
+    builtins.input = mock_input
+
+    try:
+        yield
+    finally:
+        # Restore the original input function
+        builtins.input = _original_input
+
+
+def configure_mock_input(inputs: list[str]) -> None:
+    """Configure input to be mocked globally.
+
+    Unlike MockInputContext, this function replaces the input function
+    globally without restoring it automatically. Use for simple tests
+    where cleanup isn't critical.
+
+    Args:
+        inputs: A list of strings to be returned sequentially by input().
+
+    Examples:
+        >>> configure_mock_input(["yes", "42"])
+        >>> answer = input("Continue? ")  # returns "yes"
+        >>> number = input("Enter number: ")  # returns "42"
+
+    """
+    input_values = list(inputs)  # Create a copy
+
+    def mock_input(prompt: object = '') -> str:  # noqa: ARG001
+        if not input_values:
+            raise IndexError('No more mock inputs available')
+        return input_values.pop(0)
+
+    builtins.input = mock_input

valid8r-0.2.0.dist-info/METADATA

@@ -0,0 +1,168 @@
+Metadata-Version: 2.4
+Name: valid8r
+Version: 0.2.0
+Summary: Clean, flexible input validation for Python applications
+License: MIT
+Keywords: validation,input,cli,maybe-monad
+Author: Mike Lane
+Author-email: mikelane@gmail.com
+Requires-Python: >=3.11,<4.0
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+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: Repository, https://github.com/mikelane/valid8r
+Description-Content-Type: text/markdown
+
+# Valid8r
+
+A clean, flexible input validation library for Python applications.
+
+## Features
+
+- **Clean Type Parsing**: Parse strings to various Python types with robust error handling
+- **Flexible Validation**: Chain validators and create custom validation rules
+- **Monadic Error Handling**: Use Maybe monad for clean error propagation
+- **Input Prompting**: Prompt users for input with built-in validation
+
+## Installation
+
+```bash
+pip install valid8r
+```
+
+## Quick Start
+
+```python
+from valid8r import (
+    parsers,
+    prompt,
+    validators,
+)
+
+# Simple validation
+age = prompt.ask(
+    "Enter your age: ",
+    parser=parsers.parse_int,
+    validator=validators.minimum(0) & validators.maximum(120)
+)
+
+print(f"Your age is {age}")
+```
+
+### IP parsing helpers
+
+```python
+from valid8r.core.maybe import Success, Failure
+from valid8r.core import parsers
+
+# IPv4 / IPv6 / generic IP
+for text in ["192.168.0.1", "::1", " 10.0.0.1 "]:
+    match parsers.parse_ip(text):
+        case Success(addr):
+            print("Parsed:", addr)
+        case Failure(err):
+            print("Error:", err)
+
+# CIDR (strict by default)
+match parsers.parse_cidr("10.0.0.0/8"):
+    case Success(net):
+        print("Network:", net)  # 10.0.0.0/8
+    case Failure(err):
+        print("Error:", err)
+
+# Non-strict masks host bits
+match parsers.parse_cidr("10.0.0.1/24", strict=False):
+    case Success(net):
+        assert str(net) == "10.0.0.0/24"
+```
+
+### URL and Email helpers
+
+```python
+from valid8r.core.maybe import Success, Failure
+from valid8r.core import parsers
+
+# URL parsing
+match parsers.parse_url("https://alice:pw@example.com:8443/x?q=1#top"):
+    case Success(u):
+        print(u.scheme, u.username, u.password, u.host, u.port)
+    case Failure(err):
+        print("Error:", err)
+
+# Email parsing
+match parsers.parse_email("First.Last+tag@Example.COM"):
+    case Success(e):
+        print(e.local, e.domain)  # First.Last+tag example.com
+    case Failure(err):
+        print("Error:", err)
+```
+
+## Testing Support
+
+Valid8r includes testing utilities to help you verify your validation logic:
+
+```python
+from valid8r import (
+    Maybe,
+    validators,
+    parsers,
+    prompt,
+)
+
+from valid8r.testing import (
+    MockInputContext,
+    assert_maybe_success,
+)
+
+def validate_age(age: int) -> Maybe[int]:
+    return validators.minimum(0) & validators.maximum(120)(age)
+
+# Test prompts with mock input
+with MockInputContext(["yes"]):
+    result = prompt.ask("Continue? ", parser=parsers.parse_bool)
+    assert result.is_success()
+    assert result.value_or(False) == True
+
+# Test validation functions
+result = validate_age(42)
+assert assert_maybe_success(result, 42)
+```
+
+For more information, see the [Testing with Valid8r](docs/user_guide/testing.rst) guide.
+
+## Development
+
+This project uses Poetry for dependency management and Tox for testing.
+
+### Setup
+
+```bash
+# Install Poetry
+curl -sSL https://install.python-poetry.org | python3 -
+
+# Install dependencies
+poetry install
+```
+
+### Running Tests
+
+```bash
+# Run all tests
+poetry run tox
+
+# Run BDD tests
+poetry run tox -e bdd
+```
+
+## License
+MIT
+

valid8r-0.2.0.dist-info/RECORD

@@ -0,0 +1,17 @@
+valid8r/__init__.py,sha256=Yg46vPVbLZvty-FSXkiJ3IkB6hg20pYcp6nWFidIfkk,447
+valid8r/core/__init__.py,sha256=ASOdzqCtpZHbHjjYMZkb78Z-nKxtD26ruTY0bd43ImA,520
+valid8r/core/combinators.py,sha256=KvRiDEqoZgH58cBYPO6SW9pdtkyijk0lS8aGSB5DbO4,2349
+valid8r/core/maybe.py,sha256=xT1xbiLVKohZ2aeaDZoKjT0W6Vk_PPwKbZXpIfsP7hc,4359
+valid8r/core/parsers.py,sha256=XlP9u0obe060wOJ29S5czCAQaJLObI4XxMax84R2m4k,43732
+valid8r/core/validators.py,sha256=oCrRQ2wIPNkqQXy-hJ7sQ9mJAvxtEtGhoy7WvehWqTc,5756
+valid8r/prompt/__init__.py,sha256=XYB3NEp-tmqT6fGmETVEeXd7Urj0M4ijlwdRAjj-rG8,175
+valid8r/prompt/basic.py,sha256=fLWuN-oiVZyaLdbcW5GHWpoGQ82RG0j-1n7uMYDfOb8,6008
+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.2.0.dist-info/METADATA,sha256=W0YFJg9Sd7E9UU1iyeC1e8_Pwzqzc1QU-tFFzma2A6s,4015
+valid8r-0.2.0.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+valid8r-0.2.0.dist-info/entry_points.txt,sha256=H_24A4zUgnKIXAIRosJliIcntyqMfmcgKh5_Prl7W18,79
+valid8r-0.2.0.dist-info/RECORD,,

valid8r-0.2.0.dist-info/WHEEL

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

valid8r-0.2.0.dist-info/entry_points.txt

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