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

crackerjack/services/thread_safe_status_collector.py

@@ -1,10 +1,3 @@
-"""
-Thread-safe status collection to prevent race conditions.
-
-Provides synchronized status data collection with proper locking,
-atomic operations, and consistency guarantees.
-"""
-
 import asyncio
 import json
 import threading
@@ -18,12 +11,10 @@ from .security_logger import SecurityEventLevel, SecurityEventType, get_security
 
 @dataclass
 class StatusSnapshot:
-    """Thread-safe snapshot of system status."""
-
-    services: dict[str, t.Any] = field(default_factory=dict)
-    jobs: dict[str, t.Any] = field(default_factory=dict)
-    server_stats: dict[str, t.Any] = field(default_factory=dict)
-    agent_suggestions: dict[str, t.Any] = field(default_factory=dict)
+    services: dict[str, t.Any] = field(default_factory=dict[str, t.Any])
+    jobs: dict[str, t.Any] = field(default_factory=dict[str, t.Any])
+    server_stats: dict[str, t.Any] = field(default_factory=dict[str, t.Any])
+    agent_suggestions: dict[str, t.Any] = field(default_factory=dict[str, t.Any])
     timestamp: float = field(default_factory=time.time)
     collection_duration: float = 0.0
     is_complete: bool = False
@@ -31,43 +22,22 @@ class StatusSnapshot:
 
 
 class ThreadSafeStatusCollector:
-    """
-    Thread-safe status collector with race condition prevention.
-
-    Features:
-    - Thread-safe data collection and aggregation
-    - Atomic status updates with consistency guarantees
-    - Deadlock prevention with ordered locking
-    - Timeout protection for all operations
-    - Error isolation and recovery
-    """
-
-    def __init__(self, timeout: float = 30.0):
-        """
-        Initialize thread-safe status collector.
-
-        Args:
-            timeout: Maximum time for status collection operations
-        """
+    def __init__(self, timeout: float = 30.0) -> None:
         self.timeout = timeout
         self.security_logger = get_security_logger()
 
-        # Thread safety primitives with ordered locking to prevent deadlocks
-        self._collection_lock = threading.RLock()  # Main collection lock
-        self._data_lock = threading.RLock()  # Data structure lock
-        self._file_lock = threading.RLock()  # File operation lock
+        self._collection_lock = threading.RLock()
+        self._data_lock = threading.RLock()
+        self._file_lock = threading.RLock()
 
-        # Status collection state
         self._current_snapshot: StatusSnapshot | None = None
         self._collection_in_progress = False
         self._collection_start_time = 0.0
 
-        # Cached data with expiration
         self._cache: dict[str, t.Any] = {}
         self._cache_timestamps: dict[str, float] = {}
-        self._cache_ttl = 5.0  # 5 second cache TTL
+        self._cache_ttl = 5.0
 
-        # Thread-local storage for per-thread state
         self._local = threading.local()
 
     async def collect_comprehensive_status(
@@ -77,32 +47,12 @@ class ThreadSafeStatusCollector:
         include_services: bool = True,
         include_stats: bool = True,
     ) -> StatusSnapshot:
-        """
-        Collect comprehensive system status with thread safety.
-
-        Args:
-            client_id: Client identifier for logging
-            include_jobs: Include job information
-            include_services: Include service information
-            include_stats: Include server statistics
-
-        Returns:
-            StatusSnapshot with collected data
-
-        Raises:
-            TimeoutError: If collection takes too long
-            RuntimeError: If collection fails due to concurrency issues
-        """
-
-        # Use async context manager for proper cleanup
         async with self._collection_context(client_id):
             start_time = time.time()
 
             try:
-                # Create new snapshot
                 snapshot = StatusSnapshot(timestamp=start_time)
 
-                # Collect data components in parallel with timeouts
                 collection_tasks = []
 
                 if include_services:
@@ -120,21 +70,18 @@ class ThreadSafeStatusCollector:
                         self._collect_server_stats(client_id, snapshot)
                     )
 
-                # Wait for all collections to complete with timeout
                 await asyncio.wait_for(
                     asyncio.gather(*collection_tasks, return_exceptions=True),
                     timeout=self.timeout,
                 )
 
-                # Finalize snapshot
                 snapshot.collection_duration = time.time() - start_time
                 snapshot.is_complete = True
 
-                # Log successful collection
                 self.security_logger.log_security_event(
                     event_type=SecurityEventType.STATUS_COLLECTED,
                     level=SecurityEventLevel.INFO,
-                    message=f"Status collection completed in {snapshot.collection_duration:.2f}s",
+                    message=f"Status collection completed in {snapshot.collection_duration: .2f}s",
                     client_id=client_id,
                     operation="collect_status",
                     additional_data={
@@ -169,7 +116,6 @@ class ThreadSafeStatusCollector:
                     additional_data={"error": str(e)},
                 )
 
-                # Return partial snapshot with error information
                 snapshot = StatusSnapshot(
                     timestamp=start_time,
                     collection_duration=time.time() - start_time,
@@ -180,16 +126,12 @@ class ThreadSafeStatusCollector:
                 return snapshot
 
     @asynccontextmanager
-    async def _collection_context(self, client_id: str):
-        """Context manager for status collection with proper cleanup."""
-
-        # Acquire collection lock with timeout
+    async def _collection_context(self, client_id: str) -> t.AsyncGenerator[None]:
         collection_acquired = False
         start_wait = time.time()
 
         try:
-            # Try to acquire collection lock
-            while time.time() - start_wait < 5.0:  # 5 second wait limit
+            while time.time() - start_wait < 5.0:
                 with self._collection_lock:
                     if not self._collection_in_progress:
                         self._collection_in_progress = True
@@ -213,7 +155,6 @@ class ThreadSafeStatusCollector:
             yield
 
         finally:
-            # Always release the collection lock
             if collection_acquired:
                 with self._collection_lock:
                     self._collection_in_progress = False
@@ -232,23 +173,18 @@ class ThreadSafeStatusCollector:
         client_id: str,
         snapshot: StatusSnapshot,
     ) -> None:
-        """Collect services data with thread safety."""
-
         try:
-            # Check cache first
             cached_data = self._get_cached_data("services")
             if cached_data is not None:
                 with self._data_lock:
                     snapshot.services = cached_data
                 return
 
-            # Import here to avoid circular dependencies
             from crackerjack.services.server_manager import (
                 find_mcp_server_processes,
                 find_websocket_server_processes,
             )
 
-            # Collect process data with timeout
             mcp_task = asyncio.create_task(asyncio.to_thread(find_mcp_server_processes))
             websocket_task = asyncio.create_task(
                 asyncio.to_thread(find_websocket_server_processes)
@@ -270,7 +206,6 @@ class ThreadSafeStatusCollector:
                 },
             }
 
-            # Atomically update snapshot and cache
             with self._data_lock:
                 snapshot.services = services_data
                 self._set_cached_data("services", services_data)
@@ -286,17 +221,13 @@ class ThreadSafeStatusCollector:
         client_id: str,
         snapshot: StatusSnapshot,
     ) -> None:
-        """Collect jobs data with thread safety."""
-
         try:
-            # Check cache first
             cached_data = self._get_cached_data("jobs")
             if cached_data is not None:
                 with self._data_lock:
                     snapshot.jobs = cached_data
                 return
 
-            # Get active jobs with file locking
             active_jobs = await self._get_active_jobs_safe()
 
             jobs_data = {
@@ -312,7 +243,6 @@ class ThreadSafeStatusCollector:
                 "details": active_jobs,
             }
 
-            # Atomically update snapshot and cache
             with self._data_lock:
                 snapshot.jobs = jobs_data
                 self._set_cached_data("jobs", jobs_data)
@@ -328,14 +258,11 @@ class ThreadSafeStatusCollector:
         client_id: str,
         snapshot: StatusSnapshot,
     ) -> None:
-        """Collect server statistics with thread safety."""
-
         try:
-            # Get context safely
             from crackerjack.mcp.context import get_context
 
             try:
-                context = get_context()
+                context: MCPServerContext | None = get_context()
             except RuntimeError:
                 context = None
 
@@ -344,14 +271,12 @@ class ThreadSafeStatusCollector:
                     snapshot.server_stats = {"error": "Server context not available"}
                 return
 
-            # Build stats with timeout protection
             stats_task = asyncio.create_task(
                 asyncio.to_thread(self._build_server_stats_safe, context)
             )
 
             server_stats = await asyncio.wait_for(stats_task, timeout=5.0)
 
-            # Atomically update snapshot
             with self._data_lock:
                 snapshot.server_stats = server_stats
 
@@ -362,11 +287,8 @@ class ThreadSafeStatusCollector:
                 snapshot.server_stats = {"error": error_msg}
 
     async def _get_active_jobs_safe(self) -> list[dict[str, t.Any]]:
-        """Get active jobs with file system synchronization."""
+        jobs: list[dict[str, t.Any]] = []
 
-        jobs = []
-
-        # Use file lock to prevent race conditions during file reading
         with self._file_lock:
             try:
                 from crackerjack.mcp.context import get_context
@@ -375,14 +297,11 @@ class ThreadSafeStatusCollector:
                 if not context or not context.progress_dir.exists():
                     return jobs
 
-                # Read job files with error handling
                 for progress_file in context.progress_dir.glob("job-*.json"):
                     try:
-                        # Use atomic read with timeout
                         content = progress_file.read_text(encoding="utf-8")
                         progress_data = json.loads(content)
 
-                        # Validate required fields
                         job_data = {
                             "job_id": progress_data.get("job_id", "unknown"),
                             "status": progress_data.get("status", "unknown"),
@@ -403,7 +322,6 @@ class ThreadSafeStatusCollector:
                         jobs.append(job_data)
 
                     except (json.JSONDecodeError, OSError, UnicodeDecodeError) as e:
-                        # Log file read error but continue processing other files
                         self.security_logger.log_security_event(
                             event_type=SecurityEventType.FILE_READ_ERROR,
                             level=SecurityEventLevel.WARNING,
@@ -423,8 +341,6 @@ class ThreadSafeStatusCollector:
         return jobs
 
     def _build_server_stats_safe(self, context: t.Any) -> dict[str, t.Any]:
-        """Build server stats with thread safety."""
-
         try:
             stats = {
                 "server_info": {
@@ -442,7 +358,9 @@ class ThreadSafeStatusCollector:
                     else None,
                 },
                 "resource_usage": {
-                    "temp_files_count": len(list(context.progress_dir.glob("*.json")))
+                    "temp_files_count": len(
+                        list[t.Any](context.progress_dir.glob("*.json"))
+                    )
                     if context.progress_dir.exists()
                     else 0,
                     "progress_dir": str(context.progress_dir),
@@ -450,7 +368,6 @@ class ThreadSafeStatusCollector:
                 "timestamp": time.time(),
             }
 
-            # Add state manager stats if available
             state_manager = getattr(context, "state_manager", None)
             if state_manager:
                 stats["state_manager"] = {
@@ -465,35 +382,28 @@ class ThreadSafeStatusCollector:
             return {"error": f"Failed to build server stats: {e}"}
 
     def _get_cached_data(self, key: str) -> dict[str, t.Any] | None:
-        """Get cached data if still valid."""
-
         current_time = time.time()
 
         with self._data_lock:
             if key in self._cache and key in self._cache_timestamps:
                 cache_age = current_time - self._cache_timestamps[key]
                 if cache_age < self._cache_ttl:
-                    return self._cache[key]
+                    cached_result: dict[str, t.Any] = self._cache[key]
+                    return cached_result
 
         return None
 
     def _set_cached_data(self, key: str, data: dict[str, t.Any]) -> None:
-        """Set cached data with timestamp."""
-
         with self._data_lock:
             self._cache[key] = data.copy() if hasattr(data, "copy") else data
             self._cache_timestamps[key] = time.time()
 
     def clear_cache(self) -> None:
-        """Clear all cached data."""
-
         with self._data_lock:
             self._cache.clear()
             self._cache_timestamps.clear()
 
     def get_collection_status(self) -> dict[str, t.Any]:
-        """Get current collection status and metrics."""
-
         with self._collection_lock:
             return {
                 "collection_in_progress": self._collection_in_progress,
@@ -505,13 +415,10 @@ class ThreadSafeStatusCollector:
             }
 
 
-# Global singleton instance
 _status_collector: ThreadSafeStatusCollector | None = None
 
 
 def get_thread_safe_status_collector() -> ThreadSafeStatusCollector:
-    """Get the global thread-safe status collector instance."""
-
     global _status_collector
     if _status_collector is None:
         _status_collector = ThreadSafeStatusCollector()
@@ -524,19 +431,6 @@ async def collect_secure_status(
     include_services: bool = True,
     include_stats: bool = True,
 ) -> StatusSnapshot:
-    """
-    Convenience function for secure status collection.
-
-    Args:
-        client_id: Client identifier for logging
-        include_jobs: Include job information
-        include_services: Include service information
-        include_stats: Include server statistics
-
-    Returns:
-        StatusSnapshot with collected data
-    """
-
     collector = get_thread_safe_status_collector()
     return await collector.collect_comprehensive_status(
         client_id=client_id,

crackerjack/services/unified_config.py

@@ -36,8 +36,6 @@ class CrackerjackConfig(BaseModel):
     skip_hooks: bool = False
     experimental_hooks: bool = False
 
-    # Removed unused configuration fields: performance_tracking, benchmark_mode, publish_enabled, keyring_provider
-
     batch_file_operations: bool = True
     file_operation_batch_size: int = 10
 
@@ -48,7 +46,8 @@ class CrackerjackConfig(BaseModel):
     def validate_package_path(cls, v: Any) -> Path:
         if isinstance(v, str):
             v = Path(v)
-        return v.resolve()
+        resolved_path: Path = v.resolve()
+        return resolved_path
 
     @field_validator("log_file", mode="before")
     @classmethod
@@ -56,8 +55,10 @@ class CrackerjackConfig(BaseModel):
         if v is None:
             return v
         if isinstance(v, str):
-            v = Path(v)
-        return v
+            path_v: Path = Path(v)
+            return path_v
+        validated_v: Path = t.cast(Path, v)
+        return validated_v
 
     @field_validator("test_workers")
     @classmethod
@@ -119,7 +120,6 @@ class EnvironmentConfigSource(ConfigSource):
         if value.lower() in ("false", "0", "no", "off"):
             return False
 
-        # Handle negative numbers with spaces (e.g., "- 10")
         cleaned_value = value.replace(" ", "")
 
         with suppress(ValueError):
@@ -186,9 +186,13 @@ class PyprojectConfigSource(ConfigSource):
             with self.pyproject_path.open("rb") as f:
                 pyproject_data = tomllib.load(f)
 
-            config = pyproject_data.get("tool", {}).get("crackerjack", {})
+            config: dict[str, t.Any] = pyproject_data.get("tool", {}).get(
+                "crackerjack", {}
+            )
 
-            self.logger.debug("Loaded pyproject config", keys=list(config.keys()))
+            self.logger.debug(
+                "Loaded pyproject config", keys=list[t.Any](config.keys())
+            )
             return config
 
         except ImportError:
@@ -197,9 +201,13 @@ class PyprojectConfigSource(ConfigSource):
 
                 with self.pyproject_path.open("rb") as f:
                     pyproject_data = tomllib.load(f)
-                config = pyproject_data.get("tool", {}).get("crackerjack", {})
-                self.logger.debug("Loaded pyproject config", keys=list(config.keys()))
-                return config
+                config_data: dict[str, t.Any] = pyproject_data.get("tool", {}).get(
+                    "crackerjack", {}
+                )
+                self.logger.debug(
+                    "Loaded pyproject config", keys=list[t.Any](config_data.keys())
+                )
+                return config_data
             except ImportError:
                 self.logger.warning(
                     "No TOML library available for pyproject.toml parsing",
@@ -236,7 +244,7 @@ class OptionsConfigSource(ConfigSource):
                 if value is not None:
                     config[config_key] = value
 
-        self.logger.debug("Loaded options config", keys=list(config.keys()))
+        self.logger.debug("Loaded options config", keys=list[t.Any](config.keys()))
         return config
 
 
@@ -304,7 +312,7 @@ class UnifiedConfigurationService:
                             "Merged config from source",
                             source_type=type(source).__name__,
                             priority=source.priority,
-                            keys=list(source_config.keys()),
+                            keys=list[t.Any](source_config.keys()),
                         )
                 except Exception as e:
                     self.logger.exception(

crackerjack/services/validation_rate_limiter.py

@@ -1,12 +1,3 @@
-"""
-Rate limiting for input validation to prevent abuse and DoS attacks.
-
-This module provides rate limiting functionality to:
-- Prevent excessive validation failures
-- Protect against DoS attacks via malformed input
-- Track validation patterns for security monitoring
-"""
-
 import time
 import typing as t
 from collections import defaultdict, deque
@@ -16,13 +7,11 @@ from .security_logger import SecurityEventLevel, get_security_logger
 
 
 class ValidationRateLimit:
-    """Rate limiting configuration for different validation types."""
-
     def __init__(
         self,
         max_failures: int = 10,
         window_seconds: int = 60,
-        block_duration: int = 300,  # 5 minutes
+        block_duration: int = 300,
     ):
         self.max_failures = max_failures
         self.window_seconds = window_seconds
@@ -30,20 +19,12 @@ class ValidationRateLimit:
 
 
 class ValidationRateLimiter:
-    """
-    Rate limiter for validation failures to prevent abuse.
-
-    Tracks validation failures by client/source and blocks excessive failures.
-    Uses sliding window approach for accurate rate limiting.
-    """
-
-    def __init__(self):
+    def __init__(self) -> None:
         self._failure_windows: dict[str, deque[float]] = defaultdict(deque)
         self._blocked_until: dict[str, float] = {}
         self._lock = Lock()
         self._logger = get_security_logger()
 
-        # Default rate limits by validation type
         self._limits = {
             "default": ValidationRateLimit(),
             "command_injection": ValidationRateLimit(
@@ -58,13 +39,11 @@ class ValidationRateLimiter:
         }
 
     def is_blocked(self, client_id: str) -> bool:
-        """Check if a client is currently blocked."""
         with self._lock:
             if client_id in self._blocked_until:
                 if time.time() < self._blocked_until[client_id]:
                     return True
                 else:
-                    # Block expired, remove it
                     del self._blocked_until[client_id]
             return False
 
@@ -74,35 +53,23 @@ class ValidationRateLimiter:
         validation_type: str,
         severity: SecurityEventLevel = SecurityEventLevel.MEDIUM,
     ) -> bool:
-        """
-        Record a validation failure and check if client should be blocked.
-
-        Returns True if the client should be blocked, False otherwise.
-        """
         with self._lock:
             current_time = time.time()
 
-            # Get rate limit for this validation type
             limit = self._limits.get(validation_type, self._limits["default"])
 
-            # Initialize failure window if needed
             if client_id not in self._failure_windows:
                 self._failure_windows[client_id] = deque()
 
-            # Clean old failures outside the window
             window = self._failure_windows[client_id]
             while window and current_time - window[0] > limit.window_seconds:
                 window.popleft()
 
-            # Record this failure
             window.append(current_time)
 
-            # Check if limit exceeded
             if len(window) >= limit.max_failures:
-                # Block this client
                 self._blocked_until[client_id] = current_time + limit.block_duration
 
-                # Log the rate limit exceeded event
                 self._logger.log_rate_limit_exceeded(
                     limit_type=validation_type,
                     current_count=len(window),
@@ -111,7 +78,6 @@ class ValidationRateLimiter:
                     block_duration=limit.block_duration,
                 )
 
-                # Clear the failure window since client is now blocked
                 self._failure_windows[client_id].clear()
 
                 return True
@@ -119,7 +85,6 @@ class ValidationRateLimiter:
             return False
 
     def get_remaining_attempts(self, client_id: str, validation_type: str) -> int:
-        """Get remaining validation attempts before rate limit."""
         with self._lock:
             if self.is_blocked(client_id):
                 return 0
@@ -129,7 +94,6 @@ class ValidationRateLimiter:
             return max(0, limit.max_failures - current_failures)
 
     def get_block_time_remaining(self, client_id: str) -> int:
-        """Get seconds remaining until client is unblocked."""
         with self._lock:
             if client_id in self._blocked_until:
                 remaining = max(0, int(self._blocked_until[client_id] - time.time()))
@@ -137,7 +101,6 @@ class ValidationRateLimiter:
             return 0
 
     def get_client_stats(self, client_id: str) -> dict[str, t.Any]:
-        """Get rate limiting statistics for a client."""
         with self._lock:
             current_time = time.time()
 
@@ -153,7 +116,6 @@ class ValidationRateLimiter:
                 window = self._failure_windows[client_id]
                 stats["total_failures"] = len(window)
 
-                # Count recent failures (last 5 minutes)
                 recent_count = sum(
                     1 for failure_time in window if current_time - failure_time <= 300
                 )
@@ -162,12 +124,10 @@ class ValidationRateLimiter:
             return stats
 
     def cleanup_expired_data(self) -> int:
-        """Clean up expired data and return number of items removed."""
         with self._lock:
             current_time = time.time()
             removed_count = 0
 
-            # Clean expired blocks
             expired_blocks = [
                 client_id
                 for client_id, block_until in self._blocked_until.items()
@@ -178,14 +138,11 @@ class ValidationRateLimiter:
                 del self._blocked_until[client_id]
                 removed_count += 1
 
-            # Clean old failure windows (keep only last 24 hours)
-            for client_id, window in list(self._failure_windows.items()):
-                # Remove failures older than 24 hours
-                while window and current_time - window[0] > 86400:  # 24 hours
+            for client_id, window in list[t.Any](self._failure_windows.items()):
+                while window and current_time - window[0] > 86400:
                     window.popleft()
                     removed_count += 1
 
-                # Remove empty windows
                 if not window:
                     del self._failure_windows[client_id]
 
@@ -198,7 +155,6 @@ class ValidationRateLimiter:
         window_seconds: int,
         block_duration: int,
     ) -> None:
-        """Update rate limits for a specific validation type."""
         with self._lock:
             self._limits[validation_type] = ValidationRateLimit(
                 max_failures=max_failures,
@@ -207,7 +163,6 @@ class ValidationRateLimiter:
             )
 
     def get_all_stats(self) -> dict[str, t.Any]:
-        """Get comprehensive rate limiting statistics."""
         with self._lock:
             current_time = time.time()
 
@@ -226,7 +181,6 @@ class ValidationRateLimiter:
                 "active_clients": [],
             }
 
-            # Get blocked client info
             for client_id, block_until in self._blocked_until.items():
                 remaining = max(0, int(block_until - current_time))
                 stats["blocked_clients"].append(
@@ -237,13 +191,12 @@ class ValidationRateLimiter:
                     }
                 )
 
-            # Get active client info (with recent failures)
             for client_id, window in self._failure_windows.items():
                 if client_id not in self._blocked_until and window:
                     recent_failures = sum(
                         1
                         for failure_time in window
-                        if current_time - failure_time <= 300  # Last 5 minutes
+                        if current_time - failure_time <= 300
                     )
                     if recent_failures > 0:
                         stats["active_clients"].append(
@@ -257,12 +210,10 @@ class ValidationRateLimiter:
             return stats
 
 
-# Global rate limiter instance
 _rate_limiter: ValidationRateLimiter | None = None
 
 
 def get_validation_rate_limiter() -> ValidationRateLimiter:
-    """Get the global validation rate limiter instance."""
     global _rate_limiter
     if _rate_limiter is None:
         _rate_limiter = ValidationRateLimiter()