myelectricaldatapy 2.2.0__tar.gz → 2.2.2__tar.gz

myelectricaldatapy-2.2.0/.github/workflows/dependbot-auto-approve.yml → myelectricaldatapy-2.2.2/.github/workflows/auto-approve.yml

@@ -1,26 +1,21 @@
-name: Dependabot auto-approve
+name: Dependency auto-merge
 on: pull_request
 
 permissions:
   pull-requests: write
+  contents: write
 
 jobs:
-  dependabot:
+  dependency:
     runs-on: ubuntu-latest
-    if: github.actor == 'dependabot[bot]'
+    if: ${{ github.actor == 'dependabot[bot]' || github.actor == 'pre-commit-ci[bot]' }}
     steps:
-      - name: Dependabot metadata
-        id: metadata
-        uses: dependabot/fetch-metadata@v2
-        with:
-          github-token: "${{ secrets.GITHUB_TOKEN }}"
       - name: Approve a PR
         run: gh pr review --approve "$PR_URL"
         env:
           PR_URL: ${{github.event.pull_request.html_url}}
           GH_TOKEN: ${{secrets.GITHUB_TOKEN}}
       - name: Enable auto-merge for Dependabot PRs
-        if: contains(steps.metadata.outputs.dependency-names, 'my-dependency') && steps.metadata.outputs.update-type == 'version-update:semver-patch'
         run: gh pr merge --auto --merge "$PR_URL"
         env:
           PR_URL: ${{github.event.pull_request.html_url}}

{myelectricaldatapy-2.2.0 → myelectricaldatapy-2.2.2}/.gitignore

@@ -110,5 +110,5 @@ dmypy.json
 #pyannotate
 type_info.json
 
-#perso
-test_home.py
+# Secret files
+secrets.yaml

{myelectricaldatapy-2.2.0 → myelectricaldatapy-2.2.2}/.pre-commit-config.yaml

@@ -1,14 +1,14 @@
 ---
 repos:
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.4.1
+    rev: v0.4.5
     hooks:
       - id: ruff
         args:
           - --fix
       - id: ruff-format
   - repo: https://github.com/codespell-project/codespell
-    rev: v2.2.6
+    rev: v2.3.0
     hooks:
       - id: codespell
         args:
@@ -45,11 +45,9 @@ repos:
           - --py311-plus
           - --force
           - --keep-updates
-        files: ^(/.+)?[^/]+\.py$
   - repo: https://github.com/pre-commit/mirrors-mypy
-    rev: v1.9.0
+    rev: v1.10.0
     hooks:
       - id: mypy
         args: [--strict, --ignore-missing-imports]
-        additional_dependencies: [types-requests==2.28.11.7]
-        exclude: tests/
+        exclude: (tests)

{myelectricaldatapy-2.2.0 → myelectricaldatapy-2.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: myelectricaldatapy
-Version: 2.2.0
+Version: 2.2.2
 Summary: Fetch Linky data from myelectricaldata.fr
 Author-email: Cyr-ius <cyr-ius@ipocus.net>
 License: GPL-3

{myelectricaldatapy-2.2.0 → myelectricaldatapy-2.2.2}/example.py

@@ -1,10 +1,11 @@
 #!/usr/bin/env python3
-# -*- coding: utf-8 -*-
 """Example code."""
 
 import asyncio
-import logging
 from datetime import datetime, timedelta
+import logging
+
+import yaml
 
 from myelectricaldatapy import Enedis, EnedisByPDL, EnedisException
 
@@ -16,12 +17,16 @@ formatter = logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(messag
 ch.setFormatter(formatter)
 logger.addHandler(ch)
 
-# Please , fill good values...
-PDL = "0123456789"
-TOKEN = "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+# Fill out the secrets in secrets.yaml, you can find an example
+# _secrets.yaml file, which has to be renamed after filling out the secrets.
+with open("./secrets.yaml", encoding="UTF-8") as file:
+    secrets = yaml.safe_load(file)
+
+TOKEN = secrets["TOKEN"]
+PDL = secrets["PDL"]
 
 
-async def main() -> None:
+async def async_main() -> None:
     """Main function."""
 
     api = Enedis(token=TOKEN)
@@ -38,10 +43,16 @@ async def main() -> None:
     except EnedisException as error:
         logger.error(error)
 
+    await api.async_close()
+
     myPdl = EnedisByPDL(PDL, TOKEN)
-    await myPdl.async_update()
-    print(myPdl.stats)
+    try:
+        await myPdl.async_update()
+        logger.info(myPdl.stats)
+    except EnedisException as error:
+        logger.error(error)
 
 
-loop = asyncio.get_event_loop()
-loop.run_until_complete(main())
+if __name__ == "__main__":
+    loop = asyncio.get_event_loop()
+    loop.run_until_complete(async_main())

myelectricaldatapy-2.2.2/myelectricaldatapy/auth.py

@@ -0,0 +1,68 @@
+"""Class for Enedis Authentication (http://www.myelectricaldata.fr)."""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+import socket
+from typing import Any
+
+from aiohttp import ClientError, ClientResponseError, ClientSession
+
+from .const import TIMEOUT, URL
+from .exceptions import (
+    EnedisException,
+    HttpRequestError,
+    LimitReached,
+    TimeoutExceededError,
+)
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class EnedisAuth:
+    """Class for Enedis Auth API."""
+
+    def __init__(
+        self, session: ClientSession, token: str, timeout: int = TIMEOUT
+    ) -> None:
+        """Init."""
+        self.token = token
+        self.timeout = timeout
+        self.session = session
+
+    async def async_request(self, path: str, method: str = "get", **kwargs: Any) -> Any:
+        """Request session."""
+        kwargs.setdefault("headers", {})
+        kwargs["headers"].update(
+            {"Content-Type": "application/json", "Authorization": self.token}
+        )
+
+        try:
+            async with asyncio.timeout(self.timeout):
+                _LOGGER.debug("Request: %s (%s) - %s", path, method, kwargs.get("json"))
+                response = await self.session.request(method, f"{URL}/{path}", **kwargs)
+                contents = await response.read()
+                response.raise_for_status()
+        except (asyncio.CancelledError, asyncio.TimeoutError) as error:
+            raise TimeoutExceededError(
+                "Timeout occurred while connecting to MyElectricalData."
+            ) from error
+        except ClientResponseError:
+            message = contents.decode("utf8")
+            if "application/json" in response.headers.get("Content-Type", ""):
+                if response.status == 409:
+                    raise LimitReached(json.loads(message))
+                raise EnedisException(json.loads(message))
+            raise EnedisException({"message": message})
+        except (ClientError, socket.gaierror) as error:
+            raise HttpRequestError(
+                "Error occurred while communicating with MyElectricalData."
+            ) from error
+
+        return (
+            await response.json()
+            if "application/json" in response.headers.get("Content-Type", "")
+            else await response.text()
+        )

{myelectricaldatapy-2.2.0 → myelectricaldatapy-2.2.2}/myelectricaldatapy/const.py

@@ -9,6 +9,7 @@ ATTR_PRICES = "prices"
 ATTR_SERVICE = "service"
 ATTR_STANDARD = "standard"
 ATTR_START = "start"
+ATTR_FN = "function"
 CONSUMPTION = "consumption"
 DAILY_CONSUM = "daily_consumption"
 DAILY_PROD = "daily_production"

{myelectricaldatapy-2.2.0 → myelectricaldatapy-2.2.2}/myelectricaldatapy/myelectricaldata.py

@@ -5,11 +5,13 @@ from __future__ import annotations
 from datetime import date, datetime as dt, timedelta
 import logging
 import re
-from types import TracebackType
 from typing import Any, Generator, cast
 
+from aiohttp import ClientSession
+
 from .auth import EnedisAuth
 from .const import DAILY_CONSUM, DAILY_PROD, DETAIL_CONSUM, DETAIL_PROD, TIMEOUT
+from .exceptions import EnedisException
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -18,10 +20,14 @@ class Enedis:
     """Get data of pdl."""
 
     def __init__(
-        self, token: str, session: Any | None = None, timeout: int = TIMEOUT
+        self,
+        token: str,
+        session: ClientSession = ClientSession(),
+        timeout: int = TIMEOUT,
     ) -> None:
         """Initialize."""
-        self.auth = EnedisAuth(token, session, timeout)
+        self.auth = EnedisAuth(session, token, timeout)
+        self.async_request = self.auth.async_request
         self.offpeaks: list[str] = []
         self.dt_offpeak: list[dt] = []
         self.last_access: date | None = None
@@ -43,7 +49,7 @@ class Enedis:
             end_date = end.strftime("%Y-%m-%d")
             path_range = f"/start/{start_date}/end/{end_date}"
         path = f"{service}/{pdl}{path_range}"
-        return await self.auth.request(path=path)
+        return await self.async_request(path=path)
 
     async def async_valid_access(self, pdl: str) -> Any:
         """Return valid access."""
@@ -103,7 +109,7 @@ class Enedis:
             if end
             else (dt.now() + timedelta(days=1)).strftime("%Y-%m-%d")
         )
-        return await self.auth.request(path=f"rte/tempo/{str_start}/{str_end}")
+        return await self.auth.async_request(path=f"rte/tempo/{str_start}/{str_end}")
 
     async def async_get_ecowatt(
         self, start: dt | None = None, end: dt | None = None
@@ -117,7 +123,7 @@ class Enedis:
             if end
             else (dt.now() + timedelta(days=1)).strftime("%Y-%m-%d")
         )
-        return await self.auth.request(path=f"rte/ecowatt/{str_start}/{str_end}")
+        return await self.async_request(path=f"rte/ecowatt/{str_start}/{str_end}")
 
     async def async_has_offpeak(self, pdl: str) -> bool:
         """Has offpeak hours."""
@@ -150,71 +156,42 @@ class Enedis:
 
     async def async_get_details_consumption(self, pdl: str, start: dt, end: dt) -> Any:
         """Get consumption details. (max: 7 days)."""
-        data = None
-        for interval in list(self.date_range(start, end, 7)):
-            start, end = interval
-            try:
-                rsp = await self.async_fetch_datas(DETAIL_CONSUM, pdl, start, end)
-            finally:
-                if (
-                    rsp is None
-                    or rsp.get("meter_reading", {}).get("interval_reading") is None
-                ):
-                    continue
-                elif data is None:
-                    data = cast(dict[str, Any], rsp)
-                else:
-                    data["meter_reading"]["interval_reading"].extend(
-                        rsp.get("meter_reading", {}).get("interval_reading")
-                    )
-
-        return data
+        return await self._async_get_details(DETAIL_CONSUM, pdl, start, end)
 
     async def async_get_details_production(self, pdl: str, start: dt, end: dt) -> Any:
+        """Get production details. (max: 7 days)."""
+        return await self._async_get_details(DETAIL_PROD, pdl, start, end)
+
+    async def async_get_max_power(self, pdl: str, start: dt, end: dt) -> Any:
+        """Get consumption max power."""
+        return await self.async_fetch_datas(
+            "daily_consumption_max_power", pdl, start, end
+        )
+
+    async def _async_get_details(self, mode: str, pdl: str, start: dt, end: dt) -> Any:
         """Get production details. (max: 7 days)."""
         data = None
+        response = {}
+        raise_error = False
         for interval in list(self.date_range(start, end, 7)):
             start, end = interval
             try:
-                rsp = await self.async_fetch_datas(DETAIL_PROD, pdl, start, end)
+                if raise_error is False:
+                    response = await self.async_fetch_datas(mode, pdl, start, end)
+            except EnedisException as error:
+                raise_error = True
+                _LOGGER.error(error)
             finally:
-                if (
-                    rsp is None
-                    or rsp.get("meter_reading", {}).get("interval_reading") is None
-                ):
+                new_data = response.get("meter_reading", {}).get("interval_reading")
+                if response is None or new_data is None:
                     continue
                 elif data is None:
-                    data = cast(dict[str, Any], rsp)
+                    data = cast(dict[str, Any], response)
                 else:
-                    data["meter_reading"]["interval_reading"].extend(
-                        rsp.get("meter_reading", {}).get("interval_reading")
-                    )
+                    data["meter_reading"]["interval_reading"].extend(new_data)
 
         return data
 
-    async def async_get_max_power(self, pdl: str, start: dt, end: dt) -> Any:
-        """Get consumption max power."""
-        return await self.async_fetch_datas(
-            "daily_consumption_max_power", pdl, start, end
-        )
-
-    async def __aenter__(self) -> Enedis:
-        """Asynchronous enter."""
-        return self
-
-    async def __aexit__(
-        self,
-        exc_type: type[BaseException] | None,
-        exc_value: BaseException | None,
-        traceback: TracebackType | None,
-    ) -> None:
-        """Asynchronous exit."""
-        await self.close()
-
-    async def close(self) -> None:
-        """Close the session."""
-        await self.auth.async_close()
-
     @staticmethod
     def date_range(start: dt, end: dt, intv: int) -> Generator[tuple[dt, dt], dt, None]:
         """Return range by interval date."""
@@ -228,3 +205,16 @@ class Enedis:
             yield (start, s_end)
             start = s_end
         yield (start, end)
+
+    async def __aenter__(self) -> Enedis:
+        """Asynchronous enter."""
+        return self
+
+    async def __aexit__(self, *_exc_info: object) -> None:
+        """Async exit."""
+        await self.async_close()
+
+    async def async_close(self) -> None:
+        """Close the session."""
+        if self.auth.session:
+            await self.auth.session.close()

{myelectricaldatapy-2.2.0 → myelectricaldatapy-2.2.2}/myelectricaldatapy/mypdl.py

@@ -6,6 +6,7 @@ from datetime import date, datetime as dt, timedelta
 import logging
 from typing import Any, Callable, Tuple
 
+from aiohttp import ClientSession
 import voluptuous as vol
 
 from myelectricaldatapy import Enedis, EnedisException, LimitReached
@@ -15,6 +16,7 @@ from .const import (
     ATTR_CUM_PRICE,
     ATTR_CUM_VALUE,
     ATTR_END,
+    ATTR_FN,
     ATTR_INTERVALS,
     ATTR_OFFPEAK,
     ATTR_PRICES,
@@ -88,7 +90,7 @@ class EnedisByPDL:
         self,
         pdl: str,
         token: str,
-        session: Any | None = None,
+        session: ClientSession = ClientSession(),
         timeout: int = TIMEOUT,
     ) -> None:
         """Initialize."""
@@ -300,7 +302,7 @@ class EnedisByPDL:
         func = funcs[service]
         dt_start = start if start else dt.now() - timedelta(days=days)
         dt_end = end if end else dt.now() + timedelta(days=1)
-        self._params[mode] = {"func": func, ATTR_START: dt_start, ATTR_END: dt_end}
+        self._params[mode] = {ATTR_FN: func, ATTR_START: dt_start, ATTR_END: dt_end}
         if intervals:
             self._set_intervals(mode, intervals)
         if prices:
@@ -315,23 +317,24 @@ class EnedisByPDL:
         """Update data to collect."""
         checked = True
         self.has_collected = False
-        for mode, _param in self._params.items():
+        for mode, attr in self._params.items():
             dataset = {}
-            start = _param[ATTR_START]
-            end = _param[ATTR_END]
-            if func := _param.get("func"):
-                try:
-                    dataset = await func(self.pdl, start, end)
-                    if dataset is None or dataset.get("meter_reading") is None:
-                        raise EnedisException("Data collect is empty")
-                except EnedisException as error:
-                    checked = False
-                    _LOGGER.error(error.args[1]["detail"])
+            start = attr[ATTR_START]
+            end = attr[ATTR_END]
+            fn = attr[ATTR_FN]
+            try:
+                dataset = await fn(self.pdl, start, end)
+            except EnedisException as error:
+                checked = False
+                _LOGGER.error(error)
+            else:
                 data = dataset.get("meter_reading", {}).get("interval_reading", [])
-                if len(data) > 0:
-                    checked = checked and len(data) > 0
-                    self._params[mode].update({"data": data})
-                if mode == CONSUMPTION and self._tempo_subs:
-                    self.tempo = await self._api.async_get_tempo(start, end)
+                if len(data) == 0:
+                    raise EnedisException("Data collection is empty")
+                checked = checked and len(data) > 0
+                self._params[mode].update({"data": data})
+
+            if mode == CONSUMPTION and self._tempo_subs:
+                self.tempo = await self._api.async_get_tempo(start, end)
 
         self.has_collected = checked

{myelectricaldatapy-2.2.0 → myelectricaldatapy-2.2.2}/myelectricaldatapy.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: myelectricaldatapy
-Version: 2.2.0
+Version: 2.2.2
 Summary: Fetch Linky data from myelectricaldata.fr
 Author-email: Cyr-ius <cyr-ius@ipocus.net>
 License: GPL-3

{myelectricaldatapy-2.2.0 → myelectricaldatapy-2.2.2}/myelectricaldatapy.egg-info/SOURCES.txt

@@ -9,7 +9,7 @@ pyproject.toml
 requirements-dev.txt
 requirements.txt
 .github/dependabot.yml
-.github/workflows/dependbot-auto-approve.yml
+.github/workflows/auto-approve.yml
 .github/workflows/lint.yml
 .github/workflows/pythonpublish.yml
 .github/workflows/release.yml
@@ -31,4 +31,12 @@ tests/__init__.py
 tests/conftest.py
 tests/consts.py
 tests/test_analytics.py
-tests/test_load_data.py
+tests/test_load_data.py
+tests/fixtures/access.json
+tests/fixtures/address.json
+tests/fixtures/contract.json
+tests/fixtures/daily.json
+tests/fixtures/detail.json
+tests/fixtures/ecowatt.json
+tests/fixtures/invalid_access.json
+tests/fixtures/tempo.json

{myelectricaldatapy-2.2.0 → myelectricaldatapy-2.2.2}/pyproject.toml

@@ -33,14 +33,14 @@ dependencies    = [
 
 [tool.setuptools_scm]
 
-[tool.ruff.flake8-pytest-style]
+[tool.ruff.lint.flake8-pytest-style]
 fixture-parentheses = false
 
-[tool.ruff.flake8-tidy-imports.banned-api]
-"async_timeout".msg = "use asyncio.timeout instead"
-"pytz".msg = "use zoneinfo instead"
-
-[tool.ruff.isort]
+[tool.ruff.lint.isort]
 force-sort-within-sections = true
 combine-as-imports = true
 split-on-trailing-comma = false
+
+[[tool.mypy.overrides]]
+module = "yaml"
+ignore_missing_imports = true

myelectricaldatapy-2.2.2/tests/__init__.py

@@ -0,0 +1,9 @@
+"""Tests for myelectricaldata."""
+
+from pathlib import Path
+
+
+def load_fixture(filename: str) -> str:
+    """Load a fixture."""
+    path = Path(__package__) / "fixtures" / filename
+    return path.read_text(encoding="utf-8")

myelectricaldatapy-2.2.2/tests/conftest.py

@@ -0,0 +1,125 @@
+"""Test helpers for MyElectricalData."""
+
+from collections.abc import Generator
+import json
+from typing import Any
+from unittest.mock import AsyncMock, patch
+
+import pytest
+
+import myelectricaldatapy
+
+from . import load_fixture
+
+
+@pytest.fixture(name="mock_detail")
+def mock_detail() -> dict[str, Any]:
+    return json.loads(load_fixture("detail.json"))
+
+
+@pytest.fixture(name="mock_daily")
+def mock_daily() -> dict[str, Any]:
+    return json.loads(load_fixture("daily.json"))
+
+
+@pytest.fixture(name="mock_contract")
+def mock_contract() -> dict[str, Any]:
+    return json.loads(load_fixture("contract.json"))
+
+
+@pytest.fixture(name="mock_access")
+def mock_access(request) -> dict[str, Any]:
+    if hasattr(request, "param") and request.param:
+        return json.loads(load_fixture("invalid_access.json"))
+    return json.loads(load_fixture("access.json"))
+
+
+@pytest.fixture(name="mock_address")
+def mock_address() -> dict[str, Any]:
+    return json.loads(load_fixture("address.json"))
+
+
+@pytest.fixture(name="mock_tempo")
+def mock_tempo(return_invalid: bool = False) -> dict[str, Any]:
+    return json.loads(load_fixture("tempo.json"))
+
+
+@pytest.fixture(name="mock_ecowatt")
+def mock_ecowatt(request) -> dict[str, Any]:
+    if hasattr(request, "param") and request.param:
+        return {
+            "detail": "Pas de données disponible entre la date du 2023-01-22 00:00:00 et 2023-01-22 00:00:00"  # noqa
+        }
+    return json.loads(load_fixture("ecowatt.json"))
+
+
+@pytest.fixture(name="mock_enedis")
+def mock_enedis(
+    mock_detail,
+    mock_daily,
+    mock_contract,
+    mock_access,
+    mock_address,
+    mock_tempo,
+    mock_ecowatt,
+) -> Generator[AsyncMock, None, None]:
+    """Mock a successful connection."""
+
+    with (
+        patch.object(
+            myelectricaldatapy.Enedis,
+            "async_get_daily_consumption",
+            return_value=mock_daily,
+        ),
+        patch.object(
+            myelectricaldatapy.Enedis,
+            "async_get_daily_production",
+            return_value=mock_daily,
+        ),
+        patch.object(
+            myelectricaldatapy.Enedis,
+            "async_get_details_consumption",
+            return_value=mock_detail,
+        ),
+        patch.object(
+            myelectricaldatapy.Enedis, "async_valid_access", return_value=mock_access
+        ),
+        patch.object(
+            myelectricaldatapy.Enedis, "async_get_contract", return_value=mock_contract
+        ),
+        patch.object(
+            myelectricaldatapy.Enedis, "async_get_address", return_value=mock_address
+        ),
+        patch.object(
+            myelectricaldatapy.Enedis, "async_get_tempo", return_value=mock_tempo
+        ),
+        patch.object(
+            myelectricaldatapy.Enedis, "async_get_ecowatt", return_value=mock_ecowatt
+        ),
+    ):
+        yield AsyncMock()
+
+
+@pytest.fixture(name="mock_base")
+def mock_base(
+    mock_access, mock_contract, mock_address, mock_tempo, mock_ecowatt
+) -> Generator[AsyncMock, None, None]:
+    """Mock a successful connection."""
+    with (
+        patch.object(
+            myelectricaldatapy.Enedis, "async_valid_access", return_value=mock_access
+        ),
+        patch.object(
+            myelectricaldatapy.Enedis, "async_get_contract", return_value=mock_contract
+        ),
+        patch.object(
+            myelectricaldatapy.Enedis, "async_get_address", return_value=mock_address
+        ),
+        patch.object(
+            myelectricaldatapy.Enedis, "async_get_tempo", return_value=mock_tempo
+        ),
+        patch.object(
+            myelectricaldatapy.Enedis, "async_get_ecowatt", return_value=mock_ecowatt
+        ),
+    ):
+        yield AsyncMock()

myelectricaldatapy-2.2.2/tests/consts.py

@@ -0,0 +1,4 @@
+"""Test constants."""
+
+PDL = "01234567890"
+TOKEN = "xxxxxxxxxxxxx"

myelectricaldatapy-2.2.2/tests/fixtures/access.json

@@ -0,0 +1,10 @@
+{
+  "valid": true,
+  "consent_expiration_date": "2026-01-14T15:32:38",
+  "call_number": 7,
+  "quota_reached": false,
+  "quota_limit": 50,
+  "quota_reset_at": "2023-03-01T23:59:59.999999",
+  "last_call": "2023-03-01T13:58:24.532501",
+  "ban": false
+}