gukebox 1.0.0.dev4__tar.gz → 1.0.0.dev5__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: gukebox
-Version: 1.0.0.dev4
+Version: 1.0.0.dev5
 Summary: A Jukebox to play music on speakers using 'CD' with NFC tag
 Keywords: jukebox,discstore,music,nfc
 Author: Gudsfile

{gukebox-1.0.0.dev4 → gukebox-1.0.0.dev5}/discstore/adapters/inbound/api_controller.py

@@ -20,6 +20,8 @@ from discstore.domain.use_cases.remove_disc import RemoveDisc
 from jukebox.settings.errors import SettingsError
 from jukebox.settings.service_protocols import SettingsService
 from jukebox.settings.types import JsonObject
+from jukebox.sonos.discovery import DiscoveredSonosSpeaker, SonosDiscoveryError
+from jukebox.sonos.service import SonosService
 
 
 class DiscInput(Disc):
@@ -34,6 +36,10 @@ class CurrentTagStatusOutput(CurrentTagStatus):
     pass
 
 
+class SonosSpeakerOutput(DiscoveredSonosSpeaker):
+    pass
+
+
 class SettingsResetInput(BaseModel):
     path: str
 
@@ -51,6 +57,7 @@ class APIController:
         edit_disc: EditDisc,
         get_current_tag_status: GetCurrentTagStatus,
         settings_service: SettingsService,
+        sonos_service: SonosService,
     ):
         self.add_disc = add_disc
         self.list_discs = list_discs
@@ -58,6 +65,7 @@ class APIController:
         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",
@@ -83,6 +91,15 @@ class APIController:
 
             return CurrentTagStatusOutput(**current_tag_status.model_dump())
 
+        @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/settings")
         def get_settings():
             try:

{gukebox-1.0.0.dev4 → gukebox-1.0.0.dev5}/discstore/adapters/inbound/ui_controller.py

@@ -42,6 +42,7 @@ from jukebox.settings.definitions import (
 from jukebox.settings.errors import SettingsError
 from jukebox.settings.service_protocols import SettingsService
 from jukebox.settings.types import JsonObject
+from jukebox.sonos.service import SonosService
 
 _MISSING = object()
 
@@ -74,9 +75,18 @@ class UIController(APIController):
         get_disc: GetDisc,
         get_current_tag_status: GetCurrentTagStatus,
         settings_service: SettingsService,
+        sonos_service: SonosService,
     ):
         self.get_disc = get_disc
-        super().__init__(add_disc, list_discs, remove_disc, edit_disc, get_current_tag_status, settings_service)
+        super().__init__(
+            add_disc,
+            list_discs,
+            remove_disc,
+            edit_disc,
+            get_current_tag_status,
+            settings_service,
+            sonos_service,
+        )
 
     def register_routes(self):
         super().register_routes()

{gukebox-1.0.0.dev4 → gukebox-1.0.0.dev5}/discstore/app.py

@@ -10,10 +10,11 @@ from discstore.command_handlers import execute_library_command
 from discstore.commands import is_library_command
 from discstore.di_container import build_cli_controller, build_interactive_cli_controller
 from jukebox.admin.cli_presentation import render_cli_error
-from jukebox.admin.command_handlers import execute_admin_command
-from jukebox.admin.commands import is_admin_command
+from jukebox.admin.command_handlers import execute_server_command, execute_settings_command
+from jukebox.admin.commands import is_admin_command, is_settings_command
 from jukebox.admin.di_container import (
     build_admin_api_app,
+    build_admin_services,
     build_admin_ui_app,
 )
 from jukebox.admin.di_container import (
@@ -37,24 +38,36 @@ def main():
     config = parse_config()
     set_logger("discstore", config.verbose)
     try:
-        settings_service = _build_settings_service(config)
         if is_admin_command(config.command):
+            services = build_admin_services(
+                library=config.library,
+                command=config.command,
+                logger_warning=LOGGER.warning,
+            )
             try:
-                execute_admin_command(
-                    verbose=config.verbose,
-                    command=config.command,
-                    settings_service=settings_service,
-                    build_api_app=build_admin_api_app,
-                    build_ui_app=build_admin_ui_app,
-                    source_command="discstore",
-                    library=config.library,
-                )
+                if is_settings_command(config.command):
+                    execute_settings_command(
+                        command=config.command,
+                        settings_service=services.settings,
+                        source_command="discstore",
+                        library=config.library,
+                    )
+                else:
+                    execute_server_command(
+                        verbose=config.verbose,
+                        command=config.command,
+                        services=services,
+                        build_api_app=build_admin_api_app,
+                        build_ui_app=build_admin_ui_app,
+                        source_command="discstore",
+                    )
             except RuntimeError as err:
                 print(str(err), file=sys.stderr)
                 raise SystemExit(1) from err
             return
 
         if is_library_command(config.command):
+            settings_service = _build_settings_service(config)
             try:
                 execute_library_command(
                     verbose=config.verbose,

gukebox-1.0.0.dev5/jukebox/adapters/outbound/sonos_discovery_adapter.py

@@ -0,0 +1,199 @@
+from dataclasses import dataclass
+from typing import Any, Optional, Protocol
+
+from jukebox.sonos.discovery import (
+    DiscoveredSonosSpeaker,
+    SonosDiscoveryError,
+    SonosDiscoveryPort,
+    sort_sonos_speakers,
+)
+
+
+@dataclass(frozen=True)
+class _SonosDiscoverySnapshot:
+    speakers: list[DiscoveredSonosSpeaker]
+    retry_hosts_by_uid: dict[str, list[str]]
+    normalization_errors: list[str]
+
+
+class SoCoSonosDiscoveryAdapter(SonosDiscoveryPort):
+    def discover_speakers(self) -> list[DiscoveredSonosSpeaker]:
+        snapshot = self._discover_runtime_snapshot()
+        speakers_by_uid = {speaker.uid: speaker for speaker in snapshot.speakers}
+        for expected_uid, hosts in snapshot.retry_hosts_by_uid.items():
+            for host in hosts:
+                try:
+                    recovered = self._resolve_speaker_by_host(expected_uid, host)
+                except ValueError:
+                    continue
+
+                existing = speakers_by_uid.get(recovered.uid)
+                speakers_by_uid[recovered.uid] = self._choose_preferred(existing, recovered)
+                break
+
+        recovered_speakers = sort_sonos_speakers(list(speakers_by_uid.values()))
+        if not recovered_speakers and snapshot.normalization_errors:
+            raise SonosDiscoveryError(
+                "Discovered Sonos speakers but failed to inspect any reachable speakers: "
+                f"{snapshot.normalization_errors[0]}"
+            )
+        return recovered_speakers
+
+    def _discover_runtime_snapshot(self) -> _SonosDiscoverySnapshot:
+        import soco
+        from requests.exceptions import RequestException
+        from soco.exceptions import SoCoException
+        from urllib3.exceptions import HTTPError
+
+        try:
+            discovered = soco.discover()
+        except (HTTPError, OSError, RequestException, SoCoException) as err:
+            raise SonosDiscoveryError(f"Failed to discover Sonos speakers: {err}") from err
+
+        if not discovered:
+            return _SonosDiscoverySnapshot(
+                speakers=[],
+                retry_hosts_by_uid={},
+                normalization_errors=[],
+            )
+
+        available_speakers = set(discovered)
+        for speaker in list(discovered):
+            try:
+                available_speakers.update(speaker.all_zones)
+            except Exception:
+                available_speakers.add(speaker)
+
+        speakers_by_uid = {}
+        retry_hosts_by_uid = {}
+        normalization_errors = []
+        for speaker in available_speakers:
+            expected_uid = _safe_speaker_uid(speaker)
+            normalized, error = self._normalize_speaker(speaker)
+            if normalized is None:
+                if error is not None:
+                    normalization_errors.append(error)
+                if expected_uid is not None:
+                    host = _safe_speaker_host(speaker)
+                    if host is not None:
+                        retry_hosts_by_uid.setdefault(expected_uid, set()).add(host)
+                continue
+
+            existing = speakers_by_uid.get(normalized.uid)
+            speakers_by_uid[normalized.uid] = self._choose_preferred(existing, normalized)
+
+        return _SonosDiscoverySnapshot(
+            speakers=sort_sonos_speakers(list(speakers_by_uid.values())),
+            retry_hosts_by_uid={uid: sorted(hosts) for uid, hosts in sorted(retry_hosts_by_uid.items())},
+            normalization_errors=normalization_errors,
+        )
+
+    def _resolve_speaker_by_host(self, expected_uid: str, host: str) -> DiscoveredSonosSpeaker:
+        from requests.exceptions import RequestException
+        from soco import SoCo
+        from soco.exceptions import SoCoException, SoCoUPnPException
+        from urllib3.exceptions import HTTPError
+
+        try:
+            speaker = SoCo(host)
+            resolved_uid = speaker.uid
+        except (HTTPError, OSError, RequestException, RuntimeError, SoCoException, SoCoUPnPException) as err:
+            raise ValueError(f"Failed to contact saved Sonos speaker at {host}: {err}") from err
+
+        if resolved_uid != expected_uid:
+            raise ValueError(
+                f"Saved Sonos speaker UID mismatch for host {host}: expected {expected_uid}, resolved {resolved_uid}"
+            )
+
+        try:
+            return DiscoveredSonosSpeaker(
+                uid=speaker.uid,
+                name=speaker.player_name,
+                host=speaker.ip_address,
+                household_id=speaker.household_id,
+                is_visible=getattr(speaker, "is_visible", True) is not False,
+            )
+        except (HTTPError, OSError, RequestException, RuntimeError, SoCoException, SoCoUPnPException) as err:
+            raise ValueError(f"Failed to inspect discovered Sonos speaker at {host}: {err}") from err
+
+    @staticmethod
+    def _choose_preferred(
+        existing: Optional[DiscoveredSonosSpeaker],
+        candidate: DiscoveredSonosSpeaker,
+    ) -> DiscoveredSonosSpeaker:
+        if existing is None:
+            return candidate
+        if candidate.is_visible and not existing.is_visible:
+            return candidate
+        if existing.is_visible and not candidate.is_visible:
+            return existing
+        if (candidate.name, candidate.host, candidate.uid) < (existing.name, existing.host, existing.uid):
+            return candidate
+        return existing
+
+    @staticmethod
+    def _normalize_speaker(
+        speaker: "_SonosSpeakerLike",
+    ) -> tuple[Optional[DiscoveredSonosSpeaker], Optional[str]]:
+        from requests.exceptions import RequestException
+        from soco.exceptions import SoCoException, SoCoUPnPException
+        from urllib3.exceptions import HTTPError
+
+        try:
+            return (
+                DiscoveredSonosSpeaker(
+                    uid=speaker.uid,
+                    name=speaker.player_name,
+                    host=speaker.ip_address,
+                    household_id=speaker.household_id,
+                    is_visible=getattr(speaker, "is_visible", True) is not False,
+                ),
+                None,
+            )
+        except (HTTPError, OSError, RequestException, RuntimeError, SoCoException, SoCoUPnPException) as err:
+            return (
+                None,
+                "{}: {}".format(
+                    _safe_speaker_identifier(speaker),
+                    err,
+                ),
+            )
+
+
+class _SonosSpeakerLike(Protocol):
+    uid: str
+    player_name: str
+    ip_address: str
+    household_id: str
+    all_zones: set[Any]
+
+
+def _safe_speaker_identifier(speaker: "_SonosSpeakerLike") -> str:
+    ip_address = _safe_speaker_host(speaker)
+    if ip_address:
+        return ip_address
+
+    try:
+        uid = getattr(speaker, "uid")
+    except Exception:
+        return "unknown speaker"
+
+    return str(uid)
+
+
+def _safe_speaker_host(speaker: "_SonosSpeakerLike") -> Optional[str]:
+    try:
+        ip_address = getattr(speaker, "ip_address", None)
+    except Exception:
+        return None
+
+    if ip_address:
+        return str(ip_address)
+    return None
+
+
+def _safe_speaker_uid(speaker: "_SonosSpeakerLike") -> Optional[str]:
+    try:
+        return str(getattr(speaker, "uid"))
+    except Exception:
+        return None

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

@@ -22,9 +22,18 @@ from jukebox.shared.config_utils import get_package_version
 from jukebox.shared.logger import set_logger
 
 from .cli_presentation import render_cli_error
-from .command_handlers import execute_admin_command
-from .commands import ApiCommand, SettingsResetCommand, SettingsSetCommand, SettingsShowCommand, UiCommand
-from .di_container import build_admin_api_app, build_admin_ui_app, build_settings_service
+from .command_handlers import execute_server_command, execute_settings_command, execute_sonos_command
+from .commands import (
+    ApiCommand,
+    SettingsResetCommand,
+    SettingsSetCommand,
+    SettingsShowCommand,
+    SonosListCommand,
+    UiCommand,
+    is_settings_command,
+    is_sonos_command,
+)
+from .di_container import build_admin_api_app, build_admin_services, build_admin_ui_app, build_settings_service
 
 LOGGER = logging.getLogger("jukebox-admin")
 
@@ -52,20 +61,29 @@ def _run_command(ctx: typer.Context, command: object) -> None:
     state = _get_state(ctx)
 
     try:
-        settings_service = build_settings_service(
+        services = build_admin_services(
             library=state.library,
             command=command,
             logger_warning=LOGGER.warning,
         )
         try:
-            execute_admin_command(
-                verbose=state.verbose,
-                command=command,
-                settings_service=settings_service,
-                build_api_app=build_admin_api_app,
-                build_ui_app=build_admin_ui_app,
-                source_command="jukebox-admin",
-            )
+            if is_settings_command(command):
+                execute_settings_command(
+                    command=command,
+                    settings_service=services.settings,
+                    source_command="jukebox-admin",
+                )
+            elif is_sonos_command(command):
+                execute_sonos_command(command=command, sonos_service=services.sonos)
+            else:
+                execute_server_command(
+                    verbose=state.verbose,
+                    command=command,
+                    services=services,
+                    build_api_app=build_admin_api_app,
+                    build_ui_app=build_admin_ui_app,
+                    source_command="jukebox-admin",
+                )
         except RuntimeError as err:
             typer.echo(str(err), err=True)
             raise typer.Exit(code=1)
@@ -131,8 +149,10 @@ def _exit_on_command_validation_error(err: ValidationError) -> 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")
 app.add_typer(settings_app, name="settings")
 app.add_typer(library_app, name="library")
+app.add_typer(sonos_app, name="sonos")
 
 
 @app.callback()
@@ -238,6 +258,11 @@ def ui(
     _run_command(ctx, UiCommand(type="ui", port=port))
 
 
+@sonos_app.command("list")
+def sonos_list(ctx: typer.Context) -> None:
+    _run_command(ctx, SonosListCommand(type="sonos_list"))
+
+
 @library_app.command("add")
 def library_add(
     ctx: typer.Context,

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

@@ -1,7 +1,7 @@
 import json
 import re
 import shlex
-from typing import Dict, Iterable, List, Optional, Tuple, cast
+from typing import Dict, Iterable, List, Mapping, Optional, Tuple, cast
 
 from jukebox.settings.definitions import SETTINGS, get_setting_definition, is_editable_setting_path
 from jukebox.settings.errors import (
@@ -12,6 +12,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 .commands import SettingsResetCommand, SettingsSetCommand, SettingsShowCommand
 
@@ -21,19 +22,20 @@ _VALIDATION_SUFFIX_RE = re.compile(r"\s+\[type=.*$")
 
 def render_settings_output(
     command: object,
-    payload: JsonObject,
+    payload: Mapping[str, object],
 ) -> str:
     if isinstance(command, SettingsShowCommand):
         if command.json_output:
             return json.dumps(payload, indent=2)
+        settings_payload = cast(JsonObject, payload)
         if command.effective:
-            return _render_effective_settings(payload)
-        return _render_persisted_settings(payload)
+            return _render_effective_settings(settings_payload)
+        return _render_persisted_settings(settings_payload)
 
     if isinstance(command, (SettingsSetCommand, SettingsResetCommand)):
         if command.json_output:
             return json.dumps(payload, indent=2)
-        return _render_write_result(payload)
+        return _render_write_result(cast(JsonObject, payload))
 
     raise TypeError("Unsupported settings command")
 
@@ -52,6 +54,25 @@ def render_cli_error(err: BaseException, verbose: bool = False) -> str:
     return message
 
 
+def render_sonos_speakers_output(speakers: list[DiscoveredSonosSpeaker]) -> str:
+    if not speakers:
+        return "No visible Sonos speakers found."
+
+    name_width = max(len(speaker.name) for speaker in speakers)
+    host_width = max(len(speaker.host) for speaker in speakers)
+    return "\n".join(
+        "{index}. {name:<{name_width}}   {host:<{host_width}}   {uid}".format(
+            index=index,
+            name=speaker.name,
+            name_width=name_width,
+            host=speaker.host,
+            host_width=host_width,
+            uid=speaker.uid,
+        )
+        for index, speaker in enumerate(speakers, start=1)
+    )
+
+
 def _render_persisted_settings(payload: JsonObject) -> str:
     lines = ["Persisted Settings", "Schema Version: {}".format(payload.get("schema_version", "unknown"))]
     entries = list(_collect_persisted_entries(payload))

{gukebox-1.0.0.dev4 → gukebox-1.0.0.dev5}/jukebox/admin/command_handlers.py

@@ -4,9 +4,22 @@ from typing import Callable, Optional, Protocol
 
 from jukebox.settings.service_protocols import SettingsService
 from jukebox.shared.dependency_messages import optional_extra_dependency_message
-
-from .cli_presentation import build_discstore_settings_deprecation_warning, render_settings_output
-from .commands import ApiCommand, SettingsResetCommand, SettingsSetCommand, SettingsShowCommand, UiCommand
+from jukebox.sonos.service import SonosService
+
+from .cli_presentation import (
+    build_discstore_settings_deprecation_warning,
+    render_settings_output,
+    render_sonos_speakers_output,
+)
+from .commands import (
+    ApiCommand,
+    SettingsResetCommand,
+    SettingsSetCommand,
+    SettingsShowCommand,
+    SonosListCommand,
+    UiCommand,
+)
+from .services import AdminServices
 
 
 class AppController(Protocol):
@@ -33,27 +46,24 @@ def _load_uvicorn(command_name: str, extra_name: str, source_command: str):
 
 
 def _build_server_app(
-    build_app: Callable[[str, SettingsService], AppController],
+    build_app: Callable[[str, AdminServices], AppController],
     library_path: str,
-    settings_service: SettingsService,
+    services: AdminServices,
     command_name: str,
     extra_name: str,
     source_command: str,
 ):
     try:
-        return build_app(library_path, settings_service)
+        return build_app(library_path, services)
     except ModuleNotFoundError as err:
         if err.name in {"fastapi", "fastui"} or "requires the optional" in str(err):
             _raise_optional_extra_error(command_name, extra_name, source_command, err)
         raise
 
 
-def execute_admin_command(
-    verbose: bool,
+def execute_settings_command(
     command: object,
     settings_service: SettingsService,
-    build_api_app: Callable[[str, SettingsService], AppController],
-    build_ui_app: Callable[[str, SettingsService], AppController],
     source_command: str,
     library: Optional[str] = None,
     stdout_fn: Callable[[str], None] = print,
@@ -84,14 +94,37 @@ def execute_admin_command(
         stdout_fn(render_settings_output(command, payload))
         return
 
-    runtime_config = settings_service.resolve_admin_runtime(verbose=verbose)
+    raise TypeError("Unsupported settings command")
+
+
+def execute_sonos_command(
+    command: object,
+    sonos_service: SonosService,
+    stdout_fn: Callable[[str], None] = print,
+) -> None:
+    if isinstance(command, SonosListCommand):
+        stdout_fn(render_sonos_speakers_output(sonos_service.list_available_speakers()))
+        return
+
+    raise TypeError("Unsupported Sonos command")
+
+
+def execute_server_command(
+    verbose: bool,
+    command: object,
+    services: AdminServices,
+    build_api_app: Callable[[str, AdminServices], AppController],
+    build_ui_app: Callable[[str, AdminServices], AppController],
+    source_command: str,
+) -> None:
+    runtime_config = services.settings.resolve_admin_runtime(verbose=verbose)
 
     if isinstance(command, ApiCommand):
         uvicorn = _load_uvicorn("api", "api", source_command)
         api = _build_server_app(
             build_app=build_api_app,
             library_path=runtime_config.library_path,
-            settings_service=settings_service,
+            services=services,
             command_name="api",
             extra_name="api",
             source_command=source_command,
@@ -104,7 +137,7 @@ def execute_admin_command(
         ui = _build_server_app(
             build_app=build_ui_app,
             library_path=runtime_config.library_path,
-            settings_service=settings_service,
+            services=services,
             command_name="ui",
             extra_name="ui",
             source_command=source_command,
@@ -112,4 +145,4 @@ def execute_admin_command(
         uvicorn.run(ui.app, host="0.0.0.0", port=runtime_config.ui_port)
         return
 
-    raise TypeError("Unsupported admin command")
+    raise TypeError("Unsupported server command")

{gukebox-1.0.0.dev4 → gukebox-1.0.0.dev5}/jukebox/admin/commands.py

@@ -18,6 +18,10 @@ class UiCommand(BaseModel):
     port: Optional[int] = None
 
 
+class SonosListCommand(BaseModel):
+    type: Literal["sonos_list"]
+
+
 class SettingsShowCommand(BaseModel):
     type: Literal["settings_show"]
     effective: bool = False
@@ -42,6 +46,7 @@ AdminCommand = Union[
     SettingsResetCommand,
     SettingsSetCommand,
     SettingsShowCommand,
+    SonosListCommand,
     UiCommand,
 ]
 
@@ -54,6 +59,7 @@ def is_admin_command(command: object) -> bool:
             SettingsResetCommand,
             SettingsSetCommand,
             SettingsShowCommand,
+            SonosListCommand,
             UiCommand,
         ),
     )
@@ -68,3 +74,7 @@ def is_settings_command(command: object) -> bool:
             SettingsShowCommand,
         ),
     )
+
+
+def is_sonos_command(command: object) -> bool:
+    return isinstance(command, SonosListCommand)