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

224
sat/plugins/plugin_xep_0346.py
View file

@ -61,81 +61,81 @@ class PubsubSchema(object):
self.host = host
self._p = self.host.plugins["XEP-0060"]
self._i = self.host.plugins["IDENTITY"]
host.bridge.addMethod(
"psSchemaGet",
host.bridge.add_method(
"ps_schema_get",
".plugin",
in_sign="sss",
out_sign="s",
method=self._getSchema,
method=self._get_schema,
async_=True,
)
host.bridge.addMethod(
"psSchemaSet",
host.bridge.add_method(
"ps_schema_set",
".plugin",
in_sign="ssss",
out_sign="",
method=self._setSchema,
method=self._set_schema,
async_=True,
)
host.bridge.addMethod(
"psSchemaUIGet",
host.bridge.add_method(
"ps_schema_ui_get",
".plugin",
in_sign="sss",
out_sign="s",
method=lambda service, nodeIdentifier, profile_key: self._getUISchema(
method=lambda service, nodeIdentifier, profile_key: self._get_ui_schema(
service, nodeIdentifier, default_node=None, profile_key=profile_key),
async_=True,
)
host.bridge.addMethod(
"psSchemaDictGet",
host.bridge.add_method(
"ps_schema_dict_get",
".plugin",
in_sign="sss",
out_sign="s",
method=self._getSchemaDict,
method=self._get_schema_dict,
async_=True,
)
host.bridge.addMethod(
"psSchemaApplicationNSGet",
host.bridge.add_method(
"ps_schema_application_ns_get",
".plugin",
in_sign="s",
out_sign="s",
method=self.getApplicationNS,
method=self.get_application_ns,
)
host.bridge.addMethod(
"psSchemaTemplateNodeGet",
host.bridge.add_method(
"ps_schema_template_node_get",
".plugin",
in_sign="s",
out_sign="s",
method=self.getTemplateNS,
method=self.get_template_ns,
)
host.bridge.addMethod(
"psSchemaSubmittedNodeGet",
host.bridge.add_method(
"ps_schema_submitted_node_get",
".plugin",
in_sign="s",
out_sign="s",
method=self.getSubmittedNS,
method=self.get_submitted_ns,
)
host.bridge.addMethod(
"psItemsFormGet",
host.bridge.add_method(
"ps_items_form_get",
".plugin",
in_sign="ssssiassss",
out_sign="(asa{ss})",
method=self._getDataFormItems,
method=self._get_data_form_items,
async_=True,
)
host.bridge.addMethod(
"psItemFormSend",
host.bridge.add_method(
"ps_item_form_send",
".plugin",
in_sign="ssa{sas}ssa{ss}s",
out_sign="s",
method=self._sendDataFormItem,
method=self._send_data_form_item,
async_=True,
)
def getHandler(self, client):
def get_handler(self, client):
return SchemaHandler()
def getApplicationNS(self, namespace):
def get_application_ns(self, namespace):
"""Retrieve application namespace, i.e. namespace without FDP prefix"""
if namespace.startswith(SUBMITTED_PREFIX):
namespace = namespace[len(SUBMITTED_PREFIX):]
@ -143,28 +143,28 @@ class PubsubSchema(object):
namespace = namespace[len(TEMPLATE_PREFIX):]
return namespace
def getTemplateNS(self, namespace: str) -> str:
def get_template_ns(self, namespace: str) -> str:
"""Returns node used for data template (i.e. schema)"""
app_ns = self.getApplicationNS(namespace)
app_ns = self.get_application_ns(namespace)
return f"{TEMPLATE_PREFIX}{app_ns}"
def getSubmittedNS(self, namespace: str) -> str:
def get_submitted_ns(self, namespace: str) -> str:
"""Returns node to use to submit forms"""
return f"{SUBMITTED_PREFIX}{self.getApplicationNS(namespace)}"
return f"{SUBMITTED_PREFIX}{self.get_application_ns(namespace)}"
def _getSchemaBridgeCb(self, schema_elt):
def _get_schema_bridge_cb(self, schema_elt):
if schema_elt is None:
return ""
return schema_elt.toXml()
def _getSchema(self, service, nodeIdentifier, profile_key=C.PROF_KEY_NONE):
client = self.host.getClient(profile_key)
def _get_schema(self, service, nodeIdentifier, profile_key=C.PROF_KEY_NONE):
client = self.host.get_client(profile_key)
service = None if not service else jid.JID(service)
d = defer.ensureDeferred(self.getSchema(client, service, nodeIdentifier))
d.addCallback(self._getSchemaBridgeCb)
d = defer.ensureDeferred(self.get_schema(client, service, nodeIdentifier))
d.addCallback(self._get_schema_bridge_cb)
return d
async def getSchema(self, client, service, nodeIdentifier):
async def get_schema(self, client, service, nodeIdentifier):
"""retrieve PubSub node schema
@param service(jid.JID, None): jid of PubSub service
@ -173,9 +173,9 @@ class PubsubSchema(object):
@return (domish.Element, None): schema (<x> element)
None if no schema has been set on this node
"""
app_ns = self.getApplicationNS(nodeIdentifier)
app_ns = self.get_application_ns(nodeIdentifier)
node_id = f"{TEMPLATE_PREFIX}{app_ns}"
items_data = await self._p.getItems(client, service, node_id, max_items=1)
items_data = await self._p.get_items(client, service, node_id, max_items=1)
try:
schema = next(items_data[0][0].elements(data_form.NS_X_DATA, 'x'))
except IndexError:
@ -188,7 +188,7 @@ class PubsubSchema(object):
schema = None
return schema
async def getSchemaForm(self, client, service, nodeIdentifier, schema=None,
async def get_schema_form(self, client, service, nodeIdentifier, schema=None,
form_type="form", copy_form=True):
"""Get data form from node's schema
@ -200,13 +200,13 @@ class PubsubSchema(object):
if None, it will be retrieved from node (imply one additional XMPP request)
@param form_type(unicode): type of the form
@param copy_form(bool): if True and if schema is already a data_form.Form, will deep copy it before returning
needed when the form is reused and it will be modified (e.g. in sendDataFormItem)
needed when the form is reused and it will be modified (e.g. in send_data_form_item)
@return(data_form.Form): data form
the form should not be modified if copy_form is not set
"""
if schema is None:
log.debug(_("unspecified schema, we need to request it"))
schema = await self.getSchema(client, service, nodeIdentifier)
schema = await self.get_schema(client, service, nodeIdentifier)
if schema is None:
raise exceptions.DataError(
_(
@ -234,43 +234,43 @@ class PubsubSchema(object):
form.formType = form_type
return form
def schema2XMLUI(self, schema_elt):
def schema_2_xmlui(self, schema_elt):
form = data_form.Form.fromElement(schema_elt)
xmlui = xml_tools.dataForm2XMLUI(form, "")
xmlui = xml_tools.data_form_2_xmlui(form, "")
return xmlui
def _getUISchema(self, service, nodeIdentifier, default_node=None,
def _get_ui_schema(self, service, nodeIdentifier, default_node=None,
profile_key=C.PROF_KEY_NONE):
if not nodeIdentifier:
if not default_node:
raise ValueError(_("nodeIndentifier needs to be set"))
nodeIdentifier = default_node
client = self.host.getClient(profile_key)
client = self.host.get_client(profile_key)
service = None if not service else jid.JID(service)
d = self.getUISchema(client, service, nodeIdentifier)
d = self.get_ui_schema(client, service, nodeIdentifier)
d.addCallback(lambda xmlui: xmlui.toXml())
return d
def getUISchema(self, client, service, nodeIdentifier):
d = defer.ensureDeferred(self.getSchema(client, service, nodeIdentifier))
d.addCallback(self.schema2XMLUI)
def get_ui_schema(self, client, service, nodeIdentifier):
d = defer.ensureDeferred(self.get_schema(client, service, nodeIdentifier))
d.addCallback(self.schema_2_xmlui)
return d
def _setSchema(self, service, nodeIdentifier, schema, profile_key=C.PROF_KEY_NONE):
client = self.host.getClient(profile_key)
def _set_schema(self, service, nodeIdentifier, schema, profile_key=C.PROF_KEY_NONE):
client = self.host.get_client(profile_key)
service = None if not service else jid.JID(service)
schema = generic.parseXml(schema.encode())
return defer.ensureDeferred(
self.setSchema(client, service, nodeIdentifier, schema)
self.set_schema(client, service, nodeIdentifier, schema)
)
async def setSchema(self, client, service, nodeIdentifier, schema):
async def set_schema(self, client, service, nodeIdentifier, schema):
"""Set or replace PubSub node schema
@param schema(domish.Element, None): schema to set
None if schema need to be removed
"""
node_id = self.getTemplateNS(nodeIdentifier)
node_id = self.get_template_ns(nodeIdentifier)
node_options = {
self._p.OPT_ACCESS_MODEL: self._p.ACCESS_OPEN,
self._p.OPT_PERSIST_ITEMS: 1,
@ -279,17 +279,17 @@ class PubsubSchema(object):
self._p.OPT_SEND_ITEM_SUBSCRIBE: 1,
self._p.OPT_PUBLISH_MODEL: self._p.PUBLISH_MODEL_PUBLISHERS,
}
await self._p.createIfNewNode(client, service, node_id, node_options)
await self._p.sendItem(client, service, node_id, schema, self._p.ID_SINGLETON)
await self._p.create_if_new_node(client, service, node_id, node_options)
await self._p.send_item(client, service, node_id, schema, self._p.ID_SINGLETON)
def _getSchemaDict(self, service, nodeIdentifier, profile):
def _get_schema_dict(self, service, nodeIdentifier, profile):
service = None if not service else jid.JID(service)
client = self.host.getClient(profile)
d = defer.ensureDeferred(self.getSchemaDict(client, service, nodeIdentifier))
client = self.host.get_client(profile)
d = defer.ensureDeferred(self.get_schema_dict(client, service, nodeIdentifier))
d.addCallback(data_format.serialise)
return d
async def getSchemaDict(
async def get_schema_dict(
self,
client: SatXMPPEntity,
service: Optional[jid.JID],
@ -298,13 +298,13 @@ class PubsubSchema(object):
The dictionary is made so it can be easily serialisable
"""
schema_form = await self.getSchemaForm(client, service, nodeIdentifier)
return xml_tools.dataForm2dataDict(schema_form)
schema_form = await self.get_schema_form(client, service, nodeIdentifier)
return xml_tools.data_form_2_data_dict(schema_form)
def _getDataFormItems(self, form_ns="", service="", node="", schema="", max_items=10,
def _get_data_form_items(self, form_ns="", service="", node="", schema="", max_items=10,
item_ids=None, sub_id=None, extra="",
profile_key=C.PROF_KEY_NONE):
client = self.host.getClient(profile_key)
client = self.host.get_client(profile_key)
service = jid.JID(service) if service else None
if not node:
raise exceptions.DataError(_("empty node is not allowed"))
@ -313,9 +313,9 @@ class PubsubSchema(object):
else:
schema = None
max_items = None if max_items == C.NO_LIMIT else max_items
extra = self._p.parseExtra(data_format.deserialise(extra))
extra = self._p.parse_extra(data_format.deserialise(extra))
d = defer.ensureDeferred(
self.getDataFormItems(
self.get_data_form_items(
client,
service,
node,
@ -328,10 +328,10 @@ class PubsubSchema(object):
form_ns=form_ns or None,
)
)
d.addCallback(self._p.transItemsData)
d.addCallback(self._p.trans_items_data)
return d
async def getDataFormItems(self, client, service, nodeIdentifier, schema=None,
async def get_data_form_items(self, client, service, nodeIdentifier, schema=None,
max_items=None, item_ids=None, sub_id=None, rsm_request=None,
extra=None, default_node=None, form_ns=None, filters=None):
"""Get items known as being data forms, and convert them to XMLUI
@ -341,8 +341,8 @@ class PubsubSchema(object):
@param default_node(unicode): node to use if nodeIdentifier is None or empty
@param form_ns (unicode, None): namespace of the form
None to accept everything, even if form has no namespace
@param filters(dict, None): same as for xml_tools.dataFormResult2XMLUI
other parameters as the same as for [getItems]
@param filters(dict, None): same as for xml_tools.data_form_result_2_xmlui
other parameters as the same as for [get_items]
@return (list[unicode]): XMLUI of the forms
if an item is invalid (not corresponding to form_ns or not a data_form)
it will be skipped
@ -354,12 +354,12 @@ class PubsubSchema(object):
_("default_node must be set if nodeIdentifier is not set")
)
nodeIdentifier = default_node
submitted_ns = self.getSubmittedNS(nodeIdentifier)
submitted_ns = self.get_submitted_ns(nodeIdentifier)
# we need the initial form to get options of fields when suitable
schema_form = await self.getSchemaForm(
schema_form = await self.get_schema_form(
client, service, nodeIdentifier, schema, form_type="result", copy_form=False
)
items_data = await self._p.getItems(
items_data = await self._p.get_items(
client,
service,
submitted_ns,
@ -391,7 +391,7 @@ class PubsubSchema(object):
pass
else:
prepend.append(("jid", publisher, "publisher"))
xmlui = xml_tools.dataFormResult2XMLUI(
xmlui = xml_tools.data_form_result_2_xmlui(
form,
schema_form,
# FIXME: conflicts with schema (i.e. if "id" or "publisher" already exists)
@ -404,16 +404,16 @@ class PubsubSchema(object):
break
return (items_xmlui, metadata)
def _sendDataFormItem(self, service, nodeIdentifier, values, schema=None,
def _send_data_form_item(self, service, nodeIdentifier, values, schema=None,
item_id=None, extra=None, profile_key=C.PROF_KEY_NONE):
client = self.host.getClient(profile_key)
client = self.host.get_client(profile_key)
service = None if not service else jid.JID(service)
if schema:
schema = generic.parseXml(schema.encode("utf-8"))
else:
schema = None
d = defer.ensureDeferred(
self.sendDataFormItem(
self.send_data_form_item(
client,
service,
nodeIdentifier,
@ -427,7 +427,7 @@ class PubsubSchema(object):
d.addCallback(lambda ret: ret or "")
return d
async def sendDataFormItem(
async def send_data_form_item(
self, client, service, nodeIdentifier, values, schema=None, item_id=None,
extra=None, deserialise=False):
"""Publish an item as a dataform when we know that there is a schema
@ -439,13 +439,13 @@ class PubsubSchema(object):
Schema is needed to construct data form to publish
@param deserialise(bool): if True, data are list of unicode and must be
deserialized according to expected type.
This is done in this method and not directly in _sendDataFormItem because we
This is done in this method and not directly in _send_data_form_item because we
need to know the data type which is in the form, not availablable in
_sendDataFormItem
other parameters as the same as for [self._p.sendItem]
_send_data_form_item
other parameters as the same as for [self._p.send_item]
@return (unicode): id of the created item
"""
form = await self.getSchemaForm(
form = await self.get_schema_form(
client, service, nodeIdentifier, schema, form_type="submit"
)
@ -469,7 +469,7 @@ class PubsubSchema(object):
values_list = list(
itertools.chain(*[v.splitlines() for v in values_list])
)
elif xml_tools.isXHTMLField(field):
elif xml_tools.is_xhtml_field(field):
values_list = [generic.parseXml(v.encode("utf-8"))
for v in values_list]
elif "jid" in (field.fieldType or ""):
@ -505,14 +505,14 @@ class PubsubSchema(object):
field.values = values_list
return await self._p.sendItem(
return await self._p.send_item(
client, service, nodeIdentifier, form.toElement(), item_id, extra
)
## filters ##
# filters useful for data form to XMLUI conversion #
def valueOrPublisherFilter(self, form_xmlui, widget_type, args, kwargs):
def value_or_publisher_filter(self, form_xmlui, widget_type, args, kwargs):
"""Replace missing value by publisher's user part"""
if not args[0]:
# value is not filled: we use user part of publisher (if we have it)
@ -524,7 +524,7 @@ class PubsubSchema(object):
args[0] = publisher.user.capitalize()
return widget_type, args, kwargs
def textbox2ListFilter(self, form_xmlui, widget_type, args, kwargs):
def textbox_2_list_filter(self, form_xmlui, widget_type, args, kwargs):
"""Split lines of a textbox in a list
main use case is using a textbox for labels
@ -540,7 +540,7 @@ class PubsubSchema(object):
}
return widget_type, args, kwargs
def dateFilter(self, form_xmlui, widget_type, args, kwargs):
def date_filter(self, form_xmlui, widget_type, args, kwargs):
"""Convert a string with a date to a unix timestamp"""
if widget_type != "string" or not args[0]:
return widget_type, args, kwargs
@ -553,27 +553,27 @@ class PubsubSchema(object):
## Helper methods ##
def prepareBridgeGet(self, service, node, max_items, sub_id, extra, profile_key):
def prepare_bridge_get(self, service, node, max_items, sub_id, extra, profile_key):
"""Parse arguments received from bridge *Get methods and return higher level data
@return (tuple): (client, service, node, max_items, extra, sub_id) usable for
internal methods
"""
client = self.host.getClient(profile_key)
client = self.host.get_client(profile_key)
service = jid.JID(service) if service else None
if not node:
node = None
max_items = None if max_items == C.NO_LIMIT else max_items
if not sub_id:
sub_id = None
extra = self._p.parseExtra(extra)
extra = self._p.parse_extra(extra)
return client, service, node, max_items, extra, sub_id
def _get(self, service="", node="", max_items=10, item_ids=None, sub_id=None,
extra="", default_node=None, form_ns=None, filters=None,
profile_key=C.PROF_KEY_NONE):
"""Bridge method to retrieve data from node with schema
"""bridge method to retrieve data from node with schema
this method is a helper so dependant plugins can use it directly
when adding *Get methods
@ -588,12 +588,12 @@ class PubsubSchema(object):
# have to modify them
if C.bool(extra.get("labels_as_list", C.BOOL_FALSE)):
filters = filters.copy()
filters["labels"] = self.textbox2ListFilter
client, service, node, max_items, extra, sub_id = self.prepareBridgeGet(
filters["labels"] = self.textbox_2_list_filter
client, service, node, max_items, extra, sub_id = self.prepare_bridge_get(
service, node, max_items, sub_id, extra, profile_key
)
d = defer.ensureDeferred(
self.getDataFormItems(
self.get_data_form_items(
client,
service,
node or None,
@ -607,17 +607,17 @@ class PubsubSchema(object):
filters=filters,
)
)
d.addCallback(self._p.transItemsData)
d.addCallback(self._p.trans_items_data)
d.addCallback(lambda data: data_format.serialise(data))
return d
def prepareBridgeSet(self, service, node, schema, item_id, extra, profile_key):
def prepare_bridge_set(self, service, node, schema, item_id, extra, profile_key):
"""Parse arguments received from bridge *Set methods and return higher level data
@return (tuple): (client, service, node, schema, item_id, extra) usable for
internal methods
"""
client = self.host.getClient(profile_key)
client = self.host.get_client(profile_key)
service = None if not service else jid.JID(service)
if schema:
schema = generic.parseXml(schema.encode("utf-8"))
@ -626,13 +626,13 @@ class PubsubSchema(object):
extra = data_format.deserialise(extra)
return client, service, node or None, schema, item_id or None, extra
async def copyMissingValues(self, client, service, node, item_id, form_ns, values):
async def copy_missing_values(self, client, service, node, item_id, form_ns, values):
"""Retrieve values existing in original item and missing in update
Existing item will be retrieve, and values not already specified in values will
be filled
@param service: same as for [XEP_0060.getItems]
@param node: same as for [XEP_0060.getItems]
@param service: same as for [XEP_0060.get_items]
@param node: same as for [XEP_0060.get_items]
@param item_id(unicode): id of the item to retrieve
@param form_ns (unicode, None): namespace of the form
@param values(dict): values to fill
@ -641,7 +641,7 @@ class PubsubSchema(object):
"""
try:
# we get previous item
items_data = await self._p.getItems(
items_data = await self._p.get_items(
client, service, node, item_ids=[item_id]
)
item_elt = items_data[0][0]
@ -666,12 +666,12 @@ class PubsubSchema(object):
def _set(self, service, node, values, schema=None, item_id=None, extra=None,
default_node=None, form_ns=None, fill_author=True,
profile_key=C.PROF_KEY_NONE):
"""Bridge method to set item in node with schema
"""bridge method to set item in node with schema
this method is a helper so dependant plugins can use it directly
when adding *Set methods
"""
client, service, node, schema, item_id, extra = self.prepareBridgeSet(
client, service, node, schema, item_id, extra = self.prepare_bridge_set(
service, node, schema, item_id, extra
)
d = defer.ensureDeferred(self.set(
@ -701,13 +701,13 @@ class PubsubSchema(object):
'created' and 'updated' will be forced to current time:
- 'created' is set if item_id is None, i.e. if it's a new ticket
- 'updated' is set everytime
@param extra(dict, None): same as for [XEP-0060.sendItem] with additional keys:
@param extra(dict, None): same as for [XEP-0060.send_item] with additional keys:
- update(bool): if True, get previous item data to merge with current one
if True, item_id must be set
@param form_ns (unicode, None): namespace of the form
needed when an update is done
@param default_node(unicode, None): value to use if node is not set
other arguments are same as for [self._s.sendDataFormItem]
other arguments are same as for [self._s.send_data_form_item]
@return (unicode): id of the created item
"""
if extra is None:
@ -716,7 +716,7 @@ class PubsubSchema(object):
if default_node is None:
raise ValueError(_("default_node must be set if node is not set"))
node = default_node
node = self.getSubmittedNS(node)
node = self.get_submitted_ns(node)
now = utils.xmpp_date()
if not item_id:
values["created"] = now
@ -725,16 +725,16 @@ class PubsubSchema(object):
raise exceptions.DataError(
_('if extra["update"] is set, item_id must be set too')
)
await self.copyMissingValues(client, service, node, item_id, form_ns, values)
await self.copy_missing_values(client, service, node, item_id, form_ns, values)
values["updated"] = now
if fill_author:
if not values.get("author"):
id_data = await self._i.getIdentity(client, None, ["nicknames"])
id_data = await self._i.get_identity(client, None, ["nicknames"])
values["author"] = id_data['nicknames'][0]
if not values.get("author_jid"):
values["author_jid"] = client.jid.full()
item_id = await self.sendDataFormItem(
item_id = await self.send_data_form_item(
client, service, node, values, schema, item_id, extra, deserialise
)
return item_id