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

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.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: swbt-python
-Version: 0.5.2
+Version: 0.5.3
 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.3.dist-info}/RECORD

@@ -34,20 +34,20 @@ swbt/report_loop.py,sha256=jEnwlxdWQgPwbIXvJfyhgMaJdrGYLNYzlZNotOMKiKw,7853
 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.3.dist-info/licenses/LICENSE,sha256=FzzUoYjuIh5DzpeaujIbDUTylYnyzcHRVU-_ZMyowyk,1065
+swbt_python-0.5.3.dist-info/WHEEL,sha256=uOqnPWqgFlbov4NeTCercq7cBQ2UN7xh5fiW55lOnAg,81
+swbt_python-0.5.3.dist-info/entry_points.txt,sha256=YYQc7VgoSy74iZ6s8Qr6iJpnvFoDpp8G4-v0KJH5TGo,48
+swbt_python-0.5.3.dist-info/METADATA,sha256=W59IobyxaCz0_nIchUTIqNv24T9XjR9d7CuarGeItW0,5902
+swbt_python-0.5.3.dist-info/RECORD,,