myelectricaldatapy 2.2.7__tar.gz → 2.2.9__tar.gz

{myelectricaldatapy-2.2.7 → myelectricaldatapy-2.2.9}/.github/workflows/auto-approve.yml

@@ -8,7 +8,7 @@ permissions:
 jobs:
   dependency:
     runs-on: ubuntu-latest
-    if: ${{ github.actor == 'dependabot[bot]' || github.actor == 'pre-commit-ci[bot]' }}
+    if: ${{ github.event.pull_request.user.login == 'dependabot[bot]' && github.actor == 'dependabot[bot]' }}
     steps:
       - name: Approve a PR
         run: gh pr review --approve "$PR_URL"

{myelectricaldatapy-2.2.7 → myelectricaldatapy-2.2.9}/.github/workflows/python-lint.yml

@@ -9,7 +9,7 @@ jobs:
     strategy:
       max-parallel: 4
       matrix:
-        python-version: ["3.10", "3.11", "3.12"]
+        python-version: ["3.12", "3.13", "3.14"]
 
     steps:
       - name: 📥 Checkout the repository

{myelectricaldatapy-2.2.7 → myelectricaldatapy-2.2.9}/.github/workflows/release.yml

@@ -13,7 +13,7 @@ jobs:
 
       - name: Generate changelog
         id: changelog
-        uses: metcalfc/changelog-generator@v4.7.0
+        uses: metcalfc/changelog-generator@v4.8.0
         with:
           myToken: ${{ secrets.GITHUB_TOKEN }}
 
@@ -24,7 +24,7 @@ jobs:
           body: ${{ steps.changelog.outputs.changelog }}
           draft: false
           prerelease: ${{ contains(github.ref_name, '-') }}
-          token: ${{ secrets.RELEASE_TOKEN }}
+          token: ${{ secrets.GITHUB_TOKEN }}
   publish:
     needs: release
     permissions:

{myelectricaldatapy-2.2.7 → myelectricaldatapy-2.2.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: myelectricaldatapy
-Version: 2.2.7
+Version: 2.2.9
 Summary: Fetch Linky data from myelectricaldata.fr
 Author-email: Cyr-ius <cyr-ius@ipocus.net>
 License-Expression: GPL-3.0-or-later
@@ -10,14 +10,13 @@ Platform: any
 Classifier: Programming Language :: Python
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Framework :: AsyncIO
 Classifier: Intended Audience :: Developers
 Classifier: Topic :: Home Automation
-Requires-Python: >=3.10.0
+Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: aiohttp>=3.8.1
@@ -27,6 +26,11 @@ Provides-Extra: dev
 Requires-Dist: prek; extra == "dev"
 Requires-Dist: ruff; extra == "dev"
 Requires-Dist: yamllint; extra == "dev"
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-asyncio; extra == "dev"
+Requires-Dist: python-typing-update; extra == "dev"
+Requires-Dist: typing_extensions; extra == "dev"
+Requires-Dist: freezegun; extra == "dev"
 Dynamic: license-file
 
 # myelectricaldatapy

{myelectricaldatapy-2.2.7 → myelectricaldatapy-2.2.9}/example.py

@@ -2,12 +2,13 @@
 """Example code."""
 
 import asyncio
-from datetime import datetime, timedelta
+from datetime import timedelta
 import logging
 
 import yaml
 
 from myelectricaldatapy import Enedis, EnedisByPDL, EnedisException
+from myelectricaldatapy.tz import local_now
 
 logger = logging.getLogger()
 logger.setLevel(logging.INFO)
@@ -32,8 +33,8 @@ async def async_main() -> None:
     api = Enedis(token=TOKEN)
 
     try:
-        start = datetime.now() - timedelta(days=7)
-        end = datetime.now()
+        start = local_now() - timedelta(days=7)
+        end = local_now()
         data = await api.async_fetch_datas("consumption_load_curve", PDL, start, end)
         logger.info(data)
         data = await api.async_get_contract(PDL)

{myelectricaldatapy-2.2.7 → myelectricaldatapy-2.2.9}/myelectricaldatapy/__init__.py

@@ -1,13 +1,14 @@
 """myelectricaldatapy package."""
 
+from .api import Enedis
 from .exceptions import (
     EnedisException,
     HttpRequestError,
     LimitReached,
     TimeoutExceededError,
 )
-from .myelectricaldata import Enedis
 from .mypdl import EnedisByPDL
+from .tz import get_local_timezone, set_local_timezone
 
 __all__ = [
     "Enedis",
@@ -16,4 +17,6 @@ __all__ = [
     "HttpRequestError",
     "LimitReached",
     "TimeoutExceededError",
+    "get_local_timezone",
+    "set_local_timezone",
 ]

{myelectricaldatapy-2.2.7 → myelectricaldatapy-2.2.9}/myelectricaldatapy/analytics.py

@@ -1,40 +1,25 @@
 """Class for analytics."""
 
-from __future__ import annotations
-
-from collections.abc import Collection
-from datetime import datetime as dt, timedelta
-import os
+from datetime import datetime as dt, timedelta, tzinfo as _tzinfo
 import re
 from typing import Any
-from zoneinfo import ZoneInfo
 
 import pandas as pd
 
-from .const import ATTR_OFFPEAK, ATTR_STANDARD
-
-
-def _local_timezone() -> Any:
-    """Resolve the local IANA timezone so DST offsets stay correct per-date.
-
-    Falls back to the fixed UTC offset captured at call time when the
-    system timezone database cannot be resolved (e.g. non-Linux hosts).
-    """
-    try:
-        tz_path = os.path.realpath("/etc/localtime")
-        return ZoneInfo(tz_path.split("zoneinfo/")[-1])
-    except Exception:  # noqa: BLE001
-        return dt.now().astimezone().tzinfo
+from .const import ATTR_OFFPEAK, ATTR_STANDARD, TEMPO_DAYS
+from .tz import get_local_timezone
 
 
 class EnedisAnalytics:
-    """Data analaytics."""
-
-    local_timezone = _local_timezone()
+    """Data analytics."""
 
-    def __init__(self, data: Collection[Collection[str]]) -> None:
+    def __init__(self, data: Any, timezone: _tzinfo | None = None) -> None:
         """Initialize Dataframe."""
         self.df = pd.DataFrame(data)
+        # Resolved per instance (not at import/class-definition time) so a
+        # timezone set later via tz.set_local_timezone(), or passed here
+        # explicitly, is honored.
+        self.local_timezone = timezone or get_local_timezone()
 
     def get_data_analytics(
         self,
@@ -50,20 +35,25 @@ class EnedisAnalytics:
         tempo: dict[str, str] | None = None,
     ) -> Any:
         """Convert data to analyze."""
+
         cum_value = cum_value or {}
         cum_price = cum_price or {}
         step_hour = False
+
         if not self.df.empty:
             # Convert str to datetime
             try:
-                self.df.date = pd.to_datetime(self.df.date, format="%Y-%m-%d %H:%M:%S")
+                self.df["date"] = pd.to_datetime(
+                    self.df["date"], format="%Y-%m-%d %H:%M:%S"
+                )
             except ValueError:
-                self.df.date = pd.to_datetime(self.df.date, format="%Y-%m-%d")
-            self.df.date = self.df.date.dt.tz_localize(self.local_timezone)
+                self.df["date"] = pd.to_datetime(self.df["date"], format="%Y-%m-%d")
+
+            self.df["date"] = self.df["date"].dt.tz_localize(self.local_timezone)
 
             if convertUTC:
-                self.df.date = pd.to_datetime(
-                    self.df.date, utc=True, format="%Y-%m-%d %H:%M:%S"
+                self.df["date"] = pd.to_datetime(
+                    self.df["date"], utc=True, format="%Y-%m-%d %H:%M:%S"
                 )
 
             # Subtract 1 minute at hour
@@ -72,16 +62,17 @@ class EnedisAnalytics:
             if "interval_length" in self.df:
                 step_hour = True
                 self.df.loc[
-                    (self.df.date.dt.minute == 0),
+                    (self.df["date"].dt.minute == 0),
                     "date",
-                ] = self.df.date - timedelta(minutes=1)
+                ] = self.df["date"] - timedelta(minutes=1)
 
             if start_date:
                 dt_start_date = pd.to_datetime(start_date, format="%Y-%m-%d %H:%M:%S")
-                dt_start_date = dt_start_date.tz_localize(self.local_timezone)
-                self.df = self.df[(self.df.date > dt_start_date)]
+                if dt_start_date.tzinfo is None:
+                    dt_start_date = dt_start_date.tz_localize(self.local_timezone)
+                self.df = self.df[(self.df["date"] > dt_start_date)]
 
-            self.df.index = self.df.date
+            self.df.index = self.df["date"]
 
             # Add mark
             self.df["notes"] = ATTR_STANDARD
@@ -89,18 +80,20 @@ class EnedisAnalytics:
         if self.df.empty:
             return self.df.to_dict(orient="records")
 
-        self.df.interval_length = (
-            self.df.interval_length.transform(self._weighted_interval)
+        self.df["interval_length"] = (
+            self.df["interval_length"].transform(self._weighted_interval)
             if step_hour
             else 1
         )
 
         if convertKwh:
-            self.df.value = (
-                pd.to_numeric(self.df.value) / 1000 * self.df.interval_length
+            self.df["value"] = (
+                pd.to_numeric(self.df["value"]) / 1000 * self.df["interval_length"]
             )
         else:
-            self.df.value = pd.to_numeric(self.df.value) * self.df.interval_length
+            self.df["value"] = (
+                pd.to_numeric(self.df["value"]) * self.df["interval_length"]
+            )
 
         if intervals:
             self._get_data_interval(intervals)
@@ -121,7 +114,7 @@ class EnedisAnalytics:
             for mode, values in prices.items():
                 if isinstance(values, dict):
                     for offset, price in values.items():
-                        if tempo and offset in ["blue", "white", "red"]:
+                        if tempo and offset in TEMPO_DAYS:
                             self.df.loc[
                                 (self.df.notes == mode) & (self.df.tempo == offset),
                                 "price",
@@ -149,7 +142,7 @@ class EnedisAnalytics:
 
     def _weighted_interval(self, interval: str) -> float | int:
         """Compute weighted."""
-        if interval and len(rslt := re.findall("PT([0-9]{2})M", interval)) == 1:
+        if interval and len(rslt := re.findall("PT([0-9]{1,2})M", interval)) == 1:
             return int(rslt[0]) / 60
         return 1
 
@@ -159,16 +152,18 @@ class EnedisAnalytics:
             # Convert str to datetime
             start = pd.to_datetime(interval[0], format="%H:%M:%S").time()
             end = pd.to_datetime(interval[1], format="%H:%M:%S").time()
-            # Mark
-            self.df.loc[
-                (self.df.date.dt.time > start) & (self.df.date.dt.time <= end),
-                "notes",
-            ] = ATTR_OFFPEAK
+            # Mark (handle ranges spanning midnight, e.g. 22:00:00 -> 06:00:00)
+            date_time = self.df["date"].dt.time
+            if start <= end:
+                mask = (date_time > start) & (date_time <= end)
+            else:
+                mask = (date_time > start) | (date_time <= end)
+            self.df.loc[mask, "notes"] = ATTR_OFFPEAK
 
         return self.df
 
-    def _set_tempo_days(self, tempo: dict[str, str]) -> pd.DataFrame:
+    def _set_tempo_days(self, tempo: dict[str, str]) -> None:
         """Add columns with tempo day."""
         for str_date, value in tempo.items():
             dt_date = pd.to_datetime(str_date, format="%Y-%m-%d")
-            self.df.loc[(self.df.date.dt.date == dt_date.date()), "tempo"] = value
+            self.df.loc[(self.df["date"].dt.date == dt_date.date()), "tempo"] = value

myelectricaldatapy-2.2.7/myelectricaldatapy/myelectricaldata.py → myelectricaldatapy-2.2.9/myelectricaldatapy/api.py

@@ -1,24 +1,23 @@
 """Class for Enedis Gateway (http://www.myelectricaldata.fr)."""
 
-from __future__ import annotations
-
 from collections.abc import Generator
 from datetime import date, datetime as dt, timedelta
 import logging
 import re
-from typing import Any, cast
+from typing import Any
 
 from aiohttp import ClientSession
 
 from .auth import EnedisAuth
 from .const import DAILY_CONSUM, DAILY_PROD, DETAIL_CONSUM, DETAIL_PROD, TIMEOUT
 from .exceptions import EnedisException
+from .tz import as_local, get_local_timezone, local_now
 
 _LOGGER = logging.getLogger(__name__)
 
 
 class Enedis:
-    """Get data of pdl."""
+    """Enedis API."""
 
     def __init__(
         self, token: str, session: ClientSession | None = None, timeout: int = TIMEOUT
@@ -40,7 +39,7 @@ class Enedis:
                     daily_consumption, daily_production,
                     consumption_load_curve, production_load_curve
         """
-        self.last_access = dt.now()
+        self.last_access = local_now()
         path_range = ""
         if start and end:
             start_date = start.strftime("%Y-%m-%d")
@@ -93,12 +92,12 @@ class Enedis:
     ) -> Any:
         """Return Tempo Day."""
         str_start = (
-            start.strftime("%Y-%m-%d") if start else dt.now().strftime("%Y-%m-%d")
+            start.strftime("%Y-%m-%d") if start else local_now().strftime("%Y-%m-%d")
         )
         str_end = (
             end.strftime("%Y-%m-%d")
             if end
-            else (dt.now() + timedelta(days=1)).strftime("%Y-%m-%d")
+            else (local_now() + timedelta(days=1)).strftime("%Y-%m-%d")
         )
         return await self.auth.async_request(path=f"rte/tempo/{str_start}/{str_end}")
 
@@ -107,12 +106,12 @@ class Enedis:
     ) -> Any:
         """Return Ecowatt information."""
         str_start = (
-            start.strftime("%Y-%m-%d") if start else dt.now().strftime("%Y-%m-%d")
+            start.strftime("%Y-%m-%d") if start else local_now().strftime("%Y-%m-%d")
         )
         str_end = (
             end.strftime("%Y-%m-%d")
             if end
-            else (dt.now() + timedelta(days=1)).strftime("%Y-%m-%d")
+            else (local_now() + timedelta(days=1)).strftime("%Y-%m-%d")
         )
         return await self.async_request(path=f"rte/ecowatt/{str_start}/{str_end}")
 
@@ -125,10 +124,21 @@ class Enedis:
     async def async_check_offpeak(self, pdl: str, start: dt) -> bool:
         """Return offpeak status."""
         if await self.async_has_offpeak(pdl) is True:
-            start_time = start.time()
+            # Off-peak windows are defined in local wall-clock time, so a
+            # start given in another timezone must be converted first.
+            local_timezone = get_local_timezone()
+            start_time = as_local(start).astimezone(local_timezone).time()
             for range_time in self.offpeaks:
-                starting = dt.strptime(range_time[0], "%HH%M").time()
-                ending = dt.strptime(range_time[1], "%HH%M").time()
+                starting = (
+                    dt.strptime(range_time[0], "%HH%M")
+                    .replace(tzinfo=local_timezone)
+                    .time()
+                )
+                ending = (
+                    dt.strptime(range_time[1], "%HH%M")
+                    .replace(tzinfo=local_timezone)
+                    .time()
+                )
                 if starting < start_time <= ending:
                     return True
         return False
@@ -162,7 +172,7 @@ class Enedis:
     async def _async_get_details(self, mode: str, pdl: str, start: dt, end: dt) -> Any:
         """Get production details. (max: 7 days)."""
         data = None
-        response = {}
+        response: dict[str, Any] | None = None
         raise_error = False
         for interval in list(self.date_range(start, end, 7)):
             start, end = interval
@@ -171,15 +181,18 @@ class Enedis:
                     response = await self.async_fetch_datas(mode, pdl, start, end)
             except EnedisException as error:
                 raise_error = True
+                response = None
                 _LOGGER.error(error)
-            finally:
-                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], response)
-                else:
-                    data["meter_reading"]["interval_reading"].extend(new_data)
+
+            if response is None:
+                continue
+            new_data = response.get("meter_reading", {}).get("interval_reading")
+            if new_data is None:
+                continue
+            elif data is None:
+                data = response
+            else:
+                data["meter_reading"]["interval_reading"].extend(new_data)
 
         return data
 
@@ -197,14 +210,6 @@ class Enedis:
             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:

{myelectricaldatapy-2.2.7 → myelectricaldatapy-2.2.9}/myelectricaldatapy/auth.py

@@ -1,7 +1,5 @@
 """Class for Enedis Authentication (http://www.myelectricaldata.fr)."""
 
-from __future__ import annotations
-
 import asyncio
 import json
 import logging
@@ -38,6 +36,7 @@ class EnedisAuth:
         kwargs["headers"].update(
             {"Content-Type": "application/json", "Authorization": self.token}
         )
+        contents = b""
 
         try:
             async with asyncio.timeout(self.timeout):
@@ -45,15 +44,15 @@ class EnedisAuth:
                 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:
+        except (TimeoutError, asyncio.CancelledError) as error:
             raise TimeoutExceededError(
                 "Timeout occurred while connecting to MyElectricalData."
             ) from error
-        except ClientResponseError:
+        except ClientResponseError as error:
             message = contents.decode("utf8")
-            if "application/json" in response.headers.get("Content-Type", ""):
+            if "application/json" in (error.headers or {}).get("Content-Type", ""):
                 msg = json.loads(message)
-                if response.status == 409:
+                if error.status == 409:
                     raise LimitReached(msg.get("detail", msg))
                 raise EnedisException(msg.get("detail", msg))
             raise EnedisException({"message": message})

{myelectricaldatapy-2.2.7 → myelectricaldatapy-2.2.9}/myelectricaldatapy/const.py

@@ -6,10 +6,11 @@ ATTR_END = "end"
 ATTR_INTERVALS = "intervals"
 ATTR_OFFPEAK = "offpeak"
 ATTR_PRICES = "prices"
-ATTR_SERVICE = "service"
 ATTR_STANDARD = "standard"
 ATTR_START = "start"
 ATTR_FN = "function"
+ATTR_PRICE = "price"
+TEMPO_DAYS = ("blue", "white", "red")
 CONSUMPTION = "consumption"
 DAILY_CONSUM = "daily_consumption"
 DAILY_PROD = "daily_production"

{myelectricaldatapy-2.2.7 → myelectricaldatapy-2.2.9}/myelectricaldatapy/mypdl.py

@@ -1,18 +1,15 @@
 """Class for my PDL."""
 
-from __future__ import annotations
-
 from collections.abc import Callable
-from datetime import date, datetime as dt, timedelta
+from datetime import date, datetime as dt, timedelta, tzinfo as _tzinfo
 import logging
-from typing import Any
+from typing import Any, Literal
 
 from aiohttp import ClientSession
 import voluptuous as vol
 
-from myelectricaldatapy import Enedis, EnedisException, LimitReached
-
 from .analytics import EnedisAnalytics
+from .api import Enedis
 from .const import (
     ATTR_CUM_PRICE,
     ATTR_CUM_VALUE,
@@ -20,8 +17,8 @@ from .const import (
     ATTR_FN,
     ATTR_INTERVALS,
     ATTR_OFFPEAK,
+    ATTR_PRICE,
     ATTR_PRICES,
-    ATTR_SERVICE,
     ATTR_STANDARD,
     ATTR_START,
     CONSUMPTION,
@@ -32,31 +29,18 @@ from .const import (
     PRODUCTION,
     TIMEOUT,
 )
+from .exceptions import EnedisException, LimitReached
+from .tz import as_local, local_now, set_local_timezone
 
 _LOGGER = logging.getLogger(__name__)
 
-MODES_SCH = vol.Schema(
-    {
-        vol.Optional(CONSUMPTION): {
-            vol.Required(ATTR_SERVICE): str,
-            vol.Optional(ATTR_START): dt,
-            vol.Optional(ATTR_END): dt,
-        },
-        vol.Optional(PRODUCTION): {
-            vol.Required(ATTR_SERVICE): str,
-            vol.Optional(ATTR_START): dt,
-            vol.Optional(ATTR_END): dt,
-        },
-    }
-)
-
 PRICE_SCH = vol.Schema(
     {
         vol.Required(ATTR_STANDARD): {
-            vol.Required("price"): vol.Any(int, float),
+            vol.Required(ATTR_PRICE): vol.Any(int, float),
         },
         vol.Optional(ATTR_OFFPEAK): {
-            vol.Required("price"): vol.Any(int, float),
+            vol.Required(ATTR_PRICE): vol.Any(int, float),
         },
     }
 )
@@ -100,11 +84,21 @@ class EnedisByPDL:
         token: str,
         session: ClientSession | None = None,
         timeout: int = TIMEOUT,
+        timezone: _tzinfo | None = None,
     ) -> None:
-        """Initialize."""
+        """Initialize.
+
+        timezone: the timezone to interpret naive datetimes in (e.g. Home
+            Assistant's hass.config.time_zone / dt_util.get_default_time_zone()).
+            Defaults to the host machine's timezone, which has no reason to
+            match the consuming application's configured timezone.
+        """
         session = ClientSession() if session is None else session
         self._api: Enedis = Enedis(token, session, timeout)
         self.pdl = pdl
+        self._timezone = timezone
+        if timezone is not None:
+            set_local_timezone(timezone)
         self._connected: bool = False
         self._ecowatt_subs: bool = False
         self._maxpower_subs: bool = False
@@ -118,7 +112,7 @@ class EnedisByPDL:
         self.has_collected: bool = False
         self.has_parameters: bool = False
         self.intervals: list[tuple[str, str]] = []
-        self.last_access: dt = dt.now()
+        self.last_access: dt = local_now()
         self.last_refresh: date | None = None
         self.max_power: dict[str, Any] = {}
         self.tempo: dict[str, Any] = {}
@@ -133,16 +127,44 @@ class EnedisByPDL:
         """Intervals exist."""
         return len(self.intervals) > 0
 
+    @property
+    def has_tempo_subscription(self) -> bool:
+        """Tempo subscription status."""
+        return self._tempo_subs
+
+    @property
+    def has_offpeak_hours_subscription(self) -> bool:
+        """Offpeak hours subscription status."""
+        return self._off_subs
+
+    @property
+    def has_ecowatt_subscription(self) -> bool:
+        """Ecowatt subscription status."""
+        return self._ecowatt_subs
+
+    @property
+    def has_maxpower_subscription(self) -> bool:
+        """Max power subscription status."""
+        return self._maxpower_subs
+
+    @property
+    def subscription(self) -> Literal["hphc", "tempo", "standard"]:
+        if self.has_tempo_subscription:
+            return "tempo"
+        if self.has_offpeak_hours_subscription:
+            return "hphc"
+        return "standard"
+
     @property
     def ecowatt_day(self) -> Any:
         """ecowatt."""
-        str_date = dt.now().strftime("%Y-%m-%d")
+        str_date = local_now().strftime("%Y-%m-%d")
         return self.ecowatt.get(str_date, {})
 
     @property
     def tempo_day(self) -> str | None:
         """Tempo day."""
-        str_date = dt.now().strftime("%Y-%m-%d")
+        str_date = local_now().strftime("%Y-%m-%d")
         return self.tempo.get(str_date)
 
     @property
@@ -161,7 +183,7 @@ class EnedisByPDL:
         stats = {}
         for mode, params in self._params.items():
             data = params.get("data", {})
-            analytics = EnedisAnalytics(data)
+            analytics = EnedisAnalytics(data, timezone=self._timezone)
             resultat = analytics.get_data_analytics(
                 convertKwh=True,
                 convertUTC=False,
@@ -179,22 +201,20 @@ class EnedisByPDL:
 
     async def async_update(self, force_refresh: bool = False) -> None:
         """Update data."""
-        start = dt.now() - timedelta(days=1095)
-        end = dt.now() + timedelta(days=1)
-        if force_refresh or self.last_access.date() != dt.now().date():
-            self.access = {}
-            self.contract = {}
-            self.address = {}
-            self.ecowatt = {}
-            self.max_power = {}
+
+        start = local_now() - timedelta(days=1095)
+        end = local_now() + timedelta(days=1)
+
+        if force_refresh or (self.last_access.date() != local_now().date()):
+            self.contract.clear()
+            self.contract.clear()
+            self.address.clear()
+            self.ecowatt.clear()
+            self.max_power.clear()
             self.has_collected = False
-        try:
-            if not self.access:
-                # Quota is scarce (ex: 50 calls/day on Enedis API), so the
-                # access/quota check is only refreshed once a day (or on
-                # force_refresh) instead of on every update cycle.
-                self.access = await self._api.async_valid_access(self.pdl)
 
+        try:
+            self.access = await self._api.async_valid_access(self.pdl)
             if self.access.get("quota_reached", False):
                 detail = self.access.get("information", "Quota reached")
                 raise LimitReached(409, {"detail": detail})
@@ -224,11 +244,11 @@ class EnedisByPDL:
 
             if self.has_parameters and self.has_collected is False:
                 await self.async_update_collects()
-                self.last_refresh = dt.now()
+                self.last_refresh = local_now()
         except EnedisException as error:
             raise error from error
         finally:
-            self.last_access = dt.now()
+            self.last_access = local_now()
 
     def tempo_subscription(self, activate: bool = False) -> None:
         """Enable or Disable Tempo Subscription."""
@@ -333,8 +353,8 @@ class EnedisByPDL:
         days = 1095 if service in [DAILY_PROD, DAILY_CONSUM] else 7
         mode = CONSUMPTION if service in [DAILY_CONSUM, DETAIL_CONSUM] else PRODUCTION
         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)
+        dt_start = as_local(start) if start else local_now() - timedelta(days=days)
+        dt_end = as_local(end) if end else local_now() + timedelta(days=1)
         self._params[mode] = {ATTR_FN: func, ATTR_START: dt_start, ATTR_END: dt_end}
         if intervals:
             self._set_intervals(mode, intervals)
@@ -343,7 +363,7 @@ class EnedisByPDL:
         if cum_value:
             self._set_cumsum(mode, "value", cum_value)
         if cum_price:
-            self._set_cumsum(mode, "price", cum_price)
+            self._set_cumsum(mode, ATTR_PRICE, cum_price)
         self.has_parameters = True
 
     async def async_update_collects(self) -> None:

myelectricaldatapy-2.2.9/myelectricaldatapy/tz.py

@@ -0,0 +1,64 @@
+"""Local timezone helpers.
+
+The Enedis/RTE APIs return naive timestamps that represent local wall-clock
+time (see tests/fixtures, e.g. access.json's "last_call"), so this library
+treats "naive datetime" as "local time" throughout. These helpers make that
+convention explicit and DST-safe, instead of relying on a fixed UTC offset
+captured once at import time.
+"""
+
+from datetime import UTC, datetime as dt, tzinfo as _tzinfo
+import os
+from typing import cast
+from zoneinfo import ZoneInfo
+
+
+def _resolve_local_timezone() -> _tzinfo:
+    """Resolve the local IANA timezone, DST-aware.
+
+    Falls back to the fixed UTC offset captured at call time when the
+    system timezone database cannot be resolved (e.g. non-Linux hosts).
+    """
+    try:
+        tz_path = os.path.realpath("/etc/localtime")
+        return ZoneInfo(tz_path.split("zoneinfo/")[-1])
+    except Exception:  # noqa: BLE001
+        # dt.now().astimezone() always sets tzinfo when called without
+        # arguments; typeshed just can't express that.
+        return cast(_tzinfo, dt.now().astimezone().tzinfo) or UTC
+
+
+LOCAL_TIMEZONE = _resolve_local_timezone()
+
+_override_timezone: _tzinfo | None = None
+
+
+def get_local_timezone() -> _tzinfo:
+    """Return the timezone to use for interpreting naive datetimes.
+
+    Returns the timezone set via set_local_timezone(), if any, otherwise
+    falls back to LOCAL_TIMEZONE (the host machine's /etc/localtime). The
+    host's timezone has no reason to match the application embedding this
+    library, so a caller such as a Home Assistant integration should call
+    set_local_timezone() at startup with its own configured timezone (e.g.
+    hass.config.time_zone).
+    """
+    return _override_timezone or LOCAL_TIMEZONE
+
+
+def set_local_timezone(tz: _tzinfo) -> None:
+    """Override the timezone used to interpret naive datetimes."""
+    global _override_timezone
+    _override_timezone = tz
+
+
+def local_now() -> dt:
+    """Return the current time, timezone-aware in the local zone."""
+    return dt.now(tz=get_local_timezone())
+
+
+def as_local(value: dt) -> dt:
+    """Attach the local timezone to a naive datetime; pass aware ones through."""
+    if value.tzinfo is None:
+        return value.replace(tzinfo=get_local_timezone())
+    return value

{myelectricaldatapy-2.2.7 → myelectricaldatapy-2.2.9}/myelectricaldatapy.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: myelectricaldatapy
-Version: 2.2.7
+Version: 2.2.9
 Summary: Fetch Linky data from myelectricaldata.fr
 Author-email: Cyr-ius <cyr-ius@ipocus.net>
 License-Expression: GPL-3.0-or-later
@@ -10,14 +10,13 @@ Platform: any
 Classifier: Programming Language :: Python
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Framework :: AsyncIO
 Classifier: Intended Audience :: Developers
 Classifier: Topic :: Home Automation
-Requires-Python: >=3.10.0
+Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: aiohttp>=3.8.1
@@ -27,6 +26,11 @@ Provides-Extra: dev
 Requires-Dist: prek; extra == "dev"
 Requires-Dist: ruff; extra == "dev"
 Requires-Dist: yamllint; extra == "dev"
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-asyncio; extra == "dev"
+Requires-Dist: python-typing-update; extra == "dev"
+Requires-Dist: typing_extensions; extra == "dev"
+Requires-Dist: freezegun; extra == "dev"
 Dynamic: license-file
 
 # myelectricaldatapy

{myelectricaldatapy-2.2.7 → myelectricaldatapy-2.2.9}/myelectricaldatapy.egg-info/SOURCES.txt

@@ -15,12 +15,13 @@ pyproject.toml
 .vscode/settings.json
 myelectricaldatapy/__init__.py
 myelectricaldatapy/analytics.py
+myelectricaldatapy/api.py
 myelectricaldatapy/auth.py
 myelectricaldatapy/const.py
 myelectricaldatapy/exceptions.py
-myelectricaldatapy/myelectricaldata.py
 myelectricaldatapy/mypdl.py
 myelectricaldatapy/py.typed
+myelectricaldatapy/tz.py
 myelectricaldatapy.egg-info/PKG-INFO
 myelectricaldatapy.egg-info/SOURCES.txt
 myelectricaldatapy.egg-info/dependency_links.txt

{myelectricaldatapy-2.2.7 → myelectricaldatapy-2.2.9}/myelectricaldatapy.egg-info/requires.txt

@@ -6,3 +6,8 @@ voluptuous>=0.13.1
 prek
 ruff
 yamllint
+pytest
+pytest-asyncio
+python-typing-update
+typing_extensions
+freezegun

{myelectricaldatapy-2.2.7 → myelectricaldatapy-2.2.9}/myelectricaldatapy.egg-info/scm_file_list.json

@@ -16,12 +16,13 @@
     "example.py",
     "myelectricaldatapy/__init__.py",
     "myelectricaldatapy/analytics.py",
+    "myelectricaldatapy/api.py",
     "myelectricaldatapy/auth.py",
     "myelectricaldatapy/const.py",
     "myelectricaldatapy/exceptions.py",
-    "myelectricaldatapy/myelectricaldata.py",
     "myelectricaldatapy/mypdl.py",
     "myelectricaldatapy/py.typed",
+    "myelectricaldatapy/tz.py",
     "pyproject.toml",
     "tests/__init__.py",
     "tests/conftest.py",

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

@@ -0,0 +1,8 @@
+{
+  "tag": "2.2.9",
+  "distance": 0,
+  "node": "gd64089c5c53ebbcc9f4ffe8a04ed5c1abc20a527",
+  "dirty": false,
+  "branch": "HEAD",
+  "node_date": "2026-08-24"
+}

{myelectricaldatapy-2.2.7 → myelectricaldatapy-2.2.9}/myelectricaldatapy.egg-info/top_level.txt

@@ -1 +1,2 @@
+dist
 myelectricaldatapy

{myelectricaldatapy-2.2.7 → myelectricaldatapy-2.2.9}/pyproject.toml

@@ -16,15 +16,14 @@ classifiers = [
     "Programming Language :: Python",
     "Development Status :: 5 - Production/Stable",
     "Programming Language :: Python :: 3",
-    "Programming Language :: Python :: 3.10",
-    "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
     "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
     "Framework :: AsyncIO",
     "Intended Audience :: Developers",
     "Topic :: Home Automation",
 ]
-requires-python = ">=3.10.0"
+requires-python = ">=3.12"
 dependencies    = [
     "aiohttp>=3.8.1",
     "pandas>=2.0.2",
@@ -36,6 +35,11 @@ dev = [
     "prek",
     "ruff",
     "yamllint",
+    "pytest",
+    "pytest-asyncio",
+    "python-typing-update",
+    "typing_extensions",
+    "freezegun"
 ]
 
 [project.urls]
@@ -46,12 +50,12 @@ Homepage = "https://github.com/cyr-ius/myelectricaldatapy"
 [tool.setuptools]
 platforms = ["any"]
 
+[tool.setuptools.packages.find]
+exclude = ["node_modules*", "tests*"]
+
 [tool.pytest.ini_options]
 asyncio_mode = "auto"
 
-[tool.ruff.lint.flake8-pytest-style]
-fixture-parentheses = false
-
 [tool.ruff.lint.isort]
 force-sort-within-sections = true
 combine-as-imports = true

{myelectricaldatapy-2.2.7 → myelectricaldatapy-2.2.9}/tests/test_analytics.py

@@ -12,6 +12,7 @@ import pytest
 
 import myelectricaldatapy
 from myelectricaldatapy import EnedisByPDL, LimitReached
+from myelectricaldatapy.tz import LOCAL_TIMEZONE
 
 from .consts import PDL, TOKEN
 
@@ -203,8 +204,8 @@ async def test_cumsums(mock_enedis: Mock) -> None:  # pylint: disable=unused-arg
     api = EnedisByPDL(pdl=PDL, token=TOKEN, session=ClientSession())
     api.set_collects(
         "consumption_load_curve",
-        start=dt.strptime("2023-03-01", "%Y-%m-%d"),
-        end=dt.strptime("2023-03-08", "%Y-%m-%d"),
+        start=dt.strptime("2023-03-01", "%Y-%m-%d").replace(tzinfo=LOCAL_TIMEZONE),
+        end=dt.strptime("2023-03-08", "%Y-%m-%d").replace(tzinfo=LOCAL_TIMEZONE),
         prices=prices,
         intervals=intervals,
         cum_value=cumsum_value,
@@ -228,8 +229,8 @@ async def test_extra_date(mock_base: Mock, mock_detail) -> None:  # pylint: disa
     api = EnedisByPDL(pdl=PDL, token=TOKEN, session=ClientSession())
     api.set_collects(
         "consumption_load_curve",
-        start=dt.strptime("2023-03-01", "%Y-%m-%d"),
-        end=dt.strptime("2023-03-28", "%Y-%m-%d"),
+        start=dt.strptime("2023-03-01", "%Y-%m-%d").replace(tzinfo=LOCAL_TIMEZONE),
+        end=dt.strptime("2023-03-28", "%Y-%m-%d").replace(tzinfo=LOCAL_TIMEZONE),
         prices=prices,
         intervals=intervals,
     )
@@ -243,8 +244,8 @@ async def test_extra_date(mock_base: Mock, mock_detail) -> None:  # pylint: disa
 
     api.set_collects(
         "consumption_load_curve",
-        start=dt.strptime("2023-03-01", "%Y-%m-%d"),
-        end=dt.strptime("2023-03-28", "%Y-%m-%d"),
+        start=dt.strptime("2023-03-01", "%Y-%m-%d").replace(tzinfo=LOCAL_TIMEZONE),
+        end=dt.strptime("2023-03-28", "%Y-%m-%d").replace(tzinfo=LOCAL_TIMEZONE),
         prices=prices,
         intervals=intervals,
     )
@@ -326,14 +327,16 @@ async def test_start_date(mock_enedis: Mock) -> None:  # pylint: disable=unused-
     """Test with start_date."""
     api = EnedisByPDL(pdl=PDL, token=TOKEN, session=ClientSession())
     api.set_collects(
-        "consumption_load_curve", start=dt.strptime("2023-3-7", "%Y-%m-%d")
+        "consumption_load_curve",
+        start=dt.strptime("2023-3-7", "%Y-%m-%d").replace(tzinfo=LOCAL_TIMEZONE),
     )
     await api.async_update_collects()
     resultat = api.stats["consumption"]
     assert len(resultat) == 0
 
     api.set_collects(
-        "consumption_load_curve", start=dt.strptime("2023-3-7", "%Y-%m-%d")
+        "consumption_load_curve",
+        start=dt.strptime("2023-3-7", "%Y-%m-%d").replace(tzinfo=LOCAL_TIMEZONE),
     )
     await api.async_update_collects()
     resultat = api.stats["consumption"]

{myelectricaldatapy-2.2.7 → myelectricaldatapy-2.2.9}/tests/test_load_data.py

@@ -11,6 +11,7 @@ import pytest
 
 import myelectricaldatapy
 from myelectricaldatapy import Enedis, EnedisByPDL, EnedisException, LimitReached
+from myelectricaldatapy.tz import LOCAL_TIMEZONE, local_now
 
 from .consts import PDL, TOKEN
 
@@ -71,15 +72,40 @@ async def test_check_offpeak(mock_contract) -> None:
         assert await api.async_has_offpeak(PDL) is True
 
         # 03:00 falls inside the 01:30-08:00 off-peak window
-        assert await api.async_check_offpeak(PDL, dt(2023, 3, 1, 3, 0)) is True
+        assert (
+            await api.async_check_offpeak(
+                PDL, dt(2023, 3, 1, 3, 0, tzinfo=LOCAL_TIMEZONE)
+            )
+            is True
+        )
         # exactly on the lower bound is excluded (start, end] convention
-        assert await api.async_check_offpeak(PDL, dt(2023, 3, 1, 1, 30)) is False
+        assert (
+            await api.async_check_offpeak(
+                PDL, dt(2023, 3, 1, 1, 30, tzinfo=LOCAL_TIMEZONE)
+            )
+            is False
+        )
         # exactly on the upper bound is included
-        assert await api.async_check_offpeak(PDL, dt(2023, 3, 1, 8, 0)) is True
+        assert (
+            await api.async_check_offpeak(
+                PDL, dt(2023, 3, 1, 8, 0, tzinfo=LOCAL_TIMEZONE)
+            )
+            is True
+        )
         # standard hours, not off-peak
-        assert await api.async_check_offpeak(PDL, dt(2023, 3, 1, 10, 0)) is False
+        assert (
+            await api.async_check_offpeak(
+                PDL, dt(2023, 3, 1, 10, 0, tzinfo=LOCAL_TIMEZONE)
+            )
+            is False
+        )
         # second window 12:30-14:00
-        assert await api.async_check_offpeak(PDL, dt(2023, 3, 1, 13, 0)) is True
+        assert (
+            await api.async_check_offpeak(
+                PDL, dt(2023, 3, 1, 13, 0, tzinfo=LOCAL_TIMEZONE)
+            )
+            is True
+        )
 
 
 async def test_valid_access(mock_enedis: Mock) -> None:  # pylint: disable=unused-argument
@@ -115,8 +141,8 @@ async def test_fetch_data(mock_detail) -> None:
         resultat = await api.async_fetch_datas(
             service="comsumption_load_curve",
             pdl=PDL,
-            start=dt.strptime("2022-12-30", "%Y-%m-%d"),
-            end=dt.strptime("2022-12-31", "%Y-%m-%d"),
+            start=dt.strptime("2022-12-30", "%Y-%m-%d").replace(tzinfo=LOCAL_TIMEZONE),
+            end=dt.strptime("2022-12-31", "%Y-%m-%d").replace(tzinfo=LOCAL_TIMEZONE),
         )
         assert (
             resultat["meter_reading"]["interval_reading"]
@@ -128,7 +154,7 @@ async def test_force_refresh(
     mock_enedis: Mock,  # pylint: disable=unused-argument
 ) -> None:
     """Test refresh object."""
-    last_call = dt.now().strftime("%Y-%m-%dT%H:%M:%S.%f")
+    last_call = local_now().strftime("%Y-%m-%dT%H:%M:%S.%f")
     access = {
         "valid": True,
         "quota_reached": False,

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

@@ -1,8 +0,0 @@
-{
-  "tag": "2.2.7",
-  "distance": 0,
-  "node": "g3fb21c9929da8ebafc38ec5cfef31d7ccd6ac826",
-  "dirty": false,
-  "branch": "HEAD",
-  "node_date": "2026-08-16"
-}