evolutia 0.1.1__py3-none-any.whl → 0.1.3__py3-none-any.whl

evolutia/exercise_analyzer.py

@@ -3,9 +3,15 @@ Analizador de complejidad de ejercicios.
 Identifica tipo, pasos, conceptos y variables de ejercicios.
 """
 import re
-from typing import Dict, List, Set
+import logging
+from typing import Dict, List, Set, Optional, TYPE_CHECKING
 from collections import Counter
 
+if TYPE_CHECKING:
+    from evolutia.cache.exercise_cache import ExerciseAnalysisCache
+
+logger = logging.getLogger(__name__)
+
 try:
     from utils.math_extractor import (
         extract_math_expressions,
@@ -25,70 +31,36 @@ except ImportError:
 class ExerciseAnalyzer:
     """Analiza la complejidad y estructura de ejercicios."""
 
-    # Palabras clave para identificación de tipo
-    DEMOSTRACION_KEYWORDS = [
-        'demuestre', 'demuestre que', 'pruebe', 'verifique', 'muestre que'
-    ]
-
-    CALCULO_KEYWORDS = [
-        'calcule', 'calcular', 'encuentre', 'determine', 'evalúe', 'evaluar'
-    ]
-
-    APLICACION_KEYWORDS = [
-        'considere', 'suponga', 'modelo', 'sistema físico', 'aplicación',
-        'dispositivo', 'campo', 'potencial'
-    ]
-
-    STEP_KEYWORDS = [
-        'primero', 'luego', 'finalmente', 'ahora', 'a continuación',
-        'por tanto', 'por lo tanto', 'en consecuencia', 'así',
-        'por otro lado', 'además', 'también'
-    ]
-
-    # Patrones compilados para búsqueda eficiente
     TYPE_PATTERNS = {
-        'demostracion': re.compile('|'.join(map(re.escape, DEMOSTRACION_KEYWORDS)), re.IGNORECASE),
-        'calculo': re.compile('|'.join(map(re.escape, CALCULO_KEYWORDS)), re.IGNORECASE),
-        'aplicacion': re.compile('|'.join(map(re.escape, APLICACION_KEYWORDS)), re.IGNORECASE)
+        'demostracion': re.compile(r'(?i)(demuestre|pruebe|verifique|muestre|justifique|demostraci[oó]n)'),
+        'calculo': re.compile(r'(?i)(calcule|halle|encuentre|resuelva|eval[uú]e|calcular|obtenga|determinar)'),
+        'aplicacion': re.compile(r'(?i)(aplicaci[oó]n|problema|vida real|modelo|f[íi]sic[ao]|ingenier[íi]a|econom[íi]a|contexto)')
     }
 
-    STEP_KEYWORDS_PATTERN = re.compile('|'.join(map(re.escape, STEP_KEYWORDS)), re.IGNORECASE)
+    STEP_KEYWORDS_PATTERN = re.compile(
+        r'(?i)(primero|luego|despu[ée]s|finalmente|entonces|por lo tanto|conclusi[oó]n|paso|seguidamente)',
+        re.MULTILINE
+    )
 
-    # Conceptos matemáticos comunes
     CONCEPT_PATTERNS = {
-        'vector_operations': [
-            r'\\vec', r'\\cdot', r'\\times', r'\\nabla',
-            r'producto\s+(escalar|vectorial)', r'gradiente', r'divergencia', r'rotacional'
-        ],
-        'coordinate_systems': [
-            r'coordenadas?\s+(cartesianas?|polares?|cilíndricas?|esféricas?|toroidales?)',
-            r'\\rho', r'\\theta', r'\\phi', r'\\hat\{e\}_'
-        ],
-        'integrals': [
-            r'\\int', r'\\oint', r'integral', r'teorema\s+(de\s+)?(Green|Stokes|Gauss)',
-            r'divergencia', r'rotacional'
-        ],
-        'differential_equations': [
-            r'\\frac\{d', r'\\partial', r'ecuaci[óo]n\s+diferencial',
-            r'EDP', r'EDO'
-        ],
-        'linear_algebra': [
-            r'\\begin\{matrix\}', r'\\begin\{pmatrix\}', r'\\begin\{bmatrix\}',
-            r'matriz', r'\\mathbf', r'autovalor', r'autovector'
-        ],
-        'complex_numbers': [
-            r'\\mathbb\{C\}', r'z\s*=', r'n[úu]mero\s+complejo',
-            r'\\Re', r'\\Im', r'\\arg'
-        ],
-        'series_expansions': [
-            r'\\sum', r'serie', r'expansi[óo]n', r'Fourier',
-            r'Taylor', r'\\sum_\{n=0\}'
-        ]
+        'integrals': [r'(?i)integral', r'\\int', r'\\iint', r'\\iiint', r'\\oint'],
+        'derivatives': [r'(?i)derivada', r'\\frac{d}{d', r'\\[dp]artial', r'\''],
+        'limits': [r'(?i)l[íi]mite', r'\\lim'],
+        'series': [r'(?i)serie', r'(?i)sucesi[oó]n', r'\\sum', r'convergencia'],
+        'vectors': [r'(?i)vector', r'\\vec', r'\\mathbf', r'producto punto', r'producto cruz'],
+        'matrices': [r'(?i)matriz', r'(?i)determinante', r'\\begin{pmatrix}', r'\\begin{bmatrix}', r'autovalor'],
+        'coordinate_systems': [r'(?i)coordenadas', r'(?i)polares', r'(?i)esf[ée]ricas', r'(?i)cil[íi]ndricas', r'jacobian[oa]'],
+        'vector_operations': [r'(?i)gradiente', r'(?i)divergencia', r'(?i)rotacional', r'\\nabla', r'teorema de stokes', r'teorema de green', r'teorema de la divergencia']
     }
 
-    def __init__(self):
-        """Inicializa el analizador."""
-        pass
+    def __init__(self, cache: Optional['ExerciseAnalysisCache'] = None):
+        """
+        Inicializa el analizador.
+
+        Args:
+            cache: Instancia opcional de ExerciseAnalysisCache para cachear análisis
+        """
+        self.cache = cache
 
     def identify_exercise_type(self, content: str) -> str:
         """
@@ -183,7 +155,7 @@ class ExerciseAnalyzer:
 
         return concepts
 
-    def analyze(self, exercise: Dict) -> Dict:
+    def analyze(self, exercise: Dict[str, Optional[str]]) -> Dict[str, Optional[str | int | float | List[str]]]:
         """
         Analiza un ejercicio completo y retorna metadatos de complejidad.
 
@@ -198,6 +170,17 @@ class ExerciseAnalyzer:
         content = exercise.get('content', '')
         solution = exercise.get('solution', '')
 
+        # Intentar caché primero
+        if self.cache:
+            cached_analysis = self.cache.get(exercise)
+            if cached_analysis:
+                logger.info(f"[ExerciseAnalyzer] Análisis obtenido del caché para exercise={exercise.get('label', 'unknown')}")
+                return cached_analysis['analysis']
+
+        # Análisis normal (cache miss)
+        if not content:
+            return {}
+
         # Extraer expresiones matemáticas
         math_expressions = extract_math_expressions(content)
         if solution:

evolutia/imports.py

@@ -0,0 +1,175 @@
+"""
+Módulo de imports centralizados y condicionales para EvolutIA.
+Gestiona imports de dependencias opcionales (RAG, ML, etc.) de forma centralizada.
+"""
+import logging
+from typing import TYPE_CHECKING
+
+logger = logging.getLogger(__name__)
+
+
+class OptionalImports:
+    """
+    Gestor de imports opcionales para EvolutIA.
+
+    Permite importar dependencias opcionales de forma controlada,
+    con mensajes de error claros cuando no están disponibles.
+    """
+
+    _imported_modules = {}
+
+    @classmethod
+    def get_chromadb(cls):
+        """Importa ChromaDB si está disponible."""
+        if 'chromadb' in cls._imported_modules:
+            return cls._imported_modules['chromadb']
+
+        try:
+            import chromadb
+            from chromadb.config import Settings
+            cls._imported_modules['chromadb'] = (chromadb, Settings)
+            logger.debug("[OptionalImports] ChromaDB importado exitosamente")
+            return chromadb, Settings
+        except ImportError:
+            logger.warning(
+                "[OptionalImports] chromadb no está instalado. "
+                "Instala con: pip install -e '.[rag]'"
+            )
+            return None, None
+
+    @classmethod
+    def get_sentence_transformers(cls):
+        """Importa sentence-transformers si está disponible."""
+        if 'sentence_transformers' in cls._imported_modules:
+            return cls._imported_modules['sentence_transformers']
+
+        try:
+            from sentence_transformers import SentenceTransformer
+            cls._imported_modules['sentence_transformers'] = SentenceTransformer
+            logger.debug("[OptionalImports] sentence-transformers importado exitosamente")
+            return SentenceTransformer
+        except ImportError:
+            logger.warning(
+                "[OptionalImports] sentence-transformers no está instalado. "
+                "Instala con: pip install -e '.[rag]'"
+            )
+            return None
+
+    @classmethod
+    def get_openai(cls):
+        """Importa OpenAI si está disponible."""
+        if 'openai' in cls._imported_modules:
+            return cls._imported_modules['openai']
+
+        try:
+            from openai import OpenAI
+            cls._imported_modules['openai'] = OpenAI
+            logger.debug("[OptionalImports] OpenAI importado exitosamente")
+            return OpenAI
+        except ImportError:
+            logger.warning(
+                "[OptionalImports] openai no está instalado. "
+                "Instala con: pip install openai"
+            )
+            return None
+
+    @classmethod
+    def get_anthropic(cls):
+        """Importa Anthropic si está disponible."""
+        if 'anthropic' in cls._imported_modules:
+            return cls._imported_modules['anthropic']
+
+        try:
+            import anthropic
+            cls._imported_modules['anthropic'] = anthropic
+            logger.debug("[OptionalImports] Anthropic importado exitosamente")
+            return anthropic
+        except ImportError:
+            logger.warning(
+                "[OptionalImports] anthropic no está instalado. "
+                "Instala con: pip install anthropic"
+            )
+            return None
+
+    @classmethod
+    def get_google_generativeai(cls):
+        """Importa google-generativeai si está disponible."""
+        if 'google_generativeai' in cls._imported_modules:
+            return cls._imported_modules['google_generativeai']
+
+        try:
+            import google.generativeai as genai
+            cls._imported_modules['google_generativeai'] = genai
+            logger.debug("[OptionalImports] google-generativeai importado exitosamente")
+            return genai
+        except ImportError:
+            logger.warning(
+                "[OptionalImports] google-generativeai no está instalado. "
+                "Instala con: pip install google-generativeai"
+            )
+            return None
+
+    @classmethod
+    def check_rag_available(cls) -> bool:
+        """Verifica si todas las dependencias de RAG están disponibles."""
+        chromadb, _ = cls.get_chromadb()
+        sentence_transformers = cls.get_sentence_transformers()
+
+        if chromadb is None or sentence_transformers is None:
+            return False
+        return True
+
+    @classmethod
+    def get_module(cls, module_name: str):
+        """
+        Importa un módulo específico por nombre.
+
+        Args:
+            module_name: Nombre del módulo a importar
+
+        Returns:
+            El módulo importado o None si no está disponible
+        """
+        if module_name in cls._imported_modules:
+            return cls._imported_modules[module_name]
+
+        try:
+            module = __import__(module_name)
+            cls._imported_modules[module_name] = module
+            logger.debug(f"[OptionalImports] {module_name} importado exitosamente")
+            return module
+        except ImportError:
+            logger.warning(f"[OptionalImports] {module_name} no está instalado.")
+            return None
+
+
+# Funciones de conveniencia para compatibilidad con código existente
+def get_chromadb():
+    """Importa ChromaDB si está disponible."""
+    chromadb_module, settings = OptionalImports.get_chromadb()
+    return chromadb_module, settings
+
+
+def get_sentence_transformers():
+    """Importa sentence-transformers si está disponible."""
+    return OptionalImports.get_sentence_transformers()
+
+
+def get_openai():
+    """Importa OpenAI si está disponible."""
+    return OptionalImports.get_openai()
+
+
+def get_anthropic():
+    """Importa Anthropic si está disponible."""
+    return OptionalImports.get_anthropic()
+
+
+def get_google_generativeai():
+    """Importa google-generativeai si está disponible."""
+    return OptionalImports.get_google_generativeai()
+
+
+def check_rag_available() -> bool:
+    """Verifica si todas las dependencias de RAG están disponibles."""
+    return OptionalImports.check_rag_available()