crackerjack 0.33.0__py3-none-any.whl → 0.33.1__py3-none-any.whl

crackerjack/mcp/websocket/jobs.py

@@ -1,6 +1,7 @@
 import asyncio
 import json
 import time
+import typing as t
 import uuid
 from contextlib import suppress
 from pathlib import Path
@@ -17,7 +18,6 @@ console = Console()
 
 class JobManager:
     def __init__(self, progress_dir: Path) -> None:
-        # Validate and secure the progress directory path
         self.progress_dir = SecurePathValidator.validate_safe_path(progress_dir)
         self.active_connections: dict[str, set[Any]] = {}
         self.known_jobs: set[str] = set()
@@ -26,16 +26,13 @@ class JobManager:
         self.progress_dir.mkdir(exist_ok=True)
 
     def validate_job_id(self, job_id: str) -> bool:
-        """Validate job ID using secure input validator."""
         if not job_id:
             return False
 
-        # First check if it's a valid UUID
         with suppress(ValueError):
             uuid.UUID(job_id)
             return True
 
-        # Use secure input validator for additional validation
         result = get_input_validator().validate_job_id(job_id)
         return result.valid
 
@@ -50,47 +47,43 @@ class JobManager:
             if not self.active_connections[job_id]:
                 del self.active_connections[job_id]
 
-    async def broadcast_to_job(self, job_id: str, data: dict) -> None:
+    async def broadcast_to_job(self, job_id: str, data: dict[str, t.Any]) -> None:
         if job_id not in self.active_connections:
             return
 
         timeout_manager = get_timeout_manager()
         connections = self.active_connections[job_id].copy()
 
-        # Create websocket send tasks
         send_tasks = self._create_broadcast_tasks(connections, timeout_manager, data)
 
-        # Execute broadcast with timeout handling
         if send_tasks:
             await self._execute_broadcast_tasks(job_id, send_tasks)
 
     def _create_broadcast_tasks(
-        self, connections: set, timeout_manager, data: dict
-    ) -> list:
-        """Create tasks for all websocket sends with timeout."""
+        self, connections: set[t.Any], timeout_manager: t.Any, data: dict[str, t.Any]
+    ) -> list[tuple[t.Any, asyncio.Task[t.Any]]]:
         send_tasks = []
         for websocket in connections:
             task = asyncio.create_task(
                 timeout_manager.with_timeout(
                     "websocket_broadcast",
                     websocket.send_json(data),
-                    timeout=2.0,  # Quick broadcast timeout
+                    timeout=2.0,
                 )
             )
             send_tasks.append((websocket, task))
         return send_tasks
 
-    async def _execute_broadcast_tasks(self, job_id: str, send_tasks: list) -> None:
-        """Execute broadcast tasks with timeout and error handling."""
+    async def _execute_broadcast_tasks(
+        self, job_id: str, send_tasks: list[t.Any]
+    ) -> None:
         try:
-            # Use asyncio.wait with timeout for batch sending
             done, pending = await asyncio.wait(
                 [task for _, task in send_tasks],
-                timeout=5.0,  # Overall timeout for all broadcasts
+                timeout=5.0,
                 return_when=asyncio.ALL_COMPLETED,
             )
 
-            # Handle completed and pending tasks
             await self._handle_broadcast_results(job_id, send_tasks, done, pending)
 
         except Exception as e:
@@ -98,10 +91,12 @@ class JobManager:
             await self._cleanup_failed_broadcast(job_id, send_tasks)
 
     async def _handle_broadcast_results(
-        self, job_id: str, send_tasks: list, done: set, pending: set
+        self,
+        job_id: str,
+        send_tasks: list[t.Any],
+        done: set[t.Any],
+        pending: set[t.Any],
     ) -> None:
-        """Handle results of broadcast tasks."""
-        # Cancel any pending tasks and remove failed connections
         for websocket, task in send_tasks:
             if task in pending:
                 task.cancel()
@@ -112,12 +107,12 @@ class JobManager:
                 except Exception:
                     self.remove_connection(job_id, websocket)
 
-        # Wait for cancelled tasks to complete
         if pending:
             await asyncio.gather(*pending, return_exceptions=True)
 
-    async def _cleanup_failed_broadcast(self, job_id: str, send_tasks: list) -> None:
-        """Clean up connections after broadcast failure."""
+    async def _cleanup_failed_broadcast(
+        self, job_id: str, send_tasks: list[t.Any]
+    ) -> None:
         for websocket, task in send_tasks:
             if not task.done():
                 task.cancel()
@@ -127,7 +122,7 @@ class JobManager:
         if not self.progress_dir.exists():
             return None
 
-        progress_files = list(self.progress_dir.glob("job-*.json"))
+        progress_files = list[t.Any](self.progress_dir.glob("job-*.json"))
         if not progress_files:
             return None
 
@@ -139,11 +134,10 @@ class JobManager:
             progress_file.stem[4:] if progress_file.stem.startswith("job -") else None
         )
 
-    def get_job_progress(self, job_id: str) -> dict | None:
+    def get_job_progress(self, job_id: str) -> dict[str, t.Any] | None:
         if not self.validate_job_id(job_id):
             return None
 
-        # Use secure path joining to create progress file path
         try:
             progress_file = SecurePathValidator.secure_path_join(
                 self.progress_dir, f"job-{job_id}.json"
@@ -151,21 +145,18 @@ class JobManager:
             if not progress_file.exists():
                 return None
 
-            # Validate file size before reading
             SecurePathValidator.validate_file_size(progress_file)
 
-            return json.loads(progress_file.read_text())
+            return json.loads(progress_file.read_text())  # type: ignore[no-any-return]
         except (json.JSONDecodeError, OSError):
             return None
 
     async def _process_progress_file(self, progress_file: Path) -> None:
-        # Validate the progress file path is within our allowed directory
         try:
             validated_file = SecurePathValidator.validate_safe_path(
                 progress_file, self.progress_dir
             )
         except Exception:
-            # If path validation fails, skip processing this file
             return
 
         job_id = self.extract_job_id_from_file(validated_file)
@@ -185,20 +176,18 @@ class JobManager:
 
         while self.is_running:
             try:
-                # Monitor directory changes with timeout protection
                 async with timeout_manager.timeout_context(
                     "file_operations",
-                    timeout=10.0,  # Timeout for directory monitoring cycle
+                    timeout=10.0,
                     strategy=TimeoutStrategy.GRACEFUL_DEGRADATION,
                 ):
                     if self.progress_dir.exists():
-                        # Process files with individual timeouts
                         for progress_file in self.progress_dir.glob("job-*.json"):
                             try:
                                 await timeout_manager.with_timeout(
                                     "file_operations",
                                     self._process_progress_file(progress_file),
-                                    timeout=5.0,  # Per-file timeout
+                                    timeout=5.0,
                                 )
                             except Exception as e:
                                 console.print(
@@ -206,7 +195,6 @@ class JobManager:
                                 )
                                 continue
 
-                    # Reset error count on successful cycle
                     consecutive_errors = 0
                     await asyncio.sleep(1)
 
@@ -214,14 +202,12 @@ class JobManager:
                 consecutive_errors += 1
                 console.print(f"[red]Progress monitoring error: {e}[/red]")
 
-                # Implement exponential backoff for repeated errors
                 if consecutive_errors >= max_consecutive_errors:
                     console.print(
                         f"[red]Too many consecutive errors ({consecutive_errors}), stopping monitor[/red]"
                     )
                     break
 
-                # Exponential backoff with max delay
                 delay = min(5 * (2 ** (consecutive_errors - 1)), 60)
                 await asyncio.sleep(delay)
 
@@ -232,19 +218,20 @@ class JobManager:
         timeout_manager = get_timeout_manager()
 
         try:
-            # Start file monitor with timeout protection
             async with timeout_manager.timeout_context(
                 "file_operations",
-                timeout=30.0,  # Monitor startup timeout
+                timeout=30.0,
                 strategy=TimeoutStrategy.GRACEFUL_DEGRADATION,
             ):
                 monitor = create_progress_monitor(self.progress_dir)
                 await monitor.start()
 
-                def on_progress_update(job_id: str, progress_data: dict) -> None:
+                def on_progress_update(
+                    job_id: str, progress_data: dict[str, t.Any]
+                ) -> None:
                     if job_id and self.validate_job_id(job_id):
-                        # Create broadcast task with timeout handling
-                        async def safe_broadcast():
+
+                        async def safe_broadcast() -> None:
                             try:
                                 await timeout_manager.with_timeout(
                                     "websocket_broadcast",
@@ -256,13 +243,12 @@ class JobManager:
                                     f"[yellow]Broadcast failed for job {job_id}: {e}[/yellow]"
                                 )
 
-                        asyncio.create_task(safe_broadcast())
+                        asyncio.create_task(safe_broadcast())  # type: ignore[no-untyped-call]
 
                         if job_id not in self.known_jobs:
                             self.known_jobs.add(job_id)
                             console.print(f"[green]New job detected: {job_id}[/green]")
 
-                # Start directory monitoring with proper timeout handling
                 await self._monitor_directory_changes()
 
         except Exception as e:
@@ -273,18 +259,17 @@ class JobManager:
 
         while self.is_running:
             try:
-                # Cleanup cycle with timeout protection
                 await timeout_manager.with_timeout(
                     "file_operations",
                     self._perform_cleanup_cycle(),
-                    timeout=30.0,  # Cleanup timeout
+                    timeout=30.0,
                     strategy=TimeoutStrategy.GRACEFUL_DEGRADATION,
                 )
-                await asyncio.sleep(3600)  # 1 hour between cleanups
+                await asyncio.sleep(3600)
             except Exception as e:
                 console.print(f"[red]Cleanup error: {e}[/red]")
-                # Shorter sleep on error to retry sooner
-                await asyncio.sleep(1800)  # 30 minutes on error
+
+                await asyncio.sleep(1800)
 
     async def _perform_cleanup_cycle(self) -> None:
         if not self.progress_dir.exists():
@@ -318,17 +303,16 @@ class JobManager:
 
         while self.is_running:
             try:
-                # Timeout check with its own timeout protection
                 await timeout_manager.with_timeout(
                     "file_operations",
                     self._check_and_timeout_stuck_jobs(),
-                    timeout=60.0,  # Timeout check timeout
+                    timeout=60.0,
                     strategy=TimeoutStrategy.GRACEFUL_DEGRADATION,
                 )
-                await asyncio.sleep(300)  # 5 minutes between checks
+                await asyncio.sleep(300)
             except Exception as e:
                 console.print(f"[red]Timeout check error: {e}[/red]")
-                # Continue checking even on errors
+
                 await asyncio.sleep(300)
 
     async def _check_and_timeout_stuck_jobs(self) -> None:
@@ -352,12 +336,10 @@ class JobManager:
         timeout_seconds: int,
     ) -> None:
         try:
-            # Validate the progress file path is secure
             validated_file = SecurePathValidator.validate_safe_path(
                 progress_file, self.progress_dir
             )
 
-            # Validate file size before reading
             SecurePathValidator.validate_file_size(validated_file)
 
             progress_data = json.loads(validated_file.read_text())
@@ -371,12 +353,11 @@ class JobManager:
                 self._timeout_job(progress_data, validated_file)
 
         except (json.JSONDecodeError, OSError, Exception):
-            # Catch validation errors as well as file errors
             pass
 
     def _should_timeout_job(
         self,
-        progress_data: dict,
+        progress_data: dict[str, t.Any],
         progress_file: Path,
         current_time: float,
         timeout_seconds: int,
@@ -386,7 +367,9 @@ class JobManager:
             and current_time - progress_file.stat().st_mtime > timeout_seconds
         )
 
-    def _timeout_job(self, progress_data: dict, progress_file: Path) -> None:
+    def _timeout_job(
+        self, progress_data: dict[str, t.Any], progress_file: Path
+    ) -> None:
         progress_data["status"] = "failed"
         progress_data["message"] = "Job timed out (no updates for 30 minutes)"