iatoolkit 0.4.2__py3-none-any.whl → 0.66.2__py3-none-any.whl

{services → iatoolkit/services}/dispatcher_service.py

@@ -1,19 +1,17 @@
 # Copyright (c) 2024 Fernando Libedinsky
-# Producto: IAToolkit
-# Todos los derechos reservados.
-# En trámite de registro en el Registro de Propiedad Intelectual de Chile.
-
-from common.exceptions import IAToolkitException
-from services.prompt_manager_service import PromptService
-from services.api_service import ApiService
-from repositories.llm_query_repo import LLMQueryRepo
-from repositories.models import Company, Function
-from services.excel_service import ExcelService
-from services.mail_service import MailService
-from common.session_manager import SessionManager
-from common.util import Utility
+# Product: IAToolkit
+#
+# IAToolkit is open source software.
+
+from iatoolkit.common.exceptions import IAToolkitException
+from iatoolkit.services.prompt_manager_service import PromptService
+from iatoolkit.repositories.llm_query_repo import LLMQueryRepo
+
+from iatoolkit.repositories.models import Company, Function
+from iatoolkit.services.excel_service import ExcelService
+from iatoolkit.services.mail_service import MailService
+from iatoolkit.common.util import Utility
 from injector import inject
-from typing import Dict
 import logging
 import os
 
@@ -24,12 +22,10 @@ class Dispatcher:
                  prompt_service: PromptService,
                  llmquery_repo: LLMQueryRepo,
                  util: Utility,
-                 api_service: ApiService,
                  excel_service: ExcelService,
                  mail_service: MailService):
         self.prompt_service = prompt_service
         self.llmquery_repo = llmquery_repo
-        self.api_service = api_service
         self.util = util
         self.excel_service = excel_service
         self.mail_service = mail_service
@@ -39,16 +35,9 @@ class Dispatcher:
         self._company_registry = None
         self._company_instances = None
 
-        # load into the dispatcher the configured companies
-        self.initialize_companies()
-
-        # run the statrtup logic for all companies
-        self.start_execution()
-
         self.tool_handlers = {
             "iat_generate_excel": self.excel_service.excel_generator,
             "iat_send_email": self.mail_service.send_mail,
-            "iat_api_call": self.api_service.call_api
         }
 
     @property
@@ -66,30 +55,18 @@ class Dispatcher:
             self._company_instances = self.company_registry.get_all_company_instances()
         return self._company_instances
 
-    def initialize_companies(self):
-        from iatoolkit import current_iatoolkit
-        """
-        Initializes and instantiates all registered company classes.
-        This method should be called *after* the main injector is fully configured
-        and the company registry is populated.
-        """
-        if self.company_registry.get_all_company_instances():  # Check if already instantiated
-            return
-
-        # ✅ NOW it is safe to get the injector and instantiate companies.
-        injector = current_iatoolkit().get_injector()
-        self.company_registry.instantiate_companies(injector)
-
-
     def start_execution(self):
+        # initialize the system functions and prompts
+        self.setup_iatoolkit_system()
+
         """Runs the startup logic for all registered companies."""
-        for company_name, company_instance in self.company_instances.items():
-            logging.info(f'Starting execution for company: {company_name}')
-            company_instance.start_execution()
+        for company in self.company_instances.values():
+            company.register_company()
+            company.start_execution()
 
         return True
 
-    def setup_all_companies(self):
+    def setup_iatoolkit_system(self):
         # create system functions
         for function in self.system_functions:
             self.llmquery_repo.create_or_update_function(
@@ -102,16 +79,16 @@ class Dispatcher:
                 )
             )
 
-            # create the system prompts
-            i = 1
-            for prompt in self.system_prompts:
-                self.prompt_service.create_prompt(
-                    prompt_name=prompt['name'],
-                    description=prompt['description'],
-                    order=1,
-                    is_system_prompt=True,
-                )
-                i += 1
+        # create the system prompts
+        i = 1
+        for prompt in self.system_prompts:
+            self.prompt_service.create_prompt(
+                prompt_name=prompt['name'],
+                description=prompt['description'],
+                order=1,
+                is_system_prompt=True,
+            )
+            i += 1
 
         # register in the database  every company class
         for company in self.company_instances.values():
@@ -193,51 +170,21 @@ class Dispatcher:
             tools.append(ai_tool)
         return tools
 
-    def get_user_info(self, company_name: str, user_identifier: str, is_local_user: bool) -> dict:
+    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}")
 
-        raw_user_data = {}
-        if is_local_user:
-            # source 1: local user login into IAToolkit
-            raw_user_data = SessionManager.get('user', {})
-        else:
-            # source 2: external company user
-            company_instance = self.company_instances[company_name]
-            try:
-                raw_user_data = company_instance.get_user_info(user_identifier)
-            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
-
-        # always normalize the data for consistent structure
-        return self._normalize_user_data(raw_user_data, is_local_user)
-
-    def _normalize_user_data(self, raw_data: dict, is_local: bool) -> dict:
-        """
-        Asegura que los datos del usuario siempre tengan una estructura consistente.
-        """
-        # Valores por defecto para un perfil robusto
-        normalized_user = {
-            "id": raw_data.get("id", 0),
-            "user_email": raw_data.get("email", ""),
-            "user_fullname": raw_data.get("user_fullname", ""),
-            "super_user": raw_data.get("super_user", False),
-            "company_id": raw_data.get("company_id", 0),
-            "company_name": raw_data.get("company", ""),
-            "company_short_name": raw_data.get("company_short_name", ""),
-            "is_local": is_local,
-            "extras": raw_data.get("extras", {})
-        }
-
-        # get the extras from the raw data, if any
-        extras = raw_data.get("extras", {})
-        if isinstance(extras, dict):
-            normalized_user.update(extras)
+        # source 2: external company user
+        company_instance = self.company_instances[company_name]
+        try:
+            external_user_profile = company_instance.get_user_info(user_identifier)
+        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
 
-        return normalized_user
+        return external_user_profile
 
     def get_metadata_from_filename(self, company_name: str, filename: str) -> dict:
         if company_name not in self.company_instances:
@@ -256,13 +203,6 @@ class Dispatcher:
         """Returns the instance for a given company name."""
         return self.company_instances.get(company_name)
 
-    def get_registered_companies(self) -> dict:
-        """Gets all registered companies (for debugging/admin purposes)"""
-        return {
-            "registered_classes": list(self.company_registry.get_registered_companies().keys()),
-            "instantiated": list(self.company_instances.keys()),
-            "count": len(self.company_instances)
-        }
 
 
 # iatoolkit system prompts

{services → iatoolkit/services}/document_service.py

@@ -1,7 +1,7 @@
 # Copyright (c) 2024 Fernando Libedinsky
-# Producto: IAToolkit
-# Todos los derechos reservados.
-# En trámite de registro en el Registro de Propiedad Intelectual de Chile.
+# Product: IAToolkit
+#
+# IAToolkit is open source software.
 
 from docx import Document
 import fitz  # PyMuPDF
@@ -10,7 +10,7 @@ import io
 import os
 import pytesseract
 from injector import inject
-from common.exceptions import IAToolkitException
+from iatoolkit.common.exceptions import IAToolkitException
 
 class DocumentService:
     @inject
@@ -22,7 +22,7 @@ class DocumentService:
         try:
             if filename.lower().endswith('.docx'):
                 return self.read_docx(file_content)
-            elif filename.lower().endswith('.txt'):
+            elif filename.lower().endswith('.txt') or filename.lower().endswith('.md'):
                 if isinstance(file_content, bytes):
                     try:
                         # decode using UTF-8

{services → iatoolkit/services}/excel_service.py

@@ -1,13 +1,13 @@
 # Copyright (c) 2024 Fernando Libedinsky
-# Producto: IAToolkit
-# Todos los derechos reservados.
-# En trámite de registro en el Registro de Propiedad Intelectual de Chile.
+# Product: IAToolkit
+#
+# IAToolkit is open source software.
 
-from common.util import Utility
+from iatoolkit.common.util import Utility
 import pandas as pd
 from uuid import uuid4
 from pathlib import Path
-from common.exceptions import IAToolkitException
+from iatoolkit.common.exceptions import IAToolkitException
 from injector import inject
 import os
 import logging
@@ -23,21 +23,21 @@ class ExcelService:
 
     def excel_generator(self, **kwargs) -> str:
         """
-                Genera un Excel a partir de una lista de diccionarios.
-
-                Parámetros esperados en kwargs:
-                  - filename: str (nombre lógico a mostrar, ej. "reporte_clientes.xlsx") [obligatorio]
-                  - data: list[dict] (filas del excel) [obligatorio]
-                  - sheet_name: str = "hoja 1"
-
-                Retorna:
-                     {
-                        "filename": "reporte.xlsx",
-                        "attachment_token": "8b7f8a66-...-c1c3.xlsx",
-                        "content_type": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
-                        "download_link": "/download/8b7f8a66-...-c1c3.xlsx"
-                        }
-                """
+        Genera un Excel a partir de una lista de diccionarios.
+
+        Parámetros esperados en kwargs:
+          - filename: str (nombre lógico a mostrar, ej. "reporte_clientes.xlsx") [obligatorio]
+          - data: list[dict] (filas del excel) [obligatorio]
+          - sheet_name: str = "hoja 1"
+
+        Retorna:
+             {
+                "filename": "reporte.xlsx",
+                "attachment_token": "8b7f8a66-...-c1c3.xlsx",
+                "content_type": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+                "download_link": "/download/8b7f8a66-...-c1c3.xlsx"
+                }
+        """
         try:
             # get the parameters
             fname = kwargs.get('filename')
@@ -55,7 +55,13 @@ class ExcelService:
 
             # 3. create temporary name
             token = f"{uuid4()}.xlsx"
-            filepath = Path("static/temp") / token
+
+            # 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'
+
+            download_dir = current_app.config['IATOOLKIT_DOWNLOAD_DIR']
+            filepath = Path(download_dir) / token
             filepath.parent.mkdir(parents=True, exist_ok=True)
 
             # 4. save excel file in temporary directory

{services → iatoolkit/services}/file_processor_service.py

@@ -1,13 +1,13 @@
 # Copyright (c) 2024 Fernando Libedinsky
-# Producto: IAToolkit
-# Todos los derechos reservados.
-# En trámite de registro en el Registro de Propiedad Intelectual de Chile.
+# Product: IAToolkit
+#
+# IAToolkit is open source software.
 
-from infra.connectors.file_connector import FileConnector
+from iatoolkit.infra.connectors.file_connector import FileConnector
 import logging
 import os
 from typing import Optional, Callable, Dict
-from repositories.models import Company
+from iatoolkit.repositories.models import Company
 
 
 class FileProcessorConfig:

iatoolkit/services/help_content_service.py

@@ -0,0 +1,30 @@
+# Copyright (c) 2024 Fernando Libedinsky
+# Product: IAToolkit
+#
+# IAToolkit is open source software.
+
+from iatoolkit.common.util import Utility
+from iatoolkit.common.exceptions import IAToolkitException
+import os
+from injector import inject
+import logging
+
+
+class HelpContentService:
+    @inject
+    def __init__(self, util: Utility):
+        self.util = util
+
+    def get_content(self, company_short_name: str | None) -> dict:
+        filepath = f'companies/{company_short_name}/help_content.yaml'
+        if not os.path.exists(filepath):
+            return {}
+
+        # read the file
+        try:
+            help_content = self.util.load_schema_from_yaml(filepath)
+            return help_content
+        except Exception as e:
+            logging.exception(e)
+            raise IAToolkitException(IAToolkitException.ErrorType.CONFIG_ERROR,
+                            f"Error obteniendo help de {company_short_name}: {str(e)}") from e

{services → iatoolkit/services}/history_service.py

@@ -1,32 +1,24 @@
 # Copyright (c) 2024 Fernando Libedinsky
-# Producto: IAToolkit
-# Todos los derechos reservados.
-# En trámite de registro en el Registro de Propiedad Intelectual de Chile.
+# Product: IAToolkit
+#
+# IAToolkit is open source software.
 
 from injector import inject
-from repositories.llm_query_repo import LLMQueryRepo
-from repositories.profile_repo import ProfileRepo
-from common.util import Utility
+from iatoolkit.repositories.llm_query_repo import LLMQueryRepo
+from iatoolkit.repositories.profile_repo import ProfileRepo
 
 
 class HistoryService:
     @inject
     def __init__(self, llm_query_repo: LLMQueryRepo,
-                 profile_repo: ProfileRepo,
-                 util: Utility):
+                 profile_repo: ProfileRepo):
         self.llm_query_repo = llm_query_repo
         self.profile_repo = profile_repo
-        self.util = util
 
     def get_history(self,
                      company_short_name: str,
-                     external_user_id: str = None,
-                     local_user_id: int = 0) -> dict:
+                     user_identifier: str) -> dict:
         try:
-            user_identifier, _ = self.util.resolve_user_identifier(external_user_id, local_user_id)
-            if not user_identifier:
-                return {'error': "No se pudo resolver el identificador del usuario"}
-
             # validate company
             company = self.profile_repo.get_company_by_short_name(company_short_name)
             if not company:
@@ -35,7 +27,7 @@ class HistoryService:
             history = self.llm_query_repo.get_history(company, user_identifier)
 
             if not history:
-                return {'error': 'No se pudo obtener el historial'}
+                return {'message': 'Historial vacio actualmente', 'history': []}
 
             history_list = [query.to_dict() for query in history]
 

iatoolkit/services/i18n_service.py

@@ -0,0 +1,104 @@
+# iatoolkit/services/i18n_service.py
+import os
+import logging
+from injector import inject
+from iatoolkit.common.util import Utility
+from iatoolkit.services.language_service import LanguageService
+
+
+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("El directorio 'locales' no fue encontrado.")
+            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"Fallo al cargar el archivo de traducción {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

{services → iatoolkit/services}/jwt_service.py

@@ -1,7 +1,7 @@
 # Copyright (c) 2024 Fernando Libedinsky
-# Producto: IAToolkit
-# Todos los derechos reservados.
-# En trámite de registro en el Registro de Propiedad Intelectual de Chile.
+# Product: IAToolkit
+#
+# IAToolkit is open source software.
 
 import jwt
 import time
@@ -24,16 +24,18 @@ class JWTService:
             raise RuntimeError(f"Configuración JWT esencial faltante: {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.
@@ -59,33 +61,22 @@ class JWTService:
                 logging.warning(f"Validación JWT fallida: tipo incorrecto '{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"Validación JWT fallida: user_identifier ausente o vacío.")
                 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.")
-                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.")
+            if not payload.get('company_short_name'):
+                logging.warning(f"Validación JWT fallida: company_short_name ausente.")
                 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"Validación JWT fallida: token inválido . Error: {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"Error inesperado durante validación de JWT : {e}")
             return None

iatoolkit/services/language_service.py

@@ -0,0 +1,77 @@
+# iatoolkit/services/language_service.py
+
+import logging
+from injector import inject
+from flask import g, request
+from iatoolkit.repositories.profile_repo import ProfileRepo
+from iatoolkit.common.session_manager import SessionManager
+
+
+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.
+    """
+
+    @inject
+    def __init__(self, profile_repo: ProfileRepo):
+        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
+
+        from iatoolkit.services.i18n_service import I18nService
+        lang = I18nService.FALLBACK_LANGUAGE
+
+        try:
+            company_short_name = self._get_company_short_name()
+            if company_short_name:
+                # Prioridad 1: Preferencia del Usuario
+                user_identifier = SessionManager.get('user_identifier')
+                if user_identifier:
+                    # Usamos el repositorio para obtener el objeto User
+                    user = self.profile_repo.get_user_by_email(
+                        user_identifier)  # Asumiendo que el email es el identificador
+                    if user and user.preferred_language:
+                        g.lang = user.preferred_language
+                        return g.lang
+
+                # Prioridad 2: Idioma por defecto de la Compañía (si no se encontró preferencia de usuario)
+                company = self.profile_repo.get_company_by_short_name(company_short_name)
+                if company and company.default_language:
+                    lang = company.default_language
+        except Exception as e:
+            logging.debug(f"Could not determine language, falling back to default. Reason: {e}")
+            pass
+
+        g.lang = lang
+        return lang