string-schema 0.1.5__py3-none-any.whl → 0.1.7__py3-none-any.whl

string_schema/__init__.py

@@ -64,7 +64,7 @@ from .integrations.json_schema import (
 # Note: Built-in presets moved to examples/ directory
 # Import them from simple_schema.examples.presets if needed
 
-__version__ = "0.1.0"
+__version__ = "0.1.7"
 __author__ = "importal"
 
 __all__ = [

string_schema/core/builders.py

@@ -67,10 +67,10 @@ def _simple_field_to_json_schema(field: SimpleField) -> Dict[str, Any]:
     
     # Regular single type
     prop = {"type": field.field_type}
-    
+
     if field.description:
         prop["description"] = field.description
-    if field.default is not None:
+    if field.has_default:
         prop["default"] = field.default
     
     # Handle enum/choices

string_schema/core/fields.py

@@ -10,23 +10,27 @@ import logging
 logger = logging.getLogger(__name__)
 
 
+# Sentinel value to distinguish "no default" from "default is None"
+_NO_DEFAULT = object()
+
+
 class SimpleField:
     """Enhanced SimpleField with support for all new features"""
-    
+
     def __init__(self, field_type: str, description: str = "", required: bool = True,
-                 default: Any = None, min_val: Optional[Union[int, float]] = None,
+                 default: Any = _NO_DEFAULT, min_val: Optional[Union[int, float]] = None,
                  max_val: Optional[Union[int, float]] = None, min_length: Optional[int] = None,
                  max_length: Optional[int] = None, choices: Optional[List[Any]] = None,
                  min_items: Optional[int] = None, max_items: Optional[int] = None,
                  format_hint: Optional[str] = None, union_types: Optional[List[str]] = None):
         """
         Initialize a SimpleField with comprehensive validation options.
-        
+
         Args:
             field_type: The base type (string, integer, number, boolean)
             description: Human-readable description of the field
             required: Whether the field is required (default: True)
-            default: Default value if field is not provided
+            default: Default value if field is not provided (use _NO_DEFAULT sentinel for no default)
             min_val: Minimum value for numeric types
             max_val: Maximum value for numeric types
             min_length: Minimum length for string types
@@ -41,6 +45,7 @@ class SimpleField:
         self.description = description
         self.required = required
         self.default = default
+        self.has_default = default is not _NO_DEFAULT
         self.min_val = min_val
         self.max_val = max_val
         self.min_length = min_length
@@ -70,10 +75,10 @@ class SimpleField:
             'type': self.field_type,
             'required': self.required
         }
-        
+
         if self.description:
             result['description'] = self.description
-        if self.default is not None:
+        if self.has_default:
             result['default'] = self.default
         if self.min_val is not None:
             result['min_val'] = self.min_val
@@ -93,7 +98,7 @@ class SimpleField:
             result['format_hint'] = self.format_hint
         if self.union_types:
             result['union_types'] = self.union_types
-            
+
         return result
     
     @classmethod

string_schema/integrations/pydantic.py

@@ -90,7 +90,7 @@ def _simple_field_to_pydantic(field: SimpleField) -> tuple:
     if field.description:
         field_kwargs['description'] = field.description
 
-    if field.default is not None:
+    if field.has_default:
         field_kwargs['default'] = field.default
     elif not field.required:
         field_kwargs['default'] = None

string_schema/parsing/string_parser.py

@@ -8,7 +8,7 @@ import re
 from typing import Dict, Any, List, Union, Optional
 import logging
 
-from ..core.fields import SimpleField
+from ..core.fields import SimpleField, _NO_DEFAULT
 from ..core.builders import simple_schema, list_of_objects_schema
 
 logger = logging.getLogger(__name__)
@@ -136,52 +136,110 @@ def _parse_object_fields(fields_str: str) -> Dict[str, Any]:
 
 
 def _parse_single_field_with_nesting(field_str: str) -> tuple:
-    """Parse a single field with enhanced syntax support"""
+    """
+    Parse a single field with enhanced syntax support.
+
+    New syntax support:
+        - Descriptions: field:type | description
+        - Defaults: field:type=default
+        - Combined: field:type(constraints)=default | description
+
+    Examples:
+        "name:string | User name"
+        "age:int=18"
+        "active:bool=true | Whether user is active"
+        "count:int(1,100)=1 | Item count"
+    """
     if not field_str:
         return None, None
-    
-    # Check for optional marker
+
+    # Step 1: Extract description (after |)
+    # Note: Must be done BEFORE checking for union types (which also use |)
+    description = ""
+    # Only split on | if it's not part of a union type definition
+    # Union types are like "string|int|null" (no spaces, part of type definition)
+    # Descriptions are like "type | description" (with space before |)
+    # Look for " |" pattern to distinguish from union types
+    if ' |' in field_str:
+        # This is a description separator, not a union type
+        parts = field_str.split(' |', 1)
+        field_str = parts[0].strip()
+        if len(parts) > 1:
+            description = parts[1].strip()
+
+    # Step 2: Check for optional marker (?)
+    # Must be done BEFORE extracting default to handle "string?=null" correctly
     required = True
-    if field_str.endswith('?'):
-        required = False
-        field_str = field_str[:-1].strip()
-    
-    # Split field name and definition
+    if '?' in field_str:
+        # Check if ? is before = (e.g., "string?=null")
+        if '=' in field_str:
+            # Find position of ? and =
+            q_pos = field_str.find('?')
+            eq_pos = field_str.find('=')
+            if q_pos < eq_pos:
+                # ? comes before =, so it's an optional marker
+                field_str = field_str[:q_pos] + field_str[q_pos+1:]
+                required = False
+        elif field_str.endswith('?'):
+            # Simple optional marker at the end
+            required = False
+            field_str = field_str[:-1].strip()
+
+    # Step 3: Extract default value (after =)
+    # Must be done BEFORE parsing type definition to avoid conflicts with constraints
+    default_value = _NO_DEFAULT  # Use sentinel to distinguish "no default" from "default is None"
+    if '=' in field_str:
+        # Check if = is after the type definition (not in constraints)
+        if ':' in field_str:
+            name_part, type_part = field_str.split(':', 1)
+            # Split type_part on = outside parentheses
+            parts = _split_on_equals_outside_parens(type_part)
+            if len(parts) == 2:
+                field_str = name_part + ':' + parts[0].strip()
+                default_str = parts[1].strip()
+                default_value = _parse_default_value(default_str)
+
+    # Step 4: Split field name and definition
     if ':' in field_str:
         field_name, field_def = field_str.split(':', 1)
         field_name = field_name.strip()
         field_def = field_def.strip()
-        
+
         # Handle nested structures
         if field_def.startswith('[') or field_def.startswith('{'):
             nested_structure = _parse_schema_structure(field_def)
             nested_structure['required'] = required
             return field_name, nested_structure
-        
+
         # Handle union types: string|int|null
+        # Union types have | without spaces around them
         elif '|' in field_def:
             union_types = [t.strip() for t in field_def.split('|')]
             field_type = _normalize_type_name(union_types[0])  # Use first type as primary
-            
+
             # Create field with union support
             field_obj = SimpleField(
                 field_type=field_type,
+                description=description,
+                default=default_value,
                 required=required
             )
             # Store union info for JSON schema generation
             field_obj.union_types = [_normalize_type_name(t) for t in union_types]
             return field_name, field_obj
-        
+
         # Handle enum types: enum(value1,value2,value3) or choice(...)
         elif field_def.startswith(('enum(', 'choice(', 'select(')):
             enum_values = _parse_enum_values(field_def)
             field_obj = SimpleField(
                 field_type="string",  # Enums are string-based
+                description=description,
+                default=default_value,
                 required=required,
                 choices=enum_values
             )
             return field_name, field_obj
-        
+
         # Handle array types: array(string,max=5) or list(int,min=1)
         elif field_def.startswith(('array(', 'list(')):
             array_type, constraints = _parse_array_type_definition(field_def)
@@ -195,7 +253,7 @@ def _parse_single_field_with_nesting(field_str: str) -> tuple:
                 "constraints": constraints,
                 "required": required
             }
-        
+
         # Handle regular type with constraints
         else:
             original_type = field_def.split('(')[0].strip()  # Get type before any constraints
@@ -208,16 +266,20 @@ def _parse_single_field_with_nesting(field_str: str) -> tuple:
 
             field_obj = SimpleField(
                 field_type=field_type,
+                description=description,
+                default=default_value,
                 required=required,
                 **constraints
             )
             return field_name, field_obj
-    
+
     # Field name only (default to string)
     else:
         field_name = field_str.strip()
         field_obj = SimpleField(
             field_type="string",
+            description=description,
+            default=default_value,
             required=required
         )
         return field_name, field_obj
@@ -229,12 +291,75 @@ def _parse_enum_values(enum_def: str) -> List[str]:
     match = re.match(r'^(?:enum|choice|select)\(([^)]+)\)$', enum_def)
     if not match:
         return []
-    
+
     values_str = match.group(1)
     values = [v.strip() for v in values_str.split(',')]
     return values
 
 
+def _split_on_equals_outside_parens(s: str) -> List[str]:
+    """
+    Split string on FIRST = outside parentheses only.
+
+    Example:
+        "int(1,100)=5" -> ["int(1,100)", "5"]
+        "string=hello" -> ["string", "hello"]
+        "string=a=b" -> ["string", "a=b"]  # Only split on first =
+    """
+    depth = 0
+
+    for i, char in enumerate(s):
+        if char == '(':
+            depth += 1
+        elif char == ')':
+            depth -= 1
+        elif char == '=' and depth == 0:
+            # Found first = outside parentheses - split here
+            return [s[:i], s[i+1:]]
+
+    # No = found outside parentheses
+    return [s]
+
+
+def _parse_default_value(default_str: str) -> Any:
+    """
+    Parse default value from string.
+
+    Supports:
+        - Booleans: true, false
+        - Null: null, none
+        - Numbers: 123, 45.67
+        - Strings: "hello", 'world', or unquoted
+    """
+    default_str = default_str.strip()
+
+    # Boolean
+    if default_str.lower() in ['true', 'false']:
+        return default_str.lower() == 'true'
+
+    # Null/None
+    if default_str.lower() in ['null', 'none']:
+        return None
+
+    # Number
+    try:
+        if '.' in default_str:
+            return float(default_str)
+        else:
+            return int(default_str)
+    except ValueError:
+        pass
+
+    # String (remove quotes if present)
+    if default_str.startswith('"') and default_str.endswith('"'):
+        return default_str[1:-1]
+    if default_str.startswith("'") and default_str.endswith("'"):
+        return default_str[1:-1]
+
+    # Return as-is (string)
+    return default_str
+
+
 def _parse_array_type_definition(array_def: str) -> tuple:
     """Parse array(type,constraints) or list(type,constraints)"""
     # Extract content between parentheses
@@ -363,7 +488,7 @@ def _simple_field_to_json_schema(field: SimpleField) -> Dict[str, Any]:
     # Basic metadata
     if field.description:
         prop["description"] = field.description
-    if field.default is not None:
+    if field.has_default:
         prop["default"] = field.default
 
     # Handle union types

string_schema/utilities.py

@@ -15,6 +15,7 @@ Key Functions:
 
 import functools
 import uuid
+from datetime import datetime, timezone
 from typing import Any, Dict, Type, Union, Callable, Optional, List
 import logging
 
@@ -30,6 +31,48 @@ except ImportError:
 logger = logging.getLogger(__name__)
 
 
+def _ensure_timezone_aware_dict(data: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Ensure all datetime values in a dictionary have timezone information.
+
+    This function recursively processes dictionaries and lists to add UTC timezone
+    information to naive datetime objects, ensuring consistent API responses.
+
+    Args:
+        data: Dictionary that may contain datetime values
+
+    Returns:
+        Dictionary with timezone-aware datetime values converted to ISO format
+    """
+    if not isinstance(data, dict):
+        return data
+
+    result = {}
+    for key, value in data.items():
+        if isinstance(value, datetime):
+            # Add UTC timezone to naive datetime objects
+            if value.tzinfo is None:
+                value = value.replace(tzinfo=timezone.utc)
+            # Convert to ISO format string for consistent API responses
+            result[key] = value.isoformat()
+        elif isinstance(value, dict):
+            # Recursively process nested dictionaries
+            result[key] = _ensure_timezone_aware_dict(value)
+        elif isinstance(value, list):
+            # Process lists that may contain dictionaries or datetime objects
+            result[key] = [
+                _ensure_timezone_aware_dict(item) if isinstance(item, dict)
+                else item.isoformat() if isinstance(item, datetime) and item.tzinfo is None
+                else item.replace(tzinfo=timezone.utc).isoformat() if isinstance(item, datetime)
+                else item
+                for item in value
+            ]
+        else:
+            result[key] = value
+
+    return result
+
+
 def string_to_model(schema_str: str, name: Optional[str] = None) -> Type[BaseModel]:
     """
     Create Pydantic model from string schema.
@@ -218,13 +261,21 @@ def validate_to_dict(data: Union[Dict[str, Any], Any], schema_str: str) -> Union
             try:
                 # Try Pydantic v2 RootModel style
                 validated_instance = TempModel(data)
-                # Return the validated array data
-                return validated_instance.model_dump() if hasattr(validated_instance, 'model_dump') else validated_instance.dict()
+                # Return the validated array data with timezone-aware conversion
+                result_data = validated_instance.model_dump() if hasattr(validated_instance, 'model_dump') else validated_instance.dict()
+                # Process array items for timezone-aware datetime conversion
+                if isinstance(result_data, list):
+                    return [_ensure_timezone_aware_dict(item) if isinstance(item, dict) else item for item in result_data]
+                return result_data
             except:
                 # Fallback to Pydantic v1 style
                 validated_instance = TempModel(__root__=data)
-                # Return the validated array data
-                return validated_instance.model_dump()['__root__'] if hasattr(validated_instance, 'model_dump') else validated_instance.dict()['__root__']
+                # Return the validated array data with timezone-aware conversion
+                result_data = validated_instance.model_dump()['__root__'] if hasattr(validated_instance, 'model_dump') else validated_instance.dict()['__root__']
+                # Process array items for timezone-aware datetime conversion
+                if isinstance(result_data, list):
+                    return [_ensure_timezone_aware_dict(item) if isinstance(item, dict) else item for item in result_data]
+                return result_data
         else:
             # Handle different input types for object schemas
             if isinstance(data, dict):
@@ -236,11 +287,14 @@ def validate_to_dict(data: Union[Dict[str, Any], Any], schema_str: str) -> Union
                 # Try direct validation
                 validated_instance = TempModel(data)
 
-            # Return as dictionary (use model_dump for Pydantic v2, fallback to dict for v1)
+            # Return as dictionary with timezone-aware datetime handling
             if hasattr(validated_instance, 'model_dump'):
-                return validated_instance.model_dump()
+                result_dict = validated_instance.model_dump()
             else:
-                return validated_instance.dict()
+                result_dict = validated_instance.dict()
+
+            # Ensure timezone-aware datetime conversion for consistent API responses
+            return _ensure_timezone_aware_dict(result_dict)
 
     except ValidationError as e:
         # Re-raise the original validation error
@@ -403,7 +457,7 @@ def get_model_info(model_class) -> Dict[str, Any]:
     Returns:
         Dictionary with model information including fields, types, and constraints
     """
-    if not HAS_PYDANTIC or not issubclass(model_class, BaseModel):
+    if not HAS_PYDANTIC or not isinstance(model_class, type) or not issubclass(model_class, BaseModel):
         raise ValueError("Input must be a Pydantic model class")
 
     info = {

{string_schema-0.1.5.dist-info → string_schema-0.1.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: string-schema
-Version: 0.1.5
+Version: 0.1.7
 Summary: A simple, LLM-friendly schema definition library for converting string syntax to structured schemas
 Home-page: https://github.com/xychenmsn/string-schema
 Author: Michael Chen
@@ -151,6 +151,7 @@ String Schema takes human-readable text descriptions and converts them into stru
 - **🤖 LLM Data Extraction**: Define extraction schemas that LLMs can easily follow
 - **🔧 API Development**: Generate Pydantic models and OpenAPI docs from simple syntax
 - **✅ Data Validation**: Create robust validation schemas with minimal code
+- **🌍 Timezone-Aware APIs**: Automatic UTC conversion for consistent datetime handling
 - **📋 Configuration**: Define and validate application configuration schemas
 - **🔄 Data Transformation**: Convert between different schema formats
 
@@ -175,6 +176,12 @@ print(user_dict)  # {"name": "John Doe", "email": "john@example.com", "age": 25}
 user_model = validate_to_model(raw_data, "name:string, email:email, age:int?")
 print(user_model.name)  # "John Doe" - Full type safety
 print(user_model.age)   # 25 - Converted to int
+
+# 🌍 Automatic timezone handling for datetime fields
+from datetime import datetime
+event_data = {"name": "Meeting", "start_time": datetime(2025, 8, 13, 14, 30)}
+event_dict = validate_to_dict(event_data, "name:string, start_time:datetime")
+print(event_dict)  # {"name": "Meeting", "start_time": "2025-08-13T14:30:00+00:00"}
 ```
 
 ### 🎨 Function Decorators

{string_schema-0.1.5.dist-info → string_schema-0.1.7.dist-info}/RECORD

@@ -1,9 +1,9 @@
-string_schema/__init__.py,sha256=J0_B0TNO0AK_piEcT5gFFHllywjx16DTP59ps_Fp-WU,4052
+string_schema/__init__.py,sha256=Vosc4ZtNqbdr06YwSbAYt16tfJxliONVEx5ekLXx5vM,4052
 string_schema/py.typed,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-string_schema/utilities.py,sha256=iLyqCKFd0qTL13xyZvt3Dia2-gjZCjHyDVVm59GxLK4,19918
+string_schema/utilities.py,sha256=57fzXusitdYL2AFVitY0_3d8JSlnNGC5GEqw7tzd_YI,22388
 string_schema/core/__init__.py,sha256=jeukkZ1WoCSXrBafumHVH2GkCJ6QjnkH_jAr3DESFio,481
-string_schema/core/builders.py,sha256=AHDTqtCnSe5ZN-DwedisqXqktjgl6nypd-mebucjI3k,7809
-string_schema/core/fields.py,sha256=iLUR-w3pZCr7OkQHhb2DFkVLtObnpyJ_mEUdc0qAqXY,5534
+string_schema/core/builders.py,sha256=DLloMAxeBSUSS_h7cqQ6RJPF4wnl4MyzdmJgMfj2M-M,7797
+string_schema/core/fields.py,sha256=sqIG7zw1gm85zPnAgotgjsl9vXdki72JTgewrbV0asw,5690
 string_schema/core/validators.py,sha256=6inSZGou0zKpN47ttVWOxWsN-nPN3EewUNRacB9UUkA,8303
 string_schema/examples/__init__.py,sha256=wmdWey3ggt3yXG2XQygfHeghq-P31VdTkoqyki_qY1k,639
 string_schema/examples/presets.py,sha256=T7OQOsvVrPrzS2_1C6Hls17neeIGOBfVs0xOkZehaSQ,14642
@@ -11,14 +11,14 @@ string_schema/examples/recipes.py,sha256=bOX0zH-m5NVYFnfBIGzxag1BpNexe6OPJ55ssn0
 string_schema/integrations/__init__.py,sha256=yLRtfeVEDntULjMXKv_TWKXh860lKnQzCMMYcZvOr90,323
 string_schema/integrations/json_schema.py,sha256=cNr9chGc5RSfFLNXJCTH1ZOVd91OH9oeaAvf_Nqy8Zs,12627
 string_schema/integrations/openapi.py,sha256=bUHzJWOZEDtXs0R6493jAhA0-PrKwaUTkDW5UWE6-nI,15637
-string_schema/integrations/pydantic.py,sha256=hYrnl2hKcmbp7ypEINqn065dpLaCWxb39T1A8va1YrM,21818
+string_schema/integrations/pydantic.py,sha256=m8cap2d8VHILKGnpqhh26IX1PDUFz2WPqBi1S1pUVq8,21810
 string_schema/integrations/reverse.py,sha256=qN8OCRjaH0nerZFrljAnvFLjZjo9gln2H-HBiaevLoI,9023
 string_schema/parsing/__init__.py,sha256=dFW68DqJIwP4w_aYaZMjjVK15X7tCv8A0SPqmIgGEjQ,411
 string_schema/parsing/optimizer.py,sha256=Ofte8Tb7sKmdEv7RrVIEBQ4Qqr-Whanp1vh8BakcOgw,8479
-string_schema/parsing/string_parser.py,sha256=-a_143fjNkxcRu24JdpqA6GltR7a_2AUXPNgHsbwYv4,24989
+string_schema/parsing/string_parser.py,sha256=xsHMYdMEwGirQn0GJWsOy26LqVTangzMxz8BrQ5meEw,29230
 string_schema/parsing/syntax.py,sha256=RO3BIAnWfDBupowOnoJocHtAe-kwE-SgRWXKknVwGdg,8900
-string_schema-0.1.5.dist-info/licenses/LICENSE,sha256=wCD2KBeSlVSkJy0apl6zmVj04uw97UJhRRi-en_3Qfk,1065
-string_schema-0.1.5.dist-info/METADATA,sha256=W8XGHUtUAz-SlPW1Mw1Y_SHy1SjuntWS9AolofnE64E,18246
-string_schema-0.1.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-string_schema-0.1.5.dist-info/top_level.txt,sha256=1uTmLPYIRrCDVxUW1fDFRMaWvGO48NRcGmbW4oq89I0,14
-string_schema-0.1.5.dist-info/RECORD,,
+string_schema-0.1.7.dist-info/licenses/LICENSE,sha256=wCD2KBeSlVSkJy0apl6zmVj04uw97UJhRRi-en_3Qfk,1065
+string_schema-0.1.7.dist-info/METADATA,sha256=NSS3KDt63-2VzhB6i_EYG8cN7N76ckOxL3GIReystGk,18662
+string_schema-0.1.7.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+string_schema-0.1.7.dist-info/top_level.txt,sha256=1uTmLPYIRrCDVxUW1fDFRMaWvGO48NRcGmbW4oq89I0,14
+string_schema-0.1.7.dist-info/RECORD,,

{string_schema-0.1.5.dist-info → string_schema-0.1.7.dist-info}/WHEEL

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