e-data 1.2.18__tar.gz → 1.2.20__tar.gz

e_data-1.2.20/PKG-INFO

@@ -0,0 +1,136 @@
+Metadata-Version: 2.1
+Name: e-data
+Version: 1.2.20
+Summary: Python library for managing spanish energy data from various web providers
+Home-page: https://github.com/uvejota/python-edata
+Author: VMG
+Author-email: vmayorg@outlook.es
+License: GPLv3
+Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Requires-Python: >=3.6.0
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: dateparser>=1.1.2
+Requires-Dist: freezegun>=1.2.1
+Requires-Dist: holidays>=0.14.2
+Requires-Dist: pytest>=7.1.2
+Requires-Dist: python_dateutil>=2.8.2
+Requires-Dist: requests>=2.28.1
+Requires-Dist: voluptuous>=0.13.1
+Requires-Dist: Jinja2>=3.1.2
+
+
+[![Downloads](https://pepy.tech/badge/e-data)](https://pepy.tech/project/e-data)
+[![Downloads](https://pepy.tech/badge/e-data/month)](https://pepy.tech/project/e-data)
+[![Downloads](https://pepy.tech/badge/e-data/week)](https://pepy.tech/project/e-data)
+
+# python-edata
+
+Este paquete proporciona herramientas para la descarga de tus datos de consumo eléctrico (desde Datadis.es) y su posterior procesado. La motivación principal es que conocer el consumo puede ayudarnos a reducirlo, e incluso a elegir una tarifa que mejor se adapte a nuestras necesidades. A día de hoy sus capacidades de facturación (€) son limitadas, soporta PVPC (según disponibilidad de datos de REData) y tarificación fija por tramos. Es el corazón de la integración [homeassistant-edata](https://github.com/uvejota/homeassistant-edata).
+
+_**Esta herramienta no mantiene ningún tipo de vinculación con los proveedores de datos anteriormente mencionados, simplemente consulta la información disponible y facilita su posterior análisis.**_
+
+## Instalación
+
+Puedes instalar la última versión estable mediante:
+
+``` bash
+pip install e-data
+```
+
+Si quieres probar la versión `dev` o contribuir a su desarrollo, clona este repositorio e instala manualmente las dependencias:
+
+``` bash
+pip install -r requirements.txt
+```
+
+## Estructura
+
+El paquete consta de tres módulos diferenciados:
+
+* **Conectores** (módulo `connectors`), para definir los métodos de consulta a los diferentes proveedores: Datadis y REData.
+* **Procesadores** (módulo `processors`), para procesar datos de consumo, maxímetro, o coste (tarificación). Ahora mismo consta de tres procesadores: `billing`, `consumption` y `maximeter`, además de algunas utilidades ubicadas en `utils`. Los procesadores deben heredar de la clase Processor definida en `base.py`
+* **Ayudantes** (módulo `helpers`), para ayudar en el uso y gestión de los anteriores, presentando de momento un único ayudante llamado `EdataHelper` que te permite recopilar `X` días de datos (por defecto 365) y automáticamente procesarlos. Los datos son almacenados en la variable `data`, mientras que los atributos autocalculados son almacenados en la variable `attributes`. Por lo general, primero utilizan los conectores y luego procesan los datos, gestionando varias tareas de recuperación (principalmente para Datadis).
+
+Estos módulos corresponden a la siguiente estructura del paquete:
+
+```
+edata/
+    · __init__.py
+    · connectors/
+        · __init__.py
+        · datadis.py
+        · redata.py
+    · processors/
+        · __init__.py
+        · base.py
+        · billing.py
+        · consumption.py
+        · maximeter.py
+        · utils.py
+    · helpers.py
+```
+
+## Ejemplo de uso
+
+Partimos de que tenemos credenciales en Datadis.es. Algunas aclaraciones:
+* No es necesario solicitar API pública en el registro (se utilizará la API privada habilitada por defecto)
+* El username suele ser el NIF del titular
+* Copie el CUPS de la web de Datadis, algunas comercializadoras adhieren caracteres adicionales en el CUPS mostrado en su factura.
+* La herramienta acepta el uso de NIF autorizado para consultar el suministro de otro titular.
+
+``` python
+from datetime import datetime
+import json
+
+# importamos definiciones de datos que nos interesen
+from edata.definitions import PricingRules
+# importamos el ayudante
+from edata.helpers import EdataHelper
+# importamos el procesador de utilidades
+from edata.processors import utils
+
+# Preparar reglas de tarificación (si se quiere)
+PRICING_RULES_PVPC = PricingRules(
+    p1_kw_year_eur=30.67266,
+    p2_kw_year_eur=1.4243591,
+    meter_month_eur=0.81,
+    market_kw_year_eur=3.113,
+    electricity_tax=1.0511300560,
+    iva_tax=1.05,
+    # podemos rellenar los siguientes campos si quisiéramos precio fijo (y no pvpc)
+    p1_kwh_eur=None,
+    p2_kwh_eur=None,
+    p3_kwh_eur=None,
+)
+
+# Instanciar el helper
+# 'authorized_nif' permite indicar el NIF de la persona que nos autoriza a consultar su CUPS.
+# 'data' permite "cargar" al helper datos anteriores (resultado edata.data de una ejecución anterior), para evitar volver a consultar los mismos.
+edata = EdataHelper(
+            "datadis_user",
+            "datadis_password",
+            "cups",
+            datadis_authorized_nif=None,
+            pricing_rules=PRICING_RULES_PVPC, # si se le pasa None, no aplica tarificación
+            data=None, # aquí podríamos cargar datos anteriores
+        )
+
+# Solicitar actualización de todo el histórico (se almacena en edata.data)
+edata.update(date_from=datetime(1970, 1, 1), date_to=datetime.today())
+
+# volcamos todo lo obtenido a un fichero
+with open("backup.json", "w") as file:
+    json.dump(utils.serialize_dict(edata.data), file) # se puede utilizar deserialize_dict para la posterior lectura del backup
+
+# Imprimir atributos
+print(edata.attributes)
+```

e_data-1.2.20/e_data.egg-info/PKG-INFO

@@ -0,0 +1,136 @@
+Metadata-Version: 2.1
+Name: e-data
+Version: 1.2.20
+Summary: Python library for managing spanish energy data from various web providers
+Home-page: https://github.com/uvejota/python-edata
+Author: VMG
+Author-email: vmayorg@outlook.es
+License: GPLv3
+Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Requires-Python: >=3.6.0
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: dateparser>=1.1.2
+Requires-Dist: freezegun>=1.2.1
+Requires-Dist: holidays>=0.14.2
+Requires-Dist: pytest>=7.1.2
+Requires-Dist: python_dateutil>=2.8.2
+Requires-Dist: requests>=2.28.1
+Requires-Dist: voluptuous>=0.13.1
+Requires-Dist: Jinja2>=3.1.2
+
+
+[![Downloads](https://pepy.tech/badge/e-data)](https://pepy.tech/project/e-data)
+[![Downloads](https://pepy.tech/badge/e-data/month)](https://pepy.tech/project/e-data)
+[![Downloads](https://pepy.tech/badge/e-data/week)](https://pepy.tech/project/e-data)
+
+# python-edata
+
+Este paquete proporciona herramientas para la descarga de tus datos de consumo eléctrico (desde Datadis.es) y su posterior procesado. La motivación principal es que conocer el consumo puede ayudarnos a reducirlo, e incluso a elegir una tarifa que mejor se adapte a nuestras necesidades. A día de hoy sus capacidades de facturación (€) son limitadas, soporta PVPC (según disponibilidad de datos de REData) y tarificación fija por tramos. Es el corazón de la integración [homeassistant-edata](https://github.com/uvejota/homeassistant-edata).
+
+_**Esta herramienta no mantiene ningún tipo de vinculación con los proveedores de datos anteriormente mencionados, simplemente consulta la información disponible y facilita su posterior análisis.**_
+
+## Instalación
+
+Puedes instalar la última versión estable mediante:
+
+``` bash
+pip install e-data
+```
+
+Si quieres probar la versión `dev` o contribuir a su desarrollo, clona este repositorio e instala manualmente las dependencias:
+
+``` bash
+pip install -r requirements.txt
+```
+
+## Estructura
+
+El paquete consta de tres módulos diferenciados:
+
+* **Conectores** (módulo `connectors`), para definir los métodos de consulta a los diferentes proveedores: Datadis y REData.
+* **Procesadores** (módulo `processors`), para procesar datos de consumo, maxímetro, o coste (tarificación). Ahora mismo consta de tres procesadores: `billing`, `consumption` y `maximeter`, además de algunas utilidades ubicadas en `utils`. Los procesadores deben heredar de la clase Processor definida en `base.py`
+* **Ayudantes** (módulo `helpers`), para ayudar en el uso y gestión de los anteriores, presentando de momento un único ayudante llamado `EdataHelper` que te permite recopilar `X` días de datos (por defecto 365) y automáticamente procesarlos. Los datos son almacenados en la variable `data`, mientras que los atributos autocalculados son almacenados en la variable `attributes`. Por lo general, primero utilizan los conectores y luego procesan los datos, gestionando varias tareas de recuperación (principalmente para Datadis).
+
+Estos módulos corresponden a la siguiente estructura del paquete:
+
+```
+edata/
+    · __init__.py
+    · connectors/
+        · __init__.py
+        · datadis.py
+        · redata.py
+    · processors/
+        · __init__.py
+        · base.py
+        · billing.py
+        · consumption.py
+        · maximeter.py
+        · utils.py
+    · helpers.py
+```
+
+## Ejemplo de uso
+
+Partimos de que tenemos credenciales en Datadis.es. Algunas aclaraciones:
+* No es necesario solicitar API pública en el registro (se utilizará la API privada habilitada por defecto)
+* El username suele ser el NIF del titular
+* Copie el CUPS de la web de Datadis, algunas comercializadoras adhieren caracteres adicionales en el CUPS mostrado en su factura.
+* La herramienta acepta el uso de NIF autorizado para consultar el suministro de otro titular.
+
+``` python
+from datetime import datetime
+import json
+
+# importamos definiciones de datos que nos interesen
+from edata.definitions import PricingRules
+# importamos el ayudante
+from edata.helpers import EdataHelper
+# importamos el procesador de utilidades
+from edata.processors import utils
+
+# Preparar reglas de tarificación (si se quiere)
+PRICING_RULES_PVPC = PricingRules(
+    p1_kw_year_eur=30.67266,
+    p2_kw_year_eur=1.4243591,
+    meter_month_eur=0.81,
+    market_kw_year_eur=3.113,
+    electricity_tax=1.0511300560,
+    iva_tax=1.05,
+    # podemos rellenar los siguientes campos si quisiéramos precio fijo (y no pvpc)
+    p1_kwh_eur=None,
+    p2_kwh_eur=None,
+    p3_kwh_eur=None,
+)
+
+# Instanciar el helper
+# 'authorized_nif' permite indicar el NIF de la persona que nos autoriza a consultar su CUPS.
+# 'data' permite "cargar" al helper datos anteriores (resultado edata.data de una ejecución anterior), para evitar volver a consultar los mismos.
+edata = EdataHelper(
+            "datadis_user",
+            "datadis_password",
+            "cups",
+            datadis_authorized_nif=None,
+            pricing_rules=PRICING_RULES_PVPC, # si se le pasa None, no aplica tarificación
+            data=None, # aquí podríamos cargar datos anteriores
+        )
+
+# Solicitar actualización de todo el histórico (se almacena en edata.data)
+edata.update(date_from=datetime(1970, 1, 1), date_to=datetime.today())
+
+# volcamos todo lo obtenido a un fichero
+with open("backup.json", "w") as file:
+    json.dump(utils.serialize_dict(edata.data), file) # se puede utilizar deserialize_dict para la posterior lectura del backup
+
+# Imprimir atributos
+print(edata.attributes)
+```

{e-data-1.2.18 → e_data-1.2.20}/edata/connectors/datadis.py

@@ -7,17 +7,17 @@ There a few issues that are workarounded:
 """
 
 import contextlib
+from datetime import datetime, timedelta
+import glob
 import hashlib
 import json
 import logging
-from datetime import datetime, timedelta
 import os
-from dateutil.relativedelta import relativedelta
+import tempfile
 
+from dateutil.relativedelta import relativedelta
 import requests
 
-from filelock import FileLock
-
 from ..definitions import ConsumptionData, ContractData, MaxPowerData, SupplyData
 from ..processors import utils
 
@@ -68,10 +68,15 @@ 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_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}"
+RECENT_CACHE_SUBDIR = "cache"
+
+
+def migrate_storage(storage_dir):
+    """Migrate storage from older versions."""
+
+    with contextlib.suppress(FileNotFoundError):
+        os.remove(storage_dir, "edata_recent_queries.json")
+        os.remove(storage_dir, "edata_recent_queries_cache.json")
 
 
 class DatadisConnector:
@@ -94,84 +99,69 @@ class DatadisConnector:
         self._smart_fetch = enable_smart_fetch
         self._recent_queries = {}
         self._recent_cache = {}
+        self._warned_queries = []
         if storage_path is not None:
-            self._recent_queries_file = os.path.join(
-                storage_path, RECENT_QUERIES_FILENAME
-            )
-            self._recent_queries_cache_file = os.path.join(
-                storage_path, RECENT_QUERIES_CACHE_FILENAME
-            )
+            self._recent_cache_dir = os.path.join(storage_path, RECENT_CACHE_SUBDIR)
+            migrate_storage(storage_path)
         else:
-            self._recent_queries_file = DEFAULT_RECENT_QUERIES_FILE
-            self._recent_queries_cache_file = DEFAULT_RECENT_QUERIES_CACHE
-        self._warned_queries = []
-        self._load_recent_cache()
-
-    def _load_recent_cache(self) -> None:
-        """Load caches."""
-
-        with contextlib.suppress(FileNotFoundError):
-            with open(self._recent_queries_file, encoding="utf8") as dst_file:
-                recent_queries = json.load(dst_file)
-                for query in recent_queries:
-                    recent_queries[query] = datetime.fromisoformat(
-                        recent_queries[query]
-                    )
-                self._recent_queries.update(recent_queries)
+            self._recent_cache_dir = os.path.join(
+                tempfile.gettempdir(), RECENT_CACHE_SUBDIR
+            )
 
-            with open(self._recent_queries_cache_file, encoding="utf8") as dst_file:
-                self._recent_cache.update(json.load(dst_file))
+        os.makedirs(self._recent_cache_dir, exist_ok=True)
 
     def _update_recent_queries(self, query: str, data: dict | None = None) -> None:
         """Cache a successful query to avoid exceeding query limits."""
 
-        with FileLock(self._recent_queries_file + ".lock"):
-            self._load_recent_cache()
-            # 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 cache
-            to_delete = [
-                x
-                for x in self._recent_queries
-                if (datetime.now() - self._recent_queries[x]) > QUERY_LIMIT
-            ]
-
-            for key in to_delete:
-                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)
-                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)
-                _LOGGER.info("Local cache updated")
-            except Exception as e:
-                _LOGGER.warning("Unknown error while updating cache: %s", e)
+        # identify the query by a md5 hash
+        hash_query = hashlib.md5(query.encode()).hexdigest()
+
+        # remove expired cache files
+        with contextlib.suppress(FileNotFoundError):
+            for cache_file in glob.glob(os.path.join(self._recent_cache_dir, "*")):
+                if (
+                    datetime.now()
+                    - datetime.fromtimestamp(os.path.getmtime(cache_file))
+                ) > QUERY_LIMIT:
+                    _LOGGER.info("Removing cache item '%s'", cache_file)
+                    os.remove(cache_file)
+
+        # dump current cache to disk
+        try:
+            with open(
+                os.path.join(self._recent_cache_dir, hash_query),
+                "w",
+                encoding="utf8",
+            ) as dst_file:
+                json.dump(data, dst_file)
+                _LOGGER.info("Updating cache item '%s'", hash_query)
+
+        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."""
+
         hash_query = hashlib.md5(query.encode()).hexdigest()
+        cache_file = os.path.join(self._recent_cache_dir, hash_query)
 
-        if hash_query in self._recent_queries:
-            return (datetime.now() - self._recent_queries[hash_query]) < QUERY_LIMIT
-        return False
+        return (
+            os.path.exists(cache_file)
+            and (datetime.now() - datetime.fromtimestamp(os.path.getmtime(cache_file)))
+            < QUERY_LIMIT
+        )
 
-    def _get_cache_for_query(self, query: str) -> dict:
+    def _get_cache_for_query(self, query: str) -> dict | None:
         """Return cached response for a query."""
+
         hash_query = hashlib.md5(query.encode()).hexdigest()
-        _LOGGER.info("Serving '%s' from cache", query)
-        return self._recent_cache.get(hash_query, None)
+        cache_file = os.path.join(self._recent_cache_dir, hash_query)
+
+        try:
+            with open(cache_file, encoding="utf8") as cache:
+                return json.load(cache)
+        except FileNotFoundError:
+            return None
 
     def _get_token(self):
         """Private method that fetches a new token if needed."""
@@ -227,39 +217,52 @@ class DatadisConnector:
                 key = param
                 value = data[param]
                 params = params + f"{key}={value}&"
+            anonym_params = "?" if len(data) > 0 else ""
+
+            # build anonymized params for logging
+            for anonym_param in data:
+                key = anonym_param
+                if key == "cups":
+                    value = "xxxx" + data[anonym_param][-5:]
+                elif key == "authorizedNif":
+                    value = "xxxx"
+                else:
+                    value = data[anonym_param]
+                anonym_params = anonym_params + f"{key}={value}&"
 
             # check if query is already in cache
             if not ignore_recent_queries and self._is_recent_query(url + params):
                 _cache = self._get_cache_for_query(url + params)
                 if _cache is not None:
+                    _LOGGER.info("Returning cached data")
                     return _cache
                 return []
 
             # run the query
             try:
-                _LOGGER.debug("GET %s", url + params)
+                _LOGGER.info("GET %s", url + anonym_params)
                 reply = self._session.get(
                     url + params,
                     headers={"Accept-Encoding": "identity"},
                     timeout=TIMEOUT,
                 )
             except requests.exceptions.Timeout:
-                _LOGGER.warning("Timeout at %s", url + params)
+                _LOGGER.warning("Timeout at %s", url + anonym_params)
                 return []
 
             # eval response
             if reply.status_code == 200:
                 # we're here if reply seems valid
-                _LOGGER.info("Got 200 OK at %s", url + params)
+                _LOGGER.info("Got 200 OK")
                 if reply.json():
                     response = reply.json()
-                    self._update_recent_queries(url + params, response)
+                    if not ignore_recent_queries:
+                        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)
+                    _LOGGER.info("Got an empty response")
+                    if not ignore_recent_queries:
+                        self._update_recent_queries(url + params)
             elif reply.status_code == 401 and not refresh_token:
                 # we're here if we were unauthorized so we will refresh the token
                 response = self._get(
@@ -271,24 +274,24 @@ class DatadisConnector:
             elif reply.status_code == 429:
                 # we're here if we exceeded datadis API rates (24h)
                 _LOGGER.warning(
-                    "%s %s at %s",
+                    "Got status code '%s' with message '%s'",
                     reply.status_code,
                     reply.text,
-                    url + params,
                 )
-                self._update_recent_queries(url + params)
+                if not ignore_recent_queries:
+                    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",
+                        "Got status code '%s' with message '%s'. %s. %s",
                         reply.status_code,
                         reply.text,
-                        url + params,
                         "Query temporary disabled",
                         "Future 500 code errors for this query will be silenced until restart",
                     )
-                self._update_recent_queries(url + params)
+                if not ignore_recent_queries:
+                    self._update_recent_queries(url + params)
                 self._warned_queries.append(url + params)
             else:
                 # finally, retry since an unexpected error took place (mostly 500 errors - server fault)

{e-data-1.2.18 → e_data-1.2.20}/edata/definitions.py

@@ -71,9 +71,7 @@ DEFAULT_BILLING_SURPLUS_FORMULA = (
 
 # Sum energy and power terms, and substract surplus until 0.
 # An alternative would be "[(energy_term + power_term - surplus_term), 0]|max + others_term"
-DEFAULT_BILLING_MAIN_FORMULA = (
-    "[(energy_term - surplus_term), 0]|max + power_term + others_term"
-)
+DEFAULT_BILLING_MAIN_FORMULA = "energy_term + power_term + others_term"
 
 
 class SupplyData(TypedDict):

{e-data-1.2.18 → e_data-1.2.20}/edata/helpers.py

@@ -22,6 +22,12 @@ from .storage import check_storage_integrity, dump_storage, load_storage
 _LOGGER = logging.getLogger(__name__)
 
 
+def acups(cups):
+    """Print an abbreviated and anonymized CUPS."""
+
+    return cups[-5:]
+
+
 class EdataHelper:
     """Main EdataHelper class."""
 
@@ -53,7 +59,7 @@ class EdataHelper:
         self.attributes = {}
         self._storage_dir = storage_dir_path
         self._cups = cups
-        self._scups = cups[-5:]
+        self._scups = acups(cups)
         self._authorized_nif = datadis_authorized_nif
         self.last_update = {x: datetime(1970, 1, 1) for x in self.data}
         self._date_from = datetime(1970, 1, 1)
@@ -113,7 +119,7 @@ class EdataHelper:
         date_to: datetime = datetime.today(),
         incremental_update: bool = True,
     ):
-        """Synchronous update."""
+        """Update synchronously."""
 
         _LOGGER.info(
             "%s: update triggered",
@@ -138,9 +144,9 @@ class EdataHelper:
             dump_storage(self._cups, self.data, self._storage_dir)
 
     def update_supplies(self):
-        """Synchronous data update of supplies."""
+        """Update supplies."""
 
-        _LOGGER.info("%s: supplies update triggered", self._scups)
+        _LOGGER.debug("%s: supplies update triggered", self._scups)
         if datetime.today().date() != self.last_update["supplies"].date():
             # if supplies haven't been updated today
             supplies = self.datadis_api.get_supplies(
@@ -155,9 +161,9 @@ class EdataHelper:
             _LOGGER.info("%s: supplies are already updated (skipping)", self._scups)
 
     def update_contracts(self, cups: str, distributor_code: str):
-        """Synchronous data update of contracts."""
+        """Update contracts."""
 
-        _LOGGER.info("%s: contracts update triggered", self._scups)
+        _LOGGER.debug("%s: contracts update triggered", self._scups)
         if datetime.today().date() != self.last_update["contracts"].date():
             # if contracts haven't been updated today
             contracts = self.datadis_api.get_contract_detail(
@@ -182,9 +188,9 @@ class EdataHelper:
         measurement_type: str,
         point_type: int,
     ):
-        """Synchronous data update of consumptions."""
+        """Update consumptions."""
 
-        _LOGGER.info("%s: consumptions update triggered", self._scups)
+        _LOGGER.debug("%s: consumptions update triggered", self._scups)
         if (datetime.now() - self.last_update["consumptions"]) > self.UPDATE_INTERVAL:
             consumptions = self.datadis_api.get_consumption_data(
                 cups,
@@ -196,22 +202,23 @@ class EdataHelper:
                 authorized_nif=self._authorized_nif,
             )
             if len(consumptions) > 0:
+                _LOGGER.info(
+                    "%s: got consumptions from %s to %s",
+                    self._scups,
+                    consumptions[0]["datetime"].isoformat(),
+                    consumptions[-1]["datetime"].isoformat(),
+                )
                 self.data["consumptions"] = utils.extend_by_key(
                     self.data["consumptions"], consumptions, "datetime"
                 )
                 self.last_update["consumptions"] = datetime.now()
-                _LOGGER.info(
-                    "%s: consumptions update succeeded (%s new records)",
-                    self._scups,
-                    len(consumptions),
-                )
         else:
             _LOGGER.info("%s: consumptions are already updated (skipping)", self._scups)
 
     def update_maximeter(self, cups, distributor_code, start_date, end_date):
-        """Synchronous data update of maximeter."""
+        """Update maximeter."""
 
-        _LOGGER.info("%s: maximeter update triggered", self._scups)
+        _LOGGER.debug("%s: maximeter update triggered", self._scups)
         if (datetime.now() - self.last_update["maximeter"]) > self.UPDATE_INTERVAL:
             maximeter = self.datadis_api.get_max_power(
                 cups,
@@ -221,15 +228,14 @@ class EdataHelper:
                 authorized_nif=self._authorized_nif,
             )
             if len(maximeter) > 0:
+                _LOGGER.info(
+                    "%s: maximeter update succeeded",
+                    self._scups,
+                )
                 self.data["maximeter"] = utils.extend_by_key(
                     self.data["maximeter"], maximeter, "datetime"
                 )
                 self.last_update["maximeter"] = datetime.now()
-                _LOGGER.info(
-                    "%s: maximeter update succeeded (%s new records)",
-                    self._scups,
-                    len(maximeter),
-                )
         else:
             _LOGGER.info("%s: maximeter is already updated (skipping)", self._scups)
 
@@ -239,7 +245,7 @@ class EdataHelper:
         date_from: datetime = datetime(1970, 1, 1),
         date_to: datetime = datetime.today(),
     ):
-        """Synchronous data update."""
+        """Update all data from Datadis."""
 
         _LOGGER.info(
             "%s: datadis update triggered (from %s to %s)",
@@ -264,15 +270,25 @@ class EdataHelper:
         if supply is None:
             # return if specified cups seems not valid
             _LOGGER.error(
-                "%s: CUPS not found, please check configured CUPS", self._scups
+                "%s: CUPS not found. Got: %s",
+                self._scups,
+                [acups(x["cups"]) for x in self.data["supplies"]],
             )
             return False
+        _LOGGER.info("%s: CUPS found in account", self._scups)
 
         # get some supply-related data
         supply_date_start = supply["date_start"]
         distributor_code = supply["distributorCode"]
         point_type = supply["pointType"]
 
+        _LOGGER.info(
+            "%s: CUPS start date is %s", self._scups, supply_date_start.isoformat()
+        )
+        _LOGGER.info(
+            "%s: CUPS end date is %s", self._scups, supply["date_end"].isoformat()
+        )
+
         # update contracts to get valid periods
         self.update_contracts(cups, distributor_code)
         if len(self.data["contracts"]) == 0:
@@ -280,9 +296,9 @@ class EdataHelper:
                 "%s: contracts update failed or no contracts found in the provided account",
                 self._scups,
             )
-            return False
+            # return False
 
-        # filter consumptions and maximeter, and look for gaps
+        # filter consumptions and maximeter, and log gaps
         def sort_and_filter(dt_from, dt_to):
             self.data["consumptions"], miss_cons = utils.extract_dt_ranges(
                 self.data["consumptions"],
@@ -300,82 +316,70 @@ class EdataHelper:
 
         miss_cons, miss_maxim = sort_and_filter(date_from, date_to)
 
+        # update consumptions
         _LOGGER.info(
             "%s: missing consumptions: %s",
             self._scups,
-            ", ".join(
-                [x["from"].isoformat() + " - " + x["to"].isoformat() for x in miss_cons]
-            ),
-        )
-        _LOGGER.info(
-            "%s: missing maximeter: %s",
-            self._scups,
             ", ".join(
                 [
-                    x["from"].isoformat() + " - " + x["to"].isoformat()
-                    for x in miss_maxim
+                    "from "
+                    + (x["from"] + timedelta(hours=1)).isoformat()
+                    + " to "
+                    + x["to"].isoformat()
+                    for x in miss_cons
                 ]
             ),
         )
-
-        oldest_contract = datetime.today()
-        for contract in self.data["contracts"]:
-            # register oldest contract
-            if contract["date_start"] < oldest_contract:
-                oldest_contract = contract["date_start"]
-
-            # update consumptions
-            for gap in [
-                x
-                for x in miss_cons
-                if not (
-                    x["to"] < contract["date_start"] or x["from"] > contract["date_end"]
-                )
-            ]:
+        for gap in miss_cons:
+            if not (
+                gap["to"] < supply["date_start"] or gap["from"] > supply["date_end"]
+            ):
                 # fetch consumptions for each consumptions gap in valid periods
+                start = max([gap["from"] + timedelta(hours=1), supply["date_start"]])
+                end = min([gap["to"], supply["date_end"]])
+                _LOGGER.info(
+                    "%s: requesting consumptions from %s to %s",
+                    self._scups,
+                    start.isoformat(),
+                    end.isoformat(),
+                )
                 self.update_consumptions(
                     cups,
                     distributor_code,
-                    max([gap["from"] + timedelta(hours=1), contract["date_start"]]),
-                    min([gap["to"], contract["date_end"]]),
+                    start,
+                    end,
                     "0",
                     point_type,
                 )
 
-            # update maximeter
-            for gap in [
-                x
-                for x in miss_maxim
-                if not (
-                    date_to < contract["date_start"] or date_from > contract["date_end"]
-                )
-            ]:
+        # update maximeter
+        _LOGGER.info(
+            "%s: missing maximeter: %s",
+            self._scups,
+            ", ".join(
+                [
+                    "from " + x["from"].isoformat() + " to " + x["to"].isoformat()
+                    for x in miss_maxim
+                ]
+            ),
+        )
+        for gap in miss_maxim:
+            if not (date_to < supply["date_start"] or date_from > supply["date_end"]):
                 # fetch maximeter for each maximeter gap in valid periods
                 start = max(
-                    [gap["from"], contract["date_start"] + relativedelta(months=1)]
+                    [gap["from"], supply["date_start"] + relativedelta(months=1)]
                 )
-                end = min([gap["to"], contract["date_end"]])
+                end = min([gap["to"], supply["date_end"]])
                 start = min([start, end])
+                _LOGGER.info(
+                    "%s: requesting maximeter from %s to %s",
+                    self._scups,
+                    start.isoformat(),
+                    end.isoformat(),
+                )
                 self.update_maximeter(cups, distributor_code, start, end)
 
-        # safe check periods in non-registered contracts
-        if oldest_contract != supply_date_start and oldest_contract > max(
-            [date_from, supply_date_start]
-        ):
-            _LOGGER.info(
-                "%s: supplies and contract start date do not match, exploring non-registered contracts",
-                self._scups,
-            )
-            start = max([supply_date_start, date_from])
-            self.update_consumptions(
-                cups, distributor_code, start, oldest_contract, "0", point_type
-            )
-            self.update_maximeter(cups, distributor_code, start, oldest_contract)
-            miss_cons, miss_maxim = sort_and_filter(start, date_to)
-        else:
-            miss_cons, miss_maxim = sort_and_filter(
-                max([date_from, oldest_contract]), date_to
-            )
+        miss_cons, miss_maxim = sort_and_filter(date_from, date_to)
 
         return True
 

{e-data-1.2.18 → e_data-1.2.20}/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.18"
+VERSION = "1.2.20"
 
 # What packages are required for this module to be executed?
 REQUIRED = [

e-data-1.2.18/PKG-INFO

@@ -1,128 +0,0 @@
-Metadata-Version: 2.1
-Name: e-data
-Version: 1.2.18
-Summary: Python library for managing spanish energy data from various web providers
-Home-page: https://github.com/uvejota/python-edata
-Author: VMG
-Author-email: vmayorg@outlook.es
-License: GPLv3
-Description: 
-        [![Downloads](https://pepy.tech/badge/e-data)](https://pepy.tech/project/e-data)
-        [![Downloads](https://pepy.tech/badge/e-data/month)](https://pepy.tech/project/e-data)
-        [![Downloads](https://pepy.tech/badge/e-data/week)](https://pepy.tech/project/e-data)
-        
-        # python-edata
-        
-        Este paquete proporciona herramientas para la descarga de tus datos de consumo eléctrico (desde Datadis.es) y su posterior procesado. La motivación principal es que conocer el consumo puede ayudarnos a reducirlo, e incluso a elegir una tarifa que mejor se adapte a nuestras necesidades. A día de hoy sus capacidades de facturación (€) son limitadas, soporta PVPC (según disponibilidad de datos de REData) y tarificación fija por tramos. Es el corazón de la integración [homeassistant-edata](https://github.com/uvejota/homeassistant-edata).
-        
-        _**Esta herramienta no mantiene ningún tipo de vinculación con los proveedores de datos anteriormente mencionados, simplemente consulta la información disponible y facilita su posterior análisis.**_
-        
-        ## Instalación
-        
-        Puedes instalar la última versión estable mediante:
-        
-        ``` bash
-        pip install e-data
-        ```
-        
-        Si quieres probar la versión `dev` o contribuir a su desarrollo, clona este repositorio e instala manualmente las dependencias:
-        
-        ``` bash
-        pip install -r requirements.txt
-        ```
-        
-        ## Estructura
-        
-        El paquete consta de tres módulos diferenciados:
-        
-        * **Conectores** (módulo `connectors`), para definir los métodos de consulta a los diferentes proveedores: Datadis y REData.
-        * **Procesadores** (módulo `processors`), para procesar datos de consumo, maxímetro, o coste (tarificación). Ahora mismo consta de tres procesadores: `billing`, `consumption` y `maximeter`, además de algunas utilidades ubicadas en `utils`. Los procesadores deben heredar de la clase Processor definida en `base.py`
-        * **Ayudantes** (módulo `helpers`), para ayudar en el uso y gestión de los anteriores, presentando de momento un único ayudante llamado `EdataHelper` que te permite recopilar `X` días de datos (por defecto 365) y automáticamente procesarlos. Los datos son almacenados en la variable `data`, mientras que los atributos autocalculados son almacenados en la variable `attributes`. Por lo general, primero utilizan los conectores y luego procesan los datos, gestionando varias tareas de recuperación (principalmente para Datadis).
-        
-        Estos módulos corresponden a la siguiente estructura del paquete:
-        
-        ```
-        edata/
-            · __init__.py
-            · connectors/
-                · __init__.py
-                · datadis.py
-                · redata.py
-            · processors/
-                · __init__.py
-                · base.py
-                · billing.py
-                · consumption.py
-                · maximeter.py
-                · utils.py
-            · helpers.py
-        ```
-        
-        ## Ejemplo de uso
-        
-        Partimos de que tenemos credenciales en Datadis.es. Algunas aclaraciones:
-        * No es necesario solicitar API pública en el registro (se utilizará la API privada habilitada por defecto)
-        * El username suele ser el NIF del titular
-        * Copie el CUPS de la web de Datadis, algunas comercializadoras adhieren caracteres adicionales en el CUPS mostrado en su factura.
-        * La herramienta acepta el uso de NIF autorizado para consultar el suministro de otro titular.
-        
-        ``` python
-        from datetime import datetime
-        import json
-        
-        # importamos definiciones de datos que nos interesen
-        from edata.definitions import PricingRules
-        # importamos el ayudante
-        from edata.helpers import EdataHelper
-        # importamos el procesador de utilidades
-        from edata.processors import utils
-        
-        # Preparar reglas de tarificación (si se quiere)
-        PRICING_RULES_PVPC = PricingRules(
-            p1_kw_year_eur=30.67266,
-            p2_kw_year_eur=1.4243591,
-            meter_month_eur=0.81,
-            market_kw_year_eur=3.113,
-            electricity_tax=1.0511300560,
-            iva_tax=1.05,
-            # podemos rellenar los siguientes campos si quisiéramos precio fijo (y no pvpc)
-            p1_kwh_eur=None,
-            p2_kwh_eur=None,
-            p3_kwh_eur=None,
-        )
-        
-        # Instanciar el helper
-        # 'authorized_nif' permite indicar el NIF de la persona que nos autoriza a consultar su CUPS.
-        # 'data' permite "cargar" al helper datos anteriores (resultado edata.data de una ejecución anterior), para evitar volver a consultar los mismos.
-        edata = EdataHelper(
-                    "datadis_user",
-                    "datadis_password",
-                    "cups",
-                    datadis_authorized_nif=None,
-                    pricing_rules=PRICING_RULES_PVPC, # si se le pasa None, no aplica tarificación
-                    data=None, # aquí podríamos cargar datos anteriores
-                )
-        
-        # Solicitar actualización de todo el histórico (se almacena en edata.data)
-        edata.update(date_from=datetime(1970, 1, 1), date_to=datetime.today())
-        
-        # volcamos todo lo obtenido a un fichero
-        with open("backup.json", "w") as file:
-            json.dump(utils.serialize_dict(edata.data), file) # se puede utilizar deserialize_dict para la posterior lectura del backup
-        
-        # Imprimir atributos
-        print(edata.attributes)
-        ```
-        
-Platform: UNKNOWN
-Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
-Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.6
-Classifier: Programming Language :: Python :: 3.7
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: Implementation :: CPython
-Classifier: Programming Language :: Python :: Implementation :: PyPy
-Requires-Python: >=3.6.0
-Description-Content-Type: text/markdown

e-data-1.2.18/e_data.egg-info/PKG-INFO

@@ -1,128 +0,0 @@
-Metadata-Version: 2.1
-Name: e-data
-Version: 1.2.18
-Summary: Python library for managing spanish energy data from various web providers
-Home-page: https://github.com/uvejota/python-edata
-Author: VMG
-Author-email: vmayorg@outlook.es
-License: GPLv3
-Description: 
-        [![Downloads](https://pepy.tech/badge/e-data)](https://pepy.tech/project/e-data)
-        [![Downloads](https://pepy.tech/badge/e-data/month)](https://pepy.tech/project/e-data)
-        [![Downloads](https://pepy.tech/badge/e-data/week)](https://pepy.tech/project/e-data)
-        
-        # python-edata
-        
-        Este paquete proporciona herramientas para la descarga de tus datos de consumo eléctrico (desde Datadis.es) y su posterior procesado. La motivación principal es que conocer el consumo puede ayudarnos a reducirlo, e incluso a elegir una tarifa que mejor se adapte a nuestras necesidades. A día de hoy sus capacidades de facturación (€) son limitadas, soporta PVPC (según disponibilidad de datos de REData) y tarificación fija por tramos. Es el corazón de la integración [homeassistant-edata](https://github.com/uvejota/homeassistant-edata).
-        
-        _**Esta herramienta no mantiene ningún tipo de vinculación con los proveedores de datos anteriormente mencionados, simplemente consulta la información disponible y facilita su posterior análisis.**_
-        
-        ## Instalación
-        
-        Puedes instalar la última versión estable mediante:
-        
-        ``` bash
-        pip install e-data
-        ```
-        
-        Si quieres probar la versión `dev` o contribuir a su desarrollo, clona este repositorio e instala manualmente las dependencias:
-        
-        ``` bash
-        pip install -r requirements.txt
-        ```
-        
-        ## Estructura
-        
-        El paquete consta de tres módulos diferenciados:
-        
-        * **Conectores** (módulo `connectors`), para definir los métodos de consulta a los diferentes proveedores: Datadis y REData.
-        * **Procesadores** (módulo `processors`), para procesar datos de consumo, maxímetro, o coste (tarificación). Ahora mismo consta de tres procesadores: `billing`, `consumption` y `maximeter`, además de algunas utilidades ubicadas en `utils`. Los procesadores deben heredar de la clase Processor definida en `base.py`
-        * **Ayudantes** (módulo `helpers`), para ayudar en el uso y gestión de los anteriores, presentando de momento un único ayudante llamado `EdataHelper` que te permite recopilar `X` días de datos (por defecto 365) y automáticamente procesarlos. Los datos son almacenados en la variable `data`, mientras que los atributos autocalculados son almacenados en la variable `attributes`. Por lo general, primero utilizan los conectores y luego procesan los datos, gestionando varias tareas de recuperación (principalmente para Datadis).
-        
-        Estos módulos corresponden a la siguiente estructura del paquete:
-        
-        ```
-        edata/
-            · __init__.py
-            · connectors/
-                · __init__.py
-                · datadis.py
-                · redata.py
-            · processors/
-                · __init__.py
-                · base.py
-                · billing.py
-                · consumption.py
-                · maximeter.py
-                · utils.py
-            · helpers.py
-        ```
-        
-        ## Ejemplo de uso
-        
-        Partimos de que tenemos credenciales en Datadis.es. Algunas aclaraciones:
-        * No es necesario solicitar API pública en el registro (se utilizará la API privada habilitada por defecto)
-        * El username suele ser el NIF del titular
-        * Copie el CUPS de la web de Datadis, algunas comercializadoras adhieren caracteres adicionales en el CUPS mostrado en su factura.
-        * La herramienta acepta el uso de NIF autorizado para consultar el suministro de otro titular.
-        
-        ``` python
-        from datetime import datetime
-        import json
-        
-        # importamos definiciones de datos que nos interesen
-        from edata.definitions import PricingRules
-        # importamos el ayudante
-        from edata.helpers import EdataHelper
-        # importamos el procesador de utilidades
-        from edata.processors import utils
-        
-        # Preparar reglas de tarificación (si se quiere)
-        PRICING_RULES_PVPC = PricingRules(
-            p1_kw_year_eur=30.67266,
-            p2_kw_year_eur=1.4243591,
-            meter_month_eur=0.81,
-            market_kw_year_eur=3.113,
-            electricity_tax=1.0511300560,
-            iva_tax=1.05,
-            # podemos rellenar los siguientes campos si quisiéramos precio fijo (y no pvpc)
-            p1_kwh_eur=None,
-            p2_kwh_eur=None,
-            p3_kwh_eur=None,
-        )
-        
-        # Instanciar el helper
-        # 'authorized_nif' permite indicar el NIF de la persona que nos autoriza a consultar su CUPS.
-        # 'data' permite "cargar" al helper datos anteriores (resultado edata.data de una ejecución anterior), para evitar volver a consultar los mismos.
-        edata = EdataHelper(
-                    "datadis_user",
-                    "datadis_password",
-                    "cups",
-                    datadis_authorized_nif=None,
-                    pricing_rules=PRICING_RULES_PVPC, # si se le pasa None, no aplica tarificación
-                    data=None, # aquí podríamos cargar datos anteriores
-                )
-        
-        # Solicitar actualización de todo el histórico (se almacena en edata.data)
-        edata.update(date_from=datetime(1970, 1, 1), date_to=datetime.today())
-        
-        # volcamos todo lo obtenido a un fichero
-        with open("backup.json", "w") as file:
-            json.dump(utils.serialize_dict(edata.data), file) # se puede utilizar deserialize_dict para la posterior lectura del backup
-        
-        # Imprimir atributos
-        print(edata.attributes)
-        ```
-        
-Platform: UNKNOWN
-Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
-Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.6
-Classifier: Programming Language :: Python :: 3.7
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: Implementation :: CPython
-Classifier: Programming Language :: Python :: Implementation :: PyPy
-Requires-Python: >=3.6.0
-Description-Content-Type: text/markdown