From 9561a2a305d2e2343612cd86112f89e70de55e5b Mon Sep 17 00:00:00 2001 From: mathieui Date: Mon, 1 Mar 2021 20:54:10 +0100 Subject: [PATCH 1/5] types: add some often-used types --- slixmpp/types.py | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-) diff --git a/slixmpp/types.py b/slixmpp/types.py index c8ab640c..b9a1d319 100644 --- a/slixmpp/types.py +++ b/slixmpp/types.py @@ -7,7 +7,10 @@ This file contains boilerplate to define types relevant to slixmpp. """ -from typing import Optional +from typing import ( + Optional, + Union, +) try: from typing import ( @@ -31,7 +34,6 @@ PresenceShows = Literal[ 'away', 'chat', 'dnd', 'xa', ] - MessageTypes = Literal[ 'chat', 'error', 'groupchat', 'headline', 'normal', @@ -70,3 +72,7 @@ class MucRoomItem(TypedDict, total=False): MucRoomItemKeys = Literal[ 'jid', 'role', 'affiliation', 'show', 'status', 'alt_nick', ] + +OptJid = Optional[JID] +JidStr = Union[str, JID] +OptJidStr = Optional[Union[str, JID]] From 2ff72d88fd1cab483a7572e37983e150f8cde713 Mon Sep 17 00:00:00 2001 From: mathieui Date: Mon, 1 Mar 2021 20:54:26 +0100 Subject: [PATCH 2/5] docs: improve XEP-0030 docs --- docs/api/plugins/xep_0030.rst | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) diff --git a/docs/api/plugins/xep_0030.rst b/docs/api/plugins/xep_0030.rst index 81499dba..188ede45 100644 --- a/docs/api/plugins/xep_0030.rst +++ b/docs/api/plugins/xep_0030.rst @@ -9,14 +9,31 @@ XEP-0030: Service Discovery :exclude-members: session_bind, plugin_init, plugin_end +.. _api-0030: + +Internal API Methods +-------------------- + +All ``api`` operations supported by the 0030 plugin are implemented as part of +the :class:`~.StaticDisco` class which implement an in-memory cache for disco +info and items. + + +.. automodule:: slixmpp.plugins.xep_0030.static + :members: + :member-order: bysource + + Stanza elements --------------- .. automodule:: slixmpp.plugins.xep_0030.stanza.info :members: + :member-order: bysource :undoc-members: .. automodule:: slixmpp.plugins.xep_0030.stanza.items :members: + :member-order: bysource :undoc-members: From 10611525a0d92e1dd110eca88b2bcaf8e2b9d6fd Mon Sep 17 00:00:00 2001 From: mathieui Date: Mon, 1 Mar 2021 20:54:53 +0100 Subject: [PATCH 3/5] XEP-0030 plugin: Fix PEP8, types --- slixmpp/plugins/xep_0030/disco.py | 232 ++++++++++++++++-------------- 1 file changed, 126 insertions(+), 106 deletions(-) diff --git a/slixmpp/plugins/xep_0030/disco.py b/slixmpp/plugins/xep_0030/disco.py index 6aeadc84..08dedbce 100644 --- a/slixmpp/plugins/xep_0030/disco.py +++ b/slixmpp/plugins/xep_0030/disco.py @@ -7,14 +7,20 @@ import asyncio import logging from asyncio import Future -from typing import Optional, Callable +from typing import ( + Optional, + Callable, + List, + Union, +) -from slixmpp import Iq -from slixmpp import future_wrapper +from slixmpp import JID +from slixmpp.stanza import Iq +from slixmpp.types import OptJid from slixmpp.plugins import BasePlugin -from slixmpp.xmlstream.handler import Callback, CoroutineCallback +from slixmpp.xmlstream.handler import CoroutineCallback from slixmpp.xmlstream.matcher import StanzaPath -from slixmpp.xmlstream import register_stanza_plugin, JID +from slixmpp.xmlstream import register_stanza_plugin from slixmpp.plugins.xep_0030 import stanza, DiscoInfo, DiscoItems from slixmpp.plugins.xep_0030 import StaticDisco @@ -42,14 +48,14 @@ class XEP_0030(BasePlugin): Node handler hierarchy: - :: - - JID | Node | Level - --------------------- - None | None | Global - Given | None | All nodes for the JID - None | Given | Node on self.xmpp.boundjid - Given | Given | A single node + ====== ======= ============================ + JID Node Level + ====== ======= ============================ + None None Global + Given None All nodes for the JID + None Given Node on self.xmpp.boundjid + Given Given A single node + ====== ======= ============================ Stream Handlers: @@ -62,19 +68,13 @@ class XEP_0030(BasePlugin): Events: - :: - - disco_info -- Received a disco#info Iq query result. - disco_items -- Received a disco#items Iq query result. - disco_info_query -- Received a disco#info Iq query request. - disco_items_query -- Received a disco#items Iq query request. + - :term:`disco_info` -- Received a disco#info Iq query result. + - :term:`disco_items` -- Received a disco#items Iq query result. Attributes: :var static: Object containing the default set of static node handlers. - :var default_handlers: A dictionary mapping operations to the default - global handler (by default, the static handlers). """ name = 'xep_0030' @@ -85,20 +85,23 @@ class XEP_0030(BasePlugin): 'use_cache': True, 'wrap_results': False } + static: StaticDisco def plugin_init(self): """ Start the XEP-0030 plugin. """ - self.xmpp.register_handler( - CoroutineCallback('Disco Info', - StanzaPath('iq/disco_info'), - self._handle_disco_info)) + self.xmpp.register_handler(CoroutineCallback( + 'Disco Info', + StanzaPath('iq/disco_info'), + self._handle_disco_info + )) - self.xmpp.register_handler( - CoroutineCallback('Disco Items', - StanzaPath('iq/disco_items'), - self._handle_disco_items)) + self.xmpp.register_handler(CoroutineCallback( + 'Disco Items', + StanzaPath('iq/disco_items'), + self._handle_disco_items + )) register_stanza_plugin(Iq, DiscoInfo) register_stanza_plugin(Iq, DiscoItems) @@ -127,7 +130,7 @@ class XEP_0030(BasePlugin): self.api.register(default_handler, op) self.api.register_default(default_handler, op) - def set_node_handler(self, htype: str, jid: Optional[JID] = None, + def set_node_handler(self, htype: str, jid: OptJid = None, node: Optional[str] = None, handler: Optional[Callable] = None): """ @@ -142,14 +145,14 @@ class XEP_0030(BasePlugin): Node handler hierarchy: - :: - - JID | Node | Level - --------------------- - None | None | Global - Given | None | All nodes for the JID - None | Given | Node on self.xmpp.boundjid - Given | Given | A single node + ====== ======= ============================ + JID Node Level + ====== ======= ============================ + None None Global + Given None All nodes for the JID + None Given Node on self.xmpp.boundjid + Given Given A single node + ====== ======= ============================ Handler types: @@ -180,7 +183,7 @@ class XEP_0030(BasePlugin): """ self.api.register(handler, htype, jid, node) - def del_node_handler(self, htype, jid, node): + def del_node_handler(self, htype: str, jid: OptJid, node: Optional[str]): """ Remove a handler type for a JID and node combination. @@ -190,14 +193,14 @@ class XEP_0030(BasePlugin): Node handler hierarchy: - :: - - JID | Node | Level - --------------------- - None | None | Global - Given | None | All nodes for the JID - None | Given | Node on self.xmpp.boundjid - Given | Given | A single node + ====== ======= ============================ + JID Node Level + ====== ======= ============================ + None None Global + Given None All nodes for the JID + None Given Node on self.xmpp.boundjid + Given Given A single node + ====== ======= ============================ :param htype: The type of handler to remove. :param jid: The JID from which to remove the handler. @@ -205,7 +208,8 @@ class XEP_0030(BasePlugin): """ self.api.unregister(htype, jid, node) - def restore_defaults(self, jid=None, node=None, handlers=None): + def restore_defaults(self, jid: OptJid = None, node: Optional[str] = None, + handlers: Optional[List[Callable]] = None): """ Change all or some of a node's handlers to the default handlers. Useful for manually overriding the contents @@ -227,19 +231,15 @@ class XEP_0030(BasePlugin): for op in handlers: self.api.restore_default(op, jid, node) - def supports(self, jid=None, node=None, feature=None, local=False, - cached=True, ifrom=None) -> Future: + def supports(self, jid: OptJid = None, node: Optional[str] = None, + feature: Optional[str] = None, local: bool = False, + cached: bool = True, ifrom: OptJid = None) -> Future: """ Check if a JID supports a given feature. .. versionchanged:: 1.8.0 This function now returns a Future. - Return values: - :param True: The feature is supported - :param False: The feature is not listed as supported - :param None: Nothing could be found due to a timeout - :param jid: Request info from this JID. :param node: The particular node to query. :param feature: The name of the feature to check. @@ -255,24 +255,27 @@ class XEP_0030(BasePlugin): be useful. If set to false, then the cache will be skipped, even if a result has already been cached. Defaults to false. + + :returns True: The feature is supported + :returns False: The feature is not listed as supported + :returns None: Nothing could be found due to a timeout """ data = {'feature': feature, 'local': local, 'cached': cached} return self.api['supports'](jid, node, ifrom, data) - def has_identity(self, jid=None, node=None, category=None, itype=None, - lang=None, local=False, cached=True, ifrom=None) -> Future: + def has_identity(self, jid: OptJid = None, node: Optional[str] = None, + category: Optional[str] = None, + itype: Optional[str] = None, lang: Optional[str] = None, + local: bool = False, cached: bool = True, + ifrom: OptJid = None) -> Future: """ Check if a JID provides a given identity. .. versionchanged:: 1.8.0 This function now returns a Future. - Return values: - :param True: The identity is provided - :param False: The identity is not listed - :param None: Nothing could be found due to a timeout :param jid: Request info from this JID. :param node: The particular node to query. @@ -291,6 +294,10 @@ class XEP_0030(BasePlugin): be useful. If set to false, then the cache will be skipped, even if a result has already been cached. Defaults to false. + + :returns True: The identity is provided + :returns False: The identity is not listed + :returns None: Nothing could be found due to a timeout """ data = {'category': category, 'itype': itype, @@ -301,7 +308,8 @@ class XEP_0030(BasePlugin): async def get_info_from_domain(self, domain=None, timeout=None, cached=True, callback=None): - """Fetch disco#info of specified domain and one disco#items level below""" + """Fetch disco#info of specified domain and one disco#items level below + """ if domain is None: domain = self.xmpp.boundjid.domain @@ -322,7 +330,9 @@ class XEP_0030(BasePlugin): ) self.domain_infos[domain] = [ - future.result() for future in info_futures if not future.exception()] + future.result() + for future in info_futures if not future.exception() + ] results = self.domain_infos[domain] @@ -330,8 +340,9 @@ class XEP_0030(BasePlugin): callback(results) return results - async def get_info(self, jid=None, node=None, local=None, - cached=None, **kwargs): + async def get_info(self, jid: OptJid = None, node: Optional[str] = None, + local: Optional[bool] = None, + cached: Optional[bool] = None, **kwargs) -> Iq: """ Retrieve the disco#info results from a given JID/node combination. @@ -375,7 +386,7 @@ class XEP_0030(BasePlugin): local = True if local: - log.debug("Looking up local disco#info data " + \ + log.debug("Looking up local disco#info data " "for %s, node %s.", jid, node) info = await self.api['get_info']( jid, node, kwargs.get('ifrom', None), @@ -385,7 +396,7 @@ class XEP_0030(BasePlugin): return self._wrap(kwargs.get('ifrom', None), jid, info) if cached: - log.debug("Looking up cached disco#info data " + \ + log.debug("Looking up cached disco#info data " "for %s, node %s.", jid, node) info = await self.api['get_cached_info']( jid, node, @@ -401,11 +412,10 @@ class XEP_0030(BasePlugin): iq['to'] = jid iq['type'] = 'get' iq['disco_info']['node'] = node if node else '' - return await iq.send(timeout=kwargs.get('timeout', None), - callback=kwargs.get('callback', None), - timeout_callback=kwargs.get('timeout_callback', None)) + return await iq.send(**kwargs) - def set_info(self, jid=None, node=None, info=None) -> Future: + def set_info(self, jid: OptJid = None, node: Optional[str] = None, + info: Optional[Union[Iq, DiscoInfo]] = None) -> Future: """ Set the disco#info data for a JID/node based on an existing disco#info stanza. @@ -418,7 +428,9 @@ class XEP_0030(BasePlugin): info = info['disco_info'] return self.api['set_info'](jid, node, None, info) - async def get_items(self, jid=None, node=None, local=False, **kwargs): + async def get_items(self, jid: OptJid = None, node: Optional[str] = None, + local: bool = False, ifrom: OptJid = None, + **kwargs) -> Iq: """ Retrieve the disco#items results from a given JID/node combination. @@ -445,25 +457,22 @@ class XEP_0030(BasePlugin): Otherwise the parameter is ignored. """ if local or local is None and jid is None: - items = await self.api['get_items'](jid, node, - kwargs.get('ifrom', None), - kwargs) + items = await self.api['get_items'](jid, node, ifrom, kwargs) return self._wrap(kwargs.get('ifrom', None), jid, items) iq = self.xmpp.Iq() # Check dfrom parameter for backwards compatibility - iq['from'] = kwargs.get('ifrom', kwargs.get('dfrom', '')) + iq['from'] = ifrom or kwargs.get('dfrom', '') iq['to'] = jid iq['type'] = 'get' iq['disco_items']['node'] = node if node else '' if kwargs.get('iterator', False) and self.xmpp['xep_0059']: return self.xmpp['xep_0059'].iterate(iq, 'disco_items') else: - return await iq.send(timeout=kwargs.get('timeout', None), - callback=kwargs.get('callback', None), - timeout_callback=kwargs.get('timeout_callback', None)) + return await iq.send(**kwargs) - def set_items(self, jid=None, node=None, **kwargs) -> Future: + def set_items(self, jid: OptJid = None, node: Optional[str] = None, + **kwargs) -> Future: """ Set or replace all items for the specified JID/node combination. @@ -480,7 +489,8 @@ class XEP_0030(BasePlugin): """ return self.api['set_items'](jid, node, None, kwargs) - def del_items(self, jid=None, node=None, **kwargs) -> Future: + def del_items(self, jid: OptJid = None, node: Optional[str] = None, + **kwargs) -> Future: """ Remove all items from the given JID/node combination. @@ -493,7 +503,9 @@ class XEP_0030(BasePlugin): """ return self.api['del_items'](jid, node, None, kwargs) - def add_item(self, jid='', name='', node=None, subnode='', ijid=None) -> Future: + def add_item(self, jid: str = '', name: str = '', + node: Optional[str] = None, subnode: str = '', + ijid: OptJid = None) -> Future: """ Add a new item element to the given JID/node combination. @@ -516,7 +528,8 @@ class XEP_0030(BasePlugin): 'inode': subnode} return self.api['add_item'](ijid, node, None, kwargs) - def del_item(self, jid=None, node=None, **kwargs) -> Future: + def del_item(self, jid: OptJid = None, node: Optional[str] = None, + **kwargs) -> Future: """ Remove a single item from the given JID/node combination. @@ -527,8 +540,9 @@ class XEP_0030(BasePlugin): """ return self.api['del_item'](jid, node, None, kwargs) - def add_identity(self, category='', itype='', name='', - node=None, jid=None, lang=None) -> Future: + def add_identity(self, category: str = '', itype: str = '', name: str = '', + node: Optional[str] = None, jid: OptJid = None, + lang: Optional[str] = None) -> Future: """ Add a new identity to the given JID/node combination. @@ -557,7 +571,7 @@ class XEP_0030(BasePlugin): return self.api['add_identity'](jid, node, None, kwargs) def add_feature(self, feature: str, node: Optional[str] = None, - jid: Optional[JID] = None) -> Future: + jid: OptJid = None) -> Future: """ Add a feature to a JID/node combination. @@ -571,7 +585,7 @@ class XEP_0030(BasePlugin): kwargs = {'feature': feature} return self.api['add_feature'](jid, node, None, kwargs) - def del_identity(self, jid: Optional[JID] = None, + def del_identity(self, jid: OptJid = None, node: Optional[str] = None, **kwargs) -> Future: """ Remove an identity from the given JID/node combination. @@ -588,7 +602,8 @@ class XEP_0030(BasePlugin): """ return self.api['del_identity'](jid, node, None, kwargs) - def del_feature(self, jid=None, node=None, **kwargs) -> Future: + def del_feature(self, jid: OptJid = None, node: Optional[str] = None, + **kwargs) -> Future: """ Remove a feature from a given JID/node combination. @@ -601,7 +616,8 @@ class XEP_0030(BasePlugin): """ return self.api['del_feature'](jid, node, None, kwargs) - def set_identities(self, jid=None, node=None, **kwargs) -> Future: + def set_identities(self, jid: OptJid = None, node: Optional[str] = None, + **kwargs) -> Future: """ Add or replace all identities for the given JID/node combination. @@ -618,7 +634,8 @@ class XEP_0030(BasePlugin): """ return self.api['set_identities'](jid, node, None, kwargs) - def del_identities(self, jid=None, node=None, **kwargs) -> Future: + def del_identities(self, jid: OptJid = None, node: Optional[str] = None, + **kwargs) -> Future: """ Remove all identities for a JID/node combination. @@ -635,7 +652,8 @@ class XEP_0030(BasePlugin): """ return self.api['del_identities'](jid, node, None, kwargs) - def set_features(self, jid=None, node=None, **kwargs) -> Future: + def set_features(self, jid: OptJid = None, node: Optional[str] = None, + **kwargs) -> Future: """ Add or replace the set of supported features for a JID/node combination. @@ -649,7 +667,8 @@ class XEP_0030(BasePlugin): """ return self.api['set_features'](jid, node, None, kwargs) - def del_features(self, jid=None, node=None, **kwargs) -> Future: + def del_features(self, jid: OptJid = None, node: Optional[str] = None, + **kwargs) -> Future: """ Remove all features from a JID/node combination. @@ -661,7 +680,8 @@ class XEP_0030(BasePlugin): """ return self.api['del_features'](jid, node, None, kwargs) - async def _run_node_handler(self, htype, jid, node=None, ifrom=None, data=None): + async def _run_node_handler(self, htype, jid, node: Optional[str] = None, + ifrom: OptJid = None, data=None): """ Execute the most specific node handler for the given JID/node combination. @@ -676,7 +696,7 @@ class XEP_0030(BasePlugin): return await self.api[htype](jid, node, ifrom, data) - async def _handle_disco_info(self, iq): + async def _handle_disco_info(self, iq: Iq): """ Process an incoming disco#info stanza. If it is a get request, find and return the appropriate identities @@ -686,7 +706,7 @@ class XEP_0030(BasePlugin): :param iq: The incoming disco#items stanza. """ if iq['type'] == 'get': - log.debug("Received disco info query from " + \ + log.debug("Received disco info query from " "<%s> to <%s>.", iq['from'], iq['to']) info = await self.api['get_info'](iq['to'], iq['disco_info']['node'], @@ -704,11 +724,11 @@ class XEP_0030(BasePlugin): iq.set_payload(info.xml) iq.send() elif iq['type'] == 'result': - log.debug("Received disco info result from " + \ + log.debug("Received disco info result from " "<%s> to <%s>.", iq['from'], iq['to']) if self.use_cache: - log.debug("Caching disco info result from " \ - "<%s> to <%s>.", iq['from'], iq['to']) + log.debug("Caching disco info result from " + "<%s> to <%s>.", iq['from'], iq['to']) if self.xmpp.is_component: ito = iq['to'].full else: @@ -719,7 +739,7 @@ class XEP_0030(BasePlugin): iq) self.xmpp.event('disco_info', iq) - async def _handle_disco_items(self, iq): + async def _handle_disco_items(self, iq: Iq): """ Process an incoming disco#items stanza. If it is a get request, find and return the appropriate items. If it @@ -728,7 +748,7 @@ class XEP_0030(BasePlugin): :param iq: The incoming disco#items stanza. """ if iq['type'] == 'get': - log.debug("Received disco items query from " + \ + log.debug("Received disco items query from " "<%s> to <%s>.", iq['from'], iq['to']) items = await self.api['get_items'](iq['to'], iq['disco_items']['node'], @@ -742,11 +762,11 @@ class XEP_0030(BasePlugin): iq.set_payload(items.xml) iq.send() elif iq['type'] == 'result': - log.debug("Received disco items result from " + \ + log.debug("Received disco items result from " "%s to %s.", iq['from'], iq['to']) self.xmpp.event('disco_items', iq) - def _fix_default_info(self, info): + def _fix_default_info(self, info: DiscoInfo): """ Disco#info results for a JID are required to include at least one identity and feature. As a default, if no other identity is @@ -762,20 +782,20 @@ class XEP_0030(BasePlugin): if not info['node']: if not info['identities']: if self.xmpp.is_component: - log.debug("No identity found for this entity. " + \ + log.debug("No identity found for this entity. " "Using default component identity.") info.add_identity('component', 'generic') else: - log.debug("No identity found for this entity. " + \ + log.debug("No identity found for this entity. " "Using default client identity.") info.add_identity('client', 'bot') if not info['features']: - log.debug("No features found for this entity. " + \ + log.debug("No features found for this entity. " "Using default disco#info feature.") info.add_feature(info.namespace) return result - def _wrap(self, ito, ifrom, payload, force=False): + def _wrap(self, ito: OptJid, ifrom: OptJid, payload, force=False) -> Iq: """ Ensure that results are wrapped in an Iq stanza if self.wrap_results has been set to True. From e3027dabb27e06680ef15b3cf740560a9f6ac937 Mon Sep 17 00:00:00 2001 From: mathieui Date: Mon, 1 Mar 2021 20:55:27 +0100 Subject: [PATCH 4/5] XEP-0030 stanza: FIX PEP8, types --- slixmpp/plugins/xep_0030/stanza/info.py | 74 ++++++++++++++---------- slixmpp/plugins/xep_0030/stanza/items.py | 74 ++++++++++++++---------- 2 files changed, 86 insertions(+), 62 deletions(-) diff --git a/slixmpp/plugins/xep_0030/stanza/info.py b/slixmpp/plugins/xep_0030/stanza/info.py index a77917e9..367afdad 100644 --- a/slixmpp/plugins/xep_0030/stanza/info.py +++ b/slixmpp/plugins/xep_0030/stanza/info.py @@ -1,10 +1,19 @@ - # Slixmpp: The Slick XMPP Library # Copyright (C) 2010 Nathanael C. Fritz, Lance J.T. Stout # This file is part of Slixmpp. # See the file LICENSE for copying permission. +from typing import ( + Iterable, + List, + Optional, + Set, + Tuple, + Union, +) from slixmpp.xmlstream import ElementBase, ET +IdentityType = Tuple[str, str, Optional[str], Optional[str]] + class DiscoInfo(ElementBase): @@ -18,21 +27,23 @@ class DiscoInfo(ElementBase): category with a type of 'pc' to indicate the agent is a human operated client with a GUI, or a category of 'gateway' with a type of 'aim' to identify the agent as a gateway for the legacy AIM protocol. See - for a full list of + `XMPP Registrar Disco Categories`_ for a full list of accepted category and type combinations. + .. _XMPP Registrar Disco Categories: + Features are simply a set of the namespaces that identify the supported features. For example, a client that supports service discovery will - include the feature 'http://jabber.org/protocol/disco#info'. + include the feature ``http://jabber.org/protocol/disco#info``. Since clients and components may operate in several roles at once, identity and feature information may be grouped into "nodes". If one were to write all of the identities and features used by a client, then node names would be like section headings. - Example disco#info stanzas: + Example disco#info stanza: - :: + .. code-block:: xml @@ -46,30 +57,26 @@ class DiscoInfo(ElementBase): - - Stanza Interface: - :: - - node -- The name of the node to either - query or return info from. - identities -- A set of 4-tuples, where each tuple contains - the category, type, xml:lang, and name - of an identity. - features -- A set of namespaces for features. - """ name = 'query' namespace = 'http://jabber.org/protocol/disco#info' plugin_attrib = 'disco_info' + #: Stanza interfaces: + #: + #: - ``node``: The name of the node to either query or return the info from + #: - ``identities``: A set of 4-tuples, where each tuple contains the + #: category, type, xml:lang and name of an identity + #: - ``features``: A set of namespaces for features + #: interfaces = {'node', 'features', 'identities'} lang_interfaces = {'identities'} # Cache identities and features - _identities = set() - _features = set() + _identities: Set[Tuple[str, str, Optional[str]]] + _features: Set[str] - def setup(self, xml=None): + def setup(self, xml: Optional[ET.ElementTree] = None): """ Populate the stanza object using an optional XML object. @@ -84,7 +91,9 @@ class DiscoInfo(ElementBase): self._identities = {id[0:3] for id in self['identities']} self._features = self['features'] - def add_identity(self, category, itype, name=None, lang=None): + def add_identity(self, category: str, itype: str, + name: Optional[str] = None, lang: Optional[str] = None + ) -> bool: """ Add a new identity element. Each identity must be unique in terms of all four identity components. @@ -113,7 +122,8 @@ class DiscoInfo(ElementBase): return True return False - def del_identity(self, category, itype, name=None, lang=None): + def del_identity(self, category: str, itype: str, name=None, + lang: Optional[str] = None) -> bool: """ Remove a given identity. @@ -134,7 +144,8 @@ class DiscoInfo(ElementBase): return True return False - def get_identities(self, lang=None, dedupe=True): + def get_identities(self, lang: Optional[str] = None, dedupe: bool = True + ) -> Iterable[IdentityType]: """ Return a set of all identities in tuple form as so: @@ -147,6 +158,7 @@ class DiscoInfo(ElementBase): :param dedupe: If True, de-duplicate identities, otherwise return a list of all identities. """ + identities: Union[List[IdentityType], Set[IdentityType]] if dedupe: identities = set() else: @@ -158,13 +170,14 @@ class DiscoInfo(ElementBase): id_xml.attrib['type'], id_xml.attrib.get('{%s}lang' % self.xml_ns, None), id_xml.attrib.get('name', None)) - if dedupe: + if isinstance(identities, set): identities.add(id) else: identities.append(id) return identities - def set_identities(self, identities, lang=None): + def set_identities(self, identities: Iterable[IdentityType], + lang: Optional[str] = None): """ Add or replace all identities. The identities must be a in set where each identity is a tuple of the form: @@ -187,7 +200,7 @@ class DiscoInfo(ElementBase): category, itype, lang, name = identity self.add_identity(category, itype, name, lang) - def del_identities(self, lang=None): + def del_identities(self, lang: Optional[str] = None): """ Remove all identities. If a language was specified, only remove identities using that language. @@ -204,7 +217,7 @@ class DiscoInfo(ElementBase): id_xml.attrib.get('{%s}lang' % self.xml_ns, None))) self.xml.remove(id_xml) - def add_feature(self, feature): + def add_feature(self, feature: str) -> bool: """ Add a single, new feature. @@ -218,7 +231,7 @@ class DiscoInfo(ElementBase): return True return False - def del_feature(self, feature): + def del_feature(self, feature: str) -> bool: """ Remove a single feature. @@ -232,20 +245,21 @@ class DiscoInfo(ElementBase): return True return False - def get_features(self, dedupe=True): + def get_features(self, dedupe: bool = True) -> Iterable[str]: """Return the set of all supported features.""" + features: Union[List[str], Set[str]] if dedupe: features = set() else: features = [] for feature_xml in self.xml.findall('{%s}feature' % self.namespace): - if dedupe: + if isinstance(features, set): features.add(feature_xml.attrib['var']) else: features.append(feature_xml.attrib['var']) return features - def set_features(self, features): + def set_features(self, features: Iterable[str]): """ Add or replace the set of supported features. diff --git a/slixmpp/plugins/xep_0030/stanza/items.py b/slixmpp/plugins/xep_0030/stanza/items.py index d322804c..a72a8140 100644 --- a/slixmpp/plugins/xep_0030/stanza/items.py +++ b/slixmpp/plugins/xep_0030/stanza/items.py @@ -1,9 +1,34 @@ - # Slixmpp: The Slick XMPP Library # Copyright (C) 2010 Nathanael C. Fritz, Lance J.T. Stout # This file is part of Slixmpp. # See the file LICENSE for copying permission. -from slixmpp.xmlstream import ElementBase, register_stanza_plugin +from typing import ( + Iterable, + Optional, + Set, + Tuple, +) +from slixmpp import JID +from slixmpp.xmlstream import ( + ElementBase, + ET, + register_stanza_plugin, +) + + +class DiscoItem(ElementBase): + name = 'item' + namespace = 'http://jabber.org/protocol/disco#items' + plugin_attrib = name + interfaces = {'jid', 'node', 'name'} + + def get_node(self) -> Optional[str]: + """Return the item's node name or ``None``.""" + return self._get_attr('node', None) + + def get_name(self) -> Optional[str]: + """Return the item's human readable name, or ``None``.""" + return self._get_attr('name', None) class DiscoItems(ElementBase): @@ -11,7 +36,7 @@ class DiscoItems(ElementBase): """ Example disco#items stanzas: - :: + .. code-block:: xml @@ -28,25 +53,24 @@ class DiscoItems(ElementBase): - Stanza Interface: - :: - - node -- The name of the node to either - query or return info from. - items -- A list of 3-tuples, where each tuple contains - the JID, node, and name of an item. - """ name = 'query' namespace = 'http://jabber.org/protocol/disco#items' plugin_attrib = 'disco_items' + #: Stanza Interface: + #: + #: - ``node``: The name of the node to either + #: query or return info from. + #: - ``items``: A list of 3-tuples, where each tuple contains + #: the JID, node, and name of an item. + #: interfaces = {'node', 'items'} # Cache items - _items = set() + _items: Set[Tuple[JID, Optional[str]]] - def setup(self, xml=None): + def setup(self, xml: Optional[ET.ElementTree] = None): """ Populate the stanza object using an optional XML object. @@ -59,7 +83,8 @@ class DiscoItems(ElementBase): ElementBase.setup(self, xml) self._items = {item[0:2] for item in self['items']} - def add_item(self, jid, node=None, name=None): + def add_item(self, jid: JID, node: Optional[str] = None, + name: Optional[str] = None): """ Add a new item element. Each item is required to have a JID, but may also specify a node value to reference @@ -80,7 +105,7 @@ class DiscoItems(ElementBase): return True return False - def del_item(self, jid, node=None): + def del_item(self, jid: JID, node: Optional[str] = None) -> bool: """ Remove a single item. @@ -96,7 +121,7 @@ class DiscoItems(ElementBase): return True return False - def get_items(self): + def get_items(self) -> Set[DiscoItem]: """Return all items.""" items = set() for item in self['substanzas']: @@ -104,7 +129,7 @@ class DiscoItems(ElementBase): items.add((item['jid'], item['node'], item['name'])) return items - def set_items(self, items): + def set_items(self, items: Iterable[DiscoItem]): """ Set or replace all items. The given items must be in a list or set where each item is a tuple of the form: @@ -127,19 +152,4 @@ class DiscoItems(ElementBase): self.iterables.remove(item) -class DiscoItem(ElementBase): - name = 'item' - namespace = 'http://jabber.org/protocol/disco#items' - plugin_attrib = name - interfaces = {'jid', 'node', 'name'} - - def get_node(self): - """Return the item's node name or ``None``.""" - return self._get_attr('node', None) - - def get_name(self): - """Return the item's human readable name, or ``None``.""" - return self._get_attr('name', None) - - register_stanza_plugin(DiscoItems, DiscoItem, iterable=True) From 49416dacbcf3c4070c16a29370f76dfef6dfad46 Mon Sep 17 00:00:00 2001 From: mathieui Date: Mon, 1 Mar 2021 20:55:46 +0100 Subject: [PATCH 5/5] XEP-0030 static: Fix PEP8, types --- slixmpp/plugins/xep_0030/static.py | 304 ++++++++++++++++++----------- 1 file changed, 188 insertions(+), 116 deletions(-) diff --git a/slixmpp/plugins/xep_0030/static.py b/slixmpp/plugins/xep_0030/static.py index 1ae34148..6863830f 100644 --- a/slixmpp/plugins/xep_0030/static.py +++ b/slixmpp/plugins/xep_0030/static.py @@ -1,20 +1,46 @@ - # Slixmpp: The Slick XMPP Library # Copyright (C) 2010 Nathanael C. Fritz, Lance J.T. Stout # This file is part of Slixmpp. # See the file LICENSE for copying permission. +from __future__ import annotations + import logging -from slixmpp import Iq +from typing import ( + Optional, + Any, + Dict, + Tuple, + TYPE_CHECKING, + Union, + Collection, +) + +from slixmpp import BaseXMPP, JID +from slixmpp.stanza import Iq +from slixmpp.types import TypedDict, OptJidStr, OptJid from slixmpp.exceptions import XMPPError, IqError, IqTimeout -from slixmpp.xmlstream import JID from slixmpp.plugins.xep_0030 import DiscoInfo, DiscoItems log = logging.getLogger(__name__) +if TYPE_CHECKING: + from slixmpp.plugins.xep_0030 import XEP_0030 -class StaticDisco(object): + +class NodeType(TypedDict): + info: DiscoInfo + items: DiscoItems + + +NodesType = Dict[ + Tuple[str, str, str], + NodeType +] + + +class StaticDisco: """ While components will likely require fully dynamic handling @@ -25,75 +51,87 @@ class StaticDisco(object): StaticDisco provides a set of node handlers that will store static sets of disco info and items in memory. - Attributes: - nodes -- A dictionary mapping (JID, node) tuples to a dict - containing a disco#info and a disco#items stanza. - xmpp -- The main Slixmpp object. + :var nodes: A dictionary mapping (JID, node) tuples to a dict + containing a disco#info and a disco#items stanza. + :var xmpp: The main Slixmpp object. + :var disco: The instance of the XEP-0030 plugin. """ - def __init__(self, xmpp, disco): + def __init__(self, xmpp: 'BaseXMPP', disco: 'XEP_0030'): """ Create a static disco interface. Sets of disco#info and disco#items are maintained for every given JID and node combination. These stanzas are used to store disco information in memory without any additional processing. - Arguments: - xmpp -- The main Slixmpp object. + :param xmpp: The main Slixmpp object. + :param disco: The XEP-0030 plugin. """ - self.nodes = {} - self.xmpp = xmpp - self.disco = disco + self.nodes: NodesType = {} + self.xmpp: BaseXMPP = xmpp + self.disco: 'XEP_0030' = disco - def add_node(self, jid=None, node=None, ifrom=None): - """ - Create a new set of stanzas for the provided - JID and node combination. - - Arguments: - jid -- The JID that will own the new stanzas. - node -- The node that will own the new stanzas. - """ + def add_node(self, jid: OptJidStr = None, node: Optional[str] = None, + ifrom: OptJidStr = None) -> NodeType: if jid is None: - jid = self.xmpp.boundjid.full + node_jid = self.xmpp.boundjid.full + elif isinstance(jid, JID): + node_jid = jid.full + if ifrom is None: + node_ifrom = '' + elif isinstance(ifrom, JID): + node_ifrom = ifrom.full + else: + node_ifrom = ifrom + if node is None: + node = '' + if (node_jid, node, node_ifrom) not in self.nodes: + node_dict: NodeType = { + 'info': DiscoInfo(), + 'items': DiscoItems(), + } + node_dict['info']['node'] = node + node_dict['items']['node'] = node + self.nodes[(node_jid, node, node_ifrom)] = node_dict + return self.nodes[(node_jid, node, node_ifrom)] + + def get_node(self, jid: OptJidStr = None, node: Optional[str] = None, + ifrom: OptJidStr = None) -> NodeType: + if jid is None: + node_jid = self.xmpp.boundjid.full + elif isinstance(jid, JID): + node_jid = jid.full + else: + node_jid = jid if node is None: node = '' if ifrom is None: - ifrom = '' - if isinstance(ifrom, JID): - ifrom = ifrom.full - if (jid, node, ifrom) not in self.nodes: - new_node = {'info': DiscoInfo(), 'items': DiscoItems()} - new_node['info']['node'] = node - new_node['items']['node'] = node - self.nodes[(jid, node, ifrom)] = new_node - return self.nodes[(jid, node, ifrom)] + node_ifrom = '' + elif isinstance(ifrom, JID): + node_ifrom = ifrom.full + else: + node_ifrom = ifrom + if (node_jid, node, node_ifrom) not in self.nodes: + self.add_node(node_jid, node, node_ifrom) + return self.nodes[(node_jid, node, node_ifrom)] - def get_node(self, jid=None, node=None, ifrom=None): + def node_exists(self, jid: OptJidStr = None, node: Optional[str] = None, + ifrom: OptJidStr = None) -> bool: if jid is None: - jid = self.xmpp.boundjid.full + node_jid = self.xmpp.boundjid.full + elif isinstance(jid, JID): + node_jid = jid.full + else: + node_jid = jid if node is None: node = '' if ifrom is None: - ifrom = '' - if isinstance(ifrom, JID): - ifrom = ifrom.full - if (jid, node, ifrom) not in self.nodes: - self.add_node(jid, node, ifrom) - return self.nodes[(jid, node, ifrom)] - - def node_exists(self, jid=None, node=None, ifrom=None): - if jid is None: - jid = self.xmpp.boundjid.full - if node is None: - node = '' - if ifrom is None: - ifrom = '' - if isinstance(ifrom, JID): - ifrom = ifrom.full - if (jid, node, ifrom) not in self.nodes: - return False - return True + node_ifrom = '' + elif isinstance(ifrom, JID): + node_ifrom = ifrom.full + else: + node_ifrom = ifrom + return (node_jid, node, node_ifrom) in self.nodes # ================================================================= # Node Handlers @@ -109,18 +147,20 @@ class StaticDisco(object): # the requester's JID, except for cached results. To do that, # register a custom node handler. - async def supports(self, jid, node, ifrom, data): + async def supports(self, jid: OptJid, node: Optional[str], ifrom: OptJid, + data: Any) -> Optional[bool]: """ Check if a JID supports a given feature. The data parameter may provide: - feature -- The feature to check for support. - local -- If true, then the query is for a JID/node + + :param feature: The feature to check for support. + :param local: If true, then the query is for a JID/node combination handled by this Slixmpp instance and no stanzas need to be sent. Otherwise, a disco stanza must be sent to the remove JID to retrieve the info. - cached -- If true, then look for the disco info data from + :param cached: If true, then look for the disco info data from the local cache system. If no results are found, send the query as usual. The self.use_cache setting must be set to true for this option to @@ -147,26 +187,29 @@ class StaticDisco(object): except IqTimeout: return None - async def has_identity(self, jid, node, ifrom, data): + async def has_identity(self, jid: OptJid, node: Optional[str], + ifrom: OptJid, data: Dict[str, Any] + ) -> Optional[bool]: """ Check if a JID has a given identity. The data parameter may provide: - category -- The category of the identity to check. - itype -- The type of the identity to check. - lang -- The language of the identity to check. - local -- If true, then the query is for a JID/node - combination handled by this Slixmpp instance and - no stanzas need to be sent. - Otherwise, a disco stanza must be sent to the - remove JID to retrieve the info. - cached -- If true, then look for the disco info data from - the local cache system. If no results are found, - send the query as usual. The self.use_cache - setting must be set to true for this option to - be useful. If set to false, then the cache will - be skipped, even if a result has already been - cached. Defaults to false. + + :param category: The category of the identity to check. + :param itype: The type of the identity to check. + :param lang: The language of the identity to check. + :param local: If true, then the query is for a JID/node + combination handled by this Slixmpp instance and + no stanzas need to be sent. + Otherwise, a disco stanza must be sent to the + remove JID to retrieve the info. + :param cached: If true, then look for the disco info data from + the local cache system. If no results are found, + send the query as usual. The self.use_cache + setting must be set to true for this option to + be useful. If set to false, then the cache will + be skipped, even if a result has already been + cached. Defaults to false. """ identity = (data.get('category', None), data.get('itype', None), @@ -179,14 +222,17 @@ class StaticDisco(object): info = await self.disco.get_info(jid=jid, node=node, ifrom=ifrom, **data) info = self.disco._wrap(ifrom, jid, info, True) - trunc = lambda i: (i[0], i[1], i[2]) + + def trunc(i): + return (i[0], i[1], i[2]) return identity in map(trunc, info['disco_info']['identities']) except IqError: return False except IqTimeout: return None - def get_info(self, jid, node, ifrom, data): + def get_info(self, jid: OptJid, node: Optional[str], ifrom: OptJid, + data: Any) -> Optional[DiscoInfo]: """ Return the stored info data for the requested JID/node combination. @@ -200,7 +246,8 @@ class StaticDisco(object): else: return self.get_node(jid, node)['info'] - def set_info(self, jid, node, ifrom, data): + def set_info(self, jid: OptJid, node: Optional[str], ifrom: OptJid, + data: DiscoInfo): """ Set the entire info stanza for a JID/node at once. @@ -209,7 +256,8 @@ class StaticDisco(object): new_node = self.add_node(jid, node) new_node['info'] = data - def del_info(self, jid, node, ifrom, data): + def del_info(self, jid: OptJid, node: Optional[str], ifrom: OptJid, + data: Any): """ Reset the info stanza for a given JID/node combination. @@ -218,7 +266,8 @@ class StaticDisco(object): if self.node_exists(jid, node): self.get_node(jid, node)['info'] = DiscoInfo() - def get_items(self, jid, node, ifrom, data): + def get_items(self, jid: OptJid, node: Optional[str], ifrom: OptJid, + data: Any) -> Optional[DiscoItems]: """ Return the stored items data for the requested JID/node combination. @@ -232,7 +281,8 @@ class StaticDisco(object): else: return self.get_node(jid, node)['items'] - def set_items(self, jid, node, ifrom, data): + def set_items(self, jid: OptJid, node: Optional[str], ifrom: OptJid, + data: Dict[str, Collection[Tuple]]): """ Replace the stored items data for a JID/node combination. @@ -243,7 +293,8 @@ class StaticDisco(object): new_node = self.add_node(jid, node) new_node['items']['items'] = items - def del_items(self, jid, node, ifrom, data): + def del_items(self, jid: OptJid, node: Optional[str], ifrom: OptJid, + data: Any): """ Reset the items stanza for a given JID/node combination. @@ -252,15 +303,17 @@ class StaticDisco(object): if self.node_exists(jid, node): self.get_node(jid, node)['items'] = DiscoItems() - def add_identity(self, jid, node, ifrom, data): + def add_identity(self, jid: OptJid, node: Optional[str], ifrom: OptJid, + data: Dict[str, Optional[str]]): """ Add a new identity to the JID/node combination. The data parameter may provide: - category -- The general category to which the agent belongs. - itype -- A more specific designation with the category. - name -- Optional human readable name for this identity. - lang -- Optional standard xml:lang value. + + :param category: The general category to which the agent belongs. + :param itype: A more specific designation with the category. + :param name: Optional human readable name for this identity. + :param lang: Optional standard xml:lang value. """ new_node = self.add_node(jid, node) new_node['info'].add_identity( @@ -269,27 +322,31 @@ class StaticDisco(object): data.get('name', None), data.get('lang', None)) - def set_identities(self, jid, node, ifrom, data): + def set_identities(self, jid: OptJid, node: Optional[str], ifrom: OptJid, + data: Dict[str, Collection[str]]): """ Add or replace all identities for a JID/node combination. The data parameter should include: - identities -- A list of identities in tuple form: - (category, type, name, lang) + + :param identities: A list of identities in tuple form: + (category, type, name, lang) """ identities = data.get('identities', set()) new_node = self.add_node(jid, node) new_node['info']['identities'] = identities - def del_identity(self, jid, node, ifrom, data): + def del_identity(self, jid: OptJid, node: Optional[str], ifrom: OptJid, + data: Dict[str, Optional[str]]): """ Remove an identity from a JID/node combination. The data parameter may provide: - category -- The general category to which the agent belonged. - itype -- A more specific designation with the category. - name -- Optional human readable name for this identity. - lang -- Optional, standard xml:lang value. + + :param category: The general category to which the agent belonged. + :param itype: A more specific designation with the category. + :param name: Optional human readable name for this identity. + :param lang: Optional, standard xml:lang value. """ if self.node_exists(jid, node): self.get_node(jid, node)['info'].del_identity( @@ -298,7 +355,8 @@ class StaticDisco(object): data.get('name', None), data.get('lang', None)) - def del_identities(self, jid, node, ifrom, data): + def del_identities(self, jid: OptJid, node: Optional[str], ifrom: OptJid, + data: Any): """ Remove all identities from a JID/node combination. @@ -307,40 +365,47 @@ class StaticDisco(object): if self.node_exists(jid, node): del self.get_node(jid, node)['info']['identities'] - def add_feature(self, jid, node, ifrom, data): + def add_feature(self, jid: OptJid, node: Optional[str], ifrom: OptJid, + data: Dict[str, str]): """ Add a feature to a JID/node combination. The data parameter should include: - feature -- The namespace of the supported feature. + + :param feature: The namespace of the supported feature. """ new_node = self.add_node(jid, node) new_node['info'].add_feature( data.get('feature', '')) - def set_features(self, jid, node, ifrom, data): + def set_features(self, jid: OptJid, node: Optional[str], ifrom: OptJid, + data: Dict[str, Collection[str]]): """ Add or replace all features for a JID/node combination. The data parameter should include: - features -- The new set of supported features. + + :param features: The new set of supported features. """ features = data.get('features', set()) new_node = self.add_node(jid, node) new_node['info']['features'] = features - def del_feature(self, jid, node, ifrom, data): + def del_feature(self, jid: OptJid, node: Optional[str], ifrom: OptJid, + data: Dict[str, str]): """ Remove a feature from a JID/node combination. The data parameter should include: - feature -- The namespace of the removed feature. + + :param feature: The namespace of the removed feature. """ if self.node_exists(jid, node): self.get_node(jid, node)['info'].del_feature( data.get('feature', '')) - def del_features(self, jid, node, ifrom, data): + def del_features(self, jid: OptJid, node: Optional[str], ifrom: OptJid, + data: Any): """ Remove all features from a JID/node combination. @@ -350,15 +415,17 @@ class StaticDisco(object): return del self.get_node(jid, node)['info']['features'] - def add_item(self, jid, node, ifrom, data): + def add_item(self, jid: OptJid, node: Optional[str], ifrom: OptJid, + data: Dict[str, str]): """ Add an item to a JID/node combination. The data parameter may include: - ijid -- The JID for the item. - inode -- Optional additional information to reference - non-addressable items. - name -- Optional human readable name for the item. + + :param ijid: The JID for the item. + :param inode: Optional additional information to reference + non-addressable items. + :param name: Optional human readable name for the item. """ new_node = self.add_node(jid, node) new_node['items'].add_item( @@ -366,20 +433,23 @@ class StaticDisco(object): node=data.get('inode', ''), name=data.get('name', '')) - def del_item(self, jid, node, ifrom, data): + def del_item(self, jid: OptJid, node: Optional[str], ifrom: OptJid, + data: Dict[str, str]): """ Remove an item from a JID/node combination. The data parameter may include: - ijid -- JID of the item to remove. - inode -- Optional extra identifying information. + + :param ijid: JID of the item to remove. + :param inode: Optional extra identifying information. """ if self.node_exists(jid, node): self.get_node(jid, node)['items'].del_item( data.get('ijid', ''), node=data.get('inode', None)) - def cache_info(self, jid, node, ifrom, data): + def cache_info(self, jid: OptJid, node: Optional[str], ifrom: OptJid, + data: Union[Iq, DiscoInfo]): """ Cache disco information for an external JID. @@ -388,12 +458,15 @@ class StaticDisco(object): the disco#info substanza itself. """ if isinstance(data, Iq): - data = data['disco_info'] + info = data['disco_info'] + else: + info = data new_node = self.add_node(jid, node, ifrom) - new_node['info'] = data + new_node['info'] = info - def get_cached_info(self, jid, node, ifrom, data): + def get_cached_info(self, jid: OptJid, node: Optional[str], ifrom: OptJid, + data: Any) -> Optional[DiscoInfo]: """ Retrieve cached disco info data. @@ -401,5 +474,4 @@ class StaticDisco(object): """ if not self.node_exists(jid, node, ifrom): return None - else: - return self.get_node(jid, node, ifrom)['info'] + return self.get_node(jid, node, ifrom)['info']