Refactor Jewish Calendar to use EntityDescription (#54852)

homeassistant/components/jewish_calendar/sensor.py

@@ -1,31 +1,147 @@
 """Platform to retrieve Jewish calendar information for Home Assistant."""
+from __future__ import annotations
+
 from datetime import datetime
 import logging
 
 import hdate
 
-from homeassistant.components.sensor import SensorEntity
+from homeassistant.components.sensor import SensorEntity, SensorEntityDescription
 from homeassistant.const import DEVICE_CLASS_TIMESTAMP, SUN_EVENT_SUNSET
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.entity_platform import AddEntitiesCallback
 from homeassistant.helpers.sun import get_astral_event_date
+from homeassistant.helpers.typing import ConfigType, DiscoveryInfoType
 import homeassistant.util.dt as dt_util
 
-from . import DOMAIN, SENSOR_TYPES
+from . import DOMAIN
 
 _LOGGER = logging.getLogger(__name__)
 
+DATA_SENSORS = (
+    SensorEntityDescription(
+        key="date",
+        name="Date",
+        icon="mdi:judaism",
+    ),
+    SensorEntityDescription(
+        key="weekly_portion",
+        name="Parshat Hashavua",
+        icon="mdi:book-open-variant",
+    ),
+    SensorEntityDescription(
+        key="holiday",
+        name="Holiday",
+        icon="mdi:calendar-star",
+    ),
+    SensorEntityDescription(
+        key="omer_count",
+        name="Day of the Omer",
+        icon="mdi:counter",
+    ),
+    SensorEntityDescription(
+        key="daf_yomi",
+        name="Daf Yomi",
+        icon="mdi:book-open-variant",
+    ),
+)
 
-async def async_setup_platform(hass, config, async_add_entities, discovery_info=None):
+TIME_SENSORS = (
+    SensorEntityDescription(
+        key="first_light",
+        name="Alot Hashachar",
+        icon="mdi:weather-sunset-up",
+    ),
+    SensorEntityDescription(
+        key="talit",
+        name="Talit and Tefillin",
+        icon="mdi:calendar-clock",
+    ),
+    SensorEntityDescription(
+        key="gra_end_shma",
+        name='Latest time for Shma Gr"a',
+        icon="mdi:calendar-clock",
+    ),
+    SensorEntityDescription(
+        key="mga_end_shma",
+        name='Latest time for Shma MG"A',
+        icon="mdi:calendar-clock",
+    ),
+    SensorEntityDescription(
+        key="gra_end_tfila",
+        name='Latest time for Tefilla Gr"a',
+        icon="mdi:calendar-clock",
+    ),
+    SensorEntityDescription(
+        key="mga_end_tfila",
+        name='Latest time for Tefilla MG"A',
+        icon="mdi:calendar-clock",
+    ),
+    SensorEntityDescription(
+        key="big_mincha",
+        name="Mincha Gedola",
+        icon="mdi:calendar-clock",
+    ),
+    SensorEntityDescription(
+        key="small_mincha",
+        name="Mincha Ketana",
+        icon="mdi:calendar-clock",
+    ),
+    SensorEntityDescription(
+        key="plag_mincha",
+        name="Plag Hamincha",
+        icon="mdi:weather-sunset-down",
+    ),
+    SensorEntityDescription(
+        key="sunset",
+        name="Shkia",
+        icon="mdi:weather-sunset",
+    ),
+    SensorEntityDescription(
+        key="first_stars",
+        name="T'set Hakochavim",
+        icon="mdi:weather-night",
+    ),
+    SensorEntityDescription(
+        key="upcoming_shabbat_candle_lighting",
+        name="Upcoming Shabbat Candle Lighting",
+        icon="mdi:candle",
+    ),
+    SensorEntityDescription(
+        key="upcoming_shabbat_havdalah",
+        name="Upcoming Shabbat Havdalah",
+        icon="mdi:weather-night",
+    ),
+    SensorEntityDescription(
+        key="upcoming_candle_lighting",
+        name="Upcoming Candle Lighting",
+        icon="mdi:candle",
+    ),
+    SensorEntityDescription(
+        key="upcoming_havdalah",
+        name="Upcoming Havdalah",
+        icon="mdi:weather-night",
+    ),
+)
+
+
+async def async_setup_platform(
+    hass: HomeAssistant,
+    config: ConfigType,
+    async_add_entities: AddEntitiesCallback,
+    discovery_info: DiscoveryInfoType | None = None,
+):
     """Set up the Jewish calendar sensor platform."""
     if discovery_info is None:
         return
 
     sensors = [
-        JewishCalendarSensor(hass.data[DOMAIN], sensor, sensor_info)
-        for sensor, sensor_info in SENSOR_TYPES["data"].items()
+        JewishCalendarSensor(hass.data[DOMAIN], description)
+        for description in DATA_SENSORS
     ]
     sensors.extend(
-        JewishCalendarTimeSensor(hass.data[DOMAIN], sensor, sensor_info)
-        for sensor, sensor_info in SENSOR_TYPES["time"].items()
+        JewishCalendarTimeSensor(hass.data[DOMAIN], description)
+        for description in TIME_SENSORS
     )
 
     async_add_entities(sensors)
@@ -34,20 +150,18 @@ async def async_setup_platform(hass, config, async_add_entities, discovery_info=
 class JewishCalendarSensor(SensorEntity):
     """Representation of an Jewish calendar sensor."""
 
-    def __init__(self, data, sensor, sensor_info):
+    def __init__(self, data, description: SensorEntityDescription) -> None:
         """Initialize the Jewish calendar sensor."""
-        self._type = sensor
-        self._prefix = data["prefix"]
-        self._attr_name = f"{data['name']} {sensor_info[0]}"
-        self._attr_unique_id = f"{self._prefix}_{self._type}"
-        self._attr_icon = sensor_info[1]
+        self.entity_description = description
+        self._attr_name = f"{data['name']} {description.name}"
+        self._attr_unique_id = f"{data['prefix']}_{description.key}"
         self._location = data["location"]
         self._hebrew = data["language"] == "hebrew"
         self._candle_lighting_offset = data["candle_lighting_offset"]
         self._havdalah_offset = data["havdalah_offset"]
         self._diaspora = data["diaspora"]
         self._state = None
-        self._holiday_attrs = {}
+        self._holiday_attrs: dict[str, str] = {}
 
     @property
     def native_value(self):
@@ -87,7 +201,7 @@ class JewishCalendarSensor(SensorEntity):
             after_tzais_date = daytime_date.next_day
 
         self._state = self.get_state(daytime_date, after_shkia_date, after_tzais_date)
-        _LOGGER.debug("New value for %s: %s", self._type, self._state)
+        _LOGGER.debug("New value for %s: %s", self.entity_description.key, self._state)
 
     def make_zmanim(self, date):
         """Create a Zmanim object."""
@@ -100,9 +214,9 @@ class JewishCalendarSensor(SensorEntity):
         )
 
     @property
-    def extra_state_attributes(self):
+    def extra_state_attributes(self) -> dict[str, str]:
         """Return the state attributes."""
-        if self._type != "holiday":
+        if self.entity_description.key != "holiday":
             return {}
         return self._holiday_attrs
 
@@ -110,19 +224,19 @@ class JewishCalendarSensor(SensorEntity):
         """For a given type of sensor, return the state."""
         # Terminology note: by convention in py-libhdate library, "upcoming"
         # refers to "current" or "upcoming" dates.
-        if self._type == "date":
+        if self.entity_description.key == "date":
             return after_shkia_date.hebrew_date
-        if self._type == "weekly_portion":
+        if self.entity_description.key == "weekly_portion":
             # Compute the weekly portion based on the upcoming shabbat.
             return after_tzais_date.upcoming_shabbat.parasha
-        if self._type == "holiday":
+        if self.entity_description.key == "holiday":
             self._holiday_attrs["id"] = after_shkia_date.holiday_name
             self._holiday_attrs["type"] = after_shkia_date.holiday_type.name
             self._holiday_attrs["type_id"] = after_shkia_date.holiday_type.value
             return after_shkia_date.holiday_description
-        if self._type == "omer_count":
+        if self.entity_description.key == "omer_count":
             return after_shkia_date.omer_day
-        if self._type == "daf_yomi":
+        if self.entity_description.key == "daf_yomi":
             return daytime_date.daf_yomi
 
         return None
@@ -141,9 +255,9 @@ class JewishCalendarTimeSensor(JewishCalendarSensor):
         return dt_util.as_utc(self._state).isoformat()
 
     @property
-    def extra_state_attributes(self):
+    def extra_state_attributes(self) -> dict[str, str]:
         """Return the state attributes."""
-        attrs = {}
+        attrs: dict[str, str] = {}
 
         if self._state is None:
             return attrs
@@ -152,24 +266,24 @@ class JewishCalendarTimeSensor(JewishCalendarSensor):
 
     def get_state(self, daytime_date, after_shkia_date, after_tzais_date):
         """For a given type of sensor, return the state."""
-        if self._type == "upcoming_shabbat_candle_lighting":
+        if self.entity_description.key == "upcoming_shabbat_candle_lighting":
             times = self.make_zmanim(
                 after_tzais_date.upcoming_shabbat.previous_day.gdate
             )
             return times.candle_lighting
-        if self._type == "upcoming_candle_lighting":
+        if self.entity_description.key == "upcoming_candle_lighting":
             times = self.make_zmanim(
                 after_tzais_date.upcoming_shabbat_or_yom_tov.first_day.previous_day.gdate
             )
             return times.candle_lighting
-        if self._type == "upcoming_shabbat_havdalah":
+        if self.entity_description.key == "upcoming_shabbat_havdalah":
             times = self.make_zmanim(after_tzais_date.upcoming_shabbat.gdate)
             return times.havdalah
-        if self._type == "upcoming_havdalah":
+        if self.entity_description.key == "upcoming_havdalah":
             times = self.make_zmanim(
                 after_tzais_date.upcoming_shabbat_or_yom_tov.last_day.gdate
             )
             return times.havdalah
 
         times = self.make_zmanim(dt_util.now()).zmanim
-        return times[self._type]
+        return times[self.entity_description.key]