pyg90alarm 2.5.0__tar.gz → 2.5.2__tar.gz

{pyg90alarm-2.5.0 → pyg90alarm-2.5.2}/PKG-INFO

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

{pyg90alarm-2.5.0 → pyg90alarm-2.5.2}/src/pyg90alarm/__init__.py

@@ -53,6 +53,7 @@ from .local.alarm_phones import G90AlarmPhones
 from .local.net_config import G90NetConfig, G90APNAuth
 from .local.history import G90History
 
+from .dataclass.load_save import DataclassLoadSave
 from .dataclass.validation import (
     get_field_validation_constraints,
 )
@@ -101,4 +102,6 @@ __all__ = [
     'G90History',
     # Dataclass validation
     'get_field_validation_constraints',
+    # Dataclass load/save
+    'DataclassLoadSave',
 ]

{pyg90alarm-2.5.0 → pyg90alarm-2.5.2}/src/pyg90alarm/entities/base_list.py

@@ -68,6 +68,7 @@ class G90BaseList(Generic[T], ABC):
 
         :return: Async generator of entities
         """
+        # Placeholder to satisfy the abstractmethod
         yield cast(T, None)  # pragma: no cover
 
     @property
@@ -118,7 +119,11 @@ class G90BaseList(Generic[T], ABC):
                         )
 
                         existing_entity.update(entity)
-                        non_existing_entities.remove(existing_entity)
+                        # The entity might have already been removed if there
+                        # are duplicate entities from the `_fetch` method,
+                        # protect against that
+                        if existing_entity in non_existing_entities:
+                            non_existing_entities.remove(existing_entity)
 
                         # Invoke the list change callback for the existing
                         # entity to notify about the update

{pyg90alarm-2.5.0 → pyg90alarm-2.5.2}/src/pyg90alarm/exceptions.py

@@ -32,7 +32,7 @@ class G90Error(Exception):
     """
 
 
-class G90TimeoutError(asyncio.TimeoutError):  # pylint:disable=R0903
+class G90TimeoutError(asyncio.TimeoutError, G90Error):
     """
     Raised when particular package class to report an operation (typically
     device command) has timed out.

{pyg90alarm-2.5.0 → pyg90alarm-2.5.2}/src/pyg90alarm/local/host_config.py

@@ -35,6 +35,7 @@ class G90SpeechLanguage(IntEnum):
     """
     Supported speech languages.
     """
+    NONE = 0  # Some panels send the value, exact meaning is unknown
     ENGLISH_FEMALE = 1
     ENGLISH_MALE = 2
     CHINESE_FEMALE = 3

{pyg90alarm-2.5.0 → pyg90alarm-2.5.2}/src/pyg90alarm/local/net_config.py

@@ -73,7 +73,7 @@ class G90NetConfig(DataclassLoadSave):
     # Access Point Name (APN) for GPRS connection, as provided by the cellular
     # operator
     apn_name: str = validated_string_field(
-        min_length=1, max_length=100, trust_initial_value=True
+        min_length=0, max_length=100, trust_initial_value=True
     )
     # User name for APN authentication, as provided by the cellular operator
     apn_user: str = validated_string_field(

{pyg90alarm-2.5.0 → pyg90alarm-2.5.2}/src/pyg90alarm.egg-info/PKG-INFO

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

{pyg90alarm-2.5.0 → pyg90alarm-2.5.2}/src/pyg90alarm.egg-info/SOURCES.txt

@@ -86,6 +86,7 @@ tests/test_local_notifications.py
 tests/test_net_config.py
 tests/test_paginated_commands.py
 tests/test_sensor.py
+tests/unit/test_exceptions.py
 tests/unit/dataclass/test_dataclass_load_save.py
 tests/unit/dataclass/test_dataclass_load_save_descriptor.py
 tests/unit/dataclass/test_dataclass_load_save_serialize.py

{pyg90alarm-2.5.0 → pyg90alarm-2.5.2}/tests/test_host_config.py

@@ -164,3 +164,35 @@ async def test_host_config_constraints(
     # Test setting valid value
     setattr(cfg, field_name, valid_value)
     assert getattr(cfg, field_name) == valid_value
+
+
+@pytest.mark.g90device(sent_data=[
+    b'ISTART[106,'
+    b'[900,0,0,1,2,2,60,0,0,60,2]'
+    b']IEND\0',
+    b'ISTARTIEND\0'
+])
+async def test_host_config_speech_language_zero(
+    mock_device: DeviceMock
+) -> None:
+    """
+    Tests for handling host configuration with speech language set to zero.
+    """
+    g90 = G90Alarm(host=mock_device.host, port=mock_device.port)
+
+    # Retrieve configuration
+    cfg = await g90.host_config()
+    assert isinstance(cfg, G90HostConfig)
+
+    # Verify retrieved values
+    assert cfg.speech_language == G90SpeechLanguage.NONE
+
+    # Verify zero value is allowed to be sent back to the panel
+    await cfg.save()
+
+    assert await mock_device.recv_data == [
+        b'ISTART[106,106,""]IEND\0',
+        b'ISTART[107,107,[107,'
+        b'[900,0,0,1,2,2,60,0,0,60,2]'
+        b']]IEND\0'
+    ]

{pyg90alarm-2.5.0 → pyg90alarm-2.5.2}/tests/test_net_config.py

@@ -80,7 +80,7 @@ async def test_net_config(
 @pytest.mark.parametrize(
     'field_name,invalid_value_low,invalid_value_high,valid_value', [
         pytest.param(
-            'apn_name', '', 'a' * 101, 'valid.apn.net',
+            'apn_name', None, 'a' * 101, 'valid.apn.net',
             id='apn_name'
         ),
         pytest.param(
@@ -151,3 +151,42 @@ async def test_net_config_constraints(
     # Test setting valid value
     setattr(cfg, field_name, valid_value)
     assert getattr(cfg, field_name) == valid_value
+
+
+@pytest.mark.g90device(sent_data=[
+    b'ISTART[212,'
+    b'[0,"123456789",1,1,"","user","pwd",3,"54321"]'
+    b']IEND\0',
+    b'ISTARTIEND\0'
+])
+async def test_net_config_apn_name_empty(
+    mock_device: DeviceMock, caplog: pytest.LogCaptureFixture
+) -> None:
+    """
+    Tests for handling network configuration with empty APN name.
+    """
+    g90 = G90Alarm(host=mock_device.host, port=mock_device.port)
+
+    # Retrieve configuration
+    cfg = await g90.net_config()
+    assert isinstance(cfg, G90NetConfig)
+
+    # Verify retrieved values
+    assert cfg.apn_name == ''
+
+    # Ensure that no validation error was logged for empty APN name, the value
+    # of the field as received from the panel is trusted, so no exception will
+    # be raised only error logged
+    assert (
+        'apn_name: Validation failed during initialization for trusted value'
+    ) not in ''.join(caplog.messages)
+
+    # Verify empty APN name is allowed to be sent back to the panel
+    await cfg.save()
+
+    assert await mock_device.recv_data == [
+        b'ISTART[212,212,""]IEND\0',
+        b'ISTART[213,213,[213,'
+        b'[0,"123456789",1,1,"","user","pwd",3]'
+        b']]IEND\0'
+    ]

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

@@ -0,0 +1,306 @@
+"""
+Tests for G90BaseList class
+"""
+from __future__ import annotations
+from typing import AsyncGenerator
+from unittest.mock import MagicMock
+
+from pyg90alarm.entities.base_list import G90BaseList
+
+
+async def test_find_free_idx_empty_list() -> None:
+    """
+    Tests find_free_idx with empty entities list.
+    """
+    class TestClass(G90BaseList[MagicMock]):
+        """
+        Mock subclass for testing G90BaseList.
+        """
+        async def _fetch(self) -> AsyncGenerator[MagicMock, None]:
+            """
+            Mock no entities.
+            """
+            x: MagicMock
+            for x in []:
+                yield x
+
+    base_list = TestClass(parent=MagicMock())
+    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.
+    """
+    class TestClass(G90BaseList[MagicMock]):
+        """
+        Mock subclass for testing G90BaseList.
+        """
+        async def _fetch(self) -> AsyncGenerator[MagicMock, None]:
+            """
+            Mock one entity at index 0.
+            """
+            for x in [MagicMock(index=0)]:
+                yield x
+
+    base_list = TestClass(parent=MagicMock())
+    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.
+    """
+    class TestClass(G90BaseList[MagicMock]):
+        """
+        Mock subclass for testing G90BaseList.
+        """
+        async def _fetch(self) -> AsyncGenerator[MagicMock, None]:
+            """
+            Mock entities at indexes 10 and 11.
+            """
+            for x in [MagicMock(index=10), MagicMock(index=11)]:
+                yield x
+
+    base_list = TestClass(parent=MagicMock())
+    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.
+    """
+    class TestClass(G90BaseList[MagicMock]):
+        """
+        Mock subclass for testing G90BaseList.
+        """
+        async def _fetch(self) -> AsyncGenerator[MagicMock, None]:
+            """
+            Mock entities at indexes 0, 10 and 11.
+            """
+            for x in [
+                MagicMock(index=0), MagicMock(index=10), MagicMock(index=11)
+            ]:
+                yield x
+
+    base_list = TestClass(parent=MagicMock())
+    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.
+    """
+    entity = MagicMock()
+    entity.index = 0
+    entity.subindex = 0
+    entity.name = "Test Entity"
+    entity.is_unavailable = False
+
+    class TestClass(G90BaseList[MagicMock]):
+        """
+        Mock subclass for testing G90BaseList.
+        """
+        async def _fetch(self) -> AsyncGenerator[MagicMock, None]:
+            """
+            Mock one entity.
+            """
+            yield entity
+
+    base_list = TestClass(parent=MagicMock())
+    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.
+    """
+    class TestClass(G90BaseList[MagicMock]):
+        """
+        Mock subclass for testing G90BaseList.
+        """
+        async def _fetch(self) -> AsyncGenerator[MagicMock, None]:
+            """
+            Mock one entity.
+            """
+            entity = MagicMock()
+            entity.index = 0
+            entity.subindex = 0
+            entity.name = "Test Entity"
+            entity.is_unavailable = False
+            yield entity
+
+    base_list = TestClass(parent=MagicMock())
+    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.
+    """
+    class TestClass(G90BaseList[MagicMock]):
+        """
+        Mock subclass for testing G90BaseList.
+        """
+        async def _fetch(self) -> AsyncGenerator[MagicMock, None]:
+            """
+            Mock no entities.
+            """
+            x: MagicMock
+            for x in []:
+                yield x
+
+    base_list = TestClass(parent=MagicMock())
+    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.
+    """
+    class TestClass(G90BaseList[MagicMock]):
+        """
+        Mock subclass for testing G90BaseList.
+        """
+        async def _fetch(self) -> AsyncGenerator[MagicMock, None]:
+            """
+            Mock one entity.
+            """
+            entity = MagicMock()
+            entity.index = 0
+            entity.subindex = 0
+            entity.name = "Test Entity"
+            entity.is_unavailable = True
+            yield entity
+
+    base_list = TestClass(parent=MagicMock())
+    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.
+    """
+    entity = MagicMock()
+    entity.index = 0
+    entity.subindex = 0
+    entity.name = "Test Entity"
+    entity.is_unavailable = True
+
+    class TestClass(G90BaseList[MagicMock]):
+        """
+        Mock subclass for testing G90BaseList.
+        """
+        async def _fetch(self) -> AsyncGenerator[MagicMock, None]:
+            """
+            Mock one entity.
+            """
+            yield entity
+
+    base_list = TestClass(parent=MagicMock())
+    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.
+    """
+    entity = MagicMock()
+    entity.index = 0
+    entity.subindex = 1
+    entity.name = "Test Entity"
+    entity.is_unavailable = False
+
+    class TestClass(G90BaseList[MagicMock]):
+        """
+        Mock subclass for testing G90BaseList.
+        """
+        async def _fetch(self) -> AsyncGenerator[MagicMock, None]:
+            """
+            Mock one entity.
+            """
+            yield entity
+
+    base_list = TestClass(parent=MagicMock())
+    result = await base_list.find(
+        idx=0, name="Test Entity", exclude_unavailable=False, subindex=1
+    )
+
+    assert result == entity
+
+
+async def test_duplicate_entities() -> None:
+    """
+    Tests that duplicate entities are handled correctly during update.
+    """
+    existing_entity = MagicMock()
+    existing_entity.index = 1
+    existing_entity.subindex = 0
+    existing_entity.name = "Existing entity"
+    existing_entity.is_unavailable = False
+
+    new_entity = MagicMock()
+    new_entity.index = 1
+    new_entity.subindex = 0
+    new_entity.name = "Test entity"
+    new_entity.is_unavailable = False
+
+    mock_entities = iter([
+        # Initial fetch returns one existing entity
+        [existing_entity],
+        # Second fetch returns duplicate new entities
+        [new_entity, new_entity],
+    ])
+
+    class TestClass(G90BaseList[MagicMock]):
+        """
+        Mock subclass for testing G90BaseList.
+        """
+        async def _fetch(self) -> AsyncGenerator[MagicMock, None]:
+            """
+            Mock test list entities.
+            """
+            # Yield entities under test
+            for x in next(mock_entities):
+                yield x
+
+    base_list = TestClass(parent=MagicMock())
+    # Initial update to simulate the existing entity
+    await base_list.update()
+    # Second update to test handling of duplicates, should not raise
+    result = await base_list.update()
+
+    assert len(result) == 2
+    # Initial entities not present in second update result should be marked
+    # unavailable
+    assert result[0] == existing_entity
+    assert result[0].is_unavailable is True
+    assert result[1] == new_entity

pyg90alarm-2.5.2/tests/unit/test_exceptions.py

@@ -0,0 +1,16 @@
+"""
+Tests for package-specific exceptions.
+"""
+from __future__ import annotations
+import pytest
+
+from pyg90alarm.exceptions import G90TimeoutError, G90Error
+
+
+def test_g90_timeout_error_inheritance() -> None:
+    """
+    Test that catching G90Error also catches G90TimeoutError.
+    """
+
+    with pytest.raises(G90Error):
+        raise G90TimeoutError("Timeout occurred")

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

@@ -1,192 +0,0 @@
-"""
-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