codecarbon 3.0.0rc7__tar.gz → 3.0.2__tar.gz

{codecarbon-3.0.0rc7 → codecarbon-3.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codecarbon
-Version: 3.0.0rc7
+Version: 3.0.2
 Project-URL: Homepage, https://codecarbon.io/
 Project-URL: Repository, https://github.com/mlco2/codecarbon
 Project-URL: Dashboard, http://dashboard.codecarbon.io/

codecarbon-3.0.2/codecarbon/_version.py

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

{codecarbon-3.0.0rc7 → codecarbon-3.0.2}/codecarbon/cli/main.py

@@ -96,7 +96,7 @@ def show_config(path: Path = Path("./.codecarbon.config")) -> None:
                     print(org)
     except Exception as e:
         raise ValueError(
-            f"Your configuration is invalid, please run `codecarbon config --init` first! (error: {e})"
+            f"Your configuration is invalid, please verify your configuration file at {path}. To start from scratch, run `codecarbon config` and overwrite your configuration file. (error: {e})"
         )
 
 
@@ -107,9 +107,19 @@ def get_fief_auth():
 
 
 def _get_access_token():
-    access_token_info = get_fief_auth().access_token_info()
-    access_token = access_token_info["access_token"]
-    return access_token
+    try:
+        access_token_info = get_fief_auth().access_token_info()
+        access_token = access_token_info["access_token"]
+        return access_token
+    except Exception as e:
+        raise ValueError(
+            f"Not able to retrieve the access token, please run `codecarbon login` first! (error: {e})"
+        )
+
+
+def _get_id_token():
+    id_token = get_fief_auth()._tokens["id_token"]
+    return id_token
 
 
 @codecarbon.command(
@@ -128,6 +138,10 @@ def api_get():
 @codecarbon.command("login", short_help="Login to CodeCarbon")
 def login():
     get_fief_auth().authorize()
+    api = ApiClient(endpoint_url=API_URL)  # TODO: get endpoint from config
+    id_token = _get_id_token()
+    api.set_access_token(id_token)
+    api.check_auth()
 
 
 def get_api_key(project_id: str):
@@ -214,6 +228,9 @@ def config():
             description=org_description,
         )
         organization = api.create_organization(organization=organization_create)
+        if organization is None:
+            print("Error creating organization")
+            return
         print(f"Created organization : {organization}")
     else:
         organization = [orga for orga in organizations if orga["name"] == org][0]

{codecarbon-3.0.0rc7 → codecarbon-3.0.2}/codecarbon/core/api_client.py

@@ -39,16 +39,20 @@ class ApiClient:  # (AsyncClient)
 
     def __init__(
         self,
-        # endpoint_url="https://api.codecarbon.io",
-        endpoint_url="https://dash-dev.cleverapps.io/api",  # beta API
+        endpoint_url="https://api.codecarbon.io",
         experiment_id=None,
         api_key=None,
         access_token=None,
         conf=None,
+        create_run_automatically=True,
     ):
         """
-        :project_id: ID of the existing project
+        :endpoint_url: URL of the API endpoint
+        :experiment_id: ID of the experiment
         :api_key: Code Carbon API_KEY
+        :access_token: Code Carbon API access token
+        :conf: Metadata of the experiment
+        :create_run_automatically: If False, do not create a run. To use API in read only mode.
         """
         # super().__init__(base_url=endpoint_url) # (AsyncClient)
         self.url = endpoint_url
@@ -56,21 +60,12 @@ class ApiClient:  # (AsyncClient)
         self.api_key = api_key
         self.conf = conf
         self.access_token = access_token
-        if self.experiment_id is not None:
+        if self.experiment_id is not None and create_run_automatically:
             self._create_run(self.experiment_id)
-        import warnings
-
-        # FIXME: remove this warning in the future, once the release is created
-        warnings.warn(
-            "Beta API will be reworked, and some features will be removed. If you have data persisted through the API, please be warned that it will be erased with the next API release",
-            DeprecationWarning,
-            stacklevel=2,
-        )
 
     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
         elif self.access_token:
@@ -84,6 +79,18 @@ class ApiClient:  # (AsyncClient)
         """
         self.access_token = token
 
+    def check_auth(self):
+        """
+        Check API access to user account
+        """
+        url = self.url + "/auth/check"
+        headers = self._get_headers()
+        r = requests.get(url=url, timeout=2, headers=headers)
+        if r.status_code != 200:
+            self._log_error(url, {}, r)
+            return None
+        return r.json()
+
     def get_list_organizations(self):
         """
         List all organizations
@@ -192,9 +199,8 @@ class ApiClient:  # (AsyncClient)
     def add_emission(self, carbon_emission: dict):
         assert self.experiment_id is not None
         if self.run_id is None:
-            # TODO : raise an Exception ?
-            logger.debug(
-                "ApiClient.add_emission need a run_id : the initial call may "
+            logger.warning(
+                "ApiClient.add_emission() need a run_id : the initial call may "
                 + "have failed. Retrying..."
             )
             self._create_run(self.experiment_id)
@@ -236,14 +242,15 @@ class ApiClient:  # (AsyncClient)
             return False
         return True
 
-    def _create_run(self, experiment_id):
+    def _create_run(self, experiment_id: str):
         """
         Create the experiment for project_id
-        # TODO : Allow to give an existing experiment_id
         """
         if self.experiment_id is None:
             # TODO : raise an Exception ?
-            logger.error("ApiClient FATAL The API _create_run needs an experiment_id !")
+            logger.error(
+                "ApiClient FATAL The ApiClient._create_run() needs an experiment_id !"
+            )
             return None
         try:
             run = RunCreate(

{codecarbon-3.0.0rc7 → codecarbon-3.0.2}/codecarbon/core/units.py

@@ -61,6 +61,9 @@ class Energy:
 
     kWh: float = field(compare=True)
 
+    def __post_init__(self):
+        self.kWh = float(self.kWh)
+
     @classmethod
     def from_power_and_time(cls, *, power: "Power", time: "Time") -> "Energy":
         assert isinstance(power.kW, float)
@@ -134,10 +137,8 @@ class Power:
         Returns:
             Power: Resulting Power estimation
         """
-        delta_energy = abs(e2.kWh - e1.kWh)
-        assert isinstance(delta_energy, float)
+        delta_energy = float(abs(e2.kWh - e1.kWh))
         kW = delta_energy / delay.hours if delay.hours != 0.0 else 0.0
-        assert isinstance(delta_energy, float)
         return cls(kW=kW)
 
     @classmethod

{codecarbon-3.0.0rc7/codecarbon/data/hardware → codecarbon-3.0.2/codecarbon/data/hardware/cpu_dataset_builder}/CPU_Create_Dataset.ipynb

@@ -357,7 +357,7 @@
     "\n",
     "url = \"https://www.intel.com/content/www/us/en/ark/products/series/236644/5th-gen-intel-xeon-scalable-processors.html\"\n",
     "response = requests.get(url)\n",
-    "soup = BeautifulSoup(response.text, 'html.parser')"
+    "soup = BeautifulSoup(response.text, \"html.parser\")"
    ]
   },
   {
@@ -454,25 +454,26 @@
    ],
    "source": [
     "# Find the table\n",
-    "table = soup.find('table', id='product-table')\n",
+    "table = soup.find(\"table\", id=\"product-table\")\n",
     "\n",
     "# Extract headers\n",
     "headers = []\n",
-    "for th in table.find_all('th'):\n",
-    "    header_text = th.find('div', class_='header-text-space').text.strip()\n",
+    "for th in table.find_all(\"th\"):\n",
+    "    header_text = th.find(\"div\", class_=\"header-text-space\").text.strip()\n",
     "    headers.append(header_text)\n",
     "\n",
     "# Extract rows\n",
     "data = []\n",
-    "for row in table.find('tbody').find_all('tr'):\n",
+    "for row in table.find(\"tbody\").find_all(\"tr\"):\n",
     "    row_data = {}\n",
-    "    cells = row.find_all('td')\n",
+    "    cells = row.find_all(\"td\")\n",
     "    for i, cell in enumerate(cells):\n",
     "        row_data[headers[i]] = cell.text.strip()\n",
     "    data.append(row_data)\n",
     "\n",
     "# Convert to pandas DataFrame for easy viewing/export\n",
     "import pandas as pd\n",
+    "\n",
     "df = pd.DataFrame(data)\n",
     "print(df)"
    ]
@@ -526,7 +527,7 @@
     }
    ],
    "source": [
-    "df['TDP'].replace(\"W\", \"\")"
+    "df[\"TDP\"].replace(\"W\", \"\")"
    ]
   },
   {
@@ -554,24 +555,28 @@
     "\n",
     "# Path to your manually exported AMD CPU dataset.\n",
     "# (Adjust the file path as needed.)\n",
-    "amd_csv_path = './AMD_CPU_desktop_laptop.csv'\n",
+    "amd_csv_path = \"./AMD_CPU_desktop_laptop.csv\"\n",
     "\n",
     "try:\n",
     "    amd_df = pd.read_csv(amd_csv_path)\n",
-    "    amd_df = amd_df[amd_df['Launch Date'].str.contains(\"2024|2025\", na=False)]\n",
-    "    amd_df = amd_df[amd_df['Form Factor'].str.contains(\"Desktops\", na=False)]\n",
-    "    \n",
+    "    amd_df = amd_df[amd_df[\"Launch Date\"].str.contains(\"2024|2025\", na=False)]\n",
+    "    amd_df = amd_df[amd_df[\"Form Factor\"].str.contains(\"Desktops\", na=False)]\n",
+    "\n",
     "    # Convert columns to numeric, forcing errors to NaN\n",
     "    # amd_df['Default TDP'] = amd_df['Default TDP'].str.replace('W', '').astype(float)\n",
-    "    amd_df['TDP'] = pd.to_numeric(amd_df['Default TDP'].str.replace('W', ''), errors='coerce')\n",
-    "    amd_df['# of Threads'] = pd.to_numeric(amd_df['# of Threads'], errors='coerce')\n",
-    "    \n",
+    "    amd_df[\"TDP\"] = pd.to_numeric(\n",
+    "        amd_df[\"Default TDP\"].str.replace(\"W\", \"\"), errors=\"coerce\"\n",
+    "    )\n",
+    "    amd_df[\"# of Threads\"] = pd.to_numeric(amd_df[\"# of Threads\"], errors=\"coerce\")\n",
+    "\n",
     "    # It is assumed the CSV contains columns named 'TDP' (in Watts) and 'Total Cores'\n",
     "    # Adjust the column names if they differ.\n",
-    "    amd_df['TDP_per_core'] = amd_df['TDP'] / amd_df['# of Threads']\n",
-    "    \n",
-    "    average_tdp_per_core = amd_df['TDP_per_core'].mean()\n",
-    "    print(\"Average TDP per core from AMD dataset: {:.2f} W\".format(average_tdp_per_core))\n",
+    "    amd_df[\"TDP_per_core\"] = amd_df[\"TDP\"] / amd_df[\"# of Threads\"]\n",
+    "\n",
+    "    average_tdp_per_core = amd_df[\"TDP_per_core\"].mean()\n",
+    "    print(\n",
+    "        \"Average TDP per core from AMD dataset: {:.2f} W\".format(average_tdp_per_core)\n",
+    "    )\n",
     "except Exception as e:\n",
     "    print(\"Error loading or processing AMD dataset:\", e)"
    ]
@@ -595,23 +600,27 @@
     "\n",
     "# Path to your manually exported AMD CPU dataset.\n",
     "# (Adjust the file path as needed.)\n",
-    "amd_csv_path = './AMD_Server_Processor_Specifications.csv'\n",
+    "amd_csv_path = \"./AMD_Server_Processor_Specifications.csv\"\n",
     "\n",
     "try:\n",
     "    amd_df = pd.read_csv(amd_csv_path)\n",
-    "    amd_df = amd_df[amd_df['Launch Date'].str.contains(\"2024|2025\", na=False)]\n",
-    "    \n",
+    "    amd_df = amd_df[amd_df[\"Launch Date\"].str.contains(\"2024|2025\", na=False)]\n",
+    "\n",
     "    # Convert columns to numeric, forcing errors to NaN\n",
     "    # amd_df['Default TDP'] = amd_df['Default TDP'].str.replace('W', '').astype(float)\n",
-    "    amd_df['TDP'] = pd.to_numeric(amd_df['Default TDP'].str.replace('W', ''), errors='coerce')\n",
-    "    amd_df['# of Threads'] = pd.to_numeric(amd_df['# of Threads'], errors='coerce')\n",
-    "    \n",
+    "    amd_df[\"TDP\"] = pd.to_numeric(\n",
+    "        amd_df[\"Default TDP\"].str.replace(\"W\", \"\"), errors=\"coerce\"\n",
+    "    )\n",
+    "    amd_df[\"# of Threads\"] = pd.to_numeric(amd_df[\"# of Threads\"], errors=\"coerce\")\n",
+    "\n",
     "    # It is assumed the CSV contains columns named 'TDP' (in Watts) and 'Total Cores'\n",
     "    # Adjust the column names if they differ.\n",
-    "    amd_df['TDP_per_core'] = amd_df['TDP'] / amd_df['# of Threads']\n",
-    "    \n",
-    "    average_tdp_per_core = amd_df['TDP_per_core'].mean()\n",
-    "    print(\"Average TDP per core from AMD dataset: {:.2f} W\".format(average_tdp_per_core))\n",
+    "    amd_df[\"TDP_per_core\"] = amd_df[\"TDP\"] / amd_df[\"# of Threads\"]\n",
+    "\n",
+    "    average_tdp_per_core = amd_df[\"TDP_per_core\"].mean()\n",
+    "    print(\n",
+    "        \"Average TDP per core from AMD dataset: {:.2f} W\".format(average_tdp_per_core)\n",
+    "    )\n",
     "except Exception as e:\n",
     "    print(\"Error loading or processing AMD dataset:\", e)"
    ]
@@ -1055,7 +1064,7 @@
     }
    ],
    "source": [
-    "amd_df[['Name', 'TDP', '# of Threads', 'TDP_per_core', 'Launch Date']]"
+    "amd_df[[\"Name\", \"TDP\", \"# of Threads\", \"TDP_per_core\", \"Launch Date\"]]"
    ]
   },
   {
@@ -1179,7 +1188,7 @@
     }
    ],
    "source": [
-    "df = pd.read_csv('cpu_power.csv')\n",
+    "df = pd.read_csv(\"cpu_power.csv\")\n",
     "df"
    ]
   },
@@ -1246,12 +1255,14 @@
     }
    ],
    "source": [
-    "amd_csv_path = './AMD_Server_Processor_Specifications.csv'\n",
+    "amd_csv_path = \"./AMD_Server_Processor_Specifications.csv\"\n",
     "amd_df = pd.read_csv(amd_csv_path)\n",
-    "amd_df['TDP'] = pd.to_numeric(amd_df['Default TDP'].str.replace('W', ''), errors='coerce')\n",
-    "amd_df['Name'] = amd_df['Name'].str.replace('™', '')\n",
-    "amd_server = amd_df[['Name', 'TDP' ]]\n",
-    "amd_server = amd_server.dropna(subset=['TDP'])\n",
+    "amd_df[\"TDP\"] = pd.to_numeric(\n",
+    "    amd_df[\"Default TDP\"].str.replace(\"W\", \"\"), errors=\"coerce\"\n",
+    ")\n",
+    "amd_df[\"Name\"] = amd_df[\"Name\"].str.replace(\"™\", \"\")\n",
+    "amd_server = amd_df[[\"Name\", \"TDP\"]]\n",
+    "amd_server = amd_server.dropna(subset=[\"TDP\"])\n",
     "amd_server.head(3)"
    ]
   },
@@ -1406,11 +1417,13 @@
    ],
    "source": [
     "# Merge df with amd_server, avoiding duplicates\n",
-    "amd_server['TDP'] = amd_server['TDP'].astype(int).astype(str)\n",
-    "merged_df = df.merge(amd_server, on='Name', how='outer', suffixes=('', '_AMD'), indicator=True)\n",
+    "amd_server[\"TDP\"] = amd_server[\"TDP\"].astype(int).astype(str)\n",
+    "merged_df = df.merge(\n",
+    "    amd_server, on=\"Name\", how=\"outer\", suffixes=(\"\", \"_AMD\"), indicator=True\n",
+    ")\n",
     "# Filter for new entries that are only in amd_server\n",
-    "new_cpus = merged_df[merged_df['_merge'] == 'right_only']\n",
-    "new_cpus['TDP'] = new_cpus['TDP_AMD']\n",
+    "new_cpus = merged_df[merged_df[\"_merge\"] == \"right_only\"]\n",
+    "new_cpus[\"TDP\"] = new_cpus[\"TDP_AMD\"]\n",
     "new_cpus"
    ]
   },
@@ -1528,11 +1541,9 @@
     }
    ],
    "source": [
-    "\n",
-    "\n",
     "# merged_df.query('Name.str.contains(\"EPYC\")')\n",
-    "new_cpus_to_add = new_cpus.drop(columns=['_merge']).loc[:, df.columns]\n",
-    "new_cpus_to_add\n"
+    "new_cpus_to_add = new_cpus.drop(columns=[\"_merge\"]).loc[:, df.columns]\n",
+    "new_cpus_to_add"
    ]
   },
   {
@@ -1588,7 +1599,7 @@
    "source": [
     "# Option 2: Append the new CPUs to the original df\n",
     "df = pd.concat([df, new_cpus_to_add], ignore_index=True)\n",
-    "df.sort_values('Name', ascending=True, inplace=True)\n",
+    "df.sort_values(\"Name\", ascending=True, inplace=True)\n",
     "df.query('Name.str.contains(\"AMD EPYC 4124P\")')"
    ]
   },
@@ -1598,7 +1609,36 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "df.to_csv('cpu_power.csv', index=False)"
+    "df.to_csv(\"cpu_power.csv\", index=False)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Remove with..."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import pandas as pd\n",
+    "# Load the existing dataset\n",
+    "df = pd.read_csv(\"../cpu_power.csv\")\n",
+    "# Replace with re.sub(r\" with.*\", \"\", name)\n",
+    "def clean_cpu_name(name):\n",
+    "    import re\n",
+    "    # Remove \"with\" and everything after it\n",
+    "    name = re.sub(r\" with.*\", \"\", name)\n",
+    "    # Remove \"™\" symbol\n",
+    "    name = name.replace(\"™\", \"\")\n",
+    "    return name.strip()\n",
+    "df[\"Name\"] = df[\"Name\"].apply(clean_cpu_name)\n",
+    "# Save the cleaned dataset\n",
+    "df.to_csv(\"../cpu_power.csv\", index=False)"
    ]
   },
   {
@@ -1609,7 +1649,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "codecarbon",
+   "display_name": "3.10.5",
    "language": "python",
    "name": "python3"
   },
@@ -1623,7 +1663,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.12.3"
+   "version": "3.10.5"
   }
  },
  "nbformat": 4,

codecarbon-3.0.2/codecarbon/data/hardware/cpu_dataset_builder/README.md

@@ -0,0 +1,15 @@
+# How to update the CPU database
+
+To update the CPU database, you have to run:
+
+```bash
+cd codecarbon/data/hardware/cpu_dataset_builder
+hatch run pip install playwright beautifulsoup4
+hatch run python intel_cpu_scrapper.py
+hatch run python amd_cpu_scrapper.py
+hatch run python merge_scrapped_cpu_power.py
+```
+
+Then commit the changes to the CSV files.
+
+CodeCarbon only use the `cpu_power.csv` file, but we keep the other files for reference and to allow someone else to use them if needed.