dbus-fast 3.0.0__cp314-cp314-musllinux_1_2_aarch64.whl

dbus_fast/__init__.py

@@ -0,0 +1,82 @@
+from . import introspection, message_bus, proxy_object, service
+from .constants import (
+    ArgDirection,
+    BusType,
+    ErrorType,
+    MessageFlag,
+    MessageType,
+    NameFlag,
+    PropertyAccess,
+    ReleaseNameReply,
+    RequestNameReply,
+)
+from .errors import (
+    AuthError,
+    DBusError,
+    InterfaceNotFoundError,
+    InvalidAddressError,
+    InvalidBusNameError,
+    InvalidInterfaceNameError,
+    InvalidIntrospectionError,
+    InvalidMemberNameError,
+    InvalidMessageError,
+    InvalidObjectPathError,
+    InvalidSignatureError,
+    SignalDisabledError,
+    SignatureBodyMismatchError,
+)
+from .message import Message
+from .signature import SignatureTree, SignatureType, Variant
+from .unpack import unpack_variants
+from .validators import (
+    assert_bus_name_valid,
+    assert_interface_name_valid,
+    assert_member_name_valid,
+    assert_object_path_valid,
+    is_bus_name_valid,
+    is_interface_name_valid,
+    is_member_name_valid,
+    is_object_path_valid,
+)
+
+__all__ = [
+    "ArgDirection",
+    "AuthError",
+    "BusType",
+    "DBusError",
+    "ErrorType",
+    "InterfaceNotFoundError",
+    "InvalidAddressError",
+    "InvalidBusNameError",
+    "InvalidInterfaceNameError",
+    "InvalidIntrospectionError",
+    "InvalidMemberNameError",
+    "InvalidMessageError",
+    "InvalidObjectPathError",
+    "InvalidSignatureError",
+    "Message",
+    "MessageFlag",
+    "MessageType",
+    "NameFlag",
+    "PropertyAccess",
+    "ReleaseNameReply",
+    "RequestNameReply",
+    "SignalDisabledError",
+    "SignatureBodyMismatchError",
+    "SignatureTree",
+    "SignatureType",
+    "Variant",
+    "assert_bus_name_valid",
+    "assert_interface_name_valid",
+    "assert_member_name_valid",
+    "assert_object_path_valid",
+    "introspection",
+    "is_bus_name_valid",
+    "is_interface_name_valid",
+    "is_member_name_valid",
+    "is_object_path_valid",
+    "message_bus",
+    "proxy_object",
+    "service",
+    "unpack_variants",
+]

dbus_fast/__version__.py

@@ -0,0 +1,10 @@
+__title__ = "dbus_fast"
+__description__ = (
+    "A performant zero-dependency DBus library for Python with asyncio support"
+)
+__url__ = "https://github.com/bluetooth-devices/dbus-fast"
+__version__ = "3.0.0"
+__author__ = "Bluetooth Devices authors, Tony Crisci"
+__author_email__ = "bluetooth@koston.org"
+__license__ = "MIT"
+__copyright__ = "Copyright 2022 Bluetooth Devices authors, 2019 Tony Crisci"

dbus_fast/_private/__init__.py

@@ -0,0 +1 @@
+from __future__ import annotations

dbus_fast/_private/_cython_compat.py

@@ -0,0 +1,14 @@
+"""Stub for when Cython is not available."""
+
+from __future__ import annotations
+
+
+class FakeCython:
+    """Stub for when Cython is not available."""
+
+    @property
+    def compiled(self) -> bool:
+        return False
+
+
+FAKE_CYTHON = FakeCython()

dbus_fast/_private/address.pxd

@@ -0,0 +1,15 @@
+"""cdefs for address.py"""
+
+import cython
+
+
+cdef object unquote
+
+@cython.locals(kv=cython.str, opt_string=cython.str, address=cython.str)
+cpdef parse_address(cython.str address_str)
+
+cpdef get_bus_address(object bus_type)
+
+cpdef get_session_bus_address()
+
+cpdef get_system_bus_address()

dbus_fast/_private/address.py

@@ -0,0 +1,119 @@
+# cython: freethreading_compatible = True
+
+from __future__ import annotations
+
+import os
+import re
+from urllib.parse import unquote
+
+from ..constants import BusType
+from ..errors import InvalidAddressError
+
+invalid_address_chars_re = re.compile(r"[^-0-9A-Za-z_/.%]")
+
+str_ = str
+
+
+def parse_address(address_str: str_) -> list[tuple[str, dict[str, str]]]:
+    """Parse a dbus address string into a list of addresses."""
+    addresses: list[tuple[str, dict[str, str]]] = []
+
+    for address in address_str.split(";"):
+        if not address:
+            continue
+        if address.find(":") == -1:
+            raise InvalidAddressError("address did not contain a transport")
+
+        transport, opt_string = address.split(":", 1)
+        options: dict[str, str] = {}
+
+        for kv in opt_string.split(","):
+            if not kv:
+                continue
+            if kv.find("=") == -1:
+                raise InvalidAddressError("address option did not contain a value")
+            k, v = kv.split("=", 1)
+            if invalid_address_chars_re.search(v):
+                raise InvalidAddressError("address contains invalid characters")
+            # XXX the actual unquote rules are simpler than this
+            options[k] = unquote(v)
+
+        addresses.append((transport, options))
+
+    if not addresses:
+        raise InvalidAddressError(
+            f'address string contained no addresses: "{address_str}"'
+        )
+
+    return addresses
+
+
+def get_system_bus_address() -> str:
+    """Get the system bus address from the environment or return the default."""
+    return (
+        os.environ.get("DBUS_SYSTEM_BUS_ADDRESS")
+        or "unix:path=/var/run/dbus/system_bus_socket"
+    )
+
+
+display_re = re.compile(r".*:([0-9]+)\.?.*")
+remove_quotes_re = re.compile(r"""^['"]?(.*?)['"]?$""")
+
+
+def get_session_bus_address() -> str:
+    """Get the session bus address from the environment or return the default."""
+    dbus_session_bus_address = os.environ.get("DBUS_SESSION_BUS_ADDRESS")
+    if dbus_session_bus_address:
+        return dbus_session_bus_address
+
+    home = os.environ["HOME"]
+    if "DISPLAY" not in os.environ:
+        raise InvalidAddressError(
+            "DBUS_SESSION_BUS_ADDRESS not set and could not get DISPLAY environment variable to get bus address"
+        )
+
+    display = os.environ["DISPLAY"]
+    try:
+        display = display_re.search(display).group(1)
+    except Exception as ex:
+        raise InvalidAddressError(
+            f"DBUS_SESSION_BUS_ADDRESS not set and could not parse DISPLAY environment variable to get bus address: {display}"
+        ) from ex
+
+    # XXX: this will block but they're very small files and fs operations
+    # should be fairly reliable. fix this by passing in an async func to read
+    # the file for each io backend.
+    machine_id = None
+    with open("/var/lib/dbus/machine-id") as f:
+        machine_id = f.read().rstrip()
+
+    dbus_info_file_name = f"{home}/.dbus/session-bus/{machine_id}-{display}"
+    dbus_info: str | None = None
+    try:
+        with open(dbus_info_file_name) as f:
+            dbus_info = f.read().rstrip()
+    except Exception as ex:
+        raise InvalidAddressError(
+            f"could not open dbus info file: {dbus_info_file_name}"
+        ) from ex
+
+    for line in dbus_info.split("\n"):
+        if line.strip().startswith("DBUS_SESSION_BUS_ADDRESS="):
+            _, addr = line.split("=", 1)
+            if not addr:
+                raise InvalidAddressError(
+                    f"DBUS_SESSION_BUS_ADDRESS variable not set correctly in dbus info file: {dbus_info_file_name}"
+                )
+            addr = remove_quotes_re.search(addr).group(1)
+            return addr
+
+    raise InvalidAddressError("could not find dbus session bus address")
+
+
+def get_bus_address(bus_type: BusType) -> str:
+    """Get the address of the bus specified by the bus type."""
+    if bus_type == BusType.SESSION:
+        return get_session_bus_address()
+    if bus_type == BusType.SYSTEM:
+        return get_system_bus_address()
+    raise Exception(f"got unknown bus type: {bus_type}")

dbus_fast/_private/constants.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+from enum import Enum
+
+PROTOCOL_VERSION = 1
+
+LITTLE_ENDIAN = ord("l")
+BIG_ENDIAN = ord("B")
+
+
+class HeaderField(Enum):
+    PATH = 1
+    INTERFACE = 2
+    MEMBER = 3
+    ERROR_NAME = 4
+    REPLY_SERIAL = 5
+    DESTINATION = 6
+    SENDER = 7
+    SIGNATURE = 8
+    UNIX_FDS = 9

dbus_fast/_private/marshaller.pxd

@@ -0,0 +1,110 @@
+"""cdefs for marshaller.py"""
+
+import cython
+
+from ..signature cimport SignatureTree, SignatureType, Variant
+
+
+cdef object PACK_UINT32
+
+cdef bytes PACKED_UINT32_ZERO
+cdef bytes PACKED_BOOL_TRUE
+cdef bytes PACKED_BOOL_FALSE
+
+cdef get_signature_tree
+
+cdef class Marshaller:
+
+    cdef SignatureTree signature_tree
+    cdef bytearray _buf
+    cdef cython.list body
+
+    cdef _buffer(self)
+
+    cpdef align(self, unsigned int n)
+
+    @cython.locals(
+        offset=cython.ulong,
+    )
+    cdef unsigned int _align(self, unsigned int n)
+
+    cpdef write_boolean(self, bint boolean, SignatureType type_)
+
+    @cython.locals(
+        written=cython.uint,
+    )
+    cdef unsigned int _write_boolean(self, bint boolean)
+
+    cpdef write_string(self, object value, SignatureType type_)
+
+    @cython.locals(
+        buf=cython.bytearray,
+        value_len=cython.uint,
+        signature_len=cython.uint,
+        written=cython.uint,
+    )
+    cdef unsigned int _write_string(self, object value)
+
+    @cython.locals(
+        signature_len=cython.uint,
+    )
+    cdef unsigned int _write_signature(self, bytes signature_bytes)
+
+    cpdef write_array(self, object array, SignatureType type_)
+
+    @cython.locals(
+        array_len=cython.uint,
+        buf=cython.bytearray,
+        written=cython.uint,
+        token=cython.str,
+        child_type=SignatureType,
+        array_len_packed=cython.bytes,
+        size=cython.uint,
+        writer=cython.object,
+        packer=cython.object,
+        i=cython.uint,
+    )
+    cdef unsigned int _write_array(self, object array, SignatureType type_)
+
+    cpdef write_struct(self, object array, SignatureType type_)
+
+    @cython.locals(
+        written=cython.uint,
+        i=cython.uint,
+    )
+    cdef unsigned int _write_struct(self, object array, SignatureType type_)
+
+    cpdef write_variant(self, Variant variant, SignatureType type_)
+
+    @cython.locals(
+        written=cython.uint,
+        signature=cython.str,
+        signature_bytes=cython.bytes,
+    )
+    cdef unsigned int _write_variant(self, Variant variant, SignatureType type_)
+
+    @cython.locals(
+        written=cython.uint,
+        size=cython.uint,
+    )
+    cdef unsigned int _write_single(self, SignatureType type_, object body)
+
+    @cython.locals(
+        written=cython.uint,
+        t=cython.str,
+    )
+    cpdef write_dict_entry(self, cython.list dict_entry, SignatureType type_)
+
+    cpdef marshall(self)
+
+    cdef _marshall(self)
+
+    @cython.locals(
+        offset=cython.ulong,
+        t=cython.str,
+        size=cython.uint,
+        writer=cython.object,
+        packer=cython.object,
+        type_=SignatureType,
+    )
+    cdef _construct_buffer(self)

dbus_fast/_private/marshaller.py

@@ -0,0 +1,231 @@
+# cython: freethreading_compatible = True
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from struct import Struct, error
+from typing import Any
+
+from ..signature import SignatureType, Variant, get_signature_tree
+
+PACK_LITTLE_ENDIAN = "<"
+
+PACK_UINT32 = Struct(f"{PACK_LITTLE_ENDIAN}I").pack
+PACKED_UINT32_ZERO = PACK_UINT32(0)
+PACKED_BOOL_FALSE = PACK_UINT32(0)
+PACKED_BOOL_TRUE = PACK_UINT32(1)
+
+_int = int
+_bytes = bytes
+_str = str
+
+
+class Marshaller:
+    """Marshall data for Dbus."""
+
+    __slots__ = ("_buf", "body", "signature_tree")
+
+    def __init__(self, signature: str, body: list[Any]) -> None:
+        """Marshaller constructor."""
+        self.signature_tree = get_signature_tree(signature)
+        self._buf = bytearray()
+        self.body = body
+
+    @property
+    def buffer(self) -> bytearray:
+        return self._buf
+
+    def _buffer(self) -> bytearray:
+        return self._buf
+
+    def align(self, n: _int) -> int:
+        return self._align(n)
+
+    def _align(self, n: _int) -> _int:
+        offset = n - len(self._buf) % n
+        if offset == 0 or offset == n:
+            return 0
+        for _ in range(offset):
+            self._buf.append(0)
+        return offset
+
+    def write_boolean(self, boolean: bool, type_: SignatureType) -> int:
+        return self._write_boolean(boolean)
+
+    def _write_boolean(self, boolean: bool) -> int:
+        written = self._align(4)
+        self._buf += PACKED_BOOL_TRUE if boolean else PACKED_BOOL_FALSE
+        return written + 4
+
+    def write_signature(self, signature: str, type_: SignatureType) -> int:
+        return self._write_signature(signature.encode())
+
+    def _write_signature(self, signature_bytes: _bytes) -> int:
+        signature_len = len(signature_bytes)
+        buf = self._buf
+        buf.append(signature_len)
+        buf += signature_bytes
+        buf.append(0)
+        return signature_len + 2
+
+    def write_string(self, value: _str, type_: SignatureType) -> int:
+        return self._write_string(value)
+
+    def _write_string(self, value: _str) -> int:
+        value_bytes = value.encode()
+        value_len = len(value_bytes)
+        written = self._align(4) + 4
+        buf = self._buf
+        buf += PACK_UINT32(value_len)
+        buf += value_bytes
+        written += value_len
+        buf.append(0)
+        written += 1
+        return written
+
+    def write_variant(self, variant: Variant, type_: SignatureType) -> int:
+        return self._write_variant(variant, type_)
+
+    def _write_variant(self, variant: Variant, type_: SignatureType) -> int:
+        signature = variant.signature
+        signature_bytes = signature.encode()
+        written = self._write_signature(signature_bytes)
+        written += self._write_single(variant.type, variant.value)
+        return written
+
+    def write_array(
+        self, array: bytes | list[Any] | dict[Any, Any], type_: SignatureType
+    ) -> int:
+        return self._write_array(array, type_)
+
+    def _write_array(
+        self, array: bytes | list[Any] | dict[Any, Any], type_: SignatureType
+    ) -> int:
+        # TODO max array size is 64MiB (67108864 bytes)
+        written = self._align(4)
+        # length placeholder
+        buf: bytearray = self._buf
+        offset = len(buf)
+        written += self._align(4) + 4
+        buf += PACKED_UINT32_ZERO
+        child_type = type_.children[0]
+        token = child_type.token
+
+        if token in "xtd{(":
+            # the first alignment is not included in array size
+            written += self._align(8)
+
+        array_len = 0
+        if token == "{":
+            for key, value in array.items():  # type: ignore[union-attr]
+                array_len += self.write_dict_entry([key, value], child_type)
+        elif token == "y":
+            array_len = len(array)
+            buf += array  # type: ignore[arg-type]
+        elif token == "(":
+            for value in array:
+                array_len += self._write_struct(value, child_type)
+        else:
+            writer, packer, size = self._writers[token]
+            if not writer:
+                for value in array:
+                    array_len += self._align(size) + size
+                    buf += packer(value)  # type: ignore[misc]
+            else:
+                for value in array:
+                    array_len += writer(self, value, child_type)
+
+        array_len_packed = PACK_UINT32(array_len)
+        for i in range(offset, offset + 4):
+            buf[i] = array_len_packed[i - offset]
+
+        return written + array_len
+
+    def write_struct(self, array: tuple[Any] | list[Any], type_: SignatureType) -> int:
+        return self._write_struct(array, type_)
+
+    def _write_struct(self, array: tuple[Any] | list[Any], type_: SignatureType) -> int:
+        written = self._align(8)
+        for i, value in enumerate(array):
+            written += self._write_single(type_.children[i], value)
+        return written
+
+    def write_dict_entry(self, dict_entry: list[Any], type_: SignatureType) -> int:
+        written = self._align(8)
+        written += self._write_single(type_.children[0], dict_entry[0])
+        written += self._write_single(type_.children[1], dict_entry[1])
+        return written
+
+    def _write_single(self, type_: SignatureType, body: Any) -> int:
+        t = type_.token
+        if t == "y":
+            self._buf.append(body)
+            return 1
+        if t == "u":
+            written = self._align(4)
+            self._buf += PACK_UINT32(body)
+            return written + 4
+        if t == "a":
+            return self._write_array(body, type_)
+        if t == "s" or t == "o":
+            return self._write_string(body)
+        if t == "v":
+            return self._write_variant(body, type_)
+        if t == "b":
+            return self._write_boolean(body)
+        writer, packer, size = self._writers[t]
+        if not writer:
+            written = self._align(size)
+            self._buf += packer(body)  # type: ignore[misc]
+            return written + size
+        return writer(self, body, type_)
+
+    def marshall(self) -> bytearray:
+        """Marshalls the body into a byte array"""
+        return self._marshall()
+
+    def _marshall(self) -> bytearray:
+        """Marshalls the body into a byte array"""
+        try:
+            return self._construct_buffer()
+        except KeyError as ex:
+            raise NotImplementedError(
+                f'type is not implemented yet: "{ex.args}"'
+            ) from ex
+        except error:
+            self.signature_tree.verify(self.body)
+        raise RuntimeError("should not reach here")
+
+    def _construct_buffer(self) -> bytearray:
+        self._buf.clear()
+        body = self.body
+        for i, type_ in enumerate(self.signature_tree.types):
+            self._write_single(type_, body[i])
+        return self._buf
+
+    _writers: dict[
+        str,
+        tuple[
+            Callable[[Any, Any, SignatureType], int] | None,
+            Callable[[Any], bytes] | None,
+            int,
+        ],
+    ] = {
+        "y": (None, Struct(f"{PACK_LITTLE_ENDIAN}B").pack, 1),
+        "b": (write_boolean, None, 0),
+        "n": (None, Struct(f"{PACK_LITTLE_ENDIAN}h").pack, 2),
+        "q": (None, Struct(f"{PACK_LITTLE_ENDIAN}H").pack, 2),
+        "i": (None, Struct(f"{PACK_LITTLE_ENDIAN}i").pack, 4),
+        "u": (None, PACK_UINT32, 4),
+        "x": (None, Struct(f"{PACK_LITTLE_ENDIAN}q").pack, 8),
+        "t": (None, Struct(f"{PACK_LITTLE_ENDIAN}Q").pack, 8),
+        "d": (None, Struct(f"{PACK_LITTLE_ENDIAN}d").pack, 8),
+        "h": (None, Struct(f"{PACK_LITTLE_ENDIAN}I").pack, 4),
+        "o": (write_string, None, 0),
+        "s": (write_string, None, 0),
+        "g": (write_signature, None, 0),
+        "a": (write_array, None, 0),
+        "(": (write_struct, None, 0),
+        "{": (write_dict_entry, None, 0),
+        "v": (write_variant, None, 0),
+    }