ostruct-cli 0.2.0__py3-none-any.whl → 0.4.0__py3-none-any.whl

ostruct/cli/errors.py

@@ -1,13 +1,50 @@
 """Custom error classes for CLI error handling."""
 
-from pathlib import Path
-from typing import List, Optional
+import logging
+from typing import Any, Dict, List, Optional, TextIO, cast
 
+import click
 
-class CLIError(Exception):
+from .security.errors import PathSecurityError as SecurityPathSecurityError
+
+logger = logging.getLogger(__name__)
+
+
+class CLIError(click.ClickException):
     """Base class for all CLI errors."""
 
-    pass
+    def __init__(self, message: str, context: Optional[Dict[str, Any]] = None):
+        super().__init__(message)
+        self.context = context or {}
+        self._has_been_logged = False  # Use underscore for private attribute
+
+    @property
+    def has_been_logged(self) -> bool:
+        """Whether this error has been logged."""
+        return self._has_been_logged
+
+    @has_been_logged.setter
+    def has_been_logged(self, value: bool) -> None:
+        """Set whether this error has been logged."""
+        self._has_been_logged = value
+
+    def show(self, file: Optional[TextIO] = None) -> None:
+        """Show the error message with optional context."""
+        if file is None:
+            file = cast(TextIO, click.get_text_stream("stderr"))
+
+        # Format message with context if available
+        if self.context:
+            context_str = "\n".join(
+                f"  {k}: {v}" for k, v in self.context.items()
+            )
+            click.secho(
+                f"Error: {self.message}\nContext:\n{context_str}",
+                fg="red",
+                file=file,
+            )
+        else:
+            click.secho(f"Error: {self.message}", fg="red", file=file)
 
 
 class VariableError(CLIError):
@@ -28,217 +65,134 @@ class VariableValueError(VariableError):
     pass
 
 
-class InvalidJSONError(VariableError):
+class InvalidJSONError(CLIError):
     """Raised when JSON parsing fails for a variable value."""
 
-    pass
+    def __init__(
+        self,
+        message: str,
+        source: Optional[str] = None,
+        context: Optional[Dict[str, Any]] = None,
+    ):
+        context = context or {}
+        if source:
+            context["source"] = source
+        super().__init__(message, context)
 
 
 class PathError(CLIError):
     """Base class for path-related errors."""
 
-    pass
+    def __init__(
+        self, message: str, path: str, context: Optional[Dict[str, Any]] = None
+    ):
+        context = context or {}
+        context["path"] = path
+        super().__init__(message, context)
 
 
 class FileNotFoundError(PathError):
     """Raised when a specified file does not exist."""
 
-    pass
+    def __init__(self, path: str, context: Optional[Dict[str, Any]] = None):
+        # Use path directly as the message without prepending "File not found: "
+        super().__init__(path, path, context)
 
 
-class DirectoryNotFoundError(PathError):
-    """Raised when a specified directory does not exist."""
-
-    pass
+class FileReadError(PathError):
+    """Raised when a file cannot be read or decoded.
 
-
-class PathSecurityError(Exception):
-    """Exception raised when file access is denied due to security constraints.
-
-    Attributes:
-        message: The error message with full context
-        error_logged: Whether this error has already been logged
-        wrapped: Whether this error has been wrapped by another error
+    This is a wrapper exception that preserves the original cause (FileNotFoundError,
+    UnicodeDecodeError, etc) while providing a consistent interface for error handling.
     """
 
     def __init__(
-        self, message: str, error_logged: bool = False, wrapped: bool = False
-    ) -> None:
-        """Initialize PathSecurityError.
-
-        Args:
-            message: Detailed error message with context
-            error_logged: Whether this error has already been logged
-            wrapped: Whether this error has been wrapped by another error
-        """
-        super().__init__(message)
-        self.error_logged = error_logged
-        self.message = message
-        self.wrapped = wrapped
+        self, message: str, path: str, context: Optional[Dict[str, Any]] = None
+    ):
+        super().__init__(message, path, context)
 
-    @property
-    def has_been_logged(self) -> bool:
-        """Check if this error has been logged, more readable than accessing error_logged directly."""
-        return self.error_logged
 
-    def __str__(self) -> str:
-        """Get string representation of the error."""
-        return self.message
-
-    @classmethod
-    def access_denied(
-        cls,
-        path: Path,
-        reason: Optional[str] = None,
-        error_logged: bool = False,
-    ) -> "PathSecurityError":
-        """Create access denied error.
+class DirectoryNotFoundError(PathError):
+    """Raised when a specified directory does not exist."""
 
-        Args:
-            path: Path that was denied
-            reason: Optional reason for denial
-            error_logged: Whether this error has already been logged
+    def __init__(self, path: str, context: Optional[Dict[str, Any]] = None):
+        # Use path directly as the message without prepending "Directory not found: "
+        super().__init__(path, path, context)
 
-        Returns:
-            PathSecurityError with standardized message
-        """
-        msg = f"Access denied: {path}"
-        if reason:
-            msg += f" - {reason}"
-        return cls(msg, error_logged=error_logged)
-
-    @classmethod
-    def outside_allowed(
-        cls,
-        path: Path,
-        base_dir: Optional[Path] = None,
-        error_logged: bool = False,
-    ) -> "PathSecurityError":
-        """Create error for path outside allowed directories.
 
-        Args:
-            path: Path that was outside
-            base_dir: Optional base directory for context
-            error_logged: Whether this error has already been logged
+class PathSecurityError(CLIError, SecurityPathSecurityError):
+    """CLI wrapper for security package's PathSecurityError.
 
-        Returns:
-            PathSecurityError with standardized message
-        """
-        parts = [
-            f"Access denied: {path} is outside base directory and not in allowed directories"
-        ]
-        if base_dir:
-            parts.append(f"Base directory: {base_dir}")
-        parts.append(
-            "Use --allowed-dir to specify additional allowed directories"
-        )
-        return cls("\n".join(parts), error_logged=error_logged)
+    This class bridges the security package's error handling with the CLI's
+    error handling system, providing both sets of functionality.
+    """
 
-    @classmethod
-    def traversal_attempt(
-        cls, path: Path, error_logged: bool = False
-    ) -> "PathSecurityError":
-        """Create error for directory traversal attempt.
+    def __init__(
+        self,
+        message: str,
+        path: Optional[str] = None,
+        context: Optional[Dict[str, Any]] = None,
+        error_logged: bool = False,
+    ):
+        """Initialize both parent classes properly.
 
         Args:
-            path: Path that attempted traversal
-            error_logged: Whether this error has already been logged
-
-        Returns:
-            PathSecurityError with standardized message
+            message: The error message
+            path: The path that caused the error
+            context: Additional context about the error
+            error_logged: Whether this error has been logged
         """
-        return cls(
-            f"Access denied: {path} - directory traversal not allowed",
+        # Initialize security error first
+        SecurityPathSecurityError.__init__(
+            self,
+            message,
+            path=path or "",
+            context=context,
             error_logged=error_logged,
         )
-
-    @classmethod
-    def from_expanded_paths(
-        cls,
-        original_path: str,
-        expanded_path: str,
-        base_dir: Optional[str] = None,
-        allowed_dirs: Optional[List[str]] = None,
-        error_logged: bool = False,
-    ) -> "PathSecurityError":
-        """Create error with expanded path context.
-
-        Args:
-            original_path: Original path as provided by user
-            expanded_path: Expanded absolute path
-            base_dir: Optional base directory
-            allowed_dirs: Optional list of allowed directories
-            error_logged: Whether this error has already been logged
-
-        Returns:
-            PathSecurityError with detailed path context
-        """
-        parts = [
-            f"Access denied: {original_path} is outside base directory and not in allowed directories",
-            f"File absolute path: {expanded_path}",
-        ]
-        if base_dir:
-            parts.append(f"Base directory: {base_dir}")
-        if allowed_dirs:
-            parts.append(f"Allowed directories: {allowed_dirs}")
-        parts.append(
-            "Use --allowed-dir to specify additional allowed directories"
+        # Initialize CLI error with the same context
+        CLIError.__init__(self, message, context=self.context)
+        # Ensure error_logged state is consistent
+        self._has_been_logged = error_logged
+        logger.debug(
+            "Created CLI PathSecurityError with message=%r, path=%r, context=%r, error_logged=%r",
+            message,
+            path,
+            self.context,
+            error_logged,
         )
-        return cls("\n".join(parts), error_logged=error_logged)
 
-    def format_with_context(
-        self,
-        original_path: Optional[str] = None,
-        expanded_path: Optional[str] = None,
-        base_dir: Optional[str] = None,
-        allowed_dirs: Optional[List[str]] = None,
-    ) -> str:
-        """Format error message with additional context.
+    def show(self, file: Optional[TextIO] = None) -> None:
+        """Show the error with CLI formatting."""
+        logger.debug("Showing error with context: %r", self.context)
+        super().show(file)
 
-        Args:
-            original_path: Optional original path as provided by user
-            expanded_path: Optional expanded absolute path
-            base_dir: Optional base directory
-            allowed_dirs: Optional list of allowed directories
+    @property
+    def has_been_logged(self) -> bool:
+        """Whether this error has been logged."""
+        return self._has_been_logged or super().has_been_logged
 
-        Returns:
-            Formatted error message with context
-        """
-        parts = [self.message]
-        if original_path and expanded_path and original_path != expanded_path:
-            parts.append(f"Original path: {original_path}")
-            parts.append(f"Expanded path: {expanded_path}")
-        if base_dir:
-            parts.append(f"Base directory: {base_dir}")
-        if allowed_dirs:
-            parts.append(f"Allowed directories: {allowed_dirs}")
-        if not any(
-            p.endswith(
-                "Use --allowed-dir to specify additional allowed directories"
-            )
-            for p in parts
-        ):
-            parts.append(
-                "Use --allowed-dir to specify additional allowed directories"
-            )
-        return "\n".join(parts)
+    @has_been_logged.setter
+    def has_been_logged(self, value: bool) -> None:
+        """Set whether this error has been logged."""
+        self._has_been_logged = value
+        super().has_been_logged = value  # type: ignore[misc]
 
-    @classmethod
-    def wrap_error(
-        cls, context: str, original: "PathSecurityError"
-    ) -> "PathSecurityError":
-        """Wrap an error with additional context while preserving attributes.
+    @property
+    def error_logged(self) -> bool:
+        """Whether this error has been logged (alias for has_been_logged)."""
+        return self.has_been_logged
 
-        Args:
-            context: Additional context to add to the error message
-            original: The original PathSecurityError to wrap
+    @error_logged.setter
+    def error_logged(self, value: bool) -> None:
+        """Set whether this error has been logged (alias for has_been_logged)."""
+        self.has_been_logged = value
 
-        Returns:
-            PathSecurityError with additional context and preserved attributes
-        """
-        base_message = str(original)
-        message = f"{context}: {base_message}"
-        return cls(message, error_logged=original.error_logged, wrapped=True)
+    def __str__(self) -> str:
+        """Format the error message with context."""
+        msg = SecurityPathSecurityError.__str__(self)
+        logger.debug("Formatted error message: %r", msg)
+        return msg
 
 
 class TaskTemplateError(CLIError):
@@ -277,19 +231,37 @@ class SchemaError(CLIError):
     pass
 
 
-class SchemaFileError(SchemaError):
+class SchemaFileError(CLIError):
     """Raised when a schema file is invalid or inaccessible."""
 
-    pass
+    def __init__(
+        self,
+        message: str,
+        schema_path: Optional[str] = None,
+        context: Optional[Dict[str, Any]] = None,
+    ):
+        context = context or {}
+        if schema_path:
+            context["schema_path"] = schema_path
+        super().__init__(message, context)
 
 
-class SchemaValidationError(SchemaError):
+class SchemaValidationError(CLIError):
     """Raised when a schema fails validation."""
 
-    pass
+    def __init__(
+        self,
+        message: str,
+        schema_path: Optional[str] = None,
+        context: Optional[Dict[str, Any]] = None,
+    ):
+        context = context or {}
+        if schema_path:
+            context["schema_path"] = schema_path
+        super().__init__(message, context)
 
 
-class ModelCreationError(SchemaError):
+class ModelCreationError(CLIError):
     """Base class for model creation errors."""
 
     pass
@@ -327,3 +299,82 @@ class ModelValidationError(ModelCreationError):
             f"Model '{model_name}' validation failed:\n"
             + "\n".join(validation_errors)
         )
+
+
+class ModelNotSupportedError(CLIError):
+    """Exception raised when a model doesn't support structured output."""
+
+    pass
+
+
+class ModelVersionError(CLIError):
+    """Exception raised when a model version is not supported."""
+
+    pass
+
+
+class StreamInterruptedError(CLIError):
+    """Exception raised when a stream is interrupted."""
+
+    pass
+
+
+class StreamBufferError(CLIError):
+    """Exception raised when there's an error with the stream buffer."""
+
+    pass
+
+
+class StreamParseError(CLIError):
+    """Exception raised when there's an error parsing the stream."""
+
+    pass
+
+
+class APIResponseError(CLIError):
+    """Exception raised when there's an error with the API response."""
+
+    pass
+
+
+class EmptyResponseError(CLIError):
+    """Exception raised when the API returns an empty response."""
+
+    pass
+
+
+class InvalidResponseFormatError(CLIError):
+    """Exception raised when the API response format is invalid."""
+
+    pass
+
+
+class OpenAIClientError(CLIError):
+    """Exception raised when there's an error with the OpenAI client."""
+
+    pass
+
+
+# Export public API
+__all__ = [
+    "CLIError",
+    "VariableError",
+    "PathError",
+    "PathSecurityError",
+    "FileNotFoundError",
+    "FileReadError",
+    "DirectoryNotFoundError",
+    "SchemaValidationError",
+    "SchemaFileError",
+    "InvalidJSONError",
+    "ModelCreationError",
+    "ModelNotSupportedError",
+    "ModelVersionError",
+    "StreamInterruptedError",
+    "StreamBufferError",
+    "StreamParseError",
+    "APIResponseError",
+    "EmptyResponseError",
+    "InvalidResponseFormatError",
+    "OpenAIClientError",
+]