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

{e-data-1.2.6/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.6
+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.6 → 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.6
+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.6 → 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.6 → 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,
     }
 )
@@ -175,22 +191,23 @@ class PricingRules(TypedDict):
     power_formula: str | None
     others_formula: str | None
     surplus_formula: str | None
+    cycle_start_day: int | None
 
 
 PricingRulesSchema = vol.Schema(
     {
         vol.Required("p1_kw_year_eur"): vol.Coerce(float),
         vol.Required("p2_kw_year_eur"): vol.Coerce(float),
-        vol.Required("p1_kwh_eur"): vol.Union(vol.Coerce(float), None),
-        vol.Required("p2_kwh_eur"): vol.Union(vol.Coerce(float), None),
-        vol.Required("p3_kwh_eur"): vol.Union(vol.Coerce(float), None),
-        vol.Optional("surplus_p1_kwh_eur", default=0): vol.Union(
+        vol.Optional("p1_kwh_eur", default=None): vol.Union(vol.Coerce(float), None),
+        vol.Optional("p2_kwh_eur", default=None): vol.Union(vol.Coerce(float), None),
+        vol.Optional("p3_kwh_eur", default=None): vol.Union(vol.Coerce(float), None),
+        vol.Optional("surplus_p1_kwh_eur", default=None): vol.Union(
             vol.Coerce(float), None
         ),
-        vol.Optional("surplus_p2_kwh_eur", default=0): vol.Union(
+        vol.Optional("surplus_p2_kwh_eur", default=None): vol.Union(
             vol.Coerce(float), None
         ),
-        vol.Optional("surplus_p3_kwh_eur", default=0): vol.Union(
+        vol.Optional("surplus_p3_kwh_eur", default=None): vol.Union(
             vol.Coerce(float), None
         ),
         vol.Required("meter_month_eur"): vol.Coerce(float),
@@ -201,6 +218,7 @@ PricingRulesSchema = vol.Schema(
         vol.Optional("power_formula", default=DEFAULT_BILLING_POWER_FORMULA): str,
         vol.Optional("others_formula", default=DEFAULT_BILLING_OTHERS_FORMULA): str,
         vol.Optional("surplus_formula", default=DEFAULT_BILLING_SURPLUS_FORMULA): str,
+        vol.Optional("cycle_start_day", default=1): vol.Range(1, 30),
     }
 )
 
@@ -211,9 +229,6 @@ DEFAULT_PVPC_RULES = PricingRules(
     market_kw_year_eur=3.113,
     electricity_tax=1.0511300560,
     iva_tax=1.05,
-    p1_kwh_eur=None,
-    p2_kwh_eur=None,
-    p3_kwh_eur=None,
 )
 
 
@@ -225,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
 
 
@@ -235,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.6 → e-data-1.2.8}/edata/helpers.py

@@ -433,7 +433,14 @@ class EdataHelper:
                 new_data_from = self._date_from
 
             proc = ConsumptionProcessor(
-                [x for x in self.data["consumptions"] if x["datetime"] >= new_data_from]
+                {
+                    "consumptions": [
+                        x
+                        for x in self.data["consumptions"]
+                        if x["datetime"] >= new_data_from
+                    ],
+                    "cycle_start_day": self.pricing_rules.get("cycle_start_day", 1),
+                }
             )
             today_starts = datetime(
                 datetime.today().year,
@@ -472,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
             )
@@ -491,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
             )
@@ -503,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"],
@@ -521,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
             )
@@ -536,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][
@@ -558,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.6 → e-data-1.2.8}/edata/processors/base.py

@@ -2,7 +2,7 @@
 
 from abc import ABC, abstractmethod
 from copy import deepcopy
-from typing import Any, Iterable
+from typing import Any
 
 
 class Processor(ABC):
@@ -10,8 +10,8 @@ class Processor(ABC):
 
     _LABEL = "Processor"
 
-    def __init__(self, input_data: Iterable[dict[str, Any]], auto: bool = True):
-        """Init method"""
+    def __init__(self, input_data: Any, auto: bool = True):
+        """Init method."""
         self._input = deepcopy(input_data)
         self._output = None
         if auto:
@@ -19,9 +19,9 @@ class Processor(ABC):
 
     @abstractmethod
     def do_process(self):
-        """The processing method"""
+        """The processing method."""
 
     @property
     def output(self):
-        """An output property"""
+        """An output property."""
         return deepcopy(self._output)

{e-data-1.2.6 → 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
@@ -20,12 +20,13 @@ from ..definitions import (
 )
 from ..processors import utils
 from ..processors.base import Processor
+import contextlib
 
 _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]
@@ -33,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]
@@ -42,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(
@@ -60,6 +61,8 @@ class BillingProcessor(Processor):
         )
         self._input = _schema(self._input)
 
+        self._cycle_offset = self._input["rules"]["cycle_start_day"] - 1
+
         # joint data by datetime
         _data = {
             x["datetime"]: {
@@ -124,12 +127,23 @@ class BillingProcessor(Processor):
             elif tariff == "p3":
                 x["surplus_kwh_eur"] = x["surplus_p3_kwh_eur"]
 
+            _energy_term = 0
+            _power_term = 0
+            _others_term = 0
+            _surplus_term = 0
+
+            with contextlib.suppress(Exception):
+                _energy_term = round(energy_expr(**x), 3)
+                _power_term = round(power_expr(**x), 3)
+                _others_term = round(others_expr(**x), 3)
+                _surplus_term = round(surplus_expr(**x), 3)
+
             new_item = PricingAggData(
                 datetime=x["datetime"],
-                energy_term=round(energy_expr(**x), 3),
-                power_term=round(power_expr(**x), 3),
-                others_term=round(others_expr(**x), 3),
-                surplus_term=round(surplus_expr(**x), 3),
+                energy_term=_energy_term,
+                power_term=_power_term,
+                others_term=_others_term,
+                surplus_term=_surplus_term,
                 value_eur=0,
                 delta_h=1,
             )
@@ -151,7 +165,9 @@ class BillingProcessor(Processor):
         for hour in hourly:
             curr_hour_dt: datetime = hour["datetime"]
             curr_day_dt = curr_hour_dt.replace(hour=0, minute=0, second=0)
-            curr_month_dt = curr_day_dt.replace(day=1)
+            curr_month_dt = (curr_day_dt - timedelta(days=self._cycle_offset)).replace(
+                day=1
+            )
 
             if last_day_dt is None or curr_day_dt != last_day_dt:
                 self._output["daily"].append(

e-data-1.2.8/edata/processors/consumption.py

@@ -0,0 +1,139 @@
+"""Consumption data processors."""
+
+import logging
+from collections.abc import Iterable
+from typing import TypedDict
+from datetime import datetime, timedelta
+
+import voluptuous
+
+from ..definitions import ConsumptionAggData, ConsumptionSchema
+from . import utils
+from .base import Processor
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class ConsumptionOutput(TypedDict):
+    """A dict holding ConsumptionProcessor output property."""
+
+    daily: Iterable[ConsumptionAggData]
+    monthly: Iterable[ConsumptionAggData]
+
+
+class ConsumptionProcessor(Processor):
+    """A consumptions processor."""
+
+    def do_process(self):
+        """Calculate daily and monthly consumption stats."""
+
+        self._output = ConsumptionOutput(daily=[], monthly=[])
+
+        last_day_dt = None
+        last_month_dt = None
+
+        _schema = voluptuous.Schema(
+            {
+                voluptuous.Required("consumptions"): [ConsumptionSchema],
+                voluptuous.Optional("cycle_start_day", default=1): voluptuous.Range(
+                    1, 30
+                ),
+            }
+        )
+        self._input = _schema(self._input)
+
+        self._cycle_offset = self._input["cycle_start_day"] - 1
+
+        for consumption in self._input["consumptions"]:
+            curr_hour_dt: datetime = consumption["datetime"]
+            curr_day_dt = curr_hour_dt.replace(hour=0, minute=0, second=0)
+            curr_month_dt = (curr_day_dt - timedelta(days=self._cycle_offset)).replace(
+                day=1
+            )
+
+            tariff = utils.get_pvpc_tariff(curr_hour_dt)
+            kwh = consumption["value_kWh"]
+            surplus_kwh = consumption["surplus_kWh"]
+            delta_h = consumption["delta_h"]
+
+            kwh_by_tariff = [0, 0, 0]
+            surplus_kwh_by_tariff = [0, 0, 0]
+
+            match tariff:
+                case "p1":
+                    kwh_by_tariff[0] = kwh
+                    surplus_kwh_by_tariff[0] = surplus_kwh
+                case "p2":
+                    kwh_by_tariff[1] = kwh
+                    surplus_kwh_by_tariff[1] = surplus_kwh
+                case "p3":
+                    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(
+                    ConsumptionAggData(
+                        datetime=curr_day_dt,
+                        value_kWh=kwh,
+                        delta_h=delta_h,
+                        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_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:
+                self._output["monthly"].append(
+                    ConsumptionAggData(
+                        datetime=curr_month_dt,
+                        value_kWh=kwh,
+                        delta_h=delta_h,
+                        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_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]:
+                for key in cons:
+                    if isinstance(cons[key], float):
+                        cons[key] = round(cons[key], 2)

{e-data-1.2.6 → 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.6"
+VERSION = "1.2.8"
 
 # What packages are required for this module to be executed?
 REQUIRED = [

e-data-1.2.6/edata/processors/consumption.py

@@ -1,103 +0,0 @@
-"""Consumption data processors."""
-
-import logging
-from collections.abc import Iterable
-from typing import TypedDict
-from datetime import datetime
-
-import voluptuous
-
-from ..definitions import ConsumptionAggData, ConsumptionSchema
-from . import utils
-from .base import Processor
-
-_LOGGER = logging.getLogger(__name__)
-
-
-class ConsumptionOutput(TypedDict):
-    """A dict holding ConsumptionProcessor output property."""
-
-    daily: Iterable[ConsumptionAggData]
-    monthly: Iterable[ConsumptionAggData]
-
-
-class ConsumptionProcessor(Processor):
-    """A consumptions processor."""
-
-    def do_process(self):
-        """Calculate daily and monthly consumption stats."""
-
-        self._output = ConsumptionOutput(daily=[], monthly=[])
-
-        last_day_dt = None
-        last_month_dt = None
-
-        _schema = voluptuous.Schema([ConsumptionSchema])
-        self._input = _schema(self._input)
-
-        for consumption in self._input:
-            curr_hour_dt: datetime = consumption["datetime"]
-            curr_day_dt = curr_hour_dt.replace(hour=0, minute=0, second=0)
-            curr_month_dt = curr_day_dt.replace(day=1)
-
-            tariff = utils.get_pvpc_tariff(curr_hour_dt)
-            kwh = consumption["value_kWh"]
-            delta_h = consumption["delta_h"]
-
-            kwh_p1 = 0
-            kwh_p2 = 0
-            kwh_p3 = 0
-
-            match tariff:
-                case "p1":
-                    kwh_p1 = kwh
-                case "p2":
-                    kwh_p2 = kwh
-                case "p3":
-                    kwh_p3 = kwh
-
-            if last_day_dt is None or curr_day_dt != last_day_dt:
-                self._output["daily"].append(
-                    ConsumptionAggData(
-                        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,
-                    )
-                )
-            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]["delta_h"] += delta_h
-
-            if last_month_dt is None or curr_month_dt != last_month_dt:
-                self._output["monthly"].append(
-                    ConsumptionAggData(
-                        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,
-                    )
-                )
-            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]["delta_h"] += delta_h
-
-            last_day_dt = curr_day_dt
-            last_month_dt = curr_month_dt
-
-        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)