ostruct-cli 0.7.2__py3-none-any.whl → 0.8.0__py3-none-any.whl

ostruct/cli/model_creation.py

@@ -26,6 +26,7 @@ from pydantic import (
     ConfigDict,
     EmailStr,
     Field,
+    RootModel,
     ValidationError,
     create_model,
 )
@@ -159,6 +160,96 @@ def _get_type_with_constraints(
 
     field_type = field_schema.get("type")
 
+    # Handle union types (e.g., ["string", "null"])
+    if isinstance(field_type, list):
+        union_types: List[Type[Any]] = []
+        base_type: Type[Any] = str  # Default base type for constraints
+
+        for type_name in field_type:
+            if type_name == "string":
+                base_type = str
+                union_types.append(str)
+            elif type_name == "integer":
+                base_type = int
+                union_types.append(int)
+            elif type_name == "number":
+                base_type = float
+                union_types.append(float)
+            elif type_name == "boolean":
+                base_type = bool
+                union_types.append(bool)
+            elif type_name == "null":
+                union_types.append(type(None))
+            elif type_name == "object":
+                # For object unions, we'd need more complex handling
+                base_type = dict
+                union_types.append(dict)
+            elif type_name == "array":
+                # For array unions, we'd need more complex handling
+                base_type = list
+                union_types.append(list)
+
+        if len(union_types) == 1:
+            # Single type, use it directly
+            field_type_cls: Any = union_types[0]
+        else:
+            # Create union type
+            field_type_cls = Union[tuple(union_types)]
+
+        # Apply constraints based on the base type (non-null type)
+        if base_type == 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":
+                    # For union with null, we need Optional[datetime]
+                    if type(None) in union_types:
+                        field_type_cls = Union[datetime, type(None)]
+                    else:
+                        field_type_cls = datetime
+                elif field_schema["format"] == "date":
+                    if type(None) in union_types:
+                        field_type_cls = Union[date, type(None)]
+                    else:
+                        field_type_cls = date
+                elif field_schema["format"] == "time":
+                    if type(None) in union_types:
+                        field_type_cls = Union[time, type(None)]
+                    else:
+                        field_type_cls = time
+                elif field_schema["format"] == "email":
+                    if type(None) in union_types:
+                        field_type_cls = Union[EmailStr, type(None)]
+                    else:
+                        field_type_cls = EmailStr
+                elif field_schema["format"] == "uri":
+                    if type(None) in union_types:
+                        field_type_cls = Union[AnyUrl, type(None)]
+                    else:
+                        field_type_cls = AnyUrl
+
+        elif base_type in (int, 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))
+
     # Handle array type
     if field_type == "array":
         items_schema = field_schema.get("items", {})
@@ -218,7 +309,7 @@ def _get_type_with_constraints(
 
     # Handle other types
     if field_type == "string":
-        field_type_cls: Type[Any] = str
+        field_type_cls = str
 
         # Add string-specific constraints to field_kwargs
         if "pattern" in field_schema:
@@ -319,6 +410,64 @@ def create_dynamic_model(
 
         validate_json_schema(schema)
 
+        # Handle top-level array schemas
+        if schema.get("type") == "array":
+            items_schema = schema.get("items", {})
+            if items_schema.get("type") == "object":
+                # Create the item model first
+                item_model = create_dynamic_model(
+                    items_schema,
+                    base_name=f"{base_name}Item",
+                    show_schema=show_schema,
+                    debug_validation=debug_validation,
+                )
+
+                # Return a RootModel that validates a list of the item model
+                class ArrayModel(RootModel[List[Any]]):
+                    model_config = ConfigDict(
+                        str_strip_whitespace=True,
+                        validate_assignment=True,
+                        use_enum_values=True,
+                    )
+
+                    def __init__(self, root: List[Any]) -> None:
+                        # Validate each item against the item model
+                        validated_items = []
+                        for item in root:
+                            if isinstance(item, dict):
+                                validated_items.append(
+                                    item_model.model_validate(item)
+                                )
+                            else:
+                                validated_items.append(
+                                    item_model.model_validate(item)
+                                )
+                        super().__init__(validated_items)
+
+                ArrayModel.__name__ = f"{base_name}List"
+                return ArrayModel
+            else:
+                # Handle array of primitives
+                item_type_map = {
+                    "string": str,
+                    "integer": int,
+                    "number": float,
+                    "boolean": bool,
+                }
+                # Get item type (not used in generic due to MyPy limitations)
+                item_type_map.get(items_schema.get("type", "string"), str)
+
+                # Use Any for the generic type to avoid MyPy issues with dynamic types
+                class PrimitiveArrayModel(RootModel[List[Any]]):
+                    model_config = ConfigDict(
+                        str_strip_whitespace=True,
+                        validate_assignment=True,
+                        use_enum_values=True,
+                    )
+
+                PrimitiveArrayModel.__name__ = f"{base_name}List"
+                return PrimitiveArrayModel
+
         # Process schema properties into fields
         properties = schema.get("properties", {})
         required = schema.get("required", [])

ostruct/cli/model_validation.py

@@ -0,0 +1,204 @@
+"""Model validation utilities for ostruct CLI."""
+
+import logging
+from typing import Any, Dict, List, Optional, Tuple, Type
+
+from openai_model_registry import (
+    ModelNotSupportedError,
+    ModelRegistry,
+    ParameterNotSupportedError,
+    ParameterValidationError,
+)
+from pydantic import BaseModel
+
+from .errors import (
+    CLIError,
+    InvalidJSONError,
+    ModelCreationError,
+    SchemaFileError,
+    SchemaValidationError,
+)
+from .exit_codes import ExitCode
+from .model_creation import create_dynamic_model
+from .schema_utils import supports_structured_output
+from .token_validation import validate_token_limits
+from .types import CLIParams
+
+logger = logging.getLogger(__name__)
+
+
+def validate_model_parameters(model: str, params: Dict[str, Any]) -> None:
+    """Validate model parameters against model capabilities.
+
+    Args:
+        model: The model name to validate parameters for
+        params: Dictionary of parameter names and values to validate
+
+    Raises:
+        CLIError: If parameters are invalid for the model
+    """
+    try:
+        registry = ModelRegistry.get_instance()
+        capabilities = registry.get_capabilities(model)
+
+        # Validate each parameter
+        for param_name, value in params.items():
+            try:
+                capabilities.validate_parameter(param_name, value)
+            except ParameterNotSupportedError as e:
+                raise CLIError(
+                    f"Parameter '{param_name}' not supported for model '{model}': {e}",
+                    exit_code=ExitCode.VALIDATION_ERROR,
+                ) from e
+            except ParameterValidationError as e:
+                raise CLIError(
+                    f"Invalid value for parameter '{param_name}' on model '{model}': {e}",
+                    exit_code=ExitCode.VALIDATION_ERROR,
+                ) from e
+
+    except ModelNotSupportedError as e:
+        raise CLIError(
+            f"Model '{model}' is not supported: {e}",
+            exit_code=ExitCode.VALIDATION_ERROR,
+        ) from e
+    except Exception as e:
+        logger.warning(
+            f"Could not validate parameters for model '{model}': {e}"
+        )
+        # Don't fail for unexpected validation errors
+
+
+async def validate_model_params(args: CLIParams) -> Dict[str, Any]:
+    """Validate model parameters and return a dictionary of valid parameters.
+
+    Args:
+        args: Command line arguments
+
+    Returns:
+        Dictionary of validated model parameters
+
+    Raises:
+        CLIError: If model parameters are invalid
+    """
+    params = {
+        "temperature": args.get("temperature"),
+        "max_output_tokens": args.get("max_output_tokens"),
+        "top_p": args.get("top_p"),
+        "frequency_penalty": args.get("frequency_penalty"),
+        "presence_penalty": args.get("presence_penalty"),
+        "reasoning_effort": args.get("reasoning_effort"),
+    }
+    # Remove None values
+    params = {k: v for k, v in params.items() if v is not None}
+    validate_model_parameters(args["model"], params)
+    return params
+
+
+async def validate_model_and_schema(
+    args: CLIParams,
+    schema: Dict[str, Any],
+    system_prompt: str,
+    user_prompt: str,
+    template_context: Dict[str, Any],
+) -> Tuple[
+    Type[BaseModel], List[Dict[str, str]], int, Optional[ModelRegistry]
+]:
+    """Validate model compatibility and schema, and check token limits.
+
+    Args:
+        args: Command line arguments
+        schema: Schema dictionary
+        system_prompt: Processed system prompt
+        user_prompt: Processed user prompt
+        template_context: Template context with file information
+
+    Returns:
+        Tuple of (output_model, messages, total_tokens, registry)
+
+    Raises:
+        CLIError: For validation errors
+        ModelCreationError: When model creation fails
+        SchemaValidationError: When schema is invalid
+        PromptTooLargeError: When prompt exceeds context window with actionable guidance
+    """
+    logger.debug("=== Model & Schema Validation Phase ===")
+    try:
+        output_model = create_dynamic_model(
+            schema,
+            show_schema=args.get("show_model_schema", False),
+            debug_validation=args.get("debug_validation", False),
+        )
+        logger.debug("Successfully created output model")
+    except (
+        SchemaFileError,
+        InvalidJSONError,
+        SchemaValidationError,
+        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"]):
+        msg = f"Model {args['model']} does not support structured output"
+        logger.error(msg)
+        raise ModelNotSupportedError(msg)
+
+    messages = [
+        {"role": "system", "content": system_prompt},
+        {"role": "user", "content": user_prompt},
+    ]
+
+    # Token validation - extract file paths from FileInfo objects
+    files = template_context.get("files", [])
+    file_paths = [str(f.path) if hasattr(f, "path") else str(f) for f in files]
+    combined_template_content = system_prompt + user_prompt
+    validate_token_limits(combined_template_content, file_paths, args["model"])
+
+    # For now, simplified token counting - the full implementation needs more imports
+    total_tokens = len(system_prompt) + len(user_prompt)  # Rough estimate
+    registry = ModelRegistry.get_instance()
+
+    return output_model, messages, total_tokens, registry
+
+
+def supports_web_search(model: str) -> bool:
+    """Check if model supports web search capabilities.
+
+    Args:
+        model: The model name to check
+
+    Returns:
+        True if the model supports web search, False otherwise
+    """
+    try:
+        registry = ModelRegistry.get_instance()
+        capabilities = registry.get_capabilities(model)
+        return getattr(capabilities, "supports_web_search", False)
+    except Exception:
+        # Default to False for safety if we can't determine support
+        return False
+
+
+def validate_web_search_compatibility(
+    model: str, web_search_enabled: bool
+) -> Optional[str]:
+    """Validate web search compatibility and return warning message if needed.
+
+    Args:
+        model: The model name to validate
+        web_search_enabled: Whether web search is enabled
+
+    Returns:
+        Warning message if there's a compatibility issue, None otherwise
+    """
+    if not web_search_enabled:
+        return None
+
+    if not supports_web_search(model):
+        return (
+            f"Model '{model}' does not support web search capabilities. "
+            f"Consider using a compatible model like 'gpt-4o', 'gpt-4.1', or an O-series model."
+        )
+
+    return None