crackerjack 0.30.3__py3-none-any.whl → 0.31.4__py3-none-any.whl

crackerjack/mcp/file_monitor.py

@@ -0,0 +1,336 @@
+import asyncio
+import json
+import time
+from collections.abc import Callable
+from pathlib import Path
+
+try:
+    from watchdog.events import FileSystemEvent, FileSystemEventHandler
+    from watchdog.observers import Observer
+
+    WATCHDOG_AVAILABLE = True
+except ImportError:
+    FileSystemEvent = None
+    FileSystemEventHandler = None
+    Observer = None
+    WATCHDOG_AVAILABLE = False
+
+import contextlib
+
+from rich.console import Console
+
+console = Console()
+
+
+if WATCHDOG_AVAILABLE:
+
+    class ProgressFileHandler(FileSystemEventHandler):
+        def __init__(self, callback: Callable[[str, dict], None]) -> None:
+            super().__init__()
+            self.callback = callback
+            self._last_processed: dict[str, float] = {}
+            self._debounce_delay = 0.1
+
+        def on_modified(self, event: FileSystemEvent) -> None:
+            if event.is_directory:
+                return
+
+            file_path = Path(event.src_path)
+
+            if not file_path.name.startswith("job - ") or file_path.suffix != ".json":
+                return
+
+            now = time.time()
+            if file_path.name in self._last_processed:
+                if now - self._last_processed[file_path.name] < self._debounce_delay:
+                    return
+
+            self._last_processed[file_path.name] = now
+
+            job_id = file_path.stem.replace("job - ", "")
+
+            try:
+                with file_path.open() as f:
+                    progress_data = json.load(f)
+
+                self.callback(job_id, progress_data)
+
+            except (json.JSONDecodeError, FileNotFoundError, OSError) as e:
+                console.print(
+                    f"[yellow]Warning: Failed to read progress file {file_path}: {e}[/yellow]",
+                )
+
+        def on_created(self, event: FileSystemEvent) -> None:
+            self.on_modified(event)
+else:
+
+    class ProgressFileHandler:
+        def __init__(self, callback: Callable[[str, dict], None]) -> None:
+            pass
+
+
+class AsyncProgressMonitor:
+    def __init__(self, progress_dir: Path) -> None:
+        self.progress_dir = progress_dir
+        self.observer: Observer | None = None
+        self.subscribers: dict[str, set[Callable[[dict], None]]] = {}
+        self._running = False
+
+        self.progress_dir.mkdir(exist_ok=True)
+
+        if not WATCHDOG_AVAILABLE:
+            console.print(
+                "[yellow]Warning: watchdog not available, falling back to polling[/yellow]",
+            )
+
+    async def start(self) -> None:
+        if not WATCHDOG_AVAILABLE:
+            return
+
+        self._running = True
+
+        handler = ProgressFileHandler(self._on_file_changed)
+
+        self.observer = Observer()
+        self.observer.schedule(handler, str(self.progress_dir), recursive=False)
+        self.observer.start()
+
+        console.print(
+            f"[green]📁 Started monitoring progress directory: {self.progress_dir}[/green]",
+        )
+
+    async def stop(self) -> None:
+        self._running = False
+
+        if self.observer:
+            self.observer.stop()
+            self.observer.join()
+            self.observer = None
+
+        console.print("[yellow]📁 Stopped progress directory monitoring[/yellow]")
+
+    def subscribe(self, job_id: str, callback: Callable[[dict], None]) -> None:
+        if job_id not in self.subscribers:
+            self.subscribers[job_id] = set()
+
+        self.subscribers[job_id].add(callback)
+        console.print(f"[cyan]📋 Subscribed to job updates: {job_id}[/cyan]")
+
+    def unsubscribe(self, job_id: str, callback: Callable[[dict], None]) -> None:
+        if job_id in self.subscribers:
+            self.subscribers[job_id].discard(callback)
+
+            if not self.subscribers[job_id]:
+                del self.subscribers[job_id]
+
+        console.print(f"[cyan]📋 Unsubscribed from job updates: {job_id}[/cyan]")
+
+    def _on_file_changed(self, job_id: str, progress_data: dict) -> None:
+        if job_id in self.subscribers:
+            for callback in self.subscribers[job_id].copy():
+                try:
+                    callback(progress_data)
+                except Exception as e:
+                    console.print(
+                        f"[red]Error in progress callback for job {job_id}: {e}[/red]",
+                    )
+
+                    self.subscribers[job_id].discard(callback)
+
+    async def get_current_progress(self, job_id: str) -> dict | None:
+        progress_file = self.progress_dir / f"job - {job_id}.json"
+
+        if not progress_file.exists():
+            return None
+
+        try:
+            with progress_file.open() as f:
+                return json.load(f)
+        except (json.JSONDecodeError, OSError):
+            return None
+
+    async def cleanup_completed_jobs(self, max_age_minutes: int = 60) -> int:
+        if not self.progress_dir.exists():
+            return 0
+
+        cleaned = 0
+        cutoff_time = time.time() - (max_age_minutes * 60)
+
+        for progress_file in self.progress_dir.glob("job -* .json"):
+            try:
+                if progress_file.stat().st_mtime < cutoff_time:
+                    with progress_file.open() as f:
+                        data = json.load(f)
+
+                    if data.get("status") in ("completed", "failed"):
+                        progress_file.unlink()
+                        cleaned += 1
+                        console.print(
+                            f"[dim]🧹 Cleaned up old progress file: {progress_file.name}[/dim]",
+                        )
+
+            except (json.JSONDecodeError, OSError, KeyError):
+                from contextlib import suppress
+
+                with suppress(OSError):
+                    progress_file.unlink()
+                    cleaned += 1
+                    console.print(
+                        f"[dim]🧹 Removed corrupted progress file: {progress_file.name}[/dim]",
+                    )
+
+        return cleaned
+
+
+class PollingProgressMonitor:
+    def __init__(self, progress_dir: Path) -> None:
+        self.progress_dir = progress_dir
+        self.subscribers: dict[str, set[Callable[[dict], None]]] = {}
+        self._running = False
+        self._poll_task: asyncio.Task | None = None
+        self._file_mtimes: dict[str, float] = {}
+
+        self.progress_dir.mkdir(exist_ok=True)
+
+    async def start(self) -> None:
+        self._running = True
+        self._poll_task = asyncio.create_task(self._poll_loop())
+        console.print(
+            f"[yellow]📁 Started polling progress directory: {self.progress_dir}[/yellow]",
+        )
+
+    async def stop(self) -> None:
+        self._running = False
+
+        if self._poll_task:
+            self._poll_task.cancel()
+            with contextlib.suppress(asyncio.CancelledError):
+                await self._poll_task
+            self._poll_task = None
+
+        console.print("[yellow]📁 Stopped progress directory polling[/yellow]")
+
+    async def _poll_loop(self) -> None:
+        while self._running:
+            try:
+                await self._check_files()
+                await asyncio.sleep(0.5)
+            except asyncio.CancelledError:
+                break
+            except Exception as e:
+                console.print(f"[red]Error in polling loop: {e}[/red]")
+                await asyncio.sleep(1)
+
+    async def _check_files(self) -> None:
+        if not self.progress_dir.exists():
+            return
+
+        current_files = {}
+
+        for progress_file in self.progress_dir.glob("job -* .json"):
+            try:
+                mtime = progress_file.stat().st_mtime
+                current_files[progress_file.name] = mtime
+
+                if (
+                    progress_file.name not in self._file_mtimes
+                    or mtime > self._file_mtimes[progress_file.name]
+                ):
+                    job_id = progress_file.stem.replace("job - ", "")
+
+                    try:
+                        with progress_file.open() as f:
+                            progress_data = json.load(f)
+
+                        self._notify_subscribers(job_id, progress_data)
+
+                    except (json.JSONDecodeError, OSError) as e:
+                        console.print(
+                            f"[yellow]Warning: Failed to read progress file {progress_file}: {e}[/yellow]",
+                        )
+
+            except OSError:
+                continue
+
+        self._file_mtimes = current_files
+
+    def _notify_subscribers(self, job_id: str, progress_data: dict) -> None:
+        if job_id in self.subscribers:
+            for callback in self.subscribers[job_id].copy():
+                try:
+                    callback(progress_data)
+                except Exception as e:
+                    console.print(
+                        f"[red]Error in progress callback for job {job_id}: {e}[/red]",
+                    )
+                    self.subscribers[job_id].discard(callback)
+
+    def subscribe(self, job_id: str, callback: Callable[[dict], None]) -> None:
+        if job_id not in self.subscribers:
+            self.subscribers[job_id] = set()
+
+        self.subscribers[job_id].add(callback)
+        console.print(f"[cyan]📋 Subscribed to job updates: {job_id} (polling)[/cyan]")
+
+    def unsubscribe(self, job_id: str, callback: Callable[[dict], None]) -> None:
+        if job_id in self.subscribers:
+            self.subscribers[job_id].discard(callback)
+
+            if not self.subscribers[job_id]:
+                del self.subscribers[job_id]
+
+        console.print(
+            f"[cyan]📋 Unsubscribed from job updates: {job_id} (polling)[/cyan]",
+        )
+
+    async def get_current_progress(self, job_id: str) -> dict | None:
+        progress_file = self.progress_dir / f"job - {job_id}.json"
+
+        if not progress_file.exists():
+            return None
+
+        try:
+            with progress_file.open() as f:
+                return json.load(f)
+        except (json.JSONDecodeError, OSError):
+            return None
+
+    async def cleanup_completed_jobs(self, max_age_minutes: int = 60) -> int:
+        if not self.progress_dir.exists():
+            return 0
+
+        cleaned = 0
+        cutoff_time = time.time() - (max_age_minutes * 60)
+
+        for progress_file in self.progress_dir.glob("job -* .json"):
+            try:
+                if progress_file.stat().st_mtime < cutoff_time:
+                    with progress_file.open() as f:
+                        data = json.load(f)
+
+                    if data.get("status") in ("completed", "failed"):
+                        progress_file.unlink()
+                        cleaned += 1
+                        console.print(
+                            f"[dim]🧹 Cleaned up old progress file: {progress_file.name}[/dim]",
+                        )
+
+            except (json.JSONDecodeError, OSError, KeyError):
+                from contextlib import suppress
+
+                with suppress(OSError):
+                    progress_file.unlink()
+                    cleaned += 1
+                    console.print(
+                        f"[dim]🧹 Removed corrupted progress file: {progress_file.name}[/dim]",
+                    )
+
+        return cleaned
+
+
+def create_progress_monitor(
+    progress_dir: Path,
+) -> AsyncProgressMonitor | PollingProgressMonitor:
+    if WATCHDOG_AVAILABLE:
+        return AsyncProgressMonitor(progress_dir)
+    return PollingProgressMonitor(progress_dir)