erebion/libervia-backend
Watch
1
0
Fork
You've already forked libervia-backend
 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

massive refactoring to switch from camelCase to snake_case:

Browse source 
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.
This commit is contained in:
Goffi 2023-04-08 13:54:42 +02:00
commit 6a6f15707a
1 changed files with 9945 additions and 9945 deletions
Download patch file Download diff file Expand all files Collapse all files

88
sat/plugins/plugin_xep_0096.py
View file

@ -64,18 +64,18 @@ class XEP_0096(object):
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 @@ class XEP_0096(object):
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 @@ class XEP_0096(object):
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 @@ class XEP_0096(object):
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 @@ class XEP_0096(object):
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 @@ class XEP_0096(object):
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 @@ class XEP_0096(object):
}
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 @@ class XEP_0096(object):
# 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 @@ class XEP_0096(object):
# 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 @@ class XEP_0096(object):
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 @@ class XEP_0096(object):
)
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 @@ class XEP_0096(object):
@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 @@ class XEP_0096(object):
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 @@ class XEP_0096(object):
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 @@ class XEP_0096(object):
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 @@ class XEP_0096(object):
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 @@ class XEP_0096(object):
)
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)