codecarbon 3.0.4__tar.gz → 3.0.5__tar.gz

{codecarbon-3.0.4 → codecarbon-3.0.5}/PKG-INFO

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

codecarbon-3.0.5/codecarbon/_version.py

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

{codecarbon-3.0.4 → codecarbon-3.0.5}/codecarbon/core/config.py

@@ -1,7 +1,7 @@
 import configparser
 import os
 from pathlib import Path
-from typing import List
+from typing import List, Union
 
 from codecarbon.external.logger import logger
 
@@ -44,24 +44,33 @@ def parse_env_config() -> dict:
     }
 
 
-def parse_gpu_ids(gpu_ids_str: str) -> List[int]:
+def parse_gpu_ids(gpu_ids: Union[str, List[int]]) -> List[str]:
     """
-    Transforms the potential gpu_ids string into a list of int values
+    Transforms the potential gpu_ids into a list of string id values.
+
 
     Args:
-        gpu_ids_str (str): The config file or environment variable value for `gpu_ids`
-        which is read as a string and should be parsed into a list of ints
+        gpu_ids: The config file or environment variable value for `gpu_ids`
 
     Returns:
-        list[int]: The list of GPU ids available declared by the user.
+        list[str]: The list of GPU ids available.
             Potentially empty.
     """
-    if not isinstance(gpu_ids_str, str):
-        return gpu_ids_str
-
-    gpu_ids_str = "".join(c for c in gpu_ids_str if (c.isalnum() or c == ","))
-    str_ids = [gpu_id for gpu_id in gpu_ids_str.split(",") if gpu_id]
-    return list(map(int, str_ids))
+    if isinstance(gpu_ids, str):
+        # Allow '-' in id strings since UUIDs may include them.
+        gpu_ids = "".join(c for c in gpu_ids if (c.isalnum() or c in ("-", ",")))
+        str_ids = [gpu_id for gpu_id in gpu_ids.split(",") if gpu_id]
+        return str_ids
+
+    elif isinstance(gpu_ids, list) and all(
+        isinstance(gpu_id, int) for gpu_id in gpu_ids
+    ):
+        return list(map(str, gpu_ids))
+
+    else:
+        logger.warning(
+            "Invalid gpu_ids format. Expected a string or a list of ints/strings."
+        )
 
 
 def get_hierarchical_config():

{codecarbon-3.0.4 → codecarbon-3.0.5}/codecarbon/core/resource_tracker.py

@@ -183,18 +183,11 @@ class ResourceTracker:
     def set_GPU_tracking(self):
         logger.info("[setup] GPU Tracking...")
         if self.tracker._gpu_ids:
-            # If _gpu_ids is a string or a list of int, parse it to a list of ints
-            if isinstance(self.tracker._gpu_ids, str) or (
-                isinstance(self.tracker._gpu_ids, list)
-                and all(isinstance(gpu_id, int) for gpu_id in self.tracker._gpu_ids)
-            ):
-                self.tracker._gpu_ids: List[int] = parse_gpu_ids(self.tracker._gpu_ids)
+            self.tracker._gpu_ids = parse_gpu_ids(self.tracker._gpu_ids)
+            if self.tracker._gpu_ids:
                 self.tracker._conf["gpu_ids"] = self.tracker._gpu_ids
                 self.tracker._conf["gpu_count"] = len(self.tracker._gpu_ids)
-            else:
-                logger.warning(
-                    "Invalid gpu_ids format. Expected a string or a list of ints."
-                )
+
         if gpu.is_gpu_details_available():
             logger.info("Tracking Nvidia GPU via pynvml")
             gpu_devices = GPU.from_utils(self.tracker._gpu_ids)

{codecarbon-3.0.4 → codecarbon-3.0.5}/codecarbon/data/hardware/cpu_power.csv

@@ -1538,6 +1538,7 @@ AMD Turion X2 Ultra ZM-88,35
 AMD X940,45.0
 AMD Z-01,6
 AMD Z-60,5
+ARMv8 Processor rev 0 (v8l),30
 Apple M1,10
 Athlon 5150 APU,25
 Athlon 5350 APU,25
@@ -3111,6 +3112,7 @@ Intel Core i9-11900K,125.0
 Intel Core i9-11900KF,125.0
 Intel Core i9-11900T,35.0
 Intel Core i9-13900E,65.0
+Intel Core i9-13900K,125.0
 Intel Core i9-13900TE,35.0
 Intel Core i9-14900HX,55.0
 Intel Core i9-7900X,140

codecarbon-3.0.5/codecarbon/data/private_infra/2023/canada_energy_mix.json

@@ -0,0 +1,171 @@
+{
+    "british columbia": {
+        "naturalGas": 2.8,
+        "nuclear": 0.0,
+        "petroleum": 0.1,
+        "biomass": 6.7,
+        "coal": 0.0,
+        "other": 0.0,
+        "solar": 0.6,
+        "tidal": 0.0,
+        "total": 99.9,
+        "wind": 2.9,
+        "hydro": 86.8
+    },
+    "newfoundland and labrador": {
+        "naturalGas": 0.2,
+        "nuclear": 0.0,
+        "petroleum": 0.4,
+        "biomass": 0.0,
+        "coal": 0.0,
+        "other": 0.0,
+        "solar": 0.0,
+        "tidal": 0.0,
+        "total": 100.0,
+        "wind": 0.4,
+        "hydro": 99.0
+    },
+    "saskatchewan": {
+        "naturalGas": 50.7,
+        "nuclear": 0.0,
+        "petroleum": 0.0,
+        "biomass": 1.2,
+        "coal": 27.9,
+        "other": 0.0,
+        "solar": 0.6,
+        "tidal": 0.0,
+        "total": 100.0,
+        "wind": 3.0,
+        "hydro": 16.6
+    },
+    "prince edward island": {
+        "naturalGas": 0.0,
+        "nuclear": 0.0,
+        "petroleum": 2.2,
+        "biomass": 0.6,
+        "coal": 0.0,
+        "other": 0.0,
+        "solar": 0.1,
+        "tidal": 0.0,
+        "total": 100.2,
+        "wind": 97.3,
+        "hydro": 0.0
+    },
+    "ontario": {
+        "naturalGas": 8.6,
+        "nuclear": 50.1,
+        "petroleum": 0.1,
+        "biomass": 1.0,
+        "coal": 0.0,
+        "other": 0.0,
+        "solar": 5.2,
+        "tidal": 0.0,
+        "total": 100.1,
+        "wind": 11.7,
+        "hydro": 23.4
+    },
+    "nova scotia": {
+        "naturalGas": 13.9,
+        "nuclear": 0.0,
+        "petroleum": 0.0,
+        "biomass": 3.5,
+        "coal": 47.5,
+        "other": 0.0,
+        "solar": 0.02,
+        "tidal": 0,
+        "total": 100.02,
+        "wind": 24.2,
+        "hydro": 10.9
+    },
+    "quebec": {
+        "naturalGas": 0.2,
+        "nuclear": 0.0,
+        "petroleum": 0.3,
+        "biomass": 0.7,
+        "coal": 0.0,
+        "other": 0.0,
+        "solar": 0.01,
+        "tidal": 0.0,
+        "total": 100.01,
+        "wind": 6.7,
+        "hydro": 92.1
+    },
+    "alberta": {
+        "naturalGas": 73.5,
+        "nuclear": 0.0,
+        "petroleum": 0.02,
+        "biomass": 2.0,
+        "coal": 8.0,
+        "other": 0.0,
+        "solar": 3.2,
+        "tidal": 0.0,
+        "total": 99.82,
+        "wind": 11.3,
+        "hydro": 1.8
+    },
+    "manitoba": {
+        "naturalGas": 0.6,
+        "nuclear": 0.0,
+        "petroleum": 0.1,
+        "biomass": 0.2,
+        "coal": 0.0,
+        "other": 0.0,
+        "solar": 0.1,
+        "tidal": 0.0,
+        "total": 100.1,
+        "wind": 1.7,
+        "hydro": 97.4
+    },
+    "northwest territories": {
+        "naturalGas": 7.3,
+        "nuclear": 0.0,
+        "petroleum": 10.5,
+        "biomass": 0.0,
+        "coal": 0.0,
+        "other": 0.0,
+        "solar": 0.9,
+        "tidal": 0.0,
+        "total": 100.0,
+        "wind": 7.1,
+        "hydro": 74.2
+    },
+    "new brunswick": {
+        "naturalGas": 16.6,
+        "nuclear": 39.9,
+        "petroleum": 0.3,
+        "biomass": 1.3,
+        "coal": 12.1,
+        "other": 0.0,
+        "solar": 0.0,
+        "tidal": 0.0,
+        "total": 99.9,
+        "wind": 8.7,
+        "hydro": 21.0
+    },
+    "nunavut": {
+        "naturalGas": 0.0,
+        "nuclear": 0.0,
+        "petroleum": 99.8,
+        "biomass": 0.0,
+        "coal": 0.0,
+        "other": 0.0,
+        "solar": 0.2,
+        "tidal": 0.0,
+        "total": 100.0,
+        "wind": 0.0,
+        "hydro": 0.0
+    },
+    "yukon": {
+        "naturalGas": 20.2,
+        "nuclear": 0.0,
+        "petroleum": 15.0,
+        "biomass": 0.5,
+        "coal": 0.0,
+        "other": 0.0,
+        "solar": 0.1,
+        "tidal": 0.0,
+        "total": 100.1,
+        "wind": 0.2,
+        "hydro": 64.1
+    }
+}

{codecarbon-3.0.4 → codecarbon-3.0.5}/codecarbon/emissions_tracker.py

@@ -843,7 +843,7 @@ class BaseEmissionsTracker(ABC):
             raise e
 
         warning_duration = self._measure_power_secs * 3
-        if last_duration > warning_duration:
+        if last_duration > warning_duration and not self._scheduler._stopped:
             warn_msg = (
                 "Background scheduler didn't run for a long period"
                 + " (%ds), results might be inaccurate"

{codecarbon-3.0.4 → codecarbon-3.0.5}/codecarbon/external/hardware.py

@@ -102,25 +102,43 @@ class GPU(BaseHardware):
         Get the Ids of the GPUs that we will monitor
         :return: list of ids
         """
-        gpu_ids = []
         if self.gpu_ids is not None:
-            # Check that the provided GPU ids are valid
-            if not set(self.gpu_ids).issubset(set(range(self.num_gpus))):
-                logger.warning(
-                    f"Unknown GPU ids {gpu_ids}, only {self.num_gpus} GPUs available."
-                )
-            # Keep only the GPUs that are in the provided list
-            for gpu_id in range(self.num_gpus):
-                if gpu_id in self.gpu_ids:
-                    gpu_ids.append(gpu_id)
+            uuids_to_ids = {
+                gpu.get("uuid"): gpu.get("gpu_index")
+                for gpu in self.devices.get_gpu_static_info()
+            }
+            monitored_gpu_ids = []
+
+            for gpu_id in self.gpu_ids:
+                found_gpu_id = False
+                # Does it look like an index into the number of GPUs on the system?
+                if isinstance(gpu_id, int) or gpu_id.isdigit():
+                    gpu_id = int(gpu_id)
+                    if 0 <= gpu_id < self.num_gpus:
+                        monitored_gpu_ids.append(gpu_id)
+                        found_gpu_id = True
+                # Does it match a prefix of any UUID on the system after stripping any 'MIG-'
+                # id prefix per https://docs.nvidia.com/cuda/cuda-c-programming-guide/index.html#cuda-environment-variables ?
                 else:
-                    logger.info(
-                        f"GPU number {gpu_id} will not be monitored, at your request."
+                    stripped_gpu_id_str = gpu_id.lstrip("MIG-")
+                    for uuid, id in uuids_to_ids.items():
+                        if uuid.startswith(stripped_gpu_id_str):
+                            logger.debug(
+                                f"Matching GPU ID {stripped_gpu_id_str} (originally {gpu_id}) against {uuid} for GPU index {id}"
+                            )
+                            monitored_gpu_ids.append(id)
+                            found_gpu_id = True
+                            break
+                if not found_gpu_id:
+                    logger.warning(
+                        f"GPU with ID '{gpu_id}' not found or invalid. It will be ignored."
                     )
-            self.gpu_ids = gpu_ids
+
+            monitored_gpu_ids = sorted(list(set(monitored_gpu_ids)))
+            self.gpu_ids = monitored_gpu_ids
+            return monitored_gpu_ids
         else:
-            gpu_ids = set(range(self.num_gpus))
-        return gpu_ids
+            return list(range(self.num_gpus))
 
     def total_power(self) -> Power:
         return self._total_power
@@ -135,7 +153,7 @@ class GPU(BaseHardware):
         new_gpu_ids = gpus._get_gpu_ids()
         if len(new_gpu_ids) < gpus.num_gpus:
             logger.warning(
-                f"You have {gpus.num_gpus} GPUs but we will monitor only {len(gpu_ids)} of them. Check your configuration."
+                f"You have {gpus.num_gpus} GPUs but we will monitor only {len(new_gpu_ids)} ({new_gpu_ids}) of them. Check your configuration."
             )
         return cls(gpu_ids=new_gpu_ids)
 

{codecarbon-3.0.4 → codecarbon-3.0.5}/codecarbon/input.py

@@ -24,7 +24,7 @@ class DataSource:
             "geo_js_url": "https://get.geojs.io/v1/ip/geo.json",
             "cloud_emissions_path": "data/cloud/impact.csv",
             "usa_emissions_data_path": "data/private_infra/2016/usa_emissions.json",
-            "can_energy_mix_data_path": "data/private_infra/2016/canada_energy_mix.json",  # noqa: E501
+            "can_energy_mix_data_path": "data/private_infra/2023/canada_energy_mix.json",  # noqa: E501
             "global_energy_mix_data_path": "data/private_infra/global_energy_mix.json",  # noqa: E501
             "carbon_intensity_per_source_path": "data/private_infra/carbon_intensity_per_source.json",
             "cpu_power_path": "data/hardware/cpu_power.csv",

{codecarbon-3.0.4 → codecarbon-3.0.5}/codecarbon/output_methods/file.py

@@ -36,7 +36,11 @@ class FileOutput(BaseOutput):
     def has_valid_headers(self, data: EmissionsData):
         with open(self.save_file_path) as csv_file:
             csv_reader = csv.DictReader(csv_file)
-            dict_from_csv = dict(list(csv_reader)[0])
+            csv_entries_list = list(csv_reader)
+            if len(csv_entries_list) == 0:
+                # No entries
+                return True
+            dict_from_csv = dict(csv_entries_list[0])
             list_of_column_names = list(dict_from_csv.keys())
             return list(data.values.keys()) == list_of_column_names
 
@@ -48,7 +52,7 @@ class FileOutput(BaseOutput):
         """
         file_exists: bool = os.path.isfile(self.save_file_path)
         if file_exists and not self.has_valid_headers(total):
-            logger.warning("The CSV format have changed, backing up old emission file.")
+            logger.warning("The CSV format has changed, backing up old emission file.")
             backup(self.save_file_path)
             file_exists = False
         new_df = pd.DataFrame.from_records([dict(total.values)])

{codecarbon-3.0.4 → codecarbon-3.0.5}/codecarbon.egg-info/PKG-INFO

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

{codecarbon-3.0.4 → codecarbon-3.0.5}/codecarbon.egg-info/SOURCES.txt

@@ -39,8 +39,8 @@ codecarbon/data/hardware/cpu_dataset_builder/intel_cpu_scrapper.py
 codecarbon/data/hardware/cpu_dataset_builder/merge_scrapped_cpu_power.py
 codecarbon/data/private_infra/carbon_intensity_per_source.json
 codecarbon/data/private_infra/global_energy_mix.json
-codecarbon/data/private_infra/2016/canada_energy_mix.json
 codecarbon/data/private_infra/2016/usa_emissions.json
+codecarbon/data/private_infra/2023/canada_energy_mix.json
 codecarbon/external/__init__.py
 codecarbon/external/geography.py
 codecarbon/external/hardware.py

{codecarbon-3.0.4 → codecarbon-3.0.5}/pyproject.toml

@@ -61,7 +61,7 @@ codecarbon = [
     "data/private_infra/global_energy_mix.json",
     "data/private_infra/carbon_intensity_per_source.json",
     "data/private_infra/2016/usa_emissions.json",
-    "data/private_infra/2016/canada_energy_mix.json",
+    "data/private_infra/2023/canada_energy_mix.json",
 ]
 
 [project.urls]
@@ -160,7 +160,7 @@ docs = "cd docs/edit && make docs"
 carbonboard = "python codecarbon/viz/carbonboard.py"
 
 [tool.bumpver]
-current_version = "3.0.4"
+current_version = "3.0.5"
 version_pattern = "MAJOR.MINOR.PATCH[_TAGNUM]"
 
 [tool.bumpver.file_patterns]

{codecarbon-3.0.4 → codecarbon-3.0.5}/tests/test_config.py

@@ -32,16 +32,16 @@ class TestConfig(unittest.TestCase):
 
     def test_parse_gpu_ids(self):
         for ids, target in [
-            ("0,1,2", [0, 1, 2]),
-            ("[0, 1, 2", [0, 1, 2]),
-            ("(0, 1, 2)", [0, 1, 2]),
-            ("[1]", [1]),
-            ("1", [1]),
-            ("0", [0]),
+            ("0,1,2", ["0", "1", "2"]),
+            ("[0, 1, 2", ["0", "1", "2"]),
+            ("(0, 1, 2)", ["0", "1", "2"]),
+            ("[1]", ["1"]),
+            ("1", ["1"]),
+            ("0", ["0"]),
+            ("MIG-f1e", ["MIG-f1e"]),
             ("", []),
             ([], []),
-            ([1, 2, 3], [1, 2, 3]),
-            (1, 1),
+            ([1, 2, 3], ["1", "2", "3"]),
         ]:
             self.assertEqual(parse_gpu_ids(ids), target)
 
@@ -101,6 +101,7 @@ class TestConfig(unittest.TestCase):
             "USER": "useless key",
             "CODECARBON_ENV_OVERWRITE": "SUCCESS:overwritten",
             "CODECARBON_ENV_NEW_KEY": "cool value",
+            "CODECARBON_ALLOW_MULTIPLE_RUNS": "True",
         },
     )
     def test_read_confs_and_parse_envs(self):
@@ -145,9 +146,8 @@ class TestConfig(unittest.TestCase):
             "builtins.open", new_callable=get_custom_mock_open(global_conf, local_conf)
         ):
             conf = dict(get_hierarchical_config())
-            target = {
-                "allow_multiple_runs": "True"
-            }  # allow_multiple_runs is a default value
+            # allow_multiple_runs is set in pytest.ini and not mocked, so it's visible here.
+            target = {"allow_multiple_runs": "True"}
             self.assertDictEqual(conf, target)
 
     @mock.patch.dict(
@@ -190,7 +190,7 @@ class TestConfig(unittest.TestCase):
             self.assertEqual(tracker._force_ram_power, 50.5)
             self.assertEqual(tracker._output_dir, "/success/overwritten")
             self.assertEqual(tracker._emissions_endpoint, "http://testhost:2000")
-            self.assertEqual(tracker._gpu_ids, [0, 1])
+            self.assertEqual(tracker._gpu_ids, ["0", "1"])
             self.assertEqual(tracker._co2_signal_api_token, "signal-token")
             self.assertEqual(tracker._project_name, "test-project")
             self.assertTrue(tracker._save_to_file)
@@ -206,7 +206,7 @@ class TestConfig(unittest.TestCase):
             tracker = EmissionsTracker(
                 project_name="test-project", allow_multiple_runs=True
             )
-        self.assertEqual(tracker._gpu_ids, [2, 3])
+        self.assertEqual(tracker._gpu_ids, ["2", "3"])
 
     @mock.patch.dict(
         os.environ,
@@ -220,7 +220,7 @@ class TestConfig(unittest.TestCase):
             tracker = EmissionsTracker(
                 project_name="test-project", allow_multiple_runs=True
             )
-        self.assertEqual(tracker._gpu_ids, [99])
+        self.assertEqual(tracker._gpu_ids, ["99"])
         gpu_count = 0
         for hardware in tracker._hardware:
             if isinstance(hardware, GPU):

{codecarbon-3.0.4 → codecarbon-3.0.5}/tests/test_cpu_load.py

@@ -4,7 +4,7 @@ from unittest import mock
 
 from codecarbon.core.units import Power
 from codecarbon.emissions_tracker import OfflineEmissionsTracker
-from codecarbon.external.hardware import CPU, MODE_CPU_LOAD
+from codecarbon.external.hardware import CPU, MODE_CPU_LOAD, AppleSiliconChip
 
 
 @mock.patch("codecarbon.core.cpu.is_psutil_available", return_value=True)
@@ -57,7 +57,9 @@ class TestCPULoad(unittest.TestCase):
     ):
         tracker = OfflineEmissionsTracker(country_iso_code="FRA")
         for hardware in tracker._hardware:
-            if isinstance(hardware, CPU) and hardware._mode == MODE_CPU_LOAD:
+            if (
+                isinstance(hardware, CPU) and hardware._mode == MODE_CPU_LOAD
+            ) or isinstance(hardware, AppleSiliconChip):
                 break
         else:
             raise Exception("No CPU load !!!")

{codecarbon-3.0.4 → codecarbon-3.0.5}/tests/test_emissions.py

@@ -154,10 +154,13 @@ class TestEmissions(unittest.TestCase):
                 country_iso_code="CAN", country_name="Canada", region="ontario"
             ),
         )
+        manually_computed_emissions = (
+            3 * (0.995725971 * 0.0 + 0.8166885263 * 0.1 + 0.7438415916 * 8.6) / 100.1
+        )
 
         # THEN
         assert isinstance(emissions, float)
-        self.assertAlmostEqual(emissions, 0.12, places=2)
+        self.assertAlmostEqual(emissions, manually_computed_emissions, places=2)
 
     def test_get_emissions_PRIVATE_INFRA_unknown_country(self):
         """

{codecarbon-3.0.4 → codecarbon-3.0.5}/tests/test_emissions_tracker.py

@@ -520,3 +520,91 @@ class TestCarbonTracker(unittest.TestCase):
         self.assertEqual("United States", emissions_df["country_name"].values[0])
         self.assertEqual("USA", emissions_df["country_iso_code"].values[0])
         self.assertIsInstance(tracker.final_emissions, float)
+
+    @mock.patch("codecarbon.emissions_tracker.logger")
+    def test_scheduler_warning_suppressed_when_stopped(
+        self,
+        mock_logger,
+        mock_setup_intel_cli,
+        mock_log_values,
+        mocked_get_gpu_details,
+        mocked_env_cloud_details,
+        mocked_is_gpu_details_available,
+    ):
+        """Test that scheduler warning is suppressed when scheduler is stopped."""
+        with EmissionsTracker(
+            output_dir=self.temp_path,
+            measure_power_secs=1,  # Short interval for testing
+        ) as tracker:
+            # Stop the scheduler to simulate task mode or manual stopping
+            tracker._scheduler.stop()
+
+            # Artificially set last measured time to simulate long delay
+            import time
+
+            tracker._last_measured_time = time.perf_counter() - 10  # 10 seconds ago
+
+            # Reset mock to clear any previous warning calls
+            mock_logger.warning.reset_mock()
+
+            # Call _measure_power_and_energy directly - this would normally trigger warning
+            tracker._measure_power_and_energy()
+
+            # Verify that if warning was called, it wasn't the scheduler warning
+            if mock_logger.warning.called:
+                for call in mock_logger.warning.call_args_list:
+                    args, kwargs = call
+                    if (
+                        args
+                        and "Background scheduler didn't run for a long period"
+                        in str(args[0])
+                    ):
+                        self.fail(
+                            "Scheduler warning was called when it should have been suppressed"
+                        )
+
+    @mock.patch("codecarbon.emissions_tracker.logger")
+    def test_scheduler_warning_shown_when_running(
+        self,
+        mock_logger,
+        mock_setup_intel_cli,
+        mock_log_values,
+        mocked_get_gpu_details,
+        mocked_env_cloud_details,
+        mocked_is_gpu_details_available,
+    ):
+        """Test that scheduler warning is shown when scheduler is running but delayed."""
+        with EmissionsTracker(
+            output_dir=self.temp_path,
+            measure_power_secs=1,  # Short interval for testing
+        ) as tracker:
+            # Ensure scheduler is running (default state)
+            self.assertFalse(tracker._scheduler._stopped)
+
+            # Artificially set last measured time to simulate long delay
+            import time
+
+            tracker._last_measured_time = time.perf_counter() - 10  # 10 seconds ago
+
+            # Reset mock to clear any previous warning calls
+            mock_logger.warning.reset_mock()
+
+            # Call _measure_power_and_energy directly - this should trigger warning
+            tracker._measure_power_and_energy()
+
+            # Verify warning was logged since scheduler should be running
+            scheduler_warning_found = False
+            if mock_logger.warning.called:
+                for call in mock_logger.warning.call_args_list:
+                    args, kwargs = call
+                    if (
+                        args
+                        and "Background scheduler didn't run for a long period"
+                        in str(args[0])
+                    ):
+                        scheduler_warning_found = True
+                        break
+
+            self.assertTrue(
+                scheduler_warning_found, "Expected scheduler warning was not found"
+            )

{codecarbon-3.0.4 → codecarbon-3.0.5}/tests/test_gpu.py

@@ -50,7 +50,7 @@ class FakeGPUEnv:
         self.DETAILS = {
             "handle_0": {
                 "name": b"GeForce GTX 1080",
-                "uuid": b"uuid#1",
+                "uuid": b"uuid-1",
                 "memory": real_pynvml.c_nvmlMemory_t(1024, 100, 924),
                 "temperature": 75,
                 "power_usage": 26,
@@ -66,7 +66,7 @@ class FakeGPUEnv:
             },
             "handle_1": {
                 "name": b"GeForce GTX 1080",
-                "uuid": b"uuid#2",
+                "uuid": b"uuid-2",
                 "memory": real_pynvml.c_nvmlMemory_t(1024, 200, 824),
                 "temperature": 79,
                 "power_usage": 29,
@@ -84,7 +84,7 @@ class FakeGPUEnv:
         self.expected = [
             {
                 "name": "GeForce GTX 1080",
-                "uuid": "uuid#1",
+                "uuid": "uuid-1",
                 "total_memory": 1024,
                 "free_memory": 100,
                 "used_memory": 924,
@@ -102,7 +102,7 @@ class FakeGPUEnv:
             },
             {
                 "name": "GeForce GTX 1080",
-                "uuid": "uuid#2",
+                "uuid": "uuid-2",
                 "total_memory": 1024,
                 "free_memory": 200,
                 "used_memory": 824,
@@ -146,14 +146,14 @@ class TestGpu(FakeGPUEnv):
         expected = [
             {
                 "name": "GeForce GTX 1080",
-                "uuid": "uuid#1",
+                "uuid": "uuid-1",
                 "total_memory": 1024,
                 "power_limit": 149,
                 "gpu_index": 0,
             },
             {
                 "name": "GeForce GTX 1080",
-                "uuid": "uuid#2",
+                "uuid": "uuid-2",
                 "total_memory": 1024,
                 "power_limit": 149,
                 "gpu_index": 1,
@@ -311,6 +311,33 @@ class TestGpu(FakeGPUEnv):
         expected_power = gpu2_power
         tc.assertAlmostEqual(expected_power.kW, gpu.total_power().kW)
 
+    def test_get_gpu_ids(self):
+        """
+        Check parsing of gpu_ids in various forms.
+        """
+        # Prepare
+        from codecarbon.external.hardware import GPU
+
+        for test_ids, expected_ids in [
+            ([0, 1], [0, 1]),
+            ([0, 1, 2], [0, 1]),
+            ([2], []),
+            (["0", "1"], [0, 1]),
+            # Only two GPUS in the system, so ignore the third (index 2)
+            (["0", "1", "2"], [0, 1]),
+            (["2"], []),
+            # Check UUID-to-index mapping
+            (["uuid-1"], [0]),
+            (["uuid-1", "uuid-2"], [0, 1]),
+            (["uuid-3"], []),
+            # Check UUID-to-index mapping when we need to strip the prefix
+            (["MIG-uuid-1"], [0]),
+            (["MIG-uuid-3"], []),
+        ]:
+            gpu = GPU(test_ids)
+            result = gpu._get_gpu_ids()
+            assert result == expected_ids
+
 
 class TestGpuNotAvailable:
     def setup_method(self):

{codecarbon-3.0.4 → codecarbon-3.0.5}/tests/test_unsupported_gpu.py

@@ -1,4 +1,5 @@
 import os
+import sys
 import unittest
 from unittest.mock import MagicMock, patch
 
@@ -18,6 +19,10 @@ class TestUnsupportedGPU(unittest.TestCase):
         if os.path.exists(self.output_csv):
             os.remove(self.output_csv)
 
+    # If we run this on macOS, NVMLError_NotSupported has no effect
+    # and we end up with non-zero values for GPU energy and power because
+    # we use the non-NVML code-path in hardware.AppleSiliconChip().
+    @unittest.skipIf(sys.platform == "darwin", "NVML not available on macOS")
     @patch("codecarbon.core.gpu.pynvml")
     def test_emissions_tracker_unsupported_gpu(self, mock_pynvml):
         mock_pynvml.NVMLError_NotSupported = self.NVMLError_NotSupported

codecarbon-3.0.4/codecarbon/_version.py

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

codecarbon-3.0.4/codecarbon/data/private_infra/2016/canada_energy_mix.json

@@ -1,171 +0,0 @@
-{
-    "british columbia": {
-        "naturalGas": 1.1,
-        "nuclear": 0.0,
-        "petroleum": 0.7,
-        "biomass": 6.4,
-        "coal": 0.0,
-        "other": 0.0,
-        "solar": 0.0,
-        "tidal": 0.0,
-        "total": 100,
-        "wind": 1.3,
-        "hydro": 90.5
-    },
-    "newfoundland and labrador": {
-        "naturalGas": 0.7,
-        "nuclear": 0.0,
-        "petroleum": 4.8,
-        "biomass": 0.3,
-        "coal": 0.0,
-        "other": 0.0,
-        "solar": 0.0,
-        "tidal": 0.0,
-        "total": 100,
-        "wind": 0.5,
-        "hydro": 93.7
-    },
-    "saskatchewan": {
-        "naturalGas": 35.7,
-        "nuclear": 0.0,
-        "petroleum": 0.0,
-        "biomass": 0.0,
-        "coal": 46.6,
-        "other": 0.0,
-        "solar": 0.1,
-        "tidal": 0.0,
-        "total": 99.9,
-        "wind": 3.8,
-        "hydro": 13.7
-    },
-    "prince edward island": {
-        "naturalGas": 0.0,
-        "nuclear": 0.0,
-        "petroleum": 1.1,
-        "biomass": 0.7,
-        "coal": 0.0,
-        "other": 0.0,
-        "solar": 0.3,
-        "tidal": 0.0,
-        "total": 100,
-        "wind": 97.9,
-        "hydro": 0.0
-    },
-    "ontario": {
-        "naturalGas": 5.2,
-        "nuclear": 58.6,
-        "petroleum": 0.1,
-        "biomass": 1.3,
-        "coal": 0.0,
-        "other": 0.0,
-        "solar": 2.2,
-        "tidal": 0.0,
-        "total": 100,
-        "wind": 6.7,
-        "hydro": 25.9
-    },
-    "nova scotia": {
-        "naturalGas": 14.3,
-        "nuclear": 0.0,
-        "petroleum": 12.2,
-        "biomass": 4.9,
-        "coal": 47.9,
-        "other": 0.0,
-        "solar": 0.03,
-        "tidal": 0.2,
-        "total": 100.13,
-        "wind": 11.8,
-        "hydro": 8.8
-    },
-    "quebec": {
-        "naturalGas": 0.1,
-        "nuclear": 0.0,
-        "petroleum": 0.2,
-        "biomass": 0.8,
-        "coal": 0.0,
-        "other": 0.0,
-        "solar": 0.0,
-        "tidal": 0.0,
-        "total": 100,
-        "wind": 3.9,
-        "hydro": 95.0
-    },
-    "alberta": {
-        "naturalGas": 42.2,
-        "nuclear": 0.0,
-        "petroleum": 2.6,
-        "biomass": 2.2,
-        "coal": 44.9,
-        "other": 0.2,
-        "solar": 0.1,
-        "tidal": 0.0,
-        "total": 100.1,
-        "wind": 5.4,
-        "hydro": 2.5
-    },
-    "manitoba": {
-        "naturalGas": 0.0,
-        "nuclear": 0.0,
-        "petroleum": 0.2,
-        "biomass": 0.1,
-        "coal": 0.1,
-        "other": 0.0,
-        "solar": 0.0,
-        "tidal": 0.0,
-        "total": 99.9,
-        "wind": 2.7,
-        "hydro": 96.8
-    },
-    "northwest territories": {
-        "naturalGas": 4.0,
-        "nuclear": 0.0,
-        "petroleum": 55.3,
-        "biomass": 0.0,
-        "coal": 0.0,
-        "other": 0.0,
-        "solar": 0.2,
-        "tidal": 0.0,
-        "total": 100,
-        "wind": 2.0,
-        "hydro": 38.5
-    },
-    "new brunswick": {
-        "naturalGas": 9.9,
-        "nuclear": 36.1,
-        "petroleum": 7.6,
-        "biomass": 4.2,
-        "coal": 15.8,
-        "other": 0.0,
-        "solar": 0.0,
-        "tidal": 0.0,
-        "total": 99.8,
-        "wind": 6.6,
-        "hydro": 19.6
-    },
-    "nunavut": {
-        "naturalGas": 0.0,
-        "nuclear": 0.0,
-        "petroleum": 100.0,
-        "biomass": 0.0,
-        "coal": 0.0,
-        "other": 0.0,
-        "solar": 0.0,
-        "tidal": 0.0,
-        "total": 100,
-        "wind": 0.0,
-        "hydro": 0.0
-    },
-    "yukon": {
-        "naturalGas": 2.0,
-        "nuclear": 0.0,
-        "petroleum": 5.5,
-        "biomass": 0.0,
-        "coal": 0.0,
-        "other": 0.0,
-        "solar": 0.3,
-        "tidal": 0.0,
-        "total": 100,
-        "wind": 0.0,
-        "hydro": 92.2
-    }
-}