gukebox 1.0.0.dev10__tar.gz → 1.0.0.dev12__tar.gz

{gukebox-1.0.0.dev10 → gukebox-1.0.0.dev12}/PKG-INFO

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

{gukebox-1.0.0.dev10 → gukebox-1.0.0.dev12}/jukebox/adapters/outbound/json_library_adapter.py

@@ -26,8 +26,8 @@ class JsonLibraryAdapter(LibraryRepository):
             with open(self.filepath, "r", encoding="utf-8") as f:
                 data = json.load(f)
                 return Library.model_validate(data)
-        except FileNotFoundError as err:
-            LOGGER.warning(f"File not found, continuing with an empty library: filepath: {self.filepath}, error: {err}")
+        except FileNotFoundError:
+            LOGGER.warning(f"No library file found, starting with an empty library: {self.filepath}")
             return Library()
         except (json.JSONDecodeError, ValidationError) as err:
             LOGGER.warning(
@@ -37,6 +37,7 @@ class JsonLibraryAdapter(LibraryRepository):
 
     def _write_library(self, library: Library) -> None:
         directory = os.path.dirname(self.filepath) or "."
+        os.makedirs(directory, exist_ok=True)
         temp_fd, temp_path = tempfile.mkstemp(dir=directory, prefix=".library-", suffix=".json")
 
         try:

{gukebox-1.0.0.dev10 → gukebox-1.0.0.dev12}/jukebox/adapters/outbound/readers/pn532_reader_adapter.py

@@ -47,8 +47,13 @@ class Pn532ReaderAdapter(ReaderPort):
         self.read_timeout_seconds = read_timeout_seconds
         ic, ver, rev, support = self.pn532.get_firmware_version()
         LOGGER.info(f"Found PN532 with firmware version: {ver}.{rev}")
+        self._firmware_version: tuple[int, int] = (ver, rev)
         self.pn532.SAM_configuration()
 
+    @property
+    def firmware_version(self) -> tuple[int, int]:
+        return self._firmware_version
+
     def read(self) -> Union[str, None]:
         rawuid = self.pn532.read_passive_target(timeout=self.read_timeout_seconds)
         if rawuid is None:

{gukebox-1.0.0.dev10 → gukebox-1.0.0.dev12}/jukebox/admin/app.py

@@ -42,6 +42,8 @@ from .commands import (
     is_sonos_command,
 )
 from .di_container import build_admin_api_app, build_admin_services, build_admin_ui_app, build_settings_service
+from .pn532_command_handlers import execute_pn532_command
+from .pn532_commands import Pn532ProbeCommand, Pn532ProfilesCommand, Pn532SelectCommand, is_pn532_command
 from .sonos_households import GroupedSonosHousehold
 
 
@@ -88,6 +90,15 @@ def _run_command(ctx: typer.Context, command: object) -> None:
                     coordinator_prompt_fn=_prompt_for_sonos_group_coordinator,
                     status_fn=_emit_cli_status,
                 )
+            elif is_pn532_command(command):
+                execute_pn532_command(
+                    command=command,
+                    settings_service=services.settings,
+                    profile_prompt_fn=_prompt_for_pn532_profile,
+                    protocol_prompt_fn=_prompt_for_pn532_protocol,
+                    pin_prompt_fn=_prompt_for_pn532_pin,
+                    stdout_fn=typer.echo,
+                )
             else:
                 execute_server_command(
                     verbose=state.verbose,
@@ -98,6 +109,8 @@ def _run_command(ctx: typer.Context, command: object) -> None:
                     source_command="jukebox-admin",
                 )
         except RuntimeError as err:
+            if state.verbose:
+                raise
             typer.echo(str(err), err=True)
             raise typer.Exit(code=1)
     except SystemExit as err:
@@ -110,6 +123,9 @@ def _run_command(ctx: typer.Context, command: object) -> None:
     except SettingsError as err:
         typer.echo(render_cli_error(err, verbose=state.verbose), err=True)
         raise typer.Exit(code=1)
+    except ModuleNotFoundError as err:
+        typer.echo(str(err), err=True)
+        raise typer.Exit(code=1)
     except OSError as err:
         typer.echo(str(err), err=True)
         raise typer.Exit(code=1)
@@ -195,6 +211,38 @@ def _prompt_for_sonos_household_selection(households: list[GroupedSonosHousehold
         return None
 
 
+def _prompt_for_pn532_profile(profiles: list[str]) -> Optional[str]:
+    import questionary
+
+    try:
+        return questionary.select("Select a PN532 board profile", choices=profiles).ask()
+    except KeyboardInterrupt:
+        return None
+
+
+def _prompt_for_pn532_protocol(protocols: list[str], default: str) -> Optional[str]:
+    import questionary
+
+    try:
+        return questionary.select("Select a PN532 protocol", choices=protocols, default=default).ask()
+
+    except KeyboardInterrupt:
+        return None
+
+
+def _prompt_for_pn532_pin(pin_name: str, default: Optional[int]) -> Optional[str]:
+    import questionary
+
+    default_str = str(default) if default is not None else ""
+    try:
+        return questionary.text(
+            f"SPI {pin_name} pin (GPIO number, leave blank to clear):",
+            default=default_str,
+        ).ask()
+    except KeyboardInterrupt:
+        return None
+
+
 def _prompt_for_sonos_group_coordinator(speakers: list[DiscoveredSonosSpeaker]) -> Optional[str]:
     import questionary
 
@@ -223,9 +271,11 @@ 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 and manage the saved Sonos selection")
+pn532_app = typer.Typer(help="Inspect and debug the PN532 NFC reader")
 app.add_typer(settings_app, name="settings")
 app.add_typer(library_app, name="library")
 app.add_typer(sonos_app, name="sonos")
+app.add_typer(pn532_app, name="pn532")
 
 
 @app.callback()
@@ -379,6 +429,33 @@ def sonos_show(ctx: typer.Context) -> None:
     _run_command(ctx, SonosShowCommand(type="sonos_show"))
 
 
+@pn532_app.command("profiles")
+def pn532_profiles(ctx: typer.Context) -> None:
+    """List available board profiles and their default GPIO pins."""
+    _run_command(ctx, Pn532ProfilesCommand(type="pn532_profiles"))
+
+
+@pn532_app.command("select")
+def pn532_select(
+    ctx: typer.Context,
+    profile: Annotated[
+        Optional[str],
+        typer.Option(
+            "--profile",
+            help="board profile to persist (waveshare_hat, hiletgo_v3, custom)",
+        ),
+    ] = None,
+) -> None:
+    """Select a board profile and persist it to settings."""
+    _run_command(ctx, Pn532SelectCommand(type="pn532_select", profile=profile))
+
+
+@pn532_app.command("probe")
+def pn532_probe(ctx: typer.Context) -> None:
+    """Verify the PN532 is connected, show firmware version and attempt one tag read."""
+    _run_command(ctx, Pn532ProbeCommand(type="pn532_probe"))
+
+
 @library_app.command("add")
 def library_add(
     ctx: typer.Context,

{gukebox-1.0.0.dev10 → gukebox-1.0.0.dev12}/jukebox/admin/cli_presentation.py

@@ -11,6 +11,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.shared.terminal_ui import table
 from jukebox.sonos.discovery import DiscoveredSonosSpeaker
 from jukebox.sonos.selection import SonosSelectionResult, SonosSelectionStatus
 
@@ -51,26 +52,12 @@ def render_cli_error(err: BaseException, verbose: bool = False) -> str:
 def render_sonos_speakers_output(households: list[GroupedSonosHousehold]) -> str:
     if not households:
         return "No visible Sonos speakers found."
-
-    all_speakers = [speaker for household in households for speaker in household.speakers]
-    name_width = max(len(speaker.name) for speaker in all_speakers)
-    host_width = max(len(speaker.host) for speaker in all_speakers)
-    lines = []
+    headers = ["name", "host", "uid"]
+    sections = []
     for household in households:
-        lines.append(f"Household: {household.household_id}")
-        for index, speaker in enumerate(household.speakers, start=1):
-            lines.append(
-                "  {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,
-                )
-            )
-        lines.append("")
-    return "\n".join(lines[:-1])
+        rows = [[s.name, s.host, s.uid] for s in household.speakers]
+        sections.append(f"Household: {household.household_id}\n\n" + table(headers, rows, indexed=True))
+    return "Sonos speakers:\n\n" + "\n\n".join(sections)
 
 
 def build_sonos_household_choice_label(household: GroupedSonosHousehold) -> str:

gukebox-1.0.0.dev12/jukebox/admin/pn532_command_handlers.py

@@ -0,0 +1,222 @@
+import dataclasses
+from typing import Any, Callable, Optional, cast
+
+from jukebox.pn532.profiles import (
+    PN532_PROFILES,
+    Pn532ConnectionParams,
+    Pn532Protocol,
+    SpiConnectionParams,
+    resolve_connection_params,
+)
+from jukebox.settings.service_protocols import SettingsService
+from jukebox.shared.terminal_ui import table
+
+from .pn532_commands import Pn532ProbeCommand, Pn532ProfilesCommand, Pn532SelectCommand
+
+
+def _default_build_pn532_reader(
+    read_timeout_seconds: float,
+    protocol: Pn532Protocol,
+    connection: Pn532ConnectionParams,
+) -> Any:
+    from jukebox.adapters.outbound.readers.pn532_reader_adapter import Pn532ReaderAdapter
+
+    if protocol == "spi":
+        if not isinstance(connection, SpiConnectionParams):
+            raise ValueError(f"Expected SpiConnectionParams for protocol 'spi', got {type(connection).__name__}")
+        return Pn532ReaderAdapter(
+            read_timeout_seconds=read_timeout_seconds,
+            spi_reset=connection.reset,
+            spi_cs=connection.cs,
+            spi_irq=connection.irq,
+        )
+    raise ValueError(f"Unsupported PN532 protocol: {protocol}")
+
+
+def _parse_pin(raw: Optional[str]) -> "tuple[bool, Optional[str]]":
+    """Returns (ok, value). ok=False means the user cancelled the prompt.
+    value=None means blank input (reset to profile default)."""
+    if raw is None:
+        return False, None
+    stripped = raw.strip()
+    return True, stripped if stripped else None
+
+
+def execute_pn532_command(
+    command: object,
+    settings_service: SettingsService,
+    profile_prompt_fn: Optional[Callable[[list], Optional[str]]] = None,
+    protocol_prompt_fn: Optional[Callable[[list, str], Optional[str]]] = None,
+    pin_prompt_fn: Optional[Callable[[str, Optional[int]], Optional[str]]] = None,
+    build_pn532_reader: Callable[..., Any] = _default_build_pn532_reader,
+    stdout_fn: Callable[[str], None] = print,
+) -> None:
+    if isinstance(command, Pn532ProfilesCommand):
+        stdout_fn(render_pn532_profiles_output())
+        return
+
+    if isinstance(command, Pn532SelectCommand):
+        if command.profile is not None:
+            selected = command.profile
+            settings_service.set_persisted_value("jukebox.reader.pn532.board_profile", selected)
+            stdout_fn(render_pn532_select_output(selected))
+            return
+
+        # Interactive mode
+        if profile_prompt_fn is None:
+            raise RuntimeError("Interactive PN532 profile selection is not available in this context.")
+        selected_profile = profile_prompt_fn(list(PN532_PROFILES.keys()))
+        if selected_profile is None:
+            return
+
+        defaults = PN532_PROFILES.get(cast(Any, selected_profile))
+        if defaults is None:
+            raise RuntimeError(f"Unknown board profile: {selected_profile!r}")
+
+        selected_protocol = defaults.default_protocol
+        if protocol_prompt_fn is not None:
+            prompted = protocol_prompt_fn(list(defaults.connections.keys()), defaults.default_protocol)
+            if prompted is None:
+                return
+            selected_protocol = prompted
+
+        pin_defaults = defaults.connections.get(cast(Pn532Protocol, selected_protocol))
+        if pin_defaults is None:
+            raise RuntimeError(
+                f"Protocol '{selected_protocol}' is not supported by board profile '{selected_profile}'."
+            )
+
+        if pin_prompt_fn is not None:
+            field_values: dict[str, Optional[str]] = {}
+            for f in dataclasses.fields(pin_defaults):
+                default = getattr(pin_defaults, f.name)
+                raw = pin_prompt_fn(f.name, default)
+                ok, value = _parse_pin(raw)
+                if not ok:
+                    return
+                field_values[f.name] = value
+
+            settings_service.set_persisted_value("jukebox.reader.pn532.board_profile", selected_profile)
+            if selected_protocol != defaults.default_protocol:
+                settings_service.set_persisted_value("jukebox.reader.pn532.protocol", selected_protocol)
+            else:
+                settings_service.reset_persisted_value("jukebox.reader.pn532.protocol")
+            for f in dataclasses.fields(pin_defaults):
+                path = f"jukebox.reader.pn532.{selected_protocol}.{f.name}"
+                value = field_values[f.name]
+                profile_default = getattr(pin_defaults, f.name)
+                try:
+                    is_default = value is None or int(value) == profile_default
+                except ValueError:
+                    is_default = False
+                if is_default:
+                    settings_service.reset_persisted_value(path)
+                else:
+                    assert value is not None
+                    settings_service.set_persisted_value(path, value)
+            stdout_fn(render_pn532_configure_output(selected_profile, selected_protocol, pin_defaults, field_values))
+        else:
+            settings_service.set_persisted_value("jukebox.reader.pn532.board_profile", selected_profile)
+            stdout_fn(render_pn532_select_output(selected_profile))
+        return
+
+    if isinstance(command, Pn532ProbeCommand):
+        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)
+
+        stdout_fn(render_pn532_probe_setup_output(pn532.board_profile, pn532.protocol, resolved))
+
+        try:
+            reader = build_pn532_reader(
+                read_timeout_seconds=pn532.read_timeout_seconds,
+                protocol=pn532.protocol,
+                connection=resolved,
+            )
+        except (ModuleNotFoundError, RuntimeError):
+            raise
+        except Exception as err:
+            msg = str(err)
+            if any(s in msg.lower() for s in ("not permitted", "permission", "bad gpio")):
+                raise RuntimeError(
+                    "GPIO error — your pin configuration may be incorrect.\n"
+                    "Update it with: jukebox-admin pn532 select\n"
+                    "Re-run with `--verbose` for details."
+                ) from err
+            raise RuntimeError(msg) from err
+
+        ver, rev = reader.firmware_version
+        stdout_fn(f"PN532 firmware version: {ver}.{rev}")
+
+        uid = reader.read()
+        stdout_fn(f"Tag UID: {uid}" if uid else "No tag detected")
+        return
+
+    raise TypeError("Unsupported PN532 command")
+
+
+def render_pn532_probe_setup_output(
+    board_profile: str,
+    protocol: str,
+    connection: Pn532ConnectionParams,
+) -> str:
+    fields = "  ".join(
+        f"{f.name}={getattr(connection, f.name) if getattr(connection, f.name) is not None else '-'}"
+        for f in dataclasses.fields(connection)
+    )
+    return f"Probing — profile={board_profile}  protocol={protocol}  {fields}"
+
+
+def render_pn532_profiles_output() -> str:
+    by_protocol: dict[str, list[tuple[str, Any]]] = {}
+    for name, profile in PN532_PROFILES.items():
+        protocol = profile.default_protocol
+        by_protocol.setdefault(protocol, []).append((name, profile.connections[protocol]))
+    sections = []
+    for protocol, entries in by_protocol.items():
+        field_names = [f.name for f in dataclasses.fields(entries[0][1])]
+        headers = ["name", *field_names]
+        rows = [
+            [name, *("-" if getattr(conn, f) is None else getattr(conn, f) for f in field_names)]
+            for name, conn in entries
+        ]
+        sections.append(f"Protocol: {protocol}\n\n" + table(headers, rows, indexed=True))
+    return "Available predefined board profiles:\n\n" + "\n\n".join(sections)
+
+
+def render_pn532_select_output(profile: str) -> str:
+    defaults = PN532_PROFILES.get(cast(Any, profile))
+    if defaults is None:
+        return f"Board profile saved: {profile}"
+    protocol = defaults.default_protocol
+    connection = defaults.connections[protocol]
+    fields = "  ".join(
+        f"{f.name}={getattr(connection, f.name) if getattr(connection, f.name) is not None else '-'}"
+        for f in dataclasses.fields(connection)
+    )
+    return "\n".join(
+        [
+            f"Board profile saved: {profile}",
+            f"Protocol: {protocol}",
+            f"Default pins — {fields}",
+        ]
+    )
+
+
+def render_pn532_configure_output(
+    profile: str,
+    protocol: str,
+    connection: Pn532ConnectionParams,
+    field_values: dict[str, Optional[str]],
+) -> str:
+    fields = "  ".join(
+        f"{f.name}={field_values[f.name] if field_values[f.name] is not None else '-'}"
+        for f in dataclasses.fields(connection)
+    )
+    return "\n".join(
+        [
+            f"Board profile saved: {profile}",
+            f"Protocol: {protocol}",
+            f"Pins saved — {fields}",
+        ]
+    )

gukebox-1.0.0.dev12/jukebox/admin/pn532_commands.py

@@ -0,0 +1,20 @@
+from typing import Literal, Optional
+
+from pydantic import BaseModel
+
+
+class Pn532ProfilesCommand(BaseModel):
+    type: Literal["pn532_profiles"]
+
+
+class Pn532SelectCommand(BaseModel):
+    type: Literal["pn532_select"]
+    profile: Optional[str] = None
+
+
+class Pn532ProbeCommand(BaseModel):
+    type: Literal["pn532_probe"]
+
+
+def is_pn532_command(command: object) -> bool:
+    return isinstance(command, (Pn532ProfilesCommand, Pn532SelectCommand, Pn532ProbeCommand))

{gukebox-1.0.0.dev10 → gukebox-1.0.0.dev12}/jukebox/di_container.py

@@ -25,13 +25,17 @@ def build_jukebox(config: ResolvedJukeboxRuntimeConfig):
 
     if config.reader_type == "pn532":
         from jukebox.adapters.outbound.readers.pn532_reader_adapter import Pn532ReaderAdapter
+        from jukebox.pn532.profiles import SpiConnectionParams
 
         if config.pn532_protocol == "spi":
+            conn = config.pn532_connection
+            if not isinstance(conn, SpiConnectionParams):
+                raise ValueError(f"Expected SpiConnectionParams for protocol 'spi', got {type(conn).__name__}")
             reader = Pn532ReaderAdapter(
                 read_timeout_seconds=config.pn532_read_timeout_seconds,
-                spi_reset=config.pn532_spi_reset,
-                spi_cs=config.pn532_spi_cs,
-                spi_irq=config.pn532_spi_irq,
+                spi_reset=conn.reset,
+                spi_cs=conn.cs,
+                spi_irq=conn.irq,
             )
         else:
             raise ValueError(f"Unsupported PN532 protocol: {config.pn532_protocol}")

gukebox-1.0.0.dev12/jukebox/pn532/__init__.py

@@ -0,0 +1,19 @@
+from .profiles import (
+    PN532_PROFILES,
+    Pn532BoardProfile,
+    Pn532BoardProfileDefaults,
+    Pn532ConnectionParams,
+    Pn532Protocol,
+    SpiConnectionParams,
+    resolve_connection_params,
+)
+
+__all__ = [
+    "PN532_PROFILES",
+    "Pn532BoardProfile",
+    "Pn532BoardProfileDefaults",
+    "Pn532ConnectionParams",
+    "Pn532Protocol",
+    "SpiConnectionParams",
+    "resolve_connection_params",
+]

gukebox-1.0.0.dev12/jukebox/pn532/profiles.py

@@ -0,0 +1,70 @@
+import dataclasses
+from dataclasses import dataclass
+from typing import Literal, Optional
+
+Pn532BoardProfile = Literal["waveshare_hat", "hiletgo_v3", "custom"]
+
+Pn532Protocol = Literal["spi"]
+
+
+@dataclass(frozen=True)
+class SpiConnectionParams:
+    reset: Optional[int]
+    cs: Optional[int]
+    irq: Optional[int]
+
+
+# Today SpiConnectionParams only; Union[SpiConnectionParams, UartConnectionParams, ...]
+# will be introduced when additional protocols are added.
+Pn532ConnectionParams = SpiConnectionParams
+
+
+@dataclass(frozen=True)
+class Pn532BoardProfileDefaults:
+    default_protocol: Pn532Protocol
+    connections: dict[Pn532Protocol, Pn532ConnectionParams]
+
+
+PN532_PROFILES: dict[Pn532BoardProfile, Pn532BoardProfileDefaults] = {
+    "waveshare_hat": Pn532BoardProfileDefaults(
+        default_protocol="spi",
+        connections={"spi": SpiConnectionParams(reset=20, cs=4, irq=None)},
+    ),
+    "hiletgo_v3": Pn532BoardProfileDefaults(
+        default_protocol="spi",
+        connections={"spi": SpiConnectionParams(reset=None, cs=8, irq=None)},
+    ),
+    "custom": Pn532BoardProfileDefaults(
+        default_protocol="spi",
+        connections={"spi": SpiConnectionParams(reset=None, cs=None, irq=None)},
+    ),
+}
+
+
+def resolve_connection_params(
+    board_profile: Pn532BoardProfile,
+    protocol: Pn532Protocol,
+    overrides: Pn532ConnectionParams,
+) -> Pn532ConnectionParams:
+    """Merge per-field overrides with the profile defaults for the given protocol.
+
+    A field value of None in *overrides* means "use the profile default".
+    The custom profile has None as its own default, so None is preserved.
+    """
+    profile = PN532_PROFILES[board_profile]
+    if protocol not in profile.connections:
+        supported = list(profile.connections.keys())
+        raise ValueError(
+            f"Protocol '{protocol}' is not supported by board profile '{board_profile}' (supported: {supported})"
+        )
+    defaults = profile.connections[protocol]
+    if not isinstance(overrides, type(defaults)):
+        raise ValueError(
+            f"Expected overrides of type {type(defaults).__name__} for protocol '{protocol}', "
+            f"got {type(overrides).__name__}"
+        )
+    merged = {
+        f.name: getattr(overrides, f.name) if getattr(overrides, f.name) is not None else getattr(defaults, f.name)
+        for f in dataclasses.fields(defaults)
+    }
+    return type(defaults)(**merged)

{gukebox-1.0.0.dev10 → gukebox-1.0.0.dev12}/jukebox/settings/entities.py

@@ -3,6 +3,7 @@ from typing import Literal, Optional
 
 from pydantic import BaseModel, ConfigDict, Field, model_validator
 
+from jukebox.pn532.profiles import SpiConnectionParams
 from jukebox.shared.timing import MIN_PAUSE_DELAY_SECONDS
 
 from .runtime_validation import validate_resolved_jukebox_runtime_rules
@@ -272,9 +273,7 @@ class ResolvedJukeboxRuntimeConfig(StrictModel):
     pn532_read_timeout_seconds: float
     pn532_board_profile: Literal["waveshare_hat", "hiletgo_v3", "custom"]
     pn532_protocol: Literal["spi"] = "spi"
-    pn532_spi_reset: Optional[int]
-    pn532_spi_cs: Optional[int]
-    pn532_spi_irq: Optional[int]
+    pn532_connection: SpiConnectionParams
     verbose: bool = False
 
     @model_validator(mode="after")

{gukebox-1.0.0.dev10 → gukebox-1.0.0.dev12}/jukebox/settings/resolve.py

@@ -5,7 +5,7 @@ from typing import Optional, Union, cast
 
 from pydantic import ValidationError
 
-from jukebox.pn532.profiles import resolve_spi_pins
+from jukebox.pn532.profiles import SpiConnectionParams, resolve_connection_params
 from jukebox.shared.config_utils import get_current_tag_path
 
 from .definitions import (
@@ -237,7 +237,8 @@ def _expand_path(path: str) -> str:
 
 def _derive_pn532(effective_settings: AppSettings) -> JsonObject:
     pn532 = effective_settings.jukebox.reader.pn532
-    resolved = resolve_spi_pins(pn532.board_profile, pn532.spi.reset, pn532.spi.cs, pn532.spi.irq)
+    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 {
         "reader": {
             "pn532": {

{gukebox-1.0.0.dev10 → gukebox-1.0.0.dev12}/jukebox/settings/runtime_resolver.py

@@ -1,9 +1,9 @@
 import os
-from typing import Any, Optional, Tuple
+from typing import Optional, Tuple
 
 from pydantic import ValidationError
 
-from jukebox.pn532.profiles import resolve_spi_pins
+from jukebox.pn532.profiles import SpiConnectionParams, resolve_connection_params
 from jukebox.sonos.service import SonosService
 
 from .entities import AppSettings, Pn532ReaderSettings, ResolvedJukeboxRuntimeConfig, ResolvedSonosGroupRuntime
@@ -39,7 +39,7 @@ class JukeboxRuntimeResolver:
                 pn532_read_timeout_seconds=effective_settings.jukebox.reader.pn532.read_timeout_seconds,
                 pn532_board_profile=effective_settings.jukebox.reader.pn532.board_profile,
                 pn532_protocol=effective_settings.jukebox.reader.pn532.protocol,
-                **_resolve_pn532_spi_pins(effective_settings.jukebox.reader.pn532),
+                pn532_connection=_resolve_pn532_connection(effective_settings.jukebox.reader.pn532),
                 verbose=verbose,
             )
         except (ValidationError, ValueError) as err:
@@ -63,10 +63,6 @@ class JukeboxRuntimeResolver:
         return None, None, None
 
 
-def _resolve_pn532_spi_pins(pn532: Pn532ReaderSettings) -> dict[str, Any]:
-    resolved = resolve_spi_pins(pn532.board_profile, pn532.spi.reset, pn532.spi.cs, pn532.spi.irq)
-    return {
-        "pn532_spi_reset": resolved.reset,
-        "pn532_spi_cs": resolved.cs,
-        "pn532_spi_irq": resolved.irq,
-    }
+def _resolve_pn532_connection(pn532: Pn532ReaderSettings) -> SpiConnectionParams:
+    overrides = SpiConnectionParams(reset=pn532.spi.reset, cs=pn532.spi.cs, irq=pn532.spi.irq)
+    return resolve_connection_params(pn532.board_profile, pn532.protocol, overrides)

gukebox-1.0.0.dev12/jukebox/shared/terminal_ui.py

@@ -0,0 +1,12 @@
+def table(headers, rows, indexed=False):
+    if indexed:
+        headers = ["#"] + headers
+        rows = [[i + 1] + list(row) for i, row in enumerate(rows)]
+
+    cols = list(zip(headers, *rows))
+    widths = [max(len(str(x)) for x in col) for col in cols]
+
+    def fmt(row):
+        return "  ".join(f"{str(val):<{widths[i]}}" for i, val in enumerate(row))
+
+    return "\n".join([fmt(headers), *map(fmt, rows)])

{gukebox-1.0.0.dev10 → gukebox-1.0.0.dev12}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "gukebox"
-version = "1.0.0.dev10"
+version = "1.0.0.dev12"
 description = "A Jukebox to play music on speakers using 'CD' with NFC tag"
 authors = [{ name = "Gudsfile" }]
 readme = "README.md"

gukebox-1.0.0.dev10/jukebox/pn532/__init__.py

@@ -1,8 +0,0 @@
-from .profiles import PN532_PROFILES, Pn532BoardProfile, Pn532BoardProfileDefaults, resolve_spi_pins
-
-__all__ = [
-    "PN532_PROFILES",
-    "Pn532BoardProfile",
-    "Pn532BoardProfileDefaults",
-    "resolve_spi_pins",
-]

gukebox-1.0.0.dev10/jukebox/pn532/profiles.py

@@ -1,32 +0,0 @@
-from dataclasses import dataclass
-from typing import Literal, Optional
-
-Pn532BoardProfile = Literal["waveshare_hat", "hiletgo_v3", "custom"]
-
-
-@dataclass(frozen=True)
-class Pn532BoardProfileDefaults:
-    reset: Optional[int]
-    cs: Optional[int]
-    irq: Optional[int]
-
-
-PN532_PROFILES: dict[Pn532BoardProfile, Pn532BoardProfileDefaults] = {
-    "waveshare_hat": Pn532BoardProfileDefaults(reset=20, cs=4, irq=None),
-    "hiletgo_v3": Pn532BoardProfileDefaults(reset=None, cs=8, irq=None),
-    "custom": Pn532BoardProfileDefaults(reset=None, cs=None, irq=None),
-}
-
-
-def resolve_spi_pins(
-    board_profile: Pn532BoardProfile,
-    reset: Optional[int],
-    cs: Optional[int],
-    irq: Optional[int],
-) -> Pn532BoardProfileDefaults:
-    profile = PN532_PROFILES[board_profile]
-    return Pn532BoardProfileDefaults(
-        reset=reset if reset is not None else profile.reset,
-        cs=cs if cs is not None else profile.cs,
-        irq=irq if irq is not None else profile.irq,
-    )