gukebox 1.9.1__tar.gz → 1.10.0.dev1__tar.gz

{gukebox-1.9.1 → gukebox-1.10.0.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: gukebox
-Version: 1.9.1
+Version: 1.10.0.dev1
 Summary: A Jukebox to play music on speakers using 'CD' with NFC tag
 Keywords: jukebox,music,nfc
 Author: Gudsfile
@@ -32,18 +32,16 @@ Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
-Requires-Dist: pydantic==2.14.0
+Requires-Dist: pydantic==2.14.1
 Requires-Dist: questionary==2.1.1
-Requires-Dist: soco==0.31.5
+Requires-Dist: soco==0.32.0
 Requires-Dist: typer==0.27.3
-Requires-Dist: fastapi==0.143.0 ; extra == 'api'
+Requires-Dist: fastapi==0.162.0 ; extra == 'api'
 Requires-Dist: uvicorn==0.54.0 ; extra == 'api'
 Requires-Dist: pyserial==3.5 ; extra == 'pn532'
 Requires-Dist: spidev==3.8 ; extra == 'pn532'
 Requires-Dist: lgpio==0.2.2.0 ; python_full_version < '3.13' and extra == 'pn532'
 Requires-Dist: gukebox[api] ; extra == 'ui'
-Requires-Dist: fastui==0.9.0 ; extra == 'ui'
-Requires-Dist: python-multipart==0.0.32 ; extra == 'ui'
 Requires-Python: >=3.11, <3.14
 Project-URL: Repository, https://github.com/Gudsfile/jukebox
 Provides-Extra: api
@@ -168,9 +166,9 @@ Launch the web UI (requires the `ui` extra):
 jukebox-admin ui
 ```
 
-![Jukebox Admin UI showing a disc library table with three entries and a yellow warning banner indicating an unknown NFC tag is on the reader, ready to be added](docs/img/ui-library-index-unknown-nfc-tag-banner.png)
+![Jukebox Admin UI showing the disc library table, with the floating Reader panel reporting an unknown disc on the NFC reader, ready to be added](docs/img/ui-library-index-unknown-nfc-tag-banner.png)
 
-![Add disc form with the NFC tag ID pre-filled, and empty fields for URI, artist, album, track and shuffle](docs/img/ui-add-disc-form.png)
+![Add disc form with the Tag ID pre-filled from the reader, and empty fields for URI / Path, artist, album, track, playlist and shuffle](docs/img/ui-add-disc-form.png)
 
 ## Usage
 
@@ -242,7 +240,7 @@ uv run --extra ui jukebox-admin ui
 ```
 
 > [!NOTE]
-> The admin UI is being migrated from FastUI to a Svelte SPA (see `admin-ui/`). Both currently coexist within the `jukebox-admin ui` process: FastUI serves `/`, while the new SPA is mounted at `/ui`.
+> The admin UI is a Svelte SPA (see `admin-ui/`), served at `/` by the `jukebox-admin ui` process.
 
 #### `library`
 

{gukebox-1.9.1 → gukebox-1.10.0.dev1}/README.md

@@ -115,9 +115,9 @@ Launch the web UI (requires the `ui` extra):
 jukebox-admin ui
 ```
 
-![Jukebox Admin UI showing a disc library table with three entries and a yellow warning banner indicating an unknown NFC tag is on the reader, ready to be added](docs/img/ui-library-index-unknown-nfc-tag-banner.png)
+![Jukebox Admin UI showing the disc library table, with the floating Reader panel reporting an unknown disc on the NFC reader, ready to be added](docs/img/ui-library-index-unknown-nfc-tag-banner.png)
 
-![Add disc form with the NFC tag ID pre-filled, and empty fields for URI, artist, album, track and shuffle](docs/img/ui-add-disc-form.png)
+![Add disc form with the Tag ID pre-filled from the reader, and empty fields for URI / Path, artist, album, track, playlist and shuffle](docs/img/ui-add-disc-form.png)
 
 ## Usage
 
@@ -189,7 +189,7 @@ uv run --extra ui jukebox-admin ui
 ```
 
 > [!NOTE]
-> The admin UI is being migrated from FastUI to a Svelte SPA (see `admin-ui/`). Both currently coexist within the `jukebox-admin ui` process: FastUI serves `/`, while the new SPA is mounted at `/ui`.
+> The admin UI is a Svelte SPA (see `admin-ui/`), served at `/` by the `jukebox-admin ui` process.
 
 #### `library`
 

gukebox-1.10.0.dev1/jukebox/adapters/inbound/admin/api/export_router.py

@@ -0,0 +1,29 @@
+import os
+from collections.abc import Callable
+from datetime import date
+
+from fastapi import APIRouter, HTTPException
+from fastapi.responses import FileResponse
+
+
+def _file_download(path: str, filename: str, missing_detail: str) -> FileResponse:
+    # Serve the bytes as stored on disk: a backup must not be rebuilt from parsed (or migrated) data.
+    if not os.path.isfile(path):
+        raise HTTPException(status_code=404, detail=missing_detail)
+    return FileResponse(path, media_type="application/json", filename=filename)
+
+
+def build_export_router(library_path: str, settings_path: str, today: Callable[[], date] = date.today) -> APIRouter:
+    router = APIRouter(prefix="/api/v1/export", tags=["export"])
+
+    @router.get("/library", summary="Download the library file")
+    def export_library() -> FileResponse:
+        return _file_download(library_path, f"library-{today().isoformat()}.json", "No library file to export.")
+
+    @router.get("/settings", summary="Download the persisted settings file")
+    def export_settings() -> FileResponse:
+        return _file_download(
+            settings_path, f"settings-{today().isoformat()}.json", "No persisted settings file to export."
+        )
+
+    return router

{gukebox-1.9.1 → gukebox-1.10.0.dev1}/jukebox/adapters/inbound/admin/api/models.py

@@ -3,6 +3,8 @@ from typing import Any
 from pydantic import BaseModel, RootModel, computed_field
 
 from jukebox.domain.entities import CurrentTagStatus, Disc
+from jukebox.settings.entities import SelectedSonosGroupSettings
+from jukebox.sonos.discovery import DiscoveredSonosSpeaker
 
 
 class DiscInput(Disc):
@@ -30,7 +32,6 @@ class DiscPatchMetadataInput(BaseModel):
 
 class DiscPatchOptionInput(BaseModel):
     shuffle: bool | None = None
-    is_test: bool | None = None
 
 
 class DiscPatchInput(BaseModel):
@@ -84,3 +85,39 @@ class EditableSettingDisplayOutput(BaseModel):
 class SettingsDisplaysOutput(BaseModel):
     settings: list[EditableSettingDisplayOutput]
     effective_settings_error: str | None = None
+
+
+class SonosSpeakerOutput(DiscoveredSonosSpeaker):
+    pass
+
+
+class SelectedSonosGroupOutput(SelectedSonosGroupSettings):
+    pass
+
+
+class SonosSelectionMemberAvailabilityOutput(BaseModel):
+    uid: str
+    status: str
+    speaker: SonosSpeakerOutput | None = None
+
+
+class SonosSelectionAvailabilityOutput(BaseModel):
+    status: str
+    members: list[SonosSelectionMemberAvailabilityOutput]
+
+
+class SonosSelectionOutput(BaseModel):
+    selected_group: SelectedSonosGroupOutput | None = None
+    availability: SonosSelectionAvailabilityOutput
+
+
+class SonosSelectionInput(BaseModel):
+    uids: list[str]
+    coordinator_uid: str | None = None
+
+
+class SonosSelectionUpdateOutput(BaseModel):
+    selected_group: SelectedSonosGroupOutput
+    availability: SonosSelectionAvailabilityOutput
+    message: str
+    restart_required: bool

gukebox-1.10.0.dev1/jukebox/adapters/inbound/admin/api/pn532_router.py

@@ -0,0 +1,102 @@
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+
+from jukebox.pn532.profiles import PN532_PROFILES, Pn532BoardProfile, SpiConnectionParams, resolve_connection_params
+from jukebox.settings.definitions import get_setting_definition
+from jukebox.settings.entities import Pn532SpiSettings
+from jukebox.settings.errors import SettingsError
+from jukebox.settings.pn532_configuration import save_pn532_configuration
+from jukebox.settings.service_protocols import SettingsService
+
+
+class Pn532PinsOutput(BaseModel):
+    reset: int | None
+    cs: int | None
+    irq: int | None
+
+
+class Pn532ProfileOutput(BaseModel):
+    name: str
+    label: str
+    protocol: str
+    defaults: Pn532PinsOutput
+
+
+class Pn532ConfigOutput(BaseModel):
+    board_profile: str
+    protocol: str
+    overrides: Pn532PinsOutput
+    resolved: Pn532PinsOutput
+    profiles: list[Pn532ProfileOutput]
+
+
+class Pn532ConfigInput(BaseModel):
+    board_profile: Pn532BoardProfile
+    spi: Pn532SpiSettings
+
+
+def _pins(params: SpiConnectionParams) -> Pn532PinsOutput:
+    return Pn532PinsOutput(reset=params.reset, cs=params.cs, irq=params.irq)
+
+
+def _profile_labels() -> dict[str, str]:
+    definition = get_setting_definition("jukebox.reader.pn532.board_profile")
+    return {choice.value: choice.label for choice in definition.choices} if definition else {}
+
+
+def build_pn532_router(settings_service: SettingsService) -> APIRouter:
+    router = APIRouter(prefix="/api/v1", tags=["pn532"])
+
+    @router.get(
+        "/pn532",
+        response_model=Pn532ConfigOutput,
+        summary="Get the effective PN532 config (profile defaults merged with pin overrides)",
+    )
+    def get_pn532() -> Pn532ConfigOutput:
+        try:
+            return _build_config_output(settings_service)
+        except Exception as err:
+            raise HTTPException(status_code=500, detail=f"Server error: {err!s}")
+
+    @router.put(
+        "/pn532",
+        response_model=Pn532ConfigOutput,
+        summary="Save the PN532 board profile and SPI pin overrides",
+    )
+    def put_pn532(payload: Pn532ConfigInput) -> Pn532ConfigOutput:
+        try:
+            save_pn532_configuration(
+                settings_service,
+                payload.board_profile,
+                PN532_PROFILES[payload.board_profile].default_protocol,
+                payload.spi.model_dump(),
+            )
+            return _build_config_output(settings_service)
+        except SettingsError as err:
+            raise HTTPException(status_code=400, detail=str(err))
+        except Exception as err:
+            raise HTTPException(status_code=500, detail=f"Server error: {err!s}")
+
+    return router
+
+
+def _build_config_output(settings_service: SettingsService) -> Pn532ConfigOutput:
+    labels = _profile_labels()
+    pn532 = settings_service.get_effective_settings().jukebox.reader.pn532
+    overrides = SpiConnectionParams(reset=pn532.spi.reset, cs=pn532.spi.cs, irq=pn532.spi.irq)
+    resolved = resolve_connection_params(pn532.board_profile, pn532.protocol, overrides)
+    return Pn532ConfigOutput(
+        board_profile=pn532.board_profile,
+        protocol=pn532.protocol,
+        overrides=_pins(overrides),
+        resolved=_pins(resolved),
+        profiles=[
+            Pn532ProfileOutput(
+                name=name,
+                label=labels.get(name, name),
+                protocol=profile.default_protocol,
+                defaults=_pins(profile.connections[profile.default_protocol]),
+            )
+            for name, profile in PN532_PROFILES.items()
+        ],
+    )

gukebox-1.10.0.dev1/jukebox/adapters/inbound/admin/api/sonos_router.py

@@ -0,0 +1,75 @@
+from fastapi import APIRouter, HTTPException
+
+from jukebox.adapters.inbound.admin.api.models import (
+    SelectedSonosGroupOutput,
+    SonosSelectionAvailabilityOutput,
+    SonosSelectionInput,
+    SonosSelectionMemberAvailabilityOutput,
+    SonosSelectionOutput,
+    SonosSelectionUpdateOutput,
+    SonosSpeakerOutput,
+)
+from jukebox.settings.selected_sonos_group_repository import SettingsSelectedSonosGroupRepository
+from jukebox.settings.service_protocols import SettingsService
+from jukebox.sonos.discovery import SonosDiscoveryError
+from jukebox.sonos.selection import GetSonosSelectionStatus, SaveSonosSelection
+from jukebox.sonos.service import SonosService
+
+
+def build_sonos_router(settings_service: SettingsService, sonos_service: SonosService) -> APIRouter:
+    router = APIRouter(prefix="/api/v1", tags=["sonos"])
+
+    @router.get(
+        "/sonos/speakers", response_model=list[SonosSpeakerOutput], summary="List Sonos speakers on the network"
+    )
+    def get_sonos_speakers():
+        try:
+            return sonos_service.list_network_speakers()
+        except SonosDiscoveryError as err:
+            raise HTTPException(status_code=502, detail=str(err))
+        except Exception as err:
+            raise HTTPException(status_code=500, detail=f"Server error: {err!s}")
+
+    @router.get("/sonos/selection", response_model=SonosSelectionOutput, summary="Get the selected Sonos group")
+    def get_sonos_selection():
+        try:
+            return GetSonosSelectionStatus(
+                SettingsSelectedSonosGroupRepository(settings_service),
+                sonos_service,
+            ).execute()
+        except SonosDiscoveryError as err:
+            raise HTTPException(status_code=502, detail=str(err))
+        except Exception as err:
+            raise HTTPException(status_code=500, detail=f"Server error: {err!s}")
+
+    @router.put("/sonos/selection", response_model=SonosSelectionUpdateOutput, summary="Save the selected Sonos group")
+    def put_sonos_selection(payload: SonosSelectionInput):
+        try:
+            result = SaveSonosSelection(
+                SettingsSelectedSonosGroupRepository(settings_service),
+                sonos_service,
+            ).execute(payload.uids, coordinator_uid=payload.coordinator_uid)
+            return SonosSelectionUpdateOutput(
+                selected_group=SelectedSonosGroupOutput(**result.selected_group.model_dump()),
+                availability=SonosSelectionAvailabilityOutput(
+                    status="available",
+                    members=[
+                        SonosSelectionMemberAvailabilityOutput(
+                            uid=member.uid,
+                            status="available",
+                            speaker=SonosSpeakerOutput(**member.model_dump()),
+                        )
+                        for member in result.members
+                    ],
+                ),
+                message=result.settings_message,
+                restart_required=result.restart_required,
+            )
+        except SonosDiscoveryError as err:
+            raise HTTPException(status_code=502, detail=str(err))
+        except ValueError as err:
+            raise HTTPException(status_code=400, detail=str(err))
+        except Exception as err:
+            raise HTTPException(status_code=500, detail=f"Server error: {err!s}")
+
+    return router

gukebox-1.10.0.dev1/jukebox/adapters/inbound/admin/api_controller.py

@@ -0,0 +1,99 @@
+from jukebox.shared.errors import MissingOptionalDependencyError
+
+try:
+    from fastapi import FastAPI
+
+    from jukebox.adapters.inbound.admin.api.current_tag_router import build_current_tag_router
+    from jukebox.adapters.inbound.admin.api.discs_router import build_discs_router
+    from jukebox.adapters.inbound.admin.api.export_router import build_export_router
+    from jukebox.adapters.inbound.admin.api.models import (
+        CurrentTagDiscOutput,
+        CurrentTagStatusOutput,
+        DiscInput,
+        DiscOutput,
+        DiscPatchInput,
+        SettingsPatchInput,
+        SettingsResetInput,
+        SonosSelectionInput,
+    )
+    from jukebox.adapters.inbound.admin.api.pn532_router import build_pn532_router
+    from jukebox.adapters.inbound.admin.api.settings_router import build_settings_router
+    from jukebox.adapters.inbound.admin.api.sonos_router import build_sonos_router
+except ModuleNotFoundError as e:
+    if e.name != "fastapi":
+        raise
+    raise MissingOptionalDependencyError("The `api_controller` module", "api", "jukebox-admin api") from e
+from jukebox.domain.use_cases import AddDisc, EditDisc, GetCurrentTagStatus, GetDisc, ListDiscs, RemoveDisc
+from jukebox.settings.service_protocols import SettingsService
+from jukebox.sonos.service import SonosService
+
+__all__ = [
+    "APIController",
+    "CurrentTagDiscOutput",
+    "CurrentTagStatusOutput",
+    "DiscInput",
+    "DiscOutput",
+    "DiscPatchInput",
+    "SettingsPatchInput",
+    "SettingsResetInput",
+    "SonosSelectionInput",
+]
+
+
+class APIController:
+    def __init__(
+        self,
+        add_disc: AddDisc,
+        list_discs: ListDiscs,
+        remove_disc: RemoveDisc,
+        edit_disc: EditDisc,
+        get_disc: GetDisc,
+        get_current_tag_status: GetCurrentTagStatus,
+        settings_service: SettingsService,
+        sonos_service: SonosService,
+        library_path: str,
+        settings_path: str,
+    ):
+        self.add_disc = add_disc
+        self.list_discs = list_discs
+        self.remove_disc = remove_disc
+        self.edit_disc = edit_disc
+        self.get_disc = get_disc
+        self.get_current_tag_status = get_current_tag_status
+        self.settings_service = settings_service
+        self.sonos_service = sonos_service
+        self.library_path = library_path
+        self.settings_path = settings_path
+        self.app = FastAPI(
+            title="Jukebox Admin API",
+            description="API for managing Jukebox disc library and settings",
+            docs_url="/docs",
+            redoc_url="/redoc",
+        )
+        self.register_routes()
+
+    def register_routes(self):
+        self.app.include_router(
+            build_discs_router(
+                add_disc=self.add_disc,
+                list_discs=self.list_discs,
+                remove_disc=self.remove_disc,
+                edit_disc=self.edit_disc,
+                get_disc=self.get_disc,
+            )
+        )
+        self.app.include_router(
+            build_current_tag_router(
+                get_current_tag_status=self.get_current_tag_status,
+                add_disc=self.add_disc,
+                edit_disc=self.edit_disc,
+                get_disc=self.get_disc,
+                remove_disc=self.remove_disc,
+            )
+        )
+        self.app.include_router(build_settings_router(self.settings_service))
+        self.app.include_router(
+            build_sonos_router(settings_service=self.settings_service, sonos_service=self.sonos_service)
+        )
+        self.app.include_router(build_pn532_router(self.settings_service))
+        self.app.include_router(build_export_router(self.library_path, self.settings_path))

{gukebox-1.9.1 → gukebox-1.10.0.dev1}/jukebox/adapters/inbound/admin/cli_controller.py

@@ -1,6 +1,13 @@
+import sys
+
 import typer
 
-from jukebox.adapters.inbound.admin.cli_display import display_disc, display_library_line, display_library_table
+from jukebox.adapters.inbound.admin.cli_display import (
+    build_remove_confirmation,
+    display_disc,
+    display_library_line,
+    display_library_table,
+)
 from jukebox.admin.library_commands import (
     CliAddCommand,
     CliEditCommand,
@@ -51,7 +58,7 @@ class CLIController:
                 self.search_discs_flow(command)
 
     def add_disc_flow(self, command: CliAddCommand) -> None:
-        tag = self.resolve_tag_id.execute(command.tag, command.use_current_tag)
+        tag = self.resolve_tag_id.execute(command.tag, command.use_current_tag, command.expected_tag_id)
         option = DiscOption()
         metadata = DiscMetadata(track=command.track, artist=command.artist, album=command.album)
 
@@ -70,7 +77,14 @@ class CLIController:
         typer.echo(f"Displaying mode not implemented yet: mode='{command.mode}'", err=True)
 
     def remove_disc_flow(self, command: CliRemoveCommand) -> None:
-        tag = self.resolve_tag_id.execute(command.tag, command.use_current_tag)
+        tag = self.resolve_tag_id.execute(command.tag, command.use_current_tag, command.expected_tag_id)
+        if not command.yes:
+            disc = self.get_disc.execute(tag)
+            if not sys.stdin.isatty():
+                raise ValueError(f"Refusing to remove disc '{tag}' without confirmation: pass --yes to confirm.")
+            if not typer.confirm(build_remove_confirmation(tag, disc), default=False):
+                typer.echo("Disc not removed")
+                return
         self.remove_disc.execute(tag)
         typer.echo("🗑️ Disc successfully removed")
 
@@ -86,7 +100,7 @@ class CLIController:
         metadata = DiscMetadata(**metadata_fields) if metadata_fields else None
 
         self.edit_disc.execute(
-            tag_id=self.resolve_tag_id.execute(command.tag, command.use_current_tag),
+            tag_id=self.resolve_tag_id.execute(command.tag, command.use_current_tag, command.expected_tag_id),
             uri=command.uri,
             metadata=metadata,
             option=None,
@@ -94,12 +108,9 @@ class CLIController:
         typer.echo("✅ Disc successfully edited")
 
     def get_disc_flow(self, command: CliGetCommand) -> None:
-        try:
-            tag = self.resolve_tag_id.execute(command.tag, command.use_current_tag)
-            disc = self.get_disc.execute(tag)
-            display_disc(tag, disc)
-        except ValueError as e:
-            typer.echo(str(e), err=True)
+        tag = self.resolve_tag_id.execute(command.tag, command.use_current_tag, command.expected_tag_id)
+        disc = self.get_disc.execute(tag)
+        display_disc(tag, disc)
 
     def search_discs_flow(self, command: CliSearchCommand) -> None:
         results = self.search_discs.execute(command.query)

gukebox-1.10.0.dev1/jukebox/adapters/inbound/admin/cli_display.py

@@ -0,0 +1,112 @@
+from collections.abc import Callable
+
+from rich.cells import cell_len
+from rich.console import Console
+from rich.table import Table
+
+from jukebox.domain.entities import Disc
+
+MAX_COL_WIDTH = 20
+
+# A new field also needs a place in TABLE_DROP_ORDER (and maybe TABLE_COL_BOUNDS) below
+DISC_FIELDS: list[tuple[str, Callable[[Disc], str]]] = [
+    ("Type", lambda disc: disc.metadata.display_type),
+    ("Title", lambda disc: disc.metadata.display_title),
+    ("URI", lambda disc: disc.uri),
+    ("Artist", lambda disc: disc.metadata.artist or "/"),
+    ("Album", lambda disc: disc.metadata.album or "/"),
+    ("Track", lambda disc: disc.metadata.track or "/"),
+    ("Playlist", lambda disc: disc.metadata.playlist or "/"),
+    ("Shuffle", lambda disc: str(disc.option.shuffle)),
+]
+LABEL_WIDTH = max(len(label) for label, _ in DISC_FIELDS)
+
+# Table only: Type and Title get a guaranteed width, and Title may grow past MAX_COL_WIDTH.
+# The raw fields (redundant with Title) shrink first, then disappear in TABLE_DROP_ORDER.
+TABLE_COL_BOUNDS: dict[str, tuple[int, int]] = {"Type": (11, 11), "Title": (24, 40), "Shuffle": (5, 7)}
+RAW_COL_BOUNDS = (8, MAX_COL_WIDTH)
+TABLE_DROP_ORDER = ["Playlist", "Track", "Album", "Artist", "Shuffle", "URI"]
+COL_CHROME = 3  # left border + padding on both sides
+
+
+def _disc_lines(disc: Disc) -> list[str]:
+    return [f"  {label:<{LABEL_WIDTH}} : {value(disc)}" for label, value in DISC_FIELDS]
+
+
+def display_disc(tag_id: str, disc: Disc, console: Console | None = None) -> None:
+    _console = console or Console()
+    _console.print(f"\n📀 Disc: {tag_id}")
+    for line in _disc_lines(disc):
+        _console.print(line)
+
+
+def build_remove_confirmation(tag_id: str, disc: Disc) -> str:
+    suffix = f" ({disc.metadata.display_title})" if disc.metadata.has_title else ""
+    return f'Delete disc "{tag_id}"{suffix}?'
+
+
+def display_library_line(discs: dict[str, Disc]) -> None:
+    if not discs:
+        print("The library is empty")
+        return
+
+    print("=== Discs Library ===\n")
+    for disc_id, disc in discs.items():
+        print(f"ID : {disc_id}")
+        for line in _disc_lines(disc):
+            print(line)
+        print("-" * 30)
+
+
+def display_library_table(discs: dict[str, Disc], console: Console | None = None) -> None:
+    _console = console or Console()
+    if not discs:
+        _console.print("The library is empty")
+        return
+
+    # The ID is what users copy into `library get`, so it never shrinks
+    id_width = max(cell_len(str(disc_id)) for disc_id in discs)
+    widths = _table_widths(discs, available=_console.width - 1 - (id_width + COL_CHROME))
+    fields = [(label, value) for label, value in DISC_FIELDS if label in widths]
+
+    table = Table(title="Discs Library")
+    table.add_column("ID", no_wrap=True, min_width=id_width)
+    for label, _ in fields:
+        table.add_column(label, no_wrap=True, width=widths[label])
+
+    for disc_id, disc in discs.items():
+        table.add_row(str(disc_id), *(value(disc) for _, value in fields))
+
+    _console.print(table)
+
+
+def _table_widths(discs: dict[str, Disc], available: int) -> dict[str, int]:
+    """Width of each shown column, in DISC_FIELDS order, which is also the order they grow in."""
+    targets: dict[str, int] = {}
+    minimums: dict[str, int] = {}
+    for label, value in DISC_FIELDS:
+        low, high = TABLE_COL_BOUNDS.get(label, RAW_COL_BOUNDS)
+        natural = max(cell_len(label), *(cell_len(value(disc)) for disc in discs.values()))
+        targets[label] = min(natural, high)
+        minimums[label] = min(targets[label], low)
+
+    shown = [label for label, _ in DISC_FIELDS]
+    for label in TABLE_DROP_ORDER:
+        if sum(minimums[col] + COL_CHROME for col in shown) <= available:
+            break
+        shown.remove(label)
+
+    spare = available - sum(minimums[col] + COL_CHROME for col in shown)
+    widths = {}
+    for label in shown:
+        extra = min(max(spare, 0), targets[label] - minimums[label])
+        widths[label] = minimums[label] + extra
+        spare -= extra
+    # Only Type and Title are left and still too wide (very long ID): give up their minimums
+    for label in reversed(shown):
+        if spare >= 0:
+            break
+        cut = min(-spare, widths[label] - 1)
+        widths[label] -= cut
+        spare += cut
+    return widths