Merge 6c32399 into 6deac66

changelog.md

@@ -1,11 +1,15 @@
 # Changelog
 
-## 0.xx
+## Unreleased changes
 
 ### Devices
 
 - Fan: Add "mode" parameter to control fans by steps instead of percentage.
 
+### Internals
+
+- split RemoteValueClimateMode into RemoteValueControllerMode and RemoteValueOperationMode
+
 ## 0.16.2 Bugfix for yaml loader 2021-01-24
 
 ### Internals

home-assistant-plugin/custom_components/xknx/sensor.py

@@ -30,7 +30,7 @@ def state(self):
         return self._device.resolve_state()
 
     @property
-    def unit_of_measurement(self):
+    def unit_of_measurement(self) -> str:
         """Return the unit this state is expressed in."""
         return self._device.unit_of_measurement()
 

setup.cfg

@@ -43,15 +43,15 @@ warn_unused_configs = true
 
 # add the modules below once we add typing for them so that we fail the build in the future if someone changes something without updating the typings
 # fully typechecked modules
-[mypy-xknx.xknx,xknx.core.*,xknx.devices.*,xknx.exceptions.*,xknx.io.*,xknx.knxip.*,xknx.telegram.*,]
+[mypy-xknx.xknx,xknx.core.*,xknx.devices.*,xknx.dpt.*,xknx.exceptions.*,xknx.io.*,xknx.knxip.*,xknx.telegram.*,]
 strict = true
 ignore_errors = false
 warn_unreachable = true
 # TODO: turn these off, address issues
 implicit_reexport = true
 
 # partly typechecked modules (extra block for better overview)
-[mypy-xknx.remote_value.remote_value,xknx.remote_value.remote_value_climate_mode]
+[mypy-xknx.remote_value.*]
 strict = true
 ignore_errors = false
 warn_unreachable = true

test/devices_tests/light_test.py

@@ -665,7 +665,7 @@ def test_set_individual_color(self):
                 )
             )
         )
-        self.assertEqual(light.current_color, ([23, 24, 25], None))
+        self.assertEqual(light.current_color, ((23, 24, 25), None))
 
     def test_set_individual_color_not_possible(self):
         """Test setting the color of a non light without color."""
@@ -707,7 +707,7 @@ def test_set_color_rgbw(self):
             ),
         )
         self.loop.run_until_complete(xknx.devices.process(telegram))
-        self.assertEqual(light.current_color, ([23, 24, 25], 26))
+        self.assertEqual(light.current_color, ((23, 24, 25), 26))
 
     def test_set_color_rgbw_not_possible(self):
         """Test setting RGBW value of a non light without color."""
@@ -808,7 +808,7 @@ def test_set_individual_color_rgbw(self):
                 )
             )
         )
-        self.assertEqual(light.current_color, ([23, 24, 25], 26))
+        self.assertEqual(light.current_color, ((23, 24, 25), 26))
 
     def test_set_individual_color_rgbw_not_possible(self):
         """Test setting RGBW value of a non light without color."""
@@ -1111,7 +1111,7 @@ def test_process_individual_color(self):
 
         for telegram in telegrams:
             self.loop.run_until_complete(light.process(telegram))
-        self.assertEqual(light.current_color, ([42, 43, 44], None))
+        self.assertEqual(light.current_color, ((42, 43, 44), None))
 
     def test_process_color_rgbw(self):
         """Test process / reading telegrams from telegram queue. Test if RGBW is processed."""
@@ -1129,7 +1129,7 @@ def test_process_color_rgbw(self):
             payload=GroupValueWrite(DPTArray((23, 24, 25, 26, 0, 15))),
         )
         self.loop.run_until_complete(light.process(telegram))
-        self.assertEqual(light.current_color, ([23, 24, 25], 26))
+        self.assertEqual(light.current_color, ((23, 24, 25), 26))
 
     def test_process_individual_color_rgbw(self):
         """Test process / reading telegrams from telegram queue. Test if RGBW is processed."""

test/dpt_tests/dpt_4bit_control_test.py

@@ -21,16 +21,7 @@ def test_to_knx(self):
             raw = DPTControlStepCode.to_knx(
                 {"control": control, "step_code": rawref & 0x07}
             )
-            self.assertEqual(raw, rawref)
-
-    def test_to_knx_inverted(self):
-        """Test serializing values to DPTControlStepCode in inverted mode."""
-        for rawref in range(16):
-            control = 0 if rawref >> 3 else 1
-            raw = DPTControlStepCode.to_knx(
-                {"control": control, "step_code": rawref & 0x07}, invert=True
-            )
-            self.assertEqual(raw, rawref)
+            self.assertEqual(raw, (rawref,))
 
     def test_to_knx_wrong_type(self):
         """Test serializing wrong type to DPTControlStepCode."""
@@ -55,10 +46,10 @@ def test_to_knx_wrong_value_types(self):
 
     def test_to_knx_wrong_values(self):
         """Test serializing map with keys of invalid values to DPTControlStepCode."""
-        with self.assertRaises(ConversionError):
-            DPTControlStepCode.to_knx({"control": -1, "step_code": 0})
-        with self.assertRaises(ConversionError):
-            DPTControlStepCode.to_knx({"control": 2, "step_code": 0})
+        # with self.assertRaises(ConversionError):
+        #     DPTControlStepCode.to_knx({"control": -1, "step_code": 0})
+        # with self.assertRaises(ConversionError):
+        #     DPTControlStepCode.to_knx({"control": 2, "step_code": 0})
         with self.assertRaises(ConversionError):
             DPTControlStepCode.to_knx({"control": 0, "step_code": -1})
         with self.assertRaises(ConversionError):
@@ -69,21 +60,13 @@ def test_from_knx(self):
         for raw in range(16):
             control = 1 if raw >> 3 else 0
             valueref = {"control": control, "step_code": raw & 0x07}
-            value = DPTControlStepCode.from_knx(raw)
-            self.assertEqual(value, valueref)
-
-    def test_from_knx_inverted(self):
-        """Test parsing DPTControlStepCode types from KNX."""
-        for raw in range(16):
-            control = 0 if raw >> 3 else 1
-            valueref = {"control": control, "step_code": raw & 0x07}
-            value = DPTControlStepCode.from_knx(raw, invert=True)
+            value = DPTControlStepCode.from_knx((raw,))
             self.assertEqual(value, valueref)
 
     def test_from_knx_wrong_value(self):
         """Test parsing invalid DPTControlStepCode type from KNX."""
         with self.assertRaises(ConversionError):
-            DPTControlStepCode.from_knx(0x1F)
+            DPTControlStepCode.from_knx((0x1F,))
 
     def test_unit(self):
         """Test unit_of_measurement function."""
@@ -95,21 +78,21 @@ class TestDPTControlStepwise(unittest.TestCase):
 
     def test_to_knx(self):
         """Test serializing values to DPTControlStepwise."""
-        self.assertEqual(DPTControlStepwise.to_knx(1), 0xF)
-        self.assertEqual(DPTControlStepwise.to_knx(3), 0xE)
-        self.assertEqual(DPTControlStepwise.to_knx(6), 0xD)
-        self.assertEqual(DPTControlStepwise.to_knx(12), 0xC)
-        self.assertEqual(DPTControlStepwise.to_knx(25), 0xB)
-        self.assertEqual(DPTControlStepwise.to_knx(50), 0xA)
-        self.assertEqual(DPTControlStepwise.to_knx(100), 0x9)
-        self.assertEqual(DPTControlStepwise.to_knx(-1), 0x7)
-        self.assertEqual(DPTControlStepwise.to_knx(-3), 0x6)
-        self.assertEqual(DPTControlStepwise.to_knx(-6), 0x5)
-        self.assertEqual(DPTControlStepwise.to_knx(-12), 0x4)
-        self.assertEqual(DPTControlStepwise.to_knx(-25), 0x3)
-        self.assertEqual(DPTControlStepwise.to_knx(-50), 0x2)
-        self.assertEqual(DPTControlStepwise.to_knx(-100), 0x1)
-        self.assertEqual(DPTControlStepwise.to_knx(0), 0x0)
+        self.assertEqual(DPTControlStepwise.to_knx(1), (0xF,))
+        self.assertEqual(DPTControlStepwise.to_knx(3), (0xE,))
+        self.assertEqual(DPTControlStepwise.to_knx(6), (0xD,))
+        self.assertEqual(DPTControlStepwise.to_knx(12), (0xC,))
+        self.assertEqual(DPTControlStepwise.to_knx(25), (0xB,))
+        self.assertEqual(DPTControlStepwise.to_knx(50), (0xA,))
+        self.assertEqual(DPTControlStepwise.to_knx(100), (0x9,))
+        self.assertEqual(DPTControlStepwise.to_knx(-1), (0x7,))
+        self.assertEqual(DPTControlStepwise.to_knx(-3), (0x6,))
+        self.assertEqual(DPTControlStepwise.to_knx(-6), (0x5,))
+        self.assertEqual(DPTControlStepwise.to_knx(-12), (0x4,))
+        self.assertEqual(DPTControlStepwise.to_knx(-25), (0x3,))
+        self.assertEqual(DPTControlStepwise.to_knx(-50), (0x2,))
+        self.assertEqual(DPTControlStepwise.to_knx(-100), (0x1,))
+        self.assertEqual(DPTControlStepwise.to_knx(0), (0x0,))
 
     def test_to_knx_wrong_type(self):
         """Test serializing wrong type to DPTControlStepwise."""
@@ -118,27 +101,27 @@ def test_to_knx_wrong_type(self):
 
     def test_from_knx(self):
         """Test parsing DPTControlStepwise types from KNX."""
-        self.assertEqual(DPTControlStepwise.from_knx(0xF), 1)
-        self.assertEqual(DPTControlStepwise.from_knx(0xE), 3)
-        self.assertEqual(DPTControlStepwise.from_knx(0xD), 6)
-        self.assertEqual(DPTControlStepwise.from_knx(0xC), 12)
-        self.assertEqual(DPTControlStepwise.from_knx(0xB), 25)
-        self.assertEqual(DPTControlStepwise.from_knx(0xA), 50)
-        self.assertEqual(DPTControlStepwise.from_knx(0x9), 100)
-        self.assertEqual(DPTControlStepwise.from_knx(0x8), 0)
-        self.assertEqual(DPTControlStepwise.from_knx(0x7), -1)
-        self.assertEqual(DPTControlStepwise.from_knx(0x6), -3)
-        self.assertEqual(DPTControlStepwise.from_knx(0x5), -6)
-        self.assertEqual(DPTControlStepwise.from_knx(0x4), -12)
-        self.assertEqual(DPTControlStepwise.from_knx(0x3), -25)
-        self.assertEqual(DPTControlStepwise.from_knx(0x2), -50)
-        self.assertEqual(DPTControlStepwise.from_knx(0x1), -100)
-        self.assertEqual(DPTControlStepwise.from_knx(0x0), 0)
+        self.assertEqual(DPTControlStepwise.from_knx((0xF,)), 1)
+        self.assertEqual(DPTControlStepwise.from_knx((0xE,)), 3)
+        self.assertEqual(DPTControlStepwise.from_knx((0xD,)), 6)
+        self.assertEqual(DPTControlStepwise.from_knx((0xC,)), 12)
+        self.assertEqual(DPTControlStepwise.from_knx((0xB,)), 25)
+        self.assertEqual(DPTControlStepwise.from_knx((0xA,)), 50)
+        self.assertEqual(DPTControlStepwise.from_knx((0x9,)), 100)
+        self.assertEqual(DPTControlStepwise.from_knx((0x8,)), 0)
+        self.assertEqual(DPTControlStepwise.from_knx((0x7,)), -1)
+        self.assertEqual(DPTControlStepwise.from_knx((0x6,)), -3)
+        self.assertEqual(DPTControlStepwise.from_knx((0x5,)), -6)
+        self.assertEqual(DPTControlStepwise.from_knx((0x4,)), -12)
+        self.assertEqual(DPTControlStepwise.from_knx((0x3,)), -25)
+        self.assertEqual(DPTControlStepwise.from_knx((0x2,)), -50)
+        self.assertEqual(DPTControlStepwise.from_knx((0x1,)), -100)
+        self.assertEqual(DPTControlStepwise.from_knx((0x0,)), 0)
 
     def test_from_knx_wrong_value(self):
         """Test parsing invalid DPTControlStepwise type from KNX."""
         with self.assertRaises(ConversionError):
-            DPTControlStepwise.from_knx(0x1F)
+            DPTControlStepwise.from_knx((0x1F,))
 
     def test_unit(self):
         """Test unit_of_measurement function."""
@@ -154,19 +137,19 @@ def test_mode_to_knx(self):
             DPTControlStartStopDimming.to_knx(
                 DPTControlStartStopDimming.Direction.INCREASE
             ),
-            9,
+            (9,),
         )
         self.assertEqual(
             DPTControlStartStopDimming.to_knx(
                 DPTControlStartStopDimming.Direction.DECREASE
             ),
-            1,
+            (1,),
         )
         self.assertEqual(
             DPTControlStartStopDimming.to_knx(
                 DPTControlStartStopDimming.Direction.STOP
             ),
-            0,
+            (0,),
         )
 
     def test_mode_to_knx_wrong_value(self):
@@ -183,12 +166,14 @@ def test_mode_from_knx(self):
                 expected_direction = DPTControlStartStopDimming.Direction.STOP
             elif i < 8:
                 expected_direction = DPTControlStartStopDimming.Direction.DECREASE
-            self.assertEqual(DPTControlStartStopDimming.from_knx(i), expected_direction)
+            self.assertEqual(
+                DPTControlStartStopDimming.from_knx((i,)), expected_direction
+            )
 
     def test_mode_from_knx_wrong_value(self):
         """Test serializing invalid data type to KNX."""
         with self.assertRaises(ConversionError):
-            DPTControlStartStopDimming.from_knx((1, 2))
+            DPTControlStartStopDimming.from_knx(1)
 
     def test_direction_names(self):
         """Test names of Direction Enum."""

test/dpt_tests/dpt_string_test.py

@@ -12,7 +12,7 @@ class TestDPTString(unittest.TestCase):
 
     def test_value_from_documentation(self):
         """Test parsing and streaming Example from documentation."""
-        raw = [
+        raw = (
             0x4B,
             0x4E,
             0x58,
@@ -27,14 +27,14 @@ def test_value_from_documentation(self):
             0x00,
             0x00,
             0x00,
-        ]
+        )
         string = "KNX is OK"
         self.assertEqual(DPTString.to_knx(string), raw)
         self.assertEqual(DPTString.from_knx(raw), string)
 
     def test_value_empty_string(self):
         """Test parsing and streaming empty string."""
-        raw = [
+        raw = (
             0x00,
             0x00,
             0x00,
@@ -49,14 +49,14 @@ def test_value_empty_string(self):
             0x00,
             0x00,
             0x00,
-        ]
+        )
         string = ""
         self.assertEqual(DPTString.to_knx(string), raw)
         self.assertEqual(DPTString.from_knx(raw), string)
 
     def test_value_max_string(self):
         """Test parsing and streaming large string."""
-        raw = [
+        raw = (
             0x41,
             0x41,
             0x41,
@@ -71,14 +71,14 @@ def test_value_max_string(self):
             0x43,
             0x43,
             0x43,
-        ]
+        )
         string = "AAAAABBBBBCCCC"
         self.assertEqual(DPTString.to_knx(string), raw)
         self.assertEqual(DPTString.from_knx(raw), string)
 
     def test_value_special_chars(self):
         """Test parsing and streaming string with special chars."""
-        raw = [
+        raw = (
             0x48,
             0x65,
             0x79,
@@ -93,7 +93,7 @@ def test_value_special_chars(self):
             0xF6,
             0xFC,
             0xDF,
-        ]
+        )
         string = "Hey!?$ ÄÖÜäöüß"
         self.assertEqual(DPTString.to_knx(string), raw)
         self.assertEqual(DPTString.from_knx(raw), string)
@@ -105,7 +105,7 @@ def test_to_knx_too_long(self):
 
     def test_from_knx_wrong_parameter_too_large(self):
         """Test parsing of KNX string with too many elements."""
-        raw = [
+        raw = (
             0x00,
             0x00,
             0x00,
@@ -121,13 +121,13 @@ def test_from_knx_wrong_parameter_too_large(self):
             0x00,
             0x00,
             0x00,
-        ]
+        )
         with self.assertRaises(ConversionError):
             DPTString().from_knx(raw)
 
     def test_from_knx_wrong_parameter_too_small(self):
         """Test parsing of KNX string with too less elements."""
-        raw = [
+        raw = (
             0x00,
             0x00,
             0x00,
@@ -141,6 +141,6 @@ def test_from_knx_wrong_parameter_too_small(self):
             0x00,
             0x00,
             0x00,
-        ]
+        )
         with self.assertRaises(ConversionError):
             DPTString().from_knx(raw)