""" Motor de evaluación híbrida INTEGRADO con el sistema de auto-descubrimiento de tipos """ import sympy from sympy import symbols, Symbol, sympify, solve, Eq, simplify from typing import Dict, Any, Optional, Tuple, List, Union import ast import re from contextlib import contextmanager # Importaciones del sistema de tipos from type_registry import ( discover_and_register_types, get_registered_base_context, get_registered_bracket_classes, get_registered_helper_functions ) # Importaciones existentes from tl_bracket_parser import BracketParser from tl_popup import PlotResult class HybridEvaluationEngine: """ Motor de evaluación híbrida que combina SymPy con clases especializadas VERSIÓN INTEGRADA con auto-descubrimiento de tipos """ def __init__(self, auto_discover_types: bool = True, types_directory: str = "custom_types"): self.parser = BracketParser() self.symbol_table: Dict[str, Any] = {} self.equations: List[sympy.Eq] = [] self.last_result = None # Configuración del sistema de tipos self.types_directory = types_directory self.auto_discover_enabled = auto_discover_types # Información de tipos registrados self.registered_types_info = {} self.helper_functions = [] # Debug mode self.debug = False # NUEVA CONFIGURACIÓN: Modo simbólico self.symbolic_mode = True # Por defecto, mantener forma simbólica self.show_numeric_approximation = True # Mostrar aproximación numérica self.keep_symbolic_fractions = True # Mantener fracciones como 4/5 self.auto_simplify = False # No simplificar automáticamente # Configurar contexto base self._setup_base_context() def _setup_base_context(self): """Configura el contexto base con funciones matemáticas y clases""" # 1. DESCOBRIR Y REGISTRAR TIPOS AUTOMÁTICAMENTE if self.auto_discover_enabled: try: self.registered_types_info = discover_and_register_types(self.types_directory) if self.debug: print(f"🔍 Tipos descubiertos: {self.registered_types_info['class_count']} clases") except Exception as e: print(f"⚠️ Error en auto-descubrimiento: {e}") self.registered_types_info = { 'base_context': {}, 'bracket_classes': set(), 'helper_functions': [] } # 2. FUNCIONES MATEMÁTICAS DE SYMPY (BASE) math_functions = { 'pi': sympy.pi, 'e': sympy.E, 'I': sympy.I, 'oo': sympy.oo, 'sin': sympy.sin, 'cos': sympy.cos, 'tan': sympy.tan, 'asin': sympy.asin, 'acos': sympy.acos, 'atan': sympy.atan, 'sinh': sympy.sinh, 'cosh': sympy.cosh, 'tanh': sympy.tanh, 'exp': sympy.exp, 'log': sympy.log, 'ln': sympy.log, 'sqrt': sympy.sqrt, 'abs': sympy.Abs, 'sign': sympy.sign, 'floor': sympy.floor, 'ceiling': sympy.ceiling, 'factorial': sympy.factorial, # Funciones de cálculo 'diff': sympy.diff, 'integrate': sympy.integrate, 'limit': sympy.limit, 'series': sympy.series, 'solve': sympy.solve, 'simplify': sympy.simplify, 'expand': sympy.expand, 'factor': sympy.factor, 'collect': sympy.collect, 'cancel': sympy.cancel, 'apart': sympy.apart, 'together': sympy.together, # Álgebra lineal 'Matrix': sympy.Matrix, 'det': lambda m: m.det() if hasattr(m, 'det') else sympy.det(m), 'inv': lambda m: m.inv() if hasattr(m, 'inv') else sympy.Matrix(m).inv(), # Plotting (será manejado por resultados interactivos) 'plot': self._create_plot_placeholder, 'plot3d': self._create_plot3d_placeholder, } # 3. CLASES ESPECIALIZADAS (DESDE AUTO-DESCUBRIMIENTO) specialized_classes = self.registered_types_info.get('base_context', {}) # 4. FUNCIONES DE UTILIDAD utility_functions = { '_add_equation': self._add_equation, '_assign_variable': self._assign_variable, 'help': self._help_function, 'evalf': lambda expr, n=15: expr.evalf(n) if hasattr(expr, 'evalf') else float(expr), } # 5. COMBINAR TODO EN EL CONTEXTO BASE self.base_context = { **math_functions, **specialized_classes, **utility_functions } # 6. ACTUALIZAR HELPER FUNCTIONS self.helper_functions = get_registered_helper_functions() # 7. ACTUALIZAR BRACKET PARSER CON CLASES DESCUBIERTAS self._update_bracket_parser() if self.debug: print(f"📋 Contexto base configurado: {len(self.base_context)} entradas") print(f"🆘 Helper functions: {len(self.helper_functions)}") def _update_bracket_parser(self): """Actualiza el BracketParser con las clases descubiertas""" try: discovered_bracket_classes = get_registered_bracket_classes() # Combinar con clases existentes del parser self.parser.BRACKET_CLASSES = self.parser.BRACKET_CLASSES.union(discovered_bracket_classes) if self.debug: print(f"🔧 Bracket classes actualizadas: {self.parser.BRACKET_CLASSES}") except Exception as e: print(f"⚠️ Error actualizando bracket parser: {e}") def reload_types(self): """Recarga todos los tipos del directorio (útil para desarrollo)""" if self.debug: print("🔄 Recargando tipos...") self._setup_base_context() if self.debug: print("✅ Tipos recargados") def get_available_types(self) -> Dict[str, Any]: """Retorna información sobre los tipos disponibles""" return { 'registered_classes': self.registered_types_info.get('registered_classes', {}), 'bracket_classes': list(self.registered_types_info.get('bracket_classes', set())), 'total_context_entries': len(self.base_context), 'helper_functions_count': len(self.helper_functions) } def get_type_help(self, type_name: str) -> Optional[str]: """Obtiene ayuda para un tipo específico""" # Buscar en clases registradas registered_classes = self.registered_types_info.get('registered_classes', {}) if type_name in registered_classes: cls = registered_classes[type_name] if hasattr(cls, 'Helper'): return cls.Helper(type_name) return None def _create_plot_placeholder(self, *args, **kwargs): """Crear placeholder para plots que será manejado por resultados interactivos""" if self.debug: print(f"🎯 Creando PlotResult con args: {args}, kwargs: {kwargs}") return PlotResult('plot', args, kwargs) def _create_plot3d_placeholder(self, *args, **kwargs): """Crear placeholder para plots 3D""" if self.debug: print(f"🎯 Creando PlotResult 3D con args: {args}, kwargs: {kwargs}") return PlotResult('plot3d', args, kwargs) def _help_function(self, obj=None): """Función de ayuda integrada que usa el sistema de helpers""" if obj is None: return "Ayuda disponible. Use help(función) para ayuda específica." # Primero intentar con el objeto directamente if hasattr(obj, '__doc__') and obj.__doc__: return obj.__doc__ elif hasattr(obj, 'Helper'): return obj.Helper("") # Luego buscar en helpers registrados obj_name = getattr(obj, '__name__', str(obj)) for helper_func in self.helper_functions: try: help_result = helper_func(obj_name) if help_result: return help_result except: continue return f"No hay ayuda disponible para {obj}" # ========== RESTO DE MÉTODOS EXISTENTES ========== # (Los métodos de evaluación permanecen igual) def evaluate_line(self, line: str) -> 'EvaluationResult': """ Evalúa una línea de código y retorna el resultado """ try: # 1. Parsear la línea parsed_line, parse_info = self.parser.parse_line(line) if self.debug: print(f"Parse: '{line}' → '{parsed_line}' ({parse_info})") # 2. Manejar casos especiales if parse_info == "comment": return EvaluationResult(None, "comment", original_line=line) elif parse_info == "equation": return self._evaluate_equation_addition(parsed_line, line) elif parse_info == "assignment": return self._evaluate_assignment(parsed_line, line) # 3. Evaluación SymPy return self._evaluate_sympy_expression(parsed_line, parse_info, line) except Exception as e: return EvaluationResult( None, "error", error=str(e), original_line=line ) def _evaluate_assignment(self, parsed_line: str, original_line: str) -> 'EvaluationResult': """Maneja la asignación de variables""" try: # Ejecutar _assign_variable result = self._eval_in_context(parsed_line) # Extraer nombre de variable y valor del resultado parts = original_line.split('=', 1) var_name = parts[0].strip() # Obtener el valor asignado assigned_value = self.symbol_table.get(var_name) # Generar evaluación numérica si está configurado para mostrarla numeric_result = None if self.show_numeric_approximation and hasattr(assigned_value, 'evalf'): try: numeric_eval = assigned_value.evalf() # Verificar si el resultado numérico es diferente del simbólico # Para fracciones racionales, siempre mostrar la aproximación decimal if hasattr(assigned_value, 'is_Rational') and assigned_value.is_Rational: # Es una fracción racional, mostrar aproximación decimal numeric_result = numeric_eval elif numeric_eval != assigned_value: # Para otros casos, mostrar si son diferentes try: # Intentar comparación numérica más robusta if abs(float(numeric_eval) - float(assigned_value)) > 1e-15: numeric_result = numeric_eval except: # Si la comparación falla, asumir que son diferentes numeric_result = numeric_eval except Exception as e: if self.debug: print(f"DEBUG: Error en evaluación numérica: {e}") pass return EvaluationResult( assigned_value, "assignment", symbolic_result=result, numeric_result=numeric_result, original_line=original_line ) except Exception as e: return EvaluationResult( None, "error", error=f"Error en asignación: {e}", original_line=original_line ) def _evaluate_equation_addition(self, parsed_line: str, original_line: str) -> 'EvaluationResult': """Maneja la adición de ecuaciones al sistema""" try: # Ejecutar _add_equation result = self._eval_in_context(parsed_line) return EvaluationResult( result, "equation_added", symbolic_result=f"Ecuación agregada: {original_line}", original_line=original_line ) except Exception as e: return EvaluationResult( None, "error", error=f"Error agregando ecuación: {e}", original_line=original_line ) def _evaluate_sympy_expression(self, expression: str, parse_info: str, original_line: str) -> 'EvaluationResult': """Evalúa una expresión usando SymPy""" try: # Evaluar en contexto SymPy result = self._eval_in_context(expression) if self.debug: print(f"🔍 Resultado evaluación: {result} (tipo: {type(result)})") if isinstance(result, PlotResult): print(f" 📊 Es PlotResult: plot_type={result.plot_type}") # Actualizar last_result self.last_result = result # Intentar evaluación numérica si está configurado para mostrarla numeric_result = None if self.show_numeric_approximation and hasattr(result, 'evalf'): try: numeric_eval = result.evalf() # Solo mostrar evaluación numérica si es diferente del resultado simbólico if numeric_eval != result and not ( hasattr(result, 'is_number') and result.is_number and abs(float(numeric_eval) - float(result)) < 1e-15 ): numeric_result = numeric_eval except: pass return EvaluationResult( result, "expression", symbolic_result=result, numeric_result=numeric_result, parse_info=parse_info, original_line=original_line ) except NameError as e: # Intentar crear símbolos automáticamente return self._handle_undefined_symbols(expression, original_line, e) except Exception as e: return EvaluationResult( None, "error", error=str(e), original_line=original_line ) def _handle_undefined_symbols(self, expression: str, original_line: str, error: Exception) -> 'EvaluationResult': """Maneja símbolos no definidos creándolos automáticamente""" try: # Extraer nombres de variables de la expresión var_names = self._extract_variable_names(expression) # Crear símbolos automáticamente new_symbols = {} for name in var_names: if name not in self.symbol_table and name not in self.base_context: new_symbols[name] = Symbol(name) self.symbol_table[name] = Symbol(name) if new_symbols: # Reintentar evaluación result = self._eval_in_context(expression) symbol_names = list(new_symbols.keys()) info_msg = f"Símbolos creados: {', '.join(symbol_names)}" return EvaluationResult( result, "symbolic_with_new_vars", symbolic_result=result, info=info_msg, original_line=original_line ) else: raise error except Exception as e: return EvaluationResult( None, "error", error=str(e), original_line=original_line ) def _extract_variable_names(self, expression: str) -> List[str]: """Extrae nombres de variables de una expresión""" try: # Usar SymPy para extraer símbolos expr = sympify(expression, locals=self._get_full_context()) return [str(symbol) for symbol in expr.free_symbols] except: # Fallback: usar regex pattern = r'\b[a-zA-Z_][a-zA-Z0-9_]*\b' names = re.findall(pattern, expression) # Filtrar funciones conocidas return [name for name in names if name not in self.base_context] def _eval_in_context(self, expression: str) -> Any: """Evalúa una expresión en el contexto completo""" context = self._get_full_context() # Casos especiales para funciones del sistema if expression.strip().startswith('_add_equation'): return eval(expression, {"__builtins__": {}}, context) elif expression.strip().startswith('_assign_variable'): # NUEVA LÓGICA: Manejar asignaciones en modo simbólico # Extraer la expresión de la llamada _assign_variable("var", expresión) import re match = re.match(r'_assign_variable\("([^"]+)",\s*(.+)\)', expression.strip()) if match: var_name = match.group(1) expr_to_evaluate = match.group(2).strip() # Evaluar la expresión usando la lógica simbólica if self.symbolic_mode: try: value = sympify(expr_to_evaluate, locals=context, rational=self.keep_symbolic_fractions) if self.auto_simplify and hasattr(value, 'simplify'): value = value.simplify() except: # Si falla SymPy, usar eval como fallback value = eval(expr_to_evaluate, {"__builtins__": {}}, context) else: # En modo numérico, usar eval value = eval(expr_to_evaluate, {"__builtins__": {}}, context) # Asignar directamente usando los valores evaluados self.symbol_table[var_name] = value return f"{var_name} = {value}" else: # Si no se puede parsear, usar eval como fallback return eval(expression, {"__builtins__": {}}, context) else: # NUEVA LÓGICA: Priorizar SymPy en modo simbólico if self.symbolic_mode: try: # Primero intentar con SymPy para mantener formas simbólicas result = sympify(expression, locals=context, rational=self.keep_symbolic_fractions) # Si auto_simplify está activado, simplificar if self.auto_simplify and hasattr(result, 'simplify'): result = result.simplify() return result except (SyntaxError, TypeError, ValueError) as sympy_error: # Si SymPy falla, intentar con eval para objetos especializados try: result = eval(expression, {"__builtins__": {}}, context) # Si el resultado es un objeto híbrido, retornarlo if hasattr(result, '_sympystr'): # SympyClassBase return result elif isinstance(result, PlotResult): if self.debug: print(f" 📊 PlotResult detectado en eval: {result}") return result elif hasattr(result, '__iter__') and not isinstance(result, str): return result else: # Convertir resultado de eval a SymPy si es posible try: return sympify(result, rational=self.keep_symbolic_fractions) except: return result except Exception as eval_error: # Si ambos fallan, re-lanzar el error más informativo if "invalid syntax" in str(sympy_error): raise eval_error else: raise sympy_error else: # MODO NO SIMBÓLICO: usar lógica original try: # Primero intentar evaluación directa para objetos especializados try: result = eval(expression, {"__builtins__": {}}, context) # Si el resultado es un objeto híbrido, integrarlo con SymPy si es necesario if hasattr(result, '_sympystr'): # SympyClassBase return result elif isinstance(result, PlotResult): if self.debug: print(f" 📊 PlotResult detectado en eval: {result}") return result elif hasattr(result, '__iter__') and not isinstance(result, str): # Si es una lista/tupla, verificar si contiene objetos híbridos return result else: return result except (NameError, TypeError) as eval_error: # Si eval falla, intentar con SymPy try: result = sympify(expression, locals=context) return result except: # Si ambos fallan, re-lanzar el error original de eval raise eval_error except SyntaxError as syntax_error: # Para errores de sintaxis, intentar SymPy directamente try: result = sympify(expression, locals=context) return result except: raise syntax_error def _get_full_context(self) -> Dict[str, Any]: """Obtiene el contexto completo para evaluación""" context = self.base_context.copy() context.update(self.symbol_table) context['last'] = self.last_result return context def _assign_variable(self, var_name: str, expression) -> str: """Asigna un valor a una variable""" try: # Evaluar la expresión usando el contexto completo y configuraciones simbólicas if isinstance(expression, str): value = self._eval_in_context(expression) else: value = expression # Asignar al contexto self.symbol_table[var_name] = value return f"{var_name} = {value}" except Exception as e: raise ValueError(f"Error asignando variable '{var_name}': {e}") def _add_equation(self, equation_str: str) -> str: """Agrega una ecuación al sistema""" try: # Parsear ecuación if '=' in equation_str and '==' not in equation_str: # Ecuación simple: convertir a igualdad SymPy left, right = equation_str.split('=', 1) left_expr = sympify(left.strip(), locals=self._get_full_context()) right_expr = sympify(right.strip(), locals=self._get_full_context()) equation = Eq(left_expr, right_expr) else: # Ya es una comparación válida de SymPy equation = sympify(equation_str, locals=self._get_full_context()) self.equations.append(equation) return f"Ecuación {len(self.equations)}: {equation}" except Exception as e: raise ValueError(f"Error parseando ecuación '{equation_str}': {e}") def solve_system(self, variables: Optional[List[str]] = None) -> Dict[str, Any]: """Resuelve el sistema de ecuaciones""" if not self.equations: raise ValueError("No hay ecuaciones en el sistema") if variables is None: # Obtener todas las variables libres all_symbols = set() for eq in self.equations: all_symbols.update(eq.free_symbols) variables = [str(s) for s in all_symbols] # Convertir nombres a símbolos symbol_vars = [] for var_name in variables: if var_name in self.symbol_table: symbol_vars.append(self.symbol_table[var_name]) else: symbol_vars.append(Symbol(var_name)) # Resolver sistema solutions = solve(self.equations, symbol_vars) # Convertir resultado a diccionario con nombres de variables if isinstance(solutions, dict): result = {} for symbol, value in solutions.items(): result[str(symbol)] = value # Actualizar tabla de símbolos self.symbol_table[str(symbol)] = value return result elif isinstance(solutions, list): # Múltiples soluciones return {"solutions": solutions} else: return {"result": solutions} def assign_variable(self, name: str, value: Any): """Asigna un valor a una variable""" self.symbol_table[name] = value def get_variable(self, name: str) -> Optional[Any]: """Obtiene el valor de una variable""" return self.symbol_table.get(name) def clear_equations(self): """Limpia todas las ecuaciones""" self.equations.clear() def clear_variables(self): """Limpia todas las variables""" self.symbol_table.clear() def clear_all(self): """Limpia ecuaciones y variables""" self.clear_equations() self.clear_variables() def set_symbolic_mode(self, symbolic_mode: bool = True, show_numeric: bool = True, keep_fractions: bool = True, auto_simplify: bool = False): """Configura el modo de evaluación simbólica""" self.symbolic_mode = symbolic_mode self.show_numeric_approximation = show_numeric self.keep_symbolic_fractions = keep_fractions self.auto_simplify = auto_simplify class EvaluationResult: """Resultado de evaluación con información contextual""" def __init__(self, result: Any, result_type: str, symbolic_result: Any = None, numeric_result: Any = None, error: Optional[str] = None, info: Optional[str] = None, parse_info: Optional[str] = None, original_line: Optional[str] = None): self.result = result self.result_type = result_type self.symbolic_result = symbolic_result or result self.numeric_result = numeric_result self.error = error self.info = info self.parse_info = parse_info self.original_line = original_line @property def is_error(self) -> bool: return self.result_type == "error" @property def is_interactive(self) -> bool: """Determina si el resultado requiere interactividad""" return isinstance(self.result, (PlotResult, sympy.Matrix)) or \ (isinstance(self.result, list) and len(self.result) > 3) def __str__(self): if self.is_error: return f"Error: {self.error}" elif self.result is not None: return str(self.result) return ""