gwc-pybundle 1.4.5__py3-none-any.whl

pybundle/steps/memory_profile.py

@@ -0,0 +1,173 @@
+"""
+Memory profiling with tracemalloc - Milestone 3 (v1.4.0)
+"""
+from __future__ import annotations
+
+import subprocess
+import time
+from dataclasses import dataclass
+from pathlib import Path
+
+from .base import StepResult
+from ..context import BundleContext
+
+
+@dataclass
+class MemoryProfileStep:
+    """
+    Memory profiling using tracemalloc to identify memory-consuming operations.
+    
+    Outputs:
+    - logs/62_memory_profile.txt: Top memory-consuming functions and allocations
+    """
+    
+    name: str = "memory_profile"
+    
+    def run(self, ctx: BundleContext) -> StepResult:
+        start = time.time()
+        
+        if ctx.options.no_profile or not ctx.options.profile_memory:
+            return StepResult(self.name, "SKIP", 0, "memory profiling not enabled")
+        
+        # Require pytest for memory profiling
+        if not ctx.tools.pytest:
+            return StepResult(self.name, "SKIP", 0, "pytest not found")
+        
+        tests_dir = ctx.root / "tests"
+        if not tests_dir.is_dir():
+            return StepResult(self.name, "SKIP", 0, "no tests/ directory")
+        
+        ctx.emit("  Running memory profiling on test suite")
+        
+        # Create a temporary script to run pytest with tracemalloc
+        profile_script = self._create_profile_script(ctx.root)
+        
+        try:
+            # Run the profiling script
+            result = subprocess.run(
+                [str(ctx.tools.python), str(profile_script)],
+                cwd=ctx.root,
+                capture_output=True,
+                text=True,
+                timeout=300  # 5 minute timeout
+            )
+            
+            # Write output
+            output_file = ctx.workdir / "logs" / "62_memory_profile.txt"
+            output_file.parent.mkdir(parents=True, exist_ok=True)
+            
+            with output_file.open("w") as f:
+                f.write("=" * 70 + "\n")
+                f.write("MEMORY PROFILING (tracemalloc)\n")
+                f.write("=" * 70 + "\n\n")
+                
+                if result.returncode == 0:
+                    f.write(result.stdout)
+                    if result.stderr:
+                        f.write("\n\nTest output:\n")
+                        f.write(result.stderr)
+                else:
+                    f.write("Memory profiling failed\n\n")
+                    f.write("STDOUT:\n")
+                    f.write(result.stdout)
+                    f.write("\n\nSTDERR:\n")
+                    f.write(result.stderr)
+            
+            elapsed = int((time.time() - start) * 1000)
+            if result.returncode == 0:
+                return StepResult(self.name, "OK", elapsed)
+            else:
+                return StepResult(self.name, "FAIL", elapsed, f"exit {result.returncode}")
+                
+        except subprocess.TimeoutExpired:
+            elapsed = int((time.time() - start) * 1000)
+            return StepResult(self.name, "FAIL", elapsed, "timeout")
+        except Exception as e:
+            elapsed = int((time.time() - start) * 1000)
+            return StepResult(self.name, "FAIL", elapsed, str(e))
+        finally:
+            # Clean up temporary script
+            if profile_script.exists():
+                profile_script.unlink()
+    
+    def _create_profile_script(self, root: Path) -> Path:
+        """Create a temporary Python script that runs pytest with tracemalloc"""
+        script_path = root / ".pybundle_memory_profile.py"
+        
+        script_content = '''"""Temporary memory profiling script for pybundle"""
+import tracemalloc
+import sys
+import pytest
+
+def format_size(size_bytes):
+    """Format bytes as human-readable string"""
+    for unit in ['B', 'KB', 'MB', 'GB']:
+        if size_bytes < 1024.0:
+            return f"{size_bytes:.2f} {unit}"
+        size_bytes /= 1024.0
+    return f"{size_bytes:.2f} TB"
+
+# Start tracing
+tracemalloc.start()
+
+# Record initial snapshot
+snapshot1 = tracemalloc.take_snapshot()
+
+# Run pytest
+exit_code = pytest.main(["-q"])
+
+# Take final snapshot
+snapshot2 = tracemalloc.take_snapshot()
+
+# Get traced memory
+current, peak = tracemalloc.get_traced_memory()
+
+# Stop tracing
+tracemalloc.stop()
+
+# Analyze differences
+print("=" * 70)
+print("MEMORY ALLOCATION SUMMARY")
+print("=" * 70)
+print()
+print(f"Peak memory usage: {format_size(peak)}")
+print()
+
+# Top allocations
+top_stats = snapshot2.compare_to(snapshot1, 'lineno')
+
+print("TOP 30 MEMORY ALLOCATIONS (by increase):")
+print("-" * 70)
+print(f"{'Size':<12} {'Count':<8} {'Location'}")
+print("-" * 70)
+
+for stat in top_stats[:30]:
+    print(f"{format_size(stat.size):<12} {stat.count:<8} {stat.traceback}")
+
+# Top by current size
+print()
+print("=" * 70)
+print("TOP 30 MEMORY CONSUMERS (by total size):")
+print("-" * 70)
+print(f"{'Size':<12} {'Count':<8} {'Location'}")
+print("-" * 70)
+
+current_stats = snapshot2.statistics('lineno')
+for stat in current_stats[:30]:
+    print(f"{format_size(stat.size):<12} {stat.count:<8} {stat.traceback}")
+
+print()
+print("=" * 70)
+print("RECOMMENDATIONS:")
+print("- Review functions with large memory allocations")
+print("- Check for memory leaks in repeatedly allocated objects")
+print("- Consider using generators for large data processing")
+print("=" * 70)
+
+sys.exit(exit_code)
+'''
+        
+        with script_path.open("w") as f:
+            f.write(script_content)
+        
+        return script_path

pybundle/steps/mutation_testing.py

@@ -0,0 +1,136 @@
+"""
+Mutation testing with mutmut - Milestone 4 (v1.4.1)
+"""
+from __future__ import annotations
+
+import subprocess
+import time
+from dataclasses import dataclass
+from pathlib import Path
+
+from .base import StepResult
+from ..context import BundleContext
+from ..tools import which
+
+
+@dataclass
+class MutationTestingStep:
+    """
+    Mutation testing to measure test suite effectiveness.
+    
+    EXPENSIVE: Disabled by default. Run many test executions with code mutations.
+    
+    Outputs:
+    - logs/72_mutation_testing.txt: Mutation testing results
+    """
+    
+    name: str = "mutation_testing"
+    
+    def run(self, ctx: BundleContext) -> StepResult:
+        start = time.time()
+        
+        # Only run if explicitly enabled (very slow!)
+        if not ctx.options.enable_mutation_testing:
+            return StepResult(self.name, "SKIP", 0, "mutation testing not enabled (slow!)")
+        
+        # Check for mutmut
+        mutmut = which("mutmut")
+        if not mutmut:
+            output_file = ctx.workdir / "logs" / "72_mutation_testing.txt"
+            output_file.parent.mkdir(parents=True, exist_ok=True)
+            output_file.write_text(
+                "mutmut not found; install with: pip install mutmut\n",
+                encoding="utf-8"
+            )
+            return StepResult(self.name, "SKIP", 0, "mutmut not installed")
+        
+        if not ctx.tools.pytest:
+            return StepResult(self.name, "SKIP", 0, "pytest not found")
+        
+        tests_dir = ctx.root / "tests"
+        if not tests_dir.is_dir():
+            return StepResult(self.name, "SKIP", 0, "no tests/ directory")
+        
+        ctx.emit("  ⚠️  Running mutation testing (this may take several minutes)...")
+        
+        output_file = ctx.workdir / "logs" / "72_mutation_testing.txt"
+        output_file.parent.mkdir(parents=True, exist_ok=True)
+        
+        try:
+            # Run mutmut
+            # First, run mutmut run to generate mutations
+            run_result = subprocess.run(
+                [mutmut, "run", "--paths-to-mutate", "."],
+                cwd=ctx.root,
+                capture_output=True,
+                text=True,
+                timeout=600  # 10 minute timeout (mutation testing is SLOW)
+            )
+            
+            # Then get results summary
+            results_result = subprocess.run(
+                [mutmut, "results"],
+                cwd=ctx.root,
+                capture_output=True,
+                text=True,
+                timeout=60
+            )
+            
+            # Generate report
+            with output_file.open("w") as f:
+                f.write("=" * 70 + "\n")
+                f.write("MUTATION TESTING (mutmut)\n")
+                f.write("=" * 70 + "\n")
+                f.write("⚠️  WARNING: Mutation testing is VERY SLOW\n")
+                f.write("=" * 70 + "\n\n")
+                
+                f.write("MUTATION RUN OUTPUT:\n")
+                f.write("-" * 70 + "\n")
+                f.write(run_result.stdout)
+                if run_result.stderr:
+                    f.write("\nErrors:\n")
+                    f.write(run_result.stderr)
+                
+                f.write("\n" + "=" * 70 + "\n")
+                f.write("MUTATION RESULTS SUMMARY:\n")
+                f.write("-" * 70 + "\n")
+                f.write(results_result.stdout)
+                if results_result.stderr:
+                    f.write("\nErrors:\n")
+                    f.write(results_result.stderr)
+                
+                f.write("\n" + "=" * 70 + "\n")
+                f.write("INTERPRETATION:\n")
+                f.write("-" * 70 + "\n")
+                f.write("- Killed mutations: Your tests caught the bug (GOOD!)\n")
+                f.write("- Survived mutations: Your tests missed the bug (BAD!)\n")
+                f.write("- Timeout/Suspicious: Tests took too long or behaved oddly\n")
+                f.write("\n")
+                f.write("Mutation Score = Killed / (Killed + Survived + Timeout)\n")
+                f.write("Target: >80% mutation score for well-tested code\n")
+                f.write("\n")
+                f.write("To see specific survived mutations:\n")
+                f.write("  mutmut show <id>\n")
+                f.write("\n")
+                f.write("=" * 70 + "\n")
+                f.write("RECOMMENDATIONS:\n")
+                f.write("- Add tests for survived mutations\n")
+                f.write("- Focus on edge cases and boundary conditions\n")
+                f.write("- Improve assertion quality (not just 'assert result')\n")
+            
+            elapsed = int((time.time() - start) * 1000)
+            
+            if run_result.returncode == 0:
+                return StepResult(self.name, "OK", elapsed)
+            else:
+                return StepResult(self.name, "FAIL", elapsed, f"exit {run_result.returncode}")
+                
+        except subprocess.TimeoutExpired:
+            elapsed = int((time.time() - start) * 1000)
+            with output_file.open("w") as f:
+                f.write("Mutation testing timed out after 10 minutes\n")
+                f.write("Consider testing a smaller subset or using --paths-to-mutate\n")
+            return StepResult(self.name, "FAIL", elapsed, "timeout")
+        except Exception as e:
+            elapsed = int((time.time() - start) * 1000)
+            return StepResult(self.name, "FAIL", elapsed, str(e))

pybundle/steps/mypy.py

@@ -0,0 +1,60 @@
+from __future__ import annotations
+
+import subprocess  # nosec B404 - Required for tool execution, paths validated
+import time
+from dataclasses import dataclass
+from pathlib import Path
+
+from .base import StepResult
+from ..context import BundleContext
+from ..tools import which
+
+
+def _has_mypy_config(root: Path) -> bool:
+    if (root / "mypy.ini").is_file():
+        return True
+    if (root / "setup.cfg").is_file():
+        return True
+    if (root / "pyproject.toml").is_file():
+        # we don't parse TOML here; presence is enough for v1
+        return True
+    return False
+
+
+@dataclass
+class MypyStep:
+    name: str = "mypy"
+    target: str = "pybundle"
+    outfile: str = "logs/33_mypy.txt"
+
+    def run(self, ctx: BundleContext) -> StepResult:
+        start = time.time()
+        out = ctx.workdir / self.outfile
+        out.parent.mkdir(parents=True, exist_ok=True)
+
+        mypy = which("mypy")
+        if not mypy:
+            out.write_text(
+                "mypy not found; skipping (pip install mypy)\n", encoding="utf-8"
+            )
+            return StepResult(self.name, "SKIP", 0, "missing mypy")
+
+        if not _has_mypy_config(ctx.root):
+            out.write_text(
+                "no mypy config detected (mypy.ini/setup.cfg/pyproject.toml); skipping\n",
+                encoding="utf-8",
+            )
+            return StepResult(self.name, "SKIP", 0, "no config")
+
+        cmd = [mypy, "--exclude", "^artifacts/", self.target]
+        header = f"## PWD: {ctx.root}\n## CMD: {' '.join(cmd)}\n\n"
+
+        cp = subprocess.run(  # nosec B603
+            cmd, cwd=str(ctx.root), text=True, capture_output=True, check=False
+        )
+        text = header + (cp.stdout or "") + ("\n" + cp.stderr if cp.stderr else "")
+        out.write_text(ctx.redact_text(text), encoding="utf-8")
+
+        dur = int(time.time() - start)
+        note = "" if cp.returncode == 0 else f"exit={cp.returncode} (type findings)"
+        return StepResult(self.name, "PASS", dur, note)

pybundle/steps/pip_audit.py

@@ -0,0 +1,45 @@
+from __future__ import annotations
+
+import subprocess  # nosec B404 - Required for tool execution, paths validated
+import time
+from dataclasses import dataclass
+
+from .base import StepResult
+from ..context import BundleContext
+from ..tools import which
+
+
+@dataclass
+class PipAuditStep:
+    name: str = "pip-audit"
+    outfile: str = "logs/51_pip_audit.txt"
+
+    def run(self, ctx: BundleContext) -> StepResult:
+        start = time.time()
+        out = ctx.workdir / self.outfile
+        out.parent.mkdir(parents=True, exist_ok=True)
+
+        pip_audit = which("pip-audit")
+        if not pip_audit:
+            out.write_text(
+                "pip-audit not found; skipping (pip install pip-audit)\n",
+                encoding="utf-8",
+            )
+            return StepResult(self.name, "SKIP", 0, "missing pip-audit")
+
+        # Run pip-audit to check for known vulnerabilities
+        cmd = [pip_audit, "--desc", "--format", "columns"]
+        header = f"## PWD: {ctx.root}\n## CMD: {' '.join(cmd)}\n\n"
+
+        cp = subprocess.run(  # nosec B603
+            cmd, cwd=str(ctx.root), text=True, capture_output=True, check=False
+        )
+        text = header + (cp.stdout or "") + ("\n" + cp.stderr if cp.stderr else "")
+        out.write_text(ctx.redact_text(text), encoding="utf-8")
+
+        dur = int(time.time() - start)
+        # pip-audit exit codes: 0=no vulnerabilities, 1=vulnerabilities found
+        note = (
+            "" if cp.returncode == 0 else f"exit={cp.returncode} (vulnerable packages)"
+        )
+        return StepResult(self.name, "PASS", dur, note)

pybundle/steps/pipdeptree.py

@@ -0,0 +1,61 @@
+from __future__ import annotations
+
+import subprocess  # nosec B404 - Required for tool execution, paths validated
+import time
+from dataclasses import dataclass
+
+from .base import StepResult
+from ..context import BundleContext
+from ..tools import which
+
+
+@dataclass
+class PipdeptreeStep:
+    name: str = "pipdeptree"
+    outfile: str = "meta/30_dependency_tree.txt"
+
+    def run(self, ctx: BundleContext) -> StepResult:
+        start = time.time()
+        out = ctx.workdir / self.outfile
+        out.parent.mkdir(parents=True, exist_ok=True)
+
+        pipdeptree = which("pipdeptree")
+        if not pipdeptree:
+            out.write_text(
+                "pipdeptree not found; skipping (pip install pipdeptree)\n",
+                encoding="utf-8"
+            )
+            return StepResult(self.name, "SKIP", 0, "missing pipdeptree")
+
+        # Run pipdeptree with warnings for conflicts
+        cmd = [
+            pipdeptree,
+            "--warn", "fail",  # Show warnings for conflicting dependencies
+        ]
+
+        try:
+            result = subprocess.run(  # nosec B603 - Using full path from which()
+                cmd,
+                cwd=ctx.root,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                text=True,
+                timeout=60,
+            )
+            
+            # Combine stdout and stderr to capture both tree and warnings
+            output = result.stdout
+            if result.stderr:
+                output += "\n\n=== WARNINGS ===\n" + result.stderr
+            
+            out.write_text(output, encoding="utf-8")
+            elapsed = int((time.time() - start) * 1000)
+            
+            # pipdeptree returns 0 on success, even with warnings
+            return StepResult(self.name, "OK", elapsed, None)
+        except subprocess.TimeoutExpired:
+            out.write_text("pipdeptree timed out after 60s\n", encoding="utf-8")
+            return StepResult(self.name, "FAIL", 60000, "timeout")
+        except Exception as e:
+            out.write_text(f"pipdeptree error: {e}\n", encoding="utf-8")
+            return StepResult(self.name, "FAIL", 0, str(e))