Updated docs, added charge slot list (#48)

* Updated social login instructions

* Added timeout to HTTP requests

* Added experimental charge slot sensor

* Round charge graph slots

* Fix tests...

Author: dan-r

README.md

@@ -30,7 +30,12 @@ This is the recommended installation method.
 ## Setup
 From the Home Assistant Integrations page, search for and add the Ohme integration.
 
-If you created your Ohme account through a social login (Apple/Facebook/Google), you will need to set a password in the Ohme app or 'reset your password' to use this integration.
+### Social Logins
+If you created your Ohme account through an Apple, Facebook or Google account, you will need to set a password in the Ohme app.
+
+Open the menu in the Ohme app (☰) and note the email address shown under your name. This is your login email address and may differ from what you expect.
+
+To set a password, open **Settings** from this menu and click **Account Details > Change Password**. Thanks to [EV Nick](https://www.youtube.com/c/NicolasRaimo) for these instructions.
 
 
 ## Entities
@@ -42,15 +47,16 @@ This integration exposes the following entities:
     * Pending Approval - On when a car is connected and waiting for approval
     * Charge Slot Active - On when a charge slot is in progress according to the Ohme-generated charge plan
     * Charger Online - On if charger is online and connected to the internet
-* Sensors (Charge power) - **Only available during a charge session**
+* Sensors (Session specific) - **Only available during a charge session**
     * Power Draw (Watts) - Power draw of connected car
     * Current Draw (Amps) - Current draw of connected car
     * Voltage (Volts) - Voltage reading
+    * Charge Slots - A comma separated list of assigned charge slots 
+    * Next Charge Slot Start - The next time your car will start charging according to the Ohme-generated charge plan
+    * Next Charge Slot End - The next time your car will stop charging according to the Ohme-generated charge plan
 * Sensors (Other)
     * CT Reading (Amps) - Reading from attached CT clamp
     * Accumulative Energy Usage (kWh) - Total energy used by the charger
-    * Next Charge Slot Start - The next time your car will start charging according to the Ohme-generated charge plan
-    * Next Charge Slot End - The next time your car will stop charging according to the Ohme-generated charge plan
 * Switches (Settings) - **Only options available to your charger model will show**
     * Lock Buttons - Locks buttons on charger
     * Require Approval - Require approval to start a charge
@@ -82,7 +88,7 @@ The coordinators are listed with their refresh intervals below. Relevant coordin
 * OhmeChargeSessionsCoordinator (30s refresh)
     * Binary Sensors: Car connected, car charging, pending approval and charge slot active
     * Buttons: Approve Charge
-    * Sensors: Power, current, voltage and next slot (start & end)
+    * Sensors: Power, current, voltage, charge slots and next slot (start & end)
     * Switches: Max charge, pause charge
     * Inputs: Target time, target percentage and preconditioning (If car connected)
 * OhmeAccountInfoCoordinator (1m refresh)

custom_components/ohme/api_client.py

@@ -41,9 +41,10 @@ def __init__(self, email, password):
         self._last_rule = {}
 
         # Sessions
+        timeout = aiohttp.ClientTimeout(total=10)
         self._session = aiohttp.ClientSession(
-            base_url="https://api.ohme.io")
-        self._auth_session = aiohttp.ClientSession()
+            base_url="https://api.ohme.io", timeout=timeout)
+        self._auth_session = aiohttp.ClientSession(timeout=timeout)
 
     # Auth methods
 

custom_components/ohme/const.py

@@ -1,7 +1,7 @@
 """Component constants"""
 DOMAIN = "ohme"
 USER_AGENT = "dan-r-homeassistant-ohme"
-INTEGRATION_VERSION = "0.4.2"
+INTEGRATION_VERSION = "0.4.3"
 CONFIG_VERSION = 1
 ENTITY_TYPES = ["sensor", "binary_sensor", "switch", "button", "number", "time"]
 

custom_components/ohme/sensor.py

@@ -1,6 +1,6 @@
 """Platform for sensor integration."""
 from __future__ import annotations
-
+from functools import reduce
 from homeassistant.components.sensor import (
     SensorDeviceClass,
     SensorStateClass,
@@ -13,8 +13,7 @@
 from homeassistant.util.dt import (utcnow)
 from .const import DOMAIN, DATA_CLIENT, DATA_COORDINATORS, COORDINATOR_CHARGESESSIONS, COORDINATOR_STATISTICS, COORDINATOR_ADVANCED
 from .coordinator import OhmeChargeSessionsCoordinator, OhmeStatisticsCoordinator, OhmeAdvancedSettingsCoordinator
-from .utils import charge_graph_next_slot
-
+from .utils import charge_graph_next_slot, charge_graph_slot_list
 
 async def async_setup_entry(
     hass: core.HomeAssistant,
@@ -35,7 +34,8 @@ async def async_setup_entry(
                CTSensor(adv_coordinator, hass, client),
                EnergyUsageSensor(stats_coordinator, hass, client),
                NextSlotEndSensor(coordinator, hass, client),
-               NextSlotStartSensor(coordinator, hass, client)]
+               NextSlotStartSensor(coordinator, hass, client),
+               SlotListSensor(coordinator, hass, client)]
 
     async_add_entities(sensors, update_before_add=True)
 
@@ -354,3 +354,59 @@ def _handle_coordinator_update(self) -> None:
         self._last_updated = utcnow()
 
         self.async_write_ha_state()
+
+
+class SlotListSensor(CoordinatorEntity[OhmeChargeSessionsCoordinator], SensorEntity):
+    """Sensor for next smart charge slot end time."""
+    _attr_name = "Charge Slots"
+
+    def __init__(
+            self,
+            coordinator: OhmeChargeSessionsCoordinator,
+            hass: HomeAssistant,
+            client):
+        super().__init__(coordinator=coordinator)
+
+        self._state = None
+        self._attributes = {}
+        self._last_updated = None
+        self._client = client
+
+        self.entity_id = generate_entity_id(
+            "sensor.{}", "ohme_charge_slots", hass=hass)
+
+        self._attr_device_info = hass.data[DOMAIN][DATA_CLIENT].get_device_info(
+        )
+
+    @property
+    def unique_id(self) -> str:
+        """Return the unique ID of the sensor."""
+        return self._client.get_unique_id("charge_slots")
+
+    @property
+    def icon(self):
+        """Icon of the sensor."""
+        return "mdi:timetable"
+
+    @property
+    def native_value(self):
+        """Return pre-calculated state."""
+        return self._state
+
+    @callback
+    def _handle_coordinator_update(self) -> None:
+        """Get a list of charge slots."""
+        if self.coordinator.data is None or self.coordinator.data["mode"] == "DISCONNECTED":
+            self._state = None
+        else:
+            slots = charge_graph_slot_list(
+                self.coordinator.data['startTime'], self.coordinator.data['chargeGraph']['points'])
+
+            # Convert list of tuples to text
+            self._state = reduce(lambda acc, slot: acc + f"{slot[0]}-{slot[1]}, ", slots, "")[:-2]
+
+            # Make sure we return None/Unknown if the list is empty
+            self._state = None if self._state == "" else self._state
+            
+        self._last_updated = utcnow()
+        self.async_write_ha_state()

custom_components/ohme/utils.py

@@ -3,26 +3,21 @@
 from .const import DOMAIN, DATA_OPTIONS
 import pytz
 
-
 def _format_charge_graph(charge_start, points):
     """Convert relative time in points array to real timestamp (s)."""
 
-    charge_start = round(charge_start / 1000)
-    return [{"t": x["x"] + charge_start, "y": x["y"]} for x in points]
+    # Add 30s to effectively round all times to the nearest minute
+    charge_start = round(charge_start / 1000) + 30
 
+    # _LOGGER.debug("Charge slot graph points: " + str([{"t": datetime.fromtimestamp(x["x"] + charge_start).strftime('%H:%M:%S'), "y": x["y"]} for x in points]))
 
-def charge_graph_next_slot(charge_start, points, skip_format=False):
-    """Get the next charge slot start/end times from a list of graph points."""
-    now = int(time())
-    data = points if skip_format else _format_charge_graph(charge_start, points)
+    return [{"t": x["x"] + charge_start, "y": x["y"]} for x in points]
 
-    # Filter to points from now onwards
-    data = [x for x in data if x["t"] > now]
-
-    # Give up if we have less than 2 points
-    if len(data) < 2:
-        return {"start": None, "end": None}
 
+def _next_slot(data, live=False):
+    """Get the next slot. live is whether or not we may start mid charge. Eg: For the next slot end sensor, we dont have the
+       start but still want the end of the in progress session, but for the slot list sensor we only want slots that have
+       a start AND an end."""
     start_ts = None
     end_ts = None
 
@@ -38,16 +33,68 @@ def charge_graph_next_slot(charge_start, points, skip_format=False):
             start_ts = data[idx]["t"] + 1
 
         # Take the first delta of 0 as the end
-        if delta == 0 and not end_ts:
+        if delta == 0 and (start_ts or live) and not end_ts:
             end_ts = data[idx]["t"] + 1
 
+        if start_ts and end_ts:
+            break
+    
+    return [start_ts, end_ts, idx]
+
+
+def charge_graph_next_slot(charge_start, points, skip_format=False):
+    """Get the next charge slot start/end times from a list of graph points."""
+    now = int(time())
+    data = points if skip_format else _format_charge_graph(charge_start, points)
+
+    # Filter to points from now onwards
+    data = [x for x in data if x["t"] > now]
+
+    # Give up if we have less than 2 points
+    if len(data) < 2:
+        return {"start": None, "end": None}
+
+    start_ts, end_ts, final_idx = _next_slot(data, live=True)
+
     # These need to be presented with tzinfo or Home Assistant will reject them
     return {
         "start": datetime.utcfromtimestamp(start_ts).replace(tzinfo=pytz.utc) if start_ts else None,
         "end": datetime.utcfromtimestamp(end_ts).replace(tzinfo=pytz.utc) if end_ts else None,
     }
 
 
+def charge_graph_slot_list(charge_start, points, skip_format=False):
+    """Get list of charge slots from graph points."""
+    now = int(time())
+    data = points if skip_format else _format_charge_graph(charge_start, points)
+
+    # Give up if we have less than 2 points
+    if len(data) < 2:
+        return []
+
+    slots = []
+
+    # While we still have data, keep looping
+    while len(data) > 1:
+        # Get the next slot
+        result = _next_slot(data)
+
+        # Break if we fail
+        if result[0] is None:
+            break
+        
+        # Append a tuple to the slots list with the start end end time
+        slots.append((
+            datetime.fromtimestamp(result[0]).strftime('%H:%M'),
+            datetime.fromtimestamp(result[1]).strftime('%H:%M'),
+        ))
+
+        # Cut off where we got to in this iteration for next time
+        data = data[result[2]:]
+
+    return slots
+
+
 def charge_graph_in_slot(charge_start, points, skip_format=False):
     """Are we currently in a charge slot?"""
     now = int(time())
@@ -75,6 +122,7 @@ def time_next_occurs(hour, minute):
 
     return target
 
+
 def session_in_progress(hass, data):
     """Is there a session in progress?
        Used to check if we should update the current session rather than the first schedule."""
@@ -92,6 +140,7 @@ def session_in_progress(hass, data):
 
     return True
 
+
 def get_option(hass, option):
     """Return option value, default to False."""
     return hass.data[DOMAIN][DATA_OPTIONS].get(option, None)

tests/test_utils.py

@@ -15,10 +15,10 @@ async def test_format_charge_graph(hass):
     start_time_ms = start_time * 1000
 
     result = utils._format_charge_graph(start_time_ms, TEST_DATA)
-    expected = [{"t": TEST_DATA[0]['x'] + start_time, "y": mock.ANY},
-                {"t": TEST_DATA[1]['x'] + start_time, "y": mock.ANY},
-                {"t": TEST_DATA[2]['x'] + start_time, "y": mock.ANY},
-                {"t": TEST_DATA[3]['x'] + start_time, "y": mock.ANY}]
+    expected = [{"t": TEST_DATA[0]['x'] + start_time + 30, "y": mock.ANY},
+                {"t": TEST_DATA[1]['x'] + start_time + 30, "y": mock.ANY},
+                {"t": TEST_DATA[2]['x'] + start_time + 30, "y": mock.ANY},
+                {"t": TEST_DATA[3]['x'] + start_time + 30, "y": mock.ANY}]
 
     assert expected == result