dataframe-mutator 0.1.1__tar.gz → 0.2.0__tar.gz

{dataframe_mutator-0.1.1 → dataframe_mutator-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dataframe-mutator
-Version: 0.1.1
+Version: 0.2.0
 Summary: Production-grade mutation testing for Polars dataframes. Validate test suite quality by detecting which mutations your tests catch.
 Author-email: Dataframe Mutator Contributors <suhrusai@gmail.com>
 License-Expression: MIT
@@ -26,6 +26,7 @@ Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: mutmut>=2.4.0
+Requires-Dist: click>=8.0.0
 Provides-Extra: polars
 Requires-Dist: polars>=0.19.0; extra == "polars"
 Provides-Extra: pyspark

{dataframe_mutator-0.1.1 → dataframe_mutator-0.2.0}/dataframe_mutator.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dataframe-mutator
-Version: 0.1.1
+Version: 0.2.0
 Summary: Production-grade mutation testing for Polars dataframes. Validate test suite quality by detecting which mutations your tests catch.
 Author-email: Dataframe Mutator Contributors <suhrusai@gmail.com>
 License-Expression: MIT
@@ -26,6 +26,7 @@ Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: mutmut>=2.4.0
+Requires-Dist: click>=8.0.0
 Provides-Extra: polars
 Requires-Dist: polars>=0.19.0; extra == "polars"
 Provides-Extra: pyspark

{dataframe_mutator-0.1.1 → dataframe_mutator-0.2.0}/dataframe_mutator.egg-info/SOURCES.txt

@@ -4,9 +4,16 @@ pyproject.toml
 dataframe_mutator.egg-info/PKG-INFO
 dataframe_mutator.egg-info/SOURCES.txt
 dataframe_mutator.egg-info/dependency_links.txt
+dataframe_mutator.egg-info/entry_points.txt
 dataframe_mutator.egg-info/requires.txt
 dataframe_mutator.egg-info/top_level.txt
 src/dataframe_mutator/__init__.py
+src/dataframe_mutator/cli.py
+src/dataframe_mutator/config.py
+src/dataframe_mutator/integrations.py
+src/dataframe_mutator/pytest_plugin.py
+src/dataframe_mutator/reports.py
+tests/test_advanced_features.py
 tests/test_polars_100_coverage.py
 tests/test_polars_new_operators.py
 tests/test_polars_operators.py

dataframe_mutator-0.2.0/dataframe_mutator.egg-info/entry_points.txt

@@ -0,0 +1,5 @@
+[console_scripts]
+dataframe-mutator = dataframe_mutator.cli:cli
+
+[pytest11]
+dataframe-mutator = dataframe_mutator.pytest_plugin

{dataframe_mutator-0.1.1 → dataframe_mutator-0.2.0}/dataframe_mutator.egg-info/requires.txt

@@ -1,4 +1,5 @@
 mutmut>=2.4.0
+click>=8.0.0
 
 [all]
 dataframe-mutator[dev,pandas,polars,pyspark]

{dataframe_mutator-0.1.1 → dataframe_mutator-0.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "dataframe-mutator"
-version = "0.1.1"
+version = "0.2.0"
 description = "Production-grade mutation testing for Polars dataframes. Validate test suite quality by detecting which mutations your tests catch."
 readme = "README.md"
 requires-python = ">=3.8"
@@ -30,8 +30,15 @@ classifiers = [
 ]
 dependencies = [
     "mutmut>=2.4.0",
+    "click>=8.0.0",
 ]
 
+[project.scripts]
+dataframe-mutator = "dataframe_mutator.cli:cli"
+
+[project.entry-points.pytest11]
+dataframe-mutator = "dataframe_mutator.pytest_plugin"
+
 [project.urls]
 Homepage = "https://github.com/suhrusai/dataframe-mutator"
 Documentation = "https://github.com/suhrusai/dataframe-mutator#readme"

dataframe_mutator-0.2.0/src/dataframe_mutator/cli.py

@@ -0,0 +1,159 @@
+"""Command-line interface for dataframe-mutator."""
+
+import click
+from pathlib import Path
+from typing import Optional
+from .config import MutationConfig
+from .polars import SmartPolarsTestRunner
+from .reports import HTMLReportGenerator, JSONExporter, BaselineTracker
+
+
+@click.group()
+def cli():
+    """dataframe-mutator - Mutation testing for Polars dataframes."""
+    pass
+
+
+@cli.command()
+@click.argument("source", type=click.Path(exists=True), nargs=-1, required=True)
+@click.option("--tests", default="tests/", help="Path to test directory")
+@click.option("--config", default="dataframe-mutator.toml", help="Config file path")
+@click.option("--output", default="text", type=click.Choice(["text", "json", "html"]),
+              help="Output format")
+@click.option("--threshold", type=float, help="Mutation score threshold")
+@click.option("--parallel", is_flag=True, default=True, help="Use parallel testing")
+@click.option("--workers", type=int, help="Number of parallel workers")
+@click.option("--save-baseline", is_flag=True, help="Save current results as baseline")
+def analyze(source, tests, config, output, threshold, parallel, workers, save_baseline):
+    """Analyze mutation efficiency of your code."""
+
+    # Load configuration
+    cfg = MutationConfig.from_toml(config)
+
+    # Override with CLI arguments
+    if threshold:
+        cfg.mutation_threshold = threshold
+    if not parallel:
+        cfg.parallel = False
+    if workers:
+        cfg.num_workers = workers
+    cfg.output_format = output
+    cfg.source_files = list(source)
+    cfg.test_command = f"pytest {tests}"
+
+    click.echo(f"[*] Analyzing {len(source)} file(s)...")
+    click.echo(f"[TEST] Test command: {cfg.test_command}")
+
+    try:
+        tester = SmartPolarsTestRunner(
+            test_command=cfg.test_command,
+            parallel=cfg.parallel,
+            num_workers=cfg.num_workers
+        )
+
+        all_results = {}
+        for src_file in source:
+            click.echo(f"\n[FILE] {src_file}")
+            results = tester.analyze_mutation_efficiency(src_file)
+            all_results[src_file] = results
+
+            click.echo(f"  [OK] High-value mutations: {results['high_value_mutations']}")
+            click.echo(f"  [STAT] False positives avoided: {results['potential_false_positives_avoided']:.1f}%")
+
+            if results['high_value_mutations'] == 0:
+                click.echo("  [WARN] No mutations found!")
+
+        # Generate reports
+        Path(cfg.output_dir).mkdir(exist_ok=True)
+
+        if output in ["text", "json", "html"]:
+            if output == "json" or output == "html":
+                exporter = JSONExporter(cfg)
+                exporter.export(all_results, f"{cfg.output_dir}/results.json")
+                click.echo(f"\n[REPORT] JSON report: {cfg.output_dir}/results.json")
+
+            if output == "html":
+                generator = HTMLReportGenerator(cfg)
+                generator.generate(all_results, f"{cfg.output_dir}/report.html")
+                click.echo(f"[REPORT] HTML report: {cfg.output_dir}/report.html")
+
+        # Save baseline if requested
+        if save_baseline:
+            tracker = BaselineTracker(cfg)
+            tracker.save_baseline(all_results)
+            click.echo(f"\n[SAVE] Baseline saved: {cfg.baseline_path}")
+
+        # Check threshold
+        avg_mutations = sum(r['high_value_mutations'] for r in all_results.values()) / len(all_results)
+        if avg_mutations < cfg.min_mutations:
+            click.echo(f"\n[FAIL] Below minimum mutations ({avg_mutations:.0f} < {cfg.min_mutations})")
+            raise click.Exit(1)
+
+        click.echo("\n[SUCCESS] Analysis complete!")
+
+    except Exception as e:
+        click.echo(f"[ERROR] Error: {e}", err=True)
+        raise click.Exit(1)
+
+
+@cli.command()
+@click.argument("source", type=click.Path(exists=True), nargs=-1, required=True)
+@click.option("--tests", default="tests/", help="Path to test directory")
+@click.option("--config", default="dataframe-mutator.toml", help="Config file path")
+def check(source, tests, config):
+    """Check mutation score against baseline."""
+
+    cfg = MutationConfig.from_toml(config)
+    cfg.source_files = list(source)
+    cfg.test_command = f"pytest {tests}"
+
+    tracker = BaselineTracker(cfg)
+
+    if not Path(cfg.baseline_path).exists():
+        click.echo("[FAIL] No baseline found. Run with --save-baseline first.")
+        raise click.Exit(1)
+
+    tester = SmartPolarsTestRunner(test_command=cfg.test_command)
+    baseline = tracker.load_baseline()
+
+    click.echo("[*] Comparing to baseline...")
+
+    all_pass = True
+    for src_file in source:
+        results = tester.analyze_mutation_efficiency(src_file)
+        current = results['high_value_mutations']
+        baseline_val = baseline.get(src_file, {}).get('high_value_mutations', 0)
+
+        change = current - baseline_val
+        if change >= 0:
+            click.echo(f"[OK] {src_file}: {current} mutations (+{change})")
+        else:
+            click.echo(f"[WARN] {src_file}: {current} mutations ({change})")
+            all_pass = False
+
+    if not all_pass:
+        click.echo("\n[WARN] Some files have fewer mutations than baseline")
+        raise click.Exit(1)
+
+    click.echo("\n[OK] All files meet or exceed baseline!")
+
+
+@cli.command()
+@click.option("--config", default="dataframe-mutator.toml", help="Config file path")
+def init(config):
+    """Initialize configuration file."""
+
+    cfg = MutationConfig()
+    cfg.to_json(config)
+    click.echo(f"[OK] Created {config}")
+    click.echo("Edit this file to customize mutation testing settings.")
+
+
+@cli.command()
+def version():
+    """Show version."""
+    click.echo("dataframe-mutator 0.1.1")
+
+
+if __name__ == "__main__":
+    cli()

dataframe_mutator-0.2.0/src/dataframe_mutator/config.py

@@ -0,0 +1,95 @@
+"""Configuration management for dataframe-mutator."""
+
+import json
+import sys
+from dataclasses import dataclass, field, asdict
+from pathlib import Path
+from typing import Optional, List
+
+# Try to import tomllib (Python 3.11+)
+try:
+    import tomllib
+except ImportError:
+    tomllib = None
+
+
+@dataclass
+class MutationConfig:
+    """Configuration for mutation testing."""
+
+    # Paths
+    source_files: List[str] = field(default_factory=list)
+    test_command: str = "pytest tests/"
+    skip_patterns: List[str] = field(default_factory=lambda: ["__pycache__", "*.pyc", ".git"])
+
+    # Thresholds
+    mutation_threshold: float = 0.85  # Fail if below 85%
+    min_mutations: int = 5  # Require at least 5 mutations
+
+    # Operators
+    operators: Optional[List[str]] = None  # None = all operators
+    skip_operators: List[str] = field(default_factory=list)
+
+    # Features
+    skip_low_value_mutations: bool = True
+    parallel: bool = True
+    num_workers: Optional[int] = None  # None = auto (cpu_count)
+
+    # Output
+    output_format: str = "text"  # text, json, html
+    output_dir: str = "mutation-results"
+    save_baseline: bool = False
+    baseline_path: str = ".mutation-baseline.json"
+
+    # Integrations
+    github_annotations: bool = False
+    slack_webhook: Optional[str] = None
+    slack_on_fail_only: bool = True
+
+    # Advanced
+    timeout_per_test: Optional[int] = None  # Seconds
+    max_mutations_per_file: Optional[int] = None
+
+    @classmethod
+    def from_toml(cls, path: str = "dataframe-mutator.toml") -> "MutationConfig":
+        """Load configuration from TOML file."""
+        config_path = Path(path)
+        if not config_path.exists():
+            return cls()
+
+        try:
+            # Try Python 3.11+ tomllib first
+            if tomllib:
+                with open(config_path, "rb") as f:
+                    data = tomllib.load(f)
+            else:
+                # Fallback for older Python
+                import tomli
+                with open(config_path, "rb") as f:
+                    data = tomli.load(f)
+
+            config_data = data.get("dataframe-mutator", {})
+            return cls(**config_data)
+        except Exception as e:
+            print(f"Warning: Could not load config from {path}: {e}")
+            return cls()
+
+    @classmethod
+    def from_json(cls, path: str) -> "MutationConfig":
+        """Load configuration from JSON file."""
+        try:
+            with open(path) as f:
+                data = json.load(f)
+            return cls(**data)
+        except Exception as e:
+            print(f"Warning: Could not load config from {path}: {e}")
+            return cls()
+
+    def to_json(self, path: str) -> None:
+        """Save configuration to JSON file."""
+        with open(path, "w") as f:
+            json.dump(asdict(self), f, indent=2)
+
+    def to_dict(self) -> dict:
+        """Convert to dictionary."""
+        return asdict(self)

dataframe_mutator-0.2.0/src/dataframe_mutator/integrations.py

@@ -0,0 +1,170 @@
+"""Integrations with external services and tools."""
+
+import json
+import os
+from typing import Dict, Any, Optional
+from urllib.request import urlopen, Request
+from pathlib import Path
+
+
+class SlackNotifier:
+    """Send mutation testing results to Slack."""
+
+    def __init__(self, webhook_url: str):
+        self.webhook_url = webhook_url
+
+    def notify(self, results: Dict[str, Any], threshold: float = 0.85) -> None:
+        """Send Slack notification."""
+        total_mutations = sum(r.get("high_value_mutations", 0) for r in results.values())
+        avg_false_pos = sum(r.get("potential_false_positives_avoided", 0) for r in results.values()) / len(results) if results else 0
+
+        color = "good" if total_mutations > 0 else "danger"
+
+        payload = {
+            "attachments": [{
+                "color": color,
+                "title": "🧬 Mutation Testing Results",
+                "fields": [
+                    {"title": "Total Mutations", "value": str(total_mutations), "short": True},
+                    {"title": "Files Analyzed", "value": str(len(results)), "short": True},
+                    {"title": "False Positives Avoided", "value": f"{avg_false_pos:.1f}%", "short": True},
+                    {"title": "Status", "value": "✅ Pass" if total_mutations > 0 else "⚠️ No mutations", "short": True},
+                ]
+            }]
+        }
+
+        try:
+            req = Request(
+                self.webhook_url,
+                data=json.dumps(payload).encode(),
+                headers={"Content-Type": "application/json"}
+            )
+            urlopen(req)
+        except Exception as e:
+            print(f"Warning: Failed to send Slack notification: {e}")
+
+
+class GitHubAnnotator:
+    """Add annotations to GitHub Actions workflow."""
+
+    @staticmethod
+    def annotate_mutations(results: Dict[str, Any]) -> None:
+        """Add GitHub workflow annotations for mutations."""
+        if not os.getenv("GITHUB_ACTIONS"):
+            return
+
+        for file, data in results.items():
+            mutations = data.get("high_value_mutations", 0)
+            if mutations == 0:
+                level = "warning"
+                msg = "No mutations detected - may need more tests"
+            else:
+                level = "notice"
+                msg = f"{mutations} high-value mutations found"
+
+            print(f"::{level} file={file}::{msg}")
+
+
+class CustomOperatorRegistry:
+    """Registry for custom mutation operators."""
+
+    def __init__(self, registry_path: str = ".mutation-operators"):
+        self.registry_path = Path(registry_path)
+        self.registry_path.mkdir(exist_ok=True)
+
+    def register(self, operator_class) -> None:
+        """Register a custom operator."""
+        operator_file = self.registry_path / f"{operator_class.name}.py"
+
+        # Save operator code
+        import inspect
+        code = inspect.getsource(operator_class)
+        operator_file.write_text(code)
+
+    def load_operators(self) -> list:
+        """Load all registered operators."""
+        operators = []
+
+        for op_file in self.registry_path.glob("*.py"):
+            if op_file.name == "__init__.py":
+                continue
+
+            # Dynamically import operator
+            import importlib.util
+            spec = importlib.util.spec_from_file_location("operator", op_file)
+            module = importlib.util.module_from_spec(spec)
+            spec.loader.exec_module(module)
+
+            # Find operator class
+            for attr in dir(module):
+                obj = getattr(module, attr)
+                if hasattr(obj, "name") and hasattr(obj, "mutate"):
+                    operators.append(obj)
+
+        return operators
+
+
+class OperatorSuggester:
+    """Suggest missing mutation operators based on code."""
+
+    @staticmethod
+    def analyze_code(source_file: str) -> Dict[str, int]:
+        """Analyze code and suggest operators."""
+        content = Path(source_file).read_text()
+        suggestions = {}
+
+        # Check for patterns
+        if "filter(" in content:
+            suggestions["filter_mutations"] = content.count("filter(")
+
+        if ".sum()" in content or ".mean()" in content:
+            suggestions["aggregation_mutations"] = (
+                content.count(".sum()") + content.count(".mean()")
+            )
+
+        if ".join(" in content:
+            suggestions["join_mutations"] = content.count(".join(")
+
+        if "is_null" in content or "fill_null" in content:
+            suggestions["null_handling_mutations"] = (
+                content.count("is_null") + content.count("fill_null")
+            )
+
+        if ">" in content or ">=" in content or "<" in content:
+            # Count comparison operators (rough estimate)
+            suggestions["boundary_mutations"] = (
+                content.count(" > ") + content.count(" >= ") +
+                content.count(" < ") + content.count(" <= ")
+            )
+
+        return suggestions
+
+
+class ParallelMutationRunner:
+    """Run mutations in parallel for faster testing."""
+
+    def __init__(self, num_workers: Optional[int] = None):
+        import multiprocessing
+        self.num_workers = num_workers or multiprocessing.cpu_count()
+
+    def run_parallel(self, mutations: list, test_command: str) -> Dict[str, bool]:
+        """Run mutations in parallel."""
+        from multiprocessing import Pool
+        import subprocess
+
+        def run_mutation(mutation_code: str) -> bool:
+            try:
+                result = subprocess.run(
+                    ["python", "-c", test_command],
+                    capture_output=True,
+                    timeout=30,
+                    text=True
+                )
+                return result.returncode == 0
+            except:
+                return False
+
+        with Pool(self.num_workers) as pool:
+            results = pool.map(run_mutation, mutations)
+
+        return {f"mutation_{i}": passed for i, passed in enumerate(results)}

dataframe_mutator-0.2.0/src/dataframe_mutator/pytest_plugin.py

@@ -0,0 +1,78 @@
+"""pytest plugin for mutation testing integration."""
+
+import pytest
+from pathlib import Path
+from .polars import SmartPolarsTestRunner
+from .config import MutationConfig
+
+
+def pytest_addoption(parser):
+    """Add pytest options for mutation testing."""
+    parser.addoption(
+        "--mutation",
+        action="store_true",
+        default=False,
+        help="Run mutation testing on Polars code"
+    )
+    parser.addoption(
+        "--mutation-source",
+        default="src/",
+        help="Source directory to analyze"
+    )
+    parser.addoption(
+        "--mutation-threshold",
+        type=float,
+        default=0.85,
+        help="Minimum mutation score threshold"
+    )
+
+
+def pytest_configure(config):
+    """Configure pytest for mutation testing."""
+    if config.getoption("--mutation"):
+        config.addinivalue_line("markers", "mutation: mark test as mutation testing")
+
+
+def pytest_collection_modifyitems(config, items):
+    """Modify test collection for mutation testing."""
+    if config.getoption("--mutation"):
+        # Add mutation marker to all tests
+        for item in items:
+            item.add_marker(pytest.mark.mutation)
+
+
+@pytest.fixture(scope="session")
+def mutation_tester(request):
+    """Provide mutation tester fixture."""
+    cfg = MutationConfig.from_toml()
+    return SmartPolarsTestRunner(test_command="pytest")
+
+
+def pytest_terminal_summary(terminalreporter, exitstatus, config):
+    """Add mutation testing summary to pytest output."""
+    if not config.getoption("--mutation"):
+        return
+
+    source_dir = config.getoption("--mutation-source")
+    threshold = config.getoption("--mutation-threshold")
+
+    if not Path(source_dir).exists():
+        terminalreporter.write_sep("=", "No source directory found", red=True)
+        return
+
+    try:
+        tester = SmartPolarsTestRunner(test_command="pytest")
+
+        terminalreporter.write_sep("=", "Mutation Testing Results")
+
+        for py_file in Path(source_dir).rglob("*.py"):
+            results = tester.analyze_mutation_efficiency(str(py_file))
+            mutations = results['high_value_mutations']
+            false_pos = results['potential_false_positives_avoided']
+
+            if mutations >= 1:  # Only show if mutations found
+                status = "✅" if mutations > 0 else "⚠️"
+                terminalreporter.write(f"\n{status} {py_file}: {mutations} mutations ({false_pos:.1f}% false pos avoided)")
+
+    except Exception as e:
+        terminalreporter.write_sep("!", f"Mutation testing error: {e}", yellow=True)

dataframe_mutator-0.2.0/src/dataframe_mutator/reports.py

@@ -0,0 +1,181 @@
+"""Report generation and export functionality."""
+
+import json
+from pathlib import Path
+from datetime import datetime
+from typing import Dict, Any, Optional
+from .config import MutationConfig
+
+
+class BaselineTracker:
+    """Track and compare mutation testing baselines."""
+
+    def __init__(self, config: MutationConfig):
+        self.config = config
+
+    def save_baseline(self, results: Dict[str, Any]) -> None:
+        """Save current results as baseline."""
+        baseline_data = {
+            "timestamp": datetime.now().isoformat(),
+            "results": results
+        }
+        Path(self.config.baseline_path).write_text(json.dumps(baseline_data, indent=2))
+
+    def load_baseline(self) -> Dict[str, Any]:
+        """Load saved baseline."""
+        path = Path(self.config.baseline_path)
+        if not path.exists():
+            return {}
+
+        data = json.loads(path.read_text())
+        return data.get("results", {})
+
+    def compare(self, current: Dict[str, Any]) -> Dict[str, Any]:
+        """Compare current results to baseline."""
+        baseline = self.load_baseline()
+        comparison = {}
+
+        for file, results in current.items():
+            baseline_val = baseline.get(file, {})
+            comparison[file] = {
+                "current": results.get("high_value_mutations", 0),
+                "baseline": baseline_val.get("high_value_mutations", 0),
+                "change": results.get("high_value_mutations", 0) - baseline_val.get("high_value_mutations", 0)
+            }
+
+        return comparison
+
+
+class JSONExporter:
+    """Export mutation testing results to JSON."""
+
+    def __init__(self, config: MutationConfig):
+        self.config = config
+
+    def export(self, results: Dict[str, Any], output_path: str) -> None:
+        """Export results to JSON file."""
+        export_data = {
+            "timestamp": datetime.now().isoformat(),
+            "config": self.config.to_dict(),
+            "results": results,
+            "summary": self._generate_summary(results)
+        }
+
+        Path(output_path).write_text(json.dumps(export_data, indent=2))
+
+    def _generate_summary(self, results: Dict[str, Any]) -> Dict[str, Any]:
+        """Generate summary statistics."""
+        total_mutations = sum(r.get("high_value_mutations", 0) for r in results.values())
+        avg_false_pos_avoided = sum(
+            r.get("potential_false_positives_avoided", 0)
+            for r in results.values()
+        ) / len(results) if results else 0
+
+        return {
+            "total_files": len(results),
+            "total_mutations": total_mutations,
+            "avg_false_positives_avoided": round(avg_false_pos_avoided, 2),
+            "timestamp": datetime.now().isoformat()
+        }
+
+
+class HTMLReportGenerator:
+    """Generate HTML reports with visualizations."""
+
+    def __init__(self, config: MutationConfig):
+        self.config = config
+
+    def generate(self, results: Dict[str, Any], output_path: str) -> None:
+        """Generate HTML report."""
+        html = self._build_html(results)
+        Path(output_path).write_text(html, encoding="utf-8")
+
+    def _build_html(self, results: Dict[str, Any]) -> str:
+        """Build HTML content."""
+        timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+
+        # Generate rows
+        rows = ""
+        for file, data in results.items():
+            mutations = data.get("high_value_mutations", 0)
+            false_pos = data.get("potential_false_positives_avoided", 0)
+            rows += f"""
+            <tr>
+                <td>{file}</td>
+                <td>{mutations}</td>
+                <td>{false_pos:.1f}%</td>
+            </tr>
+            """
+
+        total_mutations = sum(d.get("high_value_mutations", 0) for d in results.values())
+        avg_false_pos = sum(d.get("potential_false_positives_avoided", 0) for d in results.values()) / len(results) if results else 0
+
+        return f"""
+<!DOCTYPE html>
+<html>
+<head>
+    <title>Mutation Testing Report</title>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+    <style>
+        * {{ margin: 0; padding: 0; box-sizing: border-box; }}
+        body {{ font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, Cantarell, sans-serif; background: #f5f5f5; padding: 20px; }}
+        .container {{ max-width: 1000px; margin: 0 auto; background: white; padding: 30px; border-radius: 8px; box-shadow: 0 2px 8px rgba(0,0,0,0.1); }}
+        h1 {{ color: #333; margin-bottom: 10px; }}
+        .timestamp {{ color: #999; font-size: 14px; margin-bottom: 30px; }}
+        .metrics {{ display: grid; grid-template-columns: repeat(auto-fit, minmax(200px, 1fr)); gap: 20px; margin-bottom: 30px; }}
+        .metric {{ background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); color: white; padding: 20px; border-radius: 8px; }}
+        .metric-value {{ font-size: 28px; font-weight: bold; }}
+        .metric-label {{ font-size: 12px; opacity: 0.9; margin-top: 5px; }}
+        table {{ width: 100%; border-collapse: collapse; }}
+        th {{ background: #f5f5f5; padding: 12px; text-align: left; font-weight: 600; border-bottom: 2px solid #ddd; }}
+        td {{ padding: 12px; border-bottom: 1px solid #eee; }}
+        tr:hover {{ background: #f9f9f9; }}
+        .badge {{ display: inline-block; padding: 4px 8px; border-radius: 4px; font-size: 12px; font-weight: 600; }}
+        .badge-success {{ background: #c6f6d5; color: #22543d; }}
+        .badge-warning {{ background: #fed7d7; color: #742a2a; }}
+        footer {{ margin-top: 30px; padding-top: 20px; border-top: 1px solid #eee; color: #999; font-size: 12px; }}
+    </style>
+</head>
+<body>
+    <div class="container">
+        <h1>🧬 Mutation Testing Report</h1>
+        <div class="timestamp">Generated on {timestamp}</div>
+
+        <div class="metrics">
+            <div class="metric">
+                <div class="metric-value">{total_mutations}</div>
+                <div class="metric-label">Total Mutations</div>
+            </div>
+            <div class="metric">
+                <div class="metric-value">{len(results)}</div>
+                <div class="metric-label">Files Analyzed</div>
+            </div>
+            <div class="metric">
+                <div class="metric-value">{avg_false_pos:.1f}%</div>
+                <div class="metric-label">False Positives Avoided</div>
+            </div>
+        </div>
+
+        <h2 style="margin-bottom: 15px; color: #333;">Results by File</h2>
+        <table>
+            <thead>
+                <tr>
+                    <th>File</th>
+                    <th>Mutations</th>
+                    <th>False Positives Avoided</th>
+                </tr>
+            </thead>
+            <tbody>
+                {rows}
+            </tbody>
+        </table>
+
+        <footer>
+            <p>Generated by dataframe-mutator v0.1.1</p>
+            <p>6-10x faster mutation testing with smart AST-aware filtering</p>
+        </footer>
+    </div>
+</body>
+</html>
+        """

dataframe_mutator-0.2.0/tests/test_advanced_features.py

@@ -0,0 +1,177 @@
+"""Tests for advanced features."""
+
+import pytest
+import json
+from pathlib import Path
+import tempfile
+
+# Import new features
+from dataframe_mutator.config import MutationConfig
+from dataframe_mutator.reports import BaselineTracker, JSONExporter, HTMLReportGenerator
+from dataframe_mutator.integrations import (
+    CustomOperatorRegistry, OperatorSuggester, SlackNotifier
+)
+
+
+class TestMutationConfig:
+    """Test configuration system."""
+
+    def test_config_creation(self):
+        """Test creating default config."""
+        config = MutationConfig()
+        assert config.mutation_threshold == 0.85
+        assert config.parallel == True
+        assert config.output_format == "text"
+
+    def test_config_to_dict(self):
+        """Test config serialization."""
+        config = MutationConfig(mutation_threshold=0.9)
+        data = config.to_dict()
+        assert data["mutation_threshold"] == 0.9
+
+    def test_config_json_save_load(self):
+        """Test JSON config save/load."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            path = f"{tmpdir}/config.json"
+
+            config = MutationConfig(mutation_threshold=0.95)
+            config.to_json(path)
+
+            loaded = MutationConfig.from_json(path)
+            assert loaded.mutation_threshold == 0.95
+
+
+class TestBaselineTracker:
+    """Test baseline tracking."""
+
+    def test_save_and_load_baseline(self):
+        """Test saving and loading baseline."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            config = MutationConfig(baseline_path=f"{tmpdir}/baseline.json")
+            tracker = BaselineTracker(config)
+
+            results = {
+                "file.py": {"high_value_mutations": 10}
+            }
+
+            tracker.save_baseline(results)
+            loaded = tracker.load_baseline()
+
+            assert loaded["file.py"]["high_value_mutations"] == 10
+
+    def test_compare_results(self):
+        """Test comparing current to baseline."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            config = MutationConfig(baseline_path=f"{tmpdir}/baseline.json")
+            tracker = BaselineTracker(config)
+
+            baseline = {"file.py": {"high_value_mutations": 10}}
+            tracker.save_baseline(baseline)
+
+            current = {"file.py": {"high_value_mutations": 12}}
+            comparison = tracker.compare(current)
+
+            assert comparison["file.py"]["change"] == 2
+
+
+class TestJSONExporter:
+    """Test JSON export."""
+
+    def test_export_json(self):
+        """Test exporting to JSON."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            path = f"{tmpdir}/results.json"
+            config = MutationConfig()
+            exporter = JSONExporter(config)
+
+            results = {
+                "file.py": {
+                    "high_value_mutations": 10,
+                    "potential_false_positives_avoided": 98.5
+                }
+            }
+
+            exporter.export(results, path)
+
+            with open(path) as f:
+                data = json.load(f)
+
+            assert data["results"]["file.py"]["high_value_mutations"] == 10
+            assert data["summary"]["total_mutations"] == 10
+
+
+class TestHTMLReportGenerator:
+    """Test HTML report generation."""
+
+    def test_generate_html_report(self):
+        """Test HTML report generation."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            path = f"{tmpdir}/report.html"
+            config = MutationConfig()
+            generator = HTMLReportGenerator(config)
+
+            results = {
+                "file.py": {
+                    "high_value_mutations": 10,
+                    "potential_false_positives_avoided": 98.5
+                }
+            }
+
+            generator.generate(results, path)
+
+            html = Path(path).read_text()
+            assert "<html>" in html.lower()
+            assert "mutation" in html.lower()
+            assert "10" in html
+
+
+class TestOperatorSuggester:
+    """Test operator suggestions."""
+
+    def test_suggest_operators_for_code(self):
+        """Test suggesting operators for code."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            # Create test file
+            test_file = f"{tmpdir}/test.py"
+            Path(test_file).write_text("""
+df.filter(pl.col('amount') > 0)
+df.sum()
+df.join(other)
+""")
+
+            suggestions = OperatorSuggester.analyze_code(test_file)
+
+            assert "filter_mutations" in suggestions
+            assert "aggregation_mutations" in suggestions
+            assert "join_mutations" in suggestions
+
+
+class TestCustomOperatorRegistry:
+    """Test custom operator registry."""
+
+    def test_registry_creation(self):
+        """Test creating operator registry."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            registry = CustomOperatorRegistry(tmpdir)
+            assert Path(tmpdir).exists()
+
+
+class TestSlackNotifier:
+    """Test Slack integration."""
+
+    def test_notifier_creation(self):
+        """Test creating Slack notifier."""
+        notifier = SlackNotifier("https://hooks.slack.com/test")
+        assert notifier.webhook_url == "https://hooks.slack.com/test"
+
+    def test_notify_does_not_error(self):
+        """Test notification doesn't crash on invalid webhook."""
+        notifier = SlackNotifier("https://invalid.example.com")
+
+        results = {"file.py": {"high_value_mutations": 10}}
+        # Should not raise
+        notifier.notify(results)
+
+
+if __name__ == "__main__":
+    pytest.main([__file__, "-v"])