python-bsblan 3.1.2__tar.gz → 3.1.3__tar.gz

{python_bsblan-3.1.2 → python_bsblan-3.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-bsblan
-Version: 3.1.2
+Version: 3.1.3
 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-3.1.2 → python_bsblan-3.1.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "python-bsblan"
-version = "3.1.2"
+version = "3.1.3"
 description = "Asynchronous Python client for BSBLAN API"
 authors = [
     {name = "Willem-Jan van Rootselaar", email = "liudgervr@gmail.com"}

{python_bsblan-3.1.2 → python_bsblan-3.1.3}/src/bsblan/__init__.py

@@ -3,8 +3,10 @@
 from .bsblan import BSBLAN, BSBLANConfig
 from .exceptions import BSBLANAuthError, BSBLANConnectionError, BSBLANError
 from .models import (
+    DaySchedule,
     Device,
     DeviceTime,
+    DHWSchedule,
     DHWTimeSwitchPrograms,
     HotWaterConfig,
     HotWaterSchedule,
@@ -14,6 +16,7 @@ from .models import (
     SetHotWaterParam,
     State,
     StaticState,
+    TimeSlot,
 )
 
 __all__ = [
@@ -22,7 +25,9 @@ __all__ = [
     "BSBLANConfig",
     "BSBLANConnectionError",
     "BSBLANError",
+    "DHWSchedule",
     "DHWTimeSwitchPrograms",
+    "DaySchedule",
     "Device",
     "DeviceTime",
     "HotWaterConfig",
@@ -33,4 +38,5 @@ __all__ = [
     "SetHotWaterParam",
     "State",
     "StaticState",
+    "TimeSlot",
 ]

{python_bsblan-3.1.2 → python_bsblan-3.1.3}/src/bsblan/bsblan.py

@@ -29,6 +29,7 @@ from .constants import (
     MAX_VALID_YEAR,
     MIN_VALID_YEAR,
     MULTI_PARAMETER_ERROR_MSG,
+    NO_SCHEDULE_ERROR_MSG,
     NO_STATE_ERROR_MSG,
     SESSION_NOT_INITIALIZED_ERROR_MSG,
     SETTABLE_HOT_WATER_PARAMS,
@@ -45,8 +46,10 @@ from .exceptions import (
     BSBLANVersionError,
 )
 from .models import (
+    DaySchedule,
     Device,
     DeviceTime,
+    DHWSchedule,
     HotWaterConfig,
     HotWaterSchedule,
     HotWaterState,
@@ -930,6 +933,50 @@ class BSBLAN:
         state = self._prepare_hot_water_state(params)
         await self._set_device_state(state)
 
+    async def set_hot_water_schedule(self, schedule: DHWSchedule) -> None:
+        """Set hot water time program schedules.
+
+        This method allows setting weekly DHW schedules using a type-safe
+        interface with TimeSlot and DaySchedule objects.
+
+        Example:
+            schedule = DHWSchedule(
+                monday=DaySchedule(slots=[
+                    TimeSlot(time(6, 0), time(8, 0)),
+                    TimeSlot(time(17, 0), time(21, 0)),
+                ]),
+                tuesday=DaySchedule(slots=[
+                    TimeSlot(time(6, 0), time(8, 0)),
+                ])
+            )
+            await client.set_hot_water_schedule(schedule)
+
+        Args:
+            schedule: DHWSchedule object containing the weekly schedule.
+
+        Raises:
+            BSBLANError: If no schedule is provided.
+
+        """
+        if not schedule.has_any_schedule():
+            raise BSBLANError(NO_SCHEDULE_ERROR_MSG)
+
+        # Invert DHW_TIME_PROGRAM_PARAMS to get day_name -> param_id mapping
+        # Exclude standard_values as it's not a day of the week
+        day_param_map = {
+            v: k for k, v in DHW_TIME_PROGRAM_PARAMS.items() if v != "standard_values"
+        }
+
+        for day_name, param_id in day_param_map.items():
+            day_schedule: DaySchedule | None = getattr(schedule, day_name)
+            if day_schedule is not None:
+                state = {
+                    "Parameter": param_id,
+                    "Value": day_schedule.to_bsblan_format(),
+                    "Type": "1",
+                }
+                await self._set_device_state(state)
+
     def _prepare_hot_water_state(
         self,
         params: SetHotWaterParam,

{python_bsblan-3.1.2 → python_bsblan-3.1.3}/src/bsblan/constants.py

@@ -133,6 +133,7 @@ VALID_HVAC_MODES: Final[set[int]] = {0, 1, 2, 3}
 
 # Error Messages
 NO_STATE_ERROR_MSG: Final[str] = "No state provided."
+NO_SCHEDULE_ERROR_MSG: Final[str] = "No schedule provided."
 VERSION_ERROR_MSG: Final[str] = "Version not supported"
 FIRMWARE_VERSION_ERROR_MSG: Final[str] = "Firmware version not available"
 TEMPERATURE_RANGE_ERROR_MSG: Final[str] = "Temperature range not initialized"

{python_bsblan-3.1.2 → python_bsblan-3.1.3}/src/bsblan/models.py

@@ -7,12 +7,178 @@ from contextlib import suppress
 from dataclasses import dataclass, field
 from datetime import time
 from enum import IntEnum
-from typing import Any
+from typing import Any, Final
 
 from mashumaro.mixins.json import DataClassJSONMixin
 
 from bsblan.constants import TEMPERATURE_UNITS
 
+# Maximum number of time slots per day supported by BSB-LAN
+MAX_TIME_SLOTS_PER_DAY: Final[int] = 3
+
+
+@dataclass
+class TimeSlot:
+    """A single time slot with start and end time.
+
+    Attributes:
+        start: Start time of the slot.
+        end: End time of the slot.
+
+    Example:
+        >>> slot = TimeSlot(time(6, 0), time(8, 0))
+        >>> slot.to_bsblan_format()
+        '06:00-08:00'
+
+    """
+
+    start: time
+    end: time
+
+    def __post_init__(self) -> None:
+        """Validate that start is before end."""
+        if self.start >= self.end:
+            msg = f"Start time {self.start} must be before end time {self.end}"
+            raise ValueError(msg)
+
+    def to_bsblan_format(self) -> str:
+        """Convert to BSB-LAN format 'HH:MM-HH:MM'.
+
+        Returns:
+            str: Time slot in BSB-LAN format.
+
+        """
+        return f"{self.start.strftime('%H:%M')}-{self.end.strftime('%H:%M')}"
+
+    @classmethod
+    def from_bsblan_format(cls, value: str) -> TimeSlot:
+        """Parse from BSB-LAN format 'HH:MM-HH:MM'.
+
+        Args:
+            value: Time slot string in format 'HH:MM-HH:MM'.
+
+        Returns:
+            TimeSlot: Parsed time slot.
+
+        Raises:
+            ValueError: If the format is invalid.
+
+        """
+        try:
+            start_str, end_str = value.split("-")
+            start_h, start_m = map(int, start_str.split(":"))
+            end_h, end_m = map(int, end_str.split(":"))
+            return cls(start=time(start_h, start_m), end=time(end_h, end_m))
+        except (ValueError, AttributeError) as e:
+            msg = f"Invalid time slot format: {value}"
+            raise ValueError(msg) from e
+
+
+@dataclass
+class DaySchedule:
+    """Schedule for a single day with up to 3 time slots (BSB-LAN limit).
+
+    Attributes:
+        slots: List of time slots for the day.
+
+    Example:
+        >>> schedule = DaySchedule(slots=[
+        ...     TimeSlot(time(6, 0), time(8, 0)),
+        ...     TimeSlot(time(17, 0), time(21, 0)),
+        ... ])
+        >>> schedule.to_bsblan_format()
+        '06:00-08:00 17:00-21:00'
+
+    """
+
+    slots: list[TimeSlot] = field(default_factory=list)
+
+    def __post_init__(self) -> None:
+        """Validate max 3 slots per day (BSB-LAN limitation)."""
+        if len(self.slots) > MAX_TIME_SLOTS_PER_DAY:
+            msg = (
+                f"BSB-LAN supports maximum {MAX_TIME_SLOTS_PER_DAY} time slots per day"
+            )
+            raise ValueError(msg)
+
+    def to_bsblan_format(self) -> str:
+        """Convert to BSB-LAN string format like '06:00-08:00 17:00-21:00'.
+
+        Returns:
+            str: Day schedule in BSB-LAN format, or empty string if no slots.
+
+        """
+        if not self.slots:
+            return ""
+        return " ".join(slot.to_bsblan_format() for slot in self.slots)
+
+    @classmethod
+    def from_bsblan_format(cls, value: str) -> DaySchedule:
+        """Parse from BSB-LAN format like '06:00-08:00 17:00-21:00'.
+
+        Args:
+            value: Day schedule string in BSB-LAN format.
+
+        Returns:
+            DaySchedule: Parsed day schedule.
+
+        """
+        if not value or value == "---":
+            return cls(slots=[])
+        slot_strings = value.split()
+        slots = [TimeSlot.from_bsblan_format(s) for s in slot_strings]
+        return cls(slots=slots)
+
+
+@dataclass
+class DHWSchedule:
+    """Weekly hot water schedule for setting time programs.
+
+    Use this dataclass to set DHW time programs via set_hot_water_schedule().
+    Each day can have up to 3 time slots.
+
+    Example:
+        >>> schedule = DHWSchedule(
+        ...     monday=DaySchedule(slots=[
+        ...         TimeSlot(time(6, 0), time(8, 0)),
+        ...         TimeSlot(time(17, 0), time(21, 0)),
+        ...     ]),
+        ...     tuesday=DaySchedule(slots=[
+        ...         TimeSlot(time(6, 0), time(8, 0)),
+        ...     ])
+        ... )
+        >>> await client.set_hot_water_schedule(schedule)
+
+    """
+
+    monday: DaySchedule | None = None
+    tuesday: DaySchedule | None = None
+    wednesday: DaySchedule | None = None
+    thursday: DaySchedule | None = None
+    friday: DaySchedule | None = None
+    saturday: DaySchedule | None = None
+    sunday: DaySchedule | None = None
+
+    def has_any_schedule(self) -> bool:
+        """Check if any day has a schedule set.
+
+        Returns:
+            bool: True if at least one day has a schedule.
+
+        """
+        return any(
+            day is not None
+            for day in [
+                self.monday,
+                self.tuesday,
+                self.wednesday,
+                self.thursday,
+                self.friday,
+                self.saturday,
+                self.sunday,
+            ]
+        )
+
 
 @dataclass
 class DHWTimeSwitchPrograms:

python_bsblan-3.1.3/tests/test_schedule_models.py

@@ -0,0 +1,229 @@
+"""Test cases for schedule models (TimeSlot, DaySchedule, DHWSchedule)."""
+
+from __future__ import annotations
+
+from datetime import time
+
+import pytest
+
+from bsblan.models import DaySchedule, DHWSchedule, TimeSlot
+
+
+class TestTimeSlot:
+    """Test cases for TimeSlot dataclass."""
+
+    def test_valid_time_slot(self) -> None:
+        """Test creating a valid time slot."""
+        slot = TimeSlot(start=time(6, 0), end=time(8, 0))
+        assert slot.start == time(6, 0)
+        assert slot.end == time(8, 0)
+
+    def test_time_slot_to_bsblan_format(self) -> None:
+        """Test converting time slot to BSB-LAN format."""
+        slot = TimeSlot(start=time(6, 0), end=time(8, 0))
+        assert slot.to_bsblan_format() == "06:00-08:00"
+
+    def test_time_slot_to_bsblan_format_with_minutes(self) -> None:
+        """Test converting time slot with non-zero minutes."""
+        slot = TimeSlot(start=time(6, 30), end=time(8, 45))
+        assert slot.to_bsblan_format() == "06:30-08:45"
+
+    def test_time_slot_from_bsblan_format(self) -> None:
+        """Test parsing time slot from BSB-LAN format."""
+        slot = TimeSlot.from_bsblan_format("06:00-08:00")
+        assert slot.start == time(6, 0)
+        assert slot.end == time(8, 0)
+
+    def test_time_slot_from_bsblan_format_with_minutes(self) -> None:
+        """Test parsing time slot with non-zero minutes."""
+        slot = TimeSlot.from_bsblan_format("17:30-21:45")
+        assert slot.start == time(17, 30)
+        assert slot.end == time(21, 45)
+
+    def test_time_slot_invalid_start_after_end(self) -> None:
+        """Test that start time must be before end time."""
+        with pytest.raises(ValueError, match="must be before end time"):
+            TimeSlot(start=time(10, 0), end=time(8, 0))
+
+    def test_time_slot_invalid_start_equals_end(self) -> None:
+        """Test that start time cannot equal end time."""
+        with pytest.raises(ValueError, match="must be before end time"):
+            TimeSlot(start=time(8, 0), end=time(8, 0))
+
+    def test_time_slot_from_invalid_format(self) -> None:
+        """Test parsing invalid format raises ValueError."""
+        with pytest.raises(ValueError, match="Invalid time slot format"):
+            TimeSlot.from_bsblan_format("invalid")
+
+    def test_time_slot_from_invalid_format_missing_dash(self) -> None:
+        """Test parsing format without dash raises ValueError."""
+        with pytest.raises(ValueError, match="Invalid time slot format"):
+            TimeSlot.from_bsblan_format("06:00 08:00")
+
+    def test_time_slot_from_invalid_format_bad_time(self) -> None:
+        """Test parsing format with bad time values raises ValueError."""
+        with pytest.raises(ValueError, match="Invalid time slot format"):
+            TimeSlot.from_bsblan_format("25:00-08:00")
+
+    def test_time_slot_roundtrip(self) -> None:
+        """Test that converting to and from BSB-LAN format preserves values."""
+        original = TimeSlot(start=time(6, 30), end=time(17, 45))
+        bsblan_str = original.to_bsblan_format()
+        parsed = TimeSlot.from_bsblan_format(bsblan_str)
+        assert parsed.start == original.start
+        assert parsed.end == original.end
+
+
+class TestDaySchedule:
+    """Test cases for DaySchedule dataclass."""
+
+    def test_empty_day_schedule(self) -> None:
+        """Test creating an empty day schedule."""
+        schedule = DaySchedule()
+        assert schedule.slots == []
+
+    def test_day_schedule_with_slots(self) -> None:
+        """Test creating a day schedule with time slots."""
+        slots = [
+            TimeSlot(time(6, 0), time(8, 0)),
+            TimeSlot(time(17, 0), time(21, 0)),
+        ]
+        schedule = DaySchedule(slots=slots)
+        assert len(schedule.slots) == 2
+
+    def test_day_schedule_to_bsblan_format(self) -> None:
+        """Test converting day schedule to BSB-LAN format."""
+        schedule = DaySchedule(
+            slots=[
+                TimeSlot(time(6, 0), time(8, 0)),
+                TimeSlot(time(17, 0), time(21, 0)),
+            ]
+        )
+        assert schedule.to_bsblan_format() == "06:00-08:00 17:00-21:00"
+
+    def test_day_schedule_to_bsblan_format_empty(self) -> None:
+        """Test converting empty day schedule to BSB-LAN format."""
+        schedule = DaySchedule()
+        assert schedule.to_bsblan_format() == ""
+
+    def test_day_schedule_to_bsblan_format_single_slot(self) -> None:
+        """Test converting day schedule with single slot."""
+        schedule = DaySchedule(slots=[TimeSlot(time(6, 0), time(8, 0))])
+        assert schedule.to_bsblan_format() == "06:00-08:00"
+
+    def test_day_schedule_from_bsblan_format(self) -> None:
+        """Test parsing day schedule from BSB-LAN format."""
+        schedule = DaySchedule.from_bsblan_format("06:00-08:00 17:00-21:00")
+        assert len(schedule.slots) == 2
+        assert schedule.slots[0].start == time(6, 0)
+        assert schedule.slots[1].start == time(17, 0)
+
+    def test_day_schedule_from_bsblan_format_empty(self) -> None:
+        """Test parsing empty string returns empty schedule."""
+        schedule = DaySchedule.from_bsblan_format("")
+        assert schedule.slots == []
+
+    def test_day_schedule_from_bsblan_format_undefined(self) -> None:
+        """Test parsing '---' returns empty schedule."""
+        schedule = DaySchedule.from_bsblan_format("---")
+        assert schedule.slots == []
+
+    def test_day_schedule_max_slots_valid(self) -> None:
+        """Test that 3 slots (BSB-LAN max) is valid."""
+        schedule = DaySchedule(
+            slots=[
+                TimeSlot(time(6, 0), time(8, 0)),
+                TimeSlot(time(12, 0), time(13, 0)),
+                TimeSlot(time(17, 0), time(21, 0)),
+            ]
+        )
+        assert len(schedule.slots) == 3
+
+    def test_day_schedule_too_many_slots(self) -> None:
+        """Test that more than 3 slots raises ValueError."""
+        with pytest.raises(ValueError, match="maximum 3 time slots per day"):
+            DaySchedule(
+                slots=[
+                    TimeSlot(time(6, 0), time(7, 0)),
+                    TimeSlot(time(8, 0), time(9, 0)),
+                    TimeSlot(time(10, 0), time(11, 0)),
+                    TimeSlot(time(12, 0), time(13, 0)),
+                ]
+            )
+
+    def test_day_schedule_roundtrip(self) -> None:
+        """Test that converting to and from BSB-LAN format preserves values."""
+        original = DaySchedule(
+            slots=[
+                TimeSlot(time(6, 0), time(8, 0)),
+                TimeSlot(time(17, 0), time(21, 0)),
+            ]
+        )
+        bsblan_str = original.to_bsblan_format()
+        parsed = DaySchedule.from_bsblan_format(bsblan_str)
+        assert len(parsed.slots) == len(original.slots)
+        for orig_slot, parsed_slot in zip(original.slots, parsed.slots, strict=True):
+            assert orig_slot.start == parsed_slot.start
+            assert orig_slot.end == parsed_slot.end
+
+
+class TestDHWSchedule:
+    """Test cases for DHWSchedule dataclass."""
+
+    def test_empty_dhw_schedule(self) -> None:
+        """Test creating an empty DHW schedule."""
+        schedule = DHWSchedule()
+        assert schedule.monday is None
+        assert schedule.tuesday is None
+        assert not schedule.has_any_schedule()
+
+    def test_dhw_schedule_with_days(self) -> None:
+        """Test creating a DHW schedule with multiple days."""
+        monday = DaySchedule(slots=[TimeSlot(time(6, 0), time(8, 0))])
+        tuesday = DaySchedule(slots=[TimeSlot(time(7, 0), time(9, 0))])
+        schedule = DHWSchedule(monday=monday, tuesday=tuesday)
+        assert schedule.monday is not None
+        assert schedule.tuesday is not None
+        assert schedule.wednesday is None
+
+    def test_dhw_schedule_has_any_schedule_true(self) -> None:
+        """Test has_any_schedule returns True when a day is set."""
+        schedule = DHWSchedule(
+            monday=DaySchedule(slots=[TimeSlot(time(6, 0), time(8, 0))])
+        )
+        assert schedule.has_any_schedule() is True
+
+    def test_dhw_schedule_has_any_schedule_false(self) -> None:
+        """Test has_any_schedule returns False when no days are set."""
+        schedule = DHWSchedule()
+        assert schedule.has_any_schedule() is False
+
+    def test_dhw_schedule_all_days(self) -> None:
+        """Test setting all days of the week."""
+        day = DaySchedule(slots=[TimeSlot(time(6, 0), time(8, 0))])
+        schedule = DHWSchedule(
+            monday=day,
+            tuesday=day,
+            wednesday=day,
+            thursday=day,
+            friday=day,
+            saturday=day,
+            sunday=day,
+        )
+        assert schedule.has_any_schedule() is True
+        assert schedule.monday is not None
+        assert schedule.sunday is not None
+
+    def test_dhw_schedule_weekend_only(self) -> None:
+        """Test setting only weekend days."""
+        weekend = DaySchedule(
+            slots=[
+                TimeSlot(time(8, 0), time(10, 0)),
+                TimeSlot(time(18, 0), time(22, 0)),
+            ]
+        )
+        schedule = DHWSchedule(saturday=weekend, sunday=weekend)
+        assert schedule.saturday is not None
+        assert schedule.sunday is not None
+        assert schedule.monday is None
+        assert schedule.has_any_schedule() is True

python_bsblan-3.1.3/tests/test_set_hot_water_schedule.py

@@ -0,0 +1,174 @@
+"""Tests for set_hot_water_schedule method."""
+
+# pylint: disable=duplicate-code
+# pylint: disable=protected-access
+# file deepcode ignore W0212: this is a testfile
+
+from __future__ import annotations
+
+from datetime import time
+from typing import TYPE_CHECKING
+from unittest.mock import AsyncMock
+
+import pytest
+
+from bsblan.exceptions import BSBLANError
+from bsblan.models import DaySchedule, DHWSchedule, TimeSlot
+
+if TYPE_CHECKING:
+    from bsblan import BSBLAN
+
+
+@pytest.mark.asyncio
+async def test_set_hot_water_schedule_single_day(mock_bsblan: BSBLAN) -> None:
+    """Test setting hot water schedule for a single day.
+
+    Args:
+        mock_bsblan: The mock BSBLAN instance.
+
+    """
+    schedule = DHWSchedule(
+        monday=DaySchedule(
+            slots=[
+                TimeSlot(time(6, 0), time(8, 0)),
+                TimeSlot(time(17, 0), time(21, 0)),
+            ]
+        )
+    )
+
+    assert isinstance(mock_bsblan._request, AsyncMock)
+    await mock_bsblan.set_hot_water_schedule(schedule)
+
+    # Verify the request was made correctly for Monday (param 561)
+    mock_bsblan._request.assert_awaited_with(
+        base_path="/JS",
+        data={
+            "Parameter": "561",
+            "Value": "06:00-08:00 17:00-21:00",
+            "Type": "1",
+        },
+    )
+
+
+@pytest.mark.asyncio
+async def test_set_hot_water_schedule_multiple_days(mock_bsblan: BSBLAN) -> None:
+    """Test setting hot water schedule for multiple days.
+
+    Args:
+        mock_bsblan: The mock BSBLAN instance.
+
+    """
+    schedule = DHWSchedule(
+        monday=DaySchedule(slots=[TimeSlot(time(6, 0), time(8, 0))]),
+        friday=DaySchedule(slots=[TimeSlot(time(7, 0), time(9, 0))]),
+    )
+
+    assert isinstance(mock_bsblan._request, AsyncMock)
+    await mock_bsblan.set_hot_water_schedule(schedule)
+
+    # Should have been called twice (once for Monday, once for Friday)
+    assert mock_bsblan._request.await_count == 2
+
+
+@pytest.mark.asyncio
+async def test_set_hot_water_schedule_all_days(mock_bsblan: BSBLAN) -> None:
+    """Test setting hot water schedule for all days.
+
+    Args:
+        mock_bsblan: The mock BSBLAN instance.
+
+    """
+    day = DaySchedule(slots=[TimeSlot(time(6, 0), time(8, 0))])
+    schedule = DHWSchedule(
+        monday=day,
+        tuesday=day,
+        wednesday=day,
+        thursday=day,
+        friday=day,
+        saturday=day,
+        sunday=day,
+    )
+
+    assert isinstance(mock_bsblan._request, AsyncMock)
+    await mock_bsblan.set_hot_water_schedule(schedule)
+
+    # Should have been called 7 times (once for each day)
+    assert mock_bsblan._request.await_count == 7
+
+
+@pytest.mark.asyncio
+async def test_set_hot_water_schedule_empty_raises_error(
+    mock_bsblan: BSBLAN,
+) -> None:
+    """Test that empty schedule raises BSBLANError.
+
+    Args:
+        mock_bsblan: The mock BSBLAN instance.
+
+    """
+    schedule = DHWSchedule()
+
+    with pytest.raises(BSBLANError, match="No schedule provided"):
+        await mock_bsblan.set_hot_water_schedule(schedule)
+
+
+@pytest.mark.asyncio
+async def test_set_hot_water_schedule_parameter_ids(mock_bsblan: BSBLAN) -> None:
+    """Test that correct parameter IDs are used for each day.
+
+    Args:
+        mock_bsblan: The mock BSBLAN instance.
+
+    """
+    # Expected parameter IDs for each day
+    expected_params = {
+        "monday": "561",
+        "tuesday": "562",
+        "wednesday": "563",
+        "thursday": "564",
+        "friday": "565",
+        "saturday": "566",
+        "sunday": "567",
+    }
+
+    for day_name, param_id in expected_params.items():
+        # Reset mock
+        assert isinstance(mock_bsblan._request, AsyncMock)
+        mock_bsblan._request.reset_mock()
+
+        # Create schedule with only this day
+        schedule = DHWSchedule(
+            **{day_name: DaySchedule(slots=[TimeSlot(time(6, 0), time(8, 0))])}
+        )
+        await mock_bsblan.set_hot_water_schedule(schedule)
+
+        # Verify correct parameter ID was used
+        call_args = mock_bsblan._request.call_args
+        assert call_args is not None
+        assert call_args.kwargs["data"]["Parameter"] == param_id
+
+
+@pytest.mark.asyncio
+async def test_set_hot_water_schedule_empty_day_schedule(
+    mock_bsblan: BSBLAN,
+) -> None:
+    """Test setting an empty day schedule (clears the schedule).
+
+    Args:
+        mock_bsblan: The mock BSBLAN instance.
+
+    """
+    schedule = DHWSchedule(monday=DaySchedule(slots=[]))
+
+    assert isinstance(mock_bsblan._request, AsyncMock)
+    await mock_bsblan.set_hot_water_schedule(schedule)
+
+    # Should send empty string as value
+    mock_bsblan._request.assert_awaited_with(
+        base_path="/JS",
+        data={
+            "Parameter": "561",
+            "Value": "",
+            "Type": "1",
+        },
+    )