pyg90alarm 1.17.1__tar.gz → 1.18.0__tar.gz

{pyg90alarm-1.17.1 → pyg90alarm-1.18.0}/.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.1 → pyg90alarm-1.18.0}/PKG-INFO

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

{pyg90alarm-1.17.1 → pyg90alarm-1.18.0}/src/pyg90alarm/alarm.py

@@ -17,6 +17,7 @@
 # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 # SOFTWARE.
+# pylint: disable=too-many-lines
 
 """
 Provides interface to G90 alarm panel.
@@ -120,6 +121,14 @@ if TYPE_CHECKING:
             [int, str, G90RemoteButtonStates], Coroutine[None, None, None]
         ]
     ]
+    DoorOpenWhenArmingCallback = Union[
+        Callable[[int, str], None],
+        Callable[[int, str], Coroutine[None, None, None]]
+    ]
+    TamperCallback = Union[
+        Callable[[int, str], None],
+        Callable[[int, str], Coroutine[None, None, None]]
+    ]
     # Sensor-related callbacks for `G90Sensor` class - despite that class
     # stores them, the invocation is done by the `G90Alarm` class hence these
     # are defined here
@@ -131,6 +140,14 @@ if TYPE_CHECKING:
         Callable[[], None],
         Callable[[], Coroutine[None, None, None]]
     ]
+    SensorDoorOpenWhenArmingCallback = Union[
+        Callable[[], None],
+        Callable[[], Coroutine[None, None, None]]
+    ]
+    SensorTamperCallback = Union[
+        Callable[[], None],
+        Callable[[], Coroutine[None, None, None]]
+    ]
 
 
 # pylint: disable=too-many-public-methods
@@ -161,7 +178,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
@@ -172,6 +191,10 @@ class G90Alarm(G90DeviceNotifications):
         self._remote_button_press_cb: Optional[
             RemoteButtonPressCallback
         ] = None
+        self._door_open_when_arming_cb: Optional[
+            DoorOpenWhenArmingCallback
+        ] = None
+        self._tamper_cb: Optional[TamperCallback] = None
         self._reset_occupancy_interval = reset_occupancy_interval
         self._alert_config: Optional[G90AlertConfigFlags] = None
         self._sms_alert_when_armed = False
@@ -258,20 +281,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 +345,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:
@@ -601,6 +634,17 @@ class G90Alarm(G90DeviceNotifications):
                 await self.set_alert_config(
                     await self.alert_config | G90AlertConfigFlags.SMS_PUSH
                 )
+
+        # Reset the tampered and door open when arming flags on all sensors
+        # having those set
+        for sensor in await self.get_sensors():
+            if sensor.is_tampered:
+                # pylint: disable=protected-access
+                sensor._set_tampered(False)
+            if sensor.is_door_open_when_arming:
+                # pylint: disable=protected-access
+                sensor._set_door_open_when_arming(False)
+
         G90Callback.invoke(self._armdisarm_cb, state)
 
     @property
@@ -615,7 +659,9 @@ class G90Alarm(G90DeviceNotifications):
     def armdisarm_callback(self, value: ArmDisarmCallback) -> None:
         self._armdisarm_cb = value
 
-    async def on_alarm(self, event_id: int, zone_name: str) -> None:
+    async def on_alarm(
+        self, event_id: int, zone_name: str, is_tampered: bool
+    ) -> None:
         """
         Invoked when alarm is triggered. Fires corresponding callback if set by
         the user with :attr:`.alarm_callback`.
@@ -626,16 +672,31 @@ class G90Alarm(G90DeviceNotifications):
         :param zone_name: Sensor name
         """
         sensor = await self.find_sensor(event_id, zone_name)
-        # The callback is still delivered to the caller even if the sensor
-        # isn't found, only `extra_data` is skipped. That is to ensure the
-        # important callback isn't filtered
-        extra_data = sensor.extra_data if sensor else None
-        # Invoke the sensor activity callback to set the sensor occupancy if
-        # sensor is known, but only if that isn't already set - it helps when
-        # device notifications on triggerring sensor's activity aren't receveid
-        # by a reason
-        if sensor and not sensor.occupancy:
-            await self.on_sensor_activity(event_id, zone_name, True)
+        extra_data = None
+        if sensor:
+            # The callback is still delivered to the caller even if the sensor
+            # isn't found, only `extra_data` is skipped. That is to ensure the
+            # important callback isn't filtered
+            extra_data = sensor.extra_data
+
+            # Invoke the sensor activity callback to set the sensor occupancy
+            # if sensor is known, but only if that isn't already set - it helps
+            # when device notifications on triggerring sensor's activity aren't
+            # receveid by a reason
+            if not sensor.occupancy:
+                await self.on_sensor_activity(event_id, zone_name, True)
+
+            if is_tampered:
+                # Set the tampered flag on the sensor
+                # pylint: disable=protected-access
+                sensor._set_tampered(True)
+
+                # Invoke per-sensor callback if provided
+                G90Callback.invoke(sensor.tamper_callback)
+
+        # Invoke global tamper callback if provided and the sensor is tampered
+        if is_tampered:
+            G90Callback.invoke(self._tamper_cb, event_id, zone_name)
 
         G90Callback.invoke(
             self._alarm_cb, event_id, zone_name, extra_data
@@ -706,7 +767,10 @@ class G90Alarm(G90DeviceNotifications):
 
         # Also report the event as alarm for unification, hard-coding the
         # sensor name in case of host SOS
-        await self.on_alarm(event_id, 'Host SOS' if is_host_sos else zone_name)
+        await self.on_alarm(
+            event_id, zone_name='Host SOS' if is_host_sos else zone_name,
+            is_tampered=False
+        )
 
         if not is_host_sos:
             # Also report the remote button press for SOS - the panel will not
@@ -766,6 +830,58 @@ class G90Alarm(G90DeviceNotifications):
     ) -> None:
         self._remote_button_press_cb = value
 
+    async def on_door_open_when_arming(
+        self, event_id: int, zone_name: str
+    ) -> None:
+        """
+        Invoked when door is open when arming the device. Fires corresponding
+        callback if set by the user with
+        :attr:`.door_open_when_arming_callback`.
+
+        Please note the method is for internal use by the class.
+
+        :param event_id: The index of the sensor being active when the panel
+         is being armed.
+        :param zone_name: The name of the sensor
+        """
+        _LOGGER.debug('on_door_open_when_arming: %s %s', event_id, zone_name)
+        sensor = await self.find_sensor(event_id, zone_name)
+        if sensor:
+            # Set the low battery flag on the sensor
+            # pylint: disable=protected-access
+            sensor._set_door_open_when_arming(True)
+            # Invoke per-sensor callback if provided
+            G90Callback.invoke(sensor.door_open_when_arming_callback)
+
+        G90Callback.invoke(self._door_open_when_arming_cb, event_id, zone_name)
+
+    @property
+    def door_open_when_arming_callback(
+        self
+    ) -> Optional[DoorOpenWhenArmingCallback]:
+        """
+        Door open when arming callback, which is invoked when sensor reports
+        the condition.
+        """
+        return self._door_open_when_arming_cb
+
+    @door_open_when_arming_callback.setter
+    def door_open_when_arming_callback(
+        self, value: DoorOpenWhenArmingCallback
+    ) -> None:
+        self._door_open_when_arming_cb = value
+
+    @property
+    async def tamper_callback(self) -> Optional[TamperCallback]:
+        """
+        Tamper callback, which is invoked when sensor reports the condition.
+        """
+        return self._tamper_cb
+
+    @tamper_callback.setter
+    def tamper_callback(self, value: TamperCallback) -> None:
+        self._tamper_cb = value
+
     async def listen_device_notifications(self) -> None:
         """
         Starts internal listener for device notifications/alerts.

{pyg90alarm-1.17.1 → pyg90alarm-1.18.0}/src/pyg90alarm/const.py

@@ -201,6 +201,7 @@ class G90AlertSources(IntEnum):
     """
     DEVICE = 0
     SENSOR = 1
+    TAMPER = 3
     REMOTE = 10
     RFID = 11
     DOORBELL = 12

{pyg90alarm-1.17.1 → pyg90alarm-1.18.0}/src/pyg90alarm/device_notifications.py

@@ -159,6 +159,16 @@ class G90DeviceNotifications(DatagramProtocol):
 
             return
 
+        # An open door is detected when arming
+        if notification.kind == G90NotificationTypes.DOOR_OPEN_WHEN_ARMING:
+            g90_zone_info = G90ZoneInfo(*notification.data)
+            _LOGGER.debug('Door open detected when arming: %s', g90_zone_info)
+            G90Callback.invoke(
+                self.on_door_open_when_arming,
+                g90_zone_info.idx, g90_zone_info.name
+            )
+            return
+
         _LOGGER.warning('Unknown notification received from %s:%s:'
                         ' kind %s, data %s',
                         addr[0], addr[1], notification.kind, notification.data)
@@ -259,11 +269,15 @@ class G90DeviceNotifications(DatagramProtocol):
                 )
             # Regular alarm
             else:
-                _LOGGER.debug('Alarm: %s', alert.zone_name)
+                is_tampered = alert.state == G90AlertStates.TAMPER
+                _LOGGER.debug(
+                    'Alarm: %s, is tampered: %s', alert.zone_name, is_tampered
+                )
                 G90Callback.invoke(
                     self.on_alarm,
-                    alert.event_id, alert.zone_name
+                    alert.event_id, alert.zone_name, is_tampered
                 )
+
             handled = True
 
         # Host SOS
@@ -372,6 +386,16 @@ class G90DeviceNotifications(DatagramProtocol):
         :param name: Name of the sensor.
         """
 
+    async def on_door_open_when_arming(
+        self, event_id: int, zone_name: str
+    ) -> None:
+        """
+        Invoked when door open is detected when panel is armed.
+
+        :param event_id: Index of the sensor.
+        :param zone_name: Name of the sensor that reports door open.
+        """
+
     async def on_door_open_close(
         self, event_id: int, zone_name: str, is_open: bool
     ) -> None:
@@ -391,7 +415,9 @@ class G90DeviceNotifications(DatagramProtocol):
         :param zone_name: Name of the sensor that reports low battery.
         """
 
-    async def on_alarm(self, event_id: int, zone_name: str) -> None:
+    async def on_alarm(
+        self, event_id: int, zone_name: str, is_tampered: bool
+    ) -> None:
         """
         Invoked when device triggers the alarm.
 

{pyg90alarm-1.17.1 → pyg90alarm-1.18.0}/src/pyg90alarm/entities/sensor.py

@@ -32,7 +32,10 @@ from enum import IntEnum, IntFlag
 from ..definitions.sensors import SENSOR_DEFINITIONS, SensorDefinition
 from ..const import G90Commands
 if TYPE_CHECKING:
-    from ..alarm import G90Alarm, SensorStateCallback, SensorLowBatteryCallback
+    from ..alarm import (
+        G90Alarm, SensorStateCallback, SensorLowBatteryCallback,
+        SensorDoorOpenWhenArmingCallback, SensorTamperCallback,
+    )
 
 
 @dataclass
@@ -157,6 +160,7 @@ class G90SensorTypes(IntEnum):
 _LOGGER = logging.getLogger(__name__)
 
 
+# pylint: disable=too-many-public-methods
 class G90Sensor:  # pylint:disable=too-many-instance-attributes
     """
     Interacts with sensor on G90 alarm panel.
@@ -186,6 +190,12 @@ class G90Sensor:  # pylint:disable=too-many-instance-attributes
         self._state_callback: Optional[SensorStateCallback] = None
         self._low_battery_callback: Optional[SensorLowBatteryCallback] = None
         self._low_battery = False
+        self._tampered = False
+        self._door_open_when_arming_callback: Optional[
+            SensorDoorOpenWhenArmingCallback
+        ] = None
+        self._tamper_callback: Optional[SensorTamperCallback] = None
+        self._door_open_when_arming = False
         self._proto_idx = proto_idx
         self._extra_data: Any = None
 
@@ -238,6 +248,37 @@ class G90Sensor:  # pylint:disable=too-many-instance-attributes
     def low_battery_callback(self, value: SensorLowBatteryCallback) -> None:
         self._low_battery_callback = value
 
+    @property
+    def door_open_when_arming_callback(
+        self
+    ) -> Optional[SensorDoorOpenWhenArmingCallback]:
+        """
+        Callback that is invoked when the sensor reports on open door
+        condition when arming.
+
+        :return: Sensor's door open when arming callback
+        """
+        return self._door_open_when_arming_callback
+
+    @door_open_when_arming_callback.setter
+    def door_open_when_arming_callback(
+        self, value: SensorDoorOpenWhenArmingCallback
+    ) -> None:
+        self._door_open_when_arming_callback = value
+
+    @property
+    def tamper_callback(self) -> Optional[SensorTamperCallback]:
+        """
+        Callback that is invoked when the sensor reports being tampered.
+
+        :return: Sensor's tamper callback
+        """
+        return self._tamper_callback
+
+    @tamper_callback.setter
+    def tamper_callback(self, value: SensorTamperCallback) -> None:
+        self._tamper_callback = value
+
     @property
     def occupancy(self) -> bool:
         """
@@ -365,12 +406,16 @@ class G90Sensor:  # pylint:disable=too-many-instance-attributes
     def is_low_battery(self) -> bool:
         """
         Indicates if the sensor is reporting low battery.
+
+        The condition is cleared when the sensor reports activity (i.e. is no
+        longer low on battery as it is able to report the activity).
         """
         return self._low_battery
 
     def _set_low_battery(self, value: bool) -> None:
         """
         Sets low battery state of the sensor.
+
         Intentionally private, as low battery state is derived from
         notifications/alerts.
 
@@ -383,6 +428,56 @@ class G90Sensor:  # pylint:disable=too-many-instance-attributes
         )
         self._low_battery = value
 
+    @property
+    def is_tampered(self) -> bool:
+        """
+        Indicates if the sensor has been tampered.
+
+        The condition is cleared when panel is armed/disarmed next time.
+        """
+        return self._tampered
+
+    def _set_tampered(self, value: bool) -> None:
+        """
+        Sets tamper state of the sensor.
+
+        Intentionally private, as tamper state is derived from
+        notifications/alerts.
+
+        :param value: Tamper state
+        """
+        _LOGGER.debug(
+            "Setting tamper for sensor index=%s '%s': %s"
+            " (previous value: %s)",
+            self.index, self.name, value, self._tampered
+        )
+        self._tampered = value
+
+    @property
+    def is_door_open_when_arming(self) -> bool:
+        """
+        Indicates if the sensor reports on open door when arming.
+
+        The condition is cleared when panel is armed/disarmed next time.
+        """
+        return self._door_open_when_arming
+
+    def _set_door_open_when_arming(self, value: bool) -> None:
+        """
+        Sets door open state of the sensor when arming.
+
+        Intentionally private, as door open state is derived from
+        notifications/alerts.
+
+        :param value: Door open state
+        """
+        _LOGGER.debug(
+            "Setting door open when arming for sensor index=%s '%s': %s"
+            " (previous value: %s)",
+            self.index, self.name, value, self._door_open_when_arming
+        )
+        self._door_open_when_arming = value
+
     @property
     def enabled(self) -> bool:
         """

{pyg90alarm-1.17.1 → pyg90alarm-1.18.0}/src/pyg90alarm.egg-info/PKG-INFO

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

{pyg90alarm-1.17.1 → pyg90alarm-1.18.0}/tests/test_alarm.py

@@ -1,7 +1,10 @@
 """
 Tests for G90Alarm class
 """
+# pylint: disable=too-many-lines
+
 import asyncio
+from itertools import cycle
 from unittest.mock import MagicMock
 import pytest
 
@@ -128,6 +131,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 +239,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,""],'
@@ -387,6 +440,69 @@ async def test_sensor_low_battery_callback(mock_device: DeviceMock) -> None:
 
 
 @pytest.mark.g90device(
+    sent_data=[
+        b'ISTART[102,'
+        b'[[1,1,1],["Hall",21,0,10,1,0,32,0,0,16,1,0,""]]]IEND\0',
+    ],
+    notification_data=[
+        b'[170,[6,[21,"Hall"]]]\0',
+        b'[170,[1,[3]]]\0',
+    ]
+)
+async def test_sensor_door_open_when_arming_callback(
+    mock_device: DeviceMock
+) -> None:
+    """
+    Tests for sensor door open when arming callback.
+    """
+    g90 = G90Alarm(host=mock_device.host, port=mock_device.port,
+                   notifications_local_host=mock_device.notification_host,
+                   notifications_local_port=mock_device.notification_port)
+
+    sensors = await g90.get_sensors()
+    prop_sensors = await g90.sensors
+
+    assert sensors == prop_sensors
+    future = asyncio.get_running_loop().create_future()
+    sensor = [x for x in sensors if x.index == 21 and x.name == 'Hall']
+    door_open_when_arming_sensor_cb = MagicMock()
+    door_open_when_arming_sensor_cb.side_effect = (
+        lambda *args: future.set_result(True)
+    )
+    sensor[0].door_open_when_arming_callback = door_open_when_arming_sensor_cb
+    door_open_when_arming_cb = MagicMock()
+    g90.door_open_when_arming_callback = door_open_when_arming_cb
+
+    await g90.listen_device_notifications()
+    await mock_device.send_next_notification()
+    await asyncio.wait([future], timeout=0.1)
+
+    door_open_when_arming_sensor_cb.assert_called_once_with()
+    door_open_when_arming_cb.assert_called_once_with(21, 'Hall')
+    # Verify the door open when arming state is set upon receiving the
+    # notification
+    assert sensor[0].is_door_open_when_arming is True
+
+    # Signal the second notification is ready, the future has to be re-created
+    # as the corresponding callback will be fired again
+    future = asyncio.get_running_loop().create_future()
+    await mock_device.send_next_notification()
+    await asyncio.wait([future], timeout=0.1)
+
+    # Verify the door open when arming state is reset upon disarming
+    assert sensor[0].is_door_open_when_arming is False
+
+    g90.close_device_notifications()
+
+
+@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,""],'
+        b'["Remote 2",11,0,10,1,0,32,0,0,16,1,0,""],'
+        b'["Cord 1",12,0,126,1,0,32,0,5,16,1,0,""]'
+        b']]IEND\0',
+    ],
     notification_data=[
         b'[170,[1,[1]]]\0'
     ]
@@ -529,6 +645,65 @@ async def test_alarm_callback(mock_device: DeviceMock) -> None:
     g90.close_device_notifications()
 
 
+@pytest.mark.g90device(
+    sent_data=[
+        b'ISTART[102,'
+        b'[[1,1,1],["Hall",100,0,1,1,0,32,0,0,16,1,0,""]]]IEND\0',
+        # Alert configuration, used by sensor activity callback invoked when
+        # handling alarm
+        b'ISTART[117,[256]]IEND\0',
+    ],
+    notification_data=[
+        b'[208,[3,100,1,3,"Hall","DUMMYGUID",1630876128,0,[""]]]\0',
+        b'[170,[1,[3]]]\0',
+    ]
+)
+async def test_sensor_tamper_callback(
+    mock_device: DeviceMock
+) -> None:
+    """
+    Tests for sensor tamper callback.
+    """
+    g90 = G90Alarm(host=mock_device.host, port=mock_device.port,
+                   notifications_local_host=mock_device.notification_host,
+                   notifications_local_port=mock_device.notification_port)
+
+    sensors = await g90.get_sensors()
+    prop_sensors = await g90.sensors
+
+    assert sensors == prop_sensors
+    future = asyncio.get_running_loop().create_future()
+    sensor = [x for x in sensors if x.index == 100 and x.name == 'Hall']
+    tamper_sensor_cb = MagicMock()
+    tamper_sensor_cb.side_effect = (
+        lambda *args: future.set_result(True)
+    )
+    sensor[0].tamper_callback = tamper_sensor_cb
+    tamper_cb = MagicMock()
+    g90.tamper_callback = tamper_cb
+
+    await g90.listen_device_notifications()
+    await mock_device.send_next_notification()
+    await asyncio.wait([future], timeout=0.1)
+
+    tamper_sensor_cb.assert_called_once_with()
+    tamper_cb.assert_called_once_with(100, 'Hall')
+    # Verify the sensor tampered state is set upon receiving the
+    # notification
+    assert sensor[0].is_tampered is True
+
+    # Signal the second notification is ready, the future has to be re-created
+    # as the corresponding callback will be fired again
+    future = asyncio.get_running_loop().create_future()
+    await mock_device.send_next_notification()
+    await asyncio.wait([future], timeout=0.1)
+
+    # Verify the sensor tampered state is reset upon disarming
+    assert sensor[0].is_tampered is False
+
+    g90.close_device_notifications()
+
+
 @pytest.mark.g90device(
     sent_data=[
         b'ISTART[102,'
@@ -718,6 +893,13 @@ async def test_set_alert_config(mock_device: DeviceMock) -> None:
         # that checks if alert config has been modified externally
         b"ISTART[117,[1]]IEND\0",
         b"ISTARTIEND\0",
+        # Simulated list of sensors, which is used to reset door open when
+        # arming/tamper flags on those had the flags set when arming
+        b'ISTART[102,'
+        b'[[3,1,3],["Remote 1",10,0,10,1,0,32,0,0,16,1,0,""],'
+        b'["Remote 2",11,0,10,1,0,32,0,0,16,1,0,""],'
+        b'["Cord 1",12,0,126,1,0,32,0,5,16,1,0,""]'
+        b']]IEND\0',
     ],
     notification_data=[
         b'[170,[1,[1]]]\0',
@@ -739,11 +921,11 @@ async def test_sms_alert_when_armed(mock_device: DeviceMock) -> None:
     await mock_device.send_next_notification()
     await asyncio.wait([future], timeout=0.1)
     g90.close_device_notifications()
-    assert mock_device.recv_data == [
+    assert set([
         b'ISTART[117,117,""]IEND\0',
         b'ISTART[117,117,""]IEND\0',
         b"ISTART[116,116,[116,[513]]]IEND\0",
-    ]
+    ]).issubset(set(mock_device.recv_data))
 
 
 @pytest.mark.g90device(
@@ -752,6 +934,11 @@ async def test_sms_alert_when_armed(mock_device: DeviceMock) -> None:
         b"ISTART[117,[513]]IEND\0",
         b"ISTART[117,[513]]IEND\0",
         b"ISTARTIEND\0",
+        b'ISTART[102,'
+        b'[[3,1,3],["Remote 1",10,0,10,1,0,32,0,0,16,1,0,""],'
+        b'["Remote 2",11,0,10,1,0,32,0,0,16,1,0,""],'
+        b'["Cord 1",12,0,126,1,0,32,0,5,16,1,0,""]'
+        b']]IEND\0',
     ],
     notification_data=[
         b'[170,[1,[3]]]\0',
@@ -773,11 +960,11 @@ async def test_sms_alert_when_disarmed(mock_device: DeviceMock) -> None:
     await mock_device.send_next_notification()
     await asyncio.wait([future], timeout=0.1)
     g90.close_device_notifications()
-    assert mock_device.recv_data == [
+    assert set([
         b'ISTART[117,117,""]IEND\0',
         b'ISTART[117,117,""]IEND\0',
         b"ISTART[116,116,[116,[1]]]IEND\0",
-    ]
+    ]).issubset(set(mock_device.recv_data))
 
 
 @pytest.mark.g90device(sent_data=[

{pyg90alarm-1.17.1 → pyg90alarm-1.18.0}/tests/test_notifications.py

@@ -481,7 +481,31 @@ async def test_alarm_callback(mock_device: DeviceMock) -> None:
     await mock_device.send_next_notification()
     await asyncio.wait([future], timeout=0.1)
     notifications.close()
-    notifications.on_alarm.assert_called_once_with(11, 'Hall')
+    notifications.on_alarm.assert_called_once_with(11, 'Hall', False)
+
+
+@pytest.mark.g90device(notification_data=[
+    b'[208,[3,11,1,3,"Hall","DUMMYGUID",1630876128,0,[""]]]\0',
+])
+async def test_tamper_callback(mock_device: DeviceMock) -> None:
+    """
+    Verifies that alarm callback is handled correctly when a sensor is
+    tampered.
+    """
+    future = asyncio.get_running_loop().create_future()
+    notifications = G90DeviceNotifications(
+        local_host=mock_device.notification_host,
+        local_port=mock_device.notification_port
+    )
+    notifications.on_alarm = MagicMock()  # type: ignore[method-assign]
+    notifications.on_alarm.side_effect = (
+        lambda *args: future.set_result(True)
+    )
+    await notifications.listen()
+    await mock_device.send_next_notification()
+    await asyncio.wait([future], timeout=0.1)
+    notifications.close()
+    notifications.on_alarm.assert_called_once_with(11, 'Hall', True)
 
 
 @pytest.mark.g90device(notification_data=[
@@ -541,3 +565,29 @@ async def test_low_battery_callback(mock_device: DeviceMock) -> None:
     await asyncio.wait([future], timeout=0.1)
     notifications.close()
     notifications.on_low_battery.assert_called_once_with(26, 'Hall')
+
+
+@pytest.mark.g90device(notification_data=[
+    b'[170,[6,[21,"Hall"]]]\0'
+])
+async def test_door_open_when_arming_callback(mock_device: DeviceMock) -> None:
+    """
+    Verifies that door open when arming callback is handled correctly.
+    """
+    future = asyncio.get_running_loop().create_future()
+    notifications = G90DeviceNotifications(
+        local_host=mock_device.notification_host,
+        local_port=mock_device.notification_port
+    )
+
+    notifications.on_door_open_when_arming = (  # type: ignore[method-assign]
+        MagicMock()
+    )
+    notifications.on_door_open_when_arming.side_effect = (
+        lambda *args: future.set_result(True)
+    )
+    await notifications.listen()
+    await mock_device.send_next_notification()
+    await asyncio.wait([future], timeout=0.1)
+    notifications.close()
+    notifications.on_door_open_when_arming.assert_called_once_with(21, 'Hall')

{pyg90alarm-1.17.1 → pyg90alarm-1.18.0}/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