pyg90alarm 1.17.2__py3-none-any.whl → 1.20.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.
@@ -68,7 +69,9 @@ from .const import (
 from .base_cmd import (G90BaseCommand, G90BaseCommandData)
 from .paginated_result import G90PaginatedResult, G90PaginatedResponse
 from .entities.sensor import (G90Sensor, G90SensorTypes)
+from .entities.sensor_list import G90SensorList
 from .entities.device import G90Device
+from .entities.device_list import G90DeviceList
 from .device_notifications import (
     G90DeviceNotifications,
 )
@@ -120,6 +123,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 +142,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
@@ -160,10 +179,8 @@ 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._sensors = G90SensorList(self)
+        self._devices = G90DeviceList(self)
         self._notifications: Optional[G90DeviceNotifications] = None
         self._sensor_cb: Optional[SensorCallback] = None
         self._armdisarm_cb: Optional[ArmDisarmCallback] = None
@@ -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
@@ -247,109 +268,58 @@ class G90Alarm(G90DeviceNotifications):
     @property
     async def sensors(self) -> List[G90Sensor]:
         """
-        Property over new :meth:`.get_sensors` method, retained for
-        compatibility.
+        Returns the list of sensors configured in the device. Please note
+        it doesn't update those from the panel except initially when the list
+        if empty.
+
+        :return: List of sensors
         """
-        return await self.get_sensors()
+        return await self._sensors.entities
 
     async def get_sensors(self) -> List[G90Sensor]:
         """
-        Provides list of sensors configured in the device. Please note the list
-        is cached upon first call, so you need to re-instantiate the class to
-        reflect any updates there.
+        Provides list of sensors configured in the device, updating them from
+        panel on each call.
 
         :return: List of sensors
         """
-        # 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
-                )
-                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)
-                )
+        return await self._sensors.update()
 
-            return self._sensors
-
-    async def find_sensor(self, idx: int, name: str) -> Optional[G90Sensor]:
+    async def find_sensor(
+        self, idx: int, name: str, exclude_unavailable: bool = True
+    ) -> Optional[G90Sensor]:
         """
         Finds sensor by index and name.
 
         :param idx: Sensor index
         :param name: Sensor name
+        :param exclude_unavailable: Flag indicating if unavailable sensors
+         should be excluded from the search
         :return: Sensor instance
         """
-        sensors = await self.get_sensors()
-
-        # Fast lookup by direct index
-        if idx < len(sensors) and sensors[idx].name == name:
-            sensor = sensors[idx]
-            _LOGGER.debug('Found sensor via fast lookup: %s', sensor)
-            return sensor
-
-        # Fast lookup failed, perform slow one over the whole sensors list
-        for sensor in sensors:
-            if sensor.index == idx and sensor.name == name:
-                _LOGGER.debug('Found sensor: %s', sensor)
-                return sensor
-
-        _LOGGER.error('Sensor not found: idx=%s, name=%s', idx, name)
-        return None
+        return await self._sensors.find(idx, name, exclude_unavailable)
 
     @property
     async def devices(self) -> List[G90Device]:
         """
-        Property over new :meth:`.get_devices` method, retained for
-        compatibility.
+        Returns the list of devices (switches) configured in the device. Please
+        note it doesn't update those from the panel except initially when
+        the list if empty.
+
+        :return: List of devices
         """
-        return await self.get_devices()
+        return await self._devices.entities
 
     async def get_devices(self) -> List[G90Device]:
         """
-        Provides list of devices (switches) configured in the device. Please
-        note the list is cached upon first call, so you need to re-instantiate
-        the class to reflect any updates there. Multi-node devices, those
+        Provides list of devices (switches) configured in the device, updating
+        them from panel on each call. Multi-node devices, those
         having multiple ports, are expanded into corresponding number of
         resulting entries.
 
         :return: List of devices
         """
-        # 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
-                )
-                async for device in devices:
-                    obj = G90Device(
-                        *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)
-                )
-
-            return self._devices
+        return await self._devices.update()
 
     @property
     async def host_info(self) -> G90HostInfo:
@@ -613,6 +583,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.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 +608,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 +621,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 +716,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 +779,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/base_entity.py

@@ -0,0 +1,83 @@
+# Copyright (c) 2025 Ilia Sotnikov
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# 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.
+"""
+Base entity.
+"""
+from abc import ABC, abstractmethod
+# `Self` has been introduced in Python 3.11, need to use `typing_extensions`
+# for earlier versions
+try:
+    from typing import Self  # type: ignore[attr-defined,unused-ignore]
+except ImportError:
+    from typing_extensions import Self
+
+
+class G90BaseEntity(ABC):
+    """
+    Base entity class.
+
+    Contains minimal set of method for :class:`.G90BaseList` class
+    """
+    @abstractmethod
+    def update(
+        self,
+        obj: Self  # pylint: disable=used-before-assignment
+    ) -> None:
+        """
+        Update the entity from another one.
+
+        :param obj: Object to update from.
+        """
+
+    @property
+    @abstractmethod
+    def is_unavailable(self) -> bool:
+        """
+        Check if the entity is unavailable.
+
+        :return: True if the entity is unavailable.
+        """
+
+    @is_unavailable.setter
+    @abstractmethod
+    def is_unavailable(self, value: bool) -> None:
+        """
+        Set the entity as unavailable.
+
+        :param value: Value to set.
+        """
+
+    @property
+    @abstractmethod
+    def name(self) -> str:
+        """
+        Get the name of the entity.
+
+        :return: Name of the entity.
+        """
+
+    @property
+    @abstractmethod
+    def index(self) -> int:
+        """
+        Get the index of the entity.
+
+        :return: Index of the entity.
+        """

pyg90alarm/entities/base_list.py

@@ -0,0 +1,165 @@
+# Copyright (c) 2025 Ilia Sotnikov
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# 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.
+
+"""
+Base entity list.
+"""
+from abc import ABC, abstractmethod
+from typing import (
+    List, AsyncGenerator, Optional, TypeVar, Generic, cast, TYPE_CHECKING,
+)
+import asyncio
+import logging
+
+from .base_entity import G90BaseEntity
+if TYPE_CHECKING:
+    from ..alarm import G90Alarm
+else:
+    # Alias G90Alarm to object avoid circular imports
+    # (`G90Alarm` -> `G90SensorList` -> `G90BaseList` -> `G90Alarm`)
+    G90Alarm = object
+
+T = TypeVar('T', bound=G90BaseEntity)
+_LOGGER = logging.getLogger(__name__)
+
+
+class G90BaseList(Generic[T], ABC):
+    """
+    Base entity list class.
+
+    :param parent: Parent alarm panel instance.
+    """
+    def __init__(self, parent: G90Alarm) -> None:
+        self._entities: List[T] = []
+        self._lock = asyncio.Lock()
+        self._parent = parent
+
+    @abstractmethod
+    async def _fetch(self) -> AsyncGenerator[T, None]:
+        """
+        Fetch the list of entities from the panel.
+
+        :return: Async generator of entities
+        """
+        yield cast(T, None)
+
+    @property
+    async def entities(self) -> List[T]:
+        """
+        Return the list of entities.
+
+        :meth:`update` is called if the list is empty.
+
+        :return: List of entities
+        """
+        # Please see below for the explanation of the lock usage
+        async with self._lock:
+            entities = self._entities
+
+        if not entities:
+            return await self.update()
+
+        return entities
+
+    async def update(self) -> List[T]:
+        """
+        Update the list of entities from the panel.
+
+        :return: List of entities
+        """
+        # 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._lock:
+            entities = self._fetch()
+
+            non_existing_entities = self._entities.copy()
+            async for entity in entities:
+                try:
+                    existing_entity_idx = self._entities.index(entity)
+                except ValueError:
+                    existing_entity_idx = None
+
+                if existing_entity_idx is not None:
+                    existing_entity = self._entities[existing_entity_idx]
+                    # Update the existing entity with the new data
+                    _LOGGER.debug(
+                        "Updating existing entity '%s' from protocol"
+                        " data '%s'", existing_entity, entity
+                    )
+
+                    self._entities[existing_entity_idx].update(entity)
+                    non_existing_entities.remove(entity)
+                else:
+                    # Add the new entity to the list
+                    _LOGGER.debug('Adding new entity: %s', entity)
+                    self._entities.append(entity)
+
+            # Mark the entities that are no longer in the list
+            for unavailable_entity in non_existing_entities:
+                _LOGGER.debug(
+                    'Marking entity as unavailable: %s', unavailable_entity
+                )
+                unavailable_entity.is_unavailable = True
+
+            _LOGGER.debug(
+                'Total number of entities: %s, unavailable: %s',
+                len(self._entities), len(non_existing_entities)
+            )
+
+            return self._entities
+
+    async def find(
+        self, idx: int, name: str, exclude_unavailable: bool
+    ) -> Optional[T]:
+        """
+        Finds entity by index and name.
+
+        :param idx: Entity index
+        :param name: Entity name
+        :param exclude_unavailable: Exclude unavailable entities
+        :return: Entity instance
+        """
+        entities = await self.entities
+
+        found = None
+        # Fast lookup by direct index
+        if idx < len(entities) and entities[idx].name == name:
+            entity = entities[idx]
+            _LOGGER.debug('Found entity via fast lookup: %s', entity)
+            found = entity
+
+        # Fast lookup failed, perform slow one over the whole entities list
+        if not found:
+            for entity in entities:
+                if entity.index == idx and entity.name == name:
+                    _LOGGER.debug('Found entity: %s', entity)
+                    found = entity
+
+        if found:
+            if not exclude_unavailable or not found.is_unavailable:
+                return found
+
+            _LOGGER.debug(
+                'Entity is found but unavailable, will result in none returned'
+            )
+
+        _LOGGER.error('Entity not found: idx=%s, name=%s', idx, name)
+        return None

pyg90alarm/entities/device_list.py

@@ -0,0 +1,58 @@
+# Copyright (c) 2025 Ilia Sotnikov
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# 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.
+"""
+Device list.
+"""
+from typing import AsyncGenerator
+from .device import G90Device
+from .base_list import G90BaseList
+from ..const import G90Commands
+
+
+class G90DeviceList(G90BaseList[G90Device]):
+    """
+    Device list class.
+    """
+    async def _fetch(self) -> AsyncGenerator[G90Device, None]:
+        """
+        Fetch the list of devices from the panel.
+
+        :yields: G90Device: Device entity.
+        """
+        devices = self._parent.paginated_result(
+            G90Commands.GETDEVICELIST
+        )
+
+        async for device in devices:
+            obj = G90Device(
+                *device.data, parent=self._parent, subindex=0,
+                proto_idx=device.proto_idx
+            )
+
+            yield obj
+
+            # Multi-node devices (first node has already been handled
+            # above)
+            for node in range(1, obj.node_count):
+                obj = G90Device(
+                    *device.data, parent=self._parent,
+                    subindex=node, proto_idx=device.proto_idx
+                )
+                yield obj

pyg90alarm/entities/sensor.py

@@ -31,8 +31,12 @@ from typing import (
 from enum import IntEnum, IntFlag
 from ..definitions.sensors import SENSOR_DEFINITIONS, SensorDefinition
 from ..const import G90Commands
+from .base_entity import G90BaseEntity
 if TYPE_CHECKING:
-    from ..alarm import G90Alarm, SensorStateCallback, SensorLowBatteryCallback
+    from ..alarm import (
+        G90Alarm, SensorStateCallback, SensorLowBatteryCallback,
+        SensorDoorOpenWhenArmingCallback, SensorTamperCallback,
+    )
 
 
 @dataclass
@@ -101,6 +105,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,7 +171,8 @@ class G90SensorTypes(IntEnum):
 _LOGGER = logging.getLogger(__name__)
 
 
-class G90Sensor:  # pylint:disable=too-many-instance-attributes
+# pylint: disable=too-many-public-methods
+class G90Sensor(G90BaseEntity):  # pylint:disable=too-many-instance-attributes
     """
     Interacts with sensor on G90 alarm panel.
 
@@ -186,8 +201,15 @@ 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
+        self._unavailable = False
 
         self._definition: Optional[SensorDefinition] = None
         # Get sensor definition corresponds to the sensor type/subtype if any
@@ -199,6 +221,15 @@ class G90Sensor:  # pylint:disable=too-many-instance-attributes
                 self._definition = s_def
                 break
 
+    def update(self, obj: G90Sensor) -> None:
+        """
+        Updates sensor from another instance.
+
+        :param obj: Sensor instance to update from
+        """
+        self._protocol_data = obj.protocol_data
+        self._proto_idx = obj.proto_idx
+
     @property
     def name(self) -> str:
         """
@@ -238,6 +269,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:
         """
@@ -345,6 +407,16 @@ class G90Sensor:  # pylint:disable=too-many-instance-attributes
         """
         return self._subindex
 
+    @property
+    def proto_idx(self) -> int:
+        """
+        Index of the sensor within list of sensors as retrieved from the alarm
+        panel.
+
+        :return: Index of sensor in list of sensors.
+        """
+        return self._proto_idx
+
     @property
     def supports_enable_disable(self) -> bool:
         """
@@ -354,6 +426,15 @@ class G90Sensor:  # pylint:disable=too-many-instance-attributes
         """
         return self._definition is not None
 
+    @property
+    def protocol_data(self) -> G90SensorIncomingData:
+        """
+        Protocol data of the sensor.
+
+        :return: Protocol data
+        """
+        return self._protocol_data
+
     @property
     def is_wireless(self) -> bool:
         """
@@ -365,12 +446,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 +468,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 +527,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,
@@ -419,11 +562,11 @@ class G90Sensor:  # pylint:disable=too-many-instance-attributes
         # when instantiated.
         _LOGGER.debug(
             'Refreshing sensor at index=%s, position in protocol list=%s',
-            self.index, self._proto_idx
+            self.index, self.proto_idx
         )
         sensors_result = self.parent.paginated_result(
             G90Commands.GETSENSORLIST,
-            start=self._proto_idx, end=self._proto_idx
+            start=self.proto_idx, end=self.proto_idx
         )
         sensors = [x.data async for x in sensors_result]
 
@@ -431,7 +574,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 +587,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 +637,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:
         """
@@ -506,6 +663,17 @@ class G90Sensor:  # pylint:disable=too-many-instance-attributes
     def extra_data(self, val: Any) -> None:
         self._extra_data = val
 
+    @property
+    def is_unavailable(self) -> bool:
+        """
+        Indicates if the sensor is unavailable (e.g. has been removed).
+        """
+        return self._unavailable
+
+    @is_unavailable.setter
+    def is_unavailable(self, value: bool) -> None:
+        self._unavailable = value
+
     def _asdict(self) -> Dict[str, Any]:
         """
         Returns dictionary representation of the sensor.
@@ -517,6 +685,7 @@ class G90Sensor:  # pylint:disable=too-many-instance-attributes
             'type': self.type,
             'subtype': self.subtype,
             'index': self.index,
+            'protocol_index': self.proto_idx,
             'subindex': self.subindex,
             'node_count': self.node_count,
             'protocol': self.protocol,
@@ -528,6 +697,9 @@ 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,
+            'is_unavailable': self.is_unavailable,
         }
 
     def __repr__(self) -> str:
@@ -537,3 +709,20 @@ class G90Sensor:  # pylint:disable=too-many-instance-attributes
         :return: String representation
         """
         return super().__repr__() + f'({repr(self._asdict())})'
+
+    def __eq__(self, value: object) -> bool:
+        """
+        Compares the sensor with another object.
+
+        :param value: Object to compare with
+        :return: If the sensor is equal to the object
+        """
+        if not isinstance(value, G90Sensor):
+            return False
+
+        return (
+            self.type == value.type
+            and self.subtype == value.subtype
+            and self.index == value.index
+            and self.name == value.name
+        )

pyg90alarm/entities/sensor_list.py

@@ -0,0 +1,50 @@
+# Copyright (c) 2025 Ilia Sotnikov
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# 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.
+"""
+Sensor list.
+"""
+from typing import (
+    AsyncGenerator
+)
+
+from .sensor import G90Sensor
+from .base_list import G90BaseList
+from ..const import G90Commands
+
+
+class G90SensorList(G90BaseList[G90Sensor]):
+    """
+    Sensor list class.
+    """
+    async def _fetch(self) -> AsyncGenerator[G90Sensor, None]:
+        """
+        Fetch the list of sensors from the panel.
+
+        :yields: G90Sensor: Sensor entity.
+        """
+        entities = self._parent.paginated_result(
+            G90Commands.GETSENSORLIST
+        )
+
+        async for entity in entities:
+            yield G90Sensor(
+                *entity.data, parent=self._parent, subindex=0,
+                proto_idx=entity.proto_idx
+            )

{pyg90alarm-1.17.2.dist-info → pyg90alarm-1.20.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: pyg90alarm
-Version: 1.17.2
+Version: 1.20.0
 Summary: G90 Alarm system protocol
 Home-page: https://github.com/hostcc/pyg90alarm
 Author: Ilia Sotnikov
@@ -33,6 +33,17 @@ Requires-Dist: asynctest; extra == "test"
 Provides-Extra: docs
 Requires-Dist: sphinx; extra == "docs"
 Requires-Dist: sphinx-rtd-theme; extra == "docs"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: project-url
+Dynamic: provides-extra
+Dynamic: requires-python
+Dynamic: summary
 
 .. image::  https://github.com/hostcc/pyg90alarm/actions/workflows/main.yml/badge.svg?branch=master
    :target: https://github.com/hostcc/pyg90alarm/tree/master

{pyg90alarm-1.17.2.dist-info → pyg90alarm-1.20.0.dist-info}/RECORD

@@ -1,10 +1,10 @@
 pyg90alarm/__init__.py,sha256=5AITRm5jZSzuQaL7PS8fZZMZb4-IuGRhSqyAdfTt0Cs,2236
-pyg90alarm/alarm.py,sha256=nTP0JrXQCqLz_lhA9F_AHK3CPNbYMt3gSeQVOL9QSpI,36589
+pyg90alarm/alarm.py,sha256=YMqf5nyoqQVZPJJB2vRXzWcHNcRjfVGojN7KDBM-KS8,38093
 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
@@ -18,10 +18,14 @@ pyg90alarm/user_data_crc.py,sha256=JQBOPY3RlOgVtvR55R-rM8OuKjYW-BPXQ0W4pi6CEH0,1
 pyg90alarm/definitions/__init__.py,sha256=s0NZnkW_gMH718DJbgez28z9WA231CyszUf1O_ojUiI,68
 pyg90alarm/definitions/sensors.py,sha256=rKOu21ZpI44xk6aMh_vBjniFqnsNTc1CKwAvnv4PYLQ,19904
 pyg90alarm/entities/__init__.py,sha256=hHb6AOiC4Tz--rOWiiICMdLaZDs1Tf_xpWk_HeS_gO4,66
+pyg90alarm/entities/base_entity.py,sha256=Ea1r1aP7FMnOiEPhBhkrndmcr5Iy8jcfQuuXCNHajrU,2473
+pyg90alarm/entities/base_list.py,sha256=76DUtdXTwd26vv6HIw_qdtBNd1FqMfoRf0VI9KxV5aA,5703
 pyg90alarm/entities/device.py,sha256=f_LHvKCAqTEebZ4mrRh3CpPUI7o-OvpvOfyTRCbftJs,2818
-pyg90alarm/entities/sensor.py,sha256=4r8ouAYTZB8ih8I4ncWdQOaifYsRxaC-ukY9jvnrRvk,16139
-pyg90alarm-1.17.2.dist-info/LICENSE,sha256=f884inRbeNv-O-hbwz62Ro_1J8xiHRTnJ2cCx6A0WvU,1070
-pyg90alarm-1.17.2.dist-info/METADATA,sha256=8PoCUW_lwXEsjV5MZUGOb362h7C2JL0PHIOlEWr8twk,7714
-pyg90alarm-1.17.2.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-pyg90alarm-1.17.2.dist-info/top_level.txt,sha256=czHiGxYMyTk5QEDTDb0EpPiKqUMRa8zI4zx58Ii409M,11
-pyg90alarm-1.17.2.dist-info/RECORD,,
+pyg90alarm/entities/device_list.py,sha256=FrsfzP1BgwCKOn6bzVUpQHdatB6MUcWhPeuaJ3c5mqg,2154
+pyg90alarm/entities/sensor.py,sha256=ax-6ttps7sCWfuP6CcnS00Zy5WZVKleO8vAsdhU3KQc,21986
+pyg90alarm/entities/sensor_list.py,sha256=qLNbLZXrPlcdZLoyZw3Mzf1PwX4BiW3z6SKi_NqhVnM,1806
+pyg90alarm-1.20.0.dist-info/LICENSE,sha256=f884inRbeNv-O-hbwz62Ro_1J8xiHRTnJ2cCx6A0WvU,1070
+pyg90alarm-1.20.0.dist-info/METADATA,sha256=UDwmoHFOiwFFQiq0yVLsV0Pl1YV2D09H8AwNtw8zESQ,7951
+pyg90alarm-1.20.0.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+pyg90alarm-1.20.0.dist-info/top_level.txt,sha256=czHiGxYMyTk5QEDTDb0EpPiKqUMRa8zI4zx58Ii409M,11
+pyg90alarm-1.20.0.dist-info/RECORD,,

{pyg90alarm-1.17.2.dist-info → pyg90alarm-1.20.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.6.0)
+Generator: setuptools (75.8.0)
 Root-Is-Purelib: true
 Tag: py3-none-any