feat: A better predicted estimated cost (#133)

GuyKh · web-flow · commit e3aaab42536b · 2024-08-10T19:25:25.000+03:00
* feat: A better predicted estimated cost

* feat: A better predicted estimated cost

* feat: a better calculation of days for estimated invoice

* feat: a better calculation of days for estimated invoice

* Additional fix

* Add Sensor State Attributes
diff --git a/custom_components/iec/const.py b/custom_components/iec/const.py
@@ -28,13 +28,22 @@
 CONF_MAIN_CONTRACT_ID = "main_contract_id"
 STATICS_DICT_NAME = "statics"
 ATTRIBUTES_DICT_NAME = "entity_attributes"
+ESTIMATED_BILL_DICT_NAME = "estimated_bill"
 METER_ID_ATTR_NAME = "device_number"
 CONTRACT_ID_ATTR_NAME = "contract_id"
 IS_SMART_METER_ATTR_NAME = "is_smart_meter"
+TOTAL_EST_BILL_ATTR_NAME = "total_estimated_bill"
+EST_BILL_DAYS_ATTR_NAME = "total_bill_days"
+EST_BILL_CONSUMPTION_PRICE_ATTR_NAME = "consumption_price"
+EST_BILL_DELIVERY_PRICE_ATTR_NAME = "delivery_price"
+EST_BILL_DISTRIBUTION_PRICE_ATTR_NAME = "distribution_price"
+EST_BILL_TOTAL_KVA_PRICE_ATTR_NAME = "total_kva_price"
+EST_BILL_KWH_CONSUMPTION_ATTR_NAME = "estimated_kwh_consumption_in_bill"
 INVOICE_DICT_NAME = "invoice"
 CONTRACT_DICT_NAME = "contract"
 DAILY_READINGS_DICT_NAME = "daily_readings"
 FUTURE_CONSUMPTIONS_DICT_NAME = "future_consumption"
 STATIC_KWH_TARIFF = "kwh_tariff"
+STATIC_KVA_TARIFF = "kva_tariff"
 STATIC_BP_NUMBER = "bp_number"
 ELECTRIC_INVOICE_DOC_ID = "1"
diff --git a/custom_components/iec/coordinator.py b/custom_components/iec/coordinator.py
@@ -1,9 +1,11 @@
 """Coordinator to handle IEC connections."""
+import calendar
 import itertools
 import logging
 import socket
 from datetime import datetime, timedelta
 from typing import cast, Any  # noqa: UP035
+from collections import Counter
 
 import pytz
 from homeassistant.components.recorder import get_instance
@@ -21,7 +23,7 @@
 from homeassistant.helpers.update_coordinator import DataUpdateCoordinator
 from iec_api.iec_client import IecClient
 from iec_api.models.contract import Contract
-from iec_api.models.device import Device
+from iec_api.models.device import Device, Devices
 from iec_api.models.exceptions import IECError
 from iec_api.models.jwt import JWT
 from iec_api.models.remote_reading import ReadingResolution, RemoteReading, FutureConsumptionInfo, RemoteReadingResponse
@@ -30,7 +32,10 @@
 from .const import DOMAIN, CONF_USER_ID, STATICS_DICT_NAME, STATIC_KWH_TARIFF, INVOICE_DICT_NAME, \
     FUTURE_CONSUMPTIONS_DICT_NAME, DAILY_READINGS_DICT_NAME, STATIC_BP_NUMBER, ILS, CONF_BP_NUMBER, \
     CONF_SELECTED_CONTRACTS, CONTRACT_DICT_NAME, EMPTY_INVOICE, ELECTRIC_INVOICE_DOC_ID, ATTRIBUTES_DICT_NAME, \
-    CONTRACT_ID_ATTR_NAME, IS_SMART_METER_ATTR_NAME, METER_ID_ATTR_NAME
+    CONTRACT_ID_ATTR_NAME, IS_SMART_METER_ATTR_NAME, METER_ID_ATTR_NAME, STATIC_KVA_TARIFF, ESTIMATED_BILL_DICT_NAME, \
+    TOTAL_EST_BILL_ATTR_NAME, EST_BILL_DAYS_ATTR_NAME, EST_BILL_CONSUMPTION_PRICE_ATTR_NAME, \
+    EST_BILL_DELIVERY_PRICE_ATTR_NAME, EST_BILL_DISTRIBUTION_PRICE_ATTR_NAME, EST_BILL_TOTAL_KVA_PRICE_ATTR_NAME, \
+    EST_BILL_KWH_CONSUMPTION_ATTR_NAME
 
 _LOGGER = logging.getLogger(__name__)
 TIMEZONE = pytz.timezone("Asia/Jerusalem")
@@ -59,7 +64,12 @@ def __init__(
         self._entry_data = config_entry.data
         self._today_readings = {}
         self._devices_by_contract_id = {}
+        self._devices_by_meter_id = {}
+        self._delivery_tariff_by_pahse = {}
+        self._distribution_tariff_by_pahse = {}
+        self._power_size_by_connection_size = {}
         self._kwh_tariff: float | None = None
+        self._kva_tariff: float | None = None
         self._readings = {}
         self.api = IecClient(
             self._entry_data[CONF_USER_ID],
@@ -87,6 +97,16 @@ async def _get_devices_by_contract_id(self, contract_id) -> list[Device]:
                 _LOGGER.exception(f"Failed fetching devices by contract {contract_id}", e)
         return devices
 
+    async def _get_devices_by_device_id(self, meter_id) -> Devices:
+        devices = self._devices_by_meter_id.get(meter_id)
+        if not devices:
+            try:
+                devices = await self.api.get_device_by_device_id(str(meter_id))
+                self._devices_by_meter_id[meter_id] = devices
+            except IECError as e:
+                _LOGGER.exception(f"Failed fetching device details by meter id {meter_id}", e)
+        return devices
+
     async def _get_kwh_tariff(self) -> float:
         if not self._kwh_tariff:
             try:
@@ -95,6 +115,44 @@ async def _get_kwh_tariff(self) -> float:
                 _LOGGER.exception("Failed fetching kWh Tariff", e)
         return self._kwh_tariff or 0.0
 
+    async def _get_kva_tariff(self) -> float:
+        if not self._kva_tariff:
+            try:
+                self._kva_tariff = await self.api.get_kva_tariff()
+            except IECError as e:
+                _LOGGER.exception("Failed fetching KVA Tariff", e)
+        return self._kva_tariff or 0.0
+
+    async def _get_delivery_tariff(self, phase) -> float:
+        delivery_tariff = self._delivery_tariff_by_pahse.get(phase)
+        if not delivery_tariff:
+            try:
+                delivery_tariff = await self.api.get_delivery_tariff(phase)
+                self._delivery_tariff_by_pahse[phase] = delivery_tariff
+            except IECError as e:
+                _LOGGER.exception(f"Failed fetching Delivery Tariff by phase {phase}", e)
+        return delivery_tariff or 0.0
+
+    async def _get_distribution_tariff(self, phase) -> float:
+        distribution_tariff = self._distribution_tariff_by_pahse.get(phase)
+        if not distribution_tariff:
+            try:
+                distribution_tariff = await self.api.get_distribution_tariff(phase)
+                self._distribution_tariff_by_pahse[phase] = distribution_tariff
+            except IECError as e:
+                _LOGGER.exception(f"Failed fetching Distribution Tariff by phase {phase}", e)
+        return distribution_tariff or 0.0
+
+    async def _get_power_size(self, connection_size) -> float:
+        power_size = self._power_size_by_connection_size.get(connection_size)
+        if not power_size:
+            try:
+                power_size = await self.api.get_power_size(connection_size)
+                self._power_size_by_connection_size[connection_size] = power_size
+            except IECError as e:
+                _LOGGER.exception(f"Failed fetching Power Size by Connection Size {connection_size}", e)
+        return power_size or 0.0
+
     async def _get_readings(self, contract_id: int, device_id: str | int, device_code: str | int, date: datetime,
                             resolution: ReadingResolution):
 
@@ -191,13 +249,17 @@ async def _async_update_data(
         contracts: dict[int, Contract] = {int(c.contract_id): c for c in all_contracts if c.status == 1
                                           and int(c.contract_id) in self._contract_ids}
         localized_today = TIMEZONE.localize(datetime.today())
-        tariff = await self._get_kwh_tariff()
+        kwh_tariff = await self._get_kwh_tariff()
+        kva_tariff = await self._get_kva_tariff()
 
         data = {STATICS_DICT_NAME: {
-            STATIC_KWH_TARIFF: tariff,
+            STATIC_KWH_TARIFF: kwh_tariff,
+            STATIC_KVA_TARIFF: kva_tariff,
             STATIC_BP_NUMBER: self._bp_number
         }}
 
+        estimated_bill_dict = None
+
         _LOGGER.debug(f"All Contract Ids: {list(contracts.keys())}")
 
         for contract_id in self._contract_ids:
@@ -311,12 +373,41 @@ async def _async_update_data(
                             else:
                                 _LOGGER.debug("Failed fetching FutureConsumption, data in IEC API is corrupted")
 
+                    devices_by_id: Devices = await self._get_devices_by_device_id(device.device_number)
+                    last_meter_read = int(devices_by_id.counter_devices[0].last_mr)
+                    last_meter_read_date = devices_by_id.counter_devices[0].last_mr_date
+                    phase_count = devices_by_id.counter_devices[0].connection_size.phase
+                    connection_size = (devices_by_id.counter_devices[0].
+                                       connection_size.representative_connection_size)
+
+                    distribution_tariff = await self._get_distribution_tariff(phase_count)
+                    delivery_tariff = await self._get_delivery_tariff(phase_count)
+                    power_size = await self._get_power_size(connection_size)
+
+                    estimated_bill, fixed_price, consumption_price, total_days, delivery_price, distribution_price, \
+                    total_kva_price, estimated_kwh_consumption = (
+                            self._calculate_estimated_bill(device.device_number, future_consumption,
+                                                        last_meter_read, last_meter_read_date,
+                                                        kwh_tariff, kva_tariff, distribution_tariff,
+                                                        delivery_tariff, power_size, last_invoice))
+
+                    estimated_bill_dict = {
+                        TOTAL_EST_BILL_ATTR_NAME: estimated_bill,
+                        EST_BILL_DAYS_ATTR_NAME: total_days,
+                        EST_BILL_CONSUMPTION_PRICE_ATTR_NAME: consumption_price,
+                        EST_BILL_DELIVERY_PRICE_ATTR_NAME: delivery_price,
+                        EST_BILL_DISTRIBUTION_PRICE_ATTR_NAME: distribution_price,
+                        EST_BILL_TOTAL_KVA_PRICE_ATTR_NAME: total_kva_price,
+                        EST_BILL_KWH_CONSUMPTION_ATTR_NAME: estimated_kwh_consumption
+                    }
+
             data[str(contract_id)] = {CONTRACT_DICT_NAME: contracts.get(contract_id),
                                       INVOICE_DICT_NAME: last_invoice,
                                       FUTURE_CONSUMPTIONS_DICT_NAME: future_consumption,
                                       DAILY_READINGS_DICT_NAME: daily_readings,
-                                      STATICS_DICT_NAME: {STATIC_KWH_TARIFF: tariff},  # workaround,
-                                      ATTRIBUTES_DICT_NAME: attributes_to_add
+                                      STATICS_DICT_NAME: {STATIC_KWH_TARIFF: kwh_tariff},  # workaround,
+                                      ATTRIBUTES_DICT_NAME: attributes_to_add,
+                                      ESTIMATED_BILL_DICT_NAME: estimated_bill_dict
                                       }
 
         # Clean up for next cycle
@@ -493,3 +584,57 @@ async def _insert_statistics(self, contract_id: int, is_smart_meter: bool) -> No
             async_add_external_statistics(
                 self.hass, cost_metadata, cost_statistics
             )
+
+    @staticmethod
+    def _calculate_estimated_bill(meter_id, future_consumptions: dict[str, FutureConsumptionInfo | None],
+                                  last_meter_read, last_meter_read_date, kwh_tariff,
+                                  kva_tariff, distribution_tariff, delivery_tariff, power_size, last_invoice):
+        future_consumption_info: FutureConsumptionInfo = future_consumptions[meter_id]
+        future_consumption = future_consumption_info.total_import - last_meter_read
+
+        kva_price = power_size * kva_tariff / 365
+
+        total_kva_price = 0
+        distribution_price = 0
+        delivery_price = 0
+
+        consumption_price = future_consumption * kwh_tariff
+        total_days = 0
+
+        today = TIMEZONE.localize(datetime.today())
+
+        if last_invoice != EMPTY_INVOICE:
+            current_date = last_meter_read_date + timedelta(days=1)
+            month_counter = Counter()
+
+            while current_date <= today.date():
+                # Use (year, month) as the key for counting
+                month_year = (current_date.year, current_date.month)
+                month_counter[month_year] += 1
+
+                # Move to the next day
+                current_date += timedelta(days=1)
+
+            for (year, month), days in month_counter.items():
+                days_in_month = calendar.monthrange(year, month)[1]
+                total_kva_price += kva_price * days
+                distribution_price += (distribution_tariff / days_in_month) * days
+                delivery_price += (delivery_tariff / days_in_month) * days
+                total_days += days
+        else:
+            total_days = today.day
+            days_in_current_month = calendar.monthrange(today.year, today.month)[1]
+
+            consumption_price = future_consumption * kwh_tariff
+            total_kva_price = kva_price * total_days
+            distribution_price = (distribution_tariff / days_in_current_month) * total_days
+            delivery_price = (delivery_tariff / days_in_current_month) * total_days
+
+        _LOGGER.debug(f'Calculated estimated bill: No. of days: {total_days}, total KVA price: {total_kva_price}, '
+                      f'total distribution price: {distribution_price}, total delivery price: {delivery_price}, '
+                      f'consumption price: {consumption_price}')
+
+        fixed_price = total_kva_price + distribution_price + delivery_price
+        total_estimated_bill = consumption_price + fixed_price
+        return total_estimated_bill, fixed_price, consumption_price, total_days, \
+            delivery_price, distribution_price, total_kva_price, future_consumption
diff --git a/custom_components/iec/manifest.json b/custom_components/iec/manifest.json
@@ -10,6 +10,6 @@
   "iot_class": "cloud_polling",
   "issue_tracker": "https://github.com/guykh/iec-custom-component/issues",
   "loggers": ["iec_api"],
-  "requirements": ["iec-api==0.2.16"],
-  "version": "0.0.27"
+  "requirements": ["iec-api==0.3.1"],
+  "version": "0.0.28"
 }
diff --git a/custom_components/iec/sensor.py b/custom_components/iec/sensor.py
@@ -23,7 +23,9 @@
 from .commons import find_reading_by_date, IecEntityType
 from .const import DOMAIN, ILS, STATICS_DICT_NAME, STATIC_KWH_TARIFF, FUTURE_CONSUMPTIONS_DICT_NAME, INVOICE_DICT_NAME, \
     ILS_PER_KWH, DAILY_READINGS_DICT_NAME, EMPTY_REMOTE_READING, CONTRACT_DICT_NAME, EMPTY_INVOICE, \
-    ATTRIBUTES_DICT_NAME, METER_ID_ATTR_NAME
+    ATTRIBUTES_DICT_NAME, METER_ID_ATTR_NAME, ESTIMATED_BILL_DICT_NAME, TOTAL_EST_BILL_ATTR_NAME, EST_BILL_DAYS_ATTR_NAME, \
+    EST_BILL_CONSUMPTION_PRICE_ATTR_NAME, EST_BILL_DELIVERY_PRICE_ATTR_NAME, EST_BILL_DISTRIBUTION_PRICE_ATTR_NAME, \
+    EST_BILL_TOTAL_KVA_PRICE_ATTR_NAME, EST_BILL_KWH_CONSUMPTION_ATTR_NAME
 from .coordinator import IecApiCoordinator
 from .iec_entity import IecEntity
 
@@ -35,6 +37,7 @@ class IecEntityDescriptionMixin:
     """Mixin values for required keys."""
 
     value_fn: Callable[[dict | tuple], str | float | date] | None = None
+    custom_attrs_fn: Callable[[dict | tuple], dict[str, str | int | float | date]] | None = None
 
 
 @dataclass(frozen=True, kw_only=True)
@@ -94,9 +97,9 @@ def _get_reading_by_date(readings: list[RemoteReading] | None, desired_date: dat
         # state_class=SensorStateClass.TOTAL,
         suggested_display_precision=3,
         value_fn=lambda data:
-        (data[FUTURE_CONSUMPTIONS_DICT_NAME][data[ATTRIBUTES_DICT_NAME][METER_ID_ATTR_NAME]].future_consumption or 0)
-        if (data[FUTURE_CONSUMPTIONS_DICT_NAME]
-            and data[FUTURE_CONSUMPTIONS_DICT_NAME][data[ATTRIBUTES_DICT_NAME][METER_ID_ATTR_NAME]]) else None
+        (data[ESTIMATED_BILL_DICT_NAME][EST_BILL_KWH_CONSUMPTION_ATTR_NAME] or 0)
+        if (data[ESTIMATED_BILL_DICT_NAME]
+            and data[ESTIMATED_BILL_DICT_NAME][EST_BILL_KWH_CONSUMPTION_ATTR_NAME]) else None
     ),
     IecMeterEntityDescription(
         key="elec_forecasted_cost",
@@ -105,10 +108,14 @@ def _get_reading_by_date(readings: list[RemoteReading] | None, desired_date: dat
         # state_class=SensorStateClass.TOTAL,
         suggested_display_precision=2,
         # The API doesn't provide future *cost* so we can try to estimate it by the previous consumption
-        value_fn=lambda data:
-        ((data[FUTURE_CONSUMPTIONS_DICT_NAME][data[ATTRIBUTES_DICT_NAME][METER_ID_ATTR_NAME]].future_consumption or 0)
-         * data[STATICS_DICT_NAME][STATIC_KWH_TARIFF]) if (data[FUTURE_CONSUMPTIONS_DICT_NAME]
-                                                           and data[ATTRIBUTES_DICT_NAME][METER_ID_ATTR_NAME]) else None
+        value_fn=lambda data: (data[ESTIMATED_BILL_DICT_NAME][TOTAL_EST_BILL_ATTR_NAME] or 0),
+        custom_attrs_fn=lambda data: {
+            EST_BILL_DAYS_ATTR_NAME: data[ESTIMATED_BILL_DICT_NAME][EST_BILL_DAYS_ATTR_NAME],
+            EST_BILL_CONSUMPTION_PRICE_ATTR_NAME: data[ESTIMATED_BILL_DICT_NAME][EST_BILL_CONSUMPTION_PRICE_ATTR_NAME],
+            EST_BILL_DELIVERY_PRICE_ATTR_NAME: data[ESTIMATED_BILL_DICT_NAME][EST_BILL_DELIVERY_PRICE_ATTR_NAME],
+            EST_BILL_DISTRIBUTION_PRICE_ATTR_NAME: data[ESTIMATED_BILL_DICT_NAME][EST_BILL_DISTRIBUTION_PRICE_ATTR_NAME],
+            EST_BILL_TOTAL_KVA_PRICE_ATTR_NAME: data[ESTIMATED_BILL_DICT_NAME][EST_BILL_TOTAL_KVA_PRICE_ATTR_NAME],
+        } if data[ESTIMATED_BILL_DICT_NAME] else None
     ),
     IecMeterEntityDescription(
         key="elec_today_consumption",
@@ -296,6 +303,11 @@ def __init__(
         if attributes_to_add:
             attributes.update(attributes_to_add)
 
+        if self.entity_description.custom_attrs_fn:
+            attributes.update(self.entity_description.custom_attrs_fn(
+                self.coordinator.data.get(self.contract_id, self.meter_id)
+            ))
+
         if is_multi_contract:
             attributes["is_multi_contract"] = is_multi_contract
             self._attr_translation_placeholders = {"multi_contract": f" of {contract_id}"}
diff --git a/custom_components/iec/translations/en.json b/custom_components/iec/translations/en.json
@@ -7,10 +7,17 @@
     },
     "sensor": {
       "elec_forecasted_usage": {
-        "name": "Next bill electric forecasted usage {multi_contract}"
+        "name": "Next electric bill forecasted usage {multi_contract}"
       },
       "elec_forecasted_cost": {
-        "name": "Next bill electric forecasted cost {multi_contract}"
+        "name": "Next electric bill forecasted cost {multi_contract}",
+        "state_attributes": {
+          "total_bill_days": { "name": "Total Bill Days" },
+          "consumption_price": { "name": "Consumption Price" },
+          "delivery_price": { "name": "Delivery Price" },
+          "distribution_price": { "name": "Distribution Price" },
+          "total_kva_price": { "name": "Total KVA Price" }
+        }
       },
       "elec_today_consumption": {
         "name": "Today electric consumption {multi_contract}"
diff --git a/custom_components/iec/translations/he.json b/custom_components/iec/translations/he.json
@@ -10,7 +10,14 @@
         "name": "סך צריכת החשמל בחשבונית הבאה {multi_contract}"
       },
       "elec_forecasted_cost": {
-        "name": "סך עלות צריכת החשמל בחשבונית הבאה {multi_contract}"
+        "name": "סך עלות צריכת החשמל בחשבונית הבאה {multi_contract}",
+        "state_attributes": {
+          "total_bill_days": { "name": "מס׳ ימים לחיוב" },
+          "consumption_price": { "name": "עלות צריכה" },
+          "delivery_price": { "name": "עלות אספקה" },
+          "distribution_price": { "name": "עלות חלוקה" },
+          "total_kva_price": { "name": "עלות קיבולת לKVA" }
+        }
       },
       "elec_today_consumption": {
         "name": "סך צריכת החשמל היום {multi_contract}"
diff --git a/requirements.txt b/requirements.txt
@@ -1,5 +1,5 @@
 colorlog>=6.8.2
 homeassistant==2024.2.0
-iec-api==0.2.16
+iec-api==0.3.1
 pip>=21.0
-ruff>=0.2.2
+ruff>=0.5.6

Original file line number	Diff line number	Diff line change
`@@ -10,6 +10,6 @@`
`10`	`10`	`"iot_class": "cloud_polling",`
`11`	`11`	`"issue_tracker": "https://github.com/guykh/iec-custom-component/issues",`
`12`	`12`	`"loggers": ["iec_api"],`
`13`		`- "requirements": ["iec-api==0.2.16"],`
`14`		`- "version": "0.0.27"`
	`13`	`+ "requirements": ["iec-api==0.3.1"],`
	`14`	`+ "version": "0.0.28"`
`15`	`15`	`}`