pyg90alarm 2.2.0__tar.gz → 2.3.1__tar.gz

pyg90alarm-2.3.1/.github/dependabot.yml

@@ -0,0 +1,26 @@
+---
+version: 2
+updates:
+  - package-ecosystem: "pip"
+    directory: "/"
+    schedule:
+      interval: "daily"
+    commit-message:
+      prefix: "deps"
+      include: "scope"
+    labels:
+      - "dependencies"
+      - "automated"
+    open-pull-requests-limit: 5
+
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: "daily"
+    commit-message:
+      prefix: "deps"
+      include: "scope"
+    labels:
+      - "dependencies"
+      - "automated"
+    open-pull-requests-limit: 5

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

@@ -34,13 +34,13 @@ jobs:
     runs-on: ${{ matrix.os }}
     steps:
       - name: Checkout the code
-        uses: actions/checkout@v3
+        uses: actions/checkout@v6
         with:
           # Disable shallow clone for Sonar scanner, as it needs access to the
           # history
           fetch-depth: 0
       - name: Set Python up
-        uses: actions/setup-python@v4
+        uses: actions/setup-python@v6
         with:
           python-version: ${{ matrix.python }}
       - name: Install testing tools
@@ -56,7 +56,7 @@ jobs:
           package_version=`python3 setup.py --version`
           echo "VALUE=$package_version" >> $GITHUB_OUTPUT
       - name: SonarCloud scanning
-        uses: sonarsource/sonarcloud-github-action@master
+        uses: SonarSource/sonarqube-scan-action@v6
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
           SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }}
@@ -76,11 +76,11 @@ jobs:
       id-token: write  # Required for trusted publishing
     steps:
       - name: Checkout the code
-        uses: actions/checkout@v3
+        uses: actions/checkout@v6
         with:
           fetch-depth: 0  # `setuptools_scm` needs tags
       - name: Set Python up
-        uses: actions/setup-python@v4
+        uses: actions/setup-python@v6
         with:
           python-version: 3.9
       - name: Install the PEP517 package builder
@@ -93,7 +93,7 @@ jobs:
         if: github.event_name != 'release'
         uses: pypa/gh-action-pypi-publish@release/v1
         with:
-          repository_url: https://test.pypi.org/legacy/
+          repository-url: https://test.pypi.org/legacy/
           attestations: true
       - name: Publish the release to PyPi
         # Publish to production PyPi only happens when a release published out

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

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

{pyg90alarm-2.2.0 → pyg90alarm-2.3.1}/pyproject.toml

@@ -11,6 +11,7 @@ local_scheme = "no-local-version"
 log_cli = 1
 log_cli_level = "error"
 asyncio_mode = "auto"
+asyncio_default_fixture_loop_scope = "function"
 pythonpath = "src/"
 
 [tool.coverage.run]

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

@@ -566,10 +566,11 @@ 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 = await self.alert_config.get_flag(
-                G90AlertConfigFlags.DOOR_CLOSE
+            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
@@ -587,7 +588,7 @@ class G90Alarm(G90NotificationProtocol):
                               ' closing event will be emulated upon'
                               ' %s seconds',
                               name, sensor.type,
-                              await self.alert_config.flags,
+                              alert_config_flags,
                               self._reset_occupancy_interval)
                 G90Callback.invoke_delayed(
                     self._reset_occupancy_interval,
@@ -1230,6 +1231,7 @@ class G90Alarm(G90NotificationProtocol):
             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,

{pyg90alarm-2.2.0 → pyg90alarm-2.3.1}/src/pyg90alarm/cloud/notifications.py

@@ -69,7 +69,8 @@ class G90CloudNotifications(G90NotificationsBase, asyncio.Protocol):
     :param keep_single_connection: Whether to keep only a single device
      connection
     """
-    # pylint:disable=too-many-arguments
+    # pylint:disable=too-many-positional-arguments,too-many-arguments
+    # pylint:disable=too-many-statements
     def __init__(
         self,
         protocol_factory: Callable[[], G90NotificationProtocol],

{pyg90alarm-2.2.0 → pyg90alarm-2.3.1}/src/pyg90alarm/entities/base_list.py

@@ -68,7 +68,7 @@ class G90BaseList(Generic[T], ABC):
 
         :return: Async generator of entities
         """
-        yield cast(T, None)
+        yield cast(T, None)  # pragma: no cover
 
     @property
     async def entities(self) -> List[T]:
@@ -231,25 +231,30 @@ class G90BaseList(Generic[T], ABC):
         # Collect indexes in use by the existing entities
         occupied_indexes = set(x.index for x in entities)
         # Generate a set of possible indexes from 0 to the maximum index in
-        # use
-        possible_indexes = set(range(0, max(occupied_indexes)))
+        # use, or provide an empty set if there are no existing entities
+        if occupied_indexes:
+            possible_indexes = set(range(0, max(occupied_indexes)))
+        else:
+            # No occupied indexes, so possible_indexes is empty
+            possible_indexes = set()
 
         try:
             # Find the first free index by taking difference between
             # possible indexes and occupied ones, and then taking the minimum
             # value off the difference
             free_idx = min(
-                set(possible_indexes).difference(occupied_indexes)
+                possible_indexes.difference(occupied_indexes)
             )
-            _LOGGER.debug(
-                'Found free index: %s out of occupied indexes: %s',
-                free_idx, occupied_indexes
-            )
-            return free_idx
         except ValueError:
             # If no gaps in existing indexes, then return the index next to
             # the last existing entity
-            return len(entities)
+            free_idx = len(entities)
+
+        _LOGGER.debug(
+            'Found free index=%s out of occupied indexes: %s',
+            free_idx, occupied_indexes
+        )
+        return free_idx
 
     @property
     def list_change_callback(self) -> Optional[ListChangeCallback[T]]:

{pyg90alarm-2.2.0 → pyg90alarm-2.3.1}/src/pyg90alarm/local/base_cmd.py

@@ -59,11 +59,11 @@ class G90BaseCommand(DatagramProtocol):
     # 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,
                  local_port: Optional[int] = None,
                  timeout: float = 3.0, retries: int = 3) -> None:
-        # pylint: disable=too-many-arguments
         self._remote_host = host
         self._remote_port = port
         self._local_port = local_port

{pyg90alarm-2.2.0 → pyg90alarm-2.3.1}/src/pyg90alarm/local/config.py

@@ -22,7 +22,7 @@
 Represents various configuration aspects of the alarm panel.
 """
 from __future__ import annotations
-from typing import TYPE_CHECKING, Optional
+from typing import TYPE_CHECKING
 import logging
 from dataclasses import dataclass
 from enum import IntFlag
@@ -79,22 +79,9 @@ class G90AlertConfig:
     Represents alert configuration as received from the alarm panel.
     """
     def __init__(self, parent: G90Alarm) -> None:
-        self._alert_config: Optional[G90AlertConfigData] = None
         self.parent = parent
 
     async def _get(self) -> G90AlertConfigData:
-        """
-        Retrieves the alert configuration flags from the device. Please note
-        the configuration is cached upon first call, so you need to
-        re-instantiate the class to reflect any updates there.
-
-        :return: The alerts configured
-        """
-        if not self._alert_config:
-            self._alert_config = await self._get_uncached()
-        return self._alert_config
-
-    async def _get_uncached(self) -> G90AlertConfigData:
         """
         Retrieves the alert configuration flags directly from the device.
 
@@ -110,22 +97,23 @@ class G90AlertConfig:
         return data
 
     async def set(self, flags: G90AlertConfigFlags) -> None:
+        """
+        .. deprecated:: 2.3.0
+
+        This method is deprecated and will always raise a RuntimeError.
+        Please use :meth:`set_flag` to set individual flags.
+        """
+        raise RuntimeError(
+            'The set() method is deprecated. Please use set_flag() to set'
+            ' individual flags instead.'
+        )
+
+    async def _set(self, flags: G90AlertConfigFlags) -> None:
         """
         Sets the alert configuration flags on the device.
         """
-        # Use uncached method retrieving the alert configuration, to ensure the
-        # actual value retrieved from the device
         _LOGGER.debug('Setting alert configuration to %s', repr(flags))
-        alert_config = await self._get_uncached()
-        if alert_config != self._alert_config:
-            _LOGGER.warning(
-                'Alert configuration changed externally,'
-                ' overwriting (read "%s", will be set to "%s")',
-                repr(alert_config), repr(flags)
-            )
         await self.parent.command(G90Commands.SETNOTICEFLAG, [flags.value])
-        # Update the alert configuration stored
-        (await self._get()).flags = flags
 
     async def get_flag(self, flag: G90AlertConfigFlags) -> bool:
         """
@@ -135,20 +123,31 @@ class G90AlertConfig:
 
     async def set_flag(self, flag: G90AlertConfigFlags, value: bool) -> None:
         """
+        Sets the given flag to the desired value.
+
+        Uses read-modify-write approach.
+
         :param flag: The flag to set
         :param value: The value to set
         """
+        # Retrieve current flags
+        current_flags = await self.flags
         # Skip updating the flag if it has the desired value
-        if await self.get_flag(flag) == value:
+        if (flag in current_flags) == value:
             _LOGGER.debug(
                 'Flag %s already set to %s, skipping update',
                 repr(flag), value
             )
             return
 
-        # Invert corresponding user flag and set it
-        flags = await self.flags ^ flag
-        await self.set(flags)
+        # Set or reset corresponding user flag depending on desired value
+        if value:
+            current_flags |= flag
+        else:
+            current_flags &= ~flag
+
+        # Set the updated flags
+        await self._set(current_flags)
 
     @property
     async def flags(self) -> G90AlertConfigFlags:

{pyg90alarm-2.2.0 → pyg90alarm-2.3.1}/src/pyg90alarm/local/notifications.py

@@ -55,7 +55,8 @@ class G90LocalNotifications(G90NotificationsBase, DatagramProtocol):
     :param local_host: The host on which the local host is listening for
      notifications.
     """
-    def __init__(  # pylint:disable=too-many-arguments
+    # 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,
     ):

{pyg90alarm-2.2.0 → pyg90alarm-2.3.1}/src/pyg90alarm/local/paginated_cmd.py

@@ -48,11 +48,11 @@ class G90PaginatedCommand(G90BaseCommand):
     """
     Implements paginated command for alarm panel protocol.
     """
+    # pylint: disable=too-many-positional-arguments,too-many-arguments
     def __init__(
         self, host: str, port: int, code: G90Commands, start: int, end: int,
         **kwargs: Any
     ) -> None:
-        # pylint: disable=too-many-arguments
         self._start = start
         self._end = end
         self._expected_nelems = end - start + 1

{pyg90alarm-2.2.0 → pyg90alarm-2.3.1}/src/pyg90alarm/local/paginated_result.py

@@ -49,11 +49,11 @@ class G90PaginatedResult:
     Processes paginated response from G90 corresponding panel commands.
     """
     # pylint: disable=too-few-public-methods
+    # pylint: disable=too-many-positional-arguments,too-many-arguments
     def __init__(
         self, host: str, port: int, code: G90Commands, start: int = 1,
         end: Optional[int] = None, **kwargs: Any
     ):
-        # pylint: disable=too-many-arguments
         self._host = host
         self._port = port
         self._code = code

{pyg90alarm-2.2.0 → pyg90alarm-2.3.1}/src/pyg90alarm.egg-info/PKG-INFO

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

{pyg90alarm-2.2.0 → pyg90alarm-2.3.1}/src/pyg90alarm.egg-info/SOURCES.txt

@@ -10,6 +10,7 @@ setup.py
 sonar-project.properties
 tox.ini
 .github/CODEOWNERS
+.github/dependabot.yml
 .github/workflows/main.yml
 docs/.DS_Store
 docs/.gitignore
@@ -73,4 +74,5 @@ tests/test_discovery.py
 tests/test_history.py
 tests/test_local_notifications.py
 tests/test_paginated_commands.py
-tests/test_sensor.py
+tests/test_sensor.py
+tests/unit/entities/test_base_list.py

{pyg90alarm-2.2.0 → pyg90alarm-2.3.1}/tests/device_mock.py

@@ -406,7 +406,8 @@ class DeviceMock:  # pylint:disable=too-many-instance-attributes
     :param cloud_upstream_port: The port the simulated cloud upstream
      endpoint listens on for client requests
     """
-    def __init__(  # pylint:disable=too-many-arguments
+    # pylint:disable=too-many-positional-arguments,too-many-arguments
+    def __init__(
         self, data: List[bytes], notification_data: List[bytes],
         device_port: int, notification_port: int,
         cloud_notification_data: Optional[List[bytes]] = None,

{pyg90alarm-2.2.0 → pyg90alarm-2.3.1}/tests/test_alarm.py

@@ -432,6 +432,7 @@ async def test_door_open_close_callback(mock_device: DeviceMock) -> None:
         # Alert configuration, used by sensor activity callback invoked when
         # handling alarm
         b'ISTART[117,[256]]IEND\0',
+        b'ISTART[117,[256]]IEND\0',
     ],
     notification_data=[
         b'[208,[3,100,1,1,"Hall","DUMMYGUID",1630876128,0,[""]]]\0',
@@ -553,6 +554,7 @@ async def test_sensor_tamper_callback(
         b'ISTART[102,'
         b'[[1,1,1],["Remote",11,0,10,1,0,32,0,0,16,1,0,""]]]IEND\0',
         b'ISTART[117,[256]]IEND\0',
+        b'ISTART[117,[256]]IEND\0',
     ],
     notification_data=[
         # Host SOS
@@ -602,9 +604,18 @@ async def test_sos_callback(mock_device: DeviceMock) -> None:
     # Button press callback should be called with the remote button state, but
     # only for SOS initiated by the remote
     button_cb.assert_called_once_with(11, 'Remote', G90RemoteButtonStates.SOS)
-
     await g90.close_notifications()
 
+    # Test incurs other callbacks and corresponding tasks (two invocations of
+    # on_sensor_activity callback for reflecting state changes for the remote
+    # as a sensor), but those aren't in scope - explicitly await any
+    # pending tasks to avoid asyncio warnings
+    await asyncio.gather(
+        *(t for t in asyncio.all_tasks() if t is not asyncio.current_task()),
+        # Ignore exceptions from other tasks
+        return_exceptions=True
+    )
+
 
 @pytest.mark.g90device(
     sent_data=[
@@ -690,11 +701,7 @@ async def test_disarm(mock_device: DeviceMock) -> None:
 
 @pytest.mark.g90device(
     sent_data=[
-        # First command to get alert configuration is from
-        # `G90Alarm.get_alert_config()` property
-        b"ISTART[117,[1]]IEND\0",
-        # Second command for same is invoked by `G90Alarm.set_alert_config`
-        # that checks if alert config has been modified externally
+        # Get alert configuration
         b"ISTART[117,[1]]IEND\0",
         b"ISTARTIEND\0",
         # Simulated list of sensors, which is used to reset door open when
@@ -738,7 +745,6 @@ async def test_sms_alert_when_armed(mock_device: DeviceMock) -> None:
     sent_data=[
         # See above for the clarification on command sequence
         b"ISTART[117,[513]]IEND\0",
-        b"ISTART[117,[513]]IEND\0",
         b"ISTARTIEND\0",
         b'ISTART[102,'
         b'[[3,1,3],["Remote 1",10,0,10,1,0,32,0,0,16,1,0,""],'

{pyg90alarm-2.2.0 → pyg90alarm-2.3.1}/tests/test_config.py

@@ -29,7 +29,7 @@ async def test_alert_config(mock_device: DeviceMock) -> None:
 
 @pytest.mark.g90device(sent_data=[
     b"ISTART[117,[1]]IEND\0",
-    b"ISTART[117,[3]]IEND\0",
+    b"ISTART[117,[1]]IEND\0",
     b"ISTARTIEND\0",
 ])
 async def test_set_alert_config(mock_device: DeviceMock) -> None:
@@ -38,15 +38,16 @@ async def test_set_alert_config(mock_device: DeviceMock) -> None:
     """
     g90 = G90Alarm(host=mock_device.host, port=mock_device.port)
 
-    await g90.alert_config.set_flag(G90AlertConfigFlags.AC_POWER_FAILURE, True)
-    await g90.alert_config.set_flag(G90AlertConfigFlags.HOST_LOW_VOLTAGE, True)
+    # The flag is already set, so no update should be performed
+    await g90.alert_config.set_flag(
+        G90AlertConfigFlags.AC_POWER_FAILURE, True
+    )
+    await g90.alert_config.set_flag(
+        G90AlertConfigFlags.HOST_LOW_VOLTAGE, True
+    )
+
     assert await mock_device.recv_data == [
         b'ISTART[117,117,""]IEND\0',
         b'ISTART[117,117,""]IEND\0',
         b"ISTART[116,116,[116,[9]]]IEND\0",
     ]
-    # Validate we retrieve same alert configuration just has been set
-    assert await g90.alert_config.get_flag(
-        G90AlertConfigFlags.AC_POWER_FAILURE) is True
-    assert await g90.alert_config.get_flag(
-        G90AlertConfigFlags.HOST_LOW_VOLTAGE) is True

pyg90alarm-2.3.1/tests/unit/entities/test_base_list.py

@@ -0,0 +1,192 @@
+"""
+Tests for G90BaseList class
+"""
+from __future__ import annotations
+from typing import AsyncGenerator
+from unittest.mock import MagicMock
+
+from pyg90alarm.entities.base_list import G90BaseList
+
+
+class TestBaseList(G90BaseList[MagicMock]):
+    """
+    Mock subclass for testing G90BaseList.
+    """
+
+    # Prevent pytest from collecting this class as a test case
+    __test__ = False
+
+    async def _fetch(self) -> AsyncGenerator[MagicMock, None]:
+        """Mock _fetch method."""
+        if False:  # pragma: no cover
+            yield MagicMock()
+
+
+async def test_find_free_idx_empty_list() -> None:
+    """
+    Tests find_free_idx with empty entities list.
+    """
+
+    parent = MagicMock()
+    base_list = TestBaseList(parent)
+    base_list._entities = []
+
+    result = await base_list.find_free_idx()
+
+    assert result == 0
+
+
+async def test_find_free_idx_one_entity_at_zero() -> None:
+    """
+    Tests find_free_idx with one entity at index 0.
+    """
+
+    base_list = TestBaseList(parent=MagicMock())
+    base_list._entities = [MagicMock(index=0)]
+
+    result = await base_list.find_free_idx()
+
+    assert result == 1
+
+
+async def test_find_free_idx_returns_lowest_available_index() -> None:
+    """
+    Tests find_free_idx with two entities at indexes 10 and 11.
+    """
+
+    base_list = TestBaseList(parent=MagicMock())
+    base_list._entities = [MagicMock(index=10), MagicMock(index=11)]
+
+    result = await base_list.find_free_idx()
+
+    assert result == 0
+
+
+async def test_find_free_idx_returns_lowest_available_index_over_gap() -> None:
+    """
+    Tests find_free_idx with two entities at indexes 10 and 11.
+    """
+
+    base_list = TestBaseList(parent=MagicMock())
+    base_list._entities = [
+        MagicMock(index=0), MagicMock(index=10), MagicMock(index=11)
+    ]
+
+    result = await base_list.find_free_idx()
+
+    assert result == 1
+
+
+async def test_find_entity_by_idx_and_name() -> None:
+    """
+    Tests find with matching index, subindex, and name.
+    """
+
+    base_list = TestBaseList(parent=MagicMock())
+    entity = MagicMock()
+    entity.index = 0
+    entity.subindex = 0
+    entity.name = "Test Entity"
+    entity.is_unavailable = False
+    base_list._entities = [entity]
+
+    result = await base_list.find(
+        idx=0, name="Test Entity", exclude_unavailable=False
+    )
+
+    assert result == entity
+
+
+async def test_find_entity_name_mismatch() -> None:
+    """
+    Tests find with matching index but mismatched name.
+    """
+
+    base_list = TestBaseList(parent=MagicMock())
+    entity = MagicMock()
+    entity.index = 0
+    entity.subindex = 0
+    entity.name = "Test Entity"
+    entity.is_unavailable = False
+    base_list._entities = [entity]
+
+    result = await base_list.find(
+        idx=0, name="Wrong Name", exclude_unavailable=False
+    )
+
+    assert result is None
+
+
+async def test_find_entity_not_found() -> None:
+    """
+    Tests find with non-existing index.
+    """
+
+    base_list = TestBaseList(parent=MagicMock())
+    base_list._entities = []
+
+    result = await base_list.find(
+        idx=0, name="Test Entity", exclude_unavailable=False
+    )
+
+    assert result is None
+
+
+async def test_find_entity_unavailable_excluded() -> None:
+    """
+    Tests find with unavailable entity and exclude_unavailable=True.
+    """
+
+    base_list = TestBaseList(parent=MagicMock())
+    entity = MagicMock()
+    entity.index = 0
+    entity.subindex = 0
+    entity.name = "Test Entity"
+    entity.is_unavailable = True
+    base_list._entities = [entity]
+
+    result = await base_list.find(
+        idx=0, name="Test Entity", exclude_unavailable=True
+    )
+
+    assert result is None
+
+
+async def test_find_entity_unavailable_not_excluded() -> None:
+    """
+    Tests find with unavailable entity and exclude_unavailable=False.
+    """
+
+    base_list = TestBaseList(parent=MagicMock())
+    entity = MagicMock()
+    entity.index = 0
+    entity.subindex = 0
+    entity.name = "Test Entity"
+    entity.is_unavailable = True
+    base_list._entities = [entity]
+
+    result = await base_list.find(
+        idx=0, name="Test Entity", exclude_unavailable=False
+    )
+
+    assert result == entity
+
+
+async def test_find_entity_with_subindex() -> None:
+    """
+    Tests find with specific subindex.
+    """
+
+    base_list = TestBaseList(parent=MagicMock())
+    entity = MagicMock()
+    entity.index = 0
+    entity.subindex = 1
+    entity.name = "Test Entity"
+    entity.is_unavailable = False
+    base_list._entities = [entity]
+
+    result = await base_list.find(
+        idx=0, name="Test Entity", exclude_unavailable=False, subindex=1
+    )
+
+    assert result == entity