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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lql-cli
-Version: 0.7.0
+Version: 0.8.0
 Summary: lql — CLI for the Liquid DataViewer platform
 Project-URL: Homepage, https://github.com/Liquid4All/lql
 Author: Liquid AI

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

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

{lql_cli-0.7.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.7.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>]

{lql_cli-0.7.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.7.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")