Rename to slixmpp

8 files changed, 1280 insertions, 0 deletions

diff --git a/slixmpp/plugins/xep_0060/__init__.py b/slixmpp/plugins/xep_0060/__init__.py
new file mode 100644
index 00000000..6c4d8428
--- /dev/null
+++ b/slixmpp/plugins/xep_0060/__init__.py
@@ -0,0 +1,19 @@
+"""
+    Slixmpp: The Slick XMPP Library
+    Copyright (C) 2011 Nathanael C. Fritz, Lance J.T. Stout
+    This file is part of Slixmpp.
+
+    See the file LICENSE for copying permission.
+"""
+
+from slixmpp.plugins.base import register_plugin
+
+from slixmpp.plugins.xep_0060.pubsub import XEP_0060
+from slixmpp.plugins.xep_0060 import stanza
+
+
+register_plugin(XEP_0060)
+
+
+# Retain some backwards compatibility
+xep_0060 = XEP_0060
diff --git a/slixmpp/plugins/xep_0060/pubsub.py b/slixmpp/plugins/xep_0060/pubsub.py
new file mode 100644
index 00000000..223b014f
--- /dev/null
+++ b/slixmpp/plugins/xep_0060/pubsub.py
@@ -0,0 +1,577 @@
+"""
+    Slixmpp: The Slick XMPP Library
+    Copyright (C) 2011  Nathanael C. Fritz
+    This file is part of Slixmpp.
+
+    See the file LICENSE for copying permission.
+"""
+
+import logging
+
+from slixmpp.xmlstream import JID
+from slixmpp.xmlstream.handler import Callback
+from slixmpp.xmlstream.matcher import StanzaPath
+from slixmpp.plugins.base import BasePlugin
+from slixmpp.plugins.xep_0060 import stanza
+
+
+log = logging.getLogger(__name__)
+
+
+class XEP_0060(BasePlugin):
+
+    """
+    XEP-0060 Publish Subscribe
+    """
+
+    name = 'xep_0060'
+    description = 'XEP-0060: Publish-Subscribe'
+    dependencies = set(['xep_0030', 'xep_0004', 'xep_0082', 'xep_0131'])
+    stanza = stanza
+
+    def plugin_init(self):
+        self.node_event_map = {}
+
+        self.xmpp.register_handler(
+                Callback('Pubsub Event: Items',
+                    StanzaPath('message/pubsub_event/items'),
+                    self._handle_event_items))
+        self.xmpp.register_handler(
+                Callback('Pubsub Event: Purge',
+                    StanzaPath('message/pubsub_event/purge'),
+                    self._handle_event_purge))
+        self.xmpp.register_handler(
+                Callback('Pubsub Event: Delete',
+                    StanzaPath('message/pubsub_event/delete'),
+                    self._handle_event_delete))
+        self.xmpp.register_handler(
+                Callback('Pubsub Event: Configuration',
+                    StanzaPath('message/pubsub_event/configuration'),
+                    self._handle_event_configuration))
+        self.xmpp.register_handler(
+                Callback('Pubsub Event: Subscription',
+                    StanzaPath('message/pubsub_event/subscription'),
+                    self._handle_event_subscription))
+
+        self.xmpp['xep_0131'].supported_headers.add('SubID')
+
+    def plugin_end(self):
+        self.xmpp.remove_handler('Pubsub Event: Items')
+        self.xmpp.remove_handler('Pubsub Event: Purge')
+        self.xmpp.remove_handler('Pubsub Event: Delete')
+        self.xmpp.remove_handler('Pubsub Event: Configuration')
+        self.xmpp.remove_handler('Pubsub Event: Subscription')
+
+    def _handle_event_items(self, msg):
+        """Raise events for publish and retraction notifications."""
+        node = msg['pubsub_event']['items']['node']
+
+        multi = len(msg['pubsub_event']['items']) > 1
+        values = {}
+        if multi:
+            values = msg.values
+            del values['pubsub_event']
+
+        for item in msg['pubsub_event']['items']:
+            event_name = self.node_event_map.get(node, None)
+            event_type = 'publish'
+            if item.name == 'retract':
+                event_type = 'retract'
+
+            if multi:
+                condensed = self.xmpp.Message()
+                condensed.values = values
+                condensed['pubsub_event']['items']['node'] = node
+                condensed['pubsub_event']['items'].append(item)
+                self.xmpp.event('pubsub_%s' % event_type, msg)
+                if event_name:
+                    self.xmpp.event('%s_%s' % (event_name, event_type),
+                                    condensed)
+            else:
+                self.xmpp.event('pubsub_%s' % event_type, msg)
+                if event_name:
+                    self.xmpp.event('%s_%s' % (event_name, event_type), msg)
+
+    def _handle_event_purge(self, msg):
+        """Raise events for node purge notifications."""
+        node = msg['pubsub_event']['purge']['node']
+        event_name = self.node_event_map.get(node, None)
+
+        self.xmpp.event('pubsub_purge', msg)
+        if event_name:
+            self.xmpp.event('%s_purge' % event_name, msg)
+
+    def _handle_event_delete(self, msg):
+        """Raise events for node deletion notifications."""
+        node = msg['pubsub_event']['delete']['node']
+        event_name = self.node_event_map.get(node, None)
+
+        self.xmpp.event('pubsub_delete', msg)
+        if event_name:
+            self.xmpp.event('%s_delete' % event_name, msg)
+
+    def _handle_event_configuration(self, msg):
+        """Raise events for node configuration notifications."""
+        node = msg['pubsub_event']['configuration']['node']
+        event_name = self.node_event_map.get(node, None)
+
+        self.xmpp.event('pubsub_config', msg)
+        if event_name:
+            self.xmpp.event('%s_config' % event_name, msg)
+
+    def _handle_event_subscription(self, msg):
+        """Raise events for node subscription notifications."""
+        node = msg['pubsub_event']['subscription']['node']
+        event_name = self.node_event_map.get(node, None)
+
+        self.xmpp.event('pubsub_subscription', msg)
+        if event_name:
+            self.xmpp.event('%s_subscription' % event_name, msg)
+
+    def map_node_event(self, 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.
+
+        Arguments:
+            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.
+        """
+        self.node_event_map[node] = event_name
+
+    def create_node(self, jid, node, config=None, ntype=None, ifrom=None,
+                    block=True, 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().
+
+        Arguments:
+            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.
+            ifrom    -- Specify the sender's JID.
+            block    -- Specify if the send call will block until a response
+                        is received, or a timeout occurs. Defaults to True.
+            timeout  -- The length of time (in seconds) to wait for a response
+                        before exiting the send call if blocking is used.
+                        Defaults to slixmpp.xmlstream.RESPONSE_TIMEOUT
+            callback -- Optional reference to a stream handler function. Will
+                        be executed when a reply stanza is received.
+        """
+        iq = self.xmpp.Iq(sto=jid, sfrom=ifrom, stype='set')
+        iq['pubsub']['create']['node'] = node
+
+        if config is not None:
+            form_type = 'http://jabber.org/protocol/pubsub#node_config'
+            if 'FORM_TYPE' in config['fields']:
+                config.field['FORM_TYPE']['value'] = form_type
+            else:
+                config.add_field(var='FORM_TYPE',
+                                 ftype='hidden',
+                                 value=form_type)
+            if ntype:
+                if 'pubsub#node_type' in config['fields']:
+                    config.field['pubsub#node_type']['value'] = ntype
+                else:
+                    config.add_field(var='pubsub#node_type', value=ntype)
+            iq['pubsub']['configure'].append(config)
+
+        return iq.send(block=block, callback=callback, timeout=timeout)
+
+    def subscribe(self, jid, node, bare=True, subscribee=None, options=None,
+                  ifrom=None, block=True, 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.
+
+        Arguments:
+            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    --
+            ifrom      -- Specify the sender's JID.
+            block      -- Specify if the send call will block until a response
+                          is received, or a timeout occurs. Defaults to True.
+            timeout    -- The length of time (in seconds) to wait for a
+                          response before exiting the send call if blocking
+                          is used.
+                          Defaults to slixmpp.xmlstream.RESPONSE_TIMEOUT
+            callback   -- Optional reference to a stream handler function. Will
+                          be executed when a reply stanza is received.
+        """
+        iq = self.xmpp.Iq(sto=jid, sfrom=ifrom, stype='set')
+        iq['pubsub']['subscribe']['node'] = node
+
+        if subscribee is None:
+            if ifrom:
+                if bare:
+                    subscribee = JID(ifrom).bare
+                else:
+                    subscribee = ifrom
+            else:
+                if bare:
+                    subscribee = self.xmpp.boundjid.bare
+                else:
+                    subscribee = self.xmpp.boundjid
+
+        iq['pubsub']['subscribe']['jid'] = subscribee
+        if options is not None:
+            iq['pubsub']['options'].append(options)
+        return iq.send(block=block, callback=callback, timeout=timeout)
+
+    def unsubscribe(self, jid, node, subid=None, bare=True, subscribee=None,
+                    ifrom=None, block=True, callback=None, timeout=None):
+        """
+        Unubscribe 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.
+
+        Arguments:
+            jid        -- The pubsub service JID.
+            node       -- The node to subscribe to.
+            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 subscribing to the node.
+            ifrom      -- Specify the sender's JID.
+            block      -- Specify if the send call will block until a response
+                          is received, or a timeout occurs. Defaults to True.
+            timeout    -- The length of time (in seconds) to wait for a
+                          response before exiting the send call if blocking
+                          is used.
+                          Defaults to slixmpp.xmlstream.RESPONSE_TIMEOUT
+            callback   -- Optional reference to a stream handler function. Will
+                          be executed when a reply stanza is received.
+        """
+        iq = self.xmpp.Iq(sto=jid, sfrom=ifrom, stype='set')
+        iq['pubsub']['unsubscribe']['node'] = node
+
+        if subscribee is None:
+            if ifrom:
+                if bare:
+                    subscribee = JID(ifrom).bare
+                else:
+                    subscribee = ifrom
+            else:
+                if bare:
+                    subscribee = self.xmpp.boundjid.bare
+                else:
+                    subscribee = self.xmpp.boundjid
+
+        iq['pubsub']['unsubscribe']['jid'] = subscribee
+        iq['pubsub']['unsubscribe']['subid'] = subid
+        return iq.send(block=block, callback=callback, timeout=timeout)
+
+    def get_subscriptions(self, jid, node=None, ifrom=None, block=True,
+                          callback=None, timeout=None):
+        iq = self.xmpp.Iq(sto=jid, sfrom=ifrom, stype='get')
+        iq['pubsub']['subscriptions']['node'] = node
+        return iq.send(block=block, callback=callback, timeout=timeout)
+
+    def get_affiliations(self, jid, node=None, ifrom=None, block=True,
+                         callback=None, timeout=None):
+        iq = self.xmpp.Iq(sto=jid, sfrom=ifrom, stype='get')
+        iq['pubsub']['affiliations']['node'] = node
+        return iq.send(block=block, callback=callback, timeout=timeout)
+
+    def get_subscription_options(self, jid, node=None, user_jid=None,
+                                 ifrom=None, block=True, callback=None,
+                                 timeout=None):
+        iq = self.xmpp.Iq(sto=jid, sfrom=ifrom, stype='get')
+        if user_jid is None:
+            iq['pubsub']['default']['node'] = node
+        else:
+            iq['pubsub']['options']['node'] = node
+            iq['pubsub']['options']['jid'] = user_jid
+        return iq.send(block=block, callback=callback, timeout=timeout)
+
+    def set_subscription_options(self, jid, node, user_jid, options,
+                                 ifrom=None, block=True, callback=None,
+                                 timeout=None):
+        iq = self.xmpp.Iq(sto=jid, sfrom=ifrom, stype='get')
+        iq['pubsub']['options']['node'] = node
+        iq['pubsub']['options']['jid'] = user_jid
+        iq['pubsub']['options'].append(options)
+        return iq.send(block=block, callback=callback, timeout=timeout)
+
+    def get_node_config(self, jid, node=None, ifrom=None, block=True,
+                        callback=None, timeout=None):
+        """
+        Retrieve the configuration for a node, or the pubsub service's
+        default configuration for new nodes.
+
+        Arguments:
+            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.
+            ifrom    -- Specify the sender's JID.
+            block    -- Specify if the send call will block until a response
+                        is received, or a timeout occurs. Defaults to True.
+            timeout  -- The length of time (in seconds) to wait for a response
+                        before exiting the send call if blocking is used.
+                        Defaults to slixmpp.xmlstream.RESPONSE_TIMEOUT
+            callback -- Optional reference to a stream handler function. Will
+                        be executed when a reply stanza is received.
+        """
+        iq = self.xmpp.Iq(sto=jid, sfrom=ifrom, stype='get')
+        if node is None:
+            iq['pubsub_owner']['default']
+        else:
+            iq['pubsub_owner']['configure']['node'] = node
+        return iq.send(block=block, callback=callback, timeout=timeout)
+
+    def get_node_subscriptions(self, jid, node, ifrom=None, block=True,
+                               callback=None, timeout=None):
+        """
+        Retrieve the subscriptions associated with a given node.
+
+        Arguments:
+            jid      -- The JID of the pubsub service.
+            node     -- The node to retrieve subscriptions from.
+            ifrom    -- Specify the sender's JID.
+            block    -- Specify if the send call will block until a response
+                        is received, or a timeout occurs. Defaults to True.
+            timeout  -- The length of time (in seconds) to wait for a response
+                        before exiting the send call if blocking is used.
+                        Defaults to slixmpp.xmlstream.RESPONSE_TIMEOUT
+            callback -- Optional reference to a stream handler function. Will
+                        be executed when a reply stanza is received.
+        """
+        iq = self.xmpp.Iq(sto=jid, sfrom=ifrom, stype='get')
+        iq['pubsub_owner']['subscriptions']['node'] = node
+        return iq.send(block=block, callback=callback, timeout=timeout)
+
+    def get_node_affiliations(self, jid, node, ifrom=None, block=True,
+                              callback=None, timeout=None):
+        """
+        Retrieve the affiliations associated with a given node.
+
+        Arguments:
+            jid      -- The JID of the pubsub service.
+            node     -- The node to retrieve affiliations from.
+            ifrom    -- Specify the sender's JID.
+            block    -- Specify if the send call will block until a response
+                        is received, or a timeout occurs. Defaults to True.
+            timeout  -- The length of time (in seconds) to wait for a response
+                        before exiting the send call if blocking is used.
+                        Defaults to slixmpp.xmlstream.RESPONSE_TIMEOUT
+            callback -- Optional reference to a stream handler function. Will
+                        be executed when a reply stanza is received.
+        """
+        iq = self.xmpp.Iq(sto=jid, sfrom=ifrom, stype='get')
+        iq['pubsub_owner']['affiliations']['node'] = node
+        return iq.send(block=block, callback=callback, timeout=timeout)
+
+    def delete_node(self, jid, node, ifrom=None, block=True,
+                    callback=None, timeout=None):
+        """
+        Delete a a pubsub node.
+
+        Arguments:
+            jid      -- The JID of the pubsub service.
+            node     -- The node to delete.
+            ifrom    -- Specify the sender's JID.
+            block    -- Specify if the send call will block until a response
+                        is received, or a timeout occurs. Defaults to True.
+            timeout  -- The length of time (in seconds) to wait for a response
+                        before exiting the send call if blocking is used.
+                        Defaults to slixmpp.xmlstream.RESPONSE_TIMEOUT
+            callback -- Optional reference to a stream handler function. Will
+                        be executed when a reply stanza is received.
+        """
+        iq = self.xmpp.Iq(sto=jid, sfrom=ifrom, stype='set')
+        iq['pubsub_owner']['delete']['node'] = node
+        return iq.send(block=block, callback=callback, timeout=timeout)
+
+    def set_node_config(self, jid, node, config, ifrom=None, block=True,
+                        callback=None, timeout=None):
+        iq = self.xmpp.Iq(sto=jid, sfrom=ifrom, stype='set')
+        iq['pubsub_owner']['configure']['node'] = node
+        iq['pubsub_owner']['configure'].append(config)
+        return iq.send(block=block, callback=callback, timeout=timeout)
+
+    def publish(self, jid, node, id=None, payload=None, options=None,
+                ifrom=None, block=True, 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.
+
+        Arguments:
+            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.
+            ifrom    -- Specify the sender's JID.
+            block    -- Specify if the send call will block until a response
+                        is received, or a timeout occurs. Defaults to True.
+            timeout  -- The length of time (in seconds) to wait for a response
+                        before exiting the send call if blocking is used.
+                        Defaults to slixmpp.xmlstream.RESPONSE_TIMEOUT
+            callback -- Optional reference to a stream handler function. Will
+                        be executed when a reply stanza is received.
+        """
+        iq = self.xmpp.Iq(sto=jid, sfrom=ifrom, stype='set')
+        iq['pubsub']['publish']['node'] = node
+        if id is not None:
+            iq['pubsub']['publish']['item']['id'] = id
+        if payload is not None:
+            iq['pubsub']['publish']['item']['payload'] = payload
+        iq['pubsub']['publish_options'] = options
+        return iq.send(block=block, callback=callback, timeout=timeout)
+
+    def retract(self, jid, node, id, notify=None, ifrom=None, block=True,
+                callback=None, timeout=None):
+        """
+        Delete a single item from a node.
+        """
+        iq = self.xmpp.Iq(sto=jid, sfrom=ifrom, stype='set')
+
+        iq['pubsub']['retract']['node'] = node
+        iq['pubsub']['retract']['notify'] = notify
+        iq['pubsub']['retract']['item']['id'] = id
+        return iq.send(block=block, callback=callback, timeout=timeout)
+
+    def purge(self, jid, node, ifrom=None, block=True, callback=None,
+              timeout=None):
+        """
+        Remove all items from a node.
+        """
+        iq = self.xmpp.Iq(sto=jid, sfrom=ifrom, stype='set')
+        iq['pubsub_owner']['purge']['node'] = node
+        return iq.send(block=block, callback=callback, timeout=timeout)
+
+    def get_nodes(self, *args, **kwargs):
+        """
+        Discover the nodes provided by a Pubsub service, using disco.
+        """
+        return self.xmpp['xep_0030'].get_items(*args, **kwargs)
+
+    def get_item(self, jid, node, item_id, ifrom=None, block=True,
+                 callback=None, timeout=None):
+        """
+        Retrieve the content of an individual item.
+        """
+        iq = self.xmpp.Iq(sto=jid, sfrom=ifrom, stype='get')
+        item = stanza.Item()
+        item['id'] = item_id
+        iq['pubsub']['items']['node'] = node
+        iq['pubsub']['items'].append(item)
+        return iq.send(block=block, callback=callback, timeout=timeout)
+
+    def get_items(self, jid, node, item_ids=None, max_items=None,
+                  iterator=False, ifrom=None, block=False,
+                  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.
+        """
+        iq = self.xmpp.Iq(sto=jid, sfrom=ifrom, stype='get')
+        iq['pubsub']['items']['node'] = node
+        iq['pubsub']['items']['max_items'] = max_items
+
+        if item_ids is not None:
+            for item_id in item_ids:
+                item = stanza.Item()
+                item['id'] = item_id
+                iq['pubsub']['items'].append(item)
+
+        if iterator:
+            return self.xmpp['xep_0059'].iterate(iq, 'pubsub')
+        else:
+            return iq.send(block=block, callback=callback, timeout=timeout)
+
+    def get_item_ids(self, jid, node, ifrom=None, block=True,
+                     callback=None, timeout=None, iterator=False):
+        """
+        Retrieve the ItemIDs hosted by a given node, using disco.
+        """
+        return self.xmpp['xep_0030'].get_items(jid, node,
+                ifrom=ifrom,
+                block=block,
+                callback=callback,
+                timeout=timeout,
+                iterator=iterator)
+
+    def modify_affiliations(self, jid, node, affiliations=None, ifrom=None,
+                            block=True, callback=None, timeout=None):
+        iq = self.xmpp.Iq(sto=jid, sfrom=ifrom, stype='set')
+        iq['pubsub_owner']['affiliations']['node'] = node
+
+        if affiliations is None:
+            affiliations = []
+
+        for jid, affiliation in affiliations:
+            aff = stanza.OwnerAffiliation()
+            aff['jid'] = jid
+            aff['affiliation'] = affiliation
+            iq['pubsub_owner']['affiliations'].append(aff)
+
+        return iq.send(block=block, callback=callback, timeout=timeout)
+
+    def modify_subscriptions(self, jid, node, subscriptions=None, ifrom=None,
+                             block=True, callback=None, timeout=None):
+        iq = self.xmpp.Iq(sto=jid, sfrom=ifrom, stype='set')
+        iq['pubsub_owner']['subscriptions']['node'] = node
+
+        if subscriptions is None:
+            subscriptions = []
+
+        for jid, subscription in subscriptions:
+            sub = stanza.OwnerSubscription()
+            sub['jid'] = jid
+            sub['subscription'] = subscription
+            iq['pubsub_owner']['subscriptions'].append(sub)
+
+        return iq.send(block=block, callback=callback, timeout=timeout)
diff --git a/slixmpp/plugins/xep_0060/stanza/__init__.py b/slixmpp/plugins/xep_0060/stanza/__init__.py
new file mode 100644
index 00000000..31c4ac68
--- /dev/null
+++ b/slixmpp/plugins/xep_0060/stanza/__init__.py
@@ -0,0 +1,12 @@
+"""
+    Slixmpp: The Slick XMPP Library
+    Copyright (C) 2011  Nathanael C. Fritz
+    This file is part of Slixmpp.
+
+    See the file LICENSE for copying permission.
+"""
+
+from slixmpp.plugins.xep_0060.stanza.pubsub import *
+from slixmpp.plugins.xep_0060.stanza.pubsub_owner import *
+from slixmpp.plugins.xep_0060.stanza.pubsub_event import *
+from slixmpp.plugins.xep_0060.stanza.pubsub_errors import *
diff --git a/slixmpp/plugins/xep_0060/stanza/base.py b/slixmpp/plugins/xep_0060/stanza/base.py
new file mode 100644
index 00000000..b8f3d6cc
--- /dev/null
+++ b/slixmpp/plugins/xep_0060/stanza/base.py
@@ -0,0 +1,29 @@
+"""
+    Slixmpp: The Slick XMPP Library
+    Copyright (C) 2011  Nathanael C. Fritz
+    This file is part of Slixmpp.
+
+    See the file LICENSE for copying permission.
+"""
+
+from slixmpp.xmlstream import ET
+
+
+class OptionalSetting(object):
+
+    interfaces = set(('required',))
+
+    def set_required(self, value):
+        if value in (True, 'true', 'True', '1'):
+            self.xml.append(ET.Element("{%s}required" % self.namespace))
+        elif self['required']:
+            self.del_required()
+
+    def get_required(self):
+        required = self.xml.find("{%s}required" % self.namespace)
+        return required is not None
+
+    def del_required(self):
+        required = self.xml.find("{%s}required" % self.namespace)
+        if required is not None:
+            self.xml.remove(required)
diff --git a/slixmpp/plugins/xep_0060/stanza/pubsub.py b/slixmpp/plugins/xep_0060/stanza/pubsub.py
new file mode 100644
index 00000000..b4293918
--- /dev/null
+++ b/slixmpp/plugins/xep_0060/stanza/pubsub.py
@@ -0,0 +1,272 @@
+"""
+    Slixmpp: The Slick XMPP Library
+    Copyright (C) 2011  Nathanael C. Fritz
+    This file is part of Slixmpp.
+
+    See the file LICENSE for copying permission.
+"""
+
+from slixmpp import Iq, Message
+from slixmpp.xmlstream import register_stanza_plugin, ElementBase, ET, JID
+from slixmpp.plugins import xep_0004
+from slixmpp.plugins.xep_0060.stanza.base import OptionalSetting
+
+
+class Pubsub(ElementBase):
+    namespace = 'http://jabber.org/protocol/pubsub'
+    name = 'pubsub'
+    plugin_attrib = name
+    interfaces = set(tuple())
+
+
+class Affiliations(ElementBase):
+    namespace = 'http://jabber.org/protocol/pubsub'
+    name = 'affiliations'
+    plugin_attrib = name
+    interfaces = set(('node',))
+
+
+class Affiliation(ElementBase):
+    namespace = 'http://jabber.org/protocol/pubsub'
+    name = 'affiliation'
+    plugin_attrib = name
+    interfaces = set(('node', 'affiliation', 'jid'))
+
+    def set_jid(self, value):
+        self._set_attr('jid', str(value))
+
+    def get_jid(self):
+        return JID(self._get_attr('jid'))
+
+
+class Subscription(ElementBase):
+    namespace = 'http://jabber.org/protocol/pubsub'
+    name = 'subscription'
+    plugin_attrib = name
+    interfaces = set(('jid', 'node', 'subscription', 'subid'))
+
+    def set_jid(self, value):
+        self._set_attr('jid', str(value))
+
+    def get_jid(self):
+        return JID(self._get_attr('jid'))
+
+
+class Subscriptions(ElementBase):
+    namespace = 'http://jabber.org/protocol/pubsub'
+    name = 'subscriptions'
+    plugin_attrib = name
+    interfaces = set(('node',))
+
+
+class SubscribeOptions(ElementBase, OptionalSetting):
+    namespace = 'http://jabber.org/protocol/pubsub'
+    name = 'subscribe-options'
+    plugin_attrib = 'suboptions'
+    interfaces = set(('required',))
+
+
+class Item(ElementBase):
+    namespace = 'http://jabber.org/protocol/pubsub'
+    name = 'item'
+    plugin_attrib = name
+    interfaces = set(('id', 'payload'))
+
+    def set_payload(self, value):
+        del self['payload']
+        if isinstance(value, ElementBase):
+            if value.tag_name() in self.plugin_tag_map:
+                self.init_plugin(value.plugin_attrib, existing_xml=value.xml)
+            self.xml.append(value.xml)
+        else:
+            self.xml.append(value)
+
+    def get_payload(self):
+        childs = list(self.xml)
+        if len(childs) > 0:
+            return childs[0]
+
+    def del_payload(self):
+        for child in self.xml:
+            self.xml.remove(child)
+
+
+class Items(ElementBase):
+    namespace = 'http://jabber.org/protocol/pubsub'
+    name = 'items'
+    plugin_attrib = name
+    interfaces = set(('node', 'max_items'))
+
+    def set_max_items(self, value):
+        self._set_attr('max_items', str(value))
+
+
+class Create(ElementBase):
+    namespace = 'http://jabber.org/protocol/pubsub'
+    name = 'create'
+    plugin_attrib = name
+    interfaces = set(('node',))
+
+
+class Default(ElementBase):
+    namespace = 'http://jabber.org/protocol/pubsub'
+    name = 'default'
+    plugin_attrib = name
+    interfaces = set(('node', 'type'))
+
+    def get_type(self):
+        t = self._get_attr('type')
+        if not t:
+            return 'leaf'
+        return t
+
+
+class Publish(ElementBase):
+    namespace = 'http://jabber.org/protocol/pubsub'
+    name = 'publish'
+    plugin_attrib = name
+    interfaces = set(('node',))
+
+
+class Retract(ElementBase):
+    namespace = 'http://jabber.org/protocol/pubsub'
+    name = 'retract'
+    plugin_attrib = name
+    interfaces = set(('node', 'notify'))
+
+    def get_notify(self):
+        notify = self._get_attr('notify')
+        if notify in ('0', 'false'):
+            return False
+        elif notify in ('1', 'true'):
+            return True
+        return None
+
+    def set_notify(self, value):
+        del self['notify']
+        if value is None:
+            return
+        elif value in (True, '1', 'true', 'True'):
+            self._set_attr('notify', 'true')
+        else:
+            self._set_attr('notify', 'false')
+
+
+class Unsubscribe(ElementBase):
+    namespace = 'http://jabber.org/protocol/pubsub'
+    name = 'unsubscribe'
+    plugin_attrib = name
+    interfaces = set(('node', 'jid', 'subid'))
+
+    def set_jid(self, value):
+        self._set_attr('jid', str(value))
+
+    def get_jid(self):
+        return JID(self._get_attr('jid'))
+
+
+class Subscribe(ElementBase):
+    namespace = 'http://jabber.org/protocol/pubsub'
+    name = 'subscribe'
+    plugin_attrib = name
+    interfaces = set(('node', 'jid'))
+
+    def set_jid(self, value):
+        self._set_attr('jid', str(value))
+
+    def get_jid(self):
+        return JID(self._get_attr('jid'))
+
+
+class Configure(ElementBase):
+    namespace = 'http://jabber.org/protocol/pubsub'
+    name = 'configure'
+    plugin_attrib = name
+    interfaces = set(('node', 'type'))
+
+    def getType(self):
+        t = self._get_attr('type')
+        if not t:
+            t == 'leaf'
+        return t
+
+
+class Options(ElementBase):
+    namespace = 'http://jabber.org/protocol/pubsub'
+    name = 'options'
+    plugin_attrib = name
+    interfaces = set(('jid', 'node', 'options'))
+
+    def __init__(self, *args, **kwargs):
+        ElementBase.__init__(self, *args, **kwargs)
+
+    def get_options(self):
+        config = self.xml.find('{jabber:x:data}x')
+        form = xep_0004.Form(xml=config)
+        return form
+
+    def set_options(self, value):
+        self.xml.append(value.getXML())
+        return self
+
+    def del_options(self):
+        config = self.xml.find('{jabber:x:data}x')
+        self.xml.remove(config)
+
+    def set_jid(self, value):
+        self._set_attr('jid', str(value))
+
+    def get_jid(self):
+        return JID(self._get_attr('jid'))
+
+
+class PublishOptions(ElementBase):
+    namespace = 'http://jabber.org/protocol/pubsub'
+    name = 'publish-options'
+    plugin_attrib = 'publish_options'
+    interfaces = set(('publish_options',))
+    is_extension = True
+
+    def get_publish_options(self):
+        config = self.xml.find('{jabber:x:data}x')
+        if config is None:
+            return None
+        form = xep_0004.Form(xml=config)
+        return form
+
+    def set_publish_options(self, value):
+        if value is None:
+            self.del_publish_options()
+        else:
+            self.xml.append(value.getXML())
+        return self
+
+    def del_publish_options(self):
+        config = self.xml.find('{jabber:x:data}x')
+        if config is not None:
+            self.xml.remove(config)
+        self.parent().xml.remove(self.xml)
+
+
+register_stanza_plugin(Iq, Pubsub)
+register_stanza_plugin(Pubsub, Affiliations)
+register_stanza_plugin(Pubsub, Configure)
+register_stanza_plugin(Pubsub, Create)
+register_stanza_plugin(Pubsub, Default)
+register_stanza_plugin(Pubsub, Items)
+register_stanza_plugin(Pubsub, Options)
+register_stanza_plugin(Pubsub, Publish)
+register_stanza_plugin(Pubsub, PublishOptions)
+register_stanza_plugin(Pubsub, Retract)
+register_stanza_plugin(Pubsub, Subscribe)
+register_stanza_plugin(Pubsub, Subscription)
+register_stanza_plugin(Pubsub, Subscriptions)
+register_stanza_plugin(Pubsub, Unsubscribe)
+register_stanza_plugin(Affiliations, Affiliation, iterable=True)
+register_stanza_plugin(Configure, xep_0004.Form)
+register_stanza_plugin(Items, Item, iterable=True)
+register_stanza_plugin(Publish, Item, iterable=True)
+register_stanza_plugin(Retract, Item)
+register_stanza_plugin(Subscribe, Options)
+register_stanza_plugin(Subscription, SubscribeOptions)
+register_stanza_plugin(Subscriptions, Subscription, iterable=True)
diff --git a/slixmpp/plugins/xep_0060/stanza/pubsub_errors.py b/slixmpp/plugins/xep_0060/stanza/pubsub_errors.py
new file mode 100644
index 00000000..3e728009
--- /dev/null
+++ b/slixmpp/plugins/xep_0060/stanza/pubsub_errors.py
@@ -0,0 +1,86 @@
+"""
+    Slixmpp: The Slick XMPP Library
+    Copyright (C) 2011  Nathanael C. Fritz
+    This file is part of Slixmpp.
+
+    See the file LICENSE for copying permission.
+"""
+
+from slixmpp.stanza import Error
+from slixmpp.xmlstream import ElementBase, ET, register_stanza_plugin
+
+
+class PubsubErrorCondition(ElementBase):
+
+    plugin_attrib = 'pubsub'
+    interfaces = set(('condition', 'unsupported'))
+    plugin_attrib_map = {}
+    plugin_tag_map = {}
+    conditions = set(('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-too-big',
+                      'payload-required', 'pending-subscription',
+                      'presence-subscription-required', 'subid-required',
+                      'too-many-subscriptions', 'unsupported'))
+    condition_ns = 'http://jabber.org/protocol/pubsub#errors'
+
+    def setup(self, xml):
+        """Don't create XML for the plugin."""
+        self.xml = ET.Element('')
+
+    def get_condition(self):
+        """Return the condition element's name."""
+        for child in self.parent().xml:
+            if "{%s}" % self.condition_ns in child.tag:
+                cond = child.tag.split('}', 1)[-1]
+                if cond in self.conditions:
+                    return cond
+        return ''
+
+    def set_condition(self, value):
+        """
+        Set the tag name of the condition element.
+
+        Arguments:
+           value -- The tag name of the condition element.
+        """
+        if value in self.conditions:
+            del self['condition']
+            cond = ET.Element("{%s}%s" % (self.condition_ns, value))
+            self.parent().xml.append(cond)
+        return self
+
+    def del_condition(self):
+        """Remove the condition element."""
+        for child in self.parent().xml:
+            if "{%s}" % self.condition_ns in child.tag:
+                tag = child.tag.split('}', 1)[-1]
+                if tag in self.conditions:
+                    self.parent().xml.remove(child)
+        return self
+
+    def get_unsupported(self):
+        """Return the name of an unsupported feature"""
+        xml = self.parent().xml.find('{%s}unsupported' % self.condition_ns)
+        if xml is not None:
+            return xml.attrib.get('feature', '')
+        return ''
+
+    def set_unsupported(self, value):
+        """Mark a feature as unsupported"""
+        self.del_unsupported()
+        xml = ET.Element('{%s}unsupported' % self.condition_ns)
+        xml.attrib['feature'] = value
+        self.parent().xml.append(xml)
+
+    def del_unsupported(self):
+        """Delete an unsupported feature condition."""
+        xml = self.parent().xml.find('{%s}unsupported' % self.condition_ns)
+        if xml is not None:
+            self.parent().xml.remove(xml)
+
+
+register_stanza_plugin(Error, PubsubErrorCondition)
diff --git a/slixmpp/plugins/xep_0060/stanza/pubsub_event.py b/slixmpp/plugins/xep_0060/stanza/pubsub_event.py
new file mode 100644
index 00000000..1ba97c75
--- /dev/null
+++ b/slixmpp/plugins/xep_0060/stanza/pubsub_event.py
@@ -0,0 +1,151 @@
+"""
+    Slixmpp: The Slick XMPP Library
+    Copyright (C) 2011  Nathanael C. Fritz
+    This file is part of Slixmpp.
+
+    See the file LICENSE for copying permission.
+"""
+
+import datetime as dt
+
+from slixmpp import Message
+from slixmpp.xmlstream import register_stanza_plugin, ElementBase, ET, JID
+from slixmpp.plugins.xep_0004 import Form
+from slixmpp.plugins import xep_0082
+
+
+class Event(ElementBase):
+    namespace = 'http://jabber.org/protocol/pubsub#event'
+    name = 'event'
+    plugin_attrib = 'pubsub_event'
+    interfaces = set()
+
+
+class EventItem(ElementBase):
+    namespace = 'http://jabber.org/protocol/pubsub#event'
+    name = 'item'
+    plugin_attrib = name
+    interfaces = set(('id', 'payload', 'node', 'publisher'))
+
+    def set_payload(self, value):
+        self.xml.append(value)
+
+    def get_payload(self):
+        childs = list(self.xml)
+        if len(childs) > 0:
+            return childs[0]
+
+    def del_payload(self):
+        for child in self.xml:
+            self.xml.remove(child)
+
+
+class EventRetract(ElementBase):
+    namespace = 'http://jabber.org/protocol/pubsub#event'
+    name = 'retract'
+    plugin_attrib = name
+    interfaces = set(('id',))
+
+
+class EventItems(ElementBase):
+    namespace = 'http://jabber.org/protocol/pubsub#event'
+    name = 'items'
+    plugin_attrib = name
+    interfaces = set(('node',))
+
+
+class EventCollection(ElementBase):
+    namespace = 'http://jabber.org/protocol/pubsub#event'
+    name = 'collection'
+    plugin_attrib = name
+    interfaces = set(('node',))
+
+
+class EventAssociate(ElementBase):
+    namespace = 'http://jabber.org/protocol/pubsub#event'
+    name = 'associate'
+    plugin_attrib = name
+    interfaces = set(('node',))
+
+
+class EventDisassociate(ElementBase):
+    namespace = 'http://jabber.org/protocol/pubsub#event'
+    name = 'disassociate'
+    plugin_attrib = name
+    interfaces = set(('node',))
+
+
+class EventConfiguration(ElementBase):
+    namespace = 'http://jabber.org/protocol/pubsub#event'
+    name = 'configuration'
+    plugin_attrib = name
+    interfaces = set(('node',))
+
+
+class EventPurge(ElementBase):
+    namespace = 'http://jabber.org/protocol/pubsub#event'
+    name = 'purge'
+    plugin_attrib = name
+    interfaces = set(('node',))
+
+
+class EventDelete(ElementBase):
+    namespace = 'http://jabber.org/protocol/pubsub#event'
+    name = 'delete'
+    plugin_attrib = name
+    interfaces = set(('node', 'redirect'))
+
+    def set_redirect(self, uri):
+        del self['redirect']
+        redirect = ET.Element('{%s}redirect' % self.namespace)
+        redirect.attrib['uri'] = uri
+        self.xml.append(redirect)
+
+    def get_redirect(self):
+        redirect = self.xml.find('{%s}redirect' % self.namespace)
+        if redirect is not None:
+            return redirect.attrib.get('uri', '')
+        return ''
+
+    def del_redirect(self):
+        redirect = self.xml.find('{%s}redirect' % self.namespace)
+        if redirect is not None:
+            self.xml.remove(redirect)
+
+
+class EventSubscription(ElementBase):
+    namespace = 'http://jabber.org/protocol/pubsub#event'
+    name = 'subscription'
+    plugin_attrib = name
+    interfaces = set(('node', 'expiry', 'jid', 'subid', 'subscription'))
+
+    def get_expiry(self):
+        expiry = self._get_attr('expiry')
+        if expiry.lower() == 'presence':
+            return expiry
+        return xep_0082.parse(expiry)
+
+    def set_expiry(self, value):
+        if isinstance(value, dt.datetime):
+            value = xep_0082.format_datetime(value)
+        self._set_attr('expiry', value)
+
+    def set_jid(self, value):
+        self._set_attr('jid', str(value))
+
+    def get_jid(self):
+        return JID(self._get_attr('jid'))
+
+
+register_stanza_plugin(Message, Event)
+register_stanza_plugin(Event, EventCollection)
+register_stanza_plugin(Event, EventConfiguration)
+register_stanza_plugin(Event, EventPurge)
+register_stanza_plugin(Event, EventDelete)
+register_stanza_plugin(Event, EventItems)
+register_stanza_plugin(Event, EventSubscription)
+register_stanza_plugin(EventCollection, EventAssociate)
+register_stanza_plugin(EventCollection, EventDisassociate)
+register_stanza_plugin(EventConfiguration, Form)
+register_stanza_plugin(EventItems, EventItem, iterable=True)
+register_stanza_plugin(EventItems, EventRetract, iterable=True)
diff --git a/slixmpp/plugins/xep_0060/stanza/pubsub_owner.py b/slixmpp/plugins/xep_0060/stanza/pubsub_owner.py
new file mode 100644
index 00000000..402e5e30
--- /dev/null
+++ b/slixmpp/plugins/xep_0060/stanza/pubsub_owner.py
@@ -0,0 +1,134 @@
+"""
+    Slixmpp: The Slick XMPP Library
+    Copyright (C) 2011  Nathanael C. Fritz
+    This file is part of Slixmpp.
+
+    See the file LICENSE for copying permission.
+"""
+
+from slixmpp import Iq
+from slixmpp.xmlstream import register_stanza_plugin, ElementBase, ET, JID
+from slixmpp.plugins.xep_0004 import Form
+from slixmpp.plugins.xep_0060.stanza.base import OptionalSetting
+from slixmpp.plugins.xep_0060.stanza.pubsub import Affiliations, Affiliation
+from slixmpp.plugins.xep_0060.stanza.pubsub import Configure, Subscriptions
+
+
+class PubsubOwner(ElementBase):
+    namespace = 'http://jabber.org/protocol/pubsub#owner'
+    name = 'pubsub'
+    plugin_attrib = 'pubsub_owner'
+    interfaces = set(tuple())
+
+
+class DefaultConfig(ElementBase):
+    namespace = 'http://jabber.org/protocol/pubsub#owner'
+    name = 'default'
+    plugin_attrib = name
+    interfaces = set(('node', 'config'))
+
+    def __init__(self, *args, **kwargs):
+        ElementBase.__init__(self, *args, **kwargs)
+
+    def get_config(self):
+        return self['form']
+
+    def set_config(self, value):
+        del self['from']
+        self.append(value)
+        return self
+
+
+class OwnerAffiliations(Affiliations):
+    namespace = 'http://jabber.org/protocol/pubsub#owner'
+    interfaces = set(('node',))
+
+    def append(self, affiliation):
+        if not isinstance(affiliation, OwnerAffiliation):
+            raise TypeError
+        self.xml.append(affiliation.xml)
+
+
+class OwnerAffiliation(Affiliation):
+    namespace = 'http://jabber.org/protocol/pubsub#owner'
+    interfaces = set(('affiliation', 'jid'))
+
+
+class OwnerConfigure(Configure):
+    namespace = 'http://jabber.org/protocol/pubsub#owner'
+    name = 'configure'
+    plugin_attrib = name
+    interfaces = set(('node',))
+
+
+class OwnerDefault(OwnerConfigure):
+    namespace = 'http://jabber.org/protocol/pubsub#owner'
+    interfaces = set(('node',))
+
+
+class OwnerDelete(ElementBase, OptionalSetting):
+    namespace = 'http://jabber.org/protocol/pubsub#owner'
+    name = 'delete'
+    plugin_attrib = name
+    interfaces = set(('node',))
+
+
+class OwnerPurge(ElementBase, OptionalSetting):
+    namespace = 'http://jabber.org/protocol/pubsub#owner'
+    name = 'purge'
+    plugin_attrib = name
+    interfaces = set(('node',))
+
+
+class OwnerRedirect(ElementBase):
+    namespace = 'http://jabber.org/protocol/pubsub#owner'
+    name = 'redirect'
+    plugin_attrib = name
+    interfaces = set(('node', 'jid'))
+
+    def set_jid(self, value):
+        self._set_attr('jid', str(value))
+
+    def get_jid(self):
+        return JID(self._get_attr('jid'))
+
+
+class OwnerSubscriptions(Subscriptions):
+    name = 'subscriptions'
+    namespace = 'http://jabber.org/protocol/pubsub#owner'
+    plugin_attrib = name
+    interfaces = set(('node',))
+
+    def append(self, subscription):
+        if not isinstance(subscription, OwnerSubscription):
+            raise TypeError
+        self.xml.append(subscription.xml)
+
+
+class OwnerSubscription(ElementBase):
+    namespace = 'http://jabber.org/protocol/pubsub#owner'
+    name = 'subscription'
+    plugin_attrib = name
+    interfaces = set(('jid', 'subscription'))
+
+    def set_jid(self, value):
+        self._set_attr('jid', str(value))
+
+    def get_jid(self):
+        return JID(self._get_attr('jid'))
+
+
+register_stanza_plugin(Iq, PubsubOwner)
+register_stanza_plugin(PubsubOwner, DefaultConfig)
+register_stanza_plugin(PubsubOwner, OwnerAffiliations)
+register_stanza_plugin(PubsubOwner, OwnerConfigure)
+register_stanza_plugin(PubsubOwner, OwnerDefault)
+register_stanza_plugin(PubsubOwner, OwnerDelete)
+register_stanza_plugin(PubsubOwner, OwnerPurge)
+register_stanza_plugin(PubsubOwner, OwnerSubscriptions)
+register_stanza_plugin(DefaultConfig, Form)
+register_stanza_plugin(OwnerAffiliations, OwnerAffiliation, iterable=True)
+register_stanza_plugin(OwnerConfigure, Form)
+register_stanza_plugin(OwnerDefault, Form)
+register_stanza_plugin(OwnerDelete, OwnerRedirect)
+register_stanza_plugin(OwnerSubscriptions, OwnerSubscription, iterable=True)