pygazpar 0.1.20__py3-none-any.whl → 1.3.0__py3-none-any.whl

pygazpar/__init__.py

@@ -1,3 +1,10 @@
-from pygazpar.enum import PropertyNameEnum
-from pygazpar.client import Client
-from pygazpar.client import LoginError
+from pygazpar.client import Client  # noqa: F401
+from pygazpar.datasource import (  # noqa: F401
+    ExcelFileDataSource,
+    ExcelWebDataSource,
+    JsonFileDataSource,
+    JsonWebDataSource,
+    TestDataSource,
+)
+from pygazpar.enum import Frequency, PropertyName  # noqa: F401
+from pygazpar.version import __version__  # noqa: F401

pygazpar/__main__.py

@@ -1,58 +1,89 @@
-import argparse
-import sys
-import json
-import traceback
-import os
-import logging
-
-from pygazpar.client import Client
-
-def main():
-    """Main function"""
-    parser = argparse.ArgumentParser()
-    parser.add_argument("-u", "--username",
-                      required=True,
-                      help="GRDF username (email)")    
-    parser.add_argument("-p", "--password",
-                      required=True,
-                      help="GRDF password")    
-    parser.add_argument("-w", "--webdriver",
-                      required=True,
-                      help="Firefox webdriver executable (geckodriver)")    
-    parser.add_argument("-s", "--wait_time",
-                      required=False,
-                      type=int,
-                      default=30,
-                      help="Wait time in seconds (see https://selenium-python.readthedocs.io/waits.html for details)")    
-    parser.add_argument("-t", "--tmpdir",
-                      required=False,
-                      default="/tmp",
-                      help="tmp directory (default is /tmp)")
-    parser.add_argument("-l", "--lastNRows",
-                      required=False,
-                      type=int,
-                      default=0,
-                      help="Get only the last N rows (default is 0: it means all rows are retrieved)")                           
-
-    args = parser.parse_args()
-
-    # We remove the pygazpar log file.
-    geckodriverLogFile = f"{args.tmpdir}/pygazpar.log"
-    if os.path.isfile(geckodriverLogFile):
-        os.remove(geckodriverLogFile)
-
-    # Setup logging.
-    logging.basicConfig(filename=f"{args.tmpdir}/pygazpar.log", level=logging.DEBUG, format="%(asctime)s %(levelname)s [%(name)s] %(message)s")
-
-    client = Client(args.username, args.password, args.webdriver, int(args.wait_time), args.tmpdir, int(args.lastNRows))
-
-    try:
-        client.update()
-    except BaseException:
-        print('An error occured while querying PyGazpar library : %s', traceback.format_exc())
-        return 1
-
-    print(json.dumps(client.data(), indent=2))
-
-if __name__ == '__main__':
-    sys.exit(main())
+import argparse
+import json
+import logging
+import os
+import sys
+import traceback
+
+import pygazpar
+
+Logger = logging.getLogger(__name__)
+
+
+def main():
+    """Main function"""
+    parser = argparse.ArgumentParser()
+    parser.add_argument("-v", "--version", action="version", version=f"PyGazpar {pygazpar.__version__}")
+    parser.add_argument("-u", "--username", required=True, help="GRDF username (email)")
+    parser.add_argument("-p", "--password", required=True, help="GRDF password")
+    parser.add_argument("-c", "--pce", required=True, help="GRDF PCE identifier")
+    parser.add_argument("-t", "--tmpdir", required=False, default="/tmp", help="tmp directory (default is /tmp)")
+    parser.add_argument(
+        "-f",
+        "--frequency",
+        required=False,
+        type=lambda frequency: pygazpar.Frequency[frequency],
+        choices=list(pygazpar.Frequency),
+        default="DAILY",
+        help="Meter reading frequency (DAILY, WEEKLY, MONTHLY, YEARLY)",
+    )
+    parser.add_argument(
+        "-d",
+        "--lastNDays",
+        required=False,
+        type=int,
+        default=365,
+        help="Get only the last N days of records (default: 365 days)",
+    )
+    parser.add_argument("--datasource", required=False, default="json", help="Datasource: json | excel | test")
+
+    args = parser.parse_args()
+
+    print(f"PyGazpar version: {pygazpar.__version__}")
+    print(f"Running on Python version: {sys.version}")
+
+    # We create the tmp directory if not already exists.
+    if not os.path.exists(args.tmpdir):
+        os.mkdir(args.tmpdir)
+
+    # We remove the pygazpar log file.
+    pygazparLogFile = f"{args.tmpdir}/pygazpar.log"
+    if os.path.isfile(pygazparLogFile):
+        os.remove(pygazparLogFile)
+
+    # Setup logging.
+    logging.basicConfig(
+        filename=f"{pygazparLogFile}", level=logging.DEBUG, format="%(asctime)s %(levelname)s [%(name)s] %(message)s"
+    )
+
+    Logger.info(f"PyGazpar version: {pygazpar.__version__}")
+    Logger.info(f"Running on Python version: {sys.version}")
+    Logger.info(f"--tmpdir {args.tmpdir}")
+    Logger.info(f"--frequency {args.frequency}")
+    Logger.info(f"--lastNDays {args.lastNDays}")
+    Logger.info(f"--datasource {bool(args.datasource)}")
+
+    if args.datasource == "json":
+        client = pygazpar.Client(pygazpar.JsonWebDataSource(args.username, args.password))
+    elif args.datasource == "excel":
+        client = pygazpar.Client(pygazpar.ExcelWebDataSource(args.username, args.password, args.tmpdir))
+    elif args.datasource == "test":
+        client = pygazpar.Client(pygazpar.TestDataSource())
+    else:
+        raise ValueError("Invalid datasource: (json | excel | test) is expected")
+
+    try:
+        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
+
+    Logger.info(f"Data loaded: {len(data)} records")
+    Logger.debug(f"Data: {data}")
+    print(json.dumps(data, indent=2))
+
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

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