ostruct-cli 0.6.0__py3-none-any.whl → 0.6.1__py3-none-any.whl

ostruct/cli/cli.py

@@ -5,7 +5,6 @@ import json
 import logging
 import os
 import sys
-from enum import Enum, IntEnum
 from typing import (
     Any,
     AsyncGenerator,
@@ -20,12 +19,11 @@ from typing import (
     TypeVar,
     Union,
     cast,
-    get_origin,
     overload,
 )
 
 if sys.version_info >= (3, 11):
-    from enum import StrEnum
+    pass
 
 from datetime import date, datetime, time
 from pathlib import Path
@@ -48,15 +46,7 @@ from openai_structured.errors import (
     StreamBufferError,
 )
 from openai_structured.model_registry import ModelRegistry
-from pydantic import (
-    AnyUrl,
-    BaseModel,
-    ConfigDict,
-    EmailStr,
-    Field,
-    ValidationError,
-    create_model,
-)
+from pydantic import AnyUrl, BaseModel, EmailStr, Field
 from pydantic.fields import FieldInfo as FieldInfoType
 from pydantic.functional_validators import BeforeValidator
 from pydantic.types import constr
@@ -69,11 +59,8 @@ from .. import __version__  # noqa: F401 - Used in package metadata
 from .errors import (
     CLIError,
     DirectoryNotFoundError,
-    FieldDefinitionError,
     InvalidJSONError,
     ModelCreationError,
-    ModelValidationError,
-    NestedModelError,
     OstructFileNotFoundError,
     PathSecurityError,
     SchemaFileError,
@@ -86,6 +73,7 @@ from .errors import (
     VariableValueError,
 )
 from .file_utils import FileInfoList, collect_files
+from .model_creation import _create_enum_type, create_dynamic_model
 from .path_utils import validate_path_mapping
 from .security import SecurityManager
 from .serialization import LogSerializer
@@ -97,6 +85,71 @@ from .token_utils import estimate_tokens_with_encoding
 DEFAULT_SYSTEM_PROMPT = "You are a helpful assistant."
 
 
+# Validation functions
+def pattern(regex: str) -> Any:
+    return constr(pattern=regex)
+
+
+def min_length(length: int) -> Any:
+    return BeforeValidator(lambda v: v if len(str(v)) >= length else None)
+
+
+def max_length(length: int) -> Any:
+    return BeforeValidator(lambda v: v if len(str(v)) <= length else None)
+
+
+def ge(value: Union[int, float]) -> Any:
+    return BeforeValidator(lambda v: v if float(v) >= value else None)
+
+
+def le(value: Union[int, float]) -> Any:
+    return BeforeValidator(lambda v: v if float(v) <= value else None)
+
+
+def gt(value: Union[int, float]) -> Any:
+    return BeforeValidator(lambda v: v if float(v) > value else None)
+
+
+def lt(value: Union[int, float]) -> Any:
+    return BeforeValidator(lambda v: v if float(v) < value else None)
+
+
+def multiple_of(value: Union[int, float]) -> Any:
+    return BeforeValidator(lambda v: v if float(v) % value == 0 else None)
+
+
+def create_template_context(
+    files: Optional[
+        Dict[str, Union[FileInfoList, str, List[str], Dict[str, str]]]
+    ] = None,
+    variables: Optional[Dict[str, str]] = None,
+    json_variables: Optional[Dict[str, Any]] = None,
+    security_manager: Optional[SecurityManager] = None,
+    stdin_content: Optional[str] = None,
+) -> Dict[str, Any]:
+    """Create template context from files and variables."""
+    context: Dict[str, Any] = {}
+
+    # Add file variables
+    if files:
+        for name, file_list in files.items():
+            context[name] = file_list  # Always keep FileInfoList wrapper
+
+    # Add simple variables
+    if variables:
+        context.update(variables)
+
+    # Add JSON variables
+    if json_variables:
+        context.update(json_variables)
+
+    # Add stdin if provided
+    if stdin_content is not None:
+        context["stdin"] = stdin_content
+
+    return context
+
+
 class CLIParams(TypedDict, total=False):
     """Type-safe CLI parameters."""
 
@@ -185,12 +238,6 @@ ItemType: TypeAlias = Type[BaseModel]
 ValueType: TypeAlias = Type[Any]
 
 
-def is_container_type(tp: Type[Any]) -> bool:
-    """Check if a type is a container type (list, dict, etc.)."""
-    origin = get_origin(tp)
-    return origin in (list, dict)
-
-
 def _create_field(**kwargs: Any) -> FieldInfoType:
     """Create a Pydantic Field with the given kwargs."""
     field: FieldInfoType = Field(**kwargs)
@@ -877,8 +924,11 @@ def collect_template_files(
         # Let PathSecurityError propagate without wrapping
         raise
     except (FileNotFoundError, DirectoryNotFoundError) as e:
-        # Wrap file-related errors
-        raise ValueError(f"File access error: {e}")
+        # Convert FileNotFoundError to OstructFileNotFoundError
+        if isinstance(e, FileNotFoundError):
+            raise OstructFileNotFoundError(str(e))
+        # Let DirectoryNotFoundError propagate
+        raise
     except Exception as e:
         # Don't wrap InvalidJSONError
         if isinstance(e, InvalidJSONError):
@@ -980,38 +1030,6 @@ def collect_json_variables(args: CLIParams) -> Dict[str, Any]:
     return variables
 
 
-def create_template_context(
-    files: Optional[
-        Dict[str, Union[FileInfoList, str, List[str], Dict[str, str]]]
-    ] = None,
-    variables: Optional[Dict[str, str]] = None,
-    json_variables: Optional[Dict[str, Any]] = None,
-    security_manager: Optional[SecurityManager] = None,
-    stdin_content: Optional[str] = None,
-) -> Dict[str, Any]:
-    """Create template context from files and variables."""
-    context: Dict[str, Any] = {}
-
-    # Add file variables
-    if files:
-        for name, file_list in files.items():
-            context[name] = file_list  # Always keep FileInfoList wrapper
-
-    # Add simple variables
-    if variables:
-        context.update(variables)
-
-    # Add JSON variables
-    if json_variables:
-        context.update(json_variables)
-
-    # Add stdin if provided
-    if stdin_content is not None:
-        context["stdin"] = stdin_content
-
-    return context
-
-
 async def create_template_context_from_args(
     args: CLIParams,
     security_manager: SecurityManager,
@@ -1066,8 +1084,11 @@ async def create_template_context_from_args(
         # Let PathSecurityError propagate without wrapping
         raise
     except (FileNotFoundError, DirectoryNotFoundError) as e:
-        # Wrap file-related errors
-        raise ValueError(f"File access error: {e}")
+        # Convert FileNotFoundError to OstructFileNotFoundError
+        if isinstance(e, FileNotFoundError):
+            raise OstructFileNotFoundError(str(e))
+        # Let DirectoryNotFoundError propagate
+        raise
     except Exception as e:
         # Don't wrap InvalidJSONError
         if isinstance(e, InvalidJSONError):
@@ -1197,41 +1218,6 @@ def parse_json_var(var_str: str) -> Tuple[str, Any]:
         raise
 
 
-def _create_enum_type(values: List[Any], field_name: str) -> Type[Enum]:
-    """Create an enum type from a list of values.
-
-    Args:
-        values: List of enum values
-        field_name: Name of the field for enum type name
-
-    Returns:
-        Created enum type
-    """
-    # Determine the value type
-    value_types = {type(v) for v in values}
-
-    if len(value_types) > 1:
-        # Mixed types, use string representation
-        enum_dict = {f"VALUE_{i}": str(v) for i, v in enumerate(values)}
-        return type(f"{field_name.title()}Enum", (str, Enum), enum_dict)
-    elif value_types == {int}:
-        # All integer values
-        enum_dict = {f"VALUE_{v}": v for v in values}
-        return type(f"{field_name.title()}Enum", (IntEnum,), enum_dict)
-    elif value_types == {str}:
-        # All string values
-        enum_dict = {v.upper().replace(" ", "_"): v for v in values}
-        if sys.version_info >= (3, 11):
-            return type(f"{field_name.title()}Enum", (StrEnum,), enum_dict)
-        else:
-            # Other types, use string representation
-            return type(f"{field_name.title()}Enum", (str, Enum), enum_dict)
-
-    # Default case: treat as string enum
-    enum_dict = {f"VALUE_{i}": str(v) for i, v in enumerate(values)}
-    return type(f"{field_name.title()}Enum", (str, Enum), enum_dict)
-
-
 def handle_error(e: Exception) -> None:
     """Handle CLI errors and display appropriate messages.
 
@@ -1433,7 +1419,7 @@ async def stream_structured_output(
         EmptyResponseError,
         InvalidResponseFormatError,
     ) as e:
-        logger.error(f"Stream error: {e}")
+        logger.error("Stream error: %s", str(e))
         raise
     finally:
         # Always ensure client is properly closed
@@ -1941,254 +1927,5 @@ __all__ = [
 ]
 
 
-def create_dynamic_model(
-    schema: Dict[str, Any],
-    base_name: str = "DynamicModel",
-    show_schema: bool = False,
-    debug_validation: bool = False,
-) -> Type[BaseModel]:
-    """Create a Pydantic model from a JSON schema.
-
-    Args:
-        schema: JSON schema to create model from
-        base_name: Name for the model class
-        show_schema: Whether to show the generated model schema
-        debug_validation: Whether to show detailed validation errors
-
-    Returns:
-        Type[BaseModel]: The generated Pydantic model class
-
-    Raises:
-        ModelValidationError: If the schema is invalid
-        SchemaValidationError: If the schema violates OpenAI requirements
-    """
-    if debug_validation:
-        logger.info("Creating dynamic model from schema:")
-        logger.info(json.dumps(schema, indent=2))
-
-    try:
-        # Handle our wrapper format if present
-        if "schema" in schema:
-            if debug_validation:
-                logger.info("Found schema wrapper, extracting inner schema")
-                logger.info(
-                    "Original schema: %s", json.dumps(schema, indent=2)
-                )
-            inner_schema = schema["schema"]
-            if not isinstance(inner_schema, dict):
-                if debug_validation:
-                    logger.info(
-                        "Inner schema must be a dictionary, got %s",
-                        type(inner_schema),
-                    )
-                raise SchemaValidationError(
-                    "Inner schema must be a dictionary"
-                )
-            if debug_validation:
-                logger.info("Using inner schema:")
-                logger.info(json.dumps(inner_schema, indent=2))
-            schema = inner_schema
-
-        # Validate against OpenAI requirements
-        from .schema_validation import validate_openai_schema
-
-        validate_openai_schema(schema)
-
-        # Create model configuration
-        config = ConfigDict(
-            title=schema.get("title", base_name),
-            extra="forbid",  # OpenAI requires additionalProperties: false
-            validate_default=True,
-            use_enum_values=True,
-            arbitrary_types_allowed=True,
-            json_schema_extra={
-                k: v
-                for k, v in schema.items()
-                if k
-                not in {
-                    "type",
-                    "properties",
-                    "required",
-                    "title",
-                    "description",
-                    "additionalProperties",
-                    "readOnly",
-                }
-            },
-        )
-
-        if debug_validation:
-            logger.info("Created model configuration:")
-            logger.info("  Title: %s", config.get("title"))
-            logger.info("  Extra: %s", config.get("extra"))
-            logger.info(
-                "  Validate Default: %s", config.get("validate_default")
-            )
-            logger.info("  Use Enum Values: %s", config.get("use_enum_values"))
-            logger.info(
-                "  Arbitrary Types: %s", config.get("arbitrary_types_allowed")
-            )
-            logger.info(
-                "  JSON Schema Extra: %s", config.get("json_schema_extra")
-            )
-
-        # Process schema properties into fields
-        properties = schema.get("properties", {})
-        required = schema.get("required", [])
-
-        field_definitions: Dict[str, Tuple[Type[Any], FieldInfoType]] = {}
-        for field_name, field_schema in properties.items():
-            if debug_validation:
-                logger.info("Processing field %s:", field_name)
-                logger.info("  Schema: %s", json.dumps(field_schema, indent=2))
-
-            try:
-                python_type, field = _get_type_with_constraints(
-                    field_schema, field_name, base_name
-                )
-
-                # Handle optional fields
-                if field_name not in required:
-                    if debug_validation:
-                        logger.info(
-                            "Field %s is optional, wrapping in Optional",
-                            field_name,
-                        )
-                    field_type = cast(Type[Any], Optional[python_type])
-                else:
-                    field_type = python_type
-                    if debug_validation:
-                        logger.info("Field %s is required", field_name)
-
-                # Create field definition
-                field_definitions[field_name] = (field_type, field)
-
-                if debug_validation:
-                    logger.info("Successfully created field definition:")
-                    logger.info("  Name: %s", field_name)
-                    logger.info("  Type: %s", str(field_type))
-                    logger.info("  Required: %s", field_name in required)
-
-            except (FieldDefinitionError, NestedModelError) as e:
-                if debug_validation:
-                    logger.error("Error creating field %s:", field_name)
-                    logger.error("  Error type: %s", type(e).__name__)
-                    logger.error("  Error message: %s", str(e))
-                raise ModelValidationError(base_name, [str(e)])
-
-        # Create the model with the fields
-        field_defs: Dict[str, Any] = {
-            name: (
-                (
-                    cast(Type[Any], field_type)
-                    if is_container_type(field_type)
-                    else field_type
-                ),
-                field,
-            )
-            for name, (field_type, field) in field_definitions.items()
-        }
-        model: Type[BaseModel] = create_model(
-            base_name, __config__=config, **field_defs
-        )
-
-        # Set the model config after creation
-        model.model_config = config
-
-        if debug_validation:
-            logger.info("Successfully created model: %s", model.__name__)
-            logger.info("Model config: %s", dict(model.model_config))
-            logger.info(
-                "Model schema: %s",
-                json.dumps(model.model_json_schema(), indent=2),
-            )
-
-        # Validate the model's JSON schema
-        try:
-            model.model_json_schema()
-        except ValidationError as e:
-            validation_errors = (
-                [str(err) for err in e.errors()]
-                if hasattr(e, "errors")
-                else [str(e)]
-            )
-            if debug_validation:
-                logger.error("Schema validation failed:")
-                logger.error("  Error type: %s", type(e).__name__)
-                logger.error("  Error message: %s", str(e))
-            raise ModelValidationError(base_name, validation_errors)
-
-        return model
-
-    except SchemaValidationError as e:
-        # Always log basic error info
-        logger.error("Schema validation error: %s", str(e))
-
-        # Log additional debug info if requested
-        if debug_validation:
-            logger.error("  Error type: %s", type(e).__name__)
-            logger.error("  Error details: %s", str(e))
-        # Always raise schema validation errors directly
-        raise
-
-    except Exception as e:
-        # Always log basic error info
-        logger.error("Model creation error: %s", str(e))
-
-        # Log additional debug info if requested
-        if debug_validation:
-            logger.error("  Error type: %s", type(e).__name__)
-            logger.error("  Error details: %s", str(e))
-            if hasattr(e, "__cause__"):
-                logger.error("  Caused by: %s", str(e.__cause__))
-            if hasattr(e, "__context__"):
-                logger.error("  Context: %s", str(e.__context__))
-            if hasattr(e, "__traceback__"):
-                import traceback
-
-                logger.error(
-                    "  Traceback:\n%s",
-                    "".join(traceback.format_tb(e.__traceback__)),
-                )
-        # Always wrap other errors as ModelCreationError
-        raise ModelCreationError(
-            f"Failed to create model {base_name}",
-            context={"error": str(e)},
-        ) from e
-
-
-# Validation functions
-def pattern(regex: str) -> Any:
-    return constr(pattern=regex)
-
-
-def min_length(length: int) -> Any:
-    return BeforeValidator(lambda v: v if len(str(v)) >= length else None)
-
-
-def max_length(length: int) -> Any:
-    return BeforeValidator(lambda v: v if len(str(v)) <= length else None)
-
-
-def ge(value: Union[int, float]) -> Any:
-    return BeforeValidator(lambda v: v if float(v) >= value else None)
-
-
-def le(value: Union[int, float]) -> Any:
-    return BeforeValidator(lambda v: v if float(v) <= value else None)
-
-
-def gt(value: Union[int, float]) -> Any:
-    return BeforeValidator(lambda v: v if float(v) > value else None)
-
-
-def lt(value: Union[int, float]) -> Any:
-    return BeforeValidator(lambda v: v if float(v) < value else None)
-
-
-def multiple_of(value: Union[int, float]) -> Any:
-    return BeforeValidator(lambda v: v if float(v) % value == 0 else None)
-
-
 if __name__ == "__main__":
     main()

ostruct/cli/model_creation.py

@@ -0,0 +1,507 @@
+"""Model creation utilities for the CLI."""
+
+import json
+import logging
+import sys
+from datetime import date, datetime, time
+from enum import Enum, IntEnum
+from typing import (
+    Any,
+    Dict,
+    List,
+    Optional,
+    Tuple,
+    Type,
+    Union,
+    cast,
+    get_origin,
+)
+
+if sys.version_info >= (3, 11):
+    from enum import StrEnum
+
+from pydantic import (
+    AnyUrl,
+    BaseModel,
+    ConfigDict,
+    EmailStr,
+    Field,
+    ValidationError,
+    create_model,
+)
+from pydantic.fields import FieldInfo
+from pydantic.functional_validators import BeforeValidator
+from pydantic.types import constr
+
+from .errors import (
+    FieldDefinitionError,
+    ModelCreationError,
+    ModelValidationError,
+    NestedModelError,
+    SchemaValidationError,
+)
+
+logger = logging.getLogger(__name__)
+
+# Type aliases
+FieldType = Type[
+    Any
+]  # Changed from Type[Any] to allow both concrete types and generics
+FieldDefinition = Tuple[Any, FieldInfo]  # Changed to Any to handle generics
+
+
+def _create_enum_type(values: List[Any], field_name: str) -> Type[Enum]:
+    """Create an enum type from a list of values.
+
+    Args:
+        values: List of enum values
+        field_name: Name of the field for enum type name
+
+    Returns:
+        Created enum type
+    """
+    # Determine the value type
+    value_types = {type(v) for v in values}
+
+    if len(value_types) > 1:
+        # Mixed types, use string representation
+        enum_dict = {f"VALUE_{i}": str(v) for i, v in enumerate(values)}
+        return type(f"{field_name.title()}Enum", (str, Enum), enum_dict)
+    elif value_types == {int}:
+        # All integer values
+        enum_dict = {f"VALUE_{v}": v for v in values}
+        return type(f"{field_name.title()}Enum", (IntEnum,), enum_dict)
+    elif value_types == {str}:
+        # All string values
+        enum_dict = {v.upper().replace(" ", "_"): v for v in values}
+        if sys.version_info >= (3, 11):
+            return type(f"{field_name.title()}Enum", (StrEnum,), enum_dict)
+        else:
+            # Other types, use string representation
+            return type(f"{field_name.title()}Enum", (str, Enum), enum_dict)
+
+    # Default case: treat as string enum
+    enum_dict = {f"VALUE_{i}": str(v) for i, v in enumerate(values)}
+    return type(f"{field_name.title()}Enum", (str, Enum), enum_dict)
+
+
+def is_container_type(tp: Type[Any]) -> bool:
+    """Check if a type is a container type (List, Dict, etc).
+
+    Args:
+        tp: Type to check
+
+    Returns:
+        bool: True if type is a container type
+    """
+    origin = get_origin(tp)
+    return origin is not None and origin in (list, dict, List, Dict)
+
+
+# Validation functions
+def pattern(regex: str) -> Any:
+    return constr(pattern=regex)
+
+
+def min_length(length: int) -> Any:
+    return BeforeValidator(lambda v: v if len(str(v)) >= length else None)
+
+
+def max_length(length: int) -> Any:
+    return BeforeValidator(lambda v: v if len(str(v)) <= length else None)
+
+
+def ge(value: Union[int, float]) -> Any:
+    return BeforeValidator(lambda v: v if float(v) >= value else None)
+
+
+def le(value: Union[int, float]) -> Any:
+    return BeforeValidator(lambda v: v if float(v) <= value else None)
+
+
+def gt(value: Union[int, float]) -> Any:
+    return BeforeValidator(lambda v: v if float(v) > value else None)
+
+
+def lt(value: Union[int, float]) -> Any:
+    return BeforeValidator(lambda v: v if float(v) < value else None)
+
+
+def multiple_of(value: Union[int, float]) -> Any:
+    return BeforeValidator(lambda v: v if float(v) % value == 0 else None)
+
+
+def _get_type_with_constraints(
+    field_schema: Dict[str, Any], field_name: str, base_name: str
+) -> FieldDefinition:
+    """Get type with constraints from field schema.
+
+    Args:
+        field_schema: Field schema dict
+        field_name: Name of the field
+        base_name: Base name for nested models
+
+    Returns:
+        Tuple of (type, field)
+    """
+    field_kwargs: Dict[str, Any] = {}
+
+    # Add common field metadata
+    if "title" in field_schema:
+        field_kwargs["title"] = field_schema["title"]
+    if "description" in field_schema:
+        field_kwargs["description"] = field_schema["description"]
+    if "default" in field_schema:
+        field_kwargs["default"] = field_schema["default"]
+    if "readOnly" in field_schema:
+        field_kwargs["frozen"] = field_schema["readOnly"]
+
+    field_type = field_schema.get("type")
+
+    # Handle array type
+    if field_type == "array":
+        items_schema = field_schema.get("items", {})
+        if not items_schema:
+            return (List[Any], Field(**field_kwargs))  # Direct generic type
+
+        # Create nested model for object items
+        if (
+            isinstance(items_schema, dict)
+            and items_schema.get("type") == "object"
+        ):
+            array_item_model = create_dynamic_model(
+                items_schema,
+                base_name=f"{base_name}_{field_name}_Item",
+                show_schema=False,
+                debug_validation=False,
+            )
+            return (List[array_item_model], Field(**field_kwargs))  # type: ignore[valid-type]
+
+        # For non-object items, use the type directly
+        item_type = items_schema.get("type", "string")
+        if item_type == "string":
+            return (List[str], Field(**field_kwargs))
+        elif item_type == "integer":
+            return (List[int], Field(**field_kwargs))
+        elif item_type == "number":
+            return (List[float], Field(**field_kwargs))
+        elif item_type == "boolean":
+            return (List[bool], Field(**field_kwargs))
+        else:
+            return (List[Any], Field(**field_kwargs))
+
+    # Handle object type
+    if field_type == "object":
+        # Create nested model with explicit type annotation
+        object_model = create_dynamic_model(
+            field_schema,
+            base_name=f"{base_name}_{field_name}",
+            show_schema=False,
+            debug_validation=False,
+        )
+        return (object_model, Field(**field_kwargs))
+
+    # Handle additionalProperties
+    if "additionalProperties" in field_schema and isinstance(
+        field_schema["additionalProperties"], dict
+    ):
+        # Create nested model with explicit type annotation
+        dict_value_model = create_dynamic_model(
+            field_schema["additionalProperties"],
+            base_name=f"{base_name}_{field_name}_Value",
+            show_schema=False,
+            debug_validation=False,
+        )
+        dict_type: Type[Dict[str, Any]] = Dict[str, dict_value_model]  # type: ignore[valid-type]
+        return (dict_type, Field(**field_kwargs))
+
+    # Handle other types
+    if field_type == "string":
+        field_type_cls: Type[Any] = str
+
+        # Add string-specific constraints to field_kwargs
+        if "pattern" in field_schema:
+            field_kwargs["pattern"] = field_schema["pattern"]
+        if "minLength" in field_schema:
+            field_kwargs["min_length"] = field_schema["minLength"]
+        if "maxLength" in field_schema:
+            field_kwargs["max_length"] = field_schema["maxLength"]
+
+        # Handle special string formats
+        if "format" in field_schema:
+            if field_schema["format"] == "date-time":
+                field_type_cls = datetime
+            elif field_schema["format"] == "date":
+                field_type_cls = date
+            elif field_schema["format"] == "time":
+                field_type_cls = time
+            elif field_schema["format"] == "email":
+                field_type_cls = EmailStr
+            elif field_schema["format"] == "uri":
+                field_type_cls = AnyUrl
+
+        return (field_type_cls, Field(**field_kwargs))
+
+    if field_type == "number":
+        field_type_cls = float
+
+        # Add number-specific constraints to field_kwargs
+        if "minimum" in field_schema:
+            field_kwargs["ge"] = field_schema["minimum"]
+        if "maximum" in field_schema:
+            field_kwargs["le"] = field_schema["maximum"]
+        if "exclusiveMinimum" in field_schema:
+            field_kwargs["gt"] = field_schema["exclusiveMinimum"]
+        if "exclusiveMaximum" in field_schema:
+            field_kwargs["lt"] = field_schema["exclusiveMaximum"]
+        if "multipleOf" in field_schema:
+            field_kwargs["multiple_of"] = field_schema["multipleOf"]
+
+        return (field_type_cls, Field(**field_kwargs))
+
+    if field_type == "integer":
+        field_type_cls = int
+
+        # Add integer-specific constraints to field_kwargs
+        if "minimum" in field_schema:
+            field_kwargs["ge"] = field_schema["minimum"]
+        if "maximum" in field_schema:
+            field_kwargs["le"] = field_schema["maximum"]
+        if "exclusiveMinimum" in field_schema:
+            field_kwargs["gt"] = field_schema["exclusiveMinimum"]
+        if "exclusiveMaximum" in field_schema:
+            field_kwargs["lt"] = field_schema["exclusiveMaximum"]
+        if "multipleOf" in field_schema:
+            field_kwargs["multiple_of"] = field_schema["multipleOf"]
+
+        return (field_type_cls, Field(**field_kwargs))
+
+    if field_type == "boolean":
+        return (bool, Field(**field_kwargs))
+
+    if field_type == "null":
+        return (type(None), Field(**field_kwargs))
+
+    # Handle enum
+    if "enum" in field_schema:
+        enum_type = _create_enum_type(field_schema["enum"], field_name)
+        return (cast(Type[Any], enum_type), Field(**field_kwargs))
+
+    # Default to Any for unknown types
+    return (Any, Field(**field_kwargs))
+
+
+def create_dynamic_model(
+    schema: Dict[str, Any],
+    base_name: str = "DynamicModel",
+    show_schema: bool = False,
+    debug_validation: bool = False,
+) -> Type[BaseModel]:
+    """Create a Pydantic model from a JSON schema.
+
+    Args:
+        schema: JSON schema to create model from
+        base_name: Name for the model class
+        show_schema: Whether to show the generated model schema
+        debug_validation: Whether to show detailed validation errors
+
+    Returns:
+        Type[BaseModel]: The generated Pydantic model class
+
+    Raises:
+        ModelValidationError: If the schema is invalid
+        SchemaValidationError: If the schema violates OpenAI requirements
+    """
+    if debug_validation:
+        logger.info("Creating dynamic model from schema:")
+        logger.info(json.dumps(schema, indent=2))
+
+    try:
+        # Handle our wrapper format if present
+        if "schema" in schema:
+            if debug_validation:
+                logger.info("Found schema wrapper, extracting inner schema")
+                logger.info(
+                    "Original schema: %s", json.dumps(schema, indent=2)
+                )
+            inner_schema = schema["schema"]
+            if not isinstance(inner_schema, dict):
+                if debug_validation:
+                    logger.info(
+                        "Inner schema must be a dictionary, got %s",
+                        type(inner_schema),
+                    )
+                raise SchemaValidationError(
+                    "Inner schema must be a dictionary"
+                )
+            if debug_validation:
+                logger.info("Using inner schema:")
+                logger.info(json.dumps(inner_schema, indent=2))
+            schema = inner_schema
+
+        # Validate against OpenAI requirements
+        from .schema_validation import validate_openai_schema
+
+        validate_openai_schema(schema)
+
+        # Create model configuration
+        config = ConfigDict(
+            title=schema.get("title", base_name),
+            extra="forbid",  # OpenAI requires additionalProperties: false
+            validate_default=True,
+            use_enum_values=True,
+            arbitrary_types_allowed=True,
+            json_schema_extra={
+                k: v
+                for k, v in schema.items()
+                if k
+                not in {
+                    "type",
+                    "properties",
+                    "required",
+                    "title",
+                    "description",
+                    "additionalProperties",
+                    "readOnly",
+                }
+            },
+        )
+
+        if debug_validation:
+            logger.info("Created model configuration:")
+            logger.info("  Title: %s", config.get("title"))
+            logger.info("  Extra: %s", config.get("extra"))
+            logger.info(
+                "  Validate Default: %s", config.get("validate_default")
+            )
+            logger.info("  Use Enum Values: %s", config.get("use_enum_values"))
+            logger.info(
+                "  Arbitrary Types: %s", config.get("arbitrary_types_allowed")
+            )
+            logger.info(
+                "  JSON Schema Extra: %s", config.get("json_schema_extra")
+            )
+
+        # Process schema properties into fields
+        properties = schema.get("properties", {})
+        required = schema.get("required", [])
+
+        field_definitions: Dict[str, Tuple[Type[Any], FieldInfo]] = {}
+        for field_name, field_schema in properties.items():
+            if debug_validation:
+                logger.info("Processing field %s:", field_name)
+                logger.info("  Schema: %s", json.dumps(field_schema, indent=2))
+
+            try:
+                python_type, field = _get_type_with_constraints(
+                    field_schema, field_name, base_name
+                )
+
+                # Handle optional fields
+                if field_name not in required:
+                    if debug_validation:
+                        logger.info(
+                            "Field %s is optional, wrapping in Optional",
+                            field_name,
+                        )
+                    field_type = cast(Type[Any], Optional[python_type])
+                else:
+                    field_type = python_type
+                    if debug_validation:
+                        logger.info("Field %s is required", field_name)
+
+                # Create field definition
+                field_definitions[field_name] = (field_type, field)
+
+                if debug_validation:
+                    logger.info("Successfully created field definition:")
+                    logger.info("  Name: %s", field_name)
+                    logger.info("  Type: %s", str(field_type))
+                    logger.info("  Required: %s", field_name in required)
+
+            except (FieldDefinitionError, NestedModelError) as e:
+                if debug_validation:
+                    logger.error("Error creating field %s:", field_name)
+                    logger.error("  Error type: %s", type(e).__name__)
+                    logger.error("  Error message: %s", str(e))
+                raise ModelValidationError(base_name, [str(e)])
+
+        # Create the model with the fields
+        field_defs: Dict[str, Any] = {
+            name: (
+                (
+                    cast(Type[Any], field_type)
+                    if is_container_type(field_type)
+                    else field_type
+                ),
+                field,
+            )
+            for name, (field_type, field) in field_definitions.items()
+        }
+        model: Type[BaseModel] = create_model(
+            base_name, __config__=config, **field_defs
+        )
+
+        # Set the model config after creation
+        model.model_config = config
+
+        if debug_validation:
+            logger.info("Successfully created model: %s", model.__name__)
+            logger.info("Model config: %s", dict(model.model_config))
+            logger.info(
+                "Model schema: %s",
+                json.dumps(model.model_json_schema(), indent=2),
+            )
+
+        # Validate the model's JSON schema
+        try:
+            model.model_json_schema()
+        except ValidationError as e:
+            validation_errors = (
+                [str(err) for err in e.errors()]
+                if hasattr(e, "errors")
+                else [str(e)]
+            )
+            if debug_validation:
+                logger.error("Schema validation failed:")
+                logger.error("  Error type: %s", type(e).__name__)
+                logger.error("  Error message: %s", str(e))
+            raise ModelValidationError(base_name, validation_errors)
+
+        return model
+
+    except SchemaValidationError as e:
+        # Always log basic error info
+        logger.error("Schema validation error: %s", str(e))
+
+        # Log additional debug info if requested
+        if debug_validation:
+            logger.error("  Error type: %s", type(e).__name__)
+            logger.error("  Error details: %s", str(e))
+        # Always raise schema validation errors directly
+        raise
+
+    except Exception as e:
+        # Always log basic error info
+        logger.error("Model creation error: %s", str(e))
+
+        # Log additional debug info if requested
+        if debug_validation:
+            logger.error("  Error type: %s", type(e).__name__)
+            logger.error("  Error details: %s", str(e))
+            if hasattr(e, "__cause__"):
+                logger.error("  Caused by: %s", str(e.__cause__))
+            if hasattr(e, "__context__"):
+                logger.error("  Context: %s", str(e.__context__))
+            if hasattr(e, "__traceback__"):
+                import traceback
+
+                logger.error(
+                    "  Traceback:\n%s",
+                    "".join(traceback.format_tb(e.__traceback__)),
+                )
+        # Always wrap other errors as ModelCreationError
+        raise ModelCreationError(
+            f"Failed to create model {base_name}",
+            context={"error": str(e)},
+        ) from e

{ostruct_cli-0.6.0.dist-info → ostruct_cli-0.6.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: ostruct-cli
-Version: 0.6.0
+Version: 0.6.1
 Summary: CLI for OpenAI Structured Output
 Author: Yaniv Golan
 Author-email: yaniv@golan.name

{ostruct_cli-0.6.0.dist-info → ostruct_cli-0.6.1.dist-info}/RECORD

@@ -2,13 +2,14 @@ ostruct/__init__.py,sha256=X6zo6V7ZNMv731Wi388aTVQngD1410ExGwGx4J6lpyo,187
 ostruct/cli/__init__.py,sha256=sYHKT6o1kFy1acbXejzAvVm8Cy8U91Yf1l4DlzquHKg,409
 ostruct/cli/base_errors.py,sha256=S1cQxoiALbXKPxzgLo6XdSWpzPRb7RKz0QARmu9Zt4g,5987
 ostruct/cli/cache_manager.py,sha256=ej3KrRfkKKZ_lEp2JswjbJ5bW2ncsvna9NeJu81cqqs,5192
-ostruct/cli/cli.py,sha256=wfO5Z8PPoP8eUn5CfhxrjrdMzfbvr4ryo_tsRST0LlU,74588
+ostruct/cli/cli.py,sha256=lagB4j8G1hg2NmAYvWEarA24qYuY2w-cuRWiqUzoWik,65105
 ostruct/cli/click_options.py,sha256=WbRJdB9sO63ChN3fnCP7XWs73DHKl0C1ervfwL11am0,11371
 ostruct/cli/errors.py,sha256=zJdJ-AyzjCE8glVKbJGAcB-Mz1J1SlzTDJDmhqAVFYc,14930
 ostruct/cli/exit_codes.py,sha256=uNjvQeUGwU1mlUJYIDrExAn7YlwOXZo603yLAwpqIwk,338
 ostruct/cli/file_info.py,sha256=ilpT8IuckfhadLF1QQAPLXJp7p8kVpffDEEJ2erHPZU,14485
 ostruct/cli/file_list.py,sha256=jLuCd1ardoAXX8FNwPgIqEM-ixzr1xP5ZSqXo2lmrj0,11270
 ostruct/cli/file_utils.py,sha256=J3-6fbEGQ7KD_bU81pAxueHLv9XV0X7f8FSMt_0AJGQ,22537
+ostruct/cli/model_creation.py,sha256=TmqJVdnZOYtTctNihOlxWIbyAfX-zfxehP9rp2t6P2c,17586
 ostruct/cli/path_utils.py,sha256=j44q1OoLkqMErgK-qEuhuIZ1VyzqRIvNgxR1et9PoXA,4813
 ostruct/cli/progress.py,sha256=rj9nVEco5UeZORMbzd7mFJpFGJjbH9KbBFh5oTE5Anw,3415
 ostruct/cli/schema_validation.py,sha256=ohEuxJ0KF93qphj0JSZDnrxDn0C2ZU37g-U2JY03onM,8154
@@ -36,8 +37,8 @@ ostruct/cli/token_utils.py,sha256=r4KPEO3Sec18Q6mU0aClK6XGShvusgUggXEQgEPPlaA,13
 ostruct/cli/utils.py,sha256=1UCl4rHjBWKR5EKugvlVGHiHjO3XXmqvkgeAUSyIPDU,831
 ostruct/cli/validators.py,sha256=BYFZeebCPZObTUjO1TaAMpsD6h7ROkYAFn9C7uf1Q68,2992
 ostruct/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ostruct_cli-0.6.0.dist-info/LICENSE,sha256=QUOY6QCYVxAiH8vdrUTDqe3i9hQ5bcNczppDSVpLTjk,1068
-ostruct_cli-0.6.0.dist-info/METADATA,sha256=Zrq8a-EvLhnZdOQBBlYvONWKo61XmdAR8934_OtHUa4,10426
-ostruct_cli-0.6.0.dist-info/WHEEL,sha256=XbeZDeTWKc1w7CSIyre5aMDU_-PohRwTQceYnisIYYY,88
-ostruct_cli-0.6.0.dist-info/entry_points.txt,sha256=NFq9IuqHVTem0j9zKjV8C1si_zGcP1RL6Wbvt9fUDXw,48
-ostruct_cli-0.6.0.dist-info/RECORD,,
+ostruct_cli-0.6.1.dist-info/LICENSE,sha256=QUOY6QCYVxAiH8vdrUTDqe3i9hQ5bcNczppDSVpLTjk,1068
+ostruct_cli-0.6.1.dist-info/METADATA,sha256=2D0_QCNb3xN2Y_K1pMB5WmZBcU8KkN2rqS9qwZMa-pc,10426
+ostruct_cli-0.6.1.dist-info/WHEEL,sha256=XbeZDeTWKc1w7CSIyre5aMDU_-PohRwTQceYnisIYYY,88
+ostruct_cli-0.6.1.dist-info/entry_points.txt,sha256=NFq9IuqHVTem0j9zKjV8C1si_zGcP1RL6Wbvt9fUDXw,48
+ostruct_cli-0.6.1.dist-info/RECORD,,