pyg90alarm 2.6.0__py3-none-any.whl → 2.7.1__py3-none-any.whl

pyg90alarm/alarm.py

@@ -60,14 +60,14 @@ from typing import (
     Callable, Coroutine, Union
 )
 from .const import (
-    G90Commands, REMOTE_PORT,
+    G90Commands, G90SystemCommands,
+    REMOTE_PORT,
     REMOTE_TARGETED_DISCOVERY_PORT,
     LOCAL_TARGETED_DISCOVERY_PORT,
-    LOCAL_NOTIFICATIONS_HOST,
+    LOCAL_NOTIFICATIONS_IP,
     LOCAL_NOTIFICATIONS_PORT,
-    CLOUD_NOTIFICATIONS_HOST,
-    CLOUD_NOTIFICATIONS_PORT,
-    REMOTE_CLOUD_HOST,
+    LOCAL_CLOUD_NOTIFICATIONS_IP,
+    LOCAL_CLOUD_NOTIFICATIONS_PORT,
     REMOTE_CLOUD_PORT,
     DEVICE_REGISTRATION_TIMEOUT,
     ROOM_ID,
@@ -75,7 +75,8 @@ from .const import (
     G90RemoteButtonStates,
     G90RFIDKeypadStates,
 )
-from .local.base_cmd import (G90BaseCommand, G90BaseCommandData)
+from .local.base_cmd import G90BaseCommand, BaseCommandsDataT
+from .local.system_cmd import G90SystemCommand, G90SetServerAddressCommand
 from .local.paginated_result import G90PaginatedResult, G90PaginatedResponse
 from .entities.base_list import ListChangeCallback
 from .entities.sensor import G90Sensor
@@ -263,8 +264,8 @@ class G90Alarm(G90NotificationProtocol):
         return self._port
 
     async def command(
-        self, code: G90Commands, data: Optional[G90BaseCommandData] = None
-    ) -> G90BaseCommandData:
+        self, code: G90Commands, data: Optional[BaseCommandsDataT] = None
+    ) -> BaseCommandsDataT:
         """
         Invokes a command against the alarm panel.
 
@@ -272,7 +273,7 @@ class G90Alarm(G90NotificationProtocol):
         :param data: Command data
         :return: The result of command invocation
         """
-        cmd: G90BaseCommand = await G90BaseCommand(
+        cmd = await G90BaseCommand(
             self._host, self._port, code, data).process()
         return cmd.result
 
@@ -292,6 +293,81 @@ class G90Alarm(G90NotificationProtocol):
             self._host, self._port, code, start, end
         ).process()
 
+    async def mcu_reboot(self) -> None:
+        """
+        Reboots the MCU of the alarm panel.
+
+        Note that underlying command doesn't return any result, so there is no
+        feedback from the panel upon execution.
+        """
+        await G90SystemCommand(
+            host=self._host, port=self._port,
+            code=G90SystemCommands.MCU_REBOOT
+        ).process()
+
+    async def gsm_reboot(self) -> None:
+        """
+        Reboots the GSM module of the alarm panel.
+
+        Note that underlying command doesn't return any result, so there is no
+        feedback from the panel upon execution.
+        """
+        await G90SystemCommand(
+            host=self._host, port=self._port,
+            code=G90SystemCommands.GSM_REBOOT
+        ).process()
+
+    async def wifi_reboot(self) -> None:
+        """
+        Reboots the WiFi module of the alarm panel.
+
+        Note that underlying command doesn't return any result, so there is no
+        feedback from the panel upon execution.
+        """
+        await G90SystemCommand(
+            host=self._host, port=self._port,
+            code=G90SystemCommands.WIFI_REBOOT
+        ).process()
+
+    async def reboot(self) -> None:
+        """
+        Reboots the entire alarm panel.
+
+        The system commands performing reboot of a panel's module don't return
+        anything so there is no feedback from the panel upon execution, hence
+        the commands are spaced with delays to allow the panel to process
+        them.
+
+        Please be aware that the delays are determined experimentally and might
+        be too long or too short.
+        """
+        await self.gsm_reboot()
+        await asyncio.sleep(1)
+        await self.mcu_reboot()
+        await asyncio.sleep(1)
+        await self.wifi_reboot()
+        # The MCU likely needs more than 1 second to reboot, but checking it
+        # completed the reboot should be done separately
+        await asyncio.sleep(1)
+
+    async def set_cloud_server_address(
+        self, cloud_ip: str, cloud_port: int
+    ) -> None:
+        """
+        Sets the cloud server address the alarm panel connects to.
+
+        :param cloud_ip: IP address of the server to receive cloud protocol
+         notifications, should be reachable from the panel. Typically it is the
+         IP address of the host running the package
+        :param cloud_port: Port number of the server to receive cloud protocol
+         notifications, should be reachable from the panel
+        """
+        await G90SetServerAddressCommand(
+            host=self._host, port=self._port,
+            cloud_ip=cloud_ip,
+            cloud_port=cloud_port
+        ).process()
+
     @classmethod
     async def discover(cls) -> List[G90DiscoveredDevice]:
         """
@@ -1303,7 +1379,7 @@ class G90Alarm(G90NotificationProtocol):
             await asyncio.sleep(interval)
 
     async def use_local_notifications(
-        self, notifications_local_host: str = LOCAL_NOTIFICATIONS_HOST,
+        self, notifications_local_ip: str = LOCAL_NOTIFICATIONS_IP,
         notifications_local_port: int = LOCAL_NOTIFICATIONS_PORT
     ) -> None:
         """
@@ -1315,20 +1391,45 @@ class G90Alarm(G90NotificationProtocol):
             protocol_factory=lambda: self,
             host=self._host,
             port=self._port,
-            local_host=notifications_local_host,
+            local_ip=notifications_local_ip,
             local_port=notifications_local_port
         )
 
     # pylint: disable=too-many-positional-arguments
     async def use_cloud_notifications(
-        self, cloud_local_host: str = CLOUD_NOTIFICATIONS_HOST,
-        cloud_local_port: int = CLOUD_NOTIFICATIONS_PORT,
-        upstream_host: Optional[str] = REMOTE_CLOUD_HOST,
+        self,
+        cloud_ip: str,
+        cloud_port: int,
+        cloud_local_ip: str = LOCAL_CLOUD_NOTIFICATIONS_IP,
+        cloud_local_port: int = LOCAL_CLOUD_NOTIFICATIONS_PORT,
+        upstream_host: Optional[str] = None,
         upstream_port: Optional[int] = REMOTE_CLOUD_PORT,
         keep_single_connection: bool = True
     ) -> None:
         """
         Switches to use cloud notifications for device alerts.
+
+        Please note the method does not configure the panel for the host to
+        receive the notifications - please invoke
+        :meth:`G90Alarm.set_cloud_server_address` method to do that. The reason
+        of that is configuring cloud server address on the panel is one-time
+        operation, while the method will be called multiple times.
+
+        :param cloud_ip: The IP address of cloud server to connect to, should
+         be reachable from the panel
+        :param cloud_port: The cloud server port to connect to, should be
+         reachable from the panel
+        :param cloud_local_ip: Local IP address to bind cloud notifications
+         listener to
+        :param cloud_local_port: Local port to bind cloud notifications
+         listener to, should match `cloud_port` above unless network setup
+         dictates otherwise
+        :param upstream_host: Optional upstream host to connect to cloud
+         server through
+        :param upstream_port: Optional upstream port to connect to cloud
+         server through
+        :param keep_single_connection: If enabled, keeps a single connection
+         to the upstream cloud server for both sending and receiving data
         """
         await self.close_notifications()
 
@@ -1336,8 +1437,10 @@ class G90Alarm(G90NotificationProtocol):
             protocol_factory=lambda: self,
             upstream_host=upstream_host,
             upstream_port=upstream_port,
-            local_host=cloud_local_host,
+            local_ip=cloud_local_ip,
             local_port=cloud_local_port,
+            cloud_ip=cloud_ip,
+            cloud_port=cloud_port,
             keep_single_connection=keep_single_connection
         )
 

pyg90alarm/cloud/messages.py

@@ -37,7 +37,7 @@ from .protocol import (
 )
 from .const import G90CloudDirection, G90CloudCommand
 from ..const import (
-    G90AlertStateChangeTypes, REMOTE_CLOUD_HOST, REMOTE_CLOUD_PORT,
+    G90AlertStateChangeTypes,
     G90AlertTypes, G90AlertSources, G90AlertStates,
 )
 from ..definitions.base import G90PeripheralTypes
@@ -212,15 +212,11 @@ class G90CloudHelloDiscoveryRespMessage(G90CloudMessage):
     _source = G90CloudDirection.CLOUD_DISCOVERY
     _destination = G90CloudDirection.DEVICE
 
-    # Simulated cloud response always contains known IP address of the vendor's
-    # cloud service - that is, all interactions between alarm panel and
-    # simulated cloud service will use same IP address for unification (i.e.
-    # traffic redicrection will always be used to divert panel's cloud traffic
-    # to the simulated cloud service)
-    ip_addr: bytes = REMOTE_CLOUD_HOST.encode()
+    # The default values are set in `__post_init__()` method below
+    ip_addr: bytes = b''
     flag2: int = 0
     flag3: int = 0
-    port: int = REMOTE_CLOUD_PORT
+    port: int = 0
     _timestamp: int = 0  # unix timestamp
 
     def __post_init__(self, context: G90CloudMessageContext) -> None:
@@ -230,7 +226,7 @@ class G90CloudHelloDiscoveryRespMessage(G90CloudMessage):
         _LOGGER.debug(
             "%s: Timestamp added: %s", type(self).__name__, str(self)
         )
-        self.ip_addr = context.cloud_host.encode()
+        self.ip_addr = context.cloud_ip.encode()
         self.port = context.cloud_port
 
     @property

pyg90alarm/cloud/notifications.py

@@ -45,7 +45,6 @@ from .messages import (
 )
 from ..notifications.base import G90NotificationsBase
 from ..notifications.protocol import G90NotificationProtocol
-from ..const import (REMOTE_CLOUD_HOST, REMOTE_CLOUD_PORT)
 
 
 _LOGGER = logging.getLogger(__name__)
@@ -62,7 +61,9 @@ class G90CloudNotifications(G90NotificationsBase, asyncio.Protocol):
 
     :param protocol_factory: Factory function to create notification
      protocol handlers
-    :param local_host: Local host to bind the server to
+    :param cloud_ip: Cloud IP address to announce to the panel
+    :param cloud_port: Cloud port to announce to the panel
+    :param local_ip: Local IP to bind the server to
     :param local_port: Local port to bind the server to
     :param upstream_host: Optional upstream host to forward messages to
     :param upstream_port: Optional upstream port to forward messages to
@@ -74,7 +75,8 @@ class G90CloudNotifications(G90NotificationsBase, asyncio.Protocol):
     def __init__(
         self,
         protocol_factory: Callable[[], G90NotificationProtocol],
-        local_host: str, local_port: int,
+        local_ip: str, local_port: int,
+        cloud_ip: str, cloud_port: int,
         upstream_host: Optional[str] = None,
         upstream_port: Optional[int] = None,
         keep_single_connection: bool = True,
@@ -82,8 +84,10 @@ class G90CloudNotifications(G90NotificationsBase, asyncio.Protocol):
         super().__init__(protocol_factory)
         self._transport: Optional[Transport] = None
         self._server: Optional[asyncio.Server] = None
-        self._local_host = local_host
+        self._local_ip = local_ip
         self._local_port = local_port
+        self._cloud_ip = cloud_ip
+        self._cloud_port = cloud_port
         self._upstream_host = upstream_host
         self._upstream_port = upstream_port
         self._keep_single_connection = keep_single_connection
@@ -162,10 +166,10 @@ class G90CloudNotifications(G90NotificationsBase, asyncio.Protocol):
                 # Instantiate a context for the messages
                 ctx = G90CloudMessageContext(
                     device_id=self.device_id,
-                    local_host=self._local_host,
+                    local_ip=self._local_ip,
                     local_port=self._local_port,
-                    cloud_host=REMOTE_CLOUD_HOST,
-                    cloud_port=REMOTE_CLOUD_PORT,
+                    cloud_ip=self._cloud_ip,
+                    cloud_port=self._cloud_port,
                     upstream_host=self._upstream_host,
                     upstream_port=self._upstream_port,
                     remote_host=host,
@@ -371,11 +375,11 @@ class G90CloudNotifications(G90NotificationsBase, asyncio.Protocol):
         loop = asyncio.get_running_loop()
 
         _LOGGER.debug('Creating cloud endpoint for %s:%s',
-                      self._local_host,
+                      self._local_ip,
                       self._local_port)
         self._server = await loop.create_server(
             lambda: self,
-            self._local_host, self._local_port
+            self._local_ip, self._local_port
         )
 
     async def close(self) -> None:
@@ -404,7 +408,7 @@ class G90CloudNotifications(G90NotificationsBase, asyncio.Protocol):
         if self._server:
             _LOGGER.debug(
                 'No longer listening for cloud connections on %s:%s',
-                self._local_host, self._local_port
+                self._local_ip, self._local_port
             )
             self._server.close()
             self._server = None

pyg90alarm/cloud/protocol.py

@@ -73,11 +73,11 @@ class G90CloudMessageContext:  # pylint:disable=too-many-instance-attributes
     This class holds information about the local and remote hosts and ports,
     as well as the cloud server and upstream connection details.
     """
-    local_host: str
+    local_ip: str
     local_port: int
     remote_host: str
     remote_port: int
-    cloud_host: str
+    cloud_ip: str
     cloud_port: int
     upstream_host: Optional[str]
     upstream_port: Optional[int]

pyg90alarm/const.py

@@ -28,11 +28,10 @@ from typing import Optional
 REMOTE_PORT = 12368
 REMOTE_TARGETED_DISCOVERY_PORT = 12900
 LOCAL_TARGETED_DISCOVERY_PORT = 12901
-LOCAL_NOTIFICATIONS_HOST = '0.0.0.0'
+LOCAL_NOTIFICATIONS_IP = '0.0.0.0'
 LOCAL_NOTIFICATIONS_PORT = 12901
-CLOUD_NOTIFICATIONS_HOST = '0.0.0.0'
-CLOUD_NOTIFICATIONS_PORT = 5678
-REMOTE_CLOUD_HOST = '47.88.7.61'
+LOCAL_CLOUD_NOTIFICATIONS_IP = '0.0.0.0'
+LOCAL_CLOUD_NOTIFICATIONS_PORT = 5678
 REMOTE_CLOUD_PORT = 5678
 DEVICE_REGISTRATION_TIMEOUT = 30
 ROOM_ID = 0
@@ -42,7 +41,14 @@ CMD_PAGE_SIZE = 10
 BUG_REPORT_URL = 'https://github.com/hostcc/pyg90alarm/issues'
 
 
-class G90Commands(IntEnum):
+class G90CommandsBase(IntEnum):
+    """
+    Base class for G90Commands and G90SystemCommands to allow proper typing
+    with subclasses of `G90BaseCommand`.
+    """
+
+
+class G90Commands(G90CommandsBase):
     """
     Defines the alarm panel commands and their codes.
 
@@ -163,6 +169,27 @@ class G90Commands(IntEnum):
     PING = 219
 
 
+class G90SystemCommands(G90CommandsBase):
+    """
+    Defines system commands for the G90 alarm panel.
+    """
+    GET_CONFIGURATION = 0
+    SET_CONFIGURATION = 1
+    GSM_REBOOT = 1129
+    MCU_REBOOT = 1123
+    WIFI_REBOOT = 1006
+
+
+class G90SystemConfigurationCommands(IntEnum):
+    """
+    Defines sub-commands for getting/setting system configuration.
+
+    Applicable only to `G90SystemCommands.GET_CONFIGURATION` and
+    `G90SystemCommands.SET_CONFIGURATION` commands above.
+    """
+    SERVER_ADDRESS = 78
+
+
 class G90MessageTypes(IntEnum):
     """
     Defines message types (codes) from messages coming from the alarm panel.

pyg90alarm/local/base_cmd.py

@@ -28,40 +28,34 @@ import asyncio
 from asyncio import Future
 from asyncio.protocols import DatagramProtocol
 from asyncio.transports import DatagramTransport, BaseTransport
-from typing import Optional, Tuple, List, Any
+from typing import Optional, Tuple, List, Any, TypeVar, Generic
 from dataclasses import dataclass
+# `Self` is available in `typing` module only starting from Python 3.11, for
+# older versions need to use typing_extensions`
+from typing_extensions import Self
 from ..exceptions import (
     G90Error, G90TimeoutError, G90CommandFailure, G90CommandError
 )
-from ..const import G90Commands
+from ..const import G90Commands, G90CommandsBase
 
 
 _LOGGER = logging.getLogger(__name__)
-G90BaseCommandData = List[Any]
 
-
-@dataclass
-class G90Header:
-    """
-    Represents JSON structure of the header used in alarm panel commands.
-
-    :meta private:
-    """
-    code: Optional[int] = None
-    data: Optional[G90BaseCommandData] = None
+CommandT = TypeVar('CommandT', bound=G90CommandsBase)
+CommandDataT = TypeVar('CommandDataT')
 
 
-class G90BaseCommand(DatagramProtocol):
+class G90Command(DatagramProtocol, Generic[CommandT, CommandDataT]):
     """
-    Implements basic command handling for alarm panel protocol.
+    Base class for command handling for alarm panel protocol.
     """
     # pylint: disable=too-many-instance-attributes
     # Lock need to be shared across all of the class instances
     _sk_lock = asyncio.Lock()
 
     # pylint: disable=too-many-positional-arguments,too-many-arguments
-    def __init__(self, host: str, port: int, code: G90Commands,
-                 data: Optional[G90BaseCommandData] = None,
+    def __init__(self, host: str, port: int, code: CommandT,
+                 data: Optional[CommandDataT] = None,
                  local_port: Optional[int] = None,
                  timeout: float = 3.0, retries: int = 3) -> None:
         self._remote_host = host
@@ -70,18 +64,11 @@ class G90BaseCommand(DatagramProtocol):
         self._code = code
         self._timeout = timeout
         self._retries = retries
-        self._data = '""'
-        self._result: G90BaseCommandData = []
+        self._result: Optional[CommandDataT] = None
         self._connection_result: Optional[
             Future[Tuple[str, int, bytes]]
         ] = None
-        if data:
-            self._data = json.dumps([code, data],
-                                    # No newlines to be inserted
-                                    indent=None,
-                                    # No whitespace around entities
-                                    separators=(',', ':'))
-        self._resp = G90Header()
+        self._data = self.encode_data(data)
 
     # Implementation of datagram protocol,
     # https://docs.python.org/3/library/asyncio-protocol.html#datagram-protocols
@@ -139,92 +126,36 @@ class G90BaseCommand(DatagramProtocol):
 
         return (transport, protocol)
 
-    def to_wire(self) -> bytes:
+    def encode_data(self, data: Optional[CommandDataT]) -> str:
         """
-        Returns the command in wire format.
+        Encodes the command data to JSON string.
         """
-        wire = bytes(f'ISTART[{self._code},{self._code},{self._data}]IEND\0',
-                     'utf-8')
-        _LOGGER.debug('Encoded to wire format %s', wire)
-        return wire
+        raise NotImplementedError()
 
-    def from_wire(self, data: bytes) -> G90BaseCommandData:
+    def decode_data(self, payload: Optional[str]) -> CommandDataT:
         """
-        Parses the response from the alarm panel.
+        Decodes the command data from JSON string.
         """
-        _LOGGER.debug('To be decoded from wire format %s', data)
-        try:
-            self._parse(data.decode('utf-8'))
-        except UnicodeDecodeError as exc:
-            raise G90Error(
-                'Unable to decode response from UTF-8'
-            ) from exc
-        return self._resp.data or []
+        raise NotImplementedError()
 
-    def _parse(self, data: str) -> None:
+    def to_wire(self) -> bytes:
         """
-        Processes the response from the alarm panel.
+        Serializes the command to wire format.
         """
-        if not data.startswith('ISTART'):
-            raise G90Error('Missing start marker in data')
-        if not data.endswith('IEND\0'):
-            raise G90Error('Missing end marker in data')
-        payload = data[6:-5]
-        _LOGGER.debug("Decoded from wire: string '%s'", payload)
-
-        if not payload:
-            return
-
-        # Panel may report the last command has failed
-        if payload == 'fail':
-            raise G90CommandFailure(
-                f"Command {self._code.name}"
-                f" (code={self._code.value}) failed"
-            )
+        raise NotImplementedError()
 
-        # Also, panel may report an error supplying specific reason, e.g.
-        # command and its arguments that have failed
-        if payload.startswith('error'):
-            error = payload[5:]
-            raise G90CommandError(
-                f"Command {self._code.name}"
-                f" (code={self._code.value}) failed"
-                f" with error: '{error}'")
-
-        resp = None
-        try:
-            resp = json.loads(payload, strict=False)
-        except json.JSONDecodeError as exc:
-            raise G90Error(
-                f"Unable to parse response as JSON: '{payload}'"
-            ) from exc
-
-        if not isinstance(resp, list):
-            raise G90Error(
-                f"Malformed response, 'list' expected: '{payload}'"
-            )
-
-        if resp is not None:
-            self._resp = G90Header(*resp)
-            _LOGGER.debug('Parsed from wire: %s', self._resp)
-
-            if not self._resp.code:
-                raise G90Error(f"Missing code in response: '{payload}'")
-            # Check there is data if the response is non-empty
-            if not self._resp.data:
-                raise G90Error(f"Missing data in response: '{payload}'")
-
-            if self._resp.code != self._code:
-                raise G90Error(
-                    'Wrong response - received code '
-                    f"{self._resp.code}, expected code {self._code}")
+    def from_wire(self, data: bytes) -> Optional[CommandDataT]:
+        """
+        Deserializes the command from wire format.
+        """
+        raise NotImplementedError()
 
     @property
-    def result(self) -> G90BaseCommandData:
+    def result(self) -> CommandDataT:
         """
         The result of the command.
         """
-        return self._result
+        raise NotImplementedError()
 
     @property
     def host(self) -> str:
@@ -240,7 +171,14 @@ class G90BaseCommand(DatagramProtocol):
         """
         return self._remote_port
 
-    async def process(self) -> G90BaseCommand:
+    @property
+    def expects_response(self) -> bool:
+        """
+        Indicates whether the command expects a response.
+        """
+        return True
+
+    async def process(self) -> Self:  # G90Command[CommandT, CommandDataT]:
         """
         Processes the command.
         """
@@ -259,6 +197,9 @@ class G90BaseCommand(DatagramProtocol):
                 _LOGGER.debug('(code %s) Sending request to %s:%s',
                               self._code, self.host, self.port)
                 transport.sendto(self.to_wire())
+                if not self.expects_response:
+                    self._result = None
+                    return self
                 done, _ = await asyncio.wait([self._connection_result],
                                              timeout=self._timeout)
             if self._connection_result in done:
@@ -290,4 +231,133 @@ class G90BaseCommand(DatagramProtocol):
         Returns string representation of the command.
         """
         return f'Command: {self._code}, request: {self._data},' \
-            f' response: {self._resp.data}'
+            f' response: {self.result}'
+
+
+BaseCommandsT = G90Commands
+BaseCommandsDataT = List[Any]
+
+
+@dataclass
+class G90Header:
+    """
+    Represents JSON structure of the header used in base panel commands.
+
+    :meta private:
+    """
+    code: Optional[int] = None
+    data: Optional[BaseCommandsDataT] = None
+
+
+class G90BaseCommand(G90Command[BaseCommandsT, BaseCommandsDataT]):
+    """
+    Class for handling base G90 panel commands.
+    """
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        super().__init__(*args, **kwargs)
+        self._resp = G90Header()
+
+    def encode_data(self, data: Optional[BaseCommandsDataT]) -> str:
+        """
+        Encodes the command data to JSON string.
+        """
+        if data is None:
+            return '""'
+        return json.dumps([self._code, data],
+                          # No newlines to be inserted
+                          indent=None,
+                          # No whitespace around entities
+                          separators=(',', ':'))
+
+    def decode_data(self, payload: Optional[str]) -> BaseCommandsDataT:
+        """
+        Decodes the command data from JSON string.
+        """
+        # Also, panel may report an error supplying specific reason, e.g.
+        # command and its arguments that have failed
+        if not payload:
+            return []
+        if payload.startswith('error'):
+            error = payload[5:]
+            raise G90CommandError(
+                f"Command {self._code.name}"
+                f" (code={self._code.value}) failed"
+                f" with error: '{error}'")
+
+        resp = None
+        try:
+            resp = json.loads(payload, strict=False)
+        except json.JSONDecodeError as exc:
+            raise G90Error(
+                f"Unable to parse response as JSON: '{payload}'"
+            ) from exc
+
+        if not isinstance(resp, list):
+            raise G90Error(
+                f"Malformed response, 'list' expected: '{payload}'"
+            )
+
+        if resp is not None:
+            self._resp = G90Header(*resp)
+            _LOGGER.debug('Parsed from wire: %s', self._resp)
+
+            if not self._resp.code:
+                raise G90Error(f"Missing code in response: '{payload}'")
+            # Check there is data if the response is non-empty
+            if not self._resp.data:
+                raise G90Error(f"Missing data in response: '{payload}'")
+
+            if self._resp.code != self._code:
+                raise G90Error(
+                    'Wrong response - received code '
+                    f"{self._resp.code}, expected code {self._code}")
+
+        return self._resp.data or []
+
+    def to_wire(self) -> bytes:
+        """
+        Returns the command in wire format.
+        """
+        wire = bytes(f'ISTART[{self._code},{self._code},{self._data}]IEND\0',
+                     'utf-8')
+        _LOGGER.debug('Encoded to wire format %s', wire)
+        return wire
+
+    def from_wire(self, data: bytes) -> BaseCommandsDataT:
+        """
+        Parses the response from the alarm panel.
+        """
+        _LOGGER.debug('To be decoded from wire format %s', data)
+        try:
+            decoded_data = data.decode('utf-8')
+            if not decoded_data.startswith('ISTART'):
+                raise G90Error('Missing start marker in data')
+            if not decoded_data.endswith('IEND\0'):
+                raise G90Error('Missing end marker in data')
+            payload = decoded_data[6:-5]
+            _LOGGER.debug("Decoded from wire: string '%s'", payload)
+
+            if not payload:
+                return []
+
+            # Panel may report the last command has failed
+            if payload == 'fail':
+                raise G90CommandFailure(
+                    f"Command {self._code.name}"
+                    f" (code={self._code.value}) failed"
+                )
+
+            return self.decode_data(payload)
+        except UnicodeDecodeError as exc:
+            raise G90Error(
+                'Unable to decode response from UTF-8'
+            ) from exc
+
+    @property
+    def result(self) -> BaseCommandsDataT:
+        """
+        The result of the command.
+        """
+        if self._result is None:
+            return []
+        return self._result

pyg90alarm/local/notifications.py

@@ -52,19 +52,19 @@ class G90LocalNotifications(G90NotificationsBase, DatagramProtocol):
     :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
+    :param local_ip: The IP address on which the local host is listening for
      notifications.
     """
     # pylint:disable=too-many-positional-arguments,too-many-arguments
     def __init__(
         self, protocol_factory: Callable[[], G90NotificationProtocol],
-        port: int, host: str, local_port: int, local_host: str,
+        port: int, host: str, local_port: int, local_ip: str,
     ):
         super().__init__(protocol_factory)
 
         self._host = host
         self._port = port
-        self._notifications_local_host = local_host
+        self._notifications_local_ip = local_ip
         self._notifications_local_port = local_port
 
     # Implementation of datagram protocol,
@@ -107,11 +107,11 @@ class G90LocalNotifications(G90NotificationsBase, DatagramProtocol):
         loop = asyncio.get_running_loop()
 
         _LOGGER.debug('Creating UDP endpoint for %s:%s',
-                      self._notifications_local_host,
+                      self._notifications_local_ip,
                       self._notifications_local_port)
         (self._transport,
          _protocol) = await loop.create_datagram_endpoint(
             lambda: self,
             local_addr=(
-                self._notifications_local_host, self._notifications_local_port
+                self._notifications_local_ip, self._notifications_local_port
             ))

pyg90alarm/local/paginated_cmd.py

@@ -23,9 +23,9 @@ Implements paginated command for G90 alarm panel protocol.
 """
 from __future__ import annotations
 import logging
-from typing import Any, cast
+from typing import Any, Optional
 from dataclasses import dataclass
-from .base_cmd import G90BaseCommand, G90BaseCommandData
+from .base_cmd import G90BaseCommand, BaseCommandsDataT
 from ..exceptions import G90Error
 from ..const import G90Commands
 
@@ -82,12 +82,11 @@ class G90PaginatedCommand(G90BaseCommand):
         """
         return self._nelems
 
-    def _parse(self, data: str) -> None:
+    def decode_data(self, payload: Optional[str]) -> BaseCommandsDataT:
         """
         Parses the response from the alarm panel.
         """
-        super()._parse(data)
-        resp_data: G90BaseCommandData = self._resp.data or []
+        resp_data = super().decode_data(payload)
         try:
             page_data = resp_data.pop(0)
             page_info = G90PaginationFields(*page_data)
@@ -125,8 +124,4 @@ class G90PaginatedCommand(G90BaseCommand):
                       'total records %s, start record %s, record count %s',
                       page_info.total, page_info.start, page_info.nelems)
 
-    async def process(self) -> G90PaginatedCommand:
-        """
-        Initiates the command processing.
-        """
-        return cast(G90PaginatedCommand, await super().process())
+        return resp_data

pyg90alarm/local/system_cmd.py

@@ -0,0 +1,276 @@
+# 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.
+"""
+Provides support for system commands of the G90 alarm panel.
+"""
+from __future__ import annotations
+from typing import Any, Optional, TypeVar, List
+import logging
+
+from ..const import G90SystemCommands, G90SystemConfigurationCommands
+from .base_cmd import G90Command
+
+_LOGGER = logging.getLogger(__name__)
+
+
+SystemCommandsT = TypeVar('SystemCommandsT', bound=G90SystemCommands)
+SystemCommandsDataT = TypeVar('SystemCommandsDataT')
+
+
+class G90SystemCommandBase(G90Command[SystemCommandsT, SystemCommandsDataT]):
+    """
+    Base class for system commands of the G90 alarm panel.
+
+    :param code: System command code
+    :param kwargs: Additional arguments passed to the base class
+    """
+    def __init__(
+        self, *, code: SystemCommandsT, **kwargs: Any
+    ) -> None:
+        super().__init__(code=code, **kwargs)
+
+    @property
+    def expects_response(self) -> bool:
+        """
+        Indicates whether the command expects a response.
+
+        System commands do not return any response.
+
+        :return: False
+        """
+        return False
+
+    def encode_data(self, data: Optional[SystemCommandsDataT]) -> str:
+        """
+        Encodes the command data to string.
+
+        :param data: Data for the command
+        :return: Encoded data string
+        """
+        # Placeholder as required by the base class
+        raise NotImplementedError()  # pragma: no cover
+
+    def decode_data(self, payload: Optional[str]) -> SystemCommandsDataT:
+        """
+        Decodes the command data from string.
+
+        :param payload: Payload string
+        :return: Decoded data
+        """
+        # Placeholder as required by the base class
+        raise NotImplementedError()  # pragma: no cover
+
+    def to_wire(self) -> bytes:
+        """
+        Serializes the command to wire format as expected by the panel.
+
+        :return: Wire data
+        """
+        wire = bytes(
+            f'ISTART[0,100,"AT^IWT={self._code}{self._data},IWT"]IEND\0',
+            'utf-8'
+        )
+
+        _LOGGER.debug('Encoded to wire format %s', wire)
+        return wire
+
+    def from_wire(self, data: bytes) -> SystemCommandsDataT:
+        """
+        Deserializes the command from wire format.
+
+        :param data: Wire data
+        :return: Decoded data
+        """
+        # Placeholder as required by the base class
+        raise NotImplementedError()  # pragma: no cover
+
+    @property
+    def result(self) -> SystemCommandsDataT:
+        """
+        The result of the command.
+
+        :return: Decoded data
+        """
+        # Placeholder as required by the base class
+        raise NotImplementedError()  # pragma: no cover
+
+
+class G90SystemCommand(
+    G90SystemCommandBase[SystemCommandsT, str]
+):
+    """
+    Represents a system command of the G90 alarm panel.
+
+    :param code: System command code
+    :param kwargs: Additional arguments passed to the base class
+    """
+    def __init__(
+        self, *, code: SystemCommandsT, **kwargs: Any
+    ) -> None:
+        if code in [G90SystemCommands.SET_CONFIGURATION,
+                    G90SystemCommands.GET_CONFIGURATION]:
+            raise ValueError(
+                'Use G90SystemConfigurationCommand class for '
+                'SET_CONFIGURATION and GET_CONFIGURATION commands'
+            )
+        super().__init__(code=code, **kwargs)
+
+    def encode_data(self, data: Optional[str]) -> str:
+        """
+        Encodes the command data to string.
+
+        :param data: Data for the command
+        :return: Encoded data string
+        """
+        return data or ''
+
+    def decode_data(self, payload: Optional[str]) -> str:
+        """
+        Decodes the command data from string.
+
+        No response is expected for system commands.
+
+        :param payload: Payload string (ignored)
+        :return: Empty string
+        """
+        # No response is expected for system commands
+        return ''  # pragma: no cover
+
+    def from_wire(self, data: bytes) -> str:
+        """
+        Deserializes the command from wire format.
+
+        No response is expected for system commands.
+
+        :param data: Wire data (ignored)
+        :return: Empty string
+        """
+        # No response is expected for system commands
+        return ''  # pragma: no cover
+
+    @property
+    def result(self) -> str:
+        """
+        The result of the command.
+
+        No response is expected for system commands.
+
+        :return: Empty string
+        """
+        # No response is expected for system commands
+        return ''
+
+
+class G90SystemConfigurationCommand(
+    G90SystemCommandBase[G90SystemCommands, List[str]]
+):
+    """
+    Represents a system configuration command of the G90 alarm panel.
+
+    :param cmd: Sub-command code for configuration command
+    :param data: Data for the command
+    :param kwargs: Additional arguments passed to the base class
+    """
+    def __init__(
+        self, *, cmd: G90SystemConfigurationCommands,
+        data: Optional[List[str]] = None,
+        **kwargs: Any
+    ) -> None:
+        self._cmd = cmd
+        super().__init__(
+            code=G90SystemCommands.SET_CONFIGURATION, data=data, **kwargs
+        )
+
+    def encode_data(self, data: Optional[List[str]]) -> str:
+        """
+        Encodes the command data to string.
+
+        :param data: Data for the command
+        :return: Encoded data string
+        """
+        if data is None:
+            raise ValueError('Data must be provided for configuration command')
+
+        res = f',{self._cmd.value}={"&".join(data)}'
+        _LOGGER.debug('Encoded data "%s" to string format: %s', data, res)
+        return res
+
+    def decode_data(self, payload: Optional[str]) -> List[str]:
+        """
+        Decodes the command data from string.
+
+        System configuration commands do not return any response.
+
+        :param payload: Payload string
+        :return: Empty list
+        """
+        # System configuration commands do not return any response.
+        return []  # pragma: no cover
+
+    def from_wire(self, data: bytes) -> List[str]:
+        """
+        Deserializes the command from wire format.
+
+        System configuration commands do not return any response.
+
+        :param data: Wire data
+        :return: Empty list
+        """
+        # System configuration commands do not return any response.
+        return []  # pragma: no cover
+
+    @property
+    def result(self) -> List[str]:
+        """
+        The result of the command.
+
+        System configuration commands do not return any response.
+
+        :return: Empty list
+        """
+        # System configuration commands do not return any response.
+        return []  # pragma: no cover
+
+
+class G90SetServerAddressCommand(
+    G90SystemConfigurationCommand
+):
+    """
+    Sets the server address for the panel to communicate with using the cloud
+    notifications protocol.
+
+    :param cloud_ip: IP address of the cloud server
+    :param cloud_port: Port number of the cloud server
+    :param kwargs: Additional arguments passed to the base class
+    """
+    def __init__(
+        self, *, cloud_ip: str, cloud_port: int,
+        **kwargs: Any
+    ) -> None:
+        super().__init__(
+            cmd=G90SystemConfigurationCommands.SERVER_ADDRESS,
+            # The command requires two fields for the cloud server address, 1st
+            # is used by the panel to communicate with the server, while 2nd
+            # might potentially be a fallback address or alike. However,
+            # experiments did not show any attempts by the panel to use the 2nd
+            # address, so we set both to the same value in an avoidance of
+            # doubt.
+            data=[cloud_ip, cloud_ip, str(cloud_port)], **kwargs
+        )

{pyg90alarm-2.6.0.dist-info → pyg90alarm-2.7.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyg90alarm
-Version: 2.6.0
+Version: 2.7.1
 Summary: G90 Alarm system protocol
 Home-page: https://github.com/hostcc/pyg90alarm
 Author: Ilia Sotnikov
@@ -189,7 +189,7 @@ Cloud notifications
 The cloud protocol is native to the panel and is used to interact with mobile application. The package can mimic the cloud server and interpret the messages the panel sends to the cloud, allowing to receive the notifications and alerts.
 While the protocol also allows to send commands to the panel, it is not implemented and local protocol is used for that - i.e. when cloud notifications are in use the local protocol still utilized for sending commands to the panel.
 
-The cloud protocol is TCP based and typically interacts with cloud service at known IP address and port (not customizable at panel side). To process the cloud notifications all the traffic from panel towards the cloud (IP address ``47.88.7.61`` and TCP port ``5678`` as of writing) needs to be diverted to the node where the package is running - depending on your network equipment it could be port forwarding, DNAT or other means. It is unclear whether the panel utilizes DNS to resolve the cloud service IP address, hence the documentation only mentions IP-based traffic redirection.
+The cloud protocol is TCP based and typically interacts with cloud service at known IP address and port, which could be customized. To process the cloud notifications all the traffic from panel towards the configured IP address service needs to be received by the node where the package is running.
 
 Please see
 `the section <docs/cloud-protocol.rst>`_ for further details on the protocol.
@@ -203,25 +203,6 @@ The package could act as:
 - Chained cloud server, where in addition to interpreting the notifications it
   will also forward all packets received from the panel to the cloud server, and pass its responses back to the panel. This allows to have notifications processed by the package and the mobile application working as well.
 
-  .. note:: Sending packets upstream to the known IP address and port of the cloud server might result in those looped back (since traffic from panel to cloud service has to be redirected to the host where package runs), if your network equipment can't account for source address in redirection rules (i.e. limiting the port redirection to the panel's IP address). In that case you'll need another redirection, from the host where the package runs to the cloud service using an IP from your network. That way those two redirection rules will coexist correctly. To illustrate:
-
-   Port forwarding rule 1:
-
-   - Source: panel IP address
-   - Destination: 47.88.7.61
-   - Port: 5678
-   - Redirect to host: host where package runs
-   - Redirect to port: 5678 (or other port if you want to use it)
-
-
-   Port forwarding rule 2 (optional):
-
-   - Source: host where package runs
-   - Destination: an IP address from your network
-   - Port: 5678 (or other port if you want to use it)
-   - Redirect to : 47.88.7.61
-   - Redirect to port: 5678
-
 The code fragments below demonstrate how to utilize both modes - please note those are incomplete, since no callbacks are set to process the notifications.
 
 **Standalone mode**
@@ -232,10 +213,20 @@ The code fragments below demonstrate how to utilize both modes - please note tho
 
    # Create an instance of the alarm panel
    alarm = G90Alarm(host='<panel IP address>')
+
+   # Configure cloud server address the panel should use - the host running the
+   # package.
+   await alarm.set_cloud_server_address(
+      cloud_ip='<host IP address running the package>', cloud_port=5678
+   )
+
    # Enable cloud notifications
    await alarm.use_cloud_notifications(
-      # Optional, see note above redirecting cloud traffic from panel
-      local_port=5678,
+      # The host/port the package will listen on for the cloud notifications,
+      # should match ones above.
+      cloud_ip='<host IP address running the package>',
+      cloud_port=5678,
+      cloud_local_port=5678,
       upstream_host=None
    )
    # Start listening for notifications
@@ -250,11 +241,22 @@ The code fragments below demonstrate how to utilize both modes - please note tho
 
    # Create an instance of the alarm panel
    alarm = G90Alarm(host='<panel IP address>')
+
+   # Configure cloud server address the panel should use - the host running the
+   # package.
+   await alarm.set_cloud_server_address(
+      cloud_ip='<host IP address running the package>', cloud_port=5678
+   )
+
    # Enable cloud notifications
    await alarm.use_cloud_notifications(
-      # Optional, see note above redirecting cloud traffic from panel
-      local_port=5678,
-      # See note above re: cloud service and sending packets to it
+      # The host/port the package will listen on for the cloud notifications,
+      # should match ones above.
+      cloud_ip='<host IP address running the package>',
+      cloud_port=5678,
+      cloud_local_port=5678,
+      # Upstream cloud server address the package should forward the
+      # notifications to.
       upstream_host='47.88.7.61',
       upstream_port=5678
    )

{pyg90alarm-2.6.0.dist-info → pyg90alarm-2.7.1.dist-info}/RECORD

@@ -1,15 +1,15 @@
 pyg90alarm/__init__.py,sha256=Z1Y5bwYmtY5iycIv6IDQ464o4Q-sU7fo9S3f94NGOpg,3786
-pyg90alarm/alarm.py,sha256=BDBVQ8qRa2Bx2-786uytShTw8znlFEWakxweCGvgxME,50130
+pyg90alarm/alarm.py,sha256=3ct1UbLKSnazVKRxQvAi1N1cazT-EoEcp_ttHJu8L-g,54147
 pyg90alarm/callback.py,sha256=9PVtjRs2MLn80AgiM-UJNL8ZJF4_PxcopJIpxMmB3vc,4707
-pyg90alarm/const.py,sha256=cpaMlb8rqE1EfvmUEh3Yd_29dNO0usIo_Y-esPBh8B0,8012
+pyg90alarm/const.py,sha256=DKM1c3meX0kPnCm8g9b65o5UYm-89mgBv1we8ypLVFI,8674
 pyg90alarm/event_mapping.py,sha256=hSmRWkkuA5hlauGvYakdOrw8QFt0TMNfUuDQ4J3vHpQ,3438
 pyg90alarm/exceptions.py,sha256=9rSd5zIKALHtRHBBLD-R5zxW-5OBkHK04uVupCnAK8s,1937
 pyg90alarm/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pyg90alarm/cloud/__init__.py,sha256=u7ZzrIwCsdgmBmgtpCe6c_Kipdo8nG8PEOEcaAHXCxI,1407
 pyg90alarm/cloud/const.py,sha256=FYUxkj0DSI7nnXZHsJMfv8RNQiXKV3TYKGHSdfHdMjg,2113
-pyg90alarm/cloud/messages.py,sha256=L3cpP3IbDRdw3W6FeQxTPXoDlpUv7Fm4t-RkH9Uj4dg,18032
-pyg90alarm/cloud/notifications.py,sha256=0RxCBVcvDuwE0I1m3SLDXDQqCJimDcN4f45gr-Hvt1A,15669
-pyg90alarm/cloud/protocol.py,sha256=82l2IXSM12tv_iWkTrAQZ-aw5UR4tmWFQJKVcgBfIww,16159
+pyg90alarm/cloud/messages.py,sha256=kpaEPagzsK_fQZmNNIliz3F3KXi-xLXzR0AYze4CMKI,17674
+pyg90alarm/cloud/notifications.py,sha256=yW9ye2qgoE3djKFN-y6UKScBkmzaCm5wKFbovjoLFPU,15818
+pyg90alarm/cloud/protocol.py,sha256=pr7jwukZr8jKUApqAsTfX9U8mZS8DXlVNRPcdio3lqI,16155
 pyg90alarm/dataclass/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pyg90alarm/dataclass/load_save.py,sha256=I2WDeW4GingN8AEiwZm9Epf1gVL_Ynkise2h781Dn3I,8604
 pyg90alarm/dataclass/validation.py,sha256=yd3Q86S0L5NekzoiVFW5SwpefbIhWpwvsS-S15X4Sf8,19107
@@ -27,7 +27,7 @@ pyg90alarm/entities/sensor_list.py,sha256=0S88bhTn91O45WgbIIMQ0iXaNjlUWmMBOOFwj2
 pyg90alarm/local/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pyg90alarm/local/alarm_phones.py,sha256=bGg4aEJwtl7oMlLdOGpW2Vv4q4zS9wzkpW4q3Qy2JCU,4375
 pyg90alarm/local/alert_config.py,sha256=n2dycEf6TH0MKefQXMcRsCFJyYvUMV55LRsy4FARtDI,6027
-pyg90alarm/local/base_cmd.py,sha256=f0PozHJjErIg08vn0sAacHbigJSFor8q5jdxfXiM27c,10491
+pyg90alarm/local/base_cmd.py,sha256=kmjIFwt63sNxz2CdGw1wHv2LOsD8BJhRFxaPszhywSM,12591
 pyg90alarm/local/config.py,sha256=QYetAc6QLrAN8T-37D4Esifvao52w_uJ01nHciLbGME,1390
 pyg90alarm/local/discovery.py,sha256=8YVIXuNe57lhas0VSRf7QXZH83pEDGNj9oehNY4Kh2U,3576
 pyg90alarm/local/history.py,sha256=sL6_Z1BNYkuUwAZUi78d4p5hhcCfsXKw29i4Qu1O60M,10811
@@ -35,16 +35,17 @@ pyg90alarm/local/host_config.py,sha256=RSvg2UXPTCzzwDW6Iz3CyFtjxPUzSSdlxRMqGpWA6
 pyg90alarm/local/host_info.py,sha256=gdneg2XxxMNSFfNTjXCqsBsLZgZr_wg38sudKJ24RD8,3550
 pyg90alarm/local/host_status.py,sha256=WHGtw-A0wHILqVWP4DnZhXj8DPRGyS26AV0bL1isTz4,1863
 pyg90alarm/local/net_config.py,sha256=Y4-SUVSukk-h5x3LK-HH3IlM72dP_46nj1H8lN9rTfo,5998
-pyg90alarm/local/notifications.py,sha256=Vs6NQJciYqDALV-WwzH6wIcTGdX_UD4XBuHWjSOpCDY,4591
-pyg90alarm/local/paginated_cmd.py,sha256=5pPVP8f4ydjgu8Yq6MwqINJAUt52fFlD17wO4AI88Pc,4467
+pyg90alarm/local/notifications.py,sha256=T9Tfi_e_q0yIJEU_6A1XpBUhLVORWfNnlilQRwLx5n4,4585
+pyg90alarm/local/paginated_cmd.py,sha256=mgk46Xz7vJP9qv2YZlUIzGhxRKReuydKVgcj-f8DkvE,4300
 pyg90alarm/local/paginated_result.py,sha256=p_e8QAVznp1Q5Xi9ifjb9Bx-S3ZiAkVlPKrY6r0bYLs,5483
+pyg90alarm/local/system_cmd.py,sha256=LtkrGlBEjZKaNsycWDLS2lt8NLasWgRAMpMtpAD7AOk,8770
 pyg90alarm/local/targeted_discovery.py,sha256=Ik2C2VBtVLurf3-RKko4O2R3B6MrmFdOskd457uyASU,5516
 pyg90alarm/local/user_data_crc.py,sha256=JQBOPY3RlOgVtvR55R-rM8OuKjYW-BPXQ0W4pi6CEH0,1689
 pyg90alarm/notifications/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pyg90alarm/notifications/base.py,sha256=d3N_zNPa_jcTX4QpA78jdgMHDhmrgwqyM3HdvuO14Jk,16682
 pyg90alarm/notifications/protocol.py,sha256=TlZQ3P8-N-E2X5bzkGefz432x4lBYyIBF9VriwYn9ds,4790
-pyg90alarm-2.6.0.dist-info/licenses/LICENSE,sha256=f884inRbeNv-O-hbwz62Ro_1J8xiHRTnJ2cCx6A0WvU,1070
-pyg90alarm-2.6.0.dist-info/METADATA,sha256=VDotWAaE433s73_xrvXL1dpHDBG2T9o10-UuASDBvRs,12568
-pyg90alarm-2.6.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-pyg90alarm-2.6.0.dist-info/top_level.txt,sha256=czHiGxYMyTk5QEDTDb0EpPiKqUMRa8zI4zx58Ii409M,11
-pyg90alarm-2.6.0.dist-info/RECORD,,
+pyg90alarm-2.7.1.dist-info/licenses/LICENSE,sha256=f884inRbeNv-O-hbwz62Ro_1J8xiHRTnJ2cCx6A0WvU,1070
+pyg90alarm-2.7.1.dist-info/METADATA,sha256=vQ43pgpWnoP3zPamoD0IgtDrDPZ8lY5C-B8l2dNyUsg,11955
+pyg90alarm-2.7.1.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+pyg90alarm-2.7.1.dist-info/top_level.txt,sha256=czHiGxYMyTk5QEDTDb0EpPiKqUMRa8zI4zx58Ii409M,11
+pyg90alarm-2.7.1.dist-info/RECORD,,