e-data 1.2.7__tar.gz → 1.2.8__tar.gz

{e-data-1.2.7/e_data.egg-info → e-data-1.2.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: e-data
-Version: 1.2.7
+Version: 1.2.8
 Summary: Python library for managing spanish energy data from various web providers
 Home-page: https://github.com/uvejota/python-edata
 Author: VMG

{e-data-1.2.7 → e-data-1.2.8/e_data.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: e-data
-Version: 1.2.7
+Version: 1.2.8
 Summary: Python library for managing spanish energy data from various web providers
 Home-page: https://github.com/uvejota/python-edata
 Author: VMG

{e-data-1.2.7 → e-data-1.2.8}/edata/connectors/datadis.py

@@ -1,5 +1,13 @@
-"""Definitions for API connectors."""
+"""Datadis API connector.
 
+To fetch data from datadis.es private API.
+There a few issues that are workarounded:
+ - You have to wait 24h between two identical requests.
+ - Datadis server does not like ranges greater than 1 month.
+ - TODO: gzip header checksum errors under weird circumstances
+"""
+
+import contextlib
 import hashlib
 import json
 import logging
@@ -14,9 +22,12 @@ from ..processors import utils
 
 _LOGGER = logging.getLogger(__name__)
 
+# Token-related constants
 URL_TOKEN = "https://datadis.es/nikola-auth/tokens/login"
 TOKEN_USERNAME = "username"
 TOKEN_PASSWD = "password"
+
+# Supplies-related constants
 URL_GET_SUPPLIES = "https://datadis.es/api-private/api/get-supplies"
 GET_SUPPLIES_MANDATORY_FIELDS = [
     "cups",
@@ -25,6 +36,8 @@ GET_SUPPLIES_MANDATORY_FIELDS = [
     "pointType",
     "distributorCode",
 ]
+
+# Contracts-related constants
 URL_GET_CONTRACT_DETAIL = "https://datadis.es/api-private/api/get-contract-detail"
 GET_CONTRACT_DETAIL_MANDATORY_FIELDS = [
     "startDate",
@@ -32,6 +45,8 @@ GET_CONTRACT_DETAIL_MANDATORY_FIELDS = [
     "marketer",
     "contractedPowerkW",
 ]
+
+# Consumption-related constants
 URL_GET_CONSUMPTION_DATA = "https://datadis.es/api-private/api/get-consumption-data"
 GET_CONSUMPTION_DATA_MANDATORY_FIELDS = [
     "time",
@@ -39,17 +54,23 @@ GET_CONSUMPTION_DATA_MANDATORY_FIELDS = [
     "consumptionKWh",
     "obtainMethod",
 ]
+MAX_CONSUMPTIONS_MONTHS = (
+    1  # max consumptions in a single request (fixed to 1 due to datadis limitations)
+)
+
+# Maximeter-related constants
 URL_GET_MAX_POWER = "https://datadis.es/api-private/api/get-max-power"
 GET_MAX_POWER_MANDATORY_FIELDS = ["time", "date", "maxPower"]
 
-TIMEOUT = 3 * 60
-
-MAX_CONSUMPTIONS_MONTHS = 1
-
-QUERY_LIMIT = timedelta(hours=24)
+# Timing constants
+TIMEOUT = 3 * 60  # requests timeout
+QUERY_LIMIT = timedelta(hours=24)  # a datadis limitation, again...
 
+# Cache-related constants
 RECENT_QUERIES_FILENAME = "edata_recent_queries.json"
-RECENT_QUERIES_FILE = f"/tmp/{RECENT_QUERIES_FILENAME}"
+RECENT_QUERIES_CACHE_FILENAME = "edata_recent_queries_cache.json"
+DEFAULT_RECENT_QUERIES_FILE = f"/tmp/{RECENT_QUERIES_FILENAME}"
+DEFAULT_RECENT_QUERIES_CACHE = f"/tmp/{RECENT_QUERIES_CACHE_FILENAME}"
 
 
 class DatadisConnector:
@@ -62,54 +83,71 @@ class DatadisConnector:
         enable_smart_fetch: bool = True,
         storage_path: str | None = None,
     ) -> None:
-        """Init method."""
+        """DatadisConnector constructor."""
 
+        # initialize some things
         self._usr = username
         self._pwd = password
         self._session = requests.Session()
         self._token = {}
         self._smart_fetch = enable_smart_fetch
-
+        self._recent_queries = {}
+        self._recent_cache = {}
         if storage_path is not None:
             self._recent_queries_file = os.path.join(
                 storage_path, RECENT_QUERIES_FILENAME
             )
-            # TODO FIX this is not working after migration
+            self._recent_queries_cache_file = os.path.join(
+                storage_path, RECENT_QUERIES_CACHE_FILENAME
+            )
         else:
-            self._recent_queries_file = RECENT_QUERIES_FILE
-
+            self._recent_queries_file = DEFAULT_RECENT_QUERIES_FILE
+            self._recent_queries_cache_file = DEFAULT_RECENT_QUERIES_CACHE
         self._warned_queries = []
 
-        try:
+        # load caches (to avoid query spam if the program restarts)
+        with contextlib.suppress(FileNotFoundError):
             with open(self._recent_queries_file, encoding="utf8") as dst_file:
                 self._recent_queries = json.load(dst_file)
                 for query in self._recent_queries:
                     self._recent_queries[query] = datetime.fromisoformat(
                         self._recent_queries[query]
                     )
-        except FileNotFoundError:
-            self._recent_queries = {}
+            with open(self._recent_queries_cache_file, encoding="utf8") as dst_file:
+                self._recent_cache = json.load(dst_file)
 
-    def _update_recent_queries(self, query: str) -> None:
-        """Record a recent successful query to avoid exceeding query limits."""
+    def _update_recent_queries(self, query: str, data: dict | None = None) -> None:
+        """Cache a successful query to avoid exceeding query limits."""
 
+        # identify the query by a md5 hash
         hash_query = hashlib.md5(query.encode()).hexdigest()
+        # prepare key (hash) and values (timestamp and response)
         self._recent_queries[hash_query] = datetime.now()
+        if data is not None:
+            self._recent_cache[hash_query] = data
 
-        # purge old queries
+        # purge old cache
         to_delete = []
         for _query in self._recent_queries:
             if (datetime.now() - self._recent_queries[_query]) > QUERY_LIMIT:
                 to_delete.append(_query)
 
         for key in to_delete:
-            self._recent_queries.pop(key, None)
+            with contextlib.suppress(KeyError):
+                self._recent_queries.pop(key, None)
+                self._recent_cache.pop(key, None)
 
+        # dump current cache to disk
         try:
             with open(self._recent_queries_file, "w", encoding="utf8") as dst_file:
                 json.dump(utils.serialize_dict(self._recent_queries), dst_file)
-        except Exception:
-            pass
+            if data is not None:
+                with open(
+                    self._recent_queries_cache_file, "w", encoding="utf8"
+                ) as dst_file:
+                    json.dump(self._recent_cache, dst_file)
+        except Exception as e:
+            _LOGGER.warning("Unknown error while updating cache: %s", e)
 
     def _is_recent_query(self, query: str) -> bool:
         """Check if a query has been done recently to avoid exceeding query limits."""
@@ -119,6 +157,12 @@ class DatadisConnector:
             return (datetime.now() - self._recent_queries[hash_query]) < QUERY_LIMIT
         return False
 
+    def _get_cache_for_query(self, query: str) -> dict:
+        """Return cached response for a query."""
+        hash_query = hashlib.md5(query.encode()).hexdigest()
+
+        return self._recent_cache.get(hash_query, None)
+
     def _get_token(self):
         """Private method that fetches a new token if needed."""
 
@@ -137,7 +181,6 @@ class DatadisConnector:
             self._token["encoded"] = response.text
             # prepare session authorization bearer
             self._session.headers["Authorization"] = "Bearer " + self._token["encoded"]
-            _LOGGER.debug("token received")
             is_valid_token = True
         else:
             _LOGGER.error("Unknown error while retrieving token, got %s", response.text)
@@ -147,7 +190,7 @@ class DatadisConnector:
         """Test to login with provided credentials."""
         return self._get_token()
 
-    def _send_cmd(
+    def _get(
         self,
         url: str,
         request_data: dict | None = None,
@@ -155,7 +198,7 @@ class DatadisConnector:
         is_retry: bool = False,
         ignore_recent_queries: bool = False,
     ):
-        """Common method for GET requests."""
+        """Get request for Datadis API."""
 
         if request_data is None:
             data = {}
@@ -174,31 +217,49 @@ class DatadisConnector:
                 key = param
                 value = data[param]
                 params = params + f"{key}={value}&"
-            # query
 
+            # check if query is already in cache
             if not ignore_recent_queries and self._is_recent_query(url + params):
-                return response
+                _cache = self._get_cache_for_query(url + params)
+                if _cache is not None:
+                    return _cache
+                return []
 
+            # run the query
             try:
-                _LOGGER.info("GET %s", url + params)
-                reply = self._session.get(url + params, timeout=TIMEOUT)
+                _LOGGER.debug("GET %s", url + params)
+                reply = self._session.get(
+                    url + params,
+                    headers={"Accept-Encoding": "identity"},
+                    timeout=TIMEOUT,
+                )
             except requests.exceptions.Timeout:
                 _LOGGER.warning("Timeout at %s", url + params)
-                return response
+                return []
 
             # eval response
-            if reply.status_code == 200 and reply.json():
+            if reply.status_code == 200:
+                # we're here if reply seems valid
                 _LOGGER.info("Got 200 OK at %s", url + params)
-                response = reply.json()
-                self._update_recent_queries(url + params)
+                if reply.json():
+                    response = reply.json()
+                    self._update_recent_queries(url + params, response)
+                else:
+                    # this mostly happens when datadis provides an empty response
+                    _LOGGER.info(
+                        "Datadis returned an empty response at %s", url + params
+                    )
+                    self._update_recent_queries(url + params)
             elif reply.status_code == 401 and not refresh_token:
-                response = self._send_cmd(
+                # we're here if we were unauthorized so we will refresh the token
+                response = self._get(
                     url,
                     request_data=data,
                     refresh_token=True,
                     ignore_recent_queries=ignore_recent_queries,
                 )
             elif reply.status_code == 429:
+                # we're here if we exceeded datadis API rates (24h)
                 _LOGGER.warning(
                     "%s %s at %s",
                     reply.status_code,
@@ -206,12 +267,8 @@ class DatadisConnector:
                     url + params,
                 )
                 self._update_recent_queries(url + params)
-            elif reply.status_code == 200:
-                _LOGGER.info(
-                    "%s returned an empty response, try again later", url + params
-                )
-                self._update_recent_queries(url + params)
             elif is_retry:
+                # otherwise, if this was a retried request... warn the user
                 if (url + params) not in self._warned_queries:
                     _LOGGER.warning(
                         "%s %s at %s. %s. %s",
@@ -224,41 +281,61 @@ class DatadisConnector:
                 self._update_recent_queries(url + params)
                 self._warned_queries.append(url + params)
             else:
-                self._send_cmd(url, request_data, is_retry=True)
+                # finally, retry since an unexpected error took place (mostly 500 errors - server fault)
+                response = self._get(
+                    url,
+                    request_data,
+                    is_retry=True,
+                    ignore_recent_queries=ignore_recent_queries,
+                )
+
         return response
 
     def get_supplies(self, authorized_nif: str | None = None):
-        """Datadis get_supplies query."""
+        """Datadis 'get_supplies' query."""
+
         data = {}
+
+        # If authorized_nif is provided, we have to include it as parameter
         if authorized_nif is not None:
             data["authorizedNif"] = authorized_nif
-        response = self._send_cmd(
+
+        # Request the resource
+        response = self._get(
             URL_GET_SUPPLIES, request_data=data, ignore_recent_queries=False
         )
+
+        # Response is a list of serialized supplies.
+        # We will iter through them to transform them into SupplyData objects
         supplies = []
+        # Build tomorrow Y/m/d string since we will use it as the 'date_end' of
+        # active supplies
         tomorrow_str = (datetime.today() + timedelta(days=1)).strftime("%Y/%m/%d")
         for i in response:
+            # check data integrity (maybe this can be supressed if datadis proves to be reliable)
             if all(k in i for k in GET_SUPPLIES_MANDATORY_FIELDS):
                 supplies.append(
                     SupplyData(
-                        cups=i["cups"],
+                        cups=i["cups"],  # the supply identifier
                         date_start=datetime.strptime(
                             i["validDateFrom"]
                             if i["validDateFrom"] != ""
                             else "1970/01/01",
                             "%Y/%m/%d",
-                        ),
+                        ),  # start date of the supply. 1970/01/01 if unset.
                         date_end=datetime.strptime(
                             i["validDateTo"]
                             if i["validDateTo"] != ""
                             else tomorrow_str,
                             "%Y/%m/%d",
-                        ),
+                        ),  # end date of the supply, tomorrow if unset
+                        # the following parameters are not crucial, so they can be none
                         address=i["address"] if "address" in i else None,
                         postal_code=i["postalCode"] if "postalCode" in i else None,
                         province=i["province"] if "province" in i else None,
                         municipality=i["municipality"] if "municipality" in i else None,
                         distributor=i["distributor"] if "distributor" in i else None,
+                        # these two are mandatory, we will use them to fetch contracts data
                         pointType=i["pointType"],
                         distributorCode=i["distributorCode"],
                     )
@@ -277,7 +354,7 @@ class DatadisConnector:
         data = {"cups": cups, "distributorCode": distributor_code}
         if authorized_nif is not None:
             data["authorizedNif"] = authorized_nif
-        response = self._send_cmd(
+        response = self._get(
             URL_GET_CONTRACT_DETAIL, request_data=data, ignore_recent_queries=False
         )
         contracts = []
@@ -359,7 +436,7 @@ class DatadisConnector:
         if authorized_nif is not None:
             data["authorizedNif"] = authorized_nif
 
-        response = self._send_cmd(URL_GET_CONSUMPTION_DATA, request_data=data)
+        response = self._get(URL_GET_CONSUMPTION_DATA, request_data=data)
 
         consumptions = []
         for i in response:
@@ -405,7 +482,7 @@ class DatadisConnector:
         }
         if authorized_nif is not None:
             data["authorizedNif"] = authorized_nif
-        response = self._send_cmd(URL_GET_MAX_POWER, request_data=data)
+        response = self._get(URL_GET_MAX_POWER, request_data=data)
         maxpower_values = []
         for i in response:
             if all(k in i for k in GET_MAX_POWER_MANDATORY_FIELDS):

{e-data-1.2.7 → e-data-1.2.8}/edata/definitions.py

@@ -14,18 +14,30 @@ ATTRIBUTES = {
     "yesterday_p1_kWh": "kWh",
     "yesterday_p2_kWh": "kWh",
     "yesterday_p3_kWh": "kWh",
+    "yesterday_surplus_kWh": "kWh",
+    "yesterday_surplus_p1_kWh": "kWh",
+    "yesterday_surplus_p2_kWh": "kWh",
+    "yesterday_surplus_p3_kWh": "kWh",
     "last_registered_date": None,
     "last_registered_day_kWh": "kWh",
     "last_registered_day_hours": "h",
     "last_registered_day_p1_kWh": "kWh",
     "last_registered_day_p2_kWh": "kWh",
     "last_registered_day_p3_kWh": "kWh",
+    "last_registered_day_surplus_kWh": "kWh",
+    "last_registered_day_surplus_p1_kWh": "kWh",
+    "last_registered_day_surplus_p2_kWh": "kWh",
+    "last_registered_day_surplus_p3_kWh": "kWh",
     "month_kWh": "kWh",
     "month_daily_kWh": "kWh",
     "month_days": "d",
     "month_p1_kWh": "kWh",
     "month_p2_kWh": "kWh",
     "month_p3_kWh": "kWh",
+    "month_surplus_kWh": "kWh",
+    "month_surplus_p1_kWh": "kWh",
+    "month_surplus_p2_kWh": "kWh",
+    "month_surplus_p3_kWh": "kWh",
     "month_€": "€",
     "last_month_kWh": "kWh",
     "last_month_daily_kWh": "kWh",
@@ -33,6 +45,10 @@ ATTRIBUTES = {
     "last_month_p1_kWh": "kWh",
     "last_month_p2_kWh": "kWh",
     "last_month_p3_kWh": "kWh",
+    "last_month_surplus_kWh": "kWh",
+    "last_month_surplus_p1_kWh": "kWh",
+    "last_month_surplus_p2_kWh": "kWh",
+    "last_month_surplus_p3_kWh": "kWh",
     "last_month_€": "€",
     "max_power_kW": "kW",
     "max_power_date": None,
@@ -118,7 +134,7 @@ ConsumptionSchema = vol.Schema(
         vol.Required("datetime"): dt.datetime,
         vol.Required("delta_h"): vol.Coerce(float),
         vol.Required("value_kWh"): vol.Coerce(float),
-        vol.Optional("surplus_kWh", default=0): vol.Union(vol.Coerce(float), None),
+        vol.Optional("surplus_kWh", default=0): vol.Coerce(float),
         vol.Required("real"): bool,
     }
 )
@@ -224,6 +240,10 @@ class ConsumptionAggData(TypedDict):
     value_p1_kWh: float
     value_p2_kWh: float
     value_p3_kWh: float
+    surplus_kWh: float
+    surplus_p1_kWh: float
+    surplus_p2_kWh: float
+    surplus_p3_kWh: float
     delta_h: float
 
 
@@ -234,6 +254,10 @@ ConsumptionAggSchema = vol.Schema(
         vol.Required("value_p1_kWh"): vol.Coerce(float),
         vol.Required("value_p2_kWh"): vol.Coerce(float),
         vol.Required("value_p3_kWh"): vol.Coerce(float),
+        vol.Optional("surplus_kWh", default=0): vol.Coerce(float),
+        vol.Optional("surplus_p1_kWh", default=0): vol.Coerce(float),
+        vol.Optional("surplus_p2_kWh", default=0): vol.Coerce(float),
+        vol.Optional("surplus_p3_kWh", default=0): vol.Coerce(float),
         vol.Required("delta_h"): vol.Coerce(float),
     }
 )

{e-data-1.2.7 → e-data-1.2.8}/edata/helpers.py

@@ -479,15 +479,23 @@ class EdataHelper:
             self.attributes["yesterday_kWh"] = (
                 yday.get("value_kWh", None) if yday is not None else None
             )
-            self.attributes["yesterday_p1_kWh"] = (
-                yday.get("value_p1_kWh", None) if yday is not None else None
-            )
-            self.attributes["yesterday_p2_kWh"] = (
-                yday.get("value_p2_kWh", None) if yday is not None else None
-            )
-            self.attributes["yesterday_p3_kWh"] = (
-                yday.get("value_p3_kWh", None) if yday is not None else None
+
+            for tariff in (1, 2, 3):
+                self.attributes[f"yesterday_p{tariff}_kWh"] = (
+                    yday.get(f"value_p{tariff}_kWh", None) if yday is not None else None
+                )
+
+            self.attributes["yesterday_surplus_kWh"] = (
+                yday.get("surplus_kWh", None) if yday is not None else None
             )
+
+            for tariff in (1, 2, 3):
+                self.attributes[f"yesterday_surplus_p{tariff}_kWh"] = (
+                    yday.get(f"surplus_p{tariff}_kWh", None)
+                    if yday is not None
+                    else None
+                )
+
             self.attributes["yesterday_hours"] = (
                 yday.get("delta_h", None) if yday is not None else None
             )
@@ -498,6 +506,9 @@ class EdataHelper:
             self.attributes["month_kWh"] = (
                 month.get("value_kWh", None) if month is not None else None
             )
+            self.attributes["month_surplus_kWh"] = (
+                month.get("surplus_kWh", None) if month is not None else None
+            )
             self.attributes["month_days"] = (
                 month.get("delta_h", 0) / 24 if month is not None else None
             )
@@ -510,15 +521,13 @@ class EdataHelper:
                 if month is not None
                 else None
             )
-            self.attributes["month_p1_kWh"] = (
-                month.get("value_p1_kWh", None) if month is not None else None
-            )
-            self.attributes["month_p2_kWh"] = (
-                month.get("value_p2_kWh", None) if month is not None else None
-            )
-            self.attributes["month_p3_kWh"] = (
-                month.get("value_p3_kWh", None) if month is not None else None
-            )
+
+            for tariff in (1, 2, 3):
+                self.attributes[f"month_surplus_p{tariff}_kWh"] = (
+                    month.get(f"surplus_p{tariff}_kWh", None)
+                    if month is not None
+                    else None
+                )
 
             last_month = utils.get_by_key(
                 self.data["consumptions_monthly_sum"],
@@ -528,6 +537,9 @@ class EdataHelper:
             self.attributes["last_month_kWh"] = (
                 last_month.get("value_kWh", None) if last_month is not None else None
             )
+            self.attributes["last_month_surplus_kWh"] = (
+                last_month.get("surplus_kWh", None) if last_month is not None else None
+            )
             self.attributes["last_month_days"] = (
                 last_month.get("delta_h", 0) / 24 if last_month is not None else None
             )
@@ -543,15 +555,18 @@ class EdataHelper:
                 if last_month is not None
                 else None
             )
-            self.attributes["last_month_p1_kWh"] = (
-                last_month.get("value_p1_kWh", None) if last_month is not None else None
-            )
-            self.attributes["last_month_p2_kWh"] = (
-                last_month.get("value_p2_kWh", None) if last_month is not None else None
-            )
-            self.attributes["last_month_p3_kWh"] = (
-                last_month.get("value_p3_kWh", None) if last_month is not None else None
-            )
+            for tariff in (1, 2, 3):
+                self.attributes[f"last_month_p{tariff}_kWh"] = (
+                    last_month.get(f"value_p{tariff}_kWh", None)
+                    if last_month is not None
+                    else None
+                )
+            for tariff in (1, 2, 3):
+                self.attributes[f"last_month_surplus_p{tariff}_kWh"] = (
+                    last_month.get(f"surplus_p{tariff}_kWh", None)
+                    if last_month is not None
+                    else None
+                )
 
             if len(self.data["consumptions"]) > 0:
                 self.attributes["last_registered_date"] = self.data["consumptions"][-1][
@@ -565,21 +580,21 @@ class EdataHelper:
                         if last_day is not None
                         else None
                     )
-                    self.attributes["last_registered_day_p1_kWh"] = (
-                        last_day.get("value_p1_kWh", None)
-                        if last_day is not None
-                        else None
-                    )
-                    self.attributes["last_registered_day_p2_kWh"] = (
-                        last_day.get("value_p2_kWh", None)
-                        if last_day is not None
-                        else None
-                    )
-                    self.attributes["last_registered_day_p3_kWh"] = (
-                        last_day.get("value_p3_kWh", None)
+                    self.attributes["last_registered_day_surplus_kWh"] = (
+                        last_day.get("surplus_kWh", None)
                         if last_day is not None
                         else None
                     )
+
+                    for tariff in (1, 2, 3):
+                        self.attributes[
+                            f"last_registered_day_surplus_p{tariff}_kWh"
+                        ] = (
+                            last_day.get(f"surplus_p{tariff}_kWh", None)
+                            if last_day is not None
+                            else None
+                        )
+
                     self.attributes["last_registered_day_hours"] = (
                         last_day.get("delta_h", None) if last_day is not None else None
                     )

{e-data-1.2.7 → e-data-1.2.8}/edata/processors/billing.py

@@ -1,4 +1,4 @@
-"""Billing data processors"""
+"""Billing data processors."""
 
 import logging
 from datetime import datetime, timedelta
@@ -26,7 +26,7 @@ _LOGGER = logging.getLogger(__name__)
 
 
 class BillingOutput(TypedDict):
-    """A dict holding BillingProcessor output property"""
+    """A dict holding BillingProcessor output property."""
 
     hourly: list[PricingAggData]
     daily: list[PricingAggData]
@@ -34,7 +34,7 @@ class BillingOutput(TypedDict):
 
 
 class BillingInput(TypedDict):
-    """A dict holding BillingProcessor input data"""
+    """A dict holding BillingProcessor input data."""
 
     contracts: list[ContractData]
     consumptions: list[ConsumptionData]
@@ -43,10 +43,10 @@ class BillingInput(TypedDict):
 
 
 class BillingProcessor(Processor):
-    """A billing processor for edata"""
+    """A billing processor for edata."""
 
     def do_process(self):
-        """Main method for the BillingProcessor"""
+        """Main method for the BillingProcessor."""
         self._output = BillingOutput(hourly=[], daily=[], monthly=[])
 
         _schema = voluptuous.Schema(

{e-data-1.2.7 → e-data-1.2.8}/edata/processors/consumption.py

@@ -53,19 +53,22 @@ class ConsumptionProcessor(Processor):
 
             tariff = utils.get_pvpc_tariff(curr_hour_dt)
             kwh = consumption["value_kWh"]
+            surplus_kwh = consumption["surplus_kWh"]
             delta_h = consumption["delta_h"]
 
-            kwh_p1 = 0
-            kwh_p2 = 0
-            kwh_p3 = 0
+            kwh_by_tariff = [0, 0, 0]
+            surplus_kwh_by_tariff = [0, 0, 0]
 
             match tariff:
                 case "p1":
-                    kwh_p1 = kwh
+                    kwh_by_tariff[0] = kwh
+                    surplus_kwh_by_tariff[0] = surplus_kwh
                 case "p2":
-                    kwh_p2 = kwh
+                    kwh_by_tariff[1] = kwh
+                    surplus_kwh_by_tariff[1] = surplus_kwh
                 case "p3":
-                    kwh_p3 = kwh
+                    kwh_by_tariff[2] = kwh
+                    surplus_kwh_by_tariff[2] = surplus_kwh
 
             if last_day_dt is None or curr_day_dt != last_day_dt:
                 self._output["daily"].append(
@@ -73,16 +76,24 @@ class ConsumptionProcessor(Processor):
                         datetime=curr_day_dt,
                         value_kWh=kwh,
                         delta_h=delta_h,
-                        value_p1_kWh=kwh_p1,
-                        value_p2_kWh=kwh_p2,
-                        value_p3_kWh=kwh_p3,
+                        value_p1_kWh=kwh_by_tariff[0],
+                        value_p2_kWh=kwh_by_tariff[1],
+                        value_p3_kWh=kwh_by_tariff[2],
+                        surplus_kWh=surplus_kwh,
+                        surplus_p1_kWh=surplus_kwh_by_tariff[0],
+                        surplus_p2_kWh=surplus_kwh_by_tariff[1],
+                        surplus_p3_kWh=surplus_kwh_by_tariff[2],
                     )
                 )
             else:
                 self._output["daily"][-1]["value_kWh"] += kwh
-                self._output["daily"][-1]["value_p1_kWh"] += kwh_p1
-                self._output["daily"][-1]["value_p2_kWh"] += kwh_p2
-                self._output["daily"][-1]["value_p3_kWh"] += kwh_p3
+                self._output["daily"][-1]["value_p1_kWh"] += kwh_by_tariff[0]
+                self._output["daily"][-1]["value_p2_kWh"] += kwh_by_tariff[1]
+                self._output["daily"][-1]["value_p3_kWh"] += kwh_by_tariff[2]
+                self._output["daily"][-1]["surplus_kWh"] += surplus_kwh
+                self._output["daily"][-1]["surplus_p1_kWh"] += surplus_kwh_by_tariff[0]
+                self._output["daily"][-1]["surplus_p2_kWh"] += surplus_kwh_by_tariff[1]
+                self._output["daily"][-1]["surplus_p3_kWh"] += surplus_kwh_by_tariff[2]
                 self._output["daily"][-1]["delta_h"] += delta_h
 
             if last_month_dt is None or curr_month_dt != last_month_dt:
@@ -91,24 +102,38 @@ class ConsumptionProcessor(Processor):
                         datetime=curr_month_dt,
                         value_kWh=kwh,
                         delta_h=delta_h,
-                        value_p1_kWh=kwh_p1,
-                        value_p2_kWh=kwh_p2,
-                        value_p3_kWh=kwh_p3,
+                        value_p1_kWh=kwh_by_tariff[0],
+                        value_p2_kWh=kwh_by_tariff[1],
+                        value_p3_kWh=kwh_by_tariff[2],
+                        surplus_kWh=surplus_kwh,
+                        surplus_p1_kWh=surplus_kwh_by_tariff[0],
+                        surplus_p2_kWh=surplus_kwh_by_tariff[1],
+                        surplus_p3_kWh=surplus_kwh_by_tariff[2],
                     )
                 )
             else:
                 self._output["monthly"][-1]["value_kWh"] += kwh
-                self._output["monthly"][-1]["value_p1_kWh"] += kwh_p1
-                self._output["monthly"][-1]["value_p2_kWh"] += kwh_p2
-                self._output["monthly"][-1]["value_p3_kWh"] += kwh_p3
+                self._output["monthly"][-1]["value_p1_kWh"] += kwh_by_tariff[0]
+                self._output["monthly"][-1]["value_p2_kWh"] += kwh_by_tariff[1]
+                self._output["monthly"][-1]["value_p3_kWh"] += kwh_by_tariff[2]
+                self._output["monthly"][-1]["surplus_kWh"] += surplus_kwh
+                self._output["monthly"][-1]["surplus_p1_kWh"] += surplus_kwh_by_tariff[
+                    0
+                ]
+                self._output["monthly"][-1]["surplus_p2_kWh"] += surplus_kwh_by_tariff[
+                    1
+                ]
+                self._output["monthly"][-1]["surplus_p3_kWh"] += surplus_kwh_by_tariff[
+                    2
+                ]
                 self._output["monthly"][-1]["delta_h"] += delta_h
 
             last_day_dt = curr_day_dt
             last_month_dt = curr_month_dt
 
+        # Round to two decimals
         for item in self._output:
             for cons in self._output[item]:
-                cons["value_kWh"] = round(cons["value_kWh"], 2)
-                cons["value_p1_kWh"] = round(cons["value_p1_kWh"], 2)
-                cons["value_p2_kWh"] = round(cons["value_p2_kWh"], 2)
-                cons["value_p3_kWh"] = round(cons["value_p3_kWh"], 2)
+                for key in cons:
+                    if isinstance(cons[key], float):
+                        cons[key] = round(cons[key], 2)

{e-data-1.2.7 → e-data-1.2.8}/setup.py

@@ -20,7 +20,7 @@ URL = "https://github.com/uvejota/python-edata"
 EMAIL = "vmayorg@outlook.es"
 AUTHOR = "VMG"
 REQUIRES_PYTHON = ">=3.6.0"
-VERSION = "1.2.7"
+VERSION = "1.2.8"
 
 # What packages are required for this module to be executed?
 REQUIRED = [