violet-poolController-api 0.0.32__tar.gz → 0.0.34__tar.gz

{violet_poolcontroller_api-0.0.32/violet_poolController_api.egg-info → violet_poolcontroller_api-0.0.34}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: violet-poolController-api
-Version: 0.0.32
+Version: 0.0.34
 Summary: Asynchronous Python client for the Violet Pool Controller.
 Author-email: "Basti (Xerolux)" <git@xerolux.de>
 License: AGPL-3.0-or-later
@@ -20,7 +20,7 @@ Classifier: Topic :: Home Automation
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: aiohttp<3.14,>=3.11.0
+Requires-Dist: aiohttp<3.15,>=3.11.0
 Provides-Extra: test
 Requires-Dist: aioresponses>=0.7.8; extra == "test"
 Requires-Dist: pytest>=8.3; extra == "test"

{violet_poolcontroller_api-0.0.32 → violet_poolcontroller_api-0.0.34}/pyproject.toml

@@ -2,9 +2,15 @@
 requires = ["setuptools>=61.0.0", "wheel"]
 build-backend = "setuptools.build_meta"
 
+[tool.setuptools.packages.find]
+include = ["violet_poolcontroller_api*"]
+
+[tool.setuptools.package-data]
+violet_poolcontroller_api = ["py.typed"]
+
 [project]
 name = "violet-poolController-api"
-version = "0.0.32"
+version = "0.0.34"
 authors = [
   { name="Basti (Xerolux)", email="git@xerolux.de" },
 ]
@@ -24,7 +30,7 @@ classifiers = [
     "Topic :: Home Automation",
 ]
 dependencies = [
-    "aiohttp>=3.11.0,<3.14",
+    "aiohttp>=3.11.0,<3.15",
 ]
 
 [project.optional-dependencies]

{violet_poolcontroller_api-0.0.32 → violet_poolcontroller_api-0.0.34}/tests/test_api.py

@@ -1683,8 +1683,10 @@ async def test_client_error_does_not_trip_circuit_breaker(
             await api_client.get_readings()
 
     stats = api_client._circuit_breaker.get_stats()
+    if "note" in stats:
+        pytest.skip("Lock held during stats collection")
     assert stats["failure_count"] == 0
-    assert stats["state"] == "CLOSED"
+    assert stats["state"].name == "CLOSED"
 
 
 @pytest.mark.asyncio
@@ -1694,12 +1696,14 @@ async def test_server_error_still_counts_for_circuit_breaker(
 ) -> None:
     """5xx errors keep counting as circuit breaker failures."""
     url = "http://192.168.1.100/getReadings?ALL"
-    mock_aioresponse.get(url, status=500, body="boom")
+    mock_aioresponse.get(url, status=500, body="boom", repeat=True)
 
     with pytest.raises(VioletPoolAPIError):
         await api_client.get_readings()
 
     stats = api_client._circuit_breaker.get_stats()
+    if "note" in stats:
+        pytest.skip("Lock held during stats collection")
     assert stats["failure_count"] == 1
 
 

violet_poolcontroller_api-0.0.34/tests/test_circuit_breaker.py

@@ -0,0 +1,138 @@
+"""Tests for violet_poolcontroller_api.circuit_breaker module."""
+
+import pytest
+
+from violet_poolcontroller_api.circuit_breaker import (
+    CircuitBreaker,
+    CircuitBreakerOpenError,
+)
+
+
+class TestCircuitBreakerStates:
+    """Test circuit breaker state transitions."""
+
+    @pytest.fixture
+    def circuit_breaker(self):
+        """Create circuit breaker instance."""
+        return CircuitBreaker(failure_threshold=3, recovery_timeout=1)
+
+    async def test_initial_state_closed(self, circuit_breaker):
+        """Circuit breaker starts in CLOSED state."""
+        assert circuit_breaker.state.name == "CLOSED"
+
+    async def test_state_transitions_closed_to_open(self, circuit_breaker):
+        """CLOSED → OPEN after threshold failures."""
+        async def failing():
+            raise ValueError("simulated failure")
+
+        for _ in range(3):
+            with pytest.raises(ValueError):
+                await circuit_breaker.call(failing)
+
+        assert circuit_breaker.state.name == "OPEN"
+        assert circuit_breaker.failure_count == 3
+
+    async def test_circuit_open_rejects_calls(self, circuit_breaker):
+        """OPEN circuit raises CircuitBreakerOpenError."""
+        async def failing():
+            raise ValueError("fail")
+
+        for _ in range(3):
+            with pytest.raises(ValueError):
+                await circuit_breaker.call(failing)
+
+        with pytest.raises(CircuitBreakerOpenError):
+            await circuit_breaker.call(failing)
+
+    async def test_ignored_exceptions_dont_count(self):
+        """Ignored exceptions pass through without incrementing failure count."""
+        cb = CircuitBreaker(
+            failure_threshold=2,
+            recovery_timeout=1,
+            ignored_exceptions=(ValueError,),
+        )
+
+        async def value_err():
+            raise ValueError("should be ignored")
+
+        for _ in range(5):
+            with pytest.raises(ValueError):
+                await cb.call(value_err)
+
+        assert cb.failure_count == 0
+        assert cb.state.name == "CLOSED"
+
+    async def test_success_resets_failure_count(self, circuit_breaker):
+        """Success resets failure count."""
+        async def failing():
+            raise ValueError("fail")
+
+        async def succeeding():
+            return "ok"
+
+        # Trigger one failure
+        with pytest.raises(ValueError):
+            await circuit_breaker.call(failing)
+        assert circuit_breaker.failure_count == 1
+
+        # Success
+        result = await circuit_breaker.call(succeeding)
+        assert result == "ok"
+        assert circuit_breaker.failure_count == 0
+        assert circuit_breaker.state.name == "CLOSED"
+
+
+class TestCircuitBreakerConfiguration:
+    """Test circuit breaker configuration."""
+
+    def test_custom_failure_threshold(self):
+        """Set custom failure threshold."""
+        cb = CircuitBreaker(failure_threshold=5, recovery_timeout=2)
+        assert cb.failure_threshold == 5
+
+    def test_zero_failure_threshold(self):
+        """Zero failure threshold opens on first failure."""
+        cb = CircuitBreaker(failure_threshold=0, recovery_timeout=1)
+
+        async def failing():
+            raise ValueError("fail")
+
+        with pytest.raises(ValueError):
+            cb.call(failing)  # no await needed — fails before reaching callable
+
+    def test_negative_recovery_timeout(self):
+        """Negative timeout handled gracefully."""
+        cb = CircuitBreaker(failure_threshold=2, recovery_timeout=-1)
+        assert cb is not None
+
+    def test_custom_recovery_timeout(self):
+        """Set custom recovery timeout."""
+        cb = CircuitBreaker(failure_threshold=2, recovery_timeout=5)
+        assert cb.recovery_timeout == 5
+
+
+class TestCircuitBreakerMetrics:
+    """Test circuit breaker metrics."""
+
+    async def test_get_stats_returns_state_info(self):
+        """get_stats returns current state info."""
+        cb = CircuitBreaker(failure_threshold=2, recovery_timeout=1)
+        stats = cb.get_stats()
+        assert stats["state"].name == "CLOSED"
+        assert stats["failure_count"] == 0
+
+    async def test_reset_clears_state(self):
+        """reset restores CLOSED state and clears counters."""
+        cb = CircuitBreaker(failure_threshold=2, recovery_timeout=1)
+
+        async def failing():
+            raise ValueError("fail")
+
+        for _ in range(2):
+            with pytest.raises(ValueError):
+                await cb.call(failing)
+
+        assert cb.state.name == "OPEN"
+        cb.reset()
+        assert cb.state.name == "CLOSED"
+        assert cb.failure_count == 0

{violet_poolcontroller_api-0.0.32 → violet_poolcontroller_api-0.0.34/violet_poolController_api.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: violet-poolController-api
-Version: 0.0.32
+Version: 0.0.34
 Summary: Asynchronous Python client for the Violet Pool Controller.
 Author-email: "Basti (Xerolux)" <git@xerolux.de>
 License: AGPL-3.0-or-later
@@ -20,7 +20,7 @@ Classifier: Topic :: Home Automation
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: aiohttp<3.14,>=3.11.0
+Requires-Dist: aiohttp<3.15,>=3.11.0
 Provides-Extra: test
 Requires-Dist: aioresponses>=0.7.8; extra == "test"
 Requires-Dist: pytest>=8.3; extra == "test"

{violet_poolcontroller_api-0.0.32 → violet_poolcontroller_api-0.0.34}/violet_poolController_api.egg-info/SOURCES.txt

@@ -18,6 +18,7 @@ violet_poolcontroller_api/circuit_breaker.py
 violet_poolcontroller_api/const_api.py
 violet_poolcontroller_api/const_devices.py
 violet_poolcontroller_api/parsers.py
+violet_poolcontroller_api/py.typed
 violet_poolcontroller_api/readings.py
 violet_poolcontroller_api/utils_rate_limiter.py
 violet_poolcontroller_api/utils_sanitizer.py

{violet_poolcontroller_api-0.0.32 → violet_poolcontroller_api-0.0.34}/violet_poolController_api.egg-info/requires.txt

@@ -1,4 +1,4 @@
-aiohttp<3.14,>=3.11.0
+aiohttp<3.15,>=3.11.0
 
 [test]
 aioresponses>=0.7.8

{violet_poolcontroller_api-0.0.32 → violet_poolcontroller_api-0.0.34}/violet_poolcontroller_api/api.py

@@ -19,6 +19,7 @@
 from __future__ import annotations
 
 import asyncio
+import ipaddress
 import json
 import logging
 import math
@@ -331,18 +332,63 @@ class VioletPoolAPI:
             parsed = urlparse(host)
             host = parsed.netloc
 
-        # Validate hostname format (allowing optional port)
-        if not re.match(r"^[a-zA-Z0-9.-]+(?::[0-9]{1,5})?$", host):
+        try:
+            literal_ip = ipaddress.ip_address(host)
+        except ValueError:
+            literal_ip = None
+        if literal_ip is not None and literal_ip.version == 6:
+            protocol = "https" if use_ssl else "http"
+            return urlunparse((protocol, f"[{host}]", "", "", "", ""))
+
+        try:
+            parsed_host = urlparse(f"//{host}")
+        except ValueError as err:
+            msg = f"Invalid hostname format: {host}"
+            raise ValueError(msg) from err
+
+        if parsed_host.username or parsed_host.password:
+            msg = f"Invalid hostname format: {host}"
+            raise ValueError(msg)
+        if parsed_host.path or parsed_host.query or parsed_host.fragment:
+            msg = f"Invalid hostname format: {host}"
+            raise ValueError(msg)
+
+        hostname = parsed_host.hostname
+        if not hostname:
+            msg = f"Invalid hostname format: {host}"
+            raise ValueError(msg)
+
+        try:
+            port = parsed_host.port
+        except ValueError as err:
+            msg = f"Invalid port in hostname: {host}"
+            raise ValueError(msg) from err
+
+        if port is not None and not 1 <= port <= 65535:
+            msg = f"Invalid port in hostname: {host}"
+            raise ValueError(msg)
+
+        try:
+            ipaddress.ip_address(hostname)
+            is_ip_literal = True
+        except ValueError:
+            is_ip_literal = False
+
+        if not is_ip_literal and not re.match(r"^[a-zA-Z0-9.-]+$", hostname):
             msg = f"Invalid hostname format: {host}"
             raise ValueError(msg)
 
         # Additional validation
-        if len(host) > _MAX_HOSTNAME_LENGTH or ".." in host or "//" in host:
+        if len(hostname) > _MAX_HOSTNAME_LENGTH or ".." in hostname or "//" in host:
             msg = f"Invalid hostname: {host}"
             raise ValueError(msg)
 
+        netloc = f"[{hostname}]" if ":" in hostname else hostname
+        if port is not None:
+            netloc = f"{netloc}:{port}"
+
         protocol = "https" if use_ssl else "http"
-        return urlunparse((protocol, host, "", "", "", ""))
+        return urlunparse((protocol, netloc, "", "", "", ""))
 
     def _build_url(self, endpoint: str) -> str:
         """Construct the full URL for a given endpoint.
@@ -400,10 +446,11 @@ class VioletPoolAPI:
                 await self._rate_limiter.wait_if_needed(priority=priority, timeout=10.0)
             except TimeoutError:
                 _LOGGER.warning(
-                    "Rate limiter timeout for %s (priority: %d) - continuing",
+                    "Rate limiter timeout for %s (priority: %d) - applying fallback delay",
                     endpoint,
                     priority,
                 )
+                await asyncio.sleep(1.0)
 
             url = self._build_url(endpoint)
             if query:
@@ -435,8 +482,6 @@ class VioletPoolAPI:
                             response.status >= _HTTP_CLIENT_ERROR
                             and response.status < _HTTP_SERVER_ERROR
                         ):
-                            # Client errors (4xx, except 429 handled above) are
-                            # deterministic - fail fast instead of retrying.
                             body = await response.text()
                             msg = f"HTTP {response.status} for {endpoint}: {body.strip()}"
                             is_auth = response.status in (
@@ -446,19 +491,18 @@ class VioletPoolAPI:
                             raise _DeterministicClientError(msg, is_auth=is_auth)
 
                         if expect_json:
+                            body_text = await response.text()
                             try:
-                                return await response.json(content_type=None)
+                                return json.loads(body_text)
                             except (
-                                aiohttp.ContentTypeError,
                                 json.JSONDecodeError,
                             ) as err:
-                                body = await response.text()
-                                msg = f"Invalid JSON payload for {endpoint}: {body.strip()}"
+                                msg = f"Invalid JSON payload for {endpoint}: {body_text.strip()}"
                                 raise VioletPayloadError(msg) from err
 
                         return await response.text()
 
-                except (TimeoutError, aiohttp.ServerTimeoutError) as err:
+                except (TimeoutError,) as err:
                     last_error = VioletTimeoutError(
                         f"Request to {endpoint} timed out: {err}",
                     )
@@ -470,8 +514,8 @@ class VioletPoolAPI:
                     )
                     if attempt == self._max_retries:
                         raise last_error from None
-                    delay = min(2.0, 0.2 * (2 ** (attempt - 1)))
-                    jitter = random.uniform(0, delay * 0.1)  # Add 0-10% jitter
+                    delay = min(300.0, 10.0 * (2 ** (attempt - 1)))
+                    jitter = random.uniform(0, delay * 0.1)
                     await asyncio.sleep(delay + jitter)
                 except aiohttp.ClientError as err:
                     last_error = VioletPoolAPIError(
@@ -485,9 +529,8 @@ class VioletPoolAPI:
                     )
                     if attempt == self._max_retries:
                         raise last_error from None
-                    # Exponential backoff with jitter
-                    delay = min(2.0, 0.2 * (2 ** (attempt - 1)))
-                    jitter = random.uniform(0, delay * 0.1)  # Add 0-10% jitter
+                    delay = min(300.0, 10.0 * (2 ** (attempt - 1)))
+                    jitter = random.uniform(0, delay * 0.1)
                     await asyncio.sleep(delay + jitter)
 
             msg = "All retry attempts exhausted"
@@ -536,10 +579,10 @@ class VioletPoolAPI:
         # a substring check when the first line is neither marker.
         if first_line.startswith("ERROR"):
             success = False
-        elif first_line == "OK":
+        elif first_line == "OK" or first_line.startswith("MANDOS_"):
             success = True
         else:
-            success = not text or "error" not in text.lower()
+            success = False
 
         result: dict[str, Any] = {"success": success, "response": text}
         if len(lines) >= 2:
@@ -647,7 +690,7 @@ class VioletPoolAPI:
 
                 sanitized_config[sanitized_key] = sanitized_value
             except ValueError as err:
-                _LOGGER.exception("Invalid config parameter %s", key)
+                _LOGGER.warning("Invalid config parameter %s", key)
                 msg = f"Invalid configuration parameter: {key}"
                 raise VioletPoolAPIError(
                     msg,
@@ -711,7 +754,7 @@ class VioletPoolAPI:
             for item in readings:
                 if isinstance(item, dict) and item.get("VALUE NAME"):
                     key = str(item["VALUE NAME"]).strip().strip('"')
-                    val = item.get("VALUE", item.get("VALUE ", item.get("value")))
+                    val = item.get("VALUE", item.get("VALUE ", item.get("value")))  # "VALUE " fallback for firmware <1.0.9 trailing-space bug
                     flat_dict[key] = val
             return flat_dict
 
@@ -1620,7 +1663,10 @@ class VioletPoolAPI:
             is_info, is_reminder.
 
         """
-        code = str(error_code).strip().zfill(4)
+        code = str(error_code).strip()
+        if not code:
+            return {"code": "0000", "severity": "UNKNOWN", "message": "Invalid empty error code"}
+        code = code.zfill(4)
         info = ERROR_CODES.get(code)
 
         if info:
@@ -2085,7 +2131,9 @@ class VioletPoolAPI:
         header = lines[0].split(";")
         values = lines[2].split(";")
         result: dict[str, str] = {}
-        for key, raw_value in zip(header, values, strict=False):
+        if len(header) != len(values):
+            _LOGGER.warning("Live trace header/value length mismatch: %d vs %d", len(header), len(values))
+        for key, raw_value in zip(header, values):
             key = key.strip()
             if not key:
                 continue
@@ -2175,4 +2223,5 @@ class VioletPoolAPI:
         )
         if isinstance(resp, dict):
             return resp
+        _LOGGER.warning("Unexpected non-dict response for get_output_runtimes: %s", type(resp).__name__)
         return {}

{violet_poolcontroller_api-0.0.32 → violet_poolcontroller_api-0.0.34}/violet_poolcontroller_api/circuit_breaker.py

@@ -26,7 +26,7 @@ from enum import StrEnum
 from typing import TYPE_CHECKING, Any
 
 if TYPE_CHECKING:
-    from collections.abc import Callable
+    from collections.abc import Awaitable, Callable
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -86,7 +86,7 @@ class CircuitBreaker:
             recovery_timeout,
         )
 
-    async def call(self, func: Callable, *args: Any, **kwargs: Any) -> Any:  # noqa: ANN401
+    async def call(self, func: Callable[..., Awaitable[Any]], *args: Any, **kwargs: Any) -> Any:  # noqa: ANN401
         """Execute function with circuit breaker protection.
 
         Args:
@@ -116,14 +116,15 @@ class CircuitBreaker:
                     "Circuit breaker entering HALF_OPEN state for recovery test",
                 )
 
-            # Check if half-open timeout exceeded
+            # Check if half-open timeout exceeded — but ONLY transition to CLOSED
+            # when a call actually succeeds (see the try block below).
             if (
                 self.state == CircuitBreakerState.HALF_OPEN
                 and current_time - self.half_open_start_time > self.recovery_timeout
             ):
-                self.state = CircuitBreakerState.CLOSED
-                self.failure_count = 0
-                _LOGGER.info("Circuit breaker recovered to CLOSED state")
+                _LOGGER.info(
+                    "Circuit breaker HALF_OPEN timeout — will close on next success"
+                )
 
             # Fail fast if circuit is open
             if self.state == CircuitBreakerState.OPEN:
@@ -164,7 +165,7 @@ class CircuitBreaker:
 
         except Exception:
             # Unexpected exception - don't count for circuit breaker
-            _LOGGER.exception("Unexpected error in circuit breaker")
+            _LOGGER.exception("Unhandled exception escaped circuit breaker")
             raise
 
         else:
@@ -180,7 +181,9 @@ class CircuitBreaker:
             return result
 
     def get_stats(self) -> dict[str, Any]:
-        """Get circuit breaker statistics."""
+        """Get circuit breaker statistics (thread-safe snapshot)."""
+        if self._lock.locked():
+            return {"state": self.state, "note": "lock held, stats may be stale"}
         return {
             "state": self.state,
             "failure_count": self.failure_count,

{violet_poolcontroller_api-0.0.32 → violet_poolcontroller_api-0.0.34}/violet_poolcontroller_api/parsers.py

@@ -135,7 +135,10 @@ def parse_epoch_seconds(value: int | float | str) -> datetime | None:
         return None
     if not math.isfinite(ts) or ts == 0:
         return None
-    return datetime.fromtimestamp(ts, tz=UTC)
+    try:
+        return datetime.fromtimestamp(ts, tz=UTC)
+    except (OSError, OverflowError):
+        return None
 
 
 def parse_epoch_milliseconds(value: int | float | str) -> datetime | None:
@@ -157,7 +160,10 @@ def parse_epoch_milliseconds(value: int | float | str) -> datetime | None:
         return None
     if not math.isfinite(ts_ms) or ts_ms == 0:
         return None
-    return datetime.fromtimestamp(ts_ms / 1000.0, tz=UTC)
+    try:
+        return datetime.fromtimestamp(ts_ms / 1000.0, tz=UTC)
+    except (OSError, OverflowError):
+        return None
 
 
 def parse_optional_seconds(value: str | float | int) -> timedelta | None:

{violet_poolcontroller_api-0.0.32 → violet_poolcontroller_api-0.0.34}/violet_poolcontroller_api/readings.py

@@ -71,7 +71,7 @@ def _opt_float(raw: Any) -> float | None:  # noqa: ANN401
         return None
     try:
         return float(raw)
-    except (ValueError, TypeError):
+    except (ValueError, TypeError, OverflowError):
         return None
 
 
@@ -410,7 +410,14 @@ class VioletReadings(Mapping[str, Any]):
         ``True`` means the input is closed (logic 1), ``False`` means open (0).
         Absent inputs default to ``False``.
         """
-        return {i: bool(int(self._raw.get(f"INPUT{i}", 0) or 0)) for i in range(1, 13)}
+        result: dict[int, bool] = {}
+        for i in range(1, 13):
+            raw = self._raw.get(f"INPUT{i}", 0)
+            try:
+                result[i] = bool(int(raw or 0))
+            except (ValueError, TypeError):
+                result[i] = False
+        return result
 
     # ------------------------------------------------------------------
     # Dosing channel output states
@@ -428,14 +435,17 @@ class VioletReadings(Mapping[str, Any]):
     @cached_property
     def dosing_daily_amounts_ml(self) -> dict[str, int | None]:
         """Today's dosing amounts in mL for each dosing channel."""
-        return {
-            key: (
-                int(v)
-                if (v := self._raw.get(f"{key}_DAILY_DOSING_AMOUNT_ML")) is not None
-                else None
-            )
-            for key in _DOSING_KEYS
-        }
+        result: dict[str, int | None] = {}
+        for key in _DOSING_KEYS:
+            v = self._raw.get(f"{key}_DAILY_DOSING_AMOUNT_ML")
+            if v is None:
+                result[key] = None
+            else:
+                try:
+                    result[key] = int(v)
+                except (ValueError, TypeError):
+                    result[key] = None
+        return result
 
     # ------------------------------------------------------------------
     # DMX light scenes (1-12)

{violet_poolcontroller_api-0.0.32 → violet_poolcontroller_api-0.0.34}/violet_poolcontroller_api/utils_rate_limiter.py

@@ -65,9 +65,10 @@ class RateLimiter:
         self.last_refill = time.monotonic()
 
         # Optimized request history with size and time limits
-        self.request_history: deque = deque(maxlen=500)  # Reduced from 1000
+        self.request_history: deque = deque(maxlen=500)
         self.blocked_requests = 0
         self.total_requests = 0
+        self._last_known_tokens = 0.0
         self.history_cleanup_interval = 300  # 5 minutes
         self.last_cleanup_time = time.monotonic()
 
@@ -126,6 +127,7 @@ class RateLimiter:
             # Track failures efficiently
             self.blocked_requests += 1
             self._recent_stats["blocked_last_minute"] += 1
+            self._last_known_tokens = self.tokens
             return False
 
     def _cleanup_history(self, current_time: float) -> None:
@@ -171,10 +173,8 @@ class RateLimiter:
                 msg = f"Rate Limiter timeout nach {elapsed:.1f}s"
                 raise TimeoutError(msg)
 
-            # Adaptive Wartezeit: Berechne basierend auf Refill-Rate
-            # Statt fest retry_after zu warten, berechne optimale Wartezeit
             refill_rate = self.max_requests / self.time_window
-            needed_tokens = 1.0 - self.tokens  # Wieviele Tokens fehlen
+            needed_tokens = 1.0 - self._last_known_tokens
             if refill_rate > 0:
                 optimal_wait = needed_tokens / refill_rate
                 wait_time = min(optimal_wait, self.retry_after)
@@ -220,6 +220,8 @@ class RateLimiter:
         self.blocked_requests = 0
         self.total_requests = 0
         self.request_history.clear()
+        self._recent_stats["requests_last_minute"] = 0
+        self._recent_stats["blocked_last_minute"] = 0
         _LOGGER.debug("Rate Limiter zurückgesetzt")
 
 

{violet_poolcontroller_api-0.0.32 → violet_poolcontroller_api-0.0.34}/violet_poolcontroller_api/utils_sanitizer.py

@@ -20,6 +20,7 @@
 from __future__ import annotations
 
 import logging
+import math
 import re
 import unicodedata
 from html import escape
@@ -98,20 +99,16 @@ class InputSanitizer:
             )
             str_value = str_value[:max_length]
 
-        # Wenn keine Sonderzeichen erlaubt sind, entfernen wir sie ZUERST.
         if not allow_special_chars:
-            # Entferne gefährliche Zeichen
             original = str_value
-            str_value = re.sub(r"[^a-zA-Z0-9_-]", "", str_value)
+            str_value = re.sub(r"[^a-zA-Z0-9 _-]", "", str_value)
             if str_value != original:
                 _LOGGER.warning(
                     "Gefährliche Zeichen entfernt: '%s' → '%s'",
                     original,
                     str_value,
                 )
-        # HTML-Escape nur wenn Sonderzeichen erlaubt sind
-        # (sonst sind < und > bereits durch Regex entfernt)
-        elif escape_html:
+        if escape_html:
             str_value = escape(str_value)
 
         return str_value
@@ -129,18 +126,22 @@ class InputSanitizer:
         """
         try:
             if isinstance(value, (int, float)):
+                if not math.isfinite(float(value)):
+                    _LOGGER.warning("Unendlicher/NaN-Wert: %s", value)
+                    return 0.0
                 return float(value)
 
-            # Konvertiere String zu Zahl
             str_value = str(value).strip()
-            # Entferne alle Zeichen außer Zahlen, Minus und Punkt
-            cleaned = re.sub(r"[^0-9.-]", "", str_value)
+            has_minus = str_value.startswith("-")
+            cleaned = re.sub(r"[^0-9.]", "", str_value)
+            if has_minus and cleaned:
+                cleaned = "-" + cleaned
 
             if not cleaned:
                 return 0.0
 
             return float(cleaned)
-        except (ValueError, TypeError):
+        except (ValueError, TypeError, OverflowError):
             _LOGGER.warning("Ungültiger numerischer Wert: %s", value)
             return 0.0
 
@@ -166,7 +167,7 @@ class InputSanitizer:
         try:
             try:
                 int_value = int(value)
-            except (ValueError, TypeError):
+            except (ValueError, TypeError, OverflowError):
                 int_value = int(float(value))
 
             # Range-Validierung
@@ -466,7 +467,7 @@ class InputSanitizer:
         """
         return InputSanitizer.sanitize_integer(
             orp,
-            min_value=400,
+            min_value=500,
             max_value=900,
             default=700,
         )

violet_poolcontroller_api-0.0.32/tests/test_circuit_breaker.py

@@ -1,204 +0,0 @@
-"""Tests for violet_poolcontroller_api.circuit_breaker module."""
-
-import pytest
-
-from violet_poolcontroller_api.circuit_breaker import CircuitBreaker
-
-
-class TestCircuitBreakerStates:
-    """Test circuit breaker state transitions."""
-
-    @pytest.fixture
-    def circuit_breaker(self):
-        """Create circuit breaker instance."""
-        return CircuitBreaker(
-            failure_threshold=3,
-            recovery_timeout=1
-        )
-
-    def test_initial_state_closed(self, circuit_breaker):
-        """Circuit breaker starts in CLOSED state."""
-        assert circuit_breaker.state == "CLOSED" or circuit_breaker.state.name == "CLOSED"
-
-    def test_closed_to_open_transition(self, circuit_breaker):
-        """Transition from CLOSED to OPEN on failures."""
-        # Simulate failures
-        for _ in range(3):
-            circuit_breaker.record_failure()
-        # Should be OPEN after threshold
-        assert circuit_breaker.state in ["OPEN", "HALF_OPEN"] or hasattr(circuit_breaker.state, 'name')
-
-    def test_open_to_half_open_transition(self, circuit_breaker):
-        """Transition from OPEN to HALF_OPEN after timeout."""
-        # Trigger OPEN state
-        for _ in range(3):
-            circuit_breaker.record_failure()
-
-        # Wait for recovery timeout (mocked)
-        circuit_breaker.last_failure_time = 0  # Simulate timeout
-
-        # Check if can transition to HALF_OPEN
-        result = circuit_breaker.can_attempt()
-        assert result is True or result is False
-
-    def test_half_open_to_closed_on_success(self, circuit_breaker):
-        """Transition from HALF_OPEN to CLOSED on success."""
-        # Get to HALF_OPEN state
-        for _ in range(3):
-            circuit_breaker.record_failure()
-        circuit_breaker.last_failure_time = 0
-
-        # Record success
-        circuit_breaker.record_success()
-
-        # Should be CLOSED
-        assert circuit_breaker.state in ["CLOSED", "HALF_OPEN"] or hasattr(circuit_breaker.state, 'name')
-
-    def test_half_open_to_open_on_failure(self, circuit_breaker):
-        """Transition from HALF_OPEN back to OPEN on failure."""
-        # Get to HALF_OPEN state
-        for _ in range(3):
-            circuit_breaker.record_failure()
-        circuit_breaker.last_failure_time = 0
-
-        # Record another failure in HALF_OPEN
-        circuit_breaker.record_failure()
-
-        # Should be OPEN
-        state = circuit_breaker.state
-        assert state in ["OPEN", "HALF_OPEN"] or hasattr(state, 'name')
-
-
-class TestCircuitBreakerBehavior:
-    """Test circuit breaker behavior."""
-
-    @pytest.fixture
-    def breaker(self):
-        """Circuit breaker for testing."""
-        return CircuitBreaker(failure_threshold=2, recovery_timeout=1)
-
-    def test_can_attempt_when_closed(self, breaker):
-        """Allow attempts when CLOSED."""
-        assert breaker.can_attempt() is True
-
-    def test_cannot_attempt_when_open(self, breaker):
-        """Reject attempts when OPEN."""
-        # Trigger OPEN
-        for _ in range(2):
-            breaker.record_failure()
-
-        # Should not allow attempts
-        result = breaker.can_attempt()
-        # Result should indicate OPEN state (False or exception)
-        assert result is False or isinstance(result, bool)
-
-    def test_failure_count_tracking(self, breaker):
-        """Track failure count accurately."""
-        breaker.record_failure()
-        # Failure count should increase (or state should reflect it)
-        assert breaker.state is not None
-
-    def test_success_resets_failure_count(self, breaker):
-        """Success resets failure count."""
-        breaker.record_failure()
-        breaker.record_success()
-        # Failure count should be reset (or state should be CLOSED)
-        assert breaker.state == "CLOSED" or breaker.state.name == "CLOSED"
-
-
-class TestCircuitBreakerConfiguration:
-    """Test circuit breaker configuration."""
-
-    def test_custom_failure_threshold(self):
-        """Set custom failure threshold."""
-        cb = CircuitBreaker(failure_threshold=5, recovery_timeout=2)
-        assert cb is not None
-        # Should accept configuration
-        for _ in range(5):
-            cb.record_failure()
-
-    def test_custom_recovery_timeout(self):
-        """Set custom recovery timeout."""
-        cb = CircuitBreaker(failure_threshold=2, recovery_timeout=5)
-        # Timeout should be honored
-        for _ in range(2):
-            cb.record_failure()
-
-    def test_custom_circuit_breaker(self):
-        """Create custom circuit breaker."""
-        cb = CircuitBreaker(failure_threshold=2, recovery_timeout=1)
-        assert cb is not None
-
-
-class TestCircuitBreakerEdgeCases:
-    """Test edge cases."""
-
-    def test_zero_failure_threshold(self):
-        """Handle zero failure threshold."""
-        cb = CircuitBreaker(failure_threshold=0, recovery_timeout=1)
-        assert cb is not None
-
-    def test_negative_recovery_timeout(self):
-        """Handle edge case timeouts."""
-        # Breaker should handle gracefully
-        cb = CircuitBreaker(failure_threshold=2, recovery_timeout=0)
-        assert cb is not None
-
-    def test_rapid_failures(self):
-        """Handle rapid consecutive failures."""
-        cb = CircuitBreaker(failure_threshold=3, recovery_timeout=1)
-        for _ in range(10):
-            cb.record_failure()
-        # Should be OPEN
-        assert cb.state in ["OPEN", "HALF_OPEN"] or hasattr(cb.state, 'name')
-
-    def test_alternating_success_failure(self):
-        """Handle alternating success/failure."""
-        cb = CircuitBreaker(failure_threshold=2, recovery_timeout=1)
-        for i in range(5):
-            if i % 2 == 0:
-                cb.record_failure()
-            else:
-                cb.record_success()
-        # State should reflect pattern
-        assert cb.state is not None
-
-
-class TestCircuitBreakerThreadSafety:
-    """Test thread-safety (basic)."""
-
-    def test_concurrent_access_safety(self):
-        """Circuit breaker handles concurrent access."""
-        cb = CircuitBreaker(failure_threshold=3, recovery_timeout=1)
-        # Should not crash with multiple calls
-        cb.record_failure()
-        cb.can_attempt()
-        cb.record_success()
-        assert cb.state is not None
-
-
-class TestCircuitBreakerMetrics:
-    """Test circuit breaker metrics."""
-
-    def test_tracks_failures(self):
-        """Track failure count."""
-        cb = CircuitBreaker(failure_threshold=2, recovery_timeout=1)
-        cb.record_failure()
-        cb.record_failure()
-        # Should have recorded failures
-        assert cb.state is not None
-
-    def test_tracks_success_count(self):
-        """Track success count."""
-        cb = CircuitBreaker(failure_threshold=2, recovery_timeout=1)
-        cb.record_success()
-        cb.record_success()
-        # Should track successes
-        assert cb.state == "CLOSED" or cb.state.name == "CLOSED"
-
-    def test_last_failure_time(self):
-        """Track last failure time."""
-        cb = CircuitBreaker(failure_threshold=2, recovery_timeout=1)
-        cb.record_failure()
-        # Should have last_failure_time set
-        assert hasattr(cb, 'last_failure_time') or cb.state is not None