slab-cli 0.10.0__tar.gz → 0.12.0__tar.gz

{slab_cli-0.10.0 → slab_cli-0.12.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: slab-cli
-Version: 0.10.0
+Version: 0.12.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.10.0 → slab_cli-0.12.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "slab-cli"
-version = "0.10.0"
+version = "0.12.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.10.0 → slab_cli-0.12.0}/src/slab_cli/client.py

@@ -336,7 +336,14 @@ class SlabClient:
         resp = self._request("POST", "/custom-sets/search", json=body)
         return CustomSetSearchResult.model_validate(resp.json())
 
-    def get_custom_set(self, set_uuid: str, collector_uuid: str | None = None) -> CustomSetDetail:
-        params = {"collector_uuid": collector_uuid} if collector_uuid else {}
+    def get_custom_set(
+        self, set_uuid: str, collector_uuid: str | None = None,
+        limit: int | None = None, offset: int | None = None,
+    ) -> CustomSetDetail:
+        params: dict = {"collector_uuid": collector_uuid} if collector_uuid else {}
+        if limit is not None:
+            params["limit"] = limit
+        if offset is not None:
+            params["offset"] = offset
         resp = self._request("GET", f"/custom-sets/{set_uuid}", params=params)
         return CustomSetDetail.model_validate(resp.json())

{slab_cli-0.10.0 → slab_cli-0.12.0}/src/slab_cli/commands/collection.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 import re
 from dataclasses import dataclass, field
+from datetime import date
 from decimal import Decimal
 
 from slab_schemas.cards import CardOut, CardSearchQuery
@@ -68,6 +69,7 @@ class AddSession:
     lot_uuid: str | None = None          # the purchase this batch belongs to; its cost splits across cards
     release_set_uuid: str | None = None  # the break's product — scopes every card search to that box
     acquired_source: str | None = None   # where these came from (purchases/trades/gifts), set once
+    acquired_date: date | None = None    # when you got them; None for break/lot cards (theirs wins)
     cards_added: int = 0
 
 
@@ -119,6 +121,14 @@ def _ensure_acquisition_context(session: AddSession) -> None:
         # Trade / gift / other → ask where these came from, once for the batch.
         session.acquired_source = pick_source(session.client, session.collector)
 
+    # When you got them — asked once, and ONLY for standalone cards: a break/lot card takes its
+    # date from the container (which already asked), and storing a second copy of it would just be
+    # something else to keep in sync. Enter defaults to today, so the common "adding what I bought
+    # today" case is one keystroke — but an old pickup can be dated correctly, which matters
+    # because the portfolio chart only counts a card from the day you got it.
+    if session.break_uuid is None and session.lot_uuid is None:
+        session.acquired_date = ask_date("When did you get it?")
+
 
 def _per_card_cost(session: AddSession) -> Decimal | None:
     """The cost that varies per card. Pack pulls derive cost from the break, and a purchase attached
@@ -164,6 +174,8 @@ def _show_review(card: CardOut, session: AddSession, acq_cost: Decimal | None,
         console.print(f"    Purchase:    {session.lot_uuid[:8]}  [dim](cost split across the lot)[/dim]")
     if acq_cost is not None:
         console.print(f"    Cost:        ${acq_cost:.2f}")
+    if session.acquired_date:
+        console.print(f"    Date:        {session.acquired_date}")
     if session.acquired_source:
         console.print(f"    Source:      {session.acquired_source}")
     if self_grade:
@@ -197,6 +209,7 @@ def _submit_and_report(session: AddSession, card: CardOut, acq_cost: Decimal | N
         lot_uuid=session.lot_uuid,
         acquisition_type=session.acq_type,
         acquisition_cost=acq_cost,
+        acquired_date=session.acquired_date,
         acquired_source=session.acquired_source,
         self_grade=self_grade,
         grading_company=grading_company,

{slab_cli-0.10.0 → slab_cli-0.12.0}/src/slab_cli/commands/custom_sets.py

@@ -5,13 +5,16 @@ from __future__ import annotations
 from InquirerPy import inquirer
 from InquirerPy.base.control import Choice
 
+from types import SimpleNamespace
+
 from slab_schemas.custom_sets import (
     CustomSetCardAdd,
     CustomSetCreate,
+    CustomSetDetail,
     CustomSetOut,
     CustomSetSearchQuery,
 )
-from slab_schemas.enums import CustomSetType, MatchMode, Visibility
+from slab_schemas.enums import CustomSetType, DynamicMatch, MatchMode, Visibility
 
 from ..client import SlabClient
 from ..context import ctx
@@ -21,6 +24,7 @@ from ..display import (
     format_card_summary,
     print_custom_set_detail,
 )
+from ..paging import fetch_all_pages
 from ..picker import search_and_pick_subject
 from ..prompts import (
     ask_int_optional,
@@ -28,6 +32,8 @@ from ..prompts import (
     ask_text_optional,
     confirm,
     select_custom_set_type,
+    select_dynamic_match,
+    select_entry_kind,
     select_match_mode,
     select_printing,
     select_visibility,
@@ -38,6 +44,25 @@ from ..prompts import (
 # Helpers
 # ---------------------------------------------------------------------------
 
+def _fetch_full_detail(
+    client: SlabClient, set_uuid: str, collector: str | None
+) -> CustomSetDetail:
+    """The set with its WHOLE card list — the detail endpoint pages `cards` (completion stats
+    already cover the full set), so flows that show or iterate every entry stitch the pages back
+    together here. Capped at 5000 entries as a runaway bound (a `year`-only dynamic filter can
+    match a whole catalog); past the cap, `card_count` > len(cards) and the display says so."""
+    first: list = []
+
+    def fetch(limit: int, offset: int):
+        d = client.get_custom_set(set_uuid, collector, limit=limit, offset=offset)
+        if not first:
+            first.append(d)
+        return SimpleNamespace(items=d.cards, total=d.card_count)
+
+    cards, _ = fetch_all_pages(fetch, page=500, cap=5000)
+    return first[0].model_copy(update={"cards": cards, "offset": 0})
+
+
 def _select_custom_set(client: SlabClient, collector: str, message: str = "Select a set:") -> CustomSetOut | None:
     """Browse the collector's custom sets and pick one."""
     sets = client.collector_custom_sets(collector)
@@ -98,6 +123,7 @@ def cmd_chase_create(args: list[str]) -> None:
     visibility = select_visibility()
 
     filter_json = None
+    dynamic_match = "any_printing"
     if set_type == "dynamic":
         console.print("\n[dim]A dynamic set is defined by a search filter. Enter the filter criteria.[/dim]")
         console.print("[dim]Cards matching this filter will automatically be in the set.[/dim]\n")
@@ -106,6 +132,15 @@ def cmd_chase_create(args: list[str]) -> None:
         if filter_json is None:
             console.print("[dim]Cancelled.[/dim]")
             return
+        # One set-wide granularity. Default follows the filter's intent: a filter that names a
+        # finish/parallel dimension reads as a per-printing chase; anything else (team, player,
+        # season) reads as "one of each card — base or any parallel counts".
+        chasing_printings = any(
+            k in filter_json for k in ("finish", "parallel_only", "is_numbered", "is_1of1")
+        )
+        dynamic_match = select_dynamic_match(
+            default="exact" if chasing_printings else "any_printing"
+        )
 
     cs = ctx.client.create_custom_set(collector, CustomSetCreate(
         name=name,
@@ -113,6 +148,7 @@ def cmd_chase_create(args: list[str]) -> None:
         visibility=Visibility(visibility),
         set_type=CustomSetType(set_type),
         filter_json=filter_json,
+        dynamic_match=DynamicMatch(dynamic_match),
     ))
 
     console.print(f"\n[green]Created![/green]  {cs.name}  [dim]({cs.uuid[:8]})[/dim]")
@@ -214,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:
@@ -277,17 +361,18 @@ def cmd_chase_view(args: list[str]) -> None:
     client = ctx.client
 
     if args:
-        detail = client.get_custom_set(args[0], collector)
+        detail = _fetch_full_detail(client, args[0], collector)
     else:
         cs = _select_custom_set(client, collector, message="Which set to view?")
         if cs is None:
             return
-        detail = client.get_custom_set(cs.uuid, collector)
+        detail = _fetch_full_detail(client, cs.uuid, collector)
 
     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)
@@ -311,8 +396,8 @@ def cmd_chase_edit(args: list[str]) -> None:
     if cs is None:
         return
 
-    # Check ownership
-    detail = client.get_custom_set(cs.uuid, collector)
+    # Check ownership — metadata only, skip the card list
+    detail = client.get_custom_set(cs.uuid, collector, limit=1)
     if detail.creator_uuid != collector:
         console.print("[yellow]You can only edit sets you created.[/yellow]")
         return
@@ -350,7 +435,7 @@ def cmd_chase_edit(args: list[str]) -> None:
 
 def _chase_detail(s) -> None:
     """The drill-in for a browsed chase set: its full card list + completion, owner-aware."""
-    print_custom_set_detail(ctx.client.get_custom_set(s.uuid, ctx.collector))
+    print_custom_set_detail(_fetch_full_detail(ctx.client, s.uuid, ctx.collector))
 
 
 def cmd_chase_list(args: list[str]) -> None:
@@ -436,7 +521,7 @@ def cmd_chase_remove(args: list[str]) -> None:
         console.print("[yellow]Can only remove cards from curated sets.[/yellow]")
         return
 
-    detail = client.get_custom_set(cs.uuid, collector)
+    detail = _fetch_full_detail(client, cs.uuid, collector)
     if not detail.cards:
         console.print("[dim]This set has no cards.[/dim]")
         return
@@ -444,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}"))
 
@@ -475,8 +563,8 @@ def cmd_chase_delete(args: list[str]) -> None:
     if cs is None:
         return
 
-    # Check ownership
-    detail = client.get_custom_set(cs.uuid, collector)
+    # Check ownership — metadata only, skip the card list
+    detail = client.get_custom_set(cs.uuid, collector, limit=1)
     if detail.creator_uuid != collector:
         console.print("[yellow]You can only delete sets you created.[/yellow]")
         return

{slab_cli-0.10.0 → slab_cli-0.12.0}/src/slab_cli/display.py

@@ -530,10 +530,15 @@ def render_dashboard(d: DashboardStats) -> None:
         if d.priced_coverage is not None:
             rows.append(("Coverage", f"{pct_coverage(float(d.priced_coverage) * 100)} [slab.dim]priced[/]"))
         # Portfolio value over time — the CLI stand-in for the portal's chart, from the same payload.
+        # Each point values only the copies owned that day, so the net includes cards you ADDED in
+        # the window, not just price movement — said plainly so it isn't read as a 90d gain.
         if len(d.portfolio_series) >= 2:
             vals = [p.portfolio_value for p in d.portfolio_series]
             net = float(vals[-1]) - float(vals[0])
-            rows.append(("Trend 90d", f"{sparkline(vals)}   {signed_money(net)}"))
+            rows.append((
+                "Trend 90d",
+                f"{sparkline(vals)}   {signed_money(net)} [slab.dim]incl. cards added[/]",
+            ))
     value = section("Value", kv_grid(rows), foil=True)
 
     comp = _composition_panel(
@@ -805,7 +810,11 @@ def print_custom_set_detail(detail: CustomSetDetail) -> None:
     vis = "Public" if detail.visibility == "public" else "Private"
     sub = "subscribed" if detail.is_subscribed else "not subscribed"
 
-    head = [f"[slab.dim]{detail.set_type} · {vis} · {sub}[/]"]
+    kind = detail.set_type
+    if detail.dynamic_match:
+        grain = "any printing counts" if detail.dynamic_match == "any_printing" else "exact printings"
+        kind = f"{detail.set_type} ({grain})"
+    head = [f"[slab.dim]{kind} · {vis} · {sub}[/]"]
     if detail.description:
         head.append(detail.description)
     head.append(f"[slab.label]Creator[/] {detail.creator_name or '—'}   "
@@ -832,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 ''}[/]"
@@ -848,6 +868,13 @@ def print_custom_set_detail(detail: CustomSetDetail) -> None:
             table.add_row(str(entry.position), label, match, owned)
 
         console.print(table)
+        if detail.card_count > len(detail.cards):
+            first = detail.offset + 1
+            last = detail.offset + len(detail.cards)
+            console.print(
+                f"  [slab.dim]Showing entries {first}–{last} of {detail.card_count} "
+                f"(completion covers the full set).[/]"
+            )
     console.print()
 
 

{slab_cli-0.10.0 → slab_cli-0.12.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"),
@@ -452,6 +461,21 @@ def select_custom_set_type() -> str:
     return inquirer.select(message="Set type:", choices=choices).execute()
 
 
+def select_dynamic_match(default: str = "any_printing") -> str:
+    """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 an entry?", choices=choices, default=default,
+    ).execute()
+
+
 def select_cost_category() -> str:
     choices = [
         Choice(value="grading", name="Grading fee"),