Add water cost statistic and exclude estimations from computation (#18)

Author: TimoPtr

README.md

@@ -55,7 +55,7 @@ If installed via HACS, you can also uninstall the integration from HACS after re
 | **Email** | Yes | The email address used to log in to the SEDIF customer portal at [connexion.leaudiledefrance.fr](https://connexion.leaudiledefrance.fr). |
 | **Password** | Yes | The password for your SEDIF portal account. Stored locally in Home Assistant and only sent to the SEDIF portal for authentication. |
 
-Each contract appears as a separate device named **SEDIF Contract {number}** (e.g. "SEDIF Contract 9235380"), where the number matches your SEDIF contract reference.
+Each contract appears as a separate device named **SEDIF Contract {number}** (e.g. "SEDIF Contract XXXXXXX"), where the number matches your SEDIF contract reference.
 
 ## Entities
 
@@ -111,14 +111,23 @@ The meter reading and daily consumption sensors expose the following additional
 
 The integration imports historical water consumption data as **external statistics** with correct timestamps, so the Energy dashboard attributes usage to the right day (not when the integration polled).
 
-On first setup, up to **90 days** of history are imported. After that, only the last 7 days are fetched on each update cycle, keeping the statistics up to date without redundant API calls.
+On first setup, up to **90 days** of history are imported. After that, only the last 7 days are fetched on each update cycle, keeping the statistics up to date without redundant API calls. Estimated readings are excluded from statistics to avoid double-counting when the actual value is published later.
+
+Two external statistics are created per contract:
+
+| Statistic | Unit | Description |
+|---|---|---|
+| **SEDIF {contract_number} water consumption** | m³ | Cumulative water consumption (for Energy Dashboard water tracking) |
+| **SEDIF {contract_number} water cost** | EUR | Cumulative water cost based on the average price per m³ reported by the SEDIF portal |
 
 To add water tracking:
 
 1. Go to **Settings > Dashboards > Energy**
 2. In the **Water consumption** section, click **Add water source**
 3. Search for **SEDIF {contract_number} water consumption** — this is the external statistic created by the integration
 
+The water cost statistic can be used in custom cards or automations. It uses the average price per cubic meter provided by the SEDIF portal to compute daily costs.
+
 > **Important:** Use the external statistic, not the sensor entities. The **Meter Reading** sensor updates every 6 hours and timestamps data at poll time, which causes consumption to appear on the wrong day. The external statistic uses the actual date reported by SEDIF, so the Energy dashboard shows accurate daily breakdowns.
 
 ## Data updates

custom_components/eauidf/coordinator.py

@@ -18,7 +18,7 @@
     get_last_statistics,
 )
 from homeassistant.const import CONF_PASSWORD, CONF_USERNAME, UnitOfVolume
-from homeassistant.exceptions import ConfigEntryAuthFailed
+from homeassistant.exceptions import ConfigEntryAuthFailed, HomeAssistantError
 from homeassistant.helpers.aiohttp_client import async_create_clientsession
 from homeassistant.helpers.issue_registry import (
     IssueSeverity,
@@ -29,7 +29,12 @@
 from homeassistant.util import dt as dt_util
 from homeassistant.util.unit_conversion import VolumeConverter
 from pyeauidf import EauIDFClient
-from pyeauidf.client import AuthenticationError, ConsumptionRecord, EauIDFError
+from pyeauidf.client import (
+    AuthenticationError,
+    ConsumptionData,
+    ConsumptionRecord,
+    EauIDFError,
+)
 
 from .const import CONF_CONTRACTS, DOMAIN
 
@@ -56,7 +61,7 @@ class ContractData:
     is_estimated: bool
 
 
-type FetchResult = tuple[SedifData, dict[str, list[ConsumptionRecord]]]
+type FetchResult = tuple[SedifData, dict[str, ConsumptionData]]
 type SedifData = dict[str, ContractData]
 
 
@@ -88,9 +93,7 @@ async def _async_update_data(self) -> SedifData:
             username, password, session=async_create_clientsession(self.hass)
         )
         try:
-            sensor_data, all_records = await self._fetch_all(
-                client, contracts, start_date
-            )
+            sensor_data, all_data = await self._fetch_all(client, contracts, start_date)
         except AuthenticationError as err:
             self._on_failure()
             raise ConfigEntryAuthFailed(str(err)) from err
@@ -104,7 +107,7 @@ async def _async_update_data(self) -> SedifData:
             raise UpdateFailed(msg) from err
         else:
             self._on_success()
-            await self._insert_statistics(all_records)
+            await self._insert_statistics(all_data)
             return sensor_data
         finally:
             await client.close()
@@ -119,16 +122,19 @@ async def _compute_start_date(
 
         for contract in contracts:
             statistic_id = f"{DOMAIN}:{contract['number']}_water_consumption"
-            last_stat: dict[str, list[dict[str, Any]]] = await get_instance(
-                self.hass
-            ).async_add_executor_job(
-                get_last_statistics,  # type: ignore[arg-type]
-                self.hass,
-                1,
-                statistic_id,
-                True,  # noqa: FBT003
-                set(),
-            )
+            try:
+                last_stat: dict[str, list[dict[str, Any]]] = await get_instance(
+                    self.hass
+                ).async_add_executor_job(
+                    get_last_statistics,  # type: ignore[arg-type]
+                    self.hass,
+                    1,
+                    statistic_id,
+                    True,  # noqa: FBT003
+                    set(),
+                )
+            except HomeAssistantError:
+                last_stat = {}
             if not last_stat:
                 _LOGGER.debug(
                     "No existing statistics for %s, importing %d days",
@@ -171,17 +177,24 @@ def _on_failure(self) -> None:
 
     async def _insert_statistics(
         self,
-        records_by_contract: dict[str, list[ConsumptionRecord]],
+        data_by_contract: dict[str, ConsumptionData],
     ) -> None:
         """Import consumption records as external statistics."""
-        for contract_number, records in records_by_contract.items():
+        for contract_number, data in data_by_contract.items():
             try:
-                await self._insert_contract_statistics(contract_number, records)
+                await self._insert_contract_statistics(contract_number, data.records)
             except Exception:
                 _LOGGER.exception(
                     "Failed to insert statistics for contract %s",
                     contract_number,
                 )
+            try:
+                await self._insert_cost_statistics(contract_number, data)
+            except Exception:
+                _LOGGER.exception(
+                    "Failed to insert cost statistics for contract %s",
+                    contract_number,
+                )
 
     async def _insert_contract_statistics(
         self,
@@ -200,16 +213,20 @@ async def _insert_contract_statistics(
             unit_of_measurement=UnitOfVolume.CUBIC_METERS,
         )
 
-        last_stat: dict[str, list[dict[str, Any]]] = await get_instance(
-            self.hass
-        ).async_add_executor_job(
-            get_last_statistics,  # type: ignore[arg-type]
-            self.hass,
-            1,
-            statistic_id,
-            True,  # noqa: FBT003
-            set(),
-        )
+        try:
+            last_stat: dict[str, list[dict[str, Any]]] = await get_instance(
+                self.hass
+            ).async_add_executor_job(
+                get_last_statistics,  # type: ignore[arg-type]
+                self.hass,
+                1,
+                statistic_id,
+                True,  # noqa: FBT003
+                set(),
+            )
+        except HomeAssistantError:
+            _LOGGER.debug("No existing statistics for %s", statistic_id)
+            last_stat = {}
         last_stats_time: float | None = None
         if last_stat:
             raw_start = last_stat[statistic_id][0]["start"]
@@ -221,6 +238,8 @@ async def _insert_contract_statistics(
         local_tz = dt_util.get_default_time_zone()
         statistics: list[StatisticData] = []
         for record in sorted(records, key=lambda r: r.date):
+            if record.is_estimated:
+                continue
             d = record.date.date()
             start = datetime(d.year, d.month, d.day, tzinfo=local_tz)
             if last_stats_time is not None and start.timestamp() <= last_stats_time:
@@ -243,6 +262,76 @@ async def _insert_contract_statistics(
         else:
             _LOGGER.debug("No new statistics to insert for %s", statistic_id)
 
+    async def _insert_cost_statistics(
+        self,
+        contract_number: str,
+        data: ConsumptionData,
+    ) -> None:
+        """Import cost statistics for a single contract."""
+        statistic_id = f"{DOMAIN}:{contract_number}_water_cost"
+        metadata = StatisticMetaData(
+            mean_type=StatisticMeanType.NONE,
+            has_sum=True,
+            name=f"SEDIF {contract_number} water cost",
+            source=DOMAIN,
+            statistic_id=statistic_id,
+            unit_class=None,
+            unit_of_measurement="EUR",
+        )
+
+        last_stats_time: float | None = None
+        running_sum: float = 0.0
+        try:
+            last_stat: dict[str, list[dict[str, Any]]] = await get_instance(
+                self.hass
+            ).async_add_executor_job(
+                get_last_statistics,  # type: ignore[arg-type]
+                self.hass,
+                1,
+                statistic_id,
+                True,  # noqa: FBT003
+                {"sum"},
+            )
+        except HomeAssistantError:
+            _LOGGER.debug("No existing cost statistics for %s", statistic_id)
+            last_stat = {}
+        if last_stat:
+            raw_start = last_stat[statistic_id][0]["start"]
+            if isinstance(raw_start, (int, float)):
+                last_stats_time = raw_start
+            else:
+                last_stats_time = raw_start.timestamp()
+            running_sum = last_stat[statistic_id][0].get("sum", 0.0) or 0.0
+
+        local_tz = dt_util.get_default_time_zone()
+        statistics: list[StatisticData] = []
+        for record in sorted(data.records, key=lambda r: r.date):
+            if record.is_estimated:
+                continue
+            d = record.date.date()
+            start = datetime(d.year, d.month, d.day, tzinfo=local_tz)
+            if last_stats_time is not None and start.timestamp() <= last_stats_time:
+                continue
+            daily_cost = data.daily_cost(record)
+            running_sum += daily_cost
+            statistics.append(
+                StatisticData(
+                    start=start,
+                    state=daily_cost,
+                    sum=running_sum,
+                )
+            )
+
+        async_add_external_statistics(self.hass, metadata, statistics)
+        if statistics:
+            _LOGGER.debug(
+                "Inserted %d cost statistics for %s",
+                len(statistics),
+                statistic_id,
+            )
+        else:
+            _LOGGER.debug("No new cost statistics to insert for %s", statistic_id)
+
     @staticmethod
     async def _fetch_all(
         client: EauIDFClient,
@@ -252,18 +341,18 @@ async def _fetch_all(
         """Fetch consumption data for all contracts."""
         await client.login()
         sensor_data: SedifData = {}
-        all_records: dict[str, list[ConsumptionRecord]] = {}
+        all_data: dict[str, ConsumptionData] = {}
         end = datetime.now(UTC).date()
         for contract in contracts:
             cid = contract["id"]
             number = contract["number"]
             try:
-                records = await client.get_daily_consumption(
+                data = await client.get_daily_consumption(
                     contract_id=cid, start_date=start_date, end_date=end
                 )
-                if records:
-                    all_records[number] = records
-                    latest = records[-1]
+                if data.records:
+                    all_data[number] = data
+                    latest = data.records[-1]
                     sensor_data[number] = ContractData(
                         meter_reading_m3=latest.meter_reading,
                         daily_consumption_l=latest.consumption_liters,
@@ -282,4 +371,4 @@ async def _fetch_all(
         if not sensor_data and contracts:
             msg = "Failed to fetch data for any contract"
             raise EauIDFError(msg)
-        return sensor_data, all_records
+        return sensor_data, all_data

custom_components/eauidf/manifest.json

@@ -8,6 +8,6 @@
   "iot_class": "cloud_polling",
   "issue_tracker": "https://github.com/TimoPtr/ha_eauidf/issues",
   "quality_scale": "platinum",
-  "requirements": ["pyeauidf==1.0.1"],
+  "requirements": ["pyeauidf==1.2.0"],
   "version": "1.0.1"
 }

custom_components/eauidf/sensor.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING
 
 from homeassistant.components.sensor import (
     SensorDeviceClass,
@@ -22,6 +22,7 @@
 
 if TYPE_CHECKING:
     from collections.abc import Callable
+    from datetime import date
 
     from homeassistant.core import HomeAssistant
     from homeassistant.helpers.entity_platform import AddEntitiesCallback
@@ -33,7 +34,7 @@
 class SedifSensorDescription(SensorEntityDescription):
     """Describe a SEDIF sensor."""
 
-    value_fn: Callable[[ContractData], Any]
+    value_fn: Callable[[ContractData], float | date]
     has_extra_attributes: bool = False
 
 
@@ -118,7 +119,7 @@ def __init__(
         )
 
     @property
-    def native_value(self) -> Any:
+    def native_value(self) -> float | date | None:
         """Return the sensor value."""
         if not self.coordinator.data:
             return None

pyproject.toml

@@ -2,7 +2,7 @@
 name = "ha-eauidf"
 version = "1.0.1"
 requires-python = ">=3.14"
-dependencies = ["pyeauidf==1.0.0"]
+dependencies = ["pyeauidf==1.2.0"]
 
 [project.optional-dependencies]
 test = [

tests/conftest.py

@@ -27,8 +27,9 @@ def mock_recorder_before_hass(recorder_db_url: str) -> None:
 MOCK_USERNAME = "test@example.com"
 MOCK_PASSWORD = "secret"
 MOCK_CONTRACT_ID = "CONTRACT_001"
-MOCK_CONTRACT_NUMBER = "9235380"
+MOCK_CONTRACT_NUMBER = "1234567"
 MOCK_CONTRACTS = [{"id": MOCK_CONTRACT_ID, "number": MOCK_CONTRACT_NUMBER}]
+MOCK_PRICE_PER_M3 = 4.5
 
 
 @pytest.fixture
@@ -74,6 +75,23 @@ def make_consumption_record(
     return record
 
 
+def make_consumption_data(
+    records: list[MagicMock], price_per_m3: float = MOCK_PRICE_PER_M3
+) -> MagicMock:
+    """Create a mock ConsumptionData with records and price."""
+    data = MagicMock()
+    data.records = records
+    data.price_per_m3 = price_per_m3
+    data.daily_cost = lambda record: (record.consumption_liters / 1000) * price_per_m3
+    return data
+
+
+@pytest.fixture
+def mock_consumption_data(mock_record: MagicMock) -> MagicMock:
+    """Single-record ConsumptionData mock."""
+    return make_consumption_data([mock_record])
+
+
 @pytest.fixture
 def mock_records_list() -> list[MagicMock]:
     base = date(2026, 5, 11)
@@ -82,3 +100,9 @@ def mock_records_list() -> list[MagicMock]:
         make_consumption_record(base + timedelta(days=1), 120.0, 1234.12),
         make_consumption_record(base + timedelta(days=2), 150.0, 1234.27),
     ]
+
+
+@pytest.fixture
+def mock_consumption_data_list(mock_records_list: list[MagicMock]) -> MagicMock:
+    """Multi-record ConsumptionData mock."""
+    return make_consumption_data(mock_records_list)