ara-cli 0.1.9.95__py3-none-any.whl → 0.1.10.0__py3-none-any.whl

ara_cli/commands/extract_command.py

@@ -3,20 +3,13 @@ from ara_cli.prompt_extractor import extract_responses
 import os
 
 class ExtractCommand(Command):
-    def __init__(self, file_name, force=False, write=False, output=None, error_output=None):
+    def __init__(self, file_name, force=False, write=False, output=None):
         self.file_name = file_name
         self.force = force
         self.write = write
         self.output = output    # Callable for standard output (optional)
-        self.error_output = error_output  # Callable for errors (optional)
 
     def execute(self, *args, **kwargs):
-        try:
-            extract_responses(self.file_name, True, force=self.force, write=self.write)
-            if self.output:
-                self.output("End of extraction")
-        except Exception as e:
-            if self.error_output:
-                self.error_output(f"Extraction failed: {e}")
-            else:
-                raise
+        extract_responses(self.file_name, True, force=self.force, write=self.write)
+        if self.output:
+            self.output("End of extraction")

ara_cli/error_handler.py

@@ -0,0 +1,134 @@
+import sys
+import traceback
+from typing import Optional
+from enum import Enum
+from functools import wraps
+
+
+RED = '\033[91m'
+RESET = '\033[0m'
+
+
+class ErrorLevel(Enum):
+    INFO = "INFO"
+    WARNING = "WARNING"
+    ERROR = "ERROR"
+    CRITICAL = "CRITICAL"
+
+
+class AraError(Exception):
+    """Base exception class for ARA CLI errors"""
+
+    def __init__(
+        self, message: str, error_code: int = 1, level: ErrorLevel = ErrorLevel.ERROR
+    ):
+        self.message = message
+        self.error_code = error_code
+        self.level = level
+        super().__init__(self.message)
+
+
+class AraValidationError(AraError):
+    """Raised when validation fails"""
+
+    def __init__(self, message: str):
+        super().__init__(message, error_code=2, level=ErrorLevel.ERROR)
+
+
+class AraConfigurationError(AraError):
+    """Raised when configuration is invalid"""
+
+    def __init__(self, message: str):
+        super().__init__(message, error_code=4, level=ErrorLevel.ERROR)
+
+
+class ErrorHandler:
+    """Centralized error handler for ARA CLI"""
+
+    def __init__(self, debug_mode: bool = False):
+        self.debug_mode = debug_mode
+
+    def handle_error(self, error: Exception, context: Optional[str] = None) -> None:
+        """Handle any error with standardized output"""
+        if isinstance(error, AraError):
+            self._handle_ara_error(error, context)
+        else:
+            self._handle_generic_error(error, context)
+
+    def _handle_ara_error(self, error: AraError, context: Optional[str] = None) -> None:
+        """Handle ARA-specific errors"""
+        self._report_ara_error(error, context)
+
+        sys.exit(error.error_code)
+
+    def _handle_generic_error(
+        self, error: Exception, context: Optional[str] = None
+    ) -> None:
+        """Handle generic Python errors"""
+        self._report_generic_error(error, context)
+
+        sys.exit(1)
+
+
+    def report_error(self, error: Exception, context: Optional[str] = None) -> None:
+        """Report error with standardized formatting but don't exit"""
+        if isinstance(error, AraError):
+            self._report_ara_error(error, context)
+        else:
+            self._report_generic_error(error, context)
+
+
+    def _report_ara_error(self, error: AraError, context: Optional[str] = None) -> None:
+        """Report ARA-specific errors without exiting"""
+        error_prefix = f"[{error.level.value}]"
+
+        if context:
+            print(f"{RED}{error_prefix} {context}: {error.message}{RESET}", file=sys.stderr)
+        else:
+            print(f"{RED}{error_prefix} {error.message}{RESET}", file=sys.stderr)
+
+        if self.debug_mode:
+            traceback.print_exc()
+
+
+    def _report_generic_error(self, error: Exception, context: Optional[str] = None) -> None:
+        """Report generic Python errors without exiting"""
+        error_type = type(error).__name__
+
+        if context:
+            print(f"{RED}[ERROR] {context}: {error_type}: {str(error)}{RESET}", file=sys.stderr)
+        else:
+            print(f"{RED}[ERROR] {error_type}: {str(error)}{RESET}", file=sys.stderr)
+
+        if self.debug_mode:
+            traceback.print_exc()
+
+
+    def validate_and_exit(
+        self, condition: bool, message: str, error_code: int = 1
+    ) -> None:
+        """Validate condition and exit with error if false"""
+        if not condition:
+            raise AraValidationError(message)
+
+
+def handle_errors(_func=None, context: Optional[str] = None, error_handler: Optional[ErrorHandler] = None):
+    """Decorator to handle errors in action functions"""
+
+    def decorator(func):
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            nonlocal error_handler
+            if error_handler is None:
+                error_handler = ErrorHandler()
+
+            try:
+                return func(*args, **kwargs)
+            except Exception as e:
+                error_handler.handle_error(e, context or func.__name__)
+
+        return wrapper
+
+    if callable(_func):
+        return decorator(_func)
+    return decorator

ara_cli/file_classifier.py

@@ -1,3 +1,4 @@
+from . import error_handler
 from ara_cli.classifier import Classifier
 from ara_cli.artefact_models.artefact_model import Artefact
 from ara_cli.artefact_fuzzy_search import find_closest_name_matches
@@ -33,8 +34,8 @@ class FileClassifier:
                     if byte > 127:
                         return True
         except Exception as e:
-            # Handle unexpected errors while reading the file in binary mode
-            print(f"Error while checking if file is binary: {e}")
+            error_handler.report_error(e, "checking if file is binary")
+            # print(f"Error while checking if file is binary: {e}")
         return False
 
     def read_file_with_fallback(self, file_path):

ara_cli/prompt_extractor.py

@@ -17,7 +17,7 @@ def extract_code_blocks_md(markdown_text):
 
 
 def extract_responses(document_path, relative_to_ara_root=False, force=False, write=False):
-    print(f"Debug: Starting extraction from {document_path}")
+    print(f"Starting extraction from '{document_path}'")
     block_extraction_counter = 0
 
     with open(document_path, 'r', encoding='utf-8', errors='replace') as file: