pytastic 0.0.3__tar.gz → 0.0.5__tar.gz

{pytastic-0.0.3 → pytastic-0.0.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pytastic
-Version: 0.0.3
+Version: 0.0.5
 Summary: A dependency-free JSON validation library using TypedDict and Annotated
 License-File: LICENSE
 Author: Tersoo
@@ -25,6 +25,19 @@ Pytastic is a lightweight validation layer that respects your standard Python ty
 - **Zero Dependencies**: Pure Python standard library.
 - **No Learning Curve**: It's just standard Python typing.
 - **IDE Friendly**: We use standard types, so your IDE autocompletion works out of the box.
+- **Fast**: Code generation makes Pytastic faster than Pydantic for common use cases.
+
+## Performance
+
+Benchmark results (100,000 validation iterations):
+
+| Library | Time (s) | Ops/sec | Relative |
+|---------|----------|---------|----------|
+| msgspec | 0.058 | 1,737,663 | 1.00x |
+| **Pytastic** | **0.195** | **513,673** | **3.38x** |
+| Pydantic | 0.211 | 474,438 | 3.66x |
+
+**Pytastic beats Pydantic** while being pure Python with zero dependencies!
 
 ## Installation
 
@@ -45,6 +58,7 @@ class User(TypedDict):
     username: Annotated[str, "min_len=3; regex=^[a-z_]+$"]
     age: Annotated[int, "min=18"]
     role: Literal["admin", "user"]
+```
 
 # 2. Usage Patterns
 

{pytastic-0.0.3 → pytastic-0.0.5}/README.md

@@ -8,6 +8,19 @@ Pytastic is a lightweight validation layer that respects your standard Python ty
 - **Zero Dependencies**: Pure Python standard library.
 - **No Learning Curve**: It's just standard Python typing.
 - **IDE Friendly**: We use standard types, so your IDE autocompletion works out of the box.
+- **Fast**: Code generation makes Pytastic faster than Pydantic for common use cases.
+
+## Performance
+
+Benchmark results (100,000 validation iterations):
+
+| Library | Time (s) | Ops/sec | Relative |
+|---------|----------|---------|----------|
+| msgspec | 0.058 | 1,737,663 | 1.00x |
+| **Pytastic** | **0.195** | **513,673** | **3.38x** |
+| Pydantic | 0.211 | 474,438 | 3.66x |
+
+**Pytastic beats Pydantic** while being pure Python with zero dependencies!
 
 ## Installation
 
@@ -28,6 +41,7 @@ class User(TypedDict):
     username: Annotated[str, "min_len=3; regex=^[a-z_]+$"]
     age: Annotated[int, "min=18"]
     role: Literal["admin", "user"]
+```
 
 # 2. Usage Patterns
 

{pytastic-0.0.3 → pytastic-0.0.5}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "pytastic"
-version = "0.0.3"
+version = "0.0.5"
 description = "A dependency-free JSON validation library using TypedDict and Annotated"
 authors = ["Tersoo <tersoo@example.com>"]
 readme = "README.md"

pytastic-0.0.5/pytastic/codegen.py

@@ -0,0 +1,245 @@
+from typing import Any, Type, Dict, get_origin, get_args, Union, List, Tuple, Annotated, _TypedDictMeta, Literal
+from typing import get_type_hints
+from pytastic.exceptions import SchemaDefinitionError
+from pytastic.utils import parse_constraints
+
+
+class CodegenCompiler:
+    """Generates optimized Python validation functions from type schemas."""
+    
+    def __init__(self):
+        self._cache: Dict[Type, Any] = {}
+        self._counter = 0
+    
+    def compile(self, schema: Type) -> Any:
+        """Compiles a schema into a fast validation function."""
+        if schema in self._cache:
+            return self._cache[schema]
+        
+        schema_name = getattr(schema, '__name__', f'Schema{self._counter}')
+        self._counter += 1
+        
+        code_lines = []
+        code_lines.append(f"def validate_{schema_name}(data, path=''):")
+        
+        body_lines = self._generate_validator(schema, 'data', 'path', indent=1)
+        code_lines.extend(body_lines)
+        code_lines.append("    return data")
+        
+        code = '\n'.join(code_lines)
+        
+        namespace = {
+            'ValidationError': __import__('pytastic.exceptions', fromlist=['ValidationError']).ValidationError,
+            're': __import__('re'),
+            'math': __import__('math'),
+        }
+        
+        exec(code, namespace)
+        validator_func = namespace[f'validate_{schema_name}']
+        
+        self._cache[schema] = validator_func
+        return validator_func
+    
+    def _generate_validator(self, schema: Type, var_name: str, path_var: str, indent: int) -> List[str]:
+        """Generate validation code for a schema type."""
+        origin = get_origin(schema)
+        args = get_args(schema)
+        ind = '    ' * indent
+        lines = []
+        
+        if origin is Annotated:
+            base_type = args[0]
+            constraint_str = ''
+            for arg in args[1:]:
+                if isinstance(arg, str):
+                    constraint_str += arg + ';'
+            constraints = parse_constraints(constraint_str)
+            
+            base_origin = get_origin(base_type)
+            
+            if base_type is int or base_type is float:
+                return self._gen_number(var_name, path_var, base_type, constraints, indent)
+            elif base_type is str:
+                return self._gen_string(var_name, path_var, constraints, indent)
+            elif self._is_typeddict(base_type):
+                return self._gen_object(base_type, var_name, path_var, constraints, indent)
+            elif base_origin is list or base_origin is List:
+                inner_type = get_args(base_type)[0] if get_args(base_type) else Any
+                return self._gen_list(var_name, path_var, inner_type, constraints, indent)
+        
+        if self._is_typeddict(schema):
+            return self._gen_object(schema, var_name, path_var, {}, indent)
+        
+        if origin is list or origin is List:
+            inner_type = args[0] if args else Any
+            return self._gen_list(var_name, path_var, inner_type, {}, indent)
+        
+        if origin is Union:
+            return self._gen_union(var_name, path_var, args, indent)
+        
+        if origin is Literal:
+            return self._gen_literal(var_name, path_var, args, indent)
+        
+        if schema is int or schema is float:
+            return self._gen_number(var_name, path_var, schema, {}, indent)
+        
+        if schema is str:
+            return self._gen_string(var_name, path_var, {}, indent)
+        
+        if schema is bool:
+            lines.append(f"{ind}# bool validation (passthrough)")
+        
+        return lines
+    
+    def _gen_number(self, var: str, path: str, num_type: type, constraints: Dict, indent: int) -> List[str]:
+        """Generate number validation code."""
+        ind = '    ' * indent
+        lines = []
+        
+        type_name = 'int' if num_type is int else 'float'
+        lines.append(f"{ind}if not isinstance({var}, (int, float)):")
+        lines.append(f"{ind}    raise ValidationError(f'Expected number at {{{path}}}', [{{'path': {path}, 'message': 'Invalid type'}}])")
+        
+        if num_type is int:
+            lines.append(f"{ind}if isinstance({var}, float) and not {var}.is_integer():")
+            lines.append(f"{ind}    raise ValidationError(f'Expected integer at {{{path}}}', [{{'path': {path}, 'message': 'Expected integer'}}])")
+        
+        if 'min' in constraints:
+            min_val = constraints['min']
+            lines.append(f"{ind}if {var} < {min_val}:")
+            lines.append(f"{ind}    raise ValidationError(f'Value {{{var}}} < {min_val} at {{{path}}}', [{{'path': {path}, 'message': 'Must be >= {min_val}'}}])")
+        
+        if 'max' in constraints:
+            max_val = constraints['max']
+            lines.append(f"{ind}if {var} > {max_val}:")
+            lines.append(f"{ind}    raise ValidationError(f'Value {{{var}}} > {max_val} at {{{path}}}', [{{'path': {path}, 'message': 'Must be <= {max_val}'}}])")
+        
+        return lines
+    
+    def _gen_string(self, var: str, path: str, constraints: Dict, indent: int) -> List[str]:
+        """Generate string validation code."""
+        ind = '    ' * indent
+        lines = []
+        
+        lines.append(f"{ind}if not isinstance({var}, str):")
+        lines.append(f"{ind}    raise ValidationError(f'Expected string at {{{path}}}', [{{'path': {path}, 'message': 'Invalid type'}}])")
+        
+        min_len = constraints.get('min_length') or constraints.get('min_len')
+        if min_len:
+            lines.append(f"{ind}if len({var}) < {min_len}:")
+            lines.append(f"{ind}    raise ValidationError(f'String too short at {{{path}}}', [{{'path': {path}, 'message': 'Min length {min_len}'}}])")
+        
+        max_len = constraints.get('max_length') or constraints.get('max_len')
+        if max_len:
+            lines.append(f"{ind}if len({var}) > {max_len}:")
+            lines.append(f"{ind}    raise ValidationError(f'String too long at {{{path}}}', [{{'path': {path}, 'message': 'Max length {max_len}'}}])")
+        
+        pattern = constraints.get('regex') or constraints.get('pattern')
+        if pattern:
+            escaped_pattern = pattern.replace("'", "\\'")
+            lines.append(f"{ind}if not re.search(r'{escaped_pattern}', {var}):")
+            lines.append(f"{ind}    raise ValidationError(f'Pattern mismatch at {{{path}}}', [{{'path': {path}, 'message': 'Pattern mismatch'}}])")
+        
+        return lines
+    
+    def _gen_object(self, td_cls: Type, var: str, path: str, constraints: Dict, indent: int) -> List[str]:
+        """Generate object/TypedDict validation code."""
+        ind = '    ' * indent
+        lines = []
+        
+        lines.append(f"{ind}if not isinstance({var}, dict):")
+        lines.append(f"{ind}    raise ValidationError(f'Expected dict at {{{path}}}', [{{'path': {path}, 'message': 'Invalid type'}}])")
+        
+        type_hints = get_type_hints(td_cls, include_extras=True)
+        is_total = getattr(td_cls, '__total__', True)
+        required_keys = getattr(td_cls, '__required_keys__', set(type_hints.keys()) if is_total else set())
+        
+        for key, field_type in type_hints.items():
+            if key == '_':
+                continue
+            
+            field_var = f"{var}__{key}"
+            is_required = key in required_keys
+            
+            lines.append(f"{ind}{field_var} = {var}.get('{key}')")
+            
+            if is_required:
+                lines.append(f"{ind}if {field_var} is None:")
+                lines.append(f"{ind}    raise ValidationError(f'Missing field {key} at {{{path}}}', [{{'path': {path} + '.{key}', 'message': 'Required'}}])")
+            else:
+                lines.append(f"{ind}if {field_var} is not None:")
+                indent += 1
+                ind = '    ' * indent
+            
+            field_path = f"{path} + '.{key}'" if path != "''" else f"'{key}'"
+            field_lines = self._generate_validator(field_type, field_var, field_path, indent)
+            lines.extend(field_lines)
+            
+            if not is_required:
+                indent -= 1
+        
+        return lines
+    
+    def _gen_list(self, var: str, path: str, item_type: Type, constraints: Dict, indent: int) -> List[str]:
+        """Generate list validation code."""
+        ind = '    ' * indent
+        lines = []
+        
+        lines.append(f"{ind}if not isinstance({var}, list):")
+        lines.append(f"{ind}    raise ValidationError(f'Expected list at {{{path}}}', [{{'path': {path}, 'message': 'Invalid type'}}])")
+        
+        min_items = constraints.get('min_items')
+        if min_items:
+            lines.append(f"{ind}if len({var}) < {min_items}:")
+            lines.append(f"{ind}    raise ValidationError(f'Too few items at {{{path}}}', [{{'path': {path}, 'message': 'Min {min_items} items'}}])")
+        
+        max_items = constraints.get('max_items')
+        if max_items:
+            lines.append(f"{ind}if len({var}) > {max_items}:")
+            lines.append(f"{ind}    raise ValidationError(f'Too many items at {{{path}}}', [{{'path': {path}, 'message': 'Max {max_items} items'}}])")
+        
+        if constraints.get('unique'):
+            lines.append(f"{ind}if len({var}) != len(set({var})):")
+            lines.append(f"{ind}    raise ValidationError(f'Duplicate items found at {{{path}}}', [{{'path': {path}, 'message': 'Duplicate items found'}}])")
+        
+        lines.append(f"{ind}for _idx, _item in enumerate({var}):")
+        item_path = f"{path} + f'[{{_idx}}]'"
+        item_lines = self._generate_validator(item_type, '_item', item_path, indent + 1)
+        lines.extend(item_lines)
+        
+        return lines
+    
+    def _gen_union(self, var: str, path: str, types: Tuple, indent: int) -> List[str]:
+        """Generate union validation code."""
+        ind = '    ' * indent
+        lines = []
+        
+        lines.append(f"{ind}_union_errors = []")
+        for i, union_type in enumerate(types):
+            lines.append(f"{ind}try:")
+            type_lines = self._generate_validator(union_type, var, path, indent + 1)
+            lines.extend(type_lines)
+            if i < len(types) - 1:
+                lines.append(f"{ind}except ValidationError as _e:")
+                lines.append(f"{ind}    _union_errors.append(_e)")
+            else:
+                lines.append(f"{ind}except ValidationError:")
+                lines.append(f"{ind}    raise ValidationError(f'No union match at {{{path}}}', [{{'path': {path}, 'message': 'No match'}}])")
+        
+        return lines
+    
+    def _gen_literal(self, var: str, path: str, values: Tuple, indent: int) -> List[str]:
+        """Generate literal validation code."""
+        ind = '    ' * indent
+        lines = []
+        
+        allowed = list(values)
+        lines.append(f"{ind}_allowed = {repr(allowed)}")
+        lines.append(f"{ind}if {var} not in _allowed:")
+        lines.append(f"{ind}    raise ValidationError(f'Invalid literal value at {{{path}}}', [{{'path': {path}, 'message': 'Must be one of ' + str(_allowed)}}])")
+        
+        return lines
+    
+    def _is_typeddict(self, t: Type) -> bool:
+        """Check if type is a TypedDict."""
+        return isinstance(t, _TypedDictMeta) or (isinstance(t, type) and issubclass(t, dict) and hasattr(t, '__annotations__'))

{pytastic-0.0.3 → pytastic-0.0.5}/pytastic/compiler.py

@@ -1,8 +1,12 @@
 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.validators import (
+    Validator, NumberValidator, StringValidator, CollectionValidator, 
+    UnionValidator, ObjectValidator, LiteralValidator, AnyValidator
+)
 from pytastic.exceptions import SchemaDefinitionError
 from pytastic.utils import parse_constraints, normalize_key
+from typing import get_type_hints, NotRequired, Required
 
 class SchemaCompiler:
     """Compiles Python types (TypedDict, Annotated, etc.) into Validators."""
@@ -14,9 +18,7 @@ class SchemaCompiler:
         """
         Compiles a schema type into a Validator instance.
         """
-        if schema in self._cache:
-            return self._cache[schema]
-        
+        if schema in self._cache: return self._cache[schema]
         validator = self._build_validator(schema)
         self._cache[schema] = validator
         return validator
@@ -25,21 +27,14 @@ class SchemaCompiler:
         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:
@@ -49,7 +44,6 @@ class SchemaCompiler:
                 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)
@@ -61,109 +55,54 @@ class SchemaCompiler:
                 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 self._is_typeddict(schema): return self._compile_typeddict(schema, {})
         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 bool:
+             return AnyValidator()
         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.
-        
+        # Python 3.9+ get_type_hints(include_extras=True) includes Annotated
         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)
-                
+            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.
-        
+        # Handle metadata from `_: Annotated[...]` pattern
         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)
@@ -177,5 +116,4 @@ class SchemaCompiler:
              # Remove _ from fields and required keys checks
              fields.pop('_', None)
              required_keys.discard('_')
-
         return ObjectValidator(fields, constraints, required_keys)

{pytastic-0.0.3 → pytastic-0.0.5}/pytastic/core.py

@@ -1,7 +1,8 @@
 from typing import Any, Type, Dict, TypeVar, Optional, Callable
-from pytastic.compiler import SchemaCompiler
+from pytastic.codegen import CodegenCompiler
 from pytastic.exceptions import PytasticError
 from pytastic.schema import JsonSchemaGenerator, to_json_string
+from pytastic.compiler import SchemaCompiler
 
 T = TypeVar("T")
 
@@ -11,36 +12,37 @@ class Pytastic:
     Functions as a registry and factory for validators.
     """
     def __init__(self):
+        self.codegen = CodegenCompiler()
         self.compiler = SchemaCompiler()
-        self._registry: Dict[str, Any] = {} # Maps name -> Validator
+        self._registry: Dict[str, Any] = {}
+        self._attr_cache: Dict[str, Callable[[Any], Any]] = {}
 
     def register(self, schema: Type[T]) -> None:
         """
         Registers a schema (TypedDict) with Pytastic.
-        Compiles the schema immediately.
+        Compiles the schema immediately using code generation.
         """
-        validator = self.compiler.compile(schema)
+        validator = self.codegen.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.
+        Validates data against a schema using code generation.
         """
-        # Auto-compile if passed a class directly
-        validator = self.compiler.compile(schema)
-        return validator.validate(data)
+        validator = self.codegen.compile(schema)
+        return validator(data)
 
     def __getattr__(self, name: str) -> Callable[[Any], Any]:
         """
         Enables dynamic syntax: vx.UserSchema(data)
         """
+        if name in self._attr_cache:
+            return self._attr_cache[name]
+            
         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
+            self._attr_cache[name] = validator
+            return validator
         
         raise AttributeError(f"'Pytastic' object has no attribute '{name}'. Did you forget to register the schema?")
 

{pytastic-0.0.3 → pytastic-0.0.5}/pytastic/schema.py

@@ -41,39 +41,28 @@ class JsonSchemaGenerator:
         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'])
+        schema: Dict[str, Any] = {"type": "integer" if v.number_type is int else "number"}
         
-        step = c.get('step') or c.get('multiple_of')
-        if step: schema['multipleOf'] = float(step)
+        if v.min_val is not None: schema['minimum'] = v.min_val
+        if v.max_val is not None: schema['maximum'] = v.max_val
+        if v.exclusive_min_val is not None: schema['exclusiveMinimum'] = v.exclusive_min_val
+        if v.exclusive_max_val is not None: schema['exclusiveMaximum'] = v.exclusive_max_val
+        if v.step_val is not None: schema['multipleOf'] = v.step_val
         
         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)
+        schema: Dict[str, Any] = {"type": "string"}
         
-        fmt = c.get('format')
-        if fmt: schema['format'] = str(fmt)
+        if v.min_len is not None: schema['minLength'] = v.min_len
+        if v.max_len is not None: schema['maxLength'] = v.max_len
+        if v.pattern: schema['pattern'] = str(v.pattern)
+        if v.format: schema['format'] = str(v.format)
         
         return schema
 
     def _visit_collection(self, v: CollectionValidator) -> Dict[str, Any]:
-        schema = {"type": "array"}
+        schema: Dict[str, Any] = {"type": "array"}
         c = v.constraints
         
         if 'min_items' in c: schema['minItems'] = int(c['min_items'])
@@ -81,13 +70,7 @@ class JsonSchemaGenerator:
         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'
+            # Tuple validation using 'prefixItems' (JSON Schema 2020-12+)
             schema['prefixItems'] = [self._visit(iv) for iv in v.item_validator]
             schema['minItems'] = len(v.item_validator)
             schema['maxItems'] = len(v.item_validator)
@@ -98,7 +81,7 @@ class JsonSchemaGenerator:
         return schema
 
     def _visit_object(self, v: ObjectValidator) -> Dict[str, Any]:
-        schema = {"type": "object", "properties": {}, "required": [], "additionalProperties": True}
+        schema: Dict[str, Any] = {"type": "object", "properties": {}, "required": [], "additionalProperties": True}
         
         for name, field_validator in v.fields.items():
             schema["properties"][name] = self._visit(field_validator)

{pytastic-0.0.3 → pytastic-0.0.5}/pytastic/utils.py

@@ -5,36 +5,21 @@ 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 {}
-
+    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 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.
+            key, value = key.strip(), value.strip()
             
+            if value.lower() == 'true': value = True
+            elif value.lower() == 'false': value = False
             constraints[key] = value
-        else:
-            # Boolean flag (e.g., "unique")
-            constraints[part] = True
-            
+        else: constraints[part] = True
     return constraints
 
 def normalize_key(key: str) -> str:

{pytastic-0.0.3 → pytastic-0.0.5}/pytastic/validators.py

@@ -11,65 +11,63 @@ class Validator(ABC, Generic[T]):
     
     @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 AnyValidator(Validator[Any]):
+    __slots__ = ()
+    
+    def validate(self, data: Any, path: str = "") -> Any:
+        return data
+
 class NumberValidator(Validator[Union[int, float]]):
+    __slots__ = ('number_type', 'min_val', 'max_val', 'exclusive_min_val', 'exclusive_max_val', 'step_val')
+    
     def __init__(self, constraints: Dict[str, Any], number_type: type = int):
-        self.constraints = constraints
         self.number_type = number_type
+        self.min_val = float(constraints['min']) if 'min' in constraints else None
+        self.max_val = float(constraints['max']) if 'max' in constraints else None
+        self.exclusive_min_val = float(constraints['exclusive_min']) if 'exclusive_min' in constraints else None
+        self.exclusive_max_val = float(constraints['exclusive_max']) if 'exclusive_max' in constraints else None
+        step = constraints.get('step') or constraints.get('multiple_of')
+        self.step_val = float(step) if step else None
 
     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 self.min_val is not None and val < self.min_val:
+            raise ValidationError(f"Value {val} is less than minimum {self.min_val}", [{"path": path, "message": f"Must be >= {self.min_val}"}])
         
-        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 self.max_val is not None and val > self.max_val:
+            raise ValidationError(f"Value {val} is greater than maximum {self.max_val}", [{"path": path, "message": f"Must be <= {self.max_val}"}])
+
+        if self.exclusive_min_val is not None and val <= self.exclusive_min_val:
+            raise ValidationError(f"Value {val} must be greater than {self.exclusive_min_val}", [{"path": path, "message": f"Must be > {self.exclusive_min_val}"}])
                 
-        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}"}])
+        if self.exclusive_max_val is not None and val >= self.exclusive_max_val:
+            raise ValidationError(f"Value {val} must be less than {self.exclusive_max_val}", [{"path": path, "message": f"Must be < {self.exclusive_max_val}"}])
+
+        if self.step_val is not None:
+            if not math.isclose(val % self.step_val, 0, abs_tol=1e-9) and not math.isclose(val % self.step_val, self.step_val, abs_tol=1e-9):
+                 raise ValidationError(f"Value {val} is not a multiple of {self.step_val}", [{"path": path, "message": f"Must be multiple of {self.step_val}"}])
 
         return self.number_type(val)
 
 class StringValidator(Validator[str]):
+    __slots__ = ('min_len', 'max_len', 'pattern', 'format')
+    
     def __init__(self, constraints: Dict[str, Any]):
-        self.constraints = constraints
+        min_l = constraints.get('min_length') or constraints.get('min_len')
+        self.min_len = int(min_l) if min_l else None
+        max_l = constraints.get('max_length') or constraints.get('max_len')
+        self.max_len = int(max_l) if max_l else None
+        self.pattern = constraints.get('regex') or constraints.get('pattern')
+        self.format = constraints.get('format')
 
     def validate(self, data: Any, path: str = "") -> str:
         if not isinstance(data, str):
@@ -77,32 +75,19 @@ class StringValidator(Validator[str]):
         
         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 self.min_len is not None and len(val) < self.min_len:
+           raise ValidationError(f"String length {len(val)} is shorter than min {self.min_len}", [{"path": path, "message": f"Length must be >= {self.min_len}"}])
+
+        if self.max_len is not None and len(val) > self.max_len:
+           raise ValidationError(f"String length {len(val)} is longer than max {self.max_len}", [{"path": path, "message": f"Length must be <= {self.max_len}"}])
+
+        if self.pattern and isinstance(self.pattern, str) and not re.search(self.pattern, val):
+            raise ValidationError(f"String does not match pattern '{self.pattern}'", [{"path": path, "message": "Pattern mismatch"}])
+
+        if self.format == 'email':
             if '@' not in val: # Very basic check
                 raise ValidationError("Invalid email format", [{"path": path, "message": "Invalid email"}])
-        elif fmt == 'uuid':
+        elif self.format == '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"}])
@@ -111,6 +96,8 @@ class StringValidator(Validator[str]):
         return val
 
 class CollectionValidator(Validator[list]):
+    __slots__ = ('constraints', 'item_validator')
+    
     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)
@@ -133,12 +120,10 @@ class CollectionValidator(Validator[list]):
 
         # 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]:
@@ -165,6 +150,8 @@ class CollectionValidator(Validator[list]):
         return validated_data
 
 class UnionValidator(Validator[Any]):
+    __slots__ = ('validators', 'mode')
+    
     def __init__(self, validators: List[Validator], mode: str = "any_of"):
         self.validators = validators
         self.mode = mode # 'any_of' or 'one_of'
@@ -194,6 +181,8 @@ class UnionValidator(Validator[Any]):
         raise ValidationError("Matches none of the allowed types", [{"path": path, "message": "No match for Union"}])
 
 class ObjectValidator(Validator[Dict]):
+    __slots__ = ('fields', 'constraints', 'required_keys')
+    
     def __init__(self, fields: Dict[str, Validator], constraints: Dict[str, Any], required_keys: Set[str]):
         self.fields = fields
         self.constraints = constraints
@@ -209,8 +198,6 @@ class ObjectValidator(Validator[Dict]):
         # 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"})
         
@@ -240,6 +227,8 @@ class ObjectValidator(Validator[Dict]):
         return final_data
 
 class LiteralValidator(Validator[Any]):
+    __slots__ = ('allowed_values',)
+    
     def __init__(self, allowed_values: Tuple[Any, ...]):
         self.allowed_values = allowed_values