myelectricaldatapy 2.4.8__tar.gz → 2.5.0__tar.gz

{myelectricaldatapy-2.4.8 → myelectricaldatapy-2.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: myelectricaldatapy
-Version: 2.4.8
+Version: 2.5.0
 Summary: Fetch Linky data from myelectricaldata.fr
 Author-email: Cyr-ius <cyr-ius@ipocus.net>
 License-Expression: GPL-3.0-or-later

{myelectricaldatapy-2.4.8 → myelectricaldatapy-2.5.0}/myelectricaldatapy/api.py

@@ -11,7 +11,7 @@ from pydantic import BaseModel, ValidationError
 
 from .auth import EnedisAuth
 from .const import DAILY_CONSUM, DAILY_PROD, DETAIL_CONSUM, DETAIL_PROD
-from .exceptions import EnedisException, PayloadError
+from .exceptions import EnedisException, LimitReached, PayloadError
 from .types import (
     AccessResponse,
     Contract,
@@ -275,6 +275,16 @@ class Enedis:
                         DataCollect,
                         await self.async_fetch_datas(service, pdl, start, end),
                     )
+            except LimitReached as error:
+                # Quota/throttling errors apply to every remaining chunk too,
+                # so let the caller see them (e.g. to back off until
+                # ThrottlingError.next_access_time) instead of swallowing them.
+                # Whatever chunks already succeeded this call are attached to
+                # the exception so the caller can still persist that partial
+                # progress instead of discarding it and re-requesting the
+                # same full range (and hitting the same quota wall) next time.
+                error.partial_data = data
+                raise
             except EnedisException as error:
                 raise_error = True
                 logger.error(error)

{myelectricaldatapy-2.4.8 → myelectricaldatapy-2.5.0}/myelectricaldatapy/exceptions.py

@@ -8,7 +8,14 @@ class EnedisException(Exception):
 
 
 class LimitReached(EnedisException):
-    """Limit reached exception."""
+    """Limit reached exception.
+
+    ``partial_data`` optionally carries whatever a paginated fetch (e.g.
+    ``Enedis._async_get_details``) already collected before hitting the
+    limit, so callers can persist that progress instead of discarding it.
+    """
+
+    partial_data: Any = None
 
 
 class ThrottlingError(LimitReached):

{myelectricaldatapy-2.4.8 → myelectricaldatapy-2.5.0}/myelectricaldatapy/mypdl.py

@@ -386,7 +386,26 @@ class EnedisByPDL:
             end = attr[ATTR_END]
             fn = attr[ATTR_FN]
 
-            dataset: DataCollect | None = await fn(self.pdl, start, end)
+            try:
+                dataset: DataCollect | None = await fn(self.pdl, start, end)
+            except LimitReached as error:
+                # A paginated (detail) fetch may have already collected some
+                # chunks before hitting the quota/throttle wall. Persist that
+                # partial progress -- same as a normal successful fetch --
+                # instead of losing it and re-requesting the whole range
+                # (and the same wall) on the next cycle.
+                partial = error.partial_data
+                readings = partial.meter_reading.interval_reading if partial else []
+                if readings:
+                    self._params[mode].update(
+                        {
+                            "data": [
+                                reading.model_dump(exclude_none=True)
+                                for reading in readings
+                            ]
+                        }
+                    )
+                raise
 
             if dataset is None:
                 raise EnedisException("Data collection is empty")

{myelectricaldatapy-2.4.8 → myelectricaldatapy-2.5.0}/myelectricaldatapy.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: myelectricaldatapy
-Version: 2.4.8
+Version: 2.5.0
 Summary: Fetch Linky data from myelectricaldata.fr
 Author-email: Cyr-ius <cyr-ius@ipocus.net>
 License-Expression: GPL-3.0-or-later

myelectricaldatapy-2.5.0/myelectricaldatapy.egg-info/scm_version.json

@@ -0,0 +1,8 @@
+{
+  "tag": "2.5.0",
+  "distance": 0,
+  "node": "g04b14d4dd379114e4a869f878e146c5ed2765401",
+  "dirty": false,
+  "branch": "HEAD",
+  "node_date": "2026-09-26"
+}

{myelectricaldatapy-2.4.8 → myelectricaldatapy-2.5.0}/tests/test_load_data.py

@@ -16,7 +16,9 @@ from myelectricaldatapy import (
     EnedisException,
     LimitReached,
     Subscription,
+    ThrottlingError,
 )
+from myelectricaldatapy.const import ATTR_CONSUM
 from myelectricaldatapy.tz import LOCAL_TIMEZONE
 
 from .consts import PDL, TOKEN
@@ -249,3 +251,101 @@ async def test_exception(
             pass
         assert api.last_access is not None
         assert api.access.valid is True
+
+
+async def test_details_throttling_propagates(
+    mock_access,
+    session,
+) -> None:
+    """A ThrottlingError raised while fetching a details chunk must reach the caller.
+
+    Regression test: ``Enedis._async_get_details`` used to catch every
+    ``EnedisException`` per 7-day chunk and only log it, so callers (and
+    their ``next_access_time`` back-off logic) never saw the throttling.
+    Deliberately bypasses the ``mock_enedis`` fixture, which stubs
+    ``async_get_details_consumption`` wholesale and would skip the internal
+    per-chunk loop this test targets.
+    """
+    throttling = ThrottlingError(
+        "Throttled", next_access_time="2026-Sep-05 16:00:00+0000 UTC"
+    )
+    with (
+        patch.object(
+            myelectricaldatapy.Enedis,
+            "async_valid_access",
+            return_value=mock_access,
+        ),
+        patch.object(
+            myelectricaldatapy.Enedis,
+            "async_fetch_datas",
+            side_effect=throttling,
+        ),
+    ):
+        api = EnedisByPDL(pdl=PDL, token=TOKEN, session=session)
+        api.set_data_fetch(DETAIL_CONSUM)
+        with pytest.raises(ThrottlingError) as exc_info:
+            await api.async_update()
+        assert exc_info.value.next_access_time == "2026-Sep-05 16:00:00+0000 UTC"
+
+
+async def test_details_partial_progress_kept_on_throttle(
+    mock_access,
+    session,
+) -> None:
+    """Chunks fetched before a mid-range throttle must not be discarded.
+
+    Regression test: once ``_async_get_details`` correctly re-raises on a
+    throttled chunk (see ``test_details_throttling_propagates``), it still
+    discarded whatever earlier 7-day chunks it had already collected in the
+    same call, forcing the next cycle to re-request the whole range -- and
+    hit the same quota wall again -- instead of making forward progress.
+    """
+    first_chunk = {
+        "meter_reading": {
+            "interval_reading": [
+                {"value": "1000", "date": "2023-01-01 00:30:00"},
+            ]
+        }
+    }
+    throttling = ThrottlingError(
+        "Throttled", next_access_time="2026-Sep-05 16:00:00+0000 UTC"
+    )
+
+    with (
+        patch.object(
+            myelectricaldatapy.Enedis,
+            "async_valid_access",
+            return_value=mock_access,
+        ),
+        # Contract/address lookups also go through `async_fetch_datas`; stub
+        # them directly so they don't consume the chunk side_effect below.
+        patch.object(
+            myelectricaldatapy.Enedis, "async_get_contract", return_value=None
+        ),
+        patch.object(myelectricaldatapy.Enedis, "async_get_address", return_value=None),
+        patch.object(
+            myelectricaldatapy.Enedis,
+            "async_fetch_datas",
+            side_effect=[first_chunk, throttling],
+        ),
+    ):
+        api = EnedisByPDL(pdl=PDL, token=TOKEN, session=session)
+        # 14 days split into 7-day chunks: the first succeeds, the second
+        # (and last) throttles.
+        api.set_data_fetch(
+            DETAIL_CONSUM,
+            start=dt.strptime("2023-01-01", "%Y-%m-%d").replace(tzinfo=LOCAL_TIMEZONE),
+            end=dt.strptime("2023-01-15", "%Y-%m-%d").replace(tzinfo=LOCAL_TIMEZONE),
+        )
+        with pytest.raises(ThrottlingError) as exc_info:
+            await api.async_update()
+
+    # The exception itself carries what was already collected...
+    partial = exc_info.value.partial_data
+    assert partial is not None
+    assert len(partial.meter_reading.interval_reading) == 1
+
+    # ...and it was persisted onto the fetch params, so `api.stats` (read by
+    # callers unconditionally, even after this exception) reflects it
+    # instead of coming back empty.
+    assert api._params[ATTR_CONSUM]["data"]

myelectricaldatapy-2.4.8/myelectricaldatapy.egg-info/scm_version.json

@@ -1,8 +0,0 @@
-{
-  "tag": "2.4.8",
-  "distance": 0,
-  "node": "g5cd9f3854591c39f30943a62859e23b7590d7a81",
-  "dirty": false,
-  "branch": "HEAD",
-  "node_date": "2026-09-05"
-}