Get the IoT plugins to pass tests on Py3sleek-1.2.01.2.0

5 files changed, 284 insertions, 284 deletions

diff --git a/sleekxmpp/plugins/xep_0323/device.py b/sleekxmpp/plugins/xep_0323/device.py
index 23bdd153..0bc20327 100644
--- a/sleekxmpp/plugins/xep_0323/device.py
+++ b/sleekxmpp/plugins/xep_0323/device.py
@@ -12,51 +12,51 @@ import datetime
 import logging
 
 class Device(object):
-	"""
-	Example implementation of a device readout 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.
+    """
+
+    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.
+            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:
@@ -65,153 +65,153 @@ class Device(object):
                         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:
+        
+                    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:
+                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" 
+                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
+                  { 
+                    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_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
+        """
+        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");
+        """
+        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
+    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};
+        """
+        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
+    def _add_field_timestamp_data(self, name, timestamp, value, flags=None):
+        """
+        Adds timestamped data to a field
 
         Arguments:
             name      -- Name of the field
@@ -219,37 +219,37 @@ class Device(object):
             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] = {};
+        """
+        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;
+        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
+    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 not self.fields.has_key(name):
-			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;
+        """
+        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/stanza/sensordata.py b/sleekxmpp/plugins/xep_0323/stanza/sensordata.py
index 55e5060f..a11c3e94 100644
--- a/sleekxmpp/plugins/xep_0323/stanza/sensordata.py
+++ b/sleekxmpp/plugins/xep_0323/stanza/sensordata.py
@@ -124,10 +124,10 @@ class Request(ElementBase):
 
     def get_nodes(self):
         """Return all nodes."""
-        nodes = set()
+        nodes = []
         for node in self['substanzas']:
             if isinstance(node, RequestNode):
-                nodes.add(node)
+                nodes.append(node)
         return nodes
 
     def set_nodes(self, nodes):
@@ -190,10 +190,10 @@ class Request(ElementBase):
 
     def get_fields(self):
         """Return all fields."""
-        fields = set()
+        fields = []
         for field in self['substanzas']:
             if isinstance(field, RequestField):
-                fields.add(field)
+                fields.append(field)
         return fields
 
     def set_fields(self, fields):
@@ -351,10 +351,10 @@ class Fields(ElementBase):
 
     def get_nodes(self):
         """Return all nodes."""
-        nodes = set()
+        nodes = []
         for node in self['substanzas']:
             if isinstance(node, FieldsNode):
-                nodes.add(node)
+                nodes.append(node)
         return nodes
 
     def set_nodes(self, nodes):
@@ -450,10 +450,10 @@ class FieldsNode(ElementBase):
     def get_timestamps(self):
         """Return all timestamps."""
         #print(str(id(self)) + " get_timestamps: ")
-        timestamps = set()
+        timestamps = []
         for timestamp in self['substanzas']:
             if isinstance(timestamp, Timestamp):
-                timestamps.add(timestamp)
+                timestamps.append(timestamp)
         return timestamps
 
     def set_timestamps(self, timestamps):
@@ -634,10 +634,10 @@ class Timestamp(ElementBase):
 
     def get_datas(self):
         """ Return all data elements. """
-        datas = set()
+        datas = []
         for data in self['substanzas']:
             if isinstance(data, Field):
-                datas.add(data)
+                datas.append(data)
         return datas
 
     def set_datas(self, datas):
diff --git a/sleekxmpp/plugins/xep_0325/device.py b/sleekxmpp/plugins/xep_0325/device.py
index 1cb99510..a60d5f9a 100644
--- a/sleekxmpp/plugins/xep_0325/device.py
+++ b/sleekxmpp/plugins/xep_0325/device.py
@@ -11,36 +11,36 @@
 import datetime
 
 class Device(object):
-	"""
-	Example implementation of a device control object.
+    """
+    Example implementation of a device control object.
     
     The device object may by any custom implementation to support 
     specific devices, but it must implement the functions:
           has_control_field
           set_control_fields
-	"""
+    """
 
-	def __init__(self, nodeId):
-		self.nodeId = nodeId;
-		self.control_fields = {};
+    def __init__(self, nodeId):
+        self.nodeId = nodeId;
+        self.control_fields = {};
 
-	def has_control_field(self, field, typename):
-		"""
-		Returns true if the supplied field name exists
-		and the type matches for control in this device.
+    def has_control_field(self, field, typename):
+        """
+        Returns true if the supplied field name exists
+        and the type matches for control in this device.
 
         Arguments:
-            field      -- The field name		
+            field      -- The field name        
             typename   -- The expected type
-		"""
-		if field in self.control_fields and self.control_fields[field]["type"] == typename:
-			return True;
-		return False;
+        """
+        if field in self.control_fields and self.control_fields[field]["type"] == typename:
+            return True;
+        return False;
 
-	def set_control_fields(self, fields, session, callback):
-		"""
-		Starts a control setting procedure. Verifies the fields,
-		sets the data and (if needed) and calls the callback.
+    def set_control_fields(self, fields, session, callback):
+        """
+        Starts a control setting procedure. Verifies the fields,
+        sets the data and (if needed) and calls the callback.
 
         Arguments:
             fields   -- List of control fields in tuple format: 
@@ -48,50 +48,50 @@ class Device(object):
             session  -- Session id, only used in the callback as identifier
             callback -- Callback function to call when control set is complete.
 
-					The callback function must support the following arguments:
+                    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:
+                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"  - Set fields failed.
                                "ok"     - All fields were set.
-	            error_field -- [optional] Only applies when result == "error" 
-    	                       The field name that failed 
-    	                       (usually means it is missing)
-        	    error_msg   -- [optional] Only applies when result == "error".
-            	               Error details when a request failed.
-		"""
-
-		if len(fields) > 0:
-			# Check availiability
-			for name, typename, value in fields:
-				if not self.has_control_field(name, typename):
-					self._send_control_reject(session, name, "NotFound", callback)
-					return False;
-
-		for name, typename, value in fields:
-			self._set_field_value(name, value)
-
-		callback(session, result="ok", nodeId=self.nodeId);
-		return True
-
-	def _send_control_reject(self, session, field, message, callback):
-		"""
-		Sends a reject to the caller
+                error_field -- [optional] Only applies when result == "error" 
+                               The field name that failed 
+                               (usually means it is missing)
+                error_msg   -- [optional] Only applies when result == "error".
+                               Error details when a request failed.
+        """
+
+        if len(fields) > 0:
+            # Check availiability
+            for name, typename, value in fields:
+                if not self.has_control_field(name, typename):
+                    self._send_control_reject(session, name, "NotFound", callback)
+                    return False;
+
+        for name, typename, value in fields:
+            self._set_field_value(name, value)
+
+        callback(session, result="ok", nodeId=self.nodeId);
+        return True
+
+    def _send_control_reject(self, session, field, message, callback):
+        """
+        Sends a reject to the caller
 
         Arguments:
             session  -- Session id, see definition in 
                         set_control_fields function
             callback -- Callback function, see definition in 
                         set_control_fields function
-		"""
-		callback(session, result="error", nodeId=self.nodeId, error_field=field, error_msg=message);
+        """
+        callback(session, result="error", nodeId=self.nodeId, error_field=field, error_msg=message);
 
-	def _add_control_field(self, name, typename, value):
-		"""
-		Adds a control field to the device
+    def _add_control_field(self, name, typename, value):
+        """
+        Adds a control field to the device
 
         Arguments:
             name     -- Name of the field
@@ -99,27 +99,27 @@ class Device(object):
                         (boolean, color, string, date, dateTime, 
                          double, duration, int, long, time)
             value    -- Field value
-		"""
-		self.control_fields[name] = {"type": typename, "value": value};
+        """
+        self.control_fields[name] = {"type": typename, "value": value};
 
-	def _set_field_value(self, name, value):
-		"""
-		Set the value of a control field
+    def _set_field_value(self, name, value):
+        """
+        Set the value of a control field
 
         Arguments:
             name     -- Name of the field
             value    -- New value for the field
-		"""
-		if name in self.control_fields:
-			self.control_fields[name]["value"] = value;
+        """
+        if name in self.control_fields:
+            self.control_fields[name]["value"] = value;
 
-	def _get_field_value(self, name):
-		"""
-		Get the value of a control field. Only used for unit testing.
+    def _get_field_value(self, name):
+        """
+        Get the value of a control field. Only used for unit testing.
 
         Arguments:
             name     -- Name of the field
-		"""
-		if name in self.control_fields:
-			return self.control_fields[name]["value"];
-		return None;
+        """
+        if name in self.control_fields:
+            return self.control_fields[name]["value"];
+        return None;
diff --git a/sleekxmpp/plugins/xep_0325/stanza/control.py b/sleekxmpp/plugins/xep_0325/stanza/control.py
index 2707191f..67107ecb 100644
--- a/sleekxmpp/plugins/xep_0325/stanza/control.py
+++ b/sleekxmpp/plugins/xep_0325/stanza/control.py
@@ -83,10 +83,10 @@ class ControlSet(ElementBase):
 
     def get_nodes(self):
         """Return all nodes."""
-        nodes = set()
+        nodes = []
         for node in self['substanzas']:
             if isinstance(node, RequestNode):
-                nodes.add(node)
+                nodes.append(node)
         return nodes
 
     def set_nodes(self, nodes):
@@ -175,10 +175,10 @@ class ControlSet(ElementBase):
 
     def get_datas(self):
         """ Return all data elements. """
-        datas = set()
+        datas = []
         for data in self['substanzas']:
             if isinstance(data, BaseParameter):
-                datas.add(data)
+                datas.append(data)
         return datas
 
     def set_datas(self, datas):
@@ -274,10 +274,10 @@ class ControlSetResponse(ElementBase):
 
     def get_nodes(self):
         """Return all nodes."""
-        nodes = set()
+        nodes = []
         for node in self['substanzas']:
             if isinstance(node, RequestNode):
-                nodes.add(node)
+                nodes.append(node)
         return nodes
 
     def set_nodes(self, nodes):
diff --git a/tests/test_stream_xep_0323.py b/tests/test_stream_xep_0323.py
index b10f0b0d..fd2ad225 100644
--- a/tests/test_stream_xep_0323.py
+++ b/tests/test_stream_xep_0323.py
@@ -572,16 +572,16 @@ class TestStreamSensorData(SleekTest):
 
         self.failUnlessEqual(results, ["accepted","fields","done"]);
         # self.assertIn("nodeId", callback_data);
-        self.assertTrue(callback_data.has_key("nodeId"));
+        self.assertTrue("nodeId" in callback_data)
         self.failUnlessEqual(callback_data["nodeId"], "Device33");
         # self.assertIn("timestamp", callback_data);
-        self.assertTrue(callback_data.has_key("timestamp"));
+        self.assertTrue("timestamp" in callback_data);
         self.failUnlessEqual(callback_data["timestamp"], "2000-01-01T00:01:02");
         #self.assertIn("field_Voltage", callback_data);
-        self.assertTrue(callback_data.has_key("field_Voltage"));
+        self.assertTrue("field_Voltage" in callback_data);
         self.failUnlessEqual(callback_data["field_Voltage"], {"name": "Voltage", "value": "230.4", "typename": "numeric", "unit": "V", "flags": {"invoiced": "true"}});
         #self.assertIn("field_TestBool", callback_data);
-        self.assertTrue(callback_data.has_key("field_TestBool"));
+        self.assertTrue("field_TestBool" in callback_data);
         self.failUnlessEqual(callback_data["field_TestBool"], {"name": "TestBool", "value": "true", "typename": "boolean" });
 
     def testServiceDiscoveryClient(self):
@@ -693,13 +693,13 @@ class TestStreamSensorData(SleekTest):
 
         self.failUnlessEqual(results, ["accepted","failure"]);
         # self.assertIn("nodeId", callback_data);
-        self.assertTrue(callback_data.has_key("nodeId"));
+        self.assertTrue("nodeId" in callback_data);
         self.failUnlessEqual(callback_data["nodeId"], "Device33");
         # self.assertIn("timestamp", callback_data);
-        self.assertTrue(callback_data.has_key("timestamp"));
+        self.assertTrue("timestamp" in callback_data);
         self.failUnlessEqual(callback_data["timestamp"], "2013-03-07T17:13:30");
         # self.assertIn("error_msg", callback_data);
-        self.assertTrue(callback_data.has_key("error_msg"));
+        self.assertTrue("error_msg" in callback_data);
         self.failUnlessEqual(callback_data["error_msg"], "Timeout.");
 
     def testDelayedRequest(self):
@@ -1095,16 +1095,16 @@ class TestStreamSensorData(SleekTest):
 
         self.failUnlessEqual(results, ["queued","started","fields","done"]);
         # self.assertIn("nodeId", callback_data);
-        self.assertTrue(callback_data.has_key("nodeId"));
+        self.assertTrue("nodeId" in callback_data);
         self.failUnlessEqual(callback_data["nodeId"], "Device33");
         # self.assertIn("timestamp", callback_data);
-        self.assertTrue(callback_data.has_key("timestamp"));
+        self.assertTrue("timestamp" in callback_data);
         self.failUnlessEqual(callback_data["timestamp"], "2000-01-01T00:01:02");
         # self.assertIn("field_Voltage", callback_data);
-        self.assertTrue(callback_data.has_key("field_Voltage"));
+        self.assertTrue("field_Voltage" in callback_data);
         self.failUnlessEqual(callback_data["field_Voltage"], {"name": "Voltage", "value": "230.4", "typename": "numeric", "unit": "V", "flags": {"invoiced": "true"}});
         # self.assertIn("field_TestBool", callback_data);
-        self.assertTrue(callback_data.has_key("field_TestBool"));
+        self.assertTrue("field_TestBool" in callback_data);
         self.failUnlessEqual(callback_data["field_TestBool"], {"name": "TestBool", "value": "true", "typename": "boolean" });