codecarbon 3.2.8__tar.gz → 3.2.9__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codecarbon
-Version: 3.2.8
+Version: 3.2.9
 Author: Mila, DataForGood, BCG GAMMA, Comet.ml, Haverford College
 License-Expression: MIT
 Project-URL: Homepage, https://codecarbon.io/

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

@@ -8,7 +8,7 @@ from .emissions_tracker import (
     OfflineEmissionsTracker,
     track_emissions,
 )
-from .output import OutputMethod
+from .output_methods.base_output import OutputMethod
 
 __all__ = [
     "EmissionsTracker",

codecarbon-3.2.9/codecarbon/_version.py

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

{codecarbon-3.2.8 → 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,8 +393,12 @@ 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):
+        from codecarbon.cli.monitor import run_and_monitor
+
         return run_and_monitor(ctx, offline=offline, **tracker_args)
 
     # Instantiate the tracker
@@ -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.8 → 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, OfflineEmissionsTracker
-
 
 def run_and_monitor(
     ctx: typer.Context,
@@ -50,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(

{codecarbon-3.2.8 → 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)

{codecarbon-3.2.8 → 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"
@@ -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"]:
@@ -892,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.8 → 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,9 @@ 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"},

{codecarbon-3.2.8 → 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.8 → 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
 

{codecarbon-3.2.8 → 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.8 → 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
 

codecarbon-3.2.9/codecarbon/core/hardware_cache.py

@@ -0,0 +1,249 @@
+"""
+Process-level cache for hardware detection and setup.
+
+Reuses the outcome of the first tracker hardware probe so additional runs on
+the same device (same process) skip repeated powermetrics, cpuinfo, and GPU
+detection work.
+"""
+
+from __future__ import annotations
+
+import threading
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, Tuple
+
+from codecarbon.core.config import normalize_gpu_ids
+
+if TYPE_CHECKING:
+    from codecarbon.core.resource_tracker import ResourceTracker
+
+DEFAULT_RAPL_DIR = "/sys/class/powercap/intel-rapl/subsystem"
+
+CONF_KEYS = (
+    "ram_total_size",
+    "cpu_count",
+    "cpu_physical_count",
+    "cpu_model",
+    "gpu_count",
+    "gpu_model",
+    "gpu_ids",
+)
+
+
+class HardwareKind(str, Enum):
+    RAM = "ram"
+    CPU = "cpu"
+    APPLE_CHIP = "apple_chip"
+    GPU = "gpu"
+
+
+_cache_lock = threading.Lock()
+_plans: Dict["_HardwareCacheKey", "_HardwarePlan"] = {}
+_tdp = None
+
+
+@dataclass(frozen=True)
+class _HardwareCacheKey:
+    tracking_mode: str
+    force_cpu_power: Any
+    force_ram_power: Any
+    force_mode_cpu_load: bool
+    gpu_ids: Any
+    rapl_include_dram: bool
+    rapl_prefer_psys: bool
+
+
+@dataclass
+class _HardwarePlan:
+    ram_tracker: str
+    cpu_tracker: str
+    gpu_tracker: str
+    conf: Dict[str, Any] = field(default_factory=dict)
+    hardware_specs: List[Dict[str, Any]] = field(default_factory=list)
+
+
+def _canonical_gpu_ids(
+    gpu_ids: Optional[List],
+) -> Optional[Tuple[str, ...]]:
+    """Normalize GPU ids to a stable cache-key form (tuple of strings)."""
+    if gpu_ids is None:
+        return None
+    if not isinstance(gpu_ids, (list, tuple)):
+        gpu_ids = [gpu_ids]
+    normalized = normalize_gpu_ids(list(gpu_ids))
+    if not normalized:
+        return None
+    return tuple(str(gpu_id) for gpu_id in normalized)
+
+
+def make_key(tracker) -> _HardwareCacheKey:
+    return _HardwareCacheKey(
+        tracking_mode=tracker._tracking_mode,
+        force_cpu_power=tracker._force_cpu_power,
+        force_ram_power=tracker._force_ram_power,
+        force_mode_cpu_load=bool(tracker._conf.get("force_mode_cpu_load", False)),
+        gpu_ids=_canonical_gpu_ids(tracker._gpu_ids),
+        rapl_include_dram=bool(tracker._rapl_include_dram),
+        rapl_prefer_psys=bool(tracker._rapl_prefer_psys),
+    )
+
+
+def get_cached_tdp(cpu_module):
+    """Return a shared cpu.TDP() instance for this process."""
+    global _tdp
+    if _tdp is None:
+        _tdp = cpu_module.TDP()
+    return _tdp
+
+
+def _hardware_kind(hw) -> HardwareKind:
+    """Classify hardware without isinstance (safe if modules were reloaded)."""
+    name = type(hw).__name__
+    if name == "RAM":
+        return HardwareKind.RAM
+    if name == "CPU":
+        return HardwareKind.CPU
+    if name == "AppleSiliconChip":
+        return HardwareKind.APPLE_CHIP
+    if name == "GPU":
+        return HardwareKind.GPU
+    raise TypeError(f"Unsupported hardware type for cache: {type(hw)}")
+
+
+def _spec_from_hardware(hw) -> Dict[str, Any]:
+    kind = _hardware_kind(hw)
+    if kind == HardwareKind.RAM:
+        return {
+            "kind": kind.value,
+            "tracking_mode": hw._tracking_mode,
+            "force_ram_power": hw._force_ram_power,
+        }
+    if kind == HardwareKind.CPU:
+        spec: Dict[str, Any] = {
+            "kind": kind.value,
+            "mode": hw._mode,
+            "model": hw._model,
+            "tdp": hw._tdp,
+            "tracking_mode": hw._tracking_mode,
+            "rapl_include_dram": False,
+            "rapl_prefer_psys": False,
+        }
+        if hw._mode == "intel_rapl" and hasattr(hw, "_intel_interface"):
+            intel = hw._intel_interface
+            spec["rapl_include_dram"] = getattr(intel, "rapl_include_dram", False)
+            spec["rapl_prefer_psys"] = getattr(intel, "rapl_prefer_psys", False)
+            spec["rapl_dir"] = getattr(intel, "_lin_rapl_dir", DEFAULT_RAPL_DIR)
+        return spec
+    if kind == HardwareKind.APPLE_CHIP:
+        return {
+            "kind": kind.value,
+            "model": hw._model,
+            "chip_part": hw.chip_part,
+        }
+    if kind == HardwareKind.GPU:
+        gpu_ids = _canonical_gpu_ids(hw.gpu_ids)
+        return {"kind": kind.value, "gpu_ids": list(gpu_ids) if gpu_ids else None}
+    raise TypeError(f"Unsupported hardware type for cache: {type(hw)}")
+
+
+def _hardware_from_spec(spec: Dict[str, Any], output_dir: str):
+    from codecarbon.external.hardware import CPU, GPU, AppleSiliconChip
+    from codecarbon.external.ram import RAM
+
+    try:
+        kind = HardwareKind(spec["kind"])
+    except ValueError as exc:
+        raise ValueError(f"Unknown hardware spec kind: {spec['kind']}") from exc
+
+    if kind == HardwareKind.RAM:
+        return RAM(
+            tracking_mode=spec["tracking_mode"],
+            force_ram_power=spec.get("force_ram_power"),
+        )
+    if kind == HardwareKind.CPU:
+        return CPU(
+            output_dir=output_dir,
+            mode=spec["mode"],
+            model=spec["model"],
+            tdp=spec["tdp"],
+            tracking_mode=spec["tracking_mode"],
+            rapl_dir=spec.get("rapl_dir", DEFAULT_RAPL_DIR),
+            rapl_include_dram=spec.get("rapl_include_dram", False),
+            rapl_prefer_psys=spec.get("rapl_prefer_psys", False),
+        )
+    if kind == HardwareKind.APPLE_CHIP:
+        return AppleSiliconChip(
+            output_dir=output_dir,
+            model=spec["model"],
+            chip_part=spec["chip_part"],
+        )
+    if kind == HardwareKind.GPU:
+        gpu_ids = _canonical_gpu_ids(spec.get("gpu_ids"))
+        return GPU.from_utils(gpu_ids=list(gpu_ids) if gpu_ids else None)
+    raise ValueError(f"Unknown hardware spec kind: {kind}")
+
+
+def capture(resource_tracker: "ResourceTracker") -> _HardwarePlan:
+    tracker = resource_tracker.tracker
+    conf = {k: tracker._conf[k] for k in CONF_KEYS if k in tracker._conf}
+    return _HardwarePlan(
+        ram_tracker=resource_tracker.ram_tracker,
+        cpu_tracker=resource_tracker.cpu_tracker,
+        gpu_tracker=resource_tracker.gpu_tracker,
+        conf=conf,
+        hardware_specs=[_spec_from_hardware(hw) for hw in tracker._hardware],
+    )
+
+
+def apply(resource_tracker: "ResourceTracker", plan: _HardwarePlan) -> None:
+    tracker = resource_tracker.tracker
+    resource_tracker.ram_tracker = plan.ram_tracker
+    resource_tracker.cpu_tracker = plan.cpu_tracker
+    resource_tracker.gpu_tracker = plan.gpu_tracker
+    tracker._conf.update(plan.conf)
+    if "gpu_ids" in plan.conf:
+        tracker._gpu_ids = plan.conf["gpu_ids"]
+    tracker._hardware = [
+        _hardware_from_spec(spec, tracker._output_dir) for spec in plan.hardware_specs
+    ]
+
+
+def get_or_run_setup(
+    resource_tracker: "ResourceTracker",
+    setup_fn,
+) -> None:
+    """Apply cached hardware plan or run full setup once per cache key."""
+    key = make_key(resource_tracker.tracker)
+    with _cache_lock:
+        plan = _plans.get(key)
+        if plan is not None:
+            apply(resource_tracker, plan)
+            return
+        setup_fn()
+        _plans[key] = capture(resource_tracker)
+
+
+def clear_cache() -> None:
+    """Clear cached plans (for tests)."""
+    global _tdp
+    import sys
+
+    with _cache_lock:
+        _plans.clear()
+    _tdp = None
+
+    for mod_name, clear_fn in (
+        ("codecarbon.core.gpu_nvidia", "clear_nvidia_system_cache"),
+        ("codecarbon.core.gpu_amd", "clear_rocm_system_cache"),
+        ("codecarbon.core.cpu", "clear_powergadget_cache"),
+        ("codecarbon.core.powermetrics", "clear_powermetrics_cache"),
+    ):
+        mod = sys.modules.get(mod_name)
+        if mod is not None:
+            getattr(mod, clear_fn)()
+
+    if "codecarbon.external.hardware" in sys.modules:
+        from codecarbon.external.hardware import clear_cpu_load_prime_cache
+
+        clear_cpu_load_prime_cache()

{codecarbon-3.2.8 → codecarbon-3.2.9}/codecarbon/core/powermetrics.py

@@ -3,6 +3,8 @@ import re
 import shutil
 import subprocess
 import sys
+import time
+from functools import lru_cache
 from typing import Dict
 
 import numpy as np
@@ -11,11 +13,11 @@ from codecarbon.core.util import detect_cpu_model
 from codecarbon.external.logger import logger
 
 
+@lru_cache(maxsize=1)
 def is_powermetrics_available() -> bool:
     try:
         ApplePowermetrics()
-        response = _has_powermetrics_sudo()
-        return response
+        return _has_powermetrics_sudo()
     except Exception as e:
         logger.debug(
             "Not using PowerMetrics, an exception occurred while instantiating"
@@ -24,6 +26,10 @@ def is_powermetrics_available() -> bool:
         return False
 
 
+def clear_powermetrics_cache() -> None:
+    is_powermetrics_available.cache_clear()
+
+
 def _has_powermetrics_sudo() -> bool:
     if shutil.which("sudo") is None:
         logger.debug("sudo not available, we won't use Apple PowerMetrics.")
@@ -51,6 +57,13 @@ def _has_powermetrics_sudo() -> bool:
         stderr=subprocess.PIPE,
         text=True,
     ) as process:
+        deadline = time.time() + 3
+        while process.poll() is None and time.time() < deadline:
+            time.sleep(0.05)
+        if process.poll() is None:
+            process.kill()
+            logger.debug("PowerMetrics sudo check timed out.")
+            return False
         _, stderr = process.communicate()
 
         if re.search(r"[sudo].*password", stderr):