codecarbon 3.2.0__tar.gz → 3.2.2__tar.gz

{codecarbon-3.2.0 → codecarbon-3.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codecarbon
-Version: 3.2.0
+Version: 3.2.2
 Author: Mila, DataForGood, BCG GAMMA, Comet.ml, Haverford College
 License-Expression: MIT
 Project-URL: Homepage, https://codecarbon.io/
@@ -36,20 +36,14 @@ Requires-Dist: requests
 Requires-Dist: questionary
 Requires-Dist: rich
 Requires-Dist: typer
+Provides-Extra: carbonboard
+Requires-Dist: dash; extra == "carbonboard"
+Requires-Dist: dash_bootstrap_components>1.0.0; extra == "carbonboard"
+Requires-Dist: fire; extra == "carbonboard"
 Provides-Extra: viz-legacy
 Requires-Dist: dash; extra == "viz-legacy"
 Requires-Dist: dash_bootstrap_components>1.0.0; extra == "viz-legacy"
 Requires-Dist: fire; extra == "viz-legacy"
-Provides-Extra: viz
-Requires-Dist: mock; extra == "viz"
-Requires-Dist: pytest; extra == "viz"
-Requires-Dist: responses; extra == "viz"
-Requires-Dist: numpy<2.0.0; python_version < "3.9" and extra == "viz"
-Requires-Dist: numpy; python_version >= "3.9" and extra == "viz"
-Requires-Dist: psutil; extra == "viz"
-Requires-Dist: requests-mock; extra == "viz"
-Requires-Dist: rapidfuzz; extra == "viz"
-Requires-Dist: importlib_resources; python_version < "3.9" and extra == "viz"
 Provides-Extra: api
 Requires-Dist: alembic<2.0.0; extra == "api"
 Requires-Dist: bcrypt<5.0.0; extra == "api"
@@ -67,6 +61,7 @@ Requires-Dist: fastapi-pagination<1.0.0; extra == "api"
 Requires-Dist: pytest; extra == "api"
 Requires-Dist: mock; extra == "api"
 Requires-Dist: responses; extra == "api"
+Requires-Dist: fastapi-oidc; python_version >= "3.10" and extra == "api"
 Requires-Dist: numpy; extra == "api"
 Requires-Dist: psutil; extra == "api"
 Requires-Dist: requests-mock; extra == "api"
@@ -90,8 +85,6 @@ CodeCarbon websites:
 
 <br/>
 
-[![](https://anaconda.org/conda-forge/codecarbon/badges/version.svg)](https://anaconda.org/conda-forge/codecarbon)
-[![](https://anaconda.org/codecarbon/codecarbon/badges/version.svg)](https://anaconda.org/codecarbon/codecarbon)
 [![](https://img.shields.io/pypi/v/codecarbon?color=024758)](https://pypi.org/project/codecarbon/)
 [![DOI](https://zenodo.org/badge/263364731.svg)](https://zenodo.org/badge/latestdoi/263364731)
 <!-- [![Downloads](https://static.pepy.tech/badge/codecarbon/month)](https://pepy.tech/project/codecarbon) -->
@@ -140,10 +133,13 @@ Our hope is that this package will be used widely for estimating the carbon foot
 pip install codecarbon
 ```
 
-**From Conda repository**
-```python
-conda install -c codecarbon codecarbon
+**Using Conda environments**
+If you're using Conda, you can install CodeCarbon with pip in your Conda environment:
+```bash
+conda activate your_env
+pip install codecarbon
 ```
+
 To see more installation options please refer to the documentation: [**Installation**](https://mlco2.github.io/codecarbon/installation.html#)
 
 ## Start to estimate your impact 📏
@@ -183,6 +179,12 @@ In your command prompt use:
 ```codecarbon monitor```
 The package will track your emissions independently from your code.
 
+### Detecting your hardware 🔍
+
+In your command prompt use:
+```codecarbon detect```
+The package will detect and print your hardware information (RAM, CPU, GPU).
+
 ### In your Python code 🐍
 ```python
 from codecarbon import track_emissions

{codecarbon-3.2.0 → codecarbon-3.2.2}/README.md

@@ -13,8 +13,6 @@ CodeCarbon websites:
 
 <br/>
 
-[![](https://anaconda.org/conda-forge/codecarbon/badges/version.svg)](https://anaconda.org/conda-forge/codecarbon)
-[![](https://anaconda.org/codecarbon/codecarbon/badges/version.svg)](https://anaconda.org/codecarbon/codecarbon)
 [![](https://img.shields.io/pypi/v/codecarbon?color=024758)](https://pypi.org/project/codecarbon/)
 [![DOI](https://zenodo.org/badge/263364731.svg)](https://zenodo.org/badge/latestdoi/263364731)
 <!-- [![Downloads](https://static.pepy.tech/badge/codecarbon/month)](https://pepy.tech/project/codecarbon) -->
@@ -63,10 +61,13 @@ Our hope is that this package will be used widely for estimating the carbon foot
 pip install codecarbon
 ```
 
-**From Conda repository**
-```python
-conda install -c codecarbon codecarbon
+**Using Conda environments**
+If you're using Conda, you can install CodeCarbon with pip in your Conda environment:
+```bash
+conda activate your_env
+pip install codecarbon
 ```
+
 To see more installation options please refer to the documentation: [**Installation**](https://mlco2.github.io/codecarbon/installation.html#)
 
 ## Start to estimate your impact 📏
@@ -106,6 +107,12 @@ In your command prompt use:
 ```codecarbon monitor```
 The package will track your emissions independently from your code.
 
+### Detecting your hardware 🔍
+
+In your command prompt use:
+```codecarbon detect```
+The package will detect and print your hardware information (RAM, CPU, GPU).
+
 ### In your Python code 🐍
 ```python
 from codecarbon import track_emissions

codecarbon-3.2.2/codecarbon/_version.py

@@ -0,0 +1 @@
+__version__ = "3.2.2"

{codecarbon-3.2.0 → codecarbon-3.2.2}/codecarbon/cli/main.py

@@ -413,6 +413,31 @@ def monitor(
         raise e
 
 
+@codecarbon.command("detect", short_help="Detect hardware and print information.")
+def detect():
+    """
+    Detects hardware and prints information without running any measurements.
+    """
+    print("Detecting hardware...")
+    tracker = EmissionsTracker(save_to_file=False)
+    hardware_info = tracker.get_detected_hardware()
+
+    print("\nDetected Hardware and System Information:")
+    print(f"- Available RAM: {hardware_info['ram_total_size']:.3f} GB")
+    print(
+        f"- CPU count: {hardware_info['cpu_count']} thread(s) in {hardware_info['cpu_physical_count']} physical CPU(s)"
+    )
+    print(f"- CPU model: {hardware_info['cpu_model']}")
+    print(f"- GPU count: {hardware_info['gpu_count']}")
+
+    gpu_model_str = hardware_info["gpu_model"]
+    if hardware_info.get("gpu_ids"):
+        gpu_model_str += (
+            f" BUT only tracking these GPU ids : {hardware_info['gpu_ids']}"
+        )
+    print(f"- GPU model: {gpu_model_str}")
+
+
 def questionary_prompt(prompt, list_options, default):
     value = questionary.select(
         prompt,

{codecarbon-3.2.0 → codecarbon-3.2.2}/codecarbon/core/gpu.py

@@ -141,7 +141,11 @@ class GPUDevice:
         """Returns memory info in bytes
         https://docs.nvidia.com/deploy/nvml-api/group__nvmlDeviceQueries.html#group__nvmlDeviceQueries_1g2dfeb1db82aa1de91aa6edf941c85ca8
         """
-        return pynvml.nvmlDeviceGetMemoryInfo(self.handle)
+        try:
+            return pynvml.nvmlDeviceGetMemoryInfo(self.handle)
+        except pynvml.NVMLError_NotSupported:
+            # error thrown for the NVIDIA Blackwell GPU of DGX Spark, due to memory sharing -> return defaults instead
+            return pynvml.c_nvmlMemory_t(-1, -1, -1)
 
     def _get_temperature(self) -> int:
         """Returns degrees in the Celsius scale

{codecarbon-3.2.0 → codecarbon-3.2.2}/codecarbon/core/util.py

@@ -3,6 +3,7 @@ import re
 import subprocess
 import sys
 from contextlib import contextmanager
+from functools import lru_cache
 from os.path import expandvars
 from pathlib import Path
 from typing import Optional, Union
@@ -73,7 +74,8 @@ def backup(file_path: Union[str, Path], ext: Optional[str] = ".bak") -> None:
     file_path.rename(backup_path)
 
 
-def detect_cpu_model() -> str:
+@lru_cache(maxsize=1)
+def detect_cpu_model() -> Optional[str]:
     cpu_info = cpuinfo.get_cpu_info()
     if cpu_info:
         cpu_model_detected = cpu_info.get("brand_raw", "")
@@ -81,17 +83,17 @@ def detect_cpu_model() -> str:
     return None
 
 
-def is_mac_os() -> str:
+def is_mac_os() -> bool:
     system = sys.platform.lower()
     return system.startswith("dar")
 
 
-def is_windows_os() -> str:
+def is_windows_os() -> bool:
     system = sys.platform.lower()
     return system.startswith("win")
 
 
-def is_linux_os() -> str:
+def is_linux_os() -> bool:
     system = sys.platform.lower()
     return system.startswith("lin")
 

{codecarbon-3.2.0 → codecarbon-3.2.2}/codecarbon/emissions_tracker.py

@@ -6,6 +6,7 @@ OfflineEmissionsTracker, context manager and decorator @track_emissions
 import dataclasses
 import os
 import platform
+import re
 import time
 import uuid
 from abc import ABC, abstractmethod
@@ -13,6 +14,8 @@ from datetime import datetime
 from functools import wraps
 from typing import Any, Callable, Dict, List, Optional, Union
 
+import psutil
+
 from codecarbon._version import __version__
 from codecarbon.core.config import get_hierarchical_config
 from codecarbon.core.emissions import Emissions
@@ -181,8 +184,8 @@ class BaseEmissionsTracker(ABC):
         logger_preamble: Optional[str] = _sentinel,
         force_cpu_power: Optional[int] = _sentinel,
         force_ram_power: Optional[int] = _sentinel,
-        pue: Optional[int] = _sentinel,
-        wue: Optional[bool] = _sentinel,
+        pue: Optional[float] = _sentinel,
+        wue: Optional[float] = _sentinel,
         force_mode_cpu_load: Optional[bool] = _sentinel,
         allow_multiple_runs: Optional[bool] = _sentinel,
         rapl_include_dram: Optional[bool] = _sentinel,
@@ -335,6 +338,11 @@ class BaseEmissionsTracker(ABC):
         self._last_measured_time: float = time.perf_counter()
         self._total_energy: Energy = Energy.from_energy(kWh=0)
         self._total_water: Water = Water.from_litres(litres=0)
+        # CPU and RAM utilization tracking
+        self._cpu_utilization_history: List[float] = []
+        self._gpu_utilization_history: List[float] = []
+        self._ram_utilization_history: List[float] = []
+        self._ram_used_history: List[float] = []
         self._total_cpu_energy: Energy = Energy.from_energy(kWh=0)
         self._total_gpu_energy: Energy = Energy.from_energy(kWh=0)
         self._total_ram_energy: Energy = Energy.from_energy(kWh=0)
@@ -361,8 +369,9 @@ class BaseEmissionsTracker(ABC):
         self._active_task_emissions_at_start: Optional[EmissionsData] = None
 
         # Tracking mode detection
-        ressource_tracker = ResourceTracker(self)
-        ressource_tracker.set_CPU_GPU_ram_tracking()
+        self._hardware = []
+        resource_tracker = ResourceTracker(self)
+        resource_tracker.set_CPU_GPU_ram_tracking()
 
         self._conf["hardware"] = list(map(lambda x: x.description(), self._hardware))
 
@@ -370,18 +379,20 @@ class BaseEmissionsTracker(ABC):
         logger.info(f"  Platform system: {self._conf.get('os')}")
         logger.info(f"  Python version: {self._conf.get('python_version')}")
         logger.info(f"  CodeCarbon version: {self._conf.get('codecarbon_version')}")
-        logger.info(f"  Available RAM : {self._conf.get('ram_total_size'):.3f} GB")
+
+        hardware_info = self.get_detected_hardware()
+        logger.info(f"  Available RAM : {hardware_info['ram_total_size']:.3f} GB")
         logger.info(
-            f"  CPU count: {self._conf.get('cpu_count')} thread(s) in {self._conf.get('cpu_physical_count')} physical CPU(s)"
+            f"  CPU count: {hardware_info['cpu_count']} thread(s) in {hardware_info['cpu_physical_count']} physical CPU(s)"
         )
-        logger.info(f"  CPU model: {self._conf.get('cpu_model')}")
-        logger.info(f"  GPU count: {self._conf.get('gpu_count')}")
+        logger.info(f"  CPU model: {hardware_info['cpu_model']}")
+        logger.info(f"  GPU count: {hardware_info['gpu_count']}")
         if self._gpu_ids:
             logger.info(
-                f"  GPU model: {self._conf.get('gpu_model')} BUT only tracking these GPU ids : {self._conf.get('gpu_ids')}"
+                f"  GPU model: {hardware_info['gpu_model']} BUT only tracking these GPU ids : {hardware_info['gpu_ids']}"
             )
         else:
-            logger.info(f"  GPU model: {self._conf.get('gpu_model')}")
+            logger.info(f"  GPU model: {hardware_info['gpu_model']}")
 
         # Run `self._measure_power_and_energy` every `measure_power_secs` seconds in a
         # background thread
@@ -447,11 +458,36 @@ class BaseEmissionsTracker(ABC):
             self.run_id = uuid.uuid4()
 
         if self._save_to_prometheus:
-            self._output_handlers.append(PrometheusOutput(self._prometheus_url))
+            self._output_handlers.append(
+                PrometheusOutput(
+                    self._prometheus_url,
+                    job_name=re.sub(
+                        r"[^a-zA-Z0-9_-]",
+                        "_",
+                        f"{self._project_name}_{self._experiment_name}",
+                    ),
+                )
+            )
 
         if self._save_to_logfire:
             self._output_handlers.append(LogfireOutput())
 
+    def get_detected_hardware(self) -> Dict[str, Any]:
+        """
+        Get the detected hardware.
+        :return: A dictionary containing hardware data.
+        """
+        hardware_info = {
+            "ram_total_size": self._conf.get("ram_total_size"),
+            "cpu_count": self._conf.get("cpu_count"),
+            "cpu_physical_count": self._conf.get("cpu_physical_count"),
+            "cpu_model": self._conf.get("cpu_model"),
+            "gpu_count": self._conf.get("gpu_count"),
+            "gpu_model": self._conf.get("gpu_model"),
+            "gpu_ids": self._conf.get("gpu_ids"),
+        }
+        return hardware_info
+
     def service_shutdown(self, signum, frame):
         logger.warning("service_shutdown - Caught signal %d" % signum)
         self.stop()
@@ -482,6 +518,13 @@ class BaseEmissionsTracker(ABC):
             return
 
         self._last_measured_time = self._start_time = time.perf_counter()
+
+        # Clear utilization history for fresh measurements
+        self._cpu_utilization_history.clear()
+        self._ram_utilization_history.clear()
+        self._ram_used_history.clear()
+        self._gpu_utilization_history.clear()
+
         # Read initial energy for hardware
         for hardware in self._hardware:
             hardware.start()
@@ -525,6 +568,13 @@ class BaseEmissionsTracker(ABC):
         if task_name in self._tasks.keys():
             task_name += "_" + uuid.uuid4().__str__()
         self._last_measured_time = self._start_time = time.perf_counter()
+
+        # Clear utilization history for fresh measurements
+        self._cpu_utilization_history.clear()
+        self._ram_utilization_history.clear()
+        self._ram_used_history.clear()
+        self._gpu_utilization_history.clear()
+
         # Read initial energy for hardware
         for hardware in self._hardware:
             hardware.start()
@@ -686,6 +736,10 @@ class BaseEmissionsTracker(ABC):
 
         self.final_emissions_data = emissions_data
         self.final_emissions = emissions_data.emissions
+
+        for handler in self._output_handlers:
+            handler.exit()
+
         return emissions_data.emissions
 
     def _persist_data(
@@ -782,6 +836,26 @@ class BaseEmissionsTracker(ABC):
             duration=duration.seconds,
             emissions=emissions,  # kg
             emissions_rate=emissions / duration.seconds,  # kg/s
+            cpu_utilization_percent=(
+                sum(self._cpu_utilization_history) / len(self._cpu_utilization_history)
+                if self._cpu_utilization_history
+                else 0
+            ),
+            gpu_utilization_percent=(
+                sum(self._gpu_utilization_history) / len(self._gpu_utilization_history)
+                if self._gpu_utilization_history
+                else 0
+            ),
+            ram_utilization_percent=(
+                sum(self._ram_utilization_history) / len(self._ram_utilization_history)
+                if self._ram_utilization_history
+                else 0
+            ),
+            ram_used_gb=(
+                sum(self._ram_used_history) / len(self._ram_used_history)
+                if self._ram_used_history
+                else 0
+            ),
             cpu_power=avg_cpu_power,
             gpu_power=avg_gpu_power,
             ram_power=avg_ram_power,
@@ -855,6 +929,21 @@ class BaseEmissionsTracker(ABC):
             if isinstance(hardware, CPU):
                 hardware.monitor_power()
 
+        # Collect CPU and RAM utilization metrics
+        self._cpu_utilization_history.append(psutil.cpu_percent())
+        self._ram_utilization_history.append(psutil.virtual_memory().percent)
+        self._ram_used_history.append(psutil.virtual_memory().used / (1024**3))
+
+        # Collect GPU utilization metrics
+        for hardware in self._hardware:
+            if isinstance(hardware, GPU):
+                gpu_details = hardware.devices.get_gpu_details()
+                for gpu_detail in gpu_details:
+                    if "gpu_utilization" in gpu_detail:
+                        self._gpu_utilization_history.append(
+                            gpu_detail["gpu_utilization"]
+                        )
+
     def _do_measurements(self) -> None:
         for hardware in self._hardware:
             h_time = time.perf_counter()
@@ -1174,7 +1263,7 @@ def track_emissions(
     country_2letter_iso_code: Optional[str] = _sentinel,
     force_cpu_power: Optional[int] = _sentinel,
     force_ram_power: Optional[int] = _sentinel,
-    pue: Optional[int] = _sentinel,
+    pue: Optional[float] = _sentinel,
     wue: Optional[float] = _sentinel,
     allow_multiple_runs: Optional[bool] = _sentinel,
     rapl_include_dram: Optional[bool] = _sentinel,

{codecarbon-3.2.0 → codecarbon-3.2.2}/codecarbon/input.py

@@ -1,12 +1,16 @@
 """
-App configuration: This will likely change when we have a common location for data files
+App configuration and static reference data loading.
+
+Data files are static reference data that never change during runtime.
+They are loaded once at module import to avoid repeated file I/O on the hot path
+(start_task/stop_task calls for instance).
 """
 
 import atexit
 import json
 import sys
 from contextlib import ExitStack
-from typing import Dict
+from typing import Any, Dict
 
 import pandas as pd
 
@@ -18,6 +22,49 @@ else:
     from importlib_resources import files as importlib_resources_files
 
 
+_CACHE: Dict[str, Any] = {}
+_MODULE_NAME = "codecarbon"
+
+
+def _get_resource_path(filepath: str):
+    """Get filesystem path to a package resource file."""
+    file_manager = ExitStack()
+    atexit.register(file_manager.close)
+    ref = importlib_resources_files(_MODULE_NAME).joinpath(filepath)
+    path = file_manager.enter_context(importlib_resources_as_file(ref))
+    return path
+
+
+def _load_static_data() -> None:
+    """
+    Load all static reference data at module import.
+
+    Called once when codecarbon is imported. All data loaded here
+    is immutable and shared across all tracker instances.
+    """
+    # Global energy mix - used for emissions calculations
+    path = _get_resource_path("data/private_infra/global_energy_mix.json")
+    with open(path) as f:
+        _CACHE["global_energy_mix"] = json.load(f)
+
+    # Cloud emissions data
+    path = _get_resource_path("data/cloud/impact.csv")
+    _CACHE["cloud_emissions"] = pd.read_csv(path)
+
+    # Carbon intensity per source
+    path = _get_resource_path("data/private_infra/carbon_intensity_per_source.json")
+    with open(path) as f:
+        _CACHE["carbon_intensity_per_source"] = json.load(f)
+
+    # CPU power data
+    path = _get_resource_path("data/hardware/cpu_power.csv")
+    _CACHE["cpu_power"] = pd.read_csv(path)
+
+
+# Load static data at module import
+_load_static_data()
+
+
 class DataSource:
     def __init__(self):
         self.config = {
@@ -84,56 +131,63 @@ class DataSource:
 
     def get_global_energy_mix_data(self) -> Dict:
         """
-        Returns Global Energy Mix Data
+        Returns Global Energy Mix Data.
+        Data is pre-loaded at module import for performance.
         """
-        with open(self.global_energy_mix_data_path) as f:
-            global_energy_mix: Dict = json.load(f)
-        return global_energy_mix
+        return _CACHE["global_energy_mix"]
 
     def get_cloud_emissions_data(self) -> pd.DataFrame:
         """
-        Returns Cloud Regions Impact Data
+        Returns Cloud Regions Impact Data.
+        Data is pre-loaded at module import for performance.
         """
-        return pd.read_csv(self.cloud_emissions_path)
+        return _CACHE["cloud_emissions"]
 
     def get_country_emissions_data(self, country_iso_code: str) -> Dict:
         """
-        Returns Emissions Across Regions in a country
+        Returns Emissions Across Regions in a country.
+        Data is cached on first access per country.
+
         :param country_iso_code: ISO code similar to one used in file names
         :return: emissions in lbs/MWh and region code
         """
-        try:
-            with open(self.country_emissions_data_path(country_iso_code)) as f:
-                country_emissions_data: Dict = json.load(f)
-            return country_emissions_data
-        except KeyError:
-            # KeyError raised from line 39, when there is no data path specified for
-            # the given country
-            raise DataSourceException
+        cache_key = f"country_emissions_{country_iso_code}"
+        if cache_key not in _CACHE:
+            try:
+                with open(self.country_emissions_data_path(country_iso_code)) as f:
+                    _CACHE[cache_key] = json.load(f)
+            except KeyError:
+                # KeyError raised when there is no data path specified for the country
+                raise DataSourceException
+        return _CACHE[cache_key]
 
     def get_country_energy_mix_data(self, country_iso_code: str) -> Dict:
         """
-        Returns Energy Mix Across Regions in a country
+        Returns Energy Mix Across Regions in a country.
+        Data is cached on first access per country.
+
         :param country_iso_code: ISO code similar to one used in file names
         :return: energy mix by region code
         """
-        with open(self.country_energy_mix_data_path(country_iso_code)) as f:
-            country_energy_mix_data: Dict = json.load(f)
-        return country_energy_mix_data
+        cache_key = f"country_energy_mix_{country_iso_code}"
+        if cache_key not in _CACHE:
+            with open(self.country_energy_mix_data_path(country_iso_code)) as f:
+                _CACHE[cache_key] = json.load(f)
+        return _CACHE[cache_key]
 
     def get_carbon_intensity_per_source_data(self) -> Dict:
         """
         Returns Carbon intensity per source. In gCO2.eq/kWh.
+        Data is pre-loaded at module import for performance.
         """
-        with open(self.carbon_intensity_per_source_path) as f:
-            carbon_intensity_per_source: Dict = json.load(f)
-        return carbon_intensity_per_source
+        return _CACHE["carbon_intensity_per_source"]
 
     def get_cpu_power_data(self) -> pd.DataFrame:
         """
-        Returns CPU power Data
+        Returns CPU power Data.
+        Data is pre-loaded at module import for performance.
         """
-        return pd.read_csv(self.cpu_power_path)
+        return _CACHE["cpu_power"]
 
 
 class DataSourceException(Exception):

{codecarbon-3.2.0 → codecarbon-3.2.2}/codecarbon/output_methods/base_output.py

@@ -22,3 +22,6 @@ class BaseOutput:
 
     def task_out(self, data: List[TaskEmissionsData], experiment_name: str):
         pass
+
+    def exit(self):
+        pass

{codecarbon-3.2.0 → codecarbon-3.2.2}/codecarbon/output_methods/emissions_data.py

@@ -40,6 +40,10 @@ class EmissionsData:
     latitude: float
     ram_total_size: float
     tracking_mode: str
+    cpu_utilization_percent: float = 0.0
+    gpu_utilization_percent: float = 0.0
+    ram_utilization_percent: float = 0.0
+    ram_used_gb: float = 0.0
     on_cloud: str = "N"
     pue: float = 1
     wue: float = 0
@@ -101,6 +105,10 @@ class TaskEmissionsData:
     latitude: float
     ram_total_size: float
     tracking_mode: str
+    cpu_utilization_percent: float = 0.0
+    gpu_utilization_percent: float = 0.0
+    ram_utilization_percent: float = 0.0
+    ram_used_gb: float = 0.0
     on_cloud: str = "N"
 
     @property

{codecarbon-3.2.0 → codecarbon-3.2.2}/codecarbon/output_methods/file.py

@@ -88,6 +88,11 @@ class FileOutput(BaseOutput):
 
         """
         file_exists: bool = os.path.isfile(self.save_file_path)
+        if file_exists and os.path.getsize(self.save_file_path) == 0:
+            logger.warning(
+                f"File {self.save_file_path} exists but is empty. Treating as new file."
+            )
+            file_exists = False
         if file_exists and not self.has_valid_headers(total):
             logger.warning("The CSV format has changed, backing up old emission file.")
             backup(self.save_file_path)

{codecarbon-3.2.0 → codecarbon-3.2.2}/codecarbon/output_methods/metrics/metric_docs.py

@@ -50,17 +50,22 @@ ram_power_doc = MetricDocumentation(
 )
 cpu_energy_doc = MetricDocumentation(
     "codecarbon_cpu_energy",
-    description="Energy used per CPU (kWh)",
+    description="Energy used per CPU since last reading (kWh)",
 )
 gpu_energy_doc = MetricDocumentation(
     "codecarbon_gpu_energy",
-    description="Energy used per GPU (kWh)",
+    description="Energy used per GPU since last reading (kWh)",
 )
 ram_energy_doc = MetricDocumentation(
     "codecarbon_ram_energy",
-    description="Energy used per RAM (kWh)",
+    description="Energy used per RAM since last reading (kWh)",
 )
 energy_consumed_doc = MetricDocumentation(
     "codecarbon_energy_consumed",
-    description="Sum of cpu_energy, gpu_energy and ram_energy (kW)",
+    description="Sum of cpu_energy, gpu_energy and ram_energy (kWh)",
+)
+
+energy_consumed_total_doc = MetricDocumentation(
+    "codecarbon_energy_total",
+    description="Accumulated cpu_energy, gpu_energy and ram_energy (kWh) since the start of the run",
 )