swbt-python 0.5.2__py3-none-any.whl → 0.5.4__py3-none-any.whl

swbt/gamepad/interface.py

@@ -121,11 +121,11 @@ class SwitchGamepad(ABC):
         await self._runtime.open()
 
     async def pair(self, timeout: float | None = None) -> None:  # noqa: ASYNC109
-        """Start pairing advertising and wait until the controller is ready for input.
+        """Start pairing and wait until the controller can accept normal input.
 
         Args:
-            timeout: Maximum seconds for link connection and protocol initialization.
-                ``None`` waits without a deadline.
+            timeout: Maximum seconds for link connection, protocol initialization,
+                and normal-input readiness. ``None`` waits without a deadline.
 
         Raises:
             ConnectionTimeoutError: The timeout elapsed before a connection completed.
@@ -134,15 +134,15 @@ class SwitchGamepad(ABC):
         await self._runtime.pair(timeout=timeout)
 
     async def reconnect(self, timeout: float | None = None) -> None:  # noqa: ASYNC109
-        """Reconnect with exactly one bonded peer and raise on failure.
+        """Reconnect with one bonded peer and wait until normal input can begin.
 
         Args:
-            timeout: Maximum seconds for the active reconnect attempt. ``None`` uses
-                the transport default.
+            timeout: Maximum seconds for the active reconnect attempt and
+                normal-input readiness. ``None`` uses the transport default.
 
         Raises:
             ConnectionFailedError: No single bonded peer was available or reconnect failed.
-            ConnectionTimeoutError: The active reconnect attempt timed out.
+            ConnectionTimeoutError: The reconnect or normal-input readiness timed out.
             InvalidKeyStoreError: The key store cannot identify one current peer.
         """
         await self._runtime.reconnect(timeout=timeout)
@@ -154,11 +154,12 @@ class SwitchGamepad(ABC):
         """Try active reconnect with exactly one bonded peer.
 
         Args:
-            timeout: Maximum seconds for the active reconnect attempt. ``None`` uses
-                the transport default.
+            timeout: Maximum seconds for the active reconnect attempt and
+                normal-input readiness. ``None`` uses the transport default.
 
         Returns:
-            Reconnect route, status, selected peer, and peer count.
+            Reconnect route, status, selected peer, and peer count. ``connected``
+            means that normal input can begin.
 
         Raises:
             InvalidKeyStoreError: The key store cannot identify one current peer.
@@ -171,7 +172,7 @@ class SwitchGamepad(ABC):
         timeout: float | None = None,  # noqa: ASYNC109
         allow_pairing: bool = False,
     ) -> None:
-        """Connect using bonded reconnect first, then optional pairing fallback.
+        """Connect by bonded reconnect or pairing and wait for normal-input readiness.
 
         Args:
             timeout: Maximum seconds for each connection attempt. ``None`` uses the
@@ -199,7 +200,8 @@ class SwitchGamepad(ABC):
             allow_pairing: If ``True``, run pairing when no bonded peer is available.
 
         Returns:
-            Route and status chosen by reconnect or pairing fallback.
+            Route and status chosen by reconnect or pairing fallback. ``connected``
+            means that normal input can begin.
 
         Raises:
             InvalidKeyStoreError: The key store cannot identify one current peer.
@@ -375,7 +377,8 @@ class PeriodicSwitchGamepad(SwitchGamepad):
             diagnostics: Optional diagnostics configuration for trace output.
 
         Returns:
-            The protocol-ready periodic controller. The caller owns its lifetime.
+            A periodic controller ready to accept normal input. The caller owns
+            its lifetime.
 
         Raises:
             ValueError: ``local_address`` is invalid.
@@ -440,7 +443,8 @@ class DirectSwitchGamepad(SwitchGamepad):
             diagnostics: Optional diagnostics configuration for trace output.
 
         Returns:
-            The protocol-ready direct controller. The caller owns its lifetime.
+            A direct controller ready to accept normal input. The caller owns
+            its lifetime.
 
         Raises:
             ValueError: ``local_address`` is invalid.

swbt/gamepad/runtime.py

@@ -2,7 +2,9 @@
 
 import asyncio
 from collections.abc import Awaitable, Callable
+from contextlib import suppress
 from dataclasses import replace
+from time import monotonic
 from typing import Literal
 
 import swbt.gamepad as gamepad_module
@@ -48,6 +50,8 @@ class ControllerRuntime:
         diagnostics: DiagnosticsConfig | None = None,
         reporting_mode: Literal["periodic", "direct"] = "periodic",
         transport: HidDeviceTransport | None = None,
+        _report_sender_monotonic_time: Callable[[], float] = monotonic,
+        _report_sender_sleep: Callable[[float], Awaitable[None]] = asyncio.sleep,
     ) -> None:
         """Create a fully initialized gamepad runtime.
 
@@ -57,6 +61,8 @@ class ControllerRuntime:
             reporting_mode: Owner of normal input report scheduling.
             transport: Optional HID transport instance. When supplied, no Bumble
                 transport is created by the constructor.
+            _report_sender_monotonic_time: Internal holdoff clock override for tests.
+            _report_sender_sleep: Internal holdoff sleep override for tests.
 
         Raises:
             InvalidInputError: ``adapter`` is omitted for the default transport.
@@ -68,6 +74,8 @@ class ControllerRuntime:
         self._reporting_mode = reporting_mode
         self._transport = transport
         self._transport_was_injected = transport is not None
+        self._report_sender_monotonic_time = _report_sender_monotonic_time
+        self._report_sender_sleep = _report_sender_sleep
         self._pairing_profile: PairingProfile | None = None
         self._state_store = InputStateStore()
         self._diagnostics = DiagnosticsRecorder(
@@ -94,6 +102,7 @@ class ControllerRuntime:
         self._report_loop: ReportLoop | None = None
         self._report_sender: ReportSender | None = None
         self._protocol_handshake: ProtocolHandshake | None = None
+        self._input_readiness_task: asyncio.Task[None] | None = None
         self._input_operation_lock = asyncio.Lock()
         self._lifecycle_lock = asyncio.Lock()
         self._connected_event = asyncio.Event()
@@ -139,6 +148,8 @@ class ControllerRuntime:
                     ),
                     session=self._protocol_session,
                     diagnostics=self._diagnostics,
+                    monotonic_time=self._report_sender_monotonic_time,
+                    _sleep=self._report_sender_sleep,
                 )
                 self._report_sender = report_sender
                 self._connection_state = "opened"
@@ -161,14 +172,14 @@ class ControllerRuntime:
         self._configured_device_info_bluetooth_address = None
 
     async def pair(self, timeout: float | None = None) -> None:  # noqa: ASYNC109
-        """Start pairing advertising and wait until the controller is ready for input.
+        """Start pairing and wait until the controller can accept normal input.
 
         Args:
-            timeout: Maximum seconds for link connection and protocol initialization.
-                ``None`` waits without a deadline.
+            timeout: Maximum seconds for link connection, protocol initialization,
+                and normal-input readiness. ``None`` waits without a deadline.
 
         Raises:
-            ConnectionTimeoutError: The deadline elapsed before protocol readiness.
+            ConnectionTimeoutError: The deadline elapsed before normal-input readiness.
             ConnectionFailedError: Protocol initialization or the link failed.
             ClosedError: The transport was unavailable after opening.
         """
@@ -186,7 +197,7 @@ class ControllerRuntime:
                 raise ClosedError(msg)
             await self._transport.start_advertising()
             self._configure_device_info_bluetooth_address(self._transport)
-            await self._wait_for_protocol_ready(None)
+            await self._wait_for_input_ready(None)
 
         try:
             if timeout is None:
@@ -194,6 +205,9 @@ class ControllerRuntime:
             else:
                 async with asyncio.timeout(timeout):
                     await advertise_and_wait()
+        except asyncio.CancelledError:
+            await self._stop_input_readiness_wait()
+            raise
         except TimeoutError as error:
             msg = "connection timed out"
             connection_error = ConnectionTimeoutError(msg)
@@ -204,7 +218,7 @@ class ControllerRuntime:
                 ),
                 player_lights=_format_optional_byte(self._protocol_session.state.player_lights),
                 report_mode=_format_optional_byte(self._protocol_session.state.report_mode),
-                stage="protocol_initialization",
+                stage=self._connection_readiness_stage(),
                 state=self._connection_state,
                 timeout=timeout,
             )
@@ -216,15 +230,15 @@ class ControllerRuntime:
             raise
 
     async def reconnect(self, timeout: float | None = None) -> None:  # noqa: ASYNC109
-        """Reconnect with exactly one bonded peer and raise on failure.
+        """Reconnect with one bonded peer and wait until normal input can begin.
 
         Args:
-            timeout: Maximum seconds for the active reconnect attempt. ``None`` uses
-                the transport default.
+            timeout: Maximum seconds for the active reconnect attempt and
+                normal-input readiness. ``None`` uses the transport default.
 
         Raises:
             ConnectionFailedError: No single bonded peer was available or reconnect failed.
-            ConnectionTimeoutError: The active reconnect attempt timed out.
+            ConnectionTimeoutError: The reconnect or normal-input readiness timed out.
         """
         result = await self.try_reconnect(timeout=timeout)
         self._raise_if_connection_failed(result)
@@ -236,8 +250,8 @@ class ControllerRuntime:
         """Try active reconnect with exactly one bonded peer.
 
         Args:
-            timeout: Maximum seconds for the active reconnect attempt. ``None`` uses
-                the transport default.
+            timeout: Maximum seconds for the active reconnect attempt and
+                normal-input readiness. ``None`` uses the transport default.
 
         Returns:
             ConnectionResult: Reconnect route, status, selected peer, and peer count.
@@ -308,6 +322,7 @@ class ControllerRuntime:
             )
         except asyncio.CancelledError as error:
             if _current_task_is_cancelling():
+                await self._stop_input_readiness_wait()
                 raise
             return await self._record_active_reconnect_transport_error(
                 error,
@@ -406,6 +421,7 @@ class ControllerRuntime:
                     except Exception as error:  # noqa: BLE001
                         self._diagnostics.record_error(error, recoverable=True)
                 await self._stop_protocol_handshake()
+                await self._stop_input_readiness_wait()
                 if self._report_loop is not None:
                     await self._report_loop.stop()
                 self._disconnect_event.clear()
@@ -820,7 +836,7 @@ class ControllerRuntime:
 
     async def _wait_for_reconnect_connected(self, *, max_wait: float | None) -> None:
         try:
-            await self._wait_for_protocol_ready(max_wait)
+            await self._wait_for_input_ready(max_wait)
         except TimeoutError as error:
             self._diagnostics.record_event(
                 "connection_timeout",
@@ -830,13 +846,13 @@ class ControllerRuntime:
                 player_lights=_format_optional_byte(self._protocol_session.state.player_lights),
                 report_mode=_format_optional_byte(self._protocol_session.state.report_mode),
                 route="active_reconnect",
-                stage="protocol_initialization",
+                stage=self._connection_readiness_stage(),
                 state=self._connection_state,
                 timeout=max_wait,
             )
             raise TimeoutError from error
 
-    async def _wait_for_protocol_ready(self, max_wait: float | None) -> None:
+    async def _wait_for_input_ready(self, max_wait: float | None) -> None:
         if max_wait is None:
             await self._connection_attempt_event.wait()
         else:
@@ -844,9 +860,14 @@ class ControllerRuntime:
                 await self._connection_attempt_event.wait()
         if self._connected_event.is_set():
             return
-        msg = "protocol initialization failed"
+        msg = "connection initialization failed"
         raise ConnectionFailedError(msg) from self._connection_attempt_error
 
+    def _connection_readiness_stage(self) -> str:
+        if self._protocol_session.state.protocol_ready:
+            return "input_readiness"
+        return "protocol_initialization"
+
     def _record_disconnect_request_result(self, result: DisconnectRequestResult) -> None:
         fields: dict[str, object] = {"status": result.status}
         if result.channels:
@@ -917,6 +938,15 @@ class ControllerRuntime:
         if handshake is not None:
             await handshake.stop()
 
+    async def _stop_input_readiness_wait(self) -> None:
+        task = self._input_readiness_task
+        self._input_readiness_task = None
+        if task is None or task is asyncio.current_task():
+            return
+        task.cancel()
+        with suppress(asyncio.CancelledError):
+            await task
+
     def _start_periodic_report_loop(self) -> None:
         if self._transport is None or self._report_loop is not None:
             return
@@ -950,12 +980,7 @@ class ControllerRuntime:
             return
         if self._connected_event.is_set():
             return
-        self._connection_state = "connected"
-        self._connected_event.set()
-        self._connection_attempt_event.set()
         self._protocol_handshake = None
-        if self._reporting_mode == "periodic":
-            self._start_periodic_report_loop()
         session_state = self._protocol_session.state
         self._diagnostics.record_event(
             "protocol_ready",
@@ -965,6 +990,50 @@ class ControllerRuntime:
             route=self._connection_route,
             observed_subcommands=_format_subcommands(session_state.observed_subcommands),
         )
+        if self._reporting_mode == "direct":
+            self._publish_input_ready()
+            return
+        if self._input_readiness_task is not None:
+            return
+        self._input_readiness_task = asyncio.create_task(
+            self._complete_periodic_input_readiness(),
+            name="swbt-input-readiness",
+        )
+
+    async def _complete_periodic_input_readiness(self) -> None:
+        task = asyncio.current_task()
+        sender = self._require_report_sender()
+        try:
+            await sender.wait_until_automatic_input_ready()
+            if (
+                self._close_in_progress
+                or self._connection_attempt_event.is_set()
+                or self._report_sender is not sender
+            ):
+                return
+            self._start_periodic_report_loop()
+            self._publish_input_ready()
+        except asyncio.CancelledError:
+            raise
+        except Exception as error:  # noqa: BLE001
+            if not self._close_in_progress:
+                self._record_protocol_initialization_failure(error)
+        finally:
+            if self._input_readiness_task is task:
+                self._input_readiness_task = None
+
+    def _publish_input_ready(self) -> None:
+        if self._connected_event.is_set() or self._connection_attempt_event.is_set():
+            return
+        self._connection_state = "connected"
+        self._connected_event.set()
+        self._connection_attempt_event.set()
+        self._diagnostics.record_event(
+            "input_ready",
+            profile_kind=self._controller_profile.kind.value,
+            reporting_mode=self._reporting_mode,
+            route=self._connection_route,
+        )
 
     async def _fail_protocol_initialization(self, error: Exception) -> None:
         if self._protocol_handshake is not None:
@@ -987,7 +1056,7 @@ class ControllerRuntime:
             profile_kind=self._controller_profile.kind.value,
             report_mode=_format_optional_byte(self._protocol_session.state.report_mode),
             route=self._connection_route,
-            stage="protocol_initialization",
+            stage=self._connection_readiness_stage(),
         )
         self._diagnostics.record_error(error, recoverable=False)
 
@@ -999,7 +1068,7 @@ class ControllerRuntime:
             and not self._connection_attempt_event.is_set()
             and not self._close_in_progress
         ):
-            msg = "disconnected before protocol initialization completed"
+            msg = "disconnected before connection initialization completed"
             handshake_failure = ConnectionFailedError(msg)
             if self._protocol_handshake is not None:
                 self._protocol_handshake.fail(handshake_failure)
@@ -1014,6 +1083,7 @@ class ControllerRuntime:
                 self._protocol_handshake = None
             else:
                 await self._stop_protocol_handshake()
+            await self._stop_input_readiness_wait()
             if self._report_loop is not None:
                 await self._report_loop.stop()
                 self._report_loop = None

swbt/report_loop.py

@@ -34,6 +34,7 @@ class ReportSender:
         diagnostics: DiagnosticsRecorder | None = None,
         clock_ns: Callable[[], int] = monotonic_ns,
         monotonic_time: Callable[[], float] = monotonic,
+        _sleep: Callable[[float], Awaitable[None]] = asyncio.sleep,
     ) -> None:
         """Create a session-scoped serialized report sender."""
         self._transport = transport
@@ -42,6 +43,7 @@ class ReportSender:
         self._diagnostics = diagnostics
         self._clock_ns = clock_ns
         self._monotonic_time = monotonic_time
+        self._sleep = _sleep
         self._timer = 0
         self._send_lock = asyncio.Lock()
         self._automatic_input_holdoff_until = 0.0
@@ -80,6 +82,15 @@ class ReportSender:
             await self._send_input_locked(state, reason=reason)
             return True
 
+    async def wait_until_automatic_input_ready(self) -> None:
+        """Wait until automatic input is no longer held off by an accepted reply."""
+        while True:
+            async with self._send_lock:
+                remaining = self._automatic_input_holdoff_until - self._monotonic_time()
+                if remaining <= 0:
+                    return
+            await self._sleep(remaining)
+
     async def send_subcommand_reply(self, build_report: ReplyBuilder) -> bytes:
         """Build and send a subcommand reply under the shared send lock."""
         async with self._send_lock:

swbt/transport/_bumble_acl.py

@@ -1,33 +1,17 @@
-"""ACL queue drain helper for Bumble HID transport."""
+"""ACL queue drain helper for the pinned Bumble HID transport."""
 
-from collections.abc import Awaitable
+from typing import Any, cast
 
 
 async def drain_bumble_acl_queue(l2cap_channel: object) -> None:
-    """Wait until Bumble reports no pending ACL packets for the channel."""
-    connection = getattr(l2cap_channel, "connection", None)
-    connection_handle = getattr(connection, "handle", None)
-    acl_packet_queue = getattr(connection, "acl_packet_queue", None)
-    if acl_packet_queue is None and isinstance(connection_handle, int):
-        device = getattr(connection, "device", None)
-        host = getattr(device, "host", None)
-        get_data_packet_queue = getattr(host, "get_data_packet_queue", None)
-        if callable(get_data_packet_queue):
-            acl_packet_queue = get_data_packet_queue(connection_handle)
-    drain = getattr(acl_packet_queue, "drain", None)
-    if not isinstance(connection_handle, int) or not callable(drain):
+    """Wait for the pinned Bumble connection's pending ACL packets to complete."""
+    channel = cast("Any", l2cap_channel)
+    connection = channel.connection
+    acl_packet_queue = connection.device.host.get_data_packet_queue(connection.handle)
+    if acl_packet_queue is None:
         return
     try:
-        last_pending: int | None = None
-        while True:
-            pending = getattr(acl_packet_queue, "pending", 0)
-            if not isinstance(pending, int) or pending <= 0 or pending == last_pending:
-                return
-            last_pending = pending
-            drain_result = drain(connection_handle)
-            if isinstance(drain_result, Awaitable):
-                await drain_result
-                continue
-            return
+        await acl_packet_queue.drain(connection.handle)
     except ValueError:
+        # Bumble raises when the queue has no state for a channel that was already drained.
         return

swbt/transport/_bumble_key_store.py

@@ -9,11 +9,9 @@ from swbt.diagnostics import DiagnosticsRecorder
 from swbt.errors import InvalidKeyStoreError
 from swbt.transport._pairing_profile import KeyStoreNamespaces, PairingProfile
 
-PREVIOUS_NAMESPACE_PREFIX = "swbt.previous::"
-
 
 class _PairingProfileKeyStore:
-    """Bumble-compatible profile key store with one previous generation."""
+    """Bumble-compatible profile key store for the current namespace."""
 
     def __init__(
         self,
@@ -24,7 +22,6 @@ class _PairingProfileKeyStore:
         self._profile_path = Path(profile_path)
         self._namespace = namespace if isinstance(namespace, str) else None
         self._namespace_resolver = None if isinstance(namespace, str) else namespace
-        self.last_update_previous_saved = False
 
     def _resolve_namespace(self) -> str:
         namespace = (
@@ -36,16 +33,9 @@ class _PairingProfileKeyStore:
         return namespace
 
     async def update(self, name: str, keys: object) -> None:
-        """Write current keys and keep the overwritten current value as previous."""
+        """Replace the current namespace with one peer's keys."""
         current_store = self._current_store()
         db, current_key_map = await current_store.load()
-        previous_namespace = self._previous_namespace(current_store)
-        previous_key_map = copy.deepcopy(current_key_map)
-        self.last_update_previous_saved = bool(previous_key_map)
-        if previous_key_map:
-            db[previous_namespace] = previous_key_map
-        else:
-            db.pop(previous_namespace, None)
         current_key_map.clear()
         current_key_map[name] = cast("Any", keys).to_dict()
         await current_store.save(db)
@@ -84,10 +74,6 @@ class _PairingProfileKeyStore:
             adapter_default=self._namespace_resolver is not None,
         )
 
-    @staticmethod
-    def _previous_namespace(current_store: "_PairingProfileNamespaceStore") -> str:
-        return f"{PREVIOUS_NAMESPACE_PREFIX}{current_store.namespace}"
-
 
 class _PairingProfileNamespaceStore:
     """JsonKeyStore-compatible view over one profile namespace map."""
@@ -169,20 +155,16 @@ class _DiagnosticKeyStore:
         try:
             await cast("Any", self._key_store).update(name, keys)
         except Exception as error:
-            fields = self._generation_fields()
             self._diagnostics.record_event(
                 "key_store_update",
-                **fields,
                 error_type=type(error).__name__,
                 message=str(error),
                 peer_address=name,
                 status="failed",
             )
             raise
-        fields = self._generation_fields()
         self._diagnostics.record_event(
             "key_store_update",
-            **fields,
             peer_address=name,
             status="succeeded",
         )
@@ -209,11 +191,3 @@ class _DiagnosticKeyStore:
 
     def __getattr__(self, name: str) -> object:
         return getattr(self._key_store, name)
-
-    def _generation_fields(self) -> dict[str, object]:
-        if not isinstance(self._key_store, _PairingProfileKeyStore):
-            return {}
-        return {
-            "generation": "current",
-            "previous_saved": self._key_store.last_update_previous_saved,
-        }

swbt/transport/_bumble_lifecycle.py

@@ -25,20 +25,19 @@ class ConnectionDiagnostics:
         self._record_event = record_event
 
     def register(self, connection: object) -> None:
-        """Register all connection diagnostics callbacks supported by the connection."""
-        on_event = getattr(connection, "on", None)
-        if not callable(on_event):
-            return
+        """Register all diagnostics callbacks provided by Bumble 0.0.233."""
+        connection_with_attrs = cast("Any", connection)
+        on_event = connection_with_attrs.on
         on_event(
-            getattr(connection, "EVENT_DISCONNECTION", "disconnection"),
+            connection_with_attrs.EVENT_DISCONNECTION,
             self._handle_disconnection,
         )
         on_event(
-            getattr(connection, "EVENT_CLASSIC_PAIRING", "classic_pairing"),
+            connection_with_attrs.EVENT_CLASSIC_PAIRING,
             lambda *_args: self._record_event("classic_pairing", adapter=self._adapter),
         )
         on_event(
-            getattr(connection, "EVENT_CLASSIC_PAIRING_FAILURE", "classic_pairing_failure"),
+            connection_with_attrs.EVENT_CLASSIC_PAIRING_FAILURE,
             lambda reason=None, *_args: self._record_event(
                 "classic_pairing_failure",
                 adapter=self._adapter,
@@ -46,15 +45,15 @@ class ConnectionDiagnostics:
             ),
         )
         on_event(
-            getattr(connection, "EVENT_PAIRING_START", "pairing_start"),
+            connection_with_attrs.EVENT_PAIRING_START,
             lambda *_args: self._record_event("pairing_start", adapter=self._adapter),
         )
         on_event(
-            getattr(connection, "EVENT_PAIRING", "pairing"),
+            connection_with_attrs.EVENT_PAIRING,
             lambda keys=None, *_args: self._record_pairing_complete(connection, keys),
         )
         on_event(
-            getattr(connection, "EVENT_PAIRING_FAILURE", "pairing_failure"),
+            connection_with_attrs.EVENT_PAIRING_FAILURE,
             lambda reason=None, *_args: self._record_event(
                 "pairing_failure",
                 adapter=self._adapter,
@@ -62,15 +61,11 @@ class ConnectionDiagnostics:
             ),
         )
         on_event(
-            getattr(connection, "EVENT_CONNECTION_AUTHENTICATION", "connection_authentication"),
+            connection_with_attrs.EVENT_CONNECTION_AUTHENTICATION,
             lambda *_args: self._record_connection_authentication(connection),
         )
         on_event(
-            getattr(
-                connection,
-                "EVENT_CONNECTION_AUTHENTICATION_FAILURE",
-                "connection_authentication_failure",
-            ),
+            connection_with_attrs.EVENT_CONNECTION_AUTHENTICATION_FAILURE,
             lambda error=None, *_args: self._record_event(
                 "connection_authentication_failure",
                 adapter=self._adapter,
@@ -78,19 +73,11 @@ class ConnectionDiagnostics:
             ),
         )
         on_event(
-            getattr(
-                connection,
-                "EVENT_CONNECTION_ENCRYPTION_CHANGE",
-                "connection_encryption_change",
-            ),
+            connection_with_attrs.EVENT_CONNECTION_ENCRYPTION_CHANGE,
             lambda *_args: self._record_connection_encryption_change(connection),
         )
         on_event(
-            getattr(
-                connection,
-                "EVENT_CONNECTION_ENCRYPTION_FAILURE",
-                "connection_encryption_failure",
-            ),
+            connection_with_attrs.EVENT_CONNECTION_ENCRYPTION_FAILURE,
             lambda error=None, *_args: self._record_event(
                 "connection_encryption_failure",
                 adapter=self._adapter,
@@ -98,23 +85,19 @@ class ConnectionDiagnostics:
             ),
         )
         on_event(
-            getattr(
-                connection,
-                "EVENT_CONNECTION_ENCRYPTION_KEY_REFRESH",
-                "connection_encryption_key_refresh",
-            ),
+            connection_with_attrs.EVENT_CONNECTION_ENCRYPTION_KEY_REFRESH,
             lambda *_args: self._record_connection_encryption_refresh(connection),
         )
         on_event(
-            getattr(connection, "EVENT_LINK_KEY", "link_key"),
+            connection_with_attrs.EVENT_LINK_KEY,
             lambda *_args: self._record_event("link_key_available", adapter=self._adapter),
         )
         on_event(
-            getattr(connection, "EVENT_MODE_CHANGE", "mode_change"),
+            connection_with_attrs.EVENT_MODE_CHANGE,
             lambda *_args: self._record_classic_mode_change(connection),
         )
         on_event(
-            getattr(connection, "EVENT_MODE_CHANGE_FAILURE", "mode_change_failure"),
+            connection_with_attrs.EVENT_MODE_CHANGE_FAILURE,
             lambda status=None, *_args: self._record_event(
                 "classic_mode_change_failure",
                 adapter=self._adapter,
@@ -179,7 +162,8 @@ def register_connection_request_bridge(
     record_event: EventRecorder,
 ) -> None:
     """Wrap Bumble's connection request callback while avoiding deprecated sync APIs."""
-    original_connection_request = cast("Any", device).on_connection_request
+    device_with_attrs = cast("Any", device)
+    original_connection_request = device_with_attrs.on_connection_request
 
     def on_connection_request(
         bd_addr: object,
@@ -201,7 +185,6 @@ def register_connection_request_bridge(
             link_type,
         )
 
-    device_with_attrs = cast("Any", device)
     device_with_attrs.on_connection_request = on_connection_request
     replace_host_connection_request_listener(
         device,
@@ -267,24 +250,18 @@ def call_connection_request_without_deprecated_sync_command(
     link_type: int,
 ) -> None:
     """Run Bumble's connection request handler without its deprecated sync helper."""
-    host = getattr(device, "host", None)
-    send_async_command = getattr(host, "send_async_command", None)
-    if host is None or not callable(send_async_command):
-        connection_request(bd_addr, class_of_device, link_type)
-        return
+    device_with_attrs = cast("Any", device)
+    host = device_with_attrs.host
 
     from bumble import utils  # noqa: PLC0415
 
     missing = object()
-    host_dict = getattr(host, "__dict__", None)
-    previous_instance_attr = (
-        host_dict.get("send_command_sync", missing) if isinstance(host_dict, dict) else missing
-    )
+    previous_instance_attr = host.__dict__.get("send_command_sync", missing)
 
     def send_command_sync(command: object) -> None:
-        utils.AsyncRunner.spawn(send_async_command(command))
+        utils.AsyncRunner.spawn(host.send_async_command(command))
 
-    host_with_attrs = cast("Any", host)
+    host_with_attrs = host
     host_with_attrs.send_command_sync = send_command_sync
     try:
         connection_request(bd_addr, class_of_device, link_type)
@@ -300,12 +277,9 @@ def replace_host_connection_request_listener(
     original_connection_request: Callable[[object, int, int], None],
     replacement_connection_request: Callable[[object, int, int], None],
 ) -> None:
-    host = getattr(device, "host", None)
-    remove_listener = getattr(host, "remove_listener", None)
-    on = getattr(host, "on", None)
-    if not callable(remove_listener) or not callable(on):
-        return
+    device_with_attrs = cast("Any", device)
+    host = device_with_attrs.host
 
     with suppress(KeyError, ValueError):
-        remove_listener("connection_request", original_connection_request)
-    on("connection_request", replacement_connection_request)
+        host.remove_listener("connection_request", original_connection_request)
+    host.on("connection_request", replacement_connection_request)

swbt/transport/_pairing_profile.py

@@ -16,7 +16,7 @@ _ADDRESS_PATTERN = re.compile(r"(?:[0-9A-Fa-f]{2}:){5}[0-9A-Fa-f]{2}")
 _RESERVED_INQUIRY_LAP_MIN = 0x9E8B00
 _RESERVED_INQUIRY_LAP_MAX = 0x9E8B3F
 _PROFILE_FORMAT = "swbt.profile"
-_PROFILE_SCHEMA_VERSION = 1
+_PROFILE_SCHEMA_VERSION = 2
 _PROFILE_LOCAL_ADDRESS_IDENTITY_KIND = "exp-local-address"
 _PROFILE_ADAPTER_DEFAULT_IDENTITY_KIND = "adapter-default"
 _CONTROLLER_KINDS_BY_PROFILE_VALUE: dict[str, ControllerKind] = {
@@ -79,7 +79,7 @@ class LocalAddress:
 
 @dataclass(frozen=True)
 class PairingProfile:
-    """Validated version 1 envelope for one controller shape and its pairing data."""
+    """Validated version 2 envelope for one controller shape and its pairing data."""
 
     local_address: LocalAddress | None
     key_store_namespaces: KeyStoreNamespaces
@@ -97,14 +97,7 @@ class PairingProfile:
         address = None if local_address is None else str(local_address)
         profile = cls(
             local_address=local_address,
-            key_store_namespaces=(
-                {}
-                if address is None
-                else {
-                    address: {},
-                    f"swbt.previous::{address}": {},
-                }
-            ),
+            key_store_namespaces=({} if address is None else {address: {}}),
             controller_kind=controller_kind,
         )
         target = Path(path)
@@ -200,7 +193,10 @@ class PairingProfile:
         if payload.get("format") != _PROFILE_FORMAT:
             _invalid_profile("profile format is unsupported")
         if payload.get("schema_version") != _PROFILE_SCHEMA_VERSION:
-            _invalid_profile("profile schema_version is unsupported")
+            _invalid_profile(
+                "profile schema_version is unsupported; create a new schema v2 profile "
+                "and pair again"
+            )
         controller_kind_value = payload.get("controller_kind")
         if not isinstance(controller_kind_value, str):
             _invalid_profile("profile controller_kind is unsupported")

swbt/transport/bumble.py

@@ -132,6 +132,12 @@ class _BumbleHidRuntime(Protocol):
     def send_data(self, data: bytes) -> None:
         """Send an interrupt-channel HID data message."""
 
+    def register_set_report_cb(
+        self,
+        callback: Callable[[int, int, int, bytes], _BumbleGetSetStatus],
+    ) -> None:
+        """Register a HID SET_REPORT callback."""
+
     async def connect_control_channel(self) -> None:
         """Request control-channel L2CAP connection."""
 
@@ -455,10 +461,6 @@ class BumbleHidTransport:
         self._register_set_report_callback(hid_device)
 
     def _register_set_report_callback(self, hid_device: _BumbleHidRuntime) -> None:
-        register_set_report = getattr(hid_device, "register_set_report_cb", None)
-        if not callable(register_set_report):
-            return
-
         def on_set_report(
             report_id: int,
             report_type: int,
@@ -475,7 +477,7 @@ class BumbleHidTransport:
                 return _BumbleGetSetStatus(status=HID_GET_SET_UNSUPPORTED_REQUEST)
             return _BumbleGetSetStatus(status=HID_GET_SET_SUCCESS)
 
-        register_set_report(on_set_report)
+        hid_device.register_set_report_cb(on_set_report)
 
     def _register_device_callbacks(self, device: _BumbleDeviceRuntime) -> None:
         device.on(device.EVENT_CONNECTION, self._handle_device_connection)
@@ -840,8 +842,7 @@ def _device_info_bluetooth_address_from_bumble_address(address: object) -> bytes
     """Return Device Info address bytes from a Bumble address object."""
     if address is None:
         return None
-    to_string = getattr(address, "to_string", None)
-    address_text = str(to_string(False)) if callable(to_string) else str(address)
+    address_text = str(cast("Any", address).to_string(False))
     address_text = address_text.split("/", 1)[0]
     parts = address_text.split(":")
     if len(parts) != 6 or any(len(part) != 2 for part in parts):

{swbt_python-0.5.2.dist-info → swbt_python-0.5.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: swbt-python
-Version: 0.5.2
+Version: 0.5.4
 Summary: Python library for presenting an NX-compatible virtual Bluetooth HID input device.
 Keywords: bluetooth,bluetooth-hid,controller,gamepad,hid,nx
 Author: niart120
@@ -18,7 +18,7 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Software Development :: Libraries
 Classifier: Typing :: Typed
-Requires-Dist: bumble>=0.0.230,<0.0.231
+Requires-Dist: bumble==0.0.233
 Maintainer: niart120
 Maintainer-email: niart120 <38847256+niart120@users.noreply.github.com>
 Requires-Python: >=3.12

{swbt_python-0.5.2.dist-info → swbt_python-0.5.4.dist-info}/RECORD

@@ -7,10 +7,10 @@ swbt/gamepad/_config.py,sha256=VjYrR4erPhEohjZ1Pw5ElxryNEa8dRfsKhz2EsjpEUs,2050
 swbt/gamepad/connection.py,sha256=8EUeKYvdV_n1OIq11MFAVNhKmIbJHUoijaK6xUx6Y4g,753
 swbt/gamepad/constants.py,sha256=gDesRFvVxZ3SMSiP4qzd42em_Dt9M5hIu3-2exgKEus,84
 swbt/gamepad/controllers.py,sha256=G6EMi82F_36wSi2pm5QMFLJSZSakRogVcDeygqJJ8gI,7487
-swbt/gamepad/interface.py,sha256=quHOOj5nWzBz_W3qYMBEWglo-3zR_I9zxNqlA7HznGI,17525
+swbt/gamepad/interface.py,sha256=HWABzdzrVPAumTZPOrUjiku-mKvAPIhqTE-pvqAIgSU,17793
 swbt/gamepad/output.py,sha256=NeOp-NwYshEkuelge_POwk_i7orqOQc4SXm9t9Njs1s,5361
 swbt/gamepad/protocol_handshake.py,sha256=9vAdE0PIpSpWk9oXhStOTq0XxDlE8DejE1SLBh21rx4,6217
-swbt/gamepad/runtime.py,sha256=7QrhoqyHx5jy9cjnlNUlJ4xxnQp5_vxfE2SVGZ1Dvtk,44102
+swbt/gamepad/runtime.py,sha256=HVuhQxPtpVpcyxVo2RnWOM5Vkmn2kc9NjhJ9PPWwG4o,47170
 swbt/gamepad/transport_factory.py,sha256=0eiC-HqtNG0CJuHR8TlSPWtpInW03A4ojnBccqpryN0,921
 swbt/imu.py,sha256=sT1_MsYECQlQ-pSfayD8gojD9l3w9zEtOI3xP1IovQM,4237
 swbt/input.py,sha256=7gv75lzrcmoV8Sijz7f1pvsheRrmUi_TCIMW3DjUVjw,22275
@@ -30,24 +30,24 @@ swbt/protocol/session.py,sha256=SVkF0jaJPbnKCAWswRQsrdoCxZwjHPEMz4lktVBcXc4,4811
 swbt/protocol/spi.py,sha256=buKyNYYOHOSYbpVh3Wa2968FL4VIO_43QcSXNowNfJs,2594
 swbt/protocol/subcommand.py,sha256=NRtp9-lB8IBimC0kO8oyJnel_qSSPx65XlmGWTARB0E,8662
 swbt/py.typed,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-swbt/report_loop.py,sha256=jEnwlxdWQgPwbIXvJfyhgMaJdrGYLNYzlZNotOMKiKw,7853
+swbt/report_loop.py,sha256=zGaKStCsupzkmSTF8YZOL9H2DbH1Nf15yHtI3POJiTY,8350
 swbt/state_store.py,sha256=jE1TeNpqynbVpxFp0Xt3m1Dfl1LUKR-uqV4f14qntuM,1402
 swbt/transport/__init__.py,sha256=b_Vqsg0k_g7XclN9XHQrcJxqCwGIklxG5NqzISal4_I,68
 swbt/transport/_adapter_identity.py,sha256=xOECQBlGAZJoyKrfxrIPt88kXoksHWmWzzVo1-x5XmA,6621
-swbt/transport/_bumble_acl.py,sha256=RnueTwEgAd0w3YgxnXkw0AKQXMeECIRope96W-xQ1K8,1425
+swbt/transport/_bumble_acl.py,sha256=tZalNxNSKEsTB6WD4wEOyqEY-Td6s5wg2s_3Ve5UOqI,653
 swbt/transport/_bumble_hidp.py,sha256=mL_eT-otopHzg5G0p7uhqTYsqSuDwdXAiAwakQiHbCY,835
-swbt/transport/_bumble_key_store.py,sha256=j5fQtmnxlVk6DBPvdu7LIqu2-QCyGrvs1WoZZIj1Z-E,7986
-swbt/transport/_bumble_lifecycle.py,sha256=DHEMbZOfRLHD9jF62c2zLAn-TuFLk-8WzE1OdTSxoKI,11187
+swbt/transport/_bumble_key_store.py,sha256=d7IJ9537QRruvy4aOyVtK7RsOOnjuJ7hKmiYTt7gC_I,6938
+swbt/transport/_bumble_lifecycle.py,sha256=9NgXzyW3g2s91gPcsDuyzS9-rAp64ahDKk9fb3VJLDg,10174
 swbt/transport/_bumble_sdp.py,sha256=RtVgNI3EFi0-cIbiNqrLUi0A2Ju513kF-JWmFlkuvi4,9254
 swbt/transport/_bumble_usb_devices.py,sha256=soAKiHTzeeTYdb7M357yaac-RxG2c_BiKWH9NK9zJFY,894
 swbt/transport/_csr_bd_addr.py,sha256=FNc7y9SvEXhHyChZ8I4zgC-LyduiddLqt-HM_Ux2QXA,7949
 swbt/transport/_csr_bd_addr_harness.py,sha256=aSuFCVbneRENveN_b3CuamD7R9Wqf3CKRNU6Zcdxvpc,10297
-swbt/transport/_pairing_profile.py,sha256=ure-PK8gCnAtW_lRFjZgQyuKxYwP0fAOJpryHZR6pnM,9400
+swbt/transport/_pairing_profile.py,sha256=95tISeYHnllHfFpNs0oBsaYb5uAffXfi9eFkjb-EeFQ,9342
 swbt/transport/base.py,sha256=eI0hs1wTwJf2ppzqda4ok-tUXF1hE9dwpb0p-lpvwmo,5163
-swbt/transport/bumble.py,sha256=ntbaXuWRB5_PJMlN52pVWrgIMg4JK8S9jhv65T9dHmo,33435
+swbt/transport/bumble.py,sha256=VufUEo4aUeVebSFvZPJaVe_G7nNz5fKQMCbjgqmBbRs,33414
 swbt/transport/fake.py,sha256=4O5zlsg1TO61Ai54FGCn_xM8TEA9yi938Fso-XHdh1w,12891
-swbt_python-0.5.2.dist-info/licenses/LICENSE,sha256=FzzUoYjuIh5DzpeaujIbDUTylYnyzcHRVU-_ZMyowyk,1065
-swbt_python-0.5.2.dist-info/WHEEL,sha256=uOqnPWqgFlbov4NeTCercq7cBQ2UN7xh5fiW55lOnAg,81
-swbt_python-0.5.2.dist-info/entry_points.txt,sha256=YYQc7VgoSy74iZ6s8Qr6iJpnvFoDpp8G4-v0KJH5TGo,48
-swbt_python-0.5.2.dist-info/METADATA,sha256=w2O422wacUqZ5_ImxW4aSNfEeMKSPW2CetEbau6LlKU,5911
-swbt_python-0.5.2.dist-info/RECORD,,
+swbt_python-0.5.4.dist-info/licenses/LICENSE,sha256=FzzUoYjuIh5DzpeaujIbDUTylYnyzcHRVU-_ZMyowyk,1065
+swbt_python-0.5.4.dist-info/WHEEL,sha256=uOqnPWqgFlbov4NeTCercq7cBQ2UN7xh5fiW55lOnAg,81
+swbt_python-0.5.4.dist-info/entry_points.txt,sha256=YYQc7VgoSy74iZ6s8Qr6iJpnvFoDpp8G4-v0KJH5TGo,48
+swbt_python-0.5.4.dist-info/METADATA,sha256=Av__75M0-iYeeo-cBzL2FB2zO1ktEN4CCw6YZHA_ufA,5902
+swbt_python-0.5.4.dist-info/RECORD,,