introduce the Metric class (#113)

* introduce the Metric class

* fix errors

* imake extra attr a metric property

* fix unreachable code

* improve meter_values processing

Co-authored-by: lbbrhzn <@lbbrhzn>

Author: lbbrhzn

custom_components/ocpp/api.py

@@ -1,5 +1,6 @@
 """Representation of a OCCP Entities."""
 import asyncio
+from collections import defaultdict
 from datetime import datetime, timedelta, timezone
 import logging
 from math import sqrt
@@ -167,27 +168,28 @@ async def on_connect(self, websocket, path: str):
                 cp = self.charge_points[self.cpid]
                 await self.charge_points[self.cpid].reconnect(websocket)
         except Exception as e:
-            _LOGGER.info(f"Exception occurred:\n{e}")
+            _LOGGER.error(f"Exception occurred:\n{e}", exc_info=True)
+
         finally:
             self.charge_points[self.cpid].status = STATE_UNAVAILABLE
             _LOGGER.info(f"Charger {cp_id} disconnected from {self.host}:{self.port}.")
 
     def get_metric(self, cp_id: str, measurand: str):
         """Return last known value for given measurand."""
         if cp_id in self.charge_points:
-            return self.charge_points[cp_id].get_metric(measurand)
+            return self.charge_points[cp_id]._metrics[measurand].value
         return None
 
     def get_unit(self, cp_id: str, measurand: str):
         """Return unit of given measurand."""
         if cp_id in self.charge_points:
-            return self.charge_points[cp_id].get_unit(measurand)
+            return self.charge_points[cp_id]._metrics[measurand].unit
         return None
 
     def get_extra_attr(self, cp_id: str, measurand: str):
         """Return last known extra attributes for given measurand."""
         if cp_id in self.charge_points:
-            return self.charge_points[cp_id].get_extra_attr(measurand)
+            return self.charge_points[cp_id]._metrics[measurand].extra_attr
         return None
 
     def get_available(self, cp_id: str):
@@ -257,16 +259,14 @@ def __init__(
         # Indicates if the charger requires a reboot to apply new
         # configuration.
         self._requires_reboot = False
-        self._metrics = {}
-        self._units = {}
-        self._extra_attr = {}
         self._features_supported = {}
         self.preparing = asyncio.Event()
         self._transactionId = 0
-        self._metrics[cdet.identifier.value] = id
-        self._units[csess.session_time.value] = TIME_MINUTES
-        self._units[csess.session_energy.value] = UnitOfMeasure.kwh.value
-        self._units[csess.meter_start.value] = UnitOfMeasure.kwh.value
+        self._metrics = defaultdict(lambda: Metric(None, None))
+        self._metrics[cdet.identifier.value].value = id
+        self._metrics[csess.session_time.value].unit = TIME_MINUTES
+        self._metrics[csess.session_energy.value].unit = UnitOfMeasure.kwh.value
+        self._metrics[csess.meter_start.value].unit = UnitOfMeasure.kwh.value
 
     async def post_connect(self):
         """Logic to be executed right after a charger connects."""
@@ -349,7 +349,7 @@ async def handle_get_diagnostics(call):
             #                "StopTxnSampledData", ",".join(self.entry.data[CONF_MONITORED_VARIABLES])
             #            )
             resp = await self.get_configuration(ckey.number_of_connectors.value)
-            self._metrics[cdet.connectors.value] = resp
+            self._metrics[cdet.connectors.value].value = resp
             #            await self.start_transaction()
 
             # Register custom services with home assistant
@@ -397,7 +397,7 @@ async def get_supported_features(self):
         resp = await self.call(req)
         for key_value in resp.configuration_key:
             self._features_supported = key_value[om.value.value]
-            self._metrics[cdet.features.value] = self._features_supported
+            self._metrics[cdet.features.value].value = self._features_supported
             _LOGGER.debug("Supported feature profiles: %s", self._features_supported)
 
     async def trigger_boot_notification(self):
@@ -532,7 +532,7 @@ async def start_transaction(self, limit_amps: int = 32, limit_watts: int = 22000
             stack_level = int(resp)
             req = call.RemoteStartTransactionPayload(
                 connector_id=1,
-                id_tag=self._metrics[cdet.identifier.value],
+                id_tag=self._metrics[cdet.identifier.value].value,
                 charging_profile={
                     om.charging_profile_id.value: 1,
                     om.stack_level.value: stack_level,
@@ -748,8 +748,9 @@ def process_phases(self, data):
                     measurand_data[measurand] = {}
                 measurand_data[measurand][om.unit.value] = unit
                 measurand_data[measurand][phase] = float(value)
-        # store the measurand data as extra attributes
-        self._extra_attr.update(measurand_data)
+                self._metrics[measurand].extra_attr[om.unit.value] = unit
+                self._metrics[measurand].extra_attr[phase] = float(value)
+
         for metric, phase_info in measurand_data.items():
             # _LOGGER.debug("Metric: %s, extra attributes: %s", metric, phase_info)
             metric_value = None
@@ -782,56 +783,68 @@ def process_phases(self, data):
                         + phase_info.get(Phase.l3.value, 0)
                     )
             if metric_value is not None:
-                self._metrics[metric] = round(metric_value, 1)
+                self._metrics[metric].value = round(metric_value, 1)
 
     @on(Action.MeterValues)
     def on_meter_values(self, connector_id: int, meter_value: Dict, **kwargs):
         """Request handler for MeterValues Calls."""
-        m = om.measurand.value
         for bucket in meter_value:
             unprocessed = bucket[om.sampled_value.name]
             processed_keys = []
             for idx, sv in enumerate(bucket[om.sampled_value.name]):
-                if m in sv and om.phase.value not in sv:
-                    self._metrics[sv[m]] = round(float(sv[om.value.value]), 1)
-                    if om.unit.value in sv:
-                        if sv[om.unit.value] == DEFAULT_POWER_UNIT:
-                            self._metrics[sv[m]] = float(sv[om.value.value]) / 1000
-                            self._units[sv[m]] = HA_POWER_UNIT
-                        if sv[om.unit.value] == DEFAULT_ENERGY_UNIT:
-                            self._metrics[sv[m]] = float(sv[om.value.value]) / 1000
-                            self._units[sv[m]] = HA_ENERGY_UNIT
+                measurand = sv.get(om.measurand.value, None)
+                value = sv.get(om.value.value, None)
+                unit = sv.get(om.unit.value, None)
+                phase = sv.get(om.phase.value, None)
+                location = sv.get(om.location.value, None)
+
+                if len(sv.keys()) == 1:  # Backwars compatibility
+                    measurand = DEFAULT_MEASURAND
+                    unit = DEFAULT_ENERGY_UNIT
+
+                if phase is None:
+                    if unit == DEFAULT_POWER_UNIT:
+                        self._metrics[measurand].value = float(value) / 1000
+                        self._metrics[measurand].unit = HA_POWER_UNIT
+                    elif unit == DEFAULT_ENERGY_UNIT:
+                        self._metrics[measurand].value = float(value) / 1000
+                        self._metrics[measurand].unit = HA_ENERGY_UNIT
+                    else:
+                        self._metrics[measurand].value = round(float(value), 1)
+                        self._metrics[measurand].unit = unit
+                    if location is not None:
+                        self._metrics[measurand].extra_attr[
+                            om.location.value
+                        ] = location
                     processed_keys.append(idx)
-                if len(sv.keys()) == 1:  # for backwards compatibility
-                    self._metrics[DEFAULT_MEASURAND] = float(sv[om.value.value]) / 1000
-                    self._units[DEFAULT_MEASURAND] = HA_ENERGY_UNIT
-                    processed_keys.append(idx)
-                if m in sv and om.location.value in sv:
-                    if self._extra_attr.get(sv[m]) is None:
-                        self._extra_attr[sv[m]] = {}
-                    self._extra_attr[sv[m]][om.location.value] = sv.get(
-                        om.location.value
-                    )
             for idx in sorted(processed_keys, reverse=True):
                 unprocessed.pop(idx)
             # _LOGGER.debug("Meter data not yet processed: %s", unprocessed)
             if unprocessed is not None:
                 self.process_phases(unprocessed)
         if csess.meter_start.value not in self._metrics:
-            self._metrics[csess.meter_start.value] = self._metrics[DEFAULT_MEASURAND]
+            self._metrics[csess.meter_start.value].value = self._metrics[
+                DEFAULT_MEASURAND
+            ]
         if csess.transaction_id.value not in self._metrics:
-            self._metrics[csess.transaction_id.value] = kwargs.get(
+            self._metrics[csess.transaction_id.value].value = kwargs.get(
                 om.transaction_id.name
             )
             self._transactionId = kwargs.get(om.transaction_id.name)
-        self._metrics[csess.session_time.value] = round(
-            (int(time.time()) - float(self._metrics[csess.transaction_id.value])) / 60
-        )
-        self._metrics[csess.session_energy.value] = round(
-            float(self._metrics[DEFAULT_MEASURAND])
-            - float(self._metrics[csess.meter_start.value]),
-            1,
-        )
+        if self._metrics[csess.transaction_id.value].value is not None:
+            self._metrics[csess.session_time.value].value = round(
+                (
+                    int(time.time())
+                    - float(self._metrics[csess.transaction_id.value].value)
+                )
+                / 60
+            )
+        if self._metrics[csess.meter_start.value].value is not None:
+            self._metrics[csess.session_energy.value].value = round(
+                float(self._metrics[DEFAULT_MEASURAND].value or 0)
+                - float(self._metrics[csess.meter_start.value].value),
+                1,
+            )
         self.hass.async_create_task(self.central.update(self.central.cpid))
         return call_result.MeterValuesPayload()
 
@@ -842,12 +855,16 @@ def on_boot_notification(self, **kwargs):
         _LOGGER.debug("Received boot notification for %s: %s", self.id, kwargs)
 
         # update metrics
-        self._metrics[cdet.model.value] = kwargs.get(om.charge_point_model.name, None)
-        self._metrics[cdet.vendor.value] = kwargs.get(om.charge_point_vendor.name, None)
-        self._metrics[cdet.firmware_version.value] = kwargs.get(
+        self._metrics[cdet.model.value].value = kwargs.get(
+            om.charge_point_model.name, None
+        )
+        self._metrics[cdet.vendor.value].value = kwargs.get(
+            om.charge_point_vendor.name, None
+        )
+        self._metrics[cdet.firmware_version.value].value = kwargs.get(
             om.firmware_version.name, None
         )
-        self._metrics[cdet.serial.value] = kwargs.get(
+        self._metrics[cdet.serial.value].value = kwargs.get(
             om.charge_point_serial_number.name, None
         )
 
@@ -862,25 +879,25 @@ def on_boot_notification(self, **kwargs):
     @on(Action.StatusNotification)
     def on_status_notification(self, connector_id, error_code, status, **kwargs):
         """Handle a status notification."""
-        self._metrics[cstat.status.value] = status
+        self._metrics[cstat.status.value].value = status
         if (
             status == ChargePointStatus.suspended_ev.value
             or status == ChargePointStatus.suspended_evse.value
         ):
             if Measurand.current_import.value in self._metrics:
-                self._metrics[Measurand.current_import.value] = 0
+                self._metrics[Measurand.current_import.value].value = 0
             if Measurand.power_active_import.value in self._metrics:
-                self._metrics[Measurand.power_active_import.value] = 0
+                self._metrics[Measurand.power_active_import.value].value = 0
             if Measurand.power_reactive_import.value in self._metrics:
-                self._metrics[Measurand.power_reactive_import.value] = 0
-        self._metrics[cstat.error_code.value] = error_code
+                self._metrics[Measurand.power_reactive_import.value].value = 0
+        self._metrics[cstat.error_code.value].value = error_code
         self.hass.async_create_task(self.central.update(self.central.cpid))
         return call_result.StatusNotificationPayload()
 
     @on(Action.FirmwareStatusNotification)
     def on_firmware_status(self, status, **kwargs):
         """Handle firmware status notification."""
-        self._metrics[cstat.firmware_status.value] = status
+        self._metrics[cstat.firmware_status.value].value = status
         self.hass.async_create_task(self.central.update(self.central.cpid))
         return call_result.FirmwareStatusNotificationPayload()
 
@@ -901,9 +918,9 @@ def on_authorize(self, id_tag, **kwargs):
     def on_start_transaction(self, connector_id, id_tag, meter_start, **kwargs):
         """Handle a Start Transaction request."""
         self._transactionId = int(time.time())
-        self._metrics[cstat.stop_reason.value] = ""
-        self._metrics[csess.transaction_id.value] = self._transactionId
-        self._metrics[csess.meter_start.value] = int(meter_start) / 1000
+        self._metrics[cstat.stop_reason.value].value = ""
+        self._metrics[csess.transaction_id.value].value = self._transactionId
+        self._metrics[csess.meter_start.value].value = int(meter_start) / 1000
         self.hass.async_create_task(self.central.update(self.central.cpid))
         return call_result.StartTransactionPayload(
             id_tag_info={om.status.value: AuthorizationStatus.accepted.value},
@@ -913,19 +930,20 @@ def on_start_transaction(self, connector_id, id_tag, meter_start, **kwargs):
     @on(Action.StopTransaction)
     def on_stop_transaction(self, meter_stop, timestamp, transaction_id, **kwargs):
         """Stop the current transaction."""
-        self._metrics[cstat.stop_reason.value] = kwargs.get(om.reason.name, None)
+        self._metrics[cstat.stop_reason.value].value = kwargs.get(om.reason.name, None)
 
-        if csess.meter_start.value in self._metrics:
-            self._metrics[csess.session_energy.value] = round(
-                int(meter_stop) / 1000 - float(self._metrics[csess.meter_start.value]),
+        if self._metrics[csess.meter_start.value].value is not None:
+            self._metrics[csess.session_energy.value].value = round(
+                int(meter_stop) / 1000
+                - float(self._metrics[csess.meter_start.value].value),
                 1,
             )
         if Measurand.current_import.value in self._metrics:
-            self._metrics[Measurand.current_import.value] = 0
+            self._metrics[Measurand.current_import.value].value = 0
         if Measurand.power_active_import.value in self._metrics:
-            self._metrics[Measurand.power_active_import.value] = 0
+            self._metrics[Measurand.power_active_import.value].value = 0
         if Measurand.power_reactive_import.value in self._metrics:
-            self._metrics[Measurand.power_reactive_import.value] = 0
+            self._metrics[Measurand.power_reactive_import.value].value = 0
         self.hass.async_create_task(self.central.update(self.central.cpid))
         return call_result.StopTransactionPayload(
             id_tag_info={om.status.value: AuthorizationStatus.accepted.value}
@@ -941,18 +959,58 @@ def on_data_transfer(self, vendor_id, **kwargs):
     def on_heartbeat(self, **kwargs):
         """Handle a Heartbeat."""
         now = datetime.now(tz=timezone.utc).isoformat()
-        self._metrics[cstat.heartbeat.value] = now
+        self._metrics[cstat.heartbeat.value].value = now
         self.hass.async_create_task(self.central.update(self.central.cpid))
         return call_result.HeartbeatPayload(current_time=now)
 
     def get_metric(self, measurand: str):
         """Return last known value for given measurand."""
-        return self._metrics.get(measurand, None)
+        return self._metrics[measurand].value
 
     def get_extra_attr(self, measurand: str):
         """Return last known extra attributes for given measurand."""
-        return self._extra_attr.get(measurand, None)
+        return self._metrics[measurand].extra_attr
 
     def get_unit(self, measurand: str):
         """Return unit of given measurand."""
-        return self._units.get(measurand, None)
+        return self._metrics[measurand].unit
+
+
+class Metric:
+    """Metric class."""
+
+    def __init__(self, value, unit):
+        """Initialize a Metric."""
+        self._value = value
+        self._unit = unit
+        self._extra_attr = {}
+
+    @property
+    def value(self):
+        """Get the value of the metric."""
+        return self._value
+
+    @value.setter
+    def value(self, value):
+        """Set the value of the metric."""
+        self._value = value
+
+    @property
+    def unit(self):
+        """Get the unit of the metric."""
+        return self._unit
+
+    @unit.setter
+    def unit(self, unit: str):
+        """Set the unit of the metric."""
+        self._unit = unit
+
+    @property
+    def extra_attr(self):
+        """Get the extra attributes of the metric."""
+        return self._extra_attr
+
+    @extra_attr.setter
+    def extra_attr(self, extra_attr: dict):
+        """Set the unit of the metric."""
+        self._extra_attr = extra_attr