violet-poolController-api 0.0.10__tar.gz → 0.0.12__tar.gz

{violet_poolcontroller_api-0.0.10 → violet_poolcontroller_api-0.0.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: violet-poolController-api
-Version: 0.0.10
+Version: 0.0.12
 Summary: Asynchronous Python client for the Violet Pool Controller.
 Home-page: https://github.com/Xerolux/violet-poolController-api
 Author: Basti (Xerolux)

{violet_poolcontroller_api-0.0.10 → violet_poolcontroller_api-0.0.12}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "violet-poolController-api"
-version = "0.0.10"
+version = "0.0.12"
 authors = [
   { name="Basti (Xerolux)", email="git@xerolux.de" },
 ]

{violet_poolcontroller_api-0.0.10 → violet_poolcontroller_api-0.0.12}/setup.py

@@ -1,35 +1,35 @@
-from setuptools import setup, find_packages
-setup(
-    name="violet-poolController-api",
-    version="0.0.10",
-    author="Basti (Xerolux)",
-    author_email="git@xerolux.de",
-    description="Asynchronous Python client for the Violet Pool Controller.",
-    long_description=open("README.md").read(),
-    long_description_content_type="text/markdown",
-    url="https://github.com/Xerolux/violet-poolController-api",
-    packages=find_packages(),
-    license="AGPL-3.0-or-later",
-    classifiers=[
-        "Programming Language :: Python :: 3",
-        "License :: OSI Approved :: GNU Affero General Public License v3 or later (AGPLv3+)",
-        "Operating System :: OS Independent",
-        "Intended Audience :: Developers",
-        "Topic :: Home Automation",
-    ],
-    python_requires=">=3.12",
-    install_requires=[
-        "aiohttp>=3.9.0",
-    ],
-    extras_require={
-        "test": [
-            "aioresponses>=0.7.6",
-            "pytest>=8.0",
-            "pytest-asyncio>=0.23",
-        ],
-    },
-    project_urls={
-        "Bug Tracker": "https://github.com/Xerolux/violet-poolController-api/issues",
-        "License": "https://www.gnu.org/licenses/agpl-3.0.html",
-    },
-)
+from setuptools import setup, find_packages
+setup(
+    name="violet-poolController-api",
+    version="0.0.12",
+    author="Basti (Xerolux)",
+    author_email="git@xerolux.de",
+    description="Asynchronous Python client for the Violet Pool Controller.",
+    long_description=open("README.md").read(),
+    long_description_content_type="text/markdown",
+    url="https://github.com/Xerolux/violet-poolController-api",
+    packages=find_packages(),
+    license="AGPL-3.0-or-later",
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "License :: OSI Approved :: GNU Affero General Public License v3 or later (AGPLv3+)",
+        "Operating System :: OS Independent",
+        "Intended Audience :: Developers",
+        "Topic :: Home Automation",
+    ],
+    python_requires=">=3.12",
+    install_requires=[
+        "aiohttp>=3.9.0",
+    ],
+    extras_require={
+        "test": [
+            "aioresponses>=0.7.6",
+            "pytest>=8.0",
+            "pytest-asyncio>=0.23",
+        ],
+    },
+    project_urls={
+        "Bug Tracker": "https://github.com/Xerolux/violet-poolController-api/issues",
+        "License": "https://www.gnu.org/licenses/agpl-3.0.html",
+    },
+)

{violet_poolcontroller_api-0.0.10 → violet_poolcontroller_api-0.0.12}/tests/test_api.py

@@ -257,7 +257,7 @@ async def test_dosing_standalone_detection_dict_format(mock_aioresponse, standal
 
 @pytest.mark.asyncio
 async def test_get_hardware_profile(mock_aioresponse, api_client):
-    """Test get_hardware_profile correctly detects components."""
+    """Test get_hardware_profile correctly detects components via alive counters."""
     url = "http://192.168.1.100/getReadings?ALL"
 
     # 1. Base module only (no DOS, EXT)
@@ -270,8 +270,14 @@ async def test_get_hardware_profile(mock_aioresponse, api_client):
         "extension_module_2": False,
     }
 
-    # 2. Base module + Dosing + Ext1
-    mock_aioresponse.get(url, payload={"getReadings": {"PUMPSTATE": "2", "SYSTEM_dosagemodule_cpu_temperature": 45.5, "EXT1_1": "1"}}, status=200)
+    # 2. Base module + Dosing + Ext1 (via alive counters)
+    mock_aioresponse.get(url, payload={"getReadings": {
+        "PUMPSTATE": "2",
+        "SYSTEM_dosagemodule_alive_count": "20392243",
+        "SYSTEM_dosagemodule_cpu_temperature": 45.5,
+        "SYSTEM_ext1module_alive_count": "52443888",
+        "EXT1_1": "1",
+    }}, status=200)
     profile = await api_client.get_hardware_profile()
     assert profile == {
         "base_module": True,
@@ -280,8 +286,14 @@ async def test_get_hardware_profile(mock_aioresponse, api_client):
         "extension_module_2": False,
     }
 
-    # 3. Base module + Ext1 + Ext2 (no Dosing)
-    mock_aioresponse.get(url, payload={"getReadings": {"PUMPSTATE": "2", "EXT1_1": "1", "EXT2_1": "1"}}, status=200)
+    # 3. Base module + Ext1 + Ext2 (via alive counters, no Dosing)
+    mock_aioresponse.get(url, payload={"getReadings": {
+        "PUMPSTATE": "2",
+        "SYSTEM_ext1module_alive_count": "100",
+        "SYSTEM_ext2module_alive_count": "200",
+        "EXT1_1": "1",
+        "EXT2_1": "1",
+    }}, status=200)
     profile = await api_client.get_hardware_profile()
     assert profile == {
         "base_module": True,
@@ -290,6 +302,20 @@ async def test_get_hardware_profile(mock_aioresponse, api_client):
         "extension_module_2": True,
     }
 
+    # 4. Real-world scenario: EXT2 relay data present (value 0) but no ext2 module
+    #    Controller always returns EXT2_* keys even when the module is absent.
+    mock_aioresponse.get(url, payload={"getReadings": {
+        "PUMPSTATE": "2",
+        "SYSTEM_dosagemodule_alive_count": "20392243",
+        "SYSTEM_ext1module_alive_count": "52443888",
+        "EXT1_1": 0, "EXT1_2": 0,
+        "EXT2_1": 0, "EXT2_2": 0,
+        "EXT2_1_LAST_ON": 0, "EXT2_1_LAST_OFF": 0,
+    }}, status=200)
+    profile = await api_client.get_hardware_profile()
+    assert profile["extension_module_1"] is True
+    assert profile["extension_module_2"] is False
+
 @pytest.mark.asyncio
 async def test_get_hardware_profile_standalone_dosing(mock_aioresponse, standalone_api_client):
     """Test get_hardware_profile with a standalone dosing configuration."""

{violet_poolcontroller_api-0.0.10 → violet_poolcontroller_api-0.0.12}/violet_poolController_api.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: violet-poolController-api
-Version: 0.0.10
+Version: 0.0.12
 Summary: Asynchronous Python client for the Violet Pool Controller.
 Home-page: https://github.com/Xerolux/violet-poolController-api
 Author: Basti (Xerolux)

{violet_poolcontroller_api-0.0.10 → violet_poolcontroller_api-0.0.12}/violet_poolcontroller_api/__init__.py

@@ -13,3 +13,7 @@
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+from .api import VioletPoolAPI, VioletPoolAPIError
+
+__all__ = ["VioletPoolAPI", "VioletPoolAPIError"]

{violet_poolcontroller_api-0.0.10 → violet_poolcontroller_api-0.0.12}/violet_poolcontroller_api/api.py

@@ -18,8 +18,6 @@
 
 from __future__ import annotations
 
-from .const_devices import DEVICE_PARAMETERS
-
 import asyncio
 import json
 import logging
@@ -55,12 +53,14 @@ from .const_api import (
     API_SET_FUNCTION_MANUALLY,
     API_SET_OUTPUT_TESTMODE,
     API_SET_TARGET_VALUES,
+    DMX_SCENE_COUNT,
     DOSING_FUNCTIONS,
     TARGET_MIN_CHLORINE,
     TARGET_ORP,
     TARGET_PH,
 )
 from .circuit_breaker import CircuitBreaker, CircuitBreakerOpenError
+from .const_devices import DEVICE_PARAMETERS
 from .utils_rate_limiter import get_global_rate_limiter
 from .utils_sanitizer import InputSanitizer
 
@@ -497,6 +497,55 @@ class VioletPoolAPI:
 
         return response
 
+    def _build_hardware_profile(self, flattened: dict[str, Any]) -> dict[str, bool]:
+        """Build a hardware presence profile from flattened getReadings data.
+
+        Uses the controller's alive-counters (``SYSTEM_*_alive_count``) to
+        reliably detect connected hardware modules.  The controller always
+        emits relay keys (``EXT1_1``, ``EXT2_1``, …) with a default value of
+        ``0`` even when the physical module is absent, so checking those keys
+        would yield false positives.
+
+        Args:
+            flattened: The flattened key-value readings dict.
+
+        Returns:
+            A dictionary with boolean flags for connected hardware components.
+        """
+        def _module_alive(alive_key: str) -> bool:
+            val = flattened.get(alive_key)
+            if val is None:
+                return False
+            try:
+                return float(str(val).strip()) > 0
+            except (ValueError, TypeError):
+                return False
+
+        def _any_relay_used(prefix: str) -> bool:
+            for key, val in flattened.items():
+                if not key.startswith(prefix):
+                    continue
+                if "_LAST_ON" not in key and "_LAST_OFF" not in key and "_RUNTIME" not in key:
+                    last_on = flattened.get(f"{key}_LAST_ON")
+                    if last_on is not None:
+                        try:
+                            if float(str(last_on).strip()) > 0:
+                                return True
+                        except (ValueError, TypeError):
+                            pass
+            return False
+
+        ext1 = _module_alive("SYSTEM_ext1module_alive_count") or _any_relay_used("EXT1_")
+        ext2 = _module_alive("SYSTEM_ext2module_alive_count") or _any_relay_used("EXT2_")
+        dosing = self.dosing_standalone or _module_alive("SYSTEM_dosagemodule_alive_count")
+
+        return {
+            "base_module": not self.dosing_standalone,
+            "dosing_module": dosing,
+            "extension_module_1": ext1,
+            "extension_module_2": ext2,
+        }
+
     async def get_readings(self) -> dict[str, Any]:
         """Returns the complete dataset from the controller.
 
@@ -512,21 +561,7 @@ class VioletPoolAPI:
             payload_name="getReadings",
         )
         flattened = self._flatten_getreadings_response(response)
-
-        # Determine hardware profile based on the flattened readings
-        def is_present(key: str) -> bool:
-            if not isinstance(flattened, dict):
-                return False
-            val = flattened.get(key)
-            return val is not None and str(val).strip().upper() != "N/A"
-
-        profile = {
-            "base_module": not self.dosing_standalone,
-            "dosing_module": self.dosing_standalone or is_present("SYSTEM_dosagemodule_cpu_temperature"),
-            "extension_module_1": is_present("EXT1_1"),
-            "extension_module_2": is_present("EXT2_1"),
-        }
-
+        profile = self._build_hardware_profile(flattened)
         return self._filter_unsupported_readings(flattened, profile)
 
     def _filter_unsupported_readings(self, readings: dict[str, Any], profile: dict[str, bool]) -> dict[str, Any]:
@@ -635,20 +670,13 @@ class VioletPoolAPI:
             - extension_module_1: True if the first relay extension is present.
             - extension_module_2: True if the second relay extension is present.
         """
-        readings = await self.get_readings()
-
-        def is_present(key: str) -> bool:
-            if not isinstance(readings, dict):
-                return False
-            val = readings.get(key)
-            return val is not None and str(val).strip().upper() != "N/A"
-
-        return {
-            "base_module": not self.dosing_standalone,
-            "dosing_module": self.dosing_standalone or is_present("SYSTEM_dosagemodule_cpu_temperature"),
-            "extension_module_1": is_present("EXT1_1"),
-            "extension_module_2": is_present("EXT2_1"),
-        }
+        response = await self._request_json_dict(
+            API_READINGS,
+            query="ALL",
+            payload_name="getReadings",
+        )
+        flattened = self._flatten_getreadings_response(response)
+        return self._build_hardware_profile(flattened)
 
     async def get_overall_dosing(self) -> dict[str, Any]:
         """Returns aggregated dosing statistics.
@@ -835,7 +863,8 @@ class VioletPoolAPI:
         if not output:
             raise VioletPoolAPIError("Output identifier is required")
 
-        duration_ms = max(0, int(duration)) * 1000
+        safe_duration = max(0, min(86400, int(duration)))  # cap at 24 h
+        duration_ms = safe_duration * 1000
         payload = f"{output},{mode},{duration_ms}"
         body = await self._request(
             API_SET_OUTPUT_TESTMODE,
@@ -941,7 +970,7 @@ class VioletPoolAPI:
             raise VioletPoolAPIError(f"Unsupported DMX action: {action}")
 
         tasks = []
-        for scene in range(1, 13):
+        for scene in range(1, DMX_SCENE_COUNT + 1):
             key = f"DMX_SCENE{scene}"
             tasks.append(self.set_switch_state(key, action))
 

{violet_poolcontroller_api-0.0.10 → violet_poolcontroller_api-0.0.12}/violet_poolcontroller_api/circuit_breaker.py

@@ -22,7 +22,7 @@ import asyncio
 import logging
 import time
 from collections.abc import Callable
-from enum import StrEnum
+from enum import StrEnum
 from typing import Any
 
 _LOGGER = logging.getLogger(__name__)
@@ -175,12 +175,13 @@ class CircuitBreaker:
             "half_open_start_time": self.half_open_start_time,
         }
 
-    def reset(self) -> None:
-        """Manually reset the circuit breaker (call from sync context only)."""
-        self.state = CircuitBreakerState.CLOSED
-        self.failure_count = 0
-        self.last_failure_time = 0.0
-        self.half_open_start_time = 0.0
+    async def reset(self) -> None:
+        """Manually reset the circuit breaker to CLOSED state."""
+        async with self._lock:
+            self.state = CircuitBreakerState.CLOSED
+            self.failure_count = 0
+            self.last_failure_time = 0.0
+            self.half_open_start_time = 0.0
         _LOGGER.info("Circuit breaker manually reset to CLOSED state")
 
 

{violet_poolcontroller_api-0.0.10 → violet_poolcontroller_api-0.0.12}/violet_poolcontroller_api/const_api.py

@@ -123,8 +123,10 @@ for ext_bank in [1, 2]:
             f"Erweiterung {ext_bank}.{relay_num}"
         )
 
+DMX_SCENE_COUNT = 12  # Number of DMX scenes supported by the controller
+
 # Dynamically add DMX scenes
-for scene_num in range(1, 13):
+for scene_num in range(1, DMX_SCENE_COUNT + 1):
     SWITCH_FUNCTIONS[f"DMX_SCENE{scene_num}"] = f"DMX Szene {scene_num}"
 
 # Dynamically add digital input rules

{violet_poolcontroller_api-0.0.10 → violet_poolcontroller_api-0.0.12}/violet_poolcontroller_api/utils_rate_limiter.py

@@ -125,17 +125,20 @@ class RateLimiter:
             # Track failures efficiently
             self.blocked_requests += 1
             self._recent_stats["blocked_last_minute"] += 1
+            self.request_history.append(
+                {"time": current_time, "priority": priority, "blocked": True}
+            )
             return False
 
-    def _cleanup_history(self, current_time: float) -> None:
-        """Clean up old history entries to prevent memory leaks."""
-        # Remove entries older than 1 hour
-        cutoff_time = current_time - 3600
-
-        while self.request_history and self.request_history[0]["time"] <= cutoff_time:
-            self.request_history.popleft()
-
-        _LOGGER.debug("Rate limiter history cleanup completed")
+    def _cleanup_history(self, current_time: float) -> None:
+        """Clean up old history entries to prevent memory leaks."""
+        # Remove entries older than 1 hour
+        cutoff_time = current_time - 3600
+
+        while self.request_history and self.request_history[0]["time"] <= cutoff_time:
+            self.request_history.popleft()
+
+        _LOGGER.debug("Rate limiter history cleanup completed")
 
     def _update_recent_stats(self, current_time: float) -> None:
         """Update memory-efficient recent statistics."""