myelectricaldatapy 2.4.4__tar.gz → 2.4.5__tar.gz

{myelectricaldatapy-2.4.4 → myelectricaldatapy-2.4.5}/.github/workflows/release.yml

@@ -13,7 +13,7 @@ jobs:
 
       - name: Generate changelog
         id: changelog
-        uses: metcalfc/changelog-generator@v4.8.0
+        uses: metcalfc/changelog-generator@v5.0.1
         with:
           myToken: ${{ secrets.GITHUB_TOKEN }}
 

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: myelectricaldatapy
-Version: 2.4.4
+Version: 2.4.5
 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.5/myelectricaldatapy/analytics.py

@@ -0,0 +1,333 @@
+"""Class for analytics."""
+
+from datetime import datetime as dt, timedelta, tzinfo as _tzinfo
+import logging
+import re
+from typing import Any
+
+import pandas as pd
+
+from .const import ATTR_OFFPEAK, ATTR_STANDARD, TEMPO_DAYS
+from .exceptions import AnalyticsError, EnedisException
+from .types import TempoLabels
+from .tz import get_local_timezone
+
+logger = logging.getLogger(__name__)
+
+
+class EnedisAnalytics:
+    """Data analytics."""
+
+    def __init__(self, data: Any, timezone: _tzinfo | None = None) -> None:
+        """Initialize Dataframe."""
+        # 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()
+        try:
+            if isinstance(data, list):
+                data = self._shift_timestamps_to_interval_start(data)
+            self.df = pd.DataFrame(data)
+        except Exception as error:  # normalized below
+            raise AnalyticsError(
+                f"Could not build a dataframe from the provided data: {error}"
+            ) from error
+
+    def get_data_analytics(
+        self,
+        convertKwh: bool = False,
+        start_date: dt | None = None,
+        intervals: list[tuple[str, str]] | None = None,
+        groupby: bool = False,
+        summary: bool = False,
+        cum_value: dict[str, Any] | None = None,
+        cum_price: dict[str, Any] | None = None,
+        prices: dict[str, Any] | None = None,
+        tempo: dict[str, TempoLabels] | None = None,
+    ) -> Any:
+        """Convert data to analyze.
+
+        Any failure while crunching the dataframe is re-raised as
+        :class:`AnalyticsError` so callers only have to catch
+        :class:`EnedisException`.
+        """
+        try:
+            return self._get_data_analytics(
+                convertKwh=convertKwh,
+                start_date=start_date,
+                intervals=intervals,
+                groupby=groupby,
+                summary=summary,
+                cum_value=cum_value,
+                cum_price=cum_price,
+                prices=prices,
+                tempo=tempo,
+            )
+        except EnedisException:
+            raise
+        except Exception as error:  # normalized below
+            raise AnalyticsError(
+                f"Failed to compute analytics from the provided dataset: {error}"
+            ) from error
+
+    def _get_data_analytics(
+        self,
+        convertKwh: bool = False,
+        start_date: dt | None = None,
+        intervals: list[tuple[str, str]] | None = None,
+        groupby: bool = False,
+        summary: bool = False,
+        cum_value: dict[str, Any] | None = None,
+        cum_price: dict[str, Any] | None = None,
+        prices: dict[str, Any] | None = None,
+        tempo: dict[str, TempoLabels] | None = None,
+    ) -> Any:
+        """Convert data to analyze."""
+
+        cum_value = cum_value or {}
+        cum_price = cum_price or {}
+
+        step_hour = self._prepare_dataframe(start_date)
+        if self.df.empty:
+            return self.df.to_dict(orient="records")
+
+        self._apply_value_conversion(convertKwh, step_hour)
+
+        if intervals:
+            self._get_data_interval(intervals)
+
+        if groupby:
+            self._groupby_period(step_hour)
+
+        if tempo:
+            self._set_tempo_days(tempo)
+
+        notes = list(self.df.notes.drop_duplicates())
+        self._apply_pricing(prices, tempo, summary, cum_price, notes)
+
+        if summary:
+            self._apply_value_summary(cum_value, notes)
+
+        return self.df.to_dict(orient="records")
+
+    def _prepare_dataframe(self, start_date: dt | None) -> bool:
+        """Normalize dates, localize timezone, filter and mark rows.
+
+        Timestamps are already shifted from interval-END to interval-START
+        by :meth:`_shift_timestamps_to_interval_start` at construction time,
+        so no further per-row adjustment is needed here.
+
+        Returns whether the dataset is stepped (has an interval_length column).
+        """
+        step_hour = False
+
+        if self.df.empty:
+            return step_hour
+
+        # Convert str to datetime
+        try:
+            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)
+
+        if "interval_length" in self.df:
+            step_hour = True
+
+        if start_date:
+            dt_start_date = pd.to_datetime(start_date, format="%Y-%m-%d %H:%M:%S")
+            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"]
+
+        # Add mark
+        self.df["notes"] = ATTR_STANDARD
+
+        return step_hour
+
+    def _apply_value_conversion(self, convertKwh: bool, step_hour: bool) -> None:
+        """Weight values by interval length and optionally convert Wh to kWh."""
+        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"]
+            )
+        else:
+            self.df["value"] = (
+                pd.to_numeric(self.df["value"]) * self.df["interval_length"]
+            )
+
+    def _groupby_period(self, step_hour: bool) -> None:
+        """Aggregate values by note and period (hour or day)."""
+        freq = "h" if step_hour else "D"
+        self.df = (
+            self.df.groupby(["notes", pd.Grouper(key="date", freq=freq)])["value"]
+            .sum()
+            .reset_index()
+        )
+
+    def _apply_pricing(
+        self,
+        prices: dict[str, Any] | None,
+        tempo: dict[str, TempoLabels] | None,
+        summary: bool,
+        cum_price: dict[str, Any],
+        notes: list[str],
+    ) -> None:
+        """Compute a price per row and, if requested, a cumulative price per note."""
+        if not prices:
+            return
+
+        for mode, values in prices.items():
+            if isinstance(values, dict):
+                for offset, price in values.items():
+                    if tempo and offset in TEMPO_DAYS:
+                        self.df.loc[
+                            (self.df.notes == mode) & (self.df.tempo == offset),
+                            "price",
+                        ] = self.df.value * price
+                    elif offset == "price":
+                        self.df.loc[(self.df.notes == mode), "price"] = (
+                            self.df.value * price
+                        )
+                    else:
+                        self.df.loc[(self.df.notes == mode), "price"] = None
+
+        if summary:
+            for note in notes:
+                self.df.loc[(self.df.notes == note), "sum_price"] = self.df[
+                    (self.df.notes == note)
+                ].price.cumsum() + cum_price.get(note, 0)
+
+    def _apply_value_summary(self, cum_value: dict[str, Any], notes: list[str]) -> None:
+        """Add a cumulative value sum per note."""
+        for note in notes:
+            self.df.loc[(self.df.notes == note), "sum_value"] = self.df[
+                (self.df.notes == note)
+            ].value.cumsum() + cum_value.get(note, 0)
+
+    def _weighted_interval(self, interval: str) -> float | int:
+        """Compute weighted."""
+        if interval and len(rslt := re.findall("PT([0-9]{1,2})M", interval)) == 1:
+            return int(rslt[0]) / 60
+        return 1
+
+    def _get_data_interval(self, intervals: list[tuple[str, str]]) -> pd.DataFrame:
+        """Group date from range time."""
+        for interval in intervals:
+            # 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 (handle ranges spanning midnight, e.g. 22:00:00 -> 06:00:00).
+            # `date` holds the START of each reading's interval (see
+            # _shift_timestamps_to_interval_start), so bounds are
+            # start-inclusive / end-exclusive: a reading starting at
+            # `end` already belongs to the next (non-offpeak) slot.
+            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, TempoLabels]) -> 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
+
+    def _parse_iso8601_duration_to_minutes(self, duration: str) -> int:
+        """Parse ISO 8601 duration format to minutes."""
+        match = re.match(r"PT(\d+)([HM])", duration)
+        if not match:
+            return 30
+
+        value = int(match.group(1))
+        unit = match.group(2)
+
+        return value * 60 if unit == "H" else value
+
+    def _shift_timestamps_to_interval_start(
+        self, readings: list[dict[str, Any]]
+    ) -> list[dict[str, Any]]:
+        """
+        Shift timestamps from interval END to interval START.
+
+        Enedis API returns timestamps representing the END of each measurement interval.
+        For better UX and to avoid confusion with midnight timestamps, we shift all timestamps
+        backwards by the interval_length to represent the START of each interval.
+
+        Example with 30min intervals:
+            API returns:  2025-11-22 00:30:00 (end of 00:00-00:30 interval)
+            We transform: 2025-11-22 00:00:00 (start of 00:00-00:30 interval)
+
+        This also fixes the midnight edge case where:
+            API returns:  2025-11-23 00:00:00 (end of 23:30-00:00 interval of day 22)
+            We transform: 2025-11-22 23:30:00 (start of that interval, correctly on day 22)
+
+        Readings without an interval_length (e.g. daily aggregates) are returned
+        unchanged. Input readings are never mutated: callers (e.g. EnedisByPDL.stats,
+        a property recomputed on every access from the same stored list) may reuse
+        them across multiple EnedisAnalytics calls.
+        """
+        shifted_count = 0
+        shifted_readings: list[dict[str, Any]] = []
+
+        for reading in readings:
+            interval_length_iso = reading.get("interval_length")
+            original_date = reading.get("date")
+            if not original_date or not interval_length_iso:
+                shifted_readings.append(reading)
+                continue
+
+            # Parse ISO 8601 duration to minutes
+            interval_minutes = self._parse_iso8601_duration_to_minutes(
+                interval_length_iso
+            )
+
+            # Parse datetime (handle both formats: "YYYY-MM-DD HH:MM:SS" and "YYYY-MM-DDTHH:MM:SS")
+            try:
+                if "T" in original_date:
+                    dt_orig_date = dt.fromisoformat(original_date)
+                else:
+                    dt_orig_date = dt.strptime(
+                        original_date, "%Y-%m-%d %H:%M:%S"
+                    ).replace(tzinfo=self.local_timezone)
+
+                # Shift backwards by interval_length
+                shifted_dt = dt_orig_date - timedelta(minutes=interval_minutes)
+
+                # Format back to original format
+                new_date = (
+                    shifted_dt.strftime("%Y-%m-%dT%H:%M:%S")
+                    if "T" in original_date
+                    else shifted_dt.strftime("%Y-%m-%d %H:%M:%S")
+                )
+
+                shifted_readings.append({**reading, "date": new_date})
+                shifted_count += 1
+
+            except ValueError as e:
+                logger.warning(
+                    f"[ENEDIS] Failed to shift timestamp '{original_date}': {e}"
+                )
+                shifted_readings.append(reading)
+
+        if shifted_count > 0:
+            logger.info(
+                f"[ENEDIS] Shifted {shifted_count} timestamps from interval END → START"
+            )
+
+        return shifted_readings

{myelectricaldatapy-2.4.4 → myelectricaldatapy-2.4.5}/myelectricaldatapy/api.py

@@ -30,7 +30,7 @@ from .types import (
 )
 from .tz import as_local, get_local_timezone, local_now
 
-_LOGGER = logging.getLogger(__name__)
+logger = logging.getLogger(__name__)
 
 
 def _validate[ModelT: BaseModel](model: type[ModelT], raw: Any) -> ModelT:
@@ -136,7 +136,7 @@ class Enedis:
         try:
             return TempoResponse.validate_python(raw)
         except ValidationError as error:
-            _LOGGER.debug("Unexpected tempo payload: %s (%s)", raw, error)
+            logger.debug("Unexpected tempo payload: %s (%s)", raw, error)
             return {}
 
     async def async_get_tempo_days(self) -> TempoDays | None:
@@ -145,7 +145,7 @@ class Enedis:
         try:
             return TempoDays.model_validate(raw)
         except ValidationError as error:
-            _LOGGER.debug("Unexpected tempo days payload: %s (%s)", raw, error)
+            logger.debug("Unexpected tempo days payload: %s (%s)", raw, error)
             return None
 
     async def async_get_tempo_prices(self) -> Prices | None:
@@ -165,7 +165,7 @@ class Enedis:
                 ),
             )
         except (AttributeError, ValidationError) as error:
-            _LOGGER.debug("Unexpected tempo prices payload: %s (%s)", raw, error)
+            logger.debug("Unexpected tempo prices payload: %s (%s)", raw, error)
             return None
 
     async def async_get_ecowatt(
@@ -184,7 +184,7 @@ class Enedis:
         try:
             return EcowattResponse.validate_python(raw)
         except ValidationError as error:
-            _LOGGER.debug("Unexpected ecowatt payload: %s (%s)", raw, error)
+            logger.debug("Unexpected ecowatt payload: %s (%s)", raw, error)
             return {}
 
     async def async_has_offpeak(self, pdl: str) -> bool:
@@ -277,7 +277,7 @@ class Enedis:
                     )
             except EnedisException as error:
                 raise_error = True
-                _LOGGER.error(error)
+                logger.error(error)
 
             if response is None:
                 continue

{myelectricaldatapy-2.4.4 → myelectricaldatapy-2.4.5}/myelectricaldatapy/auth.py

@@ -17,7 +17,7 @@ from .exceptions import (
     TimeoutExceededError,
 )
 
-_LOGGER = logging.getLogger(__name__)
+logger = logging.getLogger(__name__)
 URL = "https://myelectricaldata.fr"
 
 
@@ -40,7 +40,7 @@ class EnedisAuth:
 
         try:
             async with asyncio.timeout(self.timeout):
-                _LOGGER.debug("Request: %s (%s) - %s", path, method, kwargs.get("json"))
+                logger.debug("Request: %s (%s) - %s", path, method, kwargs.get("json"))
                 response = await self.session.request(method, f"{URL}{path}", **kwargs)
                 contents = await response.read()
                 response.raise_for_status()

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

@@ -47,7 +47,7 @@ from .types import (
 )
 from .tz import as_local, local_now, set_local_timezone
 
-_LOGGER = logging.getLogger(__name__)
+logger = logging.getLogger(__name__)
 
 
 def _dump(model: BaseModel | None) -> dict[str, Any]:
@@ -174,7 +174,6 @@ class EnedisByPDL:
             analytics = EnedisAnalytics(data, timezone=self._timezone)
             resultat = analytics.get_data_analytics(
                 convertKwh=True,
-                convertUTC=False,
                 intervals=params.get(ATTR_INTERVALS, []),
                 groupby=True,
                 summary=True,
@@ -234,13 +233,13 @@ class EnedisByPDL:
                     self.contract = await self._api.async_get_contract(self.pdl)
                     self.offpeak_intervals = self._api.offpeaks
                 except EnedisException as error:
-                    _LOGGER.warning(error)
+                    logger.warning(error)
 
             if self.address is None and self.has_collected is False:
                 try:
                     self.address = await self._api.async_get_address(self.pdl)
                 except EnedisException as error:
-                    _LOGGER.warning(error)
+                    logger.warning(error)
 
             if self.ecowatt is None and self.has_ecowatt_subscription:
                 self.ecowatt = await self._api.async_get_ecowatt(start, end)
@@ -286,7 +285,7 @@ class EnedisByPDL:
                 prices if isinstance(prices, Prices) else Prices.model_validate(prices)
             )
         except ValidationError as error:
-            _LOGGER.error("Format is incorrect (%s)", error)
+            logger.error("Format is incorrect (%s)", error)
             return
 
         self._params[mode].update({ATTR_PRICES: model})
@@ -301,7 +300,7 @@ class EnedisByPDL:
         try:
             model = cum_sum if isinstance(cum_sum, Cum) else Cum.model_validate(cum_sum)
         except ValidationError as error:
-            _LOGGER.error("Format is incorrect (%s)", error)
+            logger.error("Format is incorrect (%s)", error)
             return
 
         self._params[mode].update({f"cum_{form}".lower(): model})

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: myelectricaldatapy
-Version: 2.4.4
+Version: 2.4.5
 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.5/myelectricaldatapy.egg-info/scm_version.json

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

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

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+from copy import deepcopy
 from datetime import datetime as dt
 from unittest.mock import Mock, patch
 
@@ -16,6 +17,7 @@ from myelectricaldatapy import (
     LimitReached,
     Subscription,
 )
+from myelectricaldatapy.analytics import EnedisAnalytics
 from myelectricaldatapy.tz import LOCAL_TIMEZONE
 
 from .consts import PDL, TOKEN
@@ -331,3 +333,129 @@ async def test_twice_call(
     assert api.stats["production"][0]["notes"] == "standard"
     await api.async_update()
     assert api.last_access is not None
+
+
+# --- EnedisAnalytics internals: interval-start timestamp shift ---------------
+
+
+def test_shift_timestamps_basic() -> None:
+    """A 30min reading is shifted back from interval END to interval START."""
+    analytics = EnedisAnalytics([], timezone=LOCAL_TIMEZONE)
+    readings = [
+        {"date": "2023-03-01 00:30:00", "value": "100", "interval_length": "PT30M"}
+    ]
+
+    shifted = analytics._shift_timestamps_to_interval_start(readings)
+
+    assert shifted[0]["date"] == "2023-03-01 00:00:00"
+
+
+def test_shift_timestamps_midnight_rollover() -> None:
+    """The interval ending at midnight must roll back onto the previous day."""
+    analytics = EnedisAnalytics([], timezone=LOCAL_TIMEZONE)
+    readings = [
+        {"date": "2023-03-02 00:00:00", "value": "100", "interval_length": "PT30M"}
+    ]
+
+    shifted = analytics._shift_timestamps_to_interval_start(readings)
+
+    assert shifted[0]["date"] == "2023-03-01 23:30:00"
+
+
+def test_shift_timestamps_without_interval_length_is_untouched() -> None:
+    """Daily aggregates (no interval_length) are passed through as-is."""
+    analytics = EnedisAnalytics([], timezone=LOCAL_TIMEZONE)
+    readings = [{"date": "2023-03-01", "value": "42000"}]
+
+    shifted = analytics._shift_timestamps_to_interval_start(readings)
+
+    assert shifted == readings
+
+
+def test_shift_timestamps_does_not_mutate_input() -> None:
+    """EnedisByPDL.stats recomputes analytics from the same stored list on
+    every access, so shifting must never mutate the caller's dicts in place.
+    """
+    analytics = EnedisAnalytics([], timezone=LOCAL_TIMEZONE)
+    readings = [
+        {"date": "2023-03-01 00:30:00", "value": "100", "interval_length": "PT30M"}
+    ]
+    original = deepcopy(readings)
+
+    analytics._shift_timestamps_to_interval_start(readings)
+
+    assert readings == original
+
+
+@pytest.mark.parametrize(
+    ("duration", "expected_minutes"),
+    [("PT30M", 30), ("PT1H", 60), ("PT15M", 15), ("not-a-duration", 30)],
+)
+def test_parse_iso8601_duration_to_minutes(
+    duration: str, expected_minutes: int
+) -> None:
+    analytics = EnedisAnalytics([], timezone=LOCAL_TIMEZONE)
+    assert analytics._parse_iso8601_duration_to_minutes(duration) == expected_minutes
+
+
+def test_offpeak_classification_uses_shifted_start_timestamp() -> None:
+    """Regression test for the boundary fix in _get_data_interval.
+
+    Once dates represent the interval START (not END), the offpeak mask
+    must be start-inclusive / end-exclusive; getting this wrong reclassified
+    readings right at the edges of an offpeak window.
+    """
+    data = [
+        # END of 01:00-01:30 -> shifts to 01:00 (before offpeak starts)
+        {"date": "2023-03-01 01:30:00", "value": "1000", "interval_length": "PT30M"},
+        # END of 01:30-02:00 -> shifts to 01:30 (first offpeak interval)
+        {"date": "2023-03-01 02:00:00", "value": "1000", "interval_length": "PT30M"},
+        # END of 07:30-08:00 -> shifts to 07:30 (last offpeak interval)
+        {"date": "2023-03-01 08:00:00", "value": "1000", "interval_length": "PT30M"},
+        # END of 08:00-08:30 -> shifts to 08:00 (offpeak window just ended)
+        {"date": "2023-03-01 08:30:00", "value": "1000", "interval_length": "PT30M"},
+    ]
+    analytics = EnedisAnalytics(data, timezone=LOCAL_TIMEZONE)
+
+    resultat = analytics.get_data_analytics(intervals=[("01:30:00", "08:00:00")])
+
+    notes_by_time = {r["date"].strftime("%H:%M:%S"): r["notes"] for r in resultat}
+    assert notes_by_time["01:00:00"] == "standard"
+    assert notes_by_time["01:30:00"] == "offpeak"
+    assert notes_by_time["07:30:00"] == "offpeak"
+    assert notes_by_time["08:00:00"] == "standard"
+
+
+def test_offpeak_boundaries_snap_to_reading_granularity() -> None:
+    """Documents a known limitation, not a bug: classification cannot be
+    more precise than the data's own step (30min for load curve data).
+
+    A whole reading is either offpeak or standard; it is never split. So an
+    offpeak window declared as 00:54-05:54 is not honoured to the minute:
+    each reading is classified from its own (interval-START) timestamp, so
+    the effective window silently snaps to the surrounding 30min slots
+    (here: 01:00-06:00 instead of 00:54-05:54).
+    """
+    data = [
+        # Represents [00:30, 01:00) - overlaps the declared offpeak window
+        # (00:54-01:00) but is entirely "standard": the reading starts
+        # before 00:54.
+        {"date": "2023-03-01 01:00:00", "value": "1000", "interval_length": "PT30M"},
+        # Represents [01:00, 01:30) - fully inside the declared window.
+        {"date": "2023-03-01 01:30:00", "value": "1000", "interval_length": "PT30M"},
+        # Represents [05:30, 06:00) - overlaps the declared offpeak window
+        # (05:30-05:54) but is entirely "offpeak": the reading starts
+        # before 05:54.
+        {"date": "2023-03-01 06:00:00", "value": "1000", "interval_length": "PT30M"},
+        # Represents [06:00, 06:30) - fully outside the declared window.
+        {"date": "2023-03-01 06:30:00", "value": "1000", "interval_length": "PT30M"},
+    ]
+    analytics = EnedisAnalytics(data, timezone=LOCAL_TIMEZONE)
+
+    resultat = analytics.get_data_analytics(intervals=[("00:54:00", "05:54:00")])
+
+    notes_by_time = {r["date"].strftime("%H:%M:%S"): r["notes"] for r in resultat}
+    assert notes_by_time["00:30:00"] == "standard"
+    assert notes_by_time["01:00:00"] == "offpeak"
+    assert notes_by_time["05:30:00"] == "offpeak"
+    assert notes_by_time["06:00:00"] == "standard"

myelectricaldatapy-2.4.4/myelectricaldatapy/analytics.py

@@ -1,215 +0,0 @@
-"""Class for analytics."""
-
-from datetime import datetime as dt, timedelta, tzinfo as _tzinfo
-import re
-from typing import Any
-
-import pandas as pd
-
-from .const import ATTR_OFFPEAK, ATTR_STANDARD, TEMPO_DAYS
-from .exceptions import AnalyticsError, EnedisException
-from .types import TempoLabels
-from .tz import get_local_timezone
-
-
-class EnedisAnalytics:
-    """Data analytics."""
-
-    def __init__(self, data: Any, timezone: _tzinfo | None = None) -> None:
-        """Initialize Dataframe."""
-        try:
-            self.df = pd.DataFrame(data)
-        except Exception as error:  # normalized below
-            raise AnalyticsError(
-                f"Could not build a dataframe from the provided data: {error}"
-            ) from error
-        # 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,
-        convertKwh: bool = False,
-        convertUTC: bool = False,
-        start_date: dt | None = None,
-        intervals: list[tuple[str, str]] | None = None,
-        groupby: bool = False,
-        summary: bool = False,
-        cum_value: dict[str, Any] | None = None,
-        cum_price: dict[str, Any] | None = None,
-        prices: dict[str, Any] | None = None,
-        tempo: dict[str, TempoLabels] | None = None,
-    ) -> Any:
-        """Convert data to analyze.
-
-        Any failure while crunching the dataframe is re-raised as
-        :class:`AnalyticsError` so callers only have to catch
-        :class:`EnedisException`.
-        """
-        try:
-            return self._get_data_analytics(
-                convertKwh=convertKwh,
-                convertUTC=convertUTC,
-                start_date=start_date,
-                intervals=intervals,
-                groupby=groupby,
-                summary=summary,
-                cum_value=cum_value,
-                cum_price=cum_price,
-                prices=prices,
-                tempo=tempo,
-            )
-        except EnedisException:
-            raise
-        except Exception as error:  # normalized below
-            raise AnalyticsError(
-                f"Failed to compute analytics from the provided dataset: {error}"
-            ) from error
-
-    def _get_data_analytics(
-        self,
-        convertKwh: bool = False,
-        convertUTC: bool = False,
-        start_date: dt | None = None,
-        intervals: list[tuple[str, str]] | None = None,
-        groupby: bool = False,
-        summary: bool = False,
-        cum_value: dict[str, Any] | None = None,
-        cum_price: dict[str, Any] | None = None,
-        prices: dict[str, Any] | None = None,
-        tempo: dict[str, TempoLabels] | 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"
-                )
-            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)
-
-            if convertUTC:
-                self.df["date"] = pd.to_datetime(
-                    self.df["date"], utc=True, format="%Y-%m-%d %H:%M:%S"
-                )
-
-            # Subtract 1 minute at hour
-            # because Pandas considers hour as the next hour while
-            # for Enedis it is the hour before
-            if "interval_length" in self.df:
-                step_hour = True
-                self.df.loc[
-                    (self.df["date"].dt.minute == 0),
-                    "date",
-                ] = self.df["date"] - timedelta(minutes=1)
-
-            if start_date:
-                dt_start_date = pd.to_datetime(start_date, format="%Y-%m-%d %H:%M:%S")
-                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"]
-
-            # Add mark
-            self.df["notes"] = ATTR_STANDARD
-
-        if self.df.empty:
-            return self.df.to_dict(orient="records")
-
-        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"]
-            )
-        else:
-            self.df["value"] = (
-                pd.to_numeric(self.df["value"]) * self.df["interval_length"]
-            )
-
-        if intervals:
-            self._get_data_interval(intervals)
-
-        if groupby:
-            freq = "h" if step_hour else "D"
-            self.df = (
-                self.df.groupby(["notes", pd.Grouper(key="date", freq=freq)])["value"]
-                .sum()
-                .reset_index()
-            )
-
-        if tempo:
-            self._set_tempo_days(tempo)
-
-        notes = list(self.df.notes.drop_duplicates())
-        if prices:
-            for mode, values in prices.items():
-                if isinstance(values, dict):
-                    for offset, price in values.items():
-                        if tempo and offset in TEMPO_DAYS:
-                            self.df.loc[
-                                (self.df.notes == mode) & (self.df.tempo == offset),
-                                "price",
-                            ] = self.df.value * price
-                        elif offset == "price":
-                            self.df.loc[(self.df.notes == mode), "price"] = (
-                                self.df.value * price
-                            )
-                        else:
-                            self.df.loc[(self.df.notes == mode), "price"] = None
-
-            if summary:
-                for note in notes:
-                    self.df.loc[(self.df.notes == note), "sum_price"] = self.df[
-                        (self.df.notes == note)
-                    ].price.cumsum() + cum_price.get(note, 0)
-
-        if summary:
-            for note in notes:
-                self.df.loc[(self.df.notes == note), "sum_value"] = self.df[
-                    (self.df.notes == note)
-                ].value.cumsum() + cum_value.get(note, 0)
-
-        return self.df.to_dict(orient="records")
-
-    def _weighted_interval(self, interval: str) -> float | int:
-        """Compute weighted."""
-        if interval and len(rslt := re.findall("PT([0-9]{1,2})M", interval)) == 1:
-            return int(rslt[0]) / 60
-        return 1
-
-    def _get_data_interval(self, intervals: list[tuple[str, str]]) -> pd.DataFrame:
-        """Group date from range time."""
-        for interval in intervals:
-            # 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 (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, TempoLabels]) -> 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

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

@@ -1,8 +0,0 @@
-{
-  "tag": "2.4.4",
-  "distance": 0,
-  "node": "g9a87ed2706824a82c1926e6396d5602827511a4a",
-  "dirty": false,
-  "branch": "HEAD",
-  "node_date": "2026-08-31"
-}