pyg90alarm 2.3.1__tar.gz → 2.4.0__tar.gz

{pyg90alarm-2.3.1 → pyg90alarm-2.4.0}/.github/workflows/main.yml

@@ -56,7 +56,7 @@ jobs:
           package_version=`python3 setup.py --version`
           echo "VALUE=$package_version" >> $GITHUB_OUTPUT
       - name: SonarCloud scanning
-        uses: SonarSource/sonarqube-scan-action@v6
+        uses: SonarSource/sonarqube-scan-action@v7
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
           SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }}

{pyg90alarm-2.3.1 → pyg90alarm-2.4.0}/PKG-INFO

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

{pyg90alarm-2.3.1 → pyg90alarm-2.4.0}/docs/requirements.txt

@@ -1,6 +1,7 @@
 sphinx-rtd-theme
 enum-tools[sphinx]
-sphinx-autodoc-typehints==2.3.0
+sphinx-autodoc-typehints==2.3.0; python_version < '3.11'
+sphinx-autodoc-typehints==3.6.2; python_version >= '3.11'
 pygments>=2.15.0 # not directly required, pinned by Snyk to avoid a vulnerability
 sphinx>=3.3.0 # not directly required, pinned by Snyk to avoid a vulnerability
 setuptools>=65.5.1 # not directly required, pinned by Snyk to avoid a vulnerability

{pyg90alarm-2.3.1 → pyg90alarm-2.4.0}/src/pyg90alarm/__init__.py

@@ -44,7 +44,7 @@ from .definitions.devices import (
 from .definitions.base import (
     G90PeripheralTypes,
 )
-from .local.config import G90AlertConfigFlags
+from .local.alert_config import G90AlertConfigFlags
 from .local.host_status import G90HostStatus
 from .const import (
     G90MessageTypes,

{pyg90alarm-2.3.1 → pyg90alarm-2.4.0}/src/pyg90alarm/alarm.py

@@ -73,6 +73,7 @@ from .const import (
     ROOM_ID,
     G90ArmDisarmTypes,
     G90RemoteButtonStates,
+    G90RFIDKeypadStates,
 )
 from .local.base_cmd import (G90BaseCommand, G90BaseCommandData)
 from .local.paginated_result import G90PaginatedResult, G90PaginatedResponse
@@ -95,9 +96,12 @@ from .local.targeted_discovery import (
 )
 from .local.host_info import G90HostInfo
 from .local.host_status import G90HostStatus
-from .local.config import (G90AlertConfig, G90AlertConfigFlags)
+from .local.alert_config import (G90AlertConfig, G90AlertConfigFlags)
 from .local.history import G90History
 from .local.user_data_crc import G90UserDataCRC
+from .local.alarm_phones import G90AlarmPhones
+from .local.host_config import G90HostConfig
+from .local.net_config import G90NetConfig
 from .callback import G90Callback, G90CallbackList
 from .exceptions import G90Error, G90TimeoutError
 from .cloud.notifications import G90CloudNotifications
@@ -146,6 +150,10 @@ if TYPE_CHECKING:
         Callable[[int, str], None],
         Callable[[int, str], Coroutine[None, None, None]]
     ]
+    RFIDKeypadCallback = Union[
+        Callable[[int, str, G90RFIDKeypadStates], None],
+        Callable[[int, str, G90RFIDKeypadStates], 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
@@ -217,6 +225,9 @@ class G90Alarm(G90NotificationProtocol):
         self._remote_button_press_cb: G90CallbackList[
             RemoteButtonPressCallback
         ] = G90CallbackList()
+        self._rfid_keypad_cb: G90CallbackList[
+            RFIDKeypadCallback
+        ] = G90CallbackList()
         self._door_open_when_arming_cb: G90CallbackList[
             DoorOpenWhenArmingCallback
         ] = G90CallbackList()
@@ -484,6 +495,30 @@ class G90Alarm(G90NotificationProtocol):
         """
         await self.alert_config.set(flags)
 
+    async def alarm_phones(self) -> G90AlarmPhones:
+        """
+        Provides access to alarm panel phone numbers.
+
+        :return: Alarm panel phone numbers
+        """
+        return await G90AlarmPhones.load(parent=self)
+
+    async def host_config(self) -> G90HostConfig:
+        """
+        Provides access to alarm panel configuration.
+
+        :return: Alarm panel configuration
+        """
+        return await G90HostConfig.load(parent=self)
+
+    async def net_config(self) -> G90NetConfig:
+        """
+        Provides access to alarm panel network configuration.
+
+        :return: Alarm panel network configuration
+        """
+        return await G90NetConfig.load(parent=self)
+
     @property
     async def user_data_crc(self) -> G90UserDataCRC:
         """
@@ -566,12 +601,18 @@ class G90Alarm(G90NotificationProtocol):
                 sensor._set_occupancy(False)
                 sensor.state_callback.invoke(sensor.occupancy)
 
-            alert_config_flags = await self.alert_config.flags
-            # Determine if door close notifications are available for the given
-            # sensor
-            door_close_alert_enabled = (
-                G90AlertConfigFlags.DOOR_CLOSE in alert_config_flags
-            )
+            # Determine if door close notifications are available for the
+            # given sensor
+            alert_config_flags = await self.alert_config.flags_with_fallback
+            if alert_config_flags is None:
+                # No alert configuration available, assume door close alerts
+                # are disabled
+                door_close_alert_enabled = False
+            else:
+                door_close_alert_enabled = (
+                    G90AlertConfigFlags.DOOR_CLOSE in alert_config_flags
+                )
+
             # The condition intentionally doesn't account for cord sensors of
             # subtype door, since those won't send door open/close alerts, only
             # notifications
@@ -588,7 +629,7 @@ class G90Alarm(G90NotificationProtocol):
                               ' closing event will be emulated upon'
                               ' %s seconds',
                               name, sensor.type,
-                              alert_config_flags,
+                              alert_config_flags or 'N/A',
                               self._reset_occupancy_interval)
                 G90Callback.invoke_delayed(
                     self._reset_occupancy_interval,
@@ -646,7 +687,7 @@ class G90Alarm(G90NotificationProtocol):
         is opened or closed (if corresponding alert is configured on the
         device).
 
-        .. seealso:: :attr:`.sensor_callback` for compatiblity notes
+        .. seealso:: :attr:`.sensor_callback` for compatibility notes
         """
         return self._door_open_close_cb
 
@@ -689,7 +730,7 @@ class G90Alarm(G90NotificationProtocol):
         The device arm/disarm callback, which is invoked when device state
         changes.
 
-        .. seealso:: :attr:`.sensor_callback` for compatiblity notes
+        .. seealso:: :attr:`.sensor_callback` for compatibility notes
         """
         return self._armdisarm_cb
 
@@ -743,7 +784,7 @@ class G90Alarm(G90NotificationProtocol):
         """
         The device alarm callback, which is invoked when device alarm triggers.
 
-        .. seealso:: :attr:`.sensor_callback` for compatiblity notes
+        .. seealso:: :attr:`.sensor_callback` for compatibility notes
         """
         return self._alarm_cb
 
@@ -779,7 +820,7 @@ class G90Alarm(G90NotificationProtocol):
         Low battery callback, which is invoked when sensor reports the
         condition.
 
-        .. seealso:: :attr:`.sensor_callback` for compatiblity notes
+        .. seealso:: :attr:`.sensor_callback` for compatibility notes
         """
         return self._low_battery_cb
 
@@ -824,7 +865,7 @@ class G90Alarm(G90NotificationProtocol):
         """
         SOS callback, which is invoked when SOS alert is triggered.
 
-        .. seealso:: :attr:`.sensor_callback` for compatiblity notes
+        .. seealso:: :attr:`.sensor_callback` for compatibility notes
         """
         return self._sos_cb
 
@@ -862,7 +903,7 @@ class G90Alarm(G90NotificationProtocol):
         Remote button press callback, which is invoked when remote button is
         pressed.
 
-        .. seealso:: :attr:`.sensor_callback` for compatiblity notes
+        .. seealso:: :attr:`.sensor_callback` for compatibility notes
         """
         return self._remote_button_press_cb
 
@@ -872,6 +913,53 @@ class G90Alarm(G90NotificationProtocol):
     ) -> None:
         self._remote_button_press_cb.add(value)
 
+    async def on_rfid_keypad(
+        self, event_id: int, zone_name: str,
+        state: G90RFIDKeypadStates
+    ) -> None:
+        """
+        Invoked when RFID keypad event occurs. Fires corresponding callback if
+        set by the user with :attr:`.rfid_keypad_callback`.
+
+        Please note the method is for internal use by the class.
+
+        :param event_id: Index of the RFID keypad (sensor associated with the
+         RFID keypad)
+        :param zone_name: Sensor name
+        :param state: The RFID keypad state
+        """
+        _LOGGER.debug(
+            'on_rfid_keypad: %s %s %s', event_id, zone_name, state
+        )
+        self._rfid_keypad_cb.invoke(event_id, zone_name, state)
+
+        # Invoke corresponding low battery callback for unification with
+        # regular sensors. Note that on_sensor_activity callback is not
+        # invoked, since it will reset the low battery flag
+        if state == G90RFIDKeypadStates.LOW_BATTERY:
+            await self.on_low_battery(event_id, zone_name)
+        else:
+            # Similar to remote button press, also report the event as sensor
+            # activity for unification
+            await self.on_sensor_activity(event_id, zone_name, True)
+
+    @property
+    def rfid_keypad_callback(
+        self
+    ) -> G90CallbackList[RFIDKeypadCallback]:
+        """
+        RFID keypad callback, which is invoked when RFID keypad event occurs.
+
+        .. seealso:: :attr:`.sensor_callback` for compatibility notes
+        """
+        return self._rfid_keypad_cb
+
+    @rfid_keypad_callback.setter
+    def rfid_keypad_callback(
+        self, value: RFIDKeypadCallback
+    ) -> None:
+        self._rfid_keypad_cb.add(value)
+
     async def on_door_open_when_arming(
         self, event_id: int, zone_name: str
     ) -> None:
@@ -905,7 +993,7 @@ class G90Alarm(G90NotificationProtocol):
         Door open when arming callback, which is invoked when sensor reports
         the condition.
 
-        .. seealso:: :attr:`.sensor_callback` for compatiblity notes
+        .. seealso:: :attr:`.sensor_callback` for compatibility notes
         """
         return self._door_open_when_arming_cb
 
@@ -961,7 +1049,7 @@ class G90Alarm(G90NotificationProtocol):
         Sensor list change callback, which is invoked when sensor list
         changes.
 
-        .. seealso:: :attr:`.sensor_callback` for compatiblity notes
+        .. seealso:: :attr:`.sensor_callback` for compatibility notes
         """
         return self._sensor_list_change_cb
 
@@ -998,7 +1086,7 @@ class G90Alarm(G90NotificationProtocol):
         Device list change callback, which is invoked when device list
         changes.
 
-        .. seealso:: :attr:`.sensor_callback` for compatiblity notes
+        .. seealso:: :attr:`.sensor_callback` for compatibility notes
         """
         return self._device_list_change_cb
 

{pyg90alarm-2.3.1 → pyg90alarm-2.4.0}/src/pyg90alarm/const.py

@@ -156,6 +156,7 @@ class G90Commands(IntEnum):
     DELALLLOCK = 223
     # Miscellaneous
     GETAPINFO = 212
+    SETAPINFO = 213
     PINGBYGPRS = 218
     PING = 219
 
@@ -209,21 +210,48 @@ class G90AlertSources(IntEnum):
     DEVICE = 0
     SENSOR = 1
     TAMPER = 3
+    INFRARED = 8
     REMOTE = 10
     RFID = 11
     DOORBELL = 12
     FINGERPRINT = 15
 
 
+class G90CommonSensorAlertStates(IntEnum):
+    """
+    Defines possible states of the alert sent by most sensors.
+    """
+    DOOR_CLOSE = 0
+    DOOR_OPEN = 1
+    SOS = 2
+    TAMPER = 3
+    LOW_BATTERY = 4
+    ALARM = 254
+
+
+class G90InfraredAlertStates(IntEnum):
+    """
+    Defines possible states of the alerts sent by infrared sensors.
+    """
+    MOTION_DETECTED = 0
+    TAMPER = 1
+    LOW_BATTERY = 2
+
+
 class G90AlertStates(IntEnum):
     """
-    Defines possible states of the alert sent by the panel.
+    Defines consolidated states of the alert sent by infrared and other
+    sensors.
+
+    By a reason the infrared sensors use different codes for their alert
+    states, this enum consolidates them into a single set for unification.
     """
     DOOR_CLOSE = 0
     DOOR_OPEN = 1
     SOS = 2
     TAMPER = 3
     LOW_BATTERY = 4
+    MOTION_DETECTED = 5
     ALARM = 254
 
 
@@ -261,6 +289,15 @@ class G90HistoryStates(IntEnum):
     REMOTE_BUTTON_ARM_HOME = 14
     REMOTE_BUTTON_DISARM = 15
     REMOTE_BUTTON_SOS = 16
+    RFID_KEY_ARM_AWAY = 17
+    RFID_KEY_ARM_HOME = 18
+    RFID_KEY_DISARM = 19
+    RFID_CARD_0 = 20
+    RFID_CARD_1 = 21
+    RFID_CARD_2 = 22
+    RFID_CARD_3 = 23
+    RFID_CARD_4 = 24
+    MOTION_DETECTED = 25
 
 
 class G90RemoteButtonStates(IntEnum):
@@ -271,3 +308,18 @@ class G90RemoteButtonStates(IntEnum):
     ARM_HOME = 1
     DISARM = 2
     SOS = 3
+
+
+class G90RFIDKeypadStates(IntEnum):
+    """
+    Defines possible states for RFID keypads.
+    """
+    ARM_AWAY = 0
+    ARM_HOME = 1
+    DISARM = 2
+    LOW_BATTERY = 5
+    CARD_0 = 6
+    CARD_1 = 7
+    CARD_2 = 8
+    CARD_3 = 9
+    CARD_4 = 10

pyg90alarm-2.4.0/src/pyg90alarm/event_mapping.py

@@ -0,0 +1,99 @@
+# Copyright (c) 2026 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.
+
+"""
+Defines mapping of various events.
+"""
+from __future__ import annotations
+from typing import Dict, TYPE_CHECKING
+import logging
+from .const import (
+    G90AlertSources,
+    G90AlertStates,
+    G90CommonSensorAlertStates,
+    G90InfraredAlertStates,
+)
+
+_LOGGER = logging.getLogger(__name__)
+
+
+def map_alert_state(
+    source: G90AlertSources, state: int
+) -> G90AlertStates:
+    """
+    Converts alert state of infrared and other sensors to consolidated one.
+
+    :param source: Source of the alert
+    :param state: State code as received from the panel
+    :return: Consolidated alert state
+    """
+    if TYPE_CHECKING:
+        # Forward declarations
+        key: G90CommonSensorAlertStates | G90InfraredAlertStates
+        mapping: Dict[
+            G90CommonSensorAlertStates | G90InfraredAlertStates,
+            G90AlertStates
+        ]
+
+    # Mapping for common sensors
+    mapping = {
+        G90CommonSensorAlertStates.DOOR_CLOSE:
+            G90AlertStates.DOOR_CLOSE,
+        G90CommonSensorAlertStates.DOOR_OPEN:
+            G90AlertStates.DOOR_OPEN,
+        G90CommonSensorAlertStates.SOS:
+            G90AlertStates.SOS,
+        G90CommonSensorAlertStates.TAMPER:
+            G90AlertStates.TAMPER,
+        G90CommonSensorAlertStates.LOW_BATTERY:
+            G90AlertStates.LOW_BATTERY,
+        G90CommonSensorAlertStates.ALARM:
+            G90AlertStates.ALARM,
+    }
+    key = G90CommonSensorAlertStates(state)
+    mapping_kind = 'common'
+
+    # Mapping for infrared sensors
+    if source == G90AlertSources.INFRARED:
+        mapping = {
+            G90InfraredAlertStates.MOTION_DETECTED:
+                G90AlertStates.MOTION_DETECTED,
+            G90InfraredAlertStates.TAMPER:
+                G90AlertStates.TAMPER,
+            G90InfraredAlertStates.LOW_BATTERY:
+                G90AlertStates.LOW_BATTERY,
+        }
+        key = G90InfraredAlertStates(state)
+        mapping_kind = 'infrared'
+
+    try:
+        result = mapping[key]
+    except KeyError as exc:
+        # Raise the error similar to Enum if state is invalid
+        raise ValueError(
+            f'{state} is not valid for source {source}'
+        ) from exc
+
+    _LOGGER.debug(
+        'Mapped %s sensor alert state %d to consolidated state %s'
+        ' for source %s',
+        mapping_kind, state, repr(result), repr(source)
+    )
+    return result

pyg90alarm-2.4.0/src/pyg90alarm/local/alarm_phones.py

@@ -0,0 +1,77 @@
+# Copyright (c) 2026 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.
+"""
+Protocol entity for G90 alarm panel phone numbers.
+"""
+from __future__ import annotations
+from typing import Dict, Any
+from dataclasses import dataclass
+from ..const import G90Commands
+from .dataclass_load_save import DataclassLoadSave
+
+
+@dataclass
+class G90AlarmPhones(DataclassLoadSave):
+    """
+    Interprets data fields of GETALMPHONE/SETALMPHONE commands.
+    """
+    # pylint: disable=too-many-instance-attributes
+    LOAD_COMMAND = G90Commands.GETALMPHONE
+    SAVE_COMMAND = G90Commands.SETALMPHONE
+
+    # Password to operate the panel via SMS or incoming call.
+    panel_password: str
+    # Phone number of the alarm panel's SIM card.
+    panel_phone_number: str
+    # Alarm phone number to be called on alarm.
+    # Should be in country code + number format.
+    phone_number_1: str
+    # Same, but for second alarm phone number.
+    phone_number_2: str
+    # Same, but for third alarm phone number.
+    phone_number_3: str
+    # Same, but for fourth alarm phone number.
+    phone_number_4: str
+    # Same, but for fifth alarm phone number.
+    phone_number_5: str
+    # Same, but for sixth alarm phone number.
+    phone_number_6: str
+    # Phone number to send SMS notifications on alarm.
+    # Should be in country code + number format.
+    sms_push_number_1: str
+    # Same, but for second SMS notification phone number.
+    sms_push_number_2: str
+
+    def _asdict(self) -> Dict[str, Any]:
+        """
+        Returns the dataclass fields as a dictionary, masking sensitive data.
+        """
+        return {
+            'panel_password': '********',
+            'panel_phone_number': self.panel_phone_number,
+            'phone_number_1': self.phone_number_1,
+            'phone_number_2': self.phone_number_2,
+            'phone_number_3': self.phone_number_3,
+            'phone_number_4': self.phone_number_4,
+            'phone_number_5': self.phone_number_5,
+            'phone_number_6': self.phone_number_6,
+            'sms_push_number_1': self.sms_push_number_1,
+            'sms_push_number_2': self.sms_push_number_2,
+        }

pyg90alarm-2.3.1/src/pyg90alarm/local/config.py → pyg90alarm-2.4.0/src/pyg90alarm/local/alert_config.py

@@ -22,10 +22,12 @@
 Represents various configuration aspects of the alarm panel.
 """
 from __future__ import annotations
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Optional
 import logging
 from dataclasses import dataclass
 from enum import IntFlag
+
+from pyg90alarm.exceptions import G90Error
 from ..const import G90Commands
 if TYPE_CHECKING:
     from ..alarm import G90Alarm
@@ -80,6 +82,7 @@ class G90AlertConfig:
     """
     def __init__(self, parent: G90Alarm) -> None:
         self.parent = parent
+        self._cached_data: Optional[G90AlertConfigData] = None
 
     async def _get(self) -> G90AlertConfigData:
         """
@@ -94,6 +97,10 @@ class G90AlertConfig:
             'Alert configuration: %s, flags: %s', data,
             repr(data.flags)
         )
+
+        # Cache the retrieved data for `flags_with_fallback` property
+        self._cached_data = data
+
         return data
 
     async def set(self, flags: G90AlertConfigFlags) -> None:
@@ -155,3 +162,29 @@ class G90AlertConfig:
         :return: Symbolic names for corresponding flag bits
         """
         return (await self._get()).flags
+
+    @property
+    async def flags_with_fallback(self) -> Optional[G90AlertConfigFlags]:
+        """
+        :return: Symbolic names for corresponding flag bits, falling back to
+         cached data if device communication fails
+        """
+        result = None
+
+        try:
+            result = (await self._get()).flags
+        except G90Error as exc:
+            _LOGGER.debug(
+                'Retrieving alert config flags resulted in error %s',
+                repr(exc)
+            )
+            if self._cached_data is not None:
+                _LOGGER.debug(
+                    'Falling back to cached alert configuration flags: %s',
+                    repr(self._cached_data.flags)
+                )
+                result = self._cached_data.flags
+            else:
+                _LOGGER.debug('No cached alert configuration flags available')
+
+        return result

pyg90alarm-2.4.0/src/pyg90alarm/local/config.py

@@ -0,0 +1,32 @@
+# 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.
+"""
+Compatibility module for the alert configuration, which should be imported
+from `local.alert_config` instead.
+"""
+from .alert_config import (
+    G90AlertConfig, G90AlertConfigData, G90AlertConfigFlags
+)
+
+__all__ = [
+    'G90AlertConfig',
+    'G90AlertConfigData',
+    'G90AlertConfigFlags',
+]