reformat with yapf

Author: bdraco

dbus_next/_private/constants.py

@@ -18,6 +18,4 @@ class HeaderField(Enum):
     UNIX_FDS = 9
 
 
-HEADER_NAME_MAP = {
-    field.value: field.name for field in HeaderField
-}
+HEADER_NAME_MAP = {field.value: field.name for field in HeaderField}

dbus_next/_private/marshaller.py

@@ -3,6 +3,7 @@
 
 
 class Marshaller:
+
     def __init__(self, signature, body):
         self.signature_tree = SignatureTree._get(signature)
         self.signature_tree.verify(body)

dbus_next/_private/unmarshaller.py

@@ -47,15 +47,8 @@
 HEADER_REPLY_SERIAL = HeaderField.REPLY_SERIAL.name
 HEADER_SENDER = HeaderField.SENDER.name
 
-READER_TYPE = Dict[
-    str,
-    Tuple[
-        Optional[Callable[["Unmarshaller", SignatureType], Any]],
-        Optional[str],
-        Optional[int],
-        Optional[Struct],
-    ],
-]
+READER_TYPE = Dict[str, Tuple[Optional[Callable[["Unmarshaller", SignatureType], Any]],
+                              Optional[str], Optional[int], Optional[Struct], ], ]
 
 
 class MarshallerStreamEndError(Exception):
@@ -117,17 +110,14 @@ def read_sock(self, length: int) -> bytes:
 
         try:
             msg, ancdata, *_ = self.sock.recvmsg(
-                length, socket.CMSG_LEN(MAX_UNIX_FDS * unix_fd_list.itemsize)
-            )
+                length, socket.CMSG_LEN(MAX_UNIX_FDS * unix_fd_list.itemsize))
         except BlockingIOError:
             raise MarshallerStreamEndError()
 
         for level, type_, data in ancdata:
             if not (level == socket.SOL_SOCKET and type_ == socket.SCM_RIGHTS):
                 continue
-            unix_fd_list.frombytes(
-                data[: len(data) - (len(data) % unix_fd_list.itemsize)]
-            )
+            unix_fd_list.frombytes(data[:len(data) - (len(data) % unix_fd_list.itemsize)])
             self.unix_fds.extend(list(unix_fd_list))
 
         return msg
@@ -187,9 +177,7 @@ def read_struct(self, type_: SignatureType):
 
     def read_dict_entry(self, type_: SignatureType):
         self.offset += -self.offset & 7  # align 8
-        return self.read_argument(type_.children[0]), self.read_argument(
-            type_.children[1]
-        )
+        return self.read_argument(type_.children[0]), self.read_argument(type_.children[1])
 
     def read_array(self, type_: SignatureType):
         self.offset += -self.offset & 3  # align 4 for the array
@@ -259,22 +247,14 @@ def _read_header(self):
 
         if endian != LITTLE_ENDIAN and endian != BIG_ENDIAN:
             raise InvalidMessageError(
-                f"Expecting endianness as the first byte, got {endian} from {buffer}"
-            )
+                f"Expecting endianness as the first byte, got {endian} from {buffer}")
         if protocol_version != PROTOCOL_VERSION:
-            raise InvalidMessageError(
-                f"got unknown protocol version: {protocol_version}"
-            )
+            raise InvalidMessageError(f"got unknown protocol version: {protocol_version}")
 
-        self.body_len, self.serial, self.header_len = UNPACK_LENGTHS[
-            endian
-        ].unpack_from(buffer, 4)
-        self.msg_len = (
-            self.header_len + (-self.header_len & 7) + self.body_len
-        )  # align 8
-        if (sys.byteorder == "little" and endian == LITTLE_ENDIAN) or (
-            sys.byteorder == "big" and endian == BIG_ENDIAN
-        ):
+        self.body_len, self.serial, self.header_len = UNPACK_LENGTHS[endian].unpack_from(buffer, 4)
+        self.msg_len = (self.header_len + (-self.header_len & 7) + self.body_len)  # align 8
+        if (sys.byteorder == "little" and endian == LITTLE_ENDIAN) or (sys.byteorder == "big"
+                                                                       and endian == BIG_ENDIAN):
             self.can_cast = True
         self.readers = self._readers_by_type[endian]
 
@@ -317,18 +297,17 @@ def unmarshall(self):
             return None
         return self.message
 
-    _complex_parsers: Dict[
-        str, Tuple[Callable[["Unmarshaller", SignatureType], Any], None, None, None]
-    ] = {
-        "b": (read_boolean, None, None, None),
-        "o": (read_string, None, None, None),
-        "s": (read_string, None, None, None),
-        "g": (read_signature, None, None, None),
-        "a": (read_array, None, None, None),
-        "(": (read_struct, None, None, None),
-        "{": (read_dict_entry, None, None, None),
-        "v": (read_variant, None, None, None),
-    }
+    _complex_parsers: Dict[str, Tuple[Callable[["Unmarshaller", SignatureType], Any], None, None,
+                                      None]] = {
+                                          "b": (read_boolean, None, None, None),
+                                          "o": (read_string, None, None, None),
+                                          "s": (read_string, None, None, None),
+                                          "g": (read_signature, None, None, None),
+                                          "a": (read_array, None, None, None),
+                                          "(": (read_struct, None, None, None),
+                                          "{": (read_dict_entry, None, None, None),
+                                          "v": (read_variant, None, None, None),
+                                      }
 
     _ctype_by_endian: Dict[int, Dict[str, Tuple[None, str, int, Struct]]] = {
         endian: {
@@ -343,6 +322,12 @@ def unmarshall(self):
     }
 
     _readers_by_type: Dict[int, READER_TYPE] = {
-        BIG_ENDIAN: {**_ctype_by_endian[BIG_ENDIAN], **_complex_parsers},
-        LITTLE_ENDIAN: {**_ctype_by_endian[LITTLE_ENDIAN], **_complex_parsers},
+        BIG_ENDIAN: {
+            **_ctype_by_endian[BIG_ENDIAN],
+            **_complex_parsers
+        },
+        LITTLE_ENDIAN: {
+            **_ctype_by_endian[LITTLE_ENDIAN],
+            **_complex_parsers
+        },
     }

dbus_next/_private/util.py

@@ -101,6 +101,7 @@ def parse_annotation(annotation: str) -> str:
     In this case, we must eval the result which we do only when given a string
     constant.
     '''
+
     def raise_value_error():
         raise ValueError(f'service annotations must be a string constant (got {annotation})')
 

dbus_next/aio/message_bus.py

@@ -28,6 +28,7 @@ def _future_set_result(fut, result):
 
 
 class _MessageWriter:
+
     def __init__(self, bus):
         self.messages = Queue()
         self.negotiate_unix_fd = bus._negotiate_unix_fd
@@ -114,6 +115,7 @@ class MessageBus(BaseMessageBus):
         and receive messages.
     :vartype connected: bool
     """
+
     def __init__(self,
                  bus_address: str = None,
                  bus_type: BusType = BusType.SESSION,
@@ -346,6 +348,7 @@ def _make_method_handler(self, interface, method):
             return super()._make_method_handler(interface, method)
 
         def handler(msg, send_reply):
+
             def done(fut):
                 with send_reply:
                     result = fut.result()

dbus_next/aio/proxy_object.py

@@ -72,7 +72,9 @@ class ProxyInterface(BaseProxyInterface):
     If the service returns an error for a DBus call, a :class:`DBusError
     <dbus_next.DBusError>` will be raised with information about the error.
     """
+
     def _add_method(self, intr_method):
+
         async def method_fn(*args, flags=MessageFlag.NONE):
             input_body, unix_fds = replace_fds_with_idx(intr_method.in_signature, list(args))
 
@@ -106,6 +108,7 @@ async def method_fn(*args, flags=MessageFlag.NONE):
         setattr(self, method_name, method_fn)
 
     def _add_property(self, intr_property):
+
         async def property_getter():
             msg = await self.bus.call(
                 Message(destination=self.bus_name,
@@ -151,6 +154,7 @@ class ProxyObject(BaseProxyObject):
 
     For more information, see the :class:`BaseProxyObject <dbus_next.proxy_object.BaseProxyObject>`.
     """
+
     def __init__(self, bus_name: str, path: str, introspection: Union[intr.Node, str, ET.Element],
                  bus: BaseMessageBus):
         super().__init__(bus_name, path, introspection, bus, ProxyInterface)

dbus_next/auth.py

@@ -35,6 +35,7 @@ class Authenticator:
 
     :seealso: https://dbus.freedesktop.org/doc/dbus-specification.html#auth-protocol
     """
+
     def _authentication_start(self, negotiate_unix_fd=False):
         raise NotImplementedError(
             'authentication_start() must be implemented in the inheriting class')
@@ -53,6 +54,7 @@ class AuthExternal(Authenticator):
 
     :sealso: https://dbus.freedesktop.org/doc/dbus-specification.html#auth-protocol
     """
+
     def __init__(self):
         self.negotiate_unix_fd = False
         self.negotiating_fds = False
@@ -84,6 +86,7 @@ class AuthAnnonymous(Authenticator):
 
     :sealso: https://dbus.freedesktop.org/doc/dbus-specification.html#auth-protocol
     """
+
     def _authentication_start(self, negotiate_unix_fd=False) -> str:
         if negotiate_unix_fd:
             raise AuthError(

dbus_next/errors.py

@@ -31,21 +31,25 @@ class SignalDisabledError(Exception):
 
 
 class InvalidBusNameError(TypeError):
+
     def __init__(self, name):
         super().__init__(f'invalid bus name: {name}')
 
 
 class InvalidObjectPathError(TypeError):
+
     def __init__(self, path):
         super().__init__(f'invalid object path: {path}')
 
 
 class InvalidInterfaceNameError(TypeError):
+
     def __init__(self, name):
         super().__init__(f'invalid interface name: {name}')
 
 
 class InvalidMemberNameError(TypeError):
+
     def __init__(self, member):
         super().__init__(f'invalid member name: {member}')
 
@@ -56,6 +60,7 @@ def __init__(self, member):
 
 
 class DBusError(Exception):
+
     def __init__(self, type_, text, reply=None):
         super().__init__(text)
 

dbus_next/glib/message_bus.py

@@ -24,6 +24,7 @@ class _GLibSource:
 
 
 class _MessageSource(_GLibSource):
+
     def __init__(self, bus):
         self.unmarshaller = None
         self.bus = bus
@@ -54,6 +55,7 @@ def dispatch(self, callback, user_data):
 
 
 class _MessageWritableSource(_GLibSource):
+
     def __init__(self, bus):
         self.bus = bus
         self.buf = b''
@@ -99,6 +101,7 @@ def dispatch(self, callback, user_data):
 
 
 class _AuthLineSource(_GLibSource):
+
     def __init__(self, stream):
         self.stream = stream
         self.buf = b''
@@ -146,6 +149,7 @@ class MessageBus(BaseMessageBus):
         be :class:`None` until the message bus connects.
     :vartype unique_name: str
     """
+
     def __init__(self,
                  bus_address: str = None,
                  bus_type: BusType = BusType.SESSION,
@@ -174,6 +178,7 @@ def connect(self, connect_notify: Callable[['MessageBus', Optional[Exception]],
             :class:`AuthError <dbus_next.AuthError>` on authorization errors.
         :type callback: :class:`Callable`
         """
+
         def authenticate_notify(exc):
             if exc is not None:
                 if connect_notify is not None:

dbus_next/glib/proxy_object.py

@@ -108,6 +108,7 @@ def set_callback(error: Exception)
     :class:`DBusError <dbus_next.DBusError>` will be raised with information
     about the error.
     """
+
     def _add_method(self, intr_method):
         in_len = len(intr_method.in_args)
         out_len = len(intr_method.out_args)
@@ -176,7 +177,9 @@ def callback(body, err):
         setattr(self, method_name_sync, method_fn_sync)
 
     def _add_property(self, intr_property):
+
         def property_getter(callback):
+
             def call_notify(msg, err):
                 if err:
                     callback(None, err)
@@ -226,6 +229,7 @@ def callback(value, err):
             return property_value
 
         def property_setter(value, callback):
+
             def call_notify(msg, err):
                 if err:
                     callback(None, err)
@@ -275,6 +279,7 @@ class ProxyObject(BaseProxyObject):
 
     For more information, see the :class:`BaseProxyObject <dbus_next.proxy_object.BaseProxyObject>`.
     """
+
     def __init__(self, bus_name: str, path: str, introspection: Union[intr.Node, str, ET.Element],
                  bus: BaseMessageBus):
         super().__init__(bus_name, path, introspection, bus, ProxyInterface)