gazpar2haws 0.3.2__py3-none-any.whl → 0.4.0__py3-none-any.whl

gazpar2haws/datetime_utils.py

@@ -0,0 +1,104 @@
+"""Utility functions for datetime conversions."""
+
+from datetime import date, datetime
+
+import pytz
+
+
+def timestamp_ms_to_datetime(timestamp_ms: int | float | str, timezone: str | None = None) -> datetime:
+    """
+    Convert Unix timestamp in milliseconds to a datetime object.
+
+    This is the base conversion function used by other timestamp utilities.
+
+    Args:
+        timestamp_ms: Unix timestamp in milliseconds (as int, float, or string)
+        timezone: Optional timezone string for timezone-aware datetime.
+                 If provided, creates datetime in that timezone.
+                 If not provided, uses UTC (default Home Assistant behavior).
+
+    Returns:
+        datetime object in the specified timezone or UTC
+    """
+    # Convert to seconds
+    timestamp_seconds = int(str(timestamp_ms)) / 1000
+    # Convert to specified timezone or UTC
+    if timezone:
+        return datetime.fromtimestamp(timestamp_seconds, tz=pytz.timezone(timezone))
+    return datetime.fromtimestamp(timestamp_seconds, tz=pytz.UTC)
+
+
+def timestamp_ms_to_iso_string(timestamp_ms: int | float | str, timezone: str | None = None) -> str:
+    """
+    Convert Unix timestamp in milliseconds to ISO format string.
+
+    This is used for converting Home Assistant statistics timestamps
+    (which are in milliseconds) to ISO format strings expected by
+    the import_statistics API.
+
+    Args:
+        timestamp_ms: Unix timestamp in milliseconds (as int, float, or string)
+        timezone: Optional timezone string for timezone-aware conversion.
+                 If provided, converts to that timezone before returning ISO format.
+                 If not provided, uses UTC (default Home Assistant behavior).
+
+    Returns:
+        ISO format string (e.g., "2020-12-14T00:00:00+00:00")
+    """
+    dt = timestamp_ms_to_datetime(timestamp_ms, timezone)
+    return dt.isoformat()
+
+
+def timestamp_ms_to_date(timestamp_ms: int | float | str, timezone: str) -> date:
+    """
+    Convert Unix timestamp in milliseconds to a date in the specified timezone.
+
+    This is used for extracting the date portion of Home Assistant statistics
+    timestamps while respecting the local timezone.
+
+    Args:
+        timestamp_ms: Unix timestamp in milliseconds (as int, float, or string)
+        timezone: Timezone string (e.g., "Europe/Paris")
+
+    Returns:
+        Date object in the specified timezone
+    """
+    dt = timestamp_ms_to_datetime(timestamp_ms, timezone)
+    return dt.date()
+
+
+def convert_statistics_timestamps(statistics: list[dict], timezone: str | None = None) -> list[dict]:
+    """
+    Convert all timestamp fields in statistics from Unix milliseconds to ISO format strings.
+
+    Home Assistant statistics_during_period API returns timestamps as Unix milliseconds,
+    but the import_statistics API expects ISO format strings.
+
+    Converts these fields if they exist:
+    - "start": The start time of the statistics period
+    - "end": The end time of the statistics period (if present)
+
+    Args:
+        statistics: List of statistics dictionaries with timestamp fields
+        timezone: Optional timezone string for timezone-aware conversion.
+                 If provided, converts to that timezone before returning ISO format.
+                 If not provided, uses UTC (default Home Assistant behavior).
+
+    Returns:
+        List of statistics dictionaries with converted timestamps
+    """
+    converted_statistics = []
+    for stat in statistics:
+        converted_stat = stat.copy()
+
+        # Convert start timestamp if present
+        if "start" in converted_stat:
+            converted_stat["start"] = timestamp_ms_to_iso_string(converted_stat["start"], timezone)
+
+        # Convert end timestamp if present (for statistics that have it)
+        if "end" in converted_stat:
+            converted_stat["end"] = timestamp_ms_to_iso_string(converted_stat["end"], timezone)
+
+        converted_statistics.append(converted_stat)
+
+    return converted_statistics

gazpar2haws/gazpar.py

@@ -8,6 +8,7 @@ import pytz
 from pygazpar.datasource import MeterReadings  # type: ignore
 
 from gazpar2haws.date_array import DateArray
+from gazpar2haws.datetime_utils import timestamp_ms_to_date
 from gazpar2haws.haws import HomeAssistantWS, HomeAssistantWSException
 from gazpar2haws.model import (
     ConsumptionQuantityArray,
@@ -91,12 +92,46 @@ class Gazpar:
         # Volume, energy and cost sensor names.
         volume_sensor_name = f"sensor.{self._name}_volume"
         energy_sensor_name = f"sensor.{self._name}_energy"
-        cost_sensor_name = f"sensor.{self._name}_cost"
+        consumption_cost_sensor_name = f"sensor.{self._name}_consumption_cost"
+        subscription_cost_sensor_name = f"sensor.{self._name}_subscription_cost"
+        transport_cost_sensor_name = f"sensor.{self._name}_transport_cost"
+        energy_taxes_cost_sensor_name = f"sensor.{self._name}_energy_taxes_cost"
+        total_cost_sensor_name = f"sensor.{self._name}_total_cost"
+
+        # Automatic migration from v0.3.x to v0.4.0
+        # Migrate old sensor.{name}_cost to sensor.{name}_total_cost if pricing is enabled
+        if self._pricing_config is not None:
+            try:
+                old_total_cost_sensor_name = f"sensor.{self._name}_cost"
+                await self._homeassistant.migrate_statistic(
+                    old_entity_id=old_total_cost_sensor_name,
+                    new_entity_id=total_cost_sensor_name,
+                    new_name="Gazpar2HAWS Total Cost",
+                    unit_of_measurement="€",
+                    timezone=self._timezone,
+                    as_of_date=as_of_date,
+                )
+            except Exception:  # pylint: disable=broad-except
+                Logger.warning(
+                    f"Error during automatic sensor migration from "
+                    f"{old_total_cost_sensor_name} to {total_cost_sensor_name}: "
+                    f"{traceback.format_exc()}"
+                )
 
         # Eventually reset the sensor in Home Assistant
         if self._reset:
             try:
-                await self._homeassistant.clear_statistics([volume_sensor_name, energy_sensor_name])
+                await self._homeassistant.clear_statistics(
+                    [
+                        volume_sensor_name,
+                        energy_sensor_name,
+                        consumption_cost_sensor_name,
+                        subscription_cost_sensor_name,
+                        transport_cost_sensor_name,
+                        energy_taxes_cost_sensor_name,
+                        total_cost_sensor_name,
+                    ]
+                )
             except Exception:
                 Logger.warning(f"Error while resetting the sensor in Home Assistant: {traceback.format_exc()}")
                 raise
@@ -105,7 +140,21 @@ class Gazpar:
 
         last_date_and_value_by_sensor[volume_sensor_name] = await self.find_last_date_and_value(volume_sensor_name)
         last_date_and_value_by_sensor[energy_sensor_name] = await self.find_last_date_and_value(energy_sensor_name)
-        last_date_and_value_by_sensor[cost_sensor_name] = await self.find_last_date_and_value(cost_sensor_name)
+        last_date_and_value_by_sensor[consumption_cost_sensor_name] = await self.find_last_date_and_value(
+            consumption_cost_sensor_name
+        )
+        last_date_and_value_by_sensor[subscription_cost_sensor_name] = await self.find_last_date_and_value(
+            subscription_cost_sensor_name
+        )
+        last_date_and_value_by_sensor[transport_cost_sensor_name] = await self.find_last_date_and_value(
+            transport_cost_sensor_name
+        )
+        last_date_and_value_by_sensor[energy_taxes_cost_sensor_name] = await self.find_last_date_and_value(
+            energy_taxes_cost_sensor_name
+        )
+        last_date_and_value_by_sensor[total_cost_sensor_name] = await self.find_last_date_and_value(
+            total_cost_sensor_name
+        )
 
         # Compute the start date as the minimum of the last dates plus one day
         start_date = min(min(v[0] for v in last_date_and_value_by_sensor.values()) + timedelta(days=1), as_of_date)
@@ -113,12 +162,34 @@ class Gazpar:
         # Get all start dates
         energy_start_date = last_date_and_value_by_sensor[energy_sensor_name][0] + timedelta(days=1)
         volume_start_date = last_date_and_value_by_sensor[volume_sensor_name][0] + timedelta(days=1)
-        cost_start_date = last_date_and_value_by_sensor[cost_sensor_name][0] + timedelta(days=1)
+        consumption_cost_start_date = last_date_and_value_by_sensor[consumption_cost_sensor_name][0] + timedelta(days=1)
+        subscription_cost_start_date = last_date_and_value_by_sensor[subscription_cost_sensor_name][0] + timedelta(
+            days=1
+        )
+        transport_cost_start_date = last_date_and_value_by_sensor[transport_cost_sensor_name][0] + timedelta(days=1)
+        energy_taxes_cost_start_date = last_date_and_value_by_sensor[energy_taxes_cost_sensor_name][0] + timedelta(
+            days=1
+        )
+        total_cost_start_date = last_date_and_value_by_sensor[total_cost_sensor_name][0] + timedelta(days=1)
+
+        # Get the minimum cost start date
+        cost_start_date = min(
+            consumption_cost_start_date,
+            subscription_cost_start_date,
+            transport_cost_start_date,
+            energy_taxes_cost_start_date,
+            total_cost_start_date,
+        )
 
         Logger.debug(f"Min start date for all sensors: {start_date}")
         Logger.debug(f"Energy start date: {energy_start_date}")
         Logger.debug(f"Volume start date: {volume_start_date}")
-        Logger.debug(f"Cost start date: {cost_start_date}")
+        Logger.debug(f"Consumption cost start date: {consumption_cost_start_date}")
+        Logger.debug(f"Subscription cost start date: {subscription_cost_start_date}")
+        Logger.debug(f"Transport cost start date: {transport_cost_start_date}")
+        Logger.debug(f"Energy taxes cost start date: {energy_taxes_cost_start_date}")
+        Logger.debug(f"Total cost start date: {total_cost_start_date}")
+        Logger.debug(f"Min cost start date: {cost_start_date}")
 
         # Fetch the data from GrDF and publish it to Home Assistant
         daily_history = self.fetch_daily_gazpar_history(start_date, as_of_date)
@@ -151,6 +222,7 @@ class Gazpar:
         if volume_array is not None:
             await self.publish_date_array(
                 volume_sensor_name,
+                "Gazpar2HAWS Volume",
                 "m³",
                 volume_array,
                 last_date_and_value_by_sensor[volume_sensor_name][1],
@@ -161,6 +233,7 @@ class Gazpar:
         if energy_array is not None and energy_start_date <= end_date:
             await self.publish_date_array(
                 energy_sensor_name,
+                "Gazpar2HAWS Energy",
                 "kWh",
                 energy_array[energy_start_date : end_date + timedelta(days=1)],
                 last_date_and_value_by_sensor[energy_sensor_name][1],
@@ -184,18 +257,55 @@ class Gazpar:
                 value_array=energy_array[cost_start_date : end_date + timedelta(days=1)],
             )
 
-            cost_array = pricer.compute(quantities, PriceUnit.EURO)
+            cost_breakdown = pricer.compute(quantities, PriceUnit.EURO)
         else:
-            cost_array = None
+            cost_breakdown = None
+
+        # Publish the cost breakdown to Home Assistant
+        if cost_breakdown is not None:
+            # Publish consumption cost
+            await self.publish_date_array(
+                consumption_cost_sensor_name,
+                "Gazpar2HAWS Consumption Cost",
+                cost_breakdown.consumption.value_unit,
+                cost_breakdown.consumption.value_array,
+                last_date_and_value_by_sensor[consumption_cost_sensor_name][1],
+            )
+
+            # Publish subscription cost
+            await self.publish_date_array(
+                subscription_cost_sensor_name,
+                "Gazpar2HAWS Subscription Cost",
+                cost_breakdown.subscription.value_unit,
+                cost_breakdown.subscription.value_array,
+                last_date_and_value_by_sensor[subscription_cost_sensor_name][1],
+            )
+
+            # Publish transport cost
+            await self.publish_date_array(
+                transport_cost_sensor_name,
+                "Gazpar2HAWS Transport Cost",
+                cost_breakdown.transport.value_unit,
+                cost_breakdown.transport.value_array,
+                last_date_and_value_by_sensor[transport_cost_sensor_name][1],
+            )
+
+            # Publish energy taxes cost
+            await self.publish_date_array(
+                energy_taxes_cost_sensor_name,
+                "Gazpar2HAWS Energy Taxes Cost",
+                cost_breakdown.energy_taxes.value_unit,
+                cost_breakdown.energy_taxes.value_array,
+                last_date_and_value_by_sensor[energy_taxes_cost_sensor_name][1],
+            )
 
-        # Publish the cost to Home Assistant
-        if cost_array is not None:
-            cost_initial_value = last_date_and_value_by_sensor[cost_sensor_name][1]
+            # Publish total cost
             await self.publish_date_array(
-                cost_sensor_name,
-                cost_array.value_unit,
-                cost_array.value_array,
-                cost_initial_value,
+                total_cost_sensor_name,
+                "Gazpar2HAWS Total Cost",
+                cost_breakdown.total.value_unit,
+                cost_breakdown.total.value_array,
+                last_date_and_value_by_sensor[total_cost_sensor_name][1],
             )
         else:
             Logger.info("No cost data to publish")
@@ -276,6 +386,7 @@ class Gazpar:
     async def publish_date_array(
         self,
         entity_id: str,
+        entity_name: str,
         unit_of_measurement: str,
         date_array: DateArray,
         initial_value: float,
@@ -298,7 +409,7 @@ class Gazpar:
         # Publish statistics to Home Assistant
         try:
             await self._homeassistant.import_statistics(
-                entity_id, "recorder", "gazpar2haws", unit_of_measurement, statistics
+                entity_id, "recorder", entity_name, unit_of_measurement, statistics
             )
         except Exception:
             Logger.warning(f"Error while importing statistics to Home Assistant: {traceback.format_exc()}")
@@ -353,10 +464,7 @@ class Gazpar:
 
             if last_statistic:
                 # Extract the end date of the last statistics from the unix timestamp
-                last_date = datetime.fromtimestamp(
-                    int(str(last_statistic.get("start"))) / 1000,
-                    tz=pytz.timezone(self._timezone),
-                ).date()
+                last_date = timestamp_ms_to_date(last_statistic.get("start"), self._timezone)  # type: ignore[arg-type]
 
                 # Get the last meter value
                 last_value = float(str(last_statistic.get("sum")))

gazpar2haws/haws.py

@@ -1,9 +1,12 @@
 import json
 import logging
-from datetime import datetime, timedelta
+from datetime import date, datetime, timedelta
 
+import pytz
 import websockets
 
+from gazpar2haws.datetime_utils import convert_statistics_timestamps
+
 Logger = logging.getLogger(__name__)
 
 
@@ -225,3 +228,112 @@ class HomeAssistantWS:
         await self.send_message(clear_statistics_message)
 
         Logger.debug(f"Cleared {entity_ids} statistics")
+
+    # ----------------------------------
+    async def migrate_statistic(
+        self,
+        old_entity_id: str,
+        new_entity_id: str,
+        new_name: str,
+        unit_of_measurement: str,
+        timezone: str,
+        as_of_date: date,
+    ) -> bool:
+        """
+        Migrate statistics from an old sensor to a new sensor.
+
+        This implements smart detection logic:
+        - If old sensor exists but new doesn't: AUTO-MIGRATE data
+        - If both exist: SKIP with warning (prevent data loss)
+        - If only new exists: SKIP (normal operation, no old data)
+        - On error: LOG WARNING and return False (graceful fallback)
+
+        Args:
+            old_entity_id: Source sensor ID (e.g., sensor.gazpar2haws_cost)
+            new_entity_id: Target sensor ID (e.g., sensor.gazpar2haws_total_cost)
+            new_name: Display name for the new sensor
+            unit_of_measurement: Unit for the new sensor (e.g., "€")
+            timezone: Timezone string (e.g., "Europe/Paris")
+            as_of_date: Latest date to query for migration
+
+        Returns:
+            True if migration was successful or skipped safely, False on error
+        """
+        try:
+            Logger.debug(f"Checking for migration opportunity: {old_entity_id} → {new_entity_id}")
+
+            # Create timezone-aware datetime objects
+            tz = pytz.timezone(timezone)
+
+            # Convert as_of_date to datetime at start of day (00:00:00) in target timezone
+            as_of_datetime = tz.localize(datetime.combine(as_of_date, datetime.min.time()))
+
+            # Very old date to capture all historical data (10 years back from as_of_date)
+            very_old_datetime = as_of_datetime - timedelta(days=3650)
+
+            # Check if old and new sensors have data using statistics_during_period
+            # This is more reliable than list_statistic_ids which may have caching delays
+            old_statistics_data = await self.statistics_during_period(
+                [old_entity_id], very_old_datetime, as_of_datetime
+            )
+
+            old_has_data = old_entity_id in old_statistics_data and old_statistics_data[old_entity_id]
+
+            # Decision logic
+            if not old_has_data:
+                Logger.debug(f"Old sensor {old_entity_id} does not exist or has no data - no migration needed")
+                return True
+
+            # Query new sensor to check if it already has data
+            new_statistics_data = await self.statistics_during_period(
+                [new_entity_id], very_old_datetime, as_of_datetime
+            )
+
+            new_has_data = new_entity_id in new_statistics_data and new_statistics_data[new_entity_id]
+
+            if new_has_data:
+                Logger.warning(
+                    f"Both old sensor {old_entity_id} and new sensor {new_entity_id} have data. "
+                    f"Skipping migration to prevent data loss. Old sensor can be manually deleted if desired."
+                )
+                return True
+
+            # At this point: old has data AND new doesn't → MIGRATE
+            Logger.info(f"Starting automatic migration: {old_entity_id} → {new_entity_id}")
+
+            old_statistics = old_statistics_data[old_entity_id]
+            Logger.debug(f"Found {len(old_statistics)} statistics entries to migrate from {old_entity_id}")
+
+            # Remove 'change' and 'end' fields from old statistics as they are not accepted by import_statistics
+            for stat in old_statistics:
+                if "change" in stat:
+                    del stat["change"]
+                if "end" in stat:
+                    del stat["end"]
+
+            # Convert start and end timestamps from Unix milliseconds to ISO format strings
+            # because import_statistics expects ISO format (using timezone for consistency)
+            converted_statistics = convert_statistics_timestamps(old_statistics, timezone)
+
+            # Import the statistics to the new sensor with same metadata
+            await self.import_statistics(
+                entity_id=new_entity_id,
+                source="recorder",
+                name=new_name,
+                unit_of_measurement=unit_of_measurement,
+                statistics=converted_statistics,
+            )
+
+            Logger.info(
+                f"Successfully migrated {len(old_statistics)} statistics entries "
+                f"from {old_entity_id} to {new_entity_id}. "
+                f"Old sensor can be deleted manually if desired."
+            )
+            return True
+
+        except Exception as exc:  # pylint: disable=broad-except
+            Logger.warning(
+                f"Error during statistic migration from {old_entity_id} to {new_entity_id}: {exc}. "
+                f"Continuing without migration (data is preserved in old sensor)."
+            )
+            return False

gazpar2haws/model.py

@@ -1,9 +1,10 @@
+import tempfile
 from datetime import date
 from enum import Enum
 from pathlib import Path
 from typing import Generic, Optional, TypeVar
 
-from pydantic import BaseModel, DirectoryPath, EmailStr, SecretStr, model_validator
+from pydantic import BaseModel, EmailStr, SecretStr, model_validator
 from pydantic_extra_types.timezone_name import TimeZoneName
 
 from gazpar2haws.date_array import DateArray
@@ -53,7 +54,7 @@ class Logging(BaseModel):
 class Device(BaseModel):
     name: str
     data_source: str = "json"
-    tmp_dir: DirectoryPath = DirectoryPath("/tmp")
+    tmp_dir: Optional[str] = None  # If None, will use system temp directory
     as_of_date: Optional[date] = None
     username: Optional[EmailStr] = None
     password: Optional[SecretStr] = None
@@ -72,8 +73,15 @@ class Device(BaseModel):
             raise ValueError("Missing password")
         if self.data_source != "test" and self.pce_identifier is None:
             raise ValueError("Missing pce_identifier")
-        if self.data_source == "excel" and self.tmp_dir is None or not Path(self.tmp_dir).is_dir():
+
+        # Set tmp_dir to system temp directory if not specified
+        if self.tmp_dir is None:
+            self.tmp_dir = tempfile.gettempdir()
+
+        # Validate tmp_dir exists for excel data source
+        if self.data_source == "excel" and not Path(self.tmp_dir).is_dir():
             raise ValueError(f"Invalid tmp_dir {self.tmp_dir}")
+
         return self
 
 
@@ -148,6 +156,20 @@ class Price(Unit[ValueUnit, BaseUnit]):  # pylint: disable=too-few-public-method
     vat_id: Optional[str] = None
 
 
+# ----------------------------------
+class CompositePriceValue(Period):
+    price_unit: Optional[PriceUnit] = None  # € or ¢ (applies to both components)
+    vat_id: Optional[str] = None
+
+    # Quantity component (€/kWh)
+    quantity_value: Optional[float] = None
+    quantity_unit: Optional[QuantityUnit] = None
+
+    # Time component (€/month)
+    time_value: Optional[float] = None
+    time_unit: Optional[TimeUnit] = None
+
+
 # ----------------------------------
 class PriceValue(Price[ValueUnit, BaseUnit], Value):
     pass
@@ -178,17 +200,51 @@ class EnergyTaxesPriceArray(PriceValueArray[PriceUnit, QuantityUnit]):  # pylint
     pass
 
 
+# ----------------------------------
+class CompositePriceArray(Period):  # pylint: disable=too-few-public-methods
+    name: Optional[str] = None
+    price_unit: Optional[PriceUnit] = None
+    vat_id: Optional[str] = None
+
+    # Quantity component (€/kWh) - vectorized
+    quantity_value_array: Optional[DateArray] = None
+    quantity_unit: Optional[QuantityUnit] = None
+
+    # Time component (€/month) - vectorized
+    time_value_array: Optional[DateArray] = None
+    time_unit: Optional[TimeUnit] = None
+
+    @model_validator(mode="after")
+    def set_value_arrays(self):
+        if self.quantity_value_array is None:
+            self.quantity_value_array = DateArray(
+                name=f"{self.name}_quantity", start_date=self.start_date, end_date=self.end_date
+            )  # pylint: disable=attribute-defined-outside-init
+        if self.time_value_array is None:
+            self.time_value_array = DateArray(
+                name=f"{self.name}_time", start_date=self.start_date, end_date=self.end_date
+            )  # pylint: disable=attribute-defined-outside-init
+        return self
+
+
 # ----------------------------------
 class Pricing(BaseModel):
     vat: Optional[list[VatRate]] = None
-    consumption_prices: list[PriceValue[PriceUnit, QuantityUnit]]
-    subscription_prices: Optional[list[PriceValue[PriceUnit, TimeUnit]]] = None
-    transport_prices: Optional[list[PriceValue[PriceUnit, TimeUnit]]] = None
-    energy_taxes: Optional[list[PriceValue[PriceUnit, QuantityUnit]]] = None
+    consumption_prices: list[CompositePriceValue]
+    subscription_prices: Optional[list[CompositePriceValue]] = None
+    transport_prices: Optional[list[CompositePriceValue]] = None
+    energy_taxes: Optional[list[CompositePriceValue]] = None
 
     @model_validator(mode="before")
     @classmethod
     def propagates_properties(cls, values):
+        # Default units for all price types
+        default_units = {
+            "price_unit": "€",
+            "quantity_unit": "kWh",
+            "time_unit": "month",
+        }
+
         for price_list in [
             "consumption_prices",
             "subscription_prices",
@@ -202,23 +258,19 @@ class Pricing(BaseModel):
 
             if "start_date" not in prices[0]:
                 raise ValueError(f"Missing start_date in first element of {price_list}")
-            if "value_unit" not in prices[0]:
-                prices[0]["value_unit"] = "€"
-            if "base_unit" not in prices[0]:
-                if price_list in ["consumption_prices", "energy_taxes"]:
-                    prices[0]["base_unit"] = "kWh"
-                else:
-                    raise ValueError(
-                        "Missing base_unit in first element of ['transport_prices', 'subscription_prices']"
-                    )
 
+            # Apply defaults to first entry
+            for key, default_value in default_units.items():
+                if key not in prices[0]:
+                    prices[0][key] = default_value
+
+            # Propagate properties through the list
             for i in range(len(prices) - 1):
                 if "end_date" not in prices[i]:
                     prices[i]["end_date"] = prices[i + 1]["start_date"]
-                if "value_unit" not in prices[i + 1]:
-                    prices[i + 1]["value_unit"] = prices[i]["value_unit"]
-                if "base_unit" not in prices[i + 1]:
-                    prices[i + 1]["base_unit"] = prices[i]["base_unit"]
+                for key, default_value in default_units.items():
+                    if key not in prices[i + 1]:
+                        prices[i + 1][key] = prices[i][key]
                 if "vat_id" not in prices[i + 1] and "vat_id" in prices[i]:
                     prices[i + 1]["vat_id"] = prices[i]["vat_id"]
 
@@ -233,3 +285,14 @@ class ConsumptionQuantityArray(Unit[QuantityUnit, TimeUnit], ValueArray):
 # ----------------------------------
 class CostArray(Unit[PriceUnit, TimeUnit], ValueArray):
     pass
+
+
+# ----------------------------------
+class CostBreakdown(BaseModel):
+    """Detailed breakdown of costs with individual components and total."""
+
+    consumption: CostArray
+    subscription: CostArray
+    transport: CostArray
+    energy_taxes: CostArray
+    total: CostArray