pytastic 0.0.3__tar.gz → 0.0.4__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pytastic
-Version: 0.0.3
+Version: 0.0.4
 Summary: A dependency-free JSON validation library using TypedDict and Annotated
 License-File: LICENSE
 Author: Tersoo
@@ -45,6 +45,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.4}/README.md

@@ -28,6 +28,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.4}/pyproject.toml

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

{pytastic-0.0.3 → pytastic-0.0.4}/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,52 @@ 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 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 +114,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.4}/pytastic/core.py

@@ -12,7 +12,7 @@ class Pytastic:
     """
     def __init__(self):
         self.compiler = SchemaCompiler()
-        self._registry: Dict[str, Any] = {} # Maps name -> Validator
+        self._registry: Dict[str, Any] = {}
 
     def register(self, schema: Type[T]) -> None:
         """
@@ -27,7 +27,6 @@ class Pytastic:
         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)
 
@@ -37,7 +36,6 @@ class Pytastic:
         """
         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

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

@@ -41,7 +41,7 @@ class JsonSchemaGenerator:
         return {} # Fallback
 
     def _visit_number(self, v: NumberValidator) -> Dict[str, Any]:
-        schema = {"type": "integer" if v.number_type is int else "number"}
+        schema: Dict[str, Any] = {"type": "integer" if v.number_type is int else "number"}
         c = v.constraints
         
         if 'min' in c: schema['minimum'] = float(c['min'])
@@ -55,7 +55,7 @@ class JsonSchemaGenerator:
         return schema
 
     def _visit_string(self, v: StringValidator) -> Dict[str, Any]:
-        schema = {"type": "string"}
+        schema: Dict[str, Any] = {"type": "string"}
         c = v.constraints
         
         min_l = c.get('min_length') or c.get('min_len')
@@ -73,7 +73,7 @@ class JsonSchemaGenerator:
         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 +81,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 +92,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.4}/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.4}/pytastic/validators.py

@@ -11,13 +11,12 @@ 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]):
+    def validate(self, data: Any, path: str = "") -> Any:
+        return data
+
 class NumberValidator(Validator[Union[int, float]]):
     def __init__(self, constraints: Dict[str, Any], number_type: type = int):
         self.constraints = constraints
@@ -27,8 +26,6 @@ class NumberValidator(Validator[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"}])
 
@@ -56,12 +53,9 @@ class NumberValidator(Validator[Union[int, float]]):
             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}"}])
 
@@ -133,12 +127,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]:
@@ -209,8 +201,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"})