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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: violet-poolController-api
-Version: 0.0.27
+Version: 0.0.31
 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.27 → violet_poolcontroller_api-0.0.31}/pyproject.toml

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

{violet_poolcontroller_api-0.0.27 → violet_poolcontroller_api-0.0.31}/tests/test_api.py

@@ -20,6 +20,7 @@
 
 from __future__ import annotations
 
+from collections.abc import Mapping
 from typing import TYPE_CHECKING, Any, Never
 
 import aiohttp
@@ -34,6 +35,7 @@ from violet_poolcontroller_api.const_api import (
     ERROR_CODES,
     ERROR_SEVERITY_ALARM,
     ERROR_SEVERITY_INFO,
+    ERROR_SEVERITY_REMINDER,
     ERROR_SEVERITY_WARNING,
 )
 
@@ -90,8 +92,8 @@ async def test_get_readings_success(
 
     result = await api_client.get_readings()
 
-    assert isinstance(result, dict)
-    assert result == mock_data
+    assert isinstance(result, Mapping)
+    assert dict(result) == mock_data
 
 
 @pytest.mark.asyncio
@@ -289,8 +291,8 @@ async def test_get_readings_standalone_list_format(
 
     result = await api_client.get_readings()
 
-    assert isinstance(result, dict)
-    assert result == {"date": "12.04.2023", "CPU_TEMP": 45.5}
+    assert isinstance(result, Mapping)
+    assert dict(result) == {"date": "12.04.2023", "CPU_TEMP": 45.5}
     assert api_client.dosing_standalone is True
 
 
@@ -313,7 +315,7 @@ async def test_dosing_standalone_detection_dict_format(
 
     result = await standalone_api_client.get_readings()
 
-    assert isinstance(result, dict)
+    assert isinstance(result, Mapping)
     assert standalone_api_client.dosing_standalone is False
 
 
@@ -869,6 +871,324 @@ async def test_set_dosing_parameters(
     assert result["success"] is True
 
 
+@pytest.mark.asyncio
+async def test_reset_blocking(
+    mock_aioresponse: aioresponses,
+    api_client: VioletPoolAPI,
+) -> None:
+    """Test reset_blocking clears fault blockings via GET /resetBlocking."""
+    url = "http://192.168.1.100/resetBlocking"
+    mock_aioresponse.get(url, body="OK\nBLOCKINGS_CLEARED", status=200)
+
+    result = await api_client.reset_blocking()
+
+    assert result["success"] is True
+    assert "BLOCKINGS_CLEARED" in result["response"]
+
+
+@pytest.mark.asyncio
+async def test_set_can_amount_adjust(
+    mock_aioresponse: aioresponses,
+    api_client: VioletPoolAPI,
+) -> None:
+    """Test set_can_amount (ADJUST) updates canister level via POST."""
+    url = "http://192.168.1.100/setCanAmount"
+    mock_aioresponse.post(url, body="OK\nDOS_1_CL\n25000", status=200)
+
+    result = await api_client.set_can_amount("DOS_1_CL", 25000)
+
+    assert result["success"] is True
+    # Verify form payload sent to the controller
+    sent = list(mock_aioresponse.requests.values())[0][0].kwargs["data"]
+    assert sent["action"] == "ADJUST"
+    assert sent["which"] == "DOS_1_CL"
+    assert sent["amount"] == "25000"
+    assert sent["cid"] == "1"
+
+
+@pytest.mark.asyncio
+async def test_set_can_amount_reset(
+    mock_aioresponse: aioresponses,
+    api_client: VioletPoolAPI,
+) -> None:
+    """Test set_can_amount(reset=True) sends RESET action."""
+    url = "http://192.168.1.100/setCanAmount"
+    mock_aioresponse.post(url, body="OK", status=200)
+
+    result = await api_client.set_can_amount("DOS_6_FLOC", 20000, reset=True)
+
+    assert result["success"] is True
+    sent = list(mock_aioresponse.requests.values())[0][0].kwargs["data"]
+    assert sent["action"] == "RESET"
+    assert sent["cid"] == "6"
+
+
+@pytest.mark.asyncio
+async def test_set_can_amount_rejects_unknown_key(
+    api_client: VioletPoolAPI,
+) -> None:
+    """Test set_can_amount raises on unknown dosing key."""
+    with pytest.raises(VioletPoolAPIError, match="Unknown dosing key"):
+        await api_client.set_can_amount("DOS_99_XXX", 1000)
+
+
+@pytest.mark.asyncio
+async def test_set_can_amount_rejects_nonpositive_amount(
+    api_client: VioletPoolAPI,
+) -> None:
+    """Test set_can_amount rejects zero/negative fill levels."""
+    with pytest.raises(ValueError, match="must be > 0"):
+        await api_client.set_can_amount("DOS_1_CL", 0)
+    with pytest.raises(ValueError, match="must be > 0"):
+        await api_client.set_can_amount("DOS_1_CL", -100)
+
+
+@pytest.mark.asyncio
+async def test_set_system_service_enable(
+    mock_aioresponse: aioresponses,
+    api_client: VioletPoolAPI,
+) -> None:
+    """Test set_system_service(enabled=True) hits the /enableFTP endpoint."""
+    url = "http://192.168.1.100/enableFTP"
+    mock_aioresponse.get(url, body="OK\nenableFTP", status=200)
+
+    result = await api_client.set_system_service("ftp", enabled=True)
+
+    assert result["success"] is True
+    sent_key = list(mock_aioresponse.requests.keys())[0]
+    assert str(sent_key[1]).endswith("/enableFTP")
+
+
+@pytest.mark.asyncio
+async def test_set_system_service_disable(
+    mock_aioresponse: aioresponses,
+    api_client: VioletPoolAPI,
+) -> None:
+    """Test set_system_service(enabled=False) hits /disableSSH."""
+    url = "http://192.168.1.100/disableSSH"
+    mock_aioresponse.get(url, body="OK", status=200)
+
+    result = await api_client.set_system_service("ssh", enabled=False)
+
+    assert result["success"] is True
+    sent_key = list(mock_aioresponse.requests.keys())[0]
+    assert str(sent_key[1]).endswith("/disableSSH")
+
+
+@pytest.mark.asyncio
+async def test_set_system_service_rejects_unknown(
+    api_client: VioletPoolAPI,
+) -> None:
+    """Test set_system_service raises on unknown service name."""
+    with pytest.raises(VioletPoolAPIError, match="Unknown system service"):
+        await api_client.set_system_service("telnet", enabled=True)
+
+
+@pytest.mark.asyncio
+async def test_get_system_services(
+    mock_aioresponse: aioresponses,
+    api_client: VioletPoolAPI,
+) -> None:
+    """Test get_system_services normalises raw getServiceStates response."""
+    url = "http://192.168.1.100/getServiceStates"
+    mock_aioresponse.get(
+        url,
+        payload={
+            "proftpd": 0,
+            "shairport": 1,
+            "samba": 0,
+            "sshd": 1,
+            "homekit": 0,
+            "tunnel_state": 1,
+            "support_tunnel_state": 0,
+            "date": "29.02.2024",
+            "time": "19:50:02",
+        },
+        status=200,
+    )
+
+    result = await api_client.get_system_services()
+
+    # Alexa has no state_key and must be absent.
+    assert "alexa" not in result
+    assert result == {
+        "ftp": False,
+        "shairport": True,
+        "samba": False,
+        "ssh": True,
+        "homebridge": False,
+        "tunnel": True,
+        "support_tunnel": False,
+    }
+
+
+# ---------------------------------------------------------------------------
+# OmniTronic + RS485 + LiveTrace (P12 / P13 / P15)
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_set_omni_position(
+    mock_aioresponse: aioresponses,
+    api_client: VioletPoolAPI,
+) -> None:
+    """Test set_omni_position sends OMNI,OMNI_DC<N> via setFunctionManually."""
+    url = "http://192.168.1.100/setFunctionManually?OMNI,OMNI_DC2,0,0"
+    mock_aioresponse.get(url, body="OK\nOMNITRONIC\nOMNI_DC2\n", status=200)
+
+    result = await api_client.set_omni_position(2)
+
+    # The mock only matches the exact URL we registered, so a True result
+    # proves the right URL was hit (aioresponses returns 404 otherwise).
+    assert result["success"] is True
+    assert "OMNITRONIC" in result["response"]
+    # One request must have been recorded.
+    assert len(list(mock_aioresponse.requests.values())) == 1
+
+
+@pytest.mark.asyncio
+async def test_set_omni_position_filtration(
+    mock_aioresponse: aioresponses,
+    api_client: VioletPoolAPI,
+) -> None:
+    """Position 0 (Filtration) is valid and maps to OMNI_DC0."""
+    url = "http://192.168.1.100/setFunctionManually?OMNI,OMNI_DC0,0,0"
+    mock_aioresponse.get(url, body="OK\nOMNITRONIC\nOMNI_DC0\n", status=200)
+
+    result = await api_client.set_omni_position(0)
+
+    assert result["success"] is True
+
+
+@pytest.mark.asyncio
+async def test_set_omni_position_rejects_out_of_range(
+    api_client: VioletPoolAPI,
+) -> None:
+    """Positions outside 0-5 are rejected before the request is sent."""
+    with pytest.raises(VioletPoolAPIError, match="Invalid OmniTronic position"):
+        await api_client.set_omni_position(6)
+    with pytest.raises(VioletPoolAPIError, match="Invalid OmniTronic position"):
+        await api_client.set_omni_position(-1)
+
+
+@pytest.mark.asyncio
+async def test_get_rs485_pump_data(
+    mock_aioresponse: aioresponses,
+    api_client: VioletPoolAPI,
+) -> None:
+    """Test get_rs485_pump_data returns the pump's JSON config + live values."""
+    url = "http://192.168.1.100/getRS485PumpData?BADU_ECO_DRIVE_II"
+    mock_aioresponse.get(
+        url,
+        payload={
+            "BRAND": "BADU",
+            "NAME": "Eco Drive II",
+            "pump_rs485_pwr": 450,
+            "SLAVE_PRESENT": "YES",
+        },
+        status=200,
+    )
+
+    result = await api_client.get_rs485_pump_data("BADU_ECO_DRIVE_II")
+
+    assert result["BRAND"] == "BADU"
+    assert result["pump_rs485_pwr"] == 450
+    assert result["SLAVE_PRESENT"] == "YES"
+
+
+@pytest.mark.asyncio
+async def test_get_rs485_pump_data_rejects_unknown_pump(
+    api_client: VioletPoolAPI,
+) -> None:
+    with pytest.raises(VioletPoolAPIError, match="Unknown RS485 pump name"):
+        await api_client.get_rs485_pump_data("PENTAIR_VSF")
+
+
+@pytest.mark.asyncio
+async def test_set_rs485_live(
+    mock_aioresponse: aioresponses,
+    api_client: VioletPoolAPI,
+) -> None:
+    """Test set_rs485_live forwards mode+level to the pump's modbus."""
+    url = "http://192.168.1.100/setRS485Live?BADU_ECO_DRIVE_II,1,hz,45"
+    mock_aioresponse.get(url, body='"1|0,0|2,4500"', status=200)
+
+    result = await api_client.set_rs485_live(
+        "BADU_ECO_DRIVE_II", slave_id=1, mode="hz", level=45
+    )
+
+    assert "1|0,0|2,4500" in result
+
+
+@pytest.mark.asyncio
+async def test_set_rs485_live_rejects_bad_mode(
+    api_client: VioletPoolAPI,
+) -> None:
+    with pytest.raises(VioletPoolAPIError, match="Invalid RS485 mode"):
+        await api_client.set_rs485_live(
+            "BADU_ECO_DRIVE_II", slave_id=1, mode="percent", level=50
+        )
+
+
+@pytest.mark.asyncio
+async def test_set_rs485_live_rejects_bad_slave_id(
+    api_client: VioletPoolAPI,
+) -> None:
+    with pytest.raises(ValueError, match="slave_id must be 1-247"):
+        await api_client.set_rs485_live(
+            "BADU_ECO_DRIVE_II", slave_id=0, mode="hz", level=45
+        )
+
+
+@pytest.mark.asyncio
+async def test_end_rs485_live(
+    mock_aioresponse: aioresponses,
+    api_client: VioletPoolAPI,
+) -> None:
+    """Test end_rs485_live sends the DONE sentinel."""
+    url = "http://192.168.1.100/setRS485Live?DONE"
+    mock_aioresponse.get(url, body='"DONE"', status=200)
+
+    result = await api_client.end_rs485_live()
+
+    assert result == "DONE"
+
+
+@pytest.mark.asyncio
+async def test_get_live_trace(
+    mock_aioresponse: aioresponses,
+    api_client: VioletPoolAPI,
+) -> None:
+    """Test get_live_trace parses the 3-line CSV into a dict."""
+    url = "http://192.168.1.100/getLiveTrace"
+    csv_body = (
+        "epoch;date;time;onewire1_value;pH_value;PUMP\n"
+        "ms;;;°C;;\n"
+        "1709234445000;29.02.2024;19:50:02;7,30;7,3;1\n"
+    )
+    mock_aioresponse.get(url, body=csv_body, status=200)
+
+    result = await api_client.get_live_trace()
+
+    assert result["onewire1_value"] == "7.30"  # German comma → dot
+    assert result["pH_value"] == "7.3"
+    assert result["PUMP"] == "1"
+    assert result["date"] == "29.02.2024"
+
+
+@pytest.mark.asyncio
+async def test_get_live_trace_malformed(
+    mock_aioresponse: aioresponses,
+    api_client: VioletPoolAPI,
+) -> None:
+    """Malformed payloads (fewer than 3 lines) raise VioletPoolAPIError."""
+    url = "http://192.168.1.100/getLiveTrace"
+    mock_aioresponse.get(url, body="only_one_line", status=200)
+
+    with pytest.raises(VioletPoolAPIError, match="Malformed getLiveTrace"):
+        await api_client.get_live_trace()
+
+
 @pytest.mark.asyncio
 async def test_control_pump(
     mock_aioresponse: aioresponses,
@@ -984,6 +1304,7 @@ def test_error_codes_structure() -> None:
             ERROR_SEVERITY_ALARM,
             ERROR_SEVERITY_WARNING,
             ERROR_SEVERITY_INFO,
+            ERROR_SEVERITY_REMINDER,
         ), f"Code {code} has invalid severity: {info['severity']}"
 
 
@@ -1012,6 +1333,35 @@ def test_error_codes_hardware_modules() -> None:
     assert ERROR_CODES["0209"]["severity"] == ERROR_SEVERITY_ALARM
 
 
+def test_error_codes_omnitronic_faults_added() -> None:
+    """OmniTronic multi-port valve faults (0045/46/47/49) are present as ALARM."""
+    # Regression test for missing backwash-valve codes – see CLAUDE.md notes.
+    for code in ("0045", "0046", "0047", "0049"):
+        assert code in ERROR_CODES, f"Missing OmniTronic code {code}"
+        assert ERROR_CODES[code]["severity"] == ERROR_SEVERITY_ALARM
+
+
+def test_error_codes_h2o2_dosing_added() -> None:
+    """H2O2 dosing warnings (0142-0145) are present."""
+    for code in ("0142", "0143", "0144", "0145"):
+        assert code in ERROR_CODES, f"Missing H2O2 code {code}"
+        assert ERROR_CODES[code]["severity"] == ERROR_SEVERITY_WARNING
+
+
+def test_error_codes_reminder_category() -> None:
+    """REMINDER-category codes are classified correctly (not INFO)."""
+    # 0003 birthday, 0005 system status, 0010-0012 updates, 0180-0182 calibration.
+    for code in ("0003", "0005", "0010", "0011", "0012", "0180", "0181", "0182"):
+        assert ERROR_CODES[code]["severity"] == ERROR_SEVERITY_REMINDER, code
+
+
+def test_error_code_0005_text_corrected() -> None:
+    """Code 0005 is the generic system-status reminder, not cloud maintenance."""
+    # Regression: previously held wrong text "Wartungsarbeiten am Cloud-Server".
+    assert "Cloud-Server" not in ERROR_CODES["0005"]["message"]
+    assert ERROR_CODES["0005"]["message"] == "Systemnachricht"
+
+
 def test_error_codes_four_digit_format() -> None:
     """Test all error code keys are 4-digit zero-padded strings."""
     for code in ERROR_CODES:

{violet_poolcontroller_api-0.0.27 → violet_poolcontroller_api-0.0.31}/tests/test_mock_server.py

@@ -77,18 +77,26 @@ async def _request(url: str, auth: aiohttp.BasicAuth | None = None) -> tuple[int
 
 async def test_raw_auth() -> None:
     print("=" * 60)
-    print("TEST 1: Raw HTTP - no credentials -> 401")
+    print("TEST 1: Raw HTTP - /getReadings without credentials -> 200")
     print("=" * 60)
     status, body = await _request(f"http://{HOST}:{PORT}/getReadings?ALL")
+    assert status == 200, f"Expected 200, got {status}"
+    print(f"  OK: status={status} body_len={len(body)}")
+
+    print()
+    print("=" * 60)
+    print("TEST 2: Raw HTTP - /getConfig without credentials -> 401")
+    print("=" * 60)
+    status, body = await _request(f"http://{HOST}:{PORT}/getConfig")
     assert status == 401, f"Expected 401, got {status}"
     print(f"  OK: status={status} body={body!r}")
 
     print()
     print("=" * 60)
-    print("TEST 2: Raw HTTP - wrong password -> 401")
+    print("TEST 3: Raw HTTP - /getConfig with wrong password -> 401")
     print("=" * 60)
     status, body = await _request(
-        f"http://{HOST}:{PORT}/getReadings?ALL",
+        f"http://{HOST}:{PORT}/getConfig",
         auth=aiohttp.BasicAuth("admin", "wrongpassword"),
     )
     assert status == 401, f"Expected 401, got {status}"
@@ -96,10 +104,10 @@ async def test_raw_auth() -> None:
 
     print()
     print("=" * 60)
-    print("TEST 3: Raw HTTP - correct credentials -> 200")
+    print("TEST 4: Raw HTTP - /getConfig with correct credentials -> 200")
     print("=" * 60)
     status, body = await _request(
-        f"http://{HOST}:{PORT}/getReadings?ALL",
+        f"http://{HOST}:{PORT}/getConfig",
         auth=aiohttp.BasicAuth(USER, PASS),
     )
     assert status == 200, f"Expected 200, got {status}"
@@ -107,7 +115,7 @@ async def test_raw_auth() -> None:
 
     print()
     print("=" * 60)
-    print("TEST 4: /mock/* endpoints bypass auth")
+    print("TEST 5: /mock/* endpoints bypass auth")
     print("=" * 60)
     status, body = await _request(f"http://{HOST}:{PORT}/mock/state")
     assert status == 200, f"Expected 200, got {status}"
@@ -117,7 +125,7 @@ async def test_raw_auth() -> None:
 async def test_api_client() -> None:
     print()
     print("=" * 60)
-    print("TEST 5: VioletPoolAPI - wrong credentials -> error")
+    print("TEST 6: VioletPoolAPI - wrong credentials -> error on /getConfig")
     print("=" * 60)
     async with aiohttp.ClientSession() as session:
         api_bad = VioletPoolAPI(
@@ -128,14 +136,14 @@ async def test_api_client() -> None:
             max_retries=1,
         )
         try:
-            await api_bad.get_readings()
+            await api_bad.get_config(["DOSAGE_phminus_setpoint"])
             assert False, "Should have raised VioletPoolAPIError"
         except VioletPoolAPIError as exc:
             print(f"  OK: VioletPoolAPIError raised: {exc}")
 
     print()
     print("=" * 60)
-    print("TEST 6: VioletPoolAPI - correct credentials -> full workflow")
+    print("TEST 7: VioletPoolAPI - correct credentials -> full workflow")
     print("=" * 60)
     async with aiohttp.ClientSession() as session:
         api = VioletPoolAPI(
@@ -229,7 +237,7 @@ async def test_api_client() -> None:
 
     print()
     print("=" * 60)
-    print("TEST 7: Error simulation with auth")
+    print("TEST 8: Error simulation with auth")
     print("=" * 60)
     async with aiohttp.ClientSession() as session:
         async with session.get(f"http://{HOST}:{PORT}/mock/error?code=500&count=1") as r:

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: violet-poolController-api
-Version: 0.0.27
+Version: 0.0.31
 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.27 → violet_poolcontroller_api-0.0.31}/violet_poolController_api.egg-info/SOURCES.txt

@@ -14,5 +14,7 @@ violet_poolcontroller_api/api.py
 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/readings.py
 violet_poolcontroller_api/utils_rate_limiter.py
 violet_poolcontroller_api/utils_sanitizer.py

{violet_poolcontroller_api-0.0.27 → violet_poolcontroller_api-0.0.31}/violet_poolcontroller_api/__init__.py

@@ -16,7 +16,17 @@
 
 """Violet Pool Controller API client library."""
 
-from .api import VioletPoolAPI, VioletPoolAPIError
+from .api import (
+    SETPOINT_RANGES,
+    VioletAuthError,
+    VioletPayloadError,
+    VioletPoolAPI,
+    VioletPoolAPIError,
+    VioletSetpointError,
+    VioletTimeoutError,
+    VioletUnsafeOperationError,
+    validate_setpoint,
+)
 from .circuit_breaker import CircuitBreaker, CircuitBreakerOpenError
 from .const_api import (  # noqa: F401
     ACTION_ALLAUTO,
@@ -32,6 +42,7 @@ from .const_api import (  # noqa: F401
     ERROR_CODES,
     ERROR_SEVERITY_ALARM,
     ERROR_SEVERITY_INFO,
+    ERROR_SEVERITY_REMINDER,
     ERROR_SEVERITY_WARNING,
 )
 from .const_devices import (  # noqa: F401
@@ -39,25 +50,70 @@ from .const_devices import (  # noqa: F401
     COVER_STATE_MAP,
     DEVICE_PARAMETERS,
     STATE_TRANSLATIONS,
+    CoverState,
+    DmxSceneState,
+    OnewireState,
+    OutputState,
+    PvSurplusState,
+    RuleState,
     VioletState,
     get_state_translation_language,
     set_state_translation_language,
 )
+from .parsers import (  # noqa: F401
+    parse_epoch_milliseconds,
+    parse_epoch_seconds,
+    parse_hms_string,
+    parse_optional_seconds,
+    parse_runtime_string,
+    parse_uptime_string,
+)
+from .readings import VioletReadings
 from .utils_rate_limiter import RateLimiter, get_global_rate_limiter
 from .utils_sanitizer import InputSanitizer
 
 __all__ = [
+    # Core client
     "VioletPoolAPI",
+    # Exception hierarchy
     "VioletPoolAPIError",
+    "VioletAuthError",
+    "VioletTimeoutError",
+    "VioletPayloadError",
+    "VioletSetpointError",
+    "VioletUnsafeOperationError",
+    # Setpoint validation
+    "SETPOINT_RANGES",
+    "validate_setpoint",
+    # Circuit breaker
     "CircuitBreaker",
     "CircuitBreakerOpenError",
+    # Enums
+    "OutputState",
+    "DmxSceneState",
+    "RuleState",
+    "CoverState",
+    "OnewireState",
+    "PvSurplusState",
+    # State helpers
     "VioletState",
+    "STATE_TRANSLATIONS",
+    "get_state_translation_language",
+    "set_state_translation_language",
+    # Typed readings snapshot
+    "VioletReadings",
+    # Parsers
+    "parse_runtime_string",
+    "parse_hms_string",
+    "parse_uptime_string",
+    "parse_epoch_seconds",
+    "parse_epoch_milliseconds",
+    "parse_optional_seconds",
+    # Utilities
     "InputSanitizer",
     "RateLimiter",
     "get_global_rate_limiter",
-    "get_state_translation_language",
-    "set_state_translation_language",
-    "STATE_TRANSLATIONS",
+    # Action constants
     "ACTION_ALLAUTO",
     "ACTION_ALLOFF",
     "ACTION_ALLON",
@@ -68,11 +124,14 @@ __all__ = [
     "ACTION_ON",
     "ACTION_PUSH",
     "ACTION_UNLOCK",
+    # Device constants
     "COVER_FUNCTIONS",
     "COVER_STATE_MAP",
     "DEVICE_PARAMETERS",
+    # Error codes
     "ERROR_CODES",
     "ERROR_SEVERITY_ALARM",
     "ERROR_SEVERITY_INFO",
+    "ERROR_SEVERITY_REMINDER",
     "ERROR_SEVERITY_WARNING",
 ]