pyg90alarm 1.19.0__py3-none-any.whl → 2.0.0__py3-none-any.whl

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,6 +31,7 @@ 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,
@@ -171,7 +172,7 @@ _LOGGER = logging.getLogger(__name__)
 
 
 # pylint: disable=too-many-public-methods
-class G90Sensor:  # pylint:disable=too-many-instance-attributes
+class G90Sensor(G90BaseEntity):  # pylint:disable=too-many-instance-attributes
     """
     Interacts with sensor on G90 alarm panel.
 
@@ -208,6 +209,7 @@ class G90Sensor:  # pylint:disable=too-many-instance-attributes
         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
@@ -219,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:
         """
@@ -396,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:
         """
@@ -405,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:
         """
@@ -532,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]
 
@@ -633,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.
@@ -644,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,
@@ -657,6 +699,7 @@ class G90Sensor:  # pylint:disable=too-many-instance-attributes
             '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:
@@ -666,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/{base_cmd.py → local/base_cmd.py}

@@ -30,8 +30,8 @@ from asyncio.protocols import DatagramProtocol
 from asyncio.transports import DatagramTransport, BaseTransport
 from typing import Optional, Tuple, List, Any
 from dataclasses import dataclass
-from .exceptions import (G90Error, G90TimeoutError)
-from .const import G90Commands
+from ..exceptions import (G90Error, G90TimeoutError)
+from ..const import G90Commands
 
 
 _LOGGER = logging.getLogger(__name__)
@@ -121,10 +121,7 @@ class G90BaseCommand(DatagramProtocol):
         """
         Creates UDP connection to the alarm panel.
         """
-        try:
-            loop = asyncio.get_running_loop()
-        except AttributeError:
-            loop = asyncio.get_event_loop()
+        loop = asyncio.get_running_loop()
 
         _LOGGER.debug('Creating UDP endpoint for %s:%s',
                       self.host, self.port)

pyg90alarm/{discovery.py → local/discovery.py}

@@ -29,7 +29,7 @@ import logging
 
 from .base_cmd import G90BaseCommand
 from .host_info import G90HostInfo
-from .const import G90Commands
+from ..const import G90Commands
 
 _LOGGER = logging.getLogger(__name__)
 

pyg90alarm/{history.py → local/history.py}

@@ -26,7 +26,7 @@ import logging
 from typing import Any, Optional, Dict
 from dataclasses import dataclass
 from datetime import datetime, timezone
-from .const import (
+from ..const import (
     G90AlertTypes,
     G90AlertSources,
     G90AlertStates,
@@ -34,7 +34,7 @@ from .const import (
     G90HistoryStates,
     G90RemoteButtonStates,
 )
-from .device_notifications import G90DeviceAlert
+from ..notifications.base import G90DeviceAlert
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -52,6 +52,8 @@ states_mapping_alerts = {
         G90HistoryStates.TAMPER,
     G90AlertStates.LOW_BATTERY:
         G90HistoryStates.LOW_BATTERY,
+    G90AlertStates.ALARM:
+        G90HistoryStates.ALARM,
 }
 
 states_mapping_state_changes = {

pyg90alarm/{host_status.py → local/host_status.py}

@@ -24,7 +24,7 @@ Protocol entity for G90 alarm panel status.
 from __future__ import annotations
 from typing import Any, Dict
 from dataclasses import dataclass, asdict
-from .const import G90ArmDisarmTypes
+from ..const import G90ArmDisarmTypes
 
 
 @dataclass

pyg90alarm/local/notifications.py

@@ -0,0 +1,116 @@
+# Copyright (c) 2021 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.
+
+"""
+Implements support for notifications/alerts sent by G90 alarm panel.
+"""
+import logging
+from typing import (
+    Optional, Tuple, Callable
+)
+import asyncio
+from asyncio.transports import BaseTransport
+from asyncio.protocols import DatagramProtocol
+
+from ..notifications.base import G90NotificationsBase
+from ..notifications.protocol import G90NotificationProtocol
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class G90LocalNotifications(G90NotificationsBase, DatagramProtocol):
+    """
+    Implements support for notifications/alerts sent by alarm panel.
+
+    There is a basic check to ensure only notifications/alerts from the correct
+    device are processed - the check uses the host and port of the device, and
+    the device ID (GUID) that is set by the ancestor class that implements the
+    commands (e.g. :class:`G90Alarm`). The latter to work correctly needs a
+    command to be performed first, one that fetches device GUID and then stores
+    it using :attr:`.device_id` (e.g. :meth:`G90Alarm.get_host_info`).
+
+    :param protocol_factory: A callable that returns a new instance of the
+     :class:`G90NotificationProtocol` class.
+    :param port: The port on which the device is listening for notifications.
+    :param host: The host on which the device is listening for notifications.
+    :param local_port: The port on which the local host is listening for
+     notifications.
+    :param local_host: The host on which the local host is listening for
+     notifications.
+    """
+    def __init__(  # pylint:disable=too-many-arguments
+        self, protocol_factory: Callable[[], G90NotificationProtocol],
+        port: int, host: str, local_port: int, local_host: str,
+    ):
+        super().__init__(protocol_factory)
+
+        self._host = host
+        self._port = port
+        self._notifications_local_host = local_host
+        self._notifications_local_port = local_port
+
+    # Implementation of datagram protocol,
+    # https://docs.python.org/3/library/asyncio-protocol.html#datagram-protocols
+    def connection_made(self, transport: BaseTransport) -> None:
+        """
+        Invoked when connection from the device is made.
+        """
+
+    def connection_lost(self, exc: Optional[Exception]) -> None:
+        """
+        Same but when the connection is lost.
+        """
+
+    def datagram_received(
+        self, data: bytes, addr: Tuple[str, int]
+    ) -> None:
+        """
+        Invoked when datagram is received from the device.
+        """
+        if self._host and self._host != addr[0]:
+            _LOGGER.error(
+                "Received notification/alert from wrong host '%s',"
+                " expected from '%s'",
+                addr[0], self._host
+            )
+            return
+
+        self.set_last_device_packet_time()
+
+        _LOGGER.debug('Received device message from %s:%s: %s',
+                      addr[0], addr[1], data)
+
+        self.handle(data)
+
+    async def listen(self) -> None:
+        """
+        Listens for notifications/alerts from the device.
+        """
+        loop = asyncio.get_running_loop()
+
+        _LOGGER.debug('Creating UDP endpoint for %s:%s',
+                      self._notifications_local_host,
+                      self._notifications_local_port)
+        (self._transport,
+         _protocol) = await loop.create_datagram_endpoint(
+            lambda: self,
+            local_addr=(
+                self._notifications_local_host, self._notifications_local_port
+            ))

pyg90alarm/{paginated_cmd.py → local/paginated_cmd.py}

@@ -26,8 +26,8 @@ import logging
 from typing import Any, cast
 from dataclasses import dataclass
 from .base_cmd import G90BaseCommand, G90BaseCommandData
-from .exceptions import G90Error
-from .const import G90Commands
+from ..exceptions import G90Error
+from ..const import G90Commands
 
 _LOGGER = logging.getLogger(__name__)
 

pyg90alarm/{paginated_result.py → local/paginated_result.py}

@@ -27,7 +27,7 @@ import logging
 from typing import Any, Optional, AsyncGenerator, Iterable, cast
 from dataclasses import dataclass
 from .paginated_cmd import G90PaginatedCommand
-from .const import (
+from ..const import (
     G90Commands,
     CMD_PAGE_SIZE,
 )

pyg90alarm/{targeted_discovery.py → local/targeted_discovery.py}

@@ -28,8 +28,8 @@ from dataclasses import dataclass, asdict
 import asyncio
 from asyncio.transports import BaseTransport
 from .base_cmd import G90BaseCommand
-from .const import G90Commands
-from .exceptions import G90Error
+from ..const import G90Commands
+from ..exceptions import G90Error
 
 _LOGGER = logging.getLogger(__name__)