string-schema 0.1.0__py3-none-any.whl

simple_schema/__init__.py

@@ -0,0 +1,108 @@
+"""
+Simple Schema - A simple, LLM-friendly schema definition library
+
+This library provides an intuitive way to define data schemas using simple syntax
+that works well with Large Language Models for data extraction and validation.
+
+Key Features:
+- Clear, descriptive function names that tell you exactly what they do
+- Direct conversion paths: string → JSON Schema, Pydantic, OpenAPI
+- String-based schema syntax parsing
+- JSON Schema generation
+- Pydantic model integration
+- Built-in validation and optimization
+"""
+
+# Main conversion functions (clear names)
+from .parsing.string_parser import (
+    string_to_json_schema,
+    validate_string_syntax,
+    # Legacy names for backward compatibility
+    parse_string_schema,
+    validate_string_schema
+)
+
+# 🎯 Core Pydantic Utility Functions
+from .utilities import (
+    string_to_model,        # String → Pydantic model (main utility)
+    validate_to_dict,       # Validate data → dict
+    validate_to_model,      # Validate data → Pydantic model
+    returns_dict,           # Decorator for dict validation
+    returns_model,          # Decorator for model validation
+    get_model_info,         # Model introspection utility
+    validate_schema_compatibility,  # Schema compatibility checker
+    # Legacy alias for backward compatibility
+    create_model            # Use string_to_model instead
+)
+
+# Integration functions (consistent naming)
+from .integrations.pydantic import (
+    string_to_model_code,
+    json_schema_to_model,
+    model_to_string,
+    model_to_json_schema,
+    # Legacy names for backward compatibility
+    string_to_pydantic,
+    string_to_pydantic_code,
+    json_schema_to_pydantic,
+    create_pydantic_from_json_schema
+)
+
+from .integrations.openapi import (
+    string_to_openapi,
+    openapi_to_string,
+    openapi_to_json_schema
+)
+
+from .integrations.json_schema import (
+    json_schema_to_openapi,
+    json_schema_to_string,
+    # Legacy names for backward compatibility
+    convert_to_openapi_schema
+)
+
+# Note: Built-in presets moved to examples/ directory
+# Import them from simple_schema.examples.presets if needed
+
+__version__ = "0.1.0"
+__author__ = "importal"
+
+__all__ = [
+    # 🎯 Forward conversion functions (source → target)
+    "string_to_json_schema",        # String → JSON Schema
+    "string_to_model",              # String → Pydantic model (main utility)
+    "string_to_model_code",         # String → Pydantic code
+    "string_to_openapi",            # String → OpenAPI schema
+    "json_schema_to_model",         # JSON Schema → Pydantic model
+    "json_schema_to_openapi",       # JSON Schema → OpenAPI schema
+    "validate_string_syntax",       # Validate string syntax
+
+    # 🔄 Reverse conversion functions (target → source)
+    "model_to_string",              # Pydantic model → String
+    "model_to_json_schema",         # Pydantic model → JSON Schema
+    "json_schema_to_string",        # JSON Schema → String
+    "openapi_to_string",            # OpenAPI schema → String
+    "openapi_to_json_schema",       # OpenAPI schema → JSON Schema
+
+    # 🔍 Data validation functions
+    "validate_to_dict",             # Validate data → dict
+    "validate_to_model",            # Validate data → Pydantic model
+
+    # 🎨 Function decorators
+    "returns_dict",                 # Decorator for dict validation
+    "returns_model",                # Decorator for model validation
+
+    # 🔧 Utility functions
+    "get_model_info",               # Model introspection utility
+    "validate_schema_compatibility", # Schema compatibility checker
+
+    # 🔙 Legacy names (for backward compatibility)
+    "create_model",                 # Use string_to_model instead
+    "string_to_pydantic",           # Use string_to_model instead
+    "string_to_pydantic_code",      # Use string_to_model_code instead
+    "json_schema_to_pydantic",      # Use json_schema_to_model instead
+    "parse_string_schema",
+    "validate_string_schema",
+    "create_pydantic_from_json_schema",
+    "convert_to_openapi_schema",
+]

simple_schema/core/__init__.py

@@ -0,0 +1,23 @@
+"""
+Core module for Simple 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"
+]

simple_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()

simple_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)