crackerjack 0.33.0__py3-none-any.whl → 0.33.2__py3-none-any.whl

crackerjack/services/parallel_executor.py

@@ -1,9 +1,3 @@
-"""Parallel execution coordinator for hooks and other independent operations.
-
-This module provides safe parallel execution of hooks while respecting
-security levels, dependencies, and resource constraints.
-"""
-
 import asyncio
 import time
 import typing as t
@@ -18,19 +12,13 @@ from crackerjack.services.performance_cache import get_performance_cache
 
 
 class ExecutionStrategy(Enum):
-    """Execution strategy for parallel operations."""
-
     SEQUENTIAL = "sequential"
-    PARALLEL_SAFE = (
-        "parallel_safe"  # Only parallel execution of safe, independent hooks
-    )
-    PARALLEL_AGGRESSIVE = "parallel_aggressive"  # More aggressive parallelization
+    PARALLEL_SAFE = "parallel_safe"
+    PARALLEL_AGGRESSIVE = "parallel_aggressive"
 
 
 @dataclass
 class ExecutionGroup:
-    """Group of operations that can be executed together."""
-
     name: str
     operations: list[t.Any]
     max_workers: int = 3
@@ -41,21 +29,17 @@ class ExecutionGroup:
 
 @dataclass
 class ExecutionResult:
-    """Result of executing an operation."""
-
     operation_id: str
     success: bool
     duration_seconds: float
     output: str = ""
     error: str = ""
     exit_code: int = 0
-    metadata: dict[str, t.Any] = field(default_factory=dict)
+    metadata: dict[str, t.Any] = field(default_factory=dict[str, t.Any])
 
 
 @dataclass
 class ParallelExecutionResult:
-    """Result of parallel execution batch."""
-
     group_name: str
     total_operations: int
     successful_operations: int
@@ -65,7 +49,6 @@ class ParallelExecutionResult:
 
     @property
     def success_rate(self) -> float:
-        """Calculate success rate."""
         return (
             self.successful_operations / self.total_operations
             if self.total_operations > 0
@@ -74,13 +57,10 @@ class ParallelExecutionResult:
 
     @property
     def overall_success(self) -> bool:
-        """Check if all operations succeeded."""
         return self.failed_operations == 0
 
 
 class ParallelHookExecutor:
-    """Parallel executor for hook operations with safety constraints."""
-
     def __init__(
         self,
         max_workers: int = 3,
@@ -97,7 +77,6 @@ class ParallelHookExecutor:
         self,
         hooks: list[HookDefinition],
     ) -> dict[str, list[HookDefinition]]:
-        """Analyze hook dependencies and group hooks for parallel execution."""
         groups: dict[str, list[HookDefinition]] = {
             "formatting": [],
             "validation": [],
@@ -115,7 +94,6 @@ class ParallelHookExecutor:
             else:
                 groups["comprehensive"].append(hook)
 
-        # Remove empty groups
         return {k: v for k, v in groups.items() if v}
 
     def can_execute_in_parallel(
@@ -123,25 +101,18 @@ class ParallelHookExecutor:
         hook1: HookDefinition,
         hook2: HookDefinition,
     ) -> bool:
-        """Check if two hooks can be safely executed in parallel."""
-        # Never parallelize different security levels for safety
         if hook1.security_level != hook2.security_level:
             return False
 
-        # Don't parallelize hooks that modify files with hooks that read files
         if hook1.is_formatting and not hook2.is_formatting:
             return False
 
-        # Safe combinations for parallel execution
         safe_parallel_combinations = [
-            # All formatting hooks can run in parallel
             (lambda h: h.is_formatting, lambda h: h.is_formatting),
-            # Validation hooks can run in parallel
             (
                 lambda h: h.name in {"check-yaml", "check-json", "check-toml"},
                 lambda h: h.name in {"check-yaml", "check-json", "check-toml"},
             ),
-            # Same security level non-formatting hooks
             (
                 lambda h: not h.is_formatting
                 and h.security_level == SecurityLevel.MEDIUM,
@@ -161,13 +132,11 @@ class ParallelHookExecutor:
         hooks: list[HookDefinition],
         hook_runner: t.Callable[[HookDefinition], t.Awaitable[ExecutionResult]],
     ) -> ParallelExecutionResult:
-        """Execute hooks in parallel where safe, sequential otherwise."""
         start_time = time.time()
 
         if self.strategy == ExecutionStrategy.SEQUENTIAL:
             return await self._execute_sequential(hooks, hook_runner, start_time)
 
-        # Group hooks for parallel execution
         groups = self.analyze_hook_dependencies(hooks)
         all_results: list[ExecutionResult] = []
 
@@ -177,12 +146,10 @@ class ParallelHookExecutor:
 
         for group_name, group_hooks in groups.items():
             if len(group_hooks) == 1 or not self._can_parallelize_group(group_hooks):
-                # Execute single hook or non-parallelizable group sequentially
                 for hook in group_hooks:
                     result = await hook_runner(hook)
                     all_results.append(result)
             else:
-                # Execute group in parallel
                 group_results = await self._execute_group_parallel(
                     group_hooks,
                     hook_runner,
@@ -209,7 +176,6 @@ class ParallelHookExecutor:
         hook_runner: t.Callable[[HookDefinition], t.Awaitable[ExecutionResult]],
         start_time: float,
     ) -> ParallelExecutionResult:
-        """Execute hooks sequentially (fallback)."""
         results: list[ExecutionResult] = []
 
         for hook in hooks:
@@ -230,11 +196,9 @@ class ParallelHookExecutor:
         )
 
     def _can_parallelize_group(self, hooks: list[HookDefinition]) -> bool:
-        """Check if a group of hooks can be parallelized."""
         if len(hooks) < 2:
             return False
 
-        # Check pairwise compatibility
         for i, hook1 in enumerate(hooks):
             for hook2 in hooks[i + 1 :]:
                 if not self.can_execute_in_parallel(hook1, hook2):
@@ -248,28 +212,22 @@ class ParallelHookExecutor:
         hook_runner: t.Callable[[HookDefinition], t.Awaitable[ExecutionResult]],
         group_name: str,
     ) -> list[ExecutionResult]:
-        """Execute a group of hooks in parallel."""
         self._logger.debug(f"Executing {len(hooks)} {group_name} hooks in parallel")
 
-        # Limit parallelism for safety
         max_workers = min(self.max_workers, len(hooks))
 
-        # Create semaphore to limit concurrent executions
         semaphore = asyncio.Semaphore(max_workers)
 
         async def run_with_semaphore(hook: HookDefinition) -> ExecutionResult:
             async with semaphore:
                 return await hook_runner(hook)
 
-        # Execute all hooks concurrently with limited parallelism
         tasks = [run_with_semaphore(hook) for hook in hooks]
         results = await asyncio.gather(*tasks, return_exceptions=True)
 
-        # Process results and handle exceptions
         processed_results: list[ExecutionResult] = []
         for i, result in enumerate(results):
             if isinstance(result, Exception):
-                # Create error result for exception
                 error_result = ExecutionResult(
                     operation_id=hooks[i].name,
                     success=False,
@@ -281,8 +239,7 @@ class ParallelHookExecutor:
                     f"Hook {hooks[i].name} failed with exception: {result}"
                 )
             else:
-                # result must be ExecutionResult here due to type narrowing
-                processed_results.append(result)  # type: ignore[arg-type]
+                processed_results.append(result)
 
         successful = sum(1 for r in processed_results if r.success)
         self._logger.info(
@@ -293,8 +250,6 @@ class ParallelHookExecutor:
 
 
 class AsyncCommandExecutor:
-    """Asynchronous command executor with optimization and caching."""
-
     def __init__(
         self,
         max_workers: int = 4,
@@ -313,8 +268,6 @@ class AsyncCommandExecutor:
         timeout: int = 60,
         cache_ttl: int = 120,
     ) -> ExecutionResult:
-        """Execute a command asynchronously with caching."""
-        # Check cache first
         if self.cache_results:
             cached_result = await self._get_cached_result(command, cwd)
             if cached_result:
@@ -323,12 +276,10 @@ class AsyncCommandExecutor:
                 )
                 return cached_result
 
-        # Execute command
         start_time = time.time()
         result = await self._run_command_async(command, cwd, timeout)
         result.duration_seconds = time.time() - start_time
 
-        # Cache successful results
         if self.cache_results and result.success:
             await self._cache_result(command, result, cache_ttl, cwd)
 
@@ -339,14 +290,12 @@ class AsyncCommandExecutor:
         commands: list[tuple[list[str], Path | None]],
         timeout: int = 60,
     ) -> list[ExecutionResult]:
-        """Execute multiple commands concurrently."""
         self._logger.info(f"Executing {len(commands)} commands in batch")
 
         tasks = [self.execute_command(cmd, cwd, timeout) for cmd, cwd in commands]
 
         results = await asyncio.gather(*tasks, return_exceptions=True)
 
-        # Process results and handle exceptions
         processed_results: list[ExecutionResult] = []
         for i, result in enumerate(results):
             if isinstance(result, Exception):
@@ -358,8 +307,7 @@ class AsyncCommandExecutor:
                 )
                 processed_results.append(error_result)
             else:
-                # result must be ExecutionResult here due to type narrowing
-                processed_results.append(result)  # type: ignore[arg-type]
+                processed_results.append(result)
 
         successful = sum(1 for r in processed_results if r.success)
         self._logger.info(
@@ -374,7 +322,6 @@ class AsyncCommandExecutor:
         cwd: Path | None = None,
         timeout: int = 60,
     ) -> ExecutionResult:
-        """Run command asynchronously in thread pool."""
         loop = asyncio.get_event_loop()
 
         def run_sync_command() -> ExecutionResult:
@@ -393,7 +340,7 @@ class AsyncCommandExecutor:
                 return ExecutionResult(
                     operation_id=" ".join(command),
                     success=result.returncode == 0,
-                    duration_seconds=0.0,  # Set by caller
+                    duration_seconds=0.0,
                     output=result.stdout,
                     error=result.stderr,
                     exit_code=result.returncode,
@@ -423,10 +370,10 @@ class AsyncCommandExecutor:
         command: list[str],
         cwd: Path | None = None,
     ) -> ExecutionResult | None:
-        """Get cached command result."""
         from crackerjack.services.performance_cache import get_command_cache
 
-        return get_command_cache().get_command_result(command, cwd)
+        cache_result = get_command_cache().get_command_result(command, cwd)
+        return t.cast(ExecutionResult | None, cache_result)
 
     async def _cache_result(
         self,
@@ -435,19 +382,16 @@ class AsyncCommandExecutor:
         ttl_seconds: int,
         cwd: Path | None = None,
     ) -> None:
-        """Cache command result."""
         from crackerjack.services.performance_cache import get_command_cache
 
         command_cache = get_command_cache()
         command_cache.set_command_result(command, result, cwd, ttl_seconds)
 
-    def __del__(self):
-        """Clean up thread pool."""
+    def __del__(self) -> None:
         if hasattr(self, "_thread_pool"):
             self._thread_pool.shutdown(wait=False)
 
 
-# Global executor instances
 _parallel_executor: ParallelHookExecutor | None = None
 _async_executor: AsyncCommandExecutor | None = None
 
@@ -456,7 +400,6 @@ def get_parallel_executor(
     max_workers: int = 3,
     strategy: ExecutionStrategy = ExecutionStrategy.PARALLEL_SAFE,
 ) -> ParallelHookExecutor:
-    """Get global parallel hook executor instance."""
     global _parallel_executor
     if _parallel_executor is None:
         _parallel_executor = ParallelHookExecutor(
@@ -467,7 +410,6 @@ def get_parallel_executor(
 
 
 def get_async_executor(max_workers: int = 4) -> AsyncCommandExecutor:
-    """Get global async command executor instance."""
     global _async_executor
     if _async_executor is None:
         _async_executor = AsyncCommandExecutor(max_workers=max_workers)

crackerjack/services/pattern_cache.py

@@ -195,7 +195,7 @@ class PatternCache:
         if not self._patterns:
             return {"total_patterns": 0}
 
-        patterns_by_type = {}
+        patterns_by_type: dict[str, int] = {}
         total_usage = 0
         avg_success_rate = 0.0
 

crackerjack/services/pattern_detector.py

@@ -66,7 +66,7 @@ class PatternDetector:
         self.logger.info("Starting proactive anti-pattern analysis")
 
         anti_patterns = []
-        python_files = list(self.project_path.glob("**/*.py"))
+        python_files = list[t.Any](self.project_path.glob("**/*.py"))
 
         for file_path in python_files:
             if self._should_skip_file(file_path):
@@ -155,7 +155,7 @@ class PatternDetector:
         anti_patterns = []
 
         lines = content.split("\n")
-        line_groups = {}
+        line_groups: dict[str, list[int]] = {}
 
         for i, line in enumerate(lines, 1):
             stripped = line.strip()
@@ -197,7 +197,7 @@ class PatternDetector:
                             (
                                 node.lineno,
                                 "Nested loop detected-potential O(n²) complexity",
-                                "Consider using dictionary lookups or set operations",
+                                "Consider using dictionary lookups or set[t.Any] operations",
                             )
                         )
                         break
@@ -212,7 +212,7 @@ class PatternDetector:
                             (
                                 stmt.lineno,
                                 "List concatenation in loop-inefficient",
-                                "Use list.append() and join at the end",
+                                "Use list[t.Any].append() and join at the end",
                             )
                         )
 
@@ -254,10 +254,10 @@ class PatternDetector:
     ) -> list[AntiPattern]:
         anti_patterns = []
 
-        if "/tmp/" in content or "C:\\" in content:  # nosec B108
+        if "/tmp/" in content or "C: \\" in content:  # nosec B108
             lines = content.split("\n")
             for i, line in enumerate(lines, 1):
-                if "/tmp/" in line or "C:\\" in line:  # nosec B108
+                if "/tmp/" in line or "C: \\" in line:  # nosec B108
                     anti_patterns.append(
                         AntiPattern(
                             pattern_type="security_risks",

crackerjack/services/performance_benchmarks.py

@@ -1,13 +1,8 @@
-"""Performance benchmarking service to measure Phase 3 optimization improvements.
-
-This module provides comprehensive benchmarking capabilities to measure the performance
-gains from async workflows, caching, memory optimization, and parallel execution.
-"""
-
 import asyncio
 import json
 import statistics
 import time
+import typing as t
 from dataclasses import dataclass, field
 from datetime import datetime
 from pathlib import Path
@@ -20,8 +15,6 @@ from crackerjack.services.performance_monitor import get_performance_monitor
 
 @dataclass
 class BenchmarkResult:
-    """Individual benchmark test result."""
-
     test_name: str
     baseline_time_seconds: float
     optimized_time_seconds: float
@@ -34,7 +27,6 @@ class BenchmarkResult:
 
     @property
     def time_improvement_percentage(self) -> float:
-        """Calculate time improvement percentage."""
         if self.baseline_time_seconds == 0:
             return 0.0
         return (
@@ -45,7 +37,6 @@ class BenchmarkResult:
 
     @property
     def memory_improvement_percentage(self) -> float:
-        """Calculate memory improvement percentage."""
         if self.memory_baseline_mb == 0:
             return 0.0
         return (
@@ -56,28 +47,23 @@ class BenchmarkResult:
 
     @property
     def cache_hit_ratio(self) -> float:
-        """Calculate cache hit ratio."""
         total = self.cache_hits + self.cache_misses
         return self.cache_hits / total if total > 0 else 0.0
 
     @property
     def parallelization_ratio(self) -> float:
-        """Calculate parallelization ratio."""
         total = self.parallel_operations + self.sequential_operations
         return self.parallel_operations / total if total > 0 else 0.0
 
 
 @dataclass
 class BenchmarkSuite:
-    """Collection of benchmark results."""
-
     suite_name: str
     results: list[BenchmarkResult] = field(default_factory=list)
     run_timestamp: datetime = field(default_factory=datetime.now)
 
     @property
     def average_time_improvement(self) -> float:
-        """Calculate average time improvement across all tests."""
         if not self.results:
             return 0.0
         improvements = [r.time_improvement_percentage for r in self.results]
@@ -85,7 +71,6 @@ class BenchmarkSuite:
 
     @property
     def average_memory_improvement(self) -> float:
-        """Calculate average memory improvement across all tests."""
         if not self.results:
             return 0.0
         improvements = [r.memory_improvement_percentage for r in self.results]
@@ -93,81 +78,67 @@ class BenchmarkSuite:
 
     @property
     def overall_cache_hit_ratio(self) -> float:
-        """Calculate overall cache hit ratio."""
         total_hits = sum(r.cache_hits for r in self.results)
         total_misses = sum(r.cache_misses for r in self.results)
         total = total_hits + total_misses
         return total_hits / total if total > 0 else 0.0
 
     def add_result(self, result: BenchmarkResult) -> None:
-        """Add a benchmark result to the suite."""
         self.results.append(result)
 
 
 class PerformanceBenchmarker:
-    """Service for benchmarking Phase 3 performance optimizations."""
-
-    def __init__(self):
+    def __init__(self) -> None:
         self._logger = get_logger("crackerjack.benchmarker")
         self._monitor = get_performance_monitor()
         self._memory_optimizer = get_memory_optimizer()
         self._cache = get_performance_cache()
 
-        # Benchmark configurations
         self._test_iterations = 3
         self._warmup_iterations = 1
 
     async def run_comprehensive_benchmark(self) -> BenchmarkSuite:
-        """Run comprehensive benchmark suite comparing baseline vs optimized performance."""
         self._logger.info("Starting comprehensive performance benchmark")
 
         suite = BenchmarkSuite("Phase 3 Optimization Benchmark")
 
-        # Memory optimization benchmark
         suite.add_result(await self._benchmark_memory_optimization())
 
-        # Caching benchmark
         suite.add_result(await self._benchmark_caching_performance())
 
-        # Async workflow benchmark
         suite.add_result(await self._benchmark_async_workflows())
 
         self._logger.info(
             f"Benchmark complete. Average improvements: "
-            f"Time: {suite.average_time_improvement:.1f}%, "
-            f"Memory: {suite.average_memory_improvement:.1f}%, "
-            f"Cache ratio: {suite.overall_cache_hit_ratio:.2f}"
+            f"Time: {suite.average_time_improvement: .1f}%, "
+            f"Memory: {suite.average_memory_improvement: .1f}%, "
+            f"Cache ratio: {suite.overall_cache_hit_ratio: .2f}"
         )
 
         return suite
 
     async def _benchmark_memory_optimization(self) -> BenchmarkResult:
-        """Benchmark memory optimization improvements."""
         self._logger.debug("Benchmarking memory optimization")
 
-        # Baseline: Create objects without optimization
         baseline_start = time.time()
         baseline_memory_start = self._memory_optimizer.record_checkpoint(
             "baseline_start"
         )
 
-        # Simulate heavy object creation (baseline)
         heavy_objects = []
-        for i in range(50):  # Reduced for faster testing
+        for i in range(50):
             obj = {
-                "data": f"heavy_data_{i}" * 100,  # Smaller for testing
+                "data": f"heavy_data_{i}" * 100,
                 "metadata": {"created": time.time(), "index": i},
-                "payload": list(range(100)),
+                "payload": list[t.Any](range(100)),
             }
             heavy_objects.append(obj)
 
         baseline_time = time.time() - baseline_start
         baseline_memory_peak = self._memory_optimizer.record_checkpoint("baseline_peak")
 
-        # Clean up baseline objects
         del heavy_objects
 
-        # Optimized: Use lazy loading
         optimized_start = time.time()
         optimized_memory_start = self._memory_optimizer.record_checkpoint(
             "optimized_start"
@@ -178,11 +149,11 @@ class PerformanceBenchmarker:
         lazy_objects = []
         for i in range(50):
 
-            def create_heavy_object(index: int = i):
+            def create_heavy_object(index: int = i) -> dict[str, t.Any]:
                 return {
                     "data": f"heavy_data_{index}" * 100,
                     "metadata": {"created": time.time(), "index": index},
-                    "payload": list(range(100)),
+                    "payload": list[t.Any](range(100)),
                 }
 
             lazy_obj = LazyLoader(create_heavy_object, f"heavy_object_{i}")
@@ -204,20 +175,17 @@ class PerformanceBenchmarker:
         )
 
     async def _benchmark_caching_performance(self) -> BenchmarkResult:
-        """Benchmark caching performance improvements."""
         self._logger.debug("Benchmarking caching performance")
 
         self._cache.clear()
 
-        # Baseline: No caching
         baseline_start = time.time()
 
-        for i in range(10):  # Reduced for testing
+        for i in range(10):
             await self._simulate_expensive_operation(f"operation_{i % 3}")
 
         baseline_time = time.time() - baseline_start
 
-        # Optimized: With caching
         optimized_start = time.time()
         cache_stats_start = self._cache.get_stats()
 
@@ -241,18 +209,15 @@ class PerformanceBenchmarker:
         )
 
     async def _benchmark_async_workflows(self) -> BenchmarkResult:
-        """Benchmark async workflow improvements."""
         self._logger.debug("Benchmarking async workflows")
 
-        # Baseline: Sequential operations
         baseline_start = time.time()
 
-        for i in range(5):  # Reduced for testing
-            await self._simulate_io_operation(f"seq_{i}", 0.01)  # Reduced delay
+        for i in range(5):
+            await self._simulate_io_operation(f"seq_{i}", 0.01)
 
         baseline_time = time.time() - baseline_start
 
-        # Optimized: Parallel operations
         optimized_start = time.time()
 
         tasks = [self._simulate_io_operation(f"par_{i}", 0.01) for i in range(5)]
@@ -271,37 +236,33 @@ class PerformanceBenchmarker:
         )
 
     async def _simulate_expensive_operation(self, operation_id: str) -> str:
-        """Simulate an expensive operation without caching."""
-        await asyncio.sleep(0.002)  # 2ms delay for testing
+        await asyncio.sleep(0.002)
 
         result = ""
-        for i in range(100):  # Reduced computation
+        for i in range(100):
             result += f"{operation_id}_{i}"
 
         return result[:50]
 
     async def _simulate_cached_operation(self, operation_id: str) -> str:
-        """Simulate an expensive operation with caching."""
-        cached_result = await self._cache.get_async(f"expensive_op:{operation_id}")
+        cached_result = await self._cache.get_async(f"expensive_op: {operation_id}")
         if cached_result is not None:
-            return cached_result
+            return str(cached_result)
 
         result = await self._simulate_expensive_operation(operation_id)
         await self._cache.set_async(
-            f"expensive_op:{operation_id}", result, ttl_seconds=60
+            f"expensive_op: {operation_id}", result, ttl_seconds=60
         )
 
         return result
 
     async def _simulate_io_operation(self, operation_id: str, duration: float) -> str:
-        """Simulate I/O bound operation."""
         await asyncio.sleep(duration)
         return f"result_{operation_id}"
 
     def export_benchmark_results(
         self, suite: BenchmarkSuite, output_path: Path
     ) -> None:
-        """Export benchmark results to JSON file."""
         data = {
             "suite_name": suite.suite_name,
             "run_timestamp": suite.run_timestamp.isoformat(),
@@ -337,7 +298,5 @@ class PerformanceBenchmarker:
         self._logger.info(f"Exported benchmark results to {output_path}")
 
 
-# Global benchmarker instance
 def get_benchmarker() -> PerformanceBenchmarker:
-    """Get performance benchmarker instance."""
     return PerformanceBenchmarker()