libervia-backend: sat/plugins/plugin_xep

comparison sat/plugins/plugin_xep_0277.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	78b5f356900c
children

comparison

equal deleted inserted replaced

-:c4464d7ae97b
+:524856bd7b19
 NS_ATOM = NS_ATOM
 def __init__(self, host):
 log.info(_("Microblogging plugin initialization"))
 self.host = host
-host.registerNamespace("microblog", NS_MICROBLOG)
+host.register_namespace("microblog", NS_MICROBLOG)
 self._p = self.host.plugins[
 "XEP-0060"
 ]  # this facilitate the access to pubsub plugin
 ps_cache = self.host.plugins.get("PUBSUB_CACHE")
 if ps_cache is not None:
-ps_cache.registerAnalyser(
+ps_cache.register_analyser(
 {
 "name": "XEP-0277",
 "node": NS_MICROBLOG,
 "namespace": NS_ATOM,
 "type": "blog",
 "to_sync": True,
 "parser": self.item_2_mb_data,
-"match_cb": self._cacheNodeMatchCb,
+"match_cb": self._cache_node_match_cb,
 }
 )
 self.rt_sessions = sat_defer.RTDeferredSessions()
-self.host.plugins["XEP-0060"].addManagedNode(
+self.host.plugins["XEP-0060"].add_managed_node(
-NS_MICROBLOG, items_cb=self._itemsReceived
+NS_MICROBLOG, items_cb=self._items_received
 )
-host.bridge.addMethod(
+host.bridge.add_method(
-"mbSend",
+"mb_send",
 ".plugin",
 in_sign="ssss",
 out_sign="s",
-method=self._mbSend,
+method=self._mb_send,
 async_=True,
 )
-host.bridge.addMethod(
+host.bridge.add_method(
-"mbRepeat",
+"mb_repeat",
 ".plugin",
 in_sign="sssss",
 out_sign="s",
-method=self._mbRepeat,
+method=self._mb_repeat,
 async_=True,
 )
-host.bridge.addMethod(
+host.bridge.add_method(
-"mbPreview",
+"mb_preview",
 ".plugin",
 in_sign="ssss",
 out_sign="s",
-method=self._mbPreview,
+method=self._mb_preview,
 async_=True,
 )
-host.bridge.addMethod(
+host.bridge.add_method(
-"mbRetract",
+"mb_retract",
 ".plugin",
 in_sign="ssss",
 out_sign="",
-method=self._mbRetract,
+method=self._mb_retract,
 async_=True,
 )
-host.bridge.addMethod(
+host.bridge.add_method(
-"mbGet",
+"mb_get",
 ".plugin",
 in_sign="ssiasss",
 out_sign="s",
-method=self._mbGet,
+method=self._mb_get,
 async_=True,
 )
-host.bridge.addMethod(
+host.bridge.add_method(
-"mbRename",
+"mb_rename",
 ".plugin",
 in_sign="sssss",
 out_sign="",
-method=self._mbRename,
+method=self._mb_rename,
 async_=True,
 )
-host.bridge.addMethod(
+host.bridge.add_method(
-"mbSetAccess",
+"mb_access_set",
 ".plugin",
 in_sign="ss",
 out_sign="",
-method=self.mbSetAccess,
+method=self.mb_access_set,
 async_=True,
 )
-host.bridge.addMethod(
+host.bridge.add_method(
-"mbSubscribeToMany",
+"mb_subscribe_to_many",
 ".plugin",
 in_sign="sass",
 out_sign="s",
-method=self._mbSubscribeToMany,
+method=self._mb_subscribe_to_many,
 )
-host.bridge.addMethod(
+host.bridge.add_method(
-"mbGetFromManyRTResult",
+"mb_get_from_many_rt_result",
 ".plugin",
 in_sign="ss",
 out_sign="(ua(sssasa{ss}))",
-method=self._mbGetFromManyRTResult,
+method=self._mb_get_from_many_rt_result,
 async_=True,
 )
-host.bridge.addMethod(
+host.bridge.add_method(
-"mbGetFromMany",
+"mb_get_from_many",
 ".plugin",
 in_sign="sasia{ss}s",
 out_sign="s",
-method=self._mbGetFromMany,
+method=self._mb_get_from_many,
 )
-host.bridge.addMethod(
+host.bridge.add_method(
-"mbGetFromManyWithCommentsRTResult",
+"mb_get_from_many_with_comments_rt_result",
 ".plugin",
 in_sign="ss",
 out_sign="(ua(sssa(sa(sssasa{ss}))a{ss}))",
-method=self._mbGetFromManyWithCommentsRTResult,
+method=self._mb_get_from_many_with_comments_rt_result,
 async_=True,
 )
-host.bridge.addMethod(
+host.bridge.add_method(
-"mbGetFromManyWithComments",
+"mb_get_from_many_with_comments",
 ".plugin",
 in_sign="sasiia{ss}a{ss}s",
 out_sign="s",
-method=self._mbGetFromManyWithComments,
+method=self._mb_get_from_many_with_comments,
 )
-host.bridge.addMethod(
+host.bridge.add_method(
-"mbIsCommentNode",
+"mb_is_comment_node",
 ".plugin",
 in_sign="s",
 out_sign="b",
-method=self.isCommentNode,
+method=self.is_comment_node,
 )
-def getHandler(self, client):
+def get_handler(self, client):
 return XEP_0277_handler()
-def _cacheNodeMatchCb(
+def _cache_node_match_cb(
 self,
 client: SatXMPPEntity,
 analyse: dict,
 ) -> None:
 """Check is analysed node is a comment and fill analyse accordingly"""
 if analyse["node"].startswith(NS_COMMENT_PREFIX):
 analyse["subtype"] = "comment"
-def _checkFeaturesCb(self, available):
+def _check_features_cb(self, available):
 return {"available": C.BOOL_TRUE}
-def _checkFeaturesEb(self, fail):
+def _check_features_eb(self, fail):
 return {"available": C.BOOL_FALSE}
-def getFeatures(self, profile):
+def features_get(self, profile):
-client = self.host.getClient(profile)
+client = self.host.get_client(profile)
-d = self.host.checkFeatures(client, [], identity=("pubsub", "pep"))
+d = self.host.check_features(client, [], identity=("pubsub", "pep"))
-d.addCallbacks(self._checkFeaturesCb, self._checkFeaturesEb)
+d.addCallbacks(self._check_features_cb, self._check_features_eb)
 return d
 ## plugin management methods ##
-def _itemsReceived(self, client, itemsEvent):
+def _items_received(self, client, itemsEvent):
 """Callback which manage items notifications (publish + retract)"""
-def manageItem(data, event):
+def manage_item(data, event):
-self.host.bridge.psEvent(
+self.host.bridge.ps_event(
 C.PS_MICROBLOG,
 itemsEvent.sender.full(),
 itemsEvent.nodeIdentifier,
 event,
 data_format.serialise(data),
 for item in itemsEvent.items:
 if item.name == C.PS_ITEM:
 # FIXME: service and node should be used here
 self.item_2_mb_data(client, item, None, None).addCallbacks(
-manageItem, lambda failure: None, (C.PS_PUBLISH,)
+manage_item, lambda failure: None, (C.PS_PUBLISH,)
 )
 elif item.name == C.PS_RETRACT:
-manageItem({"id": item["id"]}, C.PS_RETRACT)
+manage_item({"id": item["id"]}, C.PS_RETRACT)
 else:
 raise exceptions.InternalError("Invalid event value")
 ## data/item transformation ##
 _("Content of type XHTML must declare its namespace!")
 )
 )
 key = check_conflict("{}_xhtml".format(elem.name))
 data = data_elt.toXml()
-microblog_data[key] = yield self.host.plugins["TEXT_SYNTAXES"].cleanXHTML(
+microblog_data[key] = yield self.host.plugins["TEXT_SYNTAXES"].clean_xhtml(
 data
 )
 else:
 key = check_conflict(elem.name)
 microblog_data[key] = str(elem)
 # uri
 # FIXME: node should alway be set in the future, check FIXME in method signature
 if node is not None:
 microblog_data["node"] = node
-microblog_data['uri'] = xmpp_uri.buildXMPPUri(
+microblog_data['uri'] = xmpp_uri.build_xmpp_uri(
 "pubsub",
 path=service.full(),
 node=node,
 item=id_,
 )
 uri = href
 comments_data = {
 "uri": uri,
 }
 try:
-comment_service, comment_node = self.parseCommentUrl(uri)
+comment_service, comment_node = self.parse_comment_url(uri)
 except Exception as e:
 log.warning(f"Can't parse comments url: {e}")
 continue
 else:
 comments_data["service"] = comment_service.full()
 if not microblog_data.get("author_jid"):
 if publisher:
 microblog_data["author_jid"] = publisher
 microblog_data["author_jid_verified"] = True
 else:
-iq_elt = xml_tools.findAncestor(item_elt, "iq", C.NS_STREAM)
+iq_elt = xml_tools.find_ancestor(item_elt, "iq", C.NS_STREAM)
 microblog_data["author_jid"] = iq_elt["from"]
 microblog_data["author_jid_verified"] = False
 # categories
 categories = [
 if attr in mb_data:
 elem = entry_elt.addElement(elem_name)
 if type_:
 if type_ == "_rich":  # convert input from current syntax to XHTML
 xml_content = await synt.convert(
-mb_data[attr], synt.getCurrentSyntax(client.profile), "XHTML"
+mb_data[attr], synt.get_current_syntax(client.profile), "XHTML"
 )
 if f"{elem_name}_xhtml" in mb_data:
 raise failure.Failure(
 exceptions.DataError(
 _(
 if not url.startswith("http"):
 log.warning(f"non HTTP URL in attachment, ignoring: {attachment}")
 continue
 link_elt = entry_elt.addElement("link")
-# XXX: "uri" is set in self._manageComments if not already existing
+# XXX: "uri" is set in self._manage_comments if not already existing
 link_elt["href"] = url
 if attachment.get("external", False):
 # this is a link to an external data such as a website
 link_elt["rel"] = "related"
 else:
 category_elt["term"] = tag
 ## id ##
 entry_id = mb_data.get(
 "id",
-xmpp_uri.buildXMPPUri(
+xmpp_uri.build_xmpp_uri(
 "pubsub",
 path=service.full() if service is not None else client.jid.userhost(),
 node=node,
 item=item_id,
 ),
 entry_elt.addElement("id", content=entry_id)  #
 ## comments ##
 for comments_data in mb_data.get('comments', []):
 link_elt = entry_elt.addElement("link")
-# XXX: "uri" is set in self._manageComments if not already existing
+# XXX: "uri" is set in self._manage_comments if not already existing
 link_elt["href"] = comments_data["uri"]
 link_elt["rel"] = "replies"
 link_elt["title"] = "comments"
 if "repeated" in extra:
 return item_elt
 ## publish/preview ##
-def isCommentNode(self, node: str) -> bool:
+def is_comment_node(self, node: str) -> bool:
 """Indicate if the node is prefixed with comments namespace"""
 return node.startswith(NS_COMMENT_PREFIX)
-def getParentItem(self, item_id: str) -> str:
+def get_parent_item(self, item_id: str) -> str:
 """Return parent of a comment node
 @param item_id: a comment node
 """
-if not self.isCommentNode(item_id):
+if not self.is_comment_node(item_id):
 raise ValueError("This node is not a comment node")
 return item_id[len(NS_COMMENT_PREFIX):]
-def getCommentsNode(self, item_id):
+def get_comments_node(self, item_id):
 """Generate comment node
 @param item_id(unicode): id of the parent item
 @return (unicode): comment node to use
 """
 return f"{NS_COMMENT_PREFIX}{item_id}"
-def getCommentsService(self, client, parent_service=None):
+def get_comments_service(self, client, parent_service=None):
 """Get prefered PubSub service to create comment node
 @param pubsub_service(jid.JID, None): PubSub service of the parent item
 @param return((D)jid.JID, None): PubSub service to use
 """
 if parent_service.host == client.jid.host:
 #  it's our server, we use already found client.pubsub_service below
 pass
 else:
 # other server, let's try to find a non PEP service there
-d = self.host.findServiceEntity(
+d = self.host.find_service_entity(
 client, "pubsub", "service", parent_service
 )
 d.addCallback(lambda entity: entity or parent_service)
 else:
 # parent is already on a normal Pubsub service, we re-use it
 return defer.succeed(
 client.pubsub_service if client.pubsub_service is not None else parent_service
 )
-async def _manageComments(self, client, mb_data, service, node, item_id, access=None):
+async def _manage_comments(self, client, mb_data, service, node, item_id, access=None):
 """Check comments keys in mb_data and create comments node if necessary
 if a comments node metadata is set in the mb_data['comments'] list, it is used
 otherwise it is generated (if allow_comments is True).
 @param mb_data(dict): microblog mb_data
 comments_service = jid.JID(comments_data["service"])
 except KeyError:
 comments_service = None
 if uri:
-uri_service, uri_node = self.parseCommentUrl(uri)
+uri_service, uri_node = self.parse_comment_url(uri)
 if ((comments_node is not None and comments_node!=uri_node)
 or (comments_service is not None and comments_service!=uri_service)):
 raise ValueError(
 f"Incoherence between comments URI ({uri}) and comments_service "
 f"({comments_service}) or comments_node ({comments_node})")
 comments_data['service'] = comments_service = uri_service
 comments_data['node'] = comments_node = uri_node
 else:
 if not comments_node:
-comments_node = self.getCommentsNode(item_id)
+comments_node = self.get_comments_node(item_id)
 comments_data['node'] = comments_node
 if comments_service is None:
-comments_service = await self.getCommentsService(client, service)
+comments_service = await self.get_comments_service(client, service)
 if comments_service is None:
 comments_service = client.jid.userhostJID()
 comments_data['service'] = comments_service
-comments_data['uri'] = xmpp_uri.buildXMPPUri(
+comments_data['uri'] = xmpp_uri.build_xmpp_uri(
 "pubsub",
 path=comments_service.full(),
 node=comments_node,
 )
 else:
 raise e
 else:
 if access == self._p.ACCESS_WHITELIST:
 # for whitelist access we need to copy affiliations from parent item
-comments_affiliations = await self._p.getNodeAffiliations(
+comments_affiliations = await self._p.get_node_affiliations(
 client, service, node
 )
 # …except for "member", that we transform to publisher
 # because we wants members to be able to write to comments
 for jid_, affiliation in list(comments_affiliations.items()):
 if affiliation == "member":
 comments_affiliations[jid_] == "publisher"
-await self._p.setNodeAffiliations(
+await self._p.set_node_affiliations(
 client, comments_service, comments_node, comments_affiliations
 )
-def friendlyId(self, data):
+def friendly_id(self, data):
 """Generate a user friendly id from title or content"""
 # TODO: rich content should be converted to plain text
-id_base = regex.urlFriendlyText(
+id_base = regex.url_friendly_text(
 data.get('title')
 or data.get('title_rich')
 or data.get('content')
 or data.get('content_rich')
 or ''
 )
 return f"{id_base}-{token_urlsafe(3)}"
-def _mbSend(self, service, node, data, profile_key):
+def _mb_send(self, service, node, data, profile_key):
 service = jid.JID(service) if service else None
 node = node if node else NS_MICROBLOG
-client = self.host.getClient(profile_key)
+client = self.host.get_client(profile_key)
 data = data_format.deserialise(data)
 return defer.ensureDeferred(self.send(client, data, service, node))
 async def send(
 self,
 node = NS_MICROBLOG
 item_id = data.get("id")
 if item_id is None:
 if data.get("user_friendly_id", True):
-item_id = self.friendlyId(data)
+item_id = self.friendly_id(data)
 else:
 item_id = str(shortuuid.uuid())
 try:
-await self._manageComments(client, data, service, node, item_id, access=None)
+await self._manage_comments(client, data, service, node, item_id, access=None)
 except error.StanzaError:
 log.warning("Can't create comments node for item {}".format(item_id))
 item = await self.mb_data_2_entry_elt(client, data, item_id, service, node)
-if not await self.host.trigger.asyncPoint(
+if not await self.host.trigger.async_point(
 "XEP-0277_send", client, service, node, item, data
 ):
 return None
 extra = {}
 extra[key] = value
 await self._p.publish(client, service, node, [item], extra=extra)
 return item_id
-def _mbRepeat(
+def _mb_repeat(
 self,
 service_s: str,
 node: str,
 item: str,
 extra_s: str,
 profile_key: str
 ) -> defer.Deferred:
 service = jid.JID(service_s) if service_s else None
 node = node if node else NS_MICROBLOG
-client = self.host.getClient(profile_key)
+client = self.host.get_client(profile_key)
 extra = data_format.deserialise(extra_s)
 d = defer.ensureDeferred(
 self.repeat(client, item, service, node, extra)
 )
 # [repeat] can return None, and we always need a str
 """
 if service is None:
 service = client.jid.userhostJID()
 # we first get the post to repeat
-items, __ = await self._p.getItems(
+items, __ = await self._p.get_items(
 client,
 service,
 node,
 item_ids = [item]
 )
 try:
 next(author_elt.elements(NS_ATOM, "uri"))
 except StopIteration:
 entry_elt.addElement(
-"uri", content=xmpp_uri.buildXMPPUri(None, path=service.full())
+"uri", content=xmpp_uri.build_xmpp_uri(None, path=service.full())
 )
 # we add the link indicating that it's a repeated post
 link_elt = entry_elt.addElement("link")
 link_elt["rel"] = "via"
-link_elt["href"] = xmpp_uri.buildXMPPUri(
+link_elt["href"] = xmpp_uri.build_xmpp_uri(
 "pubsub", path=service.full(), node=node, item=item
 )
-return await self._p.sendItem(
+return await self._p.send_item(
 client,
 client.jid.userhostJID(),
 NS_MICROBLOG,
 entry_elt
 )
-def _mbPreview(self, service, node, data, profile_key):
+def _mb_preview(self, service, node, data, profile_key):
 service = jid.JID(service) if service else None
 node = node if node else NS_MICROBLOG
-client = self.host.getClient(profile_key)
+client = self.host.get_client(profile_key)
 data = data_format.deserialise(data)
 d = defer.ensureDeferred(self.preview(client, data, service, node))
 d.addCallback(data_format.serialise)
 return d
 return await self.item_2_mb_data(client, item_elt, service, node)
 ## retract ##
-def _mbRetract(self, service_jid_s, nodeIdentifier, itemIdentifier, profile_key):
+def _mb_retract(self, service_jid_s, nodeIdentifier, itemIdentifier, profile_key):
-"""Call self._p._retractItem, but use default node if node is empty"""
+"""Call self._p._retract_item, but use default node if node is empty"""
-return self._p._retractItem(
+return self._p._retract_item(
 service_jid_s,
 nodeIdentifier or NS_MICROBLOG,
 itemIdentifier,
 True,
 profile_key,
 )
 ## get ##
-def _mbGetSerialise(self, data):
+def _mb_get_serialise(self, data):
 items, metadata = data
 metadata['items'] = items
 return data_format.serialise(metadata)
-def _mbGet(self, service="", node="", max_items=10, item_ids=None, extra="",
+def _mb_get(self, service="", node="", max_items=10, item_ids=None, extra="",
 profile_key=C.PROF_KEY_NONE):
 """
 @param max_items(int): maximum number of item to get, C.NO_LIMIT for no limit
 @param item_ids (list[unicode]): list of item IDs
 """
-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._p.parseExtra(data_format.deserialise(extra))
+extra = self._p.parse_extra(data_format.deserialise(extra))
 d = defer.ensureDeferred(
-self.mbGet(client, service, node or None, max_items, item_ids,
+self.mb_get(client, service, node or None, max_items, item_ids,
 extra.rsm_request, extra.extra)
 )
-d.addCallback(self._mbGetSerialise)
+d.addCallback(self._mb_get_serialise)
 return d
-async def mbGet(
+async def mb_get(
 self,
 client: SatXMPPEntity,
 service: Optional[jid.JID] = None,
 node: Optional[str] = None,
 max_items: Optional[int] = 10,
 """
 if node is None:
 node = NS_MICROBLOG
 if rsm_request:
 max_items = None
-items_data = await self._p.getItems(
+items_data = await self._p.get_items(
 client,
 service,
 node,
 max_items=max_items,
 item_ids=item_ids,
 rsm_request=rsm_request,
 extra=extra,
 )
-mb_data_list, metadata = await self._p.transItemsDataD(
+mb_data_list, metadata = await self._p.trans_items_data_d(
 items_data, partial(self.item_2_mb_data, client, service=service, node=node))
 encrypted = metadata.pop("encrypted", None)
 if encrypted is not None:
 for mb_data in mb_data_list:
 try:
 mb_data["encrypted"] = encrypted[mb_data["id"]]
 except KeyError:
 pass
 return (mb_data_list, metadata)
-def _mbRename(self, service, node, item_id, new_id, profile_key):
+def _mb_rename(self, service, node, item_id, new_id, profile_key):
-return defer.ensureDeferred(self.mbRename(
+return defer.ensureDeferred(self.mb_rename(
-self.host.getClient(profile_key),
+self.host.get_client(profile_key),
 jid.JID(service) if service else None,
 node or None,
 item_id,
 new_id
 ))
-async def mbRename(
+async def mb_rename(
 self,
 client: SatXMPPEntity,
 service: Optional[jid.JID],
 node: Optional[str],
 item_id: str,
 new_id: str
 ) -> None:
 if not node:
 node = NS_MICROBLOG
-await self._p.renameItem(client, service, node, item_id, new_id)
+await self._p.rename_item(client, service, node, item_id, new_id)
-def parseCommentUrl(self, node_url):
+def parse_comment_url(self, node_url):
 """Parse a XMPP URI
 Determine the fields comments_service and comments_node of a microblog data
 from the href attribute of an entry's link element. For example this input:
 xmpp:sat-pubsub.example.net?;node=urn%3Axmpp%3Acomments%3A_af43b363-3259-4b2a-ba4c-1bc33aa87634__urn%3Axmpp%3Agroupblog%3Asomebody%40example.net
 will return(JID(u'sat-pubsub.example.net'), 'urn:xmpp:comments:_af43b363-3259-4b2a-ba4c-1bc33aa87634__urn:xmpp:groupblog:somebody@example.net')
 @return (tuple[jid.JID, unicode]): service and node
 """
 try:
-parsed_url = xmpp_uri.parseXMPPUri(node_url)
+parsed_url = xmpp_uri.parse_xmpp_uri(node_url)
 service = jid.JID(parsed_url["path"])
 node = parsed_url["node"]
 except Exception as e:
 raise exceptions.DataError(f"Invalid comments link: {e}")
 return (service, node)
 ## configure ##
-def mbSetAccess(self, access="presence", profile_key=C.PROF_KEY_NONE):
+def mb_access_set(self, access="presence", profile_key=C.PROF_KEY_NONE):
 """Create a microblog node on PEP with given access
 If the node already exists, it change options
 @param access: Node access model, according to xep-0060 #4.5
 @param profile_key: profile key
 """
 #  FIXME: check if this mehtod is need, deprecate it if not
-client = self.host.getClient(profile_key)
+client = self.host.get_client(profile_key)
 _options = {
 self._p.OPT_ACCESS_MODEL: access,
 self._p.OPT_MAX_ITEMS: "max",
 self._p.OPT_PERSIST_ITEMS: 1,
 ## methods to manage several stanzas/jids at once ##
 # common
-def _getClientAndNodeData(self, publishers_type, publishers, profile_key):
+def _get_client_and_node_data(self, publishers_type, publishers, profile_key):
 """Helper method to construct node_data from publishers_type/publishers
 @param publishers_type: type of the list of publishers, one of:
 C.ALL: get all jids from roster, publishers is not used
 C.GROUP: get jids from groups
 C.JID: use publishers directly as list of jids
 @param publishers: list of publishers, according to "publishers_type" (None,
 list of groups or list of jids)
 @param profile_key: %(doc_profile_key)s
 """
-client = self.host.getClient(profile_key)
+client = self.host.get_client(profile_key)
 if publishers_type == C.JID:
 jids_set = set(publishers)
 else:
-jids_set = client.roster.getJidsSet(publishers_type, publishers)
+jids_set = client.roster.get_jids_set(publishers_type, publishers)
 if publishers_type == C.ALL:
 try:
 # display messages from salut-a-toi@libervia.org or other PEP services
-services = self.host.plugins["EXTRA-PEP"].getFollowedEntities(
+services = self.host.plugins["EXTRA-PEP"].get_followed_entities(
 profile_key
 )
 except KeyError:
 pass  # plugin is not loaded
 else:
 node_data = []
 for jid_ in jids_set:
 node_data.append((jid_, NS_MICROBLOG))
 return client, node_data
-def _checkPublishers(self, publishers_type, publishers):
+def _check_publishers(self, publishers_type, publishers):
 """Helper method to deserialise publishers coming from bridge
 publishers_type(unicode): type of the list of publishers, one of:
 publishers: list of publishers according to type
 @return: deserialised (publishers_type, publishers) tuple
 publishers[:] = [jid.JID(publisher) for publisher in publishers]
 return publishers_type, publishers
 # subscribe #
-def _mbSubscribeToMany(self, publishers_type, publishers, profile_key):
+def _mb_subscribe_to_many(self, publishers_type, publishers, profile_key):
 """
 @return (str): session id: Use pubsub.getSubscribeRTResult to get the results
 """
-publishers_type, publishers = self._checkPublishers(publishers_type, publishers)
+publishers_type, publishers = self._check_publishers(publishers_type, publishers)
-return self.mbSubscribeToMany(publishers_type, publishers, profile_key)
+return self.mb_subscribe_to_many(publishers_type, publishers, profile_key)
-def mbSubscribeToMany(self, publishers_type, publishers, profile_key):
+def mb_subscribe_to_many(self, publishers_type, publishers, profile_key):
 """Subscribe microblogs for a list of groups or jids
 @param publishers_type: type of the list of publishers, one of:
 C.ALL: get all jids from roster, publishers is not used
 C.GROUP: get jids from groups
 @param publishers: list of publishers, according to "publishers_type" (None, list
 of groups or list of jids)
 @param profile: %(doc_profile)s
 @return (str): session id
 """
-client, node_data = self._getClientAndNodeData(
+client, node_data = self._get_client_and_node_data(
 publishers_type, publishers, profile_key
 )
-return self._p.subscribeToMany(
+return self._p.subscribe_to_many(
 node_data, client.jid.userhostJID(), profile_key=profile_key
 )
 # get #
-def _mbGetFromManyRTResult(self, session_id, profile_key=C.PROF_KEY_DEFAULT):
+def _mb_get_from_many_rt_result(self, session_id, profile_key=C.PROF_KEY_DEFAULT):
-"""Get real-time results for mbGetFromMany session
+"""Get real-time results for mb_get_from_many 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
 - results is a list of tuple with
 - service (unicode): pubsub service
 - node (unicode): pubsub node
 - failure (unicode): empty string in case of success, error message else
-- items_data(list): data as returned by [mbGet]
+- items_data(list): data as returned by [mb_get]
-- items_metadata(dict): metadata as returned by [mbGet]
+- items_metadata(dict): metadata as returned by [mb_get]
 @param profile_key: %(doc_profile_key)s
 """
-client = self.host.getClient(profile_key)
+client = self.host.get_client(profile_key)
 def onSuccess(items_data):
 """convert items elements to list of microblog data in items_data"""
-d = self._p.transItemsDataD(
+d = self._p.trans_items_data_d(
 items_data,
 # FIXME: service and node should be used here
 partial(self.item_2_mb_data, client),
 serialise=True
 )
 d.addCallback(lambda serialised: ("", serialised))
 return d
-d = self._p.getRTResults(
+d = self._p.get_rt_results(
 session_id,
 on_success=onSuccess,
 on_error=lambda failure: (str(failure.value), ([], {})),
 profile=client.profile,
 )
 ],
 )
 )
 return d
-def _mbGetFromMany(self, publishers_type, publishers, max_items=10, extra_dict=None,
+def _mb_get_from_many(self, publishers_type, publishers, max_items=10, extra_dict=None,
 profile_key=C.PROF_KEY_NONE):
 """
 @param max_items(int): maximum number of item to get, C.NO_LIMIT for no limit
 """
 max_items = None if max_items == C.NO_LIMIT else max_items
-publishers_type, publishers = self._checkPublishers(publishers_type, publishers)
+publishers_type, publishers = self._check_publishers(publishers_type, publishers)
-extra = self._p.parseExtra(extra_dict)
+extra = self._p.parse_extra(extra_dict)
-return self.mbGetFromMany(
+return self.mb_get_from_many(
 publishers_type,
 publishers,
 max_items,
 extra.rsm_request,
 extra.extra,
 profile_key,
 )
-def mbGetFromMany(self, publishers_type, publishers, max_items=None, rsm_request=None,
+def mb_get_from_many(self, publishers_type, publishers, max_items=None, rsm_request=None,
 extra=None, profile_key=C.PROF_KEY_NONE):
 """Get the published microblogs for a list of groups or jids
 @param publishers_type (str): type of the list of publishers (one of "GROUP" or
 "JID" or "ALL")
 @param extra (dict): Extra data
 @param profile_key: profile key
 @return (str): RT Deferred session id
 """
 # XXX: extra is unused here so far
-client, node_data = self._getClientAndNodeData(
+client, node_data = self._get_client_and_node_data(
 publishers_type, publishers, profile_key
 )
-return self._p.getFromMany(
+return self._p.get_from_many(
 node_data, max_items, rsm_request, profile_key=profile_key
 )
 # comments #
-def _mbGetFromManyWithCommentsRTResultSerialise(self, data):
+def _mb_get_from_many_with_comments_rt_result_serialise(self, data):
 """Serialisation of result
 This is probably the longest method name of whole SàT ecosystem ^^
 @param data(dict): data as received by rt_sessions
-@return (tuple): see [_mbGetFromManyWithCommentsRTResult]
+@return (tuple): see [_mb_get_from_many_with_comments_rt_result]
 """
 ret = []
 data_iter = iter(data[1].items())
 for (service, node), (success, (failure_, (items_data, metadata))) in data_iter:
 items = []
 items,
 metadata))
 return data[0], ret
-def _mbGetFromManyWithCommentsRTResult(self, session_id,
+def _mb_get_from_many_with_comments_rt_result(self, session_id,
 profile_key=C.PROF_KEY_DEFAULT):
-"""Get real-time results for [mbGetFromManyWithComments] session
+"""Get real-time results for [mb_get_from_many_with_comments] 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
 - results is a list of 5-tuple with
 - comments(list[dict]): list of microblog data
 - comments_metadata(dict): metadata of the comment node
 - metadata(dict): original node metadata
 @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(session_id, profile=profile)
+d = self.rt_sessions.get_results(session_id, profile=profile)
-d.addCallback(self._mbGetFromManyWithCommentsRTResultSerialise)
+d.addCallback(self._mb_get_from_many_with_comments_rt_result_serialise)
 return d
-def _mbGetFromManyWithComments(self, publishers_type, publishers, max_items=10,
+def _mb_get_from_many_with_comments(self, publishers_type, publishers, max_items=10,
 max_comments=C.NO_LIMIT, extra_dict=None,
 extra_comments_dict=None, profile_key=C.PROF_KEY_NONE):
 """
 @param max_items(int): maximum number of item to get, C.NO_LIMIT for no limit
 @param max_comments(int): maximum number of comments to get, C.NO_LIMIT for no
 limit
 """
 max_items = None if max_items == C.NO_LIMIT else max_items
 max_comments = None if max_comments == C.NO_LIMIT else max_comments
-publishers_type, publishers = self._checkPublishers(publishers_type, publishers)
+publishers_type, publishers = self._check_publishers(publishers_type, publishers)
-extra = self._p.parseExtra(extra_dict)
+extra = self._p.parse_extra(extra_dict)
-extra_comments = self._p.parseExtra(extra_comments_dict)
+extra_comments = self._p.parse_extra(extra_comments_dict)
-return self.mbGetFromManyWithComments(
+return self.mb_get_from_many_with_comments(
 publishers_type,
 publishers,
 max_items,
 max_comments or None,
 extra.rsm_request,
 extra_comments.rsm_request,
 extra_comments.extra,
 profile_key,
 )
-def mbGetFromManyWithComments(self, publishers_type, publishers, max_items=None,
+def mb_get_from_many_with_comments(self, publishers_type, publishers, max_items=None,
 max_comments=None, rsm_request=None, extra=None,
 rsm_comments=None, extra_comments=None,
 profile_key=C.PROF_KEY_NONE):
 """Helper method to get the microblogs and their comments in one shot
 """
 # XXX: this method seems complicated because it do a couple of treatments
 #      to serialise and associate the data, but it make life in frontends side
 #      a lot easier
-client, node_data = self._getClientAndNodeData(
+client, node_data = self._get_client_and_node_data(
 publishers_type, publishers, profile_key
 )
-def getComments(items_data):
+def get_comments(items_data):
 """Retrieve comments and add them to the items_data
 @param items_data: serialised items data
 @return (defer.Deferred): list of items where each item is associated
 with a list of comments data (service, node, list of items, metadata)
 service_s = value
 service = jid.JID(service_s)
 node = item["{}{}".format(prefix, "_node")]
 # time to get the comments
 d = defer.ensureDeferred(
-self._p.getItems(
+self._p.get_items(
 client,
 service,
 node,
 max_comments,
 rsm_request=rsm_comments,
 extra=extra_comments,
 )
 )
 # then serialise
 d.addCallback(
-lambda items_data: self._p.transItemsDataD(
+lambda items_data: self._p.trans_items_data_d(
 items_data,
 partial(
 self.item_2_mb_data, client, service=service, node=node
 ),
 serialise=True
 items_d.addCallback(lambda items_completed: (items_completed, metadata))
 return items_d
 deferreds = {}
 for service, node in node_data:
-d = deferreds[(service, node)] = defer.ensureDeferred(self._p.getItems(
+d = deferreds[(service, node)] = defer.ensureDeferred(self._p.get_items(
 client, service, node, max_items, rsm_request=rsm_request, extra=extra
 ))
 d.addCallback(
-lambda items_data: self._p.transItemsDataD(
+lambda items_data: self._p.trans_items_data_d(
 items_data,
 partial(self.item_2_mb_data, client, service=service, node=node),
 )
 )
-d.addCallback(getComments)
+d.addCallback(get_comments)
 d.addCallback(lambda items_comments_data: ("", items_comments_data))
 d.addErrback(lambda failure: (str(failure.value), ([], {})))
-return self.rt_sessions.newSession(deferreds, client.profile)
+return self.rt_sessions.new_session(deferreds, client.profile)
 @implementer(iwokkel.IDisco)
 class XEP_0277_handler(XMPPHandler):

Mercurial > libervia-backend

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