crackerjack 0.37.9__py3-none-any.whl → 0.45.2__py3-none-any.whl

crackerjack/core/timeout_manager.py

@@ -129,6 +129,157 @@ class AsyncTimeoutManager:
                 self._performance_monitor = _DummyPerformanceMonitor()
         return self._performance_monitor
 
+    def _handle_operation_success(self, operation: str, start_time: float) -> float:
+        """Handle successful operation completion."""
+        self.performance_monitor.record_operation_success(operation, start_time)
+        elapsed = time.time() - start_time
+        self._record_success(operation, elapsed)
+        return elapsed
+
+    def _handle_timeout_error(
+        self,
+        operation: str,
+        start_time: float,
+        timeout_value: float,
+        strategy: TimeoutStrategy,
+        error_msg: str = "",
+        error_type: str = "custom_timeout",
+    ) -> float | None:
+        """Handle timeout error based on strategy."""
+        elapsed = time.time() - start_time
+        self.performance_monitor.record_operation_timeout(
+            operation, start_time, timeout_value, error_msg
+        )
+        self._record_failure(operation, elapsed)
+
+        if strategy == TimeoutStrategy.CIRCUIT_BREAKER:
+            self._update_circuit_breaker(operation, False)
+
+        if strategy == TimeoutStrategy.GRACEFUL_DEGRADATION:
+            logger.warning(
+                f"Operation {operation} {error_type} ({elapsed: .1f}s), continuing gracefully"
+            )
+            return elapsed  # Return elapsed time to indicate graceful degradation
+
+        return None
+
+    @asynccontextmanager
+    async def _execute_with_timeout_context(self, timeout_value: float):
+        """Execute the context with timeout handling."""
+        try:
+            async with asyncio.timeout(timeout_value):
+                yield
+        except AttributeError:
+            task = asyncio.current_task()
+            if task:
+                try:
+                    await asyncio.wait_for(asyncio.shield(task), timeout=timeout_value)
+                    yield
+                except builtins.TimeoutError:
+                    raise TimeoutError("operation", timeout_value)
+            else:
+                yield
+
+    def _should_yield_on_graceful_degradation(self, result: float | None) -> bool:
+        """Check if graceful degradation should yield."""
+        return result is not None
+
+    def _handle_custom_timeout_exception(
+        self,
+        operation: str,
+        start_time: float,
+        timeout_value: float,
+        strategy: TimeoutStrategy,
+        error: TimeoutError,
+    ) -> float | None:
+        """Handle custom TimeoutError exception."""
+        return self._handle_timeout_error(
+            operation, start_time, timeout_value, strategy, str(error), "timed out"
+        )
+
+    def _handle_asyncio_timeout_exception(
+        self,
+        operation: str,
+        start_time: float,
+        timeout_value: float,
+        strategy: TimeoutStrategy,
+    ) -> float | None:
+        """Handle asyncio.timeout context manager timeout."""
+        return self._handle_timeout_error(
+            operation,
+            start_time,
+            timeout_value,
+            strategy,
+            "asyncio timeout",
+            "timed out",
+        )
+
+    def _handle_cancelled_exception(
+        self,
+        operation: str,
+        start_time: float,
+        timeout_value: float,
+        strategy: TimeoutStrategy,
+    ) -> float | None:
+        """Handle asyncio.CancelledError exception."""
+        return self._handle_timeout_error(
+            operation, start_time, timeout_value, strategy, "cancelled", "was cancelled"
+        )
+
+    def _handle_generic_exception(
+        self, operation: str, start_time: float, strategy: TimeoutStrategy
+    ) -> None:
+        """Handle generic exceptions."""
+        self.performance_monitor.record_operation_failure(operation, start_time)
+        elapsed = time.time() - start_time
+        self._record_failure(operation, elapsed)
+
+        if strategy == TimeoutStrategy.CIRCUIT_BREAKER:
+            self._update_circuit_breaker(operation, False)
+
+    def _dispatch_exception_handler(
+        self,
+        error: Exception,
+        operation: str,
+        start_time: float,
+        timeout_value: float,
+        strategy: TimeoutStrategy,
+    ) -> tuple[bool, Exception | None]:
+        """Dispatch exception to appropriate handler."""
+        # Custom TimeoutError
+        if isinstance(error, TimeoutError):
+            result = self._handle_custom_timeout_exception(
+                operation, start_time, timeout_value, strategy, error
+            )
+            should_yield = self._should_yield_on_graceful_degradation(result)
+            return should_yield, (None if should_yield else error)
+
+        # Asyncio timeout
+        if isinstance(error, builtins.TimeoutError):
+            result = self._handle_asyncio_timeout_exception(
+                operation, start_time, timeout_value, strategy
+            )
+            should_yield = self._should_yield_on_graceful_degradation(result)
+            reraise_error = TimeoutError(
+                operation, timeout_value, time.time() - start_time
+            )
+            return should_yield, (None if should_yield else reraise_error)
+
+        # Cancelled error
+        if isinstance(error, asyncio.CancelledError):
+            result = self._handle_cancelled_exception(
+                operation, start_time, timeout_value, strategy
+            )
+            should_yield = self._should_yield_on_graceful_degradation(result)
+            reraise_error = TimeoutError(
+                operation, timeout_value, time.time() - start_time
+            )
+            return should_yield, (None if should_yield else reraise_error)
+
+        # Generic exception
+        self._handle_generic_exception(operation, start_time, strategy)
+        return False, error
+
     @asynccontextmanager
     async def timeout_context(
         self,
@@ -146,52 +297,18 @@ class AsyncTimeoutManager:
             timeout_value = 7200.0
 
         try:
-            try:
-                async with asyncio.timeout(timeout_value):
-                    yield
-            except AttributeError:
-                task = asyncio.current_task()
-                if task:
-                    try:
-                        await asyncio.wait_for(
-                            asyncio.shield(task), timeout=timeout_value
-                        )
-                        yield
-                    except builtins.TimeoutError:
-                        raise builtins.TimeoutError(f"Operation {operation} timed out")
-                else:
-                    yield
-
-            self.performance_monitor.record_operation_success(operation, start_time)
-            elapsed = time.time() - start_time
-            self._record_success(operation, elapsed)
+            async with self._execute_with_timeout_context(timeout_value):
+                yield
+            self._handle_operation_success(operation, start_time)
 
-        except (TimeoutError, asyncio.CancelledError) as e:
-            elapsed = time.time() - start_time
-            self.performance_monitor.record_operation_timeout(
-                operation, start_time, timeout_value, str(e)
+        except Exception as e:
+            should_yield, error = self._dispatch_exception_handler(
+                e, operation, start_time, timeout_value, strategy
             )
-            self._record_failure(operation, elapsed)
-
-            if strategy == TimeoutStrategy.CIRCUIT_BREAKER:
-                self._update_circuit_breaker(operation, False)
-
-            if strategy == TimeoutStrategy.GRACEFUL_DEGRADATION:
-                logger.warning(
-                    f"Operation {operation} timed out ({elapsed: .1f}s), continuing gracefully"
-                )
-                return
-
-            raise TimeoutError(operation, timeout_value, elapsed) from e
-        except Exception:
-            self.performance_monitor.record_operation_failure(operation, start_time)
-            elapsed = time.time() - start_time
-            self._record_failure(operation, elapsed)
-
-            if strategy == TimeoutStrategy.CIRCUIT_BREAKER:
-                self._update_circuit_breaker(operation, False)
-
-            raise
+            if should_yield:
+                yield
+            elif error:
+                raise error
 
     async def with_timeout(
         self,

crackerjack/core/workflow/__init__.py

@@ -0,0 +1,21 @@
+"""Workflow component modules.
+
+Modular components extracted from workflow orchestrator for better
+separation of concerns and testability.
+"""
+
+from __future__ import annotations
+
+from .workflow_ai_coordinator import WorkflowAICoordinator
+from .workflow_event_orchestrator import WorkflowEventOrchestrator
+from .workflow_issue_parser import WorkflowIssueParser
+from .workflow_phase_executor import WorkflowPhaseExecutor
+from .workflow_security_gates import WorkflowSecurityGates
+
+__all__ = [
+    "WorkflowAICoordinator",
+    "WorkflowEventOrchestrator",
+    "WorkflowIssueParser",
+    "WorkflowPhaseExecutor",
+    "WorkflowSecurityGates",
+]