string-schema 0.1.5__tar.gz → 0.1.7__tar.gz

{string_schema-0.1.5/string_schema.egg-info → string_schema-0.1.7}/PKG-INFO

@@ -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 → string_schema-0.1.7}/README.md

@@ -103,6 +103,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
 
@@ -127,6 +128,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 → string_schema-0.1.7}/docs/pydantic-utilities.md

@@ -41,6 +41,7 @@ ProfileModel = string_to_model("name:string, profile:{bio:text?, avatar:url?, so
 
 - ✅ Basic types: `string`, `int`, `number`, `boolean`
 - ✅ Special types: `email`, `url`, `uuid`, `datetime`, `phone`
+- ✅ **Timezone-aware datetime**: Automatic UTC conversion for consistent API responses
 - ✅ Arrays: `[string]`, `[{name:string, price:number}]`
 - ✅ Nested objects: `profile:{bio:text?, avatar:url?}`
 - ✅ Enums: `status:enum(active,inactive,pending)`
@@ -57,6 +58,11 @@ ProfileModel = string_to_model("name:string, profile:{bio:text?, avatar:url?, so
 user_dict = validate_to_dict(raw_data, "name:string, email:email, age:int?")
 # Returns: {"name": "John", "email": "john@example.com", "age": 30}
 
+# Automatic timezone handling for datetime fields
+event_data = {"name": "Meeting", "start_time": datetime(2025, 8, 13, 14, 30)}
+event_dict = validate_to_dict(event_data, "name:string, start_time:datetime")
+# Returns: {"name": "Meeting", "start_time": "2025-08-13T14:30:00+00:00"}
+
 # Array validation
 events = validate_to_dict(raw_events, "[{user_id:uuid, event:enum(login,logout,purchase)}]")
 
@@ -79,6 +85,60 @@ if profile.profile:
     print(profile.profile.bio)
 ```
 
+## 🌍 Timezone Handling
+
+String Schema automatically ensures all datetime fields include timezone information for consistent, timezone-aware API responses.
+
+### **Automatic UTC Conversion**
+
+```python
+from datetime import datetime
+from string_schema import validate_to_dict
+
+# Naive datetime gets UTC timezone
+data = {"event": "Meeting", "time": datetime(2025, 8, 13, 14, 30)}
+result = validate_to_dict(data, "event:string, time:datetime")
+# Returns: {"event": "Meeting", "time": "2025-08-13T14:30:00+00:00"}
+
+# Timezone-aware datetime preserved
+from datetime import timezone
+utc_time = datetime(2025, 8, 13, 14, 30, tzinfo=timezone.utc)
+data = {"event": "UTC Meeting", "time": utc_time}
+result = validate_to_dict(data, "event:string, time:datetime")
+# Returns: {"event": "UTC Meeting", "time": "2025-08-13T14:30:00+00:00"}
+```
+
+### **Nested and Array Support**
+
+```python
+# Nested datetime handling
+user_data = {
+    "name": "John",
+    "profile": {
+        "created_at": datetime(2025, 8, 13, 10, 0),
+        "last_login": datetime(2025, 8, 13, 12, 0)
+    }
+}
+result = validate_to_dict(user_data, "name:string, profile:{created_at:datetime, last_login:datetime}")
+# All nested datetime fields get timezone info automatically
+
+# Array datetime handling
+events = [
+    {"id": 1, "timestamp": datetime(2025, 8, 13, 9, 0)},
+    {"id": 2, "timestamp": datetime(2025, 8, 13, 10, 0)}
+]
+result = validate_to_dict(events, "[{id:int, timestamp:datetime}]")
+# All timestamps in array items get timezone info
+```
+
+### **Benefits**
+
+- ✅ **Consistent API Responses**: All datetime fields include timezone information
+- ✅ **Global Application Support**: Works correctly across all timezones
+- ✅ **Frontend Compatibility**: JavaScript automatically handles timezone conversion
+- ✅ **Zero Configuration**: Works automatically for all datetime fields
+- ✅ **Performance Optimized**: Minimal overhead with maximum benefit
+
 ## 🎨 Decorators
 
 ### 4. `@returns_dict(schema_str)`

{string_schema-0.1.5 → string_schema-0.1.7}/docs/string-syntax.md

@@ -40,6 +40,56 @@ price:number(min=0)
 description:text(max=500)
 ```
 
+### Default Values
+
+Add default values using `=`:
+
+```
+active:bool=true
+count:int=0
+status:string=pending
+price:number=9.99
+```
+
+Default values can be combined with constraints:
+
+```
+age:int(0,120)=18
+limit:int(1,1000)=100
+```
+
+### Field Descriptions
+
+Add human-readable descriptions using ` |` (space before pipe):
+
+```
+name:string | User's full name
+age:int | User's age in years
+email:email | Contact email address
+```
+
+### Combined Syntax
+
+You can combine all features:
+
+```
+name:string(min=1,max=100) | User's full name
+age:int(0,120)=18 | User's age in years
+active:bool=true | Whether the account is active
+email:string? | Optional email address
+count:int(1,1000)=1 | Number of items to process
+```
+
+**Syntax Order:**
+
+```
+field_name:type(constraints)?=default | description
+```
+
+- `?` = optional marker (before `=`)
+- `=value` = default value
+- ` | text` = description (space before pipe)
+
 ## Type System
 
 ### Basic Types

string_schema-0.1.7/examples/defaults_descriptions_demo.py

@@ -0,0 +1,203 @@
+"""
+Demo: Enhanced String Schema with Defaults and Descriptions
+
+This example demonstrates the new syntax for defining default values
+and descriptions in string-schema.
+
+New syntax:
+    - field:type=default
+    - field:type | description
+    - field:type=default | description
+"""
+
+from string_schema import parse_string_schema, validate_to_dict
+import json
+
+
+def print_section(title):
+    """Print a formatted section header"""
+    print(f"\n{'='*60}")
+    print(f"  {title}")
+    print('='*60)
+
+
+def demo_default_values():
+    """Demonstrate default value syntax"""
+    print_section("Default Values")
+    
+    # Define schema with defaults
+    schema_str = """
+        active:bool=true,
+        count:int=0,
+        status:string=pending,
+        price:number=9.99
+    """
+    
+    print("\nSchema definition:")
+    print(schema_str)
+    
+    # Parse schema
+    schema = parse_string_schema(schema_str)
+    print("\nGenerated JSON Schema:")
+    print(json.dumps(schema, indent=2))
+    
+    # Validate data with defaults
+    print("\n--- Test 1: Empty data (uses all defaults) ---")
+    data = {}
+    result = validate_to_dict(data, schema_str)
+    print(f"Input:  {data}")
+    print(f"Output: {result}")
+    
+    print("\n--- Test 2: Partial data (some defaults) ---")
+    data = {"count": 5}
+    result = validate_to_dict(data, schema_str)
+    print(f"Input:  {data}")
+    print(f"Output: {result}")
+    
+    print("\n--- Test 3: Override defaults ---")
+    data = {"active": False, "count": 10, "status": "completed", "price": 19.99}
+    result = validate_to_dict(data, schema_str)
+    print(f"Input:  {data}")
+    print(f"Output: {result}")
+
+
+def demo_descriptions():
+    """Demonstrate description syntax"""
+    print_section("Field Descriptions")
+    
+    # Define schema with descriptions
+    schema_str = """
+        name:string | User's full name,
+        age:int | User's age in years,
+        email:email | Contact email address,
+        created:datetime | Account creation timestamp
+    """
+    
+    print("\nSchema definition:")
+    print(schema_str)
+    
+    # Parse schema
+    schema = parse_string_schema(schema_str)
+    print("\nGenerated JSON Schema (with descriptions):")
+    print(json.dumps(schema, indent=2))
+
+
+def demo_combined_syntax():
+    """Demonstrate combined defaults and descriptions"""
+    print_section("Combined: Defaults + Descriptions")
+    
+    # Define schema with both defaults and descriptions
+    schema_str = """
+        name:string | User's full name,
+        age:int(0,120)=18 | User's age in years,
+        active:bool=true | Whether the account is active,
+        email:string? | Optional email address,
+        count:int(1,1000)=1 | Number of items to process
+    """
+    
+    print("\nSchema definition:")
+    print(schema_str)
+    
+    # Parse schema
+    schema = parse_string_schema(schema_str)
+    print("\nGenerated JSON Schema:")
+    print(json.dumps(schema, indent=2))
+    
+    # Validate data
+    print("\n--- Test: Minimal data (uses defaults) ---")
+    data = {"name": "John Doe"}
+    result = validate_to_dict(data, schema_str)
+    print(f"Input:  {data}")
+    print(f"Output: {result}")
+
+
+def demo_worker_parameters():
+    """Demonstrate using enhanced syntax for worker parameters"""
+    print_section("Real-World Example: Worker Parameters")
+    
+    # Define worker parameters schema
+    schema_str = """
+        enable_cleanup:bool=true | Enable article cleanup step,
+        enable_cat_tag:bool=true | Enable category and tag assignment,
+        enable_create_summary:bool=true | Enable summary generation,
+        enable_embedding_generation:bool=true | Enable embedding generation,
+        max_articles_per_iteration:int(1,1000)=1 | Maximum articles to process per run,
+        processing_days_limit:int(1,365)=7 | Number of days to look back for articles,
+        model_name:string? | LLM model to use (leave empty for default)
+    """
+    
+    print("\nWorker Parameters Schema:")
+    print(schema_str)
+    
+    # Parse schema
+    schema = parse_string_schema(schema_str)
+    print("\nGenerated JSON Schema:")
+    print(json.dumps(schema, indent=2))
+    
+    # Example 1: Default configuration
+    print("\n--- Example 1: Default configuration ---")
+    params = {}
+    result = validate_to_dict(params, schema_str)
+    print(f"Input:  {params}")
+    print(f"Output: {json.dumps(result, indent=2)}")
+    
+    # Example 2: Custom configuration
+    print("\n--- Example 2: Custom configuration ---")
+    params = {
+        "enable_cleanup": False,
+        "max_articles_per_iteration": 10,
+        "model_name": "openrouter:google/gemini-2.5-flash-lite"
+    }
+    result = validate_to_dict(params, schema_str)
+    print(f"Input:  {json.dumps(params, indent=2)}")
+    print(f"Output: {json.dumps(result, indent=2)}")
+
+
+def demo_null_defaults():
+    """Demonstrate null default values"""
+    print_section("Null Default Values")
+    
+    # Define schema with null defaults
+    schema_str = """
+        name:string,
+        email:string?=null | Optional email (defaults to null),
+        phone:string?=null | Optional phone (defaults to null),
+        notes:string? | Optional notes (no default)
+    """
+    
+    print("\nSchema definition:")
+    print(schema_str)
+    
+    # Parse schema
+    schema = parse_string_schema(schema_str)
+    print("\nGenerated JSON Schema:")
+    print(json.dumps(schema, indent=2))
+    
+    # Validate data
+    print("\n--- Test: Minimal data ---")
+    data = {"name": "John Doe"}
+    result = validate_to_dict(data, schema_str)
+    print(f"Input:  {data}")
+    print(f"Output: {result}")
+
+
+def main():
+    """Run all demos"""
+    print("\n" + "="*60)
+    print("  String Schema: Defaults and Descriptions Demo")
+    print("="*60)
+    
+    demo_default_values()
+    demo_descriptions()
+    demo_combined_syntax()
+    demo_worker_parameters()
+    demo_null_defaults()
+    
+    print("\n" + "="*60)
+    print("  Demo Complete!")
+    print("="*60 + "\n")
+
+
+if __name__ == "__main__":
+    main()
+

{string_schema-0.1.5 → string_schema-0.1.7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "string-schema"
-version = "0.1.5"
+version = "0.1.7"
 description = "A simple, LLM-friendly schema definition library for converting string syntax to structured schemas"
 readme = "README.md"
 license = "MIT"

{string_schema-0.1.5 → string_schema-0.1.7}/setup.py

@@ -9,7 +9,7 @@ with open("README.md", "r", encoding="utf-8") as fh:
 
 setup(
     name="string-schema",
-    version="0.1.5",
+    version="0.1.7",
     author="Michael Chen",
     author_email="xychen@msn.com",
     description="A simple, LLM-friendly schema definition library for converting string syntax to structured schemas",

{string_schema-0.1.5 → string_schema-0.1.7}/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-0.1.5 → string_schema-0.1.7}/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-0.1.5 → string_schema-0.1.7}/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-0.1.5 → string_schema-0.1.7}/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-0.1.5 → string_schema-0.1.7}/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-0.1.5 → string_schema-0.1.7}/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 → string_schema-0.1.7/string_schema.egg-info}/PKG-INFO

@@ -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 → string_schema-0.1.7}/string_schema.egg-info/SOURCES.txt

@@ -31,6 +31,7 @@ docs/getting-started.md
 docs/pydantic-utilities.md
 docs/string-syntax.md
 docs/troubleshooting.md
+examples/defaults_descriptions_demo.py
 examples/demo.py
 examples/pydantic_utility_demo.py
 string_schema/__init__.py