""" Sistema de Autocompletado para la Calculadora MAV CAS Híbrida """ import time import re from typing import List, Tuple, Optional from PySide6.QtCore import Qt, QTimer from PySide6.QtGui import QTextCursor import logging from .gui_widgets import AutocompletePopup from .sympy_Helper import SympyTools as SympyHelper from .type_registry import get_registered_base_context class AutocompleteManager: """Gestor del sistema de autocompletado""" def __init__(self, parent_app): self.parent_app = parent_app self.logger = logging.getLogger(__name__) # Variables de autocompletado self._autocomplete_popup = None self._autocomplete_active = False self._autocomplete_suggestions = [] self._autocomplete_filter_text = "" self._autocomplete_trigger_pos = None self._popup_disabled_until_next_dot = False self._variable_popup_active = False self._last_navigation_time = 0 self._last_input_change = 0 self._current_suggestions = [] self._is_global_popup = False # Timers self._variable_popup_timer = QTimer() self._variable_popup_timer.setSingleShot(True) self._variable_popup_timer.timeout.connect(self._show_variable_autocomplete_improved) def handle_key_press(self, event) -> bool: """Maneja eventos de teclado para autocompletado - retorna True si manejó el evento""" # Navegación en popup if self._autocomplete_active or self._variable_popup_active: if event.key() == Qt.Key_Up: self._handle_arrow_key(-1) return True elif event.key() == Qt.Key_Down: self._handle_arrow_key(1) return True elif event.key() == Qt.Key_Tab: self._handle_tab_key() return True elif event.key() == Qt.Key_Escape: self._handle_escape_key() return True elif event.key() in [Qt.Key_Return, Qt.Key_Enter]: self._select_autocomplete() return True # Detectar backspace para filtrar autocompletado o cerrar popup if event.key() == Qt.Key_Backspace: if self._autocomplete_active: # Filtrar dinámicamente al eliminar caracteres QTimer.singleShot(1, self._filter_autocomplete) QTimer.singleShot(1, self._check_dot_removal) else: # Activar autocompletado de variables si no está activo QTimer.singleShot(50, self._schedule_variable_autocomplete_improved) # Procesar autocompletado después de insertar carácter if event.text() and not event.modifiers() & Qt.ControlModifier: # Guardar datos del evento para evitar que se elimine el objeto event_text = event.text() event_key = event.key() QTimer.singleShot(10, lambda: self._on_key_release_deferred(event_text, event_key)) return False def _on_key_release_deferred(self, event_text: str, event_key: int): """Maneja eventos después de insertar carácter usando datos guardados""" # Cancelar timer de variables self._variable_popup_timer.stop() # Verificar si acabamos de navegar just_navigated = (time.time() - self._last_navigation_time) < 0.1 # Caracteres que cierran el autocompletado closing_chars = [' ', '+', '-', '*', '/', '(', ')', '=', ',', ';', '>', '<', '!'] # Cerrar autocompletado con símbolos y espacio if self._autocomplete_active and event_text in closing_chars: self._close_autocomplete_popup() return # Manejar autocompletado con punto if event_text == '.' and not self._popup_disabled_until_next_dot: if self._variable_popup_active: self._close_autocomplete_popup() self._handle_dot_autocomplete() # Filtrar autocompletado si está activo (incluye caracteres alfanuméricos y backspace procesado) elif self._autocomplete_active and not just_navigated: self._filter_autocomplete() # Marcar tiempo del último cambio if event_text: self._last_input_change = time.time() # Programar autocompletado de variables - también cuando se eliminen caracteres if not self._autocomplete_active and not self._popup_disabled_until_next_dot: self._schedule_variable_autocomplete_improved() elif self._variable_popup_active and not just_navigated: # Si el popup de variables está activo, regenerar dinámicamente QTimer.singleShot(50, self._regenerate_variable_autocomplete) def _handle_dot_autocomplete(self): """Maneja el autocompletado cuando se escribe un punto""" self._close_autocomplete_popup() cursor = self.parent_app.input_text.textCursor() cursor_pos = cursor.position() # Obtener línea actual cursor.select(QTextCursor.LineUnderCursor) line_text = cursor.selectedText() # Calcular posición del punto en la línea line_start = cursor.selectionStart() dot_pos_in_line = cursor_pos - line_start - 1 if dot_pos_in_line < 0: return # Guardar posición del trigger self._autocomplete_trigger_pos = cursor_pos self._autocomplete_filter_text = "" # Texto antes del punto text_before_dot = line_text[:dot_pos_in_line].strip() # Determinar si es popup GLOBAL if not text_before_dot: self.logger.debug("Dot en línea vacía. Ofreciendo sugerencias globales.") suggestions = self._get_global_suggestions() if suggestions: self._show_autocomplete_popup(suggestions, is_global_popup=True) return # Es popup de OBJETO obj_expr_str = self._extract_object_expression(text_before_dot) if not obj_expr_str: return self.logger.debug(f"Autocompletado para objeto: '{obj_expr_str}'") # Caso especial para sympy if obj_expr_str == "sympy": methods = SympyHelper.PopupFunctionList() if methods: self._show_autocomplete_popup(methods, is_global_popup=False) return # Preprocesar con bracket parser si es necesario if '[' in obj_expr_str: obj_expr_str = self.parent_app.engine.parser._transform_brackets(obj_expr_str) # Evaluar la expresión del objeto eval_context = self.parent_app.engine._get_full_context() try: obj = eval(obj_expr_str, eval_context) self.logger.debug(f"Objeto evaluado: {type(obj)}") # Mostrar métodos del objeto if hasattr(obj, 'PopupFunctionList'): methods = obj.PopupFunctionList() if methods: self._show_autocomplete_popup(methods, is_global_popup=False) except Exception as e: self.logger.debug(f"Error evaluando objeto '{obj_expr_str}': {e}") def _extract_object_expression(self, text: str) -> str: """Extrae la expresión del objeto del texto antes del punto""" obj_expr_regex = r"([a-zA-Z_][a-zA-Z0-9_]*(?:\[[^\]]*\])?(?:(?:\s*\.\s*[a-zA-Z_][a-zA-Z0-9_]*)(?:\[[^\]]*\])?)*)$" match = re.search(obj_expr_regex, text) if match: return match.group(1).replace(" ", "") # Fallback if re.match(r"^[a-zA-Z_0-9\(\)\[\]\.\"\'\+\-\*\/ ]*$", text) and \ not text.endswith(("+", "-", "*", "/", "(", ",")): return text return "" def _get_global_suggestions(self) -> List[Tuple[str, str]]: """Obtiene sugerencias globales para autocompletado""" suggestions = [] try: # Obtener contexto dinámico dynamic_context = get_registered_base_context() for name, class_or_func in dynamic_context.items(): if name[0].isupper(): # Prioritizar capitalizados hint = f"Tipo o función: {name}" if hasattr(class_or_func, '__doc__') and class_or_func.__doc__: first_line = class_or_func.__doc__.strip().split('\n')[0] hint = f"{name} - {first_line}" suggestions.append((name, hint)) # Añadir funciones SymPy sympy_functions = SympyHelper.PopupFunctionList() if sympy_functions: current_names = {s[0] for s in suggestions} for fname, fhint in sympy_functions: if fname not in current_names: suggestions.append((fname, fhint)) # Añadir variables del contexto actual try: context = self.parent_app.engine._get_full_context() current_names = {s[0] for s in suggestions} for name, value in context.items(): if (not name.startswith('_') and not callable(value) and name not in ['sympy', 'math', 'numpy', 'plt', 'builtins'] and name not in current_names): # Descripción del valor value_str = str(value) if len(value_str) > 20: value_str = value_str[:17] + "..." suggestions.append((name, f"Variable = {value_str}")) except Exception: pass except Exception as e: self.logger.debug(f"Error obteniendo sugerencias globales: {e}") suggestions.sort(key=lambda x: x[0]) return suggestions def _schedule_variable_autocomplete_improved(self): """Programa el autocompletado de variables""" if self._autocomplete_active or self._popup_disabled_until_next_dot: return # Verificar que estemos escribiendo cursor = self.parent_app.input_text.textCursor() cursor.select(QTextCursor.LineUnderCursor) current_line = cursor.selectedText().strip() if not current_line or current_line.endswith('.'): return # Programar para 800ms después self._variable_popup_timer.start(800) def _regenerate_variable_autocomplete(self): """Regenera dinámicamente el autocompletado de variables""" if not self._variable_popup_active: return # Obtener la palabra actual bajo el cursor cursor = self.parent_app.input_text.textCursor() cursor.select(QTextCursor.WordUnderCursor) filter_text = cursor.selectedText().lower() # Obtener variables del contexto actual try: context = self.parent_app.engine._get_full_context() variables = [] # Filtrar variables for name, value in context.items(): if (not name.startswith('_') and not callable(value) and name not in ['sympy', 'math', 'numpy', 'plt', 'builtins']): # Descripción del valor value_str = str(value) if len(value_str) > 20: value_str = value_str[:17] + "..." variables.append((name, f"= {value_str}")) if variables: variables.sort(key=lambda x: x[0]) # Filtrar por texto actual si existe if filter_text: filtered_vars = [ (name, value) for name, value in variables if name.lower().startswith(filter_text) and name.lower() != filter_text ] else: filtered_vars = variables if filtered_vars: # Actualizar sugerencias y popup self._current_suggestions = variables if self._autocomplete_popup: self._autocomplete_popup.set_suggestions(filtered_vars) self._autocomplete_popup.adjust_size() else: self._close_autocomplete_popup() else: self._close_autocomplete_popup() except Exception as e: self.logger.debug(f"Error regenerando variables: {e}") def _show_variable_autocomplete_improved(self): """Muestra autocompletado de variables disponibles""" if self._autocomplete_active or self._variable_popup_active: return # Verificar línea actual cursor = self.parent_app.input_text.textCursor() cursor.select(QTextCursor.LineUnderCursor) current_line = cursor.selectedText().strip() if not current_line or current_line.endswith('.'): return # Obtener variables del contexto try: context = self.parent_app.engine._get_full_context() variables = [] # Filtrar variables for name, value in context.items(): if (not name.startswith('_') and not callable(value) and name not in ['sympy', 'math', 'numpy', 'plt', 'builtins']): # Descripción del valor value_str = str(value) if len(value_str) > 20: value_str = value_str[:17] + "..." variables.append((name, value_str)) if variables: variables.sort(key=lambda x: x[0]) # Filtrar por palabra actual words = current_line.split() if words: last_word = words[-1] filtered_vars = [ (name, value) for name, value in variables if name.lower().startswith(last_word.lower()) and name != last_word ] if filtered_vars: self._show_variable_popup(filtered_vars) except Exception as e: self.logger.debug(f"Error obteniendo variables: {e}") def _show_autocomplete_popup(self, suggestions: List[Tuple[str, str]], is_global_popup: bool = False): """Muestra popup de autocompletado""" if not suggestions: return self._close_autocomplete_popup() # Guardar estado self._current_suggestions = suggestions.copy() self._is_global_popup = is_global_popup self._autocomplete_active = True # Crear popup self._autocomplete_popup = AutocompletePopup(self.parent_app) self._autocomplete_popup.set_suggestions(suggestions) self._autocomplete_popup.item_selected.connect(self._on_autocomplete_selected) # Posicionar cursor_rect = self.parent_app.input_text.cursorRect() global_pos = self.parent_app.input_text.mapToGlobal(cursor_rect.bottomLeft()) self._autocomplete_popup.move(global_pos) self._autocomplete_popup.adjust_size() self._autocomplete_popup.show() def _show_variable_popup(self, variables: List[Tuple[str, str]]): """Muestra popup de variables""" self._variable_popup_active = True self._autocomplete_active = True # También debe estar activo para el filtrado # Las variables ya vienen en el formato correcto (nombre, descripción) self._show_autocomplete_popup(variables, is_global_popup=False) def _filter_autocomplete(self): """Filtra las sugerencias del autocompletado dinámicamente""" if not self._autocomplete_active: return cursor = self.parent_app.input_text.textCursor() current_pos = cursor.position() # Para popup de variables (filtrar por texto parcial) if self._variable_popup_active: # Obtener la palabra actual bajo el cursor cursor.select(QTextCursor.WordUnderCursor) filter_text = cursor.selectedText().lower() self._autocomplete_filter_text = filter_text # Si no hay texto que filtrar, regenerar popup con todas las variables if not filter_text: # Regenerar popup dinámicamente con variables actuales try: context = self.parent_app.engine._get_full_context() variables = [] # Filtrar variables for name, value in context.items(): if (not name.startswith('_') and not callable(value) and name not in ['sympy', 'math', 'numpy', 'plt', 'builtins']): # Descripción del valor value_str = str(value) if len(value_str) > 20: value_str = value_str[:17] + "..." variables.append((name, f"= {value_str}")) if variables: variables.sort(key=lambda x: x[0]) self._current_suggestions = variables if self._autocomplete_popup: self._autocomplete_popup.set_suggestions(variables) self._autocomplete_popup.adjust_size() else: self._close_autocomplete_popup() except Exception: self._close_autocomplete_popup() return # Filtrar sugerencias de variables existentes + regenerar con contexto actual try: context = self.parent_app.engine._get_full_context() all_variables = [] # Obtener todas las variables actuales for name, value in context.items(): if (not name.startswith('_') and not callable(value) and name not in ['sympy', 'math', 'numpy', 'plt', 'builtins']): # Descripción del valor value_str = str(value) if len(value_str) > 20: value_str = value_str[:17] + "..." all_variables.append((name, f"= {value_str}")) # Filtrar por el texto parcial filtered = [] for name, hint in all_variables: if name.lower().startswith(filter_text): filtered.append((name, hint)) # Actualizar sugerencias actuales self._current_suggestions = all_variables if filtered and self._autocomplete_popup: self._autocomplete_popup.set_suggestions(filtered) self._autocomplete_popup.adjust_size() else: self._close_autocomplete_popup() except Exception: # Fallback al método anterior filtered = [] for name, hint in self._current_suggestions: if name.lower().startswith(filter_text): filtered.append((name, hint)) if filtered and self._autocomplete_popup: self._autocomplete_popup.set_suggestions(filtered) self._autocomplete_popup.adjust_size() else: self._close_autocomplete_popup() # Para popup de métodos (filtrar después del punto) elif self._autocomplete_trigger_pos: if current_pos >= self._autocomplete_trigger_pos: cursor.setPosition(self._autocomplete_trigger_pos) cursor.setPosition(current_pos, QTextCursor.KeepAnchor) filter_text = cursor.selectedText().lower() self._autocomplete_filter_text = filter_text else: # Si el cursor está antes del punto trigger, cerrar popup self._close_autocomplete_popup() return # Filtrar sugerencias de métodos filtered = [] for name, hint in self._current_suggestions: if name.lower().startswith(self._autocomplete_filter_text): filtered.append((name, hint)) if filtered and self._autocomplete_popup: self._autocomplete_popup.set_suggestions(filtered) self._autocomplete_popup.adjust_size() else: self._close_autocomplete_popup() def _handle_arrow_key(self, direction: int): """Maneja navegación con flechas en el popup""" if self._autocomplete_popup: self._autocomplete_popup.navigate(direction) self._last_navigation_time = time.time() def _handle_tab_key(self): """Maneja tecla TAB para seleccionar""" self._select_autocomplete() def _handle_escape_key(self): """Maneja tecla ESC para cerrar popup""" self._close_autocomplete_popup() if self._autocomplete_active: self._popup_disabled_until_next_dot = True def _select_autocomplete(self): """Selecciona el item actual del autocompletado""" if not self._autocomplete_popup: return selected_text = self._autocomplete_popup.get_selected_text() if selected_text: self._insert_autocomplete_text(selected_text) self._close_autocomplete_popup() def _on_autocomplete_selected(self, text: str): """Callback cuando se selecciona un item del popup""" self._insert_autocomplete_text(text) self._close_autocomplete_popup() def _insert_autocomplete_text(self, text: str): """Inserta el texto seleccionado del autocompletado""" cursor = self.parent_app.input_text.textCursor() # Para popup de variables if self._variable_popup_active: # Obtener el texto parcial ya escrito current_pos = cursor.position() cursor.select(QTextCursor.WordUnderCursor) partial_text = cursor.selectedText() # Verificar si hay texto parcial que ya coincide con el inicio de la variable if partial_text and text.lower().startswith(partial_text.lower()): # Reemplazar completamente la palabra seleccionada con la variable completa cursor.insertText(text) elif partial_text: # Si hay texto parcial pero no coincide, reemplazar completamente cursor.insertText(text) else: # Si no hay texto parcial, insertar directamente cursor.insertText(text) return # Para popup global (después de punto solo) if self._is_global_popup: # Eliminar el punto y añadir función/variable if self._autocomplete_trigger_pos is not None: cursor.setPosition(self._autocomplete_trigger_pos - 1) else: cursor.setPosition(0) if self._autocomplete_trigger_pos is not None: cursor.setPosition(self._autocomplete_trigger_pos, QTextCursor.KeepAnchor) # Verificar si es una función o variable para decidir si agregar paréntesis try: context = self.parent_app.engine._get_full_context() if text in context: obj = context[text] if callable(obj): # Es una función, agregar paréntesis cursor.insertText(text + "()") cursor.setPosition((self._autocomplete_trigger_pos or 0) - 1 + len(text) + 1) else: # Es una variable, no agregar paréntesis cursor.insertText(text) cursor.setPosition((self._autocomplete_trigger_pos or 0) - 1 + len(text)) else: # Por defecto, asumir que es función si no está en contexto cursor.insertText(text + "()") cursor.setPosition((self._autocomplete_trigger_pos or 0) - 1 + len(text) + 1) except Exception: # Fallback: agregar paréntesis por defecto cursor.insertText(text + "()") cursor.setPosition((self._autocomplete_trigger_pos or 0) - 1 + len(text) + 1) self.parent_app.input_text.setTextCursor(cursor) else: # Para métodos de objeto - considerar texto ya escrito después del punto if self._autocomplete_filter_text: # Calcular la posición correcta del texto ya escrito current_pos = cursor.position() filter_len = len(self._autocomplete_filter_text) # Seleccionar el texto filtrado para reemplazarlo cursor.setPosition(current_pos - filter_len) cursor.setPosition(current_pos, QTextCursor.KeepAnchor) cursor.removeSelectedText() # Insertar el texto completo del método cursor.insertText(text + "()") cursor.setPosition(cursor.position() - 1) else: # Si no hay texto filtrado, insertar normalmente cursor.insertText(text + "()") cursor.setPosition(cursor.position() - 1) self.parent_app.input_text.setTextCursor(cursor) def _check_dot_removal(self): """Verifica si se borró el punto que activó el autocompletado""" if not self._autocomplete_active or not self._autocomplete_trigger_pos: return cursor = self.parent_app.input_text.textCursor() current_pos = cursor.position() # Si el cursor está antes de la posición del trigger, el punto fue eliminado if current_pos < self._autocomplete_trigger_pos: self._close_autocomplete_popup() return # Verificar si todavía existe el punto en la posición trigger if self._autocomplete_trigger_pos > 0: cursor.setPosition(self._autocomplete_trigger_pos - 1) cursor.setPosition(self._autocomplete_trigger_pos, QTextCursor.KeepAnchor) if cursor.selectedText() != '.': self._close_autocomplete_popup() def _close_autocomplete_popup(self): """Cierra el popup de autocompletado""" if self._autocomplete_popup: self._autocomplete_popup.close() self._autocomplete_popup = None # Resetear estado self._autocomplete_active = False self._variable_popup_active = False self._autocomplete_trigger_pos = None self._autocomplete_filter_text = "" self._current_suggestions = [] def stop_timers(self): """Detiene todos los timers del autocompletado""" self._variable_popup_timer.stop() def reset_state(self): """Resetea el estado del autocompletado""" self._close_autocomplete_popup() self._popup_disabled_until_next_dot = False def on_input_changed(self): """Método llamado cuando cambia el texto de entrada""" # Marcar tiempo del cambio self._last_input_change = time.time() # Si hay autocompletado activo, filtrar dinámicamente if self._autocomplete_active: QTimer.singleShot(10, self._filter_autocomplete) elif not self._popup_disabled_until_next_dot: # Programar autocompletado de variables self._schedule_variable_autocomplete_improved()