feat: Release 0.7.8 - Complete TypedDict integration for Home Assistant

- Enhanced type safety with full TypedDict compliance
- DeviceInfoDict, APIVersionResponse, StructuredValuesDict properly used
- String literals for TypedDict keys (elegant MyPy compliance)
- StaticValues and InstantValues use proper typed interfaces
- All tests pass, MyPy strict mode clean
- Ready for Home Assistant strict typing requirements

Author: lmaertin

CHANGELOG.md

@@ -5,6 +5,30 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.7.8] - 2025-10-27
+
+### Enhanced
+
+- **Type Safety**: Complete integration of TypedDict definitions from `type_definitions.py`
+  - `DeviceInfoDict` now used throughout for device information
+  - `APIVersionResponse` properly returned from version checks
+  - `StructuredValuesDict` correctly typed for structured instant values
+  - `ValueDict` extended with min/max/step fields for number types
+- **Home Assistant Compatibility**: Full strict typing compliance for HA integrations
+  - All public API methods use proper TypedDict types
+  - MyPy strict mode passes without any type: ignore comments
+  - PEP-561 compliance maintained and enhanced
+- **Code Quality**: Elegant use of string literals for TypedDict keys
+  - Replaced runtime casting with compile-time type safety
+  - Improved maintainability and readability
+  - Better IDE support and autocompletion
+
+### Fixed
+
+- **StaticValues**: Now accepts DeviceInfoDict directly without casting
+- **InstantValues**: to_structured_dict() returns proper StructuredValuesDict type
+- **Constants**: get_default_device_info() returns correct DeviceInfoDict type
+
 ## [0.7.7] - 2025-10-27
 
 ### Added

README.md

@@ -966,6 +966,9 @@ Data Classification:
 
 For detailed release notes and version history, please see [CHANGELOG.md](CHANGELOG.md).
 
-### Latest Release (0.7.7)
+### Latest Release (0.7.8)
 
-- Added `--print-payload` option for debugging HTTP payloads
+- **Enhanced Type Safety**: Full integration of TypedDict definitions from `type_definitions.py`
+- **Home Assistant Ready**: Strict typing compliance for Home Assistant integrations
+- **Improved API**: DeviceInfoDict, APIVersionResponse, and StructuredValuesDict properly utilized
+- **Better Documentation**: Enhanced type annotations and cleaner code structure

src/pooldose/__init__.py

@@ -1,5 +1,5 @@
 """Async API client for SEKO Pooldose."""
 from .client import PooldoseClient
 
-__version__ = "0.7.7"
+__version__ = "0.7.8"
 __all__ = ["PooldoseClient"]

src/pooldose/client.py

@@ -4,20 +4,21 @@
 
 import asyncio
 import logging
-from typing import Optional, Tuple, Any, Dict
+from typing import Optional, Tuple, Any
 
 import aiohttp
 from getmac import get_mac_address
 
 
 from pooldose.constants import get_default_device_info
+from pooldose.type_definitions import DeviceInfoDict, StructuredValuesDict, APIVersionResponse
 from pooldose.mappings.mapping_info import MappingInfo
 from pooldose.request_handler import RequestHandler
 from pooldose.request_status import RequestStatus
 from pooldose.values.instant_values import InstantValues
 from pooldose.values.static_values import StaticValues
 
-# pylint: disable=line-too-long,too-many-instance-attributes
+# pylint: disable=line-too-long,too-many-instance-attributes, line-too-long
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -58,7 +59,7 @@ def __init__(self, host: str, timeout: int = 30, *, websession: Optional[aiohttp
         self._request_handler: RequestHandler | None = None
 
         # Initialize device info with default or placeholder values
-        self.device_info: Dict[str, Any] = get_default_device_info()
+        self.device_info: DeviceInfoDict = get_default_device_info()
 
         # Mapping-Status und Mapping-Cache
         self._mapping_status = None
@@ -103,13 +104,13 @@ def request_handler(self) -> RequestHandler:
             raise RuntimeError("Client not connected. Call connect() first.")
         return self._request_handler
 
-    def check_apiversion_supported(self) -> Tuple[RequestStatus, Dict[str, Optional[str]]]:
+    def check_apiversion_supported(self) -> Tuple[RequestStatus, APIVersionResponse]:
         """
         Check if the loaded API version matches the supported version.
 
         Returns:
-            tuple: (RequestStatus, dict)
-                - dict contains:
+            tuple: (RequestStatus, APIVersionResponse)
+                - APIVersionResponse contains:
                     "api_version_is": the current API version (or None if not set)
                     "api_version_should": the expected API version
                 - RequestStatus.NO_DATA if not set.
@@ -120,7 +121,7 @@ def check_apiversion_supported(self) -> Tuple[RequestStatus, Dict[str, Optional[
                 "api_version_should": API_VERSION_SUPPORTED,
             }
 
-        result = {
+        result: APIVersionResponse = {
             "api_version_is": self._request_handler.api_version,
             "api_version_should": API_VERSION_SUPPORTED,
         }
@@ -233,7 +234,7 @@ def static_values(self) -> tuple[RequestStatus, StaticValues | None]:
             tuple: (RequestStatus, StaticValues|None) - Status and static values object.
         """
         try:
-            # Device info is already Dict[str, Any]
+            # Device info is DeviceInfoDict and StaticValues now accepts it directly
             return RequestStatus.SUCCESS, StaticValues(self.device_info)
         except (ValueError, TypeError, KeyError) as err:
             _LOGGER.warning("Error creating StaticValues: %s", err)
@@ -270,12 +271,12 @@ async def instant_values(self) -> tuple[RequestStatus, InstantValues | None]:
             _LOGGER.warning("Error creating InstantValues: %s", err)
             return RequestStatus.UNKNOWN_ERROR, None
 
-    async def instant_values_structured(self) -> Tuple[RequestStatus, Dict[str, Any]]:
+    async def instant_values_structured(self) -> Tuple[RequestStatus, StructuredValuesDict]:
         """
         Get instant values in structured JSON format with types as top-level keys.
 
         Returns:
-            Tuple[RequestStatus, Dict[str, Any]]: Status and structured data dict.
+            Tuple[RequestStatus, StructuredValuesDict]: Status and structured data dict.
         """
         # Get instant values object
         status, instant_values = await self.instant_values()

src/pooldose/constants.py

@@ -1,9 +1,9 @@
 """Constants for the Pooldose library."""
 
-from typing import Any, Dict, Optional
+from pooldose.type_definitions import DeviceInfoDict
 
 # Default device info structure
-DEFAULT_DEVICE_INFO: Dict[str, Optional[Any]] = {
+DEFAULT_DEVICE_INFO: DeviceInfoDict = {
     "NAME": None,           # Device name
     "SERIAL_NUMBER": None,  # Serial number
     "DEVICE_ID": None,      # Device ID, i.e., SERIAL_NUMBER + "_DEVICE"
@@ -24,6 +24,6 @@
 }
 
 
-def get_default_device_info() -> Dict[str, Optional[Any]]:
+def get_default_device_info() -> DeviceInfoDict:
     """Return a copy of the default device info structure."""
     return DEFAULT_DEVICE_INFO.copy()

src/pooldose/mock_client.py

@@ -10,6 +10,7 @@
 from typing import Any, Dict, List, Optional, Tuple, Union
 
 from pooldose.constants import get_default_device_info
+from pooldose.type_definitions import StructuredValuesDict
 from pooldose.mappings.mapping_info import MappingInfo
 from pooldose.request_status import RequestStatus
 from pooldose.values.instant_values import InstantValues
@@ -229,7 +230,7 @@ def get_last_payload(self) -> Optional[str]:
         return self._last_payload
 
 
-    async def instant_values_structured(self) -> Tuple[RequestStatus, Dict[str, Any]]:
+    async def instant_values_structured(self) -> Tuple[RequestStatus, StructuredValuesDict]:
         """
         Get structured instant values from mock data.
 

src/pooldose/type_definitions.py

@@ -44,6 +44,9 @@ class ValueDict(TypedDict, total=False):
     raw_value: Any
     status: str
     timestamp: int
+    min: Any
+    max: Any
+    step: Any
 
 # Structured values by type
 class StructuredValuesDict(TypedDict, total=False):

src/pooldose/values/instant_values.py

@@ -3,6 +3,8 @@
 import logging
 from typing import Any, Dict, Tuple, Union
 
+from pooldose.type_definitions import StructuredValuesDict
+
 
 # pylint: disable=line-too-long,too-many-arguments,too-many-positional-arguments,too-many-locals,too-many-return-statements,too-many-branches,no-else-return,too-many-public-methods
 
@@ -68,12 +70,14 @@ def get(self, key: str, default=None):
         except KeyError:
             return default
 
-    def to_structured_dict(self) -> Dict[str, Any]:
+    def to_structured_dict(self) -> StructuredValuesDict:
         """
         Convert instant values to structured dictionary format with types as top-level keys.
 
         Returns:
-            Dict[str, Any]: Structured data with format:
+            StructuredValuesDict: Structured data with format:
+            {
+                "sensor": {
                     "temperature": {"value": 25.5, "unit": "°C"},
                     "ph": {"value": 7.2, "unit": None}
                 },
@@ -91,7 +95,7 @@ def to_structured_dict(self) -> Dict[str, Any]:
                 }
             }
         """
-        structured_data: Dict[str, Dict[str, Any]] = {}
+        structured_data: StructuredValuesDict = {}
 
         # Process each mapping entry
         for mapping_key, mapping_entry in self._mapping.items():
@@ -104,32 +108,50 @@ def to_structured_dict(self) -> Dict[str, Any]:
             if raw_entry is None:
                 continue
 
-            # Initialize type section if needed
-            if entry_type not in structured_data:
-                structured_data[entry_type] = {}
+            # Initialize type section if needed - use string literals for TypedDict
+            if entry_type == "sensor":
+                if "sensor" not in structured_data:
+                    structured_data["sensor"] = {}
+            elif entry_type == "switch":
+                if "switch" not in structured_data:
+                    structured_data["switch"] = {}
+            elif entry_type == "number":
+                if "number" not in structured_data:
+                    structured_data["number"] = {}
+            elif entry_type == "binary_sensor":
+                if "binary_sensor" not in structured_data:
+                    structured_data["binary_sensor"] = {}
+            elif entry_type == "select":
+                if "select" not in structured_data:
+                    structured_data["select"] = {}
 
             # Get the processed value using existing logic
             try:
                 value_data = self._get_value(mapping_key)
                 if value_data is None:
                     continue
 
-                # Structure the data based on type
+                # Structure the data based on type - use string literals for TypedDict
                 if entry_type == "sensor":
                     if isinstance(value_data, tuple) and len(value_data) >= 2:
-                        structured_data[entry_type][mapping_key] = {
+                        structured_data["sensor"][mapping_key] = {
                             "value": value_data[0],
                             "unit": value_data[1]
                         }
 
-                elif entry_type in ("binary_sensor", "switch"):
-                    structured_data[entry_type][mapping_key] = {
+                elif entry_type == "binary_sensor":
+                    structured_data["binary_sensor"][mapping_key] = {
+                        "value": value_data
+                    }
+
+                elif entry_type == "switch":
+                    structured_data["switch"][mapping_key] = {
                         "value": value_data
                     }
 
                 elif entry_type == "number":
                     if isinstance(value_data, tuple) and len(value_data) >= 5:
-                        structured_data[entry_type][mapping_key] = {
+                        structured_data["number"][mapping_key] = {
                             "value": value_data[0],
                             "unit": value_data[1],
                             "min": value_data[2],
@@ -138,7 +160,7 @@ def to_structured_dict(self) -> Dict[str, Any]:
                         }
 
                 elif entry_type == "select":
-                    structured_data[entry_type][mapping_key] = {
+                    structured_data["select"][mapping_key] = {
                         "value": value_data
                     }
 

src/pooldose/values/static_values.py

@@ -1,7 +1,9 @@
 """Static Values for Async API client for SEKO Pooldose."""
 
 import logging
-from typing import Any, Dict, Optional
+from typing import Optional
+
+from pooldose.type_definitions import DeviceInfoDict
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -14,15 +16,15 @@ class StaticValues:
     property with a descriptive name. All properties are read-only.
 
     Args:
-        device_info (Dict[str, Any]): The dictionary containing static device information.
+        device_info (DeviceInfoDict): The dictionary containing static device information.
     """
 
-    def __init__(self, device_info: Dict[str, Any]):
+    def __init__(self, device_info: DeviceInfoDict):
         """
         Initialize StaticValues.
 
         Args:
-            device_info (Dict[str, Any]): The dictionary containing static device information.
+            device_info (DeviceInfoDict): The dictionary containing static device information.
         """
         self._device_info = device_info