Skip to content
Back to top
View this page

# Stanza Objects

The `stanzabase` module provides a wrapper for the standard `ElementTree` module that makes working with XML less painful. Instead of having to manually move up and down an element tree and insert subelements and attributes, you can interact with an object that behaves like a normal dictionary or JSON object, which silently maps keys to XML attributes and elements behind the scenes.

## Overview

The usefulness of this layer grows as the XML you have to work with becomes nested. The base unit here, `ElementBase`, can map to a single XML element, or several depending on how advanced of a mapping is desired from interface keys to XML structures. For example, a single `ElementBase` derived class could easily describe:

    <message to="user@example.com" from="friend@example.com">
      <body>Hi!</body>
      <x:extra>
        <x:item>Custom item 1</x:item>
        <x:item>Custom item 2</x:item>
        <x:item>Custom item 3</x:item>
      </x:extra>
    </message>

If that chunk of XML were put in the `ElementBase` instance `msg`, we could extract the data from the XML using:

    >>> msg['extra']
    ['Custom item 1', 'Custom item 2', 'Custom item 3']

Provided we set up the handler for the `'extra'` interface to load the `<x:item>` element content into a list.

The key concept is that given an XML structure that will be repeatedly used, we can define a set of interfaces which when we read from, write to, or delete, will automatically manipulate the underlying XML as needed. In addition, some of these interfaces may in turn reference child objects which expose interfaces for particularly complex child elements of the original XML chunk.

See also

Defining Stanza Interfaces.

Because the `stanzabase` module was developed as part of an XMPP library, these chunks of XML are referred to as stanzas, and in Slixmpp we refer to a subclass of `ElementBase` which defines the interfaces needed for interacting with a given stanza a stanza object.

To make dealing with more complicated and nested stanzas or XML chunks easier, stanza objects can be composed in two ways: as iterable child objects or as plugins. Iterable child stanzas, or substanzas, are accessible through a special `'substanzas'` interface. This option is useful for stanzas which may contain more than one of the same kind of element. When there is only one child element, the plugin method is more useful. For plugins, a parent stanza object delegates one of its XML child elements to the plugin stanza object. Here is an example:

    <iq type="result">
      <query xmlns="http://jabber.org/protocol/disco#info">
        <identity category="client" type="bot" name="Slixmpp Bot" />
      </query>
    </iq>

We can can arrange this stanza into two objects: an outer, wrapper object for dealing with the `<iq />` element and its attributes, and a plugin object to control the `<query />` payload element. If we give the plugin object the name `'disco_info'` (using its `ElementBase.plugin_attrib` value), then we can access the plugin as so:

    >>> iq['disco_info']
    '<query xmlns="http://jabber.org/protocol/disco#info">
      <identity category="client" type="bot" name="Slixmpp Bot" />
    </query>'

We can then drill down through the plugin object’s interfaces as desired:

    >>> iq['disco_info']['identities']
    [('client', 'bot', 'Slixmpp Bot')]

Plugins may also add new interfaces to the parent stanza object as if they had been defined by the parent directly, and can also override the behaviour of an interface defined by the parent.

See also

- Creating Stanza Plugins

- is_extension

- overrides

## Registering Stanza Plugins

slixmpp.xmlstream.stanzabase.register_stanza_plugin(stanza, plugin, iterable=False, overrides=False)

  Associate a stanza object as a plugin for another stanza.

      >>> from slixmpp import Iq
      >>> from slixmpp.xmlstream import register_stanza_plugin
      >>> class IqPlugin(ElementBase):
      ...     name = 'plugin'
      ...     namespace = 'sleek:xmpp'
      ...     interfaces = {'plugin'}
      ...     plugin_attrib = 'plugin'
      >>> register_stanza_plugin(Iq, IqPlugin)
      >>> iq = Iq()
      >>> iq['plugin'] = 'value'
      >>> iq
      <iq xmlns="jabber:client" id="0"><plugin xmlns="sleek:xmpp" plugin="value" /></iq>

  Plugin stanzas marked as iterable will be included in the list of substanzas for the parent, using `parent['substanzas']`. If the attribute `plugin_multi_attrib` was defined for the plugin, then the substanza set can be filtered to only instances of the plugin class. For example, given a plugin class `Foo` with `plugin_multi_attrib = 'foos'` then:

      parent['foos']

  would return a collection of all `Foo` substanzas.

  Parameters:

    - stanza (`type`[`ElementBase`]) – The class of the parent stanza.

    - plugin (`type`[`ElementBase`]) – The class of the plugin stanza.

    - iterable (`bool`) – Indicates if the plugin stanza should be included in the parent stanza’s iterable `'substanzas'` interface results.

    - overrides (`bool`) – Indicates if the plugin should be allowed to override the interface handlers for the parent stanza, based on the plugin’s `overrides` field.

  Added in version 1.0-Beta1: Made `register_stanza_plugin` the default name. The prior `registerStanzaPlugin` function name remains as an alias.

  Return type:

    `None`

## ElementBase

class slixmpp.xmlstream.stanzabase.ElementBase(xml=None, parent=None)

  The core of Slixmpp’s stanza XML manipulation and handling is provided by ElementBase. ElementBase wraps XML ElementTree objects and enables access to the XML contents through dictionary syntax, similar in style to the Ruby XMPP library Blather’s stanza implementation.

  Stanzas are defined by their name, namespace, and interfaces. For example, a simplistic Message stanza could be defined as:

      >>> class Message(ElementBase):
      ...     name = "message"
      ...     namespace = "jabber:client"
      ...     interfaces = {'to', 'from', 'type', 'body'}
      ...     sub_interfaces = {'body'}

  The resulting Message stanza’s contents may be accessed as so:

      >>> message = Message()
      >>> message['to'] = "user@example.com"
      >>> message['body'] = "Hi!"
      >>> message['body']
      'Hi!'
      >>> del message['body']
      >>> message['body']
      ''

  The interface values map to either custom access methods, stanza XML attributes, or (if the interface is also in sub_interfaces) the text contents of a stanza’s subelement.

  Custom access methods may be created by adding methods of the form “getInterface”, “setInterface”, or “delInterface”, where “Interface” is the titlecase version of the interface name.

  Stanzas may be extended through the use of plugins. A plugin is simply a stanza that has a plugin_attrib value. For example:

      >>> class MessagePlugin(ElementBase):
      ...     name = "custom_plugin"
      ...     namespace = "custom"
      ...     interfaces = {'useful_thing', 'custom'}
      ...     plugin_attrib = "custom"

  The plugin stanza class must be associated with its intended container stanza by using register_stanza_plugin as so:

      >>> register_stanza_plugin(Message, MessagePlugin)

  The plugin may then be accessed as if it were built-in to the parent stanza:

      >>> message['custom']['useful_thing'] = 'foo'

  If a plugin provides an interface that is the same as the plugin’s plugin_attrib value, then the plugin’s interface may be assigned directly from the parent stanza, as shown below, but retrieving information will require all interfaces to be used, as so:

      >>> # Same as using message['custom']['custom']
      >>> message['custom'] = 'bar'
      >>> # Must use all interfaces
      >>> message['custom']['custom']
      'bar'

  If the plugin sets `is_extension` to `True`, then both setting and getting an interface value that is the same as the plugin’s plugin_attrib value will work, as so:

      >>> MessagePlugin.is_extension = True
      >>> register_stanza_plugin(Message, MessagePlugin)
      >>> message = Message()
      >>> message['custom'] = 'bar'  # Using is_extension=True
      >>> message['custom']
      'bar'

  Parameters:

    - xml (`Element` | `None`) – Initialize the stanza object with an existing XML object.

    - parent (`ElementBase` | `ReferenceType`[`ElementBase`] | `None`) – Optionally specify a parent stanza object will contain this substanza.

  __bool__()

    Stanza objects should be treated as True in boolean contexts.

    Return type:

      `bool`

  __contains__(name)

    Check if the stanza contains a specific plugin.

    Return type:

      `bool`

  __copy__()

    Return a copy of the stanza object that does not share the same underlying XML object.

    Return type:

      `ElementBase`

  __delitem__(attrib)

    Delete the value of a stanza interface using dict-like syntax.

    Example:

        >>> from slixmpp import Message
        >>> msg = Message()
        >>> msg['body'] = "Hi!"
        >>> msg['body']
        'Hi!'
        >>> del msg['body']
        >>> msg['body']
        ''

    Stanza interfaces are typically mapped directly to the underlyig XML object, but can be overridden by the presence of a `del_attrib` method (or `del_foo` where the interface is named `'foo'`, etc).

    The effect of deleting a stanza interface value named `foo` will be one of:

    > 1. Call `del_foo` override handler, if it exists.

    > 2. Call `del_foo`, if it exists.

    > 3. Call `delFoo`, if it exists.

    > 4. Delete `foo` element, if `'foo'` is in `sub_interfaces`.

    > 5. Remove `foo` element if `'foo'` is in `bool_interfaces`.

    > 6. Delete top level XML attribute named `foo`.

    > 7. Remove the `foo` plugin, if it was loaded.

    > 8. Do nothing.

    Parameters:

      attrib (`str`) – The name of the affected stanza interface.

    Return type:

      `Any`

  __eq__(other)

    Compare the stanza object with another to test for equality.

    Stanzas are equal if their interfaces return the same values, and if they are both instances of ElementBase.

    Parameters:

      other (`Any`) – The stanza object to compare against.

    Return type:

      `bool`

  __getitem__(full_attrib)

    Return the value of a stanza interface using dict-like syntax.

    Example:

        >>> from slixmpp import Message
        >>> msg = Message()
        >>> msg['body'] = 'Message contents'
        >>> msg['body']
        'Message contents'

    Stanza interfaces are typically mapped directly to the underlying XML object, but can be overridden by the presence of a `get_attrib` method (or `get_foo` where the interface is named `'foo'`, etc).

    The search order for interface value retrieval for an interface named `'foo'` is:

    > 1. The list of substanzas (`'substanzas'`)

    > 2. The result of calling the `get_foo` override handler.

    > 3. The result of calling `get_foo`.

    > 4. The result of calling `getFoo`.

    > 5. The contents of the `foo` subelement, if `foo` is listed in `sub_interfaces`.

    > 6. True or False depending on the existence of a `foo` subelement and `foo` is in `bool_interfaces`.

    > 7. The value of the `foo` attribute of the XML object.

    > 8. The plugin named `'foo'`

    > 9. An empty string.

    Parameters:

      full_attrib (`str`) – The name of the requested stanza interface.

    Return type:

      `Any`

  __init__(xml=None, parent=None)
  __iter__()

    Return an iterator object for the stanza’s substanzas.

    The iterator is the stanza object itself. Attempting to use two iterators on the same stanza at the same time is discouraged.

    Return type:

      `ElementBase`

  __len__()

    Return the number of iterable substanzas in this stanza.

    Return type:

      `int`

  __ne__(other)

    Compare the stanza object with another to test for inequality.

    Stanzas are not equal if their interfaces return different values, or if they are not both instances of ElementBase.

    Parameters:

      other (`Any`) – The stanza object to compare against.

    Return type:

      `bool`

  __next__()

    Return the next iterable substanza.

    Return type:

      `ElementBase`

  __repr__()

    Use the stanza’s serialized XML as its representation.

    Return type:

      `str`

  __setitem__(attrib, value)

    Set the value of a stanza interface using dictionary-like syntax.

    Example:

        >>> from slixmpp import Message
        >>> msg = Message()
        >>> msg['body'] = "Hi!"
        >>> msg['body']
        'Hi!'

    Stanza interfaces are typically mapped directly to the underlying XML object, but can be overridden by the presence of a `set_attrib` method (or `set_foo` where the interface is named `'foo'`, etc).

    The effect of interface value assignment for an interface named `'foo'` will be one of:

    > 1. Delete the interface’s contents if the value is None.

    > 2. Call the `set_foo` override handler, if it exists.

    > 3. Call `set_foo`, if it exists.

    > 4. Call `setFoo`, if it exists.

    > 5. Set the text of a `foo` element, if `'foo'` is in `sub_interfaces`.

    > 6. Add or remove an empty subelement `foo` if `foo` is in `bool_interfaces`.

    > 7. Set the value of a top level XML attribute named `foo`.

    > 8. Attempt to pass the value to a plugin named `'foo'` using the plugin’s `'foo'` interface.

    > 9. Do nothing.

    Parameters:

      - attrib (`str`) – The name of the stanza interface to modify.

      - value (`Any`) – The new value of the stanza interface.

    Return type:

      `Any`

  __str__(top_level_ns=True)

    Return a string serialization of the underlying XML object.

    See also

    XML Serialization

    Parameters:

      top_level_ns (`bool`) – Display the top-most namespace. Defaults to True.

    Return type:

      `str`

  __weakref__

    list of weak references to the object

  _del_attr(name)

    Remove a top level attribute of the XML object.

    Parameters:

      name (`str`) – The name of the attribute.

    Return type:

      `None`

  _del_sub(name, all=False, lang=None)

    Remove sub elements that match the given name or XPath.

    If the element is in a path, then any parent elements that become empty after deleting the element may also be deleted if requested by setting all=True.

    Parameters:

      - name (`str`) – The name or XPath expression for the element(s) to remove.

      - all (`bool`) – If True, remove all empty elements in the path to the deleted element. Defaults to False.

    Return type:

      `None`

  _get_attr(name, default='')

    Return the value of a top level attribute of the XML object.

    In case the attribute has not been set, a default value can be returned instead. An empty string is returned if no other default is supplied.

    Parameters:

      - name (`str`) – The name of the attribute.

      - default (`str`) – Optional value to return if the attribute has not been set. An empty string is returned otherwise.

    Return type:

      `str`

  _get_plugin(name, lang=None, check=False)

    Retrieve a stanza plugin.

    Parameters:

      - check (`bool`) – Return None instead of creating the object if True.

      - name (`str`) – Stanza plugin attribute name.

      - lang (`str` | `None`) – xml:lang of the element to retrieve.

    Return type:

      `ElementBase` | `None`

  _get_stanza_values()

    Return A JSON/dictionary version of the XML content exposed through the stanza’s interfaces:

        >>> class Message(ElementBase):
        ...     name = "message"
        ...     namespace = "jabber:client"
        ...     interfaces = {'to', 'from', 'type', 'body'}
        ...     sub_interfaces = {'body'}
        >>> msg = Message()
        >>> from pprint import pprint
        >>> pprint(msg.values)
        {'body': '', 'from': '', 'lang': '', 'to': '', 'type': ''}

    Likewise, assigning to `values` will change the XML content:

        >>> msg = Message()
        >>> msg.values = {'body': 'Hi!', 'to': 'user@example.com'}
        >>> msg
        <message xmlns="jabber:client" to="user@example.com"><body>Hi!</body></message>

    Added in version 1.0-Beta1.

    Return type:

      `dict`[`str`, `Any`]

  _get_sub_text(name, default='', lang=None)

    Return the text contents of a sub element.

    In case the element does not exist, or it has no textual content, a default value can be returned instead. An empty string is returned if no other default is supplied.

    Parameters:

      - name (`str`) – The name or XPath expression of the element.

      - default (`str`) – Optional default to return if the element does not exists. An empty string is returned otherwise.

    Return type:

      `str` | `dict`[`str`, `str`]

  _set_attr(name, value)

    Set the value of a top level attribute of the XML object.

    If the new value is None or an empty string, then the attribute will be removed.

    Parameters:

      - name (`str`) – The name of the attribute.

      - value (`str` | `JID` | `None`) – The new value of the attribute, or None or ‘’ to remove it.

    Return type:

      `None`

  _set_stanza_values(values)

    Set multiple stanza interface values using a dictionary.

    Stanza plugin values may be set using nested dictionaries.

    Parameters:

      values (`dict`[`str`, `Any`]) – A dictionary mapping stanza interface with values. Plugin interfaces may accept a nested dictionary that will be used recursively.

    Added in version 1.0-Beta1.

    Return type:

      `ElementBase`

  _set_sub_text(name, text=None, keep=False, lang=None)

    Set the text contents of a sub element.

    In case the element does not exist, a element will be created, and its text contents will be set.

    If the text is set to an empty string, or None, then the element will be removed, unless keep is set to True.

    Parameters:

      - name (`str`) – The name or XPath expression of the element.

      - text (`str` | `None`) – The new textual content of the element. If the text is an empty string or None, the element will be removed unless the parameter keep is True.

      - keep (`bool`) – Indicates if the element should be kept if its text is removed. Defaults to False.

    Return type:

      `Element` | `None`

  append(item)

    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 (`Element` | `ElementBase`) – Either an XML object or a stanza object to add to this stanza’s contents.

    Return type:

      `ElementBase`

  appendxml(xml)

    Append an XML object to the stanza’s XML.

    The added XML will not be included in the list of iterable substanzas.

    Parameters:

      xml (`Element`) – The XML object to add to the stanza.

    Return type:

      `ElementBase`

  bool_interfaces: ClassVar[set[str]] = {}

    A subset of `interfaces` which maps the presence of subelements to boolean values. Using this set allows for quickly checking for the existence of empty subelements like `<required />`.

    Added in version 1.1.

  clear()

    Remove all XML element contents and plugins.

    Any attribute values will be preserved.

    Return type:

      `ElementBase`

  enable(attrib, lang=None)

    Enable and initialize a stanza plugin.

    Alias for `init_plugin()`.

    Parameters:

      attrib (`str`) – The `plugin_attrib` value of the plugin to enable.

    Return type:

      `ElementBase`

  get(key, default=None)

    Return the value of a stanza interface.

    If the found value is None or an empty string, return the supplied default value.

    Allows stanza objects to be used like dictionaries.

    Parameters:

      - key (`str`) – The name of the stanza interface to check.

      - default (`Any` | `None`) – Value to return if the stanza interface has a value of `None` or `""`. Will default to returning None.

    Return type:

      `Any`

  get_plugin(name, lang=None, check=False)

    Retrieve a stanza plugin.

    Parameters:

      - check (`bool`) – Return None instead of creating the object if True.

      - name (`str`) – Stanza plugin attribute name.

      - lang (`str` | `None`) – xml:lang of the element to retrieve.

    Return type:

      `ElementBase` | `None`

  get_stanza_values()

    Return A JSON/dictionary version of the XML content exposed through the stanza’s interfaces:

        >>> class Message(ElementBase):
        ...     name = "message"
        ...     namespace = "jabber:client"
        ...     interfaces = {'to', 'from', 'type', 'body'}
        ...     sub_interfaces = {'body'}
        >>> msg = Message()
        >>> from pprint import pprint
        >>> pprint(msg.values)
        {'body': '', 'from': '', 'lang': '', 'to': '', 'type': ''}

    Likewise, assigning to `values` will change the XML content:

        >>> msg = Message()
        >>> msg.values = {'body': 'Hi!', 'to': 'user@example.com'}
        >>> msg
        <message xmlns="jabber:client" to="user@example.com"><body>Hi!</body></message>

    Added in version 1.0-Beta1.

    Return type:

      `dict`[`str`, `Any`]

  get_toplevel_attr(name, default='')

    Return the value of a top level attribute of the XML object.

    In case the attribute has not been set, a default value can be returned instead. An empty string is returned if no other default is supplied.

    Parameters:

      - name (`str`) – The name of the attribute.

      - default (`str`) – Optional value to return if the attribute has not been set. An empty string is returned otherwise.

    Return type:

      `str`

  init_plugin(attrib, lang=None, existing_xml=None, reuse=True, element=None)

    Enable and initialize a stanza plugin.

    Parameters:

      attrib (`str`) – The `plugin_attrib` value of the plugin to enable.

    Return type:

      `ElementBase`

  interfaces: ClassVar[set[str]] = {'from', 'id', 'payload', 'to', '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.

  is_extension: ClassVar[bool] = False

    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.

  iterables: list[ElementBase]

    A list of child stanzas whose class is included in `plugin_iterables`.

  keys()

    Return the names of all stanza interfaces provided by the stanza object.

    Allows stanza objects to be used like dictionaries.

    Return type:

      `list`[`str`]

  lang_interfaces: ClassVar[set[str]] = {}

    Added in version 1.1.2.

  match(xpath)

    Compare a stanza object with an XPath-like expression.

    If the XPath matches the contents of the stanza object, the match is successful.

    The XPath expression may include checks for stanza attributes. For example:

        'presence@show=xa@priority=2/status'

    Would match a presence stanza whose show value is set to `'xa'`, has a priority value of `'2'`, and has a status element.

    Parameters:

      xpath (`str` | `list`[`str`]) – The XPath expression to check against. It may be either a string or a list of element names with attribute checks.

    Return type:

      `bool`

  name: ClassVar[str] = 'stanza'

    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 = 'jabber:client'

    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.

  next()

    Return the next iterable substanza.

    Return type:

      `ElementBase`

  overrides: ClassVar[list[str]] = []

    In some cases you may wish to override the behaviour of one of the parent stanza’s interfaces. The `overrides` list specifies the interface name and access method to be overridden. For example, to override setting the parent’s `'condition'` interface you would use:

        overrides = ['set_condition']

    Getting and deleting the `'condition'` interface would not be affected.

    Added in version 1.0-Beta5.

  parent: ReferenceType[ElementBase] | None

    A `weakref.weakref` to the parent stanza, if there is one. If not, then `parent` is `None`.

  plugin_attrib: ClassVar[str] = 'plugin'

    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_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_multi_attrib: ClassVar[str] = ''

    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'])

  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]]] = {}

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

  plugins: dict[tuple[str, str | None], ElementBase]

    An ordered dictionary of plugin stanzas, mapped by their `plugin_attrib` value.

  pop(index=0)

    Remove and return the last substanza in the list of iterable substanzas.

    Allows stanza objects to be used like lists.

    Parameters:

      index (`int`) – The index of the substanza to remove.

    Return type:

      `ElementBase`

  set_stanza_values(values)

    Set multiple stanza interface values using a dictionary.

    Stanza plugin values may be set using nested dictionaries.

    Parameters:

      values (`dict`[`str`, `Any`]) – A dictionary mapping stanza interface with values. Plugin interfaces may accept a nested dictionary that will be used recursively.

    Added in version 1.0-Beta1.

    Return type:

      `ElementBase`

  setup(xml=None)

    Initialize the stanza’s XML contents.

    Will return `True` if XML was generated according to the stanza’s definition instead of building a stanza object from an existing XML object.

    Parameters:

      xml (`Element` | `None`) – An existing XML object to use for the stanza’s content instead of generating new XML.

    Return type:

      `bool`

  sub_interfaces: ClassVar[set[str]] = {}

    A subset of `interfaces` which maps interfaces to direct subelements of the underlying XML object. Using this set, the text of these subelements may be set, retrieved, or removed without needing to define custom methods.

  tag: str

    The name of the tag for the stanza’s root element. It is the same as calling `tag_name()` and is formatted as `'{namespace}elementname'`.

  classmethod tag_name()

    Return the namespaced name of the stanza’s root element.

    The format for the tag name is:

        '{namespace}elementname'

    For example, for the stanza `<foo xmlns="bar" />`, `stanza.tag_name()` would return `"{bar}foo"`.

    Return type:

      `str`

  property values: dict[str, Any]

    A JSON/dictionary version of the XML content exposed through the stanza interfaces:

         >>> msg = Message()
         >>> msg.values
        {'body': '', 'from': , 'mucnick': '', 'mucroom': '',
         'to': , 'type': 'normal', 'id': '', 'subject': ''}

    Likewise, assigning to the `values` will change the XML content:

        >>> msg = Message()
        >>> msg.values = {'body': 'Hi!', 'to': 'user@example.com'}
        >>> msg
        '<message to="user@example.com"><body>Hi!</body></message>'

    Child stanzas are exposed as nested dictionaries.

  xml: Element

    The underlying XML object for the stanza. It is a standard `xml.etree.ElementTree` object.

  xml_ns: ClassVar[str] = 'http://www.w3.org/XML/1998/namespace'

    The default XML namespace: `http://www.w3.org/XML/1998/namespace`.

## StanzaBase

class slixmpp.xmlstream.stanzabase.StanzaBase(stream=None, xml=None, stype=None, sto=None, sfrom=None, sid=None, parent=None, recv=False)

  StanzaBase provides the foundation for all other stanza objects used by Slixmpp, and defines a basic set of interfaces common to nearly all stanzas. These interfaces are the `'id'`, `'type'`, `'to'`, and `'from'` attributes. An additional interface, `'payload'`, is available to access the XML contents of the stanza. Most stanza objects will provided more specific interfaces, however.

  Stanza Interfaces:

  > id:

  >   An optional id value that can be used to associate stanzas

  > to:

  >   A JID object representing the recipient’s JID.

  > from:

  >   A JID object representing the sender’s JID. with their replies.

  > type:

  >   The type of stanza, typically will be `'normal'`, `'error'`, `'get'`, or `'set'`, etc.

  > payload:

  >   The XML contents of the stanza.

  Parameters:

    - stream (`XMLStream` | `None`) – Optional `slixmpp.xmlstream.XMLStream` object responsible for sending this stanza.

    - xml (`Element` | `None`) – Optional XML contents to initialize stanza values.

    - stype (`str` | `None`) – Optional stanza type value.

    - sto (`str` | `JID` | `None`) – Optional string or `slixmpp.xmlstream.JID` object of the recipient’s JID.

    - sfrom (`str` | `JID` | `None`) – Optional string or `slixmpp.xmlstream.JID` object of the sender’s JID.

    - sid (`str` | `None`) – Optional ID value for the stanza.

    - parent (`ElementBase` | `None`) – Optionally specify a parent stanza object will contain this substanza.

  del_payload()

    Remove the XML contents of the stanza.

    Return type:

      `StanzaBase`

  error()

    Set the stanza’s type to `'error'`.

    Return type:

      `StanzaBase`

  exception(e)

    Handle exceptions raised during stanza processing.

    Meant to be overridden.

    Return type:

      `None`

  get_from()

    Return the value of the stanza’s `'from'` attribute.

    Return type:

      `JID`

  get_payload()

    Return a list of XML objects contained in the stanza.

    Return type:

      `list`[`Element`]

  get_to()

    Return the value of the stanza’s `'to'` attribute.

    Return type:

      `JID`

  namespace: str = 'jabber:client'

    The default XMPP client namespace

  pretty_print()

    Print an indented version of the XML content of this stanza.

    Return type:

      `None`

  reply(clear=True)

    Prepare the stanza for sending a reply.

    Swaps the `'from'` and `'to'` attributes.

    If `clear=True`, then also remove the stanza’s contents to make room for the reply content.

    For client streams, the `'from'` attribute is removed.

    Parameters:

      clear (`bool`) – Indicates if the stanza’s contents should be removed. Defaults to `True`.

    Return type:

      `StanzaBase`

  send()

    Queue the stanza to be sent on the XML stream.

    Return type:

      `None`

  set_from(value)

    Set the ‘from’ attribute of the stanza.

    Parameters:

      from (str or `JID`) – A string or JID object representing the sender’s JID.

    Return type:

      `None`

  set_payload(value)

    Add XML content to the stanza.

    Parameters:

      value (`list`[`ElementBase`] | `ElementBase`) – Either an XML or a stanza object, or a list of XML or stanza objects.

    Return type:

      `StanzaBase`

  set_to(value)

    Set the `'to'` attribute of the stanza.

    Parameters:

      value (`str` | `JID`) – A string or `slixmpp.xmlstream.JID` object representing the recipient’s JID.

    Return type:

      `None`

  set_type(value)

    Set the stanza’s `'type'` attribute.

    Only type values contained in `types` are accepted.

    Parameters:

      value (`str`) – One of the values contained in `types`

    Return type:

      `StanzaBase`

  unhandled()

    Called if no handlers have been registered to process this stanza.

    Meant to be overridden.

    Return type:

      `None`