iatoolkit 0.63.1__py3-none-any.whl → 0.69.0__py3-none-any.whl

iatoolkit/services/dispatcher_service.py

@@ -5,8 +5,9 @@
 
 from iatoolkit.common.exceptions import IAToolkitException
 from iatoolkit.services.prompt_manager_service import PromptService
+from iatoolkit.services.sql_service import SqlService
 from iatoolkit.repositories.llm_query_repo import LLMQueryRepo
-
+from iatoolkit.services.configuration_service import ConfigurationService
 from iatoolkit.repositories.models import Company, Function
 from iatoolkit.services.excel_service import ExcelService
 from iatoolkit.services.mail_service import MailService
@@ -19,14 +20,18 @@ import os
 class Dispatcher:
     @inject
     def __init__(self,
+                 config_service: ConfigurationService,
                  prompt_service: PromptService,
                  llmquery_repo: LLMQueryRepo,
                  util: Utility,
+                 sql_service: SqlService,
                  excel_service: ExcelService,
                  mail_service: MailService):
+        self.config_service = config_service
         self.prompt_service = prompt_service
         self.llmquery_repo = llmquery_repo
         self.util = util
+        self.sql_service = sql_service
         self.excel_service = excel_service
         self.mail_service = mail_service
         self.system_functions = _FUNCTION_LIST
@@ -55,17 +60,50 @@ class Dispatcher:
             self._company_instances = self.company_registry.get_all_company_instances()
         return self._company_instances
 
-    def start_execution(self):
+    def load_company_configs(self):
         # initialize the system functions and prompts
         self.setup_iatoolkit_system()
 
-        """Runs the startup logic for all registered companies."""
-        for company in self.company_instances.values():
-            company.register_company()
-            company.start_execution()
+        """Loads the configuration of every company"""
+        for company_name, company_instance in self.company_instances.items():
+            try:
+                # read company configuration from company.yaml
+                self.config_service.load_configuration(company_name, company_instance)
+
+                # register the company databases
+                self._register_company_databases(company_name)
+
+            except Exception as e:
+                logging.error(f"❌ Failed to register configuration for '{company_name}': {e}")
+                continue
 
         return True
 
+    def _register_company_databases(self, company_name: str):
+        """
+        Reads the data_sources config for a company and registers each
+        database with the central SqlService.
+        """
+        logging.info(f"  -> Registering databases for '{company_name}'...")
+        data_sources_config = self.config_service.get_configuration(company_name, 'data_sources')
+
+        if not data_sources_config or not data_sources_config.get('sql'):
+            logging.info(f"  -> No SQL data sources to register for '{company_name}'.")
+            return
+
+        for db_config in data_sources_config['sql']:
+            db_name = db_config.get('database')
+            db_env_var = db_config.get('connection_string_env')
+
+            # resolve the URI connection string from the environment variable
+            db_uri = os.getenv(db_env_var) if db_env_var else None
+            if not db_uri:
+                logging.warning(
+                    f"-> Skipping database registration for '{company_name}' due to missing 'database' name or connection URI.")
+                return
+
+            self.sql_service.register_database(db_name, db_uri)
+
     def setup_iatoolkit_system(self):
         # create system functions
         for function in self.system_functions:
@@ -90,9 +128,6 @@ class Dispatcher:
             )
             i += 1
 
-        # register in the database  every company class
-        for company in self.company_instances.values():
-            company.register_company()
 
     def dispatch(self, company_name: str, action: str, **kwargs) -> dict:
         company_key = company_name.lower()
@@ -120,37 +155,6 @@ class Dispatcher:
             raise IAToolkitException(IAToolkitException.ErrorType.EXTERNAL_SOURCE_ERROR,
                                f"Error en function call '{action}': {str(e)}") from e
 
-    def get_company_context(self, company_name: str, **kwargs) -> str:
-        if company_name not in self.company_instances:
-            raise IAToolkitException(IAToolkitException.ErrorType.EXTERNAL_SOURCE_ERROR,
-                               f"Empresa no configurada: {company_name}")
-
-        company_context = ''
-
-        # read the company context from this list of markdown files,
-        # company brief, credits, operation description, etc.
-        context_dir = os.path.join(os.getcwd(), f'companies/{company_name}/context')
-        context_files = self.util.get_files_by_extension(context_dir, '.md', return_extension=True)
-        for file in context_files:
-            filepath = os.path.join(context_dir, file)
-            company_context += self.util.load_markdown_context(filepath)
-
-        # add the schemas for every table or function call responses
-        schema_dir = os.path.join(os.getcwd(), f'companies/{company_name}/schema')
-        schema_files = self.util.get_files_by_extension(schema_dir, '.yaml', return_extension=True)
-        for file in schema_files:
-            schema_name = file.split('_')[0]
-            filepath = os.path.join(schema_dir, file)
-            company_context += self.util.generate_context_for_schema(schema_name, filepath)
-
-        company_instance = self.company_instances[company_name]
-        try:
-            return company_context + company_instance.get_company_context(**kwargs)
-        except Exception as e:
-            logging.exception(e)
-            raise IAToolkitException(IAToolkitException.ErrorType.EXTERNAL_SOURCE_ERROR,
-                               f"Error en get_company_context de {company_name}: {str(e)}") from e
-
     def get_company_services(self, company: Company) -> list[dict]:
         # create the syntax with openai response syntax, for the company function list
         tools = []
@@ -173,7 +177,7 @@ class Dispatcher:
     def get_user_info(self, company_name: str, user_identifier: str) -> dict:
         if company_name not in self.company_instances:
             raise IAToolkitException(IAToolkitException.ErrorType.EXTERNAL_SOURCE_ERROR,
-                                     f"Empresa no configurada: {company_name}")
+                                     f"company not configured: {company_name}")
 
         # source 2: external company user
         company_instance = self.company_instances[company_name]
@@ -182,14 +186,14 @@ class Dispatcher:
         except Exception as e:
             logging.exception(e)
             raise IAToolkitException(IAToolkitException.ErrorType.EXTERNAL_SOURCE_ERROR,
-                                     f"Error en get_user_info de {company_name}: {str(e)}") from e
+                                     f"Error in get_user_info: {company_name}: {str(e)}") from e
 
         return external_user_profile
 
     def get_metadata_from_filename(self, company_name: str, filename: str) -> dict:
         if company_name not in self.company_instances:
             raise IAToolkitException(IAToolkitException.ErrorType.EXTERNAL_SOURCE_ERROR,
-                               f"Empresa no configurada: {company_name}")
+                               f"company not configured: {company_name}")
 
         company_instance = self.company_instances[company_name]
         try:
@@ -197,7 +201,7 @@ class Dispatcher:
         except Exception as e:
             logging.exception(e)
             raise IAToolkitException(IAToolkitException.ErrorType.EXTERNAL_SOURCE_ERROR,
-                               f"Error en get_metadata_from_filename de {company_name}: {str(e)}") from e
+                               f"Error in get_metadata_from_filename: {company_name}: {str(e)}") from e
 
     def get_company_instance(self, company_name: str):
         """Returns the instance for a given company name."""
@@ -207,12 +211,11 @@ class Dispatcher:
 
 # iatoolkit system prompts
 _SYSTEM_PROMPT = [
-    {'name': 'query_main', 'description':'main prompt de iatoolkit'},
-    {'name': 'format_styles', 'description':'formatos y estilos de salida'},
-    {'name': 'sql_rules', 'description':'instrucciones para generar sql'}
+    {'name': 'query_main', 'description':'iatoolkit main prompt'},
+    {'name': 'format_styles', 'description':'output format styles'},
+    {'name': 'sql_rules', 'description':'instructions  for SQL queries'}
 ]
 
-
 # iatoolkit  function calls
 _FUNCTION_LIST = [
     {

iatoolkit/services/document_service.py

@@ -11,10 +11,13 @@ import os
 import pytesseract
 from injector import inject
 from iatoolkit.common.exceptions import IAToolkitException
+from iatoolkit.services.i18n_service import I18nService
 
 class DocumentService:
     @inject
-    def __init__(self):
+    def __init__(self, i18n_service: I18nService):
+        self.i18n_service = i18n_service
+
         # max number of pages to load
         self.max_doc_pages = int(os.getenv("MAX_DOC_PAGES", "200"))
 
@@ -29,7 +32,7 @@ class DocumentService:
                         file_content = file_content.decode('utf-8')
                     except UnicodeDecodeError:
                         raise IAToolkitException(IAToolkitException.ErrorType.FILE_FORMAT_ERROR,
-                                           "El archivo no es texto o la codificación no es UTF-8")
+                                           self.i18n_service.t('errors.services.no_text_file'))
 
                 return file_content
             elif filename.lower().endswith('.pdf'):

iatoolkit/services/excel_service.py

@@ -8,6 +8,7 @@ import pandas as pd
 from uuid import uuid4
 from pathlib import Path
 from iatoolkit.common.exceptions import IAToolkitException
+from iatoolkit.services.i18n_service import I18nService
 from injector import inject
 import os
 import logging
@@ -18,8 +19,11 @@ EXCEL_MIME = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
 
 class ExcelService:
     @inject
-    def __init__(self,util: Utility):
+    def __init__(self,
+                 util: Utility,
+                 i18n_service: I18nService):
         self.util = util
+        self.i18n_service = i18n_service
 
     def excel_generator(self, **kwargs) -> str:
         """
@@ -42,11 +46,11 @@ class ExcelService:
             # get the parameters
             fname = kwargs.get('filename')
             if not fname:
-                return 'falta el nombre del archivo de salida'
+                return self.i18n_service.t('errors.services.no_output_file')
 
             data = kwargs.get('data')
             if not data or not isinstance(data, list):
-                return 'faltan los datos  o no es una lista de diccionarios'
+                return self.i18n_service.t('errors.services.no_data_for_excel')
 
             sheet_name = kwargs.get('sheet_name', 'hoja 1')
 
@@ -58,7 +62,7 @@ class ExcelService:
 
             # 4. check that download directory is configured
             if 'IATOOLKIT_DOWNLOAD_DIR' not in current_app.config:
-                return 'no esta configurado el directorio temporal para guardar excels'
+                return self.i18n_service.t('errors.services.no_download_directory')
 
             download_dir = current_app.config['IATOOLKIT_DOWNLOAD_DIR']
             filepath = Path(download_dir) / token
@@ -77,28 +81,28 @@ class ExcelService:
 
         except Exception as e:
             raise IAToolkitException(IAToolkitException.ErrorType.CALL_ERROR,
-                               'error generating excel file') from e
+                               self.i18n_service.t('errors.services.cannot_create_excel')) from e
 
     def validate_file_access(self, filename):
         try:
             if not filename:
-                return jsonify({"error": "Nombre de archivo inválido"})
+                return jsonify({"error": self.i18n_service.t('errors.services.invalid_filename')})
             # Prevent path traversal attacks
             if '..' in filename or filename.startswith('/') or '\\' in filename:
-                return jsonify({"error": "Nombre de archivo inválido"})
+                return jsonify({"error": self.i18n_service.t('errors.services.invalid_filename')})
 
             temp_dir = os.path.join(current_app.root_path, 'static', 'temp')
             file_path = os.path.join(temp_dir, filename)
 
             if not os.path.exists(file_path):
-                return jsonify({"error": "Archivo no encontrado"})
+                return jsonify({"error": self.i18n_service.t('errors.services.file_not_exist')})
 
             if not os.path.isfile(file_path):
-                return jsonify({"error": "La ruta no corresponde a un archivo"})
+                return jsonify({"error": self.i18n_service.t('errors.services.path_is_not_a_file')})
 
             return None
 
         except Exception as e:
-            error_msg = f"Error validando acceso al archivo {filename}: {str(e)}"
+            error_msg = f"File validation error {filename}: {str(e)}"
             logging.error(error_msg)
-            return jsonify({"error": "Error validando archivo"})
+            return jsonify({"error": self.i18n_service.t('errors.services.file_validation_error')})

iatoolkit/services/file_processor_service.py

@@ -52,27 +52,19 @@ class FileProcessor:
                  logger: Optional[logging.Logger] = None):
         self.connector = connector
         self.config = config
-        self.logger = logger or self._setup_logger()
         self.processed_files = 0
 
-    def _setup_logger(self):
-        logging.basicConfig(
-            filename=self.config.log_file,
-            level=logging.INFO,
-            format='%(asctime)s - %(levelname)s - %(message)s'
-        )
-        return logging.getLogger(__name__)
 
     def process_files(self):
         # Fetches files from the connector, filters them, and processes them.
         try:
             files = self.connector.list_files()
         except Exception as e:
-            self.logger.error(f"Error fetching files: {e}")
+            logging.error(f"Error fetching files: {e}")
             return False
 
         if self.config.echo:
-            print(f'cargando un total de {len(files)} archivos')
+            print(f'loading {len(files)} files')
 
         for file_info in files:
             file_path = file_info['path']
@@ -95,10 +87,10 @@ class FileProcessor:
                                      context=self.config.context)
                 self.processed_files += 1
 
-                self.logger.info(f"Successfully processed file: {file_path}")
+                logging.info(f"Successfully processed file: {file_path}")
 
             except Exception as e:
-                self.logger.error(f"Error processing {file_path}: {e}")
+                logging.error(f"Error processing {file_path}: {e}")
                 if not self.config.continue_on_error:
                     raise e
 

iatoolkit/services/history_service.py

@@ -6,32 +6,33 @@
 from injector import inject
 from iatoolkit.repositories.llm_query_repo import LLMQueryRepo
 from iatoolkit.repositories.profile_repo import ProfileRepo
+from iatoolkit.services.i18n_service import I18nService
+
 
 
 class HistoryService:
     @inject
     def __init__(self, llm_query_repo: LLMQueryRepo,
-                 profile_repo: ProfileRepo):
+                 profile_repo: ProfileRepo,
+                 i18n_service: I18nService):
         self.llm_query_repo = llm_query_repo
         self.profile_repo = profile_repo
+        self.i18n_service = i18n_service
 
     def get_history(self,
                      company_short_name: str,
                      user_identifier: str) -> dict:
         try:
-            # validate company
             company = self.profile_repo.get_company_by_short_name(company_short_name)
             if not company:
-                return {'error': f'No existe la empresa: {company_short_name}'}
+                return {"error": self.i18n_service.t('errors.company_not_found', company_short_name=company_short_name)}
 
             history = self.llm_query_repo.get_history(company, user_identifier)
-
             if not history:
-                return {'message': 'Historial vacio actualmente', 'history': []}
+                return {'message': 'empty history', 'history': []}
 
             history_list = [query.to_dict() for query in history]
-
-            return {'message': 'Historial obtenido correctamente', 'history': history_list}
+            return {'message': 'history loaded ok', 'history': history_list}
 
         except Exception as e:
             return {'error': str(e)}

iatoolkit/services/i18n_service.py

@@ -0,0 +1,104 @@
+# iatoolkit/services/i18n_service.py
+import os
+import logging
+from injector import inject, singleton
+from iatoolkit.common.util import Utility
+from iatoolkit.services.language_service import LanguageService
+
+@singleton
+class I18nService:
+    """
+    Servicio centralizado para manejar la internacionalización (i18n).
+    Carga todas las traducciones desde archivos YAML en memoria al iniciar.
+    """
+    FALLBACK_LANGUAGE = 'es'
+
+    @inject
+    def __init__(self, util: Utility, language_service: LanguageService):
+        self.util = util
+        self.language_service = language_service
+
+        self.translations = {}
+        self._load_translations()
+
+    def _load_translations(self):
+        """
+        Carga todos los archivos .yaml del directorio 'locales' en memoria.
+        """
+        locales_dir = os.path.join(os.path.dirname(__file__), '..', 'locales')
+        if not os.path.exists(locales_dir):
+            logging.error("Directory 'locales' not found.")
+            return
+
+        for filename in os.listdir(locales_dir):
+            if filename.endswith('.yaml'):
+                lang_code = filename.split('.')[0]
+                filepath = os.path.join(locales_dir, filename)
+                try:
+                    self.translations[lang_code] = self.util.load_schema_from_yaml(filepath)
+                except Exception as e:
+                    logging.error(f"Error while loading the translation file {filepath}: {e}")
+
+    def _get_nested_key(self, lang: str, key: str):
+        """
+        Obtiene un valor de un diccionario anidado usando una clave con puntos.
+        """
+        data = self.translations.get(lang, {})
+        keys = key.split('.')
+        for k in keys:
+            if isinstance(data, dict) and k in data:
+                data = data[k]
+            else:
+                return None
+        return data
+
+    def get_translation_block(self, key: str, lang: str = None) -> dict:
+        """
+        Gets a whole dictionary block from the translations.
+        Useful for passing a set of translations to JavaScript.
+        """
+        if lang is None:
+            lang = self.language_service.get_current_language()
+
+        # 1. Try to get the block in the requested language
+        block = self._get_nested_key(lang, key)
+
+        # 2. If not found, try the fallback language
+        if not isinstance(block, dict):
+            block = self._get_nested_key(self.FALLBACK_LANGUAGE, key)
+
+        return block if isinstance(block, dict) else {}
+
+    def t(self, key: str, lang: str = None, **kwargs) -> str:
+        """
+        Gets the translation for a given key.
+        If 'lang' is provided, it's used. Otherwise, it's determined automatically.
+        """
+        # If no specific language is requested, determine it from the current context.
+        if lang is None:
+            lang = self.language_service.get_current_language()
+
+        # 1. Attempt to get the translation in the requested language
+        message = self._get_nested_key(lang, key)
+
+        # 2. If not found, try the fallback language
+        if message is None and lang != self.FALLBACK_LANGUAGE:
+            logging.warning(
+                f"Translation key '{key}' not found for language '{lang}'. Attempting fallback to '{self.FALLBACK_LANGUAGE}'.")
+            message = self._get_nested_key(self.FALLBACK_LANGUAGE, key)
+
+        # 3. If still not found, return the key itself as a last resort
+        if message is None:
+            logging.error(
+                f"Translation key '{key}' not found, even in fallback '{self.FALLBACK_LANGUAGE}'.")
+            return key
+
+        # 4. If variables are provided, format the message
+        if kwargs:
+            try:
+                return message.format(**kwargs)
+            except KeyError as e:
+                logging.error(f"Error formatting key '{key}': missing variable {e} in arguments.")
+                return message
+
+        return message

iatoolkit/services/jwt_service.py

@@ -20,8 +20,8 @@ class JWTService:
             self.secret_key = app.config['JWT_SECRET_KEY']
             self.algorithm = app.config['JWT_ALGORITHM']
         except KeyError as e:
-            logging.error(f"Configuración JWT faltante en app.config: {e}. JWTService no funcionará correctamente.")
-            raise RuntimeError(f"Configuración JWT esencial faltante: {e}")
+            logging.error(f"missing JWT configuration: {e}.")
+            raise RuntimeError(f"missing JWT configuration variables: {e}")
 
     def generate_chat_jwt(self,
                           company_short_name: str,
@@ -58,25 +58,23 @@ class JWTService:
 
             # Validaciones adicionales
             if payload.get('type') != 'chat_session':
-                logging.warning(f"Validación JWT fallida: tipo incorrecto '{payload.get('type')}'")
+                logging.warning(f"Invalid JWT type '{payload.get('type')}'")
                 return None
 
             # user_identifier debe estar presente
             if not payload.get('user_identifier'):
-                logging.warning(f"Validación JWT fallida: user_identifier ausente o vacío.")
+                logging.warning(f"missing user_identifier in JWT payload.")
                 return None
 
             if not payload.get('company_short_name'):
-                logging.warning(f"Validación JWT fallida: company_short_name ausente.")
+                logging.warning(f"missing company_short_name in JWT payload.")
                 return None
 
-            logging.debug(
-                f"JWT validado exitosamente para company: {payload.get('company_short_name')}, user: {payload.get('external_user_id')}")
             return payload
 
         except jwt.InvalidTokenError as e:
-            logging.warning(f"Validación JWT fallida: token inválido . Error: {e}")
+            logging.warning(f"Invalid JWT token:: {e}")
             return None
         except Exception as e:
-            logging.error(f"Error inesperado durante validación de JWT : {e}")
+            logging.error(f"unexpected error during JWT validation: {e}")
             return None

iatoolkit/services/language_service.py

@@ -0,0 +1,83 @@
+# iatoolkit/services/language_service.py
+
+import logging
+from injector import inject, singleton
+from flask import g, request
+from iatoolkit.repositories.profile_repo import ProfileRepo
+from iatoolkit.services.configuration_service import ConfigurationService
+from iatoolkit.common.session_manager import SessionManager
+
+@singleton
+class LanguageService:
+    """
+    Determines the correct language for the current request
+    based on a defined priority order (session, URL, etc.)
+    and caches it in the Flask 'g' object for the request's lifecycle.
+    """
+
+    FALLBACK_LANGUAGE = 'es'
+
+    @inject
+    def __init__(self,
+                 config_service: ConfigurationService,
+                 profile_repo: ProfileRepo):
+        self.config_service = config_service
+        self.profile_repo = profile_repo
+
+    def _get_company_short_name(self) -> str | None:
+        """
+        Gets the company_short_name from the current request context.
+        This handles different scenarios like web sessions, public URLs, and API calls.
+
+        Priority Order:
+        1. Flask Session (for logged-in web users).
+        2. URL rule variable (for public pages and API endpoints).
+        """
+        # 1. Check session for logged-in users
+        company_short_name = SessionManager.get('company_short_name')
+        if company_short_name:
+            return company_short_name
+
+        # 2. Check URL arguments (e.g., /<company_short_name>/login)
+        # This covers public pages and most API calls.
+        if request.view_args and 'company_short_name' in request.view_args:
+            return request.view_args['company_short_name']
+
+        return None
+
+    def get_current_language(self) -> str:
+        """
+        Determines and caches the language for the current request using a priority order:
+        1. User's preference (from their profile).
+        2. Company's default language.
+        3. System-wide fallback language ('es').
+        """
+        if 'lang' in g:
+            return g.lang
+
+        try:
+            # Priority 1: User's preferred language
+            user_identifier = SessionManager.get('user_identifier')
+            if user_identifier:
+                user = self.profile_repo.get_user_by_email(user_identifier)
+                if user and user.preferred_language:
+                    logging.debug(f"Language determined by user preference: {user.preferred_language}")
+                    g.lang = user.preferred_language
+                    return g.lang
+
+            # Priority 2: Company's default language
+            company_short_name = self._get_company_short_name()
+            if company_short_name:
+                locale = self.config_service.get_configuration(company_short_name, 'locale')
+                if locale:
+                    company_language = locale.split('_')[0]
+                    g.lang = company_language
+                    return g.lang
+        except Exception as e:
+            logging.info(f"Could not determine language, falling back to default. Reason: {e}")
+            pass
+
+        # Priority 3: System-wide fallback
+        logging.info(f"Language determined by system fallback: {self.FALLBACK_LANGUAGE}")
+        g.lang = self.FALLBACK_LANGUAGE
+        return g.lang

iatoolkit/services/load_documents_service.py

@@ -72,7 +72,7 @@ class LoadDocumentsService:
         """
         if not connector_config:
             raise IAToolkitException(IAToolkitException.ErrorType.MISSING_PARAMETER,
-                        f"Falta configurar conector")
+                        f"Missing connector config")
 
         try:
             if not filters:
@@ -123,7 +123,7 @@ class LoadDocumentsService:
 
         if not company:
             raise IAToolkitException(IAToolkitException.ErrorType.MISSING_PARAMETER,
-                        f"Falta configurar empresa")
+                        f"missing company")
 
         # check if file exist in repositories
         if self.doc_repo.get(company_id=company.id,filename=filename):
@@ -182,6 +182,6 @@ class LoadDocumentsService:
             self.doc_repo.session.rollback()
 
             # if something fails, throw exception
-            logging.exception("Error procesando el archivo %s: %s", filename, str(e))
+            logging.exception("Error processing file %s: %s", filename, str(e))
             raise IAToolkitException(IAToolkitException.ErrorType.LOAD_DOCUMENT_ERROR,
-                               f"Error al procesar el archivo {filename}")
+                               f"Error while processing file: {filename}")

iatoolkit/services/mail_service.py

@@ -4,6 +4,7 @@
 # IAToolkit is open source software.
 
 from iatoolkit.infra.mail_app import MailApp
+from iatoolkit.services.i18n_service import I18nService
 from injector import inject
 from pathlib import Path
 from iatoolkit.common.exceptions import IAToolkitException
@@ -13,18 +14,22 @@ TEMP_DIR = Path("static/temp")
 
 class MailService:
     @inject
-    def __init__(self, mail_app: MailApp):
+    def __init__(self,
+                 mail_app: MailApp,
+                 i18n_service: I18nService):
         self.mail_app = mail_app
+        self.i18n_service = i18n_service
+
 
     def _read_token_bytes(self, token: str) -> bytes:
         # Defensa simple contra path traversal
         if not token or "/" in token or "\\" in token or token.startswith("."):
             raise IAToolkitException(IAToolkitException.ErrorType.MAIL_ERROR,
-                               "attachment_token inválido")
+                               "attachment_token invalid")
         path = TEMP_DIR / token
         if not path.is_file():
             raise IAToolkitException(IAToolkitException.ErrorType.MAIL_ERROR,
-                               f"Adjunto no encontrado: {token}")
+                               f"attach file not found: {token}")
         return path.read_bytes()
 
     def send_mail(self, **kwargs):
@@ -59,4 +64,4 @@ class MailService:
             body=body,
             attachments=norm_attachments)
 
-        return 'mail enviado'
+        return self.i18n_service.t('services.mail_sent')