evolutia 0.1.0__py3-none-any.whl → 0.1.2__py3-none-any.whl

evolutia/exercise_analyzer.py

@@ -1,10 +1,16 @@
-"""
-Analizador de complejidad de ejercicios.
-Identifica tipo, pasos, conceptos y variables de ejercicios.
-"""
-import re
-from typing import Dict, List, Set
-from collections import Counter
+"""
+Analizador de complejidad de ejercicios.
+Identifica tipo, pasos, conceptos y variables de ejercicios.
+"""
+import re
+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 (
@@ -22,73 +28,19 @@ 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)
-    }
-
-    STEP_KEYWORDS_PATTERN = re.compile('|'.join(map(re.escape, STEP_KEYWORDS)), re.IGNORECASE)
-
-    # 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\}'
-        ]
-    }
-
-    def __init__(self):
-        """Inicializa el analizador."""
-        pass
+class ExerciseAnalyzer:
+    """Analiza la complejidad y estructura de ejercicios."""
+
+    def __init__(self, cache: Optional['ExerciseAnalysisCache'] = None):
+        """
+        Inicializa el analizador.
+
+        Args:
+            cache: Instancia opcional de ExerciseAnalysisCache para cachear análisis
+        """
+        pass
+
+        self.cache = cache
 
     def identify_exercise_type(self, content: str) -> str:
         """
@@ -183,23 +135,34 @@ class ExerciseAnalyzer:
 
         return concepts
 
-    def analyze(self, exercise: Dict) -> Dict:
-        """
-        Analiza un ejercicio completo y retorna metadatos de complejidad.
-
-        Args:
-            exercise: Diccionario con información del ejercicio
-                - 'content': Contenido del ejercicio
-                - 'solution': Contenido de la solución (opcional)
-
-        Returns:
-            Diccionario con análisis de complejidad
-        """
-        content = exercise.get('content', '')
-        solution = exercise.get('solution', '')
-
-        # Extraer expresiones matemáticas
-        math_expressions = extract_math_expressions(content)
+    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.
+
+        Args:
+            exercise: Diccionario con información del ejercicio
+                - 'content': Contenido del ejercicio
+                - 'solution': Contenido de la solución (opcional)
+
+        Returns:
+            Diccionario con análisis de complejidad
+        """
+        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:
             math_expressions.extend(extract_math_expressions(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()