codecarbon 2.8.0__tar.gz → 2.8.2__tar.gz

{codecarbon-2.8.0 → codecarbon-2.8.2}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: codecarbon
-Version: 2.8.0
+Version: 2.8.2
 Project-URL: Homepage, https://codecarbon.io/
 Project-URL: Repository, https://github.com/mlco2/codecarbon
 Project-URL: Dashboard, http://dashboard.codecarbon.io/
@@ -8,6 +8,7 @@ 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
 Author: Mila, DataForGood, BCG GAMMA, Comet.ml, Haverford College
+License-File: LICENSE
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Natural Language :: English
 Classifier: Programming Language :: Python :: 3.7

codecarbon-2.8.2/codecarbon/_version.py

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

{codecarbon-2.8.0 → codecarbon-2.8.2}/codecarbon/cli/main.py

@@ -25,12 +25,13 @@ from codecarbon.core.schemas import ExperimentCreate, OrganizationCreate, Projec
 from codecarbon.emissions_tracker import EmissionsTracker
 
 AUTH_CLIENT_ID = os.environ.get(
-    "AUTH_CLIENT_ID", "pkqh9CiOkp4MkPqRqM_k8Xc3mwBRpojS3RayIk1i5Pg"
+    "AUTH_CLIENT_ID",
+    "jsUPWIcUECQFE_ouanUuVhXx52TTjEVcVNNtNGeyAtU",
 )
 AUTH_SERVER_URL = os.environ.get(
-    "AUTH_SERVER_URL", "https://auth.codecarbon.io/codecarbon-dev"
+    "AUTH_SERVER_URL", "https://auth.codecarbon.io/codecarbon"
 )
-API_URL = os.environ.get("API_URL", "https://dash-dev.cleverapps.io/api")
+API_URL = os.environ.get("API_URL", "https://dashboard.codecarbon.io/api")
 
 DEFAULT_PROJECT_ID = "e60afa92-17b7-4720-91a0-1ae91e409ba1"
 DEFAULT_ORGANIzATION_ID = "e60afa92-17b7-4720-91a0-1ae91e409ba1"
@@ -62,6 +63,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())
     print("Current configuration : \n")
     print("Config file content : ")
     print(d)
@@ -99,7 +101,6 @@ def show_config(path: Path = Path("./.codecarbon.config")) -> None:
 
 fief = Fief(AUTH_SERVER_URL, AUTH_CLIENT_ID)
 fief_auth = FiefAuth(fief, "./credentials.json")
-print("FIEF", AUTH_SERVER_URL, AUTH_CLIENT_ID)
 
 
 def _get_access_token():
@@ -126,10 +127,7 @@ def login():
     fief_auth.authorize()
 
 
-@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())
+def get_api_key(project_id: str):
     req = requests.post(
         f"{API_URL}/projects/{project_id}/api-tokens",
         json={
@@ -139,7 +137,16 @@ def get_token(project_id: str):
         },
         headers={"Authorization": f"Bearer {_get_access_token()}"},
     )
-    print("Your token: " + req.json()["token"])
+    api_key = req.json()["token"]
+    return api_key
+
+
+@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())
+    token = get_api_key(project_id)
+    print("Your token: " + token)
     print("Add it to the api_key field in your configuration file")
 
 
@@ -290,6 +297,8 @@ def config():
         experiment = [e for e in experiments if e["name"] == experiment][0]
 
     overwrite_local_config("experiment_id", experiment["id"], path=file_path)
+    api_key = get_api_key(project_id)
+    overwrite_local_config("api_key", api_key, path=file_path)
     show_config(file_path)
     print(
         "Consult [link=https://mlco2.github.io/codecarbon/usage.html#configuration]configuration documentation[/link] for more configuration options"
@@ -316,14 +325,14 @@ def monitor(
         api (Annotated[bool, typer.Option, optional): Choose to call Code Carbon API or not. Defaults to True.
     """
     experiment_id = get_existing_local_exp_id()
-    if api and experiment_id is None:
-        print("ERROR: No experiment id, call 'codecarbon init' first.", err=True)
+    if api:
+        if experiment_id is None:
+            print("ERROR: No experiment id, call 'codecarbon config' first.", err=True)
     print("CodeCarbon is going in an infinite loop to monitor this machine.")
     with EmissionsTracker(
         measure_power_secs=measure_power_secs,
         api_call_interval=api_call_interval,
         save_to_api=api,
-        access_token=_get_access_token(),
     ) as tracker:
         # Infinite loop
         while True:

{codecarbon-2.8.0 → codecarbon-2.8.2}/codecarbon/core/api_client.py

@@ -67,24 +67,23 @@ class ApiClient:  # (AsyncClient)
             stacklevel=2,
         )
 
-    def set_access_token(self, token: str):
-        """This method sets the access token to be used for the API. For now it is not used.
-
-        Args:
-            token (str): access token to be used for the API
-        """
-        self.access_token = token
-
     def _get_headers(self):
         headers = {"Content-Type": "application/json"}
         if self.api_key:
             print(type(self.api_key))
             # set the x-api-token header
             headers["x-api-token"] = self.api_key
-        if self.access_token:
+        elif self.access_token:
             headers["Authorization"] = f"Bearer {self.access_token}"
         return headers
 
+    def set_access_token(self, token: str):
+        """This method sets the access token to be used for the API.
+        Args:
+            token (str): access token to be used for the API
+        """
+        self.access_token = token
+
     def get_list_organizations(self):
         """
         List all organizations

{codecarbon-2.8.0 → codecarbon-2.8.2}/codecarbon/core/config.py

@@ -3,6 +3,8 @@ import os
 from pathlib import Path
 from typing import List
 
+from codecarbon.external.logger import logger
+
 
 def clean_env_key(k: str) -> str:
     """
@@ -96,6 +98,16 @@ def get_hierarchical_config():
     home = Path.home()
     global_path = str((home / ".codecarbon.config").expanduser().resolve())
     local_path = str((cwd / ".codecarbon.config").expanduser().resolve())
+    if Path(global_path).exists():
+        logger.info(
+            f"Codecarbon is taking the configuration from global file: {global_path}"
+        )
+        if Path(local_path).exists():
+            logger.info(f"Some variables are overriden by the local file: {local_path}")
+    elif Path(local_path).exists():
+        logger.info(
+            f"Codecarbon is taking the configuration from the local file {local_path}"
+        )
 
     config.read([global_path, local_path])
     config.read_dict(parse_env_config())

codecarbon-2.8.2/codecarbon/core/resource_tracker.py

@@ -0,0 +1,147 @@
+from collections import Counter
+from typing import List, Union
+
+from codecarbon.core import cpu, gpu, powermetrics
+from codecarbon.core.config import parse_gpu_ids
+from codecarbon.core.util import detect_cpu_model, is_linux_os, is_mac_os, is_windows_os
+from codecarbon.external.hardware import CPU, GPU, RAM, AppleSiliconChip
+from codecarbon.external.logger import logger
+
+
+class ResourceTracker:
+    cpu_tracker = gpu_tracker = ram_tracker = "Unspecified"
+
+    def __init__(self, tracker):
+        self.tracker = tracker
+
+    def set_RAM_tracking(self):
+        logger.info("[setup] RAM Tracking...")
+        self.ram_tracker = "3 Watts for 8 GB ratio constant"
+        ram = RAM(tracking_mode=self.tracker._tracking_mode)
+        self.tracker._conf["ram_total_size"] = ram.machine_memory_GB
+        self.tracker._hardware: List[Union[RAM, CPU, GPU, AppleSiliconChip]] = [ram]
+
+    def set_CPU_tracking(self):
+        logger.info("[setup] CPU Tracking...")
+        if cpu.is_powergadget_available() and self.tracker._default_cpu_power is None:
+            logger.info("Tracking Intel CPU via Power Gadget")
+            self.cpu_tracker = "Power Gadget"
+            hardware = CPU.from_utils(self.tracker._output_dir, "intel_power_gadget")
+            self.tracker._hardware.append(hardware)
+            self.tracker._conf["cpu_model"] = hardware.get_model()
+        elif cpu.is_rapl_available():
+            logger.info("Tracking Intel CPU via RAPL interface")
+            self.cpu_tracker = "RAPL"
+            hardware = CPU.from_utils(self.tracker._output_dir, "intel_rapl")
+            self.tracker._hardware.append(hardware)
+            self.tracker._conf["cpu_model"] = hardware.get_model()
+        # change code to check if powermetrics needs to be installed or just sudo setup
+        elif (
+            powermetrics.is_powermetrics_available()
+            and self.tracker._default_cpu_power is None
+        ):
+            logger.info("Tracking Apple CPU and GPU via PowerMetrics")
+            self.gpu_tracker = "PowerMetrics"
+            self.cpu_tracker = "PowerMetrics"
+            hardware_cpu = AppleSiliconChip.from_utils(
+                self.tracker._output_dir, chip_part="CPU"
+            )
+            self.tracker._hardware.append(hardware_cpu)
+            self.tracker._conf["cpu_model"] = hardware_cpu.get_model()
+
+            hardware_gpu = AppleSiliconChip.from_utils(
+                self.tracker._output_dir, chip_part="GPU"
+            )
+            self.tracker._hardware.append(hardware_gpu)
+
+            self.tracker._conf["gpu_model"] = hardware_gpu.get_model()
+            self.tracker._conf["gpu_count"] = 1
+        else:
+            # Explain what to install to increase accuracy
+            cpu_tracking_install_instructions = ""
+            if is_mac_os():
+                if (
+                    "M1" in detect_cpu_model()
+                    or "M2" in detect_cpu_model()
+                    or "M3" in detect_cpu_model()
+                ):
+                    cpu_tracking_install_instructions = ""
+                    cpu_tracking_install_instructions = "Mac OS and ARM processor detected: Please enable PowerMetrics sudo to measure CPU"
+                else:
+                    cpu_tracking_install_instructions = "Mac OS detected: Please install Intel Power Gadget or enable PowerMetrics sudo to measure CPU"
+            elif is_windows_os():
+                cpu_tracking_install_instructions = "Windows OS detected: Please install Intel Power Gadget to measure CPU"
+            elif is_linux_os():
+                cpu_tracking_install_instructions = "Linux OS detected: Please ensure RAPL files exist at \\sys\\class\\powercap\\intel-rapl to measure CPU"
+            logger.warning(
+                f"No CPU tracking mode found. Falling back on CPU constant mode. \n {cpu_tracking_install_instructions}\n"
+            )
+            self.cpu_tracker = "TDP constant"
+            tdp = cpu.TDP()
+            power = tdp.tdp
+            model = tdp.model
+            if (power is None) and self.tracker._default_cpu_power:
+                # We haven't been able to calculate CPU power but user has input a default one. We use it
+                user_input_power = self.tracker._default_cpu_power
+                logger.debug(f"Using user input TDP: {user_input_power} W")
+                self.cpu_tracker = "User Input TDP constant"
+                power = user_input_power
+            logger.info(f"CPU Model on constant consumption mode: {model}")
+            self.tracker._conf["cpu_model"] = model
+            if tdp:
+                hardware = CPU.from_utils(
+                    self.tracker._output_dir, "constant", model, power
+                )
+                self.tracker._hardware.append(hardware)
+            else:
+                logger.warning(
+                    "Failed to match CPU TDP constant. "
+                    + "Falling back on a global constant."
+                )
+                self.cpu_tracker = "global constant"
+                hardware = CPU.from_utils(self.tracker._output_dir, "constant")
+                self.tracker._hardware.append(hardware)
+
+    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._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)
+            self.tracker._hardware.append(gpu_devices)
+            gpu_names = [n["name"] for n in gpu_devices.devices.get_gpu_static_info()]
+            gpu_names_dict = Counter(gpu_names)
+            self.tracker._conf["gpu_model"] = "".join(
+                [f"{i} x {name}" for name, i in gpu_names_dict.items()]
+            )
+            if self.tracker._conf.get("gpu_count") is None:
+                self.tracker._conf["gpu_count"] = len(
+                    gpu_devices.devices.get_gpu_static_info()
+                )
+        else:
+            logger.info("No GPU found.")
+
+    def set_CPU_GPU_ram_tracking(self):
+        self.set_RAM_tracking()
+        self.set_CPU_tracking()
+        self.set_GPU_tracking()
+
+        logger.debug(
+            f"""The below tracking methods have been set up:
+                RAM Tracking Method: {self.ram_tracker}
+                CPU Tracking Method: {self.cpu_tracker}
+                GPU Tracking Method: {self.gpu_tracker}
+            """
+        )

{codecarbon-2.8.0 → codecarbon-2.8.2}/codecarbon/emissions_tracker.py

@@ -9,24 +9,16 @@ import platform
 import time
 import uuid
 from abc import ABC, abstractmethod
-from collections import Counter
 from datetime import datetime
 from functools import wraps
 from typing import Any, Callable, Dict, List, Optional, Union
 
 from codecarbon._version import __version__
-from codecarbon.core import cpu, gpu, powermetrics
-from codecarbon.core.config import get_hierarchical_config, parse_gpu_ids
+from codecarbon.core.config import get_hierarchical_config
 from codecarbon.core.emissions import Emissions
+from codecarbon.core.resource_tracker import ResourceTracker
 from codecarbon.core.units import Energy, Power, Time
-from codecarbon.core.util import (
-    count_cpus,
-    detect_cpu_model,
-    is_linux_os,
-    is_mac_os,
-    is_windows_os,
-    suppress,
-)
+from codecarbon.core.util import count_cpus, suppress
 from codecarbon.external.geography import CloudMetadata, GeoMetadata
 from codecarbon.external.hardware import CPU, GPU, RAM, AppleSiliconChip
 from codecarbon.external.logger import logger, set_logger_format, set_logger_level
@@ -157,7 +149,6 @@ class BaseEmissionsTracker(ABC):
         api_call_interval: Optional[int] = _sentinel,
         api_endpoint: Optional[str] = _sentinel,
         api_key: Optional[str] = _sentinel,
-        access_token: Optional[str] = _sentinel,
         output_dir: Optional[str] = _sentinel,
         output_file: Optional[str] = _sentinel,
         save_to_file: Optional[bool] = _sentinel,
@@ -312,7 +303,9 @@ class BaseEmissionsTracker(ABC):
         self._tasks: Dict[str, Task] = {}
         self._active_task: Optional[str] = None
 
-        self.set_CPU_GPU_ram_tracking()
+        # Tracking mode detection
+        ressource_tracker = ResourceTracker(self)
+        ressource_tracker.set_CPU_GPU_ram_tracking()
 
         self._conf["hardware"] = list(map(lambda x: x.description(), self._hardware))
 
@@ -355,132 +348,9 @@ class BaseEmissionsTracker(ABC):
         self._emissions: Emissions = Emissions(
             self._data_source, self._co2_signal_api_token
         )
-        self._init_output_methods(api_key=self._api_key, access_token=access_token)
-
-    def set_CPU_GPU_ram_tracking(self):
-        cpu_tracker = gpu_tracker = ram_tracker = "Unspecified"
-        if self._gpu_ids:
-            # If _gpu_ids is a string or a list of int, parse it to a list of ints
-            if isinstance(self._gpu_ids, str) or (
-                isinstance(self._gpu_ids, list)
-                and all(isinstance(gpu_id, int) for gpu_id in self._gpu_ids)
-            ):
-                self._gpu_ids: List[int] = parse_gpu_ids(self._gpu_ids)
-                self._conf["gpu_ids"] = self._gpu_ids
-                self._conf["gpu_count"] = len(self._gpu_ids)
-            else:
-                logger.warning(
-                    "Invalid gpu_ids format. Expected a string or a list of ints."
-                )
-
-        logger.info("[setup] RAM Tracking...")
-        ram_tracker = "3 Watts for 8 GB ratio constant"
-        ram = RAM(tracking_mode=self._tracking_mode)
-        self._conf["ram_total_size"] = ram.machine_memory_GB
-        self._hardware: List[Union[RAM, CPU, GPU, AppleSiliconChip]] = [ram]
-
-        # Hardware detection
-        logger.info("[setup] GPU Tracking...")
-        if gpu.is_gpu_details_available():
-            logger.info("Tracking Nvidia GPU via pynvml")
-            gpu_tracker = "pynvml"
-            gpu_devices = GPU.from_utils(self._gpu_ids)
-            self._hardware.append(gpu_devices)
-            gpu_names = [n["name"] for n in gpu_devices.devices.get_gpu_static_info()]
-            gpu_names_dict = Counter(gpu_names)
-            self._conf["gpu_model"] = "".join(
-                [f"{i} x {name}" for name, i in gpu_names_dict.items()]
-            )
-            if self._conf.get("gpu_count") is None:
-                self._conf["gpu_count"] = len(gpu_devices.devices.get_gpu_static_info())
-        else:
-            logger.info("No GPU found.")
-
-        logger.info("[setup] CPU Tracking...")
-        if cpu.is_powergadget_available() and self._default_cpu_power is None:
-            logger.info("Tracking Intel CPU via Power Gadget")
-            cpu_tracker = "Power Gadget"
-            hardware = CPU.from_utils(self._output_dir, "intel_power_gadget")
-            self._hardware.append(hardware)
-            self._conf["cpu_model"] = hardware.get_model()
-        elif cpu.is_rapl_available():
-            logger.info("Tracking Intel CPU via RAPL interface")
-            cpu_tracker = "RAPL"
-            hardware = CPU.from_utils(self._output_dir, "intel_rapl")
-            self._hardware.append(hardware)
-            self._conf["cpu_model"] = hardware.get_model()
-        # change code to check if powermetrics needs to be installed or just sudo setup
-        elif (
-            powermetrics.is_powermetrics_available() and self._default_cpu_power is None
-        ):
-            logger.info("Tracking Apple CPU and GPU via PowerMetrics")
-            gpu_tracker = "PowerMetrics"
-            cpu_tracker = "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:
-            # Explain what to install to increase accuracy
-            cpu_tracking_install_instructions = ""
-            if is_mac_os():
-                if (
-                    "M1" in detect_cpu_model()
-                    or "M2" in detect_cpu_model()
-                    or "M3" in detect_cpu_model()
-                ):
-                    cpu_tracking_install_instructions = ""
-                    cpu_tracking_install_instructions = "Mac OS and ARM processor detected: Please enable PowerMetrics sudo to measure CPU"
-                else:
-                    cpu_tracking_install_instructions = "Mac OS detected: Please install Intel Power Gadget or enable PowerMetrics sudo to measure CPU"
-            elif is_windows_os():
-                cpu_tracking_install_instructions = "Windows OS detected: Please install Intel Power Gadget to measure CPU"
-            elif is_linux_os():
-                cpu_tracking_install_instructions = "Linux OS detected: Please ensure RAPL files exist at \\sys\\class\\powercap\\intel-rapl to measure CPU"
-            logger.warning(
-                f"No CPU tracking mode found. Falling back on CPU constant mode. \n {cpu_tracking_install_instructions}\n"
-            )
-            cpu_tracker = "TDP constant"
-            tdp = cpu.TDP()
-            power = tdp.tdp
-            model = tdp.model
-            if (power is None) and self._default_cpu_power:
-                # We haven't been able to calculate CPU power but user has input a default one. We use it
-                user_input_power = self._default_cpu_power
-                logger.debug(f"Using user input TDP: {user_input_power} W")
-                cpu_tracker = "User Input TDP constant"
-                power = user_input_power
-            logger.info(f"CPU Model on constant consumption mode: {model}")
-            self._conf["cpu_model"] = model
-            if tdp:
-                hardware = CPU.from_utils(self._output_dir, "constant", model, power)
-                self._hardware.append(hardware)
-            else:
-                logger.warning(
-                    "Failed to match CPU TDP constant. "
-                    + "Falling back on a global constant."
-                )
-                cpu_tracker = "global constant"
-                hardware = CPU.from_utils(self._output_dir, "constant")
-                self._hardware.append(hardware)
-        logger.debug(
-            f"""The below tracking methods have been set up:
-                RAM Tracking Method: {ram_tracker}
-                CPU Tracking Method: {cpu_tracker}
-                GPU Tracking Method: {gpu_tracker}
-            """
-        )
+        self._init_output_methods(api_key=self._api_key)
 
-    def _init_output_methods(self, *, api_key: str = None, access_token: str = None):
+    def _init_output_methods(self, *, api_key: str = None):
         """
         Prepare the different output methods
         """
@@ -504,7 +374,6 @@ class BaseEmissionsTracker(ABC):
                 endpoint_url=self._api_endpoint,
                 experiment_id=self._experiment_id,
                 api_key=api_key,
-                access_token=access_token,
                 conf=self._conf,
             )
             self.run_id = cc_api__out.run_id

codecarbon-2.8.2/codecarbon/lock.py

@@ -0,0 +1,68 @@
+"""
+Ensures that only one instance of codecarbon is running at a time.
+It creates a lock file in /tmp/.codecarbon.lock and removes it on exit.
+If the lock file already exists, it exits the program.
+"""
+
+import atexit
+import errno
+import os
+import signal
+import tempfile
+import threading
+
+from codecarbon.external.logger import logger
+
+# We use tempfile.gettempdir() to get the system's temporary directory (linux: /tmp, windows: C:\Users\username\AppData\Local\Temp)
+LOCKFILE = os.path.join(tempfile.gettempdir(), ".codecarbon.lock")
+
+
+class Lock:
+    """A lock to ensure only one instance of codecarbon is running."""
+
+    def __init__(self):
+        self._has_created_lock = False
+        self.lockfile_path = LOCKFILE
+        atexit.register(
+            self.release
+        )  # Ensure release() is called on unexpected exit of the user's python code
+        # If there is more than one thread add a lock
+        self._thread_lock = threading.Lock()
+        # If the current thread is the main thread, register signal handlers
+        if threading.current_thread() is threading.main_thread():
+            # Register signal handlers to ensure lock release on interruption
+            signal.signal(signal.SIGINT, self._handle_exit)  # Ctrl+C
+            signal.signal(signal.SIGTERM, self._handle_exit)  # Termination signal
+
+    def _handle_exit(self, signum, frame):
+        """Ensures the lock file is removed when the script is interrupted."""
+        logger.debug(f"Signal {signum} received. Releasing lock and exiting.")
+        self.release()
+        os._exit(1)  # Exit immediately to prevent further execution
+
+    def acquire(self):
+        """Creates a lock file and ensures it's the only instance running."""
+        with self._thread_lock:
+            # Attempt to create the lock file
+            try:
+                with open(LOCKFILE, "x") as _:
+                    logger.debug(f"Lock file created. Path: {LOCKFILE}")
+                    self._has_created_lock = True
+            except FileExistsError:
+                logger.debug(
+                    f"Lock file {LOCKFILE} already exists. This usually means another instance of codecarbon is running. You can safely delete it if you want or use allow_multiple_runs parameter to always bypass it."
+                )
+                raise
+
+    def release(self):
+        """Removes the lock file on exit."""
+        with self._thread_lock:
+            logger.debug("Removing the lock")
+            try:
+                # Remove the lock file only if it was created by this instance
+                if self._has_created_lock:
+                    os.remove(LOCKFILE)
+            except OSError as e:
+                logger.debug(f"Error: {e}")
+                if e.errno != errno.ENOENT:
+                    raise

{codecarbon-2.8.0 → codecarbon-2.8.2}/codecarbon/output_methods/http.py

@@ -46,19 +46,25 @@ class CodeCarbonAPIOutput(BaseOutput):
         experiment_id: str,
         api_key: str,
         conf,
-        access_token: str = None,
     ):
         self.endpoint_url: str = endpoint_url
         self.api = ApiClient(
             experiment_id=experiment_id,
             endpoint_url=endpoint_url,
             api_key=api_key,
-            access_token=access_token,
             conf=conf,
         )
         self.run_id = self.api.run_id
 
+    def live_out(self, total: EmissionsData, delta: EmissionsData):
+        # Called at regular intervals
+        try:
+            self.api.add_emission(dataclasses.asdict(delta))
+        except Exception as e:
+            logger.error(e, exc_info=True)
+
     def out(self, total: EmissionsData, delta: EmissionsData):
+        # Called on exit
         try:
             self.api.add_emission(dataclasses.asdict(delta))
         except Exception as e:

{codecarbon-2.8.0 → codecarbon-2.8.2}/pyproject.toml

@@ -183,7 +183,7 @@ include = [
 ]
 
 [tool.bumpver]
-current_version = "2.8.0"
+current_version = "2.8.2"
 version_pattern = "MAJOR.MINOR.PATCH"
 
 [tool.bumpver.file_patterns]

codecarbon-2.8.0/codecarbon/_version.py

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

codecarbon-2.8.0/codecarbon/lock.py

@@ -1,61 +0,0 @@
-"""
-Ensures that only one instance of codecarbon is running at a time.
-It creates a lock file in /tmp/.codecarbon.lock and removes it on exit.
-If the lock file already exists, it exits the program.
-"""
-
-import atexit
-import errno
-import os
-import signal
-import tempfile
-
-from codecarbon.external.logger import logger
-
-# We use tempfile.gettempdir() to get the system's temporary directory (linux: /tmp, windows: C:\Users\username\AppData\Local\Temp)
-LOCKFILE = os.path.join(tempfile.gettempdir(), ".codecarbon.lock")
-
-
-class Lock:
-    """A lock to ensure only one instance of codecarbon is running."""
-
-    def __init__(self):
-        self._has_created_lock = False
-        self.lockfile_path = LOCKFILE
-        atexit.register(
-            self.release
-        )  # Ensure release() is called on unexpected exit of the user's python code
-        # Register signal handlers to ensure lock release on interruption
-        signal.signal(signal.SIGINT, self._handle_exit)  # Ctrl+C
-        signal.signal(signal.SIGTERM, self._handle_exit)  # Termination signal
-
-    def _handle_exit(self, signum, frame):
-        """Ensures the lock file is removed when the script is interrupted."""
-        logger.debug(f"Signal {signum} received. Releasing lock and exiting.")
-        self.release()
-        os._exit(1)  # Exit immediately to prevent further execution
-
-    def acquire(self):
-        """Creates a lock file and ensures it's the only instance running."""
-        # Attempt to create the lock file
-        try:
-            with open(LOCKFILE, "x") as _:
-                logger.debug(f"Lock file created. Path: {LOCKFILE}")
-                self._has_created_lock = True
-        except FileExistsError:
-            logger.debug(
-                f"Lock file {LOCKFILE} already exists. This usually means another instance of codecarbon is running. You can safely delete it if you want or use allow_multiple_runs parameter to always bypass it."
-            )
-            raise
-
-    def release(self):
-        """Removes the lock file on exit."""
-        logger.debug("Removing the lock")
-        try:
-            # Remove the lock file only if it was created by this instance
-            if self._has_created_lock:
-                os.remove(LOCKFILE)
-        except OSError as e:
-            logger.debug(f"Error: {e}")
-            if e.errno != errno.ENOENT:
-                raise