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

iatoolkit/iatoolkit.py

@@ -3,7 +3,7 @@
 #
 # IAToolkit is open source software.
 
-from flask import Flask, url_for
+from flask import Flask, url_for, get_flashed_messages
 from flask_session import Session
 from flask_injector import FlaskInjector
 from flask_bcrypt import Bcrypt
@@ -15,10 +15,11 @@ import logging
 import os
 from typing import Optional, Dict, Any
 from iatoolkit.repositories.database_manager import DatabaseManager
-
-from injector import Binder, singleton, Injector
+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.2"
 
 # global variable for the unique instance of IAToolkit
 _iatoolkit_instance: Optional['IAToolkit'] = None
@@ -51,7 +52,7 @@ class IAToolkit:
         self.app = None
         self.db_manager = None
         self._injector = None
-        self.version = "0.0.0+dev"
+        self.version = IATOOLKIT_VERSION    # default version
 
     @classmethod
     def get_instance(cls) -> 'IAToolkit':
@@ -87,24 +88,23 @@ class IAToolkit:
         # and other integrations, as views are handled manually.
         FlaskInjector(app=self.app, injector=self._injector)
 
-        # Step 6: initialize dispatcher and registered compaies
+        # Step 6: initialize dispatcher and registered companies
         self._init_dispatcher_and_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
         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
         self._setup_download_dir()
 
-        try:
-            self.version = _pkg_version("iatoolkit")
-        except PackageNotFoundError:
-            pass
-
         logging.info(f"🎉 IAToolkit v{self.version} inicializado correctamente")
         self._initialized = True
         return self.app
@@ -113,9 +113,26 @@ class IAToolkit:
         # get a value from the config dict or the environment variable
         return self.config.get(key, os.getenv(key, default))
 
+    def _setup_request_globals(self):
+        """
+        Configures functions to run before each request to set up
+        request-global variables, such as language.
+        """
+        injector = self._injector
+
+        @self.app.before_request
+        def set_request_language():
+            """
+            Determines and caches the language for the current request in g.lang.
+            """
+            from iatoolkit.services.language_service import LanguageService
+            language_service = injector.get(LanguageService)
+            language_service.get_current_language()
+
     def _setup_logging(self):
-        log_level_str = self._get_config_value('FLASK_ENV', 'production')
-        log_level = logging.INFO if log_level_str in ('dev', 'development') else logging.WARNING
+        # Lee el nivel de log desde una variable de entorno, con 'INFO' como valor por defecto.
+        log_level_name = os.getenv('LOG_LEVEL', 'INFO').upper()
+        log_level = getattr(logging, log_level_name, logging.INFO)
 
         logging.basicConfig(
             level=log_level,
@@ -141,14 +158,17 @@ class IAToolkit:
                          static_folder=static_folder,
                          template_folder=template_folder)
 
-        is_https = self._get_config_value('USE_HTTPS', 'false').lower() == 'true'
-        is_dev = self._get_config_value('FLASK_ENV') == 'development'
+        # 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'),
-            'SESSION_COOKIE_SAMESITE': "None" if is_https else "Lax",
-            'SESSION_COOKIE_SECURE': is_https,
+            'SESSION_COOKIE_SAMESITE': "None",
+            'SESSION_COOKIE_SECURE': True,
             'SESSION_PERMANENT': False,
             'SESSION_USE_SIGNER': True,
             'JWT_SECRET_KEY': self._get_config_value('JWT_SECRET_KEY', 'iatoolkit-jwt-secret'),
@@ -156,8 +176,15 @@ class IAToolkit:
             '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)
+
         # Configuración para tokenizers en desarrollo
-        if is_dev:
+        if self._get_config_value('FLASK_ENV') == 'dev':
             os.environ["TOKENIZERS_PARALLELISM"] = "false"
 
     def _setup_database(self):
@@ -172,6 +199,15 @@ class IAToolkit:
         self.db_manager.create_all()
         logging.info("✅ Base de datos configurada correctamente")
 
+        @self.app.teardown_appcontext
+        def remove_session(exception=None):
+            """
+            Flask calls this after each request.
+            It ensures the SQLAlchemy session is properly closed
+            and the DB connection is returned to the pool.
+            """
+            self.db_manager.scoped_session.remove()
+
     def _setup_redis_sessions(self):
         redis_url = self._get_config_value('REDIS_URL')
         if not redis_url:
@@ -202,19 +238,19 @@ class IAToolkit:
 
     def _setup_cors(self):
         """🌐 Configura CORS"""
-        # Origins por defecto para desarrollo
+        from iatoolkit.company_registry import get_company_registry
+
+        # default CORS origin
         default_origins = [
-            "http://localhost:5001",
-            "http://127.0.0.1:5001",
             os.getenv('IATOOLKIT_BASE_URL')
         ]
 
-        # Obtener origins adicionales desde configuración/env
+        # Iterate through the registered company names
         extra_origins = []
-        for i in range(1, 11):  # Soporte para CORS_ORIGIN_1 a CORS_ORIGIN_10
-            origin = self._get_config_value(f'CORS_ORIGIN_{i}')
-            if origin:
-                extra_origins.append(origin)
+        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
 
         all_origins = default_origins + extra_origins
 
@@ -229,7 +265,6 @@ class IAToolkit:
 
         logging.info(f"✅ CORS configurado para: {all_origins}")
 
-
     def _configure_core_dependencies(self, binder: Binder):
         """⚙️ Configures all system dependencies."""
         try:
@@ -241,7 +276,6 @@ class IAToolkit:
             self._bind_repositories(binder)
             self._bind_services(binder)
             self._bind_infrastructure(binder)
-            self._bind_views(binder)
 
             logging.info("✅ Dependencias configuradas correctamente")
 
@@ -256,7 +290,6 @@ class IAToolkit:
         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.vs_repo import VSRepo
         from iatoolkit.repositories.tasks_repo import TaskRepo
 
@@ -279,6 +312,10 @@ class IAToolkit:
         from iatoolkit.services.jwt_service import JWTService
         from iatoolkit.services.dispatcher_service import Dispatcher
         from iatoolkit.services.branding_service import BrandingService
+        from iatoolkit.services.i18n_service import I18nService
+        from iatoolkit.services.language_service import LanguageService
+        from iatoolkit.services.configuration_service import ConfigurationService
+        from iatoolkit.services.embedding_service import EmbeddingService
 
         binder.bind(QueryService, to=QueryService)
         binder.bind(TaskService, to=TaskService)
@@ -292,39 +329,26 @@ class IAToolkit:
         binder.bind(JWTService, to=JWTService)
         binder.bind(Dispatcher, to=Dispatcher)
         binder.bind(BrandingService, to=BrandingService)
-
+        binder.bind(I18nService, to=I18nService)
+        binder.bind(LanguageService, to=LanguageService)
+        binder.bind(ConfigurationService, to=ConfigurationService)
+        binder.bind(EmbeddingService, to=EmbeddingService)
 
     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.common.auth import IAuthentication
+        from iatoolkit.services.auth_service import AuthService
         from iatoolkit.common.util import Utility
 
-
-
-        binder.bind(LLMProxy, to=LLMProxy, scope=singleton)
-        binder.bind(llmClient, to=llmClient, scope=singleton)
+        binder.bind(LLMProxy, to=LLMProxy)
+        binder.bind(llmClient, to=llmClient)
         binder.bind(GoogleChatApp, to=GoogleChatApp)
         binder.bind(MailApp, to=MailApp)
-        binder.bind(IAuthentication, to=IAuthentication)
+        binder.bind(AuthService, to=AuthService)
         binder.bind(Utility, to=Utility)
 
-    def _bind_views(self, binder: Binder):
-        """Vincula las vistas después de que el injector ha sido creado"""
-        from iatoolkit.views.llmquery_view import LLMQueryView
-        from iatoolkit.views.home_view import HomeView
-        from iatoolkit.views.chat_view import ChatView
-        from iatoolkit.views.change_password_view import ChangePasswordView
-
-        binder.bind(HomeView, to=HomeView)
-        binder.bind(ChatView, to=ChatView)
-        binder.bind(ChangePasswordView, to=ChangePasswordView)
-        binder.bind(LLMQueryView, to=LLMQueryView)
-
-        logging.info("✅ Views configuradas correctamente")
-
     def _setup_additional_services(self):
         Bcrypt(self.app)
 
@@ -335,9 +359,9 @@ class IAToolkit:
         # instantiate all the registered companies
         get_company_registry().instantiate_companies(self._injector)
 
-        # use the dispatcher to start the execution of every company
+        # use the dispatcher to load the company config.yaml file and prepare the execution
         dispatcher = self._injector.get(Dispatcher)
-        dispatcher.start_execution()
+        dispatcher.load_company_configs()
 
     def _setup_cli_commands(self):
         from iatoolkit.cli_commands import register_core_commands
@@ -362,12 +386,32 @@ class IAToolkit:
         @self.app.context_processor
         def inject_globals():
             from iatoolkit.common.session_manager import SessionManager
+            from iatoolkit.services.profile_service import ProfileService
+            from iatoolkit.services.i18n_service import I18nService
+
+            # Get services from the injector
+            profile_service = self._injector.get(ProfileService)
+            i18n_service = self._injector.get(I18nService)
+
+            # The 't' function wrapper no longer needs to determine the language itself.
+            # It will be automatically handled by the refactored I18nService.
+            def translate_for_template(key: str, **kwargs):
+                return i18n_service.t(key, **kwargs)
+
+            # Get user profile if a session exists
+            user_profile = profile_service.get_current_session_info().get('profile', {})
+
             return {
                 'url_for': url_for,
                 'iatoolkit_version': self.version,
                 'app_name': 'IAToolkit',
-                'user': SessionManager.get('user'),
-                'user_company': SessionManager.get('company_short_name'),
+                'user_identifier': SessionManager.get('user_identifier'),
+                'company_short_name': SessionManager.get('company_short_name'),
+                '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', ''),
+                'flashed_messages': get_flashed_messages(with_categories=True),
+                't': translate_for_template
             }
 
     def _get_default_static_folder(self) -> str:

iatoolkit/infra/llm_client.py

@@ -21,6 +21,7 @@ import tiktoken
 from typing import Dict, Optional, List
 from iatoolkit.services.dispatcher_service import Dispatcher
 
+CONTEXT_ERROR_MESSAGE = 'Tu consulta supera el límite de contexto, utiliza el boton de recarga de contexto.'
 
 class llmClient:
     _llm_clients_cache = {}      # class attribute, for the clients cache
@@ -37,12 +38,6 @@ class llmClient:
         self.util = util
         self._dispatcher = None # Cache for the lazy-loaded dispatcher
 
-        # get the model from the environment variable
-        self.model = os.getenv("LLM_MODEL", "")
-        if not self.model:
-            raise IAToolkitException(IAToolkitException.ErrorType.API_KEY,
-                               "La variable de entorno 'LLM_MODEL' no está configurada.")
-
         # library for counting tokens
         self.encoding = tiktoken.encoding_for_model("gpt-4o")
 
@@ -69,6 +64,7 @@ class llmClient:
                context: str,
                tools: list[dict],
                text: dict,
+               model: str,
                context_history: Optional[List[Dict]] = None,
                ) -> dict:
 
@@ -79,13 +75,13 @@ class llmClient:
         force_tool_name = None
         reasoning = {}
 
-        if 'gpt-5' in self.model:
+        if 'gpt-5' in model:
             text['verbosity'] = "low"
             reasoning = {"effort": 'minimal'}
 
         try:
             start_time = time.time()
-            logging.info(f"calling llm model '{self.model}' with {self.count_tokens(context)} tokens...")
+            logging.info(f"calling llm model '{model}' with {self.count_tokens(context)} tokens...")
 
             # get the proxy for the company
             llm_proxy = self.llm_proxy_factory.create_for_company(company)
@@ -98,7 +94,7 @@ class llmClient:
                 }]
 
                 response = llm_proxy.create_response(
-                    model=self.model,
+                    model=model,
                     previous_response_id=previous_response_id,
                     context_history=context_history,
                     input=input_messages,
@@ -116,7 +112,7 @@ class llmClient:
 
                 # in case of context error
                 if "context_length_exceeded" in str(e):
-                    error_message = 'Tu consulta supera el limite de contexto, sale e ingresa de nuevo a IAToolkit'
+                    error_message = CONTEXT_ERROR_MESSAGE
 
                 raise IAToolkitException(IAToolkitException.ErrorType.LLM_ERROR, error_message)
 
@@ -135,7 +131,7 @@ class llmClient:
                     logging.info(f"start execution fcall: {function_name}")
                     try:
                         result = self.dispatcher.dispatch(
-                            company_name=company.short_name,
+                            company_short_name=company.short_name,
                             action=function_name,
                             **args
                         )
@@ -185,7 +181,7 @@ class llmClient:
                     tool_choice_value = "required"
 
                 response = llm_proxy.create_response(
-                    model=self.model,
+                    model=model,
                     input=input_messages,
                     previous_response_id=response.id,
                     context_history=context_history,
@@ -199,7 +195,7 @@ class llmClient:
             # save the statistices
             stats['response_time']=int(time.time() - start_time)
             stats['sql_retry_count'] = sql_retry_count
-            stats['model'] = response.model
+            stats['model'] = model
 
             # decode the LLM response
             decoded_response = self.decode_response(response)
@@ -256,25 +252,23 @@ class llmClient:
 
             # in case of context error
             if "context_length_exceeded" in str(e):
-                error_message = 'Tu consulta supera el limite de contexto, sale e ingresa de nuevo a IAToolkit'
+                error_message = CONTEXT_ERROR_MESSAGE
             elif "string_above_max_length" in str(e):
-                error_message = 'La respuesta es muy larga, trata de filtrar/restringuir tu consulta'
+                error_message = 'La respuesta es muy extensa, trata de filtrar/restringuir tu consulta'
 
             raise IAToolkitException(IAToolkitException.ErrorType.LLM_ERROR, error_message)
 
     def set_company_context(self,
             company: Company,
             company_base_context: str,
-            model: str = None) -> str:
+            model) -> str:
 
-        if model:
-            self.model = model
-        logging.info(f"initializing model '{self.model}' with company context: {self.count_tokens(company_base_context)} tokens...")
+        logging.info(f"initializing model '{model}' with company context: {self.count_tokens(company_base_context)} tokens...")
 
         llm_proxy = self.llm_proxy_factory.create_for_company(company)
         try:
             response = llm_proxy.create_response(
-                model=self.model,
+                model=model,
                 input=[{
                     "role": "system",
                     "content": company_base_context
@@ -393,6 +387,7 @@ class llmClient:
 
     def add_stats(self, stats1: dict, stats2: dict) -> dict:
         stats_dict = {
+            "model": stats1.get('model', ''),
             "input_tokens": stats1.get('input_tokens', 0) + stats2.get('input_tokens', 0),
             "output_tokens": stats1.get('output_tokens', 0) + stats2.get('output_tokens', 0),
             "total_tokens": stats1.get('total_tokens', 0) + stats2.get('total_tokens', 0),

iatoolkit/infra/llm_proxy.py

@@ -7,6 +7,7 @@ from typing import Dict, List, Any
 from abc import ABC, abstractmethod
 from iatoolkit.common.util import Utility
 from iatoolkit.infra.llm_response import LLMResponse
+from iatoolkit.services.configuration_service import ConfigurationService
 from iatoolkit.infra.openai_adapter import OpenAIAdapter
 from iatoolkit.infra.gemini_adapter import GeminiAdapter
 from iatoolkit.common.exceptions import IAToolkitException
@@ -41,12 +42,16 @@ class LLMProxy:
     _clients_cache_lock = threading.Lock()
 
     @inject
-    def __init__(self, util: Utility, openai_client = None, gemini_client = None):
+    def __init__(self, util: Utility,
+                 configuration_service: ConfigurationService,
+                 openai_client = None,
+                 gemini_client = None):
         """
         Inicializa una instancia del proxy. Puede ser una instancia "base" (fábrica)
         o una instancia de "trabajo" con clientes configurados.
         """
         self.util = util
+        self.configuration_service = configuration_service
         self.openai_adapter = OpenAIAdapter(openai_client) if openai_client else None
         self.gemini_adapter = GeminiAdapter(gemini_client) if gemini_client else None
 
@@ -71,7 +76,11 @@ class LLMProxy:
             )
 
         # Devuelve una NUEVA instancia con los clientes configurados
-        return LLMProxy(util=self.util, openai_client=openai_client, gemini_client=gemini_client)
+        return LLMProxy(
+                    util=self.util,
+                    configuration_service=self.configuration_service,
+                    openai_client=openai_client,
+                    gemini_client=gemini_client)
 
     def create_response(self, model: str, input: List[Dict], **kwargs) -> LLMResponse:
         """Enruta la llamada al adaptador correcto basado en el modelo."""
@@ -103,7 +112,7 @@ class LLMProxy:
                     elif provider == LLMProvider.GEMINI:
                         client = self._create_gemini_client(company)
                     else:
-                        raise IAToolkitException(f"Proveedor no soportado: {provider.value}")
+                        raise IAToolkitException(f"provider not supported: {provider.value}")
 
                     if client:
                         LLMProxy._clients_cache[cache_key] = client
@@ -115,22 +124,41 @@ class LLMProxy:
 
     def _create_openai_client(self, company: Company) -> OpenAI:
         """Crea un cliente de OpenAI con la API key."""
-        if company.openai_api_key:
-            decrypted_api_key = self.util.decrypt_key(company.openai_api_key)
+        decrypted_api_key = ''
+        llm_config = self.configuration_service.get_configuration(company.short_name, 'llm')
+
+        # Try to get API key name from config first
+        if llm_config and llm_config.get('api-key'):
+            api_key_env_var = llm_config['api-key']
+            decrypted_api_key = os.getenv(api_key_env_var, '')
         else:
-            decrypted_api_key = os.getenv("OPENAI_API_KEY", '')
+            # Fallback to old logic
+            if company.openai_api_key:
+                decrypted_api_key = self.util.decrypt_key(company.openai_api_key)
+            else:
+                decrypted_api_key = os.getenv("OPENAI_API_KEY", '')
+
         if not decrypted_api_key:
             raise IAToolkitException(IAToolkitException.ErrorType.API_KEY,
-                               f"La empresa '{company.name}' no tiene API key de OpenAI.")
+                                     f"La empresa '{company.name}' no tiene API key de OpenAI.")
         return OpenAI(api_key=decrypted_api_key)
 
     def _create_gemini_client(self, company: Company) -> Any:
         """Configura y devuelve el cliente de Gemini."""
 
-        if company.gemini_api_key:
-            decrypted_api_key = self.util.decrypt_key(company.gemini_api_key)
+        decrypted_api_key = ''
+        llm_config = self.configuration_service.get_configuration(company.short_name, 'llm')
+
+        # Try to get API key name from config first
+        if llm_config and llm_config.get('api-key'):
+            api_key_env_var = llm_config['api-key']
+            decrypted_api_key = os.getenv(api_key_env_var, '')
         else:
-            decrypted_api_key = os.getenv("GEMINI_API_KEY", '')
+            # Fallback to old logic
+            if company.gemini_api_key:
+                decrypted_api_key = self.util.decrypt_key(company.gemini_api_key)
+            else:
+                decrypted_api_key = os.getenv("GEMINI_API_KEY", '')
 
         if not decrypted_api_key:
             return None

iatoolkit/infra/openai_adapter.py

@@ -55,7 +55,7 @@ class OpenAIAdapter:
 
             # En caso de error de contexto
             if "context_length_exceeded" in str(e):
-                error_message = 'Tu consulta supera el limite de contexto, sale e ingresa de nuevo a IAToolkit'
+                error_message = 'Tu consulta supera el limite de contexto. Reinicia el contexto con el boton de la barra superior.'
 
             raise IAToolkitException(IAToolkitException.ErrorType.LLM_ERROR, error_message)
 

iatoolkit/infra/redis_session_manager.py

@@ -37,9 +37,14 @@ class RedisSessionManager:
         return cls._client
 
     @classmethod
-    def set(cls, key: str, value: str, ex: int = None):
+    def set(cls, key: str, value: str, **kwargs):
+        """
+        Método set flexible que pasa argumentos opcionales (como ex, nx)
+        directamente al cliente de redis.
+        """
         client = cls._get_client()
-        result = client.set(key, value, ex=ex)
+        # Pasa todos los argumentos de palabra clave adicionales al cliente real
+        result = client.set(key, value, **kwargs)
         return result
 
     @classmethod
@@ -49,12 +54,53 @@ class RedisSessionManager:
         result = value if value is not None else default
         return result
 
+    @classmethod
+    def hset(cls, key: str, field: str, value: str):
+        """
+        Establece un campo en un Hash de Redis.
+        """
+        client = cls._get_client()
+        return client.hset(key, field, value)
+
+    @classmethod
+    def hget(cls, key: str, field: str):
+        """
+        Obtiene el valor de un campo de un Hash de Redis.
+        Devuelve None si la clave o el campo no existen.
+        """
+        client = cls._get_client()
+        return client.hget(key, field)
+
+    @classmethod
+    def hdel(cls, key: str, *fields):
+        """
+        Elimina uno o más campos de un Hash de Redis.
+        """
+        client = cls._get_client()
+        return client.hdel(key, *fields)
+
+    @classmethod
+    def pipeline(cls):
+        """
+        Inicia una transacción (pipeline) de Redis.
+        """
+        client = cls._get_client()
+        return client.pipeline()
+
+
     @classmethod
     def remove(cls, key: str):
         client = cls._get_client()
         result = client.delete(key)
         return result
 
+    @classmethod
+    def exists(cls, key: str) -> bool:
+        """Verifica si una clave existe en Redis."""
+        client = cls._get_client()
+        # El comando EXISTS de Redis devuelve un entero (0 o 1). Lo convertimos a booleano.
+        return bool(client.exists(key))
+
     @classmethod
     def set_json(cls, key: str, value: dict, ex: int = None):
         json_str = json.dumps(value)