homeassistant 2025.7.4__py3-none-any.whl → 2025.8.0b0__py3-none-any.whl

homeassistant/components/knx/knx_module.py

@@ -0,0 +1,301 @@
+"""Base module for the KNX integration."""
+
+from __future__ import annotations
+
+import logging
+
+from xknx import XKNX
+from xknx.core import XknxConnectionState
+from xknx.core.state_updater import StateTrackerType, TrackerOptions
+from xknx.core.telegram_queue import TelegramQueue
+from xknx.dpt import DPTBase
+from xknx.exceptions import ConversionError, CouldNotParseTelegram
+from xknx.io import ConnectionConfig, ConnectionType, SecureConfig
+from xknx.telegram import AddressFilter, Telegram
+from xknx.telegram.address import DeviceGroupAddress, GroupAddress, InternalGroupAddress
+from xknx.telegram.apci import GroupValueResponse, GroupValueWrite
+
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.const import (
+    CONF_EVENT,
+    CONF_HOST,
+    CONF_PORT,
+    CONF_TYPE,
+    EVENT_HOMEASSISTANT_STOP,
+)
+from homeassistant.core import Event, HomeAssistant
+from homeassistant.helpers.storage import STORAGE_DIR
+from homeassistant.helpers.typing import ConfigType
+
+from .const import (
+    CONF_KNX_CONNECTION_TYPE,
+    CONF_KNX_INDIVIDUAL_ADDRESS,
+    CONF_KNX_KNXKEY_FILENAME,
+    CONF_KNX_KNXKEY_PASSWORD,
+    CONF_KNX_LOCAL_IP,
+    CONF_KNX_MCAST_GRP,
+    CONF_KNX_MCAST_PORT,
+    CONF_KNX_RATE_LIMIT,
+    CONF_KNX_ROUTE_BACK,
+    CONF_KNX_ROUTING,
+    CONF_KNX_ROUTING_BACKBONE_KEY,
+    CONF_KNX_ROUTING_SECURE,
+    CONF_KNX_ROUTING_SYNC_LATENCY_TOLERANCE,
+    CONF_KNX_SECURE_DEVICE_AUTHENTICATION,
+    CONF_KNX_SECURE_USER_ID,
+    CONF_KNX_SECURE_USER_PASSWORD,
+    CONF_KNX_STATE_UPDATER,
+    CONF_KNX_TELEGRAM_LOG_SIZE,
+    CONF_KNX_TUNNEL_ENDPOINT_IA,
+    CONF_KNX_TUNNELING,
+    CONF_KNX_TUNNELING_TCP,
+    CONF_KNX_TUNNELING_TCP_SECURE,
+    KNX_ADDRESS,
+    TELEGRAM_LOG_DEFAULT,
+)
+from .device import KNXInterfaceDevice
+from .expose import KNXExposeSensor, KNXExposeTime
+from .project import KNXProject
+from .storage.config_store import KNXConfigStore
+from .telegrams import Telegrams
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class KNXModule:
+    """Representation of KNX Object."""
+
+    def __init__(
+        self, hass: HomeAssistant, config: ConfigType, entry: ConfigEntry
+    ) -> None:
+        """Initialize KNX module."""
+        self.hass = hass
+        self.config_yaml = config
+        self.connected = False
+        self.exposures: list[KNXExposeSensor | KNXExposeTime] = []
+        self.service_exposures: dict[str, KNXExposeSensor | KNXExposeTime] = {}
+        self.entry = entry
+
+        self.project = KNXProject(hass=hass, entry=entry)
+        self.config_store = KNXConfigStore(hass=hass, config_entry=entry)
+
+        default_state_updater = (
+            TrackerOptions(tracker_type=StateTrackerType.EXPIRE, update_interval_min=60)
+            if self.entry.data[CONF_KNX_STATE_UPDATER]
+            else TrackerOptions(
+                tracker_type=StateTrackerType.INIT, update_interval_min=60
+            )
+        )
+        self.xknx = XKNX(
+            address_format=self.project.get_address_format(),
+            connection_config=self.connection_config(),
+            rate_limit=self.entry.data[CONF_KNX_RATE_LIMIT],
+            state_updater=default_state_updater,
+        )
+        self.xknx.connection_manager.register_connection_state_changed_cb(
+            self.connection_state_changed_cb
+        )
+        self.telegrams = Telegrams(
+            hass=hass,
+            xknx=self.xknx,
+            project=self.project,
+            log_size=entry.data.get(CONF_KNX_TELEGRAM_LOG_SIZE, TELEGRAM_LOG_DEFAULT),
+        )
+        self.interface_device = KNXInterfaceDevice(
+            hass=hass, entry=entry, xknx=self.xknx
+        )
+
+        self._address_filter_transcoder: dict[AddressFilter, type[DPTBase]] = {}
+        self.group_address_transcoder: dict[DeviceGroupAddress, type[DPTBase]] = {}
+        self.knx_event_callback: TelegramQueue.Callback = self.register_event_callback()
+
+        self.entry.async_on_unload(
+            self.hass.bus.async_listen_once(EVENT_HOMEASSISTANT_STOP, self.stop)
+        )
+
+    async def start(self) -> None:
+        """Start XKNX object. Connect to tunneling or Routing device."""
+        await self.project.load_project(self.xknx)
+        await self.config_store.load_data()
+        await self.telegrams.load_history()
+        await self.xknx.start()
+
+    async def stop(self, event: Event | None = None) -> None:
+        """Stop XKNX object. Disconnect from tunneling or Routing device."""
+        await self.xknx.stop()
+        await self.telegrams.save_history()
+
+    def connection_config(self) -> ConnectionConfig:
+        """Return the connection_config."""
+        _conn_type: str = self.entry.data[CONF_KNX_CONNECTION_TYPE]
+        _knxkeys_file: str | None = (
+            self.hass.config.path(
+                STORAGE_DIR,
+                self.entry.data[CONF_KNX_KNXKEY_FILENAME],
+            )
+            if self.entry.data.get(CONF_KNX_KNXKEY_FILENAME) is not None
+            else None
+        )
+        if _conn_type == CONF_KNX_ROUTING:
+            return ConnectionConfig(
+                connection_type=ConnectionType.ROUTING,
+                individual_address=self.entry.data[CONF_KNX_INDIVIDUAL_ADDRESS],
+                multicast_group=self.entry.data[CONF_KNX_MCAST_GRP],
+                multicast_port=self.entry.data[CONF_KNX_MCAST_PORT],
+                local_ip=self.entry.data.get(CONF_KNX_LOCAL_IP),
+                auto_reconnect=True,
+                secure_config=SecureConfig(
+                    knxkeys_password=self.entry.data.get(CONF_KNX_KNXKEY_PASSWORD),
+                    knxkeys_file_path=_knxkeys_file,
+                ),
+                threaded=True,
+            )
+        if _conn_type == CONF_KNX_TUNNELING:
+            return ConnectionConfig(
+                connection_type=ConnectionType.TUNNELING,
+                gateway_ip=self.entry.data[CONF_HOST],
+                gateway_port=self.entry.data[CONF_PORT],
+                local_ip=self.entry.data.get(CONF_KNX_LOCAL_IP),
+                route_back=self.entry.data.get(CONF_KNX_ROUTE_BACK, False),
+                auto_reconnect=True,
+                secure_config=SecureConfig(
+                    knxkeys_password=self.entry.data.get(CONF_KNX_KNXKEY_PASSWORD),
+                    knxkeys_file_path=_knxkeys_file,
+                ),
+                threaded=True,
+            )
+        if _conn_type == CONF_KNX_TUNNELING_TCP:
+            return ConnectionConfig(
+                connection_type=ConnectionType.TUNNELING_TCP,
+                individual_address=self.entry.data.get(CONF_KNX_TUNNEL_ENDPOINT_IA),
+                gateway_ip=self.entry.data[CONF_HOST],
+                gateway_port=self.entry.data[CONF_PORT],
+                auto_reconnect=True,
+                secure_config=SecureConfig(
+                    knxkeys_password=self.entry.data.get(CONF_KNX_KNXKEY_PASSWORD),
+                    knxkeys_file_path=_knxkeys_file,
+                ),
+                threaded=True,
+            )
+        if _conn_type == CONF_KNX_TUNNELING_TCP_SECURE:
+            return ConnectionConfig(
+                connection_type=ConnectionType.TUNNELING_TCP_SECURE,
+                individual_address=self.entry.data.get(CONF_KNX_TUNNEL_ENDPOINT_IA),
+                gateway_ip=self.entry.data[CONF_HOST],
+                gateway_port=self.entry.data[CONF_PORT],
+                secure_config=SecureConfig(
+                    user_id=self.entry.data.get(CONF_KNX_SECURE_USER_ID),
+                    user_password=self.entry.data.get(CONF_KNX_SECURE_USER_PASSWORD),
+                    device_authentication_password=self.entry.data.get(
+                        CONF_KNX_SECURE_DEVICE_AUTHENTICATION
+                    ),
+                    knxkeys_password=self.entry.data.get(CONF_KNX_KNXKEY_PASSWORD),
+                    knxkeys_file_path=_knxkeys_file,
+                ),
+                auto_reconnect=True,
+                threaded=True,
+            )
+        if _conn_type == CONF_KNX_ROUTING_SECURE:
+            return ConnectionConfig(
+                connection_type=ConnectionType.ROUTING_SECURE,
+                individual_address=self.entry.data[CONF_KNX_INDIVIDUAL_ADDRESS],
+                multicast_group=self.entry.data[CONF_KNX_MCAST_GRP],
+                multicast_port=self.entry.data[CONF_KNX_MCAST_PORT],
+                local_ip=self.entry.data.get(CONF_KNX_LOCAL_IP),
+                secure_config=SecureConfig(
+                    backbone_key=self.entry.data.get(CONF_KNX_ROUTING_BACKBONE_KEY),
+                    latency_ms=self.entry.data.get(
+                        CONF_KNX_ROUTING_SYNC_LATENCY_TOLERANCE
+                    ),
+                    knxkeys_password=self.entry.data.get(CONF_KNX_KNXKEY_PASSWORD),
+                    knxkeys_file_path=_knxkeys_file,
+                ),
+                auto_reconnect=True,
+                threaded=True,
+            )
+        return ConnectionConfig(
+            auto_reconnect=True,
+            individual_address=self.entry.data.get(
+                CONF_KNX_TUNNEL_ENDPOINT_IA,  # may be configured at knxkey upload
+            ),
+            secure_config=SecureConfig(
+                knxkeys_password=self.entry.data.get(CONF_KNX_KNXKEY_PASSWORD),
+                knxkeys_file_path=_knxkeys_file,
+            ),
+            threaded=True,
+        )
+
+    def connection_state_changed_cb(self, state: XknxConnectionState) -> None:
+        """Call invoked after a KNX connection state change was received."""
+        self.connected = state == XknxConnectionState.CONNECTED
+        for device in self.xknx.devices:
+            device.after_update()
+
+    def telegram_received_cb(self, telegram: Telegram) -> None:
+        """Call invoked after a KNX telegram was received."""
+        # Not all telegrams have serializable data.
+        data: int | tuple[int, ...] | None = None
+        value = None
+        if (
+            isinstance(telegram.payload, (GroupValueWrite, GroupValueResponse))
+            and telegram.payload.value is not None
+            and isinstance(
+                telegram.destination_address, (GroupAddress, InternalGroupAddress)
+            )
+        ):
+            data = telegram.payload.value.value
+            if transcoder := (
+                self.group_address_transcoder.get(telegram.destination_address)
+                or next(
+                    (
+                        _transcoder
+                        for _filter, _transcoder in self._address_filter_transcoder.items()
+                        if _filter.match(telegram.destination_address)
+                    ),
+                    None,
+                )
+            ):
+                try:
+                    value = transcoder.from_knx(telegram.payload.value)
+                except (ConversionError, CouldNotParseTelegram) as err:
+                    _LOGGER.warning(
+                        (
+                            "Error in `knx_event` at decoding type '%s' from"
+                            " telegram %s\n%s"
+                        ),
+                        transcoder.__name__,
+                        telegram,
+                        err,
+                    )
+
+        self.hass.bus.async_fire(
+            "knx_event",
+            {
+                "data": data,
+                "destination": str(telegram.destination_address),
+                "direction": telegram.direction.value,
+                "value": value,
+                "source": str(telegram.source_address),
+                "telegramtype": telegram.payload.__class__.__name__,
+            },
+        )
+
+    def register_event_callback(self) -> TelegramQueue.Callback:
+        """Register callback for knx_event within XKNX TelegramQueue."""
+        address_filters = []
+        for filter_set in self.config_yaml[CONF_EVENT]:
+            _filters = list(map(AddressFilter, filter_set[KNX_ADDRESS]))
+            address_filters.extend(_filters)
+            if (dpt := filter_set.get(CONF_TYPE)) and (
+                transcoder := DPTBase.parse_transcoder(dpt)
+            ):
+                self._address_filter_transcoder.update(
+                    dict.fromkeys(_filters, transcoder)
+                )
+
+        return self.xknx.telegram_queue.register_telegram_received_cb(
+            self.telegram_received_cb,
+            address_filters=address_filters,
+            group_addresses=[],
+            match_for_outgoing=True,
+        )

homeassistant/components/knx/light.py

@@ -1,4 +1,4 @@
-"""Support for KNX/IP lights."""
+"""Support for KNX light entities."""
 
 from __future__ import annotations
 
@@ -28,14 +28,14 @@ from homeassistant.helpers.entity_platform import (
 from homeassistant.helpers.typing import ConfigType
 from homeassistant.util import color as color_util
 
-from . import KNXModule
 from .const import CONF_SYNC_STATE, DOMAIN, KNX_ADDRESS, KNX_MODULE_KEY, ColorTempModes
 from .entity import KnxUiEntity, KnxUiEntityPlatformController, KnxYamlEntity
+from .knx_module import KNXModule
 from .schema import LightSchema
 from .storage.const import (
+    CONF_COLOR,
     CONF_COLOR_TEMP_MAX,
     CONF_COLOR_TEMP_MIN,
-    CONF_DPT,
     CONF_ENTITY,
     CONF_GA_BLUE_BRIGHTNESS,
     CONF_GA_BLUE_SWITCH,
@@ -45,17 +45,15 @@ from .storage.const import (
     CONF_GA_GREEN_BRIGHTNESS,
     CONF_GA_GREEN_SWITCH,
     CONF_GA_HUE,
-    CONF_GA_PASSIVE,
     CONF_GA_RED_BRIGHTNESS,
     CONF_GA_RED_SWITCH,
     CONF_GA_SATURATION,
-    CONF_GA_STATE,
     CONF_GA_SWITCH,
     CONF_GA_WHITE_BRIGHTNESS,
     CONF_GA_WHITE_SWITCH,
-    CONF_GA_WRITE,
 )
 from .storage.entity_store_schema import LightColorMode
+from .storage.util import ConfigExtractor
 
 
 async def async_setup_entry(
@@ -203,94 +201,110 @@ def _create_yaml_light(xknx: XKNX, config: ConfigType) -> XknxLight:
 def _create_ui_light(xknx: XKNX, knx_config: ConfigType, name: str) -> XknxLight:
     """Return a KNX Light device to be used within XKNX."""
 
-    def get_write(key: str) -> str | None:
-        """Get the write group address."""
-        return knx_config[key][CONF_GA_WRITE] if key in knx_config else None
-
-    def get_state(key: str) -> list[Any] | None:
-        """Get the state group address."""
-        return (
-            [knx_config[key][CONF_GA_STATE], *knx_config[key][CONF_GA_PASSIVE]]
-            if key in knx_config
-            else None
-        )
-
-    def get_dpt(key: str) -> str | None:
-        """Get the DPT."""
-        return knx_config[key].get(CONF_DPT) if key in knx_config else None
+    conf = ConfigExtractor(knx_config)
 
     group_address_tunable_white = None
     group_address_tunable_white_state = None
     group_address_color_temp = None
     group_address_color_temp_state = None
+
     color_temperature_type = ColorTemperatureType.UINT_2_BYTE
-    if ga_color_temp := knx_config.get(CONF_GA_COLOR_TEMP):
-        if ga_color_temp[CONF_DPT] == ColorTempModes.RELATIVE.value:
-            group_address_tunable_white = ga_color_temp[CONF_GA_WRITE]
-            group_address_tunable_white_state = [
-                ga_color_temp[CONF_GA_STATE],
-                *ga_color_temp[CONF_GA_PASSIVE],
-            ]
+    if _color_temp_dpt := conf.get_dpt(CONF_GA_COLOR_TEMP):
+        if _color_temp_dpt == ColorTempModes.RELATIVE.value:
+            group_address_tunable_white = conf.get_write(CONF_GA_COLOR_TEMP)
+            group_address_tunable_white_state = conf.get_state_and_passive(
+                CONF_GA_COLOR_TEMP
+            )
         else:
             # absolute uint or float
-            group_address_color_temp = ga_color_temp[CONF_GA_WRITE]
-            group_address_color_temp_state = [
-                ga_color_temp[CONF_GA_STATE],
-                *ga_color_temp[CONF_GA_PASSIVE],
-            ]
-            if ga_color_temp[CONF_DPT] == ColorTempModes.ABSOLUTE_FLOAT.value:
+            group_address_color_temp = conf.get_write(CONF_GA_COLOR_TEMP)
+            group_address_color_temp_state = conf.get_state_and_passive(
+                CONF_GA_COLOR_TEMP
+            )
+            if _color_temp_dpt == ColorTempModes.ABSOLUTE_FLOAT.value:
                 color_temperature_type = ColorTemperatureType.FLOAT_2_BYTE
 
-    _color_dpt = get_dpt(CONF_GA_COLOR)
+    color_dpt = conf.get_dpt(CONF_COLOR, CONF_GA_COLOR)
+
     return XknxLight(
         xknx,
         name=name,
-        group_address_switch=get_write(CONF_GA_SWITCH),
-        group_address_switch_state=get_state(CONF_GA_SWITCH),
-        group_address_brightness=get_write(CONF_GA_BRIGHTNESS),
-        group_address_brightness_state=get_state(CONF_GA_BRIGHTNESS),
-        group_address_color=get_write(CONF_GA_COLOR)
-        if _color_dpt == LightColorMode.RGB
-        else None,
-        group_address_color_state=get_state(CONF_GA_COLOR)
-        if _color_dpt == LightColorMode.RGB
-        else None,
-        group_address_rgbw=get_write(CONF_GA_COLOR)
-        if _color_dpt == LightColorMode.RGBW
-        else None,
-        group_address_rgbw_state=get_state(CONF_GA_COLOR)
-        if _color_dpt == LightColorMode.RGBW
-        else None,
-        group_address_hue=get_write(CONF_GA_HUE),
-        group_address_hue_state=get_state(CONF_GA_HUE),
-        group_address_saturation=get_write(CONF_GA_SATURATION),
-        group_address_saturation_state=get_state(CONF_GA_SATURATION),
-        group_address_xyy_color=get_write(CONF_GA_COLOR)
-        if _color_dpt == LightColorMode.XYY
-        else None,
-        group_address_xyy_color_state=get_write(CONF_GA_COLOR)
-        if _color_dpt == LightColorMode.XYY
-        else None,
+        group_address_switch=conf.get_write(CONF_GA_SWITCH),
+        group_address_switch_state=conf.get_state_and_passive(CONF_GA_SWITCH),
+        group_address_brightness=conf.get_write(CONF_GA_BRIGHTNESS),
+        group_address_brightness_state=conf.get_state_and_passive(CONF_GA_BRIGHTNESS),
+        group_address_color=(
+            conf.get_write(CONF_COLOR, CONF_GA_COLOR)
+            if color_dpt == LightColorMode.RGB
+            else None
+        ),
+        group_address_color_state=(
+            conf.get_state_and_passive(CONF_COLOR, CONF_GA_COLOR)
+            if color_dpt == LightColorMode.RGB
+            else None
+        ),
+        group_address_rgbw=(
+            conf.get_write(CONF_COLOR, CONF_GA_COLOR)
+            if color_dpt == LightColorMode.RGBW
+            else None
+        ),
+        group_address_rgbw_state=(
+            conf.get_state_and_passive(CONF_COLOR, CONF_GA_COLOR)
+            if color_dpt == LightColorMode.RGBW
+            else None
+        ),
+        group_address_hue=conf.get_write(CONF_COLOR, CONF_GA_HUE),
+        group_address_hue_state=conf.get_state_and_passive(CONF_COLOR, CONF_GA_HUE),
+        group_address_saturation=conf.get_write(CONF_COLOR, CONF_GA_SATURATION),
+        group_address_saturation_state=conf.get_state_and_passive(
+            CONF_COLOR, CONF_GA_SATURATION
+        ),
+        group_address_xyy_color=(
+            conf.get_write(CONF_COLOR, CONF_GA_COLOR)
+            if color_dpt == LightColorMode.XYY
+            else None
+        ),
+        group_address_xyy_color_state=(
+            conf.get_state_and_passive(CONF_COLOR, CONF_GA_COLOR)
+            if color_dpt == LightColorMode.XYY
+            else None
+        ),
         group_address_tunable_white=group_address_tunable_white,
         group_address_tunable_white_state=group_address_tunable_white_state,
         group_address_color_temperature=group_address_color_temp,
         group_address_color_temperature_state=group_address_color_temp_state,
-        group_address_switch_red=get_write(CONF_GA_RED_SWITCH),
-        group_address_switch_red_state=get_state(CONF_GA_RED_SWITCH),
-        group_address_brightness_red=get_write(CONF_GA_RED_BRIGHTNESS),
-        group_address_brightness_red_state=get_state(CONF_GA_RED_BRIGHTNESS),
-        group_address_switch_green=get_write(CONF_GA_GREEN_SWITCH),
-        group_address_switch_green_state=get_state(CONF_GA_GREEN_SWITCH),
-        group_address_brightness_green=get_write(CONF_GA_GREEN_BRIGHTNESS),
-        group_address_brightness_green_state=get_state(CONF_GA_GREEN_BRIGHTNESS),
-        group_address_switch_blue=get_write(CONF_GA_BLUE_SWITCH),
-        group_address_switch_blue_state=get_state(CONF_GA_BLUE_SWITCH),
-        group_address_brightness_blue=get_write(CONF_GA_BLUE_BRIGHTNESS),
-        group_address_brightness_blue_state=get_state(CONF_GA_BLUE_BRIGHTNESS),
-        group_address_switch_white=get_write(CONF_GA_WHITE_SWITCH),
-        group_address_switch_white_state=get_state(CONF_GA_WHITE_SWITCH),
-        group_address_brightness_white=get_write(CONF_GA_WHITE_BRIGHTNESS),
-        group_address_brightness_white_state=get_state(CONF_GA_WHITE_BRIGHTNESS),
+        group_address_switch_red=conf.get_write(CONF_COLOR, CONF_GA_RED_SWITCH),
+        group_address_switch_red_state=conf.get_state_and_passive(
+            CONF_COLOR, CONF_GA_RED_SWITCH
+        ),
+        group_address_brightness_red=conf.get_write(CONF_COLOR, CONF_GA_RED_BRIGHTNESS),
+        group_address_brightness_red_state=conf.get_state_and_passive(
+            CONF_COLOR, CONF_GA_RED_BRIGHTNESS
+        ),
+        group_address_switch_green=conf.get_write(CONF_COLOR, CONF_GA_GREEN_SWITCH),
+        group_address_switch_green_state=conf.get_state_and_passive(
+            CONF_COLOR, CONF_GA_GREEN_SWITCH
+        ),
+        group_address_brightness_green=conf.get_write(CONF_GA_GREEN_BRIGHTNESS),
+        group_address_brightness_green_state=conf.get_state_and_passive(
+            CONF_COLOR, CONF_GA_GREEN_BRIGHTNESS
+        ),
+        group_address_switch_blue=conf.get_write(CONF_GA_BLUE_SWITCH),
+        group_address_switch_blue_state=conf.get_state_and_passive(CONF_GA_BLUE_SWITCH),
+        group_address_brightness_blue=conf.get_write(CONF_GA_BLUE_BRIGHTNESS),
+        group_address_brightness_blue_state=conf.get_state_and_passive(
+            CONF_COLOR, CONF_GA_BLUE_BRIGHTNESS
+        ),
+        group_address_switch_white=conf.get_write(CONF_COLOR, CONF_GA_WHITE_SWITCH),
+        group_address_switch_white_state=conf.get_state_and_passive(
+            CONF_COLOR, CONF_GA_WHITE_SWITCH
+        ),
+        group_address_brightness_white=conf.get_write(
+            CONF_COLOR, CONF_GA_WHITE_BRIGHTNESS
+        ),
+        group_address_brightness_white_state=conf.get_state_and_passive(
+            CONF_COLOR, CONF_GA_WHITE_BRIGHTNESS
+        ),
         color_temperature_type=color_temperature_type,
         min_kelvin=knx_config[CONF_COLOR_TEMP_MIN],
         max_kelvin=knx_config[CONF_COLOR_TEMP_MAX],

homeassistant/components/knx/manifest.json

@@ -13,7 +13,7 @@
   "requirements": [
     "xknx==3.8.0",
     "xknxproject==3.8.2",
-    "knx-frontend==2025.4.1.91934"
+    "knx-frontend==2025.7.23.50952"
   ],
   "single_config_entry": true
 }

homeassistant/components/knx/notify.py

@@ -1,4 +1,4 @@
-"""Support for KNX/IP notifications."""
+"""Support for KNX notify entities."""
 
 from __future__ import annotations
 
@@ -12,9 +12,9 @@ from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.helpers.typing import ConfigType
 
-from . import KNXModule
 from .const import KNX_ADDRESS, KNX_MODULE_KEY
 from .entity import KnxYamlEntity
+from .knx_module import KNXModule
 
 
 async def async_setup_entry(

homeassistant/components/knx/number.py

@@ -1,4 +1,4 @@
-"""Support for KNX/IP numeric values."""
+"""Support for KNX number entities."""
 
 from __future__ import annotations
 
@@ -22,9 +22,9 @@ from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.helpers.typing import ConfigType
 
-from . import KNXModule
 from .const import CONF_RESPOND_TO_READ, CONF_STATE_ADDRESS, KNX_ADDRESS, KNX_MODULE_KEY
 from .entity import KnxYamlEntity
+from .knx_module import KNXModule
 from .schema import NumberSchema
 
 

homeassistant/components/knx/quality_scale.yaml

@@ -104,7 +104,7 @@ rules:
       Since all entities are configured manually, names are user-defined.
   exception-translations: done
   icon-translations: done
-  reconfiguration-flow: todo
+  reconfiguration-flow: done
   repair-issues: todo
   stale-devices:
     status: exempt

homeassistant/components/knx/scene.py

@@ -1,4 +1,4 @@
-"""Support for KNX scenes."""
+"""Support for KNX scene entities."""
 
 from __future__ import annotations
 
@@ -13,9 +13,9 @@ from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.helpers.typing import ConfigType
 
-from . import KNXModule
 from .const import KNX_ADDRESS, KNX_MODULE_KEY
 from .entity import KnxYamlEntity
+from .knx_module import KNXModule
 from .schema import SceneSchema
 
 

homeassistant/components/knx/select.py

@@ -1,4 +1,4 @@
-"""Support for KNX/IP select entities."""
+"""Support for KNX select entities."""
 
 from __future__ import annotations
 
@@ -20,7 +20,6 @@ from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.helpers.restore_state import RestoreEntity
 from homeassistant.helpers.typing import ConfigType
 
-from . import KNXModule
 from .const import (
     CONF_PAYLOAD_LENGTH,
     CONF_RESPOND_TO_READ,
@@ -30,6 +29,7 @@ from .const import (
     KNX_MODULE_KEY,
 )
 from .entity import KnxYamlEntity
+from .knx_module import KNXModule
 from .schema import SelectSchema
 
 

homeassistant/components/knx/sensor.py

@@ -1,4 +1,4 @@
-"""Support for KNX/IP sensors."""
+"""Support for KNX sensor entities."""
 
 from __future__ import annotations
 
@@ -33,9 +33,9 @@ from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.helpers.typing import ConfigType, StateType
 from homeassistant.util.enum import try_parse_enum
 
-from . import KNXModule
 from .const import ATTR_SOURCE, KNX_MODULE_KEY
 from .entity import KnxYamlEntity
+from .knx_module import KNXModule
 from .schema import SensorSchema
 
 SCAN_INTERVAL = timedelta(seconds=10)

homeassistant/components/knx/services.py

@@ -35,13 +35,13 @@ from .expose import create_knx_exposure
 from .schema import ExposeSchema, dpt_base_type_validator, ga_validator
 
 if TYPE_CHECKING:
-    from . import KNXModule
+    from .knx_module import KNXModule
 
 _LOGGER = logging.getLogger(__name__)
 
 
 @callback
-def register_knx_services(hass: HomeAssistant) -> None:
+def async_setup_services(hass: HomeAssistant) -> None:
     """Register KNX integration services."""
     hass.services.async_register(
         DOMAIN,

homeassistant/components/knx/storage/__init__.py

@@ -1 +1 @@
-"""Helpers for KNX."""
+"""Handle persistent storage for the KNX integration."""