Lots of updates including error checking and ability to set values.

Author: Paul Jennings

TStat.py

@@ -47,6 +47,7 @@
 
 import datetime
 import httplib
+import urllib
 import json
 import logging
 
@@ -86,13 +87,63 @@ def _getConn(self):
 		"""Used internally to get a connection to the tstat."""
 		return httplib.HTTPConnection(self.address)
 
-	def _post(self, location, params):
+	def _post(self, key, value):
 		"""Used internally to modify tstat settings (e.g. cloud mode)."""
-		params = urllib.urlencode(params)
-		headers = {"Content-type": "application/x-www-form-urlencoded", "Accept": "text/plain"}
-		conn = self._getConn()
-		conn.request("POST", location, params, headers)
-		return conn.getresponse()
+
+		l = self.logger
+
+		# Check for valid request
+		if not self.api.has_key(key):
+			l.error("%s does not exist in API" % key)
+			return False
+
+		# Retrieve the mapping from api key to thermostat URL
+		entry = self.api[key]
+		l.debug("Got API entry: %s" % entry)
+
+		try:
+			if len(entry.setters) < 1:
+				raise TypeError
+		except TypeError:
+			l.error("%s cannot be set (maybe readonly?)" % key)
+			return False
+
+		# Check for valid values
+		if entry.valueMap is not None:
+			inverse = dict((v,k) for k, v in entry.valueMap.iteritems())
+			if not inverse.has_key(value) and not entry.valueMap.has_key(value):
+				l.warning("Value '%s' may not be a valid value for '%s'" % (value, key))
+			elif inverse.has_key(value):
+				value = inverse[value]
+
+		for setter in entry.setters:
+			location = setter[0]
+			jsonKey = setter[1]
+			if entry.usesJson:
+				params = json.dumps({jsonKey: value})
+			else:
+				params = urllib.urlencode({jsonKey: value})
+
+			headers = {"Content-type": "application/x-www-form-urlencoded", "Accept": "text/plain"}
+			conn = self._getConn()
+			conn.request("POST", location, params, headers)
+			response = conn.getresponse()
+			if response.status != 200:
+				l.error("Error %s while trying to set '%s' with '%s'" % (response.status, location, params))
+				continue
+			data = response.read()
+			response.close()
+
+			success = False
+			for s in self.api.successStrings:
+				if data.startswith(s):
+					success = True
+					break
+
+			if not success:
+				l.error("Error trying to set '%s' with '%s': %s" % (location, params, data))
+			l.debug("Response: %s" % data)
+			return True
 
 	def _get(self, key, raw=False):
 		"""Used internally to retrieve data from the tstat and process it with JSON if necessary."""
@@ -136,14 +187,29 @@ def _get(self, key, raw=False):
 			l.debug("Using cached entry")
 			response = self.cache[newest[0]].data[newest[1]]
 		else:
-			# Either data was not cached or cache was expired
-			getter = entry.getters[0]
-			# TODO: Change back to access actual tstat
-			conn = self._getConn()
-			conn.request("GET", getter[0])
-			#TODO: Error checking
-			response = json.loads(conn.getresponse().read())
-			l.debug("Got response: %s" % response)
+			for getter in entry.getters:
+				# Either data was not cached or cache was expired
+				conn = self._getConn()
+				conn.request("GET", getter[0])
+				response = conn.getresponse()
+				if response.status != 200:
+					l.warning("Request for '%s' failed (error %s)" % (getter[0], response.status))
+					response = None
+					continue
+				data = response.read()
+				response.close()
+				l.debug("Got response: %s" % data)
+				try:
+					response = json.loads(data)
+					break
+				except:
+					l.warning("Some problem with response: %s" % data)
+					response = None
+					continue
+
+			if response is None:
+				l.error("Unable to retrieve '%s' from any of %s" % (key, entry.getters))
+				return
 			self.cache[getter[0]] = CacheEntry(getter[0], response)
 
 		# Allow mappings to subdictionaries in json data
@@ -177,26 +243,54 @@ def getTstatMode(self, raw=False):
 		"""Returns current thermostat mode."""
 		return self._get('tmode', raw)
 
+	def setTstatMode(self, value):
+		"""Sets thermostat mode."""
+		return self._post('tmode', value)
+
 	def getFanMode(self, raw=False):
 		"""Returns current fan mode."""
 		return self._get('fmode', raw)
 
+	def setFanMode(self, value):
+		"""Sets fan mode."""
+		return self._post('fmode', value)
+
 	def getOverride(self, raw=False):
-		"""Returns current override setting?"""
+		"""Returns current override setting"""
 		return self._get('override', raw)
 
+	def getPower(self, raw=False):
+		"""Returns power?"""
+		return self._get('power', raw)
+
+	def setPower(self, value):
+		"""Sets power?"""
+		return self._post('power', value)
+
 	def getHoldState(self, raw=False):
 		"""Returns current hold state."""
 		return self._get('hold', raw)
 
+	def setHoldState(self, value):
+		"""Sets hold state."""
+		return self._post('hold', value)
+
 	def getHeatPoint(self, raw=False):
 		"""Returns current set point for heat."""
 		return self._get('t_heat', raw)
 
+	def setHeatPoint(self, value):
+		"""Sets point for heat."""
+		return self._post('t_heat', value)
+
 	def getCoolPoint(self, raw=False):
 		"""Returns current set point for cooling."""
 		return self._get('t_cool', raw)
 
+	def setCoolPoint(self, value):
+		"""Sets point for cooling."""
+		return self._post('t_cool', value)
+
 	def getSetPoints(self, raw=False):
 		"""Returns both heating and cooling set points."""
 		return (self.getHeatPoint(), self.getCoolPoint())
@@ -236,22 +330,19 @@ def getCoolUsageYesterday(self, raw=False):
 
 	def isOK(self):
 		"""Returns true if thermostat reports that it is OK."""
-		pass
+		return self._get('errstatus') == 'OK'
 
 	def getErrStatus(self):
 		"""Returns current error code or 0 if everything is OK."""
-		pass
+		return self._get('errstatus')
 
 	def getEventLog(self):
 		"""Returns events?"""
 		pass
 
-	def setCloudMode(self, state=True):
+	def setCloudMode(self, value):
 		"""Sets cloud mode to state."""
-		command = "on"
-		if not state:
-			command = "off"
-		return self._post("/cloud/mode", {'command': command})
+		return self._post("cloud_mode", value)
 
 def main():
 	import sys