ecoml 0.1.3__tar.gz

ecoml-0.1.3/PKG-INFO

@@ -0,0 +1,18 @@
+Metadata-Version: 2.4
+Name: ecoml
+Version: 0.1.3
+Summary: Real-time GPU, CPU, and CO₂ tracking with pill UI for Jupyter notebooks.
+Author-email: Your Name <you@example.com>
+License: MIT
+Project-URL: Homepage, https://github.com/yourname/EcoML
+Project-URL: Source, https://github.com/yourname/EcoML
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: psutil
+Requires-Dist: pynvml
+Requires-Dist: GPUtil
+Requires-Dist: python-dotenv
+Requires-Dist: pandas
+Requires-Dist: ipython
+Provides-Extra: gemini
+Requires-Dist: google-generativeai; extra == "gemini"

ecoml-0.1.3/ecoml/__init__.py

@@ -0,0 +1,26 @@
+from .tracker import EcoTracker
+from .ui import CellHook
+from .recommender import RecommendationEngine
+from .gemini_helper import GeminiAdvisor
+from pathlib import Path
+
+def enable_tracking():
+    """
+    One-line activation for EcoML inside any Jupyter Notebook.
+    """
+    log_path = Path.home() / ".ecoml" / "emissions_log.csv"
+    log_path.parent.mkdir(exist_ok=True, parents=True)
+
+    tracker = EcoTracker(log_path=str(log_path))
+    recommender = RecommendationEngine(tracker)
+    CellHook(tracker, recommender).register()
+
+    print("🌱 EcoML tracking enabled – monitoring CPU/GPU/CO₂")
+
+__all__ = [
+    "EcoTracker",
+    "CellHook",
+    "RecommendationEngine",
+    "GeminiAdvisor",
+    "enable_tracking"
+]

ecoml-0.1.3/ecoml/dashboard.py

@@ -0,0 +1,57 @@
+"""
+Simple dashboard helpers.
+
+You can use these inside a notebook to quickly inspect the CSV log.
+For PowerBI you will mostly just load data/data/emissions_log.csv directly.
+"""
+
+from typing import Optional
+
+import pandas as pd
+import matplotlib.pyplot as plt
+
+
+def load_log(log_path: str) -> pd.DataFrame:
+    df = pd.read_csv(log_path)
+    if "timestamp" in df.columns:
+        df["timestamp"] = pd.to_datetime(df["timestamp"])
+    return df
+
+
+def show_summary(df: pd.DataFrame) -> None:
+    total_runs = len(df)
+    total_runtime = df["runtime_sec"].sum()
+    total_co2 = df["co2_g"].sum()
+    avg_co2 = df["co2_g"].mean()
+
+    print("==== EcoML Summary ====")
+    print(f"Runs: {total_runs}")
+    print(f"Total runtime: {total_runtime:.2f} sec")
+    print(f"Total CO₂: {total_co2:.3f} g")
+    print(f"Average CO₂ per cell: {avg_co2:.4f} g")
+
+
+def plot_emissions_over_time(df: pd.DataFrame) -> None:
+    if "timestamp" not in df.columns:
+        print("No timestamp column – cannot plot over time.")
+        return
+
+    df_sorted = df.sort_values("timestamp")
+    plt.figure()
+    plt.plot(df_sorted["timestamp"], df_sorted["co2_g"])
+    plt.xlabel("Time")
+    plt.ylabel("CO₂ per cell (g)")
+    plt.title("EcoML: CO₂ Emissions Over Time")
+    plt.xticks(rotation=45)
+    plt.tight_layout()
+    plt.show()
+
+
+def plot_runtime_vs_emissions(df: pd.DataFrame) -> None:
+    plt.figure()
+    plt.scatter(df["runtime_sec"], df["co2_g"])
+    plt.xlabel("Runtime (sec)")
+    plt.ylabel("CO₂ (g)")
+    plt.title("EcoML: Runtime vs CO₂")
+    plt.tight_layout()
+    plt.show()

ecoml-0.1.3/ecoml/enable.py

@@ -0,0 +1,29 @@
+from .tracker import EcoTracker
+from .ui import CellHook
+from .recommender import RecommendationEngine
+from .gemini_helper import GeminiAdvisor
+
+
+def enable_tracking(
+    notebook_name: str = "Notebook",
+    log_path: str | None = None,
+) -> None:
+    """
+    One-line helper to enable EcoML tracking in any Jupyter notebook.
+
+    Usage
+    -----
+    from ecoml import enable_tracking
+    enable_tracking()
+    """
+
+    tracker = EcoTracker(
+        notebook_name=notebook_name,
+        log_path=log_path or "data/emissions_log.csv",
+    )
+
+    gemini = GeminiAdvisor()
+    recommender = RecommendationEngine(tracker=tracker, gemini=gemini)
+
+    CellHook(tracker, recommender).register()
+    print("🔥 EcoML tracking enabled – pills will appear after each cell.")

ecoml-0.1.3/ecoml/gemini_helper.py

@@ -0,0 +1,56 @@
+import os
+from pathlib import Path
+from dotenv import load_dotenv
+
+try:
+    import google.generativeai as genai
+except:
+    genai = None
+
+
+class GeminiAdvisor:
+
+    def __init__(self):
+        root = Path(__file__).resolve().parents[1]
+        load_dotenv(root / ".env")
+
+        key = os.getenv("GEMINI_API_KEY")
+        if not key:
+            print("⚠ Gemini disabled – no API key found")
+            self.enabled = False
+            return
+
+        if not genai:
+            print("⚠ Gemini client missing (pip install google-generativeai)")
+            self.enabled = False
+            return
+
+        genai.configure(api_key=key)
+        self.model = genai.GenerativeModel("gemini-2.5-flash")
+        self.enabled = True
+        print("🤖 Gemini Enabled ✓")
+
+    # ------------------------------------------------------
+    def ask(self, prompt: str) -> str | None:
+        """One-line optimization advice"""
+        try:
+            out = self.model.generate_content(prompt).text.strip()
+            return out
+        except:
+            return None
+
+    # ------------------------------------------------------
+    def generate_fix(self, err: Exception, code: str | None):
+        """Generate 1-line fix suggestion"""
+        prompt = f"""
+You are a senior Python debugger.
+
+Error:
+{err}
+
+Code that triggered it:
+{code}
+
+Give **ONE LINE FIX ONLY**.
+"""
+        return self.ask(prompt)

ecoml-0.1.3/ecoml/hardware_monitor.py

@@ -0,0 +1,78 @@
+import os
+import sys
+from pathlib import Path
+
+# Try to load pythonnet CLR
+try:
+    import clr
+    CLR_AVAILABLE = True
+except ImportError:
+    CLR_AVAILABLE = False
+
+# Path to the DLL inside ecoml/libs/
+DLL_PATH = Path(__file__).resolve().parent / "libs" / "LibreHardwareMonitorLib.dll"
+
+def init_hardware():
+    """
+    Initialize LibreHardwareMonitor.
+    Returns a Computer() object or None if unavailable.
+    """
+    if not CLR_AVAILABLE:
+        print("pythonnet not installed — LibreHardwareMonitor disabled.")
+        return None
+
+    if not DLL_PATH.exists():
+        print(f"⚠ DLL missing at {DLL_PATH}")
+        return None
+
+    try:
+        # Add DLL folder to sys.path
+        sys.path.append(str(DLL_PATH.parent))
+
+        # Load the DLL using pythonnet
+        clr.AddReference(str(DLL_PATH))
+    except Exception as e:
+        print("⚠ Failed to load LibreHardwareMonitor DLL:", e)
+        return None
+
+    try:
+        from LibreHardwareMonitor.Hardware import Computer 
+
+        computer = Computer()
+        computer.CPUEnabled = True
+        computer.Open()
+        return computer
+
+    except Exception as e:
+        print("⚠ LibreHardwareMonitor init error:", e)
+        return None
+
+
+# Initialize only once
+_computer = init_hardware()
+
+
+def get_cpu_temp_lhm():
+    """
+    Read CPU temperature via LibreHardwareMonitor.
+    Returns:
+        float (temp °C) or None if unavailable.
+    """
+    if _computer is None:
+        return None
+
+    try:
+        from LibreHardwareMonitor.Hardware import SensorType
+
+        for hardware in _computer.Hardware:
+            hardware.Update()
+
+            if "cpu" in hardware.Name.lower():
+                for sensor in hardware.Sensors:
+                    if sensor.SensorType == SensorType.Temperature:
+                        return float(sensor.Value)
+
+    except:
+        return None
+
+    return None

ecoml-0.1.3/ecoml/metrics.py

@@ -0,0 +1,103 @@
+import psutil, GPUtil, subprocess
+
+# Needed for temperature fallback
+def _read_gpu_temp_wmi():
+    """
+    Windows WMI GPU temperature reader.
+    Works on MX series GPUs (MX330).
+    """
+    try:
+        import wmi
+        w = wmi.WMI(namespace="root\\OpenHardwareMonitor")
+        for sensor in w.Sensor():
+            if sensor.SensorType == "Temperature" and "gpu" in sensor.Name.lower():
+                return float(sensor.Value)
+    except:
+        return None
+
+
+def get_metrics() -> dict:
+    """
+    SAFE SYSTEM METRICS
+    ALWAYS returns full dict → UI NEVER breaks
+    """
+
+    m = {}
+
+    # ==========================================================
+    # CPU UTIL
+    # ==========================================================
+    try:
+        m["cpu_util_avg"] = float(psutil.cpu_percent(interval=None))
+    except:
+        m["cpu_util_avg"] = 0.0
+
+    # ==========================================================
+    # CPU TEMP
+    # ==========================================================
+    try:
+        temps = psutil.sensors_temperatures()
+        if temps and "coretemp" in temps:
+            m["cpu_temp_c"] = temps["coretemp"][0].current
+        else:
+            m["cpu_temp_c"] = 0.0
+    except:
+        m["cpu_temp_c"] = 0.0
+
+    # ==========================================================
+    # GPU (PRIMARY: GPUtil)
+    # ==========================================================
+    try:
+        g = GPUtil.getGPUs()
+        if g:
+            gpu = g[0]
+
+            m.update({
+                "gpu_util_avg": gpu.load * 100,
+                "gpu_temp_c": gpu.temperature,
+                "gpu_mem_used_mb": gpu.memoryUsed,
+                "gpu_mem_free_mb": gpu.memoryFree,
+                "gpu_mem_total_mb": gpu.memoryTotal,
+                "gpu_power_w": 0.0,        # GPUtil cannot read power
+                "hardware_type": "GPU",
+                "hardware_name": gpu.name
+            })
+
+        else:
+            raise Exception("NO GPU")
+
+    except:
+        pass  # FALLBACK BELOW
+
+    # ==========================================================
+    # GPU TEMP FALLBACK (WMI)
+    # ==========================================================
+    if m.get("gpu_temp_c", 0) in [None, 0.0]:
+        t = _read_gpu_temp_wmi()
+        if t:
+            m["gpu_temp_c"] = t
+
+    # ==========================================================
+    # CPU-ONLY FALLBACK
+    # ==========================================================
+    if "hardware_type" not in m:
+        m.update({
+            "gpu_util_avg": 0.0,
+            "gpu_temp_c": 0.0,
+            "gpu_power_w": 0.0,
+            "gpu_mem_used_mb": 0.0,
+            "gpu_mem_free_mb": 0.0,
+            "gpu_mem_total_mb": 0.0,
+            "hardware_type": "CPU",
+            "hardware_name": "CPU Only"
+        })
+
+    # ==========================================================
+    # CPU POWER ESTIMATE
+    # ==========================================================
+    try:
+        m["cpu_power_w"] = max(2.0, m["cpu_util_avg"] * 0.35)
+    except:
+        m["cpu_power_w"] = 3.0
+
+    return m

ecoml-0.1.3/ecoml/predictor.py

@@ -0,0 +1,105 @@
+import os
+from datetime import datetime
+
+import joblib
+import pandas as pd
+import torch
+
+# =========================================================
+# PATHS
+# =========================================================
+BASE_DIR = os.path.dirname(os.path.abspath(__file__))
+
+DATA_PATH = os.path.join(os.path.dirname(BASE_DIR), "data", "emissions_log.csv")
+
+# ✅ Models live in ecoml/model/
+SCALER_PATH = os.path.join(BASE_DIR, "model", "scaler.pkl")
+RECOMMENDER_PATH = os.path.join(BASE_DIR, "model", "hardware_recommender_model.pkl")
+
+LOG_PATH = os.path.join(os.path.dirname(BASE_DIR), "data", "recommendations_log.csv")
+
+# =========================================================
+# ✨ MANUAL CLASS LABEL MAP
+# =========================================================
+LABEL_MAP = {
+    0: "CPU Efficient — No GPU Needed",
+    1: "GPU Efficient — Continue GPU Usage",
+    2: "Upgrade Recommended — Mid-range GPU",
+    3: "High-End GPU Required for heavy workloads",
+}
+
+# =========================================================
+# LOAD MODELS
+# =========================================================
+if not os.path.exists(SCALER_PATH) or not os.path.exists(RECOMMENDER_PATH):
+    raise FileNotFoundError(
+        f"Scaler or recommender model not found in {os.path.join(BASE_DIR, 'model')}"
+    )
+
+scaler = joblib.load(SCALER_PATH)
+recommender = joblib.load(RECOMMENDER_PATH)
+
+# =========================================================
+# GPU CHECK
+# =========================================================
+GPU_AVAILABLE = torch.cuda.is_available()
+
+print("\n=============================")
+print("🟢 GPU Available" if GPU_AVAILABLE else "⚠ No GPU detected → CPU only")
+print("=============================\n")
+
+# =========================================================
+# GET CLEAN LIVE INPUT
+# =========================================================
+def get_live_data():
+    df = pd.read_csv(DATA_PATH)
+
+    latest = df.tail(1).copy()
+
+    # keep numeric only
+    numeric = latest.select_dtypes(include=["number"])
+    latest = numeric.copy()
+
+    needed = scaler.feature_names_in_
+    latest = latest.reindex(columns=needed, fill_value=0)
+
+    scaled = scaler.transform(latest)
+    return scaled, latest
+
+
+# =========================================================
+# LOGGING
+# =========================================================
+def save_log(rec: str):
+    entry = {
+        "timestamp": datetime.now().isoformat(),
+        "recommendation": rec,
+    }
+    df = pd.DataFrame([entry])
+
+    if not os.path.exists(LOG_PATH):
+        df.to_csv(LOG_PATH, index=False)
+    else:
+        df.to_csv(LOG_PATH, mode="a", header=False, index=False)
+
+
+# =========================================================
+# PREDICT
+# =========================================================
+def run_prediction():
+    X_scaled, raw = get_live_data()
+
+    pred_int = int(recommender.predict(X_scaled)[0])
+    rec = LABEL_MAP.get(pred_int, f"Unknown Class {pred_int}")
+
+    print("🔍 INPUT:", raw.to_dict("records")[0])
+    print("⚡ RECOMMENDATION:", rec, "\n")
+
+    save_log(rec)
+
+
+# =========================================================
+# AUTO EXECUTE WHEN RUN AS SCRIPT
+# =========================================================
+if __name__ == "__main__":
+    run_prediction()

ecoml-0.1.3/ecoml/recommender.py

@@ -0,0 +1,95 @@
+from typing import Dict, Any
+
+
+class RecommendationEngine:
+
+    def __init__(self, tracker=None, gemini=None):
+        self.tracker = tracker
+        self.gemini = gemini
+
+    # ==========================================================
+    def recommend(self, m: Dict[str, Any], code=None, error=None):
+        """
+        Takes metric record dictionary
+        Returns dict with:
+            recommended_hardware
+            recommended_confidence
+            recommended_reasons
+        """
+
+        suggestions = []
+        label = "Balanced – Continue Current Hardware"
+        confidence = None
+
+        cpu = float(m.get("cpu_util_avg", 0))
+        gpu = float(m.get("gpu_util_avg", 0))
+        temp = float(m.get("cpu_temp_c", 0))
+
+        # ---------------------------------------------
+        # RULE 1: CPU bottleneck
+        # ---------------------------------------------
+        if cpu > 60 and gpu < 40:
+            label = "CPU Bottleneck – Enable GPU"
+            suggestions.append("⚠ High CPU load while GPU is idle → move workload to GPU")
+
+        # ---------------------------------------------
+        # RULE 2: GPU overload
+        # ---------------------------------------------
+        if gpu > 85:
+            suggestions.append("⚠ GPU heavily utilized")
+
+        # ---------------------------------------------
+        # RULE 3: Overheating
+        # ---------------------------------------------
+        if temp > 65:
+            suggestions.append("🔥 CPU overheating detected")
+
+        # ---------------------------------------------
+        # RULE 4: Runtime error
+        # ---------------------------------------------
+        if error:
+            suggestions.append(f"❌ Runtime error: {str(error)[:80]}")
+
+        # =========================================================
+        # 🧠 ONLY CALL GEMINI IF SOMETHING IS WRONG
+        # =========================================================
+        problem_detected = (
+            cpu > 70 or
+            gpu > 75 or
+            temp > 75 or
+            error is not None
+        )
+
+        if self.gemini and self.gemini.enabled and problem_detected:
+
+            # 🔹 Optimization hint
+            ask = f"CPU {cpu}% | GPU {gpu}% | Temp {temp}°C → Give 1-line optimization tip"
+            out = self.gemini.ask(ask)
+
+            if out:
+                suggestions.append("🤖 " + out)
+
+            # 🔹 If error, request a FIX
+            if error and code:
+                fix = self.gemini.generate_fix(error, code)
+                if fix:
+                    suggestions.append("💡 Fix → " + fix)
+
+        # =========================================================
+        # DEFAULT → NO PROBLEMS
+        # =========================================================
+        if not suggestions:
+            return {
+                "recommended_hardware": "Optimal",
+                "recommended_confidence": 1.0,
+                "recommended_reasons": "No changes required – system efficient"
+            }
+
+        # =========================================================
+        # RETURN STANDARD STRUCTURE
+        # =========================================================
+        return {
+            "recommended_hardware": label,
+            "recommended_confidence": confidence,
+            "recommended_reasons": " | ".join(suggestions)
+        }

ecoml-0.1.3/ecoml/tracker.py

@@ -0,0 +1,101 @@
+import time
+from typing import Dict, Any
+from .metrics import get_metrics
+from . import utils
+
+
+class EcoTracker:
+    """
+    Tracks runtime, energy, CO₂ emissions, power usage and
+    passes metrics to recommender + UI.
+    """
+
+    def __init__(self, log_path, notebook_name="Notebook", emission_factor=0.475):
+        self.log_path = log_path
+        self.notebook_name = notebook_name
+        self.emission_factor = emission_factor
+
+        self._cell_id = 0
+        self._start_time = None
+        self._start_metrics = None
+
+    # ================================================================
+    def start_cell(self):
+        """Called BEFORE code executes"""
+        self._cell_id += 1
+        self._start_time = time.time()
+        self._start_metrics = get_metrics()
+
+    # ================================================================
+    def end_cell(self, recommender=None, error=None, code=None) -> Dict[str, Any]:
+        """
+        Called AFTER code executes.
+
+        ⚠️ 100% SAFE VERSION:
+           - Prevents "NoneType - float" crash
+           - Returns {} instead of exploding
+           - Logs metrics + insights
+        """
+
+        # -----------------------------------------------------------------
+        # 🛑 SAFETY CHECK — if start_cell NEVER ran → DO NOT CRASH
+        # -----------------------------------------------------------------
+        if self._start_time is None or self._start_metrics is None:
+            return {}      # UI handles empty dict safely
+
+        # -----------------------------------------------------------------
+        # BASE METRICS
+        # -----------------------------------------------------------------
+        runtime = time.time() - self._start_time
+        end = get_metrics()
+
+        cpu_avg = (self._start_metrics["cpu_util_avg"] + end["cpu_util_avg"]) / 2
+        gpu_avg = (self._start_metrics["gpu_util_avg"] + end["gpu_util_avg"]) / 2
+
+        # Energy (Wh) and CO₂ (g)
+        energy_wh = (end["cpu_power_w"] + end["gpu_power_w"]) * (runtime / 3600)
+        co2 = energy_wh * self.emission_factor
+
+        # -----------------------------------------------------------------
+        # FINAL RECORD (BASE FIELDS)
+        # -----------------------------------------------------------------
+        rec = dict(
+            timestamp=utils.now(),
+            notebook=self.notebook_name,
+            cell_id=self._cell_id,
+            runtime_sec=runtime,
+
+            cpu_util_avg=cpu_avg,
+            gpu_util_avg=gpu_avg,
+            cpu_power_w=end["cpu_power_w"],
+            gpu_power_w=end["gpu_power_w"],
+
+            energy_kwh=energy_wh / 1000,
+            co2_g=co2,
+
+            hardware_type=end["hardware_type"],
+            hardware_name=end["hardware_name"],
+
+            cpu_temp_c=end["cpu_temp_c"],
+            gpu_temp_c=end["gpu_temp_c"],
+
+            gpu_mem_used_mb=end["gpu_mem_used_mb"],
+            gpu_mem_free_mb=end["gpu_mem_free_mb"],
+            gpu_mem_total_mb=end["gpu_mem_total_mb"],
+
+            notes="",
+        )
+
+        # -----------------------------------------------------------------
+        # RECOMMENDER (Gemini + rule based)
+        # -----------------------------------------------------------------
+        if recommender:
+            out = recommender.recommend(rec, code=code, error=error)
+            rec.update(out)
+
+        # -----------------------------------------------------------------
+        # WRITE TO CSV (SAFE – never crashes runtime)
+        # -----------------------------------------------------------------
+        utils.append_log_row(self.log_path, rec)
+
+        return rec

ecoml-0.1.3/ecoml/ui.py

@@ -0,0 +1,247 @@
+from __future__ import annotations
+from typing import Any, Optional
+from IPython.display import HTML, display
+
+
+# =====================================================================
+#  CSS + JAVASCRIPT (GLOBAL, EXECUTED EVERY RENDER)
+# =====================================================================
+STYLE = """
+<style>
+.ecoml-pill {
+  display:inline-flex; align-items:center; gap:10px;
+  background:#1a1a1a; border:1px solid #2f2f2f;
+  padding:7px 16px; border-radius:24px;
+  font-family:system-ui,-apple-system,BlinkMacSystemFont,"Segoe UI";
+  color:#e9ffe9; font-size:14px; font-weight:600;
+  cursor:pointer; transition:.15s;
+}
+.ecoml-pill:active { transform:scale(.97); opacity:.8; }
+
+.ecoml-icon {
+  width:22px;height:22px;border-radius:50%;
+  display:flex;align-items:center;justify-content:center;
+  font-size:15px;background:#2ecc71;
+}
+.ecoml-warm .ecoml-icon { background:#f1c40f!important; }
+.ecoml-hot  .ecoml-icon { background:#e74c3c!important; }
+
+.ecoml-box {
+  border-radius:14px;
+  background:#101010;
+  border:1px solid #2f2f2f;
+  padding:14px 18px;
+  color:#eaeaea;
+  display:none;
+  font-size:14px;
+}
+
+.ecoml-table {
+  width:100%; border-collapse:collapse;
+  font-size:13px; margin-top:6px;
+}
+.ecoml-table td {
+  padding:5px 4px;
+  border-bottom:1px solid #2a2a2a;
+  text-align:left !important;
+}
+.ecoml-table tr:last-child td { border-bottom:none; }
+.ecoml-table td:first-child { opacity:.65; font-weight:500;}
+
+.eco-header { font-weight:700; margin-bottom:4px; color:#d5ffd5; }
+.eco-suggest {
+  font-size:12px; margin:3px 0; padding-left:7px;
+  border-left:3px solid #3effaa; opacity:.9;
+}
+
+.ecoml-score-wrap { margin-top:10px;font-size:13px; }
+.ecoml-score-bar {
+  width:150px; height:6px;
+  background:#333; border-radius:10px;
+  overflow:hidden; margin-top:4px;
+}
+.ecoml-score-fill {
+  height:100%; width:0%;
+  background:linear-gradient(90deg,#12ff6e,#35ffb0);
+  transition:width .35s;
+}
+
+.eco-compare-row { margin-top:10px; display:flex; justify-content:flex-end; }
+.eco-compare-btn {
+  padding:6px 12px; border-radius:999px;
+  background:#181818; border:1px solid #333;
+  font-size:13px; cursor:pointer; color:#fff;
+}
+.eco-compare-btn:hover { background:#222; }
+</style>
+
+<script>
+if (!window.ecoToggle){
+  window.ecoToggle = function(id, fill, score){
+    let box = document.getElementById(id);
+    let bar = document.getElementById(fill);
+    if (!box) return;
+    if (box.style.display === "block"){
+      box.style.display="none";
+      bar.style.width="0%";
+    } else {
+      box.style.display="block";
+      setTimeout(() => bar.style.width = score + "%", 60);
+    }
+  }
+}
+</script>
+"""
+
+
+# =====================================================================
+def _fmt(x, d=3):
+    try: return f"{float(x):.{d}f}"
+    except: return "-"
+
+
+# =====================================================================
+#  CELL HOOK
+# =====================================================================
+class CellHook:
+    def __init__(self, tracker, recommender: Optional[Any] = None):
+        self.tracker = tracker
+        self.recommender = recommender
+        self.shell = None
+
+    # -----------------------------------------------------------------
+    def register(self):
+        from IPython import get_ipython
+        sh = get_ipython()
+        if not sh:
+            print("⚠ Not inside IPython – UI disabled")
+            return
+        sh.events.register("pre_run_cell", self._pre)
+        sh.events.register("post_run_cell", self._post)
+        print("EcoML UI CellHook Registered ✓")
+
+    # -----------------------------------------------------------------
+    def _pre(self, *_):
+        try: self.tracker.start_cell()
+        except: pass
+
+    # -----------------------------------------------------------------
+    def _post(self, result):
+        code  = getattr(result.info, "raw_cell", None)
+        error = result.error_in_exec if result.error_in_exec else None
+
+        try:
+            rec = self.tracker.end_cell(
+                recommender=self.recommender,
+                error=error,
+                code=code
+            )
+        except Exception as e:
+            display(HTML(f"<div style='color:#ff4444'>EcoML Error: {e}</div>"))
+            return
+
+        if not rec:
+            display(HTML(""))
+            return
+
+        # SAFE FIELDS
+        runtime = float(rec.get("runtime_sec", 0))
+        cpu  = float(rec.get("cpu_util_avg", 0))
+        gpu  = float(rec.get("gpu_util_avg", 0))
+        temp = float(rec.get("gpu_temp_c") or rec.get("cpu_temp_c") or 0)
+        co2  = float(rec.get("co2_g", 0))
+        energy = float(rec.get("energy_kwh", 0))
+
+        rec_hw  = rec.get("recommended_hardware", "Unknown")
+        reasons = rec.get("recommended_reasons", "")
+
+        if isinstance(reasons, list):
+            reasons = " | ".join(reasons)
+
+        cid   = rec.get("cell_id", 0)
+        box1  = f"eco-box-co2-{cid}"
+        box2  = f"eco-box-rec-{cid}"
+        fill1 = f"eco-fill-co2-{cid}"
+        fill2 = f"eco-fill-rec-{cid}"
+
+        score = max(0, min(100, int(100 - runtime*3 - gpu/2 - max(0, temp-60))))
+        cls   = "ecoml-hot" if temp>90 else ("ecoml-warm" if temp>80 else "")
+
+        # ---------------- INSIGHTS BLOCK ----------------
+        insights = ""
+        if reasons:
+            insights += "<div class='eco-header'>💡 Insights</div>"
+            for line in reasons.split(" | "):
+                insights += f"<div class='eco-suggest'>{line}</div>"
+        temp_cpu = float(rec.get("cpu_temp_c", 0))
+        temp_gpu = float(rec.get("gpu_temp_c", 0))
+
+        # ---------------- TABLE 1 ----------------
+        table1 = f"""
+        <table class='ecoml-table'>
+          <tr><td>⏱ Runtime</td><td>{_fmt(runtime)} s</td></tr>
+          <tr><td>⚡ Energy</td><td>{_fmt(energy,6)} kWh</td></tr>
+          <tr><td>🖥 CPU</td><td>{_fmt(cpu,1)}%</td></tr>
+          <tr><td>🎮 GPU</td><td>{_fmt(gpu,1)}%</td></tr>
+          <tr><td>🌡️ Temp</td><td>{_fmt(temp_gpu,1)} °C</td></tr>
+
+        </table>
+        """
+
+        # ---------------- TABLE 2 ----------------
+        table2 = f"""
+        <table class='ecoml-table'>
+          <tr><td>🔧 Recommended</td><td><b>{rec_hw}</b></td></tr>
+          <tr><td>♻ CO₂ (g)</td><td>{_fmt(co2,6)}</td></tr>
+          <tr><td>⏱ Runtime</td><td>{_fmt(runtime)} s</td></tr>
+        </table>
+        """
+
+        # =====================================================================
+        #  🔥 SIDE-BY-SIDE BOX LAYOUT
+        # =====================================================================
+        html = f"""
+        {STYLE}
+
+        <div style="display:flex;gap:14px;align-items:center;margin-top:6px;">
+          <div class="ecoml-pill {cls}" onclick="ecoToggle('{box1}','{fill1}',{score})">
+            <div class="ecoml-icon">🌿</div><b>{_fmt(co2,3)} g CO₂</b>
+          </div>
+
+          <div class="ecoml-pill {cls}" onclick="ecoToggle('{box2}','{fill2}',{score})">
+            <div class="ecoml-icon">⚙️</div><b>{rec_hw}</b>
+          </div>
+
+          <span style="opacity:.6;font-size:12px;">(Click pill)</span>
+        </div>
+
+
+        <!-- ⭐ TWO BOXES SIDE-BY-SIDE ⭐ -->
+        <div style="display:flex; gap:18px; margin-top:10px; align-items:flex-start;">
+
+          <!-- LEFT BOX -->
+          <div class="ecoml-box" id="{box1}" style="width:50%;">
+            {insights}
+            {table1}
+            <div class="ecoml-score-wrap">
+              Eco Score <b>{score}/100</b>
+              <div class="ecoml-score-bar"><div class="ecoml-score-fill" id="{fill1}"></div></div>
+            </div>
+          </div>
+
+          <!-- RIGHT BOX -->
+          <div class="ecoml-box" id="{box2}" style="width:50%;">
+            {table2}
+            <div class="ecoml-score-wrap">
+              Eco Score <b>{score}/100</b>
+              <div class="ecoml-score-bar"><div class="ecoml-score-fill" id="{fill2}"></div></div>
+            </div>
+            <div class="eco-compare-row">
+              <button class="eco-compare-btn">📊 Compare</button>
+            </div>
+          </div>
+
+        </div>
+        """
+
+        display(HTML(html))

ecoml-0.1.3/ecoml/utils.py

@@ -0,0 +1,32 @@
+import os, csv, datetime as dt
+
+LOG_HEADERS = [
+ "timestamp","notebook","cell_id","runtime_sec",
+ "cpu_util_avg","gpu_util_avg","cpu_power_w","gpu_power_w",
+ "energy_kwh","co2_g","hardware_type","hardware_name",
+ "cpu_temp_c","gpu_temp_c","gpu_mem_used_mb","gpu_mem_free_mb",
+ "gpu_mem_total_mb","notes","recommended_hardware","recommended_confidence","recommended_reasons"
+]
+
+# ==================================================
+def now():
+    return dt.datetime.now().isoformat(timespec="seconds")
+
+# ==================================================
+def ensure_log(path):
+    os.makedirs(os.path.dirname(path) or ".", exist_ok=True)
+    if not os.path.exists(path):
+        with open(path, "w", newline="", encoding="utf-8") as f:
+            csv.writer(f).writerow(LOG_HEADERS)
+
+# ==================================================
+def append_log_row(path: str, row: dict):
+    ensure_log(path)
+
+    ordered = [row.get(h, "") for h in LOG_HEADERS]
+
+    try:
+        with open(path, "a", newline="", encoding="utf-8") as f:
+            csv.writer(f).writerow(ordered)
+    except:
+        print("⚠ Failed to write log row – continuing.")

ecoml-0.1.3/ecoml.egg-info/PKG-INFO

@@ -0,0 +1,18 @@
+Metadata-Version: 2.4
+Name: ecoml
+Version: 0.1.3
+Summary: Real-time GPU, CPU, and CO₂ tracking with pill UI for Jupyter notebooks.
+Author-email: Your Name <you@example.com>
+License: MIT
+Project-URL: Homepage, https://github.com/yourname/EcoML
+Project-URL: Source, https://github.com/yourname/EcoML
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: psutil
+Requires-Dist: pynvml
+Requires-Dist: GPUtil
+Requires-Dist: python-dotenv
+Requires-Dist: pandas
+Requires-Dist: ipython
+Provides-Extra: gemini
+Requires-Dist: google-generativeai; extra == "gemini"

ecoml-0.1.3/ecoml.egg-info/SOURCES.txt

@@ -0,0 +1,29 @@
+pyproject.toml
+setup.cfg
+./ecoml/__init__.py
+./ecoml/dashboard.py
+./ecoml/enable.py
+./ecoml/gemini_helper.py
+./ecoml/hardware_monitor.py
+./ecoml/metrics.py
+./ecoml/predictor.py
+./ecoml/recommender.py
+./ecoml/tracker.py
+./ecoml/ui.py
+./ecoml/utils.py
+ecoml/__init__.py
+ecoml/dashboard.py
+ecoml/enable.py
+ecoml/gemini_helper.py
+ecoml/hardware_monitor.py
+ecoml/metrics.py
+ecoml/predictor.py
+ecoml/recommender.py
+ecoml/tracker.py
+ecoml/ui.py
+ecoml/utils.py
+ecoml.egg-info/PKG-INFO
+ecoml.egg-info/SOURCES.txt
+ecoml.egg-info/dependency_links.txt
+ecoml.egg-info/requires.txt
+ecoml.egg-info/top_level.txt

ecoml-0.1.3/ecoml.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

ecoml-0.1.3/ecoml.egg-info/requires.txt

@@ -0,0 +1,9 @@
+psutil
+pynvml
+GPUtil
+python-dotenv
+pandas
+ipython
+
+[gemini]
+google-generativeai

ecoml-0.1.3/ecoml.egg-info/top_level.txt

@@ -0,0 +1 @@
+ecoml

ecoml-0.1.3/pyproject.toml

@@ -0,0 +1,31 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "ecoml"
+version = "0.1.3"
+description = "Real-time GPU, CPU, and CO₂ tracking with pill UI for Jupyter notebooks."
+readme = "README.md"
+requires-python = ">=3.9"
+license = { text = "MIT" }
+authors = [
+  { name = "Your Name", email = "you@example.com" }
+]
+
+dependencies = [
+  "psutil",
+  "pynvml",
+  "GPUtil",
+  "python-dotenv",
+  "pandas",
+  "ipython",
+]
+
+# Optional extra for Gemini
+[project.optional-dependencies]
+gemini = ["google-generativeai"]
+
+[project.urls]
+Homepage = "https://github.com/yourname/EcoML"
+Source = "https://github.com/yourname/EcoML"

ecoml-0.1.3/setup.cfg

@@ -0,0 +1,13 @@
+[options]
+packages = find:
+package_dir = 
+	= .
+include_package_data = True
+
+[options.packages.find]
+where = .
+
+[egg_info]
+tag_build = 
+tag_date = 0
+