greenmining 1.0.5__py3-none-any.whl → 1.0.7__py3-none-any.whl

greenmining/energy/rapl.py

@@ -13,9 +13,9 @@ 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)
@@ -24,12 +24,12 @@ class RAPLEnergyMeter(EnergyMeter):
         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():
@@ -39,9 +39,9 @@ class RAPLEnergyMeter(EnergyMeter):
                     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():
@@ -50,24 +50,24 @@ class RAPLEnergyMeter(EnergyMeter):
                         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:
@@ -75,68 +75,62 @@ class RAPLEnergyMeter(EnergyMeter):
                 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()
-        }
-    
+        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()
-        }
-        
+        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,
@@ -151,7 +145,7 @@ class RAPLEnergyMeter(EnergyMeter):
             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/services/__init__.py

@@ -3,15 +3,25 @@
 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 .github_graphql_fetcher import GitHubGraphQLFetcher
+from .local_repo_analyzer import (
+    LocalRepoAnalyzer,
+    CommitAnalysis,
+    RepositoryAnalysis,
+    MethodMetrics,
+    SourceCodeChange,
+)
 from .reports import ReportGenerator
 
 __all__ = [
-    "GitHubFetcher",
+    "GitHubGraphQLFetcher",
     "CommitExtractor",
     "DataAnalyzer",
     "DataAggregator",
     "ReportGenerator",
     "LocalRepoAnalyzer",
+    "CommitAnalysis",
+    "RepositoryAnalysis",
+    "MethodMetrics",
+    "SourceCodeChange",
 ]

greenmining/services/commit_extractor.py

@@ -41,7 +41,9 @@ class CommitExtractor:
         self.github = Github(github_token) if github_token else None
         self.timeout = timeout
 
-    def extract_from_repositories(self, repositories: list[dict[str, Any] | Repository]) -> list[dict[str, Any]]:
+    def extract_from_repositories(
+        self, repositories: list[dict[str, Any] | Repository]
+    ) -> list[dict[str, Any]]:
         # Extract commits from list of repositories.
         all_commits = []
         failed_repos = []
@@ -74,15 +76,17 @@ class CommitExtractor:
                     pbar.update(1)
                 except TimeoutError:
                     signal.alarm(0)  # Cancel alarm
-                    repo_name = repo.full_name if isinstance(repo, Repository) else repo["full_name"]
-                    colored_print(
-                        f"\nTimeout processing {repo_name} (>{self.timeout}s)", "yellow"
+                    repo_name = (
+                        repo.full_name if isinstance(repo, Repository) else repo["full_name"]
                     )
+                    colored_print(f"\nTimeout processing {repo_name} (>{self.timeout}s)", "yellow")
                     failed_repos.append(repo_name)
                     pbar.update(1)
                 except Exception as e:
                     signal.alarm(0)  # Cancel alarm
-                    repo_name = repo.full_name if isinstance(repo, Repository) else repo["full_name"]
+                    repo_name = (
+                        repo.full_name if isinstance(repo, Repository) else repo["full_name"]
+                    )
                     colored_print(f"\nError processing {repo_name}: {e}", "yellow")
                     failed_repos.append(repo_name)
                     pbar.update(1)