pytastic 0.0.1__tar.gz

pytastic-0.0.1/PKG-INFO

@@ -0,0 +1,65 @@
+Metadata-Version: 2.4
+Name: pytastic
+Version: 0.0.1
+Summary: A dependency-free JSON validation library using TypedDict and Annotated
+Author: Tersoo
+Author-email: tersoo@example.com
+Requires-Python: >=3.9,<4.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Description-Content-Type: text/markdown
+
+# Pytastic
+
+A dependency-free, high-performance JSON validation library using Python's native `TypedDict` and `Annotated`.
+
+## Highlights
+- **Zero Dependencies**: Pure Python standard library.
+- **Dual API**: 
+    - `vx.User(data)` for clean, dynamic usage.
+    - `vx.validate(User, data)` for full IDE type safety.
+- **Rich Constraints**: `min`, `max`, `regex`, `unique`, `one_of`, `Literal`, and nested validation.
+
+## Installation
+
+```bash
+pip install pytastic
+```
+
+## Usage
+
+```python
+from pytastic import Pytastic
+from typing import TypedDict, Annotated, List, Literal
+
+vx = Pytastic()
+
+# 1. Define Schema
+class User(TypedDict):
+    username: Annotated[str, "min_len=3; regex=^[a-z_]+$"]
+    age: Annotated[int, "min=18"]
+    role: Literal["admin", "user"]
+
+vx.register(User)
+
+# 2. Validate
+try:
+    # Typed validation (IDE friendly)
+    user = vx.validate(User, {"username": "tersoo", "age": 25, "role": "admin"})
+    print(user)
+
+    # 3. Export JSON Schema
+    print(vx.schema(User))
+except Exception as e:
+    print(e)
+```
+
+## License
+
+MIT
+

pytastic-0.0.1/README.md

@@ -0,0 +1,48 @@
+# Pytastic
+
+A dependency-free, high-performance JSON validation library using Python's native `TypedDict` and `Annotated`.
+
+## Highlights
+- **Zero Dependencies**: Pure Python standard library.
+- **Dual API**: 
+    - `vx.User(data)` for clean, dynamic usage.
+    - `vx.validate(User, data)` for full IDE type safety.
+- **Rich Constraints**: `min`, `max`, `regex`, `unique`, `one_of`, `Literal`, and nested validation.
+
+## Installation
+
+```bash
+pip install pytastic
+```
+
+## Usage
+
+```python
+from pytastic import Pytastic
+from typing import TypedDict, Annotated, List, Literal
+
+vx = Pytastic()
+
+# 1. Define Schema
+class User(TypedDict):
+    username: Annotated[str, "min_len=3; regex=^[a-z_]+$"]
+    age: Annotated[int, "min=18"]
+    role: Literal["admin", "user"]
+
+vx.register(User)
+
+# 2. Validate
+try:
+    # Typed validation (IDE friendly)
+    user = vx.validate(User, {"username": "tersoo", "age": 25, "role": "admin"})
+    print(user)
+
+    # 3. Export JSON Schema
+    print(vx.schema(User))
+except Exception as e:
+    print(e)
+```
+
+## License
+
+MIT

pytastic-0.0.1/pyproject.toml

@@ -0,0 +1,14 @@
+[tool.poetry]
+name = "pytastic"
+version = "0.0.1"
+description = "A dependency-free JSON validation library using TypedDict and Annotated"
+authors = ["Tersoo <tersoo@example.com>"]
+readme = "README.md"
+packages = [{include = "pytastic"}]
+
+[tool.poetry.dependencies]
+python = "^3.9"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"

pytastic-0.0.1/pytastic/__init__.py

@@ -0,0 +1,4 @@
+from pytastic.core import Pytastic
+from pytastic.exceptions import PytasticError, ValidationError
+
+__all__ = ["Pytastic", "PytasticError", "ValidationError"]

pytastic-0.0.1/pytastic/compiler.py

@@ -0,0 +1,181 @@
+from abc import ABC, abstractmethod
+from typing import Any, Type, Dict, get_origin, get_args, Union, List, Tuple, Annotated, _TypedDictMeta, Literal, cast, Generic, TypeVar, Set # type: ignore
+from pytastic.validators import Validator, NumberValidator, StringValidator, CollectionValidator, UnionValidator, ObjectValidator, LiteralValidator
+from pytastic.exceptions import SchemaDefinitionError
+from pytastic.utils import parse_constraints, normalize_key
+
+class SchemaCompiler:
+    """Compiles Python types (TypedDict, Annotated, etc.) into Validators."""
+    
+    def __init__(self):
+        self._cache: Dict[Type, Validator] = {}
+
+    def compile(self, schema: Type) -> Validator:
+        """
+        Compiles a schema type into a Validator instance.
+        """
+        if schema in self._cache:
+            return self._cache[schema]
+        
+        validator = self._build_validator(schema)
+        self._cache[schema] = validator
+        return validator
+
+    def _build_validator(self, schema: Type) -> Validator:
+        origin = get_origin(schema)
+        args = get_args(schema)
+
+        # 1. Annotated[T, "constraints"]
+        if origin is Annotated:
+            base_type = args[0]
+            constraint_str = ""
+            # Combine all string annotations
+            for arg in args[1:]:
+                if isinstance(arg, str):
+                    constraint_str += arg + ";"
+            
+            constraints = parse_constraints(constraint_str)
+            
+            # Recurse on base type but PASS DOWN constraints?
+            # Actually, most validators take constraints in __init__.
+            # We need to peek at base type to know which Validator to create.
+            
+            base_origin = get_origin(base_type)
+            
+            if base_type is int or base_type is float:
+                return NumberValidator(constraints, number_type=base_type)
+            
+            if base_type is str:
+                return StringValidator(constraints)
+            
+            if base_origin is list or base_origin is List:
+                 # Annotated[list[int], "min_items=3"]
+                 inner_type = get_args(base_type)[0] if get_args(base_type) else Any
+                 item_validator = self.compile(inner_type)
+                 return CollectionValidator(constraints, item_validator=item_validator)
+                 
+            if base_origin is tuple or base_origin is Tuple:
+                # Annotated[tuple[int, str], "..."]
+                inner_types = get_args(base_type)
+                item_validators = [self.compile(t) for t in inner_types]
+                return CollectionValidator(constraints, item_validator=item_validators)
+            
+            if base_origin is Union:
+                # Annotated[Union[A, B], "one_of"]
+                union_mode = "one_of" if constraints.get("one_of") else "any_of"
+                validators = [self.compile(t) for t in get_args(base_type)]
+                return UnionValidator(validators, mode=union_mode)
+
+            # Annotated[TypedDict, "..."]
+            if self._is_typeddict(base_type):
+                 # Constraints on the object itself (e.g. min_properties)
+                 # We need to compile the TypedDict logic first, then inject constraints?
+                 # Or pass constraints to ObjectValidator?
+                 return self._compile_typeddict(base_type, constraints)
+
+            # Fallback: Just return compiled base type (ignoring constraints if unknown?)
+            # Or raise error?
+            return self.compile(base_type)
+
+        # 2. TypedDict
+        if self._is_typeddict(schema):
+            return self._compile_typeddict(schema, {})
+
+        # 3. List[T]
+        if origin is list or origin is List:
+             inner_type = args[0] if args else Any
+             return CollectionValidator({}, item_validator=self.compile(inner_type))
+        
+        # 4. Tuple[T, ...]
+        if origin is tuple or origin is Tuple:
+            return CollectionValidator({}, item_validator=[self.compile(t) for t in args])
+
+        # 5. Union[A, B]
+        if origin is Union:
+            return UnionValidator([self.compile(t) for t in args], mode="any_of")
+
+        # 6. Literal[A, B]
+        if origin is Literal:
+            return LiteralValidator(args)
+            
+        # 7. Basic Types (No Annotations)
+        if schema is int or schema is float:
+             return NumberValidator({}, number_type=schema)
+        
+        if schema is str:
+             return StringValidator({})
+
+        if schema is Any:
+             # Pass-through validator
+             from pytastic.validators import Validator
+             class AnyValidator(Validator):
+                 def validate(self, data, path=""): return data
+             return AnyValidator()
+
+        # Raise unknown type error
+        # Check for NotRequired? NotRequired is stripped by get_type_hints usually, 
+        # or handled at TypedDict level.
+        
+        raise SchemaDefinitionError(f"Unsupported type: {schema}")
+
+    def _is_typeddict(self, t: Type) -> bool:
+        return isinstance(t, _TypedDictMeta) or (isinstance(t, type) and issubclass(t, dict) and hasattr(t, '__annotations__'))
+
+    def _compile_typeddict(self, td_cls: Type, constraints: Dict[str, Any]) -> ObjectValidator:
+        from typing import get_type_hints, NotRequired, Required
+        
+        # Python 3.9+ get_type_hints(include_extras=True)
+        # But for TypedDict, we check key presence.
+        
+        type_hints = get_type_hints(td_cls, include_extras=True)
+        fields = {}
+        required_keys = set()
+        
+        # Inspect for Required/NotRequired
+        # Note: In TypedDict, strict means only defined keys. 
+        # Checking required status depends on 'total=True/False' and individual generic modifiers.
+        
+        is_total = getattr(td_cls, '__total__', True)
+        
+        for key, value in type_hints.items():
+            # Check if value is wrapped in NotRequired or Required
+            # This is tricky because get_type_hints might strip it or parse it.
+            # get_type_hints with include_extras=True preserves Annotated, but NotRequired handling varies.
+            
+            # Simple heuristic:
+            is_required = is_total
+            
+            # TODO: Robust NotRequired detection requires inspecting __annotations__ directly sometimes if get_type_hints strips it?
+            # Actually get_type_hints usually resolves it.
+            # Using basic TypedDict inspection:
+            if hasattr(td_cls, '__required_keys__'):
+                 is_required = key in td_cls.__required_keys__
+            
+            if is_required:
+                required_keys.add(key)
+                
+            fields[key] = self.compile(value)
+            
+        # Constraints from `_: Annotated[None, ...]` dummy key?
+        # User example: _: Annotated[None, "strict; min_properties=2"]
+        # This key is meant for metadata, not a real field. We should check if it exists in type_hints.
+        
+        if '_' in fields:
+             # Extract constraints from wildcard field
+             # It's compiled as a AnyValidator or NoneValidator, but we need the Annotated constraints.
+             # Easier to check __annotations__ directly for '_'
+             meta_annotation = td_cls.__annotations__.get('_', None)
+             if meta_annotation and get_origin(meta_annotation) is Annotated:
+                 args = get_args(meta_annotation)
+                 constraint_str = ""
+                 for arg in args[1:]:
+                    if isinstance(arg, str):
+                        constraint_str += arg + ";"
+                 meta_constraints = parse_constraints(constraint_str)
+                 constraints.update(meta_constraints)
+             
+             # Remove _ from fields and required keys checks
+             fields.pop('_', None)
+             required_keys.discard('_')
+
+        return ObjectValidator(fields, constraints, required_keys)

pytastic-0.0.1/pytastic/core.py

@@ -0,0 +1,54 @@
+from typing import Any, Type, Dict, TypeVar, Optional, Callable
+from pytastic.compiler import SchemaCompiler
+from pytastic.exceptions import PytasticError
+from pytastic.schema import JsonSchemaGenerator, to_json_string
+
+T = TypeVar("T")
+
+class Pytastic:
+    """
+    Main entry point for Pytastic validation.
+    Functions as a registry and factory for validators.
+    """
+    def __init__(self):
+        self.compiler = SchemaCompiler()
+        self._registry: Dict[str, Any] = {} # Maps name -> Validator
+
+    def register(self, schema: Type[T]) -> None:
+        """
+        Registers a schema (TypedDict) with Pytastic.
+        Compiles the schema immediately.
+        """
+        validator = self.compiler.compile(schema)
+        self._registry[schema.__name__] = validator
+
+    def validate(self, schema: Type[T], data: Any) -> T:
+        """
+        Validates data against a schema.
+        If the schema is not registered, it is compiled on the fly.
+        """
+        # Auto-compile if passed a class directly
+        validator = self.compiler.compile(schema)
+        return validator.validate(data)
+
+    def __getattr__(self, name: str) -> Callable[[Any], Any]:
+        """
+        Enables dynamic syntax: vx.UserSchema(data)
+        """
+        if name in self._registry:
+            validator = self._registry[name]
+            # Return a callable that runs validation
+            def validate_wrapper(data: Any) -> Any:
+                return validator.validate(data)
+            return validate_wrapper
+        
+        raise AttributeError(f"'Pytastic' object has no attribute '{name}'. Did you forget to register the schema?")
+
+    def schema(self, schema: Type[T]) -> str:
+        """
+        Returns the JSON Schema definition for a model as a string.
+        """
+        validator = self.compiler.compile(schema)
+        generator = JsonSchemaGenerator()
+        json_dict = generator.generate(validator)
+        return to_json_string(json_dict)

pytastic-0.0.1/pytastic/exceptions.py

@@ -0,0 +1,22 @@
+from typing import Any, List, Dict
+
+class PytasticError(Exception):
+    """Base exception for all Pytastic errors."""
+    pass
+
+class SchemaDefinitionError(PytasticError):
+    """Raised when a schema definition is invalid."""
+    pass
+
+class ValidationError(PytasticError):
+    """Raised when data validation fails."""
+    def __init__(self, message: str, errors: List[Dict[str, Any]] = None):
+        super().__init__(message)
+        self.errors = errors if errors is not None else []
+
+    def __str__(self):
+        if not self.errors:
+            return super().__str__()
+        
+        details = "\n".join([f"  - {e['path']}: {e['message']}" for e in self.errors])
+        return f"{super().__str__()}\n{details}"

pytastic-0.0.1/pytastic/schema.py

@@ -0,0 +1,126 @@
+import json
+from typing import Any, Dict, Type, List, Optional
+from pytastic.validators import (
+    Validator, NumberValidator, StringValidator, 
+    CollectionValidator, ObjectValidator, 
+    UnionValidator, LiteralValidator
+)
+
+class JsonSchemaGenerator:
+    """Generates JSON Schema from Pytastic Validators."""
+
+    def __init__(self):
+        self.definitions: Dict[str, Any] = {}
+    
+    def generate(self, validator: Validator, root_name: str = "Root") -> Dict[str, Any]:
+        """
+        Generates a full JSON schema object.
+        """
+        self.definitions = {}
+        schema = self._visit(validator)
+        
+        if self.definitions:
+            schema["$defs"] = self.definitions
+            
+        return schema
+
+    def _visit(self, validator: Validator) -> Dict[str, Any]:
+        if isinstance(validator, NumberValidator):
+            return self._visit_number(validator)
+        elif isinstance(validator, StringValidator):
+            return self._visit_string(validator)
+        elif isinstance(validator, CollectionValidator):
+            return self._visit_collection(validator)
+        elif isinstance(validator, ObjectValidator):
+            return self._visit_object(validator)
+        elif isinstance(validator, UnionValidator):
+            return self._visit_union(validator)
+        elif isinstance(validator, LiteralValidator):
+            return self._visit_literal(validator)
+        
+        return {} # Fallback
+
+    def _visit_number(self, v: NumberValidator) -> Dict[str, Any]:
+        schema = {"type": "integer" if v.number_type is int else "number"}
+        c = v.constraints
+        
+        if 'min' in c: schema['minimum'] = float(c['min'])
+        if 'max' in c: schema['maximum'] = float(c['max'])
+        if 'exclusive_min' in c: schema['exclusiveMinimum'] = float(c['exclusive_min'])
+        if 'exclusive_max' in c: schema['exclusiveMaximum'] = float(c['exclusive_max'])
+        
+        step = c.get('step') or c.get('multiple_of')
+        if step: schema['multipleOf'] = float(step)
+        
+        return schema
+
+    def _visit_string(self, v: StringValidator) -> Dict[str, Any]:
+        schema = {"type": "string"}
+        c = v.constraints
+        
+        min_l = c.get('min_length') or c.get('min_len')
+        if min_l: schema['minLength'] = int(min_l)
+        
+        max_l = c.get('max_length') or c.get('max_len')
+        if max_l: schema['maxLength'] = int(max_l)
+        
+        pattern = c.get('regex') or c.get('pattern')
+        if pattern: schema['pattern'] = str(pattern)
+        
+        fmt = c.get('format')
+        if fmt: schema['format'] = str(fmt)
+        
+        return schema
+
+    def _visit_collection(self, v: CollectionValidator) -> Dict[str, Any]:
+        schema = {"type": "array"}
+        c = v.constraints
+        
+        if 'min_items' in c: schema['minItems'] = int(c['min_items'])
+        if 'max_items' in c: schema['maxItems'] = int(c['max_items'])
+        if c.get('unique') or c.get('unique_items'): schema['uniqueItems'] = True
+        
+        if isinstance(v.item_validator, list):
+            # Tuple conversion -> prefixItems (Draft 2020-12) or items array (older drafts)
+            # We'll use prefixItems style logic but map to 'items' array + 'minItems' match for simple tuples?
+            # Actually standard JSON schema uses "prefixItems" for positionals now.
+            # Let's use generic "items": [...] if supported or use prefixItems. 
+            # To be safe for older parsers, tuple validation usually maps to:
+            # "type": "array", "items": [s1, s2], "minItems": X, "maxItems": X
+            schema['type'] = 'array'
+            schema['prefixItems'] = [self._visit(iv) for iv in v.item_validator]
+            schema['minItems'] = len(v.item_validator)
+            schema['maxItems'] = len(v.item_validator)
+            schema['items'] = False # No extra items allowed
+        elif isinstance(v.item_validator, Validator):
+            schema['items'] = self._visit(v.item_validator)
+            
+        return schema
+
+    def _visit_object(self, v: ObjectValidator) -> Dict[str, Any]:
+        schema = {"type": "object", "properties": {}, "required": [], "additionalProperties": True}
+        
+        for name, field_validator in v.fields.items():
+            schema["properties"][name] = self._visit(field_validator)
+        
+        schema["required"] = list(v.required_keys)
+        
+        c = v.constraints
+        if c.get('strict') or c.get('additional_properties') is False:
+             schema['additionalProperties'] = False
+        
+        min_p = c.get('min_properties') or c.get('min_props')
+        if min_p: schema['minProperties'] = int(min_p)
+
+        return schema
+
+    def _visit_union(self, v: UnionValidator) -> Dict[str, Any]:
+        schemas = [self._visit(sv) for sv in v.validators]
+        key = "oneOf" if v.mode == "one_of" else "anyOf"
+        return {key: schemas}
+
+    def _visit_literal(self, v: LiteralValidator) -> Dict[str, Any]:
+        return {"enum": list(v.allowed_values)}
+
+def to_json_string(schema: Dict[str, Any]) -> str:
+    return json.dumps(schema, indent=2)

pytastic-0.0.1/pytastic/utils.py

@@ -0,0 +1,46 @@
+from typing import Dict, Any, Union
+
+def parse_constraints(annotation_str: str) -> Dict[str, Any]:
+    """
+    Parses a constraint string into a dictionary.
+    Example: "min=10; max=20; unique" -> {'min': '10', 'max': '20', 'unique': True}
+    """
+    if not annotation_str:
+        return {}
+
+    constraints = {}
+    # Split by semicolon
+    parts = annotation_str.split(';')
+    
+    for part in parts:
+        part = part.strip()
+        if not part:
+            continue
+            
+        if '=' in part:
+            key, value = part.split('=', 1)
+            key = key.strip()
+            value = value.strip()
+            
+            # Basic type inference
+            if value.lower() == 'true':
+                value = True
+            elif value.lower() == 'false':
+                value = False
+            # We treat numbers as strings here, they will be cast by the specific validators
+            # because we don't know if 'min=10' is for an int or a float yet.
+            
+            constraints[key] = value
+        else:
+            # Boolean flag (e.g., "unique")
+            constraints[part] = True
+            
+    return constraints
+
+def normalize_key(key: str) -> str:
+    """
+    Normalizes keys to snake_case.
+    e.g. 'minItems' -> 'min_items' (if we supported camelInput)
+    But our spec focuses on snake_case input.
+    """
+    return key.lower().replace(" ", "_")

pytastic-0.0.1/pytastic/validators.py

@@ -0,0 +1,251 @@
+from abc import ABC, abstractmethod
+from typing import Any, List, Dict, Generic, TypeVar, Union, Set, Tuple
+import re
+import math
+from pytastic.exceptions import ValidationError
+
+T = TypeVar("T")
+
+class Validator(ABC, Generic[T]):
+    """Abstract base class for all validators."""
+    
+    @abstractmethod
+    def validate(self, data: Any, path: str = "") -> T:
+        """
+        Validate data against the schema.
+        Raises ValidationError if validation fails.
+        Returns the validated (and possibly coerced) data.
+        """
+        pass
+
+class NumberValidator(Validator[Union[int, float]]):
+    def __init__(self, constraints: Dict[str, Any], number_type: type = int):
+        self.constraints = constraints
+        self.number_type = number_type
+
+    def validate(self, data: Any, path: str = "") -> Union[int, float]:
+        if not isinstance(data, (int, float)):
+            raise ValidationError(f"Expected number, got {type(data).__name__}", [{"path": path, "message": "Invalid type"}])
+        
+        # Type check (int vs float strictly?)
+        # If strict int is needed:
+        if self.number_type is int and isinstance(data, float) and not data.is_integer():
+             raise ValidationError(f"Expected integer, got float", [{"path": path, "message": "Expected integer"}])
+
+        val = data
+
+        # Min/Max
+        if 'min' in self.constraints:
+            limit = float(self.constraints['min'])
+            if val < limit:
+                raise ValidationError(f"Value {val} is less than minimum {limit}", [{"path": path, "message": f"Must be >= {limit}"}])
+        
+        if 'max' in self.constraints:
+            limit = float(self.constraints['max'])
+            if val > limit:
+                raise ValidationError(f"Value {val} is greater than maximum {limit}", [{"path": path, "message": f"Must be <= {limit}"}])
+
+        # Exclusive Min/Max
+        if 'exclusive_min' in self.constraints:
+            limit = float(self.constraints['exclusive_min'])
+            if val <= limit:
+                raise ValidationError(f"Value {val} must be greater than {limit}", [{"path": path, "message": f"Must be > {limit}"}])
+                
+        if 'exclusive_max' in self.constraints:
+            limit = float(self.constraints['exclusive_max'])
+            if val >= limit:
+                raise ValidationError(f"Value {val} must be less than {limit}", [{"path": path, "message": f"Must be < {limit}"}])
+
+        # Step / Multiple Of
+        step = self.constraints.get('step') or self.constraints.get('multiple_of')
+        if step:
+            step_val = float(step)
+            # Use a small epsilon for float comparison logic if needed, but simple mod usually works for basic cases
+            # For floats, direct modulo can be problematic due to precision. math.isclose is better.
+            if not math.isclose(val % step_val, 0, abs_tol=1e-9) and not math.isclose(val % step_val, step_val, abs_tol=1e-9):
+                 raise ValidationError(f"Value {val} is not a multiple of {step_val}", [{"path": path, "message": f"Must be multiple of {step_val}"}])
+
+        return self.number_type(val)
+
+class StringValidator(Validator[str]):
+    def __init__(self, constraints: Dict[str, Any]):
+        self.constraints = constraints
+
+    def validate(self, data: Any, path: str = "") -> str:
+        if not isinstance(data, str):
+            raise ValidationError(f"Expected string, got {type(data).__name__}", [{"path": path, "message": "Invalid type"}])
+        
+        val = data
+
+        # Length
+        if 'min_length' in self.constraints or 'min_len' in self.constraints:
+            val_limit = self.constraints.get('min_length') or self.constraints.get('min_len')
+            limit = int(val_limit) if val_limit is not None else 0
+            if len(val) < limit:
+               raise ValidationError(f"String length {len(val)} is shorter than min {limit}", [{"path": path, "message": f"Length must be >= {limit}"}])
+
+        if 'max_length' in self.constraints or 'max_len' in self.constraints:
+            val_limit = self.constraints.get('max_length') or self.constraints.get('max_len')
+            if val_limit is not None:
+                limit = int(val_limit)
+                if len(val) > limit:
+                   raise ValidationError(f"String length {len(val)} is longer than max {limit}", [{"path": path, "message": f"Length must be <= {limit}"}])
+
+        # Regex
+        if 'regex' in self.constraints or 'pattern' in self.constraints:
+            pattern = self.constraints.get('regex') or self.constraints.get('pattern')
+            if isinstance(pattern, str) and not re.search(pattern, val):
+                raise ValidationError(f"String does not match pattern '{pattern}'", [{"path": path, "message": "Pattern mismatch"}])
+
+        # Format (Basic implementation)
+        fmt = self.constraints.get('format')
+        if fmt == 'email':
+            if '@' not in val: # Very basic check
+                raise ValidationError("Invalid email format", [{"path": path, "message": "Invalid email"}])
+        elif fmt == 'uuid':
+            # Basic UUID pattern
+            if not re.match(r'^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$', val.lower()):
+                 raise ValidationError("Invalid UUID format", [{"path": path, "message": "Invalid UUID"}])
+        
+        
+        return val
+
+class CollectionValidator(Validator[list]):
+    def __init__(self, constraints: Dict[str, Any], item_validator: Union[Validator, List[Validator], None] = None):
+        self.constraints = constraints
+        self.item_validator = item_validator # Can be a single validator (list) or list of validators (tuple)
+
+    def validate(self, data: Any, path: str = "") -> list:
+        if not isinstance(data, (list, tuple)):
+             raise ValidationError(f"Expected list/tuple, got {type(data).__name__}", [{"path": path, "message": "Invalid type"}])
+        
+        # Min Items
+        if 'min_items' in self.constraints:
+            limit = int(self.constraints['min_items'])
+            if len(data) < limit:
+                raise ValidationError(f"List has fewer items than {limit}", [{"path": path, "message": f"Min items: {limit}"}])
+
+        # Max Items
+        if 'max_items' in self.constraints:
+            limit = int(self.constraints['max_items'])
+            if len(data) > limit:
+                raise ValidationError(f"List has more items than {limit}", [{"path": path, "message": f"Max items: {limit}"}])
+
+        # Unique Items
+        if self.constraints.get('unique') or self.constraints.get('unique_items'):
+            # This is complex for unhashable types (dicts/lists), but simplistic set check for primitives
+            try:
+                if len(set(data)) != len(data):
+                    raise ValidationError("List items must be unique", [{"path": path, "message": "Duplicate items found"}])
+            except TypeError:
+                # Fallback for unhashables (O(N^2))
+                for i in range(len(data)):
+                    for j in range(i + 1, len(data)):
+                        if data[i] == data[j]:
+                             raise ValidationError("List items must be unique", [{"path": path, "message": "Duplicate items found"}])
+
+        validated_data = []
+        
+        # Tuple validation (positional)
+        if isinstance(self.item_validator, list):
+             if len(data) != len(self.item_validator):
+                 # Strict tuple length? Python tuples usually fixed.
+                 raise ValidationError(f"Expected {len(self.item_validator)} items, got {len(data)}", [{"path": path, "message": f"Expected {len(self.item_validator)} items"}])
+             
+             for i, (item, validator) in enumerate(zip(data, self.item_validator)):
+                 validated_data.append(validator.validate(item, path=f"{path}[{i}]"))
+        
+        # List validation (homogeneous)
+        elif isinstance(self.item_validator, Validator):
+             for i, item in enumerate(data):
+                 validated_data.append(self.item_validator.validate(item, path=f"{path}[{i}]"))
+        else:
+            validated_data = list(data)
+
+        return validated_data
+
+class UnionValidator(Validator[Any]):
+    def __init__(self, validators: List[Validator], mode: str = "any_of"):
+        self.validators = validators
+        self.mode = mode # 'any_of' or 'one_of'
+
+    def validate(self, data: Any, path: str = "") -> Any:
+        valid_results = []
+        errors = []
+
+        for v in self.validators:
+            try:
+                valid_results.append(v.validate(data, path))
+            except ValidationError as e:
+                errors.append(e)
+        
+        if self.mode == "one_of":
+            if len(valid_results) == 1:
+                return valid_results[0]
+            elif len(valid_results) == 0:
+                 raise ValidationError("Matches none of the allowed types", [{"path": path, "message": "No match for OneOf"}])
+            else:
+                 raise ValidationError("Matches multiple types in OneOf", [{"path": path, "message": "Multiple matches for OneOf"}])
+
+        # Default: any_of (return first match)
+        if valid_results:
+            return valid_results[0]
+        
+        raise ValidationError("Matches none of the allowed types", [{"path": path, "message": "No match for Union"}])
+
+class ObjectValidator(Validator[Dict]):
+    def __init__(self, fields: Dict[str, Validator], constraints: Dict[str, Any], required_keys: Set[str]):
+        self.fields = fields
+        self.constraints = constraints
+        self.required_keys = required_keys # Keys that MUST be present
+
+    def validate(self, data: Any, path: str = "") -> Dict:
+        if not isinstance(data, dict):
+            raise ValidationError(f"Expected object, got {type(data).__name__}", [{"path": path, "message": "Invalid type"}])
+        
+        final_data = {}
+        errors = []
+
+        # Check required keys
+        missing = self.required_keys - data.keys()
+        if missing:
+             # Check if missing keys have defaults? TypedDict doesn't support defaults easily at runtime without extra inspecting.
+             # For now, strict required check.
+             for k in missing:
+                 errors.append({"path": f"{path}.{k}" if path else k, "message": "Field is required"})
+        
+        # Validate Fields
+        for key, value in data.items():
+            if key in self.fields:
+                try:
+                    final_data[key] = self.fields[key].validate(value, path=f"{path}.{key}" if path else key)
+                except ValidationError as e:
+                    errors.extend(e.errors)
+            else:
+                # Extra keys
+                if self.constraints.get('additional_properties') is False or self.constraints.get('strict'):
+                     errors.append({"path": f"{path}.{key}" if path else key, "message": "Extra field not allowed"})
+                else:
+                    final_data[key] = value
+
+        # Min/Max Properties
+        if 'min_properties' in self.constraints or 'min_props' in self.constraints:
+             limit = int(self.constraints.get('min_properties') or self.constraints.get('min_props') or 0)
+             if len(data) < limit:
+                  errors.append({"path": path, "message": f"Too few properties (min {limit})"})
+
+        if errors:
+            raise ValidationError("Validation failed", errors)
+
+        return final_data
+
+class LiteralValidator(Validator[Any]):
+    def __init__(self, allowed_values: Tuple[Any, ...]):
+        self.allowed_values = allowed_values
+
+    def validate(self, data: Any, path: str = "") -> Any:
+        if data not in self.allowed_values:
+            # Format expected values for friendly error
+            allowed = ", ".join(repr(v) for v in self.allowed_values)
+            raise ValidationError(f"Value must be one of: {allowed}", [{"path": path, "message": f"Expected one of: {allowed}"}])
+        return data