jnav 1.0.0__py3-none-any.whl

jnav/log_list_view.py

@@ -0,0 +1,292 @@
+from bisect import bisect_left
+from typing import TYPE_CHECKING, ClassVar, override
+
+from rich.console import RenderableType
+from rich.style import Style
+from textual.binding import BindingType
+from textual.events import Key
+
+from .filter_provider import FilterProvider
+from .filtering import text_search_expr
+from .key_sequences import KeySequence, KeySequenceMixin
+from .log_entry_item import LEVEL_COMPONENTS
+from .log_entry_renderer import EntryStyles, LogEntryRenderer
+from .log_model import LogModel
+from .role_mapper import RoleMapper
+from .search_engine import SearchEngine
+from .selector_provider import SelectorProvider
+from .store import IndexedEntry
+from .text_input_screen import TextInputScreen
+from .virtual_list_view import VirtualListView
+
+if TYPE_CHECKING:
+    from textual import getters
+    from textual.app import App
+
+
+class LogListView(KeySequenceMixin, VirtualListView[IndexedEntry]):
+    if TYPE_CHECKING:
+        app = getters.app(App[None])
+
+    COMPONENT_CLASSES: ClassVar[set[str]] = {
+        "summary--level-error",
+        "summary--level-fatal",
+        "summary--level-critical",
+        "summary--level-warning",
+        "summary--level-info",
+        "summary--level-debug",
+        "summary--level-trace",
+        "summary--text",
+        "summary--search-highlight",
+        "summary--cursor",
+        "tree--key",
+        "tree--key-selected",
+        "tree--value",
+        "tree--value-null",
+        "tree--json-string",
+        "tree--search-highlight",
+        "tree--background",
+    }
+
+    BINDINGS: ClassVar[list[BindingType]] = []
+
+    SEQUENCES: ClassVar[list[KeySequence]] = [
+        KeySequence("gg", "jump_top", "jump to top"),
+        KeySequence("ft", "text_filter", "text filter"),
+        KeySequence("fp", "toggle_filters_pause", "pause filters"),
+        KeySequence("vi", "toggle_expanded", "toggle inline tree"),
+    ]
+    SEQUENCE_GROUPS: ClassVar[dict[str, str]] = {"f": "filter ▸", "v": "view ▸"}
+
+    DEFAULT_CSS = """
+    LogListView {
+        height: 1fr;
+        background: $background;
+        & > .summary--level-error { color: $error; text-style: bold; }
+        & > .summary--level-fatal { color: $error; text-style: bold; }
+        & > .summary--level-critical { color: $error; text-style: bold; }
+        & > .summary--level-warning { color: $warning; text-style: bold; }
+        & > .summary--level-info { color: $primary; text-style: bold; }
+        & > .summary--level-debug { color: $success; text-style: bold; }
+        & > .summary--level-trace { color: $success; text-style: bold; }
+        & > .summary--text { color: $foreground; }
+        & > .summary--cursor { background: $primary 30%; }
+        & > .tree--background { background: $background-darken-1; }
+    }
+    """
+
+    def __init__(
+        self,
+        *,
+        model: LogModel,
+        role_mapper: RoleMapper,
+        selectors: SelectorProvider,
+        search: SearchEngine,
+        filter_provider: FilterProvider,
+        id: str | None = None,
+        follow: bool,
+    ) -> None:
+        super().__init__(
+            model=model,
+            render_item=self._render_entry,
+            id=id,
+            follow=follow,
+        )
+        self._log_model = model
+        self._role_mapper = role_mapper
+        self._selectors = selectors
+        self._search = search
+        self._filter_provider = filter_provider
+        self._expanded_mode: bool = True
+        self._renderer = LogEntryRenderer(
+            search=search,
+            role_mapper=role_mapper,
+            selectors=selectors,
+        )
+        self._entry_styles: EntryStyles | None = None
+        self._saved_store_idx: int = 0
+        self._saved_offset: int = 0
+
+    def _resolve_styles(self) -> EntryStyles:
+        base_bg = self.styles.background
+        cursor_color = self.get_component_styles("summary--cursor").background
+        blended = base_bg.blend(cursor_color, cursor_color.a)
+        return EntryStyles(
+            text=self.get_component_rich_style("summary--text", partial=True),
+            levels={
+                comp: self.get_component_rich_style(comp, partial=True)
+                for comp in LEVEL_COMPONENTS.values()
+            },
+            highlight=self.get_component_rich_style(
+                "summary--search-highlight", partial=True
+            ),
+            cursor_bg=Style(bgcolor=blended.rich_color),
+            tree_key=self.get_component_rich_style("tree--key", partial=True),
+            tree_key_selected=self.get_component_rich_style(
+                "tree--key-selected", partial=True
+            ),
+            tree_value=self.get_component_rich_style("tree--value", partial=True),
+            tree_value_null=self.get_component_rich_style(
+                "tree--value-null", partial=True
+            ),
+            tree_json_string=self.get_component_rich_style(
+                "tree--json-string", partial=True
+            ),
+            tree_search_highlight=self.get_component_rich_style(
+                "tree--search-highlight", partial=True
+            ),
+            tree_bg=self.get_component_styles("tree--background").background,
+            cursor_color=cursor_color,
+        )
+
+    @override
+    def render(self) -> RenderableType:
+        self._entry_styles = self._resolve_styles()
+        return super().render()
+
+    def _render_entry(self, ie: IndexedEntry, index: int) -> RenderableType:
+        assert self._entry_styles is not None
+        return self._renderer.render(
+            ie,
+            styles=self._entry_styles,
+            is_cursor=index == self.index,
+            expanded=self._expanded_mode,
+            width=self.size.width,
+        )
+
+    @override
+    async def on_mount(self) -> None:
+        await self._log_model.on_append.subscribe_async(self._on_append_discover)
+        await self._log_model.on_will_rebuild.subscribe_async(self._on_will_rebuild)
+        await self._log_model.on_rebuild.subscribe_async(self._on_rebuild)
+        await self._role_mapper.on_change.subscribe_async(
+            self._on_fields_or_search_changed
+        )
+        await self._selectors.on_change.subscribe_async(
+            self._on_fields_or_search_changed
+        )
+        await self._search.on_change.subscribe_async(self._on_fields_or_search_changed)
+
+    async def _on_fields_or_search_changed(self, _: None) -> None:
+        self.refresh()
+        self.refresh_bindings()
+
+    def on_focus(self) -> None:
+        if self.parent is not None:
+            self.parent.add_class("focused")
+
+    def on_blur(self) -> None:
+        if self.parent is not None:
+            self.parent.remove_class("focused")
+
+    def set_expanded_mode(self, expanded: bool) -> None:
+        offset = self.cursor_viewport_offset()
+        self._expanded_mode = expanded
+        self.scroll_to_cursor_offset(offset)
+        self.refresh()
+
+    @property
+    def expanded_mode(self) -> bool:
+        return self._expanded_mode
+
+    async def initial_build(self) -> None:
+        await self._role_mapper.discover(self._log_model.all())
+        self._rebuild()
+        if not self._log_model.is_empty():
+            self.index = 0
+
+    def current_index(self) -> int:
+        visible = self._log_model.visible_indices
+        if self.index < len(visible):
+            return visible[self.index]
+        return 0
+
+    def jump_to_index(self, store_idx: int) -> None:
+        visible = self._log_model.visible_indices
+        try:
+            self.index = visible.index(store_idx)
+        except ValueError:
+            pass
+
+    async def _on_append_discover(self, new_entries: list[IndexedEntry]) -> None:
+        await self._role_mapper.discover(new_entries)
+
+    async def _on_will_rebuild(self, _: None) -> None:
+        # Snapshot cursor state from the OLD view, before the model rebuilds.
+        if self._log_model.is_empty():
+            self._saved_store_idx = 0
+        else:
+            self._saved_store_idx = self._log_model.get(self.index).index
+        self._saved_offset = self.cursor_viewport_offset()
+
+    async def _on_rebuild(self, _: None) -> None:
+        self._rebuild()
+
+    def _rebuild(self) -> None:
+        if not self._log_model.is_empty():
+            # Find closest entry to previously highlighted store index and highlight it
+            self.index = self._closest_list_index(self._saved_store_idx)
+
+            # Scroll to approximately same viewport offset as before
+            self.scroll_to_cursor_offset(self._saved_offset)
+        else:
+            self.index = 0
+            self._scroll_top_index = 0
+            self._scroll_line_offset = 0
+
+        if self.is_mounted:
+            self.refresh()
+
+    def _closest_list_index(self, store_idx: int) -> int:
+        indices = self._log_model.visible_indices
+        if not indices:
+            return 0
+        pos = bisect_left(indices, store_idx)
+
+        # store_idx is at or before the first item
+        if pos == 0:
+            return 0
+
+        # store_idx is after all items
+        if pos >= len(indices):
+            return len(indices) - 1
+
+        # store_idx falls between two items; pick the closer one
+        before = store_idx - indices[pos - 1]
+        after = indices[pos] - store_idx
+        return pos if after < before else pos - 1
+
+    async def on_key(self, event: Key) -> None:
+        if await self._handle_sequence_key(event):
+            return
+
+    @override
+    def check_action(
+        self,
+        action: str,
+        parameters: tuple[object, ...],
+    ) -> bool | None:
+        del parameters  # unused
+        if action == "toggle_expanded":
+            return bool(self._selectors.active_selectors)
+        return True
+
+    def action_toggle_expanded(self) -> None:
+        self.set_expanded_mode(not self._expanded_mode)
+
+    def action_text_filter(self) -> None:
+        async def on_dismiss(term: str | None) -> None:
+            if term:
+                expr = text_search_expr(term)
+                await self._filter_provider.add_filter(expr, label=f"text: {term}")
+
+        self.app.push_screen(TextInputScreen("Text filter"), on_dismiss)
+
+    async def action_toggle_filters_pause(self) -> None:
+        if not self._filter_provider.root.children:
+            return
+        await self._log_model.set_filtering_enabled(
+            not self._log_model.filtering_enabled
+        )
+        state = "active" if self._log_model.filtering_enabled else "paused"
+        self.app.notify(f"Filters {state}", timeout=2)

jnav/log_model.py

@@ -0,0 +1,114 @@
+from typing import override
+
+import aioreactive as rx
+from aioreactive import AsyncSubject, pipe
+
+from jnav.filter_provider import FilterProvider
+from jnav.filtering import apply_filter_tree
+from jnav.model import Model
+from jnav.store import IndexedEntry, Store
+
+
+class LogModel(Model[IndexedEntry]):
+    _on_append: AsyncSubject[list[IndexedEntry]]
+    on_will_rebuild: AsyncSubject[None]
+    on_rebuild: AsyncSubject[None]
+    _filtering_enabled: bool
+    _view: list[int]
+
+    def __init__(
+        self,
+        store: Store,
+        filter_provider: FilterProvider,
+    ):
+        self._store = store
+        self._filter_provider = filter_provider
+        self._on_append = AsyncSubject[list[IndexedEntry]]()
+        self.on_will_rebuild = AsyncSubject[None]()
+        self.on_rebuild = AsyncSubject[None]()
+        self._filtering_enabled = True
+        self._view = []
+
+    @property
+    @override
+    def on_append(self) -> AsyncSubject[list[IndexedEntry]]:
+        return self._on_append
+
+    async def start(self) -> None:
+        await self._filter_provider.on_change.subscribe_async(self.refilter)
+        filtered_append = pipe(
+            self._store.on_append,
+            rx.map(self._filter_batch),
+            rx.filter(lambda batch: len(batch) > 0),
+        )
+        await filtered_append.subscribe_async(self._append_to_view)
+
+    async def _append_to_view(self, batch: list[IndexedEntry]) -> None:
+        self._view.extend(ie.index for ie in batch)
+        await self._on_append.asend(batch)
+
+    def _filter_batch(self, batch: list[IndexedEntry]) -> list[IndexedEntry]:
+        return [i for i in batch if self._apply_filters(i)]
+
+    def _apply_filters(self, indexed_entry: IndexedEntry) -> bool:
+        if not self._filtering_enabled:
+            return True
+        root = self._filter_provider.root
+        matched, error = apply_filter_tree(root, [indexed_entry.entry.expanded])
+        return error is not None or len(matched) > 0
+
+    def _rebuild_view(self) -> None:
+        if not self._filtering_enabled:
+            self._view = list(range(len(self._store)))
+        else:
+            root = self._filter_provider.root
+            entries = [e.entry.expanded for e in self._store.all()]
+            matched, _error = apply_filter_tree(root, entries)
+            self._view = matched
+
+    def total_count(self) -> int:
+        return len(self._store)
+
+    @override
+    def count(self) -> int:
+        return len(self._view)
+
+    def all(self) -> list[IndexedEntry]:
+        return self._store.all()
+
+    @override
+    def is_empty(self) -> bool:
+        return len(self._view) == 0
+
+    @override
+    def get(self, pos: int) -> IndexedEntry:
+        return self._store.get(self._view[pos])
+
+    @property
+    def visible_entries(self) -> list[IndexedEntry]:
+        return [self._store.get(i) for i in self._view]
+
+    @property
+    def visible_indices(self) -> list[int]:
+        return list(self._view)
+
+    @property
+    def filtering_enabled(self) -> bool:
+        return self._filtering_enabled
+
+    async def set_filtering_enabled(self, value: bool) -> None:
+        await self.on_will_rebuild.asend(None)
+        self._filtering_enabled = value
+        self._rebuild_view()
+        await self.on_rebuild.asend(None)
+
+    async def pause_filtering(self) -> None:
+        await self.set_filtering_enabled(False)
+
+    async def resume_filtering(self) -> None:
+        await self.set_filtering_enabled(True)
+
+    async def refilter(self, _: None) -> None:
+        await self.on_will_rebuild.asend(None)
+        self._rebuild_view()
+        await self.on_rebuild.asend(None)

jnav/logging.py

@@ -0,0 +1,52 @@
+import logging
+from datetime import UTC, datetime
+from logging import FileHandler
+from typing import override
+
+from pythonjsonlogger.core import LogData
+from pythonjsonlogger.json import JsonFormatter
+
+
+class HLJsonFormatter(JsonFormatter):
+    @override
+    def process_log_record(self, log_data: LogData) -> LogData:
+        log_data = super().process_log_record(log_data)
+        log_data["caller"] = f"{log_data['filename']}:{log_data['lineno']}"
+        log_data.pop("filename", None)
+        log_data.pop("lineno", None)
+        log_data.pop("funcName", None)
+        if log_data.get("exc_info") is None:
+            log_data.pop("exc_info", None)
+        log_data["ts"] = datetime.fromtimestamp(log_data["created"], tz=UTC).isoformat()
+        log_data.pop("created", None)
+        return log_data
+
+
+def init_logging() -> None:
+    file_handler = FileHandler("jnav.log", mode="a", encoding="utf-8")
+    file_handler.setFormatter(
+        HLJsonFormatter(
+            [
+                "message",
+                "levelname",
+                "filename",
+                "lineno",
+                "funcName",
+                "name",
+                "exc_info",
+                "caller",
+                "created",
+            ],
+            rename_fields={
+                "levelname": "level",
+                "name": "logger",
+            },
+        )
+    )
+    file_handler.setLevel(logging.DEBUG)
+
+    logging.basicConfig(
+        level=logging.NOTSET,
+        format="%(message)s",
+        handlers=[file_handler],
+    )

jnav/manager_screen_common.py

@@ -0,0 +1,27 @@
+from typing import override
+
+from rich.text import Text
+from textual.app import ComposeResult
+from textual.widgets import Footer
+
+
+class WrappingFooter(Footer):
+    def __init__(self, *, columns: int = 4) -> None:
+        super().__init__()
+        self._columns = columns
+
+    @override
+    def compose(self) -> ComposeResult:
+        yield from super().compose()
+        self.styles.grid_size_columns = self._columns
+
+
+def list_option_prompt(label: str, enabled: bool, combine: str = "and") -> Text:
+    marker = "\u2713" if enabled else " "
+    style = "" if enabled else "dim"
+    prefix = "OR " if combine == "or" else "   "
+    return Text.assemble(
+        (prefix, "italic" if combine == "or" else "dim"),
+        (f"{marker} ", style),
+        (label, style),
+    )

jnav/model.py

@@ -0,0 +1,13 @@
+from collections.abc import Sequence
+from typing import Protocol
+
+from aioreactive import AsyncObservable
+
+
+class Model[T](Protocol):
+    @property
+    def on_append(self) -> AsyncObservable[Sequence[T]]: ...
+
+    def get(self, pos: int) -> T: ...
+    def count(self) -> int: ...
+    def is_empty(self) -> bool: ...

jnav/offset_group.py

@@ -0,0 +1,30 @@
+from collections.abc import Generator
+
+from rich.console import Console, ConsoleOptions, Group, RenderableType
+from rich.segment import Segment
+
+
+class OffsetGroup:
+    """A Rich renderable that renders a group of items, skipping the first N lines.
+
+    Used by VirtualListView to handle partial visibility of the topmost item
+    when the viewport is scrolled partway into it.
+    """
+
+    def __init__(
+        self,
+        renderables: list[RenderableType],
+        skip_lines: int,
+    ) -> None:
+        self._group = Group(*renderables)
+        self._skip = skip_lines
+
+    def __rich_console__(
+        self, console: Console, options: ConsoleOptions
+    ) -> Generator[Segment]:
+        segments = console.render(self._group, options)
+        for i, line in enumerate(Segment.split_lines(segments)):
+            if i < self._skip:
+                continue
+            yield from line
+            yield Segment.line()

jnav/parsing.py

@@ -0,0 +1,101 @@
+from dataclasses import dataclass, field
+from typing import Any, cast
+
+import orjson
+
+
+@dataclass
+class ParsedEntry:
+    raw: str
+    expanded: dict[str, Any]
+    expanded_paths: set[str] = field(default_factory=set)
+
+
+def parse_entry(line: str) -> ParsedEntry | None:
+    """Parse a JSON line into a ``ParsedEntry`` with nested JSON-encoded
+    strings expanded in place. Returns ``None`` for blank lines, invalid
+    JSON, and JSON that isn't an object."""
+    stripped = line.strip()
+    if not stripped:
+        return None
+    parsed = _try_parse_json(stripped)
+    if not isinstance(parsed, dict):
+        return None
+    expanded_paths: set[str] = set()
+    _expand_in_place(
+        parsed,
+        path="",
+        expanded_paths=expanded_paths,
+    )
+    return ParsedEntry(
+        raw=stripped,
+        expanded=parsed,
+        expanded_paths=expanded_paths,
+    )
+
+
+def _expand_in_place(
+    obj: dict[str, Any] | list[Any],
+    *,
+    path: str,
+    expanded_paths: set[str],
+) -> None:
+    """Recursively replace JSON-encoded string values with their parsed
+    objects, mutating dicts and lists in place."""
+    match obj:
+        case dict():
+            for k, v in obj.items():
+                _expand_slot(
+                    obj,
+                    key=k,
+                    value=v,
+                    child_path=f"{path}.{k}" if path else k,
+                    expanded_paths=expanded_paths,
+                )
+        case list():
+            for i, v in enumerate(obj):
+                _expand_slot(
+                    obj,
+                    key=i,
+                    value=v,
+                    child_path=f"{path}[{i}]",
+                    expanded_paths=expanded_paths,
+                )
+
+
+def _expand_slot(
+    container: dict[str, Any] | list[Any],
+    *,
+    key: str | int,
+    value: object,
+    child_path: str,
+    expanded_paths: set[str],
+) -> None:
+    # If the value is a string, try to parse it as JSON
+    if isinstance(value, str):
+        parsed = _try_parse_json(value)
+        if parsed is not None:
+            container[key] = parsed  # pyright: ignore[reportArgumentType, reportCallIssue]
+            expanded_paths.add(child_path)
+            value = parsed
+
+    # If the value is now a dict or list, recursively expand it
+    if isinstance(value, (dict, list)):
+        value = cast(dict[str, Any] | list[Any], value)
+        _expand_in_place(
+            value,
+            path=child_path,
+            expanded_paths=expanded_paths,
+        )
+
+
+def _try_parse_json(value: str) -> dict[str, Any] | list[Any] | None:
+    if not value or value[0] not in ("{", "["):
+        return None
+    try:
+        parsed = orjson.loads(value)
+    except orjson.JSONDecodeError, ValueError:
+        return None
+    if isinstance(parsed, (dict, list)) and parsed:
+        return cast(dict[str, Any] | list[Any], parsed)
+    return None

jnav/reading.py

@@ -0,0 +1,52 @@
+import asyncio
+import logging
+import os
+import sys
+from collections.abc import AsyncIterator
+from io import BufferedReader
+
+logger = logging.getLogger(__name__)
+
+
+async def read_file(path: str, *, tail: bool = True) -> AsyncIterator[str]:
+    """Yield lines from a file, optionally tailing for new content at EOF."""
+    with open(path, mode="r", errors="replace") as f:  # noqa: ASYNC230
+        while True:
+            line = f.readline()
+
+            if not line:
+                if not tail:
+                    return
+                await asyncio.sleep(0.1)
+                continue
+
+            yield line
+
+
+async def read_pipe(pipe: BufferedReader) -> AsyncIterator[str]:
+    """Yield lines from a pipe using asyncio stream reader."""
+    loop = asyncio.get_running_loop()
+    reader = asyncio.StreamReader()
+    protocol = asyncio.StreamReaderProtocol(reader)
+    await loop.connect_read_pipe(lambda: protocol, pipe)
+    while not reader.at_eof():
+        line_bytes = await reader.readline()
+        if line_bytes:
+            yield line_bytes.decode(errors="replace")
+
+
+def setup_stdin_pipe() -> BufferedReader:
+    """Duplicate stdin to a separate file descriptor.
+    This is required for TUI input handling, while we read piped input.
+    """
+    pipe = os.fdopen(os.dup(sys.stdin.fileno()), "rb")
+    sys.stdin.close()
+    try:
+        tty = open("/dev/tty")  # noqa: SIM115, replaces sys.stdin, must outlive this function
+    except OSError:
+        pipe.close()
+        raise
+    sys.stdin = tty
+    sys.__stdin__ = tty
+
+    return pipe