python-duco-connectivity 0.1.0__tar.gz → 0.1.1__tar.gz

{python_duco_connectivity-0.1.0 → python_duco_connectivity-0.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-duco-connectivity
-Version: 0.1.0
+Version: 0.1.1
 Summary: Async HTTP client for the local Duco Connectivity API
 Author: Ronald van der Meer
 License-Expression: MIT

{python_duco_connectivity-0.1.0 → python_duco_connectivity-0.1.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "python-duco-connectivity"
-version = "0.1.0"
+version = "0.1.1"
 description = "Async HTTP client for the local Duco Connectivity API"
 readme = "README.md"
 license = "MIT"

{python_duco_connectivity-0.1.0 → python_duco_connectivity-0.1.1}/src/duco_connectivity/client.py

@@ -2,6 +2,7 @@
 
 import json
 from typing import Any
+from urllib.parse import urlsplit
 
 import aiohttp
 
@@ -37,17 +38,61 @@ class DucoClient:
     ) -> None:
         self._session = session
         self._timeout = aiohttp.ClientTimeout(total=request_timeout)
-        if host.startswith("https://"):
+
+        raw_host = host.rstrip("/")
+        authority = raw_host.split("://", 1)[1] if "://" in raw_host else raw_host
+        authority = authority.split("/", 1)[0].split("?", 1)[0].split("#", 1)[0]
+
+        if "@" not in authority and authority.count(":") >= 2 and not authority.startswith("["):
+            msg = "Unbracketed IPv6 host values are not supported; use [addr] or [addr]:port"
+            raise ValueError(msg)
+
+        parsed_host = urlsplit(raw_host if "://" in host else f"//{raw_host}")
+        scheme = parsed_host.scheme.lower()
+
+        if scheme == "https":
             msg = "HTTPS is not supported by this client"
             raise ValueError(msg)
-        normalized_host = host.removeprefix("http://").removeprefix("https://").rstrip("/")
-        if "://" in host and not host.startswith("http://"):
+
+        if scheme not in ("", "http"):
             msg = f"Unsupported scheme in host value: {host}"
             raise ValueError(msg)
-        if port is None:
+
+        if parsed_host.username is not None or parsed_host.password is not None:
+            msg = f"Host value must not include user credentials: {host}"
+            raise ValueError(msg)
+
+        if parsed_host.path not in ("", "/") or parsed_host.query or parsed_host.fragment:
+            msg = f"Host value must not include a path, query, or fragment: {host}"
+            raise ValueError(msg)
+
+        normalized_host = parsed_host.hostname
+        if normalized_host is None:
+            msg = f"Invalid host value: {host}"
+            raise ValueError(msg)
+
+        try:
+            embedded_port = parsed_host.port
+        except ValueError as err:
+            msg = f"Invalid port in host value: {host}"
+            raise ValueError(msg) from err
+
+        if port is not None and not 0 <= port <= 65535:
+            msg = f"Invalid port argument: {port}"
+            raise ValueError(msg)
+
+        if embedded_port is not None and port is not None:
+            msg = "Port specified both in host and port argument"
+            raise ValueError(msg)
+
+        if ":" in normalized_host:
+            normalized_host = f"[{normalized_host}]"
+
+        resolved_port = port if port is not None else embedded_port
+        if resolved_port is None:
             self._base_url = f"http://{normalized_host}"
         else:
-            self._base_url = f"http://{normalized_host}:{port}"
+            self._base_url = f"http://{normalized_host}:{resolved_port}"
 
     @property
     def base_url(self) -> str:
@@ -106,6 +151,27 @@ class DucoClient:
         except ValueError:
             return NetworkType.UNKNOWN
 
+    @staticmethod
+    def _to_diag_status(raw_value: str) -> DiagStatus:
+        try:
+            return DiagStatus(raw_value)
+        except ValueError:
+            return DiagStatus.UNKNOWN
+
+    @staticmethod
+    def _to_ventilation_state(raw_value: str) -> VentilationState:
+        try:
+            return VentilationState(raw_value)
+        except ValueError:
+            return VentilationState.UNKNOWN
+
+    @staticmethod
+    def _to_ventilation_mode(raw_value: str) -> VentilationMode:
+        try:
+            return VentilationMode(raw_value)
+        except ValueError:
+            return VentilationMode.UNKNOWN
+
     async def async_get_api_info(self) -> ApiInfo:
         """Return API metadata advertised by the box."""
         payload = await self._request_json("GET", "/api")
@@ -177,7 +243,7 @@ class DucoClient:
         return [
             DiagComponent(
                 component=item["Component"],
-                status=DiagStatus(item["Status"]),
+                status=self._to_diag_status(item["Status"]),
             )
             for item in payload["Diag"]["SubSystems"]
         ]
@@ -223,8 +289,8 @@ class DucoClient:
         if "Ventilation" in payload:
             vent = payload["Ventilation"]
             ventilation = NodeVentilationInfo(
-                state=VentilationState(self._read_wrapped_value(vent, "State")),
-                mode=VentilationMode(self._read_wrapped_value(vent, "Mode")),
+                state=self._to_ventilation_state(self._read_wrapped_value(vent, "State")),
+                mode=self._to_ventilation_mode(self._read_wrapped_value(vent, "Mode")),
                 time_state_remain=self._read_wrapped_value(vent, "TimeStateRemain"),
                 time_state_end=self._read_wrapped_value(vent, "TimeStateEnd"),
                 flow_lvl_tgt=self._read_wrapped_value(vent, "FlowLvlTgt")

{python_duco_connectivity-0.1.0 → python_duco_connectivity-0.1.1}/src/duco_connectivity/models.py

@@ -23,19 +23,21 @@ class NetworkType(StrEnum):
     VIRT = "VIRT"
     RF = "RF"
     WI = "WI"
+    MB = "MB"
     UNKNOWN = "UNKNOWN"
 
 
 class VentilationMode(StrEnum):
-    """Control modes reported for node ventilation."""
+    """Control modes reported for node ventilation, plus a client-side fallback."""
 
     AUTO = "AUTO"
     MANU = "MANU"
     NONE = "-"
+    UNKNOWN = "UNKNOWN"
 
 
 class VentilationState(StrEnum):
-    """State values accepted and reported for node ventilation."""
+    """Ventilation states reported by the API, plus a client-side fallback."""
 
     AUTO = "AUTO"
     AUT1 = "AUT1"
@@ -54,14 +56,16 @@ class VentilationState(StrEnum):
     MAN1x3 = "MAN1x3"
     MAN2x3 = "MAN2x3"
     MAN3x3 = "MAN3x3"
+    UNKNOWN = "UNKNOWN"
 
 
 class DiagStatus(StrEnum):
-    """Health states returned by the diagnostics API."""
+    """Health states returned by the diagnostics API, plus a client-side fallback."""
 
     OK = "Ok"
     DISABLE = "Disable"
     ERROR = "Error"
+    UNKNOWN = "UNKNOWN"
 
 
 @dataclass(frozen=True, slots=True)

{python_duco_connectivity-0.1.0 → python_duco_connectivity-0.1.1}/src/python_duco_connectivity.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-duco-connectivity
-Version: 0.1.0
+Version: 0.1.1
 Summary: Async HTTP client for the local Duco Connectivity API
 Author: Ronald van der Meer
 License-Expression: MIT

{python_duco_connectivity-0.1.0 → python_duco_connectivity-0.1.1}/tests/test_client.py

@@ -13,6 +13,7 @@ from duco_connectivity import (
     DucoWriteLimitError,
     NetworkType,
     NodeType,
+    VentilationMode,
     VentilationState,
 )
 
@@ -62,6 +63,69 @@ async def test_base_url_defaults_to_http() -> None:
         assert client.base_url == "http://192.0.2.94"
 
 
+async def test_base_url_uses_embedded_port_from_host() -> None:
+    """Hosts with an embedded port should preserve that port in the base URL."""
+    async with aiohttp.ClientSession() as session:
+        client = DucoClient(session=session, host="http://192.0.2.94:8080")
+        assert client.base_url == "http://192.0.2.94:8080"
+
+
+async def test_bracketed_ipv6_host_is_accepted() -> None:
+    """Bracketed IPv6 hosts should be accepted and normalized."""
+    async with aiohttp.ClientSession() as session:
+        client = DucoClient(session=session, host="[fe80::1]")
+        assert client.base_url == "http://[fe80::1]"
+
+
+async def test_uppercase_http_scheme_is_accepted() -> None:
+    """HTTP hosts should be accepted regardless of scheme casing."""
+    async with aiohttp.ClientSession() as session:
+        client = DucoClient(session=session, host="HTTP://192.0.2.94:8080")
+        assert client.base_url == "http://192.0.2.94:8080"
+
+
+async def test_conflicting_port_sources_are_rejected() -> None:
+    """The client should reject a separate port when the host already includes one."""
+    async with aiohttp.ClientSession() as session:
+        with pytest.raises(ValueError, match="Port specified both"):
+            DucoClient(session=session, host="192.0.2.94:8080", port=8081)
+
+
+async def test_userinfo_in_host_is_rejected() -> None:
+    """The unauthenticated client should reject credentials embedded in the host value."""
+    async with aiohttp.ClientSession() as session:
+        with pytest.raises(ValueError, match="must not include user credentials"):
+            DucoClient(session=session, host="user:pass@192.0.2.94")
+
+
+async def test_invalid_embedded_port_is_rejected() -> None:
+    """Malformed embedded ports should raise a consistent client ValueError."""
+    async with aiohttp.ClientSession() as session:
+        with pytest.raises(ValueError, match="Invalid port in host value"):
+            DucoClient(session=session, host="192.0.2.94:abc")
+
+
+async def test_unbracketed_ipv6_host_is_rejected() -> None:
+    """Bare IPv6 hosts should require brackets to avoid ambiguous parsing."""
+    async with aiohttp.ClientSession() as session:
+        with pytest.raises(ValueError, match="Unbracketed IPv6 host values"):
+            DucoClient(session=session, host="fe80::1")
+
+
+async def test_negative_port_argument_is_rejected() -> None:
+    """Explicit negative ports should be rejected during client construction."""
+    async with aiohttp.ClientSession() as session:
+        with pytest.raises(ValueError, match="Invalid port argument"):
+            DucoClient(session=session, host="192.0.2.94", port=-1)
+
+
+async def test_out_of_range_port_argument_is_rejected() -> None:
+    """Explicit ports above 65535 should be rejected during client construction."""
+    async with aiohttp.ClientSession() as session:
+        with pytest.raises(ValueError, match="Invalid port argument"):
+            DucoClient(session=session, host="192.0.2.94", port=99999)
+
+
 async def test_api_info_is_parsed(api_info_full_data: dict[str, object]) -> None:
     """Test that the API info model follows the public API payload."""
     mock_response = _response(json_payload=api_info_full_data)
@@ -154,6 +218,26 @@ async def test_get_diagnostics(diag_data: dict[str, object]) -> None:
     assert diags[0].status == DiagStatus.OK
 
 
+async def test_get_diagnostics_unknown_status_falls_back_to_unknown() -> None:
+    """Unknown diagnostic statuses should not break parsing."""
+    payload: dict[str, object] = {
+        "Diag": {
+            "SubSystems": [
+                {"Component": "Ventilation", "Status": "FutureState"},
+            ]
+        }
+    }
+    mock_response = _response(json_payload=payload)
+
+    async with aiohttp.ClientSession() as session:
+        client = DucoClient(session=session, host="192.0.2.94")
+        with patch.object(session, "request", _request(mock_response)):
+            diags = await client.async_get_diagnostics()
+
+    assert len(diags) == 1
+    assert diags[0].status == DiagStatus.UNKNOWN
+
+
 async def test_get_nodes_parses_full_payload(nodes_data: dict[str, object]) -> None:
     """Test node parsing across box and sensor nodes."""
     mock_response = _response(json_payload=nodes_data)
@@ -221,6 +305,41 @@ async def test_get_nodes_unknown_network_type_falls_back_to_unknown() -> None:
     assert nodes[0].general.network_type == NetworkType.UNKNOWN
 
 
+async def test_get_nodes_mb_network_type_is_parsed() -> None:
+    """Known MB network types should be parsed explicitly."""
+    payload: dict[str, object] = {
+        "Nodes": [
+            {
+                "Node": 4,
+                "General": {
+                    "Type": {"Val": "UCCO2"},
+                    "SubType": {"Val": 0},
+                    "NetworkType": {"Val": "MB"},
+                    "Parent": {"Val": 1},
+                    "Asso": {"Val": 1},
+                    "Name": {"Val": ""},
+                    "Identify": {"Val": 0},
+                },
+                "Ventilation": {
+                    "State": {"Val": "AUTO"},
+                    "TimeStateRemain": {"Val": 0},
+                    "TimeStateEnd": {"Val": 0},
+                    "Mode": {"Val": "-"},
+                },
+            }
+        ]
+    }
+    mock_response = _response(json_payload=payload)
+
+    async with aiohttp.ClientSession() as session:
+        client = DucoClient(session=session, host="192.0.2.94")
+        with patch.object(session, "request", _request(mock_response)):
+            nodes = await client.async_get_nodes()
+
+    assert len(nodes) == 1
+    assert nodes[0].general.network_type == NetworkType.MB
+
+
 async def test_get_nodes_unknown_node_type_falls_back_to_unknown() -> None:
     """Test that unknown node types do not crash parsing."""
     payload: dict[str, object] = {
@@ -301,6 +420,80 @@ async def test_timed_manual_state_is_parsed() -> None:
     assert nodes[0].ventilation.state is VentilationState.MAN3x2
 
 
+async def test_get_nodes_unknown_ventilation_state_falls_back_to_unknown() -> None:
+    """Unknown ventilation states should not break node parsing."""
+    payload: dict[str, object] = {
+        "Nodes": [
+            {
+                "Node": 6,
+                "General": {
+                    "Type": {"Val": "BOX"},
+                    "SubType": {"Val": 1},
+                    "NetworkType": {"Val": "VIRT"},
+                    "Parent": {"Val": 0},
+                    "Asso": {"Val": 0},
+                    "Name": {"Val": "Living"},
+                    "Identify": {"Val": 0},
+                },
+                "Ventilation": {
+                    "State": {"Val": "FUTURE_STATE"},
+                    "Mode": {"Val": "AUTO"},
+                    "TimeStateRemain": {"Val": 0},
+                    "TimeStateEnd": {"Val": 0},
+                },
+            }
+        ]
+    }
+
+    mock_response = _response(json_payload=payload)
+
+    async with aiohttp.ClientSession() as session:
+        client = DucoClient(session=session, host="192.0.2.94")
+        with patch.object(session, "request", _request(mock_response)):
+            nodes = await client.async_get_nodes()
+
+    assert len(nodes) == 1
+    assert nodes[0].ventilation is not None
+    assert nodes[0].ventilation.state is VentilationState.UNKNOWN
+
+
+async def test_get_nodes_unknown_ventilation_mode_falls_back_to_unknown() -> None:
+    """Unknown ventilation modes should not break node parsing."""
+    payload: dict[str, object] = {
+        "Nodes": [
+            {
+                "Node": 7,
+                "General": {
+                    "Type": {"Val": "BOX"},
+                    "SubType": {"Val": 1},
+                    "NetworkType": {"Val": "VIRT"},
+                    "Parent": {"Val": 0},
+                    "Asso": {"Val": 0},
+                    "Name": {"Val": "Bedroom"},
+                    "Identify": {"Val": 0},
+                },
+                "Ventilation": {
+                    "State": {"Val": "AUTO"},
+                    "Mode": {"Val": "FUTURE_MODE"},
+                    "TimeStateRemain": {"Val": 0},
+                    "TimeStateEnd": {"Val": 0},
+                },
+            }
+        ]
+    }
+
+    mock_response = _response(json_payload=payload)
+
+    async with aiohttp.ClientSession() as session:
+        client = DucoClient(session=session, host="192.0.2.94")
+        with patch.object(session, "request", _request(mock_response)):
+            nodes = await client.async_get_nodes()
+
+    assert len(nodes) == 1
+    assert nodes[0].ventilation is not None
+    assert nodes[0].ventilation.mode is VentilationMode.UNKNOWN
+
+
 async def test_connection_error_raises_duco_connection_error() -> None:
     """Transport errors should raise DucoConnectionError."""
     async with aiohttp.ClientSession() as session:

{python_duco_connectivity-0.1.0 → python_duco_connectivity-0.1.1}/tests/test_models.py

@@ -84,3 +84,8 @@ def test_node_is_frozen() -> None:
     )
     with pytest.raises(AttributeError):
         node.node_id = 2  # type: ignore[misc]
+
+
+def test_network_type_includes_mb() -> None:
+    """NetworkType should expose MB as an explicit known value."""
+    assert NetworkType.MB.value == "MB"