python-bsblan 0.6.4__tar.gz → 1.0.0__tar.gz

{python_bsblan-0.6.4 → python_bsblan-1.0.0}/PKG-INFO

@@ -1,23 +1,24 @@
 Metadata-Version: 2.1
 Name: python-bsblan
-Version: 0.6.4
-Summary: Asynchronous Python client for BSBLAN
+Version: 1.0.0
+Summary: Asynchronous Python client for BSBLAN API
 Home-page: https://github.com/liudger/python-bsblan
 License: MIT
-Keywords: bsblan,thermostat,client,api
+Keywords: bsblan,thermostat,client,api,async
 Author: Willem-Jan van Rootselaar
 Author-email: liudgervr@gmail.com
 Maintainer: Willem-Jan van Rootselaar
 Maintainer-email: liudgervr@gmail.com
-Requires-Python: >=3.12,<4.0
+Requires-Python: >=3.11,<4.0
 Classifier: Development Status :: 3 - Alpha
 Classifier: Framework :: AsyncIO
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Natural Language :: English
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Dist: aiohttp (>=3.8.1)
 Requires-Dist: async-timeout (>=4.0.3,<5.0.0)
@@ -38,7 +39,7 @@ Description-Content-Type: text/markdown
 [![Python Versions][python-versions-shield]][pypi]
 ![Project Stage][project-stage-shield]
 ![Project Maintenance][maintenance-shield]
-[![License][license-shield]](LICENSE.md)
+[![License][license-shield]](.github/LICENSE.md)
 
 [![Build Status][build-shield]][build]
 [![Code Coverage][codecov-shield]][codecov]
@@ -212,7 +213,7 @@ check [the contributor's page][contributors].
 
 MIT License
 
-Copyright (c) 2024 WJ van Rootselaar
+Copyright (c) 2023-2024 WJ van Rootselaar
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -242,7 +243,7 @@ SOFTWARE.
 [contributors]: https://github.com/liudger/python-bsblan/graphs/contributors
 [frenck]: https://github.com/frenck
 [keepchangelog]: http://keepachangelog.com/en/1.0.0/
-[license-shield]: https://img.shields.io/github/license/liudger/python-bsblan.svg
+[license-shield]: https://img.shields.io/badge/license-MIT-blue.svg
 [liudger]: https://github.com/liudger
 [maintenance-shield]: https://img.shields.io/maintenance/yes/2024.svg
 [poetry]: https://python-poetry.org

{python_bsblan-0.6.4 → python_bsblan-1.0.0}/README.md

@@ -4,7 +4,7 @@
 [![Python Versions][python-versions-shield]][pypi]
 ![Project Stage][project-stage-shield]
 ![Project Maintenance][maintenance-shield]
-[![License][license-shield]](LICENSE.md)
+[![License][license-shield]](.github/LICENSE.md)
 
 [![Build Status][build-shield]][build]
 [![Code Coverage][codecov-shield]][codecov]
@@ -178,7 +178,7 @@ check [the contributor's page][contributors].
 
 MIT License
 
-Copyright (c) 2024 WJ van Rootselaar
+Copyright (c) 2023-2024 WJ van Rootselaar
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -208,7 +208,7 @@ SOFTWARE.
 [contributors]: https://github.com/liudger/python-bsblan/graphs/contributors
 [frenck]: https://github.com/frenck
 [keepchangelog]: http://keepachangelog.com/en/1.0.0/
-[license-shield]: https://img.shields.io/github/license/liudger/python-bsblan.svg
+[license-shield]: https://img.shields.io/badge/license-MIT-blue.svg
 [liudger]: https://github.com/liudger
 [maintenance-shield]: https://img.shields.io/maintenance/yes/2024.svg
 [poetry]: https://python-poetry.org

{python_bsblan-0.6.4 → python_bsblan-1.0.0}/pyproject.toml

@@ -1,7 +1,7 @@
 [tool.poetry]
 name = "python-bsblan"
-version = "0.6.4"
-description = "Asynchronous Python client for BSBLAN"
+version = "1.0.0"
+description = "Asynchronous Python client for BSBLAN API"
 authors = ["Willem-Jan van Rootselaar <liudgervr@gmail.com>"]
 maintainers = ["Willem-Jan van Rootselaar <liudgervr@gmail.com>"]
 license = "MIT"
@@ -9,8 +9,9 @@ readme = "README.md"
 homepage = "https://github.com/liudger/python-bsblan"
 repository = "https://github.com/liudger/python-bsblan"
 documentation = "https://github.com/liudger/python-bsblan"
-keywords = ["bsblan", "thermostat", "client" , "api"]
+keywords = ["bsblan", "thermostat", "client" , "api", "async"]
 classifiers = [
+  "License :: OSI Approved :: MIT License",
   "Development Status :: 3 - Alpha",
   "Framework :: AsyncIO",
   "Intended Audience :: Developers",
@@ -25,7 +26,7 @@ packages = [
 ]
 
 [tool.poetry.dependencies]
-python = "^3.12"
+python = "^3.11"
 aiohttp = ">=3.8.1"
 yarl = ">=1.7.2"
 packaging = ">=21.3"
@@ -34,9 +35,13 @@ async-timeout = "^4.0.3"
 mashumaro = "^3.13.1"
 orjson = "^3.9.10"
 
+[tool.poetry.urls]
+"Bug Tracker" = "https://github.com/liudger/python-bsblan/issues"
+Changelog = "https://github.com/liudger/python-bsblan/releases"
+
 [tool.poetry.dev-dependencies]
 covdefaults = "^2.3.0"
-ruff = "^0.6.0"
+ruff = "^0.7.0"
 aresponses = "^3.0.0"
 black = "^24.0.0"
 blacken-docs = "^1.13.0"
@@ -44,8 +49,8 @@ coverage = "^7.0.5"
 flake8 = "^7.0.0"
 isort = "^5.11.4"
 mypy = "^1.0.0"
-pre-commit = "^3.0.0"
-pre-commit-hooks = "^4.3.0"
+pre-commit = "^4.0.0"
+pre-commit-hooks = "^5.0.0"
 pylint = "^3.0.0"
 pytest = "^8.0.0"
 pytest-asyncio = "^0.24.0"
@@ -59,27 +64,21 @@ safety = "^3.0.0"
 codespell = "^2.2.2"
 bandit = "^1.7.4"
 
-[tool.poetry.urls]
-"Bug Tracker" = "https://github.com/liudger/python-bsblan/issues"
-Changelog = "https://github.com/liudger/python-bsblan/releases"
-
-[tool.coverage.report]
-show_missing = true
-fail_under = 53
 
 [tool.coverage.run]
 plugins = ["covdefaults"]
 source = ["bsblan"]
 
-[tool.isort]
-profile = "black"
-multi_line_output = 3
+[tool.coverage.report]
+show_missing = true
+fail_under = 53
 
 [tool.mypy]
 # Specify the target platform details in config, so your developers are
 # free to run mypy on Windows, Linux, or macOS and get consistent
 # results.
 platform = "linux"
+python_version = "3.11"
 
 # show error messages from unrelated files
 follow_imports = "normal"
@@ -106,9 +105,6 @@ warn_unused_configs = true
 warn_unused_ignores = true
 
 [tool.pylint.MASTER]
-extension-pkg-whitelist = [
-  "pydantic"
-]
 ignore= [
   "tests"
 ]
@@ -128,11 +124,11 @@ good-names = [
 ]
 
 [tool.pylint.DESIGN]
-max-attributes = 20
+max-attributes = 12
 
 [tool.pylint."MESSAGES CONTROL"]
 disable= [
-    "too-few-public-methods",
+    # "too-few-public-methods",
     "duplicate-code",
     "format",
     "unsubscriptable-object",
@@ -153,11 +149,16 @@ asyncio_mode = "auto"
 select = ["ALL"]
 ignore = [
   "ANN101", # Self... explanatory
+  "ANN102", # cls... Not classy enough
   "ANN401", # Opinioated warning on disallowing dynamically typed expressions
   "D203", # Conflicts with other rules
   "D213", # Conflicts with other rules
   "D417", # False positives in some occasions
   "PLR2004", # Just annoying, not really useful
+
+  # Conflicts with the Ruff formatter
+  "COM812",
+  "ISC001",
 ]
 
 [tool.ruff.lint.flake8-pytest-style]
@@ -167,9 +168,12 @@ fixture-parentheses = false
 [tool.ruff.lint.isort]
 known-first-party = ["bsblan"]
 
+[tool.ruff.lint.flake8-type-checking]
+runtime-evaluated-base-classes = ["mashumaro.mixins.orjson.DataClassORJSONMixin"]
+
 [tool.ruff.lint.mccabe]
 max-complexity = 25
 
 [build-system]
-build-backend = "poetry.core.masonry.api"
 requires = ["poetry-core>=1.0.0"]
+build-backend = "poetry.core.masonry.api"

{python_bsblan-0.6.4 → python_bsblan-1.0.0}/src/bsblan/bsblan.py

@@ -4,18 +4,18 @@ from __future__ import annotations
 
 import asyncio
 import logging
-from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Mapping, cast
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Any, Literal, Mapping, cast
 
 import aiohttp
 from aiohttp.hdrs import METH_POST
 from aiohttp.helpers import BasicAuth
 from packaging import version as pkg_version
-from typing_extensions import Self
 from yarl import URL
 
 from .constants import (
     API_DATA_NOT_INITIALIZED_ERROR_MSG,
+    API_VALIDATOR_NOT_INITIALIZED_ERROR_MSG,
     API_VERSION_ERROR_MSG,
     API_VERSIONS,
     FIRMWARE_VERSION_ERROR_MSG,
@@ -35,9 +35,13 @@ from .exceptions import (
     BSBLANVersionError,
 )
 from .models import Device, HotWaterState, Info, Sensor, State, StaticState
+from .utility import APIValidator
 
 if TYPE_CHECKING:
     from aiohttp.client import ClientSession
+    from typing_extensions import Self
+
+SectionLiteral = Literal["heating", "staticValues", "device", "sensor", "hot_water"]
 
 logging.basicConfig(level=logging.DEBUG)
 logger = logging.getLogger(__name__)
@@ -69,9 +73,15 @@ class BSBLAN:
     _temperature_range_initialized: bool = False
     _api_data: APIConfig | None = None
     _initialized: bool = False
+    _api_validator: APIValidator = field(init=False)
 
     async def __aenter__(self) -> Self:
-        """Enter the context manager."""
+        """Enter the context manager.
+
+        Returns:
+            Self: The initialized BSBLAN instance.
+
+        """
         if self.session is None:
             self.session = aiohttp.ClientSession()
             self._close_session = True
@@ -79,7 +89,12 @@ class BSBLAN:
         return self
 
     async def __aexit__(self, *args: object) -> None:
-        """Exit the context manager."""
+        """Exit the context manager.
+
+        Args:
+            *args: Variable length argument list.
+
+        """
         if self._close_session and self.session:
             await self.session.close()
 
@@ -87,10 +102,81 @@ class BSBLAN:
         """Initialize the BSBLAN client."""
         if not self._initialized:
             await self._fetch_firmware_version()
+            await self._initialize_api_validator()
             await self._initialize_temperature_range()
             await self._initialize_api_data()
             self._initialized = True
 
+    async def _initialize_api_validator(self) -> None:
+        """Initialize and validate API data against device capabilities."""
+        if self._api_version is None:
+            raise BSBLANError(API_VERSION_ERROR_MSG)
+
+        # Initialize API data if not already done
+        if self._api_data is None:
+            self._api_data = API_VERSIONS[self._api_version]
+
+        # Initialize the API validator
+        self._api_validator = APIValidator(self._api_data)
+
+        # Perform initial validation of each section
+        sections: list[SectionLiteral] = [
+            "heating",
+            "sensor",
+            "staticValues",
+            "device",
+            "hot_water",
+        ]
+        for section in sections:
+            await self._validate_api_section(section)
+
+    async def _validate_api_section(self, section: SectionLiteral) -> None:
+        """Validate a specific section of the API configuration.
+
+        Args:
+            section: The section name to validate
+
+        Raises:
+            BSBLANError: If the API validator is not initialized
+
+        """
+        if not self._api_validator:
+            raise BSBLANError(API_VALIDATOR_NOT_INITIALIZED_ERROR_MSG)
+
+        if not self._api_data:
+            raise BSBLANError(API_DATA_NOT_INITIALIZED_ERROR_MSG)
+
+        # Assign to local variable after asserting it's not None
+        api_validator = self._api_validator
+
+        if api_validator.is_section_validated(section):
+            return
+
+        # Get parameters for the section
+        try:
+            section_data = self._api_data[section]
+        except KeyError as err:
+            error_msg = f"Section '{section}' not found in API data"
+            raise BSBLANError(error_msg) from err
+
+        try:
+            # Request data from device for validation
+            params = await self._extract_params_summary(section_data)
+            response_data = await self._request(
+                params={"Parameter": params["string_par"]}
+            )
+
+            # Validate the section against actual device response
+            api_validator.validate_section(section, response_data)
+            # Update API data with validated configuration
+            if self._api_data:
+                self._api_data[section] = api_validator.get_section_params(section)
+        except BSBLANError as err:
+            logger.warning("Failed to validate section %s: %s", section, str(err))
+            # Reset validation state for this section
+            api_validator.reset_validation(section)
+            raise
+
     async def _fetch_firmware_version(self) -> None:
         """Fetch the firmware version if not already available."""
         if self._firmware_version is None:
@@ -100,7 +186,13 @@ class BSBLAN:
             self._set_api_version()
 
     def _set_api_version(self) -> None:
-        """Set the API version based on the firmware version."""
+        """Set the API version based on the firmware version.
+
+        Raises:
+            BSBLANError: If the firmware version is not set.
+            BSBLANVersionError: If the firmware version is not supported.
+
+        """
         if not self._firmware_version:
             raise BSBLANError(FIRMWARE_VERSION_ERROR_MSG)
 
@@ -126,7 +218,15 @@ class BSBLAN:
             )
 
     async def _initialize_api_data(self) -> APIConfig:
-        """Initialize and cache the API data."""
+        """Initialize and cache the API data.
+
+        Returns:
+            APIConfig: The API configuration data.
+
+        Raises:
+            BSBLANError: If the API version or data is not initialized.
+
+        """
         if self._api_data is None:
             if self._api_version is None:
                 raise BSBLANError(API_VERSION_ERROR_MSG)
@@ -143,7 +243,23 @@ class BSBLAN:
         data: dict[str, object] | None = None,
         params: Mapping[str, str | int] | str | None = None,
     ) -> dict[str, Any]:
-        """Handle a request to a BSBLAN device."""
+        """Handle a request to a BSBLAN device.
+
+        Args:
+            method (str): The HTTP method to use for the request.
+            base_path (str): The base path for the URL.
+            data (dict[str, object] | None): The data to send in the request body.
+            params (Mapping[str, str | int] | str | None): The query parameters
+                to include in the request.
+
+        Returns:
+            dict[str, Any]: The JSON response from the BSBLAN device.
+
+        Raises:
+            BSBLANConnectionError: If there is a connection error.
+            BSBLANError: If there is an error with the request.
+
+        """
         if self.session is None:
             raise BSBLANError(SESSION_NOT_INITIALIZED_ERROR_MSG)
         url = self._build_url(base_path)
@@ -170,7 +286,15 @@ class BSBLAN:
             raise BSBLANError(str(e)) from e
 
     def _build_url(self, base_path: str) -> URL:
-        """Build the URL for the request."""
+        """Build the URL for the request.
+
+        Args:
+            base_path (str): The base path for the URL.
+
+        Returns:
+            URL: The constructed URL.
+
+        """
         if self.config.passkey:
             base_path = f"/{self.config.passkey}{base_path}"
         return URL.build(
@@ -181,62 +305,117 @@ class BSBLAN:
         )
 
     def _get_auth(self) -> BasicAuth | None:
-        """Get the authentication for the request."""
+        """Get the authentication for the request.
+
+        Returns:
+            BasicAuth | None: The authentication object or None if no authentication
+                is required.
+
+        """
         if self.config.username and self.config.password:
             return BasicAuth(self.config.username, self.config.password)
         return None
 
     def _get_headers(self) -> dict[str, str]:
-        """Get the headers for the request."""
+        """Get the headers for the request.
+
+        Returns:
+            dict[str, str]: The headers for the request.
+
+        """
         return {
             "User-Agent": f"PythonBSBLAN/{self._firmware_version}",
             "Accept": "application/json, */*",
         }
 
     def _validate_single_parameter(self, *params: Any, error_msg: str) -> None:
-        """Validate that exactly one parameter is provided."""
+        """Validate that exactly one parameter is provided.
+
+        Args:
+            *params: Variable length argument list of parameters to validate.
+            error_msg (str): The error message to raise if validation fails.
+
+        Raises:
+            BSBLANError: If the validation fails.
+
+        """
         if sum(param is not None for param in params) != 1:
             raise BSBLANError(error_msg)
 
-    async def _get_parameters(self, params: dict[Any, Any]) -> dict[Any, Any]:
-        """Get the parameters info from BSBLAN device."""
+    async def _extract_params_summary(self, params: dict[Any, Any]) -> dict[Any, Any]:
+        """Get the parameters info from BSBLAN device.
+
+        Args:
+            params (dict[Any, Any]): The parameters to get info for.
+
+        Returns:
+            dict[Any, Any]: The parameters info from the BSBLAN device.
+
+        """
         string_params = ",".join(map(str, params))
         return {"string_par": string_params, "list": list(params.values())}
 
     async def state(self) -> State:
-        """Get the current state from BSBLAN device."""
-        api_data = await self._initialize_api_data()
-        params = await self._get_parameters(api_data["heating"])
+        """Get the current state from BSBLAN device.
+
+        Returns:
+            State: The current state of the BSBLAN device.
+
+        """
+        # Get validated parameters for heating section
+        heating_params = self._api_validator.get_section_params("heating")
+        params = await self._extract_params_summary(heating_params)
         data = await self._request(params={"Parameter": params["string_par"]})
         data = dict(zip(params["list"], list(data.values()), strict=True))
+        # we should convert this in homeassistant integration?
         data["hvac_mode"]["value"] = HVAC_MODE_DICT[int(data["hvac_mode"]["value"])]
         return State.from_dict(data)
 
     async def sensor(self) -> Sensor:
-        """Get the sensor information from BSBLAN device."""
-        api_data = await self._initialize_api_data()
-        params = await self._get_parameters(api_data["sensor"])
+        """Get the sensor information from BSBLAN device.
+
+        Returns:
+            Sensor: The sensor information from the BSBLAN device.
+
+        """
+        sensor_params = self._api_validator.get_section_params("sensor")
+        params = await self._extract_params_summary(sensor_params)
         data = await self._request(params={"Parameter": params["string_par"]})
         data = dict(zip(params["list"], list(data.values()), strict=True))
         return Sensor.from_dict(data)
 
     async def static_values(self) -> StaticState:
-        """Get the static information from BSBLAN device."""
-        api_data = await self._initialize_api_data()
-        params = await self._get_parameters(api_data["staticValues"])
+        """Get the static information from BSBLAN device.
+
+        Returns:
+            StaticState: The static information from the BSBLAN device.
+
+        """
+        static_params = self._api_validator.get_section_params("staticValues")
+        params = await self._extract_params_summary(static_params)
         data = await self._request(params={"Parameter": params["string_par"]})
         data = dict(zip(params["list"], list(data.values()), strict=True))
         return StaticState.from_dict(data)
 
     async def device(self) -> Device:
-        """Get BSBLAN device info."""
+        """Get BSBLAN device info.
+
+        Returns:
+            Device: The BSBLAN device information.
+
+        """
         device_info = await self._request(base_path="/JI")
         return Device.from_dict(device_info)
 
     async def info(self) -> Info:
-        """Get information about the current heating system config."""
+        """Get information about the current heating system config.
+
+        Returns:
+            Info: The information about the current heating system config.
+
+        """
         api_data = await self._initialize_api_data()
-        params = await self._get_parameters(api_data["device"])
+        params = await self._extract_params_summary(api_data["device"])
         data = await self._request(params={"Parameter": params["string_par"]})
         data = dict(zip(params["list"], list(data.values()), strict=True))
         return Info.from_dict(data)
@@ -246,7 +425,13 @@ class BSBLAN:
         target_temperature: str | None = None,
         hvac_mode: str | None = None,
     ) -> None:
-        """Change the state of the thermostat through BSB-Lan."""
+        """Change the state of the thermostat through BSB-Lan.
+
+        Args:
+            target_temperature (str | None): The target temperature to set.
+            hvac_mode (str | None): The HVAC mode to set.
+
+        """
         await self._initialize_temperature_range()
 
         self._validate_single_parameter(
@@ -263,11 +448,22 @@ class BSBLAN:
         target_temperature: str | None,
         hvac_mode: str | None,
     ) -> dict[str, Any]:
-        """Prepare the thermostat state for setting."""
+        """Prepare the thermostat state for setting.
+
+        Args:
+            target_temperature (str | None): The target temperature to set.
+            hvac_mode (str | None): The HVAC mode to set.
+
+        Returns:
+            dict[str, Any]: The prepared state for the thermostat.
+
+        """
         state: dict[str, Any] = {}
         if target_temperature is not None:
             self._validate_target_temperature(target_temperature)
-            state.update({"Parameter": "710", "Value": target_temperature, "Type": "1"})
+            state.update(
+                {"Parameter": "710", "Value": target_temperature, "Type": "1"},
+            )
         if hvac_mode is not None:
             self._validate_hvac_mode(hvac_mode)
             state.update(
@@ -280,7 +476,16 @@ class BSBLAN:
         return state
 
     def _validate_target_temperature(self, target_temperature: str) -> None:
-        """Validate the target temperature."""
+        """Validate the target temperature.
+
+        Args:
+            target_temperature (str): The target temperature to validate.
+
+        Raises:
+            BSBLANError: If the temperature range is not initialized.
+            BSBLANInvalidParameterError: If the target temperature is invalid.
+
+        """
         if self._min_temp is None or self._max_temp is None:
             raise BSBLANError(TEMPERATURE_RANGE_ERROR_MSG)
 
@@ -292,39 +497,60 @@ class BSBLAN:
             raise BSBLANInvalidParameterError(target_temperature) from err
 
     def _validate_hvac_mode(self, hvac_mode: str) -> None:
-        """Validate the HVAC mode."""
+        """Validate the HVAC mode.
+
+        Args:
+            hvac_mode (str): The HVAC mode to validate.
+
+        Raises:
+            BSBLANInvalidParameterError: If the HVAC mode is invalid.
+
+        """
         if hvac_mode not in HVAC_MODE_DICT_REVERSE:
             raise BSBLANInvalidParameterError(hvac_mode)
 
     async def _set_thermostat_state(self, state: dict[str, Any]) -> None:
-        """Set the thermostat state."""
+        """Set the thermostat state.
+
+        Args:
+            state (dict[str, Any]): The state to set for the thermostat.
+
+        """
         response = await self._request(base_path="/JS", data=state)
         logger.debug("Response for setting: %s", response)
 
     async def hot_water_state(self) -> HotWaterState:
-        """Get the current hot water state from BSBLAN device."""
-        api_data = await self._initialize_api_data()
-        params = await self._get_parameters(api_data["hot_water"])
+        """Get the current hot water state from BSBLAN device.
+
+        Returns:
+            HotWaterState: The current hot water state.
+
+        """
+        hotwater_params = self._api_validator.get_section_params("hot_water")
+        params = await self._extract_params_summary(hotwater_params)
         data = await self._request(params={"Parameter": params["string_par"]})
         data = dict(zip(params["list"], list(data.values()), strict=True))
         return HotWaterState.from_dict(data)
 
     async def set_hot_water(
         self,
-        operating_mode: str | None = None,
         nominal_setpoint: float | None = None,
         reduced_setpoint: float | None = None,
     ) -> None:
-        """Change the state of the hot water system through BSB-Lan."""
+        """Change the state of the hot water system through BSB-Lan.
+
+        Args:
+            nominal_setpoint (float | None): The nominal setpoint temperature to set.
+            reduced_setpoint (float | None): The reduced setpoint temperature to set.
+
+        """
         self._validate_single_parameter(
-            operating_mode,
             nominal_setpoint,
             reduced_setpoint,
             error_msg=MULTI_PARAMETER_ERROR_MSG,
         )
 
         state = self._prepare_hot_water_state(
-            operating_mode,
             nominal_setpoint,
             reduced_setpoint,
         )
@@ -332,16 +558,23 @@ class BSBLAN:
 
     def _prepare_hot_water_state(
         self,
-        operating_mode: str | None,
         nominal_setpoint: float | None,
         reduced_setpoint: float | None,
     ) -> dict[str, Any]:
-        """Prepare the hot water state for setting."""
+        """Prepare the hot water state for setting.
+
+        Args:
+            nominal_setpoint (float | None): The nominal setpoint temperature to set.
+            reduced_setpoint (float | None): The reduced setpoint temperature to set.
+
+        Returns:
+            dict[str, Any]: The prepared state for the hot water.
+
+        Raises:
+            BSBLANError: If no state is provided.
+
+        """
         state: dict[str, Any] = {}
-        if operating_mode is not None:
-            state.update(
-                {"Parameter": "1600", "EnumValue": operating_mode, "Type": "1"},
-            )
         if nominal_setpoint is not None:
             state.update(
                 {"Parameter": "1610", "Value": str(nominal_setpoint), "Type": "1"},
@@ -355,6 +588,11 @@ class BSBLAN:
         return state
 
     async def _set_hot_water_state(self, state: dict[str, Any]) -> None:
-        """Set the hot water state."""
+        """Set the hot water state.
+
+        Args:
+            state (dict[str, Any]): The state to set for the hot water.
+
+        """
         response = await self._request(base_path="/JS", data=state)
         logger.debug("Response for setting: %s", response)

{python_bsblan-0.6.4 → python_bsblan-1.0.0}/src/bsblan/constants.py

@@ -2,7 +2,18 @@
 
 from __future__ import annotations
 
-from typing import Final, TypedDict
+from typing import Final, NotRequired, TypedDict
+
+
+# API Config Types
+class APIConfigSection(TypedDict):
+    """Type for API configuration section."""
+
+    heating: NotRequired[dict[str, str]]
+    staticValues: NotRequired[dict[str, str]]
+    device: NotRequired[dict[str, str]]
+    sensor: NotRequired[dict[str, str]]
+    hot_water: NotRequired[dict[str, str]]
 
 
 # API Versions
@@ -41,11 +52,16 @@ API_V1: Final[APIConfig] = {
     "hot_water": {
         "1600": "operating_mode",
         "1610": "nominal_setpoint",
+        "1614": "nominal_setpoint_max",
         "1612": "reduced_setpoint",
         "1620": "release",
         "1640": "legionella_function",
         "1645": "legionella_setpoint",
-        "1641": "legionella_periodically",
+        "1641": "legionella_periodicity",
+        "1642": "legionella_function_day",
+        "1643": "legionella_function_time",
+        "8830": "dhw_actual_value_top_temperature",
+        "8820": "state_dhw_pump",
     },
 }
 
@@ -75,11 +91,16 @@ API_V3: Final[APIConfig] = {
     "hot_water": {
         "1600": "operating_mode",
         "1610": "nominal_setpoint",
+        "1614": "nominal_setpoint_max",
         "1612": "reduced_setpoint",
         "1620": "release",
         "1640": "legionella_function",
         "1645": "legionella_setpoint",
-        "1641": "legionella_periodically",
+        "1641": "legionella_periodicity",
+        "1642": "legionella_function_day",
+        "1644": "legionella_function_time",
+        "8830": "dhw_actual_value_top_temperature",
+        "8820": "state_dhw_pump",
     },
 }
 
@@ -113,6 +134,7 @@ API_VERSION_ERROR_MSG: Final[str] = "API version not set"
 MULTI_PARAMETER_ERROR_MSG: Final[str] = "Only one parameter can be set at a time"
 SESSION_NOT_INITIALIZED_ERROR_MSG: Final[str] = "Session not initialized"
 API_DATA_NOT_INITIALIZED_ERROR_MSG: Final[str] = "API data not initialized"
+API_VALIDATOR_NOT_INITIALIZED_ERROR_MSG: Final[str] = "API validator not initialized"
 
 
 # Other Constants

{python_bsblan-0.6.4 → python_bsblan-1.0.0}/src/bsblan/exceptions.py

@@ -9,7 +9,12 @@ class BSBLANError(Exception):
     message: str = "Unexpected response from the BSBLAN device."
 
     def __init__(self, message: str | None = None) -> None:
-        """Initialize a new instance of the BSBLANError class."""
+        """Initialize a new instance of the BSBLANError class.
+
+        Args:
+            message: Optional custom error message.
+
+        """
         if message is not None:
             self.message = message
         super().__init__(self.message)
@@ -22,7 +27,12 @@ class BSBLANConnectionError(BSBLANError):
     message_error: str = "Error occurred while connecting to BSBLAN device."
 
     def __init__(self, response: str | None = None) -> None:
-        """Initialize a new instance of the BSBLANConnectionError class."""
+        """Initialize a new instance of the BSBLANConnectionError class.
+
+        Args:
+            response: Optional response message.
+
+        """
         self.response = response
         super().__init__(self.message)
 
@@ -37,6 +47,11 @@ class BSBLANInvalidParameterError(BSBLANError):
     """Raised when an invalid parameter is provided."""
 
     def __init__(self, parameter: str) -> None:
-        """Initialize a new instance of the BSBLANInvalidParameterError class."""
+        """Initialize a new instance of the BSBLANInvalidParameterError class.
+
+        Args:
+            parameter: The invalid parameter that caused the error.
+
+        """
         self.message = f"Invalid values provided: {parameter}"
         super().__init__(self.message)

{python_bsblan-0.6.4 → python_bsblan-1.0.0}/src/bsblan/models.py

@@ -1,5 +1,7 @@
 """Models for BSB-Lan."""
 
+from __future__ import annotations
+
 from dataclasses import dataclass, field
 
 from mashumaro.mixins.json import DataClassJSONMixin
@@ -63,12 +65,12 @@ class State(DataClassJSONMixin):
     """
 
     hvac_mode: EntityInfo
-    hvac_mode2: EntityInfo
     target_temperature: EntityInfo
     hvac_action: EntityInfo
-    current_temperature: EntityInfo
-    room1_thermostat_mode: EntityInfo
-    room1_temp_setpoint_boost: EntityInfo
+    hvac_mode2: EntityInfo | None = None
+    current_temperature: EntityInfo | None = None
+    room1_thermostat_mode: EntityInfo | None = None
+    room1_temp_setpoint_boost: EntityInfo | None = None
 
 
 @dataclass
@@ -83,21 +85,26 @@ class StaticState(DataClassJSONMixin):
 class Sensor(DataClassJSONMixin):
     """Object holds info about object for sensor climate."""
 
-    current_temperature: EntityInfo
     outside_temperature: EntityInfo
+    current_temperature: EntityInfo | None = None
 
 
 @dataclass
 class HotWaterState(DataClassJSONMixin):
     """Object holds info about object for hot water climate."""
 
-    operating_mode: EntityInfo
-    nominal_setpoint: EntityInfo
-    reduced_setpoint: EntityInfo
-    release: EntityInfo
-    legionella_function: EntityInfo
-    legionella_setpoint: EntityInfo
-    legionella_periodically: EntityInfo
+    operating_mode: EntityInfo | None = None
+    nominal_setpoint: EntityInfo | None = None  # 1610
+    nominal_setpoint_max: EntityInfo | None = None  # 1614
+    reduced_setpoint: EntityInfo | None = None  # 1612
+    release: EntityInfo | None = None  # 1620 - programme
+    legionella_function: EntityInfo | None = None  # 1640 - Fixed weekday
+    legionella_setpoint: EntityInfo | None = None  # 1645
+    legionella_periodicity: EntityInfo | None = None  # 1641 - 7 (days)
+    legionella_function_day: EntityInfo | None = None  # 1642 - Saturday
+    legionella_function_time: EntityInfo | None = None  # 1644 - 12:00
+    dhw_actual_value_top_temperature: EntityInfo | None = None  # 8830
+    state_dhw_pump: EntityInfo | None = None  # 8820
 
 
 @dataclass

python_bsblan-1.0.0/src/bsblan/utility.py

@@ -0,0 +1,101 @@
+"""Utility functions for BSB-LAN integration."""
+
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from constants import APIConfig
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class APIValidator:
+    """Validates and maintains BSB-LAN API configuration."""
+
+    api_config: APIConfig
+    validated_sections: set[str] = field(default_factory=set)
+
+    def validate_section(self, section: str, request_data: dict[str, Any]) -> None:
+        """Validate and update a section of API config based on actual device support.
+
+        Args:
+            section: The section of the API config to validate
+                (e.g., 'heating', 'hot_water')
+            request_data: Response data from the device for validation
+
+        """
+        # Check if the section exists in the APIConfig object
+        section_config = getattr(self.api_config, section, None)
+        if section not in self.api_config:
+            logger.warning("Unknown section '%s' in API configuration", section)
+            return
+
+        # Skip if section was already validated
+        if section in self.validated_sections:
+            logger.debug("Section '%s' was already validated", section)
+            return
+
+        section_config = self.api_config[section]
+        params_to_remove = []
+
+        # Check each parameter in the section
+        for param_id, param_name in section_config.items():
+            if param_id not in request_data:
+                logger.info(
+                    "Parameter %s (%s) not found in device response",
+                    param_id,
+                    param_name,
+                )
+                params_to_remove.append(param_id)
+                continue
+
+            param_data = request_data[param_id]
+            if not self._is_valid_param(param_data):
+                logger.info(
+                    "Parameter %s (%s) returned invalid value: %s",
+                    param_id,
+                    param_name,
+                    param_data.get("value"),
+                )
+                params_to_remove.append(param_id)
+
+        # Remove unsupported parameters from the configuration
+        for param_id in params_to_remove:
+            section_config.pop(param_id)
+
+        # Mark section as validated
+        self.validated_sections.add(section)
+
+        logger.debug(
+            "Validated section '%s': removed %d unsupported parameters",
+            section,
+            len(params_to_remove),
+        )
+
+    def _is_valid_param(self, param: dict[str, Any]) -> bool:
+        """Check if parameter data is valid."""
+        return not (not param or param.get("value") in (None, "---"))
+
+    def get_section_params(self, section: str) -> Any:
+        """Get the parameter mapping for a section."""
+        return self.api_config.get(section, {}).copy()
+
+    def is_section_validated(self, section: str) -> bool:
+        """Check if a section has been validated."""
+        return section in self.validated_sections
+
+    def reset_validation(self, section: str | None = None) -> None:
+        """Reset validation state for a section or all sections.
+
+        Args:
+            section: Specific section to reset, or None to reset all
+
+        """
+        if section is None:
+            self.validated_sections.clear()
+        elif section in self.validated_sections:
+            self.validated_sections.remove(section)