Merge pull request #50 from davidrecordon/master

Normalize "Undefined" variable values to None

Author: lawtancool

pyControl4/blind.py

@@ -7,51 +7,67 @@ class C4Blind(C4Entity):
     async def getBatteryLevel(self):
         """Returns the battery of a blind. We currently don't know the range or meaning."""
         value = await self.director.getItemVariableValue(self.item_id, "Battery Level")
+        if value is None:
+            return None
         return int(value)
 
     async def getClosing(self):
         """Returns an indication of whether the blind is moving in the closed direction as a boolean
         (True=closing, False=opening). If the blind is stopped, reports the direction it last moved.
         """
         value = await self.director.getItemVariableValue(self.item_id, "Closing")
+        if value is None:
+            return None
         return bool(value)
 
     async def getFullyClosed(self):
         """Returns an indication of whether the blind is fully closed as a boolean
         (True=fully closed, False=at least partially open)."""
         value = await self.director.getItemVariableValue(self.item_id, "Fully Closed")
+        if value is None:
+            return None
         return bool(value)
 
     async def getFullyOpen(self):
         """Returns an indication of whether the blind is fully open as a boolean
         (True=fully open, False=at least partially closed)."""
         value = await self.director.getItemVariableValue(self.item_id, "Fully Open")
+        if value is None:
+            return None
         return bool(value)
 
     async def getLevel(self):
         """Returns the level (current position) of a blind as an int 0-100.
         0 is fully closed and 100 is fully open.
         """
         value = await self.director.getItemVariableValue(self.item_id, "Level")
+        if value is None:
+            return None
         return int(value)
 
     async def getOpen(self):
         """Returns an indication of whether the blind is open as a boolean (True=open, False=closed).
         This is true even if the blind is only partially open."""
         value = await self.director.getItemVariableValue(self.item_id, "Open")
+        if value is None:
+            return None
         return bool(value)
 
     async def getOpening(self):
         """Returns an indication of whether the blind is moving in the open direction as a boolean
         (True=opening, False=closing). If the blind is stopped, reports the direction it last moved.
         """
         value = await self.director.getItemVariableValue(self.item_id, "Opening")
+        if value is None:
+            return None
         return bool(value)
 
     async def getStopped(self):
         """Returns an indication of whether the blind is stopped as a boolean
         (True=stopped, False=moving)."""
         value = await self.director.getItemVariableValue(self.item_id, "Stopped")
+        if value is None:
+            return None
         return bool(value)
 
     async def getTargetLevel(self):
@@ -60,6 +76,8 @@ async def getTargetLevel(self):
         0 is fully closed and 100 is fully open.
         """
         value = await self.director.getItemVariableValue(self.item_id, "Target Level")
+        if value is None:
+            return None
         return int(value)
 
     async def open(self):

pyControl4/director.py

@@ -165,7 +165,10 @@ async def getItemVariableValue(self, item_id, var_name):
             raise ValueError("Empty response recieved from Director! The variable {} \
                     doesn't seem to exist for item {}.".format(var_name, item_id))
         jsonDictionary = json.loads(data)
-        return jsonDictionary[0]["value"]
+        value = jsonDictionary[0]["value"]
+        if value == "Undefined":
+            return None
+        return value
 
     async def getAllItemVariableValue(self, var_name):
         """Returns a dictionary with the values of the specified variable
@@ -184,6 +187,9 @@ async def getAllItemVariableValue(self, var_name):
             raise ValueError("Empty response recieved from Director! The variable {} \
                     doesn't seem to exist for any items.".format(var_name))
         jsonDictionary = json.loads(data)
+        for item in jsonDictionary:
+            if item.get("value") == "Undefined":
+                item["value"] = None
         return jsonDictionary
 
     async def getItemCommands(self, item_id):

pyControl4/fan.py

@@ -16,6 +16,8 @@ async def getState(self):
             bool: True if the fan is on, False otherwise.
         """
         value = await self.director.getItemVariableValue(self.item_id, "IS_ON")
+        if value is None:
+            return None
         return bool(value)
 
     async def getSpeed(self):
@@ -37,6 +39,8 @@ async def getSpeed(self):
             int: Current fan speed (0–4).
         """
         value = await self.director.getItemVariableValue(self.item_id, "CURRENT_SPEED")
+        if value is None:
+            return None
         return int(value)
 
     # ------------------------

pyControl4/light.py

@@ -9,11 +9,15 @@ async def getLevel(self):
         Will cause an error if called on a non-dimmer switch. Use `getState()` instead.
         """
         value = await self.director.getItemVariableValue(self.item_id, "LIGHT_LEVEL")
+        if value is None:
+            return None
         return int(value)
 
     async def getState(self):
         """Returns the power state of a dimmer or switch as a boolean (True=on, False=off)."""
         value = await self.director.getItemVariableValue(self.item_id, "LIGHT_STATE")
+        if value is None:
+            return None
         return bool(value)
 
     async def setLevel(self, level):

pyControl4/relay.py

@@ -20,9 +20,10 @@ async def getRelayStateVerified(self):
             I think this is just used to verify that the relay is functional,
             not 100% sure though.
         """
-        return bool(
-            await self.director.getItemVariableValue(self.item_id, "StateVerified")
-        )
+        value = await self.director.getItemVariableValue(self.item_id, "StateVerified")
+        if value is None:
+            return None
+        return bool(value)
 
     async def open(self):
         """Set the relay to its open state.

pyControl4/room.py

@@ -1,5 +1,7 @@
 """Controls Control4 Room devices."""
 
+from typing import Optional
+
 from pyControl4 import C4Entity
 
 
@@ -8,14 +10,18 @@ class C4Room(C4Entity):
     A media-oriented view of a Control4 Room, supporting items of type="room"
     """
 
-    async def isRoomHidden(self) -> bool:
+    async def isRoomHidden(self) -> Optional[bool]:
         """Returns True if the room is hidden from the end-user"""
         value = await self.director.getItemVariableValue(self.item_id, "ROOM_HIDDEN")
+        if value is None:
+            return None
         return int(value) != 0
 
-    async def isOn(self) -> bool:
+    async def isOn(self) -> Optional[bool]:
         """Returns True/False if the room is "ON" from the director's perspective"""
         value = await self.director.getItemVariableValue(self.item_id, "POWER_STATE")
+        if value is None:
+            return None
         return int(value) != 0
 
     async def setRoomOff(self):
@@ -45,14 +51,18 @@ async def setVideoAndAudioSource(self, source_id: int):
         """Sets the current audio and video source for the room"""
         await self._setSource(source_id, audio_only=False)
 
-    async def getVolume(self) -> int:
+    async def getVolume(self) -> Optional[int]:
         """Returns the current volume for the room from 0-100"""
         value = await self.director.getItemVariableValue(self.item_id, "CURRENT_VOLUME")
+        if value is None:
+            return None
         return int(value)
 
-    async def isMuted(self) -> bool:
+    async def isMuted(self) -> Optional[bool]:
         """Returns True if the room is muted"""
         value = await self.director.getItemVariableValue(self.item_id, "IS_MUTED")
+        if value is None:
+            return None
         return int(value) != 0
 
     async def setMuteOn(self):

pytest.ini

@@ -0,0 +1,3 @@
+[pytest]
+markers =
+    asyncio: marks tests as asyncio tests, requires the pytest-asyncio plugin.

requirements-dev.txt

@@ -3,3 +3,4 @@ xmltodict
 python-socketio-v4
 websocket-client
 pdoc3
+pytest-asyncio

tests/__init__.py

@@ -0,0 +1,62 @@
+"""Tests for handling of 'Undefined' variable values from the Control4 Director."""
+
+import json
+from unittest.mock import AsyncMock, patch
+
+import pytest
+
+from pyControl4.director import C4Director
+from pyControl4.light import C4Light
+from pyControl4.blind import C4Blind
+
+
+@pytest.fixture
+def director():
+    """Create a C4Director with a mocked session."""
+    return C4Director("192.168.1.1", "test-token")
+
+
+@pytest.mark.asyncio
+async def test_get_item_variable_value_undefined(director):
+    """Test that getItemVariableValue normalizes 'Undefined' to None."""
+    response = json.dumps([{"id": 123, "varName": "HUMIDITY", "value": "Undefined"}])
+    with patch.object(director, "sendGetRequest", new=AsyncMock(return_value=response)):
+        result = await director.getItemVariableValue(123, "HUMIDITY")
+    assert result is None
+
+
+@pytest.mark.asyncio
+async def test_get_all_item_variable_value_undefined(director):
+    """Test that getAllItemVariableValue normalizes 'Undefined' to None in items."""
+    response = json.dumps(
+        [
+            {"id": 100, "varName": "HUMIDITY", "value": "Undefined"},
+            {"id": 100, "varName": "TEMPERATURE_F", "value": 72.5},
+            {"id": 200, "varName": "HUMIDITY", "value": 45},
+        ]
+    )
+    with patch.object(director, "sendGetRequest", new=AsyncMock(return_value=response)):
+        result = await director.getAllItemVariableValue("HUMIDITY,TEMPERATURE_F")
+    assert result[0]["value"] is None
+    assert result[1]["value"] == 72.5
+    assert result[2]["value"] == 45
+
+
+@pytest.mark.asyncio
+async def test_light_get_level_undefined(director):
+    """Test that int callers propagate None instead of crashing."""
+    light = C4Light(director, 100)
+    response = json.dumps([{"id": 100, "varName": "LIGHT_LEVEL", "value": "Undefined"}])
+    with patch.object(director, "sendGetRequest", new=AsyncMock(return_value=response)):
+        result = await light.getLevel()
+    assert result is None
+
+
+@pytest.mark.asyncio
+async def test_blind_get_fully_open_undefined(director):
+    """Test that bool callers propagate None instead of a misleading value."""
+    blind = C4Blind(director, 200)
+    response = json.dumps([{"id": 200, "varName": "Fully Open", "value": "Undefined"}])
+    with patch.object(director, "sendGetRequest", new=AsyncMock(return_value=response)):
+        result = await blind.getFullyOpen()
+    assert result is None