iatoolkit 0.11.0__py3-none-any.whl → 0.71.2__py3-none-any.whl

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,20 +20,22 @@ 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_id: int,
                           company_short_name: str,
-                          external_user_id: str,
+                          user_identifier: str,
                           expires_delta_seconds: int) -> Optional[str]:
         # generate a JWT for a chat session
         try:
+            if not company_short_name or not user_identifier:
+                logging.error(f"Missing token ID: {company_short_name}/{user_identifier}")
+                return None
+
             payload = {
-                'company_id': company_id,
                 'company_short_name': company_short_name,
-                'external_user_id': external_user_id,
+                'user_identifier': user_identifier,
                 'exp': time.time() + expires_delta_seconds,
                 'iat': time.time(),
                 'type': 'chat_session'  # Identificador del tipo de token
@@ -41,10 +43,10 @@ class JWTService:
             token = jwt.encode(payload, self.secret_key, algorithm=self.algorithm)
             return token
         except Exception as e:
-            logging.error(f"Error al generar JWT para company {company_id}, user {external_user_id}: {e}")
+            logging.error(f"Error al generar JWT para {company_short_name}/{user_identifier}: {e}")
             return None
 
-    def validate_chat_jwt(self, token: str, expected_company_short_name: str) -> Optional[Dict[str, Any]]:
+    def validate_chat_jwt(self, token: str) -> Optional[Dict[str, Any]]:
         """
         Valida un JWT de sesión de chat.
         Retorna el payload decodificado si es válido y coincide con la empresa, o None.
@@ -56,36 +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
 
-            if payload.get('company_short_name') != expected_company_short_name:
-                logging.warning(
-                    f"Validación JWT fallida: company_short_name no coincide. "
-                    f"Esperado: {expected_company_short_name}, Obtenido: {payload.get('company_short_name')}"
-                )
+            # user_identifier debe estar presente
+            if not payload.get('user_identifier'):
+                logging.warning(f"missing user_identifier in JWT payload.")
                 return None
 
-            # external_user_id debe estar presente
-            if 'external_user_id' not in payload or not payload['external_user_id']:
-                logging.warning(f"Validación JWT fallida: external_user_id ausente o vacío.")
+            if not payload.get('company_short_name'):
+                logging.warning(f"missing company_short_name in JWT payload.")
                 return None
 
-            # company_id debe estar presente
-            if 'company_id' not in payload or not isinstance(payload['company_id'], int):
-                logging.warning(f"Validación JWT fallida: company_id ausente o tipo incorrecto.")
-                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.ExpiredSignatureError:
-            logging.info(f"Validación JWT fallida: token expirado para {expected_company_short_name}")
-            return None
         except jwt.InvalidTokenError as e:
-            logging.warning(f"Validación JWT fallida: token inválido para {expected_company_short_name}. 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 para {expected_company_short_name}: {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

@@ -1,50 +1,41 @@
 # Copyright (c) 2024 Fernando Libedinsky
 # Product: IAToolkit
-#
-# IAToolkit is open source software.
 
 from iatoolkit.repositories.vs_repo import VSRepo
 from iatoolkit.repositories.document_repo import DocumentRepo
-from iatoolkit.repositories.profile_repo import ProfileRepo
-from iatoolkit.repositories.llm_query_repo import LLMQueryRepo
-
 from iatoolkit.repositories.models import Document, VSDoc, Company
 from iatoolkit.services.document_service import DocumentService
+from iatoolkit.services.configuration_service import ConfigurationService
 from langchain.text_splitter import RecursiveCharacterTextSplitter
 from iatoolkit.infra.connectors.file_connector_factory import FileConnectorFactory
 from iatoolkit.services.file_processor_service import FileProcessorConfig, FileProcessor
-from iatoolkit.services.dispatcher_service import Dispatcher
 from iatoolkit.common.exceptions import IAToolkitException
 import logging
 import base64
-from injector import inject
-from typing import Dict
+from injector import inject, singleton
+import os
 
 
+@singleton
 class LoadDocumentsService:
     """
     Orchestrates the process of loading, processing, and storing documents
-    from various sources for different companies.
+    from various sources defined in the company's configuration.
     """
     @inject
     def __init__(self,
+                 config_service: ConfigurationService,
                  file_connector_factory: FileConnectorFactory,
                  doc_service: DocumentService,
                  doc_repo: DocumentRepo,
                  vector_store: VSRepo,
-                 profile_repo: ProfileRepo,
-                 dispatcher: Dispatcher,
-                 llm_query_repo: LLMQueryRepo
                  ):
+        self.config_service = config_service
         self.doc_service = doc_service
         self.doc_repo = doc_repo
-        self.profile_repo = profile_repo
-        self.llm_query_repo = llm_query_repo
         self.vector_store = vector_store
         self.file_connector_factory = file_connector_factory
-        self.dispatcher = dispatcher
 
-        # lower warnings
         logging.getLogger().setLevel(logging.ERROR)
 
         self.splitter = RecursiveCharacterTextSplitter(
@@ -53,135 +44,131 @@ class LoadDocumentsService:
             separators=["\n\n", "\n", "."]
         )
 
-    def load_company_files(self,
-                         company: Company,
-                         connector_config: Dict,
-                         predefined_metadata: Dict = None,
-                         filters: Dict = None):
+    def load_sources(self,
+                     company: Company,
+                     sources_to_load: list[str] = None,
+                     filters: dict = None) -> int:
         """
-        Loads all the company files from a connector
+        Loads documents from one or more configured sources for a company.
 
         Args:
             company (Company): The company to load files for.
-            connector_config (Dict): The configuration for the file connector.
-            predefined_metadata (Dict, optional): Metadata to be added to all documents from this source.
-            filters (Dict, optional): Filters to apply to the files.
+            sources_to_load (list[str], optional): A list of specific source names to load.
+                                                  If None, all configured sources will be loaded.
+            filters (dict, optional): Filters to apply when listing files (e.g., file extension).
 
         Returns:
-            int: The number of processed files.
+            int: The total number of processed files.
         """
-        if not connector_config:
-            raise IAToolkitException(IAToolkitException.ErrorType.MISSING_PARAMETER,
-                        f"Falta configurar conector")
+        knowledge_base_config = self.config_service.get_configuration(company.short_name, 'knowledge_base')
+        if not knowledge_base_config:
+            raise IAToolkitException(IAToolkitException.ErrorType.CONFIG_ERROR,
+                                     f"Missing 'knowledge_base' configuration for company '{company.short_name}'.")
+
+        if not sources_to_load:
+            raise IAToolkitException(IAToolkitException.ErrorType.PARAM_NOT_FILLED,
+                                f"Missing sources to load for company '{company.short_name}'.")
+
+        base_connector_config = self._get_base_connector_config(knowledge_base_config)
+        all_sources = knowledge_base_config.get('document_sources', {})
+
+        total_processed_files = 0
+        for source_name in sources_to_load:
+            source_config = all_sources.get(source_name)
+            if not source_config:
+                logging.warning(f"Source '{source_name}' not found in configuration for company '{company.short_name}'. Skipping.")
+                continue
+
+            try:
+                logging.info(f"Processing source '{source_name}' for company '{company.short_name}'...")
+
+                # Combine the base connector configuration with the specific path from the source.
+                full_connector_config = base_connector_config.copy()
+                full_connector_config['path'] = source_config.get('path')
+
+                # Prepare the context for the callback function.
+                context = {
+                    'company': company,
+                    'metadata': source_config.get('metadata', {})
+                }
+
+                processor_config = FileProcessorConfig(
+                    callback=self._file_processing_callback,
+                    context=context,
+                    filters=filters or {"filename_contains": ".pdf"},
+                    continue_on_error=True,
+                    echo=True
+                )
 
-        try:
-            if not filters:
-                filters = {"filename_contains": ".pdf"}
-
-            # Pasar metadata predefinida como parte del contexto al procesador
-            # para que esté disponible en la función load_file_callback
-            context = {
-                'company': company,
-                'metadata': {}
-            }
-
-            if predefined_metadata:
-                context['metadata'] = predefined_metadata
-
-            # config the processor
-            processor_config = FileProcessorConfig(
-                callback=self.load_file_callback,
-                context=context,
-                filters=filters,
-                continue_on_error=True,
-                echo=True
-            )
+                connector = self.file_connector_factory.create(full_connector_config)
+                processor = FileProcessor(connector, processor_config)
+                processor.process_files()
 
-            connector = self.file_connector_factory.create(connector_config)
-            processor = FileProcessor(connector, processor_config)
+                total_processed_files += processor.processed_files
+                logging.info(f"Finished processing source '{source_name}'. Processed {processor.processed_files} files.")
 
-            # process the files
-            processor.process_files()
+            except Exception as e:
+                logging.exception(f"Failed to process source '{source_name}' for company '{company.short_name}': {e}")
 
-            return processor.processed_files
-        except Exception as e:
-            logging.exception("Loading files error: %s", str(e))
-            return {"error": str(e)}
+        return total_processed_files
 
-    def load_file_callback(self, company: Company, filename: str, content: bytes, context: dict = {}):
-        """
-        Processes a single file: extracts text, generates metadata, and saves it
-        to the relational database and the vector store.
-        This method is intended to be used as the 'action' for FileProcessor.
+    def _get_base_connector_config(self, knowledge_base_config: dict) -> dict:
+        """Determines and returns the appropriate base connector configuration (dev vs prod)."""
+        connectors = knowledge_base_config.get('connectors', {})
+        env = os.getenv('FLASK_ENV', 'dev')
 
-        Args:
-            company (Company): The company associated with the file.
-            filename (str): The name of the file.
-            content (bytes): The binary content of the file.
-            context (dict, optional): A context dictionary, may contain predefined metadata.
-        """
+        if env == 'dev':
+            return connectors.get('development', {'type': 'local'})
+        else:
+            prod_config = connectors.get('production')
+            if not prod_config:
+                raise IAToolkitException(IAToolkitException.ErrorType.CONFIG_ERROR,
+                                         "Production connector configuration is missing.")
+            # The S3 connector itself is responsible for reading AWS environment variables.
+            # No need to pass credentials explicitly here.
+            return prod_config
 
+    def _file_processing_callback(self, company: Company, filename: str, content: bytes, context: dict = None):
+        """
+        Callback method to process a single file. It extracts text, merges metadata,
+        and saves the document to both relational and vector stores.
+        """
         if not company:
-            raise IAToolkitException(IAToolkitException.ErrorType.MISSING_PARAMETER,
-                        f"Falta configurar empresa")
+            raise IAToolkitException(IAToolkitException.ErrorType.MISSING_PARAMETER, "Missing company object in callback.")
 
-        # check if file exist in repositories
-        if self.doc_repo.get(company_id=company.id,filename=filename):
+        if self.doc_repo.get(company_id=company.id, filename=filename):
+            logging.debug(f"File '{filename}' already exists for company '{company.id}'. Skipping.")
             return
 
         try:
-            # extract text from the document
             document_content = self.doc_service.file_to_txt(filename, content)
-            content_base64 = base64.b64encode(content).decode('utf-8')
 
-            # generate metada based on the filename structure
-            dynamic_metadata = self.dispatcher.get_metadata_from_filename(company_name=company.short_name, filename=filename)
+            # Get predefined metadata from the context passed by the processor.
+            predefined_metadata = context.get('metadata', {}) if context else {}
 
-            # Obtener metadatos del contexto si existen
-            context_metadata = context.get('metadata', {}).copy() if context else {}
-
-            # Fusionar los metadatos. El orden de prioridad es:
-            # 1. dynamic_metadata (tiene mayor prioridad)
-            # 2. context_metadata (del parámetro context)
-            # Los valores en dynamic_metadata tendrán precedencia sobre los de context_metadata
-            final_meta = {**context_metadata, **dynamic_metadata}
-
-            # save the file in the document repositories
+            # Save the document to the relational database.
+            session = self.doc_repo.session
             new_document = Document(
                 company_id=company.id,
                 filename=filename,
                 content=document_content,
-                content_b64=content_base64,
-                meta=final_meta
+                content_b64=base64.b64encode(content).decode('utf-8'),
+                meta=predefined_metadata
             )
-
-            # insert the document into the Database (without commit)
-            session = self.doc_repo.session
             session.add(new_document)
-            session.flush()     # get the ID without commit
-
-            # split the content, and create the chunk list
-            splitted_content = self.splitter.split_text(document_content)
-            chunk_list = [
-                VSDoc(
-                    company_id=company.id,
-                    document_id=new_document.id,
-                    text=text
-                )
-                for text in splitted_content
-            ]
+            session.flush()  # Flush to get the new_document.id without committing.
 
-            # save to vector store
-            self.vector_store.add_document(chunk_list)
+            # Split into chunks and prepare for vector store.
+            chunks = self.splitter.split_text(document_content)
+            vs_docs = [VSDoc(company_id=company.id, document_id=new_document.id, text=text) for text in chunks]
 
-            # confirm the transaction
-            session.commit()
+            # Add document chunks to the vector store.
+            self.vector_store.add_document(company.short_name, vs_docs)
 
+            session.commit()
             return new_document
         except Exception as e:
             self.doc_repo.session.rollback()
-
-            # if something fails, throw exception
-            logging.exception("Error procesando el archivo %s: %s", filename, str(e))
+            logging.exception(f"Error processing file '{filename}': {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')