codecarbon 2.3.2__tar.gz → 2.3.4__tar.gz

{codecarbon-2.3.2/codecarbon.egg-info → codecarbon-2.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: codecarbon
-Version: 2.3.2
+Version: 2.3.4
 Author: Mila, DataForGood, BCG GAMMA, Comet.ml, Haverford College
 Classifier: Natural Language :: English
 Classifier: Programming Language :: Python :: 3.7
@@ -18,7 +18,7 @@ Requires-Dist: pynvml
 Requires-Dist: requests
 Requires-Dist: psutil
 Requires-Dist: py-cpuinfo
-Requires-Dist: fuzzywuzzy
+Requires-Dist: rapidfuzz
 Requires-Dist: click
 Requires-Dist: prometheus_client
 Provides-Extra: viz

codecarbon-2.3.4/codecarbon/_version.py

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

{codecarbon-2.3.2 → codecarbon-2.3.4}/codecarbon/core/cpu.py

@@ -7,13 +7,10 @@ import os
 import shutil
 import subprocess
 import sys
-import warnings
 from typing import Dict, Tuple
 
 import pandas as pd
-
-with warnings.catch_warnings(record=True) as w:
-    from fuzzywuzzy import fuzz
+from rapidfuzz import fuzz, process, utils
 
 from codecarbon.core.rapl import RAPLFile
 from codecarbon.core.units import Time
@@ -50,8 +47,6 @@ class IntelPowerGadget:
     _osx_exec = "PowerLog"
     _osx_exec_backup = "/Applications/Intel Power Gadget/PowerLog"
     _windows_exec = "PowerLog3.0.exe"
-    # TODO: There is now a 3.6 version.
-    _windows_exec_backup = "C:\\Program Files\\Intel\\Power Gadget 3.5\\PowerLog3.0.exe"
 
     def __init__(
         self,
@@ -71,6 +66,7 @@ class IntelPowerGadget:
         Setup cli command to run Intel Power Gadget
         """
         if self._system.startswith("win"):
+            self._get_windows_exec_backup()
             if shutil.which(self._windows_exec):
                 self._cli = shutil.which(
                     self._windows_exec
@@ -93,6 +89,27 @@ class IntelPowerGadget:
         else:
             raise SystemError("Platform not supported by Intel Power Gadget")
 
+    def _get_windows_exec_backup(self) -> None:
+        """
+        Find the windows executable for the current version of intel power gadget.
+        Example: "C:\\Program Files\\Intel\\Power Gadget 3.5\\PowerLog3.0.exe"
+        """
+        parent_folder = "C:\\Program Files\\Intel\\"
+
+        # Get a list of all subdirectories in the parent folder
+        subfolders = [f.name for f in os.scandir(parent_folder) if f.is_dir()]
+
+        # Look for a folder that contains "Power Gadget" in its name
+        desired_folder = next(
+            (folder for folder in subfolders if "Power Gadget" in folder), None
+        )
+        if desired_folder:
+            self._windows_exec_backup = os.path.join(
+                parent_folder, desired_folder, self._windows_exec
+            )
+        else:
+            self._windows_exec_backup = None
+
     def _log_values(self):
         """
         Logs output from Intel Power Gadget command line to a file
@@ -278,27 +295,6 @@ class TDP:
             return power
         return None
 
-    @staticmethod
-    def _get_cpus(cpu_df, cpu_idxs) -> list:
-        return [cpu_df["Name"][idx] for idx in cpu_idxs]
-
-    @staticmethod
-    def _get_direct_matches(moodel: str, cpu_df: pd.DataFrame) -> list:
-        model_l = moodel.lower()
-        return [fuzz.ratio(model_l, cpu.lower()) for cpu in cpu_df["Name"]]
-
-    @staticmethod
-    def _get_token_set_matches(model: str, cpu_df: pd.DataFrame) -> list:
-        return [fuzz.token_set_ratio(model, cpu) for cpu in cpu_df["Name"]]
-
-    @staticmethod
-    def _get_single_direct_match(
-        ratios: list, max_ratio: int, cpu_df: pd.DataFrame
-    ) -> str:
-        idx = ratios.index(max_ratio)
-        cpu_matched = cpu_df["Name"].iloc[idx]
-        return cpu_matched
-
     def _get_matching_cpu(
         self, model_raw: str, cpu_df: pd.DataFrame, greedy=False
     ) -> str:
@@ -332,33 +328,35 @@ class TDP:
         THRESHOLD_DIRECT = 100
         THRESHOLD_TOKEN_SET = 100
 
-        ratios_direct = self._get_direct_matches(model_raw, cpu_df)
-        ratios_token_set = self._get_token_set_matches(model_raw, cpu_df)
-        max_ratio_direct = max(ratios_direct)
-        max_ratio_token_set = max(ratios_token_set)
+        direct_match = process.extractOne(
+            model_raw,
+            cpu_df["Name"],
+            processor=lambda s: s.lower(),
+            scorer=fuzz.ratio,
+            score_cutoff=THRESHOLD_DIRECT,
+        )
+
+        if direct_match:
+            return direct_match[0]
 
-        # Check if a direct match exists
-        if max_ratio_direct >= THRESHOLD_DIRECT:
-            cpu_matched = self._get_single_direct_match(
-                ratios_direct, max_ratio_direct, cpu_df
-            )
-            return cpu_matched
+        indirect_matches = process.extract(
+            model_raw,
+            cpu_df["Name"],
+            processor=utils.default_process,
+            scorer=fuzz.token_set_ratio,
+            score_cutoff=THRESHOLD_TOKEN_SET,
+        )
 
-        # Check if an indirect match exists
-        if max_ratio_token_set < THRESHOLD_TOKEN_SET:
-            return None
-        cpu_idxs = self._get_max_idxs(ratios_token_set, max_ratio_token_set)
-        cpu_machings = self._get_cpus(cpu_df, cpu_idxs)
+        if indirect_matches:
+            if (
+                greedy
+                or len(indirect_matches) == 1
+                or indirect_matches[0][1] != indirect_matches[1][1]
+            ):
+                return indirect_matches[0][0]
 
-        if (cpu_machings and len(cpu_machings) == 1) or greedy:
-            cpu_matched = cpu_machings[0]
-            return cpu_matched
         return None
 
-    @staticmethod
-    def _get_max_idxs(ratios: list, max_ratio: int) -> list:
-        return [idx for idx, ratio in enumerate(ratios) if ratio == max_ratio]
-
     def _main(self) -> Tuple[str, int]:
         """
         Get CPU power from constant mode

{codecarbon-2.3.2 → codecarbon-2.3.4}/codecarbon/core/emissions.py

@@ -71,32 +71,49 @@ class Emissions:
         Returns the Country Name where the cloud region is located
         """
         df: pd.DataFrame = self._data_source.get_cloud_emissions_data()
-        return df.loc[
-            (df["provider"] == cloud.provider) & (df["region"] == cloud.region)
-        ]["country_name"].item()
+        flags = (df["provider"] == cloud.provider) & (df["region"] == cloud.region)
+        selected = df.loc[flags]
+        if not len(selected):
+            raise ValueError(
+                "Unable to find country name for "
+                f"cloud_provider={cloud.provider}, "
+                f"cloud_region={cloud.region}"
+            )
+        return selected["country_name"].item()
 
     def get_cloud_country_iso_code(self, cloud: CloudMetadata) -> str:
         """
         Returns the Country ISO Code where the cloud region is located
         """
         df: pd.DataFrame = self._data_source.get_cloud_emissions_data()
-        return df.loc[
-            (df["provider"] == cloud.provider) & (df["region"] == cloud.region)
-        ]["countryIsoCode"].item()
+        flags = (df["provider"] == cloud.provider) & (df["region"] == cloud.region)
+        selected = df.loc[flags]
+        if not len(selected):
+            raise ValueError(
+                "Unable to find country name for "
+                f"cloud_provider={cloud.provider}, "
+                f"cloud_region={cloud.region}"
+            )
+        return selected["countryIsoCode"].item()
 
     def get_cloud_geo_region(self, cloud: CloudMetadata) -> str:
         """
         Returns the State/City where the cloud region is located
         """
         df: pd.DataFrame = self._data_source.get_cloud_emissions_data()
-        state = df.loc[
-            (df["provider"] == cloud.provider) & (df["region"] == cloud.region)
-        ]["state"].item()
+        flags = (df["provider"] == cloud.provider) & (df["region"] == cloud.region)
+        selected = df.loc[flags]
+        if not len(selected):
+            raise ValueError(
+                "Unable to find country name for "
+                f"cloud_provider={cloud.provider}, "
+                f"cloud_region={cloud.region}"
+            )
+
+        state = selected["state"].item()
         if state is not None:
             return state
-        city = df.loc[
-            (df["provider"] == cloud.provider) & (df["region"] == cloud.region)
-        ]["city"].item()
+        city = selected["city"].item()
         return city
 
     def get_private_infra_emissions(self, energy: Energy, geo: GeoMetadata) -> float:

{codecarbon-2.3.2 → codecarbon-2.3.4}/codecarbon/core/measure.py

@@ -1,6 +1,6 @@
 from time import time
 
-from codecarbon.external.hardware import CPU, GPU, RAM
+from codecarbon.external.hardware import CPU, GPU, RAM, AppleSiliconChip
 from codecarbon.external.logger import logger
 
 
@@ -67,9 +67,24 @@ class MeasurePowerEnergy:
                 self._total_ram_energy += energy
                 self._ram_power = power
                 logger.info(
-                    f"Energy consumed for RAM : {self._total_ram_energy.kWh:.6f} kWh"
-                    + f". RAM Power : {self._ram_power.W} W"
+                    f"Energy consumed for RAM : {self._total_ram_energy.kWh:.6f} kWh."
+                    + f"RAM Power : {self._ram_power.W} W"
                 )
+            elif isinstance(hardware, AppleSiliconChip):
+                if hardware.chip_part == "CPU":
+                    self._total_cpu_energy += energy
+                    self._cpu_power = power
+                    logger.info(
+                        f"Energy consumed for AppleSilicon CPU : {self._total_cpu_energy.kWh:.6f} kWh"
+                        + f".Apple Silicon CPU Power : {self._cpu_power.W} W"
+                    )
+                elif hardware.chip_part == "GPU":
+                    self._total_gpu_energy += energy
+                    self._gpu_power = power
+                    logger.info(
+                        f"Energy consumed for AppleSilicon GPU : {self._total_gpu_energy.kWh:.6f} kWh"
+                        + f".Apple Silicon GPU Power : {self._gpu_power.W} W"
+                    )
             else:
                 logger.error(f"Unknown hardware type: {hardware} ({type(hardware)})")
             h_time = time.time() - h_time

codecarbon-2.3.4/codecarbon/core/powermetrics.py

@@ -0,0 +1,173 @@
+import os
+import re
+import shutil
+import subprocess
+import sys
+from typing import Dict
+
+import numpy as np
+
+from codecarbon.core.util import detect_cpu_model
+from codecarbon.external.logger import logger
+
+
+def is_powermetrics_available():
+    try:
+        ApplePowermetrics()
+        response = _has_powermetrics_sudo()
+        return response
+    except Exception as e:
+        logger.debug(
+            "Not using PowerMetrics, an exception occurred while instantiating"
+            + f" Powermetrics : {e}",
+        )
+        return False
+
+
+def _has_powermetrics_sudo():
+    process = subprocess.Popen(
+        [
+            "sudo",
+            "powermetrics",
+            "--samplers",
+            "cpu_power",
+            "-n",
+            "1",
+            "-i",
+            "1",
+            "-o",
+            "/dev/null",
+        ],
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        text=True,
+    )
+
+    _, stderr = process.communicate()
+
+    if re.search(r"[sudo].*password", stderr):
+        logger.debug(
+            """Not using PowerMetrics, sudo password prompt detected.
+                If you want to enable Powermetrics please modify your sudoers file
+                as described in :
+                https://mlco2.github.io/codecarbon/methodology.html#power-usage
+            """
+        )
+        return False
+    if process.returncode != 0:
+        raise Exception("Return code != 0")
+    else:
+        return True
+
+
+class ApplePowermetrics:
+    _osx_silicon_exec = "powermetrics"
+
+    def __init__(
+        self,
+        output_dir: str = ".",
+        n_points=10,
+        interval=100,
+        log_file_name="powermetrics_log.txt",
+    ):
+        self._log_file_path = os.path.join(output_dir, log_file_name)
+        self._system = sys.platform.lower()
+        self._n_points = n_points
+        self._interval = interval
+        self._setup_cli()
+
+    def _setup_cli(self):
+        """
+        Setup cli command to run Powermetrics
+        """
+        if self._system.startswith("darwin"):
+            cpu_model = detect_cpu_model()
+            if cpu_model.startswith("Apple"):
+                if shutil.which(self._osx_silicon_exec):
+                    self._cli = self._osx_silicon_exec
+                else:
+                    raise FileNotFoundError(
+                        f"Powermetrics executable not found on {self._system}"
+                    )
+        else:
+            raise SystemError("Platform not supported by Powermetrics")
+
+    def _log_values(self):
+        """
+        Logs output from Powermetrics to a file
+        """
+        returncode = None
+
+        if self._system.startswith("darwin"):
+            # Run the powermetrics command with sudo and capture its output
+            cmd = [
+                "sudo",
+                "powermetrics",
+                "-n",
+                str(self._n_points),
+                "",
+                "--samplers",
+                "cpu_power",
+                "--format",
+                "csv",
+                "-i",
+                str(self._interval),
+                "-o",
+                self._log_file_path,
+            ]
+            returncode = subprocess.call(cmd, universal_newlines=True)
+
+        else:
+            return None
+
+        if returncode != 0:
+            logger.warning(
+                "Returncode while logging power values using "
+                + f"Powermetrics: {returncode}"
+            )
+        return
+
+    def get_details(self, **kwargs) -> Dict:
+        """
+        Fetches the CPU Power Details by fetching values from a logged csv file
+        in _log_values function
+        """
+        self._log_values()
+        details = dict()
+        try:
+            with open(self._log_file_path) as f:
+                logfile = f.read()
+            cpu_pattern = r"CPU Power: (\d+) mW"
+            cpu_power_list = re.findall(cpu_pattern, logfile)
+
+            details["CPU Power"] = np.mean(
+                [float(power) / 1000 for power in cpu_power_list]
+            )
+            details["CPU Energy Delta"] = np.sum(
+                [
+                    (self._interval / 1000) * (float(power) / 1000)
+                    for power in cpu_power_list
+                ]
+            )
+            gpu_pattern = r"GPU Power: (\d+) mW"
+            gpu_power_list = re.findall(gpu_pattern, logfile)
+            details["GPU Power"] = np.mean(
+                [float(power) / 1000 for power in gpu_power_list]
+            )
+            details["GPU Energy Delta"] = np.sum(
+                [
+                    (self._interval / 1000) * (float(power) / 1000)
+                    for power in gpu_power_list
+                ]
+            )
+        except Exception as e:
+            logger.info(
+                f"Unable to read Powermetrics logged file at {self._log_file_path}\n \
+                Exception occurred {e}",
+                exc_info=True,
+            )
+        return details
+
+    def start(self):
+        # TODO: Read energy
+        pass

{codecarbon-2.3.2 → codecarbon-2.3.4}/codecarbon/emissions_tracker.py

@@ -14,13 +14,13 @@ from functools import wraps
 from typing import Any, Callable, Dict, List, Optional, Union
 
 from codecarbon._version import __version__
-from codecarbon.core import cpu, gpu
+from codecarbon.core import cpu, gpu, powermetrics
 from codecarbon.core.config import get_hierarchical_config, parse_gpu_ids
 from codecarbon.core.emissions import Emissions
 from codecarbon.core.units import Energy, Power, Time
 from codecarbon.core.util import count_cpus, suppress
 from codecarbon.external.geography import CloudMetadata, GeoMetadata
-from codecarbon.external.hardware import CPU, GPU, RAM
+from codecarbon.external.hardware import CPU, GPU, RAM, AppleSiliconChip
 from codecarbon.external.logger import logger, set_logger_format, set_logger_level
 from codecarbon.external.scheduler import PeriodicScheduler
 from codecarbon.external.task import Task
@@ -275,7 +275,7 @@ class BaseEmissionsTracker(ABC):
         logger.info("[setup] RAM Tracking...")
         ram = RAM(tracking_mode=self._tracking_mode)
         self._conf["ram_total_size"] = ram.machine_memory_GB
-        self._hardware: List[Union[RAM, CPU, GPU]] = [ram]
+        self._hardware: List[Union[RAM, CPU, GPU, AppleSiliconChip]] = [ram]
 
         # Hardware detection
         logger.info("[setup] GPU Tracking...")
@@ -293,7 +293,7 @@ class BaseEmissionsTracker(ABC):
             logger.info("No GPU found.")
 
         logger.info("[setup] CPU Tracking...")
-        if cpu.is_powergadget_available():
+        if cpu.is_powergadget_available() and self._default_cpu_power is None:
             logger.info("Tracking Intel CPU via Power Gadget")
             hardware = CPU.from_utils(self._output_dir, "intel_power_gadget")
             self._hardware.append(hardware)
@@ -303,6 +303,23 @@ class BaseEmissionsTracker(ABC):
             hardware = CPU.from_utils(self._output_dir, "intel_rapl")
             self._hardware.append(hardware)
             self._conf["cpu_model"] = hardware.get_model()
+        elif (
+            powermetrics.is_powermetrics_available() and self._default_cpu_power is None
+        ):
+            logger.info("Tracking Apple CPU and GPU via PowerMetrics")
+            hardware_cpu = AppleSiliconChip.from_utils(
+                self._output_dir, chip_part="CPU"
+            )
+            self._hardware.append(hardware_cpu)
+            self._conf["cpu_model"] = hardware_cpu.get_model()
+
+            hardware_gpu = AppleSiliconChip.from_utils(
+                self._output_dir, chip_part="GPU"
+            )
+            self._hardware.append(hardware_gpu)
+
+            self._conf["gpu_model"] = hardware_gpu.get_model()
+            self._conf["gpu_count"] = 1
         else:
             logger.warning(
                 "No CPU tracking mode found. Falling back on CPU constant mode."
@@ -640,9 +657,10 @@ class BaseEmissionsTracker(ABC):
             h_time = time.time()
             # Compute last_duration again for more accuracy
             last_duration = time.time() - self._last_measured_time
-            power, energy = hardware.measure_power_and_energy(
-                last_duration=last_duration
-            )
+            (
+                power,
+                energy,
+            ) = hardware.measure_power_and_energy(last_duration=last_duration)
             # Apply the PUE of the datacenter to the consumed energy
             energy *= self._pue
             self._total_energy += energy
@@ -667,6 +685,21 @@ class BaseEmissionsTracker(ABC):
                     f"Energy consumed for RAM : {self._total_ram_energy.kWh:.6f} kWh"
                     + f". RAM Power : {self._ram_power.W} W"
                 )
+            elif isinstance(hardware, AppleSiliconChip):
+                if hardware.chip_part == "CPU":
+                    self._total_cpu_energy += energy
+                    self._cpu_power = power
+                    logger.info(
+                        f"Energy consumed for all CPUs : {self._total_cpu_energy.kWh:.6f} kWh"
+                        + f". Total CPU Power : {self._cpu_power.W} W"
+                    )
+                elif hardware.chip_part == "GPU":
+                    self._total_gpu_energy += energy
+                    self._gpu_power = power
+                    logger.info(
+                        f"Energy consumed for all GPUs : {self._total_gpu_energy.kWh:.6f} kWh"
+                        + f". Total GPU Power : {self._gpu_power.W} W"
+                    )
             else:
                 logger.error(f"Unknown hardware type: {hardware} ({type(hardware)})")
             h_time = time.time() - h_time
@@ -704,7 +737,7 @@ class BaseEmissionsTracker(ABC):
                 emissions = self._prepare_emissions_data(delta=True)
                 logger.info(
                     f"{emissions.emissions_rate * 1000:.6f} g.CO2eq/s mean an estimation of "
-                    + f"{emissions.emissions_rate*3600*24*365:,} kg.CO2eq/year"
+                    + f"{emissions.emissions_rate * 3600 * 24 * 365:,} kg.CO2eq/year"
                 )
                 if self._cc_api__out:
                     self._cc_api__out.out(emissions)

{codecarbon-2.3.2 → codecarbon-2.3.4}/codecarbon/external/hardware.py

@@ -11,6 +11,7 @@ import psutil
 
 from codecarbon.core.cpu import IntelPowerGadget, IntelRAPL
 from codecarbon.core.gpu import AllGPUDevices
+from codecarbon.core.powermetrics import ApplePowermetrics
 from codecarbon.core.units import Energy, Power, Time
 from codecarbon.core.util import SLURM_JOB_ID, detect_cpu_model
 from codecarbon.external.logger import logger
@@ -202,7 +203,7 @@ class CPU(BaseHardware):
         return super().measure_power_and_energy(last_duration=last_duration)
 
     def start(self):
-        if self._mode in ["intel_power_gadget", "intel_rapl"]:
+        if self._mode in ["intel_power_gadget", "intel_rapl", "apple_powermetrics"]:
             self._intel_interface.start()
         pass
 
@@ -395,3 +396,75 @@ class RAM(BaseHardware):
             ram_power = Power.from_watts(0)
 
         return ram_power
+
+
+@dataclass
+class AppleSiliconChip(BaseHardware):
+    def __init__(
+        self,
+        output_dir: str,
+        model: str,
+        chip_part: str = "CPU",
+    ):
+        self._output_dir = output_dir
+        self._model = model
+        self._interface = ApplePowermetrics(self._output_dir)
+        self.chip_part = chip_part
+
+    def __repr__(self) -> str:
+        return f"AppleSiliconChip ({self._model} > {self.chip_part})"
+
+    def _get_power(self) -> Power:
+        """
+        Get Chip part power
+        Args:
+            chip_part (str): Chip part to get power from (CPU, GPU)
+        :return: power in kW
+        """
+
+        all_details: Dict = self._interface.get_details()
+
+        power = 0
+        for metric, value in all_details.items():
+            if re.match(rf"^{self.chip_part} Power", metric):
+                power += value
+                logger.debug(f"_get_power_from_cpus - MATCH {metric} : {value}")
+
+            else:
+                logger.debug(f"_get_power_from_cpus - DONT MATCH {metric} : {value}")
+        return Power.from_watts(power)
+
+    def _get_energy(self, delay: Time) -> Energy:
+        """
+        Get Chip part energy deltas
+        Args:
+            chip_part (str): Chip part to get power from (Processor, GPU, etc.)
+        :return: energy in kWh
+        """
+        all_details: Dict = self._interface.get_details(delay)
+
+        energy = 0
+        for metric, value in all_details.items():
+            if re.match(rf"^{self.chip_part} Energy Delta_\d", metric):
+                energy += value
+        return Energy.from_energy(energy)
+
+    def total_power(self) -> Power:
+        return self._get_power()
+
+    def start(self):
+        self._interface.start()
+
+    def get_model(self):
+        return self._model
+
+    @classmethod
+    def from_utils(
+        cls, output_dir: str, model: Optional[str] = None, chip_part: str = "Processor"
+    ) -> "AppleSiliconChip":
+        if model is None:
+            model = detect_cpu_model()
+            if model is None:
+                logger.warning("Could not read AppleSiliconChip model.")
+
+        return cls(output_dir=output_dir, model=model, chip_part=chip_part)

{codecarbon-2.3.2 → codecarbon-2.3.4/codecarbon.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: codecarbon
-Version: 2.3.2
+Version: 2.3.4
 Author: Mila, DataForGood, BCG GAMMA, Comet.ml, Haverford College
 Classifier: Natural Language :: English
 Classifier: Programming Language :: Python :: 3.7
@@ -18,7 +18,7 @@ Requires-Dist: pynvml
 Requires-Dist: requests
 Requires-Dist: psutil
 Requires-Dist: py-cpuinfo
-Requires-Dist: fuzzywuzzy
+Requires-Dist: rapidfuzz
 Requires-Dist: click
 Requires-Dist: prometheus_client
 Provides-Extra: viz

{codecarbon-2.3.2 → codecarbon-2.3.4}/codecarbon.egg-info/SOURCES.txt

@@ -54,6 +54,7 @@ codecarbon/core/cpu.py
 codecarbon/core/emissions.py
 codecarbon/core/gpu.py
 codecarbon/core/measure.py
+codecarbon/core/powermetrics.py
 codecarbon/core/rapl.py
 codecarbon/core/schemas.py
 codecarbon/core/units.py
@@ -96,6 +97,7 @@ tests/test_energy.py
 tests/test_geography.py
 tests/test_gpu.py
 tests/test_logging_output.py
+tests/test_powermetrics.py
 tests/test_ram.py
 tests/test_tracking_inference.py
 tests/test_viz_data.py

{codecarbon-2.3.2 → codecarbon-2.3.4}/codecarbon.egg-info/requires.txt

@@ -4,7 +4,7 @@ pynvml
 requests
 psutil
 py-cpuinfo
-fuzzywuzzy
+rapidfuzz
 click
 prometheus_client
 

{codecarbon-2.3.2 → codecarbon-2.3.4}/setup.py

@@ -10,7 +10,7 @@ DEPENDENCIES = [
     "requests",
     "psutil",
     "py-cpuinfo",
-    "fuzzywuzzy",
+    "rapidfuzz",
     "click",
     "prometheus_client",
 ]
@@ -20,7 +20,7 @@ TEST_DEPENDENCIES = ["mock", "pytest", "responses", "tox", "numpy", "requests-mo
 
 setuptools.setup(
     name="codecarbon",
-    version="2.3.2",
+    version="2.3.4",
     author="Mila, DataForGood, BCG GAMMA, Comet.ml, Haverford College",
     long_description=long_description,
     long_description_content_type="text/markdown",

{codecarbon-2.3.2 → codecarbon-2.3.4}/tests/test_cpu.py

@@ -5,7 +5,12 @@ from unittest import mock
 
 import pytest
 
-from codecarbon.core.cpu import TDP, IntelPowerGadget, IntelRAPL
+from codecarbon.core.cpu import (
+    TDP,
+    IntelPowerGadget,
+    IntelRAPL,
+    is_powergadget_available,
+)
 from codecarbon.core.units import Energy, Power, Time
 from codecarbon.external.hardware import CPU
 from codecarbon.input import DataSource
@@ -14,9 +19,10 @@ from codecarbon.input import DataSource
 class TestIntelPowerGadget(unittest.TestCase):
     @pytest.mark.integ_test
     def test_intel_power_gadget(self):
-        power_gadget = IntelPowerGadget()
-        cpu_details = power_gadget.get_cpu_details()
-        assert len(cpu_details) > 0
+        if is_powergadget_available():
+            power_gadget = IntelPowerGadget()
+            cpu_details = power_gadget.get_cpu_details()
+            assert len(cpu_details) > 0
 
     @mock.patch("codecarbon.core.cpu.IntelPowerGadget._log_values")
     @mock.patch("codecarbon.core.cpu.IntelPowerGadget._setup_cli")
@@ -45,16 +51,16 @@ class TestIntelPowerGadget(unittest.TestCase):
             "GT Frequency(MHz)": 125.0,
             "GT Requsted Frequency(MHz)": 125.0,
         }
-
-        power_gadget = IntelPowerGadget(
-            output_dir=os.path.join(os.path.dirname(__file__), "test_data"),
-            log_file_name="mock_intel_power_gadget_data.csv",
-        )
-        cpu_details = power_gadget.get_cpu_details()
-        cpu_details["Cumulative IA Energy_0(mWh)"] = round(
-            cpu_details["Cumulative IA Energy_0(mWh)"], 3
-        )
-        self.assertDictEqual(expected_cpu_details, cpu_details)
+        if is_powergadget_available():
+            power_gadget = IntelPowerGadget(
+                output_dir=os.path.join(os.path.dirname(__file__), "test_data"),
+                log_file_name="mock_intel_power_gadget_data.csv",
+            )
+            cpu_details = power_gadget.get_cpu_details()
+            cpu_details["Cumulative IA Energy_0(mWh)"] = round(
+                cpu_details["Cumulative IA Energy_0(mWh)"], 3
+            )
+            self.assertDictEqual(expected_cpu_details, cpu_details)
 
 
 class TestIntelRAPL(unittest.TestCase):

{codecarbon-2.3.2 → codecarbon-2.3.4}/tests/test_emissions_tracker_constant.py

@@ -99,3 +99,34 @@ class TestCarbonTrackerConstant(unittest.TestCase):
         with open(file_path, "r") as f:
             lines = [line.rstrip() for line in f]
         assert len(lines) == 2
+
+    def test_carbon_tracker_offline_region_error(self):
+        # Test errors when unknown information is given to the offline tracker
+        from codecarbon.external.geography import CloudMetadata
+
+        tracker = OfflineEmissionsTracker(
+            country_iso_code="USA",
+            cloud_provider="aws",
+            cloud_region="us-east-1",
+            output_dir=self.emissions_path,
+            output_file=self.emissions_file,
+        )
+        tracker.start()
+        tracker._measure_power_and_energy()
+        cloud: CloudMetadata = tracker._get_cloud_metadata()
+
+        try:
+            with self.assertRaises(ValueError) as context:
+                tracker._emissions.get_cloud_country_iso_code(cloud)
+            self.assertTrue("Unable to find country name" in context.exception.args[0])
+
+            with self.assertRaises(ValueError) as context:
+                tracker._emissions.get_cloud_geo_region(cloud)
+            self.assertTrue("Unable to find country name" in context.exception.args[0])
+
+            with self.assertRaises(ValueError) as context:
+                tracker._emissions.get_cloud_country_name(cloud)
+            self.assertTrue("Unable to find country name" in context.exception.args[0])
+
+        finally:
+            tracker.stop()

codecarbon-2.3.4/tests/test_powermetrics.py

@@ -0,0 +1,35 @@
+import os
+import unittest
+import unittest.result
+from unittest import mock
+
+import pytest
+
+from codecarbon.core.powermetrics import ApplePowermetrics, is_powermetrics_available
+
+
+class TestApplePowerMetrics(unittest.TestCase):
+    @pytest.mark.integ_test
+    def test_apple_powermetrics(self):
+        if is_powermetrics_available():
+            power_gadget = ApplePowermetrics()
+            details = power_gadget.get_details()
+            assert len(details) > 0
+
+    @mock.patch("codecarbon.core.powermetrics.ApplePowermetrics._log_values")
+    @mock.patch("codecarbon.core.powermetrics.ApplePowermetrics._setup_cli")
+    def test_get_details(self, mock_setup, mock_log_values):
+        expected_details = {
+            "CPU Power": 0.3146,
+            "CPU Energy Delta": 0.3146,
+            "GPU Power": 0.0386,
+            "GPU Energy Delta": 0.0386,
+        }
+        if is_powermetrics_available():
+            powermetrics = ApplePowermetrics(
+                output_dir=os.path.join(os.path.dirname(__file__), "test_data"),
+                log_file_name="mock_powermetrics_log.txt",
+            )
+            cpu_details = powermetrics.get_details()
+
+            self.assertDictEqual(expected_details, cpu_details)

codecarbon-2.3.2/codecarbon/_version.py

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