jstdata 0.2.0__py3-none-any.whl

jstdata/workflows/find.py

@@ -0,0 +1,386 @@
+"""Host-level find modal: search metrics or entities and add to the session."""
+
+from __future__ import annotations
+
+import asyncio
+import json
+from typing import Any, Literal
+
+from textual import on, work
+from textual.app import ComposeResult
+from textual.binding import Binding
+from textual.containers import Horizontal, Vertical
+from textual.screen import ModalScreen
+from textual.widgets import Input, Label, ListItem, ListView, Static
+
+from ..client import JSTDataClient
+from ..models import Entity, Metric
+from ..session import Session
+
+_PLACEHOLDER = "Highlight a result and press i to inspect."
+FindMode = Literal["metric", "entity"]
+_MODES: tuple[FindMode, ...] = ("metric", "entity")
+
+
+def _resource_type(resource: Any) -> str:
+    if isinstance(resource, Entity):
+        return "entity"
+    if isinstance(resource, Metric):
+        return "metric"
+    return "metric"
+
+
+def _resource_label(resource: Any) -> str:
+    return (
+        getattr(resource, "label", None)
+        or getattr(resource, "name", None)
+        or getattr(resource, "id", "Unknown")
+    )
+
+
+def next_find_mode(mode: FindMode) -> FindMode:
+    """Cycle metric → entity → metric."""
+    return "entity" if mode == "metric" else "metric"
+
+
+class FindResultRow(ListItem):
+    """One search hit in the find modal."""
+
+    def __init__(self, resource: Any) -> None:
+        super().__init__()
+        self.resource = resource
+        self.resource_type = _resource_type(resource)
+
+    def compose(self) -> ComposeResult:
+        name = _resource_label(self.resource)
+        source = getattr(self.resource, "source", "") or ""
+        yield Label(
+            f"{self.resource_type.upper():<8} {name}  [{self.resource.id}]"
+            + (f"  {source}" if source else ""),
+            classes="find-row-label",
+        )
+
+
+class FindModal(ModalScreen[None]):
+    """Shared find surface: metric/entity search, add to session, inspect."""
+
+    DEFAULT_CSS = """
+    FindModal {
+        align: center middle;
+        background: rgba(0, 0, 0, 0.7);
+    }
+
+    #find-container {
+        width: 90%;
+        height: 80%;
+        max-width: 140;
+        max-height: 40;
+        border: thick #4ade80;
+        background: #111111;
+        padding: 1 1;
+    }
+
+    #find-title {
+        text-style: bold;
+        color: #4ade80;
+        text-align: center;
+        height: 1;
+        margin-bottom: 0;
+    }
+
+    #find-mode-bar {
+        height: 1;
+        text-align: center;
+        margin-bottom: 1;
+        color: #888;
+    }
+
+    #find-search-input {
+        width: 100%;
+        background: #0a0a0a;
+        border: solid #333;
+        margin-bottom: 1;
+    }
+
+    #find-body {
+        height: 1fr;
+        width: 100%;
+    }
+
+    #find-results-pane {
+        width: 1fr;
+        height: 100%;
+        border-right: solid #333;
+        padding-right: 1;
+    }
+
+    #find-inspect-pane {
+        width: 1fr;
+        height: 100%;
+        padding-left: 1;
+    }
+
+    .find-pane-header {
+        color: #4ade80;
+        text-style: bold;
+        height: 1;
+        margin-bottom: 1;
+    }
+
+    #find-results-list {
+        height: 1fr;
+        width: 100%;
+        background: #0a0a0a;
+        border: solid #222;
+    }
+
+    FindResultRow {
+        height: 1;
+        min-height: 1;
+        max-height: 1;
+        width: 100%;
+        padding: 0 1;
+        overflow: hidden;
+    }
+
+    FindResultRow:hover,
+    FindResultRow.-highlighted {
+        background: #1a3a1a;
+    }
+
+    .find-row-label {
+        width: 100%;
+        height: 1;
+        color: #e0e0e0;
+        overflow: hidden;
+    }
+
+    ListView > ListItem {
+        height: 1;
+        min-height: 1;
+        max-height: 1;
+    }
+
+    #find-inspect-payload {
+        height: 1fr;
+        width: 100%;
+        background: #0a0a0a;
+        border: solid #222;
+        color: #e0e0e0;
+        padding: 1;
+        overflow-y: auto;
+        overflow-x: auto;
+    }
+
+    #find-hint {
+        color: #888;
+        height: 1;
+        margin-top: 1;
+        dock: bottom;
+    }
+    """
+
+    BINDINGS = [
+        Binding("escape", "dismiss", "Close"),
+        Binding(
+            "shift+tab",
+            "toggle_mode",
+            "Toggle metric/entity",
+            priority=True,
+        ),
+        Binding("i", "inspect", "Inspect"),
+        Binding("j", "cursor_down", "Down", show=False),
+        Binding("k", "cursor_up", "Up", show=False),
+        Binding("down", "cursor_down", "Down", show=False),
+        Binding("up", "cursor_up", "Up", show=False),
+    ]
+
+    def __init__(
+        self,
+        client: JSTDataClient,
+        session: Session,
+        mode: FindMode = "metric",
+    ) -> None:
+        super().__init__()
+        self.client = client
+        self.session = session
+        self.mode: FindMode = mode if mode in _MODES else "metric"
+        self.search_task: asyncio.Task[None] | None = None
+        self._inspected_id: str | None = None
+
+    def compose(self) -> ComposeResult:
+        with Vertical(id="find-container"):
+            yield Label("FIND // ADD TO SESSION", id="find-title", markup=True)
+            yield Label("", id="find-mode-bar", markup=True)
+            yield Input(
+                placeholder="Search metrics…",
+                id="find-search-input",
+            )
+            with Horizontal(id="find-body"):
+                with Vertical(id="find-results-pane"):
+                    yield Label("RESULTS", classes="find-pane-header")
+                    yield ListView(id="find-results-list")
+                with Vertical(id="find-inspect-pane"):
+                    yield Label("INSPECT", classes="find-pane-header")
+                    yield Static(_PLACEHOLDER, id="find-inspect-payload", markup=False)
+            yield Label("", id="find-hint", markup=True)
+
+    def on_mount(self) -> None:
+        self._refresh_mode_chrome()
+        self.query_one("#find-search-input", Input).focus()
+
+    def _refresh_mode_chrome(self) -> None:
+        if self.mode == "metric":
+            self.query_one("#find-title").update(
+                "FIND // [bold #38bdf8]METRIC[/]"
+            )
+            mode_bar = (
+                "[bold #38bdf8]METRIC[/]  ·  [dim #fbbf24]ENTITY[/]   "
+                "(shift+tab to switch)"
+            )
+        else:
+            self.query_one("#find-title").update(
+                "FIND // [bold #fbbf24]ENTITY[/]"
+            )
+            mode_bar = (
+                "[dim #38bdf8]METRIC[/]  ·  [bold #fbbf24]ENTITY[/]   "
+                "(shift+tab to switch)"
+            )
+        self.query_one("#find-mode-bar").update(mode_bar)
+        placeholder = (
+            "Search metrics…" if self.mode == "metric" else "Search entities…"
+        )
+        self.query_one("#find-search-input", Input).placeholder = placeholder
+        other = next_find_mode(self.mode)
+        self.query_one("#find-hint").update(
+            f"[bold]shift+tab[/bold] switch to {other}  //  "
+            "[bold]tab[/bold]/[bold]enter[/bold] results  //  "
+            "[bold]i[/bold] inspect  //  "
+            "[bold]j[/bold]/[bold]k[/bold]  //  [bold]esc[/bold] close"
+        )
+
+    def _show_placeholder(self) -> None:
+        self._inspected_id = None
+        self.query_one("#find-inspect-payload", Static).update(_PLACEHOLDER)
+
+    def _highlighted_row(self) -> FindResultRow | None:
+        list_view = self.query_one("#find-results-list", ListView)
+        child = list_view.highlighted_child
+        if isinstance(child, FindResultRow):
+            return child
+        return None
+
+    def _add_resource(self, resource: Any) -> bool:
+        if isinstance(resource, Metric):
+            added = self.session.add_metric(resource.id)
+        elif isinstance(resource, Entity):
+            added = self.session.add_entity(resource.id)
+        elif resource.id in self.session.resource_ids():
+            return False
+        else:
+            return False
+        if added and hasattr(self.app, "remember_label"):
+            self.app.remember_label(resource.id, _resource_label(resource))
+        return added
+
+    def action_toggle_mode(self) -> None:
+        self.mode = next_find_mode(self.mode)
+        self._refresh_mode_chrome()
+        self.query_one("#find-results-list", ListView).clear()
+        self._show_placeholder()
+        query = self.query_one("#find-search-input", Input).value.strip()
+        if self.search_task:
+            self.search_task.cancel()
+        if len(query) >= 2:
+            self.search_task = asyncio.create_task(self._do_search(query))
+
+    @on(Input.Changed, "#find-search-input")
+    def on_search_changed(self, event: Input.Changed) -> None:
+        if self.search_task:
+            self.search_task.cancel()
+        if len(event.value.strip()) < 2:
+            self.query_one("#find-results-list", ListView).clear()
+            self._show_placeholder()
+            return
+        self.search_task = asyncio.create_task(self._do_search(event.value.strip()))
+
+    async def _do_search(self, query: str) -> None:
+        try:
+            await asyncio.sleep(0.3)
+            if self.mode == "entity":
+                results = await asyncio.to_thread(
+                    self.client.search_entities, query, limit=20
+                )
+            else:
+                results = await asyncio.to_thread(
+                    self.client.search_metrics, query, limit=20
+                )
+            list_view = self.query_one("#find-results-list", ListView)
+            list_view.clear()
+            self._show_placeholder()
+            for r in results:
+                list_view.append(FindResultRow(r))
+        except asyncio.CancelledError:
+            pass
+        except Exception as e:
+            self.notify(f"Search error: {e}", severity="error")
+
+    @on(Input.Submitted, "#find-search-input")
+    def on_search_submit(self) -> None:
+        self.query_one("#find-results-list", ListView).focus()
+
+    @on(ListView.Selected, "#find-results-list")
+    def on_result_selected(self, event: ListView.Selected) -> None:
+        if not isinstance(event.item, FindResultRow):
+            return
+        resource = event.item.resource
+        if not self._add_resource(resource):
+            self.notify(f"{resource.id} is already in session", severity="warning")
+            return
+        self.notify(f"Added {resource.id} to session")
+
+    @on(ListView.Highlighted, "#find-results-list")
+    def on_highlight_changed(self, event: ListView.Highlighted) -> None:
+        row = event.item if isinstance(event.item, FindResultRow) else None
+        if row is None or row.resource.id != self._inspected_id:
+            self._show_placeholder()
+
+    def action_inspect(self) -> None:
+        if isinstance(self.focused, Input):
+            return
+        row = self._highlighted_row()
+        if row is None:
+            self.notify("Select a result to inspect", severity="warning")
+            return
+        self.query_one("#find-inspect-payload", Static).update("Fetching...")
+        self._fetch_payload(row.resource_type, row.resource.id)
+
+    @work(exclusive=True)
+    async def _fetch_payload(self, resource_type: str, resource_id: str) -> None:
+        try:
+            data = await asyncio.to_thread(
+                self.client.make_request, f"{resource_type}/{resource_id}"
+            )
+            text = json.dumps(data, indent=2, default=str)
+            self._inspected_id = resource_id
+            self.query_one("#find-inspect-payload", Static).update(text)
+        except Exception as e:
+            self._inspected_id = None
+            self.query_one("#find-inspect-payload", Static).update(
+                f"Inspect failed: {e}"
+            )
+
+    def action_cursor_down(self) -> None:
+        focused = self.focused
+        if isinstance(focused, Input):
+            return
+        self.query_one("#find-results-list", ListView).action_cursor_down()
+
+    def action_cursor_up(self) -> None:
+        focused = self.focused
+        if isinstance(focused, Input):
+            return
+        self.query_one("#find-results-list", ListView).action_cursor_up()
+
+    def action_dismiss(self) -> None:
+        self.dismiss()

jstdata/workflows/host.py

@@ -0,0 +1,255 @@
+"""Workflow host: shared pipeline runtime and universal modals wiring."""
+
+from __future__ import annotations
+
+from textual.app import App, ComposeResult
+from textual.binding import Binding
+from textual.containers import Horizontal, Vertical
+from textual.screen import ModalScreen
+from textual.widgets import Input, Label
+
+from ..client import JSTDataClient
+from .base import (
+    ResolvedStep,
+    default_session_path,
+    hydrate_labels,
+    load_session_or_empty,
+)
+from .export import ExportModal
+from .find import FindModal
+from .session_manager import SessionManagerModal
+
+
+class HelpScreen(ModalScreen):
+    """Step-specific keybindings from the current StepSpec."""
+
+    DEFAULT_CSS = """
+    HelpScreen {
+        align: center middle;
+        background: rgba(0, 0, 0, 0.7);
+    }
+
+    #help-container {
+        width: 60;
+        height: auto;
+        max-height: 90%;
+        border: thick #4ade80;
+        background: #111111;
+        padding: 1 2;
+    }
+
+    #help-title {
+        text-style: bold;
+        color: #4ade80;
+        margin-bottom: 1;
+        text-align: center;
+    }
+
+    #help-note {
+        color: #888;
+        margin-bottom: 1;
+        text-align: center;
+    }
+
+    .key-row {
+        height: auto;
+        margin-bottom: 0;
+    }
+
+    .key-col {
+        color: #4ade80;
+        text-style: bold;
+        width: 16;
+    }
+
+    .desc-col {
+        color: #e0e0e0;
+        width: 1fr;
+    }
+
+    #help-footer {
+        color: #888;
+        margin-top: 1;
+        height: 1;
+    }
+    """
+
+    BINDINGS = [
+        Binding("escape", "dismiss", "Close"),
+        Binding("question_mark", "dismiss", "Close", show=False),
+    ]
+
+    def __init__(self, step_name: str, bindings: list) -> None:
+        super().__init__()
+        self.step_name = step_name
+        self.step_bindings = bindings
+
+    def compose(self) -> ComposeResult:
+        with Vertical(id="help-container"):
+            yield Label(f"{self.step_name.upper()} // KEYBINDINGS", id="help-title")
+            yield Label(
+                "Universal keys stay in the status bar (s/f/e/n/p/q).",
+                id="help-note",
+            )
+            if not self.step_bindings:
+                yield Label("(no step-specific bindings)", classes="desc-col")
+            else:
+                for b in self.step_bindings:
+                    if not getattr(b, "show_in_help", True):
+                        continue
+                    yield Horizontal(
+                        Label(b.key, classes="key-col"),
+                        Label(b.description, classes="desc-col"),
+                        classes="key-row",
+                    )
+            yield Label("[bold]esc[/bold] / [bold]?[/bold] close", id="help-footer", markup=True)
+
+    def action_dismiss(self) -> None:
+        self.dismiss()
+
+
+class WorkflowHost(App):
+    """One-process host for a pipeline of steps sharing a Session."""
+
+    CSS = """
+    Screen {
+        background: #0a0a0a;
+        color: #e0e0e0;
+    }
+    """
+
+    BINDINGS = [
+        Binding("q", "quit", "Quit"),
+        Binding("ctrl+c", "quit", "Quit"),
+        Binding("escape", "back", "Back"),
+        Binding("question_mark", "show_help", "Step help", key_display="?"),
+        Binding("s", "session", "Session"),
+        Binding("f", "find", "Find"),
+        Binding("e", "export", "Export"),
+        Binding("n", "next_step", "Next"),
+        Binding("p", "prev_step", "Prev"),
+    ]
+
+    def __init__(
+        self,
+        client: JSTDataClient,
+        steps: list[ResolvedStep],
+        session_path: str | None = None,
+        output_path: str | None = None,
+    ) -> None:
+        super().__init__()
+        if not steps:
+            raise ValueError("WorkflowHost requires at least one step")
+        self.client = client
+        self.steps = steps
+        self.step_index = 0
+        prefix = "-".join(s.spec.id for s in steps)
+        self.output_path = output_path or default_session_path(prefix)
+        self.session = load_session_or_empty(session_path)
+        self.labels: dict[str, str] = {}
+        hydrate_labels(self.client, self.session, self.labels)
+
+    def remember_label(self, resource_id: str, label: str) -> None:
+        """Cache a display label for UI (session remains source of truth)."""
+        self.labels[resource_id] = label or resource_id
+
+    @property
+    def step_count(self) -> int:
+        return len(self.steps)
+
+    @property
+    def current_step_id(self) -> str:
+        return self.steps[self.step_index].spec.id
+
+    @property
+    def current_step_spec(self):
+        return self.steps[self.step_index].spec
+
+    def check_action(self, action: str, parameters: tuple[object, ...]) -> bool | None:
+        # Let printable host keys fall through to focused Inputs (search, path, etc.).
+        if action in {"session", "find", "export", "next_step", "prev_step", "show_help"}:
+            if isinstance(self.focused, Input):
+                return False
+        return True
+
+    def on_mount(self) -> None:
+        self._push_current_step()
+
+    def _make_current_screen(self):
+        resolved = self.steps[self.step_index]
+        return resolved.spec.create_screen(
+            self.client,
+            self.session,
+            **resolved.kwargs,
+        )
+
+    def _push_current_step(self) -> None:
+        self.push_screen(self._make_current_screen())
+
+    def _pop_overlays(self) -> None:
+        """Dismiss modals. Keep the default screen plus the current step."""
+        while len(self.screen_stack) > 2:
+            self.pop_screen()
+
+    def action_next_step(self) -> None:
+        if self.step_index >= len(self.steps) - 1:
+            self.notify("Last step in the pipeline", severity="warning")
+            return
+        self._pop_overlays()
+        self.step_index += 1
+        self.switch_screen(self._make_current_screen())
+
+    def action_prev_step(self) -> None:
+        if self.step_index <= 0:
+            self.notify("First step in the pipeline", severity="warning")
+            return
+        self._pop_overlays()
+        self.step_index -= 1
+        self.switch_screen(self._make_current_screen())
+
+    def action_session(self) -> None:
+        """Shared session manager: remove / inspect staged resources."""
+        self.push_screen(
+            SessionManagerModal(self.client, self.session, self.labels)
+        )
+
+    def action_find(self) -> None:
+        """Shared find: search catalog and add resources to the session."""
+        self.push_screen(FindModal(self.client, self.session))
+
+    def action_export(self) -> None:
+        """Shared export: copy Python/CLI or write session file."""
+        self.push_screen(ExportModal(self.session, default_path=self.output_path))
+
+    def action_inspect(self) -> None:
+        screen = self.screen
+        if hasattr(screen, "action_inspect"):
+            screen.action_inspect()
+
+    def action_back(self) -> None:
+        """Leave step-local filter / inspector focus when applicable."""
+        focused = self.focused
+        screen = self.screen
+        if getattr(focused, "id", None) in (
+            "metrics-filter",
+            "search-input",
+        ) and hasattr(screen, "action_leave_filter"):
+            screen.action_leave_filter()
+            return
+        if focused and getattr(focused, "id", None) in (
+            "inspector-search-input",
+            "inspector-results-list",
+        ):
+            try:
+                screen.query_one("#search-input", Input).focus()
+            except Exception:
+                pass
+
+    def action_show_help(self) -> None:
+        """Show step-specific keybindings from the current StepSpec."""
+        spec = self.current_step_spec
+        self.push_screen(HelpScreen(spec.name, list(spec.bindings)))
+
+
+# Back-compat alias
+JSTDataApp = WorkflowHost