--- a/sat/plugins/plugin_xep_0096.py	Fri Apr 07 15:18:39 2023 +0200
+++ b/sat/plugins/plugin_xep_0096.py	Sat Apr 08 13:54:42 2023 +0200
@@ -64,18 +64,18 @@
         self._f = self.host.plugins["FILE"]
         self._f.register(self)
         self._si = self.host.plugins["XEP-0095"]
-        self._si.registerSIProfile(SI_PROFILE_NAME, self._transferRequest)
-        host.bridge.addMethod(
-            "siSendFile", ".plugin", in_sign="sssss", out_sign="s", method=self._fileSend
+        self._si.register_si_profile(SI_PROFILE_NAME, self._transfer_request)
+        host.bridge.add_method(
+            "si_file_send", ".plugin", in_sign="sssss", out_sign="s", method=self._file_send
         )
 
-    async def canHandleFileSend(self, client, peer_jid, filepath):
+    async def can_handle_file_send(self, client, peer_jid, filepath):
         return await self.host.hasFeature(client, NS_SI_FT, peer_jid)
 
     def unload(self):
-        self._si.unregisterSIProfile(SI_PROFILE_NAME)
+        self._si.unregister_si_profile(SI_PROFILE_NAME)
 
-    def _badRequest(self, client, iq_elt, message=None):
+    def _bad_request(self, client, iq_elt, message=None):
         """Send a bad-request error
 
         @param iq_elt(domish.Element): initial <IQ> element of the SI request
@@ -85,7 +85,7 @@
             log.warning(message)
         self._si.sendError(client, iq_elt, "bad-request")
 
-    def _parseRange(self, parent_elt, file_size):
+    def _parse_range(self, parent_elt, file_size):
         """find and parse <range/> element
 
         @param parent_elt(domish.Element): direct parent of the <range/> element
@@ -118,7 +118,7 @@
 
         return range_, range_offset, range_length
 
-    def _transferRequest(self, client, iq_elt, si_id, si_mime_type, si_elt):
+    def _transfer_request(self, client, iq_elt, si_id, si_mime_type, si_elt):
         """Called when a file transfer is requested
 
         @param iq_elt(domish.Element): initial <IQ> element of the SI request
@@ -132,14 +132,14 @@
         try:
             file_elt = next(si_elt.elements(NS_SI_FT, "file"))
         except StopIteration:
-            return self._badRequest(
+            return self._bad_request(
                 client, iq_elt, "No <file/> element found in SI File Transfer request"
             )
 
         try:
-            feature_elt = self.host.plugins["XEP-0020"].getFeatureElt(si_elt)
+            feature_elt = self.host.plugins["XEP-0020"].get_feature_elt(si_elt)
         except exceptions.NotFound:
-            return self._badRequest(
+            return self._bad_request(
                 client, iq_elt, "No <feature/> element found in SI File Transfer request"
             )
 
@@ -147,7 +147,7 @@
             filename = file_elt["name"]
             file_size = int(file_elt["size"])
         except (KeyError, ValueError):
-            return self._badRequest(client, iq_elt, "Malformed SI File Transfer request")
+            return self._bad_request(client, iq_elt, "Malformed SI File Transfer request")
 
         file_date = file_elt.getAttribute("date")
         file_hash = file_elt.getAttribute("hash")
@@ -164,16 +164,16 @@
             file_desc = ""
 
         try:
-            range_, range_offset, range_length = self._parseRange(file_elt, file_size)
+            range_, range_offset, range_length = self._parse_range(file_elt, file_size)
         except ValueError:
-            return self._badRequest(client, iq_elt, "Malformed SI File Transfer request")
+            return self._bad_request(client, iq_elt, "Malformed SI File Transfer request")
 
         try:
             stream_method = self.host.plugins["XEP-0020"].negotiate(
                 feature_elt, "stream-method", self.managed_stream_m, namespace=None
             )
         except KeyError:
-            return self._badRequest(client, iq_elt, "No stream method found")
+            return self._bad_request(client, iq_elt, "No stream method found")
 
         if stream_method:
             if stream_method == self.host.plugins["XEP-0065"].NAMESPACE:
@@ -207,11 +207,11 @@
         }
 
         d = defer.ensureDeferred(
-            self._f.getDestDir(client, peer_jid, data, data, stream_object=True)
+            self._f.get_dest_dir(client, peer_jid, data, data, stream_object=True)
         )
-        d.addCallback(self.confirmationCb, client, iq_elt, data)
+        d.addCallback(self.confirmation_cb, client, iq_elt, data)
 
-    def confirmationCb(self, accepted, client, iq_elt, data):
+    def confirmation_cb(self, accepted, client, iq_elt, data):
         """Called on confirmation answer
 
         @param accepted(bool): True if file transfer is accepted
@@ -244,14 +244,14 @@
 
         # file_obj = self._getFileObject(dest_path, can_range)
         # range_offset = file_obj.tell()
-        d = data["stream_plugin"].createSession(
+        d = data["stream_plugin"].create_session(
             client, data["stream_object"], client.jid, data["peer_jid"], data["si_id"]
         )
-        d.addCallback(self._transferCb, client, data)
-        d.addErrback(self._transferEb, client, data)
+        d.addCallback(self._transfer_cb, client, data)
+        d.addErrback(self._transfer_eb, client, data)
 
         # we can send the iq result
-        feature_elt = self.host.plugins["XEP-0020"].chooseOption(
+        feature_elt = self.host.plugins["XEP-0020"].choose_option(
             {"stream-method": data["stream_method"]}, namespace=None
         )
         misc_elts = []
@@ -261,9 +261,9 @@
         #     range_elt['offset'] = str(range_offset)
         #     #TODO: manage range length
         #     misc_elts.append(range_elt)
-        self._si.acceptStream(client, iq_elt, feature_elt, misc_elts)
+        self._si.accept_stream(client, iq_elt, feature_elt, misc_elts)
 
-    def _transferCb(self, __, client, data):
+    def _transfer_cb(self, __, client, data):
         """Called by the stream method when transfer successfuly finished
 
         @param data: session data
@@ -272,7 +272,7 @@
         data["stream_object"].close()
         log.info("Transfer {si_id} successfuly finished".format(**data))
 
-    def _transferEb(self, failure, client, data):
+    def _transfer_eb(self, failure, client, data):
         """Called when something went wrong with the transfer
 
         @param id: stream id
@@ -285,13 +285,13 @@
         )
         data["stream_object"].close()
 
-    def _fileSend(self, peer_jid_s, filepath, name, desc, profile=C.PROF_KEY_NONE):
-        client = self.host.getClient(profile)
-        return self.fileSend(
+    def _file_send(self, peer_jid_s, filepath, name, desc, profile=C.PROF_KEY_NONE):
+        client = self.host.get_client(profile)
+        return self.file_send(
             client, jid.JID(peer_jid_s), filepath, name or None, desc or None
         )
 
-    def fileSend(self, client, peer_jid, filepath, name=None, desc=None, extra=None):
+    def file_send(self, client, peer_jid, filepath, name=None, desc=None, extra=None):
         """Send a file using XEP-0096
 
         @param peer_jid(jid.JID): recipient
@@ -302,7 +302,7 @@
         @param extra: not used here
         @return: an unique id to identify the transfer
         """
-        feature_elt = self.host.plugins["XEP-0020"].proposeFeatures(
+        feature_elt = self.host.plugins["XEP-0020"].propose_features(
             {"stream-method": self.managed_stream_m}, namespace=None
         )
 
@@ -320,23 +320,23 @@
 
         file_transfer_elts.append(domish.Element((None, "range")))
 
-        sid, offer_d = self._si.proposeStream(
+        sid, offer_d = self._si.propose_stream(
             client, peer_jid, SI_PROFILE, feature_elt, file_transfer_elts
         )
         args = [filepath, sid, size, client]
-        offer_d.addCallbacks(self._fileCb, self._fileEb, args, None, args)
+        offer_d.addCallbacks(self._file_cb, self._file_eb, args, None, args)
         return sid
 
-    def _fileCb(self, result_tuple, filepath, sid, size, client):
+    def _file_cb(self, result_tuple, filepath, sid, size, client):
         iq_elt, si_elt = result_tuple
 
         try:
-            feature_elt = self.host.plugins["XEP-0020"].getFeatureElt(si_elt)
+            feature_elt = self.host.plugins["XEP-0020"].get_feature_elt(si_elt)
         except exceptions.NotFound:
             log.warning("No <feature/> element found in result while expected")
             return
 
-        choosed_options = self.host.plugins["XEP-0020"].getChoosedOptions(
+        choosed_options = self.host.plugins["XEP-0020"].get_choosed_options(
             feature_elt, namespace=None
         )
         try:
@@ -350,7 +350,7 @@
         except StopIteration:
             pass
         else:
-            range_, range_offset, range_length = self._parseRange(file_elt, size)
+            range_, range_offset, range_length = self._parse_range(file_elt, size)
 
         if stream_method == self.host.plugins["XEP-0065"].NAMESPACE:
             plugin = self.host.plugins["XEP-0065"]
@@ -363,12 +363,12 @@
         stream_object = stream.FileStreamObject(
             self.host, client, filepath, uid=sid, size=size
         )
-        d = plugin.startStream(client, stream_object, client.jid,
+        d = plugin.start_stream(client, stream_object, client.jid,
                                jid.JID(iq_elt["from"]), sid)
-        d.addCallback(self._sendCb, client, sid, stream_object)
-        d.addErrback(self._sendEb, client, sid, stream_object)
+        d.addCallback(self._send_cb, client, sid, stream_object)
+        d.addErrback(self._send_eb, client, sid, stream_object)
 
-    def _fileEb(self, failure, filepath, sid, size, client):
+    def _file_eb(self, failure, filepath, sid, size, client):
         if failure.check(error.StanzaError):
             stanza_err = failure.value
             if stanza_err.code == "403" and stanza_err.condition == "forbidden":
@@ -376,20 +376,20 @@
                 log.info("File transfer refused by {}".format(from_s))
                 msg = D_("The contact {} has refused your file").format(from_s)
                 title = D_("File refused")
-                xml_tools.quickNote(self.host, client, msg, title, C.XMLUI_DATA_LVL_INFO)
+                xml_tools.quick_note(self.host, client, msg, title, C.XMLUI_DATA_LVL_INFO)
             else:
                 log.warning(_("Error during file transfer"))
                 msg = D_(
                     "Something went wrong during the file transfer session initialisation: {reason}"
                 ).format(reason=str(stanza_err))
                 title = D_("File transfer error")
-                xml_tools.quickNote(self.host, client, msg, title, C.XMLUI_DATA_LVL_ERROR)
+                xml_tools.quick_note(self.host, client, msg, title, C.XMLUI_DATA_LVL_ERROR)
         elif failure.check(exceptions.DataError):
             log.warning("Invalid stanza received")
         else:
             log.error("Error while proposing stream: {}".format(failure))
 
-    def _sendCb(self, __, client, sid, stream_object):
+    def _send_cb(self, __, client, sid, stream_object):
         log.info(
             _("transfer {sid} successfuly finished [{profile}]").format(
                 sid=sid, profile=client.profile
@@ -397,7 +397,7 @@
         )
         stream_object.close()
 
-    def _sendEb(self, failure, client, sid, stream_object):
+    def _send_eb(self, failure, client, sid, stream_object):
         log.warning(
             _("transfer {sid} failed [{profile}]: {reason}").format(
                 sid=sid, profile=client.profile, reason=str(failure.value)