slab-cli 0.3.0__tar.gz → 0.5.0__tar.gz

{slab_cli-0.3.0 → slab_cli-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: slab-cli
-Version: 0.3.0
+Version: 0.5.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.3.0 → slab_cli-0.5.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "slab-cli"
-version = "0.3.0"
+version = "0.5.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.3.0 → slab_cli-0.5.0}/src/slab_cli/client.py

@@ -22,7 +22,6 @@ from slab_schemas.collection import (
     BreakOut,
     BreakSearchQuery,
     BreakSearchResult,
-    BreakUpdate,
     LotCreate,
     LotOut,
     LotSearchQuery,
@@ -37,7 +36,6 @@ from slab_schemas.collection import (
     CollectionResult,
     CollectionSearchQuery,
     CollectorOut,
-    CollectorUpdate,
 )
 from slab_schemas.custom_sets import (
     CustomSetCardAdd,
@@ -51,8 +49,8 @@ from slab_schemas.custom_sets import (
 )
 from slab_schemas.dashboard import CatalogStats, DashboardStats
 from slab_schemas.pricing import CardComps, CardMarket, SetTopCards
-from slab_schemas.sealed import SealedMarket, SealedPriceHistory, SealedProductOut
-from slab_schemas.timeseries import CardPriceHistory, PortfolioHistory
+from slab_schemas.sealed import SealedPriceHistory, SealedProductOut
+from slab_schemas.timeseries import CardPriceHistory
 
 
 class ApiError(Exception):
@@ -145,21 +143,6 @@ class SlabClient:
         resp = self._request("GET", f"/cards/{card_uuid}/price-history", params=params)
         return CardPriceHistory.model_validate(resp.json())
 
-    def get_portfolio_history(
-        self,
-        collector_uuid: str,
-        start: str | None = None,
-        end: str | None = None,
-        interval: str = "daily",
-    ) -> PortfolioHistory:
-        params: dict[str, str] = {"interval": interval}
-        if start:
-            params["start"] = start
-        if end:
-            params["end"] = end
-        resp = self._request("GET", f"/collectors/{collector_uuid}/portfolio/history", params=params)
-        return PortfolioHistory.model_validate(resp.json())
-
     def search_sets(self, query: SetSearchQuery) -> SetSearchResult:
         resp = self._request("POST", "/sets/search", json=query.model_dump(mode="json", exclude_none=True))
         return SetSearchResult.model_validate(resp.json())
@@ -175,12 +158,6 @@ class SlabClient:
         resp = self._request("GET", f"/sets/{set_uuid}/top-cards", params={"limit": str(limit)})
         return SetTopCards.model_validate(resp.json())
 
-    def get_sealed_market(self, product_uuid: str, comps_limit: int = 25) -> SealedMarket:
-        resp = self._request(
-            "GET", f"/sealed/{product_uuid}/market", params={"comps_limit": str(comps_limit)}
-        )
-        return SealedMarket.model_validate(resp.json())
-
     def get_sealed_price_history(
         self,
         product_uuid: str,
@@ -204,14 +181,6 @@ class SlabClient:
         resp = self._request("GET", "/account")
         return MeOut.model_validate(resp.json())
 
-    # --- collectors ---
-
-    def rename_collector(self, collector_uuid: str, name: str) -> CollectorOut:
-        resp = self._request(
-            "PATCH", f"/collectors/{collector_uuid}", json=CollectorUpdate(name=name).model_dump(mode="json")
-        )
-        return CollectorOut.model_validate(resp.json())
-
     # --- breaks ---
 
     def create_break(self, collector_uuid: str, payload: BreakCreate) -> BreakOut:
@@ -225,14 +194,6 @@ class SlabClient:
         resp = self._request("POST", f"/collectors/{collector_uuid}/breaks/search", json=body)
         return BreakSearchResult.model_validate(resp.json())
 
-    def update_break(self, collector_uuid: str, break_uuid: str, payload: BreakUpdate) -> BreakOut:
-        resp = self._request(
-            "PATCH",
-            f"/collectors/{collector_uuid}/breaks/{break_uuid}",
-            json=payload.model_dump(mode="json", exclude_unset=True),
-        )
-        return BreakOut.model_validate(resp.json())
-
     def delete_break(self, collector_uuid: str, break_uuid: str) -> None:
         self._request("DELETE", f"/collectors/{collector_uuid}/breaks/{break_uuid}")
 

slab_cli-0.5.0/src/slab_cli/commands/setup.py

@@ -0,0 +1,51 @@
+"""Setup commands — check identity.
+
+Collectors are NOT created here. Your account and its collector are provisioned when you sign up
+in the portal; the CLI just consumes the API key and collector UUID you get there. SLAB_COLLECTOR
+is required and explicit — the CLI does not guess a collector from the account, so you must set it
+to the UUID you copy from the portal (Settings).
+"""
+
+from __future__ import annotations
+
+from slab_schemas.account import MeOut
+
+from ..config import get_collector_uuid
+from ..context import ctx
+from ..display import console
+
+
+def cmd_whoami(args: list[str]) -> None:
+    """Show the active collector — and VALIDATE it against your account. SLAB_COLLECTOR is just a
+    string until it's checked, so this resolves it against the account behind your API key and
+    prints the collector's name. A wrong or stale UUID is caught HERE (with the list of collectors
+    you actually own) instead of surfacing later as a cryptic 'collector not found' mid-command."""
+    me = ctx.client.get_account_context()
+    names = {c.uuid: c.name for c in me.collectors}
+    uuid = get_collector_uuid()
+
+    if not uuid:
+        console.print("[yellow]SLAB_COLLECTOR is not set.[/yellow]")
+        _print_collectors(me, names)
+        return
+
+    name = names.get(uuid)
+    if name is None:
+        console.print(f"[red]SLAB_COLLECTOR is {uuid},[/red]")
+        console.print("[red]but that isn't a collector on this account.[/red]")
+        _print_collectors(me, names)
+        return
+
+    console.print(f"Active collector: [bold]{name}[/bold]  [dim]{uuid}[/dim]")
+
+
+def _print_collectors(me: MeOut, names: dict[str, str]) -> None:
+    """List the account's real collectors (marking the default) so the user knows what to set."""
+    if not names:
+        console.print("[dim]This account has no collectors yet.[/dim]")
+        return
+    console.print("[dim]Collectors on this account:[/dim]")
+    for c in me.collectors:
+        tag = " [dim](default)[/dim]" if c.uuid == me.default_collector_uuid else ""
+        console.print(f"  [bold]{c.name}[/bold]{tag}  [dim]{c.uuid}[/dim]")
+    console.print("[dim]Set one:  export SLAB_COLLECTOR=<uuid>[/dim]")

{slab_cli-0.3.0 → slab_cli-0.5.0}/src/slab_cli/context.py

@@ -5,11 +5,8 @@ calling _client()/_require_collector() themselves."""
 
 from __future__ import annotations
 
-import sys
-
 from .client import SlabClient
 from .config import get_api_key, get_base_url, get_collector_uuid
-from .display import console
 
 
 class MissingCollector(Exception):
@@ -31,21 +28,13 @@ class CliContext:
 
     @property
     def collector(self) -> str:
-        """The active collector UUID. Resolution order: SLAB_COLLECTOR env var, then — for a
-        single-collector (`collector`) account only — the account's default collector, so a solo
-        user needs just their API key. A `developer` account owns many collectors (one per
-        end-user), so there is NO safe default: it must set SLAB_COLLECTOR explicitly, or this
-        raises MissingCollector. Cached per invocation."""
+        """The active collector UUID, from the SLAB_COLLECTOR env var. Required and explicit — the
+        CLI does not guess or auto-resolve a collector from the account. Copy your collector's UUID
+        from the portal (Settings) and set SLAB_COLLECTOR to it; if it's unset this raises
+        MissingCollector. Cached per invocation."""
         if self._collector:
             return self._collector
         uuid = get_collector_uuid()
-        if not uuid:
-            # No explicit collector. Only a single-collector account may zero-config fall back to
-            # its default; a developer account has no unambiguous default and must set one.
-            me = self.client.get_account_context()
-            if me.account.account_type == "developer":
-                raise MissingCollector
-            uuid = me.default_collector_uuid
         if not uuid:
             raise MissingCollector
         self._collector = uuid

{slab_cli-0.3.0 → slab_cli-0.5.0}/src/slab_cli/display.py

@@ -38,6 +38,7 @@ from .theme import (
     sparkline,
     titled,
 )
+from .prompts import _slot
 
 
 def format_grade_delta(delta: float | None) -> str | None:
@@ -81,7 +82,7 @@ def format_card_summary(card: CardOut) -> str:
     """One-line summary of a card for inline display. Shows the subset (the line) and the parallel
     finish only when there is one — so a no-finish INSERT reads as its insert name, not 'Base'."""
     subjects = ", ".join(s.name for s in card.subjects) or "—"
-    slot = (card.subset or "?") + (f" · {card.finish}" if card.finish else "")
+    slot = _slot(card)
     pr = f" /{card.print_run}" if card.print_run else ""
     attrs = f" [{', '.join(a.name for a in card.attributes)}]" if card.attributes else ""
     return f"{card.card_number}  {subjects} — {card.brand or ''} {card.set_name or ''} — {slot}{pr}{attrs}"
@@ -419,7 +420,7 @@ def _highlight_panel(title: str, cards: list[HighlightCard], show_cost: bool = F
     rows = []
     for h in cards:
         subj = ", ".join(h.subjects) or "—"
-        slot = (h.subset or "?") + (f" · {h.finish}" if h.finish else "")
+        slot = _slot(h)
         run = f" /{h.print_run}" if h.print_run else ""
         cost = f"   [slab.gain]{money(h.cost_basis)}[/]" if (show_cost and h.cost_basis is not None) else ""
         rows.append(f"[slab.value]#{h.card_number}[/] {subj}  [slab.dim]{slot}{run}[/]{cost}")
@@ -785,7 +786,7 @@ 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 = (card.subset or "?") + (f" · {card.finish}" if card and card.finish 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 "—"
 
@@ -819,7 +820,7 @@ def _card_headline(card_number, subjects: str, set_name: str | None, slot: str)
 def render_card_market(m: CardMarket) -> None:
     """Display the market pricing for a catalog card — all grade buckets."""
     subjects = ", ".join(m.subjects) or "—"
-    slot = (m.subset or "?") + (f" · {m.finish}" if m.finish else "")
+    slot = _slot(m)
     console.print()
     console.print(_card_headline(m.card_number, subjects, m.set_name, slot))
 
@@ -926,7 +927,7 @@ def render_set_market(s: SetOut, sealed: list[SealedProductOut], top: SetTopCard
         ("Comps", {"justify": "right", "style": "slab.dim"}),
     ])
     for i, entry in enumerate(top.cards, 1):
-        slot = (entry.subset or "?") + (f" · {entry.finish}" if entry.finish else "")
+        slot = _slot(entry)
         if entry.print_run:
             slot += f" /{entry.print_run}"
         fmv = f"[slab.foil]{money(entry.market.fair_market_value)}[/]"
@@ -947,7 +948,7 @@ def render_set_market(s: SetOut, sealed: list[SealedProductOut], top: SetTopCard
 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 "—"
-    slot = (c.subset or "?") + (f" · {c.finish}" if c.finish else "")
+    slot = _slot(c)
     console.print()
     console.print(_card_headline(c.card_number, subjects, c.set_name, slot))
 

{slab_cli-0.3.0 → slab_cli-0.5.0}/src/slab_cli/main.py

@@ -8,6 +8,7 @@ one group; `slab <group> <command> --help` explains a single command.
 
 from __future__ import annotations
 
+import re
 import sys
 
 from .client import ApiConnectionError, ApiError
@@ -19,6 +20,16 @@ from .help import render_command_help, render_group_help, render_root_help
 
 _HELP_FLAGS = ("-h", "--help", "help")
 
+# assert_owned's 404 detail for an unknown/unowned collector is exactly "collector <uuid> not found".
+# Distinct from copy/break/lot not-found details ("copy X not found for collector Y"), which name a
+# parent collector but don't start with it — so anchoring to the start avoids false positives.
+_MISSING_COLLECTOR_RE = re.compile(r"^collector \S+ not found$")
+
+
+def _is_missing_collector(detail: str | None) -> bool:
+    """True when a 404 detail means the active collector itself is unknown to this account."""
+    return bool(detail and _MISSING_COLLECTOR_RE.match(detail))
+
 
 def _run(args: list[str]) -> int:
     """Resolve `args` against the registry and run the command. Returns a process exit code."""
@@ -82,7 +93,14 @@ def main() -> None:
         console.print("[dim]  Check that the API is running and SLAB_API_URL is correct.[/dim]")
         sys.exit(1)
     except ApiError as e:
-        if e.status == 404:
+        if e.status == 404 and _is_missing_collector(e.detail):
+            # The active collector (SLAB_COLLECTOR) doesn't resolve to a live collector on this
+            # account. This otherwise surfaces mid-flow (e.g. picking Gift → fetching prior sources)
+            # as a cryptic "Not found" — point the user at the fix instead.
+            console.print("[red]Your active collector wasn't found for this account.[/red]")
+            console.print("  See which one the CLI is using:  [bold]slab collector current[/bold]")
+            console.print("  Then set SLAB_COLLECTOR to a collector UUID from the portal (Settings).")
+        elif e.status == 404:
             console.print(f"[yellow]Not found: {e.detail}[/yellow]")
         elif e.status == 401:
             console.print("[red]Unauthorized — check your SLAB_API_KEY.[/red]")

{slab_cli-0.3.0 → slab_cli-0.5.0}/src/slab_cli/prompts.py

@@ -8,6 +8,7 @@ from __future__ import annotations
 from collections import Counter
 from datetime import date
 from decimal import Decimal, InvalidOperation
+from typing import Protocol
 
 from InquirerPy import inquirer
 from InquirerPy.base.control import Choice
@@ -30,7 +31,15 @@ from .theme import console as _console
 # Label builders (for select menus)
 # ---------------------------------------------------------------------------
 
-def _slot(c: CardOut) -> str:
+class _HasSlot(Protocol):
+    """Any DTO that carries a card's line identity — a subset and an optional parallel finish
+    (CardOut, HighlightCard, CardMarket, custom-set entries, …). `_slot` is duck-typed over these."""
+
+    subset: str | None
+    finish: str | None
+
+
+def _slot(c: _HasSlot) -> str:
     """The card's line: its subset, plus the parallel finish when it has one. 'Base' shows only
     when the subset is literally Base — a no-finish INSERT shows its insert name, not 'Base'
     (id_finish NULL means 'base printing of this line', not 'the base set')."""

slab_cli-0.3.0/src/slab_cli/commands/setup.py

@@ -1,23 +0,0 @@
-"""Setup commands — check identity.
-
-Collectors are NOT created here. Your account and its collector are provisioned when you sign up
-in the portal; the CLI just consumes the API key and collector UUID you get there. When
-SLAB_COLLECTOR is unset the CLI falls back to your account's default collector (see context.py),
-so a solo user only needs their API key.
-"""
-
-from __future__ import annotations
-
-from ..config import get_collector_uuid
-from ..display import console
-
-
-def cmd_whoami(args: list[str]) -> None:
-    uuid = get_collector_uuid()
-    if uuid:
-        console.print(f"Active collector: [bold]{uuid}[/bold]")
-    else:
-        console.print(
-            "[dim]SLAB_COLLECTOR not set — the CLI will use your account's default collector.\n"
-            "Find your collector UUID and API key in the portal.[/dim]"
-        )