Error in light.py

[digidolphin]

After upgrading to 2026.3.2 i got the error below. I have fixed it in the attached light.py.
Error setting up entry My home for smartthings

Traceback (most recent call last):
  File "/usr/src/homeassistant/homeassistant/config_entries.py", line 769, in __async_setup_with_context
    result = await component.async_setup_entry(hass, self)
             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "/config/custom_components/smartthings/__init__.py", line 157, in async_setup_entry
    broker = DeviceBroker(hass, entry, token, smart_app, devices, scenes)
  File "/config/custom_components/smartthings/__init__.py", line 280, in __init__
    self._assignments = self._assign_capabilities(devices)
                        ~~~~~~~~~~~~~~~~~~~~~~~~~^^^^^^^^^
  File "/config/custom_components/smartthings/__init__.py", line 291, in _assign_capabilities
    platform_module = importlib.import_module(
        f".{platform}", self.__module__
    )
  File "/usr/src/homeassistant/homeassistant/util/loop.py", line 201, in protected_loop_func
    return func(*args, **kwargs)
  File "/usr/local/lib/python3.14/importlib/__init__.py", line 88, in import_module
    return _bootstrap._gcd_import(name[level:], package, level)
           ~~~~~~~~~~~~~~~~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "<frozen importlib._bootstrap>", line 1398, in _gcd_import
  File "<frozen importlib._bootstrap>", line 1371, in _find_and_load
  File "<frozen importlib._bootstrap>", line 1342, in _find_and_load_unlocked
  File "<frozen importlib._bootstrap>", line 938, in _load_unlocked
  File "<frozen importlib._bootstrap_external>", line 759, in exec_module
  File "<frozen importlib._bootstrap>", line 491, in _call_with_frames_removed
  File "/config/custom_components/smartthings/light.py", line 9, in <module>
    from homeassistant.components.light import (
    ...<9 lines>...
    )
ImportError: cannot import name 'ATTR_COLOR_TEMP' from 'homeassistant.components.light' (/usr/src/homeassistant/homeassistant/components/light/__init__.py)

light.py

[TimPasquini]

I had the same issue, looks like it's a HA API change. I used an LLM to remap it and it seems to be working for me again.

Replace your light.py with:

from __future__ import annotations

import asyncio
from collections.abc import Sequence

from pysmartthings import Capability

from homeassistant.components.light import (
    ATTR_BRIGHTNESS,
    ATTR_COLOR_TEMP_KELVIN,
    ATTR_HS_COLOR,
    ATTR_TRANSITION,
    ColorMode,
    LightEntity,
    LightEntityFeature,
)
import homeassistant.util.color as color_util

from . import SmartThingsEntity
from .const import DATA_BROKERS, DOMAIN


async def async_setup_entry(hass, config_entry, async_add_entities):
    """Add lights for a config entry."""
    broker = hass.data[DOMAIN][DATA_BROKERS][config_entry.entry_id]
    async_add_entities(
        [
            SmartThingsLight(device)
            for device in broker.devices.values()
            if broker.any_assigned(device.device_id, "light")
        ],
        True,
    )


def get_capabilities(capabilities: Sequence[str]) -> Sequence[str] | None:
    """Return all capabilities supported if minimum required are present."""
    supported = [
        Capability.switch,
        Capability.switch_level,
        Capability.color_control,
        Capability.color_temperature,
    ]
    # Must be able to be turned on/off.
    if Capability.switch not in capabilities:
        return None
    # Must have one of these.
    light_capabilities = [
        Capability.color_control,
        Capability.color_temperature,
        Capability.switch_level,
    ]
    if any(capability in capabilities for capability in light_capabilities):
        return supported
    return None


def convert_scale(value, value_scale, target_scale, round_digits=4):
    """Convert a value to a different scale."""
    return round(value * target_scale / value_scale, round_digits)


class SmartThingsLight(SmartThingsEntity, LightEntity):
    """Define a SmartThings Light."""

    def __init__(self, device):
        """Initialize a SmartThingsLight."""
        super().__init__(device)
        self._brightness = None
        self._color_temp_kelvin = None
        self._hs_color = None

        self._supports_level = Capability.switch_level in self._device.capabilities
        self._supports_color_temp = (
            Capability.color_temperature in self._device.capabilities
        )
        self._supports_color = Capability.color_control in self._device.capabilities

        self._attr_supported_features = self._determine_supported_features()
        self._attr_supported_color_modes = self._determine_supported_color_modes()

    def _determine_supported_features(self) -> LightEntityFeature:
        """Get extra features supported by the device."""
        features = LightEntityFeature(0)
        if self._supports_level:
            features |= LightEntityFeature.TRANSITION
        return features

    def _determine_supported_color_modes(self) -> set[ColorMode]:
        """Get supported color modes for the device."""
        color_modes: set[ColorMode] = set()

        if self._supports_color:
            color_modes.add(ColorMode.HS)
        if self._supports_color_temp:
            color_modes.add(ColorMode.COLOR_TEMP)
        if self._supports_level:
            color_modes.add(ColorMode.BRIGHTNESS)

        if not color_modes:
            color_modes.add(ColorMode.ONOFF)

        return color_modes

    async def async_turn_on(self, **kwargs) -> None:
        """Turn the light on."""
        tasks = []

        # Color temperature
        if self._supports_color_temp and ATTR_COLOR_TEMP_KELVIN in kwargs:
            tasks.append(
                self.async_set_color_temp_kelvin(kwargs[ATTR_COLOR_TEMP_KELVIN])
            )

        # Color
        if self._supports_color and ATTR_HS_COLOR in kwargs:
            tasks.append(self.async_set_color(kwargs[ATTR_HS_COLOR]))

        if tasks:
            # Set temp/color first.
            await asyncio.gather(*tasks)

        # Switch/brightness/transition
        if self._supports_level and ATTR_BRIGHTNESS in kwargs:
            await self.async_set_level(
                kwargs[ATTR_BRIGHTNESS], kwargs.get(ATTR_TRANSITION, 0)
            )
        else:
            await self._device.switch_on(set_status=True)

        # State is set optimistically in the commands above, therefore update
        # the entity state ahead of receiving the confirming push updates.
        self.async_schedule_update_ha_state(True)

    async def async_turn_off(self, **kwargs) -> None:
        """Turn the light off."""
        # Switch/transition
        if self._supports_level and ATTR_TRANSITION in kwargs:
            await self.async_set_level(0, int(kwargs[ATTR_TRANSITION]))
        else:
            await self._device.switch_off(set_status=True)

        # State is set optimistically in the commands above, therefore update
        # the entity state ahead of receiving the confirming push updates.
        self.async_schedule_update_ha_state(True)

    async def async_update(self):
        """Update entity attributes when the device status has changed."""
        # Brightness
        if self._supports_level:
            self._brightness = int(
                convert_scale(self._device.status.level, 100, 255, 0)
            )

        # Color Temperature
        if self._supports_color_temp:
            self._color_temp_kelvin = self._device.status.color_temperature

        # Color
        if self._supports_color:
            self._hs_color = (
                convert_scale(self._device.status.hue, 100, 360),
                self._device.status.saturation,
            )

    async def async_set_color(self, hs_color):
        """Set the color of the device."""
        hue = convert_scale(float(hs_color[0]), 360, 100)
        hue = max(min(hue, 100.0), 0.0)
        saturation = max(min(float(hs_color[1]), 100.0), 0.0)
        await self._device.set_color(hue, saturation, set_status=True)

    async def async_set_color_temp_kelvin(self, value: float):
        """Set the color temperature of the device."""
        kelvin = max(min(float(value), 30000.0), 1.0)
        await self._device.set_color_temperature(kelvin, set_status=True)

    async def async_set_level(self, brightness: int, transition: int):
        """Set the brightness of the light over transition."""
        level = int(convert_scale(brightness, 255, 100, 0))
        # Due to rounding, set level to 1 (one) so we don't inadvertently
        # turn off the light when a low brightness is set.
        level = 1 if level == 0 and brightness > 0 else level
        level = max(min(level, 100), 0)
        duration = int(transition)
        await self._device.set_level(level, duration, set_status=True)

    @property
    def brightness(self):
        """Return the brightness of this light between 0..255."""
        return self._brightness

    @property
    def color_temp_kelvin(self):
        """Return the color temperature in Kelvin."""
        return self._color_temp_kelvin

    @property
    def hs_color(self):
        """Return the hue and saturation color value [float, float]."""
        return self._hs_color

    @property
    def color_mode(self) -> ColorMode:
        """Return the active color mode."""
        if not self.is_on:
            # Must still return a valid supported mode.
            if ColorMode.HS in self.supported_color_modes:
                return ColorMode.HS
            if ColorMode.COLOR_TEMP in self.supported_color_modes:
                return ColorMode.COLOR_TEMP
            if ColorMode.BRIGHTNESS in self.supported_color_modes:
                return ColorMode.BRIGHTNESS
            return ColorMode.ONOFF

        if self._supports_color and self._hs_color is not None:
            return ColorMode.HS
        if self._supports_color_temp and self._color_temp_kelvin is not None:
            return ColorMode.COLOR_TEMP
        if self._supports_level:
            return ColorMode.BRIGHTNESS
        return ColorMode.ONOFF

    @property
    def is_on(self) -> bool:
        """Return true if light is on."""
        return self._device.status.switch

    @property
    def min_color_temp_kelvin(self):
        """Return the warmest color temperature that this light supports."""
        # SmartThings does not expose this attribute, instead it's
        # implemented within each device-type handler. This value is the
        # lowest kelvin found supported across 20+ handlers.
        return 2000

    @property
    def max_color_temp_kelvin(self):
        """Return the coldest color temperature that this light supports."""
        # SmartThings does not expose this attribute, instead it's
        # implemented within each device-type handler. This value is the
        # highest kelvin found supported across 20+ handlers.
        return 9000```