libervia-backend: sat/memory/memory.py comparison

comparison sat/memory/memory.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	94708a7d3ecf
children	98d1f34ce5b9

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)
 log = getLogger(__name__)
 import os.path
 import copy
 from collections import namedtuple
-from ConfigParser import SafeConfigParser, NoOptionError, NoSectionError
+from configparser import SafeConfigParser, NoOptionError, NoSectionError
 from uuid import uuid4
 from twisted.python import failure
 from twisted.internet import defer, reactor, error
 from twisted.words.protocols.jabber import jid
 from sat.core import exceptions
 """
 if session_id is None:
 session_id = str(uuid4())
 elif session_id in self._sessions:
 raise exceptions.ConflictError(
-u"Session id {} is already used".format(session_id)
+"Session id {} is already used".format(session_id)
 )
 timer = reactor.callLater(self.timeout, self._purgeSession, session_id)
 if session_data is None:
 session_data = {}
 self._sessions[session_id] = (
 except error.AlreadyCalled:
 # if the session is time-outed, the timer has been called
 pass
 del self._sessions[session_id]
 log.debug(
-u"Session {} purged{}".format(
+"Session {} purged{}".format(
 session_id,
-u" (profile {})".format(profile) if profile is not None else u"",
+" (profile {})".format(profile) if profile is not None else "",
 )
 )
 def __len__(self):
 return len(self._sessions)
 def __delitem__(self, session_id):
 """ delete the session data """
 self._purgeSession(session_id)
 def keys(self):
-return self._sessions.keys()
+return list(self._sessions.keys())
 def iterkeys(self):
-return self._sessions.iterkeys()
+return iter(self._sessions.keys())
 class ProfileSessions(Sessions):
 """ProfileSessions extends the Sessions class, but here the profile can be
 used as the key to retrieve data or delete a session (instead of session id).
 @param profile: %(doc_profile)s
 @return: a list containing the sessions ids
 """
 ret = []
-for session_id in self._sessions.iterkeys():
+for session_id in self._sessions.keys():
 try:
 timer, session_data, profile_set = self._sessions[session_id]
 except ValueError:
 continue
 if profile == profile_set:
 old_default = "~/.sat"
 if os.path.isfile(os.path.expanduser(old_default) + "/" + C.SAVEFILE_DATABASE):
 if not silent:
 log.warning(
 _(
-u"A database has been found in the default local_dir for previous versions (< 0.5)"
+"A database has been found in the default local_dir for previous versions (< 0.5)"
 )
 )
 tools_config.fixConfigOption("", "local_dir", old_default, silent)
 return False
 filename = os.path.expanduser(filename)
 if os.path.exists(filename):
 try:
 self.params.load_xml(filename)
-log.debug(_(u"Parameters loaded from file: %s") % filename)
+log.debug(_("Parameters loaded from file: %s") % filename)
 return True
 except Exception as e:
-log.error(_(u"Can't load parameters from file: %s") % e)
+log.error(_("Can't load parameters from file: %s") % e)
 return False
 def save_xml(self, filename):
 """Save parameters template to xml file
 return False
 # TODO: need to encrypt files (at least passwords !) and set permissions
 filename = os.path.expanduser(filename)
 try:
 self.params.save_xml(filename)
-log.debug(_(u"Parameters saved to file: %s") % filename)
+log.debug(_("Parameters saved to file: %s") % filename)
 return True
 except Exception as e:
-log.error(_(u"Can't save parameters to file: %s") % e)
+log.error(_("Can't save parameters to file: %s") % e)
 return False
 def load(self):
 """Load parameters and all memory things from db"""
 # parameters data
 profile = self.getProfileName(profile)
 def createSession(__):
 """Called once params are loaded."""
 self._entities_cache[profile] = {}
-log.info(u"[{}] Profile session started".format(profile))
+log.info("[{}] Profile session started".format(profile))
 return False
 def backendInitialised(__):
 def doStartSession(__=None):
 if self.isSessionStarted(profile):
 """Delete a profile session
 @param profile: %(doc_profile)s
 """
 if self.host.isConnected(profile):
-log.debug(u"Disconnecting profile because of session stop")
+log.debug("Disconnecting profile because of session stop")
 self.host.disconnect(profile)
 self.auth_sessions.profileDelUnique(profile)
 try:
 self._entities_cache[profile]
 except KeyError:
-log.warning(u"Profile was not in cache")
+log.warning("Profile was not in cache")
 def _isSessionStarted(self, profile_key):
 return self.isSessionStarted(self.getProfileName(profile_key))
 def isSessionStarted(self, profile):
 # submitting a form with empty passwords is restricted to local frontends.
 return defer.succeed(None)
 def check_result(result):
 if not result:
-log.warning(u"Authentication failure of profile {}".format(profile))
+log.warning("Authentication failure of profile {}".format(profile))
 raise failure.Failure(
 exceptions.PasswordError(
-u"The provided profile password doesn't match."
+"The provided profile password doesn't match."
 )
 )
 if (
 not session_data
 ):  # avoid to create two profile sessions when password if specified
 def gotPersonalKey(personal_key):
 """Create the session for this profile and store the personal key"""
 self.auth_sessions.newSession(
 {C.MEMORY_CRYPTO_KEY: personal_key}, profile=profile
 )
-log.debug(u"auth session created for profile %s" % profile)
+log.debug("auth session created for profile %s" % profile)
 d = PersistentDict(C.MEMORY_CRYPTO_NAMESPACE, profile).load()
 d.addCallback(lambda data: BlockCipher.decrypt(key, data[C.MEMORY_CRYPTO_KEY]))
 return d.addCallback(gotPersonalKey)
 try:
 del self._entities_cache[profile]
 except KeyError:
 log.error(
 _(
-u"Trying to purge roster status cache for a profile not in memory: [%s]"
+"Trying to purge roster status cache for a profile not in memory: [%s]"
 )
 % profile
 )
 def getProfilesList(self, clients=True, components=False):
 @param clients(bool): if True return clients profiles
 @param components(bool): if True return components profiles
 @return (list[unicode]): selected profiles
 """
 if not clients and not components:
-log.warning(_(u"requesting no profiles at all"))
+log.warning(_("requesting no profiles at all"))
 return []
 profiles = self.storage.getProfilesList()
 if clients and components:
 return sorted(profiles)
 isComponent = self.storage.profileIsComponent
 @param component(None, unicode): set to entry point if this is a component
 @return: Deferred
 @raise exceptions.NotFound: component is not a known plugin import name
 """
 if not name:
-raise ValueError(u"Empty profile name")
+raise ValueError("Empty profile name")
 if name[0] == "@":
-raise ValueError(u"A profile name can't start with a '@'")
+raise ValueError("A profile name can't start with a '@'")
 if "\n" in name:
-raise ValueError(u"A profile name can't contain line feed ('\\n')")
+raise ValueError("A profile name can't contain line feed ('\\n')")
 if name in self._entities_cache:
-raise exceptions.ConflictError(u"A session for this profile exists")
+raise exceptions.ConflictError("A session for this profile exists")
 if component:
 if not component in self.host.plugins:
 raise exceptions.NotFound(
 _(
-u"Can't find component {component} entry point".format(
+"Can't find component {component} entry point".format(
 component=component
 )
 )
 )
 # FIXME: PLUGIN_INFO is not currently accessible after import, but type shoul be tested here
 ## Statuses ##
 def _getPresenceStatuses(self, profile_key):
 ret = self.getPresenceStatuses(profile_key)
-return {entity.full(): data for entity, data in ret.iteritems()}
+return {entity.full(): data for entity, data in ret.items()}
 def getPresenceStatuses(self, profile_key):
 """Get all the presence statuses of a profile
 @param profile_key: %(doc_profile_key)s
 """
 client = self.host.getClient(profile_key)
 profile_cache = self._getProfileCache(client)
 entities_presence = {}
-for entity_jid, entity_data in profile_cache.iteritems():
+for entity_jid, entity_data in profile_cache.items():
-for resource, resource_data in entity_data.iteritems():
+for resource, resource_data in entity_data.items():
 full_jid = copy.copy(entity_jid)
 full_jid.resource = resource
 try:
 presence_data = self.getEntityDatum(full_jid, "presence", profile_key)
 except KeyError:
 profile_cache = self._getProfileCache(client)
 try:
 entity_data = profile_cache[entity_jid.userhostJID()]
 except KeyError:
 raise exceptions.UnknownEntityError(
-u"Entity {} not in cache".format(entity_jid)
+"Entity {} not in cache".format(entity_jid)
 )
 resources = set(entity_data.keys())
 resources.discard(None)
 return resources
 full_jid = copy.copy(entity_jid)
 full_jid.resource = resource
 try:
 presence_data = self.getEntityDatum(full_jid, "presence", client.profile)
 except KeyError:
-log.debug(u"Can't get presence data for {}".format(full_jid))
+log.debug("Can't get presence data for {}".format(full_jid))
 else:
 if presence_data.show != C.PRESENCE_UNAVAILABLE:
 available.append(resource)
 return available
 except KeyError:  # plugin not found
 pass
 try:
 resources = self.getAllResources(client, entity_jid)
 except exceptions.UnknownEntityError:
-log.warning(u"Entity is not in cache, we can't find any resource")
+log.warning("Entity is not in cache, we can't find any resource")
 return None
 priority_resources = []
 for resource in resources:
 full_jid = copy.copy(entity_jid)
 full_jid.resource = resource
 try:
 presence_data = self.getEntityDatum(full_jid, "presence", client.profile)
 except KeyError:
-log.debug(u"No presence information for {}".format(full_jid))
+log.debug("No presence information for {}".format(full_jid))
 continue
 priority_resources.append((resource, presence_data.priority))
 try:
 return max(priority_resources, key=lambda res_tuple: res_tuple[1])[0]
 except ValueError:
-log.warning(u"No resource found at all for {}".format(entity_jid))
+log.warning("No resource found at all for {}".format(entity_jid))
 return None
 ## Entities data ##
 def _getProfileCache(self, client):
 @param with_bare: if True, include bare jids
 @return (list[unicode]): list of jids
 """
 profile_cache = self._getProfileCache(client)
 # we construct a list of all known full jids (bare jid of entities x resources)
-for bare_jid, entity_data in profile_cache.iteritems():
+for bare_jid, entity_data in profile_cache.items():
-for resource in entity_data.iterkeys():
+for resource in entity_data.keys():
 if resource is None:
 continue
 full_jid = copy.copy(bare_jid)
 full_jid.resource = resource
 yield full_jid
 jid_.resource, {}
 )
 entity_data[key] = value
 if key in self._key_signals and not silent:
-if not isinstance(value, basestring):
+if not isinstance(value, str):
 log.error(
-u"Setting a non string value ({}) for a key ({}) which has a signal flag".format(
+"Setting a non string value ({}) for a key ({}) which has a signal flag".format(
 value, key
 )
 )
 else:
 self.host.bridge.entityDataUpdated(
 for jid_ in entities:
 try:
 entity_data = profile_cache[jid_.userhostJID()][jid_.resource]
 except KeyError:
 raise exceptions.UnknownEntityError(
-u"Entity {} not in cache".format(jid_)
+"Entity {} not in cache".format(jid_)
 )
 try:
 del entity_data[key]
 except KeyError as e:
 if entity_jid in (C.ENTITY_ALL_RESOURCES, C.ENTITY_ALL):
 def _getEntitiesData(self, entities_jids, keys_list, profile_key):
 ret = self.getEntitiesData(
 [jid.JID(jid_) for jid_ in entities_jids], keys_list, profile_key
 )
-return {jid_.full(): data for jid_, data in ret.iteritems()}
+return {jid_.full(): data for jid_, data in ret.items()}
 def getEntitiesData(self, entities_jids, keys_list=None, profile_key=C.PROF_KEY_NONE):
 """Get a list of cached values for several entities at once
 @param entities_jids: jids of the entities, or empty list for all entities in cache
 ]
 except KeyError:
 continue
 ret_data[entity.full()] = fillEntityData(entity_cache_data, keys_list)
 else:
-for bare_jid, data in profile_cache.iteritems():
+for bare_jid, data in profile_cache.items():
-for resource, entity_cache_data in data.iteritems():
+for resource, entity_cache_data in data.items():
 full_jid = copy.copy(bare_jid)
 full_jid.resource = resource
 ret_data[full_jid] = fillEntityData(entity_cache_data)
 return ret_data
 profile_cache = self._getProfileCache(client)
 try:
 entity_data = profile_cache[entity_jid.userhostJID()][entity_jid.resource]
 except KeyError:
 raise exceptions.UnknownEntityError(
-u"Entity {} not in cache (was requesting {})".format(
+"Entity {} not in cache (was requesting {})".format(
 entity_jid, keys_list
 )
 )
 if keys_list is None:
 return entity_data
 raise ValueError(_("Need a bare jid to delete all resources"))
 try:
 del profile_cache[entity_jid]
 except KeyError:
 raise exceptions.UnknownEntityError(
-u"Entity {} not in cache".format(entity_jid)
+"Entity {} not in cache".format(entity_jid)
 )
 else:
 try:
 del profile_cache[entity_jid.userhostJID()][entity_jid.resource]
 except KeyError:
 raise exceptions.UnknownEntityError(
-u"Entity {} not in cache".format(entity_jid)
+"Entity {} not in cache".format(entity_jid)
 )
 ## Encryption ##
 def encryptValue(self, value, profile):
 return d.addCallback(cb)
 def done(__):
 log.debug(
-_(u"Personal data (%(ns)s, %(key)s) has been successfuly encrypted")
+_("Personal data (%(ns)s, %(key)s) has been successfuly encrypted")
 % {"ns": C.MEMORY_CRYPTO_NAMESPACE, "key": data_key}
 )
 d = PersistentDict(C.MEMORY_CRYPTO_NAMESPACE, profile).load()
 return d.addCallback(gotIndMemory).addCallback(done)
 peer_jid = peer_jid.userhostJID()
 if peer_jid == file_data["owner"]:
 # the owner has all rights
 return
 if not C.ACCESS_PERMS.issuperset(perms_to_check):
-raise exceptions.InternalError(_(u"invalid permission"))
+raise exceptions.InternalError(_("invalid permission"))
 for perm in perms_to_check:
 # we check each perm and raise PermissionError as soon as one condition is not valid
 # we must never return here, we only return after the loop if nothing was blocking the access
 try:
-perm_data = file_data[u"access"][perm]
+perm_data = file_data["access"][perm]
-perm_type = perm_data[u"type"]
+perm_type = perm_data["type"]
 except KeyError:
 raise exceptions.PermissionError()
 if perm_type == C.ACCESS_TYPE_PUBLIC:
 continue
 elif perm_type == C.ACCESS_TYPE_WHITELIST:
 try:
-jids = perm_data[u"jids"]
+jids = perm_data["jids"]
 except KeyError:
 raise exceptions.PermissionError()
 if peer_jid.full() in jids:
 continue
 else:
 raise exceptions.PermissionError()
 else:
 raise exceptions.InternalError(
-_(u"unknown access type: {type}").format(type=perm_type)
+_("unknown access type: {type}").format(type=perm_type)
 )
 @defer.inlineCallbacks
 def checkPermissionToRoot(self, client, file_data, peer_jid, perms_to_check):
 """do checkFilePermission on file_data and all its parents until root"""
 current = file_data
 while True:
 self.checkFilePermission(current, peer_jid, perms_to_check)
-parent = current[u"parent"]
+parent = current["parent"]
 if not parent:
 break
 files_data = yield self.getFile(
 self, client, peer_jid=None, file_id=parent, perms_to_check=None
 )
 try:
 current = files_data[0]
 except IndexError:
-raise exceptions.DataError(u"Missing parent")
+raise exceptions.DataError("Missing parent")
 @defer.inlineCallbacks
 def _getParentDir(
 self, client, path, parent, namespace, owner, peer_jid, perms_to_check
 ):
 (i.e. which don't exist)
 """
 # if path is set, we have to retrieve parent directory of the file(s) from it
 if parent is not None:
 raise exceptions.ConflictError(
-_(u"You can't use path and parent at the same time")
+_("You can't use path and parent at the same time")
 )
-path_elts = filter(None, path.split(u"/"))
+path_elts = [_f for _f in path.split("/") if _f]
-if {u"..", u"."}.intersection(path_elts):
+if {"..", "."}.intersection(path_elts):
-raise ValueError(_(u'".." or "." can\'t be used in path'))
+raise ValueError(_('".." or "." can\'t be used in path'))
 # we retrieve all directories from path until we get the parent container
 # non existing directories will be created
-parent = u""
+parent = ""
 for idx, path_elt in enumerate(path_elts):
 directories = yield self.storage.getFiles(
 client,
 parent=parent,
 type_=C.FILE_TYPE_DIRECTORY,
 if not directories:
 defer.returnValue((parent, path_elts[idx:]))
 # from this point, directories don't exist anymore, we have to create them
 elif len(directories) > 1:
 raise exceptions.InternalError(
-_(u"Several directories found, this should not happen")
+_("Several directories found, this should not happen")
 )
 else:
 directory = directories[0]
 self.checkFilePermission(directory, peer_jid, perms_to_check)
-parent = directory[u"id"]
+parent = directory["id"]
 defer.returnValue((parent, []))
 @defer.inlineCallbacks
 def getFiles(
 self, client, peer_jid, file_id=None, version=None, parent=None, path=None,
 the file
 on the path
 """
 if peer_jid is None and perms_to_check or perms_to_check is None and peer_jid:
 raise exceptions.InternalError(
-u"if you want to disable permission check, both peer_jid and "
+"if you want to disable permission check, both peer_jid and "
-u"perms_to_check must be None"
+"perms_to_check must be None"
 )
 if owner is not None:
 owner = owner.userhostJID()
 if path is not None:
 # permission are checked by _getParentDir
 # we need to check all the parents
 parent_data = yield self.storage.getFiles(client, file_id=parent)
 try:
 parent_data = parent_data[0]
 except IndexError:
-raise exceptions.DataError(u"mising parent")
+raise exceptions.DataError("mising parent")
 yield self.checkPermissionToRoot(
 client, parent_data, peer_jid, perms_to_check
 )
 files = yield self.storage.getFiles(
 files.remove(file_data)
 defer.returnValue(files)
 @defer.inlineCallbacks
 def setFile(
-self, client, name, file_id=None, version=u"", parent=None, path=None,
+self, client, name, file_id=None, version="", parent=None, path=None,
 type_=C.FILE_TYPE_FILE, file_hash=None, hash_algo=None, size=None,
 namespace=None, mime_type=None, created=None, modified=None, owner=None,
 access=None, extra=None, peer_jid=None, perms_to_check=(C.ACCESS_PERM_WRITE,)
 ):
 """Set a file metadata
 if namespace is not None:
 namespace = namespace.strip() or None
 if type_ == C.FILE_TYPE_DIRECTORY:
 if any(version, file_hash, size, mime_type):
 raise ValueError(
-u"version, file_hash, size and mime_type can't be set for a directory"
+"version, file_hash, size and mime_type can't be set for a directory"
 )
 if owner is not None:
 owner = owner.userhostJID()
 if path is not None:
 new_dir_id = shortuuid.uuid()
 yield self.storage.setFile(
 client,
 name=new_dir,
 file_id=new_dir_id,
-version=u"",
+version="",
 parent=parent,
 type_=C.FILE_TYPE_DIRECTORY,
 namespace=namespace,
 created=time.time(),
 owner=owner,
 access=access,
 extra={},
 )
 parent = new_dir_id
 elif parent is None:
-parent = u""
+parent = ""
 yield self.storage.setFile(
 client,
 file_id=file_id,
 version=version,
 to delete)
 @param recursive(boolean): True if recursive deletion is needed
 @param files_path(unicode): path of the directory containing the actual files
 @param file_data(dict): data of the file to delete
 """
-if file_data[u'owner'] != peer_jid:
+if file_data['owner'] != peer_jid:
 raise exceptions.PermissionError(
-u"file {file_name} can't be deleted, {peer_jid} is not the owner"
+"file {file_name} can't be deleted, {peer_jid} is not the owner"
-.format(file_name=file_data[u'name'], peer_jid=peer_jid.full()))
+.format(file_name=file_data['name'], peer_jid=peer_jid.full()))
-if file_data[u'type'] == C.FILE_TYPE_DIRECTORY:
+if file_data['type'] == C.FILE_TYPE_DIRECTORY:
-sub_files = yield self.getFiles(client, peer_jid, parent=file_data[u'id'])
+sub_files = yield self.getFiles(client, peer_jid, parent=file_data['id'])
 if sub_files and not recursive:
-raise exceptions.DataError(_(u"Can't delete directory, it is not empty"))
+raise exceptions.DataError(_("Can't delete directory, it is not empty"))
 # we first delete the sub-files
 for sub_file_data in sub_files:
 yield self._deleteFile(client, peer_jid, recursive, sub_file_data)
 # then the directory itself
-yield self.storage.fileDelete(file_data[u'id'])
+yield self.storage.fileDelete(file_data['id'])
-elif file_data[u'type'] == C.FILE_TYPE_FILE:
+elif file_data['type'] == C.FILE_TYPE_FILE:
-log.info(_(u"deleting file {name} with hash {file_hash}").format(
+log.info(_("deleting file {name} with hash {file_hash}").format(
-name=file_data[u'name'], file_hash=file_data[u'file_hash']))
+name=file_data['name'], file_hash=file_data['file_hash']))
-yield self.storage.fileDelete(file_data[u'id'])
+yield self.storage.fileDelete(file_data['id'])
 references = yield self.getFiles(
-client, peer_jid, file_hash=file_data[u'file_hash'])
+client, peer_jid, file_hash=file_data['file_hash'])
 if references:
-log.debug(u"there are still references to the file, we keep it")
+log.debug("there are still references to the file, we keep it")
 else:
-file_path = os.path.join(files_path, file_data[u'file_hash'])
+file_path = os.path.join(files_path, file_data['file_hash'])
-log.info(_(u"no reference left to {file_path}, deleting").format(
+log.info(_("no reference left to {file_path}, deleting").format(
 file_path=file_path))
 os.unlink(file_path)
 else:
-raise exceptions.InternalError(u'Unexpected file type: {file_type}'
+raise exceptions.InternalError('Unexpected file type: {file_type}'
-.format(file_type=file_data[u'type']))
+.format(file_type=file_data['type']))
 @defer.inlineCallbacks
 def fileDelete(self, client, peer_jid, file_id, recursive=False):
 """Delete a single file or a directory and all its sub-files
 """
 # FIXME: we only allow owner of file to delete files for now, but WRITE access
 #        should be checked too
 files_data = yield self.getFiles(client, peer_jid, file_id)
 if not files_data:
-raise exceptions.NotFound(u"Can't find the file with id {file_id}".format(
+raise exceptions.NotFound("Can't find the file with id {file_id}".format(
 file_id=file_id))
 file_data = files_data[0]
-if file_data[u"type"] != C.FILE_TYPE_DIRECTORY and recursive:
+if file_data["type"] != C.FILE_TYPE_DIRECTORY and recursive:
-raise ValueError(u"recursive can only be set for directories")
+raise ValueError("recursive can only be set for directories")
 files_path = self.host.getLocalPath(None, C.FILES_DIR, profile=False)
 yield self._deleteFile(client, peer_jid, recursive, files_path, file_data)
 ## Misc ##
 self.getAvailableResources(client, entity_jid)
 )  # is any resource is available, entity is available
 try:
 presence_data = self.getEntityDatum(entity_jid, "presence", client.profile)
 except KeyError:
-log.debug(u"No presence information for {}".format(entity_jid))
+log.debug("No presence information for {}".format(entity_jid))
 return False
 return presence_data.show != C.PRESENCE_UNAVAILABLE

Mercurial > libervia-backend

comparison sat/memory/memory.py @ 3028:ab2696e34d29