universal-validator 1.0.0__py3-none-any.whl

universal_validator-1.0.0.dist-info/METADATA

@@ -0,0 +1,432 @@
+Metadata-Version: 2.4
+Name: universal-validator
+Version: 1.0.0
+Summary: Comprehensive data validation library for API, database, and form contexts
+Home-page: https://github.com/parthivrawat/universal-validator
+Author: Parthiv Rawat
+License: MIT
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
+Dynamic: author
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: provides-extra
+Dynamic: requires-python
+Dynamic: summary
+
+# Universal Data Validator
+
+A comprehensive data validation library for Python that works across API, database, and form contexts.
+
+## Features
+
+- ✅ **Rich Validator Types**: String, int, float, bool, email, URL, list, dict
+- ✅ **Schema-Based Validation**: Define complex data structures
+- ✅ **Custom Validators**: Add your own validation logic
+- ✅ **Nested Validation**: Validate nested objects and lists
+- ✅ **Clear Error Messages**: Detailed error reporting with field paths
+- ✅ **Zero Dependencies**: No external dependencies required
+- ✅ **Production Ready**: Comprehensive test coverage
+
+## Installation
+
+```bash
+pip install universal-validator
+```
+
+## Quick Start
+
+```python
+from universal_validator import Schema, validators
+
+schema = Schema({
+    'email': validators.email(),
+    'age': validators.int(min_value=0, max_value=120),
+    'username': validators.string(min_length=3, max_length=20),
+    'tags': validators.list(validators.string())
+})
+
+result = schema.validate(data)
+if not result.valid:
+    for error in result.errors:
+        print(f"{error.field}: {error.message}")
+```
+
+## Usage Examples
+
+### String Validation
+
+```python
+from universal_validator import validators
+
+# Basic string
+validator = validators.string()
+
+# String with length constraints
+validator = validators.string(min_length=3, max_length=20)
+
+# String with pattern
+validator = validators.string(pattern=r'^\d{3}-\d{4}$')
+
+# String with choices
+validator = validators.string(choices=['red', 'green', 'blue'])
+
+# Optional string
+validator = validators.string(required=False)
+
+# Nullable string
+validator = validators.string(nullable=True)
+```
+
+### Integer and Float Validation
+
+```python
+# Integer with range
+age_validator = validators.int(min_value=0, max_value=120)
+
+# Float with range
+price_validator = validators.float(min_value=0.0, max_value=9999.99)
+
+# Optional integer
+count_validator = validators.int(required=False)
+```
+
+### Boolean Validation
+
+```python
+# Boolean
+terms_validator = validators.bool()
+
+# Optional boolean
+newsletter_validator = validators.bool(required=False)
+```
+
+### Email and URL Validation
+
+```python
+# Email validation
+email_validator = validators.email()
+
+# URL validation
+url_validator = validators.url()
+```
+
+### List Validation
+
+```python
+# Simple list
+tags_validator = validators.list()
+
+# List with item validation
+numbers_validator = validators.list(validators.int())
+
+# List with length constraints
+items_validator = validators.list(
+    validators.string(),
+    min_length=1,
+    max_length=10
+)
+```
+
+### Dictionary Validation
+
+```python
+# Dictionary with schema
+address_validator = validators.dict({
+    'street': validators.string(),
+    'city': validators.string(),
+    'zip': validators.string(pattern=r'^\d{5}$')
+})
+
+# Nested dictionary
+user_validator = validators.dict({
+    'name': validators.string(),
+    'email': validators.email(),
+    'address': validators.dict({
+        'street': validators.string(),
+        'city': validators.string()
+    })
+})
+```
+
+### Schema Validation
+
+```python
+from universal_validator import Schema, validators
+
+# Define schema
+user_schema = Schema({
+    'username': validators.string(min_length=3, max_length=20),
+    'email': validators.email(),
+    'age': validators.int(min_value=13, required=False),
+    'bio': validators.string(max_length=500, required=False),
+    'tags': validators.list(validators.string()),
+    'settings': validators.dict({
+        'theme': validators.string(choices=['light', 'dark']),
+        'notifications': validators.bool()
+    })
+})
+
+# Validate data
+data = {
+    'username': 'john_doe',
+    'email': 'john@example.com',
+    'age': 25,
+    'tags': ['python', 'javascript'],
+    'settings': {
+        'theme': 'dark',
+        'notifications': True
+    }
+}
+
+result = user_schema.validate(data)
+
+if result.valid:
+    print("✅ Data is valid!")
+else:
+    print("❌ Validation errors:")
+    for error in result.errors:
+        print(f"  {error.field}: {error.message}")
+```
+
+### Custom Validators
+
+```python
+from universal_validator import validators
+
+def is_even(value):
+    """Custom validator to check if number is even."""
+    if value % 2 != 0:
+        return "Value must be even"
+    return None
+
+# Add custom validator
+validator = validators.int().custom(is_even)
+
+result = validator.validate(4, 'number')
+print(result.valid)  # True
+
+result = validator.validate(3, 'number')
+print(result.valid)  # False
+print(result.errors[0].message)  # "Value must be even"
+```
+
+### Multiple Custom Validators
+
+```python
+def is_positive(value):
+    return "Must be positive" if value <= 0 else None
+
+def is_even(value):
+    return "Must be even" if value % 2 != 0 else None
+
+validator = validators.int().custom(is_positive).custom(is_even)
+
+result = validator.validate(4, 'field')
+print(result.valid)  # True
+
+result = validator.validate(-2, 'field')
+print(result.valid)  # False
+```
+
+## Real-World Examples
+
+### User Registration
+
+```python
+from universal_validator import Schema, validators
+
+registration_schema = Schema({
+    'username': validators.string(min_length=3, max_length=20),
+    'email': validators.email(),
+    'password': validators.string(min_length=8),
+    'confirm_password': validators.string(min_length=8),
+    'age': validators.int(min_value=13, required=False),
+    'terms_accepted': validators.bool()
+})
+
+data = {
+    'username': 'john_doe',
+    'email': 'john@example.com',
+    'password': 'secure_password_123',
+    'confirm_password': 'secure_password_123',
+    'age': 25,
+    'terms_accepted': True
+}
+
+result = registration_schema.validate(data)
+```
+
+### API Request Validation
+
+```python
+api_request_schema = Schema({
+    'method': validators.string(choices=['GET', 'POST', 'PUT', 'DELETE']),
+    'url': validators.url(),
+    'headers': validators.dict(required=False),
+    'body': validators.dict(required=False),
+    'timeout': validators.float(min_value=0, required=False)
+})
+
+request_data = {
+    'method': 'POST',
+    'url': 'https://api.example.com/users',
+    'headers': {'Content-Type': 'application/json'},
+    'body': {'name': 'John'},
+    'timeout': 30.0
+}
+
+result = api_request_schema.validate(request_data)
+```
+
+### Configuration Validation
+
+```python
+config_schema = Schema({
+    'database': validators.dict({
+        'host': validators.string(),
+        'port': validators.int(min_value=1, max_value=65535),
+        'username': validators.string(),
+        'password': validators.string(),
+        'ssl': validators.bool()
+    }),
+    'cache': validators.dict({
+        'enabled': validators.bool(),
+        'ttl': validators.int(min_value=0),
+        'max_size': validators.int(min_value=1)
+    }),
+    'features': validators.list(validators.string())
+})
+
+config = {
+    'database': {
+        'host': 'localhost',
+        'port': 5432,
+        'username': 'admin',
+        'password': 'secret',
+        'ssl': True
+    },
+    'cache': {
+        'enabled': True,
+        'ttl': 3600,
+        'max_size': 1000
+    },
+    'features': ['feature1', 'feature2']
+}
+
+result = config_schema.validate(config)
+```
+
+## Error Handling
+
+```python
+from universal_validator import Schema, validators, ValidationError
+
+schema = Schema({
+    'email': validators.email()
+})
+
+# Option 1: Check result
+result = schema.validate({'email': 'invalid'})
+if not result.valid:
+    for error in result.errors:
+        print(f"{error.field}: {error.message}")
+
+# Option 2: Raise exception
+try:
+    schema.validate_or_raise({'email': 'invalid'})
+except ValidationError as e:
+    print(f"Validation failed: {e}")
+```
+
+## API Reference
+
+### Validators
+
+- `validators.string(min_length, max_length, pattern, choices, required, nullable)` - String validator
+- `validators.int(min_value, max_value, required, nullable)` - Integer validator
+- `validators.float(min_value, max_value, required, nullable)` - Float validator
+- `validators.bool(required, nullable)` - Boolean validator
+- `validators.email(required, nullable)` - Email validator
+- `validators.url(required, nullable)` - URL validator
+- `validators.list(item_validator, min_length, max_length, required, nullable)` - List validator
+- `validators.dict(schema, required, nullable)` - Dictionary validator
+
+### Schema
+
+- `Schema(schema_dict)` - Create a schema
+- `schema.validate(data)` - Validate data and return ValidationResult
+- `schema.validate_or_raise(data)` - Validate data and raise ValidationError if invalid
+
+### ValidationResult
+
+- `result.valid` - Boolean indicating if validation passed
+- `result.errors` - List of ValidationError objects
+
+### ValidationError
+
+- `error.field` - Field name that failed validation
+- `error.message` - Error message
+- `error.value` - Value that failed validation
+
+## Testing
+
+```bash
+# Install dev dependencies
+pip install -e ".[dev]"
+
+# Run tests
+pytest test_universal_validator.py -v
+
+# Run with coverage
+pytest test_universal_validator.py --cov=universal_validator --cov-report=html
+```
+
+## Comparison with Other Libraries
+
+| Feature | universal-validator | pydantic | marshmallow | cerberus |
+|---------|-------------------|----------|-------------|----------|
+| Schema-based | ✅ | ✅ | ✅ | ✅ |
+| Custom validators | ✅ | ✅ | ✅ | ✅ |
+| Zero dependencies | ✅ | ❌ | ❌ | ✅ |
+| Nested validation | ✅ | ✅ | ✅ | ✅ |
+| Clear errors | ✅ | ✅ | ✅ | ✅ |
+| Simple API | ✅ | ❌ | ❌ | ✅ |
+| Type hints | ✅ | ✅ | ❌ | ❌ |
+
+## License
+
+MIT License
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+## Changelog
+
+### 1.0.0 (2024-01-15)
+- Initial release
+- Support for string, int, float, bool, email, URL, list, dict validators
+- Schema-based validation
+- Custom validators
+- Nested validation
+- Comprehensive test coverage

universal_validator-1.0.0.dist-info/RECORD

@@ -0,0 +1,6 @@
+universal_validator.py,sha256=n6rrR6R7HYRilD5McWkWVENKuZ8awOWYtGzW3VpeUCA,15609
+universal_validator-1.0.0.dist-info/licenses/LICENSE,sha256=Qzfvr-Ixz6apkYUiJvtzlRSxx6wTxtrfIns9vuymgLw,1070
+universal_validator-1.0.0.dist-info/METADATA,sha256=rK3rt31ld6yTebboXPrQ79ILIMEV5cMT9GPFHMmI5zs,11371
+universal_validator-1.0.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+universal_validator-1.0.0.dist-info/top_level.txt,sha256=0jky5xjF7BqL6L-K83mH6q_ZNRtQEx6SBGKaGdCNoJI,20
+universal_validator-1.0.0.dist-info/RECORD,,

universal_validator-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

universal_validator-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Parthiv Rawat
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

universal_validator-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+universal_validator

universal_validator.py

@@ -0,0 +1,448 @@
+"""
+Universal Data Validator Library
+
+A comprehensive data validation library that works across API, database, and form contexts.
+
+Author: Parthiv Rawat
+License: MIT
+"""
+
+from typing import Any, Callable, Dict, List, Optional, Union, Type, TypeVar, Generic
+from dataclasses import dataclass
+from enum import Enum
+import re
+from datetime import datetime
+
+
+T = TypeVar('T')
+
+
+class ValidationError(Exception):
+    """Base exception for validation errors."""
+    
+    def __init__(self, field: str, message: str, value: Any = None):
+        self.field = field
+        self.message = message
+        self.value = value
+        super().__init__(f"{field}: {message}")
+
+
+class ValidationResult:
+    """Result of a validation operation."""
+    
+    def __init__(self, valid: bool = True, errors: Optional[List[ValidationError]] = None):
+        self.valid = valid
+        self.errors = errors or []
+    
+    def add_error(self, error: ValidationError):
+        """Add a validation error."""
+        self.valid = False
+        self.errors.append(error)
+    
+    def __bool__(self):
+        return self.valid
+    
+    def __repr__(self):
+        if self.valid:
+            return "ValidationResult(valid=True)"
+        return f"ValidationResult(valid=False, errors={len(self.errors)})"
+
+
+class Validator(Generic[T]):
+    """Base validator class."""
+    
+    def __init__(self, required: bool = True, nullable: bool = False):
+        self.required = required
+        self.nullable = nullable
+        self.custom_validators: List[Callable[[Any], Optional[str]]] = []
+    
+    def validate(self, value: Any, field: str = "field") -> ValidationResult:
+        """Validate a value."""
+        result = ValidationResult()
+        
+        if value is None:
+            if self.required and not self.nullable:
+                result.add_error(ValidationError(field, "Field is required"))
+            return result
+        
+        type_error = self._validate_type(value, field)
+        if type_error:
+            result.add_error(type_error)
+            return result
+        
+        constraint_errors = self._validate_constraints(value, field)
+        for error in constraint_errors:
+            result.add_error(error)
+        
+        for custom_validator in self.custom_validators:
+            error_msg = custom_validator(value)
+            if error_msg:
+                result.add_error(ValidationError(field, error_msg, value))
+        
+        return result
+    
+    def _validate_type(self, value: Any, field: str) -> Optional[ValidationError]:
+        """Validate the type of the value."""
+        return None
+    
+    def _validate_constraints(self, value: Any, field: str) -> List[ValidationError]:
+        """Validate constraints on the value."""
+        return []
+    
+    def custom(self, validator: Callable[[Any], Optional[str]]) -> 'Validator[T]':
+        """Add a custom validator function."""
+        self.custom_validators.append(validator)
+        return self
+
+
+class StringValidator(Validator[str]):
+    """Validator for string values."""
+    
+    def __init__(self, 
+                 min_length: Optional[int] = None,
+                 max_length: Optional[int] = None,
+                 pattern: Optional[str] = None,
+                 choices: Optional[List[str]] = None,
+                 **kwargs):
+        super().__init__(**kwargs)
+        self.min_length = min_length
+        self.max_length = max_length
+        self.pattern = pattern
+        self.choices = choices
+    
+    def _validate_type(self, value: Any, field: str) -> Optional[ValidationError]:
+        if not isinstance(value, str):
+            return ValidationError(field, f"Expected string, got {type(value).__name__}", value)
+        return None
+    
+    def _validate_constraints(self, value: str, field: str) -> List[ValidationError]:
+        errors = []
+        
+        if self.min_length is not None and len(value) < self.min_length:
+            errors.append(ValidationError(
+                field, 
+                f"String length must be at least {self.min_length}, got {len(value)}",
+                value
+            ))
+        
+        if self.max_length is not None and len(value) > self.max_length:
+            errors.append(ValidationError(
+                field,
+                f"String length must be at most {self.max_length}, got {len(value)}",
+                value
+            ))
+        
+        if self.pattern is not None and not re.match(self.pattern, value):
+            errors.append(ValidationError(
+                field,
+                f"String does not match pattern {self.pattern}",
+                value
+            ))
+        
+        if self.choices is not None and value not in self.choices:
+            errors.append(ValidationError(
+                field,
+                f"Value must be one of {self.choices}, got '{value}'",
+                value
+            ))
+        
+        return errors
+
+
+class IntValidator(Validator[int]):
+    """Validator for integer values."""
+    
+    def __init__(self,
+                 min_value: Optional[int] = None,
+                 max_value: Optional[int] = None,
+                 **kwargs):
+        super().__init__(**kwargs)
+        self.min_value = min_value
+        self.max_value = max_value
+    
+    def _validate_type(self, value: Any, field: str) -> Optional[ValidationError]:
+        if not isinstance(value, int) or isinstance(value, bool):
+            return ValidationError(field, f"Expected int, got {type(value).__name__}", value)
+        return None
+    
+    def _validate_constraints(self, value: int, field: str) -> List[ValidationError]:
+        errors = []
+        
+        if self.min_value is not None and value < self.min_value:
+            errors.append(ValidationError(
+                field,
+                f"Value must be at least {self.min_value}, got {value}",
+                value
+            ))
+        
+        if self.max_value is not None and value > self.max_value:
+            errors.append(ValidationError(
+                field,
+                f"Value must be at most {self.max_value}, got {value}",
+                value
+            ))
+        
+        return errors
+
+
+class FloatValidator(Validator[float]):
+    """Validator for float values."""
+    
+    def __init__(self,
+                 min_value: Optional[float] = None,
+                 max_value: Optional[float] = None,
+                 **kwargs):
+        super().__init__(**kwargs)
+        self.min_value = min_value
+        self.max_value = max_value
+    
+    def _validate_type(self, value: Any, field: str) -> Optional[ValidationError]:
+        if not isinstance(value, (int, float)) or isinstance(value, bool):
+            return ValidationError(field, f"Expected float, got {type(value).__name__}", value)
+        return None
+    
+    def _validate_constraints(self, value: float, field: str) -> List[ValidationError]:
+        errors = []
+        
+        if self.min_value is not None and value < self.min_value:
+            errors.append(ValidationError(
+                field,
+                f"Value must be at least {self.min_value}, got {value}",
+                value
+            ))
+        
+        if self.max_value is not None and value > self.max_value:
+            errors.append(ValidationError(
+                field,
+                f"Value must be at most {self.max_value}, got {value}",
+                value
+            ))
+        
+        return errors
+
+
+class BoolValidator(Validator[bool]):
+    """Validator for boolean values."""
+    
+    def _validate_type(self, value: Any, field: str) -> Optional[ValidationError]:
+        if not isinstance(value, bool):
+            return ValidationError(field, f"Expected bool, got {type(value).__name__}", value)
+        return None
+
+
+class EmailValidator(StringValidator):
+    """Validator for email addresses."""
+    
+    def __init__(self, **kwargs):
+        pattern = r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$'
+        super().__init__(pattern=pattern, **kwargs)
+    
+    def _validate_constraints(self, value: str, field: str) -> List[ValidationError]:
+        errors = super()._validate_constraints(value, field)
+        
+        if not re.match(self.pattern, value):
+            errors = [ValidationError(field, f"Invalid email address: {value}", value)]
+        
+        return errors
+
+
+class UrlValidator(StringValidator):
+    """Validator for URLs."""
+    
+    def __init__(self, **kwargs):
+        pattern = r'^https?://[^\s/$.?#].[^\s]*$'
+        super().__init__(pattern=pattern, **kwargs)
+    
+    def _validate_constraints(self, value: str, field: str) -> List[ValidationError]:
+        errors = super()._validate_constraints(value, field)
+        
+        if not re.match(self.pattern, value):
+            errors = [ValidationError(field, f"Invalid URL: {value}", value)]
+        
+        return errors
+
+
+class ListValidator(Validator[List]):
+    """Validator for list values."""
+    
+    def __init__(self,
+                 item_validator: Optional[Validator] = None,
+                 min_length: Optional[int] = None,
+                 max_length: Optional[int] = None,
+                 **kwargs):
+        super().__init__(**kwargs)
+        self.item_validator = item_validator
+        self.min_length = min_length
+        self.max_length = max_length
+    
+    def _validate_type(self, value: Any, field: str) -> Optional[ValidationError]:
+        if not isinstance(value, list):
+            return ValidationError(field, f"Expected list, got {type(value).__name__}", value)
+        return None
+    
+    def _validate_constraints(self, value: List, field: str) -> List[ValidationError]:
+        errors = []
+        
+        if self.min_length is not None and len(value) < self.min_length:
+            errors.append(ValidationError(
+                field,
+                f"List length must be at least {self.min_length}, got {len(value)}",
+                value
+            ))
+        
+        if self.max_length is not None and len(value) > self.max_length:
+            errors.append(ValidationError(
+                field,
+                f"List length must be at most {self.max_length}, got {len(value)}",
+                value
+            ))
+        
+        if self.item_validator:
+            for i, item in enumerate(value):
+                item_result = self.item_validator.validate(item, f"{field}[{i}]")
+                errors.extend(item_result.errors)
+        
+        return errors
+
+
+class DictValidator(Validator[Dict]):
+    """Validator for dictionary values."""
+    
+    def __init__(self,
+                 schema: Optional[Dict[str, Validator]] = None,
+                 **kwargs):
+        super().__init__(**kwargs)
+        self.schema = schema or {}
+    
+    def _validate_type(self, value: Any, field: str) -> Optional[ValidationError]:
+        if not isinstance(value, dict):
+            return ValidationError(field, f"Expected dict, got {type(value).__name__}", value)
+        return None
+    
+    def _validate_constraints(self, value: Dict, field: str) -> List[ValidationError]:
+        errors = []
+        
+        for key, validator in self.schema.items():
+            if key in value:
+                result = validator.validate(value[key], f"{field}.{key}")
+                errors.extend(result.errors)
+            elif validator.required:
+                errors.append(ValidationError(f"{field}.{key}", "Field is required"))
+        
+        return errors
+
+
+class Schema:
+    """Schema for validating complex data structures."""
+    
+    def __init__(self, schema: Dict[str, Validator]):
+        self.schema = schema
+    
+    def validate(self, data: Dict[str, Any]) -> ValidationResult:
+        """Validate data against the schema."""
+        result = ValidationResult()
+        
+        if not isinstance(data, dict):
+            result.add_error(ValidationError("root", f"Expected dict, got {type(data).__name__}"))
+            return result
+        
+        for field, validator in self.schema.items():
+            if field in data:
+                field_result = validator.validate(data[field], field)
+                for error in field_result.errors:
+                    result.add_error(error)
+            elif validator.required:
+                result.add_error(ValidationError(field, "Field is required"))
+        
+        return result
+    
+    def validate_or_raise(self, data: Dict[str, Any]) -> None:
+        """Validate data and raise exception if invalid."""
+        result = self.validate(data)
+        if not result.valid:
+            error_messages = [f"{e.field}: {e.message}" for e in result.errors]
+            raise ValidationError("validation", "\n".join(error_messages))
+
+
+class validators:
+    """Namespace for validator factory functions."""
+    
+    @staticmethod
+    def string(min_length: Optional[int] = None,
+               max_length: Optional[int] = None,
+               pattern: Optional[str] = None,
+               choices: Optional[List[str]] = None,
+               required: bool = True,
+               nullable: bool = False) -> StringValidator:
+        """Create a string validator."""
+        return StringValidator(
+            min_length=min_length,
+            max_length=max_length,
+            pattern=pattern,
+            choices=choices,
+            required=required,
+            nullable=nullable
+        )
+    
+    @staticmethod
+    def int(min_value: Optional[int] = None,
+            max_value: Optional[int] = None,
+            required: bool = True,
+            nullable: bool = False) -> IntValidator:
+        """Create an integer validator."""
+        return IntValidator(
+            min_value=min_value,
+            max_value=max_value,
+            required=required,
+            nullable=nullable
+        )
+    
+    @staticmethod
+    def float(min_value: Optional[float] = None,
+              max_value: Optional[float] = None,
+              required: bool = True,
+              nullable: bool = False) -> FloatValidator:
+        """Create a float validator."""
+        return FloatValidator(
+            min_value=min_value,
+            max_value=max_value,
+            required=required,
+            nullable=nullable
+        )
+    
+    @staticmethod
+    def bool(required: bool = True, nullable: bool = False) -> BoolValidator:
+        """Create a boolean validator."""
+        return BoolValidator(required=required, nullable=nullable)
+    
+    @staticmethod
+    def email(required: bool = True, nullable: bool = False) -> EmailValidator:
+        """Create an email validator."""
+        return EmailValidator(required=required, nullable=nullable)
+    
+    @staticmethod
+    def url(required: bool = True, nullable: bool = False) -> UrlValidator:
+        """Create a URL validator."""
+        return UrlValidator(required=required, nullable=nullable)
+    
+    @staticmethod
+    def list(item_validator: Optional[Validator] = None,
+             min_length: Optional[int] = None,
+             max_length: Optional[int] = None,
+             required: bool = True,
+             nullable: bool = False) -> ListValidator:
+        """Create a list validator."""
+        return ListValidator(
+            item_validator=item_validator,
+            min_length=min_length,
+            max_length=max_length,
+            required=required,
+            nullable=nullable
+        )
+    
+    @staticmethod
+    def dict(schema: Optional[Dict[str, Validator]] = None,
+             required: bool = True,
+             nullable: bool = False) -> DictValidator:
+        """Create a dictionary validator."""
+        return DictValidator(schema=schema, required=required, nullable=nullable)