Skip to content
Back to top
View this page

# XEP-0060: Publish-Subscribe

class slixmpp.plugins.xep_0060.XEP_0060(xmpp, config=None)

  XEP-0060 Publish Subscribe

  create_node(jid, node, config=None, ntype=None, ifrom=None, callback=None, timeout=None)

    Create and configure a new pubsub node.

    A server MAY use a different name for the node than the one provided, so be sure to check the result stanza for a server assigned name.

    If no configuration form is provided, the node will be created using the server’s default configuration. To get the default configuration use get_node_config().

    Parameters:

      - jid – The JID of the pubsub service.

      - node – Optional name of the node to create. If no name is provided, the server MAY generate a node ID for you. The server can also assign a different name than the one you provide; check the result stanza to see if the server assigned a name.

      - config – Optional XEP-0004 data form of configuration settings.

      - ntype – The type of node to create. Servers typically default to using ‘leaf’ if no type is provided.

  delete_node(jid, node, ifrom=None, callback=None, timeout=None)

    Delete a a pubsub node.

    Parameters:

      - jid – The JID of the pubsub service.

      - node – The node to delete.

  dependencies: ClassVar[set[str]] = {'xep_0004', 'xep_0030', 'xep_0082', 'xep_0131'}

    Some plugins may depend on others in order to function properly. Any plugin names included in `dependencies` will be initialized as needed if this plugin is enabled.

  description: str = 'XEP-0060: Publish-Subscribe'

    A longer name for the plugin, describing its purpose. For example, a plugin for XEP-0030 would use ‘Service Discovery’ as its description value.

  get_item(jid, node, item_id, ifrom=None, callback=None, timeout=None)

    Retrieve the content of an individual item.

  get_item_ids(jid, node, ifrom=None, callback=None, timeout=None, iterator=False)

    Retrieve the ItemIDs hosted by a given node, using disco.

  get_items(jid, node, item_ids=None, max_items=None, iterator=False, ifrom=None, callback=None, timeout=None)

    Request the contents of a node’s items.

    The desired items can be specified, or a query for the last few published items can be used.

    Pubsub services may use result set management for nodes with many items, so an iterator can be returned if needed.

  get_node_affiliations(jid, node, ifrom=None, callback=None, timeout=None)

    Retrieve the affiliations associated with a given node.

    Parameters:

      - jid – The JID of the pubsub service.

      - node – The node to retrieve affiliations from.

  get_node_config(jid, node=None, ifrom=None, callback=None, timeout=None)

    Retrieve the configuration for a node, or the pubsub service’s default configuration for new nodes.

    Parameters:

      - jid – The JID of the pubsub service.

      - node – The node to retrieve the configuration for. If None, the default configuration for new nodes will be requested. Defaults to None.

  get_node_subscriptions(jid, node, ifrom=None, callback=None, timeout=None)

    Retrieve the subscriptions associated with a given node.

    Parameters:

      - jid – The JID of the pubsub service.

      - node – The node to retrieve subscriptions from.

  get_nodes(*args, **kwargs)

    Discover the nodes provided by a Pubsub service, using disco.

  map_node_event(node, event_name)

    Map node names to events.

    When a pubsub event is received for the given node, raise the provided event.

    For example:

        map_node_event('http://jabber.org/protocol/tune',
                       'user_tune')

    will produce the events ‘user_tune_publish’ and ‘user_tune_retract’ when the respective notifications are received from the node ‘http://jabber.org/protocol/tune’, among other events.

    Parameters:

      - node – The node name to map to an event.

      - event_name – The name of the event to raise when a notification from the given node is received.

  name: str = 'xep_0060'

    A short name for the plugin based on the implemented specification. For example, a plugin for XEP-0030 would use ‘xep_0030’.

  publish(jid, node, id=None, payload=None, options=None, ifrom=None, callback=None, timeout=None)

    Add a new item to a node, or edit an existing item.

    For services that support it, you can use the publish command as an event signal by not including an ID or payload.

    When including a payload and you do not provide an ID then the service will generally create an ID for you.

    Publish options may be specified, and how those options are processed is left to the service, such as treating the options as preconditions that the node’s settings must match.

    Parameters:

      - jid – The JID of the pubsub service.

      - node – The node to publish the item to.

      - id – Optionally specify the ID of the item.

      - payload – The item content to publish.

      - options – A form of publish options.

  purge(jid, node, ifrom=None, callback=None, timeout=None)

    Remove all items from a node.

  retract(jid, node, id, notify=None, ifrom=None, callback=None, timeout=None)

    Delete a single item from a node.

  subscribe(jid, node, bare=True, subscribee=None, options=None, ifrom=None, callback=None, timeout=None)

    Subscribe to updates from a pubsub node.

    The rules for determining the JID that is subscribing to the node are: 1. If subscribee is given, use that as provided. 2. If ifrom was given, use the bare or full version based on bare. 3. Otherwise, use self.xmpp.boundjid based on bare.

    Parameters:

      - jid – The pubsub service JID.

      - node – The node to subscribe to.

      - bare – Indicates if the subscribee is a bare or full JID. Defaults to True for a bare JID.

      - subscribee – The JID that is subscribing to the node.

      - options

  unsubscribe(jid, node, subid=None, bare=True, subscribee=None, ifrom=None, callback=None, timeout=None)

    Unsubscribe from updates from a pubsub node.

    The rules for determining the JID that is unsubscribing from the node are: 1. If subscribee is given, use that as provided. 2. If ifrom was given, use the bare or full version based on bare. 3. Otherwise, use self.xmpp.boundjid based on bare.

    Parameters:

      - jid – The pubsub service JID.

      - node – The node to unsubscribe from.

      - subid – The specific subscription, if multiple subscriptions exist for this JID/node combination.

      - bare – Indicates if the subscribee is a bare or full JID. Defaults to True for a bare JID.

      - subscribee – The JID that is unsubscribing from the node.

## Stanza elements

class slixmpp.plugins.xep_0060.stanza.base.OptionalSetting
  del_required()
  get_required()
  interfaces = {'required'}
  namespace: str
  set_required(value)
  xml: Element

class slixmpp.plugins.xep_0060.stanza.pubsub.Affiliation(xml=None, parent=None)
  get_jid()
  interfaces: ClassVar[set[str]] = {'affiliation', 'jid', 'node'}

    The set of keys that the stanza provides for accessing and manipulating the underlying XML object. This set may be augmented with the `plugin_attrib` value of any registered stanza plugins.

  name: ClassVar[str] = 'affiliation'

    The XML tag name of the element, not including any namespace prefixes. For example, an `ElementBase` object for `<message />` would use `name = 'message'`.

  namespace: str = 'http://jabber.org/protocol/pubsub'

    The XML namespace for the element. Given `<foo xmlns="bar" />`, then `namespace = "bar"` should be used. The default namespace is `jabber:client` since this is being used in an XMPP library.

  plugin_attrib: ClassVar[str] = 'affiliation'

    For `ElementBase` subclasses which are intended to be used as plugins, the `plugin_attrib` value defines the plugin name. Plugins may be accessed by using the `plugin_attrib` value as the interface. An example using `plugin_attrib = 'foo'`:

        register_stanza_plugin(Message, FooPlugin)
        msg = Message()
        msg['foo']['an_interface_from_the_foo_plugin']

  set_jid(value)

class slixmpp.plugins.xep_0060.stanza.pubsub.Affiliations(xml=None, parent=None)
  interfaces: ClassVar[set[str]] = {'node'}

    The set of keys that the stanza provides for accessing and manipulating the underlying XML object. This set may be augmented with the `plugin_attrib` value of any registered stanza plugins.

  name: ClassVar[str] = 'affiliations'

    The XML tag name of the element, not including any namespace prefixes. For example, an `ElementBase` object for `<message />` would use `name = 'message'`.

  namespace: str = 'http://jabber.org/protocol/pubsub'

    The XML namespace for the element. Given `<foo xmlns="bar" />`, then `namespace = "bar"` should be used. The default namespace is `jabber:client` since this is being used in an XMPP library.

  plugin_attrib: ClassVar[str] = 'affiliations'

    For `ElementBase` subclasses which are intended to be used as plugins, the `plugin_attrib` value defines the plugin name. Plugins may be accessed by using the `plugin_attrib` value as the interface. An example using `plugin_attrib = 'foo'`:

        register_stanza_plugin(Message, FooPlugin)
        msg = Message()
        msg['foo']['an_interface_from_the_foo_plugin']

  plugin_attrib_map: ClassVar[dict[str, type[ElementBase]]] = {'affiliation': <class 'slixmpp.plugins.xep_0060.stanza.pubsub.Affiliation'>}

    A mapping of the `plugin_attrib` values of registered plugins to their respective classes.

  plugin_iterables: ClassVar[set[type[ElementBase]]] = {<class 'slixmpp.plugins.xep_0060.stanza.pubsub.Affiliation'>}

    The set of stanza classes that can be iterated over using the ‘substanzas’ interface. Classes are added to this set when registering a plugin with `iterable=True`:

        register_stanza_plugin(DiscoInfo, DiscoItem, iterable=True)

    Added in version 1.0-Beta5.

  plugin_overrides: ClassVar[dict[str, str]] = {}

    A map of interface operations to the overriding functions. For example, after overriding the `set` operation for the interface `body`, `plugin_overrides` would be:

        {'set_body': <some function>}

  plugin_tag_map: ClassVar[dict[str, type[ElementBase]]] = {'{http://jabber.org/protocol/pubsub}affiliation': <class 'slixmpp.plugins.xep_0060.stanza.pubsub.Affiliation'>}

    A mapping of root element tag names (in `'{namespace}elementname'` format) to the plugin classes responsible for them.

class slixmpp.plugins.xep_0060.stanza.pubsub.Configure(xml=None, parent=None)
  getType()
  interfaces: ClassVar[set[str]] = {'node', 'type'}

    The set of keys that the stanza provides for accessing and manipulating the underlying XML object. This set may be augmented with the `plugin_attrib` value of any registered stanza plugins.

  name: ClassVar[str] = 'configure'

    The XML tag name of the element, not including any namespace prefixes. For example, an `ElementBase` object for `<message />` would use `name = 'message'`.

  namespace: str = 'http://jabber.org/protocol/pubsub'

    The XML namespace for the element. Given `<foo xmlns="bar" />`, then `namespace = "bar"` should be used. The default namespace is `jabber:client` since this is being used in an XMPP library.

  plugin_attrib: ClassVar[str] = 'configure'

    For `ElementBase` subclasses which are intended to be used as plugins, the `plugin_attrib` value defines the plugin name. Plugins may be accessed by using the `plugin_attrib` value as the interface. An example using `plugin_attrib = 'foo'`:

        register_stanza_plugin(Message, FooPlugin)
        msg = Message()
        msg['foo']['an_interface_from_the_foo_plugin']

  plugin_attrib_map: ClassVar[dict[str, type[ElementBase]]] = {'form': <class 'slixmpp.plugins.xep_0004.stanza.form.Form'>}

    A mapping of the `plugin_attrib` values of registered plugins to their respective classes.

  plugin_iterables: ClassVar[set[type[ElementBase]]] = {}

    The set of stanza classes that can be iterated over using the ‘substanzas’ interface. Classes are added to this set when registering a plugin with `iterable=True`:

        register_stanza_plugin(DiscoInfo, DiscoItem, iterable=True)

    Added in version 1.0-Beta5.

  plugin_overrides: ClassVar[dict[str, str]] = {}

    A map of interface operations to the overriding functions. For example, after overriding the `set` operation for the interface `body`, `plugin_overrides` would be:

        {'set_body': <some function>}

  plugin_tag_map: ClassVar[dict[str, type[ElementBase]]] = {'{jabber:x:data}x': <class 'slixmpp.plugins.xep_0004.stanza.form.Form'>}

    A mapping of root element tag names (in `'{namespace}elementname'` format) to the plugin classes responsible for them.

class slixmpp.plugins.xep_0060.stanza.pubsub.Create(xml=None, parent=None)
  interfaces: ClassVar[set[str]] = {'node'}

    The set of keys that the stanza provides for accessing and manipulating the underlying XML object. This set may be augmented with the `plugin_attrib` value of any registered stanza plugins.

  name: ClassVar[str] = 'create'

    The XML tag name of the element, not including any namespace prefixes. For example, an `ElementBase` object for `<message />` would use `name = 'message'`.

  namespace: str = 'http://jabber.org/protocol/pubsub'

    The XML namespace for the element. Given `<foo xmlns="bar" />`, then `namespace = "bar"` should be used. The default namespace is `jabber:client` since this is being used in an XMPP library.

  plugin_attrib: ClassVar[str] = 'create'

    For `ElementBase` subclasses which are intended to be used as plugins, the `plugin_attrib` value defines the plugin name. Plugins may be accessed by using the `plugin_attrib` value as the interface. An example using `plugin_attrib = 'foo'`:

        register_stanza_plugin(Message, FooPlugin)
        msg = Message()
        msg['foo']['an_interface_from_the_foo_plugin']

class slixmpp.plugins.xep_0060.stanza.pubsub.Default(xml=None, parent=None)
  get_type()
  interfaces: ClassVar[set[str]] = {'node', 'type'}

    The set of keys that the stanza provides for accessing and manipulating the underlying XML object. This set may be augmented with the `plugin_attrib` value of any registered stanza plugins.

  name: ClassVar[str] = 'default'

    The XML tag name of the element, not including any namespace prefixes. For example, an `ElementBase` object for `<message />` would use `name = 'message'`.

  namespace: str = 'http://jabber.org/protocol/pubsub'

    The XML namespace for the element. Given `<foo xmlns="bar" />`, then `namespace = "bar"` should be used. The default namespace is `jabber:client` since this is being used in an XMPP library.

  plugin_attrib: ClassVar[str] = 'default'

    For `ElementBase` subclasses which are intended to be used as plugins, the `plugin_attrib` value defines the plugin name. Plugins may be accessed by using the `plugin_attrib` value as the interface. An example using `plugin_attrib = 'foo'`:

        register_stanza_plugin(Message, FooPlugin)
        msg = Message()
        msg['foo']['an_interface_from_the_foo_plugin']

class slixmpp.plugins.xep_0060.stanza.pubsub.Item(xml=None, parent=None)
  del_payload()
  get_payload()
  interfaces: ClassVar[set[str]] = {'id', 'payload'}

    The set of keys that the stanza provides for accessing and manipulating the underlying XML object. This set may be augmented with the `plugin_attrib` value of any registered stanza plugins.

  name: ClassVar[str] = 'item'

    The XML tag name of the element, not including any namespace prefixes. For example, an `ElementBase` object for `<message />` would use `name = 'message'`.

  namespace: str = 'http://jabber.org/protocol/pubsub'

    The XML namespace for the element. Given `<foo xmlns="bar" />`, then `namespace = "bar"` should be used. The default namespace is `jabber:client` since this is being used in an XMPP library.

  plugin_attrib: ClassVar[str] = 'item'

    For `ElementBase` subclasses which are intended to be used as plugins, the `plugin_attrib` value defines the plugin name. Plugins may be accessed by using the `plugin_attrib` value as the interface. An example using `plugin_attrib = 'foo'`:

        register_stanza_plugin(Message, FooPlugin)
        msg = Message()
        msg['foo']['an_interface_from_the_foo_plugin']

  plugin_multi_attrib: ClassVar[str] = 'items'

    For `ElementBase` subclasses that are intended to be an iterable group of items, the `plugin_multi_attrib` value defines an interface for the parent stanza which returns the entire group of matching substanzas. So the following are equivalent:

        # Given stanza class Foo, with plugin_multi_attrib = 'foos'
        parent['foos']
        filter(isinstance(item, Foo), parent['substanzas'])

  set_payload(value)

class slixmpp.plugins.xep_0060.stanza.pubsub.Items(xml=None, parent=None)
  interfaces: ClassVar[set[str]] = {'max_items', 'node'}

    The set of keys that the stanza provides for accessing and manipulating the underlying XML object. This set may be augmented with the `plugin_attrib` value of any registered stanza plugins.

  name: ClassVar[str] = 'items'

    The XML tag name of the element, not including any namespace prefixes. For example, an `ElementBase` object for `<message />` would use `name = 'message'`.

  namespace: str = 'http://jabber.org/protocol/pubsub'

    The XML namespace for the element. Given `<foo xmlns="bar" />`, then `namespace = "bar"` should be used. The default namespace is `jabber:client` since this is being used in an XMPP library.

  plugin_attrib: ClassVar[str] = 'items'

    For `ElementBase` subclasses which are intended to be used as plugins, the `plugin_attrib` value defines the plugin name. Plugins may be accessed by using the `plugin_attrib` value as the interface. An example using `plugin_attrib = 'foo'`:

        register_stanza_plugin(Message, FooPlugin)
        msg = Message()
        msg['foo']['an_interface_from_the_foo_plugin']

  plugin_attrib_map: ClassVar[dict[str, type[ElementBase]]] = {'item': <class 'slixmpp.plugins.xep_0060.stanza.pubsub.Item'>, 'items': <class 'slixmpp.xmlstream.stanzabase.multifactory.<locals>.Multi'>}

    A mapping of the `plugin_attrib` values of registered plugins to their respective classes.

  plugin_iterables: ClassVar[set[type[ElementBase]]] = {<class 'slixmpp.plugins.xep_0060.stanza.pubsub.Item'>}

    The set of stanza classes that can be iterated over using the ‘substanzas’ interface. Classes are added to this set when registering a plugin with `iterable=True`:

        register_stanza_plugin(DiscoInfo, DiscoItem, iterable=True)

    Added in version 1.0-Beta5.

  plugin_overrides: ClassVar[dict[str, str]] = {}

    A map of interface operations to the overriding functions. For example, after overriding the `set` operation for the interface `body`, `plugin_overrides` would be:

        {'set_body': <some function>}

  plugin_tag_map: ClassVar[dict[str, type[ElementBase]]] = {'{http://jabber.org/protocol/pubsub}item': <class 'slixmpp.plugins.xep_0060.stanza.pubsub.Item'>, '{jabber:client}stanza': <class 'slixmpp.xmlstream.stanzabase.multifactory.<locals>.Multi'>}

    A mapping of root element tag names (in `'{namespace}elementname'` format) to the plugin classes responsible for them.

  set_max_items(value)

class slixmpp.plugins.xep_0060.stanza.pubsub.Options(*args, **kwargs)
  del_options()
  get_jid()
  get_options()
  interfaces: ClassVar[set[str]] = {'jid', 'node', 'options'}

    The set of keys that the stanza provides for accessing and manipulating the underlying XML object. This set may be augmented with the `plugin_attrib` value of any registered stanza plugins.

  name: ClassVar[str] = 'options'

    The XML tag name of the element, not including any namespace prefixes. For example, an `ElementBase` object for `<message />` would use `name = 'message'`.

  namespace: str = 'http://jabber.org/protocol/pubsub'

    The XML namespace for the element. Given `<foo xmlns="bar" />`, then `namespace = "bar"` should be used. The default namespace is `jabber:client` since this is being used in an XMPP library.

  plugin_attrib: ClassVar[str] = 'options'

    For `ElementBase` subclasses which are intended to be used as plugins, the `plugin_attrib` value defines the plugin name. Plugins may be accessed by using the `plugin_attrib` value as the interface. An example using `plugin_attrib = 'foo'`:

        register_stanza_plugin(Message, FooPlugin)
        msg = Message()
        msg['foo']['an_interface_from_the_foo_plugin']

  set_jid(value)
  set_options(value)

class slixmpp.plugins.xep_0060.stanza.pubsub.Publish(xml=None, parent=None)
  interfaces: ClassVar[set[str]] = {'node'}

    The set of keys that the stanza provides for accessing and manipulating the underlying XML object. This set may be augmented with the `plugin_attrib` value of any registered stanza plugins.

  name: ClassVar[str] = 'publish'

    The XML tag name of the element, not including any namespace prefixes. For example, an `ElementBase` object for `<message />` would use `name = 'message'`.

  namespace: str = 'http://jabber.org/protocol/pubsub'

    The XML namespace for the element. Given `<foo xmlns="bar" />`, then `namespace = "bar"` should be used. The default namespace is `jabber:client` since this is being used in an XMPP library.

  plugin_attrib: ClassVar[str] = 'publish'

    For `ElementBase` subclasses which are intended to be used as plugins, the `plugin_attrib` value defines the plugin name. Plugins may be accessed by using the `plugin_attrib` value as the interface. An example using `plugin_attrib = 'foo'`:

        register_stanza_plugin(Message, FooPlugin)
        msg = Message()
        msg['foo']['an_interface_from_the_foo_plugin']

  plugin_attrib_map: ClassVar[dict[str, type[ElementBase]]] = {'item': <class 'slixmpp.plugins.xep_0060.stanza.pubsub.Item'>, 'items': <class 'slixmpp.xmlstream.stanzabase.multifactory.<locals>.Multi'>}

    A mapping of the `plugin_attrib` values of registered plugins to their respective classes.

  plugin_iterables: ClassVar[set[type[ElementBase]]] = {<class 'slixmpp.plugins.xep_0060.stanza.pubsub.Item'>}

    The set of stanza classes that can be iterated over using the ‘substanzas’ interface. Classes are added to this set when registering a plugin with `iterable=True`:

        register_stanza_plugin(DiscoInfo, DiscoItem, iterable=True)

    Added in version 1.0-Beta5.

  plugin_overrides: ClassVar[dict[str, str]] = {}

    A map of interface operations to the overriding functions. For example, after overriding the `set` operation for the interface `body`, `plugin_overrides` would be:

        {'set_body': <some function>}

  plugin_tag_map: ClassVar[dict[str, type[ElementBase]]] = {'{http://jabber.org/protocol/pubsub}item': <class 'slixmpp.plugins.xep_0060.stanza.pubsub.Item'>, '{jabber:client}stanza': <class 'slixmpp.xmlstream.stanzabase.multifactory.<locals>.Multi'>}

    A mapping of root element tag names (in `'{namespace}elementname'` format) to the plugin classes responsible for them.

class slixmpp.plugins.xep_0060.stanza.pubsub.PublishOptions(xml=None, parent=None)
  del_publish_options()
  get_publish_options()
  interfaces: ClassVar[set[str]] = {'publish_options'}

    The set of keys that the stanza provides for accessing and manipulating the underlying XML object. This set may be augmented with the `plugin_attrib` value of any registered stanza plugins.

  is_extension: ClassVar[bool] = True

    If you need to add a new interface to an existing stanza, you can create a plugin and set `is_extension = True`. Be sure to set the `plugin_attrib` value to the desired interface name, and that it is the only interface listed in `interfaces`. Requests for the new interface from the parent stanza will be passed to the plugin directly.

    Added in version 1.0-Beta5.

  name: ClassVar[str] = 'publish-options'

    The XML tag name of the element, not including any namespace prefixes. For example, an `ElementBase` object for `<message />` would use `name = 'message'`.

  namespace: str = 'http://jabber.org/protocol/pubsub'

    The XML namespace for the element. Given `<foo xmlns="bar" />`, then `namespace = "bar"` should be used. The default namespace is `jabber:client` since this is being used in an XMPP library.

  plugin_attrib: ClassVar[str] = 'publish_options'

    For `ElementBase` subclasses which are intended to be used as plugins, the `plugin_attrib` value defines the plugin name. Plugins may be accessed by using the `plugin_attrib` value as the interface. An example using `plugin_attrib = 'foo'`:

        register_stanza_plugin(Message, FooPlugin)
        msg = Message()
        msg['foo']['an_interface_from_the_foo_plugin']

  set_publish_options(value)

class slixmpp.plugins.xep_0060.stanza.pubsub.Pubsub(xml=None, parent=None)
  interfaces: ClassVar[set[str]] = {}

    The set of keys that the stanza provides for accessing and manipulating the underlying XML object. This set may be augmented with the `plugin_attrib` value of any registered stanza plugins.

  name: ClassVar[str] = 'pubsub'

    The XML tag name of the element, not including any namespace prefixes. For example, an `ElementBase` object for `<message />` would use `name = 'message'`.

  namespace: str = 'http://jabber.org/protocol/pubsub'

    The XML namespace for the element. Given `<foo xmlns="bar" />`, then `namespace = "bar"` should be used. The default namespace is `jabber:client` since this is being used in an XMPP library.

  plugin_attrib: ClassVar[str] = 'pubsub'

    For `ElementBase` subclasses which are intended to be used as plugins, the `plugin_attrib` value defines the plugin name. Plugins may be accessed by using the `plugin_attrib` value as the interface. An example using `plugin_attrib = 'foo'`:

        register_stanza_plugin(Message, FooPlugin)
        msg = Message()
        msg['foo']['an_interface_from_the_foo_plugin']

  plugin_attrib_map: ClassVar[dict[str, type[ElementBase]]] = {'affiliations': <class 'slixmpp.plugins.xep_0060.stanza.pubsub.Affiliations'>, 'configure': <class 'slixmpp.plugins.xep_0060.stanza.pubsub.Configure'>, 'create': <class 'slixmpp.plugins.xep_0060.stanza.pubsub.Create'>, 'default': <class 'slixmpp.plugins.xep_0060.stanza.pubsub.Default'>, 'items': <class 'slixmpp.plugins.xep_0060.stanza.pubsub.Items'>, 'options': <class 'slixmpp.plugins.xep_0060.stanza.pubsub.Options'>, 'publish': <class 'slixmpp.plugins.xep_0060.stanza.pubsub.Publish'>, 'publish_options': <class 'slixmpp.plugins.xep_0060.stanza.pubsub.PublishOptions'>, 'retract': <class 'slixmpp.plugins.xep_0060.stanza.pubsub.Retract'>, 'subscribe': <class 'slixmpp.plugins.xep_0060.stanza.pubsub.Subscribe'>, 'subscription': <class 'slixmpp.plugins.xep_0060.stanza.pubsub.Subscription'>, 'subscriptions': <class 'slixmpp.plugins.xep_0060.stanza.pubsub.Subscriptions'>, 'unsubscribe': <class 'slixmpp.plugins.xep_0060.stanza.pubsub.Unsubscribe'>}

    A mapping of the `plugin_attrib` values of registered plugins to their respective classes.

  plugin_iterables: ClassVar[set[type[ElementBase]]] = {}

    The set of stanza classes that can be iterated over using the ‘substanzas’ interface. Classes are added to this set when registering a plugin with `iterable=True`:

        register_stanza_plugin(DiscoInfo, DiscoItem, iterable=True)

    Added in version 1.0-Beta5.

  plugin_overrides: ClassVar[dict[str, str]] = {}

    A map of interface operations to the overriding functions. For example, after overriding the `set` operation for the interface `body`, `plugin_overrides` would be:

        {'set_body': <some function>}

  plugin_tag_map: ClassVar[dict[str, type[ElementBase]]] = {'{http://jabber.org/protocol/pubsub}affiliations': <class 'slixmpp.plugins.xep_0060.stanza.pubsub.Affiliations'>, '{http://jabber.org/protocol/pubsub}configure': <class 'slixmpp.plugins.xep_0060.stanza.pubsub.Configure'>, '{http://jabber.org/protocol/pubsub}create': <class 'slixmpp.plugins.xep_0060.stanza.pubsub.Create'>, '{http://jabber.org/protocol/pubsub}default': <class 'slixmpp.plugins.xep_0060.stanza.pubsub.Default'>, '{http://jabber.org/protocol/pubsub}items': <class 'slixmpp.plugins.xep_0060.stanza.pubsub.Items'>, '{http://jabber.org/protocol/pubsub}options': <class 'slixmpp.plugins.xep_0060.stanza.pubsub.Options'>, '{http://jabber.org/protocol/pubsub}publish': <class 'slixmpp.plugins.xep_0060.stanza.pubsub.Publish'>, '{http://jabber.org/protocol/pubsub}publish-options': <class 'slixmpp.plugins.xep_0060.stanza.pubsub.PublishOptions'>, '{http://jabber.org/protocol/pubsub}retract': <class 'slixmpp.plugins.xep_0060.stanza.pubsub.Retract'>, '{http://jabber.org/protocol/pubsub}subscribe': <class 'slixmpp.plugins.xep_0060.stanza.pubsub.Subscribe'>, '{http://jabber.org/protocol/pubsub}subscription': <class 'slixmpp.plugins.xep_0060.stanza.pubsub.Subscription'>, '{http://jabber.org/protocol/pubsub}subscriptions': <class 'slixmpp.plugins.xep_0060.stanza.pubsub.Subscriptions'>, '{http://jabber.org/protocol/pubsub}unsubscribe': <class 'slixmpp.plugins.xep_0060.stanza.pubsub.Unsubscribe'>}

    A mapping of root element tag names (in `'{namespace}elementname'` format) to the plugin classes responsible for them.

class slixmpp.plugins.xep_0060.stanza.pubsub.Retract(xml=None, parent=None)
  get_notify()
  interfaces: ClassVar[set[str]] = {'node', 'notify'}

    The set of keys that the stanza provides for accessing and manipulating the underlying XML object. This set may be augmented with the `plugin_attrib` value of any registered stanza plugins.

  name: ClassVar[str] = 'retract'

    The XML tag name of the element, not including any namespace prefixes. For example, an `ElementBase` object for `<message />` would use `name = 'message'`.

  namespace: str = 'http://jabber.org/protocol/pubsub'

    The XML namespace for the element. Given `<foo xmlns="bar" />`, then `namespace = "bar"` should be used. The default namespace is `jabber:client` since this is being used in an XMPP library.

  plugin_attrib: ClassVar[str] = 'retract'

    For `ElementBase` subclasses which are intended to be used as plugins, the `plugin_attrib` value defines the plugin name. Plugins may be accessed by using the `plugin_attrib` value as the interface. An example using `plugin_attrib = 'foo'`:

        register_stanza_plugin(Message, FooPlugin)
        msg = Message()
        msg['foo']['an_interface_from_the_foo_plugin']

  plugin_attrib_map: ClassVar[dict[str, type[ElementBase]]] = {'item': <class 'slixmpp.plugins.xep_0060.stanza.pubsub.Item'>}

    A mapping of the `plugin_attrib` values of registered plugins to their respective classes.

  plugin_iterables: ClassVar[set[type[ElementBase]]] = {}

    The set of stanza classes that can be iterated over using the ‘substanzas’ interface. Classes are added to this set when registering a plugin with `iterable=True`:

        register_stanza_plugin(DiscoInfo, DiscoItem, iterable=True)

    Added in version 1.0-Beta5.

  plugin_overrides: ClassVar[dict[str, str]] = {}

    A map of interface operations to the overriding functions. For example, after overriding the `set` operation for the interface `body`, `plugin_overrides` would be:

        {'set_body': <some function>}

  plugin_tag_map: ClassVar[dict[str, type[ElementBase]]] = {'{http://jabber.org/protocol/pubsub}item': <class 'slixmpp.plugins.xep_0060.stanza.pubsub.Item'>}

    A mapping of root element tag names (in `'{namespace}elementname'` format) to the plugin classes responsible for them.

  set_notify(value)

class slixmpp.plugins.xep_0060.stanza.pubsub.Subscribe(xml=None, parent=None)
  get_jid()
  interfaces: ClassVar[set[str]] = {'jid', 'node'}

    The set of keys that the stanza provides for accessing and manipulating the underlying XML object. This set may be augmented with the `plugin_attrib` value of any registered stanza plugins.

  name: ClassVar[str] = 'subscribe'

    The XML tag name of the element, not including any namespace prefixes. For example, an `ElementBase` object for `<message />` would use `name = 'message'`.

  namespace: str = 'http://jabber.org/protocol/pubsub'

    The XML namespace for the element. Given `<foo xmlns="bar" />`, then `namespace = "bar"` should be used. The default namespace is `jabber:client` since this is being used in an XMPP library.

  plugin_attrib: ClassVar[str] = 'subscribe'

    For `ElementBase` subclasses which are intended to be used as plugins, the `plugin_attrib` value defines the plugin name. Plugins may be accessed by using the `plugin_attrib` value as the interface. An example using `plugin_attrib = 'foo'`:

        register_stanza_plugin(Message, FooPlugin)
        msg = Message()
        msg['foo']['an_interface_from_the_foo_plugin']

  plugin_attrib_map: ClassVar[dict[str, type[ElementBase]]] = {'options': <class 'slixmpp.plugins.xep_0060.stanza.pubsub.Options'>}

    A mapping of the `plugin_attrib` values of registered plugins to their respective classes.

  plugin_iterables: ClassVar[set[type[ElementBase]]] = {}

    The set of stanza classes that can be iterated over using the ‘substanzas’ interface. Classes are added to this set when registering a plugin with `iterable=True`:

        register_stanza_plugin(DiscoInfo, DiscoItem, iterable=True)

    Added in version 1.0-Beta5.

  plugin_overrides: ClassVar[dict[str, str]] = {}

    A map of interface operations to the overriding functions. For example, after overriding the `set` operation for the interface `body`, `plugin_overrides` would be:

        {'set_body': <some function>}

  plugin_tag_map: ClassVar[dict[str, type[ElementBase]]] = {'{http://jabber.org/protocol/pubsub}options': <class 'slixmpp.plugins.xep_0060.stanza.pubsub.Options'>}

    A mapping of root element tag names (in `'{namespace}elementname'` format) to the plugin classes responsible for them.

  set_jid(value)

class slixmpp.plugins.xep_0060.stanza.pubsub.SubscribeOptions(xml=None, parent=None)
  interfaces: ClassVar[set[str]] = {'required'}

    The set of keys that the stanza provides for accessing and manipulating the underlying XML object. This set may be augmented with the `plugin_attrib` value of any registered stanza plugins.

  name: ClassVar[str] = 'subscribe-options'

    The XML tag name of the element, not including any namespace prefixes. For example, an `ElementBase` object for `<message />` would use `name = 'message'`.

  namespace: str = 'http://jabber.org/protocol/pubsub'

    The XML namespace for the element. Given `<foo xmlns="bar" />`, then `namespace = "bar"` should be used. The default namespace is `jabber:client` since this is being used in an XMPP library.

  plugin_attrib: ClassVar[str] = 'suboptions'

    For `ElementBase` subclasses which are intended to be used as plugins, the `plugin_attrib` value defines the plugin name. Plugins may be accessed by using the `plugin_attrib` value as the interface. An example using `plugin_attrib = 'foo'`:

        register_stanza_plugin(Message, FooPlugin)
        msg = Message()
        msg['foo']['an_interface_from_the_foo_plugin']

class slixmpp.plugins.xep_0060.stanza.pubsub.Subscription(xml=None, parent=None)
  get_jid()
  interfaces: ClassVar[set[str]] = {'jid', 'node', 'subid', 'subscription'}

    The set of keys that the stanza provides for accessing and manipulating the underlying XML object. This set may be augmented with the `plugin_attrib` value of any registered stanza plugins.

  name: ClassVar[str] = 'subscription'

    The XML tag name of the element, not including any namespace prefixes. For example, an `ElementBase` object for `<message />` would use `name = 'message'`.

  namespace: str = 'http://jabber.org/protocol/pubsub'

    The XML namespace for the element. Given `<foo xmlns="bar" />`, then `namespace = "bar"` should be used. The default namespace is `jabber:client` since this is being used in an XMPP library.

  plugin_attrib: ClassVar[str] = 'subscription'

    For `ElementBase` subclasses which are intended to be used as plugins, the `plugin_attrib` value defines the plugin name. Plugins may be accessed by using the `plugin_attrib` value as the interface. An example using `plugin_attrib = 'foo'`:

        register_stanza_plugin(Message, FooPlugin)
        msg = Message()
        msg['foo']['an_interface_from_the_foo_plugin']

  plugin_attrib_map: ClassVar[dict[str, type[ElementBase]]] = {'suboptions': <class 'slixmpp.plugins.xep_0060.stanza.pubsub.SubscribeOptions'>}

    A mapping of the `plugin_attrib` values of registered plugins to their respective classes.

  plugin_iterables: ClassVar[set[type[ElementBase]]] = {}

    The set of stanza classes that can be iterated over using the ‘substanzas’ interface. Classes are added to this set when registering a plugin with `iterable=True`:

        register_stanza_plugin(DiscoInfo, DiscoItem, iterable=True)

    Added in version 1.0-Beta5.

  plugin_overrides: ClassVar[dict[str, str]] = {}

    A map of interface operations to the overriding functions. For example, after overriding the `set` operation for the interface `body`, `plugin_overrides` would be:

        {'set_body': <some function>}

  plugin_tag_map: ClassVar[dict[str, type[ElementBase]]] = {'{http://jabber.org/protocol/pubsub}subscribe-options': <class 'slixmpp.plugins.xep_0060.stanza.pubsub.SubscribeOptions'>}

    A mapping of root element tag names (in `'{namespace}elementname'` format) to the plugin classes responsible for them.

  set_jid(value)

class slixmpp.plugins.xep_0060.stanza.pubsub.Subscriptions(xml=None, parent=None)
  interfaces: ClassVar[set[str]] = {'node'}

    The set of keys that the stanza provides for accessing and manipulating the underlying XML object. This set may be augmented with the `plugin_attrib` value of any registered stanza plugins.

  name: ClassVar[str] = 'subscriptions'

    The XML tag name of the element, not including any namespace prefixes. For example, an `ElementBase` object for `<message />` would use `name = 'message'`.

  namespace: str = 'http://jabber.org/protocol/pubsub'

    The XML namespace for the element. Given `<foo xmlns="bar" />`, then `namespace = "bar"` should be used. The default namespace is `jabber:client` since this is being used in an XMPP library.

  plugin_attrib: ClassVar[str] = 'subscriptions'

    For `ElementBase` subclasses which are intended to be used as plugins, the `plugin_attrib` value defines the plugin name. Plugins may be accessed by using the `plugin_attrib` value as the interface. An example using `plugin_attrib = 'foo'`:

        register_stanza_plugin(Message, FooPlugin)
        msg = Message()
        msg['foo']['an_interface_from_the_foo_plugin']

  plugin_attrib_map: ClassVar[dict[str, type[ElementBase]]] = {'subscription': <class 'slixmpp.plugins.xep_0060.stanza.pubsub.Subscription'>}

    A mapping of the `plugin_attrib` values of registered plugins to their respective classes.

  plugin_iterables: ClassVar[set[type[ElementBase]]] = {<class 'slixmpp.plugins.xep_0060.stanza.pubsub.Subscription'>}

    The set of stanza classes that can be iterated over using the ‘substanzas’ interface. Classes are added to this set when registering a plugin with `iterable=True`:

        register_stanza_plugin(DiscoInfo, DiscoItem, iterable=True)

    Added in version 1.0-Beta5.

  plugin_overrides: ClassVar[dict[str, str]] = {}

    A map of interface operations to the overriding functions. For example, after overriding the `set` operation for the interface `body`, `plugin_overrides` would be:

        {'set_body': <some function>}

  plugin_tag_map: ClassVar[dict[str, type[ElementBase]]] = {'{http://jabber.org/protocol/pubsub}subscription': <class 'slixmpp.plugins.xep_0060.stanza.pubsub.Subscription'>}

    A mapping of root element tag names (in `'{namespace}elementname'` format) to the plugin classes responsible for them.

class slixmpp.plugins.xep_0060.stanza.pubsub.Unsubscribe(xml=None, parent=None)
  get_jid()
  interfaces: ClassVar[set[str]] = {'jid', 'node', 'subid'}

    The set of keys that the stanza provides for accessing and manipulating the underlying XML object. This set may be augmented with the `plugin_attrib` value of any registered stanza plugins.

  name: ClassVar[str] = 'unsubscribe'

    The XML tag name of the element, not including any namespace prefixes. For example, an `ElementBase` object for `<message />` would use `name = 'message'`.

  namespace: str = 'http://jabber.org/protocol/pubsub'

    The XML namespace for the element. Given `<foo xmlns="bar" />`, then `namespace = "bar"` should be used. The default namespace is `jabber:client` since this is being used in an XMPP library.

  plugin_attrib: ClassVar[str] = 'unsubscribe'

    For `ElementBase` subclasses which are intended to be used as plugins, the `plugin_attrib` value defines the plugin name. Plugins may be accessed by using the `plugin_attrib` value as the interface. An example using `plugin_attrib = 'foo'`:

        register_stanza_plugin(Message, FooPlugin)
        msg = Message()
        msg['foo']['an_interface_from_the_foo_plugin']

  set_jid(value)

class slixmpp.plugins.xep_0060.stanza.pubsub_errors.PubsubErrorCondition(xml=None, parent=None)
  condition_ns = 'http://jabber.org/protocol/pubsub#errors'
  conditions = {'closed-node', 'configuration-required', 'invalid-jid', 'invalid-options', 'invalid-payload', 'invalid-subid', 'item-forbidden', 'item-required', 'jid-required', 'max-items-exceeded', 'max-nodes-exceeded', 'nodeid-required', 'not-in-roster-group', 'not-subscribed', 'payload-required', 'payload-too-big', 'pending-subscription', 'presence-subscription-required', 'subid-required', 'too-many-subscriptions', 'unsupported'}
  del_condition()

    Remove the condition element.

  del_unsupported()

    Delete an unsupported feature condition.

  get_condition()

    Return the condition element’s name.

  get_unsupported()

    Return the name of an unsupported feature

  interfaces: ClassVar[set[str]] = {'condition', 'unsupported'}

    The set of keys that the stanza provides for accessing and manipulating the underlying XML object. This set may be augmented with the `plugin_attrib` value of any registered stanza plugins.

  plugin_attrib: ClassVar[str] = 'pubsub'

    For `ElementBase` subclasses which are intended to be used as plugins, the `plugin_attrib` value defines the plugin name. Plugins may be accessed by using the `plugin_attrib` value as the interface. An example using `plugin_attrib = 'foo'`:

        register_stanza_plugin(Message, FooPlugin)
        msg = Message()
        msg['foo']['an_interface_from_the_foo_plugin']

  plugin_attrib_map: ClassVar[dict[str, type[ElementBase]]] = {}

    A mapping of the `plugin_attrib` values of registered plugins to their respective classes.

  plugin_tag_map: ClassVar[dict[str, type[ElementBase]]] = {}

    A mapping of root element tag names (in `'{namespace}elementname'` format) to the plugin classes responsible for them.

  set_condition(value)

    Set the tag name of the condition element.

    Arguments:

      value – The tag name of the condition element.

  set_unsupported(value)

    Mark a feature as unsupported

  setup(xml)

    Don’t create XML for the plugin.

class slixmpp.plugins.xep_0060.stanza.pubsub_owner.DefaultConfig(*args, **kwargs)
  get_config()
  interfaces: ClassVar[set[str]] = {'config', 'node'}

    The set of keys that the stanza provides for accessing and manipulating the underlying XML object. This set may be augmented with the `plugin_attrib` value of any registered stanza plugins.

  name: ClassVar[str] = 'default'

    The XML tag name of the element, not including any namespace prefixes. For example, an `ElementBase` object for `<message />` would use `name = 'message'`.

  namespace: str = 'http://jabber.org/protocol/pubsub#owner'

    The XML namespace for the element. Given `<foo xmlns="bar" />`, then `namespace = "bar"` should be used. The default namespace is `jabber:client` since this is being used in an XMPP library.

  plugin_attrib: ClassVar[str] = 'default'

    For `ElementBase` subclasses which are intended to be used as plugins, the `plugin_attrib` value defines the plugin name. Plugins may be accessed by using the `plugin_attrib` value as the interface. An example using `plugin_attrib = 'foo'`:

        register_stanza_plugin(Message, FooPlugin)
        msg = Message()
        msg['foo']['an_interface_from_the_foo_plugin']

  plugin_attrib_map: ClassVar[dict[str, type[ElementBase]]] = {'form': <class 'slixmpp.plugins.xep_0004.stanza.form.Form'>}

    A mapping of the `plugin_attrib` values of registered plugins to their respective classes.

  plugin_iterables: ClassVar[set[type[ElementBase]]] = {}

    The set of stanza classes that can be iterated over using the ‘substanzas’ interface. Classes are added to this set when registering a plugin with `iterable=True`:

        register_stanza_plugin(DiscoInfo, DiscoItem, iterable=True)

    Added in version 1.0-Beta5.

  plugin_overrides: ClassVar[dict[str, str]] = {}

    A map of interface operations to the overriding functions. For example, after overriding the `set` operation for the interface `body`, `plugin_overrides` would be:

        {'set_body': <some function>}

  plugin_tag_map: ClassVar[dict[str, type[ElementBase]]] = {'{jabber:x:data}x': <class 'slixmpp.plugins.xep_0004.stanza.form.Form'>}

    A mapping of root element tag names (in `'{namespace}elementname'` format) to the plugin classes responsible for them.

  set_config(value)

class slixmpp.plugins.xep_0060.stanza.pubsub_owner.OwnerAffiliation(xml=None, parent=None)
  interfaces: ClassVar[set[str]] = {'affiliation', 'jid'}

    The set of keys that the stanza provides for accessing and manipulating the underlying XML object. This set may be augmented with the `plugin_attrib` value of any registered stanza plugins.

  namespace: str = 'http://jabber.org/protocol/pubsub#owner'

    The XML namespace for the element. Given `<foo xmlns="bar" />`, then `namespace = "bar"` should be used. The default namespace is `jabber:client` since this is being used in an XMPP library.

class slixmpp.plugins.xep_0060.stanza.pubsub_owner.OwnerAffiliations(xml=None, parent=None)
  append(affiliation)

    Append either an XML object or a substanza to this stanza object.

    If a substanza object is appended, it will be added to the list of iterable stanzas.

    Allows stanza objects to be used like lists.

    Parameters:

      item – Either an XML object or a stanza object to add to this stanza’s contents.

  interfaces: ClassVar[set[str]] = {'node'}

    The set of keys that the stanza provides for accessing and manipulating the underlying XML object. This set may be augmented with the `plugin_attrib` value of any registered stanza plugins.

  namespace: str = 'http://jabber.org/protocol/pubsub#owner'

    The XML namespace for the element. Given `<foo xmlns="bar" />`, then `namespace = "bar"` should be used. The default namespace is `jabber:client` since this is being used in an XMPP library.

  plugin_attrib_map: ClassVar[dict[str, type[ElementBase]]] = {'affiliation': <class 'slixmpp.plugins.xep_0060.stanza.pubsub_owner.OwnerAffiliation'>}

    A mapping of the `plugin_attrib` values of registered plugins to their respective classes.

  plugin_iterables: ClassVar[set[type[ElementBase]]] = {<class 'slixmpp.plugins.xep_0060.stanza.pubsub.Affiliation'>, <class 'slixmpp.plugins.xep_0060.stanza.pubsub_owner.OwnerAffiliation'>}

    The set of stanza classes that can be iterated over using the ‘substanzas’ interface. Classes are added to this set when registering a plugin with `iterable=True`:

        register_stanza_plugin(DiscoInfo, DiscoItem, iterable=True)

    Added in version 1.0-Beta5.

  plugin_overrides: ClassVar[dict[str, str]] = {}

    A map of interface operations to the overriding functions. For example, after overriding the `set` operation for the interface `body`, `plugin_overrides` would be:

        {'set_body': <some function>}

  plugin_tag_map: ClassVar[dict[str, type[ElementBase]]] = {'{http://jabber.org/protocol/pubsub#owner}affiliation': <class 'slixmpp.plugins.xep_0060.stanza.pubsub_owner.OwnerAffiliation'>, '{http://jabber.org/protocol/pubsub}affiliation': <class 'slixmpp.plugins.xep_0060.stanza.pubsub.Affiliation'>}

    A mapping of root element tag names (in `'{namespace}elementname'` format) to the plugin classes responsible for them.

class slixmpp.plugins.xep_0060.stanza.pubsub_owner.OwnerConfigure(xml=None, parent=None)
  interfaces: ClassVar[set[str]] = {'node'}

    The set of keys that the stanza provides for accessing and manipulating the underlying XML object. This set may be augmented with the `plugin_attrib` value of any registered stanza plugins.

  name: ClassVar[str] = 'configure'

    The XML tag name of the element, not including any namespace prefixes. For example, an `ElementBase` object for `<message />` would use `name = 'message'`.

  namespace: str = 'http://jabber.org/protocol/pubsub#owner'

    The XML namespace for the element. Given `<foo xmlns="bar" />`, then `namespace = "bar"` should be used. The default namespace is `jabber:client` since this is being used in an XMPP library.

  plugin_attrib: ClassVar[str] = 'configure'

    For `ElementBase` subclasses which are intended to be used as plugins, the `plugin_attrib` value defines the plugin name. Plugins may be accessed by using the `plugin_attrib` value as the interface. An example using `plugin_attrib = 'foo'`:

        register_stanza_plugin(Message, FooPlugin)
        msg = Message()
        msg['foo']['an_interface_from_the_foo_plugin']

  plugin_attrib_map: ClassVar[dict[str, type[ElementBase]]] = {'form': <class 'slixmpp.plugins.xep_0004.stanza.form.Form'>}

    A mapping of the `plugin_attrib` values of registered plugins to their respective classes.

  plugin_iterables: ClassVar[set[type[ElementBase]]] = {}

    The set of stanza classes that can be iterated over using the ‘substanzas’ interface. Classes are added to this set when registering a plugin with `iterable=True`:

        register_stanza_plugin(DiscoInfo, DiscoItem, iterable=True)

    Added in version 1.0-Beta5.

  plugin_overrides: ClassVar[dict[str, str]] = {}

    A map of interface operations to the overriding functions. For example, after overriding the `set` operation for the interface `body`, `plugin_overrides` would be:

        {'set_body': <some function>}

  plugin_tag_map: ClassVar[dict[str, type[ElementBase]]] = {'{jabber:x:data}x': <class 'slixmpp.plugins.xep_0004.stanza.form.Form'>}

    A mapping of root element tag names (in `'{namespace}elementname'` format) to the plugin classes responsible for them.

class slixmpp.plugins.xep_0060.stanza.pubsub_owner.OwnerDefault(xml=None, parent=None)
  interfaces: ClassVar[set[str]] = {'node'}

    The set of keys that the stanza provides for accessing and manipulating the underlying XML object. This set may be augmented with the `plugin_attrib` value of any registered stanza plugins.

  namespace: str = 'http://jabber.org/protocol/pubsub#owner'

    The XML namespace for the element. Given `<foo xmlns="bar" />`, then `namespace = "bar"` should be used. The default namespace is `jabber:client` since this is being used in an XMPP library.

  plugin_attrib_map: ClassVar[dict[str, type[ElementBase]]] = {'form': <class 'slixmpp.plugins.xep_0004.stanza.form.Form'>}

    A mapping of the `plugin_attrib` values of registered plugins to their respective classes.

  plugin_iterables: ClassVar[set[type[ElementBase]]] = {}

    The set of stanza classes that can be iterated over using the ‘substanzas’ interface. Classes are added to this set when registering a plugin with `iterable=True`:

        register_stanza_plugin(DiscoInfo, DiscoItem, iterable=True)

    Added in version 1.0-Beta5.

  plugin_overrides: ClassVar[dict[str, str]] = {}

    A map of interface operations to the overriding functions. For example, after overriding the `set` operation for the interface `body`, `plugin_overrides` would be:

        {'set_body': <some function>}

  plugin_tag_map: ClassVar[dict[str, type[ElementBase]]] = {'{jabber:x:data}x': <class 'slixmpp.plugins.xep_0004.stanza.form.Form'>}

    A mapping of root element tag names (in `'{namespace}elementname'` format) to the plugin classes responsible for them.

class slixmpp.plugins.xep_0060.stanza.pubsub_owner.OwnerDelete(xml=None, parent=None)
  interfaces: ClassVar[set[str]] = {'node'}

    The set of keys that the stanza provides for accessing and manipulating the underlying XML object. This set may be augmented with the `plugin_attrib` value of any registered stanza plugins.

  name: ClassVar[str] = 'delete'

    The XML tag name of the element, not including any namespace prefixes. For example, an `ElementBase` object for `<message />` would use `name = 'message'`.

  namespace: str = 'http://jabber.org/protocol/pubsub#owner'

    The XML namespace for the element. Given `<foo xmlns="bar" />`, then `namespace = "bar"` should be used. The default namespace is `jabber:client` since this is being used in an XMPP library.

  plugin_attrib: ClassVar[str] = 'delete'

    For `ElementBase` subclasses which are intended to be used as plugins, the `plugin_attrib` value defines the plugin name. Plugins may be accessed by using the `plugin_attrib` value as the interface. An example using `plugin_attrib = 'foo'`:

        register_stanza_plugin(Message, FooPlugin)
        msg = Message()
        msg['foo']['an_interface_from_the_foo_plugin']

  plugin_attrib_map: ClassVar[dict[str, type[ElementBase]]] = {'redirect': <class 'slixmpp.plugins.xep_0060.stanza.pubsub_owner.OwnerRedirect'>}

    A mapping of the `plugin_attrib` values of registered plugins to their respective classes.

  plugin_iterables: ClassVar[set[type[ElementBase]]] = {}

    The set of stanza classes that can be iterated over using the ‘substanzas’ interface. Classes are added to this set when registering a plugin with `iterable=True`:

        register_stanza_plugin(DiscoInfo, DiscoItem, iterable=True)

    Added in version 1.0-Beta5.

  plugin_overrides: ClassVar[dict[str, str]] = {}

    A map of interface operations to the overriding functions. For example, after overriding the `set` operation for the interface `body`, `plugin_overrides` would be:

        {'set_body': <some function>}

  plugin_tag_map: ClassVar[dict[str, type[ElementBase]]] = {'{http://jabber.org/protocol/pubsub#owner}redirect': <class 'slixmpp.plugins.xep_0060.stanza.pubsub_owner.OwnerRedirect'>}

    A mapping of root element tag names (in `'{namespace}elementname'` format) to the plugin classes responsible for them.

class slixmpp.plugins.xep_0060.stanza.pubsub_owner.OwnerPurge(xml=None, parent=None)
  interfaces: ClassVar[set[str]] = {'node'}

    The set of keys that the stanza provides for accessing and manipulating the underlying XML object. This set may be augmented with the `plugin_attrib` value of any registered stanza plugins.

  name: ClassVar[str] = 'purge'

    The XML tag name of the element, not including any namespace prefixes. For example, an `ElementBase` object for `<message />` would use `name = 'message'`.

  namespace: str = 'http://jabber.org/protocol/pubsub#owner'

    The XML namespace for the element. Given `<foo xmlns="bar" />`, then `namespace = "bar"` should be used. The default namespace is `jabber:client` since this is being used in an XMPP library.

  plugin_attrib: ClassVar[str] = 'purge'

    For `ElementBase` subclasses which are intended to be used as plugins, the `plugin_attrib` value defines the plugin name. Plugins may be accessed by using the `plugin_attrib` value as the interface. An example using `plugin_attrib = 'foo'`:

        register_stanza_plugin(Message, FooPlugin)
        msg = Message()
        msg['foo']['an_interface_from_the_foo_plugin']

class slixmpp.plugins.xep_0060.stanza.pubsub_owner.OwnerRedirect(xml=None, parent=None)
  get_jid()
  interfaces: ClassVar[set[str]] = {'jid', 'node'}

    The set of keys that the stanza provides for accessing and manipulating the underlying XML object. This set may be augmented with the `plugin_attrib` value of any registered stanza plugins.

  name: ClassVar[str] = 'redirect'

    The XML tag name of the element, not including any namespace prefixes. For example, an `ElementBase` object for `<message />` would use `name = 'message'`.

  namespace: str = 'http://jabber.org/protocol/pubsub#owner'

    The XML namespace for the element. Given `<foo xmlns="bar" />`, then `namespace = "bar"` should be used. The default namespace is `jabber:client` since this is being used in an XMPP library.

  plugin_attrib: ClassVar[str] = 'redirect'

    For `ElementBase` subclasses which are intended to be used as plugins, the `plugin_attrib` value defines the plugin name. Plugins may be accessed by using the `plugin_attrib` value as the interface. An example using `plugin_attrib = 'foo'`:

        register_stanza_plugin(Message, FooPlugin)
        msg = Message()
        msg['foo']['an_interface_from_the_foo_plugin']

  set_jid(value)

class slixmpp.plugins.xep_0060.stanza.pubsub_owner.OwnerSubscription(xml=None, parent=None)
  get_jid()
  interfaces: ClassVar[set[str]] = {'jid', 'subscription'}

    The set of keys that the stanza provides for accessing and manipulating the underlying XML object. This set may be augmented with the `plugin_attrib` value of any registered stanza plugins.

  name: ClassVar[str] = 'subscription'

    The XML tag name of the element, not including any namespace prefixes. For example, an `ElementBase` object for `<message />` would use `name = 'message'`.

  namespace: str = 'http://jabber.org/protocol/pubsub#owner'

    The XML namespace for the element. Given `<foo xmlns="bar" />`, then `namespace = "bar"` should be used. The default namespace is `jabber:client` since this is being used in an XMPP library.

  plugin_attrib: ClassVar[str] = 'subscription'

    For `ElementBase` subclasses which are intended to be used as plugins, the `plugin_attrib` value defines the plugin name. Plugins may be accessed by using the `plugin_attrib` value as the interface. An example using `plugin_attrib = 'foo'`:

        register_stanza_plugin(Message, FooPlugin)
        msg = Message()
        msg['foo']['an_interface_from_the_foo_plugin']

  set_jid(value)

class slixmpp.plugins.xep_0060.stanza.pubsub_owner.OwnerSubscriptions(xml=None, parent=None)
  append(subscription)

    Append either an XML object or a substanza to this stanza object.

    If a substanza object is appended, it will be added to the list of iterable stanzas.

    Allows stanza objects to be used like lists.

    Parameters:

      item – Either an XML object or a stanza object to add to this stanza’s contents.

  interfaces: ClassVar[set[str]] = {'node'}

    The set of keys that the stanza provides for accessing and manipulating the underlying XML object. This set may be augmented with the `plugin_attrib` value of any registered stanza plugins.

  name: ClassVar[str] = 'subscriptions'

    The XML tag name of the element, not including any namespace prefixes. For example, an `ElementBase` object for `<message />` would use `name = 'message'`.

  namespace: str = 'http://jabber.org/protocol/pubsub#owner'

    The XML namespace for the element. Given `<foo xmlns="bar" />`, then `namespace = "bar"` should be used. The default namespace is `jabber:client` since this is being used in an XMPP library.

  plugin_attrib: ClassVar[str] = 'subscriptions'

    For `ElementBase` subclasses which are intended to be used as plugins, the `plugin_attrib` value defines the plugin name. Plugins may be accessed by using the `plugin_attrib` value as the interface. An example using `plugin_attrib = 'foo'`:

        register_stanza_plugin(Message, FooPlugin)
        msg = Message()
        msg['foo']['an_interface_from_the_foo_plugin']

  plugin_attrib_map: ClassVar[dict[str, type[ElementBase]]] = {'subscription': <class 'slixmpp.plugins.xep_0060.stanza.pubsub_owner.OwnerSubscription'>}

    A mapping of the `plugin_attrib` values of registered plugins to their respective classes.

  plugin_iterables: ClassVar[set[type[ElementBase]]] = {<class 'slixmpp.plugins.xep_0060.stanza.pubsub.Subscription'>, <class 'slixmpp.plugins.xep_0060.stanza.pubsub_owner.OwnerSubscription'>}

    The set of stanza classes that can be iterated over using the ‘substanzas’ interface. Classes are added to this set when registering a plugin with `iterable=True`:

        register_stanza_plugin(DiscoInfo, DiscoItem, iterable=True)

    Added in version 1.0-Beta5.

  plugin_overrides: ClassVar[dict[str, str]] = {}

    A map of interface operations to the overriding functions. For example, after overriding the `set` operation for the interface `body`, `plugin_overrides` would be:

        {'set_body': <some function>}

  plugin_tag_map: ClassVar[dict[str, type[ElementBase]]] = {'{http://jabber.org/protocol/pubsub#owner}subscription': <class 'slixmpp.plugins.xep_0060.stanza.pubsub_owner.OwnerSubscription'>, '{http://jabber.org/protocol/pubsub}subscription': <class 'slixmpp.plugins.xep_0060.stanza.pubsub.Subscription'>}

    A mapping of root element tag names (in `'{namespace}elementname'` format) to the plugin classes responsible for them.

class slixmpp.plugins.xep_0060.stanza.pubsub_owner.PubsubOwner(xml=None, parent=None)
  interfaces: ClassVar[set[str]] = {}

    The set of keys that the stanza provides for accessing and manipulating the underlying XML object. This set may be augmented with the `plugin_attrib` value of any registered stanza plugins.

  name: ClassVar[str] = 'pubsub'

    The XML tag name of the element, not including any namespace prefixes. For example, an `ElementBase` object for `<message />` would use `name = 'message'`.

  namespace: str = 'http://jabber.org/protocol/pubsub#owner'

    The XML namespace for the element. Given `<foo xmlns="bar" />`, then `namespace = "bar"` should be used. The default namespace is `jabber:client` since this is being used in an XMPP library.

  plugin_attrib: ClassVar[str] = 'pubsub_owner'

    For `ElementBase` subclasses which are intended to be used as plugins, the `plugin_attrib` value defines the plugin name. Plugins may be accessed by using the `plugin_attrib` value as the interface. An example using `plugin_attrib = 'foo'`:

        register_stanza_plugin(Message, FooPlugin)
        msg = Message()
        msg['foo']['an_interface_from_the_foo_plugin']

  plugin_attrib_map: ClassVar[dict[str, type[ElementBase]]] = {'affiliations': <class 'slixmpp.plugins.xep_0060.stanza.pubsub_owner.OwnerAffiliations'>, 'configure': <class 'slixmpp.plugins.xep_0060.stanza.pubsub_owner.OwnerDefault'>, 'default': <class 'slixmpp.plugins.xep_0060.stanza.pubsub_owner.DefaultConfig'>, 'delete': <class 'slixmpp.plugins.xep_0060.stanza.pubsub_owner.OwnerDelete'>, 'purge': <class 'slixmpp.plugins.xep_0060.stanza.pubsub_owner.OwnerPurge'>, 'subscriptions': <class 'slixmpp.plugins.xep_0060.stanza.pubsub_owner.OwnerSubscriptions'>}

    A mapping of the `plugin_attrib` values of registered plugins to their respective classes.

  plugin_iterables: ClassVar[set[type[ElementBase]]] = {}

    The set of stanza classes that can be iterated over using the ‘substanzas’ interface. Classes are added to this set when registering a plugin with `iterable=True`:

        register_stanza_plugin(DiscoInfo, DiscoItem, iterable=True)

    Added in version 1.0-Beta5.

  plugin_overrides: ClassVar[dict[str, str]] = {}

    A map of interface operations to the overriding functions. For example, after overriding the `set` operation for the interface `body`, `plugin_overrides` would be:

        {'set_body': <some function>}

  plugin_tag_map: ClassVar[dict[str, type[ElementBase]]] = {'{http://jabber.org/protocol/pubsub#owner}affiliations': <class 'slixmpp.plugins.xep_0060.stanza.pubsub_owner.OwnerAffiliations'>, '{http://jabber.org/protocol/pubsub#owner}configure': <class 'slixmpp.plugins.xep_0060.stanza.pubsub_owner.OwnerDefault'>, '{http://jabber.org/protocol/pubsub#owner}default': <class 'slixmpp.plugins.xep_0060.stanza.pubsub_owner.DefaultConfig'>, '{http://jabber.org/protocol/pubsub#owner}delete': <class 'slixmpp.plugins.xep_0060.stanza.pubsub_owner.OwnerDelete'>, '{http://jabber.org/protocol/pubsub#owner}purge': <class 'slixmpp.plugins.xep_0060.stanza.pubsub_owner.OwnerPurge'>, '{http://jabber.org/protocol/pubsub#owner}subscriptions': <class 'slixmpp.plugins.xep_0060.stanza.pubsub_owner.OwnerSubscriptions'>}

    A mapping of root element tag names (in `'{namespace}elementname'` format) to the plugin classes responsible for them.

class slixmpp.plugins.xep_0060.stanza.pubsub_event.Event(xml=None, parent=None)
  interfaces: ClassVar[set[str]] = {}

    The set of keys that the stanza provides for accessing and manipulating the underlying XML object. This set may be augmented with the `plugin_attrib` value of any registered stanza plugins.

  name: ClassVar[str] = 'event'

    The XML tag name of the element, not including any namespace prefixes. For example, an `ElementBase` object for `<message />` would use `name = 'message'`.

  namespace: str = 'http://jabber.org/protocol/pubsub#event'

    The XML namespace for the element. Given `<foo xmlns="bar" />`, then `namespace = "bar"` should be used. The default namespace is `jabber:client` since this is being used in an XMPP library.

  plugin_attrib: ClassVar[str] = 'pubsub_event'

    For `ElementBase` subclasses which are intended to be used as plugins, the `plugin_attrib` value defines the plugin name. Plugins may be accessed by using the `plugin_attrib` value as the interface. An example using `plugin_attrib = 'foo'`:

        register_stanza_plugin(Message, FooPlugin)
        msg = Message()
        msg['foo']['an_interface_from_the_foo_plugin']

  plugin_attrib_map: ClassVar[dict[str, type[ElementBase]]] = {'collection': <class 'slixmpp.plugins.xep_0060.stanza.pubsub_event.EventCollection'>, 'configuration': <class 'slixmpp.plugins.xep_0060.stanza.pubsub_event.EventConfiguration'>, 'delete': <class 'slixmpp.plugins.xep_0060.stanza.pubsub_event.EventDelete'>, 'items': <class 'slixmpp.plugins.xep_0060.stanza.pubsub_event.EventItems'>, 'purge': <class 'slixmpp.plugins.xep_0060.stanza.pubsub_event.EventPurge'>, 'subscription': <class 'slixmpp.plugins.xep_0060.stanza.pubsub_event.EventSubscription'>}

    A mapping of the `plugin_attrib` values of registered plugins to their respective classes.

  plugin_iterables: ClassVar[set[type[ElementBase]]] = {}

    The set of stanza classes that can be iterated over using the ‘substanzas’ interface. Classes are added to this set when registering a plugin with `iterable=True`:

        register_stanza_plugin(DiscoInfo, DiscoItem, iterable=True)

    Added in version 1.0-Beta5.

  plugin_overrides: ClassVar[dict[str, str]] = {}

    A map of interface operations to the overriding functions. For example, after overriding the `set` operation for the interface `body`, `plugin_overrides` would be:

        {'set_body': <some function>}

  plugin_tag_map: ClassVar[dict[str, type[ElementBase]]] = {'{http://jabber.org/protocol/pubsub#event}collection': <class 'slixmpp.plugins.xep_0060.stanza.pubsub_event.EventCollection'>, '{http://jabber.org/protocol/pubsub#event}configuration': <class 'slixmpp.plugins.xep_0060.stanza.pubsub_event.EventConfiguration'>, '{http://jabber.org/protocol/pubsub#event}delete': <class 'slixmpp.plugins.xep_0060.stanza.pubsub_event.EventDelete'>, '{http://jabber.org/protocol/pubsub#event}items': <class 'slixmpp.plugins.xep_0060.stanza.pubsub_event.EventItems'>, '{http://jabber.org/protocol/pubsub#event}purge': <class 'slixmpp.plugins.xep_0060.stanza.pubsub_event.EventPurge'>, '{http://jabber.org/protocol/pubsub#event}subscription': <class 'slixmpp.plugins.xep_0060.stanza.pubsub_event.EventSubscription'>}

    A mapping of root element tag names (in `'{namespace}elementname'` format) to the plugin classes responsible for them.

class slixmpp.plugins.xep_0060.stanza.pubsub_event.EventAssociate(xml=None, parent=None)
  interfaces: ClassVar[set[str]] = {'node'}

    The set of keys that the stanza provides for accessing and manipulating the underlying XML object. This set may be augmented with the `plugin_attrib` value of any registered stanza plugins.

  name: ClassVar[str] = 'associate'

    The XML tag name of the element, not including any namespace prefixes. For example, an `ElementBase` object for `<message />` would use `name = 'message'`.

  namespace: str = 'http://jabber.org/protocol/pubsub#event'

    The XML namespace for the element. Given `<foo xmlns="bar" />`, then `namespace = "bar"` should be used. The default namespace is `jabber:client` since this is being used in an XMPP library.

  plugin_attrib: ClassVar[str] = 'associate'

    For `ElementBase` subclasses which are intended to be used as plugins, the `plugin_attrib` value defines the plugin name. Plugins may be accessed by using the `plugin_attrib` value as the interface. An example using `plugin_attrib = 'foo'`:

        register_stanza_plugin(Message, FooPlugin)
        msg = Message()
        msg['foo']['an_interface_from_the_foo_plugin']

class slixmpp.plugins.xep_0060.stanza.pubsub_event.EventCollection(xml=None, parent=None)
  interfaces: ClassVar[set[str]] = {'node'}

    The set of keys that the stanza provides for accessing and manipulating the underlying XML object. This set may be augmented with the `plugin_attrib` value of any registered stanza plugins.

  name: ClassVar[str] = 'collection'

    The XML tag name of the element, not including any namespace prefixes. For example, an `ElementBase` object for `<message />` would use `name = 'message'`.

  namespace: str = 'http://jabber.org/protocol/pubsub#event'

    The XML namespace for the element. Given `<foo xmlns="bar" />`, then `namespace = "bar"` should be used. The default namespace is `jabber:client` since this is being used in an XMPP library.

  plugin_attrib: ClassVar[str] = 'collection'

    For `ElementBase` subclasses which are intended to be used as plugins, the `plugin_attrib` value defines the plugin name. Plugins may be accessed by using the `plugin_attrib` value as the interface. An example using `plugin_attrib = 'foo'`:

        register_stanza_plugin(Message, FooPlugin)
        msg = Message()
        msg['foo']['an_interface_from_the_foo_plugin']

  plugin_attrib_map: ClassVar[dict[str, type[ElementBase]]] = {'associate': <class 'slixmpp.plugins.xep_0060.stanza.pubsub_event.EventAssociate'>, 'disassociate': <class 'slixmpp.plugins.xep_0060.stanza.pubsub_event.EventDisassociate'>}

    A mapping of the `plugin_attrib` values of registered plugins to their respective classes.

  plugin_iterables: ClassVar[set[type[ElementBase]]] = {}

    The set of stanza classes that can be iterated over using the ‘substanzas’ interface. Classes are added to this set when registering a plugin with `iterable=True`:

        register_stanza_plugin(DiscoInfo, DiscoItem, iterable=True)

    Added in version 1.0-Beta5.

  plugin_overrides: ClassVar[dict[str, str]] = {}

    A map of interface operations to the overriding functions. For example, after overriding the `set` operation for the interface `body`, `plugin_overrides` would be:

        {'set_body': <some function>}

  plugin_tag_map: ClassVar[dict[str, type[ElementBase]]] = {'{http://jabber.org/protocol/pubsub#event}associate': <class 'slixmpp.plugins.xep_0060.stanza.pubsub_event.EventAssociate'>, '{http://jabber.org/protocol/pubsub#event}disassociate': <class 'slixmpp.plugins.xep_0060.stanza.pubsub_event.EventDisassociate'>}

    A mapping of root element tag names (in `'{namespace}elementname'` format) to the plugin classes responsible for them.

class slixmpp.plugins.xep_0060.stanza.pubsub_event.EventConfiguration(xml=None, parent=None)
  interfaces: ClassVar[set[str]] = {'node'}

    The set of keys that the stanza provides for accessing and manipulating the underlying XML object. This set may be augmented with the `plugin_attrib` value of any registered stanza plugins.

  name: ClassVar[str] = 'configuration'

    The XML tag name of the element, not including any namespace prefixes. For example, an `ElementBase` object for `<message />` would use `name = 'message'`.

  namespace: str = 'http://jabber.org/protocol/pubsub#event'

    The XML namespace for the element. Given `<foo xmlns="bar" />`, then `namespace = "bar"` should be used. The default namespace is `jabber:client` since this is being used in an XMPP library.

  plugin_attrib: ClassVar[str] = 'configuration'

    For `ElementBase` subclasses which are intended to be used as plugins, the `plugin_attrib` value defines the plugin name. Plugins may be accessed by using the `plugin_attrib` value as the interface. An example using `plugin_attrib = 'foo'`:

        register_stanza_plugin(Message, FooPlugin)
        msg = Message()
        msg['foo']['an_interface_from_the_foo_plugin']

  plugin_attrib_map: ClassVar[dict[str, type[ElementBase]]] = {'form': <class 'slixmpp.plugins.xep_0004.stanza.form.Form'>}

    A mapping of the `plugin_attrib` values of registered plugins to their respective classes.

  plugin_iterables: ClassVar[set[type[ElementBase]]] = {}

    The set of stanza classes that can be iterated over using the ‘substanzas’ interface. Classes are added to this set when registering a plugin with `iterable=True`:

        register_stanza_plugin(DiscoInfo, DiscoItem, iterable=True)

    Added in version 1.0-Beta5.

  plugin_overrides: ClassVar[dict[str, str]] = {}

    A map of interface operations to the overriding functions. For example, after overriding the `set` operation for the interface `body`, `plugin_overrides` would be:

        {'set_body': <some function>}

  plugin_tag_map: ClassVar[dict[str, type[ElementBase]]] = {'{jabber:x:data}x': <class 'slixmpp.plugins.xep_0004.stanza.form.Form'>}

    A mapping of root element tag names (in `'{namespace}elementname'` format) to the plugin classes responsible for them.

class slixmpp.plugins.xep_0060.stanza.pubsub_event.EventDelete(xml=None, parent=None)
  del_redirect()
  get_redirect()
  interfaces: ClassVar[set[str]] = {'node', 'redirect'}

    The set of keys that the stanza provides for accessing and manipulating the underlying XML object. This set may be augmented with the `plugin_attrib` value of any registered stanza plugins.

  name: ClassVar[str] = 'delete'

    The XML tag name of the element, not including any namespace prefixes. For example, an `ElementBase` object for `<message />` would use `name = 'message'`.

  namespace: str = 'http://jabber.org/protocol/pubsub#event'

    The XML namespace for the element. Given `<foo xmlns="bar" />`, then `namespace = "bar"` should be used. The default namespace is `jabber:client` since this is being used in an XMPP library.

  plugin_attrib: ClassVar[str] = 'delete'

    For `ElementBase` subclasses which are intended to be used as plugins, the `plugin_attrib` value defines the plugin name. Plugins may be accessed by using the `plugin_attrib` value as the interface. An example using `plugin_attrib = 'foo'`:

        register_stanza_plugin(Message, FooPlugin)
        msg = Message()
        msg['foo']['an_interface_from_the_foo_plugin']

  set_redirect(uri)

class slixmpp.plugins.xep_0060.stanza.pubsub_event.EventDisassociate(xml=None, parent=None)
  interfaces: ClassVar[set[str]] = {'node'}

    The set of keys that the stanza provides for accessing and manipulating the underlying XML object. This set may be augmented with the `plugin_attrib` value of any registered stanza plugins.

  name: ClassVar[str] = 'disassociate'

    The XML tag name of the element, not including any namespace prefixes. For example, an `ElementBase` object for `<message />` would use `name = 'message'`.

  namespace: str = 'http://jabber.org/protocol/pubsub#event'

    The XML namespace for the element. Given `<foo xmlns="bar" />`, then `namespace = "bar"` should be used. The default namespace is `jabber:client` since this is being used in an XMPP library.

  plugin_attrib: ClassVar[str] = 'disassociate'

    For `ElementBase` subclasses which are intended to be used as plugins, the `plugin_attrib` value defines the plugin name. Plugins may be accessed by using the `plugin_attrib` value as the interface. An example using `plugin_attrib = 'foo'`:

        register_stanza_plugin(Message, FooPlugin)
        msg = Message()
        msg['foo']['an_interface_from_the_foo_plugin']

class slixmpp.plugins.xep_0060.stanza.pubsub_event.EventItem(xml=None, parent=None)
  del_payload()
  get_payload()
  interfaces: ClassVar[set[str]] = {'id', 'node', 'payload', 'publisher'}

    The set of keys that the stanza provides for accessing and manipulating the underlying XML object. This set may be augmented with the `plugin_attrib` value of any registered stanza plugins.

  name: ClassVar[str] = 'item'

    The XML tag name of the element, not including any namespace prefixes. For example, an `ElementBase` object for `<message />` would use `name = 'message'`.

  namespace: str = 'http://jabber.org/protocol/pubsub#event'

    The XML namespace for the element. Given `<foo xmlns="bar" />`, then `namespace = "bar"` should be used. The default namespace is `jabber:client` since this is being used in an XMPP library.

  plugin_attrib: ClassVar[str] = 'item'

    For `ElementBase` subclasses which are intended to be used as plugins, the `plugin_attrib` value defines the plugin name. Plugins may be accessed by using the `plugin_attrib` value as the interface. An example using `plugin_attrib = 'foo'`:

        register_stanza_plugin(Message, FooPlugin)
        msg = Message()
        msg['foo']['an_interface_from_the_foo_plugin']

  set_payload(value)

class slixmpp.plugins.xep_0060.stanza.pubsub_event.EventItems(xml=None, parent=None)
  interfaces: ClassVar[set[str]] = {'node'}

    The set of keys that the stanza provides for accessing and manipulating the underlying XML object. This set may be augmented with the `plugin_attrib` value of any registered stanza plugins.

  name: ClassVar[str] = 'items'

    The XML tag name of the element, not including any namespace prefixes. For example, an `ElementBase` object for `<message />` would use `name = 'message'`.

  namespace: str = 'http://jabber.org/protocol/pubsub#event'

    The XML namespace for the element. Given `<foo xmlns="bar" />`, then `namespace = "bar"` should be used. The default namespace is `jabber:client` since this is being used in an XMPP library.

  plugin_attrib: ClassVar[str] = 'items'

    For `ElementBase` subclasses which are intended to be used as plugins, the `plugin_attrib` value defines the plugin name. Plugins may be accessed by using the `plugin_attrib` value as the interface. An example using `plugin_attrib = 'foo'`:

        register_stanza_plugin(Message, FooPlugin)
        msg = Message()
        msg['foo']['an_interface_from_the_foo_plugin']

  plugin_attrib_map: ClassVar[dict[str, type[ElementBase]]] = {'item': <class 'slixmpp.plugins.xep_0060.stanza.pubsub_event.EventItem'>, 'retract': <class 'slixmpp.plugins.xep_0060.stanza.pubsub_event.EventRetract'>}

    A mapping of the `plugin_attrib` values of registered plugins to their respective classes.

  plugin_iterables: ClassVar[set[type[ElementBase]]] = {<class 'slixmpp.plugins.xep_0060.stanza.pubsub_event.EventItem'>, <class 'slixmpp.plugins.xep_0060.stanza.pubsub_event.EventRetract'>}

    The set of stanza classes that can be iterated over using the ‘substanzas’ interface. Classes are added to this set when registering a plugin with `iterable=True`:

        register_stanza_plugin(DiscoInfo, DiscoItem, iterable=True)

    Added in version 1.0-Beta5.

  plugin_overrides: ClassVar[dict[str, str]] = {}

    A map of interface operations to the overriding functions. For example, after overriding the `set` operation for the interface `body`, `plugin_overrides` would be:

        {'set_body': <some function>}

  plugin_tag_map: ClassVar[dict[str, type[ElementBase]]] = {'{http://jabber.org/protocol/pubsub#event}item': <class 'slixmpp.plugins.xep_0060.stanza.pubsub_event.EventItem'>, '{http://jabber.org/protocol/pubsub#event}retract': <class 'slixmpp.plugins.xep_0060.stanza.pubsub_event.EventRetract'>}

    A mapping of root element tag names (in `'{namespace}elementname'` format) to the plugin classes responsible for them.

class slixmpp.plugins.xep_0060.stanza.pubsub_event.EventPurge(xml=None, parent=None)
  interfaces: ClassVar[set[str]] = {'node'}

    The set of keys that the stanza provides for accessing and manipulating the underlying XML object. This set may be augmented with the `plugin_attrib` value of any registered stanza plugins.

  name: ClassVar[str] = 'purge'

    The XML tag name of the element, not including any namespace prefixes. For example, an `ElementBase` object for `<message />` would use `name = 'message'`.

  namespace: str = 'http://jabber.org/protocol/pubsub#event'

    The XML namespace for the element. Given `<foo xmlns="bar" />`, then `namespace = "bar"` should be used. The default namespace is `jabber:client` since this is being used in an XMPP library.

  plugin_attrib: ClassVar[str] = 'purge'

    For `ElementBase` subclasses which are intended to be used as plugins, the `plugin_attrib` value defines the plugin name. Plugins may be accessed by using the `plugin_attrib` value as the interface. An example using `plugin_attrib = 'foo'`:

        register_stanza_plugin(Message, FooPlugin)
        msg = Message()
        msg['foo']['an_interface_from_the_foo_plugin']

class slixmpp.plugins.xep_0060.stanza.pubsub_event.EventRetract(xml=None, parent=None)
  interfaces: ClassVar[set[str]] = {'id'}

    The set of keys that the stanza provides for accessing and manipulating the underlying XML object. This set may be augmented with the `plugin_attrib` value of any registered stanza plugins.

  name: ClassVar[str] = 'retract'

    The XML tag name of the element, not including any namespace prefixes. For example, an `ElementBase` object for `<message />` would use `name = 'message'`.

  namespace: str = 'http://jabber.org/protocol/pubsub#event'

    The XML namespace for the element. Given `<foo xmlns="bar" />`, then `namespace = "bar"` should be used. The default namespace is `jabber:client` since this is being used in an XMPP library.

  plugin_attrib: ClassVar[str] = 'retract'

    For `ElementBase` subclasses which are intended to be used as plugins, the `plugin_attrib` value defines the plugin name. Plugins may be accessed by using the `plugin_attrib` value as the interface. An example using `plugin_attrib = 'foo'`:

        register_stanza_plugin(Message, FooPlugin)
        msg = Message()
        msg['foo']['an_interface_from_the_foo_plugin']

class slixmpp.plugins.xep_0060.stanza.pubsub_event.EventSubscription(xml=None, parent=None)
  get_expiry()
  get_jid()
  interfaces: ClassVar[set[str]] = {'expiry', 'jid', 'node', 'subid', 'subscription'}

    The set of keys that the stanza provides for accessing and manipulating the underlying XML object. This set may be augmented with the `plugin_attrib` value of any registered stanza plugins.

  name: ClassVar[str] = 'subscription'

    The XML tag name of the element, not including any namespace prefixes. For example, an `ElementBase` object for `<message />` would use `name = 'message'`.

  namespace: str = 'http://jabber.org/protocol/pubsub#event'

    The XML namespace for the element. Given `<foo xmlns="bar" />`, then `namespace = "bar"` should be used. The default namespace is `jabber:client` since this is being used in an XMPP library.

  plugin_attrib: ClassVar[str] = 'subscription'

    For `ElementBase` subclasses which are intended to be used as plugins, the `plugin_attrib` value defines the plugin name. Plugins may be accessed by using the `plugin_attrib` value as the interface. An example using `plugin_attrib = 'foo'`:

        register_stanza_plugin(Message, FooPlugin)
        msg = Message()
        msg['foo']['an_interface_from_the_foo_plugin']

  set_expiry(value)
  set_jid(value)