bumble 0.0.219__py3-none-any.whl → 0.0.221__py3-none-any.whl

bumble/profiles/pacs.py

@@ -21,7 +21,7 @@ from __future__ import annotations
 import dataclasses
 import logging
 import struct
-from typing import Optional, Sequence, Union
+from collections.abc import Sequence
 
 from bumble import gatt, gatt_adapters, gatt_client, hci
 from bumble.profiles import le_audio
@@ -39,7 +39,7 @@ class PacRecord:
     '''Published Audio Capabilities Service, Table 3.2/3.4.'''
 
     coding_format: hci.CodingFormat
-    codec_specific_capabilities: Union[CodecSpecificCapabilities, bytes]
+    codec_specific_capabilities: CodecSpecificCapabilities | bytes
     metadata: le_audio.Metadata = dataclasses.field(default_factory=le_audio.Metadata)
 
     @classmethod
@@ -56,7 +56,7 @@ class PacRecord:
         offset += 1
         metadata = le_audio.Metadata.from_bytes(data[offset : offset + metadata_size])
 
-        codec_specific_capabilities: Union[CodecSpecificCapabilities, bytes]
+        codec_specific_capabilities: CodecSpecificCapabilities | bytes
         if coding_format.codec_id == hci.CodecID.VENDOR_SPECIFIC:
             codec_specific_capabilities = codec_specific_capabilities_bytes
         else:
@@ -101,10 +101,10 @@ class PacRecord:
 class PublishedAudioCapabilitiesService(gatt.TemplateService):
     UUID = gatt.GATT_PUBLISHED_AUDIO_CAPABILITIES_SERVICE
 
-    sink_pac: Optional[gatt.Characteristic[bytes]]
-    sink_audio_locations: Optional[gatt.Characteristic[bytes]]
-    source_pac: Optional[gatt.Characteristic[bytes]]
-    source_audio_locations: Optional[gatt.Characteristic[bytes]]
+    sink_pac: gatt.Characteristic[bytes] | None
+    sink_audio_locations: gatt.Characteristic[bytes] | None
+    source_pac: gatt.Characteristic[bytes] | None
+    source_audio_locations: gatt.Characteristic[bytes] | None
     available_audio_contexts: gatt.Characteristic[bytes]
     supported_audio_contexts: gatt.Characteristic[bytes]
 
@@ -115,9 +115,9 @@ class PublishedAudioCapabilitiesService(gatt.TemplateService):
         available_source_context: ContextType,
         available_sink_context: ContextType,
         sink_pac: Sequence[PacRecord] = (),
-        sink_audio_locations: Optional[AudioLocation] = None,
+        sink_audio_locations: AudioLocation | None = None,
         source_pac: Sequence[PacRecord] = (),
-        source_audio_locations: Optional[AudioLocation] = None,
+        source_audio_locations: AudioLocation | None = None,
     ) -> None:
         characteristics = []
 
@@ -183,14 +183,10 @@ class PublishedAudioCapabilitiesService(gatt.TemplateService):
 class PublishedAudioCapabilitiesServiceProxy(gatt_client.ProfileServiceProxy):
     SERVICE_CLASS = PublishedAudioCapabilitiesService
 
-    sink_pac: Optional[gatt_client.CharacteristicProxy[list[PacRecord]]] = None
-    sink_audio_locations: Optional[gatt_client.CharacteristicProxy[AudioLocation]] = (
-        None
-    )
-    source_pac: Optional[gatt_client.CharacteristicProxy[list[PacRecord]]] = None
-    source_audio_locations: Optional[gatt_client.CharacteristicProxy[AudioLocation]] = (
-        None
-    )
+    sink_pac: gatt_client.CharacteristicProxy[list[PacRecord]] | None = None
+    sink_audio_locations: gatt_client.CharacteristicProxy[AudioLocation] | None = None
+    source_pac: gatt_client.CharacteristicProxy[list[PacRecord]] | None = None
+    source_audio_locations: gatt_client.CharacteristicProxy[AudioLocation] | None = None
     available_audio_contexts: gatt_client.CharacteristicProxy[tuple[ContextType, ...]]
     supported_audio_contexts: gatt_client.CharacteristicProxy[tuple[ContextType, ...]]
 

bumble/profiles/pbp.py

@@ -22,6 +22,7 @@ import enum
 
 from typing_extensions import Self
 
+from bumble import core, data_types, gatt
 from bumble.profiles import le_audio
 
 
@@ -46,3 +47,18 @@ class PublicBroadcastAnnouncement:
         return cls(
             features=features, metadata=le_audio.Metadata.from_bytes(metadata_ltv)
         )
+
+    def get_advertising_data(self) -> bytes:
+        return bytes(
+            core.AdvertisingData(
+                [
+                    data_types.ServiceData16BitUUID(
+                        gatt.GATT_PUBLIC_BROADCAST_ANNOUNCEMENT_SERVICE, bytes(self)
+                    )
+                ]
+            )
+        )
+
+    def __bytes__(self) -> bytes:
+        metadata_bytes = bytes(self.metadata)
+        return bytes([self.features, len(metadata_bytes)]) + metadata_bytes

bumble/profiles/vcs.py

@@ -20,9 +20,9 @@ from __future__ import annotations
 
 import dataclasses
 import enum
-from typing import Sequence
+from collections.abc import Sequence
 
-from bumble import att, device, gatt, gatt_adapters, gatt_client, utils
+from bumble import att, device, gatt, gatt_adapters, gatt_client
 
 # -----------------------------------------------------------------------------
 # Constants

bumble/profiles/vocs.py

@@ -18,7 +18,6 @@
 # -----------------------------------------------------------------------------
 import struct
 from dataclasses import dataclass
-from typing import Optional
 
 from bumble import utils
 from bumble.att import ATT_Error
@@ -69,7 +68,7 @@ class ErrorCode(utils.OpenIntEnum):
 class VolumeOffsetState:
     volume_offset: int = 0
     change_counter: int = 0
-    attribute: Optional[Characteristic] = None
+    attribute: Characteristic | None = None
 
     def __bytes__(self) -> bytes:
         return struct.pack('<hB', self.volume_offset, self.change_counter)
@@ -93,7 +92,7 @@ class VolumeOffsetState:
 @dataclass
 class VocsAudioLocation:
     audio_location: AudioLocation = AudioLocation.NOT_ALLOWED
-    attribute: Optional[Characteristic] = None
+    attribute: Characteristic | None = None
 
     def __bytes__(self) -> bytes:
         return struct.pack('<I', self.audio_location)
@@ -118,7 +117,6 @@ class VolumeOffsetControlPoint:
     volume_offset_state: VolumeOffsetState
 
     async def on_write(self, connection: Connection, value: bytes) -> None:
-
         opcode = value[0]
         if opcode != SetVolumeOffsetOpCode.SET_VOLUME_OFFSET:
             raise ATT_Error(ErrorCode.OPCODE_NOT_SUPPORTED)
@@ -148,7 +146,7 @@ class VolumeOffsetControlPoint:
 @dataclass
 class AudioOutputDescription:
     audio_output_description: str = ''
-    attribute: Optional[Characteristic] = None
+    attribute: Characteristic | None = None
 
     @classmethod
     def from_bytes(cls, data: bytes):
@@ -173,11 +171,10 @@ class VolumeOffsetControlService(TemplateService):
 
     def __init__(
         self,
-        volume_offset_state: Optional[VolumeOffsetState] = None,
-        audio_location: Optional[VocsAudioLocation] = None,
-        audio_output_description: Optional[AudioOutputDescription] = None,
+        volume_offset_state: VolumeOffsetState | None = None,
+        audio_location: VocsAudioLocation | None = None,
+        audio_output_description: AudioOutputDescription | None = None,
     ) -> None:
-
         self.volume_offset_state = (
             VolumeOffsetState() if volume_offset_state is None else volume_offset_state
         )

bumble/rfcomm.py

@@ -22,7 +22,8 @@ import collections
 import dataclasses
 import enum
 import logging
-from typing import TYPE_CHECKING, Callable, Optional, Union
+from collections.abc import Callable
+from typing import TYPE_CHECKING
 
 from typing_extensions import Self
 
@@ -119,7 +120,7 @@ RFCOMM_DYNAMIC_CHANNEL_NUMBER_END   = 30
 
 # -----------------------------------------------------------------------------
 def make_service_sdp_records(
-    service_record_handle: int, channel: int, uuid: Optional[UUID] = None
+    service_record_handle: int, channel: int, uuid: UUID | None = None
 ) -> list[sdp.ServiceAttribute]:
     """
     Create SDP records for an RFComm service given a channel number and an
@@ -186,7 +187,7 @@ async def find_rfcomm_channels(connection: Connection) -> dict[int, list[UUID]]:
         )
         for attribute_lists in search_result:
             service_classes: list[UUID] = []
-            channel: Optional[int] = None
+            channel: int | None = None
             for attribute in attribute_lists:
                 # The layout is [[L2CAP_PROTOCOL], [RFCOMM_PROTOCOL, RFCOMM_CHANNEL]].
                 if attribute.id == sdp.SDP_PROTOCOL_DESCRIPTOR_LIST_ATTRIBUTE_ID:
@@ -207,7 +208,7 @@ async def find_rfcomm_channels(connection: Connection) -> dict[int, list[UUID]]:
 # -----------------------------------------------------------------------------
 async def find_rfcomm_channel_with_uuid(
     connection: Connection, uuid: str | UUID
-) -> Optional[int]:
+) -> int | None:
     """Searches an RFCOMM channel associated with given UUID from service records.
 
     Args:
@@ -473,15 +474,15 @@ class DLC(utils.EventEmitter):
         self.state = DLC.State.INIT
         self.role = multiplexer.role
         self.c_r = 1 if self.role == Multiplexer.Role.INITIATOR else 0
-        self.connection_result: Optional[asyncio.Future] = None
-        self.disconnection_result: Optional[asyncio.Future] = None
+        self.connection_result: asyncio.Future | None = None
+        self.disconnection_result: asyncio.Future | None = None
         self.drained = asyncio.Event()
         self.drained.set()
         # Queued packets when sink is not set.
         self._enqueued_rx_packets: collections.deque[bytes] = collections.deque(
             maxlen=DEFAULT_RX_QUEUE_SIZE
         )
-        self._sink: Optional[Callable[[bytes], None]] = None
+        self._sink: Callable[[bytes], None] | None = None
 
         # Compute the MTU
         max_overhead = 4 + 1  # header with 2-byte length + fcs
@@ -490,11 +491,11 @@ class DLC(utils.EventEmitter):
         )
 
     @property
-    def sink(self) -> Optional[Callable[[bytes], None]]:
+    def sink(self) -> Callable[[bytes], None] | None:
         return self._sink
 
     @sink.setter
-    def sink(self, sink: Optional[Callable[[bytes], None]]) -> None:
+    def sink(self, sink: Callable[[bytes], None] | None) -> None:
         self._sink = sink
         # Dump queued packets to sink
         if sink:
@@ -712,7 +713,7 @@ class DLC(utils.EventEmitter):
                 self.drained.set()
 
     # Stream protocol
-    def write(self, data: Union[bytes, str]) -> None:
+    def write(self, data: bytes | str) -> None:
         # We can only send bytes
         if not isinstance(data, bytes):
             if isinstance(data, str):
@@ -769,10 +770,10 @@ class Multiplexer(utils.EventEmitter):
 
     EVENT_DLC = "dlc"
 
-    connection_result: Optional[asyncio.Future]
-    disconnection_result: Optional[asyncio.Future]
-    open_result: Optional[asyncio.Future]
-    acceptor: Optional[Callable[[int], Optional[tuple[int, int]]]]
+    connection_result: asyncio.Future | None
+    disconnection_result: asyncio.Future | None
+    open_result: asyncio.Future | None
+    acceptor: Callable[[int], tuple[int, int] | None] | None
     dlcs: dict[int, DLC]
 
     def __init__(self, l2cap_channel: l2cap.ClassicChannel, role: Role) -> None:
@@ -784,7 +785,7 @@ class Multiplexer(utils.EventEmitter):
         self.connection_result = None
         self.disconnection_result = None
         self.open_result = None
-        self.open_pn: Optional[RFCOMM_MCC_PN] = None
+        self.open_pn: RFCOMM_MCC_PN | None = None
         self.open_rx_max_credits = 0
         self.acceptor = None
 
@@ -1031,8 +1032,8 @@ class Multiplexer(utils.EventEmitter):
 
 # -----------------------------------------------------------------------------
 class Client:
-    multiplexer: Optional[Multiplexer]
-    l2cap_channel: Optional[l2cap.ClassicChannel]
+    multiplexer: Multiplexer | None
+    l2cap_channel: l2cap.ClassicChannel | None
 
     def __init__(
         self, connection: Connection, l2cap_mtu: int = RFCOMM_DEFAULT_L2CAP_MTU
@@ -1145,7 +1146,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) -> tuple[int, int] | None:
         return self.dlc_configs.get(channel_number)
 
     def on_dlc(self, dlc: DLC) -> None:

bumble/sdp.py

@@ -20,7 +20,8 @@ from __future__ import annotations
 import asyncio
 import logging
 import struct
-from typing import TYPE_CHECKING, Iterable, NewType, Optional, Sequence, Union
+from collections.abc import Iterable, Sequence
+from typing import TYPE_CHECKING, NewType
 
 from typing_extensions import Self
 
@@ -497,7 +498,7 @@ class ServiceAttribute:
     @staticmethod
     def find_attribute_in_list(
         attribute_list: Iterable[ServiceAttribute], attribute_id: int
-    ) -> Optional[DataElement]:
+    ) -> DataElement | None:
         return next(
             (
                 attribute.value
@@ -528,7 +529,7 @@ class ServiceAttribute:
     def to_string(self, with_colors=False):
         if with_colors:
             return (
-                f'Attribute(id={color(self.id_name(self.id),"magenta")},'
+                f'Attribute(id={color(self.id_name(self.id), "magenta")},'
                 f'value={self.value})'
             )
 
@@ -778,11 +779,11 @@ class SDP_ServiceSearchAttributeResponse(SDP_PDU):
 class Client:
     def __init__(self, connection: Connection, mtu: int = 0) -> None:
         self.connection = connection
-        self.channel: Optional[l2cap.ClassicChannel] = None
+        self.channel: l2cap.ClassicChannel | None = None
         self.mtu = mtu
         self.request_semaphore = asyncio.Semaphore(1)
-        self.pending_request: Optional[SDP_PDU] = None
-        self.pending_response: Optional[asyncio.futures.Future[SDP_PDU]] = None
+        self.pending_request: SDP_PDU | None = None
+        self.pending_response: asyncio.futures.Future[SDP_PDU] | None = None
         self.next_transaction_id = 0
 
     async def connect(self) -> None:
@@ -898,7 +899,7 @@ class Client:
     async def search_attributes(
         self,
         uuids: Iterable[core.UUID],
-        attribute_ids: Iterable[Union[int, tuple[int, int]]],
+        attribute_ids: Iterable[int | tuple[int, int]],
     ) -> list[list[ServiceAttribute]]:
         """
         Search for attributes by UUID and attribute IDs.
@@ -970,7 +971,7 @@ class Client:
     async def get_attributes(
         self,
         service_record_handle: int,
-        attribute_ids: Iterable[Union[int, tuple[int, int]]],
+        attribute_ids: Iterable[int | tuple[int, int]],
     ) -> list[ServiceAttribute]:
         """
         Get attributes for a service.
@@ -1042,10 +1043,10 @@ class Client:
 # -----------------------------------------------------------------------------
 class Server:
     CONTINUATION_STATE = bytes([0x01, 0x00])
-    channel: Optional[l2cap.ClassicChannel]
+    channel: l2cap.ClassicChannel | None
     Service = NewType('Service', list[ServiceAttribute])
     service_records: dict[int, Service]
-    current_response: Union[None, bytes, tuple[int, list[int]]]
+    current_response: None | bytes | tuple[int, list[int]]
 
     def __init__(self, device: Device) -> None:
         self.device = device
@@ -1123,7 +1124,7 @@ class Server:
         self,
         continuation_state: bytes,
         transaction_id: int,
-    ) -> Optional[bool]:
+    ) -> bool | None:
         # Check if this is a valid continuation
         if len(continuation_state) > 1:
             if (

bumble/smp.py

@@ -27,17 +27,9 @@ from __future__ import annotations
 import asyncio
 import enum
 import logging
+from collections.abc import Awaitable, Callable
 from dataclasses import dataclass, field
-from typing import (
-    TYPE_CHECKING,
-    Any,
-    Awaitable,
-    Callable,
-    ClassVar,
-    Optional,
-    TypeVar,
-    cast,
-)
+from typing import TYPE_CHECKING, ClassVar, TypeVar, cast
 
 from bumble import crypto, utils
 from bumble.colors import color
@@ -213,10 +205,10 @@ class SMP_Command:
     fields: ClassVar[Fields]
     code: int = field(default=0, init=False)
     name: str = field(default='', init=False)
-    _payload: Optional[bytes] = field(default=None, init=False)
+    _payload: bytes | None = field(default=None, init=False)
 
     @classmethod
-    def from_bytes(cls, pdu: bytes) -> "SMP_Command":
+    def from_bytes(cls, pdu: bytes) -> SMP_Command:
         code = pdu[0]
 
         subclass = SMP_Command.smp_classes.get(code)
@@ -554,7 +546,7 @@ class OobContext:
     r: bytes
 
     def __init__(
-        self, ecc_key: Optional[crypto.EccKey] = None, r: Optional[bytes] = None
+        self, ecc_key: crypto.EccKey | None = None, r: bytes | None = None
     ) -> None:
         self.ecc_key = crypto.EccKey.generate() if ecc_key is None else ecc_key
         self.r = crypto.r() if r is None else r
@@ -570,7 +562,7 @@ class OobLegacyContext:
 
     tk: bytes
 
-    def __init__(self, tk: Optional[bytes] = None) -> None:
+    def __init__(self, tk: bytes | None = None) -> None:
         self.tk = crypto.r() if tk is None else tk
 
 
@@ -677,31 +669,31 @@ class Session:
         self.stk = None
         self.ltk_ediv = 0
         self.ltk_rand = bytes(8)
-        self.link_key: Optional[bytes] = None
+        self.link_key: bytes | None = None
         self.maximum_encryption_key_size: int = 0
         self.initiator_key_distribution: int = 0
         self.responder_key_distribution: int = 0
-        self.peer_random_value: Optional[bytes] = None
+        self.peer_random_value: bytes | None = None
         self.peer_public_key_x: bytes = bytes(32)
         self.peer_public_key_y = bytes(32)
         self.peer_ltk = None
         self.peer_ediv = None
-        self.peer_rand: Optional[bytes] = None
+        self.peer_rand: bytes | None = None
         self.peer_identity_resolving_key = None
-        self.peer_bd_addr: Optional[Address] = None
+        self.peer_bd_addr: Address | None = None
         self.peer_signature_key = None
         self.peer_expected_distributions: list[type[SMP_Command]] = []
         self.dh_key = b''
         self.confirm_value = None
-        self.passkey: Optional[int] = None
+        self.passkey: int | None = None
         self.passkey_ready = asyncio.Event()
         self.passkey_step = 0
         self.passkey_display = False
         self.pairing_method: PairingMethod = PairingMethod.JUST_WORKS
         self.pairing_config = pairing_config
-        self.wait_before_continuing: Optional[asyncio.Future[None]] = None
+        self.wait_before_continuing: asyncio.Future[None] | None = None
         self.completed = False
-        self.ctkd_task: Optional[Awaitable[None]] = None
+        self.ctkd_task: Awaitable[None] | None = None
 
         # Decide if we're the initiator or the responder
         self.is_initiator = is_initiator
@@ -720,7 +712,7 @@ class Session:
 
         # Create a future that can be used to wait for the session to complete
         if self.is_initiator:
-            self.pairing_result: Optional[asyncio.Future[None]] = (
+            self.pairing_result: asyncio.Future[None] | None = (
                 asyncio.get_running_loop().create_future()
             )
         else:
@@ -828,7 +820,7 @@ class Session:
     def auth_req(self) -> int:
         return smp_auth_req(self.bonding, self.mitm, self.sc, self.keypress, self.ct2)
 
-    def get_long_term_key(self, rand: bytes, ediv: int) -> Optional[bytes]:
+    def get_long_term_key(self, rand: bytes, ediv: int) -> bytes | None:
         if not self.sc and not self.completed:
             if rand == self.ltk_rand and ediv == self.ltk_ediv:
                 return self.stk
@@ -939,7 +931,7 @@ class Session:
             self.pairing_config.delegate.display_number(self.passkey, digits=6)
         )
 
-    def input_passkey(self, next_steps: Optional[Callable[[], None]] = None) -> None:
+    def input_passkey(self, next_steps: Callable[[], None] | None = None) -> None:
         # Prompt the user for the passkey displayed on the peer
         def after_input(passkey: int) -> None:
             self.passkey = passkey
@@ -956,7 +948,7 @@ class Session:
         self.prompt_user_for_number(after_input)
 
     def display_or_input_passkey(
-        self, next_steps: Optional[Callable[[], None]] = None
+        self, next_steps: Callable[[], None] | None = None
     ) -> None:
         if self.passkey_display:
 
@@ -1006,7 +998,6 @@ class Session:
         self.send_command(response)
 
     def send_pairing_confirm_command(self) -> None:
-
         if self.pairing_method != PairingMethod.OOB:
             self.r = crypto.r()
             logger.debug(f'generated random: {self.r.hex()}')
@@ -1842,7 +1833,6 @@ class Session:
             self.send_public_key_command()
 
             def next_steps() -> None:
-
                 if self.pairing_method in (
                     PairingMethod.JUST_WORKS,
                     PairingMethod.NUMERIC_COMPARISON,
@@ -1929,7 +1919,7 @@ class Manager(utils.EventEmitter):
     sessions: dict[int, Session]
     pairing_config_factory: Callable[[Connection], PairingConfig]
     session_proxy: type[Session]
-    _ecc_key: Optional[crypto.EccKey]
+    _ecc_key: crypto.EccKey | None
 
     def __init__(
         self,
@@ -2022,7 +2012,7 @@ class Manager(utils.EventEmitter):
         self.device.on_pairing_start(session.connection)
 
     async def on_pairing(
-        self, session: Session, identity_address: Optional[Address], keys: PairingKeys
+        self, session: Session, identity_address: Address | None, keys: PairingKeys
     ) -> None:
         # Store the keys in the key store
         if self.device.keystore and identity_address is not None:
@@ -2041,7 +2031,7 @@ class Manager(utils.EventEmitter):
 
     def get_long_term_key(
         self, connection: Connection, rand: bytes, ediv: int
-    ) -> Optional[bytes]:
+    ) -> bytes | None:
         if session := self.sessions.get(connection.handle):
             return session.get_long_term_key(rand, ediv)
 

bumble/snoop.py

@@ -16,13 +16,14 @@ import datetime
 import logging
 import os
 import struct
+from collections.abc import Generator
 
 # -----------------------------------------------------------------------------
 # Imports
 # -----------------------------------------------------------------------------
 from contextlib import contextmanager
 from enum import IntEnum
-from typing import BinaryIO, Generator
+from typing import BinaryIO
 
 from bumble import core
 from bumble.hci import HCI_COMMAND_PACKET, HCI_EVENT_PACKET
@@ -65,7 +66,7 @@ class BtSnooper(Snooper):
     """
 
     IDENTIFICATION_PATTERN = b'btsnoop\0'
-    TIMESTAMP_ANCHOR = datetime.datetime(2000, 1, 1)
+    TIMESTAMP_ANCHOR = datetime.datetime(2000, 1, 1, tzinfo=datetime.timezone.utc)
     TIMESTAMP_DELTA = 0x00E03AB44A676000
     ONE_MS = datetime.timedelta(microseconds=1)
 
@@ -85,7 +86,13 @@ class BtSnooper(Snooper):
 
         # Compute the current timestamp
         timestamp = (
-            int((datetime.datetime.utcnow() - self.TIMESTAMP_ANCHOR) / self.ONE_MS)
+            int(
+                (
+                    datetime.datetime.now(tz=datetime.timezone.utc)
+                    - self.TIMESTAMP_ANCHOR
+                )
+                / self.ONE_MS
+            )
             + self.TIMESTAMP_DELTA
         )
 
@@ -129,7 +136,7 @@ def create_snooper(spec: str) -> Generator[Snooper, None, None]:
           records will be written to that file if it can be opened/created.
           The keyword args that may be referenced by the string pattern are:
             now: the value of `datetime.now()`
-            utcnow: the value of `datetime.utcnow()`
+            utcnow: the value of `datetime.now(tz=datetime.timezone.utc)`
             pid: the current process ID.
             instance: the instance ID in the current process.
 
@@ -153,7 +160,7 @@ def create_snooper(spec: str) -> Generator[Snooper, None, None]:
             global _SNOOPER_INSTANCE_COUNT
             file_path = io_name.format(
                 now=datetime.datetime.now(),
-                utcnow=datetime.datetime.utcnow(),
+                utcnow=datetime.datetime.now(tz=datetime.timezone.utc),
                 pid=os.getpid(),
                 instance=_SNOOPER_INSTANCE_COUNT,
             )

bumble/tools/generate_company_id_list.py

@@ -27,7 +27,7 @@ import sys
 import yaml
 
 # -----------------------------------------------------------------------------
-with open(sys.argv[1], "r") as yaml_file:
+with open(sys.argv[1]) as yaml_file:
     root = yaml.safe_load(yaml_file)
     companies = {}
     for company in root["company_identifiers"]:

bumble/tools/intel_util.py

@@ -18,7 +18,7 @@ import asyncio
 # Imports
 # -----------------------------------------------------------------------------
 import logging
-from typing import Any, Optional
+from typing import Any
 
 import click
 
@@ -47,7 +47,7 @@ def print_device_info(device_info: dict[intel.ValueType, Any]) -> None:
 
 
 # -----------------------------------------------------------------------------
-async def get_driver(host: Host, force: bool) -> Optional[intel.Driver]:
+async def get_driver(host: Host, force: bool) -> intel.Driver | None:
     # Create a driver
     driver = await intel.Driver.for_host(host, force)
     if driver is None:

bumble/tools/rtk_fw_download.py

@@ -21,11 +21,11 @@ import urllib.error
 import urllib.request
 
 import click
+from bumble.tools import rtk_util
 
 import bumble.logging
 from bumble.colors import color
 from bumble.drivers import rtk
-from bumble.tools import rtk_util
 
 # -----------------------------------------------------------------------------
 # Logging

bumble/tools/rtk_util.py

@@ -21,7 +21,7 @@ import logging
 import click
 
 import bumble.logging
-from bumble import company_ids, hci, transport
+from bumble import transport
 from bumble.drivers import rtk
 from bumble.host import Host
 

bumble/transport/__init__.py

@@ -18,7 +18,6 @@
 import logging
 import os
 import re
-from typing import Optional
 
 from bumble import utils
 from bumble.snoop import create_snooper
@@ -111,7 +110,7 @@ async def open_transport(name: str) -> Transport:
 
 
 # -----------------------------------------------------------------------------
-async def _open_transport(scheme: str, spec: Optional[str]) -> Transport:
+async def _open_transport(scheme: str, spec: str | None) -> Transport:
     # pylint: disable=import-outside-toplevel
     # pylint: disable=too-many-return-statements