pyg90alarm 2.6.0__tar.gz → 2.7.1__tar.gz

{pyg90alarm-2.6.0 → pyg90alarm-2.7.1}/.github/workflows/main.yml

@@ -3,8 +3,6 @@ name: main
 
 on:
   pull_request:
-  release:
-    types: [published]
   push:
     branches:
       - main
@@ -68,10 +66,35 @@ jobs:
             -Dsonar.projectVersion=${{ steps.package-version.outputs.VALUE }}
           # yamllint enable rule:line-length
 
+  release:
+    name: Release with semantic-release
+    runs-on: ubuntu-latest
+    needs: [tests]
+    permissions:
+      contents: write
+      issues: write
+      pull-requests: write
+    outputs:
+      new_release_published: ${{ steps.semantic.outputs.new_release_published }}
+    steps:
+      - name: Checkout code (SSH)
+        uses: actions/checkout@v6
+        with:
+          fetch-depth: 0
+
+      - name: Run semantic release
+        id: semantic
+        uses: cycjimmy/semantic-release-action@v6
+        with:
+          extra_plugins: |
+            conventional-changelog-conventionalcommits@9.1.0
+        env:
+          GITHUB_TOKEN: ${{ github.token }}
+
   pypi-publish:
     name: Publish to PyPi
     runs-on: ubuntu-latest
-    needs: [tests]
+    needs: [tests, release]
     permissions:
       id-token: write  # Required for trusted publishing
     steps:
@@ -90,7 +113,7 @@ jobs:
       - name: Publish the package to Test PyPi
         # Skip publishing to test PyPI if we're performing release, there might
         # be already the version of the package from the merge to master branch
-        if: github.event_name != 'release'
+        if: needs.release.outputs.new_release_published != 'true'
         uses: pypa/gh-action-pypi-publish@release/v1
         with:
           repository-url: https://test.pypi.org/legacy/
@@ -98,11 +121,7 @@ jobs:
       - name: Publish the release to PyPi
         # Publish to production PyPi only happens when a release published out
         # of the main branch
-        if: >-
-          github.event_name == 'release'
-          && github.event.action == 'published'
-          && (github.event.release.target_commitish == 'main'
-             || github.event.release.target_commitish == 'master')
+        if: needs.release.outputs.new_release_published == 'true'
         uses: pypa/gh-action-pypi-publish@release/v1
         with:
           attestations: true

{pyg90alarm-2.6.0 → pyg90alarm-2.7.1}/PKG-INFO

@@ -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 → pyg90alarm-2.7.1}/README.rst

@@ -142,7 +142,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.
@@ -156,25 +156,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**
@@ -185,10 +166,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
@@ -203,11 +194,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 → pyg90alarm-2.7.1}/docs/local-protocol.rst

@@ -158,3 +158,62 @@ uses ``utf-8`` encoding.
 
 Data varies across different notification and alert types, see
 `src/pyg90alarm/local/notifications.py <../../src/pyg90alarm/local/notifications.py>`_.
+
+System commands
+---------------
+
+In addition to regular commands, the local protocol also supports system commands that perform device maintenance operations. Unlike regular commands, system commands do not expect a response from the device and are invoked using a special wire format based on AT commands.
+
+.. note:: System commands are not exposed through regular command interface but have their own dedicated methods in the ``G90Alarm`` class.
+
+Wire Format
+^^^^^^^^^^^
+
+System commands use a different wire format compared to regular commands:
+
+:samp:`ISTART[0,100,"AT^IWT={command code}{command data},IWT"]IEND\\0`
+
+The command is wrapped in an AT command format (``AT^IWT=...``) within a regular command structure with fixed codes ``0`` and ``100``.
+
+Available System Commands
+^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+The following system commands are available:
+
+- MCU Reboot (code ``1123``)
+  Reboots the Main Control Unit (MCU) of the alarm panel.
+
+  **Wire format example:**
+
+  :samp:`ISTART[0,100,"AT^IWT=1123,IWT"]IEND\\0`
+
+- GSM Reboot (code ``1129``)
+  Reboots the GSM module of the alarm panel.
+
+  **Wire format example:**
+
+  :samp:`ISTART[0,100,"AT^IWT=1129,IWT"]IEND\\0`
+
+- WiFi Reboot (code ``1006``)
+  Reboots the WiFi module of the alarm panel.
+
+  **Wire format example:**
+
+  :samp:`ISTART[0,100,"AT^IWT=1006,IWT"]IEND\\0`
+
+- Set Server Address (configuration command ``1`` with sub-command ``78``)
+  Configures the cloud server address that the alarm panel connects to.
+  The command requires three parameters separated by ``&``: cloud primary host,
+  cloud secondary host, and cloud port number.
+
+  There is no indication the panel will use DNS resolution, so both addresses should be IP ones. Also, it is unclear what 2nd address is used for - experiments revealed the panel always connects to the 1st one.
+
+  **Wire format example:**
+
+  :samp:`ISTART[0,100,"AT^IWT=1,78=192.168.1.100&192.168.1.100&5678,IWT"]IEND\\0`
+
+  Where:
+
+  - ``192.168.1.100`` is the primary IP address of the cloud server
+  - ``192.168.1.100`` is the secondary IP address of the cloud server (see above note)
+  - ``5678`` is the port number the cloud server listens on

{pyg90alarm-2.6.0 → pyg90alarm-2.7.1}/src/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-2.6.0 → pyg90alarm-2.7.1}/src/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-2.6.0 → pyg90alarm-2.7.1}/src/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-2.6.0 → pyg90alarm-2.7.1}/src/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]