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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: slab-cli
-Version: 0.11.0
+Version: 0.13.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

{slab_cli-0.11.0 → slab_cli-0.13.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "slab-cli"
-version = "0.11.0"
+version = "0.13.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"}]

{slab_cli-0.11.0 → slab_cli-0.13.0}/src/slab_cli/commands/custom_sets.py

@@ -33,6 +33,7 @@ from ..prompts import (
     confirm,
     select_custom_set_type,
     select_dynamic_match,
+    select_entry_kind,
     select_match_mode,
     select_printing,
     select_visibility,
@@ -249,53 +250,101 @@ def cmd_chase_add(args: list[str]) -> None:
     _batch_add_cards(client, collector, cs.uuid)
 
 
+def _build_player_slot(position: int) -> tuple[CustomSetCardAdd, str] | None:
+    """The player-slot path: pick a subject, optionally narrow with qualifiers. Returns the
+    payload plus a display label, or None if the user backed out."""
+    picked = search_and_pick_subject(None, prompt="Search for the player:")
+    if picked is None:
+        return None
+    cards, subject_name = picked
+    subject_uuid = next(
+        (s.uuid for c in cards for s in c.subjects if s.name == subject_name and s.uuid), None)
+    if subject_uuid is None:
+        console.print("[yellow]The API did not serve a subject id — is it up to date?[/yellow]")
+        return None
+
+    console.print(f"\n  [bold]{subject_name}[/bold] — any card of this player fills the slot.")
+    console.print("  [dim]Optionally narrow what counts. Enter skips each — skip all three for"
+                  " truly any card.[/dim]")
+    year = ask_int_optional("Only a season? (2025 = 2025-26):")
+    team = ask_text_optional("Only showing them on a team? (e.g. Hurricanes):")
+    attribute = ask_text_optional("Require an attribute? (e.g. Autograph, Rookie):")
+
+    quals = [q for q in (
+        f"{year}-{str(year + 1)[-2:]}" if year else None, team or None, attribute or None) if q]
+    label = f"{subject_name} — any card" + (f" · {' · '.join(quals)}" if quals else "")
+    payload = CustomSetCardAdd(
+        subject_uuid=subject_uuid,
+        match_mode=MatchMode.any_card,
+        subject_year=year,
+        subject_team=team or None,
+        subject_attribute=attribute or None,
+        position=position,
+    )
+    return payload, label
+
+
 def _batch_add_cards(client: SlabClient, collector: str, set_uuid: str) -> None:
-    """Batch loop: search → pick player → pick printing → choose match mode → add.
+    """Batch loop: choose the kind of goal (a card, or a player), build the entry, add, repeat.
 
-    Match mode is decided once and reused (like acquisition type in `slab collection add`).
-    Serial number is only asked once if exact_serial — reused for the batch."""
+    For card entries the match mode is decided once and reused (like acquisition type in
+    `slab collection add`); serial number likewise. Player slots ask their qualifiers each time —
+    they ARE the entry."""
     default_match: str | None = None
     default_serial: int | None = None
     added = 0
 
     while True:
-        card_uuid, subject = _search_and_select_card_for_set()
-        if card_uuid is None:
-            if added > 0 and not confirm("Try again?", default=True):
-                break
-            elif added == 0:
-                return
-            continue
-
-        # Match mode — ask once, reuse across batch
-        if default_match is None:
-            default_match = select_match_mode()
-            if default_match == "exact_serial":
-                default_serial = ask_int_optional("Which serial number (applies to all cards in this batch)?")
-                if default_serial is None:
-                    console.print("[yellow]Serial number is required for exact_serial match.[/yellow]")
-                    default_match = None
-                    continue
-
-        serial = default_serial if default_match == "exact_serial" else None
-
-        entry = client.add_set_card(
-            collector, set_uuid,
-            CustomSetCardAdd(
+        kind = select_entry_kind()
+
+        if kind == "player":
+            built = _build_player_slot(added)
+            if built is None:
+                if added == 0 and not confirm("Try again?", default=True):
+                    return
+                continue
+            payload, label = built
+        else:
+            card_uuid, subject = _search_and_select_card_for_set()
+            if card_uuid is None:
+                if added > 0 and not confirm("Try again?", default=True):
+                    break
+                elif added == 0:
+                    return
+                continue
+
+            # Match mode — ask once, reuse across batch
+            if default_match is None:
+                default_match = select_match_mode()
+                if default_match == "exact_serial":
+                    default_serial = ask_int_optional("Which serial number (applies to all cards in this batch)?")
+                    if default_serial is None:
+                        console.print("[yellow]Serial number is required for exact_serial match.[/yellow]")
+                        default_match = None
+                        continue
+
+            serial = default_serial if default_match == "exact_serial" else None
+            payload = CustomSetCardAdd(
                 card_uuid=card_uuid,
                 match_mode=MatchMode(default_match),
                 serial_number=serial,
                 position=added,
-            ),
-        )
-        match_label = entry.match_mode
-        if entry.serial_number is not None:
-            match_label = f"serial #{entry.serial_number}"
-        console.print(f"[green]Added![/green]  {subject or 'Card'} — {match_label}")
+            )
+            label = f"{subject or 'Card'} — " + (
+                f"serial #{serial}" if serial is not None else default_match)
+
+        try:
+            client.add_set_card(collector, set_uuid, payload)
+        except Exception as exc:  # 409 duplicate slot etc. — keep the batch alive
+            console.print(f"[yellow]Not added: {exc}[/yellow]")
+            if not confirm("Add another entry to this set?", default=True):
+                break
+            continue
+        console.print(f"[green]Added![/green]  {label}")
         console.print()
         added += 1
 
-        if not confirm("Add another card to this set?", default=True):
+        if not confirm("Add another entry to this set?", default=True):
             break
 
     if added > 0:
@@ -322,7 +371,8 @@ def cmd_chase_view(args: list[str]) -> None:
     print_custom_set_detail(detail)
 
     # Offer to add missing cards to the collection
-    missing = [e for e in detail.cards if not e.owned]
+    # Only card-backed entries can pre-fill an add; a player slot has no single card to offer.
+    missing = [e for e in detail.cards if not e.owned and e.card]
     if missing and confirm(f"Add any of the {len(missing)} missing cards to your collection?", default=False):
         from .collection import _add_single_card, AddSession
         session = AddSession(client=client, collector=collector)
@@ -479,10 +529,13 @@ def cmd_chase_remove(args: list[str]) -> None:
     choices = []
     for entry in detail.cards:
         card = entry.card
-        subjects = ", ".join(s.name for s in card.subjects) if card else "—"
-        label = f"{card.card_number}  {subjects} — {entry.match_mode}"
-        if entry.serial_number is not None:
-            label += f" #{entry.serial_number}"
+        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}"))
 

{slab_cli-0.11.0 → slab_cli-0.13.0}/src/slab_cli/display.py

@@ -841,14 +841,25 @@ def print_custom_set_detail(detail: CustomSetDetail) -> None:
 
         for entry in detail.cards:
             card = entry.card
-            subjects = ", ".join(s.name for s in card.subjects) if card else "—"
-            slot = _slot(card) if card else "—"
-            pr = f" /{card.print_run}" if card and card.print_run else ""
-            label = f"{card.card_number}  {subjects} [slab.dim]— {slot}{pr}[/]" if card else "—"
+            if card:
+                subjects = ", ".join(s.name for s in card.subjects)
+                slot = _slot(card)
+                pr = f" /{card.print_run}" if card.print_run else ""
+                label = f"{card.card_number}  {subjects} [slab.dim]— {slot}{pr}[/]"
+            else:
+                # A player slot: the subject is the goal; show its qualifiers inline.
+                quals = " · ".join(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)
+                label = f"{entry.subject or '—'} [slab.dim]— any card"
+                label += f" · {quals}[/]" if quals else "[/]"
 
             match = entry.match_mode
             if entry.match_mode == "exact_serial" and entry.serial_number is not None:
                 match = f"serial #{entry.serial_number}"
+            elif entry.match_mode == "any_card":
+                match = "player"
 
             if entry.owned:
                 owned = f"[slab.gain]✓[/] [slab.dim]{entry.owned_printing or ''}[/]"

{slab_cli-0.11.0 → slab_cli-0.13.0}/src/slab_cli/prompts.py

@@ -436,6 +436,15 @@ def select_match_mode() -> str:
     return inquirer.select(message="Match mode:", choices=choices).execute()
 
 
+def select_entry_kind() -> str:
+    """The first fork when adding to a chase set: is the goal a card, or a player?"""
+    choices = [
+        Choice(value="card", name="A specific card — search the catalog, pick the printing"),
+        Choice(value="player", name="A player — any card of them counts (optionally narrowed)"),
+    ]
+    return inquirer.select(message="What are you chasing?", choices=choices).execute()
+
+
 def select_visibility() -> str:
     choices = [
         Choice(value="private", name="Private — only you can see it"),
@@ -453,15 +462,17 @@ def select_custom_set_type() -> str:
 
 
 def select_dynamic_match(default: str = "any_printing") -> str:
-    """The set-wide granularity of a dynamic set — what counts as completing a card."""
+    """The set-wide granularity of a dynamic set — what counts as completing an entry."""
     choices = [
         Choice(value="any_printing",
                name="Any printing — one entry per card; base or any parallel completes it"),
+        Choice(value="any_card",
+               name="Any card — one entry per PLAYER; any matching card completes it (roster chase)"),
         Choice(value="exact",
                name="Exact — every matching parallel is its own entry to chase"),
     ]
     return inquirer.select(
-        message="What counts as having a card?", choices=choices, default=default,
+        message="What counts as having an entry?", choices=choices, default=default,
     ).execute()