XEP-0222: Add more types and docs, and use new-style kwargs

slixmpp/plugins/xep_0222.py

@@ -5,6 +5,7 @@
 # See the file LICENSE for copying permission.
 import logging
 
+from asyncio import Future
 from typing import Optional, Callable, List
 from slixmpp import JID
 from slixmpp.xmlstream import register_stanza_plugin, ElementBase
@@ -28,9 +29,11 @@ class XEP_0222(BasePlugin):
     profile = {'pubsub#persist_items': True,
                'pubsub#send_last_published_item': 'never'}
 
-    def configure(self, node, ifrom=None, callback=None, timeout=None):
+    def configure(self, node: str, **iqkwargs) -> Future:
         """
         Update a node's configuration to match the public storage profile.
+
+        :param node: Node to set the configuration at.
         """
         config = self.xmpp['xep_0004'].Form()
         config['type'] = 'submit'
@@ -38,29 +41,26 @@ class XEP_0222(BasePlugin):
         for field, value in self.profile.items():
             config.add_field(var=field, value=value)
 
-        return self.xmpp['xep_0060'].set_node_config(None, node, config,
+        return self.xmpp['xep_0060'].set_node_config(
-                ifrom=ifrom,
+            jid=None, node=node, config=config, **iqkwargs
-                callback=callback,
+        )
-                timeout=timeout)
 
     def store(self, stanza: ElementBase, node: Optional[str] = None,
-              id: Optional[str] = None, ifrom: Optional[JID] = None,
+              id: Optional[str] = None, **pubsubkwargs) -> Future:
-              options: Optional[Form] = None,
-              callback: Optional[Callable] = None,
-              timeout: Optional[int] = None):
         """
         Store public data via PEP.
 
         This is just a (very) thin wrapper around the XEP-0060 publish()
         method to set the defaults expected by PEP.
 
-        :param stanza:  The private content to store.
+        :param stanza:  The public content to store.
         :param node: The node to publish the content to. If not specified,
                      the stanza's namespace will be used.
         :param id: Optionally specify the ID of the item.
         :param options: Publish options to use, which will be modified to
                         fit the persistent storage option profile.
         """
+        options = pubsubkwargs.pop('options', None)
         if not options:
             options = self.xmpp['xep_0004'].stanza.Form()
             options['type'] = 'submit'
@@ -75,17 +75,12 @@ class XEP_0222(BasePlugin):
                 options.add_field(var=field)
             options.get_fields()[field]['value'] = value
 
-        return self.xmpp['xep_0163'].publish(stanza, node,
+        pubsubkwargs['options'] = options
-                options=options,
+
-                ifrom=ifrom,
+        return self.xmpp['xep_0163'].publish(stanza, node, id=id, **pubsubkwargs)
-                callback=callback,
-                timeout=timeout)
 
     def retrieve(self, node: str, id: Optional[str] = None,
-                 item_ids: Optional[List[str]] = None,
+                 item_ids: Optional[List[str]] = None, **iqkwargs) -> Future:
-                 ifrom: Optional[JID] = None,
-                 callback: Optional[Callable] = None,
-                 timeout: Optional[int] = None):
         """
         Retrieve public data via PEP.
 
@@ -96,23 +91,17 @@ class XEP_0222(BasePlugin):
         :param id: Optionally specify the ID of the item.
         :param item_ids: Specify a group of IDs. If id is also specified, it
                          will be included in item_ids.
-        :param ifrom: Specify the sender's JID.
-        :param timeout: The length of time (in seconds) to wait for a response
-                        before exiting the send call if blocking is used.
-                        Defaults to slixmpp.xmlstream.RESPONSE_TIMEOUT
-        :param callback: Optional reference to a stream handler function. Will
-                         be executed when a reply stanza is received.
         """
         if item_ids is None:
             item_ids = []
         if id is not None:
             item_ids.append(id)
 
-        return self.xmpp['xep_0060'].get_items(None, node,
+        return self.xmpp['xep_0060'].get_items(
-                item_ids=item_ids,
+            jid=None, node=node,
-                ifrom=ifrom,
+            item_ids=item_ids,
-                callback=callback,
+            **iqkwargs
-                timeout=timeout)
+        )
 
 
 register_plugin(XEP_0222)