libervia-backend: libervia/backend/plugins/plugin_xep

comparison libervia/backend/plugins/plugin_xep_0277.py @ 4270:0d7bb4df2343

Reformatted code base using black.

author	Goffi <goffi@goffi.org>
date	Wed, 19 Jun 2024 18:44:57 +0200
parents	c86a22009c1f
children

comparison

equal deleted inserted replaced

-:64a85ce8be70
+:0d7bb4df2343
 client: SatXMPPEntity,
 item_elt: domish.Element,
 service: Optional[jid.JID],
 # FIXME: node is Optional until all calls to item_2_mb_data set properly service
 #   and node. Once done, the Optional must be removed here
-node: Optional[str]
+node: Optional[str],
 ) -> dict:
 """Convert an XML Item to microblog data
 @param item_elt: microblog item element
 @param service: PubSub service where the item has been retrieved
 """
 if service is None:
 service = client.jid.userhostJID()
 extra: Dict[str, Any] = {}
-mb_data: Dict[str, Any] = {
+mb_data: Dict[str, Any] = {"service": service.full(), "extra": extra}
-"service": service.full(),
-"extra": extra
-}
 def check_conflict(key, increment=False):
 """Check if key is already in microblog data
 @param key(unicode): key to check
 _("Content of type XHTML must declare its namespace!")
 )
 )
 key = check_conflict("{}_xhtml".format(elem.name))
 data = data_elt.toXml()
-mb_data[key] = yield self.host.plugins["TEXT_SYNTAXES"].clean_xhtml(
+mb_data[key] = yield self.host.plugins["TEXT_SYNTAXES"].clean_xhtml(data)
-data
-)
 else:
 key = check_conflict(elem.name)
 mb_data[key] = str(elem)
 id_ = item_elt.getAttribute("id", "")  # there can be no id for transient nodes
 # uri
 # FIXME: node should alway be set in the future, check FIXME in method signature
 if node is not None:
 mb_data["node"] = node
-mb_data['uri'] = xmpp_uri.build_xmpp_uri(
+mb_data["uri"] = xmpp_uri.build_xmpp_uri(
 "pubsub",
 path=service.full(),
 node=node,
 item=id_,
 )
 # atom:id
 try:
 id_elt = next(entry_elt.elements(NS_ATOM, "id"))
 except StopIteration:
-msg = ("No atom id found in the pubsub item {}, this is not standard !"
+msg = "No atom id found in the pubsub item {}, this is not standard !".format(
-.format(id_))
+id_
+)
 log.warning(msg)
 mb_data["atom_id"] = ""
 else:
 mb_data["atom_id"] = str(id_elt)
 mb_data["published"] = calendar.timegm(
 dateutil.parser.parse(str(published_elt)).utctimetuple()
 )
 # links
-comments = mb_data['comments'] = []
+comments = mb_data["comments"] = []
 for link_elt in entry_elt.elements(NS_ATOM, "link"):
 href = link_elt.getAttribute("href")
 if not href:
-log.warning(
+log.warning(f"missing href in <link> element: {link_elt.toXml()}")
-f'missing href in <link> element: {link_elt.toXml()}'
-)
 continue
 rel = link_elt.getAttribute("rel")
-if (rel == "replies" and link_elt.getAttribute("title") == "comments"):
+if rel == "replies" and link_elt.getAttribute("title") == "comments":
 uri = href
 comments_data = {
 "uri": uri,
 }
 try:
 top_elt = top_elt.parent
 repeater_jid = jid.JID(top_elt["from"])
 except (AttributeError, RuntimeError):
 # we should always have either the "publisher" attribute or the
 # stanza available
-log.error(
+log.error(f"Can't find repeater of the post: {item_elt.toXml()}")
-f"Can't find repeater of the post: {item_elt.toXml()}"
-)
 continue
-extra["repeated"] = {
+extra["repeated"] = {"by": repeater_jid.full(), "uri": href}
-"by": repeater_jid.full(),
-"uri": href
-}
 elif rel in ("related", "enclosure"):
-attachment: Dict[str, Any] = {
+attachment: Dict[str, Any] = {"sources": [{"url": href}]}
-"sources": [{"url": href}]
-}
 if rel == "related":
 attachment["external"] = True
 for attr, key in (
 ("type", "media_type"),
 ("title", "desc"),
 log.warning(
 f"Invalid or missing media type for alternate link: {href}"
 )
 extra.setdefault("alt_links", []).append(link_data)
 else:
-log.warning(
+log.warning(f"Unmanaged link element: {link_elt.toXml()}")
-f"Unmanaged link element: {link_elt.toXml()}"
-)
 # author
 publisher = item_elt.getAttribute("publisher")
 try:
 author_elt = next(entry_elt.elements(NS_ATOM, "author"))
 author = mb_data["author"] = str(name_elt).strip()
 # uri
 try:
 uri_elt = next(author_elt.elements(NS_ATOM, "uri"))
 except StopIteration:
-log.debug(
+log.debug("No uri element found in author element of item {}".format(id_))
-"No uri element found in author element of item {}".format(id_)
-)
 if publisher:
 mb_data["author_jid"] = publisher
 else:
 uri = str(uri_elt)
 if uri.startswith("xmpp:"):
 uri = uri[5:]
 mb_data["author_jid"] = uri
 else:
-mb_data["author_jid"] = (
+mb_data["author_jid"] = item_elt.getAttribute("publisher") or ""
-item_elt.getAttribute("publisher") or ""
-)
 if not author and mb_data["author_jid"]:
 # FIXME: temporary workaround for missing author name, would be
 #   better to use directly JID's identity (to be done from frontends?)
 try:
 mb_data["author"] = jid.JID(mb_data["author_jid"]).user
 except Exception as e:
-log.warning(f"No author name found, and can't parse author jid: {e}")
+log.warning(
+f"No author name found, and can't parse author jid: {e}"
+)
 if not publisher:
 log.debug("No publisher attribute, we can't verify author jid")
 mb_data["author_jid_verified"] = False
 elif jid.JID(publisher).userhostJID() == jid.JID(uri).userhostJID():
 ]
 mb_data["tags"] = categories
 ## the trigger ##
 # if other plugins have things to add or change
-yield self.host.trigger.point(
+yield self.host.trigger.point("XEP-0277_item2data", item_elt, entry_elt, mb_data)
-"XEP-0277_item2data", item_elt, entry_elt, mb_data
-)
 defer.returnValue(mb_data)
 async def mb_data_2_entry_elt(self, client, mb_data, item_id, service, node):
 """Convert a data dict to en entry usable to create an item
 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.get_current_syntax(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(
 _(
 for attachment in attachments:
 try:
 url = attachment["url"]
 except KeyError:
 try:
-url = next(
+url = next(s["url"] for s in attachment["sources"] if "url" in s)
-s['url'] for s in attachment["sources"] if 'url' in s
-)
 except (StopIteration, KeyError):
 log.warning(
 f'"url" missing in attachment, ignoring: {attachment}'
 )
 continue
 # this is an attached file
 link_elt["rel"] = "enclosure"
 for key, attr in (
 ("media_type", "type"),
 ("desc", "title"),
-("size", "lenght")
+("size", "lenght"),
 ):
 value = attachment.get(key)
 if value:
-link_elt[attr]  = str(value)
+link_elt[attr] = str(value)
 ## alternate links ##
 alt_links = extra.get("alt_links")
 if alt_links:
 for link_data in alt_links:
 url_template = link_data["url"]
 url = url_template.format(
 service=quote(service.full(), safe=""),
 node=quote(node, safe=""),
-item=quote(item_id, safe="")
+item=quote(item_id, safe=""),
 )
 link_elt = entry_elt.addElement("link")
 link_elt["href"] = url
 link_elt["rel"] = "alternate"
 pass
 ## published/updated time ##
 current_time = time.time()
 entry_elt.addElement(
-"updated", content=utils.xmpp_date(float(mb_data.get("updated", current_time)))
+"updated",
+content=utils.xmpp_date(float(mb_data.get("updated", current_time))),
 )
 entry_elt.addElement(
 "published",
 content=utils.xmpp_date(float(mb_data.get("published", current_time))),
 )
 ## categories ##
-for tag in mb_data.get('tags', []):
+for tag in mb_data.get("tags", []):
 category_elt = entry_elt.addElement("category")
 category_elt["term"] = tag
 ## id ##
 entry_id = mb_data.get(
 ),
 )
 entry_elt.addElement("id", content=entry_id)  #
 ## comments ##
-for comments_data in mb_data.get('comments', []):
+for comments_data in mb_data.get("comments", []):
 link_elt = entry_elt.addElement("link")
 # XXX: "uri" is set in self._manage_comments if not already existing
 try:
 link_elt["href"] = comments_data["uri"]
 except KeyError:
 repeated = extra["repeated"]
 link_elt = entry_elt.addElement("link")
 link_elt["rel"] = "via"
 link_elt["href"] = repeated["uri"]
 except KeyError as e:
-log.warning(
+log.warning(f"invalid repeated element({e}): {extra['repeated']}")
-f"invalid repeated element({e}): {extra['repeated']}"
-)
 ## final item building ##
 item_elt = pubsub.Item(id=item_id, payload=entry_elt)
 ## the trigger ##
 @param item_id: a comment node
 """
 if not self.is_comment_node(item_id):
 raise ValueError("This node is not a comment node")
-return item_id[len(NS_COMMENT_PREFIX):]
+return item_id[len(NS_COMMENT_PREFIX) :]
 def get_comments_node(self, item_id):
 """Generate comment node
 @param item_id(unicode): id of the parent item
 return defer.succeed(
 client.pubsub_service if client.pubsub_service is not None else parent_service
 )
-async def _manage_comments(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
 return
 elif allow_comments == False:
 if "comments" in mb_data:
 log.warning(
 "comments are not allowed but there is already a comments node, "
-"it may be lost: {uri}".format(
+"it may be lost: {uri}".format(uri=mb_data["comments"])
-uri=mb_data["comments"]
-)
 )
 del mb_data["comments"]
 return
 # we have usually a single comment node, but the spec allow several, so we need to
 # handle this in a list
-if len(mb_data.setdefault('comments', [])) == 0:
+if len(mb_data.setdefault("comments", [])) == 0:
 # we need at least one comment node
-mb_data['comments'].append({})
+mb_data["comments"].append({})
 if access is None:
 # TODO: cache access models per service/node
 try:
 parent_node_config = await self._p.getConfiguration(client, service, node)
 except error.StanzaError as e:
 log.debug(f"Can't get parent node configuration: {e}")
 access = self._p.ACCESS_OPEN
 else:
-access = parent_node_config.get(self._p.OPT_ACCESS_MODEL, self._p.ACCESS_OPEN)
+access = parent_node_config.get(
+self._p.OPT_ACCESS_MODEL, self._p.ACCESS_OPEN
+)
 options = {
 self._p.OPT_ACCESS_MODEL: access,
 self._p.OPT_MAX_ITEMS: "max",
 self._p.OPT_PERSIST_ITEMS: 1,
 }
 # if other plugins need to change the options
 self.host.trigger.point("XEP-0277_comments", client, mb_data, options)
-for comments_data in mb_data['comments']:
+for comments_data in mb_data["comments"]:
-uri = comments_data.get('uri')
+uri = comments_data.get("uri")
-comments_node = comments_data.get('node')
+comments_node = comments_data.get("node")
 try:
 comments_service = jid.JID(comments_data["service"])
 except KeyError:
 comments_service = None
 if uri:
 uri_service, uri_node = self.parse_comment_url(uri)
-if ((comments_node is not None and comments_node!=uri_node)
+if (comments_node is not None and comments_node != uri_node) or (
-or (comments_service is not None and comments_service!=uri_service)):
+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})")
+f"({comments_service}) or comments_node ({comments_node})"
-comments_data['service'] = comments_service = uri_service
+)
-comments_data['node'] = comments_node = uri_node
+comments_data["service"] = comments_service = uri_service
+comments_data["node"] = comments_node = uri_node
 else:
 if not comments_node:
 comments_node = self.get_comments_node(item_id)
-comments_data['node'] = comments_node
+comments_data["node"] = comments_node
 if comments_service is None:
 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["service"] = comments_service
-comments_data['uri'] = xmpp_uri.build_xmpp_uri(
+comments_data["uri"] = xmpp_uri.build_xmpp_uri(
 "pubsub",
 path=comments_service.full(),
 node=comments_node,
 )
 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.url_friendly_text(
-data.get('title')
+data.get("title")
-or data.get('title_rich')
+or data.get("title_rich")
-or data.get('content')
+or data.get("content")
-or data.get('content_rich')
+or data.get("content_rich")
-or ''
+or ""
 )
 if not data.get("user_friendly_id_suffix", True):
 return id_base
 else:
 return f"{id_base}-{token_urlsafe(3)}"
 async def send(
 self,
 client: SatXMPPEntity,
 data: dict,
 service: Optional[jid.JID] = None,
-node: Optional[str] = NS_MICROBLOG
+node: Optional[str] = NS_MICROBLOG,
 ) -> Optional[str]:
 """Send XEP-0277's microblog data
 @param data: microblog data (must include at least a "content" or a "title" key).
 see http://wiki.goffi.org/wiki/Bridge_API_-_Microblogging/en for details
 if not data.get("user_friendly_id_suffix", True):
 # we have no random suffix, which can lead to conflict, so we check if
 # the item doesn't already exist, and change ID if it's the case.
 try:
 items, __ = await self._p.get_items(
-client,
+client, service, node, item_ids=[item_id]
-service,
-node,
-item_ids = [item_id]
 )
 except exceptions.NotFound:
 pass
 else:
 # the item already exists
 await self._p.publish(client, service, node, [item], extra=extra)
 return item_id
 def _mb_repeat(
-self,
+self, service_s: str, node: str, item: str, extra_s: str, profile_key: str
-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.get_client(profile_key)
 extra = data_format.deserialise(extra_s)
-d = defer.ensureDeferred(
+d = defer.ensureDeferred(self.repeat(client, item, service, node, extra))
-self.repeat(client, item, service, node, extra)
-)
 # [repeat] can return None, and we always need a str
 d.addCallback(lambda ret: ret or "")
 return d
 async def repeat(
 """
 if service is None:
 service = client.jid.userhostJID()
 # we first get the post to repeat
-items, __ = await self._p.get_items(
+items, __ = await self._p.get_items(client, service, node, item_ids=[item])
-client,
-service,
-node,
-item_ids = [item]
-)
 if not items:
 raise exceptions.NotFound(
 f"no item found at node {node!r} on {service} with ID {item!r}"
 )
 item_elt = items[0]
 try:
 entry_elt = next(item_elt.elements(NS_ATOM, "entry"))
 except StopIteration:
-raise exceptions.DataError(
+raise exceptions.DataError("post to repeat is not a XEP-0277 blog item")
-"post to repeat is not a XEP-0277 blog item"
-)
 # we want to be sure that we have an author element
 try:
 author_elt = next(entry_elt.elements(NS_ATOM, "author"))
 except StopIteration:
 link_elt["href"] = xmpp_uri.build_xmpp_uri(
 "pubsub", path=service.full(), node=node, item=item
 )
 return await self._p.send_item(
-client,
+client, client.jid.userhostJID(), NS_MICROBLOG, entry_elt
-client.jid.userhostJID(),
-NS_MICROBLOG,
-entry_elt
 )
 def _mb_preview(self, service, node, data, profile_key):
 service = jid.JID(service) if service else None
 node = node if node else NS_MICROBLOG
 async def preview(
 self,
 client: SatXMPPEntity,
 data: dict,
 service: Optional[jid.JID] = None,
-node: Optional[str] = NS_MICROBLOG
+node: Optional[str] = NS_MICROBLOG,
 ) -> dict:
 """Preview microblog data without publishing them
 params are the same as for [send]
 @return: microblog data as would be retrieved from published item
 # we have to serialise then deserialise to be sure that all triggers are called
 item_elt = await self.mb_data_2_entry_elt(client, data, item_id, service, node)
 item_elt.uri = pubsub.NS_PUBSUB
 return await self.item_2_mb_data(client, item_elt, service, node)
 ## retract ##
 def _mb_retract(self, service_jid_s, nodeIdentifier, itemIdentifier, profile_key):
 """Call self._p._retract_item, but use default node if node is empty"""
 ## get ##
 def _mb_get_serialise(self, data):
 items, metadata = data
-metadata['items'] = items
+metadata["items"] = items
 return data_format.serialise(metadata)
-def _mb_get(self, service="", node="", max_items=10, item_ids=None, extra="",
+def _mb_get(
-profile_key=C.PROF_KEY_NONE):
+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.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.parse_extra(data_format.deserialise(extra))
 d = defer.ensureDeferred(
-self.mb_get(client, service, node or None, max_items, item_ids,
+self.mb_get(
-extra.rsm_request, extra.extra)
+client,
+service,
+node or None,
+max_items,
+item_ids,
+extra.rsm_request,
+extra.extra,
+)
 )
 d.addCallback(self._mb_get_serialise)
 return d
 async def mb_get(
 service: Optional[jid.JID] = None,
 node: Optional[str] = None,
 max_items: Optional[int] = 10,
 item_ids: Optional[List[str]] = None,
 rsm_request: Optional[rsm.RSMRequest] = None,
-extra: Optional[Dict[str, Any]] = None
+extra: Optional[Dict[str, Any]] = None,
 ) -> Tuple[List[Dict[str, Any]], Dict[str, Any]]:
 """Get some microblogs
 @param service(jid.JID, None): jid of the publisher
 None to get profile's PEP
 item_ids=item_ids,
 rsm_request=rsm_request,
 extra=extra,
 )
 mb_data_list, metadata = await self._p.trans_items_data_d(
-items_data, partial(self.item_2_mb_data, client, service=service, node=node))
+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 _mb_rename(self, service, node, item_id, new_id, profile_key):
-return defer.ensureDeferred(self.mb_rename(
+return defer.ensureDeferred(
-self.host.get_client(profile_key),
+self.mb_rename(
-jid.JID(service) if service else None,
+self.host.get_client(profile_key),
-node or None,
+jid.JID(service) if service else None,
-item_id,
+node or None,
-new_id
+item_id,
-))
+new_id,
+)
+)
 async def mb_rename(
 self,
 client: SatXMPPEntity,
 service: Optional[jid.JID],
 node: Optional[str],
 item_id: str,
-new_id: str
+new_id: str,
 ) -> None:
 if not node:
 node = NS_MICROBLOG
 await self._p.rename_item(client, service, node, item_id, new_id)
 """convert items elements to list of microblog data in items_data"""
 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
+serialise=True,
 )
 d.addCallback(lambda serialised: ("", serialised))
 return d
 d = self._p.get_rt_results(
 ],
 )
 )
 return d
-def _mb_get_from_many(self, publishers_type, publishers, max_items=10, extra_dict=None,
+def _mb_get_from_many(
-profile_key=C.PROF_KEY_NONE):
+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._check_publishers(publishers_type, publishers)
 extra.rsm_request,
 extra.extra,
 profile_key,
 )
-def mb_get_from_many(self, publishers_type, publishers, max_items=None, rsm_request=None,
+def mb_get_from_many(
-extra=None, profile_key=C.PROF_KEY_NONE):
+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 publishers (list): list of publishers, according to publishers_type (list
 for (service, node), (success, (failure_, (items_data, metadata))) in data_iter:
 items = []
 for item, item_metadata in items_data:
 item = data_format.serialise(item)
 items.append((item, item_metadata))
-ret.append((
+ret.append((service.full(), node, failure_, items, metadata))
-service.full(),
-node,
-failure_,
-items,
-metadata))
 return data[0], ret
-def _mb_get_from_many_with_comments_rt_result(self, session_id,
+def _mb_get_from_many_with_comments_rt_result(
-profile_key=C.PROF_KEY_DEFAULT):
+self, session_id, profile_key=C.PROF_KEY_DEFAULT
+):
 """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
 profile = self.host.get_client(profile_key).profile
 d = self.rt_sessions.get_results(session_id, profile=profile)
 d.addCallback(self._mb_get_from_many_with_comments_rt_result_serialise)
 return d
-def _mb_get_from_many_with_comments(self, publishers_type, publishers, max_items=10,
+def _mb_get_from_many_with_comments(
-max_comments=C.NO_LIMIT, extra_dict=None,
+self,
-extra_comments_dict=None, profile_key=C.PROF_KEY_NONE):
+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
 """
 extra_comments.rsm_request,
 extra_comments.extra,
 profile_key,
 )
-def mb_get_from_many_with_comments(self, publishers_type, publishers, max_items=None,
+def mb_get_from_many_with_comments(
-max_comments=None, rsm_request=None, extra=None,
+self,
-rsm_comments=None, extra_comments=None,
+publishers_type,
-profile_key=C.PROF_KEY_NONE):
+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
 @param publishers_type (str): type of the list of publishers (one of "GROUP" or
 "JID" or "ALL")
 @param publishers (list): list of publishers, according to publishers_type (list
 # then serialise
 d.addCallback(
 lambda items_data: self._p.trans_items_data_d(
 items_data,
 partial(
-self.item_2_mb_data, client, service=service, node=node
+self.item_2_mb_data,
+client,
+service=service,
+node=node,
 ),
-serialise=True
+serialise=True,
 )
 )
 # with failure handling
 d.addCallback(
 lambda serialised_items_data: ("",) + serialised_items_data
 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.get_items(
+d = deferreds[(service, node)] = defer.ensureDeferred(
-client, service, node, max_items, rsm_request=rsm_request, extra=extra
+self._p.get_items(
-))
+client, service, node, max_items, rsm_request=rsm_request, extra=extra
+)
+)
 d.addCallback(
 lambda items_data: self._p.trans_items_data_d(
 items_data,
 partial(self.item_2_mb_data, client, service=service, node=node),
 )

Mercurial > libervia-backend

comparison libervia/backend/plugins/plugin_xep_0277.py @ 4270:0d7bb4df2343