slab-cli 0.22.0__tar.gz → 0.24.0__tar.gz

{slab_cli-0.22.0 → slab_cli-0.24.0}/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.3
 Name: slab-cli
-Version: 0.22.0
+Version: 0.24.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.35.0
+Requires-Dist: slab-schemas>=0.41.0
 Requires-Dist: httpx>=0.27
 Requires-Dist: rich>=13.0
 Requires-Dist: inquirerpy>=0.3

{slab_cli-0.22.0 → slab_cli-0.24.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "slab-cli"
-version = "0.22.0"
+version = "0.24.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"}]
@@ -12,7 +12,7 @@ dependencies = [
     # 0.34 reframes the grading desk from verdicts to break-even readings (BreakEvenRegion,
     # GradingDesk.break_even) — the desk shows data, never tells the user to grade.
     # 0.35 adds Liquidity/LiquidityLabel, which the market view's Sells column renders.
-    "slab-schemas>=0.35.0",
+    "slab-schemas>=0.41.0",  # CardSerials (slab card serials)
     "httpx>=0.27",
     "rich>=13.0",
     "InquirerPy>=0.3",

{slab_cli-0.22.0 → slab_cli-0.24.0}/src/slab_cli/client.py

@@ -17,6 +17,7 @@ from slab_schemas.cards import (
     SetSearchResult,
 )
 from slab_schemas.community import CommunityBoard
+from slab_schemas.serials import CardSerials
 from slab_schemas.collection import (
     BreakCreate,
     BreakOut,
@@ -151,6 +152,12 @@ class SlabClient:
         )
         return CollectionGradingDesk.model_validate(resp.json())
 
+    def get_card_serials(self, card_uuid: str) -> CardSerials:
+        """Which numbered copies of this printing have surfaced — sales with a stated serial and
+        collection copies — grouped by serial (GET /cards/{uuid}/serials)."""
+        resp = self._request("GET", f"/cards/{card_uuid}/serials")
+        return CardSerials.model_validate(resp.json())
+
     def get_card_price_history(
         self,
         card_uuid: str,

{slab_cli-0.22.0 → slab_cli-0.24.0}/src/slab_cli/commands/pricing.py

@@ -17,6 +17,7 @@ from ..display import (
     render_portfolio,
     render_price_history,
     render_sealed_price_history,
+    render_serials,
     render_set_market,
 )
 from ..paging import fetch_all_pages
@@ -71,6 +72,17 @@ def cmd_comps(args: list[str]) -> None:
     render_comps(ctx.client.get_card_comps(card.uuid))
 
 
+def cmd_serials(args: list[str]) -> None:
+    """Which numbered copies of a card have surfaced. Same player → set → card flow as `price`,
+    then one row per serial seen: how many collections hold it, how many times it has sold, and
+    its last sale. Sales and held copies are shown apart — the collector who bought #24 on eBay
+    is one transfer seen from both sides. Unnumbered printings say so and stop."""
+    card = _pick_card(args)
+    if card is None:
+        return
+    render_serials(ctx.client.get_card_serials(card.uuid))
+
+
 def _split_desk_flags(args: list[str]) -> tuple[list[str], float | None, str | None]:
     """Pull `--fee <amount>` and `--company <name>` out of a grading query. Hand-rolled (the
     shared flag grammar is search-specific); an unparseable fee errors loudly rather than

{slab_cli-0.22.0 → slab_cli-0.24.0}/src/slab_cli/commands/registry.py

@@ -61,6 +61,7 @@ GROUPS: list[Group] = [
         Command("price", "Market price + 7d/30d trend", pricing.cmd_price, "<query>"),
         Command("grade", "The grading math: payoffs per grade + break-even", pricing.cmd_grade, "<query> [--fee N]"),
         Command("comps", "Recent raw sales behind the price", pricing.cmd_comps, "<query>"),
+        Command("serials", "Which numbered copies have surfaced (sales + collections)", pricing.cmd_serials, "<query>"),
         Command("history", "Price history over time", pricing.cmd_history, "<query>"),
     ]),
     Group("set", "browse and price sealed products", [

{slab_cli-0.22.0 → slab_cli-0.24.0}/src/slab_cli/display.py

@@ -24,6 +24,7 @@ from slab_schemas.enums import BreakEvenRegion, Grade, LiquidityLabel, SealedFor
 from slab_schemas.liquidity import Liquidity
 from slab_schemas.pricing import CardComps, CardMarket, PortfolioSummary, SetTopCards
 from slab_schemas.sealed import SealedPriceHistory, SealedProductOut
+from slab_schemas.serials import CardSerials
 from slab_schemas.timeseries import CardPriceHistory
 
 from .browse import Page, browse
@@ -1254,6 +1255,51 @@ def render_set_market(s: SetOut, sealed: list[SealedProductOut], top: SetTopCard
     console.print("  [slab.dim]Drill in with `slab card price` / `slab card comps`.[/]\n")
 
 
+def render_serials(s: CardSerials) -> None:
+    """Which numbered copies of a printing have surfaced — one row per serial, sales and held
+    copies kept apart (the same transfer can be seen from both sides). The meaning text comes
+    from the response's glossary, so the CLI, the site and the API say the same words."""
+    subjects = ", ".join(s.subjects) or "—"
+    console.print()
+    console.print(_card_headline(s.card_number, subjects, s.set_name, _slot(s)))
+
+    if not s.print_run:
+        console.print("\n  [slab.dim]This printing isn't serial-numbered, so there are no serials to track.[/]\n")
+        return
+
+    unseen = max(0, s.print_run - s.serials_seen)
+    pct = f" ({s.coverage_pct:.0f}%)" if s.coverage_pct is not None else ""
+    console.print(heading("Serials Seen", f"{s.serials_seen} of /{s.print_run}{pct} · {unseen} never surfaced"))
+    if not s.serials:
+        console.print("  [slab.dim]No numbered copy of this card has surfaced in a sale or a collection yet.[/]\n")
+        return
+
+    table = slab_table([
+        ("Serial", {"justify": "right", "style": "slab.foil"}),
+        ("Held", {"justify": "right"}),
+        ("Sales", {"justify": "right"}),
+        ("Last sale", {"justify": "right", "style": "slab.foil"}),
+        ("Grade", {"style": "slab.dim"}),
+        ("Last seen", {"style": "slab.dim"}),
+    ])
+    for sig in s.serials:
+        last = sig.sales[-1] if sig.sales else None
+        table.add_row(
+            f"{sig.serial_number}/{s.print_run}",
+            str(sig.held) if sig.held else "[slab.dim]—[/]",
+            str(len(sig.sales)) if sig.sales else "[slab.dim]—[/]",
+            money(last.sale_price) if last and last.sale_price is not None else "—",
+            (last.grade_key or "—") if last else "—",
+            sig.last_seen.isoformat() if sig.last_seen else "—",
+        )
+    console.print(table)
+    for key in ("serials.coverage", "serials.held"):
+        info = s.glossary.get(key)
+        if info:
+            console.print(f"  [slab.dim]{info.label}: {info.summary}[/]")
+    console.print()
+
+
 def render_comps(c: CardComps) -> None:
     """Display recent comps (raw sales) for a catalog card — the evidence behind its FMV."""
     subjects = ", ".join(c.subjects) or "—"

{slab_cli-0.22.0 → slab_cli-0.24.0}/src/slab_cli/prompts.py

@@ -184,6 +184,20 @@ def select_printing(cards: list[CardOut], subject: str, show_set: bool = False)
     ).execute()
 
 
+def _released_at(s: SetOut) -> date:
+    """When a set hit shelves, for newest-first ordering.
+
+    `year` is the SEASON (2025 for a 2025-26 product) and a season's products ship across fourteen
+    months, so ranking by it ties a whole season together and puts a 2025-26 product that shipped
+    in July above a 2024-25 one that shipped in October. Sets whose overview hasn't been ingested
+    carry no release date, so those fall back to Jan 1 of the season's second calendar year — the
+    middle of that season's window — which keeps them among their own season. Same rule as the
+    API's `-release` sort."""
+    if s.release_date:
+        return s.release_date
+    return date(s.year + 1, 1, 1) if s.year else date.min
+
+
 def select_set(sets: list[SetOut], initial: str | None = None) -> SetOut | None:
     """Pick one set from the catalog — fuzzy type-to-filter, pre-seeded with the user's query so
     the closest names surface immediately (backspace to widen). Auto-selects a lone match;
@@ -192,7 +206,9 @@ def select_set(sets: list[SetOut], initial: str | None = None) -> SetOut | None:
         return None
     if len(sets) == 1:
         return sets[0]
-    ranked = sorted(sets, key=lambda s: (-(s.year or 0), s.name or ""))  # newest first
+    # Newest release first, name A-Z within a day — negate the ordinal rather than reversing the
+    # whole sort, which would flip the names too.
+    ranked = sorted(sets, key=lambda s: (-_released_at(s).toordinal(), s.name or ""))
     choices = [Choice(value=s, name=_set_label(s)) for s in ranked]
     return inquirer.fuzzy(
         message=f"Which set? ({len(sets)} in catalog — type to filter):",