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

{greenmining-1.1.9.dist-info → greenmining-1.2.1.dist-info}/RECORD

@@ -1,18 +1,14 @@
-greenmining/__init__.py,sha256=tQoU8k_I_ymm67bNlYo0laMgS_eP9ersn5NAkdRjRvc,3390
+greenmining/__init__.py,sha256=W-CMUfo3U7pWBGAKtwT5XwjcMxbKjF5c42ViFFsOBS4,4096
 greenmining/__main__.py,sha256=NYOVS7D4w2XDLn6SyXHXPKE5GrNGOeoWSTb_KazgK5c,590
-greenmining/config.py,sha256=MQ5aPaa_Y9MZke774dmibz2-XSqRVsQiiNaLDr8f7S0,2771
 greenmining/gsf_patterns.py,sha256=UvNJPY3HlAx1SicwUqci40TlLg8lCL0tszSOH4haxQs,55921
 greenmining/utils.py,sha256=-dnLUw9taCzvQ2dk6uc66GAohOFiXJFKs9TLSEPk5kM,2893
-greenmining/analyzers/__init__.py,sha256=rTgpDfFE6za4QAHW59ncnS6TW02omn-TZMnYNVUIZp0,753
+greenmining/analyzers/__init__.py,sha256=wnBrn8EyAHG_qnesOPAYkZyc-XigXWy2pI3bMeIoLH4,416
 greenmining/analyzers/code_diff_analyzer.py,sha256=1dk68R3O0RZG8gx1cm9B_UlZ1Uwyb_Q3oScRbCVx4tM,10950
 greenmining/analyzers/metrics_power_correlator.py,sha256=MgKXAIYjNihzzyilCd88_AMjZP9sdC6NkCAVbrvvOus,5957
-greenmining/analyzers/power_regression.py,sha256=j_SL8BHQi89zkjjKPPcjsPrvfDAeGpLeZujQiNw_RKI,7375
-greenmining/analyzers/qualitative_analyzer.py,sha256=5LiqP2It3q6_RLiLGkyGRZaRxg00dcyTPvlN5l-wq_k,15379
 greenmining/analyzers/statistical_analyzer.py,sha256=PA0w0sytRmMO6N1a2iH7VdA6Icg4DcyBLFXOGq7PepY,5942
 greenmining/analyzers/temporal_analyzer.py,sha256=JfTcAoI20oCFMehGrSRnDqhJTXI-RUbdCTMwDOTW9-g,14259
-greenmining/analyzers/version_power_analyzer.py,sha256=2P6zOqBg-ButtIhF-4cutiwD2Q1geMY49VFUghHXXoI,8119
 greenmining/controllers/__init__.py,sha256=UiAT6zBvC1z_9cJWfzq1cLA0I4r9b2vURHipj8oDczI,180
-greenmining/controllers/repository_controller.py,sha256=ZRMU6oUWUELW91qcZ_iBiRcDNT8ruTIy2aRjQbOb0O0,6571
+greenmining/controllers/repository_controller.py,sha256=sjfbDhyRY59MsKLw0dkxzpe1QZKtm9ScO4E8VFYZy9A,6041
 greenmining/energy/__init__.py,sha256=GoCYh7hitWBoPMtan1HF1yezCHi7o4sa_YUJgGkeJc8,558
 greenmining/energy/base.py,sha256=3hIPgc4B0Nz9V7DTh2Xd6trDRtmozUBBpa5UWRuWzcw,5918
 greenmining/energy/carbon_reporter.py,sha256=bKIFlLhHfYzI4DBu_ff4GW1Psz4oSCAF4NmzQb-EShA,8298
@@ -24,17 +20,15 @@ greenmining/models/aggregated_stats.py,sha256=CZxjwXswvtmYPwpcbodLUsZpsbsNKBDIqv
 greenmining/models/analysis_result.py,sha256=YICTCEcrJxZ1R8Xaio3AZOjCGwMzC_62BMAL0J_XY1w,1509
 greenmining/models/commit.py,sha256=LCwDcRu4-BeCJQdk590oQNZZZM9t8W9FlaHlo9DCVmc,2415
 greenmining/models/repository.py,sha256=MUeCOtVMOsU4Oa_BBoB163Ij5BKytTKwbzoGORJx4rU,2850
-greenmining/presenters/__init__.py,sha256=d1CMtqtUAHYHYNzigPyjtGOUtnH1drtUwf7-bFQq2B8,138
-greenmining/presenters/console_presenter.py,sha256=qagn2c2aOym0WNKV8n175MQ-BTheLjrXzW8c1OafzAQ,4904
 greenmining/services/__init__.py,sha256=ZEMOVut0KRdume_vz58beSNps3YgeoGBXmUjEqNgIhc,690
 greenmining/services/commit_extractor.py,sha256=qBM9QpGzPZRmGMFufJ6gP8eWIuufTowLX8mQxqZwyEU,6996
 greenmining/services/data_aggregator.py,sha256=BU_HUb-8c0n0sa_7VZRB8jIVnaVhRLf-E6KA4ASh-08,19427
 greenmining/services/data_analyzer.py,sha256=0XqW-slrnt7RotrHDweOqKtoN8XIA7y6p7s2Jau6cMg,7431
 greenmining/services/github_graphql_fetcher.py,sha256=ZklXdEAc60KeFL83zRYMwW_-2OwMKpfPY7Wrifl0D50,11539
-greenmining/services/local_repo_analyzer.py,sha256=PYHj-zz0cePWbQq9HtGvd2OcZUYM8rRGe8eKIAp1_fI,24874
+greenmining/services/local_repo_analyzer.py,sha256=kdqN9O7GlmOs1_H1iNni1HEcCzF9bBCPeP3wMStGe5Q,25306
 greenmining/services/reports.py,sha256=nhJuYiA5tPD_9AjtgSLEnrpW3x15sZXrwIxpxQEBbh0,23219
-greenmining-1.1.9.dist-info/licenses/LICENSE,sha256=M7ma3JHGeiIZIs3ea0HTcFl_wLFPX2NZElUliYs4bCA,1083
-greenmining-1.1.9.dist-info/METADATA,sha256=QVrwbhh-huQmP8Uv0YQDgraGOFoTmFRNxq7T27bZ4wk,30175
-greenmining-1.1.9.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-greenmining-1.1.9.dist-info/top_level.txt,sha256=nreXgXxZIWI-42yQknQ0HXtUrFnzZ8N1ra4Mdy2KcsI,12
-greenmining-1.1.9.dist-info/RECORD,,
+greenmining-1.2.1.dist-info/licenses/LICENSE,sha256=M7ma3JHGeiIZIs3ea0HTcFl_wLFPX2NZElUliYs4bCA,1083
+greenmining-1.2.1.dist-info/METADATA,sha256=ZmLnx5P5jN8XpRGgfx_gVzykWvUZdsHrTEpg3Plh9-A,10522
+greenmining-1.2.1.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+greenmining-1.2.1.dist-info/top_level.txt,sha256=nreXgXxZIWI-42yQknQ0HXtUrFnzZ8N1ra4Mdy2KcsI,12
+greenmining-1.2.1.dist-info/RECORD,,

greenmining/analyzers/power_regression.py

@@ -1,211 +0,0 @@
-# Power regression detection for identifying commits that increased power consumption.
-# Compares energy measurements between baseline and target commits.
-
-from __future__ import annotations
-
-import subprocess
-from dataclasses import dataclass, field
-from typing import Any, Dict, List, Optional
-
-from pydriller import Repository
-
-from greenmining.utils import colored_print
-
-
-@dataclass
-class PowerRegression:
-    # A detected power regression from a commit.
-
-    sha: str
-    message: str
-    author: str
-    date: str
-    power_before: float  # watts
-    power_after: float  # watts
-    power_increase: float  # percentage
-    energy_before: float  # joules
-    energy_after: float  # joules
-    is_regression: bool = True
-
-    def to_dict(self) -> Dict[str, Any]:
-        return {
-            "sha": self.sha,
-            "message": self.message,
-            "author": self.author,
-            "date": self.date,
-            "power_before": round(self.power_before, 4),
-            "power_after": round(self.power_after, 4),
-            "power_increase": round(self.power_increase, 2),
-            "energy_before": round(self.energy_before, 4),
-            "energy_after": round(self.energy_after, 4),
-            "is_regression": self.is_regression,
-        }
-
-
-class PowerRegressionDetector:
-    # Detect commits that caused power consumption regressions.
-    # Runs a test command at each commit and measures energy usage.
-
-    def __init__(
-        self,
-        test_command: str = "pytest tests/ -x",
-        energy_backend: str = "rapl",
-        threshold_percent: float = 5.0,
-        iterations: int = 5,
-        warmup_iterations: int = 1,
-    ):
-        # Initialize power regression detector.
-        # Args:
-        #   test_command: Shell command to run for energy measurement
-        #   energy_backend: Energy measurement backend (rapl, codecarbon, cpu_meter)
-        #   threshold_percent: Minimum percentage increase to flag as regression
-        #   iterations: Number of measurement iterations per commit (for accuracy)
-        #   warmup_iterations: Number of warmup runs before measurement
-        self.test_command = test_command
-        self.energy_backend = energy_backend
-        self.threshold_percent = threshold_percent
-        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 _run_test_command(self, cwd: str) -> float:
-        # Run test command and return energy consumed in joules.
-        meter = self._get_energy_meter()
-
-        # Warmup
-        for _ in range(self.warmup_iterations):
-            subprocess.run(
-                self.test_command,
-                shell=True,
-                cwd=cwd,
-                capture_output=True,
-                text=True,
-                timeout=300,
-            )
-
-        # Measure
-        total_joules = 0.0
-        for _ in range(self.iterations):
-            meter.start()
-            subprocess.run(
-                self.test_command,
-                shell=True,
-                cwd=cwd,
-                capture_output=True,
-                text=True,
-                timeout=300,
-            )
-            metrics = meter.stop()
-            total_joules += metrics.joules
-
-        return total_joules / self.iterations
-
-    def detect(
-        self,
-        repo_path: str,
-        baseline_commit: str = "HEAD~10",
-        target_commit: str = "HEAD",
-        max_commits: int = 50,
-    ) -> List[PowerRegression]:
-        # Detect power regressions between baseline and target commits.
-        # Args:
-        #   repo_path: Path to local git repository
-        #   baseline_commit: Baseline commit SHA or reference
-        #   target_commit: Target commit SHA or reference
-        #   max_commits: Maximum commits to analyze
-        regressions = []
-
-        colored_print(f"Detecting power regressions in {repo_path}", "cyan")
-        colored_print(f"  Range: {baseline_commit}..{target_commit}", "cyan")
-        colored_print(f"  Test: {self.test_command}", "cyan")
-        colored_print(f"  Threshold: {self.threshold_percent}%", "cyan")
-
-        # Get commits in range
-        commits = list(
-            Repository(
-                path_to_repo=repo_path,
-                from_commit=baseline_commit,
-                to_commit=target_commit,
-            ).traverse_commits()
-        )
-
-        if not commits:
-            colored_print("No commits found in range", "yellow")
-            return regressions
-
-        # Measure baseline
-        colored_print(f"  Measuring baseline ({commits[0].hash[:8]})...", "cyan")
-        self._checkout(repo_path, commits[0].hash)
-        baseline_energy = self._run_test_command(repo_path)
-        colored_print(f"  Baseline: {baseline_energy:.4f} joules", "green")
-
-        previous_energy = baseline_energy
-        commit_count = 0
-
-        for commit in commits[1:]:
-            if commit_count >= max_commits:
-                break
-
-            try:
-                self._checkout(repo_path, commit.hash)
-                current_energy = self._run_test_command(repo_path)
-
-                # Calculate change
-                if previous_energy > 0:
-                    change_percent = ((current_energy - previous_energy) / previous_energy) * 100
-                else:
-                    change_percent = 0.0
-
-                # Check for regression
-                if change_percent > self.threshold_percent:
-                    regression = PowerRegression(
-                        sha=commit.hash,
-                        message=commit.msg[:200],
-                        author=commit.author.name,
-                        date=commit.author_date.isoformat() if commit.author_date else "",
-                        power_before=previous_energy / max(1, self.iterations),
-                        power_after=current_energy / max(1, self.iterations),
-                        power_increase=change_percent,
-                        energy_before=previous_energy,
-                        energy_after=current_energy,
-                    )
-                    regressions.append(regression)
-                    colored_print(f"  REGRESSION: {commit.hash[:8]} +{change_percent:.1f}%", "red")
-                else:
-                    colored_print(f"  OK: {commit.hash[:8]} {change_percent:+.1f}%", "green")
-
-                previous_energy = current_energy
-                commit_count += 1
-
-            except Exception as e:
-                colored_print(f"  Warning: Failed on {commit.hash[:8]}: {e}", "yellow")
-                continue
-
-        # Restore to target
-        self._checkout(repo_path, target_commit)
-
-        colored_print(
-            f"\nFound {len(regressions)} power regressions "
-            f"(>{self.threshold_percent}% increase)",
-            "cyan" if not regressions else "red",
-        )
-
-        return regressions
-
-    @staticmethod
-    def _checkout(repo_path: str, ref: str):
-        # Checkout a specific commit.
-        subprocess.run(
-            ["git", "checkout", ref, "--quiet"],
-            cwd=repo_path,
-            capture_output=True,
-            text=True,
-        )

greenmining/analyzers/qualitative_analyzer.py

@@ -1,394 +0,0 @@
-# Qualitative Analysis Framework for Pattern Validation
-
-from __future__ import annotations
-
-import random
-from typing import Dict, List, Optional
-from dataclasses import dataclass
-from collections import defaultdict
-import json
-
-
-@dataclass
-class ValidationSample:
-    # Represents a single validation sample
-
-    commit_sha: str
-    commit_message: str
-    code_diff: Optional[str]
-    repository: str
-    detected_patterns: List[str]
-    detection_method: str  # 'keyword', 'nlp', 'code_diff'
-    validation_status: Optional[str] = None  # 'pending', 'validated', 'rejected'
-    true_label: Optional[bool] = None  # Ground truth after manual review
-    reviewer: Optional[str] = None
-    review_notes: Optional[str] = None
-
-
-@dataclass
-class ValidationMetrics:
-    # Precision/recall metrics for validation
-
-    true_positives: int
-    false_positives: int
-    true_negatives: int
-    false_negatives: int
-    precision: float
-    recall: float
-    f1_score: float
-    accuracy: float
-
-
-class QualitativeAnalyzer:
-    # Framework for manual validation and qualitative analysis.
-
-    def __init__(self, sample_size: int = 30, stratify_by: str = "pattern"):
-        # Initialize qualitative analyzer.
-        self.sample_size = sample_size
-        self.stratify_by = stratify_by
-        self.samples: List[ValidationSample] = []
-
-    def generate_validation_samples(
-        self, commits: List[Dict], analysis_results: List[Dict], include_negatives: bool = True
-    ) -> List[ValidationSample]:
-        # Generate stratified validation samples.
-        # Build commit lookup
-        commit_lookup = {c.get("hash", c.get("sha")): c for c in commits}
-
-        # Separate positives (detected as green) and negatives
-        positives = [r for r in analysis_results if r.get("is_green_aware", False)]
-        negatives = [r for r in analysis_results if not r.get("is_green_aware", False)]
-
-        samples = []
-
-        # Calculate sample distribution
-        if include_negatives:
-            # 80% positives, 20% negatives (to check false negatives)
-            pos_sample_size = int(self.sample_size * 0.8)
-            neg_sample_size = self.sample_size - pos_sample_size
-        else:
-            pos_sample_size = self.sample_size
-            neg_sample_size = 0
-
-        # Sample positives (stratified by pattern or repository)
-        if self.stratify_by == "pattern":
-            pos_samples = self._stratified_sample_by_pattern(positives, pos_sample_size)
-        elif self.stratify_by == "repository":
-            pos_samples = self._stratified_sample_by_repo(positives, commit_lookup, pos_sample_size)
-        else:
-            pos_samples = random.sample(positives, min(pos_sample_size, len(positives)))
-
-        # Sample negatives (random)
-        if include_negatives and negatives:
-            neg_samples = random.sample(negatives, min(neg_sample_size, len(negatives)))
-        else:
-            neg_samples = []
-
-        # Create ValidationSample objects
-        for result in pos_samples + neg_samples:
-            commit_sha = result.get("commit_sha")
-            commit = commit_lookup.get(commit_sha, {})
-
-            sample = ValidationSample(
-                commit_sha=commit_sha,
-                commit_message=commit.get("message", result.get("commit_message", "")),
-                code_diff=result.get("code_diff"),
-                repository=commit.get("repository", result.get("repository", "")),
-                detected_patterns=result.get("patterns_detected", []),
-                detection_method=result.get("detection_method", "keyword"),
-                validation_status="pending",
-            )
-            samples.append(sample)
-
-        self.samples = samples
-        return samples
-
-    def _stratified_sample_by_pattern(self, results: List[Dict], sample_size: int) -> List[Dict]:
-        # Stratified sampling ensuring each pattern category is represented.
-        # Group by dominant pattern
-        pattern_groups = defaultdict(list)
-        for result in results:
-            patterns = result.get("patterns_detected", [])
-            if patterns:
-                # Use first pattern as primary
-                primary_pattern = patterns[0]
-                pattern_groups[primary_pattern].append(result)
-
-        # Calculate samples per pattern (proportional)
-        total = len(results)
-        samples = []
-
-        for pattern, group in pattern_groups.items():
-            proportion = len(group) / total
-            pattern_sample_size = max(1, int(sample_size * proportion))
-            pattern_samples = random.sample(group, min(pattern_sample_size, len(group)))
-            samples.extend(pattern_samples)
-
-        # If we have fewer than sample_size, add random extras
-        if len(samples) < sample_size and len(samples) < len(results):
-            remaining = [r for r in results if r not in samples]
-            extra_needed = min(sample_size - len(samples), len(remaining))
-            samples.extend(random.sample(remaining, extra_needed))
-
-        return samples[:sample_size]
-
-    def _stratified_sample_by_repo(
-        self, results: List[Dict], commit_lookup: Dict, sample_size: int
-    ) -> List[Dict]:
-        # Stratified sampling ensuring each repository is represented.
-        # Group by repository
-        repo_groups = defaultdict(list)
-        for result in results:
-            commit_sha = result.get("commit_sha")
-            commit = commit_lookup.get(commit_sha, {})
-            repo = commit.get("repository", result.get("repository", "unknown"))
-            repo_groups[repo].append(result)
-
-        # Sample proportionally from each repo
-        samples = []
-        total = len(results)
-
-        for repo, group in repo_groups.items():
-            proportion = len(group) / total
-            repo_sample_size = max(1, int(sample_size * proportion))
-            repo_samples = random.sample(group, min(repo_sample_size, len(group)))
-            samples.extend(repo_samples)
-
-        return samples[:sample_size]
-
-    def export_samples_for_review(self, output_path: str) -> None:
-        # Export validation samples to JSON for manual review.
-        samples_data = []
-        for i, sample in enumerate(self.samples, 1):
-            samples_data.append(
-                {
-                    "sample_id": i,
-                    "commit_sha": sample.commit_sha,
-                    "repository": sample.repository,
-                    "commit_message": sample.commit_message,
-                    "detected_patterns": sample.detected_patterns,
-                    "detection_method": sample.detection_method,
-                    "code_diff_preview": sample.code_diff[:500] if sample.code_diff else None,
-                    "validation_status": sample.validation_status,
-                    "true_label": sample.true_label,
-                    "reviewer": sample.reviewer,
-                    "review_notes": sample.review_notes,
-                    "___INSTRUCTIONS___": "Set true_label to true/false, add reviewer name, add review_notes",
-                }
-            )
-
-        with open(output_path, "w") as f:
-            json.dump(samples_data, f, indent=2)
-
-    def import_validated_samples(self, input_path: str) -> None:
-        # Import manually validated samples from JSON.
-        with open(input_path, "r") as f:
-            samples_data = json.load(f)
-
-        # Update samples with validation results
-        for data in samples_data:
-            commit_sha = data["commit_sha"]
-
-            # Find matching sample
-            for sample in self.samples:
-                if sample.commit_sha == commit_sha:
-                    sample.true_label = data.get("true_label")
-                    sample.reviewer = data.get("reviewer")
-                    sample.review_notes = data.get("review_notes")
-                    sample.validation_status = (
-                        "validated" if sample.true_label is not None else "pending"
-                    )
-                    break
-
-    def calculate_metrics(self) -> ValidationMetrics:
-        # Calculate precision, recall, F1, and accuracy.
-        # Count outcomes
-        tp = 0  # True positive: detected as green, truly green
-        fp = 0  # False positive: detected as green, not green
-        tn = 0  # True negative: not detected, truly not green
-        fn = 0  # False negative: not detected, but is green
-
-        for sample in self.samples:
-            if sample.true_label is None:
-                continue  # Skip unvalidated samples
-
-            detected_as_green = len(sample.detected_patterns) > 0
-            truly_green = sample.true_label
-
-            if detected_as_green and truly_green:
-                tp += 1
-            elif detected_as_green and not truly_green:
-                fp += 1
-            elif not detected_as_green and not truly_green:
-                tn += 1
-            elif not detected_as_green and truly_green:
-                fn += 1
-
-        # Calculate metrics
-        total = tp + fp + tn + fn
-        precision = tp / (tp + fp) if (tp + fp) > 0 else 0
-        recall = tp / (tp + fn) if (tp + fn) > 0 else 0
-        f1 = 2 * (precision * recall) / (precision + recall) if (precision + recall) > 0 else 0
-        accuracy = (tp + tn) / total if total > 0 else 0
-
-        return ValidationMetrics(
-            true_positives=tp,
-            false_positives=fp,
-            true_negatives=tn,
-            false_negatives=fn,
-            precision=round(precision, 4),
-            recall=round(recall, 4),
-            f1_score=round(f1, 4),
-            accuracy=round(accuracy, 4),
-        )
-
-    def get_validation_report(self) -> Dict:
-        # Generate comprehensive validation report.
-        validated_count = sum(1 for s in self.samples if s.validation_status == "validated")
-        pending_count = sum(1 for s in self.samples if s.validation_status == "pending")
-
-        metrics = self.calculate_metrics() if validated_count > 0 else None
-
-        # Analyze false positives and false negatives
-        false_positives = [
-            {
-                "commit_sha": s.commit_sha,
-                "detected_patterns": s.detected_patterns,
-                "review_notes": s.review_notes,
-            }
-            for s in self.samples
-            if s.true_label is not None and len(s.detected_patterns) > 0 and not s.true_label
-        ]
-
-        false_negatives = [
-            {
-                "commit_sha": s.commit_sha,
-                "commit_message": s.commit_message[:100],
-                "review_notes": s.review_notes,
-            }
-            for s in self.samples
-            if s.true_label is not None and len(s.detected_patterns) == 0 and s.true_label
-        ]
-
-        # Pattern accuracy breakdown
-        pattern_accuracy = self._analyze_pattern_accuracy()
-
-        return {
-            "sampling": {
-                "total_samples": len(self.samples),
-                "validated_samples": validated_count,
-                "pending_samples": pending_count,
-                "validation_progress": (
-                    round(validated_count / len(self.samples) * 100, 1) if self.samples else 0
-                ),
-                "stratification_method": self.stratify_by,
-            },
-            "metrics": {
-                "precision": metrics.precision if metrics else None,
-                "recall": metrics.recall if metrics else None,
-                "f1_score": metrics.f1_score if metrics else None,
-                "accuracy": metrics.accuracy if metrics else None,
-                "true_positives": metrics.true_positives if metrics else None,
-                "false_positives": metrics.false_positives if metrics else None,
-                "true_negatives": metrics.true_negatives if metrics else None,
-                "false_negatives": metrics.false_negatives if metrics else None,
-            },
-            "error_analysis": {
-                "false_positive_count": len(false_positives),
-                "false_negative_count": len(false_negatives),
-                "false_positives": false_positives[:5],  # Top 5
-                "false_negatives": false_negatives[:5],  # Top 5
-            },
-            "pattern_accuracy": pattern_accuracy,
-        }
-
-    def _analyze_pattern_accuracy(self) -> Dict:
-        # Analyze accuracy per pattern category.
-        pattern_stats = defaultdict(lambda: {"tp": 0, "fp": 0})
-
-        for sample in self.samples:
-            if sample.true_label is None:
-                continue
-
-            for pattern in sample.detected_patterns:
-                if sample.true_label:
-                    pattern_stats[pattern]["tp"] += 1
-                else:
-                    pattern_stats[pattern]["fp"] += 1
-
-        # Calculate precision per pattern
-        pattern_accuracy = {}
-        for pattern, stats in pattern_stats.items():
-            total = stats["tp"] + stats["fp"]
-            precision = stats["tp"] / total if total > 0 else 0
-            pattern_accuracy[pattern] = {
-                "true_positives": stats["tp"],
-                "false_positives": stats["fp"],
-                "precision": round(precision, 4),
-            }
-
-        return pattern_accuracy
-
-    def get_inter_rater_reliability(
-        self,
-        samples_from_reviewer_a: List[ValidationSample],
-        samples_from_reviewer_b: List[ValidationSample],
-    ) -> Dict:
-        # Calculate inter-rater reliability (Cohen's Kappa).
-        # Match samples by commit_sha
-        matched_samples = []
-        for sample_a in samples_from_reviewer_a:
-            for sample_b in samples_from_reviewer_b:
-                if sample_a.commit_sha == sample_b.commit_sha:
-                    matched_samples.append((sample_a, sample_b))
-                    break
-
-        if not matched_samples:
-            return {"error": "No matching samples between reviewers"}
-
-        # Calculate agreement
-        agreements = 0
-        for sample_a, sample_b in matched_samples:
-            if sample_a.true_label == sample_b.true_label:
-                agreements += 1
-
-        observed_agreement = agreements / len(matched_samples)
-
-        # Calculate expected agreement (by chance)
-        a_positive = sum(1 for s, _ in matched_samples if s.true_label)
-        b_positive = sum(1 for _, s in matched_samples if s.true_label)
-        n = len(matched_samples)
-
-        p_a_yes = a_positive / n
-        p_b_yes = b_positive / n
-        expected_agreement = (p_a_yes * p_b_yes) + ((1 - p_a_yes) * (1 - p_b_yes))
-
-        # Cohen's Kappa
-        kappa = (
-            (observed_agreement - expected_agreement) / (1 - expected_agreement)
-            if expected_agreement < 1
-            else 1
-        )
-
-        return {
-            "cohens_kappa": round(kappa, 4),
-            "observed_agreement": round(observed_agreement, 4),
-            "expected_agreement": round(expected_agreement, 4),
-            "sample_count": n,
-            "interpretation": self._interpret_kappa(kappa),
-        }
-
-    def _interpret_kappa(self, kappa: float) -> str:
-        # Interpret Cohen's Kappa value.
-        if kappa < 0:
-            return "Poor (less than chance)"
-        elif kappa < 0.20:
-            return "Slight"
-        elif kappa < 0.40:
-            return "Fair"
-        elif kappa < 0.60:
-            return "Moderate"
-        elif kappa < 0.80:
-            return "Substantial"
-        else:
-            return "Almost perfect"