pyg90alarm 1.13.0__py3-none-any.whl → 1.15.0__py3-none-any.whl

pyg90alarm/alarm.py

@@ -48,8 +48,14 @@ G90HostInfo(host_guid='<...>',
             wifi_signal_level=100)
 
 """
+from __future__ import annotations
 import asyncio
+from asyncio import Task
 import logging
+from typing import (
+    TYPE_CHECKING, Any, List, Optional, AsyncGenerator,
+    Callable, Coroutine, Union
+)
 from .const import (
     G90Commands, REMOTE_PORT,
     REMOTE_TARGETED_DISCOVERY_PORT,
@@ -57,15 +63,17 @@ from .const import (
     NOTIFICATIONS_PORT,
     G90ArmDisarmTypes,
 )
-from .base_cmd import G90BaseCommand
-from .paginated_result import G90PaginatedResult
+from .base_cmd import (G90BaseCommand, G90BaseCommandData)
+from .paginated_result import G90PaginatedResult, G90PaginatedResponse
 from .entities.sensor import (G90Sensor, G90SensorTypes)
 from .entities.device import G90Device
 from .device_notifications import (
     G90DeviceNotifications,
 )
-from .discovery import G90Discovery
-from .targeted_discovery import G90TargetedDiscovery
+from .discovery import G90Discovery, G90DiscoveredDevice
+from .targeted_discovery import (
+    G90TargetedDiscovery, G90DiscoveredDeviceTargeted,
+)
 from .host_info import G90HostInfo
 from .host_status import G90HostStatus
 from .config import (G90AlertConfig, G90AlertConfigFlags)
@@ -76,6 +84,39 @@ from .exceptions import G90Error, G90TimeoutError
 
 _LOGGER = logging.getLogger(__name__)
 
+if TYPE_CHECKING:
+    # Type alias for the callback functions available to the user, should be
+    # compatible with `G90Callback.Callback` type, since `G90Callback.invoke`
+    # is used to invoke them
+    AlarmCallback = Union[
+        Callable[[int, str, Any], None],
+        Callable[[int, str, Any], Coroutine[None, None, None]]
+    ]
+    DoorOpenCloseCallback = Union[
+        Callable[[int, str, bool], None],
+        Callable[[int, str, bool], Coroutine[None, None, None]]
+    ]
+    SensorCallback = Union[
+        Callable[[int, str, bool], None],
+        Callable[[int, str, bool], Coroutine[None, None, None]]
+    ]
+    SensorStateCallback = Union[
+        Callable[[bool], None],
+        Callable[[bool], Coroutine[None, None, None]]
+    ]
+    LowBatteryCallback = Union[
+        Callable[[int, str], None],
+        Callable[[int, str], Coroutine[None, None, None]]
+    ]
+    SensorLowBatteryCallback = Union[
+        Callable[[bool], None],
+        Callable[[bool], Coroutine[None, None, None]]
+    ]
+    ArmDisarmCallback = Union[
+        Callable[[G90ArmDisarmTypes], None],
+        Callable[[G90ArmDisarmTypes], Coroutine[None, None, None]]
+    ]
+
 
 # pylint: disable=too-many-public-methods
 class G90Alarm(G90DeviceNotifications):
@@ -83,121 +124,117 @@ class G90Alarm(G90DeviceNotifications):
     """
     Allows to interact with G90 alarm panel.
 
-    :param str host: Hostname or IP address of the alarm panel. Since the
+    :param host: Hostname or IP address of the alarm panel. Since the
      protocol is UDP-based it is ok to use broadcast or directed broadcast
      addresses, such as `255.255.255.255` or `10.10.10.255` (the latter assumes
      the device is on `10.10.10.0/24` network)
     :param port: The UDP port of the device where it listens for the
      protocol commands on WiFi interface, currently the devices don't allow it
      to be customized
-    :type port: int, optional
     :param reset_occupancy_interval: The interval upon that the sensors are
      simulated to go into inactive state.
-    :type reset_occupancy_interval: int, optional
     """
     # pylint: disable=too-many-instance-attributes,too-many-arguments
-    def __init__(self, host, port=REMOTE_PORT,
-                 reset_occupancy_interval=3,
-                 notifications_host='0.0.0.0',
-                 notifications_port=NOTIFICATIONS_PORT):
+    def __init__(self, host: str, port: int = REMOTE_PORT,
+                 reset_occupancy_interval: float = 3.0,
+                 notifications_host: str = '0.0.0.0',
+                 notifications_port: int = NOTIFICATIONS_PORT):
         super().__init__(host=notifications_host, port=notifications_port)
         self._host = host
         self._port = port
-        self._sensors = []
-        self._devices = []
-        self._notifications = None
-        self._sensor_cb = None
-        self._armdisarm_cb = None
-        self._door_open_close_cb = None
-        self._alarm_cb = None
-        self._low_battery_cb = None
+        self._sensors: List[G90Sensor] = []
+        self._devices: List[G90Device] = []
+        self._notifications: Optional[G90DeviceNotifications] = None
+        self._sensor_cb: Optional[SensorCallback] = None
+        self._armdisarm_cb: Optional[ArmDisarmCallback] = None
+        self._door_open_close_cb: Optional[DoorOpenCloseCallback] = None
+        self._alarm_cb: Optional[AlarmCallback] = None
+        self._low_battery_cb: Optional[LowBatteryCallback] = None
         self._reset_occupancy_interval = reset_occupancy_interval
-        self._alert_config = None
+        self._alert_config: Optional[G90AlertConfigFlags] = None
         self._sms_alert_when_armed = False
-        self._alert_simulation_task = None
+        self._alert_simulation_task: Optional[Task[Any]] = None
         self._alert_simulation_start_listener_back = False
 
-    async def command(self, code, data=None):
+    async def command(
+        self, code: G90Commands, data: Optional[G90BaseCommandData] = None
+    ) -> G90BaseCommandData:
         """
         Invokes a command against the alarm panel.
 
         :param code: Command code
-        :type code: :class:`.G90Commands`
         :param data: Command data
-        :type data: object or None, optional
-        :return: :attr:`.G90BaseCommand.result` that contains the result of
-         command invocation
+        :return: The result of command invocation
         """
-        cmd = await G90BaseCommand(
+        cmd: G90BaseCommand = await G90BaseCommand(
             self._host, self._port, code, data).process()
         return cmd.result
 
-    def paginated_result(self, code, start=1, end=None):
+    def paginated_result(
+        self, code: G90Commands, start: int = 1, end: Optional[int] = None
+    ) -> AsyncGenerator[G90PaginatedResponse, None]:
         """
         Returns asynchronous generator for a paginated command, that is -
         command operating on a range of records.
 
         :param code: Command code
-        :type code: :class:`.G90Commands`
-        :param int start: Starting record position (one-based)
-        :param int end: Ending record position (one-based)
-        :return: :class:`.G90PaginatedResult` being asynchronous generator
-          over the result of command invocation. Each access to the generator
-          yields :class:`.G90PaginatedResponse` instance
+        :param start: Starting record position (one-based)
+        :param end: Ending record position (one-based)
+        :return: Asynchronous generator over the result of command invocation.
         """
         return G90PaginatedResult(
             self._host, self._port, code, start, end
         ).process()
 
     @classmethod
-    async def discover(cls):
+    async def discover(cls) -> List[G90DiscoveredDevice]:
         """
         Initiates discovering devices available in the same network segment, by
         using global broadcast address as the destination.
 
         :return: List of discovered devices
-        :rtype: list[{'guid', 'host', 'port'}]
         """
-        return await G90Discovery(
+        cmd: G90Discovery = await G90Discovery(
             port=REMOTE_PORT,
             host='255.255.255.255'
         ).process()
+        return cmd.devices
 
     @classmethod
-    async def targeted_discover(cls, device_id):
+    async def targeted_discover(
+        cls, device_id: str
+    ) -> List[G90DiscoveredDeviceTargeted]:
         """
         Initiates discovering devices available in the same network segment
         using targeted protocol, that is - specifying target device GUID in the
         request, so only the specific device should respond to the query.
 
         :param device_id: GUID of the target device to discover
-        :type device_id: str
         :return: List of discovered devices
-        :rtype: list[{'guid', 'host', 'port'}]
         """
-        return await G90TargetedDiscovery(
+        cmd = await G90TargetedDiscovery(
             device_id=device_id,
             port=REMOTE_TARGETED_DISCOVERY_PORT,
             local_port=LOCAL_TARGETED_DISCOVERY_PORT,
             host='255.255.255.255'
         ).process()
+        return cmd.devices
 
     @property
-    async def sensors(self):
+    async def sensors(self) -> List[G90Sensor]:
         """
         Property over new :meth:`.get_sensors` method, retained for
         compatibility.
         """
         return await self.get_sensors()
 
-    async def get_sensors(self):
+    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.
 
         :return: List of sensors
-        :rtype: list(:class:`.G90Sensor`)
         """
         if not self._sensors:
             sensors = self.paginated_result(
@@ -214,14 +251,13 @@ class G90Alarm(G90DeviceNotifications):
 
         return self._sensors
 
-    async def find_sensor(self, idx, name):
+    async def find_sensor(self, idx: int, name: str) -> Optional[G90Sensor]:
         """
         Finds sensor by index and name.
 
-        :param int idx: Sensor index
-        :param str name: Sensor name
+        :param idx: Sensor index
+        :param name: Sensor name
         :return: Sensor instance
-        :rtype :class:`.G90Sensor`|None
         """
         sensors = await self.get_sensors()
 
@@ -241,14 +277,14 @@ class G90Alarm(G90DeviceNotifications):
         return None
 
     @property
-    async def devices(self):
+    async def devices(self) -> List[G90Device]:
         """
         Property over new :meth:`.get_devices` method, retained for
         compatibility.
         """
         return await self.get_devices()
 
-    async def get_devices(self):
+    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
@@ -257,7 +293,6 @@ class G90Alarm(G90DeviceNotifications):
         resulting entries.
 
         :return: List of devices
-        :rtype: list(:class:`.G90Device`)
         """
         if not self._devices:
             devices = self.paginated_result(
@@ -283,82 +318,74 @@ class G90Alarm(G90DeviceNotifications):
         return self._devices
 
     @property
-    async def host_info(self):
+    async def host_info(self) -> G90HostInfo:
         """
         Property over new :meth:`.get_host_info` method, retained for
         compatibility.
         """
         return await self.get_host_info()
 
-    async def get_host_info(self):
+    async def get_host_info(self) -> G90HostInfo:
         """
         Provides the device information (for example hardware versions, signal
         levels etc.).
 
         :return: Device information
-        :rtype: Instance of :class:`.G90HostInfo`
         """
         res = await self.command(G90Commands.GETHOSTINFO)
         return G90HostInfo(*res)
 
     @property
-    async def host_status(self):
+    async def host_status(self) -> G90HostStatus:
         """
         Property over new :meth:`.get_host_status` method, retained for
         compatibility.
         """
         return await self.get_host_status()
 
-    async def get_host_status(self):
+    async def get_host_status(self) -> G90HostStatus:
         """
         Provides the device status (for example, armed or disarmed, configured
         phone number, product name etc.).
 
         :return: Device information
-        :rtype: Instance of :class:`.G90HostStatus`
 
         """
         res = await self.command(G90Commands.GETHOSTSTATUS)
         return G90HostStatus(*res)
 
     @property
-    async def alert_config(self):
+    async def alert_config(self) -> G90AlertConfigFlags:
         """
         Property over new :meth:`.get_alert_config` method, retained for
         compatibility.
         """
         return await self.get_alert_config()
 
-    async def get_alert_config(self):
+    async def get_alert_config(self) -> G90AlertConfigFlags:
         """
         Retrieves the alert configuration flags from the device. Please note
         the configuration is cached upon first call, so you need to
         re-instantiate the class to reflect any updates there.
 
-        :return: Instance of :class:`.G90AlertConfigFlags` containing the
-         alerts configured
+        :return: The alerts configured
         """
         if not self._alert_config:
             self._alert_config = await self._alert_config_uncached()
         return self._alert_config
 
-    async def _alert_config_uncached(self):
+    async def _alert_config_uncached(self) -> G90AlertConfigFlags:
         """
         Retrieves the alert configuration flags directly from the device.
 
-        :return: Instance of :class:`.G90AlertConfigFlags` containing the
-         alerts configured
+        :return: The alerts configured
         """
         res = await self.command(G90Commands.GETNOTICEFLAG)
         return G90AlertConfig(*res).flags
 
-    async def set_alert_config(self, value):
+    async def set_alert_config(self, flags: G90AlertConfigFlags) -> None:
         """
-        It might be possible to implement the async property setter with
-        `async_as_sync` decorator, although it might have implications with the
-        setter not executed if the program terminates earlier. Hence, for the
-        sake of better predictability this is implemented as regular
-        (non-property) method
+        Sets the alert configuration flags on the device.
         """
         # Use uncached method retrieving the alert configuration, to ensure the
         # actual value retrieved from the device
@@ -367,45 +394,43 @@ class G90Alarm(G90DeviceNotifications):
             _LOGGER.warning(
                 'Alert configuration changed externally,'
                 ' overwriting (read "%s", will be set to "%s")',
-                str(alert_config), str(value)
+                str(alert_config), str(flags)
             )
-        await self.command(G90Commands.SETNOTICEFLAG, [value])
+        await self.command(G90Commands.SETNOTICEFLAG, [flags.value])
         # Update the alert configuration stored
-        self._alert_config = value
+        self._alert_config = flags
 
     @property
-    async def user_data_crc(self):
+    async def user_data_crc(self) -> G90UserDataCRC:
         """
         Property over new :meth:`.get_user_data_crc` method, retained for
         compatibility.
         """
         return await self.get_user_data_crc()
 
-    async def get_user_data_crc(self):
+    async def get_user_data_crc(self) -> G90UserDataCRC:
         """
         Retieves checksums (CRC) for different on-device databases (history,
         sensors etc.). Might be used to detect if there is a change in a
         particular database.
 
-        .. note:: Note that due to a bug in the firmware CRC for sensos and
+        .. note:: Note that due to a bug in the firmware CRC for sensors and
           device databases change on each call even if there were no changes
 
-        :return: Instance of :class:`.G90UserDataCRC` containing checksums for
-          different databases
+        :return: Checksums for different databases
         """
         res = await self.command(G90Commands.GETUSERDATACRC)
         return G90UserDataCRC(*res)
 
-    async def history(self, start=1, count=1):
+    async def history(
+        self, start: int = 1, count: int = 1
+    ) -> List[G90History]:
         """
         Retrieves event history from the device.
 
         :param start: Starting record number (one-based)
-        :type start: int
         :param count: Number of records to retrieve
-        :type count: int
         :return: List of history entries
-        :rtype: list[:class:`.G90History`]
         """
         res = self.paginated_result(G90Commands.GETHISTORY,
                                     start, count)
@@ -417,18 +442,23 @@ class G90Alarm(G90DeviceNotifications):
             key=lambda x: x.datetime, reverse=True
         )
 
-    async def on_sensor_activity(self, idx, name, occupancy=True):
+    async def on_sensor_activity(
+        self, idx: int, name: str, occupancy: bool = True
+    ) -> None:
         """
-        Callback that invoked both for sensor notifications and door open/close
-        alerts, since the logic for both is same and could be reused. Please
-        note the callback is for internal use by the class.
+        Invoked both for sensor notifications and door open/close
+        alerts, since the logic for both is same and could be reused.
+        Fires corresponding callback if set by the user with
+        :attr:`.sensor_callback`.
+
+        Please note the method is for internal use by the class.
 
-        :param int idx: The index of the sensor the callback is invoked for.
+        :param idx: The index of the sensor the callback is invoked for.
          Please note the index is a property of sensor, not the direct index of
          :attr:`sensors` array
-        :param str name: The name of the sensor, along with the `idx` parameter
+        :param name: The name of the sensor, along with the `idx` parameter
          it is used to look the sensor up from the :attr:`sensors` list
-        :param bool occupancy: The flag indicating the target sensor state
+        :param occupancy: The flag indicating the target sensor state
          (=occupancy), will always be `True` for callbacks invoked from alarm
          panel notifications, and reflects actual sensor state for device
          alerts (only for `door` type sensors, if door open/close alerts are
@@ -437,16 +467,19 @@ class G90Alarm(G90DeviceNotifications):
         _LOGGER.debug('on_sensor_activity: %s %s %s', idx, name, occupancy)
         sensor = await self.find_sensor(idx, name)
         if sensor:
-            _LOGGER.debug('Setting occupancy to %s (previously %s)',
-                          occupancy, sensor.occupancy)
-            sensor.occupancy = occupancy
+            # Reset the low battery flag since the sensor reports activity,
+            # implying it has sufficient battery power
+            # pylint: disable=protected-access
+            sensor._set_low_battery(False)
+            # Set the sensor occupancy
+            # pylint: disable=protected-access
+            sensor._set_occupancy(occupancy)
 
             # Emulate turning off the occupancy - most of sensors will not
             # notify the device of that, nor the device would emit such
             # notification itself
-            def reset_sensor_occupancy(sensor):
-                _LOGGER.debug('Resetting occupancy for sensor %s', sensor)
-                sensor.occupancy = False
+            def reset_sensor_occupancy(sensor: G90Sensor) -> None:
+                sensor._set_occupancy(False)
                 G90Callback.invoke(sensor.state_callback, sensor.occupancy)
 
             # Determine if door close notifications are available for the given
@@ -479,25 +512,27 @@ class G90Alarm(G90DeviceNotifications):
         G90Callback.invoke(self._sensor_cb, idx, name, occupancy)
 
     @property
-    def sensor_callback(self):
+    def sensor_callback(self) -> Optional[SensorCallback]:
         """
-        Get or set sensor activity callback, the callback is invoked when
-        sensor activates.
-
-        :type: .. py:function:: ()(idx, name, occupancy)
+        Sensor activity callback, which is invoked when sensor activates.
         """
         return self._sensor_cb
 
     @sensor_callback.setter
-    def sensor_callback(self, value):
+    def sensor_callback(self, value: SensorCallback) -> None:
         self._sensor_cb = value
 
-    async def on_door_open_close(self, event_id, zone_name, is_open):
+    async def on_door_open_close(
+        self, event_id: int, zone_name: str, is_open: bool
+    ) -> None:
         """
-        Callback that invoked when door open/close alert comes from the alarm
-        panel. Please note the callback is for internal use by the class.
+        Invoked when door open/close alert comes from the alarm
+        panel. Fires corresponding callback if set by the user with
+        :attr:`.door_open_close_callback`.
+
+        Please note the method is for internal use by the class.
 
-        .. seealso:: `method`:on_sensor_activity for arguments
+        .. seealso:: :meth:`.on_sensor_activity` method for arguments
         """
         # Same internal callback is reused both for door open/close alerts and
         # sensor notifications. The former adds reporting when a door is
@@ -509,30 +544,26 @@ class G90Alarm(G90DeviceNotifications):
         )
 
     @property
-    def door_open_close_callback(self):
+    def door_open_close_callback(self) -> Optional[DoorOpenCloseCallback]:
         """
-        Get or set door open/close callback, the callback is invoked when door
+        The door open/close callback, which is invoked when door
         is opened or closed (if corresponding alert is configured on the
         device).
-
-        :type: .. py:function:: ()(idx: int, name: str, is_open: bool)
         """
         return self._door_open_close_cb
 
     @door_open_close_callback.setter
-    def door_open_close_callback(self, value):
-        """
-        Sets callback for door open/close events.
-        """
+    def door_open_close_callback(self, value: DoorOpenCloseCallback) -> None:
         self._door_open_close_cb = value
 
-    async def on_armdisarm(self, state):
+    async def on_armdisarm(self, state: G90ArmDisarmTypes) -> None:
         """
-        Callback that invoked when the device is armed or disarmed. Please note
-        the callback is for internal use by the class.
+        Invoked when the device is armed or disarmed.  Fires corresponding
+        callback if set by the user with :attr:`.armdisarm_callback`.
+
+        Please note the method is for internal use by the class.
 
         :param state: Device state (armed, disarmed, armed home)
-        :type state: :class:`G90ArmDisarmTypes`
         """
         if self._sms_alert_when_armed:
             if state == G90ArmDisarmTypes.DISARM:
@@ -549,27 +580,26 @@ class G90Alarm(G90DeviceNotifications):
         G90Callback.invoke(self._armdisarm_cb, state)
 
     @property
-    def armdisarm_callback(self):
+    def armdisarm_callback(self) -> Optional[ArmDisarmCallback]:
         """
-        Get or set device arm/disarm callback, the callback is invoked when
-        device state changes.
-
-        :type: .. py:function:: ()(state: :class:`.G90ArmDisarmTypes`)
+        The device arm/disarm callback, which is invoked when device state
+        changes.
         """
         return self._armdisarm_cb
 
     @armdisarm_callback.setter
-    def armdisarm_callback(self, value):
+    def armdisarm_callback(self, value: ArmDisarmCallback) -> None:
         self._armdisarm_cb = value
 
-    async def on_alarm(self, event_id, zone_name):
+    async def on_alarm(self, event_id: int, zone_name: str) -> None:
         """
-        Callback that invoked when alarm is triggered. Fires alarm callback if
-        set by the user with `:property:G90Alarm.alarm_callback`.
-        Please note the callback is for internal use by the class.
+        Invoked when alarm is triggered. Fires corresponding callback if set by
+        the user with :attr:`.alarm_callback`.
+
+        Please note the method is for internal use by the class.
 
-        :param int: Index of the sensor triggered alarm
-        :param str: Sensor name
+        :param event_id: Index of the sensor triggered alarm
+        :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
@@ -588,67 +618,63 @@ class G90Alarm(G90DeviceNotifications):
         )
 
     @property
-    def alarm_callback(self):
+    def alarm_callback(self) -> Optional[AlarmCallback]:
         """
-        Get or set device alarm callback, the callback is invoked when
-        device alarm triggers.
-
-        :type:
-          .. py:function:: ()(
-            sensor_idx: int, sensor_name: str, extra_data: str|None
-          )
+        The device alarm callback, which is invoked when device alarm triggers.
         """
         return self._alarm_cb
 
     @alarm_callback.setter
-    def alarm_callback(self, value):
+    def alarm_callback(self, value: AlarmCallback) -> None:
         self._alarm_cb = value
 
-    async def on_low_battery(self, event_id, zone_name):
+    async def on_low_battery(self, event_id: int, zone_name: str) -> None:
         """
-        Callback that invoked when the sensor reports on low battery. Fires
+        Invoked when the sensor reports on low battery. Fires
         corresponding callback if set by the user with
-        `:property:G90Alarm.on_low_battery_callback`.
-        Please note the callback is for internal use by the class.
+        :attr:`.on_low_battery_callback`.
+
+        Please note the method is for internal use by the class.
 
-        :param int: Index of the sensor triggered alarm
-        :param str: Sensor name
+        :param event_id: Index of the sensor triggered alarm
+        :param zone_name: Sensor name
         """
+        _LOGGER.debug('on_low_battery: %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_low_battery(True)
             # Invoke per-sensor callback if provided
             G90Callback.invoke(sensor.low_battery_callback)
 
         G90Callback.invoke(self._low_battery_cb, event_id, zone_name)
 
     @property
-    def low_battery_callback(self):
+    def low_battery_callback(self) -> Optional[LowBatteryCallback]:
         """
-        Get or set low battery callback, the callback is invoked when sensor
-        the condition is reported by a sensor.
-
-        :type: .. py:function:: ()(idx, name)
+        Low battery callback, which is invoked when sensor reports the
+        condition.
         """
         return self._low_battery_cb
 
     @low_battery_callback.setter
-    def low_battery_callback(self, value):
+    def low_battery_callback(self, value: LowBatteryCallback) -> None:
         self._low_battery_cb = value
 
-    async def listen_device_notifications(self):
+    async def listen_device_notifications(self) -> None:
         """
         Starts internal listener for device notifications/alerts.
-
         """
         await self.listen()
 
-    def close_device_notifications(self):
+    def close_device_notifications(self) -> None:
         """
         Closes the listener for device notifications/alerts.
         """
         self.close()
 
-    async def arm_away(self):
+    async def arm_away(self) -> None:
         """
         Arms the device in away mode.
         """
@@ -656,7 +682,7 @@ class G90Alarm(G90DeviceNotifications):
         await self.command(G90Commands.SETHOSTSTATUS,
                            [state])
 
-    async def arm_home(self):
+    async def arm_home(self) -> None:
         """
         Arms the device in home mode.
         """
@@ -664,7 +690,7 @@ class G90Alarm(G90DeviceNotifications):
         await self.command(G90Commands.SETHOSTSTATUS,
                            [state])
 
-    async def disarm(self):
+    async def disarm(self) -> None:
         """
         Disarms the device.
         """
@@ -673,7 +699,7 @@ class G90Alarm(G90DeviceNotifications):
                            [state])
 
     @property
-    def sms_alert_when_armed(self):
+    def sms_alert_when_armed(self) -> bool:
         """
         When enabled, allows to save costs on SMS by having corresponding alert
         enabled only when device is armed.
@@ -681,12 +707,12 @@ class G90Alarm(G90DeviceNotifications):
         return self._sms_alert_when_armed
 
     @sms_alert_when_armed.setter
-    def sms_alert_when_armed(self, value):
+    def sms_alert_when_armed(self, value: bool) -> None:
         self._sms_alert_when_armed = value
 
     async def start_simulating_alerts_from_history(
-        self, interval=5, history_depth=5
-    ):
+        self, interval: float = 5, history_depth: int = 5
+    ) -> None:
         """
         Starts the separate task to simulate device alerts from history
         entries.
@@ -695,9 +721,9 @@ class G90Alarm(G90DeviceNotifications):
         notifications will not be processed thus resulting in possible
         duplicated if those could be received from the network.
 
-        :param int interval: Interval (in seconds) between polling for newer
+        :param interval: Interval (in seconds) between polling for newer
           history entities
-        :param int history_depth: Amount of history entries to fetch during
+        :param history_depth: Amount of history entries to fetch during
           each polling cycle
         """
         # Remember if device notifications listener has been started already
@@ -710,7 +736,7 @@ class G90Alarm(G90DeviceNotifications):
             self._simulate_alerts_from_history(interval, history_depth)
         )
 
-    async def stop_simulating_alerts_from_history(self):
+    async def stop_simulating_alerts_from_history(self) -> None:
         """
         Stops the task simulating device alerts from history entries.
 
@@ -728,7 +754,9 @@ class G90Alarm(G90DeviceNotifications):
         if self._alert_simulation_start_listener_back:
             await self.listen()
 
-    async def _simulate_alerts_from_history(self, interval, history_depth):
+    async def _simulate_alerts_from_history(
+        self, interval: float, history_depth: int
+    ) -> None:
         """
         Periodically fetches history entries from the device and simulates
         device alerts off of those.
@@ -736,7 +764,7 @@ class G90Alarm(G90DeviceNotifications):
         Only the history entries occur after the process is started are
         handled, to avoid triggering callbacks retrospectively.
 
-        See :method:`start_simulating_alerts_from_history` for the parameters.
+        See :meth:`.start_simulating_alerts_from_history` for the parameters.
         """
         last_history_ts = None
 
@@ -773,7 +801,7 @@ class G90Alarm(G90DeviceNotifications):
                 for item in reversed(history):
                     # Process only the entries newer than one been recorded as
                     # most recent one
-                    if item.datetime > last_history_ts:
+                    if last_history_ts and item.datetime > last_history_ts:
                         _LOGGER.debug(
                             'Found newer history entry: %s, simulating alert',
                             repr(item)