iatoolkit 0.22.1__py3-none-any.whl → 0.50.2__py3-none-any.whl

iatoolkit/common/routes.py

@@ -6,7 +6,7 @@
 from flask import render_template, redirect, flash, url_for,send_from_directory, current_app, abort
 from iatoolkit.common.session_manager import SessionManager
 from flask import jsonify
-from iatoolkit.views.history_view import HistoryView
+from iatoolkit.views.history_api_view import HistoryApiView
 import os
 
 
@@ -20,36 +20,34 @@ def logout(company_short_name: str):
 def register_views(injector, app):
 
     from iatoolkit.views.index_view import IndexView
-    from iatoolkit.views.init_context_view import InitContextView
-    from iatoolkit.views.llmquery_view import LLMQueryView
+    from iatoolkit.views.init_context_api_view import InitContextApiView
+    from iatoolkit.views.llmquery_web_view import LLMQueryWebView
+    from iatoolkit.views.llmquery_api_view import LLMQueryApiView
     from iatoolkit.views.tasks_view import TaskView
     from iatoolkit.views.tasks_review_view import TaskReviewView
-    from iatoolkit.views.home_view import HomeView
+    from iatoolkit.views.login_test_view import LoginTest
     from iatoolkit.views.login_view import LoginView, InitiateLoginView
-    from iatoolkit.views.external_login_view import InitiateExternalChatView, ExternalChatLoginView
+    from iatoolkit.views.external_login_view import InitiateExternalChatView
     from iatoolkit.views.signup_view import SignupView
     from iatoolkit.views.verify_user_view import VerifyAccountView
     from iatoolkit.views.forgot_password_view import ForgotPasswordView
     from iatoolkit.views.change_password_view import ChangePasswordView
-    from iatoolkit.views.file_store_view import FileStoreView
-    from iatoolkit.views.user_feedback_view import UserFeedbackView
-    from iatoolkit.views.prompt_view import PromptView
+    from iatoolkit.views.file_store_api_view import FileStoreApiView
+    from iatoolkit.views.user_feedback_api_view import UserFeedbackApiView
+    from iatoolkit.views.prompt_api_view import PromptApiView
     from iatoolkit.views.chat_token_request_view import ChatTokenRequestView
-    from iatoolkit.views.download_file_view import DownloadFileView
 
     # iatoolkit home page
     app.add_url_rule('/<company_short_name>', view_func=IndexView.as_view('index'))
 
     # init (reset) the company context (with api-key)
-    app.add_url_rule('/<company_short_name>/<external_user_id>/init-context',
-                         view_func=InitContextView.as_view('init-context'))
+    app.add_url_rule('/<company_short_name>/api/init_context_api',
+                     view_func=InitContextApiView.as_view('init_context_api'))
 
     # this functions are for login external users (with api-key)
     # only the first one should be used from an external app
     app.add_url_rule('/<company_short_name>/initiate_external_chat',
                      view_func=InitiateExternalChatView.as_view('initiate_external_chat'))
-    app.add_url_rule('/<company_short_name>/external_login',
-                     view_func=ExternalChatLoginView.as_view('external_login'))
 
     # this endpoint is for requesting a chat token for external users
     app.add_url_rule('/auth/chat_token',
@@ -70,36 +68,27 @@ def register_views(injector, app):
 
     # main chat query, used by the JS in the browser (with credentials)
     # can be used also for executing iatoolkit prompts
-    app.add_url_rule('/<company_short_name>/llm_query', view_func=LLMQueryView.as_view('llm_query'))
+    app.add_url_rule('/<company_short_name>/llm_query', view_func=LLMQueryWebView.as_view('llm_query_web'))
 
-    # chat buttons are here
+    # this is the same function as above, but with api-key
+    app.add_url_rule('/<company_short_name>/api/llm_query', view_func=LLMQueryApiView.as_view('llm_query_api'))
+
+    # chat buttons are here on
 
     # open the promt directory
-    app.add_url_rule('/<company_short_name>/prompts', view_func=PromptView.as_view('prompt'))
+    app.add_url_rule('/<company_short_name>/api/prompts', view_func=PromptApiView.as_view('prompt'))
 
     # feedback and history
-    app.add_url_rule('/<company_short_name>/feedback', view_func=UserFeedbackView.as_view('feedback'))
-    app.add_url_rule('/<company_short_name>/history', view_func=HistoryView.as_view('history'))
+    app.add_url_rule('/<company_short_name>/api/feedback', view_func=UserFeedbackApiView.as_view('feedback'))
+    app.add_url_rule('/<company_short_name>/api/history', view_func=HistoryApiView.as_view('history'))
 
     # tasks management endpoints: create task, and review answer
     app.add_url_rule('/tasks', view_func=TaskView.as_view('tasks'))
     app.add_url_rule('/tasks/review/<int:task_id>', view_func=TaskReviewView.as_view('tasks-review'))
 
     # this endpoint is for upload documents into the vector store (api-key)
-    app.add_url_rule('/load', view_func=FileStoreView.as_view('load'))
-
-    # login testing (old home page)
-    app.add_url_rule('/login_testing', view_func=HomeView.as_view('home'))
-
-    app.add_url_rule(
-        '/about',  # URL de la ruta
-        view_func=lambda: render_template('about.html'))
-
-    app.add_url_rule('/version', 'version',
-                     lambda: jsonify({"iatoolkit_version": current_app.config.get('VERSION', 'N/A')}))
+    app.add_url_rule('/api/load', view_func=FileStoreApiView.as_view('load_api'))
 
-    app.add_url_rule('/<company_short_name>/<external_user_id>/download-file/<path:filename>',
-                     view_func=DownloadFileView.as_view('download-file'))
 
     @app.route('/download/<path:filename>')
     def download_file(filename):
@@ -122,6 +111,17 @@ def register_views(injector, app):
         except FileNotFoundError:
             abort(404)
 
+    # login testing (old home page)
+    app.add_url_rule('/login_test', view_func=LoginTest.as_view('login_test'))
+
+    app.add_url_rule(
+        '/about',  # URL de la ruta
+        view_func=lambda: render_template('about.html'))
+
+    app.add_url_rule('/version', 'version',
+                     lambda: jsonify({"iatoolkit_version": current_app.config.get('VERSION', 'N/A')}))
+
+
     # hacer que la raíz '/' vaya al home de iatoolkit
     @app.route('/')
     def root_redirect():

iatoolkit/common/session_manager.py

@@ -5,7 +5,6 @@
 
 from flask import session
 
-
 class SessionManager:
     @staticmethod
     def set(key, value):

iatoolkit/common/util.py

@@ -9,7 +9,6 @@ from iatoolkit.common.exceptions import IAToolkitException
 from injector import inject
 import os
 from jinja2 import Environment, FileSystemLoader
-from iatoolkit.common.session_manager import SessionManager
 from datetime import datetime, date
 from decimal import Decimal
 import yaml
@@ -22,26 +21,6 @@ class Utility:
     def __init__(self):
         self.encryption_key = os.getenv('FERNET_KEY')
 
-    @staticmethod
-    def resolve_user_identifier(external_user_id: str = None, local_user_id: int = 0) -> tuple[str, bool]:
-        """
-        Resuelve un identificador único de usuario desde external_user_id o local_user_id.
-
-        Lógica:
-        - Si external_user_id existe y no está vacío: usar external_user_id
-        - Si no, y local_user_id > 0: obtener email de la sesión actual y retornarlo como ID
-        - Si ninguno: retornar string vacío
-
-        """
-        if external_user_id and external_user_id.strip():
-            return external_user_id.strip(), False
-        elif local_user_id and local_user_id > 0:
-            # get the user information from the session
-            user_data = SessionManager.get('user')
-            if user_data:
-                return user_data.get('email', ''), True
-
-        return "", False
 
     def render_prompt_from_template(self,
                                     template_pathname: str,

iatoolkit/iatoolkit.py

@@ -257,7 +257,6 @@ class IAToolkit:
             self._bind_repositories(binder)
             self._bind_services(binder)
             self._bind_infrastructure(binder)
-            self._bind_views(binder)
 
             logging.info("✅ Dependencias configuradas correctamente")
 
@@ -309,34 +308,21 @@ class IAToolkit:
         binder.bind(Dispatcher, to=Dispatcher)
         binder.bind(BrandingService, to=BrandingService)
 
-
     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(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
-
-        binder.bind(HomeView, to=HomeView)
-        binder.bind(LLMQueryView, to=LLMQueryView)
-
-        logging.info("✅ Views configuradas correctamente")
-
     def _setup_additional_services(self):
         Bcrypt(self.app)
 
@@ -374,12 +360,13 @@ class IAToolkit:
         @self.app.context_processor
         def inject_globals():
             from iatoolkit.common.session_manager import SessionManager
+
             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'),
                 'iatoolkit_base_url': os.environ.get('IATOOLKIT_BASE_URL', ''),
             }
 

iatoolkit/infra/llm_client.py

@@ -266,16 +266,14 @@ class llmClient:
     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

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)

iatoolkit/repositories/models.py

@@ -265,8 +265,7 @@ class UserFeedback(Base):
     id = Column(Integer, primary_key=True)
     company_id = Column(Integer, ForeignKey('iat_companies.id',
                                             ondelete='CASCADE'), nullable=False)
-    local_user_id = Column(Integer, default=0, nullable=True)
-    external_user_id = Column(String(128), default='', nullable=True)
+    user_identifier = Column(String(128), default='', nullable=True)
     message = Column(Text, nullable=False)
     rating = Column(Integer, nullable=False)
     created_at = Column(DateTime, default=datetime.now)

iatoolkit/services/auth_service.py

@@ -0,0 +1,74 @@
+# Copyright (c) 2024 Fernando Libedinsky
+# Product: IAToolkit
+#
+# IAToolkit is open source software.
+
+from flask import request
+from injector import inject
+from iatoolkit.services.profile_service import ProfileService
+from flask import request
+
+
+class AuthService:
+    """
+    Centralized service for handling authentication for all incoming requests.
+    It determines the user's identity based on either a Flask session cookie or an API Key.
+    """
+
+    @inject
+    def __init__(self, profile_service: ProfileService):
+        """
+        Injects ProfileService to access session information and validate API keys.
+        """
+        self.profile_service = profile_service
+
+    def verify(self) -> dict:
+        """
+        Verifies the current request and identifies the user.
+
+        Returns a dictionary with:
+        - success: bool
+        - user_identifier: str (if successful)
+        - company_short_name: str (if successful)
+        - error_message: str (on failure)
+        - status_code: int (on failure)
+        """
+        # --- Priority 1: Check for a valid Flask web session ---
+        session_info = self.profile_service.get_current_session_info()
+        if session_info and session_info.get('user_identifier'):
+            # User is authenticated via a web session cookie.
+            return {
+                "success": True,
+                "company_short_name": session_info['company_short_name'],
+                "user_identifier": session_info['user_identifier']
+            }
+
+        # --- Priority 2: Check for a valid API Key in headers ---
+        api_key = None
+        auth = request.headers.get('Authorization', '')
+        if isinstance(auth, str) and auth.lower().startswith('bearer '):
+            api_key =  auth.split(' ', 1)[1].strip()
+
+        if api_key:
+            api_key_entry = self.profile_service.get_active_api_key_entry(api_key)
+            if not api_key_entry:
+                return {"success": False, "error": "Invalid or inactive API Key", "status_code": 401}
+
+            # obtain the company from the api_key_entry
+            company = api_key_entry.company
+
+            # For API calls, the external_user_id must be provided in the request.
+            user_identifier = ''
+            if request.is_json:
+                data = request.get_json() or {}
+                user_identifier = data.get('external_user_id', '')
+
+            return {
+                "success": True,
+                "company_short_name": company.short_name,
+                "user_identifier": user_identifier
+            }
+
+        # --- Failure: No valid credentials found ---
+        return {"success": False, "error": "Authentication required. No session cookie or API Key provided.",
+                "status_code": 401}

iatoolkit/services/dispatcher_service.py

@@ -10,7 +10,6 @@ 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.session_manager import SessionManager
 from iatoolkit.common.util import Utility
 from injector import inject
 import logging
@@ -171,29 +170,24 @@ 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
+        # 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)
+        return self._normalize_user_data(raw_user_data)
 
-    def _normalize_user_data(self, raw_data: dict, is_local: bool) -> dict:
+    def _normalize_user_data(self, raw_data: dict) -> dict:
         """
         Asegura que los datos del usuario siempre tengan una estructura consistente.
         """
@@ -203,10 +197,7 @@ class Dispatcher:
             "username": raw_data.get("id", 0),
             "user_email": raw_data.get("email", ""),
             "user_fullname": raw_data.get("user_fullname", ""),
-            "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,
+            "is_local": False,
             "extras": raw_data.get("extras", {})
         }
 

iatoolkit/services/excel_service.py

@@ -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')

iatoolkit/services/history_service.py

@@ -5,29 +5,20 @@
 
 from injector import inject
 from iatoolkit.repositories.llm_query_repo import LLMQueryRepo
-
 from iatoolkit.repositories.profile_repo import ProfileRepo
-from iatoolkit.common.util import Utility
 
 
 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: