Add config options to set min event duration

README.md

@@ -30,7 +30,7 @@ Sign-up for a free Luno wallet using [this invite link](http://www.luno.com/invi
 
 ### Bitcoin
 `3EGnQKKbF6AijqW9unyBuW8YeEscY5wMSE` 
-<img width="200" alt="image" src="img_9.png">
+<img width="200" alt="Bitcoin address: 3EGnQKKbF6AijqW9unyBuW8YeEscY5wMSE" src="img_9.png">
 
 
 # Manual Install
@@ -149,6 +149,5 @@ rest_command:
  content_type: "application/json; charset=utf-8"
  verify_ssl: true
 ```
-- [Load Shedding (Start)](examples/automation3.yaml) 
-- [Load Shedding (End)](examples/automation4.yaml)
+- [Load Shedding (Start/End)](examples/automation3.yaml)
 </details>

custom_components/load_shedding/__init__.py

@@ -44,6 +44,7 @@
  ATTR_STAGE,
  ATTR_START_TIME,
  CONF_AREAS,
+ CONF_MIN_EVENT_DURATION,
  DEFAULT_SCAN_INTERVAL,
  DOMAIN,
  MANUFACTURER,
@@ -61,29 +62,29 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
  return True
 
 
-async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
+async def async_setup_entry(hass: HomeAssistant, config_entry: ConfigEntry) -> bool:
  """Set up LoadShedding as config entry."""
  if not hass.data.get(DOMAIN):
  hass.data.setdefault(DOMAIN, {})
 
  sepush: SePush = None
- if api_key := entry.options.get(CONF_API_KEY):
+ if api_key := config_entry.options.get(CONF_API_KEY):
  sepush: SePush = SePush(token=api_key)
  if not sepush:
  return False
 
  stage_coordinator = LoadSheddingStageCoordinator(hass, sepush)
  stage_coordinator.update_interval = timedelta(
- seconds=entry.options.get(CONF_SCAN_INTERVAL, DEFAULT_SCAN_INTERVAL)
+ seconds=config_entry.options.get(CONF_SCAN_INTERVAL, DEFAULT_SCAN_INTERVAL)
  )
 
  area_coordinator = LoadSheddingAreaCoordinator(
  hass, sepush, stage_coordinator=stage_coordinator
  )
  area_coordinator.update_interval = timedelta(
- seconds=entry.options.get(CONF_SCAN_INTERVAL, DEFAULT_SCAN_INTERVAL)
+ seconds=config_entry.options.get(CONF_SCAN_INTERVAL, DEFAULT_SCAN_INTERVAL)
  )
- for conf in entry.options.get(CONF_AREAS, {}).values():
+ for conf in config_entry.options.get(CONF_AREAS, {}).values():
  area = Area(
  id=conf.get(CONF_ID),
  name=conf.get(CONF_NAME),
@@ -95,18 +96,18 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
  quota_coordinator = LoadSheddingQuotaCoordinator(hass, sepush)
  quota_coordinator.update_interval = timedelta(seconds=QUOTA_UPDATE_INTERVAL)
 
- hass.data[DOMAIN][entry.entry_id] = {
+ hass.data[DOMAIN][config_entry.entry_id] = {
  ATTR_STAGE: stage_coordinator,
  ATTR_AREA: area_coordinator,
  ATTR_QUOTA: quota_coordinator,
  }
 
- entry.async_on_unload(entry.add_update_listener(update_listener))
+ config_entry.async_on_unload(config_entry.add_update_listener(update_listener))
 
  await stage_coordinator.async_config_entry_first_refresh()
  await area_coordinator.async_config_entry_first_refresh()
  await quota_coordinator.async_config_entry_first_refresh()
- await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
+ await hass.config_entries.async_forward_entry_setups(config_entry, PLATFORMS)
 
  return True
 
@@ -119,14 +120,14 @@ async def async_unload_entry(hass: HomeAssistant, config_entry: ConfigEntry) ->
  return unload_ok
 
 
-async def async_reload_entry(hass: HomeAssistant, entry: ConfigEntry):
+async def async_reload_entry(hass: HomeAssistant, config_entry: ConfigEntry):
  """Reload config entry."""
- await hass.config_entries.async_reload(entry.entry_id)
+ await hass.config_entries.async_reload(config_entry.entry_id)
 
 
-async def update_listener(hass: HomeAssistant, entry: ConfigEntry) -> bool:
+async def update_listener(hass: HomeAssistant, config_entry: ConfigEntry) -> bool:
  """Update listener."""
- return await hass.config_entries.async_reload(entry.entry_id)
+ return await hass.config_entries.async_reload(config_entry.entry_id)
 
 
 async def async_migrate_entry(hass: HomeAssistant, config_entry: ConfigEntry) -> bool:
@@ -288,17 +289,17 @@ async def _async_update_data(self) -> dict:
  return self.data
 
  async def async_update_area(self) -> dict:
- """Retrieve schedule data."""
- areas_stage_schedules: dict = {}
+ """Retrieve area data."""
+ area_id_data: dict = {}
 
  for area in self.areas:
- # Get forecast for area
- events = []
  try:
  esp = await self.hass.async_add_executor_job(self.sepush.area, area.id)
  except SePushError as err:
  raise UpdateFailed(err) from err
 
+ # Get events for area
+ events = []
  for event in esp.get("events", {}):
  note = event.get("note")
  parts = str(note).split(" ")
@@ -318,7 +319,6 @@ async def async_update_area(self) -> dict:
 
  # Get schedule for area
  stage_schedule = {}
- sast = timezone(timedelta(hours=+2), "SAST")
  for day in esp.get("schedule", {}).get("days", []):
  date = datetime.strptime(day.get("date"), "%Y-%m-%d")
  stage_timeslots = day.get("stages", [])
@@ -328,30 +328,8 @@ async def async_update_area(self) -> dict:
  stage_schedule[stage] = []
  for timeslot in timeslots:
  start_str, end_str = timeslot.strip().split("-")
- start = (
- datetime.strptime(start_str, "%H:%M")
- .replace(
- year=date.year,
- month=date.month,
- day=date.day,
- second=0,
- microsecond=0,
- tzinfo=sast,
- )
- .astimezone(timezone.utc)
- )
- end = (
- datetime.strptime(end_str, "%H:%M")
- .replace(
- year=date.year,
- month=date.month,
- day=date.day,
- second=0,
- microsecond=0,
- tzinfo=sast,
- )
- .astimezone(timezone.utc)
- )
+ start = utc_dt(date, datetime.strptime(start_str, "%H:%M"))
+ end = utc_dt(date, datetime.strptime(end_str, "%H:%M"))
  if end < start:
  end = end + timedelta(days=1)
  stage_schedule[stage].append(
@@ -362,12 +340,12 @@ async def async_update_area(self) -> dict:
  }
  )
 
- areas_stage_schedules[area.id] = {
+ area_id_data[area.id] = {
  ATTR_EVENTS: events,
  ATTR_SCHEDULE: stage_schedule,
  }
 
- return areas_stage_schedules
+ return area_id_data
 
  async def async_area_forecast(self) -> None:
  """Derive area forecast from planned stages and area schedule."""
@@ -379,8 +357,6 @@ async def async_area_forecast(self) -> None:
  eskom_stages = stages.get(eskom, {}).get(ATTR_PLANNED, [])
  cape_town_stages = stages.get(cape_town, {}).get(ATTR_PLANNED, [])
 
- now = datetime.now(timezone.utc)
-
  for area_id, data in self.data.items():
  stage_schedules = data.get(ATTR_SCHEDULE)
 
@@ -402,9 +378,6 @@ async def async_area_forecast(self) -> None:
  start_time = timeslot.get(ATTR_START_TIME)
  end_time = timeslot.get(ATTR_END_TIME)
 
- # if end_time < now:
- # continue
-
  if start_time >= planned_end_time:
  continue
  if end_time <= planned_start_time:
@@ -425,6 +398,13 @@ async def async_area_forecast(self) -> None:
  if start_time == end_time:
  continue
 
+ # Minimum event duration
+ min_event_dur = self.stage_coordinator.config_entry.options.get(
+ CONF_MIN_EVENT_DURATION, 30
+ ) # minutes
+ if end_time - start_time < timedelta(minutes=min_event_dur):
+ continue
+
  forecast.append(
  {
  ATTR_STAGE: planned_stage,
@@ -436,6 +416,20 @@ async def async_area_forecast(self) -> None:
  data[ATTR_FORECAST] = forecast
 
 
+def utc_dt(date: datetime, time: datetime) -> datetime:
+ """Given a date and time in SAST, this function returns a datetime object in UTC"""
+ sast = timezone(timedelta(hours=+2), "SAST")
+
+ return time.replace(
+ year=date.year,
+ month=date.month,
+ day=date.day,
+ second=0,
+ microsecond=0,
+ tzinfo=sast,
+ ).astimezone(timezone.utc)
+
+
 class LoadSheddingQuotaCoordinator(DataUpdateCoordinator[dict[str, Any]]):
  """Class to manage fetching LoadShedding Quota."""
 

custom_components/load_shedding/config_flow.py

@@ -25,6 +25,7 @@
  CONF_ADD_AREA,
  CONF_DELETE_AREA,
  CONF_MULTI_STAGE_EVENTS,
+ CONF_MIN_EVENT_DURATION,
  CONF_SETUP_API,
 )
 
@@ -271,6 +272,10 @@ async def async_step_init(
  CONF_MULTI_STAGE_EVENTS,
  default=self.opts.get(CONF_MULTI_STAGE_EVENTS, False),
  ): bool,
+ vol.Optional(
+ CONF_MIN_EVENT_DURATION,
+ default=self.opts.get(CONF_MIN_EVENT_DURATION, 30),
+ ): int,
  }
  )
 
@@ -282,6 +287,7 @@ async def async_step_init(
  # if user_input.get(CONF_ACTION) == CONF_DELETE_AREA:
  # return await self.async_step_delete_area()
  self.opts[CONF_MULTI_STAGE_EVENTS] = user_input.get(CONF_MULTI_STAGE_EVENTS)
+ self.opts[CONF_MIN_EVENT_DURATION] = user_input.get(CONF_MIN_EVENT_DURATION)
  return self.async_create_entry(title=NAME, data=self.opts)
 
  return self.async_show_form(

custom_components/load_shedding/const.py

@@ -29,6 +29,7 @@
 CONF_DELETE_AREA = "delete_area"
 CONF_SETUP_API = "setup_api"
 CONF_MULTI_STAGE_EVENTS = "multi_stage_events"
+CONF_MIN_EVENT_DURATION = "min_event_duration"
 CONF_API_KEY: Final = "api_key"
 CONF_AREA: Final = "area"
 CONF_AREAS: Final = "areas"

custom_components/load_shedding/sensor.py

@@ -176,11 +176,14 @@ def extra_state_attributes(self) -> dict[str, list, Any]:
  data[ATTR_PLANNED].append(planned)
 
  cur_stage = Stage.NO_LOAD_SHEDDING
- if planned := data[ATTR_PLANNED]:
+
+ planned = []
+ if ATTR_PLANNED in data:
+ planned = data[ATTR_PLANNED]
  cur_stage = planned[0].get(ATTR_STAGE, Stage.UNKNOWN)
 
- attrs = get_sensor_attrs(data[ATTR_PLANNED], cur_stage)
- attrs[ATTR_PLANNED] = data[ATTR_PLANNED]
+ attrs = get_sensor_attrs(planned, cur_stage)
+ attrs[ATTR_PLANNED] = planned
  attrs[ATTR_LAST_UPDATE] = self.coordinator.last_update
  attrs = clean(attrs)
 
@@ -238,7 +241,7 @@ def native_value(self) -> StateType:
  events = self.data.get(ATTR_FORECAST, [])
 
  if not events:
- return self._attr_native_value
+ return STATE_OFF
 
  now = datetime.now(timezone.utc)
 
@@ -285,8 +288,12 @@ def extra_state_attributes(self) -> dict[str, list, Any]:
 
  data[ATTR_FORECAST].append(forecast)
 
- attrs = get_sensor_attrs(data[ATTR_FORECAST])
- attrs[ATTR_FORECAST] = data[ATTR_FORECAST]
+ forecast = []
+ if ATTR_FORECAST in data:
+ forecast = data[ATTR_FORECAST]
+
+ attrs = get_sensor_attrs(forecast)
+ attrs[ATTR_FORECAST] = forecast
  attrs[ATTR_LAST_UPDATE] = self.coordinator.last_update
  attrs = clean(attrs)
 

custom_components/load_shedding/strings.json

@@ -49,7 +49,9 @@
  "data": {
  "add_area": "Add area",
  "delete_area": "Remove area",
- "setup_api": "Configure API"
+ "setup_api": "Configure API",
+ "multi_stage_events": "Multi-stage events",
+ "min_event_duration": "Min. event duration (mins)"
  }
  },
  "sepush": {

custom_components/load_shedding/translations/en.json

@@ -57,6 +57,7 @@
  "data": {
  "add_area": "Add area",
  "delete_area": "Remove area",
+ "min_event_duration": "Min. event duration (mins)",
  "multi_stage_events": "Multi-stage events",
  "setup_api": "Configure API"
  },

examples/automation1.yaml

@@ -1,14 +1,22 @@
 alias: Load Shedding (Stage)
-description: ''
+description: ""
 trigger:
  - platform: state
  entity_id:
- - sensor.load_shedding_stage
-condition:
- - condition: template
- value_template: >-
- {{ trigger.from_state.state != 'unavailable' and trigger.to_state.state != 'unavailable' }}
+ - sensor.load_shedding_stage_eskom
+ attribute: stage
+condition: []
 action:
+ - service: notify.mobile_app_nokia_8_sirocco
+ data:
+ title: Load Shedding
+ message: |-
+ {% if is_state_attr(trigger.entity_id, "stage", 0) %}
+ Suspended
+ {% else %}
+ {{ states(trigger.entity_id) }}
+ {% endif %}
+ enabled: true
  - choose:
  - conditions:
  - condition: or
@@ -39,17 +47,29 @@ action:
  at: input_datetime.wake
  continue_on_timeout: false
  default: []
- - service: notify.mobile_app_nokia_8_sirocco
- data:
- title: Load Shedding
- message: '{{ states.sensor.load_shedding_stage.state }}'
  - service: tts.home_assistant_say
  data:
  entity_id: media_player.assistant_speakers
  cache: true
- message: >-
- {% if is_state("sensor.load_shedding_stage", "No Load Shedding") %} Load
- Shedding suspended {% else %} Load Shedding {{
- states.sensor.load_shedding_stage.state }} {% endif %}
- enabled: false
-mode: single
+ message: |-
+ Load Shedding {% if is_state_attr(trigger.entity_id, "stage", 0) %}
+ Suspended
+ {% else %}
+ {{ states(trigger.entity_id) }}
+ {% endif %}
+ - delay:
+ hours: 0
+ minutes: 0
+ seconds: 5
+ milliseconds: 0
+ - if:
+ - condition: state
+ entity_id: sensor.load_shedding_area_eskde_14_milnertoncityofcapetownwesterncape
+ state: "on"
+ then:
+ - service: tts.home_assistant_say
+ data:
+ message: Load shedding imminent!
+ entity_id: media_player.assistant_speakers
+ cache: true
+mode: single