crackerjack 0.37.9__py3-none-any.whl → 0.45.2__py3-none-any.whl

crackerjack/services/{performance_benchmarks.py → monitoring/performance_benchmarks.py}

@@ -7,10 +7,18 @@ from dataclasses import dataclass, field
 from datetime import datetime
 from pathlib import Path
 
-from crackerjack.services.logging import get_logger
-from crackerjack.services.memory_optimizer import get_memory_optimizer
-from crackerjack.services.performance_cache import get_performance_cache
-from crackerjack.services.performance_monitor import get_performance_monitor
+from acb.console import Console
+from acb.depends import Inject, depends
+from acb.logger import Logger
+
+from crackerjack.models.protocols import (
+    PerformanceBenchmarkProtocol,
+    PerformanceBenchmarkServiceProtocol,
+    ServiceProtocol,
+)
+from crackerjack.services.memory_optimizer import LazyLoader, MemoryOptimizer
+from crackerjack.services.monitoring.performance_cache import get_performance_cache
+from crackerjack.services.monitoring.performance_monitor import get_performance_monitor
 
 
 @dataclass
@@ -88,10 +96,11 @@ class BenchmarkSuite:
 
 
 class PerformanceBenchmarker:
-    def __init__(self) -> None:
-        self._logger = get_logger("crackerjack.benchmarker")
+    @depends.inject
+    def __init__(self, logger: Inject[Logger]) -> None:
+        self._logger = logger
         self._monitor = get_performance_monitor()
-        self._memory_optimizer = get_memory_optimizer()
+        self._memory_optimizer = MemoryOptimizer.get_instance()
         self._cache = get_performance_cache()
 
         self._test_iterations = 3
@@ -144,8 +153,6 @@ class PerformanceBenchmarker:
             "optimized_start"
         )
 
-        from crackerjack.services.memory_optimizer import LazyLoader
-
         lazy_objects = []
         for i in range(50):
 
@@ -298,15 +305,94 @@ class PerformanceBenchmarker:
         self._logger.info(f"Exported benchmark results to {output_path}")
 
 
-class PerformanceBenchmarkService:
+class PerformanceBenchmarkService(
+    PerformanceBenchmarkProtocol, PerformanceBenchmarkServiceProtocol, ServiceProtocol
+):
     """Service wrapper for performance benchmarking in workflow orchestration."""
 
-    def __init__(self, console, pkg_path):
+    @depends.inject
+    def __init__(
+        self, console: Console, logger: Inject[Logger], pkg_path: Path
+    ) -> None:
         self._console = console
         self._pkg_path = pkg_path
-        self._benchmarker = PerformanceBenchmarker()
-        self._logger = get_logger("crackerjack.benchmark_service")
+        self._benchmarker = PerformanceBenchmarker(logger=logger)
+        self._logger = logger
+
+    def initialize(self) -> None:
+        pass
+
+    def cleanup(self) -> None:
+        pass
+
+    def health_check(self) -> bool:
+        return True
+
+    def shutdown(self) -> None:
+        pass
+
+    def metrics(self) -> dict[str, t.Any]:
+        return {}
+
+    def is_healthy(self) -> bool:
+        return True
+
+    def register_resource(self, resource: t.Any) -> None:
+        pass
+
+    def cleanup_resource(self, resource: t.Any) -> None:
+        pass
+
+    def record_error(self, error: Exception) -> None:
+        pass
+
+    def increment_requests(self) -> None:
+        pass
+
+    def get_custom_metric(self, name: str) -> t.Any:
+        return None
+
+    def set_custom_metric(self, name: str, value: t.Any) -> None:
+        pass
+
+    # Methods for PerformanceBenchmarkProtocol
+    def run_benchmark(self, operation: str) -> dict[str, t.Any]:
+        """Run a specific benchmark operation."""
+        start_time = time.time()
+        # Since we don't have operation-specific benchmark methods,
+        # we'll return basic timing information
+        return {
+            "operation": operation,
+            "start_time": start_time,
+            "end_time": time.time(),
+            "duration": time.time() - start_time,
+            "status": "completed",
+        }
+
+    def get_report(self) -> dict[str, t.Any]:
+        """Get performance report."""
+        # Return a basic report based on workflow metrics
+        return {
+            "timestamp": datetime.now().isoformat(),
+            "report_type": "performance_summary",
+            "total_benchmarks": 0,  # This would be updated with actual values from the benchmarker
+            "summary": "Performance benchmark service operational",
+        }
+
+    def compare_benchmarks(
+        self,
+        baseline: dict[str, t.Any],
+        current: dict[str, t.Any],
+    ) -> dict[str, t.Any]:
+        """Compare two benchmark results."""
+        return {
+            "comparison_type": "basic_comparison",
+            "baseline": baseline,
+            "current": current,
+            "differences": {},
+        }
 
+    # Methods for PerformanceBenchmarkServiceProtocol
     async def run_benchmark_suite(self) -> BenchmarkSuite | None:
         """Run comprehensive benchmark suite and return results."""
         try:
@@ -321,4 +407,4 @@ class PerformanceBenchmarkService:
 
 
 def get_benchmarker() -> PerformanceBenchmarker:
-    return PerformanceBenchmarker()
+    return PerformanceBenchmarker(logger=depends.get_sync(Logger))

crackerjack/services/{performance_cache.py → monitoring/performance_cache.py}

@@ -8,7 +8,8 @@ from pathlib import Path
 from threading import Lock
 from weakref import WeakValueDictionary
 
-from crackerjack.services.logging import get_logger
+from acb.depends import Inject, depends
+from acb.logger import Logger
 
 
 @dataclass
@@ -45,8 +46,10 @@ class CacheStats:
 
 
 class PerformanceCache:
+    @depends.inject
     def __init__(
         self,
+        logger: Inject[Logger],
         max_memory_mb: int = 50,
         default_ttl_seconds: int = 300,
         cleanup_interval_seconds: int = 60,
@@ -58,7 +61,7 @@ class PerformanceCache:
         self._cache: dict[str, CacheEntry] = {}
         self._lock = Lock()
         self._stats = CacheStats()
-        self._logger = get_logger("crackerjack.performance_cache")
+        self._logger = logger
         self._cleanup_task: asyncio.Task[None] | None = None
         self._invalidation_map: dict[str, set[str]] = {}
 
@@ -241,9 +244,9 @@ class PerformanceCache:
 
 
 class GitOperationCache:
-    def __init__(self, cache: PerformanceCache):
+    def __init__(self, cache: PerformanceCache, logger: Logger):
         self.cache = cache
-        self._logger = get_logger("crackerjack.git_cache")
+        self._logger = logger
 
     def _make_repo_key(self, repo_path: Path, operation: str, params: str = "") -> str:
         repo_hash = hashlib.md5(
@@ -268,7 +271,7 @@ class GitOperationCache:
     ) -> None:
         key = self._make_repo_key(repo_path, "branch_info")
         invalidation_keys = {f"git_repo: {repo_path}"}
-        self.cache.set[t.Any](key, branch_info, ttl_seconds, invalidation_keys)
+        self.cache.set(key, branch_info, ttl_seconds, invalidation_keys)
 
     def get_file_status(self, repo_path: Path) -> t.Any:
         key = self._make_repo_key(repo_path, "file_status")
@@ -282,7 +285,7 @@ class GitOperationCache:
     ) -> None:
         key = self._make_repo_key(repo_path, "file_status")
         invalidation_keys = {f"git_repo: {repo_path}", "git_files"}
-        self.cache.set[t.Any](key, file_status, ttl_seconds, invalidation_keys)
+        self.cache.set(key, file_status, ttl_seconds, invalidation_keys)
 
     def invalidate_repo(self, repo_path: Path) -> None:
         self.cache.invalidate(f"git_repo: {repo_path}")
@@ -290,9 +293,9 @@ class GitOperationCache:
 
 
 class FileSystemCache:
-    def __init__(self, cache: PerformanceCache):
+    def __init__(self, cache: PerformanceCache, logger: Logger):
         self.cache = cache
-        self._logger = get_logger("crackerjack.filesystem_cache")
+        self._logger = logger
 
     def _make_file_key(self, file_path: Path, operation: str) -> str:
         file_hash = hashlib.md5(
@@ -312,16 +315,16 @@ class FileSystemCache:
     ) -> None:
         key = self._make_file_key(file_path, "stats")
         invalidation_keys = {f"file: {file_path}"}
-        self.cache.set[t.Any](key, stats, ttl_seconds, invalidation_keys)
+        self.cache.set(key, stats, ttl_seconds, invalidation_keys)
 
     def invalidate_file(self, file_path: Path) -> None:
         self.cache.invalidate(f"file: {file_path}")
 
 
 class CommandResultCache:
-    def __init__(self, cache: PerformanceCache):
+    def __init__(self, cache: PerformanceCache, logger: Logger):
         self.cache = cache
-        self._logger = get_logger("crackerjack.command_cache")
+        self._logger = logger
 
     def _make_command_key(self, command: list[str], cwd: Path | None = None) -> str:
         cmd_str = " ".join(command)
@@ -352,7 +355,7 @@ class CommandResultCache:
         if cwd:
             invalidation_keys.add(f"cwd: {cwd}")
 
-        self.cache.set[t.Any](key, result, ttl_seconds, invalidation_keys)
+        self.cache.set(key, result, ttl_seconds, invalidation_keys)
 
     def invalidate_commands(self) -> None:
         self.cache.invalidate("commands")
@@ -371,12 +374,15 @@ def get_performance_cache() -> PerformanceCache:
 
 
 def get_git_cache() -> GitOperationCache:
-    return GitOperationCache(get_performance_cache())
+    performance_cache = get_performance_cache()
+    return GitOperationCache(performance_cache, logger=performance_cache._logger)
 
 
 def get_filesystem_cache() -> FileSystemCache:
-    return FileSystemCache(get_performance_cache())
+    performance_cache = get_performance_cache()
+    return FileSystemCache(performance_cache, logger=performance_cache._logger)
 
 
 def get_command_cache() -> CommandResultCache:
-    return CommandResultCache(get_performance_cache())
+    performance_cache = get_performance_cache()
+    return CommandResultCache(performance_cache, logger=performance_cache._logger)

crackerjack/services/{performance_monitor.py → monitoring/performance_monitor.py}

@@ -7,9 +7,11 @@ from pathlib import Path
 from threading import Lock
 from typing import Any
 
-from crackerjack.services.logging import get_logger
+from acb.depends import Inject, depends
+from acb.logger import Logger
+
 from crackerjack.services.memory_optimizer import MemoryOptimizer
-from crackerjack.services.performance_cache import get_performance_cache
+from crackerjack.services.monitoring.performance_cache import get_performance_cache
 
 
 @dataclass
@@ -119,15 +121,17 @@ class PerformanceBenchmark:
 
 
 class PerformanceMonitor:
+    @depends.inject
     def __init__(
         self,
+        logger: Inject[Logger],
         data_retention_days: int = 30,
         benchmark_history_size: int = 100,
     ):
         self.data_retention_days = data_retention_days
         self.benchmark_history_size = benchmark_history_size
         self._initialize_data_structures(benchmark_history_size)
-        self._initialize_services()
+        self._initialize_services(logger)
         self._initialize_thresholds()
 
     def _initialize_data_structures(self, history_size: int) -> None:
@@ -140,9 +144,9 @@ class PerformanceMonitor:
             lambda: deque(maxlen=history_size)  # type: ignore[arg-type]
         )
 
-    def _initialize_services(self) -> None:
+    def _initialize_services(self, logger: Logger) -> None:
         self._lock = Lock()
-        self._logger = get_logger("crackerjack.performance_monitor")
+        self._logger = logger
         self._memory_optimizer = MemoryOptimizer.get_instance()
         self._cache = get_performance_cache()
 
@@ -532,7 +536,7 @@ def get_performance_monitor() -> PerformanceMonitor:
     global _global_monitor
     with _monitor_lock:
         if _global_monitor is None:
-            _global_monitor = PerformanceMonitor()
+            _global_monitor = PerformanceMonitor(logger=depends.get_sync(Logger))
         return _global_monitor
 
 

crackerjack/services/parallel_executor.py

@@ -1,14 +1,23 @@
 import asyncio
+import subprocess
 import time
 import typing as t
-from concurrent.futures import ThreadPoolExecutor
+from contextlib import suppress
 from dataclasses import dataclass, field
 from enum import Enum
 from pathlib import Path
 
+from acb.depends import Inject, depends
+from acb.logger import Logger
+
 from crackerjack.config.hooks import HookDefinition, SecurityLevel
-from crackerjack.services.logging import get_logger
-from crackerjack.services.performance_cache import get_performance_cache
+from crackerjack.models.protocols import (
+    AsyncCommandExecutorProtocol,
+    ParallelHookExecutorProtocol,
+    PerformanceCacheProtocol,
+    ServiceProtocol,
+)
+from crackerjack.models.results import ExecutionResult, ParallelExecutionResult
 
 
 class ExecutionStrategy(Enum):
@@ -27,42 +36,19 @@ class ExecutionGroup:
     security_level: SecurityLevel = SecurityLevel.MEDIUM
 
 
-@dataclass
-class ExecutionResult:
-    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[str, t.Any])
-
+class ParallelHookExecutor(ParallelHookExecutorProtocol, ServiceProtocol):
+    """Executes hooks in parallel or sequentially based on defined strategies.
 
-@dataclass
-class ParallelExecutionResult:
-    group_name: str
-    total_operations: int
-    successful_operations: int
-    failed_operations: int
-    total_duration_seconds: float
-    results: list[ExecutionResult]
-
-    @property
-    def success_rate(self) -> float:
-        return (
-            self.successful_operations / self.total_operations
-            if self.total_operations > 0
-            else 0.0
-        )
+    This service manages the concurrent execution of various hooks (e.g., linting, formatting)
+    to optimize performance and provide faster feedback loops. It supports different execution
+    strategies and handles dependencies between hooks.
+    """
 
-    @property
-    def overall_success(self) -> bool:
-        return self.failed_operations == 0
-
-
-class ParallelHookExecutor:
+    @depends.inject
     def __init__(
         self,
+        logger: Inject[Logger],
+        cache: Inject[PerformanceCacheProtocol],
         max_workers: int = 3,
         timeout_seconds: int = 300,
         strategy: ExecutionStrategy = ExecutionStrategy.PARALLEL_SAFE,
@@ -70,8 +56,68 @@ class ParallelHookExecutor:
         self.max_workers = max_workers
         self.timeout_seconds = timeout_seconds
         self.strategy = strategy
-        self._logger = get_logger("crackerjack.parallel_executor")
-        self._cache = get_performance_cache()
+        self._logger = logger
+        self._cache = cache
+
+    def initialize(self) -> None:
+        pass
+
+    def cleanup(self) -> None:
+        pass
+
+    async def async_cleanup(self) -> None:
+        """Async cleanup for any remaining tasks."""
+        with suppress(RuntimeError):
+            loop = asyncio.get_running_loop()
+            pending_tasks = (
+                task
+                for task in asyncio.all_tasks(loop)
+                if not task.done()
+                and ("hook" in str(task).lower() or "parallel" in str(task).lower())
+            )
+
+            for task in pending_tasks:
+                if not task.done():
+                    try:
+                        task.cancel()
+                        await asyncio.wait_for(task, timeout=0.1)
+                    except (TimeoutError, asyncio.CancelledError):
+                        pass
+                    except RuntimeError as e:
+                        if "Event loop is closed" in str(e):
+                            return
+                        else:
+                            raise
+
+    def health_check(self) -> bool:
+        return True
+
+    def shutdown(self) -> None:
+        pass
+
+    def metrics(self) -> dict[str, t.Any]:
+        return {}
+
+    def is_healthy(self) -> bool:
+        return True
+
+    def register_resource(self, resource: t.Any) -> None:
+        pass
+
+    def cleanup_resource(self, resource: t.Any) -> None:
+        pass
+
+    def record_error(self, error: Exception) -> None:
+        pass
+
+    def increment_requests(self) -> None:
+        pass
+
+    def get_custom_metric(self, name: str) -> t.Any:
+        return None
+
+    def set_custom_metric(self, name: str, value: t.Any) -> None:
+        pass
 
     def analyze_hook_dependencies(
         self,
@@ -239,7 +285,7 @@ class ParallelHookExecutor:
                     f"Hook {hooks[i].name} failed with exception: {result}"
                 )
             else:
-                processed_results.append(result)
+                processed_results.append(t.cast(ExecutionResult, result))
 
         successful = sum(1 for r in processed_results if r.success)
         self._logger.info(
@@ -249,18 +295,82 @@ class ParallelHookExecutor:
         return processed_results
 
 
-class AsyncCommandExecutor:
+class AsyncCommandExecutor(AsyncCommandExecutorProtocol, ServiceProtocol):
+    """Executes shell commands asynchronously, with caching capabilities.
+
+    This service provides a robust way to run external commands without blocking
+    the main event loop, supporting parallel execution and caching of results
+    to improve performance and responsiveness.
+    """
+
+    @depends.inject
     def __init__(
         self,
+        logger: Inject[Logger],
+        cache: Inject[PerformanceCacheProtocol],
         max_workers: int = 4,
         cache_results: bool = True,
     ):
         self.max_workers = max_workers
         self.cache_results = cache_results
-        self._logger = get_logger("crackerjack.async_executor")
-        self._cache = get_performance_cache()
+        self._logger = logger
+        self._cache = cache
+        from concurrent.futures import ThreadPoolExecutor
+
         self._thread_pool = ThreadPoolExecutor(max_workers=max_workers)
 
+    def shutdown(self) -> None:
+        if hasattr(self, "_thread_pool"):
+            self._thread_pool.shutdown(wait=True)
+
+    def metrics(self) -> dict[str, t.Any]:
+        return {}
+
+    def is_healthy(self) -> bool:
+        return True
+
+    def register_resource(self, resource: t.Any) -> None:
+        pass
+
+    def cleanup_resource(self, resource: t.Any) -> None:
+        pass
+
+    def record_error(self, error: Exception) -> None:
+        pass
+
+    def increment_requests(self) -> None:
+        pass
+
+    def get_custom_metric(self, name: str) -> t.Any:
+        return None
+
+    def set_custom_metric(self, name: str, value: t.Any) -> None:
+        pass
+
+    async def async_cleanup(self) -> None:
+        """Async cleanup for any remaining command executor tasks."""
+        with suppress(RuntimeError):
+            loop = asyncio.get_running_loop()
+            pending_tasks = (
+                task
+                for task in asyncio.all_tasks(loop)
+                if not task.done()
+                and ("command" in str(task).lower() or "async" in str(task).lower())
+            )
+
+            for task in pending_tasks:
+                if not task.done():
+                    try:
+                        task.cancel()
+                        await asyncio.wait_for(task, timeout=0.1)
+                    except (TimeoutError, asyncio.CancelledError):
+                        pass
+                    except RuntimeError as e:
+                        if "Event loop is closed" in str(e):
+                            return
+                        else:
+                            raise
+
     async def execute_command(
         self,
         command: list[str],
@@ -307,7 +417,7 @@ class AsyncCommandExecutor:
                 )
                 processed_results.append(error_result)
             else:
-                processed_results.append(result)
+                processed_results.append(t.cast(ExecutionResult, result))
 
         successful = sum(1 for r in processed_results if r.success)
         self._logger.info(
@@ -325,8 +435,6 @@ class AsyncCommandExecutor:
         loop = asyncio.get_event_loop()
 
         def run_sync_command() -> ExecutionResult:
-            import subprocess
-
             try:
                 result = subprocess.run(
                     command,
@@ -370,9 +478,7 @@ class AsyncCommandExecutor:
         command: list[str],
         cwd: Path | None = None,
     ) -> ExecutionResult | None:
-        from crackerjack.services.performance_cache import get_command_cache
-
-        cache_result = get_command_cache().get_command_result(command, cwd)
+        cache_result = self._cache.get(self._get_cache_key(command, cwd))
         return t.cast(ExecutionResult | None, cache_result)
 
     async def _cache_result(
@@ -382,14 +488,13 @@ class AsyncCommandExecutor:
         ttl_seconds: int,
         cwd: Path | None = None,
     ) -> None:
-        from crackerjack.services.performance_cache import get_command_cache
+        self._cache.set(self._get_cache_key(command, cwd), result, ttl_seconds)
 
-        command_cache = get_command_cache()
-        command_cache.set_command_result(command, result, cwd, ttl_seconds)
-
-    def __del__(self) -> None:
-        if hasattr(self, "_thread_pool"):
-            self._thread_pool.shutdown(wait=False)
+    def _get_cache_key(self, command: list[str], cwd: Path | None) -> str:
+        key_parts = [" ".join(command)]
+        if cwd:
+            key_parts.append(str(cwd))
+        return ":".join(key_parts)
 
 
 _parallel_executor: ParallelHookExecutor | None = None
@@ -403,6 +508,8 @@ def get_parallel_executor(
     global _parallel_executor
     if _parallel_executor is None:
         _parallel_executor = ParallelHookExecutor(
+            logger=depends.get_sync(Logger),
+            cache=depends.get_sync(PerformanceCacheProtocol),
             max_workers=max_workers,
             strategy=strategy,
         )
@@ -412,5 +519,9 @@ def get_parallel_executor(
 def get_async_executor(max_workers: int = 4) -> AsyncCommandExecutor:
     global _async_executor
     if _async_executor is None:
-        _async_executor = AsyncCommandExecutor(max_workers=max_workers)
+        _async_executor = AsyncCommandExecutor(
+            logger=depends.get_sync(Logger),
+            cache=depends.get_sync(PerformanceCacheProtocol),
+            max_workers=max_workers,
+        )
     return _async_executor