greenmining 1.0.2__py3-none-any.whl → 1.0.4__py3-none-any.whl

greenmining/energy/rapl.py

@@ -0,0 +1,157 @@
+# Intel RAPL (Running Average Power Limit) energy measurement for Linux.
+
+from __future__ import annotations
+
+import os
+import time
+from datetime import datetime
+from pathlib import Path
+from typing import Dict, List, Optional
+
+from .base import EnergyMeter, EnergyMetrics, EnergyBackend
+
+
+class RAPLEnergyMeter(EnergyMeter):
+    # Energy measurement using Intel RAPL on Linux.
+    
+    RAPL_PATH = Path("/sys/class/powercap/intel-rapl")
+    
+    def __init__(self):
+        # Initialize RAPL energy meter.
+        super().__init__(EnergyBackend.RAPL)
+        self._domains: Dict[str, Path] = {}
+        self._start_energy: Dict[str, int] = {}
+        self._start_time: Optional[float] = None
+        self._power_samples: List[float] = []
+        self._discover_domains()
+    
+    def _discover_domains(self) -> None:
+        # Discover available RAPL domains.
+        if not self.RAPL_PATH.exists():
+            return
+        
+        # Find all RAPL domains (intel-rapl:0, intel-rapl:0:0, etc.)
+        for domain_path in self.RAPL_PATH.glob("intel-rapl:*"):
+            if (domain_path / "energy_uj").exists():
+                # Get domain name
+                name_file = domain_path / "name"
+                if name_file.exists():
+                    domain_name = name_file.read_text().strip()
+                else:
+                    domain_name = domain_path.name
+                
+                self._domains[domain_name] = domain_path / "energy_uj"
+            
+            # Check for sub-domains (core, uncore, dram, etc.)
+            for subdomain_path in domain_path.glob("intel-rapl:*:*"):
+                if (subdomain_path / "energy_uj").exists():
+                    name_file = subdomain_path / "name"
+                    if name_file.exists():
+                        subdomain_name = name_file.read_text().strip()
+                    else:
+                        subdomain_name = subdomain_path.name
+                    
+                    self._domains[subdomain_name] = subdomain_path / "energy_uj"
+    
+    def _read_energy(self, path: Path) -> int:
+        # Read energy value in microjoules from a RAPL file.
+        try:
+            return int(path.read_text().strip())
+        except (PermissionError, FileNotFoundError, ValueError):
+            return 0
+    
+    def is_available(self) -> bool:
+        # Check if RAPL is available on this system.
+        if not self.RAPL_PATH.exists():
+            return False
+        
+        if not self._domains:
+            return False
+        
+        # Try to read at least one domain
+        for path in self._domains.values():
+            try:
+                self._read_energy(path)
+                return True
+            except Exception:
+                continue
+        
+        return False
+    
+    def start(self) -> None:
+        # Start energy measurement.
+        if self._is_measuring:
+            raise RuntimeError("Already measuring energy")
+        
+        self._is_measuring = True
+        self._start_time = time.time()
+        self._power_samples = []
+        
+        # Read starting energy values for all domains
+        self._start_energy = {
+            name: self._read_energy(path)
+            for name, path in self._domains.items()
+        }
+    
+    def stop(self) -> EnergyMetrics:
+        # Stop energy measurement and return results.
+        if not self._is_measuring:
+            raise RuntimeError("Not currently measuring energy")
+        
+        end_time = time.time()
+        self._is_measuring = False
+        
+        # Read ending energy values
+        end_energy = {
+            name: self._read_energy(path)
+            for name, path in self._domains.items()
+        }
+        
+        # Calculate energy consumption per domain (in joules)
+        duration = end_time - self._start_time
+        
+        # Handle counter wrap-around (RAPL counters are typically 32-bit)
+        MAX_ENERGY_UJ = 2**32
+        
+        domain_energy = {}
+        for name in self._domains:
+            start = self._start_energy.get(name, 0)
+            end = end_energy.get(name, 0)
+            
+            if end >= start:
+                delta_uj = end - start
+            else:
+                # Counter wrapped around
+                delta_uj = (MAX_ENERGY_UJ - start) + end
+            
+            domain_energy[name] = delta_uj / 1_000_000  # Convert to joules
+        
+        # Aggregate metrics
+        total_joules = sum(domain_energy.values())
+        
+        # Extract component-specific energy
+        cpu_energy = domain_energy.get("core", 0) or domain_energy.get("package-0", total_joules)
+        dram_energy = domain_energy.get("dram", 0)
+        gpu_energy = domain_energy.get("uncore", None)  # Integrated GPU
+        
+        # Calculate power
+        watts_avg = total_joules / duration if duration > 0 else 0
+        
+        return EnergyMetrics(
+            joules=total_joules,
+            watts_avg=watts_avg,
+            watts_peak=watts_avg,  # RAPL doesn't provide instantaneous peak
+            duration_seconds=duration,
+            cpu_energy_joules=cpu_energy,
+            dram_energy_joules=dram_energy,
+            gpu_energy_joules=gpu_energy,
+            carbon_grams=None,  # RAPL doesn't track carbon
+            carbon_intensity=None,
+            backend="rapl",
+            start_time=datetime.fromtimestamp(self._start_time),
+            end_time=datetime.fromtimestamp(end_time),
+        )
+    
+    def get_available_domains(self) -> List[str]:
+        # Get list of available RAPL domains.
+        return list(self._domains.keys())

greenmining/gsf_patterns.py

@@ -1,10 +1,4 @@
-"""
-Green Software Foundation Patterns
-Official patterns from https://patterns.greensoftware.foundation/
-
-Categories: Cloud (40+ patterns), Web (15+ patterns), AI/ML (10+ patterns)
-Total: 65+ official GSF patterns
-"""
+# Green Software Foundation Patterns
 
 GSF_PATTERNS = {
     # ==================== CLOUD PATTERNS (40+) ====================
@@ -1219,7 +1213,7 @@ GSF_PATTERNS = {
     },
 }
 
-# Green software keywords (comprehensive list from all GSF patterns + VU Amsterdam research)
+# Green software keywords (comprehensive list from all GSF patterns)
 GREEN_KEYWORDS = [
     # Core sustainability terms
     "energy",
@@ -1565,15 +1559,7 @@ GREEN_KEYWORDS = [
 
 
 def get_pattern_by_keywords(commit_message: str) -> list:
-    """
-    Match commit message against GSF patterns.
-
-    Args:
-        commit_message: The commit message to analyze
-
-    Returns:
-        List of matched pattern names
-    """
+    # Match commit message against GSF patterns.
     message_lower = commit_message.lower()
     matched_patterns = []
 
@@ -1587,14 +1573,6 @@ def get_pattern_by_keywords(commit_message: str) -> list:
 
 
 def is_green_aware(commit_message: str) -> bool:
-    """
-    Check if commit shows green software awareness.
-
-    Args:
-        commit_message: The commit message to analyze
-
-    Returns:
-        True if commit has green keywords
-    """
+    # Check if commit shows green software awareness.
     message_lower = commit_message.lower()
     return any(keyword.lower() in message_lower for keyword in GREEN_KEYWORDS)

greenmining/models/__init__.py

@@ -1,8 +1,4 @@
-"""
-Models Package - Data models and entities for green microservices mining.
-
-This package contains all data structures and domain models following MCP architecture.
-"""
+# Models Package - Data models and entities for green microservices mining.
 
 from .aggregated_stats import AggregatedStats
 from .analysis_result import AnalysisResult

greenmining/models/aggregated_stats.py

@@ -1,4 +1,4 @@
-"""Aggregated Statistics Model - Represents aggregated analysis data."""
+# Aggregated Statistics Model - Represents aggregated analysis data.
 
 from __future__ import annotations
 
@@ -8,7 +8,7 @@ from typing import Dict, List, Optional
 
 @dataclass
 class AggregatedStats:
-    """Data model for aggregated statistics."""
+    # Data model for aggregated statistics.
 
     summary: dict = field(default_factory=dict)
     known_patterns: dict = field(default_factory=dict)
@@ -17,7 +17,7 @@ class AggregatedStats:
     timestamp: Optional[str] = None
 
     def to_dict(self) -> dict:
-        """Convert to dictionary."""
+        # Convert to dictionary.
         return {
             "summary": self.summary,
             "known_patterns": self.known_patterns,
@@ -28,5 +28,5 @@ class AggregatedStats:
 
     @classmethod
     def from_dict(cls, data: dict) -> "AggregatedStats":
-        """Create from dictionary."""
+        # Create from dictionary.
         return cls(**{k: v for k, v in data.items() if k in cls.__annotations__})

greenmining/models/analysis_result.py

@@ -1,4 +1,4 @@
-"""Analysis Result Model - Represents commit analysis output."""
+# Analysis Result Model - Represents commit analysis output.
 
 from dataclasses import dataclass
 from typing import Optional
@@ -6,7 +6,7 @@ from typing import Optional
 
 @dataclass
 class AnalysisResult:
-    """Data model for commit analysis results."""
+    # Data model for commit analysis results.
 
     commit_id: str
     repo_name: str
@@ -26,7 +26,7 @@ class AnalysisResult:
             self.files_changed = []
 
     def to_dict(self) -> dict:
-        """Convert to dictionary."""
+        # Convert to dictionary.
         return {
             "commit_id": self.commit_id,
             "repo_name": self.repo_name,
@@ -44,5 +44,5 @@ class AnalysisResult:
 
     @classmethod
     def from_dict(cls, data: dict) -> "AnalysisResult":
-        """Create from dictionary."""
+        # Create from dictionary.
         return cls(**{k: v for k, v in data.items() if k in cls.__annotations__})

greenmining/models/commit.py

@@ -1,4 +1,4 @@
-"""Commit Model - Represents a Git commit."""
+# Commit Model - Represents a Git commit.
 
 from __future__ import annotations
 
@@ -8,7 +8,7 @@ from typing import List
 
 @dataclass
 class Commit:
-    """Data model for a Git commit."""
+    # Data model for a Git commit.
 
     commit_id: str
     repo_name: str
@@ -26,7 +26,7 @@ class Commit:
     in_main_branch: bool = True
 
     def to_dict(self) -> dict:
-        """Convert to dictionary."""
+        # Convert to dictionary.
         return {
             "commit_id": self.commit_id,
             "repo_name": self.repo_name,
@@ -46,12 +46,12 @@ class Commit:
 
     @classmethod
     def from_dict(cls, data: dict) -> "Commit":
-        """Create from dictionary."""
+        # Create from dictionary.
         return cls(**{k: v for k, v in data.items() if k in cls.__annotations__})
 
     @classmethod
     def from_pydriller_commit(cls, commit, repo_name: str) -> "Commit":
-        """Create from PyDriller commit object."""
+        # Create from PyDriller commit object.
         return cls(
             commit_id=commit.hash,
             repo_name=repo_name,

greenmining/models/repository.py

@@ -1,4 +1,4 @@
-"""Repository Model - Represents a GitHub repository."""
+# Repository Model - Represents a GitHub repository.
 
 from __future__ import annotations
 
@@ -8,7 +8,7 @@ from typing import List, Optional
 
 @dataclass
 class Repository:
-    """Data model for a GitHub repository."""
+    # Data model for a GitHub repository.
 
     repo_id: int
     name: str
@@ -33,7 +33,7 @@ class Repository:
     license: Optional[str] = None
 
     def to_dict(self) -> dict:
-        """Convert to dictionary."""
+        # Convert to dictionary.
         return {
             "repo_id": self.repo_id,
             "name": self.name,
@@ -60,12 +60,12 @@ class Repository:
 
     @classmethod
     def from_dict(cls, data: dict) -> "Repository":
-        """Create from dictionary."""
+        # Create from dictionary.
         return cls(**{k: v for k, v in data.items() if k in cls.__annotations__})
 
     @classmethod
     def from_github_repo(cls, repo, repo_id: int) -> "Repository":
-        """Create from PyGithub repository object."""
+        # Create from PyGithub repository object.
         return cls(
             repo_id=repo_id,
             name=repo.name,

greenmining/presenters/__init__.py

@@ -1,8 +1,4 @@
-"""
-Presenters Package - UI/CLI presentation layer.
-
-Presenters handle output formatting and user interaction.
-"""
+# Presenters Package - UI/CLI presentation layer.
 
 from .console_presenter import ConsolePresenter
 

greenmining/presenters/console_presenter.py

@@ -1,4 +1,4 @@
-"""Console Presenter - Handles console output formatting."""
+# Console Presenter - Handles console output formatting.
 
 from __future__ import annotations
 
@@ -10,26 +10,26 @@ from greenmining.utils import colored_print
 
 
 class ConsolePresenter:
-    """Presenter for console/terminal output."""
+    # Presenter for console/terminal output.
 
     @staticmethod
     def show_banner():
-        """Display application banner."""
+        # Display application banner.
         banner = """
-╔══════════════════════════════════════════════════════════╗
-║           Green Microservices Mining                     ║
-╚══════════════════════════════════════════════════════════╝
+
+           Green Microservices Mining                     
+
         """
         colored_print(banner, "green")
 
     @staticmethod
     def show_repositories(repositories: list[dict], limit: int = 10):
-        """Display repository table."""
+        # 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")
+        colored_print(f"\n Top {min(limit, len(repositories))} Repositories:\n", "cyan")
 
         table_data = []
         for repo in repositories[:limit]:
@@ -51,8 +51,8 @@ class ConsolePresenter:
 
     @staticmethod
     def show_commit_stats(stats: dict[str, Any]):
-        """Display commit statistics."""
-        colored_print("\n📈 Commit Statistics:\n", "cyan")
+        # Display commit statistics.
+        colored_print("\n Commit Statistics:\n", "cyan")
 
         table_data = [
             ["Total Commits", f"{stats.get('total_commits', 0):,}"],
@@ -65,8 +65,8 @@ class ConsolePresenter:
 
     @staticmethod
     def show_analysis_results(results: dict[str, Any]):
-        """Display analysis results."""
-        colored_print("\n🔬 Analysis Results:\n", "cyan")
+        # Display analysis results.
+        colored_print("\n Analysis Results:\n", "cyan")
 
         summary = results.get("summary", {})
         table_data = [
@@ -80,12 +80,12 @@ class ConsolePresenter:
 
     @staticmethod
     def show_pattern_distribution(patterns: dict[str, Any], limit: int = 10):
-        """Display pattern distribution."""
+        # Display pattern distribution.
         if not patterns:
             colored_print("No patterns to display", "yellow")
             return
 
-        colored_print(f"\n🎯 Top {limit} Green Patterns:\n", "cyan")
+        colored_print(f"\n Top {limit} Green Patterns:\n", "cyan")
 
         # Sort by count
         sorted_patterns = sorted(
@@ -108,12 +108,12 @@ class ConsolePresenter:
 
     @staticmethod
     def show_pipeline_status(status: dict[str, Any]):
-        """Display pipeline status."""
-        colored_print("\n⚙️  Pipeline Status:\n", "cyan")
+        # Display pipeline status.
+        colored_print("\n  Pipeline Status:\n", "cyan")
 
         table_data = []
         for phase, info in status.items():
-            status_icon = "✅" if info.get("completed") else "⏳"
+            status_icon = "" if info.get("completed") else "⏳"
             table_data.append(
                 [status_icon, phase, info.get("file", "N/A"), info.get("size", "N/A")]
             )
@@ -123,21 +123,21 @@ class ConsolePresenter:
 
     @staticmethod
     def show_progress_message(phase: str, current: int, total: int):
-        """Display progress message."""
+        # 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")
+        # Display error message.
+        colored_print(f" Error: {message}", "red")
 
     @staticmethod
     def show_success(message: str):
-        """Display success message."""
-        colored_print(f"✅ {message}", "green")
+        # Display success message.
+        colored_print(f" {message}", "green")
 
     @staticmethod
     def show_warning(message: str):
-        """Display warning message."""
-        colored_print(f"⚠️  Warning: {message}", "yellow")
+        # Display warning message.
+        colored_print(f"  Warning: {message}", "yellow")

greenmining/services/__init__.py

@@ -1,13 +1,17 @@
-"""
-Services Package - Core business logic and data processing services.
-
-Services implement the actual mining, extraction, analysis operations.
-"""
+# Services Package - Core business logic and data processing services.
 
 from .commit_extractor import CommitExtractor
 from .data_aggregator import DataAggregator
 from .data_analyzer import DataAnalyzer
 from .github_fetcher import GitHubFetcher
+from .local_repo_analyzer import LocalRepoAnalyzer
 from .reports import ReportGenerator
 
-__all__ = ["GitHubFetcher", "CommitExtractor", "DataAnalyzer", "DataAggregator", "ReportGenerator"]
+__all__ = [
+    "GitHubFetcher",
+    "CommitExtractor",
+    "DataAnalyzer",
+    "DataAggregator",
+    "ReportGenerator",
+    "LocalRepoAnalyzer",
+]