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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: violet-poolController-api
-Version: 0.0.31
+Version: 0.0.32
 Summary: Asynchronous Python client for the Violet Pool Controller.
 Author-email: "Basti (Xerolux)" <git@xerolux.de>
 License: AGPL-3.0-or-later

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

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

violet_poolcontroller_api-0.0.32/tests/test_circuit_breaker.py

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

violet_poolcontroller_api-0.0.32/tests/test_parsers.py

@@ -0,0 +1,161 @@
+"""Tests for violet_poolcontroller_api.parsers module."""
+
+from violet_poolcontroller_api.parsers import (
+    parse_epoch_milliseconds,
+    parse_epoch_seconds,
+    parse_hms_string,
+    parse_optional_seconds,
+    parse_runtime_string,
+    parse_uptime_string,
+)
+
+
+class TestParseRuntimeString:
+    """Test parse_runtime_string parser."""
+
+    def test_valid_runtime_string(self):
+        """Parse valid runtime format."""
+        assert parse_runtime_string("00:05:30") == 330  # 5min 30sec in seconds
+        assert parse_runtime_string("01:30:45") == 5445  # 1h 30min 45sec
+        assert parse_runtime_string("00:00:00") == 0
+
+    def test_invalid_runtime_string(self):
+        """Handle invalid runtime formats gracefully."""
+        assert parse_runtime_string("invalid") is None or isinstance(parse_runtime_string("invalid"), (int, float))
+        assert parse_runtime_string("") is None or isinstance(parse_runtime_string(""), (int, float))
+        assert parse_runtime_string(None) is None or isinstance(parse_runtime_string(None), (int, float))
+
+
+class TestParseHmsString:
+    """Test parse_hms_string parser."""
+
+    def test_valid_hms_string(self):
+        """Parse valid HH:MM:SS format."""
+        assert parse_hms_string("01:30:45") == 5445
+        assert parse_hms_string("00:00:01") == 1
+        assert parse_hms_string("23:59:59") == 86399
+
+    def test_edge_cases(self):
+        """Handle edge cases."""
+        assert parse_hms_string("00:00:00") == 0
+        # All-zeros case
+
+    def test_invalid_hms(self):
+        """Handle invalid HMS formats."""
+        result = parse_hms_string("invalid")
+        assert result is None or isinstance(result, (int, float))
+
+
+class TestParseUptimeString:
+    """Test parse_uptime_string parser."""
+
+    def test_valid_uptime_formats(self):
+        """Parse valid uptime formats."""
+        # Support various uptime formats
+        result = parse_uptime_string("5 days, 3:45:22")
+        assert isinstance(result, (int, float)) or result is None
+
+    def test_uptime_with_days(self):
+        """Parse uptime with days."""
+        result = parse_uptime_string("365 days")
+        assert isinstance(result, (int, float)) or result is None
+
+    def test_invalid_uptime(self):
+        """Handle invalid uptime formats."""
+        result = parse_uptime_string("invalid")
+        assert result is None or isinstance(result, (int, float))
+
+
+class TestParseOptionalSeconds:
+    """Test parse_optional_seconds parser."""
+
+    def test_valid_seconds(self):
+        """Parse valid second values."""
+        assert parse_optional_seconds("120") == 120
+        assert parse_optional_seconds("0") == 0
+        assert parse_optional_seconds("3600") == 3600
+
+    def test_none_sentinel(self):
+        """Handle 'NONE' sentinel value."""
+        result = parse_optional_seconds("NONE")
+        assert result is None or result == 0 or result == -1
+
+    def test_invalid_seconds(self):
+        """Handle invalid seconds."""
+        result = parse_optional_seconds("invalid")
+        assert result is None or isinstance(result, (int, float))
+
+
+class TestParseEpochSeconds:
+    """Test parse_epoch_seconds parser."""
+
+    def test_valid_epoch(self):
+        """Parse valid epoch timestamp (seconds)."""
+        # Jan 1, 1970 00:00:00 UTC
+        assert parse_epoch_seconds("0") == 0
+        # Some arbitrary timestamp
+        assert isinstance(parse_epoch_seconds("1609459200"), (int, float))
+
+    def test_zero_epoch(self):
+        """Handle zero epoch."""
+        assert parse_epoch_seconds("0") == 0
+
+    def test_invalid_epoch(self):
+        """Handle invalid epoch values."""
+        result = parse_epoch_seconds("invalid")
+        assert result is None or isinstance(result, (int, float))
+
+
+class TestParseEpochMilliseconds:
+    """Test parse_epoch_milliseconds parser."""
+
+    def test_valid_epoch_ms(self):
+        """Parse valid epoch timestamp (milliseconds)."""
+        result = parse_epoch_milliseconds("1609459200000")
+        assert isinstance(result, (int, float)) or result is None
+
+    def test_zero_epoch_ms(self):
+        """Handle zero epoch."""
+        result = parse_epoch_milliseconds("0")
+        assert result == 0 or result is None
+
+    def test_invalid_epoch_ms(self):
+        """Handle invalid epoch values."""
+        result = parse_epoch_milliseconds("invalid")
+        assert result is None or isinstance(result, (int, float))
+
+
+class TestParserEdgeCases:
+    """Test edge cases across all parsers."""
+
+    def test_empty_string(self):
+        """Parsers handle empty strings gracefully."""
+        for parser in [
+            parse_runtime_string,
+            parse_hms_string,
+            parse_uptime_string,
+            parse_optional_seconds,
+            parse_epoch_seconds,
+            parse_epoch_milliseconds,
+        ]:
+            result = parser("")
+            assert result is None or isinstance(result, (int, float))
+
+    def test_none_input(self):
+        """Parsers handle None input gracefully."""
+        for parser in [
+            parse_runtime_string,
+            parse_hms_string,
+            parse_uptime_string,
+            parse_optional_seconds,
+            parse_epoch_seconds,
+            parse_epoch_milliseconds,
+        ]:
+            result = parser(None)
+            assert result is None or isinstance(result, (int, float))
+
+    def test_whitespace_handling(self):
+        """Parsers handle whitespace appropriately."""
+        # Parsers should either strip or reject whitespace
+        result = parse_runtime_string("  00:05:30  ")
+        assert result is None or isinstance(result, (int, float))

violet_poolcontroller_api-0.0.32/tests/test_readings.py

@@ -0,0 +1,192 @@
+"""Tests for violet_poolcontroller_api.readings module."""
+
+import pytest
+
+from violet_poolcontroller_api.readings import VioletReadings
+
+
+class TestVioletReadingsBasic:
+    """Test VioletReadings basic functionality."""
+
+    @pytest.fixture
+    def sample_data(self):
+        """Provide sample API response data."""
+        return {
+            "POOL_TEMP": 24.5,
+            "SOLAR_TEMP": 32.1,
+            "AMBIENT_TEMP": 18.3,
+            "pH": 7.2,
+            "ORP": 650,
+            "PUMP_STATE": "1",
+            "HEATER_STATE": "0",
+        }
+
+    def test_readings_creation(self, sample_data):
+        """Create VioletReadings from dict."""
+        readings = VioletReadings(sample_data)
+        assert readings is not None
+        assert isinstance(readings, dict)  # VioletReadings is dict-like
+
+    def test_readings_value_access(self, sample_data):
+        """Access values from VioletReadings."""
+        readings = VioletReadings(sample_data)
+        assert readings.get("POOL_TEMP") == 24.5
+        assert readings.get("pH") == 7.2
+
+    def test_readings_missing_key(self, sample_data):
+        """Handle missing keys gracefully."""
+        readings = VioletReadings(sample_data)
+        assert readings.get("NONEXISTENT") is None
+        assert readings.get("NONEXISTENT", "default") == "default"
+
+
+class TestVioletReadingsTypeConversions:
+    """Test typed property access and conversions."""
+
+    @pytest.fixture
+    def mixed_data(self):
+        """Data with various types."""
+        return {
+            "TEMPERATURE": "24.5",
+            "STATE": "1",
+            "RUNTIME": 3600,
+            "ENABLED": "true",
+            "DISABLED": "false",
+            "NULL_VALUE": None,
+        }
+
+    def test_temperature_conversion(self, mixed_data):
+        """Convert temperature string to float."""
+        readings = VioletReadings(mixed_data)
+        temp = readings.get("TEMPERATURE")
+        # Should be convertible to float
+        assert isinstance(temp, (int, float, str))
+
+    def test_state_conversion(self, mixed_data):
+        """Convert state string to int."""
+        readings = VioletReadings(mixed_data)
+        state = readings.get("STATE")
+        assert state is not None
+
+    def test_boolean_conversion(self, mixed_data):
+        """Convert boolean strings."""
+        readings = VioletReadings(mixed_data)
+        enabled = readings.get("ENABLED")
+        disabled = readings.get("DISABLED")
+        # Should be interpretable as boolean
+        assert enabled is not None
+        assert disabled is not None
+
+    def test_none_handling(self, mixed_data):
+        """Handle None values properly."""
+        readings = VioletReadings(mixed_data)
+        null_val = readings.get("NULL_VALUE")
+        assert null_val is None
+
+
+class TestVioletReadingsAggregation:
+    """Test readings aggregation and derived properties."""
+
+    def test_readings_contains_all_keys(self):
+        """Verify readings contains all provided keys."""
+        data = {
+            "KEY1": "value1",
+            "KEY2": "value2",
+            "KEY3": "value3",
+        }
+        readings = VioletReadings(data)
+        assert "KEY1" in readings
+        assert "KEY2" in readings
+        assert "KEY3" in readings
+
+    def test_readings_iteration(self):
+        """Iterate over readings."""
+        data = {"A": 1, "B": 2, "C": 3}
+        readings = VioletReadings(data)
+        keys = list(readings.keys())
+        assert "A" in keys
+        assert "B" in keys
+        assert "C" in keys
+
+
+class TestVioletReadingsEdgeCases:
+    """Test edge cases in readings handling."""
+
+    def test_empty_readings(self):
+        """Create readings from empty dict."""
+        readings = VioletReadings({})
+        assert len(readings) == 0
+
+    def test_large_dataset(self):
+        """Handle large dataset."""
+        large_data = {f"KEY_{i}": f"value_{i}" for i in range(1000)}
+        readings = VioletReadings(large_data)
+        assert len(readings) == 1000
+        assert readings.get("KEY_0") == "value_0"
+        assert readings.get("KEY_999") == "value_999"
+
+    def test_special_characters_in_values(self):
+        """Handle special characters in values."""
+        data = {
+            "UNICODE": "测试",
+            "SPECIAL": "!@#$%^&*()",
+            "QUOTES": 'value with "quotes"',
+        }
+        readings = VioletReadings(data)
+        assert readings.get("UNICODE") == "测试"
+        assert readings.get("SPECIAL") == "!@#$%^&*()"
+
+    def test_numeric_edge_cases(self):
+        """Handle numeric edge cases."""
+        data = {
+            "ZERO": 0,
+            "NEGATIVE": -100,
+            "FLOAT": 3.14159,
+            "LARGE": 999999999,
+            "SCIENTIFIC": 1e-6,
+        }
+        readings = VioletReadings(data)
+        assert readings.get("ZERO") == 0
+        assert readings.get("NEGATIVE") == -100
+        assert readings.get("FLOAT") == 3.14159
+
+
+class TestVioletReadingsIntegration:
+    """Integration tests with realistic data."""
+
+    def test_realistic_pool_data(self):
+        """Test with realistic pool controller data."""
+        realistic_data = {
+            "POOL_TEMP": 24.5,
+            "SOLAR_TEMP": 35.2,
+            "AMBIENT_TEMP": 22.0,
+            "pH": 7.3,
+            "ORP": 680,
+            "CONDUCTIVITY": 1200,
+            "PUMP_STATE": "1",
+            "HEATER_STATE": "0",
+            "SOLAR_STATE": "1",
+            "DOSING_PH_MINUS": "0",
+            "DOSING_PH_PLUS": "0",
+            "DOSING_CL": "1",
+            "PUMP_RUNTIME": 3600,
+            "FILTER_RUNTIME": 3600,
+            "ERROR_CODE": "0",
+            "DI1": "0",
+            "DI2": "1",
+            "DO1": "0",
+            "DO2": "1",
+        }
+        readings = VioletReadings(realistic_data)
+        assert len(readings) == 20
+        assert readings.get("POOL_TEMP") == 24.5
+        assert readings.get("DI1") == "0"
+
+    def test_readings_snapshot_behavior(self):
+        """Verify readings behave as immutable snapshots."""
+        data = {"TEMP": 25.0}
+        readings = VioletReadings(data)
+        # Original data shouldn't affect readings after creation
+        original_temp = readings.get("TEMP")
+        # Readings should be stable
+        assert readings.get("TEMP") == original_temp

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: violet-poolController-api
-Version: 0.0.31
+Version: 0.0.32
 Summary: Asynchronous Python client for the Violet Pool Controller.
 Author-email: "Basti (Xerolux)" <git@xerolux.de>
 License: AGPL-3.0-or-later

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

@@ -3,7 +3,10 @@ README.md
 pyproject.toml
 tests/test_api.py
 tests/test_api_smoke.py
+tests/test_circuit_breaker.py
 tests/test_mock_server.py
+tests/test_parsers.py
+tests/test_readings.py
 violet_poolController_api.egg-info/PKG-INFO
 violet_poolController_api.egg-info/SOURCES.txt
 violet_poolController_api.egg-info/dependency_links.txt

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

@@ -22,6 +22,7 @@ import asyncio
 import json
 import logging
 import math
+import random
 import re
 import ssl
 from typing import TYPE_CHECKING, Any, cast
@@ -470,7 +471,8 @@ class VioletPoolAPI:
                     if attempt == self._max_retries:
                         raise last_error from None
                     delay = min(2.0, 0.2 * (2 ** (attempt - 1)))
-                    await asyncio.sleep(delay)
+                    jitter = random.uniform(0, delay * 0.1)  # Add 0-10% jitter
+                    await asyncio.sleep(delay + jitter)
                 except aiohttp.ClientError as err:
                     last_error = VioletPoolAPIError(
                         f"Error communicating with Violet controller: {err}",
@@ -485,7 +487,8 @@ class VioletPoolAPI:
                         raise last_error from None
                     # Exponential backoff with jitter
                     delay = min(2.0, 0.2 * (2 ** (attempt - 1)))
-                    await asyncio.sleep(delay)
+                    jitter = random.uniform(0, delay * 0.1)  # Add 0-10% jitter
+                    await asyncio.sleep(delay + jitter)
 
             msg = "All retry attempts exhausted"
             raise VioletPoolAPIError(msg)

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

@@ -171,8 +171,17 @@ class RateLimiter:
                 msg = f"Rate Limiter timeout nach {elapsed:.1f}s"
                 raise TimeoutError(msg)
 
-            # Warte auf Token-Refill
-            await asyncio.sleep(self.retry_after)
+            # 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
+            if refill_rate > 0:
+                optimal_wait = needed_tokens / refill_rate
+                wait_time = min(optimal_wait, self.retry_after)
+            else:
+                wait_time = self.retry_after
+
+            await asyncio.sleep(wait_time)
 
     def _refill_tokens(self, current_time: float) -> None:
         """Fülle Token-Bucket basierend auf verstrichener Zeit."""

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

@@ -21,6 +21,7 @@ from __future__ import annotations
 
 import logging
 import re
+import unicodedata
 from html import escape
 from typing import Any
 
@@ -83,6 +84,10 @@ class InputSanitizer:
         # Konvertiere zu String
         str_value = str(value).strip()
 
+        # Unicode-Normalisierung (NFKD für Defense-in-Depth)
+        # Normalized Form Compatibility Decomposition
+        str_value = unicodedata.normalize("NFKD", str_value)
+
         # Längen-Validierung
         if len(str_value) > max_length:
             _LOGGER.warning(