feat: Added event sensor for exposing the discounts (1.5 hours dev time)

Author: BottlecapDave

_docs/entities/fan_club.md

@@ -41,4 +41,25 @@ The next discount for the specified fan club, that differs from the current disc
 |-----------|------|-------------|
 | `source` | `string` | The source of the discount |
 | `start` | `datetime` | The date/time when the discount starts |
-| `end` | `datetime` | The date/time when the discount ends |
+| `end` | `datetime` | The date/time when the discount ends |
+
+## Discounts
+
+`event.octopus_energy_fan_club_{{ACCOUNT_ID}}_{{FAN_CLUB_ID}}_discounts`
+
+The state of this sensor states when the discounts were last retrieved. The attributes of this sensor exposes the available discounts for a given fan club source.
+
+| Attribute | Type | Description |
+|-----------|------|-------------|
+| `discounts` | `array` | The list of past, present and future discounts |
+| `account_id` | `string` | The id of the account the discounts are for |
+| `source` | `string` | The source of the discounts (e.g. Fan #1) |
+
+Each rate item has the following attributes
+
+| Attribute | Type | Description |
+|-----------|------|-------------|
+| `start` | `datetime` | The date/time when the discount starts/started |
+| `end` | `datetime` | The date/time when the discount ends/ended |
+| `discount` | `float` | The value of the discount |
+| `is_estimated` | `boolean` | Determines if the discount is estimated |

custom_components/octopus_energy/__init__.py

@@ -563,7 +563,8 @@ async def async_setup_dependencies(hass, config):
         discounts.append(DiscountSource(source=item.discountSource, discounts=combine_discounts(item)))
 
     if (len(discounts) > 0):
-      hass.data[DOMAIN][account_id][DATA_FAN_CLUB_DISCOUNTS] = FanClubDiscountCoordinatorResult(now, 1, discounts)
+      # Make it old so we can force a refresh
+      hass.data[DOMAIN][account_id][DATA_FAN_CLUB_DISCOUNTS] = FanClubDiscountCoordinatorResult(now - timedelta(days=1), 1, discounts)
       await async_setup_fan_club_discounts_coordinator(hass, account_id, mock_fan_club)
 
 async def options_update_listener(hass, entry):

custom_components/octopus_energy/const.py

@@ -231,6 +231,8 @@
 EVENT_NEW_FREE_ELECTRICITY_SESSION = "octopus_energy_new_octoplus_free_electricity_session"
 EVENT_ALL_FREE_ELECTRICITY_SESSIONS = "octopus_energy_all_octoplus_free_electricity_sessions"
 
+EVENT_FAN_CLUB_DISCOUNTS = "octopus_energy_fan_club_discounts"
+
 REPAIR_UNIQUE_RATES_CHANGED_KEY = "electricity_unique_rates_updated_{}"
 REPAIR_INVALID_API_KEY = "invalid_api_key_{}"
 REPAIR_ACCOUNT_NOT_FOUND = "account_not_found_{}"

custom_components/octopus_energy/coordinators/fan_club_discounts.py

@@ -1,5 +1,6 @@
 import logging
 from datetime import datetime, timedelta
+from typing import Any, Callable
 
 from homeassistant.util.dt import (now)
 from homeassistant.helpers.update_coordinator import (
@@ -12,6 +13,7 @@
   DOMAIN,
   DATA_CLIENT,
   DATA_FAN_CLUB_DISCOUNTS,
+  EVENT_FAN_CLUB_DISCOUNTS,
   REFRESH_RATE_IN_MINUTES_FAN_CLUB_DISCOUNTS,
 )
 
@@ -34,6 +36,7 @@ async def async_refresh_fan_club_discounts(
     account_id: str,
     client: OctopusEnergyApiClient,
     existing_result: FanClubDiscountCoordinatorResult,
+    fire_event: Callable[[str, "dict[str, Any]"], None],
     mock_fan_club: bool = False
 ) -> FanClubDiscountCoordinatorResult:
   if existing_result is None or current >= existing_result.next_refresh:
@@ -48,6 +51,10 @@ async def async_refresh_fan_club_discounts(
         for item in result.fanClubStatus:
           discounts.append(DiscountSource(source=item.discountSource, discounts=combine_discounts(item)))
 
+          # Fire events
+          event_data = { "discounts": list(map(lambda x: x.dict(), discounts[-1].discounts)), "account_id": account_id, "source": discounts[-1].source }
+          fire_event(EVENT_FAN_CLUB_DISCOUNTS, event_data)
+
       return FanClubDiscountCoordinatorResult(current, 1, discounts)
     except Exception as e:
       if isinstance(e, ApiException) == False:
@@ -84,6 +91,7 @@ async def async_update_data():
       account_id,
       client,
       hass.data[DOMAIN][account_id][DATA_FAN_CLUB_DISCOUNTS] if DATA_FAN_CLUB_DISCOUNTS in hass.data[DOMAIN][account_id] else None,
+      hass.bus.async_fire,
       mock_fan_club
     )
 

custom_components/octopus_energy/event.py

@@ -15,10 +15,14 @@
 from .gas.rates_previous_consumption import OctopusEnergyGasPreviousConsumptionRates
 from .octoplus.saving_sessions_events import OctopusEnergyOctoplusSavingSessionEvents
 from .octoplus.free_electricity_sessions_events import OctopusEnergyOctoplusFreeElectricitySessionEvents
+from .coordinators.fan_club_discounts import FanClubDiscountCoordinatorResult
+from .fan_club.discounts import OctopusEnergyFanClubDiscounts
 
 from .const import (
   CONFIG_ACCOUNT_ID,
   DATA_CLIENT,
+  DATA_FAN_CLUB_DISCOUNTS,
+  DATA_FAN_CLUB_DISCOUNTS_COORDINATOR,
   DOMAIN,
 
   CONFIG_MAIN_API_KEY,
@@ -91,5 +95,11 @@ async def async_setup_main_sensors(hass, entry, async_add_entities):
           entities.append(OctopusEnergyGasNextDayRates(hass, meter, point))
           entities.append(OctopusEnergyGasPreviousConsumptionRates(hass, meter, point))
 
+  if DATA_FAN_CLUB_DISCOUNTS_COORDINATOR in hass.data[DOMAIN][account_id]:
+    fan_club_response: FanClubDiscountCoordinatorResult = hass.data[DOMAIN][account_id][DATA_FAN_CLUB_DISCOUNTS]
+    if fan_club_response is not None:
+      for fan_club in fan_club_response.discounts:
+        entities.append(OctopusEnergyFanClubDiscounts(hass, account_id, fan_club.source))
+
   if len(entities) > 0:
     async_add_entities(entities)

custom_components/octopus_energy/fan_club/__init__.py

@@ -9,33 +9,43 @@ class Discount(BaseModel):
     start: datetime
     end: datetime
     discount: float
+    is_estimated: bool
 
 class DiscountSource(BaseModel):
     source: str
     discounts: list[Discount]
 
-def discount_period_to_discount(period: DiscountPeriod) -> Discount:
-  return Discount(start=period.startAt, end=period.startAt + timedelta(minutes=30), discount=float(period.discount) * 100)
+def discount_period_to_discount(period: DiscountPeriod, is_estimated: bool) -> Discount:
+  return Discount(start=period.startAt, end=period.startAt + timedelta(minutes=30), discount=float(period.discount) * 100, is_estimated=is_estimated)
 
 def combine_discounts(status: FanClubStatusItem) -> list[Discount]:
   discounts: list[Discount] = []
 
-  discounts.extend(list(map(lambda x: discount_period_to_discount(x), status.historic)))
-  discounts.append(discount_period_to_discount(status.current))
+  discounts.extend(list(map(lambda x: discount_period_to_discount(x, False), status.historic)))
+
+  # Add current discount period. The current time is basically "now", so depending on where we are will depend on
+  # the number of current discounts that need to be added
+  current = discount_period_to_discount(status.current, True)
+  current.start = current.start.replace(minute=30 if current.start.minute >= 30 else 0, second=0, microsecond=0)
+  current.end = current.start + timedelta(minutes=30)
+  discounts.append(current)
+  if (current.start.minute < 30):
+    discounts.append(Discount(start=current.end, end=current.end + timedelta(minutes=30), discount=current.discount, is_estimated=True))
   for forecast in status.forecast.data:
-    discounts.append(Discount(start=forecast.validTime, end=forecast.validTime + timedelta(minutes=30), discount=float(forecast.projectedDiscount) * 100))
-    discounts.append(Discount(start=forecast.validTime + timedelta(minutes=30), end=forecast.validTime + timedelta(minutes=60), discount=float(forecast.projectedDiscount) * 100))
+    discounts.append(Discount(start=forecast.validTime, end=forecast.validTime + timedelta(minutes=30), discount=float(forecast.projectedDiscount) * 100, is_estimated=True))
+    discounts.append(Discount(start=forecast.validTime + timedelta(minutes=30), end=forecast.validTime + timedelta(minutes=60), discount=float(forecast.projectedDiscount) * 100, is_estimated=True))
 
+  discounts.sort(key=lambda x: x.start)
   return discounts
 
 def get_fan_club_number(discountSource: str):
   return discountSource.split(":")[0].strip()
 
 def mock_fan_club_forecast() -> FanClubResponse:
   now: datetime = utcnow()
-  now = now.replace(minute=30 if now.minute >= 30 else 0, second=0, microsecond=0)
+  now_thirty_minute = now.replace(minute=30 if now.minute >= 30 else 0, second=0, microsecond=0)
   historic = []
-  current = now
+  current = now_thirty_minute
   for i in range(0, 48):
     current = current - timedelta(minutes=30)
     historic.append({
@@ -44,7 +54,7 @@ def mock_fan_club_forecast() -> FanClubResponse:
     })
 
   forecast = []
-  current = now
+  current = now_thirty_minute
   for i in range(0, 48):
     current = current + timedelta(minutes=60)
     forecast.append({
@@ -58,7 +68,7 @@ def mock_fan_club_forecast() -> FanClubResponse:
         "discountSource": "#1 Fan: Market Weighton - Carr Farm",
         "current": {
             "startAt": now,
-            "discount": "0.500"
+            "discount": f"{random.choice([0,0.200,0.500])}"
         },
         "historic": historic,
         "forecast": {

custom_components/octopus_energy/fan_club/current_discount.py

@@ -88,6 +88,8 @@ def _handle_coordinator_update(self) -> None:
       discount_information = None
       if target_discount is not None:
         discount_information = get_current_fan_club_discount_information(target_discount.discounts, current)
+      else:
+        _LOGGER.warning(f"Unable to find discount information for '{self._discount_source}'")
 
       if discount_information is not None:
         self._attributes = {

custom_components/octopus_energy/fan_club/discounts.py

@@ -0,0 +1,62 @@
+import logging
+
+from homeassistant.core import HomeAssistant, callback
+
+from homeassistant.components.event import (
+    EventEntity,
+    EventExtraStoredData,
+)
+from homeassistant.helpers.restore_state import RestoreEntity
+
+from .base import (OctopusEnergyFanClubSensor)
+from ..utils.attributes import dict_to_typed_dict
+from ..const import EVENT_FAN_CLUB_DISCOUNTS
+from . import get_fan_club_number
+
+_LOGGER = logging.getLogger(__name__)
+
+class OctopusEnergyFanClubDiscounts(OctopusEnergyFanClubSensor, EventEntity, RestoreEntity):
+  """Sensor for displaying the current day's rates."""
+
+  def __init__(self, hass: HomeAssistant, account_id: str, discount_source: str):
+    """Init sensor."""
+    # Pass coordinator to base class
+
+    self._hass = hass
+    self._state = None
+    self._last_updated = None
+    self._account_id = account_id
+    self._discount_source = discount_source
+
+    self._attr_event_types = [EVENT_FAN_CLUB_DISCOUNTS]
+    OctopusEnergyFanClubSensor.__init__(self, hass, "event")
+
+  @property
+  def unique_id(self):
+    """The id of the sensor."""
+    return f"octopus_energy_fan_club_{self._account_id}_{get_fan_club_number(self._discount_source)}_discounts"
+    
+  @property
+  def name(self):
+    """Name of the sensor."""
+    return f"Discounts Fan Club ({get_fan_club_number(self._discount_source)}/{self._account_id})"
+
+  async def async_added_to_hass(self):
+    """Call when entity about to be added to hass."""
+    # If not None, we got an initial value.
+    await super().async_added_to_hass()
+    
+    self._hass.bus.async_listen(self._attr_event_types[0], self._async_handle_event)
+
+  async def async_get_last_event_data(self):
+    data = await super().async_get_last_event_data()
+    return EventExtraStoredData.from_dict({
+      "last_event_type": data.last_event_type,
+      "last_event_attributes": dict_to_typed_dict(data.last_event_attributes),
+    })
+
+  @callback
+  def _async_handle_event(self, event) -> None:
+    if (event.data is not None and "account_id" in event.data and event.data["account_id"] == self._account_id and "source" in event.data and event.data["source"] == self._discount_source):
+      self._trigger_event(event.event_type, event.data)
+      self.async_write_ha_state()

custom_components/octopus_energy/fan_club/next_discount.py

@@ -85,6 +85,8 @@ def _handle_coordinator_update(self) -> None:
       discount_information = None
       if target_discount is not None:
         discount_information = get_next_fan_club_discount_information(target_discount.discounts, next)
+      else:
+        _LOGGER.warning(f"Unable to find discount information for '{self._discount_source}'")
 
       if discount_information is not None:
         self._attributes = {

custom_components/octopus_energy/fan_club/previous_discount.py

@@ -85,6 +85,8 @@ def _handle_coordinator_update(self) -> None:
       discount_information = None
       if target_discount is not None:
         discount_information = get_previous_fan_club_discount_information(target_discount.discounts, previous)
+      else:
+        _LOGGER.warning(f"Unable to find discount information for '{self._discount_source}'")
 
       if discount_information is not None:
         self._attributes = {