gukebox 1.0.0.dev6__tar.gz → 1.0.0.dev7__tar.gz

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

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

gukebox-1.0.0.dev7/discstore/adapters/inbound/api/__init__.py

@@ -0,0 +1,25 @@
+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 (
+    CurrentTagDiscOutput,
+    CurrentTagStatusOutput,
+    DiscInput,
+    DiscOutput,
+    DiscPatchInput,
+    SettingsPatchInput,
+    SettingsResetInput,
+)
+from discstore.adapters.inbound.api.settings_router import build_settings_router
+
+__all__ = [
+    "CurrentTagDiscOutput",
+    "CurrentTagStatusOutput",
+    "DiscInput",
+    "DiscOutput",
+    "DiscPatchInput",
+    "SettingsPatchInput",
+    "SettingsResetInput",
+    "build_current_tag_router",
+    "build_discs_router",
+    "build_settings_router",
+]

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

@@ -0,0 +1,161 @@
+from typing import Any, Optional
+
+from fastapi import APIRouter, HTTPException, Response, status
+
+from discstore.adapters.inbound.api.models import (
+    CurrentTagDiscOutput,
+    CurrentTagStatusOutput,
+    DiscInput,
+    DiscOutput,
+    DiscPatchInput,
+)
+from discstore.domain.entities import CurrentTagStatus, Disc, DiscMetadata, DiscOption
+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.get_disc import GetDisc
+from discstore.domain.use_cases.remove_disc import RemoveDisc
+
+
+def build_current_tag_router(
+    get_current_tag_status: GetCurrentTagStatus,
+    add_disc: AddDisc,
+    edit_disc: EditDisc,
+    get_disc: GetDisc,
+    remove_disc: RemoveDisc,
+) -> APIRouter:
+    router = APIRouter(prefix="/api/v1", tags=["current-tag"])
+
+    def read_current_tag_status() -> Optional[CurrentTagStatus]:
+        return get_current_tag_status.execute()
+
+    def ensure_expected_tag_id_matches(
+        expected_tag_id: Optional[str], current_tag_status: Optional[CurrentTagStatus]
+    ) -> None:
+        if expected_tag_id is None:
+            return
+
+        actual_tag_id = None if current_tag_status is None else current_tag_status.tag_id
+        if actual_tag_id != expected_tag_id:
+            raise HTTPException(
+                status_code=409,
+                detail=f"Current tag changed: expected_tag_id='{expected_tag_id}', actual_tag_id={repr(actual_tag_id)}",
+            )
+
+    def build_current_tag_disc_output(tag_id: str, disc: Disc) -> CurrentTagDiscOutput:
+        return CurrentTagDiscOutput(tag_id=tag_id, disc=DiscOutput(**disc.model_dump()))
+
+    @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 = read_current_tag_status()
+        if current_tag_status is None:
+            return Response(status_code=204)
+
+        return CurrentTagStatusOutput(**current_tag_status.model_dump())
+
+    @router.get(
+        "/current-tag/disc",
+        response_model=CurrentTagDiscOutput,
+        responses={204: {"description": "No current tag"}, 404: {"description": "Current tag disc not found"}},
+        summary="Get the current tag disc",
+    )
+    def get_current_tag_disc() -> Any:
+        current_tag_status = read_current_tag_status()
+        if current_tag_status is None:
+            return Response(status_code=204)
+
+        if not current_tag_status.known_in_library:
+            raise HTTPException(status_code=404, detail=f"Tag does not exist: tag_id='{current_tag_status.tag_id}'")
+
+        return build_current_tag_disc_output(current_tag_status.tag_id, get_disc.execute(current_tag_status.tag_id))
+
+    @router.post(
+        "/current-tag/disc",
+        response_model=CurrentTagDiscOutput,
+        status_code=201,
+        responses={204: {"description": "No current tag"}, 409: {"description": "Current tag changed or disc exists"}},
+        summary="Create a disc for the current tag",
+    )
+    def create_current_tag_disc(
+        disc: DiscInput,
+        expected_tag_id: Optional[str] = None,
+    ) -> Any:
+        current_tag_status = read_current_tag_status()
+        ensure_expected_tag_id_matches(expected_tag_id, current_tag_status)
+        if current_tag_status is None:
+            return Response(status_code=204)
+
+        try:
+            new_disc = Disc(**disc.model_dump())
+            add_disc.execute(current_tag_status.tag_id, new_disc)
+            return build_current_tag_disc_output(current_tag_status.tag_id, new_disc)
+        except ValueError as value_err:
+            raise HTTPException(status_code=409, detail=str(value_err))
+        except Exception as err:
+            raise HTTPException(status_code=500, detail=f"Server error: {str(err)}")
+
+    @router.patch(
+        "/current-tag/disc",
+        response_model=CurrentTagDiscOutput,
+        responses={
+            204: {"description": "No current tag"},
+            404: {"description": "Current tag disc not found"},
+            409: {"description": "Current tag changed"},
+        },
+        summary="Update the current tag disc",
+    )
+    def update_current_tag_disc(
+        disc_patch: DiscPatchInput,
+        expected_tag_id: Optional[str] = None,
+    ) -> Any:
+        current_tag_status = read_current_tag_status()
+        ensure_expected_tag_id_matches(expected_tag_id, current_tag_status)
+        if current_tag_status is None:
+            return Response(status_code=204)
+
+        try:
+            metadata = None
+            if disc_patch.metadata is not None:
+                metadata = DiscMetadata(**disc_patch.metadata.model_dump(exclude_unset=True, exclude_none=True))
+
+            option = None
+            if disc_patch.option is not None:
+                option = DiscOption(**disc_patch.option.model_dump(exclude_unset=True, exclude_none=True))
+
+            edit_disc.execute(current_tag_status.tag_id, disc_patch.uri, metadata, option)
+            return build_current_tag_disc_output(current_tag_status.tag_id, get_disc.execute(current_tag_status.tag_id))
+        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)}")
+
+    @router.delete(
+        "/current-tag/disc",
+        status_code=204,
+        responses={
+            204: {"description": "No current tag or disc deleted"},
+            404: {"description": "Current tag disc not found"},
+            409: {"description": "Current tag changed"},
+        },
+        summary="Delete the current tag disc",
+    )
+    def delete_current_tag_disc(expected_tag_id: Optional[str] = None) -> Response:
+        current_tag_status = read_current_tag_status()
+        ensure_expected_tag_id_matches(expected_tag_id, current_tag_status)
+        if current_tag_status is None:
+            return Response(status_code=status.HTTP_204_NO_CONTENT)
+
+        try:
+            remove_disc.execute(current_tag_status.tag_id)
+            return Response(status_code=status.HTTP_204_NO_CONTENT)
+        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.dev7/discstore/adapters/inbound/api/discs_router.py

@@ -0,0 +1,73 @@
+from typing import Dict
+
+from fastapi import APIRouter, HTTPException, Response, status
+
+from discstore.adapters.inbound.api.models import DiscInput, DiscOutput, DiscPatchInput
+from discstore.domain.entities import Disc, DiscMetadata, DiscOption
+from discstore.domain.use_cases.add_disc import AddDisc
+from discstore.domain.use_cases.edit_disc import EditDisc
+from discstore.domain.use_cases.get_disc import GetDisc
+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,
+    get_disc: GetDisc,
+) -> 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.get("/discs/{tag_id}", response_model=DiscOutput, summary="Get a disc")
+    def get_disc_route(tag_id: str) -> Disc:
+        try:
+            return get_disc.execute(tag_id)
+        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)}")
+
+    @router.post("/discs/{tag_id}", response_model=DiscOutput, status_code=201, summary="Create a disc")
+    def create_disc_route(tag_id: str, disc: DiscInput) -> Disc:
+        try:
+            new_disc = Disc(**disc.model_dump())
+            return add_disc.execute(tag_id, new_disc)
+        except ValueError as value_err:
+            raise HTTPException(status_code=409, detail=str(value_err))
+        except Exception as err:
+            raise HTTPException(status_code=500, detail=f"Server error: {str(err)}")
+
+    @router.patch("/discs/{tag_id}", response_model=DiscOutput, summary="Update a disc")
+    def update_disc_route(tag_id: str, disc_patch: DiscPatchInput) -> Disc:
+        try:
+            metadata = None
+            if disc_patch.metadata is not None:
+                metadata = DiscMetadata(**disc_patch.metadata.model_dump(exclude_unset=True, exclude_none=True))
+
+            option = None
+            if disc_patch.option is not None:
+                option = DiscOption(**disc_patch.option.model_dump(exclude_unset=True, exclude_none=True))
+
+            return edit_disc.execute(tag_id, disc_patch.uri, metadata, option)
+        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)}")
+
+    @router.delete("/discs/{tag_id}", status_code=204, summary="Delete a disc")
+    def remove_disc_route(tag_id: str) -> Response:
+        try:
+            remove_disc.execute(tag_id)
+            return Response(status_code=status.HTTP_204_NO_CONTENT)
+        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.dev7/discstore/adapters/inbound/api/models.py

@@ -0,0 +1,48 @@
+from typing import Any, Dict, Optional
+
+from pydantic import BaseModel, RootModel
+
+from discstore.domain.entities import CurrentTagStatus, Disc
+
+
+class DiscInput(Disc):
+    pass
+
+
+class DiscOutput(Disc):
+    pass
+
+
+class DiscPatchMetadataInput(BaseModel):
+    artist: Optional[str] = None
+    album: Optional[str] = None
+    track: Optional[str] = None
+    playlist: Optional[str] = None
+
+
+class DiscPatchOptionInput(BaseModel):
+    shuffle: Optional[bool] = None
+    is_test: Optional[bool] = None
+
+
+class DiscPatchInput(BaseModel):
+    uri: Optional[str] = None
+    metadata: Optional[DiscPatchMetadataInput] = None
+    option: Optional[DiscPatchOptionInput] = None
+
+
+class CurrentTagStatusOutput(CurrentTagStatus):
+    pass
+
+
+class CurrentTagDiscOutput(BaseModel):
+    tag_id: str
+    disc: DiscOutput
+
+
+class SettingsResetInput(BaseModel):
+    path: str
+
+
+class SettingsPatchInput(RootModel[Dict[str, Any]]):
+    pass

{gukebox-1.0.0.dev6 → gukebox-1.0.0.dev7}/discstore/adapters/inbound/api_controller.py

@@ -10,9 +10,11 @@ try:
     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 (
+        CurrentTagDiscOutput,
         CurrentTagStatusOutput,
         DiscInput,
         DiscOutput,
+        DiscPatchInput,
         SettingsPatchInput,
         SettingsResetInput,
     )
@@ -26,20 +28,23 @@ except ModuleNotFoundError as 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.get_disc import GetDisc
 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.selection import GetSonosSelectionStatus, SaveSonosSelection
 from jukebox.sonos.service import SonosService
 
 __all__ = [
     "APIController",
+    "CurrentTagDiscOutput",
     "CurrentTagStatusOutput",
     "DiscInput",
     "DiscOutput",
+    "DiscPatchInput",
     "SettingsPatchInput",
     "SettingsResetInput",
     "SonosSelectionInput",
@@ -54,11 +59,17 @@ class SelectedSonosGroupOutput(SelectedSonosGroupSettings):
     pass
 
 
-class SonosSelectionAvailabilityOutput(BaseModel):
+class SonosSelectionMemberAvailabilityOutput(BaseModel):
+    uid: str
     status: str
     speaker: Optional[SonosSpeakerOutput] = None
 
 
+class SonosSelectionAvailabilityOutput(BaseModel):
+    status: str
+    members: list[SonosSelectionMemberAvailabilityOutput]
+
+
 class SonosSelectionOutput(BaseModel):
     selected_group: Optional[SelectedSonosGroupOutput] = None
     availability: SonosSelectionAvailabilityOutput
@@ -66,6 +77,7 @@ class SonosSelectionOutput(BaseModel):
 
 class SonosSelectionInput(BaseModel):
     uids: list[str]
+    coordinator_uid: Optional[str] = None
 
 
 class SonosSelectionUpdateOutput(BaseModel):
@@ -82,6 +94,7 @@ class APIController:
         list_discs: ListDiscs,
         remove_disc: RemoveDisc,
         edit_disc: EditDisc,
+        get_disc: GetDisc,
         get_current_tag_status: GetCurrentTagStatus,
         settings_service: SettingsService,
         sonos_service: SonosService,
@@ -90,6 +103,7 @@ class APIController:
         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
@@ -108,9 +122,18 @@ class APIController:
                 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_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])
@@ -137,21 +160,22 @@ class APIController:
         @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)
+                ).execute(payload.uids, coordinator_uid=payload.coordinator_uid)
                 return SonosSelectionUpdateOutput(
                     selected_group=SelectedSonosGroupOutput(**result.selected_group.model_dump()),
                     availability=SonosSelectionAvailabilityOutput(
                         status="available",
-                        speaker=SonosSpeakerOutput(**result.speaker.model_dump()),
+                        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,

{gukebox-1.0.0.dev6 → gukebox-1.0.0.dev7}/discstore/adapters/inbound/ui_controller.py

@@ -83,6 +83,7 @@ class UIController(APIController):
             list_discs,
             remove_disc,
             edit_disc,
+            get_disc,
             get_current_tag_status,
             settings_service,
             sonos_service,

{gukebox-1.0.0.dev6 → gukebox-1.0.0.dev7}/discstore/domain/use_cases/add_disc.py

@@ -6,5 +6,6 @@ class AddDisc:
     def __init__(self, repository: LibraryRepository):
         self.repository = repository
 
-    def execute(self, tag_id: str, disc: Disc) -> None:
+    def execute(self, tag_id: str, disc: Disc) -> Disc:
         self.repository.add_disc(tag_id, disc)
+        return disc

{gukebox-1.0.0.dev6 → gukebox-1.0.0.dev7}/discstore/domain/use_cases/edit_disc.py

@@ -14,7 +14,7 @@ class EditDisc:
         uri: Optional[str] = None,
         metadata: Optional[DiscMetadata] = None,
         option: Optional[DiscOption] = None,
-    ) -> None:
+    ) -> Disc:
         current_disc = self.repository.get_disc(tag_id)
         if current_disc is None:
             raise ValueError(f"Tag does not exist: tag_id='{tag_id}'")
@@ -37,3 +37,4 @@ class EditDisc:
 
         updated_disc = Disc(uri=new_uri, metadata=new_metadata, option=new_option)
         self.repository.update_disc(tag_id, updated_disc)
+        return updated_disc

{gukebox-1.0.0.dev6 → gukebox-1.0.0.dev7}/jukebox/adapters/outbound/sonos_discovery_adapter.py

@@ -153,10 +153,7 @@ class SoCoSonosDiscoveryAdapter(SonosDiscoveryPort):
         except (HTTPError, OSError, RequestException, RuntimeError, SoCoException, SoCoUPnPException) as err:
             return (
                 None,
-                "{}: {}".format(
-                    _safe_speaker_identifier(speaker),
-                    err,
-                ),
+                f"{_safe_speaker_identifier(speaker)}: {err}",
             )
 
 

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

@@ -82,6 +82,7 @@ def _run_command(ctx: typer.Context, command: object) -> None:
                     sonos_service=services.sonos,
                     settings_service=services.settings,
                     speaker_prompt_fn=_prompt_for_sonos_speaker_selection,
+                    coordinator_prompt_fn=_prompt_for_sonos_group_coordinator,
                 )
             else:
                 execute_server_command(
@@ -154,12 +155,30 @@ 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]:
+def _prompt_for_sonos_speaker_selection(speakers: list[DiscoveredSonosSpeaker]) -> Optional[list[str]]:
+    import questionary
+
+    try:
+        return questionary.checkbox(
+            "Select one or more Sonos speakers",
+            choices=[
+                questionary.Choice(
+                    title=build_sonos_speaker_choice_label(speaker),
+                    value=speaker.uid,
+                )
+                for speaker in speakers
+            ],
+        ).ask()
+    except KeyboardInterrupt:
+        return None
+
+
+def _prompt_for_sonos_group_coordinator(speakers: list[DiscoveredSonosSpeaker]) -> Optional[str]:
     import questionary
 
     try:
         return questionary.select(
-            "Select a Sonos speaker",
+            "Select the Sonos coordinator",
             choices=[
                 questionary.Choice(
                     title=build_sonos_speaker_choice_label(speaker),
@@ -294,10 +313,28 @@ def sonos_select(
     ctx: typer.Context,
     uids: Annotated[
         Optional[list[str]],
-        typer.Option("--uids", help="discover and persist exactly one Sonos speaker UID"),
+        typer.Option(
+            "--uids",
+            help=(
+                "comma-separated Sonos speaker UIDs to persist as the selected group; may be repeated; "
+                "first UID is used as coordinator if --coordinator is omitted"
+            ),
+        ),
+    ] = None,
+    coordinator: Annotated[
+        Optional[str],
+        typer.Option("--coordinator", help="coordinator UID for the selected Sonos group"),
     ] = None,
 ) -> None:
-    _run_command(ctx, SonosSelectCommand(type="sonos_select", uids=uids))
+    parsed_uids = (
+        None if uids is None else [uid.strip() for raw_uids in uids for uid in raw_uids.split(",") if uid.strip()]
+    )
+    try:
+        command = SonosSelectCommand(type="sonos_select", uids=parsed_uids, coordinator=coordinator)
+    except ValidationError as err:
+        _exit_on_command_validation_error(err)
+
+    _run_command(ctx, command)
 
 
 @sonos_app.command("show")