myelectricaldatapy 2.4.5__tar.gz → 2.4.7__tar.gz

{myelectricaldatapy-2.4.5 → myelectricaldatapy-2.4.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: myelectricaldatapy
-Version: 2.4.5
+Version: 2.4.7
 Summary: Fetch Linky data from myelectricaldata.fr
 Author-email: Cyr-ius <cyr-ius@ipocus.net>
 License-Expression: GPL-3.0-or-later
@@ -120,7 +120,7 @@ Workflow:
 | `set_ecowatt_subscription(activate=False)`                                                                                                                                        | Enable Ecowatt retrieval                                                                              |
 | `set_maxpower_subscription(activate=False)`                                                                                                                                       | Enable max power retrieval                                                                            |
 | `async_update(force_refresh=False)`                                                                                                                                               | Refresh access, contract, address, tempo, ecowatt, collects                                           |
-| `async_update_collects()`                                                                                                                                                         | Refresh only the registered collects                                                                  |
+| `_async_fetch_data()`                                                                                                                                                             | Refresh only the registered collects                                                                  |
 | `stats`                                                                                                                                                                           | `dict` keyed by mode (`"consumption"` / `"production"`) with the computed analytics                   |
 | `access`, `contract`, `address`, `ecowatt`, `max_power`, `tempo`, `tempo_days`, `tempo_prices`                                                                                    | Last fetched models                                                                                   |
 | `is_connected`, `has_intervals`, `has_tempo_subscription`, `has_offpeak_hours_subscription`, `has_standard_subscription`, `has_ecowatt_subscription`, `has_maxpower_subscription` | Boolean state                                                                                         |

{myelectricaldatapy-2.4.5 → myelectricaldatapy-2.4.7}/README.md

@@ -85,7 +85,7 @@ Workflow:
 | `set_ecowatt_subscription(activate=False)`                                                                                                                                        | Enable Ecowatt retrieval                                                                              |
 | `set_maxpower_subscription(activate=False)`                                                                                                                                       | Enable max power retrieval                                                                            |
 | `async_update(force_refresh=False)`                                                                                                                                               | Refresh access, contract, address, tempo, ecowatt, collects                                           |
-| `async_update_collects()`                                                                                                                                                         | Refresh only the registered collects                                                                  |
+| `_async_fetch_data()`                                                                                                                                                             | Refresh only the registered collects                                                                  |
 | `stats`                                                                                                                                                                           | `dict` keyed by mode (`"consumption"` / `"production"`) with the computed analytics                   |
 | `access`, `contract`, `address`, `ecowatt`, `max_power`, `tempo`, `tempo_days`, `tempo_prices`                                                                                    | Last fetched models                                                                                   |
 | `is_connected`, `has_intervals`, `has_tempo_subscription`, `has_offpeak_hours_subscription`, `has_standard_subscription`, `has_ecowatt_subscription`, `has_maxpower_subscription` | Boolean state                                                                                         |

{myelectricaldatapy-2.4.5 → myelectricaldatapy-2.4.7}/myelectricaldatapy/mypdl.py

@@ -41,7 +41,6 @@ from .types import (
     Prices,
     Subscription,
     TempoDays,
-    TempoLabels,
     TempoMapping,
     UsagePoint,
 )
@@ -61,7 +60,7 @@ class EnedisByPDL:
     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 "_async_fetch_data" function allows you to perform the calculations
     The result is displayed in the property: stats
     y"""
 
@@ -88,6 +87,7 @@ class EnedisByPDL:
         self._connected: bool = False
         self._ecowatt_subs: bool = False
         self._maxpower_subs: bool = False
+        self._convert_kwh: bool = True
         self._params: dict[Mode, dict[str, Any]] = {}
         self.subscription: Subscription = subscription
         self.access: AccessResponse | None = None
@@ -101,7 +101,7 @@ class EnedisByPDL:
         self._update_lock = asyncio.Lock()
         self.last_refresh: date | None = None
         self.max_power: DataCollect | None = None
-        self.tempo: TempoMapping | None = None
+        self.tempo_historics: TempoMapping | None = None
         self.tempo_days: TempoDays | None = None
         self.tempo_prices: Prices | None = None
 
@@ -130,7 +130,7 @@ class EnedisByPDL:
 
     @property
     def has_standard_subscription(self) -> bool:
-        """Offpeak hours subscription status."""
+        """Standard subscription status."""
         return self.subscription == Subscription.STANDARD
 
     @property
@@ -150,10 +150,24 @@ class EnedisByPDL:
         return self.ecowatt.get(str_date) if self.ecowatt is not None else None
 
     @property
-    def tempo_day(self) -> TempoLabels | None:
+    def tempo(self) -> str | None:
         """Tempo day."""
         str_date = local_now().strftime("%Y-%m-%d")
-        return self.tempo.get(str_date) if self.tempo is not None else None
+        return (
+            self.tempo_historics.get(str_date)
+            if self.tempo_historics is not None
+            else None
+        )
+
+    @property
+    def tempo_next(self) -> str | None:
+        """Tempo next days."""
+        str_date = (local_now() + timedelta(days=1)).strftime("%Y-%m-%d")
+        return (
+            self.tempo_historics.get(str_date)
+            if self.tempo_historics is not None
+            else None
+        )
 
     @property
     def prod_prices(self) -> Prices | None:
@@ -173,7 +187,7 @@ class EnedisByPDL:
             data = params.get("data", [])
             analytics = EnedisAnalytics(data, timezone=self._timezone)
             resultat = analytics.get_data_analytics(
-                convertKwh=True,
+                convertKwh=self._convert_kwh,
                 intervals=params.get(ATTR_INTERVALS, []),
                 groupby=True,
                 summary=True,
@@ -181,7 +195,7 @@ class EnedisByPDL:
                 cum_value=_dump(params.get(ATTR_CUM_VALUE)),
                 cum_price=_dump(params.get(ATTR_CUM_PRICE)),
                 start_date=params.get(ATTR_START),
-                tempo=self.tempo,
+                tempo=self.tempo_historics,
             )
             stats.update({mode: resultat})
         return stats
@@ -202,6 +216,7 @@ class EnedisByPDL:
         self.ecowatt = None
         self.max_power = None
         self.has_collected = False
+        self.tempo_historics = None
         self.tempo_days = None
         self.tempo_prices = None
 
@@ -249,9 +264,10 @@ class EnedisByPDL:
                     self.pdl, start, end
                 )
 
-            if self.has_parameters and self.has_collected is False:
-                await self.async_update_collects()
-                self.last_refresh = local_now()
+            if self.tempo_historics is None and self.has_tempo_subscription:
+                start = local_now() - timedelta(days=1095)
+                end = local_now() + timedelta(days=1)
+                self.tempo_historics = await self._api.async_get_tempo(start, end)
 
             if self.tempo_prices is None and self.has_tempo_subscription:
                 self.tempo_prices = await self._api.async_get_tempo_prices()
@@ -259,6 +275,10 @@ class EnedisByPDL:
             if self.tempo_days is None and self.has_tempo_subscription:
                 self.tempo_days = await self._api.async_get_tempo_days()
 
+            if self.has_parameters and self.has_collected is False:
+                await self._async_fetch_data()
+                self.last_refresh = local_now()
+
         except EnedisException as error:
             raise error from error
         finally:
@@ -314,6 +334,7 @@ class EnedisByPDL:
         prices: Prices | Mapping[str, Any] | None = None,
         cum_value: Cum | Mapping[str, Any] | None = None,
         cum_price: Cum | Mapping[str, Any] | None = None,
+        convert_kwh: bool = True,
     ) -> None:
         """Set parameters for data fetching.
 
@@ -322,8 +343,9 @@ class EnedisByPDL:
         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
-        cum_sum: price of start
-        cum_price:
+        cum_sum: Cumulative kwh value of start
+        cum_price: Cumulative price of start
+        convert_kwh: whether to convert kWh to Wh
         """
         funcs: dict[str, Callable[..., Any]] = {
             DAILY_PROD: self._api.async_get_daily_production,
@@ -349,9 +371,10 @@ class EnedisByPDL:
         if cum_price:
             self._set_cumsum(mode, ATTR_PRICE, cum_price)
 
+        self._convert_kwh = convert_kwh
         self.has_parameters = True
 
-    async def async_update_collects(self) -> None:
+    async def _async_fetch_data(self) -> None:
         """Fetch data.
 
         It is necessary to value the initial data via the method: set_data_fetch.
@@ -380,9 +403,6 @@ class EnedisByPDL:
                 }
             )
 
-            if mode == ATTR_CONSUM and self.has_tempo_subscription:
-                self.tempo = await self._api.async_get_tempo(start, end)
-
         self.has_collected = True
 
     async def async_close(self) -> None:

{myelectricaldatapy-2.4.5 → myelectricaldatapy-2.4.7}/myelectricaldatapy/types.py

@@ -13,14 +13,34 @@ from datetime import datetime
 from enum import IntFlag
 from typing import Annotated, Any, Literal
 
-from pydantic import AfterValidator, BaseModel, ConfigDict, TypeAdapter, model_validator
+from pydantic import (
+    AfterValidator,
+    BaseModel,
+    BeforeValidator,
+    ConfigDict,
+    TypeAdapter,
+    model_validator,
+)
 
 # type Subscription = Literal["hphc", "tempo", "standard"]
 type ProductionCollect = Literal["production_load_curve", "daily_production"]
 type ConsumptionCollect = Literal["consumption_load_curve", "daily_consumption"]
 type EnergyCollect = ProductionCollect | ConsumptionCollect
 type Mode = Literal["consumption", "production"]
-type TempoLabels = Literal["blue", "white", "red"]
+
+
+def _lower_tempo_label(value: Any) -> Any:
+    """Normalize case before matching the ``blue``/``white``/``red`` literals.
+
+    The RTE Tempo API returns the colour in upper case (``"BLUE"``, ...),
+    which does not match the lower-case literal used throughout the package.
+    """
+    return value.lower() if isinstance(value, str) else value
+
+
+type TempoLabels = Annotated[
+    Literal["blue", "white", "red"], BeforeValidator(_lower_tempo_label)
+]
 
 type Service = (
     Literal[
@@ -89,7 +109,7 @@ class Prices(BaseModel):
 
 
 class Cum(_InputModel):
-    """Cumulative starting values for ``standard`` and ``offpeak`` intervals."""
+    """Cumulative starting kwh or wh values for ``standard`` and ``offpeak`` intervals."""
 
     standard: float
     offpeak: float | None = None

{myelectricaldatapy-2.4.5 → myelectricaldatapy-2.4.7}/myelectricaldatapy.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: myelectricaldatapy
-Version: 2.4.5
+Version: 2.4.7
 Summary: Fetch Linky data from myelectricaldata.fr
 Author-email: Cyr-ius <cyr-ius@ipocus.net>
 License-Expression: GPL-3.0-or-later
@@ -120,7 +120,7 @@ Workflow:
 | `set_ecowatt_subscription(activate=False)`                                                                                                                                        | Enable Ecowatt retrieval                                                                              |
 | `set_maxpower_subscription(activate=False)`                                                                                                                                       | Enable max power retrieval                                                                            |
 | `async_update(force_refresh=False)`                                                                                                                                               | Refresh access, contract, address, tempo, ecowatt, collects                                           |
-| `async_update_collects()`                                                                                                                                                         | Refresh only the registered collects                                                                  |
+| `_async_fetch_data()`                                                                                                                                                             | Refresh only the registered collects                                                                  |
 | `stats`                                                                                                                                                                           | `dict` keyed by mode (`"consumption"` / `"production"`) with the computed analytics                   |
 | `access`, `contract`, `address`, `ecowatt`, `max_power`, `tempo`, `tempo_days`, `tempo_prices`                                                                                    | Last fetched models                                                                                   |
 | `is_connected`, `has_intervals`, `has_tempo_subscription`, `has_offpeak_hours_subscription`, `has_standard_subscription`, `has_ecowatt_subscription`, `has_maxpower_subscription` | Boolean state                                                                                         |

{myelectricaldatapy-2.4.5 → myelectricaldatapy-2.4.7}/myelectricaldatapy.egg-info/scm_version.json

@@ -1,7 +1,7 @@
 {
-  "tag": "2.4.5",
+  "tag": "2.4.7",
   "distance": 0,
-  "node": "gf020e899389b76b7cf905171890380ed977aad11",
+  "node": "g85859d7b8fa97063c80cc6a908044430ab80231c",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-09-05"

myelectricaldatapy-2.4.7/tests/fixtures/tempo.json

@@ -0,0 +1 @@
+{ "2023-03-01": "BLUE", "2023-03-02": "RED", "2023-03-03": "BLUE" }

{myelectricaldatapy-2.4.5 → myelectricaldatapy-2.4.7}/tests/test_analytics.py

@@ -57,7 +57,7 @@ async def test_standard_daily_consumption_with_prices(
     """Test standard with price."""
     api = EnedisByPDL(pdl=PDL, token=TOKEN, session=session)
     api.set_data_fetch(DAILY_CONSUM, prices=STANDARD_PRICE)
-    await api.async_update_collects()
+    await api._async_fetch_data()
     resultat = api.stats["consumption"]
 
     assert resultat[0]["notes"] == "standard"
@@ -69,7 +69,7 @@ async def test_standard_detail_consumption(mock_enedis: Mock, session) -> None:
     """Test standard with price."""
     api = EnedisByPDL(pdl=PDL, token=TOKEN, session=session)
     api.set_data_fetch(DETAIL_CONSUM)
-    await api.async_update_collects()
+    await api._async_fetch_data()
     resultat = api.stats["consumption"]
 
     assert resultat[0]["notes"] == "standard"
@@ -83,7 +83,7 @@ async def test_standard_detail_consumption_with_prices(
     """Test standard with price."""
     api = EnedisByPDL(pdl=PDL, token=TOKEN, session=session)
     api.set_data_fetch(DETAIL_CONSUM, prices=STANDARD_PRICE)
-    await api.async_update_collects()
+    await api._async_fetch_data()
     resultat = api.stats["consumption"]
 
     assert resultat[0]["notes"] == "standard"
@@ -95,7 +95,7 @@ async def test_hphc_detail_consumption(mock_enedis: Mock, session) -> None:
     # Without price
     api = EnedisByPDL(pdl=PDL, token=TOKEN, session=session, subscription="hphc")
     api.set_data_fetch(DETAIL_CONSUM, intervals=OFFPEAK_INTERVALS)
-    await api.async_update_collects()
+    await api._async_fetch_data()
     resultat = api.stats["consumption"]
     assert resultat[27]["value"] == 1.296
     assert resultat[28]["value"] == 0.618
@@ -106,7 +106,7 @@ async def test_hphc_detail_consumption_with_prices(mock_enedis: Mock, session) -
     """Test without offpeak , with price."""
     api = EnedisByPDL(pdl=PDL, token=TOKEN, session=session, subscription="hphc")
     api.set_data_fetch(DETAIL_CONSUM, prices=HPHC_PRICE, intervals=OFFPEAK_INTERVALS)
-    await api.async_update_collects()
+    await api._async_fetch_data()
     resultat = api.stats["consumption"]
 
     assert resultat[0]["notes"] == "offpeak"
@@ -119,7 +119,7 @@ async def test_hphc_detail_consumption_with_prices(mock_enedis: Mock, session) -
 async def test_hphc_daily_consumption(mock_enedis: Mock, session) -> None:
     api = EnedisByPDL(pdl=PDL, token=TOKEN, session=session, subscription="hphc")
     api.set_data_fetch(DAILY_CONSUM, intervals=OFFPEAK_INTERVALS)
-    await api.async_update_collects()
+    await api._async_fetch_data()
     resultat = api.stats["consumption"]
 
     assert resultat[0]["value"] == 42.045
@@ -130,7 +130,7 @@ async def test_hphc_daily_consumption(mock_enedis: Mock, session) -> None:
 async def test_hphc_daily_consumption_with_prices(mock_enedis: Mock, session) -> None:
     api = EnedisByPDL(pdl=PDL, token=TOKEN, session=session, subscription="hphc")
     api.set_data_fetch(DAILY_CONSUM, prices=HPHC_PRICE, intervals=OFFPEAK_INTERVALS)
-    await api.async_update_collects()
+    await api._async_fetch_data()
     resultat = api.stats["consumption"]
 
     assert resultat[0]["value"] == 42.045
@@ -191,7 +191,7 @@ async def test_hphc_cumsums(mock_enedis: Mock, session) -> None:
         cum_value=CUMSUM_VALUE,
         cum_price=CUMSUM_PRICE,
     )
-    await api.async_update_collects()
+    await api._async_fetch_data()
     resultat = api.stats["consumption"]
     # offpeak
     assert resultat[0]["sum_value"] == resultat[0]["value"] + 1000
@@ -212,7 +212,7 @@ async def test_hphc_cumsum_range(mock_enedis: Mock, session) -> None:  # pylint:
         prices=HPHC_PRICE,
         intervals=OFFPEAK_INTERVALS,
     )
-    await api.async_update_collects()
+    await api._async_fetch_data()
     resultat = api.stats["consumption"]
     # offpeak
     assert resultat[0]["sum_value"] is not None
@@ -230,7 +230,7 @@ async def test_hphc_cumsum_range(mock_enedis: Mock, session) -> None:  # pylint:
         "myelectricaldatapy.Enedis.async_fetch_datas",
         side_effect=[mock_enedis, LimitReached(500, {"detail": "Limit reached"})],
     ):
-        await api.async_update_collects()
+        await api._async_fetch_data()
         resultat = api.stats["consumption"]
         assert resultat[0]["sum_value"] is not None
 
@@ -247,14 +247,14 @@ async def test_tempo_detail_comsumption(mock_enedis: Mock, session) -> None:
         cum_value=CUMSUM_VALUE,
         cum_price=CUMSUM_PRICE,
     )
-    await api.async_update_collects()
+    await api.async_update()
     resultat = api.stats["consumption"]
 
     assert resultat[0]["tempo"] == "blue"
     assert resultat[0]["value"] == 1.079
     assert resultat[0].get("sum_price") is None
     assert resultat[0]["sum_value"] == resultat[0]["value"] + 1000
-    assert api.tempo_day == "blue"
+    assert api.tempo == "blue"
 
 
 @freeze_time("2023-3-1")
@@ -270,21 +270,21 @@ async def test_tempo_detail_comsumption_with_price(mock_enedis: Mock, session) -
         cum_value=CUMSUM_VALUE,
         cum_price=CUMSUM_PRICE,
     )
-    await api.async_update_collects()
+    await api.async_update()
     resultat = api.stats["consumption"]
 
     assert resultat[0]["tempo"] == "blue"
     assert resultat[0]["value"] == 1.079
     assert resultat[0]["sum_price"] == resultat[0]["price"] + 75
     assert resultat[0]["sum_value"] == resultat[0]["value"] + 1000
-    assert api.tempo_day == "blue"
+    assert api.tempo == "blue"
 
 
 @freeze_time("2023-3-1")
 async def test_production(mock_enedis: Mock, session) -> None:
     api = EnedisByPDL(pdl=PDL, token=TOKEN, session=session, subscription="tempo")
     api.set_data_fetch(DAILY_PROD, intervals=OFFPEAK_INTERVALS)
-    await api.async_update_collects()
+    await api._async_fetch_data()
     resultat = api.stats.get("production")
     assert resultat[0].get("tempo") is None
     assert resultat[0].get("price") is None
@@ -296,7 +296,7 @@ async def test_production(mock_enedis: Mock, session) -> None:
 async def test_production_with_price(mock_enedis: Mock, session) -> None:
     api = EnedisByPDL(pdl=PDL, token=TOKEN, session=session, subscription="tempo")
     api.set_data_fetch(DAILY_PROD, prices=STANDARD_PRICE, intervals=OFFPEAK_INTERVALS)
-    await api.async_update_collects()
+    await api._async_fetch_data()
     resultat = api.stats.get("production")
     assert round(resultat[1].get("price", 0), 3) == 5.519
     assert resultat[1].get("value") == 32.464
@@ -312,7 +312,7 @@ async def test_start_date(mock_enedis: Mock, session) -> None:
         DETAIL_CONSUM,
         start=dt.strptime("2023-3-7", "%Y-%m-%d").replace(tzinfo=LOCAL_TIMEZONE),
     )
-    await api.async_update_collects()
+    await api._async_fetch_data()
     resultat = api.stats["consumption"]
     assert len(resultat) == 0
 

{myelectricaldatapy-2.4.5 → myelectricaldatapy-2.4.7}/tests/test_load_data.py

@@ -94,7 +94,7 @@ async def test_tempoday(mock_enedis: Mock, session) -> None:
     mypdl.set_data_fetch(DETAIL_CONSUM)
     await mypdl.async_update()
     resultat = mypdl.stats["consumption"]
-    assert mypdl.tempo_day == "blue"
+    assert mypdl.tempo == "blue"
 
 
 @freeze_time("2023-3-3")

myelectricaldatapy-2.4.5/tests/fixtures/tempo.json

@@ -1 +0,0 @@
-{ "2023-03-01": "blue", "2023-03-02": "red", "2023-03-03": "blue" }