slab-cli 0.1.0__py3-none-any.whl

slab_cli/commands/custom_sets.py

@@ -0,0 +1,484 @@
+"""Custom set commands — create, add cards, view completion, edit, remove, delete."""
+
+from __future__ import annotations
+
+from InquirerPy import inquirer
+from InquirerPy.base.control import Choice
+
+from slab_schemas.custom_sets import (
+    CustomSetCardAdd,
+    CustomSetCreate,
+    CustomSetOut,
+    CustomSetSearchQuery,
+)
+from slab_schemas.enums import CustomSetType, MatchMode, Visibility
+
+from ..client import SlabClient
+from ..context import ctx
+from ..display import (
+    console,
+    format_card_summary,
+    print_custom_set_detail,
+    print_custom_sets,
+)
+from ..picker import search_and_pick_subject
+from ..prompts import (
+    ask_int_optional,
+    ask_text,
+    ask_text_optional,
+    confirm,
+    select_custom_set_type,
+    select_match_mode,
+    select_printing,
+    select_visibility,
+)
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+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)
+    if not sets:
+        console.print("[dim]No custom sets yet. Use `slab chase create` to make one.[/dim]")
+        return None
+    choices = [
+        Choice(value=s, name=f"{s.name}  ({s.set_type} · {s.card_count} cards · {s.subscriber_count} subs)")
+        for s in sets
+    ]
+    return inquirer.select(message=message, choices=choices, max_height="70%").execute()
+
+
+def _pick_from_sets(sets: list[CustomSetOut], message: str) -> CustomSetOut | None:
+    """Pick one set from an arbitrary result list (discovery/search), labelling creator + whether
+    you're already subscribed — distinct from `_select_custom_set`, which lists only your own sets."""
+    if not sets:
+        return None
+    choices = []
+    for s in sets:
+        sub = "  ✓ subscribed" if s.is_subscribed else ""
+        by = f" — by {s.creator_name}" if s.creator_name else ""
+        choices.append(Choice(
+            value=s,
+            name=f"{s.name}  ({s.set_type} · {s.card_count} cards · {s.subscriber_count} subs){by}{sub}",
+        ))
+    return inquirer.select(message=message, choices=choices, max_height="70%").execute()
+
+
+def _search_and_select_card_for_set() -> tuple[str | None, str | None]:
+    """Search the catalog, pick a player, pick a printing. Returns (card_uuid, subject_name) or
+    (None, None). Uses the shared subject picker; the only chase-specific step is the summary print
+    and the (uuid, subject) return shape the batch loop wants."""
+    picked = search_and_pick_subject(None)
+    if picked is None:
+        return None, None
+    cards, subject = picked
+
+    card = select_printing(cards, subject)
+    if card is None:
+        return None, None
+
+    console.print(f"\n  [bold]{format_card_summary(card)}[/bold]\n")
+    return card.uuid, subject
+
+
+# ---------------------------------------------------------------------------
+# slab chase create — create a new custom set
+# ---------------------------------------------------------------------------
+
+def cmd_chase_create(args: list[str]) -> None:
+    """Create a new custom set — curated or dynamic."""
+    collector = ctx.collector
+
+    name = ask_text("Set name:")
+    description = ask_text_optional("Description (enter to skip):")
+    set_type = select_custom_set_type()
+    visibility = select_visibility()
+
+    filter_json = None
+    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")
+        # Build a CardFilter interactively
+        filter_json = _build_dynamic_filter()
+        if filter_json is None:
+            console.print("[dim]Cancelled.[/dim]")
+            return
+
+    cs = ctx.client.create_custom_set(collector, CustomSetCreate(
+        name=name,
+        description=description,
+        visibility=Visibility(visibility),
+        set_type=CustomSetType(set_type),
+        filter_json=filter_json,
+    ))
+
+    console.print(f"\n[green]Created![/green]  {cs.name}  [dim]({cs.uuid[:8]})[/dim]")
+    console.print(f"  Type: {cs.set_type}  |  Visibility: {cs.visibility}")
+    console.print(f"  You are auto-subscribed.\n")
+
+    if set_type == "curated" and confirm("Add cards to this set now?", default=True):
+        _batch_add_cards(ctx.client, collector, cs.uuid)
+
+
+def _build_dynamic_filter() -> dict | None:
+    """Build a CardFilter dict interactively for a dynamic set.
+
+    Walks through the most common filter dimensions. Each is skippable (enter = skip).
+    At least one filter must be set."""
+    filter_parts: dict = {}
+
+    console.print("[dim]  Set the criteria for this dynamic set. Press enter to skip any field.[/dim]\n")
+
+    subject = ask_text_optional("Player name:")
+    if subject:
+        filter_parts["subject"] = subject
+
+    team = ask_text_optional("Team (e.g. Maple Leafs):")
+    if team:
+        filter_parts["team"] = [team]
+
+    subset = ask_text_optional("Subset (e.g. Young Guns):")
+    if subset:
+        filter_parts["subset"] = [subset]
+
+    brand = ask_text_optional("Brand (e.g. Upper Deck):")
+    if brand:
+        filter_parts["brand"] = [brand]
+
+    year_str = ask_text_optional("Season year (e.g. 2025):")
+    if year_str:
+        try:
+            filter_parts["year"] = int(year_str)
+        except ValueError:
+            console.print("[yellow]  Skipped — not a valid year.[/yellow]")
+
+    finish = ask_text_optional("Finish (e.g. Rainbow, Gold):")
+    if finish:
+        filter_parts["finish"] = [finish]
+
+    attribute = ask_text_optional("Attribute (e.g. Rookie, Autograph, Memorabilia):")
+    if attribute:
+        filter_parts["attribute"] = [attribute]
+
+    # Boolean filters — only ask the ones that make sense
+    if "attribute" not in filter_parts:
+        if confirm("Only rookies?", default=False):
+            filter_parts["rookie"] = True
+
+    if confirm("Only numbered cards?", default=False):
+        filter_parts["is_numbered"] = True
+        max_run = ask_text_optional("Max print run (e.g. 99 for /99-or-less, enter to skip):")
+        if max_run:
+            try:
+                filter_parts["numbered_max"] = int(max_run)
+            except ValueError:
+                pass
+
+    if "finish" not in filter_parts:
+        if confirm("Only base cards (no parallels)?", default=False):
+            filter_parts["base_only"] = True
+
+    if not filter_parts:
+        console.print("[yellow]No filters set — a dynamic set needs at least one.[/yellow]")
+        return None
+
+    console.print("\n  [bold]Filter preview:[/bold]")
+    for k, v in filter_parts.items():
+        console.print(f"    {k}: {v}")
+
+    if not confirm("Create with these filters?", default=True):
+        return None
+
+    return filter_parts
+
+
+# ---------------------------------------------------------------------------
+# slab chase add — add cards to a curated set (batch)
+# ---------------------------------------------------------------------------
+
+def cmd_chase_add(args: list[str]) -> None:
+    """Add cards to a curated custom set — batch mode like `slab collection add`."""
+    collector = ctx.collector
+    client = ctx.client
+
+    cs = _select_custom_set(client, collector, message="Which set to add cards to?")
+    if cs is None:
+        return
+    if cs.set_type != "curated":
+        console.print("[yellow]Can only add cards to curated sets. Dynamic sets are filter-defined.[/yellow]")
+        return
+
+    _batch_add_cards(client, collector, cs.uuid)
+
+
+def _batch_add_cards(client: SlabClient, collector: str, set_uuid: str) -> None:
+    """Batch loop: search → pick player → pick printing → choose match mode → add.
+
+    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."""
+    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(
+                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}")
+        console.print()
+        added += 1
+
+        if not confirm("Add another card to this set?", default=True):
+            break
+
+    if added > 0:
+        console.print(f"[dim]Done — {added} card(s) added to the set.[/dim]")
+
+
+# ---------------------------------------------------------------------------
+# slab chase view — view a set with completion
+# ---------------------------------------------------------------------------
+
+def cmd_chase_view(args: list[str]) -> None:
+    """View a custom set with your completion progress. Offers to add missing cards."""
+    collector = ctx.collector
+    client = ctx.client
+
+    if args:
+        detail = client.get_custom_set(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)
+
+    print_custom_set_detail(detail)
+
+    # Offer to add missing cards to the collection
+    missing = [e for e in detail.cards if not e.owned]
+    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)
+        for entry in missing:
+            card = entry.card
+            subjects = ", ".join(s.name for s in card.subjects)
+            console.print(f"\n  [bold]{card.card_number}[/bold] {subjects} — {card.finish or 'Base'}")
+            if confirm("Add this missing card to your collection?", default=False):
+                # Pre-fill this exact printing — skip the search, go straight to acquisition details.
+                _add_single_card(session, card=card)
+            if not confirm("Continue to next missing card?", default=True):
+                break
+
+
+def cmd_chase_edit(args: list[str]) -> None:
+    """Edit a custom set's name, description, or visibility."""
+    collector = ctx.collector
+    client = ctx.client
+
+    cs = _select_custom_set(client, collector, message="Which set to edit?")
+    if cs is None:
+        return
+
+    # Check ownership
+    detail = client.get_custom_set(cs.uuid, collector)
+    if detail.creator_uuid != collector:
+        console.print("[yellow]You can only edit sets you created.[/yellow]")
+        return
+
+    console.print(f"\n  Current name: {cs.name}")
+    console.print(f"  Current description: {cs.description or '—'}")
+    console.print(f"  Current visibility: {cs.visibility}\n")
+
+    from slab_schemas.custom_sets import CustomSetUpdate
+
+    name = ask_text_optional(f"New name (enter to keep '{cs.name}'):")
+    description = ask_text_optional("New description (enter to keep current):")
+    vis = None
+    if confirm("Change visibility?", default=False):
+        vis = select_visibility()
+
+    update = CustomSetUpdate(
+        name=name,
+        description=description,
+        visibility=Visibility(vis) if vis else None,
+    )
+
+    # Only send if something changed
+    if not any(v is not None for v in update.model_dump(exclude_unset=True).values()):
+        console.print("[dim]No changes.[/dim]")
+        return
+
+    updated = client.update_custom_set(collector, cs.uuid, update)
+    console.print(f"[green]Updated![/green]  {updated.name}")
+
+
+# ---------------------------------------------------------------------------
+# slab chase list — your custom sets
+# ---------------------------------------------------------------------------
+
+def cmd_chase_list(args: list[str]) -> None:
+    """List your custom sets (created + subscribed)."""
+    sets = ctx.client.collector_custom_sets(ctx.collector)
+    print_custom_sets(sets)
+
+
+# ---------------------------------------------------------------------------
+# slab chase find — discover public sets
+# ---------------------------------------------------------------------------
+
+def _discover_sets(client: SlabClient, collector: str, args: list[str], empty_prompt: str) -> list[CustomSetOut]:
+    """Search public sets (plus your own), most-subscribed first. `collector` is passed so results
+    carry the is_subscribed flag. Returns the matching sets (possibly empty)."""
+    q = " ".join(args) if args else ask_text_optional(empty_prompt)
+    result = client.search_custom_sets(
+        CustomSetSearchQuery(q=q, collector_uuid=collector, sort="-subscribers")
+    )
+    return result.items
+
+
+def cmd_chase_find(args: list[str]) -> None:
+    """Discover public chase sets by name (your own private sets are included too). This is how you
+    find a set someone else published before subscribing to it with `slab chase subscribe`."""
+    sets = _discover_sets(ctx.client, ctx.collector, args, "Search sets by name (enter for all public):")
+    if not sets:
+        console.print("[yellow]No matching sets found.[/yellow]")
+        return
+    print_custom_sets(sets)
+    console.print(
+        "[dim]`slab chase subscribe` to track one · `slab chase view <uuid>` to see its cards.[/dim]"
+    )
+
+
+# ---------------------------------------------------------------------------
+# slab chase subscribe — subscribe to / unsubscribe from a public set
+# ---------------------------------------------------------------------------
+
+def cmd_chase_subscribe(args: list[str]) -> None:
+    """Subscribe to a public chase set (or unsubscribe if already tracking it). Search by name,
+    pick one, and toggle. Subscribed sets show in `slab chase list` and track your completion."""
+    collector = ctx.collector
+    client = ctx.client
+
+    sets = _discover_sets(client, collector, args, "Search sets by name (enter for popular public sets):")
+    if not sets:
+        console.print("[yellow]No matching sets found.[/yellow]")
+        return
+
+    cs = _pick_from_sets(sets, message="Which set?")
+    if cs is None:
+        return
+
+    if cs.is_subscribed:
+        if confirm(f"You're already subscribed to '{cs.name}'. Unsubscribe?", default=False):
+            client.unsubscribe(collector, cs.uuid)
+            console.print(f"[green]Unsubscribed.[/green]  {cs.name}")
+        else:
+            console.print("[dim]No change.[/dim]")
+    else:
+        if confirm(f"Subscribe to '{cs.name}'?", default=True):
+            client.subscribe(collector, cs.uuid)
+            console.print(f"[green]Subscribed![/green]  {cs.name}  [dim]— track it with `slab chase view`[/dim]")
+        else:
+            console.print("[dim]No change.[/dim]")
+
+
+# ---------------------------------------------------------------------------
+# slab chase remove — remove a card from a curated set
+# ---------------------------------------------------------------------------
+
+def cmd_chase_remove(args: list[str]) -> None:
+    """Remove a card entry from a curated set."""
+    collector = ctx.collector
+    client = ctx.client
+
+    cs = _select_custom_set(client, collector, message="Which set to remove a card from?")
+    if cs is None:
+        return
+    if cs.set_type != "curated":
+        console.print("[yellow]Can only remove cards from curated sets.[/yellow]")
+        return
+
+    detail = client.get_custom_set(cs.uuid, collector)
+    if not detail.cards:
+        console.print("[dim]This set has no cards.[/dim]")
+        return
+
+    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}"
+        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):",
+        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 delete — delete a set you created
+# ---------------------------------------------------------------------------
+
+def cmd_chase_delete(args: list[str]) -> None:
+    """Delete a custom set you created — removes the set, its card entries, and every subscription."""
+    collector = ctx.collector
+    client = ctx.client
+
+    cs = _select_custom_set(client, collector, message="Which set to delete?")
+    if cs is None:
+        return
+
+    # Check ownership
+    detail = client.get_custom_set(cs.uuid, collector)
+    if detail.creator_uuid != collector:
+        console.print("[yellow]You can only delete sets you created.[/yellow]")
+        return
+
+    console.print(f"\n  [bold]{cs.name}[/bold]  ({cs.set_type} · {cs.card_count} cards · {cs.subscriber_count} subs)")
+    if not confirm("Delete this set? It disappears for every subscriber.", default=False):
+        console.print("[dim]Cancelled.[/dim]")
+        return
+
+    client.delete_custom_set(collector, cs.uuid)
+    console.print(f"[green]Deleted.[/green]  {cs.name}")

slab_cli/commands/export.py

@@ -0,0 +1,129 @@
+"""Export command — dump your collection to a printable CSV checklist.
+
+Built for the physical audit / stock-take: you have a stack of cards and want to reconcile it
+against what's recorded. Run `slab export`, pick one of the sets you own from the list (fuzzy — no
+need to type an exact name), and you get a CSV with an `in_hand` column. Print it, tick each card
+off as you match it, and the one physical card with no row is your gap. Rows are sorted by
+subset → finish → card number so they walk in the same order you'd sort a stack.
+"""
+
+from __future__ import annotations
+
+import csv
+
+from slab_schemas.collection import CollectionSearchQuery
+
+from ..context import ctx
+from ..display import console
+from ..paging import fetch_all_pages
+from ..prompts import select_owned_set
+from .collection import _natural_chunks
+
+_COLUMNS = ["in_hand", "subset", "finish", "card_number", "player", "serial", "print_run", "status", "cost_basis"]
+
+
+def _num_key(card_number: str | None) -> tuple:
+    """Numeric-aware sort key mirroring the physical-stack order used in the collection walk: purely
+    numeric card numbers first (ascending), lettered/alphanumeric runs after — each ordered by full
+    natural chunks so 'B-2' sorts before 'B-10'. Reuses collection._natural_chunks so the export and
+    the walk sort identically (the old first-digit-run-only key mis-ordered multi-part numbers)."""
+    s = (card_number or "").strip()
+    return (0 if s.isdigit() else 1, _natural_chunks(s))
+
+
+def _fetch_all(collector: str, set_slug: str | None) -> list:
+    """Page through the whole collection (or one set) — no row cap."""
+    copies, _ = fetch_all_pages(
+        lambda limit, offset: ctx.client.search_collection(
+            collector,
+            CollectionSearchQuery(
+                set_slug=[set_slug] if set_slug else None, limit=limit, offset=offset
+            ),
+        ),
+    )
+    return copies
+
+
+def _owned_sets(copies: list) -> list[tuple[str, str, int]]:
+    """Distinct (slug, name, count) of the sets these copies belong to, sorted by count desc."""
+    agg: dict[str, list] = {}
+    for cp in copies:
+        c = cp.card
+        if not c or not c.set_slug:
+            continue
+        entry = agg.setdefault(c.set_slug, [c.set_name or c.set_slug, 0])
+        entry[1] += 1
+    return sorted(((slug, name, n) for slug, (name, n) in agg.items()), key=lambda s: (-s[2], s[1]))
+
+
+def _write_csv(copies: list, out_file: str) -> None:
+    copies = sorted(
+        copies,
+        key=lambda cp: (
+            (cp.card.subset or "") if cp.card else "",
+            (cp.card.finish or "") if cp.card else "",
+            _num_key(cp.card.card_number if cp.card else None),
+            (cp.card.card_number or "") if cp.card else "",
+        ),
+    )
+    with open(out_file, "w", newline="") as fh:
+        writer = csv.writer(fh)
+        writer.writerow(_COLUMNS)
+        for cp in copies:
+            c = cp.card
+            players = " / ".join(s.name for s in c.subjects) if c else ""
+            writer.writerow([
+                "[ ]",
+                (c.subset if c else "") or "",
+                (c.finish if c else None) or "BASE",
+                (c.card_number if c else "") or "",
+                players,
+                cp.serial_number if cp.serial_number is not None else "",
+                (c.print_run if c else None) or "",
+                cp.status or "",
+                f"{cp.cost_basis:.2f}" if cp.cost_basis is not None else "",
+            ])
+
+
+def cmd_export(args: list[str]) -> None:
+    """Export your collection to a printable CSV checklist.
+
+    Usage: slab export [--set <slug>] [--out FILE]
+      slab export                       # pick a set from a list (or the whole collection)
+      slab export --set <slug>          # non-interactive (scripting)
+      slab export --out audit.csv
+    """
+    out_file: str | None = None
+    set_slug: str | None = None
+    it = iter(args)
+    for a in it:
+        if a in ("--out", "-o"):
+            out_file = next(it, None)
+        elif a == "--set":
+            set_slug = next(it, None)
+
+    if set_slug is None:
+        # Interactive: fetch the collection, let the user pick from the sets they own.
+        all_copies = _fetch_all(ctx.collector, None)
+        if not all_copies:
+            console.print("[yellow]Your collection is empty — nothing to export.[/yellow]")
+            return
+        picked = select_owned_set(_owned_sets(all_copies), total=len(all_copies))
+        set_slug = picked or None  # "" → whole collection
+        copies = all_copies if set_slug is None else [
+            cp for cp in all_copies if cp.card and cp.card.set_slug == set_slug
+        ]
+    else:
+        copies = _fetch_all(ctx.collector, set_slug)
+        if not copies:
+            console.print(f"[yellow]No copies found for set '{set_slug}'.[/yellow]")
+            return
+
+    out_file = out_file or f"{set_slug or 'slab-collection'}-checklist.csv"
+    _write_csv(copies, out_file)
+
+    console.print(f"\n[green]Exported {len(copies)} copies[/green] → [bold]{out_file}[/bold]")
+    console.print(
+        "[dim]Open/print it and tick in_hand as you match each physical card — "
+        "the one card with no row is your gap.[/dim]"
+    )