bumble 0.0.211__py3-none-any.whl → 0.0.213__py3-none-any.whl

bumble/helpers.py

@@ -34,9 +34,8 @@ from bumble.att import ATT_CID, ATT_PDU
 from bumble.smp import SMP_CID, SMP_Command
 from bumble.core import name_or_number
 from bumble.l2cap import (
+    CommandCode,
     L2CAP_PDU,
-    L2CAP_CONNECTION_REQUEST,
-    L2CAP_CONNECTION_RESPONSE,
     L2CAP_SIGNALING_CID,
     L2CAP_LE_SIGNALING_CID,
     L2CAP_Control_Frame,
@@ -106,14 +105,14 @@ class PacketTracer:
                 self.analyzer.emit(control_frame)
 
                 # Check if this signals a new channel
-                if control_frame.code == L2CAP_CONNECTION_REQUEST:
+                if control_frame.code == CommandCode.L2CAP_CONNECTION_REQUEST:
                     connection_request = cast(L2CAP_Connection_Request, control_frame)
                     self.psms[connection_request.source_cid] = connection_request.psm
-                elif control_frame.code == L2CAP_CONNECTION_RESPONSE:
+                elif control_frame.code == CommandCode.L2CAP_CONNECTION_RESPONSE:
                     connection_response = cast(L2CAP_Connection_Response, control_frame)
                     if (
                         connection_response.result
-                        == L2CAP_Connection_Response.CONNECTION_SUCCESSFUL
+                        == L2CAP_Connection_Response.Result.CONNECTION_SUCCESSFUL
                     ):
                         if self.peer and (
                             psm := self.peer.psms.get(connection_response.source_cid)

bumble/hfp.py

@@ -26,14 +26,9 @@ import enum
 import traceback
 import re
 from typing import (
-    Dict,
-    List,
     Union,
-    Set,
     Any,
     Optional,
-    Type,
-    Tuple,
     ClassVar,
     Iterable,
     TYPE_CHECKING,
@@ -375,7 +370,7 @@ class CallLineIdentification:
     cli_validity: Optional[int] = None
 
     @classmethod
-    def parse_from(cls: Type[Self], parameters: List[bytes]) -> Self:
+    def parse_from(cls, parameters: list[bytes]) -> Self:
         return cls(
             number=parameters[0].decode(),
             type=int(parameters[1]),
@@ -505,9 +500,9 @@ STATUS_CODES = {
 
 @dataclasses.dataclass
 class HfConfiguration:
-    supported_hf_features: List[HfFeature]
-    supported_hf_indicators: List[HfIndicator]
-    supported_audio_codecs: List[AudioCodec]
+    supported_hf_features: list[HfFeature]
+    supported_hf_indicators: list[HfIndicator]
+    supported_audio_codecs: list[AudioCodec]
 
 
 @dataclasses.dataclass
@@ -535,7 +530,7 @@ class AtResponse:
     parameters: list
 
     @classmethod
-    def parse_from(cls: Type[Self], buffer: bytearray) -> Self:
+    def parse_from(cls: type[Self], buffer: bytearray) -> Self:
         code_and_parameters = buffer.split(b':')
         parameters = (
             code_and_parameters[1] if len(code_and_parameters) > 1 else bytearray()
@@ -563,7 +558,7 @@ class AtCommand:
     )
 
     @classmethod
-    def parse_from(cls: Type[Self], buffer: bytearray) -> Self:
+    def parse_from(cls: type[Self], buffer: bytearray) -> Self:
         if not (match := cls._PARSE_PATTERN.fullmatch(buffer.decode())):
             if buffer.startswith(b'ATA'):
                 return cls(code='A', sub_code=AtCommand.SubCode.NONE, parameters=[])
@@ -598,7 +593,7 @@ class AgIndicatorState:
     """
 
     indicator: AgIndicator
-    supported_values: Set[int]
+    supported_values: set[int]
     current_status: int
     index: Optional[int] = None
     enabled: bool = True
@@ -616,14 +611,14 @@ class AgIndicatorState:
         return f'(\"{self.indicator.value}\",{supported_values_text})'
 
     @classmethod
-    def call(cls: Type[Self]) -> Self:
+    def call(cls: type[Self]) -> Self:
         """Default call indicator state."""
         return cls(
             indicator=AgIndicator.CALL, supported_values={0, 1}, current_status=0
         )
 
     @classmethod
-    def callsetup(cls: Type[Self]) -> Self:
+    def callsetup(cls: type[Self]) -> Self:
         """Default callsetup indicator state."""
         return cls(
             indicator=AgIndicator.CALL_SETUP,
@@ -632,7 +627,7 @@ class AgIndicatorState:
         )
 
     @classmethod
-    def callheld(cls: Type[Self]) -> Self:
+    def callheld(cls: type[Self]) -> Self:
         """Default call indicator state."""
         return cls(
             indicator=AgIndicator.CALL_HELD,
@@ -641,14 +636,14 @@ class AgIndicatorState:
         )
 
     @classmethod
-    def service(cls: Type[Self]) -> Self:
+    def service(cls: type[Self]) -> Self:
         """Default service indicator state."""
         return cls(
             indicator=AgIndicator.SERVICE, supported_values={0, 1}, current_status=0
         )
 
     @classmethod
-    def signal(cls: Type[Self]) -> Self:
+    def signal(cls: type[Self]) -> Self:
         """Default signal indicator state."""
         return cls(
             indicator=AgIndicator.SIGNAL,
@@ -657,14 +652,14 @@ class AgIndicatorState:
         )
 
     @classmethod
-    def roam(cls: Type[Self]) -> Self:
+    def roam(cls: type[Self]) -> Self:
         """Default roam indicator state."""
         return cls(
             indicator=AgIndicator.CALL, supported_values={0, 1}, current_status=0
         )
 
     @classmethod
-    def battchg(cls: Type[Self]) -> Self:
+    def battchg(cls: type[Self]) -> Self:
         """Default battery charge indicator state."""
         return cls(
             indicator=AgIndicator.BATTERY_CHARGE,
@@ -720,17 +715,25 @@ class HfProtocol(utils.EventEmitter):
                 vrec: VoiceRecognitionState
     """
 
+    EVENT_CODEC_NEGOTIATION = "codec_negotiation"
+    EVENT_AG_INDICATOR = "ag_indicator"
+    EVENT_SPEAKER_VOLUME = "speaker_volume"
+    EVENT_MICROPHONE_VOLUME = "microphone_volume"
+    EVENT_RING = "ring"
+    EVENT_CLI_NOTIFICATION = "cli_notification"
+    EVENT_VOICE_RECOGNITION = "voice_recognition"
+
     class HfLoopTermination(HfpProtocolError):
         """Termination signal for run() loop."""
 
     supported_hf_features: int
-    supported_audio_codecs: List[AudioCodec]
+    supported_audio_codecs: list[AudioCodec]
 
     supported_ag_features: int
-    supported_ag_call_hold_operations: List[CallHoldOperation]
+    supported_ag_call_hold_operations: list[CallHoldOperation]
 
-    ag_indicators: List[AgIndicatorState]
-    hf_indicators: Dict[HfIndicator, HfIndicatorState]
+    ag_indicators: list[AgIndicatorState]
+    hf_indicators: dict[HfIndicator, HfIndicatorState]
 
     dlc: rfcomm.DLC
     command_lock: asyncio.Lock
@@ -777,7 +780,8 @@ class HfProtocol(utils.EventEmitter):
         self.dlc.sink = self._read_at
         # Stop the run() loop when L2CAP is closed.
         self.dlc.multiplexer.l2cap_channel.on(
-            'close', lambda: self.unsolicited_queue.put_nowait(None)
+            self.dlc.multiplexer.l2cap_channel.EVENT_CLOSE,
+            lambda: self.unsolicited_queue.put_nowait(None),
         )
 
     def supports_hf_feature(self, feature: HfFeature) -> bool:
@@ -827,7 +831,7 @@ class HfProtocol(utils.EventEmitter):
         cmd: str,
         timeout: float = 1.0,
         response_type: AtResponseType = AtResponseType.NONE,
-    ) -> Union[None, AtResponse, List[AtResponse]]:
+    ) -> Union[None, AtResponse, list[AtResponse]]:
         """
         Sends an AT command and wait for the peer response.
         Wait for the AT responses sent by the peer, to the status code.
@@ -844,7 +848,7 @@ class HfProtocol(utils.EventEmitter):
         async with self.command_lock:
             logger.debug(f">>> {cmd}")
             self.dlc.write(cmd + '\r')
-            responses: List[AtResponse] = []
+            responses: list[AtResponse] = []
 
             while True:
                 result = await asyncio.wait_for(
@@ -1034,7 +1038,7 @@ class HfProtocol(utils.EventEmitter):
         # ID. The HF shall be ready to accept the synchronous connection
         # establishment as soon as it has sent the AT commands AT+BCS=<Codec ID>.
         self.active_codec = AudioCodec(codec_id)
-        self.emit('codec_negotiation', self.active_codec)
+        self.emit(self.EVENT_CODEC_NEGOTIATION, self.active_codec)
 
         logger.info("codec connection setup completed")
 
@@ -1064,7 +1068,7 @@ class HfProtocol(utils.EventEmitter):
         # code, with the value indicating (call=0).
         await self.execute_command("AT+CHUP")
 
-    async def query_current_calls(self) -> List[CallInfo]:
+    async def query_current_calls(self) -> list[CallInfo]:
         """4.32.1 Query List of Current Calls in AG.
 
         Return:
@@ -1095,7 +1099,7 @@ class HfProtocol(utils.EventEmitter):
         # CIEV is in 1-index, while ag_indicators is in 0-index.
         ag_indicator = self.ag_indicators[index - 1]
         ag_indicator.current_status = value
-        self.emit('ag_indicator', ag_indicator)
+        self.emit(self.EVENT_AG_INDICATOR, ag_indicator)
         logger.info(f"AG indicator updated: {ag_indicator.indicator}, {value}")
 
     async def handle_unsolicited(self):
@@ -1110,19 +1114,21 @@ class HfProtocol(utils.EventEmitter):
                 int(result.parameters[0]), int(result.parameters[1])
             )
         elif result.code == "+VGS":
-            self.emit('speaker_volume', int(result.parameters[0]))
+            self.emit(self.EVENT_SPEAKER_VOLUME, int(result.parameters[0]))
         elif result.code == "+VGM":
-            self.emit('microphone_volume', int(result.parameters[0]))
+            self.emit(self.EVENT_MICROPHONE_VOLUME, int(result.parameters[0]))
         elif result.code == "RING":
-            self.emit('ring')
+            self.emit(self.EVENT_RING)
         elif result.code == "+CLIP":
             self.emit(
-                'cli_notification', CallLineIdentification.parse_from(result.parameters)
+                self.EVENT_CLI_NOTIFICATION,
+                CallLineIdentification.parse_from(result.parameters),
             )
         elif result.code == "+BVRA":
             # TODO: Support Enhanced Voice Recognition.
             self.emit(
-                'voice_recognition', VoiceRecognitionState(int(result.parameters[0]))
+                self.EVENT_VOICE_RECOGNITION,
+                VoiceRecognitionState(int(result.parameters[0])),
             )
         else:
             logging.info(f"unhandled unsolicited response {result.code}")
@@ -1179,28 +1185,41 @@ class AgProtocol(utils.EventEmitter):
                 volume: Int
     """
 
+    EVENT_SLC_COMPLETE = "slc_complete"
+    EVENT_SUPPORTED_AUDIO_CODECS = "supported_audio_codecs"
+    EVENT_CODEC_NEGOTIATION = "codec_negotiation"
+    EVENT_VOICE_RECOGNITION = "voice_recognition"
+    EVENT_CALL_HOLD = "call_hold"
+    EVENT_HF_INDICATOR = "hf_indicator"
+    EVENT_CODEC_CONNECTION_REQUEST = "codec_connection_request"
+    EVENT_ANSWER = "answer"
+    EVENT_DIAL = "dial"
+    EVENT_HANG_UP = "hang_up"
+    EVENT_SPEAKER_VOLUME = "speaker_volume"
+    EVENT_MICROPHONE_VOLUME = "microphone_volume"
+
     supported_hf_features: int
-    supported_hf_indicators: Set[HfIndicator]
-    supported_audio_codecs: List[AudioCodec]
+    supported_hf_indicators: set[HfIndicator]
+    supported_audio_codecs: list[AudioCodec]
 
     supported_ag_features: int
-    supported_ag_call_hold_operations: List[CallHoldOperation]
+    supported_ag_call_hold_operations: list[CallHoldOperation]
 
-    ag_indicators: List[AgIndicatorState]
+    ag_indicators: list[AgIndicatorState]
     hf_indicators: collections.OrderedDict[HfIndicator, HfIndicatorState]
 
     dlc: rfcomm.DLC
 
     read_buffer: bytearray
     active_codec: AudioCodec
-    calls: List[CallInfo]
+    calls: list[CallInfo]
 
     indicator_report_enabled: bool
     inband_ringtone_enabled: bool
     cme_error_enabled: bool
     cli_notification_enabled: bool
     call_waiting_enabled: bool
-    _remained_slc_setup_features: Set[HfFeature]
+    _remained_slc_setup_features: set[HfFeature]
 
     def __init__(self, dlc: rfcomm.DLC, configuration: AgConfiguration) -> None:
         super().__init__()
@@ -1371,7 +1390,7 @@ class AgProtocol(utils.EventEmitter):
 
     def _check_remained_slc_commands(self) -> None:
         if not self._remained_slc_setup_features:
-            self.emit('slc_complete')
+            self.emit(self.EVENT_SLC_COMPLETE)
 
     def _on_brsf(self, hf_features: bytes) -> None:
         self.supported_hf_features = int(hf_features)
@@ -1390,17 +1409,17 @@ class AgProtocol(utils.EventEmitter):
 
     def _on_bac(self, *args) -> None:
         self.supported_audio_codecs = [AudioCodec(int(value)) for value in args]
-        self.emit('supported_audio_codecs', self.supported_audio_codecs)
+        self.emit(self.EVENT_SUPPORTED_AUDIO_CODECS, self.supported_audio_codecs)
         self.send_ok()
 
     def _on_bcs(self, codec: bytes) -> None:
         self.active_codec = AudioCodec(int(codec))
         self.send_ok()
-        self.emit('codec_negotiation', self.active_codec)
+        self.emit(self.EVENT_CODEC_NEGOTIATION, self.active_codec)
 
     def _on_bvra(self, vrec: bytes) -> None:
         self.send_ok()
-        self.emit('voice_recognition', VoiceRecognitionState(int(vrec)))
+        self.emit(self.EVENT_VOICE_RECOGNITION, VoiceRecognitionState(int(vrec)))
 
     def _on_chld(self, operation_code: bytes) -> None:
         call_index: Optional[int] = None
@@ -1427,7 +1446,7 @@ class AgProtocol(utils.EventEmitter):
         # Real three-way calls have more complicated situations, but this is not a popular issue - let users to handle the remaining :)
 
         self.send_ok()
-        self.emit('call_hold', operation, call_index)
+        self.emit(self.EVENT_CALL_HOLD, operation, call_index)
 
     def _on_chld_test(self) -> None:
         if not self.supports_ag_feature(AgFeature.THREE_WAY_CALLING):
@@ -1553,7 +1572,7 @@ class AgProtocol(utils.EventEmitter):
             return
 
         self.hf_indicators[index].current_status = int(value_bytes)
-        self.emit('hf_indicator', self.hf_indicators[index])
+        self.emit(self.EVENT_HF_INDICATOR, self.hf_indicators[index])
         self.send_ok()
 
     def _on_bia(self, *args) -> None:
@@ -1562,21 +1581,21 @@ class AgProtocol(utils.EventEmitter):
         self.send_ok()
 
     def _on_bcc(self) -> None:
-        self.emit('codec_connection_request')
+        self.emit(self.EVENT_CODEC_CONNECTION_REQUEST)
         self.send_ok()
 
     def _on_a(self) -> None:
         """ATA handler."""
-        self.emit('answer')
+        self.emit(self.EVENT_ANSWER)
         self.send_ok()
 
     def _on_d(self, number: bytes) -> None:
         """ATD handler."""
-        self.emit('dial', number.decode())
+        self.emit(self.EVENT_DIAL, number.decode())
         self.send_ok()
 
     def _on_chup(self) -> None:
-        self.emit('hang_up')
+        self.emit(self.EVENT_HANG_UP)
         self.send_ok()
 
     def _on_clcc(self) -> None:
@@ -1602,11 +1621,11 @@ class AgProtocol(utils.EventEmitter):
         self.send_ok()
 
     def _on_vgs(self, level: bytes) -> None:
-        self.emit('speaker_volume', int(level))
+        self.emit(self.EVENT_SPEAKER_VOLUME, int(level))
         self.send_ok()
 
     def _on_vgm(self, level: bytes) -> None:
-        self.emit('microphone_volume', int(level))
+        self.emit(self.EVENT_MICROPHONE_VOLUME, int(level))
         self.send_ok()
 
 
@@ -1670,7 +1689,7 @@ def make_hf_sdp_records(
     rfcomm_channel: int,
     configuration: HfConfiguration,
     version: ProfileVersion = ProfileVersion.V1_8,
-) -> List[sdp.ServiceAttribute]:
+) -> list[sdp.ServiceAttribute]:
     """
     Generates the SDP record for HFP Hands-Free support.
 
@@ -1756,7 +1775,7 @@ def make_ag_sdp_records(
     rfcomm_channel: int,
     configuration: AgConfiguration,
     version: ProfileVersion = ProfileVersion.V1_8,
-) -> List[sdp.ServiceAttribute]:
+) -> list[sdp.ServiceAttribute]:
     """
     Generates the SDP record for HFP Audio-Gateway support.
 
@@ -1836,7 +1855,7 @@ def make_ag_sdp_records(
 
 async def find_hf_sdp_record(
     connection: device.Connection,
-) -> Optional[Tuple[int, ProfileVersion, HfSdpFeature]]:
+) -> Optional[tuple[int, ProfileVersion, HfSdpFeature]]:
     """Searches a Hands-Free SDP record from remote device.
 
     Args:
@@ -1888,7 +1907,7 @@ async def find_hf_sdp_record(
 
 async def find_ag_sdp_record(
     connection: device.Connection,
-) -> Optional[Tuple[int, ProfileVersion, AgSdpFeature]]:
+) -> Optional[tuple[int, ProfileVersion, AgSdpFeature]]:
     """Searches an Audio-Gateway SDP record from remote device.
 
     Args:
@@ -1986,7 +2005,7 @@ class EscoParameters:
     transmit_codec_frame_size: int = 60
     receive_codec_frame_size: int = 60
 
-    def asdict(self) -> Dict[str, Any]:
+    def asdict(self) -> dict[str, Any]:
         # dataclasses.asdict() will recursively deep-copy the entire object,
         # which is expensive and breaks CodingFormat object, so let it simply copy here.
         return self.__dict__

bumble/hid.py

@@ -201,6 +201,13 @@ class HID(ABC, utils.EventEmitter):
     l2cap_intr_channel: Optional[l2cap.ClassicChannel] = None
     connection: Optional[device.Connection] = None
 
+    EVENT_INTERRUPT_DATA = "interrupt_data"
+    EVENT_CONTROL_DATA = "control_data"
+    EVENT_SUSPEND = "suspend"
+    EVENT_EXIT_SUSPEND = "exit_suspend"
+    EVENT_VIRTUAL_CABLE_UNPLUG = "virtual_cable_unplug"
+    EVENT_HANDSHAKE = "handshake"
+
     class Role(enum.IntEnum):
         HOST = 0x00
         DEVICE = 0x01
@@ -215,7 +222,7 @@ class HID(ABC, utils.EventEmitter):
         device.register_l2cap_server(HID_CONTROL_PSM, self.on_l2cap_connection)
         device.register_l2cap_server(HID_INTERRUPT_PSM, self.on_l2cap_connection)
 
-        device.on('connection', self.on_device_connection)
+        device.on(device.EVENT_CONNECTION, self.on_device_connection)
 
     async def connect_control_channel(self) -> None:
         # Create a new L2CAP connection - control channel
@@ -258,15 +265,20 @@ class HID(ABC, utils.EventEmitter):
     def on_device_connection(self, connection: device.Connection) -> None:
         self.connection = connection
         self.remote_device_bd_address = connection.peer_address
-        connection.on('disconnection', self.on_device_disconnection)
+        connection.on(connection.EVENT_DISCONNECTION, self.on_device_disconnection)
 
     def on_device_disconnection(self, reason: int) -> None:
         self.connection = None
 
     def on_l2cap_connection(self, l2cap_channel: l2cap.ClassicChannel) -> None:
         logger.debug(f'+++ New L2CAP connection: {l2cap_channel}')
-        l2cap_channel.on('open', lambda: self.on_l2cap_channel_open(l2cap_channel))
-        l2cap_channel.on('close', lambda: self.on_l2cap_channel_close(l2cap_channel))
+        l2cap_channel.on(
+            l2cap_channel.EVENT_OPEN, lambda: self.on_l2cap_channel_open(l2cap_channel)
+        )
+        l2cap_channel.on(
+            l2cap_channel.EVENT_CLOSE,
+            lambda: self.on_l2cap_channel_close(l2cap_channel),
+        )
 
     def on_l2cap_channel_open(self, l2cap_channel: l2cap.ClassicChannel) -> None:
         if l2cap_channel.psm == HID_CONTROL_PSM:
@@ -290,7 +302,7 @@ class HID(ABC, utils.EventEmitter):
 
     def on_intr_pdu(self, pdu: bytes) -> None:
         logger.debug(f'<<< HID INTERRUPT PDU: {pdu.hex()}')
-        self.emit("interrupt_data", pdu)
+        self.emit(self.EVENT_INTERRUPT_DATA, pdu)
 
     def send_pdu_on_ctrl(self, msg: bytes) -> None:
         assert self.l2cap_ctrl_channel
@@ -363,17 +375,17 @@ class Device(HID):
             self.handle_set_protocol(pdu)
         elif message_type == Message.MessageType.DATA:
             logger.debug('<<< HID CONTROL DATA')
-            self.emit('control_data', pdu)
+            self.emit(self.EVENT_CONTROL_DATA, pdu)
         elif message_type == Message.MessageType.CONTROL:
             if param == Message.ControlCommand.SUSPEND:
                 logger.debug('<<< HID SUSPEND')
-                self.emit('suspend')
+                self.emit(self.EVENT_SUSPEND)
             elif param == Message.ControlCommand.EXIT_SUSPEND:
                 logger.debug('<<< HID EXIT SUSPEND')
-                self.emit('exit_suspend')
+                self.emit(self.EVENT_EXIT_SUSPEND)
             elif param == Message.ControlCommand.VIRTUAL_CABLE_UNPLUG:
                 logger.debug('<<< HID VIRTUAL CABLE UNPLUG')
-                self.emit('virtual_cable_unplug')
+                self.emit(self.EVENT_VIRTUAL_CABLE_UNPLUG)
             else:
                 logger.debug('<<< HID CONTROL OPERATION UNSUPPORTED')
         else:
@@ -538,14 +550,14 @@ class Host(HID):
         message_type = pdu[0] >> 4
         if message_type == Message.MessageType.HANDSHAKE:
             logger.debug(f'<<< HID HANDSHAKE: {Message.Handshake(param).name}')
-            self.emit('handshake', Message.Handshake(param))
+            self.emit(self.EVENT_HANDSHAKE, Message.Handshake(param))
         elif message_type == Message.MessageType.DATA:
             logger.debug('<<< HID CONTROL DATA')
-            self.emit('control_data', pdu)
+            self.emit(self.EVENT_CONTROL_DATA, pdu)
         elif message_type == Message.MessageType.CONTROL:
             if param == Message.ControlCommand.VIRTUAL_CABLE_UNPLUG:
                 logger.debug('<<< HID VIRTUAL CABLE UNPLUG')
-                self.emit('virtual_cable_unplug')
+                self.emit(self.EVENT_VIRTUAL_CABLE_UNPLUG)
             else:
                 logger.debug('<<< HID CONTROL OPERATION UNSUPPORTED')
         else: