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

comparison sat/core/xmpp.py @ 2643:189e38fb11ff

core: style improvments (90 chars limit)

author	Goffi <goffi@goffi.org>
date	Sun, 29 Jul 2018 18:44:27 +0200
parents	56f94936df1e
children	f2cf1daa42cb

comparison

equal deleted inserted replaced

-:755a0b8643bd
+:189e38fb11ff
 # else, it's a deferred which fire on disconnection
 self._connected = None
 self.profile = profile
 self.host_app = host_app
 self.cache = cache.Cache(host_app, profile)
-self._mess_id_uid = {}  # map from message id to uid used in history. Key: (full_jid,message_id) Value: uid
+self._mess_id_uid = {}  # map from message id to uid used in history.
+# Key: (full_jid,message_id) Value: uid
 self.conn_deferred = defer.Deferred()
-self._progress_cb = {}  # callback called when a progress is requested (key = progress id)
+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)
 ## initialisation ##
 @defer.inlineCallbacks
 @classmethod
 @defer.inlineCallbacks
 def startConnection(cls, host, profile, max_retries):
 """instantiate the entity and start the connection"""
-# FIXME: reconnection doesn't seems to be handled correclty (client is deleted then recreated from scrash
+# FIXME: reconnection doesn't seems to be handled correclty
-#        most of methods called here should be called once on first connection (e.g. adding subprotocols)
+#        (client is deleted then recreated from scratch)
-#        but client should not be deleted except if session is finished (independently of connection/deconnection
+#        most of methods called here should be called once on first connection
-#
+#        (e.g. adding subprotocols)
+#        but client should not be deleted except if session is finished
+#        (independently of connection/deconnection)
 try:
 port = int(
 host.memory.getParamA(
 C.FORCE_PORT_PARAM, "Connection", profile_key=profile
 )
 yield entity.getConnectionDeferred()
 yield defer.maybeDeferred(entity.entityConnected)
-# Call profileConnected callback for all plugins, and print error message if any of them fails
+# Call profileConnected callback for all plugins,
+# and print error message if any of them fails
 conn_cb_list = []
-for dummy, callback in plugin_conn_cb:
+for __, callback in plugin_conn_cb:
 conn_cb_list.append(defer.maybeDeferred(callback, entity))
 list_d = defer.DeferredList(conn_cb_list)
 def logPluginResults(results):
 all_succeed = all([success for success, result in results])
 def getConnectionDeferred(self):
 """Return a deferred which fire when the client is connected"""
 return self.conn_deferred
-def _disconnectionCb(self, dummy):
+def _disconnectionCb(self, __):
 self._connected = None
 def _disconnectionEb(self, failure_):
 log.error(_(u"Error while disconnecting: {}".format(failure_)))
 self.streamInitialized()
 self.host_app.bridge.connected(
 self.profile, unicode(self.jid)
 )  # we send the signal to the clients
-def _finish_connection(self, dummy):
+def _finish_connection(self, __):
 self.conn_deferred.callback(None)
 def streamInitialized(self):
 """Called after _authd"""
 log.debug(_(u"XML stream is initialized"))
 self.conn_deferred.errback(
 error.StreamError(u"Server unexpectedly closed the connection")
 )
 @defer.inlineCallbacks
-def _cleanConnection(self, dummy):
+def _cleanConnection(self, __):
 """method called on disconnection
 used to call profileDisconnected* triggers
 """
 trigger_name = "profileDisconnected"
 @param post_xml_treatments(D): the same Deferred as in sendMessage trigger
 """
 raise NotImplementedError
-def sendMessage(
+def sendMessage(self, to_jid, message, subject=None, mess_type="auto", extra=None,
-self,
+uid=None, no_trigger=False,):
-to_jid,
+r"""Send a message to an entity
-message,
-subject=None,
-mess_type="auto",
-extra=None,
-uid=None,
-no_trigger=False,
-):
-"""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)
 @param mess_type(str): one of standard message type (cf RFC 6121 §5.2.2) or:
 pre_xml_treatments,
 post_xml_treatments,
 ):
 return defer.succeed(None)
-log.debug(
+log.debug(_(u"Sending message (type {type}, to {to})")
-_(u"Sending message (type {type}, to {to})").format(
+.format(type=data["type"], to=to_jid.full()))
-type=data["type"], to=to_jid.full()
-)
+pre_xml_treatments.addCallback(lambda __: self.generateMessageXML(data))
-)
-pre_xml_treatments.addCallback(lambda dummy: self.generateMessageXML(data))
 pre_xml_treatments.chainDeferred(post_xml_treatments)
 post_xml_treatments.addCallback(self.sendMessageData)
 if send_only:
-log.debug(
+log.debug(_(u"Triggers, storage and echo have been inhibited by the "
-_(
+u"'send_only' parameter"))
-"Triggers, storage and echo have been inhibited by the 'send_only' parameter"
-)
-)
 else:
 self.addPostXmlCallbacks(post_xml_treatments)
 post_xml_treatments.addErrback(self._cancelErrorTrap)
 post_xml_treatments.addErrback(self.host_app.logErrback)
 pre_xml_treatments.callback(data)
 # 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
-# SàT is multi-frontends and can be used on mobile devices, as a bot, with a web frontend,
+# SàT is multi-frontends and can be used on mobile devices, as a bot,
-# etc., we should implement a way to dynamically update identities through the bridge
+# with a web frontend,
+# etc., we should implement a way to dynamically update identities through the
+# bridge
 self.identities = [disco.DiscoIdentity(u"client", u"pc", C.APP_NAME)]
 if sys.platform == "android":
 # FIXME: temporary hack as SRV is not working on android
 # TODO: remove this hack and fix SRV
 log.info(u"FIXME: Android hack, ignoring SRV")
 _(u"invalid data used for host: {data}").format(data=host_data)
 )
 host_data = None
 if host_data is not None:
 log.info(
-u"using {host}:{port} for host {host_ori} as requested in config".format(
+u"using {host}:{port} for host {host_ori} as requested in config"
-host_ori=user_jid.host, host=host, port=port
+.format(host_ori=user_jid.host, host=host, port=port)
-)
 )
 wokkel_client.XMPPClient.__init__(
 self, user_jid, password, host or None, port or C.XMPP_C2S_PORT
 )
 #      it is intended for things like end 2 end encryption.
 #      *DO NOT* cancel (i.e. return False) without very good reason
 #      (out of band transmission for instance).
 #      e2e should have a priority of 0 here, and out of band transmission
 #      a lower priority
-#  FIXME: trigger not used yet, can be uncommented when e2e full stanza encryption is implemented
+#  FIXME: trigger not used yet, can be uncommented when e2e full stanza
+#         encryption is implemented
 #  if not self.host_app.trigger.point("send", self, obj):
 #      return
 super(SatXMPPClient, self).send(obj)
 def sendMessageData(self, mess_data):
 The trigger can't be cancelled, it's a good place for e2e encryption which
 don't handle full stanza encryption
 @param mess_data(dict): message data as constructed by onMessage workflow
 @return (dict): mess_data (so it can be used in a deferred chain)
 """
-# XXX: This is the last trigger before u"send" (last but one globally) for sending message.
+# XXX: This is the last trigger before u"send" (last but one globally)
-#      This is intented for e2e encryption which doesn't do full stanza encryption (e.g. OTR)
+#      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
 self.host_app.trigger.point("sendMessageData", self, mess_data)
 self.send(mess_data[u"xml"])
 return mess_data
 mess_type=C.MESS_TYPE_INFO,
 extra={},
 profile=self.profile,
 )
-def _finish_connection(self, dummy):
+def _finish_connection(self, __):
 self.roster.requestRoster()
 self.presence.available()
-super(SatXMPPClient, self)._finish_connection(dummy)
+super(SatXMPPClient, self)._finish_connection(__)
 class SatXMPPComponent(SatXMPPEntity, component.Component):
 """XMPP component
 "Component"
 )  # used for to distinguish some trigger points set in SatXMPPEntity
 is_component = True
 sendHistory = (
 False
-)  # XXX: set to True from entry plugin to keep messages in history for received messages
+)  # XXX: set to True from entry plugin to keep messages in history for received
+#      messages
 def __init__(
 self,
 host_app,
 profile,
 @param plugins(list): list of validated plugins, will be filled by the method
 give an empty list for first call
 @param required(bool): True if plugin is mandatory
 for recursive calls only, should not be modified by inital caller
 @raise InternalError: one of the plugin is not handling components
-@raise KeyError: one plugin should be present in self.host_app.plugins but it is not
+@raise KeyError: one plugin should be present in self.host_app.plugins but it
+is not
 """
 if C.PLUG_MODE_COMPONENT not in current._info[u"modes"]:
 if not required:
 return
 else:
 log.error(
 _(
-u"Plugin {current_name} is needed for {entry_name}, but it doesn't handle component mode"
+u"Plugin {current_name} is needed for {entry_name}, "
+u"but it doesn't handle component mode"
 ).format(
 current_name=current._info[u"import_name"],
 entry_name=self.entry_plugin._info[u"import_name"],
 )
 )
 log.info(u"history is skipped as requested")
 data[u"extra"][u"history"] = C.HISTORY_SKIP
 else:
 return self.host.memory.addToHistory(client, data)
-def bridgeSignal(self, dummy, client, data):
+def bridgeSignal(self, __, client, data):
 try:
 data["extra"]["received_timestamp"] = data["received_timestamp"]
 data["extra"]["delay_sender"] = data["delay_sender"]
 except KeyError:
 pass
 if not item.subscriptionTo and not item.subscriptionFrom and not item.ask:
 # 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(
-u"Removing contact {} from roster because there is no presence subscription".format(
+u"Removing contact {} from roster because there is no presence "
+u"subscription".format(
 item.jid
 )
 )
 self.removeItem(item.entity)  # FIXME: to be checked
 else:
 @param item (RosterIem): item added
 """
 log.debug(u"registering item: {}".format(item.entity.full()))
 if item.entity.resource:
 log.warning(
-u"Received a roster item with a resource, this is not common but not restricted by RFC 6121, this case may be not well tested."
+u"Received a roster item with a resource, this is not common but not "
+u"restricted by RFC 6121, this case may be not well tested."
 )
 if not item.subscriptionTo:
 if not item.subscriptionFrom:
 log.info(
 _(u"There's no subscription between you and [{}]!").format(
 jids_set.remove(entity)
 if not jids_set:
 del self._groups[group]
 except KeyError:
 log.warning(
-u"there is no cache for the group [%(group)s] of the removed roster item [%(jid)s]"
+u"there is no cache for the group [{group}] of the removed roster "
-% {"group": group, "jid": entity}
+u"item [{jid_}]".format(group=group, jid=entity)
 )
 # then we send the bridge signal
 self.host.bridge.contactDeleted(entity.full(), self.parent.profile)
 presence_d.addCallback(lambda __: super(SatPresenceProtocol, self).send(obj))
 def availableReceived(self, entity, show=None, statuses=None, priority=0):
 log.debug(
 _(
-u"presence update for [%(entity)s] (available, show=%(show)s statuses=%(statuses)s priority=%(priority)d)"
+u"presence update for [{entity}] (available, show={show} "
+u"statuses={statuses} priority={priority})"
 )
-% {
+.format(
-"entity": entity,
+entity=entity,
-C.PRESENCE_SHOW: show,
+show=show,
-C.PRESENCE_STATUSES: statuses,
+statuses=statuses,
-C.PRESENCE_PRIORITY: priority,
+priority=priority,
-}
+)
 )
 if not statuses:
 statuses = {}
 "presenceReceived", entity, "unavailable", 0, statuses, self.parent.profile
 ):
 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
+# 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.getEntityDatum(
 entity, "presence", self.parent.profile
 )
 except (KeyError, exceptions.UnknownEntityError):
 def subscribeReceived(self, entity):
 log.debug(_(u"subscription request from [%s]") % entity.userhost())
 yield self.parent.roster.got_roster
 item = self.parent.roster.getItem(entity)
 if item and item.subscriptionTo:
-# We automatically accept subscription if we are already subscribed to contact presence
+# We automatically accept subscription if we are already subscribed to
+# contact presence
 log.debug(_("sending automatic subscription acceptance"))
 self.subscribed(entity)
 else:
 self.host.memory.addWaitingSub(
 "subscribe", entity.userhost(), self.parent.profile
 log.debug(u"iqFallback: xml = [%s]" % (iq.toXml()))
 generic.FallbackHandler.iqFallback(self, iq)
 class SatVersionHandler(generic.VersionHandler):
 def getDiscoInfo(self, requestor, target, node):
-# XXX: We need to work around wokkel's behaviour (namespace not added if there is a
+# XXX: We need to work around wokkel's behaviour (namespace not added if there
-# node) as it cause issues with XEP-0115 & PEP (XEP-0163): there is a node when server
+#      is a node) as it cause issues with XEP-0115 & PEP (XEP-0163): there is a
-# ask for disco info, and not when we generate the key, so the hash is used with different
+#      node when server ask for disco info, and not when we generate the key, so
-# disco features, and when the server (seen on ejabberd) generate its own hash for security check
+#      the hash is used with different disco features, and when the server (seen
-# it reject our features (resulting in e.g. no notification on PEP)
+#      on ejabberd) generate its own hash for security check it reject our
+#      features (resulting in e.g. no notification on PEP)
 return generic.VersionHandler.getDiscoInfo(self, requestor, target, None)
 class SatIdentityHandler(XMPPHandler):
-""" Manage disco Identity of SàT.
+"""Manage disco Identity of SàT."""
-"""
-# TODO: dynamic identity update (see docstring). Note that a XMPP entity can have several identities
 implements(iwokkel.IDisco)
+# 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
 def getDiscoItems(self, requestor, target, nodeIdentifier=""):

Mercurial > libervia-backend

comparison sat/core/xmpp.py @ 2643:189e38fb11ff