zigpy 1.5.0__tar.gz → 1.6.0__tar.gz

{zigpy-1.5.0/zigpy.egg-info → zigpy-1.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: zigpy
-Version: 1.5.0
+Version: 1.6.0
 Summary: Library implementing a Zigbee stack
 Author-email: Russell Cloran <rcloran@gmail.com>
 License: GPL-3.0

{zigpy-1.5.0 → zigpy-1.6.0}/pyproject.toml

@@ -36,6 +36,9 @@ zigpy = ["py.typed"]
 [dependency-groups]
 testing = [
     "aioresponses",
+    # aioresponses 0.7.8 is incompatible with aiohttp 3.14's mandatory
+    # `stream_writer` argument; remove once aioresponses PR #288 is released.
+    "aiohttp<3.14",
     "asynctest",
     "codespell==2.4.1",
     "coverage[toml]",

{zigpy-1.5.0 → zigpy-1.6.0}/tests/test_quirks.py

@@ -965,6 +965,34 @@ async def test_request_with_kwargs(real_device):
         assert all(c == request_mock.mock_calls[0] for c in request_mock.mock_calls)
 
 
+def test_custom_cluster_subclass_keeps_same_id_attributes() -> None:
+    """Subclassing a custom cluster with two same-ID attributes keeps both."""
+
+    class MeteringBase(zigpy.quirks.CustomCluster, zcl.clusters.smartenergy.Metering):
+        class AttributeDefs(zcl.clusters.smartenergy.Metering.AttributeDefs):
+            # Shares its ID with the standard `current_summ_delivered` attribute
+            current_summ_delivered_mfg = zcl.foundation.ZCLAttributeDef(
+                id=0x0000,
+                type=t.uint48_t,
+                manufacturer_code=0x1166,
+            )
+
+    class MeteringVariant1(MeteringBase):
+        pass
+
+    class MeteringVariant2(MeteringBase):
+        pass
+
+    for cls in (MeteringBase, MeteringVariant1, MeteringVariant2):
+        assert "current_summ_delivered" in cls.attributes_by_name
+        assert "current_summ_delivered_mfg" in cls.attributes_by_name
+        assert cls.find_attribute("current_summ_delivered").id == 0x0000
+        assert (
+            cls.find_attribute(0x0000, manufacturer_code=0x1166)
+            is cls.AttributeDefs.current_summ_delivered_mfg
+        )
+
+
 def test_purge_custom_quirks(tmp_path: pathlib.Path, app_mock) -> None:
     def load_quirks():
         for importer, modname, _ in pkgutil.walk_packages(path=[str(tmp_path)]):

{zigpy-1.5.0 → zigpy-1.6.0}/tests/test_zcl.py

@@ -1423,6 +1423,132 @@ async def test_zcl_cluster_definition_backwards_compatibility():
     )
 
 
+def test_zcl_cluster_subclass_keeps_same_id_attributes():
+    """Subclassing a cluster keeps two attribute definitions sharing an ID."""
+
+    class TestCluster(zcl.Cluster):
+        cluster_id = 0xABCD
+        ep_attribute = "test_cluster"
+        _skip_registry = True
+
+        class AttributeDefs(zcl.BaseAttributeDefs):
+            attribute = foundation.ZCLAttributeDef(id=0x0001, type=t.uint8_t)
+            attribute_mfg = foundation.ZCLAttributeDef(
+                id=0x0001,
+                type=t.uint48_t,
+                manufacturer_code=0x1234,
+            )
+
+    class TestClusterSubclass(TestCluster):
+        pass
+
+    class TestClusterSubSubclass(TestClusterSubclass):
+        pass
+
+    for cls in (TestCluster, TestClusterSubclass, TestClusterSubSubclass):
+        assert set(cls.attributes_by_name) == {"attribute", "attribute_mfg"}
+        assert cls.find_attribute("attribute") is cls.AttributeDefs.attribute
+        assert (
+            cls.find_attribute(0x0001, manufacturer_code=0x1234)
+            is cls.AttributeDefs.attribute_mfg
+        )
+
+
+def test_zcl_cluster_subclass_keeps_same_id_commands():
+    """Subclassing a cluster keeps two command definitions sharing an ID."""
+
+    class TestCluster(zcl.Cluster):
+        cluster_id = 0xABCD
+        ep_attribute = "test_cluster"
+        _skip_registry = True
+
+        class ServerCommandDefs(zcl.BaseCommandDefs):
+            command = foundation.ZCLCommandDef(id=0x00, schema={"param1": t.uint8_t})
+            command_mfg = foundation.ZCLCommandDef(
+                id=0x00,
+                schema={"param1": t.uint8_t},
+                manufacturer_code=0x1234,
+            )
+
+        class ClientCommandDefs(zcl.BaseCommandDefs):
+            response = foundation.ZCLCommandDef(id=0x01, schema={})
+            response_mfg = foundation.ZCLCommandDef(
+                id=0x01,
+                schema={},
+                manufacturer_code=0x1234,
+            )
+
+    class TestClusterSubclass(TestCluster):
+        pass
+
+    class TestClusterSubSubclass(TestClusterSubclass):
+        pass
+
+    for cls in (TestCluster, TestClusterSubclass, TestClusterSubSubclass):
+        assert set(cls.commands_by_name) == {
+            "command",
+            "command_mfg",
+            "response",
+            "response_mfg",
+        }
+        assert {cmd.name for cmd in cls.ServerCommandDefs} == {
+            "command",
+            "command_mfg",
+        }
+        assert {cmd.name for cmd in cls.ClientCommandDefs} == {
+            "response",
+            "response_mfg",
+        }
+
+
+def test_zcl_cluster_subclass_old_style_definitions():
+    """Subclasses of clusters with old-style definitions inherit the rebuilt defs."""
+
+    class TestCluster(zcl.Cluster):
+        cluster_id = 0xABCD
+        ep_attribute = "test_cluster"
+        _skip_registry = True
+
+        attributes = {
+            0x1234: ("attribute", t.uint8_t),
+            0x1235: ("attribute2", t.uint32_t, True),
+        }
+
+        server_commands = {
+            0x00: ("server_command", (t.uint8_t,), True),
+        }
+
+        client_commands = {
+            0x01: ("client_command", (t.uint8_t,), False),
+        }
+
+    class TestClusterSubclass(TestCluster):
+        pass
+
+    assert set(TestClusterSubclass.attributes_by_name) == {"attribute", "attribute2"}
+    assert TestClusterSubclass.AttributeDefs.attribute.id == 0x1234
+    assert TestClusterSubclass.AttributeDefs.attribute2.is_manufacturer_specific
+    assert set(TestClusterSubclass.commands_by_name) == {
+        "server_command",
+        "client_command",
+    }
+
+    # An explicit empty old-style dict does not wipe the inherited definitions
+    class TestClusterEmptyOverride(TestCluster):
+        attributes = {}
+        server_commands = {}
+        client_commands = {}
+
+    assert set(TestClusterEmptyOverride.attributes_by_name) == {
+        "attribute",
+        "attribute2",
+    }
+    assert set(TestClusterEmptyOverride.commands_by_name) == {
+        "server_command",
+        "client_command",
+    }
+
+
 async def test_zcl_cluster_definition_invalid_name():
     # This is fine
     class TestCluster(zcl.Cluster):

{zigpy-1.5.0 → zigpy-1.6.0}/zigpy/application.py

@@ -15,7 +15,7 @@ import os
 import random
 import time
 import typing
-from typing import Any, ParamSpec, TypeVar
+from typing import Any, ClassVar, ParamSpec, TypeVar
 import warnings
 
 import zigpy.appdb
@@ -53,10 +53,19 @@ _P = ParamSpec("_P")
 CHANNEL_CHANGE_BROADCAST_DELAY_S = 1.0
 CHANNEL_CHANGE_SETTINGS_RELOAD_DELAY_S = 1.0
 
+# Entry point group used by radio libraries to advertise their controller class:
+# the entry point name is the radio type and its value is the controller class
+RADIO_ENTRY_POINT_GROUP = "zigpy.radio"
+
 
 class ControllerApplication(zigpy.util.ListenableMixin, abc.ABC):
     SCHEMA = conf.CONFIG_SCHEMA
 
+    # User-facing metadata, set by radio libraries advertising themselves via the
+    # `zigpy.radio` entry point group
+    DISPLAY_NAME: ClassVar[str | None] = None
+    DESCRIPTION: ClassVar[str | None] = None
+
     _watchdog_period: int = 30
     _probe_configs: list[dict[str, Any]] = []
 

{zigpy-1.5.0 → zigpy-1.6.0}/zigpy/ota/__init__.py

@@ -461,6 +461,10 @@ class OTA:
 
     def register_provider(self, provider: zigpy.ota.providers.BaseOtaProvider) -> None:
         """Register a new OTA provider."""
+        if provider in self._providers:
+            _LOGGER.warning("Ignoring duplicate OTA provider: %s", provider)
+            return
+
         _LOGGER.debug("Registering new OTA provider: %s", provider)
         self._providers.append(provider)
 

{zigpy-1.5.0 → zigpy-1.6.0}/zigpy/ota/providers.py

@@ -247,13 +247,17 @@ class BaseOtaProvider:
         raise NotImplementedError
 
     def __eq__(self, other: object) -> bool:
-        if not isinstance(other, self.__class__):
+        if not isinstance(other, BaseOtaProvider):
             return NotImplemented
 
+        # Providers of a different concrete type are never equal
+        if type(self) is not type(other):
+            return False
+
         return self.url == other.url and self.manufacturer_ids == other.manufacturer_ids
 
     def __hash__(self) -> int:
-        return hash((self.url, self.manufacturer_ids))
+        return hash((type(self), self.url, self.manufacturer_ids))
 
     def __repr__(self) -> str:
         return f"{self.__class__.__name__}(url={self.url!r}, manufacturer_ids={self.manufacturer_ids!r})"
@@ -372,21 +376,36 @@ class Ledvance(BaseOtaProvider):
             )
 
 
-# stub provider to keep existing configurations working
-@register_provider
-class Salus(BaseOtaProvider):
-    NAME = "salus"
-    MANUFACTURER_IDS = (4216, 43981)
+class StubOtaProvider(BaseOtaProvider):
+    """Stub provider to keep existing configurations working."""
 
     VOL_SCHEMA = zigpy.config.SCHEMA_OTA_PROVIDER_URL
 
     async def _load_index(
         self, session: aiohttp.ClientSession
     ) -> typing.AsyncIterator[BaseOtaImageMetadata]:
-        if False:
+        if typing.TYPE_CHECKING:
             yield  # pragma: no cover
 
 
+@register_provider
+class Salus(StubOtaProvider):
+    NAME = "salus"
+    MANUFACTURER_IDS = (4216, 43981)
+
+
+@register_provider
+class ThirdReality(StubOtaProvider):
+    NAME = "thirdreality"
+    MANUFACTURER_IDS = (4659, 4877, 5127)
+
+
+@register_provider
+class Inovelli(StubOtaProvider):
+    NAME = "inovelli"
+    MANUFACTURER_IDS = (4655,)
+
+
 @register_provider
 class Sonoff(BaseOtaProvider):
     NAME = "sonoff"
@@ -490,7 +509,7 @@ class LocalZigpyProvider(BaseZigpyProvider):
         return super().__eq__(other) and self.index_file == other.index_file
 
     def __hash__(self) -> int:
-        return hash((self.index_file, self.manufacturer_ids))
+        return hash((type(self), self.index_file, self.manufacturer_ids))
 
     def __repr__(self) -> str:
         return f"{self.__class__.__name__}(index_file={self.index_file!r}, manufacturer_ids={self.manufacturer_ids!r})"
@@ -583,7 +602,7 @@ class LocalZ2MProvider(BaseZ2MProvider):
         return super().__eq__(other) and self.index_file == other.index_file
 
     def __hash__(self) -> int:
-        return hash((self.index_file, self.manufacturer_ids))
+        return hash((type(self), self.index_file, self.manufacturer_ids))
 
     def __repr__(self) -> str:
         return f"{self.__class__.__name__}(index_file={self.index_file!r}, manufacturer_ids={self.manufacturer_ids!r})"
@@ -688,7 +707,7 @@ class ZigpyOtaProvider(BaseZigpyProvider):
         return super().__eq__(other) and self.channel == other.channel
 
     def __hash__(self) -> int:
-        return hash((self.url, self.channel, self.manufacturer_ids))
+        return hash((type(self), self.url, self.channel, self.manufacturer_ids))
 
     def __repr__(self) -> str:
         return f"{self.__class__.__name__}(url={self.url!r}, channel={self.channel!r}, manufacturer_ids={self.manufacturer_ids!r})"
@@ -751,7 +770,7 @@ class AdvancedFileProvider(BaseOtaProvider):
         return super().__eq__(other) and self.path == other.path
 
     def __hash__(self) -> int:
-        return hash((self.path, self.manufacturer_ids))
+        return hash((type(self), self.path, self.manufacturer_ids))
 
     def __repr__(self) -> str:
         return f"{self.__class__.__name__}(path={self.path!r}, manufacturer_ids={self.manufacturer_ids!r})"

{zigpy-1.5.0 → zigpy-1.6.0}/zigpy/zcl/__init__.py

@@ -400,8 +400,11 @@ class Cluster(util.ListenableMixin, util.CatchingTaskMixin, EventBase):
 
             cls.attributes[attr.id] = attr.replace(id=attr_id)
 
-        # Create new definitions from the old-style definitions
-        if cls.attributes and "AttributeDefs" not in cls.__dict__:
+        # Create new definitions from old-style definitions authored by this class
+        # itself: an MRO-inherited `attributes` dict is keyed purely by attribute ID
+        # and cannot represent two same-ID attributes (e.g. a standard and a
+        # manufacturer-specific one), so rebuilding from it would drop one of them
+        if cls.__dict__.get("attributes") and "AttributeDefs" not in cls.__dict__:
             cls.AttributeDefs = types.new_class(
                 name="AttributeDefs",
                 bases=(BaseAttributeDefs,),
@@ -410,7 +413,10 @@ class Cluster(util.ListenableMixin, util.CatchingTaskMixin, EventBase):
             for attr in cls.attributes.values():
                 setattr(cls.AttributeDefs, attr.name, attr)
 
-        if cls.server_commands and "ServerCommandDefs" not in cls.__dict__:
+        if (
+            cls.__dict__.get("server_commands")
+            and "ServerCommandDefs" not in cls.__dict__
+        ):
             cls.ServerCommandDefs = types.new_class(
                 name="ServerCommandDefs",
                 bases=(BaseCommandDefs,),
@@ -419,7 +425,10 @@ class Cluster(util.ListenableMixin, util.CatchingTaskMixin, EventBase):
             for command in cls.server_commands.values():
                 setattr(cls.ServerCommandDefs, command.name, command)
 
-        if cls.client_commands and "ClientCommandDefs" not in cls.__dict__:
+        if (
+            cls.__dict__.get("client_commands")
+            and "ClientCommandDefs" not in cls.__dict__
+        ):
             cls.ClientCommandDefs = types.new_class(
                 name="ClientCommandDefs",
                 bases=(BaseCommandDefs,),

{zigpy-1.5.0 → zigpy-1.6.0/zigpy.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: zigpy
-Version: 1.5.0
+Version: 1.6.0
 Summary: Library implementing a Zigbee stack
 Author-email: Russell Cloran <rcloran@gmail.com>
 License: GPL-3.0