aiohomematic 2025.10.0__py3-none-any.whl → 2025.10.2__py3-none-any.whl

aiohomematic/model/custom/cover.py

@@ -100,6 +100,7 @@ class CustomDpCover(CustomDataPoint):
         "_dp_group_level",
         "_dp_level",
         "_dp_stop",
+        "_use_group_channel_for_cover_state",
     )
     _category = DataPointCategory.COVER
     _closed_level: float = _CLOSED_LEVEL
@@ -118,11 +119,16 @@ class CustomDpCover(CustomDataPoint):
         self._dp_group_level: DpSensor[float | None] = self._get_data_point(
             field=Field.GROUP_LEVEL, data_point_type=DpSensor[float | None]
         )
+        self._use_group_channel_for_cover_state = self.central.config.use_group_channel_for_cover_state
 
     @property
     def _group_level(self) -> float:
         """Return the channel level of the cover."""
-        if self._dp_group_level.value is not None and self.usage == DataPointUsage.CDP_PRIMARY:
+        if (
+            self._use_group_channel_for_cover_state
+            and self._dp_group_level.value is not None
+            and self.usage == DataPointUsage.CDP_PRIMARY
+        ):
             return float(self._dp_group_level.value)
         return self._dp_level.value if self._dp_level.value is not None else self._closed_level
 
@@ -143,6 +149,7 @@ class CustomDpCover(CustomDataPoint):
     @bind_collector()
     async def set_position(
         self,
+        *,
         position: int | None = None,
         tilt_position: int | None = None,
         collector: CallParameterCollector | None = None,
@@ -159,6 +166,7 @@ class CustomDpCover(CustomDataPoint):
 
     async def _set_level(
         self,
+        *,
         level: float | None = None,
         tilt_level: float | None = None,
         collector: CallParameterCollector | None = None,
@@ -188,21 +196,21 @@ class CustomDpCover(CustomDataPoint):
         return None
 
     @bind_collector()
-    async def open(self, collector: CallParameterCollector | None = None) -> None:
+    async def open(self, *, collector: CallParameterCollector | None = None) -> None:
         """Open the cover."""
         if not self.is_state_change(open=True):
             return
         await self._set_level(level=self._open_level, collector=collector)
 
     @bind_collector()
-    async def close(self, collector: CallParameterCollector | None = None) -> None:
+    async def close(self, *, collector: CallParameterCollector | None = None) -> None:
         """Close the cover."""
         if not self.is_state_change(close=True):
             return
         await self._set_level(level=self._closed_level, collector=collector)
 
     @bind_collector(enabled=False)
-    async def stop(self, collector: CallParameterCollector | None = None) -> None:
+    async def stop(self, *, collector: CallParameterCollector | None = None) -> None:
         """Stop the device if in motion."""
         await self._dp_stop.send_value(value=True, collector=collector)
 
@@ -237,6 +245,7 @@ class CustomDpWindowDrive(CustomDpCover):
 
     async def _set_level(
         self,
+        *,
         level: float | None = None,
         tilt_level: float | None = None,
         collector: CallParameterCollector | None = None,
@@ -276,7 +285,11 @@ class CustomDpBlind(CustomDpCover):
     @property
     def _group_tilt_level(self) -> float:
         """Return the group level of the tilt."""
-        if self._dp_group_level_2.value is not None and self.usage == DataPointUsage.CDP_PRIMARY:
+        if (
+            self._use_group_channel_for_cover_state
+            and self._dp_group_level_2.value is not None
+            and self.usage == DataPointUsage.CDP_PRIMARY
+        ):
             return float(self._dp_group_level_2.value)
         return self._dp_level_2.value if self._dp_level_2.value is not None else self._closed_level
 
@@ -311,6 +324,7 @@ class CustomDpBlind(CustomDpCover):
     @bind_collector(enabled=False)
     async def set_position(
         self,
+        *,
         position: int | None = None,
         tilt_position: int | None = None,
         collector: CallParameterCollector | None = None,
@@ -332,6 +346,7 @@ class CustomDpBlind(CustomDpCover):
 
     async def _set_level(
         self,
+        *,
         level: float | None = None,
         tilt_level: float | None = None,
         collector: CallParameterCollector | None = None,
@@ -382,6 +397,7 @@ class CustomDpBlind(CustomDpCover):
     @bind_collector()
     async def _send_level(
         self,
+        *,
         level: float,
         tilt_level: float,
         collector: CallParameterCollector | None = None,
@@ -398,7 +414,7 @@ class CustomDpBlind(CustomDpCover):
         await super()._set_level(level=level, collector=collector)
 
     @bind_collector(enabled=False)
-    async def open(self, collector: CallParameterCollector | None = None) -> None:
+    async def open(self, *, collector: CallParameterCollector | None = None) -> None:
         """Open the cover and open the tilt."""
         if not self.is_state_change(open=True, tilt_open=True):
             return
@@ -409,7 +425,7 @@ class CustomDpBlind(CustomDpCover):
         )
 
     @bind_collector(enabled=False)
-    async def close(self, collector: CallParameterCollector | None = None) -> None:
+    async def close(self, *, collector: CallParameterCollector | None = None) -> None:
         """Close the cover and close the tilt."""
         if not self.is_state_change(close=True, tilt_close=True):
             return
@@ -420,7 +436,7 @@ class CustomDpBlind(CustomDpCover):
         )
 
     @bind_collector(enabled=False)
-    async def stop(self, collector: CallParameterCollector | None = None) -> None:
+    async def stop(self, *, collector: CallParameterCollector | None = None) -> None:
         """Stop the device if in motion."""
         try:
             acquired: bool = await asyncio.wait_for(
@@ -436,26 +452,26 @@ class CustomDpBlind(CustomDpCover):
                 self._command_processing_lock.release()
 
     @bind_collector(enabled=False)
-    async def _stop(self, collector: CallParameterCollector | None = None) -> None:
+    async def _stop(self, *, collector: CallParameterCollector | None = None) -> None:
         """Stop the device if in motion. Do only call with _command_processing_lock held."""
         await super().stop(collector=collector)
 
     @bind_collector(enabled=False)
-    async def open_tilt(self, collector: CallParameterCollector | None = None) -> None:
+    async def open_tilt(self, *, collector: CallParameterCollector | None = None) -> None:
         """Open the tilt."""
         if not self.is_state_change(tilt_open=True):
             return
         await self._set_level(tilt_level=self._open_tilt_level, collector=collector)
 
     @bind_collector(enabled=False)
-    async def close_tilt(self, collector: CallParameterCollector | None = None) -> None:
+    async def close_tilt(self, *, collector: CallParameterCollector | None = None) -> None:
         """Close the tilt."""
         if not self.is_state_change(tilt_close=True):
             return
         await self._set_level(tilt_level=self._closed_level, collector=collector)
 
     @bind_collector(enabled=False)
-    async def stop_tilt(self, collector: CallParameterCollector | None = None) -> None:
+    async def stop_tilt(self, *, collector: CallParameterCollector | None = None) -> None:
         """Stop the device if in motion. Use only when command_processing_lock is held."""
         await self.stop(collector=collector)
 
@@ -471,16 +487,16 @@ class CustomDpBlind(CustomDpCover):
             return True
         return super().is_state_change(**kwargs)
 
-    def _get_combined_value(self, level: float | None = None, tilt_level: float | None = None) -> str | None:
+    def _get_combined_value(self, *, level: float | None = None, tilt_level: float | None = None) -> str | None:
         """Return the combined parameter."""
         if level is None and tilt_level is None:
             return None
         levels: list[str] = []
         # the resulting hex value is based on the doubled position
         if level is not None:
-            levels.append(convert_hm_level_to_cpv(hm_level=level))
+            levels.append(convert_hm_level_to_cpv(value=level))
         if tilt_level is not None:
-            levels.append(convert_hm_level_to_cpv(hm_level=tilt_level))
+            levels.append(convert_hm_level_to_cpv(value=tilt_level))
 
         if levels:
             return ",".join(levels)
@@ -503,7 +519,7 @@ class CustomDpIpBlind(CustomDpBlind):
         """Return operation mode of cover."""
         return self._dp_operation_mode.value
 
-    def _get_combined_value(self, level: float | None = None, tilt_level: float | None = None) -> str | None:
+    def _get_combined_value(self, *, level: float | None = None, tilt_level: float | None = None) -> str | None:
         """Return the combined parameter."""
         if level is None and tilt_level is None:
             return None
@@ -553,6 +569,7 @@ class CustomDpGarage(CustomDataPoint):
     @bind_collector()
     async def set_position(
         self,
+        *,
         position: int | None = None,
         tilt_position: int | None = None,
         collector: CallParameterCollector | None = None,
@@ -589,26 +606,26 @@ class CustomDpGarage(CustomDataPoint):
         return None
 
     @bind_collector()
-    async def open(self, collector: CallParameterCollector | None = None) -> None:
+    async def open(self, *, collector: CallParameterCollector | None = None) -> None:
         """Open the garage door."""
         if not self.is_state_change(open=True):
             return
         await self._dp_door_command.send_value(value=_GarageDoorCommand.OPEN, collector=collector)
 
     @bind_collector()
-    async def close(self, collector: CallParameterCollector | None = None) -> None:
+    async def close(self, *, collector: CallParameterCollector | None = None) -> None:
         """Close the garage door."""
         if not self.is_state_change(close=True):
             return
         await self._dp_door_command.send_value(value=_GarageDoorCommand.CLOSE, collector=collector)
 
     @bind_collector(enabled=False)
-    async def stop(self, collector: CallParameterCollector | None = None) -> None:
+    async def stop(self, *, collector: CallParameterCollector | None = None) -> None:
         """Stop the device if in motion."""
         await self._dp_door_command.send_value(value=_GarageDoorCommand.STOP, collector=collector)
 
     @bind_collector()
-    async def vent(self, collector: CallParameterCollector | None = None) -> None:
+    async def vent(self, *, collector: CallParameterCollector | None = None) -> None:
         """Move the garage door to vent position."""
         if not self.is_state_change(vent=True):
             return
@@ -626,6 +643,7 @@ class CustomDpGarage(CustomDataPoint):
 
 
 def make_ip_cover(
+    *,
     channel: hmd.Channel,
     custom_config: CustomConfig,
 ) -> None:
@@ -639,6 +657,7 @@ def make_ip_cover(
 
 
 def make_rf_cover(
+    *,
     channel: hmd.Channel,
     custom_config: CustomConfig,
 ) -> None:
@@ -652,6 +671,7 @@ def make_rf_cover(
 
 
 def make_ip_blind(
+    *,
     channel: hmd.Channel,
     custom_config: CustomConfig,
 ) -> None:
@@ -665,6 +685,7 @@ def make_ip_blind(
 
 
 def make_ip_garage(
+    *,
     channel: hmd.Channel,
     custom_config: CustomConfig,
 ) -> None:
@@ -678,6 +699,7 @@ def make_ip_garage(
 
 
 def make_ip_hdm(
+    *,
     channel: hmd.Channel,
     custom_config: CustomConfig,
 ) -> None:
@@ -691,6 +713,7 @@ def make_ip_hdm(
 
 
 def make_rf_blind(
+    *,
     channel: hmd.Channel,
     custom_config: CustomConfig,
 ) -> None:
@@ -704,6 +727,7 @@ def make_rf_blind(
 
 
 def make_rf_window_drive(
+    *,
     channel: hmd.Channel,
     custom_config: CustomConfig,
 ) -> None:

aiohomematic/model/custom/data_point.py

@@ -46,6 +46,7 @@ class CustomDataPoint(BaseDataPoint):
 
     def __init__(
         self,
+        *,
         channel: hmd.Channel,
         unique_id: str,
         device_profile: DeviceProfile,
@@ -183,7 +184,7 @@ class CustomDataPoint(BaseDataPoint):
         """Return the signature of the data_point."""
         return f"{self._category}/{self._channel.device.model}/{self.data_point_name_postfix}"
 
-    async def load_data_point_value(self, call_source: CallSource, direct_call: bool = False) -> None:
+    async def load_data_point_value(self, *, call_source: CallSource, direct_call: bool = False) -> None:
         """Init the data point values."""
         for dp in self._readable_data_points:
             await dp.load_data_point_value(call_source=call_source, direct_call=direct_call)
@@ -242,7 +243,7 @@ class CustomDataPoint(BaseDataPoint):
         if hmed.get_include_default_data_points(device_profile=self._device_profile):
             self._mark_data_points(custom_data_point_def=hmed.get_default_data_points())
 
-    def _add_data_points(self, field_dict_name: hmed.CDPD, is_visible: bool | None = None) -> None:
+    def _add_data_points(self, *, field_dict_name: hmed.CDPD, is_visible: bool | None = None) -> None:
         """Add data points to custom data point."""
         fields = self._device_def.get(field_dict_name, {})
         for channel_no, channel in fields.items():
@@ -253,6 +254,7 @@ class CustomDataPoint(BaseDataPoint):
 
     def _add_data_point(
         self,
+        *,
         field: Field,
         data_point: hmge.GenericDataPoint | None,
         is_visible: bool | None = None,
@@ -270,7 +272,7 @@ class CustomDataPoint(BaseDataPoint):
         )
         self._data_points[field] = data_point
 
-    def _unregister_data_point_updated_callback(self, cb: Callable, custom_id: str) -> None:
+    def _unregister_data_point_updated_callback(self, *, cb: Callable, custom_id: str) -> None:
         """Unregister update callback."""
         for unregister in self._unregister_callbacks:
             if unregister is not None:
@@ -278,7 +280,7 @@ class CustomDataPoint(BaseDataPoint):
 
         super()._unregister_data_point_updated_callback(cb=cb, custom_id=custom_id)
 
-    def _mark_data_points(self, custom_data_point_def: Mapping[int | tuple[int, ...], tuple[str, ...]]) -> None:
+    def _mark_data_points(self, *, custom_data_point_def: Mapping[int | tuple[int, ...], tuple[str, ...]]) -> None:
         """Mark data points to be created, even though a custom data point is present."""
         if not custom_data_point_def:
             return
@@ -289,7 +291,7 @@ class CustomDataPoint(BaseDataPoint):
                 for channel_no in channel_nos:
                     self._mark_data_point(channel_no=channel_no, parameters=parameters)
 
-    def _mark_data_point(self, channel_no: int | None, parameters: tuple[str, ...]) -> None:
+    def _mark_data_point(self, *, channel_no: int | None, parameters: tuple[str, ...]) -> None:
         """Mark data point to be created, even though a custom data point is present."""
         channel_address = get_channel_address(device_address=self._device.address, channel_no=channel_no)
 
@@ -298,7 +300,7 @@ class CustomDataPoint(BaseDataPoint):
                 dp.force_usage(forced_usage=DataPointUsage.DATA_POINT)
 
     def _get_data_point[DataPointT: hmge.GenericDataPoint](
-        self, field: Field, data_point_type: type[DataPointT]
+        self, *, field: Field, data_point_type: type[DataPointT]
     ) -> DataPointT:
         """Get data point."""
         if dp := self._data_points.get(field):
@@ -318,7 +320,7 @@ class CustomDataPoint(BaseDataPoint):
             NoneTypeDataPoint(),
         )
 
-    def has_data_point_key(self, data_point_keys: set[DataPointKey]) -> bool:
+    def has_data_point_key(self, *, data_point_keys: set[DataPointKey]) -> bool:
         """Return if a data_point with one of the data points is part of this data_point."""
         result = [dp for dp in self._data_points.values() if dp.dpk in data_point_keys]
         return len(result) > 0

aiohomematic/model/custom/definition.py

@@ -594,6 +594,7 @@ def validate_custom_data_point_definition() -> Any:
 
 
 def make_custom_data_point(
+    *,
     channel: hmd.Channel,
     data_point_class: type,
     device_profile: DeviceProfile,
@@ -620,6 +621,7 @@ def make_custom_data_point(
 
 
 def _create_custom_data_point(
+    *,
     channel: hmd.Channel,
     custom_data_point_class: type,
     device_profile: DeviceProfile,
@@ -650,9 +652,9 @@ def _create_custom_data_point(
         ) from exc
 
 
-def _rebase_pri_channels(device_profile: DeviceProfile, custom_config: CustomConfig) -> CustomConfig:
+def _rebase_pri_channels(*, device_profile: DeviceProfile, custom_config: CustomConfig) -> CustomConfig:
     """Re base primary channel of custom config."""
-    device_def = _get_device_group(device_profile, 0)
+    device_def = _get_device_group(device_profile=device_profile, group_no=0)
     if (pri_def := device_def[CDPD.PRIMARY_CHANNEL]) is None:
         return custom_config
     pri_channels = [cu + pri_def for cu in custom_config.channels]
@@ -663,9 +665,9 @@ def _rebase_pri_channels(device_profile: DeviceProfile, custom_config: CustomCon
     )
 
 
-def _relevant_channels(device_profile: DeviceProfile, custom_config: CustomConfig) -> tuple[int | None, ...]:
+def _relevant_channels(*, device_profile: DeviceProfile, custom_config: CustomConfig) -> tuple[int | None, ...]:
     """Return the relevant channels."""
-    device_def = _get_device_group(device_profile, 0)
+    device_def = _get_device_group(device_profile=device_profile, group_no=0)
     def_channels = [device_def[CDPD.PRIMARY_CHANNEL]]
     if sec_channels := device_def.get(CDPD.SECONDARY_CHANNELS):
         def_channels.extend(sec_channels)
@@ -681,10 +683,10 @@ def _relevant_channels(device_profile: DeviceProfile, custom_config: CustomConfi
 
 
 def add_channel_groups_to_device(
-    device: hmd.Device, device_profile: DeviceProfile, custom_config: CustomConfig
+    *, device: hmd.Device, device_profile: DeviceProfile, custom_config: CustomConfig
 ) -> None:
     """Return the relevant channels."""
-    device_def = _get_device_group(device_profile, 0)
+    device_def = _get_device_group(device_profile=device_profile, group_no=0)
     if (pri_channel := device_def[CDPD.PRIMARY_CHANNEL]) is None:
         return
     for conf_channel in custom_config.channels:
@@ -699,7 +701,7 @@ def add_channel_groups_to_device(
                 device.add_channel_to_group(channel_no=conf_channel + sec_channel, group_no=group_no)
 
 
-def get_channel_group_no(device: hmd.Device, channel_no: int | None) -> int | None:
+def get_channel_group_no(*, device: hmd.Device, channel_no: int | None) -> int | None:
     """Get channel group of sub_device."""
     return device.get_channel_group_no(channel_no=channel_no)
 
@@ -711,13 +713,13 @@ def get_default_data_points() -> Mapping[int | tuple[int, ...], tuple[Parameter,
     )
 
 
-def get_include_default_data_points(device_profile: DeviceProfile) -> bool:
+def get_include_default_data_points(*, device_profile: DeviceProfile) -> bool:
     """Return if default data points should be included."""
-    device = _get_device_definition(device_profile)
+    device = _get_device_definition(device_profile=device_profile)
     return bool(device.get(CDPD.INCLUDE_DEFAULT_DPS, DEFAULT_INCLUDE_DEFAULT_DPS))
 
 
-def _get_device_definition(device_profile: DeviceProfile) -> Mapping[CDPD, Any]:
+def _get_device_definition(*, device_profile: DeviceProfile) -> Mapping[CDPD, Any]:
     """Return device from data_point definitions."""
     return cast(
         Mapping[CDPD, Any],
@@ -725,9 +727,9 @@ def _get_device_definition(device_profile: DeviceProfile) -> Mapping[CDPD, Any]:
     )
 
 
-def _get_device_group(device_profile: DeviceProfile, group_no: int | None) -> Mapping[CDPD, Any]:
+def _get_device_group(*, device_profile: DeviceProfile, group_no: int | None) -> Mapping[CDPD, Any]:
     """Return the device group."""
-    device = _get_device_definition(device_profile)
+    device = _get_device_definition(device_profile=device_profile)
     group = cast(dict[CDPD, Any], device[CDPD.DEVICE_GROUP])
     # Create a deep copy of the group due to channel rebase
     group = deepcopy(group)
@@ -750,7 +752,7 @@ def _get_device_group(device_profile: DeviceProfile, group_no: int | None) -> Ma
 
 
 def _rebase_data_point_dict(
-    data_point_dict: CDPD, group: Mapping[CDPD, Any], group_no: int
+    *, data_point_dict: CDPD, group: Mapping[CDPD, Any], group_no: int
 ) -> Mapping[int | None, Any]:
     """Rebase data_point_dict with group_no."""
     new_fields: dict[int | None, Any] = {}
@@ -763,7 +765,9 @@ def _rebase_data_point_dict(
     return new_fields
 
 
-def _get_device_data_points(device_profile: DeviceProfile, group_no: int | None) -> Mapping[int, tuple[Parameter, ...]]:
+def _get_device_data_points(
+    *, device_profile: DeviceProfile, group_no: int | None
+) -> Mapping[int, tuple[Parameter, ...]]:
     """Return the device data points."""
     if (
         additional_dps := VALID_CUSTOM_DATA_POINT_DEFINITION[CDPD.DEVICE_DEFINITIONS]
@@ -779,6 +783,7 @@ def _get_device_data_points(device_profile: DeviceProfile, group_no: int | None)
 
 
 def get_custom_configs(
+    *,
     model: str,
     category: DataPointCategory | None = None,
 ) -> tuple[CustomConfig, ...]:
@@ -807,6 +812,7 @@ def get_custom_configs(
 
 
 def _get_data_point_config_by_category(
+    *,
     category_devices: Mapping[str, CustomConfig | tuple[CustomConfig, ...]],
     model: str,
 ) -> CustomConfig | tuple[CustomConfig, ...] | None:
@@ -822,7 +828,7 @@ def _get_data_point_config_by_category(
     return None
 
 
-def is_multi_channel_device(model: str, category: DataPointCategory) -> bool:
+def is_multi_channel_device(*, model: str, category: DataPointCategory) -> bool:
     """Return true, if device has multiple channels."""
     channels: list[int | None] = []
     for custom_config in get_custom_configs(model=model, category=category):
@@ -830,9 +836,9 @@ def is_multi_channel_device(model: str, category: DataPointCategory) -> bool:
     return len(channels) > 1
 
 
-def data_point_definition_exists(model: str) -> bool:
+def data_point_definition_exists(*, model: str) -> bool:
     """Check if device desc exits."""
-    return len(get_custom_configs(model)) > 0
+    return len(get_custom_configs(model=model)) > 0
 
 
 def get_required_parameters() -> tuple[Parameter, ...]: