libervia-backend: sat/core/sat

comparison sat/core/sat_main.py @ 3028:ab2696e34d29

Python 3 port: /!\ this is a huge commit /!\ starting from this commit, SàT is needs Python 3.6+ /!\ SàT maybe be instable or some feature may not work anymore, this will improve with time This patch port backend, bridge and frontends to Python 3. Roughly this has been done this way: - 2to3 tools has been applied (with python 3.7) - all references to python2 have been replaced with python3 (notably shebangs) - fixed files not handled by 2to3 (notably the shell script) - several manual fixes - fixed issues reported by Python 3 that where not handled in Python 2 - replaced "async" with "async_" when needed (it's a reserved word from Python 3.7) - replaced zope's "implements" with @implementer decorator - temporary hack to handle data pickled in database, as str or bytes may be returned, to be checked later - fixed hash comparison for password - removed some code which is not needed anymore with Python 3 - deactivated some code which needs to be checked (notably certificate validation) - tested with jp, fixed reported issues until some basic commands worked - ported Primitivus (after porting dependencies like urwid satext) - more manual fixes

author	Goffi <goffi@goffi.org>
date	Tue, 13 Aug 2019 19:08:41 +0200
parents	6959c71ab8bf
children	fee60f17ebac

comparison

equal deleted inserted replaced

-:ff5bcb12ae60
+:ab2696e34d29
-#!/usr/bin/env python2
+#!/usr/bin/env python3
 # -*- coding: utf-8 -*-
 # SAT: a jabber client
 # Copyright (C) 2009-2019 Jérôme Poisson (goffi@goffi.org)
 self.initialised = defer.Deferred()
 self.profiles = {}
 self.plugins = {}
 # map for short name to whole namespace,
 self.ns_map = {
-u"x-data": xmpp.NS_X_DATA,
+"x-data": xmpp.NS_X_DATA,
-u"disco#info": xmpp.NS_DISCO_INFO,
+"disco#info": xmpp.NS_DISCO_INFO,
 }
 # extended by plugins with registerNamespace
 self.memory = memory.Memory(self)
 self.trigger = (
 trigger.TriggerManager()
 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))
+log.error("Can't find bridge module of name {}".format(bridge_name))
 sys.exit(1)
-log.info(u"using {} bridge".format(bridge_name))
+log.info("using {} bridge".format(bridge_name))
 try:
 self.bridge = bridge_module.Bridge()
 except exceptions.BridgeInitError:
-log.error(u"Bridge can't be initialised, can't start SàT core")
+log.error("Bridge can't be initialised, can't start SàT core")
 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)
 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(
+self._version_cache = "{} « {} » ({})".format(
 version, C.APP_RELEASE_NAME, utils.getRepositoryData(sat)
 )
 return self._version_cache
 else:
 return version
 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(
+_("Could not initialize backend: {reason}").format(
 reason=str(e).decode("utf-8", "ignore")
 )
 )
 sys.exit(1)
 self._addBaseMenus()
 self.initialised.callback(None)
-log.info(_(u"Backend is ready"))
+log.info(_("Backend is ready"))
 def _addBaseMenus(self):
 """Add base menus"""
 encryption.EncryptionHandler._importMenus(self)
 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 "
+"Can't import plugin [{path}] because of an unavailale third party "
-u"module:\n{msg}".format(
+"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(
+"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(
+_("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"]
-plugin_modes = plugin_info[u"modes"] = set(
+plugin_modes = plugin_info["modes"] = set(
-plugin_info.setdefault(u"modes", C.PLUG_MODE_DEFAULT)
+plugin_info.setdefault("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["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"
+"{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 "
+"Name conflict for import name [{import_name}], can't import "
-u"plugin [{name}]"
+"plugin [{name}]"
 ).format(**plugin_info)
 )
 continue
 plugins_to_import[import_name] = (plugin_path, mod, plugin_info)
 while True:
 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("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)
+_("Recommended plugin not found: {}").format(import_name)
 )
 return
-msg = u"Dependency not found: {}".format(import_name)
+msg = "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]"
+"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
 )
 except ImportError as e:
 log.warning(
-_(u"Can't import plugin {name}: {error}").format(
+_("Can't import plugin {name}: {error}").format(
 name=plugin_info["name"], error=e
 )
 )
 if optional:
 return
 # we instanciate the plugin here
 try:
 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}'.format(
+'Error while loading plugin "{name}", ignoring it: {error}'.format(
 name=plugin_info["name"], error=e
 )
 )
 if optional:
 return
-raise ImportError(u"Error during initiation")
+raise ImportError("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
 """
 # TODO: in the futur, it should be possible to hot unload a plugin
 #       pluging depending on the unloaded one should be unloaded too
 #       for now, just a basic call on plugin.unload is done
 defers_list = []
-for plugin in self.plugins.itervalues():
+for plugin in self.plugins.values():
 try:
 unload = plugin.unload
 except AttributeError:
 continue
 else:
 if options is None:
 options = {}
 def connectProfile(__=None):
 if self.isConnected(profile):
-log.info(_(u"already connected !"))
+log.info(_("already connected !"))
 return True
 if self.memory.isComponent(profile):
 d = xmpp.SatXMPPComponent.startConnection(self, profile, max_retries)
 else:
 # FIXME: client should not be deleted if only disconnected
 #        it shoud be deleted only when session is finished
 if not self.isConnected(profile_key):
 # isConnected is checked here and not on client
 # because client is deleted when session is ended
-log.info(_(u"not connected !"))
+log.info(_("not connected !"))
 return defer.succeed(None)
 client = self.getClient(profile_key)
 return client.entityDisconnect()
 def getFeatures(self, profile_key=C.PROF_KEY_NONE):
 profile_key = C.PROF_KEY_NONE
 except exceptions.ProfileNotSetError:
 pass
 features = []
-for import_name, plugin in self.plugins.iteritems():
+for import_name, plugin in self.plugins.items():
 try:
 features_d = defer.maybeDeferred(plugin.getFeatures, profile_key)
 except AttributeError:
 features_d = defer.succeed({})
 features.append(features_d)
 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(
+"Error while getting features for {name}: {failure}".format(
 name=name, failure=data
 )
 )
 ret[name] = {}
 return ret
-d_list.addCallback(buildFeatures, self.plugins.keys())
+d_list.addCallback(buildFeatures, list(self.plugins.keys()))
 return d_list
 def getContacts(self, profile_key):
 client = self.getClient(profile_key)
 log.error(_("Trying to remove reference to a client not referenced"))
 else:
 self.memory.purgeProfileSession(profile)
 def startService(self):
-log.info(u"Salut à toi ô mon frère !")
+log.info("Salut à toi ô mon frère !")
 def stopService(self):
-log.info(u"Salut aussi à Rantanplan")
+log.info("Salut aussi à Rantanplan")
 return self.pluginsUnload()
 def run(self):
 log.debug(_("running app"))
 reactor.run()
 Manage list through profile_key like C.PROF_KEY_ALL
 @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(_("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()
+return list(self.profiles.values())
 elif profile[0] == "@":  #  only profile keys can start with "@"
 raise exceptions.ProfileKeyUnknown
 return [self.profiles[profile]]
 def _getConfig(self, section, name):
 @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 str(self.memory.getConfig(section, name, ""))
-def logErrback(self, failure_, msg=_(u"Unexpected error: {failure_}")):
+def logErrback(self, failure_, msg=_("Unexpected error: {failure_}")):
 """Generic errback logging
 @param msg(unicode): error message ("failure_" key will be use for format)
 can be used as last errback to show unexpected error
 """
 #  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("this short name is already used")
 self.ns_map[short_name] = namespace
 def getNamespaces(self):
 return self.ns_map
 def getNamespace(self, short_name):
 try:
 return self.ns_map[short_name]
 except KeyError:
-raise exceptions.NotFound(u"namespace {short_name} is not registered"
+raise exceptions.NotFound("namespace {short_name} is not registered"
 .format(short_name=short_name))
 def getSessionInfos(self, profile_key):
 """compile interesting data on current profile session"""
 client = self.getClient(profile_key)
 data = {
 "jid": client.jid.full(),
-"started": unicode(int(client.started))
+"started": str(int(client.started))
 }
 return defer.succeed(data)
 # local dirs
 def _encryptionPluginsGet(self):
 plugins = encryption.EncryptionHandler.getPlugins()
 ret = []
 for p in plugins:
 ret.append({
-u"name": p.name,
+"name": p.name,
-u"namespace": p.namespace,
+"namespace": p.namespace,
-u"priority": unicode(p.priority),
+"priority": str(p.priority),
 })
 return ret
 def _encryptionTrustUIGet(self, to_jid_s, namespace, profile_key):
 client = self.getClient(profile_key)
 return client.sendMessage(
 to_jid,
 message,
 subject,
 mess_type,
-{unicode(key): unicode(value) for key, value in extra.items()},
+{str(key): str(value) for key, value in list(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)
 @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")
+_("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":
 for idx, (success, infos) in enumerate(services_infos):
 service_jid = services_jids[idx]
 if not success:
 log.warning(
-_(u"Can't find features for service {service_jid}, ignoring")
+_("Can't find features for service {service_jid}, ignoring")
 .format(service_jid=service_jid.full()))
 continue
 if (identities is not None
 and not set(infos.identities.keys()).issuperset(identities)):
 continue
 found_identities = [
-(cat, type_, name or u"")
+(cat, type_, name or "")
-for (cat, type_), name in infos.identities.iteritems()
+for (cat, type_), name in infos.identities.items()
 ]
 found_service[service_jid.full()] = found_identities
 to_find = []
 if own_jid:
 for idx, (success, infos) in enumerate(infos_data):
 full_jid = full_jids[idx]
 if not success:
 log.warning(
-_(u"Can't retrieve {full_jid} infos, ignoring")
+_("Can't retrieve {full_jid} infos, ignoring")
 .format(full_jid=full_jid.full()))
 continue
 if infos.features.issuperset(namespaces):
 if identities is not None and not set(
 infos.identities.keys()
 ).issuperset(identities):
 continue
 found_identities = [
-(cat, type_, name or u"")
+(cat, type_, name or "")
-for (cat, type_), name in infos.identities.iteritems()
+for (cat, type_), name in infos.identities.items()
 ]
 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))
+log.debug("Killing action {} for timeout".format(keep_id))
 client.actions[keep_id]
 def actionNew(
 self,
 action_data,
 @param keep_id(None, unicode): if not None, used to keep action for differed
 retrieval. Must be set to the callback_id.
 Action will be deleted after 30 min.
 @param profile: %(doc_profile)s
 """
-id_ = unicode(uuid.uuid4())
+id_ = str(uuid.uuid4())
 if keep_id is not None:
 client = self.getClient(profile)
 action_timer = reactor.callLater(60 * 30, self._killAction, keep_id, client)
 client.actions[keep_id] = (action_data, id_, security_limit, action_timer)
 """Return current non answered actions
 @param profile: %(doc_profile)s
 """
 client = self.getClient(profile)
-return [action_tuple[:-1] for action_tuple in client.actions.itervalues()]
+return [action_tuple[:-1] for action_tuple in client.actions.values()]
 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:
-raise exceptions.ConflictError(u"Progress ID is not unique !")
+raise exceptions.ConflictError("Progress ID is not unique !")
 client._progress_cb[progress_id] = (callback, metadata)
 def removeProgressCb(self, progress_id, profile):
 """Remove a progress callback"""
 client = self.getClient(profile)
 try:
 del client._progress_cb[progress_id]
 except KeyError:
-log.error(_(u"Trying to remove an unknow progress callback"))
+log.error(_("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: str(v) for k, v in data.items()}
 def progressGet(self, progress_id, profile):
 """Return a dict with progress information
 @param progress_id(unicode): unique id of the progressing element
 data = {}
 return data
 def _progressGetAll(self, profile_key):
 progress_all = self.progressGetAll(profile_key)
-for profile, progress_dict in progress_all.iteritems():
+for profile, progress_dict in progress_all.items():
-for progress_id, data in progress_dict.iteritems():
+for progress_id, data in progress_dict.items():
-for key, value in data.iteritems():
+for key, value in data.items():
-data[key] = unicode(value)
+data[key] = str(value)
 return progress_all
 def progressGetAllMetadata(self, profile_key):
 """Return all progress metadata at once
 progress_dict = {}
 progress_all[profile] = progress_dict
 for (
 progress_id,
 (__, progress_metadata),
-) in client._progress_cb.iteritems():
+) in client._progress_cb.items():
 progress_dict[progress_id] = progress_metadata
 return progress_all
 def progressGetAll(self, profile_key):
 """Return all progress status at once
 progress_all = {}
 for client in clients:
 profile = client.profile
 progress_dict = {}
 progress_all[profile] = progress_dict
-for progress_id, (progress_cb, __) in client._progress_cb.iteritems():
+for progress_id, (progress_cb, __) in client._progress_cb.items():
 progress_dict[progress_id] = progress_cb(progress_id, profile)
 return progress_all
 def registerCallback(self, callback, *args, **kwargs):
 """Register a callback.
 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"))
+raise exceptions.ConflictError(_("id already registered"))
 self._cb_map[callback_id] = (callback, args, kwargs)
 if "one_shot" in kwargs:  # One Shot callback are removed after 30 min
 def purgeCallback():
 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")
+_("trying to launch action with a non-existant profile")
 )
 else:
 profile = client.profile
 # we check if the action is kept, and remove it
 try:
 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))
+raise exceptions.DataError("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 = (
 """
 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):
-"""register a new menu for frontends
+r"""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
 @return (unicode): menu_id (same as callback_id)
 """
 if callable(callback):
 callback_id = self.registerCallback(callback, with_data=True)
-elif isinstance(callback, basestring):
+elif isinstance(callback, str):
 # The callback is already registered
 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
 else:
 raise exceptions.DataError("Unknown callback type")
-for menu_data in self._menus.itervalues():
+for menu_data in self._menus.values():
 if menu_data["path"] == path and menu_data["type"] == type_:
 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(
+"this menu path is already used: {path} ({menu_key})".format(
 path=path_canonical, menu_key=menu_key
 )
 )
 menu_data = {
 - extra (dict(unicode, unicode)): extra data where key can be:
 - 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():
+for menu_id, menu_data in self._menus.items():
 type_ = menu_data["type"]
 path = menu_data["path"]
 menu_security_limit = menu_data["security_limit"]
 if security_limit != C.NO_SECURITY_LIMIT and (
 menu_security_limit == C.NO_SECURITY_LIMIT
 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(
+"Can't find menu {path} ({menu_type})".format(
 path=canonical_path, menu_type=menu_type
 )
 )
 return self.launchCallback(callback_id, data, client.profile)

Mercurial > libervia-backend

comparison sat/core/sat_main.py @ 3028:ab2696e34d29