libervia-backend: sat/plugins/plugin_xep

comparison sat/plugins/plugin_xep_0313.py @ 4037:524856bd7b19

massive refactoring to switch from camelCase to snake_case: historically, Libervia (SàT before) was using camelCase as allowed by PEP8 when using a pre-PEP8 code, to use the same coding style as in Twisted. However, snake_case is more readable and it's better to follow PEP8 best practices, so it has been decided to move on full snake_case. Because Libervia has a huge codebase, this ended with a ugly mix of camelCase and snake_case. To fix that, this patch does a big refactoring by renaming every function and method (including bridge) that are not coming from Twisted or Wokkel, to use fully snake_case. This is a massive change, and may result in some bugs.

author	Goffi <goffi@goffi.org>
date	Sat, 08 Apr 2023 13:54:42 +0200
parents	5245b675f7ad
children

comparison

equal deleted inserted replaced

-:c4464d7ae97b
+:524856bd7b19
 class XEP_0313(object):
 def __init__(self, host):
 log.info(_("Message Archive Management plugin initialization"))
 self.host = host
-self.host.registerNamespace("mam", mam.NS_MAM)
+self.host.register_namespace("mam", mam.NS_MAM)
-host.registerNamespace("fulltextmam", NS_FTS)
+host.register_namespace("fulltextmam", NS_FTS)
 self._rsm = host.plugins["XEP-0059"]
 self._sid = host.plugins["XEP-0359"]
 # Deferred used to store last stanza id in order of reception
 self._last_stanza_id_d = defer.Deferred()
 self._last_stanza_id_d.callback(None)
-host.bridge.addMethod(
+host.bridge.add_method(
-"MAMGet", ".plugin", in_sign='sss',
+"mam_get", ".plugin", in_sign='sss',
-out_sign='(a(sdssa{ss}a{ss}ss)ss)', method=self._getArchives,
+out_sign='(a(sdssa{ss}a{ss}ss)ss)', method=self._get_archives,
 async_=True)
 async def resume(self, client):
 """Retrieve one2one messages received since the last we have in local storage"""
-stanza_id_data = await self.host.memory.storage.getPrivates(
+stanza_id_data = await self.host.memory.storage.get_privates(
 mam.NS_MAM, [KEY_LAST_STANZA_ID], profile=client.profile)
 stanza_id = stanza_id_data.get(KEY_LAST_STANZA_ID)
 rsm_req = None
 if stanza_id is None:
 log.info("can't retrieve last stanza ID, checking history")
-last_mess = await self.host.memory.historyGet(
+last_mess = await self.host.memory.history_get(
 None, None, limit=1, filters={'not_types': C.MESS_TYPE_GROUPCHAT,
 'last_stanza_id': True},
 profile=client.profile)
 if not last_mess:
 log.info(_("It seems that we have no MAM history yet"))
 rsm_req = rsm.RSMRequest(max_=100, after=stanza_id)
 mam_req = mam.MAMRequest(rsm_=rsm_req)
 complete = False
 count = 0
 while not complete:
-mam_data = await self.getArchives(client, mam_req,
+mam_data = await self.get_archives(client, mam_req,
 service=client.jid.userhostJID())
 elt_list, rsm_response, mam_response = mam_data
 complete = mam_response["complete"]
 # we update MAM request for next iteration
 mam_req.rsm.after = rsm_response.last
 else:
 count += len(elt_list)
 for mess_elt in elt_list:
 try:
-fwd_message_elt = self.getMessageFromResult(
+fwd_message_elt = self.get_message_from_result(
 client, mess_elt, mam_req)
 except exceptions.DataError:
 continue
 try:
 'was expecting a message sent by our jid, but this one if '
 'from {from_jid}, ignoring\n{xml}').format(
 from_jid=from_jid.full(), xml=mess_elt.toXml()))
 continue
 # adding message to history
-mess_data = client.messageProt.parseMessage(fwd_message_elt)
+mess_data = client.messageProt.parse_message(fwd_message_elt)
 try:
-await client.messageProt.addToHistory(mess_data)
+await client.messageProt.add_to_history(mess_data)
 except exceptions.CancelError as e:
 log.warning(
 "message has not been added to history: {e}".format(e=e))
 except Exception as e:
 log.error(
 log.info(_("We have received no message while offline"))
 else:
 log.info(_("We have received {num_mess} message(s) while offline.")
 .format(num_mess=count))
-def profileConnected(self, client):
+def profile_connected(self, client):
 defer.ensureDeferred(self.resume(client))
-def getHandler(self, client):
+def get_handler(self, client):
 mam_client = client._mam = SatMAMClient(self)
 return mam_client
-def parseExtra(self, extra, with_rsm=True):
+def parse_extra(self, extra, with_rsm=True):
 """Parse extra dictionnary to retrieve MAM arguments
 @param extra(dict): data for parse
 @param with_rsm(bool): if True, RSM data will be parsed too
 @return (data_form, None): request with parsed arguments
 mam_args[arg] = value
 except KeyError:
 continue
 if with_rsm:
-rsm_request = self._rsm.parseExtra(extra)
+rsm_request = self._rsm.parse_extra(extra)
 if rsm_request is not None:
 mam_args["rsm_"] = rsm_request
 if form_args:
 mam_args["form"] = mam.buildForm(**form_args)
 assert isinstance(order_by, list)
 mam_args["orderBy"] = order_by
 return mam.MAMRequest(**mam_args) if mam_args else None
-def getMessageFromResult(self, client, mess_elt, mam_req, service=None):
+def get_message_from_result(self, client, mess_elt, mam_req, service=None):
 """Extract usable <message/> from MAM query result
 The message will be validated, and stanza-id/delay will be added if necessary.
 @param mess_elt(domish.Element): result <message/> element wrapping the message
 to retrieve
 else:
 if not result_elt["queryid"] == mam_req.query_id:
 log.error("Unexpected query id (was expecting {query_id}): {xml}"
 .format(query_id=mam.query_id, xml=mess_elt.toXml()))
 raise exceptions.DataError("Invalid element")
-stanza_id = self._sid.getStanzaId(fwd_message_elt,
+stanza_id = self._sid.get_stanza_id(fwd_message_elt,
 service_jid)
 if stanza_id is None:
 # not stanza-id element is present, we add one so message
 # will be archived with it, and we won't request several times
 # the same MAM achive
 stanza_id = result_elt["id"]
 except AttributeError:
 log.warning('Invalid MAM result: missing "id" attribute: {xml}'
 .format(xml=result_elt.toXml()))
 raise exceptions.DataError("Invalid element")
-self._sid.addStanzaId(client, fwd_message_elt, stanza_id, by=service_jid)
+self._sid.add_stanza_id(client, fwd_message_elt, stanza_id, by=service_jid)
 if delay_elt is not None:
 fwd_message_elt.addChild(delay_elt)
 return fwd_message_elt
 None for user server
 @return (D(domish.Element)): <IQ/> result
 """
 return client._mam.queryArchive(mam_req, service)
-def _appendMessage(self, elt_list, message_cb, message_elt):
+def _append_message(self, elt_list, message_cb, message_elt):
 if message_cb is not None:
 elt_list.append(message_cb(message_elt))
 else:
 elt_list.append(message_elt)
-def _queryFinished(self, iq_result, client, elt_list, event):
+def _query_finished(self, iq_result, client, elt_list, event):
-client.xmlstream.removeObserver(event, self._appendMessage)
+client.xmlstream.removeObserver(event, self._append_message)
 try:
 fin_elt = next(iq_result.elements(mam.NS_MAM, "fin"))
 except StopIteration:
 raise exceptions.DataError("Invalid MAM result")
 except rsm.RSMNotFoundError:
 rsm_response = None
 return (elt_list, rsm_response, mam_response)
-def serializeArchiveResult(self, data, client, mam_req, service):
+def serialize_archive_result(self, data, client, mam_req, service):
 elt_list, rsm_response, mam_response = data
 mess_list = []
 for elt in elt_list:
-fwd_message_elt = self.getMessageFromResult(client, elt, mam_req,
+fwd_message_elt = self.get_message_from_result(client, elt, mam_req,
 service=service)
-mess_data = client.messageProt.parseMessage(fwd_message_elt)
+mess_data = client.messageProt.parse_message(fwd_message_elt)
-mess_list.append(client.messageGetBridgeArgs(mess_data))
+mess_list.append(client.message_get_bridge_args(mess_data))
 metadata = {
 'rsm': self._rsm.response2dict(rsm_response),
 'mam': mam_response
 }
 return mess_list, data_format.serialise(metadata), client.profile
-def _getArchives(self, service, extra_ser, profile_key):
+def _get_archives(self, service, extra_ser, profile_key):
 """
 @return: tuple with:
-- list of message with same data as in bridge.messageNew
+- list of message with same data as in bridge.message_new
 - response metadata with:
 - rsm data (first, last, count, index)
 - mam data (complete, stable)
 - profile
 """
-client = self.host.getClient(profile_key)
+client = self.host.get_client(profile_key)
 service = jid.JID(service) if service else None
 extra = data_format.deserialise(extra_ser, {})
-mam_req = self.parseExtra(extra)
+mam_req = self.parse_extra(extra)
-d = self.getArchives(client, mam_req, service=service)
+d = self.get_archives(client, mam_req, service=service)
-d.addCallback(self.serializeArchiveResult, client, mam_req, service)
+d.addCallback(self.serialize_archive_result, client, mam_req, service)
 return d
-def getArchives(self, client, query, service=None, message_cb=None):
+def get_archives(self, client, query, service=None, message_cb=None):
 """Query archive and gather page result
 @param query(mam.MAMRequest): MAM request
 @param service(jid.JID, None): MAM service to use
 None to use our own server
 """
 if query.query_id is None:
 query.query_id = str(uuid.uuid4())
 elt_list = []
 event = MESSAGE_RESULT.format(mam_ns=mam.NS_MAM, query_id=query.query_id)
-client.xmlstream.addObserver(event, self._appendMessage, 0, elt_list, message_cb)
+client.xmlstream.addObserver(event, self._append_message, 0, elt_list, message_cb)
 d = self.queryArchive(client, query, service)
-d.addCallback(self._queryFinished, client, elt_list, event)
+d.addCallback(self._query_finished, client, elt_list, event)
 return d
-def getPrefs(self, client, service=None):
+def get_prefs(self, client, service=None):
 """Retrieve the current user preferences.
 @param service: entity offering the MAM service (None for user archives)
 @return: the server response as a Deferred domish.Element
 """
 # http://xmpp.org/extensions/xep-0313.html#prefs
 return client._mam.queryPrefs(service)
-def _setPrefs(self, service_s=None, default="roster", always=None, never=None,
+def _set_prefs(self, service_s=None, default="roster", always=None, never=None,
 profile_key=C.PROF_KEY_NONE):
 service = jid.JID(service_s) if service_s else None
 always_jid = [jid.JID(entity) for entity in always]
 never_jid = [jid.JID(entity) for entity in never]
 # TODO: why not build here a MAMPrefs object instead of passing the args separately?
 @return: the server response as a Deferred domish.Element
 """
 # http://xmpp.org/extensions/xep-0313.html#prefs
 return client._mam.setPrefs(service, default, always, never)
-def onMessageStanzaId(self, message_elt, client):
+def on_message_stanza_id(self, message_elt, client):
 """Called when a message with a stanza-id is received
 the messages' stanza ids are stored when received, so the last one can be used
 to retrieve missing history on next connection
 @param message_elt(domish.Element): <message> with a stanza-id
 """
 service_jid = client.jid.userhostJID()
-stanza_id = self._sid.getStanzaId(message_elt, service_jid)
+stanza_id = self._sid.get_stanza_id(message_elt, service_jid)
 if stanza_id is None:
 log.debug("Ignoring <message>, stanza id is not from our server")
 else:
 # we use self._last_stanza_id_d do be sure that last_stanza_id is stored in
 # the order of reception
 self._last_stanza_id_d.addCallback(
-lambda __: self.host.memory.storage.setPrivateValue(
+lambda __: self.host.memory.storage.set_private_value(
 namespace=mam.NS_MAM,
 key=KEY_LAST_STANZA_ID,
 value=stanza_id,
 profile=client.profile))
 def connectionInitialized(self):
 observer_xpath = MESSAGE_STANZA_ID.format(
 ns_stanza_id=self.host.ns_map['stanza_id'])
 self.xmlstream.addObserver(
-observer_xpath, self.plugin_parent.onMessageStanzaId, client=self.parent
+observer_xpath, self.plugin_parent.on_message_stanza_id, client=self.parent
 )
 def getDiscoInfo(self, requestor, target, nodeIdentifier=""):
 return [disco.DiscoFeature(mam.NS_MAM)]

Mercurial > libervia-backend

comparison sat/plugins/plugin_xep_0313.py @ 4037:524856bd7b19