bumble 0.0.212__py3-none-any.whl → 0.0.214__py3-none-any.whl

bumble/profiles/hap.py

@@ -20,7 +20,7 @@ import asyncio
 import functools
 from dataclasses import dataclass, field
 import logging
-from typing import Any, Dict, List, Optional, Set, Union
+from typing import Any, Optional, Union
 
 from bumble import att, gatt, gatt_adapters, gatt_client
 from bumble.core import InvalidArgumentError, InvalidStateError
@@ -228,23 +228,25 @@ class HearingAccessService(gatt.TemplateService):
     hearing_aid_preset_control_point: gatt.Characteristic[bytes]
     active_preset_index_characteristic: gatt.Characteristic[bytes]
     active_preset_index: int
-    active_preset_index_per_device: Dict[Address, int]
+    active_preset_index_per_device: dict[Address, int]
 
     device: Device
 
     server_features: HearingAidFeatures
-    preset_records: Dict[int, PresetRecord]  # key is the preset index
+    preset_records: dict[int, PresetRecord]  # key is the preset index
     read_presets_request_in_progress: bool
 
-    preset_changed_operations_history_per_device: Dict[
-        Address, List[PresetChangedOperation]
+    other_server_in_binaural_set: Optional[HearingAccessService] = None
+
+    preset_changed_operations_history_per_device: dict[
+        Address, list[PresetChangedOperation]
     ]
 
     # Keep an updated list of connected client to send notification to
-    currently_connected_clients: Set[Connection]
+    currently_connected_clients: set[Connection]
 
     def __init__(
-        self, device: Device, features: HearingAidFeatures, presets: List[PresetRecord]
+        self, device: Device, features: HearingAidFeatures, presets: list[PresetRecord]
     ) -> None:
         self.active_preset_index_per_device = {}
         self.read_presets_request_in_progress = False
@@ -333,7 +335,7 @@ class HearingAccessService(gatt.TemplateService):
             # Update the active preset index if needed
             await self.notify_active_preset_for_connection(connection)
 
-        utils.cancel_on_event(connection, 'disconnection', on_connection_async())
+        connection.cancel_on_disconnection(on_connection_async())
 
     def _on_read_active_preset_index(self, connection: Connection) -> bytes:
         del connection  # Unused
@@ -379,7 +381,7 @@ class HearingAccessService(gatt.TemplateService):
         utils.AsyncRunner.spawn(self._read_preset_response(connection, presets))
 
     async def _read_preset_response(
-        self, connection: Connection, presets: List[PresetRecord]
+        self, connection: Connection, presets: list[PresetRecord]
     ):
         # If the ATT bearer is terminated before all notifications or indications are sent, then the server shall consider the Read Presets Request operation aborted and shall not either continue or restart the operation when the client reconnects.
         try:
@@ -513,7 +515,7 @@ class HearingAccessService(gatt.TemplateService):
         for connection in self.currently_connected_clients:
             await self.notify_active_preset_for_connection(connection)
 
-    async def set_active_preset(self, connection: Connection, value: bytes) -> None:
+    async def set_active_preset(self, value: bytes) -> None:
         index = value[1]
         preset = self.preset_records.get(index, None)
         if (
@@ -530,10 +532,10 @@ class HearingAccessService(gatt.TemplateService):
         self.active_preset_index = index
         await self.notify_active_preset()
 
-    async def _on_set_active_preset(self, connection: Connection, value: bytes):
-        await self.set_active_preset(connection, value)
+    async def _on_set_active_preset(self, _: Connection, value: bytes):
+        await self.set_active_preset(value)
 
-    async def set_next_or_previous_preset(self, connection: Connection, is_previous):
+    async def set_next_or_previous_preset(self, is_previous):
         '''Set the next or the previous preset as active'''
 
         if self.active_preset_index == 0x00:
@@ -563,48 +565,47 @@ class HearingAccessService(gatt.TemplateService):
             self.active_preset_index = first_preset.index
         await self.notify_active_preset()
 
-    async def _on_set_next_preset(
-        self, connection: Connection, __value__: bytes
-    ) -> None:
-        await self.set_next_or_previous_preset(connection, False)
+    async def _on_set_next_preset(self, _: Connection, __value__: bytes) -> None:
+        await self.set_next_or_previous_preset(False)
 
-    async def _on_set_previous_preset(
-        self, connection: Connection, __value__: bytes
-    ) -> None:
-        await self.set_next_or_previous_preset(connection, True)
+    async def _on_set_previous_preset(self, _: Connection, __value__: bytes) -> None:
+        await self.set_next_or_previous_preset(True)
 
     async def _on_set_active_preset_synchronized_locally(
-        self, connection: Connection, value: bytes
+        self, _: Connection, value: bytes
     ):
         if (
             self.server_features.preset_synchronization_support
-            == PresetSynchronizationSupport.PRESET_SYNCHRONIZATION_IS_SUPPORTED
+            == PresetSynchronizationSupport.PRESET_SYNCHRONIZATION_IS_NOT_SUPPORTED
         ):
             raise att.ATT_Error(ErrorCode.PRESET_SYNCHRONIZATION_NOT_SUPPORTED)
-        await self.set_active_preset(connection, value)
-        # TODO (low priority) inform other server of the change
+        await self.set_active_preset(value)
+        if self.other_server_in_binaural_set:
+            await self.other_server_in_binaural_set.set_active_preset(value)
 
     async def _on_set_next_preset_synchronized_locally(
-        self, connection: Connection, __value__: bytes
+        self, _: Connection, __value__: bytes
     ):
         if (
             self.server_features.preset_synchronization_support
-            == PresetSynchronizationSupport.PRESET_SYNCHRONIZATION_IS_SUPPORTED
+            == PresetSynchronizationSupport.PRESET_SYNCHRONIZATION_IS_NOT_SUPPORTED
         ):
             raise att.ATT_Error(ErrorCode.PRESET_SYNCHRONIZATION_NOT_SUPPORTED)
-        await self.set_next_or_previous_preset(connection, False)
-        # TODO (low priority) inform other server of the change
+        await self.set_next_or_previous_preset(False)
+        if self.other_server_in_binaural_set:
+            await self.other_server_in_binaural_set.set_next_or_previous_preset(False)
 
     async def _on_set_previous_preset_synchronized_locally(
-        self, connection: Connection, __value__: bytes
+        self, _: Connection, __value__: bytes
     ):
         if (
             self.server_features.preset_synchronization_support
-            == PresetSynchronizationSupport.PRESET_SYNCHRONIZATION_IS_SUPPORTED
+            == PresetSynchronizationSupport.PRESET_SYNCHRONIZATION_IS_NOT_SUPPORTED
         ):
             raise att.ATT_Error(ErrorCode.PRESET_SYNCHRONIZATION_NOT_SUPPORTED)
-        await self.set_next_or_previous_preset(connection, True)
-        # TODO (low priority) inform other server of the change
+        await self.set_next_or_previous_preset(True)
+        if self.other_server_in_binaural_set:
+            await self.other_server_in_binaural_set.set_next_or_previous_preset(True)
 
 
 # -----------------------------------------------------------------------------

bumble/profiles/le_audio.py

@@ -19,7 +19,7 @@ from __future__ import annotations
 import dataclasses
 import enum
 import struct
-from typing import Any, List, Type
+from typing import Any
 from typing_extensions import Self
 
 from bumble.profiles import bap
@@ -108,13 +108,13 @@ class Metadata:
             return self.data
 
         @classmethod
-        def from_bytes(cls: Type[Self], data: bytes) -> Self:
+        def from_bytes(cls: type[Self], data: bytes) -> Self:
             return cls(tag=Metadata.Tag(data[0]), data=data[1:])
 
         def __bytes__(self) -> bytes:
             return bytes([len(self.data) + 1, self.tag]) + self.data
 
-    entries: List[Entry] = dataclasses.field(default_factory=list)
+    entries: list[Entry] = dataclasses.field(default_factory=list)
 
     def pretty_print(self, indent: str) -> str:
         """Convenience method to generate a string with one key-value pair per line."""
@@ -140,7 +140,7 @@ class Metadata:
         )
 
     @classmethod
-    def from_bytes(cls: Type[Self], data: bytes) -> Self:
+    def from_bytes(cls: type[Self], data: bytes) -> Self:
         entries = []
         offset = 0
         length = len(data)

bumble/profiles/mcp.py

@@ -29,7 +29,7 @@ from bumble import gatt
 from bumble import gatt_client
 from bumble import utils
 
-from typing import Type, Optional, ClassVar, Dict, TYPE_CHECKING
+from typing import Optional, ClassVar, TYPE_CHECKING
 from typing_extensions import Self
 
 # -----------------------------------------------------------------------------
@@ -167,7 +167,7 @@ class ObjectId(int):
     '''See Media Control Service 4.4.2. Object ID field.'''
 
     @classmethod
-    def create_from_bytes(cls: Type[Self], data: bytes) -> Self:
+    def create_from_bytes(cls: type[Self], data: bytes) -> Self:
         return cls(int.from_bytes(data, byteorder='little', signed=False))
 
     def __bytes__(self) -> bytes:
@@ -182,7 +182,7 @@ class GroupObjectType:
     object_id: ObjectId
 
     @classmethod
-    def from_bytes(cls: Type[Self], data: bytes) -> Self:
+    def from_bytes(cls: type[Self], data: bytes) -> Self:
         return cls(
             object_type=ObjectType(data[0]),
             object_id=ObjectId.create_from_bytes(data[1:]),
@@ -310,7 +310,7 @@ class MediaControlServiceProxy(
 ):
     SERVICE_CLASS = MediaControlService
 
-    _CHARACTERISTICS: ClassVar[Dict[str, core.UUID]] = {
+    _CHARACTERISTICS: ClassVar[dict[str, core.UUID]] = {
         'media_player_name': gatt.GATT_MEDIA_PLAYER_NAME_CHARACTERISTIC,
         'media_player_icon_object_id': gatt.GATT_MEDIA_PLAYER_ICON_OBJECT_ID_CHARACTERISTIC,
         'media_player_icon_url': gatt.GATT_MEDIA_PLAYER_ICON_URL_CHARACTERISTIC,

bumble/profiles/vcs.py

@@ -20,7 +20,7 @@ from __future__ import annotations
 import dataclasses
 import enum
 
-from typing import Optional, Sequence
+from typing import Sequence
 
 from bumble import att
 from bumble import utils
@@ -161,10 +161,8 @@ class VolumeControlService(gatt.TemplateService):
         handler = getattr(self, '_on_' + opcode.name.lower())
         if handler(*value[2:]):
             self.change_counter = (self.change_counter + 1) % 256
-            utils.cancel_on_event(
-                connection,
-                'disconnection',
-                connection.device.notify_subscribers(attribute=self.volume_state),
+            connection.cancel_on_disconnection(
+                connection.device.notify_subscribers(attribute=self.volume_state)
             )
             self.emit(self.EVENT_VOLUME_STATE_CHANGE)
 

bumble/rfcomm.py

@@ -22,7 +22,7 @@ import asyncio
 import collections
 import dataclasses
 import enum
-from typing import Callable, Dict, List, Optional, Tuple, Union, TYPE_CHECKING
+from typing import Callable, Optional, Union, TYPE_CHECKING
 from typing_extensions import Self
 
 
@@ -123,7 +123,7 @@ RFCOMM_DYNAMIC_CHANNEL_NUMBER_END   = 30
 # -----------------------------------------------------------------------------
 def make_service_sdp_records(
     service_record_handle: int, channel: int, uuid: Optional[UUID] = None
-) -> List[sdp.ServiceAttribute]:
+) -> list[sdp.ServiceAttribute]:
     """
     Create SDP records for an RFComm service given a channel number and an
     optional UUID. A Service Class Attribute is included only if the UUID is not None.
@@ -169,7 +169,7 @@ def make_service_sdp_records(
 
 
 # -----------------------------------------------------------------------------
-async def find_rfcomm_channels(connection: Connection) -> Dict[int, List[UUID]]:
+async def find_rfcomm_channels(connection: Connection) -> dict[int, list[UUID]]:
     """Searches all RFCOMM channels and their associated UUID from SDP service records.
 
     Args:
@@ -188,7 +188,7 @@ async def find_rfcomm_channels(connection: Connection) -> Dict[int, List[UUID]]:
             ],
         )
         for attribute_lists in search_result:
-            service_classes: List[UUID] = []
+            service_classes: list[UUID] = []
             channel: Optional[int] = None
             for attribute in attribute_lists:
                 # The layout is [[L2CAP_PROTOCOL], [RFCOMM_PROTOCOL, RFCOMM_CHANNEL]].
@@ -275,7 +275,7 @@ class RFCOMM_Frame:
             self.fcs = compute_fcs(bytes([self.address, self.control]) + self.length)
 
     @staticmethod
-    def parse_mcc(data) -> Tuple[int, bool, bytes]:
+    def parse_mcc(data) -> tuple[int, bool, bytes]:
         mcc_type = data[0] >> 2
         c_r = bool((data[0] >> 1) & 1)
         length = data[1]
@@ -771,8 +771,8 @@ class Multiplexer(utils.EventEmitter):
     connection_result: Optional[asyncio.Future]
     disconnection_result: Optional[asyncio.Future]
     open_result: Optional[asyncio.Future]
-    acceptor: Optional[Callable[[int], Optional[Tuple[int, int]]]]
-    dlcs: Dict[int, DLC]
+    acceptor: Optional[Callable[[int], Optional[tuple[int, int]]]]
+    dlcs: dict[int, DLC]
 
     def __init__(self, l2cap_channel: l2cap.ClassicChannel, role: Role) -> None:
         super().__init__()
@@ -1088,8 +1088,8 @@ class Server(utils.EventEmitter):
     ) -> None:
         super().__init__()
         self.device = device
-        self.acceptors: Dict[int, Callable[[DLC], None]] = {}
-        self.dlc_configs: Dict[int, Tuple[int, int]] = {}
+        self.acceptors: dict[int, Callable[[DLC], None]] = {}
+        self.dlc_configs: dict[int, tuple[int, int]] = {}
 
         # Register ourselves with the L2CAP channel manager
         self.l2cap_server = device.create_l2cap_server(
@@ -1144,7 +1144,7 @@ class Server(utils.EventEmitter):
         # Notify
         self.emit(self.EVENT_START, multiplexer)
 
-    def accept_dlc(self, channel_number: int) -> Optional[Tuple[int, int]]:
+    def accept_dlc(self, channel_number: int) -> Optional[tuple[int, int]]:
         return self.dlc_configs.get(channel_number)
 
     def on_dlc(self, dlc: DLC) -> None:

bumble/rtp.py

@@ -17,7 +17,6 @@
 # -----------------------------------------------------------------------------
 from __future__ import annotations
 import struct
-from typing import List
 
 
 # -----------------------------------------------------------------------------
@@ -60,7 +59,7 @@ class MediaPacket:
         sequence_number: int,
         timestamp: int,
         ssrc: int,
-        csrc_list: List[int],
+        csrc_list: list[int],
         payload_type: int,
         payload: bytes,
     ) -> None:

bumble/sdp.py

@@ -19,7 +19,7 @@ from __future__ import annotations
 import asyncio
 import logging
 import struct
-from typing import Iterable, NewType, Optional, Union, Sequence, Type, TYPE_CHECKING
+from typing import Iterable, NewType, Optional, Union, Sequence, TYPE_CHECKING
 from typing_extensions import Self
 
 from bumble import core, l2cap
@@ -547,7 +547,7 @@ class SDP_PDU:
         SDP_SERVICE_ATTRIBUTE_REQUEST: SDP_SERVICE_ATTRIBUTE_RESPONSE,
         SDP_SERVICE_SEARCH_ATTRIBUTE_REQUEST: SDP_SERVICE_SEARCH_ATTRIBUTE_RESPONSE,
     }
-    sdp_pdu_classes: dict[int, Type[SDP_PDU]] = {}
+    sdp_pdu_classes: dict[int, type[SDP_PDU]] = {}
     name = None
     pdu_id = 0
 

bumble/smp.py

@@ -26,18 +26,13 @@ from __future__ import annotations
 import logging
 import asyncio
 import enum
-import secrets
 from dataclasses import dataclass
 from typing import (
     TYPE_CHECKING,
     Any,
     Awaitable,
     Callable,
-    Dict,
-    List,
     Optional,
-    Tuple,
-    Type,
     cast,
 )
 
@@ -210,7 +205,7 @@ class SMP_Command:
     See Bluetooth spec @ Vol 3, Part H - 3 SECURITY MANAGER PROTOCOL
     '''
 
-    smp_classes: Dict[int, Type[SMP_Command]] = {}
+    smp_classes: dict[int, type[SMP_Command]] = {}
     fields: Any
     code = 0
     name = ''
@@ -254,7 +249,7 @@ class SMP_Command:
 
     @staticmethod
     def key_distribution_str(value: int) -> str:
-        key_types: List[str] = []
+        key_types: list[str] = []
         if value & SMP_ENC_KEY_DISTRIBUTION_FLAG:
             key_types.append('ENC')
         if value & SMP_ID_KEY_DISTRIBUTION_FLAG:
@@ -706,7 +701,7 @@ class Session:
         self.peer_identity_resolving_key = None
         self.peer_bd_addr: Optional[Address] = None
         self.peer_signature_key = None
-        self.peer_expected_distributions: List[Type[SMP_Command]] = []
+        self.peer_expected_distributions: list[type[SMP_Command]] = []
         self.dh_key = b''
         self.confirm_value = None
         self.passkey: Optional[int] = None
@@ -767,7 +762,9 @@ class Session:
 
         # OOB
         self.oob_data_flag = (
-            1 if pairing_config.oob and pairing_config.oob.peer_data else 0
+            1
+            if pairing_config.oob and (not self.sc or pairing_config.oob.peer_data)
+            else 0
         )
 
         # Set up addresses
@@ -814,7 +811,7 @@ class Session:
             self.tk = bytes(16)
 
     @property
-    def pkx(self) -> Tuple[bytes, bytes]:
+    def pkx(self) -> tuple[bytes, bytes]:
         return (self.ecc_key.x[::-1], self.peer_public_key_x)
 
     @property
@@ -826,7 +823,7 @@ class Session:
         return self.pkx[0 if self.is_responder else 1]
 
     @property
-    def nx(self) -> Tuple[bytes, bytes]:
+    def nx(self) -> tuple[bytes, bytes]:
         assert self.peer_random_value
         return (self.r, self.peer_random_value)
 
@@ -900,7 +897,7 @@ class Session:
 
             self.send_pairing_failed(SMP_CONFIRM_VALUE_FAILED_ERROR)
 
-        utils.cancel_on_event(self.connection, 'disconnection', prompt())
+        self.connection.cancel_on_disconnection(prompt())
 
     def prompt_user_for_numeric_comparison(
         self, code: int, next_steps: Callable[[], None]
@@ -919,7 +916,7 @@ class Session:
 
             self.send_pairing_failed(SMP_CONFIRM_VALUE_FAILED_ERROR)
 
-        utils.cancel_on_event(self.connection, 'disconnection', prompt())
+        self.connection.cancel_on_disconnection(prompt())
 
     def prompt_user_for_number(self, next_steps: Callable[[int], None]) -> None:
         async def prompt() -> None:
@@ -936,12 +933,11 @@ class Session:
                 logger.warning(f'exception while prompting: {error}')
                 self.send_pairing_failed(SMP_PASSKEY_ENTRY_FAILED_ERROR)
 
-        utils.cancel_on_event(self.connection, 'disconnection', prompt())
+        self.connection.cancel_on_disconnection(prompt())
 
-    def display_passkey(self) -> None:
-        # Generate random Passkey/PIN code
-        self.passkey = secrets.randbelow(1000000)
-        assert self.passkey is not None
+    async def display_passkey(self) -> None:
+        # Get the passkey value from the delegate
+        self.passkey = await self.pairing_config.delegate.generate_passkey()
         logger.debug(f'Pairing PIN CODE: {self.passkey:06}')
         self.passkey_ready.set()
 
@@ -950,14 +946,9 @@ class Session:
             self.tk = self.passkey.to_bytes(16, byteorder='little')
             logger.debug(f'TK from passkey = {self.tk.hex()}')
 
-        try:
-            utils.cancel_on_event(
-                self.connection,
-                'disconnection',
-                self.pairing_config.delegate.display_number(self.passkey, digits=6),
-            )
-        except Exception as error:
-            logger.warning(f'exception while displaying number: {error}')
+        self.connection.cancel_on_disconnection(
+            self.pairing_config.delegate.display_number(self.passkey, digits=6)
+        )
 
     def input_passkey(self, next_steps: Optional[Callable[[], None]] = None) -> None:
         # Prompt the user for the passkey displayed on the peer
@@ -979,9 +970,16 @@ class Session:
         self, next_steps: Optional[Callable[[], None]] = None
     ) -> None:
         if self.passkey_display:
-            self.display_passkey()
-            if next_steps is not None:
-                next_steps()
+
+            async def display_passkey():
+                await self.display_passkey()
+                if next_steps is not None:
+                    next_steps()
+
+            try:
+                self.connection.cancel_on_disconnection(display_passkey())
+            except Exception as error:
+                logger.warning(f'exception while displaying passkey: {error}')
         else:
             self.input_passkey(next_steps)
 
@@ -1051,7 +1049,7 @@ class Session:
                 )
 
             # Perform the next steps asynchronously in case we need to wait for input
-            utils.cancel_on_event(self.connection, 'disconnection', next_steps())
+            self.connection.cancel_on_disconnection(next_steps())
         else:
             confirm_value = crypto.c1(
                 self.tk,
@@ -1174,8 +1172,8 @@ class Session:
                 self.connection.transport == PhysicalTransport.BR_EDR
                 and self.initiator_key_distribution & SMP_ENC_KEY_DISTRIBUTION_FLAG
             ):
-                self.ctkd_task = utils.cancel_on_event(
-                    self.connection, 'disconnection', self.get_link_key_and_derive_ltk()
+                self.ctkd_task = self.connection.cancel_on_disconnection(
+                    self.get_link_key_and_derive_ltk()
                 )
             elif not self.sc:
                 # Distribute the LTK, EDIV and RAND
@@ -1213,8 +1211,8 @@ class Session:
                 self.connection.transport == PhysicalTransport.BR_EDR
                 and self.responder_key_distribution & SMP_ENC_KEY_DISTRIBUTION_FLAG
             ):
-                self.ctkd_task = utils.cancel_on_event(
-                    self.connection, 'disconnection', self.get_link_key_and_derive_ltk()
+                self.ctkd_task = self.connection.cancel_on_disconnection(
+                    self.get_link_key_and_derive_ltk()
                 )
             # Distribute the LTK, EDIV and RAND
             elif not self.sc:
@@ -1269,7 +1267,7 @@ class Session:
             f'{[c.__name__ for c in self.peer_expected_distributions]}'
         )
 
-    def check_key_distribution(self, command_class: Type[SMP_Command]) -> None:
+    def check_key_distribution(self, command_class: type[SMP_Command]) -> None:
         # First, check that the connection is encrypted
         if not self.connection.is_encrypted:
             logger.warning(
@@ -1306,9 +1304,7 @@ class Session:
 
         # Wait for the pairing process to finish
         assert self.pairing_result
-        await utils.cancel_on_event(
-            self.connection, 'disconnection', self.pairing_result
-        )
+        await self.connection.cancel_on_disconnection(self.pairing_result)
 
     def on_disconnection(self, _: int) -> None:
         self.connection.remove_listener(
@@ -1329,7 +1325,7 @@ class Session:
         if self.is_initiator:
             self.distribute_keys()
 
-        utils.cancel_on_event(self.connection, 'disconnection', self.on_pairing())
+        self.connection.cancel_on_disconnection(self.on_pairing())
 
     def on_connection_encryption_change(self) -> None:
         if self.connection.is_encrypted and not self.completed:
@@ -1440,10 +1436,8 @@ class Session:
     def on_smp_pairing_request_command(
         self, command: SMP_Pairing_Request_Command
     ) -> None:
-        utils.cancel_on_event(
-            self.connection,
-            'disconnection',
-            self.on_smp_pairing_request_command_async(command),
+        self.connection.cancel_on_disconnection(
+            self.on_smp_pairing_request_command_async(command)
         )
 
     async def on_smp_pairing_request_command_async(
@@ -1507,7 +1501,7 @@ class Session:
         # Display a passkey if we need to
         if not self.sc:
             if self.pairing_method == PairingMethod.PASSKEY and self.passkey_display:
-                self.display_passkey()
+                await self.display_passkey()
 
         # Respond
         self.send_pairing_response_command()
@@ -1577,11 +1571,12 @@ class Session:
         if self.pairing_method == PairingMethod.CTKD_OVER_CLASSIC:
             # Authentication is already done in SMP, so remote shall start keys distribution immediately
             return
-        elif self.sc:
-            if self.pairing_method == PairingMethod.PASSKEY:
-                self.display_or_input_passkey()
 
+        if self.sc:
             self.send_public_key_command()
+
+            if self.pairing_method == PairingMethod.PASSKEY:
+                self.display_or_input_passkey()
         else:
             if self.pairing_method == PairingMethod.PASSKEY:
                 self.display_or_input_passkey(self.send_pairing_confirm_command)
@@ -1689,7 +1684,7 @@ class Session:
                 ):
                     return
             elif self.pairing_method == PairingMethod.PASSKEY:
-                assert self.passkey and self.confirm_value
+                assert self.passkey is not None and self.confirm_value is not None
                 # Check that the random value matches what was committed to earlier
                 confirm_verifier = crypto.f4(
                     self.pkb,
@@ -1718,7 +1713,7 @@ class Session:
             ):
                 self.send_pairing_random_command()
             elif self.pairing_method == PairingMethod.PASSKEY:
-                assert self.passkey and self.confirm_value
+                assert self.passkey is not None and self.confirm_value is not None
                 # Check that the random value matches what was committed to earlier
                 confirm_verifier = crypto.f4(
                     self.pka,
@@ -1755,7 +1750,7 @@ class Session:
             ra = bytes(16)
             rb = ra
         elif self.pairing_method == PairingMethod.PASSKEY:
-            assert self.passkey
+            assert self.passkey is not None
             ra = self.passkey.to_bytes(16, byteorder='little')
             rb = ra
         elif self.pairing_method == PairingMethod.OOB:
@@ -1854,19 +1849,23 @@ class Session:
             elif self.pairing_method == PairingMethod.PASSKEY:
                 self.send_pairing_confirm_command()
         else:
-            if self.pairing_method == PairingMethod.PASSKEY:
-                self.display_or_input_passkey()
-
             # Send our public key back to the initiator
             self.send_public_key_command()
 
-            if self.pairing_method in (
-                PairingMethod.JUST_WORKS,
-                PairingMethod.NUMERIC_COMPARISON,
-                PairingMethod.OOB,
-            ):
-                # We can now send the confirmation value
-                self.send_pairing_confirm_command()
+            def next_steps() -> None:
+
+                if self.pairing_method in (
+                    PairingMethod.JUST_WORKS,
+                    PairingMethod.NUMERIC_COMPARISON,
+                    PairingMethod.OOB,
+                ):
+                    # We can now send the confirmation value
+                    self.send_pairing_confirm_command()
+
+            if self.pairing_method == PairingMethod.PASSKEY:
+                self.display_or_input_passkey(next_steps)
+            else:
+                next_steps()
 
     def on_smp_pairing_dhkey_check_command(
         self, command: SMP_Pairing_DHKey_Check_Command
@@ -1888,7 +1887,7 @@ class Session:
                     self.wait_before_continuing = None
                     self.send_pairing_dhkey_check_command()
 
-                utils.cancel_on_event(self.connection, 'disconnection', next_steps())
+                self.connection.cancel_on_disconnection(next_steps())
             else:
                 self.send_pairing_dhkey_check_command()
         else:
@@ -1938,9 +1937,9 @@ class Manager(utils.EventEmitter):
     '''
 
     device: Device
-    sessions: Dict[int, Session]
+    sessions: dict[int, Session]
     pairing_config_factory: Callable[[Connection], PairingConfig]
-    session_proxy: Type[Session]
+    session_proxy: type[Session]
     _ecc_key: Optional[crypto.EccKey]
 
     def __init__(