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

crackerjack/models/resource_protocols.py

@@ -1,9 +1,3 @@
-"""Resource lifecycle management protocols.
-
-Defines protocols and interfaces for comprehensive resource management
-patterns throughout the crackerjack codebase.
-"""
-
 import typing as t
 from abc import ABC, abstractmethod
 from types import TracebackType
@@ -14,184 +8,104 @@ if t.TYPE_CHECKING:
 
 
 class AsyncCleanupProtocol(t.Protocol):
-    """Protocol for resources that support async cleanup."""
-
-    async def cleanup(self) -> None:
-        """Clean up the resource asynchronously."""
-        ...
+    async def cleanup(self) -> None: ...
 
 
 class SyncCleanupProtocol(t.Protocol):
-    """Protocol for resources that support synchronous cleanup."""
-
-    def cleanup(self) -> None:
-        """Clean up the resource synchronously."""
-        ...
+    def cleanup(self) -> None: ...
 
 
 class ResourceLifecycleProtocol(t.Protocol):
-    """Protocol for resources with full lifecycle management."""
-
-    async def initialize(self) -> None:
-        """Initialize the resource."""
-        ...
+    async def initialize(self) -> None: ...
 
-    async def cleanup(self) -> None:
-        """Clean up the resource."""
-        ...
+    async def cleanup(self) -> None: ...
 
-    def is_initialized(self) -> bool:
-        """Check if the resource is initialized."""
-        ...
+    def is_initialized(self) -> bool: ...
 
-    def is_closed(self) -> bool:
-        """Check if the resource is closed."""
-        ...
+    def is_closed(self) -> bool: ...
 
 
 class AsyncContextProtocol(t.Protocol):
-    """Protocol for async context managers."""
-
-    async def __aenter__(self) -> t.Self:
-        """Enter async context."""
-        ...
+    async def __aenter__(self) -> t.Self: ...
 
     async def __aexit__(
         self,
         exc_type: type[BaseException] | None,
         exc_val: BaseException | None,
         exc_tb: TracebackType | None,
-    ) -> None:
-        """Exit async context."""
-        ...
+    ) -> None: ...
 
 
 class ResourceManagerProtocol(t.Protocol):
-    """Protocol for resource managers."""
-
-    def register_resource(self, resource: AsyncCleanupProtocol) -> None:
-        """Register a resource for management."""
-        ...
+    def register_resource(self, resource: AsyncCleanupProtocol) -> None: ...
 
     def register_cleanup_callback(
         self, callback: t.Callable[[], t.Awaitable[None]]
-    ) -> None:
-        """Register a cleanup callback."""
-        ...
+    ) -> None: ...
 
-    async def cleanup_all(self) -> None:
-        """Clean up all managed resources."""
-        ...
+    async def cleanup_all(self) -> None: ...
 
 
 class FileResourceProtocol(t.Protocol):
-    """Protocol for file-based resources."""
-
     @property
-    def path(self) -> "Path":
-        """Get the file path."""
-        ...
+    def path(self) -> "Path": ...
 
-    def exists(self) -> bool:
-        """Check if the file exists."""
-        ...
+    def exists(self) -> bool: ...
 
-    async def cleanup(self) -> None:
-        """Clean up the file resource."""
-        ...
+    async def cleanup(self) -> None: ...
 
 
 class ProcessResourceProtocol(t.Protocol):
-    """Protocol for process-based resources."""
-
     @property
-    def pid(self) -> int:
-        """Get the process ID."""
-        ...
+    def pid(self) -> int: ...
 
-    def is_running(self) -> bool:
-        """Check if the process is running."""
-        ...
+    def is_running(self) -> bool: ...
 
-    async def cleanup(self) -> None:
-        """Clean up the process resource."""
-        ...
+    async def cleanup(self) -> None: ...
 
 
 class TaskResourceProtocol(t.Protocol):
-    """Protocol for asyncio task resources."""
-
     @property
-    def task(self) -> "asyncio.Task[t.Any]":
-        """Get the asyncio task."""
-        ...
+    def task(self) -> "asyncio.Task[t.Any]": ...
 
-    def is_done(self) -> bool:
-        """Check if the task is done."""
-        ...
+    def is_done(self) -> bool: ...
 
-    def is_cancelled(self) -> bool:
-        """Check if the task is cancelled."""
-        ...
+    def is_cancelled(self) -> bool: ...
 
-    async def cleanup(self) -> None:
-        """Clean up the task resource."""
-        ...
+    async def cleanup(self) -> None: ...
 
 
 class NetworkResourceProtocol(t.Protocol):
-    """Protocol for network-based resources."""
-
     @property
-    def is_connected(self) -> bool:
-        """Check if the resource is connected."""
-        ...
+    def is_connected(self) -> bool: ...
 
-    async def disconnect(self) -> None:
-        """Disconnect the resource."""
-        ...
+    async def disconnect(self) -> None: ...
 
-    async def cleanup(self) -> None:
-        """Clean up the network resource."""
-        ...
+    async def cleanup(self) -> None: ...
 
 
 class CacheResourceProtocol(t.Protocol):
-    """Protocol for cache-based resources."""
-
-    def clear(self) -> None:
-        """Clear the cache."""
-        ...
+    def clear(self) -> None: ...
 
-    def get_size(self) -> int:
-        """Get the cache size."""
-        ...
+    def get_size(self) -> int: ...
 
-    async def cleanup(self) -> None:
-        """Clean up the cache resource."""
-        ...
+    async def cleanup(self) -> None: ...
 
 
-# Abstract base classes for resource implementations
 class AbstractManagedResource(ABC):
-    """Abstract base class for managed resources."""
-
     def __init__(self) -> None:
         self._initialized = False
         self._closed = False
 
     @abstractmethod
     async def _do_initialize(self) -> None:
-        """Perform resource initialization. Override in subclasses."""
         pass
 
     @abstractmethod
     async def _do_cleanup(self) -> None:
-        """Perform resource cleanup. Override in subclasses."""
         pass
 
     async def initialize(self) -> None:
-        """Initialize the resource if not already initialized."""
         if self._initialized:
             return
 
@@ -203,7 +117,6 @@ class AbstractManagedResource(ABC):
             raise
 
     async def cleanup(self) -> None:
-        """Clean up the resource if not already closed."""
         if self._closed:
             return
 
@@ -211,7 +124,6 @@ class AbstractManagedResource(ABC):
         try:
             await self._do_cleanup()
         except Exception:
-            # Log but don't re-raise during cleanup
             import logging
 
             logging.getLogger(__name__).warning(
@@ -219,15 +131,12 @@ class AbstractManagedResource(ABC):
             )
 
     def is_initialized(self) -> bool:
-        """Check if the resource is initialized."""
         return self._initialized
 
     def is_closed(self) -> bool:
-        """Check if the resource is closed."""
         return self._closed
 
     async def __aenter__(self) -> t.Self:
-        """Enter async context and initialize."""
         await self.initialize()
         return self
 
@@ -237,41 +146,32 @@ class AbstractManagedResource(ABC):
         exc_val: BaseException | None,
         exc_tb: TracebackType | None,
     ) -> None:
-        """Exit async context and cleanup."""
         await self.cleanup()
 
 
 class AbstractFileResource(AbstractManagedResource):
-    """Abstract base class for file-based resources."""
-
     def __init__(self, path: "Path") -> None:
         super().__init__()
         self._path = path
 
     @property
     def path(self) -> "Path":
-        """Get the file path."""
         return self._path
 
     def exists(self) -> bool:
-        """Check if the file exists."""
         return self._path.exists()
 
 
 class AbstractProcessResource(AbstractManagedResource):
-    """Abstract base class for process-based resources."""
-
     def __init__(self, pid: int) -> None:
         super().__init__()
         self._pid = pid
 
     @property
     def pid(self) -> int:
-        """Get the process ID."""
         return self._pid
 
     def is_running(self) -> bool:
-        """Check if the process is running."""
         try:
             import os
 
@@ -282,59 +182,49 @@ class AbstractProcessResource(AbstractManagedResource):
 
 
 class AbstractTaskResource(AbstractManagedResource):
-    """Abstract base class for asyncio task resources."""
-
     def __init__(self, task: "asyncio.Task[t.Any]") -> None:
         super().__init__()
         self._task = task
 
     @property
     def task(self) -> "asyncio.Task[t.Any]":
-        """Get the asyncio task."""
         return self._task
 
     def is_done(self) -> bool:
-        """Check if the task is done."""
         return self._task.done()
 
     def is_cancelled(self) -> bool:
-        """Check if the task is cancelled."""
         return self._task.cancelled()
 
 
 class AbstractNetworkResource(AbstractManagedResource):
-    """Abstract base class for network-based resources."""
-
     def __init__(self) -> None:
         super().__init__()
         self._connected = False
 
     @property
     def is_connected(self) -> bool:
-        """Check if the resource is connected."""
         return self._connected and not self._closed
 
     async def disconnect(self) -> None:
-        """Disconnect the resource."""
         if self._connected:
             self._connected = False
             await self._do_disconnect()
 
     @abstractmethod
     async def _do_disconnect(self) -> None:
-        """Perform disconnection. Override in subclasses."""
         pass
 
     async def _do_cleanup(self) -> None:
-        """Cleanup includes disconnection."""
         await self.disconnect()
 
 
-# Resource lifecycle decorators
-def with_resource_cleanup(resource_attr: str):
-    """Decorator to ensure resource cleanup on method exit."""
-
-    def decorator(func: t.Callable[..., t.Awaitable[t.Any]]):
+def with_resource_cleanup(
+    resource_attr: str,
+) -> t.Callable[..., t.Callable[..., t.Awaitable[t.Any]]]:
+    def decorator(
+        func: t.Callable[..., t.Awaitable[t.Any]],
+    ) -> t.Callable[..., t.Awaitable[t.Any]]:
         async def wrapper(self: t.Any, *args: t.Any, **kwargs: t.Any) -> t.Any:
             resource = getattr(self, resource_attr, None)
             try:
@@ -348,10 +238,12 @@ def with_resource_cleanup(resource_attr: str):
     return decorator
 
 
-def ensure_initialized(resource_attr: str):
-    """Decorator to ensure resource is initialized before method execution."""
-
-    def decorator(func: t.Callable[..., t.Awaitable[t.Any]]):
+def ensure_initialized(
+    resource_attr: str,
+) -> t.Callable[..., t.Callable[..., t.Awaitable[t.Any]]]:
+    def decorator(
+        func: t.Callable[..., t.Awaitable[t.Any]],
+    ) -> t.Callable[..., t.Awaitable[t.Any]]:
         async def wrapper(self: t.Any, *args: t.Any, **kwargs: t.Any) -> t.Any:
             resource = getattr(self, resource_attr, None)
             if resource and hasattr(resource, "initialize"):
@@ -363,92 +255,45 @@ def ensure_initialized(resource_attr: str):
     return decorator
 
 
-# Resource health monitoring protocols
 class HealthCheckProtocol(t.Protocol):
-    """Protocol for health checking resources."""
-
-    async def health_check(self) -> dict[str, t.Any]:
-        """Perform health check and return status."""
-        ...
+    async def health_check(self) -> dict[str, t.Any]: ...
 
-    def is_healthy(self) -> bool:
-        """Quick health check."""
-        ...
+    def is_healthy(self) -> bool: ...
 
 
 class MonitorableResourceProtocol(t.Protocol):
-    """Protocol for resources that can be monitored."""
+    def get_metrics(self) -> dict[str, t.Any]: ...
 
-    def get_metrics(self) -> dict[str, t.Any]:
-        """Get resource metrics."""
-        ...
+    def get_status(self) -> str: ...
 
-    def get_status(self) -> str:
-        """Get resource status string."""
-        ...
+    async def health_check(self) -> dict[str, t.Any]: ...
 
-    async def health_check(self) -> dict[str, t.Any]:
-        """Perform health check."""
-        ...
 
-
-# Resource factory protocols
 class ResourceFactoryProtocol(t.Protocol):
-    """Protocol for resource factories."""
-
-    async def create_resource(self, **kwargs: t.Any) -> AsyncCleanupProtocol:
-        """Create a new resource instance."""
-        ...
+    async def create_resource(self, **kwargs: t.Any) -> AsyncCleanupProtocol: ...
 
-    def get_resource_type(self) -> str:
-        """Get the resource type name."""
-        ...
+    def get_resource_type(self) -> str: ...
 
 
 class PooledResourceProtocol(t.Protocol):
-    """Protocol for pooled resources."""
-
-    async def acquire(self) -> AsyncCleanupProtocol:
-        """Acquire a resource from the pool."""
-        ...
+    async def acquire(self) -> AsyncCleanupProtocol: ...
 
-    async def release(self, resource: AsyncCleanupProtocol) -> None:
-        """Release a resource back to the pool."""
-        ...
+    async def release(self, resource: AsyncCleanupProtocol) -> None: ...
 
-    def get_pool_size(self) -> int:
-        """Get current pool size."""
-        ...
+    def get_pool_size(self) -> int: ...
 
-    def get_active_count(self) -> int:
-        """Get count of active resources."""
-        ...
+    def get_active_count(self) -> int: ...
 
 
-# Error handling protocols
 class ResourceErrorProtocol(t.Protocol):
-    """Protocol for resource error handling."""
+    def handle_error(self, error: Exception) -> bool: ...
 
-    def handle_error(self, error: Exception) -> bool:
-        """Handle resource error. Return True if error was handled."""
-        ...
+    def should_retry(self, error: Exception) -> bool: ...
 
-    def should_retry(self, error: Exception) -> bool:
-        """Check if operation should be retried on this error."""
-        ...
-
-    def get_retry_delay(self, attempt: int) -> float:
-        """Get delay before retry attempt."""
-        ...
+    def get_retry_delay(self, attempt: int) -> float: ...
 
 
 class FallbackResourceProtocol(t.Protocol):
-    """Protocol for resources with fallback capabilities."""
-
-    async def get_fallback(self) -> AsyncCleanupProtocol | None:
-        """Get fallback resource if primary fails."""
-        ...
+    async def get_fallback(self) -> AsyncCleanupProtocol | None: ...
 
-    def has_fallback(self) -> bool:
-        """Check if fallback is available."""
-        ...
+    def has_fallback(self) -> bool: ...

crackerjack/monitoring/ai_agent_watchdog.py

@@ -21,7 +21,7 @@ class AgentPerformanceMetrics:
     failed_fixes: int = 0
     average_confidence: float = 0.0
     average_execution_time: float = 0.0
-    issue_types_handled: dict[IssueType, int] = field(default_factory=dict)
+    issue_types_handled: dict[IssueType, int] = field(default_factory=dict[str, t.Any])
     recent_failures: list[str] = field(default_factory=list)
     last_successful_fix: datetime | None = None
     regression_patterns: list[str] = field(default_factory=list)
@@ -34,7 +34,7 @@ class WatchdogAlert:
     agent_name: str | None = None
     issue_id: str | None = None
     timestamp: datetime = field(default_factory=datetime.now)
-    details: dict[str, t.Any] = field(default_factory=dict)
+    details: dict[str, t.Any] = field(default_factory=dict[str, t.Any])
 
 
 class AIAgentWatchdog:
@@ -54,7 +54,7 @@ class AIAgentWatchdog:
         self.min_success_rate = 0.6
         self.max_recent_failures = 3
 
-    async def start_monitoring(self, coordinator: AgentCoordinator):
+    async def start_monitoring(self, coordinator: AgentCoordinator) -> None:
         self.monitoring_active = True
         self.console.print("🔍 [bold green]AI Agent Watchdog Started[/bold green]")
 
@@ -70,14 +70,14 @@ class AIAgentWatchdog:
             f"📊 Monitoring {len(coordinator.agents)} agents: {[a.__class__.__name__ for a in coordinator.agents]}"
         )
 
-    def stop_monitoring(self):
+    def stop_monitoring(self) -> None:
         self.monitoring_active = False
         self.console.print("🔍 [bold yellow]AI Agent Watchdog Stopped[/bold yellow]")
         self._generate_final_report()
 
     async def monitor_issue_handling(
         self, agent_name: str, issue: Issue, result: FixResult, execution_time: float
-    ):
+    ) -> None:
         if not self.monitoring_active:
             return
 
@@ -134,7 +134,7 @@ class AIAgentWatchdog:
         result: FixResult,
         execution_time: float,
         metrics: AgentPerformanceMetrics,
-    ):
+    ) -> None:
         alerts = []
 
         if execution_time > self.max_execution_time:
@@ -179,14 +179,14 @@ class AIAgentWatchdog:
             )
 
         if len(metrics.recent_failures) >= self.max_recent_failures:
-            unique_failures = set(metrics.recent_failures)
+            unique_failures = set[t.Any](metrics.recent_failures)
             if len(unique_failures) == 1:
                 alerts.append(
                     WatchdogAlert(
                         level="error",
                         message=f"Agent repeating same failure {len(metrics.recent_failures)} times",
                         agent_name=agent_name,
-                        details={"repeated_failure": list(unique_failures)[0]},
+                        details={"repeated_failure": list[t.Any](unique_failures)[0]},
                     )
                 )
 
@@ -194,7 +194,7 @@ class AIAgentWatchdog:
             self.alerts.append(alert)
             await self._handle_alert(alert)
 
-    async def _handle_alert(self, alert: WatchdogAlert):
+    async def _handle_alert(self, alert: WatchdogAlert) -> None:
         colors = {"warning": "yellow", "error": "red", "critical": "bold red"}
         color = colors.get(alert.level) or "white"
 
@@ -270,7 +270,7 @@ class AIAgentWatchdog:
         cutoff = datetime.now() - timedelta(hours=hours)
         return [alert for alert in self.alerts if alert.timestamp > cutoff]
 
-    def _generate_final_report(self):
+    def _generate_final_report(self) -> None:
         self.console.print("\n📊 [bold]AI Agent Watchdog Final Report[/bold]")
 
         total_issues = sum(
@@ -314,7 +314,7 @@ class AIAgentWatchdog:
 
         self._save_monitoring_report()
 
-    def _save_monitoring_report(self):
+    def _save_monitoring_report(self) -> None:
         report_data = {
             "timestamp": datetime.now().isoformat(),
             "metrics": {
@@ -351,13 +351,13 @@ class AIAgentWatchdog:
         report_file = Path(".crackerjack") / "ai_agent_monitoring_report.json"
         report_file.parent.mkdir(exist_ok=True)
 
-        with open(report_file, "w") as f:
+        with report_file.open("w") as f:
             json.dump(report_data, f, indent=2)
 
         self.console.print(f"📄 Detailed report saved: {report_file}")
 
 
-async def run_agent_monitoring_demo():
+async def run_agent_monitoring_demo() -> None:
     console = Console()
     watchdog = AIAgentWatchdog(console)