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

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

@@ -1,9 +1,9 @@
 Metadata-Version: 2.3
 Name: slab-cli
-Version: 0.13.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.13.0 → slab_cli-0.16.0}/pyproject.toml

@@ -1,12 +1,13 @@
 [project]
 name = "slab-cli"
-version = "0.13.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.13.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.13.0 → slab_cli-0.16.0}/src/slab_cli/client.py

@@ -40,6 +40,7 @@ from slab_schemas.collection import (
 from slab_schemas.custom_sets import (
     CustomSetCardAdd,
     CustomSetCardOut,
+    CustomSetCardUpdate,
     CustomSetCreate,
     CustomSetDetail,
     CustomSetOut,
@@ -316,6 +317,17 @@ class SlabClient:
         )
         return CustomSetCardOut.model_validate(resp.json())
 
+    def update_set_card(
+        self, collector_uuid: str, set_uuid: str, entry_uuid: str, payload: CustomSetCardUpdate
+    ) -> CustomSetCardOut:
+        # Sparse by fields-set (not exclude_none): explicitly passing None CLEARS a qualifier.
+        resp = self._request(
+            "PATCH",
+            f"/collectors/{collector_uuid}/custom-sets/{set_uuid}/cards/{entry_uuid}",
+            json=payload.model_dump(mode="json", exclude_unset=True),
+        )
+        return CustomSetCardOut.model_validate(resp.json())
+
     def delete_set_card(self, collector_uuid: str, set_uuid: str, entry_uuid: str) -> None:
         self._request("DELETE", f"/collectors/{collector_uuid}/custom-sets/{set_uuid}/cards/{entry_uuid}")
 

{slab_cli-0.13.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.13.0 → slab_cli-0.16.0}/src/slab_cli/commands/custom_sets.py

@@ -236,7 +236,8 @@ def _build_dynamic_filter() -> dict | None:
 # ---------------------------------------------------------------------------
 
 def cmd_chase_add(args: list[str]) -> None:
-    """Add cards to a curated custom set — batch mode like `slab collection add`."""
+    """Add entries to a curated custom set — specific cards or player slots, batch mode like
+    `slab collection add`."""
     collector = ctx.collector
     client = ctx.client
 
@@ -388,7 +389,7 @@ def cmd_chase_view(args: list[str]) -> None:
 
 
 def cmd_chase_edit(args: list[str]) -> None:
-    """Edit a custom set's name, description, or visibility."""
+    """Edit a custom set's name, description, visibility, or (dynamic) match granularity."""
     collector = ctx.collector
     client = ctx.client
 
@@ -404,7 +405,10 @@ def cmd_chase_edit(args: list[str]) -> None:
 
     console.print(f"\n  Current name: {cs.name}")
     console.print(f"  Current description: {cs.description or '—'}")
-    console.print(f"  Current visibility: {cs.visibility}\n")
+    console.print(f"  Current visibility: {cs.visibility}")
+    if cs.set_type == "dynamic":
+        console.print(f"  Current match granularity: {detail.dynamic_match}")
+    console.print()
 
     from slab_schemas.custom_sets import CustomSetUpdate
 
@@ -413,11 +417,20 @@ def cmd_chase_edit(args: list[str]) -> None:
     vis = None
     if confirm("Change visibility?", default=False):
         vis = select_visibility()
+    new_match = None
+    if cs.set_type == "dynamic" and confirm(
+        "Change what counts as having an entry? (per printing / per card / per player)",
+        default=False,
+    ):
+        new_match = select_dynamic_match(default=detail.dynamic_match or "any_printing")
+        if new_match == detail.dynamic_match:
+            new_match = None
 
     update = CustomSetUpdate(
         name=name,
         description=description,
         visibility=Visibility(vis) if vis else None,
+        dynamic_match=DynamicMatch(new_match) if new_match else None,
     )
 
     # Only send if something changed
@@ -427,6 +440,11 @@ def cmd_chase_edit(args: list[str]) -> None:
 
     updated = client.update_custom_set(collector, cs.uuid, update)
     console.print(f"[green]Updated![/green]  {updated.name}")
+    if new_match:
+        console.print(
+            f"  [dim]Membership redefined — the set now tracks one entry per "
+            f"{'player' if new_match == 'any_card' else 'card slot' if new_match == 'any_printing' else 'printing'}.[/dim]"
+        )
 
 
 # ---------------------------------------------------------------------------
@@ -521,33 +539,114 @@ def cmd_chase_remove(args: list[str]) -> None:
         console.print("[yellow]Can only remove cards from curated sets.[/yellow]")
         return
 
-    detail = _fetch_full_detail(client, cs.uuid, collector)
-    if not detail.cards:
-        console.print("[dim]This set has no cards.[/dim]")
-        return
+    entry = _pick_entry(client, collector, cs.uuid, "Remove which entry?")
+    if entry and confirm(f"Remove this entry? ({entry.uuid[:8]})", default=False):
+        client.delete_set_card(collector, cs.uuid, entry.uuid)
+        console.print("[green]Removed.[/green]")
 
-    choices = []
-    for entry in detail.cards:
-        card = entry.card
-        if card:
-            subjects = ", ".join(s.name for s in card.subjects)
-            label = f"{card.card_number}  {subjects} — {entry.match_mode}"
-            if entry.serial_number is not None:
-                label += f" #{entry.serial_number}"
-        else:
-            label = f"{entry.subject or '—'} — any card"
-        owned = " ✓" if entry.owned else ""
-        choices.append(Choice(value=entry, name=f"{label}{owned}"))
 
-    entry = inquirer.select(
-        message=f"Remove which card? ({len(detail.cards)} in set):",
+def _entry_label(entry) -> str:
+    """One line describing an entry — the card and its mode, or the player slot + qualifiers."""
+    card = entry.card
+    if card:
+        subjects = ", ".join(s.name for s in card.subjects)
+        label = f"{card.card_number}  {subjects} — {entry.match_mode}"
+        if entry.serial_number is not None:
+            label += f" #{entry.serial_number}"
+        return label
+    quals = " · ".join(str(q) for q in (
+        f"{entry.subject_year}-{str(entry.subject_year + 1)[-2:]}" if entry.subject_year else None,
+        entry.subject_team, entry.subject_attribute) if q)
+    return f"{entry.subject or '—'} — any card" + (f" · {quals}" if quals else "")
+
+
+def _pick_entry(client: SlabClient, collector: str, set_uuid: str, message: str):
+    """Fetch the full entry list and pick one (None if empty or backed out)."""
+    detail = _fetch_full_detail(client, set_uuid, collector)
+    if not detail.cards:
+        console.print("[dim]This set has no entries.[/dim]")
+        return None
+    choices = [
+        Choice(value=e, name=f"{_entry_label(e)}{' ✓' if e.owned else ''}")
+        for e in detail.cards
+    ]
+    return inquirer.select(
+        message=f"{message} ({len(detail.cards)} in set):",
         choices=choices,
         max_height="70%",
     ).execute()
 
-    if entry and confirm(f"Remove this card entry? ({entry.uuid[:8]})", default=False):
-        client.delete_set_card(collector, cs.uuid, entry.uuid)
-        console.print("[green]Removed.[/green]")
+
+# ---------------------------------------------------------------------------
+# slab chase tune — retune one entry (match mode / player-slot qualifiers)
+# ---------------------------------------------------------------------------
+
+def cmd_chase_tune(args: list[str]) -> None:
+    """Retune one entry of a curated set: a card entry's match mode, or a player slot's
+    season/team/attribute qualifiers. An entry's KIND (card vs player) is fixed — switch by
+    removing and re-adding."""
+    collector = ctx.collector
+    client = ctx.client
+
+    cs = _select_custom_set(client, collector, message="Which set to tune?")
+    if cs is None:
+        return
+    if cs.set_type != "curated":
+        console.print("[yellow]Dynamic sets have one set-wide granularity — use `slab chase edit`.[/yellow]")
+        return
+    detail = client.get_custom_set(cs.uuid, collector, limit=1)
+    if detail.creator_uuid != collector:
+        console.print("[yellow]You can only tune sets you created.[/yellow]")
+        return
+
+    entry = _pick_entry(client, collector, cs.uuid, "Tune which entry?")
+    if entry is None:
+        return
+
+    from slab_schemas.custom_sets import CustomSetCardUpdate
+
+    changes: dict = {}
+    if entry.card:
+        console.print(f"\n  {_entry_label(entry)}")
+        new_mode = select_match_mode()
+        if new_mode != entry.match_mode:
+            changes["match_mode"] = MatchMode(new_mode)
+        if new_mode == "exact_serial":
+            serial = ask_int_optional("Which serial number?")
+            if serial is None:
+                console.print("[yellow]Serial number is required for exact_serial.[/yellow]")
+                return
+            if serial != entry.serial_number:
+                changes["serial_number"] = serial
+    else:
+        console.print(f"\n  {_entry_label(entry)}")
+        console.print("  [dim]Retune the qualifiers — Enter keeps the current value, '-' clears it.[/dim]")
+        for field, label, cast in (
+            ("subject_year", f"Season (current: {entry.subject_year or 'any'}):", int),
+            ("subject_team", f"Team (current: {entry.subject_team or 'any'}):", str),
+            ("subject_attribute", f"Attribute (current: {entry.subject_attribute or 'any'}):", str),
+        ):
+            raw = ask_text_optional(label)
+            if not raw:
+                continue
+            if raw.strip() == "-":
+                if getattr(entry, field) is not None:
+                    changes[field] = None
+                continue
+            try:
+                value = cast(raw.strip())
+            except ValueError:
+                console.print(f"[yellow]  Skipped — not a valid value for {field}.[/yellow]")
+                continue
+            if value != getattr(entry, field):
+                changes[field] = value
+
+    if not changes:
+        console.print("[dim]No changes.[/dim]")
+        return
+
+    updated = client.update_set_card(collector, cs.uuid, entry.uuid, CustomSetCardUpdate(**changes))
+    console.print(f"[green]Tuned![/green]  {_entry_label(updated)}")
 
 
 # ---------------------------------------------------------------------------

{slab_cli-0.13.0 → slab_cli-0.16.0}/src/slab_cli/commands/registry.py

@@ -94,13 +94,14 @@ GROUPS: list[Group] = [
     ]),
     Group("chase", "custom sets & set-completion", [
         Command("create", "Create a custom set (curated or dynamic)", custom_sets.cmd_chase_create),
-        Command("add", "Add cards to a curated set", custom_sets.cmd_chase_add),
+        Command("add", "Add cards or player slots to a curated set", custom_sets.cmd_chase_add),
         Command("view", "View a set with completion + add missing", custom_sets.cmd_chase_view, "[uuid]"),
-        Command("edit", "Edit name, description, or visibility", custom_sets.cmd_chase_edit),
+        Command("edit", "Edit name, description, visibility, or granularity", custom_sets.cmd_chase_edit),
+        Command("tune", "Retune one entry — match mode or player-slot qualifiers", custom_sets.cmd_chase_tune),
         Command("list", "Your sets (created + subscribed)", custom_sets.cmd_chase_list),
         Command("find", "Discover public sets by name", custom_sets.cmd_chase_find, "[query]"),
         Command("subscribe", "Subscribe to / unsubscribe from a public set", custom_sets.cmd_chase_subscribe, "[query]"),
-        Command("remove", "Remove a card from a set", custom_sets.cmd_chase_remove),
+        Command("remove", "Remove an entry from a set", custom_sets.cmd_chase_remove),
         Command("delete", "Delete a set you created", custom_sets.cmd_chase_delete),
     ]),
     Group("collector", "your identity", [

{slab_cli-0.13.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.13.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