string-schema 0.1.1__tar.gz → 0.1.3__tar.gz

{string_schema-0.1.1/string_schema.egg-info → string_schema-0.1.3}/PKG-INFO

@@ -1,12 +1,12 @@
 Metadata-Version: 2.4
 Name: string-schema
-Version: 0.1.1
+Version: 0.1.3
 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
 Author-email: Michael Chen <xychen@msn.com>
 Maintainer-email: Michael Chen <xychen@msn.com>
-License: MIT
+License-Expression: MIT
 Project-URL: Homepage, https://github.com/xychenmsn/string-schema
 Project-URL: Documentation, https://github.com/xychenmsn/string-schema#readme
 Project-URL: Repository, https://github.com/xychenmsn/string-schema
@@ -15,7 +15,6 @@ Project-URL: Changelog, https://github.com/xychenmsn/string-schema/releases
 Keywords: schema,validation,json,llm,ai,data-extraction,pydantic
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.11

{string_schema-0.1.1 → string_schema-0.1.3}/pyproject.toml

@@ -4,10 +4,10 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "string-schema"
-version = "0.1.1"
+version = "0.1.3"
 description = "A simple, LLM-friendly schema definition library for converting string syntax to structured schemas"
 readme = "README.md"
-license = {text = "MIT"}
+license = "MIT"
 authors = [
     {name = "Michael Chen", email = "xychen@msn.com"}
 ]
@@ -18,7 +18,6 @@ keywords = ["schema", "validation", "json", "llm", "ai", "data-extraction", "pyd
 classifiers = [
     "Development Status :: 3 - Alpha",
     "Intended Audience :: Developers",
-    "License :: OSI Approved :: MIT License",
     "Operating System :: OS Independent",
     "Programming Language :: Python :: 3",
     "Programming Language :: Python :: 3.11",
@@ -58,8 +57,9 @@ Repository = "https://github.com/xychenmsn/string-schema"
 "Bug Reports" = "https://github.com/xychenmsn/string-schema/issues"
 Changelog = "https://github.com/xychenmsn/string-schema/releases"
 
-[tool.setuptools]
-packages = ["string_schema"]
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["string_schema*"]
 
 [tool.setuptools.package-data]
 string_schema = ["py.typed"]

{string_schema-0.1.1 → string_schema-0.1.3}/setup.py

@@ -9,7 +9,7 @@ with open("README.md", "r", encoding="utf-8") as fh:
 
 setup(
     name="string-schema",
-    version="0.1.1",
+    version="0.1.3",
     author="Michael Chen",
     author_email="xychen@msn.com",
     description="A simple, LLM-friendly schema definition library for converting string syntax to structured schemas",
@@ -20,7 +20,6 @@ setup(
     classifiers=[
         "Development Status :: 3 - Alpha",
         "Intended Audience :: Developers",
-        "License :: OSI Approved :: MIT License",
         "Operating System :: OS Independent",
         "Programming Language :: Python :: 3",
         "Programming Language :: Python :: 3.11",

string_schema-0.1.3/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-0.1.3/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-0.1.3/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)