string-schema 0.1.0__py3-none-any.whl

simple_schema/core/validators.py

@@ -0,0 +1,242 @@
+"""
+Validation utilities for Simple Schema
+
+Contains functions for validating schemas and field definitions.
+"""
+
+from typing import Any, Dict, List, Union
+import logging
+
+from .fields import SimpleField
+
+logger = logging.getLogger(__name__)
+
+
+def validate_schema(schema: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Validate a JSON schema generated by Simple Schema.
+    
+    Args:
+        schema: The JSON schema to validate
+        
+    Returns:
+        Dictionary with validation results including:
+        - valid: Boolean indicating if schema is valid
+        - errors: List of error messages
+        - warnings: List of warning messages
+        - field_count: Number of fields in the schema
+    """
+    result = {
+        'valid': True,
+        'errors': [],
+        'warnings': [],
+        'field_count': 0,
+        'features_used': []
+    }
+    
+    try:
+        # Basic schema structure validation
+        if not isinstance(schema, dict):
+            result['errors'].append("Schema must be a dictionary")
+            result['valid'] = False
+            return result
+        
+        if 'type' not in schema:
+            result['errors'].append("Schema must have a 'type' field")
+            result['valid'] = False
+            return result
+        
+        schema_type = schema['type']
+        
+        if schema_type == 'object':
+            result.update(_validate_object_schema(schema))
+        elif schema_type == 'array':
+            result.update(_validate_array_schema(schema))
+        else:
+            result['warnings'].append(f"Unusual schema type: {schema_type}")
+        
+        # Check for potential issues
+        if result['field_count'] > 20:
+            result['warnings'].append("Schema has many fields (>20), consider simplifying")
+        
+        if result['field_count'] == 0:
+            result['warnings'].append("Schema has no fields defined")
+            
+    except Exception as e:
+        result['errors'].append(f"Validation error: {str(e)}")
+        result['valid'] = False
+    
+    # Set overall validity
+    result['valid'] = len(result['errors']) == 0
+    
+    return result
+
+
+def _validate_object_schema(schema: Dict[str, Any]) -> Dict[str, Any]:
+    """Validate object-type schema"""
+    result = {
+        'field_count': 0,
+        'features_used': [],
+        'errors': [],
+        'warnings': []
+    }
+    
+    properties = schema.get('properties', {})
+    required = schema.get('required', [])
+    
+    result['field_count'] = len(properties)
+    
+    # Validate each property
+    for field_name, field_schema in properties.items():
+        field_result = _validate_field_schema(field_name, field_schema)
+        result['errors'].extend(field_result['errors'])
+        result['warnings'].extend(field_result['warnings'])
+        result['features_used'].extend(field_result['features_used'])
+    
+    # Validate required fields
+    for req_field in required:
+        if req_field not in properties:
+            result['errors'].append(f"Required field '{req_field}' not found in properties")
+    
+    # Remove duplicate features
+    result['features_used'] = list(set(result['features_used']))
+    
+    return result
+
+
+def _validate_array_schema(schema: Dict[str, Any]) -> Dict[str, Any]:
+    """Validate array-type schema"""
+    result = {
+        'field_count': 0,
+        'features_used': ['arrays'],
+        'errors': [],
+        'warnings': []
+    }
+    
+    items = schema.get('items', {})
+    
+    if not items:
+        result['errors'].append("Array schema must have 'items' definition")
+        return result
+    
+    # Validate array constraints
+    if 'minItems' in schema:
+        result['features_used'].append('array_constraints')
+    if 'maxItems' in schema:
+        result['features_used'].append('array_constraints')
+    
+    # Validate items schema
+    if items.get('type') == 'object':
+        items_result = _validate_object_schema(items)
+        result['field_count'] = items_result['field_count']
+        result['errors'].extend(items_result['errors'])
+        result['warnings'].extend(items_result['warnings'])
+        result['features_used'].extend(items_result['features_used'])
+    else:
+        # Simple array items
+        field_result = _validate_field_schema('array_item', items)
+        result['errors'].extend(field_result['errors'])
+        result['warnings'].extend(field_result['warnings'])
+        result['features_used'].extend(field_result['features_used'])
+    
+    return result
+
+
+def _validate_field_schema(field_name: str, field_schema: Dict[str, Any]) -> Dict[str, Any]:
+    """Validate individual field schema"""
+    result = {
+        'features_used': [],
+        'errors': [],
+        'warnings': []
+    }
+    
+    # Check for union types
+    if 'anyOf' in field_schema:
+        result['features_used'].append('union_types')
+        # Validate each union option
+        for i, union_option in enumerate(field_schema['anyOf']):
+            if 'type' not in union_option:
+                result['errors'].append(f"Union option {i} in field '{field_name}' missing type")
+    
+    # Check for enum
+    if 'enum' in field_schema:
+        result['features_used'].append('enums')
+        enum_values = field_schema['enum']
+        if not isinstance(enum_values, list) or len(enum_values) == 0:
+            result['errors'].append(f"Field '{field_name}' enum must be non-empty list")
+    
+    # Check for format hints
+    if 'format' in field_schema:
+        result['features_used'].append('special_types')
+        format_value = field_schema['format']
+        valid_formats = ['email', 'uri', 'date-time', 'date', 'uuid']
+        if format_value not in valid_formats:
+            result['warnings'].append(f"Field '{field_name}' uses non-standard format: {format_value}")
+    
+    # Check for constraints
+    constraint_fields = ['minimum', 'maximum', 'minLength', 'maxLength', 'minItems', 'maxItems']
+    if any(field in field_schema for field in constraint_fields):
+        result['features_used'].append('constraints')
+    
+    # Validate constraint values
+    if 'minimum' in field_schema and 'maximum' in field_schema:
+        if field_schema['minimum'] > field_schema['maximum']:
+            result['errors'].append(f"Field '{field_name}' minimum > maximum")
+    
+    if 'minLength' in field_schema and 'maxLength' in field_schema:
+        if field_schema['minLength'] > field_schema['maxLength']:
+            result['errors'].append(f"Field '{field_name}' minLength > maxLength")
+    
+    if 'minItems' in field_schema and 'maxItems' in field_schema:
+        if field_schema['minItems'] > field_schema['maxItems']:
+            result['errors'].append(f"Field '{field_name}' minItems > maxItems")
+    
+    return result
+
+
+def validate_simple_field(field: SimpleField) -> Dict[str, Any]:
+    """
+    Validate a SimpleField instance.
+    
+    Args:
+        field: The SimpleField to validate
+        
+    Returns:
+        Dictionary with validation results
+    """
+    result = {
+        'valid': True,
+        'errors': [],
+        'warnings': []
+    }
+    
+    # Validate field type
+    valid_types = ['string', 'integer', 'number', 'boolean']
+    if field.field_type not in valid_types:
+        result['warnings'].append(f"Unusual field type: {field.field_type}")
+    
+    # Validate constraints
+    if field.min_val is not None and field.max_val is not None:
+        if field.min_val > field.max_val:
+            result['errors'].append("min_val cannot be greater than max_val")
+    
+    if field.min_length is not None and field.max_length is not None:
+        if field.min_length > field.max_length:
+            result['errors'].append("min_length cannot be greater than max_length")
+    
+    if field.min_items is not None and field.max_items is not None:
+        if field.min_items > field.max_items:
+            result['errors'].append("min_items cannot be greater than max_items")
+    
+    # Validate choices
+    if field.choices and len(field.choices) == 0:
+        result['errors'].append("choices list cannot be empty")
+    
+    # Validate union types
+    if field.union_types and len(field.union_types) < 2:
+        result['warnings'].append("union_types should have at least 2 types")
+    
+    # Set overall validity
+    result['valid'] = len(result['errors']) == 0
+    
+    return result

simple_schema/examples/__init__.py

@@ -0,0 +1,36 @@
+"""
+Examples module for Simple Schema
+
+Contains built-in schema presets and common patterns.
+"""
+
+from .presets import (
+    user_schema,
+    product_schema,
+    contact_schema,
+    article_schema,
+    event_schema,
+    get_examples
+)
+from .recipes import (
+    create_list_schema,
+    create_nested_schema,
+    create_enum_schema,
+    create_union_schema
+)
+
+__all__ = [
+    # Presets
+    "user_schema",
+    "product_schema", 
+    "contact_schema",
+    "article_schema",
+    "event_schema",
+    "get_examples",
+    
+    # Recipes
+    "create_list_schema",
+    "create_nested_schema",
+    "create_enum_schema", 
+    "create_union_schema"
+]

simple_schema/examples/presets.py

@@ -0,0 +1,345 @@
+"""
+Built-in schema presets for Simple Schema
+
+Contains commonly used schema definitions for typical data structures.
+"""
+
+from typing import Any, Dict, List, Optional, Union
+import logging
+
+from ..core.fields import SimpleField
+from ..core.builders import simple_schema, list_of_objects_schema
+
+logger = logging.getLogger(__name__)
+
+
+def user_schema(include_email: bool = True, include_phone: bool = False, 
+               include_profile: bool = False, include_preferences: bool = False) -> Dict[str, Any]:
+    """Generate enhanced user schema with special types"""
+    fields = {
+        'name': SimpleField('string', 'Full name', min_length=1, max_length=100),
+        'age': SimpleField('integer', 'Age in years', min_val=13, max_val=120, required=False)
+    }
+    
+    if include_email:
+        fields['email'] = SimpleField('string', 'Email address', format_hint='email')
+    
+    if include_phone:
+        fields['phone'] = SimpleField('string', 'Phone number', format_hint='phone', required=False)
+    
+    if include_profile:
+        fields['bio'] = SimpleField('string', 'Biography', max_length=500, required=False)
+        fields['avatar'] = SimpleField('string', 'Avatar URL', format_hint='url', required=False)
+    
+    if include_preferences:
+        fields['theme'] = SimpleField('string', 'UI theme', choices=['light', 'dark'], required=False)
+        fields['notifications'] = SimpleField('boolean', 'Email notifications enabled', required=False)
+    
+    return simple_schema(fields)
+
+
+def product_schema(include_price: bool = True, include_description: bool = True,
+                  include_images: bool = False, include_reviews: bool = False) -> Dict[str, Any]:
+    """Generate enhanced product schema"""
+    fields = {
+        'name': SimpleField('string', 'Product name', min_length=1, max_length=200),
+        'category': SimpleField('string', 'Product category', 
+                               choices=['electronics', 'clothing', 'books', 'home', 'sports'])
+    }
+    
+    if include_price:
+        fields['price'] = SimpleField('number', 'Price', min_val=0)
+    
+    if include_description:
+        fields['description'] = SimpleField('string', 'Product description', 
+                                          max_length=1000, required=False)
+    
+    if include_images:
+        # This would need to be handled as a nested array, which is complex
+        # For now, we'll represent it as a simple field
+        fields['image_urls'] = SimpleField('string', 'Comma-separated image URLs', required=False)
+    
+    if include_reviews:
+        # Similarly, this would be a complex nested structure
+        fields['avg_rating'] = SimpleField('number', 'Average rating', min_val=1.0, max_val=5.0, required=False)
+        fields['review_count'] = SimpleField('integer', 'Number of reviews', min_val=0, required=False)
+    
+    return simple_schema(fields)
+
+
+def contact_schema(include_company: bool = False, include_address: bool = False,
+                  include_social: bool = False) -> Dict[str, Any]:
+    """Generate enhanced contact schema"""
+    fields = {
+        'name': SimpleField('string', 'Contact name', min_length=1, max_length=100),
+        'email': SimpleField('string', 'Email address', format_hint='email'),
+        'phone': SimpleField('string', 'Phone number', format_hint='phone', required=False)
+    }
+    
+    if include_company:
+        fields['company'] = SimpleField('string', 'Company name', max_length=200, required=False)
+        fields['job_title'] = SimpleField('string', 'Job title', max_length=100, required=False)
+    
+    if include_address:
+        fields['address'] = SimpleField('string', 'Full address', max_length=500, required=False)
+        fields['city'] = SimpleField('string', 'City', max_length=100, required=False)
+        fields['country'] = SimpleField('string', 'Country', max_length=100, required=False)
+    
+    if include_social:
+        fields['linkedin'] = SimpleField('string', 'LinkedIn URL', format_hint='url', required=False)
+        fields['twitter'] = SimpleField('string', 'Twitter URL', format_hint='url', required=False)
+        fields['website'] = SimpleField('string', 'Personal website', format_hint='url', required=False)
+    
+    return simple_schema(fields)
+
+
+def article_schema(include_summary: bool = True, include_tags: bool = False,
+                  include_metadata: bool = False) -> Dict[str, Any]:
+    """Generate enhanced article schema"""
+    fields = {
+        'title': SimpleField('string', 'Article title', min_length=1, max_length=200),
+        'content': SimpleField('string', 'Article content', min_length=10)
+    }
+    
+    if include_summary:
+        fields['summary'] = SimpleField('string', 'Brief summary', max_length=500, required=False)
+    
+    if include_tags:
+        # Represented as comma-separated for simplicity
+        fields['tags'] = SimpleField('string', 'Comma-separated tags', max_length=200, required=False)
+    
+    if include_metadata:
+        fields['author'] = SimpleField('string', 'Author name', max_length=100, required=False)
+        fields['published_date'] = SimpleField('string', 'Publication date', format_hint='date', required=False)
+        fields['word_count'] = SimpleField('integer', 'Word count', min_val=0, required=False)
+    
+    return simple_schema(fields)
+
+
+def event_schema(include_location: bool = True, include_attendees: bool = False) -> Dict[str, Any]:
+    """Generate enhanced event schema"""
+    fields = {
+        'title': SimpleField('string', 'Event title', min_length=1, max_length=200),
+        'date': SimpleField('string', 'Event date', format_hint='datetime'),
+        'status': SimpleField('string', 'Event status', 
+                             choices=['planned', 'active', 'completed', 'cancelled'])
+    }
+    
+    if include_location:
+        fields['venue'] = SimpleField('string', 'Venue name', max_length=200, required=False)
+        fields['address'] = SimpleField('string', 'Event address', max_length=500, required=False)
+        fields['is_online'] = SimpleField('boolean', 'Is online event', required=False)
+        fields['meeting_url'] = SimpleField('string', 'Meeting URL', format_hint='url', required=False)
+    
+    if include_attendees:
+        fields['max_attendees'] = SimpleField('integer', 'Maximum attendees', min_val=1, required=False)
+        fields['current_attendees'] = SimpleField('integer', 'Current attendee count', min_val=0, required=False)
+    
+    return simple_schema(fields)
+
+
+# List versions of schemas
+def user_list_schema(**kwargs) -> Dict[str, Any]:
+    """Generate schema for array of users"""
+    user_fields = {}
+    user_base = user_schema(**kwargs)
+    
+    # Convert properties to SimpleField definitions
+    for field_name, field_schema in user_base['properties'].items():
+        field_type = field_schema['type']
+        required = field_name in user_base.get('required', [])
+        
+        simple_field = SimpleField(field_type, required=required)
+        
+        # Copy constraints
+        if 'minimum' in field_schema:
+            simple_field.min_val = field_schema['minimum']
+        if 'maximum' in field_schema:
+            simple_field.max_val = field_schema['maximum']
+        if 'minLength' in field_schema:
+            simple_field.min_length = field_schema['minLength']
+        if 'maxLength' in field_schema:
+            simple_field.max_length = field_schema['maxLength']
+        if 'enum' in field_schema:
+            simple_field.choices = field_schema['enum']
+        if 'format' in field_schema:
+            simple_field.format_hint = field_schema['format']
+        
+        user_fields[field_name] = simple_field
+    
+    return list_of_objects_schema(user_fields, "List of users")
+
+
+def product_list_schema(**kwargs) -> Dict[str, Any]:
+    """Generate schema for array of products"""
+    return _convert_object_to_list_schema(product_schema(**kwargs), "List of products")
+
+
+def contact_list_schema(**kwargs) -> Dict[str, Any]:
+    """Generate schema for array of contacts"""
+    return _convert_object_to_list_schema(contact_schema(**kwargs), "List of contacts")
+
+
+def article_list_schema(**kwargs) -> Dict[str, Any]:
+    """Generate schema for array of articles"""
+    return _convert_object_to_list_schema(article_schema(**kwargs), "List of articles")
+
+
+def event_list_schema(**kwargs) -> Dict[str, Any]:
+    """Generate schema for array of events"""
+    return _convert_object_to_list_schema(event_schema(**kwargs), "List of events")
+
+
+def _convert_object_to_list_schema(object_schema: Dict[str, Any], description: str) -> Dict[str, Any]:
+    """Helper function to convert object schema to list schema"""
+    fields = {}
+    
+    # Convert properties to SimpleField definitions
+    for field_name, field_schema in object_schema['properties'].items():
+        field_type = field_schema['type']
+        required = field_name in object_schema.get('required', [])
+        
+        simple_field = SimpleField(field_type, required=required)
+        
+        # Copy constraints
+        if 'minimum' in field_schema:
+            simple_field.min_val = field_schema['minimum']
+        if 'maximum' in field_schema:
+            simple_field.max_val = field_schema['maximum']
+        if 'minLength' in field_schema:
+            simple_field.min_length = field_schema['minLength']
+        if 'maxLength' in field_schema:
+            simple_field.max_length = field_schema['maxLength']
+        if 'enum' in field_schema:
+            simple_field.choices = field_schema['enum']
+        if 'format' in field_schema:
+            simple_field.format_hint = field_schema['format']
+        if 'description' in field_schema:
+            simple_field.description = field_schema['description']
+        
+        fields[field_name] = simple_field
+    
+    return list_of_objects_schema(fields, description)
+
+
+# Enhanced utility schemas
+def simple_list_schema(item_type: str = 'string', description: str = 'List of items',
+                      min_items: Optional[int] = None, max_items: Optional[int] = None) -> Dict[str, Any]:
+    """Generate schema for simple arrays with enhanced constraints"""
+    from ..core.builders import simple_array_schema
+    return simple_array_schema(item_type, description, min_items, max_items)
+
+
+def key_value_schema(description: str = 'Key-value pairs') -> Dict[str, Any]:
+    """Generate schema for flexible key-value objects"""
+    return {
+        "type": "object",
+        "description": description,
+        "additionalProperties": {"type": "string"}
+    }
+
+
+def enum_schema(field_name: str, values: List[str], description: str = "") -> Dict[str, Any]:
+    """Generate schema for a single enum field"""
+    fields = {
+        field_name: SimpleField('string', description, choices=values)
+    }
+    return simple_schema(fields)
+
+
+def union_schema(field_name: str, types: List[str], description: str = "") -> Dict[str, Any]:
+    """Generate schema for a single union field"""
+    fields = {
+        field_name: SimpleField('string', description, union_types=types)
+    }
+    return simple_schema(fields)
+
+
+# Enhanced examples with all new features
+ENHANCED_EXAMPLES = {
+    "simple_user": {
+        "description": "Basic user information with special types",
+        "schema": user_schema(include_email=True, include_phone=True),
+        "prompt_example": "Extract user: John Doe, 25 years old, john@example.com, phone +1-555-0123"
+    },
+    
+    "product_with_enum": {
+        "description": "Product with category enum",
+        "schema": product_schema(include_price=True, include_description=True),
+        "prompt_example": "Product: iPhone 14, $999, Electronics category, Latest smartphone with advanced features"
+    },
+    
+    "contact_with_social": {
+        "description": "Contact with social media links",
+        "schema": contact_schema(include_company=True, include_social=True),
+        "prompt_example": "Contact: Jane Smith, jane@company.org, works at TechCorp as Developer, LinkedIn: linkedin.com/in/janesmith"
+    },
+    
+    "simple_string_array": {
+        "description": "Simple array of strings (FIXED!)",
+        "schema": simple_list_schema('string', 'List of tags', max_items=5),
+        "prompt_example": "Tags: python, javascript, react, machine-learning, AI"
+    },
+    
+    "email_array": {
+        "description": "Array of email addresses",
+        "schema": simple_list_schema('string', 'List of emails', min_items=1, max_items=3),
+        "prompt_example": "Emails: john@example.com, jane@company.org, admin@website.com"
+    },
+    
+    "user_list": {
+        "description": "List of user objects",
+        "schema": user_list_schema(include_email=True),
+        "prompt_example": "Users: John Doe (25, john@example.com), Jane Smith (30, jane@company.org)"
+    },
+    
+    "enum_status": {
+        "description": "Simple enum field",
+        "schema": enum_schema('status', ['active', 'inactive', 'pending'], 'User status'),
+        "prompt_example": "Status: active"
+    },
+    
+    "union_id": {
+        "description": "Union type field",
+        "schema": union_schema('id', ['string', 'integer'], 'Flexible ID field'),
+        "prompt_example": "ID: abc123 or ID: 12345"
+    }
+}
+
+
+def get_examples() -> Dict[str, Dict[str, Any]]:
+    """Get all enhanced simple schema examples"""
+    return ENHANCED_EXAMPLES.copy()
+
+
+def print_examples():
+    """Print all enhanced simple schema examples"""
+    print("🔧 Enhanced Simple Schema Examples:")
+    print("=" * 60)
+    
+    for name, example in ENHANCED_EXAMPLES.items():
+        print(f"\n📋 {name.upper().replace('_', ' ')}")
+        print(f"Description: {example['description']}")
+        print(f"Prompt: {example['prompt_example']}")
+        print(f"Schema Preview: {_schema_preview(example['schema'])}")
+        print("-" * 40)
+
+
+def _schema_preview(schema: Dict[str, Any]) -> str:
+    """Generate a preview of the schema structure"""
+    if schema.get('type') == 'object':
+        properties = schema.get('properties', {})
+        field_names = list(properties.keys())
+        if len(field_names) <= 3:
+            return f"Object with fields: {', '.join(field_names)}"
+        else:
+            return f"Object with {len(field_names)} fields: {', '.join(field_names[:3])}..."
+    elif schema.get('type') == 'array':
+        items = schema.get('items', {})
+        if items.get('type') == 'object':
+            item_fields = list(items.get('properties', {}).keys())
+            return f"Array of objects with fields: {', '.join(item_fields[:3])}"
+        else:
+            return f"Array of {items.get('type', 'items')}"
+    else:
+        return f"{schema.get('type', 'unknown')} type"