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

e-data-1.2.18/PKG-INFO

@@ -0,0 +1,128 @@
+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

@@ -0,0 +1,128 @@
+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.17 → e-data-1.2.18}/edata/connectors/datadis.py

@@ -4,7 +4,6 @@ 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
@@ -17,6 +16,8 @@ from dateutil.relativedelta import relativedelta
 
 import requests
 
+from filelock import FileLock
+
 from ..definitions import ConsumptionData, ContractData, MaxPowerData, SupplyData
 from ..processors import utils
 
@@ -104,50 +105,59 @@ class DatadisConnector:
             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."""
 
-        # 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]
+                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)
+
             with open(self._recent_queries_cache_file, encoding="utf8") as dst_file:
-                self._recent_cache = json.load(dst_file)
+                self._recent_cache.update(json.load(dst_file))
 
     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 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:
-            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)
+        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:
-                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)
+                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)
 
     def _is_recent_query(self, query: str) -> bool:
         """Check if a query has been done recently to avoid exceeding query limits."""
@@ -160,7 +170,7 @@ class DatadisConnector:
     def _get_cache_for_query(self, query: str) -> dict:
         """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)
 
     def _get_token(self):
@@ -302,7 +312,7 @@ class DatadisConnector:
 
         # Request the resource
         response = self._get(
-            URL_GET_SUPPLIES, request_data=data, ignore_recent_queries=False
+            URL_GET_SUPPLIES, request_data=data, ignore_recent_queries=True
         )
 
         # Response is a list of serialized supplies.
@@ -318,23 +328,27 @@ class DatadisConnector:
                     SupplyData(
                         cups=i["cups"],  # the supply identifier
                         date_start=datetime.strptime(
-                            i["validDateFrom"]
-                            if i["validDateFrom"] != ""
-                            else "1970/01/01",
+                            (
+                                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,
+                            (
+                                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,
+                        address=i.get("address", None),
+                        postal_code=i.get("postalCode", None),
+                        province=i.get("province", None),
+                        municipality=i.get("municipality", None),
+                        distributor=i.get("distributor", None),
                         # these two are mandatory, we will use them to fetch contracts data
                         pointType=i["pointType"],
                         distributorCode=i["distributorCode"],
@@ -355,7 +369,7 @@ class DatadisConnector:
         if authorized_nif is not None:
             data["authorizedNif"] = authorized_nif
         response = self._get(
-            URL_GET_CONTRACT_DETAIL, request_data=data, ignore_recent_queries=False
+            URL_GET_CONTRACT_DETAIL, request_data=data, ignore_recent_queries=True
         )
         contracts = []
         tomorrow_str = (datetime.today() + timedelta(days=1)).strftime("%Y/%m/%d")
@@ -373,12 +387,16 @@ class DatadisConnector:
                         ),
                         marketer=i["marketer"],
                         distributorCode=distributor_code,
-                        power_p1=i["contractedPowerkW"][0]
-                        if isinstance(i["contractedPowerkW"], list)
-                        else None,
-                        power_p2=i["contractedPowerkW"][1]
-                        if (len(i["contractedPowerkW"]) > 1)
-                        else None,
+                        power_p1=(
+                            i["contractedPowerkW"][0]
+                            if isinstance(i["contractedPowerkW"], list)
+                            else None
+                        ),
+                        power_p2=(
+                            i["contractedPowerkW"][1]
+                            if (len(i["contractedPowerkW"]) > 1)
+                            else None
+                        ),
                     )
                 )
             else:

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

@@ -74,9 +74,11 @@ class EdataHelper:
         self.datadis_api = DatadisConnector(
             datadis_username,
             datadis_password,
-            storage_path=os.path.join(storage_dir_path, const.PROG_NAME)
-            if storage_dir_path is not None
-            else None,
+            storage_path=(
+                os.path.join(storage_dir_path, const.PROG_NAME)
+                if storage_dir_path is not None
+                else None
+            ),
         )
         self.redata_api = REDataConnector()
 
@@ -679,11 +681,11 @@ class EdataHelper:
                         for x in self.data["consumptions"]
                         if x["datetime"] >= new_data_from
                     ],
-                    prices=[
-                        x for x in self.data["pvpc"] if x["datetime"] >= new_data_from
-                    ]
-                    if self.is_pvpc
-                    else None,
+                    prices=(
+                        [x for x in self.data["pvpc"] if x["datetime"] >= new_data_from]
+                        if self.is_pvpc
+                        else None
+                    ),
                     rules=self.pricing_rules,
                 )
             )

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

e-data-1.2.17/PKG-INFO

@@ -1,128 +0,0 @@
-Metadata-Version: 2.1
-Name: e-data
-Version: 1.2.17
-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
-
-
-[![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.17/e_data.egg-info/PKG-INFO

@@ -1,128 +0,0 @@
-Metadata-Version: 2.1
-Name: e-data
-Version: 1.2.17
-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
-
-
-[![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)
-```