seejx 0.3.0__py3-none-any.whl

seejx/__init__.py

@@ -0,0 +1,20 @@
+"""seejx - Interactive JSONL browser with rich rendering and full-screen scrolling.
+
+Fork of `seej` (MIT, © 2025 Lei Zhang) with an in-app full-screen scroll
+viewer: trackpad / mouse-wheel / arrow-key scrolling, wcwidth-aware wrapping,
+and a soft status bar. See NOTICE for details.
+"""
+
+__version__ = "0.3.0"
+
+from .see_jsonl import main
+from .renderers import register_renderer, get_renderer
+from .conditions import SafeExampleProxy, build_condition_function
+
+__all__ = [
+    "main",
+    "register_renderer",
+    "get_renderer",
+    "SafeExampleProxy",
+    "build_condition_function",
+]

seejx/conditions.py

@@ -0,0 +1,178 @@
+"""Condition parsing and evaluation for filtering examples."""
+
+import ast
+import operator
+from typing import Any, Callable, Optional
+from rich.console import Console
+
+console = Console()
+
+
+class SafeExampleProxy:
+    """安全的样本代理，支持 ex['key'] 和 ex.key 两种语法"""
+
+    def __init__(self, data: dict):
+        self._data = data
+
+    def __getitem__(self, key):
+        """支持 ex['key'] 语法"""
+        return self._data.get(key)
+
+    def __getattr__(self, key):
+        """支持 ex.key 语法"""
+        if key.startswith("_"):
+            raise AttributeError(f"Cannot access private attribute: {key}")
+        return self._data.get(key)
+
+    def __contains__(self, key):
+        """支持 'key' in ex"""
+        return key in self._data
+
+    def get(self, key, default=None):
+        """支持 ex.get('key', default)"""
+        return self._data.get(key, default)
+
+
+def create_safe_namespace():
+    """创建安全的执行命名空间"""
+    # 只允许安全的内置函数和操作符
+    safe_builtins = {
+        "len": len,
+        "str": str,
+        "int": int,
+        "float": float,
+        "bool": bool,
+        "list": list,
+        "dict": dict,
+        "tuple": tuple,
+        "set": set,
+        "abs": abs,
+        "min": min,
+        "max": max,
+        "sum": sum,
+        "any": any,
+        "all": all,
+        "isinstance": isinstance,
+        "True": True,
+        "False": False,
+        "None": None,
+    }
+    return safe_builtins
+
+
+def validate_condition_syntax(condition: str) -> tuple[bool, Optional[str]]:
+    """
+    验证条件表达式的语法安全性
+
+    Returns:
+        (is_valid, error_message)
+    """
+    # 检查是否包含 'ex'
+    if "ex" not in condition:
+        return False, "Condition must reference 'ex' (e.g., ex['field'] == 'value')"
+
+    # 尝试解析 AST
+    try:
+        tree = ast.parse(condition, mode="eval")
+    except SyntaxError as e:
+        return False, f"Syntax error: {e}"
+
+    # 检查危险操作
+    dangerous_nodes = (
+        ast.Import,
+        ast.ImportFrom,  # 禁止导入
+        ast.Call,  # 暂时禁止所有函数调用（可以放宽）
+    )
+
+    for node in ast.walk(tree):
+        # 允许安全的函数调用
+        if isinstance(node, ast.Call):
+            if isinstance(node.func, ast.Name):
+                func_name = node.func.id
+                if func_name not in create_safe_namespace():
+                    return False, f"Function '{func_name}' is not allowed"
+
+        # 禁止其他危险操作
+        if isinstance(node, (ast.Import, ast.ImportFrom)):
+            return False, "Import statements are not allowed"
+
+    return True, None
+
+
+def build_condition_function(conditions: list[str]) -> Optional[Callable]:
+    """
+    构建条件过滤函数
+
+    Args:
+        conditions: 条件表达式列表，例如 ["ex['type'] == 'chat'", "len(ex['messages']) > 5"]
+
+    Returns:
+        过滤函数或 None
+    """
+    if not conditions:
+        return None
+
+    console.print("[bold]Building filter conditions:[/bold]")
+
+    # 验证并处理每个条件
+    validated_conditions = []
+    for idx, cond in enumerate(conditions, 1):
+        cond = cond.strip()
+        if not cond:
+            continue
+
+        is_valid, error = validate_condition_syntax(cond)
+        if not is_valid:
+            console.print(f"[red]✗[/red] Condition {idx}: {cond}")
+            console.print(f"  [red]Error: {error}[/red]")
+            continue
+
+        validated_conditions.append(cond)
+        console.print(f"[green]✓[/green] Condition {idx}: [cyan]{cond}[/cyan]")
+
+    if not validated_conditions:
+        console.print("[yellow]Warning: No valid conditions, showing all examples[/yellow]")
+        return None
+
+    # 组合所有条件
+    combined_expr = " and ".join(f"({c})" for c in validated_conditions)
+    console.print(f"\n[bold]Combined:[/bold] [dim]{combined_expr}[/dim]\n")
+
+    # 编译表达式
+    try:
+        compiled_code = compile(combined_expr, "<condition>", "eval")
+    except Exception as e:
+        console.print(f"[red]Failed to compile conditions: {e}[/red]")
+        return None
+
+    # 创建安全的命名空间
+    safe_namespace = create_safe_namespace()
+
+    def condition_filter(example: dict) -> bool:
+        """实际的过滤函数"""
+        try:
+            # 创建代理对象
+            ex = SafeExampleProxy(example)
+            # 在安全命名空间中执行
+            namespace = {**safe_namespace, "ex": ex}
+            result = eval(compiled_code, {"__builtins__": {}}, namespace)
+            return bool(result)
+        except KeyError as e:
+            # 字段不存在时返回 False
+            return False
+        except Exception as e:
+            # 其他错误：打印警告但不中断
+            # console.print(f"[yellow]Warning: Condition evaluation error: {e}[/yellow]")
+            return False
+
+    try:
+        console.print(f"\n[red][bold]>>>Press any key to see jsonl!<<<\n[/bold][/red]")
+        input()
+    except KeyboardInterrupt:
+        console.print(f"\n[bold]Keyboard Interruptted[/bold]\n")
+        exit(0)
+
+    return condition_filter
+
+
+# ============ 向后兼容的旧版解析（可选保留） ============

seejx/config.py

@@ -0,0 +1,82 @@
+"""Configuration parsing for seejx."""
+
+from typing import Dict, Callable
+from rich.console import Console
+from rich.table import Table
+from .renderers.base import get_renderer, list_renderers, get_all_renderer_names
+
+console = Console()
+
+
+def parse_render_mappings(render_args) -> Dict[str, Callable]:
+    """解析渲染映射参数"""
+    field_mapper = {}
+    if not render_args:
+        return field_mapper
+
+    for mapping in render_args:
+        if "=" not in mapping:
+            console.print(f"[yellow]Warning: Invalid mapping format '{mapping}', expected 'renderer=field1,field2'[/yellow]")
+            continue
+
+        renderer_name, fields_str = mapping.split("=", 1)
+        renderer = get_renderer(renderer_name.strip())
+
+        if renderer is None:
+            console.print(f"[yellow]Warning: Unknown renderer '{renderer_name}'[/yellow]")
+
+            # 尝试给出建议
+            all_names = get_all_renderer_names()
+            suggestions = [name for name in all_names if renderer_name.lower() in name.lower()]
+            if suggestions:
+                console.print(f"[dim]Did you mean: {', '.join(suggestions[:3])}?[/dim]")
+            console.print(f"[dim]Use --list-renderers to see all available options[/dim]")
+            continue
+
+        for field in fields_str.split(","):
+            field = field.strip()
+            if field:
+                field_mapper[field] = renderer
+                console.print(f"[green]✓[/green] Mapped '{field}' → {renderer_name}")
+
+    return field_mapper
+
+
+def print_available_renderers():
+    """打印所有可用的渲染器"""
+    renderers = list_renderers()
+
+    if not renderers:
+        console.print("[yellow]No renderers available[/yellow]")
+        return
+
+    table = Table(title="Available Renderers", show_header=True, header_style="bold magenta")
+    table.add_column("Renderer", style="cyan", no_wrap=True)
+    table.add_column("Source", style="yellow", width=12)
+    table.add_column("Aliases", style="dim")
+    table.add_column("Description", style="green")
+
+    # 按来源分组排序
+    builtin_renderers = []
+    plugin_renderers = []
+
+    for name, info in renderers.items():
+        if info.source == "builtin":
+            builtin_renderers.append((name, info))
+        else:
+            plugin_renderers.append((name, info))
+
+    # 先显示内置，再显示插件
+    for name, info in sorted(builtin_renderers) + sorted(plugin_renderers):
+        source = info.source
+        if info.plugin_name:
+            source = f"📦 {info.plugin_name}"
+
+        aliases = ", ".join(info.aliases) if info.aliases else "-"
+        desc = info.description or "-"
+
+        table.add_row(name, source, aliases, desc)
+
+    console.print(table)
+    console.print("\n[bold]Usage:[/bold] seejx data.jsonl -r [cyan]<renderer>[/cyan]=[green]<field1>[/green],[green]<field2>[/green]...")
+    console.print("[bold]Example:[/bold] seejx data.jsonl -r messages=chat,conversation")

seejx/navigator.py

@@ -0,0 +1,419 @@
+"""Example navigator for browsing JSONL data.
+
+内建全屏滚动视图:整条记录常驻内存,只显示一个窗口。
+- 两指滑动 / 鼠标滚轮 / ↑↓ / j k :上下滚动(永远能到最顶最底)
+- PgUp/PgDn / 空格 / b        :整页滚动
+- g / G                        :跳到开头 / 结尾
+- → / ←(或 n / p / 回车)     :下一条 / 上一条记录
+- t                           :切换 rich / raw 渲染
+- q(或 Ctrl-C)               :退出
+"""
+
+import io
+import os
+import sys
+import shutil
+import termios
+import tty
+import select
+from contextlib import redirect_stdout
+from pathlib import Path
+
+import readchar  # noqa: F401 (保留以兼容其它模块)
+from rich.console import Console
+from rich.panel import Panel
+from rich.text import Text
+
+from .tools import get_terminal_width, load_jsonl_iter
+from .renderers.base import get_renderer
+from .renderers.base import console as _base_console
+from .renderers import console
+
+try:
+    from wcwidth import wcwidth as _wcwidth
+
+    def _cw(c):
+        w = _wcwidth(c)
+        return 1 if w < 0 else w
+except Exception:  # pragma: no cover
+
+    def _cw(c):
+        return 2 if ord(c) >= 0x1100 else 1
+
+
+console = Console()
+
+ESC = "\x1b"
+
+
+def control_str(s, wrap=False, raw=False):
+    """打印控制信息(保留给非交互路径使用)"""
+    if raw:
+        console.print(s)
+        return
+    content = Text(s, style="bold red", overflow="fold")
+    if wrap:
+        content = Panel(content, expand=False, title="Control")
+    console.print(content)
+
+
+def _wrap_ansi(line, width):
+    """按可见宽度硬换行,保留 ANSI 颜色(跨行续色)。"""
+    if width <= 0:
+        return [line]
+    line = line.rstrip("\r")
+    rows = []
+    cur = ""
+    vis = 0
+    active = []  # 当前生效的 SGR 序列,换行时续上
+    i, n = 0, len(line)
+
+    def flush(newline_active):
+        nonlocal cur, vis
+        rows.append(cur + (ESC + "[0m" if active else ""))
+        cur = "".join(active) if newline_active else ""
+        vis = 0
+
+    while i < n:
+        c = line[i]
+        if c == ESC and i + 1 < n and line[i + 1] == "[":
+            j = i + 2
+            while j < n and not ("@" <= line[j] <= "~"):
+                j += 1
+            seq = line[i : j + 1]
+            cur += seq
+            if seq.endswith("m"):
+                params = seq[2:-1]
+                if params in ("", "0"):
+                    active = []
+                else:
+                    active.append(seq)
+            i = j + 1
+            continue
+        if c == "\t":
+            spaces = 8 - (vis % 8)
+            for _ in range(spaces):
+                if vis >= width:
+                    flush(True)
+                cur += " "
+                vis += 1
+            i += 1
+            continue
+        cwid = _cw(c)
+        if vis + cwid > width:
+            flush(True)
+        cur += c
+        vis += cwid
+        i += 1
+    rows.append(cur + (ESC + "[0m" if active else ""))
+    return rows
+
+
+class ExampleNavigator:
+    """JSONL 示例浏览器(全屏滚动版)"""
+
+    def __init__(
+        self,
+        file_path,
+        start_idx=0,
+        no_rich=False,
+        condition_fn=None,
+        condition_display=None,
+        show_tool_call_details=False,
+        custom_mapper=None,
+    ):
+        self.file_path = file_path
+        self.start_idx = start_idx
+        self.no_rich = no_rich
+        self.condition_fn = condition_fn
+        self.condition_display = condition_display or "None"
+        self.custom_mapper = custom_mapper or {}
+
+        self._render_configs = {
+            "show_tool_call_details": show_tool_call_details,
+        }
+
+        self.current_idx = -1
+        self.iterator = load_jsonl_iter(file_path, skip=start_idx)
+        self.example_history = []
+
+        self.top = 0
+        self.status = ""
+        self._cache_key = None
+        self._wrapped = []
+
+        if not self._advance("next"):
+            print("No examples matched.")
+            return
+        self.run()
+
+    # ---------- 渲染 ----------
+
+    def get_renderer_for_field(self, field_name):
+        if field_name in self.custom_mapper:
+            return self.custom_mapper[field_name]
+        renderer = get_renderer(field_name)
+        if renderer is not None:
+            return renderer
+        return get_renderer("eye")
+
+    def _render_current_lines(self, cols):
+        """把当前记录渲染成带颜色的逻辑行列表。"""
+        file_idx, ex = self.example_history[self.current_idx]
+        consoles = [console, _base_console]
+        saved = [(c._force_terminal, c._width) for c in consoles]
+        for c in consoles:
+            c._force_terminal = True
+            c._width = cols
+        buf = io.StringIO()
+        try:
+            with redirect_stdout(buf):
+                console.rule(f"[bold cyan]▼ IDX={file_idx}[/bold cyan]", style="cyan")
+                for k, v in ex.items():
+                    renderer = self.get_renderer_for_field(k)
+                    console.print(
+                        f"[[red][bold]{k}[/bold][/red] [dim]@{renderer.__name__}[/dim]]"
+                    )
+                    renderer(v, no_rich=self.no_rich, **self._render_configs)
+                    print("-" * cols)
+        finally:
+            for c, (ft, w) in zip(consoles, saved):
+                c._force_terminal = ft
+                c._width = w
+        return buf.getvalue().split("\n")
+
+    def _get_wrapped(self, cols):
+        key = (cols, self.current_idx, self.no_rich)
+        if key != self._cache_key:
+            logical = self._render_current_lines(cols)
+            wrapped = []
+            for ln in logical:
+                wrapped.extend(_wrap_ansi(ln, cols))
+            self._wrapped = wrapped
+            self._cache_key = key
+        return self._wrapped
+
+    def _draw(self, wrapped, cols, rows, view_h, max_top):
+        out = [ESC + "[H"]
+        for i in range(view_h):
+            idx = self.top + i
+            row = wrapped[idx] if idx < len(wrapped) else ""
+            out.append(f"{ESC}[{i + 1};1H{ESC}[2K" + row)
+        total = len(wrapped)
+        bot = min(total, self.top + view_h)
+        pct = 100 if max_top == 0 else int(self.top / max_top * 100)
+        file_idx, _ = self.example_history[self.current_idx]
+        mode = "raw" if self.no_rich else "rich"
+
+        # 柔和状态条:深灰底 + 分色前景(不再用刺眼的反显白底黑字)
+        BG = f"{ESC}[48;5;236m"
+        segs = []
+        vis = 0
+
+        def add(text, fg):
+            """按剩余宽度截断后着色追加,保证整条不超过一行。"""
+            nonlocal vis
+            room = cols - vis
+            if room <= 0:
+                return
+            out_chars = []
+            for ch in text:
+                w = _cw(ch)
+                if w > room:
+                    break
+                out_chars.append(ch)
+                room -= w
+                vis += w
+            if out_chars:
+                segs.append(f"{ESC}[38;5;{fg}m" + "".join(out_chars))
+
+        add(f" IDX={file_idx} ", 81)                 # 青色
+        add(f" {self.top + 1}-{bot}/{total} {pct:3d}% ", 252)  # 浅灰
+        add(f" [{mode}] ", 179)                       # 暖黄
+        add(" ↕滚动  ←→上/下条  g/G首尾  t切换  q退出 ", 244)  # 暗灰提示
+        if self.status:
+            add(f" {self.status} ", 210)              # 浅红提醒
+        if vis < cols:
+            segs.append(" " * (cols - vis))           # 用底色补齐整行
+        bar = BG + "".join(segs) + ESC + "[0m"
+        out.append(f"{ESC}[{rows};1H{ESC}[2K" + bar)
+
+        sys.stdout.write("".join(out))
+        sys.stdout.flush()
+
+    # ---------- 记录导航 ----------
+
+    def _advance(self, direction):
+        if direction == "prev":
+            if self.current_idx > 0:
+                self.current_idx -= 1
+                self.status = ""
+                return True
+            self.status = "已是第一条"
+            return False
+        # next
+        if self.current_idx < len(self.example_history) - 1:
+            self.current_idx += 1
+            self.status = ""
+            return True
+        try:
+            with open(os.devnull, "w") as dn, redirect_stdout(dn):
+                while True:
+                    new_example = next(self.iterator)
+                    if self.condition_fn is None or self.condition_fn(new_example):
+                        break
+            self.current_idx += 1
+            self.example_history.append((self.current_idx + self.start_idx, new_example))
+            self.status = ""
+            return True
+        except StopIteration:
+            self.status = "已到最后一条"
+            return False
+
+    # ---------- 输入 ----------
+
+    def _read_event(self):
+        fd = self.fd
+
+        def more(timeout=0.03):
+            r, _, _ = select.select([fd], [], [], timeout)
+            return os.read(fd, 1) if r else b""
+
+        ch = os.read(fd, 1)
+        if not ch or ch == b"\x03":
+            return "quit"
+        if ch in (b"q", b"Q", b"x", b"X"):
+            return "quit"
+        if ch in (b"t", b"T"):
+            return "toggle"
+        if ch == b" ":
+            return "pgdn"
+        if ch in (b"b", b"B"):
+            return "pgup"
+        if ch == b"g":
+            return "home"
+        if ch == b"G":
+            return "end"
+        if ch in (b"j",):
+            return "down"
+        if ch in (b"k",):
+            return "up"
+        if ch in (b"n", b"N", b"\r", b"\n"):
+            return "nextrec"
+        if ch in (b"p", b"P"):
+            return "prevrec"
+        if ch != b"\x1b":
+            return "none"
+
+        b1 = more()
+        if b1 == b"":
+            return "quit"  # 单独 ESC
+        if b1 not in (b"[", b"O"):
+            return "none"
+        nb = more()
+        if nb == b"<":  # SGR 鼠标/滚轮
+            data = b""
+            while True:
+                c = more()
+                if not c or c in (b"M", b"m"):
+                    break
+                data += c
+            try:
+                cb = int(data.split(b";")[0])
+            except (ValueError, IndexError):
+                return "none"
+            if cb == 64:
+                return "wheelup"
+            if cb == 65:
+                return "wheeldown"
+            return "none"
+        seq = nb
+        while seq[-1:].isdigit() or seq[-1:] == b";":
+            c = more()
+            if not c:
+                break
+            seq += c
+        final = seq[-1:]
+        if final == b"A":
+            return "up"
+        if final == b"B":
+            return "down"
+        if final == b"C":
+            return "nextrec"
+        if final == b"D":
+            return "prevrec"
+        if final == b"H":
+            return "home"
+        if final == b"F":
+            return "end"
+        if final == b"~":
+            n = seq[:-1]
+            if n == b"5":
+                return "pgup"
+            if n == b"6":
+                return "pgdn"
+            if n in (b"1", b"7"):
+                return "home"
+            if n in (b"4", b"8"):
+                return "end"
+        return "none"
+
+    # ---------- 主循环 ----------
+
+    def run(self):
+        self.fd = sys.stdin.fileno()
+        try:
+            old = termios.tcgetattr(self.fd)
+        except termios.error:
+            # 非 tty(如管道):退回一次性打印
+            cols = get_terminal_width()
+            for ln in self._get_wrapped(cols):
+                print(ln)
+            return
+        try:
+            tty.setcbreak(self.fd)
+            # 备用屏 + 隐藏光标 + 开启鼠标滚轮上报(SGR)
+            sys.stdout.write(ESC + "[?1049h" + ESC + "[?25l" + ESC + "[?1000h" + ESC + "[?1006h")
+            sys.stdout.flush()
+            while True:
+                cols, rows = shutil.get_terminal_size((80, 24))
+                wrapped = self._get_wrapped(cols)
+                view_h = max(1, rows - 1)
+                max_top = max(0, len(wrapped) - view_h)
+                self.top = max(0, min(self.top, max_top))
+                self._draw(wrapped, cols, rows, view_h, max_top)
+
+                ev = self._read_event()
+                if ev == "quit":
+                    break
+                elif ev == "toggle":
+                    self.no_rich = not self.no_rich
+                    self.top = 0
+                elif ev == "up":
+                    self.top -= 1
+                elif ev == "down":
+                    self.top += 1
+                elif ev == "wheelup":
+                    self.top -= 3
+                elif ev == "wheeldown":
+                    self.top += 3
+                elif ev == "pgup":
+                    self.top -= max(1, view_h - 1)
+                elif ev == "pgdn":
+                    self.top += max(1, view_h - 1)
+                elif ev == "home":
+                    self.top = 0
+                elif ev == "end":
+                    self.top = max_top
+                elif ev == "nextrec":
+                    if self._advance("next"):
+                        self.top = 0
+                elif ev == "prevrec":
+                    if self._advance("prev"):
+                        self.top = 0
+        finally:
+            sys.stdout.write(
+                ESC + "[?1000l" + ESC + "[?1006l" + ESC + "[?25h" + ESC + "[?1049l"
+            )
+            sys.stdout.flush()
+            termios.tcsetattr(self.fd, termios.TCSADRAIN, old)