iatoolkit 0.71.4__py3-none-any.whl → 1.4.2__py3-none-any.whl

iatoolkit/company_registry.py

@@ -3,9 +3,10 @@
 #
 # IAToolkit is open source software.
 
-from typing import Dict, Type, Any
+from typing import Dict, Type, Any, Optional
 from .base_company import BaseCompany
 import logging
+from injector import inject
 
 
 class CompanyRegistry:
@@ -14,10 +15,35 @@ class CompanyRegistry:
     Allow the client to register companies and instantiate them with dependency injection.
     """
 
+    @inject
     def __init__(self):
         self._company_classes: Dict[str, Type[BaseCompany]] = {}
         self._company_instances: Dict[str, BaseCompany] = {}
 
+    def register(self, name: str, company_class: Type[BaseCompany]) -> None:
+        """
+        Registers a company in the registry.
+
+        COMMUNITY EDITION LIMITATION:
+        This base implementation enforces a strict single-tenant limit.
+        It raises a RuntimeError if a second company is registered.
+        """
+        if not issubclass(company_class, BaseCompany):
+            raise ValueError(f"The class {company_class.__name__} must be a subclass of BaseCompany")
+
+        company_key = name.lower()
+
+        # --- STRICT SINGLE-TENANT ENFORCEMENT ---
+        # If a company is already registered (and it's not an update to the same key)
+        if len(self._company_classes) > 0 and company_key not in self._company_classes:
+            logging.error(f"❌ Community Edition Restriction: Cannot register '{name}'. Limit reached (1).")
+            raise RuntimeError(
+                "IAToolkit Community Edition allows only one company instance. "
+                "Upgrade to IAToolkit Enterprise to enable multi-tenancy."
+            )
+
+        self._company_classes[company_key] = company_class
+        logging.info(f"Company registered: {name}")
 
     def instantiate_companies(self, injector) -> Dict[str, BaseCompany]:
         """
@@ -34,15 +60,16 @@ class CompanyRegistry:
 
                 except Exception as e:
                     logging.error(f"Error while creating company instance for {company_key}: {e}")
-                    logging.exception(e)
-                    raise
+                    raise e
 
         return self._company_instances.copy()
 
     def get_all_company_instances(self) -> Dict[str, BaseCompany]:
-        """Devuelve un diccionario con todas las instancias de empresas creadas."""
         return self._company_instances.copy()
 
+    def get_company_instance(self, company_name: str) -> Optional[BaseCompany]:
+        return self._company_instances.get(company_name.lower())
+
     def get_registered_companies(self) -> Dict[str, Type[BaseCompany]]:
         return self._company_classes.copy()
 
@@ -50,11 +77,33 @@ class CompanyRegistry:
         self._company_classes.clear()
         self._company_instances.clear()
 
+# --- Singleton Management ---
 
-# global instance of the company registry
+# Global instance (Default: Community Edition)
 _company_registry = CompanyRegistry()
 
 
+def get_company_registry() -> CompanyRegistry:
+    """Get the global company registry instance."""
+    return _company_registry
+
+def get_registered_companies() -> Dict[str, Type[BaseCompany]]:
+    return _company_registry.get_registered_companies()
+
+
+def set_company_registry(registry: CompanyRegistry) -> None:
+    """
+    Sets the global company registry instance.
+    Use this to inject an Enterprise-compatible registry implementation.
+    """
+    global _company_registry
+    if not isinstance(registry, CompanyRegistry):
+        raise ValueError("Registry must inherit from CompanyRegistry")
+
+    _company_registry = registry
+    logging.info(f"✅ Company Registry implementation swapped: {type(registry).__name__}")
+
+
 def register_company(name: str, company_class: Type[BaseCompany]) -> None:
     """
     Public function to register a company.
@@ -63,13 +112,5 @@ def register_company(name: str, company_class: Type[BaseCompany]) -> None:
         name: Name of the company
         company_class: Class that inherits from BaseCompany
     """
-    if not issubclass(company_class, BaseCompany):
-        raise ValueError(f"La clase {company_class.__name__} debe heredar de BaseCompany")
-
-    company_key = name.lower()
-    _company_registry._company_classes[company_key] = company_class
+    _company_registry.register(name, company_class)
 
-
-def get_company_registry() -> CompanyRegistry:
-    """get the global company registry instance"""
-    return _company_registry

iatoolkit/{iatoolkit.py → core.py}

@@ -3,27 +3,31 @@
 #
 # IAToolkit is open source software.
 
-from flask import Flask, url_for, get_flashed_messages
+from flask import Flask, url_for, get_flashed_messages, request
 from flask_session import Session
 from flask_injector import FlaskInjector
 from flask_bcrypt import Bcrypt
 from flask_cors import CORS
 from iatoolkit.common.exceptions import IAToolkitException
+from iatoolkit.repositories.database_manager import DatabaseManager
+from iatoolkit.common.interfaces.asset_storage import AssetRepository
+from iatoolkit.company_registry import get_registered_companies
+from werkzeug.middleware.proxy_fix import ProxyFix
+from injector import Binder, Injector, singleton
+from typing import Optional, Dict, Any
 from urllib.parse import urlparse
 import redis
 import logging
 import os
-from typing import Optional, Dict, Any
-from iatoolkit.repositories.database_manager import DatabaseManager
-from werkzeug.middleware.proxy_fix import ProxyFix
-from injector import Binder, Injector, singleton
-from importlib.metadata import version as _pkg_version, PackageNotFoundError
 
-IATOOLKIT_VERSION = "0.71.4"
+from iatoolkit import __version__ as IATOOLKIT_VERSION
+from iatoolkit.services.configuration_service import ConfigurationService
 
 # global variable for the unique instance of IAToolkit
 _iatoolkit_instance: Optional['IAToolkit'] = None
 
+def is_bound(injector: Injector, cls) -> bool:
+    return cls in injector.binder._bindings
 
 class IAToolkit:
     """
@@ -51,8 +55,9 @@ class IAToolkit:
         self.config = config or {}
         self.app = None
         self.db_manager = None
-        self._injector = None
-        self.version = IATOOLKIT_VERSION    # default version
+        self._injector = Injector()         # init empty injector
+        self.version = IATOOLKIT_VERSION
+        self.license = "Community Edition"
 
     @classmethod
     def get_instance(cls) -> 'IAToolkit':
@@ -62,7 +67,7 @@ class IAToolkit:
             _iatoolkit_instance = cls()
         return _iatoolkit_instance
 
-    def create_iatoolkit(self):
+    def create_iatoolkit(self, start: bool = True):
         """
             Creates, configures, and returns the Flask application instance.
             this is the main entry point for the application factory.
@@ -78,8 +83,8 @@ class IAToolkit:
         # Step 2: Set up the core components that DI depends on
         self._setup_database()
 
-        # Step 3: Create the Injector and configure all dependencies in one place
-        self._injector = Injector(self._configure_core_dependencies)
+        # Step 3: Configure dependencies using the existing injector
+        self._configure_core_dependencies(self._injector)
 
         # Step 4: Register routes using the fully configured injector
         self._register_routes()
@@ -88,27 +93,42 @@ class IAToolkit:
         # and other integrations, as views are handled manually.
         FlaskInjector(app=self.app, injector=self._injector)
 
-        # Step 6: initialize dispatcher and registered companies
-        self._init_dispatcher_and_company_instances()
+        # Step 6: initialize registered companies
+        self._instantiate_company_instances()
 
         # Re-apply logging configuration in case it was modified by company-specific code
         self._setup_logging()
 
-        # Step 7: Finalize setup within the application context
+        # Step 7: load company configuration file
+        self._load_company_configuration()
+
+        # Step 8: Finalize setup within the application context
         self._setup_redis_sessions()
+
         self._setup_cors()
         self._setup_additional_services()
         self._setup_cli_commands()
         self._setup_request_globals()
         self._setup_context_processors()
 
-        # Step 8: define the download_dir for excel's
+        # Step 9: define the download_dir
         self._setup_download_dir()
 
-        logging.info(f"🎉 IAToolkit v{self.version} inicializado correctamente")
+        # register data source
+        if start:
+            self.register_data_sources()
+
+        logging.info(f"🎉 IAToolkit {self.license} version {self.version} correctly initialized.")
         self._initialized = True
+
         return self.app
 
+    def register_data_sources(self):
+        # load the company configurations
+        configuration_service = self._injector.get(ConfigurationService)
+        for company in get_registered_companies():
+            configuration_service.register_data_sources(company)
+
     def _get_config_value(self, key: str, default=None):
         # get a value from the config dict or the environment variable
         return self.config.get(key, os.getenv(key, default))
@@ -141,14 +161,15 @@ class IAToolkit:
             force=True
         )
 
+        logging.getLogger("httpx").setLevel(logging.WARNING)
+
     def _register_routes(self):
         """Registers routes by passing the configured injector."""
         from iatoolkit.common.routes import register_views
 
         # Pass the injector to the view registration function
-        register_views(self._injector, self.app)
-
-        logging.info("✅ Routes registered.")
+        register_views(self.app)
+        logging.info("✅ Community routes registered.")
 
     def _create_flask_instance(self):
         static_folder = self._get_config_value('STATIC_FOLDER') or self._get_default_static_folder()
@@ -158,12 +179,6 @@ class IAToolkit:
                          static_folder=static_folder,
                          template_folder=template_folder)
 
-        # get the IATOOLKIT_VERSION from the package metadata
-        try:
-            self.version = _pkg_version("iatoolkit")
-        except PackageNotFoundError:
-            pass
-
         self.app.config.update({
             'VERSION': self.version,
             'SECRET_KEY': self._get_config_value('FLASK_SECRET_KEY', 'iatoolkit-default-secret'),
@@ -171,15 +186,10 @@ class IAToolkit:
             'SESSION_COOKIE_SECURE': True,
             'SESSION_PERMANENT': False,
             'SESSION_USE_SIGNER': True,
-            'JWT_SECRET_KEY': self._get_config_value('JWT_SECRET_KEY', 'iatoolkit-jwt-secret'),
+            'IATOOLKIT_SECRET_KEY': self._get_config_value('IATOOLKIT_SECRET_KEY', 'iatoolkit-jwt-secret'),
             'JWT_ALGORITHM': 'HS256',
-            'JWT_EXPIRATION_SECONDS_CHAT': int(self._get_config_value('JWT_EXPIRATION_SECONDS_CHAT', 3600))
         })
 
-        parsed_url = urlparse(os.getenv('IATOOLKIT_BASE_URL'))
-        if parsed_url.scheme == 'https':
-            self.app.config['PREFERRED_URL_SCHEME'] = 'https'
-
         # 2. ProxyFix para no tener problemas con iframes y rutas
         self.app.wsgi_app = ProxyFix(self.app.wsgi_app, x_proto=1)
 
@@ -188,16 +198,16 @@ class IAToolkit:
             os.environ["TOKENIZERS_PARALLELISM"] = "false"
 
     def _setup_database(self):
-        database_uri = self._get_config_value('DATABASE_URI')
+        database_uri = self._get_config_value('DATABASE_URI') or self._get_config_value('DATABASE_URL')
         if not database_uri:
             raise IAToolkitException(
                 IAToolkitException.ErrorType.CONFIG_ERROR,
-                "DATABASE_URI es requerida (config dict o variable de entorno)"
+                "DATABASE_URI is required (config dict or env. variable)"
             )
 
-        self.db_manager = DatabaseManager(database_uri)
+        self.db_manager = DatabaseManager(database_url=database_uri, schema='iatoolkit')
         self.db_manager.create_all()
-        logging.info("✅ Base de datos configurada correctamente")
+        logging.info("✅ Database configured successfully")
 
         @self.app.teardown_appcontext
         def remove_session(exception=None):
@@ -211,7 +221,7 @@ class IAToolkit:
     def _setup_redis_sessions(self):
         redis_url = self._get_config_value('REDIS_URL')
         if not redis_url:
-            logging.warning("⚠️ REDIS_URL no configurada, usando sesiones en memoria")
+            logging.warning("⚠️ REDIS_URL not configured, will use memory sessions")
             return
 
         try:
@@ -230,27 +240,26 @@ class IAToolkit:
             })
 
             Session(self.app)
-            logging.info("✅ Redis y sesiones configurados correctamente")
+            logging.info("✅ Redis and sessions configured successfully")
 
         except Exception as e:
-            logging.error(f"❌ Error configurando Redis: {e}")
-            logging.warning("⚠️ Continuando sin Redis")
+            logging.error(f"❌ Error configuring Redis: {e}")
+            raise e
 
     def _setup_cors(self):
         """🌐 Configura CORS"""
         from iatoolkit.company_registry import get_company_registry
 
         # default CORS origin
-        default_origins = [
-            os.getenv('IATOOLKIT_BASE_URL')
-        ]
+        default_origins = []
 
         # Iterate through the registered company names
         extra_origins = []
         all_company_instances = get_company_registry().get_all_company_instances()
         for company_name, company_instance in all_company_instances.items():
-            cors_origin = company_instance.company.parameters.get('cors_origin', [])
-            extra_origins += cors_origin
+            if company_instance.company:
+                cors_origin = company_instance.company.parameters.get('cors_origin', [])
+                extra_origins += cors_origin
 
         all_origins = default_origins + extra_origins
 
@@ -263,10 +272,13 @@ class IAToolkit:
              ],
              methods=["GET", "POST", "PUT", "DELETE", "OPTIONS"])
 
-        logging.info(f"✅ CORS configurado para: {all_origins}")
+        logging.info(f"✅ CORS configured for: {all_origins}")
 
-    def _configure_core_dependencies(self, binder: Binder):
+    def _configure_core_dependencies(self, injector: Injector):
         """⚙️ Configures all system dependencies."""
+
+        # get the binder from injector
+        binder = injector.binder
         try:
             # Core dependencies
             binder.bind(Flask, to=self.app)
@@ -277,13 +289,13 @@ class IAToolkit:
             self._bind_services(binder)
             self._bind_infrastructure(binder)
 
-            logging.info("✅ Dependencias configuradas correctamente")
+            logging.info("✅ Dependencies configured successfully")
 
         except Exception as e:
-            logging.error(f"❌ Error configurando dependencias: {e}")
+            logging.error(f"❌ Error configuring dependencies: {e}")
             raise IAToolkitException(
                 IAToolkitException.ErrorType.CONFIG_ERROR,
-                f"❌ Error configurando dependencias: {e}"
+                f"❌ Error configuring dependencies: {e}"
             )
 
     def _bind_repositories(self, binder: Binder):
@@ -291,20 +303,22 @@ class IAToolkit:
         from iatoolkit.repositories.profile_repo import ProfileRepo
         from iatoolkit.repositories.llm_query_repo import LLMQueryRepo
         from iatoolkit.repositories.vs_repo import VSRepo
-        from iatoolkit.repositories.tasks_repo import TaskRepo
+        from iatoolkit.repositories.filesystem_asset_repository import FileSystemAssetRepository
 
         binder.bind(DocumentRepo, to=DocumentRepo)
         binder.bind(ProfileRepo, to=ProfileRepo)
         binder.bind(LLMQueryRepo, to=LLMQueryRepo)
         binder.bind(VSRepo, to=VSRepo)
-        binder.bind(TaskRepo, to=TaskRepo)
+
+        # this class can be setup befor by iatoolkit enterprise
+        if not is_bound(self._injector, AssetRepository):
+            binder.bind(AssetRepository, to=FileSystemAssetRepository)
 
     def _bind_services(self, binder: Binder):
         from iatoolkit.services.query_service import QueryService
-        from iatoolkit.services.tasks_service import TaskService
         from iatoolkit.services.benchmark_service import BenchmarkService
         from iatoolkit.services.document_service import DocumentService
-        from iatoolkit.services.prompt_manager_service import PromptService
+        from iatoolkit.services.prompt_service import PromptService
         from iatoolkit.services.excel_service import ExcelService
         from iatoolkit.services.mail_service import MailService
         from iatoolkit.services.load_documents_service import LoadDocumentsService
@@ -316,9 +330,14 @@ class IAToolkit:
         from iatoolkit.services.language_service import LanguageService
         from iatoolkit.services.configuration_service import ConfigurationService
         from iatoolkit.services.embedding_service import EmbeddingService
+        from iatoolkit.services.history_manager_service import HistoryManagerService
+        from iatoolkit.services.tool_service import ToolService
+        from iatoolkit.services.llm_client_service import llmClient
+        from iatoolkit.services.auth_service import AuthService
+        from iatoolkit.services.sql_service import SqlService
+        from iatoolkit.services.knowledge_base_service import KnowledgeBaseService
 
         binder.bind(QueryService, to=QueryService)
-        binder.bind(TaskService, to=TaskService)
         binder.bind(BenchmarkService, to=BenchmarkService)
         binder.bind(DocumentService, to=DocumentService)
         binder.bind(PromptService, to=PromptService)
@@ -333,32 +352,38 @@ class IAToolkit:
         binder.bind(LanguageService, to=LanguageService)
         binder.bind(ConfigurationService, to=ConfigurationService)
         binder.bind(EmbeddingService, to=EmbeddingService)
+        binder.bind(HistoryManagerService, to=HistoryManagerService)
+        binder.bind(ToolService, to=ToolService)
+        binder.bind(llmClient, to=llmClient)
+        binder.bind(AuthService, to=AuthService)
+        binder.bind(SqlService, to=SqlService)
+        binder.bind(KnowledgeBaseService, to=KnowledgeBaseService)
 
     def _bind_infrastructure(self, binder: Binder):
-        from iatoolkit.infra.llm_client import llmClient
         from iatoolkit.infra.llm_proxy import LLMProxy
         from iatoolkit.infra.google_chat_app import GoogleChatApp
-        from iatoolkit.infra.mail_app import MailApp
-        from iatoolkit.services.auth_service import AuthService
+        from iatoolkit.infra.brevo_mail_app import BrevoMailApp
         from iatoolkit.common.util import Utility
+        from iatoolkit.common.model_registry import ModelRegistry
 
         binder.bind(LLMProxy, to=LLMProxy)
-        binder.bind(llmClient, to=llmClient)
         binder.bind(GoogleChatApp, to=GoogleChatApp)
-        binder.bind(MailApp, to=MailApp)
-        binder.bind(AuthService, to=AuthService)
+        binder.bind(BrevoMailApp, to=BrevoMailApp)
         binder.bind(Utility, to=Utility)
+        binder.bind(ModelRegistry, to=ModelRegistry)
 
     def _setup_additional_services(self):
         Bcrypt(self.app)
 
-    def _init_dispatcher_and_company_instances(self):
+    def _instantiate_company_instances(self):
         from iatoolkit.company_registry import get_company_registry
-        from iatoolkit.services.dispatcher_service import Dispatcher
 
         # instantiate all the registered companies
         get_company_registry().instantiate_companies(self._injector)
 
+    def _load_company_configuration(self):
+        from iatoolkit.services.dispatcher_service import Dispatcher
+
         # use the dispatcher to load the company config.yaml file and prepare the execution
         dispatcher = self._injector.get(Dispatcher)
         dispatcher.load_company_configs()
@@ -369,17 +394,18 @@ class IAToolkit:
 
         # 1. Register core commands
         register_core_commands(self.app)
-        logging.info("✅ Comandos CLI del núcleo registrados.")
+        logging.info("✅ Core CLI commands registered.")
 
         # 2. Register company-specific commands
         try:
             # Iterate through the registered company names
             all_company_instances = get_company_registry().get_all_company_instances()
             for company_name, company_instance in all_company_instances.items():
-                company_instance.register_cli_commands(self.app)
+                if hasattr(company_instance, "register_cli_commands"):
+                    company_instance.register_cli_commands(self.app)
 
         except Exception as e:
-            logging.error(f"❌ Error durante el registro de comandos de compañías: {e}")
+            logging.error(f"❌ error while registering company commands: {e}")
 
     def _setup_context_processors(self):
         # Configura context processors para templates
@@ -403,15 +429,18 @@ class IAToolkit:
 
             return {
                 'url_for': url_for,
-                'iatoolkit_version': self.version,
+                'iatoolkit_version': f'{self.version}',
+                'license': self.license,
                 'app_name': 'IAToolkit',
                 'user_identifier': SessionManager.get('user_identifier'),
                 'company_short_name': SessionManager.get('company_short_name'),
+                'user_role': user_profile.get('user_role'),
                 'user_is_local': user_profile.get('user_is_local'),
                 'user_email': user_profile.get('user_email'),
-                'iatoolkit_base_url': os.environ.get('IATOOLKIT_BASE_URL', ''),
+                'iatoolkit_base_url': request.url_root,
                 'flashed_messages': get_flashed_messages(with_categories=True),
-                't': translate_for_template
+                't': translate_for_template,
+                'google_analytics_id': self._get_config_value('GOOGLE_ANALYTICS_ID', ''),
             }
 
     def _get_default_static_folder(self) -> str:
@@ -442,7 +471,7 @@ class IAToolkit:
         if not self._injector:
             raise IAToolkitException(
                 IAToolkitException.ErrorType.CONFIG_ERROR,
-                "App no inicializada. Llame a create_app() primero"
+                "App no initialized. Call create_app() first"
             )
         return self._injector.get(Dispatcher)
 
@@ -450,7 +479,7 @@ class IAToolkit:
         if not self.db_manager:
             raise IAToolkitException(
                 IAToolkitException.ErrorType.CONFIG_ERROR,
-                "Database manager no inicializado"
+                "Database manager not initialized."
             )
         return self.db_manager
 
@@ -459,7 +488,7 @@ class IAToolkit:
         default_download_dir = os.path.join(os.getcwd(), 'iatoolkit-downloads')
 
         # 3. if user specified one, use it
-        download_dir = self.app.config.get('IATOOLKIT_DOWNLOAD_DIR', default_download_dir)
+        download_dir = self._get_config_value('IATOOLKIT_DOWNLOAD_DIR', default_download_dir)
 
         # 3. save it in the app config
         self.app.config['IATOOLKIT_DOWNLOAD_DIR'] = download_dir
@@ -475,6 +504,7 @@ class IAToolkit:
         logging.info(f"✅ download dir created in: {download_dir}")
 
 
+
 def current_iatoolkit() -> IAToolkit:
     return IAToolkit.get_instance()
 

iatoolkit/infra/{mail_app.py → brevo_mail_app.py}

@@ -13,12 +13,13 @@ import logging
 MAX_ATTACH_BYTES = int(os.getenv("BREVO_MAX_ATTACH_BYTES", str(5 * 1024 * 1024)))  # 5MB seguro
 
 
-class MailApp:
-    def __init__(self,):
+class BrevoMailApp:
+    def _init_brevo(self, provider_config: dict, sender: dict = None):
+        # config and init the brevo client
         self.configuration = sib_api_v3_sdk.Configuration()
-        self.configuration.api_key['api-key'] = os.getenv('BREVO_API_KEY')
+        self.configuration.api_key['api-key'] = provider_config.get("api_key")
         self.mail_api = sib_api_v3_sdk.TransactionalEmailsApi(sib_api_v3_sdk.ApiClient(self.configuration))
-        self.sender = {"email": "ia@iatoolkit.com", "name": "IA Toolkit"}
+
 
     @staticmethod
     def _strip_data_url_prefix(b64: str) -> str:
@@ -73,13 +74,20 @@ class MailApp:
 
 
     def send_email(self,
+                   provider_config: dict,
                    to: str,
                    subject: str,
                    body: str,
-                   sender: dict = None,
+                   sender: dict,
                    attachments: list[dict] = None):
-        if not sender:
-            sender = self.sender
+
+        if not provider_config.get("api_key"):
+            logging.error(f'Try to send brevo_mail without api_key in provider_config')
+            raise IAToolkitException(IAToolkitException.ErrorType.MAIL_ERROR,
+                                     f"Invalid mail configuration for Brevo: missing api-key")
+
+        # init the Brevo client
+        self._init_brevo(provider_config)
 
         try:
             sdk_attachments = self._normalize_attachments(attachments)
@@ -112,34 +120,4 @@ class MailApp:
             logging.exception("MAIL ERROR: %s", str(e))
             raise IAToolkitException(IAToolkitException.ErrorType.MAIL_ERROR,
                                f"No se pudo enviar correo: {str(e)}") from e
-''''
-    def send_template_email(self,
-                   subject: str,
-                   recipients: list,
-                   template_name: str,
-                   context: dict,
-                   sender=None):
-        try:
-            # Renderiza el template con el contexto proporcionado
-            with self.app.app_context():
-                html_message = render_template(template_name, **context)
 
-            # Crea el mensaje
-            msg = Message(
-                subject=subject,
-                recipients=recipients,
-                html=html_message,
-                sender=sender or self.app.config.get('MAIL_DEFAULT_SENDER')
-            )
-
-            # Envía el correo
-            # self.send_brevo_email(msg)
-            pass
-        except jinja2.exceptions.TemplateNotFound:
-            raise IAToolkitException(IAToolkitException.ErrorType.MAIL_ERROR,
-                               f"Error: No se encontró el template '{template_name}'.")
-        except Exception as e:
-            raise IAToolkitException(IAToolkitException.ErrorType.MAIL_ERROR,
-                               f'No se pudo enviar correo: {str(e)}') from e
-    
-    '''