pyg90alarm 1.17.1__py3-none-any.whl → 1.18.0__py3-none-any.whl

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/const.py

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

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/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.dist-info → pyg90alarm-1.18.0.dist-info}/METADATA

@@ -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.dist-info → pyg90alarm-1.18.0.dist-info}/RECORD

@@ -1,10 +1,10 @@
 pyg90alarm/__init__.py,sha256=5AITRm5jZSzuQaL7PS8fZZMZb4-IuGRhSqyAdfTt0Cs,2236
-pyg90alarm/alarm.py,sha256=GMft1R4Yp70VeWQLHApE8yVcfsDBbzhbHj1rc_gIj8k,35947
+pyg90alarm/alarm.py,sha256=dOhe2C2zsJ55VE5NJF-PE7pKRF_YOCF70ACJbDYEgF8,40196
 pyg90alarm/base_cmd.py,sha256=Bz7yoZ0RpkcjWARya664DKAPo3goD6BeaKtuW-hA804,9902
 pyg90alarm/callback.py,sha256=3JsD_JChmZD24OyjaCP-PxxuBDBX7myGYhkM4RN7bk4,3742
 pyg90alarm/config.py,sha256=2YtIgdT7clQXmYvkdn_fhIdS05CY8E1Yc90R8_tAmRI,1961
-pyg90alarm/const.py,sha256=0EkfCtySEPi6W0TO-j-F1y7_MVFaMOuKDY1Bx6QGDDQ,6617
-pyg90alarm/device_notifications.py,sha256=61oruR70snBRXNzOfj313TO7p2TmbEk-dH9AA1nkDkY,16687
+pyg90alarm/const.py,sha256=uBzDUSlVO3FZxLI11bzfCm6JTI2_ciageyf43JLSehg,6632
+pyg90alarm/device_notifications.py,sha256=pqkeKYORUUZUEovUKajuu8JHCtXD0ulAZIKelNfn2Eg,17602
 pyg90alarm/discovery.py,sha256=fwyBHDCKGej06OwhpbVCHYTRU9WWkeYysAFgv3FiwqI,3575
 pyg90alarm/exceptions.py,sha256=eiOcRe7D18EIPyPFDNU9DdFgbnkwPmkiLl8lGPOhBNw,1475
 pyg90alarm/history.py,sha256=5NfgB0V-7TZlMNHEjtRbOA0ZtJfQTgh2ysZIg5RM7ck,9080
@@ -19,9 +19,9 @@ pyg90alarm/definitions/__init__.py,sha256=s0NZnkW_gMH718DJbgez28z9WA231CyszUf1O_
 pyg90alarm/definitions/sensors.py,sha256=rKOu21ZpI44xk6aMh_vBjniFqnsNTc1CKwAvnv4PYLQ,19904
 pyg90alarm/entities/__init__.py,sha256=hHb6AOiC4Tz--rOWiiICMdLaZDs1Tf_xpWk_HeS_gO4,66
 pyg90alarm/entities/device.py,sha256=f_LHvKCAqTEebZ4mrRh3CpPUI7o-OvpvOfyTRCbftJs,2818
-pyg90alarm/entities/sensor.py,sha256=4r8ouAYTZB8ih8I4ncWdQOaifYsRxaC-ukY9jvnrRvk,16139
-pyg90alarm-1.17.1.dist-info/LICENSE,sha256=f884inRbeNv-O-hbwz62Ro_1J8xiHRTnJ2cCx6A0WvU,1070
-pyg90alarm-1.17.1.dist-info/METADATA,sha256=7lYmor4_swZNNn3P2yF7FRse5Hz4X3xpgAeNE55t0LA,7714
-pyg90alarm-1.17.1.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-pyg90alarm-1.17.1.dist-info/top_level.txt,sha256=czHiGxYMyTk5QEDTDb0EpPiKqUMRa8zI4zx58Ii409M,11
-pyg90alarm-1.17.1.dist-info/RECORD,,
+pyg90alarm/entities/sensor.py,sha256=G9WoFL32Kjh8qgHyyO_Yn2gZkDkkxjNIdKV1DnmkhnU,19125
+pyg90alarm-1.18.0.dist-info/LICENSE,sha256=f884inRbeNv-O-hbwz62Ro_1J8xiHRTnJ2cCx6A0WvU,1070
+pyg90alarm-1.18.0.dist-info/METADATA,sha256=xHpDuXsOvtcHmIS7-lPEeQ6nHG6NkuBZLW-eMEJoroY,7714
+pyg90alarm-1.18.0.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+pyg90alarm-1.18.0.dist-info/top_level.txt,sha256=czHiGxYMyTk5QEDTDb0EpPiKqUMRa8zI4zx58Ii409M,11
+pyg90alarm-1.18.0.dist-info/RECORD,,