libervia-backend: sat_frontends/quick_frontend/quick_contact

comparison sat_frontends/quick_frontend/quick_contact_list.py @ 2624:56f94936df1e

code style reformatting using black

author	Goffi <goffi@goffi.org>
date	Wed, 27 Jun 2018 20:14:46 +0200
parents	81b70eeb710f
children	ce1e15d59496

comparison

equal deleted inserted replaced

-:49533de4540b
+:56f94936df1e
 """Contact List handling multi profiles at once,
 should replace quick_contact_list module in the future"""
 from sat.core.i18n import _
 from sat.core.log import getLogger
 log = getLogger(__name__)
 from sat.core import exceptions
 from sat_frontends.quick_frontend.quick_widgets import QuickWidget
 from sat_frontends.quick_frontend.constants import Const as C
 from sat_frontends.tools import jid
 from collections import OrderedDict
 try:
 # FIXME: to be removed when an acceptable solution is here
-unicode('')  # XXX: unicode doesn't exist in pyjamas
+unicode("")  # XXX: unicode doesn't exist in pyjamas
 except (TypeError, AttributeError):  # Error raised is not the same depending on
 # pyjsbuild options
 # XXX: pyjamas' max doesn't support key argument, so we implement it ourself
 pyjamas_max = max
 def max(iterable, key):
 iter_cpy = list(iterable)
 # do we show entities with notifications?
 # if True, entities will be show even if they normally would not
 # (e.g. not in contact list) if they have notifications attached
 self.show_entities_with_notifs = True
-self.host.bridge.asyncGetParamA(C.SHOW_EMPTY_GROUPS,
+self.host.bridge.asyncGetParamA(
-"General",
+C.SHOW_EMPTY_GROUPS,
-profile_key=profile,
+"General",
-callback=self._showEmptyGroups)
+profile_key=profile,
+callback=self._showEmptyGroups,
-self.host.bridge.asyncGetParamA(C.SHOW_OFFLINE_CONTACTS,
+)
-"General",
-profile_key=profile,
+self.host.bridge.asyncGetParamA(
-callback=self._showOfflineContacts)
+C.SHOW_OFFLINE_CONTACTS,
+"General",
+profile_key=profile,
+callback=self._showOfflineContacts,
+)
 # FIXME: workaround for a pyjamas issue: calling hash on a class method always
 #        return a different value if that method is defined directly within the
 #        class (with the "def" keyword)
 self.presenceListener = self.onPresenceUpdate
-self.host.addListener('presence', self.presenceListener, [self.profile])
+self.host.addListener("presence", self.presenceListener, [self.profile])
 self.nickListener = self.onNickUpdate
-self.host.addListener('nick', self.nickListener, [self.profile])
+self.host.addListener("nick", self.nickListener, [self.profile])
 self.notifListener = self.onNotification
-self.host.addListener('notification', self.notifListener, [self.profile])
+self.host.addListener("notification", self.notifListener, [self.profile])
 # notifListener only update the entity, so we can re-use it
-self.host.addListener('notificationsClear', self.notifListener, [self.profile])
+self.host.addListener("notificationsClear", self.notifListener, [self.profile])
 def _showEmptyGroups(self, show_str):
 # Called only by __init__
 # self.update is not wanted here, as it is done by
 # handler when all profiles are ready
 def roster_connected(self):
 """Return all the bare JIDs of the roster entities that are connected.
 @return (set[jid.JID])
 """
-return set([entity for entity in self._roster
+return set(
-if self.getCache(entity, C.PRESENCE_SHOW) is not None])
+[
+entity
+for entity in self._roster
+if self.getCache(entity, C.PRESENCE_SHOW) is not None
+]
+)
 @property
 def roster_entities_by_group(self):
 """Return a dictionary binding the roster groups to their entities bare JIDs.
 This also includes the empty group (None key).
 @return (dict[unicode,set(jid.JID)])
 """
-return {group: self._groups[group]['jids'] for group in self._groups}
+return {group: self._groups[group]["jids"] for group in self._groups}
 @property
 def roster_groups_by_entities(self):
 """Return a dictionary binding the entities bare JIDs to their roster groups
 @return (dict[jid.JID, set(unicode)])
 """
 result = {}
 for group, data in self._groups.iteritems():
-for entity in data['jids']:
+for entity in data["jids"]:
 result.setdefault(entity, set()).add(group)
 return result
 @property
 def selected(self):
 entities are not sorted
 """
 return self._cache.iteritems()
 @property
 def items(self):
 """Return item representation for all visible entities in cache
 entities are not sorted
 key: bare jid, value: data
 """
-return {jid_:cache for jid_, cache in self._cache.iteritems()
+return {
-if self.entityVisible(jid_)}
+jid_: cache
+for jid_, cache in self._cache.iteritems()
+if self.entityVisible(jid_)
+}
 def getItem(self, entity):
 """Return item representation of requested entity
 @param entity(jid.JID): bare jid of entity
 if name is None:
 # full cache is requested
 return cache
-if name in ('status', C.PRESENCE_STATUSES, C.PRESENCE_PRIORITY, C.PRESENCE_SHOW):
+if name in ("status", C.PRESENCE_STATUSES, C.PRESENCE_PRIORITY, C.PRESENCE_SHOW):
 # these data are related to the resource
 if not entity.resource:
 main_resource = cache[C.CONTACT_MAIN_RESOURCE]
 if main_resource is None:
 # we ignore presence info if we don't have any resource in cache
 return
 cache = cache[C.CONTACT_RESOURCES].setdefault(main_resource, {})
 else:
 cache = cache[C.CONTACT_RESOURCES].setdefault(entity.resource, {})
-if name == 'status':  # XXX: we get the first status for 'status' key
+if name == "status":  # XXX: we get the first status for 'status' key
 # TODO: manage main language for statuses
-return cache[C.PRESENCE_STATUSES].get(C.PRESENCE_STATUSES_DEFAULT, '')
+return cache[C.PRESENCE_STATUSES].get(C.PRESENCE_STATUSES_DEFAULT, "")
 elif entity.resource:
 try:
 return cache[C.CONTACT_RESOURCES][entity.resource][name]
 except KeyError:
 @param group: a valid (existing) group name
 @param name: name of the data (can't be "jids")
 @param value: value to set
 """
-assert name is not 'jids'
+assert name is not "jids"
 self._groups[group][name] = value
 def getGroupData(self, group, name=None):
 """Return value associated to group data
 @return (iter[jid.JID]): found special entities
 """
 for entity in self._specials:
 if bare and entity.resource:
 continue
-if (special_type is not None
+if (
-and self.getCache(entity, C.CONTACT_SPECIAL) != special_type):
+special_type is not None
+and self.getCache(entity, C.CONTACT_SPECIAL) != special_type
+):
 continue
 yield entity
 def disconnect(self):
 # for now we just clear contacts on disconnect
 was_visible = self.entityVisible(entity_bare)
 if in_roster:
 self._roster.add(entity_bare)
-cache = self._cache.setdefault(entity_bare, {C.CONTACT_RESOURCES: {},
+cache = self._cache.setdefault(
-C.CONTACT_MAIN_RESOURCE: None,
+entity_bare,
-C.CONTACT_SELECTED: set()})
+{
+C.CONTACT_RESOURCES: {},
+C.CONTACT_MAIN_RESOURCE: None,
+C.CONTACT_SELECTED: set(),
+},
+)
 # we don't want forbidden data in attributes
 assert not C.CONTACT_DATA_FORBIDDEN.intersection(attributes)
 # we set groups and fill self._groups accordingly
 if not groups:
 groups = [None]  # [None] is the default group
 if C.CONTACT_GROUPS in cache:
 # XXX: don't use set(cache[C.CONTACT_GROUPS]).difference(groups) because
 #      it won't work in Pyjamas if None is in cache[C.CONTACT_GROUPS]
-for group in [group for group in cache[C.CONTACT_GROUPS]
+for group in [
-if group not in groups]:
+group for group in cache[C.CONTACT_GROUPS] if group not in groups
-self._groups[group]['jids'].remove(entity_bare)
+]:
+self._groups[group]["jids"].remove(entity_bare)
 cache[C.CONTACT_GROUPS] = groups
 for group in groups:
-self._groups.setdefault(group, {}).setdefault('jids', set()).add(
+self._groups.setdefault(group, {}).setdefault("jids", set()).add(
-entity_bare)
+entity_bare
+)
 # special entities management
 if C.CONTACT_SPECIAL in attributes:
 if attributes[C.CONTACT_SPECIAL] is None:
 del attributes[C.CONTACT_SPECIAL]
 self._specials.add(entity)
 cache[C.CONTACT_MAIN_RESOURCE] = None
 # now the attributes we keep in cache
 # XXX: if entity is a full jid, we store the value for the resource only
-cache_attr = (cache[C.CONTACT_RESOURCES].setdefault(entity.resource, {})
+cache_attr = (
-if entity.resource else cache)
+cache[C.CONTACT_RESOURCES].setdefault(entity.resource, {})
+if entity.resource
+else cache
+)
 for attribute, value in attributes.iteritems():
 if value is None:
 # XXX: pyjamas hack: we need to use pop instead of del
 try:
 cache_attr[attribute].pop(value)
 except KeyError:
 pass
 else:
-if attribute == 'nick' and self.isSpecial(entity, C.CONTACT_SPECIAL_GROUP):
+if attribute == "nick" and self.isSpecial(
+entity, C.CONTACT_SPECIAL_GROUP
+):
 # we don't want to keep nick for MUC rooms
 # FIXME: this is here as plugin XEP-0054 can link resource's nick
 #        with bare jid which in the case of MUC
 #        set the nick for the whole MUC
 #        resulting in bad name displayed in some frontends
 if check_resource:
 selected = self._selected
 else:
 selected = {selected.bare for selected in self._selected}
-return ((show is not None and show != C.PRESENCE_UNAVAILABLE)
+return (
-or self.show_disconnected
+(show is not None and show != C.PRESENCE_UNAVAILABLE)
-or entity in selected
+or self.show_disconnected
-or (self.show_entities_with_notifs
+or entity in selected
-and next(self.host.getNotifs(entity.bare, profile=self.profile), None))
+or (
-)
+self.show_entities_with_notifs
+and next(self.host.getNotifs(entity.bare, profile=self.profile), None)
+)
+)
 def anyEntityVisible(self, entities, check_resources=False):
 """Tell if in a list of entities, at least one should be shown
 @param entities (list[jid.JID]): list of jids
 self._roster.remove(entity_bare)
 except KeyError:
 pass
 del self._cache[entity_bare]
 for group in groups:
-self._groups[group]['jids'].remove(entity_bare)
+self._groups[group]["jids"].remove(entity_bare)
-if not self._groups[group]['jids']:
+if not self._groups[group]["jids"]:
 # FIXME: we use pop because of pyjamas:
 #        http://wiki.goffi.org/wiki/Issues_with_Pyjamas/en
 self._groups.pop(group)
 for iterable in (self._selected, self._specials):
 to_remove = set()
 cache[C.CONTACT_MAIN_RESOURCE] = None
 else:
 try:
 del cache[C.CONTACT_RESOURCES][entity.resource]
 except KeyError:
-log.error(u"Presence unavailable received "
+log.error(
-u"for an unknown resource [{}]".format(entity))
+u"Presence unavailable received "
+u"for an unknown resource [{}]".format(entity)
+)
 if not cache[C.CONTACT_RESOURCES]:
 cache[C.CONTACT_MAIN_RESOURCE] = None
 else:
 if not entity.resource:
-log.warning(_(u"received presence from entity "
+log.warning(
-u"without resource: {}".format(entity)))
+_(
+u"received presence from entity "
+u"without resource: {}".format(entity)
+)
+)
 resources_data = cache[C.CONTACT_RESOURCES]
 resource_data = resources_data.setdefault(entity.resource, {})
 resource_data[C.PRESENCE_SHOW] = show
 resource_data[C.PRESENCE_PRIORITY] = int(priority)
 resource_data[C.PRESENCE_STATUSES] = statuses
 if entity.bare not in self._specials:
 # we may have resources with no priority
 # (when a cached value is added for a not connected resource)
-priority_resource = max(resources_data,
+priority_resource = max(
-key=lambda res: resources_data[res].get(
+resources_data,
-C.PRESENCE_PRIORITY, -2**32))
+key=lambda res: resources_data[res].get(
+C.PRESENCE_PRIORITY, -2 ** 32
+),
+)
 cache[C.CONTACT_MAIN_RESOURCE] = priority_resource
 if self.entityVisible(entity.bare):
 update_type = C.UPDATE_MODIFY if was_visible else C.UPDATE_ADD
 self.update([entity], update_type, self.profile)
 elif was_visible:
 @param entity(jid.JID): entity updated
 @param new_nick(unicode): new nick of the entity
 @param profile: %(doc_profile)s
 """
 assert profile == self.profile
-self.setCache(entity, 'nick', new_nick)
+self.setCache(entity, "nick", new_nick)
 def onNotification(self, entity, notif, profile):
 """Update entity with notification
 @param entity(jid.JID): entity updated
 def update(self, entities=None, type_=None, profile=None):
 handler.update(entities, type_, profile)
 class QuickContactListHandler(object):
 def __init__(self, host):
 super(QuickContactListHandler, self).__init__()
 self.host = host
 global handler
 if handler is not None:
-raise exceptions.InternalError(u"QuickContactListHandler must be "
+raise exceptions.InternalError(
-u"instanciated only once")
+u"QuickContactListHandler must be " u"instanciated only once"
+)
 handler = self
-self._clist = {} # key: profile, value: ProfileContactList
+self._clist = {}  # key: profile, value: ProfileContactList
 self._widgets = set()
-self._update_locked = False # se to True to ignore updates
+self._update_locked = False  # se to True to ignore updates
 def __getitem__(self, profile):
 """Return ProfileContactList instance for the requested profile"""
 return self._clist[profile]
 key: bare jid, value: data
 """
 return self.items_sort(self.items)
 def items_sort(self, items):
 """sort items
 @param items(dict): items to sort (will be emptied !)
 @return (OrderedDict): sorted items
 """
 ordered_items = OrderedDict()
 bare_jids = sorted(items.keys())
 for jid_ in bare_jids:
 ordered_items[jid_] = items.pop(jid_)
 return ordered_items
 def register(self, widget):
 """Register a QuickContactList widget
 This method should only be used in QuickContactList
 else:
 to_fill.update(self._clist.items())
 remaining = to_fill.difference(filled)
 if remaining != to_fill:
-log.debug(u"Not re-filling already filled contact list(s) for {}".format(
+log.debug(
-u', '.join(to_fill.intersection(filled))))
+u"Not re-filling already filled contact list(s) for {}".format(
+u", ".join(to_fill.intersection(filled))
+)
+)
 for profile in remaining:
 self._clist[profile]._fill()
 def clearContacts(self, keep_cache=False):
 """Clear all the contact list
 @param locked(bool): updates are forbidden if True
 @param do_update(bool): if True, a full update is done after unlocking
 if set to False, widget state can be inconsistent, be sure to know
 what youa re doing!
 """
-log.debug(u"Contact lists updates are now {}".format(
+log.debug(
-u"LOCKED" if locked else u"UNLOCKED"))
+u"Contact lists updates are now {}".format(
+u"LOCKED" if locked else u"UNLOCKED"
+)
+)
 self._update_locked = locked
 if not locked and do_update:
 self.update()
 def update(self, entities=None, type_=None, profile=None):
 widget.update(entities, type_, profile)
 class QuickContactList(QuickWidget):
 """This class manage the visual representation of contacts"""
-SINGLE=False
-PROFILES_MULTIPLE=True
+SINGLE = False
+PROFILES_MULTIPLE = True
 # Can be linked to no profile (e.g. at the early frontend start)
-PROFILES_ALLOW_NONE=True
+PROFILES_ALLOW_NONE = True
 def __init__(self, host, profiles):
 super(QuickContactList, self).__init__(host, None, profiles)
 # options
 # for next values, None means use indivual value per profile
 # True or False mean override these values for all profiles
-self.show_disconnected = None # TODO
+self.show_disconnected = None  # TODO
-self.show_empty_groups = None # TODO
+self.show_empty_groups = None  # TODO
-self.show_resources = None # TODO
+self.show_resources = None  # TODO
-self.show_status = None # TODO
+self.show_status = None  # TODO
 def postInit(self):
 """Method to be called by frontend after widget is initialised"""
 handler.register(self)

Mercurial > libervia-backend

comparison sat_frontends/quick_frontend/quick_contact_list.py @ 2624:56f94936df1e