greenmining 1.1.9__py3-none-any.whl → 1.2.0__py3-none-any.whl

greenmining/analyzers/version_power_analyzer.py

@@ -1,246 +0,0 @@
-# Version-by-version power analysis.
-# Measure power consumption across multiple software versions/tags.
-
-from __future__ import annotations
-
-import subprocess
-from dataclasses import dataclass, field
-from typing import Any, Dict, List, Optional
-
-from greenmining.utils import colored_print
-
-
-@dataclass
-class VersionPowerProfile:
-    # Power profile for a single version.
-
-    version: str
-    commit_sha: str
-    energy_joules: float = 0.0
-    power_watts_avg: float = 0.0
-    duration_seconds: float = 0.0
-    iterations: int = 0
-    energy_std: float = 0.0  # Standard deviation across iterations
-
-    def to_dict(self) -> Dict[str, Any]:
-        return {
-            "version": self.version,
-            "commit_sha": self.commit_sha,
-            "energy_joules": round(self.energy_joules, 4),
-            "power_watts_avg": round(self.power_watts_avg, 4),
-            "duration_seconds": round(self.duration_seconds, 4),
-            "iterations": self.iterations,
-            "energy_std": round(self.energy_std, 4),
-        }
-
-
-@dataclass
-class VersionPowerReport:
-    # Complete power analysis report across versions.
-
-    versions: List[VersionPowerProfile] = field(default_factory=list)
-    trend: str = "stable"  # increasing, decreasing, stable
-    total_change_percent: float = 0.0
-    most_efficient: str = ""
-    least_efficient: str = ""
-
-    def to_dict(self) -> Dict[str, Any]:
-        return {
-            "versions": [v.to_dict() for v in self.versions],
-            "trend": self.trend,
-            "total_change_percent": round(self.total_change_percent, 2),
-            "most_efficient": self.most_efficient,
-            "least_efficient": self.least_efficient,
-        }
-
-    def summary(self) -> str:
-        # Generate human-readable summary.
-        lines = [
-            "Version Power Analysis Report",
-            "-" * 40,
-            f"Versions analyzed: {len(self.versions)}",
-            f"Trend: {self.trend}",
-            f"Total change: {self.total_change_percent:+.2f}%",
-            f"Most efficient: {self.most_efficient}",
-            f"Least efficient: {self.least_efficient}",
-            "",
-            "Per-version breakdown:",
-        ]
-        for v in self.versions:
-            lines.append(
-                f"  {v.version}: {v.energy_joules:.4f}J "
-                f"({v.power_watts_avg:.2f}W avg, {v.duration_seconds:.2f}s)"
-            )
-        return "\n".join(lines)
-
-
-class VersionPowerAnalyzer:
-    # Measure and compare power consumption across software versions.
-
-    def __init__(
-        self,
-        test_command: str = "pytest tests/",
-        energy_backend: str = "rapl",
-        iterations: int = 10,
-        warmup_iterations: int = 2,
-    ):
-        # Initialize version power analyzer.
-        # Args:
-        #   test_command: Shell command to run for measurement
-        #   energy_backend: Energy measurement backend
-        #   iterations: Number of measurement iterations per version
-        #   warmup_iterations: Warmup runs before measuring
-        self.test_command = test_command
-        self.energy_backend = energy_backend
-        self.iterations = iterations
-        self.warmup_iterations = warmup_iterations
-        self._meter = None
-
-    def _get_energy_meter(self):
-        # Get energy meter instance.
-        if self._meter is None:
-            from greenmining.energy.base import get_energy_meter
-
-            self._meter = get_energy_meter(self.energy_backend)
-        return self._meter
-
-    def _measure_version(self, repo_path: str, version: str) -> VersionPowerProfile:
-        # Measure power consumption for a specific version.
-        meter = self._get_energy_meter()
-
-        # Checkout version
-        sha = self._checkout_version(repo_path, version)
-        colored_print(f"  Measuring {version} ({sha[:8]})...", "cyan")
-
-        # Warmup
-        for i in range(self.warmup_iterations):
-            subprocess.run(
-                self.test_command,
-                shell=True,
-                cwd=repo_path,
-                capture_output=True,
-                text=True,
-                timeout=600,
-            )
-
-        # Measure iterations
-        measurements = []
-        for i in range(self.iterations):
-            meter.start()
-            subprocess.run(
-                self.test_command,
-                shell=True,
-                cwd=repo_path,
-                capture_output=True,
-                text=True,
-                timeout=600,
-            )
-            metrics = meter.stop()
-            measurements.append(metrics)
-
-        # Aggregate
-        import numpy as np
-
-        energies = [m.joules for m in measurements]
-        avg_energy = float(np.mean(energies))
-        std_energy = float(np.std(energies))
-        avg_power = float(np.mean([m.watts_avg for m in measurements]))
-        avg_duration = float(np.mean([m.duration_seconds for m in measurements]))
-
-        profile = VersionPowerProfile(
-            version=version,
-            commit_sha=sha,
-            energy_joules=avg_energy,
-            power_watts_avg=avg_power,
-            duration_seconds=avg_duration,
-            iterations=self.iterations,
-            energy_std=std_energy,
-        )
-
-        colored_print(
-            f"  {version}: {avg_energy:.4f}J +/-{std_energy:.4f} "
-            f"({avg_power:.2f}W, {avg_duration:.2f}s)",
-            "green",
-        )
-        return profile
-
-    def analyze_versions(
-        self,
-        repo_path: str,
-        versions: List[str],
-    ) -> VersionPowerReport:
-        # Analyze power consumption across multiple versions.
-        # Args:
-        #   repo_path: Path to local git repository
-        #   versions: List of version tags or commit references
-        colored_print(f"\nAnalyzing {len(versions)} versions for power consumption", "cyan")
-        colored_print(f"  Test: {self.test_command}", "cyan")
-        colored_print(f"  Iterations: {self.iterations} (+{self.warmup_iterations} warmup)", "cyan")
-
-        profiles = []
-        for version in versions:
-            try:
-                profile = self._measure_version(repo_path, version)
-                profiles.append(profile)
-            except Exception as e:
-                colored_print(f"  Error measuring {version}: {e}", "red")
-
-        if not profiles:
-            return VersionPowerReport()
-
-        # Determine trend
-        first_energy = profiles[0].energy_joules
-        last_energy = profiles[-1].energy_joules
-
-        if first_energy > 0:
-            total_change = ((last_energy - first_energy) / first_energy) * 100
-        else:
-            total_change = 0.0
-
-        if total_change > 5:
-            trend = "increasing"
-        elif total_change < -5:
-            trend = "decreasing"
-        else:
-            trend = "stable"
-
-        # Find most/least efficient
-        most_efficient = min(profiles, key=lambda p: p.energy_joules)
-        least_efficient = max(profiles, key=lambda p: p.energy_joules)
-
-        report = VersionPowerReport(
-            versions=profiles,
-            trend=trend,
-            total_change_percent=total_change,
-            most_efficient=most_efficient.version,
-            least_efficient=least_efficient.version,
-        )
-
-        colored_print(f"\nTrend: {trend} ({total_change:+.2f}%)", "cyan")
-        colored_print(f"Most efficient: {most_efficient.version}", "green")
-        colored_print(f"Least efficient: {least_efficient.version}", "red")
-
-        # Restore to latest version
-        try:
-            self._checkout_version(repo_path, versions[-1])
-        except Exception:
-            pass
-
-        return report
-
-    @staticmethod
-    def _checkout_version(repo_path: str, version: str) -> str:
-        # Checkout a version and return its SHA.
-        subprocess.run(
-            ["git", "checkout", version, "--quiet"],
-            cwd=repo_path,
-            capture_output=True,
-            text=True,
-        )
-        result = subprocess.run(
-            ["git", "rev-parse", "HEAD"],
-            cwd=repo_path,
-            capture_output=True,
-            text=True,
-        )
-        return result.stdout.strip()

greenmining/config.py

@@ -1,91 +0,0 @@
-import os
-from pathlib import Path
-from typing import Any, Dict, List
-
-from dotenv import load_dotenv
-
-
-def _load_yaml_config(yaml_path: Path) -> Dict[str, Any]:
-    # Load configuration from YAML file if it exists.
-    if not yaml_path.exists():
-        return {}
-    try:
-        import yaml
-
-        with open(yaml_path, "r") as f:
-            return yaml.safe_load(f) or {}
-    except ImportError:
-        return {}
-    except Exception:
-        return {}
-
-
-class Config:
-    # Configuration class for loading from env vars and YAML.
-
-    def __init__(self, env_file: str = ".env", yaml_file: str = "greenmining.yaml"):
-        # Initialize configuration from environment and YAML file.
-        env_path = Path(env_file)
-        if env_path.exists():
-            load_dotenv(env_path)
-        else:
-            load_dotenv()
-
-        # Load YAML config
-        yaml_path = Path(yaml_file)
-        self._yaml_config = _load_yaml_config(yaml_path)
-
-        # GitHub API Configuration
-        self.GITHUB_TOKEN = os.getenv("GITHUB_TOKEN")
-        if not self.GITHUB_TOKEN or self.GITHUB_TOKEN == "your_github_pat_here":
-            raise ValueError("GITHUB_TOKEN not set. Please set it in .env file or environment.")
-
-        # Search Configuration (YAML: sources.search.*)
-        yaml_search = self._yaml_config.get("sources", {}).get("search", {})
-
-        self.SUPPORTED_LANGUAGES: List[str] = yaml_search.get(
-            "languages",
-            [
-                "Python",
-                "JavaScript",
-                "TypeScript",
-                "Java",
-                "C++",
-                "C#",
-                "Go",
-                "Rust",
-                "PHP",
-                "Ruby",
-                "Swift",
-                "Kotlin",
-                "Scala",
-                "R",
-                "MATLAB",
-                "Dart",
-                "Lua",
-                "Perl",
-                "Haskell",
-                "Elixir",
-            ],
-        )
-
-        # Repository Limits
-        self.MIN_STARS = yaml_search.get("min_stars", int(os.getenv("MIN_STARS", "100")))
-        self.MAX_REPOS = int(os.getenv("MAX_REPOS", "100"))
-
-        # Output Configuration (YAML: output.directory)
-        yaml_output = self._yaml_config.get("output", {})
-        self.OUTPUT_DIR = Path(yaml_output.get("directory", os.getenv("OUTPUT_DIR", "./data")))
-        self.OUTPUT_DIR.mkdir(parents=True, exist_ok=True)
-
-        # File Paths
-        self.REPOS_FILE = self.OUTPUT_DIR / "repositories.json"
-
-    def __repr__(self) -> str:
-        # String representation of configuration (hiding sensitive data).
-        return (
-            f"Config("
-            f"MAX_REPOS={self.MAX_REPOS}, "
-            f"OUTPUT_DIR={self.OUTPUT_DIR}"
-            f")"
-        )

greenmining/presenters/__init__.py

@@ -1,7 +0,0 @@
-# Presenters Package - UI/CLI presentation layer.
-
-from .console_presenter import ConsolePresenter
-
-__all__ = [
-    "ConsolePresenter",
-]

greenmining/presenters/console_presenter.py

@@ -1,143 +0,0 @@
-# Console Presenter - Handles console output formatting.
-
-from __future__ import annotations
-
-from typing import Any, Dict, List
-
-from tabulate import tabulate
-
-from greenmining.utils import colored_print
-
-
-class ConsolePresenter:
-    # Presenter for console/terminal output.
-
-    @staticmethod
-    def show_banner():
-        # Display application banner.
-        banner = """
-
-           Green Microservices Mining                     
-
-        """
-        colored_print(banner, "green")
-
-    @staticmethod
-    def show_repositories(repositories: list[dict], limit: int = 10):
-        # Display repository table.
-        if not repositories:
-            colored_print("No repositories to display", "yellow")
-            return
-
-        colored_print(f"\n Top {min(limit, len(repositories))} Repositories:\n", "cyan")
-
-        table_data = []
-        for repo in repositories[:limit]:
-            table_data.append(
-                [
-                    repo.get("full_name", "N/A"),
-                    repo.get("language", "N/A"),
-                    f"{repo.get('stars', 0):,}",
-                    (
-                        repo.get("description", "")[:50] + "..."
-                        if len(repo.get("description", "")) > 50
-                        else repo.get("description", "")
-                    ),
-                ]
-            )
-
-        headers = ["Repository", "Language", "Stars", "Description"]
-        print(tabulate(table_data, headers=headers, tablefmt="grid"))
-
-    @staticmethod
-    def show_commit_stats(stats: dict[str, Any]):
-        # Display commit statistics.
-        colored_print("\n Commit Statistics:\n", "cyan")
-
-        table_data = [
-            ["Total Commits", f"{stats.get('total_commits', 0):,}"],
-            ["Repositories", stats.get("total_repos", 0)],
-            ["Avg per Repo", f"{stats.get('avg_per_repo', 0):.1f}"],
-            ["Date Range", stats.get("date_range", "N/A")],
-        ]
-
-        print(tabulate(table_data, headers=["Metric", "Value"], tablefmt="grid"))
-
-    @staticmethod
-    def show_analysis_results(results: dict[str, Any]):
-        # Display analysis results.
-        colored_print("\n Analysis Results:\n", "cyan")
-
-        summary = results.get("summary", {})
-        table_data = [
-            ["Total Commits Analyzed", f"{summary.get('total_commits', 0):,}"],
-            ["Green-Aware Commits", f"{summary.get('green_commits', 0):,}"],
-            ["Green Rate", f"{summary.get('green_commit_rate', 0):.1%}"],
-            ["Patterns Detected", len(results.get("known_patterns", {}))],
-        ]
-
-        print(tabulate(table_data, headers=["Metric", "Value"], tablefmt="grid"))
-
-    @staticmethod
-    def show_pattern_distribution(patterns: dict[str, Any], limit: int = 10):
-        # Display pattern distribution.
-        if not patterns:
-            colored_print("No patterns to display", "yellow")
-            return
-
-        colored_print(f"\n Top {limit} Green Patterns:\n", "cyan")
-
-        # Sort by count
-        sorted_patterns = sorted(
-            patterns.items(), key=lambda x: x[1].get("count", 0), reverse=True
-        )[:limit]
-
-        table_data = []
-        for pattern_name, data in sorted_patterns:
-            table_data.append(
-                [
-                    pattern_name,
-                    data.get("count", 0),
-                    f"{data.get('percentage', 0):.1f}%",
-                    data.get("confidence_distribution", {}).get("HIGH", 0),
-                ]
-            )
-
-        headers = ["Pattern", "Count", "Percentage", "High Confidence"]
-        print(tabulate(table_data, headers=headers, tablefmt="grid"))
-
-    @staticmethod
-    def show_pipeline_status(status: dict[str, Any]):
-        # Display pipeline status.
-        colored_print("\n  Pipeline Status:\n", "cyan")
-
-        table_data = []
-        for phase, info in status.items():
-            status_icon = "done" if info.get("completed") else "pending"
-            table_data.append(
-                [status_icon, phase, info.get("file", "N/A"), info.get("size", "N/A")]
-            )
-
-        headers = ["Status", "Phase", "Output File", "Size"]
-        print(tabulate(table_data, headers=headers, tablefmt="grid"))
-
-    @staticmethod
-    def show_progress_message(phase: str, current: int, total: int):
-        # Display progress message.
-        percentage = (current / total * 100) if total > 0 else 0
-        colored_print(f"[{phase}] Progress: {current}/{total} ({percentage:.1f}%)", "cyan")
-
-    @staticmethod
-    def show_error(message: str):
-        # Display error message.
-        colored_print(f" Error: {message}", "red")
-
-    @staticmethod
-    def show_success(message: str):
-        # Display success message.
-        colored_print(f" {message}", "green")
-
-    @staticmethod
-    def show_warning(message: str):
-        # Display warning message.
-        colored_print(f"  Warning: {message}", "yellow")