diff libervia/frontends/bridge/dbus_bridge.py @ 4270:0d7bb4df2343

Reformatted code base using black.
author Goffi <goffi@goffi.org>
date Wed, 19 Jun 2024 18:44:57 +0200
parents 730f542e4ad0
children 4cf98f506269
line wrap: on
line diff
--- a/libervia/frontends/bridge/dbus_bridge.py	Tue Jun 18 12:06:45 2024 +0200
+++ b/libervia/frontends/bridge/dbus_bridge.py	Wed Jun 19 18:44:57 2024 +0200
@@ -33,12 +33,10 @@
 
 # Interface prefix
 const_INT_PREFIX = config.config_get(
-    config.parse_main_conf(),
-    "",
-    "bridge_dbus_int_prefix",
-    "org.libervia.Libervia")
+    config.parse_main_conf(), "", "bridge_dbus_int_prefix", "org.libervia.Libervia"
+)
 const_ERROR_PREFIX = const_INT_PREFIX + ".error"
-const_OBJ_PATH = '/org/libervia/Libervia/bridge'
+const_OBJ_PATH = "/org/libervia/Libervia/bridge"
 const_CORE_SUFFIX = ".core"
 const_PLUGIN_SUFFIX = ".plugin"
 const_TIMEOUT = 120
@@ -52,7 +50,7 @@
     """
     full_name = dbus_e.get_dbus_name()
     if full_name.startswith(const_ERROR_PREFIX):
-        name = dbus_e.get_dbus_name()[len(const_ERROR_PREFIX) + 1:]
+        name = dbus_e.get_dbus_name()[len(const_ERROR_PREFIX) + 1 :]
     else:
         name = full_name
     # XXX: dbus_e.args doesn't contain the original DBusException args, but we
@@ -62,7 +60,7 @@
     try:
         message, condition = ast.literal_eval(message)
     except (SyntaxError, ValueError, TypeError):
-        condition = ''
+        condition = ""
     return BridgeException(name, message, condition)
 
 
@@ -71,24 +69,33 @@
     def bridge_connect(self, callback, errback):
         try:
             self.sessions_bus = dbus.SessionBus()
-            self.db_object = self.sessions_bus.get_object(const_INT_PREFIX,
-                                                          const_OBJ_PATH)
-            self.db_core_iface = dbus.Interface(self.db_object,
-                                                dbus_interface=const_INT_PREFIX + const_CORE_SUFFIX)
-            self.db_plugin_iface = dbus.Interface(self.db_object,
-                                                  dbus_interface=const_INT_PREFIX + const_PLUGIN_SUFFIX)
+            self.db_object = self.sessions_bus.get_object(
+                const_INT_PREFIX, const_OBJ_PATH
+            )
+            self.db_core_iface = dbus.Interface(
+                self.db_object, dbus_interface=const_INT_PREFIX + const_CORE_SUFFIX
+            )
+            self.db_plugin_iface = dbus.Interface(
+                self.db_object, dbus_interface=const_INT_PREFIX + const_PLUGIN_SUFFIX
+            )
         except dbus.exceptions.DBusException as e:
-            if e._dbus_error_name in ('org.freedesktop.DBus.Error.ServiceUnknown',
-                                      'org.freedesktop.DBus.Error.Spawn.ExecFailed'):
+            if e._dbus_error_name in (
+                "org.freedesktop.DBus.Error.ServiceUnknown",
+                "org.freedesktop.DBus.Error.Spawn.ExecFailed",
+            ):
                 errback(BridgeExceptionNoService())
-            elif e._dbus_error_name == 'org.freedesktop.DBus.Error.NotSupported':
-                log.error(_("D-Bus is not launched, please see README to see instructions on how to launch it"))
+            elif e._dbus_error_name == "org.freedesktop.DBus.Error.NotSupported":
+                log.error(
+                    _(
+                        "D-Bus is not launched, please see README to see instructions on how to launch it"
+                    )
+                )
                 errback(BridgeInitError)
             else:
                 errback(e)
         else:
             callback()
-        #props = self.db_core_iface.getProperties()
+        # props = self.db_core_iface.getProperties()
 
     def register_signal(self, functionName, handler, iface="core"):
         if iface == "core":
@@ -96,10 +103,10 @@
         elif iface == "plugin":
             self.db_plugin_iface.connect_to_signal(functionName, handler)
         else:
-            log.error(_('Unknown interface'))
+            log.error(_("Unknown interface"))
 
     def __getattribute__(self, name):
-        """ usual __getattribute__ if the method exists, else try to find a plugin method """
+        """usual __getattribute__ if the method exists, else try to find a plugin method"""
         try:
             return object.__getattribute__(self, name)
         except AttributeError:
@@ -114,20 +121,26 @@
                 args = list(args)
 
                 if kwargs:
-                    if 'callback' in kwargs:
+                    if "callback" in kwargs:
                         async_ = True
-                        _callback = kwargs.pop('callback')
-                        _errback = kwargs.pop('errback', lambda failure: log.error(str(failure)))
+                        _callback = kwargs.pop("callback")
+                        _errback = kwargs.pop(
+                            "errback", lambda failure: log.error(str(failure))
+                        )
                     try:
-                        args.append(kwargs.pop('profile'))
+                        args.append(kwargs.pop("profile"))
                     except KeyError:
                         try:
-                            args.append(kwargs.pop('profile_key'))
+                            args.append(kwargs.pop("profile_key"))
                         except KeyError:
                             pass
                     # at this point, kwargs should be empty
                     if kwargs:
-                        log.warning("unexpected keyword arguments, they will be ignored: {}".format(kwargs))
+                        log.warning(
+                            "unexpected keyword arguments, they will be ignored: {}".format(
+                                kwargs
+                            )
+                        )
                 elif len(args) >= 2 and callable(args[-1]) and callable(args[-2]):
                     async_ = True
                     _errback = args.pop()
@@ -136,9 +149,11 @@
                 method = getattr(self.db_plugin_iface, name)
 
                 if async_:
-                    kwargs['timeout'] = const_TIMEOUT
-                    kwargs['reply_handler'] = _callback
-                    kwargs['error_handler'] = lambda err: _errback(dbus_to_bridge_exception(err))
+                    kwargs["timeout"] = const_TIMEOUT
+                    kwargs["reply_handler"] = _callback
+                    kwargs["error_handler"] = lambda err: _errback(
+                        dbus_to_bridge_exception(err)
+                    )
 
                 try:
                     return method(*args, **kwargs)
@@ -158,14 +173,25 @@
 
             return get_plugin_method
 
-    def action_launch(self, callback_id, data, profile_key="@DEFAULT@", callback=None, errback=None):
+    def action_launch(
+        self, callback_id, data, profile_key="@DEFAULT@", callback=None, errback=None
+    ):
         if callback is None:
             error_handler = None
         else:
             if errback is None:
                 errback = log.error
-            error_handler = lambda err:errback(dbus_to_bridge_exception(err))
-        return str(self.db_core_iface.action_launch(callback_id, data, profile_key, timeout=const_TIMEOUT, reply_handler=callback, error_handler=error_handler))
+            error_handler = lambda err: errback(dbus_to_bridge_exception(err))
+        return str(
+            self.db_core_iface.action_launch(
+                callback_id,
+                data,
+                profile_key,
+                timeout=const_TIMEOUT,
+                reply_handler=callback,
+                error_handler=error_handler,
+            )
+        )
 
     def actions_get(self, profile_key="@DEFAULT@", callback=None, errback=None):
         if callback is None:
@@ -173,12 +199,12 @@
         else:
             if errback is None:
                 errback = log.error
-            error_handler = lambda err:errback(dbus_to_bridge_exception(err))
-        kwargs={}
+            error_handler = lambda err: errback(dbus_to_bridge_exception(err))
+        kwargs = {}
         if callback is not None:
-            kwargs['timeout'] = const_TIMEOUT
-            kwargs['reply_handler'] = callback
-            kwargs['error_handler'] = error_handler
+            kwargs["timeout"] = const_TIMEOUT
+            kwargs["reply_handler"] = callback
+            kwargs["error_handler"] = error_handler
         return self.db_core_iface.actions_get(profile_key, **kwargs)
 
     def config_get(self, section, name, callback=None, errback=None):
@@ -187,45 +213,69 @@
         else:
             if errback is None:
                 errback = log.error
-            error_handler = lambda err:errback(dbus_to_bridge_exception(err))
-        kwargs={}
+            error_handler = lambda err: errback(dbus_to_bridge_exception(err))
+        kwargs = {}
         if callback is not None:
-            kwargs['timeout'] = const_TIMEOUT
-            kwargs['reply_handler'] = callback
-            kwargs['error_handler'] = error_handler
+            kwargs["timeout"] = const_TIMEOUT
+            kwargs["reply_handler"] = callback
+            kwargs["error_handler"] = error_handler
         return str(self.db_core_iface.config_get(section, name, **kwargs))
 
-    def connect(self, profile_key="@DEFAULT@", password='', options={}, callback=None, errback=None):
+    def connect(
+        self,
+        profile_key="@DEFAULT@",
+        password="",
+        options={},
+        callback=None,
+        errback=None,
+    ):
         if callback is None:
             error_handler = None
         else:
             if errback is None:
                 errback = log.error
-            error_handler = lambda err:errback(dbus_to_bridge_exception(err))
-        return self.db_core_iface.connect(profile_key, password, options, timeout=const_TIMEOUT, reply_handler=callback, error_handler=error_handler)
+            error_handler = lambda err: errback(dbus_to_bridge_exception(err))
+        return self.db_core_iface.connect(
+            profile_key,
+            password,
+            options,
+            timeout=const_TIMEOUT,
+            reply_handler=callback,
+            error_handler=error_handler,
+        )
 
-    def contact_add(self, entity_jid, profile_key="@DEFAULT@", callback=None, errback=None):
+    def contact_add(
+        self, entity_jid, profile_key="@DEFAULT@", callback=None, errback=None
+    ):
         if callback is None:
             error_handler = None
         else:
             if errback is None:
                 errback = log.error
-            error_handler = lambda err:errback(dbus_to_bridge_exception(err))
-        kwargs={}
+            error_handler = lambda err: errback(dbus_to_bridge_exception(err))
+        kwargs = {}
         if callback is not None:
-            kwargs['timeout'] = const_TIMEOUT
-            kwargs['reply_handler'] = callback
-            kwargs['error_handler'] = error_handler
+            kwargs["timeout"] = const_TIMEOUT
+            kwargs["reply_handler"] = callback
+            kwargs["error_handler"] = error_handler
         return self.db_core_iface.contact_add(entity_jid, profile_key, **kwargs)
 
-    def contact_del(self, entity_jid, profile_key="@DEFAULT@", callback=None, errback=None):
+    def contact_del(
+        self, entity_jid, profile_key="@DEFAULT@", callback=None, errback=None
+    ):
         if callback is None:
             error_handler = None
         else:
             if errback is None:
                 errback = log.error
-            error_handler = lambda err:errback(dbus_to_bridge_exception(err))
-        return self.db_core_iface.contact_del(entity_jid, profile_key, timeout=const_TIMEOUT, reply_handler=callback, error_handler=error_handler)
+            error_handler = lambda err: errback(dbus_to_bridge_exception(err))
+        return self.db_core_iface.contact_del(
+            entity_jid,
+            profile_key,
+            timeout=const_TIMEOUT,
+            reply_handler=callback,
+            error_handler=error_handler,
+        )
 
     def contact_get(self, arg_0, profile_key="@DEFAULT@", callback=None, errback=None):
         if callback is None:
@@ -233,22 +283,38 @@
         else:
             if errback is None:
                 errback = log.error
-            error_handler = lambda err:errback(dbus_to_bridge_exception(err))
-        return self.db_core_iface.contact_get(arg_0, profile_key, timeout=const_TIMEOUT, reply_handler=callback, error_handler=error_handler)
+            error_handler = lambda err: errback(dbus_to_bridge_exception(err))
+        return self.db_core_iface.contact_get(
+            arg_0,
+            profile_key,
+            timeout=const_TIMEOUT,
+            reply_handler=callback,
+            error_handler=error_handler,
+        )
 
-    def contact_update(self, entity_jid, name, groups, profile_key="@DEFAULT@", callback=None, errback=None):
+    def contact_update(
+        self,
+        entity_jid,
+        name,
+        groups,
+        profile_key="@DEFAULT@",
+        callback=None,
+        errback=None,
+    ):
         if callback is None:
             error_handler = None
         else:
             if errback is None:
                 errback = log.error
-            error_handler = lambda err:errback(dbus_to_bridge_exception(err))
-        kwargs={}
+            error_handler = lambda err: errback(dbus_to_bridge_exception(err))
+        kwargs = {}
         if callback is not None:
-            kwargs['timeout'] = const_TIMEOUT
-            kwargs['reply_handler'] = callback
-            kwargs['error_handler'] = error_handler
-        return self.db_core_iface.contact_update(entity_jid, name, groups, profile_key, **kwargs)
+            kwargs["timeout"] = const_TIMEOUT
+            kwargs["reply_handler"] = callback
+            kwargs["error_handler"] = error_handler
+        return self.db_core_iface.contact_update(
+            entity_jid, name, groups, profile_key, **kwargs
+        )
 
     def contacts_get(self, profile_key="@DEFAULT@", callback=None, errback=None):
         if callback is None:
@@ -256,21 +322,28 @@
         else:
             if errback is None:
                 errback = log.error
-            error_handler = lambda err:errback(dbus_to_bridge_exception(err))
-        return self.db_core_iface.contacts_get(profile_key, timeout=const_TIMEOUT, reply_handler=callback, error_handler=error_handler)
+            error_handler = lambda err: errback(dbus_to_bridge_exception(err))
+        return self.db_core_iface.contacts_get(
+            profile_key,
+            timeout=const_TIMEOUT,
+            reply_handler=callback,
+            error_handler=error_handler,
+        )
 
-    def contacts_get_from_group(self, group, profile_key="@DEFAULT@", callback=None, errback=None):
+    def contacts_get_from_group(
+        self, group, profile_key="@DEFAULT@", callback=None, errback=None
+    ):
         if callback is None:
             error_handler = None
         else:
             if errback is None:
                 errback = log.error
-            error_handler = lambda err:errback(dbus_to_bridge_exception(err))
-        kwargs={}
+            error_handler = lambda err: errback(dbus_to_bridge_exception(err))
+        kwargs = {}
         if callback is not None:
-            kwargs['timeout'] = const_TIMEOUT
-            kwargs['reply_handler'] = callback
-            kwargs['error_handler'] = error_handler
+            kwargs["timeout"] = const_TIMEOUT
+            kwargs["reply_handler"] = callback
+            kwargs["error_handler"] = error_handler
         return self.db_core_iface.contacts_get_from_group(group, profile_key, **kwargs)
 
     def devices_infos_get(self, bare_jid, profile_key, callback=None, errback=None):
@@ -279,35 +352,99 @@
         else:
             if errback is None:
                 errback = log.error
-            error_handler = lambda err:errback(dbus_to_bridge_exception(err))
-        return str(self.db_core_iface.devices_infos_get(bare_jid, profile_key, timeout=const_TIMEOUT, reply_handler=callback, error_handler=error_handler))
+            error_handler = lambda err: errback(dbus_to_bridge_exception(err))
+        return str(
+            self.db_core_iface.devices_infos_get(
+                bare_jid,
+                profile_key,
+                timeout=const_TIMEOUT,
+                reply_handler=callback,
+                error_handler=error_handler,
+            )
+        )
 
-    def disco_find_by_features(self, namespaces, identities, bare_jid=False, service=True, roster=True, own_jid=True, local_device=False, profile_key="@DEFAULT@", callback=None, errback=None):
+    def disco_find_by_features(
+        self,
+        namespaces,
+        identities,
+        bare_jid=False,
+        service=True,
+        roster=True,
+        own_jid=True,
+        local_device=False,
+        profile_key="@DEFAULT@",
+        callback=None,
+        errback=None,
+    ):
         if callback is None:
             error_handler = None
         else:
             if errback is None:
                 errback = log.error
-            error_handler = lambda err:errback(dbus_to_bridge_exception(err))
-        return self.db_core_iface.disco_find_by_features(namespaces, identities, bare_jid, service, roster, own_jid, local_device, profile_key, timeout=const_TIMEOUT, reply_handler=callback, error_handler=error_handler)
+            error_handler = lambda err: errback(dbus_to_bridge_exception(err))
+        return self.db_core_iface.disco_find_by_features(
+            namespaces,
+            identities,
+            bare_jid,
+            service,
+            roster,
+            own_jid,
+            local_device,
+            profile_key,
+            timeout=const_TIMEOUT,
+            reply_handler=callback,
+            error_handler=error_handler,
+        )
 
-    def disco_infos(self, entity_jid, node=u'', use_cache=True, profile_key="@DEFAULT@", callback=None, errback=None):
+    def disco_infos(
+        self,
+        entity_jid,
+        node="",
+        use_cache=True,
+        profile_key="@DEFAULT@",
+        callback=None,
+        errback=None,
+    ):
         if callback is None:
             error_handler = None
         else:
             if errback is None:
                 errback = log.error
-            error_handler = lambda err:errback(dbus_to_bridge_exception(err))
-        return self.db_core_iface.disco_infos(entity_jid, node, use_cache, profile_key, timeout=const_TIMEOUT, reply_handler=callback, error_handler=error_handler)
+            error_handler = lambda err: errback(dbus_to_bridge_exception(err))
+        return self.db_core_iface.disco_infos(
+            entity_jid,
+            node,
+            use_cache,
+            profile_key,
+            timeout=const_TIMEOUT,
+            reply_handler=callback,
+            error_handler=error_handler,
+        )
 
-    def disco_items(self, entity_jid, node=u'', use_cache=True, profile_key="@DEFAULT@", callback=None, errback=None):
+    def disco_items(
+        self,
+        entity_jid,
+        node="",
+        use_cache=True,
+        profile_key="@DEFAULT@",
+        callback=None,
+        errback=None,
+    ):
         if callback is None:
             error_handler = None
         else:
             if errback is None:
                 errback = log.error
-            error_handler = lambda err:errback(dbus_to_bridge_exception(err))
-        return self.db_core_iface.disco_items(entity_jid, node, use_cache, profile_key, timeout=const_TIMEOUT, reply_handler=callback, error_handler=error_handler)
+            error_handler = lambda err: errback(dbus_to_bridge_exception(err))
+        return self.db_core_iface.disco_items(
+            entity_jid,
+            node,
+            use_cache,
+            profile_key,
+            timeout=const_TIMEOUT,
+            reply_handler=callback,
+            error_handler=error_handler,
+        )
 
     def disconnect(self, profile_key="@DEFAULT@", callback=None, errback=None):
         if callback is None:
@@ -315,8 +452,13 @@
         else:
             if errback is None:
                 errback = log.error
-            error_handler = lambda err:errback(dbus_to_bridge_exception(err))
-        return self.db_core_iface.disconnect(profile_key, timeout=const_TIMEOUT, reply_handler=callback, error_handler=error_handler)
+            error_handler = lambda err: errback(dbus_to_bridge_exception(err))
+        return self.db_core_iface.disconnect(
+            profile_key,
+            timeout=const_TIMEOUT,
+            reply_handler=callback,
+            error_handler=error_handler,
+        )
 
     def encryption_namespace_get(self, arg_0, callback=None, errback=None):
         if callback is None:
@@ -324,12 +466,12 @@
         else:
             if errback is None:
                 errback = log.error
-            error_handler = lambda err:errback(dbus_to_bridge_exception(err))
-        kwargs={}
+            error_handler = lambda err: errback(dbus_to_bridge_exception(err))
+        kwargs = {}
         if callback is not None:
-            kwargs['timeout'] = const_TIMEOUT
-            kwargs['reply_handler'] = callback
-            kwargs['error_handler'] = error_handler
+            kwargs["timeout"] = const_TIMEOUT
+            kwargs["reply_handler"] = callback
+            kwargs["error_handler"] = error_handler
         return str(self.db_core_iface.encryption_namespace_get(arg_0, **kwargs))
 
     def encryption_plugins_get(self, callback=None, errback=None):
@@ -338,22 +480,33 @@
         else:
             if errback is None:
                 errback = log.error
-            error_handler = lambda err:errback(dbus_to_bridge_exception(err))
-        kwargs={}
+            error_handler = lambda err: errback(dbus_to_bridge_exception(err))
+        kwargs = {}
         if callback is not None:
-            kwargs['timeout'] = const_TIMEOUT
-            kwargs['reply_handler'] = callback
-            kwargs['error_handler'] = error_handler
+            kwargs["timeout"] = const_TIMEOUT
+            kwargs["reply_handler"] = callback
+            kwargs["error_handler"] = error_handler
         return str(self.db_core_iface.encryption_plugins_get(**kwargs))
 
-    def encryption_trust_ui_get(self, to_jid, namespace, profile_key, callback=None, errback=None):
+    def encryption_trust_ui_get(
+        self, to_jid, namespace, profile_key, callback=None, errback=None
+    ):
         if callback is None:
             error_handler = None
         else:
             if errback is None:
                 errback = log.error
-            error_handler = lambda err:errback(dbus_to_bridge_exception(err))
-        return str(self.db_core_iface.encryption_trust_ui_get(to_jid, namespace, profile_key, timeout=const_TIMEOUT, reply_handler=callback, error_handler=error_handler))
+            error_handler = lambda err: errback(dbus_to_bridge_exception(err))
+        return str(
+            self.db_core_iface.encryption_trust_ui_get(
+                to_jid,
+                namespace,
+                profile_key,
+                timeout=const_TIMEOUT,
+                reply_handler=callback,
+                error_handler=error_handler,
+            )
+        )
 
     def entities_data_get(self, jids, keys, profile, callback=None, errback=None):
         if callback is None:
@@ -361,12 +514,12 @@
         else:
             if errback is None:
                 errback = log.error
-            error_handler = lambda err:errback(dbus_to_bridge_exception(err))
-        kwargs={}
+            error_handler = lambda err: errback(dbus_to_bridge_exception(err))
+        kwargs = {}
         if callback is not None:
-            kwargs['timeout'] = const_TIMEOUT
-            kwargs['reply_handler'] = callback
-            kwargs['error_handler'] = error_handler
+            kwargs["timeout"] = const_TIMEOUT
+            kwargs["reply_handler"] = callback
+            kwargs["error_handler"] = error_handler
         return self.db_core_iface.entities_data_get(jids, keys, profile, **kwargs)
 
     def entity_data_get(self, jid, keys, profile, callback=None, errback=None):
@@ -375,12 +528,12 @@
         else:
             if errback is None:
                 errback = log.error
-            error_handler = lambda err:errback(dbus_to_bridge_exception(err))
-        kwargs={}
+            error_handler = lambda err: errback(dbus_to_bridge_exception(err))
+        kwargs = {}
         if callback is not None:
-            kwargs['timeout'] = const_TIMEOUT
-            kwargs['reply_handler'] = callback
-            kwargs['error_handler'] = error_handler
+            kwargs["timeout"] = const_TIMEOUT
+            kwargs["reply_handler"] = callback
+            kwargs["error_handler"] = error_handler
         return self.db_core_iface.entity_data_get(jid, keys, profile, **kwargs)
 
     def features_get(self, profile_key, callback=None, errback=None):
@@ -389,17 +542,42 @@
         else:
             if errback is None:
                 errback = log.error
-            error_handler = lambda err:errback(dbus_to_bridge_exception(err))
-        return self.db_core_iface.features_get(profile_key, timeout=const_TIMEOUT, reply_handler=callback, error_handler=error_handler)
+            error_handler = lambda err: errback(dbus_to_bridge_exception(err))
+        return self.db_core_iface.features_get(
+            profile_key,
+            timeout=const_TIMEOUT,
+            reply_handler=callback,
+            error_handler=error_handler,
+        )
 
-    def history_get(self, from_jid, to_jid, limit, between=True, filters='', profile="@NONE@", callback=None, errback=None):
+    def history_get(
+        self,
+        from_jid,
+        to_jid,
+        limit,
+        between=True,
+        filters="",
+        profile="@NONE@",
+        callback=None,
+        errback=None,
+    ):
         if callback is None:
             error_handler = None
         else:
             if errback is None:
                 errback = log.error
-            error_handler = lambda err:errback(dbus_to_bridge_exception(err))
-        return self.db_core_iface.history_get(from_jid, to_jid, limit, between, filters, profile, timeout=const_TIMEOUT, reply_handler=callback, error_handler=error_handler)
+            error_handler = lambda err: errback(dbus_to_bridge_exception(err))
+        return self.db_core_iface.history_get(
+            from_jid,
+            to_jid,
+            limit,
+            between,
+            filters,
+            profile,
+            timeout=const_TIMEOUT,
+            reply_handler=callback,
+            error_handler=error_handler,
+        )
 
     def image_check(self, arg_0, callback=None, errback=None):
         if callback is None:
@@ -407,12 +585,12 @@
         else:
             if errback is None:
                 errback = log.error
-            error_handler = lambda err:errback(dbus_to_bridge_exception(err))
-        kwargs={}
+            error_handler = lambda err: errback(dbus_to_bridge_exception(err))
+        kwargs = {}
         if callback is not None:
-            kwargs['timeout'] = const_TIMEOUT
-            kwargs['reply_handler'] = callback
-            kwargs['error_handler'] = error_handler
+            kwargs["timeout"] = const_TIMEOUT
+            kwargs["reply_handler"] = callback
+            kwargs["error_handler"] = error_handler
         return str(self.db_core_iface.image_check(arg_0, **kwargs))
 
     def image_convert(self, source, dest, arg_2, extra, callback=None, errback=None):
@@ -421,17 +599,37 @@
         else:
             if errback is None:
                 errback = log.error
-            error_handler = lambda err:errback(dbus_to_bridge_exception(err))
-        return str(self.db_core_iface.image_convert(source, dest, arg_2, extra, timeout=const_TIMEOUT, reply_handler=callback, error_handler=error_handler))
+            error_handler = lambda err: errback(dbus_to_bridge_exception(err))
+        return str(
+            self.db_core_iface.image_convert(
+                source,
+                dest,
+                arg_2,
+                extra,
+                timeout=const_TIMEOUT,
+                reply_handler=callback,
+                error_handler=error_handler,
+            )
+        )
 
-    def image_generate_preview(self, image_path, profile_key, callback=None, errback=None):
+    def image_generate_preview(
+        self, image_path, profile_key, callback=None, errback=None
+    ):
         if callback is None:
             error_handler = None
         else:
             if errback is None:
                 errback = log.error
-            error_handler = lambda err:errback(dbus_to_bridge_exception(err))
-        return str(self.db_core_iface.image_generate_preview(image_path, profile_key, timeout=const_TIMEOUT, reply_handler=callback, error_handler=error_handler))
+            error_handler = lambda err: errback(dbus_to_bridge_exception(err))
+        return str(
+            self.db_core_iface.image_generate_preview(
+                image_path,
+                profile_key,
+                timeout=const_TIMEOUT,
+                reply_handler=callback,
+                error_handler=error_handler,
+            )
+        )
 
     def image_resize(self, image_path, width, height, callback=None, errback=None):
         if callback is None:
@@ -439,8 +637,17 @@
         else:
             if errback is None:
                 errback = log.error
-            error_handler = lambda err:errback(dbus_to_bridge_exception(err))
-        return str(self.db_core_iface.image_resize(image_path, width, height, timeout=const_TIMEOUT, reply_handler=callback, error_handler=error_handler))
+            error_handler = lambda err: errback(dbus_to_bridge_exception(err))
+        return str(
+            self.db_core_iface.image_resize(
+                image_path,
+                width,
+                height,
+                timeout=const_TIMEOUT,
+                reply_handler=callback,
+                error_handler=error_handler,
+            )
+        )
 
     def init_pre_script(self, callback=None, errback=None):
         if callback is None:
@@ -448,8 +655,10 @@
         else:
             if errback is None:
                 errback = log.error
-            error_handler = lambda err:errback(dbus_to_bridge_exception(err))
-        return self.db_core_iface.init_pre_script(timeout=const_TIMEOUT, reply_handler=callback, error_handler=error_handler)
+            error_handler = lambda err: errback(dbus_to_bridge_exception(err))
+        return self.db_core_iface.init_pre_script(
+            timeout=const_TIMEOUT, reply_handler=callback, error_handler=error_handler
+        )
 
     def is_connected(self, profile_key="@DEFAULT@", callback=None, errback=None):
         if callback is None:
@@ -457,27 +666,31 @@
         else:
             if errback is None:
                 errback = log.error
-            error_handler = lambda err:errback(dbus_to_bridge_exception(err))
-        kwargs={}
+            error_handler = lambda err: errback(dbus_to_bridge_exception(err))
+        kwargs = {}
         if callback is not None:
-            kwargs['timeout'] = const_TIMEOUT
-            kwargs['reply_handler'] = callback
-            kwargs['error_handler'] = error_handler
+            kwargs["timeout"] = const_TIMEOUT
+            kwargs["reply_handler"] = callback
+            kwargs["error_handler"] = error_handler
         return self.db_core_iface.is_connected(profile_key, **kwargs)
 
-    def main_resource_get(self, contact_jid, profile_key="@DEFAULT@", callback=None, errback=None):
+    def main_resource_get(
+        self, contact_jid, profile_key="@DEFAULT@", callback=None, errback=None
+    ):
         if callback is None:
             error_handler = None
         else:
             if errback is None:
                 errback = log.error
-            error_handler = lambda err:errback(dbus_to_bridge_exception(err))
-        kwargs={}
+            error_handler = lambda err: errback(dbus_to_bridge_exception(err))
+        kwargs = {}
         if callback is not None:
-            kwargs['timeout'] = const_TIMEOUT
-            kwargs['reply_handler'] = callback
-            kwargs['error_handler'] = error_handler
-        return str(self.db_core_iface.main_resource_get(contact_jid, profile_key, **kwargs))
+            kwargs["timeout"] = const_TIMEOUT
+            kwargs["reply_handler"] = callback
+            kwargs["error_handler"] = error_handler
+        return str(
+            self.db_core_iface.main_resource_get(contact_jid, profile_key, **kwargs)
+        )
 
     def menu_help_get(self, menu_id, language, callback=None, errback=None):
         if callback is None:
@@ -485,22 +698,40 @@
         else:
             if errback is None:
                 errback = log.error
-            error_handler = lambda err:errback(dbus_to_bridge_exception(err))
-        kwargs={}
+            error_handler = lambda err: errback(dbus_to_bridge_exception(err))
+        kwargs = {}
         if callback is not None:
-            kwargs['timeout'] = const_TIMEOUT
-            kwargs['reply_handler'] = callback
-            kwargs['error_handler'] = error_handler
+            kwargs["timeout"] = const_TIMEOUT
+            kwargs["reply_handler"] = callback
+            kwargs["error_handler"] = error_handler
         return str(self.db_core_iface.menu_help_get(menu_id, language, **kwargs))
 
-    def menu_launch(self, menu_type, path, data, security_limit, profile_key, callback=None, errback=None):
+    def menu_launch(
+        self,
+        menu_type,
+        path,
+        data,
+        security_limit,
+        profile_key,
+        callback=None,
+        errback=None,
+    ):
         if callback is None:
             error_handler = None
         else:
             if errback is None:
                 errback = log.error
-            error_handler = lambda err:errback(dbus_to_bridge_exception(err))
-        return self.db_core_iface.menu_launch(menu_type, path, data, security_limit, profile_key, timeout=const_TIMEOUT, reply_handler=callback, error_handler=error_handler)
+            error_handler = lambda err: errback(dbus_to_bridge_exception(err))
+        return self.db_core_iface.menu_launch(
+            menu_type,
+            path,
+            data,
+            security_limit,
+            profile_key,
+            timeout=const_TIMEOUT,
+            reply_handler=callback,
+            error_handler=error_handler,
+        )
 
     def menus_get(self, language, security_limit, callback=None, errback=None):
         if callback is None:
@@ -508,12 +739,12 @@
         else:
             if errback is None:
                 errback = log.error
-            error_handler = lambda err:errback(dbus_to_bridge_exception(err))
-        kwargs={}
+            error_handler = lambda err: errback(dbus_to_bridge_exception(err))
+        kwargs = {}
         if callback is not None:
-            kwargs['timeout'] = const_TIMEOUT
-            kwargs['reply_handler'] = callback
-            kwargs['error_handler'] = error_handler
+            kwargs["timeout"] = const_TIMEOUT
+            kwargs["reply_handler"] = callback
+            kwargs["error_handler"] = error_handler
         return self.db_core_iface.menus_get(language, security_limit, **kwargs)
 
     def message_encryption_get(self, to_jid, profile_key, callback=None, errback=None):
@@ -522,22 +753,40 @@
         else:
             if errback is None:
                 errback = log.error
-            error_handler = lambda err:errback(dbus_to_bridge_exception(err))
-        kwargs={}
+            error_handler = lambda err: errback(dbus_to_bridge_exception(err))
+        kwargs = {}
         if callback is not None:
-            kwargs['timeout'] = const_TIMEOUT
-            kwargs['reply_handler'] = callback
-            kwargs['error_handler'] = error_handler
-        return str(self.db_core_iface.message_encryption_get(to_jid, profile_key, **kwargs))
+            kwargs["timeout"] = const_TIMEOUT
+            kwargs["reply_handler"] = callback
+            kwargs["error_handler"] = error_handler
+        return str(
+            self.db_core_iface.message_encryption_get(to_jid, profile_key, **kwargs)
+        )
 
-    def message_encryption_start(self, to_jid, namespace='', replace=False, profile_key="@NONE@", callback=None, errback=None):
+    def message_encryption_start(
+        self,
+        to_jid,
+        namespace="",
+        replace=False,
+        profile_key="@NONE@",
+        callback=None,
+        errback=None,
+    ):
         if callback is None:
             error_handler = None
         else:
             if errback is None:
                 errback = log.error
-            error_handler = lambda err:errback(dbus_to_bridge_exception(err))
-        return self.db_core_iface.message_encryption_start(to_jid, namespace, replace, profile_key, timeout=const_TIMEOUT, reply_handler=callback, error_handler=error_handler)
+            error_handler = lambda err: errback(dbus_to_bridge_exception(err))
+        return self.db_core_iface.message_encryption_start(
+            to_jid,
+            namespace,
+            replace,
+            profile_key,
+            timeout=const_TIMEOUT,
+            reply_handler=callback,
+            error_handler=error_handler,
+        )
 
     def message_encryption_stop(self, to_jid, profile_key, callback=None, errback=None):
         if callback is None:
@@ -545,17 +794,43 @@
         else:
             if errback is None:
                 errback = log.error
-            error_handler = lambda err:errback(dbus_to_bridge_exception(err))
-        return self.db_core_iface.message_encryption_stop(to_jid, profile_key, timeout=const_TIMEOUT, reply_handler=callback, error_handler=error_handler)
+            error_handler = lambda err: errback(dbus_to_bridge_exception(err))
+        return self.db_core_iface.message_encryption_stop(
+            to_jid,
+            profile_key,
+            timeout=const_TIMEOUT,
+            reply_handler=callback,
+            error_handler=error_handler,
+        )
 
-    def message_send(self, to_jid, message, subject={}, mess_type="auto", extra={}, profile_key="@NONE@", callback=None, errback=None):
+    def message_send(
+        self,
+        to_jid,
+        message,
+        subject={},
+        mess_type="auto",
+        extra={},
+        profile_key="@NONE@",
+        callback=None,
+        errback=None,
+    ):
         if callback is None:
             error_handler = None
         else:
             if errback is None:
                 errback = log.error
-            error_handler = lambda err:errback(dbus_to_bridge_exception(err))
-        return self.db_core_iface.message_send(to_jid, message, subject, mess_type, extra, profile_key, timeout=const_TIMEOUT, reply_handler=callback, error_handler=error_handler)
+            error_handler = lambda err: errback(dbus_to_bridge_exception(err))
+        return self.db_core_iface.message_send(
+            to_jid,
+            message,
+            subject,
+            mess_type,
+            extra,
+            profile_key,
+            timeout=const_TIMEOUT,
+            reply_handler=callback,
+            error_handler=error_handler,
+        )
 
     def namespaces_get(self, callback=None, errback=None):
         if callback is None:
@@ -563,55 +838,89 @@
         else:
             if errback is None:
                 errback = log.error
-            error_handler = lambda err:errback(dbus_to_bridge_exception(err))
-        kwargs={}
+            error_handler = lambda err: errback(dbus_to_bridge_exception(err))
+        kwargs = {}
         if callback is not None:
-            kwargs['timeout'] = const_TIMEOUT
-            kwargs['reply_handler'] = callback
-            kwargs['error_handler'] = error_handler
+            kwargs["timeout"] = const_TIMEOUT
+            kwargs["reply_handler"] = callback
+            kwargs["error_handler"] = error_handler
         return self.db_core_iface.namespaces_get(**kwargs)
 
-    def notification_add(self, type_, body_plain, body_rich, title, is_global, requires_action, arg_6, priority, expire_at, extra, callback=None, errback=None):
+    def notification_add(
+        self,
+        type_,
+        body_plain,
+        body_rich,
+        title,
+        is_global,
+        requires_action,
+        arg_6,
+        priority,
+        expire_at,
+        extra,
+        callback=None,
+        errback=None,
+    ):
         if callback is None:
             error_handler = None
         else:
             if errback is None:
                 errback = log.error
-            error_handler = lambda err:errback(dbus_to_bridge_exception(err))
-        kwargs={}
+            error_handler = lambda err: errback(dbus_to_bridge_exception(err))
+        kwargs = {}
         if callback is not None:
-            kwargs['timeout'] = const_TIMEOUT
-            kwargs['reply_handler'] = callback
-            kwargs['error_handler'] = error_handler
-        return self.db_core_iface.notification_add(type_, body_plain, body_rich, title, is_global, requires_action, arg_6, priority, expire_at, extra, **kwargs)
+            kwargs["timeout"] = const_TIMEOUT
+            kwargs["reply_handler"] = callback
+            kwargs["error_handler"] = error_handler
+        return self.db_core_iface.notification_add(
+            type_,
+            body_plain,
+            body_rich,
+            title,
+            is_global,
+            requires_action,
+            arg_6,
+            priority,
+            expire_at,
+            extra,
+            **kwargs,
+        )
 
-    def notification_delete(self, id_, is_global, profile_key, callback=None, errback=None):
+    def notification_delete(
+        self, id_, is_global, profile_key, callback=None, errback=None
+    ):
         if callback is None:
             error_handler = None
         else:
             if errback is None:
                 errback = log.error
-            error_handler = lambda err:errback(dbus_to_bridge_exception(err))
-        kwargs={}
+            error_handler = lambda err: errback(dbus_to_bridge_exception(err))
+        kwargs = {}
         if callback is not None:
-            kwargs['timeout'] = const_TIMEOUT
-            kwargs['reply_handler'] = callback
-            kwargs['error_handler'] = error_handler
-        return self.db_core_iface.notification_delete(id_, is_global, profile_key, **kwargs)
+            kwargs["timeout"] = const_TIMEOUT
+            kwargs["reply_handler"] = callback
+            kwargs["error_handler"] = error_handler
+        return self.db_core_iface.notification_delete(
+            id_, is_global, profile_key, **kwargs
+        )
 
-    def notifications_expired_clean(self, limit_timestamp, profile_key, callback=None, errback=None):
+    def notifications_expired_clean(
+        self, limit_timestamp, profile_key, callback=None, errback=None
+    ):
         if callback is None:
             error_handler = None
         else:
             if errback is None:
                 errback = log.error
-            error_handler = lambda err:errback(dbus_to_bridge_exception(err))
-        kwargs={}
+            error_handler = lambda err: errback(dbus_to_bridge_exception(err))
+        kwargs = {}
         if callback is not None:
-            kwargs['timeout'] = const_TIMEOUT
-            kwargs['reply_handler'] = callback
-            kwargs['error_handler'] = error_handler
-        return self.db_core_iface.notifications_expired_clean(limit_timestamp, profile_key, **kwargs)
+            kwargs["timeout"] = const_TIMEOUT
+            kwargs["reply_handler"] = callback
+            kwargs["error_handler"] = error_handler
+        return self.db_core_iface.notifications_expired_clean(
+            limit_timestamp, profile_key, **kwargs
+        )
 
     def notifications_get(self, filters, profile_key, callback=None, errback=None):
         if callback is None:
@@ -619,59 +928,120 @@
         else:
             if errback is None:
                 errback = log.error
-            error_handler = lambda err:errback(dbus_to_bridge_exception(err))
-        kwargs={}
+            error_handler = lambda err: errback(dbus_to_bridge_exception(err))
+        kwargs = {}
         if callback is not None:
-            kwargs['timeout'] = const_TIMEOUT
-            kwargs['reply_handler'] = callback
-            kwargs['error_handler'] = error_handler
+            kwargs["timeout"] = const_TIMEOUT
+            kwargs["reply_handler"] = callback
+            kwargs["error_handler"] = error_handler
         return str(self.db_core_iface.notifications_get(filters, profile_key, **kwargs))
 
-    def param_get_a(self, name, category, attribute="value", profile_key="@DEFAULT@", callback=None, errback=None):
+    def param_get_a(
+        self,
+        name,
+        category,
+        attribute="value",
+        profile_key="@DEFAULT@",
+        callback=None,
+        errback=None,
+    ):
+        if callback is None:
+            error_handler = None
+        else:
+            if errback is None:
+                errback = log.error
+            error_handler = lambda err: errback(dbus_to_bridge_exception(err))
+        kwargs = {}
+        if callback is not None:
+            kwargs["timeout"] = const_TIMEOUT
+            kwargs["reply_handler"] = callback
+            kwargs["error_handler"] = error_handler
+        return str(
+            self.db_core_iface.param_get_a(
+                name, category, attribute, profile_key, **kwargs
+            )
+        )
+
+    def param_get_a_async(
+        self,
+        name,
+        category,
+        attribute="value",
+        security_limit=-1,
+        profile_key="@DEFAULT@",
+        callback=None,
+        errback=None,
+    ):
         if callback is None:
             error_handler = None
         else:
             if errback is None:
                 errback = log.error
-            error_handler = lambda err:errback(dbus_to_bridge_exception(err))
-        kwargs={}
-        if callback is not None:
-            kwargs['timeout'] = const_TIMEOUT
-            kwargs['reply_handler'] = callback
-            kwargs['error_handler'] = error_handler
-        return str(self.db_core_iface.param_get_a(name, category, attribute, profile_key, **kwargs))
+            error_handler = lambda err: errback(dbus_to_bridge_exception(err))
+        return str(
+            self.db_core_iface.param_get_a_async(
+                name,
+                category,
+                attribute,
+                security_limit,
+                profile_key,
+                timeout=const_TIMEOUT,
+                reply_handler=callback,
+                error_handler=error_handler,
+            )
+        )
 
-    def param_get_a_async(self, name, category, attribute="value", security_limit=-1, profile_key="@DEFAULT@", callback=None, errback=None):
+    def param_set(
+        self,
+        name,
+        value,
+        category,
+        security_limit=-1,
+        profile_key="@DEFAULT@",
+        callback=None,
+        errback=None,
+    ):
         if callback is None:
             error_handler = None
         else:
             if errback is None:
                 errback = log.error
-            error_handler = lambda err:errback(dbus_to_bridge_exception(err))
-        return str(self.db_core_iface.param_get_a_async(name, category, attribute, security_limit, profile_key, timeout=const_TIMEOUT, reply_handler=callback, error_handler=error_handler))
+            error_handler = lambda err: errback(dbus_to_bridge_exception(err))
+        kwargs = {}
+        if callback is not None:
+            kwargs["timeout"] = const_TIMEOUT
+            kwargs["reply_handler"] = callback
+            kwargs["error_handler"] = error_handler
+        return self.db_core_iface.param_set(
+            name, value, category, security_limit, profile_key, **kwargs
+        )
 
-    def param_set(self, name, value, category, security_limit=-1, profile_key="@DEFAULT@", callback=None, errback=None):
+    def param_ui_get(
+        self,
+        security_limit=-1,
+        app="",
+        extra="",
+        profile_key="@DEFAULT@",
+        callback=None,
+        errback=None,
+    ):
         if callback is None:
             error_handler = None
         else:
             if errback is None:
                 errback = log.error
-            error_handler = lambda err:errback(dbus_to_bridge_exception(err))
-        kwargs={}
-        if callback is not None:
-            kwargs['timeout'] = const_TIMEOUT
-            kwargs['reply_handler'] = callback
-            kwargs['error_handler'] = error_handler
-        return self.db_core_iface.param_set(name, value, category, security_limit, profile_key, **kwargs)
-
-    def param_ui_get(self, security_limit=-1, app='', extra='', profile_key="@DEFAULT@", callback=None, errback=None):
-        if callback is None:
-            error_handler = None
-        else:
-            if errback is None:
-                errback = log.error
-            error_handler = lambda err:errback(dbus_to_bridge_exception(err))
-        return str(self.db_core_iface.param_ui_get(security_limit, app, extra, profile_key, timeout=const_TIMEOUT, reply_handler=callback, error_handler=error_handler))
+            error_handler = lambda err: errback(dbus_to_bridge_exception(err))
+        return str(
+            self.db_core_iface.param_ui_get(
+                security_limit,
+                app,
+                extra,
+                profile_key,
+                timeout=const_TIMEOUT,
+                reply_handler=callback,
+                error_handler=error_handler,
+            )
+        )
 
     def params_categories_get(self, callback=None, errback=None):
         if callback is None:
@@ -679,26 +1049,28 @@
         else:
             if errback is None:
                 errback = log.error
-            error_handler = lambda err:errback(dbus_to_bridge_exception(err))
-        kwargs={}
+            error_handler = lambda err: errback(dbus_to_bridge_exception(err))
+        kwargs = {}
         if callback is not None:
-            kwargs['timeout'] = const_TIMEOUT
-            kwargs['reply_handler'] = callback
-            kwargs['error_handler'] = error_handler
+            kwargs["timeout"] = const_TIMEOUT
+            kwargs["reply_handler"] = callback
+            kwargs["error_handler"] = error_handler
         return self.db_core_iface.params_categories_get(**kwargs)
 
-    def params_register_app(self, xml, security_limit=-1, app='', callback=None, errback=None):
+    def params_register_app(
+        self, xml, security_limit=-1, app="", callback=None, errback=None
+    ):
         if callback is None:
             error_handler = None
         else:
             if errback is None:
                 errback = log.error
-            error_handler = lambda err:errback(dbus_to_bridge_exception(err))
-        kwargs={}
+            error_handler = lambda err: errback(dbus_to_bridge_exception(err))
+        kwargs = {}
         if callback is not None:
-            kwargs['timeout'] = const_TIMEOUT
-            kwargs['reply_handler'] = callback
-            kwargs['error_handler'] = error_handler
+            kwargs["timeout"] = const_TIMEOUT
+            kwargs["reply_handler"] = callback
+            kwargs["error_handler"] = error_handler
         return self.db_core_iface.params_register_app(xml, security_limit, app, **kwargs)
 
     def params_template_load(self, filename, callback=None, errback=None):
@@ -707,12 +1079,12 @@
         else:
             if errback is None:
                 errback = log.error
-            error_handler = lambda err:errback(dbus_to_bridge_exception(err))
-        kwargs={}
+            error_handler = lambda err: errback(dbus_to_bridge_exception(err))
+        kwargs = {}
         if callback is not None:
-            kwargs['timeout'] = const_TIMEOUT
-            kwargs['reply_handler'] = callback
-            kwargs['error_handler'] = error_handler
+            kwargs["timeout"] = const_TIMEOUT
+            kwargs["reply_handler"] = callback
+            kwargs["error_handler"] = error_handler
         return self.db_core_iface.params_template_load(filename, **kwargs)
 
     def params_template_save(self, filename, callback=None, errback=None):
@@ -721,36 +1093,64 @@
         else:
             if errback is None:
                 errback = log.error
-            error_handler = lambda err:errback(dbus_to_bridge_exception(err))
-        kwargs={}
+            error_handler = lambda err: errback(dbus_to_bridge_exception(err))
+        kwargs = {}
         if callback is not None:
-            kwargs['timeout'] = const_TIMEOUT
-            kwargs['reply_handler'] = callback
-            kwargs['error_handler'] = error_handler
+            kwargs["timeout"] = const_TIMEOUT
+            kwargs["reply_handler"] = callback
+            kwargs["error_handler"] = error_handler
         return self.db_core_iface.params_template_save(filename, **kwargs)
 
-    def params_values_from_category_get_async(self, category, security_limit=-1, app="", extra="", profile_key="@DEFAULT@", callback=None, errback=None):
+    def params_values_from_category_get_async(
+        self,
+        category,
+        security_limit=-1,
+        app="",
+        extra="",
+        profile_key="@DEFAULT@",
+        callback=None,
+        errback=None,
+    ):
         if callback is None:
             error_handler = None
         else:
             if errback is None:
                 errback = log.error
-            error_handler = lambda err:errback(dbus_to_bridge_exception(err))
-        return self.db_core_iface.params_values_from_category_get_async(category, security_limit, app, extra, profile_key, timeout=const_TIMEOUT, reply_handler=callback, error_handler=error_handler)
+            error_handler = lambda err: errback(dbus_to_bridge_exception(err))
+        return self.db_core_iface.params_values_from_category_get_async(
+            category,
+            security_limit,
+            app,
+            extra,
+            profile_key,
+            timeout=const_TIMEOUT,
+            reply_handler=callback,
+            error_handler=error_handler,
+        )
 
-    def presence_set(self, to_jid='', show='', statuses={}, profile_key="@DEFAULT@", callback=None, errback=None):
+    def presence_set(
+        self,
+        to_jid="",
+        show="",
+        statuses={},
+        profile_key="@DEFAULT@",
+        callback=None,
+        errback=None,
+    ):
         if callback is None:
             error_handler = None
         else:
             if errback is None:
                 errback = log.error
-            error_handler = lambda err:errback(dbus_to_bridge_exception(err))
-        kwargs={}
+            error_handler = lambda err: errback(dbus_to_bridge_exception(err))
+        kwargs = {}
         if callback is not None:
-            kwargs['timeout'] = const_TIMEOUT
-            kwargs['reply_handler'] = callback
-            kwargs['error_handler'] = error_handler
-        return self.db_core_iface.presence_set(to_jid, show, statuses, profile_key, **kwargs)
+            kwargs["timeout"] = const_TIMEOUT
+            kwargs["reply_handler"] = callback
+            kwargs["error_handler"] = error_handler
+        return self.db_core_iface.presence_set(
+            to_jid, show, statuses, profile_key, **kwargs
+        )
 
     def presence_statuses_get(self, profile_key="@DEFAULT@", callback=None, errback=None):
         if callback is None:
@@ -758,12 +1158,12 @@
         else:
             if errback is None:
                 errback = log.error
-            error_handler = lambda err:errback(dbus_to_bridge_exception(err))
-        kwargs={}
+            error_handler = lambda err: errback(dbus_to_bridge_exception(err))
+        kwargs = {}
         if callback is not None:
-            kwargs['timeout'] = const_TIMEOUT
-            kwargs['reply_handler'] = callback
-            kwargs['error_handler'] = error_handler
+            kwargs["timeout"] = const_TIMEOUT
+            kwargs["reply_handler"] = callback
+            kwargs["error_handler"] = error_handler
         return self.db_core_iface.presence_statuses_get(profile_key, **kwargs)
 
     def private_data_delete(self, namespace, key, arg_2, callback=None, errback=None):
@@ -772,8 +1172,15 @@
         else:
             if errback is None:
                 errback = log.error
-            error_handler = lambda err:errback(dbus_to_bridge_exception(err))
-        return self.db_core_iface.private_data_delete(namespace, key, arg_2, timeout=const_TIMEOUT, reply_handler=callback, error_handler=error_handler)
+            error_handler = lambda err: errback(dbus_to_bridge_exception(err))
+        return self.db_core_iface.private_data_delete(
+            namespace,
+            key,
+            arg_2,
+            timeout=const_TIMEOUT,
+            reply_handler=callback,
+            error_handler=error_handler,
+        )
 
     def private_data_get(self, namespace, key, profile_key, callback=None, errback=None):
         if callback is None:
@@ -781,26 +1188,54 @@
         else:
             if errback is None:
                 errback = log.error
-            error_handler = lambda err:errback(dbus_to_bridge_exception(err))
-        return str(self.db_core_iface.private_data_get(namespace, key, profile_key, timeout=const_TIMEOUT, reply_handler=callback, error_handler=error_handler))
+            error_handler = lambda err: errback(dbus_to_bridge_exception(err))
+        return str(
+            self.db_core_iface.private_data_get(
+                namespace,
+                key,
+                profile_key,
+                timeout=const_TIMEOUT,
+                reply_handler=callback,
+                error_handler=error_handler,
+            )
+        )
 
-    def private_data_set(self, namespace, key, data, profile_key, callback=None, errback=None):
+    def private_data_set(
+        self, namespace, key, data, profile_key, callback=None, errback=None
+    ):
         if callback is None:
             error_handler = None
         else:
             if errback is None:
                 errback = log.error
-            error_handler = lambda err:errback(dbus_to_bridge_exception(err))
-        return self.db_core_iface.private_data_set(namespace, key, data, profile_key, timeout=const_TIMEOUT, reply_handler=callback, error_handler=error_handler)
+            error_handler = lambda err: errback(dbus_to_bridge_exception(err))
+        return self.db_core_iface.private_data_set(
+            namespace,
+            key,
+            data,
+            profile_key,
+            timeout=const_TIMEOUT,
+            reply_handler=callback,
+            error_handler=error_handler,
+        )
 
-    def profile_create(self, profile, password='', component='', callback=None, errback=None):
+    def profile_create(
+        self, profile, password="", component="", callback=None, errback=None
+    ):
         if callback is None:
             error_handler = None
         else:
             if errback is None:
                 errback = log.error
-            error_handler = lambda err:errback(dbus_to_bridge_exception(err))
-        return self.db_core_iface.profile_create(profile, password, component, timeout=const_TIMEOUT, reply_handler=callback, error_handler=error_handler)
+            error_handler = lambda err: errback(dbus_to_bridge_exception(err))
+        return self.db_core_iface.profile_create(
+            profile,
+            password,
+            component,
+            timeout=const_TIMEOUT,
+            reply_handler=callback,
+            error_handler=error_handler,
+        )
 
     def profile_delete_async(self, profile, callback=None, errback=None):
         if callback is None:
@@ -808,21 +1243,28 @@
         else:
             if errback is None:
                 errback = log.error
-            error_handler = lambda err:errback(dbus_to_bridge_exception(err))
-        return self.db_core_iface.profile_delete_async(profile, timeout=const_TIMEOUT, reply_handler=callback, error_handler=error_handler)
+            error_handler = lambda err: errback(dbus_to_bridge_exception(err))
+        return self.db_core_iface.profile_delete_async(
+            profile,
+            timeout=const_TIMEOUT,
+            reply_handler=callback,
+            error_handler=error_handler,
+        )
 
-    def profile_is_session_started(self, profile_key="@DEFAULT@", callback=None, errback=None):
+    def profile_is_session_started(
+        self, profile_key="@DEFAULT@", callback=None, errback=None
+    ):
         if callback is None:
             error_handler = None
         else:
             if errback is None:
                 errback = log.error
-            error_handler = lambda err:errback(dbus_to_bridge_exception(err))
-        kwargs={}
+            error_handler = lambda err: errback(dbus_to_bridge_exception(err))
+        kwargs = {}
         if callback is not None:
-            kwargs['timeout'] = const_TIMEOUT
-            kwargs['reply_handler'] = callback
-            kwargs['error_handler'] = error_handler
+            kwargs["timeout"] = const_TIMEOUT
+            kwargs["reply_handler"] = callback
+            kwargs["error_handler"] = error_handler
         return self.db_core_iface.profile_is_session_started(profile_key, **kwargs)
 
     def profile_name_get(self, profile_key="@DEFAULT@", callback=None, errback=None):
@@ -831,12 +1273,12 @@
         else:
             if errback is None:
                 errback = log.error
-            error_handler = lambda err:errback(dbus_to_bridge_exception(err))
-        kwargs={}
+            error_handler = lambda err: errback(dbus_to_bridge_exception(err))
+        kwargs = {}
         if callback is not None:
-            kwargs['timeout'] = const_TIMEOUT
-            kwargs['reply_handler'] = callback
-            kwargs['error_handler'] = error_handler
+            kwargs["timeout"] = const_TIMEOUT
+            kwargs["reply_handler"] = callback
+            kwargs["error_handler"] = error_handler
         return str(self.db_core_iface.profile_name_get(profile_key, **kwargs))
 
     def profile_set_default(self, profile, callback=None, errback=None):
@@ -845,35 +1287,45 @@
         else:
             if errback is None:
                 errback = log.error
-            error_handler = lambda err:errback(dbus_to_bridge_exception(err))
-        kwargs={}
+            error_handler = lambda err: errback(dbus_to_bridge_exception(err))
+        kwargs = {}
         if callback is not None:
-            kwargs['timeout'] = const_TIMEOUT
-            kwargs['reply_handler'] = callback
-            kwargs['error_handler'] = error_handler
+            kwargs["timeout"] = const_TIMEOUT
+            kwargs["reply_handler"] = callback
+            kwargs["error_handler"] = error_handler
         return self.db_core_iface.profile_set_default(profile, **kwargs)
 
-    def profile_start_session(self, password='', profile_key="@DEFAULT@", callback=None, errback=None):
+    def profile_start_session(
+        self, password="", profile_key="@DEFAULT@", callback=None, errback=None
+    ):
         if callback is None:
             error_handler = None
         else:
             if errback is None:
                 errback = log.error
-            error_handler = lambda err:errback(dbus_to_bridge_exception(err))
-        return self.db_core_iface.profile_start_session(password, profile_key, timeout=const_TIMEOUT, reply_handler=callback, error_handler=error_handler)
+            error_handler = lambda err: errback(dbus_to_bridge_exception(err))
+        return self.db_core_iface.profile_start_session(
+            password,
+            profile_key,
+            timeout=const_TIMEOUT,
+            reply_handler=callback,
+            error_handler=error_handler,
+        )
 
-    def profiles_list_get(self, clients=True, components=False, callback=None, errback=None):
+    def profiles_list_get(
+        self, clients=True, components=False, callback=None, errback=None
+    ):
         if callback is None:
             error_handler = None
         else:
             if errback is None:
                 errback = log.error
-            error_handler = lambda err:errback(dbus_to_bridge_exception(err))
-        kwargs={}
+            error_handler = lambda err: errback(dbus_to_bridge_exception(err))
+        kwargs = {}
         if callback is not None:
-            kwargs['timeout'] = const_TIMEOUT
-            kwargs['reply_handler'] = callback
-            kwargs['error_handler'] = error_handler
+            kwargs["timeout"] = const_TIMEOUT
+            kwargs["reply_handler"] = callback
+            kwargs["error_handler"] = error_handler
         return self.db_core_iface.profiles_list_get(clients, components, **kwargs)
 
     def progress_get(self, id, profile, callback=None, errback=None):
@@ -882,12 +1334,12 @@
         else:
             if errback is None:
                 errback = log.error
-            error_handler = lambda err:errback(dbus_to_bridge_exception(err))
-        kwargs={}
+            error_handler = lambda err: errback(dbus_to_bridge_exception(err))
+        kwargs = {}
         if callback is not None:
-            kwargs['timeout'] = const_TIMEOUT
-            kwargs['reply_handler'] = callback
-            kwargs['error_handler'] = error_handler
+            kwargs["timeout"] = const_TIMEOUT
+            kwargs["reply_handler"] = callback
+            kwargs["error_handler"] = error_handler
         return self.db_core_iface.progress_get(id, profile, **kwargs)
 
     def progress_get_all(self, profile, callback=None, errback=None):
@@ -896,12 +1348,12 @@
         else:
             if errback is None:
                 errback = log.error
-            error_handler = lambda err:errback(dbus_to_bridge_exception(err))
-        kwargs={}
+            error_handler = lambda err: errback(dbus_to_bridge_exception(err))
+        kwargs = {}
         if callback is not None:
-            kwargs['timeout'] = const_TIMEOUT
-            kwargs['reply_handler'] = callback
-            kwargs['error_handler'] = error_handler
+            kwargs["timeout"] = const_TIMEOUT
+            kwargs["reply_handler"] = callback
+            kwargs["error_handler"] = error_handler
         return self.db_core_iface.progress_get_all(profile, **kwargs)
 
     def progress_get_all_metadata(self, profile, callback=None, errback=None):
@@ -910,12 +1362,12 @@
         else:
             if errback is None:
                 errback = log.error
-            error_handler = lambda err:errback(dbus_to_bridge_exception(err))
-        kwargs={}
+            error_handler = lambda err: errback(dbus_to_bridge_exception(err))
+        kwargs = {}
         if callback is not None:
-            kwargs['timeout'] = const_TIMEOUT
-            kwargs['reply_handler'] = callback
-            kwargs['error_handler'] = error_handler
+            kwargs["timeout"] = const_TIMEOUT
+            kwargs["reply_handler"] = callback
+            kwargs["error_handler"] = error_handler
         return self.db_core_iface.progress_get_all_metadata(profile, **kwargs)
 
     def ready_get(self, callback=None, errback=None):
@@ -924,8 +1376,10 @@
         else:
             if errback is None:
                 errback = log.error
-            error_handler = lambda err:errback(dbus_to_bridge_exception(err))
-        return self.db_core_iface.ready_get(timeout=const_TIMEOUT, reply_handler=callback, error_handler=error_handler)
+            error_handler = lambda err: errback(dbus_to_bridge_exception(err))
+        return self.db_core_iface.ready_get(
+            timeout=const_TIMEOUT, reply_handler=callback, error_handler=error_handler
+        )
 
     def roster_resync(self, profile_key="@DEFAULT@", callback=None, errback=None):
         if callback is None:
@@ -933,8 +1387,13 @@
         else:
             if errback is None:
                 errback = log.error
-            error_handler = lambda err:errback(dbus_to_bridge_exception(err))
-        return self.db_core_iface.roster_resync(profile_key, timeout=const_TIMEOUT, reply_handler=callback, error_handler=error_handler)
+            error_handler = lambda err: errback(dbus_to_bridge_exception(err))
+        return self.db_core_iface.roster_resync(
+            profile_key,
+            timeout=const_TIMEOUT,
+            reply_handler=callback,
+            error_handler=error_handler,
+        )
 
     def session_infos_get(self, profile_key, callback=None, errback=None):
         if callback is None:
@@ -942,8 +1401,13 @@
         else:
             if errback is None:
                 errback = log.error
-            error_handler = lambda err:errback(dbus_to_bridge_exception(err))
-        return self.db_core_iface.session_infos_get(profile_key, timeout=const_TIMEOUT, reply_handler=callback, error_handler=error_handler)
+            error_handler = lambda err: errback(dbus_to_bridge_exception(err))
+        return self.db_core_iface.session_infos_get(
+            profile_key,
+            timeout=const_TIMEOUT,
+            reply_handler=callback,
+            error_handler=error_handler,
+        )
 
     def sub_waiting_get(self, profile_key="@DEFAULT@", callback=None, errback=None):
         if callback is None:
@@ -951,26 +1415,28 @@
         else:
             if errback is None:
                 errback = log.error
-            error_handler = lambda err:errback(dbus_to_bridge_exception(err))
-        kwargs={}
+            error_handler = lambda err: errback(dbus_to_bridge_exception(err))
+        kwargs = {}
         if callback is not None:
-            kwargs['timeout'] = const_TIMEOUT
-            kwargs['reply_handler'] = callback
-            kwargs['error_handler'] = error_handler
+            kwargs["timeout"] = const_TIMEOUT
+            kwargs["reply_handler"] = callback
+            kwargs["error_handler"] = error_handler
         return self.db_core_iface.sub_waiting_get(profile_key, **kwargs)
 
-    def subscription(self, sub_type, entity, profile_key="@DEFAULT@", callback=None, errback=None):
+    def subscription(
+        self, sub_type, entity, profile_key="@DEFAULT@", callback=None, errback=None
+    ):
         if callback is None:
             error_handler = None
         else:
             if errback is None:
                 errback = log.error
-            error_handler = lambda err:errback(dbus_to_bridge_exception(err))
-        kwargs={}
+            error_handler = lambda err: errback(dbus_to_bridge_exception(err))
+        kwargs = {}
         if callback is not None:
-            kwargs['timeout'] = const_TIMEOUT
-            kwargs['reply_handler'] = callback
-            kwargs['error_handler'] = error_handler
+            kwargs["timeout"] = const_TIMEOUT
+            kwargs["reply_handler"] = callback
+            kwargs["error_handler"] = error_handler
         return self.db_core_iface.subscription(sub_type, entity, profile_key, **kwargs)
 
     def version_get(self, callback=None, errback=None):
@@ -979,12 +1445,12 @@
         else:
             if errback is None:
                 errback = log.error
-            error_handler = lambda err:errback(dbus_to_bridge_exception(err))
-        kwargs={}
+            error_handler = lambda err: errback(dbus_to_bridge_exception(err))
+        kwargs = {}
         if callback is not None:
-            kwargs['timeout'] = const_TIMEOUT
-            kwargs['reply_handler'] = callback
-            kwargs['error_handler'] = error_handler
+            kwargs["timeout"] = const_TIMEOUT
+            kwargs["reply_handler"] = callback
+            kwargs["error_handler"] = error_handler
         return str(self.db_core_iface.version_get(**kwargs))
 
 
@@ -992,11 +1458,13 @@
 
     def register_signal(self, functionName, handler, iface="core"):
         loop = asyncio.get_running_loop()
-        async_handler = lambda *args: asyncio.run_coroutine_threadsafe(handler(*args), loop)
+        async_handler = lambda *args: asyncio.run_coroutine_threadsafe(
+            handler(*args), loop
+        )
         return super().register_signal(functionName, async_handler, iface)
 
     def __getattribute__(self, name):
-        """ usual __getattribute__ if the method exists, else try to find a plugin method """
+        """usual __getattribute__ if the method exists, else try to find a plugin method"""
         try:
             return object.__getattribute__(self, name)
         except AttributeError:
@@ -1006,16 +1474,18 @@
                 fut = loop.create_future()
                 method = getattr(self.db_plugin_iface, name)
                 reply_handler = lambda ret=None: loop.call_soon_threadsafe(
-                    fut.set_result, ret)
+                    fut.set_result, ret
+                )
                 error_handler = lambda err: loop.call_soon_threadsafe(
-                    fut.set_exception, dbus_to_bridge_exception(err))
+                    fut.set_exception, dbus_to_bridge_exception(err)
+                )
                 try:
                     method(
                         *args,
                         **kwargs,
                         timeout=const_TIMEOUT,
                         reply_handler=reply_handler,
-                        error_handler=error_handler
+                        error_handler=error_handler,
                     )
                 except ValueError as e:
                     if e.args[0].startswith("Unable to guess signature"):
@@ -1030,7 +1500,7 @@
                             **kwargs,
                             timeout=const_TIMEOUT,
                             reply_handler=reply_handler,
-                            error_handler=error_handler
+                            error_handler=error_handler,
                         )
 
                     else:
@@ -1044,7 +1514,7 @@
         fut = loop.create_future()
         super().bridge_connect(
             callback=lambda: loop.call_soon_threadsafe(fut.set_result, None),
-            errback=lambda e: loop.call_soon_threadsafe(fut.set_exception, e)
+            errback=lambda e: loop.call_soon_threadsafe(fut.set_exception, e),
         )
         return fut
 
@@ -1052,566 +1522,1212 @@
         loop = asyncio.get_running_loop()
         fut = loop.create_future()
         reply_handler = lambda ret=None: loop.call_soon_threadsafe(fut.set_result, ret)
-        error_handler = lambda err: loop.call_soon_threadsafe(fut.set_exception, dbus_to_bridge_exception(err))
-        self.db_core_iface.action_launch(callback_id, data, profile_key, timeout=const_TIMEOUT, reply_handler=reply_handler, error_handler=error_handler)
+        error_handler = lambda err: loop.call_soon_threadsafe(
+            fut.set_exception, dbus_to_bridge_exception(err)
+        )
+        self.db_core_iface.action_launch(
+            callback_id,
+            data,
+            profile_key,
+            timeout=const_TIMEOUT,
+            reply_handler=reply_handler,
+            error_handler=error_handler,
+        )
         return fut
 
     def actions_get(self, profile_key="@DEFAULT@"):
         loop = asyncio.get_running_loop()
         fut = loop.create_future()
         reply_handler = lambda ret=None: loop.call_soon_threadsafe(fut.set_result, ret)
-        error_handler = lambda err: loop.call_soon_threadsafe(fut.set_exception, dbus_to_bridge_exception(err))
-        self.db_core_iface.actions_get(profile_key, timeout=const_TIMEOUT, reply_handler=reply_handler, error_handler=error_handler)
+        error_handler = lambda err: loop.call_soon_threadsafe(
+            fut.set_exception, dbus_to_bridge_exception(err)
+        )
+        self.db_core_iface.actions_get(
+            profile_key,
+            timeout=const_TIMEOUT,
+            reply_handler=reply_handler,
+            error_handler=error_handler,
+        )
         return fut
 
     def config_get(self, section, name):
         loop = asyncio.get_running_loop()
         fut = loop.create_future()
         reply_handler = lambda ret=None: loop.call_soon_threadsafe(fut.set_result, ret)
-        error_handler = lambda err: loop.call_soon_threadsafe(fut.set_exception, dbus_to_bridge_exception(err))
-        self.db_core_iface.config_get(section, name, timeout=const_TIMEOUT, reply_handler=reply_handler, error_handler=error_handler)
+        error_handler = lambda err: loop.call_soon_threadsafe(
+            fut.set_exception, dbus_to_bridge_exception(err)
+        )
+        self.db_core_iface.config_get(
+            section,
+            name,
+            timeout=const_TIMEOUT,
+            reply_handler=reply_handler,
+            error_handler=error_handler,
+        )
         return fut
 
-    def connect(self, profile_key="@DEFAULT@", password='', options={}):
+    def connect(self, profile_key="@DEFAULT@", password="", options={}):
         loop = asyncio.get_running_loop()
         fut = loop.create_future()
         reply_handler = lambda ret=None: loop.call_soon_threadsafe(fut.set_result, ret)
-        error_handler = lambda err: loop.call_soon_threadsafe(fut.set_exception, dbus_to_bridge_exception(err))
-        self.db_core_iface.connect(profile_key, password, options, timeout=const_TIMEOUT, reply_handler=reply_handler, error_handler=error_handler)
+        error_handler = lambda err: loop.call_soon_threadsafe(
+            fut.set_exception, dbus_to_bridge_exception(err)
+        )
+        self.db_core_iface.connect(
+            profile_key,
+            password,
+            options,
+            timeout=const_TIMEOUT,
+            reply_handler=reply_handler,
+            error_handler=error_handler,
+        )
         return fut
 
     def contact_add(self, entity_jid, profile_key="@DEFAULT@"):
         loop = asyncio.get_running_loop()
         fut = loop.create_future()
         reply_handler = lambda ret=None: loop.call_soon_threadsafe(fut.set_result, ret)
-        error_handler = lambda err: loop.call_soon_threadsafe(fut.set_exception, dbus_to_bridge_exception(err))
-        self.db_core_iface.contact_add(entity_jid, profile_key, timeout=const_TIMEOUT, reply_handler=reply_handler, error_handler=error_handler)
+        error_handler = lambda err: loop.call_soon_threadsafe(
+            fut.set_exception, dbus_to_bridge_exception(err)
+        )
+        self.db_core_iface.contact_add(
+            entity_jid,
+            profile_key,
+            timeout=const_TIMEOUT,
+            reply_handler=reply_handler,
+            error_handler=error_handler,
+        )
         return fut
 
     def contact_del(self, entity_jid, profile_key="@DEFAULT@"):
         loop = asyncio.get_running_loop()
         fut = loop.create_future()
         reply_handler = lambda ret=None: loop.call_soon_threadsafe(fut.set_result, ret)
-        error_handler = lambda err: loop.call_soon_threadsafe(fut.set_exception, dbus_to_bridge_exception(err))
-        self.db_core_iface.contact_del(entity_jid, profile_key, timeout=const_TIMEOUT, reply_handler=reply_handler, error_handler=error_handler)
+        error_handler = lambda err: loop.call_soon_threadsafe(
+            fut.set_exception, dbus_to_bridge_exception(err)
+        )
+        self.db_core_iface.contact_del(
+            entity_jid,
+            profile_key,
+            timeout=const_TIMEOUT,
+            reply_handler=reply_handler,
+            error_handler=error_handler,
+        )
         return fut
 
     def contact_get(self, arg_0, profile_key="@DEFAULT@"):
         loop = asyncio.get_running_loop()
         fut = loop.create_future()
         reply_handler = lambda ret=None: loop.call_soon_threadsafe(fut.set_result, ret)
-        error_handler = lambda err: loop.call_soon_threadsafe(fut.set_exception, dbus_to_bridge_exception(err))
-        self.db_core_iface.contact_get(arg_0, profile_key, timeout=const_TIMEOUT, reply_handler=reply_handler, error_handler=error_handler)
+        error_handler = lambda err: loop.call_soon_threadsafe(
+            fut.set_exception, dbus_to_bridge_exception(err)
+        )
+        self.db_core_iface.contact_get(
+            arg_0,
+            profile_key,
+            timeout=const_TIMEOUT,
+            reply_handler=reply_handler,
+            error_handler=error_handler,
+        )
         return fut
 
     def contact_update(self, entity_jid, name, groups, profile_key="@DEFAULT@"):
         loop = asyncio.get_running_loop()
         fut = loop.create_future()
         reply_handler = lambda ret=None: loop.call_soon_threadsafe(fut.set_result, ret)
-        error_handler = lambda err: loop.call_soon_threadsafe(fut.set_exception, dbus_to_bridge_exception(err))
-        self.db_core_iface.contact_update(entity_jid, name, groups, profile_key, timeout=const_TIMEOUT, reply_handler=reply_handler, error_handler=error_handler)
+        error_handler = lambda err: loop.call_soon_threadsafe(
+            fut.set_exception, dbus_to_bridge_exception(err)
+        )
+        self.db_core_iface.contact_update(
+            entity_jid,
+            name,
+            groups,
+            profile_key,
+            timeout=const_TIMEOUT,
+            reply_handler=reply_handler,
+            error_handler=error_handler,
+        )
         return fut
 
     def contacts_get(self, profile_key="@DEFAULT@"):
         loop = asyncio.get_running_loop()
         fut = loop.create_future()
         reply_handler = lambda ret=None: loop.call_soon_threadsafe(fut.set_result, ret)
-        error_handler = lambda err: loop.call_soon_threadsafe(fut.set_exception, dbus_to_bridge_exception(err))
-        self.db_core_iface.contacts_get(profile_key, timeout=const_TIMEOUT, reply_handler=reply_handler, error_handler=error_handler)
+        error_handler = lambda err: loop.call_soon_threadsafe(
+            fut.set_exception, dbus_to_bridge_exception(err)
+        )
+        self.db_core_iface.contacts_get(
+            profile_key,
+            timeout=const_TIMEOUT,
+            reply_handler=reply_handler,
+            error_handler=error_handler,
+        )
         return fut
 
     def contacts_get_from_group(self, group, profile_key="@DEFAULT@"):
         loop = asyncio.get_running_loop()
         fut = loop.create_future()
         reply_handler = lambda ret=None: loop.call_soon_threadsafe(fut.set_result, ret)
-        error_handler = lambda err: loop.call_soon_threadsafe(fut.set_exception, dbus_to_bridge_exception(err))
-        self.db_core_iface.contacts_get_from_group(group, profile_key, timeout=const_TIMEOUT, reply_handler=reply_handler, error_handler=error_handler)
+        error_handler = lambda err: loop.call_soon_threadsafe(
+            fut.set_exception, dbus_to_bridge_exception(err)
+        )
+        self.db_core_iface.contacts_get_from_group(
+            group,
+            profile_key,
+            timeout=const_TIMEOUT,
+            reply_handler=reply_handler,
+            error_handler=error_handler,
+        )
         return fut
 
     def devices_infos_get(self, bare_jid, profile_key):
         loop = asyncio.get_running_loop()
         fut = loop.create_future()
         reply_handler = lambda ret=None: loop.call_soon_threadsafe(fut.set_result, ret)
-        error_handler = lambda err: loop.call_soon_threadsafe(fut.set_exception, dbus_to_bridge_exception(err))
-        self.db_core_iface.devices_infos_get(bare_jid, profile_key, timeout=const_TIMEOUT, reply_handler=reply_handler, error_handler=error_handler)
+        error_handler = lambda err: loop.call_soon_threadsafe(
+            fut.set_exception, dbus_to_bridge_exception(err)
+        )
+        self.db_core_iface.devices_infos_get(
+            bare_jid,
+            profile_key,
+            timeout=const_TIMEOUT,
+            reply_handler=reply_handler,
+            error_handler=error_handler,
+        )
         return fut
 
-    def disco_find_by_features(self, namespaces, identities, bare_jid=False, service=True, roster=True, own_jid=True, local_device=False, profile_key="@DEFAULT@"):
+    def disco_find_by_features(
+        self,
+        namespaces,
+        identities,
+        bare_jid=False,
+        service=True,
+        roster=True,
+        own_jid=True,
+        local_device=False,
+        profile_key="@DEFAULT@",
+    ):
         loop = asyncio.get_running_loop()
         fut = loop.create_future()
         reply_handler = lambda ret=None: loop.call_soon_threadsafe(fut.set_result, ret)
-        error_handler = lambda err: loop.call_soon_threadsafe(fut.set_exception, dbus_to_bridge_exception(err))
-        self.db_core_iface.disco_find_by_features(namespaces, identities, bare_jid, service, roster, own_jid, local_device, profile_key, timeout=const_TIMEOUT, reply_handler=reply_handler, error_handler=error_handler)
+        error_handler = lambda err: loop.call_soon_threadsafe(
+            fut.set_exception, dbus_to_bridge_exception(err)
+        )
+        self.db_core_iface.disco_find_by_features(
+            namespaces,
+            identities,
+            bare_jid,
+            service,
+            roster,
+            own_jid,
+            local_device,
+            profile_key,
+            timeout=const_TIMEOUT,
+            reply_handler=reply_handler,
+            error_handler=error_handler,
+        )
         return fut
 
-    def disco_infos(self, entity_jid, node=u'', use_cache=True, profile_key="@DEFAULT@"):
+    def disco_infos(self, entity_jid, node="", use_cache=True, profile_key="@DEFAULT@"):
         loop = asyncio.get_running_loop()
         fut = loop.create_future()
         reply_handler = lambda ret=None: loop.call_soon_threadsafe(fut.set_result, ret)
-        error_handler = lambda err: loop.call_soon_threadsafe(fut.set_exception, dbus_to_bridge_exception(err))
-        self.db_core_iface.disco_infos(entity_jid, node, use_cache, profile_key, timeout=const_TIMEOUT, reply_handler=reply_handler, error_handler=error_handler)
+        error_handler = lambda err: loop.call_soon_threadsafe(
+            fut.set_exception, dbus_to_bridge_exception(err)
+        )
+        self.db_core_iface.disco_infos(
+            entity_jid,
+            node,
+            use_cache,
+            profile_key,
+            timeout=const_TIMEOUT,
+            reply_handler=reply_handler,
+            error_handler=error_handler,
+        )
         return fut
 
-    def disco_items(self, entity_jid, node=u'', use_cache=True, profile_key="@DEFAULT@"):
+    def disco_items(self, entity_jid, node="", use_cache=True, profile_key="@DEFAULT@"):
         loop = asyncio.get_running_loop()
         fut = loop.create_future()
         reply_handler = lambda ret=None: loop.call_soon_threadsafe(fut.set_result, ret)
-        error_handler = lambda err: loop.call_soon_threadsafe(fut.set_exception, dbus_to_bridge_exception(err))
-        self.db_core_iface.disco_items(entity_jid, node, use_cache, profile_key, timeout=const_TIMEOUT, reply_handler=reply_handler, error_handler=error_handler)
+        error_handler = lambda err: loop.call_soon_threadsafe(
+            fut.set_exception, dbus_to_bridge_exception(err)
+        )
+        self.db_core_iface.disco_items(
+            entity_jid,
+            node,
+            use_cache,
+            profile_key,
+            timeout=const_TIMEOUT,
+            reply_handler=reply_handler,
+            error_handler=error_handler,
+        )
         return fut
 
     def disconnect(self, profile_key="@DEFAULT@"):
         loop = asyncio.get_running_loop()
         fut = loop.create_future()
         reply_handler = lambda ret=None: loop.call_soon_threadsafe(fut.set_result, ret)
-        error_handler = lambda err: loop.call_soon_threadsafe(fut.set_exception, dbus_to_bridge_exception(err))
-        self.db_core_iface.disconnect(profile_key, timeout=const_TIMEOUT, reply_handler=reply_handler, error_handler=error_handler)
+        error_handler = lambda err: loop.call_soon_threadsafe(
+            fut.set_exception, dbus_to_bridge_exception(err)
+        )
+        self.db_core_iface.disconnect(
+            profile_key,
+            timeout=const_TIMEOUT,
+            reply_handler=reply_handler,
+            error_handler=error_handler,
+        )
         return fut
 
     def encryption_namespace_get(self, arg_0):
         loop = asyncio.get_running_loop()
         fut = loop.create_future()
         reply_handler = lambda ret=None: loop.call_soon_threadsafe(fut.set_result, ret)
-        error_handler = lambda err: loop.call_soon_threadsafe(fut.set_exception, dbus_to_bridge_exception(err))
-        self.db_core_iface.encryption_namespace_get(arg_0, timeout=const_TIMEOUT, reply_handler=reply_handler, error_handler=error_handler)
+        error_handler = lambda err: loop.call_soon_threadsafe(
+            fut.set_exception, dbus_to_bridge_exception(err)
+        )
+        self.db_core_iface.encryption_namespace_get(
+            arg_0,
+            timeout=const_TIMEOUT,
+            reply_handler=reply_handler,
+            error_handler=error_handler,
+        )
         return fut
 
     def encryption_plugins_get(self):
         loop = asyncio.get_running_loop()
         fut = loop.create_future()
         reply_handler = lambda ret=None: loop.call_soon_threadsafe(fut.set_result, ret)
-        error_handler = lambda err: loop.call_soon_threadsafe(fut.set_exception, dbus_to_bridge_exception(err))
-        self.db_core_iface.encryption_plugins_get(timeout=const_TIMEOUT, reply_handler=reply_handler, error_handler=error_handler)
+        error_handler = lambda err: loop.call_soon_threadsafe(
+            fut.set_exception, dbus_to_bridge_exception(err)
+        )
+        self.db_core_iface.encryption_plugins_get(
+            timeout=const_TIMEOUT,
+            reply_handler=reply_handler,
+            error_handler=error_handler,
+        )
         return fut
 
     def encryption_trust_ui_get(self, to_jid, namespace, profile_key):
         loop = asyncio.get_running_loop()
         fut = loop.create_future()
         reply_handler = lambda ret=None: loop.call_soon_threadsafe(fut.set_result, ret)
-        error_handler = lambda err: loop.call_soon_threadsafe(fut.set_exception, dbus_to_bridge_exception(err))
-        self.db_core_iface.encryption_trust_ui_get(to_jid, namespace, profile_key, timeout=const_TIMEOUT, reply_handler=reply_handler, error_handler=error_handler)
+        error_handler = lambda err: loop.call_soon_threadsafe(
+            fut.set_exception, dbus_to_bridge_exception(err)
+        )
+        self.db_core_iface.encryption_trust_ui_get(
+            to_jid,
+            namespace,
+            profile_key,
+            timeout=const_TIMEOUT,
+            reply_handler=reply_handler,
+            error_handler=error_handler,
+        )
         return fut
 
     def entities_data_get(self, jids, keys, profile):
         loop = asyncio.get_running_loop()
         fut = loop.create_future()
         reply_handler = lambda ret=None: loop.call_soon_threadsafe(fut.set_result, ret)
-        error_handler = lambda err: loop.call_soon_threadsafe(fut.set_exception, dbus_to_bridge_exception(err))
-        self.db_core_iface.entities_data_get(jids, keys, profile, timeout=const_TIMEOUT, reply_handler=reply_handler, error_handler=error_handler)
+        error_handler = lambda err: loop.call_soon_threadsafe(
+            fut.set_exception, dbus_to_bridge_exception(err)
+        )
+        self.db_core_iface.entities_data_get(
+            jids,
+            keys,
+            profile,
+            timeout=const_TIMEOUT,
+            reply_handler=reply_handler,
+            error_handler=error_handler,
+        )
         return fut
 
     def entity_data_get(self, jid, keys, profile):
         loop = asyncio.get_running_loop()
         fut = loop.create_future()
         reply_handler = lambda ret=None: loop.call_soon_threadsafe(fut.set_result, ret)
-        error_handler = lambda err: loop.call_soon_threadsafe(fut.set_exception, dbus_to_bridge_exception(err))
-        self.db_core_iface.entity_data_get(jid, keys, profile, timeout=const_TIMEOUT, reply_handler=reply_handler, error_handler=error_handler)
+        error_handler = lambda err: loop.call_soon_threadsafe(
+            fut.set_exception, dbus_to_bridge_exception(err)
+        )
+        self.db_core_iface.entity_data_get(
+            jid,
+            keys,
+            profile,
+            timeout=const_TIMEOUT,
+            reply_handler=reply_handler,
+            error_handler=error_handler,
+        )
         return fut
 
     def features_get(self, profile_key):
         loop = asyncio.get_running_loop()
         fut = loop.create_future()
         reply_handler = lambda ret=None: loop.call_soon_threadsafe(fut.set_result, ret)
-        error_handler = lambda err: loop.call_soon_threadsafe(fut.set_exception, dbus_to_bridge_exception(err))
-        self.db_core_iface.features_get(profile_key, timeout=const_TIMEOUT, reply_handler=reply_handler, error_handler=error_handler)
+        error_handler = lambda err: loop.call_soon_threadsafe(
+            fut.set_exception, dbus_to_bridge_exception(err)
+        )
+        self.db_core_iface.features_get(
+            profile_key,
+            timeout=const_TIMEOUT,
+            reply_handler=reply_handler,
+            error_handler=error_handler,
+        )
         return fut
 
-    def history_get(self, from_jid, to_jid, limit, between=True, filters='', profile="@NONE@"):
+    def history_get(
+        self, from_jid, to_jid, limit, between=True, filters="", profile="@NONE@"
+    ):
         loop = asyncio.get_running_loop()
         fut = loop.create_future()
         reply_handler = lambda ret=None: loop.call_soon_threadsafe(fut.set_result, ret)
-        error_handler = lambda err: loop.call_soon_threadsafe(fut.set_exception, dbus_to_bridge_exception(err))
-        self.db_core_iface.history_get(from_jid, to_jid, limit, between, filters, profile, timeout=const_TIMEOUT, reply_handler=reply_handler, error_handler=error_handler)
+        error_handler = lambda err: loop.call_soon_threadsafe(
+            fut.set_exception, dbus_to_bridge_exception(err)
+        )
+        self.db_core_iface.history_get(
+            from_jid,
+            to_jid,
+            limit,
+            between,
+            filters,
+            profile,
+            timeout=const_TIMEOUT,
+            reply_handler=reply_handler,
+            error_handler=error_handler,
+        )
         return fut
 
     def image_check(self, arg_0):
         loop = asyncio.get_running_loop()
         fut = loop.create_future()
         reply_handler = lambda ret=None: loop.call_soon_threadsafe(fut.set_result, ret)
-        error_handler = lambda err: loop.call_soon_threadsafe(fut.set_exception, dbus_to_bridge_exception(err))
-        self.db_core_iface.image_check(arg_0, timeout=const_TIMEOUT, reply_handler=reply_handler, error_handler=error_handler)
+        error_handler = lambda err: loop.call_soon_threadsafe(
+            fut.set_exception, dbus_to_bridge_exception(err)
+        )
+        self.db_core_iface.image_check(
+            arg_0,
+            timeout=const_TIMEOUT,
+            reply_handler=reply_handler,
+            error_handler=error_handler,
+        )
         return fut
 
     def image_convert(self, source, dest, arg_2, extra):
         loop = asyncio.get_running_loop()
         fut = loop.create_future()
         reply_handler = lambda ret=None: loop.call_soon_threadsafe(fut.set_result, ret)
-        error_handler = lambda err: loop.call_soon_threadsafe(fut.set_exception, dbus_to_bridge_exception(err))
-        self.db_core_iface.image_convert(source, dest, arg_2, extra, timeout=const_TIMEOUT, reply_handler=reply_handler, error_handler=error_handler)
+        error_handler = lambda err: loop.call_soon_threadsafe(
+            fut.set_exception, dbus_to_bridge_exception(err)
+        )
+        self.db_core_iface.image_convert(
+            source,
+            dest,
+            arg_2,
+            extra,
+            timeout=const_TIMEOUT,
+            reply_handler=reply_handler,
+            error_handler=error_handler,
+        )
         return fut
 
     def image_generate_preview(self, image_path, profile_key):
         loop = asyncio.get_running_loop()
         fut = loop.create_future()
         reply_handler = lambda ret=None: loop.call_soon_threadsafe(fut.set_result, ret)
-        error_handler = lambda err: loop.call_soon_threadsafe(fut.set_exception, dbus_to_bridge_exception(err))
-        self.db_core_iface.image_generate_preview(image_path, profile_key, timeout=const_TIMEOUT, reply_handler=reply_handler, error_handler=error_handler)
+        error_handler = lambda err: loop.call_soon_threadsafe(
+            fut.set_exception, dbus_to_bridge_exception(err)
+        )
+        self.db_core_iface.image_generate_preview(
+            image_path,
+            profile_key,
+            timeout=const_TIMEOUT,
+            reply_handler=reply_handler,
+            error_handler=error_handler,
+        )
         return fut
 
     def image_resize(self, image_path, width, height):
         loop = asyncio.get_running_loop()
         fut = loop.create_future()
         reply_handler = lambda ret=None: loop.call_soon_threadsafe(fut.set_result, ret)
-        error_handler = lambda err: loop.call_soon_threadsafe(fut.set_exception, dbus_to_bridge_exception(err))
-        self.db_core_iface.image_resize(image_path, width, height, timeout=const_TIMEOUT, reply_handler=reply_handler, error_handler=error_handler)
+        error_handler = lambda err: loop.call_soon_threadsafe(
+            fut.set_exception, dbus_to_bridge_exception(err)
+        )
+        self.db_core_iface.image_resize(
+            image_path,
+            width,
+            height,
+            timeout=const_TIMEOUT,
+            reply_handler=reply_handler,
+            error_handler=error_handler,
+        )
         return fut
 
     def init_pre_script(self):
         loop = asyncio.get_running_loop()
         fut = loop.create_future()
         reply_handler = lambda ret=None: loop.call_soon_threadsafe(fut.set_result, ret)
-        error_handler = lambda err: loop.call_soon_threadsafe(fut.set_exception, dbus_to_bridge_exception(err))
-        self.db_core_iface.init_pre_script(timeout=const_TIMEOUT, reply_handler=reply_handler, error_handler=error_handler)
+        error_handler = lambda err: loop.call_soon_threadsafe(
+            fut.set_exception, dbus_to_bridge_exception(err)
+        )
+        self.db_core_iface.init_pre_script(
+            timeout=const_TIMEOUT,
+            reply_handler=reply_handler,
+            error_handler=error_handler,
+        )
         return fut
 
     def is_connected(self, profile_key="@DEFAULT@"):
         loop = asyncio.get_running_loop()
         fut = loop.create_future()
         reply_handler = lambda ret=None: loop.call_soon_threadsafe(fut.set_result, ret)
-        error_handler = lambda err: loop.call_soon_threadsafe(fut.set_exception, dbus_to_bridge_exception(err))
-        self.db_core_iface.is_connected(profile_key, timeout=const_TIMEOUT, reply_handler=reply_handler, error_handler=error_handler)
+        error_handler = lambda err: loop.call_soon_threadsafe(
+            fut.set_exception, dbus_to_bridge_exception(err)
+        )
+        self.db_core_iface.is_connected(
+            profile_key,
+            timeout=const_TIMEOUT,
+            reply_handler=reply_handler,
+            error_handler=error_handler,
+        )
         return fut
 
     def main_resource_get(self, contact_jid, profile_key="@DEFAULT@"):
         loop = asyncio.get_running_loop()
         fut = loop.create_future()
         reply_handler = lambda ret=None: loop.call_soon_threadsafe(fut.set_result, ret)
-        error_handler = lambda err: loop.call_soon_threadsafe(fut.set_exception, dbus_to_bridge_exception(err))
-        self.db_core_iface.main_resource_get(contact_jid, profile_key, timeout=const_TIMEOUT, reply_handler=reply_handler, error_handler=error_handler)
+        error_handler = lambda err: loop.call_soon_threadsafe(
+            fut.set_exception, dbus_to_bridge_exception(err)
+        )
+        self.db_core_iface.main_resource_get(
+            contact_jid,
+            profile_key,
+            timeout=const_TIMEOUT,
+            reply_handler=reply_handler,
+            error_handler=error_handler,
+        )
         return fut
 
     def menu_help_get(self, menu_id, language):
         loop = asyncio.get_running_loop()
         fut = loop.create_future()
         reply_handler = lambda ret=None: loop.call_soon_threadsafe(fut.set_result, ret)
-        error_handler = lambda err: loop.call_soon_threadsafe(fut.set_exception, dbus_to_bridge_exception(err))
-        self.db_core_iface.menu_help_get(menu_id, language, timeout=const_TIMEOUT, reply_handler=reply_handler, error_handler=error_handler)
+        error_handler = lambda err: loop.call_soon_threadsafe(
+            fut.set_exception, dbus_to_bridge_exception(err)
+        )
+        self.db_core_iface.menu_help_get(
+            menu_id,
+            language,
+            timeout=const_TIMEOUT,
+            reply_handler=reply_handler,
+            error_handler=error_handler,
+        )
         return fut
 
     def menu_launch(self, menu_type, path, data, security_limit, profile_key):
         loop = asyncio.get_running_loop()
         fut = loop.create_future()
         reply_handler = lambda ret=None: loop.call_soon_threadsafe(fut.set_result, ret)
-        error_handler = lambda err: loop.call_soon_threadsafe(fut.set_exception, dbus_to_bridge_exception(err))
-        self.db_core_iface.menu_launch(menu_type, path, data, security_limit, profile_key, timeout=const_TIMEOUT, reply_handler=reply_handler, error_handler=error_handler)
+        error_handler = lambda err: loop.call_soon_threadsafe(
+            fut.set_exception, dbus_to_bridge_exception(err)
+        )
+        self.db_core_iface.menu_launch(
+            menu_type,
+            path,
+            data,
+            security_limit,
+            profile_key,
+            timeout=const_TIMEOUT,
+            reply_handler=reply_handler,
+            error_handler=error_handler,
+        )
         return fut
 
     def menus_get(self, language, security_limit):
         loop = asyncio.get_running_loop()
         fut = loop.create_future()
         reply_handler = lambda ret=None: loop.call_soon_threadsafe(fut.set_result, ret)
-        error_handler = lambda err: loop.call_soon_threadsafe(fut.set_exception, dbus_to_bridge_exception(err))
-        self.db_core_iface.menus_get(language, security_limit, timeout=const_TIMEOUT, reply_handler=reply_handler, error_handler=error_handler)
+        error_handler = lambda err: loop.call_soon_threadsafe(
+            fut.set_exception, dbus_to_bridge_exception(err)
+        )
+        self.db_core_iface.menus_get(
+            language,
+            security_limit,
+            timeout=const_TIMEOUT,
+            reply_handler=reply_handler,
+            error_handler=error_handler,
+        )
         return fut
 
     def message_encryption_get(self, to_jid, profile_key):
         loop = asyncio.get_running_loop()
         fut = loop.create_future()
         reply_handler = lambda ret=None: loop.call_soon_threadsafe(fut.set_result, ret)
-        error_handler = lambda err: loop.call_soon_threadsafe(fut.set_exception, dbus_to_bridge_exception(err))
-        self.db_core_iface.message_encryption_get(to_jid, profile_key, timeout=const_TIMEOUT, reply_handler=reply_handler, error_handler=error_handler)
+        error_handler = lambda err: loop.call_soon_threadsafe(
+            fut.set_exception, dbus_to_bridge_exception(err)
+        )
+        self.db_core_iface.message_encryption_get(
+            to_jid,
+            profile_key,
+            timeout=const_TIMEOUT,
+            reply_handler=reply_handler,
+            error_handler=error_handler,
+        )
         return fut
 
-    def message_encryption_start(self, to_jid, namespace='', replace=False, profile_key="@NONE@"):
+    def message_encryption_start(
+        self, to_jid, namespace="", replace=False, profile_key="@NONE@"
+    ):
         loop = asyncio.get_running_loop()
         fut = loop.create_future()
         reply_handler = lambda ret=None: loop.call_soon_threadsafe(fut.set_result, ret)
-        error_handler = lambda err: loop.call_soon_threadsafe(fut.set_exception, dbus_to_bridge_exception(err))
-        self.db_core_iface.message_encryption_start(to_jid, namespace, replace, profile_key, timeout=const_TIMEOUT, reply_handler=reply_handler, error_handler=error_handler)
+        error_handler = lambda err: loop.call_soon_threadsafe(
+            fut.set_exception, dbus_to_bridge_exception(err)
+        )
+        self.db_core_iface.message_encryption_start(
+            to_jid,
+            namespace,
+            replace,
+            profile_key,
+            timeout=const_TIMEOUT,
+            reply_handler=reply_handler,
+            error_handler=error_handler,
+        )
         return fut
 
     def message_encryption_stop(self, to_jid, profile_key):
         loop = asyncio.get_running_loop()
         fut = loop.create_future()
         reply_handler = lambda ret=None: loop.call_soon_threadsafe(fut.set_result, ret)
-        error_handler = lambda err: loop.call_soon_threadsafe(fut.set_exception, dbus_to_bridge_exception(err))
-        self.db_core_iface.message_encryption_stop(to_jid, profile_key, timeout=const_TIMEOUT, reply_handler=reply_handler, error_handler=error_handler)
+        error_handler = lambda err: loop.call_soon_threadsafe(
+            fut.set_exception, dbus_to_bridge_exception(err)
+        )
+        self.db_core_iface.message_encryption_stop(
+            to_jid,
+            profile_key,
+            timeout=const_TIMEOUT,
+            reply_handler=reply_handler,
+            error_handler=error_handler,
+        )
         return fut
 
-    def message_send(self, to_jid, message, subject={}, mess_type="auto", extra={}, profile_key="@NONE@"):
+    def message_send(
+        self,
+        to_jid,
+        message,
+        subject={},
+        mess_type="auto",
+        extra={},
+        profile_key="@NONE@",
+    ):
         loop = asyncio.get_running_loop()
         fut = loop.create_future()
         reply_handler = lambda ret=None: loop.call_soon_threadsafe(fut.set_result, ret)
-        error_handler = lambda err: loop.call_soon_threadsafe(fut.set_exception, dbus_to_bridge_exception(err))
-        self.db_core_iface.message_send(to_jid, message, subject, mess_type, extra, profile_key, timeout=const_TIMEOUT, reply_handler=reply_handler, error_handler=error_handler)
+        error_handler = lambda err: loop.call_soon_threadsafe(
+            fut.set_exception, dbus_to_bridge_exception(err)
+        )
+        self.db_core_iface.message_send(
+            to_jid,
+            message,
+            subject,
+            mess_type,
+            extra,
+            profile_key,
+            timeout=const_TIMEOUT,
+            reply_handler=reply_handler,
+            error_handler=error_handler,
+        )
         return fut
 
     def namespaces_get(self):
         loop = asyncio.get_running_loop()
         fut = loop.create_future()
         reply_handler = lambda ret=None: loop.call_soon_threadsafe(fut.set_result, ret)
-        error_handler = lambda err: loop.call_soon_threadsafe(fut.set_exception, dbus_to_bridge_exception(err))
-        self.db_core_iface.namespaces_get(timeout=const_TIMEOUT, reply_handler=reply_handler, error_handler=error_handler)
+        error_handler = lambda err: loop.call_soon_threadsafe(
+            fut.set_exception, dbus_to_bridge_exception(err)
+        )
+        self.db_core_iface.namespaces_get(
+            timeout=const_TIMEOUT,
+            reply_handler=reply_handler,
+            error_handler=error_handler,
+        )
         return fut
 
-    def notification_add(self, type_, body_plain, body_rich, title, is_global, requires_action, arg_6, priority, expire_at, extra):
+    def notification_add(
+        self,
+        type_,
+        body_plain,
+        body_rich,
+        title,
+        is_global,
+        requires_action,
+        arg_6,
+        priority,
+        expire_at,
+        extra,
+    ):
         loop = asyncio.get_running_loop()
         fut = loop.create_future()
         reply_handler = lambda ret=None: loop.call_soon_threadsafe(fut.set_result, ret)
-        error_handler = lambda err: loop.call_soon_threadsafe(fut.set_exception, dbus_to_bridge_exception(err))
-        self.db_core_iface.notification_add(type_, body_plain, body_rich, title, is_global, requires_action, arg_6, priority, expire_at, extra, timeout=const_TIMEOUT, reply_handler=reply_handler, error_handler=error_handler)
+        error_handler = lambda err: loop.call_soon_threadsafe(
+            fut.set_exception, dbus_to_bridge_exception(err)
+        )
+        self.db_core_iface.notification_add(
+            type_,
+            body_plain,
+            body_rich,
+            title,
+            is_global,
+            requires_action,
+            arg_6,
+            priority,
+            expire_at,
+            extra,
+            timeout=const_TIMEOUT,
+            reply_handler=reply_handler,
+            error_handler=error_handler,
+        )
         return fut
 
     def notification_delete(self, id_, is_global, profile_key):
         loop = asyncio.get_running_loop()
         fut = loop.create_future()
         reply_handler = lambda ret=None: loop.call_soon_threadsafe(fut.set_result, ret)
-        error_handler = lambda err: loop.call_soon_threadsafe(fut.set_exception, dbus_to_bridge_exception(err))
-        self.db_core_iface.notification_delete(id_, is_global, profile_key, timeout=const_TIMEOUT, reply_handler=reply_handler, error_handler=error_handler)
+        error_handler = lambda err: loop.call_soon_threadsafe(
+            fut.set_exception, dbus_to_bridge_exception(err)
+        )
+        self.db_core_iface.notification_delete(
+            id_,
+            is_global,
+            profile_key,
+            timeout=const_TIMEOUT,
+            reply_handler=reply_handler,
+            error_handler=error_handler,
+        )
         return fut
 
     def notifications_expired_clean(self, limit_timestamp, profile_key):
         loop = asyncio.get_running_loop()
         fut = loop.create_future()
         reply_handler = lambda ret=None: loop.call_soon_threadsafe(fut.set_result, ret)
-        error_handler = lambda err: loop.call_soon_threadsafe(fut.set_exception, dbus_to_bridge_exception(err))
-        self.db_core_iface.notifications_expired_clean(limit_timestamp, profile_key, timeout=const_TIMEOUT, reply_handler=reply_handler, error_handler=error_handler)
+        error_handler = lambda err: loop.call_soon_threadsafe(
+            fut.set_exception, dbus_to_bridge_exception(err)
+        )
+        self.db_core_iface.notifications_expired_clean(
+            limit_timestamp,
+            profile_key,
+            timeout=const_TIMEOUT,
+            reply_handler=reply_handler,
+            error_handler=error_handler,
+        )
         return fut
 
     def notifications_get(self, filters, profile_key):
         loop = asyncio.get_running_loop()
         fut = loop.create_future()
         reply_handler = lambda ret=None: loop.call_soon_threadsafe(fut.set_result, ret)
-        error_handler = lambda err: loop.call_soon_threadsafe(fut.set_exception, dbus_to_bridge_exception(err))
-        self.db_core_iface.notifications_get(filters, profile_key, timeout=const_TIMEOUT, reply_handler=reply_handler, error_handler=error_handler)
+        error_handler = lambda err: loop.call_soon_threadsafe(
+            fut.set_exception, dbus_to_bridge_exception(err)
+        )
+        self.db_core_iface.notifications_get(
+            filters,
+            profile_key,
+            timeout=const_TIMEOUT,
+            reply_handler=reply_handler,
+            error_handler=error_handler,
+        )
         return fut
 
     def param_get_a(self, name, category, attribute="value", profile_key="@DEFAULT@"):
         loop = asyncio.get_running_loop()
         fut = loop.create_future()
         reply_handler = lambda ret=None: loop.call_soon_threadsafe(fut.set_result, ret)
-        error_handler = lambda err: loop.call_soon_threadsafe(fut.set_exception, dbus_to_bridge_exception(err))
-        self.db_core_iface.param_get_a(name, category, attribute, profile_key, timeout=const_TIMEOUT, reply_handler=reply_handler, error_handler=error_handler)
+        error_handler = lambda err: loop.call_soon_threadsafe(
+            fut.set_exception, dbus_to_bridge_exception(err)
+        )
+        self.db_core_iface.param_get_a(
+            name,
+            category,
+            attribute,
+            profile_key,
+            timeout=const_TIMEOUT,
+            reply_handler=reply_handler,
+            error_handler=error_handler,
+        )
         return fut
 
-    def param_get_a_async(self, name, category, attribute="value", security_limit=-1, profile_key="@DEFAULT@"):
+    def param_get_a_async(
+        self,
+        name,
+        category,
+        attribute="value",
+        security_limit=-1,
+        profile_key="@DEFAULT@",
+    ):
         loop = asyncio.get_running_loop()
         fut = loop.create_future()
         reply_handler = lambda ret=None: loop.call_soon_threadsafe(fut.set_result, ret)
-        error_handler = lambda err: loop.call_soon_threadsafe(fut.set_exception, dbus_to_bridge_exception(err))
-        self.db_core_iface.param_get_a_async(name, category, attribute, security_limit, profile_key, timeout=const_TIMEOUT, reply_handler=reply_handler, error_handler=error_handler)
+        error_handler = lambda err: loop.call_soon_threadsafe(
+            fut.set_exception, dbus_to_bridge_exception(err)
+        )
+        self.db_core_iface.param_get_a_async(
+            name,
+            category,
+            attribute,
+            security_limit,
+            profile_key,
+            timeout=const_TIMEOUT,
+            reply_handler=reply_handler,
+            error_handler=error_handler,
+        )
         return fut
 
-    def param_set(self, name, value, category, security_limit=-1, profile_key="@DEFAULT@"):
+    def param_set(
+        self, name, value, category, security_limit=-1, profile_key="@DEFAULT@"
+    ):
         loop = asyncio.get_running_loop()
         fut = loop.create_future()
         reply_handler = lambda ret=None: loop.call_soon_threadsafe(fut.set_result, ret)
-        error_handler = lambda err: loop.call_soon_threadsafe(fut.set_exception, dbus_to_bridge_exception(err))
-        self.db_core_iface.param_set(name, value, category, security_limit, profile_key, timeout=const_TIMEOUT, reply_handler=reply_handler, error_handler=error_handler)
+        error_handler = lambda err: loop.call_soon_threadsafe(
+            fut.set_exception, dbus_to_bridge_exception(err)
+        )
+        self.db_core_iface.param_set(
+            name,
+            value,
+            category,
+            security_limit,
+            profile_key,
+            timeout=const_TIMEOUT,
+            reply_handler=reply_handler,
+            error_handler=error_handler,
+        )
         return fut
 
-    def param_ui_get(self, security_limit=-1, app='', extra='', profile_key="@DEFAULT@"):
+    def param_ui_get(self, security_limit=-1, app="", extra="", profile_key="@DEFAULT@"):
         loop = asyncio.get_running_loop()
         fut = loop.create_future()
         reply_handler = lambda ret=None: loop.call_soon_threadsafe(fut.set_result, ret)
-        error_handler = lambda err: loop.call_soon_threadsafe(fut.set_exception, dbus_to_bridge_exception(err))
-        self.db_core_iface.param_ui_get(security_limit, app, extra, profile_key, timeout=const_TIMEOUT, reply_handler=reply_handler, error_handler=error_handler)
+        error_handler = lambda err: loop.call_soon_threadsafe(
+            fut.set_exception, dbus_to_bridge_exception(err)
+        )
+        self.db_core_iface.param_ui_get(
+            security_limit,
+            app,
+            extra,
+            profile_key,
+            timeout=const_TIMEOUT,
+            reply_handler=reply_handler,
+            error_handler=error_handler,
+        )
         return fut
 
     def params_categories_get(self):
         loop = asyncio.get_running_loop()
         fut = loop.create_future()
         reply_handler = lambda ret=None: loop.call_soon_threadsafe(fut.set_result, ret)
-        error_handler = lambda err: loop.call_soon_threadsafe(fut.set_exception, dbus_to_bridge_exception(err))
-        self.db_core_iface.params_categories_get(timeout=const_TIMEOUT, reply_handler=reply_handler, error_handler=error_handler)
+        error_handler = lambda err: loop.call_soon_threadsafe(
+            fut.set_exception, dbus_to_bridge_exception(err)
+        )
+        self.db_core_iface.params_categories_get(
+            timeout=const_TIMEOUT,
+            reply_handler=reply_handler,
+            error_handler=error_handler,
+        )
         return fut
 
-    def params_register_app(self, xml, security_limit=-1, app=''):
+    def params_register_app(self, xml, security_limit=-1, app=""):
         loop = asyncio.get_running_loop()
         fut = loop.create_future()
         reply_handler = lambda ret=None: loop.call_soon_threadsafe(fut.set_result, ret)
-        error_handler = lambda err: loop.call_soon_threadsafe(fut.set_exception, dbus_to_bridge_exception(err))
-        self.db_core_iface.params_register_app(xml, security_limit, app, timeout=const_TIMEOUT, reply_handler=reply_handler, error_handler=error_handler)
+        error_handler = lambda err: loop.call_soon_threadsafe(
+            fut.set_exception, dbus_to_bridge_exception(err)
+        )
+        self.db_core_iface.params_register_app(
+            xml,
+            security_limit,
+            app,
+            timeout=const_TIMEOUT,
+            reply_handler=reply_handler,
+            error_handler=error_handler,
+        )
         return fut
 
     def params_template_load(self, filename):
         loop = asyncio.get_running_loop()
         fut = loop.create_future()
         reply_handler = lambda ret=None: loop.call_soon_threadsafe(fut.set_result, ret)
-        error_handler = lambda err: loop.call_soon_threadsafe(fut.set_exception, dbus_to_bridge_exception(err))
-        self.db_core_iface.params_template_load(filename, timeout=const_TIMEOUT, reply_handler=reply_handler, error_handler=error_handler)
+        error_handler = lambda err: loop.call_soon_threadsafe(
+            fut.set_exception, dbus_to_bridge_exception(err)
+        )
+        self.db_core_iface.params_template_load(
+            filename,
+            timeout=const_TIMEOUT,
+            reply_handler=reply_handler,
+            error_handler=error_handler,
+        )
         return fut
 
     def params_template_save(self, filename):
         loop = asyncio.get_running_loop()
         fut = loop.create_future()
         reply_handler = lambda ret=None: loop.call_soon_threadsafe(fut.set_result, ret)
-        error_handler = lambda err: loop.call_soon_threadsafe(fut.set_exception, dbus_to_bridge_exception(err))
-        self.db_core_iface.params_template_save(filename, timeout=const_TIMEOUT, reply_handler=reply_handler, error_handler=error_handler)
+        error_handler = lambda err: loop.call_soon_threadsafe(
+            fut.set_exception, dbus_to_bridge_exception(err)
+        )
+        self.db_core_iface.params_template_save(
+            filename,
+            timeout=const_TIMEOUT,
+            reply_handler=reply_handler,
+            error_handler=error_handler,
+        )
         return fut
 
-    def params_values_from_category_get_async(self, category, security_limit=-1, app="", extra="", profile_key="@DEFAULT@"):
+    def params_values_from_category_get_async(
+        self, category, security_limit=-1, app="", extra="", profile_key="@DEFAULT@"
+    ):
         loop = asyncio.get_running_loop()
         fut = loop.create_future()
         reply_handler = lambda ret=None: loop.call_soon_threadsafe(fut.set_result, ret)
-        error_handler = lambda err: loop.call_soon_threadsafe(fut.set_exception, dbus_to_bridge_exception(err))
-        self.db_core_iface.params_values_from_category_get_async(category, security_limit, app, extra, profile_key, timeout=const_TIMEOUT, reply_handler=reply_handler, error_handler=error_handler)
+        error_handler = lambda err: loop.call_soon_threadsafe(
+            fut.set_exception, dbus_to_bridge_exception(err)
+        )
+        self.db_core_iface.params_values_from_category_get_async(
+            category,
+            security_limit,
+            app,
+            extra,
+            profile_key,
+            timeout=const_TIMEOUT,
+            reply_handler=reply_handler,
+            error_handler=error_handler,
+        )
         return fut
 
-    def presence_set(self, to_jid='', show='', statuses={}, profile_key="@DEFAULT@"):
+    def presence_set(self, to_jid="", show="", statuses={}, profile_key="@DEFAULT@"):
         loop = asyncio.get_running_loop()
         fut = loop.create_future()
         reply_handler = lambda ret=None: loop.call_soon_threadsafe(fut.set_result, ret)
-        error_handler = lambda err: loop.call_soon_threadsafe(fut.set_exception, dbus_to_bridge_exception(err))
-        self.db_core_iface.presence_set(to_jid, show, statuses, profile_key, timeout=const_TIMEOUT, reply_handler=reply_handler, error_handler=error_handler)
+        error_handler = lambda err: loop.call_soon_threadsafe(
+            fut.set_exception, dbus_to_bridge_exception(err)
+        )
+        self.db_core_iface.presence_set(
+            to_jid,
+            show,
+            statuses,
+            profile_key,
+            timeout=const_TIMEOUT,
+            reply_handler=reply_handler,
+            error_handler=error_handler,
+        )
         return fut
 
     def presence_statuses_get(self, profile_key="@DEFAULT@"):
         loop = asyncio.get_running_loop()
         fut = loop.create_future()
         reply_handler = lambda ret=None: loop.call_soon_threadsafe(fut.set_result, ret)
-        error_handler = lambda err: loop.call_soon_threadsafe(fut.set_exception, dbus_to_bridge_exception(err))
-        self.db_core_iface.presence_statuses_get(profile_key, timeout=const_TIMEOUT, reply_handler=reply_handler, error_handler=error_handler)
+        error_handler = lambda err: loop.call_soon_threadsafe(
+            fut.set_exception, dbus_to_bridge_exception(err)
+        )
+        self.db_core_iface.presence_statuses_get(
+            profile_key,
+            timeout=const_TIMEOUT,
+            reply_handler=reply_handler,
+            error_handler=error_handler,
+        )
         return fut
 
     def private_data_delete(self, namespace, key, arg_2):
         loop = asyncio.get_running_loop()
         fut = loop.create_future()
         reply_handler = lambda ret=None: loop.call_soon_threadsafe(fut.set_result, ret)
-        error_handler = lambda err: loop.call_soon_threadsafe(fut.set_exception, dbus_to_bridge_exception(err))
-        self.db_core_iface.private_data_delete(namespace, key, arg_2, timeout=const_TIMEOUT, reply_handler=reply_handler, error_handler=error_handler)
+        error_handler = lambda err: loop.call_soon_threadsafe(
+            fut.set_exception, dbus_to_bridge_exception(err)
+        )
+        self.db_core_iface.private_data_delete(
+            namespace,
+            key,
+            arg_2,
+            timeout=const_TIMEOUT,
+            reply_handler=reply_handler,
+            error_handler=error_handler,
+        )
         return fut
 
     def private_data_get(self, namespace, key, profile_key):
         loop = asyncio.get_running_loop()
         fut = loop.create_future()
         reply_handler = lambda ret=None: loop.call_soon_threadsafe(fut.set_result, ret)
-        error_handler = lambda err: loop.call_soon_threadsafe(fut.set_exception, dbus_to_bridge_exception(err))
-        self.db_core_iface.private_data_get(namespace, key, profile_key, timeout=const_TIMEOUT, reply_handler=reply_handler, error_handler=error_handler)
+        error_handler = lambda err: loop.call_soon_threadsafe(
+            fut.set_exception, dbus_to_bridge_exception(err)
+        )
+        self.db_core_iface.private_data_get(
+            namespace,
+            key,
+            profile_key,
+            timeout=const_TIMEOUT,
+            reply_handler=reply_handler,
+            error_handler=error_handler,
+        )
         return fut
 
     def private_data_set(self, namespace, key, data, profile_key):
         loop = asyncio.get_running_loop()
         fut = loop.create_future()
         reply_handler = lambda ret=None: loop.call_soon_threadsafe(fut.set_result, ret)
-        error_handler = lambda err: loop.call_soon_threadsafe(fut.set_exception, dbus_to_bridge_exception(err))
-        self.db_core_iface.private_data_set(namespace, key, data, profile_key, timeout=const_TIMEOUT, reply_handler=reply_handler, error_handler=error_handler)
+        error_handler = lambda err: loop.call_soon_threadsafe(
+            fut.set_exception, dbus_to_bridge_exception(err)
+        )
+        self.db_core_iface.private_data_set(
+            namespace,
+            key,
+            data,
+            profile_key,
+            timeout=const_TIMEOUT,
+            reply_handler=reply_handler,
+            error_handler=error_handler,
+        )
         return fut
 
-    def profile_create(self, profile, password='', component=''):
+    def profile_create(self, profile, password="", component=""):
         loop = asyncio.get_running_loop()
         fut = loop.create_future()
         reply_handler = lambda ret=None: loop.call_soon_threadsafe(fut.set_result, ret)
-        error_handler = lambda err: loop.call_soon_threadsafe(fut.set_exception, dbus_to_bridge_exception(err))
-        self.db_core_iface.profile_create(profile, password, component, timeout=const_TIMEOUT, reply_handler=reply_handler, error_handler=error_handler)
+        error_handler = lambda err: loop.call_soon_threadsafe(
+            fut.set_exception, dbus_to_bridge_exception(err)
+        )
+        self.db_core_iface.profile_create(
+            profile,
+            password,
+            component,
+            timeout=const_TIMEOUT,
+            reply_handler=reply_handler,
+            error_handler=error_handler,
+        )
         return fut
 
     def profile_delete_async(self, profile):
         loop = asyncio.get_running_loop()
         fut = loop.create_future()
         reply_handler = lambda ret=None: loop.call_soon_threadsafe(fut.set_result, ret)
-        error_handler = lambda err: loop.call_soon_threadsafe(fut.set_exception, dbus_to_bridge_exception(err))
-        self.db_core_iface.profile_delete_async(profile, timeout=const_TIMEOUT, reply_handler=reply_handler, error_handler=error_handler)
+        error_handler = lambda err: loop.call_soon_threadsafe(
+            fut.set_exception, dbus_to_bridge_exception(err)
+        )
+        self.db_core_iface.profile_delete_async(
+            profile,
+            timeout=const_TIMEOUT,
+            reply_handler=reply_handler,
+            error_handler=error_handler,
+        )
         return fut
 
     def profile_is_session_started(self, profile_key="@DEFAULT@"):
         loop = asyncio.get_running_loop()
         fut = loop.create_future()
         reply_handler = lambda ret=None: loop.call_soon_threadsafe(fut.set_result, ret)
-        error_handler = lambda err: loop.call_soon_threadsafe(fut.set_exception, dbus_to_bridge_exception(err))
-        self.db_core_iface.profile_is_session_started(profile_key, timeout=const_TIMEOUT, reply_handler=reply_handler, error_handler=error_handler)
+        error_handler = lambda err: loop.call_soon_threadsafe(
+            fut.set_exception, dbus_to_bridge_exception(err)
+        )
+        self.db_core_iface.profile_is_session_started(
+            profile_key,
+            timeout=const_TIMEOUT,
+            reply_handler=reply_handler,
+            error_handler=error_handler,
+        )
         return fut
 
     def profile_name_get(self, profile_key="@DEFAULT@"):
         loop = asyncio.get_running_loop()
         fut = loop.create_future()
         reply_handler = lambda ret=None: loop.call_soon_threadsafe(fut.set_result, ret)
-        error_handler = lambda err: loop.call_soon_threadsafe(fut.set_exception, dbus_to_bridge_exception(err))
-        self.db_core_iface.profile_name_get(profile_key, timeout=const_TIMEOUT, reply_handler=reply_handler, error_handler=error_handler)
+        error_handler = lambda err: loop.call_soon_threadsafe(
+            fut.set_exception, dbus_to_bridge_exception(err)
+        )
+        self.db_core_iface.profile_name_get(
+            profile_key,
+            timeout=const_TIMEOUT,
+            reply_handler=reply_handler,
+            error_handler=error_handler,
+        )
         return fut
 
     def profile_set_default(self, profile):
         loop = asyncio.get_running_loop()
         fut = loop.create_future()
         reply_handler = lambda ret=None: loop.call_soon_threadsafe(fut.set_result, ret)
-        error_handler = lambda err: loop.call_soon_threadsafe(fut.set_exception, dbus_to_bridge_exception(err))
-        self.db_core_iface.profile_set_default(profile, timeout=const_TIMEOUT, reply_handler=reply_handler, error_handler=error_handler)
+        error_handler = lambda err: loop.call_soon_threadsafe(
+            fut.set_exception, dbus_to_bridge_exception(err)
+        )
+        self.db_core_iface.profile_set_default(
+            profile,
+            timeout=const_TIMEOUT,
+            reply_handler=reply_handler,
+            error_handler=error_handler,
+        )
         return fut
 
-    def profile_start_session(self, password='', profile_key="@DEFAULT@"):
+    def profile_start_session(self, password="", profile_key="@DEFAULT@"):
         loop = asyncio.get_running_loop()
         fut = loop.create_future()
         reply_handler = lambda ret=None: loop.call_soon_threadsafe(fut.set_result, ret)
-        error_handler = lambda err: loop.call_soon_threadsafe(fut.set_exception, dbus_to_bridge_exception(err))
-        self.db_core_iface.profile_start_session(password, profile_key, timeout=const_TIMEOUT, reply_handler=reply_handler, error_handler=error_handler)
+        error_handler = lambda err: loop.call_soon_threadsafe(
+            fut.set_exception, dbus_to_bridge_exception(err)
+        )
+        self.db_core_iface.profile_start_session(
+            password,
+            profile_key,
+            timeout=const_TIMEOUT,
+            reply_handler=reply_handler,
+            error_handler=error_handler,
+        )
         return fut
 
     def profiles_list_get(self, clients=True, components=False):
         loop = asyncio.get_running_loop()
         fut = loop.create_future()
         reply_handler = lambda ret=None: loop.call_soon_threadsafe(fut.set_result, ret)
-        error_handler = lambda err: loop.call_soon_threadsafe(fut.set_exception, dbus_to_bridge_exception(err))
-        self.db_core_iface.profiles_list_get(clients, components, timeout=const_TIMEOUT, reply_handler=reply_handler, error_handler=error_handler)
+        error_handler = lambda err: loop.call_soon_threadsafe(
+            fut.set_exception, dbus_to_bridge_exception(err)
+        )
+        self.db_core_iface.profiles_list_get(
+            clients,
+            components,
+            timeout=const_TIMEOUT,
+            reply_handler=reply_handler,
+            error_handler=error_handler,
+        )
         return fut
 
     def progress_get(self, id, profile):
         loop = asyncio.get_running_loop()
         fut = loop.create_future()
         reply_handler = lambda ret=None: loop.call_soon_threadsafe(fut.set_result, ret)
-        error_handler = lambda err: loop.call_soon_threadsafe(fut.set_exception, dbus_to_bridge_exception(err))
-        self.db_core_iface.progress_get(id, profile, timeout=const_TIMEOUT, reply_handler=reply_handler, error_handler=error_handler)
+        error_handler = lambda err: loop.call_soon_threadsafe(
+            fut.set_exception, dbus_to_bridge_exception(err)
+        )
+        self.db_core_iface.progress_get(
+            id,
+            profile,
+            timeout=const_TIMEOUT,
+            reply_handler=reply_handler,
+            error_handler=error_handler,
+        )
         return fut
 
     def progress_get_all(self, profile):
         loop = asyncio.get_running_loop()
         fut = loop.create_future()
         reply_handler = lambda ret=None: loop.call_soon_threadsafe(fut.set_result, ret)
-        error_handler = lambda err: loop.call_soon_threadsafe(fut.set_exception, dbus_to_bridge_exception(err))
-        self.db_core_iface.progress_get_all(profile, timeout=const_TIMEOUT, reply_handler=reply_handler, error_handler=error_handler)
+        error_handler = lambda err: loop.call_soon_threadsafe(
+            fut.set_exception, dbus_to_bridge_exception(err)
+        )
+        self.db_core_iface.progress_get_all(
+            profile,
+            timeout=const_TIMEOUT,
+            reply_handler=reply_handler,
+            error_handler=error_handler,
+        )
         return fut
 
     def progress_get_all_metadata(self, profile):
         loop = asyncio.get_running_loop()
         fut = loop.create_future()
         reply_handler = lambda ret=None: loop.call_soon_threadsafe(fut.set_result, ret)
-        error_handler = lambda err: loop.call_soon_threadsafe(fut.set_exception, dbus_to_bridge_exception(err))
-        self.db_core_iface.progress_get_all_metadata(profile, timeout=const_TIMEOUT, reply_handler=reply_handler, error_handler=error_handler)
+        error_handler = lambda err: loop.call_soon_threadsafe(
+            fut.set_exception, dbus_to_bridge_exception(err)
+        )
+        self.db_core_iface.progress_get_all_metadata(
+            profile,
+            timeout=const_TIMEOUT,
+            reply_handler=reply_handler,
+            error_handler=error_handler,
+        )
         return fut
 
     def ready_get(self):
         loop = asyncio.get_running_loop()
         fut = loop.create_future()
         reply_handler = lambda ret=None: loop.call_soon_threadsafe(fut.set_result, ret)
-        error_handler = lambda err: loop.call_soon_threadsafe(fut.set_exception, dbus_to_bridge_exception(err))
-        self.db_core_iface.ready_get(timeout=const_TIMEOUT, reply_handler=reply_handler, error_handler=error_handler)
+        error_handler = lambda err: loop.call_soon_threadsafe(
+            fut.set_exception, dbus_to_bridge_exception(err)
+        )
+        self.db_core_iface.ready_get(
+            timeout=const_TIMEOUT,
+            reply_handler=reply_handler,
+            error_handler=error_handler,
+        )
         return fut
 
     def roster_resync(self, profile_key="@DEFAULT@"):
         loop = asyncio.get_running_loop()
         fut = loop.create_future()
         reply_handler = lambda ret=None: loop.call_soon_threadsafe(fut.set_result, ret)
-        error_handler = lambda err: loop.call_soon_threadsafe(fut.set_exception, dbus_to_bridge_exception(err))
-        self.db_core_iface.roster_resync(profile_key, timeout=const_TIMEOUT, reply_handler=reply_handler, error_handler=error_handler)
+        error_handler = lambda err: loop.call_soon_threadsafe(
+            fut.set_exception, dbus_to_bridge_exception(err)
+        )
+        self.db_core_iface.roster_resync(
+            profile_key,
+            timeout=const_TIMEOUT,
+            reply_handler=reply_handler,
+            error_handler=error_handler,
+        )
         return fut
 
     def session_infos_get(self, profile_key):
         loop = asyncio.get_running_loop()
         fut = loop.create_future()
         reply_handler = lambda ret=None: loop.call_soon_threadsafe(fut.set_result, ret)
-        error_handler = lambda err: loop.call_soon_threadsafe(fut.set_exception, dbus_to_bridge_exception(err))
-        self.db_core_iface.session_infos_get(profile_key, timeout=const_TIMEOUT, reply_handler=reply_handler, error_handler=error_handler)
+        error_handler = lambda err: loop.call_soon_threadsafe(
+            fut.set_exception, dbus_to_bridge_exception(err)
+        )
+        self.db_core_iface.session_infos_get(
+            profile_key,
+            timeout=const_TIMEOUT,
+            reply_handler=reply_handler,
+            error_handler=error_handler,
+        )
         return fut
 
     def sub_waiting_get(self, profile_key="@DEFAULT@"):
         loop = asyncio.get_running_loop()
         fut = loop.create_future()
         reply_handler = lambda ret=None: loop.call_soon_threadsafe(fut.set_result, ret)
-        error_handler = lambda err: loop.call_soon_threadsafe(fut.set_exception, dbus_to_bridge_exception(err))
-        self.db_core_iface.sub_waiting_get(profile_key, timeout=const_TIMEOUT, reply_handler=reply_handler, error_handler=error_handler)
+        error_handler = lambda err: loop.call_soon_threadsafe(
+            fut.set_exception, dbus_to_bridge_exception(err)
+        )
+        self.db_core_iface.sub_waiting_get(
+            profile_key,
+            timeout=const_TIMEOUT,
+            reply_handler=reply_handler,
+            error_handler=error_handler,
+        )
         return fut
 
     def subscription(self, sub_type, entity, profile_key="@DEFAULT@"):
         loop = asyncio.get_running_loop()
         fut = loop.create_future()
         reply_handler = lambda ret=None: loop.call_soon_threadsafe(fut.set_result, ret)
-        error_handler = lambda err: loop.call_soon_threadsafe(fut.set_exception, dbus_to_bridge_exception(err))
-        self.db_core_iface.subscription(sub_type, entity, profile_key, timeout=const_TIMEOUT, reply_handler=reply_handler, error_handler=error_handler)
+        error_handler = lambda err: loop.call_soon_threadsafe(
+            fut.set_exception, dbus_to_bridge_exception(err)
+        )
+        self.db_core_iface.subscription(
+            sub_type,
+            entity,
+            profile_key,
+            timeout=const_TIMEOUT,
+            reply_handler=reply_handler,
+            error_handler=error_handler,
+        )
         return fut
 
     def version_get(self):
         loop = asyncio.get_running_loop()
         fut = loop.create_future()
         reply_handler = lambda ret=None: loop.call_soon_threadsafe(fut.set_result, ret)
-        error_handler = lambda err: loop.call_soon_threadsafe(fut.set_exception, dbus_to_bridge_exception(err))
-        self.db_core_iface.version_get(timeout=const_TIMEOUT, reply_handler=reply_handler, error_handler=error_handler)
+        error_handler = lambda err: loop.call_soon_threadsafe(
+            fut.set_exception, dbus_to_bridge_exception(err)
+        )
+        self.db_core_iface.version_get(
+            timeout=const_TIMEOUT,
+            reply_handler=reply_handler,
+            error_handler=error_handler,
+        )
         return fut