string-schema 0.1.1__py3-none-any.whl → 0.1.3__py3-none-any.whl

string_schema/core/__init__.py

@@ -0,0 +1,23 @@
+"""
+Core module for String Schema
+
+Contains the fundamental classes and functions for schema definition and building.
+"""
+
+from .fields import SimpleField
+from .builders import (
+    simple_schema,
+    list_of_objects_schema,
+    simple_array_schema,
+    quick_pydantic_model
+)
+from .validators import validate_schema
+
+__all__ = [
+    "SimpleField",
+    "simple_schema",
+    "list_of_objects_schema",
+    "simple_array_schema", 
+    "quick_pydantic_model",
+    "validate_schema"
+]

string_schema/core/builders.py

@@ -0,0 +1,244 @@
+"""
+Schema builders for Simple Schema
+
+Contains functions for building schemas from SimpleField definitions.
+"""
+
+from typing import Any, Dict, List, Optional, Union, Type
+import logging
+
+from .fields import SimpleField
+
+# Optional pydantic import
+try:
+    from pydantic import BaseModel, Field, create_model
+    HAS_PYDANTIC = True
+except ImportError:
+    HAS_PYDANTIC = False
+    BaseModel = None
+    Field = None
+    create_model = None
+
+logger = logging.getLogger(__name__)
+
+
+def simple_schema(fields: Dict[str, Union[str, SimpleField]]) -> Dict[str, Any]:
+    """Generate JSON Schema from simple field definitions with enhanced support"""
+    properties = {}
+    required = []
+    
+    for field_name, field_def in fields.items():
+        if isinstance(field_def, str):
+            field_def = SimpleField(field_def)
+        
+        prop_schema = _simple_field_to_json_schema(field_def)
+        properties[field_name] = prop_schema
+        
+        if field_def.required:
+            required.append(field_name)
+    
+    schema = {
+        "type": "object",
+        "properties": properties
+    }
+    if required:
+        schema["required"] = required
+    
+    return schema
+
+
+def _simple_field_to_json_schema(field: SimpleField) -> Dict[str, Any]:
+    """Convert SimpleField to JSON Schema property with enhanced features"""
+    # Handle union types first
+    if field.union_types and len(field.union_types) > 1:
+        union_schemas = []
+        for union_type in field.union_types:
+            if union_type == "null":
+                union_schemas.append({"type": "null"})
+            else:
+                union_schemas.append({"type": union_type})
+        prop = {"anyOf": union_schemas}
+        
+        # Add description to the union
+        if field.description:
+            prop["description"] = field.description
+        
+        return prop
+    
+    # Regular single type
+    prop = {"type": field.field_type}
+    
+    if field.description:
+        prop["description"] = field.description
+    if field.default is not None:
+        prop["default"] = field.default
+    
+    # Handle enum/choices
+    if field.choices:
+        prop["enum"] = field.choices
+    
+    # Add format hints for special types
+    if field.format_hint:
+        if field.format_hint == "email":
+            prop["format"] = "email"
+        elif field.format_hint in ["url", "uri"]:
+            prop["format"] = "uri"
+        elif field.format_hint == "datetime":
+            prop["format"] = "date-time"
+        elif field.format_hint == "date":
+            prop["format"] = "date"
+        elif field.format_hint == "uuid":
+            prop["format"] = "uuid"
+        # Note: phone doesn't have a standard JSON Schema format
+    
+    # Numeric constraints
+    if field.field_type in ["integer", "number"]:
+        if field.min_val is not None:
+            prop["minimum"] = field.min_val
+        if field.max_val is not None:
+            prop["maximum"] = field.max_val
+    
+    # String constraints
+    if field.field_type == "string":
+        if field.min_length is not None:
+            prop["minLength"] = field.min_length
+        if field.max_length is not None:
+            prop["maxLength"] = field.max_length
+    
+    # Array constraints (for when this field itself is an array)
+    if field.min_items is not None:
+        prop["minItems"] = field.min_items
+    if field.max_items is not None:
+        prop["maxItems"] = field.max_items
+    
+    return prop
+
+
+def list_of_objects_schema(item_fields: Dict[str, Union[str, SimpleField]],
+                          description: str = "List of objects",
+                          min_items: Optional[int] = None,
+                          max_items: Optional[int] = None) -> Dict[str, Any]:
+    """Generate schema for array of objects with enhanced constraints"""
+    item_schema = simple_schema(item_fields)
+    
+    array_schema = {
+        "type": "array",
+        "description": description,
+        "items": item_schema
+    }
+    
+    # Add array size constraints
+    if min_items is not None:
+        array_schema["minItems"] = min_items
+    if max_items is not None:
+        array_schema["maxItems"] = max_items
+    
+    return array_schema
+
+
+def simple_array_schema(item_type: str = 'string', description: str = 'Array of items',
+                       min_items: Optional[int] = None, max_items: Optional[int] = None,
+                       format_hint: Optional[str] = None) -> Dict[str, Any]:
+    """Generate schema for simple arrays like [string], [int], [email]"""
+    items_schema = {"type": item_type}
+    
+    # Add format for special types
+    if format_hint:
+        if format_hint == "email":
+            items_schema["format"] = "email"
+        elif format_hint in ["url", "uri"]:
+            items_schema["format"] = "uri"
+        elif format_hint == "datetime":
+            items_schema["format"] = "date-time"
+        elif format_hint == "date":
+            items_schema["format"] = "date"
+        elif format_hint == "uuid":
+            items_schema["format"] = "uuid"
+    
+    array_schema = {
+        "type": "array",
+        "description": description,
+        "items": items_schema
+    }
+    
+    # Add array size constraints
+    if min_items is not None:
+        array_schema["minItems"] = min_items
+    if max_items is not None:
+        array_schema["maxItems"] = max_items
+    
+    return array_schema
+
+
+def quick_pydantic_model(name: str, fields: Dict[str, Union[str, SimpleField]]) -> Type:
+    """Create Pydantic model from simple field definitions"""
+    if not HAS_PYDANTIC:
+        raise ImportError("Pydantic is required for quick_pydantic_model. Install with: pip install pydantic")
+
+    pydantic_fields = {}
+
+    for field_name, field_def in fields.items():
+        if isinstance(field_def, str):
+            field_def = SimpleField(field_def)
+
+        from ..integrations.pydantic import _simple_field_to_pydantic
+        python_type, field_info = _simple_field_to_pydantic(field_def)
+        pydantic_fields[field_name] = (python_type, field_info)
+
+    return create_model(name, **pydantic_fields)
+
+
+def _simple_field_to_pydantic(field: SimpleField) -> tuple:
+    """Convert SimpleField to Pydantic field specification"""
+    if not HAS_PYDANTIC:
+        raise ImportError("Pydantic is required for this function")
+
+    # Type mapping
+    type_mapping = {
+        'string': str,
+        'integer': int,
+        'number': float,
+        'boolean': bool
+    }
+
+    python_type = type_mapping.get(field.field_type, str)
+
+    # Handle union types
+    if field.union_types and len(field.union_types) > 1:
+        from typing import Union as TypingUnion
+        union_python_types = []
+        for union_type in field.union_types:
+            if union_type == "null":
+                union_python_types.append(type(None))
+            else:
+                union_python_types.append(type_mapping.get(union_type, str))
+        python_type = TypingUnion[tuple(union_python_types)]
+
+    # Handle optional fields
+    if not field.required:
+        python_type = Optional[python_type]
+
+    # Build Field arguments
+    field_kwargs = {}
+
+    if field.description:
+        field_kwargs['description'] = field.description
+
+    if field.default is not None:
+        field_kwargs['default'] = field.default
+    elif not field.required:
+        field_kwargs['default'] = None
+
+    # Numeric constraints
+    if field.min_val is not None:
+        field_kwargs['ge'] = field.min_val
+    if field.max_val is not None:
+        field_kwargs['le'] = field.max_val
+
+    # String constraints
+    if field.min_length is not None:
+        field_kwargs['min_length'] = field.min_length
+    if field.max_length is not None:
+        field_kwargs['max_length'] = field.max_length
+
+    return python_type, Field(**field_kwargs) if field_kwargs else Field()

string_schema/core/fields.py

@@ -0,0 +1,138 @@
+"""
+Core field definitions for Simple Schema
+
+Contains the SimpleField class and related field utilities.
+"""
+
+from typing import Any, List, Optional, Union
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+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,
+                 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
+            min_val: Minimum value for numeric types
+            max_val: Maximum value for numeric types
+            min_length: Minimum length for string types
+            max_length: Maximum length for string types
+            choices: List of allowed values (enum)
+            min_items: Minimum items for array types
+            max_items: Maximum items for array types
+            format_hint: Special format hint (email, url, datetime, etc.)
+            union_types: List of types for union fields
+        """
+        self.field_type = field_type
+        self.description = description
+        self.required = required
+        self.default = default
+        self.min_val = min_val
+        self.max_val = max_val
+        self.min_length = min_length
+        self.max_length = max_length
+        self.choices = choices
+        self.min_items = min_items
+        self.max_items = max_items
+        self.format_hint = format_hint
+        self.union_types = union_types or []
+    
+    def __repr__(self):
+        """String representation of the field"""
+        parts = [f"type={self.field_type}"]
+        if self.description:
+            parts.append(f"desc='{self.description}'")
+        if not self.required:
+            parts.append("optional")
+        if self.choices:
+            parts.append(f"choices={self.choices}")
+        if self.union_types:
+            parts.append(f"union={self.union_types}")
+        return f"SimpleField({', '.join(parts)})"
+    
+    def to_dict(self) -> dict:
+        """Convert field to dictionary representation"""
+        result = {
+            'type': self.field_type,
+            'required': self.required
+        }
+        
+        if self.description:
+            result['description'] = self.description
+        if self.default is not None:
+            result['default'] = self.default
+        if self.min_val is not None:
+            result['min_val'] = self.min_val
+        if self.max_val is not None:
+            result['max_val'] = self.max_val
+        if self.min_length is not None:
+            result['min_length'] = self.min_length
+        if self.max_length is not None:
+            result['max_length'] = self.max_length
+        if self.choices:
+            result['choices'] = self.choices
+        if self.min_items is not None:
+            result['min_items'] = self.min_items
+        if self.max_items is not None:
+            result['max_items'] = self.max_items
+        if self.format_hint:
+            result['format_hint'] = self.format_hint
+        if self.union_types:
+            result['union_types'] = self.union_types
+            
+        return result
+    
+    @classmethod
+    def from_dict(cls, data: dict) -> 'SimpleField':
+        """Create SimpleField from dictionary representation"""
+        return cls(
+            field_type=data['type'],
+            description=data.get('description', ''),
+            required=data.get('required', True),
+            default=data.get('default'),
+            min_val=data.get('min_val'),
+            max_val=data.get('max_val'),
+            min_length=data.get('min_length'),
+            max_length=data.get('max_length'),
+            choices=data.get('choices'),
+            min_items=data.get('min_items'),
+            max_items=data.get('max_items'),
+            format_hint=data.get('format_hint'),
+            union_types=data.get('union_types')
+        )
+
+
+# Utility functions for creating common field types
+def create_enhanced_field(field_type: str, **kwargs) -> SimpleField:
+    """Create enhanced SimpleField with all features"""
+    return SimpleField(field_type, **kwargs)
+
+
+def create_special_type_field(special_type: str, required: bool = True, **kwargs) -> SimpleField:
+    """Create field with special type hints"""
+    return SimpleField('string', format_hint=special_type, required=required, **kwargs)
+
+
+def create_enum_field(values: List[str], required: bool = True, **kwargs) -> SimpleField:
+    """Create enum field with specific values"""
+    return SimpleField('string', choices=values, required=required, **kwargs)
+
+
+def create_union_field(types: List[str], required: bool = True, **kwargs) -> SimpleField:
+    """Create union field with multiple types"""
+    primary_type = types[0] if types else 'string'
+    return SimpleField(primary_type, union_types=types, required=required, **kwargs)

string_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

string_schema/examples/__init__.py

@@ -0,0 +1,36 @@
+"""
+Examples module for String 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"
+]