Merge pull request #4 from amitfin/master

swing support

Author: OnFreund

pycoolmasternet_async/__init__.py

@@ -1 +1,2 @@
 from .coolmasternet import CoolMasterNet
+from .coolmasternet import SWING_MODES

pycoolmasternet_async/coolmasternet.py

@@ -3,39 +3,57 @@
 
 _MODES = ["auto", "cool", "dry", "fan", "heat"]
 
+_SWING_CHAR_TO_NAME = {
+    "a": "auto",
+    "h": "horizontal",
+    "3": "30",
+    "4": "45",
+    "6": "60",
+    "v": "vertical",
+    "x": "stop",
+}
+
+_SWING_NAME_TO_CHAR = {value: key for key, value in _SWING_CHAR_TO_NAME.items()}
+
+SWING_MODES = list(_SWING_CHAR_TO_NAME.values())
+
 
 class CoolMasterNet():
     """A connection to a coolmasternet bridge."""
-    def __init__(self, host, port=10102, read_timeout=1):
+    def __init__(self, host, port=10102, read_timeout=1, swing_support=False):
         """Initialize this CoolMasterNet instance to connect to a particular
         host at a particular port."""
         self._host = host
         self._port = port
         self._read_timeout = read_timeout
+        self._swing_support = swing_support
+        self._concurrent_reads = asyncio.Semaphore(3)
 
     async def _make_request(self, request):
         """Send a request to the CoolMasterNet and returns the response."""
-        reader, writer = await asyncio.open_connection(self._host, self._port)
+        async with self._concurrent_reads:
+
+            reader, writer = await asyncio.open_connection(self._host, self._port)
 
-        try:
-            prompt = await asyncio.wait_for(reader.readuntil(b">"), self._read_timeout)
-            if prompt != b">":
-                raise Exception("CoolMasterNet prompt not found")
+            try:
+                prompt = await asyncio.wait_for(reader.readuntil(b">"), self._read_timeout)
+                if prompt != b">":
+                    raise Exception("CoolMasterNet prompt not found")
 
-            writer.write((request + "\n").encode("ascii"))
-            response = await asyncio.wait_for(reader.readuntil(b"\n>"), self._read_timeout)
+                writer.write((request + "\n").encode("ascii"))
+                response = await asyncio.wait_for(reader.readuntil(b"\n>"), self._read_timeout)
 
-            data = response.decode("ascii")
-            if data.endswith("\n>"):
-                data = data[:-1]
+                data = response.decode("ascii")
+                if data.endswith("\n>"):
+                    data = data[:-1]
 
-            if data.endswith("OK\r\n"):
-                data = data[:-4]
+                if data.endswith("OK\r\n"):
+                    data = data[:-4]
 
-            return data
-        finally:
-            writer.close()
-            await writer.wait_closed()
+                return data
+            finally:
+                writer.close()
+                await writer.wait_closed()
 
     async def info(self):
         """Get the general info the this CoolMasterNet."""
@@ -48,20 +66,30 @@ async def status(self):
         """Return a list of CoolMasterNetUnit objects with current status."""
         status_lines = (await self._make_request("ls2")).strip().split("\r\n")
         return {
-            line[0:6]:CoolMasterNetUnit(self, line[0:6], line)
-            for line in status_lines
+            key: unit
+            for unit, key in await asyncio.gather(
+                *(CoolMasterNetUnit.create(self, line[0:6], line) for line in status_lines))
         }
 
 
 class CoolMasterNetUnit():
     """An immutable snapshot of a unit."""
-    def __init__(self, bridge, unit_id, raw):
+    def __init__(self, bridge, unit_id, raw, swing_raw):
         """Initialize a unit snapshot."""
         self._raw = raw
+        self._swing_raw = swing_raw
         self._unit_id = unit_id
         self._bridge = bridge
         self._parse()
 
+    @classmethod
+    async def create(cls, bridge, unit_id, raw=None):
+        if raw is None:
+            raw = (await bridge._make_request(f"ls2 {unit_id}")).strip()   
+        swing_raw = ((await bridge._make_request(f"query {unit_id} s")).strip() 
+            if bridge._swing_support else "")
+        return CoolMasterNetUnit(bridge, unit_id, raw, swing_raw), unit_id
+
     def _parse(self):
         fields = re.split(r"\s+", self._raw.strip())
         if len(fields) != 9:
@@ -73,14 +101,14 @@ def _parse(self):
         self._temperature = float(fields[3][:-1])
         self._fan_speed = fields[4].lower()
         self._mode = fields[5].lower()
+        self._swing = _SWING_CHAR_TO_NAME.get(self._swing_raw)
 
     async def _make_unit_request(self, request):
         return await self._bridge._make_request(request.replace("UID", self._unit_id))
 
     async def refresh(self):
         """Refresh the data from CoolMasterNet and return it as a new instance."""
-        status_line = (await self._make_unit_request("ls2 UID")).strip()
-        return CoolMasterNetUnit(self._bridge, status_line[0:6], status_line)
+        return (await CoolMasterNetUnit.create(self._bridge, self._unit_id))[0]
 
     @property
     def unit_id(self):
@@ -112,6 +140,11 @@ def mode(self):
         """The current mode (e.g. heat, cool)."""
         return self._mode
 
+    @property
+    def swing(self):
+        """The current swing mode (e.g. horizontal)."""
+        return self._swing
+
     @property
     def temperature_unit(self):
         return self._temperature_unit
@@ -137,6 +170,21 @@ async def set_thermostat(self, value):
         await self._make_unit_request(f"temp UID {value}")
         return await self.refresh()
 
+    async def set_swing(self, value):
+        """Set the swing mode."""
+        if not value in SWING_MODES:
+            raise ValueError(
+                f"Unrecognized swing mode {value}. Valid values: {', '.join(SWING_MODES)}"
+            )
+
+        return_value = await self._make_unit_request(f"swing UID {_SWING_NAME_TO_CHAR[value]}")
+        if return_value.startswith("Unsupported Feature"):
+            raise ValueError(
+                f"Unit {self._unit_id} doesn't support swing mode {value}."
+            )
+
+        return await self.refresh()
+
     async def turn_on(self):
         """Turn a unit on."""
         await self._make_unit_request("on UID")

setup.py

@@ -18,7 +18,7 @@
 EMAIL = 'onfreund@gmail.com'
 AUTHOR = 'On Freund'
 REQUIRES_PYTHON = '>=3.7.0'
-VERSION = '0.1.3'
+VERSION = '0.1.4'
 
 REQUIRED = []