Bump version to 1.1.4

A log message is shown for those who try to set it to True.

Fixes issue #171

.gitignore

@@ -6,3 +6,4 @@ docs/_build/
 *.swp
 .tox/
 .coverage
+sleekxmpp.egg-info/

LICENSE

@@ -138,3 +138,32 @@ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 THE SOFTWARE.
+
+
+python-gnupg: A Python wrapper for the GNU Privacy Guard
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Copyright (c) 2008-2012 by Vinay Sajip.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright notice,
+      this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright notice,
+      this list of conditions and the following disclaimer in the documentation
+      and/or other materials provided with the distribution.
+    * The name(s) of the copyright holder(s) may not be used to endorse or
+      promote products derived from this software without specific prior
+      written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) "AS IS" AND ANY EXPRESS OR
+IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
+EVENT SHALL THE COPYRIGHT HOLDER(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
+INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

README.rst

@@ -45,21 +45,13 @@ The latest source code for SleekXMPP may be found on `Github
 ``develop`` branch.
 
 **Latest Release**
-    - `1.0 <http://github.com/fritzy/SleekXMPP/zipball/1.0>`_
+    - `1.1.4 <http://github.com/fritzy/SleekXMPP/zipball/1.1.4>`_
 
 **Develop Releases**
     - `Latest Develop Version <http://github.com/fritzy/SleekXMPP/zipball/develop>`_
 
 **Older Stable Releases**
-    - `1.0 RC3 <http://github.com/fritzy/SleekXMPP/zipball/1.0-RC3>`_  
-    - `1.0 RC2 <http://github.com/fritzy/SleekXMPP/zipball/1.0-RC2>`_  
-    - `1.0 RC1 <http://github.com/fritzy/SleekXMPP/zipball/1.0-RC1>`_  
-    - `1.0 Beta6.1 <http://github.com/fritzy/SleekXMPP/zipball/1.0-Beta6.1>`_  
-    - `1.0 Beta5 <http://github.com/fritzy/SleekXMPP/zipball/1.0-Beta5>`_
-    - `1.0 Beta4 <http://github.com/fritzy/SleekXMPP/zipball/1.0-Beta4>`_
-    - `1.0 Beta3 <http://github.com/fritzy/SleekXMPP/zipball/1.0-Beta3>`_
-    - `1.0 Beta2 <http://github.com/fritzy/SleekXMPP/zipball/1.0-Beta2>`_
-    - `1.0 Beta1 <http://github.com/fritzy/SleekXMPP/zipball/1.0-Beta1>`_
+    - `1.0 <http://github.com/fritzy/SleekXMPP/zipball/1.0>`_
 
 Installing DNSPython
 ---------------------
@@ -118,8 +110,12 @@ SleekXMPP projects::
             self.add_event_handler("session_start", self.session_start)
             self.add_event_handler("message", self.message)
 
-            self.register_plugin('xep_0030') # Service Discovery
-            self.register_plugin('xep_0199') # XMPP Ping
+            # If you wanted more functionality, here's how to register plugins:
+            # self.register_plugin('xep_0030') # Service Discovery
+            # self.register_plugin('xep_0199') # XMPP Ping
+
+            # Here's how to access plugins once you've registered them:
+            # self['xep_0030'].add_feature('echo_demo')
 
             # If you are working with an OpenFire server, you will
             # need to use a different SSL version:
@@ -128,18 +124,20 @@ SleekXMPP projects::
 
         def session_start(self, event):
             self.send_presence()
+            self.get_roster()
 
             # Most get_*/set_* methods from plugins use Iq stanzas, which
             # can generate IqError and IqTimeout exceptions
-            try:
-                self.get_roster()
-            except IqError as err:
-                logging.error('There was an error getting the roster')
-                logging.error(err.iq['error']['condition'])
-                self.disconnect()
-            except IqTimeout:
-                logging.error('Server is taking too long to respond')
-                self.disconnect()
+            #
+            # try:
+            #     self.get_roster()
+            # except IqError as err:
+            #     logging.error('There was an error getting the roster')
+            #     logging.error(err.iq['error']['condition'])
+            #     self.disconnect()
+            # except IqTimeout:
+            #     logging.error('Server is taking too long to respond')
+            #     self.disconnect()
 
         def message(self, msg):
             if msg['type'] in ('chat', 'normal'):

conn_tests/test_pubsubjobs.py

@@ -1,171 +0,0 @@
-import logging
-import sleekxmpp
-from optparse import OptionParser
-from xml.etree import cElementTree as ET
-import os
-import time
-import sys
-import unittest
-import sleekxmpp.plugins.xep_0004
-from sleekxmpp.xmlstream.matcher.stanzapath import StanzaPath
-from sleekxmpp.xmlstream.handler.waiter import Waiter
-try:
-	import configparser
-except ImportError:
-	import ConfigParser as configparser
-try:
-	import queue
-except ImportError:
-	import Queue as queue
-
-class TestClient(sleekxmpp.ClientXMPP):
-	def __init__(self, jid, password):
-		sleekxmpp.ClientXMPP.__init__(self, jid, password)
-		self.add_event_handler("session_start", self.start)
-		#self.add_event_handler("message", self.message)
-		self.waitforstart = queue.Queue()
-	
-	def start(self, event):
-		self.getRoster()
-		self.sendPresence()
-		self.waitforstart.put(True)
-
-
-class TestPubsubServer(unittest.TestCase):
-	statev = {}
-
-	def __init__(self, *args, **kwargs):
-		unittest.TestCase.__init__(self, *args, **kwargs)
-
-	def setUp(self):
-		pass
-
-	def test001getdefaultconfig(self):
-		"""Get the default node config"""
-		self.xmpp1['xep_0060'].deleteNode(self.pshost, 'testnode2')
-		self.xmpp1['xep_0060'].deleteNode(self.pshost, 'testnode3')
-		self.xmpp1['xep_0060'].deleteNode(self.pshost, 'testnode4')
-		self.xmpp1['xep_0060'].deleteNode(self.pshost, 'testnode5')
-		result = self.xmpp1['xep_0060'].getNodeConfig(self.pshost)
-		self.statev['defaultconfig'] = result
-		self.failUnless(isinstance(result, sleekxmpp.plugins.xep_0004.Form))
-	
-	def test002createdefaultnode(self):
-		"""Create a node without config"""
-		self.failUnless(self.xmpp1['xep_0060'].create_node(self.pshost, 'testnode1'))
-
-	def test003deletenode(self):
-		"""Delete recently created node"""
-		self.failUnless(self.xmpp1['xep_0060'].deleteNode(self.pshost, 'testnode1'))
-	
-	def test004createnode(self):
-		"""Create a node with a config"""
-		self.statev['defaultconfig'].field['pubsub#access_model'].setValue('open')
-		self.statev['defaultconfig'].field['pubsub#notify_retract'].setValue(True)
-		self.statev['defaultconfig'].field['pubsub#persist_items'].setValue(True)
-		self.statev['defaultconfig'].field['pubsub#presence_based_delivery'].setValue(True)
-		p = self.xmpp2.Presence()
-		p['to'] = self.pshost
-		p.send()
-		self.failUnless(self.xmpp1['xep_0060'].create_node(self.pshost, 'testnode2', self.statev['defaultconfig'], ntype='job'))
-	
-	def test005reconfigure(self):
-		"""Retrieving node config and reconfiguring"""
-		nconfig = self.xmpp1['xep_0060'].getNodeConfig(self.pshost, 'testnode2')
-		self.failUnless(nconfig, "No configuration returned")
-		#print("\n%s ==\n %s" % (nconfig.getValues(), self.statev['defaultconfig'].getValues()))
-		self.failUnless(nconfig.getValues() == self.statev['defaultconfig'].getValues(), "Configuration does not match")
-		self.failUnless(self.xmpp1['xep_0060'].setNodeConfig(self.pshost, 'testnode2', nconfig))
-
-	def test006subscribetonode(self):
-		"""Subscribe to node from account 2"""
-		self.failUnless(self.xmpp2['xep_0060'].subscribe(self.pshost, "testnode2"))
-	
-	def test007publishitem(self):
-		"""Publishing item"""
-		item = ET.Element('{http://netflint.net/protocol/test}test')
-		w = Waiter('wait publish', StanzaPath('message/pubsub_event/items'))
-		self.xmpp2.registerHandler(w)
-		#result = self.xmpp1['xep_0060'].setItem(self.pshost, "testnode2", (('test1', item),))
-		result = self.xmpp1['jobs'].createJob(self.pshost, "testnode2", 'test1', item)
-		msg = w.wait(5) # got to get a result in 5 seconds
-		self.failUnless(msg != False, "Account #2 did not get message event")
-		#result = self.xmpp1['xep_0060'].setItem(self.pshost, "testnode2", (('test2', item),))
-		result = self.xmpp1['jobs'].createJob(self.pshost, "testnode2", 'test2', item)
-		w = Waiter('wait publish2', StanzaPath('message/pubsub_event/items'))
-		self.xmpp2.registerHandler(w)
-		self.xmpp2['jobs'].claimJob(self.pshost, 'testnode2', 'test1')
-		msg = w.wait(5) # got to get a result in 5 seconds
-		self.xmpp2['jobs'].claimJob(self.pshost, 'testnode2', 'test2')
-		self.xmpp2['jobs'].finishJob(self.pshost, 'testnode2', 'test1')
-		self.xmpp2['jobs'].finishJob(self.pshost, 'testnode2', 'test2')
-		print result
-		#need to add check for update
-
-	def test900cleanup(self):
-		"Cleaning up"
-		#self.failUnless(self.xmpp1['xep_0060'].deleteNode(self.pshost, 'testnode2'), "Could not delete test node.")
-		time.sleep(10)
-	
-
-if __name__ == '__main__':
-	#parse command line arguements
-	optp = OptionParser()
-	optp.add_option('-q','--quiet', help='set logging to ERROR', action='store_const', dest='loglevel', const=logging.ERROR, default=logging.INFO)
-	optp.add_option('-d','--debug', help='set logging to DEBUG', action='store_const', dest='loglevel', const=logging.DEBUG, default=logging.INFO)
-	optp.add_option('-v','--verbose', help='set logging to COMM', action='store_const', dest='loglevel', const=5, default=logging.INFO)
-	optp.add_option("-c","--config", dest="configfile", default="config.xml", help="set config file to use")
-	optp.add_option("-n","--nodenum", dest="nodenum", default="1", help="set node number to use")
-	optp.add_option("-p","--pubsub", dest="pubsub", default="1", help="set pubsub host to use")
-	opts,args = optp.parse_args()
-	
-	logging.basicConfig(level=opts.loglevel, format='%(levelname)-8s %(message)s')
-
-	#load xml config
-	logging.info("Loading config file: %s" , opts.configfile)
-	config = configparser.RawConfigParser()
-	config.read(opts.configfile)
-	
-	#init
-	logging.info("Account 1 is %s" , config.get('account1', 'jid'))
-	xmpp1 = TestClient(config.get('account1','jid'), config.get('account1','pass'))
-	logging.info("Account 2 is %s" , config.get('account2', 'jid'))
-	xmpp2 = TestClient(config.get('account2','jid'), config.get('account2','pass'))
-	
-	xmpp1.registerPlugin('xep_0004')
-	xmpp1.registerPlugin('xep_0030')
-	xmpp1.registerPlugin('xep_0060')
-	xmpp1.registerPlugin('xep_0199')
-	xmpp1.registerPlugin('jobs')
-	xmpp2.registerPlugin('xep_0004')
-	xmpp2.registerPlugin('xep_0030')
-	xmpp2.registerPlugin('xep_0060')
-	xmpp2.registerPlugin('xep_0199')
-	xmpp2.registerPlugin('jobs')
-
-	if not config.get('account1', 'server'):
-		# we don't know the server, but the lib can probably figure it out
-		xmpp1.connect() 
-	else:
-		xmpp1.connect((config.get('account1', 'server'), 5222))
-	xmpp1.process(threaded=True)
-	
-	#init
-	if not config.get('account2', 'server'):
-		# we don't know the server, but the lib can probably figure it out
-		xmpp2.connect() 
-	else:
-		xmpp2.connect((config.get('account2', 'server'), 5222))
-	xmpp2.process(threaded=True)
-
-	TestPubsubServer.xmpp1 = xmpp1
-	TestPubsubServer.xmpp2 = xmpp2
-	TestPubsubServer.pshost = config.get('settings', 'pubsub')
-	xmpp1.waitforstart.get(True)
-	xmpp2.waitforstart.get(True)
-	testsuite = unittest.TestLoader().loadTestsFromTestCase(TestPubsubServer)
-
-	alltests_suite = unittest.TestSuite([testsuite])
-	result = unittest.TextTestRunner(verbosity=2).run(alltests_suite)
-	xmpp1.disconnect()
-	xmpp2.disconnect()

conn_tests/test_pubsubserver.py

@@ -1,233 +0,0 @@
-import logging
-import sleekxmpp
-from optparse import OptionParser
-from xml.etree import cElementTree as ET
-import os
-import time
-import sys
-import unittest
-import sleekxmpp.plugins.xep_0004
-from sleekxmpp.xmlstream.matcher.stanzapath import StanzaPath
-from sleekxmpp.xmlstream.handler.waiter import Waiter
-try:
-	import configparser
-except ImportError:
-	import ConfigParser as configparser
-try:
-	import queue
-except ImportError:
-	import Queue as queue
-
-class TestClient(sleekxmpp.ClientXMPP):
-	def __init__(self, jid, password):
-		sleekxmpp.ClientXMPP.__init__(self, jid, password)
-		self.add_event_handler("session_start", self.start)
-		#self.add_event_handler("message", self.message)
-		self.waitforstart = queue.Queue()
-	
-	def start(self, event):
-		self.getRoster()
-		self.sendPresence()
-		self.waitforstart.put(True)
-
-
-class TestPubsubServer(unittest.TestCase):
-	statev = {}
-
-	def __init__(self, *args, **kwargs):
-		unittest.TestCase.__init__(self, *args, **kwargs)
-
-	def setUp(self):
-		pass
-
-	def test001getdefaultconfig(self):
-		"""Get the default node config"""
-		self.xmpp1['xep_0060'].deleteNode(self.pshost, 'testnode2')
-		self.xmpp1['xep_0060'].deleteNode(self.pshost, 'testnode3')
-		self.xmpp1['xep_0060'].deleteNode(self.pshost, 'testnode4')
-		self.xmpp1['xep_0060'].deleteNode(self.pshost, 'testnode5')
-		result = self.xmpp1['xep_0060'].getNodeConfig(self.pshost)
-		self.statev['defaultconfig'] = result
-		self.failUnless(isinstance(result, sleekxmpp.plugins.xep_0004.Form))
-	
-	def test002createdefaultnode(self):
-		"""Create a node without config"""
-		self.failUnless(self.xmpp1['xep_0060'].create_node(self.pshost, 'testnode1'))
-
-	def test003deletenode(self):
-		"""Delete recently created node"""
-		self.failUnless(self.xmpp1['xep_0060'].deleteNode(self.pshost, 'testnode1'))
-	
-	def test004createnode(self):
-		"""Create a node with a config"""
-		self.statev['defaultconfig'].field['pubsub#access_model'].setValue('open')
-		self.statev['defaultconfig'].field['pubsub#notify_retract'].setValue(True)
-		self.failUnless(self.xmpp1['xep_0060'].create_node(self.pshost, 'testnode2', self.statev['defaultconfig']))
-	
-	def test005reconfigure(self):
-		"""Retrieving node config and reconfiguring"""
-		nconfig = self.xmpp1['xep_0060'].getNodeConfig(self.pshost, 'testnode2')
-		self.failUnless(nconfig, "No configuration returned")
-		#print("\n%s ==\n %s" % (nconfig.getValues(), self.statev['defaultconfig'].getValues()))
-		self.failUnless(nconfig.getValues() == self.statev['defaultconfig'].getValues(), "Configuration does not match")
-		self.failUnless(self.xmpp1['xep_0060'].setNodeConfig(self.pshost, 'testnode2', nconfig))
-
-	def test006subscribetonode(self):
-		"""Subscribe to node from account 2"""
-		self.failUnless(self.xmpp2['xep_0060'].subscribe(self.pshost, "testnode2"))
-	
-	def test007publishitem(self):
-		"""Publishing item"""
-		item = ET.Element('{http://netflint.net/protocol/test}test')
-		w = Waiter('wait publish', StanzaPath('message/pubsub_event/items'))
-		self.xmpp2.registerHandler(w)
-		result = self.xmpp1['xep_0060'].setItem(self.pshost, "testnode2", (('test1', item),))
-		msg = w.wait(5) # got to get a result in 5 seconds
-		self.failUnless(msg != False, "Account #2 did not get message event")
-		self.failUnless(result)
-		#need to add check for update
-	
-	def test008updateitem(self):
-		"""Updating item"""
-		item = ET.Element('{http://netflint.net/protocol/test}test', {'someattr': 'hi there'})
-		w = Waiter('wait publish', StanzaPath('message/pubsub_event/items'))
-		self.xmpp2.registerHandler(w)
-		result = self.xmpp1['xep_0060'].setItem(self.pshost, "testnode2", (('test1', item),))
-		msg = w.wait(5) # got to get a result in 5 seconds
-		self.failUnless(msg != False, "Account #2 did not get message event")
-		self.failUnless(result)
-		#need to add check for update
-	
-	def test009deleteitem(self):
-		"""Deleting item"""
-		w = Waiter('wait retract', StanzaPath('message/pubsub_event/items@node=testnode2'))
-		self.xmpp2.registerHandler(w)
-		result = self.xmpp1['xep_0060'].deleteItem(self.pshost, "testnode2", "test1")
-		self.failUnless(result, "Got error when deleting item.")
-		msg = w.wait(1)
-		self.failUnless(msg != False, "Did not get retract notice.")
-	
-	def test010unsubscribenode(self):
-		"Unsubscribing Account #2"
-		self.failUnless(self.xmpp2['xep_0060'].unsubscribe(self.pshost, "testnode2"), "Got error response when unsubscribing.")
-	
-	def test011createcollectionnode(self):
-		"Create a collection node w/ Account #2"
-		self.failUnless(self.xmpp2['xep_0060'].create_node(self.pshost, "testnode3", self.statev['defaultconfig'], True), "Could not create collection node")
-	
-	def test012subscribecollection(self):
-		"Subscribe Account #1 to collection"
-		self.failUnless(self.xmpp1['xep_0060'].subscribe(self.pshost, "testnode3"))
-	
-	def test013assignnodetocollection(self):
-		"Assign node to collection"
-		self.failUnless(self.xmpp2['xep_0060'].addNodeToCollection(self.pshost, 'testnode2', 'testnode3'))
-	
-	def test014publishcollection(self):
-		"""Publishing item to collection child"""
-		item = ET.Element('{http://netflint.net/protocol/test}test')
-		w = Waiter('wait publish2', StanzaPath('message/pubsub_event/items@node=testnode2'))
-		self.xmpp1.registerHandler(w)
-		result = self.xmpp2['xep_0060'].setItem(self.pshost, "testnode2", (('test2', item),))
-		msg = w.wait(5) # got to get a result in 5 seconds
-		self.failUnless(msg != False, "Account #1 did not get message event: perhaps node was advertised incorrectly?")
-		self.failUnless(result)
-
-#	def test016speedtest(self):
-#		"Uncached speed test"
-#		import time
-#		start = time.time()
-#		for y in range(0, 50000, 1000):
-#			start2 = time.time()
-#			for x in range(y, y+1000):
-#				self.failUnless(self.xmpp1['xep_0060'].subscribe(self.pshost, "testnode4", subscribee="testuser%s@whatever" % x))
-#			print time.time() - start2
-#		seconds = time.time() - start
-#		print "--", seconds
-#		print "---------"
-#		time.sleep(15)
-#		self.failUnless(self.xmpp1['xep_0060'].deleteNode(self.pshost, 'testnode4'), "Could not delete non-cached test node")
-	
-#	def test015speedtest(self):
-#		"cached speed test"
-#		result = self.xmpp1['xep_0060'].getNodeConfig(self.pshost)
-#		self.statev['defaultconfig'] = result
-#		self.statev['defaultconfig'].field['pubsub#node_type'].setValue("leaf")
-#		self.statev['defaultconfig'].field['sleek#saveonchange'].setValue(True)
-#		self.failUnless(self.xmpp1['xep_0060'].create_node(self.pshost, 'testnode4', self.statev['defaultconfig']))
-#		self.statev['defaultconfig'].field['sleek#saveonchange'].setValue(False)
-#		self.failUnless(self.xmpp1['xep_0060'].create_node(self.pshost, 'testnode5', self.statev['defaultconfig']))
-#		start = time.time()
-#		for y in range(0, 50000, 1000):
-#			start2 = time.time()
-#			for x in range(y, y+1000):
-#				self.failUnless(self.xmpp1['xep_0060'].subscribe(self.pshost, "testnode5", subscribee="testuser%s@whatever" % x))
-#			print time.time() - start2
-#		seconds = time.time() - start
-#		print "--", seconds
-
-	def test900cleanup(self):
-		"Cleaning up"
-		self.failUnless(self.xmpp1['xep_0060'].deleteNode(self.pshost, 'testnode2'), "Could not delete test node.")
-		self.failUnless(self.xmpp1['xep_0060'].deleteNode(self.pshost, 'testnode3'), "Could not delete collection node")
-	
-
-if __name__ == '__main__':
-	#parse command line arguements
-	optp = OptionParser()
-	optp.add_option('-q','--quiet', help='set logging to ERROR', action='store_const', dest='loglevel', const=logging.ERROR, default=logging.INFO)
-	optp.add_option('-d','--debug', help='set logging to DEBUG', action='store_const', dest='loglevel', const=logging.DEBUG, default=logging.INFO)
-	optp.add_option('-v','--verbose', help='set logging to COMM', action='store_const', dest='loglevel', const=5, default=logging.INFO)
-	optp.add_option("-c","--config", dest="configfile", default="config.xml", help="set config file to use")
-	optp.add_option("-n","--nodenum", dest="nodenum", default="1", help="set node number to use")
-	optp.add_option("-p","--pubsub", dest="pubsub", default="1", help="set pubsub host to use")
-	opts,args = optp.parse_args()
-	
-	logging.basicConfig(level=opts.loglevel, format='%(levelname)-8s %(message)s')
-
-	#load xml config
-	logging.info("Loading config file: %s" , opts.configfile)
-	config = configparser.RawConfigParser()
-	config.read(opts.configfile)
-	
-	#init
-	logging.info("Account 1 is %s" , config.get('account1', 'jid'))
-	xmpp1 = TestClient(config.get('account1','jid'), config.get('account1','pass'))
-	logging.info("Account 2 is %s" , config.get('account2', 'jid'))
-	xmpp2 = TestClient(config.get('account2','jid'), config.get('account2','pass'))
-	
-	xmpp1.registerPlugin('xep_0004')
-	xmpp1.registerPlugin('xep_0030')
-	xmpp1.registerPlugin('xep_0060')
-	xmpp1.registerPlugin('xep_0199')
-	xmpp2.registerPlugin('xep_0004')
-	xmpp2.registerPlugin('xep_0030')
-	xmpp2.registerPlugin('xep_0060')
-	xmpp2.registerPlugin('xep_0199')
-
-	if not config.get('account1', 'server'):
-		# we don't know the server, but the lib can probably figure it out
-		xmpp1.connect() 
-	else:
-		xmpp1.connect((config.get('account1', 'server'), 5222))
-	xmpp1.process(threaded=True)
-	
-	#init
-	if not config.get('account2', 'server'):
-		# we don't know the server, but the lib can probably figure it out
-		xmpp2.connect() 
-	else:
-		xmpp2.connect((config.get('account2', 'server'), 5222))
-	xmpp2.process(threaded=True)
-
-	TestPubsubServer.xmpp1 = xmpp1
-	TestPubsubServer.xmpp2 = xmpp2
-	TestPubsubServer.pshost = config.get('settings', 'pubsub')
-	xmpp1.waitforstart.get(True)
-	xmpp2.waitforstart.get(True)
-	testsuite = unittest.TestLoader().loadTestsFromTestCase(TestPubsubServer)
-
-	alltests_suite = unittest.TestSuite([testsuite])
-	result = unittest.TextTestRunner(verbosity=2).run(alltests_suite)
-	xmpp1.disconnect()
-	xmpp2.disconnect()

conn_tests/testconfig.ini

@@ -1,13 +0,0 @@
-[settings]
-enabled=true
-pubsub=pubsub.recon
-
-[account1]
-jid=fritzy@recon
-pass=testing123
-server=
-
-[account2]
-jid=fritzy2@recon
-pass=testing123
-server=

conn_tests/testpubsub.py

@@ -1,350 +0,0 @@
-"""
-    SleekXMPP: The Sleek XMPP Library
-    Copyright (C) 2010 Nathanael C. Fritz
-    This file is part of SleekXMPP.
-    
-    See the file LICENSE for copying permission.
-"""
-
-import logging
-import sleekxmpp
-from optparse import OptionParser
-from xml.etree import cElementTree as ET
-import os
-import time
-import sys
-import Queue
-import thread
-
-
-class testps(sleekxmpp.ClientXMPP):
-	def __init__(self, jid, password, ssl=False, plugin_config = {}, plugin_whitelist=[], nodenum=0, pshost=None):
-		sleekxmpp.ClientXMPP.__init__(self, jid, password, ssl, plugin_config, plugin_whitelist)
-		self.registerPlugin('xep_0004')
-		self.registerPlugin('xep_0030')
-		self.registerPlugin('xep_0060')
-		self.registerPlugin('xep_0092')
-		self.add_handler("<message xmlns='jabber:client'><event xmlns='http://jabber.org/protocol/pubsub#event' /></message>", self.pubsubEventHandler, name='Pubsub Event', threaded=True)
-		self.add_event_handler("session_start", self.start, threaded=True)
-		self.add_handler("<iq type='error' />", self.handleError, name='Iq Error')
-		self.events = Queue.Queue()
-		self.default_config = None
-		self.ps = self.plugin['xep_0060']
-		self.node = "pstestnode_%s"
-		self.pshost = pshost
-		if pshost is None:
-			self.pshost = self.boundjid.host
-		self.nodenum = int(nodenum)
-		self.leafnode = self.nodenum + 1
-		self.collectnode = self.nodenum + 2
-		self.lasterror = ''
-		self.sprintchars = 0
-		self.defaultconfig = None
-		self.tests = ['test_defaultConfig', 'test_createDefaultNode', 'test_getNodes', 'test_deleteNode', 'test_createWithConfig', 'test_reconfigureNode', 'test_subscribeToNode', 'test_addItem', 'test_updateItem', 'test_deleteItem', 'test_unsubscribeNode', 'test_createCollection', 'test_subscribeCollection', 'test_addNodeCollection', 'test_deleteNodeCollection', 'test_addCollectionNode', 'test_deleteCollectionNode', 'test_unsubscribeNodeCollection', 'test_deleteCollection']
-		self.passed = 0
-		self.width = 120
-	
-	def start(self, event):
-		#TODO: make this configurable
-		self.getRoster()
-		self.sendPresence(ppriority=20)
-		thread.start_new(self.test_all, tuple())
-	
-	def sprint(self, msg, end=False, color=False):
-		length = len(msg)
-		if color:
-			if color == "red":
-				color = "1;31"
-			elif color == "green":
-				color = "0;32"
-			msg = "%s%s%s" % ("\033[%sm" % color, msg, "\033[0m")
-		if not end:
-			sys.stdout.write(msg)
-			self.sprintchars += length
-		else:
-			self.sprint("%s%s" % ("." * (self.width - self.sprintchars - length), msg))
-			print('')
-			self.sprintchars = 0
-		sys.stdout.flush()
-
-	def pubsubEventHandler(self, xml):
-		for item in xml.findall('{http://jabber.org/protocol/pubsub#event}event/{http://jabber.org/protocol/pubsub#event}items/{http://jabber.org/protocol/pubsub#event}item'):
-			self.events.put(item.get('id', '__unknown__'))
-		for item in xml.findall('{http://jabber.org/protocol/pubsub#event}event/{http://jabber.org/protocol/pubsub#event}items/{http://jabber.org/protocol/pubsub#event}retract'):
-			self.events.put(item.get('id', '__unknown__'))
-		for item in xml.findall('{http://jabber.org/protocol/pubsub#event}event/{http://jabber.org/protocol/pubsub#event}collection/{http://jabber.org/protocol/pubsub#event}disassociate'):
-			self.events.put(item.get('node', '__unknown__'))
-		for item in xml.findall('{http://jabber.org/protocol/pubsub#event}event/{http://jabber.org/protocol/pubsub#event}collection/{http://jabber.org/protocol/pubsub#event}associate'):
-			self.events.put(item.get('node', '__unknown__'))
-	
-	def handleError(self, xml):
-		error = xml.find('{jabber:client}error')
-		self.lasterror =  error.getchildren()[0].tag.split('}')[-1]
-		
-	def test_all(self):
-		print("Running Publish-Subscribe Tests")
-		version = self.plugin['xep_0092'].getVersion(self.pshost)
-		if version:
-			print("%s %s on %s" % (version.get('name', 'Unknown Server'), version.get('version', 'v?'), version.get('os', 'Unknown OS')))
-		print("=" * self.width)
-		for test in self.tests:
-			testfunc = getattr(self, test)
-			self.sprint("%s" % testfunc.__doc__)
-			if testfunc():
-				self.sprint("Passed", True, "green")
-				self.passed += 1
-			else:
-				if not self.lasterror:
-					self.lasterror = 'No response'
-				self.sprint("Failed (%s)" % self.lasterror, True, "red")
-				self.lasterror = ''
-		print("=" * self.width)
-		self.sprint("Cleaning up...")
-		#self.ps.deleteNode(self.pshost, self.node % self.nodenum)
-		self.ps.deleteNode(self.pshost, self.node % self.leafnode)
-		#self.ps.deleteNode(self.pshost, self.node % self.collectnode)
-		self.sprint("Done", True, "green")
-		self.disconnect()
-		self.sprint("%s" % self.passed, False, "green")
-		self.sprint("/%s Passed -- " % len(self.tests))
-		if len(self.tests) - self.passed:
-			self.sprint("%s" % (len(self.tests) - self.passed), False, "red")
-		else:
-			self.sprint("%s" % (len(self.tests) - self.passed), False, "green")
-		self.sprint(" Failed Tests")
-		print
-		#print "%s/%s Passed -- %s Failed Tests" % (self.passed, len(self.tests), len(self.tests) - self.passed)
-	
-	def test_defaultConfig(self):
-		"Retreiving default configuration"
-		result = self.ps.getNodeConfig(self.pshost)
-		if result is False or result is None:
-			return False
-		else:
-			self.defaultconfig = result
-			try:
-				self.defaultconfig.field['pubsub#access_model'].setValue('open')
-			except KeyError:
-				pass
-			try:
-				self.defaultconfig.field['pubsub#notify_retract'].setValue(True)
-			except KeyError:
-				pass
-			return True
-	
-	def test_createDefaultNode(self):
-		"Creating default node"
-		return self.ps.create_node(self.pshost, self.node % self.nodenum)
-	
-	def test_getNodes(self):
-		"Getting list of nodes"
-		self.ps.getNodes(self.pshost)
-		self.ps.getItems(self.pshost, 'blog')
-		return True
-	
-	def test_deleteNode(self):
-		"Deleting node"
-		return self.ps.deleteNode(self.pshost, self.node % self.nodenum)
-	
-	def test_createWithConfig(self):
-		"Creating node with config"
-		if self.defaultconfig is None:
-			self.lasterror = "No Avail Config"
-			return False
-		return self.ps.create_node(self.pshost, self.node % self.leafnode, self.defaultconfig)
-	
-	def test_reconfigureNode(self):
-		"Retrieving node config and reconfiguring"
-		nconfig = self.ps.getNodeConfig(self.pshost, self.node % self.leafnode)
-		if nconfig == False:
-			return False
-		return self.ps.setNodeConfig(self.pshost, self.node % self.leafnode, nconfig)
-		
-	def test_subscribeToNode(self):
-		"Subscribing to node"
-		return self.ps.subscribe(self.pshost, self.node % self.leafnode)
-	
-	def test_addItem(self):
-		"Adding item, waiting for notification"
-		item = ET.Element('test')
-		result = self.ps.setItem(self.pshost, self.node % self.leafnode, (('test_node1', item),))
-		if result == False:
-			return False
-		try:
-			event = self.events.get(True, 10)
-		except Queue.Empty:
-			return False
-		if event == 'test_node1':
-			return True
-		return False
-	
-	def test_updateItem(self):
-		"Updating item, waiting for notification"
-		item = ET.Element('test')
-		item.attrib['crap'] = 'yup, right here'
-		result = self.ps.setItem(self.pshost, self.node % self.leafnode, (('test_node1', item),))
-		if result == False:
-			return False
-		try:
-			event = self.events.get(True, 10)
-		except Queue.Empty:
-			return False
-		if event == 'test_node1':
-			return True
-		return False
-
-	def test_deleteItem(self):
-		"Deleting item, waiting for notification"
-		result = self.ps.deleteItem(self.pshost, self.node % self.leafnode, 'test_node1')
-		if result == False:
-			return False
-		try:
-			event = self.events.get(True, 10)
-		except Queue.Empty:
-			self.lasterror = "No Notification"
-			return False
-		if event == 'test_node1':
-			return True
-		return False
-	
-	def test_unsubscribeNode(self):
-		"Unsubscribing from node"
-		return self.ps.unsubscribe(self.pshost, self.node % self.leafnode)
-
-	def test_createCollection(self):
-		"Creating collection node"
-		return self.ps.create_node(self.pshost, self.node % self.collectnode, self.defaultconfig, True)
-	
-	def test_subscribeCollection(self):
-		"Subscribing to collection node"
-		return self.ps.subscribe(self.pshost, self.node % self.collectnode)
-	
-	def test_addNodeCollection(self):
-		"Assigning node to collection, waiting for notification"
-		config = self.ps.getNodeConfig(self.pshost, self.node % self.leafnode)
-		if not config or config is None:
-			self.lasterror = "Config Error"
-			return False
-		try:
-			config.field['pubsub#collection'].setValue(self.node % self.collectnode)
-		except KeyError:
-			self.sprint("...Missing Field...", False, "red")
-			config.addField('pubsub#collection', value=self.node % self.collectnode)
-		if not self.ps.setNodeConfig(self.pshost, self.node % self.leafnode, config):
-			return False
-		try:
-			event = self.events.get(True, 10)
-		except Queue.Empty:
-			self.lasterror = "No Notification"
-			return False
-		if event == self.node % self.leafnode:
-			return True
-		return False
-	
-	def test_deleteNodeCollection(self):
-		"Removing node assignment to collection, waiting for notification"
-		config = self.ps.getNodeConfig(self.pshost, self.node % self.leafnode)
-		if not config or config is None:
-			self.lasterror = "Config Error"
-			return False
-		try:
-			config.field['pubsub#collection'].delValue(self.node % self.collectnode)
-		except KeyError:
-			self.sprint("...Missing Field...", False, "red")
-			config.addField('pubsub#collection', value='')
-		if not self.ps.setNodeConfig(self.pshost, self.node % self.leafnode, config):
-			return False
-		try:
-			event = self.events.get(True, 10)
-		except Queue.Empty:
-			self.lasterror = "No Notification"
-			return False
-		if event == self.node % self.leafnode:
-			return True
-		return False
-
-	def test_addCollectionNode(self):
-		"Assigning node from collection, waiting for notification"
-		config = self.ps.getNodeConfig(self.pshost, self.node % self.collectnode)
-		if not config or config is None:
-			self.lasterror = "Config Error"
-			return False
-		try:
-			config.field['pubsub#children'].setValue(self.node % self.leafnode)
-		except KeyError:
-			self.sprint("...Missing Field...", False, "red")
-			config.addField('pubsub#children', value=self.node % self.leafnode)
-		if not self.ps.setNodeConfig(self.pshost, self.node % self.collectnode, config):
-			return False
-		try:
-			event = self.events.get(True, 10)
-		except Queue.Empty:
-			self.lasterror = "No Notification"
-			return False
-		if event == self.node % self.leafnode:
-			return True
-		return False
-
-	def test_deleteCollectionNode(self):
-		"Removing node from collection, waiting for notification"
-		config = self.ps.getNodeConfig(self.pshost, self.node % self.collectnode)
-		if not config or config is None:
-			self.lasterror = "Config Error"
-			return False
-		try:
-			config.field['pubsub#children'].delValue(self.node % self.leafnode)
-		except KeyError:
-			self.sprint("...Missing Field...", False, "red")
-			config.addField('pubsub#children', value='')
-		if not self.ps.setNodeConfig(self.pshost, self.node % self.collectnode, config):
-			return False
-		try:
-			event = self.events.get(True, 10)
-		except Queue.Empty:
-			self.lasterror = "No Notification"
-			return False
-		if event == self.node % self.leafnode:
-			return True
-		return False
-	
-	def test_unsubscribeNodeCollection(self):
-		"Unsubscribing from collection"
-		return self.ps.unsubscribe(self.pshost, self.node % self.collectnode)
-	
-	def test_deleteCollection(self):
-		"Deleting collection"
-		return self.ps.deleteNode(self.pshost, self.node % self.collectnode)
-
-if __name__ == '__main__':
-	#parse command line arguements
-	optp = OptionParser()
-	optp.add_option('-q','--quiet', help='set logging to ERROR', action='store_const', dest='loglevel', const=logging.ERROR, default=logging.INFO)
-	optp.add_option('-d','--debug', help='set logging to DEBUG', action='store_const', dest='loglevel', const=logging.DEBUG, default=logging.INFO)
-	optp.add_option('-v','--verbose', help='set logging to COMM', action='store_const', dest='loglevel', const=5, default=logging.INFO)
-	optp.add_option("-c","--config", dest="configfile", default="config.xml", help="set config file to use")
-	optp.add_option("-n","--nodenum", dest="nodenum", default="1", help="set node number to use")
-	optp.add_option("-p","--pubsub", dest="pubsub", default="1", help="set pubsub host to use")
-	opts,args = optp.parse_args()
-	
-	logging.basicConfig(level=opts.loglevel, format='%(levelname)-8s %(message)s')
-
-	#load xml config
-	logging.info("Loading config file: %s" , opts.configfile)
-	config = ET.parse(os.path.expanduser(opts.configfile)).find('auth')
-	
-	#init
-	logging.info("Logging in as %s" , config.attrib['jid'])
-	
-	
-	plugin_config = {}
-	plugin_config['xep_0092'] = {'name': 'SleekXMPP Example', 'version': '0.1-dev'}
-	plugin_config['xep_0199'] = {'keepalive': True, 'timeout': 30, 'frequency': 300}
-	
-	con = testps(config.attrib['jid'], config.attrib['pass'], plugin_config=plugin_config, plugin_whitelist=[], nodenum=opts.nodenum, pshost=opts.pubsub)
-	if not config.get('server', None):
-		# we don't know the server, but the lib can probably figure it out
-		con.connect() 
-	else:
-		con.connect((config.attrib['server'], 5222))
-	con.process(threaded=False)
-	print("")

docs/.gitignore

@@ -0,0 +1 @@
+_build/*

docs/_static/haiku.css

@@ -59,9 +59,10 @@ body {
     margin: auto;
     padding: 0px;
     font-family: "Helvetica Neueu", Helvetica, sans-serif;
-    min-width: 59em;
+    min-width: 30em;
     max-width: 70em;
     color: #444;
+    text-align: center;
 }
 
 div.footer {
@@ -124,21 +125,25 @@ a.headerlink:hover {
 /* basic text elements */
 
 div.content {
+    margin: auto;
     margin-top: 20px;
-    margin-left: 40px;
-    margin-right: 40px;
     margin-bottom: 50px;
     font-size: 0.9em;
+    width: 700px;
+    text-align: left;
 }
 
 /* heading and navigation */
 
 div.header {
     position: relative;
+    margin: auto;
     margin-top: 125px;
     height: 85px;
     padding: 0 40px;
     font-family: "Yanone Kaffeesatz";
+    text-align: left;
+    width: 750px;
 }
 div.header h1 {
     font-size: 2.6em;
@@ -185,12 +190,12 @@ div.topnav {
     z-index: 0;
 }
 div.topnav p {
+    margin: auto;
     margin-top: 0;
-    margin-left: 40px;
-    margin-right: 40px;
     margin-bottom: 0px;
     text-align: right;
     font-size: 0.8em;
+    width: 750px;
 }
 div.bottomnav {
     background: #eeeeee;
@@ -404,3 +409,23 @@ div.viewcode-block:target {
     padding: 0 12px;
 }
 
+#from_andyet {
+    -webkit-box-shadow: #CCC 0px 0px 3px;
+    background: rgba(255, 255, 255, 1);
+    bottom: 0px;
+    right: 17px;
+    padding: 3px 10px;
+    position: fixed;
+}
+
+#from_andyet h2 {
+    background-image: url("images/from_&yet.png");
+    background-repeat: no-repeat;
+    height: 29px;
+    line-height: 0;
+    text-indent: -9999em;
+    width: 79px;
+    margin-top: 0;
+    margin: 0px;
+    padding: 0px;
+}

docs/_static/pygments.css

@@ -0,0 +1,70 @@
+.highlight .hll { background-color: #ffffcc }
+.highlight  { background: #000000; color: #f6f3e8; }
+.highlight .c { color: #7C7C7C; } /* Comment */
+.highlight .err { color: #f6f3e8; } /* Error */
+.highlight .g { color: #f6f3e8; } /* Generic */
+.highlight .k { color: #00ADEE; } /* Keyword */
+.highlight .l { color: #f6f3e8; } /* Literal */
+.highlight .n { color: #f6f3e8; } /* Name */
+.highlight .o { color: #f6f3e8; } /* Operator */
+.highlight .x { color: #f6f3e8; } /* Other */
+.highlight .p { color: #f6f3e8; } /* Punctuation */
+.highlight .cm { color: #7C7C7C; } /* Comment.Multiline */
+.highlight .cp { color: #96CBFE; } /* Comment.Preproc */
+.highlight .c1 { color: #7C7C7C; } /* Comment.Single */
+.highlight .cs { color: #7C7C7C; } /* Comment.Special */
+.highlight .gd { color: #f6f3e8; } /* Generic.Deleted */
+.highlight .ge { color: #f6f3e8; } /* Generic.Emph */
+.highlight .gr { color: #ffffff; background-color: #ff0000 } /* Generic.Error */
+.highlight .gh { color: #f6f3e8; font-weight: bold; } /* Generic.Heading */
+.highlight .gi { color: #f6f3e8; } /* Generic.Inserted */
+.highlight .go { color: #070707; } /* Generic.Output */
+.highlight .gp { color: #f6f3e8; } /* Generic.Prompt */
+.highlight .gs { color: #f6f3e8; } /* Generic.Strong */
+.highlight .gu { color: #f6f3e8; font-weight: bold; } /* Generic.Subheading */
+.highlight .gt { color: #ffffff; font-weight: bold; background-color: #FF6C60 } /* Generic.Traceback */
+.highlight .kc { color: #6699CC; } /* Keyword.Constant */
+.highlight .kd { color: #6699CC; } /* Keyword.Declaration */
+.highlight .kn { color: #6699CC; } /* Keyword.Namespace */
+.highlight .kp { color: #6699CC; } /* Keyword.Pseudo */
+.highlight .kr { color: #6699CC; } /* Keyword.Reserved */
+.highlight .kt { color: #FFFFB6; } /* Keyword.Type */
+.highlight .ld { color: #f6f3e8; } /* Literal.Date */
+.highlight .m { color: #FF73FD; } /* Literal.Number */
+.highlight .s { color: #F46DBA;/*#A8FF60;*/ } /* Literal.String */
+.highlight .na { color: #f6f3e8; } /* Name.Attribute */
+.highlight .nb { color: #f6f3e8; } /* Name.Builtin */
+.highlight .nc { color: #f6f3e8; } /* Name.Class */
+.highlight .no { color: #99CC99; } /* Name.Constant */
+.highlight .nd { color: #f6f3e8; } /* Name.Decorator */
+.highlight .ni { color: #E18964; } /* Name.Entity */
+.highlight .ne { color: #f6f3e8; } /* Name.Exception */
+.highlight .nf { color: #F64DBA; } /* Name.Function */
+.highlight .nl { color: #f6f3e8; } /* Name.Label */
+.highlight .nn { color: #f6f3e8; } /* Name.Namespace */
+.highlight .nx { color: #f6f3e8; } /* Name.Other */
+.highlight .py { color: #f6f3e8; } /* Name.Property */
+.highlight .nt { color: #00ADEE; } /* Name.Tag */
+.highlight .nv { color: #C6C5FE; } /* Name.Variable */
+.highlight .ow { color: #ffffff; } /* Operator.Word */
+.highlight .w { color: #f6f3e8; } /* Text.Whitespace */
+.highlight .mf { color: #FF73FD; } /* Literal.Number.Float */
+.highlight .mh { color: #FF73FD; } /* Literal.Number.Hex */
+.highlight .mi { color: #FF73FD; } /* Literal.Number.Integer */
+.highlight .mo { color: #FF73FD; } /* Literal.Number.Oct */
+.highlight .sb { color: #A8FF60; } /* Literal.String.Backtick */
+.highlight .sc { color: #A8FF60; } /* Literal.String.Char */
+.highlight .sd { color: #A8FF60; } /* Literal.String.Doc */
+.highlight .s2 { color: #A8FF60; } /* Literal.String.Double */
+.highlight .se { color: #A8FF60; } /* Literal.String.Escape */
+.highlight .sh { color: #A8FF60; } /* Literal.String.Heredoc */
+.highlight .si { color: #A8FF60; } /* Literal.String.Interpol */
+.highlight .sx { color: #A8FF60; } /* Literal.String.Other */
+.highlight .sr { color: #A8FF60; } /* Literal.String.Regex */
+.highlight .s1 { color: #A8FF60; } /* Literal.String.Single */
+.highlight .ss { color: #A8FF60; } /* Literal.String.Symbol */
+.highlight .bp { color: #f6f3e8; } /* Name.Builtin.Pseudo */
+.highlight .vc { color: #C6C5FE; } /* Name.Variable.Class */
+.highlight .vg { color: #C6C5FE; } /* Name.Variable.Global */
+.highlight .vi { color: #C6C5FE; } /* Name.Variable.Instance */
+.highlight .il { color: #FF73FD; } /* Literal.Number.Integer.Long */

docs/_templates/layout.html

@@ -0,0 +1,70 @@
+{#
+    haiku/layout.html
+    ~~~~~~~~~~~~~~~~~
+
+    Sphinx layout template for the haiku theme.
+
+    :copyright: Copyright 2007-2010 by the Sphinx team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+#}
+{% extends "basic/layout.html" %}
+{% set script_files = script_files + ['_static/theme_extras.js'] %}
+{% set css_files = css_files + ['_static/print.css'] %}
+
+{# do not display relbars #}
+{% block relbar1 %}{% endblock %}
+{% block relbar2 %}{% endblock %}
+
+{% macro nav() %}
+        <p>
+        {%- block haikurel1 %}
+        {%- endblock %}
+        {%- if prev %}
+        «&#160;&#160;<a href="{{ prev.link|e }}">{{ prev.title }}</a>
+        &#160;&#160;::&#160;&#160;
+        {%- endif %}
+        <a class="uplink" href="{{ pathto(master_doc) }}">{{ _('Contents') }}</a>
+        {%- if next %}
+        &#160;&#160;::&#160;&#160;
+        <a href="{{ next.link|e }}">{{ next.title }}</a>&#160;&#160;»
+        {%- endif %}
+        {%- block haikurel2 %}
+        {%- endblock %}
+        </p>
+{% endmacro %}
+
+{% block content %}
+      <div class="header">
+        {%- block haikuheader %}
+        {%- if theme_full_logo != "false" %}
+        <a href="{{ pathto('index') }}">
+          <img class="logo" src="{{ pathto('_static/' + logo, 1) }}" alt="Logo"/>
+        </a>
+        {%- else %}
+        {%- if logo -%}
+          <img class="rightlogo" src="{{ pathto('_static/' + logo, 1) }}" alt="Logo"/>
+        {%- endif -%}
+        <h1 class="heading"><a href="{{ pathto('index') }}">
+          <span>{{ title|striptags }}</span></a></h1>
+        <h2 class="heading"><span>{{ shorttitle|e }}</span></h2>
+        {%- endif %}
+        {%- endblock %}
+      </div>
+      <div class="topnav">
+      {{ nav() }}
+      </div>
+      <div class="content">
+        {#{%- if display_toc %}
+        <div id="toc">
+          <h3>Table Of Contents</h3>
+          {{ toc }}
+        </div>
+        {%- endif %}#}
+        {% block body %}{% endblock %}
+      </div>
+      <div class="bottomnav">
+      {{ nav() }}
+      </div>
+      <a id="from_andyet" href="http://andyet.net"><h2>From &amp;yet</h2></a>
+{% endblock %}
+

docs/conf.py

@@ -50,7 +50,7 @@ copyright = u'2011, Nathan Fritz, Lance Stout'
 # The short X.Y version.
 version = '1.0'
 # The full version, including alpha/beta/rc tags.
-release = '1.0RC3'
+release = '1.0'
 
 # The language for content autogenerated by Sphinx. Refer to documentation
 # for a list of supported languages.
@@ -91,7 +91,7 @@ pygments_style = 'tango'
 
 # The theme to use for HTML and HTML Help pages.  See the documentation for
 # a list of builtin themes.
-html_theme = 'nature'
+html_theme = 'haiku'
 
 # Theme options are theme-specific and customize the look and feel of a theme
 # further.  For a list of options available for each theme, see the

docs/getting_started/muc.rst

@@ -1,2 +1,208 @@
+.. _mucbot:
+
+=========================
 Mulit-User Chat (MUC) Bot
 =========================
+
+.. note::
+
+    If you have any issues working through this quickstart guide
+    or the other tutorials here, please either send a message to the
+    `mailing list <http://groups.google.com/group/sleekxmpp-discussion>`_
+    or join the chat room at `sleek@conference.jabber.org
+    <xmpp:sleek@conference.jabber.org?join>`_.
+
+If you have not yet installed SleekXMPP, do so now by either checking out a version
+from `Github <http://github.com/fritzy/SleekXMPP>`_, or installing it using ``pip``
+or ``easy_install``.
+
+.. code-block:: sh
+
+    pip install sleekxmpp  # Or: easy_install sleekxmpp
+
+
+Now that you've got the basic gist of using SleekXMPP by following the
+echobot example (:ref:`echobot`), we can use one of the bundled plugins
+to create a very popular XMPP starter project: a `Multi-User Chat`_
+(MUC) bot. Our bot will login to an XMPP server, join an MUC chat room
+and "lurk" indefinitely, responding with a generic message to anyone
+that mentions its nickname. It will also greet members as they join the
+chat room.
+
+.. _`multi-user chat`: http://xmpp.org/extensions/xep-0045.html
+
+Joining The Room
+----------------
+
+As usual, our code will be based on the pattern explained in :ref:`echobot`.
+To start, we create an ``MUCBot`` class based on
+:class:`ClientXMPP <sleekxmpp.clientxmpp.ClientXMPP>` and which accepts
+parameters for the JID of the MUC room to join, and the nick that the
+bot will use inside the chat room.  We also register an
+:term:`event handler` for the :term:`session_start` event.
+
+
+.. code-block:: python
+
+    import sleekxmpp
+
+    class MUCBot(sleekxmpp.ClientXMPP):
+
+        def __init__(self, jid, password, room, nick):
+            sleekxmpp.ClientXMPP.__init__(self, jid, password)
+
+            self.room = room
+            self.nick = nick
+
+            self.add_event_handler("session_start", self.start)
+
+After initialization, we also need to register the MUC (XEP-0045) plugin
+so that we can make use of the group chat plugin's methods and events.
+
+.. code-block:: python
+
+    xmpp.register_plugin('xep_0045')
+
+Finally, we can make our bot join the chat room once an XMPP session
+has been established:
+
+.. code-block:: python
+
+    def start(self, event):
+        self.get_roster()
+        self.send_presence()
+        self.plugin['xep_0045'].joinMUC(self.room,
+                                        self.nick,
+                                        wait=True)
+
+Note that as in :ref:`echobot`, we need to include send an initial presence and request
+the roster. Next, we want to join the group chat, so we call the
+``joinMUC`` method of the MUC plugin.
+
+.. note::
+
+    The :attr:`plugin <sleekxmpp.basexmpp.BaseXMPP.plugin>` attribute is
+    dictionary that maps to instances of plugins that we have previously
+    registered, by their names.
+
+
+Adding Functionality
+--------------------
+
+Currently, our bot just sits dormantly inside the chat room, but we
+would like it to respond to two distinct events by issuing a generic
+message in each case to the chat room. In particular, when a member
+mentions the bot's nickname inside the chat room, and when a member
+joins the chat room.
+
+Responding to Mentions
+~~~~~~~~~~~~~~~~~~~~~~
+
+Whenever a user mentions our bot's nickname in chat, our bot will
+respond with a generic message resembling *"I heard that, user."* We do
+this by examining all of the messages sent inside the chat and looking
+for the ones which contain the nickname string.
+
+First, we register an event handler for the :term:`groupchat_message`
+event inside the bot's ``__init__`` function.
+
+.. note::
+
+    We do not register a handler for the :term:`message` event in this
+    bot, but if we did, the group chat message would have been sent to
+    both handlers.
+
+.. code-block:: python
+
+    def __init__(self, jid, password, room, nick):
+        sleekxmpp.ClientXMPP.__init__(self, jid, password)
+
+        self.room = room
+        self.nick = nick
+
+        self.add_event_handler("session_start", self.start)
+        self.add_event_handler("groupchat_message", self.muc_message)
+
+Then, we can send our generic message whenever the bot's nickname gets
+mentioned.
+
+.. warning::
+
+    Always check that a message is not from yourself,
+    otherwise you will create an infinite loop responding
+    to your own messages.
+
+.. code-block:: python
+
+    def muc_message(self, msg):
+        if msg['mucnick'] != self.nick and self.nick in msg['body']:
+            self.send_message(mto=msg['from'].bare,
+                              mbody="I heard that, %s." % msg['mucnick'],
+                              mtype='groupchat')
+
+
+Greeting Members
+~~~~~~~~~~~~~~~~
+
+Now we want to greet member whenever they join the group chat. To
+do this we will use the dynamic ``muc::room@server::got_online`` [1]_
+event so it's a good idea to register an event handler for it.
+
+.. note::
+
+    The groupchat_presence event is triggered whenever a
+    presence stanza is received from any chat room, including
+    any presences you send yourself. To limit event handling
+    to a single room, use the events ``muc::room@server::presence``,
+    ``muc::room@server::got_online``, or ``muc::room@server::got_offline``.
+
+.. code-block:: python
+
+    def __init__(self, jid, password, room, nick):
+        sleekxmpp.ClientXMPP.__init__(self, jid, password)
+
+        self.room = room
+        self.nick = nick
+
+        self.add_event_handler("session_start", self.start)
+        self.add_event_handler("groupchat_message", self.muc_message)
+        self.add_event_handler("muc::%s::got_online" % self.room,
+                               self.muc_online)
+
+Now all that's left to do is to greet them:
+
+.. code-block:: python
+
+    def muc_online(self, presence):
+        if presence['muc']['nick'] != self.nick:
+            self.send_message(mto=presence['from'].bare,
+                              mbody="Hello, %s %s" % (presence['muc']['role'],
+                                                      presence['muc']['nick']),
+                              mtype='groupchat')
+
+.. [1] this is similar to the :term:`got_online` event and is sent by
+       the xep_0045 plugin whenever a member joins the referenced
+       MUC chat room.
+
+
+Final Product
+-------------
+
+.. compound::
+
+    The final step is to create a small runner script for initialising our ``MUCBot`` class and adding some
+    basic configuration options. By following the basic boilerplate pattern in :ref:`echobot`, we arrive
+    at the code below. To experiment with this example, you can use:
+
+    .. code-block:: sh
+
+            python muc.py -d -j jid@example.com -r room@muc.example.net -n lurkbot
+
+    which will prompt for the password, log in, and join the group chat. To test, open
+    your regular IM client and join the same group chat that you sent the bot to. You
+    will see ``lurkbot`` as one of the members in the group chat, and that it greeted
+    you upon entry. Send a message with the string "lurkbot" inside the body text, and you
+    will also see that it responds with our pre-programmed customized message.
+
+.. include:: ../../examples/muc.py
+    :literal:

docs/index.rst

@@ -13,7 +13,7 @@ SleekXMPP
     ``develop`` branch.
 
     **Latest Stable Release**
-        - `1.0 RC3 <http://github.com/fritzy/SleekXMPP/zipball/1.0-RC3>`_  
+        - `1.0 <http://github.com/fritzy/SleekXMPP/zipball/1.0>`_
 
     **Develop Releases**
         - `Latest Develop Version <http://github.com/fritzy/SleekXMPP/zipball/develop>`_
@@ -59,6 +59,72 @@ SleekXMPP's design goals and philosphy are:
     sensible defaults and appropriate abstractions. XML can be ugly to work
     with, but it doesn't have to be that way.
 
+Here's your first SleekXMPP Bot:
+--------------------------------
+
+.. code-block:: python
+
+    import logging
+
+    from sleekxmpp import ClientXMPP
+    from sleekxmpp.exceptions import IqError, IqTimeout
+
+
+    class EchoBot(ClientXMPP):
+
+        def __init__(self, jid, password):
+            ClientXMPP.__init__(self, jid, password)
+
+            self.add_event_handler("session_start", self.session_start)
+            self.add_event_handler("message", self.message)
+
+            # If you wanted more functionality, here's how to register plugins:
+            # self.register_plugin('xep_0030') # Service Discovery
+            # self.register_plugin('xep_0199') # XMPP Ping
+
+            # Here's how to access plugins once you've registered them:
+            # self['xep_0030'].add_feature('echo_demo')
+
+            # If you are working with an OpenFire server, you will
+            # need to use a different SSL version:
+            # import ssl
+            # self.ssl_version = ssl.PROTOCOL_SSLv3
+
+        def session_start(self, event):
+            self.send_presence()
+            self.get_roster()
+
+            # Most get_*/set_* methods from plugins use Iq stanzas, which
+            # can generate IqError and IqTimeout exceptions
+            #
+            # try:
+            #     self.get_roster()
+            # except IqError as err:
+            #     logging.error('There was an error getting the roster')
+            #     logging.error(err.iq['error']['condition'])
+            #     self.disconnect()
+            # except IqTimeout:
+            #     logging.error('Server is taking too long to respond')
+            #     self.disconnect()
+
+        def message(self, msg):
+            if msg['type'] in ('chat', 'normal'):
+                msg.reply("Thanks for sending\n%(body)s" % msg).send()
+
+
+    if __name__ == '__main__':
+        # Ideally use optparse or argparse to get JID, 
+        # password, and log level.
+
+        logging.basicConfig(level=logging.DEBUG,
+                            format='%(levelname)-8s %(message)s')
+
+        xmpp = EchoBot('somejid@example.com', 'use_getpass')
+        xmpp.connect()
+        xmpp.process(block=True)
+
+
+
 Getting Started (with Examples)
 -------------------------------
 .. toctree::
@@ -156,17 +222,24 @@ Additional Info
 
 Credits
 -------
-**Main Author:** Nathan Fritz
-    `fritzy@netflint.net <xmpp:fritzy@netflint.net?message>`_, 
-    `@fritzy <http://twitter.com/fritzy>`_
 
-    Nathan is also the author of XMPPHP and `Seesmic-AS3-XMPP
-    <http://code.google.com/p/seesmic-as3-xmpp/>`_, and a member of the XMPP
-    Council.
+**Main Author:** `Nathan Fritz <http://andyet.net/team/fritzy>`_
+     `fritzy@netflint.net <xmpp:fritzy@netflint.net?message>`_,
+     `@fritzy <http://twitter.com/fritzy>`_
 
-**Co-Author:** Lance Stout
-    `lancestout@gmail.com <xmpp:lancestout@gmail.com?message>`_, 
-    `@lancestout <http://twitter.com/lancestout>`_
+     Nathan is also the author of XMPPHP and `Seesmic-AS3-XMPP
+     <http://code.google.com/p/seesmic-as3-xmpp/>`_, and a former member of the XMPP
+     Council.
+
+**Co-Author:** `Lance Stout <http://andyet.net/team/lance>`_
+     `lancestout@gmail.com <xmpp:lancestout@gmail.com?message>`_,
+     `@lancestout <http://twitter.com/lancestout>`_
+
+Both Fritzy and Lance work for `&yet <http://andyet.net>`_, which specializes in
+realtime web and XMPP applications.
+
+    - `contact@andyet.net <mailto:contact@andyet.net>`_
+    - `XMPP Consulting <http://xmppconsulting.com>`_
 
 **Contributors:**
     - Brian Beggs (`macdiesel <http://github.com/macdiesel>`_)

examples/custom_stanzas/custom_stanza_provider.py

@@ -0,0 +1,173 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""
+    SleekXMPP: The Sleek XMPP Library
+    Copyright (C) 2010  Nathanael C. Fritz
+    This file is part of SleekXMPP.
+
+    See the file LICENSE for copying permission.
+"""
+
+import sys
+import logging
+import getpass
+from optparse import OptionParser
+
+import sleekxmpp
+
+from sleekxmpp import ClientXMPP, Iq
+from sleekxmpp.exceptions import IqError, IqTimeout, XMPPError
+from sleekxmpp.xmlstream import register_stanza_plugin
+from sleekxmpp.xmlstream.handler import Callback
+from sleekxmpp.xmlstream.matcher import StanzaPath
+from stanza import Action
+
+# Python versions before 3.0 do not use UTF-8 encoding
+# by default. To ensure that Unicode is handled properly
+# throughout SleekXMPP, we will set the default encoding
+# ourselves to UTF-8.
+if sys.version_info < (3, 0):
+    reload(sys)
+    sys.setdefaultencoding('utf8')
+else:
+    raw_input = input
+
+
+class ActionBot(sleekxmpp.ClientXMPP):
+
+    """
+    A simple SleekXMPP bot that receives a custom stanza
+    from another client.
+    """
+
+    def __init__(self, jid, password):
+        sleekxmpp.ClientXMPP.__init__(self, jid, password)
+
+        # The session_start event will be triggered when
+        # the bot establishes its connection with the server
+        # and the XML streams are ready for use. We want to
+        # listen for this event so that we we can initialize
+        # our roster.
+        self.add_event_handler("session_start", self.start)
+
+        self.registerHandler(
+          Callback('Some custom iq',
+            StanzaPath('iq@type=set/action'),
+            self._handle_action))
+
+        self.add_event_handler('custom_action', 
+                self._handle_action_event, 
+                threaded=True)
+
+        register_stanza_plugin(Iq, Action)
+
+    def start(self, event):
+        """
+        Process the session_start event.
+
+        Typical actions for the session_start event are
+        requesting the roster and broadcasting an initial
+        presence stanza.
+
+        Arguments:
+            event -- An empty dictionary. The session_start
+                     event does not provide any additional
+                     data.
+        """
+        self.send_presence()
+        self.get_roster()
+
+    def _handle_action(self, iq):
+        """
+        Raise an event for the stanza so that it can be processed in its
+        own thread without blocking the main stanza processing loop.
+        """
+        self.event('custom_action', iq)
+
+    def _handle_action_event(self, iq):
+        """
+        Respond to the custom action event.
+
+        Since one of the actions is to disconnect, this
+        event handler needs to be run in threaded mode, by
+        using `threaded=True` in the `add_event_handler` call.
+        """
+        method = iq['action']['method']
+        param = iq['action']['param']
+
+        if method == 'is_prime' and param == '2':
+            print("got message: %s" % iq)
+            iq.reply()
+            iq['action']['status'] = 'done'
+            iq.send()
+        elif method == 'bye':
+            print("got message: %s" % iq)
+            self.disconnect()
+        else:
+            print("got message: %s" % iq)
+            iq.reply()
+            iq['action']['status'] = 'error'
+            iq.send()
+
+if __name__ == '__main__':
+    # Setup the command line arguments.
+    optp = OptionParser()
+
+    # Output verbosity options.
+    optp.add_option('-q', '--quiet', help='set logging to ERROR',
+                    action='store_const', dest='loglevel',
+                    const=logging.ERROR, default=logging.INFO)
+    optp.add_option('-d', '--debug', help='set logging to DEBUG',
+                    action='store_const', dest='loglevel',
+                    const=logging.DEBUG, default=logging.INFO)
+    optp.add_option('-v', '--verbose', help='set logging to COMM',
+                    action='store_const', dest='loglevel',
+                    const=5, default=logging.INFO)
+
+    # JID and password options.
+    optp.add_option("-j", "--jid", dest="jid",
+                    help="JID to use")
+    optp.add_option("-p", "--password", dest="password",
+                    help="password to use")
+
+    opts, args = optp.parse_args()
+
+    # Setup logging.
+    logging.basicConfig(level=opts.loglevel,
+                        format='%(levelname)-8s %(message)s')
+
+    if opts.jid is None:
+        opts.jid = raw_input("Username: ")
+    if opts.password is None:
+        opts.password = getpass.getpass("Password: ")
+
+    # Setup the CommandBot and register plugins. Note that while plugins may
+    # have interdependencies, the order in which you register them does
+    # not matter.
+    xmpp = ActionBot(opts.jid, opts.password)
+    xmpp.register_plugin('xep_0030') # Service Discovery
+    xmpp.register_plugin('xep_0004') # Data Forms
+    xmpp.register_plugin('xep_0050') # Adhoc Commands
+    xmpp.register_plugin('xep_0199', {'keepalive': True, 'frequency':15})
+
+    # If you are working with an OpenFire server, you may need
+    # to adjust the SSL version used:
+    # xmpp.ssl_version = ssl.PROTOCOL_SSLv3
+
+    # If you want to verify the SSL certificates offered by a server:
+    # xmpp.ca_certs = "path/to/ca/cert"
+
+    # Connect to the XMPP server and start processing XMPP stanzas.
+    if xmpp.connect():
+        # If you do not have the dnspython library installed, you will need
+        # to manually specify the name of the server if it does not match
+        # the one in the JID. For example, to use Google Talk you would
+        # need to use:
+        #
+        # if xmpp.connect(('talk.google.com', 5222)):
+        #     ...
+        xmpp.process(block=True)
+        print("Done")
+    else:
+        print("Unable to connect.")

examples/custom_stanzas/custom_stanza_user.py

@@ -0,0 +1,175 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""
+    SleekXMPP: The Sleek XMPP Library
+    Copyright (C) 2010  Nathanael C. Fritz
+    This file is part of SleekXMPP.
+
+    See the file LICENSE for copying permission.
+"""
+
+import sys
+import logging
+import getpass
+from optparse import OptionParser
+
+import sleekxmpp
+from sleekxmpp import Iq
+from sleekxmpp.exceptions import XMPPError
+from sleekxmpp.xmlstream import register_stanza_plugin
+
+from stanza import Action
+
+# Python versions before 3.0 do not use UTF-8 encoding
+# by default. To ensure that Unicode is handled properly
+# throughout SleekXMPP, we will set the default encoding
+# ourselves to UTF-8.
+if sys.version_info < (3, 0):
+    reload(sys)
+    sys.setdefaultencoding('utf8')
+else:
+    raw_input = input
+
+
+class ActionUserBot(sleekxmpp.ClientXMPP):
+
+    """
+    A simple SleekXMPP bot that sends a custom action stanza
+    to another client.
+    """
+
+    def __init__(self, jid, password, other):
+        sleekxmpp.ClientXMPP.__init__(self, jid, password)
+
+        self.action_provider = other
+
+        # The session_start event will be triggered when
+        # the bot establishes its connection with the server
+        # and the XML streams are ready for use. We want to
+        # listen for this event so that we we can initialize
+        # our roster.
+        self.add_event_handler("session_start", self.start, threaded=True)
+        self.add_event_handler("message", self.message)
+
+        register_stanza_plugin(Iq, Action)
+
+    def start(self, event):
+        """
+        Process the session_start event.
+
+        Typical actions for the session_start event are
+        requesting the roster and broadcasting an initial
+        presence stanza.
+
+        Arguments:
+            event -- An empty dictionary. The session_start
+                     event does not provide any additional
+                     data.
+        """
+        self.send_presence()
+        self.get_roster()
+
+        self.send_custom_iq()
+
+    def send_custom_iq(self):
+        """Create and send two custom actions.
+
+        If the first action was successful, then send
+        a shutdown command and then disconnect.
+        """
+        iq = self.Iq()
+        iq['to'] = self.action_provider
+        iq['type'] = 'set'
+        iq['action']['method'] = 'is_prime'
+        iq['action']['param'] = '2'
+
+        try:
+            resp = iq.send()
+            if resp['action']['status'] == 'done':
+                #sending bye
+                iq2 = self.Iq()
+                iq2['to'] = self.action_provider
+                iq2['type'] = 'set'
+                iq2['action']['method'] = 'bye'
+                iq2.send(block=False)
+            
+                # The wait=True delays the disconnect until the queue
+                # of stanzas to be sent becomes empty.
+                self.disconnect(wait=True)
+        except XMPPError:
+            print('There was an error sending the custom action.')
+
+    def message(self, msg):
+        """
+        Process incoming message stanzas.
+
+        Arguments:
+            msg -- The received message stanza.
+        """
+        logging.info(msg['body'])
+
+if __name__ == '__main__':
+    # Setup the command line arguments.
+    optp = OptionParser()
+
+    # Output verbosity options.
+    optp.add_option('-q', '--quiet', help='set logging to ERROR',
+                    action='store_const', dest='loglevel',
+                    const=logging.ERROR, default=logging.INFO)
+    optp.add_option('-d', '--debug', help='set logging to DEBUG',
+                    action='store_const', dest='loglevel',
+                    const=logging.DEBUG, default=logging.INFO)
+    optp.add_option('-v', '--verbose', help='set logging to COMM',
+                    action='store_const', dest='loglevel',
+                    const=5, default=logging.INFO)
+
+    # JID and password options.
+    optp.add_option("-j", "--jid", dest="jid",
+                    help="JID to use")
+    optp.add_option("-p", "--password", dest="password",
+                    help="password to use")
+    optp.add_option("-o", "--other", dest="other",
+                    help="JID providing custom stanza")
+
+    opts, args = optp.parse_args()
+
+    # Setup logging.
+    logging.basicConfig(level=opts.loglevel,
+                        format='%(levelname)-8s %(message)s')
+
+    if opts.jid is None:
+        opts.jid = raw_input("Username: ")
+    if opts.password is None:
+        opts.password = getpass.getpass("Password: ")
+    if opts.other is None:
+        opts.other = raw_input("JID Providing custom stanza: ")
+
+    # Setup the CommandBot and register plugins. Note that while plugins may
+    # have interdependencies, the order in which you register them does
+    # not matter.
+    xmpp = ActionUserBot(opts.jid, opts.password, opts.other)
+    xmpp.register_plugin('xep_0030') # Service Discovery
+    xmpp.register_plugin('xep_0004') # Data Forms
+    xmpp.register_plugin('xep_0050') # Adhoc Commands
+
+    # If you are working with an OpenFire server, you may need
+    # to adjust the SSL version used:
+    # xmpp.ssl_version = ssl.PROTOCOL_SSLv3
+
+    # If you want to verify the SSL certificates offered by a server:
+    # xmpp.ca_certs = "path/to/ca/cert"
+
+    # Connect to the XMPP server and start processing XMPP stanzas.
+    if xmpp.connect():
+        # If you do not have the dnspython library installed, you will need
+        # to manually specify the name of the server if it does not match
+        # the one in the JID. For example, to use Google Talk you would
+        # need to use:
+        #
+        # if xmpp.connect(('talk.google.com', 5222)):
+        #     ...
+        xmpp.process(block=True)
+        print("Done")
+    else:
+        print("Unable to connect.")

examples/custom_stanzas/stanza.py

@@ -0,0 +1,56 @@
+from sleekxmpp.xmlstream import ElementBase
+
+class Action(ElementBase):
+
+    """
+    A stanza class for XML content of the form:
+
+    <action xmlns="sleekxmpp:custom:actions">
+      <method>X</method>
+      <param>X</param>
+      <status>X</status>
+    </action>
+    """
+   
+    #: The `name` field refers to the basic XML tag name of the
+    #: stanza. Here, the tag name will be 'action'.
+    name = 'action'
+
+    #: The namespace of the main XML tag.
+    namespace = 'sleekxmpp:custom:actions'
+
+    #: The `plugin_attrib` value is the name that can be used
+    #: with a parent stanza to access this stanza. For example
+    #: from an Iq stanza object, accessing:
+    #: 
+    #:     iq['action']
+    #: 
+    #: would reference an Action object, and will even create
+    #: an Action object and append it to the Iq stanza if
+    #: one doesn't already exist.
+    plugin_attrib = 'action'
+
+    #: Stanza objects expose dictionary-like interfaces for
+    #: accessing and manipulating substanzas and other values.
+    #: The set of interfaces defined here are the names of
+    #: these dictionary-like interfaces provided by this stanza
+    #: type. For example, an Action stanza object can use:
+    #:
+    #:     action['method'] = 'foo'
+    #:     print(action['param'])
+    #:     del action['status']
+    #:
+    #: to set, get, or remove its values.
+    interfaces = set(('method', 'param', 'status'))
+
+    #: By default, values in the `interfaces` set are mapped to
+    #: attribute values. This can be changed such that an interface
+    #: maps to a subelement's text value by adding interfaces to
+    #: the sub_interfaces set. For example, here all interfaces
+    #: are marked as sub_interfaces, and so the XML produced will
+    #: look like:
+    #: 
+    #:     <action xmlns="sleekxmpp:custom:actions">
+    #:       <method>foo</method>
+    #:     </action>
+    sub_interfaces = interfaces

examples/disco_browser.py

@@ -62,7 +62,7 @@ class Disco(sleekxmpp.ClientXMPP):
         # and the XML streams are ready for use. We want to
         # listen for this event so that we we can initialize
         # our roster.
-        self.add_event_handler("session_start", self.start)
+        self.add_event_handler("session_start", self.start, threaded=True)
 
     def start(self, event):
         """

examples/muc.py

@@ -76,8 +76,8 @@ class MUCBot(sleekxmpp.ClientXMPP):
                      event does not provide any additional
                      data.
         """
-        self.getRoster()
-        self.sendPresence()
+        self.get_roster()
+        self.send_presence()
         self.plugin['xep_0045'].joinMUC(self.room,
                                         self.nick,
                                         # If a room password is needed, use:

examples/ping.py

@@ -45,7 +45,7 @@ class PingTest(sleekxmpp.ClientXMPP):
         # and the XML streams are ready for use. We want to
         # listen for this event so that we we can initialize
         # our roster.
-        self.add_event_handler("session_start", self.start)
+        self.add_event_handler("session_start", self.start, threaded=True)
 
     def start(self, event):
         """

examples/pubsub_client.py

@@ -0,0 +1,198 @@
+import sys
+import logging
+import getpass
+from optparse import OptionParser
+
+import sleekxmpp
+from sleekxmpp.xmlstream import ET, tostring
+
+
+# Python versions before 3.0 do not use UTF-8 encoding
+# by default. To ensure that Unicode is handled properly
+# throughout SleekXMPP, we will set the default encoding
+# ourselves to UTF-8.
+if sys.version_info < (3, 0):
+    reload(sys)
+    sys.setdefaultencoding('utf8')
+else:
+    raw_input = input
+
+
+class PubsubClient(sleekxmpp.ClientXMPP):
+
+    def __init__(self, jid, password, server, 
+                       node=None, action='list', data=''):
+        super(PubsubClient, self).__init__(jid, password)
+
+        self.register_plugin('xep_0030')
+        self.register_plugin('xep_0059')
+        self.register_plugin('xep_0060')
+
+        self.actions = ['nodes', 'create', 'delete', 
+                        'publish', 'get', 'retract',
+                        'purge', 'subscribe', 'unsubscribe']
+
+        self.action = action
+        self.node = node
+        self.data = data
+        self.pubsub_server = server
+
+        self.add_event_handler('session_start', self.start, threaded=True)
+
+    def start(self, event):
+        self.get_roster()
+        self.send_presence()
+
+        try:
+            getattr(self, self.action)()
+        except:
+            logging.error('Could not execute: %s' % self.action)
+        self.disconnect()
+
+    def nodes(self):
+        try:
+            result = self['xep_0060'].get_nodes(self.pubsub_server, self.node)
+            for item in result['disco_items']['items']:
+                print('  - %s' % str(item))
+        except:
+            logging.error('Could not retrieve node list.')
+
+    def create(self):
+        try:
+            self['xep_0060'].create_node(self.pubsub_server, self.node)
+        except:
+            logging.error('Could not create node: %s' % self.node)
+
+    def delete(self):
+        try:
+            self['xep_0060'].delete_node(self.pubsub_server, self.node)
+            print('Deleted node: %s' % self.node)
+        except:
+            logging.error('Could not delete node: %s' % self.node)
+
+    def publish(self):
+        payload = ET.fromstring("<test xmlns='test'>%s</test>" % self.data)
+        try:
+            result = self['xep_0060'].publish(self.pubsub_server, self.node, payload=payload)
+            id = result['pubsub']['publish']['item']['id']
+            print('Published at item id: %s' % id)
+        except:
+            logging.error('Could not publish to: %s' % self.node)
+
+    def get(self):
+        try:
+            result = self['xep_0060'].get_item(self.pubsub_server, self.node, self.data)
+            for item in result['pubsub']['items']['substanzas']:
+                print('Retrieved item %s: %s' % (item['id'], tostring(item['payload'])))
+        except:
+            logging.error('Could not retrieve item %s from node %s' % (self.data, self.node))
+
+    def retract(self):
+        try:
+            result = self['xep_0060'].retract(self.pubsub_server, self.node, self.data)
+            print('Retracted item %s from node %s' % (self.data, self.node))
+        except:
+            logging.error('Could not retract item %s from node %s' % (self.data, self.node))
+
+    def purge(self):
+        try:
+            result = self['xep_0060'].purge(self.pubsub_server, self.node)
+            print('Purged all items from node %s' % self.node)
+        except:
+            logging.error('Could not purge items from node %s' % self.node)
+
+    def subscribe(self):
+        try:
+            result = self['xep_0060'].subscribe(self.pubsub_server, self.node)
+            print('Subscribed %s to node %s' % (self.boundjid.bare, self.node))
+        except:
+            logging.error('Could not subscribe %s to node %s' % (self.boundjid.bare, self.node))
+
+    def unsubscribe(self):
+        try:
+            result = self['xep_0060'].unsubscribe(self.pubsub_server, self.node)
+            print('Unsubscribed %s from node %s' % (self.boundjid.bare, self.node))
+        except:
+            logging.error('Could not unsubscribe %s from node %s' % (self.boundjid.bare, self.node))
+
+
+
+
+if __name__ == '__main__':
+    # Setup the command line arguments.
+    optp = OptionParser()
+    optp.version = '%%prog 0.1'
+    optp.usage = "Usage: %%prog [options] <jid> " + \
+                             'nodes|create|delete|purge|subscribe|unsubscribe|publish|retract|get' + \
+                             ' [<node> <data>]'
+
+    optp.add_option('-q','--quiet', help='set logging to ERROR',
+                    action='store_const',
+                    dest='loglevel',
+                    const=logging.ERROR,
+                    default=logging.ERROR)
+    optp.add_option('-d','--debug', help='set logging to DEBUG',
+                    action='store_const',
+                    dest='loglevel',
+                    const=logging.DEBUG,
+                    default=logging.ERROR)
+    optp.add_option('-v','--verbose', help='set logging to COMM',
+                    action='store_const',
+                    dest='loglevel',
+                    const=5,
+                    default=logging.ERROR)
+
+    # JID and password options.
+    optp.add_option("-j", "--jid", dest="jid",
+                    help="JID to use")
+    optp.add_option("-p", "--password", dest="password",
+                    help="password to use")
+    opts,args = optp.parse_args()
+
+    # Setup logging.
+    logging.basicConfig(level=opts.loglevel,
+                        format='%(levelname)-8s %(message)s')
+
+    if len(args) < 2:
+        optp.print_help()
+        exit()
+
+    if opts.jid is None:
+        opts.jid = raw_input("Username: ")
+    if opts.password is None:
+        opts.password = getpass.getpass("Password: ")
+
+    if len(args) == 2:
+        args = (args[0], args[1], '', '', '')
+    elif len(args) == 3:
+        args = (args[0], args[1], args[2], '', '')
+    elif len(args) == 4:
+        args = (args[0], args[1], args[2], args[3], '')
+
+
+    # Setup the Pubsub client
+    xmpp = PubsubClient(opts.jid, opts.password,
+                        server=args[0],
+                        node=args[2],
+                        action=args[1],
+                        data=args[3])
+
+    # If you are working with an OpenFire server, you may need
+    # to adjust the SSL version used:
+    # xmpp.ssl_version = ssl.PROTOCOL_SSLv3
+
+    # If you want to verify the SSL certificates offered by a server:
+    # xmpp.ca_certs = "path/to/ca/cert"
+
+    # Connect to the XMPP server and start processing XMPP stanzas.
+    if xmpp.connect():
+        # If you do not have the dnspython library installed, you will need
+        # to manually specify the name of the server if it does not match
+        # the one in the JID. For example, to use Google Talk you would
+        # need to use:
+        #
+        # if xmpp.connect(('talk.google.com', 5222)):
+        #     ...
+        xmpp.process(block=True)
+    else:
+        print("Unable to connect.")

examples/pubsub_events.py

@@ -0,0 +1,151 @@
+import sys
+import logging
+import getpass
+from optparse import OptionParser
+
+import sleekxmpp
+from sleekxmpp.xmlstream import ET, tostring
+from sleekxmpp.xmlstream.matcher import StanzaPath
+from sleekxmpp.xmlstream.handler import Callback
+
+
+# Python versions before 3.0 do not use UTF-8 encoding
+# by default. To ensure that Unicode is handled properly
+# throughout SleekXMPP, we will set the default encoding
+# ourselves to UTF-8.
+if sys.version_info < (3, 0):
+    reload(sys)
+    sys.setdefaultencoding('utf8')
+else:
+    raw_input = input
+
+
+class PubsubEvents(sleekxmpp.ClientXMPP):
+
+    def __init__(self, jid, password):
+        super(PubsubEvents, self).__init__(jid, password)
+
+        self.register_plugin('xep_0030')
+        self.register_plugin('xep_0059')
+        self.register_plugin('xep_0060')
+
+        self.add_event_handler('session_start', self.start)
+
+        # Some services may require configuration to allow
+        # sending delete, configuration, or subscription  events.
+        self.add_event_handler('pubsub_publish', self._publish)
+        self.add_event_handler('pubsub_retract', self._retract)
+        self.add_event_handler('pubsub_purge', self._purge)
+        self.add_event_handler('pubsub_delete', self._delete)
+        self.add_event_handler('pubsub_config', self._config)
+        self.add_event_handler('pubsub_subscription', self._subscription)
+
+        # Want to use nicer, more specific pubsub event names?
+        # self['xep_0060'].map_node_event('node_name', 'event_prefix')
+        # self.add_event_handler('event_prefix_publish', handler)
+        # self.add_event_handler('event_prefix_retract', handler)
+        # self.add_event_handler('event_prefix_purge', handler)
+        # self.add_event_handler('event_prefix_delete', handler)
+
+    def start(self, event):
+        self.get_roster()
+        self.send_presence()
+
+    def _publish(self, msg):
+        """Handle receiving a publish item event."""
+        print('Published item %s to %s:' % (
+            msg['pubsub_event']['items']['item']['id'],
+            msg['pubsub_event']['items']['node']))
+        data = msg['pubsub_event']['items']['item']['payload']
+        if data is not None:
+            print(tostring(data))
+        else:
+            print('No item content')
+
+    def _retract(self, msg):
+        """Handle receiving a retract item event."""
+        print('Retracted item %s from %s' % (
+            msg['pubsub_event']['items']['retract']['id'],
+            msg['pubsub_event']['items']['node']))
+
+    def _purge(self, msg):
+        """Handle receiving a node purge event."""
+        print('Purged all items from %s' % (
+            msg['pubsub_event']['purge']['node']))
+
+    def _delete(self, msg):
+        """Handle receiving a node deletion event."""
+        print('Deleted node %s' % (
+           msg['pubsub_event']['delete']['node']))
+ 
+    def _config(self, msg):
+        """Handle receiving a node configuration event."""
+        print('Configured node %s:' % (
+            msg['pubsub_event']['configuration']['node']))
+        print(msg['pubsub_event']['configuration']['form'])
+
+    def _subscription(self, msg):
+        """Handle receiving a node subscription event."""
+        print('Subscription change for node %s:' % (
+            msg['pubsub_event']['subscription']['node']))
+        print(msg['pubsub_event']['subscription'])
+
+
+if __name__ == '__main__':
+    # Setup the command line arguments.
+    optp = OptionParser()
+
+    # Output verbosity options.
+    optp.add_option('-q', '--quiet', help='set logging to ERROR',
+                    action='store_const', dest='loglevel',
+                    const=logging.ERROR, default=logging.INFO)
+    optp.add_option('-d', '--debug', help='set logging to DEBUG',
+                    action='store_const', dest='loglevel',
+                    const=logging.DEBUG, default=logging.INFO)
+    optp.add_option('-v', '--verbose', help='set logging to COMM',
+                    action='store_const', dest='loglevel',
+                    const=5, default=logging.INFO)
+
+    # JID and password options.
+    optp.add_option("-j", "--jid", dest="jid",
+                    help="JID to use")
+    optp.add_option("-p", "--password", dest="password",
+                    help="password to use")
+
+    opts, args = optp.parse_args()
+
+    # Setup logging.
+    logging.basicConfig(level=opts.loglevel,
+                        format='%(levelname)-8s %(message)s')
+
+    if opts.jid is None:
+        opts.jid = raw_input("Username: ")
+    if opts.password is None:
+        opts.password = getpass.getpass("Password: ")
+
+    logging.info("Run this in conjunction with the pubsub_client.py " + \
+                 "example to watch events happen as you give commands.")
+
+    # Setup the PubsubEvents listener
+    xmpp = PubsubEvents(opts.jid, opts.password)
+
+    # If you are working with an OpenFire server, you may need
+    # to adjust the SSL version used:
+    # xmpp.ssl_version = ssl.PROTOCOL_SSLv3
+
+    # If you want to verify the SSL certificates offered by a server:
+    # xmpp.ca_certs = "path/to/ca/cert"
+
+    # Connect to the XMPP server and start processing XMPP stanzas.
+    if xmpp.connect():
+        # If you do not have the dnspython library installed, you will need
+        # to manually specify the name of the server if it does not match
+        # the one in the JID. For example, to use Google Talk you would
+        # need to use:
+        #
+        # if xmpp.connect(('talk.google.com', 5222)):
+        #     ...
+        xmpp.process(block=True)
+        print("Done")
+    else:
+        print("Unable to connect.")

examples/register_account.py

@@ -0,0 +1,175 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""
+    SleekXMPP: The Sleek XMPP Library
+    Copyright (C) 2010  Nathanael C. Fritz
+    This file is part of SleekXMPP.
+
+    See the file LICENSE for copying permission.
+"""
+
+import sys
+import logging
+import getpass
+from optparse import OptionParser
+
+import sleekxmpp
+from sleekxmpp.exceptions import IqError, IqTimeout
+
+# Python versions before 3.0 do not use UTF-8 encoding
+# by default. To ensure that Unicode is handled properly
+# throughout SleekXMPP, we will set the default encoding
+# ourselves to UTF-8.
+if sys.version_info < (3, 0):
+    reload(sys)
+    sys.setdefaultencoding('utf8')
+else:
+    raw_input = input
+
+
+class RegisterBot(sleekxmpp.ClientXMPP):
+
+    """
+    A basic bot that will attempt to register an account
+    with an XMPP server.
+
+    NOTE: This follows the very basic registration workflow
+          from XEP-0077. More advanced server registration
+          workflows will need to check for data forms, etc.
+    """
+
+    def __init__(self, jid, password):
+        sleekxmpp.ClientXMPP.__init__(self, jid, password)
+
+        # The session_start event will be triggered when
+        # the bot establishes its connection with the server
+        # and the XML streams are ready for use. We want to
+        # listen for this event so that we we can initialize
+        # our roster.
+        self.add_event_handler("session_start", self.start, threaded=True)
+
+        # The register event provides an Iq result stanza with
+        # a registration form from the server. This may include
+        # the basic registration fields, a data form, an 
+        # out-of-band URL, or any combination. For more advanced
+        # cases, you will need to examine the fields provided
+        # and respond accordingly. SleekXMPP provides plugins
+        # for data forms and OOB links that will make that easier.
+        self.add_event_handler("register", self.register, threaded=True)
+
+    def start(self, event):
+        """
+        Process the session_start event.
+
+        Typical actions for the session_start event are
+        requesting the roster and broadcasting an initial
+        presence stanza.
+
+        Arguments:
+            event -- An empty dictionary. The session_start
+                     event does not provide any additional
+                     data.
+        """
+        self.send_presence()
+        self.get_roster()
+
+        # We're only concerned about registering, so nothing more to do here.
+        self.disconnect()
+
+    def register(self, iq):
+        """
+        Fill out and submit a registration form.
+
+        The form may be composed of basic registration fields, a data form,
+        an out-of-band link, or any combination thereof. Data forms and OOB
+        links can be checked for as so:
+
+        if iq.match('iq/register/form'):
+            # do stuff with data form
+            # iq['register']['form']['fields']
+        if iq.match('iq/register/oob'):
+            # do stuff with OOB URL
+            # iq['register']['oob']['url']
+
+        To get the list of basic registration fields, you can use:
+            iq['register']['fields']
+        """
+        resp = self.Iq()
+        resp['type'] = 'set'
+        resp['register']['username'] = self.boundjid.user
+        resp['register']['password'] = self.password
+
+        try:
+            resp.send(now=True)
+            logging.info("Account created for %s!" % self.boundjid)
+        except IqError as e:
+            logging.error("Could not register account: %s" % 
+                    e.iq['error']['text'])
+            self.disconnect()
+        except IqTimeout:
+            logging.error("No response from server.")
+            self.disconnect()
+
+
+if __name__ == '__main__':
+    # Setup the command line arguments.
+    optp = OptionParser()
+
+    # Output verbosity options.
+    optp.add_option('-q', '--quiet', help='set logging to ERROR',
+                    action='store_const', dest='loglevel',
+                    const=logging.ERROR, default=logging.INFO)
+    optp.add_option('-d', '--debug', help='set logging to DEBUG',
+                    action='store_const', dest='loglevel',
+                    const=logging.DEBUG, default=logging.INFO)
+    optp.add_option('-v', '--verbose', help='set logging to COMM',
+                    action='store_const', dest='loglevel',
+                    const=5, default=logging.INFO)
+
+    # JID and password options.
+    optp.add_option("-j", "--jid", dest="jid",
+                    help="JID to use")
+    optp.add_option("-p", "--password", dest="password",
+                    help="password to use")
+
+    opts, args = optp.parse_args()
+
+    # Setup logging.
+    logging.basicConfig(level=opts.loglevel,
+                        format='%(levelname)-8s %(message)s')
+
+    if opts.jid is None:
+        opts.jid = raw_input("Username: ")
+    if opts.password is None:
+        opts.password = getpass.getpass("Password: ")
+
+    # Setup the RegisterBot and register plugins. Note that while plugins may
+    # have interdependencies, the order in which you register them does
+    # not matter.
+    xmpp = RegisterBot(opts.jid, opts.password)
+    xmpp.register_plugin('xep_0030') # Service Discovery
+    xmpp.register_plugin('xep_0004') # Data forms
+    xmpp.register_plugin('xep_0066') # Out-of-band Data
+    xmpp.register_plugin('xep_0077') # In-band Registration
+
+    # If you are working with an OpenFire server, you may need
+    # to adjust the SSL version used:
+    # xmpp.ssl_version = ssl.PROTOCOL_SSLv3
+
+    # If you want to verify the SSL certificates offered by a server:
+    # xmpp.ca_certs = "path/to/ca/cert"
+
+    # Connect to the XMPP server and start processing XMPP stanzas.
+    if xmpp.connect():
+        # If you do not have the dnspython library installed, you will need
+        # to manually specify the name of the server if it does not match
+        # the one in the JID. For example, to use Google Talk you would
+        # need to use:
+        #
+        # if xmpp.connect(('talk.google.com', 5222)):
+        #     ...
+        xmpp.process(block=True)
+        print("Done")
+    else:
+        print("Unable to connect.")

examples/rpc_client_side.py

@@ -16,7 +16,7 @@ class Thermostat(Endpoint):
     def FQN(self):
         return 'thermostat'
     
-    def __init(self, initial_temperature):
+    def __init__(self, initial_temperature):
         self._temperature = initial_temperature
         self._event = threading.Event()        
     
@@ -50,4 +50,4 @@ def main():
     
 if __name__ == '__main__':
     main()
-    
+    

examples/rpc_server_side.py

@@ -15,7 +15,7 @@ class Thermostat(Endpoint):
     def FQN(self):
         return 'thermostat'
     
-    def __init(self, initial_temperature):
+    def __init__(self, initial_temperature):
         self._temperature = initial_temperature
         self._event = threading.Event()        
     
@@ -49,4 +49,4 @@ def main():
     
 if __name__ == '__main__':
     main()
-    
+    

examples/send_client.py

@@ -47,7 +47,7 @@ class SendMsgBot(sleekxmpp.ClientXMPP):
         # and the XML streams are ready for use. We want to
         # listen for this event so that we we can initialize
         # our roster.
-        self.add_event_handler("session_start", self.start)
+        self.add_event_handler("session_start", self.start, threaded=True)
 
     def start(self, event):
         """

examples/thirdparty_auth.py

@@ -0,0 +1,247 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""
+    SleekXMPP: The Sleek XMPP Library
+    Copyright (C) 2010  Nathanael C. Fritz
+    This file is part of SleekXMPP.
+
+    See the file LICENSE for copying permission.
+"""
+
+import sys
+import logging
+import getpass
+from optparse import OptionParser
+
+try:
+    from httplib import HTTPSConnection
+    from urllib import urlencode
+except ImportError:
+    from urllib.parse import urlencode
+    from http.client import HTTPSConnection
+
+import sleekxmpp
+from sleekxmpp.xmlstream import JID
+
+# Python versions before 3.0 do not use UTF-8 encoding
+# by default. To ensure that Unicode is handled properly
+# throughout SleekXMPP, we will set the default encoding
+# ourselves to UTF-8.
+if sys.version_info < (3, 0):
+    reload(sys)
+    sys.setdefaultencoding('utf8')
+else:
+    raw_input = input
+
+
+class ThirdPartyAuthBot(sleekxmpp.ClientXMPP):
+
+    """
+    A simple SleekXMPP bot that will echo messages it
+    receives, along with a short thank you message.
+
+    This version uses a thirdpary service for authentication,
+    such as Facebook or Google.
+    """
+
+    def __init__(self, jid, password):
+        sleekxmpp.ClientXMPP.__init__(self, jid, password)
+
+        # The X-GOOGLE-TOKEN mech is ranked lower than PLAIN
+        # due to Google only allowing a single SASL attempt per
+        # connection. So PLAIN will be used for TLS connections,
+        # and X-GOOGLE-TOKEN for non-TLS connections. To use
+        # X-GOOGLE-TOKEN with a TLS connection, explicitly select
+        # it using:
+        #
+        # sleekxmpp.ClientXMPP.__init__(self, jid, password,
+        #                               sasl_mech="X-GOOGLE-TOKEN")
+
+        # The session_start event will be triggered when
+        # the bot establishes its connection with the server
+        # and the XML streams are ready for use. We want to
+        # listen for this event so that we we can initialize
+        # our roster.
+        self.add_event_handler("session_start", self.start)
+
+        # The message event is triggered whenever a message
+        # stanza is received. Be aware that that includes
+        # MUC messages and error messages.
+        self.add_event_handler("message", self.message)
+
+    def start(self, event):
+        """
+        Process the session_start event.
+
+        Typical actions for the session_start event are
+        requesting the roster and broadcasting an initial
+        presence stanza.
+
+        Arguments:
+            event -- An empty dictionary. The session_start
+                     event does not provide any additional
+                     data.
+        """
+        self.send_presence()
+        self.get_roster()
+
+    def message(self, msg):
+        """
+        Process incoming message stanzas. Be aware that this also
+        includes MUC messages and error messages. It is usually
+        a good idea to check the messages's type before processing
+        or sending replies.
+
+        Arguments:
+            msg -- The received message stanza. See the documentation
+                   for stanza objects and the Message stanza to see
+                   how it may be used.
+        """
+        if msg['type'] in ('chat', 'normal'):
+            msg.reply("Thanks for sending\n%(body)s" % msg).send()
+
+
+if __name__ == '__main__':
+    # Setup the command line arguments.
+    optp = OptionParser()
+
+    # Output verbosity options.
+    optp.add_option('-q', '--quiet', help='set logging to ERROR',
+                    action='store_const', dest='loglevel',
+                    const=logging.ERROR, default=logging.INFO)
+    optp.add_option('-d', '--debug', help='set logging to DEBUG',
+                    action='store_const', dest='loglevel',
+                    const=logging.DEBUG, default=logging.INFO)
+    optp.add_option('-v', '--verbose', help='set logging to COMM',
+                    action='store_const', dest='loglevel',
+                    const=5, default=logging.INFO)
+
+    # JID and password options.
+    optp.add_option("-j", "--jid", dest="jid",
+                    help="JID to use")
+    optp.add_option("-p", "--password", dest="password",
+                    help="password to use")
+
+    opts, args = optp.parse_args()
+
+    # Setup logging.
+    logging.basicConfig(level=opts.loglevel,
+                        format='%(levelname)-8s %(message)s')
+
+    if opts.jid is None:
+        opts.jid = raw_input("Username: ")
+    if opts.password is None:
+        opts.password = getpass.getpass("Password: ")
+
+    
+    access_token = None
+
+    # Since documentation on how to work with Google tokens
+    # can be difficult to find, we'll demo a basic version
+    # here. Note that responses could refer to a Captcha
+    # URL that would require a browser.
+
+    # Using Facebook or MSN's custom authentication requires
+    # a browser, but the process is the same once a token
+    # has been retrieved.
+
+    # Request an access token from Google:
+    try:
+        conn = HTTPSConnection('www.google.com')
+    except:
+        print('Could not connect to Google')
+        sys.exit()
+
+    params = urlencode({
+        'accountType': 'GOOGLE',
+        'service': 'mail',
+        'Email': JID(opts.jid).bare,
+        'Passwd': opts.password
+    })
+    headers = {
+        'Content-Type': 'application/x-www-form-urlencoded' 
+    }
+    try:
+        conn.request('POST', '/accounts/ClientLogin', params, headers)
+        resp = conn.getresponse().read()
+        data = {}
+        for line in resp.split():
+            k, v = line.split(b'=', 1)
+            data[k] = v
+    except Exception as e:
+        print('Could not retrieve login data')
+        sys.exit()
+
+    if b'SID' not in data:
+        print('Required data not found')
+        sys.exit()
+
+
+    params = urlencode({
+        'SID': data[b'SID'],
+        'LSID': data[b'LSID'],
+        'service': 'mail'
+    })
+    try:
+        conn.request('POST', '/accounts/IssueAuthToken', params, headers)
+        resp = conn.getresponse()
+        data = resp.read().split()
+    except:
+        print('Could not retrieve auth data')
+        sys.exit()
+
+    if not data:
+        print('Could not retrieve token')
+        sys.exit()
+
+    access_token = data[0]
+
+
+    # Setup the ThirdPartyAuthBot and register plugins. Note that while plugins
+    # may have interdependencies, the order in which you register them does not
+    # matter.
+
+    # If using MSN, the JID should be "user@messenger.live.com", which will
+    # be overridden on session bind.
+
+    # We're using an access token instead of a password, so we'll use `''` as
+    # a password argument filler.
+
+    xmpp = ThirdPartyAuthBot(opts.jid, '')  
+    xmpp.credentials['access_token'] = access_token
+
+    # The credentials dictionary is used to provide additional authentication
+    # information beyond just a password.
+    
+    xmpp.register_plugin('xep_0030') # Service Discovery
+    xmpp.register_plugin('xep_0004') # Data Forms
+    xmpp.register_plugin('xep_0060') # PubSub
+
+    # MSN will kill connections that have been inactive for even
+    # short periods of time. So use pings to keep the session alive;
+    # whitespace keepalives do not work.
+    xmpp.register_plugin('xep_0199', {'keepalive': True, 'frequency': 60})
+
+    # If you are working with an OpenFire server, you may need
+    # to adjust the SSL version used:
+    # xmpp.ssl_version = ssl.PROTOCOL_SSLv3
+
+    # If you want to verify the SSL certificates offered by a server:
+    # xmpp.ca_certs = "path/to/ca/cert"
+
+    # Connect to the XMPP server and start processing XMPP stanzas.
+    # Google only allows one SASL attempt per connection, so in order to 
+    # enable the X-GOOGLE-TOKEN mechanism, we'll disable TLS.
+    if xmpp.connect(use_tls=False):
+        # If you do not have the dnspython library installed, you will need
+        # to manually specify the name of the server if it does not match
+        # the one in the JID. For example, to use Google Talk you would
+        # need to use:
+        #
+        # if xmpp.connect(('talk.google.com', 5222)):
+        #     ...
+        xmpp.process(block=True)
+        print("Done")
+    else:
+        print("Unable to connect.")

examples/user_location.py

@@ -0,0 +1,125 @@
+#!/usr/bin/env python
+
+import sys
+import logging
+import getpass
+from optparse import OptionParser
+
+try:
+    import json
+except ImportError:
+    import simplejson as json
+
+try:
+    import requests
+except ImportError:
+    print('This demo requires the requests package for using HTTP.')
+    sys.exit()
+
+from sleekxmpp import ClientXMPP
+
+
+class LocationBot(ClientXMPP):
+
+    def __init__(self, jid, password):
+        super(LocationBot, self).__init__(jid, password)
+
+        self.add_event_handler('session_start', self.start, threaded=True)
+        self.add_event_handler('user_location_publish', 
+                               self.user_location_publish)
+
+        self.register_plugin('xep_0004')
+        self.register_plugin('xep_0030')
+        self.register_plugin('xep_0060')
+        self.register_plugin('xep_0115')
+        self.register_plugin('xep_0128')
+        self.register_plugin('xep_0163')
+        self.register_plugin('xep_0080')
+
+        self.current_tune = None
+
+    def start(self, event):
+        self.send_presence()
+        self.get_roster()
+        self['xep_0115'].update_caps()
+
+        print("Using freegeoip.net to get geolocation.")
+        r = requests.get('http://freegeoip.net/json/')
+        try:
+            data = json.loads(r.text)
+        except:
+            print("Could not retrieve user location.")
+            self.disconnect()
+            return
+
+        self['xep_0080'].publish_location(
+                lat=data['latitude'],
+                lon=data['longitude'],
+                locality=data['city'],
+                region=data['region_name'],
+                country=data['country_name'],
+                countrycode=data['country_code'],
+                postalcode=data['zipcode'])
+
+    def user_location_publish(self, msg):
+        geo = msg['pubsub_event']['items']['item']['geoloc']
+        print("%s is at:" % msg['from'])
+        for key, val in geo.values.items():
+            if val:
+                print("  %s: %s" % (key, val))
+
+
+if __name__ == '__main__':
+    # Setup the command line arguments.
+    optp = OptionParser()
+
+    # Output verbosity options.
+    optp.add_option('-q', '--quiet', help='set logging to ERROR',
+                    action='store_const', dest='loglevel',
+                    const=logging.ERROR, default=logging.INFO)
+    optp.add_option('-d', '--debug', help='set logging to DEBUG',
+                    action='store_const', dest='loglevel',
+                    const=logging.DEBUG, default=logging.INFO)
+    optp.add_option('-v', '--verbose', help='set logging to COMM',
+                    action='store_const', dest='loglevel',
+                    const=5, default=logging.INFO)
+
+    # JID and password options.
+    optp.add_option("-j", "--jid", dest="jid",
+                    help="JID to use")
+    optp.add_option("-p", "--password", dest="password",
+                    help="password to use")
+
+    opts, args = optp.parse_args()
+
+    # Setup logging.
+    logging.basicConfig(level=opts.loglevel,
+                        format='%(levelname)-8s %(message)s')
+
+    if opts.jid is None:
+        opts.jid = raw_input("Username: ")
+    if opts.password is None:
+        opts.password = getpass.getpass("Password: ")
+
+    xmpp = LocationBot(opts.jid, opts.password)
+
+    # If you are working with an OpenFire server, you may need
+    # to adjust the SSL version used:
+    # xmpp.ssl_version = ssl.PROTOCOL_SSLv3
+
+    # If you want to verify the SSL certificates offered by a server:
+    # xmpp.ca_certs = "path/to/ca/cert"
+
+    # Connect to the XMPP server and start processing XMPP stanzas.
+    if xmpp.connect():
+        # If you do not have the dnspython library installed, you will need
+        # to manually specify the name of the server if it does not match
+        # the one in the JID. For example, to use Google Talk you would
+        # need to use:
+        #
+        # if xmpp.connect(('talk.google.com', 5222)):
+        #     ...
+        xmpp.process(block=True)
+        print("Done")
+    else:
+        print("Unable to connect.")

examples/user_tune.py

@@ -0,0 +1,137 @@
+#!/usr/bin/env python
+
+import sys
+import logging
+import getpass
+from optparse import OptionParser
+
+try:
+    from appscript import *
+except ImportError:
+    print('This demo requires the appscript package to interact with iTunes.')
+    sys.exit()
+
+from sleekxmpp import ClientXMPP
+
+
+class TuneBot(ClientXMPP):
+
+    def __init__(self, jid, password):
+        super(TuneBot, self).__init__(jid, password)
+
+        # Check for the current song every 5 seconds.
+        self.schedule('Check Current Tune', 5, self._update_tune, repeat=True)
+
+        self.add_event_handler('session_start', self.start)
+        self.add_event_handler('user_tune_publish', self.user_tune_publish)
+
+        self.register_plugin('xep_0004')
+        self.register_plugin('xep_0030')
+        self.register_plugin('xep_0060')
+        self.register_plugin('xep_0115')
+        self.register_plugin('xep_0118')
+        self.register_plugin('xep_0128')
+        self.register_plugin('xep_0163')
+
+        self.current_tune = None
+
+    def start(self, event):
+        self.send_presence()
+        self.get_roster()
+        self['xep_0115'].update_caps()
+
+    def _update_tune(self):
+        itunes_count = app('System Events').processes[its.name == 'iTunes'].count()
+        if itunes_count > 0:
+            iTunes = app('iTunes')
+            if iTunes.player_state.get() == k.playing:
+                track = iTunes.current_track.get()
+                length = track.time.get()
+                if ':' in length:
+                    minutes, secs = map(int, length.split(':'))
+                    secs += minutes * 60
+                else:
+                    secs = int(length)
+
+                artist = track.artist.get()
+                title = track.name.get()
+                source = track.album.get()
+                rating = track.rating.get() / 10
+
+                tune = (artist, secs, rating, source, title)
+                if tune != self.current_tune:
+                    self.current_tune = tune
+
+                    # We have a new song playing, so publish it.
+                    self['xep_0118'].publish_tune(
+                            artist=artist,
+                            length=secs,
+                            title=title,
+                            rating=rating,
+                            source=source)
+            else:
+                # No song is playing, clear the user tune.
+                tune = None
+                if tune != self.current_tune:
+                    self.current_tune = tune
+                    self['xep_0118'].stop()
+
+    def user_tune_publish(self, msg):
+        tune = msg['pubsub_event']['items']['item']['tune']
+        print("%s is listening to: %s" % (msg['from'], tune['title']))
+
+
+if __name__ == '__main__':
+    # Setup the command line arguments.
+    optp = OptionParser()
+
+    # Output verbosity options.
+    optp.add_option('-q', '--quiet', help='set logging to ERROR',
+                    action='store_const', dest='loglevel',
+                    const=logging.ERROR, default=logging.INFO)
+    optp.add_option('-d', '--debug', help='set logging to DEBUG',
+                    action='store_const', dest='loglevel',
+                    const=logging.DEBUG, default=logging.INFO)
+    optp.add_option('-v', '--verbose', help='set logging to COMM',
+                    action='store_const', dest='loglevel',
+                    const=5, default=logging.INFO)
+
+    # JID and password options.
+    optp.add_option("-j", "--jid", dest="jid",
+                    help="JID to use")
+    optp.add_option("-p", "--password", dest="password",
+                    help="password to use")
+
+    opts, args = optp.parse_args()
+
+    # Setup logging.
+    logging.basicConfig(level=opts.loglevel,
+                        format='%(levelname)-8s %(message)s')
+
+    if opts.jid is None:
+        opts.jid = raw_input("Username: ")
+    if opts.password is None:
+        opts.password = getpass.getpass("Password: ")
+
+    xmpp = TuneBot(opts.jid, opts.password)
+
+    # If you are working with an OpenFire server, you may need
+    # to adjust the SSL version used:
+    # xmpp.ssl_version = ssl.PROTOCOL_SSLv3
+
+    # If you want to verify the SSL certificates offered by a server:
+    # xmpp.ca_certs = "path/to/ca/cert"
+
+    # Connect to the XMPP server and start processing XMPP stanzas.
+    if xmpp.connect():
+        # If you do not have the dnspython library installed, you will need
+        # to manually specify the name of the server if it does not match
+        # the one in the JID. For example, to use Google Talk you would
+        # need to use:
+        #
+        # if xmpp.connect(('talk.google.com', 5222)):
+        #     ...
+        xmpp.process(block=True)
+        print("Done")
+    else:
+        print("Unable to connect.")

setup.py

@@ -8,6 +8,7 @@
 # file, which you should have received as part of this distribution.
 
 import sys
+import codecs
 try:
     from setuptools import setup, Command
 except ImportError:
@@ -31,7 +32,7 @@ from sleekxmpp.version import __version__
 
 VERSION          = __version__
 DESCRIPTION      = 'SleekXMPP is an elegant Python library for XMPP (aka Jabber, Google Talk, etc).'
-with open('README.rst') as readme:
+with codecs.open('README.rst', 'r', encoding='UTF-8') as readme:
     LONG_DESCRIPTION = ''.join(readme)
 
 CLASSIFIERS      = [ 'Intended Audience :: Developers',
@@ -56,22 +57,37 @@ packages     = [ 'sleekxmpp',
                  'sleekxmpp/plugins/xep_0004/stanza',
                  'sleekxmpp/plugins/xep_0009',
                  'sleekxmpp/plugins/xep_0009/stanza',
+                 'sleekxmpp/plugins/xep_0012',
+                 'sleekxmpp/plugins/xep_0027',
                  'sleekxmpp/plugins/xep_0030',
                  'sleekxmpp/plugins/xep_0030/stanza',
+                 'sleekxmpp/plugins/xep_0047',
                  'sleekxmpp/plugins/xep_0050',
+                 'sleekxmpp/plugins/xep_0054',
                  'sleekxmpp/plugins/xep_0059',
                  'sleekxmpp/plugins/xep_0060',
                  'sleekxmpp/plugins/xep_0060/stanza',
                  'sleekxmpp/plugins/xep_0066',
+                 'sleekxmpp/plugins/xep_0077',
                  'sleekxmpp/plugins/xep_0078',
+                 'sleekxmpp/plugins/xep_0080',
                  'sleekxmpp/plugins/xep_0085',
                  'sleekxmpp/plugins/xep_0086',
                  'sleekxmpp/plugins/xep_0092',
+                 'sleekxmpp/plugins/xep_0107',
+                 'sleekxmpp/plugins/xep_0108',
+                 'sleekxmpp/plugins/xep_0115',
+                 'sleekxmpp/plugins/xep_0118',
                  'sleekxmpp/plugins/xep_0128',
+                 'sleekxmpp/plugins/xep_0153',
+                 'sleekxmpp/plugins/xep_0172',
+                 'sleekxmpp/plugins/xep_0184',
+                 'sleekxmpp/plugins/xep_0198',
                  'sleekxmpp/plugins/xep_0199',
                  'sleekxmpp/plugins/xep_0202',
                  'sleekxmpp/plugins/xep_0203',
                  'sleekxmpp/plugins/xep_0224',
+                 'sleekxmpp/plugins/xep_0231',
                  'sleekxmpp/plugins/xep_0249',
                  'sleekxmpp/features',
                  'sleekxmpp/features/feature_mechanisms',
@@ -79,6 +95,7 @@ packages     = [ 'sleekxmpp',
                  'sleekxmpp/features/feature_starttls',
                  'sleekxmpp/features/feature_bind',
                  'sleekxmpp/features/feature_session',
+                 'sleekxmpp/features/feature_rosterver',
                  'sleekxmpp/thirdparty',
                  'sleekxmpp/thirdparty/suelta',
                  'sleekxmpp/thirdparty/suelta/mechanisms',
@@ -95,7 +112,7 @@ setup(
     license      = 'MIT',
     platforms    = [ 'any' ],
     packages     = packages,
-    requires     = [ 'dnspython' ],
+    requires     = [ 'dnspython', 'pyasn1', 'pyasn1_modules' ],
     classifiers  = CLASSIFIERS,
     cmdclass     = {'test': TestCommand}
 )

sleekxmpp/api.py

@@ -0,0 +1,198 @@
+from sleekxmpp.xmlstream import JID
+
+
+class APIWrapper(object):
+
+    def __init__(self, api, name):
+        self.api = api
+        self.name = name
+        if name not in self.api.settings:
+            self.api.settings[name] = {}
+
+    def __getattr__(self, attr):
+        """Curry API management commands with the API name."""
+        if attr == 'name':
+            return self.name
+        elif attr == 'settings':
+            return self.api.settings[self.name]
+        elif attr == 'register':
+            def curried_handler(handler, op, jid=None, node=None, default=False):
+                register = getattr(self.api, attr)
+                return register(handler, self.name, op, jid, node, default)
+            return curried_handler
+        elif attr == 'register_default':
+            def curried_handler(handler, op, jid=None, node=None):
+                return getattr(self.api, attr)(handler, self.name, op)
+            return curried_handler
+        elif attr in ('run', 'restore_default', 'unregister'):
+            def curried_handler(*args, **kwargs):
+                return getattr(self.api, attr)(self.name, *args, **kwargs)
+            return curried_handler
+        return None
+
+    def __getitem__(self, attr):
+        def curried_handler(jid=None, node=None, ifrom=None, args=None):
+            return self.api.run(self.name, attr, jid, node, ifrom, args)
+        return curried_handler
+
+
+class APIRegistry(object):
+
+    def __init__(self, xmpp):
+        self._handlers = {}
+        self._handler_defaults = {}
+        self.xmpp = xmpp
+        self.settings = {} 
+
+    def _setup(self, ctype, op):
+        """Initialize the API callback dictionaries.
+
+        :param string ctype: The name of the API to initialize.
+        :param string op: The API operation to initialize.
+        """
+        if ctype not in self.settings:
+            self.settings[ctype] = {}
+        if ctype not in self._handler_defaults:
+            self._handler_defaults[ctype] = {}
+        if ctype not in self._handlers:
+            self._handlers[ctype] = {}
+        if op not in self._handlers[ctype]:
+            self._handlers[ctype][op] = {'global': None,
+                                         'jid': {},
+                                         'node': {}}
+
+    def wrap(self, ctype):
+        """Return a wrapper object that targets a specific API."""
+        return APIWrapper(self, ctype)
+
+    def purge(self, ctype):
+        """Remove all information for a given API."""
+        del self.settings[ctype]
+        del self._handler_defaults[ctype]
+        del self._handlers[ctype]
+
+    def run(self, ctype, op, jid=None, node=None, ifrom=None, args=None):
+        """Execute an API callback, based on specificity.
+
+        The API callback that is executed is chosen based on the combination
+        of the provided JID and node:
+
+        JID   | node  | Handler
+        ==============================
+        Given | Given | Node handler
+        Given | None  | JID handler
+        None  | None  | Global handler
+
+        A node handler is responsible for servicing a single node at a single
+        JID, while a JID handler may respond for any node at a given JID, and
+        the global handler will answer to any JID+node combination.
+
+        Handlers should check that the JID ``ifrom`` is authorized to perform
+        the desired action.
+
+        :param string ctype: The name of the API to use.
+        :param string op: The API operation to perform.
+        :param JID jid: Optionally provide specific JID.
+        :param string node: Optionally provide specific node.
+        :param JID ifrom: Optionally provide the requesting JID.
+        :param tuple args: Optional positional arguments to the handler.
+        """
+        self._setup(ctype, op)
+
+        if jid in (None, ''):
+            jid = self.xmpp.boundjid
+        if jid and not isinstance(jid, JID):
+            jid = JID(jid)
+
+        if node is None:
+            node = ''
+
+        if self.xmpp.is_component:
+            if self.settings[ctype].get('component_bare', False):
+                jid = jid.bare
+            else:
+                jid = jid.full
+        else:
+            if self.settings[ctype].get('client_bare', True):
+                jid = jid.bare
+            else:
+                jid = jid.full
+
+        jid = JID(jid)
+
+        handler = self._handlers[ctype][op]['node'].get((jid, node), None)
+        if handler is None:
+            handler = self._handlers[ctype][op]['jid'].get(jid, None)
+        if handler is None:
+            handler = self._handlers[ctype][op].get('global', None)
+
+        if handler:
+            try:
+                return handler(jid, node, ifrom, args)
+            except TypeError:
+                # To preserve backward compatibility, drop the ifrom
+                # parameter for existing handlers that don't understand it.
+                return handler(jid, node, args)
+
+    def register(self, handler, ctype, op, jid=None, node=None, default=False):
+        """Register an API callback, with JID+node specificity.
+
+        The API callback can later be executed based on the
+        specificity of the provided JID+node combination. 
+        
+        See :meth:`~ApiRegistry.run` for more details.
+
+        :param string ctype: The name of the API to use.
+        :param string op: The API operation to perform.
+        :param JID jid: Optionally provide specific JID.
+        :param string node: Optionally provide specific node.
+        """
+        self._setup(ctype, op)
+        if jid is None and node is None:
+            if handler is None:
+                handler = self._handler_defaults[op]
+            self._handlers[ctype][op]['global'] = handler
+        elif jid is not None and node is None:
+            self._handlers[ctype][op]['jid'][jid] = handler
+        else:
+            self._handlers[ctype][op]['node'][(jid, node)] = handler
+
+        if default:
+            self.register_default(handler, ctype, op)
+
+    def register_default(self, handler, ctype, op):
+        """Register a default, global handler for an operation.
+
+        :param func handler: The default, global handler for the operation.
+        :param string ctype: The name of the API to modify.
+        :param string op: The API operation to use.
+        """
+        self._setup(ctype, op)
+        self._handler_defaults[ctype][op] = handler
+
+    def unregister(self, ctype, op, jid=None, node=None):
+        """Remove an API callback.
+
+        The API callback chosen for removal is based on the
+        specificity of the provided JID+node combination.
+
+        See :meth:`~ApiRegistry.run` for more details.
+
+        :param string ctype: The name of the API to use.
+        :param string op: The API operation to perform.
+        :param JID jid: Optionally provide specific JID.
+        :param string node: Optionally provide specific node.
+        """
+        self._setup(ctype, op)
+        self.register(None, ctype, op, jid, node)
+
+    def restore_default(self, ctype, op, jid=None, node=None):
+        """Reset an API callback to use a default handler.
+
+        :param string ctype: The name of the API to use.
+        :param string op: The API operation to perform.
+        :param JID jid: Optionally provide specific JID.
+        :param string node: Optionally provide specific node.
+        """
+        self.unregister(ctype, op, jid, node)
+        self.register(self._handler_defaults[ctype][op], ctype, op, jid, node)

sleekxmpp/basexmpp.py

@@ -15,22 +15,25 @@
 from __future__ import with_statement, unicode_literals
 
 import sys
-import copy
 import logging
 
 import sleekxmpp
-from sleekxmpp import plugins, roster
+from sleekxmpp import plugins, features, roster
+from sleekxmpp.api import APIRegistry
 from sleekxmpp.exceptions import IqError, IqTimeout
 
-from sleekxmpp.stanza import Message, Presence, Iq, Error, StreamError
+from sleekxmpp.stanza import Message, Presence, Iq, StreamError
 from sleekxmpp.stanza.roster import Roster
 from sleekxmpp.stanza.nick import Nick
 from sleekxmpp.stanza.htmlim import HTMLIM
 
-from sleekxmpp.xmlstream import XMLStream, JID, tostring
+from sleekxmpp.xmlstream import XMLStream, JID
 from sleekxmpp.xmlstream import ET, register_stanza_plugin
-from sleekxmpp.xmlstream.matcher import *
-from sleekxmpp.xmlstream.handler import *
+from sleekxmpp.xmlstream.matcher import MatchXPath
+from sleekxmpp.xmlstream.handler import Callback
+
+from sleekxmpp.features import *
+from sleekxmpp.plugins import PluginManager, register_plugin, load_plugin
 
 
 log = logging.getLogger(__name__)
@@ -65,9 +68,10 @@ class BaseXMPP(XMLStream):
 
         #: The JabberID (JID) used by this connection. 
         self.boundjid = JID(jid)
+        self._expected_server_name = self.boundjid.host
 
         #: A dictionary mapping plugin names to plugins.
-        self.plugin = {}
+        self.plugin = PluginManager(self)
 
         #: Configuration options for whitelisted plugins.
         #: If a plugin is registered without any configuration,
@@ -95,6 +99,22 @@ class BaseXMPP(XMLStream):
         #: ``'to'`` and ``'from'`` JIDs of stanzas.
         self.is_component = False
 
+        #: The API registry is a way to process callbacks based on
+        #: JID+node combinations. Each callback in the registry is
+        #: marked with:
+        #: 
+        #:   - An API name, e.g. xep_0030
+        #:   - The name of an action, e.g. get_info
+        #:   - The JID that will be affected
+        #:   - The node that will be affected
+        #:
+        #: API handlers with no JID or node will act as global handlers,
+        #: while those with a JID and no node will service all nodes
+        #: for a JID, and handlers with both a JID and node will be
+        #: used only for that specific combination. The handler that
+        #: provides the most specificity will be used.
+        self.api = APIRegistry(self)
+
         #: Flag indicating that the initial presence broadcast has
         #: been sent. Until this happens, some servers may not
         #: behave as expected when sending stanzas.
@@ -186,9 +206,18 @@ class BaseXMPP(XMLStream):
         - The send queue processor
         - The scheduler
         """
+        if 'xep_0115' in self.plugin:
+            name = 'xep_0115'
+            if not hasattr(self.plugin[name], 'post_inited'):
+                if hasattr(self.plugin[name], 'post_init'):
+                    self.plugin[name].post_init()
+                self.plugin[name].post_inited = True
+
         for name in self.plugin:
-            if not self.plugin[name].post_inited:
-                self.plugin[name].post_init()
+            if not hasattr(self.plugin[name], 'post_inited'):
+                if hasattr(self.plugin[name], 'post_init'):
+                    self.plugin[name].post_init()
+                self.plugin[name].post_inited = True
         return XMLStream.process(self, *args, **kwargs)
 
     def register_plugin(self, plugin, pconfig={}, module=None):
@@ -201,42 +230,14 @@ class BaseXMPP(XMLStream):
         :param module: Optional refence to the module containing the plugin
                        class if using custom plugins.
         """
-        try:
-            # Import the given module that contains the plugin.
-            if not module:
-                try:
-                    module = sleekxmpp.plugins
-                    module = __import__(
-                            str("%s.%s" % (module.__name__, plugin)),
-                            globals(), locals(), [str(plugin)])
-                except ImportError:
-                    module = sleekxmpp.features
-                    module = __import__(
-                            str("%s.%s" % (module.__name__, plugin)),
-                            globals(), locals(), [str(plugin)])
-            if isinstance(module, str):
-                # We probably want to load a module from outside
-                # the sleekxmpp package, so leave out the globals().
-                module = __import__(module, fromlist=[plugin])
 
-            # Use the global plugin config cache, if applicable
-            if not pconfig:
-                pconfig = self.plugin_config.get(plugin, {})
+        # Use the global plugin config cache, if applicable
+        if not pconfig:
+            pconfig = self.plugin_config.get(plugin, {})
 
-            # Load the plugin class from the module.
-            self.plugin[plugin] = getattr(module, plugin)(self, pconfig)
-
-            # Let XEP/RFC implementing plugins have some extra logging info.
-            spec = '(CUSTOM) %s'
-            if self.plugin[plugin].xep:
-                spec = "(XEP-%s) " % self.plugin[plugin].xep
-            elif self.plugin[plugin].rfc:
-                spec = "(RFC-%s) " % self.plugin[plugin].rfc
-
-            desc = (spec, self.plugin[plugin].description)
-            log.debug("Loaded Plugin %s %s" % desc)
-        except:
-            log.exception("Unable to load plugin: %s", plugin)
+        if not self.plugin.registered(plugin):
+            load_plugin(plugin, module)
+        self.plugin.enable(plugin, pconfig)
 
     def register_plugins(self):
         """Register and initialize all built-in plugins.
@@ -253,15 +254,10 @@ class BaseXMPP(XMLStream):
 
         for plugin in plugin_list:
             if plugin in plugins.__all__:
-                self.register_plugin(plugin,
-                                     self.plugin_config.get(plugin, {}))
+                self.register_plugin(plugin)
             else:
                 raise NameError("Plugin %s not in plugins.__all__." % plugin)
 
-        # Resolve plugin inter-dependencies.
-        for plugin in self.plugin:
-            self.plugin[plugin].post_init()
-
     def __getitem__(self, key):
         """Return a plugin given its name, if it has been registered."""
         if key in self.plugin:
@@ -671,6 +667,8 @@ class BaseXMPP(XMLStream):
 
     def _handle_message(self, msg):
         """Process incoming message stanzas."""
+        if not self.is_component and not msg['to'].bare:
+            msg['to'] = self.boundjid
         self.event('message', msg)
 
     def _handle_available(self, presence):
@@ -736,7 +734,11 @@ class BaseXMPP(XMLStream):
 
         Update the roster with presence information.
         """
-        self.event("presence_%s" % presence['type'], presence)
+        if not self.is_component and not presence['to'].bare:
+            presence['to'] = self.boundjid
+
+        self.event('presence', presence)
+        self.event('presence_%s' % presence['type'], presence)
 
         # Check for changes in subscription state.
         if presence['type'] in ('subscribe', 'subscribed',
@@ -763,6 +765,11 @@ class BaseXMPP(XMLStream):
             iq = exception.iq
             log.error('Request timed out: %s', iq)
             log.warning('You should catch IqTimeout exceptions')
+        elif isinstance(exception, SyntaxError):
+            # Hide stream parsing errors that occur when the
+            # stream is disconnected (they've been handled, we
+            # don't need to make a mess in the logs).
+            pass
         else:
             log.exception(exception)
 

sleekxmpp/clientxmpp.py

@@ -15,22 +15,13 @@
 from __future__ import absolute_import, unicode_literals
 
 import logging
-import base64
-import sys
-import hashlib
-import random
-import threading
 
-import sleekxmpp
-from sleekxmpp import plugins
-from sleekxmpp import stanza
-from sleekxmpp import features
+from sleekxmpp.stanza import StreamFeatures
 from sleekxmpp.basexmpp import BaseXMPP
-from sleekxmpp.stanza import *
-from sleekxmpp.xmlstream import XMLStream, RestartStream
-from sleekxmpp.xmlstream import StanzaBase, ET, register_stanza_plugin
-from sleekxmpp.xmlstream.matcher import *
-from sleekxmpp.xmlstream.handler import *
+from sleekxmpp.exceptions import XMPPError
+from sleekxmpp.xmlstream import XMLStream
+from sleekxmpp.xmlstream.matcher import StanzaPath, MatchXPath
+from sleekxmpp.xmlstream.handler import Callback
 
 # Flag indicating if DNS SRV records are available for use.
 try:
@@ -74,12 +65,15 @@ class ClientXMPP(BaseXMPP):
         BaseXMPP.__init__(self, jid, 'jabber:client')
 
         self.set_jid(jid)
-        self.password = password
         self.escape_quotes = escape_quotes
         self.plugin_config = plugin_config
         self.plugin_whitelist = plugin_whitelist
         self.default_port = 5222
 
+        self.credentials = {}
+
+        self.password = password
+
         self.stream_header = "<stream:stream to='%s' %s %s version='1.0'>" % (
                 self.boundjid.host,
                 "xmlns:stream='%s'" % self.stream_ns,
@@ -90,6 +84,8 @@ class ClientXMPP(BaseXMPP):
         self._stream_feature_handlers = {}
         self._stream_feature_order = []
 
+        self.dns_service = 'xmpp-client'
+
         #TODO: Use stream state here
         self.authenticated = False
         self.sessionstarted = False
@@ -97,6 +93,7 @@ class ClientXMPP(BaseXMPP):
         self.bindfail = False
 
         self.add_event_handler('connected', self._handle_connected)
+        self.add_event_handler('session_bind', self._handle_session_bind)
 
         self.register_stanza(StreamFeatures)
 
@@ -106,9 +103,7 @@ class ClientXMPP(BaseXMPP):
                          self._handle_stream_features))
         self.register_handler(
                 Callback('Roster Update',
-                         MatchXPath('{%s}iq/{%s}query' % (
-                             self.default_ns,
-                             'jabber:iq:roster')),
+                         StanzaPath('iq@type=set/roster'),
                          self._handle_roster))
 
         # Setup default stream features
@@ -117,6 +112,15 @@ class ClientXMPP(BaseXMPP):
         self.register_plugin('feature_session')
         self.register_plugin('feature_mechanisms',
                 pconfig={'use_mech': sasl_mech} if sasl_mech else None)
+        self.register_plugin('feature_rosterver')
+
+    @property
+    def password(self):
+        return self.credentials.get('password', '')
+
+    @password.setter
+    def password(self, value):
+        self.credentials['password'] = value
 
     def connect(self, address=tuple(), reattempt=True,
                 use_tls=True, use_ssl=False):
@@ -135,41 +139,22 @@ class ClientXMPP(BaseXMPP):
                         should be used. Defaults to ``False``.
         """
         self.session_started_event.clear()
-        if not address:
+
+        # If an address was provided, disable using DNS SRV lookup;
+        # otherwise, use the domain from the client JID with the standard
+        # XMPP client port and allow SRV lookup.
+        if address:
+            self.dns_service = None
+        else:
             address = (self.boundjid.host, 5222)
+            self.dns_service = 'xmpp-client'
+
+        self._expected_server_name = self.boundjid.host
 
         return XMLStream.connect(self, address[0], address[1],
                                  use_tls=use_tls, use_ssl=use_ssl,
                                  reattempt=reattempt)
 
-    def get_dns_records(self, domain, port=None):
-        """Get the DNS records for a domain, including SRV records.
-
-        :param domain: The domain in question.
-        :param port: If the results don't include a port, use this one.
-        """
-        if port is None:
-            port = self.default_port
-        if DNSPYTHON:
-            try:
-                record = "_xmpp-client._tcp.%s" % domain
-                answers = []
-                for answer in dns.resolver.query(record, dns.rdatatype.SRV):
-                    address = (answer.target.to_text()[:-1], answer.port)
-                    answers.append((address, answer.priority, answer.weight))
-            except (dns.resolver.NXDOMAIN, dns.resolver.NoAnswer):
-                log.warning("No SRV records for %s", domain)
-                answers = super(ClientXMPP, self).get_dns_records(domain, port)
-            except dns.exception.Timeout:
-                log.warning("DNS resolution timed out " + \
-                            "for SRV record of %s", domain)
-                answers = super(ClientXMPP, self).get_dns_records(domain, port)
-            return answers
-        else:
-            log.warning("dnspython is not installed -- " + \
-                        "relying on OS A record resolution")
-            return [((domain, port), 0, 0)]
-
     def register_feature(self, name, handler, restart=False, order=5000):
         """Register a stream feature handler.
 
@@ -236,10 +221,18 @@ class ClientXMPP(BaseXMPP):
         iq = self.Iq()
         iq['type'] = 'get'
         iq.enable('roster')
-        response = iq.send(block, timeout, callback)
+        if 'rosterver' in self.features:
+            iq['roster']['ver'] = self.client_roster.version
 
-        if callback is None:
-            return self._handle_roster(response, request=True)
+        if not block and callback is None:
+            callback = lambda resp: self._handle_roster(resp)
+
+        response = iq.send(block, timeout, callback)
+        self.event('roster_received', response)
+
+        if block: 
+            self._handle_roster(response)
+            return response
 
     def _handle_connected(self, event=None):
         #TODO: Use stream state here
@@ -262,31 +255,43 @@ class ClientXMPP(BaseXMPP):
                     # restarting the XML stream.
                     return True
 
-    def _handle_roster(self, iq, request=False):
+    def _handle_roster(self, iq):
         """Update the roster after receiving a roster stanza.
 
         :param iq: The roster stanza.
-        :param request: Indicates if this stanza is a response
-                        to a request for the roster, and not an
-                        empty acknowledgement from the server.
         """
-        if iq['type'] == 'set' or (iq['type'] == 'result' and request):
-            for jid in iq['roster']['items']:
-                item = iq['roster']['items'][jid]
-                roster = self.roster[iq['to'].bare]
-                roster[jid]['name'] = item['name']
-                roster[jid]['groups'] = item['groups']
-                roster[jid]['from'] = item['subscription'] in ['from', 'both']
-                roster[jid]['to'] = item['subscription'] in ['to', 'both']
-                roster[jid]['pending_out'] = (item['ask'] == 'subscribe')
-            self.event('roster_received', iq)
+        if iq['type'] == 'set':
+            if iq['from'].bare and iq['from'].bare != self.boundjid.bare:
+                raise XMPPError(condition='service-unavailable')
 
+        roster = self.client_roster
+        if iq['roster']['ver']:
+            roster.version = iq['roster']['ver']
+        for jid in iq['roster']['items']:
+            item = iq['roster']['items'][jid]
+            roster[jid]['name'] = item['name']
+            roster[jid]['groups'] = item['groups']
+            roster[jid]['from'] = item['subscription'] in ['from', 'both']
+            roster[jid]['to'] = item['subscription'] in ['to', 'both']
+            roster[jid]['pending_out'] = (item['ask'] == 'subscribe')
+
+            roster[jid].save(remove=(item['subscription'] == 'remove'))
+                 
         self.event("roster_update", iq)
         if iq['type'] == 'set':
-            iq.reply()
-            iq.enable('roster')
-            iq.send()
-        return True
+            resp = self.Iq(stype='result',
+                           sto=iq['from'],
+                           sid=iq['id'])
+            resp.enable('roster')
+            resp.send()
+
+    def _handle_session_bind(self, jid):
+        """Set the client roster to the JID set by the server.
+
+        :param :class:`sleekxmpp.xmlstream.jid.JID` jid: The bound JID as
+            dictated by the server. The same as :attr:`boundjid`.
+        """
+        self.client_roster = self.roster[jid]
 
 
 # To comply with PEP8, method names now use underscores.

sleekxmpp/componentxmpp.py

@@ -15,17 +15,14 @@
 from __future__ import absolute_import
 
 import logging
-import base64
 import sys
 import hashlib
 
-from sleekxmpp import plugins
-from sleekxmpp import stanza
 from sleekxmpp.basexmpp import BaseXMPP
-from sleekxmpp.xmlstream import XMLStream, RestartStream
-from sleekxmpp.xmlstream import StanzaBase, ET
-from sleekxmpp.xmlstream.matcher import *
-from sleekxmpp.xmlstream.handler import *
+from sleekxmpp.xmlstream import XMLStream
+from sleekxmpp.xmlstream import ET
+from sleekxmpp.xmlstream.matcher import MatchXPath
+from sleekxmpp.xmlstream.handler import Callback
 
 
 log = logging.getLogger(__name__)
@@ -82,7 +79,7 @@ class ComponentXMPP(BaseXMPP):
                                self._handle_probe)
 
     def connect(self, host=None, port=None, use_ssl=False, 
-                      use_tls=True, reattempt=True):
+                      use_tls=False, reattempt=True):
         """Connect to the server.
 
         Setting ``reattempt`` to ``True`` will cause connection attempts to
@@ -104,10 +101,16 @@ class ComponentXMPP(BaseXMPP):
             host = self.server_host
         if port is None:
             port = self.server_port
+
+        self.server_name = self.boundjid.host
+
+        if use_tls:
+            log.info("XEP-0114 components can not use TLS")
+
         log.debug("Connecting to %s:%s", host, port)
         return XMLStream.connect(self, host=host, port=port,
                                        use_ssl=use_ssl,
-                                       use_tls=use_tls,
+                                       use_tls=False,
                                        reattempt=reattempt)
 
     def incoming_filter(self, xml):

sleekxmpp/features/__init__.py

@@ -6,4 +6,10 @@
     See the file LICENSE for copying permission.
 """
 
-__all__ = ['feature_starttls', 'feature_mechanisms', 'feature_bind']
+__all__ = [
+    'feature_starttls', 
+    'feature_mechanisms', 
+    'feature_bind', 
+    'feature_session',
+    'feature_rosterver'
+]

sleekxmpp/features/feature_bind/__init__.py

@@ -6,5 +6,14 @@
     See the file LICENSE for copying permission.
 """
 
-from sleekxmpp.features.feature_bind.bind import feature_bind
+from sleekxmpp.plugins.base import register_plugin
+
+from sleekxmpp.features.feature_bind.bind import FeatureBind
 from sleekxmpp.features.feature_bind.stanza import Bind
+
+
+register_plugin(FeatureBind)
+
+
+# Retain some backwards compatibility
+feature_bind = FeatureBind

sleekxmpp/features/feature_bind/bind.py

@@ -11,22 +11,20 @@ import logging
 from sleekxmpp.stanza import Iq, StreamFeatures
 from sleekxmpp.features.feature_bind import stanza
 from sleekxmpp.xmlstream import register_stanza_plugin
-from sleekxmpp.xmlstream.matcher import *
-from sleekxmpp.xmlstream.handler import *
-from sleekxmpp.plugins.base import base_plugin
+from sleekxmpp.plugins import BasePlugin, register_plugin
 
 
 log = logging.getLogger(__name__)
 
 
-class feature_bind(base_plugin):
+class FeatureBind(BasePlugin):
+
+    name = 'feature_bind'
+    description = 'RFC 6120: Stream Feature: Resource Binding'
+    dependencies = set()
+    stanza = stanza
 
     def plugin_init(self):
-        self.name = 'Bind Resource'
-        self.rfc = '6120'
-        self.description = 'Resource Binding Stream Feature'
-        self.stanza = stanza
-
         self.xmpp.register_feature('bind',
                 self._handle_bind_resource,
                 restart=False,
@@ -52,6 +50,7 @@ class feature_bind(base_plugin):
 
         self.xmpp.set_jid(response['bind']['jid'])
         self.xmpp.bound = True
+        self.xmpp.event('session_bind', self.xmpp.boundjid, direct=True)
 
         self.xmpp.features.add('bind')
 

sleekxmpp/features/feature_bind/stanza.py

@@ -6,8 +6,7 @@
     See the file LICENSE for copying permission.
 """
 
-from sleekxmpp.stanza import Iq, StreamFeatures
-from sleekxmpp.xmlstream import ElementBase, ET, register_stanza_plugin
+from sleekxmpp.xmlstream import ElementBase
 
 
 class Bind(ElementBase):

sleekxmpp/features/feature_mechanisms/__init__.py

@@ -6,8 +6,17 @@
     See the file LICENSE for copying permission.
 """
 
-from sleekxmpp.features.feature_mechanisms.mechanisms import feature_mechanisms
+from sleekxmpp.plugins.base import register_plugin
+
+from sleekxmpp.features.feature_mechanisms.mechanisms import FeatureMechanisms
 from sleekxmpp.features.feature_mechanisms.stanza import Mechanisms
 from sleekxmpp.features.feature_mechanisms.stanza import Auth
 from sleekxmpp.features.feature_mechanisms.stanza import Success
 from sleekxmpp.features.feature_mechanisms.stanza import Failure
+
+
+register_plugin(FeatureMechanisms)
+
+
+# Retain some backwards compatibility
+feature_mechanisms = FeatureMechanisms

sleekxmpp/features/feature_mechanisms/mechanisms.py

@@ -9,36 +9,48 @@
 import logging
 
 from sleekxmpp.thirdparty import suelta
+from sleekxmpp.thirdparty.suelta.exceptions import SASLCancelled, SASLError
+from sleekxmpp.thirdparty.suelta.exceptions import SASLPrepFailure
 
 from sleekxmpp.stanza import StreamFeatures
 from sleekxmpp.xmlstream import RestartStream, register_stanza_plugin
-from sleekxmpp.xmlstream.matcher import *
-from sleekxmpp.xmlstream.handler import *
-from sleekxmpp.plugins.base import base_plugin
+from sleekxmpp.plugins import BasePlugin
+from sleekxmpp.xmlstream.matcher import MatchXPath
+from sleekxmpp.xmlstream.handler import Callback
 from sleekxmpp.features.feature_mechanisms import stanza
 
 
 log = logging.getLogger(__name__)
 
 
-class feature_mechanisms(base_plugin):
+class FeatureMechanisms(BasePlugin):
+
+    name = 'feature_mechanisms'
+    description = 'RFC 6120: Stream Feature: SASL'
+    dependencies = set()
+    stanza = stanza
 
     def plugin_init(self):
-        self.name = 'SASL Mechanisms'
-        self.rfc = '6120'
-        self.description = "SASL Stream Feature"
-        self.stanza = stanza
-
         self.use_mech = self.config.get('use_mech', None)
 
+        if not self.use_mech and not self.xmpp.boundjid.user:
+            self.use_mech = 'ANONYMOUS'
+
         def tls_active():
             return 'starttls' in self.xmpp.features
 
         def basic_callback(mech, values):
-            if 'username' in values:
-                values['username'] = self.xmpp.boundjid.user
-            if 'password' in values:
-                values['password'] = self.xmpp.password
+            creds = self.xmpp.credentials
+            for value in values:
+                if value == 'username':
+                    values['username'] = self.xmpp.boundjid.user
+                elif value == 'password':
+                    values['password'] = creds['password']
+                elif value == 'email':
+                    jid = self.xmpp.boundjid.bare
+                    values['email'] = creds.get('email', jid)
+                elif value in creds:
+                    values[value] = creds[value]
             mech.fulfill(values)
 
         sasl_callback = self.config.get('sasl_callback', None)
@@ -53,6 +65,9 @@ class feature_mechanisms(base_plugin):
                                 tls_active=tls_active,
                                 mech=self.use_mech)
 
+        self.mech_list = set()
+        self.attempted_mechs = set()
+
         register_stanza_plugin(StreamFeatures, stanza.Mechanisms)
 
         self.xmpp.register_stanza(stanza.Success)
@@ -60,19 +75,18 @@ class feature_mechanisms(base_plugin):
         self.xmpp.register_stanza(stanza.Auth)
         self.xmpp.register_stanza(stanza.Challenge)
         self.xmpp.register_stanza(stanza.Response)
+        self.xmpp.register_stanza(stanza.Abort)
 
         self.xmpp.register_handler(
                 Callback('SASL Success',
                          MatchXPath(stanza.Success.tag_name()),
                          self._handle_success,
-                         instream=True,
-                         once=True))
+                         instream=True))
         self.xmpp.register_handler(
                 Callback('SASL Failure',
                          MatchXPath(stanza.Failure.tag_name()),
                          self._handle_fail,
-                         instream=True,
-                         once=True))
+                         instream=True))
         self.xmpp.register_handler(
                 Callback('SASL Challenge',
                          MatchXPath(stanza.Challenge.tag_name()),
@@ -95,35 +109,63 @@ class feature_mechanisms(base_plugin):
             # server has incorrectly offered it again.
             return False
 
-        mech_list = features['mechanisms']
+        if not self.use_mech:
+            self.mech_list = set(features['mechanisms'])
+        else:
+            self.mech_list = set([self.use_mech])
+        return self._send_auth()
+
+    def _send_auth(self):
+        mech_list = self.mech_list - self.attempted_mechs
         self.mech = self.sasl.choose_mechanism(mech_list)
 
-        if self.mech is not None:
+        if mech_list and self.mech is not None:
             resp = stanza.Auth(self.xmpp)
             resp['mechanism'] = self.mech.name
-            resp['value'] = self.mech.process()
-            resp.send(now=True)
+            try:
+                resp['value'] = self.mech.process()
+            except SASLCancelled:
+                self.attempted_mechs.add(self.mech.name)
+                self._send_auth()
+            except SASLError:
+                self.attempted_mechs.add(self.mech.name)
+                self._send_auth()
+            except SASLPrepFailure:
+                log.exception("A credential value did not pass SASLprep.")
+                self.xmpp.disconnect()
+            else:
+                resp.send(now=True)
         else:
             log.error("No appropriate login method.")
             self.xmpp.event("no_auth", direct=True)
+            self.attempted_mechs = set()
             self.xmpp.disconnect()
         return True
 
     def _handle_challenge(self, stanza):
         """SASL challenge received. Process and send response."""
         resp = self.stanza.Response(self.xmpp)
-        resp['value'] = self.mech.process(stanza['value'])
-        resp.send(now=True)
+        try:
+            resp['value'] = self.mech.process(stanza['value'])
+        except SASLCancelled:
+            self.stanza.Abort(self.xmpp).send()
+        except SASLError:
+            self.stanza.Abort(self.xmpp).send()
+        else:
+            resp.send(now=True)
 
     def _handle_success(self, stanza):
         """SASL authentication succeeded. Restart the stream."""
+        self.attempted_mechs = set()
         self.xmpp.authenticated = True
         self.xmpp.features.add('mechanisms')
+        self.xmpp.event('auth_success', stanza, direct=True)
         raise RestartStream()
 
     def _handle_fail(self, stanza):
         """SASL authentication failed. Disconnect and shutdown."""
+        self.attempted_mechs.add(self.mech.name)
         log.info("Authentication failed: %s", stanza['condition'])
         self.xmpp.event("failed_auth", stanza, direct=True)
-        self.xmpp.disconnect()
+        self._send_auth()
         return True

sleekxmpp/features/feature_mechanisms/stanza/__init__.py

@@ -13,3 +13,4 @@ from sleekxmpp.features.feature_mechanisms.stanza.success import Success
 from sleekxmpp.features.feature_mechanisms.stanza.failure import Failure
 from sleekxmpp.features.feature_mechanisms.stanza.challenge import Challenge
 from sleekxmpp.features.feature_mechanisms.stanza.response import Response
+from sleekxmpp.features.feature_mechanisms.stanza.abort import Abort

sleekxmpp/features/feature_mechanisms/stanza/abort.py

@@ -0,0 +1,24 @@
+"""
+    SleekXMPP: The Sleek XMPP Library
+    Copyright (C) 2011  Nathanael C. Fritz
+    This file is part of SleekXMPP.
+
+    See the file LICENSE for copying permission.
+"""
+
+from sleekxmpp.xmlstream import StanzaBase
+
+
+class Abort(StanzaBase):
+
+    """
+    """
+
+    name = 'abort'
+    namespace = 'urn:ietf:params:xml:ns:xmpp-sasl'
+    interfaces = set()
+    plugin_attrib = name
+
+    def setup(self, xml):
+        StanzaBase.setup(self, xml)
+        self.xml.tag = self.tag_name()

sleekxmpp/features/feature_mechanisms/stanza/auth.py

@@ -10,9 +10,7 @@ import base64
 
 from sleekxmpp.thirdparty.suelta.util import bytes
 
-from sleekxmpp.stanza import StreamFeatures
-from sleekxmpp.xmlstream import ElementBase, StanzaBase, ET
-from sleekxmpp.xmlstream import register_stanza_plugin
+from sleekxmpp.xmlstream import StanzaBase
 
 
 class Auth(StanzaBase):
@@ -25,15 +23,28 @@ class Auth(StanzaBase):
     interfaces = set(('mechanism', 'value'))
     plugin_attrib = name
 
+    #: Some SASL mechs require sending values as is, 
+    #: without converting base64.
+    plain_mechs = set(['X-MESSENGER-OAUTH2'])
+
     def setup(self, xml):
         StanzaBase.setup(self, xml)
         self.xml.tag = self.tag_name()
 
     def get_value(self):
-        return base64.b64decode(bytes(self.xml.text))
+        if not self['mechanism'] in self.plain_mechs:
+            return base64.b64decode(bytes(self.xml.text))
+        else:
+            return self.xml.text
 
     def set_value(self, values):
-        self.xml.text = bytes(base64.b64encode(values)).decode('utf-8')
+        if not self['mechanism'] in self.plain_mechs:
+            if values:
+                self.xml.text = bytes(base64.b64encode(values)).decode('utf-8')
+            else:
+                self.xml.text = '='
+        else:
+            self.xml.text = bytes(values).decode('utf-8')
 
     def del_value(self):
         self.xml.text = ''

sleekxmpp/features/feature_mechanisms/stanza/challenge.py

@@ -10,9 +10,7 @@ import base64
 
 from sleekxmpp.thirdparty.suelta.util import bytes
 
-from sleekxmpp.stanza import StreamFeatures
-from sleekxmpp.xmlstream import ElementBase, StanzaBase, ET
-from sleekxmpp.xmlstream import register_stanza_plugin
+from sleekxmpp.xmlstream import StanzaBase
 
 
 class Challenge(StanzaBase):
@@ -33,7 +31,10 @@ class Challenge(StanzaBase):
         return base64.b64decode(bytes(self.xml.text))
 
     def set_value(self, values):
-        self.xml.text = bytes(base64.b64encode(values)).decode('utf-8')
+        if values:
+            self.xml.text = bytes(base64.b64encode(values)).decode('utf-8')
+        else:
+            self.xml.text = '='
 
     def del_value(self):
         self.xml.text = ''

sleekxmpp/features/feature_mechanisms/stanza/failure.py

@@ -6,9 +6,7 @@
     See the file LICENSE for copying permission.
 """
 
-from sleekxmpp.stanza import StreamFeatures
-from sleekxmpp.xmlstream import ElementBase, StanzaBase, ET
-from sleekxmpp.xmlstream import register_stanza_plugin
+from sleekxmpp.xmlstream import StanzaBase, ET
 
 
 class Failure(StanzaBase):

sleekxmpp/features/feature_mechanisms/stanza/mechanisms.py

@@ -6,9 +6,7 @@
     See the file LICENSE for copying permission.
 """
 
-from sleekxmpp.stanza import StreamFeatures
-from sleekxmpp.xmlstream import ElementBase, StanzaBase, ET
-from sleekxmpp.xmlstream import register_stanza_plugin
+from sleekxmpp.xmlstream import ElementBase, ET
 
 
 class Mechanisms(ElementBase):

sleekxmpp/features/feature_mechanisms/stanza/response.py

@@ -10,9 +10,7 @@ import base64
 
 from sleekxmpp.thirdparty.suelta.util import bytes
 
-from sleekxmpp.stanza import StreamFeatures
-from sleekxmpp.xmlstream import ElementBase, StanzaBase, ET
-from sleekxmpp.xmlstream import register_stanza_plugin
+from sleekxmpp.xmlstream import StanzaBase
 
 
 class Response(StanzaBase):
@@ -33,7 +31,10 @@ class Response(StanzaBase):
         return base64.b64decode(bytes(self.xml.text))
 
     def set_value(self, values):
-        self.xml.text = bytes(base64.b64encode(values)).decode('utf-8')
+        if values:
+            self.xml.text = bytes(base64.b64encode(values)).decode('utf-8')
+        else:
+            self.xml.text = '='
 
     def del_value(self):
         self.xml.text = ''

sleekxmpp/features/feature_mechanisms/stanza/success.py

@@ -6,9 +6,7 @@
     See the file LICENSE for copying permission.
 """
 
-from sleekxmpp.stanza import StreamFeatures
-from sleekxmpp.xmlstream import ElementBase, StanzaBase, ET
-from sleekxmpp.xmlstream import register_stanza_plugin
+from sleekxmpp.xmlstream import StanzaBase
 
 
 class Success(StanzaBase):

sleekxmpp/features/feature_rosterver/__init__.py

@@ -0,0 +1,19 @@
+"""
+    SleekXMPP: The Sleek XMPP Library
+    Copyright (C) 2012  Nathanael C. Fritz
+    This file is part of SleekXMPP.
+
+    See the file LICENSE for copying permission.
+"""
+
+from sleekxmpp.plugins.base import register_plugin
+
+from sleekxmpp.features.feature_rosterver.rosterver import FeatureRosterVer
+from sleekxmpp.features.feature_rosterver.stanza import RosterVer
+
+
+register_plugin(FeatureRosterVer)
+
+
+# Retain some backwards compatibility
+feature_rosterver = FeatureRosterVer

sleekxmpp/features/feature_rosterver/rosterver.py

@@ -0,0 +1,42 @@
+"""
+    SleekXMPP: The Sleek XMPP Library
+    Copyright (C) 2012  Nathanael C. Fritz
+    This file is part of SleekXMPP.
+
+    See the file LICENSE for copying permission.
+"""
+
+import logging
+
+from sleekxmpp.stanza import Iq, StreamFeatures
+from sleekxmpp.features.feature_rosterver import stanza
+from sleekxmpp.xmlstream import register_stanza_plugin
+from sleekxmpp.plugins.base import BasePlugin
+
+
+log = logging.getLogger(__name__)
+
+
+class FeatureRosterVer(BasePlugin):
+
+    name = 'feature_rosterver'
+    description = 'RFC 6121: Stream Feature: Roster Versioning'
+    dependences = set()
+    stanza = stanza
+
+    def plugin_init(self):
+        self.xmpp.register_feature('rosterver',
+                self._handle_rosterver,
+                restart=False,
+                order=9000)
+
+        register_stanza_plugin(StreamFeatures, stanza.RosterVer)
+
+    def _handle_rosterver(self, features):
+        """Enable using roster versioning.
+
+        Arguments:
+            features -- The stream features stanza.
+        """
+        log.debug("Enabling roster versioning.")
+        self.xmpp.features.add('rosterver')

sleekxmpp/features/feature_rosterver/stanza.py

@@ -0,0 +1,17 @@
+"""
+    SleekXMPP: The Sleek XMPP Library
+    Copyright (C) 2012  Nathanael C. Fritz
+    This file is part of SleekXMPP.
+
+    See the file LICENSE for copying permission.
+"""
+
+from sleekxmpp.xmlstream import ElementBase
+
+
+class RosterVer(ElementBase):
+
+    name = 'ver'
+    namespace = 'urn:xmpp:features:rosterver'
+    interfaces = set()
+    plugin_attrib = 'rosterver'

sleekxmpp/features/feature_session/__init__.py

@@ -6,5 +6,14 @@
     See the file LICENSE for copying permission.
 """
 
-from sleekxmpp.features.feature_session.session import feature_session
+from sleekxmpp.plugins.base import register_plugin
+
+from sleekxmpp.features.feature_session.session import FeatureSession
 from sleekxmpp.features.feature_session.stanza import Session
+
+
+register_plugin(FeatureSession)
+
+
+# Retain some backwards compatibility
+feature_session = FeatureSession

sleekxmpp/features/feature_session/session.py

@@ -10,9 +10,7 @@ import logging
 
 from sleekxmpp.stanza import Iq, StreamFeatures
 from sleekxmpp.xmlstream import register_stanza_plugin
-from sleekxmpp.xmlstream.matcher import *
-from sleekxmpp.xmlstream.handler import *
-from sleekxmpp.plugins.base import base_plugin
+from sleekxmpp.plugins import BasePlugin
 
 from sleekxmpp.features.feature_session import stanza
 
@@ -20,14 +18,14 @@ from sleekxmpp.features.feature_session import stanza
 log = logging.getLogger(__name__)
 
 
-class feature_session(base_plugin):
+class FeatureSession(BasePlugin):
+
+    name = 'feature_session'
+    description = 'RFC 3920: Stream Feature: Start Session'
+    dependencies = set()
+    stanza = stanza
 
     def plugin_init(self):
-        self.name = 'Start Session'
-        self.rfc = '3920'
-        self.description = 'Start Session Stream Feature'
-        self.stanza = stanza
-
         self.xmpp.register_feature('session',
                 self._handle_start_session,
                 restart=False,
@@ -46,7 +44,7 @@ class feature_session(base_plugin):
         iq = self.xmpp.Iq()
         iq['type'] = 'set'
         iq.enable('session')
-        response = iq.send(now=True)
+        iq.send(now=True)
 
         self.xmpp.features.add('session')
 

sleekxmpp/features/feature_session/stanza.py

@@ -6,8 +6,7 @@
     See the file LICENSE for copying permission.
 """
 
-from sleekxmpp.stanza import Iq, StreamFeatures
-from sleekxmpp.xmlstream import ElementBase, ET, register_stanza_plugin
+from sleekxmpp.xmlstream import ElementBase
 
 
 class Session(ElementBase):

sleekxmpp/features/feature_starttls/__init__.py

@@ -6,5 +6,14 @@
     See the file LICENSE for copying permission.
 """
 
-from sleekxmpp.features.feature_starttls.starttls import feature_starttls
+from sleekxmpp.plugins.base import register_plugin
+
+from sleekxmpp.features.feature_starttls.starttls import FeatureSTARTTLS
 from sleekxmpp.features.feature_starttls.stanza import *
+
+
+register_plugin(FeatureSTARTTLS)
+
+
+# Retain some backwards compatibility
+feature_starttls = FeatureSTARTTLS

sleekxmpp/features/feature_starttls/stanza.py

@@ -6,9 +6,7 @@
     See the file LICENSE for copying permission.
 """
 
-from sleekxmpp.stanza import StreamFeatures
 from sleekxmpp.xmlstream import StanzaBase, ElementBase
-from sleekxmpp.xmlstream import register_stanza_plugin
 
 
 class STARTTLS(ElementBase):

sleekxmpp/features/feature_starttls/starttls.py

@@ -10,23 +10,23 @@ import logging
 
 from sleekxmpp.stanza import StreamFeatures
 from sleekxmpp.xmlstream import RestartStream, register_stanza_plugin
-from sleekxmpp.xmlstream.matcher import *
-from sleekxmpp.xmlstream.handler import *
-from sleekxmpp.plugins.base import base_plugin
+from sleekxmpp.plugins import BasePlugin
+from sleekxmpp.xmlstream.matcher import MatchXPath
+from sleekxmpp.xmlstream.handler import Callback
 from sleekxmpp.features.feature_starttls import stanza
 
 
 log = logging.getLogger(__name__)
 
 
-class feature_starttls(base_plugin):
+class FeatureSTARTTLS(BasePlugin):
+
+    name = 'feature_starttls'
+    description = 'RFC 6120: Stream Feature: STARTTLS'
+    dependencies = set()
+    stanza = stanza
 
     def plugin_init(self):
-        self.name = "STARTTLS"
-        self.rfc = '6120'
-        self.description = "STARTTLS Stream Feature"
-        self.stanza = stanza
-
         self.xmpp.register_handler(
                 Callback('STARTTLS Proceed',
                         MatchXPath(stanza.Proceed.tag_name()),

sleekxmpp/plugins/__init__.py

@@ -5,9 +5,50 @@
 
     See the file LICENSE for copying permission.
 """
-__all__ = ['xep_0004', 'xep_0009', 'xep_0012', 'xep_0030', 'xep_0033',
-           'xep_0045', 'xep_0050', 'xep_0060', 'xep_0066', 'xep_0082',
-           'xep_0085', 'xep_0086', 'xep_0092', 'xep_0128', 'xep_0199',
-           'xep_0203', 'xep_0224', 'xep_0249', 'gmail_notify']
 
-# Don't automatically load xep_0078
+from sleekxmpp.plugins.base import PluginManager, PluginNotFound, BasePlugin
+from sleekxmpp.plugins.base import register_plugin, load_plugin
+
+
+__all__ = [
+    # Non-standard
+    'gmail_notify',  # Gmail searching and notifications
+
+    # XEPS
+    'xep_0004',  # Data Forms
+    'xep_0009',  # Jabber-RPC
+    'xep_0012',  # Last Activity
+    'xep_0027',  # Current Jabber OpenPGP Usage
+    'xep_0030',  # Service Discovery
+    'xep_0033',  # Extended Stanza Addresses
+    'xep_0045',  # Multi-User Chat (Client)
+    'xep_0047',  # In-Band Bytestreams
+    'xep_0050',  # Ad-hoc Commands
+    'xep_0054',  # vcard-temp
+    'xep_0059',  # Result Set Management
+    'xep_0060',  # Pubsub (Client)
+    'xep_0066',  # Out of Band Data
+    'xep_0077',  # In-Band Registration
+#   'xep_0078',  # Non-SASL auth. Don't automatically load
+    'xep_0080',  # User Location
+    'xep_0082',  # XMPP Date and Time Profiles
+    'xep_0085',  # Chat State Notifications
+    'xep_0086',  # Legacy Error Codes
+    'xep_0092',  # Software Version
+    'xep_0107',  # User Mood
+    'xep_0108',  # User Activity
+    'xep_0115',  # Entity Capabilities
+    'xep_0118',  # User Tune
+    'xep_0128',  # Extended Service Discovery
+    'xep_0153',  # vCard-Based Avatars
+    'xep_0163',  # Personal Eventing Protocol
+    'xep_0172',  # User Nickname
+    'xep_0184',  # Message Receipts
+    'xep_0198',  # Stream Management
+    'xep_0199',  # Ping
+    'xep_0202',  # Entity Time
+    'xep_0203',  # Delayed Delivery
+    'xep_0224',  # Attention
+    'xep_0231',  # Bits of Binary
+    'xep_0249',  # Direct MUC Invitations
+]

sleekxmpp/plugins/base.py

@@ -1,91 +1,301 @@
-"""
-    SleekXMPP: The Sleek XMPP Library
-    Copyright (C) 2010 Nathanael C. Fritz
-    This file is part of SleekXMPP.
+# -*- encoding: utf-8 -*-
 
-    See the file LICENSE for copying permission.
+"""
+    sleekxmpp.plugins.base
+    ~~~~~~~~~~~~~~~~~~~~~~
+
+    This module provides XMPP functionality that
+    is specific to client connections.
+
+    Part of SleekXMPP: The Sleek XMPP Library
+
+    :copyright: (c) 2012 Nathanael C. Fritz
+    :license: MIT, see LICENSE for more details
 """
 
+import sys
+import logging
+import threading
 
-class base_plugin(object):
 
+if sys.version_info >= (3, 0):
+    unicode = str
+
+
+log = logging.getLogger(__name__)
+
+
+#: Associate short string names of plugins with implementations. The
+#: plugin names are based on the spec used by the plugin, such as
+#: `'xep_0030'` for a plugin that implements XEP-0030.
+PLUGIN_REGISTRY = {}
+
+#: In order to do cascading plugin disabling, reverse dependencies
+#: must be tracked. 
+PLUGIN_DEPENDENTS = {}
+
+#: Only allow one thread to manipulate the plugin registry at a time. 
+REGISTRY_LOCK = threading.RLock()
+
+
+class PluginNotFound(Exception):
+    """Raised if an unknown plugin is accessed."""
+
+
+def register_plugin(impl, name=None):
+    """Add a new plugin implementation to the registry.
+
+    :param class impl: The plugin class.
+
+    The implementation class must provide a :attr:`~BasePlugin.name`
+    value that will be used as a short name for enabling and disabling
+    the plugin. The name should be based on the specification used by
+    the plugin. For example, a plugin implementing XEP-0030 would be
+    named `'xep_0030'`.
     """
-    The base_plugin class serves as a base for user created plugins
-    that provide support for existing or experimental XEPS.
+    if name is None:
+        name = impl.name
+    with REGISTRY_LOCK:
+        PLUGIN_REGISTRY[name] = impl
+        if name not in PLUGIN_DEPENDENTS:
+            PLUGIN_DEPENDENTS[name] = set()
+        for dep in impl.dependencies:
+            if dep not in PLUGIN_DEPENDENTS:
+                PLUGIN_DEPENDENTS[dep] = set()
+            PLUGIN_DEPENDENTS[dep].add(name)
 
-    Each plugin has a dictionary for configuration options, as well
-    as a name and description.
 
-    The lifecycle of a plugin is:
-        1. The plugin is instantiated during registration.
-        2. Once the XML stream begins processing, the method
-           plugin_init() is called (if the plugin is configured
-           as enabled with {'enable': True}).
-        3. After all plugins have been initialized, the
-           method post_init() is called.
+def load_plugin(name, module=None):
+    """Find and import a plugin module so that it can be registered.
 
-    Recommended event handlers:
-        session_start -- Plugins which require the use of the current
-                         bound JID SHOULD wait for the session_start
-                         event to perform any initialization (or
-                         resetting). This is a transitive recommendation,
-                         plugins that use other plugins which use the
-                         bound JID should also wait for session_start
-                         before making such calls.
-        session_end   -- If the plugin keeps any per-session state,
-                         such as joined MUC rooms, such state SHOULD
-                         be cleared when the session_end event is raised.
+    This function is called to import plugins that have selected for
+    enabling, but no matching registered plugin has been found.
 
-    Attributes:
-        xep          -- The XEP number the plugin implements, if any.
-        description  -- A short description of the plugin, typically
-                        the long name of the implemented XEP.
-        xmpp         -- The main SleekXMPP instance.
-        config       -- A dictionary of custom configuration values.
-                        The value 'enable' is special and controls
-                        whether or not the plugin is initialized
-                        after registration.
-        post_initted -- Executed after all plugins have been initialized
-                        to handle any cross-plugin interactions, such as
-                        registering service discovery items.
-        enable       -- Indicates that the plugin is enabled for use and
-                        will be initialized after registration.
-
-    Methods:
-        plugin_init  -- Initialize the plugin state.
-        post_init    -- Handle any cross-plugin concerns.
+    :param str name: The name of the plugin. It is expected that
+                     plugins are in packages matching their name,
+                     even though the plugin class name does not
+                     have to match.
+    :param str module: The name of the base module to search 
+                       for the plugin.
     """
+    try:
+        if not module:
+            try:
+                module = 'sleekxmpp.plugins.%s' % name
+                __import__(module)
+                mod = sys.modules[module]
+            except:
+                module = 'sleekxmpp.features.%s' % name
+                __import__(module)
+                mod = sys.modules[module]
+        elif isinstance(module, (str, unicode)):
+            __import__(module)
+            mod = sys.modules[module]
+        else:
+            mod = module
 
+        # Add older style plugins to the registry.
+        if hasattr(mod, name):
+            plugin = getattr(mod, name)
+            if hasattr(plugin, 'xep') or hasattr(plugin, 'rfc'):
+                plugin.name = name
+                # Mark the plugin as an older style plugin so
+                # we can work around dependency issues.
+                plugin.old_style = True
+            register_plugin(plugin, name)
+    except:
+        log.exception("Unable to load plugin: %s", name)
+
+
+class PluginManager(object): 
     def __init__(self, xmpp, config=None):
-        """
-        Instantiate a new plugin and store the given configuration.
+        #: We will track all enabled plugins in a set so that we
+        #: can enable plugins in batches and pull in dependencies
+        #: without problems.
+        self._enabled = set()
 
-        Arguments:
-            xmpp   -- The main SleekXMPP instance.
-            config -- A dictionary of configuration values.
+        #: Maintain references to active plugins.
+        self._plugins = {}
+
+        self._plugin_lock = threading.RLock()
+
+        #: Globally set default plugin configuration. This will
+        #: be used for plugins that are auto-enabled through
+        #: dependency loading.
+        self.config = config if config else {}
+
+        self.xmpp = xmpp
+
+    def register(self, plugin, enable=True):
+        """Register a new plugin, and optionally enable it.
+
+        :param class plugin: The implementation class of the plugin
+                             to register.
+        :param bool enable: If ``True``, immediately enable the
+                            plugin after registration.
         """
+        register_plugin(plugin)
+        if enable:
+            self.enable(plugin.name)
+
+    def enable(self, name, config=None, enabled=None):
+        """Enable a plugin, including any dependencies.
+
+        :param string name: The short name of the plugin.
+        :param dict config: Optional settings dictionary for
+                            configuring plugin behaviour.
+        """
+        top_level = False
+        if enabled is None:
+            enabled = set()
+
+        with self._plugin_lock:
+            if name not in self._enabled:
+                enabled.add(name)
+                self._enabled.add(name)
+                if not self.registered(name):
+                    load_plugin(name)
+
+                plugin_class = PLUGIN_REGISTRY.get(name, None)
+                if not plugin_class:
+                    raise PluginNotFound(name)
+
+                if config is None:
+                    config = self.config.get(name, None)
+
+                plugin = plugin_class(self.xmpp, config)
+                self._plugins[name] = plugin
+                for dep in plugin.dependencies:
+                    self.enable(dep, enabled=enabled)
+                plugin.plugin_init()
+                log.debug("Loaded Plugin: %s", plugin.description)
+
+        if top_level:
+            for name in enabled:
+                if hasattr(self.plugins[name], 'old_style'):
+                    # Older style plugins require post_init()
+                    # to run just before stream processing begins,
+                    # so we don't call it here.
+                    pass
+                self.plugins[name].post_init()
+
+    def enable_all(self, names=None, config=None):
+        """Enable all registered plugins.
+        
+        :param list names: A list of plugin names to enable. If
+                           none are provided, all registered plugins
+                           will be enabled.
+        :param dict config: A dictionary mapping plugin names to
+                            configuration dictionaries, as used by
+                            :meth:`~PluginManager.enable`.
+        """
+        names = names if names else PLUGIN_REGISTRY.keys()
         if config is None:
             config = {}
-        self.xep = None
-        self.rfc = None
-        self.description = 'Base Plugin'
+        for name in names:
+            self.enable(name, config.get(name, {}))
+
+    def enabled(self, name):
+        """Check if a plugin has been enabled.
+
+        :param string name: The name of the plugin to check.
+        :return: boolean
+        """
+        return name in self._enabled
+
+    def registered(self, name):
+        """Check if a plugin has been registered.
+
+        :param string name: The name of the plugin to check.
+        :return: boolean
+        """
+        return name in PLUGIN_REGISTRY
+
+    def disable(self, name, _disabled=None):
+        """Disable a plugin, including any dependent upon it.
+
+        :param string name: The name of the plugin to disable.
+        :param set _disabled: Private set used to track the
+                              disabled status of plugins during
+                              the cascading process.
+        """
+        if _disabled is None:
+            _disabled = set()
+        with self._plugin_lock:
+            if name not in _disabled and name in self._enabled:
+                _disabled.add(name)
+                plugin = self._plugins.get(name, None)
+                if plugin is None:
+                    raise PluginNotFound(name)
+                for dep in PLUGIN_DEPENDENTS[name]:
+                    self.disable(dep, _disabled)
+                plugin.plugin_end()
+                if name in self._enabled:
+                    self._enabled.remove(name)
+                del self._plugins[name]
+
+    def __keys__(self):
+        """Return the set of enabled plugins."""
+        return self._plugins.keys()
+
+    def __getitem__(self, name):
+        """
+        Allow plugins to be accessed through the manager as if
+        it were a dictionary.
+        """
+        plugin = self._plugins.get(name, None)
+        if plugin is None:
+            raise PluginNotFound(name)
+        return plugin
+
+    def __iter__(self):
+        """Return an iterator over the set of enabled plugins."""
+        return self._plugins.__iter__()
+
+    def __len__(self):
+        """Return the number of enabled plugins."""
+        return len(self._plugins)
+
+
+class BasePlugin(object):
+
+    #: A short name for the plugin based on the implemented specification.
+    #: For example, a plugin for XEP-0030 would use `'xep_0030'`.
+    name = ''
+
+    #: A longer name for the plugin, describing its purpose. For example,
+    #: a plugin for XEP-0030 would use `'Service Discovery'` as its
+    #: description value.
+    description = ''
+
+    #: Some plugins may depend on others in order to function properly.
+    #: Any plugin names included in :attr:`~BasePlugin.dependencies` will
+    #: be initialized as needed if this plugin is enabled.
+    dependencies = set()
+
+    def __init__(self, xmpp, config=None):
         self.xmpp = xmpp
-        self.config = config
-        self.post_inited = False
-        self.enable = config.get('enable', True)
-        if self.enable:
-            self.plugin_init()
+        if self.xmpp:
+            self.api = self.xmpp.api.wrap(self.name)
+
+        #: A plugin's behaviour may be configurable, in which case those
+        #: configuration settings will be provided as a dictionary.
+        self.config = config if config is not None else {}
 
     def plugin_init(self):
-        """
-        Initialize plugin state, such as registering any stream or
-        event handlers, or new stanza types.
-        """
+        """Initialize plugin state, such as registering event handlers."""
+        pass
+
+    def plugin_end(self):
+        """Cleanup plugin state, and prepare for plugin removal."""
         pass
 
     def post_init(self):
+        """Initialize any cross-plugin state.
+       
+        Only needed if the plugin has circular dependencies.
         """
-        Perform any cross-plugin interactions, such as registering
-        service discovery identities or items.
-        """
-        self.post_inited = True
+        pass
+
+
+base_plugin = BasePlugin

sleekxmpp/plugins/xep_0004/__init__.py

@@ -6,6 +6,17 @@
     See the file LICENSE for copying permission.
 """
 
+from sleekxmpp.plugins.base import register_plugin
+
 from sleekxmpp.plugins.xep_0004.stanza import Form
 from sleekxmpp.plugins.xep_0004.stanza import FormField, FieldOption
-from sleekxmpp.plugins.xep_0004.dataforms import xep_0004
+from sleekxmpp.plugins.xep_0004.dataforms import XEP_0004
+
+
+register_plugin(XEP_0004)
+
+
+# Retain some backwards compatibility
+xep_0004 = XEP_0004
+xep_0004.makeForm = xep_0004.make_form
+xep_0004.buildForm = xep_0004.build_form

sleekxmpp/plugins/xep_0004/dataforms.py

@@ -6,29 +6,27 @@
     See the file LICENSE for copying permission.
 """
 
-import copy
-
-from sleekxmpp.thirdparty import OrderedDict
-
 from sleekxmpp import Message
-from sleekxmpp.xmlstream import register_stanza_plugin, ElementBase, ET
+from sleekxmpp.xmlstream import register_stanza_plugin
 from sleekxmpp.xmlstream.handler import Callback
 from sleekxmpp.xmlstream.matcher import StanzaPath
-from sleekxmpp.plugins.base import base_plugin
+from sleekxmpp.plugins import BasePlugin
 from sleekxmpp.plugins.xep_0004 import stanza
 from sleekxmpp.plugins.xep_0004.stanza import Form, FormField, FieldOption
 
 
-class xep_0004(base_plugin):
+class XEP_0004(BasePlugin):
+
     """
     XEP-0004: Data Forms
     """
 
-    def plugin_init(self):
-        self.xep = '0004'
-        self.description = 'Data Forms'
-        self.stanza = stanza
+    name = 'xep_0004'
+    description = 'XEP-0004: Data Forms'
+    dependencies = set(['xep_0030'])
+    stanza = stanza
 
+    def plugin_init(self):
         self.xmpp.registerHandler(
             Callback('Data Form',
                  StanzaPath('message/form'),
@@ -38,6 +36,8 @@ class xep_0004(base_plugin):
         register_stanza_plugin(Form, FormField, iterable=True)
         register_stanza_plugin(Message, Form)
 
+        self.xmpp['xep_0030'].add_feature('jabber:x:data')
+
     def make_form(self, ftype='form', title='', instructions=''):
         f = Form()
         f['type'] = ftype
@@ -45,16 +45,8 @@ class xep_0004(base_plugin):
         f['instructions'] = instructions
         return f
 
-    def post_init(self):
-        base_plugin.post_init(self)
-        self.xmpp.plugin['xep_0030'].add_feature('jabber:x:data')
-
     def handle_form(self, message):
         self.xmpp.event("message_xform", message)
 
     def build_form(self, xml):
         return Form(xml=xml)
-
-
-xep_0004.makeForm = xep_0004.make_form
-xep_0004.buildForm = xep_0004.build_form

sleekxmpp/plugins/xep_0004/stanza/field.py

@@ -79,19 +79,21 @@ class FormField(ElementBase):
         reqXML = self.xml.find('{%s}required' % self.namespace)
         return reqXML is not None
 
-    def get_value(self):
+    def get_value(self, convert=True):
         valsXML = self.xml.findall('{%s}value' % self.namespace)
         if len(valsXML) == 0:
             return None
         elif self._type == 'boolean':
-            return valsXML[0].text in self.true_values
+            if convert:
+                return valsXML[0].text in self.true_values
+            return valsXML[0].text
         elif self._type in self.multi_value_types or len(valsXML) > 1:
             values = []
             for valXML in valsXML:
                 if valXML.text is None:
                     valXML.text = ''
                 values.append(valXML.text)
-            if self._type == 'text-multi':
+            if self._type == 'text-multi' and convert:
                 values = "\n".join(values)
             return values
         else:
@@ -136,6 +138,8 @@ class FormField(ElementBase):
                 valXML.text = '0'
                 self.xml.append(valXML)
         elif self._type in self.multi_value_types or self._type in ('', None):
+            if isinstance(value, bool):
+                value = [value]
             if not isinstance(value, list):
                 value = value.replace('\r', '')
                 value = value.split('\n')

sleekxmpp/plugins/xep_0009/__init__.py

@@ -6,6 +6,15 @@
     See the file LICENSE for copying permission.
 """
 
+from sleekxmpp.plugins.base import register_plugin
+
 from sleekxmpp.plugins.xep_0009 import stanza
-from sleekxmpp.plugins.xep_0009.rpc import xep_0009
+from sleekxmpp.plugins.xep_0009.rpc import XEP_0009
 from sleekxmpp.plugins.xep_0009.stanza import RPCQuery, MethodCall, MethodResponse
+
+
+register_plugin(XEP_0009)
+
+
+# Retain some backwards compatibility
+xep_0009 = XEP_0009

sleekxmpp/plugins/xep_0009/binding.py

@@ -6,10 +6,14 @@
     See the file LICENSE for copying permission.
 """
 
-from xml.etree import cElementTree as ET
+from sleekxmpp.xmlstream import ET
 import base64
 import logging
 import time
+import sys
+
+if sys.version_info > (3, 0):
+    unicode = str
 
 log = logging.getLogger(__name__)
 
@@ -54,7 +58,7 @@ def _py2xml(*args):
             boolean = ET.Element("{%s}boolean" % _namespace)
             boolean.text = str(int(x))
             val.append(boolean)
-        elif type(x) is str:
+        elif type(x) in (str, unicode):
             string = ET.Element("{%s}string" % _namespace)
             string.text = x
             val.append(string)
@@ -152,7 +156,7 @@ class rpctime(object):
 
     def __init__(self,data=None):
         #assume string data is in iso format YYYYMMDDTHH:MM:SS
-        if type(data) is str:
+        if type(data) in (str, unicode):
             self.timestamp = time.strptime(data,"%Y%m%dT%H:%M:%S")
         elif type(data) is time.struct_time:
             self.timestamp = data

sleekxmpp/plugins/xep_0009/rpc.py

@@ -6,28 +6,28 @@
     See the file LICENSE for copying permission.
 """
 
-from sleekxmpp.plugins import base
-from sleekxmpp.plugins.xep_0009.stanza.RPC import RPCQuery, MethodCall, MethodResponse
-from sleekxmpp.stanza.iq import Iq
-from sleekxmpp.xmlstream.handler.callback import Callback
-from sleekxmpp.xmlstream.matcher.xpath import MatchXPath
-from sleekxmpp.xmlstream.stanzabase import register_stanza_plugin
-from xml.etree import cElementTree as ET
 import logging
 
+from sleekxmpp import Iq
+from sleekxmpp.xmlstream import ET, register_stanza_plugin
+from sleekxmpp.xmlstream.handler import Callback
+from sleekxmpp.xmlstream.matcher import MatchXPath
+from sleekxmpp.plugins import BasePlugin
+from sleekxmpp.plugins.xep_0009 import stanza
+from sleekxmpp.plugins.xep_0009.stanza.RPC import RPCQuery, MethodCall, MethodResponse
 
 
 log = logging.getLogger(__name__)
 
 
+class XEP_0009(BasePlugin):
 
-class xep_0009(base.base_plugin):
+    name = 'xep_0009'
+    description = 'XEP-0009: Jabber-RPC'
+    dependencies = set(['xep_0030'])
+    stanza = stanza
 
     def plugin_init(self):
-        self.xep = '0009'
-        self.description = 'Jabber-RPC'
-        #self.stanza = sleekxmpp.plugins.xep_0009.stanza
-
         register_stanza_plugin(Iq, RPCQuery)
         register_stanza_plugin(RPCQuery, MethodCall)
         register_stanza_plugin(RPCQuery, MethodResponse)
@@ -51,10 +51,8 @@ class xep_0009(base.base_plugin):
         self.xmpp.add_event_handler('error', self._handle_error)
         #self.activeCalls = []
 
-    def post_init(self):
-        base.base_plugin.post_init(self)
-        self.xmpp.plugin['xep_0030'].add_feature('jabber:iq:rpc')
-        self.xmpp.plugin['xep_0030'].add_identity('automation','rpc')
+        self.xmpp['xep_0030'].add_feature('jabber:iq:rpc')
+        self.xmpp['xep_0030'].add_identity('automation','rpc')
 
     def make_iq_method_call(self, pto, pmethod, params):
         iq = self.xmpp.makeIqSet()
@@ -218,4 +216,3 @@ class xep_0009(base.base_plugin):
     def _extract_method(self, stanza):
         xml = ET.fromstring("%s" % stanza)
         return xml.find("./methodCall/methodName").text
-

sleekxmpp/plugins/xep_0012.py

@@ -1,115 +0,0 @@
-"""
-    SleekXMPP: The Sleek XMPP Library
-    Copyright (C) 2010 Nathanael C. Fritz
-    This file is part of SleekXMPP.
-
-    See the file LICENSE for copying permission.
-"""
-
-from datetime import datetime
-import logging
-
-from . import base
-from .. stanza.iq import Iq
-from .. xmlstream.handler.callback import Callback
-from .. xmlstream.matcher.xpath import MatchXPath
-from .. xmlstream import ElementBase, ET, JID, register_stanza_plugin
-
-
-log = logging.getLogger(__name__)
-
-
-class LastActivity(ElementBase):
-    name = 'query'
-    namespace = 'jabber:iq:last'
-    plugin_attrib = 'last_activity'
-    interfaces = set(('seconds', 'status'))
-
-    def get_seconds(self):
-        return int(self._get_attr('seconds'))
-
-    def set_seconds(self, value):
-        self._set_attr('seconds', str(value))
-
-    def get_status(self):
-        return self.xml.text
-
-    def set_status(self, value):
-        self.xml.text = str(value)
-
-    def del_status(self):
-        self.xml.text = ''
-
-class xep_0012(base.base_plugin):
-    """
-    XEP-0012 Last Activity
-    """
-    def plugin_init(self):
-        self.description = "Last Activity"
-        self.xep = "0012"
-
-        self.xmpp.registerHandler(
-            Callback('Last Activity',
-                 MatchXPath('{%s}iq/{%s}query' % (self.xmpp.default_ns,
-                                  LastActivity.namespace)),
-                 self.handle_last_activity_query))
-        register_stanza_plugin(Iq, LastActivity)
-
-        self.xmpp.add_event_handler('last_activity_request', self.handle_last_activity)
-
-
-    def post_init(self):
-        base.base_plugin.post_init(self)
-        if self.xmpp.is_component:
-            # We are a component, so we track the uptime
-            self.xmpp.add_event_handler("session_start", self._reset_uptime)
-            self._start_datetime = datetime.now()
-        self.xmpp.plugin['xep_0030'].add_feature('jabber:iq:last')
-
-    def _reset_uptime(self, event):
-        self._start_datetime = datetime.now()
-
-    def handle_last_activity_query(self, iq):
-        if iq['type'] == 'get':
-            log.debug("Last activity requested by %s", iq['from'])
-            self.xmpp.event('last_activity_request', iq)
-        elif iq['type'] == 'result':
-            log.debug("Last activity result from %s", iq['from'])
-            self.xmpp.event('last_activity', iq)
-
-    def handle_last_activity(self, iq):
-        jid = iq['from']
-
-        if self.xmpp.is_component:
-            # Send the uptime
-            result = LastActivity()
-            td = (datetime.now() - self._start_datetime)
-            result['seconds'] = td.seconds + td.days * 24 * 3600
-            reply = iq.reply().setPayload(result.xml).send()
-        else:
-            barejid = JID(jid).bare
-            if barejid in self.xmpp.roster and ( self.xmpp.roster[barejid]['subscription'] in ('from', 'both') or
-                                                 barejid == self.xmpp.boundjid.bare ):
-                # We don't know how to calculate it
-                iq.reply().error().setPayload(iq['last_activity'].xml)
-                iq['error']['code'] = '503'
-                iq['error']['type'] = 'cancel'
-                iq['error']['condition'] = 'service-unavailable'
-                iq.send()
-            else:
-                iq.reply().error().setPayload(iq['last_activity'].xml)
-                iq['error']['code'] = '403'
-                iq['error']['type'] = 'auth'
-                iq['error']['condition'] = 'forbidden'
-                iq.send()
-
-    def get_last_activity(self, jid):
-        """Query the LastActivity of jid and return it in seconds"""
-        iq = self.xmpp.makeIqGet()
-        query = LastActivity()
-        iq.append(query.xml)
-        iq.attrib['to'] = jid
-        iq.attrib['from'] = self.xmpp.boundjid.full
-        id = iq.get('id')
-        result = iq.send()
-        return result['last_activity']['seconds']

sleekxmpp/plugins/xep_0012/__init__.py

@@ -0,0 +1,19 @@
+"""
+    SleekXMPP: The Sleek XMPP Library
+    Copyright (C) 2012 Nathanael C. Fritz, Lance J.T. Stout
+    This file is part of SleekXMPP.
+
+    See the file LICENSE for copying permission.
+"""
+
+from sleekxmpp.plugins.base import register_plugin
+
+from sleekxmpp.plugins.xep_0012.stanza import LastActivity
+from sleekxmpp.plugins.xep_0012.last_activity import XEP_0012
+
+
+register_plugin(XEP_0012)
+
+
+# Retain some backwards compatibility
+xep_0004 = XEP_0012

sleekxmpp/plugins/xep_0012/last_activity.py

@@ -0,0 +1,152 @@
+"""
+    SleekXMPP: The Sleek XMPP Library
+    Copyright (C) 2012 Nathanael C. Fritz, Lance J.T. Stout
+    This file is part of SleekXMPP.
+
+    See the file LICENSE for copying permission.
+"""
+
+import logging
+from datetime import datetime, timedelta
+
+from sleekxmpp.plugins import BasePlugin, register_plugin
+from sleekxmpp import Iq
+from sleekxmpp.exceptions import XMPPError
+from sleekxmpp.xmlstream import JID, register_stanza_plugin
+from sleekxmpp.xmlstream.handler import Callback
+from sleekxmpp.xmlstream.matcher import StanzaPath
+from sleekxmpp.plugins.xep_0012 import stanza, LastActivity
+
+
+log = logging.getLogger(__name__)
+
+
+class XEP_0012(BasePlugin):
+
+    """
+    XEP-0012 Last Activity
+    """
+
+    name = 'xep_0012'
+    description = 'XEP-0012: Last Activity'
+    dependencies = set(['xep_0030'])
+    stanza = stanza
+
+    def plugin_init(self):
+        register_stanza_plugin(Iq, LastActivity)
+
+        self._last_activities = {}
+
+        self.xmpp.registerHandler(
+            Callback('Last Activity',
+                 StanzaPath('iq@type=get/last_activity'),
+                 self._handle_get_last_activity))
+
+        self.xmpp.plugin['xep_0030'].add_feature('jabber:iq:last')
+
+        self.api.register(self._default_get_last_activity,
+                'get_last_activity',
+                default=True)
+        self.api.register(self._default_set_last_activity,
+                'set_last_activity',
+                default=True)
+        self.api.register(self._default_del_last_activity,
+                'del_last_activity',
+                default=True)
+
+    def begin_idle(self, jid=None, status=None):
+        self.set_last_activity(jid, 0, status)
+
+    def end_idle(self, jid=None):
+        self.del_last_activity(jid)
+
+    def start_uptime(self, status=None):
+        self.set_last_activity(jid, 0, status)
+
+    def set_last_activity(self, jid=None, seconds=None, status=None):
+        self.api['set_last_activity'](jid, args={
+            'seconds': seconds,
+            'status': status})
+
+    def del_last_activity(self, jid):
+        self.api['del_last_activity'](jid)
+
+    def get_last_activity(self, jid, local=False, ifrom=None, block=True,
+                          timeout=None, callback=None):
+        if jid is not None and not isinstance(jid, JID):
+            jid = JID(jid)
+
+        if self.xmpp.is_component:
+            if jid.domain == self.xmpp.boundjid.domain:
+                local = True
+        else:
+            if str(jid) == str(self.xmpp.boundjid):
+                local = True
+        jid = jid.full
+
+        if local or jid in (None, ''):
+            log.debug("Looking up local last activity data for %s", jid)
+            return self.api['get_last_activity'](jid, None, ifrom, None)
+
+        iq = self.xmpp.Iq()
+        iq['from'] = ifrom
+        iq['to'] = jid
+        iq['type'] = 'get'
+        iq.enable('last_activity')
+        return iq.send(timeout=timeout,
+                       block=block,
+                       callback=callback)
+
+    def _handle_get_last_activity(self, iq):
+        log.debug("Received last activity query from " + \
+                  "<%s> to <%s>.", iq['from'], iq['to'])
+        reply = self.api['get_last_activity'](iq['to'], None, iq['from'], iq)
+        reply.send()
+
+    # =================================================================
+    # Default in-memory implementations for storing last activity data.
+    # =================================================================
+
+    def _default_set_last_activity(self, jid, node, ifrom, data):
+        seconds = data.get('seconds', None)
+        if seconds is None:
+            seconds = 0
+
+        status = data.get('status', None)
+        if status is None:
+            status = ''
+
+        self._last_activities[jid] = {
+            'seconds': datetime.now() - timedelta(seconds=seconds),
+            'status': status}
+
+    def _default_del_last_activity(self, jid, node, ifrom, data):
+        if jid in self._last_activities:
+            del self._last_activities[jid]
+
+    def _default_get_last_activity(self, jid, node, ifrom, iq):
+        if not isinstance(iq, Iq):
+            reply = self.xmpp.Iq()
+        else:
+            iq.reply()
+            reply = iq
+
+        if jid not in self._last_activities:
+            raise XMPPError('service-unavailable')
+
+        bare = JID(jid).bare
+
+        if bare != self.xmpp.boundjid.bare:
+            if bare in self.xmpp.roster[jid]:
+                sub = self.xmpp.roster[jid][bare]['subscription']
+                if sub not in ('from', 'both'):
+                    raise XMPPError('forbidden')
+
+        td = datetime.now() - self._last_activities[jid]['seconds']
+        seconds = td.seconds + td.days * 24 * 3600
+        status = self._last_activities[jid]['status']
+
+        reply['last_activity']['seconds'] = seconds
+        reply['last_activity']['status'] = status
+
+        return reply

sleekxmpp/plugins/xep_0012/stanza.py

@@ -0,0 +1,32 @@
+"""
+    SleekXMPP: The Sleek XMPP Library
+    Copyright (C) 2012 Nathanael C. Fritz, Lance J.T. Stout
+    This file is part of SleekXMPP.
+
+    See the file LICENSE for copying permission.
+"""
+
+from sleekxmpp.xmlstream import ElementBase
+
+
+class LastActivity(ElementBase):
+
+    name = 'query'
+    namespace = 'jabber:iq:last'
+    plugin_attrib = 'last_activity'
+    interfaces = set(('seconds', 'status'))
+
+    def get_seconds(self):
+        return int(self._get_attr('seconds'))
+
+    def set_seconds(self, value):
+        self._set_attr('seconds', str(value))
+
+    def get_status(self):
+        return self.xml.text
+
+    def set_status(self, value):
+        self.xml.text = str(value)
+
+    def del_status(self):
+        self.xml.text = ''

sleekxmpp/plugins/xep_0027/__init__.py

@@ -0,0 +1,15 @@
+"""
+    SleekXMPP: The Sleek XMPP Library
+    Copyright (C) 2012 Nathanael C. Fritz, Lance J.T. Stout
+    This file is part of SleekXMPP.
+
+    See the file LICENSE for copying permission.
+"""
+
+from sleekxmpp.plugins.base import register_plugin
+
+from sleekxmpp.plugins.xep_0027.stanza import Signed, Encrypted
+from sleekxmpp.plugins.xep_0027.gpg import XEP_0027
+
+
+register_plugin(XEP_0027)

sleekxmpp/plugins/xep_0027/gpg.py

@@ -0,0 +1,161 @@
+"""
+    SleekXMPP: The Sleek XMPP Library
+    Copyright (C) 2012 Nathanael C. Fritz, Lance J.T. Stout
+    This file is part of SleekXMPP.
+
+    See the file LICENSE for copying permission.
+"""
+
+from sleekxmpp.thirdparty import GPG
+
+from sleekxmpp.stanza import Presence, Message
+from sleekxmpp.plugins.base import BasePlugin, register_plugin
+from sleekxmpp.xmlstream import ElementBase, register_stanza_plugin
+from sleekxmpp.xmlstream.handler import Callback
+from sleekxmpp.xmlstream.matcher import StanzaPath
+from sleekxmpp.plugins.xep_0027 import stanza, Signed, Encrypted
+
+
+def _extract_data(data, kind):
+    stripped = []
+    begin_headers = False
+    begin_data = False
+    for line in data.split('\n'):
+        if not begin_headers and 'BEGIN PGP %s' % kind in line:
+            begin_headers = True
+            continue
+        if begin_headers and line == '':
+            begin_data = True
+            continue
+        if 'END PGP %s' % kind in line:
+            return '\n'.join(stripped)
+        if begin_data:
+            stripped.append(line)
+    return ''
+
+
+class XEP_0027(BasePlugin):
+
+    name = 'xep_0027'
+    description = 'XEP-0027: Current Jabber OpenPGP Usage'
+    dependencies = set()
+    stanza = stanza
+
+    def plugin_init(self):
+        self.gpg_binary = self.config.get('gpg_binary', 'gpg')
+        self.gpg_home = self.config.get('gpg_home', '')
+        self.use_agent = self.config.get('use_agent', True)
+        self.keyring = self.config.get('keyring', None)
+        self.key_server = self.config.get('key_server', 'pgp.mit.edu')
+
+        self.gpg = GPG(gnupghome=self.gpg_home,
+                       gpgbinary=self.gpg_binary,
+                       use_agent=self.use_agent,
+                       keyring=self.keyring)
+
+        self.xmpp.add_filter('out', self._sign_presence)
+
+        self._keyids = {}
+
+        self.api.register(self._set_keyid, 'set_keyid', default=True)
+        self.api.register(self._get_keyid, 'get_keyid', default=True)
+        self.api.register(self._del_keyid, 'del_keyid', default=True)
+        self.api.register(self._get_keyids, 'get_keyids', default=True)
+
+        register_stanza_plugin(Presence, Signed)
+        register_stanza_plugin(Message, Encrypted)
+
+        self.xmpp.add_event_handler('unverified_signed_presence',
+                self._handle_unverified_signed_presence,
+                threaded=True)
+
+        self.xmpp.register_handler(
+                Callback('Signed Presence',
+                    StanzaPath('presence/signed'),
+                    self._handle_signed_presence))
+
+        self.xmpp.register_handler(
+                Callback('Encrypted Message',
+                    StanzaPath('message/encrypted'),
+                    self._handle_encrypted_message))
+
+    def _sign_presence(self, stanza):
+        if isinstance(stanza, Presence):
+            if stanza['type'] == 'available' or stanza['type'] in Presence.showtypes:
+                stanza['signed'] = stanza['status']
+        return stanza
+
+    def sign(self, data, jid=None):
+        keyid = self.get_keyid(jid)
+        if keyid:
+            signed = self.gpg.sign(data, keyid=keyid)
+            return _extract_data(signed.data, 'SIGNATURE')
+
+    def encrypt(self, data, jid=None):
+        keyid = self.get_keyid(jid)
+        if keyid:
+            enc = self.gpg.encrypt(data, keyid)
+            return _extract_data(enc.data, 'MESSAGE')
+
+    def decrypt(self, data, jid=None):
+        template = '-----BEGIN PGP MESSAGE-----\n' + \
+                   '\n' + \
+                   '%s\n' + \
+                   '-----END PGP MESSAGE-----\n'
+        dec = self.gpg.decrypt(template % data)
+        return dec.data
+
+    def verify(self, data, sig, jid=None):
+        template = '-----BEGIN PGP SIGNED MESSAGE-----\n' + \
+                   'Hash: SHA1\n' + \
+                   '\n' + \
+                   '%s\n' + \
+                   '-----BEGIN PGP SIGNATURE-----\n' + \
+                   '\n' + \
+                   '%s\n' + \
+                   '-----END PGP SIGNATURE-----\n'
+        v = self.gpg.verify(template % (data, sig))
+        return v
+
+    def set_keyid(self, jid=None, keyid=None):
+        self.api['set_keyid'](jid, args=keyid)
+
+    def get_keyid(self, jid=None):
+        return self.api['get_keyid'](jid)
+
+    def del_keyid(self, jid=None):
+        self.api['del_keyid'](jid)
+
+    def get_keyids(self):
+        return self.api['get_keyids']()
+
+    def _handle_signed_presence(self, pres):
+        self.xmpp.event('unverified_signed_presence', pres)
+
+    def _handle_unverified_signed_presence(self, pres):
+        verified = self.verify(pres['status'], pres['signed'])
+        if verified.key_id:
+            if not self.get_keyid(pres['from']):
+                known_keyids = [e['keyid'] for e in self.gpg.list_keys()]
+                if verified.key_id not in known_keyids:
+                    self.gpg.recv_keys(self.key_server, verified.key_id)
+                self.set_keyid(jid=pres['from'], keyid=verified.key_id)
+            self.xmpp.event('signed_presence', pres)
+
+    def _handle_encrypted_message(self, msg):
+        self.xmpp.event('encrypted_message', msg)
+
+    # =================================================================
+
+    def _set_keyid(self, jid, node, ifrom, keyid):
+        self._keyids[jid] = keyid
+
+    def _get_keyid(self, jid, node, ifrom, keyid):
+        return self._keyids.get(jid, None)
+
+    def _del_keyid(self, jid, node, ifrom, keyid):
+        if jid in self._keyids:
+            del self._keyids[jid]
+
+    def _get_keyids(self, jid, node, ifrom, data):
+        return self._keyids

sleekxmpp/plugins/xep_0027/stanza.py

@@ -0,0 +1,56 @@
+"""
+    SleekXMPP: The Sleek XMPP Library
+    Copyright (C) 2012 Nathanael C. Fritz, Lance J.T. Stout
+    This file is part of SleekXMPP.
+
+    See the file LICENSE for copying permission.
+"""
+
+from sleekxmpp.xmlstream import ElementBase
+
+
+class Signed(ElementBase):
+    name = 'x'
+    namespace = 'jabber:x:signed'
+    plugin_attrib = 'signed'
+    interfaces = set(['signed'])
+    is_extension = True
+
+    def set_signed(self, value):
+        parent = self.parent()
+        xmpp = parent.stream
+        data = xmpp['xep_0027'].sign(value, parent['from'])
+        if data:
+            self.xml.text = data
+        else:
+            del parent['signed']
+
+    def get_signed(self):
+        return self.xml.text
+
+
+class Encrypted(ElementBase):
+    name = 'x'
+    namespace = 'jabber:x:encrypted'
+    plugin_attrib = 'encrypted'
+    interfaces = set(['encrypted'])
+    is_extension = True
+
+    def set_encrypted(self, value):
+        parent = self.parent()
+        xmpp = parent.stream
+        data = xmpp['xep_0027'].encrypt(value, parent['to'].bare)
+        if data:
+            self.xml.text = data
+        else:
+            del parent['encrypted']
+
+    def get_encrypted(self):
+        parent = self.parent()
+        xmpp = parent.stream
+        if self.xml.text:
+            return xmpp['xep_0027'].decrypt(self.xml.text, parent['to'])
+        return None
+
+
+

sleekxmpp/plugins/xep_0030/__init__.py

@@ -6,7 +6,18 @@
     See the file LICENSE for copying permission.
 """
 
+from sleekxmpp.plugins.base import register_plugin
+
 from sleekxmpp.plugins.xep_0030 import stanza
 from sleekxmpp.plugins.xep_0030.stanza import DiscoInfo, DiscoItems
 from sleekxmpp.plugins.xep_0030.static import StaticDisco
-from sleekxmpp.plugins.xep_0030.disco import xep_0030
+from sleekxmpp.plugins.xep_0030.disco import XEP_0030
+
+
+register_plugin(XEP_0030)
+
+# Retain some backwards compatibility
+xep_0030 = XEP_0030
+XEP_0030.getInfo = XEP_0030.get_info
+XEP_0030.getItems = XEP_0030.get_items
+XEP_0030.make_static = XEP_0030.restore_defaults

sleekxmpp/plugins/xep_0030/disco.py

@@ -8,20 +8,19 @@
 
 import logging
 
-import sleekxmpp
 from sleekxmpp import Iq
-from sleekxmpp.exceptions import XMPPError
-from sleekxmpp.plugins.base import base_plugin
+from sleekxmpp.plugins import BasePlugin
 from sleekxmpp.xmlstream.handler import Callback
 from sleekxmpp.xmlstream.matcher import StanzaPath
-from sleekxmpp.xmlstream import register_stanza_plugin, ElementBase, ET, JID
-from sleekxmpp.plugins.xep_0030 import DiscoInfo, DiscoItems, StaticDisco
+from sleekxmpp.xmlstream import register_stanza_plugin, JID
+from sleekxmpp.plugins.xep_0030 import stanza, DiscoInfo, DiscoItems
+from sleekxmpp.plugins.xep_0030 import StaticDisco
 
 
 log = logging.getLogger(__name__)
 
 
-class xep_0030(base_plugin):
+class XEP_0030(BasePlugin):
 
     """
     XEP-0030: Service Discovery
@@ -85,14 +84,15 @@ class xep_0030(base_plugin):
         add_item         --
     """
 
+    name = 'xep_0030'
+    description = 'XEP-0030: Service Discovery'
+    dependencies = set()
+    stanza = stanza
+
     def plugin_init(self):
         """
         Start the XEP-0030 plugin.
         """
-        self.xep = '0030'
-        self.description = 'Service Discovery'
-        self.stanza = sleekxmpp.plugins.xep_0030.stanza
-
         self.xmpp.register_handler(
                 Callback('Disco Info',
                          StanzaPath('iq/disco_info'),
@@ -106,30 +106,24 @@ class xep_0030(base_plugin):
         register_stanza_plugin(Iq, DiscoInfo)
         register_stanza_plugin(Iq, DiscoItems)
 
-        self.static = StaticDisco(self.xmpp)
+        self.static = StaticDisco(self.xmpp, self)
+
+        self.use_cache = self.config.get('use_cache', True)
+        self.wrap_results = self.config.get('wrap_results', False)
+
+        self._disco_ops = [
+                'get_info', 'set_info', 'set_identities', 'set_features',
+                'get_items', 'set_items', 'del_items', 'add_identity',
+                'del_identity', 'add_feature', 'del_feature', 'add_item',
+                'del_item', 'del_identities', 'del_features', 'cache_info',
+                'get_cached_info', 'supports', 'has_identity']
 
-        self._disco_ops = ['get_info', 'set_identities', 'set_features',
-                           'get_items', 'set_items', 'del_items',
-                           'add_identity', 'del_identity', 'add_feature',
-                           'del_feature', 'add_item', 'del_item',
-                           'del_identities', 'del_features']
-        self.default_handlers = {}
-        self._handlers = {}
         for op in self._disco_ops:
-            self._add_disco_op(op, getattr(self.static, op))
-
-    def post_init(self):
-        """Handle cross-plugin dependencies."""
-        base_plugin.post_init(self)
-        if 'xep_0059' in self.xmpp.plugin:
-            register_stanza_plugin(DiscoItems,
-                                   self.xmpp['xep_0059'].stanza.Set)
+            self.api.register(getattr(self.static, op), op, default=True)
 
     def _add_disco_op(self, op, default_handler):
-        self.default_handlers[op] = default_handler
-        self._handlers[op] = {'global': default_handler,
-                              'jid': {},
-                              'node': {}}
+        self.api.register(default_handler, op)
+        self.api.register_default(default_handler, op)
 
     def set_node_handler(self, htype, jid=None, node=None, handler=None):
         """
@@ -175,20 +169,7 @@ class xep_0030(base_plugin):
                        assumed.
             handler -- The handler function to use.
         """
-        if htype not in self._disco_ops:
-            return
-        if jid is None and node is None:
-            self._handlers[htype]['global'] = handler
-        elif node is None:
-            self._handlers[htype]['jid'][jid] = handler
-        elif jid is None:
-            if self.xmpp.is_component:
-                jid = self.xmpp.boundjid.full
-            else:
-                jid = self.xmpp.boundjid.bare
-            self._handlers[htype]['node'][(jid, node)] = handler
-        else:
-            self._handlers[htype]['node'][(jid, node)] = handler
+        self.api.register(handler, htype, jid, node)
 
     def del_node_handler(self, htype, jid, node):
         """
@@ -211,7 +192,7 @@ class xep_0030(base_plugin):
             jid   -- The JID from which to remove the handler.
             node  -- The node from which to remove the handler.
         """
-        self.set_node_handler(htype, jid, node, None)
+        self.api.unregister(htype, jid, node)
 
     def restore_defaults(self, jid=None, node=None, handlers=None):
         """
@@ -234,10 +215,80 @@ class xep_0030(base_plugin):
         if handlers is None:
             handlers = self._disco_ops
         for op in handlers:
-            self.del_node_handler(op, jid, node)
-            self.set_node_handler(op, jid, node, self.default_handlers[op])
+            self.api.restore_default(op, jid, node)
 
-    def get_info(self, jid=None, node=None, local=False, **kwargs):
+    def supports(self, jid=None, node=None, feature=None, local=False,
+                       cached=True, ifrom=None):
+        """
+        Check if a JID supports a given feature.
+
+        Return values:
+            True  -- The feature is supported
+            False -- The feature is not listed as supported
+            None  -- Nothing could be found due to a timeout
+
+        Arguments:
+            jid      -- Request info from this JID.
+            node     -- The particular node to query.
+            feature  -- The name of the feature to check.
+            local    -- If true, then the query is for a JID/node
+                        combination handled by this Sleek instance and
+                        no stanzas need to be sent.
+                        Otherwise, a disco stanza must be sent to the
+                        remove JID to retrieve the info.
+            cached   -- If true, then look for the disco info data from
+                        the local cache system. If no results are found,
+                        send the query as usual. The self.use_cache
+                        setting must be set to true for this option to
+                        be useful. If set to false, then the cache will
+                        be skipped, even if a result has already been
+                        cached. Defaults to false.
+            ifrom    -- Specifiy the sender's JID.
+        """
+        data = {'feature': feature,
+                'local': local,
+                'cached': cached}
+        return self.api['supports'](jid, node, ifrom, data)
+
+    def has_identity(self, jid=None, node=None, category=None, itype=None,
+                     lang=None, local=False, cached=True, ifrom=None):
+        """
+        Check if a JID provides a given identity.
+
+        Return values:
+            True  -- The identity is provided
+            False -- The identity is not listed
+            None  -- Nothing could be found due to a timeout
+
+        Arguments:
+            jid      -- Request info from this JID.
+            node     -- The particular node to query.
+            category -- The category of the identity to check.
+            itype    -- The type of the identity to check.
+            lang     -- The language of the identity to check.
+            local    -- If true, then the query is for a JID/node
+                        combination handled by this Sleek instance and
+                        no stanzas need to be sent.
+                        Otherwise, a disco stanza must be sent to the
+                        remove JID to retrieve the info.
+            cached   -- If true, then look for the disco info data from
+                        the local cache system. If no results are found,
+                        send the query as usual. The self.use_cache
+                        setting must be set to true for this option to
+                        be useful. If set to false, then the cache will
+                        be skipped, even if a result has already been
+                        cached. Defaults to false.
+            ifrom    -- Specifiy the sender's JID.
+        """
+        data = {'category': category,
+                'itype': itype,
+                'lang': lang,
+                'local': local,
+                'cached': cached}
+        return self.api['has_identity'](jid, node, ifrom, data)
+
+    def get_info(self, jid=None, node=None, local=False,
+                       cached=None, **kwargs):
         """
         Retrieve the disco#info results from a given JID/node combination.
 
@@ -257,6 +308,13 @@ class xep_0030(base_plugin):
                         no stanzas need to be sent.
                         Otherwise, a disco stanza must be sent to the
                         remove JID to retrieve the info.
+            cached   -- If true, then look for the disco info data from
+                        the local cache system. If no results are found,
+                        send the query as usual. The self.use_cache
+                        setting must be set to true for this option to
+                        be useful. If set to false, then the cache will
+                        be skipped, even if a result has already been
+                        cached. Defaults to false.
             ifrom    -- Specifiy the sender's JID.
             block    -- If true, block and wait for the stanzas' reply.
             timeout  -- The time in seconds to block while waiting for
@@ -266,11 +324,35 @@ class xep_0030(base_plugin):
                         received instead of blocking and waiting for
                         the reply.
         """
-        if local or jid is None:
+        if jid is not None and not isinstance(jid, JID):
+            jid = JID(jid)
+            if self.xmpp.is_component:
+                if jid.domain == self.xmpp.boundjid.domain:
+                    local = True
+            else:
+                if str(jid) == str(self.xmpp.boundjid):
+                    local = True
+            jid = jid.full
+        elif jid in (None, ''):
+            local = True
+
+        if local:
             log.debug("Looking up local disco#info data " + \
                       "for %s, node %s.", jid, node)
-            info = self._run_node_handler('get_info', jid, node, kwargs)
-            return self._fix_default_info(info)
+            info = self.api['get_info'](jid, node, 
+                    kwargs.get('ifrom', None), 
+                    kwargs)
+            info = self._fix_default_info(info)
+            return self._wrap(kwargs.get('ifrom', None), jid, info)
+
+        if cached:
+            log.debug("Looking up cached disco#info data " + \
+                      "for %s, node %s.", jid, node)
+            info = self.api['get_cached_info'](jid, node, 
+                    kwargs.get('ifrom', None), 
+                    kwargs)
+            if info is not None:
+                return self._wrap(kwargs.get('ifrom', None), jid, info)
 
         iq = self.xmpp.Iq()
         # Check dfrom parameter for backwards compatibility
@@ -282,6 +364,15 @@ class xep_0030(base_plugin):
                        block=kwargs.get('block', True),
                        callback=kwargs.get('callback', None))
 
+    def set_info(self, jid=None, node=None, info=None):
+        """
+        Set the disco#info data for a JID/node based on an existing
+        disco#info stanza.
+        """
+        if isinstance(info, Iq):
+            info = info['disco_info']
+        self.api['set_info'](jid, node, None, info)
+
     def get_items(self, jid=None, node=None, local=False, **kwargs):
         """
         Retrieve the disco#items results from a given JID/node combination.
@@ -314,7 +405,10 @@ class xep_0030(base_plugin):
                         Otherwise the parameter is ignored.
         """
         if local or jid is None:
-            return self._run_node_handler('get_items', jid, node, kwargs)
+            items = self.api['get_items'](jid, node, 
+                    kwargs.get('ifrom', None), 
+                    kwargs)
+            return self._wrap(kwargs.get('ifrom', None), jid, items)
 
         iq = self.xmpp.Iq()
         # Check dfrom parameter for backwards compatibility
@@ -341,7 +435,7 @@ class xep_0030(base_plugin):
             node  -- Optional node to modify.
             items -- A series of items in tuple format.
         """
-        self._run_node_handler('set_items', jid, node, kwargs)
+        self.api['set_items'](jid, node, None, kwargs)
 
     def del_items(self, jid=None, node=None, **kwargs):
         """
@@ -351,7 +445,7 @@ class xep_0030(base_plugin):
             jid  -- The JID to modify.
             node -- Optional node to modify.
         """
-        self._run_node_handler('del_items', jid, node, kwargs)
+        self.api['del_items'](jid, node, None, kwargs)
 
     def add_item(self, jid='', name='', node=None, subnode='', ijid=None):
         """
@@ -372,7 +466,7 @@ class xep_0030(base_plugin):
         kwargs = {'ijid': jid,
                   'name': name,
                   'inode': subnode}
-        self._run_node_handler('add_item', ijid, node, kwargs)
+        self.api['add_item'](ijid, node, None, kwargs)
 
     def del_item(self, jid=None, node=None, **kwargs):
         """
@@ -384,7 +478,7 @@ class xep_0030(base_plugin):
             ijid  -- The item's JID.
             inode -- The item's node.
         """
-        self._run_node_handler('del_item', jid, node, kwargs)
+        self.api['del_item'](jid, node, None, kwargs)
 
     def add_identity(self, category='', itype='', name='',
                      node=None, jid=None, lang=None):
@@ -411,7 +505,7 @@ class xep_0030(base_plugin):
                   'itype': itype,
                   'name': name,
                   'lang': lang}
-        self._run_node_handler('add_identity', jid, node, kwargs)
+        self.api['add_identity'](jid, node, None, kwargs)
 
     def add_feature(self, feature, node=None, jid=None):
         """
@@ -423,7 +517,7 @@ class xep_0030(base_plugin):
             jid     -- The JID to modify.
         """
         kwargs = {'feature': feature}
-        self._run_node_handler('add_feature', jid, node, kwargs)
+        self.api['add_feature'](jid, node, None, kwargs)
 
     def del_identity(self, jid=None, node=None, **kwargs):
         """
@@ -437,7 +531,7 @@ class xep_0030(base_plugin):
             name     -- Optional, human readable name for the identity.
             lang     -- Optional, the identity's xml:lang value.
         """
-        self._run_node_handler('del_identity', jid, node, kwargs)
+        self.api['del_identity'](jid, node, None, kwargs)
 
     def del_feature(self, jid=None, node=None, **kwargs):
         """
@@ -448,7 +542,7 @@ class xep_0030(base_plugin):
             node    -- The node to modify.
             feature -- The feature's namespace.
         """
-        self._run_node_handler('del_feature', jid, node, kwargs)
+        self.api['del_feature'](jid, node, None, kwargs)
 
     def set_identities(self, jid=None, node=None, **kwargs):
         """
@@ -463,7 +557,7 @@ class xep_0030(base_plugin):
             identities -- A set of identities in tuple form.
             lang       -- Optional, xml:lang value.
         """
-        self._run_node_handler('set_identities', jid, node, kwargs)
+        self.api['set_identities'](jid, node, None, kwargs)
 
     def del_identities(self, jid=None, node=None, **kwargs):
         """
@@ -478,7 +572,7 @@ class xep_0030(base_plugin):
             lang -- Optional. If given, only remove identities
                     using this xml:lang value.
         """
-        self._run_node_handler('del_identities', jid, node, kwargs)
+        self.api['del_identities'](jid, node, None, kwargs)
 
     def set_features(self, jid=None, node=None, **kwargs):
         """
@@ -490,7 +584,7 @@ class xep_0030(base_plugin):
             node     -- The node to modify.
             features -- The new set of supported features.
         """
-        self._run_node_handler('set_features', jid, node, kwargs)
+        self.api['set_features'](jid, node, None, kwargs)
 
     def del_features(self, jid=None, node=None, **kwargs):
         """
@@ -500,9 +594,9 @@ class xep_0030(base_plugin):
             jid  -- The JID to modify.
             node -- The node to modify.
         """
-        self._run_node_handler('del_features', jid, node, kwargs)
+        self.api['del_features'](jid, node, None, kwargs)
 
-    def _run_node_handler(self, htype, jid, node, data={}):
+    def _run_node_handler(self, htype, jid, node=None, ifrom=None, data={}):
         """
         Execute the most specific node handler for the given
         JID/node combination.
@@ -513,22 +607,7 @@ class xep_0030(base_plugin):
             node  -- The node requested.
             data  -- Optional, custom data to pass to the handler.
         """
-        if jid is None:
-            if self.xmpp.is_component:
-                jid = self.xmpp.boundjid.full
-            else:
-                jid = self.xmpp.boundjid.bare
-        if node is None:
-            node = ''
-
-        if self._handlers[htype]['node'].get((jid, node), False):
-            return self._handlers[htype]['node'][(jid, node)](jid, node, data)
-        elif self._handlers[htype]['jid'].get(jid, False):
-            return self._handlers[htype]['jid'][jid](jid, node, data)
-        elif self._handlers[htype]['global']:
-            return self._handlers[htype]['global'](jid, node, data)
-        else:
-            return None
+        return self.api[htype](jid, node, ifrom, data)
 
     def _handle_disco_info(self, iq):
         """
@@ -547,11 +626,12 @@ class xep_0030(base_plugin):
                 jid = iq['to'].full
             else:
                 jid = iq['to'].bare
-            info = self._run_node_handler('get_info',
-                                          jid,
-                                          iq['disco_info']['node'],
-                                          iq)
+            info = self.api['get_info'](jid,
+                                        iq['disco_info']['node'],
+                                        iq['from'],
+                                        iq)
             if isinstance(info, Iq):
+                info['id'] = iq['id']
                 info.send()
             else:
                 iq.reply()
@@ -560,8 +640,19 @@ class xep_0030(base_plugin):
                     iq.set_payload(info.xml)
                 iq.send()
         elif iq['type'] == 'result':
-            log.debug("Received disco info result from" + \
-                      "%s to %s.", iq['from'], iq['to'])
+            log.debug("Received disco info result from " + \
+                      "<%s> to <%s>.", iq['from'], iq['to'])
+            if self.use_cache:
+                log.debug("Caching disco info result from " \
+                      "<%s> to <%s>.", iq['from'], iq['to'])
+                if self.xmpp.is_component:
+                    ito = iq['to'].full
+                else:
+                    ito = None
+                self.api['cache_info'](iq['from'].full,
+                                       iq['disco_info']['node'],
+                                       ito,
+                                       iq)
             self.xmpp.event('disco_info', iq)
 
     def _handle_disco_items(self, iq):
@@ -580,9 +671,9 @@ class xep_0030(base_plugin):
                 jid = iq['to'].full
             else:
                 jid = iq['to'].bare
-            items = self._run_node_handler('get_items',
-                                          jid,
+            items = self.api['get_items'](jid,
                                           iq['disco_items']['node'],
+                                          iq['from'].full,
                                           iq)
             if isinstance(items, Iq):
                 items.send()
@@ -592,7 +683,7 @@ class xep_0030(base_plugin):
                     iq.set_payload(items.xml)
                 iq.send()
         elif iq['type'] == 'result':
-            log.debug("Received disco items result from" + \
+            log.debug("Received disco items result from " + \
                       "%s to %s.", iq['from'], iq['to'])
             self.xmpp.event('disco_items', iq)
 
@@ -607,24 +698,43 @@ class xep_0030(base_plugin):
         Arguments:
             info -- The disco#info quest (not the full Iq stanza) to modify.
         """
+        result = info
+        if isinstance(info, Iq):
+            info = info['disco_info']
         if not info['node']:
             if not info['identities']:
                 if self.xmpp.is_component:
-                    log.debug("No identity found for this entity." + \
+                    log.debug("No identity found for this entity. " + \
                               "Using default component identity.")
                     info.add_identity('component', 'generic')
                 else:
-                    log.debug("No identity found for this entity." + \
+                    log.debug("No identity found for this entity. " + \
                               "Using default client identity.")
                     info.add_identity('client', 'bot')
             if not info['features']:
-                log.debug("No features found for this entity." + \
+                log.debug("No features found for this entity. " + \
                           "Using default disco#info feature.")
                 info.add_feature(info.namespace)
-        return info
+        return result
 
+    def _wrap(self, ito, ifrom, payload, force=False):
+        """
+        Ensure that results are wrapped in an Iq stanza
+        if self.wrap_results has been set to True.
 
-# Retain some backwards compatibility
-xep_0030.getInfo = xep_0030.get_info
-xep_0030.getItems = xep_0030.get_items
-xep_0030.make_static = xep_0030.restore_defaults
+        Arguments:
+            ito     -- The JID to use as the 'to' value
+            ifrom   -- The JID to use as the 'from' value
+            payload -- The disco data to wrap
+            force   -- Force wrapping, regardless of self.wrap_results
+        """
+        if (force or self.wrap_results) and not isinstance(payload, Iq):
+            iq = self.xmpp.Iq()
+            # Since we're simulating a result, we have to treat
+            # the 'from' and 'to' values opposite the normal way.
+            iq['to'] = self.xmpp.boundjid if ito is None else ito
+            iq['from'] = self.xmpp.boundjid if ifrom is None else ifrom
+            iq['type'] = 'result'
+            iq.append(payload)
+            return iq
+        return payload

sleekxmpp/plugins/xep_0030/stanza/info.py

@@ -146,7 +146,7 @@ class DiscoInfo(ElementBase):
                     return True
         return False
 
-    def get_identities(self, lang=None):
+    def get_identities(self, lang=None, dedupe=True):
         """
         Return a set of all identities in tuple form as so:
             (category, type, lang, name)
@@ -155,17 +155,25 @@ class DiscoInfo(ElementBase):
         that language.
 
         Arguments:
-            lang -- Optional, standard xml:lang value.
+            lang   -- Optional, standard xml:lang value.
+            dedupe -- If True, de-duplicate identities, otherwise
+                      return a list of all identities.
         """
-        identities = set()
+        if dedupe:
+            identities = set()
+        else:
+            identities = []
         for id_xml in self.findall('{%s}identity' % self.namespace):
             xml_lang = id_xml.attrib.get('{%s}lang' % self.xml_ns, None)
             if lang is None or xml_lang == lang:
-                identities.add((
-                    id_xml.attrib['category'],
-                    id_xml.attrib['type'],
-                    id_xml.attrib.get('{%s}lang' % self.xml_ns, None),
-                    id_xml.attrib.get('name', None)))
+                id = (id_xml.attrib['category'],
+                      id_xml.attrib['type'],
+                      id_xml.attrib.get('{%s}lang' % self.xml_ns, None),
+                      id_xml.attrib.get('name', None))
+                if dedupe:
+                    identities.add(id)
+                else:
+                    identities.append(id)
         return identities
 
     def set_identities(self, identities, lang=None):
@@ -237,11 +245,17 @@ class DiscoInfo(ElementBase):
                     return True
         return False
 
-    def get_features(self):
+    def get_features(self, dedupe=True):
         """Return the set of all supported features."""
-        features = set()
+        if dedupe:
+            features = set()
+        else:
+            features = []
         for feature_xml in self.findall('{%s}feature' % self.namespace):
-            features.add(feature_xml.attrib['var'])
+            if dedupe:
+                features.add(feature_xml.attrib['var'])
+            else:
+                features.append(feature_xml.attrib['var'])
         return features
 
     def set_features(self, features):

sleekxmpp/plugins/xep_0030/stanza/items.py

@@ -6,7 +6,7 @@
     See the file LICENSE for copying permission.
 """
 
-from sleekxmpp.xmlstream import ElementBase, ET
+from sleekxmpp.xmlstream import ElementBase, register_stanza_plugin
 
 
 class DiscoItems(ElementBase):
@@ -78,13 +78,11 @@ class DiscoItems(ElementBase):
         """
         if (jid, node) not in self._items:
             self._items.add((jid, node))
-            item_xml = ET.Element('{%s}item' % self.namespace)
-            item_xml.attrib['jid'] = jid
-            if name:
-                item_xml.attrib['name'] = name
-            if node:
-                item_xml.attrib['node'] = node
-            self.xml.append(item_xml)
+            item = DiscoItem(parent=self)
+            item['jid'] = jid
+            item['node'] = node
+            item['name'] = name
+            self.iterables.append(item)
             return True
         return False
 
@@ -108,11 +106,9 @@ class DiscoItems(ElementBase):
     def get_items(self):
         """Return all items."""
         items = set()
-        for item_xml in self.findall('{%s}item' % self.namespace):
-            item = (item_xml.attrib['jid'],
-                    item_xml.attrib.get('node'),
-                    item_xml.attrib.get('name'))
-            items.add(item)
+        for item in self['substanzas']:
+            if isinstance(item, DiscoItem):
+                items.add((item['jid'], item['node'], item['name']))
         return items
 
     def set_items(self, items):
@@ -132,5 +128,24 @@ class DiscoItems(ElementBase):
     def del_items(self):
         """Remove all items."""
         self._items = set()
-        for item_xml in self.findall('{%s}item' % self.namespace):
-            self.xml.remove(item_xml)
+        for item in self['substanzas']:
+            if isinstance(item, DiscoItem):
+                self.xml.remove(item.xml)
+
+
+class DiscoItem(ElementBase):
+    name = 'item'
+    namespace = 'http://jabber.org/protocol/disco#items'
+    plugin_attrib = name
+    interfaces = set(('jid', 'node', 'name'))
+
+    def get_node(self):
+        """Return the item's node name or ``None``."""
+        return self._get_attr('node', None)
+
+    def get_name(self):
+        """Return the item's human readable name, or ``None``."""
+        return self._get_attr('name', None)
+
+
+register_stanza_plugin(DiscoItems, DiscoItem, iterable=True)

sleekxmpp/plugins/xep_0030/static.py

@@ -7,14 +7,11 @@
 """
 
 import logging
+import threading
 
-import sleekxmpp
 from sleekxmpp import Iq
-from sleekxmpp.exceptions import XMPPError
-from sleekxmpp.plugins.base import base_plugin
-from sleekxmpp.xmlstream.handler import Callback
-from sleekxmpp.xmlstream.matcher import StanzaPath
-from sleekxmpp.xmlstream import register_stanza_plugin, ElementBase, ET, JID
+from sleekxmpp.exceptions import XMPPError, IqError, IqTimeout
+from sleekxmpp.xmlstream import JID
 from sleekxmpp.plugins.xep_0030 import DiscoInfo, DiscoItems
 
 
@@ -38,7 +35,7 @@ class StaticDisco(object):
         xmpp  -- The main SleekXMPP object.
     """
 
-    def __init__(self, xmpp):
+    def __init__(self, xmpp, disco):
         """
         Create a static disco interface. Sets of disco#info and
         disco#items are maintained for every given JID and node
@@ -50,8 +47,10 @@ class StaticDisco(object):
         """
         self.nodes = {}
         self.xmpp = xmpp
+        self.disco = disco
+        self.lock = threading.RLock()
 
-    def add_node(self, jid=None, node=None):
+    def add_node(self, jid=None, node=None, ifrom=None):
         """
         Create a new set of stanzas for the provided
         JID and node combination.
@@ -60,83 +59,213 @@ class StaticDisco(object):
             jid  -- The JID that will own the new stanzas.
             node -- The node that will own the new stanzas.
         """
-        if jid is None:
-            jid = self.xmpp.boundjid.full
-        if node is None:
-            node = ''
-        if (jid, node) not in self.nodes:
-            self.nodes[(jid, node)] = {'info': DiscoInfo(),
-                                       'items': DiscoItems()}
-            self.nodes[(jid, node)]['info']['node'] = node
-            self.nodes[(jid, node)]['items']['node'] = node
+        with self.lock:
+            if jid is None:
+                jid = self.xmpp.boundjid.full
+            if node is None:
+                node = ''
+            if ifrom is None:
+                ifrom = ''
+            if isinstance(ifrom, JID):
+                ifrom = ifrom.full
+            if (jid, node, ifrom) not in self.nodes:
+                self.nodes[(jid, node, ifrom)] = {'info': DiscoInfo(),
+                                           'items': DiscoItems()}
+                self.nodes[(jid, node, ifrom)]['info']['node'] = node
+                self.nodes[(jid, node, ifrom)]['items']['node'] = node
+
+    def get_node(self, jid=None, node=None, ifrom=None):
+        with self.lock:
+            if jid is None:
+                jid = self.xmpp.boundjid.full
+            if node is None:
+                node = ''
+            if ifrom is None:
+                ifrom = ''
+            if isinstance(ifrom, JID):
+                ifrom = ifrom.full
+            if (jid, node, ifrom) not in self.nodes:
+                self.add_node(jid, node, ifrom)
+            return self.nodes[(jid, node, ifrom)]
+
+    def node_exists(self, jid=None, node=None, ifrom=None):
+        with self.lock:
+            if jid is None:
+                jid = self.xmpp.boundjid.full
+            if node is None:
+                node = ''
+            if ifrom is None:
+                ifrom = ''
+            if isinstance(ifrom, JID):
+                ifrom = ifrom.full
+            if (jid, node, ifrom) not in self.nodes:
+                return False
+            return True
 
     # =================================================================
     # Node Handlers
     #
-    # Each handler accepts three arguments: jid, node, and data.
-    # The jid and node parameters together determine the set of
-    # info and items stanzas that will be retrieved or added.
-    # The data parameter is a dictionary with additional paramters
-    # that will be passed to other calls.
+    # Each handler accepts four arguments: jid, node, ifrom, and data.
+    # The jid and node parameters together determine the set of info
+    # and items stanzas that will be retrieved or added. Additionally,
+    # the ifrom value allows for cached results when results vary based
+    # on the requester's JID. The data parameter is a dictionary with
+    # additional parameters that will be passed to other calls.
+    #
+    # This implementation does not allow different responses based on
+    # the requester's JID, except for cached results. To do that,
+    # register a custom node handler.
 
-    def get_info(self, jid, node, data):
+    def supports(self, jid, node, ifrom, data):
+        """
+        Check if a JID supports a given feature.
+
+        The data parameter may provide:
+            feature  -- The feature to check for support.
+            local    -- If true, then the query is for a JID/node
+                        combination handled by this Sleek instance and
+                        no stanzas need to be sent.
+                        Otherwise, a disco stanza must be sent to the
+                        remove JID to retrieve the info.
+            cached   -- If true, then look for the disco info data from
+                        the local cache system. If no results are found,
+                        send the query as usual. The self.use_cache
+                        setting must be set to true for this option to
+                        be useful. If set to false, then the cache will
+                        be skipped, even if a result has already been
+                        cached. Defaults to false.
+        """
+        feature = data.get('feature', None)
+
+        data = {'local': data.get('local', False),
+                'cached': data.get('cached', True)}
+
+        if not feature:
+            return False
+
+        try:
+            info = self.disco.get_info(jid=jid, node=node,
+                                       ifrom=ifrom, **data)
+            info = self.disco._wrap(ifrom, jid, info, True)
+            features = info['disco_info']['features']
+            return feature in features
+        except IqError:
+            return False
+        except IqTimeout:
+            return None
+
+    def has_identity(self, jid, node, ifrom, data):
+        """
+        Check if a JID has a given identity.
+
+        The data parameter may provide:
+            category -- The category of the identity to check.
+            itype    -- The type of the identity to check.
+            lang     -- The language of the identity to check.
+            local    -- If true, then the query is for a JID/node
+                        combination handled by this Sleek instance and
+                        no stanzas need to be sent.
+                        Otherwise, a disco stanza must be sent to the
+                        remove JID to retrieve the info.
+            cached   -- If true, then look for the disco info data from
+                        the local cache system. If no results are found,
+                        send the query as usual. The self.use_cache
+                        setting must be set to true for this option to
+                        be useful. If set to false, then the cache will
+                        be skipped, even if a result has already been
+                        cached. Defaults to false.
+        """
+        identity = (data.get('category', None),
+                    data.get('itype', None),
+                    data.get('lang', None))
+
+        data = {'local': data.get('local', False),
+                'cached': data.get('cached', True)}
+
+        try:
+            info = self.disco.get_info(jid=jid, node=node,
+                                       ifrom=ifrom, **data)
+            info = self.disco._wrap(ifrom, jid, info, True)
+            trunc = lambda i: (i[0], i[1], i[2])
+            return identity in map(trunc, info['disco_info']['identities'])
+        except IqError:
+            return False
+        except IqTimeout:
+            return None
+
+    def get_info(self, jid, node, ifrom, data):
         """
         Return the stored info data for the requested JID/node combination.
 
         The data parameter is not used.
         """
-        if (jid, node) not in self.nodes:
-            if not node:
-                return DiscoInfo()
+        with self.lock:
+            if not self.node_exists(jid, node):
+                if not node:
+                    return DiscoInfo()
+                else:
+                    raise XMPPError(condition='item-not-found')
             else:
-                raise XMPPError(condition='item-not-found')
-        else:
-            return self.nodes[(jid, node)]['info']
+                return self.get_node(jid, node)['info']
 
-    def del_info(self, jid, node, data):
+    def set_info(self, jid, node, ifrom, data):
+        """
+        Set the entire info stanza for a JID/node at once.
+
+        The data parameter is a disco#info substanza.
+        """
+        with self.lock:
+            self.add_node(jid, node)
+            self.get_node(jid, node)['info'] = data
+
+    def del_info(self, jid, node, ifrom, data):
         """
         Reset the info stanza for a given JID/node combination.
 
         The data parameter is not used.
         """
-        if (jid, node) in self.nodes:
-            self.nodes[(jid, node)]['info'] = DiscoInfo()
+        with self.lock:
+            if self.node_exists(jid, node):
+                self.get_node(jid, node)['info'] = DiscoInfo()
 
-    def get_items(self, jid, node, data):
+    def get_items(self, jid, node, ifrom, data):
         """
         Return the stored items data for the requested JID/node combination.
 
         The data parameter is not used.
         """
-        if (jid, node) not in self.nodes:
-            if not node:
-                return DiscoInfo()
+        with self.lock:
+            if not self.node_exists(jid, node):
+                if not node:
+                    return DiscoInfo()
+                else:
+                    raise XMPPError(condition='item-not-found')
             else:
-                raise XMPPError(condition='item-not-found')
-        else:
-            return self.nodes[(jid, node)]['items']
+                return self.get_node(jid, node)['items']
 
-    def set_items(self, jid, node, data):
+    def set_items(self, jid, node, ifrom, data):
         """
         Replace the stored items data for a JID/node combination.
 
-        The data parameter may provided:
+        The data parameter may provide:
             items -- A set of items in tuple format.
         """
-        items = data.get('items', set())
-        self.add_node(jid, node)
-        self.nodes[(jid, node)]['items']['items'] = items
+        with self.lock:
+            items = data.get('items', set())
+            self.add_node(jid, node)
+            self.get_node(jid, node)['items']['items'] = items
 
-    def del_items(self, jid, node, data):
+    def del_items(self, jid, node, ifrom, data):
         """
         Reset the items stanza for a given JID/node combination.
 
         The data parameter is not used.
         """
-        if (jid, node) in self.nodes:
-            self.nodes[(jid, node)]['items'] = DiscoItems()
+        with self.lock:
+            if self.node_exists(jid, node):
+                self.get_node(jid, node)['items'] = DiscoItems()
 
-    def add_identity(self, jid, node, data):
+    def add_identity(self, jid, node, ifrom, data):
         """
         Add a new identity to te JID/node combination.
 
@@ -146,14 +275,15 @@ class StaticDisco(object):
             name     -- Optional human readable name for this identity.
             lang     -- Optional standard xml:lang value.
         """
-        self.add_node(jid, node)
-        self.nodes[(jid, node)]['info'].add_identity(
-                data.get('category', ''),
-                data.get('itype', ''),
-                data.get('name', None),
-                data.get('lang', None))
+        with self.lock:
+            self.add_node(jid, node)
+            self.get_node(jid, node)['info'].add_identity(
+                    data.get('category', ''),
+                    data.get('itype', ''),
+                    data.get('name', None),
+                    data.get('lang', None))
 
-    def set_identities(self, jid, node, data):
+    def set_identities(self, jid, node, ifrom, data):
         """
         Add or replace all identities for a JID/node combination.
 
@@ -161,11 +291,12 @@ class StaticDisco(object):
             identities -- A list of identities in tuple form:
                             (category, type, name, lang)
         """
-        identities = data.get('identities', set())
-        self.add_node(jid, node)
-        self.nodes[(jid, node)]['info']['identities'] = identities
+        with self.lock:
+            identities = data.get('identities', set())
+            self.add_node(jid, node)
+            self.get_node(jid, node)['info']['identities'] = identities
 
-    def del_identity(self, jid, node, data):
+    def del_identity(self, jid, node, ifrom, data):
         """
         Remove an identity from a JID/node combination.
 
@@ -175,67 +306,72 @@ class StaticDisco(object):
             name     -- Optional human readable name for this identity.
             lang     -- Optional, standard xml:lang value.
         """
-        if (jid, node) not in self.nodes:
-            return
-        self.nodes[(jid, node)]['info'].del_identity(
-                data.get('category', ''),
-                data.get('itype', ''),
-                data.get('name', None),
-                data.get('lang', None))
+        with self.lock:
+            if self.node_exists(jid, node):
+                self.get_node(jid, node)['info'].del_identity(
+                        data.get('category', ''),
+                        data.get('itype', ''),
+                        data.get('name', None),
+                        data.get('lang', None))
 
-    def del_identities(self, jid, node, data):
+    def del_identities(self, jid, node, ifrom, data):
         """
         Remove all identities from a JID/node combination.
 
         The data parameter is not used.
         """
-        if (jid, node) not in self.nodes:
-            return
-        del self.nodes[(jid, node)]['info']['identities']
+        with self.lock:
+            if self.node_exists(jid, node):
+                del self.get_node(jid, node)['info']['identities']
 
-    def add_feature(self, jid, node, data):
+    def add_feature(self, jid, node, ifrom, data):
         """
         Add a feature to a JID/node combination.
 
         The data parameter should include:
             feature -- The namespace of the supported feature.
         """
-        self.add_node(jid, node)
-        self.nodes[(jid, node)]['info'].add_feature(data.get('feature', ''))
+        with self.lock:
+            self.add_node(jid, node)
+            self.get_node(jid, node)['info'].add_feature(
+                    data.get('feature', ''))
 
-    def set_features(self, jid, node, data):
+    def set_features(self, jid, node, ifrom, data):
         """
         Add or replace all features for a JID/node combination.
 
         The data parameter should include:
             features -- The new set of supported features.
         """
-        features = data.get('features', set())
-        self.add_node(jid, node)
-        self.nodes[(jid, node)]['info']['features'] = features
+        with self.lock:
+            features = data.get('features', set())
+            self.add_node(jid, node)
+            self.get_node(jid, node)['info']['features'] = features
 
-    def del_feature(self, jid, node, data):
+    def del_feature(self, jid, node, ifrom, data):
         """
         Remove a feature from a JID/node combination.
 
         The data parameter should include:
             feature -- The namespace of the removed feature.
         """
-        if (jid, node) not in self.nodes:
-            return
-        self.nodes[(jid, node)]['info'].del_feature(data.get('feature', ''))
+        with self.lock:
+            if self.node_exists(jid, node):
+                self.get_node(jid, node)['info'].del_feature(
+                        data.get('feature', ''))
 
-    def del_features(self, jid, node, data):
+    def del_features(self, jid, node, ifrom, data):
         """
         Remove all features from a JID/node combination.
 
         The data parameter is not used.
         """
-        if (jid, node) not in self.nodes:
-            return
-        del self.nodes[(jid, node)]['info']['features']
+        with self.lock:
+            if not self.node_exists(jid, node):
+                return
+            del self.get_node(jid, node)['info']['features']
 
-    def add_item(self, jid, node, data):
+    def add_item(self, jid, node, ifrom, data):
         """
         Add an item to a JID/node combination.
 
@@ -245,13 +381,14 @@ class StaticDisco(object):
                      non-addressable items.
             name  -- Optional human readable name for the item.
         """
-        self.add_node(jid, node)
-        self.nodes[(jid, node)]['items'].add_item(
-                data.get('ijid', ''),
-                node=data.get('inode', ''),
-                name=data.get('name', ''))
+        with self.lock:
+            self.add_node(jid, node)
+            self.get_node(jid, node)['items'].add_item(
+                    data.get('ijid', ''),
+                    node=data.get('inode', ''),
+                    name=data.get('name', ''))
 
-    def del_item(self, jid, node, data):
+    def del_item(self, jid, node, ifrom, data):
         """
         Remove an item from a JID/node combination.
 
@@ -259,7 +396,38 @@ class StaticDisco(object):
             ijid  -- JID of the item to remove.
             inode -- Optional extra identifying information.
         """
-        if (jid, node) in self.nodes:
-            self.nodes[(jid, node)]['items'].del_item(
-                    data.get('ijid', ''),
-                    node=data.get('inode', None))
+        with self.lock:
+            if self.node_exists(jid, node):
+                self.get_node(jid, node)['items'].del_item(
+                        data.get('ijid', ''),
+                        node=data.get('inode', None))
+
+    def cache_info(self, jid, node, ifrom, data):
+        """
+        Cache disco information for an external JID.
+
+        The data parameter is the Iq result stanza
+        containing the disco info to cache, or
+        the disco#info substanza itself.
+        """
+        with self.lock:
+            if isinstance(data, Iq):
+                data = data['disco_info']
+
+            self.add_node(jid, node, ifrom)
+            self.get_node(jid, node, ifrom)['info'] = data
+
+    def get_cached_info(self, jid, node, ifrom, data):
+        """
+        Retrieve cached disco info data.
+
+        The data parameter is not used.
+        """
+        with self.lock:
+            if isinstance(jid, JID):
+                jid = jid.full
+
+            if not self.node_exists(jid, node, ifrom):
+                return None
+            else:
+                return self.get_node(jid, node, ifrom)['info']

sleekxmpp/plugins/xep_0033.py

@@ -7,155 +7,161 @@
 """
 
 import logging
-from . import base
-from .. xmlstream.handler.callback import Callback
-from .. xmlstream.matcher.xpath import MatchXPath
-from .. xmlstream.stanzabase import registerStanzaPlugin, ElementBase, ET, JID
-from .. stanza.message import Message
+from sleekxmpp import Message
+from sleekxmpp.xmlstream.handler.callback import Callback
+from sleekxmpp.xmlstream.matcher.xpath import MatchXPath
+from sleekxmpp.xmlstream import register_stanza_plugin, ElementBase, ET, JID
+from sleekxmpp.plugins import BasePlugin, register_plugin
 
 
 class Addresses(ElementBase):
-	namespace = 'http://jabber.org/protocol/address'
-	name = 'addresses'
-	plugin_attrib = 'addresses'
-	interfaces = set(('addresses', 'bcc', 'cc', 'noreply', 'replyroom', 'replyto', 'to'))
+    namespace = 'http://jabber.org/protocol/address'
+    name = 'addresses'
+    plugin_attrib = 'addresses'
+    interfaces = set(('addresses', 'bcc', 'cc', 'noreply', 'replyroom', 'replyto', 'to'))
 
-	def addAddress(self, atype='to', jid='', node='', uri='', desc='', delivered=False):
-		address = Address(parent=self)
-		address['type'] = atype
-		address['jid'] = jid
-		address['node'] = node
-		address['uri'] = uri
-		address['desc'] = desc
-		address['delivered'] = delivered
-		return address
+    def addAddress(self, atype='to', jid='', node='', uri='', desc='', delivered=False):
+        address = Address(parent=self)
+        address['type'] = atype
+        address['jid'] = jid
+        address['node'] = node
+        address['uri'] = uri
+        address['desc'] = desc
+        address['delivered'] = delivered
+        return address
 
-	def getAddresses(self, atype=None):
-		addresses = []
-		for addrXML in self.xml.findall('{%s}address' % Address.namespace):
-			# ElementTree 1.2.6 does not support [@attr='value'] in findall
-			if atype is None or addrXML.attrib.get('type') == atype:
-				addresses.append(Address(xml=addrXML, parent=None))
-		return addresses
+    def getAddresses(self, atype=None):
+        addresses = []
+        for addrXML in self.xml.findall('{%s}address' % Address.namespace):
+            # ElementTree 1.2.6 does not support [@attr='value'] in findall
+            if atype is None or addrXML.attrib.get('type') == atype:
+                addresses.append(Address(xml=addrXML, parent=None))
+        return addresses
 
-	def setAddresses(self, addresses, set_type=None):
-		self.delAddresses(set_type)
-		for addr in addresses:
-			addr = dict(addr)
-			# Remap 'type' to 'atype' to match the add method
-			if set_type is not None:
-				addr['type'] = set_type
-			curr_type = addr.get('type', None)
-			if curr_type is not None:
-				del addr['type']
-				addr['atype'] = curr_type
-			self.addAddress(**addr)
+    def setAddresses(self, addresses, set_type=None):
+        self.delAddresses(set_type)
+        for addr in addresses:
+            addr = dict(addr)
+            # Remap 'type' to 'atype' to match the add method
+            if set_type is not None:
+                addr['type'] = set_type
+            curr_type = addr.get('type', None)
+            if curr_type is not None:
+                del addr['type']
+                addr['atype'] = curr_type
+            self.addAddress(**addr)
 
-	def delAddresses(self, atype=None):
-		if atype is None:
-			return
-		for addrXML in self.xml.findall('{%s}address' % Address.namespace):
-			# ElementTree 1.2.6 does not support [@attr='value'] in findall
-			if addrXML.attrib.get('type') == atype:
-				self.xml.remove(addrXML)
+    def delAddresses(self, atype=None):
+        if atype is None:
+            return
+        for addrXML in self.xml.findall('{%s}address' % Address.namespace):
+            # ElementTree 1.2.6 does not support [@attr='value'] in findall
+            if addrXML.attrib.get('type') == atype:
+                self.xml.remove(addrXML)
 
-	# --------------------------------------------------------------
+    # --------------------------------------------------------------
 
-	def delBcc(self):
-		self.delAddresses('bcc')
+    def delBcc(self):
+        self.delAddresses('bcc')
 
-	def delCc(self):
-		self.delAddresses('cc')
+    def delCc(self):
+        self.delAddresses('cc')
 
-	def delNoreply(self):
-		self.delAddresses('noreply')
+    def delNoreply(self):
+        self.delAddresses('noreply')
 
-	def delReplyroom(self):
-		self.delAddresses('replyroom')
+    def delReplyroom(self):
+        self.delAddresses('replyroom')
 
-	def delReplyto(self):
-		self.delAddresses('replyto')
+    def delReplyto(self):
+        self.delAddresses('replyto')
 
-	def delTo(self):
-		self.delAddresses('to')
+    def delTo(self):
+        self.delAddresses('to')
 
-	# --------------------------------------------------------------
+    # --------------------------------------------------------------
 
-	def getBcc(self):
-		return self.getAddresses('bcc')
+    def getBcc(self):
+        return self.getAddresses('bcc')
 
-	def getCc(self):
-		return self.getAddresses('cc')
+    def getCc(self):
+        return self.getAddresses('cc')
 
-	def getNoreply(self):
-		return self.getAddresses('noreply')
+    def getNoreply(self):
+        return self.getAddresses('noreply')
 
-	def getReplyroom(self):
-		return self.getAddresses('replyroom')
+    def getReplyroom(self):
+        return self.getAddresses('replyroom')
 
-	def getReplyto(self):
-		return self.getAddresses('replyto')
+    def getReplyto(self):
+        return self.getAddresses('replyto')
 
-	def getTo(self):
-		return self.getAddresses('to')
+    def getTo(self):
+        return self.getAddresses('to')
 
-	# --------------------------------------------------------------
+    # --------------------------------------------------------------
 
-	def setBcc(self, addresses):
-		self.setAddresses(addresses, 'bcc')
+    def setBcc(self, addresses):
+        self.setAddresses(addresses, 'bcc')
 
-	def setCc(self, addresses):
-		self.setAddresses(addresses, 'cc')
+    def setCc(self, addresses):
+        self.setAddresses(addresses, 'cc')
 
-	def setNoreply(self, addresses):
-		self.setAddresses(addresses, 'noreply')
+    def setNoreply(self, addresses):
+        self.setAddresses(addresses, 'noreply')
 
-	def setReplyroom(self, addresses):
-		self.setAddresses(addresses, 'replyroom')
+    def setReplyroom(self, addresses):
+        self.setAddresses(addresses, 'replyroom')
 
-	def setReplyto(self, addresses):
-		self.setAddresses(addresses, 'replyto')
+    def setReplyto(self, addresses):
+        self.setAddresses(addresses, 'replyto')
 
-	def setTo(self, addresses):
-		self.setAddresses(addresses, 'to')
+    def setTo(self, addresses):
+        self.setAddresses(addresses, 'to')
 
 
 class Address(ElementBase):
-	namespace = 'http://jabber.org/protocol/address'
-	name = 'address'
-	plugin_attrib = 'address'
-	interfaces = set(('delivered', 'desc', 'jid', 'node', 'type', 'uri'))
-	address_types = set(('bcc', 'cc', 'noreply', 'replyroom', 'replyto', 'to'))
+    namespace = 'http://jabber.org/protocol/address'
+    name = 'address'
+    plugin_attrib = 'address'
+    interfaces = set(('delivered', 'desc', 'jid', 'node', 'type', 'uri'))
+    address_types = set(('bcc', 'cc', 'noreply', 'replyroom', 'replyto', 'to'))
 
-	def getDelivered(self):
-		return self.xml.attrib.get('delivered', False)
+    def getDelivered(self):
+        return self.xml.attrib.get('delivered', False)
 
-	def setDelivered(self, delivered):
-		if delivered:
-			self.xml.attrib['delivered'] = "true"
-		else:
-			del self['delivered']
+    def setDelivered(self, delivered):
+        if delivered:
+            self.xml.attrib['delivered'] = "true"
+        else:
+            del self['delivered']
 
-	def setUri(self, uri):
-		if uri:
-			del self['jid']
-			del self['node']
-			self.xml.attrib['uri'] = uri
-		elif 'uri' in self.xml.attrib:
-			del self.xml.attrib['uri']
+    def setUri(self, uri):
+        if uri:
+            del self['jid']
+            del self['node']
+            self.xml.attrib['uri'] = uri
+        elif 'uri' in self.xml.attrib:
+            del self.xml.attrib['uri']
 
 
-class xep_0033(base.base_plugin):
-	"""
-	XEP-0033: Extended Stanza Addressing
-	"""
+class XEP_0033(BasePlugin):
 
-	def plugin_init(self):
-		self.xep = '0033'
-		self.description = 'Extended Stanza Addressing'
+    """
+    XEP-0033: Extended Stanza Addressing
+    """
 
-		registerStanzaPlugin(Message, Addresses)
+    name = 'xep_0033'
+    description = 'XEP-0033: Extended Stanza Addressing'
+    dependencies = set(['xep_0033'])
 
-	def post_init(self):
-		base.base_plugin.post_init(self)
-		self.xmpp.plugin['xep_0030'].add_feature(Addresses.namespace)
+    def plugin_init(self):
+        self.xep = '0033'
+
+        register_stanza_plugin(Message, Addresses)
+
+        self.xmpp.plugin['xep_0030'].add_feature(Addresses.namespace)
+
+
+xep_0033 = XEP_0033
+register_plugin(XEP_0033)

sleekxmpp/plugins/xep_0045.py

@@ -6,14 +6,15 @@
     See the file LICENSE for copying permission.
 """
 from __future__ import with_statement
-from . import base
+
 import logging
-from xml.etree import cElementTree as ET
-from .. xmlstream.stanzabase import registerStanzaPlugin, ElementBase, JID
-from .. stanza.presence import Presence
-from .. xmlstream.handler.callback import Callback
-from .. xmlstream.matcher.xpath import MatchXPath
-from .. xmlstream.matcher.xmlmask import MatchXMLMask
+
+from sleekxmpp import Presence
+from sleekxmpp.plugins import BasePlugin, register_plugin
+from sleekxmpp.xmlstream import register_stanza_plugin, ElementBase, JID, ET
+from sleekxmpp.xmlstream.handler.callback import Callback
+from sleekxmpp.xmlstream.matcher.xpath import MatchXPath
+from sleekxmpp.xmlstream.matcher.xmlmask import MatchXMLMask
 from sleekxmpp.exceptions import IqError, IqTimeout
 
 
@@ -107,22 +108,31 @@ class MUCPresence(ElementBase):
         log.warning("Cannot delete room through mucpresence plugin.")
         return self
 
-class xep_0045(base.base_plugin):
+
+class XEP_0045(BasePlugin):
+
     """
-    Implements XEP-0045 Multi User Chat
+    Implements XEP-0045 Multi-User Chat
     """
 
+    name = 'xep_0045'
+    description = 'XEP-0045: Multi-User Chat'
+    dependencies = set(['xep_0030', 'xep_0004'])
+
     def plugin_init(self):
         self.rooms = {}
         self.ourNicks = {}
         self.xep = '0045'
-        self.description = 'Multi User Chat'
         # load MUC support in presence stanzas
-        registerStanzaPlugin(Presence, MUCPresence)
+        register_stanza_plugin(Presence, MUCPresence)
         self.xmpp.registerHandler(Callback('MUCPresence', MatchXMLMask("<presence xmlns='%s' />" % self.xmpp.default_ns), self.handle_groupchat_presence))
         self.xmpp.registerHandler(Callback('MUCMessage', MatchXMLMask("<message xmlns='%s' type='groupchat'><body/></message>" % self.xmpp.default_ns), self.handle_groupchat_message))
         self.xmpp.registerHandler(Callback('MUCSubject', MatchXMLMask("<message xmlns='%s' type='groupchat'><subject/></message>" % self.xmpp.default_ns), self.handle_groupchat_subject))
-        self.xmpp.registerHandler(Callback('MUCInvite', MatchXPath("{%s}message/{http://jabber.org/protocol/muc#user}x/invite" % self.xmpp.default_ns), self.handle_groupchat_invite))
+        self.xmpp.registerHandler(Callback('MUCConfig', MatchXMLMask("<message xmlns='%s' type='groupchat'><x xmlns='http://jabber.org/protocol/muc#user'><status/></x></message>" % self.xmpp.default_ns), self.handle_config_change))
+        self.xmpp.registerHandler(Callback('MUCInvite', MatchXPath("{%s}message/{%s}x/{%s}invite" % (
+            self.xmpp.default_ns,
+            'http://jabber.org/protocol/muc#user',
+            'http://jabber.org/protocol/muc#user')), self.handle_groupchat_invite))
 
     def handle_groupchat_invite(self, inv):
         """ Handle an invite into a muc.
@@ -131,6 +141,11 @@ class xep_0045(base.base_plugin):
         if inv['from'] not in self.rooms.keys():
             self.xmpp.event("groupchat_invite", inv)
 
+    def handle_config_change(self, msg):
+        """Handle a MUC configuration change (with status code)."""
+        self.xmpp.event('groupchat_config_status', msg)
+        self.xmpp.event('muc::%s::config_status' % msg['from'].bare , msg)
+
     def handle_groupchat_presence(self, pr):
         """ Handle a presence in a muc.
         """
@@ -374,3 +389,7 @@ class xep_0045(base.base_plugin):
         if room not in self.rooms.keys():
             return None
         return self.rooms[room].keys()
+
+
+xep_0045 = XEP_0045
+register_plugin(XEP_0045)

sleekxmpp/plugins/xep_0047/__init__.py

@@ -0,0 +1,21 @@
+"""
+    SleekXMPP: The Sleek XMPP Library
+    Copyright (C) 2012 Nathanael C. Fritz, Lance J.T. Stout
+    This file is part of SleekXMPP.
+
+    See the file LICENSE for copying permission.
+"""
+
+from sleekxmpp.plugins.base import register_plugin
+
+from sleekxmpp.plugins.xep_0047 import stanza
+from sleekxmpp.plugins.xep_0047.stanza import Open, Close, Data
+from sleekxmpp.plugins.xep_0047.stream import IBBytestream
+from sleekxmpp.plugins.xep_0047.ibb import XEP_0047
+
+
+register_plugin(XEP_0047)
+
+
+# Retain some backwards compatibility
+xep_0047 = XEP_0047

sleekxmpp/plugins/xep_0047/ibb.py

@@ -0,0 +1,148 @@
+import uuid
+import logging
+import threading
+
+from sleekxmpp import Message, Iq
+from sleekxmpp.exceptions import XMPPError
+from sleekxmpp.xmlstream.handler import Callback
+from sleekxmpp.xmlstream.matcher import StanzaPath
+from sleekxmpp.xmlstream import register_stanza_plugin
+from sleekxmpp.plugins import BasePlugin
+from sleekxmpp.plugins.xep_0047 import stanza, Open, Close, Data, IBBytestream
+
+
+log = logging.getLogger(__name__)
+
+
+class XEP_0047(BasePlugin):
+
+    name = 'xep_0047'
+    description = 'XEP-0047: In-band Bytestreams'
+    dependencies = set(['xep_0030'])
+    stanza = stanza
+
+    def plugin_init(self):
+        self.streams = {}
+        self.pending_streams = {3: 5}
+        self.pending_close_streams = {}
+        self._stream_lock = threading.Lock()
+
+        self.max_block_size = self.config.get('max_block_size', 8192)
+        self.window_size = self.config.get('window_size', 1)
+        self.auto_accept = self.config.get('auto_accept', True)
+        self.accept_stream = self.config.get('accept_stream', None)
+
+        register_stanza_plugin(Iq, Open)
+        register_stanza_plugin(Iq, Close)
+        register_stanza_plugin(Iq, Data)
+
+        self.xmpp.register_handler(Callback(
+            'IBB Open',
+            StanzaPath('iq@type=set/ibb_open'),
+            self._handle_open_request))
+
+        self.xmpp.register_handler(Callback(
+            'IBB Close',
+            StanzaPath('iq@type=set/ibb_close'),
+            self._handle_close))
+
+        self.xmpp.register_handler(Callback(
+            'IBB Data',
+            StanzaPath('iq@type=set/ibb_data'),
+            self._handle_data))
+
+        self.xmpp['xep_0030'].add_feature('http://jabber.org/protocol/ibb')
+
+    def _accept_stream(self, iq):
+        if self.accept_stream is not None:
+            return self.accept_stream(iq)
+        if self.auto_accept:
+            if iq['ibb_open']['block_size'] <= self.max_block_size:
+                return True
+        return False
+
+    def open_stream(self, jid, block_size=4096, sid=None, window=1,
+                    ifrom=None, block=True, timeout=None, callback=None):
+        if sid is None:
+            sid = str(uuid.uuid4())
+
+        iq = self.xmpp.Iq()
+        iq['type'] = 'set'
+        iq['to'] = jid
+        iq['from'] = ifrom
+        iq['ibb_open']['block_size'] = block_size
+        iq['ibb_open']['sid'] = sid
+        iq['ibb_open']['stanza'] = 'iq'
+
+        stream = IBBytestream(self.xmpp, sid, block_size,
+                              iq['to'], iq['from'], window)
+
+        with self._stream_lock:
+            self.pending_streams[iq['id']] = stream
+
+        self.pending_streams[iq['id']] = stream
+
+        if block:
+            resp = iq.send(timeout=timeout)
+            self._handle_opened_stream(resp)
+            return stream
+        else:
+            cb = None
+            if callback is not None:
+                def chained(resp):
+                    self._handle_opened_stream(resp)
+                    callback(resp)
+                cb = chained
+            else:
+                cb = self._handle_opened_stream
+            return iq.send(block=block, timeout=timeout, callback=cb)
+
+    def _handle_opened_stream(self, iq):
+        if iq['type'] == 'result':
+            with self._stream_lock:
+                stream = self.pending_streams.get(iq['id'], None)
+                if stream is not None:
+                    stream.sender = iq['to']
+                    stream.receiver = iq['from']
+                    stream.stream_started.set()
+                    self.streams[stream.sid] = stream
+                    self.xmpp.event('ibb_stream_start', stream)
+
+        with self._stream_lock:
+            if iq['id'] in self.pending_streams:
+                del self.pending_streams[iq['id']]
+
+    def _handle_open_request(self, iq):
+        sid = iq['ibb_open']['sid']
+        size = iq['ibb_open']['block_size']
+        if not self._accept_stream(iq):
+            raise XMPPError('not-acceptable')
+
+        if size > self.max_block_size:
+            raise XMPPError('resource-constraint')
+
+        stream = IBBytestream(self.xmpp, sid, size,
+                              iq['from'], iq['to'],
+                              self.window_size)
+        stream.stream_started.set()
+        self.streams[sid] = stream
+        iq.reply()
+        iq.send()
+
+        self.xmpp.event('ibb_stream_start', stream)
+
+    def _handle_data(self, iq):
+        sid = iq['ibb_data']['sid']
+        stream = self.streams.get(sid, None)
+        if stream is not None and iq['from'] != stream.sender:
+            stream._recv_data(iq)
+        else:
+            raise XMPPError('item-not-found')
+
+    def _handle_close(self, iq):
+        sid = iq['ibb_close']['sid']
+        stream = self.streams.get(sid, None)
+        if stream is not None and iq['from'] != stream.sender:
+            stream._closed(iq)
+        else:
+            raise XMPPError('item-not-found')

sleekxmpp/plugins/xep_0047/stanza.py

@@ -0,0 +1,67 @@
+import re
+import base64
+
+from sleekxmpp.exceptions import XMPPError
+from sleekxmpp.xmlstream import ElementBase
+from sleekxmpp.thirdparty.suelta.util import bytes
+
+
+VALID_B64 = re.compile(r'[A-Za-z0-9\+\/]*=*')
+
+
+def to_b64(data):
+    return bytes(base64.b64encode(bytes(data))).decode('utf-8')
+
+
+def from_b64(data):
+    return bytes(base64.b64decode(bytes(data))).decode('utf-8')
+
+
+class Open(ElementBase):
+    name = 'open'
+    namespace = 'http://jabber.org/protocol/ibb'
+    plugin_attrib = 'ibb_open'
+    interfaces = set(('block_size', 'sid', 'stanza'))
+
+    def get_block_size(self):
+        return int(self._get_attr('block-size'))
+
+    def set_block_size(self, value):
+        self._set_attr('block-size', str(value))
+
+    def del_block_size(self):
+        self._del_attr('block-size')
+
+
+class Data(ElementBase):
+    name = 'data'
+    namespace = 'http://jabber.org/protocol/ibb'
+    plugin_attrib = 'ibb_data'
+    interfaces = set(('seq', 'sid', 'data'))
+    sub_interfaces = set(['data'])
+
+    def get_seq(self):
+        return int(self._get_attr('seq', '0'))
+
+    def set_seq(self, value):
+        self._set_attr('seq', str(value))
+
+    def get_data(self):
+        b64_data = self.xml.text.strip()
+        if VALID_B64.match(b64_data).group() == b64_data:
+            return from_b64(b64_data)
+        else:
+            raise XMPPError('not-acceptable')
+
+    def set_data(self, value):
+        self.xml.text = to_b64(value)
+
+    def del_data(self):
+        self.xml.text = ''
+
+
+class Close(ElementBase):
+    name = 'close'
+    namespace = 'http://jabber.org/protocol/ibb'
+    plugin_attrib = 'ibb_close'
+    interfaces = set(['sid'])

sleekxmpp/plugins/xep_0047/stream.py

@@ -0,0 +1,137 @@
+import socket
+import threading
+import logging
+try:
+    import queue
+except ImportError:
+    import Queue as queue
+
+from sleekxmpp.exceptions import XMPPError
+
+
+log = logging.getLogger(__name__)
+
+
+class IBBytestream(object):
+
+    def __init__(self, xmpp, sid, block_size, to, ifrom, window_size=1):
+        self.xmpp = xmpp
+        self.sid = sid
+        self.block_size = block_size
+        self.window_size = window_size
+
+        self.receiver = to
+        self.sender = ifrom
+
+        self.send_seq = -1
+        self.recv_seq = -1
+
+        self._send_seq_lock = threading.Lock()
+        self._recv_seq_lock = threading.Lock()
+
+        self.stream_started = threading.Event()
+        self.stream_in_closed = threading.Event()
+        self.stream_out_closed = threading.Event()
+
+        self.recv_queue = queue.Queue()
+
+        self.send_window = threading.BoundedSemaphore(value=self.window_size)
+        self.window_ids = set()
+        self.window_empty = threading.Event()
+        self.window_empty.set()
+
+    def send(self, data):
+        if not self.stream_started.is_set() or \
+               self.stream_out_closed.is_set():
+            raise socket.error
+        data = data[0:self.block_size]
+        self.send_window.acquire()
+        with self._send_seq_lock:
+            self.send_seq = (self.send_seq + 1) % 65535
+            seq = self.send_seq
+        iq = self.xmpp.Iq()
+        iq['type'] = 'set'
+        iq['to'] = self.receiver
+        iq['from'] = self.sender
+        iq['ibb_data']['sid'] = self.sid
+        iq['ibb_data']['seq'] = seq
+        iq['ibb_data']['data'] = data
+        self.window_empty.clear()
+        self.window_ids.add(iq['id'])
+        iq.send(block=False, callback=self._recv_ack)
+        return len(data)
+
+    def sendall(self, data):
+        sent_len = 0
+        while sent_len < len(data):
+            sent_len += self.send(data[sent_len:])
+
+    def _recv_ack(self, iq):
+        self.window_ids.remove(iq['id'])
+        if not self.window_ids:
+            self.window_empty.set()
+        self.send_window.release()
+        if iq['type'] == 'error':
+            self.close()
+
+    def _recv_data(self, iq):
+        with self._recv_seq_lock:
+            new_seq = iq['ibb_data']['seq']
+            if new_seq != (self.recv_seq + 1) % 65535:
+                self.close()
+                raise XMPPError('unexpected-request')
+            self.recv_seq = new_seq
+
+        data = iq['ibb_data']['data']
+        if len(data) > self.block_size:
+            self.close()
+            raise XMPPError('not-acceptable')
+
+        self.recv_queue.put(data)
+        self.xmpp.event('ibb_stream_data', {'stream': self, 'data': data})
+        iq.reply()
+        iq.send()
+
+    def recv(self, *args, **kwargs):
+        return self.read(block=True)
+
+    def read(self, block=True, timeout=None, **kwargs):
+        if not self.stream_started.is_set() or \
+               self.stream_in_closed.is_set():
+            raise socket.error
+        if timeout is not None:
+            block = True
+        try:
+            return self.recv_queue.get(block, timeout)
+        except:
+            return None
+
+    def close(self):
+        iq = self.xmpp.Iq()
+        iq['type'] = 'set'
+        iq['to'] = self.receiver
+        iq['from'] = self.sender
+        iq['ibb_close']['sid'] = self.sid
+        self.stream_out_closed.set()
+        iq.send(block=False,
+                callback=lambda x: self.stream_in_closed.set())
+        self.xmpp.event('ibb_stream_end', self)
+
+    def _closed(self, iq):
+        self.stream_in_closed.set()
+        self.stream_out_closed.set()
+        while not self.window_empty.is_set():
+            log.info('waiting for send window to empty')
+            self.window_empty.wait(timeout=1)
+        iq.reply()
+        iq.send()
+        self.xmpp.event('ibb_stream_end', self)
+
+    def makefile(self, *args, **kwargs):
+        return self
+
+    def connect(*args, **kwargs):
+        return None
+
+    def shutdown(self, *args, **kwargs):
+        return None

sleekxmpp/plugins/xep_0050/__init__.py

@@ -6,5 +6,14 @@
     See the file LICENSE for copying permission.
 """
 
+from sleekxmpp.plugins.base import register_plugin
+
 from sleekxmpp.plugins.xep_0050.stanza import Command
-from sleekxmpp.plugins.xep_0050.adhoc import xep_0050
+from sleekxmpp.plugins.xep_0050.adhoc import XEP_0050
+
+
+register_plugin(XEP_0050)
+
+
+# Retain some backwards compatibility
+xep_0050 = XEP_0050

sleekxmpp/plugins/xep_0050/adhoc.py

@@ -14,7 +14,7 @@ from sleekxmpp.exceptions import IqError
 from sleekxmpp.xmlstream.handler import Callback
 from sleekxmpp.xmlstream.matcher import StanzaPath
 from sleekxmpp.xmlstream import register_stanza_plugin, JID
-from sleekxmpp.plugins.base import base_plugin
+from sleekxmpp.plugins import BasePlugin
 from sleekxmpp.plugins.xep_0050 import stanza
 from sleekxmpp.plugins.xep_0050 import Command
 from sleekxmpp.plugins.xep_0004 import Form
@@ -23,7 +23,7 @@ from sleekxmpp.plugins.xep_0004 import Form
 log = logging.getLogger(__name__)
 
 
-class xep_0050(base_plugin):
+class XEP_0050(BasePlugin):
 
     """
     XEP-0050: Ad-Hoc Commands
@@ -78,12 +78,13 @@ class xep_0050(base_plugin):
         terminate_command -- Command user API: delete a command's session
     """
 
+    name = 'xep_0050'
+    description = 'XEP-0050: Ad-Hoc Commands'
+    dependencies = set(['xep_0030', 'xep_0004'])
+    stanza = stanza
+
     def plugin_init(self):
         """Start the XEP-0050 plugin."""
-        self.xep = '0050'
-        self.description = 'Ad-Hoc Commands'
-        self.stanza = stanza
-
         self.threaded = self.config.get('threaded', True)
         self.commands = {}
         self.sessions = self.config.get('session_db', {})
@@ -109,10 +110,8 @@ class xep_0050(base_plugin):
                                     self._handle_command_complete,
                                     threaded=self.threaded)
 
-    def post_init(self):
-        """Handle cross-plugin interactions."""
-        base_plugin.post_init(self)
         self.xmpp['xep_0030'].add_feature(Command.namespace)
+        self.xmpp['xep_0030'].set_items(node=Command.namespace, items=tuple())
 
     def set_backend(self, db):
         """
@@ -214,13 +213,24 @@ class xep_0050(base_plugin):
         name, handler = self.commands.get(key, ('Not found', None))
         if not handler:
             log.debug('Command not found: %s, %s', key, self.commands)
+
+        payload = []
+        for stanza in iq['command']['substanzas']:
+            payload.append(stanza)
+
+        if len(payload) == 1:
+            payload = payload[0]
+
+        interfaces = set([item.plugin_attrib for item in payload])
+        payload_classes = set([item.__class__ for item in payload])
+
         initial_session = {'id': sessionid,
                            'from': iq['from'],
                            'to': iq['to'],
                            'node': node,
-                           'payload': None,
-                           'interfaces': '',
-                           'payload_classes': None,
+                           'payload': payload,
+                           'interfaces': interfaces,
+                           'payload_classes': payload_classes,
                            'notes': None,
                            'has_next': False,
                            'allow_complete': False,
@@ -270,11 +280,19 @@ class xep_0050(base_plugin):
         sessionid = session['id']
 
         payload = session['payload']
+        if payload is None:
+            payload = []
         if not isinstance(payload, list):
             payload = [payload]
 
-        session['interfaces'] = [item.plugin_attrib for item in payload]
-        session['payload_classes'] = [item.__class__ for item in payload]
+        interfaces = session.get('interfaces', set())
+        payload_classes = session.get('payload_classes', set())
+
+        interfaces.update(set([item.plugin_attrib for item in payload]))
+        payload_classes.update(set([item.__class__ for item in payload]))
+
+        session['interfaces'] = interfaces
+        session['payload_classes'] = payload_classes
 
         self.sessions[sessionid] = session
 
@@ -369,7 +387,6 @@ class xep_0050(base_plugin):
 
         del self.sessions[sessionid]
 
-
     # =================================================================
     # Client side (command user) API
 
@@ -477,8 +494,10 @@ class xep_0050(base_plugin):
         session['jid'] = jid
         session['node'] = node
         session['timestamp'] = time.time()
-        session['payload'] = None
         session['block'] = block
+        if 'payload' not in session:
+            session['payload'] = None
+
         iq = self.xmpp.Iq()
         iq['type'] = 'set'
         iq['to'] = jid
@@ -486,6 +505,12 @@ class xep_0050(base_plugin):
         session['from'] = ifrom
         iq['command']['node'] = node
         iq['command']['action'] = 'execute'
+        if session['payload'] is not None:
+            payload = session['payload']
+            if not isinstance(payload, list):
+                payload = list(payload)
+            for stanza in payload:
+                iq['command'].append(stanza)
         sessionid = 'client:pending_' + iq['id']
         session['id'] = sessionid
         self.sessions[sessionid] = session
@@ -567,10 +592,11 @@ class xep_0050(base_plugin):
             session -- All stored data relevant to the current
                        command session.
         """
+        sessionid = 'client:' + session['id']
         try:
-            del self.sessions[session['id']]
-        except:
-            pass
+            del self.sessions[sessionid]
+        except Exception as e:
+            log.error("Error deleting adhoc command session: %s" % e.message)
 
     def _handle_command_result(self, iq):
         """

sleekxmpp/plugins/xep_0054/__init__.py

@@ -0,0 +1,15 @@
+"""
+    SleekXMPP: The Sleek XMPP Library
+    Copyright (C) 2012 Nathanael C. Fritz, Lance J.T. Stout
+    This file is part of SleekXMPP.
+
+    See the file LICENSE for copying permission.
+"""
+
+from sleekxmpp.plugins.base import register_plugin
+
+from sleekxmpp.plugins.xep_0054.stanza import VCardTemp
+from sleekxmpp.plugins.xep_0054.vcard_temp import XEP_0054
+
+
+register_plugin(XEP_0054)

sleekxmpp/plugins/xep_0054/stanza.py

@@ -0,0 +1,535 @@
+import base64
+import datetime as dt
+
+from sleekxmpp.thirdparty.suelta.util import bytes
+
+from sleekxmpp.xmlstream import ElementBase, ET, register_stanza_plugin, JID
+from sleekxmpp.plugins import xep_0082
+
+
+class VCardTemp(ElementBase):
+    name = 'vCard'
+    namespace = 'vcard-temp'
+    plugin_attrib = 'vcard_temp'
+    interfaces = set(['FN', 'VERSION'])
+    sub_interfaces = set(['FN', 'VERSION'])
+
+
+class Name(ElementBase):
+    name = 'N'
+    namespace = 'vcard-temp'
+    plugin_attrib = name
+    interfaces = set(['FAMILY', 'GIVEN', 'MIDDLE', 'PREFIX', 'SUFFIX'])
+    sub_interfaces = interfaces
+
+    def _set_component(self, name, value):
+        if isinstance(value, list):
+            value = ','.join(value)
+        if value is not None:
+            self._set_sub_text(name, value, keep=True)
+        else:
+            self._del_sub(name)
+
+    def _get_component(self, name):
+        value = self._get_sub_text(name, '')
+        if ',' in value:
+            value = [v.strip() for v in value.split(',')]
+        return value
+
+    def set_family(self, value):
+        self._set_component('FAMILY', value)
+
+    def get_family(self):
+        return self._get_component('FAMILY')
+
+    def set_given(self, value):
+        self._set_component('GIVEN', value)
+
+    def get_given(self):
+        return self._get_component('GIVEN')
+
+    def set_middle(self, value):
+        print(value)
+        self._set_component('MIDDLE', value)
+
+    def get_middle(self):
+        return self._get_component('MIDDLE')
+
+    def set_prefix(self, value):
+        self._set_component('PREFIX', value)
+
+    def get_prefix(self):
+        return self._get_component('PREFIX')
+
+    def set_suffix(self, value):
+        self._set_component('SUFFIX', value)
+
+    def get_suffix(self):
+        return self._get_component('SUFFIX')
+
+
+class Nickname(ElementBase):
+    name = 'NICKNAME'
+    namespace = 'vcard-temp'
+    plugin_attrib = name
+    interfaces = set([name])
+    is_extension = True
+
+    def set_nickname(self, value):
+        if not value:
+            self.xml.text = ''
+            return
+
+        if not isinstance(value, list):
+            value = [value]
+
+        self.xml.text = ','.join(value)
+
+    def get_nickname(self):
+        if self.xml.text:
+            return self.xml.text.split(',')
+
+
+class Email(ElementBase):
+    name = 'EMAIL'
+    namespace = 'vcard-temp'
+    plugin_attrib = name
+    interfaces = set(['HOME', 'WORK', 'INTERNET', 'PREF', 'X400', 'USERID'])
+    sub_interfaces = set(['USERID'])
+    bool_interfaces = set(['HOME', 'WORK', 'INTERNET', 'PREF', 'X400'])
+
+
+class Address(ElementBase):
+    name = 'ADR'
+    namespace = 'vcard-temp'
+    plugin_attrib = name
+    interfaces = set(['HOME', 'WORK', 'POSTAL', 'PARCEL', 'DOM', 'INTL', 
+                      'PREF', 'POBOX', 'EXTADD', 'STREET', 'LOCALITY', 
+                      'REGION', 'PCODE', 'CTRY'])
+    sub_interfaces = set(['POBOX', 'EXTADD', 'STREET', 'LOCALITY',
+                          'REGION', 'PCODE', 'CTRY'])
+    bool_interfaces = set(['HOME', 'WORK', 'DOM', 'INTL', 'PREF'])
+
+
+class Telephone(ElementBase):
+    name = 'TEL'
+    namespace = 'vcard-temp'
+    plugin_attrib = name
+    interfaces = set(['HOME', 'WORK', 'VOICE', 'FAX', 'PAGER', 'MSG',
+                      'CELL', 'VIDEO', 'BBS', 'MODEM', 'ISDN', 'PCS',
+                      'PREF', 'NUMBER'])
+    sub_interfaces = set(['NUMBER'])
+    bool_interfaces = set(['HOME', 'WORK', 'VOICE', 'FAX', 'PAGER', 
+                           'MSG', 'CELL', 'VIDEO', 'BBS', 'MODEM', 
+                           'ISDN', 'PCS', 'PREF'])
+
+    def setup(self, xml=None):
+        super(Telephone, self).setup(xml=xml)
+        self._set_sub_text('NUMBER', '', keep=True)
+
+    def set_number(self, value):
+        self._set_sub_text('NUMBER', value, keep=True)
+
+    def del_number(self):
+        self._set_sub_text('NUMBER', '', keep=True)
+
+
+class Label(ElementBase):
+    name = 'LABEL'
+    namespace = 'vcard-temp'
+    plugin_attrib = name
+    interfaces = set(['HOME', 'WORK', 'POSTAL', 'PARCEL', 'DOM', 'INT',
+                      'PREF', 'lines'])
+    bool_interfaces = set(['HOME', 'WORK', 'POSTAL', 'PARCEL', 'DOM', 
+                           'INT', 'PREF'])
+
+    def add_line(self, value):
+        line = ET.Element('{%s}LINE' % self.namespace)
+        line.text = value
+        self.xml.append(line)
+
+    def get_lines(self):
+        lines = self.xml.find('{%s}LINE' % self.namespace)
+        if lines is None:
+            return []
+        return [line.text for line in lines]
+
+    def set_lines(self, values):
+        self.del_lines()
+        for line in values:
+            self.add_line(line)
+
+    def del_lines(self):
+        lines = self.xml.find('{%s}LINE' % self.namespace)
+        if lines is None:
+            return
+        for line in lines:
+            self.xml.remove(line)
+
+
+class Geo(ElementBase):
+    name = 'GEO'
+    namespace = 'vcard-temp'
+    plugin_attrib = name
+    interfaces = set(['LAT', 'LON'])
+    sub_interfaces = interfaces
+
+
+class Org(ElementBase):
+    name = 'ORG'
+    namespace = 'vcard-temp'
+    plugin_attrib = name
+    interfaces = set(['ORGNAME', 'ORGUNIT', 'orgunits'])
+    sub_interfaces = set(['ORGNAME', 'ORGUNIT'])
+
+    def add_orgunit(self, value):
+        orgunit = ET.Element('{%s}ORGUNIT' % self.namespace)
+        orgunit.text = value
+        self.xml.append(orgunit)
+
+    def get_orgunits(self):
+        orgunits = self.xml.find('{%s}ORGUNIT' % self.namespace)
+        if orgunits is None:
+            return []
+        return [orgunit.text for orgunit in orgunits]
+
+    def set_orgunits(self, values):
+        self.del_orgunits()
+        for orgunit in values:
+            self.add_orgunit(orgunit)
+
+    def del_orgunits(self):
+        orgunits = self.xml.find('{%s}ORGUNIT' % self.namespace)
+        if orgunits is None:
+            return
+        for orgunit in orgunits:
+            self.xml.remove(orgunit)
+
+
+class Photo(ElementBase):
+    name = 'PHOTO'
+    namespace = 'vcard-temp'
+    plugin_attrib = name
+    interfaces = set(['TYPE', 'EXTVAL'])
+    sub_interfaces = interfaces
+
+
+class Logo(ElementBase):
+    name = 'LOGO'
+    namespace = 'vcard-temp'
+    plugin_attrib = name
+    interfaces = set(['TYPE', 'EXTVAL'])
+    sub_interfaces = interfaces
+
+
+class Sound(ElementBase):
+    name = 'LOGO'
+    namespace = 'vcard-temp'
+    plugin_attrib = name
+    interfaces = set(['PHONETC', 'EXTVAL'])
+    sub_interfaces = interfaces
+
+
+class BinVal(ElementBase):
+    name = 'BINVAL'
+    namespace = 'vcard-temp'
+    plugin_attrib = name
+    interfaces = set(['BINVAL'])
+    is_extension = True
+
+    def setup(self, xml=None):
+        self.xml = ET.Element('')
+        return True
+
+    def set_binval(self, value):
+        self.del_binval()
+        parent = self.parent()
+        if value:
+            xml = ET.Element('{%s}BINVAL' % self.namespace)
+            xml.text = bytes(base64.b64encode(value)).decode('utf-8')
+            parent.append(xml)
+
+    def get_binval(self):
+        parent = self.parent()
+        xml = parent.find('{%s}BINVAL' % self.namespace)
+        if xml is not None:
+            return base64.b64decode(bytes(xml.text))
+        return b''
+
+    def del_binval(self):
+        self.parent()._del_sub('{%s}BINVAL' % self.namespace)
+
+
+class Classification(ElementBase):
+    name = 'CLASS'
+    namespace = 'vcard-temp'
+    plugin_attrib = name
+    interfaces = set(['PUBLIC', 'PRIVATE', 'CONFIDENTIAL'])
+    bool_interfaces = interfaces
+
+
+class Categories(ElementBase):
+    name = 'CATEGORIES'
+    namespace = 'vcard-temp'
+    plugin_attrib = name
+    interfaces = set([name])
+    is_extension = True
+
+    def set_categories(self, values):
+        self.del_categories()
+        for keyword in values:
+            item = ET.Element('{%s}KEYWORD' % self.namespace)
+            item.text = keyword
+            self.xml.append(item)
+
+    def get_categories(self):
+        items = self.xml.findall('{%s}KEYWORD' % self.namespace)
+        if items is None:
+            return []
+        keywords = []
+        for item in items:
+            keywords.append(item.text)
+        return keywords
+
+    def del_categories(self):
+        items = self.xml.findall('{%s}KEYWORD' % self.namespace)
+        for item in items:
+            self.xml.remove(item)
+
+
+class Birthday(ElementBase):
+    name = 'BDAY'
+    namespace = 'vcard-temp'
+    plugin_attrib = name
+    interfaces = set([name])
+    is_extension = True
+
+    def set_bday(self, value):
+        if isinstance(value, dt.datetime):
+            value = xep_0082.format_datetime(value)
+        self.xml.text = value
+
+    def get_bday(self):
+        if not self.xml.text:
+            return None
+        return xep_0082.parse(self.xml.text)
+
+
+class Rev(ElementBase):
+    name = 'REV'
+    namespace = 'vcard-temp'
+    plugin_attrib = name
+    interfaces = set([name])
+    is_extension = True
+
+    def set_rev(self, value):
+        if isinstance(value, dt.datetime):
+            value = xep_0082.format_datetime(value)
+        self.xml.text = value
+
+    def get_rev(self):
+        if not self.xml.text:
+            return None
+        return xep_0082.parse(self.xml.text)
+
+
+class Title(ElementBase):
+    name = 'TITLE'
+    namespace = 'vcard-temp'
+    plugin_attrib = name
+    interfaces = set([name])
+    is_extension = True
+
+    def set_title(self, value):
+        self.xml.text = value
+
+    def get_title(self):
+        return self.xml.text
+
+
+class Role(ElementBase):
+    name = 'ROLE'
+    namespace = 'vcard-temp'
+    plugin_attrib = name
+    interfaces = set([name])
+    is_extension = True
+
+    def set_role(self, value):
+        self.xml.text = value
+
+    def get_role(self):
+        return self.xml.text
+
+
+class Note(ElementBase):
+    name = 'NOTE'
+    namespace = 'vcard-temp'
+    plugin_attrib = name
+    interfaces = set([name])
+    is_extension = True
+
+    def set_note(self, value):
+        self.xml.text = value
+
+    def get_note(self):
+        return self.xml.text
+
+
+class Desc(ElementBase):
+    name = 'DESC'
+    namespace = 'vcard-temp'
+    plugin_attrib = name
+    interfaces = set([name])
+    is_extension = True
+
+    def set_desc(self, value):
+        self.xml.text = value
+
+    def get_desc(self):
+        return self.xml.text
+
+
+class URL(ElementBase):
+    name = 'URL'
+    namespace = 'vcard-temp'
+    plugin_attrib = name
+    interfaces = set([name])
+    is_extension = True
+
+    def set_url(self, value):
+        self.xml.text = value
+
+    def get_url(self):
+        return self.xml.text
+
+
+class UID(ElementBase):
+    name = 'UID'
+    namespace = 'vcard-temp'
+    plugin_attrib = name
+    interfaces = set([name])
+    is_extension = True
+
+    def set_uid(self, value):
+        self.xml.text = value
+
+    def get_uid(self):
+        return self.xml.text
+
+
+class ProdID(ElementBase):
+    name = 'PRODID'
+    namespace = 'vcard-temp'
+    plugin_attrib = name
+    interfaces = set([name])
+    is_extension = True
+
+    def set_prodid(self, value):
+        self.xml.text = value
+
+    def get_prodid(self):
+        return self.xml.text
+
+
+class Mailer(ElementBase):
+    name = 'MAILER'
+    namespace = 'vcard-temp'
+    plugin_attrib = name
+    interfaces = set([name])
+    is_extension = True
+
+    def set_mailer(self, value):
+        self.xml.text = value
+
+    def get_mailer(self):
+        return self.xml.text
+
+
+class SortString(ElementBase):
+    name = 'SORT-STRING'
+    namespace = 'vcard-temp'
+    plugin_attrib = 'SORT_STRING'
+    interfaces = set([name])
+    is_extension = True
+
+    def set_sort_string(self, value):
+        self.xml.text = value
+
+    def get_sort_string(self):
+        return self.xml.text
+
+
+class Agent(ElementBase):
+    name = 'AGENT'
+    namespace = 'vcard-temp'
+    plugin_attrib = name
+    interfaces = set(['EXTVAL'])
+    sub_interfaces = interfaces
+
+
+class JabberID(ElementBase):
+    name = 'JABBERID'
+    namespace = 'vcard-temp'
+    plugin_attrib = name
+    interfaces = set([name])
+    is_extension = True
+
+    def set_jabberid(self, value):
+        self.xml.text = JID(value).bare
+
+    def get_jabberid(self):
+        return JID(self.xml.text)
+
+
+class TimeZone(ElementBase):
+    name = 'TZ'
+    namespace = 'vcard-temp'
+    plugin_attrib = name
+    interfaces = set([name])
+    is_extension = True
+
+    def set_tz(self, value):
+        time = xep_0082.time(offset=value) 
+        if time[-1] == 'Z':
+            self.xml.text = 'Z'
+        else:
+            self.xml.text = time[-6:]
+
+    def get_tz(self):
+        if not self.xml.text:
+            return xep_0082.tzutc()
+        time = xep_0082.parse('00:00:00%s' % self.xml.text)
+        return time.tzinfo
+
+
+register_stanza_plugin(VCardTemp, Name)
+register_stanza_plugin(VCardTemp, Address, iterable=True)
+register_stanza_plugin(VCardTemp, Agent, iterable=True)
+register_stanza_plugin(VCardTemp, Birthday, iterable=True)
+register_stanza_plugin(VCardTemp, Categories, iterable=True)
+register_stanza_plugin(VCardTemp, Desc, iterable=True)
+register_stanza_plugin(VCardTemp, Email, iterable=True)
+register_stanza_plugin(VCardTemp, Geo, iterable=True)
+register_stanza_plugin(VCardTemp, JabberID, iterable=True)
+register_stanza_plugin(VCardTemp, Label, iterable=True)
+register_stanza_plugin(VCardTemp, Logo, iterable=True)
+register_stanza_plugin(VCardTemp, Mailer, iterable=True)
+register_stanza_plugin(VCardTemp, Note, iterable=True)
+register_stanza_plugin(VCardTemp, Nickname, iterable=True)
+register_stanza_plugin(VCardTemp, Photo, iterable=True)
+register_stanza_plugin(VCardTemp, ProdID, iterable=True)
+register_stanza_plugin(VCardTemp, Rev, iterable=True)
+register_stanza_plugin(VCardTemp, Role, iterable=True)
+register_stanza_plugin(VCardTemp, SortString, iterable=True)
+register_stanza_plugin(VCardTemp, Sound, iterable=True)
+register_stanza_plugin(VCardTemp, Telephone, iterable=True)
+register_stanza_plugin(VCardTemp, Title, iterable=True)
+register_stanza_plugin(VCardTemp, TimeZone, iterable=True)
+register_stanza_plugin(VCardTemp, UID, iterable=True)
+register_stanza_plugin(VCardTemp, URL, iterable=True)
+
+register_stanza_plugin(Photo, BinVal)
+register_stanza_plugin(Logo, BinVal)
+register_stanza_plugin(Sound, BinVal)
+
+register_stanza_plugin(Agent, VCardTemp)

sleekxmpp/plugins/xep_0054/vcard_temp.py

@@ -0,0 +1,130 @@
+"""
+    SleekXMPP: The Sleek XMPP Library
+    Copyright (C) 2012 Nathanael C. Fritz, Lance J.T. Stout
+    This file is part of SleekXMPP.
+
+    See the file LICENSE for copying permission.
+"""
+
+import logging
+
+from sleekxmpp import Iq
+from sleekxmpp.exceptions import XMPPError
+from sleekxmpp.xmlstream import register_stanza_plugin
+from sleekxmpp.xmlstream.handler import Callback
+from sleekxmpp.xmlstream.matcher import StanzaPath
+from sleekxmpp.plugins import BasePlugin
+from sleekxmpp.plugins.xep_0054 import VCardTemp, stanza
+
+
+log = logging.getLogger(__name__)
+
+
+class XEP_0054(BasePlugin):
+
+    """
+    XEP-0054: vcard-temp
+    """
+
+    name = 'xep_0054'
+    description = 'XEP-0054: vcard-temp'
+    dependencies = set(['xep_0030', 'xep_0082'])
+    stanza = stanza
+
+    def plugin_init(self):
+        """
+        Start the XEP-0054 plugin.
+        """
+        register_stanza_plugin(Iq, VCardTemp)
+
+        self.xmpp['xep_0030'].add_feature('vcard-temp')
+
+        self.api.register(self._set_vcard, 'set_vcard', default=True)
+        self.api.register(self._get_vcard, 'get_vcard', default=True)
+        self.api.register(self._del_vcard, 'del_vcard', default=True)
+
+        self._vcard_cache = {}
+
+        self.xmpp.register_handler(
+                Callback('VCardTemp',
+                    StanzaPath('iq/vcard_temp'),
+                    self._handle_get_vcard))
+
+    def make_vcard(self):
+        return VCardTemp()
+
+    def get_vcard(self, jid=None, ifrom=None, local=False, cached=False, 
+                  block=True, callback=None, timeout=None):
+        if self.xmpp.is_component and jid.domain == self.xmpp.boundjid.domain:
+            local = True
+
+        if local:
+            vcard = self.api['get_vcard'](jid, None, ifrom)
+            if not isinstance(vcard, Iq):
+                iq = self.xmpp.Iq()
+                if vcard is None:
+                    vcard = VCardTemp()
+                iq.append(vcard)
+                return iq
+            return vcard
+
+        if cached:
+            vcard = self.api['get_vcard'](jid, None, ifrom)
+            if vcard is not None:
+                if not isinstance(vcard, Iq):
+                    iq = self.xmpp.Iq()
+                    iq.append(vcard)
+                    return iq
+                return vcard
+
+        iq = self.xmpp.Iq()
+        iq['to'] = jid
+        iq['from'] = ifrom
+        iq['type'] = 'get'
+        iq.enable('vcard_temp')
+
+        vcard = iq.send(block=block, callback=callback, timeout=timeout)
+        
+        if block:
+            self.api['set_vcard'](vcard['from'], args=vcard['vcard_temp'])
+            return vcard
+
+    def publish_vcard(self, vcard=None, jid=None, block=True, ifrom=None, 
+                      callback=None, timeout=None):
+        if self.xmpp.is_component:
+            self.api['set_vcard'](jid, None, ifrom, vcard)
+            return
+
+        iq = self.xmpp.Iq()
+        iq['to'] = jid
+        iq['from'] = ifrom
+        iq['type'] = 'set'
+        iq.append(vcard)
+        return iq.send(block=block, callback=callback, timeout=timeout)
+
+    def _handle_get_vcard(self, iq):
+        if iq['type'] == 'result':
+            self.api['set_vcard'](jid=iq['from'], args=iq['vcard_temp'])
+            return
+        elif iq['type'] == 'get':
+            vcard = self.api['get_vard'](iq['from'].bare)
+            if isinstance(vcard, Iq):
+                vcard.send()
+            else:
+                iq.reply()
+                iq.append(vcard)
+                iq.send()
+        elif iq['type'] == 'set':
+            raise XMPPError('service-unavailable')
+
+    # =================================================================
+
+    def _set_vcard(self, jid, node, ifrom, vcard):
+        self._vcard_cache[jid.bare] = vcard
+
+    def _get_vcard(self, jid, node, ifrom, vcard):
+        return self._vcard_cache.get(jid.bare, None)
+
+    def _del_vcard(self, jid, node, ifrom, vcard):
+        if jid.bare in self._vcard_cache:
+            del self._vcard_cache[jid.bare]

sleekxmpp/plugins/xep_0059/__init__.py

@@ -6,5 +6,13 @@
     See the file LICENSE for copying permission.
 """
 
+from sleekxmpp.plugins.base import register_plugin
+
 from sleekxmpp.plugins.xep_0059.stanza import Set
-from sleekxmpp.plugins.xep_0059.rsm import ResultIterator, xep_0059
+from sleekxmpp.plugins.xep_0059.rsm import ResultIterator, XEP_0059
+
+
+register_plugin(XEP_0059)
+
+# Retain some backwards compatibility
+xep_0059 = XEP_0059

sleekxmpp/plugins/xep_0059/rsm.py

@@ -10,9 +10,10 @@ import logging
 
 import sleekxmpp
 from sleekxmpp import Iq
-from sleekxmpp.plugins.base import base_plugin
+from sleekxmpp.plugins import BasePlugin, register_plugin
 from sleekxmpp.xmlstream import register_stanza_plugin
-from sleekxmpp.plugins.xep_0059 import Set
+from sleekxmpp.plugins.xep_0059 import stanza, Set
+from sleekxmpp.exceptions import XMPPError
 
 
 log = logging.getLogger(__name__)
@@ -70,38 +71,49 @@ class ResultIterator():
         elif self.start:
             self.query[self.interface]['rsm']['after'] = self.start
 
-        r = self.query.send(block=True)
+        try:
+            r = self.query.send(block=True)
 
-        if not r or not r[self.interface]['rsm']['first'] and \
-           not r[self.interface]['rsm']['last']:
+            if not r[self.interface]['rsm']['first'] and \
+               not r[self.interface]['rsm']['last']:
+                raise StopIteration
+
+            if r[self.interface]['rsm']['count'] and \
+               r[self.interface]['rsm']['first_index']:
+                count = int(r[self.interface]['rsm']['count'])
+                first = int(r[self.interface]['rsm']['first_index'])
+                num_items = len(r[self.interface]['substanzas'])
+                if first + num_items == count:
+                    raise StopIteration
+
+            if self.reverse:
+                self.start = r[self.interface]['rsm']['first']
+            else:
+                self.start = r[self.interface]['rsm']['last']
+
+            return r
+        except XMPPError:
             raise StopIteration
 
-        if self.reverse:
-            self.start = r[self.interface]['rsm']['first']
-        else:
-            self.start = r[self.interface]['rsm']['last']
 
-        return r
-
-
-class xep_0059(base_plugin):
+class XEP_0059(BasePlugin):
 
     """
     XEP-0050: Result Set Management
     """
 
+    name = 'xep_0059'
+    description = 'XEP-0059: Result Set Management'
+    dependencies = set(['xep_0030'])
+    stanza = stanza
+
     def plugin_init(self):
         """
         Start the XEP-0059 plugin.
         """
-        self.xep = '0059'
-        self.description = 'Result Set Management'
-        self.stanza = sleekxmpp.plugins.xep_0059.stanza
-
-    def post_init(self):
-        """Handle inter-plugin dependencies."""
-        base_plugin.post_init(self)
         self.xmpp['xep_0030'].add_feature(Set.namespace)
+        register_stanza_plugin(self.xmpp['xep_0030'].stanza.DiscoItems,
+                               self.stanza.Set)
 
     def iterate(self, stanza, interface):
         """

sleekxmpp/plugins/xep_0060/__init__.py

@@ -1,2 +1,19 @@
-from sleekxmpp.plugins.xep_0060.pubsub import xep_0060
+"""
+    SleekXMPP: The Sleek XMPP Library
+    Copyright (C) 2011 Nathanael C. Fritz, Lance J.T. Stout
+    This file is part of SleekXMPP.
+
+    See the file LICENSE for copying permission.
+"""
+
+from sleekxmpp.plugins.base import register_plugin
+
+from sleekxmpp.plugins.xep_0060.pubsub import XEP_0060
 from sleekxmpp.plugins.xep_0060 import stanza
+
+
+register_plugin(XEP_0060)
+
+
+# Retain some backwards compatibility
+xep_0060 = XEP_0060

sleekxmpp/plugins/xep_0060/pubsub.py

@@ -9,23 +9,138 @@
 import logging
 
 from sleekxmpp.xmlstream import JID
-from sleekxmpp.plugins.base import base_plugin
+from sleekxmpp.xmlstream.handler import Callback
+from sleekxmpp.xmlstream.matcher import StanzaPath
+from sleekxmpp.plugins.base import BasePlugin
 from sleekxmpp.plugins.xep_0060 import stanza
 
 
 log = logging.getLogger(__name__)
 
 
-class xep_0060(base_plugin):
+class XEP_0060(BasePlugin):
 
     """
     XEP-0060 Publish Subscribe
     """
 
+    name = 'xep_0060'
+    description = 'XEP-0060: Publish-Subscribe'
+    dependencies = set(['xep_0030', 'xep_0004'])
+    stanza = stanza
+
     def plugin_init(self):
-        self.xep = '0060'
-        self.description = 'Publish-Subscribe'
-        self.stanza = stanza
+        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))
+
+    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):
@@ -98,8 +213,9 @@ class xep_0060(base_plugin):
             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.
+            timeout    -- The length of time (in seconds) to wait for a
+                          response before exiting the send call if blocking
+                          is used.
                           Defaults to sleekxmpp.xmlstream.RESPONSE_TIMEOUT
             callback   -- Optional reference to a stream handler function. Will
                           be executed when a reply stanza is received.
@@ -146,8 +262,9 @@ class xep_0060(base_plugin):
             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.
+            timeout    -- The length of time (in seconds) to wait for a
+                          response before exiting the send call if blocking
+                          is used.
                           Defaults to sleekxmpp.xmlstream.RESPONSE_TIMEOUT
             callback   -- Optional reference to a stream handler function. Will
                           be executed when a reply stanza is received.
@@ -183,8 +300,9 @@ class xep_0060(base_plugin):
         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):
+    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
@@ -364,7 +482,7 @@ class xep_0060(base_plugin):
         """
         Discover the nodes provided by a Pubsub service, using disco.
         """
-        return self.xmpp.plugin['xep_0030'].get_items(*args, **kwargs)
+        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):
@@ -372,7 +490,7 @@ class xep_0060(base_plugin):
         Retrieve the content of an individual item.
         """
         iq = self.xmpp.Iq(sto=jid, sfrom=ifrom, stype='get')
-        item = self.stanza.Item()
+        item = stanza.Item()
         item['id'] = item_id
         iq['pubsub']['items']['node'] = node
         iq['pubsub']['items'].append(item)
@@ -396,7 +514,7 @@ class xep_0060(base_plugin):
 
         if item_ids is not None:
             for item_id in item_ids:
-                item = self.stanza.Item()
+                item = stanza.Item()
                 item['id'] = item_id
                 iq['pubsub']['items'].append(item)
 
@@ -410,12 +528,12 @@ class xep_0060(base_plugin):
         """
         Retrieve the ItemIDs hosted by a given node, using disco.
         """
-        return self.xmpp.plugin['xep_0030'].get_items(jid, node,
-                                                      ifrom=ifrom,
-                                                      block=block,
-                                                      callback=callback,
-                                                      timeout=timeout,
-                                                      iterator=iterator)
+        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):
@@ -426,7 +544,7 @@ class xep_0060(base_plugin):
             affiliations = []
 
         for jid, affiliation in affiliations:
-            aff = self.stanza.OwnerAffiliation()
+            aff = stanza.OwnerAffiliation()
             aff['jid'] = jid
             aff['affiliation'] = affiliation
             iq['pubsub_owner']['affiliations'].append(aff)
@@ -442,7 +560,7 @@ class xep_0060(base_plugin):
             subscriptions = []
 
         for jid, subscription in subscriptions:
-            sub = self.stanza.OwnerSubscription()
+            sub = stanza.OwnerSubscription()
             sub['jid'] = jid
             sub['subscription'] = subscription
             iq['pubsub_owner']['subscriptions'].append(sub)

sleekxmpp/plugins/xep_0060/stanza/pubsub_event.py

@@ -6,23 +6,26 @@
     See the file LICENSE for copying permission.
 """
 
+import datetime as dt
+
 from sleekxmpp import Message
 from sleekxmpp.xmlstream import register_stanza_plugin, ElementBase, ET, JID
 from sleekxmpp.plugins.xep_0004 import Form
+from sleekxmpp.plugins import xep_0082
 
 
 class Event(ElementBase):
     namespace = 'http://jabber.org/protocol/pubsub#event'
     name = 'event'
     plugin_attrib = 'pubsub_event'
-    interfaces = set(('node',))
+    interfaces = set()
 
 
 class EventItem(ElementBase):
     namespace = 'http://jabber.org/protocol/pubsub#event'
     name = 'item'
     plugin_attrib = name
-    interfaces = set(('id', 'payload'))
+    interfaces = set(('id', 'payload', 'node', 'publisher'))
 
     def set_payload(self, value):
         self.xml.append(value)
@@ -76,7 +79,7 @@ class EventConfiguration(ElementBase):
     namespace = 'http://jabber.org/protocol/pubsub#event'
     name = 'configuration'
     plugin_attrib = name
-    interfaces = set(('node', 'config'))
+    interfaces = set(('node',))
 
 
 class EventPurge(ElementBase):
@@ -86,12 +89,47 @@ class EventPurge(ElementBase):
     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))
 
@@ -102,8 +140,9 @@ class EventSubscription(ElementBase):
 register_stanza_plugin(Message, Event)
 register_stanza_plugin(Event, EventCollection)
 register_stanza_plugin(Event, EventConfiguration)
-register_stanza_plugin(Event, EventItems)
 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)

sleekxmpp/plugins/xep_0066/__init__.py

@@ -6,6 +6,15 @@
     See the file LICENSE for copying permission.
 """
 
+from sleekxmpp.plugins.base import register_plugin
+
 from sleekxmpp.plugins.xep_0066 import stanza
 from sleekxmpp.plugins.xep_0066.stanza import OOB, OOBTransfer
-from sleekxmpp.plugins.xep_0066.oob import xep_0066
+from sleekxmpp.plugins.xep_0066.oob import XEP_0066
+
+
+register_plugin(XEP_0066)
+
+
+# Retain some backwards compatibility
+xep_0066 = XEP_0066

sleekxmpp/plugins/xep_0066/oob.py

@@ -13,19 +13,19 @@ from sleekxmpp.exceptions import XMPPError
 from sleekxmpp.xmlstream import register_stanza_plugin
 from sleekxmpp.xmlstream.handler import Callback
 from sleekxmpp.xmlstream.matcher import StanzaPath
-from sleekxmpp.plugins.base import base_plugin
+from sleekxmpp.plugins import BasePlugin
 from sleekxmpp.plugins.xep_0066 import stanza
 
 
 log = logging.getLogger(__name__)
 
 
-class xep_0066(base_plugin):
+class XEP_0066(BasePlugin):
 
     """
-    XEP-0066: Out-of-Band Data
+    XEP-0066: Out of Band Data
 
-    Out-of-Band Data is a basic method for transferring files between
+    Out of Band Data is a basic method for transferring files between
     XMPP agents. The URL of the resource in question is sent to the receiving
     entity, which then downloads the resource before responding to the OOB
     request. OOB is also used as a generic means to transmit URLs in other
@@ -42,11 +42,13 @@ class xep_0066(base_plugin):
                     or other addressable resource.
     """
 
+    name = 'xep_0066'
+    description = 'XEP-0066: Out of Band Data'
+    dependencies = set(['xep_0030'])
+    stanza = stanza
+
     def plugin_init(self):
         """Start the XEP-0066 plugin."""
-        self.xep = '0066'
-        self.description = 'Out-of-Band Transfer'
-        self.stanza = stanza
 
         self.url_handlers = {'global': self._default_handler,
                              'jid': {}}
@@ -60,9 +62,6 @@ class xep_0066(base_plugin):
                          StanzaPath('iq@type=set/oob_transfer'),
                          self._handle_transfer))
 
-    def post_init(self):
-        """Handle cross-plugin dependencies."""
-        base_plugin.post_init(self)
         self.xmpp['xep_0030'].add_feature(stanza.OOBTransfer.namespace)
         self.xmpp['xep_0030'].add_feature(stanza.OOB.namespace)
 
@@ -121,7 +120,7 @@ class xep_0066(base_plugin):
             iq -- The Iq stanza containing the OOB transfer request.
         """
         if iq['to'] in self.url_handlers['jid']:
-            return self.url_handlers['jid'][jid](iq)
+            return self.url_handlers['jid'][iq['to']](iq)
         else:
             if self.url_handlers['global']:
                 self.url_handlers['global'](iq)

sleekxmpp/plugins/xep_0077/__init__.py

@@ -0,0 +1,19 @@
+"""
+    SleekXMPP: The Sleek XMPP Library
+    Copyright (C) 2012 Nathanael C. Fritz, Lance J.T. Stout
+    This file is part of SleekXMPP.
+
+    See the file LICENSE for copying permission.
+"""
+
+from sleekxmpp.plugins.base import register_plugin
+
+from sleekxmpp.plugins.xep_0077.stanza import Register, RegisterFeature
+from sleekxmpp.plugins.xep_0077.register import XEP_0077
+
+
+register_plugin(XEP_0077)
+
+
+# Retain some backwards compatibility
+xep_0077 = XEP_0077

sleekxmpp/plugins/xep_0077/register.py

@@ -0,0 +1,90 @@
+"""
+    SleekXMPP: The Sleek XMPP Library
+    Copyright (C) 2012 Nathanael C. Fritz, Lance J.T. Stout
+    This file is part of SleekXMPP.
+
+    See the file LICENSE for copying permission.
+"""
+
+import logging
+
+from sleekxmpp.stanza import StreamFeatures, Iq
+from sleekxmpp.xmlstream import register_stanza_plugin, JID
+from sleekxmpp.plugins import BasePlugin
+from sleekxmpp.plugins.xep_0077 import stanza, Register, RegisterFeature
+
+
+log = logging.getLogger(__name__)
+
+
+class XEP_0077(BasePlugin):
+
+    """
+    XEP-0077: In-Band Registration
+    """
+
+    name = 'xep_0077'
+    description = 'XEP-0077: In-Band Registration'
+    dependencies = set(['xep_0004', 'xep_0066'])
+    stanza = stanza
+
+    def plugin_init(self):
+        self.create_account = self.config.get('create_account', True)
+
+        register_stanza_plugin(StreamFeatures, RegisterFeature)
+        register_stanza_plugin(Iq, Register)
+
+        if self.xmpp.is_component:
+            pass
+        else:
+            self.xmpp.register_feature('register',
+                self._handle_register_feature,
+                restart=False,
+                order=self.config.get('order', 50))
+
+        register_stanza_plugin(Register, self.xmpp['xep_0004'].stanza.Form)
+        register_stanza_plugin(Register, self.xmpp['xep_0066'].stanza.OOB)
+
+    def _handle_register_feature(self, features):
+        if 'mechanisms' in self.xmpp.features:
+            # We have already logged in with an account
+            return False
+
+        if self.create_account and self.xmpp.event_handled('register'):
+            form = self.get_registration()
+            self.xmpp.event('register', form, direct=True)
+            return True
+        return False
+
+    def get_registration(self, jid=None, ifrom=None, block=True,
+                         timeout=None, callback=None):
+        iq = self.xmpp.Iq()
+        iq['type'] = 'get'
+        iq['to'] = jid
+        iq['from'] = ifrom
+        iq.enable('register')
+        return iq.send(block=block, timeout=timeout,
+                       callback=callback, now=True)
+
+    def cancel_registration(self, jid=None, ifrom=None, block=True,
+                            timeout=None, callback=None):
+        iq = self.xmpp.Iq()
+        iq['type'] = 'set'
+        iq['to'] = jid
+        iq['from'] = ifrom
+        iq['register']['remove'] = True
+        return iq.send(block=block, timeout=timeout, callback=callback)
+
+    def change_password(self, password, jid=None, ifrom=None, block=True,
+                        timeout=None, callback=None):
+        iq = self.xmpp.Iq()
+        iq['type'] = 'set'
+        iq['to'] = jid
+        iq['from'] = ifrom
+        if self.xmpp.is_component:
+            ifrom = JID(ifrom)
+            iq['register']['username'] = ifrom.user
+        else:
+            iq['register']['username'] = self.xmpp.boundjid.user
+        iq['register']['password'] = password
+        return iq.send(block=block, timeout=timeout, callback=callback)

sleekxmpp/plugins/xep_0077/stanza.py

@@ -0,0 +1,73 @@
+"""
+    SleekXMPP: The Sleek XMPP Library
+    Copyright (C) 2012 Nathanael C. Fritz, Lance J.T. Stout
+    This file is part of SleekXMPP.
+
+    See the file LICENSE for copying permission.
+"""
+
+from __future__ import unicode_literals
+
+from sleekxmpp.xmlstream import ElementBase, ET
+
+
+class Register(ElementBase):
+
+    namespace = 'jabber:iq:register'
+    name = 'query'
+    plugin_attrib = 'register'
+    interfaces = set(('username', 'password', 'email', 'nick', 'name',
+                      'first', 'last', 'address', 'city', 'state', 'zip',
+                      'phone', 'url', 'date', 'misc', 'text', 'key',
+                      'registered', 'remove', 'instructions', 'fields'))
+    sub_interfaces = interfaces
+    form_fields = set(('username', 'password', 'email', 'nick', 'name',
+                       'first', 'last', 'address', 'city', 'state', 'zip',
+                       'phone', 'url', 'date', 'misc', 'text', 'key'))
+
+    def get_registered(self):
+        present = self.xml.find('{%s}registered' % self.namespace)
+        return present is not None
+
+    def get_remove(self):
+        present = self.xml.find('{%s}remove' % self.namespace)
+        return present is not None
+
+    def set_registered(self, value):
+        if value:
+            self.add_field('registered')
+        else:
+            del self['registered']
+
+    def set_remove(self, value):
+        if value:
+            self.add_field('remove')
+        else:
+            del self['remove']
+
+    def add_field(self, value):
+        self._set_sub_text(value, '', keep=True)
+
+    def get_fields(self):
+        fields = set()
+        for field in self.form_fields:
+            if self.xml.find('{%s}%s' % (self.namespace, field)) is not None:
+                fields.add(field)
+        return fields
+
+    def set_fields(self, fields):
+        del self['fields']
+        for field in fields:
+            self._set_sub_text(field, '', keep=True)
+
+    def del_fields(self):
+        for field in self.form_fields:
+            self._del_sub(field)
+
+
+class RegisterFeature(ElementBase):
+
+    name = 'register'
+    namespace = 'http://jabber.org/features/iq-register'
+    plugin_attrib = name
+    interfaces = set()

sleekxmpp/plugins/xep_0078/__init__.py

@@ -6,7 +6,15 @@
     See the file LICENSE for copying permission.
 """
 
+from sleekxmpp.plugins.base import register_plugin
+
 from sleekxmpp.plugins.xep_0078 import stanza
 from sleekxmpp.plugins.xep_0078.stanza import IqAuth, AuthFeature
-from sleekxmpp.plugins.xep_0078.legacyauth import xep_0078
+from sleekxmpp.plugins.xep_0078.legacyauth import XEP_0078
 
+
+register_plugin(XEP_0078)
+
+
+# Retain some backwards compatibility
+xep_0078 = XEP_0078