python-bsblan 5.2.0__py3-none-any.whl → 6.0.0__py3-none-any.whl

bsblan/bsblan.py

@@ -19,6 +19,8 @@ from yarl import URL
 
 from .constants import (
     API_VERSIONS,
+    PPS_HEATING_PARAMS,
+    PPS_STATIC_VALUES_PARAMS,
     APIConfig,
     CircuitConfig,
     ErrorMsg,
@@ -100,6 +102,7 @@ class BSBLAN:
     _firmware_version: str | None = None
     _api_version: str | None = None
     _api_data: APIConfig | None = None
+    _device: Device | None = None
     _initialized: bool = False
     _api_validator: APIValidator = field(init=False)
     _temperature_unit: str = "°C"
@@ -152,13 +155,10 @@ class BSBLAN:
     async def get_available_circuits(self) -> list[int]:
         """Detect which heating circuits are available on the device.
 
-        Uses a two-step probe for each circuit (1, 2):
-        1. Query the operating mode parameter — the response must be
-           non-empty and contain actual data.
-        2. Query the status parameter (8000/8001) — an inactive
-           circuit returns ``value="0"`` with ``desc="---"``.
-
-        A circuit is only considered available when both checks pass.
+        Uses the configured operating mode probe parameters from
+        CircuitConfig.PROBE_PARAMS as the only discovery signal. Status
+        parameters are not queried during discovery to keep setup lightweight
+        and avoid excluding valid circuits when status data is unavailable.
 
         This is useful for integration setup flows (e.g., Home Assistant
         config flow) to discover how many circuits the user's controller
@@ -173,54 +173,48 @@ class BSBLAN:
                 # circuits == [1, 2] for a dual-circuit controller
 
         """
+        if self._uses_pps_bus:
+            return await self._get_available_pps_circuits()
+
         available: list[int] = []
         for circuit, param_id in CircuitConfig.PROBE_PARAMS.items():
             try:
                 response = await self._request(
                     params={"Parameter": param_id},
                 )
-                # A circuit exists if the response contains the param_id key
-                # with actual data (not an empty dict)
-                if not response.get(param_id):
-                    continue
-
-                # Secondary check: query the status parameter.
-                # Inactive circuits either:
-                # - return value="0" and desc="---"
-                # - return an empty dict {} (param not supported)
-                status_id = CircuitConfig.STATUS_PARAMS[circuit]
-                status_resp = await self._request(
-                    params={"Parameter": status_id},
+            except BSBLANError:
+                logger.debug(
+                    "Circuit %d not available (operating mode request failed)",
+                    circuit,
                 )
-                status_data = status_resp.get(status_id, {})
+                continue
 
-                # Empty response means the parameter doesn't exist
-                if not status_data or not isinstance(status_data, dict):
-                    logger.debug(
-                        "Circuit %d has no status data (not supported)",
-                        circuit,
-                    )
-                    continue
-
-                # value="0" + desc="---" means inactive
-                if (
-                    status_data.get("desc") == CircuitConfig.INACTIVE_MARKER
-                    and str(status_data.get("value", "")) == "0"
-                ):
-                    logger.debug(
-                        "Circuit %d has status '---' (inactive)",
-                        circuit,
-                    )
-                    continue
-
-                available.append(circuit)
-            except BSBLANError:
+            # A circuit exists if the response contains the operating mode key
+            # with actual data (not an empty dict).
+            if not response.get(param_id):
                 logger.debug(
-                    "Circuit %d not available (request failed)",
+                    "Circuit %d has no operating mode data (not supported)",
                     circuit,
                 )
+                continue
+
+            available.append(circuit)
         return sorted(available)
 
+    async def _get_available_pps_circuits(self) -> list[int]:
+        """Detect the single PPS room-unit climate circuit."""
+        param_id = "15000"
+        try:
+            response = await self._request(params={"Parameter": param_id})
+        except BSBLANError:
+            logger.debug("PPS climate circuit not available")
+            return []
+
+        if not response.get(param_id):
+            logger.debug("PPS climate circuit has no operating mode data")
+            return []
+        return [1]
+
     async def _setup_api_validator(self) -> None:
         """Set up the API validator without validating sections.
 
@@ -234,9 +228,21 @@ class BSBLAN:
         if self._api_data is None:
             self._api_data = self._copy_api_config()
 
+        self._apply_bus_specific_api_config()
+
         # Initialize the API validator (but don't validate sections yet)
         self._api_validator = APIValidator(self._api_data)
 
+    def _apply_bus_specific_api_config(self) -> None:
+        """Apply bus-specific parameter maps to the current API config."""
+        if self._api_data is None or not self._uses_pps_bus:
+            return
+
+        self._api_data["heating"] = PPS_HEATING_PARAMS.copy()
+        self._api_data["staticValues"] = PPS_STATIC_VALUES_PARAMS.copy()
+        self._api_data["heating_circuit2"] = {}
+        self._api_data["staticValues_circuit2"] = {}
+
     async def _ensure_section_validated(
         self, section: SectionLiteral, include: list[str] | None = None
     ) -> None:
@@ -273,11 +279,26 @@ class BSBLAN:
             logger.debug("Lazy loading section: %s", section)
             response_data = await self._validate_api_section(section, include)
 
-            # Extract temperature unit from heating section validation
-            # (parameter 710 - target_temperature is always in heating section)
-            if section == "heating" and response_data:
+            if response_data and self._should_extract_temperature_unit(
+                section, include, response_data
+            ):
                 self._extract_temperature_unit_from_response(response_data)
 
+    def _should_extract_temperature_unit(
+        self,
+        section: SectionLiteral,
+        include: list[str] | None,
+        response_data: dict[str, Any],
+    ) -> bool:
+        """Return whether the validation response should update temperature unit."""
+        if section != "heating":
+            return False
+
+        if include is None or "target_temperature" in include:
+            return True
+
+        return any(param_id in response_data for param_id in ("710", "15004"))
+
     async def _ensure_hot_water_group_validated(
         self,
         group_name: str,
@@ -470,17 +491,16 @@ class BSBLAN:
     ) -> None:
         """Extract temperature unit from heating section response data.
 
-        Gets the unit from parameter 710 (target_temperature) which is always
+        Gets the unit from the target_temperature parameter, which is always
         present in the heating section.
 
         Args:
             response_data: The response data from heating section validation
 
         """
-        # Look for parameter 710 (target_temperature) in the response
+        # Look for target_temperature in the response.
         for param_id, param_data in response_data.items():
-            # Check if this is parameter 710 and has unit information
-            if param_id == "710" and isinstance(param_data, dict):
+            if param_id in {"710", "15004"} and isinstance(param_data, dict):
                 unit = param_data.get("unit", "")
                 if unit in ("°C", "°C"):
                     self._temperature_unit = "°C"
@@ -489,16 +509,15 @@ class BSBLAN:
                 else:
                     # Keep default if unit is empty or unknown
                     logger.debug(
-                        "Unknown or empty temperature unit from parameter 710: '%s'. "
-                        "Using default (°C)",
+                        "Unknown or empty temperature unit from heating target: "
+                        "'%s'. Using default (°C)",
                         unit,
                     )
                 logger.debug("Temperature unit set to: %s", self._temperature_unit)
                 return
 
-        # If we didn't find parameter 710, log a warning
         logger.warning(
-            "Could not find parameter 710 in heating section response. "
+            "Could not find target temperature in heating section response. "
             "Using default temperature unit (°C)"
         )
 
@@ -520,6 +539,31 @@ class BSBLAN:
             logger.debug("BSBLAN version: %s", self._firmware_version)
             self._set_api_version()
 
+    @property
+    def device_info(self) -> Device | None:
+        """Return cached device metadata from the last /JI response."""
+        return self._device
+
+    @property
+    def supports_time_sync(self) -> bool:
+        """Return cached support for the normal BSB/LPB time sync command."""
+        return self._device is not None and self._device.supports_time_sync
+
+    @property
+    def _uses_pps_bus(self) -> bool:
+        """Return whether cached metadata identifies the device as PPS."""
+        return self._device is not None and self._device.is_pps_bus
+
+    @property
+    def _is_bus_writable(self) -> bool:
+        """Return whether cached metadata says writes are allowed."""
+        return self._device is None or self._device.is_bus_writable
+
+    async def _ensure_device_metadata(self) -> None:
+        """Fetch device metadata if it has not been loaded yet."""
+        if self._device is None:
+            await self.device()
+
     def _set_api_version(self) -> None:
         """Set the API version based on the firmware version.
 
@@ -598,8 +642,8 @@ class BSBLAN:
         Args:
             circuit: The heating circuit number (1 or 2).
 
-        Note: Temperature unit is extracted during heating section validation
-        from the response (parameter 710), so no extra API call is needed here.
+        Note: Temperature unit is extracted during heating section validation,
+        so no extra API call is needed here.
 
         """
         if circuit in self._circuit_temp_initialized:
@@ -619,10 +663,20 @@ class BSBLAN:
             BSBLANInvalidParameterError: If the circuit number is invalid.
 
         """
-        if circuit not in CircuitConfig.VALID:
+        if circuit not in CircuitConfig.VALID or (self._uses_pps_bus and circuit != 1):
             msg = ErrorMsg.INVALID_CIRCUIT.format(circuit)
             raise BSBLANInvalidParameterError(msg)
 
+    def _validate_bus_write_supported(self) -> None:
+        """Validate that cached metadata permits writes."""
+        if not self._is_bus_writable:
+            raise BSBLANError(ErrorMsg.BUS_WRITE_NOT_SUPPORTED)
+
+    def _validate_time_sync_supported(self) -> None:
+        """Validate that normal parameter 0 time sync is safe."""
+        if not self.supports_time_sync:
+            raise BSBLANError(ErrorMsg.TIME_SYNC_NOT_SUPPORTED)
+
     @property
     def get_temperature_unit(self) -> str:
         """Get the unit of temperature.
@@ -904,8 +958,26 @@ class BSBLAN:
         params = self._extract_params_summary(section_params)
         data = await self._request(params={"Parameter": params["string_par"]})
         data = dict(zip(params["list"], list(data.values()), strict=True))
+        if section == "heating" and self._uses_pps_bus:
+            self._normalize_pps_state_data(data)
         return model_class.model_validate(data)
 
+    def _normalize_pps_state_data(self, data: dict[str, Any]) -> None:
+        """Normalize PPS climate values to the library's State model."""
+        hvac_mode = data.get("hvac_mode")
+        if not isinstance(hvac_mode, dict):
+            return
+
+        try:
+            raw_mode = int(hvac_mode["value"])
+        except (KeyError, TypeError, ValueError):
+            return
+
+        hvac_mode["value"] = Validation.PPS_HVAC_MODE_FROM_BSBLAN.get(
+            raw_mode,
+            raw_mode,
+        )
+
     async def state(
         self,
         include: list[str] | None = None,
@@ -927,8 +999,9 @@ class BSBLAN:
             State: The current state of the BSBLAN device.
 
         Note:
-            The hvac_mode.value is returned as a raw integer from the device:
-            0=off, 1=auto, 2=eco, 3=heat.
+            For BSB/LPB devices, hvac_mode.value is returned as a raw integer:
+            0=off, 1=auto, 2=eco, 3=heat. PPS devices normalize their raw
+            operating modes to the same library values, but do not support eco.
 
         Example:
             # Fetch only hvac_mode and current_temperature
@@ -1000,7 +1073,8 @@ class BSBLAN:
 
         """
         device_info = await self._request(base_path="/JI")
-        return Device.model_validate(device_info)
+        self._device = Device.model_validate(device_info)
+        return self._device
 
     async def info(self, include: list[str] | None = None) -> Info:
         """Get information about the current heating system config.
@@ -1027,6 +1101,9 @@ class BSBLAN:
             DeviceTime: The current time information from the BSB-LAN device.
 
         """
+        await self._ensure_device_metadata()
+        self._validate_time_sync_supported()
+
         # Get only parameter 0 for time
         data = await self._request(params={"Parameter": "0"})
         # Create the data dictionary in the expected format
@@ -1044,6 +1121,8 @@ class BSBLAN:
             BSBLANInvalidParameterError: If the time format is invalid.
 
         """
+        await self._ensure_device_metadata()
+        self._validate_time_sync_supported()
         self._validate_time_format(time_value)
         state: dict[str, object] = {
             "Parameter": "0",
@@ -1064,7 +1143,9 @@ class BSBLAN:
         Args:
             target_temperature (str | None): The target temperature to set.
             hvac_mode (int | None): The HVAC mode to set as raw integer value.
-                Valid values: 0=off, 1=auto, 2=eco, 3=heat.
+                For BSB/LPB, valid values are 0=off, 1=auto, 2=eco, 3=heat.
+                For PPS, valid values are 0=off, 1=auto, and 3=heat/manual;
+                they are translated to PPS raw values before posting.
             circuit: The heating circuit number (1 or 2). Defaults to 1.
 
         Example:
@@ -1076,6 +1157,8 @@ class BSBLAN:
 
         """
         self._validate_circuit(circuit)
+        if self._uses_pps_bus:
+            self._validate_bus_write_supported()
         await self._initialize_temperature_range(circuit)
 
         self._validate_single_parameter(
@@ -1108,7 +1191,7 @@ class BSBLAN:
             dict[str, Any]: The prepared state for the thermostat.
 
         """
-        param_ids = CircuitConfig.THERMOSTAT_PARAMS[circuit]
+        param_ids = self._thermostat_params(circuit)
         state: dict[str, Any] = {}
         if target_temperature is not None:
             await self._validate_target_temperature(
@@ -1124,15 +1207,24 @@ class BSBLAN:
             )
         if hvac_mode is not None:
             self._validate_hvac_mode(hvac_mode)
+            hvac_value = str(hvac_mode)
+            if self._uses_pps_bus:
+                hvac_value = Validation.PPS_HVAC_MODE_TO_BSBLAN[hvac_mode]
             state.update(
                 {
                     "Parameter": param_ids["hvac_mode"],
-                    "Value": str(hvac_mode),
+                    "Value": hvac_value,
                     "Type": "1",
                 },
             )
         return state
 
+    def _thermostat_params(self, circuit: int) -> dict[str, str]:
+        """Return thermostat write parameters for the active bus type."""
+        if self._uses_pps_bus:
+            return {"target_temperature": "15004", "hvac_mode": "15000"}
+        return CircuitConfig.THERMOSTAT_PARAMS[circuit]
+
     async def _validate_target_temperature(
         self,
         target_temperature: str,
@@ -1177,13 +1269,17 @@ class BSBLAN:
         """Validate the HVAC mode.
 
         Args:
-            hvac_mode (int): The HVAC mode to validate (0-3).
+            hvac_mode (int): The HVAC mode to validate. BSB/LPB accepts 0-3;
+                PPS accepts 0, 1, and 3.
 
         Raises:
             BSBLANInvalidParameterError: If the HVAC mode is invalid.
 
         """
-        if hvac_mode not in Validation.HVAC_MODES:
+        valid_modes = (
+            Validation.PPS_HVAC_MODES if self._uses_pps_bus else Validation.HVAC_MODES
+        )
+        if hvac_mode not in valid_modes:
             raise BSBLANInvalidParameterError(str(hvac_mode))
 
     def _validate_time_format(self, time_value: str) -> None:

bsblan/constants.py

@@ -114,6 +114,19 @@ BASE_STATIC_VALUES_CIRCUIT2_PARAMS: Final[dict[str, str]] = {
     "1014": "min_temp",
 }
 
+# PPS bus supports one room-unit style climate circuit. These parameters are
+# exposed by BSB-LAN in the 15000+ range and mirror the circuit 1 climate model.
+PPS_HEATING_PARAMS: Final[dict[str, str]] = {
+    "15000": "hvac_mode",
+    "15004": "target_temperature",
+    "15008": "current_temperature",
+}
+
+PPS_STATIC_VALUES_PARAMS: Final[dict[str, str]] = {
+    "15006": "min_temp",
+    "15007": "max_temp",
+}
+
 V1_STATIC_VALUES_CIRCUIT2_EXTENSIONS: Final[dict[str, str]] = {
     "1030": "max_temp",
 }
@@ -207,6 +220,17 @@ class Validation:
     """Validation-related constants for BSBLAN."""
 
     HVAC_MODES: Final[set[int]] = {0, 1, 2, 3}
+    PPS_HVAC_MODES: Final[set[int]] = {0, 1, 3}
+    PPS_HVAC_MODE_TO_BSBLAN: Final[dict[int, str]] = {
+        0: "2",  # off
+        1: "0",  # auto
+        3: "1",  # manual/comfort
+    }
+    PPS_HVAC_MODE_FROM_BSBLAN: Final[dict[int, int]] = {
+        0: 1,  # auto
+        1: 3,  # manual/comfort
+        2: 0,  # off
+    }
     MIN_YEAR: Final[int] = 1900
     MAX_YEAR: Final[int] = 2100
 
@@ -492,6 +516,8 @@ class ErrorMsg:
         "Empty include list provided. Use None to fetch all parameters."
     )
     NO_HEATING_SCHEDULE_PARAMS = "No heating schedule parameters available"
+    TIME_SYNC_NOT_SUPPORTED = "Time synchronization is not supported by this device"
+    BUS_WRITE_NOT_SUPPORTED = "Writing parameters is not supported by this device"
 
 
 # Handle both ASCII and Unicode degree symbols

bsblan/models.py

@@ -326,13 +326,13 @@ class EntityInfo(BaseModel, Generic[T]):
     unit: str
     desc: str
     value: T | None = None
-    data_type: int = Field(alias="dataType", default=0)
+    data_type: int = Field(validation_alias="dataType", default=0)
     error: int = 0
     readonly: int = 0
     readwrite: int = 0
     precision: float | None = None
-    data_type_name: str = Field(default="", alias="dataType_name")
-    data_type_family: str = Field(default="", alias="dataType_family")
+    data_type_name: str = Field(default="", validation_alias="dataType_name")
+    data_type_family: str = Field(default="", validation_alias="dataType_family")
 
     @model_validator(mode="before")
     @classmethod
@@ -611,6 +611,26 @@ class Device(BaseModel):
     version: str
     MAC: str  # pylint: disable=invalid-name
     uptime: int
+    bus: str | None = None
+    buswritable: int | bool | None = None
+    busaddr: int | None = None
+    busdest: int | None = None
+    busdevices: list[Any] | None = None
+
+    @property
+    def is_pps_bus(self) -> bool:
+        """Return whether the device is connected to a PPS bus."""
+        return self.bus is not None and self.bus.upper() == "PPS"
+
+    @property
+    def is_bus_writable(self) -> bool:
+        """Return whether BSB-LAN reports global bus writes as enabled."""
+        return self.buswritable is None or bool(self.buswritable)
+
+    @property
+    def supports_time_sync(self) -> bool:
+        """Return whether normal BSB/LPB time synchronization is supported."""
+        return not self.is_pps_bus
 
 
 class Info(BaseModel):

{python_bsblan-5.2.0.dist-info → python_bsblan-6.0.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-bsblan
-Version: 5.2.0
+Version: 6.0.0
 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.0.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+bsblan/__init__.py,sha256=YD_edvxHL5ocUE2iLWhdinqpsRYWJkVrcds0b6aKp9U,1288
+bsblan/bsblan.py,sha256=-Xwju6B5RcRUDYoMcU--WSn5Gvrjv3j6itDnYCtVZhU,66563
+bsblan/constants.py,sha256=Ln0a-4cgKnr6pjtBaPnpdir2vWQTIZunSbHb552adLE,23769
+bsblan/exceptions.py,sha256=jL7qohIMmuVTsdWBB_trKPg5Yzim6JxaOT13h6EJPlk,1770
+bsblan/models.py,sha256=O8VGJGf0Kpqwo4r0SH4xRBmjC759hlnu8wMR9MM_I8E,21457
+bsblan/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+bsblan/utility.py,sha256=sS0wWJoqvLAHzwaSLIqQEQ-boHsYFLKAHw8KNTSmdX8,5772
+python_bsblan-6.0.0.dist-info/METADATA,sha256=yCAHEUdVrPSjdvpodvhdR3NZUVJz47eGzkMefg3zkBg,8529
+python_bsblan-6.0.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+python_bsblan-6.0.0.dist-info/licenses/LICENSE.md,sha256=Shv8HPcD1WbZjBPvfb5r3h_cwaPeVaUZMUqU_XQGwGw,1092
+python_bsblan-6.0.0.dist-info/RECORD,,

python_bsblan-5.2.0.dist-info/RECORD

@@ -1,11 +0,0 @@
-bsblan/__init__.py,sha256=YD_edvxHL5ocUE2iLWhdinqpsRYWJkVrcds0b6aKp9U,1288
-bsblan/bsblan.py,sha256=PCNForRgeJFHwZRE_mEcvySQxiYLA2JCIzMJu429Fq4,63034
-bsblan/constants.py,sha256=LoMSrEdZj2zohDFxOQ2JT7J4jIH9clXh7sfkNnnjl5A,22864
-bsblan/exceptions.py,sha256=jL7qohIMmuVTsdWBB_trKPg5Yzim6JxaOT13h6EJPlk,1770
-bsblan/models.py,sha256=qEycc2eVkCK2CXWDXBSqtTyM-to6pH7jX6aKvXeH3R8,20705
-bsblan/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-bsblan/utility.py,sha256=sS0wWJoqvLAHzwaSLIqQEQ-boHsYFLKAHw8KNTSmdX8,5772
-python_bsblan-5.2.0.dist-info/METADATA,sha256=MjhQBz4cjiRwunT2OH4X-gRFsprNSIpLBMNu7kam24Y,8529
-python_bsblan-5.2.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
-python_bsblan-5.2.0.dist-info/licenses/LICENSE.md,sha256=Shv8HPcD1WbZjBPvfb5r3h_cwaPeVaUZMUqU_XQGwGw,1092
-python_bsblan-5.2.0.dist-info/RECORD,,