python-bsblan 6.1.11__tar.gz → 6.2.0__tar.gz

{python_bsblan-6.1.11 → python_bsblan-6.2.0}/.github/workflows/codeql.yaml

@@ -27,6 +27,6 @@ jobs:
         with:
           persist-credentials: false
       - name: 🏗 Initialize CodeQL
-        uses: github/codeql-action/init@6f2ac81f5cd81fe351a197ba0b00d91d03cd2aee # v4.39.0
+        uses: github/codeql-action/init@9b3254085494b55a0f7c4c2b3d2d52cc712ce370 # v4.39.1
       - name: 🚀 Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@6f2ac81f5cd81fe351a197ba0b00d91d03cd2aee # v4.39.0
+        uses: github/codeql-action/analyze@9b3254085494b55a0f7c4c2b3d2d52cc712ce370 # v4.39.1

{python_bsblan-6.1.11 → python_bsblan-6.2.0}/.github/workflows/release.yaml

@@ -54,7 +54,7 @@ jobs:
         with:
           subject-path: ./dist/*
       - name: 🚀 Publish to PyPi
-        uses: pypa/gh-action-pypi-publish@dc37677b2e1c63e2034f94d8a5b11f265b73ba33 # v1.14.2
+        uses: pypa/gh-action-pypi-publish@7245906fb61fa33a13554f9d5fb856fe61758086 # v1.14.3
         with:
           verbose: true
           print-hash: true

{python_bsblan-6.1.11 → python_bsblan-6.2.0}/.github/workflows/scorecard.yml

@@ -40,7 +40,7 @@ jobs:
 
       - name: "Run analysis"
         # yamllint disable-line rule:line-length
-        uses: ossf/scorecard-action@2d1146689b8cda280b9bc96326124645441f03bc # v2.4.4
+        uses: ossf/scorecard-action@fa7117db83c52d787ae5a89f350999701505d78e # v2.5.0
         with:
           results_file: results.sarif
           results_format: sarif
@@ -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@6f2ac81f5cd81fe351a197ba0b00d91d03cd2aee # v4.39.0
+        uses: github/codeql-action/upload-sarif@9b3254085494b55a0f7c4c2b3d2d52cc712ce370 # v4.39.1
         with:
           sarif_file: results.sarif

python_bsblan-6.2.0/.nvmrc

@@ -0,0 +1 @@
+24.22.1

{python_bsblan-6.1.11 → python_bsblan-6.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: python-bsblan
-Version: 6.1.11
+Version: 6.2.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.1.11 → python_bsblan-6.2.0}/examples/control.py

@@ -409,11 +409,9 @@ async def main() -> None:
         # Example: Set device 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)
+            current_time = datetime.now()  # noqa: DTZ005
+            print(f"Current system time: {current_time:%d.%m.%Y %H:%M:%S}")
+            await bsblan.set_time(current_time)
         else:
             print("\nSkipping device time sync for this bus type")
 

{python_bsblan-6.1.11 → python_bsblan-6.2.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "python-bsblan"
-version = "6.1.11"
+version = "6.2.0"
 description = "Asynchronous Python client for BSBLAN API"
 authors = [
     {name = "Willem-Jan van Rootselaar", email = "liudgervr@gmail.com"}
@@ -197,7 +197,7 @@ dev = [
     # 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.89",
+    "ty==0.0.90",
     "prek>=0.3.3",
     "pre-commit-hooks==6.0.0",
     "pylint==4.1.3",

{python_bsblan-6.1.11 → python_bsblan-6.2.0}/src/bsblan/bsblan.py

@@ -51,9 +51,10 @@ from .models import (
     State,
     StaticState,
 )
-from .utility import is_param_value_active, validate_time_format
+from .utility import is_param_value_active
 
 if TYPE_CHECKING:
+    from datetime import datetime
     from typing import Self
 
     from aiohttp.client import ClientSession
@@ -862,24 +863,31 @@ class BSBLAN:
         time_data = {"time": data["0"]}
         return DeviceTime.model_validate(time_data)
 
-    async def set_time(self, time_value: str) -> None:
+    async def set_time(self, value: datetime) -> None:
         """Set the time on the BSB-LAN device.
 
         Args:
-            time_value (str): The time value to set in format "DD.MM.YYYY HH:MM:SS"
-                (e.g., "13.08.2025 10:25:55").
+            value (datetime): The local time of the heating system. Its date and
+                time are written as they are, without timezone conversion.
 
         Raises:
-            BSBLANInvalidParameterError: If the time format is invalid.
+            BSBLANInvalidParameterError: If the year is out of range.
+            BSBLANError: If the device does not accept the new time.
 
         """
         await self._ensure_device_metadata()
         self._validate_time_sync_supported()
-        self._validate_time_format(time_value)
+        if not Validation.MIN_YEAR <= value.year <= Validation.MAX_YEAR:
+            msg = f"Invalid year: {value.year}"
+            raise BSBLANInvalidParameterError(msg)
+        # BSB-LAN 4.1 rejects a space between the date and the time
         response = await self._request(
-            base_path="/JS", data=self._set_payload("0", time_value)
+            base_path="/JS",
+            data=self._set_payload("0", value.strftime("%d.%m.%Y_%H:%M:%S")),
         )
         logger.debug("Response for setting time: %s", response)
+        if response.get("0", {}).get("status") != 1:
+            raise BSBLANError(ErrorMsg.TIME_SYNC_FAILED)
 
     async def thermostat(  # noqa: PLR0913  # pylint: disable=too-many-arguments
         self,
@@ -992,21 +1000,6 @@ class BSBLAN:
             circuit,
         )
 
-    def _validate_time_format(self, time_value: str) -> None:
-        """Validate the time format.
-
-        Args:
-            time_value (str): The time value to validate.
-
-        Raises:
-            BSBLANInvalidParameterError: If the time format is invalid.
-
-        """
-        try:
-            validate_time_format(time_value, Validation.MIN_YEAR, Validation.MAX_YEAR)
-        except ValueError as err:
-            raise BSBLANInvalidParameterError(str(err)) from err
-
     def _set_payload(
         self, parameter: str, value: str, type_: str = "1"
     ) -> dict[str, Any]:

{python_bsblan-6.1.11 → python_bsblan-6.2.0}/src/bsblan/constants.py

@@ -561,6 +561,7 @@ class ErrorMsg:
     )
     NO_HEATING_SCHEDULE_PARAMS = "No heating schedule parameters available"
     TIME_SYNC_NOT_SUPPORTED = "Time synchronization is not supported by this device"
+    TIME_SYNC_FAILED = "The device did not accept the new time"
     BUS_WRITE_NOT_SUPPORTED = "Writing parameters is not supported by this device"
 
 

{python_bsblan-6.1.11 → python_bsblan-6.2.0}/src/bsblan/utility.py

@@ -3,7 +3,6 @@
 from __future__ import annotations
 
 import logging
-import re
 from dataclasses import dataclass, field
 from typing import Any
 
@@ -12,65 +11,6 @@ from .constants import CircuitConfig
 logger = logging.getLogger(__name__)
 
 
-def validate_time_format(
-    time_value: str,
-    min_year: int,
-    max_year: int,
-) -> None:
-    """Validate the BSB-LAN time format.
-
-    Args:
-        time_value: The time value to validate in format DD.MM.YYYY HH:MM:SS.
-        min_year: Minimum valid year.
-        max_year: Maximum valid year.
-
-    Raises:
-        ValueError: If the time format is invalid.
-
-    """
-    # BSB-LAN supports format: DD.MM.YYYY HH:MM:SS (e.g., "13.08.2025 10:25:55")
-    pattern = r"^(\d{2})\.(\d{2})\.(\d{4}) (\d{2}):(\d{2}):(\d{2})$"
-
-    match = re.match(pattern, time_value)
-    if not match:
-        msg = f"Invalid time format: {time_value}. Expected DD.MM.YYYY HH:MM:SS"
-        raise ValueError(msg)
-
-    day, month, year, hour, minute, second = map(int, match.groups())
-
-    # Validate ranges
-    if not (1 <= day <= 31):
-        msg = f"Invalid day: {day}"
-        raise ValueError(msg)
-    if not (1 <= month <= 12):
-        msg = f"Invalid month: {month}"
-        raise ValueError(msg)
-    if not (min_year <= year <= max_year):
-        msg = f"Invalid year: {year}"
-        raise ValueError(msg)
-    if not (0 <= hour <= 23):
-        msg = f"Invalid hour: {hour}"
-        raise ValueError(msg)
-    if not (0 <= minute <= 59):
-        msg = f"Invalid minute: {minute}"
-        raise ValueError(msg)
-    if not (0 <= second <= 59):
-        msg = f"Invalid second: {second}"
-        raise ValueError(msg)
-
-    # Additional validation for days per month
-    if month in (4, 6, 9, 11) and day > 30:
-        msg = f"Invalid day {day} for month {month}"
-        raise ValueError(msg)
-    if month == 2:
-        # Leap year check
-        is_leap = (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0)
-        max_day = 29 if is_leap else 28
-        if day > max_day:
-            msg = f"Invalid day {day} for February in year {year}"
-            raise ValueError(msg)
-
-
 def is_param_value_active(param: dict[str, Any] | None) -> bool:
     """Check whether a parameter payload carries an active value.
 

{python_bsblan-6.1.11 → python_bsblan-6.2.0}/tests/test_pps.py

@@ -5,6 +5,7 @@
 from __future__ import annotations
 
 import json
+from datetime import UTC, datetime
 from typing import TYPE_CHECKING, Any
 from unittest.mock import AsyncMock
 
@@ -126,7 +127,7 @@ async def test_pps_set_time_raises_without_posting(pps_bsblan: BSBLAN) -> None:
     pps_bsblan._request = request_mock  # type: ignore[method-assign]
 
     with pytest.raises(BSBLANError, match=ErrorMsg.TIME_SYNC_NOT_SUPPORTED):
-        await pps_bsblan.set_time("01.01.2024 12:30:45")
+        await pps_bsblan.set_time(datetime(2024, 1, 1, 12, 30, 45, tzinfo=UTC))
 
     request_mock.assert_not_awaited()
 
@@ -178,7 +179,7 @@ async def test_set_time_fetches_device_metadata_before_sync() -> None:
         bsblan._request = request_mock  # type: ignore[method-assign]
 
         with pytest.raises(BSBLANError, match=ErrorMsg.TIME_SYNC_NOT_SUPPORTED):
-            await bsblan.set_time("01.01.2024 12:30:45")
+            await bsblan.set_time(datetime(2024, 1, 1, 12, 30, 45, tzinfo=UTC))
 
     request_mock.assert_awaited_once_with(base_path="/JI")
 

python_bsblan-6.2.0/tests/test_time.py

@@ -0,0 +1,112 @@
+"""Tests for device time functionality."""
+
+# pylint: disable=duplicate-code
+# pylint: disable=protected-access
+# file deepcode ignore W0212: this is a testfile
+
+import json
+from datetime import UTC, datetime, timedelta, timezone
+from unittest.mock import AsyncMock
+
+import pytest
+
+from bsblan import BSBLAN
+from bsblan.constants import ErrorMsg
+from bsblan.exceptions import BSBLANError, BSBLANInvalidParameterError
+from bsblan.models import Device, DeviceTime, EntityInfo
+from tests import load_fixture
+
+
+def set_bsb_device_metadata(bsblan: BSBLAN) -> None:
+    """Seed cached BSB device metadata for time tests."""
+    bsblan._device = Device.model_validate(json.loads(load_fixture("device.json")))
+
+
+def set_time_status(bsblan: BSBLAN, status: int) -> None:
+    """Make BSB-LAN answer a time write with the given status."""
+    assert isinstance(bsblan._request, AsyncMock)
+    bsblan._request.return_value = {"0": {"status": status}}
+
+
+@pytest.mark.asyncio
+async def test_get_time(mock_bsblan: BSBLAN) -> None:
+    """Test getting device time.
+
+    Args:
+        mock_bsblan (BSBLAN): The mock BSBLAN instance.
+
+    """
+    # Load the time response from fixture
+    time_response = json.loads(load_fixture("time.json"))
+
+    assert isinstance(mock_bsblan._request, AsyncMock)
+    mock_bsblan._request.return_value = time_response
+    set_bsb_device_metadata(mock_bsblan)
+
+    # Test getting device time
+    device_time = await mock_bsblan.time()
+
+    # Verify the request was made correctly
+    mock_bsblan._request.assert_awaited_with(params={"Parameter": "0"})
+
+    # Verify the response structure
+    assert isinstance(device_time, DeviceTime)
+    assert isinstance(device_time.time, EntityInfo)
+    assert device_time.time.name == "Current date / Current time of day"
+    assert device_time.time.value == "13.08.2025 11:51:37"
+    assert device_time.time.desc == ""
+    assert device_time.time.data_type == 5
+
+
+@pytest.mark.asyncio
+async def test_set_time(mock_bsblan: BSBLAN) -> None:
+    """Test setting device time."""
+    set_bsb_device_metadata(mock_bsblan)
+    set_time_status(mock_bsblan, 1)
+
+    await mock_bsblan.set_time(datetime(2024, 1, 1, 12, 30, 45, tzinfo=UTC))
+
+    assert isinstance(mock_bsblan._request, AsyncMock)
+    mock_bsblan._request.assert_awaited_with(
+        base_path="/JS",
+        data={"Parameter": "0", "Value": "01.01.2024_12:30:45", "Type": "1"},
+    )
+
+
+@pytest.mark.asyncio
+async def test_set_time_without_timezone_conversion(mock_bsblan: BSBLAN) -> None:
+    """Test the date and time are written as they are in the given timezone."""
+    set_bsb_device_metadata(mock_bsblan)
+    set_time_status(mock_bsblan, 1)
+    utc_plus_two = timezone(timedelta(hours=2))
+
+    await mock_bsblan.set_time(datetime(2025, 8, 13, 10, 25, 55, tzinfo=utc_plus_two))
+
+    assert isinstance(mock_bsblan._request, AsyncMock)
+    mock_bsblan._request.assert_awaited_with(
+        base_path="/JS",
+        data={"Parameter": "0", "Value": "13.08.2025_10:25:55", "Type": "1"},
+    )
+
+
+@pytest.mark.asyncio
+async def test_set_time_rejected(mock_bsblan: BSBLAN) -> None:
+    """Test setting device time raises when BSB-LAN rejects it."""
+    set_bsb_device_metadata(mock_bsblan)
+    set_time_status(mock_bsblan, 0)
+
+    with pytest.raises(BSBLANError, match=ErrorMsg.TIME_SYNC_FAILED):
+        await mock_bsblan.set_time(datetime(2024, 1, 1, 12, 30, 45, tzinfo=UTC))
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("year", [1899, 2101])
+async def test_set_time_invalid_year(mock_bsblan: BSBLAN, year: int) -> None:
+    """Test setting device time outside the supported years raises."""
+    set_bsb_device_metadata(mock_bsblan)
+
+    with pytest.raises(BSBLANInvalidParameterError, match=f"Invalid year: {year}"):
+        await mock_bsblan.set_time(datetime(year, 1, 1, 12, 30, 45, tzinfo=UTC))
+
+    assert isinstance(mock_bsblan._request, AsyncMock)
+    mock_bsblan._request.assert_not_awaited()

python_bsblan-6.2.0/tests/test_utility.py

@@ -0,0 +1,173 @@
+"""Test cases for utility module."""
+
+# pylint: disable=redefined-outer-name
+# pylint: disable=protected-access
+
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+import pytest
+
+from bsblan.utility import APIValidator, is_param_value_active
+
+
+@pytest.fixture
+def mock_request_data() -> dict[str, Any]:
+    """Fixture for mock request data."""
+    return {
+        "700": {
+            "name": "Operating mode",
+            "error": 0,
+            "value": "3",
+            "desc": "Comfort",
+            "dataType": 1,
+            "readonly": 0,
+            "unit": "",
+        },
+        "710": {
+            "name": "Comfort setpoint",
+            "error": 0,
+            "value": "20.0",
+            "desc": "",
+            "dataType": 0,
+            "readonly": 0,
+            "unit": "°C",
+        },
+    }
+
+
+@pytest.fixture
+def validator() -> APIValidator:
+    """Fixture for APIValidator instance."""
+    api_config = {
+        "heating": {
+            "700": "hvac_mode",
+            "710": "target_temperature",
+            # Add other parameters as needed
+        },
+        "staticValues": {
+            "712": "min_temp",
+            "714": "heating_protective_setpoint",
+            "716": "max_temp",
+            # Add other parameters as needed
+        },
+        "hot_water": {
+            "8830": "dhw_actual_value_top_temperature",
+            "8820": "state_dhw_pump",
+            # Add other parameters as needed
+        },
+    }
+    validated_sections: set[str] = set()
+    return APIValidator(api_config=api_config, validated_sections=validated_sections)
+
+
+def test_is_param_value_active() -> None:
+    """Test the shared active-value predicate."""
+    assert is_param_value_active({"value": "20.0"}) is True
+
+    assert is_param_value_active({"value": None}) is False
+    assert is_param_value_active({"value": "---"}) is False
+    assert is_param_value_active({}) is False
+    assert is_param_value_active(None) is False
+
+
+def test_is_valid_param(validator: APIValidator) -> None:
+    """Test parameter validation logic."""
+    valid_param: dict[str, Any] = {
+        "value": "20.0",
+    }
+    assert validator._is_valid_param(valid_param) is True
+
+    invalid_params: list[dict[str, Any]] = [
+        {"value": None},  # None value
+        {"value": "---"},  # Invalid value
+        {},  # Empty dict
+    ]
+
+    for param in invalid_params:
+        assert validator._is_valid_param(param) is False
+
+
+def test_get_section_params(validator: APIValidator) -> None:
+    """Test getting section parameters."""
+    # Test existing section
+    heating_params = validator.get_section_params("heating")
+    assert isinstance(heating_params, dict)
+    assert "700" in heating_params
+    assert heating_params["700"] == "hvac_mode"
+
+    # Test non-existent section
+    empty_params = validator.get_section_params("non_existent")
+    assert isinstance(empty_params, dict)
+    assert len(empty_params) == 0
+
+
+def test_is_section_validated(validator: APIValidator) -> None:
+    """Test section validation status checking."""
+    assert validator.is_section_validated("heating") is False
+
+    validator.validated_sections.add("heating")
+    assert validator.is_section_validated("heating") is True
+
+
+def test_reset_validation(validator: APIValidator) -> None:
+    """Test validation reset functionality."""
+    # Add some validated sections
+    validator.validated_sections.update({"heating", "sensor"})
+    validator.reset_validation()
+    assert len(validator.validated_sections) == 0
+
+
+def test_api_validator_with_empty_sections() -> None:
+    """Test APIValidator with empty API config sections."""
+    empty_config: dict[str, dict[str, Any]] = {
+        "heating": {},
+        "sensor": {},
+        "device": {},
+        "staticValues": {},
+        "hot_water": {},
+    }
+    validator = APIValidator(empty_config)
+
+    assert validator.get_section_params("heating") == {}
+    assert not validator.is_section_validated("heating")
+
+
+def test_api_validator_error_handling(
+    validator: APIValidator,
+    caplog: pytest.LogCaptureFixture,
+) -> None:
+    """Test error handling in APIValidator."""
+    with caplog.at_level(logging.INFO):
+        # Test with invalid request data
+        validator.validate_section("heating", {})
+        assert "Parameter" in caplog.text
+
+
+def test_api_validator_logging(
+    validator: APIValidator,
+    mock_request_data: dict[str, Any],
+    caplog: pytest.LogCaptureFixture,
+) -> None:
+    """Test logging functionality in APIValidator."""
+    with caplog.at_level(logging.DEBUG):
+        validator.validate_section("heating", mock_request_data)
+
+    # Verify debug logs
+    assert "Validated section 'heating'" in caplog.text
+    assert "removed" in caplog.text
+
+
+def test_api_validator_concurrent_validation(
+    validator: APIValidator,
+    mock_request_data: dict[str, Any],
+) -> None:
+    """Test concurrent validation of multiple sections."""
+    # Simulate concurrent validation attempts
+    validator.validate_section("heating", mock_request_data)
+    validator.validate_section("heating", mock_request_data)
+
+    assert len(validator.validated_sections) == 1
+    assert "heating" in validator.validated_sections

python_bsblan-6.1.11/.nvmrc

@@ -1 +0,0 @@
-24.22.0