jnav 1.0.0__py3-none-any.whl

jnav/inline_tree.py

@@ -0,0 +1,75 @@
+from rich.style import Style
+from rich.text import Text
+from rich.tree import Tree as RichTree
+
+from .filtering import get_nested
+from .parsing import ParsedEntry
+from .search_engine import SearchEngine
+from .tree_rendering import TreeBuildVisitor, walk_tree
+
+
+def _add_branch(
+    parent: RichTree,
+    label: Text,
+    path: str,
+    value: object,
+) -> RichTree:
+    del path, value  # unused
+    return parent.add(label)
+
+
+def _add_leaf(
+    parent: RichTree,
+    label: Text,
+    path: str,
+    value: object,
+) -> None:
+    del path, value  # unused
+    parent.add(label)
+
+
+def render_inline_tree(
+    parsed: ParsedEntry,
+    *,
+    custom_fields: set[str],
+    search: SearchEngine | None = None,
+    key_style: Style | None = None,
+    selected_style: Style | None = None,
+    value_style: Style | None = None,
+    value_null_style: Style | None = None,
+    json_string_style: Style | None = None,
+    search_highlight_style: Style | None = None,
+) -> RichTree | None:
+    if not custom_fields:
+        return None
+    _default = Style()
+    values = [(f, get_nested(parsed.expanded, f)) for f in custom_fields]
+
+    # Filter out selectors with no matches
+    filtered = {f: v for f, v in values if v is not None}
+
+    # Don't render the tree if there are no selectors with matches
+    if not filtered:
+        return None
+
+    tree = RichTree("", guide_style="dim", hide_root=True)
+    visitor = TreeBuildVisitor(
+        root=tree,
+        add_branch=_add_branch,
+        add_leaf=_add_leaf,
+        selected=custom_fields,
+        key_style=key_style or _default,
+        selected_style=selected_style or _default,
+        value_style=value_style or _default,
+        value_null_style=value_null_style or _default,
+        json_string_style=json_string_style or _default,
+        search_highlight_style=search_highlight_style or _default,
+        search_term=search.term if search else None,
+    )
+    walk_tree(
+        value=filtered,
+        path="",
+        visitor=visitor,
+        json_paths=parsed.expanded_paths,
+    )
+    return tree

jnav/key_sequences.py

@@ -0,0 +1,211 @@
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, ClassVar
+
+from textual.binding import Binding, BindingsMap
+
+if TYPE_CHECKING:
+    from textual.events import Key
+
+
+# pyright: reportUninitializedInstanceVariable=false
+# pyright: reportAttributeAccessIssue=false
+# pyright: reportUnknownMemberType=false
+# pyright: reportUnknownVariableType=false
+# pyright: reportUnknownArgumentType=false
+
+
+@dataclass(frozen=True)
+class KeySequence:
+    keys: str
+    action: str
+    description: str = ""
+    show: bool = True
+    id: str | None = None
+
+
+class KeySequenceMixin:
+    """Mixin that adds multi-key sequence support to a Textual widget.
+
+    Usage::
+
+        class MyWidget(KeySequenceMixin, Tree):
+            SEQUENCES = [
+                KeySequence("ff", "filter_and", "Filter AND"),
+                KeySequence("fo", "filter_or", "Filter OR"),
+            ]
+            SEQUENCE_GROUPS = {"f": "Filter..."}
+
+            async def on_key(self, event: Key) -> None:
+                if await self._handle_sequence_key(event):
+                    return
+
+    SEQUENCES maps key strings (min 2 chars) to actions.
+    SEQUENCE_GROUPS maps a prefix character to a label shown in the
+    footer (e.g. ``"f"`` -> ``"Filter..."``). Prefixes without an
+    entry still work but won't show a footer hint.
+    """
+
+    SEQUENCES: ClassVar[list[KeySequence]] = []
+    SEQUENCE_GROUPS: ClassVar[dict[str, str]] = {}
+
+    _seq_buffer: str = ""
+    _seq_pending: bool = False
+    _seq_saved_bindings: BindingsMap | None = None
+    _seq_saved_ancestor_bindings: list[tuple[object, BindingsMap]] = []  # noqa: RUF012
+    _seq_keymap: dict[str, str] = {}  # noqa: RUF012
+    _seq_lookup: dict[str, KeySequence] = {}  # noqa: RUF012
+    _seq_prefixes: dict[str, str] = {}  # noqa: RUF012
+    _seq_base_bindings: BindingsMap | None = None
+
+    async def on_mount(self) -> None:
+        self._seq_buffer = ""
+        self._seq_pending = False
+        self._seq_saved_bindings = None
+        self._seq_base_bindings = None
+        self._rebuild_sequences()
+
+    def _rebuild_sequences(self) -> None:
+        if self._seq_pending:
+            self._seq_pending = False
+            self._seq_buffer = ""
+            if self._seq_saved_bindings is not None:
+                self._bindings = self._seq_saved_bindings
+                self._seq_saved_bindings = None
+
+        self._seq_lookup = self._build_seq_lookup()
+        self._seq_prefixes = self._build_seq_prefixes()
+
+        if self._seq_base_bindings is None:
+            self._seq_base_bindings = self._bindings.copy()
+        else:
+            self._bindings = self._seq_base_bindings.copy()
+
+        self._inject_prefix_bindings()
+
+    def _build_seq_lookup(self) -> dict[str, KeySequence]:
+        lookup: dict[str, KeySequence] = {}
+        for seq in self.SEQUENCES:
+            keys = seq.keys
+            if seq.id and seq.id in self._seq_keymap:
+                keys = self._seq_keymap[seq.id]
+            if len(keys) < 2:
+                msg = f"Sequence keys must be at least 2 characters, got {keys!r}"
+                raise ValueError(msg)
+            lookup[keys] = seq
+        return lookup
+
+    def _build_seq_prefixes(self) -> dict[str, str]:
+        prefixes: dict[str, str] = {}
+        for keys in self._seq_lookup:
+            char = keys[0]
+            if char not in prefixes:
+                prefixes[char] = self.SEQUENCE_GROUPS.get(char, "")
+        return prefixes
+
+    def _inject_prefix_bindings(self) -> None:
+        # Build prefix bindings first, then prepend them so they appear before
+        # the widget's own bindings in the footer.
+        prefix_entries: list[tuple[str, Binding]] = []
+        for char, label in self._seq_prefixes.items():
+            self._bindings.key_to_bindings.pop(char, None)
+            if label:
+                prefix_entries.append((
+                    char,
+                    Binding(char, f"_seq_prefix_{char}", label),
+                ))
+        if not prefix_entries:
+            return
+        existing = dict(self._bindings.key_to_bindings)
+        self._bindings.key_to_bindings.clear()
+        for char, binding in prefix_entries:
+            self._bindings.key_to_bindings[char] = [binding]
+        for key, bindings in existing.items():
+            self._bindings.key_to_bindings[key] = bindings
+
+    async def _handle_sequence_key(self, event: Key) -> bool:
+        if self._seq_pending:
+            event.prevent_default()
+            event.stop()
+
+            if event.key == "escape":
+                self._reset_sequence()
+                return True
+
+            self._seq_buffer += event.key
+
+            has_longer = any(
+                k.startswith(self._seq_buffer) and k != self._seq_buffer
+                for k in self._seq_lookup
+            )
+            if has_longer:
+                self._show_continuations(self._seq_buffer)
+                return True
+
+            if self._seq_buffer in self._seq_lookup:
+                seq = self._seq_lookup[self._seq_buffer]
+                self._reset_sequence()
+                await self.run_action(seq.action)
+                return True
+
+            self._reset_sequence()
+            return True
+
+        if event.key in self._seq_prefixes:
+            self._seq_pending = True
+            self._seq_buffer = event.key
+            event.prevent_default()
+            event.stop()
+            self._show_continuations(event.key)
+            return True
+
+        return False
+
+    def _show_continuations(self, prefix: str) -> None:
+        if self._seq_saved_bindings is None:
+            self._seq_saved_bindings = self._bindings
+            self._hide_ancestor_bindings()
+
+        continuations: list[Binding] = []
+        seen: set[str] = set()
+        for keys, seq in self._seq_lookup.items():
+            if keys.startswith(prefix) and len(keys) > len(prefix):
+                next_char = keys[len(prefix)]
+                if next_char not in seen:
+                    seen.add(next_char)
+                    continuations.append(
+                        Binding(
+                            next_char,
+                            f"_seq_cont_{seq.action}",
+                            seq.description,
+                            show=seq.show,
+                        )
+                    )
+        continuations.append(Binding("escape", "_seq_cancel", "Cancel", show=False))
+        self._bindings = BindingsMap(continuations)
+        self.refresh_bindings()
+
+    def _reset_sequence(self) -> None:
+        self._seq_pending = False
+        self._seq_buffer = ""
+        if self._seq_saved_bindings is not None:
+            self._bindings = self._seq_saved_bindings
+            self._seq_saved_bindings = None
+        self._restore_ancestor_bindings()
+        self.refresh_bindings()
+
+    def _hide_ancestor_bindings(self) -> None:
+        self._seq_saved_ancestor_bindings = []
+        for ancestor in self.ancestors_with_self[1:]:
+            if hasattr(ancestor, "_bindings"):
+                self._seq_saved_ancestor_bindings.append((ancestor, ancestor._bindings))
+                ancestor._bindings = BindingsMap([])
+
+    def _restore_ancestor_bindings(self) -> None:
+        for ancestor, bindings in self._seq_saved_ancestor_bindings:
+            ancestor._bindings = bindings
+        self._seq_saved_ancestor_bindings = []
+
+    def set_sequence_keymap(self, keymap: dict[str, str]) -> None:
+        self._seq_keymap = keymap
+        self._rebuild_sequences()
+        self.refresh_bindings()

jnav/log_entry_item.py

@@ -0,0 +1,96 @@
+from datetime import UTC, datetime
+
+from rich.style import Style
+from rich.text import Text
+
+from .field_mapping import FieldMapping, TimestampFormat
+from .parsing import ParsedEntry
+from .search_engine import SearchEngine
+from .tree_rendering import highlight_text
+
+LEVEL_COMPONENTS = {
+    "error": "summary--level-error",
+    "fatal": "summary--level-fatal",
+    "critical": "summary--level-critical",
+    "warn": "summary--level-warning",
+    "warning": "summary--level-warning",
+    "info": "summary--level-info",
+    "debug": "summary--level-debug",
+    "trace": "summary--level-trace",
+}
+
+_EPOCH_DIVISORS: dict[TimestampFormat, int] = {
+    "epoch_s": 1,
+    "epoch_ms": 1_000,
+    "epoch_us": 1_000_000,
+    "epoch_ns": 1_000_000_000,
+}
+
+
+def format_timestamp(value: object, fmt: TimestampFormat) -> str:
+    """Format a timestamp value as HH:MM:SS.mmm. Falls back to the raw string
+    representation on any parsing failure."""
+    try:
+        if fmt == "iso8601":
+            dt = datetime.fromisoformat(str(value))
+        else:
+            if not isinstance(value, (int, float)) or isinstance(value, bool):
+                return str(value)
+            dt = datetime.fromtimestamp(float(value) / _EPOCH_DIVISORS[fmt], tz=UTC)
+        return dt.strftime("%H:%M:%S") + f".{dt.microsecond // 1000:03d}"
+    except ValueError, TypeError, OSError, OverflowError:
+        return str(value)
+
+
+def _get_level_shorthand(value: str) -> str:
+    s = value[0]
+    remainder = value[1:].lower()
+    vowels = set("aeiouy")
+    s += "".join(c for c in remainder if c not in vowels)
+    s = s.upper()
+    if len(s) > 3:
+        s = s[:3]
+    return s
+
+
+def render_summary(
+    parsed: ParsedEntry,
+    mapping: FieldMapping,
+    search: SearchEngine | None = None,
+    *,
+    text_style: Style | None = None,
+    level_styles: dict[str, Style] | None = None,
+    highlight_style: Style | None = None,
+) -> Text:
+    _ts = text_style or Style()
+    _hl = highlight_style or Style()
+    parts: list[str | tuple[str, str | Style]] = [" "]
+
+    if mapping.timestamp is not None:
+        ts_val = parsed.expanded.get(mapping.timestamp.path)
+        if ts_val not in (None, ""):
+            parts.append((format_timestamp(ts_val, mapping.timestamp.format), _ts))
+            parts.append(" ")
+
+    if mapping.level is not None:
+        level_val = parsed.expanded.get(mapping.level)
+        level_str = str(level_val) if level_val else ""
+        if level_str:
+            component = LEVEL_COMPONENTS.get(level_str.strip().lower())
+            short = _get_level_shorthand(level_str)
+            if component and level_styles and component in level_styles:
+                parts.append((short, level_styles[component]))
+            else:
+                parts.append((short, _ts))
+            parts.append(" ")
+
+    if mapping.message is not None:
+        msg_val = parsed.expanded.get(mapping.message)
+        msg_str = str(msg_val) if msg_val or msg_val == 0 else ""
+        parts.append((msg_str, _ts))
+
+    text = Text.assemble(*parts)
+    text.no_wrap = True
+    text.overflow = "ellipsis"
+    search_term = search.term if search else None
+    return highlight_text(text, search_term, _hl)

jnav/log_entry_renderer.py

@@ -0,0 +1,90 @@
+from dataclasses import dataclass
+
+from rich.console import Group, RenderableType
+from rich.padding import Padding
+from rich.style import Style
+from textual.color import Color
+
+from .inline_tree import render_inline_tree
+from .log_entry_item import render_summary
+from .role_mapper import RoleMapper
+from .search_engine import SearchEngine
+from .selector_provider import SelectorProvider
+from .store import IndexedEntry
+
+
+@dataclass(frozen=True)
+class EntryStyles:
+    text: Style
+    levels: dict[str, Style]
+    highlight: Style
+    cursor_bg: Style
+    tree_key: Style
+    tree_key_selected: Style
+    tree_value: Style
+    tree_value_null: Style
+    tree_json_string: Style
+    tree_search_highlight: Style
+    tree_bg: Color
+    cursor_color: Color
+
+
+class LogEntryRenderer:
+    def __init__(
+        self,
+        *,
+        search: SearchEngine,
+        role_mapper: RoleMapper,
+        selectors: SelectorProvider,
+    ) -> None:
+        self._search = search
+        self._role_mapper = role_mapper
+        self._selectors = selectors
+
+    def render(
+        self,
+        ie: IndexedEntry,
+        *,
+        styles: EntryStyles,
+        is_cursor: bool,
+        expanded: bool,
+        width: int,
+    ) -> RenderableType:
+        text = render_summary(
+            ie.entry,
+            self._role_mapper.mapping,
+            self._search,
+            text_style=styles.text,
+            level_styles=styles.levels,
+            highlight_style=styles.highlight,
+        )
+        text.truncate(width - 2, overflow="ellipsis", pad=False)
+
+        if is_cursor:
+            text.stylize(styles.cursor_bg)
+            text.pad_right(width - text.cell_len)
+            text.style = styles.cursor_bg
+
+        if not expanded:
+            return text
+
+        tree = render_inline_tree(
+            ie.entry,
+            custom_fields=self._selectors.active_selectors,
+            search=self._search,
+            key_style=styles.tree_key,
+            selected_style=styles.tree_key_selected,
+            value_style=styles.tree_value,
+            value_null_style=styles.tree_value_null,
+            json_string_style=styles.tree_json_string,
+            search_highlight_style=styles.tree_search_highlight,
+        )
+        if tree is None:
+            return text
+
+        tree_bg = styles.tree_bg
+        if is_cursor:
+            tree_bg = tree_bg.blend(styles.cursor_color, styles.cursor_color.a * 0.66)
+        tree_style = Style(bgcolor=tree_bg.rich_color)
+        padded_tree = Padding(tree, (0, 2, 0, 5), style=tree_style, expand=True)
+        return Group(text, padded_tree)