libervia-backend: libervia/backend/core/xmpp.py comparison

comparison libervia/backend/core/xmpp.py @ 4270:0d7bb4df2343

Reformatted code base using black.

author	Goffi <goffi@goffi.org>
date	Wed, 19 Jun 2024 18:44:57 +0200
parents	2417ad1d0f23
children	0f953ce5f0a8

comparison

equal deleted inserted replaced

-:64a85ce8be70
+:0d7bb4df2343
 return partial(getattr(self.plugin, attr), self.client)
 class SatXMPPEntity(core_types.SatXMPPEntity):
 """Common code for Client and Component"""
 # profile is added there when start_connection begins and removed when it is finished
 profiles_connecting = set()
 def __init__(self, host_app, profile, max_retries):
 factory = self.factory
 # we monkey patch clientConnectionLost to handle network_enabled/network_disabled
 # and to allow plugins to tune reconnection mechanism
 clientConnectionFailed_ori = factory.clientConnectionFailed
 clientConnectionLost_ori = factory.clientConnectionLost
 factory.clientConnectionFailed = partial(
-self.connection_terminated, term_type="failed", cb=clientConnectionFailed_ori)
+self.connection_terminated, term_type="failed", cb=clientConnectionFailed_ori
+)
 factory.clientConnectionLost = partial(
-self.connection_terminated, term_type="lost", cb=clientConnectionLost_ori)
+self.connection_terminated, term_type="lost", cb=clientConnectionLost_ori
+)
 factory.maxRetries = max_retries
 factory.maxDelay = 30
 # when self._connected_d is None, we are not connected
 # else, it's a deferred which fire on disconnection
 self._connected_d = None
 self.profile = profile
 self.host_app = host_app
 self.cache = cache.Cache(host_app, profile)
 self.mess_id2uid = {}  # map from message id to uid used in history.
 # Key: (full_jid, message_id) Value: uid
 # this Deferred fire when entity is connected
 self.conn_deferred = defer.Deferred()
 self._progress_cb = {}  # callback called when a progress is requested
 # (key = progress id)
 self.actions = {}  # used to keep track of actions for retrieval (key = action_id)
 self.encryption = encryption.EncryptionHandler(self)
 def __str__(self):
 return f"Client for profile {self.profile}"
 if plugin.is_handler:
 plugin.get_handler(self).setHandlerParent(self)
 # profile_connecting/profile_connected methods handling
-timer = connection_timer[plugin] = {
+timer = connection_timer[plugin] = {"total": 0}
-"total": 0
-}
 # profile connecting is called right now (before actually starting client)
 connecting_cb = getattr(plugin, "profile_connecting", None)
 if connecting_cb is not None:
 connecting_start = time.time()
 await utils.as_deferred(connecting_cb, self)
 """
 return
 @staticmethod
 async def _run_profile_connected(
-callback: Callable,
+callback: Callable, entity: "SatXMPPEntity", timer: Dict[str, float]
-entity: "SatXMPPEntity",
-timer: Dict[str, float]
 ) -> None:
 connected_start = time.time()
 await utils.as_deferred(callback, entity)
 timer["connected"] = time.time() - connected_start
 timer["total"] += timer["connected"]
 C.FORCE_PORT_PARAM, "Connection", profile_key=profile
 )
 )
 except ValueError:
 log.debug(_("Can't parse port value, using default value"))
-port = (
+port = None  # will use default value 5222 or be retrieved from a DNS SRV record
-None
-)  # will use default value 5222 or be retrieved from a DNS SRV record
 password = await host.memory.param_get_a_async(
 "Password", "Connection", profile_key=profile
 )
 entity_jid_s = await host.memory.param_get_a_async(
-"JabberID", "Connection", profile_key=profile)
+"JabberID", "Connection", profile_key=profile
+)
 entity_jid = jid.JID(entity_jid_s)
 if not entity_jid.resource and not cls.is_component and entity_jid.user:
 # if no resource is specified, we create our own instead of using
 # server returned one, as it will then stay stable in case of
 # reconnection. we only do that for client and if there is a user part, to
 # let server decide for anonymous login
 resource_dict = await host.memory.storage.get_privates(
-"core:xmpp", ["resource"] , profile=profile)
+"core:xmpp", ["resource"], profile=profile
+)
 try:
 resource = resource_dict["resource"]
 except KeyError:
 resource = f"{C.APP_NAME_FILE}.{shortuuid.uuid()}"
 await host.memory.storage.set_private_value(
-"core:xmpp", "resource", resource, profile=profile)
+"core:xmpp", "resource", resource, profile=profile
+)
-log.info(_("We'll use the stable resource {resource}").format(
-resource=resource))
+log.info(
+_("We'll use the stable resource {resource}").format(
+resource=resource
+)
+)
 entity_jid.resource = resource
 if profile in host.profiles:
 if host.profiles[profile].is_connected():
 raise exceptions.InternalError(
 f"There is already a connected profile of name {profile!r} in "
-f"host")
+f"host"
-log.debug(
+)
-"removing unconnected profile {profile!r}")
+log.debug("removing unconnected profile {profile!r}")
 del host.profiles[profile]
 entity = host.profiles[profile] = cls(
-host, profile, entity_jid, password,
+host,
-host.memory.param_get_a(C.FORCE_SERVER_PARAM, "Connection",
+profile,
-profile_key=profile) or None,
+entity_jid,
-port, max_retries,
+password,
-)
+host.memory.param_get_a(
+C.FORCE_SERVER_PARAM, "Connection", profile_key=profile
+)
+or None,
+port,
+max_retries,
+)
 await entity.encryption.load_sessions()
 entity._create_sub_protocols()
 log.debug(f"Plugin loading time for {profile!r} (longer to shorter):\n")
 plugins_by_timer = sorted(
 connection_timer,
 key=lambda p: connection_timer[p]["total"],
-reverse=True
+reverse=True,
 )
 # total is the addition of all connecting and connected, doesn't really
 # reflect the real loading time as connected are launched in a
 # DeferredList
 total_plugins = 0
 anymore
 """
 # we save connector because it may be deleted when connection will be dropped
 # if reconnection is disabled
 self._saved_connector = connector
-if reason is not None and not isinstance(reason.value,
+if reason is not None and not isinstance(
-internet_error.ConnectionDone):
+reason.value, internet_error.ConnectionDone
+):
 try:
 reason_str = str(reason.value)
 except Exception:
 # FIXME: workaround for Android were p4a strips docstrings
 #        while Twisted use docstring in __str__
 connector.connect()
 def _connected(self, xs):
 send_hooks = []
 receive_hooks = []
-self.host_app.trigger.point(
+self.host_app.trigger.point("stream_hooks", self, receive_hooks, send_hooks)
-"stream_hooks", self, receive_hooks, send_hooks)
 for hook in receive_hooks:
 xs.add_hook(C.STREAM_HOOK_RECEIVE, hook)
 for hook in send_hooks:
 xs.add_hook(C.STREAM_HOOK_SEND, hook)
 super(SatXMPPEntity, self)._connected(xs)
 else:
 err = reason
 try:
 if err.value.args[0][0][2] == "certificate verify failed":
 err = exceptions.InvalidCertificate(
-_("Your server certificate is not valid "
+_(
-"(its identity can't be checked).\n\n"
+"Your server certificate is not valid "
-"This should never happen and may indicate that "
+"(its identity can't be checked).\n\n"
-"somebody is trying to spy on you.\n"
+"This should never happen and may indicate that "
-"Please contact your server administrator."))
+"somebody is trying to spy on you.\n"
+"Please contact your server administrator."
+)
+)
 self.factory.stopTrying()
 try:
 # with invalid certificate, we should not retry to connect
 # so we delete saved connector to avoid reconnection if
 # network_enabled is called.
 self.xmlstream.send(iq_error_elt)
 def generate_message_xml(
 self,
 data: core_types.MessageData,
-post_xml_treatments: Optional[defer.Deferred] = None
+post_xml_treatments: Optional[defer.Deferred] = None,
 ) -> core_types.MessageData:
 """Generate <message/> stanza from message data
 @param data: message data
 domish element will be put in data['xml']
 # XXX: This is the last trigger before u"send" (last but one globally)
 #      for sending message.
 #      This is intented for e2e encryption which doesn't do full stanza
 #      encryption (e.g. OTR)
 #      This trigger point can't cancel the method
-await self.host_app.trigger.async_point("send_message_data", self, mess_data,
+await self.host_app.trigger.async_point(
-triggers_no_cancel=True)
+"send_message_data", self, mess_data, triggers_no_cancel=True
+)
 await self.a_send(mess_data["xml"])
 return mess_data
 def sendMessage(
-self, to_jid, message, subject=None, mess_type="auto", extra=None, uid=None,
+self,
-no_trigger=False):
+to_jid,
+message,
+subject=None,
+mess_type="auto",
+extra=None,
+uid=None,
+no_trigger=False,
+):
 r"""Send a message to an entity
 @param to_jid(jid.JID): destinee of the message
 @param message(dict): message body, key is the language (use '' when unknown)
 @param subject(dict): message subject, key is the language (use '' when unknown)
 pre_xml_treatments,
 post_xml_treatments,
 ):
 return defer.succeed(None)
-log.debug(_("Sending message (type {type}, to {to})")
+log.debug(
-.format(type=data["type"], to=to_jid.full()))
+_("Sending message (type {type}, to {to})").format(
+type=data["type"], to=to_jid.full()
-pre_xml_treatments.addCallback(lambda __: self.generate_message_xml(data, post_xml_treatments))
+)
+)
+pre_xml_treatments.addCallback(
+lambda __: self.generate_message_xml(data, post_xml_treatments)
+)
 pre_xml_treatments.addCallback(lambda __: post_xml_treatments)
 pre_xml_treatments.addErrback(self._cancel_error_trap)
 post_xml_treatments.addCallback(
 lambda __: defer.ensureDeferred(self.send_message_data(data))
 )
 if send_only:
-log.debug(_("Triggers, storage and echo have been inhibited by the "
+log.debug(
-"'send_only' parameter"))
+_(
+"Triggers, storage and echo have been inhibited by the "
+"'send_only' parameter"
+)
+)
 else:
 self.add_post_xml_callbacks(post_xml_treatments)
 post_xml_treatments.addErrback(self._cancel_error_trap)
 post_xml_treatments.addErrback(self.host_app.log_errback)
 pre_xml_treatments.callback(data)
 failure.trap(exceptions.CancelError)
 def is_message_printable(self, mess_data):
 """Return True if a message contain payload to show in frontends"""
 return (
-mess_data["message"] or mess_data["subject"]
+mess_data["message"]
+or mess_data["subject"]
 or mess_data["extra"].get(C.KEY_ATTACHMENTS)
 or mess_data["type"] == C.MESS_TYPE_INFO
 )
 async def message_add_to_history(self, data):
 )  # empty body should be managed by plugins before this point
 return data
 def message_get_bridge_args(self, data):
 """Generate args to use with bridge from data dict"""
-return (data["uid"], data["timestamp"], data["from"].full(),
+return (
-data["to"].full(), data["message"], data["subject"],
+data["uid"],
-data["type"], data_format.serialise(data["extra"]))
+data["timestamp"],
+data["from"].full(),
+data["to"].full(),
+data["message"],
+data["subject"],
+data["type"],
+data_format.serialise(data["extra"]),
+)
 def message_send_to_bridge(self, data):
 """Send message to bridge, so frontends can display it
 @param data: message data dictionnary
 # we need a message to send something
 if self.is_message_printable(data):
 # We send back the message, so all frontends are aware of it
 self.host_app.bridge.message_new(
-*self.message_get_bridge_args(data),
+*self.message_get_bridge_args(data), profile=self.profile
-profile=self.profile
 )
 else:
 log.warning(_("No message found"))
 return data
 @implementer(iwokkel.IDisco)
 class SatXMPPClient(SatXMPPEntity, wokkel_client.XMPPClient):
 trigger_suffix = ""
 is_component = False
-def __init__(self, host_app, profile, user_jid, password, host=None,
+def __init__(
-port=C.XMPP_C2S_PORT, max_retries=C.XMPP_MAX_RETRIES):
+self,
+host_app,
+profile,
+user_jid,
+password,
+host=None,
+port=C.XMPP_C2S_PORT,
+max_retries=C.XMPP_MAX_RETRIES,
+):
 # XXX: DNS SRV records are checked when the host is not specified.
 # If no SRV record is found, the host is directly extracted from the JID.
 self.started = time.time()
 # Currently, we use "client/pc/Salut à Toi", but as
 _("invalid data used for host: {data}").format(data=host_data)
 )
 host_data = None
 if host_data is not None:
 log.info(
-"using {host}:{port} for host {host_ori} as requested in config"
+"using {host}:{port} for host {host_ori} as requested in config".format(
-.format(host_ori=user_jid.host, host=host, port=port)
+host_ori=user_jid.host, host=host, port=port
+)
 )
 self.check_certificate = host_app.memory.param_get_a(
-"check_certificate", "Connection", profile_key=profile)
+"check_certificate", "Connection", profile_key=profile
+)
 if self.check_certificate:
 tls_required, configurationForTLS = True, None
 else:
 tls_required = False
 configurationForTLS = ssl.CertificateOptions(trustRoot=None)
 wokkel_client.XMPPClient.__init__(
-self, user_jid, password, host or None, port or C.XMPP_C2S_PORT,
+self,
-tls_required=tls_required, configurationForTLS=configurationForTLS
+user_jid,
+password,
+host or None,
+port or C.XMPP_C2S_PORT,
+tls_required=tls_required,
+configurationForTLS=configurationForTLS,
 )
 SatXMPPEntity.__init__(self, host_app, profile, max_retries)
 if not self.check_certificate:
-msg = (_("Certificate validation is deactivated, this is unsecure and "
+msg = _(
+"Certificate validation is deactivated, this is unsecure and "
 "somebody may be spying on you. If you have no good reason to disable "
-"certificate validation, please activate \"Check certificate\" in your "
+'certificate validation, please activate "Check certificate" in your '
-"settings in \"Connection\" tab."))
+'settings in "Connection" tab.'
-xml_tools.quick_note(host_app, self, msg, _("Security notice"),
+)
-level = C.XMLUI_DATA_LVL_WARNING)
+xml_tools.quick_note(
+host_app, self, msg, _("Security notice"), level=C.XMLUI_DATA_LVL_WARNING
+)
 @property
 def server_jid(self):
 return jid.JID(self.jid.host)
 lambda ret: defer.ensureDeferred(self.message_add_to_history(ret))
 )
 post_xml_treatments.addCallback(self.message_send_to_bridge)
 def feedback(
-self,
+self, to_jid: jid.JID, message: str, extra: Optional[ExtraDict] = None
-to_jid: jid.JID,
-message: str,
-extra: Optional[ExtraDict] = None
 ) -> None:
 """Send message to frontends
 This message will be an info message, not recorded in history.
 It can be used to give feedback of a command
 An entry point plugin is launched after component is connected.
 Component need to instantiate MessageProtocol itself
 """
 trigger_suffix = (
-"Component"
+"Component"  # used for to distinguish some trigger points set in SatXMPPEntity
-)  # used for to distinguish some trigger points set in SatXMPPEntity
+)
 is_component = True
 # XXX: set to True from entry plugin to keep messages in history for sent messages
 sendHistory = False
 # XXX: same as sendHistory but for received messaged
 receiveHistory = False
-def __init__(self, host_app, profile, component_jid, password, host=None, port=None,
+def __init__(
-max_retries=C.XMPP_MAX_RETRIES):
+self,
+host_app,
+profile,
+component_jid,
+password,
+host=None,
+port=None,
+max_retries=C.XMPP_MAX_RETRIES,
+):
 self.started = time.time()
 if port is None:
 port = C.XMPP_COMPONENT_PORT
 ## entry point ##
 plugin to your dependencies.
 A "user" part must be present in "to_jid" (otherwise, the component itself is addressed)
 @param to_jid: destination JID of the request
 """
 try:
-unescape = self.host_app.plugins['XEP-0106'].unescape
+unescape = self.host_app.plugins["XEP-0106"].unescape
 except KeyError:
 raise exceptions.MissingPlugin("Plugin XEP-0106 is needed to retrieve owner")
 else:
 user = unescape(to_jid.user)
-if '@' in user:
+if "@" in user:
 # a full jid is specified
 return jid.JID(user)
 else:
 # only user part is specified, we use our own host to build the full jid
 return jid.JID(None, (user, self.host, None))
 with our host.
 Peer jid is the requesting jid from the IQ element
 @param iq_elt: IQ stanza sent from the requested
 @return: owner and peer JIDs
 """
-to_jid = jid.JID(iq_elt['to'])
+to_jid = jid.JID(iq_elt["to"])
 if to_jid.user:
 owner = self.get_owner_from_jid(to_jid)
 else:
 owner = jid.JID(iq_elt["from"]).userhostJID()
 class SatMessageProtocol(xmppim.MessageProtocol):
 def __init__(self, host):
 xmppim.MessageProtocol.__init__(self)
 self.host = host
-self.messages_queue  = defer.DeferredQueue()
+self.messages_queue = defer.DeferredQueue()
 def setHandlerParent(self, parent):
 super().setHandlerParent(parent)
 defer.ensureDeferred(self.process_messages())
 @param client(SatXMPPClient, None): client to map message id to uid
 if None, mapping will not be done
 @return(dict): message data
 """
 if message_elt.name != "message":
-log.warning(_(
+log.warning(
-"parse_message used with a non <message/> stanza, ignoring: {xml}"
+_(
-.format(xml=message_elt.toXml())))
+"parse_message used with a non <message/> stanza, ignoring: {xml}".format(
+xml=message_elt.toXml()
+)
+)
+)
 return {}
 if message_elt.uri == None:
 # xmlns may be None when wokkel element parsing strip out root namespace
 self.normalize_ns(message_elt, None)
 elif message_elt.uri != C.NS_CLIENT:
-log.warning(_(
+log.warning(
-"received <message> with a wrong namespace: {xml}"
+_(
-.format(xml=message_elt.toXml())))
+"received <message> with a wrong namespace: {xml}".format(
+xml=message_elt.toXml()
+)
+)
+)
 client = self.parent
-if not message_elt.hasAttribute('to'):
+if not message_elt.hasAttribute("to"):
-message_elt['to'] = client.jid.full()
+message_elt["to"] = client.jid.full()
 message = {}
 subject = {}
 extra = {}
 data: MessageData = {
 try:
 received_timestamp = message_elt._received_timestamp
 except AttributeError:
 # message_elt._received_timestamp should have been set in onMessage
 # but if parse_message is called directly, it can be missing
-log.debug("missing received timestamp for {message_elt}".format(
+log.debug(
-message_elt=message_elt))
+"missing received timestamp for {message_elt}".format(
+message_elt=message_elt
+)
+)
 received_timestamp = time.time()
 try:
 delay_elt = next(message_elt.elements(delay.NS_DELAY, "delay"))
 except StopIteration:
 data["timestamp"] = calendar.timegm(parsed_delay.stamp.utctimetuple())
 data["received_timestamp"] = received_timestamp
 if parsed_delay.sender:
 data["delay_sender"] = parsed_delay.sender.full()
-self.host.trigger.point("message_parse", client,  message_elt, data)
+self.host.trigger.point("message_parse", client, message_elt, data)
 return data
 def onMessage(self, message_elt: domish.Element) -> None:
 message_elt._received_timestamp = time.time()
 self.messages_queue.put(message_elt)
 await self.process_message(client, message_elt)
 except Exception:
 log.exception(f"Can't process message {message_elt.toXml()}")
 def _on_processing_timeout(
-self,
+self, message_elt: domish.Element, async_point_d: defer.Deferred
-message_elt: domish.Element,
-async_point_d: defer.Deferred
 ) -> None:
 log.error(
 "Processing of following message took too long, cancelling:"
 f"{message_elt.toXml()}"
 )
 async_point_d.cancel()
 async def process_message(
-self,
+self, client: SatXMPPEntity, message_elt: domish.Element
-client: SatXMPPEntity,
-message_elt: domish.Element
 ) -> None:
 # TODO: handle threads
 if not "from" in message_elt.attributes:
 message_elt["from"] = client.jid.host
 log.debug(_("got message from: {from_}").format(from_=message_elt["from"]))
 # we use client namespace all the time to simplify parsing
 self.normalize_ns(message_elt, component.NS_COMPONENT_ACCEPT)
 # plugin can add their treatments to this deferred
 post_treat = defer.Deferred()
-async_point_d = defer.ensureDeferred(self.host.trigger.async_point(
+async_point_d = defer.ensureDeferred(
-"message_received", client, message_elt, post_treat
+self.host.trigger.async_point(
-))
+"message_received", client, message_elt, post_treat
+)
+)
 # message_received triggers block the messages queue, so they must not take too
 # long to proceed.
 delayed_call = reactor.callLater(
-10,
+10, self._on_processing_timeout, message_elt, async_point_d
-self._on_processing_timeout,
-message_elt,
-async_point_d
 )
 trigger_ret_continue = await async_point_d
 if delayed_call.active():
 delayed_call.cancel()
 except exceptions.CancelError:
 pass
 def complete_attachments(self, data: MessageData) -> MessageData:
 """Complete missing metadata of attachments"""
-for attachment in data['extra'].get(C.KEY_ATTACHMENTS, []):
+for attachment in data["extra"].get(C.KEY_ATTACHMENTS, []):
 if "name" not in attachment and "url" in attachment:
-name = (Path(unquote(urlparse(attachment['url']).path)).name
+name = (
-or C.FILE_DEFAULT_NAME)
+Path(unquote(urlparse(attachment["url"]).path)).name
+or C.FILE_DEFAULT_NAME
+)
 attachment["name"] = name
-if ((C.KEY_ATTACHMENTS_MEDIA_TYPE not in attachment
+if C.KEY_ATTACHMENTS_MEDIA_TYPE not in attachment and "name" in attachment:
-and "name" in attachment)):
+media_type = mimetypes.guess_type(attachment["name"], strict=False)[0]
-media_type = mimetypes.guess_type(attachment['name'], strict=False)[0]
 if media_type:
 attachment[C.KEY_ATTACHMENTS_MEDIA_TYPE] = media_type
 return data
 async def add_to_history(self, data: MessageData) -> MessageData:
 else:
 # we need a message to store
 if self.parent.is_message_printable(data):
 return await self.host.memory.add_to_history(self.parent, data)
 else:
-log.debug("not storing empty message to history: {data}"
+log.debug(
-.format(data=data))
+"not storing empty message to history: {data}".format(data=data)
+)
 return data
 def bridge_signal(self, data: MessageData) -> MessageData:
 """Send signal to frontends for the given message"""
 try:
 data["type"],
 data_format.serialise(data["extra"]),
 profile=self.parent.profile,
 )
 else:
-log.debug("Discarding bridge signal for empty message: {data}".format(
+log.debug(
-data=data))
+"Discarding bridge signal for empty message: {data}".format(data=data)
+)
 return data
 class LiberviaRosterProtocol(xmppim.RosterClientProtocol):
 return self.is_jid_in_roster(entity_jid)
 @property
 def versioning(self):
 """True if server support roster versioning"""
-return (NS_ROSTER_VER, 'ver') in self.parent.xmlstream.features
+return (NS_ROSTER_VER, "ver") in self.parent.xmlstream.features
 @property
 def roster_cache(self):
 """Cache of roster from storage
 self._groups.clear()
 yield self.request_roster()
 @defer.inlineCallbacks
 def request_roster(self):
-"""Ask the server for Roster list """
+"""Ask the server for Roster list"""
 if self.versioning:
 log.info(_("our server support roster versioning, we use it"))
 roster_cache = self.roster_cache
 yield roster_cache.load()
 try:
 # we deserialise cached roster to our local cache
 for roster_jid_s, roster_item_elt_s in roster_cache.items():
 if roster_jid_s == ROSTER_VER_KEY:
 continue
 roster_jid = jid.JID(roster_jid_s)
-roster_item_elt = generic.parseXml(roster_item_elt_s.encode('utf-8'))
+roster_item_elt = generic.parseXml(roster_item_elt_s.encode("utf-8"))
 roster_item = xmppim.RosterItem.fromElement(roster_item_elt)
 self._jids[roster_jid] = roster_item
 self._register_item(roster_item)
 else:
 log.warning(_("our server doesn't support roster versioning"))
 version = None
 log.debug("requesting roster")
 roster = yield self.getRoster(version=version)
 if roster is None:
-log.debug("empty roster result received, we'll get roster item with roster "
+log.debug(
-"pushes")
+"empty roster result received, we'll get roster item with roster "
+"pushes"
+)
 else:
 # a full roster is received
 self._groups.clear()
 self._jids = roster
 for item in roster.values():
 # XXX: current behaviour: we don't want contact in our roster list
 # if there is no presence subscription
 # may change in the future
 log.info(
 "Removing contact {} from roster because there is no presence "
-"subscription".format(
+"subscription".format(item.jid)
-item.jid
-)
 )
 self.removeItem(item.entity)  # FIXME: to be checked
 else:
 self._register_item(item)
 yield self._cache_roster(roster.version)
 except KeyError:
 pass  # no previous item registration (or it's been cleared)
 self._jids[entity] = item
 self._register_item(item)
 self.host.bridge.contact_new(
-entity.full(), self.get_attributes(item), list(item.groups),
+entity.full(),
-self.parent.profile
+self.get_attributes(item),
+list(item.groups),
+self.parent.profile,
 )
 def removeReceived(self, request):
 entity = request.item.entity
 log.info(_("removing {entity} from roster").format(entity=entity.full()))
 def is_jid_in_roster(self, entity_jid):
 """Return True if jid is in roster"""
 if not isinstance(entity_jid, jid.JID):
 raise exceptions.InternalError(
-f"a JID is expected, not {type(entity_jid)}: {entity_jid!r}")
+f"a JID is expected, not {type(entity_jid)}: {entity_jid!r}"
+)
 return entity_jid in self._jids
 def is_subscribed_from(self, entity_jid: jid.JID) -> bool:
 """Return True if entity is authorised to see our presence"""
 try:
 if None in statuses:  # we only want string keys
 statuses[C.PRESENCE_STATUSES_DEFAULT] = statuses.pop(None)
 if not self.host.trigger.point(
-"presence_received", self.parent, entity, C.PRESENCE_UNAVAILABLE, 0, statuses,
+"presence_received",
+self.parent,
+entity,
+C.PRESENCE_UNAVAILABLE,
+0,
+statuses,
 ):
 return
 # now it's time to notify frontends
 # if the entity is not known yet in this session or is already unavailable,
 # there is no need to send an unavailable signal
 try:
-presence = self.host.memory.get_entity_datum(
+presence = self.host.memory.get_entity_datum(self.client, entity, "presence")
-self.client, entity, "presence"
-)
 except (KeyError, exceptions.UnknownEntityError):
 # the entity has not been seen yet in this session
 pass
 else:
 if presence.show != C.PRESENCE_UNAVAILABLE:
 disco.DiscoClientProtocol.__init__(self)
 def getDiscoInfo(self, requestor, target, nodeIdentifier=""):
 # those features are implemented in Wokkel (or sat_tmp.wokkel)
 # and thus are always available
-return [disco.DiscoFeature(NS_X_DATA),
+return [
-disco.DiscoFeature(NS_XML_ELEMENT),
+disco.DiscoFeature(NS_X_DATA),
-disco.DiscoFeature(NS_DISCO_INFO)]
+disco.DiscoFeature(NS_XML_ELEMENT),
+disco.DiscoFeature(NS_DISCO_INFO),
+]
 def getDiscoItems(self, requestor, target, nodeIdentifier=""):
 return []
 @implementer(iwokkel.IDisco)
 class SatIdentityHandler(XMPPHandler):
 """Manage disco Identity of SàT."""
 # TODO: dynamic identity update (see docstring). Note that a XMPP entity can have
 #       several identities
 def getDiscoInfo(self, requestor, target, nodeIdentifier=""):
 return self.parent.identities

Mercurial > libervia-backend

comparison libervia/backend/core/xmpp.py @ 4270:0d7bb4df2343