myelectricaldatapy 2.4.4__tar.gz → 2.4.7__tar.gz

{myelectricaldatapy-2.4.4 → myelectricaldatapy-2.4.7}/.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.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: myelectricaldatapy
-Version: 2.4.4
+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.4 → 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.7/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.7}/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.7}/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.7}/myelectricaldatapy/mypdl.py

@@ -41,13 +41,12 @@ from .types import (
     Prices,
     Subscription,
     TempoDays,
-    TempoLabels,
     TempoMapping,
     UsagePoint,
 )
 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]:
@@ -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,8 +187,7 @@ class EnedisByPDL:
             data = params.get("data", [])
             analytics = EnedisAnalytics(data, timezone=self._timezone)
             resultat = analytics.get_data_analytics(
-                convertKwh=True,
-                convertUTC=False,
+                convertKwh=self._convert_kwh,
                 intervals=params.get(ATTR_INTERVALS, []),
                 groupby=True,
                 summary=True,
@@ -182,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
@@ -203,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
 
@@ -234,13 +248,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)
@@ -250,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()
@@ -260,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:
@@ -286,7 +305,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 +320,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})
@@ -315,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.
 
@@ -323,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,
@@ -350,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.
@@ -381,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: