iatoolkit 0.3.9__py3-none-any.whl → 0.107.4__py3-none-any.whl

iatoolkit/views/help_content_api_view.py

@@ -0,0 +1,54 @@
+# Copyright (c) 2024 Fernando Libedinsky
+# Product: IAToolkit
+#
+# IAToolkit is open source software.
+
+from flask import request, jsonify
+from flask.views import MethodView
+from iatoolkit.services.configuration_service import ConfigurationService
+from iatoolkit.services.i18n_service import I18nService
+from iatoolkit.services.auth_service import AuthService
+from injector import inject
+import logging
+
+
+class HelpContentApiView(MethodView):
+    """
+    Handles requests from the web UI to fetch a user's query history.
+    Authentication is based on the active Flask session.
+    """
+
+    @inject
+    def __init__(self,
+                 auth_service: AuthService,
+                 config_service: ConfigurationService,
+                 i18n_service: I18nService):
+        self.auth_service = auth_service
+        self.config_service = config_service
+        self.i18n_service = i18n_service
+
+    def post(self, company_short_name: str):
+        try:
+            # 1. Get the authenticated user's
+            auth_result = self.auth_service.verify()
+            if not auth_result.get("success"):
+                return jsonify(auth_result), auth_result.get("status_code")
+
+            user_identifier = auth_result.get('user_identifier')
+
+            # 2. Call the config service with the unified identifier.
+            response = self.config_service.get_configuration(
+                company_short_name=company_short_name,
+                content_key='help_content'      # specific key for this service
+            )
+
+            if "error" in response:
+                # Handle errors reported by the service itself.
+                return jsonify({'error_message': response["error"]}), 400
+
+            return jsonify(response), 200
+
+        except Exception as e:
+            logging.exception(
+                f"Unexpected error fetching help_content for {company_short_name}: {e}")
+            return jsonify({"error_message": self.i18n_service.t('errors.general.unexpected_error', error=str(e))}), 500

iatoolkit/views/history_api_view.py

@@ -0,0 +1,56 @@
+# Copyright (c) 2024 Fernando Libedinsky
+# Product: IAToolkit
+#
+# IAToolkit is open source software.
+
+from flask import request, jsonify
+from flask.views import MethodView
+from iatoolkit.services.history_manager_service import HistoryManagerService
+from iatoolkit.services.auth_service import AuthService
+from iatoolkit.services.i18n_service import I18nService
+from injector import inject
+import logging
+
+
+class HistoryApiView(MethodView):
+    """
+    Handles requests from the web UI to fetch a user's query history.
+    Authentication is based on the active Flask session.
+    """
+
+    @inject
+    def __init__(self,
+                 auth_service: AuthService,
+                 history_service: HistoryManagerService,
+                 i18n_service: I18nService):
+        self.auth_service = auth_service
+        self.history_service = history_service
+        self.i18n_service = i18n_service
+
+
+    def post(self, company_short_name: str):
+        try:
+            # 1. Get the authenticated user's
+            auth_result = self.auth_service.verify()
+            if not auth_result.get("success"):
+                return jsonify(auth_result), auth_result.get("status_code")
+
+            user_identifier = auth_result.get('user_identifier')
+
+            # 2. Call the history service with the unified identifier.
+            # The service's signature should now only expect user_identifier.
+            response = self.history_service.get_full_history(
+                company_short_name=company_short_name,
+                user_identifier=user_identifier
+            )
+
+            if "error" in response:
+                # Handle errors reported by the service itself.
+                return jsonify({'error_message': response["error"]}), 400
+
+            return jsonify(response), 200
+
+        except Exception as e:
+            logging.exception(
+                f"Unexpected error: {e}")
+            return jsonify({"error_message": self.i18n_service.t('errors.general.unexpected_error', error=str(e))}), 500

iatoolkit/views/home_view.py

@@ -0,0 +1,63 @@
+# iatoolkit/views/home_view.py
+from flask import render_template,  render_template_string, request
+from flask.views import MethodView
+from injector import inject
+from iatoolkit.services.profile_service import ProfileService
+from iatoolkit.services.branding_service import BrandingService
+from iatoolkit.services.i18n_service import I18nService
+from iatoolkit.common.util import Utility
+
+class HomeView(MethodView):
+    """
+    Handles the rendering of the company-specific home page with a login widget.
+    If the custom template is not found or fails, it renders an error page.
+    """
+
+    @inject
+    def __init__(self,
+                 profile_service: ProfileService,
+                 branding_service: BrandingService,
+                 i18n_service: I18nService,
+                 utility: Utility):
+        self.profile_service = profile_service
+        self.branding_service = branding_service
+        self.i18n_service = i18n_service
+        self.util = utility
+
+    def get(self, company_short_name: str):
+        branding_data = {}
+        try:
+            company = self.profile_service.get_company_by_short_name(company_short_name)
+            if not company:
+                return render_template('error.html',
+                                       message=self.i18n_service.t('errors.templates.company_not_found')), 404
+
+            branding_data = self.branding_service.get_company_branding(company_short_name)
+
+            template_name = self.util.get_template_by_language("home")
+            home_template = self.util.get_company_template(company_short_name, template_name)
+
+            # 2. Verificamos si el archivo de plantilla personalizado no existe.
+            if not home_template:
+                message = self.i18n_service.t('errors.templates.home_template_not_found', company_name=company_short_name)
+                return render_template(
+                    "error.html",
+                    company_short_name=company_short_name,
+                    branding=branding_data,
+                    message=message
+                ), 500
+
+            # 3. Si el archivo existe, intentamos leerlo y renderizarlo.
+            return render_template_string(
+                home_template,
+                company_short_name=company_short_name,
+                branding=branding_data,
+            )
+        except Exception as e:
+            message = self.i18n_service.t('errors.templates.processing_error', error=str(e))
+            return render_template(
+                "error.html",
+                company_short_name=company_short_name,
+                branding=branding_data,
+                message=message
+            ), 500

iatoolkit/views/init_context_api_view.py

@@ -0,0 +1,74 @@
+from flask.views import MethodView
+from injector import inject
+from iatoolkit.services.query_service import QueryService
+from iatoolkit.services.profile_service import ProfileService
+from iatoolkit.services.auth_service import AuthService
+from iatoolkit.services.i18n_service import I18nService
+from flask import jsonify, request
+import logging
+
+
+class InitContextApiView(MethodView):
+    """
+    API endpoint to force a full context rebuild for a user.
+    Handles both web users (via session) and API users (via API Key).
+    """
+
+    @inject
+    def __init__(self,
+                 auth_service: AuthService,
+                 query_service: QueryService,
+                 profile_service: ProfileService,
+                 i18n_service: I18nService):
+        self.auth_service = auth_service
+        self.query_service = query_service
+        self.profile_service = profile_service
+        self.i18n_service = i18n_service
+
+    def post(self, company_short_name: str):
+        """
+        Cleans and rebuilds the context. The user is identified either by
+        an active web session or by the external_user_id in the JSON payload
+        for API calls.
+        """
+        try:
+            # 1. Authenticate the request. This handles both session and API Key.
+            auth_result = self.auth_service.verify()
+            if not auth_result.get("success"):
+                return jsonify(auth_result), auth_result.get("status_code")
+
+            user_identifier = auth_result.get('user_identifier')
+
+            # check if model was sent as a parameter
+            data = request.get_json(silent=True) or {}
+            model = data.get('model', '')
+
+            # reinit the LLM context
+            response = self.query_service.init_context(
+                company_short_name=company_short_name,
+                user_identifier=user_identifier,
+                model=model)
+
+            # Respond with JSON, as this is an API endpoint.
+            success_message = self.i18n_service.t('api_responses.context_reloaded_success')
+            response_message = {'status': 'OK', 'message': success_message}
+
+            # if received a response ID with the context, return it
+            if response and response.get('response_id'):
+                response_message['response_id'] = response['response_id']
+
+            return jsonify(response_message), 200
+
+        except Exception as e:
+            logging.exception(f"errors while reloading context: {e}")
+            error_message = self.i18n_service.t('errors.general.unexpected_error', error=str(e))
+            return jsonify({"error_message": error_message}), 406
+
+    def options(self, company_short_name):
+        """
+        Maneja las solicitudes preflight de CORS.
+        Su única función es existir y devolver una respuesta exitosa para que
+        el middleware Flask-CORS pueda interceptarla y añadir las cabeceras
+        'Access-Control-Allow-*'.
+        """
+        return {}, 200

iatoolkit/views/llmquery_api_view.py

@@ -0,0 +1,59 @@
+from flask.views import MethodView
+from flask import request, jsonify
+from injector import inject
+from iatoolkit.services.query_service import QueryService
+from iatoolkit.services.auth_service import AuthService
+from iatoolkit.services.profile_service import ProfileService
+from iatoolkit.services.i18n_service import I18nService
+import logging
+
+class LLMQueryApiView(MethodView):
+    """
+    API-only endpoint for submitting queries. Authenticates via API Key.
+    """
+
+    @inject
+    def __init__(self,
+                 auth_service: AuthService,
+                 query_service: QueryService,
+                 profile_service: ProfileService,
+                 i18n_service: I18nService):
+        self.auth_service = auth_service
+        self.query_service = query_service
+        self.profile_service = profile_service
+        self.i18n_service = i18n_service
+
+    def post(self, company_short_name: str):
+        try:
+            # 1. Authenticate the API request.
+            auth_result = self.auth_service.verify()
+            if not auth_result.get("success"):
+                return jsonify(auth_result), auth_result.get("status_code")
+
+            # 2. Get the user identifier from the payload.
+            user_identifier = auth_result.get('user_identifier')
+
+            data = request.get_json()
+            if not data:
+                return jsonify({"error": "Invalid JSON body"}), 400
+
+            # 4. Call the unified query service method.
+            result = self.query_service.llm_query(
+                company_short_name=company_short_name,
+                user_identifier=user_identifier,
+                model=data.get('model', ''),
+                question=data.get('question', ''),
+                prompt_name=data.get('prompt_name'),
+                client_data=data.get('client_data', {}),
+                ignore_history=data.get('ignore_history', False),
+                files=data.get('files', [])
+            )
+            if 'error' in result:
+                return jsonify(result), 409
+
+            return jsonify(result), 200
+
+        except Exception as e:
+            logging.exception(
+                f"Unexpected error: {e}")
+            return jsonify({"error": True, "error_message": self.i18n_service.t('errors.general.unexpected_error')}), 500

iatoolkit/views/load_company_configuration_api_view.py

@@ -0,0 +1,49 @@
+# Copyright (c) 2024 Fernando Libedinsky
+# Product: IAToolkit
+#
+# IAToolkit is open source software.
+
+from flask.views import MethodView
+from flask import redirect, url_for, jsonify, request, g
+from injector import inject
+from iatoolkit.services.auth_service import AuthService
+from iatoolkit.services.profile_service import ProfileService
+from iatoolkit.services.configuration_service import ConfigurationService
+import logging
+
+class LoadCompanyConfigurationApiView(MethodView):
+    @inject
+    def __init__(self,
+                 configuration_service: ConfigurationService,
+                 profile_service: ProfileService,
+                 auth_service: AuthService):
+        self.configuration_service = configuration_service
+        self.profile_service = profile_service
+        self.auth_service = auth_service
+
+    def get(self, company_short_name: str = None):
+        try:
+            # 1. Get the authenticated user's
+            auth_result = self.auth_service.verify(anonymous=True)
+            if not auth_result.get("success"):
+                return jsonify(auth_result), auth_result.get("status_code", 401)
+
+            company = self.profile_service.get_company_by_short_name(company_short_name)
+            if not company:
+                return jsonify({"error": "company not found."}), 404
+
+            config, errors = self.configuration_service.load_configuration(company_short_name)
+            if config:
+                self.configuration_service.register_data_sources(company_short_name)
+
+            # this is fo avoid serialization issues
+            if 'company' in config:
+                config.pop('company')
+
+            status_code = 200 if not errors else 400
+            return {'config': config, 'errors': [errors]}, status_code
+        except Exception as e:
+            logging.exception(f"Unexpected error: {e}")
+            return {'status': 'error'}, 500
+
+

iatoolkit/views/load_document_api_view.py

@@ -0,0 +1,65 @@
+# Copyright (c) 2024 Fernando Libedinsky
+# Product: IAToolkit
+#
+# IAToolkit is open source software.
+
+from flask.views import MethodView
+from flask import request, jsonify
+from iatoolkit.services.load_documents_service import LoadDocumentsService
+from iatoolkit.services.auth_service import AuthService
+from iatoolkit.repositories.profile_repo import ProfileRepo
+from injector import inject
+import base64
+
+
+class LoadDocumentApiView(MethodView):
+    @inject
+    def __init__(self,
+                 auth_service: AuthService,
+                 doc_service: LoadDocumentsService,
+                 profile_repo: ProfileRepo,):
+        self.auth_service = auth_service
+        self.doc_service = doc_service
+        self.profile_repo = profile_repo
+
+    def post(self):
+        try:
+            # 1. Authenticate the API request.
+            auth_result = self.auth_service.verify()
+            if not auth_result.get("success"):
+                return jsonify(auth_result), auth_result.get("status_code")
+
+            req_data = request.get_json()
+            required_fields = ['company', 'filename', 'content']
+            for field in required_fields:
+                if field not in req_data:
+                    return jsonify({"error": f"El campo {field} es requerido"}), 400
+
+            company_short_name = req_data.get('company', '')
+            filename = req_data.get('filename', False)
+            base64_content = req_data.get('content', '')
+            metadata = req_data.get('metadata', {})
+
+            # get company
+            company = self.profile_repo.get_company_by_short_name(company_short_name)
+            if not company:
+                return jsonify({"error": f"La empresa {company_short_name} no existe"}), 400
+
+            # get the file content from base64
+            content = base64.b64decode(base64_content)
+
+            new_document = self.doc_service._file_processing_callback(
+                filename=filename,
+                content=content,
+                company=company,
+                context={'metadata': metadata})
+
+            return jsonify({
+                "document_id": new_document.id,
+            }), 200
+
+        except Exception as e:
+            response = jsonify({"error": str(e)})
+            response.status_code = 500
+
+            return response

iatoolkit/views/login_view.py

@@ -0,0 +1,170 @@
+# Copyright (c) 2024 Fernando Libedinsky
+# Product: IAToolkit
+#
+# IAToolkit is open source software.
+
+from flask.views import MethodView
+from flask import (request, redirect, render_template, url_for,
+                   render_template_string, flash, make_response)
+from injector import inject
+from iatoolkit.services.profile_service import ProfileService
+from iatoolkit.services.jwt_service import JWTService
+from iatoolkit.services.query_service import QueryService
+from iatoolkit.services.prompt_service import PromptService
+from iatoolkit.services.branding_service import BrandingService
+from iatoolkit.services.configuration_service import ConfigurationService
+from iatoolkit.services.i18n_service import I18nService
+from iatoolkit.views.base_login_view import BaseLoginView
+import logging
+
+
+class LoginView(BaseLoginView):
+    """
+    Handles login for local users.
+    Authenticates and then delegates the path decision (fast/slow) to the base class.
+    """
+    def post(self, company_short_name: str):
+        company = self.profile_service.get_company_by_short_name(company_short_name)
+        if not company:
+            return render_template('error.html',
+                                   message=self.i18n_service.t('errors.templates.company_not_found')), 404
+
+        branding_data = self.branding_service.get_company_branding(company_short_name)
+        email = request.form.get('email')
+        password = request.form.get('password')
+        current_lang = request.form.get('lang') or request.args.get('lang') or 'en'
+
+        # 1. Authenticate internal user
+        auth_response = self.auth_service.login_local_user(
+            company_short_name=company_short_name,
+            email=email,
+            password=password
+        )
+
+        if not auth_response['success']:
+            flash(auth_response["message"], 'error')
+
+            # Resolve the correct template name based on language (e.g., home_en.html or home_es.html)
+            template_name = self.utility.get_template_by_language("home")
+            home_template = self.utility.get_company_template(company_short_name, template_name)
+
+            if not home_template:
+                return render_template('error.html',
+                                       message=f'Home template ({template_name}) not found.'), 500
+
+            return render_template_string(
+                home_template,
+                company_short_name=company_short_name,
+                company=company,
+                branding=branding_data,
+                form_data={"email": email},
+            ), 400
+
+        user_identifier = auth_response['user_identifier']
+
+        # 3. define URL to call when slow path is finished
+        target_url = url_for('finalize_no_token',
+                             company_short_name=company_short_name,
+                             _external=True,
+                             lang=current_lang)
+
+        # 2. Delegate the path decision to the centralized logic.
+        try:
+            return self._handle_login_path(company_short_name, user_identifier, target_url)
+        except Exception as e:
+            message = self.i18n_service.t('errors.templates.processing_error', error=str(e))
+            return render_template(
+                "error.html",
+                company_short_name=company_short_name,
+                branding=branding_data,
+                message=message
+            ), 500
+
+
+class FinalizeContextView(MethodView):
+    """
+    Finalizes context loading in the slow path.
+    This view is invoked by the iframe inside onboarding_shell.html.
+    """
+    @inject
+    def __init__(self,
+                 profile_service: ProfileService,
+                 query_service: QueryService,
+                 prompt_service: PromptService,
+                 branding_service: BrandingService,
+                 config_service: ConfigurationService,
+                 jwt_service: JWTService,
+                 i18n_service: I18nService
+                 ):
+        self.profile_service = profile_service
+        self.jwt_service = jwt_service
+        self.query_service = query_service
+        self.prompt_service = prompt_service
+        self.branding_service = branding_service
+        self.config_service = config_service
+        self.i18n_service = i18n_service
+
+    def get(self, company_short_name: str, token: str = None):
+        try:
+            # get the languaje from the query string if it exists
+            current_lang = request.args.get('lang') or 'en'
+
+            session_info = self.profile_service.get_current_session_info()
+            if session_info:
+                # session exists, internal user
+                user_identifier = session_info.get('user_identifier')
+                token = ''
+            elif token:
+                # user identified by api-key
+                payload = self.jwt_service.validate_chat_jwt(token)
+                if not payload:
+                    logging.warning("Fallo crítico: No se pudo leer el auth token.")
+                    return redirect(url_for('home', company_short_name=company_short_name, lang=current_lang))
+
+                user_identifier = payload.get('user_identifier')
+            else:
+                logging.error("missing session information or auth token")
+                return redirect(url_for('home', company_short_name=company_short_name, lang=current_lang))
+
+            company = self.profile_service.get_company_by_short_name(company_short_name)
+            if not company:
+                return render_template('error.html',
+                            company_short_name=company_short_name,
+                            message="Empresa no encontrada"), 404
+            branding_data = self.branding_service.get_company_branding(company_short_name)
+
+            default_llm_model, available_llm_models = self.config_service.get_llm_configuration(company_short_name)
+
+            # 2. Finalize the context rebuild (the heavy task).
+            self.query_service.set_context_for_llm(
+                company_short_name=company_short_name,
+                user_identifier=user_identifier
+            )
+
+            # 3. render the chat page.
+            prompts = self.prompt_service.get_user_prompts(company_short_name)
+            onboarding_cards = self.config_service.get_configuration(company_short_name, 'onboarding_cards')
+
+            # Get the entire 'js_messages' block in the correct language.
+            js_translations = self.i18n_service.get_translation_block('js_messages')
+
+            # Importante: no envolver con make_response; dejar que Flask gestione
+            # tanto strings como tuplas (string, status) que pueda devolver render_template
+            return render_template(
+                "chat.html",
+                company_short_name=company_short_name,
+                user_identifier=user_identifier,
+                branding=branding_data,
+                prompts=prompts,
+                onboarding_cards=onboarding_cards,
+                js_translations=js_translations,
+                redeem_token=token,
+                llm_default_model=default_llm_model,
+                llm_available_models=available_llm_models,
+            )
+
+        except Exception as e:
+            return render_template("error.html",
+                                   company_short_name=company_short_name,
+                                   branding=branding_data,
+                                   message=f"An unexpected error occurred during context loading: {str(e)}"), 500

iatoolkit/views/logout_api_view.py

@@ -0,0 +1,57 @@
+# Copyright (c) 2024 Fernando Libedinsky
+# Product: IAToolkit
+#
+# IAToolkit is open source software.
+
+from flask.views import MethodView
+from flask import redirect, url_for, jsonify, request, g
+from injector import inject
+from iatoolkit.services.auth_service import AuthService
+from iatoolkit.services.profile_service import ProfileService
+from iatoolkit.common.session_manager import SessionManager
+import logging
+
+class LogoutApiView(MethodView):
+    @inject
+    def __init__(self,
+                 profile_service: ProfileService,
+                 auth_service: AuthService):
+        self.profile_service = profile_service
+        self.auth_service = auth_service
+
+    def get(self, company_short_name: str = None):
+        try:
+            # 1. Get the authenticated user's
+            auth_result = self.auth_service.verify(anonymous=True)
+            if not auth_result.get("success"):
+                return jsonify(auth_result), auth_result.get("status_code", 401)
+
+            company = self.profile_service.get_company_by_short_name(company_short_name)
+            if not company:
+                return jsonify({"error": "company not found."}), 404
+
+            # get URL for redirection
+            url_for_redirect = company.parameters.get('external_urls', {}).get('logout_url')
+            if not url_for_redirect:
+                current_lang = (
+                        request.args.get('lang')
+                        or getattr(g, 'lang', None)
+                        or 'en'
+                )
+
+                url_for_redirect = url_for('home',
+                                           company_short_name=company_short_name,
+                                           lang=current_lang)
+
+            # clear de session cookie
+            SessionManager.clear()
+
+            return {
+                'status': 'success',
+                'url': url_for_redirect,
+            }, 200
+        except Exception as e:
+            logging.exception(f"Unexpected error: {e}")
+            return {'status': 'error'}, 500
+
+