Use properties

README.md

@@ -14,43 +14,37 @@ pip install pyopensprinkler
 from pyopensprinkler import OpenSprinkler
 
 os = OpenSprinkler("hostname:port", "md5password")
-version = os.device.getFirmwareVersion()
+version = os.device.firmware_version()
 ```
 
 ## Commands
 
-`os.getPrograms()`
+`os.programs`
 
-`os.getProgram(index)`
-Index starts from 0
-
-`os.getStations()`
-
-`os.getStation(index)`
-Index starts from 0
+`os.stations`
 
 ### Device
 
-`os.device.getFirmwareVersion()`
+`os.device.firmware_version`
 
-`os.device.getHardwareVersion()`
+`os.device.hardware_version`
 
-`os.device.getLastRun()`
+`os.device.last run`
 
-`os.device.getRainDelay()`
+`os.device.get_rain_delay`
 
-`os.device.getRainDelayStopTime()`
+`os.device.rain_delay_stop_time`
 
-`os.device.getRainSensor1()`
+`os.device.rain_sensor_1`
 
-`os.device.getRainSensor2()`
+`os.device.rain_sensor_2`
 
-`os.device.getRainSensorLegacy()`
+`os.device.rain_sensor_legacy`
 Rain sensor for firmware version <= 2.1.7
 
-`os.device.getOperationEnabled()`
+`os.device.operation_enabled`
 
-`os.device.getWaterLevel()`
+`os.device.water_level`
 
 `os.device.enable()`
 
@@ -59,14 +53,13 @@ Rain sensor for firmware version <= 2.1.7
 ### Programs
 
 ```python
-programs = os.getPrograms()
-isEnabled = program[0].getEnabled()
+is_enabled = os.programs[0].enabled
 
-program = os.getProgram(0)
+program = os.programs[0]
 program.run()
 ```
 
-`program.getEnabled()`
+`program.enabled`
 
 `program.enable()`
 
@@ -77,18 +70,16 @@ program.run()
 ### Stations
 
 ```python
-stations = os.getStations()
-isEnabled = stations[0].getStatus()
-
-station = os.getStation(0)
+isEnabled = os.stations[0].status
+station = os.station[0]
 station.run(120)
 ```
 
-`station.getIsRunning()`
+`station.is_running`
 
-`station.getRunningProgramId()`
+`station.running_program_id`
 
-`station.getStatus()`
+`station.status`
 
 `station.run(seconds)`
  Acceptable range for seconds is 0 to 64800 (18 hours)

pyopensprinkler/__init__.py

@@ -1,10 +1,11 @@
 """Main OpenSprinkler module."""
 
-import httplib2
 import json
 import urllib
 
+import httplib2
 from cachetools import cached, TTLCache
+
 from pyopensprinkler.device import Device
 from pyopensprinkler.program import Program
 from pyopensprinkler.station import Station
@@ -23,50 +24,33 @@ def __init__(self, host, md5password):
 
         self.device = Device(self)
 
-        self.getPrograms()
-        self.getStations()
-
-    def _request(self, path, params={}):
+    def request(self, path, params=None):
+        if params is None:
+            params = {}
         """Make a request from the API."""
-        params['pw'] = self._md5password
+        params["pw"] = self._md5password
         qs = urllib.parse.urlencode(params)
 
         url = f"{'/'.join([self._baseUrl, path])}?{qs}"
-        return self._requestHttp(url)
+        return self.request_http(url)
 
     @cached(cache=TTLCache(maxsize=32, ttl=1))
-    def _requestHttp(self, url):
-        (resp, content) = _HTTP.request(url, 'GET')
+    def request_http(self, url):
+        (resp, content) = _HTTP.request(url, "GET")
         # TODO: check resp for errors
+        content = json.loads(content.decode("UTF-8"))
+        return resp, content
 
-        content = json.loads(content.decode('UTF-8'))
-
-        return (resp, content)
-
-    def getPrograms(self):
+    @property
+    def programs(self):
         """Retrieve programs"""
-        (resp, content) = self._request('jp')
+        (resp, content) = self.request("jp")
+        return [Program(self, program, i) for i, program in enumerate(content["pd"])]
 
-        self._programs = []
-        for i, program in enumerate(content['pd']):
-            self._programs.append(Program(self, program, i))
-
-        return self._programs
-
-    def getProgram(self, index):
-        """Retrieve program"""
-        return self._programs[index]
-
-    def getStations(self):
+    @property
+    def stations(self):
         """Retrieve stations"""
-        (resp, content) = self._request('jn')
-
-        self._stations = []
-        for i, station in enumerate(content['snames']):
-            self._stations.append(Station(self, station, i))
-
-        return self._stations
-
-    def getStation(self, index):
-        """Retrieve station"""
-        return self._stations[index]
+        (resp, content) = self.request("jn")
+        return [
+            Station(self, station, i) for i, station in enumerate(content["snames"])
+        ]

pyopensprinkler/device.py

@@ -8,67 +8,76 @@ def __init__(self, opensprinkler):
         """Device class initializer."""
         self._opensprinkler = opensprinkler
 
-    def _getOption(self, option):
+    def _get_option(self, option):
         """Retrieve option"""
-        (resp, content) = self._opensprinkler._request('jo')
+        (resp, content) = self._opensprinkler.request("jo")
         return content[option]
 
-    def _getVariable(self, option):
+    def _get_variable(self, option):
         """Retrieve option"""
-        (resp, content) = self._opensprinkler._request('jc')
+        (resp, content) = self._opensprinkler.request("jc")
         return content[option]
 
-    def _setVariable(self, option, value):
+    def _set_variable(self, option, value):
         """Retrieve option"""
-        params = {}
-        params[option] = value
-        (resp, content) = self._opensprinkler._request('cv', params)
-        return content['result']
+        params = {option: value}
+        (resp, content) = self._opensprinkler.request("cv", params)
+        return content["result"]
 
-    def getFirmwareVersion(self):
+    @property
+    def firmware_version(self):
         """Retrieve firmware version"""
-        return self._getOption('fwv')
+        return self._get_option("fwv")
 
-    def getHardwareVersion(self):
+    @property
+    def hardware_version(self):
         """Retrieve hardware version"""
-        return self._getOption('hwv')
+        return self._get_option("hwv")
 
-    def getLastRun(self):
+    @property
+    def last_run(self):
         """Retrieve hardware version"""
-        return self._getVariable('lrun')[3]
+        return self._get_variable("lrun")[3]
 
-    def getRainDelay(self):
+    @property
+    def rain_delay(self):
         """Retrieve rain delay"""
-        return self._getVariable('rd')
+        return self._get_variable("rd")
 
-    def getRainDelayStopTime(self):
+    @property
+    def rain_delay_stop_time(self):
         """Retrieve rain delay stop time"""
-        return self._getVariable('rdst')
+        return self._get_variable("rdst")
 
-    def getRainSensor1(self):
+    @property
+    def rain_sensor_1(self):
         """Retrieve hardware version"""
-        return self._getVariable('sn1')
+        return self._get_variable("sn1")
 
-    def getRainSensor2(self):
+    @property
+    def rain_sensor_2(self):
         """Retrieve hardware version"""
-        return self._getVariable('sn2')
+        return self._get_variable("sn2")
 
-    def getRainSensorLegacy(self):
+    @property
+    def rain_sensor_legacy(self):
         """Retrieve hardware version"""
-        return self._getVariable('rs')
+        return self._get_variable("rs")
 
-    def getOperationEnabled(self):
+    @property
+    def operation_enabled(self):
         """Retrieve operation enabled"""
-        return self._getVariable('en')
+        return self._get_variable("en")
 
-    def getWaterLevel(self):
+    @property
+    def water_level(self):
         """Retrieve water level"""
-        return self._getOption('wl')
+        return self._get_option("wl")
 
     def enable(self):
         """Enable operation"""
-        return self._setVariable('en', 1)
+        return self._set_variable("en", 1)
 
     def disable(self):
         """Disable operation"""
-        return self._setVariable('en', 0)
+        return self._set_variable("en", 0)

pyopensprinkler/program.py

@@ -20,31 +20,30 @@ def index(self):
         """Program index"""
         return self._index
 
-    def _getVariable(self, variableIndex):
+    def _get_variable(self, variable_index):
         """Retrieve option"""
-        (resp, content) = self._opensprinkler._request('jp')
-        return content['pd'][self._index][variableIndex]
+        (resp, content) = self._opensprinkler.request("jp")
+        return content["pd"][self._index][variable_index]
 
-    def _setVariable(self, option, value):
+    def _set_variable(self, option, value):
         """Set option"""
-        params = {}
-        params['pid'] = self._index
-        params[option] = value
-        (resp, content) = self._opensprinkler._request('mp', params)
-        return content['result']
+        params = {"pid": self._index, option: value}
+        (resp, content) = self._opensprinkler.request("mp", params)
+        return content["result"]
 
-    def getEnabled(self):
+    @property
+    def enabled(self):
         """Retrieve enabled flag"""
-        return int('{0:08b}'.format(self._getVariable(0))[7])
+        return int("{0:08b}".format(self._get_variable(0))[7])
 
     def enable(self):
         """Enable operation"""
-        return self._setVariable('en', 1)
+        return self._set_variable("en", 1)
 
     def disable(self):
         """Disable operation"""
-        return self._setVariable('en', 0)
+        return self._set_variable("en", 0)
 
     def run(self):
         """Run program"""
-        return self._setVariable('uwt', 0)
+        return self._set_variable("uwt", 0)