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

evolutia/validation/config_validator.py

@@ -0,0 +1,502 @@
+"""
+Validador de configuración para EvolutIA.
+Valida exhaustivamente la configuración del sistema.
+"""
+import logging
+from pathlib import Path
+from typing import Dict, Any, List, Tuple, Optional, Union
+
+logger = logging.getLogger(__name__)
+
+
+class ConfigValidationError(Exception):
+    """Excepción para errores de validación de configuración."""
+    def __init__(self, message: str, errors: Optional[List[str]] = None):
+        super().__init__(message)
+        self.errors = errors or []
+        self.message = message
+
+
+class ConfigValidator:
+    """Validador de configuración del sistema."""
+
+    # Valores válidos para algunas configuraciones
+    VALID_API_PROVIDERS = {
+        'openai', 'anthropic', 'local', 'gemini', 'deepseek', 'generic'
+    }
+    VALID_EMBEDDING_PROVIDERS = {'openai', 'sentence-transformers'}
+    VALID_VECTOR_STORE_TYPES = {'chromadb'}
+
+    def __init__(self):
+        self.errors: List[str] = []
+        self.warnings: List[str] = []
+
+    def validate_config(self, config: Dict[str, Any]) -> Tuple[bool, List[str]]:
+        """
+        Valida toda la configuración.
+
+        Args:
+            config: Diccionario de configuración
+
+        Returns:
+            Tupla (is_valid, error_messages) donde is_valid es True si la
+            configuración es válida, y error_messages es una lista con
+            mensajes de error (vacía si is_valid es True)
+        """
+        self.errors = []
+        self.warnings = []
+
+        # Validar secciones principales
+        self._validate_paths(config.get('paths', {}))
+        self._validate_api(config.get('api', {}))
+        self._validate_exam(config.get('exam', {}))
+        self._validate_generation(config.get('generation', {}))
+        self._validate_rag(config.get('rag', {}))
+
+        # Log warnings
+        for warning in self.warnings:
+            logger.warning(f"[ConfigValidator] {warning}")
+
+        return len(self.errors) == 0, self.errors
+
+    def _validate_paths(self, paths: Dict[str, Any]):
+        """Valida la configuración de rutas."""
+        if not paths:
+            self.warnings.append("No se encontró configuración de rutas")
+            return
+
+        # Validar base_path
+        base_path = paths.get('base_path')
+        if base_path:
+            path = Path(base_path)
+            if not path.exists():
+                self.errors.append(
+                    f"paths.base_path no existe: {base_path}"
+                )
+            elif not path.is_dir():
+                self.errors.append(
+                    f"paths.base_path no es un directorio: {base_path}"
+                )
+
+        # Validar materials_directories
+        materials_dirs = paths.get('materials_directories')
+        if materials_dirs:
+            if isinstance(materials_dirs, str) and materials_dirs == 'auto':
+                # Valor especial para descubrimiento automático
+                pass
+            elif isinstance(materials_dirs, list):
+                for topic in materials_dirs:
+                    if base_path:
+                        topic_path = Path(base_path) / topic
+                        if not topic_path.exists():
+                            self.warnings.append(
+                                f"paths.materials_directories contiene tema no existente: {topic}"
+                            )
+
+    def _validate_api(self, api: Dict[str, Any]):
+        """Valida la configuración de API."""
+        if not api:
+            self.warnings.append("No se encontró configuración de API")
+            return
+
+        # Validar default_provider
+        default_provider = api.get('default_provider')
+        if default_provider:
+            if default_provider not in self.VALID_API_PROVIDERS:
+                self.errors.append(
+                    f"api.default_provider debe ser uno de {sorted(self.VALID_API_PROVIDERS)}, "
+                    f"obtenido: {default_provider}"
+                )
+
+        # Validar configuración de proveedores
+        providers = api.get('providers', {})
+        if providers:
+            for provider_name, provider_config in providers.items():
+                if provider_name not in self.VALID_API_PROVIDERS:
+                    self.warnings.append(
+                        f"api.providers contiene proveedor desconocido: {provider_name}"
+                    )
+                    continue
+
+                self._validate_provider_config(provider_name, provider_config)
+
+    def _validate_provider_config(self, provider_name: str, provider_config: Dict[str, Any]):
+        """Valida la configuración de un proveedor específico."""
+        if provider_name == 'openai':
+            self._validate_openai_config(provider_config)
+        elif provider_name == 'anthropic':
+            self._validate_anthropic_config(provider_config)
+        elif provider_name == 'local':
+            self._validate_local_config(provider_config)
+        elif provider_name == 'gemini':
+            self._validate_gemini_config(provider_config)
+        elif provider_name == 'deepseek':
+            self._validate_deepseek_config(provider_config)
+        elif provider_name == 'generic':
+            self._validate_generic_config(provider_config)
+
+    def _validate_openai_config(self, config: Dict[str, Any]):
+        """Valida configuración de OpenAI."""
+        model = config.get('model')
+        if model and not isinstance(model, str):
+            self.errors.append(
+                f"api.providers.openai.model debe ser string, obtenido: {type(model)}"
+            )
+
+        max_tokens = config.get('max_tokens')
+        if max_tokens is not None:
+            if not isinstance(max_tokens, int) or max_tokens <= 0:
+                self.errors.append(
+                    f"api.providers.openai.max_tokens debe ser entero positivo, "
+                    f"obtenido: {max_tokens}"
+                )
+
+        temperature = config.get('temperature')
+        if temperature is not None:
+            if not isinstance(temperature, (int, float)) or not (0 <= temperature <= 2):
+                self.errors.append(
+                    f"api.providers.openai.temperature debe estar entre 0 y 2, "
+                    f"obtenido: {temperature}"
+                )
+
+    def _validate_anthropic_config(self, config: Dict[str, Any]):
+        """Valida configuración de Anthropic."""
+        model = config.get('model')
+        if model and not isinstance(model, str):
+            self.errors.append(
+                f"api.providers.anthropic.model debe ser string, obtenido: {type(model)}"
+            )
+
+        max_tokens = config.get('max_tokens')
+        if max_tokens is not None:
+            if not isinstance(max_tokens, int) or max_tokens <= 0:
+                self.errors.append(
+                    f"api.providers.anthropic.max_tokens debe ser entero positivo, "
+                    f"obtenido: {max_tokens}"
+                )
+
+        temperature = config.get('temperature')
+        if temperature is not None:
+            if not isinstance(temperature, (int, float)) or not (0 <= temperature <= 1):
+                self.errors.append(
+                    f"api.providers.anthropic.temperature debe estar entre 0 y 1, "
+                    f"obtenido: {temperature}"
+                )
+
+    def _validate_local_config(self, config: Dict[str, Any]):
+        """Valida configuración de modelos locales."""
+        base_url = config.get('base_url')
+        if base_url:
+            if not isinstance(base_url, str):
+                self.errors.append(
+                    f"api.providers.local.base_url debe ser string, obtenido: {type(base_url)}"
+                )
+            elif not base_url.startswith(('http://', 'https://')):
+                self.errors.append(
+                    f"api.providers.local.base_url debe ser una URL válida, "
+                    f"obtenido: {base_url}"
+                )
+
+        model = config.get('model')
+        if model and not isinstance(model, str):
+            self.errors.append(
+                f"api.providers.local.model debe ser string, obtenido: {type(model)}"
+            )
+
+        timeout = config.get('timeout')
+        if timeout is not None:
+            if not isinstance(timeout, (int, float)) or timeout <= 0:
+                self.errors.append(
+                    f"api.providers.local.timeout debe ser numérico positivo, "
+                    f"obtenido: {timeout}"
+                )
+
+    def _validate_gemini_config(self, config: Dict[str, Any]):
+        """Valida configuración de Gemini."""
+        model = config.get('model')
+        if model and not isinstance(model, str):
+            self.errors.append(
+                f"api.providers.gemini.model debe ser string, obtenido: {type(model)}"
+            )
+
+        temperature = config.get('temperature')
+        if temperature is not None:
+            if not isinstance(temperature, (int, float)) or not (0 <= temperature <= 2):
+                self.errors.append(
+                    f"api.providers.gemini.temperature debe estar entre 0 y 2, "
+                    f"obtenido: {temperature}"
+                )
+
+    def _validate_deepseek_config(self, config: Dict[str, Any]):
+        """Valida configuración de DeepSeek."""
+        model = config.get('model')
+        if model and not isinstance(model, str):
+            self.errors.append(
+                f"api.providers.deepseek.model debe ser string, obtenido: {type(model)}"
+            )
+
+        temperature = config.get('temperature')
+        if temperature is not None:
+            if not isinstance(temperature, (int, float)) or not (0 <= temperature <= 2):
+                self.errors.append(
+                    f"api.providers.deepseek.temperature debe estar entre 0 y 2, "
+                    f"obtenido: {temperature}"
+                )
+
+    def _validate_generic_config(self, config: Dict[str, Any]):
+        """Valida configuración genérica."""
+        base_url = config.get('base_url')
+        if base_url:
+            if not isinstance(base_url, str):
+                self.errors.append(
+                    f"api.providers.generic.base_url debe ser string, obtenido: {type(base_url)}"
+                )
+            elif not base_url.startswith(('http://', 'https://')):
+                self.errors.append(
+                    f"api.providers.generic.base_url debe ser una URL válida, "
+                    f"obtenido: {base_url}"
+                )
+
+        model = config.get('model')
+        if model and not isinstance(model, str):
+            self.errors.append(
+                f"api.providers.generic.model debe ser string, obtenido: {type(model)}"
+            )
+
+    def _validate_exam(self, exam: Dict[str, Any]):
+        """Valida la configuración de examen."""
+        if not exam:
+            self.warnings.append("No se encontró configuración de examen")
+            return
+
+        default = exam.get('default', {})
+        if default:
+            self._validate_exam_default(default)
+
+        keywords = exam.get('keywords', {})
+        if keywords:
+            self._validate_exam_keywords(keywords)
+
+    def _validate_exam_default(self, default: Dict[str, Any]):
+        """Valida configuración por defecto de examen."""
+        subject = default.get('subject')
+        if subject and not isinstance(subject, str):
+            self.errors.append(
+                f"exam.default.subject debe ser string, obtenido: {type(subject)}"
+            )
+
+        points_per_exercise = default.get('points_per_exercise')
+        if points_per_exercise is not None:
+            if not isinstance(points_per_exercise, int) or points_per_exercise <= 0:
+                self.errors.append(
+                    f"exam.default.points_per_exercise debe ser entero positivo, "
+                    f"obtenido: {points_per_exercise}"
+                )
+
+        duration_hours = default.get('duration_hours')
+        if duration_hours is not None:
+            if not isinstance(duration_hours, (int, float)) or not (0 < duration_hours <= 24):
+                self.errors.append(
+                    f"exam.default.duration_hours debe estar entre 0 y 24, "
+                    f"obtenido: {duration_hours}"
+                )
+
+    def _validate_exam_keywords(self, keywords: Dict[str, Any]):
+        """Valida configuración de keywords de examen."""
+        if not isinstance(keywords, dict):
+            self.errors.append(
+                f"exam.keywords debe ser un diccionario, obtenido: {type(keywords)}"
+            )
+            return
+
+        for topic, kw_list in keywords.items():
+            if not isinstance(kw_list, list):
+                self.errors.append(
+                    f"exam.keywords.{topic} debe ser una lista, obtenido: {type(kw_list)}"
+                )
+            else:
+                for kw in kw_list:
+                    if not isinstance(kw, str):
+                        self.errors.append(
+                            f"exam.keywords.{topic} debe contener solo strings, "
+                            f"encontrado: {kw} ({type(kw)})"
+                        )
+
+    def _validate_generation(self, generation: Dict[str, Any]):
+        """Valida la configuración de generación."""
+        if not generation:
+            self.warnings.append("No se encontró configuración de generación")
+            return
+
+        max_workers = generation.get('max_workers')
+        if max_workers is not None:
+            if not isinstance(max_workers, int) or not (1 <= max_workers <= 50):
+                self.errors.append(
+                    f"generation.max_workers debe estar entre 1 y 50, "
+                    f"obtenido: {max_workers}"
+                )
+
+        request_delay = generation.get('request_delay')
+        if request_delay is not None:
+            if not isinstance(request_delay, (int, float)) or request_delay < 0:
+                self.errors.append(
+                    f"generation.request_delay debe ser numérico no negativo, "
+                    f"obtenido: {request_delay}"
+                )
+
+        retry_attempts = generation.get('retry_attempts')
+        if retry_attempts is not None:
+            if not isinstance(retry_attempts, int) or retry_attempts < 0:
+                self.errors.append(
+                    f"generation.retry_attempts debe ser entero no negativo, "
+                    f"obtenido: {retry_attempts}"
+                )
+
+        llm_params = generation.get('llm_params', {})
+        if llm_params:
+            self._validate_llm_params(llm_params)
+
+        complexity = generation.get('complexity', {})
+        if complexity:
+            self._validate_complexity_config(complexity)
+
+    def _validate_llm_params(self, llm_params: Dict[str, Any]):
+        """Valida parámetros LLM de generación."""
+        default_temperature = llm_params.get('default_temperature')
+        if default_temperature is not None:
+            if not isinstance(default_temperature, (int, float)) or not (0 <= default_temperature <= 2):
+                self.errors.append(
+                    f"generation.llm_params.default_temperature debe estar entre 0 y 2, "
+                    f"obtenido: {default_temperature}"
+                )
+
+        default_max_tokens = llm_params.get('default_max_tokens')
+        if default_max_tokens is not None:
+            if not isinstance(default_max_tokens, int) or default_max_tokens <= 0:
+                self.errors.append(
+                    f"generation.llm_params.default_max_tokens debe ser entero positivo, "
+                    f"obtenido: {default_max_tokens}"
+                )
+
+    def _validate_complexity_config(self, complexity: Dict[str, Any]):
+        """Valida configuración de complejidad."""
+        min_improvement_percent = complexity.get('min_improvement_percent')
+        if min_improvement_percent is not None:
+            if not isinstance(min_improvement_percent, (int, float)) or not (0 <= min_improvement_percent <= 100):
+                self.errors.append(
+                    f"generation.complexity.min_improvement_percent debe estar entre 0 y 100, "
+                    f"obtenido: {min_improvement_percent}"
+                )
+
+        required_improvements_count = complexity.get('required_improvements_count')
+        if required_improvements_count is not None:
+            if not isinstance(required_improvements_count, int) or required_improvements_count < 0:
+                self.errors.append(
+                    f"generation.complexity.required_improvements_count debe ser entero no negativo, "
+                    f"obtenido: {required_improvements_count}"
+                )
+
+    def _validate_rag(self, rag: Dict[str, Any]):
+        """Valida la configuración de RAG."""
+        if not rag:
+            return  # RAG es opcional
+
+        vector_store = rag.get('vector_store', {})
+        if vector_store:
+            self._validate_rag_vector_store(vector_store)
+
+        embeddings = rag.get('embeddings', {})
+        if embeddings:
+            self._validate_rag_embeddings(embeddings)
+
+        retrieval = rag.get('retrieval', {})
+        if retrieval:
+            self._validate_rag_retrieval(retrieval)
+
+        chunking = rag.get('chunking', {})
+        if chunking:
+            self._validate_rag_chunking(chunking)
+
+    def _validate_rag_vector_store(self, vector_store: Dict[str, Any]):
+        """Valida configuración de vector store RAG."""
+        store_type = vector_store.get('type')
+        if store_type and store_type not in self.VALID_VECTOR_STORE_TYPES:
+            self.errors.append(
+                f"rag.vector_store.type debe ser uno de {sorted(self.VALID_VECTOR_STORE_TYPES)}, "
+                f"obtenido: {store_type}"
+            )
+
+        persist_directory = vector_store.get('persist_directory')
+        if persist_directory:
+            # Verificar que el directorio pueda crearse
+            path = Path(persist_directory)
+            if path.exists() and not path.is_dir():
+                self.errors.append(
+                    f"rag.vector_store.persist_directory debe ser un directorio, "
+                    f"obtenido: {persist_directory}"
+                )
+
+    def _validate_rag_embeddings(self, embeddings: Dict[str, Any]):
+        """Valida configuración de embeddings RAG."""
+        provider = embeddings.get('provider')
+        if provider and provider not in self.VALID_EMBEDDING_PROVIDERS:
+            self.errors.append(
+                f"rag.embeddings.provider debe ser uno de {sorted(self.VALID_EMBEDDING_PROVIDERS)}, "
+                f"obtenido: {provider}"
+            )
+
+        model = embeddings.get('model')
+        if model and not isinstance(model, str):
+            self.errors.append(
+                f"rag.embeddings.model debe ser string, obtenido: {type(model)}"
+            )
+
+        batch_size = embeddings.get('batch_size')
+        if batch_size is not None:
+            if not isinstance(batch_size, int) or batch_size <= 0:
+                self.errors.append(
+                    f"rag.embeddings.batch_size debe ser entero positivo, "
+                    f"obtenido: {batch_size}"
+                )
+
+    def _validate_rag_retrieval(self, retrieval: Dict[str, Any]):
+        """Valida configuración de recuperación RAG."""
+        top_k = retrieval.get('top_k')
+        if top_k is not None:
+            if not isinstance(top_k, int) or not (1 <= top_k <= 100):
+                self.errors.append(
+                    f"rag.retrieval.top_k debe estar entre 1 y 100, "
+                    f"obtenido: {top_k}"
+                )
+
+        similarity_threshold = retrieval.get('similarity_threshold')
+        if similarity_threshold is not None:
+            if not isinstance(similarity_threshold, (int, float)) or not (0 <= similarity_threshold <= 1):
+                self.errors.append(
+                    f"rag.retrieval.similarity_threshold debe estar entre 0 y 1, "
+                    f"obtenido: {similarity_threshold}"
+                )
+
+    def _validate_rag_chunking(self, chunking: Dict[str, Any]):
+        """Valida configuración de chunking RAG."""
+        chunk_size = chunking.get('chunk_size')
+        if chunk_size is not None:
+            if not isinstance(chunk_size, int) or chunk_size <= 0:
+                self.errors.append(
+                    f"rag.chunking.chunk_size debe ser entero positivo, "
+                    f"obtenido: {chunk_size}"
+                )
+
+        chunk_overlap = chunking.get('chunk_overlap')
+        if chunk_overlap is not None:
+            if not isinstance(chunk_overlap, int) or chunk_overlap < 0:
+                self.errors.append(
+                    f"rag.chunking.chunk_overlap debe ser entero no negativo, "
+                    f"obtenido: {chunk_overlap}"
+                )
+
+        if chunk_size and chunk_overlap and chunk_overlap >= chunk_size:
+            self.errors.append(
+                f"rag.chunking.chunk_overlap debe ser menor que chunk_size, "
+                f"obtenido: overlap={chunk_overlap}, size={chunk_size}"
+            )

evolutia/variation_generator.py

@@ -1,22 +1,22 @@
-"""
-Generador de variaciones de ejercicios con mayor complejidad.
-Utiliza APIs de IA para generar variaciones inteligentes.
-"""
-import os
-import logging
-from typing import Dict, Optional
-from dotenv import load_dotenv
-from pathlib import Path
-
-# Imports for new Provider system
-from .llm_providers import get_provider
-from .utils.json_parser import extract_and_parse_json
-
-# Cargar variables de entorno explícitamente desde el directorio del script
-env_path = Path(__file__).parent / '.env'
-load_dotenv(dotenv_path=env_path)
-
-logger = logging.getLogger(__name__)
+"""
+Generador de variaciones de ejercicios con mayor complejidad.
+Utiliza APIs de IA para generar variaciones inteligentes.
+"""
+import os
+import logging
+from typing import Dict, Optional, List, Union, Any
+from dotenv import load_dotenv
+from pathlib import Path
+
+# Imports for new Provider system
+from .llm_providers import get_provider, LLMProvider
+from .utils.json_parser import extract_and_parse_json
+
+# Cargar variables de entorno explícitamente desde el directorio del script
+env_path = Path(__file__).parent / '.env'
+load_dotenv(dotenv_path=env_path)
+
+logger = logging.getLogger(__name__)
 
 
 
@@ -37,27 +37,36 @@ class VariationGenerator:
         
         self._provider_instance = None
     
-    def _get_provider(self):
-        """Lazy loader para el proveedor, permitiendo configuración tardía de props."""
-        if self._provider_instance:
-            return self._provider_instance
-            
-        kwargs = {}
-        if self.model_name:
-            kwargs['model_name'] = self.model_name
-        elif self.local_model and self.api_provider == 'local':
-             kwargs['model_name'] = self.local_model
-             
-        if self.base_url and self.api_provider == 'local':
-            kwargs['base_url'] = self.base_url
-
-        try:
-            self._provider_instance = get_provider(self.api_provider, **kwargs)
-        except ValueError as e:
-            logger.error(f"Error inicializando proveedor: {e}")
-            return None
-            
-        return self._provider_instance
+    def _get_provider(self):
+        """
+        Lazy loader para el proveedor, permitiendo configuración tardía de props.
+
+        Returns:
+            Instancia de LLMProvider si la inicialización fue exitosa
+            None si hubo un error de configuración
+        """
+        if self._provider_instance:
+            return self._provider_instance
+
+        kwargs = {}
+        if self.model_name:
+            kwargs['model_name'] = self.model_name
+        elif self.local_model and self.api_provider == 'local':
+             kwargs['model_name'] = self.local_model
+
+        if self.base_url:
+            kwargs['base_url'] = self.base_url
+
+        try:
+            self._provider_instance = get_provider(self.api_provider, **kwargs)
+            logger.info(f"[VariationGenerator] Proveedor inicializado: {self.api_provider}")
+            return self._provider_instance
+        except ValueError as e:
+            logger.error(f"[VariationGenerator] Error inicializando proveedor '{self.api_provider}': {e}")
+            return None
+        except Exception as e:
+            logger.error(f"[VariationGenerator] Error inesperado inicializando proveedor '{self.api_provider}': {e}")
+            return None
 
     def _create_prompt(self, exercise: Dict, analysis: Dict) -> str:
         """Crea el prompt para generar una variación."""
@@ -96,8 +105,8 @@ REGLAS DE FORMATO:
 Genera solo el contenido solicitado."""
         return prompt
 
-    def _create_quiz_prompt(self, context_info: Dict) -> str:
-        """Crea prompt para ejercicios de selección única."""
+    def _create_quiz_prompt(self, context_info: Dict[str, Any]) -> str:
+        """Crea prompt para ejercicios de selección única."""
         content = context_info.get('content', '')
         
         prompt = f"""Actúa como un profesor experto. Genera una pregunta de examen de tipo SELECCIÓN ÚNICA (Quiz) basada en el siguiente material:
@@ -124,30 +133,33 @@ REQUISITOS:
 """
         return prompt
 
-    def generate_variation(self, exercise: Dict, analysis: Dict, exercise_type: str = "development") -> Optional[Dict]:
-        """
-        Genera una variación de un ejercicio existente.
-        """
-        # 1. Crear prompt según tipo
-        if exercise_type == 'multiple_choice':
-            context_info = {
-                'content': f"Ejercicio Original:\n{exercise.get('content')}"
-            }
-            prompt = self._create_quiz_prompt(context_info)
-        else:
-            prompt = self._create_prompt(exercise, analysis)
-            
-        # 2. Get Provider
-        provider = self._get_provider()
-        if not provider: return None
-        
-        # 3. Generar
-        content = provider.generate_content(prompt, system_prompt="Eres un experto en diseño de exámenes de ingeniería.")
-        
-        if not content:
-            return None
-            
-        # 4. Parsear respuesta
+    def generate_variation(self, exercise: Dict[str, Any], analysis: Dict[str, Any], exercise_type: str = "development") -> Optional[Dict]:
+        """
+        Genera una variación de un ejercicio existente.
+        """
+         # 1. Crear prompt según tipo
+        if exercise_type == 'multiple_choice':
+            context_info = {
+                'content': f"Ejercicio Original:\n{exercise.get('content')}"
+            }
+            prompt = self._create_quiz_prompt(context_info)
+        else:
+            prompt = self._create_prompt(exercise, analysis)
+
+        # 2. Get Provider
+        provider = self._get_provider()
+        if not provider:
+            logger.warning("[VariationGenerator] Proveedor no inicializado, no se puede generar variación")
+            return None
+
+        # 3. Generar
+        content = provider.generate_content(prompt, system_prompt="Eres un experto en diseño de exámenes de ingeniería.")
+
+        if not content:
+            logger.warning("[VariationGenerator] Proveedor retornó contenido vacío")
+            return None
+
+        # 4. Parsear respuesta
         variation_content = ""
         variation_solution = ""
         
@@ -200,10 +212,10 @@ INSTRUCCIONES:
 """
         return prompt
 
-    def generate_new_exercise_from_topic(self, topic: str, tags: list = None, difficulty: str = "alta", exercise_type: str = "development") -> Optional[Dict]:
-        """
-        Genera un ejercicio nuevo desde cero.
-        """
+    def generate_new_exercise_from_topic(self, topic: str, tags: Optional[List[str]] = None, difficulty: str = "alta", exercise_type: str = "development") -> Optional[Dict]:
+        """
+        Genera un ejercicio nuevo desde cero.
+        """
         tags = tags or []
         context = {} # Base implementations doesn't use context