pyg90alarm 1.17.2__tar.gz → 1.19.0__tar.gz

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

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

{pyg90alarm-1.17.2 → pyg90alarm-1.19.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
@@ -174,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
@@ -613,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
@@ -627,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`.
@@ -638,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
@@ -718,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
@@ -778,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.2 → pyg90alarm-1.19.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.2 → pyg90alarm-1.19.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.2 → pyg90alarm-1.19.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
@@ -101,6 +104,16 @@ class G90SensorUserFlags(IntFlag):
     ALERT_WHEN_AWAY_AND_HOME = 32
     ALERT_WHEN_AWAY = 64
     SUPPORTS_UPDATING_SUBTYPE = 512     # Only relevant for cord sensors
+    # Flags that can be set by the user
+    USER_SETTABLE = (
+        ENABLED
+        | ARM_DELAY
+        | DETECT_DOOR
+        | DOOR_CHIME
+        | INDEPENDENT_ZONE
+        | ALERT_WHEN_AWAY_AND_HOME
+        | ALERT_WHEN_AWAY
+    )
 
 
 class G90SensorProtocols(IntEnum):
@@ -157,6 +170,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 +200,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 +258,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 +416,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 +438,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:
         """
@@ -392,18 +497,26 @@ class G90Sensor:  # pylint:disable=too-many-instance-attributes
         """
         return self.user_flag & G90SensorUserFlags.ENABLED != 0
 
-    async def set_enabled(self, value: bool) -> None:
+    async def set_user_flag(self, value: G90SensorUserFlags) -> None:
         """
-        Sets disabled/enabled state of the sensor.
+        Sets user flags of the sensor.
 
-        :param value: Whether to enable or disable the sensor
+        :param value: User flags to set, values other than
+          :attr:`.G90SensorUserFlags.USER_SETTABLE` will be ignored and
+          preserved from existing sensor flags.
         """
+        if value & ~G90SensorUserFlags.USER_SETTABLE:
+            _LOGGER.warning(
+                'User flags for sensor index=%s contain non-user settable'
+                ' flags, those will be ignored: %s',
+                self.index, repr(value & ~G90SensorUserFlags.USER_SETTABLE)
+            )
         # Checking private attribute directly, since `mypy` doesn't recognize
         # the check for sensor definition to be defined if done over
         # `self.supports_enable_disable` property
         if not self._definition:
             _LOGGER.warning(
-                'Manipulating with enable/disable for sensor index=%s'
+                'Manipulating with user flags for sensor index=%s'
                 ' is unsupported - no sensor definition for'
                 ' type=%s, subtype=%s',
                 self.index,
@@ -431,7 +544,7 @@ class G90Sensor:  # pylint:disable=too-many-instance-attributes
         if not sensors:
             _LOGGER.error(
                 'Sensor index=%s not found when attempting to set its'
-                ' enable/disable state',
+                ' user flag',
                 self.index,
             )
             return
@@ -444,30 +557,30 @@ class G90Sensor:  # pylint:disable=too-many-instance-attributes
         ) != self._protocol_data:
             _LOGGER.error(
                 "Sensor index=%s '%s' has been changed externally,"
-                " refusing to alter its enable/disable state",
+                " refusing to alter its user flag",
                 self.index,
                 self.name
             )
             return
 
-        # Modify the value of the user flag setting enabled/disabled one
-        # appropriately.
-        user_flag = self.user_flag
-        if value:
-            user_flag |= G90SensorUserFlags.ENABLED
-        else:
-            user_flag &= ~G90SensorUserFlags.ENABLED
+        prev_user_flag = self.user_flag
 
         # Re-instantiate the protocol data with modified user flags
         _data = asdict(self._protocol_data)
-        _data['user_flag_data'] = user_flag
+        _data['user_flag_data'] = (
+            # Preserve flags that are not user-settable
+            self.user_flag & ~G90SensorUserFlags.USER_SETTABLE
+        ) | (
+            # Combine them with the new user-settable flags
+            value & G90SensorUserFlags.USER_SETTABLE
+        )
         self._protocol_data = self._protocol_incoming_data_kls(**_data)
 
         _LOGGER.debug(
-            'Sensor index=%s: %s enabled flag, resulting user_flag %s',
+            'Sensor index=%s: previous user_flag %s, resulting user_flag %s',
             self._protocol_data.index,
-            'Setting' if value else 'Clearing',
-            self.user_flag
+            repr(prev_user_flag),
+            repr(self.user_flag)
         )
 
         # Generate protocol data from write operation, deriving values either
@@ -494,6 +607,20 @@ class G90Sensor:  # pylint:disable=too-many-instance-attributes
             G90Commands.SETSINGLESENSOR, list(astuple(outgoing_data))
         )
 
+    async def set_enabled(self, value: bool) -> None:
+        """
+        Sets the sensor enabled/disabled.
+        """
+
+        # Modify the value of the user flag setting enabled/disabled one
+        # appropriately.
+        user_flag = self.user_flag
+        if value:
+            user_flag |= G90SensorUserFlags.ENABLED
+        else:
+            user_flag &= ~G90SensorUserFlags.ENABLED
+        await self.set_user_flag(user_flag)
+
     @property
     def extra_data(self) -> Any:
         """
@@ -528,6 +655,8 @@ class G90Sensor:  # pylint:disable=too-many-instance-attributes
             'supports_enable_disable': self.supports_enable_disable,
             'is_wireless': self.is_wireless,
             'is_low_battery': self.is_low_battery,
+            'is_tampered': self.is_tampered,
+            'is_door_open_when_arming': self.is_door_open_when_arming,
         }
 
     def __repr__(self) -> str:

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

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

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

@@ -1,6 +1,8 @@
 """
 Tests for G90Alarm class
 """
+# pylint: disable=too-many-lines
+
 import asyncio
 from itertools import cycle
 from unittest.mock import MagicMock
@@ -13,7 +15,7 @@ from pyg90alarm.host_info import (
     G90HostInfo, G90HostInfoGsmStatus, G90HostInfoWifiStatus,
 )
 from pyg90alarm.entities.sensor import (
-    G90Sensor,
+    G90Sensor, G90SensorUserFlags,
 )
 from pyg90alarm.entities.device import (
     G90Device,
@@ -438,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'
     ]
@@ -580,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,'
@@ -769,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',
@@ -790,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(
@@ -803,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',
@@ -824,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=[
@@ -963,3 +1099,36 @@ async def test_device_unsupported_disable(mock_device: DeviceMock) -> None:
     assert mock_device.recv_data == [
         b'ISTART[138,138,[138,[1,10]]]IEND\0',
     ]
+
+
+@pytest.mark.g90device(sent_data=[
+    b'ISTART[102,'
+    b'[[1,1,1],'
+    b'["Night Light2",10,0,138,0,0,33,0,0,17,1,0,""]'
+    b']]IEND\0',
+    b'ISTART[102,'
+    b'[[1,1,1],'
+    b'["Night Light2",10,0,138,0,0,33,0,0,17,1,0,""]'
+    b']]IEND\0',
+    b"ISTARTIEND\0",
+])
+async def test_sensor_set_user_flags(mock_device: DeviceMock) -> None:
+    """
+    Tests for setting user flags on a sensor.
+    """
+    g90 = G90Alarm(host=mock_device.host, port=mock_device.port)
+    sensors = await g90.get_sensors()
+    await sensors[0].set_user_flag(
+        # Intentionally contains non-user settable flag, which should be
+        # ignored and not configured for the sensor that initial doesn't have
+        # it set
+        G90SensorUserFlags.INDEPENDENT_ZONE | G90SensorUserFlags.ARM_DELAY
+        | G90SensorUserFlags.SUPPORTS_UPDATING_SUBTYPE
+    )
+    assert mock_device.recv_data == [
+        b'ISTART[102,102,[102,[1,10]]]IEND\0',
+        b'ISTART[102,102,[102,[1,1]]]IEND\0',
+        b'ISTART[103,103,[103,'
+        b'["Night Light2",10,0,138,0,0,18,0,0,17,1,0,2,"060A0600"]'
+        b']]IEND\0',
+    ]

{pyg90alarm-1.17.2 → pyg90alarm-1.19.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')