def set_annotations(self, notes):

         _task = yield

         for note in notes:

             self._log.info(note)

     def block(self, jids, report=None):

         _task = yield

         response = yield _make_block_request(jids, report)

         yield process_response(response)

     def unblock(self, jids):

         _task = yield

         response = yield _make_unblock_request(jids)

         yield process_response(response)

     def disco_info(self, jid, node=None):

         _task = yield

         response = yield get_disco_request(Namespace.DISCO_INFO, jid, node)

         if response.isError():

             raise StanzaError(response)

     def disco_items(self, jid, node=None):

         _task = yield

         response = yield get_disco_request(Namespace.DISCO_ITEMS, jid, node)

         if response.isError():

             raise StanzaError(response)

     def set_devicelist(self, devicelist=None, public=True):

         task = yield

         access_model = 'open' if public else 'presence'

         options = {

     def set_bundle(self, bundle, device_id, public=True):

         task = yield

         access_model = 'open' if public else 'presence'

         options = {

     def request_bundle(self, jid, device_id):

         task = yield

         items = yield self.request_items(

             f'{Namespace.OMEMO_TEMP_BUNDLE}:{device_id}',

             max_items=1,

             'pubsub#access_model': access_model,

         }

         result = yield self.publish(Namespace.OPENPGP_PK,

                                     _make_keylist(keylist),

                                     id_='current',

     def set_public_key(self, key, fingerprint, date, public=True):

         task = yield

         access_model = 'open' if public else 'presence'

         options = {

     def request_public_key(self, jid, fingerprint):

         task = yield

         items = yield self.request_items(

             f'{Namespace.OPENPGP_PK}:{fingerprint}',

             max_items=1,

     def request_keylist(self, jid=None):

         task = yield

         items = yield self.request_items(

             Namespace.OPENPGP_PK,

             max_items=1,

     def request_secret_key(self):

         task = yield

         items = yield self.request_items(

             Namespace.OPENPGP_SK,

             max_items=1)

     def set_secret_key(self, secret_key):

         task = yield

         options = {

             'pubsub#persist_items': 'true',

             'pubsub#access_model': 'whitelist',

     def ping(self, jid):

         _task = yield

         response = yield _make_ping_request(jid)

         yield process_response(response)

     def get_access_model(self, node):

         _task = yield

         result = yield self.get_node_configuration(node)

         raise_if_error(result)

         result.form['pubsub#access_model'].value = model

         result = yield self.set_node_configuration(node, result.form)

         yield finalize(task, result)

         if ver_support and version is None:

             version = ''

         response = yield _make_request(version, ver_support)

         if response.isError():

     def request_software_version(self, jid):

         _task = yield

         response = yield Iq(typ='get', to=jid, queryNS=Namespace.VERSION)

         if response.isError():

             raise StanzaError(response)

         for info, data in avatar.pubsub_avatar_info():

             item = _make_avatar_data_node(data)

             result = yield self.publish(Namespace.AVATAR_DATA,

                                         item,

     def _publish_avatar_metadata(self, metadata, access_model):

         task = yield

         options = {

             'pubsub#persist_items': 'true',

             'pubsub#access_model': access_model,

 # You should have received a copy of the GNU General Public License

 # along with this program; If not, see <http://www.gnu.org/licenses/>.

 from urllib.parse import urlparse

 from urllib.parse import unquote

         dict_[key] = unquote(value)

     return (url.path, action, dict_)

 from nbxmpp.errors import CancelledError

 from nbxmpp.errors import TimeoutStanzaError

 from nbxmpp.simplexml import Node

 log = logging.getLogger('nbxmpp.task')

 def iq_request_task(func):

     @wraps(func)

     def func_wrapper(self, *args, timeout=None, callback=None, user_data=None, **kwargs):

         task = IqRequestTask(func(self, *args, **kwargs),

                              self._log,

                              self._client)