pomera-ai-commander 0.1.0

package/core/search_operation_manager.py

@@ -0,0 +1,435 @@
+#!/usr/bin/env python3
+"""
+Search operation manager with cancellation, timeout handling, and resource management.
+"""
+
+import tkinter as tk
+import threading
+import time
+import weakref
+from typing import Dict, List, Optional, Callable, Any, Set
+from dataclasses import dataclass, field
+from enum import Enum
+import uuid
+
+class CancellationReason(Enum):
+    """Reasons for operation cancellation."""
+    USER_REQUESTED = "user_requested"
+    TIMEOUT = "timeout"
+    RESOURCE_LIMIT = "resource_limit"
+    WIDGET_DESTROYED = "widget_destroyed"
+    SYSTEM_SHUTDOWN = "system_shutdown"
+    ERROR = "error"
+
+class OperationStatus(Enum):
+    """Status of search operations."""
+    PENDING = "pending"
+    RUNNING = "running"
+    COMPLETED = "completed"
+    CANCELLED = "cancelled"
+    FAILED = "failed"
+
+@dataclass
+class OperationTimeout:
+    """Timeout configuration for operations."""
+    search_timeout: float = 30.0  # seconds
+    highlight_timeout: float = 60.0  # seconds
+    replace_timeout: float = 120.0  # seconds
+    preview_timeout: float = 15.0  # seconds
+
+@dataclass
+class ResourceLimits:
+    """Resource limits for operations."""
+    max_concurrent_operations: int = 5
+    max_operations_per_widget: int = 3
+    max_memory_mb: float = 100.0
+    max_matches_per_operation: int = 10000
+
+
+
+@dataclass
+class ManagedOperation:
+    """Represents a managed search operation."""
+    operation_id: str
+    operation_type: str
+    text_widget_ref: Optional[weakref.ref] = None
+    status: OperationStatus = OperationStatus.PENDING
+    cancellation_reason: Optional[CancellationReason] = None
+    
+    # Operation parameters
+    pattern: str = ""
+    replacement: str = ""
+    case_sensitive: bool = True
+    whole_words: bool = False
+    use_regex: bool = False
+    
+    # Control
+    cancel_event: threading.Event = field(default_factory=threading.Event)
+    completion_event: threading.Event = field(default_factory=threading.Event)
+    
+    # Callbacks
+    progress_callback: Optional[Callable] = None
+    completion_callback: Optional[Callable] = None
+    error_callback: Optional[Callable] = None
+    
+    # Results
+    results: Dict[str, Any] = field(default_factory=dict)
+    error_message: Optional[str] = None
+    
+    def is_cancelled(self) -> bool:
+        """Check if operation is cancelled."""
+        return self.cancel_event.is_set()
+    
+    def cancel(self, reason: CancellationReason):
+        """Cancel the operation with given reason."""
+        self.cancellation_reason = reason
+        self.status = OperationStatus.CANCELLED
+        self.cancel_event.set()
+        self.completion_event.set()
+    
+    def complete(self, results: Optional[Dict[str, Any]] = None):
+        """Mark operation as completed."""
+        if results:
+            self.results.update(results)
+        self.status = OperationStatus.COMPLETED
+        self.completion_event.set()
+    
+    def fail(self, error_message: str):
+        """Mark operation as failed."""
+        self.error_message = error_message
+        self.status = OperationStatus.FAILED
+        self.completion_event.set()
+    
+    def get_text_widget(self) -> Optional[tk.Text]:
+        """Get the text widget if it still exists."""
+        return self.text_widget_ref() if self.text_widget_ref else None
+
+class SearchOperationManager:
+    """
+    Manages search operations with cancellation, timeout handling,
+    and resource management for optimal performance.
+    """
+    
+    def __init__(self, 
+                 timeouts: Optional[OperationTimeout] = None,
+                 limits: Optional[ResourceLimits] = None):
+        
+        self.timeouts = timeouts or OperationTimeout()
+        self.limits = limits or ResourceLimits()
+        
+        # Operation tracking
+        self.operations: Dict[str, ManagedOperation] = {}
+        self.operations_lock = threading.RLock()
+        
+        # Widget-specific operation tracking
+        self.widget_operations: Dict[int, List[str]] = {}  # widget_id -> operation_ids
+        
+        # Timeout monitoring
+        self.timeout_monitor_thread = None
+        self.shutdown_event = threading.Event()
+        self._start_timeout_monitor()
+    
+    def _start_timeout_monitor(self):
+        """Start the timeout monitoring thread."""
+        if self.timeout_monitor_thread is None or not self.timeout_monitor_thread.is_alive():
+            self.timeout_monitor_thread = threading.Thread(
+                target=self._timeout_monitor_loop,
+                daemon=True,
+                name="SearchOperationTimeout"
+            )
+            self.timeout_monitor_thread.start()
+    
+    def _timeout_monitor_loop(self):
+        """Monitor operations for timeouts."""
+        while not self.shutdown_event.is_set():
+            try:
+                current_time = time.time()
+                operations_to_cancel = []
+                
+                with self.operations_lock:
+                    for op_id, operation in self.operations.items():
+                        if operation.status not in [OperationStatus.RUNNING, OperationStatus.PENDING]:
+                            continue
+                        
+                        # Check timeout based on operation type
+                        timeout = self._get_timeout_for_operation(operation.operation_type)
+                        if current_time - operation.metrics.start_time > timeout:
+                            operations_to_cancel.append((op_id, operation))
+                
+                # Cancel timed out operations
+                for op_id, operation in operations_to_cancel:
+                    self._cancel_operation_internal(operation, CancellationReason.TIMEOUT)
+                
+                # Sleep for a short interval
+                time.sleep(1.0)
+                
+            except Exception as e:
+                print(f"Error in timeout monitor: {e}")
+                time.sleep(1.0)
+    
+    def _get_timeout_for_operation(self, operation_type: str) -> float:
+        """Get timeout value for operation type."""
+        timeout_map = {
+            'search': self.timeouts.search_timeout,
+            'highlight': self.timeouts.highlight_timeout,
+            'replace': self.timeouts.replace_timeout,
+            'preview': self.timeouts.preview_timeout
+        }
+        return timeout_map.get(operation_type, self.timeouts.search_timeout)
+    
+    def create_operation(self,
+                        operation_type: str,
+                        text_widget: tk.Text,
+                        pattern: str,
+                        replacement: str = "",
+                        case_sensitive: bool = True,
+                        whole_words: bool = False,
+                        use_regex: bool = False,
+                        progress_callback: Optional[Callable] = None,
+                        completion_callback: Optional[Callable] = None,
+                        error_callback: Optional[Callable] = None) -> Optional[str]:
+        """
+        Create a new managed search operation.
+        
+        Returns:
+            Operation ID if created successfully, None if rejected due to limits
+        """
+        with self.operations_lock:
+            # Check resource limits
+            if not self._can_create_operation(text_widget):
+                return None
+            
+            # Generate unique operation ID
+            operation_id = str(uuid.uuid4())
+            
+            # Create operation
+            operation = ManagedOperation(
+                operation_id=operation_id,
+                operation_type=operation_type,
+                text_widget_ref=weakref.ref(text_widget),
+                pattern=pattern,
+                replacement=replacement,
+                case_sensitive=case_sensitive,
+                whole_words=whole_words,
+                use_regex=use_regex,
+                progress_callback=progress_callback,
+                completion_callback=completion_callback,
+                error_callback=error_callback
+            )
+            
+            # Track operation
+            self.operations[operation_id] = operation
+            
+            # Track by widget
+            widget_id = id(text_widget)
+            if widget_id not in self.widget_operations:
+                self.widget_operations[widget_id] = []
+            self.widget_operations[widget_id].append(operation_id)
+            
+            return operation_id
+    
+    def _can_create_operation(self, text_widget: tk.Text) -> bool:
+        """Check if a new operation can be created based on resource limits."""
+        # Check total concurrent operations
+        active_count = sum(1 for op in self.operations.values() 
+                          if op.status in [OperationStatus.PENDING, OperationStatus.RUNNING])
+        
+        if active_count >= self.limits.max_concurrent_operations:
+            return False
+        
+        # Check operations per widget
+        widget_id = id(text_widget)
+        if widget_id in self.widget_operations:
+            widget_active_count = sum(1 for op_id in self.widget_operations[widget_id]
+                                    if op_id in self.operations and 
+                                    self.operations[op_id].status in [OperationStatus.PENDING, OperationStatus.RUNNING])
+            
+            if widget_active_count >= self.limits.max_operations_per_widget:
+                return False
+        
+        return True
+    
+    def start_operation(self, operation_id: str) -> bool:
+        """Start a pending operation."""
+        with self.operations_lock:
+            if operation_id not in self.operations:
+                return False
+            
+            operation = self.operations[operation_id]
+            if operation.status != OperationStatus.PENDING:
+                return False
+            
+            # Check if widget still exists
+            if operation.get_text_widget() is None:
+                self._cancel_operation_internal(operation, CancellationReason.WIDGET_DESTROYED)
+                return False
+            
+            operation.status = OperationStatus.RUNNING
+            return True
+    
+    def cancel_operation(self, operation_id: str, reason: CancellationReason = CancellationReason.USER_REQUESTED) -> bool:
+        """Cancel a specific operation."""
+        with self.operations_lock:
+            if operation_id not in self.operations:
+                return False
+            
+            operation = self.operations[operation_id]
+            self._cancel_operation_internal(operation, reason)
+            return True
+    
+    def _cancel_operation_internal(self, operation: ManagedOperation, reason: CancellationReason):
+        """Internal method to cancel an operation."""
+        if operation.status in [OperationStatus.COMPLETED, OperationStatus.CANCELLED, OperationStatus.FAILED]:
+            return
+        
+        operation.cancel(reason)
+        
+        # Call error callback if provided
+        if operation.error_callback:
+            try:
+                operation.error_callback(operation, f"Operation cancelled: {reason.value}")
+            except Exception as e:
+                print(f"Error in operation error callback: {e}")
+    
+    def cancel_widget_operations(self, text_widget: tk.Text, reason: CancellationReason = CancellationReason.USER_REQUESTED):
+        """Cancel all operations for a specific widget."""
+        widget_id = id(text_widget)
+        
+        with self.operations_lock:
+            if widget_id not in self.widget_operations:
+                return
+            
+            for operation_id in self.widget_operations[widget_id][:]:  # Copy list to avoid modification during iteration
+                if operation_id in self.operations:
+                    operation = self.operations[operation_id]
+                    self._cancel_operation_internal(operation, reason)
+    
+    def cancel_all_operations(self, reason: CancellationReason = CancellationReason.SYSTEM_SHUTDOWN):
+        """Cancel all active operations."""
+        with self.operations_lock:
+            for operation in list(self.operations.values()):
+                self._cancel_operation_internal(operation, reason)
+    
+    def complete_operation(self, operation_id: str, results: Optional[Dict[str, Any]] = None) -> bool:
+        """Mark an operation as completed."""
+        with self.operations_lock:
+            if operation_id not in self.operations:
+                return False
+            
+            operation = self.operations[operation_id]
+            if operation.status != OperationStatus.RUNNING:
+                return False
+            
+            operation.complete(results)
+            
+            # Call completion callback if provided
+            if operation.completion_callback:
+                try:
+                    operation.completion_callback(operation)
+                except Exception as e:
+                    print(f"Error in operation completion callback: {e}")
+            
+            return True
+    
+    def fail_operation(self, operation_id: str, error_message: str) -> bool:
+        """Mark an operation as failed."""
+        with self.operations_lock:
+            if operation_id not in self.operations:
+                return False
+            
+            operation = self.operations[operation_id]
+            if operation.status not in [OperationStatus.PENDING, OperationStatus.RUNNING]:
+                return False
+            
+            operation.fail(error_message)
+            
+            # Call error callback if provided
+            if operation.error_callback:
+                try:
+                    operation.error_callback(operation, error_message)
+                except Exception as e:
+                    print(f"Error in operation error callback: {e}")
+            
+            return True
+    
+    def get_operation(self, operation_id: str) -> Optional[ManagedOperation]:
+        """Get operation by ID."""
+        with self.operations_lock:
+            return self.operations.get(operation_id)
+    
+    def get_widget_operations(self, text_widget: tk.Text) -> List[ManagedOperation]:
+        """Get all operations for a specific widget."""
+        widget_id = id(text_widget)
+        
+        with self.operations_lock:
+            if widget_id not in self.widget_operations:
+                return []
+            
+            operations = []
+            for operation_id in self.widget_operations[widget_id]:
+                if operation_id in self.operations:
+                    operations.append(self.operations[operation_id])
+            
+            return operations
+    
+    def get_active_operations(self) -> List[ManagedOperation]:
+        """Get all active (pending or running) operations."""
+        with self.operations_lock:
+            return [op for op in self.operations.values() 
+                   if op.status in [OperationStatus.PENDING, OperationStatus.RUNNING]]
+    
+    def cleanup_completed_operations(self, max_age_seconds: float = 300):
+        """Clean up old completed operations."""
+        current_time = time.time()
+        operations_to_remove = []
+        
+        with self.operations_lock:
+            for operation_id, operation in self.operations.items():
+                if operation.status in [OperationStatus.COMPLETED, OperationStatus.CANCELLED, OperationStatus.FAILED]:
+                    operations_to_remove.append(operation_id)
+            
+            # Remove old operations
+            for operation_id in operations_to_remove:
+                operation = self.operations.pop(operation_id, None)
+                if operation and operation.text_widget_ref:
+                    widget_id = id(operation.get_text_widget()) if operation.get_text_widget() else None
+                    if widget_id and widget_id in self.widget_operations:
+                        try:
+                            self.widget_operations[widget_id].remove(operation_id)
+                            if not self.widget_operations[widget_id]:
+                                del self.widget_operations[widget_id]
+                        except ValueError:
+                            pass
+    
+    def wait_for_operation(self, operation_id: str, timeout: Optional[float] = None) -> bool:
+        """Wait for an operation to complete."""
+        operation = self.get_operation(operation_id)
+        if not operation:
+            return False
+        
+        return operation.completion_event.wait(timeout)
+    
+    def shutdown(self):
+        """Shutdown the operation manager."""
+        self.cancel_all_operations(CancellationReason.SYSTEM_SHUTDOWN)
+        self.shutdown_event.set()
+        
+        if self.timeout_monitor_thread and self.timeout_monitor_thread.is_alive():
+            self.timeout_monitor_thread.join(timeout=2.0)
+
+# Global instance
+_global_operation_manager = None
+
+def get_operation_manager() -> SearchOperationManager:
+    """Get the global search operation manager instance."""
+    global _global_operation_manager
+    if _global_operation_manager is None:
+        _global_operation_manager = SearchOperationManager()
+    return _global_operation_manager
+
+def shutdown_operation_manager():
+    """Shutdown the global operation manager."""
+    global _global_operation_manager
+    if _global_operation_manager is not None:
+        _global_operation_manager.shutdown()
+        _global_operation_manager = None