lql-cli 0.5.0__tar.gz → 0.7.0__tar.gz

{lql_cli-0.5.0 → lql_cli-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lql-cli
-Version: 0.5.0
+Version: 0.7.0
 Summary: lql — CLI for the Liquid DataViewer platform
 Project-URL: Homepage, https://github.com/Liquid4All/lql
 Author: Liquid AI
@@ -166,11 +166,23 @@ lql preview <file.jsonl|file.json>     Local file: each line/object is a row
 lql preview <dataset-id>               Platform dataset (fetched & paged lazily)
 lql preview <org/name> --hf            HuggingFace repo: sync to DataViewer, then view
 lql preview <src> -c <field>           Force field(s) as conversations (repeatable)
+lql preview <src> -f "col=value"       Filter rows (repeatable, AND); local & platform
 lql preview <src> -n <N>               Page size when paging a platform dataset
 lql preview <src> --offset N           Start at row index N
 lql preview <src> --title "<title>"    Title shown in the viewer header
 ```
 
+**Filtering (`--filter`/`-f`).** Show only matching rows — works on local files and
+platform datasets (platform filtering runs server-side). Repeatable; filters AND
+together; string match is case-insensitive. Operators: `=`, `!=`, `~` (contains),
+`>`, `<`, `>=`, `<=`.
+
+```
+lql preview <dataset-id> -f "domain=telecom"
+lql preview data.jsonl -f "reward>=0.8" -f "split=test"     # both must hold
+lql preview <dataset-id> -f "model~lfm"                      # contains
+```
+
 **HuggingFace datasets (`--hf`).** `lql preview org/name --hf` syncs the repo
 into a DataViewer workspace, then opens it. You pick the target workspace from
 an interactive list (or pass `--workspace <id>`; `--split` defaults to `train`).
@@ -189,10 +201,11 @@ and **`p` plays** the current sample's audio via the system player (`afplay`/
 `open`). Images render inline in pager mode (one sample at a time); scroll mode
 shows placeholders to avoid decoding the whole buffer.
 
-**Navigation** — two modes, toggle with `m` / `Tab`:
+**Navigation** — two modes, toggle with `m`:
 
 - **pager** (default): one sample at a time · `←/→` or `n`/`b` switch samples · `↑/↓`/`j`/`k`/PgUp-Dn scroll
 - **scroll**: all samples in one buffer · `n`/`b` jump between samples · arrows scroll
+- **copy**: `Tab`/`Shift+Tab` move a highlight between blocks · `c` copies the focused message/field · `Y` copies the whole sample as JSON (via OSC 52 — reaches your **local** clipboard over SSH where the terminal supports it, e.g. Ghostty/iTerm2; not macOS Terminal)
 - `p` play audio · `q` quits
 
 ```

{lql_cli-0.5.0 → lql_cli-0.7.0}/README.md

@@ -150,11 +150,23 @@ lql preview <file.jsonl|file.json>     Local file: each line/object is a row
 lql preview <dataset-id>               Platform dataset (fetched & paged lazily)
 lql preview <org/name> --hf            HuggingFace repo: sync to DataViewer, then view
 lql preview <src> -c <field>           Force field(s) as conversations (repeatable)
+lql preview <src> -f "col=value"       Filter rows (repeatable, AND); local & platform
 lql preview <src> -n <N>               Page size when paging a platform dataset
 lql preview <src> --offset N           Start at row index N
 lql preview <src> --title "<title>"    Title shown in the viewer header
 ```
 
+**Filtering (`--filter`/`-f`).** Show only matching rows — works on local files and
+platform datasets (platform filtering runs server-side). Repeatable; filters AND
+together; string match is case-insensitive. Operators: `=`, `!=`, `~` (contains),
+`>`, `<`, `>=`, `<=`.
+
+```
+lql preview <dataset-id> -f "domain=telecom"
+lql preview data.jsonl -f "reward>=0.8" -f "split=test"     # both must hold
+lql preview <dataset-id> -f "model~lfm"                      # contains
+```
+
 **HuggingFace datasets (`--hf`).** `lql preview org/name --hf` syncs the repo
 into a DataViewer workspace, then opens it. You pick the target workspace from
 an interactive list (or pass `--workspace <id>`; `--split` defaults to `train`).
@@ -173,10 +185,11 @@ and **`p` plays** the current sample's audio via the system player (`afplay`/
 `open`). Images render inline in pager mode (one sample at a time); scroll mode
 shows placeholders to avoid decoding the whole buffer.
 
-**Navigation** — two modes, toggle with `m` / `Tab`:
+**Navigation** — two modes, toggle with `m`:
 
 - **pager** (default): one sample at a time · `←/→` or `n`/`b` switch samples · `↑/↓`/`j`/`k`/PgUp-Dn scroll
 - **scroll**: all samples in one buffer · `n`/`b` jump between samples · arrows scroll
+- **copy**: `Tab`/`Shift+Tab` move a highlight between blocks · `c` copies the focused message/field · `Y` copies the whole sample as JSON (via OSC 52 — reaches your **local** clipboard over SSH where the terminal supports it, e.g. Ghostty/iTerm2; not macOS Terminal)
 - `p` play audio · `q` quits
 
 ```

{lql_cli-0.5.0 → lql_cli-0.7.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "lql-cli"
-version = "0.5.0"
+version = "0.7.0"
 description = "lql — CLI for the Liquid DataViewer platform"
 readme = "README.md"
 requires-python = ">=3.12"

lql_cli-0.7.0/src/lql/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.7.0"

{lql_cli-0.5.0 → lql_cli-0.7.0}/src/lql/commands/instructions.py

@@ -100,10 +100,19 @@ DataViewer workspace (you pick one interactively, or pass --workspace <id>;
 --split defaults to train) and reused on later previews (dedup by repo+split).
 
 Options: -c/--column (field(s) to treat as conversations; default auto-detect,
-repeatable), -n/--limit (page size when paging a platform dataset), --offset
-(start row index), --title, --hf, --split, --workspace, --profile, --api-url.
+repeatable), -f/--filter (filter rows; see below), -n/--limit (page size when
+paging a platform dataset), --offset (start row index), --title, --hf, --split,
+--workspace, --profile, --api-url.
 
-Navigation: two modes toggled with m/Tab — pager (one sample at a time; ←/→ or
+Filtering: -f/--filter "col<op>value" shows only matching rows — works on local
+files and platform datasets (server-side for platform). Repeatable; filters AND
+together; string compare is case-insensitive. Operators: = (eq), != (ne),
+~ (contains), >, <, >=, <=.
+
+  lql preview <dataset-id> -f "domain=telecom" -f "reward>=0.8"
+  lql preview data.jsonl -f "model~lfm"
+
+Navigation: two modes toggled with m — pager (one sample at a time; ←/→ or
 n/b switch samples, ↑/↓/j/k scroll) and scroll (all samples; n/b jump between
 them). q quits. Works over plain SSH with no browser or port-forward.
 
@@ -112,6 +121,11 @@ Sixel; placeholder otherwise) for both multimodal image segments and image-mode
 columns; audio shows a ♪ line and `p` plays the current sample's clip via the
 system player (afplay/open).
 
+Copy: Tab/Shift+Tab move a highlight between blocks, `c` copies the focused
+message/field, `Y` copies the whole sample as JSON — via OSC 52, reaching the
+local clipboard over SSH where the terminal supports it (e.g. Ghostty/iTerm2;
+not macOS Terminal).
+
 ## Evals
 
 Eval datasets (evaluation-run output: each row a sample with a model 'response'

{lql_cli-0.5.0 → lql_cli-0.7.0}/src/lql/commands/preview.py

@@ -759,6 +759,67 @@ def _choose_workspace(client: ApiClient, tui_mod) -> Optional[str]:
     return choice
 
 
+# --------------------------------------------------------------------------
+# Row filtering (--filter "col<op>value")
+# --------------------------------------------------------------------------
+
+# Maps each CLI symbol to the platform filter API's operator name (the same
+# names work server-side and locally). _parse_filters picks the earliest operator
+# (longest on a tie), so list order doesn't affect correctness.
+_FILTER_OPS = [(">=", "gte"), ("<=", "lte"), ("!=", "ne"), ("~", "contains"), ("=", "eq"), (">", "gt"), ("<", "lt")]
+_NUMERIC_OPS = {"gt": lambda c, v: c > v, "lt": lambda c, v: c < v, "gte": lambda c, v: c >= v, "lte": lambda c, v: c <= v}
+
+
+def _parse_filters(specs: Optional[List[str]]) -> List[tuple]:
+    """Parse ['col=value', 'reward>=0.5', 'name~kod'] → [(col, op, value), ...].
+
+    Splits on the EARLIEST operator (longest on a tie, so 'reward>=5' is gte not
+    gt), keeping operator chars in the value intact (e.g. 'q=a>b' → col 'q', value
+    'a>b'). Rejects an empty column or value."""
+    out: List[tuple] = []
+    for spec in specs or []:
+        chosen = None  # (index, symbol, op_name)
+        for sym, op in _FILTER_OPS:
+            i = spec.find(sym)
+            if i > 0 and (chosen is None or i < chosen[0] or (i == chosen[0] and len(sym) > len(chosen[1]))):
+                chosen = (i, sym, op)
+        if chosen is None:
+            print_error(
+                f"Invalid --filter '{spec}'. Use col=value, col!=value, col~text, or col>/</>=/<= N.",
+                "bad_filter",
+            )
+            raise typer.Exit(1)
+        i, sym, op = chosen
+        col, val = spec[:i].strip(), spec[i + len(sym):].strip()
+        if not col or not val:
+            print_error(f"Invalid --filter '{spec}': both a column and a value are required.", "bad_filter")
+            raise typer.Exit(1)
+        out.append((col, op, val))
+    return out
+
+
+def _cell_matches(cell: object, op: str, val: str) -> bool:
+    if op == "contains":
+        return cell is not None and val.lower() in str(cell).lower()
+    if op in ("eq", "ne"):
+        equal = cell is not None and str(cell).strip().lower() == val.strip().lower()
+        return equal if op == "eq" else not equal
+    try:
+        return _NUMERIC_OPS[op](float(cell), float(val))  # gt/lt/gte/lte
+    except (TypeError, ValueError):
+        return False
+
+
+def _row_matches(row: object, filters: List[tuple]) -> bool:
+    """Client-side predicate (local files). A non-dict row can't match a column
+    filter. All filters AND together."""
+    if not filters:
+        return True
+    if not isinstance(row, dict):
+        return False
+    return all(_cell_matches(row.get(col), op, val) for col, op, val in filters)
+
+
 # --------------------------------------------------------------------------
 # Command
 # --------------------------------------------------------------------------
@@ -772,6 +833,13 @@ def preview(
     ] = None,
     limit: Annotated[int, typer.Option("--limit", "-n", help="Page size when paging a platform dataset")] = 25,
     offset: Annotated[int, typer.Option("--offset", help="Start at this row index")] = 0,
+    filter_: Annotated[
+        Optional[List[str]],
+        typer.Option(
+            "--filter", "-f",
+            help="Filter rows: 'col=value', 'col!=value', 'col~text' (contains), or 'col>/</>=/<= N'. Repeatable (AND).",
+        ),
+    ] = None,
     title: Annotated[Optional[str], typer.Option("--title", help="Title shown in the viewer header")] = None,
     hf: Annotated[
         bool, typer.Option("--hf", help="Treat SOURCE as a HuggingFace repo (org/name); sync it to DataViewer, then view")
@@ -801,13 +869,20 @@ def preview(
         print_error("The terminal viewer requires 'textual'. Install it: pip install textual", "missing_textual")
         raise typer.Exit(1)
 
+    filters = _parse_filters(filter_)
     local_path = Path(source)
     is_local = (not hf) and local_path.exists() and local_path.is_file()
 
-    # Local file → load whole, view immediately.
+    # Local file → load whole (filter client-side), view immediately.
     if is_local:
+        rows = _load_local(local_path)
+        if filters:
+            rows = [r for r in rows if _row_matches(r, filters)]
+            if not rows:
+                print_error("No rows match the filter(s).", "no_match")
+                raise typer.Exit(3)
         tui_mod.run(
-            tui_mod.RowSource(initial=_load_local(local_path)),
+            tui_mod.RowSource(initial=rows),
             title or local_path.name,
             forced_cols=column or None,
             start_idx=max(0, offset),
@@ -834,11 +909,17 @@ def preview(
         view_title = title or f"dataset {source}"
 
     page_size = limit if limit and limit > 0 else 25
+    api_filters = [{"column": col, "operator": op, "value": val} for col, op, val in filters]
 
     def _fetch_page(off: int, lim: int) -> List[object]:
-        data = client.get(
-            f"/v1/datasets/{q(dataset_id)}/rows", params={"limit": str(lim), "offset": str(offset + off)}
-        ).json()
+        params = {"limit": str(lim), "offset": str(offset + off)}
+        if api_filters:
+            # Server-side filtering via the same endpoint `eval samples` uses.
+            data = client.post(
+                f"/v1/datasets/{q(dataset_id)}/rows/filter", json={"filters": api_filters}, params=params
+            ).json()
+        else:
+            data = client.get(f"/v1/datasets/{q(dataset_id)}/rows", params=params).json()
         return _normalize_loaded(data)
 
     # Fetch the first page up front (with feedback) so the viewer opens already
@@ -857,8 +938,13 @@ def preview(
             if first:
                 break
     if not first:
-        msg = f"Dataset returned no rows for split '{split}'." if hf else "Dataset returned no rows."
-        print_error(msg, "empty_dataset")
+        if filters:
+            msg, code = "No rows match the filter(s).", "no_match"
+        elif hf:
+            msg, code = f"Dataset returned no rows for split '{split}'.", "empty_dataset"
+        else:
+            msg, code = "Dataset returned no rows.", "empty_dataset"
+        print_error(msg, code)
         raise typer.Exit(3)
     row_source = tui_mod.RowSource(initial=first, fetch_page=_fetch_page, page_size=page_size)
     tui_mod.run(

{lql_cli-0.5.0 → lql_cli-0.7.0}/src/lql/commands/tui.py

@@ -375,22 +375,44 @@ def _field(key: str, value: object, inline_images: bool = False) -> Panel:
     return Panel(body, title=f"[dim]{escape(str(key))}[/]", title_align="left", border_style="grey30", box=box.MINIMAL)
 
 
-def render_sample(
+def _field_copy_text(value: object) -> str:
+    return value if isinstance(value, str) else json.dumps(value, ensure_ascii=False, indent=2, default=str)
+
+
+def sample_blocks(
     row: object, forced_cols: Optional[List[str]] = None, width: Optional[int] = None, inline_images: bool = False
-) -> RenderableType:
-    blocks: List[RenderableType] = []
+) -> List[tuple]:
+    """Return [(renderable, copy_text), ...] — one entry per message/field, with
+    the raw text to copy. copy_text is None for non-copyable bits (e.g. a column
+    label). Single source for both render_sample (Group) and the focusable
+    per-block widgets in the viewer."""
+    blocks: List[tuple] = []
+
+    def _conv(raw: list, col: Optional[str]) -> None:
+        if col:
+            blocks.append((Text(col, style="dim"), None))
+        for m in _parse_messages(raw):
+            blocks.append((_message(m, width, inline_images), m.get("content") or ""))
+
     if _is_conversation(row):
-        blocks.extend(_conversation(row, width=width, inline_images=inline_images))
+        _conv(row, None)
     elif isinstance(row, dict):
         for key, val in row.items():
             forced = forced_cols is not None and key in forced_cols
             auto = forced_cols is None and _is_conversation(val)
             if (forced or auto) and _is_conversation(val):
-                blocks.extend(_conversation(val, col=key, width=width, inline_images=inline_images))
+                _conv(val, key)
             else:
-                blocks.append(_field(key, val, inline_images))
+                blocks.append((_field(key, val, inline_images), _field_copy_text(val)))
     else:
-        blocks.append(_field("value", row, inline_images))
+        blocks.append((_field("value", row, inline_images), _field_copy_text(row)))
+    return blocks
+
+
+def render_sample(
+    row: object, forced_cols: Optional[List[str]] = None, width: Optional[int] = None, inline_images: bool = False
+) -> RenderableType:
+    blocks = [r for r, _ in sample_blocks(row, forced_cols, width, inline_images)]
     return Group(*blocks) if blocks else Text("(empty sample)", style="dim")
 
 
@@ -533,16 +555,31 @@ def run(
     except Exception:
         pass
 
+    class CopyBlock(Static):
+        """A focusable block (message/field/sample) that remembers the raw text
+        to copy. Tab/Shift+Tab move focus between blocks; `c` copies the focused
+        one to the clipboard (via OSC 52, so it works over SSH)."""
+
+        can_focus = True
+
+        def __init__(self, renderable, copy_text: str, **kwargs) -> None:
+            super().__init__(renderable, **kwargs)
+            self.copy_text = copy_text
+
     class Viewer(App):
         CSS = """
         Screen { background: $surface; }
         #body { padding: 1 2; }
         #body > Static { margin-bottom: 1; }
+        CopyBlock { margin-bottom: 1; }
+        CopyBlock:focus { background: $boost; }
         """
         BINDINGS = [
             Binding("right,n,l", "next", "Next"),
             Binding("left,b,h", "prev", "Prev"),
-            Binding("m,tab", "toggle_mode", "Mode"),
+            Binding("m", "toggle_mode", "Mode"),
+            Binding("c", "copy", "Copy block"),
+            Binding("Y", "copy_sample", "Copy JSON"),
             Binding("down,j", "scroll_down", "Down", show=False),
             Binding("up,k", "scroll_up", "Up", show=False),
             Binding("pagedown,space", "page_down", "Page", show=False),
@@ -591,19 +628,36 @@ def run(
         def _update_title(self) -> None:
             self.sub_title = self._counter()
 
-        async def _rebuild(self) -> None:
+        async def _rebuild(self, preserve_focus: bool = False) -> None:
             body = self.query_one("#body", VerticalScroll)
+            # Remember which copy-block was focused so a width-driven rebuild
+            # (resize) doesn't silently change what `c` copies.
+            keep_idx = None
+            if preserve_focus and self.mode == "pager" and isinstance(self.focused, CopyBlock):
+                cbs = list(self.query("#body CopyBlock"))
+                if self.focused in cbs:
+                    keep_idx = cbs.index(self.focused)
             await body.remove_children()
             w = self._content_width()
             self._last_width = w
             if self.mode == "pager":
                 row = self.source.get(self.idx)
                 # Inline images only in pager mode (one sample) so we never decode/
-                # fetch images for the whole buffer at once.
-                content = render_sample(row, forced_cols, width=w, inline_images=True) if row is not None else Text("(no data)")
-                await body.mount(Static(content))
+                # fetch images for the whole buffer at once. Each message/field is a
+                # focusable CopyBlock (Tab to move, c to copy).
+                widgets = []
+                if row is None:
+                    widgets.append(Static(Text("(no data)")))
+                else:
+                    for rend, copy_text in sample_blocks(row, forced_cols, width=w, inline_images=True):
+                        widgets.append(Static(rend) if copy_text is None else CopyBlock(rend, copy_text))
+                await body.mount(*widgets)
                 body.scroll_home(animate=False)
                 self._mounted = 1
+                cbs = [wgt for wgt in widgets if isinstance(wgt, CopyBlock)]
+                target = cbs[keep_idx] if (keep_idx is not None and keep_idx < len(cbs)) else (cbs[0] if cbs else None)
+                if target is not None:
+                    target.focus()
             else:
                 n = self.source.count()
                 widgets = []
@@ -611,7 +665,9 @@ def run(
                     row = self.source.get(i)
                     label = f"sample {i + 1 + self.index_base}/{n + self.index_base}{'+' if self.source.has_more else ''}"
                     header = Rule(label, style="grey42")
-                    widgets.append(Static(Group(header, render_sample(row, forced_cols, width=w)), id=f"s{i}"))
+                    # In scroll mode each whole sample is one focusable block (c copies the row JSON).
+                    body_r = Group(header, render_sample(row, forced_cols, width=w))
+                    widgets.append(CopyBlock(body_r, _field_copy_text(row), id=f"s{i}"))
                 if widgets:
                     await body.mount(*widgets)
                 self._mounted = n
@@ -619,16 +675,18 @@ def run(
             self._update_title()
 
         async def on_resize(self, event) -> None:
-            # Re-flow bubble widths when the terminal size changes.
+            # Re-flow bubble widths when the terminal size changes; keep the
+            # focused block so `c` still copies what the user selected.
             if self._loading:
                 return
             if self._content_width() != self._last_width:
-                await self._rebuild()
+                await self._rebuild(preserve_focus=True)
 
         def _scroll_to_current(self) -> None:
             try:
                 target = self.query_one(f"#s{self.idx}")
                 self.query_one("#body", VerticalScroll).scroll_to_widget(target, animate=False, top=True)
+                target.focus()  # so `c` copies the current sample in scroll mode
             except Exception:
                 pass
 
@@ -705,4 +763,18 @@ def run(
             err = _play_audio(clips[0])
             self._set_status(f"⚠ {err}" if err else "▶ playing audio…")
 
+        def action_copy(self) -> None:
+            focused = self.focused
+            if isinstance(focused, CopyBlock):
+                self.copy_to_clipboard(focused.copy_text)
+                n = len(focused.copy_text)
+                self._set_status(f"copied {n} char{'s' if n != 1 else ''} (OSC 52)")
+            else:
+                self._set_status("Tab to focus a block, then c to copy")
+
+        def action_copy_sample(self) -> None:
+            row = self.source.get(self.idx)
+            self.copy_to_clipboard(json.dumps(row, ensure_ascii=False, indent=2, default=str))
+            self._set_status("copied sample JSON ✓")
+
     Viewer().run()

{lql_cli-0.5.0 → lql_cli-0.7.0}/uv.lock

@@ -185,7 +185,7 @@ wheels = [
 
 [[package]]
 name = "lql-cli"
-version = "0.5.0"
+version = "0.7.0"
 source = { editable = "." }
 dependencies = [
     { name = "httpx" },

lql_cli-0.5.0/src/lql/__init__.py

@@ -1 +0,0 @@
-__version__ = "0.5.0"