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

crackerjack/mcp/progress_monitor.py

@@ -5,6 +5,7 @@ import subprocess
 import sys
 import tempfile
 import time
+import typing as t
 from contextlib import suppress
 from pathlib import Path
 
@@ -26,7 +27,7 @@ from .progress_components import (
 
 
 class AgentStatusPanel(Widget):
-    def __init__(self, **kwargs) -> None:
+    def __init__(self, **kwargs: t.Any) -> None:
         super().__init__(**kwargs)
         self.border_title = "🤖 AI Agents"
         self.border_title_align = "left"
@@ -49,13 +50,13 @@ class AgentStatusPanel(Widget):
 
             agents_table.styles.max_height = "8"
 
-    def update_agent_data(self, agent_data: dict) -> None:
+    def update_agent_data(self, agent_data: dict[str, t.Any]) -> None:
         with suppress(Exception):
             self._update_coordinator_status(agent_data)
             self._update_agents_table(agent_data)
             self._update_stats(agent_data)
 
-    def _update_coordinator_status(self, data: dict) -> None:
+    def _update_coordinator_status(self, data: dict[str, t.Any]) -> None:
         with suppress(Exception):
             activity = data.get("agent_activity", {})
             registry = activity.get("agent_registry", {})
@@ -68,7 +69,7 @@ class AgentStatusPanel(Widget):
                 f"Coordinator: {status_emoji} {coordinator_status.title()} ({total_agents} agents)",
             )
 
-    def _update_agents_table(self, data: dict) -> None:
+    def _update_agents_table(self, data: dict[str, t.Any]) -> None:
         with suppress(Exception):
             agents_table = self.query_one("#agents-table", DataTable)
             agents_table.clear()
@@ -105,7 +106,7 @@ class AgentStatusPanel(Widget):
                     f"{processing_time: .1f}s" if processing_time > 0 else "-",
                 )
 
-    def _update_stats(self, data: dict) -> None:
+    def _update_stats(self, data: dict[str, t.Any]) -> None:
         with suppress(Exception):
             performance = data.get("agent_performance", {})
             total_issues = performance.get("total_issues_processed", 0)
@@ -152,12 +153,12 @@ class AgentStatusPanel(Widget):
 
 
 class JobPanel(Widget):
-    def __init__(self, job_data: dict, **kwargs) -> None:
+    def __init__(self, job_data: dict[str, t.Any], **kwargs: t.Any) -> None:
         super().__init__(**kwargs)
         self.job_data = job_data
         self.completion_time = None
         self.iteration_count = job_data.get("iteration", 0)
-        self.max_iterations = job_data.get("max_iterations", 10)
+        self.max_iterations = job_data.get("max_iterations", 5)
         self.fade_timer = None
         self.remove_timer = None
         self.fade_level = 0
@@ -417,11 +418,13 @@ class CrackerjackDashboard(App):
 
     def __init__(self) -> None:
         super().__init__()
-        self.progress_dir = Path(tempfile.gettempdir()) / "crackerjack - mcp-progress"
+        self.progress_dir = Path(tempfile.gettempdir()) / "crackerjack-mcp-progress"
         self.websocket_url = "ws://localhost:8675"
         self.refresh_timer = None
-        self.active_jobs = {}
-        self.completed_jobs_stats = {}
+        self._refresh_counter = 0
+        self.dev = False
+        self.active_jobs: dict[str, t.Any] = {}
+        self.completed_jobs_stats: dict[str, t.Any] = {}
         self.current_polling_method = "File"
         self.timeout_manager = get_timeout_manager()
 
@@ -532,19 +535,14 @@ class CrackerjackDashboard(App):
 
     async def _refresh_data(self) -> None:
         try:
-            # Refresh cycle with timeout protection
             async with self.timeout_manager.timeout_context(
                 "network_operations",
-                timeout=10.0,  # Total refresh timeout
+                timeout=10.0,
                 strategy=TimeoutStrategy.GRACEFUL_DEGRADATION,
             ):
-                if hasattr(self, "_refresh_counter"):
-                    self._refresh_counter += 1
-                else:
-                    self._refresh_counter = 0
+                self._refresh_counter += 1
 
-                # Ensure services running less frequently to avoid overhead
-                if self._refresh_counter % 20 == 0:  # Every 10 seconds instead of 5
+                if self._refresh_counter % 20 == 0:
                     with suppress(Exception):
                         await self.timeout_manager.with_timeout(
                             "network_operations",
@@ -553,7 +551,6 @@ class CrackerjackDashboard(App):
                             strategy=TimeoutStrategy.FAIL_FAST,
                         )
 
-                # Collect data with individual timeouts
                 jobs_data = await self.timeout_manager.with_timeout(
                     "network_operations",
                     self._discover_jobs(),
@@ -575,7 +572,6 @@ class CrackerjackDashboard(App):
                     strategy=TimeoutStrategy.FAIL_FAST,
                 )
 
-                # Update UI components
                 self.query_one("#services-panel").border_title = "🔧 Services"
 
                 self._update_jobs_table(jobs_data)
@@ -586,12 +582,11 @@ class CrackerjackDashboard(App):
                 self._update_status_bars(jobs_data)
 
         except Exception as e:
-            # Log error but don't crash the dashboard
             with suppress(Exception):
                 console = Console()
                 console.print(f"[red]Dashboard refresh error: {e}[/red]")
 
-    async def _discover_jobs(self) -> dict:
+    async def _discover_jobs(self) -> dict[str, t.Any]:
         try:
             result = await self.timeout_manager.with_timeout(
                 "network_operations",
@@ -600,9 +595,9 @@ class CrackerjackDashboard(App):
                 strategy=TimeoutStrategy.FAIL_FAST,
             )
             self.current_polling_method = result["method"]
-            return result["data"]
+            data_result = result["data"]
+            return t.cast(dict[str, t.Any], data_result)
         except Exception:
-            # Return empty data structure on timeout or error
             return {
                 "active": 0,
                 "completed": 0,
@@ -615,31 +610,31 @@ class CrackerjackDashboard(App):
                 "current_errors": 0,
             }
 
-    async def _collect_services_data(self) -> list:
+    async def _collect_services_data(self) -> list[t.Any]:
         try:
-            return await self.timeout_manager.with_timeout(
+            services_data = await self.timeout_manager.with_timeout(
                 "network_operations",
                 self.service_checker.collect_services_data(),
                 timeout=3.0,
                 strategy=TimeoutStrategy.FAIL_FAST,
             )
+            return t.cast(list[t.Any], services_data)
         except Exception:
-            # Return minimal service data on timeout
             return [("Services", "🔴 Timeout", "0")]
 
-    async def _collect_recent_errors(self) -> list:
+    async def _collect_recent_errors(self) -> list[t.Any]:
         try:
-            return await self.timeout_manager.with_timeout(
+            errors_data = await self.timeout_manager.with_timeout(
                 "file_operations",
                 self.error_collector.collect_recent_errors(),
                 timeout=2.0,
                 strategy=TimeoutStrategy.FAIL_FAST,
             )
+            return t.cast(list[t.Any], errors_data)
         except Exception:
-            # Return empty error list on timeout
             return []
 
-    def _update_jobs_table(self, jobs_data: dict) -> None:
+    def _update_jobs_table(self, jobs_data: dict[str, t.Any]) -> None:
         with suppress(Exception):
             jobs_table = self.query_one("#jobs-table", DataTable)
             jobs_table.clear()
@@ -681,7 +676,7 @@ class CrackerjackDashboard(App):
                 ],
             )
 
-    def _update_services_table(self, services_data: list) -> None:
+    def _update_services_table(self, services_data: list[t.Any]) -> None:
         with suppress(Exception):
             services_table = self.query_one("#services-table", DataTable)
             services_table.clear()
@@ -705,7 +700,7 @@ class CrackerjackDashboard(App):
                 polling_status += " 🟢"
             services_table.add_row("Polling", polling_status, "")
 
-    def _update_errors_table(self, errors_data: list) -> None:
+    def _update_errors_table(self, errors_data: list[t.Any]) -> None:
         with suppress(Exception):
             errors_table = self.query_one("#errors-table", DataTable)
             errors_table.clear()
@@ -767,7 +762,7 @@ class CrackerjackDashboard(App):
                 ],
             )
 
-    def _update_agent_panel(self, jobs_data: dict) -> None:
+    def _update_agent_panel(self, jobs_data: dict[str, t.Any]) -> None:
         with suppress(Exception):
             agent_panel = self.query_one("#agent - status-panel", AgentStatusPanel)
 
@@ -780,7 +775,7 @@ class CrackerjackDashboard(App):
             if agent_data:
                 agent_panel.update_agent_data(agent_data)
 
-    def _update_job_panels(self, jobs_data: dict) -> None:
+    def _update_job_panels(self, jobs_data: dict[str, t.Any]) -> None:
         with suppress(Exception):
             container = self.query_one("#job - discovery-container")
             current_job_ids = self._get_current_job_ids(jobs_data)
@@ -789,14 +784,14 @@ class CrackerjackDashboard(App):
             self._update_or_create_panels(jobs_data, container)
             self._handle_placeholder_visibility(container)
 
-    def _get_current_job_ids(self, jobs_data: dict) -> set:
+    def _get_current_job_ids(self, jobs_data: dict[str, t.Any]) -> set[t.Any]:
         return (
             {job["job_id"] for job in jobs_data["individual_jobs"]}
             if jobs_data["individual_jobs"]
             else set()
         )
 
-    def _remove_obsolete_panels(self, current_job_ids: set) -> None:
+    def _remove_obsolete_panels(self, current_job_ids: set[t.Any]) -> None:
         jobs_to_remove = []
         for job_id, panel in self.active_jobs.items():
             panel_status = panel.job_data.get("status", "").lower()
@@ -811,7 +806,9 @@ class CrackerjackDashboard(App):
             panel = self.active_jobs.pop(job_id)
             panel.remove()
 
-    def _update_or_create_panels(self, jobs_data: dict, container) -> None:
+    def _update_or_create_panels(
+        self, jobs_data: dict[str, t.Any], container: t.Any
+    ) -> None:
         if not jobs_data["individual_jobs"]:
             return
 
@@ -822,7 +819,7 @@ class CrackerjackDashboard(App):
             else:
                 self._create_new_panel(job, container)
 
-    def _update_existing_panel(self, job: dict) -> None:
+    def _update_existing_panel(self, job: dict[str, t.Any]) -> None:
         existing_panel = self.active_jobs[job["job_id"]]
         existing_panel.job_data = job
         existing_panel.iteration_count = job.get("iteration", 0)
@@ -833,7 +830,7 @@ class CrackerjackDashboard(App):
         self._handle_job_completion(existing_panel, job)
         self._update_panel_border(existing_panel)
 
-    def _update_panel_title(self, panel, job: dict) -> None:
+    def _update_panel_title(self, panel: t.Any, job: dict[str, t.Any]) -> None:
         project_name = job.get("project", "crackerjack")
         status = job.get("status", "").lower()
 
@@ -846,25 +843,25 @@ class CrackerjackDashboard(App):
         else:
             panel.border_subtitle = ""
 
-    def _handle_job_completion(self, panel, job: dict) -> None:
+    def _handle_job_completion(self, panel: t.Any, job: dict[str, t.Any]) -> None:
         job_status = job.get("status", "").lower()
         if job_status in ("completed", "failed") and panel.completion_time is None:
             panel.completion_time = time.time()
             panel.fade_timer = panel.set_timer(300.0, panel._start_fade)
             panel.remove_timer = panel.set_timer(1200.0, panel._remove_panel)
 
-    def _update_panel_border(self, panel) -> None:
+    def _update_panel_border(self, panel: t.Any) -> None:
         new_border = panel._calculate_border_style()
         if new_border != panel.border_style:
             panel.border_style = new_border
             panel.refresh()
 
-    def _create_new_panel(self, job: dict, container) -> None:
+    def _create_new_panel(self, job: dict[str, t.Any], container: t.Any) -> None:
         job_panel = JobPanel(job)
         self.active_jobs[job["job_id"]] = job_panel
         container.mount(job_panel)
 
-    def _handle_placeholder_visibility(self, container) -> None:
+    def _handle_placeholder_visibility(self, container: t.Any) -> None:
         has_placeholder = bool(container.query("#no - jobs-label"))
 
         if not self.active_jobs and not has_placeholder:
@@ -877,7 +874,7 @@ class CrackerjackDashboard(App):
         elif self.active_jobs and has_placeholder:
             container.query("#no - jobs-label").remove()
 
-    def _update_status_bars(self, jobs_data: dict) -> None:
+    def _update_status_bars(self, jobs_data: dict[str, t.Any]) -> None:
         pass
 
     def action_refresh(self) -> None:
@@ -908,7 +905,7 @@ class CrackerjackDashboard(App):
     def _restore_terminal_fallback(self) -> None:
         self.terminal_restorer.restore_terminal()
 
-    def _signal_handler(self, _signum, _frame) -> None:
+    def _signal_handler(self, _signum: t.Any, _frame: t.Any) -> None:
         with suppress(Exception):
             self._restore_terminal()
             self._cleanup_started_services()
@@ -941,18 +938,18 @@ class JobMetrics:
         self.completion_time: float | None = None
 
         self.iteration = 0
-        self.max_iterations = 10
+        self.max_iterations = 5
         self.current_stage = "Initializing"
         self.status = "running"
         self.message = ""
 
-        self.stages_completed = set()
-        self.stages_failed = set()
+        self.stages_completed: set[str] = set()
+        self.stages_failed: set[str] = set()
 
-        self.errors = []
-        self.warnings = []
-        self.hook_failures = []
-        self.test_failures = []
+        self.errors: list[str] = []
+        self.warnings: list[str] = []
+        self.hook_failures: list[str] = []
+        self.test_failures: list[str] = []
 
 
 async def run_progress_monitor(

crackerjack/mcp/rate_limiter.py

@@ -35,10 +35,10 @@ class RateLimiter:
         self.requests_per_hour = requests_per_hour
 
         self.minute_windows: dict[str, deque[float]] = defaultdict(
-            lambda: deque(maxlen=requests_per_minute),
+            lambda: deque(maxlen=requests_per_minute),  # type: ignore[misc]
         )
         self.hour_windows: dict[str, deque[float]] = defaultdict(
-            lambda: deque(maxlen=requests_per_hour),
+            lambda: deque(maxlen=requests_per_hour),  # type: ignore[misc]
         )
 
         self.global_minute_window: deque[float] = deque(maxlen=requests_per_minute * 10)
@@ -110,7 +110,7 @@ class RateLimiter:
         self._cleanup_global_windows(minute_cutoff, hour_cutoff)
 
     def _cleanup_client_windows(self, minute_cutoff: float, hour_cutoff: float) -> None:
-        for client_id in list(self.minute_windows.keys()):
+        for client_id in list[t.Any](self.minute_windows.keys()):
             minute_window = self.minute_windows[client_id]
             hour_window = self.hour_windows[client_id]
 
@@ -200,7 +200,7 @@ class ResourceMonitor:
         stale_jobs = []
 
         async with self._lock:
-            for job_id, start_time in list(self.active_jobs.items()):
+            for job_id, start_time in list[t.Any](self.active_jobs.items()):
                 if now - start_time > max_duration:
                     stale_jobs.append(job_id)
                     del self.active_jobs[job_id]
@@ -234,7 +234,7 @@ class ResourceMonitor:
             if not progress_dir.exists():
                 return True
 
-            file_count = len(list(progress_dir.glob("job-* .json")))
+            file_count = len(list[t.Any](progress_dir.glob("job-* .json")))
             if file_count > self.config.max_progress_files:
                 console.print(
                     f"[red]🚫 Progress files ({file_count}) exceed limit ({self.config.max_progress_files})[/ red]",
@@ -272,7 +272,7 @@ class RateLimitMiddleware:
         )
         self.resource_monitor = ResourceMonitor(self.config)
 
-        self._cleanup_task: asyncio.Task | None = None
+        self._cleanup_task: asyncio.Task[None] | None = None
         self._running = False
 
     async def start(self) -> None:

crackerjack/mcp/server_core.py

@@ -9,7 +9,7 @@ from rich.console import Console
 try:
     import tomli
 except ImportError:
-    tomli = None
+    tomli = None  # type: ignore[assignment]
 
 try:
     from fastmcp import FastMCP
@@ -17,7 +17,7 @@ try:
     _mcp_available = True
 except ImportError:
     _mcp_available = False
-    FastMCP = None
+    FastMCP = None  # type: ignore[misc,assignment,no-redef]
 
 MCP_AVAILABLE: Final[bool] = _mcp_available
 
@@ -43,7 +43,6 @@ console = Console()
 
 
 def _load_mcp_config(project_path: Path) -> dict[str, t.Any]:
-    """Load MCP server configuration from pyproject.toml."""
     pyproject_path = project_path / "pyproject.toml"
 
     if not pyproject_path.exists() or not tomli:
@@ -228,7 +227,6 @@ def _merge_config_with_args(
     http_port: int | None,
     http_mode: bool,
 ) -> dict[str, t.Any]:
-    """Merge MCP configuration with command line arguments."""
     if http_port:
         mcp_config["http_port"] = http_port
     if http_mode:
@@ -240,7 +238,6 @@ def _setup_server_context(
     project_path: Path,
     websocket_port: int | None,
 ) -> MCPServerContext:
-    """Set up and initialize the MCP server context."""
     config = MCPServerConfig(
         project_path=project_path,
         rate_limit_config=RateLimitConfig(),
@@ -262,13 +259,12 @@ def _print_server_info(
     websocket_port: int | None,
     http_mode: bool,
 ) -> None:
-    """Print server startup information."""
     console.print("[green]Starting Crackerjack MCP Server...[/ green]")
     console.print(f"Project path: {project_path}")
 
     if mcp_config.get("http_enabled", False) or http_mode:
         console.print(
-            f"[cyan]HTTP Mode: http://{mcp_config['http_host']}:{mcp_config['http_port']}/mcp[/ cyan]"
+            f"[cyan]HTTP Mode: http: //{mcp_config['http_host']}: {mcp_config['http_port']}/mcp[/ cyan]"
         )
     else:
         console.print("[cyan]STDIO Mode[/ cyan]")
@@ -280,7 +276,6 @@ def _print_server_info(
 def _run_mcp_server(
     mcp_app: t.Any, mcp_config: dict[str, t.Any], http_mode: bool
 ) -> None:
-    """Execute the MCP server with appropriate transport mode."""
     console.print("[yellow]MCP app created, about to run...[/ yellow]")
 
     try:
@@ -310,23 +305,32 @@ def main(
     try:
         project_path = Path(project_path_arg).resolve()
 
-        # Load and merge configuration
         mcp_config = _load_mcp_config(project_path)
         mcp_config = _merge_config_with_args(mcp_config, http_port, http_mode)
 
-        # Set up server context
         _setup_server_context(project_path, websocket_port)
 
-        # Create MCP server
         mcp_app = create_mcp_server(mcp_config)
         if not mcp_app:
             console.print("[red]Failed to create MCP server[/ red]")
             return
 
-        # Print server information
         _print_server_info(project_path, mcp_config, websocket_port, http_mode)
 
-        # Run the server
+        # Auto-start WebSocket server if websocket_port is specified
+        if websocket_port:
+            import asyncio
+
+            try:
+                asyncio.run(_start_websocket_server())
+                console.print(
+                    f"[green]✅ WebSocket server auto-started on port {websocket_port}[/green]"
+                )
+            except Exception as e:
+                console.print(
+                    f"[yellow]⚠️ WebSocket server auto-start failed: {e}[/yellow]"
+                )
+
         _run_mcp_server(mcp_app, mcp_config, http_mode)
 
     except KeyboardInterrupt:
@@ -344,20 +348,17 @@ def main(
 if __name__ == "__main__":
     import sys
 
-    # Initialize defaults
     project_path = "."
     websocket_port = None
     http_mode = "--http" in sys.argv
     http_port = None
 
-    # Parse project path from non-flag arguments
     non_flag_args = [arg for arg in sys.argv[1:] if not arg.startswith("--")]
     if non_flag_args:
         project_path = non_flag_args[0]
         if len(non_flag_args) > 1 and non_flag_args[1].isdigit():
             websocket_port = int(non_flag_args[1])
 
-    # Parse HTTP port flag
     if "--http-port" in sys.argv:
         port_idx = sys.argv.index("--http-port")
         if port_idx + 1 < len(sys.argv):

crackerjack/mcp/service_watchdog.py

@@ -34,11 +34,12 @@ class ServiceConfig:
         self.max_restarts = max_restarts
         self.restart_window = restart_window
 
-        self.process: subprocess.Popen | None = None
+        self.process: subprocess.Popen[bytes] | None = None
         self.restart_count = 0
         self.restart_timestamps: list[float] = []
         self.last_health_check = 0.0
         self.is_healthy = False
+        self._port_acknowledged = False
         self.last_error: str | None = None
 
 

crackerjack/mcp/state.py

@@ -92,7 +92,9 @@ class SessionState:
 
 
 class StateManager:
-    def __init__(self, state_dir: Path | None = None, batched_saver=None) -> None:
+    def __init__(
+        self, state_dir: Path | None = None, batched_saver: t.Any | None = None
+    ) -> None:
         self._lock = asyncio.Lock()
         self.state_dir = state_dir or Path.home() / ".cache" / "crackerjack-mcp"
         self.state_dir.mkdir(exist_ok=True)
@@ -258,7 +260,7 @@ class StateManager:
         priority_counts = {}
         for priority in Priority:
             priority_counts[priority.value] = len(self.get_issues_by_priority(priority))
-        type_counts = {}
+        type_counts: dict[str, int] = {}
         for issue in issues:
             type_counts[issue.type] = type_counts.get(issue.type, 0) + 1
         stage_status = {}
@@ -351,14 +353,9 @@ class StateManager:
         return checkpoints
 
     def start_session(self) -> None:
-        """Start or initialize a session."""
-        # Session is already initialized in __init__, this is a no-op
-        # but provided for API compatibility
         self._save_state()
 
     def complete_session(self) -> None:
-        """Complete the current session."""
-        # Mark session as complete in metadata
         if not self.session_state.metadata:
             self.session_state.metadata = {}
         self.session_state.metadata["status"] = "completed"

crackerjack/mcp/task_manager.py

@@ -14,7 +14,7 @@ logger = logging.getLogger(__name__)
 @dataclass
 class TaskInfo:
     task_id: str
-    task: asyncio.Task
+    task: asyncio.Task[t.Any]
     created_at: float
     description: str = ""
     timeout_seconds: float | None = None
@@ -25,7 +25,7 @@ class AsyncTaskManager:
         self.max_concurrent_tasks = max_concurrent_tasks
         self._tasks: dict[str, TaskInfo] = {}
         self._task_semaphore = asyncio.Semaphore(max_concurrent_tasks)
-        self._cleanup_task: asyncio.Task | None = None
+        self._cleanup_task: asyncio.Task[t.Any] | None = None
         self._running = False
         self._lock = asyncio.Lock()
 
@@ -61,11 +61,11 @@ class AsyncTaskManager:
 
     async def create_task(
         self,
-        coro: t.Coroutine,
+        coro: t.Coroutine[t.Any, t.Any, t.Any],
         task_id: str,
         description: str = "",
         timeout_seconds: float | None = None,
-    ) -> asyncio.Task:
+    ) -> asyncio.Task[t.Any]:
         async with self._lock:
             if task_id in self._tasks:
                 msg = f"Task {task_id} already exists"
@@ -100,7 +100,9 @@ class AsyncTaskManager:
             console.print(f"[blue]🚀 Task {task_id} created: {description}[ / blue]")
         return task
 
-    async def _wrap_task(self, coro: t.Coroutine, task_id: str) -> t.Any:
+    async def _wrap_task(
+        self, coro: t.Coroutine[t.Any, t.Any, t.Any], task_id: str
+    ) -> t.Any:
         try:
             async with self._task_semaphore:
                 result = await coro
@@ -185,11 +187,11 @@ class AsyncTaskManager:
     @asynccontextmanager
     async def managed_task(
         self,
-        coro: t.Coroutine,
+        coro: t.Coroutine[t.Any, t.Any, t.Any],
         task_id: str,
         description: str = "",
         timeout_seconds: float | None = None,
-    ):
+    ) -> t.AsyncGenerator[asyncio.Task[t.Any]]:
         task = await self.create_task(coro, task_id, description, timeout_seconds)
         try:
             yield task
@@ -201,7 +203,7 @@ class AsyncTaskManager:
 
     async def _cancel_all_tasks(self) -> None:
         async with self._lock:
-            tasks_to_cancel = list(self._tasks.values())
+            tasks_to_cancel = list[t.Any](self._tasks.values())
 
         if not tasks_to_cancel:
             return
@@ -240,7 +242,7 @@ class AsyncTaskManager:
     async def _cleanup_completed_tasks(self) -> None:
         async with self._lock:
             completed_tasks = []
-            for task_id, task_info in list(self._tasks.items()):
+            for task_id, task_info in list[t.Any](self._tasks.items()):
                 if task_info.task.done():
                     completed_tasks.append(task_id)
                     del self._tasks[task_id]