gukebox 1.9.1__tar.gz → 1.10.0.dev2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: gukebox
-Version: 1.9.1
+Version: 1.10.0.dev2
 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
@@ -61,7 +59,7 @@ Pick an album, place it on the reader, and the music starts playing. Remove it,
 
 [![gukebox last version](https://img.shields.io/pypi/v/gukebox.svg?logo=pypi)](https://pypi.python.org/pypi/gukebox)
 [![license](https://img.shields.io/pypi/l/gukebox.svg)](https://pypi.python.org/pypi/gukebox)
-[![actions status](https://github.com/gudsfile/jukebox/actions/workflows/python.yml/badge.svg)](https://github.com/gudsfile/jukebox/actions)
+[![actions status](https://github.com/gudsfile/jukebox/actions/workflows/ci.yml/badge.svg)](https://github.com/gudsfile/jukebox/actions)
 
 ![rpi](https://img.shields.io/badge/-Zero%202W%20%7C%203%20%7C%205-C51A4A?logo=raspberry-pi&label=RPi&logoColor=C51A4A&labcolor=C51A4A)
 [![python versions](https://img.shields.io/pypi/pyversions/gukebox.svg?logo=python)](https://pypi.python.org/pypi/gukebox) [![uv](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/uv/main/assets/badge/v0.json)](https://github.com/astral-sh/uv)
@@ -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.dev2}/README.md

@@ -8,7 +8,7 @@ Pick an album, place it on the reader, and the music starts playing. Remove it,
 
 [![gukebox last version](https://img.shields.io/pypi/v/gukebox.svg?logo=pypi)](https://pypi.python.org/pypi/gukebox)
 [![license](https://img.shields.io/pypi/l/gukebox.svg)](https://pypi.python.org/pypi/gukebox)
-[![actions status](https://github.com/gudsfile/jukebox/actions/workflows/python.yml/badge.svg)](https://github.com/gudsfile/jukebox/actions)
+[![actions status](https://github.com/gudsfile/jukebox/actions/workflows/ci.yml/badge.svg)](https://github.com/gudsfile/jukebox/actions)
 
 ![rpi](https://img.shields.io/badge/-Zero%202W%20%7C%203%20%7C%205-C51A4A?logo=raspberry-pi&label=RPi&logoColor=C51A4A&labcolor=C51A4A)
 [![python versions](https://img.shields.io/pypi/pyversions/gukebox.svg?logo=python)](https://pypi.python.org/pypi/gukebox) [![uv](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/uv/main/assets/badge/v0.json)](https://github.com/astral-sh/uv)
@@ -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.dev2/jukebox/adapters/inbound/admin/api/backup_archive.py

@@ -0,0 +1,53 @@
+import io
+import zipfile
+
+LIBRARY_ENTRY = "library.json"
+SETTINGS_ENTRY = "settings.json"
+EXPECTED_ENTRIES = (LIBRARY_ENTRY, SETTINGS_ENTRY)
+# Both files are small JSON documents: refuse anything bigger before decompressing it.
+MAX_ENTRY_SIZE_BYTES = 10 * 1024 * 1024
+
+
+class InvalidBackupArchiveError(ValueError):
+    """Raised when an uploaded backup archive does not hold exactly the expected files."""
+
+
+def build_backup_archive(library: bytes, settings: bytes) -> bytes:
+    buffer = io.BytesIO()
+    with zipfile.ZipFile(buffer, "w", compression=zipfile.ZIP_DEFLATED) as archive:
+        archive.writestr(LIBRARY_ENTRY, library)
+        archive.writestr(SETTINGS_ENTRY, settings)
+    return buffer.getvalue()
+
+
+def read_backup_archive(content: bytes) -> tuple[bytes, bytes]:
+    """Return the library and settings files of a backup archive, as stored in it."""
+    try:
+        archive = zipfile.ZipFile(io.BytesIO(content))
+    except zipfile.BadZipFile as err:
+        raise InvalidBackupArchiveError("The file is not a zip archive.") from err
+
+    with archive:
+        names = archive.namelist()
+        missing = [name for name in EXPECTED_ENTRIES if name not in names]
+        extra = sorted({name for name in names if name not in EXPECTED_ENTRIES})
+        if missing or extra or len(names) != len(EXPECTED_ENTRIES):
+            problems = []
+            if missing:
+                problems.append(f"missing {', '.join(missing)}")
+            if extra:
+                problems.append(f"unexpected {', '.join(extra)}")
+            if not problems:
+                problems.append("duplicated entries")
+            raise InvalidBackupArchiveError(
+                f"The archive must hold exactly {LIBRARY_ENTRY} and {SETTINGS_ENTRY}: {'; '.join(problems)}."
+            )
+
+        for name in EXPECTED_ENTRIES:
+            if archive.getinfo(name).file_size > MAX_ENTRY_SIZE_BYTES:
+                raise InvalidBackupArchiveError(f"{name} is too large.")
+
+        try:
+            return archive.read(LIBRARY_ENTRY), archive.read(SETTINGS_ENTRY)
+        except (zipfile.BadZipFile, OSError) as err:
+            raise InvalidBackupArchiveError(f"The archive is corrupted: {err}") from err

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

@@ -0,0 +1,57 @@
+import json
+import os
+from collections.abc import Callable
+from datetime import date
+
+from fastapi import APIRouter, HTTPException
+from fastapi.responses import FileResponse, Response
+
+from jukebox.adapters.inbound.admin.api.backup_archive import build_backup_archive
+from jukebox.domain.entities import Library
+from jukebox.settings.migration import CURRENT_SETTINGS_SCHEMA_VERSION
+
+# A missing file is a normal state (settings never changed, no disc yet): the archive holds what the app reads then.
+DEFAULT_LIBRARY = json.dumps(Library().model_dump(), indent=2).encode()
+DEFAULT_SETTINGS = json.dumps({"schema_version": CURRENT_SETTINGS_SCHEMA_VERSION}, indent=2).encode()
+
+
+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 _read_file(path: str, default: bytes) -> bytes:
+    try:
+        with open(path, "rb") as file_obj:
+            return file_obj.read()
+    except FileNotFoundError:
+        return default
+
+
+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."
+        )
+
+    @router.get("/all", summary="Download the library and the persisted settings files as one zip archive")
+    def export_all() -> Response:
+        archive = build_backup_archive(
+            _read_file(library_path, DEFAULT_LIBRARY),
+            _read_file(settings_path, DEFAULT_SETTINGS),
+        )
+        filename = f"jukebox-backup-{today().isoformat()}.zip"
+        return Response(
+            archive, media_type="application/zip", headers={"Content-Disposition": f'attachment; filename="{filename}"'}
+        )
+
+    return router

gukebox-1.10.0.dev2/jukebox/adapters/inbound/admin/api/import_router.py

@@ -0,0 +1,200 @@
+import json
+import logging
+from typing import Any
+
+from fastapi import APIRouter, HTTPException, Request
+from pydantic import BaseModel, ConfigDict, ValidationError
+
+from jukebox.adapters.inbound.admin.api.backup_archive import (
+    LIBRARY_ENTRY,
+    SETTINGS_ENTRY,
+    InvalidBackupArchiveError,
+    read_backup_archive,
+)
+from jukebox.domain.entities import Disc, Library, LibraryImportSummary
+from jukebox.domain.repositories import LibraryRepository
+from jukebox.domain.use_cases import ImportLibrary, PreviewLibraryImport
+from jukebox.settings.errors import SettingsError
+from jukebox.settings.service_protocols import SettingsService
+from jukebox.settings.types import JsonObject, JsonValue
+
+LOGGER = logging.getLogger("jukebox")
+
+# The body is the uploaded file itself, read raw so that a file that is not JSON gets a clear 400.
+_FILE_BODY: dict[str, Any] = {
+    "requestBody": {"required": True, "content": {"application/json": {"schema": {"type": "object"}}}}
+}
+_ARCHIVE_BODY: dict[str, Any] = {
+    "requestBody": {
+        "required": True,
+        "content": {"application/zip": {"schema": {"type": "string", "format": "binary"}}},
+    }
+}
+
+
+class _LibraryFile(BaseModel):
+    """An uploaded library file: unlike a stored library, it must hold `discs` and nothing else.
+
+    This keeps a settings file, picked by mistake, from replacing the library with an empty one.
+    """
+
+    model_config = ConfigDict(strict=True, extra="forbid")
+    discs: dict[str, Disc]
+
+
+def _parse_json(content: bytes, source: str = "") -> JsonValue:
+    try:
+        return json.loads(content)
+    except (UnicodeDecodeError, json.JSONDecodeError) as err:
+        raise HTTPException(status_code=400, detail=f"{source}The file is not valid JSON: {err}")
+
+
+def _parse_library(content: bytes, source: str = "") -> Library:
+    try:
+        return Library(discs=_LibraryFile.model_validate(_parse_json(content, source)).discs)
+    except ValidationError as err:
+        raise HTTPException(status_code=400, detail=f"{source}Invalid library file: {err}")
+
+
+async def _read_library_file(request: Request) -> Library:
+    return _parse_library(await request.body())
+
+
+def build_import_router(
+    library_repository: LibraryRepository,
+    preview_library_import: PreviewLibraryImport,
+    import_library: ImportLibrary,
+    settings_service: SettingsService,
+) -> APIRouter:
+    router = APIRouter(prefix="/api/v1/import", tags=["import"])
+
+    @router.post(
+        "/library/preview",
+        response_model=LibraryImportSummary,
+        summary="Validate a library file and summarize what importing it would change",
+        openapi_extra=_FILE_BODY,
+    )
+    async def preview_library(request: Request) -> LibraryImportSummary:
+        library = await _read_library_file(request)
+        try:
+            return preview_library_import.execute(library)
+        except Exception as err:
+            raise HTTPException(status_code=500, detail=f"Server error: {err!s}")
+
+    @router.post(
+        "/library",
+        response_model=LibraryImportSummary,
+        summary="Replace the library with a library file",
+        openapi_extra=_FILE_BODY,
+    )
+    async def import_library_file(request: Request) -> LibraryImportSummary:
+        library = await _read_library_file(request)
+        try:
+            summary = preview_library_import.execute(library)
+            import_library.execute(library)
+            return summary
+        except Exception as err:
+            raise HTTPException(status_code=500, detail=f"Server error: {err!s}")
+
+    @router.post(
+        "/settings/preview",
+        response_model=dict[str, Any],
+        summary="Validate a settings file and list the settings importing it would change",
+        openapi_extra=_FILE_BODY,
+    )
+    async def preview_settings(request: Request) -> JsonObject:
+        raw_data = _parse_json(await request.body())
+        try:
+            return settings_service.preview_settings_import(raw_data)
+        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}")
+
+    @router.post(
+        "/settings",
+        response_model=dict[str, Any],
+        summary="Replace the persisted settings with a settings file",
+        openapi_extra=_FILE_BODY,
+    )
+    async def import_settings(request: Request) -> JsonObject:
+        raw_data = _parse_json(await request.body())
+        try:
+            return settings_service.import_persisted_settings(raw_data)
+        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}")
+
+    async def read_archive(request: Request) -> tuple[Library, JsonValue]:
+        try:
+            library_content, settings_content = read_backup_archive(await request.body())
+        except InvalidBackupArchiveError as err:
+            raise HTTPException(status_code=400, detail=str(err))
+        library = _parse_library(library_content, f"{LIBRARY_ENTRY}: ")
+        settings_data = _parse_json(settings_content, f"{SETTINGS_ENTRY}: ")
+        return library, settings_data
+
+    def preview_archive(library: Library, settings_data: JsonValue) -> JsonObject:
+        try:
+            settings_summary = settings_service.preview_settings_import(settings_data)
+        except SettingsError as err:
+            raise HTTPException(status_code=400, detail=f"{SETTINGS_ENTRY}: {err}")
+        return {
+            "library": preview_library_import.execute(library).model_dump(mode="json"),
+            "settings": settings_summary,
+        }
+
+    @router.post(
+        "/all/preview",
+        response_model=dict[str, Any],
+        summary="Validate a backup archive and summarize what importing it would change",
+        openapi_extra=_ARCHIVE_BODY,
+    )
+    async def preview_all(request: Request) -> JsonObject:
+        library, settings_data = await read_archive(request)
+        try:
+            return preview_archive(library, settings_data)
+        except HTTPException:
+            raise
+        except Exception as err:
+            raise HTTPException(status_code=500, detail=f"Server error: {err!s}")
+
+    @router.post(
+        "/all",
+        response_model=dict[str, Any],
+        summary="Replace the library and the persisted settings with a backup archive",
+        openapi_extra=_ARCHIVE_BODY,
+    )
+    async def import_all(request: Request) -> JsonObject:
+        library, settings_data = await read_archive(request)
+        try:
+            # Validate both files before writing any of them.
+            summary = preview_archive(library, settings_data)
+            # Write both files or none: keep the library file as is, even corrupted, to put it back.
+            previous_library = library_repository.snapshot()
+            import_library.execute(library)
+            try:
+                summary["settings"] = settings_service.import_persisted_settings(settings_data)
+            except Exception as err:
+                try:
+                    library_repository.restore(previous_library)
+                except Exception as rollback_err:
+                    LOGGER.exception("Could not put the previous library back")
+                    raise HTTPException(
+                        status_code=500,
+                        detail=(
+                            f"The library was replaced but the settings were not: {err!s}. "
+                            f"Putting the previous library back failed: {rollback_err!s}"
+                        ),
+                    )
+                raise
+            return summary
+        except HTTPException:
+            raise
+        except SettingsError as err:
+            raise HTTPException(status_code=400, detail=f"{SETTINGS_ENTRY}: {err}")
+        except Exception as err:
+            raise HTTPException(status_code=500, detail=f"Server error: {err!s}")
+
+    return router

{gukebox-1.9.1 → gukebox-1.10.0.dev2}/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.dev2/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.dev2/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