codecarbon 3.2.7__tar.gz → 3.2.8__tar.gz

{codecarbon-3.2.7 → codecarbon-3.2.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codecarbon
-Version: 3.2.7
+Version: 3.2.8
 Author: Mila, DataForGood, BCG GAMMA, Comet.ml, Haverford College
 License-Expression: MIT
 Project-URL: Homepage, https://codecarbon.io/
@@ -20,13 +20,14 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: arrow
 Requires-Dist: authlib>=1.2.1
+Requires-Dist: joserfc>=1.0.0
 Requires-Dist: click
 Requires-Dist: pandas>=2.3.3; python_version >= "3.14"
 Requires-Dist: pandas; python_version < "3.14"
 Requires-Dist: prometheus_client
 Requires-Dist: psutil>=6.0.0
 Requires-Dist: py-cpuinfo
-Requires-Dist: pydantic
+Requires-Dist: pydantic<3.0.0,>=2.0.0
 Requires-Dist: nvidia-ml-py
 Requires-Dist: rapidfuzz
 Requires-Dist: requests
@@ -42,8 +43,6 @@ 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: amdsmi
-Requires-Dist: amdsmi>=6.0.0; extra == "amdsmi"
 Dynamic: license-file
 
 ![banner](docs/images/banner.png)
@@ -124,6 +123,8 @@ Configuration precedence and examples: [configuration guide](https://docs.codeca
 
 We created a Python package that estimates your hardware electricity power consumption (GPU + CPU + RAM) and we apply to it the carbon intensity of the region where the computing is done.
 
+CodeCarbon focuses on the main compute components it can measure or estimate directly: CPU, GPU, and RAM. It does not separately model disk I/O, network transfers, displays, cooling, or other peripherals because those sources are usually much smaller for local code-level experiments and are not exposed through the same low-overhead measurement interfaces.
+
 ![calculation Summary](docs/images/calculation.png)
 
 We explain more about this calculation in the [**Methodology**](https://docs.codecarbon.io/latest/explanation/methodology/) section of the documentation.

{codecarbon-3.2.7 → codecarbon-3.2.8}/README.md

@@ -76,6 +76,8 @@ Configuration precedence and examples: [configuration guide](https://docs.codeca
 
 We created a Python package that estimates your hardware electricity power consumption (GPU + CPU + RAM) and we apply to it the carbon intensity of the region where the computing is done.
 
+CodeCarbon focuses on the main compute components it can measure or estimate directly: CPU, GPU, and RAM. It does not separately model disk I/O, network transfers, displays, cooling, or other peripherals because those sources are usually much smaller for local code-level experiments and are not exposed through the same low-overhead measurement interfaces.
+
 ![calculation Summary](docs/images/calculation.png)
 
 We explain more about this calculation in the [**Methodology**](https://docs.codecarbon.io/latest/explanation/methodology/) section of the documentation.

{codecarbon-3.2.7 → codecarbon-3.2.8}/codecarbon/__init__.py

@@ -8,6 +8,12 @@ from .emissions_tracker import (
     OfflineEmissionsTracker,
     track_emissions,
 )
+from .output import OutputMethod
 
-__all__ = ["EmissionsTracker", "OfflineEmissionsTracker", "track_emissions"]
+__all__ = [
+    "EmissionsTracker",
+    "OfflineEmissionsTracker",
+    "OutputMethod",
+    "track_emissions",
+]
 __app_name__ = "codecarbon"

codecarbon-3.2.8/codecarbon/_version.py

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

{codecarbon-3.2.7 → codecarbon-3.2.8}/codecarbon/cli/auth.py

@@ -6,6 +6,7 @@ PKCE), credential storage, JWKS validation, and transparent refresh.
 """
 
 import json
+import logging
 import os
 import webbrowser
 from http.server import BaseHTTPRequestHandler, HTTPServer
@@ -15,9 +16,9 @@ from urllib.parse import parse_qs, urlparse
 import requests
 from authlib.common.security import generate_token
 from authlib.integrations.requests_client import OAuth2Session
-from authlib.jose import JsonWebKey
-from authlib.jose import jwt as jose_jwt
 from authlib.oauth2.rfc7636 import create_s256_code_challenge
+from joserfc import jwt as jose_jwt
+from joserfc.jwk import KeySet
 
 AUTH_CLIENT_ID = os.environ.get(
     "AUTH_CLIENT_ID",
@@ -31,6 +32,7 @@ AUTH_SERVER_WELL_KNOWN = os.environ.get(
 _REDIRECT_PORT = 8090
 _REDIRECT_URI = f"http://localhost:{_REDIRECT_PORT}/callback"
 _CREDENTIALS_FILE = Path("./credentials.json")
+logger = logging.getLogger(__name__)
 
 
 # ── OAuth callback server ───────────────────────────────────────────
@@ -108,11 +110,16 @@ def _validate_access_token(access_token: str) -> bool:
         discovery = _discover_endpoints()
         jwks_resp = requests.get(discovery["jwks_uri"])
         jwks_resp.raise_for_status()
-        keyset = JsonWebKey.import_key_set(jwks_resp.json())
-        claims = jose_jwt.decode(access_token, keyset)
-        claims.validate()
+        keyset = KeySet.import_key_set(jwks_resp.json())
+        token = jose_jwt.decode(access_token, keyset)
+        jose_jwt.JWTClaimsRegistry().validate(token.claims)
         return True
-    except requests.RequestException:
+    except requests.RequestException as exc:
+        logger.warning(
+            "Skipping local access token validation because the auth server is "
+            "unreachable; the API will validate the token. Error: %s",
+            exc,
+        )
         return True  # Can't reach auth server — let the API handle it
     except Exception:
         return False

{codecarbon-3.2.7 → codecarbon-3.2.8}/codecarbon/cli/main.py

@@ -377,7 +377,7 @@ def monitor(
 
     # If extra args are provided (e.g. `codecarbon monitor -- my_script.py`), delegate to `run_and_monitor`
     if getattr(ctx, "args", None):
-        return run_and_monitor(ctx, **tracker_args)
+        return run_and_monitor(ctx, offline=offline, **tracker_args)
 
     # Instantiate the tracker
     if offline:

{codecarbon-3.2.7 → codecarbon-3.2.8}/codecarbon/cli/monitor.py

@@ -8,7 +8,7 @@ import typer
 from rich import print
 from typing_extensions import Annotated
 
-from codecarbon.emissions_tracker import EmissionsTracker
+from codecarbon.emissions_tracker import EmissionsTracker, OfflineEmissionsTracker
 
 
 def run_and_monitor(
@@ -17,6 +17,7 @@ def run_and_monitor(
         str,
         typer.Option(help="Log level (critical, error, warning, info, debug)"),
     ] = "error",
+    offline: bool = False,
     **tracker_args,
 ):
     """
@@ -63,8 +64,8 @@ def run_and_monitor(
         )
         raise typer.Exit(1)
 
-    # Initialize tracker with specified logging level and shared args
-    tracker = EmissionsTracker(
+    tracker_cls = OfflineEmissionsTracker if offline else EmissionsTracker
+    tracker = tracker_cls(
         log_level=log_level,
         save_to_logger=False,
         tracking_mode="process",

{codecarbon-3.2.7 → codecarbon-3.2.8}/codecarbon/core/api_client.py

@@ -227,6 +227,10 @@ class ApiClient:  # (AsyncClient)
             gpu_energy=carbon_emission["gpu_energy"],
             ram_energy=carbon_emission["ram_energy"],
             energy_consumed=carbon_emission["energy_consumed"],
+            cpu_utilization_percent=carbon_emission.get("cpu_utilization_percent"),
+            gpu_utilization_percent=carbon_emission.get("gpu_utilization_percent"),
+            ram_utilization_percent=carbon_emission.get("ram_utilization_percent"),
+            wue=carbon_emission.get("wue", 0),
         )
         try:
             payload = dataclasses.asdict(emission)

{codecarbon-3.2.7 → codecarbon-3.2.8}/codecarbon/core/cpu.py

@@ -217,19 +217,19 @@ def is_psutil_available():
                 return True
             else:
                 logger.debug(
-                    f"is_psutil_available(): psutil.cpu_times().nice is too small: {nice}"
+                    f"is_psutil_available(): psutil.cpu_times().nice is too small: {nice}; "
+                    "using fallback check."
                 )
-                return False
 
         else:
-            # Fallback: check if psutil works by calling cpu_percent
             logger.debug(
                 "is_psutil_available(): no 'nice' attribute, using fallback check."
             )
 
-            # check CPU utilization usable
-            psutil.cpu_percent(interval=0.0, percpu=False)
-            return True
+        # Fallback: check if psutil CPU utilization is usable. This covers
+        # platforms like Windows and macOS where cpu_times().nice is absent or 0.
+        psutil.cpu_percent(interval=0.0, percpu=False)
+        return True
 
     except Exception as e:
         logger.debug(
@@ -828,7 +828,8 @@ class IntelRAPL:
         """
         cpu_details = {}
         try:
-            list(map(lambda rapl_file: rapl_file.delta(duration), self._rapl_files))
+            for rapl_file in self._rapl_files:
+                rapl_file.delta(duration)
 
             for rapl_file in self._rapl_files:
                 logger.debug(rapl_file)

{codecarbon-3.2.7 → codecarbon-3.2.8}/codecarbon/core/emissions.py

@@ -16,6 +16,12 @@ from codecarbon.external.geography import CloudMetadata, GeoMetadata
 from codecarbon.external.logger import logger
 from codecarbon.input import DataSource, DataSourceException
 
+_NORDIC_REGIONS_BY_COUNTRY = {
+    "SWE": {"SE1", "SE2", "SE3", "SE4"},
+    "NOR": {"NO1", "NO2", "NO3", "NO4", "NO5"},
+    "FIN": {"FI"},
+}
+
 
 class Emissions:
     def __init__(
@@ -169,8 +175,11 @@ class Emissions:
                     + " >>> Using CodeCarbon's data."
                 )
 
+        country_iso_code = (
+            geo.country_iso_code.upper() if geo.country_iso_code is not None else None
+        )
         compute_with_regional_data: bool = (geo.region is not None) and (
-            geo.country_iso_code.upper() in ["USA", "CAN", "SWE", "NOR", "FIN"]
+            country_iso_code in ["USA", "CAN"] or self._is_supported_nordic_region(geo)
         )
 
         if compute_with_regional_data:
@@ -187,24 +196,10 @@ class Emissions:
     def _try_get_nordic_region_emissions(
         self, energy: Energy, geo: GeoMetadata
     ) -> Optional[float]:
-        nordic_regions = {
-            "SE1",
-            "SE2",
-            "SE3",
-            "SE4",
-            "NO1",
-            "NO2",
-            "NO3",
-            "NO4",
-            "NO5",
-            "FI",
-        }
-        if geo.region is None:
+        if not self._is_supported_nordic_region(geo):
             return None
 
         region_upper = geo.region.upper()
-        if region_upper not in nordic_regions:
-            return None
 
         try:
             nordic_data = self._data_source.get_nordic_country_energy_mix_data()
@@ -225,6 +220,16 @@ class Emissions:
             )
         return None
 
+    @staticmethod
+    def _is_supported_nordic_region(geo: GeoMetadata) -> bool:
+        if geo.country_iso_code is None or geo.region is None:
+            return False
+
+        country_regions = _NORDIC_REGIONS_BY_COUNTRY.get(
+            geo.country_iso_code.upper(), set()
+        )
+        return geo.region.upper() in country_regions
+
     def get_region_emissions(self, energy: Energy, geo: GeoMetadata) -> float:
         """
         Computes emissions for a region on private infra.
@@ -248,6 +253,11 @@ class Emissions:
         nordic_emissions = self._try_get_nordic_region_emissions(energy, geo)
         if nordic_emissions is not None:
             return nordic_emissions
+        if (
+            geo.country_iso_code is not None
+            and geo.country_iso_code.upper() in _NORDIC_REGIONS_BY_COUNTRY
+        ):
+            return self.get_country_emissions(energy, geo)
 
         # Handle USA and Canada regional data
         try:

{codecarbon-3.2.7 → codecarbon-3.2.8}/codecarbon/core/gpu_amd.py

@@ -28,7 +28,7 @@ except ImportError:
             "Please install amdsmi to get GPU metrics."
         )
     AMDSMI_AVAILABLE = False
-except AttributeError as e:
+except (AttributeError, OSError, KeyError) as e:
     amdsmi = None
     # In some environments, amdsmi may be present but not properly configured, leading to AttributeError when importing
     logger.warning(

{codecarbon-3.2.7 → codecarbon-3.2.8}/codecarbon/core/schemas.py

@@ -22,6 +22,10 @@ class EmissionBase:
     gpu_energy: float
     ram_energy: float
     energy_consumed: float
+    cpu_utilization_percent: Optional[float] = None
+    gpu_utilization_percent: Optional[float] = None
+    ram_utilization_percent: Optional[float] = None
+    wue: Optional[float] = 0
 
 
 class EmissionCreate(EmissionBase):

codecarbon-3.2.8/codecarbon/core/telemetry_client.py

@@ -0,0 +1,61 @@
+import json
+from typing import Optional, Union
+
+import requests
+
+from codecarbon.core.telemetry_schemas import TelemetryCreate
+from codecarbon.external.logger import logger
+
+
+class TelemetryClient:
+    """
+    Client dedicated to sending CodeCarbon telemetry payloads.
+    """
+
+    def __init__(
+        self,
+        endpoint_url="https://api.codecarbon.io",
+        telemetry: Optional[Union[TelemetryCreate, dict]] = None,
+    ):
+        self.endpoint_url = endpoint_url.rstrip("/")
+        self.telemetry_url = self.endpoint_url + "/telemetry"
+        self.headers = {"Content-Type": "application/json"}
+        self.telemetry = self._validate_telemetry(telemetry) if telemetry else None
+
+    def add_telemetry(self, telemetry: Optional[Union[TelemetryCreate, dict]] = None):
+        telemetry_payload = (
+            self._validate_telemetry(telemetry) if telemetry else self.telemetry
+        )
+        if telemetry_payload is None:
+            logger.error("TelemetryClient.add_telemetry() needs a telemetry payload")
+            return None
+        payload = telemetry_payload.model_dump(mode="json", exclude_none=True)
+
+        try:
+            response = requests.post(
+                url=self.telemetry_url,
+                json=payload,
+                timeout=2,
+                headers=self.headers,
+            )
+            if response.status_code != 201:
+                self._log_error(payload, response)
+                return None
+            return response.json()
+        except Exception as e:
+            logger.error(e, exc_info=True)
+            return None
+
+    @staticmethod
+    def _validate_telemetry(telemetry: Union[TelemetryCreate, dict]) -> TelemetryCreate:
+        if isinstance(telemetry, TelemetryCreate):
+            return telemetry
+        return TelemetryCreate(**telemetry)
+
+    def _log_error(self, payload, response):
+        logger.error(
+            f"TelemetryClient Error when calling the API on {self.telemetry_url} with : {json.dumps(payload)}"
+        )
+        logger.error(
+            f"TelemetryClient API return http code {response.status_code} and answer : {response.text}"
+        )

codecarbon-3.2.8/codecarbon/core/telemetry_schemas.py

@@ -0,0 +1,156 @@
+from datetime import datetime
+from enum import Enum
+from typing import List, Optional
+
+from pydantic import BaseModel, ConfigDict, Field, model_validator
+
+
+class TelemetryLevel(str, Enum):
+    disabled = "disabled"
+    minimal = "minimal"
+    extensive = "extensive"
+
+
+class TelemetryBase(BaseModel):
+    model_config = ConfigDict(extra="forbid", use_enum_values=True)
+
+    timestamp: datetime
+    telemetry_level: TelemetryLevel
+
+    os: Optional[str] = None
+    country_name: Optional[str] = None
+    country_iso_code: Optional[str] = Field(default=None, min_length=2, max_length=3)
+    region: Optional[str] = None
+    cloud_provider: Optional[str] = None
+    cloud_region: Optional[str] = None
+    longitude: Optional[float] = Field(default=None, ge=-180, le=180)
+    latitude: Optional[float] = Field(default=None, ge=-90, le=90)
+
+    cpu_count: Optional[int] = Field(default=None, ge=0)
+    cpu_physical_count: Optional[int] = Field(default=None, ge=0)
+    cpu_model: Optional[str] = None
+    cpu_architecture: Optional[str] = None
+    gpu_count: Optional[int] = Field(default=None, ge=0)
+    gpu_model: Optional[str] = None
+    gpu_driver_version: Optional[str] = None
+    gpu_memory_total_gb: Optional[float] = Field(default=None, ge=0)
+    ram_total_size_gb: Optional[float] = Field(default=None, ge=0)
+    cuda_version: Optional[str] = None
+    cudnn_version: Optional[str] = None
+
+    python_version: Optional[str] = None
+    python_implementation: Optional[str] = None
+    python_executable_hash: Optional[str] = Field(
+        default=None, min_length=64, max_length=64
+    )
+    python_env_type: Optional[str] = None
+    codecarbon_version: Optional[str] = None
+    codecarbon_install_method: Optional[str] = None
+
+    total_emissions_kg: Optional[float] = Field(default=None, ge=0)
+    emissions_rate_kg_per_sec: Optional[float] = Field(default=None, ge=0)
+    energy_consumed_kwh: Optional[float] = Field(default=None, ge=0)
+    cpu_energy_kwh: Optional[float] = Field(default=None, ge=0)
+    gpu_energy_kwh: Optional[float] = Field(default=None, ge=0)
+    ram_energy_kwh: Optional[float] = Field(default=None, ge=0)
+    duration_seconds: Optional[float] = Field(default=None, ge=0)
+    cpu_utilization_avg: Optional[float] = Field(default=None, ge=0, le=100)
+    gpu_utilization_avg: Optional[float] = Field(default=None, ge=0, le=100)
+    ram_utilization_avg: Optional[float] = Field(default=None, ge=0, le=100)
+
+    tracking_mode: Optional[str] = None
+    api_mode: Optional[str] = None
+    output_methods: Optional[List[str]] = None
+    hardware_tracked: Optional[List[str]] = None
+    task_tracking_used: Optional[bool] = None
+    decorator_vs_context: Optional[str] = None
+    measure_power_interval_secs: Optional[float] = Field(default=None, ge=0)
+
+    hardware_detection_success: Optional[bool] = None
+    rapl_available: Optional[bool] = None
+    gpu_detection_method: Optional[str] = None
+    first_measurement_time_ms: Optional[float] = Field(default=None, ge=0)
+    tracking_overhead_percent: Optional[float] = Field(default=None, ge=0)
+    errors_encountered: Optional[List[str]] = None
+    warning_count: Optional[int] = Field(default=None, ge=0)
+
+    ide_used: Optional[str] = None
+    notebook_environment: Optional[str] = None
+    ci_environment: Optional[str] = None
+    python_package_manager: Optional[str] = None
+    framework_detected: Optional[str] = None
+
+    has_torch: Optional[bool] = None
+    torch_version: Optional[str] = None
+    has_transformers: Optional[bool] = None
+    transformers_version: Optional[str] = None
+    has_diffusers: Optional[bool] = None
+    diffusers_version: Optional[str] = None
+    has_tensorflow: Optional[bool] = None
+    tensorflow_version: Optional[str] = None
+    has_keras: Optional[bool] = None
+    keras_version: Optional[str] = None
+    has_pytorch_lightning: Optional[bool] = None
+    pytorch_lightning_version: Optional[str] = None
+    has_fastai: Optional[bool] = None
+    fastai_version: Optional[str] = None
+    ml_framework_primary: Optional[str] = None
+
+    container_runtime: Optional[str] = None
+    in_container: Optional[bool] = None
+    host_machine_hash: Optional[str] = None
+
+    @model_validator(mode="after")
+    def validate_telemetry_level(self):
+        if self.telemetry_level == TelemetryLevel.disabled:
+            raise ValueError("Disabled telemetry must not be submitted")
+
+        if self.telemetry_level == TelemetryLevel.minimal:
+            extensive_fields = set(type(self).model_fields) - MINIMAL_TELEMETRY_FIELDS
+            submitted_extensive_fields = [
+                field
+                for field in extensive_fields
+                if getattr(self, field) not in (None, [], {})
+            ]
+            if submitted_extensive_fields:
+                fields = ", ".join(sorted(submitted_extensive_fields))
+                raise ValueError(
+                    f"Minimal telemetry cannot include extensive fields: {fields}"
+                )
+
+        return self
+
+
+MINIMAL_TELEMETRY_FIELDS = {
+    "timestamp",
+    "telemetry_level",
+    "os",
+    "country_name",
+    "country_iso_code",
+    "region",
+    "cloud_provider",
+    "cloud_region",
+    "longitude",
+    "latitude",
+    "cpu_count",
+    "cpu_physical_count",
+    "cpu_model",
+    "cpu_architecture",
+    "gpu_count",
+    "gpu_model",
+    "gpu_driver_version",
+    "gpu_memory_total_gb",
+    "ram_total_size_gb",
+    "cuda_version",
+    "cudnn_version",
+    "python_version",
+    "python_implementation",
+    "python_executable_hash",
+    "python_env_type",
+    "codecarbon_version",
+    "codecarbon_install_method",
+}
+
+
+class TelemetryCreate(TelemetryBase):
+    pass