libervia-backend: sat/plugins/plugin_xep

comparison sat/plugins/plugin_xep_0060.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	9456852d3286
children

comparison

equal deleted inserted replaced

-:c4464d7ae97b
+:524856bd7b19
 self.host = host
 self._rsm = host.plugins.get("XEP-0059")
 self._mam = host.plugins.get("XEP-0313")
 self._node_cb = {}  # dictionnary of callbacks for node (key: node, value: list of callbacks)
 self.rt_sessions = sat_defer.RTDeferredSessions()
-host.bridge.addMethod(
+host.bridge.add_method(
-"psNodeCreate",
+"ps_node_create",
 ".plugin",
 in_sign="ssa{ss}s",
 out_sign="s",
-method=self._createNode,
+method=self._create_node,
 async_=True,
 )
-host.bridge.addMethod(
+host.bridge.add_method(
-"psNodeConfigurationGet",
+"ps_node_configuration_get",
 ".plugin",
 in_sign="sss",
 out_sign="a{ss}",
-method=self._getNodeConfiguration,
+method=self._get_node_configuration,
 async_=True,
 )
-host.bridge.addMethod(
+host.bridge.add_method(
-"psNodeConfigurationSet",
+"ps_node_configuration_set",
 ".plugin",
 in_sign="ssa{ss}s",
 out_sign="",
-method=self._setNodeConfiguration,
+method=self._set_node_configuration,
 async_=True,
 )
-host.bridge.addMethod(
+host.bridge.add_method(
-"psNodeAffiliationsGet",
+"ps_node_affiliations_get",
 ".plugin",
 in_sign="sss",
 out_sign="a{ss}",
-method=self._getNodeAffiliations,
+method=self._get_node_affiliations,
 async_=True,
 )
-host.bridge.addMethod(
+host.bridge.add_method(
-"psNodeAffiliationsSet",
+"ps_node_affiliations_set",
 ".plugin",
 in_sign="ssa{ss}s",
 out_sign="",
-method=self._setNodeAffiliations,
+method=self._set_node_affiliations,
 async_=True,
 )
-host.bridge.addMethod(
+host.bridge.add_method(
-"psNodeSubscriptionsGet",
+"ps_node_subscriptions_get",
 ".plugin",
 in_sign="sss",
 out_sign="a{ss}",
-method=self._getNodeSubscriptions,
+method=self._get_node_subscriptions,
 async_=True,
 )
-host.bridge.addMethod(
+host.bridge.add_method(
-"psNodeSubscriptionsSet",
+"ps_node_subscriptions_set",
 ".plugin",
 in_sign="ssa{ss}s",
 out_sign="",
-method=self._setNodeSubscriptions,
+method=self._set_node_subscriptions,
 async_=True,
 )
-host.bridge.addMethod(
+host.bridge.add_method(
-"psNodePurge",
+"ps_node_purge",
 ".plugin",
 in_sign="sss",
 out_sign="",
-method=self._purgeNode,
+method=self._purge_node,
 async_=True,
 )
-host.bridge.addMethod(
+host.bridge.add_method(
-"psNodeDelete",
+"ps_node_delete",
 ".plugin",
 in_sign="sss",
 out_sign="",
-method=self._deleteNode,
+method=self._delete_node,
 async_=True,
 )
-host.bridge.addMethod(
+host.bridge.add_method(
-"psNodeWatchAdd",
+"ps_node_watch_add",
 ".plugin",
 in_sign="sss",
 out_sign="",
 method=self._addWatch,
 async_=False,
 )
-host.bridge.addMethod(
+host.bridge.add_method(
-"psNodeWatchRemove",
+"ps_node_watch_remove",
 ".plugin",
 in_sign="sss",
 out_sign="",
-method=self._removeWatch,
+method=self._remove_watch,
 async_=False,
 )
-host.bridge.addMethod(
+host.bridge.add_method(
-"psAffiliationsGet",
+"ps_affiliations_get",
 ".plugin",
 in_sign="sss",
 out_sign="a{ss}",
-method=self._getAffiliations,
+method=self._get_affiliations,
 async_=True,
 )
-host.bridge.addMethod(
+host.bridge.add_method(
-"psItemsGet",
+"ps_items_get",
 ".plugin",
 in_sign="ssiassss",
 out_sign="s",
-method=self._getItems,
+method=self._get_items,
 async_=True,
 )
-host.bridge.addMethod(
+host.bridge.add_method(
-"psItemSend",
+"ps_item_send",
 ".plugin",
 in_sign="ssssss",
 out_sign="s",
-method=self._sendItem,
+method=self._send_item,
 async_=True,
 )
-host.bridge.addMethod(
+host.bridge.add_method(
-"psItemsSend",
+"ps_items_send",
 ".plugin",
 in_sign="ssasss",
 out_sign="as",
-method=self._sendItems,
+method=self._send_items,
 async_=True,
 )
-host.bridge.addMethod(
+host.bridge.add_method(
-"psItemRetract",
+"ps_item_retract",
 ".plugin",
 in_sign="sssbs",
 out_sign="",
-method=self._retractItem,
+method=self._retract_item,
 async_=True,
 )
-host.bridge.addMethod(
+host.bridge.add_method(
-"psItemsRetract",
+"ps_items_retract",
 ".plugin",
 in_sign="ssasbs",
 out_sign="",
-method=self._retractItems,
+method=self._retract_items,
 async_=True,
 )
-host.bridge.addMethod(
+host.bridge.add_method(
-"psItemRename",
+"ps_item_rename",
 ".plugin",
 in_sign="sssss",
 out_sign="",
-method=self._renameItem,
+method=self._rename_item,
 async_=True,
 )
-host.bridge.addMethod(
+host.bridge.add_method(
-"psSubscribe",
+"ps_subscribe",
 ".plugin",
 in_sign="ssss",
 out_sign="s",
 method=self._subscribe,
 async_=True,
 )
-host.bridge.addMethod(
+host.bridge.add_method(
-"psUnsubscribe",
+"ps_unsubscribe",
 ".plugin",
 in_sign="sss",
 out_sign="",
 method=self._unsubscribe,
 async_=True,
 )
-host.bridge.addMethod(
+host.bridge.add_method(
-"psSubscriptionsGet",
+"ps_subscriptions_get",
 ".plugin",
 in_sign="sss",
 out_sign="s",
 method=self._subscriptions,
 async_=True,
 )
-host.bridge.addMethod(
+host.bridge.add_method(
-"psSubscribeToMany",
+"ps_subscribe_to_many",
 ".plugin",
 in_sign="a(ss)sa{ss}s",
 out_sign="s",
-method=self._subscribeToMany,
+method=self._subscribe_to_many,
 )
-host.bridge.addMethod(
+host.bridge.add_method(
-"psGetSubscribeRTResult",
+"ps_get_subscribe_rt_result",
 ".plugin",
 in_sign="ss",
 out_sign="(ua(sss))",
-method=self._manySubscribeRTResult,
+method=self._many_subscribe_rt_result,
 async_=True,
 )
-host.bridge.addMethod(
+host.bridge.add_method(
-"psGetFromMany",
+"ps_get_from_many",
 ".plugin",
 in_sign="a(ss)iss",
 out_sign="s",
-method=self._getFromMany,
+method=self._get_from_many,
 )
-host.bridge.addMethod(
+host.bridge.add_method(
-"psGetFromManyRTResult",
+"ps_get_from_many_rt_result",
 ".plugin",
 in_sign="ss",
 out_sign="(ua(sssasa{ss}))",
-method=self._getFromManyRTResult,
+method=self._get_from_many_rt_result,
 async_=True,
 )
 #  high level observer method
-host.bridge.addSignal(
+host.bridge.add_signal(
-"psEvent", ".plugin", signature="ssssss"
+"ps_event", ".plugin", signature="ssssss"
 )  # args: category, service(jid), node, type (C.PS_ITEMS, C.PS_DELETE), data, profile
 # low level observer method, used if service/node is in watching list (see psNodeWatch* methods)
-host.bridge.addSignal(
+host.bridge.add_signal(
-"psEventRaw", ".plugin", signature="sssass"
+"ps_event_raw", ".plugin", signature="sssass"
 )  # args: service(jid), node, type (C.PS_ITEMS, C.PS_DELETE), list of item_xml, profile
-def getHandler(self, client):
+def get_handler(self, client):
 client.pubsub_client = SatPubSubClient(self.host, self)
 return client.pubsub_client
-async def profileConnected(self, client):
+async def profile_connected(self, client):
 client.pubsub_watching = set()
 try:
 client.pubsub_service = jid.JID(
-self.host.memory.getConfig("", "pubsub_service")
+self.host.memory.config_get("", "pubsub_service")
 )
 except RuntimeError:
 log.info(
 _(
 "Can't retrieve pubsub_service from conf, we'll use first one that "
 "we find"
 )
 )
-pubsub_services = await self.host.findServiceEntities(
+pubsub_services = await self.host.find_service_entities(
 client, "pubsub", "service"
 )
 for service_jid in pubsub_services:
-infos = await self.host.memory.disco.getInfos(client, service_jid)
+infos = await self.host.memory.disco.get_infos(client, service_jid)
 if not DEFAULT_PUBSUB_MIN_FEAT.issubset(infos.features):
 continue
 names = {(n or "").lower() for n in infos.identities.values()}
 if "libervia pubsub service" in names:
 # this is the name of Libervia's side project pubsub service, we know
 pubsub_service_str = (
 client.pubsub_service.full() if client.pubsub_service else "PEP"
 )
 log.info(f"default pubsub service: {pubsub_service_str}")
-def getFeatures(self, profile):
+def features_get(self, profile):
 try:
-client = self.host.getClient(profile)
+client = self.host.get_client(profile)
 except exceptions.ProfileNotSetError:
 return {}
 try:
 return {
 "service": client.pubsub_service.full()
 if client.pubsub_service is not None
 else ""
 }
 except AttributeError:
-if self.host.isConnected(profile):
+if self.host.is_connected(profile):
 log.debug("Profile is not connected, service is not checked yet")
 else:
 log.error("Service should be available !")
 return {}
-def parseExtra(self, extra):
+def parse_extra(self, extra):
 """Parse extra dictionnary
 used bridge's extra dictionnaries
 @param extra(dict): extra data used to configure request
 @return(Extra): filled Extra instance
 # rsm
 if self._rsm is None:
 rsm_request = None
 else:
-rsm_request = self._rsm.parseExtra(extra)
+rsm_request = self._rsm.parse_extra(extra)
 # mam
 if self._mam is None:
 mam_request = None
 else:
-mam_request = self._mam.parseExtra(extra, with_rsm=False)
+mam_request = self._mam.parse_extra(extra, with_rsm=False)
 if mam_request is not None:
 assert "mam" not in extra
 extra["mam"] = mam_request
 return Extra(rsm_request, extra)
-def addManagedNode(
+def add_managed_node(
 self,
 node: str,
 priority: int = 0,
 **kwargs: Callable
 ):
 assert event_name in C.PS_EVENTS
 cb_list = callbacks.setdefault(event_name, [])
 cb_list.append((cb, priority))
 cb_list.sort(key=lambda c: c[1], reverse=True)
-def removeManagedNode(self, node, *args):
+def remove_managed_node(self, node, *args):
 """Add a handler for a node
 @param node(unicode): node to monitor
 @param *args: callback(s) to remove
 """
 #     @param service (JID): target service
 #     @param nodeIdentifier (str): the parent node name (leave empty to retrieve first-level nodes)
 #     @param profile (str): %(doc_profile)s
 #     @return: deferred which fire a list of nodes
 #     """
-#     client = self.host.getClient(profile)
+#     client = self.host.get_client(profile)
 #     d = self.host.getDiscoItems(client, service, nodeIdentifier)
 #     d.addCallback(lambda result: [item.getAttribute('node') for item in result.toElement().children if item.hasAttribute('node')])
 #     return d
 # def listSubscribedNodes(self, service, nodeIdentifier='', filter_='subscribed', profile=C.PROF_KEY_NONE):
 #     """
 #     d = self.subscriptions(service, nodeIdentifier, profile_key=profile)
 #     d.addCallback(lambda subs: [sub.getAttribute('node') for sub in subs if sub.getAttribute('subscription') == filter_])
 #     return d
-def _sendItem(self, service, nodeIdentifier, payload, item_id=None, extra_ser="",
+def _send_item(self, service, nodeIdentifier, payload, item_id=None, extra_ser="",
 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)
 payload = xml_tools.parse(payload)
 extra = data_format.deserialise(extra_ser)
-d = defer.ensureDeferred(self.sendItem(
+d = defer.ensureDeferred(self.send_item(
 client, service, nodeIdentifier, payload, item_id or None, extra
 ))
 d.addCallback(lambda ret: ret or "")
 return d
-def _sendItems(self, service, nodeIdentifier, items, extra_ser=None,
+def _send_items(self, service, nodeIdentifier, items, extra_ser=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)
 try:
 items = [xml_tools.parse(item) for item in items]
 except Exception as e:
 raise exceptions.DataError(_("Can't parse items: {msg}").format(
 msg=e))
 extra = data_format.deserialise(extra_ser)
-return defer.ensureDeferred(self.sendItems(
+return defer.ensureDeferred(self.send_items(
 client, service, nodeIdentifier, items, extra=extra
 ))
-async def sendItem(
+async def send_item(
 self,
 client: SatXMPPClient,
 service: Union[jid.JID, None],
 nodeIdentifier: str,
 payload: domish.Element,
 assert isinstance(payload, domish.Element)
 item_elt = domish.Element((pubsub.NS_PUBSUB, 'item'))
 if item_id is not None:
 item_elt['id'] = item_id
 item_elt.addChild(payload)
-published_ids = await self.sendItems(
+published_ids = await self.send_items(
 client,
 service,
 nodeIdentifier,
 [item_elt],
 extra=extra
 try:
 return published_ids[0]
 except IndexError:
 return item_id
-async def sendItems(
+async def send_items(
 self,
 client: SatXMPPEntity,
 service: Optional[jid.JID],
 nodeIdentifier: str,
 items: List[domish.Element],
 """
 if sender is None:
 sender = client.jid
 if extra is None:
 extra = {}
-if not await self.host.trigger.asyncPoint(
+if not await self.host.trigger.async_point(
 "XEP-0060_publish", client, service, nodeIdentifier, items, options, sender,
 extra
 ):
 return extra["iq_result_elt"]
 iq_result_elt = await client.pubsub_client.publish(
 service, nodeIdentifier, items, sender,
 options=options
 )
 return iq_result_elt
-def _unwrapMAMMessage(self, message_elt):
+def _unwrap_mam_message(self, message_elt):
 try:
 item_elt = reduce(
 lambda elt, ns_name: next(elt.elements(*ns_name)),
 (message_elt,
 (mam.NS_MAM, "result"),
 ))
 except StopIteration:
 raise exceptions.DataError("Can't find Item in MAM message element")
 return item_elt
-def serialiseItems(self, items_data):
+def serialise_items(self, items_data):
 items, metadata = items_data
 metadata['items'] = items
 return data_format.serialise(metadata)
-def _getItems(self, service="", node="", max_items=10, item_ids=None, sub_id=None,
+def _get_items(self, service="", node="", max_items=10, item_ids=None, sub_id=None,
 extra="", profile_key=C.PROF_KEY_NONE):
 """Get items from pubsub node
 @param max_items(int): maximum number of item to get, C.NO_LIMIT for no limit
 """
-client = self.host.getClient(profile_key)
+client = self.host.get_client(profile_key)
 service = jid.JID(service) if service else None
 max_items = None if max_items == C.NO_LIMIT else max_items
-extra = self.parseExtra(data_format.deserialise(extra))
+extra = self.parse_extra(data_format.deserialise(extra))
-d = defer.ensureDeferred(self.getItems(
+d = defer.ensureDeferred(self.get_items(
 client,
 service,
 node,
 max_items,
 item_ids,
 sub_id or None,
 extra.rsm_request,
 extra.extra,
 ))
-d.addCallback(self.transItemsData)
+d.addCallback(self.trans_items_data)
-d.addCallback(self.serialiseItems)
+d.addCallback(self.serialise_items)
 return d
-async def getItems(
+async def get_items(
 self,
 client: SatXMPPEntity,
 service: Optional[jid.JID],
 node: str,
 max_items: Optional[int] = None,
 max_items = None
 if rsm_request and item_ids:
 raise ValueError("items_id can't be used with rsm")
 if extra is None:
 extra = {}
-cont, ret = await self.host.trigger.asyncReturnPoint(
+cont, ret = await self.host.trigger.async_return_point(
 "XEP-0060_getItems", client, service, node, max_items, item_ids, sub_id,
 rsm_request, extra
 )
 if not cont:
 return ret
 orderBy = extra.get(C.KEY_ORDER_BY),
 rsm_request = rsm_request,
 extra = extra
 ))
 # we have no MAM data here, so we add None
-d.addErrback(sat_defer.stanza2NotFound)
+d.addErrback(sat_defer.stanza_2_not_found)
 d.addTimeout(TIMEOUT, reactor)
 items, rsm_response = await d
 mam_response = None
 else:
 # if mam is requested, we have to do a totally different query
 raise exceptions.DataError("items_ids parameter can't be used with MAM")
 if mam_query.node is None:
 mam_query.node = node
 elif mam_query.node != node:
 raise exceptions.DataError(
-"MAM query node is incoherent with getItems's node"
+"MAM query node is incoherent with get_items's node"
 )
 if mam_query.rsm is None:
 mam_query.rsm = rsm_request
 else:
 if mam_query.rsm != rsm_request:
 raise exceptions.DataError(
 "Conflict between RSM request and MAM's RSM request"
 )
-items, rsm_response, mam_response = await self._mam.getArchives(
+items, rsm_response, mam_response = await self._mam.get_archives(
-client, mam_query, service, self._unwrapMAMMessage
+client, mam_query, service, self._unwrap_mam_message
 )
 try:
 subscribe = C.bool(extra["subscribe"])
 except KeyError:
 # TODO: handle mam_response
 service_jid = service if service else client.jid.userhostJID()
 metadata = {
 "service": service_jid,
 "node": node,
-"uri": self.getNodeURI(service_jid, node),
+"uri": self.get_node_uri(service_jid, node),
 }
 if mam_response is not None:
 # mam_response is a dict with "complete" and "stable" keys
 # we can put them directly in metadata
 metadata.update(mam_response)
 #         - key: a value in (a subset of) data.keys()
 #         - couple (list[dict], dict) containing:
 #             - list of items
 #             - RSM response data
 #     """
-#     client = self.host.getClient(profile_key)
+#     client = self.host.get_client(profile_key)
 #     found_nodes = yield self.listNodes(service, profile=client.profile)
 #     d_dict = {}
 #     for publisher, node in data.items():
 #         if node not in found_nodes:
 #             log.debug(u"Skip the items retrieval for [{node}]: node doesn't exist".format(node=node))
 #             continue  # avoid pubsub "item-not-found" error
-#         d_dict[publisher] = self.getItems(service, node, max_items, None, sub_id, rsm, client.profile)
+#         d_dict[publisher] = self.get_items(service, node, max_items, None, sub_id, rsm, client.profile)
 #     defer.returnValue(d_dict)
 def getOptions(self, service, nodeIdentifier, subscriber, subscriptionIdentifier=None,
 profile_key=C.PROF_KEY_NONE):
-client = self.host.getClient(profile_key)
+client = self.host.get_client(profile_key)
 return client.pubsub_client.getOptions(
 service, nodeIdentifier, subscriber, subscriptionIdentifier
 )
 def setOptions(self, service, nodeIdentifier, subscriber, options,
 subscriptionIdentifier=None, profile_key=C.PROF_KEY_NONE):
-client = self.host.getClient(profile_key)
+client = self.host.get_client(profile_key)
 return client.pubsub_client.setOptions(
 service, nodeIdentifier, subscriber, options, subscriptionIdentifier
 )
-def _createNode(self, service_s, nodeIdentifier, options, profile_key):
+def _create_node(self, service_s, nodeIdentifier, options, profile_key):
-client = self.host.getClient(profile_key)
+client = self.host.get_client(profile_key)
 return self.createNode(
 client, jid.JID(service_s) if service_s else None, nodeIdentifier, options
 )
 def createNode(
 """
 # TODO: if pubsub service doesn't hande publish-options, configure it in a second time
 return client.pubsub_client.createNode(service, nodeIdentifier, options)
 @defer.inlineCallbacks
-def createIfNewNode(self, client, service, nodeIdentifier, options=None):
+def create_if_new_node(self, client, service, nodeIdentifier, options=None):
 """Helper method similar to createNode, but will not fail in case of conflict"""
 try:
 yield self.createNode(client, service, nodeIdentifier, options)
 except error.StanzaError as e:
 if e.condition == "conflict":
 pass
 else:
 raise e
-def _getNodeConfiguration(self, service_s, nodeIdentifier, profile_key):
+def _get_node_configuration(self, service_s, nodeIdentifier, profile_key):
-client = self.host.getClient(profile_key)
+client = self.host.get_client(profile_key)
 d = self.getConfiguration(
 client, jid.JID(service_s) if service_s else None, nodeIdentifier
 )
 def serialize(form):
 formType="submit", formNamespace=pubsub.NS_PUBSUB_NODE_CONFIG
 )
 form.makeFields(options)
 return form
-def _setNodeConfiguration(self, service_s, nodeIdentifier, options, profile_key):
+def _set_node_configuration(self, service_s, nodeIdentifier, options, profile_key):
-client = self.host.getClient(profile_key)
+client = self.host.get_client(profile_key)
 d = self.setConfiguration(
 client, jid.JID(service_s) if service_s else None, nodeIdentifier, options
 )
 return d
 request.options = form
 d = request.send(client.xmlstream)
 return d
-def _getAffiliations(self, service_s, nodeIdentifier, profile_key):
+def _get_affiliations(self, service_s, nodeIdentifier, profile_key):
-client = self.host.getClient(profile_key)
+client = self.host.get_client(profile_key)
-d = self.getAffiliations(
+d = self.get_affiliations(
 client, jid.JID(service_s) if service_s else None, nodeIdentifier or None
 )
 return d
-def getAffiliations(self, client, service, nodeIdentifier=None):
+def get_affiliations(self, client, service, nodeIdentifier=None):
 """Retrieve affiliations of an entity
 @param nodeIdentifier(unicode, None): node to get affiliation from
 None to get all nodes affiliations for this service
 """
 d = request.send(client.xmlstream)
 d.addCallback(cb)
 return d
-def _getNodeAffiliations(self, service_s, nodeIdentifier, profile_key):
+def _get_node_affiliations(self, service_s, nodeIdentifier, profile_key):
-client = self.host.getClient(profile_key)
+client = self.host.get_client(profile_key)
-d = self.getNodeAffiliations(
+d = self.get_node_affiliations(
 client, jid.JID(service_s) if service_s else None, nodeIdentifier
 )
 d.addCallback(
 lambda affiliations: {j.full(): a for j, a in affiliations.items()}
 )
 return d
-def getNodeAffiliations(self, client, service, nodeIdentifier):
+def get_node_affiliations(self, client, service, nodeIdentifier):
 """Retrieve affiliations of a node owned by profile"""
 request = pubsub.PubSubRequest("affiliationsGet")
 request.recipient = service
 request.nodeIdentifier = nodeIdentifier
 d = request.send(client.xmlstream)
 d.addCallback(cb)
 return d
-def _setNodeAffiliations(
+def _set_node_affiliations(
 self, service_s, nodeIdentifier, affiliations, profile_key=C.PROF_KEY_NONE
 ):
-client = self.host.getClient(profile_key)
+client = self.host.get_client(profile_key)
 affiliations = {
 jid.JID(jid_): affiliation for jid_, affiliation in affiliations.items()
 }
-d = self.setNodeAffiliations(
+d = self.set_node_affiliations(
 client,
 jid.JID(service_s) if service_s else None,
 nodeIdentifier,
 affiliations,
 )
 return d
-def setNodeAffiliations(self, client, service, nodeIdentifier, affiliations):
+def set_node_affiliations(self, client, service, nodeIdentifier, affiliations):
 """Update affiliations of a node owned by profile
 @param affiliations(dict[jid.JID, unicode]): affiliations to set
 check https://xmpp.org/extensions/xep-0060.html#affiliations for a list of possible affiliations
 """
 request.nodeIdentifier = nodeIdentifier
 request.affiliations = affiliations
 d = request.send(client.xmlstream)
 return d
-def _purgeNode(self, service_s, nodeIdentifier, profile_key):
+def _purge_node(self, service_s, nodeIdentifier, profile_key):
-client = self.host.getClient(profile_key)
+client = self.host.get_client(profile_key)
-return self.purgeNode(
+return self.purge_node(
 client, jid.JID(service_s) if service_s else None, nodeIdentifier
 )
-def purgeNode(self, client, service, nodeIdentifier):
+def purge_node(self, client, service, nodeIdentifier):
-return client.pubsub_client.purgeNode(service, nodeIdentifier)
+return client.pubsub_client.purge_node(service, nodeIdentifier)
-def _deleteNode(self, service_s, nodeIdentifier, profile_key):
+def _delete_node(self, service_s, nodeIdentifier, profile_key):
-client = self.host.getClient(profile_key)
+client = self.host.get_client(profile_key)
 return self.deleteNode(
 client, jid.JID(service_s) if service_s else None, nodeIdentifier
 )
 def deleteNode(
 def _addWatch(self, service_s, node, profile_key):
 """watch modifications on a node
 This method should only be called from bridge
 """
-client = self.host.getClient(profile_key)
+client = self.host.get_client(profile_key)
 service = jid.JID(service_s) if service_s else client.jid.userhostJID()
 client.pubsub_watching.add((service, node))
-def _removeWatch(self, service_s, node, profile_key):
+def _remove_watch(self, service_s, node, profile_key):
 """remove a node watch
 This method should only be called from bridge
 """
-client = self.host.getClient(profile_key)
+client = self.host.get_client(profile_key)
 service = jid.JID(service_s) if service_s else client.jid.userhostJID()
 client.pubsub_watching.remove((service, node))
-def _retractItem(
+def _retract_item(
 self, service_s, nodeIdentifier, itemIdentifier, notify, profile_key
 ):
-return self._retractItems(
+return self._retract_items(
 service_s, nodeIdentifier, (itemIdentifier,), notify, profile_key
 )
-def _retractItems(
+def _retract_items(
 self, service_s, nodeIdentifier, itemIdentifiers, notify, profile_key
 ):
-client = self.host.getClient(profile_key)
+client = self.host.get_client(profile_key)
-return self.retractItems(
+return self.retract_items(
 client,
 jid.JID(service_s) if service_s else None,
 nodeIdentifier,
 itemIdentifiers,
 notify,
 )
-def retractItems(
+def retract_items(
 self,
 client: SatXMPPClient,
 service: jid.JID,
 nodeIdentifier: str,
 itemIdentifiers: Iterable[str],
 ) -> defer.Deferred:
 return client.pubsub_client.retractItems(
 service, nodeIdentifier, itemIdentifiers, notify=notify
 )
-def _renameItem(
+def _rename_item(
 self,
 service,
 node,
 item_id,
 new_id,
 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
-return defer.ensureDeferred(self.renameItem(
+return defer.ensureDeferred(self.rename_item(
 client, service, node, item_id, new_id
 ))
-async def renameItem(
+async def rename_item(
 self,
 client: SatXMPPEntity,
 service: Optional[jid.JID],
 node: str,
 item_id: str,
 """
 if not item_id or not new_id:
 raise ValueError("item_id and new_id must not be empty")
 # retract must be done last, so if something goes wrong, the exception will stop
 # the workflow and no accidental delete should happen
-item_elt = (await self.getItems(client, service, node, item_ids=[item_id]))[0][0]
+item_elt = (await self.get_items(client, service, node, item_ids=[item_id]))[0][0]
-await self.sendItem(client, service, node, item_elt.firstChildElement(), new_id)
+await self.send_item(client, service, node, item_elt.firstChildElement(), new_id)
-await self.retractItems(client, service, node, [item_id])
+await self.retract_items(client, service, node, [item_id])
 def _subscribe(self, service, nodeIdentifier, options, 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)
 d = defer.ensureDeferred(
 self.subscribe(
 client,
 service,
 options: Optional[dict] = None
 ) -> pubsub.Subscription:
 # TODO: reimplement a subscribtion cache, checking that we have not subscription before trying to subscribe
 if service is None:
 service = client.jid.userhostJID()
-cont, trigger_sub = await self.host.trigger.asyncReturnPoint(
+cont, trigger_sub = await self.host.trigger.async_return_point(
 "XEP-0060_subscribe", client, service, nodeIdentifier, sub_jid, options,
 )
 if not cont:
 return trigger_sub
 try:
 else:
 raise e
 return subscription
 def _unsubscribe(self, service, nodeIdentifier, 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)
 return defer.ensureDeferred(self.unsubscribe(client, service, nodeIdentifier))
 async def unsubscribe(
 self,
 nodeIdentifier: str,
 sub_jid: Optional[jid.JID] = None,
 subscriptionIdentifier: Optional[str] = None,
 sender: Optional[jid.JID] = None,
 ) -> None:
-if not await self.host.trigger.asyncPoint(
+if not await self.host.trigger.async_point(
 "XEP-0060_unsubscribe", client, service, nodeIdentifier, sub_jid,
 subscriptionIdentifier, sender
 ):
 return
 try:
 self,
 service="",
 nodeIdentifier="",
 profile_key=C.PROF_KEY_NONE
 ) -> str:
-client = self.host.getClient(profile_key)
+client = self.host.get_client(profile_key)
 service = None if not service else jid.JID(service)
 subs = await self.subscriptions(client, service, nodeIdentifier or None)
 return data_format.serialise(subs)
 async def subscriptions(
 @param service(jid.JID): PubSub service
 @param nodeIdentifier(unicode, None): node to check
 None to get all subscriptions
 """
-cont, ret = await self.host.trigger.asyncReturnPoint(
+cont, ret = await self.host.trigger.async_return_point(
 "XEP-0060_subscriptions", client, service, node
 )
 if not cont:
 return ret
 subs = await client.pubsub_client.subscriptions(service, node)
 ret.append(sub_dict)
 return ret
 ## misc tools ##
-def getNodeURI(self, service, node, item=None):
+def get_node_uri(self, service, node, item=None):
 """Return XMPP URI of a PubSub node
 @param service(jid.JID): PubSub service
 @param node(unicode): node
 @return (unicode): URI of the node
 ## methods to manage several stanzas/jids at once ##
 # generic #
-def getRTResults(
+def get_rt_results(
 self, session_id, on_success=None, on_error=None, profile=C.PROF_KEY_NONE
 ):
-return self.rt_sessions.getResults(session_id, on_success, on_error, profile)
+return self.rt_sessions.get_results(session_id, on_success, on_error, profile)
-def transItemsData(self, items_data, item_cb=lambda item: item.toXml()):
+def trans_items_data(self, items_data, item_cb=lambda item: item.toXml()):
-"""Helper method to transform result from [getItems]
+"""Helper method to transform result from [get_items]
 the items_data must be a tuple(list[domish.Element], dict[unicode, unicode])
-as returned by [getItems].
+as returned by [get_items].
-@param items_data(tuple): tuple returned by [getItems]
+@param items_data(tuple): tuple returned by [get_items]
 @param item_cb(callable): method to transform each item
 @return (tuple): a serialised form ready to go throught bridge
 """
 items, metadata = items_data
 items = [item_cb(item) for item in items]
 return (items, metadata)
-def transItemsDataD(self, items_data, item_cb):
+def trans_items_data_d(self, items_data, item_cb):
-"""Helper method to transform result from [getItems], deferred version
+"""Helper method to transform result from [get_items], deferred version
 the items_data must be a tuple(list[domish.Element], dict[unicode, unicode])
-as returned by [getItems]. metadata values are then casted to unicode and
+as returned by [get_items]. metadata values are then casted to unicode and
 each item is passed to items_cb.
 An errback is added to item_cb, and when it is fired the value is filtered from
 final items
-@param items_data(tuple): tuple returned by [getItems]
+@param items_data(tuple): tuple returned by [get_items]
 @param item_cb(callable): method to transform each item (must return a deferred)
 @return (tuple): a deferred which fire a dict which can be serialised to go
 throught bridge
 """
 items, metadata = items_data
 [i for i in parsed_items if i is not None],
 metadata
 ))
 return d
-def serDList(self, results, failure_result=None):
+def ser_d_list(self, results, failure_result=None):
 """Serialise a DeferredList result
 @param results: DeferredList results
 @param failure_result: value to use as value for failed Deferred
 (default: empty tuple)
 ]
 # subscribe #
 @utils.ensure_deferred
-async def _getNodeSubscriptions(
+async def _get_node_subscriptions(
 self,
 service: str,
 node: str,
 profile_key: str
 ) -> Dict[str, str]:
-client = self.host.getClient(profile_key)
+client = self.host.get_client(profile_key)
-subs = await self.getNodeSubscriptions(
+subs = await self.get_node_subscriptions(
 client, jid.JID(service) if service else None, node
 )
 return {j.full(): a for j, a in subs.items()}
-async def getNodeSubscriptions(
+async def get_node_subscriptions(
 self,
 client: SatXMPPEntity,
 service: Optional[jid.JID],
 nodeIdentifier: str
 ) -> Dict[jid.JID, str]:
 _("Invalid result: bad <subscription> element: {}").format(
 iq_elt.toXml
 )
 )
-def _setNodeSubscriptions(
+def _set_node_subscriptions(
 self, service_s, nodeIdentifier, subscriptions, profile_key=C.PROF_KEY_NONE
 ):
-client = self.host.getClient(profile_key)
+client = self.host.get_client(profile_key)
 subscriptions = {
 jid.JID(jid_): subscription
 for jid_, subscription in subscriptions.items()
 }
-d = self.setNodeSubscriptions(
+d = self.set_node_subscriptions(
 client,
 jid.JID(service_s) if service_s else None,
 nodeIdentifier,
 subscriptions,
 )
 return d
-def setNodeSubscriptions(self, client, service, nodeIdentifier, subscriptions):
+def set_node_subscriptions(self, client, service, nodeIdentifier, subscriptions):
 """Set or update subscriptions of a node owned by profile
 @param subscriptions(dict[jid.JID, unicode]): subscriptions to set
 check https://xmpp.org/extensions/xep-0060.html#substates for a list of possible subscriptions
 """
 for jid_, state in subscriptions.items()
 }
 d = request.send(client.xmlstream)
 return d
-def _manySubscribeRTResult(self, session_id, profile_key=C.PROF_KEY_DEFAULT):
+def _many_subscribe_rt_result(self, session_id, profile_key=C.PROF_KEY_DEFAULT):
 """Get real-time results for subcribeToManu session
 @param session_id: id of the real-time deferred session
 @param return (tuple): (remaining, results) where:
 - remaining is the number of still expected results
 - service: pubsub service
 - and node: pubsub node
 - failure(unicode): empty string in case of success, error message else
 @param profile_key: %(doc_profile_key)s
 """
-profile = self.host.getClient(profile_key).profile
+profile = self.host.get_client(profile_key).profile
-d = self.rt_sessions.getResults(
+d = self.rt_sessions.get_results(
 session_id,
 on_success=lambda result: "",
 on_error=lambda failure: str(failure.value),
 profile=profile,
 )
 ],
 )
 )
 return d
-def _subscribeToMany(
+def _subscribe_to_many(
 self, node_data, subscriber=None, options=None, profile_key=C.PROF_KEY_NONE
 ):
-return self.subscribeToMany(
+return self.subscribe_to_many(
 [(jid.JID(service), str(node)) for service, node in node_data],
 jid.JID(subscriber),
 options,
 profile_key,
 )
-def subscribeToMany(
+def subscribe_to_many(
 self, node_data, subscriber, options=None, profile_key=C.PROF_KEY_NONE
 ):
 """Subscribe to several nodes at once.
 @param node_data (iterable[tuple]): iterable of tuple (service, node) where:
 @param subscriber (jid.JID): optional subscription identifier.
 @param options (dict): subscription options
 @param profile_key (str): %(doc_profile_key)s
 @return (str): RT Deferred session id
 """
-client = self.host.getClient(profile_key)
+client = self.host.get_client(profile_key)
 deferreds = {}
 for service, node in node_data:
 deferreds[(service, node)] = defer.ensureDeferred(
 client.pubsub_client.subscribe(
 service, node, subscriber, options=options
 )
 )
-return self.rt_sessions.newSession(deferreds, client.profile)
+return self.rt_sessions.new_session(deferreds, client.profile)
 # found_nodes = yield self.listNodes(service, profile=client.profile)
 # subscribed_nodes = yield self.listSubscribedNodes(service, profile=client.profile)
 # d_list = []
 # for nodeIdentifier in (set(nodeIdentifiers) - set(subscribed_nodes)):
 #     if nodeIdentifier not in found_nodes:
 #     d_list.append(client.pubsub_client.subscribe(service, nodeIdentifier, sub_jid or client.pubsub_client.parent.jid.userhostJID(), options=options))
 # defer.returnValue(d_list)
 # get #
-def _getFromManyRTResult(self, session_id, profile_key=C.PROF_KEY_DEFAULT):
+def _get_from_many_rt_result(self, session_id, profile_key=C.PROF_KEY_DEFAULT):
-"""Get real-time results for getFromMany session
+"""Get real-time results for get_from_many session
 @param session_id: id of the real-time deferred session
 @param profile_key: %(doc_profile_key)s
 @param return (tuple): (remaining, results) where:
 - remaining is the number of still expected results
 - node (unicode): pubsub node
 - failure (unicode): empty string in case of success, error message else
 - items (list[s]): raw XML of items
 - metadata(dict): serialised metadata
 """
-profile = self.host.getClient(profile_key).profile
+profile = self.host.get_client(profile_key).profile
-d = self.rt_sessions.getResults(
+d = self.rt_sessions.get_results(
 session_id,
-on_success=lambda result: ("", self.transItemsData(result)),
+on_success=lambda result: ("", self.trans_items_data(result)),
 on_error=lambda failure: (str(failure.value) or UNSPECIFIED, ([], {})),
 profile=profile,
 )
 d.addCallback(
 lambda ret: (
 ],
 )
 )
 return d
-def _getFromMany(
+def _get_from_many(
 self, node_data, max_item=10, extra="", profile_key=C.PROF_KEY_NONE
 ):
 """
 @param max_item(int): maximum number of item to get, C.NO_LIMIT for no limit
 """
 max_item = None if max_item == C.NO_LIMIT else max_item
-extra = self.parseExtra(data_format.deserialise(extra))
+extra = self.parse_extra(data_format.deserialise(extra))
-return self.getFromMany(
+return self.get_from_many(
 [(jid.JID(service), str(node)) for service, node in node_data],
 max_item,
 extra.rsm_request,
 extra.extra,
 profile_key,
 )
-def getFromMany(self, node_data, max_item=None, rsm_request=None, extra=None,
+def get_from_many(self, node_data, max_item=None, rsm_request=None, extra=None,
 profile_key=C.PROF_KEY_NONE):
 """Get items from many nodes at once
 @param node_data (iterable[tuple]): iterable of tuple (service, node) where:
 - service (jid.JID) is the pubsub service
 @param max_items (int): optional limit on the number of retrieved items.
 @param rsm_request (RSMRequest): RSM request data
 @param profile_key (unicode): %(doc_profile_key)s
 @return (str): RT Deferred session id
 """
-client = self.host.getClient(profile_key)
+client = self.host.get_client(profile_key)
 deferreds = {}
 for service, node in node_data:
-deferreds[(service, node)] = defer.ensureDeferred(self.getItems(
+deferreds[(service, node)] = defer.ensureDeferred(self.get_items(
 client, service, node, max_item, rsm_request=rsm_request, extra=extra
 ))
-return self.rt_sessions.newSession(deferreds, client.profile)
+return self.rt_sessions.new_session(deferreds, client.profile)
 @implementer(disco.IDisco)
 class SatPubSubClient(rsm.PubSubClient):
 service, nodeIdentifier, maxItems, subscriptionIdentifier, sender,
 itemIdentifiers, orderBy, rsm_request
 )
 # items must be returned, thus this async point can't stop the workflow (but it
 # can modify returned items)
-await self.host.trigger.asyncPoint(
+await self.host.trigger.async_point(
 "XEP-0060_items", self.parent, service, nodeIdentifier, items, rsm_response,
 extra
 )
 return items, rsm_response
-def _getNodeCallbacks(self, node, event):
+def _get_node_callbacks(self, node, event):
 """Generate callbacks from given node and event
 @param node(unicode): node used for the item
 any registered node which prefix the node will match
 @param event(unicode): one of C.PS_ITEMS, C.PS_RETRACT, C.PS_DELETE
 for callback_data in callbacks_dict[event]:
 yield callback_data[0]
 except KeyError:
 continue
-async def _callNodeCallbacks(self, client, event: pubsub.ItemsEvent) -> None:
+async def _call_node_callbacks(self, client, event: pubsub.ItemsEvent) -> None:
 """Call sequencially event callbacks of a node
 Callbacks are called sequencially and not in parallel to be sure to respect
 priority (notably for plugin needing to get old items before they are modified or
 deleted from cache).
 """
-for callback in self._getNodeCallbacks(event.nodeIdentifier, C.PS_ITEMS):
+for callback in self._get_node_callbacks(event.nodeIdentifier, C.PS_ITEMS):
 try:
-await utils.asDeferred(callback, client, event)
+await utils.as_deferred(callback, client, event)
 except Exception as e:
 log.error(
 f"Error while running items event callback {callback}: {e}"
 )
 def itemsReceived(self, event):
 log.debug("Pubsub items received")
 client = self.parent
-defer.ensureDeferred(self._callNodeCallbacks(client, event))
+defer.ensureDeferred(self._call_node_callbacks(client, event))
 if (event.sender, event.nodeIdentifier) in client.pubsub_watching:
 raw_items = [i.toXml() for i in event.items]
-self.host.bridge.psEventRaw(
+self.host.bridge.ps_event_raw(
 event.sender.full(),
 event.nodeIdentifier,
 C.PS_ITEMS,
 raw_items,
 client.profile,
 )
 def deleteReceived(self, event):
 log.debug(("Publish node deleted"))
-for callback in self._getNodeCallbacks(event.nodeIdentifier, C.PS_DELETE):
+for callback in self._get_node_callbacks(event.nodeIdentifier, C.PS_DELETE):
-d = utils.asDeferred(callback, self.parent, event)
+d = utils.as_deferred(callback, self.parent, event)
 d.addErrback(lambda f: log.error(
 f"Error while running delete event callback {callback}: {f}"
 ))
 client = self.parent
 if (event.sender, event.nodeIdentifier) in client.pubsub_watching:
-self.host.bridge.psEventRaw(
+self.host.bridge.ps_event_raw(
 event.sender.full(), event.nodeIdentifier, C.PS_DELETE, [], client.profile
 )
 def purgeReceived(self, event):
 log.debug(("Publish node purged"))
-for callback in self._getNodeCallbacks(event.nodeIdentifier, C.PS_PURGE):
+for callback in self._get_node_callbacks(event.nodeIdentifier, C.PS_PURGE):
-d = utils.asDeferred(callback, self.parent, event)
+d = utils.as_deferred(callback, self.parent, event)
 d.addErrback(lambda f: log.error(
 f"Error while running purge event callback {callback}: {f}"
 ))
 client = self.parent
 if (event.sender, event.nodeIdentifier) in client.pubsub_watching:
-self.host.bridge.psEventRaw(
+self.host.bridge.ps_event_raw(
 event.sender.full(), event.nodeIdentifier, C.PS_PURGE, [], client.profile
 )
 def subscriptions(self, service, nodeIdentifier, sender=None):
 """Return the list of subscriptions to the given service and node.
 subs.append(subscription)
 return subs
 return d.addCallback(cb)
-def purgeNode(self, service, nodeIdentifier):
+def purge_node(self, service, nodeIdentifier):
 """Purge a node (i.e. delete all items from it)
 @param service(jid.JID, None): service to send the item to
 None to use PEP
 @param NodeIdentifier(unicode): PubSub node to use

Mercurial > libervia-backend

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