ostruct-cli 0.5.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."""
 
@@ -106,6 +159,9 @@ class CLIParams(TypedDict, total=False):
     dir: List[
         Tuple[str, str]
     ]  # List of (name, dir) tuples from Click's nargs=2
+    patterns: List[
+        Tuple[str, str]
+    ]  # List of (name, pattern) tuples from Click's nargs=2
     allowed_dirs: List[str]
     base_dir: str
     allowed_dir_file: Optional[str]
@@ -182,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)
@@ -796,7 +846,7 @@ 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, schema_path=path)
+        raise SchemaValidationError(msg, context={"path": path})
 
     # Validate schema structure
     if "schema" in schema:
@@ -806,7 +856,7 @@ 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, schema_path=path)
+            raise SchemaValidationError(msg, context={"path": path})
         if verbose:
             logger.debug("Inner schema validated successfully")
             logger.debug(
@@ -821,7 +871,7 @@ 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, schema_path=path)
+        raise SchemaValidationError(msg, context={"path": path})
 
     # Return the full schema including wrapper
     return schema
@@ -845,20 +895,22 @@ def collect_template_files(
         ValueError: If file mappings are invalid or files cannot be accessed
     """
     try:
-        # Get files and directories from args - they are already tuples from Click's nargs=2
+        # Get files, directories, and patterns from args - they are already tuples from Click's nargs=2
         files = list(
             args.get("files", [])
         )  # List of (name, path) tuples from Click
         dirs = args.get("dir", [])  # List of (name, dir) tuples from Click
+        patterns = args.get(
+            "patterns", []
+        )  # List of (name, pattern) tuples from Click
 
-        # Collect files from directories
+        # Collect files from directories and patterns
         dir_files = collect_files(
-            file_mappings=cast(
-                List[Tuple[str, Union[str, Path]]], files
-            ),  # Cast to correct type
-            dir_mappings=cast(
-                List[Tuple[str, Union[str, Path]]], dirs
-            ),  # Cast to correct type
+            file_mappings=cast(List[Tuple[str, Union[str, Path]]], files),
+            dir_mappings=cast(List[Tuple[str, Union[str, Path]]], dirs),
+            pattern_mappings=cast(
+                List[Tuple[str, Union[str, Path]]], patterns
+            ),
             dir_recursive=args.get("recursive", False),
             security_manager=security_manager,
         )
@@ -872,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):
@@ -975,53 +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 direct inputs.
-
-    Args:
-        files: Optional dictionary mapping names to FileInfoList objects
-        variables: Optional dictionary of simple string variables
-        json_variables: Optional dictionary of JSON variables
-        security_manager: Optional security manager for path validation
-        stdin_content: Optional content to use for stdin
-
-    Returns:
-        Template context dictionary
-
-    Raises:
-        PathSecurityError: If any file paths violate security constraints
-        VariableError: If variable mappings are invalid
-    """
-    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,
@@ -1076,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):
@@ -1207,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.
 
@@ -1413,15 +1389,37 @@ async def stream_structured_output(
         ):
             yield chunk
 
+    except APIResponseError as e:
+        if "Invalid schema for response_format" in str(
+            e
+        ) and 'type: "array"' in str(e):
+            error_msg = (
+                "OpenAI API Schema Error: The schema must have a root type of 'object', not 'array'. "
+                "To fix this:\n"
+                "1. Wrap your array in an object property, e.g.:\n"
+                "   {\n"
+                '     "type": "object",\n'
+                '     "properties": {\n'
+                '       "items": {\n'
+                '         "type": "array",\n'
+                '         "items": { ... your array items schema ... }\n'
+                "       }\n"
+                "     }\n"
+                "   }\n"
+                "2. Make sure to update your template to handle the wrapper object."
+            )
+            logger.error(error_msg)
+            raise InvalidResponseFormatError(error_msg)
+        logger.error(f"API error: {e}")
+        raise
     except (
         StreamInterruptedError,
         StreamBufferError,
         StreamParseError,
-        APIResponseError,
         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
@@ -1763,8 +1761,7 @@ async def execute_model(
             user_prompt=user_prompt,
             output_schema=output_model,
             output_file=args.get("output_file"),
-            **params,  # Only pass validated model parameters
-            on_log=log_callback,  # Pass logging callback separately
+            on_log=log_callback,
         ):
             output_buffer.append(response)
 
@@ -1930,257 +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
-    """
-    if debug_validation:
-        logger.info("Creating dynamic model from schema:")
-        logger.info(json.dumps(schema, indent=2))
-
-    try:
-        # Extract required fields
-        required: Set[str] = set(schema.get("required", []))
-
-        # 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
-
-        # Ensure schema has type field
-        if "type" not in schema:
-            if debug_validation:
-                logger.info("Schema missing type field, assuming object type")
-            schema["type"] = "object"
-
-        # For non-object root schemas, create a wrapper model
-        if schema["type"] != "object":
-            if debug_validation:
-                logger.info(
-                    "Converting non-object root schema to object wrapper"
-                )
-            schema = {
-                "type": "object",
-                "properties": {"value": schema},
-                "required": ["value"],
-            }
-
-        # Create model configuration
-        config = ConfigDict(
-            title=schema.get("title", base_name),
-            extra=(
-                "forbid"
-                if schema.get("additionalProperties") is False
-                else "allow"
-            ),
-            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:
-            if debug_validation:
-                logger.error("Schema validation failed:")
-                logger.error("  Error type: %s", type(e).__name__)
-                logger.error("  Error message: %s", str(e))
-            validation_errors = (
-                [str(err) for err in e.errors()]
-                if hasattr(e, "errors")
-                else [str(e)]
-            )
-            raise ModelValidationError(base_name, validation_errors)
-
-        return model
-
-    except Exception as e:
-        if debug_validation:
-            logger.error("Failed to create model:")
-            logger.error("  Error type: %s", type(e).__name__)
-            logger.error("  Error message: %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__)),
-                )
-        raise ModelCreationError(
-            f"Failed to create model '{base_name}': {str(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()