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

bumble/att.py

@@ -29,18 +29,18 @@ import enum
 import functools
 import inspect
 import struct
+from collections.abc import Awaitable, Callable
 from typing import (
     TYPE_CHECKING,
-    Awaitable,
-    Callable,
     ClassVar,
     Generic,
-    Optional,
+    TypeAlias,
     TypeVar,
-    Union,
 )
 
-from bumble import hci, utils
+from typing_extensions import TypeIs
+
+from bumble import hci, l2cap, utils
 from bumble.colors import color
 from bumble.core import UUID, InvalidOperationError, ProtocolError
 from bumble.hci import HCI_Object
@@ -53,6 +53,14 @@ if TYPE_CHECKING:
 
 _T = TypeVar('_T')
 
+Bearer: TypeAlias = "Connection | l2cap.LeCreditBasedChannel"
+EnhancedBearer: TypeAlias = l2cap.LeCreditBasedChannel
+
+
+def is_enhanced_bearer(bearer: Bearer) -> TypeIs[EnhancedBearer]:
+    return isinstance(bearer, EnhancedBearer)
+
+
 # -----------------------------------------------------------------------------
 # Constants
 # -----------------------------------------------------------------------------
@@ -61,6 +69,7 @@ _T = TypeVar('_T')
 
 ATT_CID = 0x04
 ATT_PSM = 0x001F
+EATT_PSM = 0x0027
 
 class Opcode(hci.SpecableEnum):
     ATT_ERROR_RESPONSE              = 0x01
@@ -220,7 +229,7 @@ class ATT_PDU:
     fields: ClassVar[hci.Fields] = ()
     op_code: int = dataclasses.field(init=False)
     name: str = dataclasses.field(init=False)
-    _payload: Optional[bytes] = dataclasses.field(default=None, init=False)
+    _payload: bytes | None = dataclasses.field(default=None, init=False)
 
     @classmethod
     def from_bytes(cls, pdu: bytes) -> ATT_PDU:
@@ -760,31 +769,66 @@ class AttributeValue(Generic[_T]):
 
     def __init__(
         self,
-        read: Union[
-            Callable[[Connection], _T],
-            Callable[[Connection], Awaitable[_T]],
-            None,
-        ] = None,
-        write: Union[
-            Callable[[Connection, _T], None],
-            Callable[[Connection, _T], Awaitable[None]],
-            None,
-        ] = None,
+        read: (
+            Callable[[Connection], _T] | Callable[[Connection], Awaitable[_T]] | None
+        ) = None,
+        write: (
+            Callable[[Connection, _T], None]
+            | Callable[[Connection, _T], Awaitable[None]]
+            | None
+        ) = None,
     ):
         self._read = read
         self._write = write
 
-    def read(self, connection: Connection) -> Union[_T, Awaitable[_T]]:
+    def read(self, connection: Connection) -> _T | Awaitable[_T]:
         if self._read is None:
             raise InvalidOperationError('AttributeValue has no read function')
         return self._read(connection)
 
-    def write(self, connection: Connection, value: _T) -> Union[Awaitable[None], None]:
+    def write(self, connection: Connection, value: _T) -> Awaitable[None] | None:
         if self._write is None:
             raise InvalidOperationError('AttributeValue has no write function')
         return self._write(connection, value)
 
 
+# -----------------------------------------------------------------------------
+class AttributeValueV2(Generic[_T]):
+    '''
+    Attribute value compatible with enhanced bearers.
+
+    The only difference between AttributeValue and AttributeValueV2 is that the actual
+    bearer (ACL connection for un-enhanced bearer, L2CAP channel for enhanced bearer)
+    will be passed into read and write callbacks in V2, while in V1 it is always
+    the base ACL connection.
+
+    This is only required when attributes must distinguish bearers, otherwise normal
+    `AttributeValue` objects are also applicable in enhanced bearers.
+    '''
+
+    def __init__(
+        self,
+        read: Callable[[Bearer], Awaitable[_T]] | Callable[[Bearer], _T] | None = None,
+        write: (
+            Callable[[Bearer, _T], Awaitable[None]]
+            | Callable[[Bearer, _T], None]
+            | None
+        ) = None,
+    ):
+        self._read = read
+        self._write = write
+
+    def read(self, bearer: Bearer) -> _T | Awaitable[_T]:
+        if self._read is None:
+            raise InvalidOperationError('AttributeValue has no read function')
+        return self._read(bearer)
+
+    def write(self, bearer: Bearer, value: _T) -> Awaitable[None] | None:
+        if self._write is None:
+            raise InvalidOperationError('AttributeValue has no write function')
+        return self._write(bearer, value)
+
+
 # -----------------------------------------------------------------------------
 class Attribute(utils.EventEmitter, Generic[_T]):
     class Permissions(enum.IntFlag):
@@ -828,13 +872,13 @@ class Attribute(utils.EventEmitter, Generic[_T]):
     EVENT_READ = "read"
     EVENT_WRITE = "write"
 
-    value: Union[AttributeValue[_T], _T, None]
+    value: AttributeValue[_T] | _T | None
 
     def __init__(
         self,
-        attribute_type: Union[str, bytes, UUID],
-        permissions: Union[str, Attribute.Permissions],
-        value: Union[AttributeValue[_T], _T, None] = None,
+        attribute_type: str | bytes | UUID,
+        permissions: str | Attribute.Permissions,
+        value: AttributeValue[_T] | _T | None = None,
     ) -> None:
         utils.EventEmitter.__init__(self)
         self.handle = 0
@@ -860,7 +904,8 @@ class Attribute(utils.EventEmitter, Generic[_T]):
     def decode_value(self, value: bytes) -> _T:
         return value  # type: ignore
 
-    async def read_value(self, connection: Connection) -> bytes:
+    async def read_value(self, bearer: Bearer) -> bytes:
+        connection = bearer.connection if is_enhanced_bearer(bearer) else bearer
         if (
             (self.permissions & self.READ_REQUIRES_ENCRYPTION)
             and connection is not None
@@ -883,7 +928,7 @@ class Attribute(utils.EventEmitter, Generic[_T]):
                 error_code=ATT_INSUFFICIENT_AUTHORIZATION_ERROR, att_handle=self.handle
             )
 
-        value: Union[_T, None]
+        value: _T | None
         if isinstance(self.value, AttributeValue):
             try:
                 read_value = self.value.read(connection)
@@ -895,6 +940,17 @@ class Attribute(utils.EventEmitter, Generic[_T]):
                 raise ATT_Error(
                     error_code=error.error_code, att_handle=self.handle
                 ) from error
+        elif isinstance(self.value, AttributeValueV2):
+            try:
+                read_value = self.value.read(bearer)
+                if inspect.isawaitable(read_value):
+                    value = await read_value
+                else:
+                    value = read_value
+            except ATT_Error as error:
+                raise ATT_Error(
+                    error_code=error.error_code, att_handle=self.handle
+                ) from error
         else:
             value = self.value
 
@@ -902,7 +958,8 @@ class Attribute(utils.EventEmitter, Generic[_T]):
 
         return b'' if value is None else self.encode_value(value)
 
-    async def write_value(self, connection: Connection, value: bytes) -> None:
+    async def write_value(self, bearer: Bearer, value: bytes) -> None:
+        connection = bearer.connection if is_enhanced_bearer(bearer) else bearer
         if (
             (self.permissions & self.WRITE_REQUIRES_ENCRYPTION)
             and connection is not None
@@ -936,6 +993,15 @@ class Attribute(utils.EventEmitter, Generic[_T]):
                 raise ATT_Error(
                     error_code=error.error_code, att_handle=self.handle
                 ) from error
+        elif isinstance(self.value, AttributeValueV2):
+            try:
+                result = self.value.write(bearer, decoded_value)
+                if inspect.isawaitable(result):
+                    await result
+            except ATT_Error as error:
+                raise ATT_Error(
+                    error_code=error.error_code, att_handle=self.handle
+                ) from error
         else:
             self.value = decoded_value
 

bumble/audio/io.py

@@ -26,7 +26,8 @@ import logging
 import pathlib
 import sys
 import wave
-from typing import TYPE_CHECKING, AsyncGenerator, BinaryIO
+from collections.abc import AsyncGenerator
+from typing import TYPE_CHECKING, BinaryIO
 
 from bumble.colors import color
 
@@ -545,5 +546,6 @@ class SoundDeviceAudioInput(ThreadedAudioInput):
         return bytes(pcm_buffer)
 
     def _close(self):
-        self._stream.stop()
-        self._stream = None
+        if self._stream:
+            self._stream.stop()
+            self._stream = None

bumble/avc.py

@@ -19,7 +19,6 @@ from __future__ import annotations
 
 import enum
 import struct
-from typing import Union
 
 from bumble import core, utils
 
@@ -166,7 +165,7 @@ class Frame:
 
     def to_bytes(
         self,
-        ctype_or_response: Union[CommandFrame.CommandType, ResponseFrame.ResponseCode],
+        ctype_or_response: CommandFrame.CommandType | ResponseFrame.ResponseCode,
     ) -> bytes:
         # TODO: support extended subunit types and ids.
         return (

bumble/avctp.py

@@ -21,7 +21,6 @@ import logging
 import struct
 from collections.abc import Callable
 from enum import IntEnum
-from typing import Optional
 
 from bumble import core, l2cap
 from bumble.colors import color
@@ -147,7 +146,7 @@ class MessageAssembler:
 class Protocol:
     CommandHandler = Callable[[int, bytes], None]
     command_handlers: dict[int, CommandHandler]  # Command handlers, by PID
-    ResponseHandler = Callable[[int, Optional[bytes]], None]
+    ResponseHandler = Callable[[int, bytes | None], None]
     response_handlers: dict[int, ResponseHandler]  # Response handlers, by PID
     next_transaction_label: int
     message_assembler: MessageAssembler
@@ -258,7 +257,7 @@ class Protocol:
 
     def send_ipid(self, transaction_label: int, pid: int) -> None:
         logger.debug(
-            ">>> AVCTP ipid: " f"transaction_label={transaction_label}, " f"pid={pid}"
+            f">>> AVCTP ipid: transaction_label={transaction_label}, pid={pid}"
         )
         self.send_message(transaction_label, False, True, pid, b'')