lql-cli 0.6.0__tar.gz → 0.8.0__tar.gz

{lql_cli-0.6.0 → lql_cli-0.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lql-cli
-Version: 0.6.0
+Version: 0.8.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`).

{lql_cli-0.6.0 → lql_cli-0.8.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`).

{lql_cli-0.6.0 → lql_cli-0.8.0}/pyproject.toml

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

lql_cli-0.8.0/src/lql/__init__.py

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

{lql_cli-0.6.0 → lql_cli-0.8.0}/src/lql/commands/datasets.py

@@ -10,7 +10,7 @@ from .._group import AliasGroup
 
 from .._opts import ApiUrlOpt, JsonOpt, ProfileOpt
 from ..api import ApiClient
-from ..output import print_error, print_json, print_table
+from ..output import print_error, print_grouped_tables, print_json, print_table
 from ..util import q
 
 app = typer.Typer(help="Manage datasets", cls=AliasGroup, no_args_is_help=True)
@@ -21,6 +21,23 @@ def _truncate(v: object, n: int = 80) -> str:
     return s[: n - 3] + "..." if len(s) > n else s
 
 
+def _workspace_index(client: ApiClient) -> dict:
+    """Map workspace id -> {"name", "team_name"}. Returns {} if lookups fail."""
+    try:
+        teams = {t.get("id"): (t.get("name") or "") for t in client.get("/v1/teams").json()}
+    except Exception:
+        teams = {}
+    try:
+        out = {}
+        for w in client.get("/v1/workspaces").json():
+            name = w.get("display_name") or w.get("name") or ""
+            tname = teams.get(w.get("team_id")) or ("(unknown team)" if w.get("team_id") else "Personal")
+            out[w.get("id")] = {"name": name, "team_name": tname}
+        return out
+    except Exception:
+        return {}
+
+
 @app.command("list")
 def list_datasets(
     workspace: Annotated[Optional[str], typer.Option("--workspace", help="Filter by workspace ID")] = None,
@@ -28,6 +45,10 @@ def list_datasets(
         Optional[str],
         typer.Option("--search", "-s", help="Filter by case-insensitive substring of name / HF repo"),
     ] = None,
+    flat: Annotated[
+        bool,
+        typer.Option("--flat", "-f", help="Flat table instead of the default workspace-grouped view"),
+    ] = False,
     json_out: JsonOpt = False,
     profile: ProfileOpt = None,
     api_url: ApiUrlOpt = None,
@@ -47,13 +68,61 @@ def list_datasets(
             or s in (d.get("name") or "").lower()
             or s in (d.get("hf_repo_id") or "").lower()
         ]
+
+    ws_index = _workspace_index(client)
+
+    def _ws_info(d: dict) -> dict:
+        return ws_index.get(d.get("workspace_id")) or {}
+
+    # Enrich each dataset with resolved names (additive, keeps --json useful).
+    for d in items:
+        info = _ws_info(d)
+        d["workspace_name"] = info.get("name") or ""
+        d["team_name"] = info.get("team_name") or ""
+
+    if json_out:
+        print_json(items)
+        return
+
+    def _row(d: dict) -> list:
+        return [
+            d.get("id") or "",
+            d.get("display_name") or d.get("name") or "",
+            d.get("row_count") if d.get("row_count") is not None else "",
+        ]
+
+    def _ws_label(d: dict) -> str:
+        info = _ws_info(d)
+        wid = d.get("workspace_id") or ""
+        name = info.get("name") or "(unknown workspace)"
+        team = info.get("team_name") or ""
+        head = f"{name} · {team}" if team else name
+        return f"{head} ({wid})" if wid else head
+
+    if not flat:
+        groups: dict[str, list] = {}
+        labels: dict[str, str] = {}
+        for d in sorted(items, key=lambda d: (d.get("display_name") or d.get("name") or "").lower()):
+            info = _ws_info(d)
+            # Sort sections by team, then workspace name, so a team's datasets cluster.
+            key = (info.get("team_name") or "~", info.get("name") or "~", d.get("workspace_id") or "")
+            groups.setdefault(key, []).append(d)
+            labels[key] = _ws_label(d)
+        order = sorted(groups)
+        print_grouped_tables(
+            ["ID", "Name", "Rows"],
+            [(labels[k], [_row(d) for d in groups[k]]) for k in order],
+        )
+        return
+
     print_table(
-        ["ID", "Name", "Workspace", "Rows"],
+        ["ID", "Name", "Workspace", "Team", "Rows"],
         [
             [
                 d.get("id") or "",
                 d.get("display_name") or d.get("name") or "",
-                d.get("workspace_id") or "",
+                d.get("workspace_name") or d.get("workspace_id") or "",
+                d.get("team_name") or "",
                 d.get("row_count") if d.get("row_count") is not None else "",
             ]
             for d in items

{lql_cli-0.6.0 → lql_cli-0.8.0}/src/lql/commands/instructions.py

@@ -38,6 +38,13 @@ All commands accept --json for stable JSON output to stdout.
 Errors always go to stderr as: { "error": "message", "code": "slug" }
 Data always goes to stdout.
 
+AGENTS: always pass --json and parse that. It is the stable contract — a flat,
+unnested structure carrying full IDs plus resolved names (e.g. team_name,
+workspace_name, parent_name on list results). The default human output is
+Rich-rendered tables that may be grouped into sections and have truncated cells
+(IDs shown as `8b45ab54-…`); do NOT parse it. Table-only display flags like
+--flat / --group never affect --json output.
+
 Exit codes:
   0  success
   1  usage / validation error
@@ -52,7 +59,7 @@ Pagination: --limit N --offset N on list commands.
 
 A workspace is the top-level container for datasets, spec docs, and members.
 
-  lql workspaces list [--search <text>]            # --search filters by name / slug substring
+  lql workspaces list [--search <text>] [--flat]   # grouped by team by default; --flat for a single table; --search filters by name / slug substring
   lql workspaces create <name>
   lql workspaces show <id>
   lql workspaces update <id> --name <new-name>
@@ -63,7 +70,7 @@ A workspace is the top-level container for datasets, spec docs, and members.
 
 ## Datasets
 
-  lql datasets list [--workspace <id>] [--search <text>]   # --search filters by name / HF repo substring
+  lql datasets list [--workspace <id>] [--search <text>] [--flat]   # grouped by workspace (with team) by default; --flat for a single table; --search filters by name / HF repo substring
   lql datasets show <id>
   lql datasets create --workspace <id> --hf-repo <org/repo> [--name <display>] [--split <split>]
   lql datasets create --workspace <id> --hf-bucket <org/bucket> --key <path-or-glob> [--name <display>]
@@ -100,8 +107,17 @@ 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.
+
+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

{lql_cli-0.6.0 → lql_cli-0.8.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.6.0 → lql_cli-0.8.0}/src/lql/commands/workspaces.py

@@ -7,7 +7,7 @@ from .._group import AliasGroup
 
 from .._opts import ApiUrlOpt, JsonOpt, ProfileOpt
 from ..api import ApiClient
-from ..output import print_json, print_table
+from ..output import print_grouped_tables, print_json, print_table
 from ..util import q
 
 app = typer.Typer(help="Manage workspaces", cls=AliasGroup, no_args_is_help=True)
@@ -15,12 +15,28 @@ members_app = typer.Typer(help="Manage workspace members", cls=AliasGroup, no_ar
 app.add_typer(members_app, name="members")
 
 
+def _ws_name(w: dict) -> str:
+    return w.get("display_name") or w.get("name") or ""
+
+
+def _team_names(client: ApiClient) -> dict:
+    """Map team id -> team name. Returns {} if teams can't be fetched."""
+    try:
+        return {t.get("id"): (t.get("name") or "") for t in client.get("/v1/teams").json()}
+    except Exception:
+        return {}
+
+
 @app.command("list")
 def list_workspaces(
     search: Annotated[
         Optional[str],
         typer.Option("--search", "-s", help="Filter by case-insensitive substring of name / slug"),
     ] = None,
+    flat: Annotated[
+        bool,
+        typer.Option("--flat", "-f", help="Flat table instead of the default team-grouped view"),
+    ] = False,
     json_out: JsonOpt = False,
     profile: ProfileOpt = None,
     api_url: ApiUrlOpt = None,
@@ -37,9 +53,54 @@ def list_workspaces(
             or s in (w.get("name") or "").lower()
             or s in (w.get("slug") or "").lower()
         ]
+
+    team_names = _team_names(client)
+    name_by_id = {w.get("id"): _ws_name(w) for w in items}
+    # Enrich each workspace with resolved names (additive, keeps --json useful).
+    for w in items:
+        w["team_name"] = team_names.get(w.get("team_id")) or ""
+        w["parent_name"] = name_by_id.get(w.get("parent_id")) or ""
+
+    if json_out:
+        print_json(items)
+        return
+
+    def _team_label(w: dict) -> str:
+        name, tid = w.get("team_name"), w.get("team_id")
+        if name:
+            return f"{name} ({tid})"
+        if tid:
+            return f"(unknown team) ({tid})"
+        return "Personal"
+
+    if not flat:
+        groups: dict[str, list] = {}
+        for w in sorted(items, key=lambda w: _ws_name(w).lower()):
+            groups.setdefault(_team_label(w), []).append(w)
+        # Named teams first (alphabetical), then unknown teams, then Personal last.
+        def _rank(label: str) -> tuple:
+            if label == "Personal":
+                return (2, label)
+            if label.startswith("(unknown team)"):
+                return (1, label)
+            return (0, label.lower())
+
+        order = sorted(groups, key=_rank)
+        print_grouped_tables(
+            ["ID", "Name", "Parent"],
+            [
+                (label, [[w.get("id") or "", _ws_name(w), w.get("parent_name") or ""] for w in groups[label]])
+                for label in order
+            ],
+        )
+        return
+
     print_table(
-        ["ID", "Name"],
-        [[w.get("id") or "", w.get("display_name") or w.get("name") or ""] for w in items],
+        ["ID", "Name", "Parent", "Team"],
+        [
+            [w.get("id") or "", _ws_name(w), w.get("parent_name") or "", _team_label(w)]
+            for w in items
+        ],
         json_out,
         items,
     )

{lql_cli-0.6.0 → lql_cli-0.8.0}/src/lql/output.py

@@ -1,6 +1,6 @@
 import json
 import sys
-from typing import List, Sequence
+from typing import List, Sequence, Tuple
 
 from rich.console import Console
 from rich.table import Table
@@ -24,6 +24,26 @@ def print_table(headers: Sequence[str], rows: Sequence[Sequence[str]], is_json:
     _console.print(table)
 
 
+def print_grouped_tables(
+    headers: Sequence[str],
+    groups: Sequence[Tuple[str, Sequence[Sequence[str]]]],
+) -> None:
+    """Print one table per group, each preceded by a bold group header.
+
+    `groups` is a sequence of (label, rows) pairs. JSON callers should print
+    the underlying data directly rather than going through this helper.
+    """
+    for label, rows in groups:
+        _console.print(f"[bold]{label}[/bold] ({len(rows)})")
+        table = Table(show_header=True, header_style="bold")
+        for h in headers:
+            table.add_column(str(h))
+        for row in rows:
+            table.add_row(*[str(c) for c in row])
+        _console.print(table)
+        _console.print()
+
+
 def print_error(message: str, code: str) -> None:
     # Compact, machine-readable; always to stderr (matches the TS contract).
     sys.stderr.write(json.dumps({"error": message, "code": code}) + "\n")

{lql_cli-0.6.0 → lql_cli-0.8.0}/uv.lock

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

lql_cli-0.6.0/src/lql/__init__.py

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