libervia-backend: sat/core/sat

comparison sat/core/sat_main.py @ 2624:56f94936df1e

code style reformatting using black

author	Goffi <goffi@goffi.org>
date	Wed, 27 Jun 2018 20:14:46 +0200
parents	9446f1ea9eac
children	189e38fb11ff

comparison

equal deleted inserted replaced

-:49533de4540b
+:56f94936df1e
 from twisted.internet import reactor
 from wokkel.xmppim import RosterItem
 from sat.core import xmpp
 from sat.core import exceptions
 from sat.core.log import getLogger
 log = getLogger(__name__)
 from sat.core.constants import Const as C
 from sat.memory import memory
 from sat.memory import cache
 from sat.tools import trigger
 import sys
 import os.path
 import uuid
 try:
-from collections import OrderedDict # only available from python 2.7
+from collections import OrderedDict  # only available from python 2.7
 except ImportError:
 from ordereddict import OrderedDict
 class SAT(service.Service):
 def __init__(self):
 self._cb_map = {}  # map from callback_id to callbacks
-self._menus = OrderedDict()  # dynamic menus. key: callback_id, value: menu data (dictionnary)
+self._menus = (
+OrderedDict()
+)  # dynamic menus. key: callback_id, value: menu data (dictionnary)
 self._menus_paths = {}  # path to id. key: (menu_type, lower case tuple of path), value: menu id
 self.initialised = defer.Deferred()
 self.profiles = {}
 self.plugins = {}
-self.ns_map = {u'x-data': u'jabber:x:data'}  # map for short name to whole namespace,
+self.ns_map = {
-# extended by plugins with registerNamespace
+u"x-data": u"jabber:x:data"
+}  #  map for short name to whole namespace,
+#  extended by plugins with registerNamespace
 self.memory = memory.Memory(self)
-self.trigger = trigger.TriggerManager()  # trigger are used to change SàT behaviour
+self.trigger = (
+trigger.TriggerManager()
-bridge_name = self.memory.getConfig('', 'bridge', 'dbus')
+)  # trigger are used to change SàT behaviour
+bridge_name = self.memory.getConfig("", "bridge", "dbus")
 bridge_module = dynamic_import.bridge(bridge_name)
 if bridge_module is None:
 log.error(u"Can't find bridge module of name {}".format(bridge_name))
 sys.exit(1)
 self.bridge.register_method("getReady", lambda: self.initialised)
 self.bridge.register_method("getVersion", lambda: self.full_version)
 self.bridge.register_method("getFeatures", self.getFeatures)
 self.bridge.register_method("profileNameGet", self.memory.getProfileName)
 self.bridge.register_method("profilesListGet", self.memory.getProfilesList)
-self.bridge.register_method("getEntityData", lambda jid_, keys, profile: self.memory.getEntityData(jid.JID(jid_), keys, profile))
+self.bridge.register_method(
+"getEntityData",
+lambda jid_, keys, profile: self.memory.getEntityData(
+jid.JID(jid_), keys, profile
+),
+)
 self.bridge.register_method("getEntitiesData", self.memory._getEntitiesData)
 self.bridge.register_method("profileCreate", self.memory.createProfile)
 self.bridge.register_method("asyncDeleteProfile", self.memory.asyncDeleteProfile)
 self.bridge.register_method("profileStartSession", self.memory.startSession)
-self.bridge.register_method("profileIsSessionStarted", self.memory._isSessionStarted)
+self.bridge.register_method(
+"profileIsSessionStarted", self.memory._isSessionStarted
+)
 self.bridge.register_method("profileSetDefault", self.memory.profileSetDefault)
 self.bridge.register_method("connect", self._connect)
 self.bridge.register_method("disconnect", self.disconnect)
 self.bridge.register_method("getContacts", self.getContacts)
 self.bridge.register_method("getContactsFromGroup", self.getContactsFromGroup)
 self.bridge.register_method("getMainResource", self.memory._getMainResource)
-self.bridge.register_method("getPresenceStatuses", self.memory._getPresenceStatuses)
+self.bridge.register_method(
+"getPresenceStatuses", self.memory._getPresenceStatuses
+)
 self.bridge.register_method("getWaitingSub", self.memory.getWaitingSub)
 self.bridge.register_method("messageSend", self._messageSend)
 self.bridge.register_method("getConfig", self._getConfig)
 self.bridge.register_method("setParam", self.setParam)
 self.bridge.register_method("getParamA", self.memory.getStringParamA)
 self.bridge.register_method("asyncGetParamA", self.memory.asyncGetStringParamA)
-self.bridge.register_method("asyncGetParamsValuesFromCategory", self.memory.asyncGetParamsValuesFromCategory)
+self.bridge.register_method(
+"asyncGetParamsValuesFromCategory",
+self.memory.asyncGetParamsValuesFromCategory,
+)
 self.bridge.register_method("getParamsUI", self.memory.getParamsUI)
-self.bridge.register_method("getParamsCategories", self.memory.getParamsCategories)
+self.bridge.register_method(
+"getParamsCategories", self.memory.getParamsCategories
+)
 self.bridge.register_method("paramsRegisterApp", self.memory.paramsRegisterApp)
 self.bridge.register_method("historyGet", self.memory._historyGet)
 self.bridge.register_method("setPresence", self._setPresence)
 self.bridge.register_method("subscription", self.subscription)
 self.bridge.register_method("addContact", self._addContact)
 @property
 def full_version(self):
 """Return the full version of SàT (with release name and extra data when in development mode)"""
 version = self.version
-if version[-1] == 'D':
+if version[-1] == "D":
 # we are in debug version, we add extra data
 try:
 return self._version_cache
 except AttributeError:
-self._version_cache = u"{} « {} » ({})".format(version, C.APP_RELEASE_NAME, utils.getRepositoryData(sat))
+self._version_cache = u"{} « {} » ({})".format(
+version, C.APP_RELEASE_NAME, utils.getRepositoryData(sat)
+)
 return self._version_cache
 else:
 return version
 @property
 try:
 self._import_plugins()
 ui_contact_list.ContactList(self)
 ui_profile_manager.ProfileManager(self)
 except Exception as e:
-log.error(_(u"Could not initialize backend: {reason}").format(
+log.error(
-reason = str(e).decode('utf-8', 'ignore')))
+_(u"Could not initialize backend: {reason}").format(
+reason=str(e).decode("utf-8", "ignore")
+)
+)
 sys.exit(1)
 self.initialised.callback(None)
 log.info(_(u"Backend is ready"))
 def _unimport_plugin(self, plugin_path):
 # FIXME: should use imp
 # TODO: do not import all plugins if no needed: component plugins are not needed if we
 #       just use a client, and plugin blacklisting should be possible in sat.conf
 plugins_path = os.path.dirname(sat.plugins.__file__)
 plugin_glob = "plugin*." + C.PLUGIN_EXT
-plug_lst = [os.path.splitext(plugin)[0] for plugin in map(os.path.basename, glob(os.path.join(plugins_path, plugin_glob)))]
+plug_lst = [
+os.path.splitext(plugin)[0]
+for plugin in map(
+os.path.basename, glob(os.path.join(plugins_path, plugin_glob))
+)
+]
 plugins_to_import = {}  # plugins we still have to import
 for plug in plug_lst:
-plugin_path = 'sat.plugins.' + plug
+plugin_path = "sat.plugins." + plug
 try:
 __import__(plugin_path)
 except exceptions.MissingModule as e:
 self._unimport_plugin(plugin_path)
-log.warning(u"Can't import plugin [{path}] because of an unavailale third party module:\n{msg}".format(
+log.warning(
-path=plugin_path, msg=e))
+u"Can't import plugin [{path}] because of an unavailale third party module:\n{msg}".format(
+path=plugin_path, msg=e
+)
+)
 continue
 except exceptions.CancelError as e:
-log.info(u"Plugin [{path}] cancelled its own import: {msg}".format(path=plugin_path, msg=e))
+log.info(
+u"Plugin [{path}] cancelled its own import: {msg}".format(
+path=plugin_path, msg=e
+)
+)
 self._unimport_plugin(plugin_path)
 continue
 except Exception as e:
 import traceback
-log.error(_(u"Can't import plugin [{path}]:\n{error}").format(path=plugin_path, error=traceback.format_exc()))
+log.error(
+_(u"Can't import plugin [{path}]:\n{error}").format(
+path=plugin_path, error=traceback.format_exc()
+)
+)
 self._unimport_plugin(plugin_path)
 continue
 mod = sys.modules[plugin_path]
 plugin_info = mod.PLUGIN_INFO
-import_name = plugin_info['import_name']
+import_name = plugin_info["import_name"]
-plugin_modes = plugin_info[u'modes'] = set(plugin_info.setdefault(u"modes", C.PLUG_MODE_DEFAULT))
+plugin_modes = plugin_info[u"modes"] = set(
+plugin_info.setdefault(u"modes", C.PLUG_MODE_DEFAULT)
+)
 # if the plugin is an entry point, it must work in component mode
-if plugin_info[u'type'] == C.PLUG_TYPE_ENTRY_POINT:
+if plugin_info[u"type"] == C.PLUG_TYPE_ENTRY_POINT:
 # if plugin is an entrypoint, we cache it
 if C.PLUG_MODE_COMPONENT not in plugin_modes:
-log.error(_(u"{type} type must be used with {mode} mode, ignoring plugin").format(
+log.error(
-type = C.PLUG_TYPE_ENTRY_POINT, mode = C.PLUG_MODE_COMPONENT))
+_(
+u"{type} type must be used with {mode} mode, ignoring plugin"
+).format(type=C.PLUG_TYPE_ENTRY_POINT, mode=C.PLUG_MODE_COMPONENT)
+)
 self._unimport_plugin(plugin_path)
 continue
 if import_name in plugins_to_import:
-log.error(_(u"Name conflict for import name [{import_name}], can't import plugin [{name}]").format(**plugin_info))
+log.error(
+_(
+u"Name conflict for import name [{import_name}], can't import plugin [{name}]"
+).format(**plugin_info)
+)
 continue
 plugins_to_import[import_name] = (plugin_path, mod, plugin_info)
 while True:
 try:
 self._import_plugins_from_dict(plugins_to_import)
 except ImportError:
 pass
 if not plugins_to_import:
 break
-def _import_plugins_from_dict(self, plugins_to_import, import_name=None, optional=False):
+def _import_plugins_from_dict(
+self, plugins_to_import, import_name=None, optional=False
+):
 """Recursively import and their dependencies in the right order
 @param plugins_to_import(dict): key=import_name and values=(plugin_path, module, plugin_info)
 @param import_name(unicode, None): name of the plugin to import as found in PLUGIN_INFO['import_name']
 @param optional(bool): if False and plugin is not found, an ImportError exception is raised
 """
 if import_name in self.plugins:
-log.debug(u'Plugin {} already imported, passing'.format(import_name))
+log.debug(u"Plugin {} already imported, passing".format(import_name))
 return
 if not import_name:
 import_name, (plugin_path, mod, plugin_info) = plugins_to_import.popitem()
 else:
 if not import_name in plugins_to_import:
 if optional:
-log.warning(_(u"Recommended plugin not found: {}").format(import_name))
+log.warning(
+_(u"Recommended plugin not found: {}").format(import_name)
+)
 return
 msg = u"Dependency not found: {}".format(import_name)
 log.error(msg)
 raise ImportError(msg)
 plugin_path, mod, plugin_info = plugins_to_import.pop(import_name)
 dependencies = plugin_info.setdefault("dependencies", [])
 recommendations = plugin_info.setdefault("recommendations", [])
 for to_import in dependencies + recommendations:
 if to_import not in self.plugins:
-log.debug(u'Recursively import dependency of [%s]: [%s]' % (import_name, to_import))
+log.debug(
+u"Recursively import dependency of [%s]: [%s]"
+% (import_name, to_import)
+)
 try:
-self._import_plugins_from_dict(plugins_to_import, to_import, to_import not in dependencies)
+self._import_plugins_from_dict(
+plugins_to_import, to_import, to_import not in dependencies
+)
 except ImportError as e:
-log.warning(_(u"Can't import plugin {name}: {error}").format(name=plugin_info['name'], error=e))
+log.warning(
+_(u"Can't import plugin {name}: {error}").format(
+name=plugin_info["name"], error=e
+)
+)
 if optional:
 return
 raise e
-log.info("importing plugin: {}".format(plugin_info['name']))
+log.info("importing plugin: {}".format(plugin_info["name"]))
 # we instanciate the plugin here
 try:
-self.plugins[import_name] = getattr(mod, plugin_info['main'])(self)
+self.plugins[import_name] = getattr(mod, plugin_info["main"])(self)
 except Exception as e:
-log.warning(u'Error while loading plugin "{name}", ignoring it: {error}'
+log.warning(
-.format(name=plugin_info['name'], error=e))
+u'Error while loading plugin "{name}", ignoring it: {error}'.format(
+name=plugin_info["name"], error=e
+)
+)
 if optional:
 return
 raise ImportError(u"Error during initiation")
 if C.bool(plugin_info.get(C.PI_HANDLER, C.BOOL_FALSE)):
 self.plugins[import_name].is_handler = True
 else:
 self.plugins[import_name].is_handler = False
 # we keep metadata as a Class attribute
 self.plugins[import_name]._info = plugin_info
-#TODO: test xmppclient presence and register handler parent
+# TODO: test xmppclient presence and register handler parent
 def pluginsUnload(self):
 """Call unload method on every loaded plugin, if exists
 @return (D): A deferred which return None when all method have been called
 continue
 else:
 defers_list.append(defer.maybeDeferred(unload))
 return defers_list
-def _connect(self, profile_key, password='', options=None):
+def _connect(self, profile_key, password="", options=None):
 profile = self.memory.getProfileName(profile_key)
 return self.connect(profile, password, options)
-def connect(self, profile, password='', options=None, max_retries=C.XMPP_MAX_RETRIES):
+def connect(self, profile, password="", options=None, max_retries=C.XMPP_MAX_RETRIES):
 """Connect a profile (i.e. connect client.component to XMPP server)
 Retrieve the individual parameters, authenticate the profile
 and initiate the connection to the associated XMPP server.
 @param profile: %(doc_profile)s
 - True if the XMPP connection was already established
 - False if the XMPP connection has been initiated (it may still fail)
 @raise exceptions.PasswordError: Profile password is wrong
 """
 if options is None:
-options={}
+options = {}
 def connectProfile(dummy=None):
 if self.isConnected(profile):
 log.info(_("already connected !"))
 return True
 except AttributeError:
 features_d = defer.succeed({})
 features.append(features_d)
 d_list = defer.DeferredList(features)
 def buildFeatures(result, import_names):
 assert len(result) == len(import_names)
 ret = {}
-for name, (success, data) in zip (import_names, result):
+for name, (success, data) in zip(import_names, result):
 if success:
 ret[name] = data
 else:
-log.warning(u"Error while getting features for {name}: {failure}".format(
+log.warning(
-name=name, failure=data))
+u"Error while getting features for {name}: {failure}".format(
+name=name, failure=data
+)
+)
 ret[name] = {}
 return ret
 d_list.addCallback(buildFeatures, self.plugins.keys())
 return d_list
 def getContacts(self, profile_key):
 client = self.getClient(profile_key)
 def got_roster(dummy):
 ret = []
 for item in client.roster.getItems():  # we get all items for client's roster
 # and convert them to expected format
 attr = client.roster.getAttributes(item)
 @param profile_key: %(doc_profile_key)s
 @return: list of clients
 """
 if not profile_key:
-raise exceptions.DataError(_(u'profile_key must not be empty'))
+raise exceptions.DataError(_(u"profile_key must not be empty"))
 try:
 profile = self.memory.getProfileName(profile_key, True)
 except exceptions.ProfileUnknownError:
 return []
 if profile == C.PROF_KEY_ALL:
 return self.profiles.values()
-elif profile[0] == '@':  # only profile keys can start with "@"
+elif profile[0] == "@":  #  only profile keys can start with "@"
 raise exceptions.ProfileKeyUnknown
 return [self.profiles[profile]]
 def _getConfig(self, section, name):
 """Get the main configuration option
 @param section: section of the config file (None or '' for DEFAULT)
 @param name: name of the option
 @return: unicode representation of the option
 """
-return unicode(self.memory.getConfig(section, name, ''))
+return unicode(self.memory.getConfig(section, name, ""))
 def logErrback(self, failure_):
 """generic errback logging
 can be used as last errback to show unexpected error
 """
 log.error(_(u"Unexpected error: {}".format(failure_)))
 return failure_
-# namespaces
+#  namespaces
 def registerNamespace(self, short_name, namespace):
 """associate a namespace to a short name"""
 if short_name in self.ns_map:
-raise exceptions.ConflictError(u'this short name is already used')
+raise exceptions.ConflictError(u"this short name is already used")
 self.ns_map[short_name] = namespace
 def getNamespaces(self):
 return self.ns_map
 def getSessionInfos(self, profile_key):
 """compile interesting data on current profile session"""
 client = self.getClient(profile_key)
-data = {
+data = {"jid": client.jid.full(), "started": unicode(int(client.started))}
-"jid": client.jid.full(),
-"started": unicode(int(client.started)),
-}
 return defer.succeed(data)
 # local dirs
 def getLocalPath(self, client, dir_name, *extra_path, **kwargs):
 @param *extra_path: extra path element(s) to use
 @return (unicode): path
 """
 # FIXME: component and profile are parsed with **kwargs because of python 2 limitations
 #        once moved to python 3, this can be fixed
-component = kwargs.pop('component', False)
+component = kwargs.pop("component", False)
-profile = kwargs.pop('profile', True)
+profile = kwargs.pop("profile", True)
 assert not kwargs
-path_elts = [self.memory.getConfig('', 'local_dir')]
+path_elts = [self.memory.getConfig("", "local_dir")]
 if component:
 path_elts.append(C.COMPONENTS_DIR)
 path_elts.append(regex.pathEscape(dir_name))
 if extra_path:
 path_elts.extend([regex.pathEscape(p) for p in extra_path])
 @param profile_key: key_word or profile name to determine profile name
 @return: True if connected
 """
 profile = self.memory.getProfileName(profile_key)
 if not profile:
-log.error(_('asking connection status for a non-existant profile'))
+log.error(_("asking connection status for a non-existant profile"))
 raise exceptions.ProfileUnknownError(profile_key)
 if profile not in self.profiles:
 return False
 return self.profiles[profile].isConnected()
 ## XMPP methods ##
-def _messageSend(self, to_jid_s, message, subject=None, mess_type='auto', extra=None, profile_key=C.PROF_KEY_NONE):
+def _messageSend(
+self,
+to_jid_s,
+message,
+subject=None,
+mess_type="auto",
+extra=None,
+profile_key=C.PROF_KEY_NONE,
+):
 client = self.getClient(profile_key)
 to_jid = jid.JID(to_jid_s)
-#XXX: we need to use the dictionary comprehension because D-Bus return its own types, and pickle can't manage them. TODO: Need to find a better way
+# XXX: we need to use the dictionary comprehension because D-Bus return its own types, and pickle can't manage them. TODO: Need to find a better way
-return client.sendMessage(to_jid, message, subject, mess_type, {unicode(key): unicode(value) for key, value in extra.items()})
+return client.sendMessage(
+to_jid,
+message,
+subject,
+mess_type,
+{unicode(key): unicode(value) for key, value in extra.items()},
+)
 def _setPresence(self, to="", show="", statuses=None, profile_key=C.PROF_KEY_NONE):
 return self.setPresence(jid.JID(to) if to else None, show, statuses, profile_key)
-def setPresence(self, to_jid=None, show="", statuses=None, profile_key=C.PROF_KEY_NONE):
+def setPresence(
+self, to_jid=None, show="", statuses=None, profile_key=C.PROF_KEY_NONE
+):
 """Send our presence information"""
 if statuses is None:
 statuses = {}
 profile = self.memory.getProfileName(profile_key)
 assert profile
-priority = int(self.memory.getParamA("Priority", "Connection", profile_key=profile))
+priority = int(
+self.memory.getParamA("Priority", "Connection", profile_key=profile)
+)
 self.profiles[profile].presence.available(to_jid, show, statuses, priority)
-#XXX: FIXME: temporary fix to work around openfire 3.7.0 bug (presence is not broadcasted to generating resource)
+# XXX: FIXME: temporary fix to work around openfire 3.7.0 bug (presence is not broadcasted to generating resource)
-if '' in statuses:
+if "" in statuses:
-statuses[C.PRESENCE_STATUSES_DEFAULT] = statuses.pop('')
+statuses[C.PRESENCE_STATUSES_DEFAULT] = statuses.pop("")
-self.bridge.presenceUpdate(self.profiles[profile].jid.full(), show,
+self.bridge.presenceUpdate(
-int(priority), statuses, profile)
+self.profiles[profile].jid.full(), show, int(priority), statuses, profile
+)
 def subscription(self, subs_type, raw_jid, profile_key):
 """Called to manage subscription
 @param subs_type: subsciption type (cf RFC 3921)
 @param raw_jid: unicode entity's jid
 @param profile_key: profile"""
 profile = self.memory.getProfileName(profile_key)
 assert profile
 to_jid = jid.JID(raw_jid)
-log.debug(_(u'subsciption request [%(subs_type)s] for %(jid)s') % {'subs_type': subs_type, 'jid': to_jid.full()})
+log.debug(
+_(u"subsciption request [%(subs_type)s] for %(jid)s")
+% {"subs_type": subs_type, "jid": to_jid.full()}
+)
 if subs_type == "subscribe":
 self.profiles[profile].presence.subscribe(to_jid)
 elif subs_type == "subscribed":
 self.profiles[profile].presence.subscribed(to_jid)
 elif subs_type == "unsubscribe":
 return self.memory.disco.findServiceEntities(*args, **kwargs)
 def findFeaturesSet(self, *args, **kwargs):
 return self.memory.disco.findFeaturesSet(*args, **kwargs)
-def _findByFeatures(self, namespaces, identities, bare_jids, service, roster, own_jid, local_device, profile_key):
+def _findByFeatures(
+self,
+namespaces,
+identities,
+bare_jids,
+service,
+roster,
+own_jid,
+local_device,
+profile_key,
+):
 client = self.getClient(profile_key)
-return self.findByFeatures(client, namespaces, identities, bare_jids, service, roster, own_jid, local_device)
+return self.findByFeatures(
+client,
+namespaces,
+identities,
+bare_jids,
+service,
+roster,
+own_jid,
+local_device,
+)
 @defer.inlineCallbacks
-def findByFeatures(self, client, namespaces, identities=None, bare_jids=False, service=True, roster=True, own_jid=True, local_device=False):
+def findByFeatures(
+self,
+client,
+namespaces,
+identities=None,
+bare_jids=False,
+service=True,
+roster=True,
+own_jid=True,
+local_device=False,
+):
 """retrieve all services or contacts managing a set a features
 @param namespaces(list[unicode]): features which must be handled
 @param identities(list[tuple[unicode,unicode]], None): if not None or empty, only keep those identities
 tuple must by (category, type)
 - roster entities
 """
 if not identities:
 identities = None
 if not namespaces and not identities:
-raise exceptions.DataError("at least one namespace or one identity must be set")
+raise exceptions.DataError(
+"at least one namespace or one identity must be set"
+)
 found_service = {}
 found_own = {}
 found_roster = {}
 if service:
 services_jids = yield self.findFeaturesSet(client, namespaces)
 for service_jid in services_jids:
 infos = yield self.getDiscoInfos(client, service_jid)
-if identities is not None and not set(infos.identities.keys()).issuperset(identities):
+if identities is not None and not set(infos.identities.keys()).issuperset(
+identities
+):
 continue
-found_identities = [(cat, type_, name or u'') for (cat, type_), name in infos.identities.iteritems()]
+found_identities = [
+(cat, type_, name or u"")
+for (cat, type_), name in infos.identities.iteritems()
+]
 found_service[service_jid.full()] = found_identities
 jids = []
 if roster:
 jids.extend(client.roster.getJids())
 if own_jid:
 jids.append(client.jid.userhostJID())
-for found, jids in ((found_own, [client.jid.userhostJID()]),
+for found, jids in (
-(found_roster, client.roster.getJids())):
+(found_own, [client.jid.userhostJID()]),
+(found_roster, client.roster.getJids()),
+):
 for jid_ in jids:
 if jid_.resource:
 if bare_jids:
 continue
 resources = [jid_.resource]
 full_jid = jid.JID(tuple=(jid_.user, jid_.host, resource))
 if full_jid == client.jid and not local_device:
 continue
 infos = yield self.getDiscoInfos(client, full_jid)
 if infos.features.issuperset(namespaces):
-if identities is not None and not set(infos.identities.keys()).issuperset(identities):
+if identities is not None and not set(
+infos.identities.keys()
+).issuperset(identities):
 continue
-found_identities = [(cat, type_, name or u'') for (cat, type_), name in infos.identities.iteritems()]
+found_identities = [
+(cat, type_, name or u"")
+for (cat, type_), name in infos.identities.iteritems()
+]
 found[full_jid.full()] = found_identities
 defer.returnValue((found_service, found_own, found_roster))
 ## Generic HMI ##
 def _killAction(self, keep_id, client):
 log.debug(u"Killing action {} for timeout".format(keep_id))
 client.actions[keep_id]
-def actionNew(self, action_data, security_limit=C.NO_SECURITY_LIMIT, keep_id=None, profile=C.PROF_KEY_NONE):
+def actionNew(
+self,
+action_data,
+security_limit=C.NO_SECURITY_LIMIT,
+keep_id=None,
+profile=C.PROF_KEY_NONE,
+):
 """Shortcut to bridge.actionNew which generate and id and keep for retrieval
 @param action_data(dict): action data (see bridge documentation)
 @param security_limit: %(doc_security_limit)s
 @param keep_id(None, unicode): if not None, used to keep action for differed retrieval
 @param profile: %(doc_profile)s
 """
 id_ = unicode(uuid.uuid4())
 if keep_id is not None:
 client = self.getClient(profile)
-action_timer = reactor.callLater(60*30, self._killAction, keep_id, client)
+action_timer = reactor.callLater(60 * 30, self._killAction, keep_id, client)
 client.actions[keep_id] = (action_data, id_, security_limit, action_timer)
 self.bridge.actionNew(action_data, id_, security_limit, profile)
 def actionsGet(self, profile):
 @param profile: %(doc_profile)s
 """
 client = self.getClient(profile)
 return [action_tuple[:-1] for action_tuple in client.actions.itervalues()]
-def registerProgressCb(self, progress_id, callback, metadata=None, profile=C.PROF_KEY_NONE):
+def registerProgressCb(
+self, progress_id, callback, metadata=None, profile=C.PROF_KEY_NONE
+):
 """Register a callback called when progress is requested for id"""
 if metadata is None:
 metadata = {}
 client = self.getClient(profile)
 if progress_id in client._progress_cb:
 except KeyError:
 log.error(_(u"Trying to remove an unknow progress callback"))
 def _progressGet(self, progress_id, profile):
 data = self.progressGet(progress_id, profile)
-return {k: unicode(v) for k,v in data.iteritems()}
+return {k: unicode(v) for k, v in data.iteritems()}
 def progressGet(self, progress_id, profile):
 """Return a dict with progress information
 @param progress_id(unicode): unique id of the progressing element
 progress_all = {}
 for client in clients:
 profile = client.profile
 progress_dict = {}
 progress_all[profile] = progress_dict
-for progress_id, (dummy, progress_metadata) in client._progress_cb.iteritems():
+for (
+progress_id,
+(dummy, progress_metadata),
+) in client._progress_cb.iteritems():
 progress_dict[progress_id] = progress_metadata
 return progress_all
 def progressGetAll(self, profile_key):
 """Return all progress status at once
 with_data(bool): True if the callback use the optional data dict
 force_id(unicode): id to avoid generated id. Can lead to name conflict, avoid if possible
 one_shot(bool): True to delete callback once it have been called
 @return: id of the registered callback
 """
-callback_id = kwargs.pop('force_id', None)
+callback_id = kwargs.pop("force_id", None)
 if callback_id is None:
 callback_id = str(uuid.uuid4())
 else:
 if callback_id in self._cb_map:
 raise exceptions.ConflictError(_(u"id already registered"))
 self._cb_map[callback_id] = (callback, args, kwargs)
-if "one_shot" in kwargs: # One Shot callback are removed after 30 min
+if "one_shot" in kwargs:  # One Shot callback are removed after 30 min
 def purgeCallback():
 try:
 self.removeCallback(callback_id)
 except KeyError:
 pass
 reactor.callLater(1800, purgeCallback)
 return callback_id
 def removeCallback(self, callback_id):
 - xmlui: a XMLUI need to be displayed
 - validated: if present, can be used to launch a callback, it can have the values
 - C.BOOL_TRUE
 - C.BOOL_FALSE
 """
-# FIXME: security limit need to be checked here
+#  FIXME: security limit need to be checked here
 try:
 client = self.getClient(profile_key)
 except exceptions.NotFound:
 # client is not available yet
 profile = self.memory.getProfileName(profile_key)
 if not profile:
-raise exceptions.ProfileUnknownError(_(u'trying to launch action with a non-existant profile'))
+raise exceptions.ProfileUnknownError(
+_(u"trying to launch action with a non-existant profile")
+)
 else:
 profile = client.profile
 # we check if the action is kept, and remove it
 try:
 action_tuple = client.actions[callback_id]
 except KeyError:
 pass
 else:
-action_tuple[-1].cancel() # the last item is the action timer
+action_tuple[-1].cancel()  # the last item is the action timer
 del client.actions[callback_id]
 try:
 callback, args, kwargs = self._cb_map[callback_id]
 except KeyError:
 raise exceptions.DataError(u"Unknown callback id {}".format(callback_id))
 if kwargs.get("with_data", False):
 if data is None:
 raise exceptions.DataError("Required data for this callback is missing")
-args,kwargs=list(args)[:],kwargs.copy() # we don't want to modify the original (kw)args
+args, kwargs = (
+list(args)[:],
+kwargs.copy(),
+)  # we don't want to modify the original (kw)args
 args.insert(0, data)
 kwargs["profile"] = profile
 del kwargs["with_data"]
-if kwargs.pop('one_shot', False):
+if kwargs.pop("one_shot", False):
 self.removeCallback(callback_id)
 return defer.maybeDeferred(callback, *args, **kwargs)
-#Menus management
+# Menus management
 def _getMenuCanonicalPath(self, path):
 """give canonical form of path
 canonical form is a tuple of the path were every element is stripped and lowercase
 @param path(iterable[unicode]): untranslated path to menu
 @return (tuple[unicode]): canonical form of path
 """
 return tuple((p.lower().strip() for p in path))
-def importMenu(self, path, callback, security_limit=C.NO_SECURITY_LIMIT, help_string="", type_=C.MENU_GLOBAL):
+def importMenu(
+self,
+path,
+callback,
+security_limit=C.NO_SECURITY_LIMIT,
+help_string="",
+type_=C.MENU_GLOBAL,
+):
 """register a new menu for frontends
 @param path(iterable[unicode]): path to go to the menu (category/subcategory/.../item) (e.g.: ("File", "Open"))
 /!\ use D_() instead of _() for translations (e.g. (D_("File"), D_("Open")))
 untranslated/lower case path can be used to identity a menu, for this reason it must be unique independently of case.
 callback_id = callback
 try:
 callback, args, kwargs = self._cb_map[callback_id]
 except KeyError:
 raise exceptions.DataError("Unknown callback id")
-kwargs["with_data"] = True # we have to be sure that we use extra data
+kwargs["with_data"] = True  # we have to be sure that we use extra data
 else:
 raise exceptions.DataError("Unknown callback type")
 for menu_data in self._menus.itervalues():
-if menu_data['path'] == path and menu_data['type'] == type_:
+if menu_data["path"] == path and menu_data["type"] == type_:
-raise exceptions.ConflictError(_("A menu with the same path and type already exists"))
+raise exceptions.ConflictError(
+_("A menu with the same path and type already exists")
+)
 path_canonical = self._getMenuCanonicalPath(path)
 menu_key = (type_, path_canonical)
 if menu_key in self._menus_paths:
-raise exceptions.ConflictError(u"this menu path is already used: {path} ({menu_key})".format(
+raise exceptions.ConflictError(
-path=path_canonical, menu_key=menu_key))
+u"this menu path is already used: {path} ({menu_key})".format(
+path=path_canonical, menu_key=menu_key
-menu_data = {'path': tuple(path),
+)
-'path_canonical': path_canonical,
+)
-'security_limit': security_limit,
-'help_string': help_string,
+menu_data = {
-'type': type_
+"path": tuple(path),
-}
+"path_canonical": path_canonical,
+"security_limit": security_limit,
+"help_string": help_string,
+"type": type_,
+}
 self._menus[callback_id] = menu_data
 self._menus_paths[menu_key] = callback_id
 return callback_id
-def getMenus(self, language='', security_limit=C.NO_SECURITY_LIMIT):
+def getMenus(self, language="", security_limit=C.NO_SECURITY_LIMIT):
 """Return all menus registered
 @param language: language used for translation, or empty string for default
 @param security_limit: %(doc_security_limit)s
 @return: array of tuple with:
 - icon: name of the icon to use (TODO)
 - help_url: link to a page with more complete documentation (TODO)
 """
 ret = []
 for menu_id, menu_data in self._menus.iteritems():
-type_ = menu_data['type']
+type_ = menu_data["type"]
-path = menu_data['path']
+path = menu_data["path"]
-menu_security_limit = menu_data['security_limit']
+menu_security_limit = menu_data["security_limit"]
-if security_limit!=C.NO_SECURITY_LIMIT and (menu_security_limit==C.NO_SECURITY_LIMIT or menu_security_limit>security_limit):
+if security_limit != C.NO_SECURITY_LIMIT and (
+menu_security_limit == C.NO_SECURITY_LIMIT
+or menu_security_limit > security_limit
+):
 continue
 languageSwitch(language)
 path_i18n = [_(elt) for elt in path]
 languageSwitch()
-extra = {} # TODO: manage extra data like icon
+extra = {}  # TODO: manage extra data like icon
 ret.append((menu_id, type_, path, path_i18n, extra))
 return ret
-def _launchMenu(self, menu_type, path, data=None, security_limit=C.NO_SECURITY_LIMIT, profile_key=C.PROF_KEY_NONE):
+def _launchMenu(
+self,
+menu_type,
+path,
+data=None,
+security_limit=C.NO_SECURITY_LIMIT,
+profile_key=C.PROF_KEY_NONE,
+):
 client = self.getClient(profile_key)
 return self.launchMenu(client, menu_type, path, data, security_limit)
-def launchMenu(self, client, menu_type, path, data=None, security_limit=C.NO_SECURITY_LIMIT):
+def launchMenu(
+self, client, menu_type, path, data=None, security_limit=C.NO_SECURITY_LIMIT
+):
 """launch action a menu action
 @param menu_type(unicode): type of menu to launch
 @param path(iterable[unicode]): canonical path of the menu
 @params data(dict): menu data
 canonical_path = self._getMenuCanonicalPath(path)
 menu_key = (menu_type, canonical_path)
 try:
 callback_id = self._menus_paths[menu_key]
 except KeyError:
-raise exceptions.NotFound(u"Can't find menu {path} ({menu_type})".format(
+raise exceptions.NotFound(
-path=canonical_path, menu_type=menu_type))
+u"Can't find menu {path} ({menu_type})".format(
+path=canonical_path, menu_type=menu_type
+)
+)
 return self.launchCallback(callback_id, data, client.profile)
-def getMenuHelp(self, menu_id, language=''):
+def getMenuHelp(self, menu_id, language=""):
 """return the help string of the menu
 @param menu_id: id of the menu (same as callback_id)
 @param language: language used for translation, or empty string for default
 @param return: translated help
 try:
 menu_data = self._menus[menu_id]
 except KeyError:
 raise exceptions.DataError("Trying to access an unknown menu")
 languageSwitch(language)
-help_string = _(menu_data['help_string'])
+help_string = _(menu_data["help_string"])
 languageSwitch()
 return help_string

Mercurial > libervia-backend

comparison sat/core/sat_main.py @ 2624:56f94936df1e