libervia-backend: sat/plugins/plugin_xep

comparison sat/plugins/plugin_xep_0085.py @ 2624:56f94936df1e

code style reformatting using black

author	Goffi <goffi@goffi.org>
date	Wed, 27 Jun 2018 20:14:46 +0200
parents	26edcf3a30eb
children	94708a7d3ecf

comparison

equal deleted inserted replaced

-:49533de4540b
+:56f94936df1e
 from sat.core.i18n import _
 from sat.core.constants import Const as C
 from sat.core import exceptions
 from sat.core.log import getLogger
 log = getLogger(__name__)
 from wokkel import disco, iwokkel
 from zope.interface import implements
 from twisted.words.protocols.jabber.jid import JID
 try:
 from twisted.words.protocols.xmlstream import XMPPHandler
 except ImportError:
 from wokkel.subprotocols import XMPPHandler
 from twisted.words.xish import domish
 C.PI_TYPE: "XEP",
 C.PI_PROTOCOLS: ["XEP-0085"],
 C.PI_DEPENDENCIES: [],
 C.PI_MAIN: "XEP_0085",
 C.PI_HANDLER: "yes",
-C.PI_DESCRIPTION: _("""Implementation of Chat State Notifications Protocol""")
+C.PI_DESCRIPTION: _("""Implementation of Chat State Notifications Protocol"""),
 }
 # Describe the internal transitions that are triggered
 # by a timer. Beside that, external transitions can be
 TRANSITIONS = {
 "active": {"next_state": "inactive", "delay": 120},
 "inactive": {"next_state": "gone", "delay": 480},
 "gone": {"next_state": "", "delay": 0},
 "composing": {"next_state": "paused", "delay": 30},
-"paused": {"next_state": "inactive", "delay": 450}
+"paused": {"next_state": "inactive", "delay": 450},
 }
 class UnknownChatStateException(Exception):
 """
 This error is raised when an unknown chat state is used.
 """
 pass
 class XEP_0085(object):
 """
 Implementation for XEP 0085
 """
 params = """
 <params>
 <individual>
 <category name="%(category_name)s" label="%(category_label)s">
 <param name="%(param_name)s" label="%(param_label)s" value="true" type="bool" security="0"/>
 </category>
 </individual>
 </params>
 """ % {
-'category_name': PARAM_KEY,
+"category_name": PARAM_KEY,
-'category_label': _(PARAM_KEY),
+"category_label": _(PARAM_KEY),
-'param_name': PARAM_NAME,
+"param_name": PARAM_NAME,
-'param_label': _('Enable chat state notifications')
+"param_label": _("Enable chat state notifications"),
 }
 def __init__(self, host):
 log.info(_("Chat State Notifications plugin initialization"))
 self.host = host
 host.trigger.add("MessageReceived", self.messageReceivedTrigger)
 host.trigger.add("sendMessage", self.sendMessageTrigger)
 host.trigger.add("paramUpdateTrigger", self.paramUpdateTrigger)
 # args: to_s (jid as string), profile
-host.bridge.addMethod("chatStateComposing", ".plugin", in_sign='ss',
+host.bridge.addMethod(
-out_sign='', method=self.chatStateComposing)
+"chatStateComposing",
+".plugin",
+in_sign="ss",
+out_sign="",
+method=self.chatStateComposing,
+)
 # args: from (jid as string), state in CHAT_STATES, profile
-host.bridge.addSignal("chatStateReceived", ".plugin", signature='sss')
+host.bridge.addSignal("chatStateReceived", ".plugin", signature="sss")
 def getHandler(self, client):
 return XEP_0085_handler(self, client.profile)
 def profileDisconnected(self, client):
 return
 for to_jid in self.map[profile]:
 # FIXME: the "unavailable" presence stanza is received by to_jid
 # before the chat state, so it will be ignored... find a way to
 # actually defer the disconnection
-self.map[profile][to_jid]._onEvent('gone')
+self.map[profile][to_jid]._onEvent("gone")
 del self.map[profile]
 def updateCache(self, entity_jid, value, profile):
 """Update the entity data of the given profile for one or all contacts.
 Reset the chat state(s) display if the notification has been disabled.
 @param profile: current profile
 """
 if value == DELETE_VALUE:
 self.host.memory.delEntityDatum(entity_jid, ENTITY_KEY, profile)
 else:
-self.host.memory.updateEntityData(entity_jid, ENTITY_KEY, value, profile_key=profile)
+self.host.memory.updateEntityData(
+entity_jid, ENTITY_KEY, value, profile_key=profile
+)
 if not value or value == DELETE_VALUE:
 # reinit chat state UI for this or these contact(s)
 self.host.bridge.chatStateReceived(entity_jid.full(), "", profile)
 def paramUpdateTrigger(self, name, value, category, type_, profile):
 @param value: "true" to activate the notifications, or any other value to delete it
 @param category: parameter category
 @param type_: parameter type
 """
 if (category, name) == (PARAM_KEY, PARAM_NAME):
-self.updateCache(C.ENTITY_ALL, True if C.bool(value) else DELETE_VALUE, profile=profile)
+self.updateCache(
+C.ENTITY_ALL, True if C.bool(value) else DELETE_VALUE, profile=profile
+)
 return False
 return True
 def messageReceivedTrigger(self, client, message, post_treat):
 """
 try:
 domish.generateElementsNamed(message.elements(), name="active").next()
 # contact enabled Chat State Notifications
 self.updateCache(from_jid, True, profile=profile)
 except StopIteration:
-if message.getAttribute('type') == 'chat':
+if message.getAttribute("type") == "chat":
 # contact didn't enable Chat State Notifications
 self.updateCache(from_jid, False, profile=profile)
 return True
 except StopIteration:
 pass
 # send our next "composing" states to any MUC and to the contacts who enabled the feature
 self._chatStateInit(from_jid, message.getAttribute("type"), profile)
-state_list = [child.name for child in message.elements() if
+state_list = [
-message.getAttribute("type") in MESSAGE_TYPES
+child.name
-and child.name in CHAT_STATES
+for child in message.elements()
-and child.defaultUri == NS_CHAT_STATES]
+if message.getAttribute("type") in MESSAGE_TYPES
+and child.name in CHAT_STATES
+and child.defaultUri == NS_CHAT_STATES
+]
 for state in state_list:
 # there must be only one state according to the XEP
-if state != 'gone' or message.getAttribute('type') != 'groupchat':
+if state != "gone" or message.getAttribute("type") != "groupchat":
-self.host.bridge.chatStateReceived(message.getAttribute("from"), state, profile)
+self.host.bridge.chatStateReceived(
+message.getAttribute("from"), state, profile
+)
 break
 return True
-def sendMessageTrigger(self, client, mess_data, pre_xml_treatments, post_xml_treatments):
+def sendMessageTrigger(
+self, client, mess_data, pre_xml_treatments, post_xml_treatments
+):
 """
 Eventually add the chat state to the message and initiate
 the state machine when sending an "active" state.
 """
 profile = client.profile
 def treatment(mess_data):
-message = mess_data['xml']
+message = mess_data["xml"]
 to_jid = JID(message.getAttribute("to"))
 if not self._checkActivation(to_jid, forceEntityData=True, profile=profile):
 return mess_data
 try:
 # message with a body always mean active state
 domish.generateElementsNamed(message.elements(), name="body").next()
-message.addElement('active', NS_CHAT_STATES)
+message.addElement("active", NS_CHAT_STATES)
 # launch the chat state machine (init the timer)
 if self._isMUC(to_jid, profile):
 to_jid = to_jid.userhostJID()
 self._chatStateActive(to_jid, mess_data["type"], profile)
 except StopIteration:
 @param to_jid (JID): full or bare JID to check
 @param profile (str): %(doc_profile)s
 @return: bool
 """
 try:
-type_ = self.host.memory.getEntityDatum(to_jid.userhostJID(), 'type', profile)
+type_ = self.host.memory.getEntityDatum(to_jid.userhostJID(), "type", profile)
-if type_ == 'chatroom': # FIXME: should not use disco instead ?
+if type_ == "chatroom":  # FIXME: should not use disco instead ?
 return True
 except (exceptions.UnknownEntityError, KeyError):
 pass
 return False
 """
 if mess_type is None:
 return
 profile_map = self.map.setdefault(profile, {})
 if to_jid not in profile_map:
-machine = ChatStateMachine(self.host, to_jid,
+machine = ChatStateMachine(self.host, to_jid, mess_type, profile)
-mess_type, profile)
 self.map[profile][to_jid] = machine
 def _chatStateActive(self, to_jid, mess_type, profile_key):
 """
 Launch the chat state machine on "active" state.
 to_jid = JID(to_jid_s)
 if self._isMUC(to_jid, client.profile):
 to_jid = to_jid.userhostJID()
 elif not to_jid.resource:
 to_jid.resource = self.host.memory.getMainResource(client, to_jid)
-if not self._checkActivation(to_jid, forceEntityData=False, profile=client.profile):
+if not self._checkActivation(
+to_jid, forceEntityData=False, profile=client.profile
+):
 return
 try:
 self.map[client.profile][to_jid]._onEvent("composing")
 except (KeyError, AttributeError):
 # no message has been sent/received since the notifications
 assert state in TRANSITIONS
 transition = TRANSITIONS[state]
 assert "next_state" in transition and "delay" in transition
 if state != self.state and state != "active":
-if state != 'gone' or self.mess_type != 'groupchat':
+if state != "gone" or self.mess_type != "groupchat":
 # send a new message without body
-log.debug(u"sending state '{state}' to {jid}".format(state=state, jid=self.to_jid.full()))
+log.debug(
+u"sending state '{state}' to {jid}".format(
+state=state, jid=self.to_jid.full()
+)
+)
 client = self.host.getClient(self.profile)
 mess_data = {
-'from': client.jid,
+"from": client.jid,
-'to': self.to_jid,
+"to": self.to_jid,
-'uid': '',
+"uid": "",
-'message': {},
+"message": {},
-'type': self.mess_type,
+"type": self.mess_type,
-'subject': {},
+"subject": {},
-'extra': {},
+"extra": {},
 }
 client.generateMessageXML(mess_data)
-mess_data['xml'].addElement(state, NS_CHAT_STATES)
+mess_data["xml"].addElement(state, NS_CHAT_STATES)
-client.send(mess_data['xml'])
+client.send(mess_data["xml"])
 self.state = state
 try:
 self.timer.cancel()
 except (internet_error.AlreadyCalled, AttributeError):
 pass
 if transition["next_state"] and transition["delay"] > 0:
-self.timer = reactor.callLater(transition["delay"], self._onEvent, transition["next_state"])
+self.timer = reactor.callLater(
+transition["delay"], self._onEvent, transition["next_state"]
+)
 class XEP_0085_handler(XMPPHandler):
 implements(iwokkel.IDisco)
 def __init__(self, plugin_parent, profile):
 self.plugin_parent = plugin_parent
 self.host = plugin_parent.host
 self.profile = profile
-def getDiscoInfo(self, requestor, target, nodeIdentifier=''):
+def getDiscoInfo(self, requestor, target, nodeIdentifier=""):
 return [disco.DiscoFeature(NS_CHAT_STATES)]
-def getDiscoItems(self, requestor, target, nodeIdentifier=''):
+def getDiscoItems(self, requestor, target, nodeIdentifier=""):
 return []

Mercurial > libervia-backend

comparison sat/plugins/plugin_xep_0085.py @ 2624:56f94936df1e