codecarbon 3.2.2__tar.gz → 3.2.3__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codecarbon
-Version: 3.2.2
+Version: 3.2.3
 Author: Mila, DataForGood, BCG GAMMA, Comet.ml, Haverford College
 License-Expression: MIT
 Project-URL: Homepage, https://codecarbon.io/
@@ -10,7 +10,6 @@ Project-URL: Documentation, https://mlco2.github.io/codecarbon/
 Project-URL: Issues, https://github.com/mlco2/codecarbon/issues
 Project-URL: Changelog, https://github.com/mlco2/codecarbon/releases
 Classifier: Natural Language :: English
-Classifier: Programming Language :: Python :: 3.7
 Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
@@ -18,12 +17,12 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
-Requires-Python: >=3.7
+Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: arrow
+Requires-Dist: authlib>=1.2.1
 Requires-Dist: click
-Requires-Dist: fief-client[cli]
 Requires-Dist: pandas>=2.3.3; python_version >= "3.14"
 Requires-Dist: pandas; python_version < "3.14"
 Requires-Dist: prometheus_client
@@ -46,12 +45,14 @@ Requires-Dist: dash_bootstrap_components>1.0.0; extra == "viz-legacy"
 Requires-Dist: fire; extra == "viz-legacy"
 Provides-Extra: api
 Requires-Dist: alembic<2.0.0; extra == "api"
+Requires-Dist: authlib>=1.2.1; extra == "api"
 Requires-Dist: bcrypt<5.0.0; extra == "api"
 Requires-Dist: python-dateutil<3.0.0; extra == "api"
 Requires-Dist: dependency-injector<5.0.0; extra == "api"
 Requires-Dist: fastapi<1.0.0; extra == "api"
 Requires-Dist: fief-client[fastapi]; extra == "api"
 Requires-Dist: httpx; extra == "api"
+Requires-Dist: itsdangerous; extra == "api"
 Requires-Dist: pydantic[email]<2.0.0; extra == "api"
 Requires-Dist: psycopg2-binary<3.0.0; extra == "api"
 Requires-Dist: requests<3.0.0; extra == "api"
@@ -67,7 +68,6 @@ Requires-Dist: psutil; extra == "api"
 Requires-Dist: requests-mock; extra == "api"
 Requires-Dist: rapidfuzz; extra == "api"
 Requires-Dist: PyJWT; extra == "api"
-Requires-Dist: logfire[fastapi]>=1.0.1; extra == "api"
 Dynamic: license-file
 
 ![banner](docs/edit/images/banner.png)
@@ -89,6 +89,7 @@ CodeCarbon websites:
 [![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) -->
 [![OpenSSF Scorecard](https://api.scorecard.dev/projects/github.com/mlco2/codecarbon/badge)](https://scorecard.dev/viewer/?uri=github.com/mlco2/codecarbon)
+[![codecov](https://codecov.io/gh/mlco2/codecarbon/graph/badge.svg)](https://codecov.io/gh/mlco2/codecarbon)
 
 
 - [About CodeCarbon 💡](#about-codecarbon-)

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

@@ -17,6 +17,7 @@ CodeCarbon websites:
 [![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) -->
 [![OpenSSF Scorecard](https://api.scorecard.dev/projects/github.com/mlco2/codecarbon/badge)](https://scorecard.dev/viewer/?uri=github.com/mlco2/codecarbon)
+[![codecov](https://codecov.io/gh/mlco2/codecarbon/graph/badge.svg)](https://codecov.io/gh/mlco2/codecarbon)
 
 
 - [About CodeCarbon 💡](#about-codecarbon-)

codecarbon-3.2.3/codecarbon/_version.py

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

codecarbon-3.2.3/codecarbon/cli/auth.py

@@ -0,0 +1,225 @@
+"""
+OIDC Authentication helpers for the CodeCarbon CLI.
+
+Handles the full token lifecycle: browser-based login (Authorization Code +
+PKCE), credential storage, JWKS validation, and transparent refresh.
+"""
+
+import json
+import os
+import webbrowser
+from http.server import BaseHTTPRequestHandler, HTTPServer
+from pathlib import Path
+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
+
+AUTH_CLIENT_ID = os.environ.get(
+    "AUTH_CLIENT_ID",
+    "codecarbon-cli",
+)
+AUTH_SERVER_WELL_KNOWN = os.environ.get(
+    "AUTH_SERVER_WELL_KNOWN",
+    "https://authentication.codecarbon.io/realms/codecarbon/.well-known/openid-configuration",
+)
+
+_REDIRECT_PORT = 8090
+_REDIRECT_URI = f"http://localhost:{_REDIRECT_PORT}/callback"
+_CREDENTIALS_FILE = Path("./credentials.json")
+
+
+# ── OAuth callback server ───────────────────────────────────────────
+
+
+class _CallbackHandler(BaseHTTPRequestHandler):
+    """HTTP handler that captures the OAuth2 authorization callback."""
+
+    callback_url = None
+    error = None
+
+    def do_GET(self):
+        _CallbackHandler.callback_url = f"http://localhost:{_REDIRECT_PORT}{self.path}"
+        parsed = urlparse(self.path)
+        params = parse_qs(parsed.query)
+
+        if "error" in params:
+            _CallbackHandler.error = params["error"][0]
+            self.send_response(400)
+            self.send_header("Content-Type", "text/html")
+            self.end_headers()
+            msg = params.get("error_description", [params["error"][0]])[0]
+            self.wfile.write(
+                f"<html><body><h1>Login failed</h1><p>{msg}</p></body></html>".encode()
+            )
+        else:
+            self.send_response(200)
+            self.send_header("Content-Type", "text/html")
+            self.end_headers()
+            self.wfile.write(
+                b"<html><body><h1>Login successful!</h1>"
+                b"<p>You can close this window.</p></body></html>"
+            )
+
+    def log_message(self, format, *args):
+        pass
+
+
+# ── OIDC discovery ──────────────────────────────────────────────────
+
+
+def _discover_endpoints():
+    """Fetch OpenID Connect discovery document."""
+    resp = requests.get(AUTH_SERVER_WELL_KNOWN)
+    resp.raise_for_status()
+    return resp.json()
+
+
+# ── Credential storage ──────────────────────────────────────────────
+
+
+def _save_credentials(tokens):
+    """Save OAuth tokens to the local credentials file."""
+    with open(_CREDENTIALS_FILE, "w") as f:
+        json.dump(tokens, f)
+
+
+def _load_credentials():
+    """Load OAuth tokens from the local credentials file."""
+    with open(_CREDENTIALS_FILE, "r") as f:
+        return json.load(f)
+
+
+# ── Token validation & refresh ──────────────────────────────────────
+
+
+def _validate_access_token(access_token: str) -> bool:
+    """Validate access token against the current OIDC provider's JWKS.
+
+    Returns False when the signature or expiry check fails (wrong provider,
+    expired, tampered).  Returns True on network errors so the caller can
+    fall through to the API and let the server decide.
+    """
+    try:
+        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()
+        return True
+    except requests.RequestException:
+        return True  # Can't reach auth server — let the API handle it
+    except Exception:
+        return False
+
+
+def _refresh_tokens(refresh_token: str) -> dict:
+    """Exchange a refresh token for a new token set via the OIDC token endpoint."""
+    discovery = _discover_endpoints()
+    resp = requests.post(
+        discovery["token_endpoint"],
+        data={
+            "grant_type": "refresh_token",
+            "refresh_token": refresh_token,
+            "client_id": AUTH_CLIENT_ID,
+        },
+    )
+    resp.raise_for_status()
+    return resp.json()
+
+
+# ── Public API ──────────────────────────────────────────────────────
+
+
+def authorize():
+    """Run the OAuth2 Authorization Code flow with PKCE."""
+    discovery = _discover_endpoints()
+
+    session = OAuth2Session(
+        client_id=AUTH_CLIENT_ID,
+        redirect_uri=_REDIRECT_URI,
+        scope="openid offline_access",
+        token_endpoint_auth_method="none",
+    )
+
+    code_verifier = generate_token(48)
+    code_challenge = create_s256_code_challenge(code_verifier)
+
+    uri, state = session.create_authorization_url(
+        discovery["authorization_endpoint"],
+        code_challenge=code_challenge,
+        code_challenge_method="S256",
+    )
+
+    _CallbackHandler.callback_url = None
+    _CallbackHandler.error = None
+
+    server = HTTPServer(("localhost", _REDIRECT_PORT), _CallbackHandler)
+
+    print("Opening browser for authentication...")
+    webbrowser.open(uri)
+
+    server.handle_request()
+    server.server_close()
+
+    if _CallbackHandler.error:
+        raise ValueError(f"Authorization failed: {_CallbackHandler.error}")
+
+    if not _CallbackHandler.callback_url:
+        raise ValueError("Authorization failed: no callback received")
+
+    token = session.fetch_token(
+        discovery["token_endpoint"],
+        authorization_response=_CallbackHandler.callback_url,
+        code_verifier=code_verifier,
+    )
+
+    _save_credentials(token)
+    return token
+
+
+def get_access_token() -> str:
+    """Return a valid access token, refreshing or failing with a clear message."""
+    try:
+        creds = _load_credentials()
+    except Exception as e:
+        raise ValueError(
+            "Not able to retrieve the access token, "
+            f"please run `codecarbon login` first! (error: {e})"
+        )
+
+    access_token = creds.get("access_token")
+    if not access_token:
+        raise ValueError("No access token found. Please run `codecarbon login` first.")
+
+    # Fast path: token is still valid for the current OIDC provider
+    if _validate_access_token(access_token):
+        return access_token
+
+    # Token is expired or was issued by a different provider — try refresh
+    refresh_token = creds.get("refresh_token")
+    if refresh_token:
+        try:
+            new_tokens = _refresh_tokens(refresh_token)
+            _save_credentials(new_tokens)
+            return new_tokens["access_token"]
+        except Exception:
+            pass
+
+    # Refresh failed — credentials are stale (e.g. auth provider migrated)
+    _CREDENTIALS_FILE.unlink(missing_ok=True)
+    raise ValueError(
+        "Your session has expired or the authentication provider has changed. "
+        "Please run `codecarbon login` again."
+    )
+
+
+def get_id_token() -> str:
+    """Return the stored OIDC id_token."""
+    creds = _load_credentials()
+    return creds["id_token"]

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

@@ -8,13 +8,12 @@ from typing import Optional
 import questionary
 import requests
 import typer
-from fief_client import Fief
-from fief_client.integrations.cli import FiefAuth
 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,
@@ -22,17 +21,11 @@ from codecarbon.cli.cli_utils import (
     get_existing_local_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
 
-AUTH_CLIENT_ID = os.environ.get(
-    "AUTH_CLIENT_ID",
-    "jsUPWIcUECQFE_ouanUuVhXx52TTjEVcVNNtNGeyAtU",
-)
-AUTH_SERVER_URL = os.environ.get(
-    "AUTH_SERVER_URL", "https://auth.codecarbon.io/codecarbon"
-)
 API_URL = os.environ.get("API_URL", "https://dashboard.codecarbon.io/api")
 
 DEFAULT_PROJECT_ID = "e60afa92-17b7-4720-91a0-1ae91e409ba1"
@@ -78,7 +71,7 @@ def show_config(path: Path = Path("./.codecarbon.config")) -> None:
     d = get_config(path)
     api_endpoint = get_api_endpoint(path)
     api = ApiClient(endpoint_url=api_endpoint)
-    api.set_access_token(_get_access_token())
+    api.set_access_token(get_access_token())
     print("Current configuration : \n")
     print("Config file content : ")
     print(d)
@@ -114,28 +107,6 @@ def show_config(path: Path = Path("./.codecarbon.config")) -> None:
         )
 
 
-def get_fief_auth():
-    fief = Fief(AUTH_SERVER_URL, AUTH_CLIENT_ID)
-    fief_auth = FiefAuth(fief, "./credentials.json")
-    return fief_auth
-
-
-def _get_access_token():
-    try:
-        access_token_info = get_fief_auth().access_token_info()
-        access_token = access_token_info["access_token"]
-        return access_token
-    except Exception as e:
-        raise ValueError(
-            f"Not able to retrieve the access token, please run `codecarbon login` first! (error: {e})"
-        )
-
-
-def _get_id_token():
-    id_token = get_fief_auth()._tokens["id_token"]
-    return id_token
-
-
 @codecarbon.command(
     "test-api", short_help="Make an authenticated GET request to an API endpoint"
 )
@@ -144,16 +115,16 @@ def api_get():
     ex: test-api
     """
     api = ApiClient(endpoint_url=API_URL)  # TODO: get endpoint from config
-    api.set_access_token(_get_access_token())
+    api.set_access_token(get_access_token())
     organizations = api.get_list_organizations()
     print(organizations)
 
 
 @codecarbon.command("login", short_help="Login to CodeCarbon")
 def login():
-    get_fief_auth().authorize()
+    authorize()
     api = ApiClient(endpoint_url=API_URL)  # TODO: get endpoint from config
-    access_token = _get_access_token()
+    access_token = get_access_token()
     api.set_access_token(access_token)
     api.check_auth()
 
@@ -166,7 +137,7 @@ def get_api_key(project_id: str):
             "name": "api token",
             "x_token": "???",
         },
-        headers={"Authorization": f"Bearer {_get_access_token()}"},
+        headers={"Authorization": f"Bearer {get_access_token()}"},
     )
     api_key = req.json()["token"]
     return api_key
@@ -175,7 +146,7 @@ def get_api_key(project_id: str):
 @codecarbon.command("get-token", short_help="Get project token")
 def get_token(project_id: str):
     # api = ApiClient(endpoint_url=API_URL) # TODO: get endpoint from config
-    # api.set_access_token(_get_access_token())
+    # api.set_access_token(get_access_token())
     token = get_api_key(project_id)
     print("Your token: " + token)
     print("Add it to the api_key field in your configuration file")
@@ -223,7 +194,7 @@ def config():
     )
     overwrite_local_config("api_endpoint", api_endpoint, path=file_path)
     api = ApiClient(endpoint_url=api_endpoint)
-    api.set_access_token(_get_access_token())
+    api.set_access_token(get_access_token())
     organizations = api.get_list_organizations()
     org = questionary_prompt(
         "Pick existing organization from list or Create new organization ?",
@@ -339,13 +310,18 @@ def config():
     )
 
 
-@codecarbon.command("monitor", short_help="Monitor your machine's carbon emissions.")
+@codecarbon.command(
+    "monitor",
+    short_help="Monitor your machine's carbon emissions.",
+    context_settings={"allow_extra_args": True, "ignore_unknown_options": True},
+)
 def monitor(
+    ctx: typer.Context,
     measure_power_secs: Annotated[
-        int, typer.Argument(help="Interval between two measures.")
+        int, typer.Option(help="Interval between two measures.")
     ] = 10,
     api_call_interval: Annotated[
-        int, typer.Argument(help="Number of measures between API calls.")
+        int, typer.Option(help="Number of measures between API calls.")
     ] = 30,
     api: Annotated[
         bool, typer.Option(help="Choose to call Code Carbon API or not")
@@ -359,6 +335,13 @@ def monitor(
     ] = None,
 ):
     """Monitor your machine's carbon emissions."""
+
+    # Shared tracker args so monitor and run_and_monitor behave the same
+    tracker_args = {
+        "measure_power_secs": measure_power_secs,
+        "api_call_interval": api_call_interval,
+    }
+    # Set up the tracker arguments based on mode (offline vs online) and validate required args for each mode
     if offline:
         if not country_iso_code:
             print(
@@ -366,11 +349,11 @@ def monitor(
             )
             raise typer.Exit(1)
 
-        tracker = OfflineEmissionsTracker(
-            measure_power_secs=measure_power_secs,
-            country_iso_code=country_iso_code,
-            region=region,
-        )
+        tracker_args = {
+            **tracker_args,
+            "country_iso_code": country_iso_code,
+            "region": region,
+        }
     else:
         experiment_id = get_existing_local_exp_id()
         if api and experiment_id is None:
@@ -380,11 +363,17 @@ def monitor(
             )
             raise typer.Exit(1)
 
-        tracker = EmissionsTracker(
-            measure_power_secs=measure_power_secs,
-            api_call_interval=api_call_interval,
-            save_to_api=api,
-        )
+        tracker_args = {**tracker_args, "save_to_api": api}
+
+    # 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)
+
+    # Instantiate the tracker
+    if offline:
+        tracker = OfflineEmissionsTracker(**tracker_args)
+    else:
+        tracker = EmissionsTracker(**tracker_args)
 
     def signal_handler(signum, frame):
         print("\nReceived signal to stop. Saving emissions data...")

codecarbon-3.2.3/codecarbon/cli/monitor.py

@@ -0,0 +1,127 @@
+"""CodeCarbon CLI - Monitor Command"""
+
+import os
+import subprocess
+import sys
+
+import typer
+from rich import print
+from typing_extensions import Annotated
+
+from codecarbon.emissions_tracker import EmissionsTracker
+
+
+def run_and_monitor(
+    ctx: typer.Context,
+    log_level: Annotated[
+        str, typer.Option(help="Log level (critical, error, warning, info, debug)")
+    ] = "error",
+    **tracker_args,
+):
+    """
+    Run a command and track its carbon emissions.
+
+    This command wraps any executable and measures the process's total power
+    consumption during its execution. When the command completes, a summary
+    report is displayed and emissions data is saved to a CSV file.
+
+    Note: This tracks process-level emissions (only the specific command), not the
+    entire machine. For machine-level tracking, use the `monitor` command.
+
+    Examples:
+
+        Do not use quotes around the command. Use -- to separate CodeCarbon args.
+
+        # Run any shell command:
+        codecarbon monitor -- ./benchmark.sh
+
+        # Commands with arguments (use single quotes for special chars):
+        codecarbon monitor -- python -c 'print("Hello World!")'
+
+        # Pipe the command output:
+        codecarbon monitor -- npm run test > output.txt
+
+        # Display the CodeCarbon detailed logs:
+        codecarbon monitor --log-level debug -- python --version
+
+    The emissions data is appended to emissions.csv (default) in the current
+    directory. The file path is shown in the final report.
+    """
+    # Suppress all CodeCarbon logs during execution
+    from codecarbon.external.logger import set_logger_level
+
+    set_logger_level(log_level)
+
+    # Get the command from remaining args
+    command = ctx.args
+
+    if not command:
+        print(
+            "ERROR: No command provided. Use: codecarbon monitor -- <command>",
+            file=sys.stderr,
+        )
+        raise typer.Exit(1)
+
+    # Initialize tracker with specified logging level and shared args
+    tracker = EmissionsTracker(
+        log_level=log_level,
+        save_to_logger=False,
+        tracking_mode="process",
+        **tracker_args,
+    )
+
+    print("🌱 CodeCarbon: Starting emissions tracking...")
+    print(f"   Command: {' '.join(command)}")
+    print()
+
+    tracker.start()
+
+    process = None
+    try:
+        # Run the command, streaming output to console
+        # Let the child inherit the parent's std streams so Click's
+        # `CliRunner` can capture output (don't pass StringIO objects).
+        process = subprocess.Popen(command, text=True)
+
+        # Wait for completion
+        exit_code = process.wait()
+
+    except FileNotFoundError:
+        print(f"❌ Error: Command not found: {command[0]}", file=sys.stderr)
+        exit_code = 127
+    except KeyboardInterrupt:
+        print("\n⚠️  Interrupted by user", file=sys.stderr)
+        if process is not None:
+            process.terminate()
+            try:
+                process.wait(timeout=5)
+            except subprocess.TimeoutExpired:
+                process.kill()
+        exit_code = 130
+    except Exception as e:
+        print(f"❌ Error running command: {e}", file=sys.stderr)
+        exit_code = 1
+    finally:
+        emissions = tracker.stop()
+        print()
+        print("=" * 60)
+        print("🌱 CodeCarbon Emissions Report")
+        print("=" * 60)
+        print(f"   Command: {' '.join(command)}")
+        if emissions is not None:
+            print(f"   Emissions: {emissions * 1000:.4f} g CO2eq")
+        else:
+            print("   Emissions: N/A")
+
+        # Show where the data was saved
+        if hasattr(tracker, "_conf") and "output_file" in tracker._conf:
+            output_path = tracker._conf["output_file"]
+            # Make it absolute if it's relative
+            if not os.path.isabs(output_path):
+                output_path = os.path.abspath(output_path)
+            print(f"   Saved to: {output_path}")
+
+        print("   ⚠️  Note: Tracked the command process and its children")
+        print("=" * 60)
+
+    raise typer.Exit(exit_code)

{codecarbon-3.2.2 → codecarbon-3.2.3}/codecarbon/core/cpu.py

@@ -208,14 +208,29 @@ def is_rapl_available(rapl_dir: Optional[str] = None) -> bool:
 
 def is_psutil_available():
     try:
-        nice = psutil.cpu_times().nice
-        if nice > 0.0001:
-            return True
+        cpu_times = psutil.cpu_times()
+
+        # platforms like Windows do not have 'nice' attribute
+        if hasattr(cpu_times, "nice"):
+            nice = cpu_times.nice
+            if nice > 0.0001:
+                return True
+            else:
+                logger.debug(
+                    f"is_psutil_available(): psutil.cpu_times().nice is too small: {nice}"
+                )
+                return False
+
         else:
+            # Fallback: check if psutil works by calling cpu_percent
             logger.debug(
-                f"is_psutil_available() : psutil.cpu_times().nice is too small : {nice} !"
+                "is_psutil_available(): no 'nice' attribute, using fallback check."
             )
-            return False
+
+            # check CPU utilization usable
+            psutil.cpu_percent(interval=0.0, percpu=False)
+            return True
+
     except Exception as e:
         logger.debug(
             "Not using the psutil interface, an exception occurred while instantiating "