Source code for aioxmpp.pubsub.xso

########################################################################
# File name: xso.py
# This file is part of: aioxmpp
#
# LICENSE
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Lesser General Public License as
# published by the Free Software Foundation, either version 3 of the
# License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful, but
# WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
# Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public
# License along with this program.  If not, see
# <http://www.gnu.org/licenses/>.
#
########################################################################
import aioxmpp.forms
import aioxmpp.stanza
import aioxmpp.xso as xso

from enum import Enum

from aioxmpp.utils import namespaces


class Feature(Enum):
    ACCESS_AUTHORIZE = \
        "http://jabber.org/protocol/pubsub#access-authorize"
    ACCESS_OPEN = \
        "http://jabber.org/protocol/pubsub#access-open"
    ACCESS_PRESENCE = \
        "http://jabber.org/protocol/pubsub#access-presence"
    ACCESS_ROSTER = \
        "http://jabber.org/protocol/pubsub#access-roster"
    ACCESS_WHITELIST = \
        "http://jabber.org/protocol/pubsub#access-whitelist"
    AUTO_CREATE = \
        "http://jabber.org/protocol/pubsub#auto-create"
    AUTO_SUBSCRIBE = \
        "http://jabber.org/protocol/pubsub#auto-subscribe"
    COLLECTIONS = \
        "http://jabber.org/protocol/pubsub#collections"
    CONFIG_NODE = \
        "http://jabber.org/protocol/pubsub#config-node"
    CREATE_AND_CONFIGURE = \
        "http://jabber.org/protocol/pubsub#create-and-configure"
    CREATE_NODES = \
        "http://jabber.org/protocol/pubsub#create-nodes"
    DELETE_ITEMS = \
        "http://jabber.org/protocol/pubsub#delete-items"
    DELETE_NODES = \
        "http://jabber.org/protocol/pubsub#delete-nodes"
    FILTERED_NOTIFICATIONS = \
        "http://jabber.org/protocol/pubsub#filtered-notifications"
    GET_PENDING = \
        "http://jabber.org/protocol/pubsub#get-pending"
    INSTANT_NODES = \
        "http://jabber.org/protocol/pubsub#instant-nodes"
    ITEM_IDS = \
        "http://jabber.org/protocol/pubsub#item-ids"
    LAST_PUBLISHED = \
        "http://jabber.org/protocol/pubsub#last-published"
    LEASED_SUBSCRIPTION = \
        "http://jabber.org/protocol/pubsub#leased-subscription"
    MANAGE_SUBSCRIPTIONS = \
        "http://jabber.org/protocol/pubsub#manage-subscriptions"
    MEMBER_AFFILIATION = \
        "http://jabber.org/protocol/pubsub#member-affiliation"
    META_DATA = \
        "http://jabber.org/protocol/pubsub#meta-data"
    MODIFY_AFFILIATIONS = \
        "http://jabber.org/protocol/pubsub#modify-affiliations"
    MULTI_COLLECTION = \
        "http://jabber.org/protocol/pubsub#multi-collection"
    MULTI_SUBSCRIBE = \
        "http://jabber.org/protocol/pubsub#multi-subscribe"
    OUTCAST_AFFILIATION = \
        "http://jabber.org/protocol/pubsub#outcast-affiliation"
    PERSISTENT_ITEMS = \
        "http://jabber.org/protocol/pubsub#persistent-items"
    PRESENCE_NOTIFICATIONS = \
        "http://jabber.org/protocol/pubsub#presence-notifications"
    PRESENCE_SUBSCRIBE = \
        "http://jabber.org/protocol/pubsub#presence-subscribe"
    PUBLISH = \
        "http://jabber.org/protocol/pubsub#publish"
    PUBLISH_OPTIONS = \
        "http://jabber.org/protocol/pubsub#publish-options"
    PUBLISH_ONLY_AFFILIATION = \
        "http://jabber.org/protocol/pubsub#publish-only-affiliation"
    PUBLISHER_AFFILIATION = \
        "http://jabber.org/protocol/pubsub#publisher-affiliation"
    PURGE_NODES = \
        "http://jabber.org/protocol/pubsub#purge-nodes"
    RETRACT_ITEMS = \
        "http://jabber.org/protocol/pubsub#retract-items"
    RETRIEVE_AFFILIATIONS = \
        "http://jabber.org/protocol/pubsub#retrieve-affiliations"
    RETRIEVE_DEFAULT = \
        "http://jabber.org/protocol/pubsub#retrieve-default"
    RETRIEVE_ITEMS = \
        "http://jabber.org/protocol/pubsub#retrieve-items"
    RETRIEVE_SUBSCRIPTIONS = \
        "http://jabber.org/protocol/pubsub#retrieve-subscriptions"
    SUBSCRIBE = \
        "http://jabber.org/protocol/pubsub#subscribe"
    SUBSCRIPTION_OPTIONS = \
        "http://jabber.org/protocol/pubsub#subscription-options"
    SUBSCRIPTION_NOTIFICATIONS = \
        "http://jabber.org/protocol/pubsub#subscription-notifications"


namespaces.xep0060_features = Feature
namespaces.xep0060 = "http://jabber.org/protocol/pubsub"
namespaces.xep0060_errors = "http://jabber.org/protocol/pubsub#errors"
namespaces.xep0060_event = "http://jabber.org/protocol/pubsub#event"
namespaces.xep0060_owner = "http://jabber.org/protocol/pubsub#owner"


class Affiliation(xso.XSO):
    TAG = (namespaces.xep0060, "affiliation")

    node = xso.Attr(
        "node",
        default=None
    )

    affiliation = xso.Attr(
        "affiliation",
        validator=xso.RestrictToSet({
            "member",
            "none",
            "outcast",
            "owner",
            "publisher",
            "publish-only",
        }),
    )

    def __init__(self, affiliation, node=None):
        super().__init__()
        self.affiliation = affiliation
        self.node = node


class Affiliations(xso.XSO):
    TAG = (namespaces.xep0060, "affiliations")

    node = xso.Attr(
        "node",
        default=None
    )

    affiliations = xso.ChildList(
        [Affiliation],
    )

    def __init__(self, affiliations=[], node=None):
        super().__init__()
        self.affiliations[:] = affiliations
        self.node = node


class Configure(xso.XSO):
    TAG = (namespaces.xep0060, "configure")

    data = xso.Child([
        aioxmpp.forms.Data,
    ])


class Create(xso.XSO):
    TAG = (namespaces.xep0060, "create")

    node = xso.Attr(
        "node",
        default=None
    )


class Default(xso.XSO):
    TAG = (namespaces.xep0060, "default")

    node = xso.Attr(
        "node",
        default=None
    )

    type_ = xso.Attr(
        "type",
        validator=xso.RestrictToSet({
            "leaf",
            "collection",
        }),
        default="leaf",
    )

    data = xso.Child([
        aioxmpp.forms.Data,
    ])

    def __init__(self, *, node=None, data=None):
        super().__init__()
        self.node = node
        self.data = data


class Item(xso.XSO):
    TAG = (namespaces.xep0060, "item")

    id_ = xso.Attr(
        "id",
        default=None
    )

    registered_payload = xso.Child([], strict=True)

    unregistered_payload = xso.Collector()

    def __init__(self, id_=None):
        super().__init__()
        self.id_ = id_


class Items(xso.XSO):
    TAG = (namespaces.xep0060, "items")

    max_items = xso.Attr(
        (None, "max_items"),
        type_=xso.Integer(),
        validator=xso.NumericRange(min_=1),
        default=None,
    )

    node = xso.Attr(
        "node",
    )

    subid = xso.Attr(
        "subid",
        default=None
    )

    items = xso.ChildList(
        [Item]
    )

    def __init__(self, node, subid=None, max_items=None):
        super().__init__()
        self.node = node
        self.subid = subid
        self.max_items = max_items


class Options(xso.XSO):
    TAG = (namespaces.xep0060, "options")

    jid = xso.Attr(
        "jid",
        type_=xso.JID()
    )

    node = xso.Attr(
        "node",
        default=None
    )

    subid = xso.Attr(
        "subid",
        default=None
    )

    data = xso.Child([
        aioxmpp.forms.Data,
    ])

    def __init__(self, jid, node=None, subid=None):
        super().__init__()
        self.jid = jid
        self.node = node
        self.subid = subid


class PublishOptions(xso.XSO):
    TAG = (namespaces.xep0060, "publish-options")

    data = xso.Child([
        aioxmpp.forms.Data,
    ])


class Publish(xso.XSO):
    TAG = (namespaces.xep0060, "publish")

    node = xso.Attr(
        "node",
    )

    item = xso.Child([
        Item
    ])


class Retract(xso.XSO):
    TAG = (namespaces.xep0060, "retract")

    node = xso.Attr(
        "node",
    )

    item = xso.Child([
        Item
    ])

    notify = xso.Attr(
        "notify",
        type_=xso.Bool(),
        default=False,
    )


class Subscribe(xso.XSO):
    TAG = (namespaces.xep0060, "subscribe")

    jid = xso.Attr(
        "jid",
        type_=xso.JID()
    )

    node = xso.Attr(
        "node",
        default=None
    )

    def __init__(self, jid, node=None):
        super().__init__()
        self.jid = jid
        self.node = node


class SubscribeOptions(xso.XSO):
    TAG = (namespaces.xep0060, "subscribe-options")

    required = xso.ChildTag(
        [
            (namespaces.xep0060, "required"),
        ],
        allow_none=True
    )


class Subscription(xso.XSO):
    TAG = (namespaces.xep0060, "subscription")

    jid = xso.Attr(
        "jid",
        type_=xso.JID()
    )

    node = xso.Attr(
        "node",
        default=None
    )

    subid = xso.Attr(
        "subid",
        default=None
    )

    subscription = xso.Attr(
        "subscription",
        validator=xso.RestrictToSet({
            "none",
            "pending",
            "subscribed",
            "unconfigured",
        }),
        default=None
    )

    subscribe_options = xso.Child(
        [SubscribeOptions]
    )

    def __init__(self, jid, node=None, subid=None, *, subscription=None):
        super().__init__()
        self.jid = jid
        self.node = node
        self.subid = subid
        self.subscription = subscription


class Subscriptions(xso.XSO):
    TAG = (namespaces.xep0060, "subscriptions")

    node = xso.Attr(
        "node",
        default=None
    )

    subscriptions = xso.ChildList(
        [Subscription],
    )

    def __init__(self, *, subscriptions=[], node=None):
        super().__init__()
        self.node = node
        self.subscriptions[:] = subscriptions


class Unsubscribe(xso.XSO):
    TAG = (namespaces.xep0060, "unsubscribe")

    jid = xso.Attr(
        "jid",
        type_=xso.JID()
    )

    node = xso.Attr(
        "node",
        default=None
    )

    subid = xso.Attr(
        "subid",
        default=None
    )

    def __init__(self, jid, node=None, subid=None):
        super().__init__()
        self.jid = jid
        self.node = node
        self.subid = subid


@aioxmpp.stanza.IQ.as_payload_class
class Request(xso.XSO):
    """
    This XSO represents the ``<pubsub/>`` IQ payload from the generic pubsub
    namespace (``http://jabber.org/protocol/pubsub``). It can carry different
    types of payload.

    .. attribute:: payload

       This is the generic payload attribute. It supports the following
       classes:

       .. autosummary::

          Affiliations
          Create
          Default
          Items
          Publish
          Retract
          Subscribe
          Subscription
          Subscriptions
          Unsubscribe

    .. attribute:: options

       As :class:`Options` may both be used independently and along with
       another :attr:`payload`, they have their own attribute.

       Independent of their use, :class:`Options` objects are always available
       here. If they are used without another payload, the :attr:`payload`
       attribute is :data:`None`.

    .. attribute:: configure

       As :class:`Configure` may both be used independently and along with
       another :attr:`payload`, it has its own attribute.

       Independent of their use, :class:`Configure` objects are always
       available here. If they are used without another payload, the
       :attr:`payload` attribute is :data:`None`.

    """
    TAG = (namespaces.xep0060, "pubsub")

    payload = xso.Child([
        Affiliations,
        Create,
        Default,
        Items,
        Publish,
        Retract,
        Subscribe,
        Subscription,
        Subscriptions,
        Unsubscribe,
    ])

    options = xso.Child([
        Options,
    ])

    configure = xso.Child([
        Configure,
    ])

    publish_options = xso.Child([
        PublishOptions,
    ])

    def __init__(self, payload=None):
        super().__init__()
        self.payload = payload


aioxmpp.stanza.Message.xep0060_request = xso.Child([
    Request
])


class EventAssociate(xso.XSO):
    TAG = (namespaces.xep0060_event, "associate")

    node = xso.Attr(
        "node",
    )


class EventDisassociate(xso.XSO):
    TAG = (namespaces.xep0060_event, "disassociate")

    node = xso.Attr(
        "node",
    )


class EventCollection(xso.XSO):
    TAG = (namespaces.xep0060_event, "collection")

    assoc = xso.Child([
        EventAssociate,
        EventDisassociate,
    ])


class EventRedirect(xso.XSO):
    TAG = (namespaces.xep0060_event, "redirect")

    uri = xso.Attr(
        "uri",
    )

    def __init__(self, uri):
        super().__init__()
        self.uri = uri


class EventDelete(xso.XSO):
    TAG = (namespaces.xep0060_event, "delete")

    _redirect = xso.Child([
        EventRedirect,
    ])

    node = xso.Attr(
        "node",
    )

    def __init__(self, node, *, redirect_uri=None):
        super().__init__()
        self.node = node
        if redirect_uri is not None:
            self._redirect = EventRedirect(redirect_uri)

    @property
    def redirect_uri(self):
        if self._redirect is None:
            return None
        return self._redirect.uri

    @redirect_uri.setter
    def redirect_uri(self, value):
        if value is None:
            del self._redirect
            return
        self._redirect = EventRedirect(value)

    @redirect_uri.deleter
    def redirect_uri(self):
        del self._redirect


class EventRetract(xso.XSO):
    TAG = (namespaces.xep0060_event, "retract")

    id_ = xso.Attr(
        "id",
    )

    def __init__(self, id_):
        super().__init__()
        self.id_ = id_


class EventItem(xso.XSO):
    TAG = (namespaces.xep0060_event, "item")

    id_ = xso.Attr(
        "id",
        default=None,
    )

    node = xso.Attr(
        "node",
        default=None,
    )

    publisher = xso.Attr(
        "publisher",
        default=None,
    )

    registered_payload = xso.Child([], strict=True)

    unregistered_payload = xso.Collector()

    def __init__(self, payload, *, id_=None):
        super().__init__()
        self.registered_payload = payload
        self.id_ = id_


class EventItems(xso.XSO):
    TAG = (namespaces.xep0060_event, "items")

    node = xso.Attr(
        "node",
    )

    retracts = xso.ChildList([EventRetract])

    items = xso.ChildList([EventItem])

    def __init__(self, node, *, items=[], retracts=[]):
        super().__init__()
        self.items[:] = items
        self.retracts[:] = retracts
        self.node = node


class EventPurge(xso.XSO):
    TAG = (namespaces.xep0060_event, "purge")

    node = xso.Attr(
        "node",
    )


class EventSubscription(xso.XSO):
    TAG = (namespaces.xep0060_event, "subscription")

    jid = xso.Attr(
        "jid",
        type_=xso.JID()
    )

    node = xso.Attr(
        "node",
        default=None
    )

    subid = xso.Attr(
        "subid",
        default=None
    )

    subscription = xso.Attr(
        "subscription",
        validator=xso.RestrictToSet({
            "none",
            "pending",
            "subscribed",
            "unconfigured",
        }),
        default=None
    )

    expiry = xso.Attr(
        "expiry",
        type_=xso.DateTime(),
    )


class EventConfiguration(xso.XSO):
    TAG = (namespaces.xep0060_event, "configuration")

    node = xso.Attr(
        "node",
        default=None
    )

    data = xso.Child([
        aioxmpp.forms.Data,
    ])


class Event(xso.XSO):
    TAG = (namespaces.xep0060_event, "event")

    payload = xso.Child([
        EventCollection,
        EventConfiguration,
        EventDelete,
        EventItems,
        EventPurge,
        EventSubscription,
    ])

    def __init__(self, payload=None):
        super().__init__()
        self.payload = payload


aioxmpp.stanza.Message.xep0060_event = xso.Child([
    Event
])


class OwnerAffiliation(xso.XSO):
    TAG = (namespaces.xep0060_owner, "affiliation")

    affiliation = xso.Attr(
        "affiliation",
        validator=xso.RestrictToSet({
            "member",
            "outcast",
            "owner",
            "publisher",
            "publish-only",
            "none",
        }),
        validate=xso.ValidateMode.ALWAYS,
    )

    jid = xso.Attr(
        "jid",
        type_=xso.JID(),
    )

    def __init__(self, jid, affiliation):
        super().__init__()
        self.jid = jid
        self.affiliation = affiliation


class OwnerAffiliations(xso.XSO):
    TAG = (namespaces.xep0060_owner, "affiliations")

    affiliations = xso.ChildList([OwnerAffiliation])

    node = xso.Attr(
        "node",
    )

    def __init__(self, node, *, affiliations=[]):
        super().__init__()
        self.node = node
        self.affiliations[:] = affiliations


class OwnerConfigure(xso.XSO):
    TAG = (namespaces.xep0060_owner, "configure")

    node = xso.Attr(
        "node",
        default=None,
    )

    data = xso.Child([
        aioxmpp.forms.Data,
    ])

    def __init__(self, node=None):
        super().__init__()
        self.node = node


class OwnerDefault(xso.XSO):
    TAG = (namespaces.xep0060_owner, "default")

    data = xso.Child([
        aioxmpp.forms.Data,
    ])


class OwnerRedirect(xso.XSO):
    TAG = (namespaces.xep0060_owner, "redirect")

    uri = xso.Attr(
        "uri",
    )

    def __init__(self, uri):
        super().__init__()
        self.uri = uri


class OwnerDelete(xso.XSO):
    TAG = (namespaces.xep0060_owner, "delete")

    _redirect = xso.Child([OwnerRedirect])

    node = xso.Attr(
        "node",
    )

    def __init__(self, node, *, redirect_uri=None):
        super().__init__()
        self.node = node
        if redirect_uri is not None:
            self._redirect = OwnerRedirect(redirect_uri)

    @property
    def redirect_uri(self):
        if self._redirect is None:
            return None
        return self._redirect.uri

    @redirect_uri.setter
    def redirect_uri(self, value):
        if value is None:
            del self._redirect
            return
        self._redirect = OwnerRedirect(value)

    @redirect_uri.deleter
    def redirect_uri(self):
        del self._redirect


class OwnerPurge(xso.XSO):
    TAG = (namespaces.xep0060_owner, "purge")

    node = xso.Attr(
        "node",
    )

    def __init__(self, node):
        super().__init__()
        self.node = node


class OwnerSubscription(xso.XSO):
    TAG = (namespaces.xep0060_owner, "subscription")

    subscription = xso.Attr(
        "subscription",
        validator=xso.RestrictToSet({
            "none",
            "pending",
            "subscribed",
            "unconfigured",
        }),
        validate=xso.ValidateMode.ALWAYS
    )

    jid = xso.Attr(
        "jid",
        type_=xso.JID(),
    )

    def __init__(self, jid, subscription):
        super().__init__()
        self.jid = jid
        self.subscription = subscription


class OwnerSubscriptions(xso.XSO):
    TAG = (namespaces.xep0060_owner, "subscriptions")

    node = xso.Attr(
        "node",
    )

    subscriptions = xso.ChildList([OwnerSubscription])

    def __init__(self, node, *, subscriptions=[]):
        super().__init__()
        self.node = node
        self.subscriptions[:] = subscriptions


@aioxmpp.stanza.IQ.as_payload_class
class OwnerRequest(xso.XSO):
    TAG = (namespaces.xep0060_owner, "pubsub")

    payload = xso.Child([
        OwnerAffiliations,
        OwnerConfigure,
        OwnerDefault,
        OwnerDelete,
        OwnerPurge,
        OwnerSubscriptions,
    ])

    def __init__(self, payload):
        super().__init__()
        self.payload = payload


def as_payload_class(cls):
    """
    Register the given class `cls` as Publish-Subscribe payload on both
    :class:`Item` and :class:`EventItem`.

    Return the class, to allow this to be used as decorator.
    """

    Item.register_child(
        Item.registered_payload,
        cls,
    )

    EventItem.register_child(
        EventItem.registered_payload,
        cls,
    )

    return cls


ClosedNode = aioxmpp.stanza.make_application_error(
    "ClosedNode",
    (namespaces.xep0060_errors, "closed-node"),
)

ConfigurationRequired = aioxmpp.stanza.make_application_error(
    "ConfigurationRequired",
    (namespaces.xep0060_errors, "configuration-required"),
)

InvalidJID = aioxmpp.stanza.make_application_error(
    "InvalidJID",
    (namespaces.xep0060_errors, "invalid-jid"),
)

InvalidOptions = aioxmpp.stanza.make_application_error(
    "InvalidOptions",
    (namespaces.xep0060_errors, "invalid-options"),
)

InvalidPayload = aioxmpp.stanza.make_application_error(
    "InvalidPayload",
    (namespaces.xep0060_errors, "invalid-payload"),
)

InvalidSubID = aioxmpp.stanza.make_application_error(
    "InvalidSubID",
    (namespaces.xep0060_errors, "invalid-subid"),
)

ItemForbidden = aioxmpp.stanza.make_application_error(
    "ItemForbidden",
    (namespaces.xep0060_errors, "item-forbidden"),
)

ItemRequired = aioxmpp.stanza.make_application_error(
    "ItemRequired",
    (namespaces.xep0060_errors, "item-required"),
)

JIDRequired = aioxmpp.stanza.make_application_error(
    "JIDRequired",
    (namespaces.xep0060_errors, "jid-required"),
)

MaxItemsExceeded = aioxmpp.stanza.make_application_error(
    "MaxItemsExceeded",
    (namespaces.xep0060_errors, "max-items-exceeded"),
)

MaxNodesExceeded = aioxmpp.stanza.make_application_error(
    "MaxNodesExceeded",
    (namespaces.xep0060_errors, "max-nodes-exceeded"),
)

NodeIDRequired = aioxmpp.stanza.make_application_error(
    "NodeIDRequired",
    (namespaces.xep0060_errors, "nodeid-required"),
)

NotInRosterGroup = aioxmpp.stanza.make_application_error(
    "NotInRosterGroup",
    (namespaces.xep0060_errors, "not-in-roster-group"),
)

NotSubscribed = aioxmpp.stanza.make_application_error(
    "NotSubscribed",
    (namespaces.xep0060_errors, "not-subscribed"),
)

PayloadTooBig = aioxmpp.stanza.make_application_error(
    "PayloadTooBig",
    (namespaces.xep0060_errors, "payload-too-big"),
)

PayloadRequired = aioxmpp.stanza.make_application_error(
    "PayloadRequired",
    (namespaces.xep0060_errors, "payload-required"),
)

PendingSubscription = aioxmpp.stanza.make_application_error(
    "PendingSubscription",
    (namespaces.xep0060_errors, "pending-subscription"),
)

PresenceSubscriptionRequired = aioxmpp.stanza.make_application_error(
    "PresenceSubscriptionRequired",
    (namespaces.xep0060_errors, "presence-subscription-required"),
)

SubIDRequired = aioxmpp.stanza.make_application_error(
    "SubIDRequired",
    (namespaces.xep0060_errors, "subid-required"),
)

TooManySubscriptions = aioxmpp.stanza.make_application_error(
    "TooManySubscriptions",
    (namespaces.xep0060_errors, "too-many-subscriptions"),
)


@aioxmpp.stanza.Error.as_application_condition
class Unsupported(xso.XSO):
    TAG = (namespaces.xep0060_errors, "unsupported")

    feature = xso.Attr(
        "feature",
        validator=xso.RestrictToSet({
            "access-authorize",
            "access-open",
            "access-presence",
            "access-roster",
            "access-whitelist",
            "auto-create",
            "auto-subscribe",
            "collections",
            "config-node",
            "create-and-configure",
            "create-nodes",
            "delete-items",
            "delete-nodes",
            "filtered-notifications",
            "get-pending",
            "instant-nodes",
            "item-ids",
            "last-published",
            "leased-subscription",
            "manage-subscriptions",
            "member-affiliation",
            "meta-data",
            "modify-affiliations",
            "multi-collection",
            "multi-subscribe",
            "outcast-affiliation",
            "persistent-items",
            "presence-notifications",
            "presence-subscribe",
            "publish",
            "publish-options",
            "publish-only-affiliation",
            "publisher-affiliation",
            "purge-nodes",
            "retract-items",
            "retrieve-affiliations",
            "retrieve-default",
            "retrieve-items",
            "retrieve-subscriptions",
            "subscribe",
            "subscription-options",
            "subscription-notifications",
        })
    )


# foo
Feature.__docstring___ = \
    """
    .. attribute:: ACCESS_AUTHORIZE
       :annotation: = "http://jabber.org/protocol/pubsub#access-authorize"

       The default node access model is authorize.

    .. attribute:: ACCESS_OPEN
       :annotation: = "http://jabber.org/protocol/pubsub#access-open"

       The default node access model is open.

    .. attribute:: ACCESS_PRESENCE
       :annotation: = "http://jabber.org/protocol/pubsub#access-presence"

       The default node access model is presence.

    .. attribute:: ACCESS_ROSTER
       :annotation: = "http://jabber.org/protocol/pubsub#access-roster"

       The default node access model is roster.

    .. attribute:: ACCESS_WHITELIST
       :annotation: = "http://jabber.org/protocol/pubsub#access-whitelist"

       The default node access model is whitelist.

    .. attribute:: AUTO_CREATE
       :annotation: = "http://jabber.org/protocol/pubsub#auto-create"

       The service supports automatic creation of nodes on first publish.

    .. attribute:: AUTO_SUBSCRIBE
       :annotation: = "http://jabber.org/protocol/pubsub#auto-subscribe"

       The service supports automatic subscription to a nodes based on presence subscription.

    .. attribute:: COLLECTIONS
       :annotation: = "http://jabber.org/protocol/pubsub#collections"

       Collection nodes are supported.

    .. attribute:: CONFIG_NODE
       :annotation: = "http://jabber.org/protocol/pubsub#config-node"

       Configuration of node options is supported.

    .. attribute:: CREATE_AND_CONFIGURE
       :annotation: = "http://jabber.org/protocol/pubsub#create-and-configure"

       Simultaneous creation and configuration of nodes is supported.

    .. attribute:: CREATE_NODES
       :annotation: = "http://jabber.org/protocol/pubsub#create-nodes"

       Creation of nodes is supported.

    .. attribute:: DELETE_ITEMS
       :annotation: = "http://jabber.org/protocol/pubsub#delete-items"

       Deletion of items is supported.

    .. attribute:: DELETE_NODES
       :annotation: = "http://jabber.org/protocol/pubsub#delete-nodes"

       Deletion of nodes is supported.

    .. attribute:: FILTERED_NOTIFICATIONS
       :annotation: = "http://jabber.org/protocol/pubsub#filtered-notifications"

       The service supports filtering of notifications based on Entity Capabilities.

    .. attribute:: GET_PENDING
       :annotation: = "http://jabber.org/protocol/pubsub#get-pending"

       Retrieval of pending subscription approvals is supported.

    .. attribute:: INSTANT_NODES
       :annotation: = "http://jabber.org/protocol/pubsub#instant-nodes"

       Creation of instant nodes is supported.

    .. attribute:: ITEM_IDS
       :annotation: = "http://jabber.org/protocol/pubsub#item-ids"

       Publishers may specify item identifiers.

    .. attribute:: LAST_PUBLISHED
       :annotation: = "http://jabber.org/protocol/pubsub#last-published"

       The service supports sending of the last published item to new subscribers and to newly available resources.

    .. attribute:: LEASED_SUBSCRIPTION
       :annotation: = "http://jabber.org/protocol/pubsub#leased-subscription"

       Time-based subscriptions are supported.

    .. attribute:: MANAGE_SUBSCRIPTIONS
       :annotation: = "http://jabber.org/protocol/pubsub#manage-subscriptions"

       Node owners may manage subscriptions.

    .. attribute:: MEMBER_AFFILIATION
       :annotation: = "http://jabber.org/protocol/pubsub#member-affiliation"

       The member affiliation is supported.

    .. attribute:: META_DATA
       :annotation: = "http://jabber.org/protocol/pubsub#meta-data"

       Node meta-data is supported.

    .. attribute:: MODIFY_AFFILIATIONS
       :annotation: = "http://jabber.org/protocol/pubsub#modify-affiliations"

       Node owners may modify affiliations.

    .. attribute:: MULTI_COLLECTION
       :annotation: = "http://jabber.org/protocol/pubsub#multi-collection"

       A single leaf node can be associated with multiple collections.

    .. attribute:: MULTI_SUBSCRIBE
       :annotation: = "http://jabber.org/protocol/pubsub#multi-subscribe"

       A single entity may subscribe to a node multiple times.

    .. attribute:: OUTCAST_AFFILIATION
       :annotation: = "http://jabber.org/protocol/pubsub#outcast-affiliation"

       The outcast affiliation is supported.

    .. attribute:: PERSISTENT_ITEMS
       :annotation: = "http://jabber.org/protocol/pubsub#persistent-items"

       Persistent items are supported.

    .. attribute:: PRESENCE_NOTIFICATIONS
       :annotation: = "http://jabber.org/protocol/pubsub#presence-notifications"

       Presence-based delivery of event notifications is supported.

    .. attribute:: PRESENCE_SUBSCRIBE
       :annotation: = "http://jabber.org/protocol/pubsub#presence-subscribe"

       Implicit presence-based subscriptions are supported.

    .. attribute:: PUBLISH
       :annotation: = "http://jabber.org/protocol/pubsub#publish"

       Publishing items is supported.

    .. attribute:: PUBLISH_OPTIONS
       :annotation: = "http://jabber.org/protocol/pubsub#publish-options"

       Publication with publish options is supported.

    .. attribute:: PUBLISH_ONLY_AFFILIATION
       :annotation: = "http://jabber.org/protocol/pubsub#publish-only-affiliation"

       The publish-only affiliation is supported.

    .. attribute:: PUBLISHER_AFFILIATION
       :annotation: = "http://jabber.org/protocol/pubsub#publisher-affiliation"

       The publisher affiliation is supported.

    .. attribute:: PURGE_NODES
       :annotation: = "http://jabber.org/protocol/pubsub#purge-nodes"

       Purging of nodes is supported.

    .. attribute:: RETRACT_ITEMS
       :annotation: = "http://jabber.org/protocol/pubsub#retract-items"

       Item retraction is supported.

    .. attribute:: RETRIEVE_AFFILIATIONS
       :annotation: = "http://jabber.org/protocol/pubsub#retrieve-affiliations"

       Retrieval of current affiliations is supported.

    .. attribute:: RETRIEVE_DEFAULT
       :annotation: = "http://jabber.org/protocol/pubsub#retrieve-default"

       Retrieval of default node configuration is supported.

    .. attribute:: RETRIEVE_ITEMS
       :annotation: = "http://jabber.org/protocol/pubsub#retrieve-items"

       Item retrieval is supported.

    .. attribute:: RETRIEVE_SUBSCRIPTIONS
       :annotation: = "http://jabber.org/protocol/pubsub#retrieve-subscriptions"

       Retrieval of current subscriptions is supported.

    .. attribute:: SUBSCRIBE
       :annotation: = "http://jabber.org/protocol/pubsub#subscribe"

       Subscribing and unsubscribing are supported.

    .. attribute:: SUBSCRIPTION_OPTIONS
       :annotation: = "http://jabber.org/protocol/pubsub#subscription-options"

       Configuration of subscription options is supported.

    .. attribute:: SUBSCRIPTION_NOTIFICATIONS
       :annotation: = "http://jabber.org/protocol/pubsub#subscription-notifications"

       Notification of subscription state changes is supported.
    """  # NOQA: E501


class NodeConfigForm(aioxmpp.forms.Form):
    """
    Declaration of the form with type
    ``http://jabber.org/protocol/pubsub#node_config``

    .. autoattribute:: access_model

    .. autoattribute:: body_xslt

    .. autoattribute:: children_association_policy

    .. autoattribute:: children_association_whitelist

    .. autoattribute:: children

    .. autoattribute:: children_max

    .. autoattribute:: collection

    .. autoattribute:: contact

    .. autoattribute:: dataform_xslt

    .. autoattribute:: deliver_notifications

    .. autoattribute:: deliver_payloads

    .. autoattribute:: description

    .. autoattribute:: item_expire

    .. autoattribute:: itemreply

    .. autoattribute:: language

    .. autoattribute:: max_items

    .. autoattribute:: max_payload_size

    .. autoattribute:: node_type

    .. autoattribute:: notification_type

    .. autoattribute:: notify_config

    .. autoattribute:: notify_delete

    .. autoattribute:: notify_retract

    .. autoattribute:: notify_sub

    .. autoattribute:: persist_items

    .. autoattribute:: presence_based_delivery

    .. autoattribute:: publish_model

    .. autoattribute:: purge_offline

    .. autoattribute:: roster_groups_allowed

    .. autoattribute:: send_last_published_item

    .. autoattribute:: tempsub

    .. autoattribute:: subscribe

    .. autoattribute:: title

    .. autoattribute:: type

    """

    FORM_TYPE = 'http://jabber.org/protocol/pubsub#node_config'

    access_model = aioxmpp.forms.ListSingle(
        var='pubsub#access_model',
        label='Who may subscribe and retrieve items'
    )

    body_xslt = aioxmpp.forms.TextSingle(
        var='pubsub#body_xslt',
        label='The URL of an XSL transformation which can be applied to '
        'payloads in order to generate an appropriate message body element.'
    )

    children_association_policy = aioxmpp.forms.ListSingle(
        var='pubsub#children_association_policy',
        label='Who may associate leaf nodes with a collection'
    )

    children_association_whitelist = aioxmpp.forms.JIDMulti(
        var='pubsub#children_association_whitelist',
        label='The list of JIDs that may associate leaf nodes with a '
        'collection'
    )

    children = aioxmpp.forms.TextMulti(
        var='pubsub#children',
        label='The child nodes (leaf or collection) associated with a '
        'collection'
    )

    children_max = aioxmpp.forms.TextSingle(
        var='pubsub#children_max',
        label='The maximum number of child nodes that can be associated with '
        'a collection'
    )

    collection = aioxmpp.forms.TextMulti(
        var='pubsub#collection',
        label='The collection(s) with which a node is affiliated'
    )

    contact = aioxmpp.forms.JIDMulti(
        var='pubsub#contact',
        label='The JIDs of those to contact with questions'
    )

    dataform_xslt = aioxmpp.forms.TextSingle(
        var='pubsub#dataform_xslt',
        label='The URL of an XSL transformation which can be applied to the '
        'payload format in order to generate a valid Data Forms result that '
        'the client could display using a generic Data Forms rendering engine'
    )

    deliver_notifications = aioxmpp.forms.Boolean(
        var='pubsub#deliver_notifications',
        label='Whether to deliver event notifications'
    )

    deliver_payloads = aioxmpp.forms.Boolean(
        var='pubsub#deliver_payloads',
        label='Whether to deliver payloads with event notifications; applies '
        'only to leaf nodes'
    )

    description = aioxmpp.forms.TextSingle(
        var='pubsub#description',
        label='A description of the node'
    )

    item_expire = aioxmpp.forms.TextSingle(
        var='pubsub#item_expire',
        label='Number of seconds after which to automatically purge items'
    )

    itemreply = aioxmpp.forms.ListSingle(
        var='pubsub#itemreply',
        label='Whether owners or publisher should receive replies to items'
    )

    language = aioxmpp.forms.ListSingle(
        var='pubsub#language',
        label='The default language of the node'
    )

    max_items = aioxmpp.forms.TextSingle(
        var='pubsub#max_items',
        label='The maximum number of items to persist'
    )

    max_payload_size = aioxmpp.forms.TextSingle(
        var='pubsub#max_payload_size',
        label='The maximum payload size in bytes'
    )

    node_type = aioxmpp.forms.ListSingle(
        var='pubsub#node_type',
        label='Whether the node is a leaf (default) or a collection'
    )

    notification_type = aioxmpp.forms.ListSingle(
        var='pubsub#notification_type',
        label='Specify the delivery style for notifications'
    )

    notify_config = aioxmpp.forms.Boolean(
        var='pubsub#notify_config',
        label='Whether to notify subscribers when the node configuration '
        'changes'
    )

    notify_delete = aioxmpp.forms.Boolean(
        var='pubsub#notify_delete',
        label='Whether to notify subscribers when the node is deleted'
    )

    notify_retract = aioxmpp.forms.Boolean(
        var='pubsub#notify_retract',
        label='Whether to notify subscribers when items are removed from the '
        'node'
    )

    notify_sub = aioxmpp.forms.Boolean(
        var='pubsub#notify_sub',
        label='Whether to notify owners about new subscribers and unsubscribes'
    )

    persist_items = aioxmpp.forms.Boolean(
        var='pubsub#persist_items',
        label='Whether to persist items to storage'
    )

    presence_based_delivery = aioxmpp.forms.Boolean(
        var='pubsub#presence_based_delivery',
        label='Whether to deliver notifications to available users only'
    )

    publish_model = aioxmpp.forms.ListSingle(
        var='pubsub#publish_model',
        label='The publisher model'
    )

    purge_offline = aioxmpp.forms.Boolean(
        var='pubsub#purge_offline',
        label='Whether to purge all items when the relevant publisher goes '
        'offline'
    )

    roster_groups_allowed = aioxmpp.forms.ListMulti(
        var='pubsub#roster_groups_allowed',
        label='The roster group(s) allowed to subscribe and retrieve items'
    )

    send_last_published_item = aioxmpp.forms.ListSingle(
        var='pubsub#send_last_published_item',
        label='When to send the last published item'
    )

    tempsub = aioxmpp.forms.Boolean(
        var='pubsub#tempsub',
        label='Whether to make all subscriptions temporary, based on '
        'subscriber presence'
    )

    subscribe = aioxmpp.forms.Boolean(
        var='pubsub#subscribe',
        label='Whether to allow subscriptions'
    )

    title = aioxmpp.forms.TextSingle(
        var='pubsub#title',
        label='A friendly name for the node'
    )

    type = aioxmpp.forms.TextSingle(
        var='pubsub#type',
        label='The type of node data, usually specified by the namespace of '
        'the payload (if any)'
    )