bumble 0.0.218__py3-none-any.whl → 0.0.220__py3-none-any.whl

bumble/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.0.218'
-__version_tuple__ = version_tuple = (0, 0, 218)
+__version__ = version = '0.0.220'
+__version_tuple__ = version_tuple = (0, 0, 220)
 
 __commit_id__ = commit_id = None

bumble/a2dp.py

@@ -21,11 +21,12 @@ import dataclasses
 import enum
 import logging
 import struct
-from collections.abc import AsyncGenerator
-from typing import Awaitable, Callable
+from collections.abc import AsyncGenerator, Awaitable, Callable
+from typing import Union
 
 from typing_extensions import ClassVar, Self
 
+from bumble import utils
 from bumble.codecs import AacAudioRtpPacket
 from bumble.company_ids import COMPANY_IDENTIFIERS
 from bumble.core import (
@@ -59,19 +60,18 @@ logger = logging.getLogger(__name__)
 # -----------------------------------------------------------------------------
 # fmt: off
 
-A2DP_SBC_CODEC_TYPE            = 0x00
-A2DP_MPEG_1_2_AUDIO_CODEC_TYPE = 0x01
-A2DP_MPEG_2_4_AAC_CODEC_TYPE   = 0x02
-A2DP_ATRAC_FAMILY_CODEC_TYPE   = 0x03
-A2DP_NON_A2DP_CODEC_TYPE       = 0xFF
-
-A2DP_CODEC_TYPE_NAMES = {
-    A2DP_SBC_CODEC_TYPE:            'A2DP_SBC_CODEC_TYPE',
-    A2DP_MPEG_1_2_AUDIO_CODEC_TYPE: 'A2DP_MPEG_1_2_AUDIO_CODEC_TYPE',
-    A2DP_MPEG_2_4_AAC_CODEC_TYPE:   'A2DP_MPEG_2_4_AAC_CODEC_TYPE',
-    A2DP_ATRAC_FAMILY_CODEC_TYPE:   'A2DP_ATRAC_FAMILY_CODEC_TYPE',
-    A2DP_NON_A2DP_CODEC_TYPE:       'A2DP_NON_A2DP_CODEC_TYPE'
-}
+class CodecType(utils.OpenIntEnum):
+    SBC            = 0x00
+    MPEG_1_2_AUDIO = 0x01
+    MPEG_2_4_AAC   = 0x02
+    ATRAC_FAMILY   = 0x03
+    NON_A2DP       = 0xFF
+
+A2DP_SBC_CODEC_TYPE            = CodecType.SBC
+A2DP_MPEG_1_2_AUDIO_CODEC_TYPE = CodecType.MPEG_1_2_AUDIO
+A2DP_MPEG_2_4_AAC_CODEC_TYPE   = CodecType.MPEG_2_4_AAC
+A2DP_ATRAC_FAMILY_CODEC_TYPE   = CodecType.ATRAC_FAMILY
+A2DP_NON_A2DP_CODEC_TYPE       = CodecType.NON_A2DP
 
 
 SBC_SYNC_WORD = 0x9C
@@ -259,9 +259,48 @@ def make_audio_sink_service_sdp_records(service_record_handle, version=(1, 3)):
     ]
 
 
+# -----------------------------------------------------------------------------
+class MediaCodecInformation:
+    '''Base Media Codec Information.'''
+
+    @classmethod
+    def create(
+        cls, media_codec_type: int, data: bytes
+    ) -> Union[MediaCodecInformation, bytes]:
+        if media_codec_type == CodecType.SBC:
+            return SbcMediaCodecInformation.from_bytes(data)
+        elif media_codec_type == CodecType.MPEG_2_4_AAC:
+            return AacMediaCodecInformation.from_bytes(data)
+        elif media_codec_type == CodecType.NON_A2DP:
+            vendor_media_codec_information = (
+                VendorSpecificMediaCodecInformation.from_bytes(data)
+            )
+            if (
+                vendor_class_map := A2DP_VENDOR_MEDIA_CODEC_INFORMATION_CLASSES.get(
+                    vendor_media_codec_information.vendor_id
+                )
+            ) and (
+                media_codec_information_class := vendor_class_map.get(
+                    vendor_media_codec_information.codec_id
+                )
+            ):
+                return media_codec_information_class.from_bytes(
+                    vendor_media_codec_information.value
+                )
+        return vendor_media_codec_information
+
+    @classmethod
+    def from_bytes(cls, data: bytes) -> Self:
+        del data  # Unused.
+        raise NotImplementedError
+
+    def __bytes__(self) -> bytes:
+        raise NotImplementedError
+
+
 # -----------------------------------------------------------------------------
 @dataclasses.dataclass
-class SbcMediaCodecInformation:
+class SbcMediaCodecInformation(MediaCodecInformation):
     '''
     A2DP spec - 4.3.2 Codec Specific Information Elements
     '''
@@ -345,7 +384,7 @@ class SbcMediaCodecInformation:
 
 # -----------------------------------------------------------------------------
 @dataclasses.dataclass
-class AacMediaCodecInformation:
+class AacMediaCodecInformation(MediaCodecInformation):
     '''
     A2DP spec - 4.5.2 Codec Specific Information Elements
     '''
@@ -427,7 +466,7 @@ class AacMediaCodecInformation:
 
 @dataclasses.dataclass
 # -----------------------------------------------------------------------------
-class VendorSpecificMediaCodecInformation:
+class VendorSpecificMediaCodecInformation(MediaCodecInformation):
     '''
     A2DP spec - 4.7.2 Codec Specific Information Elements
     '''

bumble/apps/auracast.py

@@ -742,10 +742,9 @@ async def run_receive(
         ]
         packet_stats = [0, 0]
 
-        audio_output = await audio_io.create_audio_output(output)
-        # This try should be replaced with contextlib.aclosing() when python 3.9 is no
-        # longer needed.
-        try:
+        async with contextlib.AsyncExitStack() as stack:
+            audio_output = await audio_io.create_audio_output(output)
+            stack.push_async_callback(audio_output.aclose)
             await audio_output.open(
                 audio_io.PcmFormat(
                     audio_io.PcmFormat.Endianness.LITTLE,
@@ -793,8 +792,6 @@ async def run_receive(
             terminated = asyncio.Event()
             big_sync.on(big_sync.Event.TERMINATION, lambda _: terminated.set())
             await terminated.wait()
-        finally:
-            await audio_output.aclose()
 
 
 async def run_transmit(
@@ -891,11 +888,10 @@ async def run_transmit(
         print('Start Periodic Advertising')
         await advertising_set.start_periodic()
 
-        audio_input = await audio_io.create_audio_input(input, input_format)
-        pcm_format = await audio_input.open()
-        # This try should be replaced with contextlib.aclosing() when python 3.9 is no
-        # longer needed.
-        try:
+        async with contextlib.AsyncExitStack() as stack:
+            audio_input = await audio_io.create_audio_input(input, input_format)
+            pcm_format = await audio_input.open()
+            stack.push_async_callback(audio_input.aclose)
             if pcm_format.channels != 2:
                 print("Only 2 channels PCM configurations are supported")
                 return
@@ -967,8 +963,6 @@ async def run_transmit(
                 await iso_queues[1].write(lc3_frame[mid:])
 
                 frame_count += 1
-        finally:
-            await audio_input.aclose()
 
 
 def run_async(async_command: Coroutine) -> None:

bumble/audio/io.py

@@ -19,13 +19,13 @@ from __future__ import annotations
 
 import abc
 import asyncio
+import concurrent.futures
 import dataclasses
 import enum
 import logging
 import pathlib
 import sys
 import wave
-from concurrent.futures import ThreadPoolExecutor
 from typing import TYPE_CHECKING, AsyncGenerator, BinaryIO
 
 from bumble.colors import color
@@ -176,7 +176,7 @@ class ThreadedAudioOutput(AudioOutput):
     """
 
     def __init__(self) -> None:
-        self._thread_pool = ThreadPoolExecutor(1)
+        self._thread_pool = concurrent.futures.ThreadPoolExecutor(1)
         self._pcm_samples: asyncio.Queue[bytes] = asyncio.Queue()
         self._write_task = asyncio.create_task(self._write_loop())
 
@@ -405,7 +405,7 @@ class ThreadedAudioInput(AudioInput):
     """Base class for AudioInput implementation where reading samples may block."""
 
     def __init__(self) -> None:
-        self._thread_pool = ThreadPoolExecutor(1)
+        self._thread_pool = concurrent.futures.ThreadPoolExecutor(1)
         self._pcm_samples: asyncio.Queue[bytes] = asyncio.Queue()
 
     @abc.abstractmethod

bumble/avctp.py

@@ -19,10 +19,11 @@ from __future__ import annotations
 
 import logging
 import struct
+from collections.abc import Callable
 from enum import IntEnum
-from typing import Callable, Optional, cast
+from typing import Optional
 
-from bumble import avc, core, l2cap
+from bumble import core, l2cap
 from bumble.colors import color
 
 # -----------------------------------------------------------------------------
@@ -144,9 +145,9 @@ class MessageAssembler:
 
 # -----------------------------------------------------------------------------
 class Protocol:
-    CommandHandler = Callable[[int, avc.CommandFrame], None]
+    CommandHandler = Callable[[int, bytes], None]
     command_handlers: dict[int, CommandHandler]  # Command handlers, by PID
-    ResponseHandler = Callable[[int, Optional[avc.ResponseFrame]], None]
+    ResponseHandler = Callable[[int, Optional[bytes]], None]
     response_handlers: dict[int, ResponseHandler]  # Response handlers, by PID
     next_transaction_label: int
     message_assembler: MessageAssembler
@@ -204,20 +205,15 @@ class Protocol:
                 self.send_ipid(transaction_label, pid)
                 return
 
-            command_frame = cast(avc.CommandFrame, avc.Frame.from_bytes(payload))
-            self.command_handlers[pid](transaction_label, command_frame)
+            self.command_handlers[pid](transaction_label, payload)
         else:
             if pid not in self.response_handlers:
                 logger.warning(f"no response handler for PID {pid}")
                 return
 
             # By convention, for an ipid, send a None payload to the response handler.
-            if ipid:
-                response_frame = None
-            else:
-                response_frame = cast(avc.ResponseFrame, avc.Frame.from_bytes(payload))
-
-            self.response_handlers[pid](transaction_label, response_frame)
+            response_payload = None if ipid else payload
+            self.response_handlers[pid](transaction_label, response_payload)
 
     def send_message(
         self,