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

homeassistant/components/jewish_calendar/binary_sensor.py

@@ -13,8 +13,7 @@ from homeassistant.components.binary_sensor import (
     BinarySensorEntityDescription,
 )
 from homeassistant.const import EntityCategory
-from homeassistant.core import CALLBACK_TYPE, HomeAssistant, callback
-from homeassistant.helpers import event
+from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.util import dt as dt_util
 
@@ -23,36 +22,29 @@ from .entity import JewishCalendarConfigEntry, JewishCalendarEntity
 PARALLEL_UPDATES = 0
 
 
-@dataclass(frozen=True)
-class JewishCalendarBinarySensorMixIns(BinarySensorEntityDescription):
-    """Binary Sensor description mixin class for Jewish Calendar."""
-
-    is_on: Callable[[Zmanim, dt.datetime], bool] = lambda _, __: False
-
-
-@dataclass(frozen=True)
-class JewishCalendarBinarySensorEntityDescription(
-    JewishCalendarBinarySensorMixIns, BinarySensorEntityDescription
-):
+@dataclass(frozen=True, kw_only=True)
+class JewishCalendarBinarySensorEntityDescription(BinarySensorEntityDescription):
     """Binary Sensor Entity description for Jewish Calendar."""
 
+    is_on: Callable[[Zmanim], Callable[[dt.datetime], bool]]
+
 
 BINARY_SENSORS: tuple[JewishCalendarBinarySensorEntityDescription, ...] = (
     JewishCalendarBinarySensorEntityDescription(
         key="issur_melacha_in_effect",
         translation_key="issur_melacha_in_effect",
-        is_on=lambda state, now: bool(state.issur_melacha_in_effect(now)),
+        is_on=lambda state: state.issur_melacha_in_effect,
     ),
     JewishCalendarBinarySensorEntityDescription(
         key="erev_shabbat_hag",
         translation_key="erev_shabbat_hag",
-        is_on=lambda state, now: bool(state.erev_shabbat_chag(now)),
+        is_on=lambda state: state.erev_shabbat_chag,
         entity_registry_enabled_default=False,
     ),
     JewishCalendarBinarySensorEntityDescription(
         key="motzei_shabbat_hag",
         translation_key="motzei_shabbat_hag",
-        is_on=lambda state, now: bool(state.motzei_shabbat_chag(now)),
+        is_on=lambda state: state.motzei_shabbat_chag,
         entity_registry_enabled_default=False,
     ),
 )
@@ -73,9 +65,7 @@ async def async_setup_entry(
 class JewishCalendarBinarySensor(JewishCalendarEntity, BinarySensorEntity):
     """Representation of an Jewish Calendar binary sensor."""
 
-    _attr_should_poll = False
     _attr_entity_category = EntityCategory.DIAGNOSTIC
-    _update_unsub: CALLBACK_TYPE | None = None
 
     entity_description: JewishCalendarBinarySensorEntityDescription
 
@@ -83,40 +73,12 @@ class JewishCalendarBinarySensor(JewishCalendarEntity, BinarySensorEntity):
     def is_on(self) -> bool:
         """Return true if sensor is on."""
         zmanim = self.make_zmanim(dt.date.today())
-        return self.entity_description.is_on(zmanim, dt_util.now())
-
-    async def async_added_to_hass(self) -> None:
-        """Run when entity about to be added to hass."""
-        await super().async_added_to_hass()
-        self._schedule_update()
-
-    async def async_will_remove_from_hass(self) -> None:
-        """Run when entity will be removed from hass."""
-        if self._update_unsub:
-            self._update_unsub()
-            self._update_unsub = None
-        return await super().async_will_remove_from_hass()
-
-    @callback
-    def _update(self, now: dt.datetime | None = None) -> None:
-        """Update the state of the sensor."""
-        self._update_unsub = None
-        self._schedule_update()
-        self.async_write_ha_state()
-
-    def _schedule_update(self) -> None:
-        """Schedule the next update of the sensor."""
-        now = dt_util.now()
-        zmanim = self.make_zmanim(dt.date.today())
-        update = zmanim.netz_hachama.local + dt.timedelta(days=1)
-        candle_lighting = zmanim.candle_lighting
-        if candle_lighting is not None and now < candle_lighting < update:
-            update = candle_lighting
-        havdalah = zmanim.havdalah
-        if havdalah is not None and now < havdalah < update:
-            update = havdalah
-        if self._update_unsub:
-            self._update_unsub()
-        self._update_unsub = event.async_track_point_in_time(
-            self.hass, self._update, update
-        )
+        return self.entity_description.is_on(zmanim)(dt_util.now())
+
+    def _update_times(self, zmanim: Zmanim) -> list[dt.datetime | None]:
+        """Return a list of times to update the sensor."""
+        return [
+            zmanim.netz_hachama.local + dt.timedelta(days=1),
+            zmanim.candle_lighting,
+            zmanim.havdalah,
+        ]

homeassistant/components/jewish_calendar/config_flow.py

@@ -9,7 +9,11 @@ import zoneinfo
 from hdate.translator import Language
 import voluptuous as vol
 
-from homeassistant.config_entries import ConfigFlow, ConfigFlowResult, OptionsFlow
+from homeassistant.config_entries import (
+    ConfigFlow,
+    ConfigFlowResult,
+    OptionsFlowWithReload,
+)
 from homeassistant.const import (
     CONF_ELEVATION,
     CONF_LANGUAGE,
@@ -124,7 +128,7 @@ class JewishCalendarConfigFlow(ConfigFlow, domain=DOMAIN):
         return self.async_update_reload_and_abort(reconfigure_entry, data=user_input)
 
 
-class JewishCalendarOptionsFlowHandler(OptionsFlow):
+class JewishCalendarOptionsFlowHandler(OptionsFlowWithReload):
     """Handle Jewish Calendar options."""
 
     async def async_step_init(

homeassistant/components/jewish_calendar/entity.py

@@ -1,17 +1,24 @@
 """Entity representing a Jewish Calendar sensor."""
 
+from abc import abstractmethod
 from dataclasses import dataclass
 import datetime as dt
+import logging
 
 from hdate import HDateInfo, Location, Zmanim
 from hdate.translator import Language, set_language
 
 from homeassistant.config_entries import ConfigEntry
+from homeassistant.core import CALLBACK_TYPE, callback
+from homeassistant.helpers import event
 from homeassistant.helpers.device_registry import DeviceEntryType, DeviceInfo
 from homeassistant.helpers.entity import Entity, EntityDescription
+from homeassistant.util import dt as dt_util
 
 from .const import DOMAIN
 
+_LOGGER = logging.getLogger(__name__)
+
 type JewishCalendarConfigEntry = ConfigEntry[JewishCalendarData]
 
 
@@ -19,9 +26,7 @@ type JewishCalendarConfigEntry = ConfigEntry[JewishCalendarData]
 class JewishCalendarDataResults:
     """Jewish Calendar results dataclass."""
 
-    daytime_date: HDateInfo
-    after_shkia_date: HDateInfo
-    after_tzais_date: HDateInfo
+    dateinfo: HDateInfo
     zmanim: Zmanim
 
 
@@ -41,6 +46,8 @@ class JewishCalendarEntity(Entity):
     """An HA implementation for Jewish Calendar entity."""
 
     _attr_has_entity_name = True
+    _attr_should_poll = False
+    _update_unsub: CALLBACK_TYPE | None = None
 
     def __init__(
         self,
@@ -65,3 +72,55 @@ class JewishCalendarEntity(Entity):
             candle_lighting_offset=self.data.candle_lighting_offset,
             havdalah_offset=self.data.havdalah_offset,
         )
+
+    async def async_added_to_hass(self) -> None:
+        """Call when entity is added to hass."""
+        await super().async_added_to_hass()
+        self._schedule_update()
+
+    async def async_will_remove_from_hass(self) -> None:
+        """Run when entity will be removed from hass."""
+        if self._update_unsub:
+            self._update_unsub()
+            self._update_unsub = None
+        return await super().async_will_remove_from_hass()
+
+    @abstractmethod
+    def _update_times(self, zmanim: Zmanim) -> list[dt.datetime | None]:
+        """Return a list of times to update the sensor."""
+
+    def _schedule_update(self) -> None:
+        """Schedule the next update of the sensor."""
+        now = dt_util.now()
+        zmanim = self.make_zmanim(now.date())
+        update = dt_util.start_of_local_day() + dt.timedelta(days=1)
+
+        for update_time in self._update_times(zmanim):
+            if update_time is not None and now < update_time < update:
+                update = update_time
+
+        if self._update_unsub:
+            self._update_unsub()
+        self._update_unsub = event.async_track_point_in_time(
+            self.hass, self._update, update
+        )
+
+    @callback
+    def _update(self, now: dt.datetime | None = None) -> None:
+        """Update the sensor data."""
+        self._update_unsub = None
+        self._schedule_update()
+        self.create_results(now)
+        self.async_write_ha_state()
+
+    def create_results(self, now: dt.datetime | None = None) -> None:
+        """Create the results for the sensor."""
+        if now is None:
+            now = dt_util.now()
+
+        _LOGGER.debug("Now: %s Location: %r", now, self.data.location)
+
+        today = now.date()
+        zmanim = self.make_zmanim(today)
+        dateinfo = HDateInfo(today, diaspora=self.data.diaspora)
+        self.data.results = JewishCalendarDataResults(dateinfo, zmanim)

homeassistant/components/jewish_calendar/sensor.py

@@ -16,17 +16,12 @@ from homeassistant.components.sensor import (
     SensorEntity,
     SensorEntityDescription,
 )
-from homeassistant.const import SUN_EVENT_SUNSET, EntityCategory
+from homeassistant.const import EntityCategory
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
-from homeassistant.helpers.sun import get_astral_event_date
 from homeassistant.util import dt as dt_util
 
-from .entity import (
-    JewishCalendarConfigEntry,
-    JewishCalendarDataResults,
-    JewishCalendarEntity,
-)
+from .entity import JewishCalendarConfigEntry, JewishCalendarEntity
 
 _LOGGER = logging.getLogger(__name__)
 PARALLEL_UPDATES = 0
@@ -37,15 +32,19 @@ class JewishCalendarBaseSensorDescription(SensorEntityDescription):
     """Base class describing Jewish Calendar sensor entities."""
 
     value_fn: Callable | None
+    next_update_fn: Callable[[Zmanim], dt.datetime | None] | None
 
 
 @dataclass(frozen=True, kw_only=True)
 class JewishCalendarSensorDescription(JewishCalendarBaseSensorDescription):
     """Class describing Jewish Calendar sensor entities."""
 
-    value_fn: Callable[[JewishCalendarDataResults], str | int]
-    attr_fn: Callable[[JewishCalendarDataResults], dict[str, str]] | None = None
+    value_fn: Callable[[HDateInfo], str | int]
+    attr_fn: Callable[[HDateInfo], dict[str, str]] | None = None
     options_fn: Callable[[bool], list[str]] | None = None
+    next_update_fn: Callable[[Zmanim], dt.datetime | None] | None = (
+        lambda zmanim: zmanim.shkia.local
+    )
 
 
 @dataclass(frozen=True, kw_only=True)
@@ -55,17 +54,18 @@ class JewishCalendarTimestampSensorDescription(JewishCalendarBaseSensorDescripti
     value_fn: (
         Callable[[HDateInfo, Callable[[dt.date], Zmanim]], dt.datetime | None] | None
     ) = None
+    next_update_fn: Callable[[Zmanim], dt.datetime | None] | None = None
 
 
 INFO_SENSORS: tuple[JewishCalendarSensorDescription, ...] = (
     JewishCalendarSensorDescription(
         key="date",
         translation_key="hebrew_date",
-        value_fn=lambda results: str(results.after_shkia_date.hdate),
-        attr_fn=lambda results: {
-            "hebrew_year": str(results.after_shkia_date.hdate.year),
-            "hebrew_month_name": str(results.after_shkia_date.hdate.month),
-            "hebrew_day": str(results.after_shkia_date.hdate.day),
+        value_fn=lambda info: str(info.hdate),
+        attr_fn=lambda info: {
+            "hebrew_year": str(info.hdate.year),
+            "hebrew_month_name": str(info.hdate.month),
+            "hebrew_day": str(info.hdate.day),
         },
     ),
     JewishCalendarSensorDescription(
@@ -73,24 +73,19 @@ INFO_SENSORS: tuple[JewishCalendarSensorDescription, ...] = (
         translation_key="weekly_portion",
         device_class=SensorDeviceClass.ENUM,
         options_fn=lambda _: [str(p) for p in Parasha],
-        value_fn=lambda results: results.after_tzais_date.upcoming_shabbat.parasha,
+        value_fn=lambda info: info.upcoming_shabbat.parasha,
+        next_update_fn=lambda zmanim: zmanim.havdalah,
     ),
     JewishCalendarSensorDescription(
         key="holiday",
         translation_key="holiday",
         device_class=SensorDeviceClass.ENUM,
         options_fn=lambda diaspora: HolidayDatabase(diaspora).get_all_names(),
-        value_fn=lambda results: ", ".join(
-            str(holiday) for holiday in results.after_shkia_date.holidays
-        ),
-        attr_fn=lambda results: {
-            "id": ", ".join(
-                holiday.name for holiday in results.after_shkia_date.holidays
-            ),
+        value_fn=lambda info: ", ".join(str(holiday) for holiday in info.holidays),
+        attr_fn=lambda info: {
+            "id": ", ".join(holiday.name for holiday in info.holidays),
             "type": ", ".join(
-                dict.fromkeys(
-                    _holiday.type.name for _holiday in results.after_shkia_date.holidays
-                )
+                dict.fromkeys(_holiday.type.name for _holiday in info.holidays)
             ),
         },
     ),
@@ -98,13 +93,13 @@ INFO_SENSORS: tuple[JewishCalendarSensorDescription, ...] = (
         key="omer_count",
         translation_key="omer_count",
         entity_registry_enabled_default=False,
-        value_fn=lambda results: results.after_shkia_date.omer.total_days,
+        value_fn=lambda info: info.omer.total_days,
     ),
     JewishCalendarSensorDescription(
         key="daf_yomi",
         translation_key="daf_yomi",
         entity_registry_enabled_default=False,
-        value_fn=lambda results: results.daytime_date.daf_yomi,
+        value_fn=lambda info: info.daf_yomi,
     ),
 )
 
@@ -184,12 +179,14 @@ TIME_SENSORS: tuple[JewishCalendarTimestampSensorDescription, ...] = (
         value_fn=lambda at_date, mz: mz(
             at_date.upcoming_shabbat.previous_day.gdate
         ).candle_lighting,
+        next_update_fn=lambda zmanim: zmanim.havdalah,
     ),
     JewishCalendarTimestampSensorDescription(
         key="upcoming_shabbat_havdalah",
         translation_key="upcoming_shabbat_havdalah",
         entity_registry_enabled_default=False,
         value_fn=lambda at_date, mz: mz(at_date.upcoming_shabbat.gdate).havdalah,
+        next_update_fn=lambda zmanim: zmanim.havdalah,
     ),
     JewishCalendarTimestampSensorDescription(
         key="upcoming_candle_lighting",
@@ -197,6 +194,7 @@ TIME_SENSORS: tuple[JewishCalendarTimestampSensorDescription, ...] = (
         value_fn=lambda at_date, mz: mz(
             at_date.upcoming_shabbat_or_yom_tov.first_day.previous_day.gdate
         ).candle_lighting,
+        next_update_fn=lambda zmanim: zmanim.havdalah,
     ),
     JewishCalendarTimestampSensorDescription(
         key="upcoming_havdalah",
@@ -204,6 +202,7 @@ TIME_SENSORS: tuple[JewishCalendarTimestampSensorDescription, ...] = (
         value_fn=lambda at_date, mz: mz(
             at_date.upcoming_shabbat_or_yom_tov.last_day.gdate
         ).havdalah,
+        next_update_fn=lambda zmanim: zmanim.havdalah,
     ),
 )
 
@@ -213,7 +212,7 @@ async def async_setup_entry(
     config_entry: JewishCalendarConfigEntry,
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
-    """Set up the Jewish calendar sensors ."""
+    """Set up the Jewish calendar sensors."""
     sensors: list[JewishCalendarBaseSensor] = [
         JewishCalendarSensor(config_entry, description) for description in INFO_SENSORS
     ]
@@ -229,44 +228,33 @@ class JewishCalendarBaseSensor(JewishCalendarEntity, SensorEntity):
 
     _attr_entity_category = EntityCategory.DIAGNOSTIC
 
-    async def async_update(self) -> None:
-        """Update the state of the sensor."""
-        now = dt_util.now()
-        _LOGGER.debug("Now: %s Location: %r", now, self.data.location)
-
-        today = now.date()
-        event_date = get_astral_event_date(self.hass, SUN_EVENT_SUNSET, today)
-
-        if event_date is None:
-            _LOGGER.error("Can't get sunset event date for %s", today)
-            return
-
-        sunset = dt_util.as_local(event_date)
+    entity_description: JewishCalendarBaseSensorDescription
 
-        _LOGGER.debug("Now: %s Sunset: %s", now, sunset)
+    def _update_times(self, zmanim: Zmanim) -> list[dt.datetime | None]:
+        """Return a list of times to update the sensor."""
+        if self.entity_description.next_update_fn is None:
+            return []
+        return [self.entity_description.next_update_fn(zmanim)]
 
-        daytime_date = HDateInfo(today, diaspora=self.data.diaspora)
-
-        # The Jewish day starts after darkness (called "tzais") and finishes at
-        # sunset ("shkia"). The time in between is a gray area
-        # (aka "Bein Hashmashot"  # codespell:ignore
-        # - literally: "in between the sun and the moon").
-
-        # For some sensors, it is more interesting to consider the date to be
-        # tomorrow based on sunset ("shkia"), for others based on "tzais".
-        # Hence the following variables.
-        after_tzais_date = after_shkia_date = daytime_date
-        today_times = self.make_zmanim(today)
+    def get_dateinfo(self, now: dt.datetime | None = None) -> HDateInfo:
+        """Get the next date info."""
+        if self.data.results is None:
+            self.create_results()
+        assert self.data.results is not None, "Results should be available"
 
-        if now > sunset:
-            after_shkia_date = daytime_date.next_day
+        if now is None:
+            now = dt_util.now()
 
-        if today_times.havdalah and now > today_times.havdalah:
-            after_tzais_date = daytime_date.next_day
+        today = now.date()
+        zmanim = self.make_zmanim(today)
+        update = None
+        if self.entity_description.next_update_fn:
+            update = self.entity_description.next_update_fn(zmanim)
 
-        self.data.results = JewishCalendarDataResults(
-            daytime_date, after_shkia_date, after_tzais_date, today_times
-        )
+        _LOGGER.debug("Today: %s, update: %s", today, update)
+        if update is not None and now >= update:
+            return self.data.results.dateinfo.next_day
+        return self.data.results.dateinfo
 
 
 class JewishCalendarSensor(JewishCalendarBaseSensor):
@@ -288,18 +276,14 @@ class JewishCalendarSensor(JewishCalendarBaseSensor):
     @property
     def native_value(self) -> str | int | dt.datetime | None:
         """Return the state of the sensor."""
-        if self.data.results is None:
-            return None
-        return self.entity_description.value_fn(self.data.results)
+        return self.entity_description.value_fn(self.get_dateinfo())
 
     @property
     def extra_state_attributes(self) -> dict[str, str]:
         """Return the state attributes."""
-        if self.data.results is None:
+        if self.entity_description.attr_fn is None:
             return {}
-        if self.entity_description.attr_fn is not None:
-            return self.entity_description.attr_fn(self.data.results)
-        return {}
+        return self.entity_description.attr_fn(self.get_dateinfo())
 
 
 class JewishCalendarTimeSensor(JewishCalendarBaseSensor):
@@ -312,9 +296,8 @@ class JewishCalendarTimeSensor(JewishCalendarBaseSensor):
     def native_value(self) -> dt.datetime | None:
         """Return the state of the sensor."""
         if self.data.results is None:
-            return None
+            self.create_results()
+        assert self.data.results is not None, "Results should be available"
         if self.entity_description.value_fn is None:
             return self.data.results.zmanim.zmanim[self.entity_description.key].local
-        return self.entity_description.value_fn(
-            self.data.results.after_tzais_date, self.make_zmanim
-        )
+        return self.entity_description.value_fn(self.get_dateinfo(), self.make_zmanim)

homeassistant/components/jewish_calendar/services.py

@@ -50,7 +50,6 @@ def async_setup_services(hass: HomeAssistant) -> None:
         today = now.date()
         event_date = get_astral_event_date(hass, SUN_EVENT_SUNSET, today)
         if event_date is None:
-            _LOGGER.error("Can't get sunset event date for %s", today)
             raise HomeAssistantError(
                 translation_domain=DOMAIN, translation_key="sunset_event"
             )

homeassistant/components/jewish_calendar/translations/ga.json

@@ -9,10 +9,14 @@
         "time_zone": "Crios ama"
     },
     "config": {
+        "abort": {
+            "reconfigure_successful": "D'\u00e9irigh leis an athchumr\u00fa"
+        },
         "step": {
             "reconfigure": {
                 "data": {
                     "diaspora": "Lasmuigh d'Iosrael?",
+                    "language": "Teanga",
                     "time_zone": "Crios ama"
                 },
                 "data_description": {
@@ -26,6 +30,7 @@
             "user": {
                 "data": {
                     "diaspora": "Lasmuigh d'Iosrael?",
+                    "language": "Teanga",
                     "time_zone": "Crios ama"
                 },
                 "data_description": {
@@ -176,7 +181,8 @@
                     "name": "D\u00e1ta"
                 },
                 "language": {
-                    "description": "Teanga chun an Omer a chomhaireamh inti."
+                    "description": "Teanga chun an Omer a chomhaireamh inti.",
+                    "name": "Teanga"
                 },
                 "nusach": {
                     "description": "Nusach chun an Omer a chomhaireamh isteach.",

homeassistant/components/jewish_calendar/translations/ko.json

@@ -1,11 +1,28 @@
 {
     "config": {
         "step": {
+            "reconfigure": {
+                "data": {
+                    "elevation": "\uace0\ub3c4",
+                    "language": "\uc5b8\uc5b4",
+                    "location": "\uc704\uce58"
+                }
+            },
             "user": {
                 "data": {
+                    "elevation": "\uace0\ub3c4",
                     "location": "\uc704\uce58"
                 }
             }
         }
+    },
+    "services": {
+        "count_omer": {
+            "fields": {
+                "language": {
+                    "name": "\uc5b8\uc5b4"
+                }
+            }
+        }
     }
 }

homeassistant/components/jewish_calendar/translations/nl.json

@@ -1,4 +1,7 @@
 {
+    "common": {
+        "time_zone": "Tijdzone"
+    },
     "config": {
         "abort": {
             "already_configured": "Apparaat is al geconfigureerd",
@@ -9,14 +12,16 @@
                 "data": {
                     "elevation": "Hoogte",
                     "language": "Taal",
-                    "location": "Locatie"
+                    "location": "Locatie",
+                    "time_zone": "Tijdzone"
                 }
             },
             "user": {
                 "data": {
                     "elevation": "Hoogte",
                     "language": "Taal",
-                    "location": "Locatie"
+                    "location": "Locatie",
+                    "time_zone": "Tijdzone"
                 }
             }
         }

homeassistant/components/justnimbus/translations/ga.json

@@ -0,0 +1,27 @@
+{
+    "config": {
+        "step": {
+            "user": {
+                "data": {
+                    "zip_code": "C\u00f3d ZIP"
+                }
+            }
+        }
+    },
+    "entity": {
+        "sensor": {
+            "pump_type": {
+                "name": "Cine\u00e1l caid\u00e9il"
+            },
+            "reservoir_capacity": {
+                "name": "Cumas an taiscumair"
+            },
+            "water_saved": {
+                "name": "Ioml\u00e1n s\u00e1bh\u00e1ilte"
+            },
+            "water_used": {
+                "name": "\u00das\u00e1id ioml\u00e1n"
+            }
+        }
+    }
+}

homeassistant/components/jvc_projector/translations/ga.json

@@ -1,9 +1,21 @@
 {
     "entity": {
+        "select": {
+            "input": {
+                "name": "Ionchur",
+                "state": {
+                    "hdmi1": "HDMI 1",
+                    "hdmi2": "HDMI 2"
+                }
+            }
+        },
         "sensor": {
             "jvc_power_status": {
+                "name": "St\u00e1das cumhachta",
                 "state": {
-                    "error": "Earr\u00e1id"
+                    "cooling": "Fuar\u00fa",
+                    "error": "Earr\u00e1id",
+                    "warming": "T\u00e9amh"
                 }
             }
         }

homeassistant/components/jvc_projector/translations/it.json

@@ -53,7 +53,7 @@
                 "state": {
                     "cooling": "Raffreddamento",
                     "error": "Errore",
-                    "on": "On",
+                    "on": "Acceso",
                     "standby": "In attesa",
                     "warming": "Riscaldamento"
                 }

homeassistant/components/keba/strings.json

@@ -28,7 +28,7 @@
       "fields": {
         "current": {
           "name": "Current",
-          "description": "The maximum current used for the charging process. The value is depending on the DIP-switch settings and the used cable of the charging station."
+          "description": "The maximum current used for the charging process. The value depends on the DIP switch settings and the cable used by the charging station."
         }
       }
     },