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

homeassistant/components/switchbot_cloud/const.py

@@ -15,3 +15,5 @@ VACUUM_FAN_SPEED_QUIET = "quiet"
 VACUUM_FAN_SPEED_STANDARD = "standard"
 VACUUM_FAN_SPEED_STRONG = "strong"
 VACUUM_FAN_SPEED_MAX = "max"
+
+AFTER_COMMAND_REFRESH = 5

homeassistant/components/switchbot_cloud/fan.py

@@ -0,0 +1,120 @@
+"""Support for the Switchbot Battery Circulator fan."""
+
+import asyncio
+from typing import Any
+
+from switchbot_api import (
+    BatteryCirculatorFanCommands,
+    BatteryCirculatorFanMode,
+    CommonCommands,
+)
+
+from homeassistant.components.fan import FanEntity, FanEntityFeature
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+
+from . import SwitchbotCloudData
+from .const import DOMAIN
+from .entity import SwitchBotCloudEntity
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    config: ConfigEntry,
+    async_add_entities: AddConfigEntryEntitiesCallback,
+) -> None:
+    """Set up SwitchBot Cloud entry."""
+    data: SwitchbotCloudData = hass.data[DOMAIN][config.entry_id]
+    async_add_entities(
+        SwitchBotCloudFan(data.api, device, coordinator)
+        for device, coordinator in data.devices.fans
+    )
+
+
+class SwitchBotCloudFan(SwitchBotCloudEntity, FanEntity):
+    """Representation of a SwitchBot Battery Circulator Fan."""
+
+    _attr_name = None
+
+    _attr_supported_features = (
+        FanEntityFeature.SET_SPEED
+        | FanEntityFeature.PRESET_MODE
+        | FanEntityFeature.TURN_OFF
+        | FanEntityFeature.TURN_ON
+    )
+    _attr_preset_modes = list(BatteryCirculatorFanMode)
+
+    _attr_is_on: bool | None = None
+
+    @property
+    def is_on(self) -> bool | None:
+        """Return true if the entity is on."""
+        return self._attr_is_on
+
+    def _set_attributes(self) -> None:
+        """Set attributes from coordinator data."""
+        if self.coordinator.data is None:
+            return
+
+        power: str = self.coordinator.data["power"]
+        mode: str = self.coordinator.data["mode"]
+        fan_speed: str = self.coordinator.data["fanSpeed"]
+        self._attr_is_on = power == "on"
+        self._attr_preset_mode = mode
+        self._attr_percentage = int(fan_speed)
+        self._attr_supported_features = (
+            FanEntityFeature.PRESET_MODE
+            | FanEntityFeature.TURN_OFF
+            | FanEntityFeature.TURN_ON
+        )
+        if self.is_on and self.preset_mode == BatteryCirculatorFanMode.DIRECT.value:
+            self._attr_supported_features |= FanEntityFeature.SET_SPEED
+
+    async def async_turn_on(
+        self,
+        percentage: int | None = None,
+        preset_mode: str | None = None,
+        **kwargs: Any,
+    ) -> None:
+        """Turn on the fan."""
+        await self.send_api_command(CommonCommands.ON)
+        await self.send_api_command(
+            command=BatteryCirculatorFanCommands.SET_WIND_MODE,
+            parameters=str(self.preset_mode),
+        )
+        if self.preset_mode == BatteryCirculatorFanMode.DIRECT.value:
+            await self.send_api_command(
+                command=BatteryCirculatorFanCommands.SET_WIND_SPEED,
+                parameters=str(self.percentage),
+            )
+        await asyncio.sleep(5)
+        await self.coordinator.async_request_refresh()
+
+    async def async_turn_off(self, **kwargs: Any) -> None:
+        """Turn off the fan."""
+        await self.send_api_command(CommonCommands.OFF)
+        await asyncio.sleep(5)
+        await self.coordinator.async_request_refresh()
+
+    async def async_set_percentage(self, percentage: int) -> None:
+        """Set the speed of the fan, as a percentage."""
+        await self.send_api_command(
+            command=BatteryCirculatorFanCommands.SET_WIND_MODE,
+            parameters=str(BatteryCirculatorFanMode.DIRECT.value),
+        )
+        await self.send_api_command(
+            command=BatteryCirculatorFanCommands.SET_WIND_SPEED,
+            parameters=str(percentage),
+        )
+        await asyncio.sleep(5)
+        await self.coordinator.async_request_refresh()
+
+    async def async_set_preset_mode(self, preset_mode: str) -> None:
+        """Set new preset mode."""
+        await self.send_api_command(
+            command=BatteryCirculatorFanCommands.SET_WIND_MODE,
+            parameters=preset_mode,
+        )
+        await asyncio.sleep(5)
+        await self.coordinator.async_request_refresh()

homeassistant/components/switchbot_cloud/light.py

@@ -0,0 +1,153 @@
+"""Support for the Switchbot Light."""
+
+import asyncio
+from typing import Any
+
+from switchbot_api import (
+    CommonCommands,
+    Device,
+    Remote,
+    RGBWLightCommands,
+    RGBWWLightCommands,
+    SwitchBotAPI,
+)
+
+from homeassistant.components.light import ColorMode, LightEntity
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.core import HomeAssistant, callback
+from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+
+from . import SwitchbotCloudData, SwitchBotCoordinator
+from .const import AFTER_COMMAND_REFRESH, DOMAIN
+from .entity import SwitchBotCloudEntity
+
+
+def value_map_brightness(value: int) -> int:
+    """Return value for brightness map."""
+    return int(value / 255 * 100)
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    config: ConfigEntry,
+    async_add_entities: AddConfigEntryEntitiesCallback,
+) -> None:
+    """Set up SwitchBot Cloud entry."""
+    data: SwitchbotCloudData = hass.data[DOMAIN][config.entry_id]
+    async_add_entities(
+        _async_make_entity(data.api, device, coordinator)
+        for device, coordinator in data.devices.lights
+    )
+
+
+class SwitchBotCloudLight(SwitchBotCloudEntity, LightEntity):
+    """Base Class for SwitchBot Light."""
+
+    _attr_is_on: bool | None = None
+    _attr_name: str | None = None
+
+    _attr_color_mode = ColorMode.UNKNOWN
+
+    def _set_attributes(self) -> None:
+        """Set attributes from coordinator data."""
+        if self.coordinator.data is None:
+            return
+
+        power: str | None = self.coordinator.data.get("power")
+        brightness: int | None = self.coordinator.data.get("brightness")
+        color: str | None = self.coordinator.data.get("color")
+        color_temperature: int | None = self.coordinator.data.get("colorTemperature")
+        self._attr_is_on = power == "on" if power else None
+        self._attr_brightness: int | None = brightness if brightness else None
+        self._attr_rgb_color: tuple | None = (
+            (tuple(int(i) for i in color.split(":"))) if color else None
+        )
+        self._attr_color_temp_kelvin: int | None = (
+            color_temperature if color_temperature else None
+        )
+
+    async def async_turn_off(self, **kwargs: Any) -> None:
+        """Turn the light off."""
+        await self.send_api_command(CommonCommands.OFF)
+        await asyncio.sleep(AFTER_COMMAND_REFRESH)
+        await self.coordinator.async_request_refresh()
+
+    async def async_turn_on(self, **kwargs: Any) -> None:
+        """Turn the light on."""
+        brightness: int | None = kwargs.get("brightness")
+        rgb_color: tuple[int, int, int] | None = kwargs.get("rgb_color")
+        color_temp_kelvin: int | None = kwargs.get("color_temp_kelvin")
+        if brightness is not None:
+            self._attr_color_mode = ColorMode.RGB
+            await self._send_brightness_command(brightness)
+        elif rgb_color is not None:
+            self._attr_color_mode = ColorMode.RGB
+            await self._send_rgb_color_command(rgb_color)
+        elif color_temp_kelvin is not None:
+            self._attr_color_mode = ColorMode.COLOR_TEMP
+            await self._send_color_temperature_command(color_temp_kelvin)
+        else:
+            self._attr_color_mode = ColorMode.RGB
+            await self.send_api_command(CommonCommands.ON)
+        await asyncio.sleep(AFTER_COMMAND_REFRESH)
+        await self.coordinator.async_request_refresh()
+
+    async def _send_brightness_command(self, brightness: int) -> None:
+        """Send a brightness command."""
+        await self.send_api_command(
+            RGBWLightCommands.SET_BRIGHTNESS,
+            parameters=str(value_map_brightness(brightness)),
+        )
+
+    async def _send_rgb_color_command(self, rgb_color: tuple) -> None:
+        """Send an RGB command."""
+        await self.send_api_command(
+            RGBWLightCommands.SET_COLOR,
+            parameters=f"{rgb_color[2]}:{rgb_color[1]}:{rgb_color[0]}",
+        )
+
+    async def _send_color_temperature_command(self, color_temp_kelvin: int) -> None:
+        """Send a color temperature command."""
+        await self.send_api_command(
+            RGBWWLightCommands.SET_COLOR_TEMPERATURE,
+            parameters=str(color_temp_kelvin),
+        )
+
+
+class SwitchBotCloudStripLight(SwitchBotCloudLight):
+    """Representation of a SwitchBot Strip Light."""
+
+    _attr_supported_color_modes = {ColorMode.RGB}
+
+
+class SwitchBotCloudRGBWWLight(SwitchBotCloudLight):
+    """Representation of SwitchBot |Strip Light|Floor Lamp|Color Bulb."""
+
+    _attr_max_color_temp_kelvin = 6500
+    _attr_min_color_temp_kelvin = 2700
+
+    _attr_supported_color_modes = {ColorMode.RGB, ColorMode.COLOR_TEMP}
+
+    async def _send_brightness_command(self, brightness: int) -> None:
+        """Send a brightness command."""
+        await self.send_api_command(
+            RGBWWLightCommands.SET_BRIGHTNESS,
+            parameters=str(value_map_brightness(brightness)),
+        )
+
+    async def _send_rgb_color_command(self, rgb_color: tuple) -> None:
+        """Send an RGB command."""
+        await self.send_api_command(
+            RGBWWLightCommands.SET_COLOR,
+            parameters=f"{rgb_color[0]}:{rgb_color[1]}:{rgb_color[2]}",
+        )
+
+
+@callback
+def _async_make_entity(
+    api: SwitchBotAPI, device: Device | Remote, coordinator: SwitchBotCoordinator
+) -> SwitchBotCloudStripLight | SwitchBotCloudRGBWWLight:
+    """Make a SwitchBotCloudLight."""
+    if device.device_type == "Strip Light":
+        return SwitchBotCloudStripLight(api, device, coordinator)
+    return SwitchBotCloudRGBWWLight(api, device, coordinator)

homeassistant/components/switchbot_cloud/manifest.json

@@ -8,5 +8,5 @@
   "integration_type": "hub",
   "iot_class": "cloud_polling",
   "loggers": ["switchbot_api"],
-  "requirements": ["switchbot-api==2.5.0"]
+  "requirements": ["switchbot-api==2.7.0"]
 }

homeassistant/components/switchbot_cloud/sensor.py

@@ -91,6 +91,7 @@ CO2_DESCRIPTION = SensorEntityDescription(
 
 SENSOR_DESCRIPTIONS_BY_DEVICE_TYPES = {
     "Bot": (BATTERY_DESCRIPTION,),
+    "Battery Circulator Fan": (BATTERY_DESCRIPTION,),
     "Meter": (
         TEMPERATURE_DESCRIPTION,
         HUMIDITY_DESCRIPTION,

homeassistant/components/switchbot_cloud/vacuum.py

@@ -2,7 +2,15 @@
 
 from typing import Any
 
-from switchbot_api import Device, Remote, SwitchBotAPI, VacuumCommands
+from switchbot_api import (
+    Device,
+    Remote,
+    SwitchBotAPI,
+    VacuumCleanerV2Commands,
+    VacuumCleanerV3Commands,
+    VacuumCleanMode,
+    VacuumCommands,
+)
 
 from homeassistant.components.vacuum import (
     StateVacuumEntity,
@@ -63,6 +71,11 @@ VACUUM_FAN_SPEED_TO_SWITCHBOT_FAN_SPEED: dict[str, str] = {
 class SwitchBotCloudVacuum(SwitchBotCloudEntity, StateVacuumEntity):
     """Representation of a SwitchBot vacuum."""
 
+    # "K10+"
+    # "K10+ Pro"
+    # "Robot Vacuum Cleaner S1"
+    # "Robot Vacuum Cleaner S1 Plus"
+
     _attr_supported_features: VacuumEntityFeature = (
         VacuumEntityFeature.BATTERY
         | VacuumEntityFeature.FAN_SPEED
@@ -85,23 +98,26 @@ class SwitchBotCloudVacuum(SwitchBotCloudEntity, StateVacuumEntity):
                 VacuumCommands.POW_LEVEL,
                 parameters=VACUUM_FAN_SPEED_TO_SWITCHBOT_FAN_SPEED[fan_speed],
             )
-        self.async_write_ha_state()
+            await self.coordinator.async_request_refresh()
 
     async def async_pause(self) -> None:
         """Pause the cleaning task."""
         await self.send_api_command(VacuumCommands.STOP)
+        self.async_write_ha_state()
 
     async def async_return_to_base(self, **kwargs: Any) -> None:
         """Set the vacuum cleaner to return to the dock."""
         await self.send_api_command(VacuumCommands.DOCK)
+        await self.coordinator.async_request_refresh()
 
     async def async_start(self) -> None:
         """Start or resume the cleaning task."""
         await self.send_api_command(VacuumCommands.START)
+        await self.coordinator.async_request_refresh()
 
     def _set_attributes(self) -> None:
         """Set attributes from coordinator data."""
-        if not self.coordinator.data:
+        if self.coordinator.data is None:
             return
 
         self._attr_battery_level = self.coordinator.data.get("battery")
@@ -109,11 +125,127 @@ class SwitchBotCloudVacuum(SwitchBotCloudEntity, StateVacuumEntity):
 
         switchbot_state = str(self.coordinator.data.get("workingStatus"))
         self._attr_activity = VACUUM_SWITCHBOT_STATE_TO_HA_STATE.get(switchbot_state)
+        if self._attr_fan_speed is None:
+            self._attr_fan_speed = VACUUM_FAN_SPEED_QUIET
+
+
+class SwitchBotCloudVacuumK20PlusPro(SwitchBotCloudVacuum):
+    """Representation of a SwitchBot K20+ Pro."""
+
+    async def async_set_fan_speed(self, fan_speed: str, **kwargs: Any) -> None:
+        """Set fan speed."""
+        self._attr_fan_speed = fan_speed
+        await self.send_api_command(
+            VacuumCleanerV2Commands.CHANGE_PARAM,
+            parameters={
+                "fanLevel": int(VACUUM_FAN_SPEED_TO_SWITCHBOT_FAN_SPEED[fan_speed]) + 1,
+                "waterLevel": 1,
+                "times": 1,
+            },
+        )
+        await self.coordinator.async_request_refresh()
+
+    async def async_pause(self) -> None:
+        """Pause the cleaning task."""
+        await self.send_api_command(VacuumCleanerV2Commands.PAUSE)
+        await self.coordinator.async_request_refresh()
+
+    async def async_return_to_base(self, **kwargs: Any) -> None:
+        """Set the vacuum cleaner to return to the dock."""
+        await self.send_api_command(VacuumCleanerV2Commands.DOCK)
+        await self.coordinator.async_request_refresh()
+
+    async def async_start(self) -> None:
+        """Start or resume the cleaning task."""
+        fan_level = (
+            VACUUM_FAN_SPEED_TO_SWITCHBOT_FAN_SPEED.get(self.fan_speed)
+            if self.fan_speed
+            else None
+        )
+        await self.send_api_command(
+            VacuumCleanerV2Commands.START_CLEAN,
+            parameters={
+                "action": VacuumCleanMode.SWEEP.value,
+                "param": {
+                    "fanLevel": int(fan_level if fan_level else VACUUM_FAN_SPEED_QUIET)
+                    + 1,
+                    "times": 1,
+                },
+            },
+        )
+        await self.coordinator.async_request_refresh()
+
+
+class SwitchBotCloudVacuumK10PlusProCombo(SwitchBotCloudVacuumK20PlusPro):
+    """Representation of a SwitchBot vacuum K10+ Pro Combo."""
+
+    async def async_set_fan_speed(self, fan_speed: str, **kwargs: Any) -> None:
+        """Set fan speed."""
+        self._attr_fan_speed = fan_speed
+        if fan_speed in VACUUM_FAN_SPEED_TO_SWITCHBOT_FAN_SPEED:
+            await self.send_api_command(
+                VacuumCleanerV2Commands.CHANGE_PARAM,
+                parameters={
+                    "fanLevel": int(VACUUM_FAN_SPEED_TO_SWITCHBOT_FAN_SPEED[fan_speed])
+                    + 1,
+                    "times": 1,
+                },
+            )
+        await self.coordinator.async_request_refresh()
+
+
+class SwitchBotCloudVacuumV3(SwitchBotCloudVacuumK20PlusPro):
+    """Representation of a SwitchBot vacuum Robot Vacuum Cleaner S10 & S20."""
+
+    async def async_set_fan_speed(self, fan_speed: str, **kwargs: Any) -> None:
+        """Set fan speed."""
+        self._attr_fan_speed = fan_speed
+        await self.send_api_command(
+            VacuumCleanerV3Commands.CHANGE_PARAM,
+            parameters={
+                "fanLevel": int(VACUUM_FAN_SPEED_TO_SWITCHBOT_FAN_SPEED[fan_speed]) + 1,
+                "waterLevel": 1,
+                "times": 1,
+            },
+        )
+        await self.coordinator.async_request_refresh()
+
+    async def async_start(self) -> None:
+        """Start or resume the cleaning task."""
+        fan_level = (
+            VACUUM_FAN_SPEED_TO_SWITCHBOT_FAN_SPEED.get(self.fan_speed)
+            if self.fan_speed
+            else None
+        )
+        await self.send_api_command(
+            VacuumCleanerV3Commands.START_CLEAN,
+            parameters={
+                "action": VacuumCleanMode.SWEEP.value,
+                "param": {
+                    "fanLevel": int(fan_level if fan_level else VACUUM_FAN_SPEED_QUIET),
+                    "waterLevel": 1,
+                    "times": 1,
+                },
+            },
+        )
+        await self.coordinator.async_request_refresh()
 
 
 @callback
 def _async_make_entity(
     api: SwitchBotAPI, device: Device | Remote, coordinator: SwitchBotCoordinator
-) -> SwitchBotCloudVacuum:
+) -> (
+    SwitchBotCloudVacuum
+    | SwitchBotCloudVacuumK20PlusPro
+    | SwitchBotCloudVacuumV3
+    | SwitchBotCloudVacuumK10PlusProCombo
+):
     """Make a SwitchBotCloudVacuum."""
+    if device.device_type in VacuumCleanerV2Commands.get_supported_devices():
+        if device.device_type == "K20+ Pro":
+            return SwitchBotCloudVacuumK20PlusPro(api, device, coordinator)
+        return SwitchBotCloudVacuumK10PlusProCombo(api, device, coordinator)
+
+    if device.device_type in VacuumCleanerV3Commands.get_supported_devices():
+        return SwitchBotCloudVacuumV3(api, device, coordinator)
     return SwitchBotCloudVacuum(api, device, coordinator)

homeassistant/components/switcher_kis/translations/ko.json

@@ -7,6 +7,18 @@
         "step": {
             "confirm": {
                 "description": "\uc124\uc815\uc744 \uc2dc\uc791\ud558\uc2dc\uaca0\uc2b5\ub2c8\uae4c?"
+            },
+            "credentials": {
+                "data": {
+                    "token": "\uc561\uc138\uc2a4 \ud1a0\ud070",
+                    "username": "\uc0ac\uc6a9\uc790 \uc774\ub984"
+                }
+            },
+            "reauth_confirm": {
+                "data": {
+                    "token": "\uc561\uc138\uc2a4 \ud1a0\ud070",
+                    "username": "\uc0ac\uc6a9\uc790 \uc774\ub984"
+                }
             }
         }
     },

homeassistant/components/switcher_kis/translations/sk.json

@@ -53,7 +53,7 @@
         },
         "cover": {
             "cover": {
-                "name": "Obal {cover_id}"
+                "name": "Kryt {cover_id}"
             }
         },
         "light": {

homeassistant/components/synology_dsm/__init__.py

@@ -136,7 +136,6 @@ async def async_setup_entry(hass: HomeAssistant, entry: SynologyDSMConfigEntry)
         coordinator_switches=coordinator_switches,
     )
     await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
-    entry.async_on_unload(entry.add_update_listener(_async_update_listener))
 
     if entry.options[CONF_BACKUP_SHARE]:
 
@@ -172,13 +171,6 @@ async def async_unload_entry(
     return unload_ok
 
 
-async def _async_update_listener(
-    hass: HomeAssistant, entry: SynologyDSMConfigEntry
-) -> None:
-    """Handle options update."""
-    await hass.config_entries.async_reload(entry.entry_id)
-
-
 async def async_remove_config_entry_device(
     hass: HomeAssistant, entry: SynologyDSMConfigEntry, device_entry: dr.DeviceEntry
 ) -> bool:

homeassistant/components/synology_dsm/config_flow.py

@@ -24,7 +24,7 @@ from homeassistant.config_entries import (
     ConfigEntry,
     ConfigFlow,
     ConfigFlowResult,
-    OptionsFlow,
+    OptionsFlowWithReload,
 )
 from homeassistant.const import (
     CONF_DISKS,
@@ -441,7 +441,7 @@ class SynologyDSMFlowHandler(ConfigFlow, domain=DOMAIN):
         return None
 
 
-class SynologyDSMOptionsFlowHandler(OptionsFlow):
+class SynologyDSMOptionsFlowHandler(OptionsFlowWithReload):
     """Handle a option flow."""
 
     config_entry: SynologyDSMConfigEntry

homeassistant/components/system_bridge/translations/ga.json

@@ -1,7 +1,81 @@
 {
     "config": {
         "abort": {
-            "unique_id_mismatch": "N\u00ed hionann an t-aitheant\u00f3ir agus an t-aitheant\u00f3ir roimhe seo"
+            "unique_id_mismatch": "N\u00ed hionann an t-aitheant\u00f3ir agus an t-aitheant\u00f3ir roimhe seo",
+            "unsupported_version": "N\u00ed thaca\u00edtear le do leagan de System Bridge. Uasghr\u00e1daigh go dt\u00ed an leagan is d\u00e9ana\u00ed le do thoil."
+        },
+        "step": {
+            "user": {
+                "data": {
+                    "token": "Comhartha"
+                }
+            }
+        }
+    },
+    "entity": {
+        "binary_sensor": {
+            "camera_in_use": {
+                "name": "Ceamara in \u00fas\u00e1id"
+            },
+            "pending_reboot": {
+                "name": "Atos\u00fa ar feitheamh"
+            }
+        },
+        "sensor": {
+            "processes": {
+                "name": "Pr\u00f3isis"
+            }
+        }
+    },
+    "exceptions": {
+        "authentication_failed": {
+            "message": "Theip ar fh\u00edordheimhni\u00fa do {title} ({host})"
+        },
+        "connection_failed": {
+            "message": "Tharla earr\u00e1id nasctha le haghaidh {title} ({host})"
+        },
+        "device_not_found": {
+            "message": "N\u00edorbh fh\u00e9idir gl\u00e9as {device} a aimsi\u00fa"
+        },
+        "no_data_received": {
+            "message": "N\u00edor fuarthas aon sonra\u00ed \u00f3 {host}"
+        },
+        "process_not_found": {
+            "message": "N\u00edorbh fh\u00e9idir an pr\u00f3iseas a aimsi\u00fa le haitheantas {id}."
+        },
+        "timeout": {
+            "message": "Tharla teorainn ama do {title} ({host})"
+        },
+        "unsupported_version": {
+            "message": "N\u00edl leagan tacaithe de System Bridge \u00e1 rith agat do {title} ({host}). Uasghr\u00e1daigh go dt\u00ed an leagan is d\u00e9ana\u00ed le do thoil."
+        }
+    },
+    "issues": {
+        "unsupported_version": {
+            "description": "N\u00ed thaca\u00edtear le do leagan de System Bridge don \u00f3stach {host}.\n\nUasghr\u00e1daigh go dt\u00ed an leagan is d\u00e9ana\u00ed le do thoil.",
+            "title": "Uasghr\u00e1d\u00fa Droichead an Ch\u00f3rais ag teast\u00e1il"
+        }
+    },
+    "services": {
+        "get_process_by_id": {
+            "description": "Faigheann s\u00e9 pr\u00f3iseas de r\u00e9ir an aitheantais.",
+            "fields": {
+                "id": {
+                    "description": "Aitheantas an phr\u00f3isis le f\u00e1il.",
+                    "name": "Aitheantas"
+                }
+            },
+            "name": "Faigh pr\u00f3iseas de r\u00e9ir aitheantais"
+        },
+        "get_processes_by_name": {
+            "description": "Faigheann s\u00e9 liosta de phr\u00f3isis de r\u00e9ir ainm.",
+            "fields": {
+                "name": {
+                    "description": "Ainm an phr\u00f3isis at\u00e1 le f\u00e1il.",
+                    "name": "Ainm"
+                }
+            },
+            "name": "Faigh pr\u00f3isis de r\u00e9ir ainm"
         }
     }
 }

homeassistant/components/system_bridge/translations/ko.json

@@ -12,6 +12,11 @@
         },
         "flow_title": "{name}",
         "step": {
+            "authenticate": {
+                "data": {
+                    "token": "API \ud1a0\ud070"
+                }
+            },
             "user": {
                 "data": {
                     "host": "\ud638\uc2a4\ud2b8",

homeassistant/components/system_health/__init__.py

@@ -231,7 +231,7 @@ async def handle_info(
                     "Error fetching system info for %s - %s",
                     domain,
                     key,
-                    exc_info=(type(exception), exception, exception.__traceback__),  # noqa: LOG014
+                    exc_info=(type(exception), exception, exception.__traceback__),
                 )
                 event_msg["success"] = False
                 event_msg["error"] = {"type": "failed", "error": "unknown"}