python-bsblan 5.2.1__tar.gz → 6.0.1__tar.gz

{python_bsblan-5.2.1 → python_bsblan-6.0.1}/.github/workflows/codeql.yaml

@@ -27,6 +27,6 @@ jobs:
         with:
           persist-credentials: false
       - name: 🏗 Initialize CodeQL
-        uses: github/codeql-action/init@e46ed2cbd01164d986452f91f178727624ae40d7 # v4.35.3
+        uses: github/codeql-action/init@9e0d7b8d25671d64c341c19c0152d693099fb5ba # v4.35.5
       - name: 🚀 Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@e46ed2cbd01164d986452f91f178727624ae40d7 # v4.35.3
+        uses: github/codeql-action/analyze@9e0d7b8d25671d64c341c19c0152d693099fb5ba # v4.35.5

{python_bsblan-5.2.1 → python_bsblan-6.0.1}/.github/workflows/dependency-review.yaml

@@ -18,4 +18,4 @@ jobs:
           persist-credentials: false
       - name: 👀 Dependency review
         # yamllint disable-line rule:line-length
-        uses: actions/dependency-review-action@2031cfc080254a8a887f58cffee85186f0e49e48 # v4.9.0
+        uses: actions/dependency-review-action@a1d282b36b6f3519aa1f3fc636f609c47dddb294 # v5.0.0

{python_bsblan-5.2.1 → python_bsblan-6.0.1}/.github/workflows/release-drafter.yaml

@@ -36,7 +36,7 @@ jobs:
     steps:
       - name: 🚀 Run Release Drafter
         # yamllint disable-line rule:line-length
-        uses: release-drafter/release-drafter@563bf132657a13ded0b01fcb723c5a58cdd824e2 # v7.2.1
+        uses: release-drafter/release-drafter@c2e2804cc59f45f57076a99af580d0fedb697927 # v7.3.0
         with:
           prerelease: ${{ github.event.inputs.prerelease == 'true' }}
           prerelease-identifier: ${{ github.event.inputs.prerelease_identifier }}

{python_bsblan-5.2.1 → python_bsblan-6.0.1}/.github/workflows/scorecard.yml

@@ -66,6 +66,6 @@ jobs:
       # Upload the results to GitHub's code scanning dashboard (optional).
       - name: "Upload to code-scanning"
         # yamllint disable-line rule:line-length
-        uses: github/codeql-action/upload-sarif@e46ed2cbd01164d986452f91f178727624ae40d7 # v4.35.3
+        uses: github/codeql-action/upload-sarif@9e0d7b8d25671d64c341c19c0152d693099fb5ba # v4.35.5
         with:
           sarif_file: results.sarif

{python_bsblan-5.2.1 → python_bsblan-6.0.1}/.github/workflows/tests.yaml

@@ -84,7 +84,7 @@ jobs:
           uv run python -m coverage xml -i
       - name: 🚀 Upload coverage report
         if: env.HAS_CODECOV_TOKEN == 'true'
-        uses: codecov/codecov-action@57e3a136b779b570ffcdbf80b3bdc90e7fab3de2 # v6.0.0
+        uses: codecov/codecov-action@e79a6962e0d4c0c17b229090214935d2e33f8354 # v6.0.1
         with:
           token: ${{ secrets.CODECOV_TOKEN }}
       - name: ℹ️ Skip Codecov upload (missing token)

{python_bsblan-5.2.1 → python_bsblan-6.0.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-bsblan
-Version: 5.2.1
+Version: 6.0.1
 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
@@ -24,9 +24,9 @@ Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=3.12
 Requires-Dist: aiohttp>=3.8.1
-Requires-Dist: backoff>=2.2.1
 Requires-Dist: packaging>=21.3
 Requires-Dist: pydantic>=2.0
+Requires-Dist: python-backoff>=2.3.1
 Requires-Dist: yarl>=1.7.2
 Description-Content-Type: text/markdown
 

{python_bsblan-5.2.1 → python_bsblan-6.0.1}/docs/api/client.md

@@ -10,6 +10,8 @@ The main entry point for interacting with BSB-LAN devices.
       members:
         - __init__
         - initialize
+        - device_info
+        - supports_time_sync
         - get_available_circuits
         - state
         - sensor

{python_bsblan-5.2.1 → python_bsblan-6.0.1}/docs/getting-started.md

@@ -63,6 +63,42 @@ async def main() -> None:
 asyncio.run(main())
 ```
 
+## PPS bus support
+
+PPS bus devices are detected from the device metadata returned by BSB-LAN. The
+client provides minimal climate support for PPS devices through the same climate
+methods used by BSB/LPB devices.
+
+Supported PPS climate operations:
+
+- `state()` for `hvac_mode`, `target_temperature`, and `current_temperature`
+- `static_values()` for `min_temp` and `max_temp`
+- `thermostat()` for target temperature and HVAC mode
+- `get_available_circuits()`, which returns `[1]` when the single PPS
+  climate circuit is available, otherwise `[]`; PPS devices only ever expose
+  circuit `1`
+
+PPS devices currently have these limitations:
+
+- Only circuit `1` is supported.
+- `time()` and `set_time()` are not supported for PPS devices.
+- `thermostat(hvac_mode=2)` is not supported on PPS devices. Valid PPS modes
+    are `0` (off), `1` (auto), and `3` (heat/manual).
+- Hot water and schedule helpers are intended for BSB/LPB devices.
+
+Check `supports_time_sync` before showing or calling time synchronization in
+applications:
+
+```python
+async with BSBLAN(config) as client:
+    device = client.device_info or await client.device()
+    print(f"Bus type: {device.bus or 'unknown'}")
+
+    if client.supports_time_sync:
+        device_time = await client.time()
+        print(device_time.time.value)
+```
+
 ## Hot water control
 
 ```python

{python_bsblan-5.2.1 → python_bsblan-6.0.1}/examples/control.py

@@ -68,6 +68,16 @@ def print_attributes(title: str, attributes: dict[str, str]) -> None:
         print(f"{label}: {value}")
 
 
+def format_yes_no(*, value: bool) -> str:
+    """Format a boolean as a readable yes/no value."""
+    return "yes" if value else "no"
+
+
+def format_optional(value: Any) -> str:
+    """Format optional device metadata for display."""
+    return "N/A" if value is None else str(value)
+
+
 def get_hvac_action_name(status_code: int) -> str:
     """Map BSB-LAN parameter 8000 status code to a human-readable HVAC action.
 
@@ -180,6 +190,11 @@ async def print_device_info(device: Device, info: Info) -> None:
         "Device Name": device.name or "N/A",
         "Version": device.version or "N/A",
         "Device Identification": device_identification,
+        "Bus Type": format_optional(device.bus),
+        "Bus Writable Flag": format_optional(device.buswritable),
+        "Bus Address": format_optional(device.busaddr),
+        "Bus Destination": format_optional(device.busdest),
+        "Supports Time Sync": format_yes_no(value=device.supports_time_sync),
     }
     print_attributes("Device Information", attributes)
 
@@ -319,6 +334,11 @@ async def main() -> None:
 
     # Initialize BSBLAN with the configuration object
     async with BSBLAN(config) as bsblan:
+        # Get and print device and general info, including bus metadata
+        device: Device = bsblan.device_info or await bsblan.device()
+        info: Info = await bsblan.info()
+        await print_device_info(device, info)
+
         # Get and print state
         state: State = await bsblan.state()
         await print_state(state)
@@ -335,14 +355,12 @@ async def main() -> None:
         sensor: Sensor = await bsblan.sensor()
         await print_sensor(sensor)
 
-        # Get and print device and general info
-        device: Device = await bsblan.device()
-        info: Info = await bsblan.info()
-        await print_device_info(device, info)
-
         # Get and print device time
-        device_time: DeviceTime = await bsblan.time()
-        await print_device_time(device_time)
+        if bsblan.supports_time_sync:
+            device_time: DeviceTime = await bsblan.time()
+            await print_device_time(device_time)
+        else:
+            print("\nDevice time is not available for this bus type")
 
         # Get and print static state
         static_state: StaticState = await bsblan.static_values()
@@ -375,13 +393,15 @@ async def main() -> None:
         await bsblan.set_hot_water(SetHotWaterParam(dhw_time_programs=dhw_programs))
 
         # Example: Set device time
-        print("\nSetting device time to current system time")
-        # Get current local system time and format it for BSB-LAN (DD.MM.YYYY HH:MM:SS)
-        # Note: Using local time intentionally for this demo to sync BSB-LAN
-        current_time = datetime.now().replace(microsecond=0)  # noqa: DTZ005 - Demo uses local time
-        formatted_time = current_time.strftime("%d.%m.%Y %H:%M:%S")
-        print(f"Current system time: {formatted_time}")
-        await bsblan.set_time(formatted_time)
+        if bsblan.supports_time_sync:
+            print("\nSetting device time to current system time")
+            # Get current local system time and format it for BSB-LAN.
+            current_time = datetime.now().replace(microsecond=0)  # noqa: DTZ005
+            formatted_time = current_time.strftime("%d.%m.%Y %H:%M:%S")
+            print(f"Current system time: {formatted_time}")
+            await bsblan.set_time(formatted_time)
+        else:
+            print("\nSkipping device time sync for this bus type")
 
 
 if __name__ == "__main__":

{python_bsblan-5.2.1 → python_bsblan-6.0.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "python-bsblan"
-version = "5.2.1"
+version = "6.0.1"
 description = "Asynchronous Python client for BSBLAN API"
 authors = [
     {name = "Willem-Jan van Rootselaar", email = "liudgervr@gmail.com"}
@@ -28,7 +28,7 @@ dependencies = [
     "aiohttp>=3.8.1",
     "yarl>=1.7.2",
     "packaging>=21.3",
-    "backoff>=2.2.1",
+    "python-backoff>=2.3.1",
     "pydantic>=2.0",
 ]
 
@@ -185,18 +185,18 @@ build-backend = "hatchling.build"
 dev = [
     "aresponses==3.0.0",
     "bandit==1.9.4",
-    "black==26.3.1",
+    "black==26.5.1",
     "blacken-docs==1.20.0",
     "codespell==2.4.2",
     "covdefaults==2.3.0",
-    "coverage==7.13.5",
+    "coverage==7.14.0",
     "darglint==1.8.1",
     "flake8==7.3.0",
     "flake8-simplify==0.30.0",
     # hatch is required to support type hinting and proper packaging of the py.typed file.
     "hatch>=1.14.1",
     "isort==8.0.1",
-    "ty==0.0.34",
+    "ty==0.0.38",
     "prek>=0.3.3",
     "pre-commit-hooks==6.0.0",
     "pylint==4.0.5",
@@ -205,7 +205,7 @@ dev = [
     "pytest-cov==7.1.0",
     "pytest-xdist>=3.8.0",
     "pyupgrade==3.21.2",
-    "ruff==0.15.12",
+    "ruff==0.15.13",
     "safety==3.7.0",
     "vulture==2.16",
     "yamllint==1.38.0",

{python_bsblan-5.2.1 → python_bsblan-6.0.1}/src/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"
@@ -170,6 +173,9 @@ 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:
@@ -195,6 +201,20 @@ class BSBLAN:
             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.
 
@@ -208,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:
@@ -247,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,
@@ -444,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"
@@ -463,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)"
         )
 
@@ -494,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.
 
@@ -572,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:
@@ -593,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.
@@ -878,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,
@@ -901,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
@@ -974,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.
@@ -1001,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
@@ -1018,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",
@@ -1038,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:
@@ -1050,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(
@@ -1082,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(
@@ -1098,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,
@@ -1151,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:

{python_bsblan-5.2.1 → python_bsblan-6.0.1}/src/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

{python_bsblan-5.2.1 → python_bsblan-6.0.1}/src/bsblan/models.py

@@ -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):