pytastic 0.0.6__tar.gz → 0.0.7__tar.gz

{pytastic-0.0.6 → pytastic-0.0.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pytastic
-Version: 0.0.6
+Version: 0.0.7
 Summary: A dependency-free JSON validation library using TypedDict and Annotated
 License-File: LICENSE
 Author: Tersoo
@@ -13,6 +13,7 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
+Project-URL: Repository, https://github.com/tersoo/pytastic
 Description-Content-Type: text/markdown
 
 # Pytastic
@@ -37,7 +38,7 @@ Benchmark results (100,000 validation iterations):
 | **Pytastic** | **0.1794** | **557,277** | **3.37x** |
 | Pydantic | 0.2002 | 499,381 | 3.76x |
 
-**Pytastic is faster than Pydantic** Pure Python with zero dependencies!
+**Pytastic is faster than Pydantic** i.e. Pure Python with zero dependencies!
 
 ## Installation
 

{pytastic-0.0.6 → pytastic-0.0.7}/README.md

@@ -20,7 +20,7 @@ Benchmark results (100,000 validation iterations):
 | **Pytastic** | **0.1794** | **557,277** | **3.37x** |
 | Pydantic | 0.2002 | 499,381 | 3.76x |
 
-**Pytastic is faster than Pydantic** Pure Python with zero dependencies!
+**Pytastic is faster than Pydantic** i.e. Pure Python with zero dependencies!
 
 ## Installation
 

{pytastic-0.0.6 → pytastic-0.0.7}/pyproject.toml

@@ -1,9 +1,10 @@
 [tool.poetry]
 name = "pytastic"
-version = "0.0.6"
+version = "0.0.7"
 description = "A dependency-free JSON validation library using TypedDict and Annotated"
 authors = ["Tersoo <tersoo@example.com>"]
 readme = "README.md"
+repository = "https://github.com/tersoo/pytastic"
 packages = [{include = "pytastic"}]
 
 [tool.poetry.dependencies]

{pytastic-0.0.6 → pytastic-0.0.7}/pytastic/codegen.py

@@ -6,7 +6,6 @@ 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
@@ -66,14 +65,32 @@ class CodegenCompiler:
             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)
+            elif base_origin is tuple or base_origin is Tuple:
+                inner_types = get_args(base_type)
+                return self._gen_tuple(var_name, path_var, inner_types, constraints, indent)
         
         if self._is_typeddict(schema):
-            return self._gen_object(schema, var_name, path_var, {}, indent)
+            constraints = {}
+            # Handle metadata from `_: Annotated[...]` pattern
+            if hasattr(schema, '__annotations__') and '_' in schema.__annotations__:
+                 meta_annotation = schema.__annotations__.get('_', None)
+                 if meta_annotation and get_origin(meta_annotation) is Annotated:
+                     meta_args = get_args(meta_annotation)
+                     constraint_str = ""
+                     for arg in meta_args[1:]:
+                        if isinstance(arg, str):
+                            constraint_str += arg + ";"
+                     meta_constraints = parse_constraints(constraint_str)
+                     constraints.update(meta_constraints)
+            return self._gen_object(schema, var_name, path_var, constraints, 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 tuple or origin is Tuple:
+            return self._gen_tuple(var_name, path_var, args, {}, indent)
+        
         if origin is Union:
             return self._gen_union(var_name, path_var, args, indent)
         
@@ -178,6 +195,19 @@ class CodegenCompiler:
             if not is_required:
                 indent -= 1
         
+        # Additional Properties Check
+        if constraints.get('strict') or constraints.get('additional_properties') is False:
+             lines.append(f"{ind}known_keys = set({repr(list(type_hints.keys()))}) - {{'_'}}")
+             lines.append(f"{ind}extra_keys = set({var}.keys()) - known_keys")
+             lines.append(f"{ind}if extra_keys:")
+             lines.append(f"{ind}    raise ValidationError(f'Extra fields not allowed at {{{path}}}: {{extra_keys}}', [{{'path': {path}, 'message': 'Extra fields not allowed'}}])")
+
+        # Min Properties
+        min_props = constraints.get('min_properties') or constraints.get('min_props')
+        if min_props:
+             lines.append(f"{ind}if len({var}) < {min_props}:")
+             lines.append(f"{ind}    raise ValidationError(f'Too few properties at {{{path}}}', [{{'path': {path}, 'message': 'Min properties {min_props}'}}])")
+
         return lines
     
     def _gen_list(self, var: str, path: str, item_type: Type, constraints: Dict, indent: int) -> List[str]:
@@ -228,6 +258,30 @@ class CodegenCompiler:
         
         return lines
     
+    def _gen_tuple(self, var: str, path: str, item_types: Tuple[Type, ...], constraints: Dict, indent: int) -> List[str]:
+        """Generate tuple validation code."""
+        ind = '    ' * indent
+        lines = []
+        
+        lines.append(f"{ind}if not isinstance({var}, (list, tuple)):")
+        lines.append(f"{ind}    raise ValidationError(f'Expected tuple at {{{path}}}', [{{'path': {path}, 'message': 'Invalid type'}}])")
+        
+        expected_len = len(item_types)
+        lines.append(f"{ind}if len({var}) != {expected_len}:")
+        lines.append(f"{ind}    raise ValidationError(f'Expected {expected_len} items at {{{path}}}', [{{'path': {path}, 'message': 'Expected {expected_len} items'}}])")
+        
+        for i, item_type in enumerate(item_types):
+            item_path = f"{path} + f'[{i}]'"
+            # Tuple items are accessed by index
+            # We need to assign to a temp var to be safe for recursive validation
+            temp_var = f"_tuple_item_{indent}_{i}"
+            lines.append(f"{ind}{temp_var} = {var}[{i}]")
+            
+            item_lines = self._generate_validator(item_type, temp_var, item_path, indent)
+            lines.extend(item_lines)
+            
+        return lines
+
     def _gen_literal(self, var: str, path: str, values: Tuple, indent: int) -> List[str]:
         """Generate literal validation code."""
         ind = '    ' * indent