python-bsblan 6.1.7__py3-none-any.whl → 6.1.8__py3-none-any.whl

bsblan/_validation.py

@@ -75,8 +75,9 @@ class SectionValidator:
         self._api_validator: APIValidator | None = None
         # Cache of validated hot water parameter id -> name.
         self._hot_water_param_cache: dict[str, str] = {}
-        # Track which hot water param groups have been validated.
+        # Track which hot water param groups have been fully validated.
         self._validated_hot_water_groups: set[str] = set()
+        self._validated_hot_water_parameters: dict[str, set[str]] = {}
         # Locks to prevent concurrent validation of the same section/group.
         self._section_locks: dict[str, asyncio.Lock] = {}
         self._hot_water_group_locks: dict[str, asyncio.Lock] = {}
@@ -192,6 +193,11 @@ class SectionValidator:
             raise BSBLANError(ErrorMsg.API_VALIDATOR_NOT_INITIALIZED)
 
         api_validator = self._api_validator
+        if api_validator.is_section_validated(section):
+            return
+
+        def _requested_parameter_ids() -> set[str]:
+            return set(self._get_section_params(section, include))
 
         async def _validate() -> None:
             logger.debug("Lazy loading section: %s", section)
@@ -205,7 +211,9 @@ class SectionValidator:
         await self._run_once_locked(
             section,
             self._section_locks,
-            lambda: api_validator.is_section_validated(section),
+            lambda: api_validator.are_parameters_validated(
+                section, _requested_parameter_ids()
+            ),
             _validate,
         )
 
@@ -231,49 +239,38 @@ class SectionValidator:
                 If provided, only these parameters will be validated.
 
         """
+        if group_name in self._validated_hot_water_groups:
+            return
 
-        async def _validate() -> None:
-            if not self._api_validator:
-                raise BSBLANError(ErrorMsg.API_VALIDATOR_NOT_INITIALIZED)
+        def _group_params() -> dict[str, str]:
+            return self._get_hot_water_group_params(param_filter, include)
 
-            api_data = self._get_api_data()
-            if not api_data:
-                raise BSBLANError(ErrorMsg.API_DATA_NOT_INITIALIZED)
+        def _requested_parameter_ids() -> set[str]:
+            return set(_group_params())
 
+        async def _validate() -> None:
             logger.debug("Lazy loading hot water group: %s", group_name)
-
-            # Get the base hot water params from API config
-            section_data = api_data.get("hot_water", {})
-
-            # Filter to only the params in this group
-            group_params = {
-                param_id: param_name
-                for param_id, param_name in section_data.items()
-                if param_id in param_filter
+            group_params = _group_params()
+            uncovered_params = {
+                param_id: name
+                for param_id, name in group_params.items()
+                if param_id
+                not in self._validated_hot_water_parameters.get(group_name, set())
             }
 
-            # Apply include filter if specified - only validate requested params
-            if include is not None:
-                group_params = {
-                    param_id: name
-                    for param_id, name in group_params.items()
-                    if name in include
-                }
-
-            if not group_params:
+            if not uncovered_params:
                 logger.debug("No parameters to validate for group %s", group_name)
-                self._validated_hot_water_groups.add(group_name)
                 return
 
             # Request only these specific parameters from the device
-            params = self._extract_params_summary(group_params)
+            params = self._extract_params_summary(uncovered_params)
             response_data = await self._request(
                 params={"Parameter": params["string_par"]}
             )
 
             # Validate and filter out unsupported params
             params_to_remove = []
-            for param_id, param_name in group_params.items():
+            for param_id, param_name in uncovered_params.items():
                 if param_id not in response_data:
                     logger.info(
                         "Hot water param %s (%s) not found in response",
@@ -294,26 +291,87 @@ class SectionValidator:
                     params_to_remove.append(param_id)
 
             # Update the cache with validated params for this group
-            for param_id, param_name in group_params.items():
+            for param_id, param_name in uncovered_params.items():
                 if param_id not in params_to_remove:
                     self._hot_water_param_cache[param_id] = param_name
 
-            # Mark this group as validated
-            self._validated_hot_water_groups.add(group_name)
+            validated_ids = self._validated_hot_water_parameters.setdefault(
+                group_name, set()
+            )
+            validated_ids.update(uncovered_params)
+            if (
+                self._get_hot_water_group_params(param_filter, None).keys()
+                <= validated_ids
+            ):
+                self._validated_hot_water_groups.add(group_name)
+            else:
+                self._validated_hot_water_groups.discard(group_name)
             logger.debug(
                 "Validated hot water group '%s': %d params, removed %d unsupported",
                 group_name,
-                len(group_params),
+                len(uncovered_params),
                 len(params_to_remove),
             )
 
         await self._run_once_locked(
             group_name,
             self._hot_water_group_locks,
-            lambda: group_name in self._validated_hot_water_groups,
+            lambda: self._are_hot_water_parameters_validated(
+                group_name, _requested_parameter_ids()
+            ),
             _validate,
         )
 
+    def _get_section_params(
+        self, section: SectionLiteral, include: list[str] | None
+    ) -> dict[str, str]:
+        """Get the configured parameters selected for a section request."""
+        api_data = self._get_api_data()
+        if not api_data:
+            raise BSBLANError(ErrorMsg.API_DATA_NOT_INITIALIZED)
+
+        try:
+            section_data = api_data[section]
+        except KeyError as err:
+            msg = ErrorMsg.SECTION_NOT_FOUND.format(section)
+            raise BSBLANError(msg) from err
+
+        if include is None:
+            return section_data
+        return {
+            param_id: name for param_id, name in section_data.items() if name in include
+        }
+
+    def _get_hot_water_group_params(
+        self, param_filter: set[str], include: list[str] | None
+    ) -> dict[str, str]:
+        """Get configured parameters selected for a hot water group request."""
+        if not self._api_validator:
+            raise BSBLANError(ErrorMsg.API_VALIDATOR_NOT_INITIALIZED)
+
+        api_data = self._get_api_data()
+        if not api_data:
+            raise BSBLANError(ErrorMsg.API_DATA_NOT_INITIALIZED)
+
+        group_params = {
+            param_id: param_name
+            for param_id, param_name in api_data.get("hot_water", {}).items()
+            if param_id in param_filter
+        }
+        if include is None:
+            return group_params
+        return {
+            param_id: name for param_id, name in group_params.items() if name in include
+        }
+
+    def _are_hot_water_parameters_validated(
+        self, group_name: str, parameter_ids: set[str]
+    ) -> bool:
+        """Check whether every requested hot water parameter ID was validated."""
+        return group_name in self._validated_hot_water_groups or parameter_ids.issubset(
+            self._validated_hot_water_parameters.get(group_name, set())
+        )
+
     async def _validate_api_section(
         self, section: SectionLiteral, include: list[str] | None = None
     ) -> dict[str, Any] | None:
@@ -340,36 +398,31 @@ class SectionValidator:
         if not api_data:
             raise BSBLANError(ErrorMsg.API_DATA_NOT_INITIALIZED)
 
-        # Assign to local variable after asserting it's not None
         api_validator = self._api_validator
-
         if api_validator.is_section_validated(section):
             return None
 
-        # Get parameters for the section
-        try:
-            section_data = api_data[section]
-        except KeyError as err:
-            msg = ErrorMsg.SECTION_NOT_FOUND.format(section)
-            raise BSBLANError(msg) from err
+        section_data = self._get_section_params(section, include)
+        uncovered_params = {
+            param_id: name
+            for param_id, name in section_data.items()
+            if not api_validator.are_parameters_validated(section, {param_id})
+        }
 
-        # Filter to only included params if specified
-        if include is not None:
-            section_data = {
-                param_id: name
-                for param_id, name in section_data.items()
-                if name in include
-            }
+        if not uncovered_params:
+            return None
 
         try:
             # Request data from device for validation
-            params = self._extract_params_summary(section_data)
+            params = self._extract_params_summary(uncovered_params)
             response_data = await self._request(
                 params={"Parameter": params["string_par"]}
             )
 
             # Validate the section against actual device response
-            api_validator.validate_section(section, response_data, include)
+            api_validator.validate_section(
+                section, response_data, parameter_ids=set(uncovered_params)
+            )
             # Update API data with validated configuration
             api_data[section] = api_validator.get_section_params(section)
 

bsblan/models.py

@@ -254,7 +254,11 @@ def _convert_bsblan_value(
         The converted value, or None if the value is inactive.
 
     """
-    if raw_value is None or raw_value in {"---", ""}:
+    # BSB-LAN's `replaceDisabled` setting decides what the firmware sends for a
+    # deactivated/inactive numeric parameter. It defaults to "---", but its own
+    # BSB_LAN_config.h documents "None" as the value Home Assistant users should
+    # pick, so both spellings reach us in the wild.
+    if raw_value is None or raw_value in {"---", "", "None"}:
         return None
 
     raw = str(raw_value)
@@ -302,7 +306,8 @@ class EntityInfo(BaseModel, Generic[T]):
     - ``EntityInfo[time]`` for HH:MM time values
     - ``EntityInfo[str]`` for string / datetime values
 
-    When the device returns ``"---"`` (sensor not in use), ``value`` is set
+    When the device returns ``"---"`` or ``"None"`` (sensor not in use, per
+    BSB-LAN's ``replaceDisabled`` setting), ``value`` is set
     to ``None``.
 
     Attributes:

bsblan/utility.py

@@ -94,12 +94,14 @@ class APIValidator:
     # Flexible type for API data (accepts `APIConfig`, plain dicts, or None)
     api_config: Any  # intentionally permissive to support tests and dynamic data
     validated_sections: set[str] = field(default_factory=set)
+    validated_parameters: dict[str, set[str]] = field(default_factory=dict)
 
     def validate_section(
         self,
         section: str,
         request_data: dict[str, Any],
         include: list[str] | None = None,
+        parameter_ids: set[str] | None = None,
     ) -> None:
         """Validate and update a section of API config based on actual device support.
 
@@ -109,6 +111,8 @@ class APIValidator:
             request_data: Response data from the device for validation
             include: Optional list of parameter names to validate. If None,
                 validates all parameters for the section.
+            parameter_ids: Optional parameter IDs to validate. When supplied,
+                takes precedence over ``include``.
 
         """
         # Check if the section exists in the APIConfig object
@@ -116,19 +120,27 @@ class APIValidator:
             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 = []
+        validated_ids = set()
 
         # Check each parameter in the section (filtered by include if specified)
-        for param_id, param_name in section_config.items():
+        for param_id, param_name in list(section_config.items()):
             # Skip params not in include list (if include is specified)
-            if include is not None and param_name not in include:
+            if parameter_ids is not None and param_id not in parameter_ids:
                 continue
+            if (
+                parameter_ids is None
+                and include is not None
+                and param_name not in include
+            ):
+                continue
+
+            validated_ids.add(param_id)
 
             if param_id not in request_data:
                 logger.info(
@@ -153,8 +165,11 @@ class APIValidator:
         for param_id in params_to_remove:
             section_config.pop(param_id)
 
-        # Mark section as validated
-        self.validated_sections.add(section)
+        self.validated_parameters.setdefault(section, set()).update(validated_ids)
+        if set(section_config).issubset(self.validated_parameters[section]):
+            self.validated_sections.add(section)
+        else:
+            self.validated_sections.discard(section)
 
         logger.debug(
             "Validated section '%s': removed %d unsupported parameters",
@@ -170,8 +185,14 @@ class APIValidator:
         """Get the parameter mapping for a section."""
         return (self.api_config or {}).get(section, {}).copy()
 
+    def are_parameters_validated(self, section: str, parameter_ids: set[str]) -> bool:
+        """Check whether every requested parameter ID was validated."""
+        return section in self.validated_sections or parameter_ids.issubset(
+            self.validated_parameters.get(section, set())
+        )
+
     def is_section_validated(self, section: str) -> bool:
-        """Check if a section has been validated."""
+        """Check whether every current parameter in a section was validated."""
         return section in self.validated_sections
 
     def reset_validation(self, section: str | None = None) -> None:
@@ -183,5 +204,9 @@ class APIValidator:
         """
         if section is None:
             self.validated_sections.clear()
+            self.validated_parameters.clear()
         elif section in self.validated_sections:
             self.validated_sections.remove(section)
+            self.validated_parameters.pop(section, None)
+        else:
+            self.validated_parameters.pop(section, None)

{python_bsblan-6.1.7.dist-info → python_bsblan-6.1.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-bsblan
-Version: 6.1.7
+Version: 6.1.8
 Summary: Asynchronous Python client for BSBLAN API
 Project-URL: Homepage, https://github.com/liudger/python-bsblan
 Project-URL: Repository, https://github.com/liudger/python-bsblan

{python_bsblan-6.1.7.dist-info → python_bsblan-6.1.8.dist-info}/RECORD

@@ -5,15 +5,15 @@ bsblan/_schedules.py,sha256=Pb0TrhoZM3Wlf83zZOo2d31xDLI0178TNWRqhljJJmU,5273
 bsblan/_temperature.py,sha256=DsxFd6f1EMYKHcrf74ScQk6YqaYuUy0zBPHhiP-C0nY,11366
 bsblan/_thermostat.py,sha256=_Dgvt1iVLGJT2H5i4z9R1RUU44NZCJJwnP1D9rSXDHk,5052
 bsblan/_transport.py,sha256=qNtV_8uJrfYfHlbaExPln4jCaJxqE5sypq5OHyxG8KE,8266
-bsblan/_validation.py,sha256=PsS7IeQ_IiiNYF6iu1opJJCe6aHPo41kxvSjapV6fjc,15661
+bsblan/_validation.py,sha256=JXXRRo95k9yIaErrHxui30e5b3CXJkRWvxo9Fy47Pgo,17742
 bsblan/_version.py,sha256=hpeIg9JUswHSorY3iSUERcMC1MzwM9Rpdo1wqeh5rc8,2799
 bsblan/bsblan.py,sha256=su_WvelM4FauTyn1RNTJYQZwfwXhSG0Mj6r7RIGNVIg,46887
 bsblan/constants.py,sha256=G0VEImKfc30W68c8RCH3AWRitCTMSVVgXwdhqHOQr7o,25589
 bsblan/exceptions.py,sha256=Z9pXtVc8zhy9FTBkT8leJ1UE9zdOdLHF7pE7C4GjBmg,2795
-bsblan/models.py,sha256=1uRHmDxvPyGYvIuEJczP1mdCR1IJafDrBL9yKDew8E8,22570
+bsblan/models.py,sha256=nbQjmkLEdM_MtazTTDS1KISZs9h1iestoZg8byVB9kM,22932
 bsblan/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-bsblan/utility.py,sha256=IvDUIpa77lJ6GLFTOx34fDhMlTuIJsaz9HcG-3bncH4,6248
-python_bsblan-6.1.7.dist-info/METADATA,sha256=IXEEUQlZMsUdTijDyzPPUrOVzdQc6HfvNpmdoGF_0Xw,9585
-python_bsblan-6.1.7.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
-python_bsblan-6.1.7.dist-info/licenses/LICENSE.md,sha256=Shv8HPcD1WbZjBPvfb5r3h_cwaPeVaUZMUqU_XQGwGw,1092
-python_bsblan-6.1.7.dist-info/RECORD,,
+bsblan/utility.py,sha256=5oD3f84ke_r7pTQN2jjhhgtVjLjq1Ohld3LlHN7m8xg,7421
+python_bsblan-6.1.8.dist-info/METADATA,sha256=t4usBriYaK4FCTLbD_YI1zMN9Wye-Mfnylmd21mC-hQ,9585
+python_bsblan-6.1.8.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+python_bsblan-6.1.8.dist-info/licenses/LICENSE.md,sha256=Shv8HPcD1WbZjBPvfb5r3h_cwaPeVaUZMUqU_XQGwGw,1092
+python_bsblan-6.1.8.dist-info/RECORD,,