codecarbon 3.2.7__tar.gz → 3.2.9__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codecarbon
-Version: 3.2.7
+Version: 3.2.9
 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.9}/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.9}/codecarbon/__init__.py

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

codecarbon-3.2.9/codecarbon/_version.py

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

{codecarbon-3.2.7 → codecarbon-3.2.9}/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.9}/codecarbon/cli/main.py

@@ -5,15 +5,12 @@ import time
 from pathlib import Path
 from typing import Optional
 
-import questionary
-import requests
 import typer
 from rich import print
 from rich.prompt import Confirm
 from typing_extensions import Annotated
 
 from codecarbon import __app_name__, __version__
-from codecarbon.cli.auth import authorize, get_access_token
 from codecarbon.cli.cli_utils import (
     create_new_config_file,
     get_api_endpoint,
@@ -21,10 +18,6 @@ from codecarbon.cli.cli_utils import (
     get_existing_exp_id,
     overwrite_local_config,
 )
-from codecarbon.cli.monitor import run_and_monitor
-from codecarbon.core.api_client import ApiClient, get_datetime_with_timezone
-from codecarbon.core.schemas import ExperimentCreate, OrganizationCreate, ProjectCreate
-from codecarbon.emissions_tracker import EmissionsTracker, OfflineEmissionsTracker
 
 API_URL = os.environ.get("API_URL", "https://dashboard.codecarbon.io/api")
 
@@ -68,6 +61,9 @@ def version(
 
 
 def show_config(path: Path = Path("./.codecarbon.config")) -> None:
+    from codecarbon.cli.auth import get_access_token
+    from codecarbon.core.api_client import ApiClient
+
     d = get_config(path)
     print("Current configuration : \n")
     print("Config file content : ")
@@ -114,6 +110,9 @@ def api_get():
     """
     ex: test-api
     """
+    from codecarbon.cli.auth import get_access_token
+    from codecarbon.core.api_client import ApiClient
+
     api_endpoint = get_api_endpoint()
     api = ApiClient(endpoint_url=api_endpoint)
     api.set_access_token(get_access_token())
@@ -123,6 +122,9 @@ def api_get():
 
 @codecarbon.command("login", short_help="Login to CodeCarbon")
 def login():
+    from codecarbon.cli.auth import authorize, get_access_token
+    from codecarbon.core.api_client import ApiClient
+
     authorize()
     api_endpoint = get_api_endpoint()
     api = ApiClient(endpoint_url=api_endpoint)
@@ -132,6 +134,10 @@ def login():
 
 
 def get_api_key(project_id: str):
+    import requests
+
+    from codecarbon.cli.auth import get_access_token
+
     api_endpoint = get_api_endpoint()
     api_endpoint = api_endpoint.rstrip("/")
     req = requests.post(
@@ -161,6 +167,13 @@ def config():
     """
     Initialize CodeCarbon, this will prompt you for configuration of Organisation/Team/Project/Experiment.
     """
+    from codecarbon.cli.auth import get_access_token
+    from codecarbon.core.api_client import ApiClient, get_datetime_with_timezone
+    from codecarbon.core.schemas import (
+        ExperimentCreate,
+        OrganizationCreate,
+        ProjectCreate,
+    )
 
     print("Welcome to CodeCarbon configuration wizard")
     home = Path.home()
@@ -342,6 +355,10 @@ def monitor(
         str,
         typer.Option(help="Region/province for offline mode"),
     ] = None,
+    log_level: Annotated[
+        str,
+        typer.Option(help="Log level (critical, error, warning, info, debug)"),
+    ] = "error",
 ):
     """Monitor your machine's carbon emissions."""
 
@@ -349,6 +366,7 @@ def monitor(
     tracker_args = {
         "measure_power_secs": measure_power_secs,
         "api_call_interval": api_call_interval,
+        "log_level": log_level,
     }
     # Set up the tracker arguments based on mode (offline vs online) and validate required args for each mode
     if offline:
@@ -375,9 +393,13 @@ def monitor(
 
         tracker_args = {**tracker_args, "save_to_api": api}
 
+    from codecarbon.emissions_tracker import EmissionsTracker, OfflineEmissionsTracker
+
     # 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)
+        from codecarbon.cli.monitor import run_and_monitor
+
+        return run_and_monitor(ctx, offline=offline, **tracker_args)
 
     # Instantiate the tracker
     if offline:
@@ -417,6 +439,8 @@ def detect():
     """
     Detects hardware and prints information without running any measurements.
     """
+    from codecarbon.emissions_tracker import EmissionsTracker
+
     print("Detecting hardware...")
     tracker = EmissionsTracker(save_to_file=False)
     hardware_info = tracker.get_detected_hardware()
@@ -438,6 +462,8 @@ def detect():
 
 
 def questionary_prompt(prompt, list_options, default):
+    import questionary
+
     value = questionary.select(
         prompt,
         list_options,

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

@@ -8,8 +8,6 @@ import typer
 from rich import print
 from typing_extensions import Annotated
 
-from codecarbon.emissions_tracker import EmissionsTracker
-
 
 def run_and_monitor(
     ctx: typer.Context,
@@ -17,6 +15,7 @@ def run_and_monitor(
         str,
         typer.Option(help="Log level (critical, error, warning, info, debug)"),
     ] = "error",
+    offline: bool = False,
     **tracker_args,
 ):
     """
@@ -49,12 +48,15 @@ def run_and_monitor(
     directory. The file path is shown in the final report.
     """
     # Suppress all CodeCarbon logs during execution
+    from codecarbon.emissions_tracker import EmissionsTracker, OfflineEmissionsTracker
     from codecarbon.external.logger import set_logger_level
 
     set_logger_level(log_level)
 
-    # Get the command from remaining args
-    command = ctx.args
+    # Get the command from remaining args (strip nested subcommand / `--` leftovers)
+    command = list(getattr(ctx, "args", None) or [])
+    while command and command[0] in ("monitor", "--"):
+        command.pop(0)
 
     if not command:
         print(
@@ -63,8 +65,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.9}/codecarbon/core/api_client.py

@@ -10,7 +10,6 @@ import dataclasses
 import json
 from datetime import timedelta, tzinfo
 
-import arrow
 import requests
 
 from codecarbon.core.schemas import (
@@ -22,12 +21,11 @@ from codecarbon.core.schemas import (
 )
 from codecarbon.external.logger import logger
 
-# from codecarbon.output import EmissionsData
-
 
 def get_datetime_with_timezone():
-    timestamp = str(arrow.now().isoformat())
-    return timestamp
+    import arrow
+
+    return str(arrow.now().isoformat())
 
 
 class ApiClient:  # (AsyncClient)
@@ -227,6 +225,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.9}/codecarbon/core/cpu.py

@@ -4,14 +4,16 @@ using Intel Power Gadget
 https://software.intel.com/content/www/us/en/develop/articles/intel-power-gadget.html
 """
 
+from __future__ import annotations
+
 import os
 import re
 import shutil
 import subprocess
 import sys
-from typing import Dict, Optional, Tuple
+from functools import lru_cache
+from typing import TYPE_CHECKING, Dict, Optional, Tuple
 
-import pandas as pd
 import psutil
 from rapidfuzz import fuzz, process, utils
 
@@ -19,12 +21,15 @@ from codecarbon.core.rapl import RAPLFile
 from codecarbon.core.units import Time
 from codecarbon.core.util import count_cpus, detect_cpu_model
 from codecarbon.external.logger import logger
-from codecarbon.input import DataSource
+
+if TYPE_CHECKING:
+    import pandas as pd
 
 # default W value per core for a CPU if no model is found in the ref csv
 DEFAULT_POWER_PER_CORE = 4
 
 
+@lru_cache(maxsize=1)
 def is_powergadget_available() -> bool:
     """
     Checks if Intel Power Gadget is available on the system.
@@ -44,6 +49,10 @@ def is_powergadget_available() -> bool:
         return False
 
 
+def clear_powergadget_cache() -> None:
+    is_powergadget_available.cache_clear()
+
+
 def _get_candidate_bases(rapl_dir: str) -> list:
     """Get list of directories to scan for RAPL files."""
     default_rapl_dir = "/sys/class/powercap/intel-rapl/subsystem"
@@ -217,19 +226,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(
@@ -366,6 +375,8 @@ class IntelPowerGadget:
         self._log_values()
         cpu_details = {}
         try:
+            import pandas as pd
+
             cpu_data = pd.read_csv(self._log_file_path).dropna()
             for col_name in cpu_data.columns:
                 if col_name in ["System Time", "Elapsed Time (sec)", "RDTSC"]:
@@ -828,7 +839,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)
@@ -891,6 +903,8 @@ class TDP:
         return float(cpu_power_df[cpu_power_df["Name"] == match]["TDP"].values[0])
 
     def _get_cpu_power_from_registry(self, cpu_model_raw: str) -> Optional[int]:
+        from codecarbon.input import DataSource
+
         cpu_power_df = DataSource().get_cpu_power_data()
         cpu_matching = self._get_matching_cpu(cpu_model_raw, cpu_power_df)
         if cpu_matching:

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

@@ -6,9 +6,7 @@ https://github.com/mlco2/impact
 https://github.com/responsibleproblemsolving/energy-usage
 """
 
-from typing import Dict, Optional
-
-import pandas as pd
+from typing import TYPE_CHECKING, Dict, Optional
 
 from codecarbon.core import electricitymaps_api
 from codecarbon.core.units import EmissionsPerKWh, Energy
@@ -16,6 +14,15 @@ from codecarbon.external.geography import CloudMetadata, GeoMetadata
 from codecarbon.external.logger import logger
 from codecarbon.input import DataSource, DataSourceException
 
+if TYPE_CHECKING:
+    import pandas as pd
+
+_NORDIC_REGIONS_BY_COUNTRY = {
+    "SWE": {"SE1", "SE2", "SE3", "SE4"},
+    "NOR": {"NO1", "NO2", "NO3", "NO4", "NO5"},
+    "FIN": {"FI"},
+}
+
 
 class Emissions:
     def __init__(
@@ -169,8 +176,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 +197,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 +221,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 +254,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.9}/codecarbon/core/gpu.py

@@ -137,6 +137,23 @@ class AllGPUDevices:
             logger.warning("Failed to retrieve gpu information", exc_info=True)
             return []
 
+    def get_gpu_utilization_list(self) -> List:
+        """Lightweight alternative to :meth:`get_gpu_details` for the 1s
+        monitoring hot path. Returns only ``gpu_index`` and
+        ``gpu_utilization`` per device, skipping heavyweight queries
+        (memory, temperature, compute mode, process lists).
+
+        >>> get_gpu_utilization_list()
+        [
+            {"gpu_index": 0, "gpu_utilization": 0},
+        ]
+        """
+        try:
+            return [d.get_gpu_utilization_lightweight() for d in self.devices]
+        except Exception:
+            logger.warning("Failed to retrieve gpu utilization", exc_info=True)
+            return []
+
     def get_delta(self, last_duration: Time) -> List:
         """Get difference since last time this function was called
         >>> get_delta()

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

@@ -1,21 +1,26 @@
 import subprocess
 from collections import namedtuple
+from functools import lru_cache
 from typing import Callable
 
 from codecarbon.core.gpu_device import GPUDevice
 from codecarbon.external.logger import logger
 
 
+@lru_cache(maxsize=1)
 def is_rocm_system():
     """Returns True if the system has an rocm-smi interface."""
     try:
-        # Check if rocm-smi is available
         subprocess.check_output(["rocm-smi", "--help"])
         return True
     except (subprocess.CalledProcessError, OSError):
         return False
 
 
+def clear_rocm_system_cache() -> None:
+    is_rocm_system.cache_clear()
+
+
 try:
     import amdsmi
 
@@ -28,7 +33,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.9}/codecarbon/core/gpu_device.py

@@ -101,6 +101,20 @@ class GPUDevice:
         }
         return device_details
 
+    def get_gpu_utilization_lightweight(self) -> Dict[str, Any]:
+        """
+        Lightweight alternative to :meth:`get_gpu_details` for the hot path
+        (``_monitor_power`` which runs every 1s).
+
+        Only queries the GPU utilization — avoids heavyweight calls like
+        memory info, temperature, compute mode, and process lists which are
+        not consumed by the tracker's monitoring loop.
+        """
+        return {
+            "gpu_index": self.gpu_index,
+            "gpu_utilization": self._get_gpu_utilization(),
+        }
+
     def _to_utf8(self, str_or_bytes) -> Any:
         if hasattr(str_or_bytes, "decode"):
             return str_or_bytes.decode("utf-8", errors="replace")

{codecarbon-3.2.7 → codecarbon-3.2.9}/codecarbon/core/gpu_nvidia.py

@@ -1,21 +1,26 @@
 import subprocess
 from dataclasses import dataclass
+from functools import lru_cache
 from typing import Any, Union
 
 from codecarbon.core.gpu_device import GPUDevice
 from codecarbon.external.logger import logger
 
 
+@lru_cache(maxsize=1)
 def is_nvidia_system():
     """Returns True if the system has an nvidia-smi interface."""
     try:
-        # Check if nvidia-smi is available
         subprocess.check_output(["nvidia-smi", "--help"])
         return True
     except Exception:
         return False
 
 
+def clear_nvidia_system_cache() -> None:
+    is_nvidia_system.cache_clear()
+
+
 try:
     import pynvml