ostruct-cli 0.6.0__py3-none-any.whl → 0.6.2__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,17 +73,87 @@ 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
 from .template_env import create_jinja_env
-from .template_utils import SystemPromptError, render_template
+from .template_utils import (
+    SystemPromptError,
+    render_template,
+    validate_json_schema,
+)
 from .token_utils import estimate_tokens_with_encoding
 
 # Constants
 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 +242,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)
@@ -784,7 +835,7 @@ def validate_schema_file(
         logger.error(msg)
         raise SchemaFileError(msg, schema_path=path)
     except Exception as e:
-        if isinstance(e, InvalidJSONError):
+        if isinstance(e, (InvalidJSONError, SchemaValidationError)):
             raise
         msg = f"Failed to read schema file {path}: {e}"
         logger.error(msg)
@@ -799,7 +850,13 @@ def validate_schema_file(
     if not isinstance(schema, dict):
         msg = f"Schema in {path} must be a JSON object"
         logger.error(msg)
-        raise SchemaValidationError(msg, context={"path": path})
+        raise SchemaValidationError(
+            msg,
+            context={
+                "validation_type": "schema",
+                "schema_path": path,
+            },
+        )
 
     # Validate schema structure
     if "schema" in schema:
@@ -809,7 +866,13 @@ def validate_schema_file(
         if not isinstance(inner_schema, dict):
             msg = f"Inner schema in {path} must be a JSON object"
             logger.error(msg)
-            raise SchemaValidationError(msg, context={"path": path})
+            raise SchemaValidationError(
+                msg,
+                context={
+                    "validation_type": "schema",
+                    "schema_path": path,
+                },
+            )
         if verbose:
             logger.debug("Inner schema validated successfully")
             logger.debug(
@@ -824,7 +887,20 @@ def validate_schema_file(
     if "type" not in schema.get("schema", schema):
         msg = f"Schema in {path} must specify a type"
         logger.error(msg)
-        raise SchemaValidationError(msg, context={"path": path})
+        raise SchemaValidationError(
+            msg,
+            context={
+                "validation_type": "schema",
+                "schema_path": path,
+            },
+        )
+
+    # Validate schema against JSON Schema spec
+    try:
+        validate_json_schema(schema)
+    except SchemaValidationError as e:
+        logger.error("Schema validation error: %s", str(e))
+        raise  # Re-raise to preserve error chain
 
     # Return the full schema including wrapper
     return schema
@@ -877,8 +953,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 +1059,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 +1113,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 +1247,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.
 
@@ -1239,19 +1254,24 @@ def handle_error(e: Exception) -> None:
     Provides enhanced debug logging for CLI errors.
     """
     # 1. Determine error type and message
-    if isinstance(e, click.UsageError):
+    if isinstance(e, SchemaValidationError):
+        msg = str(e)  # Already formatted in SchemaValidationError
+        exit_code = e.exit_code
+    elif isinstance(e, ModelCreationError):
+        # Unwrap ModelCreationError that might wrap SchemaValidationError
+        if isinstance(e.__cause__, SchemaValidationError):
+            return handle_error(e.__cause__)
+        msg = f"Model creation error: {str(e)}"
+        exit_code = ExitCode.SCHEMA_ERROR
+    elif isinstance(e, click.UsageError):
         msg = f"Usage error: {str(e)}"
         exit_code = ExitCode.USAGE_ERROR
     elif isinstance(e, SchemaFileError):
-        # Preserve specific schema error handling
         msg = str(e)  # Use existing __str__ formatting
         exit_code = ExitCode.SCHEMA_ERROR
     elif isinstance(e, (InvalidJSONError, json.JSONDecodeError)):
         msg = f"Invalid JSON error: {str(e)}"
         exit_code = ExitCode.DATA_ERROR
-    elif isinstance(e, SchemaValidationError):
-        msg = f"Schema validation error: {str(e)}"
-        exit_code = ExitCode.VALIDATION_ERROR
     elif isinstance(e, CLIError):
         msg = str(e)  # Use existing __str__ formatting
         exit_code = ExitCode(e.exit_code)  # Convert int to ExitCode
@@ -1263,7 +1283,7 @@ def handle_error(e: Exception) -> None:
     if isinstance(e, CLIError) and logger.isEnabledFor(logging.DEBUG):
         # Format context fields with lowercase keys and simple values
         context_str = ""
-        if hasattr(e, "context"):
+        if hasattr(e, "context") and e.context:
             for key, value in sorted(e.context.items()):
                 if key not in {
                     "timestamp",
@@ -1271,13 +1291,18 @@ def handle_error(e: Exception) -> None:
                     "version",
                     "python_version",
                 }:
-                    context_str += f"{key.lower()}: {value}\n"
+                    if isinstance(value, dict):
+                        context_str += (
+                            f"{key.lower()}:\n{json.dumps(value, indent=2)}\n"
+                        )
+                    else:
+                        context_str += f"{key.lower()}: {value}\n"
 
-        logger.debug(
-            "Error details:\n"
-            f"Type: {type(e).__name__}\n"
-            f"{context_str.rstrip()}"
-        )
+            logger.debug(
+                "Error details:\n"
+                f"Type: {type(e).__name__}\n"
+                f"{context_str.rstrip()}"
+            )
     elif not isinstance(e, click.UsageError):
         logger.error(msg, exc_info=True)
     else:
@@ -1433,7 +1458,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
@@ -1481,30 +1506,11 @@ def run(
 ) -> None:
     """Run a structured task with template and schema.
 
-    TASK_TEMPLATE is the path to your Jinja2 template file that defines the task.
-    SCHEMA_FILE is the path to your JSON schema file that defines the expected output structure.
-
-    The command supports various options for file handling, variable definition,
-    model configuration, and output control. Use --help to see all available options.
-
-    Examples:
-        # Basic usage
-        ostruct run task.j2 schema.json
-
-        # Process multiple files
-        ostruct run task.j2 schema.json -f code main.py -f test tests/test_main.py
-
-        # Scan directories recursively
-        ostruct run task.j2 schema.json -d src ./src -R
-
-        # Define variables
-        ostruct run task.j2 schema.json -V debug=true -J config='{"env":"prod"}'
-
-        # Configure model
-        ostruct run task.j2 schema.json -m gpt-4 --temperature 0.7 --max-output-tokens 1000
-
-        # Control output
-        ostruct run task.j2 schema.json --output-file result.json --verbose
+    Args:
+        ctx: Click context
+        task_template: Path to task template file
+        schema_file: Path to schema file
+        **kwargs: Additional CLI options
     """
     try:
         # Convert Click parameters to typed dict
@@ -1525,25 +1531,33 @@ def run(
         try:
             exit_code = loop.run_until_complete(run_cli_async(params))
             sys.exit(int(exit_code))
+        except SchemaValidationError as e:
+            # Log the error with full context
+            logger.error("Schema validation error: %s", str(e))
+            if e.context:
+                logger.debug(
+                    "Error context: %s", json.dumps(e.context, indent=2)
+                )
+            # Re-raise to preserve error chain and exit code
+            raise
+        except (CLIError, InvalidJSONError, SchemaFileError) as e:
+            handle_error(e)
+            sys.exit(
+                e.exit_code
+                if hasattr(e, "exit_code")
+                else ExitCode.INTERNAL_ERROR
+            )
+        except click.UsageError as e:
+            handle_error(e)
+            sys.exit(ExitCode.USAGE_ERROR)
+        except Exception as e:
+            handle_error(e)
+            sys.exit(ExitCode.INTERNAL_ERROR)
         finally:
             loop.close()
-
-    except (
-        CLIError,
-        InvalidJSONError,
-        SchemaFileError,
-        SchemaValidationError,
-    ) as e:
-        handle_error(e)
-        sys.exit(
-            e.exit_code if hasattr(e, "exit_code") else ExitCode.INTERNAL_ERROR
-        )
-    except click.UsageError as e:
-        handle_error(e)
-        sys.exit(ExitCode.USAGE_ERROR)
-    except Exception as e:
-        handle_error(e)
-        sys.exit(ExitCode.INTERNAL_ERROR)
+    except KeyboardInterrupt:
+        logger.info("Operation cancelled by user")
+        raise
 
 
 # Remove the old @create_click_command() decorator and cli function definition
@@ -1596,6 +1610,7 @@ async def validate_inputs(
 
     Raises:
         CLIError: For various validation errors
+        SchemaValidationError: When schema is invalid
     """
     logger.debug("=== Input Validation Phase ===")
     security_manager = validate_security_manager(
@@ -1607,10 +1622,22 @@ async def validate_inputs(
     task_template = validate_task_template(
         args.get("task"), args.get("task_file")
     )
+
+    # Load and validate schema
     logger.debug("Validating schema from %s", args["schema_file"])
-    schema = validate_schema_file(
-        args["schema_file"], args.get("verbose", False)
-    )
+    try:
+        schema = validate_schema_file(
+            args["schema_file"], args.get("verbose", False)
+        )
+
+        # Validate schema structure before any model creation
+        validate_json_schema(
+            schema
+        )  # This will raise SchemaValidationError if invalid
+    except SchemaValidationError as e:
+        logger.error("Schema validation error: %s", str(e))
+        raise  # Re-raise the SchemaValidationError to preserve the error chain
+
     template_context = await create_template_context_from_args(
         args, security_manager
     )
@@ -1689,6 +1716,7 @@ async def validate_model_and_schema(
         ModelCreationError,
     ) as e:
         logger.error("Schema error: %s", str(e))
+        # Pass through the error without additional wrapping
         raise
 
     if not supports_structured_output(args["model"]):
@@ -1834,19 +1862,21 @@ async def execute_model(
 async def run_cli_async(args: CLIParams) -> ExitCode:
     """Async wrapper for CLI operations.
 
+    Args:
+        args: CLI parameters.
+
     Returns:
-        Exit code to return from the CLI
+        Exit code.
 
     Raises:
-        CLIError: For various error conditions
-        KeyboardInterrupt: When operation is cancelled by user
+        CLIError: For errors during CLI operations.
     """
     try:
         # 0. Model Parameter Validation
         logger.debug("=== Model Parameter Validation ===")
         params = await validate_model_params(args)
 
-        # 1. Input Validation Phase
+        # 1. Input Validation Phase (includes schema validation)
         security_manager, task_template, schema, template_context, env = (
             await validate_inputs(args)
         )
@@ -1863,15 +1893,12 @@ async def run_cli_async(args: CLIParams) -> ExitCode:
             )
         )
 
-        # 4. Dry Run Output Phase
+        # 4. Dry Run Output Phase - Moved after all validations
         if args.get("dry_run", False):
             logger.info("\n=== Dry Run Summary ===")
+            # Only log success if we got this far (no validation errors)
             logger.info("✓ Template rendered successfully")
             logger.info("✓ Schema validation passed")
-            logger.info("✓ Model compatibility validated")
-            logger.info(
-                f"✓ Token count: {total_tokens}/{registry.get_capabilities(args['model']).context_window}"
-            )
 
             if args.get("verbose", False):
                 logger.info("\nSystem Prompt:")
@@ -1881,6 +1908,7 @@ async def run_cli_async(args: CLIParams) -> ExitCode:
                 logger.info("-" * 40)
                 logger.info(user_prompt)
 
+            # Return success only if we got here (no validation errors)
             return ExitCode.SUCCESS
 
         # 5. Execution Phase
@@ -1891,6 +1919,10 @@ async def run_cli_async(args: CLIParams) -> ExitCode:
     except KeyboardInterrupt:
         logger.info("Operation cancelled by user")
         raise
+    except SchemaValidationError as e:
+        # Ensure schema validation errors are properly propagated with the correct exit code
+        logger.error("Schema validation error: %s", str(e))
+        raise  # Re-raise the SchemaValidationError to preserve the error chain
     except Exception as e:
         if isinstance(e, CLIError):
             raise  # Let our custom errors propagate
@@ -1941,254 +1973,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()