aiohomematic 2026.1.29__py3-none-any.whl

aiohomematic/model/custom/data_point.py

@@ -0,0 +1,360 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2021-2026
+"""
+Base implementation for custom device-specific data points.
+
+Public API of this module is defined by __all__.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+import contextlib
+from datetime import datetime
+import logging
+from typing import Any, Final, Unpack
+
+from aiohomematic.const import INIT_DATETIME, CallSource, DataPointKey, DataPointUsage, DeviceProfile, Field, Parameter
+from aiohomematic.decorators import inspector
+from aiohomematic.interfaces import ChannelProtocol, CustomDataPointProtocol, GenericDataPointProtocolAny
+from aiohomematic.model.custom import definition as hmed
+from aiohomematic.model.custom.mixins import StateChangeArgs
+from aiohomematic.model.custom.profile import RebasedChannelGroupConfig
+from aiohomematic.model.custom.registry import DeviceConfig
+from aiohomematic.model.data_point import BaseDataPoint
+from aiohomematic.model.support import (
+    DataPointNameData,
+    DataPointPathData,
+    PathData,
+    check_channel_is_the_only_primary_channel,
+    get_custom_data_point_name,
+)
+from aiohomematic.property_decorators import DelegatedProperty, state_property
+from aiohomematic.support import get_channel_address
+from aiohomematic.type_aliases import UnsubscribeCallback
+
+_LOGGER: Final = logging.getLogger(__name__)
+
+
+class CustomDataPoint(BaseDataPoint, CustomDataPointProtocol):
+    """Base class for custom data point."""
+
+    __slots__ = (
+        "_allow_undefined_generic_data_points",
+        "_channel_group",
+        "_custom_data_point_def",
+        "_data_points",
+        "_device_config",
+        "_device_profile",
+        "_extended",
+        "_group_no",
+        "_schedule_channel_no",
+        "_unsubscribe_callbacks",
+    )
+
+    def __init__(
+        self,
+        *,
+        channel: ChannelProtocol,
+        unique_id: str,
+        device_profile: DeviceProfile,
+        channel_group: RebasedChannelGroupConfig,
+        custom_data_point_def: Mapping[int | tuple[int, ...], tuple[Parameter, ...]],
+        group_no: int | None,
+        device_config: DeviceConfig,
+    ) -> None:
+        """Initialize the data point."""
+        self._unsubscribe_callbacks: list[UnsubscribeCallback] = []
+        self._device_profile: Final = device_profile
+        self._channel_group: Final = channel_group
+        self._custom_data_point_def: Final = custom_data_point_def
+        self._group_no: int | None = group_no
+        self._device_config: Final = device_config
+        self._extended: Final = device_config.extended
+        super().__init__(
+            channel=channel,
+            unique_id=unique_id,
+            is_in_multiple_channels=hmed.is_multi_channel_device(model=channel.device.model, category=self.category),
+        )
+        self._allow_undefined_generic_data_points: Final[bool] = channel_group.allow_undefined_generic_data_points
+        self._data_points: Final[dict[Field, GenericDataPointProtocolAny]] = {}
+        self._init_data_points()
+        self._post_init()
+        if self.usage == DataPointUsage.CDP_PRIMARY:
+            self._device.init_week_profile(data_point=self)
+
+    def __del__(self) -> None:
+        """Clean up subscriptions when the object is garbage collected."""
+        with contextlib.suppress(Exception):
+            self.unsubscribe_from_data_point_updated()
+
+    allow_undefined_generic_data_points: Final = DelegatedProperty[bool](path="_allow_undefined_generic_data_points")
+    device_config: Final = DelegatedProperty[DeviceConfig](path="_device_config")
+    group_no: Final = DelegatedProperty[int | None](path="_group_no")
+
+    @property
+    def _readable_data_points(self) -> tuple[GenericDataPointProtocolAny, ...]:
+        """Returns the list of readable data points."""
+        return tuple(dp for dp in self._data_points.values() if dp.is_readable)
+
+    @property
+    def _relevant_data_points(self) -> tuple[GenericDataPointProtocolAny, ...]:
+        """Returns the list of relevant data points. To be overridden by subclasses."""
+        return self._readable_data_points
+
+    @property
+    def data_point_name_postfix(self) -> str:
+        """Return the data point name postfix."""
+        return ""
+
+    @property
+    def has_data_points(self) -> bool:
+        """Return if there are data points."""
+        return len(self._data_points) > 0
+
+    @property
+    def has_schedule(self) -> bool:
+        """Flag if device supports schedule."""
+        if self._device.week_profile:
+            return self._device.week_profile.has_schedule
+        return False
+
+    @property
+    def is_refreshed(self) -> bool:
+        """Return if all relevant data_point have been refreshed (received a value)."""
+        return all(dp.is_refreshed for dp in self._relevant_data_points)
+
+    @property
+    def is_status_valid(self) -> bool:
+        """Return if all relevant data points have valid status."""
+        return all(dp.is_status_valid for dp in self._relevant_data_points)
+
+    @property
+    def schedule(self) -> dict[Any, Any]:
+        """Return cached schedule entries from device week profile."""
+        if self._device.week_profile:
+            return self._device.week_profile.schedule
+        return {}
+
+    @property
+    def state_uncertain(self) -> bool:
+        """Return, if the state is uncertain."""
+        return any(dp.state_uncertain for dp in self._relevant_data_points)
+
+    @property
+    def unconfirmed_last_values_send(self) -> Mapping[Field, Any]:
+        """Return the unconfirmed values send for the data point."""
+        unconfirmed_values: dict[Field, Any] = {}
+        for field, dp in self._data_points.items():
+            if (unconfirmed_value := dp.unconfirmed_last_value_send) is not None:
+                unconfirmed_values[field] = unconfirmed_value
+        return unconfirmed_values
+
+    @state_property
+    def modified_at(self) -> datetime:
+        """Return the latest last update timestamp."""
+        modified_at: datetime = INIT_DATETIME
+        for dp in self._readable_data_points:
+            if (data_point_modified_at := dp.modified_at) and data_point_modified_at > modified_at:
+                modified_at = data_point_modified_at
+        return modified_at
+
+    @state_property
+    def refreshed_at(self) -> datetime:
+        """Return the latest last refresh timestamp."""
+        refreshed_at: datetime = INIT_DATETIME
+        for dp in self._readable_data_points:
+            if (data_point_refreshed_at := dp.refreshed_at) and data_point_refreshed_at > refreshed_at:
+                refreshed_at = data_point_refreshed_at
+        return refreshed_at
+
+    async def get_schedule(self, *, force_load: bool = False) -> dict[Any, Any]:
+        """Get schedule from device week profile."""
+        if self._device.week_profile:
+            return await self._device.week_profile.get_schedule(force_load=force_load)
+        return {}
+
+    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
+
+    def is_state_change(self, **kwargs: Unpack[StateChangeArgs]) -> bool:
+        """
+        Check if the state changes due to kwargs.
+
+        If the state is uncertain, the state should also marked as changed.
+        """
+        if self.state_uncertain:
+            return True
+        _LOGGER.debug("NO_STATE_CHANGE: %s", self.name)
+        return False
+
+    @inspector(re_raise=False)
+    async def load_data_point_value(self, *, call_source: CallSource, direct_call: bool = False) -> None:
+        """Initialize 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)
+        if self._device.week_profile and self.usage == DataPointUsage.CDP_PRIMARY:
+            await self._device.week_profile.reload_and_cache_schedule()
+        self.publish_data_point_updated_event()
+
+    async def set_schedule(self, *, schedule_data: dict[Any, Any]) -> None:
+        """Set schedule on device week profile."""
+        if self._device.week_profile:
+            await self._device.week_profile.set_schedule(schedule_data=schedule_data)
+
+    def unsubscribe_from_data_point_updated(self) -> None:
+        """Unregister all internal update handlers."""
+        for unreg in self._unsubscribe_callbacks:
+            if unreg is not None:
+                unreg()
+        self._unsubscribe_callbacks.clear()
+
+    def _add_channel_data_points(
+        self,
+        *,
+        channel_fields: Mapping[int | None, Mapping[Field, Parameter]],
+        is_visible: bool | None = None,
+    ) -> None:
+        """Add channel-specific data points to custom data point."""
+        for channel_no, ch_fields in channel_fields.items():
+            for field_name, parameter in ch_fields.items():
+                channel_address = get_channel_address(device_address=self._device.address, channel_no=channel_no)
+                if dp := self._device.get_generic_data_point(channel_address=channel_address, parameter=parameter):
+                    self._add_data_point(field=field_name, data_point=dp, is_visible=is_visible)
+
+    def _add_data_point(
+        self,
+        *,
+        field: Field,
+        data_point: GenericDataPointProtocolAny | None,
+        is_visible: bool | None = None,
+    ) -> None:
+        """Add data point to collection and subscribed handler."""
+        if not data_point:
+            return
+        if is_visible is True and data_point.is_forced_sensor is False:
+            data_point.force_usage(forced_usage=DataPointUsage.CDP_VISIBLE)
+        elif is_visible is False and data_point.is_forced_sensor is False:
+            data_point.force_usage(forced_usage=DataPointUsage.NO_CREATE)
+
+        self._unsubscribe_callbacks.append(
+            data_point.subscribe_to_internal_data_point_updated(handler=self.publish_data_point_updated_event)
+        )
+        self._data_points[field] = data_point
+
+    def _add_fixed_channel_data_points(
+        self,
+        *,
+        fixed_channel_fields: Mapping[int, Mapping[Field, Parameter]],
+        is_visible: bool | None = None,
+    ) -> None:
+        """Add fixed channel data points (absolute channel numbers) to custom data point."""
+        for channel_no, ch_fields in fixed_channel_fields.items():
+            channel_address = get_channel_address(device_address=self._device.address, channel_no=channel_no)
+            for field_name, parameter in ch_fields.items():
+                if dp := self._device.get_generic_data_point(channel_address=channel_address, parameter=parameter):
+                    self._add_data_point(field=field_name, data_point=dp, is_visible=is_visible)
+
+    def _get_data_point_name(self) -> DataPointNameData:
+        """Create the name for the data point."""
+        is_only_primary_channel = check_channel_is_the_only_primary_channel(
+            current_channel_no=self._channel.no,
+            primary_channel=self._channel_group.primary_channel,
+            device_has_multiple_channels=self.is_in_multiple_channels,
+        )
+        return get_custom_data_point_name(
+            channel=self._channel,
+            is_only_primary_channel=is_only_primary_channel,
+            ignore_multiple_channels_for_name=self._ignore_multiple_channels_for_name,
+            usage=self._get_data_point_usage(),
+            postfix=self.data_point_name_postfix.replace("_", " ").title(),
+        )
+
+    def _get_data_point_usage(self) -> DataPointUsage:
+        """Generate the usage for the data point."""
+        if self._forced_usage:
+            return self._forced_usage
+        if self._channel.no in self._device_config.channels:
+            return DataPointUsage.CDP_PRIMARY
+        return DataPointUsage.CDP_SECONDARY
+
+    def _get_path_data(self) -> PathData:
+        """Return the path data of the data_point."""
+        return DataPointPathData(
+            interface=self._device.client.interface,
+            address=self._device.address,
+            channel_no=self._channel.no,
+            kind=self._category,
+        )
+
+    def _get_signature(self) -> str:
+        """Return the signature of the data_point."""
+        return f"{self._category}/{self._channel.device.model}/{self.data_point_name_postfix}"
+
+    def _init_data_points(self) -> None:
+        """Initialize data point collection."""
+        cg = self._channel_group
+
+        # Add primary channel fields (applied to the primary channel)
+        for field_name, parameter in cg.fields.items():
+            if dp := self._device.get_generic_data_point(channel_address=self._channel.address, parameter=parameter):
+                self._add_data_point(field=field_name, data_point=dp, is_visible=False)
+
+        # Add visible primary channel fields
+        for field_name, parameter in cg.visible_fields.items():
+            if dp := self._device.get_generic_data_point(channel_address=self._channel.address, parameter=parameter):
+                self._add_data_point(field=field_name, data_point=dp, is_visible=True)
+
+        # Add fixed channel fields (absolute channel numbers from profile config)
+        self._add_fixed_channel_data_points(fixed_channel_fields=cg.fixed_channel_fields)
+        self._add_fixed_channel_data_points(fixed_channel_fields=cg.visible_fixed_channel_fields, is_visible=True)
+
+        # Add fixed channel fields from extended config (legacy support)
+        if self._extended:
+            if fixed_channels := self._extended.fixed_channel_fields:
+                self._add_fixed_channel_data_points(fixed_channel_fields=fixed_channels)
+            if additional_dps := self._extended.additional_data_points:
+                self._mark_data_points(custom_data_point_def=additional_dps)
+
+        # Add channel-specific fields (relative channel numbers, rebased)
+        self._add_channel_data_points(channel_fields=cg.channel_fields)
+
+        # Add visible channel-specific fields
+        self._add_channel_data_points(channel_fields=cg.visible_channel_fields, is_visible=True)
+
+        # Add default device data points
+        self._mark_data_points(custom_data_point_def=self._custom_data_point_def)
+
+        # Add default data points
+        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 _mark_data_point(self, *, channel_no: int | None, parameters: tuple[Parameter, ...]) -> 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)
+
+        for parameter in parameters:
+            if dp := self._device.get_generic_data_point(channel_address=channel_address, parameter=parameter):
+                dp.force_usage(forced_usage=DataPointUsage.DATA_POINT)
+
+    def _mark_data_points(
+        self, *, custom_data_point_def: Mapping[int | tuple[int, ...], tuple[Parameter, ...]]
+    ) -> None:
+        """Mark data points to be created, even though a custom data point is present."""
+        if not custom_data_point_def:
+            return
+        for channel_nos, parameters in custom_data_point_def.items():
+            if isinstance(channel_nos, int):
+                self._mark_data_point(channel_no=channel_nos, parameters=parameters)
+            else:
+                for channel_no in channel_nos:
+                    self._mark_data_point(channel_no=channel_no, parameters=parameters)
+
+    def _post_init(self) -> None:
+        """Post action after initialisation of the data point fields."""
+        _LOGGER.debug(
+            "POST_INIT_DATA_POINT_FIELDS: Post action after initialisation of the data point fields for %s",
+            self.full_name,
+        )

aiohomematic/model/custom/definition.py

@@ -0,0 +1,300 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2021-2026
+"""
+Device profile definitions for custom data point implementations.
+
+This module provides profile definitions and factory functions for creating
+custom data points. Device-to-profile mappings are managed by DeviceProfileRegistry
+in registry.py.
+
+Public API of this module is defined by __all__.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+import logging
+from typing import Final, cast
+
+from aiohomematic import i18n
+from aiohomematic.const import DataPointCategory, DeviceProfile, Parameter
+from aiohomematic.exceptions import AioHomematicException
+from aiohomematic.interfaces import ChannelProtocol, DeviceProtocol
+from aiohomematic.model.custom.profile import (
+    DEFAULT_DATA_POINTS,
+    PROFILE_CONFIGS,
+    ProfileConfig,
+    RebasedChannelGroupConfig,
+    get_profile_config,
+    rebase_channel_group,
+)
+from aiohomematic.model.custom.registry import DeviceConfig, DeviceProfileRegistry
+from aiohomematic.model.support import generate_unique_id
+from aiohomematic.support import extract_exc_args
+
+_LOGGER: Final = logging.getLogger(__name__)
+
+
+def create_custom_data_point(
+    *,
+    channel: ChannelProtocol,
+    device_config: DeviceConfig,
+) -> None:
+    """
+    Create a custom data point for a channel.
+
+    This is the main entry point for creating custom data points. It handles
+    channel group setup, determines the relevant channels, and creates the
+    actual data point instance.
+
+    Args:
+        channel: The channel to create the data point for.
+        device_config: The device configuration from DeviceProfileRegistry.
+
+    """
+    device_profile = device_config.profile_type
+    profile_config = get_profile_config(profile_type=device_profile)
+
+    # Set up channel groups on the device
+    _add_channel_groups_to_device(
+        device=channel.device,
+        profile_config=profile_config,
+        device_config=device_config,
+    )
+
+    # Get the group number for this channel
+    group_no = channel.device.get_channel_group_no(channel_no=channel.no)
+
+    # Determine which channels are relevant for this data point
+    relevant = _get_relevant_channels(
+        profile_config=profile_config,
+        device_config=device_config,
+    )
+
+    if channel.no not in relevant:
+        return
+
+    # Create the rebased channel group
+    channel_group = rebase_channel_group(profile_config=profile_config, group_no=group_no)
+
+    # Get rebased additional data points
+    custom_data_point_def = _rebase_additional_data_points(
+        profile_config=profile_config,
+        group_no=group_no,
+    )
+
+    # Rebase the device config channels
+    rebased_device_config = _rebase_device_config_channels(
+        profile_config=profile_config,
+        device_config=device_config,
+    )
+
+    # Create the data point instance
+    _instantiate_custom_data_point(
+        channel=channel,
+        device_config=rebased_device_config,
+        device_profile=device_profile,
+        channel_group=channel_group,
+        custom_data_point_def=custom_data_point_def,
+        group_no=group_no,
+    )
+
+
+def _instantiate_custom_data_point(
+    *,
+    channel: ChannelProtocol,
+    device_config: DeviceConfig,
+    device_profile: DeviceProfile,
+    channel_group: RebasedChannelGroupConfig,
+    custom_data_point_def: Mapping[int | tuple[int, ...], tuple[Parameter, ...]],
+    group_no: int | None,
+) -> None:
+    """Instantiate and add a custom data point to the channel."""
+
+    unique_id = generate_unique_id(config_provider=channel.device.config_provider, address=channel.address)
+
+    try:
+        dp = device_config.data_point_class(
+            channel=channel,
+            unique_id=unique_id,
+            device_profile=device_profile,
+            channel_group=channel_group,
+            custom_data_point_def=custom_data_point_def,
+            group_no=group_no,
+            device_config=device_config,
+        )
+        if dp.has_data_points:
+            channel.add_data_point(data_point=dp)
+    except Exception as exc:
+        raise AioHomematicException(
+            i18n.tr(
+                key="exception.model.custom.definition.create_custom_data_point.failed",
+                reason=extract_exc_args(exc=exc),
+            )
+        ) from exc
+
+
+def _add_channel_groups_to_device(
+    *,
+    device: DeviceProtocol,
+    profile_config: ProfileConfig,
+    device_config: DeviceConfig,
+) -> None:
+    """Add channel group mappings to the device."""
+    cg = profile_config.channel_group
+
+    if (primary_channel := cg.primary_channel) is None:
+        return
+
+    for conf_channel in device_config.channels:
+        if conf_channel is None:
+            continue
+
+        group_no = conf_channel + primary_channel
+        device.add_channel_to_group(channel_no=group_no, group_no=group_no)
+
+        if cg.state_channel_offset is not None:
+            device.add_channel_to_group(channel_no=conf_channel + cg.state_channel_offset, group_no=group_no)
+
+        for sec_channel in cg.secondary_channels:
+            device.add_channel_to_group(channel_no=conf_channel + sec_channel, group_no=group_no)
+
+
+def _get_relevant_channels(
+    *,
+    profile_config: ProfileConfig,
+    device_config: DeviceConfig,
+) -> set[int | None]:
+    """Return the set of channels that are relevant for this data point."""
+
+    cg = profile_config.channel_group
+    primary_channel = cg.primary_channel
+
+    # Collect all definition channels (primary + secondary)
+    def_channels: list[int | None] = [primary_channel]
+    def_channels.extend(cg.secondary_channels)
+
+    # Calculate relevant channels by combining definition and config channels
+    relevant: set[int | None] = set()
+    for def_ch in def_channels:
+        for conf_ch in device_config.channels:
+            if def_ch is not None and conf_ch is not None:
+                relevant.add(def_ch + conf_ch)
+            else:
+                relevant.add(None)
+
+    return relevant
+
+
+def _rebase_device_config_channels(
+    *,
+    profile_config: ProfileConfig,
+    device_config: DeviceConfig,
+) -> DeviceConfig:
+    """Rebase device config channels with the primary channel offset."""
+    if (primary_channel := profile_config.channel_group.primary_channel) is None:
+        return device_config
+
+    rebased_channels = tuple(ch + primary_channel for ch in device_config.channels if ch is not None)
+
+    return DeviceConfig(
+        data_point_class=device_config.data_point_class,
+        profile_type=device_config.profile_type,
+        channels=rebased_channels if rebased_channels else device_config.channels,
+        extended=device_config.extended,
+        schedule_channel_no=device_config.schedule_channel_no,
+    )
+
+
+def _rebase_additional_data_points(
+    *,
+    profile_config: ProfileConfig,
+    group_no: int | None,
+) -> Mapping[int | tuple[int, ...], tuple[Parameter, ...]]:
+    """Rebase additional data points with the group offset."""
+    additional_dps = profile_config.additional_data_points
+    if not group_no:
+        # Cast is safe: Mapping[int, T] is a subtype of Mapping[int | tuple[int, ...], T]
+        return cast(Mapping[int | tuple[int, ...], tuple[Parameter, ...]], additional_dps)
+
+    new_dps: dict[int | tuple[int, ...], tuple[Parameter, ...]] = {}
+    for channel_no, params in additional_dps.items():
+        new_dps[channel_no + group_no] = params
+
+    return new_dps
+
+
+# =============================================================================
+# Public API functions
+# =============================================================================
+
+
+def create_custom_data_points(*, channel: ChannelProtocol) -> None:
+    """
+    Create custom data points for a channel.
+
+    Queries the DeviceProfileRegistry for configurations matching the device model
+    and creates custom data points for each configuration.
+
+    Args:
+        channel: The channel to create data points for.
+
+    """
+    device_configs = DeviceProfileRegistry.get_configs(model=channel.device.model)
+    for device_config in device_configs:
+        create_custom_data_point(channel=channel, device_config=device_config)
+
+
+def data_point_definition_exists(*, model: str) -> bool:
+    """Check if a device definition exists for the model."""
+    return len(DeviceProfileRegistry.get_configs(model=model)) > 0
+
+
+def get_default_data_points() -> Mapping[int | tuple[int, ...], tuple[Parameter, ...]]:
+    """Return the default data points configuration."""
+    return DEFAULT_DATA_POINTS
+
+
+def get_include_default_data_points(*, device_profile: DeviceProfile) -> bool:
+    """Return if default data points should be included for this profile."""
+    return get_profile_config(profile_type=device_profile).include_default_data_points
+
+
+def get_required_parameters() -> tuple[Parameter, ...]:
+    """Return all required parameters for custom data points."""
+    required_parameters: list[Parameter] = []
+
+    # Add default data points
+    for params in DEFAULT_DATA_POINTS.values():
+        required_parameters.extend(params)
+
+    # Add parameters from profile configurations
+    for profile_config in PROFILE_CONFIGS.values():
+        group = profile_config.channel_group
+        required_parameters.extend(group.fields.values())
+        required_parameters.extend(group.visible_fields.values())
+        for field_map in group.channel_fields.values():
+            required_parameters.extend(field_map.values())
+        for field_map in group.visible_channel_fields.values():
+            required_parameters.extend(field_map.values())
+        for field_map in group.fixed_channel_fields.values():
+            required_parameters.extend(field_map.values())
+        for field_map in group.visible_fixed_channel_fields.values():
+            required_parameters.extend(field_map.values())
+        for params in profile_config.additional_data_points.values():
+            required_parameters.extend(params)
+
+    # Add required parameters from DeviceProfileRegistry extended configs
+    for extended_config in DeviceProfileRegistry.get_all_extended_configs():
+        required_parameters.extend(extended_config.required_parameters)
+
+    return tuple(sorted(set(required_parameters)))
+
+
+def is_multi_channel_device(*, model: str, category: DataPointCategory) -> bool:
+    """Return true if device has multiple channels for the given category."""
+    device_configs = DeviceProfileRegistry.get_configs(model=model, category=category)
+    channels: list[int | None] = []
+    for config in device_configs:
+        channels.extend(config.channels)
+    return len(channels) > 1