PySwitchbot 0.65.0__tar.gz → 0.67.0__tar.gz

{pyswitchbot-0.65.0 → pyswitchbot-0.67.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PySwitchbot
-Version: 0.65.0
+Version: 0.67.0
 Summary: A library to communicate with Switchbot
 Home-page: https://github.com/sblibs/pySwitchbot/
 Author: Daniel Hjelseth Hoyer

{pyswitchbot-0.65.0 → pyswitchbot-0.67.0}/PySwitchbot.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PySwitchbot
-Version: 0.65.0
+Version: 0.67.0
 Summary: A library to communicate with Switchbot
 Home-page: https://github.com/sblibs/pySwitchbot/
 Author: Daniel Hjelseth Hoyer

{pyswitchbot-0.65.0 → pyswitchbot-0.67.0}/PySwitchbot.egg-info/SOURCES.txt

@@ -45,6 +45,7 @@ switchbot/const/evaporative_humidifier.py
 switchbot/const/fan.py
 switchbot/const/hub2.py
 switchbot/const/hub3.py
+switchbot/const/light.py
 switchbot/const/lock.py
 switchbot/devices/__init__.py
 switchbot/devices/air_purifier.py
@@ -73,7 +74,11 @@ tests/test_adv_parser.py
 tests/test_air_purifier.py
 tests/test_base_cover.py
 tests/test_blind_tilt.py
+tests/test_bulb.py
+tests/test_ceiling_light.py
+tests/test_colormode_imports.py
 tests/test_curtain.py
+tests/test_encrypted_device.py
 tests/test_evaporative_humidifier.py
 tests/test_fan.py
 tests/test_helpers.py
@@ -82,4 +87,5 @@ tests/test_hub3.py
 tests/test_lock.py
 tests/test_relay_switch.py
 tests/test_roller_shade.py
+tests/test_strip_light.py
 tests/test_vacuum.py

{pyswitchbot-0.65.0 → pyswitchbot-0.67.0}/setup.py

@@ -20,7 +20,7 @@ setup(
         "cryptography>=39.0.0",
         "pyOpenSSL>=23.0.0",
     ],
-    version="0.65.0",
+    version="0.67.0",
     description="A library to communicate with Switchbot",
     long_description=long_description,
     long_description_content_type="text/markdown",

{pyswitchbot-0.65.0 → pyswitchbot-0.67.0}/switchbot/__init__.py

@@ -11,11 +11,15 @@ from bleak_retry_connector import (
 from .adv_parser import SwitchbotSupportedType, parse_advertisement_data
 from .const import (
     AirPurifierMode,
+    BulbColorMode,
+    CeilingLightColorMode,
+    ColorMode,
     FanMode,
     HumidifierAction,
     HumidifierMode,
     HumidifierWaterLevel,
     LockStatus,
+    StripLightColorMode,
     SwitchbotAccountConnectionError,
     SwitchbotApiError,
     SwitchbotAuthenticationError,
@@ -28,11 +32,11 @@ from .devices.bot import Switchbot
 from .devices.bulb import SwitchbotBulb
 from .devices.ceiling_light import SwitchbotCeilingLight
 from .devices.curtain import SwitchbotCurtain
-from .devices.device import ColorMode, SwitchbotDevice, SwitchbotEncryptedDevice
+from .devices.device import SwitchbotDevice, SwitchbotEncryptedDevice
 from .devices.evaporative_humidifier import SwitchbotEvaporativeHumidifier
 from .devices.fan import SwitchbotFan
 from .devices.humidifier import SwitchbotHumidifier
-from .devices.light_strip import SwitchbotLightStrip
+from .devices.light_strip import SwitchbotLightStrip, SwitchbotStripLight3
 from .devices.lock import SwitchbotLock
 from .devices.plug import SwitchbotPlugMini
 from .devices.relay_switch import SwitchbotRelaySwitch, SwitchbotRelaySwitch2PM
@@ -43,6 +47,8 @@ from .models import SwitchBotAdvertisement
 
 __all__ = [
     "AirPurifierMode",
+    "BulbColorMode",
+    "CeilingLightColorMode",
     "ColorMode",
     "FanMode",
     "GetSwitchbotDevices",
@@ -50,6 +56,7 @@ __all__ = [
     "HumidifierMode",
     "HumidifierWaterLevel",
     "LockStatus",
+    "StripLightColorMode",
     "SwitchBotAdvertisement",
     "Switchbot",
     "Switchbot",
@@ -76,6 +83,7 @@ __all__ = [
     "SwitchbotRelaySwitch",
     "SwitchbotRelaySwitch2PM",
     "SwitchbotRollerShade",
+    "SwitchbotStripLight3",
     "SwitchbotSupportedType",
     "SwitchbotSupportedType",
     "SwitchbotVacuum",

{pyswitchbot-0.65.0 → pyswitchbot-0.67.0}/switchbot/adv_parser.py

@@ -24,8 +24,13 @@ from .adv_parsers.hubmini_matter import process_hubmini_matter
 from .adv_parsers.humidifier import process_evaporative_humidifier, process_wohumidifier
 from .adv_parsers.keypad import process_wokeypad
 from .adv_parsers.leak import process_leak
-from .adv_parsers.light_strip import process_wostrip
-from .adv_parsers.lock import process_lock2, process_wolock, process_wolock_pro
+from .adv_parsers.light_strip import process_light, process_wostrip
+from .adv_parsers.lock import (
+    process_lock2,
+    process_locklite,
+    process_wolock,
+    process_wolock_pro,
+)
 from .adv_parsers.meter import process_wosensorth, process_wosensorth_c
 from .adv_parsers.motion import process_wopresence
 from .adv_parsers.plug import process_woplugmini
@@ -304,7 +309,7 @@ SUPPORTED_TYPES: dict[str | bytes, SwitchbotSupportedType] = {
     "-": {
         "modelName": SwitchbotModel.LOCK_LITE,
         "modelFriendlyName": "Lock Lite",
-        "func": process_wolock,
+        "func": process_locklite,
         "manufacturer_id": 2409,
     },
     b"\x00\x10\xa5\xb8": {
@@ -325,6 +330,18 @@ SUPPORTED_TYPES: dict[str | bytes, SwitchbotSupportedType] = {
         "func": process_relay_switch_2pm,
         "manufacturer_id": 2409,
     },
+    b"\x00\x10\xd0\xb0": {
+        "modelName": SwitchbotModel.FLOOR_LAMP,
+        "modelFriendlyName": "Floor Lamp",
+        "func": process_light,
+        "manufacturer_id": 2409,
+    },
+    b"\x00\x10\xd0\xb1": {
+        "modelName": SwitchbotModel.STRIP_LIGHT_3,
+        "modelFriendlyName": "Strip Light 3",
+        "func": process_light,
+        "manufacturer_id": 2409,
+    },
 }
 
 _SWITCHBOT_MODEL_TO_CHAR = {

pyswitchbot-0.67.0/switchbot/adv_parsers/light_strip.py

@@ -0,0 +1,32 @@
+"""Light strip adv parser."""
+
+from __future__ import annotations
+
+import struct
+
+
+def process_wostrip(
+    data: bytes | None, mfr_data: bytes | None
+) -> dict[str, bool | int]:
+    """Process WoStrip services data."""
+    if mfr_data is None:
+        return {}
+    return {
+        "sequence_number": mfr_data[6],
+        "isOn": bool(mfr_data[7] & 0b10000000),
+        "brightness": mfr_data[7] & 0b01111111,
+        "delay": bool(mfr_data[8] & 0b10000000),
+        "network_state": (mfr_data[8] & 0b01110000) >> 4,
+        "color_mode": mfr_data[8] & 0b00001111,
+    }
+
+
+def process_light(data: bytes | None, mfr_data: bytes | None) -> dict[str, bool | int]:
+    """Support for strip light 3 and floor lamp."""
+    common_data = process_wostrip(data, mfr_data)
+    if not common_data:
+        return {}
+
+    light_data = {"cw": struct.unpack(">H", mfr_data[16:18])[0]}
+
+    return common_data | light_data

{pyswitchbot-0.65.0 → pyswitchbot-0.67.0}/switchbot/adv_parsers/lock.py

@@ -11,6 +11,21 @@ _LOGGER = logging.getLogger(__name__)
 
 def process_wolock(data: bytes | None, mfr_data: bytes | None) -> dict[str, bool | int]:
     """Support for lock and lock lite process data."""
+    common_data = process_locklite(data, mfr_data)
+    if not common_data:
+        return {}
+
+    common_data["door_open"] = bool(mfr_data[7] & 0b00000100)
+    common_data["unclosed_alarm"] = bool(mfr_data[8] & 0b00100000)
+    common_data["auto_lock_paused"] = bool(mfr_data[8] & 0b00000010)
+
+    return common_data
+
+
+def process_locklite(
+    data: bytes | None, mfr_data: bytes | None
+) -> dict[str, bool | int]:
+    """Support for lock lite process data."""
     if mfr_data is None:
         return {}
 
@@ -24,11 +39,8 @@ def process_wolock(data: bytes | None, mfr_data: bytes | None) -> dict[str, bool
         "calibration": bool(mfr_data[7] & 0b10000000),
         "status": LockStatus((mfr_data[7] & 0b01110000) >> 4),
         "update_from_secondary_lock": bool(mfr_data[7] & 0b00001000),
-        "door_open": bool(mfr_data[7] & 0b00000100),
         "double_lock_mode": bool(mfr_data[8] & 0b10000000),
-        "unclosed_alarm": bool(mfr_data[8] & 0b00100000),
         "unlocked_alarm": bool(mfr_data[8] & 0b00010000),
-        "auto_lock_paused": bool(mfr_data[8] & 0b00000010),
         "night_latch": bool(mfr_data[9] & 0b00000001) if len(mfr_data) > 9 else False,
     }
 
@@ -37,10 +49,11 @@ def parse_common_data(mfr_data: bytes | None) -> dict[str, bool | int]:
     if mfr_data is None:
         return {}
 
+    _LOGGER.debug("mfr_data: %s", mfr_data.hex())
     return {
         "sequence_number": mfr_data[6],
         "calibration": bool(mfr_data[7] & 0b10000000),
-        "status": LockStatus((mfr_data[7] & 0b01111000) >> 4),
+        "status": LockStatus((mfr_data[7] & 0b01111000) >> 3),
         "update_from_secondary_lock": bool(mfr_data[8] & 0b11000000),
         "door_open_from_secondary_lock": bool(mfr_data[8] & 0b00100000),
         "door_open": bool(mfr_data[8] & 0b00010000),

{pyswitchbot-0.65.0 → pyswitchbot-0.67.0}/switchbot/const/__init__.py

@@ -10,6 +10,12 @@ from .evaporative_humidifier import (
     HumidifierWaterLevel,
 )
 from .fan import FanMode
+from .light import (
+    BulbColorMode,
+    CeilingLightColorMode,
+    ColorMode,
+    StripLightColorMode,
+)
 
 # Preserve old LockStatus export for backwards compatibility
 from .lock import LockStatus
@@ -85,6 +91,8 @@ class SwitchbotModel(StrEnum):
     LOCK_LITE = "Lock Lite"
     GARAGE_DOOR_OPENER = "Garage Door Opener"
     RELAY_SWITCH_2PM = "Relay Switch 2PM"
+    STRIP_LIGHT_3 = "Strip Light 3"
+    FLOOR_LAMP = "Floor Lamp"
 
 
 __all__ = [
@@ -92,11 +100,15 @@ __all__ = [
     "DEFAULT_RETRY_TIMEOUT",
     "DEFAULT_SCAN_TIMEOUT",
     "AirPurifierMode",
+    "BulbColorMode",
+    "CeilingLightColorMode",
+    "ColorMode",
     "FanMode",
     "HumidifierAction",
     "HumidifierMode",
     "HumidifierWaterLevel",
     "LockStatus",
+    "StripLightColorMode",
     "SwitchbotAccountConnectionError",
     "SwitchbotApiError",
     "SwitchbotAuthenticationError",

pyswitchbot-0.67.0/switchbot/const/light.py

@@ -0,0 +1,34 @@
+from enum import Enum
+
+
+class ColorMode(Enum):
+    OFF = 0
+    COLOR_TEMP = 1
+    RGB = 2
+    EFFECT = 3
+
+
+class StripLightColorMode(Enum):
+    RGB = 2
+    SCENE = 3
+    MUSIC = 4
+    CONTROLLER = 5
+    COLOR_TEMP = 6
+    UNKNOWN = 10
+
+
+class BulbColorMode(Enum):
+    COLOR_TEMP = 1
+    RGB = 2
+    DYNAMIC = 3
+    UNKNOWN = 10
+
+
+class CeilingLightColorMode(Enum):
+    COLOR_TEMP = 0
+    NIGHT = 1
+    MUSIC = 4
+    UNKNOWN = 10
+
+
+DEFAULT_COLOR_TEMP = 4001

{pyswitchbot-0.65.0 → pyswitchbot-0.67.0}/switchbot/devices/air_purifier.py

@@ -21,8 +21,6 @@ _LOGGER = logging.getLogger(__name__)
 
 
 COMMAND_HEAD = "570f4c"
-COMMAND_TURN_OFF = f"{COMMAND_HEAD}010000"
-COMMAND_TURN_ON = f"{COMMAND_HEAD}010100"
 COMMAND_SET_MODE = {
     AirPurifierMode.LEVEL_1.name.lower(): f"{COMMAND_HEAD}01010100",
     AirPurifierMode.LEVEL_2.name.lower(): f"{COMMAND_HEAD}01010132",
@@ -37,6 +35,9 @@ DEVICE_GET_BASIC_SETTINGS_KEY = "570f4d81"
 class SwitchbotAirPurifier(SwitchbotSequenceDevice, SwitchbotEncryptedDevice):
     """Representation of a Switchbot Air Purifier."""
 
+    _turn_on_command = f"{COMMAND_HEAD}010100"
+    _turn_off_command = f"{COMMAND_HEAD}010000"
+
     def __init__(
         self,
         device: BLEDevice,
@@ -109,18 +110,6 @@ class SwitchbotAirPurifier(SwitchbotSequenceDevice, SwitchbotEncryptedDevice):
         result = await self._send_command(COMMAND_SET_MODE[preset_mode])
         return self._check_command_result(result, 0, {1})
 
-    @update_after_operation
-    async def turn_on(self) -> bool:
-        """Turn on the air purifier."""
-        result = await self._send_command(COMMAND_TURN_ON)
-        return self._check_command_result(result, 0, {1})
-
-    @update_after_operation
-    async def turn_off(self) -> bool:
-        """Turn off the air purifier."""
-        result = await self._send_command(COMMAND_TURN_OFF)
-        return self._check_command_result(result, 0, {1})
-
     def get_current_percentage(self) -> Any:
         """Return cached percentage."""
         return self._get_adv_value("speed")

pyswitchbot-0.67.0/switchbot/devices/base_light.py

@@ -0,0 +1,179 @@
+from __future__ import annotations
+
+import logging
+from abc import abstractmethod
+from typing import Any
+
+from ..helpers import create_background_task
+from ..models import SwitchBotAdvertisement
+from .device import SwitchbotDevice, SwitchbotOperationError, update_after_operation
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class SwitchbotBaseLight(SwitchbotDevice):
+    """Representation of a Switchbot light."""
+
+    _effect_dict: dict[str, list[str]] = {}
+    _set_brightness_command: str = ""
+    _set_color_temp_command: str = ""
+    _set_rgb_command: str = ""
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        """Switchbot base light constructor."""
+        super().__init__(*args, **kwargs)
+        self._state: dict[str, Any] = {}
+
+    @property
+    def on(self) -> bool | None:
+        """Return if light is on."""
+        return self.is_on()
+
+    @property
+    def rgb(self) -> tuple[int, int, int] | None:
+        """Return the current rgb value."""
+        if "r" not in self._state or "g" not in self._state or "b" not in self._state:
+            return None
+        return self._state["r"], self._state["g"], self._state["b"]
+
+    @property
+    def color_temp(self) -> int | None:
+        """Return the current color temp value."""
+        return self._state.get("cw") or self.min_temp
+
+    @property
+    def brightness(self) -> int | None:
+        """Return the current brightness value."""
+        return self._get_adv_value("brightness") or 0
+
+    @property
+    @abstractmethod
+    def color_mode(self) -> Any:
+        """Return the current color mode."""
+        raise NotImplementedError("Subclasses must implement color mode")
+
+    @property
+    def min_temp(self) -> int:
+        """Return minimum color temp."""
+        return 2700
+
+    @property
+    def max_temp(self) -> int:
+        """Return maximum color temp."""
+        return 6500
+
+    @property
+    def get_effect_list(self) -> list[str] | None:
+        """Return the list of supported effects."""
+        return list(self._effect_dict) if self._effect_dict else None
+
+    def is_on(self) -> bool | None:
+        """Return bulb state from cache."""
+        return self._get_adv_value("isOn")
+
+    def get_effect(self):
+        """Return the current effect."""
+        return self._get_adv_value("effect")
+
+    @update_after_operation
+    async def set_brightness(self, brightness: int) -> bool:
+        """Set brightness."""
+        assert 0 <= brightness <= 100, "Brightness must be between 0 and 100"
+        hex_brightness = f"{brightness:02X}"
+        self._check_function_support(self._set_brightness_command)
+        result = await self._send_command(
+            self._set_brightness_command.format(hex_brightness)
+        )
+        return self._check_command_result(result, 0, {1})
+
+    @update_after_operation
+    async def set_color_temp(self, brightness: int, color_temp: int) -> bool:
+        """Set color temp."""
+        assert 0 <= brightness <= 100, "Brightness must be between 0 and 100"
+        assert 2700 <= color_temp <= 6500, "Color Temp must be between 2700 and 6500"
+        hex_data = f"{brightness:02X}{color_temp:04X}"
+        self._check_function_support(self._set_color_temp_command)
+        result = await self._send_command(self._set_color_temp_command.format(hex_data))
+        return self._check_command_result(result, 0, {1})
+
+    @update_after_operation
+    async def set_rgb(self, brightness: int, r: int, g: int, b: int) -> bool:
+        """Set rgb."""
+        assert 0 <= brightness <= 100, "Brightness must be between 0 and 100"
+        assert 0 <= r <= 255, "r must be between 0 and 255"
+        assert 0 <= g <= 255, "g must be between 0 and 255"
+        assert 0 <= b <= 255, "b must be between 0 and 255"
+        self._check_function_support(self._set_rgb_command)
+        hex_data = f"{brightness:02X}{r:02X}{g:02X}{b:02X}"
+        result = await self._send_command(self._set_rgb_command.format(hex_data))
+        return self._check_command_result(result, 0, {1})
+
+    @update_after_operation
+    async def set_effect(self, effect: str) -> bool:
+        """Set effect."""
+        effect_template = self._effect_dict.get(effect.lower())
+        if not effect_template:
+            raise SwitchbotOperationError(f"Effect {effect} not supported")
+        result = await self._send_multiple_commands(effect_template)
+        if result:
+            self._override_state({"effect": effect})
+        return result
+
+    async def _send_multiple_commands(self, keys: list[str]) -> bool:
+        """
+        Send multiple commands to device.
+
+        Since we current have no way to tell which command the device
+        needs we send both.
+        """
+        final_result = False
+        for key in keys:
+            result = await self._send_command(key)
+            final_result |= self._check_command_result(result, 0, {1})
+        return final_result
+
+    async def _get_multi_commands_results(
+        self, commands: list[str]
+    ) -> tuple[bytes, bytes] | None:
+        """Check results after sending multiple commands."""
+        if not (results := await self._get_basic_info_by_multi_commands(commands)):
+            return None
+
+        _version_info, _data = results[0], results[1]
+        _LOGGER.debug(
+            "version info: %s, data: %s, address: %s",
+            _version_info,
+            _data,
+            self._device.address,
+        )
+        return _version_info, _data
+
+    async def _get_basic_info_by_multi_commands(
+        self, commands: list[str]
+    ) -> list[bytes] | None:
+        """Get device basic settings by sending multiple commands."""
+        results = []
+        for command in commands:
+            if not (result := await self._get_basic_info(command)):
+                return None
+            results.append(result)
+        return results
+
+
+class SwitchbotSequenceBaseLight(SwitchbotBaseLight):
+    """Representation of a Switchbot light."""
+
+    def update_from_advertisement(self, advertisement: SwitchBotAdvertisement) -> None:
+        """Update device data from advertisement."""
+        current_state = self._get_adv_value("sequence_number")
+        super().update_from_advertisement(advertisement)
+        new_state = self._get_adv_value("sequence_number")
+        _LOGGER.debug(
+            "%s: update advertisement: %s (seq before: %s) (seq after: %s)",
+            self.name,
+            advertisement,
+            current_state,
+            new_state,
+        )
+        if current_state != new_state:
+            create_background_task(self.update())

pyswitchbot-0.67.0/switchbot/devices/bulb.py

@@ -0,0 +1,66 @@
+from __future__ import annotations
+
+from typing import Any
+
+from ..const.light import BulbColorMode, ColorMode
+from .base_light import SwitchbotSequenceBaseLight
+
+# Private mapping from device-specific color modes to original ColorMode enum
+_BULB_COLOR_MODE_MAP = {
+    BulbColorMode.COLOR_TEMP: ColorMode.COLOR_TEMP,
+    BulbColorMode.RGB: ColorMode.RGB,
+    BulbColorMode.DYNAMIC: ColorMode.EFFECT,
+    BulbColorMode.UNKNOWN: ColorMode.OFF,
+}
+COLOR_BULB_CONTROL_HEADER = "570F4701"
+
+
+class SwitchbotBulb(SwitchbotSequenceBaseLight):
+    """Representation of a Switchbot bulb."""
+
+    _turn_on_command = f"{COLOR_BULB_CONTROL_HEADER}01"
+    _turn_off_command = f"{COLOR_BULB_CONTROL_HEADER}02"
+    _set_rgb_command = f"{COLOR_BULB_CONTROL_HEADER}12{{}}"
+    _set_color_temp_command = f"{COLOR_BULB_CONTROL_HEADER}13{{}}"
+    _set_brightness_command = f"{COLOR_BULB_CONTROL_HEADER}14{{}}"
+    _get_basic_info_command = ["570003", "570f4801"]
+    _effect_dict = {
+        "colorful": ["570F4701010300"],
+        "flickering": ["570F4701010301"],
+        "breathing": ["570F4701010302"],
+    }
+
+    @property
+    def color_modes(self) -> set[ColorMode]:
+        """Return the supported color modes."""
+        return {ColorMode.RGB, ColorMode.COLOR_TEMP}
+
+    @property
+    def color_mode(self) -> ColorMode:
+        """Return the current color mode."""
+        device_mode = BulbColorMode(self._get_adv_value("color_mode") or 10)
+        return _BULB_COLOR_MODE_MAP.get(device_mode, ColorMode.OFF)
+
+    async def get_basic_info(self) -> dict[str, Any] | None:
+        """Get device basic settings."""
+        if not (
+            res := await self._get_multi_commands_results(self._get_basic_info_command)
+        ):
+            return None
+        _version_info, _data = res
+
+        self._state["r"] = _data[3]
+        self._state["g"] = _data[4]
+        self._state["b"] = _data[5]
+        self._state["cw"] = int.from_bytes(_data[6:8], "big")
+
+        return {
+            "isOn": bool(_data[1] & 0b10000000),
+            "brightness": _data[2] & 0b01111111,
+            "r": self._state["r"],
+            "g": self._state["g"],
+            "b": self._state["b"],
+            "cw": self._state["cw"],
+            "color_mode": _data[10] & 0b00001111,
+            "firmware": _version_info[2] / 10.0,
+        }

pyswitchbot-0.67.0/switchbot/devices/ceiling_light.py

@@ -0,0 +1,69 @@
+from __future__ import annotations
+
+from typing import Any
+
+from ..const.light import (
+    DEFAULT_COLOR_TEMP,
+    CeilingLightColorMode,
+    ColorMode,
+)
+from .base_light import SwitchbotSequenceBaseLight
+from .device import update_after_operation
+
+# Private mapping from device-specific color modes to original ColorMode enum
+_CEILING_LIGHT_COLOR_MODE_MAP = {
+    CeilingLightColorMode.COLOR_TEMP: ColorMode.COLOR_TEMP,
+    CeilingLightColorMode.NIGHT: ColorMode.COLOR_TEMP,
+    CeilingLightColorMode.MUSIC: ColorMode.EFFECT,
+    CeilingLightColorMode.UNKNOWN: ColorMode.OFF,
+}
+CEILING_LIGHT_CONTROL_HEADER = "570F5401"
+
+
+class SwitchbotCeilingLight(SwitchbotSequenceBaseLight):
+    """Representation of a Switchbot ceiling light."""
+
+    _turn_on_command = f"{CEILING_LIGHT_CONTROL_HEADER}01FF01FFFF"
+    _turn_off_command = f"{CEILING_LIGHT_CONTROL_HEADER}02FF01FFFF"
+    _set_brightness_command = f"{CEILING_LIGHT_CONTROL_HEADER}01FF01{{}}"
+    _set_color_temp_command = f"{CEILING_LIGHT_CONTROL_HEADER}01FF01{{}}"
+    _get_basic_info_command = ["5702", "570f5581"]
+
+    @property
+    def color_modes(self) -> set[ColorMode]:
+        """Return the supported color modes."""
+        return {ColorMode.COLOR_TEMP}
+
+    @property
+    def color_mode(self) -> ColorMode:
+        """Return the current color mode."""
+        device_mode = CeilingLightColorMode(self._get_adv_value("color_mode") or 10)
+        return _CEILING_LIGHT_COLOR_MODE_MAP.get(device_mode, ColorMode.OFF)
+
+    @update_after_operation
+    async def set_brightness(self, brightness: int) -> bool:
+        """Set brightness."""
+        assert 0 <= brightness <= 100, "Brightness must be between 0 and 100"
+        hex_brightness = f"{brightness:02X}"
+        color_temp = self._state.get("cw", DEFAULT_COLOR_TEMP)
+        hex_data = f"{hex_brightness}{color_temp:04X}"
+        result = await self._send_command(self._set_brightness_command.format(hex_data))
+        return self._check_command_result(result, 0, {1})
+
+    async def get_basic_info(self) -> dict[str, Any] | None:
+        """Get device basic settings."""
+        if not (
+            res := await self._get_multi_commands_results(self._get_basic_info_command)
+        ):
+            return None
+        _version_info, _data = res
+
+        self._state["cw"] = int.from_bytes(_data[3:5], "big")
+
+        return {
+            "isOn": bool(_data[1] & 0b10000000),
+            "color_mode": _data[1] & 0b01000000,
+            "brightness": _data[2] & 0b01111111,
+            "cw": self._state["cw"],
+            "firmware": _version_info[2] / 10.0,
+        }