greentensor 0.1.0__tar.gz

greentensor-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 GreenTensor
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

greentensor-0.1.0/PKG-INFO

@@ -0,0 +1,143 @@
+Metadata-Version: 2.4
+Name: greentensor
+Version: 0.1.0
+Summary: Energy-efficient middleware for PyTorch ML workloads — tracks carbon, optimizes GPU, reports savings.
+Author: GreenTensor
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/YOUR_USERNAME/greentensor
+Project-URL: Issues, https://github.com/YOUR_USERNAME/greentensor/issues
+Keywords: green ai,carbon,energy,pytorch,sustainability,mlops
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: torch
+Requires-Dist: numpy
+Requires-Dist: codecarbon
+Requires-Dist: psutil
+Requires-Dist: streamlit
+Dynamic: license-file
+
+# GreenTensor
+
+**Energy-efficient middleware for PyTorch ML workloads.**
+
+GreenTensor wraps your training loop with one line of code and gives you:
+- Real carbon emissions and energy tracking (via CodeCarbon)
+- Automatic GPU optimizations (cuDNN benchmark, mixed precision)
+- Idle GPU detection to reduce wasted energy
+- A detailed savings report comparing against your baseline
+
+---
+
+## Install
+
+```bash
+pip install greentensor
+```
+
+---
+
+## Quickstart
+
+```python
+from greentensor import GreenTensor
+
+with GreenTensor() as gt:
+    with gt.mixed_precision():
+        train()  # your existing training code, unchanged
+```
+
+Output:
+```
+  +======================================+
+  |        GreenTensor Report            |
+  +======================================+
+  Runtime          : 12.34 s
+  Energy Used      : 0.000412 kWh
+  CO2 Emissions    : 0.000096 kg
+  ======================================
+```
+
+---
+
+## Compare against a baseline
+
+```python
+import pickle
+from greentensor import GreenTensor
+from greentensor.core.tracker import Tracker
+from greentensor.report.metrics import RunMetrics
+import time
+
+# 1. Run baseline (no optimizations)
+tracker = Tracker()
+tracker.start()
+t0 = time.perf_counter()
+train()
+duration = time.perf_counter() - t0
+emissions_kg, energy_kwh = tracker.stop()
+baseline = RunMetrics(duration_s=duration, energy_kwh=energy_kwh, emissions_kg=emissions_kg)
+
+# 2. Run optimized — report shows real savings
+with GreenTensor(baseline=baseline) as gt:
+    with gt.mixed_precision():
+        train()
+```
+
+---
+
+## Batch size optimizer
+
+```python
+from greentensor import optimize_batch_size
+
+batch_size = optimize_batch_size(32)  # auto-scales based on available GPU memory
+```
+
+---
+
+## Dashboard
+
+```bash
+streamlit run dashboard/app.py
+```
+
+Enter baseline and optimized metrics manually, or upload `.pkl` files saved from your runs.
+
+---
+
+## Configuration
+
+```python
+from greentensor import GreenTensor, Config
+
+config = Config(
+    enable_cudnn_benchmark=True,
+    enable_mixed_precision=True,
+    idle_threshold_pct=10.0,   # GPU util % below which idle is detected
+    max_batch_size=512,
+)
+
+with GreenTensor(config=config) as gt:
+    train()
+```
+
+---
+
+## Run tests
+
+```bash
+pip install pytest
+pytest tests/ -v
+```
+
+---
+
+## License
+
+MIT

greentensor-0.1.0/README.md

@@ -0,0 +1,119 @@
+# GreenTensor
+
+**Energy-efficient middleware for PyTorch ML workloads.**
+
+GreenTensor wraps your training loop with one line of code and gives you:
+- Real carbon emissions and energy tracking (via CodeCarbon)
+- Automatic GPU optimizations (cuDNN benchmark, mixed precision)
+- Idle GPU detection to reduce wasted energy
+- A detailed savings report comparing against your baseline
+
+---
+
+## Install
+
+```bash
+pip install greentensor
+```
+
+---
+
+## Quickstart
+
+```python
+from greentensor import GreenTensor
+
+with GreenTensor() as gt:
+    with gt.mixed_precision():
+        train()  # your existing training code, unchanged
+```
+
+Output:
+```
+  +======================================+
+  |        GreenTensor Report            |
+  +======================================+
+  Runtime          : 12.34 s
+  Energy Used      : 0.000412 kWh
+  CO2 Emissions    : 0.000096 kg
+  ======================================
+```
+
+---
+
+## Compare against a baseline
+
+```python
+import pickle
+from greentensor import GreenTensor
+from greentensor.core.tracker import Tracker
+from greentensor.report.metrics import RunMetrics
+import time
+
+# 1. Run baseline (no optimizations)
+tracker = Tracker()
+tracker.start()
+t0 = time.perf_counter()
+train()
+duration = time.perf_counter() - t0
+emissions_kg, energy_kwh = tracker.stop()
+baseline = RunMetrics(duration_s=duration, energy_kwh=energy_kwh, emissions_kg=emissions_kg)
+
+# 2. Run optimized — report shows real savings
+with GreenTensor(baseline=baseline) as gt:
+    with gt.mixed_precision():
+        train()
+```
+
+---
+
+## Batch size optimizer
+
+```python
+from greentensor import optimize_batch_size
+
+batch_size = optimize_batch_size(32)  # auto-scales based on available GPU memory
+```
+
+---
+
+## Dashboard
+
+```bash
+streamlit run dashboard/app.py
+```
+
+Enter baseline and optimized metrics manually, or upload `.pkl` files saved from your runs.
+
+---
+
+## Configuration
+
+```python
+from greentensor import GreenTensor, Config
+
+config = Config(
+    enable_cudnn_benchmark=True,
+    enable_mixed_precision=True,
+    idle_threshold_pct=10.0,   # GPU util % below which idle is detected
+    max_batch_size=512,
+)
+
+with GreenTensor(config=config) as gt:
+    train()
+```
+
+---
+
+## Run tests
+
+```bash
+pip install pytest
+pytest tests/ -v
+```
+
+---
+
+## License
+
+MIT

greentensor-0.1.0/greentensor/__init__.py

@@ -0,0 +1,9 @@
+"""
+GreenTensor — energy-efficient ML workload middleware.
+"""
+from greentensor.core.context import GreenTensor
+from greentensor.report.metrics import RunMetrics, calculate_savings
+from greentensor.optimizers.batch_optimizer import optimize_batch_size
+from greentensor.utils.config import Config
+
+__all__ = ["GreenTensor", "RunMetrics", "calculate_savings", "optimize_batch_size", "Config"]

greentensor-0.1.0/greentensor/core/context.py

@@ -0,0 +1,64 @@
+import time
+import functools
+from greentensor.core.tracker import Tracker
+from greentensor.optimizers.gpu_optimizer import GPUOptimizer
+from greentensor.optimizers.idle_optimizer import IdleOptimizer
+from greentensor.report.report import generate_report
+from greentensor.report.metrics import RunMetrics
+from greentensor.utils.config import Config
+from greentensor.utils.logger import logger
+
+
+class GreenTensor:
+    def __init__(self, config=None, baseline=None, verbose=True):
+        self.config = config or Config()
+        self.baseline = baseline
+        self.verbose = verbose
+        self.tracker = Tracker(self.config)
+        self.gpu_optimizer = GPUOptimizer(self.config)
+        self.idle_optimizer = IdleOptimizer(self.config)
+        self.metrics = None
+
+    def __enter__(self):
+        logger.info("GreenTensor session starting...")
+        self.gpu_optimizer.apply()
+        self.idle_optimizer.apply()
+        self.tracker.start()
+        self._start = time.perf_counter()
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        duration = time.perf_counter() - self._start
+        emissions_kg, energy_kwh = self.tracker.stop()
+        self.idle_optimizer.revert()
+        self.gpu_optimizer.revert()
+
+        self.metrics = RunMetrics(
+            duration_s=duration,
+            energy_kwh=energy_kwh,
+            emissions_kg=emissions_kg,
+            idle_seconds=self.idle_optimizer.idle_seconds,
+        )
+
+        if self.verbose:
+            report = generate_report(
+                duration=duration,
+                emissions_kg=emissions_kg,
+                energy_kwh=energy_kwh,
+                idle_seconds=self.idle_optimizer.idle_seconds,
+                baseline=self.baseline,
+            )
+            print(report)
+
+        return False
+
+    def mixed_precision(self):
+        return self.gpu_optimizer.mixed_precision()
+
+    @staticmethod
+    def profile(func):
+        @functools.wraps(func)
+        def wrapper(*args, **kwargs):
+            with GreenTensor():
+                return func(*args, **kwargs)
+        return wrapper

greentensor-0.1.0/greentensor/core/profiler.py

@@ -0,0 +1,60 @@
+import subprocess
+import platform
+import time
+import functools
+from greentensor.utils.logger import logger
+
+class Profiler:
+
+    @staticmethod
+    def get_gpu_metrics() -> dict:
+        """
+        Query live GPU utilization (%) and power draw (W) via nvidia-smi.
+        Returns zeros gracefully when no GPU / nvidia-smi is unavailable.
+        """
+        try:
+            result = subprocess.run(
+                [
+                    "nvidia-smi",
+                    "--query-gpu=utilization.gpu,power.draw",
+                    "--format=csv,noheader,nounits",
+                ],
+                capture_output=True,
+                text=True,
+                timeout=5,
+            )
+            line = result.stdout.strip()
+            if line:
+                parts = line.split(", ")
+                util = float(parts[0])
+                power = float(parts[1])
+                return {"util_%": util, "power_W": power}
+        except FileNotFoundError:
+            pass  # nvidia-smi not installed
+        except Exception as e:
+            logger.debug(f"nvidia-smi query failed: {e}")
+        return {"util_%": 0.0, "power_W": 0.0}
+
+    @staticmethod
+    def track_gpu(func):
+        """Decorator that captures GPU metrics before and after a function call."""
+        @functools.wraps(func)
+        def wrapper(*args, **kwargs):
+            start = Profiler.get_gpu_metrics()
+            t0 = time.perf_counter()
+            result = func(*args, **kwargs)
+            elapsed = time.perf_counter() - t0
+            end = Profiler.get_gpu_metrics()
+            profile = {
+                "duration_s": elapsed,
+                "gpu_start": start,
+                "gpu_end": end,
+                "avg_power_W": (start["power_W"] + end["power_W"]) / 2,
+            }
+            return result, profile
+        return wrapper
+
+    @staticmethod
+    def estimate_energy_kwh(power_w: float, duration_s: float) -> float:
+        """Convert average power (W) and duration (s) to energy in kWh."""
+        return (power_w * duration_s) / 3_600_000

greentensor-0.1.0/greentensor/core/tracker.py

@@ -0,0 +1,102 @@
+import time
+from greentensor.utils.config import Config
+from greentensor.utils.logger import logger
+
+class Tracker:
+    """
+    Tracks energy and carbon emissions for a workload.
+    Uses CodeCarbon when available; falls back to nvidia-smi power sampling.
+    """
+
+    def __init__(self, config: Config = None):
+        self.config = config or Config()
+        self._codecarbon = None
+        self._start_time = None
+        self._power_samples: list[float] = []
+        self._sampling = False
+        self._sample_thread = None
+
+    # ------------------------------------------------------------------ #
+    #  Public API                                                          #
+    # ------------------------------------------------------------------ #
+
+    def start(self):
+        self._start_time = time.perf_counter()
+        if self._try_start_codecarbon():
+            logger.info("Tracking emissions via CodeCarbon.")
+        else:
+            logger.info("CodeCarbon unavailable — falling back to nvidia-smi power sampling.")
+            self._start_power_sampling()
+
+    def stop(self) -> tuple[float, float]:
+        """
+        Returns (emissions_kg_co2, energy_kwh).
+        """
+        duration = time.perf_counter() - self._start_time
+
+        if self._codecarbon:
+            return self._stop_codecarbon()
+
+        return self._stop_power_sampling(duration)
+
+    # ------------------------------------------------------------------ #
+    #  CodeCarbon path                                                     #
+    # ------------------------------------------------------------------ #
+
+    def _try_start_codecarbon(self) -> bool:
+        try:
+            from codecarbon import EmissionsTracker
+            self._codecarbon = EmissionsTracker(
+                log_level="error",
+                save_to_file=False,
+                save_to_api=False,
+            )
+            self._codecarbon.start()
+            return True
+        except Exception as e:
+            logger.debug(f"CodeCarbon init failed: {e}")
+            self._codecarbon = None
+            return False
+
+    def _stop_codecarbon(self) -> tuple[float, float]:
+        emissions_kg = self._codecarbon.stop() or 0.0
+        # CodeCarbon exposes energy via its internal tracker
+        try:
+            energy_kwh = self._codecarbon._total_energy.kWh
+        except Exception:
+            # fallback: derive from emissions using config intensity
+            energy_kwh = emissions_kg / self.config.carbon_intensity_kg_per_kwh
+        return emissions_kg, energy_kwh
+
+    # ------------------------------------------------------------------ #
+    #  Power-sampling fallback                                             #
+    # ------------------------------------------------------------------ #
+
+    def _start_power_sampling(self):
+        import threading
+        self._sampling = True
+        self._power_samples = []
+
+        def _sample():
+            from greentensor.core.profiler import Profiler
+            while self._sampling:
+                m = Profiler.get_gpu_metrics()
+                self._power_samples.append(m["power_W"])
+                time.sleep(0.5)
+
+        self._sample_thread = threading.Thread(target=_sample, daemon=True)
+        self._sample_thread.start()
+
+    def _stop_power_sampling(self, duration_s: float) -> tuple[float, float]:
+        self._sampling = False
+        if self._sample_thread:
+            self._sample_thread.join(timeout=2)
+
+        if self._power_samples:
+            avg_power_w = sum(self._power_samples) / len(self._power_samples)
+        else:
+            avg_power_w = 0.0
+
+        energy_kwh = (avg_power_w * duration_s) / 3_600_000
+        emissions_kg = energy_kwh * self.config.carbon_intensity_kg_per_kwh
+        return emissions_kg, energy_kwh

greentensor-0.1.0/greentensor/optimizers/base.py

@@ -0,0 +1,19 @@
+from abc import ABC, abstractmethod
+
+class BaseOptimizer(ABC):
+    """All optimizers must implement apply() and revert()."""
+
+    @abstractmethod
+    def apply(self):
+        """Apply the optimization."""
+
+    @abstractmethod
+    def revert(self):
+        """Revert the optimization to its original state."""
+
+    def __enter__(self):
+        self.apply()
+        return self
+
+    def __exit__(self, *args):
+        self.revert()

greentensor-0.1.0/greentensor/optimizers/batch_optimizer.py

@@ -0,0 +1,45 @@
+from .base import BaseOptimizer
+from greentensor.utils.config import Config
+from greentensor.utils.logger import logger
+
+class BatchOptimizer(BaseOptimizer):
+    """Suggests an optimal batch size based on GPU memory availability."""
+
+    def __init__(self, current_batch: int, config: Config = None):
+        self.config = config or Config()
+        self.original_batch = current_batch
+        self.optimal_batch = current_batch
+
+    def apply(self):
+        self.optimal_batch = self._compute_optimal(self.original_batch)
+        if self.optimal_batch != self.original_batch:
+            logger.info(f"Batch size optimized: {self.original_batch} → {self.optimal_batch}")
+        return self.optimal_batch
+
+    def revert(self):
+        self.optimal_batch = self.original_batch
+
+    def _compute_optimal(self, batch: int) -> int:
+        import torch
+        if torch.cuda.is_available():
+            free_mem, total_mem = torch.cuda.mem_get_info()
+            free_gb = free_mem / (1024 ** 3)
+            # scale batch size proportionally to free memory, capped by config
+            if free_gb > 4:
+                candidate = min(batch * 4, self.config.max_batch_size)
+            elif free_gb > 2:
+                candidate = min(batch * 2, self.config.max_batch_size)
+            else:
+                candidate = max(batch, self.config.min_batch_size)
+            return candidate
+        # CPU: just double if below min threshold
+        if batch < self.config.min_batch_size:
+            return self.config.min_batch_size
+        if batch < 64:
+            return min(batch * 2, self.config.max_batch_size)
+        return batch
+
+
+def optimize_batch_size(current_batch: int, config: Config = None) -> int:
+    """Convenience function — returns the recommended batch size."""
+    return BatchOptimizer(current_batch, config).apply()

greentensor-0.1.0/greentensor/optimizers/gpu_optimizer.py

@@ -0,0 +1,38 @@
+import torch
+from .base import BaseOptimizer
+from greentensor.utils.logger import logger
+from greentensor.utils.config import Config
+
+class GPUOptimizer(BaseOptimizer):
+    def __init__(self, config: Config = None):
+        self.config = config or Config()
+        self._prev_cudnn_benchmark = None
+        self._prev_cudnn_enabled = None
+
+    def apply(self):
+        if not torch.cuda.is_available():
+            logger.warning("No CUDA GPU detected — GPU optimizations skipped.")
+            return
+
+        if self.config.enable_cudnn_benchmark:
+            self._prev_cudnn_benchmark = torch.backends.cudnn.benchmark
+            self._prev_cudnn_enabled = torch.backends.cudnn.enabled
+            torch.backends.cudnn.benchmark = True
+            torch.backends.cudnn.enabled = True
+            logger.info("cuDNN benchmark mode enabled.")
+
+    def revert(self):
+        if not torch.cuda.is_available():
+            return
+        if self._prev_cudnn_benchmark is not None:
+            torch.backends.cudnn.benchmark = self._prev_cudnn_benchmark
+            torch.backends.cudnn.enabled = self._prev_cudnn_enabled
+            logger.info("cuDNN settings restored.")
+
+    def mixed_precision(self):
+        """Returns an autocast context for mixed precision training."""
+        if torch.cuda.is_available() and self.config.enable_mixed_precision:
+            return torch.cuda.amp.autocast()
+        # no-op context on CPU
+        import contextlib
+        return contextlib.nullcontext()

greentensor-0.1.0/greentensor/optimizers/idle_optimizer.py

@@ -0,0 +1,42 @@
+import time
+import threading
+from .base import BaseOptimizer
+from greentensor.utils.config import Config
+from greentensor.utils.logger import logger
+
+class IdleOptimizer(BaseOptimizer):
+    """
+    Monitors GPU utilization in a background thread.
+    When the GPU is idle (below threshold), it throttles the process
+    to reduce wasted energy during idle periods.
+    """
+
+    def __init__(self, config: Config = None):
+        self.config = config or Config()
+        self._stop_event = threading.Event()
+        self._thread = None
+        self.idle_seconds = 0.0
+        self._lock = threading.Lock()
+
+    def apply(self):
+        self._stop_event.clear()
+        self._thread = threading.Thread(target=self._monitor, daemon=True)
+        self._thread.start()
+        logger.info("Idle optimizer started.")
+
+    def revert(self):
+        self._stop_event.set()
+        if self._thread:
+            self._thread.join(timeout=2)
+        logger.info(f"Idle optimizer stopped. Total idle time: {self.idle_seconds:.2f}s")
+
+    def _monitor(self):
+        from greentensor.core.profiler import Profiler
+        while not self._stop_event.is_set():
+            metrics = Profiler.get_gpu_metrics()
+            if metrics["util_%"] < self.config.idle_threshold_pct:
+                time.sleep(self.config.idle_sleep_s)
+                with self._lock:
+                    self.idle_seconds += self.config.idle_sleep_s
+            else:
+                time.sleep(0.1)

greentensor-0.1.0/greentensor/report/metrics.py

@@ -0,0 +1,22 @@
+from dataclasses import dataclass
+
+@dataclass
+class RunMetrics:
+    duration_s: float
+    energy_kwh: float
+    emissions_kg: float
+    idle_seconds: float = 0.0
+
+def calculate_savings(baseline: RunMetrics, optimized: RunMetrics) -> dict:
+    """Compare two real RunMetrics objects and return absolute + relative savings."""
+    energy_saved = baseline.energy_kwh - optimized.energy_kwh
+    emissions_saved = baseline.emissions_kg - optimized.emissions_kg
+    energy_reduction_pct = (energy_saved / baseline.energy_kwh * 100) if baseline.energy_kwh else 0.0
+    time_saved = baseline.duration_s - optimized.duration_s
+
+    return {
+        "energy_saved_kwh": energy_saved,
+        "emissions_saved_kg": emissions_saved,
+        "energy_reduction_pct": energy_reduction_pct,
+        "time_saved_s": time_saved,
+    }

greentensor-0.1.0/greentensor/report/report.py

@@ -0,0 +1,39 @@
+# -*- coding: utf-8 -*-
+from greentensor.report.metrics import RunMetrics
+
+def generate_report(duration, emissions_kg, energy_kwh,
+                    idle_seconds=0.0, baseline=None):
+    """
+    Generate a human-readable GreenTensor report.
+    If a baseline RunMetrics is provided, savings are computed against real data.
+    """
+    lines = [
+        "",
+        "  +======================================+",
+        "  |        GreenTensor Report            |",
+        "  +======================================+",
+        "  Runtime          : {:.2f} s".format(duration),
+        "  Energy Used      : {:.6f} kWh".format(energy_kwh),
+        "  CO2 Emissions    : {:.6f} kg".format(emissions_kg),
+    ]
+
+    if idle_seconds > 0:
+        lines.append("  Idle Time        : {:.2f} s".format(idle_seconds))
+
+    if baseline:
+        energy_saved = baseline.energy_kwh - energy_kwh
+        emissions_saved = baseline.emissions_kg - emissions_kg
+        reduction_pct = (energy_saved / baseline.energy_kwh * 100) if baseline.energy_kwh else 0.0
+        time_saved = baseline.duration_s - duration
+
+        lines += [
+            "",
+            "  -- Savings vs Baseline --",
+            "  Baseline Energy  : {:.6f} kWh".format(baseline.energy_kwh),
+            "  Energy Saved     : {:.6f} kWh  ({:.1f}% reduction)".format(energy_saved, reduction_pct),
+            "  Emissions Saved  : {:.6f} kg CO2".format(emissions_saved),
+            "  Time Saved       : {:.2f} s".format(time_saved),
+        ]
+
+    lines.append("  ======================================\n")
+    return "\n".join(lines)

greentensor-0.1.0/greentensor/utils/config.py

@@ -0,0 +1,18 @@
+from dataclasses import dataclass, field
+
+@dataclass
+class Config:
+    # Batch optimization
+    min_batch_size: int = 32
+    max_batch_size: int = 512
+
+    # GPU
+    enable_cudnn_benchmark: bool = True
+    enable_mixed_precision: bool = True
+
+    # Idle detection
+    idle_threshold_pct: float = 10.0   # GPU util % below which we consider it idle
+    idle_sleep_s: float = 0.5          # seconds to sleep when idle detected
+
+    # Reporting
+    carbon_intensity_kg_per_kwh: float = 0.000233  # world avg kg CO2 per Wh → per kWh = 0.233 kg

greentensor-0.1.0/greentensor/utils/logger.py

@@ -0,0 +1,13 @@
+import logging
+import sys
+
+def get_logger(name: str = "greentensor") -> logging.Logger:
+    logger = logging.getLogger(name)
+    if not logger.handlers:
+        handler = logging.StreamHandler(sys.stdout)
+        handler.setFormatter(logging.Formatter("[%(asctime)s] %(levelname)s %(name)s: %(message)s", "%H:%M:%S"))
+        logger.addHandler(handler)
+    logger.setLevel(logging.INFO)
+    return logger
+
+logger = get_logger()

greentensor-0.1.0/greentensor.egg-info/PKG-INFO

@@ -0,0 +1,143 @@
+Metadata-Version: 2.4
+Name: greentensor
+Version: 0.1.0
+Summary: Energy-efficient middleware for PyTorch ML workloads — tracks carbon, optimizes GPU, reports savings.
+Author: GreenTensor
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/YOUR_USERNAME/greentensor
+Project-URL: Issues, https://github.com/YOUR_USERNAME/greentensor/issues
+Keywords: green ai,carbon,energy,pytorch,sustainability,mlops
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: torch
+Requires-Dist: numpy
+Requires-Dist: codecarbon
+Requires-Dist: psutil
+Requires-Dist: streamlit
+Dynamic: license-file
+
+# GreenTensor
+
+**Energy-efficient middleware for PyTorch ML workloads.**
+
+GreenTensor wraps your training loop with one line of code and gives you:
+- Real carbon emissions and energy tracking (via CodeCarbon)
+- Automatic GPU optimizations (cuDNN benchmark, mixed precision)
+- Idle GPU detection to reduce wasted energy
+- A detailed savings report comparing against your baseline
+
+---
+
+## Install
+
+```bash
+pip install greentensor
+```
+
+---
+
+## Quickstart
+
+```python
+from greentensor import GreenTensor
+
+with GreenTensor() as gt:
+    with gt.mixed_precision():
+        train()  # your existing training code, unchanged
+```
+
+Output:
+```
+  +======================================+
+  |        GreenTensor Report            |
+  +======================================+
+  Runtime          : 12.34 s
+  Energy Used      : 0.000412 kWh
+  CO2 Emissions    : 0.000096 kg
+  ======================================
+```
+
+---
+
+## Compare against a baseline
+
+```python
+import pickle
+from greentensor import GreenTensor
+from greentensor.core.tracker import Tracker
+from greentensor.report.metrics import RunMetrics
+import time
+
+# 1. Run baseline (no optimizations)
+tracker = Tracker()
+tracker.start()
+t0 = time.perf_counter()
+train()
+duration = time.perf_counter() - t0
+emissions_kg, energy_kwh = tracker.stop()
+baseline = RunMetrics(duration_s=duration, energy_kwh=energy_kwh, emissions_kg=emissions_kg)
+
+# 2. Run optimized — report shows real savings
+with GreenTensor(baseline=baseline) as gt:
+    with gt.mixed_precision():
+        train()
+```
+
+---
+
+## Batch size optimizer
+
+```python
+from greentensor import optimize_batch_size
+
+batch_size = optimize_batch_size(32)  # auto-scales based on available GPU memory
+```
+
+---
+
+## Dashboard
+
+```bash
+streamlit run dashboard/app.py
+```
+
+Enter baseline and optimized metrics manually, or upload `.pkl` files saved from your runs.
+
+---
+
+## Configuration
+
+```python
+from greentensor import GreenTensor, Config
+
+config = Config(
+    enable_cudnn_benchmark=True,
+    enable_mixed_precision=True,
+    idle_threshold_pct=10.0,   # GPU util % below which idle is detected
+    max_batch_size=512,
+)
+
+with GreenTensor(config=config) as gt:
+    train()
+```
+
+---
+
+## Run tests
+
+```bash
+pip install pytest
+pytest tests/ -v
+```
+
+---
+
+## License
+
+MIT

greentensor-0.1.0/greentensor.egg-info/SOURCES.txt

@@ -0,0 +1,26 @@
+LICENSE
+README.md
+pyproject.toml
+greentensor/__init__.py
+greentensor.egg-info/PKG-INFO
+greentensor.egg-info/SOURCES.txt
+greentensor.egg-info/dependency_links.txt
+greentensor.egg-info/requires.txt
+greentensor.egg-info/top_level.txt
+greentensor/core/context.py
+greentensor/core/profiler.py
+greentensor/core/tracker.py
+greentensor/optimizers/base.py
+greentensor/optimizers/batch_optimizer.py
+greentensor/optimizers/gpu_optimizer.py
+greentensor/optimizers/idle_optimizer.py
+greentensor/report/metrics.py
+greentensor/report/report.py
+greentensor/utils/config.py
+greentensor/utils/logger.py
+tests/test_batch_optimizer.py
+tests/test_config.py
+tests/test_context.py
+tests/test_metrics.py
+tests/test_profiler.py
+tests/test_report.py

greentensor-0.1.0/greentensor.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

greentensor-0.1.0/greentensor.egg-info/requires.txt

@@ -0,0 +1,5 @@
+torch
+numpy
+codecarbon
+psutil
+streamlit

greentensor-0.1.0/greentensor.egg-info/top_level.txt

@@ -0,0 +1 @@
+greentensor

greentensor-0.1.0/pyproject.toml

@@ -0,0 +1,30 @@
+[build-system]
+requires = ["setuptools>=42", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "greentensor"
+version = "0.1.0"
+description = "Energy-efficient middleware for PyTorch ML workloads — tracks carbon, optimizes GPU, reports savings."
+readme = "README.md"
+license = "MIT"
+authors = [{ name = "GreenTensor" }]
+keywords = ["green ai", "carbon", "energy", "pytorch", "sustainability", "mlops"]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+    "Intended Audience :: Developers",
+    "Intended Audience :: Science/Research",
+]
+requires-python = ">=3.9"
+dependencies = ["torch", "numpy", "codecarbon", "psutil", "streamlit"]
+
+[project.urls]
+Homepage = "https://github.com/YOUR_USERNAME/greentensor"
+Issues = "https://github.com/YOUR_USERNAME/greentensor/issues"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["greentensor*"]
+exclude = ["tests*"]

greentensor-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

greentensor-0.1.0/tests/test_batch_optimizer.py

@@ -0,0 +1,30 @@
+from unittest.mock import patch
+from greentensor.optimizers.batch_optimizer import BatchOptimizer, optimize_batch_size
+from greentensor.utils.config import Config
+
+def test_optimize_batch_cpu():
+    # On CPU path: batch < min_batch_size → bumped to min
+    config = Config(min_batch_size=32, max_batch_size=512)
+    with patch("torch.cuda.is_available", return_value=False):
+        result = optimize_batch_size(16, config)
+    assert result == 32
+
+def test_optimize_batch_cpu_doubles():
+    config = Config(min_batch_size=32, max_batch_size=512)
+    with patch("torch.cuda.is_available", return_value=False):
+        result = optimize_batch_size(32, config)
+    assert result == 64
+
+def test_optimize_batch_respects_max():
+    config = Config(min_batch_size=32, max_batch_size=64)
+    with patch("torch.cuda.is_available", return_value=False):
+        result = optimize_batch_size(64, config)
+    assert result == 64
+
+def test_batch_optimizer_revert():
+    config = Config(min_batch_size=32, max_batch_size=512)
+    with patch("torch.cuda.is_available", return_value=False):
+        opt = BatchOptimizer(32, config)
+        opt.apply()
+        opt.revert()
+    assert opt.optimal_batch == 32

greentensor-0.1.0/tests/test_config.py

@@ -0,0 +1,15 @@
+from greentensor.utils.config import Config
+
+def test_defaults():
+    c = Config()
+    assert c.min_batch_size == 32
+    assert c.max_batch_size == 512
+    assert c.enable_cudnn_benchmark is True
+    assert c.enable_mixed_precision is True
+    assert c.idle_threshold_pct == 10.0
+    assert c.carbon_intensity_kg_per_kwh == 0.000233
+
+def test_custom():
+    c = Config(min_batch_size=16, max_batch_size=256)
+    assert c.min_batch_size == 16
+    assert c.max_batch_size == 256

greentensor-0.1.0/tests/test_context.py

@@ -0,0 +1,52 @@
+import time
+from unittest.mock import patch, MagicMock
+from greentensor.core.context import GreenTensor
+from greentensor.report.metrics import RunMetrics
+
+def _mock_tracker():
+    t = MagicMock()
+    t.start.return_value = None
+    t.stop.return_value = (0.00001, 0.00005)  # (emissions_kg, energy_kwh)
+    return t
+
+def test_context_manager_runs():
+    with patch("greentensor.core.context.Tracker", return_value=_mock_tracker()), \
+         patch("greentensor.core.context.GPUOptimizer") as mock_gpu, \
+         patch("greentensor.core.context.IdleOptimizer") as mock_idle:
+
+        mock_idle.return_value.idle_seconds = 0.0
+        with GreenTensor(verbose=False) as gt:
+            time.sleep(0.01)
+
+        assert gt.metrics is not None
+        assert gt.metrics.duration_s > 0
+        assert gt.metrics.energy_kwh == 0.00005
+        assert gt.metrics.emissions_kg == 0.00001
+
+def test_context_manager_does_not_suppress_exceptions():
+    with patch("greentensor.core.context.Tracker", return_value=_mock_tracker()), \
+         patch("greentensor.core.context.GPUOptimizer"), \
+         patch("greentensor.core.context.IdleOptimizer") as mock_idle:
+
+        mock_idle.return_value.idle_seconds = 0.0
+        try:
+            with GreenTensor(verbose=False):
+                raise ValueError("test error")
+        except ValueError as e:
+            assert str(e) == "test error"
+        else:
+            assert False, "Exception should not have been suppressed"
+
+def test_profile_decorator():
+    with patch("greentensor.core.context.Tracker", return_value=_mock_tracker()), \
+         patch("greentensor.core.context.GPUOptimizer"), \
+         patch("greentensor.core.context.IdleOptimizer") as mock_idle:
+
+        mock_idle.return_value.idle_seconds = 0.0
+
+        @GreenTensor.profile
+        def my_func():
+            return 99
+
+        result = my_func()
+        assert result == 99

greentensor-0.1.0/tests/test_metrics.py

@@ -0,0 +1,21 @@
+from greentensor.report.metrics import RunMetrics, calculate_savings
+
+def test_calculate_savings_basic():
+    baseline = RunMetrics(duration_s=10.0, energy_kwh=0.002, emissions_kg=0.001)
+    optimized = RunMetrics(duration_s=7.0, energy_kwh=0.0012, emissions_kg=0.0006)
+    s = calculate_savings(baseline, optimized)
+
+    assert abs(s["energy_saved_kwh"] - 0.0008) < 1e-9
+    assert abs(s["emissions_saved_kg"] - 0.0004) < 1e-9
+    assert abs(s["energy_reduction_pct"] - 40.0) < 1e-6
+    assert abs(s["time_saved_s"] - 3.0) < 1e-9
+
+def test_calculate_savings_zero_baseline():
+    baseline = RunMetrics(duration_s=0.0, energy_kwh=0.0, emissions_kg=0.0)
+    optimized = RunMetrics(duration_s=1.0, energy_kwh=0.001, emissions_kg=0.0)
+    s = calculate_savings(baseline, optimized)
+    assert s["energy_reduction_pct"] == 0.0  # no div-by-zero
+
+def test_runmetrics_defaults():
+    m = RunMetrics(duration_s=5.0, energy_kwh=0.001, emissions_kg=0.0002)
+    assert m.idle_seconds == 0.0

greentensor-0.1.0/tests/test_profiler.py

@@ -0,0 +1,32 @@
+from unittest.mock import patch
+from greentensor.core.profiler import Profiler
+
+def test_get_gpu_metrics_no_nvidia_smi():
+    # When nvidia-smi is not available, should return zeros gracefully
+    with patch("subprocess.run", side_effect=FileNotFoundError):
+        m = Profiler.get_gpu_metrics()
+    assert m == {"util_%": 0.0, "power_W": 0.0}
+
+def test_get_gpu_metrics_parses_output():
+    mock = type("R", (), {"stdout": "45, 120.5\n", "returncode": 0})()
+    with patch("subprocess.run", return_value=mock):
+        m = Profiler.get_gpu_metrics()
+    assert m["util_%"] == 45.0
+    assert m["power_W"] == 120.5
+
+def test_estimate_energy_kwh():
+    # 100W for 3600s = 0.1 kWh
+    kwh = Profiler.estimate_energy_kwh(100.0, 3600.0)
+    assert abs(kwh - 0.1) < 1e-9
+
+def test_track_gpu_decorator():
+    @Profiler.track_gpu
+    def dummy():
+        return 42
+
+    with patch.object(Profiler, "get_gpu_metrics", return_value={"util_%": 0.0, "power_W": 0.0}):
+        result, profile = dummy()
+
+    assert result == 42
+    assert "duration_s" in profile
+    assert "avg_power_W" in profile

greentensor-0.1.0/tests/test_report.py

@@ -0,0 +1,19 @@
+from greentensor.report.report import generate_report
+from greentensor.report.metrics import RunMetrics
+
+def test_report_no_baseline():
+    r = generate_report(5.0, 0.0003, 0.0013)
+    assert "5.00 s" in r
+    assert "0.001300 kWh" in r
+    assert "0.000300 kg" in r
+    assert "Savings" not in r
+
+def test_report_with_baseline():
+    baseline = RunMetrics(duration_s=10.0, energy_kwh=0.002, emissions_kg=0.001)
+    r = generate_report(7.0, 0.0006, 0.0013, baseline=baseline)
+    assert "Savings vs Baseline" in r
+    assert "reduction" in r
+
+def test_report_with_idle():
+    r = generate_report(5.0, 0.0003, 0.0013, idle_seconds=2.5)
+    assert "2.50 s" in r