--- a/sat/plugins/plugin_xep_0313.py	Fri Apr 07 15:18:39 2023 +0200
+++ b/sat/plugins/plugin_xep_0313.py	Sat Apr 08 13:54:42 2023 +0200
@@ -63,27 +63,27 @@
     def __init__(self, host):
         log.info(_("Message Archive Management plugin initialization"))
         self.host = host
-        self.host.registerNamespace("mam", mam.NS_MAM)
-        host.registerNamespace("fulltextmam", NS_FTS)
+        self.host.register_namespace("mam", mam.NS_MAM)
+        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(
-            "MAMGet", ".plugin", in_sign='sss',
-            out_sign='(a(sdssa{ss}a{ss}ss)ss)', method=self._getArchives,
+        host.bridge.add_method(
+            "mam_get", ".plugin", in_sign='sss',
+            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)
@@ -99,7 +99,7 @@
         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"]
@@ -114,7 +114,7 @@
 
             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
@@ -142,9 +142,9 @@
                                 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))
@@ -159,14 +159,14 @@
             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
@@ -208,7 +208,7 @@
                 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
 
@@ -224,7 +224,7 @@
 
         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.
@@ -267,7 +267,7 @@
                 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
@@ -279,7 +279,7 @@
                     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)
@@ -304,14 +304,14 @@
         """
         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):
-        client.xmlstream.removeObserver(event, self._appendMessage)
+    def _query_finished(self, iq_result, client, elt_list, event):
+        client.xmlstream.removeObserver(event, self._append_message)
         try:
             fin_elt = next(iq_result.elements(mam.NS_MAM, "fin"))
         except StopIteration:
@@ -327,39 +327,39 @@
 
         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_list.append(client.messageGetBridgeArgs(mess_data))
+            mess_data = client.messageProt.parse_message(fwd_message_elt)
+            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.addCallback(self.serializeArchiveResult, client, mam_req, service)
+        d = self.get_archives(client, mam_req, service=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
@@ -378,12 +378,12 @@
             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)
@@ -392,7 +392,7 @@
         # 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]
@@ -413,7 +413,7 @@
         # 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
@@ -421,14 +421,14 @@
         @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,
@@ -449,7 +449,7 @@
         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=""):