gukebox 1.0.0.dev5__tar.gz → 1.0.0.dev6__tar.gz

{gukebox-1.0.0.dev5 → gukebox-1.0.0.dev6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: gukebox
-Version: 1.0.0.dev5
+Version: 1.0.0.dev6
 Summary: A Jukebox to play music on speakers using 'CD' with NFC tag
 Keywords: jukebox,discstore,music,nfc
 Author: Gudsfile
@@ -35,6 +35,7 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Requires-Dist: pydantic==2.12.5
+Requires-Dist: questionary==2.1.1
 Requires-Dist: soco==0.30.14
 Requires-Dist: typer==0.23.2 ; python_full_version < '3.10'
 Requires-Dist: typer==0.24.1 ; python_full_version >= '3.10'
@@ -42,16 +43,16 @@ Requires-Dist: fastapi==0.128.7 ; python_full_version < '3.10' and extra == 'api
 Requires-Dist: fastapi==0.135.1 ; python_full_version >= '3.10' and extra == 'api'
 Requires-Dist: uvicorn==0.39.0 ; python_full_version < '3.10' and extra == 'api'
 Requires-Dist: uvicorn==0.41.0 ; python_full_version >= '3.10' and extra == 'api'
-Requires-Dist: pyserial==3.5 ; extra == 'nfc'
-Requires-Dist: spidev==3.8 ; extra == 'nfc'
-Requires-Dist: lgpio==0.2.2.0 ; python_full_version < '3.13' and extra == 'nfc'
+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 ; python_full_version >= '3.10' and extra == 'ui'
 Requires-Dist: python-multipart==0.0.22 ; python_full_version >= '3.10' and extra == 'ui'
 Requires-Python: >=3.9, <3.14
 Project-URL: Repository, https://github.com/Gudsfile/jukebox
 Provides-Extra: api
-Provides-Extra: nfc
+Provides-Extra: pn532
 Provides-Extra: ui
 Description-Content-Type: text/markdown
 
@@ -106,7 +107,7 @@ Install the package from [PyPI](https://pypi.org/project/gukebox/).
 > The package name is `gukebox` with `g` instead of a `j` (due to a name already taken).
 
 > [!NOTE]
-> The `nfc` extra is optional but required for NFC reading, [check compatibility](#readers).
+> The `pn532` extra is optional but required for NFC reading, [check compatibility](#readers).
 
 ### Recommended installation
 
@@ -131,7 +132,7 @@ source jukebox/bin/activate
 
 3. Install `gukebox` into the virtual environment:
 ```shell
-pip install "gukebox[nfc]"
+pip install "gukebox[pn532]"
 ```
 
 > [!IMPORTANT]
@@ -218,7 +219,7 @@ Start the jukebox with the `jukebox` command (show help message with `--help`)
 jukebox PLAYER_TO_USE READER_TO_USE
 ```
 
-🎉 With choosing the `sonos` player and `nfc` reader, by approaching a NFC tag stored in the `library.json` file, you should hear the associated music begins.
+🎉 With choosing the `sonos` player and `pn532` reader, by approaching a NFC tag stored in the `library.json` file, you should hear the associated music begins.
 
 Optional Parameters
 
@@ -241,7 +242,7 @@ Expected syntax: `tag_id` or `tag_id duration_seconds`.
 - duration_seconds: a non-negative number of seconds used to simulate how long the tag remains in place. Fractional values are allowed.
 Complete example: `your:tag:uid 2.5`
 
-**NFC** (`nfc`)
+**NFC Pn532** (`pn532`)
 Read an NFC tag and get its UID.
 This project works with an NFC reader like the **PN532** and NFC tags like the **NTAG2xx**.
 It is configured according to the [Waveshare PN532 wiki](https://www.waveshare.com/wiki/PN532_NFC_HAT).

{gukebox-1.0.0.dev5 → gukebox-1.0.0.dev6}/README.md

@@ -49,7 +49,7 @@ Install the package from [PyPI](https://pypi.org/project/gukebox/).
 > The package name is `gukebox` with `g` instead of a `j` (due to a name already taken).
 
 > [!NOTE]
-> The `nfc` extra is optional but required for NFC reading, [check compatibility](#readers).
+> The `pn532` extra is optional but required for NFC reading, [check compatibility](#readers).
 
 ### Recommended installation
 
@@ -74,7 +74,7 @@ source jukebox/bin/activate
 
 3. Install `gukebox` into the virtual environment:
 ```shell
-pip install "gukebox[nfc]"
+pip install "gukebox[pn532]"
 ```
 
 > [!IMPORTANT]
@@ -161,7 +161,7 @@ Start the jukebox with the `jukebox` command (show help message with `--help`)
 jukebox PLAYER_TO_USE READER_TO_USE
 ```
 
-🎉 With choosing the `sonos` player and `nfc` reader, by approaching a NFC tag stored in the `library.json` file, you should hear the associated music begins.
+🎉 With choosing the `sonos` player and `pn532` reader, by approaching a NFC tag stored in the `library.json` file, you should hear the associated music begins.
 
 Optional Parameters
 
@@ -184,7 +184,7 @@ Expected syntax: `tag_id` or `tag_id duration_seconds`.
 - duration_seconds: a non-negative number of seconds used to simulate how long the tag remains in place. Fractional values are allowed.
 Complete example: `your:tag:uid 2.5`
 
-**NFC** (`nfc`)
+**NFC Pn532** (`pn532`)
 Read an NFC tag and get its UID.
 This project works with an NFC reader like the **PN532** and NFC tags like the **NTAG2xx**.
 It is configured according to the [Waveshare PN532 wiki](https://www.waveshare.com/wiki/PN532_NFC_HAT).

gukebox-1.0.0.dev6/discstore/adapters/inbound/api/current_tag_router.py

@@ -0,0 +1,25 @@
+from typing import Any
+
+from fastapi import APIRouter, Response
+
+from discstore.adapters.inbound.api.models import CurrentTagStatusOutput
+from discstore.domain.use_cases.get_current_tag_status import GetCurrentTagStatus
+
+
+def build_current_tag_router(get_current_tag_status: GetCurrentTagStatus) -> APIRouter:
+    router = APIRouter(prefix="/api/v1", tags=["current-tag"])
+
+    @router.get(
+        "/current-tag",
+        response_model=CurrentTagStatusOutput,
+        responses={204: {"description": "No current tag"}},
+        summary="Get the current NFC tag status",
+    )
+    def get_current_tag() -> Any:
+        current_tag_status = get_current_tag_status.execute()
+        if current_tag_status is None:
+            return Response(status_code=204)
+
+        return CurrentTagStatusOutput(**current_tag_status.model_dump())
+
+    return router

gukebox-1.0.0.dev6/discstore/adapters/inbound/api/discs_router.py

@@ -0,0 +1,48 @@
+from typing import Dict
+
+from fastapi import APIRouter, HTTPException
+
+from discstore.adapters.inbound.api.models import DiscInput, DiscOutput
+from discstore.domain.entities import Disc
+from discstore.domain.use_cases.add_disc import AddDisc
+from discstore.domain.use_cases.edit_disc import EditDisc
+from discstore.domain.use_cases.list_discs import ListDiscs
+from discstore.domain.use_cases.remove_disc import RemoveDisc
+
+
+def build_discs_router(
+    add_disc: AddDisc,
+    list_discs: ListDiscs,
+    remove_disc: RemoveDisc,
+    edit_disc: EditDisc,
+) -> APIRouter:
+    router = APIRouter(prefix="/api/v1", tags=["discs"])
+
+    @router.get("/discs", response_model=Dict[str, DiscOutput], summary="List discs")
+    def list_discs_route() -> Dict[str, Disc]:
+        return list_discs.execute()
+
+    @router.post("/disc", status_code=201, summary="Create or update a disc")
+    def add_or_edit_disc(tag_id: str, disc: DiscInput) -> Dict[str, str]:
+        try:
+            self_disc = Disc(**disc.model_dump())
+            add_disc.execute(tag_id, self_disc)
+            return {"message": "Disc added"}
+        except ValueError:
+            new_disc = Disc(**disc.model_dump())
+            edit_disc.execute(tag_id, new_disc.uri, new_disc.metadata, new_disc.option)
+            return {"message": "Disc edited"}
+        except Exception as err:
+            raise HTTPException(status_code=500, detail=f"Server error: {str(err)}")
+
+    @router.delete("/disc", status_code=200, summary="Delete a disc")
+    def remove_disc_route(tag_id: str) -> Dict[str, str]:
+        try:
+            remove_disc.execute(tag_id)
+            return {"message": "Disc removed"}
+        except ValueError as value_err:
+            raise HTTPException(status_code=404, detail=str(value_err))
+        except Exception as err:
+            raise HTTPException(status_code=500, detail=f"Server error: {str(err)}")
+
+    return router

gukebox-1.0.0.dev6/discstore/adapters/inbound/api/models.py

@@ -0,0 +1,25 @@
+from typing import Any, Dict
+
+from pydantic import BaseModel, RootModel
+
+from discstore.domain.entities import CurrentTagStatus, Disc
+
+
+class DiscInput(Disc):
+    pass
+
+
+class DiscOutput(Disc):
+    pass
+
+
+class CurrentTagStatusOutput(CurrentTagStatus):
+    pass
+
+
+class SettingsResetInput(BaseModel):
+    path: str
+
+
+class SettingsPatchInput(RootModel[Dict[str, Any]]):
+    pass

gukebox-1.0.0.dev6/discstore/adapters/inbound/api/settings_router.py

@@ -0,0 +1,46 @@
+from typing import Any, Dict, cast
+
+from fastapi import APIRouter, HTTPException
+
+from discstore.adapters.inbound.api.models import SettingsPatchInput, SettingsResetInput
+from jukebox.settings.errors import SettingsError
+from jukebox.settings.service_protocols import SettingsService
+from jukebox.settings.types import JsonObject
+
+
+def build_settings_router(settings_service: SettingsService) -> APIRouter:
+    router = APIRouter(prefix="/api/v1", tags=["settings"])
+
+    @router.get("/settings", response_model=Dict[str, Any], summary="Get persisted settings")
+    def get_settings() -> JsonObject:
+        try:
+            return settings_service.get_persisted_settings_view()
+        except Exception as err:
+            raise HTTPException(status_code=500, detail=f"Server error: {str(err)}")
+
+    @router.get("/settings/effective", response_model=Dict[str, Any], summary="Get effective settings")
+    def get_effective_settings() -> JsonObject:
+        try:
+            return settings_service.get_effective_settings_view()
+        except Exception as err:
+            raise HTTPException(status_code=500, detail=f"Server error: {str(err)}")
+
+    @router.patch("/settings", response_model=Dict[str, Any], summary="Patch persisted settings")
+    def patch_settings(patch: SettingsPatchInput) -> JsonObject:
+        try:
+            return settings_service.patch_persisted_settings(cast(JsonObject, patch.root))
+        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: {str(err)}")
+
+    @router.post("/settings/reset", response_model=Dict[str, Any], summary="Reset a persisted setting")
+    def reset_settings(payload: SettingsResetInput) -> JsonObject:
+        try:
+            return settings_service.reset_persisted_value(payload.path)
+        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: {str(err)}")
+
+    return router

gukebox-1.0.0.dev6/discstore/adapters/inbound/api_controller.py

@@ -0,0 +1,166 @@
+from typing import Optional
+
+from pydantic import BaseModel
+
+from jukebox.shared.dependency_messages import optional_extra_dependency_message
+
+try:
+    from fastapi import FastAPI, HTTPException
+
+    from discstore.adapters.inbound.api.current_tag_router import build_current_tag_router
+    from discstore.adapters.inbound.api.discs_router import build_discs_router
+    from discstore.adapters.inbound.api.models import (
+        CurrentTagStatusOutput,
+        DiscInput,
+        DiscOutput,
+        SettingsPatchInput,
+        SettingsResetInput,
+    )
+    from discstore.adapters.inbound.api.settings_router import build_settings_router
+except ModuleNotFoundError as e:
+    if e.name != "fastapi":
+        raise
+    raise ModuleNotFoundError(
+        optional_extra_dependency_message("The `api_controller` module", "api", "discstore api")
+    ) from e
+from discstore.domain.use_cases.add_disc import AddDisc
+from discstore.domain.use_cases.edit_disc import EditDisc
+from discstore.domain.use_cases.get_current_tag_status import GetCurrentTagStatus
+from discstore.domain.use_cases.list_discs import ListDiscs
+from discstore.domain.use_cases.remove_disc import RemoveDisc
+from jukebox.settings.entities import SelectedSonosGroupSettings
+from jukebox.settings.selected_sonos_group_repository import SettingsSelectedSonosGroupRepository
+from jukebox.settings.service_protocols import SettingsService
+from jukebox.sonos.discovery import DiscoveredSonosSpeaker, SonosDiscoveryError
+from jukebox.sonos.selection import GetSonosSelectionStatus, PlanSonosSelection, SaveSonosSelection
+from jukebox.sonos.service import SonosService
+
+__all__ = [
+    "APIController",
+    "CurrentTagStatusOutput",
+    "DiscInput",
+    "DiscOutput",
+    "SettingsPatchInput",
+    "SettingsResetInput",
+    "SonosSelectionInput",
+]
+
+
+class SonosSpeakerOutput(DiscoveredSonosSpeaker):
+    pass
+
+
+class SelectedSonosGroupOutput(SelectedSonosGroupSettings):
+    pass
+
+
+class SonosSelectionAvailabilityOutput(BaseModel):
+    status: str
+    speaker: Optional[SonosSpeakerOutput] = None
+
+
+class SonosSelectionOutput(BaseModel):
+    selected_group: Optional[SelectedSonosGroupOutput] = None
+    availability: SonosSelectionAvailabilityOutput
+
+
+class SonosSelectionInput(BaseModel):
+    uids: list[str]
+
+
+class SonosSelectionUpdateOutput(BaseModel):
+    selected_group: SelectedSonosGroupOutput
+    availability: SonosSelectionAvailabilityOutput
+    message: str
+    restart_required: bool
+
+
+class APIController:
+    def __init__(
+        self,
+        add_disc: AddDisc,
+        list_discs: ListDiscs,
+        remove_disc: RemoveDisc,
+        edit_disc: EditDisc,
+        get_current_tag_status: GetCurrentTagStatus,
+        settings_service: SettingsService,
+        sonos_service: SonosService,
+    ):
+        self.add_disc = add_disc
+        self.list_discs = list_discs
+        self.remove_disc = remove_disc
+        self.edit_disc = edit_disc
+        self.get_current_tag_status = get_current_tag_status
+        self.settings_service = settings_service
+        self.sonos_service = sonos_service
+        self.app = FastAPI(
+            title="DiscStore API",
+            description="API for managing Jukebox disc library",
+            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,
+            )
+        )
+        self.app.include_router(build_current_tag_router(self.get_current_tag_status))
+        self.app.include_router(build_settings_router(self.settings_service))
+
+        @self.app.get("/api/v1/sonos/speakers", response_model=list[SonosSpeakerOutput])
+        def get_sonos_speakers():
+            try:
+                return self.sonos_service.list_available_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: {str(err)}")
+
+        @self.app.get("/api/v1/sonos/selection", response_model=SonosSelectionOutput)
+        def get_sonos_selection():
+            try:
+                return GetSonosSelectionStatus(
+                    SettingsSelectedSonosGroupRepository(self.settings_service),
+                    self.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: {str(err)}")
+
+        @self.app.put("/api/v1/sonos/selection", response_model=SonosSelectionUpdateOutput)
+        def put_sonos_selection(payload: SonosSelectionInput):
+            try:
+                plan = PlanSonosSelection(self.sonos_service).execute(requested_uids=payload.uids)
+                if plan.status in {"invalid_request", "none_available"}:
+                    raise HTTPException(status_code=400, detail=str(plan.error_message))
+                if plan.status == "needs_choice" or plan.selected_uid is None:
+                    raise HTTPException(status_code=400, detail="No Sonos speaker selection was made.")
+
+                result = SaveSonosSelection(
+                    SettingsSelectedSonosGroupRepository(self.settings_service),
+                    self.sonos_service,
+                ).execute(plan.selected_uid)
+                return SonosSelectionUpdateOutput(
+                    selected_group=SelectedSonosGroupOutput(**result.selected_group.model_dump()),
+                    availability=SonosSelectionAvailabilityOutput(
+                        status="available",
+                        speaker=SonosSpeakerOutput(**result.speaker.model_dump()),
+                    ),
+                    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 HTTPException:
+                raise
+            except Exception as err:
+                raise HTTPException(status_code=500, detail=f"Server error: {str(err)}")

{gukebox-1.0.0.dev5 → gukebox-1.0.0.dev6}/jukebox/adapters/inbound/config.py

@@ -16,7 +16,7 @@ class JukeboxCliConfig(BaseModel):
     library: Optional[str] = None
     verbose: bool = False
     player: Optional[Literal["dryrun", "sonos"]] = None
-    reader: Optional[Literal["dryrun", "nfc"]] = None
+    reader: Optional[Literal["dryrun", "pn532"]] = None
     sonos_host: Optional[str] = None
     sonos_name: Optional[str] = None
     pause_duration_seconds: Optional[int] = None
@@ -40,7 +40,7 @@ def parse_config() -> JukeboxCliConfig:
     add_version_arg(parser)
 
     parser.add_argument("positional_player", nargs="?", choices=["dryrun", "sonos"], help="override the player type")
-    parser.add_argument("positional_reader", nargs="?", choices=["dryrun", "nfc"], help="override the reader type")
+    parser.add_argument("positional_reader", nargs="?", choices=["dryrun", "pn532"], help="override the reader type")
 
     parser.add_argument(
         "--player",
@@ -50,7 +50,7 @@ def parse_config() -> JukeboxCliConfig:
     )
     parser.add_argument(
         "--reader",
-        choices=["dryrun", "nfc"],
+        choices=["dryrun", "pn532"],
         default=None,
         help="override the reader type without providing both positional type arguments",
     )

gukebox-1.0.0.dev5/jukebox/adapters/outbound/readers/nfc_reader_adapter.py → gukebox-1.0.0.dev6/jukebox/adapters/outbound/readers/pn532_reader_adapter.py

@@ -9,7 +9,7 @@ from jukebox.shared.dependency_messages import optional_extra_dependency_message
 try:
     from pn532 import PN532_SPI
 except ModuleNotFoundError as err:
-    raise ModuleNotFoundError(optional_extra_dependency_message("The `nfc` reader", "nfc", "jukebox ...")) from err
+    raise ModuleNotFoundError(optional_extra_dependency_message("The `pn532` reader", "pn532", "jukebox ...")) from err
 
 from jukebox.domain.ports import ReaderPort
 from jukebox.shared.timing import DEFAULT_NFC_READ_TIMEOUT_SECONDS
@@ -25,13 +25,13 @@ def spi_active():
     return any(dev.startswith("spidev") for dev in os.listdir("/dev"))
 
 
-class NfcReaderAdapter(ReaderPort):
-    """Adapter for NFC reader implementing ReaderPort."""
+class Pn532ReaderAdapter(ReaderPort):
+    """Adapter for Pn532 NFC reader implementing ReaderPort."""
 
     def __init__(self, read_timeout_seconds: float = DEFAULT_NFC_READ_TIMEOUT_SECONDS):
         if not spi_active():
             error_message = (
-                "The SPI interface is not enabled. Please enable it to use the NFC reader."
+                "The SPI interface is not enabled. Please enable it to use the PN532 NFC reader."
                 "You can enable SPI using `sudo raspi-config` then navigate to: Interface Options > SPI > Enable > Yes."
             )
             LOGGER.error(error_message)

{gukebox-1.0.0.dev5 → gukebox-1.0.0.dev6}/jukebox/admin/app.py

@@ -20,8 +20,9 @@ from discstore.di_container import build_cli_controller, build_interactive_cli_c
 from jukebox.settings.errors import SettingsError
 from jukebox.shared.config_utils import get_package_version
 from jukebox.shared.logger import set_logger
+from jukebox.sonos.discovery import DiscoveredSonosSpeaker
 
-from .cli_presentation import render_cli_error
+from .cli_presentation import build_sonos_speaker_choice_label, render_cli_error
 from .command_handlers import execute_server_command, execute_settings_command, execute_sonos_command
 from .commands import (
     ApiCommand,
@@ -29,6 +30,8 @@ from .commands import (
     SettingsSetCommand,
     SettingsShowCommand,
     SonosListCommand,
+    SonosSelectCommand,
+    SonosShowCommand,
     UiCommand,
     is_settings_command,
     is_sonos_command,
@@ -74,7 +77,12 @@ def _run_command(ctx: typer.Context, command: object) -> None:
                     source_command="jukebox-admin",
                 )
             elif is_sonos_command(command):
-                execute_sonos_command(command=command, sonos_service=services.sonos)
+                execute_sonos_command(
+                    command=command,
+                    sonos_service=services.sonos,
+                    settings_service=services.settings,
+                    speaker_prompt_fn=_prompt_for_sonos_speaker_selection,
+                )
             else:
                 execute_server_command(
                     verbose=state.verbose,
@@ -146,10 +154,28 @@ def _exit_on_command_validation_error(err: ValidationError) -> None:
     raise SystemExit(str(err)) from err
 
 
+def _prompt_for_sonos_speaker_selection(speakers: list[DiscoveredSonosSpeaker]) -> Optional[str]:
+    import questionary
+
+    try:
+        return questionary.select(
+            "Select a Sonos speaker",
+            choices=[
+                questionary.Choice(
+                    title=build_sonos_speaker_choice_label(speaker),
+                    value=speaker.uid,
+                )
+                for speaker in speakers
+            ],
+        ).ask()
+    except KeyboardInterrupt:
+        return None
+
+
 app = typer.Typer(help="Admin CLI for jukebox")
 settings_app = typer.Typer(help="Inspect and manage application settings")
 library_app = typer.Typer(help="Manage the library")
-sonos_app = typer.Typer(help="Inspect Sonos speakers discovered on the network")
+sonos_app = typer.Typer(help="Inspect Sonos speakers and manage the saved Sonos selection")
 app.add_typer(settings_app, name="settings")
 app.add_typer(library_app, name="library")
 app.add_typer(sonos_app, name="sonos")
@@ -263,6 +289,22 @@ def sonos_list(ctx: typer.Context) -> None:
     _run_command(ctx, SonosListCommand(type="sonos_list"))
 
 
+@sonos_app.command("select")
+def sonos_select(
+    ctx: typer.Context,
+    uids: Annotated[
+        Optional[list[str]],
+        typer.Option("--uids", help="discover and persist exactly one Sonos speaker UID"),
+    ] = None,
+) -> None:
+    _run_command(ctx, SonosSelectCommand(type="sonos_select", uids=uids))
+
+
+@sonos_app.command("show")
+def sonos_show(ctx: typer.Context) -> None:
+    _run_command(ctx, SonosShowCommand(type="sonos_show"))
+
+
 @library_app.command("add")
 def library_add(
     ctx: typer.Context,

{gukebox-1.0.0.dev5 → gukebox-1.0.0.dev6}/jukebox/admin/cli_presentation.py

@@ -13,6 +13,7 @@ from jukebox.settings.errors import (
 from jukebox.settings.types import JsonObject, JsonValue
 from jukebox.settings.view_utils import MISSING, lookup_object, lookup_optional_dotted_path, lookup_provenance_label
 from jukebox.sonos.discovery import DiscoveredSonosSpeaker
+from jukebox.sonos.selection import SonosSelectionResult, SonosSelectionStatus
 
 from .commands import SettingsResetCommand, SettingsSetCommand, SettingsShowCommand
 
@@ -73,6 +74,39 @@ def render_sonos_speakers_output(speakers: list[DiscoveredSonosSpeaker]) -> str:
     )
 
 
+def build_sonos_speaker_choice_label(speaker: DiscoveredSonosSpeaker) -> str:
+    return "{} ({})".format(speaker.name, speaker.host)
+
+
+def render_sonos_selection_saved_output(result: SonosSelectionResult) -> str:
+    return "\n".join(
+        [
+            "Selected Sonos speaker: {}".format(result.speaker.name),
+            "UID: {}".format(result.speaker.uid),
+            result.settings_message,
+        ]
+    )
+
+
+def render_sonos_selection_status_output(status: SonosSelectionStatus) -> str:
+    lines = ["Selected Sonos Speaker", ""]
+
+    if status.selected_group is None:
+        lines.append("- Status: not selected")
+        return "\n".join(lines)
+
+    lines.append("- UID: {}".format(status.selected_group.coordinator_uid))
+    lines.append("- Status: {}".format(status.availability.status))
+
+    speaker = status.availability.speaker
+    if speaker is not None:
+        lines.append("- Name: {}".format(speaker.name))
+        lines.append("- Host: {}".format(speaker.host))
+        lines.append("- Household: {}".format(speaker.household_id))
+
+    return "\n".join(lines)
+
+
 def _render_persisted_settings(payload: JsonObject) -> str:
     lines = ["Persisted Settings", "Schema Version: {}".format(payload.get("schema_version", "unknown"))]
     entries = list(_collect_persisted_entries(payload))