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

homeassistant/components/letpot/coordinator.py

@@ -8,7 +8,7 @@ import logging
 
 from letpot.deviceclient import LetPotDeviceClient
 from letpot.exceptions import LetPotAuthenticationException, LetPotException
-from letpot.models import AuthenticationInfo, LetPotDevice, LetPotDeviceStatus
+from letpot.models import LetPotDevice, LetPotDeviceStatus
 
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant
@@ -34,8 +34,8 @@ class LetPotDeviceCoordinator(DataUpdateCoordinator[LetPotDeviceStatus]):
         self,
         hass: HomeAssistant,
         config_entry: LetPotConfigEntry,
-        info: AuthenticationInfo,
         device: LetPotDevice,
+        device_client: LetPotDeviceClient,
     ) -> None:
         """Initialize coordinator."""
         super().__init__(
@@ -45,9 +45,8 @@ class LetPotDeviceCoordinator(DataUpdateCoordinator[LetPotDeviceStatus]):
             name=f"LetPot {device.serial_number}",
             update_interval=timedelta(minutes=10),
         )
-        self._info = info
         self.device = device
-        self.device_client = LetPotDeviceClient(info, device.serial_number)
+        self.device_client = device_client
 
     def _handle_status_update(self, status: LetPotDeviceStatus) -> None:
         """Distribute status update to entities."""
@@ -56,7 +55,9 @@ class LetPotDeviceCoordinator(DataUpdateCoordinator[LetPotDeviceStatus]):
     async def _async_setup(self) -> None:
         """Set up subscription for coordinator."""
         try:
-            await self.device_client.subscribe(self._handle_status_update)
+            await self.device_client.subscribe(
+                self.device.serial_number, self._handle_status_update
+            )
         except LetPotAuthenticationException as exc:
             raise ConfigEntryAuthFailed from exc
 
@@ -64,7 +65,7 @@ class LetPotDeviceCoordinator(DataUpdateCoordinator[LetPotDeviceStatus]):
         """Request an update from the device and wait for a status update or timeout."""
         try:
             async with asyncio.timeout(REQUEST_UPDATE_TIMEOUT):
-                await self.device_client.get_current_status()
+                await self.device_client.get_current_status(self.device.serial_number)
         except LetPotException as exc:
             raise UpdateFailed(exc) from exc
 

homeassistant/components/letpot/entity.py

@@ -30,12 +30,13 @@ class LetPotEntity(CoordinatorEntity[LetPotDeviceCoordinator]):
     def __init__(self, coordinator: LetPotDeviceCoordinator) -> None:
         """Initialize a LetPot entity."""
         super().__init__(coordinator)
+        info = coordinator.device_client.device_info(coordinator.device.serial_number)
         self._attr_device_info = DeviceInfo(
             identifiers={(DOMAIN, coordinator.device.serial_number)},
             name=coordinator.device.name,
             manufacturer="LetPot",
-            model=coordinator.device_client.device_model_name,
-            model_id=coordinator.device_client.device_model_code,
+            model=info.model_name,
+            model_id=info.model_code,
             serial_number=coordinator.device.serial_number,
         )
 

homeassistant/components/letpot/manifest.json

@@ -6,6 +6,7 @@
   "documentation": "https://www.home-assistant.io/integrations/letpot",
   "integration_type": "hub",
   "iot_class": "cloud_push",
+  "loggers": ["letpot"],
   "quality_scale": "bronze",
-  "requirements": ["letpot==0.4.0"]
+  "requirements": ["letpot==0.5.0"]
 }

homeassistant/components/letpot/sensor.py

@@ -50,7 +50,9 @@ SENSORS: tuple[LetPotSensorEntityDescription, ...] = (
         state_class=SensorStateClass.MEASUREMENT,
         supported_fn=(
             lambda coordinator: DeviceFeature.TEMPERATURE
-            in coordinator.device_client.device_features
+            in coordinator.device_client.device_info(
+                coordinator.device.serial_number
+            ).features
         ),
     ),
     LetPotSensorEntityDescription(
@@ -61,7 +63,9 @@ SENSORS: tuple[LetPotSensorEntityDescription, ...] = (
         state_class=SensorStateClass.MEASUREMENT,
         supported_fn=(
             lambda coordinator: DeviceFeature.WATER_LEVEL
-            in coordinator.device_client.device_features
+            in coordinator.device_client.device_info(
+                coordinator.device.serial_number
+            ).features
         ),
     ),
 )

homeassistant/components/letpot/switch.py

@@ -25,7 +25,7 @@ class LetPotSwitchEntityDescription(LetPotEntityDescription, SwitchEntityDescrip
     """Describes a LetPot switch entity."""
 
     value_fn: Callable[[LetPotDeviceStatus], bool | None]
-    set_value_fn: Callable[[LetPotDeviceClient, bool], Coroutine[Any, Any, None]]
+    set_value_fn: Callable[[LetPotDeviceClient, str, bool], Coroutine[Any, Any, None]]
 
 
 SWITCHES: tuple[LetPotSwitchEntityDescription, ...] = (
@@ -33,7 +33,9 @@ SWITCHES: tuple[LetPotSwitchEntityDescription, ...] = (
         key="alarm_sound",
         translation_key="alarm_sound",
         value_fn=lambda status: status.system_sound,
-        set_value_fn=lambda device_client, value: device_client.set_sound(value),
+        set_value_fn=(
+            lambda device_client, serial, value: device_client.set_sound(serial, value)
+        ),
         entity_category=EntityCategory.CONFIG,
         supported_fn=lambda coordinator: coordinator.data.system_sound is not None,
     ),
@@ -41,25 +43,35 @@ SWITCHES: tuple[LetPotSwitchEntityDescription, ...] = (
         key="auto_mode",
         translation_key="auto_mode",
         value_fn=lambda status: status.water_mode == 1,
-        set_value_fn=lambda device_client, value: device_client.set_water_mode(value),
+        set_value_fn=(
+            lambda device_client, serial, value: device_client.set_water_mode(
+                serial, value
+            )
+        ),
         entity_category=EntityCategory.CONFIG,
         supported_fn=(
             lambda coordinator: DeviceFeature.PUMP_AUTO
-            in coordinator.device_client.device_features
+            in coordinator.device_client.device_info(
+                coordinator.device.serial_number
+            ).features
         ),
     ),
     LetPotSwitchEntityDescription(
         key="power",
         translation_key="power",
         value_fn=lambda status: status.system_on,
-        set_value_fn=lambda device_client, value: device_client.set_power(value),
+        set_value_fn=lambda device_client, serial, value: device_client.set_power(
+            serial, value
+        ),
         entity_category=EntityCategory.CONFIG,
     ),
     LetPotSwitchEntityDescription(
         key="pump_cycling",
         translation_key="pump_cycling",
         value_fn=lambda status: status.pump_mode == 1,
-        set_value_fn=lambda device_client, value: device_client.set_pump_mode(value),
+        set_value_fn=lambda device_client, serial, value: device_client.set_pump_mode(
+            serial, value
+        ),
         entity_category=EntityCategory.CONFIG,
     ),
 )
@@ -104,11 +116,13 @@ class LetPotSwitchEntity(LetPotEntity, SwitchEntity):
     @exception_handler
     async def async_turn_on(self, **kwargs: Any) -> None:
         """Turn the entity on."""
-        await self.entity_description.set_value_fn(self.coordinator.device_client, True)
+        await self.entity_description.set_value_fn(
+            self.coordinator.device_client, self.coordinator.device.serial_number, True
+        )
 
     @exception_handler
     async def async_turn_off(self, **kwargs: Any) -> None:
         """Turn the entity off."""
         await self.entity_description.set_value_fn(
-            self.coordinator.device_client, False
+            self.coordinator.device_client, self.coordinator.device.serial_number, False
         )

homeassistant/components/letpot/time.py

@@ -26,7 +26,7 @@ class LetPotTimeEntityDescription(TimeEntityDescription):
     """Describes a LetPot time entity."""
 
     value_fn: Callable[[LetPotDeviceStatus], time | None]
-    set_value_fn: Callable[[LetPotDeviceClient, time], Coroutine[Any, Any, None]]
+    set_value_fn: Callable[[LetPotDeviceClient, str, time], Coroutine[Any, Any, None]]
 
 
 TIME_SENSORS: tuple[LetPotTimeEntityDescription, ...] = (
@@ -34,8 +34,10 @@ TIME_SENSORS: tuple[LetPotTimeEntityDescription, ...] = (
         key="light_schedule_end",
         translation_key="light_schedule_end",
         value_fn=lambda status: None if status is None else status.light_schedule_end,
-        set_value_fn=lambda deviceclient, value: deviceclient.set_light_schedule(
-            start=None, end=value
+        set_value_fn=(
+            lambda device_client, serial, value: device_client.set_light_schedule(
+                serial=serial, start=None, end=value
+            )
         ),
         entity_category=EntityCategory.CONFIG,
     ),
@@ -43,8 +45,10 @@ TIME_SENSORS: tuple[LetPotTimeEntityDescription, ...] = (
         key="light_schedule_start",
         translation_key="light_schedule_start",
         value_fn=lambda status: None if status is None else status.light_schedule_start,
-        set_value_fn=lambda deviceclient, value: deviceclient.set_light_schedule(
-            start=value, end=None
+        set_value_fn=(
+            lambda device_client, serial, value: device_client.set_light_schedule(
+                serial=serial, start=value, end=None
+            )
         ),
         entity_category=EntityCategory.CONFIG,
     ),
@@ -89,5 +93,5 @@ class LetPotTimeEntity(LetPotEntity, TimeEntity):
     async def async_set_value(self, value: time) -> None:
         """Set the time."""
         await self.entity_description.set_value_fn(
-            self.coordinator.device_client, value
+            self.coordinator.device_client, self.coordinator.device.serial_number, value
         )

homeassistant/components/lg_thinq/climate.py

@@ -12,6 +12,7 @@ from homeassistant.components.climate import (
     ATTR_HVAC_MODE,
     ATTR_TARGET_TEMP_HIGH,
     ATTR_TARGET_TEMP_LOW,
+    PRESET_NONE,
     SWING_OFF,
     SWING_ON,
     ClimateEntity,
@@ -22,7 +23,6 @@ from homeassistant.components.climate import (
 from homeassistant.const import ATTR_TEMPERATURE, UnitOfTemperature
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
-from homeassistant.helpers.temperature import display_temp
 
 from . import ThinqConfigEntry
 from .coordinator import DeviceDataUpdateCoordinator
@@ -109,11 +109,11 @@ class ThinQClimateEntity(ThinQEntity, ClimateEntity):
         )
         self._attr_hvac_modes = [HVACMode.OFF]
         self._attr_hvac_mode = HVACMode.OFF
-        self._attr_preset_modes = []
+        self._attr_preset_modes = [PRESET_NONE]
+        self._attr_preset_mode = PRESET_NONE
         self._attr_temperature_unit = (
             self._get_unit_of_measurement(self.data.unit) or UnitOfTemperature.CELSIUS
         )
-        self._requested_hvac_mode: str | None = None
 
         # Set up HVAC modes.
         for mode in self.data.hvac_modes:
@@ -157,17 +157,19 @@ class ThinQClimateEntity(ThinQEntity, ClimateEntity):
             )
 
         if self.data.is_on:
-            hvac_mode = self._requested_hvac_mode or self.data.hvac_mode
+            hvac_mode = self.data.hvac_mode
             if hvac_mode in STR_TO_HVAC:
                 self._attr_hvac_mode = STR_TO_HVAC.get(hvac_mode)
-                self._attr_preset_mode = None
+                self._attr_preset_mode = PRESET_NONE
             elif hvac_mode in THINQ_PRESET_MODE:
+                self._attr_hvac_mode = (
+                    HVACMode.COOL if hvac_mode == "energy_saving" else HVACMode.FAN_ONLY
+                )
                 self._attr_preset_mode = hvac_mode
         else:
             self._attr_hvac_mode = HVACMode.OFF
-            self._attr_preset_mode = None
+            self._attr_preset_mode = PRESET_NONE
 
-        self.reset_requested_hvac_mode()
         self._attr_current_humidity = self.data.humidity
         self._attr_current_temperature = self.data.current_temp
 
@@ -202,10 +204,6 @@ class ThinQClimateEntity(ThinQEntity, ClimateEntity):
             self.target_temperature_step,
         )
 
-    def reset_requested_hvac_mode(self) -> None:
-        """Cancel request to set hvac mode."""
-        self._requested_hvac_mode = None
-
     async def async_turn_on(self) -> None:
         """Turn the entity on."""
         _LOGGER.debug(
@@ -226,16 +224,13 @@ class ThinQClimateEntity(ThinQEntity, ClimateEntity):
             await self.async_turn_off()
             return
 
+        if hvac_mode == HVACMode.HEAT_COOL:
+            hvac_mode = HVACMode.AUTO
+
         # If device is off, turn on first.
         if not self.data.is_on:
             await self.async_turn_on()
 
-        # When we request hvac mode while turning on the device, the previously set
-        # hvac mode is displayed first and then switches to the requested hvac mode.
-        # To prevent this, set the requested hvac mode here so that it will be set
-        # immediately on the next update.
-        self._requested_hvac_mode = HVAC_TO_STR.get(hvac_mode)
-
         _LOGGER.debug(
             "[%s:%s] async_set_hvac_mode: %s",
             self.coordinator.device_name,
@@ -244,9 +239,8 @@ class ThinQClimateEntity(ThinQEntity, ClimateEntity):
         )
         await self.async_call_api(
             self.coordinator.api.async_set_hvac_mode(
-                self.property_id, self._requested_hvac_mode
-            ),
-            self.reset_requested_hvac_mode,
+                self.property_id, HVAC_TO_STR.get(hvac_mode)
+            )
         )
 
     async def async_set_preset_mode(self, preset_mode: str) -> None:
@@ -257,6 +251,8 @@ class ThinQClimateEntity(ThinQEntity, ClimateEntity):
             self.property_id,
             preset_mode,
         )
+        if preset_mode == PRESET_NONE:
+            preset_mode = "cool" if self.preset_mode == "energy_saving" else "fan"
         await self.async_call_api(
             self.coordinator.api.async_set_hvac_mode(self.property_id, preset_mode)
         )
@@ -301,59 +297,50 @@ class ThinQClimateEntity(ThinQEntity, ClimateEntity):
             )
         )
 
-    def _round_by_step(self, temperature: float) -> float:
-        """Round the value by step."""
-        if (
-            target_temp := display_temp(
-                self.coordinator.hass,
-                temperature,
-                self.coordinator.hass.config.units.temperature_unit,
-                self.target_temperature_step or 1,
-            )
-        ) is not None:
-            return target_temp
-
-        return temperature
-
     async def async_set_temperature(self, **kwargs: Any) -> None:
         """Set new target temperature."""
+        if hvac_mode := kwargs.get(ATTR_HVAC_MODE):
+            if hvac_mode == HVACMode.OFF:
+                await self.async_turn_off()
+                return
+
+            if hvac_mode == HVACMode.HEAT_COOL:
+                hvac_mode = HVACMode.AUTO
+
+        # If device is off, turn on first.
+        if not self.data.is_on:
+            await self.async_turn_on()
+
+        if hvac_mode and hvac_mode != self.hvac_mode:
+            await self.async_set_hvac_mode(HVACMode(hvac_mode))
+
         _LOGGER.debug(
             "[%s:%s] async_set_temperature: %s",
             self.coordinator.device_name,
             self.property_id,
             kwargs,
         )
-        if hvac_mode := kwargs.get(ATTR_HVAC_MODE):
-            await self.async_set_hvac_mode(HVACMode(hvac_mode))
-            if hvac_mode == HVACMode.OFF:
-                return
-
-        if (temperature := kwargs.get(ATTR_TEMPERATURE)) is not None:
-            if (
-                target_temp := self._round_by_step(temperature)
-            ) != self.target_temperature:
+        if temperature := kwargs.get(ATTR_TEMPERATURE):
+            if self.data.step >= 1:
+                temperature = int(temperature)
+            if temperature != self.target_temperature:
                 await self.async_call_api(
                     self.coordinator.api.async_set_target_temperature(
-                        self.property_id, target_temp
-                    )
-                )
-
-        if (temperature_low := kwargs.get(ATTR_TARGET_TEMP_LOW)) is not None:
-            if (
-                target_temp_low := self._round_by_step(temperature_low)
-            ) != self.target_temperature_low:
-                await self.async_call_api(
-                    self.coordinator.api.async_set_target_temperature_low(
-                        self.property_id, target_temp_low
+                        self.property_id,
+                        temperature,
                     )
                 )
 
-        if (temperature_high := kwargs.get(ATTR_TARGET_TEMP_HIGH)) is not None:
-            if (
-                target_temp_high := self._round_by_step(temperature_high)
-            ) != self.target_temperature_high:
-                await self.async_call_api(
-                    self.coordinator.api.async_set_target_temperature_high(
-                        self.property_id, target_temp_high
-                    )
+        if (temperature_low := kwargs.get(ATTR_TARGET_TEMP_LOW)) and (
+            temperature_high := kwargs.get(ATTR_TARGET_TEMP_HIGH)
+        ):
+            if self.data.step >= 1:
+                temperature_low = int(temperature_low)
+                temperature_high = int(temperature_high)
+            await self.async_call_api(
+                self.coordinator.api.async_set_target_temperature_low_high(
+                    self.property_id,
+                    temperature_low,
+                    temperature_high,
                 )
+            )

homeassistant/components/lg_thinq/icons.json

@@ -219,6 +219,9 @@
       "total_pollution_level": {
         "default": "mdi:air-filter"
       },
+      "carbon_dioxide": {
+        "default": "mdi:molecule-co2"
+      },
       "monitoring_enabled": {
         "default": "mdi:monitor-eye"
       },
@@ -330,9 +333,21 @@
       "hop_oil_info": {
         "default": "mdi:information-box-outline"
       },
+      "hop_oil_capsule_1": {
+        "default": "mdi:information-box-outline"
+      },
+      "hop_oil_capsule_2": {
+        "default": "mdi:information-box-outline"
+      },
       "flavor_info": {
         "default": "mdi:information-box-outline"
       },
+      "flavor_capsule_1": {
+        "default": "mdi:information-box-outline"
+      },
+      "flavor_capsule_2": {
+        "default": "mdi:information-box-outline"
+      },
       "beer_remain": {
         "default": "mdi:glass-mug-variant"
       },

homeassistant/components/lg_thinq/sensor.py

@@ -75,6 +75,11 @@ AIR_QUALITY_SENSOR_DESC: dict[ThinQProperty, SensorEntityDescription] = {
         device_class=SensorDeviceClass.ENUM,
         translation_key=ThinQProperty.TOTAL_POLLUTION_LEVEL,
     ),
+    ThinQProperty.CO2: SensorEntityDescription(
+        key=ThinQProperty.CO2,
+        device_class=SensorDeviceClass.ENUM,
+        translation_key="carbon_dioxide",
+    ),
 }
 BATTERY_SENSOR_DESC: dict[ThinQProperty, SensorEntityDescription] = {
     ThinQProperty.BATTERY_PERCENT: SensorEntityDescription(
@@ -175,10 +180,30 @@ RECIPE_SENSOR_DESC: dict[ThinQProperty, SensorEntityDescription] = {
         key=ThinQProperty.HOP_OIL_INFO,
         translation_key=ThinQProperty.HOP_OIL_INFO,
     ),
+    ThinQProperty.HOP_OIL_CAPSULE_1: SensorEntityDescription(
+        key=ThinQProperty.HOP_OIL_CAPSULE_1,
+        device_class=SensorDeviceClass.ENUM,
+        translation_key=ThinQProperty.HOP_OIL_CAPSULE_1,
+    ),
+    ThinQProperty.HOP_OIL_CAPSULE_2: SensorEntityDescription(
+        key=ThinQProperty.HOP_OIL_CAPSULE_2,
+        device_class=SensorDeviceClass.ENUM,
+        translation_key=ThinQProperty.HOP_OIL_CAPSULE_2,
+    ),
     ThinQProperty.FLAVOR_INFO: SensorEntityDescription(
         key=ThinQProperty.FLAVOR_INFO,
         translation_key=ThinQProperty.FLAVOR_INFO,
     ),
+    ThinQProperty.FLAVOR_CAPSULE_1: SensorEntityDescription(
+        key=ThinQProperty.FLAVOR_CAPSULE_1,
+        device_class=SensorDeviceClass.ENUM,
+        translation_key=ThinQProperty.FLAVOR_CAPSULE_1,
+    ),
+    ThinQProperty.FLAVOR_CAPSULE_2: SensorEntityDescription(
+        key=ThinQProperty.FLAVOR_CAPSULE_2,
+        device_class=SensorDeviceClass.ENUM,
+        translation_key=ThinQProperty.FLAVOR_CAPSULE_2,
+    ),
     ThinQProperty.BEER_REMAIN: SensorEntityDescription(
         key=ThinQProperty.BEER_REMAIN,
         native_unit_of_measurement=PERCENTAGE,
@@ -415,6 +440,7 @@ DEVICE_TYPE_SENSOR_MAP: dict[DeviceType, tuple[SensorEntityDescription, ...]] =
     DeviceType.COOKTOP: (
         RUN_STATE_SENSOR_DESC[ThinQProperty.CURRENT_STATE],
         POWER_SENSOR_DESC[ThinQProperty.POWER_LEVEL],
+        TIMER_SENSOR_DESC[TimerProperty.REMAIN],
     ),
     DeviceType.DEHUMIDIFIER: (
         JOB_MODE_SENSOR_DESC[ThinQProperty.CURRENT_JOB_MODE],
@@ -435,7 +461,11 @@ DEVICE_TYPE_SENSOR_MAP: dict[DeviceType, tuple[SensorEntityDescription, ...]] =
         RECIPE_SENSOR_DESC[ThinQProperty.WORT_INFO],
         RECIPE_SENSOR_DESC[ThinQProperty.YEAST_INFO],
         RECIPE_SENSOR_DESC[ThinQProperty.HOP_OIL_INFO],
+        RECIPE_SENSOR_DESC[ThinQProperty.HOP_OIL_CAPSULE_1],
+        RECIPE_SENSOR_DESC[ThinQProperty.HOP_OIL_CAPSULE_2],
         RECIPE_SENSOR_DESC[ThinQProperty.FLAVOR_INFO],
+        RECIPE_SENSOR_DESC[ThinQProperty.FLAVOR_CAPSULE_1],
+        RECIPE_SENSOR_DESC[ThinQProperty.FLAVOR_CAPSULE_2],
         RECIPE_SENSOR_DESC[ThinQProperty.BEER_REMAIN],
         RUN_STATE_SENSOR_DESC[ThinQProperty.CURRENT_STATE],
         ELAPSED_DAY_SENSOR_DESC[ThinQProperty.ELAPSED_DAY_STATE],
@@ -497,6 +527,16 @@ DEVICE_TYPE_SENSOR_MAP: dict[DeviceType, tuple[SensorEntityDescription, ...]] =
         TEMPERATURE_SENSOR_DESC[ThinQPropertyEx.ROOM_IN_WATER_CURRENT_TEMPERATURE],
         TEMPERATURE_SENSOR_DESC[ThinQPropertyEx.ROOM_OUT_WATER_CURRENT_TEMPERATURE],
     ),
+    DeviceType.VENTILATOR: (
+        AIR_QUALITY_SENSOR_DESC[ThinQProperty.CO2],
+        AIR_QUALITY_SENSOR_DESC[ThinQProperty.PM1],
+        AIR_QUALITY_SENSOR_DESC[ThinQProperty.PM2],
+        AIR_QUALITY_SENSOR_DESC[ThinQProperty.PM10],
+        TEMPERATURE_SENSOR_DESC[ThinQProperty.CURRENT_TEMPERATURE],
+        TIME_SENSOR_DESC[TimerProperty.ABSOLUTE_TO_START],
+        TIME_SENSOR_DESC[TimerProperty.ABSOLUTE_TO_STOP],
+        TIMER_SENSOR_DESC[TimerProperty.SLEEP_TIMER_RELATIVE_TO_STOP],
+    ),
     DeviceType.WASHCOMBO_MAIN: WASHER_SENSORS,
     DeviceType.WASHCOMBO_MINI: WASHER_SENSORS,
     DeviceType.WASHER: WASHER_SENSORS,

homeassistant/components/lg_thinq/strings.json

@@ -74,7 +74,7 @@
     },
     "binary_sensor": {
       "eco_friendly_mode": {
-        "name": "Eco friendly"
+        "name": "Eco-friendly"
       },
       "power_save_enabled": {
         "name": "Power saving mode"
@@ -149,7 +149,7 @@
               "cliff_error": "Fall prevention sensor has an error",
               "clutch_error": "Clutch error",
               "compressor_error": "Compressor error",
-              "dispensing_error": "Dispensor error",
+              "dispensing_error": "Dispenser error",
               "door_close_error": "Door closed error",
               "door_lock_error": "Door lock error",
               "door_open_error": "Door open",
@@ -233,7 +233,7 @@
               "styling_is_complete": "Styling is completed",
               "time_to_change_filter": "It is time to replace the filter",
               "time_to_change_water_filter": "You need to replace water filter",
-              "time_to_clean": "Need to selfcleaning",
+              "time_to_clean": "Need for self-cleaning",
               "time_to_clean_filter": "It is time to clean the filter",
               "timer_is_complete": "Timer has been completed",
               "washing_is_complete": "Washing is completed",
@@ -333,6 +333,19 @@
           "very_bad": "Poor"
         }
       },
+      "carbon_dioxide": {
+        "name": "[%key:component::sensor::entity_component::carbon_dioxide::name%]",
+        "state": {
+          "invalid": "[%key:component::lg_thinq::entity::sensor::total_pollution_level::state::invalid%]",
+          "good": "[%key:component::lg_thinq::entity::sensor::total_pollution_level::state::good%]",
+          "normal": "[%key:component::lg_thinq::entity::sensor::total_pollution_level::state::normal%]",
+          "moderate": "[%key:component::lg_thinq::entity::sensor::total_pollution_level::state::normal%]",
+          "bad": "[%key:component::lg_thinq::entity::sensor::total_pollution_level::state::bad%]",
+          "unhealthy": "[%key:component::lg_thinq::entity::sensor::total_pollution_level::state::bad%]",
+          "very_bad": "[%key:component::lg_thinq::entity::sensor::total_pollution_level::state::very_bad%]",
+          "poor": "[%key:component::lg_thinq::entity::sensor::total_pollution_level::state::very_bad%]"
+        }
+      },
       "monitoring_enabled": {
         "name": "Air quality sensor",
         "state": {
@@ -771,19 +784,57 @@
       "hop_oil_info": {
         "name": "Hops"
       },
+      "hop_oil_capsule_1": {
+        "name": "First hop",
+        "state": {
+          "cascade": "Cascade",
+          "chinook": "Chinook",
+          "goldings": "Goldings",
+          "fuggles": "Fuggles",
+          "hallertau": "Hallertau",
+          "citrussy": "Citrussy"
+        }
+      },
+      "hop_oil_capsule_2": {
+        "name": "Second hop",
+        "state": {
+          "cascade": "[%key:component::lg_thinq::entity::sensor::hop_oil_capsule_1::state::cascade%]",
+          "chinook": "[%key:component::lg_thinq::entity::sensor::hop_oil_capsule_1::state::chinook%]",
+          "goldings": "[%key:component::lg_thinq::entity::sensor::hop_oil_capsule_1::state::goldings%]",
+          "fuggles": "[%key:component::lg_thinq::entity::sensor::hop_oil_capsule_1::state::fuggles%]",
+          "hallertau": "[%key:component::lg_thinq::entity::sensor::hop_oil_capsule_1::state::hallertau%]",
+          "citrussy": "[%key:component::lg_thinq::entity::sensor::hop_oil_capsule_1::state::citrussy%]"
+        }
+      },
       "flavor_info": {
         "name": "Flavor"
       },
+      "flavor_capsule_1": {
+        "name": "First flavor",
+        "state": {
+          "coriander": "Coriander",
+          "coriander_seed": "[%key:component::lg_thinq::entity::sensor::flavor_capsule_1::state::coriander%]",
+          "orange": "Orange"
+        }
+      },
+      "flavor_capsule_2": {
+        "name": "Second flavor",
+        "state": {
+          "coriander": "[%key:component::lg_thinq::entity::sensor::flavor_capsule_1::state::coriander%]",
+          "coriander_seed": "[%key:component::lg_thinq::entity::sensor::flavor_capsule_1::state::coriander%]",
+          "orange": "[%key:component::lg_thinq::entity::sensor::flavor_capsule_1::state::orange%]"
+        }
+      },
       "beer_remain": {
         "name": "Recipe progress"
       },
       "battery_level": {
         "name": "Battery",
         "state": {
-          "high": "Full",
+          "high": "[%key:common::state::full%]",
           "mid": "[%key:common::state::medium%]",
           "low": "[%key:common::state::low%]",
-          "warning": "Empty"
+          "warning": "[%key:common::state::empty%]"
         }
       },
       "relative_to_start": {

homeassistant/components/lg_thinq/translations/bg.json

@@ -164,6 +164,9 @@
             "battery_level": {
                 "name": "\u0411\u0430\u0442\u0435\u0440\u0438\u044f"
             },
+            "carbon_dioxide": {
+                "name": "\u0412\u044a\u0433\u043b\u0435\u0440\u043e\u0434\u0435\u043d \u0434\u0438\u043e\u043a\u0441\u0438\u0434"
+            },
             "cock_state": {
                 "state": {
                     "cleaning": "\u0412 \u043f\u0440\u043e\u0446\u0435\u0441 \u043d\u0430 \u0438\u0437\u043f\u044a\u043b\u043d\u0435\u043d\u0438\u0435",