myelectricaldatapy 2.2.2__tar.gz → 2.2.4__tar.gz

myelectricaldatapy-2.2.2/.github/workflows/pythonpublish.yml → myelectricaldatapy-2.2.4/.github/workflows/python-publish.yml

@@ -3,10 +3,8 @@ name: Upload Python Package
 on:
   release:
     types: ["published"]
-
-  push:
-    tags:
-      - "*.*.*"
+  workflow_call:
+  workflow_dispatch:
 
 jobs:
   deploy:

{myelectricaldatapy-2.2.2 → myelectricaldatapy-2.2.4}/.github/workflows/release.yml

@@ -26,3 +26,11 @@ jobs:
           body: ${{ steps.changelog.outputs.changelog }}
           draft: false
           prerelease: false
+  publish:
+    needs: release
+    permissions:
+      contents: write
+      packages: write
+      id-token: write
+    if: ${{ ! contains(github.ref_name, '-') }}
+    uses: ./.github/workflows/python-publish.yml

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

@@ -1,7 +1,7 @@
 ---
 repos:
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.4.5
+    rev: v0.8.2
     hooks:
       - id: ruff
         args:
@@ -17,7 +17,7 @@ repos:
           - --quiet-level=2
         exclude_types: [csv, json]
   - repo: https://github.com/pre-commit/pre-commit-hooks
-    rev: v4.6.0
+    rev: v5.0.0
     hooks:
       - id: check-executables-have-shebangs
         stages: [manual]
@@ -33,7 +33,7 @@ repos:
     hooks:
       - id: prettier
   - repo: https://github.com/cdce8p/python-typing-update
-    rev: v0.6.0
+    rev: v0.7.0
     hooks:
       # Run `python-typing-update` hook manually from time to time
       # to update python typing syntax.
@@ -46,7 +46,7 @@ repos:
           - --force
           - --keep-updates
   - repo: https://github.com/pre-commit/mirrors-mypy
-    rev: v1.10.0
+    rev: v1.13.0
     hooks:
       - id: mypy
         args: [--strict, --ignore-missing-imports]

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

@@ -1,9 +1,10 @@
 Metadata-Version: 2.1
 Name: myelectricaldatapy
-Version: 2.2.2
+Version: 2.2.4
 Summary: Fetch Linky data from myelectricaldata.fr
 Author-email: Cyr-ius <cyr-ius@ipocus.net>
 License: GPL-3
+Project-URL: Homepage, https://github.com/cyr-ius/myelectricaldatapy
 Keywords: enedis,linky,async,myelectricaldata
 Classifier: Programming Language :: Python
 Classifier: Development Status :: 5 - Production/Stable

myelectricaldatapy-2.2.4/_secrets.yaml

@@ -0,0 +1,3 @@
+---
+PDL: "0123456789"
+TOKEN: "xxxxxxxxxxxxxxxxxxxxxxxx"

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

@@ -52,7 +52,10 @@ async def async_main() -> None:
     except EnedisException as error:
         logger.error(error)
 
+    await myPdl.async_close()
+
 
 if __name__ == "__main__":
-    loop = asyncio.get_event_loop()
-    loop.run_until_complete(async_main())
+    loop = asyncio.new_event_loop()
+    asyncio.set_event_loop(loop)
+    asyncio.run(async_main())

{myelectricaldatapy-2.2.2 → myelectricaldatapy-2.2.4}/myelectricaldatapy/auth.py

@@ -52,9 +52,10 @@ class EnedisAuth:
         except ClientResponseError:
             message = contents.decode("utf8")
             if "application/json" in response.headers.get("Content-Type", ""):
+                msg = json.loads(message)
                 if response.status == 409:
-                    raise LimitReached(json.loads(message))
-                raise EnedisException(json.loads(message))
+                    raise LimitReached(msg.get("detail", msg))
+                raise EnedisException(msg.get("detail", msg))
             raise EnedisException({"message": message})
         except (ClientError, socket.gaierror) as error:
             raise HttpRequestError(

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

@@ -20,12 +20,10 @@ class Enedis:
     """Get data of pdl."""
 
     def __init__(
-        self,
-        token: str,
-        session: ClientSession = ClientSession(),
-        timeout: int = TIMEOUT,
+        self, token: str, session: ClientSession | None = None, timeout: int = TIMEOUT
     ) -> None:
         """Initialize."""
+        session = session or ClientSession()
         self.auth = EnedisAuth(session, token, timeout)
         self.async_request = self.auth.async_request
         self.offpeaks: list[str] = []

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

@@ -84,16 +84,24 @@ CUM_SCH = vol.Schema(
 
 
 class EnedisByPDL:
-    """PDL class."""
+    """Enedis by PDL class.
+
+    This class allows you to obtain information specific to a connection point.
+
+    The "set_collect" function allows you to specify the collection parameters from Enedis
+    The "async_update_collects" function allows you to perform the calculations
+    The result is displayed in the property: stats
+    y"""
 
     def __init__(
         self,
         pdl: str,
         token: str,
-        session: ClientSession = ClientSession(),
+        session: ClientSession | None = None,
         timeout: int = TIMEOUT,
     ) -> None:
         """Initialize."""
+        session = ClientSession() if session is None else session
         self._api: Enedis = Enedis(token, session, timeout)
         self.pdl = pdl
         self._connected: bool = False
@@ -290,7 +298,25 @@ class EnedisByPDL:
         cum_value: dict[str, Any] | None = None,
         cum_price: dict[str, Any] | None = None,
     ) -> None:
-        """Set parameters for data collect."""
+        """Set parameters for data collect.
+
+        service: "daily_production" or "daily_consumption" or "detail_production" or "detail_consumption"
+        start: date of begin to collect data
+        end: date of end to collect data
+        intervals: offpeak hours range - ex: [("01:00","05:00"),("12:00","14:00")]
+        prices: price for standard interval and offpeak interval
+            ex: {
+                    "standard": [float], "offpeak": [float]
+                }
+            ex: {
+                    "standard":{"blue":[float],"white":[float],"red":[float]},
+                    "offpeak":{"blue":[float],"white":[float],"red":[float]}
+                }
+        cum_sum: price of start
+            ex: {"standard":[float], "offpeak":[float]}
+        cum_price:
+            ex: {"standard":[float], "offpeak":[float]}
+        """
         funcs: dict[str, Callable[..., Any]] = {
             DAILY_PROD: self._api.async_get_daily_production,
             DETAIL_PROD: self._api.async_get_details_production,
@@ -314,7 +340,11 @@ class EnedisByPDL:
         self.has_parameters = True
 
     async def async_update_collects(self) -> None:
-        """Update data to collect."""
+        """Update data to collect.
+
+        It is necessary to value the initial data via the method: set_collects.
+        The execution of this method updates the property: stats.
+        """
         checked = True
         self.has_collected = False
         for mode, attr in self._params.items():
@@ -328,6 +358,8 @@ class EnedisByPDL:
                 checked = False
                 _LOGGER.error(error)
             else:
+                if dataset is None:
+                    raise EnedisException("Data collection is empty")
                 data = dataset.get("meter_reading", {}).get("interval_reading", [])
                 if len(data) == 0:
                     raise EnedisException("Data collection is empty")
@@ -338,3 +370,12 @@ class EnedisByPDL:
                 self.tempo = await self._api.async_get_tempo(start, end)
 
         self.has_collected = checked
+
+    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._api.auth.session:
+            await self._api.auth.session.close()

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

@@ -1,9 +1,10 @@
 Metadata-Version: 2.1
 Name: myelectricaldatapy
-Version: 2.2.2
+Version: 2.2.4
 Summary: Fetch Linky data from myelectricaldata.fr
 Author-email: Cyr-ius <cyr-ius@ipocus.net>
 License: GPL-3
+Project-URL: Homepage, https://github.com/cyr-ius/myelectricaldatapy
 Keywords: enedis,linky,async,myelectricaldata
 Classifier: Programming Language :: Python
 Classifier: Development Status :: 5 - Production/Stable

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

@@ -4,14 +4,15 @@
 LICENSE
 MANIFEST.in
 README.md
+_secrets.yaml
 example.py
 pyproject.toml
 requirements-dev.txt
 requirements.txt
 .github/dependabot.yml
 .github/workflows/auto-approve.yml
-.github/workflows/lint.yml
-.github/workflows/pythonpublish.yml
+.github/workflows/python-lint.yml
+.github/workflows/python-publish.yml
 .github/workflows/release.yml
 .vscode/settings.json
 myelectricaldatapy/__init__.py

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name        = "myelectricaldatapy"
-dynamic = ["version"]
+dynamic     = ["version"]
 license     = {text = "GPL-3"}
 description = "Fetch Linky data from myelectricaldata.fr"
 readme      = "README.md"
@@ -31,8 +31,14 @@ dependencies    = [
     "voluptuous>=0.13.1",
 ]
 
+[project.urls]
+Homepage = "https://github.com/cyr-ius/myelectricaldatapy"
+
 [tool.setuptools_scm]
 
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+
 [tool.ruff.lint.flake8-pytest-style]
 fixture-parentheses = false
 

{myelectricaldatapy-2.2.2 → myelectricaldatapy-2.2.4}/requirements-dev.txt

@@ -4,10 +4,11 @@
 codespell
 mypy
 pre-commit
-python-typing-update
-ruff
-yamllint
-types-requests
 pytest
 pytest-asyncio
+python-typing-update
+ruff
 setuptools_scm
+types-requests
+yamllint
+freezegun

{myelectricaldatapy-2.2.2 → myelectricaldatapy-2.2.4}/tests/__init__.py

@@ -1,5 +1,7 @@
 """Tests for myelectricaldata."""
 
+from __future__ import annotations
+
 from pathlib import Path
 
 

{myelectricaldatapy-2.2.2 → myelectricaldatapy-2.2.4}/tests/conftest.py

@@ -1,5 +1,7 @@
 """Test helpers for MyElectricalData."""
 
+from __future__ import annotations
+
 from collections.abc import Generator
 import json
 from typing import Any
@@ -7,9 +9,7 @@ from unittest.mock import AsyncMock, patch
 
 import pytest
 
-import myelectricaldatapy
-
-from . import load_fixture
+from tests import load_fixture
 
 
 @pytest.fixture(name="mock_detail")
@@ -66,35 +66,37 @@ def mock_enedis(
     """Mock a successful connection."""
 
     with (
-        patch.object(
-            myelectricaldatapy.Enedis,
-            "async_get_daily_consumption",
+        patch(
+            "myelectricaldatapy.Enedis.async_get_daily_consumption",
             return_value=mock_daily,
         ),
-        patch.object(
-            myelectricaldatapy.Enedis,
-            "async_get_daily_production",
+        patch(
+            "myelectricaldatapy.Enedis.async_get_daily_production",
             return_value=mock_daily,
         ),
-        patch.object(
-            myelectricaldatapy.Enedis,
-            "async_get_details_consumption",
+        patch(
+            "myelectricaldatapy.Enedis.async_get_details_consumption",
             return_value=mock_detail,
         ),
-        patch.object(
-            myelectricaldatapy.Enedis, "async_valid_access", return_value=mock_access
+        patch(
+            "myelectricaldatapy.Enedis.async_valid_access",
+            return_value=mock_access,
         ),
-        patch.object(
-            myelectricaldatapy.Enedis, "async_get_contract", return_value=mock_contract
+        patch(
+            "myelectricaldatapy.Enedis.async_get_contract",
+            return_value=mock_contract,
         ),
-        patch.object(
-            myelectricaldatapy.Enedis, "async_get_address", return_value=mock_address
+        patch(
+            "myelectricaldatapy.Enedis.async_get_address",
+            return_value=mock_address,
         ),
-        patch.object(
-            myelectricaldatapy.Enedis, "async_get_tempo", return_value=mock_tempo
+        patch(
+            "myelectricaldatapy.Enedis.async_get_tempo",
+            return_value=mock_tempo,
         ),
-        patch.object(
-            myelectricaldatapy.Enedis, "async_get_ecowatt", return_value=mock_ecowatt
+        patch(
+            "myelectricaldatapy.Enedis.async_get_ecowatt",
+            return_value=mock_ecowatt,
         ),
     ):
         yield AsyncMock()
@@ -106,20 +108,25 @@ def mock_base(
 ) -> Generator[AsyncMock, None, None]:
     """Mock a successful connection."""
     with (
-        patch.object(
-            myelectricaldatapy.Enedis, "async_valid_access", return_value=mock_access
+        patch(
+            "myelectricaldatapy.Enedis.async_valid_access",
+            return_value=mock_access,
         ),
-        patch.object(
-            myelectricaldatapy.Enedis, "async_get_contract", return_value=mock_contract
+        patch(
+            "myelectricaldatapy.Enedis.async_get_contract",
+            return_value=mock_contract,
         ),
-        patch.object(
-            myelectricaldatapy.Enedis, "async_get_address", return_value=mock_address
+        patch(
+            "myelectricaldatapy.Enedis.async_get_address",
+            return_value=mock_address,
         ),
-        patch.object(
-            myelectricaldatapy.Enedis, "async_get_tempo", return_value=mock_tempo
+        patch(
+            "myelectricaldatapy.Enedis.async_get_tempo",
+            return_value=mock_tempo,
         ),
-        patch.object(
-            myelectricaldatapy.Enedis, "async_get_ecowatt", return_value=mock_ecowatt
+        patch(
+            "myelectricaldatapy.Enedis.async_get_ecowatt",
+            return_value=mock_ecowatt,
         ),
     ):
         yield AsyncMock()

{myelectricaldatapy-2.2.2 → myelectricaldatapy-2.2.4}/tests/test_analytics.py

@@ -6,6 +6,7 @@ from datetime import datetime as dt
 from typing import Any
 from unittest.mock import Mock, patch
 
+from aiohttp import ClientSession
 from freezegun import freeze_time
 import pytest
 
@@ -16,10 +17,9 @@ from .consts import PDL, TOKEN
 
 
 @freeze_time("2023-03-01")
-@pytest.mark.asyncio
 async def test_compute(mock_enedis: Mock) -> None:  # pylint: disable=unused-argument
     """Test standard."""
-    api = EnedisByPDL(pdl=PDL, token=TOKEN)
+    api = EnedisByPDL(pdl=PDL, token=TOKEN, session=ClientSession())
     api.set_collects("consumption_load_curve")
     await api.async_update()
     resultat = api.stats["consumption"]
@@ -27,7 +27,7 @@ async def test_compute(mock_enedis: Mock) -> None:  # pylint: disable=unused-arg
     assert resultat[0]["notes"] == "standard"
     assert resultat[0]["value"] == 1.296
 
-    api = EnedisByPDL(pdl=PDL, token=TOKEN)
+    api = EnedisByPDL(pdl=PDL, token=TOKEN, session=ClientSession())
     api.set_collects("daily_consumption")
     await api.async_update()
     resultat = api.stats["consumption"]
@@ -37,7 +37,6 @@ async def test_compute(mock_enedis: Mock) -> None:  # pylint: disable=unused-arg
 
 
 @freeze_time("2023-03-01")
-@pytest.mark.asyncio
 async def test_without_offpeak(
     mock_enedis: Mock,
 ) -> None:  # pylint: disable=unused-argument
@@ -45,7 +44,7 @@ async def test_without_offpeak(
     await mock_enedis()
     prices: dict[str, Any] = {"standard": {"price": 0.17}}
     # Test standard price
-    api = EnedisByPDL(pdl=PDL, token=TOKEN)
+    api = EnedisByPDL(pdl=PDL, token=TOKEN, session=ClientSession())
     api.set_collects("consumption_load_curve", prices=prices)
     await api.async_update_collects()
     resultat = api.stats["consumption"]
@@ -62,14 +61,13 @@ async def test_without_offpeak(
 
 
 @freeze_time("2023-03-01")
-@pytest.mark.asyncio
 async def test_with_offpeak(
     mock_enedis: Mock,  # pylint: disable=unused-argument
 ) -> None:
     """Test without offpeak , with price."""
     intervals = [("01:30:00", "08:00:00"), ("12:30:00", "14:00:00")]
     prices: dict[str, Any] = {"standard": {"price": 0.17}, "offpeak": {"price": 0.18}}
-    api = EnedisByPDL(pdl=PDL, token=TOKEN)
+    api = EnedisByPDL(pdl=PDL, token=TOKEN, session=ClientSession())
     api.set_collects("consumption_load_curve", prices=prices, intervals=intervals)
     await api.async_update_collects()
     resultat = api.stats["consumption"]
@@ -81,7 +79,7 @@ async def test_with_offpeak(
     print(resultat)
 
     # Without cums
-    api = EnedisByPDL(pdl=PDL, token=TOKEN)
+    api = EnedisByPDL(pdl=PDL, token=TOKEN, session=ClientSession())
     api.set_collects("consumption_load_curve", prices=prices, intervals=intervals)
     await api.async_update_collects()
     resultat = api.stats["consumption"]
@@ -93,7 +91,7 @@ async def test_with_offpeak(
     print(resultat)
 
     # Without price
-    api = EnedisByPDL(pdl=PDL, token=TOKEN)
+    api = EnedisByPDL(pdl=PDL, token=TOKEN, session=ClientSession())
     api.set_collects("consumption_load_curve", intervals=intervals)
     await api.async_update_collects()
     resultat = api.stats["consumption"]
@@ -102,7 +100,7 @@ async def test_with_offpeak(
     print(resultat)
 
     # Daily
-    api = EnedisByPDL(pdl=PDL, token=TOKEN)
+    api = EnedisByPDL(pdl=PDL, token=TOKEN, session=ClientSession())
     api.set_collects("daily_consumption", prices=prices, intervals=intervals)
     await api.async_update_collects()
     resultat = api.stats["consumption"]
@@ -112,14 +110,13 @@ async def test_with_offpeak(
 
 
 @freeze_time("2023-03-01")
-@pytest.mark.asyncio
 async def test_daily_with_offpeak(
     mock_enedis: Mock,  # pylint: disable=unused-argument
 ) -> None:
     """Test daily with offpeak."""
     prices: dict[str, Any] = {"standard": {"price": 0.17}, "offpeak": {"price": 0.18}}
     intervals = [("01:30:00", "08:00:00"), ("12:30:00", "14:00:00")]
-    api = EnedisByPDL(pdl=PDL, token=TOKEN)
+    api = EnedisByPDL(pdl=PDL, token=TOKEN, session=ClientSession())
     api.set_collects("daily_consumption", prices=prices, intervals=intervals)
     await api.async_update_collects()
     resultat = api.stats["consumption"]
@@ -128,7 +125,6 @@ async def test_daily_with_offpeak(
 
 
 @freeze_time("2023-03-01")
-@pytest.mark.asyncio
 async def test_compare(mock_enedis: Mock) -> None:  # pylint: disable=unused-argument
     """Test details compare."""
     prices: dict[str, Any] = {"standard": {"price": 0.17}, "offpeak": {"price": 0.18}}
@@ -141,7 +137,7 @@ async def test_compare(mock_enedis: Mock) -> None:  # pylint: disable=unused-arg
         "offpeak": {"sum_price": 0},
     }
     intervals = [("01:30:00", "08:00:00"), ("12:30:00", "14:00:00")]
-    api = EnedisByPDL(pdl=PDL, token=TOKEN)
+    api = EnedisByPDL(pdl=PDL, token=TOKEN, session=ClientSession())
     api.set_collects(
         "consumption_load_curve",
         prices=prices,
@@ -198,14 +194,13 @@ async def test_compare(mock_enedis: Mock) -> None:  # pylint: disable=unused-arg
 
 
 @freeze_time("2023-03-01")
-@pytest.mark.asyncio
 async def test_cumsums(mock_enedis: Mock) -> None:  # pylint: disable=unused-argument
     """Test cumulative summary."""
     prices: dict[str, Any] = {"standard": {"price": 0.17}, "offpeak": {"price": 0.18}}
     cumsum_value: dict[str, Any] = {"standard": 100, "offpeak": 1000}
     cumsum_price: dict[str, Any] = {"standard": 50, "offpeak": 75}
     intervals = [("01:30:00", "08:00:00"), ("12:30:00", "14:00:00")]
-    api = EnedisByPDL(pdl=PDL, token=TOKEN)
+    api = EnedisByPDL(pdl=PDL, token=TOKEN, session=ClientSession())
     api.set_collects(
         "consumption_load_curve",
         start=dt.strptime("2023-03-01", "%Y-%m-%d"),
@@ -226,12 +221,11 @@ async def test_cumsums(mock_enedis: Mock) -> None:  # pylint: disable=unused-arg
 
 
 @freeze_time("2023-03-01")
-@pytest.mark.asyncio
 async def test_extra_date(mock_base: Mock, mock_detail) -> None:  # pylint: disable=unused-argument
     """Test cumulative summary."""
     prices: dict[str, Any] = {"standard": {"price": 0.17}, "offpeak": {"price": 0.18}}
     intervals = [("01:30:00", "08:00:00"), ("12:30:00", "14:00:00")]
-    api = EnedisByPDL(pdl=PDL, token=TOKEN)
+    api = EnedisByPDL(pdl=PDL, token=TOKEN, session=ClientSession())
     api.set_collects(
         "consumption_load_curve",
         start=dt.strptime("2023-03-01", "%Y-%m-%d"),
@@ -264,7 +258,6 @@ async def test_extra_date(mock_base: Mock, mock_detail) -> None:  # pylint: disa
 
 
 @freeze_time("2023-3-1")
-@pytest.mark.asyncio
 async def test_tempo(mock_enedis: Mock) -> None:  # pylint: disable=unused-argument
     """Test tempo pricings."""
     prices: dict[str, Any] = {
@@ -282,7 +275,7 @@ async def test_tempo(mock_enedis: Mock) -> None:  # pylint: disable=unused-argum
     cumsum_value: dict[str, Any] = {"standard": 100, "offpeak": 1000}
     cumsum_price: dict[str, Any] = {"standard": 50, "offpeak": 75}
     intervals = [("01:30:00", "08:00:00"), ("12:30:00", "14:00:00")]
-    api = EnedisByPDL(pdl=PDL, token=TOKEN)
+    api = EnedisByPDL(pdl=PDL, token=TOKEN, session=ClientSession())
     api.set_collects(
         "consumption_load_curve",
         prices=prices,
@@ -300,7 +293,7 @@ async def test_tempo(mock_enedis: Mock) -> None:  # pylint: disable=unused-argum
     assert api.tempo_day == "blue"
 
     # Check Daily -> compute not possible.
-    api = EnedisByPDL(pdl=PDL, token=TOKEN)
+    api = EnedisByPDL(pdl=PDL, token=TOKEN, session=ClientSession())
     api.set_collects("daily_production", prices=prices, intervals=intervals)
     await api.async_update_collects()
     resultat = api.stats.get("production")
@@ -308,21 +301,20 @@ async def test_tempo(mock_enedis: Mock) -> None:  # pylint: disable=unused-argum
 
 
 @freeze_time("2023-03-01")
-@pytest.mark.asyncio
 async def test_standard_offpeak_cumsum(
     mock_enedis: Mock,  # pylint: disable=unused-argument
 ) -> None:
     """Test with offpeak and cumsum."""
     prices: dict[str, Any] = {"standard": {"price": 0.5}, "offpeak": {"price": 1}}
     intervals = [("01:30:00", "08:00:00"), ("12:30:00", "14:00:00")]
-    api = EnedisByPDL(pdl=PDL, token=TOKEN)
+    api = EnedisByPDL(pdl=PDL, token=TOKEN, session=ClientSession())
     api.set_collects("consumption_load_curve", prices=prices, intervals=intervals)
     await api.async_update_collects()
     resultat = api.stats["consumption"]
     assert resultat[0]["value"] == 1.079
 
     # Test daily data , check ignore intervals.
-    api = EnedisByPDL(pdl=PDL, token=TOKEN)
+    api = EnedisByPDL(pdl=PDL, token=TOKEN, session=ClientSession())
     api.set_collects("daily_consumption", prices=prices, intervals=intervals)
     await api.async_update_collects()
     resultat = api.stats["consumption"]
@@ -332,7 +324,7 @@ async def test_standard_offpeak_cumsum(
 @pytest.mark.asyncio
 async def test_start_date(mock_enedis: Mock) -> None:  # pylint: disable=unused-argument
     """Test with start_date."""
-    api = EnedisByPDL(pdl=PDL, token=TOKEN)
+    api = EnedisByPDL(pdl=PDL, token=TOKEN, session=ClientSession())
     api.set_collects(
         "consumption_load_curve", start=dt.strptime("2023-3-7", "%Y-%m-%d")
     )
@@ -349,13 +341,12 @@ async def test_start_date(mock_enedis: Mock) -> None:  # pylint: disable=unused-
 
 
 @freeze_time("2023-3-1")
-@pytest.mark.asyncio
 async def test_twice_call(
     mock_enedis: Mock,  # pylint: disable=unused-argument
 ) -> None:
     """Tests raise exception."""
     intervals = [("01:30:00", "08:00:00"), ("12:30:00", "14:00:00")]
-    api = EnedisByPDL(pdl=PDL, token=TOKEN)
+    api = EnedisByPDL(pdl=PDL, token=TOKEN, session=ClientSession())
     api.set_collects("consumption_load_curve", intervals=intervals)
     api.set_collects("daily_production")
     await api.async_update()

{myelectricaldatapy-2.2.2 → myelectricaldatapy-2.2.4}/tests/test_load_data.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 from datetime import datetime as dt
 from unittest.mock import Mock, patch
 
+from aiohttp import ClientSession
 from freezegun import freeze_time
 import pytest
 
@@ -15,40 +16,37 @@ from .consts import PDL, TOKEN
 
 
 @freeze_time("2023-01-23")
-@pytest.mark.asyncio
 async def test_ecowatt(mock_enedis: Mock) -> None:  # pylint: disable=unused-argument
     """Test get ecowatt."""
-    api = Enedis(token=TOKEN)
+    api = Enedis(token=TOKEN, session=ClientSession())
     resultat = await api.async_get_ecowatt()
     assert resultat["2023-01-22"]["value"] == 1
 
-    mypdl = EnedisByPDL(pdl=PDL, token=TOKEN)
+    mypdl = EnedisByPDL(pdl=PDL, token=TOKEN, session=ClientSession())
     mypdl.ecowatt_subscription(True)
     await mypdl.async_update()
     assert mypdl.ecowatt_day["message"] == "Pas d’alerte."
 
 
-@pytest.mark.asyncio
 @pytest.mark.parametrize("mock_ecowatt", [True], indirect=True)
 async def test_invalid_ecowatt(mock_enedis: Mock, mock_ecowatt: bool) -> None:
     """Test ecowatt."""
     with patch.object(
         myelectricaldatapy.Enedis, "async_get_ecowatt", return_value=mock_ecowatt
     ):
-        api = Enedis(token=TOKEN)
+        api = Enedis(token=TOKEN, session=ClientSession())
         resultat = await api.async_get_ecowatt()
         assert resultat.get("2023-01-22") is None
 
 
 @freeze_time("2023-3-3")
-@pytest.mark.asyncio
 async def test_tempoday(mock_enedis: Mock) -> None:  # pylint: disable=unused-argument
     """Test get tempo day."""
-    api = Enedis(token=TOKEN)
+    api = Enedis(token=TOKEN, session=ClientSession())
     resultat = await api.async_get_tempo()
     assert resultat["2023-3-1"] == "blue"
 
-    mypdl = EnedisByPDL(pdl=PDL, token=TOKEN)
+    mypdl = EnedisByPDL(pdl=PDL, token=TOKEN, session=ClientSession())
     mypdl.set_collects("consumption_load_curve")
     mypdl.tempo_subscription(True)
     await mypdl.async_update()
@@ -56,10 +54,9 @@ async def test_tempoday(mock_enedis: Mock) -> None:  # pylint: disable=unused-ar
     assert mypdl.tempo_day == "blue"
 
 
-@pytest.mark.asyncio
 async def test_valid_access(mock_enedis: Mock) -> None:  # pylint: disable=unused-argument
     """Test access."""
-    api = Enedis(token=TOKEN)
+    api = Enedis(token=TOKEN, session=ClientSession())
     resultat = await api.async_valid_access(PDL)
     assert resultat["valid"] is True
 
@@ -67,7 +64,6 @@ async def test_valid_access(mock_enedis: Mock) -> None:  # pylint: disable=unuse
     assert resultat is True
 
 
-@pytest.mark.asyncio
 @pytest.mark.parametrize("mock_access", [True], indirect=True)
 async def test_invalid_access(
     mock_enedis: Mock,
@@ -77,18 +73,17 @@ async def test_invalid_access(
     with patch.object(
         myelectricaldatapy.Enedis, "async_valid_access", return_value=mock_access
     ):
-        api = Enedis(token=TOKEN)
+        api = Enedis(token=TOKEN, session=ClientSession())
         resultat = await api.async_valid_access(PDL)
         assert resultat["quota_reached"] is True
 
 
-@pytest.mark.asyncio
 async def test_fetch_data(mock_detail) -> None:
     """Test fetch data."""
     with patch.object(
         myelectricaldatapy.auth.EnedisAuth, "async_request", return_value=mock_detail
     ):
-        api = Enedis(token=TOKEN)
+        api = Enedis(token=TOKEN, session=ClientSession())
         resultat = await api.async_fetch_datas(
             service="comsumption_load_curve",
             pdl=PDL,
@@ -101,7 +96,6 @@ async def test_fetch_data(mock_detail) -> None:
         )
 
 
-@pytest.mark.asyncio
 async def test_force_refresh(
     mock_enedis: Mock,  # pylint: disable=unused-argument
 ) -> None:
@@ -115,7 +109,7 @@ async def test_force_refresh(
     with patch.object(
         myelectricaldatapy.Enedis, "async_valid_access", return_value=access
     ):
-        api = EnedisByPDL(pdl=PDL, token=TOKEN)
+        api = EnedisByPDL(pdl=PDL, token=TOKEN, session=ClientSession())
         api.set_collects("consumption_load_curve")
         await api.async_update()
         save_refresh = api.last_refresh
@@ -125,7 +119,6 @@ async def test_force_refresh(
         assert api.last_refresh != save_refresh
 
 
-@pytest.mark.asyncio
 async def test_exception(
     mock_enedis: Mock,  # pylint: disable=unused-argument
 ) -> None:
@@ -135,7 +128,7 @@ async def test_exception(
         "async_valid_access",
         side_effect=LimitReached(500, {"detail": "Limit reached"}),
     ):
-        api = EnedisByPDL(pdl=PDL, token=TOKEN)
+        api = EnedisByPDL(pdl=PDL, token=TOKEN, session=ClientSession())
         api.set_collects("consumption_load_curve")
         try:
             await api.async_update()
@@ -149,7 +142,7 @@ async def test_exception(
         "async_get_details_consumption",
         side_effect=LimitReached(500, {"detail": "Limit reached"}),
     ):
-        api = EnedisByPDL(pdl=PDL, token=TOKEN)
+        api = EnedisByPDL(pdl=PDL, token=TOKEN, session=ClientSession())
         api.set_collects("consumption_load_curve")
         try:
             await api.async_update()
@@ -163,7 +156,7 @@ async def test_exception(
         "async_get_details_consumption",
         side_effect=EnedisException(500, {"detail": "Error"}),
     ):
-        api = EnedisByPDL(pdl=PDL, token=TOKEN)
+        api = EnedisByPDL(pdl=PDL, token=TOKEN, session=ClientSession())
         api.set_collects("consumption_load_curve")
         api.set_collects("daily_production")
         try: