Rename to slixmpp

7 files changed, 0 insertions, 1877 deletions

diff --git a/sleekxmpp/plugins/xep_0323/__init__.py b/sleekxmpp/plugins/xep_0323/__init__.py
deleted file mode 100644
index 10779ada..00000000
--- a/sleekxmpp/plugins/xep_0323/__init__.py
+++ /dev/null
@@ -1,18 +0,0 @@
-"""
-    SleekXMPP: The Sleek XMPP Library
-    Implementation of xeps for Internet of Things
-    http://wiki.xmpp.org/web/Tech_pages/IoT_systems
-    Copyright (C) 2013 Sustainable Innovation, Joachim.lindborg@sust.se, bjorn.westrom@consoden.se
-    This file is part of SleekXMPP.
-
-    See the file LICENSE for copying permission.
-"""
-
-from sleekxmpp.plugins.base import register_plugin
-
-from sleekxmpp.plugins.xep_0323.sensordata import XEP_0323
-from sleekxmpp.plugins.xep_0323 import stanza
-
-register_plugin(XEP_0323)
-
-xep_0323=XEP_0323
diff --git a/sleekxmpp/plugins/xep_0323/device.py b/sleekxmpp/plugins/xep_0323/device.py
deleted file mode 100644
index 0bc20327..00000000
--- a/sleekxmpp/plugins/xep_0323/device.py
+++ /dev/null
@@ -1,255 +0,0 @@
-"""
-    SleekXMPP: The Sleek XMPP Library
-    Implementation of xeps for Internet of Things
-    http://wiki.xmpp.org/web/Tech_pages/IoT_systems
-    Copyright (C) 2013 Sustainable Innovation, Joachim.lindborg@sust.se, bjorn.westrom@consoden.se
-    This file is part of SleekXMPP.
-
-    See the file LICENSE for copying permission.
-"""
-
-import datetime
-import logging
-
-class Device(object):
-    """
-    Example implementation of a device readout object. 
-    Is registered in the XEP_0323.register_node call
-    The device object may be any custom implementation to support 
-    specific devices, but it must implement the functions:
-          has_field
-          request_fields
-    """
-
-    def __init__(self, nodeId, fields={}):
-        self.nodeId = nodeId
-        self.fields = fields # see fields described below
-        # {'type':'numeric',
-        #  'name':'myname',
-        #  'value': 42,
-        #  'unit':'Z'}];
-        self.timestamp_data = {}
-        self.momentary_data = {}
-        self.momentary_timestamp = ""
-        logging.debug("Device object started nodeId %s",nodeId)
-
-    def has_field(self, field):
-        """
-        Returns true if the supplied field name exists in this device.
-
-        Arguments:
-            field      -- The field name        
-        """
-        if field in self.fields.keys():
-            return True;
-        return False;
-    
-    def refresh(self, fields):
-        """
-        override method to do the refresh work
-        refresh values from hardware or other
-        """
-        pass
-        
-
-    def request_fields(self, fields, flags, session, callback):
-        """
-        Starts a data readout. Verifies the requested fields,
-        refreshes the data (if needed) and calls the callback
-        with requested data.
-
-
-        Arguments:
-            fields   -- List of field names to readout
-            flags    -- [optional] data classifier flags for the field, e.g. momentary
-                        Formatted as a dictionary like { "flag name": "flag value" ... }
-            session  -- Session id, only used in the callback as identifier
-            callback -- Callback function to call when data is available.
-        
-                    The callback function must support the following arguments:
-
-                session  -- Session id, as supplied in the request_fields call
-                nodeId   -- Identifier for this device
-                result   -- The current result status of the readout. Valid values are:
-                               "error"  - Readout failed.
-                               "fields" - Contains readout data.
-                               "done"   - Indicates that the readout is complete. May contain 
-                                          readout data.
-                timestamp_block -- [optional] Only applies when result != "error" 
-                               The readout data. Structured as a dictionary:
-                  { 
-                    timestamp:     timestamp for this datablock,
-                    fields:        list of field dictionary (one per readout field).
-                      readout field dictionary format:
-                      {
-                        type:      The field type (numeric, boolean, dateTime, timeSpan, string, enum)
-                        name:      The field name
-                        value:     The field value
-                        unit:      The unit of the field. Only applies to type numeric.
-                        dataType:  The datatype of the field. Only applies to type enum.
-                        flags:     [optional] data classifier flags for the field, e.g. momentary
-                               Formatted as a dictionary like { "flag name": "flag value" ... }
-                      }  
-                  }
-                error_msg -- [optional] Only applies when result == "error".
-                                Error details when a request failed. 
-
-        """
-        logging.debug("request_fields called looking for fields %s",fields)
-        if len(fields) > 0:
-            # Check availiability
-            for f in fields:
-                if f not in self.fields.keys():
-                    self._send_reject(session, callback)
-                    return False;
-        else:
-            # Request all fields
-            fields = self.fields.keys();
-
-
-        # Refresh data from device
-        # ...
-        logging.debug("about to refresh device fields %s",fields)
-        self.refresh(fields)
-
-        if "momentary" in flags and flags['momentary'] == "true" or \
-           "all" in flags and flags['all'] == "true":
-            ts_block = {};
-            timestamp = "";
-
-            if len(self.momentary_timestamp) > 0:
-                timestamp = self.momentary_timestamp;
-            else:
-                timestamp = self._get_timestamp();
-
-            field_block = [];
-            for f in self.momentary_data:
-                if f in fields:
-                    field_block.append({"name": f, 
-                                "type": self.fields[f]["type"], 
-                                "unit": self.fields[f]["unit"],
-                                "dataType": self.fields[f]["dataType"],
-                                "value": self.momentary_data[f]["value"], 
-                                "flags": self.momentary_data[f]["flags"]});
-            ts_block["timestamp"] = timestamp;
-            ts_block["fields"] = field_block;
-
-            callback(session, result="done", nodeId=self.nodeId, timestamp_block=ts_block);
-            return
-
-        from_flag = self._datetime_flag_parser(flags, 'from')
-        to_flag = self._datetime_flag_parser(flags, 'to')
-
-        for ts in sorted(self.timestamp_data.keys()):
-            tsdt = datetime.datetime.strptime(ts, "%Y-%m-%dT%H:%M:%S")
-            if not from_flag is None: 
-                if tsdt < from_flag: 
-                    #print (str(tsdt) + " < " + str(from_flag))
-                    continue
-            if not to_flag is None: 
-                if tsdt > to_flag: 
-                    #print (str(tsdt) + " > " + str(to_flag))
-                    continue
-    
-            ts_block = {};
-            field_block = [];
-
-            for f in self.timestamp_data[ts]:
-                if f in fields:
-                    field_block.append({"name": f, 
-                                "type": self.fields[f]["type"], 
-                                "unit": self.fields[f]["unit"],
-                                "dataType": self.fields[f]["dataType"],
-                                "value": self.timestamp_data[ts][f]["value"], 
-                                "flags": self.timestamp_data[ts][f]["flags"]});
-
-            ts_block["timestamp"] = ts;
-            ts_block["fields"] = field_block;
-            callback(session, result="fields", nodeId=self.nodeId, timestamp_block=ts_block);
-        callback(session, result="done", nodeId=self.nodeId, timestamp_block=None);
-
-    def _datetime_flag_parser(self, flags, flagname):
-        if not flagname in flags:
-            return None
-        
-        dt = None
-        try:
-            dt = datetime.datetime.strptime(flags[flagname], "%Y-%m-%dT%H:%M:%S")
-        except ValueError:
-            # Badly formatted datetime, ignore it
-            pass
-        return dt
-
-
-    def _get_timestamp(self):
-        """
-        Generates a properly formatted timestamp of current time
-        """
-        return datetime.datetime.now().replace(microsecond=0).isoformat()
-
-    def _send_reject(self, session, callback):
-        """
-        Sends a reject to the caller
-
-        Arguments:
-            session  -- Session id, see definition in request_fields function
-            callback -- Callback function, see definition in request_fields function
-        """
-        callback(session, result="error", nodeId=self.nodeId, timestamp_block=None, error_msg="Reject");
-
-    def _add_field(self, name, typename, unit=None, dataType=None):
-        """
-        Adds a field to the device
-
-        Arguments:
-            name     -- Name of the field
-            typename -- Type of the field (numeric, boolean, dateTime, timeSpan, string, enum)
-            unit     -- [optional] only applies to "numeric". Unit for the field.
-            dataType -- [optional] only applies to "enum". Datatype for the field.
-        """
-        self.fields[name] = {"type": typename, "unit": unit, "dataType": dataType};
-
-    def _add_field_timestamp_data(self, name, timestamp, value, flags=None):
-        """
-        Adds timestamped data to a field
-
-        Arguments:
-            name      -- Name of the field
-            timestamp -- Timestamp for the data (string)
-            value     -- Field value at the timestamp
-            flags     -- [optional] data classifier flags for the field, e.g. momentary
-                         Formatted as a dictionary like { "flag name": "flag value" ... }
-        """
-        if not name in self.fields.keys():
-            return False;
-        if not timestamp in self.timestamp_data:
-            self.timestamp_data[timestamp] = {};
-
-        self.timestamp_data[timestamp][name] = {"value": value, "flags": flags};
-        return True;
-
-    def _add_field_momentary_data(self, name, value, flags=None):
-        """
-        Sets momentary data to a field
-
-        Arguments:
-            name      -- Name of the field
-            value     -- Field value at the timestamp
-            flags     -- [optional] data classifier flags for the field, e.g. momentary
-                         Formatted as a dictionary like { "flag name": "flag value" ... }
-        """
-        if name not in self.fields:
-            return False;
-        if flags is None:
-            flags = {};
-        
-        flags["momentary"] = "true"
-        self.momentary_data[name] = {"value": value, "flags": flags};
-        return True;
-
-    def _set_momentary_timestamp(self, timestamp):
-        """
-        This function is only for unit testing to produce predictable results.
-        """
-        self.momentary_timestamp = timestamp;
-
diff --git a/sleekxmpp/plugins/xep_0323/sensordata.py b/sleekxmpp/plugins/xep_0323/sensordata.py
deleted file mode 100644
index 2e2f2470..00000000
--- a/sleekxmpp/plugins/xep_0323/sensordata.py
+++ /dev/null
@@ -1,723 +0,0 @@
-"""
-    SleekXMPP: The Sleek XMPP Library
-    Implementation of xeps for Internet of Things
-    http://wiki.xmpp.org/web/Tech_pages/IoT_systems
-    Copyright (C) 2013 Sustainable Innovation, Joachim.lindborg@sust.se, bjorn.westrom@consoden.se
-    This file is part of SleekXMPP.
-
-    See the file LICENSE for copying permission.
-"""
-
-import logging
-import time
-import datetime
-from threading import Thread, Lock, Timer
-
-from sleekxmpp.plugins.xep_0323.timerreset import TimerReset
-
-from sleekxmpp.xmlstream import JID
-from sleekxmpp.xmlstream.handler import Callback
-from sleekxmpp.xmlstream.matcher import StanzaPath
-from sleekxmpp.plugins.base import BasePlugin
-from sleekxmpp.plugins.xep_0323 import stanza
-from sleekxmpp.plugins.xep_0323.stanza import Sensordata
-
-
-log = logging.getLogger(__name__)
-
-
-class XEP_0323(BasePlugin):
-
-    """
-    XEP-0323: IoT Sensor Data 
-
-
-    This XEP provides the underlying architecture, basic operations and data
-    structures for sensor data communication over XMPP networks. It includes
-    a hardware abstraction model, removing any technical detail implemented 
-    in underlying technologies.
-
-    Also see <http://xmpp.org/extensions/xep-0323.html>
-
-    Configuration Values:
-        threaded -- Indicates if communication with sensors should be threaded.
-                    Defaults to True.
-
-    Events:
-        Sensor side
-        -----------
-        Sensordata Event:Req    -- Received a request for data
-        Sensordata Event:Cancel -- Received a cancellation for a request
-
-        Client side
-        -----------
-        Sensordata Event:Accepted -- Received a accept from sensor for a request
-        Sensordata Event:Rejected -- Received a reject from sensor for a request
-        Sensordata Event:Cancelled -- Received a cancel confirm from sensor
-        Sensordata Event:Fields   -- Received fields from sensor for a request
-                                     This may be triggered multiple times since 
-                                     the sensor can split up its response in
-                                     multiple messages.
-        Sensordata Event:Failure  -- Received a failure indication from sensor 
-                                     for a request. Typically a comm timeout.
-
-    Attributes:
-        threaded -- Indicates if command events should be threaded.
-                    Defaults to True.
-        sessions -- A dictionary or equivalent backend mapping
-                    session IDs to dictionaries containing data
-                    relevant to a request's session. This dictionary is used
-                    both by the client and sensor side. On client side, seqnr
-                    is used as key, while on sensor side, a session_id is used
-                    as key. This ensures that the two will not collide, so 
-                    one instance can be both client and sensor.
-        Sensor side
-        -----------
-        nodes    -- A dictionary mapping sensor nodes that are serviced through
-                    this XMPP instance to their device handlers ("drivers").
-        Client side
-        -----------
-        last_seqnr -- The last used sequence number (integer). One sequence of
-                    communication (e.g. -->request, <--accept, <--fields)
-                    between client and sensor is identified by a unique
-                    sequence number (unique between the client/sensor pair)
-
-    Methods:
-        plugin_init       -- Overrides base_plugin.plugin_init
-        post_init         -- Overrides base_plugin.post_init
-        plugin_end        -- Overrides base_plugin.plugin_end
-
-        Sensor side
-        -----------
-        register_node     -- Register a sensor as available from this XMPP 
-                             instance.
-
-        Client side
-        -----------
-        request_data      -- Initiates a request for data from one or more 
-                             sensors. Non-blocking, a callback function will
-                             be called when data is available.
-
-    """
-
-    name = 'xep_0323'
-    description = 'XEP-0323 Internet of Things - Sensor Data'
-    dependencies = set(['xep_0030']) 
-    stanza = stanza
-
-
-    default_config = {
-        'threaded': True
-#        'session_db': None
-    }
-
-    def plugin_init(self):
-        """ Start the XEP-0323 plugin """
-
-        self.xmpp.register_handler(
-                Callback('Sensordata Event:Req',
-                    StanzaPath('iq@type=get/req'),
-                    self._handle_event_req))
-
-        self.xmpp.register_handler(
-                Callback('Sensordata Event:Accepted',
-                    StanzaPath('iq@type=result/accepted'),
-                    self._handle_event_accepted))
-
-        self.xmpp.register_handler(
-                Callback('Sensordata Event:Rejected',
-                    StanzaPath('iq@type=error/rejected'),
-                    self._handle_event_rejected))
-
-        self.xmpp.register_handler(
-                Callback('Sensordata Event:Cancel',
-                    StanzaPath('iq@type=get/cancel'),
-                    self._handle_event_cancel))
-
-        self.xmpp.register_handler(
-                Callback('Sensordata Event:Cancelled',
-                    StanzaPath('iq@type=result/cancelled'),
-                    self._handle_event_cancelled))
-
-        self.xmpp.register_handler(
-                Callback('Sensordata Event:Fields',
-                    StanzaPath('message/fields'),
-                    self._handle_event_fields))
-
-        self.xmpp.register_handler(
-                Callback('Sensordata Event:Failure',
-                    StanzaPath('message/failure'),
-                    self._handle_event_failure))
-
-        self.xmpp.register_handler(
-                Callback('Sensordata Event:Started',
-                    StanzaPath('message/started'),
-                    self._handle_event_started))
-
-        # Server side dicts
-        self.nodes = {};
-        self.sessions = {};
-
-        self.last_seqnr = 0;
-        self.seqnr_lock = Lock();
-
-        ## For testning only
-        self.test_authenticated_from = ""
-
-    def post_init(self):
-        """ Init complete. Register our features in Serivce discovery. """
-        BasePlugin.post_init(self)
-        self.xmpp['xep_0030'].add_feature(Sensordata.namespace)
-        self.xmpp['xep_0030'].set_items(node=Sensordata.namespace, items=tuple())
-
-    def _new_session(self):
-        """ Return a new session ID. """
-        return str(time.time()) + '-' + self.xmpp.new_id()
-
-    def session_bind(self, jid):
-        logging.debug("setting the Disco discovery for %s" % Sensordata.namespace)
-        self.xmpp['xep_0030'].add_feature(Sensordata.namespace)
-        self.xmpp['xep_0030'].set_items(node=Sensordata.namespace, items=tuple())
-
-
-    def plugin_end(self):
-        """ Stop the XEP-0323 plugin """
-        self.sessions.clear();
-        self.xmpp.remove_handler('Sensordata Event:Req')
-        self.xmpp.remove_handler('Sensordata Event:Accepted')
-        self.xmpp.remove_handler('Sensordata Event:Rejected')
-        self.xmpp.remove_handler('Sensordata Event:Cancel')
-        self.xmpp.remove_handler('Sensordata Event:Cancelled')
-        self.xmpp.remove_handler('Sensordata Event:Fields')
-        self.xmpp['xep_0030'].del_feature(feature=Sensordata.namespace)
-
-
-    # =================================================================
-    # Sensor side (data provider) API
-
-    def register_node(self, nodeId, device, commTimeout, sourceId=None, cacheType=None):
-        """
-        Register a sensor/device as available for serving of data through this XMPP
-        instance. 
-
-        The device object may by any custom implementation to support 
-        specific devices, but it must implement the functions:
-          has_field
-          request_fields
-        according to the interfaces shown in the example device.py file.
-
-        Arguments:
-            nodeId      -- The identifier for the device
-            device      -- The device object
-            commTimeout -- Time in seconds to wait between each callback from device during
-                           a data readout. Float.
-            sourceId    -- [optional] identifying the data source controlling the device
-            cacheType   -- [optional] narrowing down the search to a specific kind of node        
-        """
-        self.nodes[nodeId] = {"device": device, 
-                                "commTimeout": commTimeout,
-                                "sourceId": sourceId, 
-                                "cacheType": cacheType};
-
-    def _set_authenticated(self, auth=''):
-        """ Internal testing function """
-        self.test_authenticated_from = auth;
-
-
-    def _handle_event_req(self, iq):
-        """
-        Event handler for reception of an Iq with req - this is a request.
-
-        Verifies that 
-          - all the requested nodes are available
-          - at least one of the requested fields is available from at least 
-            one of the nodes
-
-        If the request passes verification, an accept response is sent, and
-        the readout process is started in a separate thread.
-        If the verification fails, a reject message is sent.
-        """
-
-        seqnr = iq['req']['seqnr'];
-        error_msg = '';
-        req_ok = True;
-
-        # Authentication
-        if len(self.test_authenticated_from) > 0 and not iq['from'] == self.test_authenticated_from:
-            # Invalid authentication
-            req_ok = False;
-            error_msg = "Access denied";
-
-        # Nodes
-        process_nodes = [];
-        if len(iq['req']['nodes']) > 0:
-            for n in iq['req']['nodes']:
-                if not n['nodeId'] in self.nodes:
-                    req_ok = False;
-                    error_msg = "Invalid nodeId " + n['nodeId'];
-            process_nodes = [n['nodeId'] for n in iq['req']['nodes']];
-        else:
-            process_nodes = self.nodes.keys();
-
-        # Fields - if we just find one we are happy, otherwise we reject
-        process_fields = [];
-        if len(iq['req']['fields']) > 0:
-            found = False
-            for f in iq['req']['fields']:
-                for node in self.nodes:
-                    if self.nodes[node]["device"].has_field(f['name']):
-                        found = True;
-                        break;
-            if not found:
-                req_ok = False;
-                error_msg = "Invalid field " + f['name'];
-            process_fields = [f['name'] for n in iq['req']['fields']];
-
-        req_flags = iq['req']._get_flags();
-
-        request_delay_sec = None
-        if 'when' in req_flags:
-            # Timed request - requires datetime string in iso format
-            # ex. 2013-04-05T15:00:03
-            dt = None
-            try:
-                dt = datetime.datetime.strptime(req_flags['when'], "%Y-%m-%dT%H:%M:%S")
-            except ValueError:
-                req_ok = False;
-                error_msg = "Invalid datetime in 'when' flag, please use ISO format (i.e. 2013-04-05T15:00:03)."
-
-            if not dt is None:
-                # Datetime properly formatted
-                dtnow = datetime.datetime.now()
-                dtdiff = dt - dtnow
-                request_delay_sec = dtdiff.seconds + dtdiff.days * 24 * 3600
-                if request_delay_sec <= 0:
-                    req_ok = False;
-                    error_msg = "Invalid datetime in 'when' flag, cannot set a time in the past. Current time: " + dtnow.isoformat();
-
-        if req_ok:
-            session = self._new_session();
-            self.sessions[session] = {"from": iq['from'], "to": iq['to'], "seqnr": seqnr};
-            self.sessions[session]["commTimers"] = {};
-            self.sessions[session]["nodeDone"] = {};
-
-            #print("added session: " + str(self.sessions))
-
-            iq.reply();
-            iq['accepted']['seqnr'] = seqnr;
-            if not request_delay_sec is None:
-                iq['accepted']['queued'] = "true"
-            iq.send(block=False);
-
-            self.sessions[session]["node_list"] = process_nodes;
-
-            if not request_delay_sec is None:
-                # Delay request to requested time
-                timer = Timer(request_delay_sec, self._event_delayed_req, args=(session, process_fields, req_flags))
-                self.sessions[session]["commTimers"]["delaytimer"] = timer;
-                timer.start();
-                return
-
-            if self.threaded:
-                #print("starting thread")
-                tr_req = Thread(target=self._threaded_node_request, args=(session, process_fields, req_flags))
-                tr_req.start()
-                #print("started thread")
-            else:
-                self._threaded_node_request(session, process_fields, req_flags);
-
-        else:
-            iq.reply();
-            iq['type'] = 'error';
-            iq['rejected']['seqnr'] = seqnr;
-            iq['rejected']['error'] = error_msg;
-            iq.send(block=False);            
-
-    def _threaded_node_request(self, session, process_fields, flags):
-        """ 
-        Helper function to handle the device readouts in a separate thread.
-        
-        Arguments:
-            session         -- The request session id
-            process_fields  -- The fields to request from the devices
-            flags           -- [optional] flags to pass to the devices, e.g. momentary
-                               Formatted as a dictionary like { "flag name": "flag value" ... }
-        """
-        for node in self.sessions[session]["node_list"]:
-            self.sessions[session]["nodeDone"][node] = False;        
-
-        for node in self.sessions[session]["node_list"]:
-            timer = TimerReset(self.nodes[node]['commTimeout'], self._event_comm_timeout, args=(session, node));
-            self.sessions[session]["commTimers"][node] = timer;
-            #print("Starting timer " + str(timer) + ", timeout: " + str(self.nodes[node]['commTimeout']))
-            timer.start();
-            self.nodes[node]['device'].request_fields(process_fields, flags=flags, session=session, callback=self._device_field_request_callback);
-
-    def _event_comm_timeout(self, session, nodeId):
-        """ 
-        Triggered if any of the readout operations timeout.
-        Sends a failure message back to the client, stops communicating
-        with the failing device.
-        
-        Arguments:
-            session         -- The request session id
-            nodeId          -- The id of the device which timed out
-        """
-        msg = self.xmpp.Message();
-        msg['from'] = self.sessions[session]['to'];
-        msg['to'] = self.sessions[session]['from'];
-        msg['failure']['seqnr'] = self.sessions[session]['seqnr'];            
-        msg['failure']['error']['text'] = "Timeout";
-        msg['failure']['error']['nodeId'] = nodeId;
-        msg['failure']['error']['timestamp'] = datetime.datetime.now().replace(microsecond=0).isoformat();
-
-        # Drop communication with this device and check if we are done
-        self.sessions[session]["nodeDone"][nodeId] = True;
-        if (self._all_nodes_done(session)):
-            msg['failure']['done'] = 'true';
-        msg.send();
-        # The session is complete, delete it
-        #print("del session " + session + " due to timeout")
-        del self.sessions[session];
-
-    def _event_delayed_req(self, session, process_fields, req_flags):
-        """
-        Triggered when the timer from a delayed request fires.
-
-        Arguments:
-            session         -- The request session id
-            process_fields  -- The fields to request from the devices
-            flags           -- [optional] flags to pass to the devices, e.g. momentary
-                               Formatted as a dictionary like { "flag name": "flag value" ... }
-        """
-        msg = self.xmpp.Message();
-        msg['from'] = self.sessions[session]['to'];
-        msg['to'] = self.sessions[session]['from'];
-        msg['started']['seqnr'] = self.sessions[session]['seqnr'];
-        msg.send();
-
-        if self.threaded:
-            tr_req = Thread(target=self._threaded_node_request, args=(session, process_fields, req_flags))
-            tr_req.start()
-        else:
-            self._threaded_node_request(session, process_fields, req_flags);
-
-    def _all_nodes_done(self, session):
-        """ 
-        Checks wheter all devices are done replying to the readout.
-        
-        Arguments:
-            session         -- The request session id
-        """
-        for n in self.sessions[session]["nodeDone"]:
-            if not self.sessions[session]["nodeDone"][n]:
-                return False;
-        return True;
-
-    def _device_field_request_callback(self, session, nodeId, result, timestamp_block, error_msg=None):
-        """ 
-        Callback function called by the devices when they have any additional data.
-        Composes a message with the data and sends it back to the client, and resets 
-        the timeout timer for the device.
-        
-        Arguments:
-            session         -- The request session id
-            nodeId          -- The device id which initiated the callback
-            result          -- The current result status of the readout. Valid values are:
-                               "error"  - Readout failed.
-                               "fields" - Contains readout data.
-                               "done"   - Indicates that the readout is complete. May contain 
-                                          readout data.
-            timestamp_block -- [optional] Only applies when result != "error" 
-                               The readout data. Structured as a dictionary:
-              { 
-                timestamp:     timestamp for this datablock,
-                fields:        list of field dictionary (one per readout field).
-                  readout field dictionary format:
-                  {
-                    type:      The field type (numeric, boolean, dateTime, timeSpan, string, enum)
-                    name:      The field name
-                    value:     The field value
-                    unit:      The unit of the field. Only applies to type numeric.
-                    dataType:  The datatype of the field. Only applies to type enum.
-                    flags:     [optional] data classifier flags for the field, e.g. momentary
-                               Formatted as a dictionary like { "flag name": "flag value" ... }
-                  }  
-              }
-            error_msg        -- [optional] Only applies when result == "error".
-                                Error details when a request failed.
-        """
-        if not session in self.sessions:
-            # This can happend if a session was deleted, like in a cancellation. Just drop the data.
-            return
-
-        if result == "error":
-            self.sessions[session]["commTimers"][nodeId].cancel();
-
-            msg = self.xmpp.Message();
-            msg['from'] = self.sessions[session]['to'];
-            msg['to'] = self.sessions[session]['from'];
-            msg['failure']['seqnr'] = self.sessions[session]['seqnr'];
-            msg['failure']['error']['text'] = error_msg;
-            msg['failure']['error']['nodeId'] = nodeId;
-            msg['failure']['error']['timestamp'] = datetime.datetime.now().replace(microsecond=0).isoformat();
-
-            # Drop communication with this device and check if we are done
-            self.sessions[session]["nodeDone"][nodeId] = True;   
-            if (self._all_nodes_done(session)):
-                msg['failure']['done'] = 'true';
-                # The session is complete, delete it
-                # print("del session " + session + " due to error")
-                del self.sessions[session];
-            msg.send();
-        else:
-            msg = self.xmpp.Message();
-            msg['from'] = self.sessions[session]['to'];
-            msg['to'] = self.sessions[session]['from'];
-            msg['fields']['seqnr'] = self.sessions[session]['seqnr'];
-
-            if timestamp_block is not None and len(timestamp_block) > 0:
-                node = msg['fields'].add_node(nodeId);
-                ts = node.add_timestamp(timestamp_block["timestamp"]);
-
-                for f in timestamp_block["fields"]:
-                    data = ts.add_data( typename=f['type'], 
-                                        name=f['name'], 
-                                        value=f['value'], 
-                                        unit=f['unit'], 
-                                        dataType=f['dataType'], 
-                                        flags=f['flags']);
-
-            if result == "done":
-                self.sessions[session]["commTimers"][nodeId].cancel();
-                self.sessions[session]["nodeDone"][nodeId] = True;
-                msg['fields']['done'] = 'true';
-                if (self._all_nodes_done(session)):
-                    # The session is complete, delete it
-                    # print("del session " + session + " due to complete")
-                    del self.sessions[session];
-            else:
-                # Restart comm timer
-                self.sessions[session]["commTimers"][nodeId].reset();
-
-            msg.send();
-
-    def _handle_event_cancel(self, iq):
-        """ Received Iq with cancel - this is a cancel request. 
-        Delete the session and confirm. """
-
-        seqnr = iq['cancel']['seqnr'];
-        # Find the session
-        for s in self.sessions:
-            if self.sessions[s]['from'] == iq['from'] and self.sessions[s]['to'] == iq['to'] and self.sessions[s]['seqnr'] == seqnr:
-                # found it. Cancel all timers
-                for n in self.sessions[s]["commTimers"]:
-                    self.sessions[s]["commTimers"][n].cancel();
-
-                # Confirm
-                iq.reply();
-                iq['type'] = 'result';
-                iq['cancelled']['seqnr'] = seqnr;
-                iq.send(block=False);            
-                
-                # Delete session
-                del self.sessions[s]
-                return
-
-        # Could not find session, send reject
-        iq.reply();
-        iq['type'] = 'error';
-        iq['rejected']['seqnr'] = seqnr;
-        iq['rejected']['error'] = "Cancel request received, no matching request is active.";
-        iq.send(block=False);       
-
-    # =================================================================
-    # Client side (data retriever) API
-
-    def request_data(self, from_jid, to_jid, callback, nodeIds=None, fields=None, flags=None):
-        """ 
-        Called on the client side to initiade a data readout.
-        Composes a message with the request and sends it to the device(s).
-        Does not block, the callback will be called when data is available.
-        
-        Arguments:
-            from_jid        -- The jid of the requester
-            to_jid          -- The jid of the device(s)
-            callback        -- The callback function to call when data is availble. 
-                            
-                            The callback function must support the following arguments:
-
-                from_jid    -- The jid of the responding device(s)
-                result      -- The current result status of the readout. Valid values are:
-                               "accepted"  - Readout request accepted
-                               "queued"    - Readout request accepted and queued
-                               "rejected"  - Readout request rejected
-                               "failure"   - Readout failed.
-                               "cancelled" - Confirmation of request cancellation.
-                               "started"   - Previously queued request is now started
-                               "fields"    - Contains readout data.
-                               "done"      - Indicates that the readout is complete.
-
-                nodeId      -- [optional] Mandatory when result == "fields" or "failure".
-                               The node Id of the responding device. One callback will only
-                               contain data from one device.
-                timestamp   -- [optional] Mandatory when result == "fields".
-                               The timestamp of data in this callback. One callback will only
-                               contain data from one timestamp.
-                fields      -- [optional] Mandatory when result == "fields".
-                               List of field dictionaries representing the readout data. 
-                               Dictionary format:
-                  {
-                    typename:  The field type (numeric, boolean, dateTime, timeSpan, string, enum)
-                    name:      The field name
-                    value:     The field value
-                    unit:      The unit of the field. Only applies to type numeric.
-                    dataType:  The datatype of the field. Only applies to type enum.
-                    flags:     [optional] data classifier flags for the field, e.g. momentary.
-                               Formatted as a dictionary like { "flag name": "flag value" ... }
-                  }  
-
-                error_msg   -- [optional] Mandatory when result == "rejected" or "failure".
-                               Details about why the request is rejected or failed. 
-                               "rejected" means that the request is stopped, but note that the 
-                               request will continue even after a "failure". "failure" only means
-                               that communication was stopped to that specific device, other
-                               device(s) (if any) will continue their readout.
-
-            nodeIds      -- [optional] Limits the request to the node Ids in this list.
-            fields       -- [optional] Limits the request to the field names in this list.
-            flags        -- [optional] Limits the request according to the flags, or sets
-                            readout conditions such as timing.
-
-        Return value:
-            session      -- Session identifier. Client can use this as a reference to cancel
-                            the request.
-        """
-        iq = self.xmpp.Iq();
-        iq['from'] = from_jid;
-        iq['to'] = to_jid;
-        iq['type'] = "get";
-        seqnr = self._get_new_seqnr();
-        iq['id'] = seqnr;
-        iq['req']['seqnr'] = seqnr;
-        if nodeIds is not None:
-            for nodeId in nodeIds:
-                iq['req'].add_node(nodeId);
-        if fields is not None:
-            for field in fields:
-                iq['req'].add_field(field);
-
-        iq['req']._set_flags(flags);
-
-        self.sessions[seqnr] = {"from": iq['from'], "to": iq['to'], "seqnr": seqnr, "callback": callback};
-        iq.send(block=False); 
-
-        return seqnr;
-
-    def cancel_request(self, session):
-        """ 
-        Called on the client side to cancel a request for data readout.
-        Composes a message with the cancellation and sends it to the device(s).
-        Does not block, the callback will be called when cancellation is 
-        confirmed.
-        
-        Arguments:
-            session        -- The session id of the request to cancel
-        """
-        seqnr = session
-        iq = self.xmpp.Iq();
-        iq['from'] = self.sessions[seqnr]['from']
-        iq['to'] = self.sessions[seqnr]['to'];
-        iq['type'] = "get";
-        iq['id'] = seqnr;
-        iq['cancel']['seqnr'] = seqnr;
-        iq.send(block=False);
-
-    def _get_new_seqnr(self):
-        """ Returns a unique sequence number (unique across threads) """
-        self.seqnr_lock.acquire();
-        self.last_seqnr = self.last_seqnr + 1;
-        self.seqnr_lock.release();
-        return str(self.last_seqnr);
-
-    def _handle_event_accepted(self, iq):
-        """ Received Iq with accepted - request was accepted """
-        seqnr = iq['accepted']['seqnr'];
-        result = "accepted"
-        if iq['accepted']['queued'] == 'true':
-            result = "queued"
-
-        callback = self.sessions[seqnr]["callback"];
-        callback(from_jid=iq['from'], result=result);
-
-    def _handle_event_rejected(self, iq):
-        """ Received Iq with rejected - this is a reject. 
-        Delete the session. """
-        seqnr = iq['rejected']['seqnr'];
-        callback = self.sessions[seqnr]["callback"];
-        callback(from_jid=iq['from'], result="rejected", error_msg=iq['rejected']['error']);
-        # Session terminated
-        del self.sessions[seqnr];
-
-    def _handle_event_cancelled(self, iq):
-        """ 
-        Received Iq with cancelled - this is a cancel confirm. 
-        Delete the session. 
-        """
-        #print("Got cancelled")
-        seqnr = iq['cancelled']['seqnr'];
-        callback = self.sessions[seqnr]["callback"];
-        callback(from_jid=iq['from'], result="cancelled");
-        # Session cancelled
-        del self.sessions[seqnr];
-
-    def _handle_event_fields(self, msg):
-        """ 
-        Received Msg with fields - this is a data reponse to a request.
-        If this is the last data block, issue a "done" callback.
-        """
-        seqnr = msg['fields']['seqnr'];
-        callback = self.sessions[seqnr]["callback"];
-        for node in msg['fields']['nodes']:
-            for ts in node['timestamps']:
-                fields = [];
-                for d in ts['datas']:
-                    field_block = {};
-                    field_block["name"] = d['name'];
-                    field_block["typename"] = d._get_typename();
-                    field_block["value"] = d['value'];
-                    if not d['unit'] == "": field_block["unit"] = d['unit'];
-                    if not d['dataType'] == "": field_block["dataType"] = d['dataType'];
-                    flags = d._get_flags();
-                    if not len(flags) == 0:
-                        field_block["flags"] = flags;
-                    fields.append(field_block);
-
-                callback(from_jid=msg['from'], result="fields", nodeId=node['nodeId'], timestamp=ts['value'], fields=fields);
-                
-        if msg['fields']['done'] == "true":
-            callback(from_jid=msg['from'], result="done");
-            # Session done
-            del self.sessions[seqnr];
-
-    def _handle_event_failure(self, msg):
-        """ 
-        Received Msg with failure - our request failed
-        Delete the session. 
-        """
-        seqnr = msg['failure']['seqnr'];
-        callback = self.sessions[seqnr]["callback"];
-        callback(from_jid=msg['from'], result="failure", nodeId=msg['failure']['error']['nodeId'], timestamp=msg['failure']['error']['timestamp'], error_msg=msg['failure']['error']['text']);
-
-        # Session failed
-        del self.sessions[seqnr];
-
-    def _handle_event_started(self, msg):
-        """ 
-        Received Msg with started - our request was queued and is now started. 
-        """
-        seqnr = msg['started']['seqnr'];
-        callback = self.sessions[seqnr]["callback"];
-        callback(from_jid=msg['from'], result="started");
-    
-
diff --git a/sleekxmpp/plugins/xep_0323/stanza/__init__.py b/sleekxmpp/plugins/xep_0323/stanza/__init__.py
deleted file mode 100644
index c039cefa..00000000
--- a/sleekxmpp/plugins/xep_0323/stanza/__init__.py
+++ /dev/null
@@ -1,12 +0,0 @@
-"""
-    SleekXMPP: The Sleek XMPP Library
-    Implementation of xeps for Internet of Things
-    http://wiki.xmpp.org/web/Tech_pages/IoT_systems
-    Copyright (C) 2013 Sustainable Innovation, Joachim.lindborg@sust.se, bjorn.westrom@consoden.se
-    This file is part of SleekXMPP.
-
-    See the file LICENSE for copying permission.
-"""
-
-from sleekxmpp.plugins.xep_0323.stanza.sensordata import *
-
diff --git a/sleekxmpp/plugins/xep_0323/stanza/base.py b/sleekxmpp/plugins/xep_0323/stanza/base.py
deleted file mode 100644
index 1dadcf46..00000000
--- a/sleekxmpp/plugins/xep_0323/stanza/base.py
+++ /dev/null
@@ -1,13 +0,0 @@
-"""
-    SleekXMPP: The Sleek XMPP Library
-    Implementation of xeps for Internet of Things
-    http://wiki.xmpp.org/web/Tech_pages/IoT_systems
-    Copyright (C) 2013 Sustainable Innovation, Joachim.lindborg@sust.se, bjorn.westrom@consoden.se
-    This file is part of SleekXMPP.
-
-    See the file LICENSE for copying permission.
-"""
-
-from sleekxmpp.xmlstream import ET
-
-pass
diff --git a/sleekxmpp/plugins/xep_0323/stanza/sensordata.py b/sleekxmpp/plugins/xep_0323/stanza/sensordata.py
deleted file mode 100644
index a11c3e94..00000000
--- a/sleekxmpp/plugins/xep_0323/stanza/sensordata.py
+++ /dev/null
@@ -1,792 +0,0 @@
-"""
-    SleekXMPP: The Sleek XMPP Library
-    Implementation of xeps for Internet of Things
-    http://wiki.xmpp.org/web/Tech_pages/IoT_systems
-    Copyright (C) 2013 Sustainable Innovation, Joachim.lindborg@sust.se, bjorn.westrom@consoden.se
-    This file is part of SleekXMPP.
-
-    See the file LICENSE for copying permission.
-"""
-
-from sleekxmpp import Iq, Message
-from sleekxmpp.xmlstream import register_stanza_plugin, ElementBase, ET, JID
-from re import match
-
-class Sensordata(ElementBase):
-    """ Placeholder for the namespace, not used as a stanza """
-    namespace = 'urn:xmpp:iot:sensordata'
-    name = 'sensordata'
-    plugin_attrib = name
-    interfaces = set(tuple())
-
-class FieldTypes():
-    """ 
-    All field types are optional booleans that default to False
-    """
-    field_types = set([ 'momentary','peak','status','computed','identity','historicalSecond','historicalMinute','historicalHour', \
-                        'historicalDay','historicalWeek','historicalMonth','historicalQuarter','historicalYear','historicalOther'])
-
-class FieldStatus():
-    """ 
-    All field statuses are optional booleans that default to False
-    """
-    field_status = set([ 'missing','automaticEstimate','manualEstimate','manualReadout','automaticReadout','timeOffset','warning','error', \
-                         'signed','invoiced','endOfSeries','powerFailure','invoiceConfirmed'])
-
-class Request(ElementBase):
-    namespace = 'urn:xmpp:iot:sensordata'
-    name = 'req'
-    plugin_attrib = name
-    interfaces = set(['seqnr','nodes','fields','serviceToken','deviceToken','userToken','from','to','when','historical','all'])
-    interfaces.update(FieldTypes.field_types);
-    _flags = set(['serviceToken','deviceToken','userToken','from','to','when','historical','all']);
-    _flags.update(FieldTypes.field_types);
-    
-    def __init__(self, xml=None, parent=None):
-        ElementBase.__init__(self, xml, parent);
-        self._nodes = set()
-        self._fields = set()
-
-    def setup(self, xml=None):
-        """
-        Populate the stanza object using an optional XML object.
-
-        Overrides ElementBase.setup
-
-        Caches item information.
-
-        Arguments:
-            xml -- Use an existing XML object for the stanza's values.
-        """
-        ElementBase.setup(self, xml)
-        self._nodes = set([node['nodeId'] for node in self['nodes']])
-        self._fields = set([field['name'] for field in self['fields']])
-
-    def _get_flags(self):
-        """
-        Helper function for getting of flags. Returns all flags in 
-        dictionary format: { "flag name": "flag value" ... } 
-        """
-        flags = {};
-        for f in self._flags:
-            if not self[f] == "":
-                flags[f] = self[f];
-        return flags;
-
-    def _set_flags(self, flags):
-        """
-        Helper function for setting of flags. 
-
-        Arguments:
-            flags -- Flags in dictionary format: { "flag name": "flag value" ... } 
-        """
-        for f in self._flags:
-            if flags is not None and f in flags:
-                self[f] = flags[f];
-            else:
-                self[f] = None;
-
-    def add_node(self, nodeId, sourceId=None, cacheType=None):
-        """
-        Add a new node element. Each item is required to have a
-        nodeId, but may also specify a sourceId value and cacheType.
-
-        Arguments:
-            nodeId    -- The ID for the node.
-            sourceId  -- [optional] identifying the data source controlling the device
-            cacheType -- [optional] narrowing down the search to a specific kind of node        
-        """
-        if nodeId not in self._nodes:
-            self._nodes.add((nodeId))
-            node = RequestNode(parent=self)
-            node['nodeId'] = nodeId
-            node['sourceId'] = sourceId
-            node['cacheType'] = cacheType
-            self.iterables.append(node)
-            return node
-        return None
-
-    def del_node(self, nodeId):
-        """
-        Remove a single node.
-
-        Arguments:
-            nodeId  -- Node ID of the item to remove.
-        """
-        if nodeId in self._nodes:
-            nodes = [i for i in self.iterables if isinstance(i, RequestNode)]
-            for node in nodes:
-                if node['nodeId'] == nodeId:
-                    self.xml.remove(node.xml)
-                    self.iterables.remove(node)
-                    return True
-        return False
-
-    def get_nodes(self):
-        """Return all nodes."""
-        nodes = []
-        for node in self['substanzas']:
-            if isinstance(node, RequestNode):
-                nodes.append(node)
-        return nodes
-
-    def set_nodes(self, nodes):
-        """
-        Set or replace all nodes. The given nodes must be in a
-        list or set where each item is a tuple of the form:
-            (nodeId, sourceId, cacheType)
-
-        Arguments:
-            nodes -- A series of nodes in tuple format.
-        """
-        self.del_nodes()
-        for node in nodes:
-            if isinstance(node, RequestNode):
-                self.add_node(node['nodeId'], node['sourceId'], node['cacheType'])
-            else:
-                nodeId, sourceId, cacheType = node
-                self.add_node(nodeId, sourceId, cacheType)
-
-    def del_nodes(self):
-        """Remove all nodes."""
-        self._nodes = set()
-        nodes = [i for i in self.iterables if isinstance(i, RequestNode)]
-        for node in nodes:
-            self.xml.remove(node.xml)
-            self.iterables.remove(node)
-
-
-    def add_field(self, name):
-        """
-        Add a new field element. Each item is required to have a
-        name.
-
-        Arguments:
-            name  -- The name of the field.
-        """
-        if name not in self._fields:
-            self._fields.add((name))
-            field = RequestField(parent=self)
-            field['name'] = name
-            self.iterables.append(field)
-            return field
-        return None
-
-    def del_field(self, name):
-        """
-        Remove a single field.
-
-        Arguments:
-            name  -- name of field to remove.
-        """
-        if name in self._fields:
-            fields = [i for i in self.iterables if isinstance(i, RequestField)]
-            for field in fields:
-                if field['name'] == name:
-                    self.xml.remove(field.xml)
-                    self.iterables.remove(field)
-                    return True
-        return False
-
-    def get_fields(self):
-        """Return all fields."""
-        fields = []
-        for field in self['substanzas']:
-            if isinstance(field, RequestField):
-                fields.append(field)
-        return fields
-
-    def set_fields(self, fields):
-        """
-        Set or replace all fields. The given fields must be in a
-        list or set where each item is RequestField or string
-
-        Arguments:
-            fields -- A series of fields in RequestField or string format.
-        """
-        self.del_fields()
-        for field in fields:
-            if isinstance(field, RequestField):
-                self.add_field(field['name'])
-            else:
-                self.add_field(field)
-
-    def del_fields(self):
-        """Remove all fields."""
-        self._fields = set()
-        fields = [i for i in self.iterables if isinstance(i, RequestField)]
-        for field in fields:
-            self.xml.remove(field.xml)
-            self.iterables.remove(field)
-
-
-class RequestNode(ElementBase):
-    """ Node element in a request """
-    namespace = 'urn:xmpp:iot:sensordata'
-    name = 'node'
-    plugin_attrib = name
-    interfaces = set(['nodeId','sourceId','cacheType'])
-
-class RequestField(ElementBase):
-    """ Field element in a request """
-    namespace = 'urn:xmpp:iot:sensordata'
-    name = 'field'
-    plugin_attrib = name
-    interfaces = set(['name'])
-
-class Accepted(ElementBase):
-    namespace = 'urn:xmpp:iot:sensordata'
-    name = 'accepted'
-    plugin_attrib = name
-    interfaces = set(['seqnr','queued'])
-
-class Started(ElementBase):
-    namespace = 'urn:xmpp:iot:sensordata'
-    name = 'started'
-    plugin_attrib = name
-    interfaces = set(['seqnr'])
-
-class Failure(ElementBase):
-    namespace = 'urn:xmpp:iot:sensordata'
-    name = 'failure'
-    plugin_attrib = name
-    interfaces = set(['seqnr','done'])
-
-class Error(ElementBase):
-    """ Error element in a request failure """
-    namespace = 'urn:xmpp:iot:sensordata'
-    name = 'error'
-    plugin_attrib = name
-    interfaces = set(['nodeId','timestamp','sourceId','cacheType','text'])
-
-    def get_text(self):
-        """Return then contents inside the XML tag."""
-        return self.xml.text
-
-    def set_text(self, value):
-        """Set then contents inside the XML tag.
-
-        :param value: string
-        """
-
-        self.xml.text = value;
-        return self
-
-    def del_text(self):
-        """Remove the contents inside the XML tag."""
-        self.xml.text = ""
-        return self
-
-class Rejected(ElementBase):
-    namespace = 'urn:xmpp:iot:sensordata'
-    name = 'rejected'
-    plugin_attrib = name
-    interfaces = set(['seqnr','error'])
-    sub_interfaces = set(['error'])
-
-class Fields(ElementBase):
-    """ Fields element, top level in a response message with data """
-    namespace = 'urn:xmpp:iot:sensordata'
-    name = 'fields'
-    plugin_attrib = name
-    interfaces = set(['seqnr','done','nodes'])
-
-    def __init__(self, xml=None, parent=None):
-        ElementBase.__init__(self, xml, parent);
-        self._nodes = set()
-
-    def setup(self, xml=None):
-        """
-        Populate the stanza object using an optional XML object.
-
-        Overrides ElementBase.setup
-
-        Caches item information.
-
-        Arguments:
-            xml -- Use an existing XML object for the stanza's values.
-        """
-        ElementBase.setup(self, xml)
-        self._nodes = set([node['nodeId'] for node in self['nodes']])
-
-
-    def add_node(self, nodeId, sourceId=None, cacheType=None, substanzas=None):
-        """
-        Add a new node element. Each item is required to have a
-        nodeId, but may also specify a sourceId value and cacheType.
-
-        Arguments:
-            nodeId  -- The ID for the node.
-            sourceId  -- [optional] identifying the data source controlling the device
-            cacheType -- [optional] narrowing down the search to a specific kind of node        
-        """
-        if nodeId not in self._nodes:
-            self._nodes.add((nodeId))
-            node = FieldsNode(parent=self)
-            node['nodeId'] = nodeId
-            node['sourceId'] = sourceId
-            node['cacheType'] = cacheType
-            if substanzas is not None:
-                node.set_timestamps(substanzas)
-
-            self.iterables.append(node)
-            return node
-        return None
-
-    def del_node(self, nodeId):
-        """
-        Remove a single node.
-
-        Arguments:
-            nodeId  -- Node ID of the item to remove.
-        """
-        if nodeId in self._nodes:
-            nodes = [i for i in self.iterables if isinstance(i, FieldsNode)]
-            for node in nodes:
-                if node['nodeId'] == nodeId:
-                    self.xml.remove(node.xml)
-                    self.iterables.remove(node)
-                    return True
-        return False
-
-    def get_nodes(self):
-        """Return all nodes."""
-        nodes = []
-        for node in self['substanzas']:
-            if isinstance(node, FieldsNode):
-                nodes.append(node)
-        return nodes
-
-    def set_nodes(self, nodes):
-        """
-        Set or replace all nodes. The given nodes must be in a
-        list or set where each item is a tuple of the form:
-            (nodeId, sourceId, cacheType)
-
-        Arguments:
-            nodes -- A series of nodes in tuple format.
-        """
-        #print(str(id(self)) + " set_nodes: got " + str(nodes))
-        self.del_nodes()
-        for node in nodes:
-            if isinstance(node, FieldsNode):
-                self.add_node(node['nodeId'], node['sourceId'], node['cacheType'], substanzas=node['substanzas'])
-            else:
-                nodeId, sourceId, cacheType = node
-                self.add_node(nodeId, sourceId, cacheType)
-
-    def del_nodes(self):
-        """Remove all nodes."""
-        self._nodes = set()
-        nodes = [i for i in self.iterables if isinstance(i, FieldsNode)]
-        for node in nodes:
-            self.xml.remove(node.xml)
-            self.iterables.remove(node)
-
-
-class FieldsNode(ElementBase):
-    """ Node element in response fields """
-    namespace = 'urn:xmpp:iot:sensordata'
-    name = 'node'
-    plugin_attrib = name
-    interfaces = set(['nodeId','sourceId','cacheType','timestamps'])
-
-    def __init__(self, xml=None, parent=None):
-        ElementBase.__init__(self, xml, parent);
-        self._timestamps = set()
-
-    def setup(self, xml=None):
-        """
-        Populate the stanza object using an optional XML object.
-
-        Overrides ElementBase.setup
-
-        Caches item information.
-
-        Arguments:
-            xml -- Use an existing XML object for the stanza's values.
-        """
-        ElementBase.setup(self, xml)
-        self._timestamps = set([ts['value'] for ts in self['timestamps']])
-
-    def add_timestamp(self, timestamp, substanzas=None):
-        """
-        Add a new timestamp element. 
-
-        Arguments:
-            timestamp  -- The timestamp in ISO format.
-        """
-        #print(str(id(self)) + " add_timestamp: " + str(timestamp))
-
-        if timestamp not in self._timestamps:
-            self._timestamps.add((timestamp))
-            ts = Timestamp(parent=self)
-            ts['value'] = timestamp
-            if not substanzas is None:
-                ts.set_datas(substanzas);
-                #print("add_timestamp with substanzas: " + str(substanzas))
-            self.iterables.append(ts)
-            #print(str(id(self)) + " added_timestamp: " + str(id(ts)))
-            return ts
-        return None
-
-    def del_timestamp(self, timestamp):
-        """
-        Remove a single timestamp.
-
-        Arguments:
-            timestamp  -- timestamp (in ISO format) of the item to remove.
-        """
-        #print("del_timestamp: ")
-        if timestamp in self._timestamps:
-            timestamps = [i for i in self.iterables if isinstance(i, Timestamp)]
-            for ts in timestamps:
-                if ts['value'] == timestamp:
-                    self.xml.remove(ts.xml)
-                    self.iterables.remove(ts)
-                    return True
-        return False
-
-    def get_timestamps(self):
-        """Return all timestamps."""
-        #print(str(id(self)) + " get_timestamps: ")
-        timestamps = []
-        for timestamp in self['substanzas']:
-            if isinstance(timestamp, Timestamp):
-                timestamps.append(timestamp)
-        return timestamps
-
-    def set_timestamps(self, timestamps):
-        """
-        Set or replace all timestamps. The given timestamps must be in a
-        list or set where each item is a timestamp
-
-        Arguments:
-            timestamps -- A series of timestamps.
-        """
-        #print(str(id(self)) + " set_timestamps: got " + str(timestamps))
-        self.del_timestamps()
-        for timestamp in timestamps:
-            #print("set_timestamps: subset " + str(timestamp))
-            #print("set_timestamps: subset.substanzas " + str(timestamp['substanzas']))
-            if isinstance(timestamp, Timestamp):
-                self.add_timestamp(timestamp['value'], substanzas=timestamp['substanzas'])
-            else:
-                #print("set_timestamps: got " + str(timestamp))
-                self.add_timestamp(timestamp)
-
-    def del_timestamps(self):
-        """Remove all timestamps."""
-        #print(str(id(self)) + " del_timestamps: ")
-        self._timestamps = set()
-        timestamps = [i for i in self.iterables if isinstance(i, Timestamp)]
-        for timestamp in timestamps:
-            self.xml.remove(timestamp.xml)
-            self.iterables.remove(timestamp)
-
-class Field(ElementBase):
-    """ 
-    Field element in response Timestamp. This is a base class,
-    all instances of fields added to Timestamp must be of types:
-        DataNumeric
-        DataString
-        DataBoolean
-        DataDateTime
-        DataTimeSpan
-        DataEnum
-    """    
-    namespace = 'urn:xmpp:iot:sensordata'
-    name = 'field'
-    plugin_attrib = name
-    interfaces = set(['name','module','stringIds']);
-    interfaces.update(FieldTypes.field_types);
-    interfaces.update(FieldStatus.field_status);
-
-    _flags = set();
-    _flags.update(FieldTypes.field_types);
-    _flags.update(FieldStatus.field_status);
-
-    def set_stringIds(self, value):
-        """Verifies stringIds according to regexp from specification XMPP-0323.
-
-        :param value: string
-        """
-
-        pattern = re.compile("^\d+([|]\w+([.]\w+)*([|][^,]*)?)?(,\d+([|]\w+([.]\w+)*([|][^,]*)?)?)*$")
-        if pattern.match(value) is not None:
-            self.xml.stringIds = value;
-        else:
-            # Bad content, add nothing
-            pass
-
-        return self
-
-    def _get_flags(self):
-        """
-        Helper function for getting of flags. Returns all flags in 
-        dictionary format: { "flag name": "flag value" ... } 
-        """
-        flags = {};
-        for f in self._flags:
-            if not self[f] == "":
-                flags[f] = self[f];
-        return flags;
-
-    def _set_flags(self, flags):
-        """
-        Helper function for setting of flags. 
-
-        Arguments:
-            flags -- Flags in dictionary format: { "flag name": "flag value" ... } 
-        """
-        for f in self._flags:
-            if flags is not None and f in flags:
-                self[f] = flags[f];
-            else:
-                self[f] = None;
-
-    def _get_typename(self):
-        return "invalid type, use subclasses!";
-
-
-class Timestamp(ElementBase):
-    """ Timestamp element in response Node """
-    namespace = 'urn:xmpp:iot:sensordata'
-    name = 'timestamp'
-    plugin_attrib = name
-    interfaces = set(['value','datas'])
-
-    def __init__(self, xml=None, parent=None):
-        ElementBase.__init__(self, xml, parent);
-        self._datas = set()
-
-    def setup(self, xml=None):
-        """
-        Populate the stanza object using an optional XML object.
-
-        Overrides ElementBase.setup
-
-        Caches item information.
-
-        Arguments:
-            xml -- Use an existing XML object for the stanza's values.
-        """
-        ElementBase.setup(self, xml)
-        self._datas = set([data['name'] for data in self['datas']])
-
-    def add_data(self, typename, name, value, module=None, stringIds=None, unit=None, dataType=None, flags=None):
-        """
-        Add a new data element. 
-
-        Arguments:
-            typename   -- The type of data element (numeric, string, boolean, dateTime, timeSpan or enum)
-            value      -- The value of the data element
-            module     -- [optional] language module to use for the data element
-            stringIds  -- [optional] The stringIds used to find associated text in the language module
-            unit       -- [optional] The unit. Only applicable for type numeric
-            dataType   -- [optional] The dataType. Only applicable for type enum
-        """
-        if name not in self._datas:
-            dataObj = None;
-            if typename == "numeric":
-                dataObj = DataNumeric(parent=self);
-                dataObj['unit'] = unit;
-            elif typename == "string":
-                dataObj = DataString(parent=self);
-            elif typename == "boolean":
-                dataObj = DataBoolean(parent=self);
-            elif typename == "dateTime":
-                dataObj = DataDateTime(parent=self);
-            elif typename == "timeSpan":
-                dataObj = DataTimeSpan(parent=self);
-            elif typename == "enum":
-                dataObj = DataEnum(parent=self);
-                dataObj['dataType'] = dataType;
-
-            dataObj['name'] = name;
-            dataObj['value'] = value;
-            dataObj['module'] = module;
-            dataObj['stringIds'] = stringIds;
-
-            if flags is not None:
-                dataObj._set_flags(flags);
-
-            self._datas.add(name)
-            self.iterables.append(dataObj)
-            return dataObj
-        return None
-
-    def del_data(self, name):
-        """
-        Remove a single data element.
-
-        Arguments:
-            data_name  -- The data element name to remove.
-        """
-        if name in self._datas:
-            datas = [i for i in self.iterables if isinstance(i, Field)]
-            for data in datas:
-                if data['name'] == name:
-                    self.xml.remove(data.xml)
-                    self.iterables.remove(data)
-                    return True
-        return False
-
-    def get_datas(self):
-        """ Return all data elements. """
-        datas = []
-        for data in self['substanzas']:
-            if isinstance(data, Field):
-                datas.append(data)
-        return datas
-
-    def set_datas(self, datas):
-        """
-        Set or replace all data elements. The given elements must be in a
-        list or set where each item is a data element (numeric, string, boolean, dateTime, timeSpan or enum)
-
-        Arguments:
-            datas -- A series of data elements.
-        """
-        self.del_datas()
-        for data in datas:
-            self.add_data(typename=data._get_typename(), name=data['name'], value=data['value'], module=data['module'], stringIds=data['stringIds'], unit=data['unit'], dataType=data['dataType'], flags=data._get_flags())
-
-    def del_datas(self):
-        """Remove all data elements."""
-        self._datas = set()
-        datas = [i for i in self.iterables if isinstance(i, Field)]
-        for data in datas:
-            self.xml.remove(data.xml)
-            self.iterables.remove(data)
-
-class DataNumeric(Field):
-    """ 
-    Field data of type numeric. 
-    Note that the value is expressed as a string. 
-    """
-    namespace = 'urn:xmpp:iot:sensordata'
-    name = 'numeric'
-    plugin_attrib = name
-    interfaces = set(['value', 'unit']);
-    interfaces.update(Field.interfaces);
-
-    def _get_typename(self):
-        return "numeric"    
-
-class DataString(Field):
-    """ 
-    Field data of type string 
-    """
-    namespace = 'urn:xmpp:iot:sensordata'
-    name = 'string'
-    plugin_attrib = name
-    interfaces = set(['value']);
-    interfaces.update(Field.interfaces);
-
-    def _get_typename(self):
-        return "string"    
-
-class DataBoolean(Field):
-    """ 
-    Field data of type boolean.
-    Note that the value is expressed as a string. 
-    """
-    namespace = 'urn:xmpp:iot:sensordata'
-    name = 'boolean'
-    plugin_attrib = name
-    interfaces = set(['value']);
-    interfaces.update(Field.interfaces);
-
-    def _get_typename(self):
-        return "boolean"    
-
-class DataDateTime(Field):
-    """ 
-    Field data of type dateTime.
-    Note that the value is expressed as a string. 
-    """
-    namespace = 'urn:xmpp:iot:sensordata'
-    name = 'dateTime'
-    plugin_attrib = name
-    interfaces = set(['value']);
-    interfaces.update(Field.interfaces);
-
-    def _get_typename(self):
-        return "dateTime"    
-
-class DataTimeSpan(Field):
-    """ 
-    Field data of type timeSpan.
-    Note that the value is expressed as a string. 
-    """
-    namespace = 'urn:xmpp:iot:sensordata'
-    name = 'timeSpan'
-    plugin_attrib = name
-    interfaces = set(['value']);
-    interfaces.update(Field.interfaces);
-
-    def _get_typename(self):
-        return "timeSpan"    
-
-class DataEnum(Field):
-    """ 
-    Field data of type enum.
-    Note that the value is expressed as a string. 
-    """
-    namespace = 'urn:xmpp:iot:sensordata'
-    name = 'enum'
-    plugin_attrib = name
-    interfaces = set(['value', 'dataType']);
-    interfaces.update(Field.interfaces);
-
-    def _get_typename(self):
-        return "enum"    
-
-class Done(ElementBase):
-    """ Done element used to signal that all data has been transferred """
-    namespace = 'urn:xmpp:iot:sensordata'
-    name = 'done'
-    plugin_attrib = name
-    interfaces = set(['seqnr'])
-
-class Cancel(ElementBase):
-    """ Cancel element used to signal that a request shall be cancelled """
-    namespace = 'urn:xmpp:iot:sensordata'
-    name = 'cancel'
-    plugin_attrib = name
-    interfaces = set(['seqnr'])
-
-class Cancelled(ElementBase):
-    """ Cancelled element used to signal that cancellation is confirmed """
-    namespace = 'urn:xmpp:iot:sensordata'
-    name = 'cancelled'
-    plugin_attrib = name
-    interfaces = set(['seqnr'])
-
-
-register_stanza_plugin(Iq, Request)
-register_stanza_plugin(Request, RequestNode, iterable=True)
-register_stanza_plugin(Request, RequestField, iterable=True)
-
-register_stanza_plugin(Iq, Accepted)
-register_stanza_plugin(Message, Failure)
-register_stanza_plugin(Failure, Error)
-
-register_stanza_plugin(Iq, Rejected)
-
-register_stanza_plugin(Message, Fields)
-register_stanza_plugin(Fields, FieldsNode, iterable=True)
-register_stanza_plugin(FieldsNode, Timestamp, iterable=True)
-register_stanza_plugin(Timestamp, Field, iterable=True)
-register_stanza_plugin(Timestamp, DataNumeric, iterable=True)
-register_stanza_plugin(Timestamp, DataString, iterable=True)
-register_stanza_plugin(Timestamp, DataBoolean, iterable=True)
-register_stanza_plugin(Timestamp, DataDateTime, iterable=True)
-register_stanza_plugin(Timestamp, DataTimeSpan, iterable=True)
-register_stanza_plugin(Timestamp, DataEnum, iterable=True)
-
-register_stanza_plugin(Message, Started)
-
-register_stanza_plugin(Iq, Cancel)
-register_stanza_plugin(Iq, Cancelled)
diff --git a/sleekxmpp/plugins/xep_0323/timerreset.py b/sleekxmpp/plugins/xep_0323/timerreset.py
deleted file mode 100644
index 578f1efe..00000000
--- a/sleekxmpp/plugins/xep_0323/timerreset.py
+++ /dev/null
@@ -1,64 +0,0 @@
-"""
-    SleekXMPP: The Sleek XMPP Library
-    Implementation of xeps for Internet of Things
-    http://wiki.xmpp.org/web/Tech_pages/IoT_systems
-    Copyright (C) 2013 Sustainable Innovation, Joachim.lindborg@sust.se, bjorn.westrom@consoden.se
-    This file is part of SleekXMPP.
-
-    See the file LICENSE for copying permission.
-"""
-from threading import Thread, Event, Timer
-import time
-
-def TimerReset(*args, **kwargs):
-    """ Global function for Timer """
-    return _TimerReset(*args, **kwargs)
-
-
-class _TimerReset(Thread):
-    """Call a function after a specified number of seconds:
-
-    t = TimerReset(30.0, f, args=[], kwargs={})
-    t.start()
-    t.cancel() # stop the timer's action if it's still waiting
-    """
-
-    def __init__(self, interval, function, args=[], kwargs={}):
-        Thread.__init__(self)
-        self.interval = interval
-        self.function = function
-        self.args = args
-        self.kwargs = kwargs
-        self.finished = Event()
-        self.resetted = True
-
-    def cancel(self):
-        """Stop the timer if it hasn't finished yet"""
-        self.finished.set()
-
-    def run(self):
-        #print "Time: %s - timer running..." % time.asctime()
-
-        while self.resetted:
-            #print "Time: %s - timer waiting for timeout in %.2f..." % (time.asctime(), self.interval)
-            self.resetted = False
-            self.finished.wait(self.interval)
-
-        if not self.finished.isSet():
-            self.function(*self.args, **self.kwargs)
-        self.finished.set()
-        #print "Time: %s - timer finished!" % time.asctime()
-
-    def reset(self, interval=None):
-        """ Reset the timer """
-
-        if interval:
-            #print "Time: %s - timer resetting to %.2f..." % (time.asctime(), interval)
-            self.interval = interval
-        else:
-            #print "Time: %s - timer resetting..." % time.asctime()
-            pass
-
-        self.resetted = True
-        self.finished.set()
-        self.finished.clear()