slab-cli 0.14.0__tar.gz → 0.16.0__tar.gz

{slab_cli-0.14.0 → slab_cli-0.16.0}/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.3
 Name: slab-cli
-Version: 0.14.0
+Version: 0.16.0
 Summary: CLI for the slab trading-card API — catalog, collect, and track your cards from the terminal.
 Author: dev_jeb
-Requires-Dist: slab-schemas>=0.1.0
+Requires-Dist: slab-schemas>=0.31.0
 Requires-Dist: httpx>=0.27
 Requires-Dist: rich>=13.0
 Requires-Dist: inquirerpy>=0.3

{slab_cli-0.14.0 → slab_cli-0.16.0}/pyproject.toml

@@ -1,12 +1,13 @@
 [project]
 name = "slab-cli"
-version = "0.14.0"
+version = "0.16.0"
 description = "CLI for the slab trading-card API — catalog, collect, and track your cards from the terminal."
 readme = "README.md"
 authors = [{name = "dev_jeb"}]
 requires-python = ">=3.13"
 dependencies = [
-    "slab-schemas>=0.1.0",
+    # 0.31: CardSearchQuery.collapse_parallels — `card search` sends it on every query.
+    "slab-schemas>=0.31.0",
     "httpx>=0.27",
     "rich>=13.0",
     "InquirerPy>=0.3",

{slab_cli-0.14.0 → slab_cli-0.16.0}/src/slab_cli/browse.py

@@ -4,11 +4,17 @@
 keyboard-driven viewport: ↑/↓ (or j/k) move the highlight, PgUp/PgDn jump, `/` type-to-filters
 across every column, and q leaves — printing the plain table on the way out so the data
 survives in scrollback. Enter drills down: with a `detail` callback the highlighted row's
-detail view REPLACES the list as a scrollable page (Esc/q climbs back up to the list, same row
+detail view REPLACES the list as a scrollable page (Esc climbs back up to the list, same row
 highlighted); without one, Enter simply returns the row's item to the caller. Anywhere output
 isn't an interactive terminal (a pipe, CI, redirection) it degrades to the static table, so
 `slab ... | grep` keeps working unchanged.
 
+**A drill-down may be another list.** When `detail` returns a `Page` instead of printing, that
+page is pushed as its own list screen with its own columns and its own `detail` — so a search can
+show one row per card, its parallels one level down, and that printing's market view one level
+below THAT, without any screen knowing how deep it sits. Esc pops exactly one level; q leaves the
+whole stack at once (and prints the top-level table as the receipt).
+
 Reading keys is the one OS-specific part, and this module doesn't do it: `platforms.current()`
 hands back a backend whose `key_source()` yields a `read()` returning platform-neutral key NAMES
 ('up', 'enter', …). Everything below is written against those names, so it behaves identically on
@@ -21,6 +27,7 @@ the same spec drives the interactive view, the static fallback, and the exit rec
 from __future__ import annotations
 
 import sys
+from dataclasses import dataclass, field
 from typing import Any, Callable, Sequence
 
 from rich.console import Group
@@ -33,6 +40,22 @@ from .theme import console, heading, slab_table
 # One row: the domain object Enter should act on, plus its cell markup strings (one per column).
 Row = tuple[Any, Sequence[str]]
 
+
+@dataclass
+class Page:
+    """A list screen. Return one from a `detail` callback to drill from a list INTO another list
+    (instead of into a printed page) — same columns/rows/hint contract the root browse takes, so a
+    level is described the same way whether it's the first screen or the third."""
+
+    columns: list[tuple[str, dict]]
+    rows: list[Row]
+    title: str
+    note: str | None = None
+    hint: str = "open"
+    footer: str | None = None
+    detail: Callable[[Any], "Page | None"] | None = None
+    sel: int = field(default=0, repr=False)  # where this level's highlight sits, kept across pops
+
 # The highlight bar — a slate a step brighter than the card border, so the selected row reads as
 # lit without fighting the cells' own foreground colors (markup styles set color only, never bg).
 _SELECTED_BG = "on #223052"
@@ -149,9 +172,13 @@ def _run_list(
     note: str | None,
     hint: str,
     start: int,
-) -> tuple[Any | None, int]:
-    """The list screen. Returns (chosen item, its index in `rows`) on Enter, or (None, last
-    highlighted index) on quit — the index lets a drill-down return to the same row."""
+) -> tuple[Any | None, int, str]:
+    """The list screen. Returns (chosen item, its index in `rows`, action).
+
+    The action is "select" (Enter — item is set), "back" (Esc: up one level) or "quit" (q: leave
+    browsing entirely). The index is where the highlight ended up, so a drill-down returns to the
+    same row; Esc and q are different answers because with nested lists only one of them means
+    "I'm done", and collapsing them would strand a user three levels deep."""
     plains = [row_plain(cells) for _item, cells in rows]
     query, typing = "", False
     sel = min(max(start, 0), len(rows) - 1)
@@ -198,14 +225,14 @@ def _run_list(
                 if typing:
                     typing = False  # keep the filter, back to moving
                 elif view:
-                    return view[sel][0], row_index(view[sel])
+                    return view[sel][0], row_index(view[sel]), "select"
             elif key == "esc":
                 if typing or query:
                     typing, query = False, ""
                 else:
-                    return None, sel
+                    return None, (row_index(view[sel]) if view else 0), "back"
             elif key == "quit" or (not typing and key == "q"):
-                return None, (row_index(view[sel]) if view else 0)
+                return None, (row_index(view[sel]) if view else 0), "quit"
             elif typing:
                 if key == "backspace":
                     if query:
@@ -260,11 +287,9 @@ def _run_pager(read: KeyReader, lines: list[Text], *, back_hint: str) -> None:
                 return
 
 
-def _capture_lines(render: Callable[[], None]) -> list[Text]:
-    """Run a print-to-console renderer and capture its output as styled lines for the pager."""
-    with console.capture() as cap:
-        render()
-    lines = [Text.from_ansi(line) for line in cap.get().splitlines()]
+def _lines_from(captured: str) -> list[Text]:
+    """Captured console output as trimmed styled lines — what the pager scrolls."""
+    lines = [Text.from_ansi(line) for line in captured.splitlines()]
     while lines and not lines[-1].plain.strip():
         lines.pop()
     while lines and not lines[0].plain.strip():
@@ -272,6 +297,20 @@ def _capture_lines(render: Callable[[], None]) -> list[Text]:
     return lines or [Text.from_markup("[slab.dim]Nothing to show.[/]")]
 
 
+def _open(detail: Callable[[Any], "Page | None"], item: Any) -> tuple["Page | None", list[Text]]:
+    """Run a drill-down and report which kind it was: `(page, lines)`.
+
+    A detail callback either returns a Page (another list) or prints its view and returns None, and
+    it can only say which by running — so the console is captured either way and the lines are kept
+    only for the printing kind. An empty Page falls back to its captured lines too, so a drill-down
+    that found nothing shows a page saying so rather than a dead list screen."""
+    with console.capture() as cap:
+        page = detail(item)
+    if page is not None and page.rows:
+        return page, []
+    return None, _lines_from(cap.get())
+
+
 def browse(
     columns: list[tuple[str, dict]],
     rows: list[Row],
@@ -281,19 +320,23 @@ def browse(
     hint: str = "open",
     footer: str | None = None,
     start: int = 0,
-    detail: Callable[[Any], None] | None = None,
+    detail: Callable[[Any], "Page | None"] | None = None,
 ) -> Any | None:
     """Browse `rows` interactively. `columns` is the same `(header, kwargs)` spec `slab_table`
     takes; each row is `(item, cells)` with one markup string per column. `hint` names what
     Enter does in the footer (e.g. "market view"); `start` pre-selects a row.
 
-    With a `detail` callback, Enter drills down: `detail(item)` runs (it may fetch and must
-    print to the console), its output replaces the list as a scrollable page, and leaving the
-    page returns to the list on the same row — the loop lives here, and browse returns None
-    when the user finally quits. Without `detail`, Enter returns the chosen item directly.
+    With a `detail` callback, Enter drills down and `detail(item)` decides into WHAT:
 
-    Quitting from the list prints the plain table (with `footer`) as a scrollback receipt. On
-    a non-interactive stdout/stdin the static table is printed instead and None returned.
+    * it prints to the console and returns None — the output replaces the list as a scrollable
+      page (the leaf view: a market report, a break's card);
+    * it returns a `Page` — that page becomes another list screen, with its own `detail`.
+
+    Either way Esc climbs back one level, landing on the row it left from, and q leaves the whole
+    stack. Without a `detail`, Enter returns the chosen item to the caller instead.
+
+    Quitting prints the top-level table (with `footer`) as a scrollback receipt. On a
+    non-interactive stdout/stdin the static table is printed instead and None returned.
     """
     if not rows:
         return None
@@ -301,24 +344,36 @@ def browse(
         print_table(columns, rows, title=title, note=note, footer=footer)
         return None
 
+    root = Page(columns, rows, title, note, hint, footer, detail, sel=start)
     picked: Any | None = None
-    sel = start
     try:
         with current_platform().key_source() as read:
-            while True:
-                item, sel = _run_list(read, columns, rows, title=title, note=note,
-                                      hint=hint, start=sel)
-                if item is None:
+            stack = [root]
+            while stack:
+                page = stack[-1]
+                item, page.sel, action = _run_list(
+                    read, page.columns, page.rows,
+                    title=page.title, note=page.note, hint=page.hint, start=page.sel,
+                )
+                if action == "quit":
                     break
-                if detail is None:
+                if action == "back":
+                    stack.pop()
+                    continue
+                if page.detail is None:
                     picked = item
                     break
-                _run_pager(read, _capture_lines(lambda: detail(item)), back_hint="back to list")
+                drilled, lines = _open(page.detail, item)
+                if drilled is not None and drilled.rows:
+                    stack.append(drilled)
+                else:
+                    _run_pager(read, lines, back_hint="back to list")
     except KeyboardInterrupt:
         pass
 
     if picked is not None:
         return picked
-    # Quit: leave the classic table behind so the results live on in scrollback.
-    print_table(columns, rows, title=title, note=note, footer=footer)
+    # Quit: leave the classic table behind so the results live on in scrollback. It's the TOP
+    # level's table however deep the user was — that's the list they asked for.
+    print_table(root.columns, root.rows, title=root.title, note=root.note, footer=root.footer)
     return None

{slab_cli-0.14.0 → slab_cli-0.16.0}/src/slab_cli/commands/catalog.py

@@ -34,25 +34,42 @@ def cmd_search(args: list[str]) -> None:
       slab card search --brand "Upper Deck" --run-min 1 --run-max 99   # print-run range
       slab card search McDavid --auto --parallel --sort -year   # stack modifiers, newest first
       slab card search --subset "Young Guns" --rookie --limit 50
+      slab card search Coffey --printings                # every finish as its own row
 
     Every flag combines with AND; repeat an any-of flag (--team, --brand, --finish…) to widen it.
 
     Sort keys: year, card_number, numbered, subject, brand, set (prefix - for descending).
 
-    In a terminal the results are a scrollable list — Enter drills into the highlighted
-    card's market view, Esc climbs back. Piped output prints the plain table.
+    Results are one row per CARD, however many parallels it has — a player with a 17-finish
+    rainbow would otherwise bury his other cards under one of them. In a terminal that list is
+    scrollable and drills down: Enter opens the card's printings (base + every parallel, with
+    print run and odds), Enter again opens that printing's market view, Esc climbs back one level
+    and q leaves. `--printings` flattens it back to one row per printing (finish, run, and odds
+    on every row) — what you want when the finish IS the thing you're scanning for, and the form
+    to pipe when a script wants every parallel. Piped output prints the plain table of whichever
+    shape you asked for; the row shape doesn't change just because output is a terminal.
     """
     if not args:
         args = [ask_text("Search cards:")]
 
     values, q = parse_flags(args, CARD_SEARCH_FLAGS)
     values.setdefault("limit", 25)
+    values.setdefault("collapse_parallels", True)
     result = ctx.client.search_cards(CardSearchQuery(q=q, **values))
 
     def market_view(c) -> None:
         render_card_market(ctx.client.get_card_market(c.uuid))
 
-    browse_cards(result, detail=market_view)
+    # The rainbow is fetched on drill-in, not up front: one call per card the user actually opens,
+    # and it returns the WHOLE slot even when the search matched a single finish.
+    def rainbow(c) -> list:
+        return ctx.client.get_parallels(c.uuid)
+
+    browse_cards(
+        result,
+        detail=market_view,
+        printings=rainbow if values["collapse_parallels"] else None,
+    )
 
 
 cmd_search.flags = CARD_SEARCH_FLAGS

{slab_cli-0.14.0 → slab_cli-0.16.0}/src/slab_cli/display.py

@@ -24,7 +24,7 @@ from slab_schemas.pricing import CardComps, CardMarket, PortfolioSummary, SetTop
 from slab_schemas.sealed import SealedPriceHistory, SealedProductOut
 from slab_schemas.timeseries import CardPriceHistory
 
-from .browse import browse
+from .browse import Page, browse
 from .theme import (
     bar,
     console,
@@ -102,7 +102,25 @@ CARD_COLUMNS = [
     ("Finish", {"style": "slab.accent"}),
     ("Attrs", {"style": "slab.dim"}),
     ("Run", {"justify": "right", "style": "slab.dim"}),
-    ("UUID", {"style": "slab.muted"}),
+]
+
+# The collapsed shape: one row per CARD, not per printing. Finish and Run are the two columns that
+# vary *within* a slot, so they move down to the printings level and their place is taken by the
+# count of printings there — the row says "this card exists 17 ways", the level below says which.
+SLOT_COLUMNS = [
+    ("Number", {"style": "slab.value"}),
+    ("Subject(s)", {}),
+    ("Set", {}),
+    ("Subset", {}),
+    ("Attrs", {"style": "slab.dim"}),
+    ("Printings", {"justify": "right", "style": "slab.accent"}),
+]
+
+PRINTING_COLUMNS = [
+    ("Finish", {"style": "slab.accent"}),
+    ("Run", {"justify": "right"}),
+    ("Attrs", {"style": "slab.dim"}),
+    ("Odds", {"style": "slab.dim"}),
 ]
 
 
@@ -112,21 +130,69 @@ def card_cells(c: CardOut) -> list[str]:
     attrs = ", ".join(a.name for a in c.attributes)
     finish = c.finish or "[slab.dim]Base[/]"
     pr = f"/{c.print_run}" if c.print_run else ""
-    return [c.card_number, subjects, c.set_name or "", c.subset or "", finish, attrs, pr, c.uuid[:8]]
+    return [c.card_number, subjects, c.set_name or "", c.subset or "", finish, attrs, pr]
+
+
+def slot_cells(c: CardOut) -> list[str]:
+    """One card SLOT as its SLOT_COLUMNS cells — the base card plus how many printings it has."""
+    subjects = ", ".join(s.name for s in c.subjects)
+    attrs = ", ".join(a.name for a in c.attributes)
+    n = c.printing_count
+    # A card with no parallels is a dead end, so it reads as a dim 1 rather than an invitation.
+    printings = "[slab.dim]1[/]" if not n or n <= 1 else str(n)
+    return [c.card_number, subjects, c.set_name or "", c.subset or "", attrs, printings]
+
+
+def printing_cells(c: CardOut) -> list[str]:
+    """One printing of a slot as its PRINTING_COLUMNS cells — what differs between rainbow rows."""
+    attrs = ", ".join(a.name for a in c.attributes)
+    return [
+        c.finish or "[slab.dim]Base[/]",
+        f"/{c.print_run}" if c.print_run else "[slab.dim]—[/]",
+        attrs,
+        c.odds or "",
+    ]
+
+
+def card_title(c: CardOut) -> str:
+    """A single card named for a heading: '#86 Paul Coffey — 2021-22 Stature'."""
+    subjects = ", ".join(s.name for s in c.subjects) or "—"
+    return f"#{c.card_number} {subjects} — {c.set_name or ''} {c.subset or ''}".strip()
 
 
-def browse_cards(result: CardSearchResult, *, detail=None) -> CardOut | None:
-    """Browse a card search. With `detail` (a `CardOut -> None` renderer), Enter drills into
-    that view as a page; Esc climbs back. Static table on non-interactive output."""
+def browse_cards(result: CardSearchResult, *, detail=None, printings=None) -> CardOut | None:
+    """Browse a card search. `detail` (a `CardOut -> None` renderer) is what Enter opens on a
+    PRINTING; Esc climbs back. Static table on non-interactive output.
+
+    With `printings` (a `CardOut -> list[CardOut]` loader, i.e. the parallels endpoint) the list is
+    one row per card and Enter opens that card's printings as a nested list, whose Enter runs
+    `detail` — so a search for a player reads as his cards, not as every finish of every card.
+    Without it, every printing is its own row and Enter runs `detail` straight away."""
     if not result.items:
         console.print("[slab.dim]No cards found.[/]")
         return None
+    footer = _shown_footer(len(result.items), result.total,
+                           "narrow your search, or `--limit N` to see more.")
+    if printings is None:
+        return browse(
+            CARD_COLUMNS, [(c, card_cells(c)) for c in result.items],
+            title="Cards", note=f"{result.total} total", hint="market view",
+            footer=footer, detail=detail,
+        )
+
+    def rainbow(card: CardOut) -> Page:
+        rows = printings(card)
+        return Page(
+            PRINTING_COLUMNS, [(p, printing_cells(p)) for p in rows],
+            title=card_title(card),
+            note=f"{len(rows)} printing{'' if len(rows) == 1 else 's'}",
+            hint="market view", detail=detail,
+        )
+
     return browse(
-        CARD_COLUMNS, [(c, card_cells(c)) for c in result.items],
-        title="Cards", note=f"{result.total} total", hint="market view",
-        footer=_shown_footer(len(result.items), result.total,
-                             "narrow your search, or `--limit N` to see more."),
-        detail=detail,
+        SLOT_COLUMNS, [(c, slot_cells(c)) for c in result.items],
+        title="Cards", note=f"{result.total} total", hint="printings",
+        footer=footer, detail=rainbow,
     )
 
 

{slab_cli-0.14.0 → slab_cli-0.16.0}/src/slab_cli/flags.py

@@ -162,7 +162,12 @@ _PAGING_FLAGS: list[Flag] = [
 
 # What each search command parses: the shared card grammar + its scope's extras.
 
-CARD_SEARCH_FLAGS: list[Flag] = CARD_FLAGS + _PAGING_FLAGS
+CARD_SEARCH_FLAGS: list[Flag] = CARD_FLAGS + [
+    # Catalog-only: mirrors CardSearchQuery.collapse_parallels, which CollectionSearchQuery has no
+    # equivalent of (a collection lists the copies you own, and a copy already IS one printing).
+    Flag("--printings", "collapse_parallels", "bool",
+         "One row per printing instead of per card", store=False),
+] + _PAGING_FLAGS
 
 COLLECTION_SEARCH_FLAGS: list[Flag] = CARD_FLAGS + [
     # collection-only filters — mirrors CollectionSearchQuery's extension of CardFilter