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

e_data-1.2.19/PKG-INFO

@@ -0,0 +1,136 @@
+Metadata-Version: 2.1
+Name: e-data
+Version: 1.2.19
+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.19/e_data.egg-info/PKG-INFO

@@ -0,0 +1,136 @@
+Metadata-Version: 2.1
+Name: e-data
+Version: 1.2.19
+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.19}/edata/connectors/datadis.py

@@ -7,16 +7,15 @@ There a few issues that are workarounded:
 """
 
 import contextlib
+from datetime import datetime, timedelta
 import hashlib
 import json
 import logging
-from datetime import datetime, timedelta
 import os
-from dateutil.relativedelta import relativedelta
-
-import requests
 
+from dateutil.relativedelta import relativedelta
 from filelock import FileLock
+import requests
 
 from ..definitions import ConsumptionData, ContractData, MaxPowerData, SupplyData
 from ..processors import utils
@@ -155,7 +154,8 @@ class DatadisConnector:
                         self._recent_queries_cache_file, "w", encoding="utf8"
                     ) as dst_file:
                         json.dump(self._recent_cache, dst_file)
-                _LOGGER.info("Local cache updated")
+                _LOGGER.debug("Local cache updated")
+
             except Exception as e:
                 _LOGGER.warning("Unknown error while updating cache: %s", e)
 
@@ -253,13 +253,15 @@ class DatadisConnector:
                 _LOGGER.info("Got 200 OK at %s", url + params)
                 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)
+                    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(
@@ -276,7 +278,8 @@ class DatadisConnector:
                     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:
@@ -288,7 +291,8 @@ class DatadisConnector:
                         "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.19}/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.19}/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,22 @@ 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()
+        )
+
         # update contracts to get valid periods
         self.update_contracts(cups, distributor_code)
         if len(self.data["contracts"]) == 0:
@@ -282,7 +295,7 @@ class EdataHelper:
             )
             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"],
@@ -318,64 +331,47 @@ class EdataHelper:
             ),
         )
 
-        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"]
-                )
-            ]:
+        # update consumptions
+        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: request 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
+        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: request 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.19}/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.19"
 
 # 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