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

string_schema/integrations/reverse.py

@@ -0,0 +1,275 @@
+"""
+Reverse conversion functions for String Schema
+
+This module provides functions to convert from various schema formats back to
+String Schema string syntax, completing the conversion matrix.
+
+Conversion Matrix:
+- model_to_string()         # Pydantic model → String syntax
+- model_to_json_schema()    # Pydantic model → JSON Schema  
+- json_schema_to_string()   # JSON Schema → String syntax
+- openapi_to_string()       # OpenAPI schema → String syntax
+- openapi_to_json_schema()  # OpenAPI schema → JSON Schema
+
+Note: Some information loss is expected and acceptable when converting
+from more complex formats to simpler string syntax.
+"""
+
+from typing import Any, Dict, List, Union, Optional, Type
+import logging
+
+# Optional pydantic import
+try:
+    from pydantic import BaseModel
+    HAS_PYDANTIC = True
+except ImportError:
+    HAS_PYDANTIC = False
+    BaseModel = None
+
+logger = logging.getLogger(__name__)
+
+
+def model_to_string(model: Type[BaseModel], include_name: bool = False) -> str:
+    """
+    Convert Pydantic model to String Schema string syntax.
+
+    Args:
+        model: Pydantic model class
+        include_name: Whether to include model name in output
+
+    Returns:
+        String representation in String Schema syntax
+
+    Example:
+        UserModel = create_model("name:string, email:email, age:int?")
+        schema_str = model_to_string(UserModel)
+        # Returns: "name:string, email:email, age:int?"
+    """
+    if not HAS_PYDANTIC:
+        raise ImportError("Pydantic is required for model_to_string. Install with: pip install pydantic")
+    
+    # First convert to JSON Schema, then to string
+    json_schema = model_to_json_schema(model)
+    return json_schema_to_string(json_schema)
+
+
+def model_to_json_schema(model: Type[BaseModel]) -> Dict[str, Any]:
+    """
+    Convert Pydantic model to JSON Schema.
+    
+    Args:
+        model: Pydantic model class
+        
+    Returns:
+        JSON Schema dictionary
+        
+    Example:
+        UserModel = create_model("name:string, email:email")
+        json_schema = model_to_json_schema(UserModel)
+    """
+    if not HAS_PYDANTIC:
+        raise ImportError("Pydantic is required for model_to_json_schema. Install with: pip install pydantic")
+    
+    try:
+        # Use Pydantic's built-in JSON Schema generation
+        if hasattr(model, 'model_json_schema'):
+            # Pydantic v2
+            return model.model_json_schema()
+        elif hasattr(model, 'schema'):
+            # Pydantic v1
+            return model.schema()
+        else:
+            raise ValueError(f"Unable to extract JSON Schema from model {model}")
+    except Exception as e:
+        raise ValueError(f"Failed to convert model to JSON Schema: {str(e)}") from e
+
+
+def json_schema_to_string(json_schema: Dict[str, Any]) -> str:
+    """
+    Convert JSON Schema to String Schema string syntax.
+
+    Args:
+        json_schema: JSON Schema dictionary
+
+    Returns:
+        String representation in String Schema syntax
+
+    Example:
+        json_schema = {"type": "object", "properties": {"name": {"type": "string"}}}
+        schema_str = json_schema_to_string(json_schema)
+        # Returns: "name:string"
+    """
+    if json_schema.get('type') == 'array':
+        return _convert_array_schema_to_string(json_schema)
+    elif json_schema.get('type') == 'object':
+        return _convert_object_schema_to_string(json_schema)
+    else:
+        # Single field schema
+        return _convert_field_schema_to_string('field', json_schema)
+
+
+def openapi_to_string(openapi_schema: Dict[str, Any]) -> str:
+    """
+    Convert OpenAPI schema to String Schema string syntax.
+
+    Args:
+        openapi_schema: OpenAPI schema dictionary
+
+    Returns:
+        String representation in String Schema syntax
+
+    Example:
+        openapi_schema = {"type": "object", "properties": {"name": {"type": "string"}}}
+        schema_str = openapi_to_string(openapi_schema)
+        # Returns: "name:string"
+    """
+    # OpenAPI schemas are very similar to JSON Schema
+    # First convert to JSON Schema format, then to string
+    json_schema = openapi_to_json_schema(openapi_schema)
+    return json_schema_to_string(json_schema)
+
+
+def openapi_to_json_schema(openapi_schema: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Convert OpenAPI schema to JSON Schema.
+    
+    Args:
+        openapi_schema: OpenAPI schema dictionary
+        
+    Returns:
+        JSON Schema dictionary
+        
+    Example:
+        openapi_schema = {"type": "string", "format": "email"}
+        json_schema = openapi_to_json_schema(openapi_schema)
+    """
+    # OpenAPI 3.0 schemas are mostly compatible with JSON Schema
+    # Just need to handle some OpenAPI-specific keywords
+    json_schema = openapi_schema.copy()
+    
+    # Remove OpenAPI-specific keywords that aren't in JSON Schema
+    openapi_only_keywords = [
+        'example', 'examples', 'discriminator', 'xml', 'externalDocs'
+    ]
+    
+    for keyword in openapi_only_keywords:
+        json_schema.pop(keyword, None)
+    
+    # Handle nested properties recursively
+    if 'properties' in json_schema:
+        for prop_name, prop_schema in json_schema['properties'].items():
+            json_schema['properties'][prop_name] = openapi_to_json_schema(prop_schema)
+    
+    # Handle array items
+    if 'items' in json_schema:
+        json_schema['items'] = openapi_to_json_schema(json_schema['items'])
+    
+    return json_schema
+
+
+# Helper functions for JSON Schema to string conversion
+
+def _convert_object_schema_to_string(json_schema: Dict[str, Any]) -> str:
+    """Convert object-type JSON Schema to string syntax."""
+    properties = json_schema.get('properties', {})
+    required_fields = set(json_schema.get('required', []))
+    
+    if not properties:
+        return "{}"
+    
+    field_strings = []
+    for field_name, field_schema in properties.items():
+        field_str = _convert_field_schema_to_string(field_name, field_schema)
+        if field_name not in required_fields:
+            field_str += "?"
+        field_strings.append(field_str)
+    
+    # Check if this should be wrapped in braces (nested object)
+    if len(field_strings) > 1 or any(':' in fs for fs in field_strings):
+        return "{" + ", ".join(field_strings) + "}"
+    else:
+        return ", ".join(field_strings)
+
+
+def _convert_array_schema_to_string(json_schema: Dict[str, Any]) -> str:
+    """Convert array-type JSON Schema to string syntax."""
+    items_schema = json_schema.get('items', {})
+    
+    if items_schema.get('type') == 'object':
+        # Array of objects
+        object_str = _convert_object_schema_to_string(items_schema)
+        return f"[{object_str}]"
+    else:
+        # Array of primitives
+        item_type = _get_simple_type_from_json_schema(items_schema)
+        return f"[{item_type}]"
+
+
+def _convert_field_schema_to_string(field_name: str, field_schema: Dict[str, Any]) -> str:
+    """Convert a single field's JSON Schema to string syntax."""
+    field_type = _get_simple_type_from_json_schema(field_schema)
+    constraints = _extract_constraints_from_json_schema(field_schema)
+    
+    if constraints:
+        constraint_str = ",".join(f"{k}={v}" for k, v in constraints.items())
+        return f"{field_name}:{field_type}({constraint_str})"
+    else:
+        return f"{field_name}:{field_type}"
+
+
+def _get_simple_type_from_json_schema(field_schema: Dict[str, Any]) -> str:
+    """Extract simple type from JSON Schema field."""
+    json_type = field_schema.get('type', 'string')
+    format_hint = field_schema.get('format')
+    
+    # Handle special formats
+    if format_hint:
+        format_mapping = {
+            'email': 'email',
+            'uri': 'url', 
+            'url': 'url',
+            'date-time': 'datetime',
+            'date': 'date',
+            'uuid': 'uuid',
+            'phone': 'phone'
+        }
+        if format_hint in format_mapping:
+            return format_mapping[format_hint]
+    
+    # Handle enums
+    if 'enum' in field_schema:
+        enum_values = field_schema['enum']
+        return f"enum({','.join(str(v) for v in enum_values)})"
+    
+    # Handle basic types
+    type_mapping = {
+        'string': 'string',
+        'integer': 'int',
+        'number': 'number',
+        'boolean': 'bool'
+    }
+    
+    return type_mapping.get(json_type, 'string')
+
+
+def _extract_constraints_from_json_schema(field_schema: Dict[str, Any]) -> Dict[str, Any]:
+    """Extract constraints from JSON Schema field."""
+    constraints = {}
+    
+    # String constraints
+    if 'minLength' in field_schema:
+        constraints['min'] = field_schema['minLength']
+    if 'maxLength' in field_schema:
+        constraints['max'] = field_schema['maxLength']
+    
+    # Number constraints  
+    if 'minimum' in field_schema:
+        constraints['min'] = field_schema['minimum']
+    if 'maximum' in field_schema:
+        constraints['max'] = field_schema['maximum']
+    
+    # Pattern constraint
+    if 'pattern' in field_schema:
+        constraints['pattern'] = f"'{field_schema['pattern']}'"
+    
+    return constraints

string_schema/parsing/__init__.py

@@ -0,0 +1,16 @@
+"""
+Parsing module for String Schema
+
+Contains functionality for parsing string-based schema definitions.
+"""
+
+from .string_parser import parse_string_schema, validate_string_schema
+from .syntax import get_string_schema_examples
+from .optimizer import optimize_string_schema
+
+__all__ = [
+    "parse_string_schema",
+    "validate_string_schema", 
+    "get_string_schema_examples",
+    "optimize_string_schema"
+]

string_schema/parsing/optimizer.py

@@ -0,0 +1,246 @@
+"""
+Schema optimization utilities for Simple Schema
+
+Contains functions for optimizing and improving schema definitions.
+"""
+
+import re
+from typing import Dict, Any, List, Optional
+import logging
+
+from .string_parser import validate_string_schema
+
+logger = logging.getLogger(__name__)
+
+
+def optimize_string_schema(schema_str: str) -> str:
+    """Optimize enhanced schema string for better readability"""
+    try:
+        validation = validate_string_schema(schema_str)
+        if not validation['valid']:
+            return schema_str
+        
+        # For now, return the original schema
+        # Future: Could implement smart formatting, type inference, etc.
+        optimized = _format_schema_string(schema_str)
+        return optimized
+        
+    except Exception as e:
+        logger.warning(f"Failed to optimize schema string: {e}")
+        return schema_str
+
+
+def _format_schema_string(schema_str: str) -> str:
+    """Format schema string for better readability"""
+    # Remove extra whitespace
+    schema_str = re.sub(r'\s+', ' ', schema_str.strip())
+    
+    # Add spacing around operators
+    schema_str = re.sub(r'([:|,])', r'\1 ', schema_str)
+    schema_str = re.sub(r'\s+', ' ', schema_str)
+    
+    # Format nested structures
+    if '{' in schema_str and '}' in schema_str:
+        schema_str = _format_nested_objects(schema_str)
+    
+    return schema_str.strip()
+
+
+def _format_nested_objects(schema_str: str) -> str:
+    """Format nested object structures with proper indentation"""
+    # This is a simplified formatter - could be enhanced
+    result = ""
+    indent_level = 0
+    
+    for char in schema_str:
+        if char == '{':
+            result += char + '\n' + '  ' * (indent_level + 1)
+            indent_level += 1
+        elif char == '}':
+            indent_level -= 1
+            result += '\n' + '  ' * indent_level + char
+        elif char == ',':
+            result += char + '\n' + '  ' * indent_level
+        else:
+            result += char
+    
+    return result
+
+
+def suggest_improvements(schema_str: str) -> List[str]:
+    """Suggest improvements for a schema string"""
+    suggestions = []
+    
+    try:
+        validation = validate_string_schema(schema_str)
+        
+        # Check for missing constraints
+        if 'arrays' in validation.get('features_used', []):
+            if 'constraints' not in validation.get('features_used', []):
+                suggestions.append("Consider adding array size constraints (e.g., [string](max=5)) for better LLM guidance")
+        
+        # Check for missing special types
+        if 'email' in schema_str.lower() and 'special_types' not in validation.get('features_used', []):
+            suggestions.append("Use 'email' type instead of 'string' for email fields")
+        
+        if 'url' in schema_str.lower() and 'special_types' not in validation.get('features_used', []):
+            suggestions.append("Use 'url' type instead of 'string' for URL fields")
+        
+        # Check for overly complex schemas
+        field_count = len(validation.get('parsed_fields', {}))
+        if field_count > 15:
+            suggestions.append("Consider breaking down complex schemas into smaller, focused schemas")
+        
+        # Check for missing optional markers
+        if '?' not in schema_str and field_count > 5:
+            suggestions.append("Consider marking some fields as optional with '?' for more flexible extraction")
+        
+        # Check for enum opportunities
+        if 'status' in schema_str.lower() and 'enums' not in validation.get('features_used', []):
+            suggestions.append("Consider using enum for status fields (e.g., status:enum(active,inactive))")
+        
+    except Exception as e:
+        logger.warning(f"Failed to generate suggestions: {e}")
+    
+    return suggestions
+
+
+def simplify_schema(schema_str: str, max_fields: int = 10) -> str:
+    """Simplify a complex schema by reducing fields"""
+    try:
+        validation = validate_string_schema(schema_str)
+        parsed_fields = validation.get('parsed_fields', {})
+        
+        if len(parsed_fields) <= max_fields:
+            return schema_str
+        
+        # This is a basic implementation - could be enhanced with smarter field selection
+        logger.info(f"Schema has {len(parsed_fields)} fields, simplifying to {max_fields}")
+        
+        # For now, just return the original schema with a warning
+        return schema_str + " # Note: Consider simplifying this schema"
+        
+    except Exception as e:
+        logger.warning(f"Failed to simplify schema: {e}")
+        return schema_str
+
+
+def infer_types(data_sample: Dict[str, Any]) -> str:
+    """Infer schema string from a data sample"""
+    fields = []
+    
+    for key, value in data_sample.items():
+        field_def = _infer_field_type(key, value)
+        fields.append(field_def)
+    
+    return ", ".join(fields)
+
+
+def _infer_field_type(field_name: str, value: Any) -> str:
+    """Infer field type from a value"""
+    if value is None:
+        return f"{field_name}:string?"
+    
+    if isinstance(value, bool):
+        return f"{field_name}:bool"
+    
+    if isinstance(value, int):
+        return f"{field_name}:int"
+    
+    if isinstance(value, float):
+        return f"{field_name}:number"
+    
+    if isinstance(value, str):
+        # Try to infer special types
+        if '@' in value and '.' in value:
+            return f"{field_name}:email"
+        elif value.startswith(('http://', 'https://')):
+            return f"{field_name}:url"
+        elif re.match(r'^\d{4}-\d{2}-\d{2}', value):
+            return f"{field_name}:date"
+        else:
+            return f"{field_name}:string"
+    
+    if isinstance(value, list):
+        if not value:
+            return f"{field_name}:[string]"
+        
+        # Infer from first item
+        first_item = value[0]
+        if isinstance(first_item, dict):
+            # Object array - this would need more complex inference
+            return f"{field_name}:[object]"
+        else:
+            item_type = _infer_simple_type(first_item)
+            return f"{field_name}:[{item_type}]"
+    
+    if isinstance(value, dict):
+        # Nested object - would need recursive inference
+        return f"{field_name}:object"
+    
+    return f"{field_name}:string"
+
+
+def _infer_simple_type(value: Any) -> str:
+    """Infer simple type from a value"""
+    if isinstance(value, bool):
+        return "bool"
+    elif isinstance(value, int):
+        return "int"
+    elif isinstance(value, float):
+        return "number"
+    elif isinstance(value, str):
+        if '@' in value and '.' in value:
+            return "email"
+        elif value.startswith(('http://', 'https://')):
+            return "url"
+        else:
+            return "string"
+    else:
+        return "string"
+
+
+def validate_optimization(original: str, optimized: str) -> Dict[str, Any]:
+    """Validate that optimization preserves schema semantics"""
+    result = {
+        'valid': True,
+        'errors': [],
+        'warnings': [],
+        'changes': []
+    }
+    
+    try:
+        original_validation = validate_string_schema(original)
+        optimized_validation = validate_string_schema(optimized)
+        
+        if not original_validation['valid']:
+            result['errors'].append("Original schema is invalid")
+        
+        if not optimized_validation['valid']:
+            result['errors'].append("Optimized schema is invalid")
+        
+        # Compare field counts
+        orig_fields = len(original_validation.get('parsed_fields', {}))
+        opt_fields = len(optimized_validation.get('parsed_fields', {}))
+        
+        if orig_fields != opt_fields:
+            result['warnings'].append(f"Field count changed: {orig_fields} → {opt_fields}")
+        
+        # Compare features
+        orig_features = set(original_validation.get('features_used', []))
+        opt_features = set(optimized_validation.get('features_used', []))
+        
+        if orig_features != opt_features:
+            added = opt_features - orig_features
+            removed = orig_features - opt_features
+            
+            if added:
+                result['changes'].append(f"Added features: {', '.join(added)}")
+            if removed:
+                result['changes'].append(f"Removed features: {', '.join(removed)}")
+        
+    except Exception as e:
+        result['errors'].append(f"Validation error: {str(e)}")
+    
+    result['valid'] = len(result['errors']) == 0
+    return result