glaip-sdk 0.6.15b2__py3-none-any.whl → 0.6.16__py3-none-any.whl

glaip_sdk/cli/slash/tui/background_tasks.py

@@ -0,0 +1,72 @@
+"""Shared mixin for tracking background asyncio tasks in Textual apps.
+
+Authors:
+    Raymond Christopher (raymond.christopher@gdplabs.id)
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+from collections.abc import Callable, Coroutine
+from typing import Any
+
+
+class BackgroundTaskMixin:
+    """Mixin that tracks background tasks and cleans them up on unmount."""
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        """Initialize task tracking set for derived Textual apps."""
+        super().__init__(*args, **kwargs)
+        self._pending_tasks: set[asyncio.Task[Any]] = set()
+
+    def track_task(
+        self,
+        coro: Coroutine[Any, Any, Any],
+        *,
+        on_error: Callable[[Exception], None] | None = None,
+        logger: logging.Logger | None = None,
+    ) -> asyncio.Task[Any]:
+        """Create and track a background task with optional error handling."""
+        task = asyncio.create_task(coro)
+        self._pending_tasks.add(task)
+
+        def _cleanup(finished: asyncio.Task[Any]) -> None:
+            self._pending_tasks.discard(finished)
+            if finished.cancelled():
+                return
+            try:
+                exc = finished.exception()
+            except Exception:
+                return
+            if exc:
+                if on_error:
+                    on_error(exc)
+                elif logger:
+                    logger.debug("Background task failed", exc_info=exc)
+
+        task.add_done_callback(_cleanup)
+        return task
+
+    def on_unmount(self) -> None:  # pragma: no cover - UI lifecycle hook
+        """Ensure background tasks are cleaned up on exit."""
+        pending = [task for task in self._pending_tasks if not task.done()]
+        for task in pending:
+            try:
+                task.cancel()
+            except Exception:
+                continue
+        if pending:
+            try:
+                loop = asyncio.get_running_loop()
+            except RuntimeError:
+                loop = None
+            if loop and loop.is_running():
+                try:
+                    loop.create_task(asyncio.gather(*pending, return_exceptions=True))
+                except Exception:
+                    pass
+        self._pending_tasks.clear()
+        parent_on_unmount = getattr(super(), "on_unmount", None)
+        if callable(parent_on_unmount):
+            parent_on_unmount()  # type: ignore[misc]

glaip_sdk/cli/slash/tui/loading.py

@@ -0,0 +1,58 @@
+"""Shared helpers for toggling Textual loading indicators.
+
+Note: uses Textual's built-in LoadingIndicator as the MVP; upgrade to the
+PulseIndicator from cli-textual-animated-indicators.md when shipped.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from typing import TYPE_CHECKING
+
+try:  # pragma: no cover - optional dependency
+    from textual.widgets import LoadingIndicator
+except Exception:  # pragma: no cover - optional dependency
+    LoadingIndicator = None  # type: ignore[assignment]
+
+if TYPE_CHECKING:  # pragma: no cover - type checking aid
+    from textual.widgets import LoadingIndicator as _LoadingIndicatorType
+
+    LoadingIndicator: type[_LoadingIndicatorType] | None
+
+
+def _set_indicator_display(app: object, selector: str, visible: bool) -> None:
+    """Safely toggle a LoadingIndicator's display property."""
+    if LoadingIndicator is None:
+        return
+    try:
+        indicator = app.query_one(selector, LoadingIndicator)  # type: ignore[arg-type]
+        indicator.display = visible
+    except Exception:
+        # Ignore lookup/rendering errors to keep UI resilient
+        return
+
+
+def show_loading_indicator(
+    app: object,
+    selector: str,
+    *,
+    message: str | None = None,
+    set_status: Callable[..., None] | None = None,
+    status_style: str = "cyan",
+) -> None:
+    """Show a loading indicator and optionally set a status message."""
+    _set_indicator_display(app, selector, True)
+    if message and set_status:
+        try:
+            set_status(message, status_style)
+        except TypeError:
+            # Fallback for setters that accept only a single arg or kwargs
+            try:
+                set_status(message)
+            except Exception:
+                return
+
+
+def hide_loading_indicator(app: object, selector: str) -> None:
+    """Hide a loading indicator."""
+    _set_indicator_display(app, selector, False)