pyg90alarm 1.17.0__tar.gz → 1.17.2__tar.gz

{pyg90alarm-1.17.0 → pyg90alarm-1.17.2}/.github/workflows/main.yml

@@ -75,6 +75,8 @@ jobs:
     name: Publish to PyPi
     runs-on: ubuntu-latest
     needs: [tests]
+    permissions:
+      id-token: write  # Required for trusted publishing
     steps:
       - name: Checkout the code
         uses: actions/checkout@v3
@@ -94,8 +96,8 @@ jobs:
         if: github.event_name != 'release'
         uses: pypa/gh-action-pypi-publish@release/v1
         with:
-          password: ${{ secrets.TEST_PYPI_TOKEN }}
           repository_url: https://test.pypi.org/legacy/
+          attestations: true
       - name: Publish the release to PyPi
         # Publish to production PyPi only happens when a release published out
         # of the main branch
@@ -106,4 +108,4 @@ jobs:
              || github.event.release.target_commitish == 'master')
         uses: pypa/gh-action-pypi-publish@release/v1
         with:
-          password: ${{ secrets.PYPI_TOKEN }}
+          attestations: true

{pyg90alarm-1.17.0 → pyg90alarm-1.17.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyg90alarm
-Version: 1.17.0
+Version: 1.17.2
 Summary: G90 Alarm system protocol
 Home-page: https://github.com/hostcc/pyg90alarm
 Author: Ilia Sotnikov

{pyg90alarm-1.17.0 → pyg90alarm-1.17.2}/src/pyg90alarm/alarm.py

@@ -161,7 +161,9 @@ class G90Alarm(G90DeviceNotifications):
         self._host: str = host
         self._port: int = port
         self._sensors: List[G90Sensor] = []
+        self._sensors_lock = asyncio.Lock()
         self._devices: List[G90Device] = []
+        self._devices_lock = asyncio.Lock()
         self._notifications: Optional[G90DeviceNotifications] = None
         self._sensor_cb: Optional[SensorCallback] = None
         self._armdisarm_cb: Optional[ArmDisarmCallback] = None
@@ -258,20 +260,26 @@ class G90Alarm(G90DeviceNotifications):
 
         :return: List of sensors
         """
-        if not self._sensors:
-            sensors = self.paginated_result(
-                G90Commands.GETSENSORLIST
-            )
-            async for sensor in sensors:
-                obj = G90Sensor(
-                    *sensor.data, parent=self, subindex=0,
-                    proto_idx=sensor.proto_idx
+        # Use lock around the operation, to ensure no duplicated entries in the
+        # resulting list or redundant exchanges with panel are made when the
+        # method is called concurrently
+        async with self._sensors_lock:
+            if not self._sensors:
+                sensors = self.paginated_result(
+                    G90Commands.GETSENSORLIST
                 )
-                self._sensors.append(obj)
+                async for sensor in sensors:
+                    obj = G90Sensor(
+                        *sensor.data, parent=self, subindex=0,
+                        proto_idx=sensor.proto_idx
+                    )
+                    self._sensors.append(obj)
 
-            _LOGGER.debug('Total number of sensors: %s', len(self._sensors))
+                _LOGGER.debug(
+                    'Total number of sensors: %s', len(self._sensors)
+                )
 
-        return self._sensors
+            return self._sensors
 
     async def find_sensor(self, idx: int, name: str) -> Optional[G90Sensor]:
         """
@@ -316,28 +324,32 @@ class G90Alarm(G90DeviceNotifications):
 
         :return: List of devices
         """
-        if not self._devices:
-            devices = self.paginated_result(
-                G90Commands.GETDEVICELIST
-            )
-            async for device in devices:
-                obj = G90Device(
-                    *device.data, parent=self, subindex=0,
-                    proto_idx=device.proto_idx
+        # See `get_sensors` method for the rationale behind the lock usage
+        async with self._devices_lock:
+            if not self._devices:
+                devices = self.paginated_result(
+                    G90Commands.GETDEVICELIST
                 )
-                self._devices.append(obj)
-                # Multi-node devices (first node has already been added
-                # above
-                for node in range(1, obj.node_count):
+                async for device in devices:
                     obj = G90Device(
-                        *device.data, parent=self,
-                        subindex=node, proto_idx=device.proto_idx
+                        *device.data, parent=self, subindex=0,
+                        proto_idx=device.proto_idx
                     )
                     self._devices.append(obj)
+                    # Multi-node devices (first node has already been added
+                    # above
+                    for node in range(1, obj.node_count):
+                        obj = G90Device(
+                            *device.data, parent=self,
+                            subindex=node, proto_idx=device.proto_idx
+                        )
+                        self._devices.append(obj)
 
-            _LOGGER.debug('Total number of devices: %s', len(self._devices))
+                _LOGGER.debug(
+                    'Total number of devices: %s', len(self._devices)
+                )
 
-        return self._devices
+            return self._devices
 
     @property
     async def host_info(self) -> G90HostInfo:
@@ -915,7 +927,10 @@ class G90Alarm(G90DeviceNotifications):
                         # notifications port
                         self._handle_alert(
                             (self._host, self._notifications_local_port),
-                            item.as_device_alert()
+                            item.as_device_alert(),
+                            # Skip verifying device GUID, since history entry
+                            # don't have it
+                            verify_device_id=False
                         )
 
                         # Record the entry as most recent one

{pyg90alarm-1.17.0 → pyg90alarm-1.17.2}/src/pyg90alarm/device_notifications.py

@@ -208,13 +208,17 @@ class G90DeviceNotifications(DatagramProtocol):
         return False
 
     def _handle_alert(
-        self, addr: Tuple[str, int], alert: G90DeviceAlert
+        self, addr: Tuple[str, int], alert: G90DeviceAlert,
+        verify_device_id: bool = True
     ) -> None:
         handled = False
 
         # Stop processing when alert is received from the device with different
-        # GUID
-        if self.device_id and alert.device_id != self.device_id:
+        # GUID (if enabled)
+        if (
+            verify_device_id and self.device_id
+            and alert.device_id != self.device_id
+        ):
             _LOGGER.error(
                 "Received alert from wrong device: expected '%s', got '%s'",
                 self.device_id, alert.device_id

{pyg90alarm-1.17.0 → pyg90alarm-1.17.2}/src/pyg90alarm.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyg90alarm
-Version: 1.17.0
+Version: 1.17.2
 Summary: G90 Alarm system protocol
 Home-page: https://github.com/hostcc/pyg90alarm
 Author: Ilia Sotnikov

{pyg90alarm-1.17.0 → pyg90alarm-1.17.2}/tests/test_alarm.py

@@ -2,6 +2,7 @@
 Tests for G90Alarm class
 """
 import asyncio
+from itertools import cycle
 from unittest.mock import MagicMock
 import pytest
 
@@ -128,6 +129,35 @@ async def test_devices(mock_device: DeviceMock) -> None:
     assert isinstance(devices[0]._asdict(), dict)
 
 
+# Provide an endless sequence of simulated panel responses for the devices
+# list. Each attempt will simulate a single device. This sequence will prevent
+# `G90TimeoutError` if the code under test initiates more exchanges with the
+# panel than the simulated data contains.
+@pytest.mark.g90device(sent_data=cycle([
+    b'ISTART[138,'
+    b'[[1,1,1],["Switch",10,0,10,1,0,32,0,0,16,1,0,""]]]IEND\0',
+]))
+async def test_get_devices_concurrent(mock_device: DeviceMock) -> None:
+    """
+    Tests for concurrently retrieving list of devices produces consistent
+    results.
+    """
+    g90 = G90Alarm(host=mock_device.host, port=mock_device.port)
+    g90.paginated_result = MagicMock(  # type: ignore[method-assign]
+        spec=g90.paginated_result, wraps=g90.paginated_result
+    )
+
+    # Issue two concurrent requests to retrieve devices
+    res = await asyncio.gather(g90.get_devices(), g90.get_devices())
+    # Ensure only single exchange with the panel
+    g90.paginated_result.assert_called_once()
+    # While `pylint` demands use of generator, the comprehension is used
+    # instead for ease of trroubleshooting test failures as it will show the
+    # list elements, not just generator instance
+    # pylint: disable=use-a-generator
+    assert all([len(x) == 1 for x in res])
+
+
 @pytest.mark.g90device(sent_data=[
     b'ISTART[138,'
     b'[[1,1,1],["Switch",10,0,10,1,0,32,0,0,16,2,0,""]]]IEND\0'
@@ -207,6 +237,27 @@ async def test_single_sensor(mock_device: DeviceMock) -> None:
     assert isinstance(sensors[0]._asdict(), dict)
 
 
+# See `test_get_devices_concurrent` for the explanation of the test
+@pytest.mark.g90device(sent_data=cycle([
+    b'ISTART[102,'
+    b'[[1,1,1],["Remote",10,0,10,1,0,32,0,0,16,1,0,""]]]IEND\0',
+]))
+async def test_get_sensors_concurrent(mock_device: DeviceMock) -> None:
+    """
+    Tests for concurrently retrieving list of sensors produces consistent
+    results.
+    """
+    g90 = G90Alarm(host=mock_device.host, port=mock_device.port)
+    g90.paginated_result = MagicMock(  # type: ignore[method-assign]
+        spec=g90.paginated_result, wraps=g90.paginated_result
+    )
+
+    res = await asyncio.gather(g90.get_sensors(), g90.get_sensors())
+    g90.paginated_result.assert_called_once()
+    # pylint: disable=use-a-generator
+    assert all([len(x) == 1 for x in res])
+
+
 @pytest.mark.g90device(sent_data=[
     b'ISTART[102,'
     b'[[3,1,3],["Remote 1",10,0,10,1,0,32,0,0,16,1,0,""],'

{pyg90alarm-1.17.0 → pyg90alarm-1.17.2}/tests/test_history.py

@@ -135,6 +135,10 @@ async def test_history_parsing_error(mock_device: DeviceMock) -> None:
 
 
 @pytest.mark.g90device(sent_data=[
+    # Host info
+    b'ISTART[206,'
+    b'["DUMMYGUID","DUMMYPRODUCT",'
+    b'"1.2","1.1","206","206",3,3,0,2,"4242",50,100]]IEND\0',
     # Simulate empty history initially
     b'ISTART[200,[[0,0,0]]]IEND\0',
     # The history records will be used to remember the timestamp of most recent
@@ -173,6 +177,9 @@ async def test_simulate_alerts_from_history(mock_device: DeviceMock) -> None:
     armdisarm_cb.side_effect = lambda *args: future_armdisarm.set_result(True)
 
     g90 = G90Alarm(host=mock_device.host, port=mock_device.port)
+    # Call the method to store device GUID, so that its validation in
+    # `G90DeviceNotifications._handle_alert()` is involved
+    await g90.get_host_info()
     g90.alarm_callback = alarm_cb
     g90.armdisarm_callback = armdisarm_cb
     # Simulate device timeout exception every 2nd call to `G90Alarm.history()`

{pyg90alarm-1.17.0 → pyg90alarm-1.17.2}/tox.ini

@@ -16,19 +16,14 @@ isolated_build = true
 deps =
     -r requirements_dev.txt
 
-allowlist_externals =
-	cat
 commands =
     check-manifest --ignore 'tox.ini,tests/**,docs/**,.pylintrc,.readthedocs.yaml,sonar-project.properties'
     flake8 --tee --output-file=flake8.txt src/pyg90alarm/ tests/
-    pylint --output-format=parseable --output=pylint.txt src/pyg90alarm/ tests/
+    pylint --output-format=text,parseable:pylint.txt src/pyg90alarm/ tests/
     mypy --strict --cobertura-xml-report=mypy/ src/pyg90alarm/ tests/
 	  # Ensure only traces for in-repository module is processed, not for one
 	  # installed by `tox` (see above for more details)
     pytest --cov=src/pyg90alarm --cov-append --cov-report=term-missing -v tests []
-commands_post =
-	# Show the `pylint` report to the standard output, to ease fixing the issues reported
-	cat pylint.txt
 
 [flake8]
 exclude = .tox,*.egg,build,data,scripts,docs