pygazpar 1.3.0b2__tar.gz → 1.3.0b3__tar.gz

{pygazpar-1.3.0b2 → pygazpar-1.3.0b3}/CHANGELOG.md

@@ -4,7 +4,11 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-## [1.3.0] - 2025-02-08
+## [1.3.0] - 2025-02-09
+
+### Added
+
+[#84](https://github.com/ssenart/PyGazpar/issues/84) : Add a function to retrieve list of PCE ids and labels from account.
 
 ### Changed
 

{pygazpar-1.3.0b2 → pygazpar-1.3.0b3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: pygazpar
-Version: 1.3.0b2
+Version: 1.3.0b3
 Summary: Python library to download gas consumption from a GrDF (French Gas Company) account
 License: MIT License
          
@@ -113,8 +113,12 @@ client = pygazpar.Client(pygazpar.JsonWebDataSource(
     password='your password')
 )
 
-data = client.loadSince(pceIdentifier='your PCE identifier',
-                        lastNDays=60,
+# Returns the list of your PCE identifiers attached to your account.
+pce_identifiers = client.get_pce_identifiers()
+
+# Returns the daily and monthly consumptions for the last 60 days on your PCE identifier.
+data = client.load_since(pce_identifier='your PCE identifier',
+                        last_n_days=60,
                         frequencies=[pygazpar.Frequency.DAILY, pygazpar.Frequency.MONTHLY])
 ```
 See [samples/jsonSample.py](samples/jsonSample.py) file for the full example.
@@ -129,8 +133,12 @@ client = pygazpar.Client(pygazpar.ExcelWebDataSource(
     password='your password')
 )
 
-data = client.loadSince(pceIdentifier='your PCE identifier',
-                        lastNDays=60,
+# Returns the list of your PCE identifiers attached to your account.
+pce_identifiers = client.get_pce_identifiers()
+
+# Returns the daily and monthly consumptions for the last 60 days on your PCE identifier.
+data = client.load_since(pce_identifier='your PCE identifier',
+                        last_n_days=60,
                         frequencies=[pygazpar.Frequency.DAILY, pygazpar.Frequency.MONTHLY])
 ```
 See [samples/excelSample.py](samples/jsonSample.py) file for the full example.
@@ -142,8 +150,8 @@ import pygazpar
 
 client = pygazpar.Client(pygazpar.TestDataSource())
 
-data = client.loadSince(pceIdentifier='your PCE identifier',
-                        lastNDays=10,
+data = client.load_since(pce_identifier='your PCE identifier',
+                        last_n_days=10,
                         frequencies=[pygazpar.Frequency.DAILY, Frequency.MONTHLY])
 ```
 See [samples/testSample.py](samples/jsonSample.py) file for the full example.

{pygazpar-1.3.0b2 → pygazpar-1.3.0b3}/README.md

@@ -76,8 +76,12 @@ client = pygazpar.Client(pygazpar.JsonWebDataSource(
     password='your password')
 )
 
-data = client.loadSince(pceIdentifier='your PCE identifier',
-                        lastNDays=60,
+# Returns the list of your PCE identifiers attached to your account.
+pce_identifiers = client.get_pce_identifiers()
+
+# Returns the daily and monthly consumptions for the last 60 days on your PCE identifier.
+data = client.load_since(pce_identifier='your PCE identifier',
+                        last_n_days=60,
                         frequencies=[pygazpar.Frequency.DAILY, pygazpar.Frequency.MONTHLY])
 ```
 See [samples/jsonSample.py](samples/jsonSample.py) file for the full example.
@@ -92,8 +96,12 @@ client = pygazpar.Client(pygazpar.ExcelWebDataSource(
     password='your password')
 )
 
-data = client.loadSince(pceIdentifier='your PCE identifier',
-                        lastNDays=60,
+# Returns the list of your PCE identifiers attached to your account.
+pce_identifiers = client.get_pce_identifiers()
+
+# Returns the daily and monthly consumptions for the last 60 days on your PCE identifier.
+data = client.load_since(pce_identifier='your PCE identifier',
+                        last_n_days=60,
                         frequencies=[pygazpar.Frequency.DAILY, pygazpar.Frequency.MONTHLY])
 ```
 See [samples/excelSample.py](samples/jsonSample.py) file for the full example.
@@ -105,8 +113,8 @@ import pygazpar
 
 client = pygazpar.Client(pygazpar.TestDataSource())
 
-data = client.loadSince(pceIdentifier='your PCE identifier',
-                        lastNDays=10,
+data = client.load_since(pce_identifier='your PCE identifier',
+                        last_n_days=10,
                         frequencies=[pygazpar.Frequency.DAILY, Frequency.MONTHLY])
 ```
 See [samples/testSample.py](samples/jsonSample.py) file for the full example.

{pygazpar-1.3.0b2 → pygazpar-1.3.0b3}/pygazpar/__main__.py

@@ -67,7 +67,7 @@ def main():
         raise ValueError("Invalid datasource: (json | excel | test) is expected")
 
     try:
-        data = client.loadSince(args.pce, int(args.lastNDays), [args.frequency])
+        data = client.load_since(args.pce, int(args.lastNDays), [args.frequency])
     except BaseException:  # pylint: disable=broad-except
         print("An error occured while querying PyGazpar library : %s", traceback.format_exc())
         return 1

pygazpar-1.3.0b3/pygazpar/api_client.py

@@ -0,0 +1,228 @@
+import http.cookiejar
+import json
+import logging
+import time
+import traceback
+from datetime import date
+from enum import Enum
+from typing import Any
+
+from requests import Response, Session
+
+SESSION_TOKEN_URL = "https://connexion.grdf.fr/api/v1/authn"
+SESSION_TOKEN_PAYLOAD = """{{
+    "username": "{0}",
+    "password": "{1}",
+    "options": {{
+        "multiOptionalFactorEnroll": "false",
+        "warnBeforePasswordExpired": "false"
+    }}
+}}"""
+
+AUTH_TOKEN_URL = "https://connexion.grdf.fr/login/sessionCookieRedirect"
+AUTH_TOKEN_PARAMS = """{{
+    "checkAccountSetupComplete": "true",
+    "token": "{0}",
+    "redirectUrl": "https://monespace.grdf.fr"
+}}"""
+
+API_BASE_URL = "https://monespace.grdf.fr/api"
+
+DATE_FORMAT = "%Y-%m-%d"
+
+Logger = logging.getLogger(__name__)
+
+
+# ------------------------------------------------------
+class ConsumptionType(str, Enum):
+    INFORMATIVE = "informatives"
+    PUBLISHED = "publiees"
+
+
+# ------------------------------------------------------
+class Frequency(str, Enum):
+    HOURLY = "Horaire"
+    DAILY = "Journalier"
+    WEEKLY = "Hebdomadaire"
+    MONTHLY = "Mensuel"
+    YEARLY = "Annuel"
+
+
+# ------------------------------------------------------
+class ServerError(SystemError):
+
+    def __init__(self, message: str, status_code: int):
+        super().__init__(message)
+        self.status_code = status_code
+
+
+# ------------------------------------------------------
+class InternalServerError(ServerError):
+
+    def __init__(self, message: str):
+        super().__init__(message, 500)
+
+
+# ------------------------------------------------------
+class APIClient:
+
+    # ------------------------------------------------------
+    def __init__(self, username: str, password: str, retry_count: int = 10):
+        self._username = username
+        self._password = password
+        self._retry_count = retry_count
+        self._session = None
+
+    # ------------------------------------------------------
+    def login(self):
+        if self._session is not None:
+            return
+
+        session = Session()
+        session.headers.update({"domain": "grdf.fr"})
+        session.headers.update({"Content-Type": "application/json"})
+        session.headers.update({"X-Requested-With": "XMLHttpRequest"})
+
+        payload = SESSION_TOKEN_PAYLOAD.format(self._username, self._password)
+
+        response = session.post(SESSION_TOKEN_URL, data=payload)
+
+        if response.status_code != 200:
+            raise ServerError(
+                f"An error occurred while logging in. Status code: {response.status_code} - {response.text}",
+                response.status_code,
+            )
+
+        session_token = response.json().get("sessionToken")
+
+        jar = http.cookiejar.CookieJar()
+
+        self._session = Session()  # pylint: disable=attribute-defined-outside-init
+        self._session.headers.update({"Content-Type": "application/json"})
+        self._session.headers.update({"X-Requested-With": "XMLHttpRequest"})
+
+        params = json.loads(AUTH_TOKEN_PARAMS.format(session_token))
+
+        response = self._session.get(AUTH_TOKEN_URL, params=params, allow_redirects=True, cookies=jar)  # type: ignore
+
+        if response.status_code != 200:
+            raise ServerError(
+                f"An error occurred while getting the auth token. Status code: {response.status_code} - {response.text}",
+                response.status_code,
+            )
+
+    # ------------------------------------------------------
+    def is_logged_in(self) -> bool:
+        return self._session is not None
+
+    # ------------------------------------------------------
+    def logout(self):
+        if self._session is None:
+            return
+
+        self._session.close()
+        self._session = None
+
+    # ------------------------------------------------------
+    def get(self, endpoint: str, params: dict[str, Any]) -> Response:
+
+        if self._session is None:
+            raise ConnectionError("You must login first")
+
+        retry = self._retry_count
+        while retry > 0:
+
+            try:
+                response = self._session.get(f"{API_BASE_URL}{endpoint}", params=params)
+
+                if "text/html" in response.headers.get("Content-Type"):  # type: ignore
+                    raise InternalServerError(
+                        f"An unknown error occurred. Please check your query parameters (endpoint: {endpoint}): {params}"
+                    )
+
+                if response.status_code != 200:
+                    raise ServerError(
+                        f"HTTP error on enpoint '{endpoint}': Status code: {response.status_code} - {response.text}. Query parameters: {params}",
+                        response.status_code,
+                    )
+
+                break
+            except InternalServerError as internalServerError:  # pylint: disable=broad-exception-caught
+                if retry == 1:
+                    Logger.error(f"{internalServerError}. Retry limit reached: {traceback.format_exc()}")
+                    raise internalServerError
+                retry -= 1
+                Logger.warning(f"{internalServerError}. Retry in 3 seconds ({retry} retries left)...")
+                time.sleep(3)
+
+        return response
+
+    # ------------------------------------------------------
+    def get_pce_list(self, details: bool = False) -> list[Any]:
+
+        res = self.get("/e-conso/pce", {"details": details}).json()
+
+        if type(res) is not list:
+            raise TypeError(f"Invalid response type: {type(res)} (list expected)")
+
+        return res
+
+    # ------------------------------------------------------
+    def get_pce_consumption(
+        self, consumption_type: ConsumptionType, start_date: date, end_date: date, pce_list: list[str]
+    ) -> dict[str, Any]:
+
+        start = start_date.strftime(DATE_FORMAT)
+        end = end_date.strftime(DATE_FORMAT)
+
+        res = self.get(
+            f"/e-conso/pce/consommation/{consumption_type.value}",
+            {"dateDebut": start, "dateFin": end, "pceList[]": ",".join(pce_list)},
+        ).json()
+
+        if type(res) is list and len(res) == 0:
+            return dict[str, Any]()
+
+        if type(res) is not dict:
+            raise TypeError(f"Invalid response type: {type(res)} (dict expected)")
+
+        return res
+
+    # ------------------------------------------------------
+    def get_pce_consumption_excelsheet(
+        self,
+        consumption_type: ConsumptionType,
+        start_date: date,
+        end_date: date,
+        frequency: Frequency,
+        pce_list: list[str],
+    ) -> dict[str, Any]:
+
+        start = start_date.strftime(DATE_FORMAT)
+        end = end_date.strftime(DATE_FORMAT)
+
+        response = self.get(
+            f"/e-conso/pce/consommation/{consumption_type.value}/telecharger",
+            {"dateDebut": start, "dateFin": end, "frequence": frequency.value, "pceList[]": ",".join(pce_list)},
+        )
+
+        filename = response.headers["Content-Disposition"].split("filename=")[1]
+
+        res = {"filename": filename, "content": response.content}
+
+        return res
+
+    # ------------------------------------------------------
+    def get_pce_meteo(self, end_date: date, days: int, pce: str) -> dict[str, Any]:
+
+        end = end_date.strftime(DATE_FORMAT)
+
+        res = self.get(f"/e-conso/pce/{pce}/meteo", {"dateFinPeriode": end, "nbJours": days}).json()
+
+        if type(res) is list and len(res) == 0:
+            return dict[str, Any]()
+
+        if type(res) is not dict:
+            raise TypeError(f"Invalid response type: {type(res)} (dict expected)")
+
+        return res

pygazpar-1.3.0b3/pygazpar/client.py

@@ -0,0 +1,98 @@
+import logging
+import warnings
+from datetime import date, timedelta
+from typing import Optional
+
+from pygazpar.datasource import IDataSource, MeterReadingsByFrequency
+from pygazpar.enum import Frequency
+
+DEFAULT_LAST_N_DAYS = 365
+
+
+Logger = logging.getLogger(__name__)
+
+
+# ------------------------------------------------------------------------------------------------------------
+class Client:
+
+    # ------------------------------------------------------
+    def __init__(self, dataSource: IDataSource):
+        self.__dataSource = dataSource
+
+    # ------------------------------------------------------
+    def login(self):
+
+        try:
+            self.__dataSource.login()
+        except Exception:
+            Logger.error("An unexpected error occured while login", exc_info=True)
+            raise
+
+    # ------------------------------------------------------
+    def logout(self):
+
+        try:
+            self.__dataSource.logout()
+        except Exception:
+            Logger.error("An unexpected error occured while logout", exc_info=True)
+            raise
+
+    # ------------------------------------------------------
+    def get_pce_identifiers(self) -> list[str]:
+
+        try:
+            res = self.__dataSource.get_pce_identifiers()
+        except Exception:
+            Logger.error("An unexpected error occured while getting the PCE identifiers", exc_info=True)
+            raise
+
+        return res
+
+    # ------------------------------------------------------
+    def load_since(
+        self, pce_identifier: str, last_n_days: int = DEFAULT_LAST_N_DAYS, frequencies: Optional[list[Frequency]] = None
+    ) -> MeterReadingsByFrequency:
+
+        end_date = date.today()
+        start_date = end_date + timedelta(days=-last_n_days)
+
+        res = self.load_date_range(pce_identifier, start_date, end_date, frequencies)
+
+        return res
+
+    # ------------------------------------------------------
+    def load_date_range(
+        self, pce_identifier: str, start_date: date, end_date: date, frequencies: Optional[list[Frequency]] = None
+    ) -> MeterReadingsByFrequency:
+
+        Logger.debug("Start loading the data...")
+
+        try:
+            res = self.__dataSource.load(pce_identifier, start_date, end_date, frequencies)
+
+            Logger.debug("The data load terminates normally")
+        except Exception:
+            Logger.error("An unexpected error occured while loading the data", exc_info=True)
+            raise
+
+        return res
+
+    # ------------------------------------------------------
+    def loadSince(
+        self, pceIdentifier: str, lastNDays: int = DEFAULT_LAST_N_DAYS, frequencies: Optional[list[Frequency]] = None
+    ) -> MeterReadingsByFrequency:
+        warnings.warn(
+            "Client.loadSince() method will be removed in 2026-01-01. Please migrate to Client.load_since() method",
+            DeprecationWarning,
+        )
+        return self.load_since(pceIdentifier, lastNDays, frequencies)
+
+    # ------------------------------------------------------
+    def loadDateRange(
+        self, pceIdentifier: str, startDate: date, endDate: date, frequencies: Optional[list[Frequency]] = None
+    ) -> MeterReadingsByFrequency:
+        warnings.warn(
+            "Client.loadDateRange() method will be removed in 2026-01-01. Please migrate to Client.load_date_range() method",
+            DeprecationWarning,
+        )
+        return self.load_date_range(pceIdentifier, startDate, endDate, frequencies)

{pygazpar-1.3.0b2 → pygazpar-1.3.0b3}/pygazpar/datasource.py

@@ -1,52 +1,46 @@
 import glob
-import http.cookiejar
 import json
 import logging
 import os
-import time
 from abc import ABC, abstractmethod
 from datetime import date, timedelta
-from typing import Any, Dict, List, Optional, cast
+from typing import Any, Optional, cast
 
 import pandas as pd
-from requests import Session
 
+from pygazpar.api_client import APIClient, ConsumptionType
+from pygazpar.api_client import Frequency as APIClientFrequency
 from pygazpar.enum import Frequency, PropertyName
 from pygazpar.excelparser import ExcelParser
 from pygazpar.jsonparser import JsonParser
 
-SESSION_TOKEN_URL = "https://connexion.grdf.fr/api/v1/authn"
-SESSION_TOKEN_PAYLOAD = """{{
-    "username": "{0}",
-    "password": "{1}",
-    "options": {{
-        "multiOptionalFactorEnroll": "false",
-        "warnBeforePasswordExpired": "false"
-    }}
-}}"""
-
-AUTH_TOKEN_URL = "https://connexion.grdf.fr/login/sessionCookieRedirect"
-AUTH_TOKEN_PARAMS = """{{
-    "checkAccountSetupComplete": "true",
-    "token": "{0}",
-    "redirectUrl": "https://monespace.grdf.fr"
-}}"""
-
 Logger = logging.getLogger(__name__)
 
-MeterReading = Dict[str, Any]
+MeterReading = dict[str, Any]
 
-MeterReadings = List[MeterReading]
+MeterReadings = list[MeterReading]
 
-MeterReadingsByFrequency = Dict[str, MeterReadings]
+MeterReadingsByFrequency = dict[str, MeterReadings]
 
 
 # ------------------------------------------------------------------------------------------------------------
 class IDataSource(ABC):  # pylint: disable=too-few-public-methods
 
+    @abstractmethod
+    def login(self):
+        pass
+
+    @abstractmethod
+    def logout(self):
+        pass
+
+    @abstractmethod
+    def get_pce_identifiers(self) -> list[str]:
+        pass
+
     @abstractmethod
     def load(
-        self, pceIdentifier: str, startDate: date, endDate: date, frequencies: Optional[List[Frequency]] = None
+        self, pceIdentifier: str, startDate: date, endDate: date, frequencies: Optional[list[Frequency]] = None
     ) -> MeterReadingsByFrequency:
         pass
 
@@ -57,65 +51,50 @@ class WebDataSource(IDataSource):  # pylint: disable=too-few-public-methods
     # ------------------------------------------------------
     def __init__(self, username: str, password: str):
 
-        self.__username = username
-        self.__password = password
+        self._api_client = APIClient(username, password)
 
     # ------------------------------------------------------
-    def load(
-        self, pceIdentifier: str, startDate: date, endDate: date, frequencies: Optional[List[Frequency]] = None
-    ) -> MeterReadingsByFrequency:
+    def login(self):
 
-        self._login(self.__username, self.__password)  # We ignore the return value.
-
-        res = self._loadFromSession(pceIdentifier, startDate, endDate, frequencies)
-
-        Logger.debug("The data update terminates normally")
-
-        return res
+        if not self._api_client.is_logged_in():
+            self._api_client.login()
 
     # ------------------------------------------------------
-    def _login(self, username: str, password: str) -> str:
+    def logout(self):
 
-        session = Session()
-        session.headers.update({"domain": "grdf.fr"})
-        session.headers.update({"Content-Type": "application/json"})
-        session.headers.update({"X-Requested-With": "XMLHttpRequest"})
+        if self._api_client.is_logged_in():
+            self._api_client.logout()
 
-        payload = SESSION_TOKEN_PAYLOAD.format(username, password)
-
-        response = session.post(SESSION_TOKEN_URL, data=payload)
-
-        if response.status_code != 200:
-            raise ValueError(
-                f"An error occurred while logging in. Status code: {response.status_code} - {response.text}"
-            )
+    # ------------------------------------------------------
+    def get_pce_identifiers(self) -> list[str]:
 
-        session_token = response.json().get("sessionToken")
+        if not self._api_client.is_logged_in():
+            self._api_client.login()
 
-        Logger.debug("Session token: %s", session_token)
+        pce_list = self._api_client.get_pce_list()
 
-        jar = http.cookiejar.CookieJar()
+        if pce_list is None:
+            return []
 
-        self._session = Session()  # pylint: disable=attribute-defined-outside-init
-        self._session.headers.update({"Content-Type": "application/json"})
-        self._session.headers.update({"X-Requested-With": "XMLHttpRequest"})
+        return [pce["idObject"] for pce in pce_list]
 
-        params = json.loads(AUTH_TOKEN_PARAMS.format(session_token))
+    # ------------------------------------------------------
+    def load(
+        self, pceIdentifier: str, startDate: date, endDate: date, frequencies: Optional[list[Frequency]] = None
+    ) -> MeterReadingsByFrequency:
 
-        response = self._session.get(AUTH_TOKEN_URL, params=params, allow_redirects=True, cookies=jar)  # type: ignore
+        if not self._api_client.is_logged_in():
+            self._api_client.login()
 
-        if response.status_code != 200:
-            raise ValueError(
-                f"An error occurred while getting the auth token. Status code: {response.status_code} - {response.text}"
-            )
+        res = self._loadFromSession(pceIdentifier, startDate, endDate, frequencies)
 
-        auth_token = self._session.cookies.get("auth_token", domain="monespace.grdf.fr")
+        Logger.debug("The data update terminates normally")
 
-        return auth_token  # type: ignore
+        return res
 
     @abstractmethod
     def _loadFromSession(
-        self, pceIdentifier: str, startDate: date, endDate: date, frequencies: Optional[List[Frequency]] = None
+        self, pceIdentifier: str, startDate: date, endDate: date, frequencies: Optional[list[Frequency]] = None
     ) -> MeterReadingsByFrequency:
         pass
 
@@ -123,8 +102,6 @@ class WebDataSource(IDataSource):  # pylint: disable=too-few-public-methods
 # ------------------------------------------------------------------------------------------------------------
 class ExcelWebDataSource(WebDataSource):  # pylint: disable=too-few-public-methods
 
-    DATA_URL = "https://monespace.grdf.fr/api/e-conso/pce/consommation/informatives/telecharger?dateDebut={0}&dateFin={1}&frequence={3}&pceList[]={2}"
-
     DATE_FORMAT = "%Y-%m-%d"
 
     FREQUENCY_VALUES = {
@@ -146,7 +123,7 @@ class ExcelWebDataSource(WebDataSource):  # pylint: disable=too-few-public-metho
 
     # ------------------------------------------------------
     def _loadFromSession(  # pylint: disable=too-many-branches
-        self, pceIdentifier: str, startDate: date, endDate: date, frequencies: Optional[List[Frequency]] = None
+        self, pceIdentifier: str, startDate: date, endDate: date, frequencies: Optional[list[Frequency]] = None
     ) -> MeterReadingsByFrequency:  # pylint: disable=too-many-branches
 
         res = {}
@@ -171,33 +148,24 @@ class ExcelWebDataSource(WebDataSource):  # pylint: disable=too-few-public-metho
             frequencyList = list(set(frequencies))
 
         for frequency in frequencyList:
-            # Inject parameters.
-            downloadUrl = ExcelWebDataSource.DATA_URL.format(
-                startDate.strftime(ExcelWebDataSource.DATE_FORMAT),
-                endDate.strftime(ExcelWebDataSource.DATE_FORMAT),
-                pceIdentifier,
-                ExcelWebDataSource.FREQUENCY_VALUES[frequency],
-            )
 
             Logger.debug(
                 f"Loading data of frequency {ExcelWebDataSource.FREQUENCY_VALUES[frequency]} from {startDate.strftime(ExcelWebDataSource.DATE_FORMAT)} to {endDate.strftime(ExcelWebDataSource.DATE_FORMAT)}"
             )
 
-            # Retry mechanism.
-            retry = 10
-            while retry > 0:
-
-                try:
-                    self.__downloadFile(self._session, downloadUrl, self.__tmpDirectory)
-                    break
-                except Exception as e:  # pylint: disable=broad-exception-caught
+            response = self._api_client.get_pce_consumption_excelsheet(
+                ConsumptionType.INFORMATIVE,
+                startDate,
+                endDate,
+                APIClientFrequency(ExcelWebDataSource.FREQUENCY_VALUES[frequency]),
+                [pceIdentifier],
+            )
 
-                    if retry == 1:
-                        raise e
+            filename = response["filename"]
+            content = response["content"]
 
-                    Logger.error("An error occurred while loading data. Retry in 3 seconds.")
-                    time.sleep(3)
-                    retry -= 1
+            with open(f"{self.__tmpDirectory}/{filename}", "wb") as file:
+                file.write(content)
 
             # Load the XLSX file into the data structure
             file_list = glob.glob(data_file_path_pattern)
@@ -221,26 +189,6 @@ class ExcelWebDataSource(WebDataSource):  # pylint: disable=too-few-public-metho
 
         return res
 
-    # ------------------------------------------------------
-    def __downloadFile(self, session: Session, url: str, path: str):
-
-        response = session.get(url)
-
-        if "text/html" in response.headers.get("Content-Type"):  # type: ignore
-            raise ValueError("An error occurred while loading data. Please check your credentials.")
-
-        if response.status_code != 200:
-            raise ValueError(
-                f"An error occurred while loading data. Status code: {response.status_code} - {response.text}"
-            )
-
-        response.raise_for_status()
-
-        filename = response.headers["Content-Disposition"].split("filename=")[1]
-
-        with open(f"{path}/{filename}", "wb") as file:
-            file.write(response.content)
-
 
 # ------------------------------------------------------------------------------------------------------------
 class ExcelFileDataSource(IDataSource):  # pylint: disable=too-few-public-methods
@@ -249,8 +197,22 @@ class ExcelFileDataSource(IDataSource):  # pylint: disable=too-few-public-method
 
         self.__excelFile = excelFile
 
+    # ------------------------------------------------------
+    def login(self):
+        pass
+
+    # ------------------------------------------------------
+    def logout(self):
+        pass
+
+    # ------------------------------------------------------
+    def get_pce_identifiers(self) -> list[str]:
+
+        return ["0123456789"]
+
+    # ------------------------------------------------------
     def load(
-        self, pceIdentifier: str, startDate: date, endDate: date, frequencies: Optional[List[Frequency]] = None
+        self, pceIdentifier: str, startDate: date, endDate: date, frequencies: Optional[list[Frequency]] = None
     ) -> MeterReadingsByFrequency:
 
         res = {}
@@ -275,21 +237,16 @@ class ExcelFileDataSource(IDataSource):  # pylint: disable=too-few-public-method
 # ------------------------------------------------------------------------------------------------------------
 class JsonWebDataSource(WebDataSource):  # pylint: disable=too-few-public-methods
 
-    DATA_URL = (
-        "https://monespace.grdf.fr/api/e-conso/pce/consommation/informatives?dateDebut={0}&dateFin={1}&pceList[]={2}"
-    )
-
-    TEMPERATURES_URL = "https://monespace.grdf.fr/api/e-conso/pce/{0}/meteo?dateFinPeriode={1}&nbJours={2}"
-
     INPUT_DATE_FORMAT = "%Y-%m-%d"
 
     OUTPUT_DATE_FORMAT = "%d/%m/%Y"
 
+    # ------------------------------------------------------
     def _loadFromSession(
-        self, pceIdentifier: str, startDate: date, endDate: date, frequencies: Optional[List[Frequency]] = None
+        self, pceIdentifier: str, startDate: date, endDate: date, frequencies: Optional[list[Frequency]] = None
     ) -> MeterReadingsByFrequency:
 
-        res = {}
+        res = dict[str, Any]()
 
         computeByFrequency = {
             Frequency.HOURLY: FrequencyConverter.computeHourly,
@@ -299,56 +256,30 @@ class JsonWebDataSource(WebDataSource):  # pylint: disable=too-few-public-method
             Frequency.YEARLY: FrequencyConverter.computeYearly,
         }
 
-        # Data URL: Inject parameters.
-        downloadUrl = JsonWebDataSource.DATA_URL.format(
-            startDate.strftime(JsonWebDataSource.INPUT_DATE_FORMAT),
-            endDate.strftime(JsonWebDataSource.INPUT_DATE_FORMAT),
-            pceIdentifier,
-        )
-
-        # Retry mechanism.
-        retry = 10
-        while retry > 0:
-
-            try:
-                response = self._session.get(downloadUrl)
-
-                if "text/html" in response.headers.get("Content-Type"):  # type: ignore
-                    raise ValueError("An error occurred while loading data. Please check your credentials.")
-
-                if response.status_code != 200:
-                    raise ValueError(
-                        f"An error occurred while loading data. Status code: {response.status_code} - {response.text}"
-                    )
-
-                break
-            except Exception as e:  # pylint: disable=broad-exception-caught
-
-                if retry == 1:
-                    raise e
-
-                Logger.error("An error occurred while loading data. Retry in 3 seconds.")
-                time.sleep(3)
-                retry -= 1
-
-        data = response.text
+        data = self._api_client.get_pce_consumption(ConsumptionType.INFORMATIVE, startDate, endDate, [pceIdentifier])
 
         Logger.debug("Json meter data: %s", data)
 
         # Temperatures URL: Inject parameters.
         endDate = date.today() - timedelta(days=1) if endDate >= date.today() else endDate
-        days = min((endDate - startDate).days, 730)
-        temperaturesUrl = JsonWebDataSource.TEMPERATURES_URL.format(
-            pceIdentifier, endDate.strftime(JsonWebDataSource.INPUT_DATE_FORMAT), days
-        )
+        days = max(
+            min((endDate - startDate).days, 730), 10
+        )  # At least 10 days, at most 730 days, to avoid HTTP 500 error.
 
         # Get weather data.
-        temperatures = self._session.get(temperaturesUrl).text
+        try:
+            temperatures = self._api_client.get_pce_meteo(endDate, days, pceIdentifier)
+        except Exception:  # pylint: disable=broad-except
+            # Not a blocking error.
+            temperatures = None
 
         Logger.debug("Json temperature data: %s", temperatures)
 
         # Transform all the data into the target structure.
-        daily = JsonParser.parse(data, temperatures, pceIdentifier)
+        if data is None or len(data) == 0:
+            return res
+
+        daily = JsonParser.parse(json.dumps(data), json.dumps(temperatures), pceIdentifier)
 
         Logger.debug("Processed daily data: %s", daily)
 
@@ -368,13 +299,28 @@ class JsonWebDataSource(WebDataSource):  # pylint: disable=too-few-public-method
 # ------------------------------------------------------------------------------------------------------------
 class JsonFileDataSource(IDataSource):  # pylint: disable=too-few-public-methods
 
+    # ------------------------------------------------------
     def __init__(self, consumptionJsonFile: str, temperatureJsonFile):
 
         self.__consumptionJsonFile = consumptionJsonFile
         self.__temperatureJsonFile = temperatureJsonFile
 
+    # ------------------------------------------------------
+    def login(self):
+        pass
+
+    # ------------------------------------------------------
+    def logout(self):
+        pass
+
+    # ------------------------------------------------------
+    def get_pce_identifiers(self) -> list[str]:
+
+        return ["0123456789"]
+
+    # ------------------------------------------------------
     def load(
-        self, pceIdentifier: str, startDate: date, endDate: date, frequencies: Optional[List[Frequency]] = None
+        self, pceIdentifier: str, startDate: date, endDate: date, frequencies: Optional[list[Frequency]] = None
     ) -> MeterReadingsByFrequency:
 
         res = {}
@@ -409,12 +355,27 @@ class TestDataSource(IDataSource):  # pylint: disable=too-few-public-methods
 
     __test__ = False  # Will not be discovered as a test
 
+    # ------------------------------------------------------
     def __init__(self):
 
         pass
 
+    # ------------------------------------------------------
+    def login(self):
+        pass
+
+    # ------------------------------------------------------
+    def logout(self):
+        pass
+
+    # ------------------------------------------------------
+    def get_pce_identifiers(self) -> list[str]:
+
+        return ["0123456789"]
+
+    # ------------------------------------------------------
     def load(
-        self, pceIdentifier: str, startDate: date, endDate: date, frequencies: Optional[List[Frequency]] = None
+        self, pceIdentifier: str, startDate: date, endDate: date, frequencies: Optional[list[Frequency]] = None
     ) -> MeterReadingsByFrequency:
 
         res = dict[str, Any]()
@@ -440,7 +401,7 @@ class TestDataSource(IDataSource):  # pylint: disable=too-few-public-methods
             )
 
             with open(dataSampleFilename, mode="r", encoding="utf-8") as jsonFile:
-                res[frequency.value] = cast(List[Dict[PropertyName, Any]], json.load(jsonFile))
+                res[frequency.value] = cast(list[dict[PropertyName, Any]], json.load(jsonFile))
 
         return res
 
@@ -465,19 +426,19 @@ class FrequencyConverter:
 
     # ------------------------------------------------------
     @staticmethod
-    def computeHourly(daily: List[Dict[str, Any]]) -> List[Dict[str, Any]]:  # pylint: disable=unused-argument
+    def computeHourly(daily: list[dict[str, Any]]) -> list[dict[str, Any]]:  # pylint: disable=unused-argument
 
         return []
 
     # ------------------------------------------------------
     @staticmethod
-    def computeDaily(daily: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+    def computeDaily(daily: list[dict[str, Any]]) -> list[dict[str, Any]]:
 
         return daily
 
     # ------------------------------------------------------
     @staticmethod
-    def computeWeekly(daily: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+    def computeWeekly(daily: list[dict[str, Any]]) -> list[dict[str, Any]]:
 
         df = pd.DataFrame(daily)
 
@@ -533,13 +494,13 @@ class FrequencyConverter:
         # Select target columns.
         df = df[["time_period", "start_index_m3", "end_index_m3", "volume_m3", "energy_kwh", "timestamp"]]
 
-        res = cast(List[Dict[str, Any]], df.to_dict("records"))
+        res = cast(list[dict[str, Any]], df.to_dict("records"))
 
         return res
 
     # ------------------------------------------------------
     @staticmethod
-    def computeMonthly(daily: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+    def computeMonthly(daily: list[dict[str, Any]]) -> list[dict[str, Any]]:
 
         df = pd.DataFrame(daily)
 
@@ -581,13 +542,13 @@ class FrequencyConverter:
         # Select target columns.
         df = df[["time_period", "start_index_m3", "end_index_m3", "volume_m3", "energy_kwh", "timestamp"]]
 
-        res = cast(List[Dict[str, Any]], df.to_dict("records"))
+        res = cast(list[dict[str, Any]], df.to_dict("records"))
 
         return res
 
     # ------------------------------------------------------
     @staticmethod
-    def computeYearly(daily: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+    def computeYearly(daily: list[dict[str, Any]]) -> list[dict[str, Any]]:
 
         df = pd.DataFrame(daily)
 
@@ -624,6 +585,6 @@ class FrequencyConverter:
         # Select target columns.
         df = df[["time_period", "start_index_m3", "end_index_m3", "volume_m3", "energy_kwh", "timestamp"]]
 
-        res = cast(List[Dict[str, Any]], df.to_dict("records"))
+        res = cast(list[dict[str, Any]], df.to_dict("records"))
 
         return res

{pygazpar-1.3.0b2 → pygazpar-1.3.0b3}/pygazpar/excelparser.py

@@ -1,6 +1,6 @@
 import logging
 from datetime import datetime
-from typing import Any, Dict, List
+from typing import Any
 
 from openpyxl import load_workbook
 from openpyxl.cell.cell import Cell
@@ -18,7 +18,7 @@ class ExcelParser:  # pylint: disable=too-few-public-methods
 
     # ------------------------------------------------------
     @staticmethod
-    def parse(dataFilename: str, dataReadingFrequency: Frequency) -> List[Dict[str, Any]]:
+    def parse(dataFilename: str, dataReadingFrequency: Frequency) -> list[dict[str, Any]]:
 
         parseByFrequency = {
             Frequency.HOURLY: ExcelParser.__parseHourly,
@@ -43,7 +43,7 @@ class ExcelParser:  # pylint: disable=too-few-public-methods
 
     # ------------------------------------------------------
     @staticmethod
-    def __fillRow(row: Dict, propertyName: str, cell: Cell, isNumber: bool):
+    def __fillRow(row: dict, propertyName: str, cell: Cell, isNumber: bool):
 
         if cell.value is not None:
             if isNumber:
@@ -57,12 +57,12 @@ class ExcelParser:  # pylint: disable=too-few-public-methods
 
     # ------------------------------------------------------
     @staticmethod
-    def __parseHourly(worksheet: Worksheet) -> List[Dict[str, Any]]:  # pylint: disable=unused-argument
+    def __parseHourly(worksheet: Worksheet) -> list[dict[str, Any]]:  # pylint: disable=unused-argument
         return []
 
     # ------------------------------------------------------
     @staticmethod
-    def __parseDaily(worksheet: Worksheet) -> List[Dict[str, Any]]:
+    def __parseDaily(worksheet: Worksheet) -> list[dict[str, Any]]:
 
         res = []
 
@@ -91,7 +91,7 @@ class ExcelParser:  # pylint: disable=too-few-public-methods
 
     # ------------------------------------------------------
     @staticmethod
-    def __parseWeekly(worksheet: Worksheet) -> List[Dict[str, Any]]:
+    def __parseWeekly(worksheet: Worksheet) -> list[dict[str, Any]]:
 
         res = []
 
@@ -115,7 +115,7 @@ class ExcelParser:  # pylint: disable=too-few-public-methods
 
     # ------------------------------------------------------
     @staticmethod
-    def __parseMonthly(worksheet: Worksheet) -> List[Dict[str, Any]]:
+    def __parseMonthly(worksheet: Worksheet) -> list[dict[str, Any]]:
 
         res = []
 

{pygazpar-1.3.0b2 → pygazpar-1.3.0b3}/pygazpar/jsonparser.py

@@ -1,7 +1,7 @@
 import json
 import logging
 from datetime import datetime
-from typing import Any, Dict, List
+from typing import Any
 
 from pygazpar.enum import PropertyName
 
@@ -17,7 +17,7 @@ class JsonParser:  # pylint: disable=too-few-public-methods
 
     # ------------------------------------------------------
     @staticmethod
-    def parse(jsonStr: str, temperaturesStr: str, pceIdentifier: str) -> List[Dict[str, Any]]:
+    def parse(jsonStr: str, temperaturesStr: str, pceIdentifier: str) -> list[dict[str, Any]]:
 
         res = []
 

{pygazpar-1.3.0b2 → pygazpar-1.3.0b3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "pygazpar"
-version = "1.3.0b2"
+version = "1.3.0b3"
 description = "Python library to download gas consumption from a GrDF (French Gas Company) account"
 license = { file = "LICENSE" }
 readme = "README.md"

pygazpar-1.3.0b2/pygazpar/client.py

@@ -1,64 +0,0 @@
-import logging
-from datetime import date, timedelta
-from typing import List, Optional
-
-from pygazpar.datasource import IDataSource, MeterReadingsByFrequency
-from pygazpar.enum import Frequency
-
-AUTH_NONCE_URL = "https://monespace.grdf.fr/client/particulier/accueil"
-LOGIN_URL = "https://login.monespace.grdf.fr/sofit-account-api/api/v1/auth"
-LOGIN_HEADER = {"domain": "grdf.fr"}
-LOGIN_PAYLOAD = """{{
-    "email": "{0}",
-    "password": "{1}",
-    "capp": "meg",
-    "goto": "https://sofa-connexion.grdf.fr:443/openam/oauth2/externeGrdf/authorize?response_type=code&scope=openid%20profile%20email%20infotravaux%20%2Fv1%2Faccreditation%20%2Fv1%2Faccreditations%20%2Fdigiconso%2Fv1%20%2Fdigiconso%2Fv1%2Fconsommations%20new_meg&client_id=prod_espaceclient&state=0&redirect_uri=https%3A%2F%2Fmonespace.grdf.fr%2F_codexch&nonce={2}&by_pass_okta=1&capp=meg"}}"""
-DATA_URL = "https://monespace.grdf.fr/api/e-conso/pce/consommation/informatives/telecharger?dateDebut={1}&dateFin={2}&frequence={0}&pceList%5B%5D={3}"
-DATA_FILENAME = "Donnees_informatives_*.xlsx"
-
-DEFAULT_TMP_DIRECTORY = "/tmp"
-DEFAULT_LAST_N_DAYS = 365
-
-
-Logger = logging.getLogger(__name__)
-
-
-# ------------------------------------------------------------------------------------------------------------
-class Client:
-
-    # ------------------------------------------------------
-    def __init__(self, dataSource: IDataSource):
-        self.__dataSource = dataSource
-
-    # ------------------------------------------------------
-    def loadSince(
-        self, pceIdentifier: str, lastNDays: int = DEFAULT_LAST_N_DAYS, frequencies: Optional[List[Frequency]] = None
-    ) -> MeterReadingsByFrequency:
-
-        try:
-            endDate = date.today()
-            startDate = endDate + timedelta(days=-lastNDays)
-
-            res = self.loadDateRange(pceIdentifier, startDate, endDate, frequencies)
-        except Exception:
-            Logger.error("An unexpected error occured while loading the data", exc_info=True)
-            raise
-
-        return res
-
-    # ------------------------------------------------------
-    def loadDateRange(
-        self, pceIdentifier: str, startDate: date, endDate: date, frequencies: Optional[List[Frequency]] = None
-    ) -> MeterReadingsByFrequency:
-
-        Logger.debug("Start loading the data...")
-
-        try:
-            res = self.__dataSource.load(pceIdentifier, startDate, endDate, frequencies)
-
-            Logger.debug("The data load terminates normally")
-        except Exception:
-            Logger.error("An unexpected error occured while loading the data", exc_info=True)
-            raise
-
-        return res