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

iatoolkit/services/user_session_context_service.py

@@ -0,0 +1,143 @@
+# Copyright (c) 2024 Fernando Libedinsky
+# Product: IAToolkit
+#
+# IAToolkit is open source software.
+
+from iatoolkit.infra.redis_session_manager import RedisSessionManager
+from typing import List, Dict, Optional
+import json
+import logging
+
+
+class UserSessionContextService:
+    """
+    Gestiona el contexto de la sesión del usuario usando un único Hash de Redis por sesión.
+    Esto mejora la atomicidad y la eficiencia.
+    """
+
+    def _get_session_key(self, company_short_name: str, user_identifier: str) -> Optional[str]:
+        """Devuelve la clave única de Redis para el Hash de sesión del usuario."""
+        user_identifier = (user_identifier or "").strip()
+        if not company_short_name or not user_identifier:
+            return None
+        return f"session:{company_short_name}/{user_identifier}"
+
+    def clear_all_context(self, company_short_name: str, user_identifier: str):
+        """Limpia el contexto del LLM en la sesión para un usuario de forma atómica."""
+        session_key = self._get_session_key(company_short_name, user_identifier)
+        if session_key:
+            # RedisSessionManager.remove(session_key)
+            # 'profile_data' should not be deleted
+            RedisSessionManager.hdel(session_key, 'context_version')
+            RedisSessionManager.hdel(session_key, 'context_history')
+            RedisSessionManager.hdel(session_key, 'last_response_id')
+
+    def clear_llm_history(self, company_short_name: str, user_identifier: str):
+        """Limpia solo los campos relacionados con el historial del LLM (ID y chat)."""
+        session_key = self._get_session_key(company_short_name, user_identifier)
+        if session_key:
+            RedisSessionManager.hdel(session_key, 'last_response_id', 'context_history')
+
+    def get_last_response_id(self, company_short_name: str, user_identifier: str) -> Optional[str]:
+        session_key = self._get_session_key(company_short_name, user_identifier)
+        if not session_key:
+            return None
+        return RedisSessionManager.hget(session_key, 'last_response_id')
+
+    def save_last_response_id(self, company_short_name: str, user_identifier: str, response_id: str):
+        session_key = self._get_session_key(company_short_name, user_identifier)
+        if session_key:
+            RedisSessionManager.hset(session_key, 'last_response_id', response_id)
+
+    def save_context_history(self, company_short_name: str, user_identifier: str, context_history: List[Dict]):
+        session_key = self._get_session_key(company_short_name, user_identifier)
+        if session_key:
+            try:
+                history_json = json.dumps(context_history)
+                RedisSessionManager.hset(session_key, 'context_history', history_json)
+            except (TypeError, ValueError) as e:
+                logging.error(f"Error al serializar context_history para {session_key}: {e}")
+
+    def get_context_history(self, company_short_name: str, user_identifier: str) -> Optional[List[Dict]]:
+        session_key = self._get_session_key(company_short_name, user_identifier)
+        if not session_key:
+            return None
+
+        history_json = RedisSessionManager.hget(session_key, 'context_history')
+        if not history_json:
+            return []
+
+        try:
+            return json.loads(history_json)
+        except json.JSONDecodeError:
+            return []
+
+    def save_profile_data(self, company_short_name: str, user_identifier: str, data: dict):
+        session_key = self._get_session_key(company_short_name, user_identifier)
+        if session_key:
+            try:
+                data_json = json.dumps(data)
+                RedisSessionManager.hset(session_key, 'profile_data', data_json)
+            except (TypeError, ValueError) as e:
+                logging.error(f"Error al serializar profile_data para {session_key}: {e}")
+
+    def get_profile_data(self, company_short_name: str, user_identifier: str) -> dict:
+        session_key = self._get_session_key(company_short_name, user_identifier)
+        if not session_key:
+            return {}
+
+        data_json = RedisSessionManager.hget(session_key, 'profile_data')
+        if not data_json:
+            return {}
+
+        try:
+            return json.loads(data_json)
+        except json.JSONDecodeError:
+            return {}
+
+    def save_context_version(self, company_short_name: str, user_identifier: str, version: str):
+        session_key = self._get_session_key(company_short_name, user_identifier)
+        if session_key:
+            RedisSessionManager.hset(session_key, 'context_version', version)
+
+    def get_context_version(self, company_short_name: str, user_identifier: str) -> Optional[str]:
+        session_key = self._get_session_key(company_short_name, user_identifier)
+        if not session_key:
+            return None
+        return RedisSessionManager.hget(session_key, 'context_version')
+
+    def save_prepared_context(self, company_short_name: str, user_identifier: str, context: str, version: str):
+        """Guarda un contexto de sistema pre-renderizado y su versión, listos para ser enviados al LLM."""
+        session_key = self._get_session_key(company_short_name, user_identifier)
+        if session_key:
+            RedisSessionManager.hset(session_key, 'prepared_context', context)
+            RedisSessionManager.hset(session_key, 'prepared_context_version', version)
+
+    def get_and_clear_prepared_context(self, company_short_name: str, user_identifier: str) -> tuple:
+        """Obtiene el contexto preparado y su versión, y los elimina para asegurar que se usan una sola vez."""
+        session_key = self._get_session_key(company_short_name, user_identifier)
+        if not session_key:
+            return None, None
+
+        pipe = RedisSessionManager.pipeline()
+        pipe.hget(session_key, 'prepared_context')
+        pipe.hget(session_key, 'prepared_context_version')
+        pipe.hdel(session_key, 'prepared_context', 'prepared_context_version')
+        results = pipe.execute()
+
+        # results[0] es el contexto, results[1] es la versión
+        return (results[0], results[1]) if results else (None, None)
+
+    # --- Métodos de Bloqueo ---
+    def acquire_lock(self, lock_key: str, expire_seconds: int) -> bool:
+        """Intenta adquirir un lock. Devuelve True si se adquiere, False si no."""
+        # SET con NX (solo si no existe) y EX (expiración) es una operación atómica.
+        return RedisSessionManager.set(lock_key, "1", ex=expire_seconds, nx=True)
+
+    def release_lock(self, lock_key: str):
+        """Libera un lock."""
+        RedisSessionManager.remove(lock_key)
+
+    def is_locked(self, lock_key: str) -> bool:
+        """Verifica si un lock existe."""
+        return RedisSessionManager.exists(lock_key)

iatoolkit/static/js/chat_feedback_button.js

@@ -0,0 +1,80 @@
+$(document).ready(function () {
+    const feedbackModal = $('#feedbackModal');
+    $('#submit-feedback').on('click', function () {
+        sendFeedback(this);
+    });
+
+    // Evento para enviar el feedback
+    async function sendFeedback(submitButton) {
+        toastr.options = {"positionClass": "toast-bottom-right", "preventDuplicates": true};
+        const feedbackText = $('#feedback-text').val().trim();
+        const activeStars = $('.star.active').length;
+
+        if (!feedbackText) {
+            toastr.error(t_js('feedback_comment_error'));
+            return;
+        }
+
+        if (activeStars === 0) {
+            toastr.error(t_js('feedback_rating_error'));
+            return;
+        }
+
+        submitButton.disabled = true;
+
+        // call the IAToolkit API to send feedback
+        const data = {
+            "user_identifier": window.user_identifier,
+            "message": feedbackText,
+            "rating": activeStars,
+        };
+
+        const responseData = await callToolkit('/api/feedback', data, "POST");
+        if (responseData)
+            toastr.success(t_js('feedback_sent_success_body'), t_js('feedback_sent_success_title'));
+        else
+            toastr.error(t_js('feedback_sent_error'));
+
+        submitButton.disabled = false;
+        feedbackModal.modal('hide');
+    }
+
+// Evento para abrir el modal de feedback
+$('#send-feedback-button').on('click', function () {
+    $('#submit-feedback').prop('disabled', false);
+    $('.star').removeClass('active hover-active'); // Resetea estrellas
+    $('#feedback-text').val('');
+    feedbackModal.modal('show');
+});
+
+// Evento que se dispara DESPUÉS de que el modal se ha ocultado
+$('#feedbackModal').on('hidden.bs.modal', function () {
+    $('#feedback-text').val('');
+    $('.star').removeClass('active');
+});
+
+// Function for the star rating system
+window.gfg = function (rating) {
+    $('.star').removeClass('active');
+    $('.star').each(function (index) {
+        if (index < rating) {
+            $(this).addClass('active');
+        }
+    });
+};
+
+$('.star').hover(
+    function () {
+        const rating = $(this).data('rating');
+        $('.star').removeClass('hover-active');
+        $('.star').each(function (index) {
+            if ($(this).data('rating') <= rating) {
+                $(this).addClass('hover-active');
+            }
+        });
+    },
+    function () {
+        $('.star').removeClass('hover-active');
+    });
+
+});

iatoolkit/static/js/chat_filepond.js

@@ -0,0 +1,85 @@
+$(document).ready(function () {
+    const paperclipButton = $('#paperclip-button');
+    const viewFilesButtonContainer = $('#view-files-button-container');
+    const viewFilesButton = $('#view-files-button');
+    const uploadedFilesModalElement = $('#uploadedFilesModal');
+    const uploadedFilesModal = uploadedFilesModalElement;  // En Bootstrap 3, el elemento jQuery es el modal
+    const uploadedFilesList = $('#uploaded-files-list');
+
+    // Initialize FilePond
+    window.filePond = FilePond.create(
+        document.querySelector('#file-upload'), {
+        allowMultiple: true,
+        labelIdle: '',
+        credits: false,
+        allowFileSizeValidation: true,
+        maxFileSize: '10MB',
+        stylePanelLayout: null,
+        itemInsertLocation: 'after',
+        instantUpload: false,
+    });
+
+    $('.filepond--root').hide(); // Ocultar la UI de FilePond
+
+    // Función para actualizar la visibilidad del icono "ver archivos"
+    function updateFileIconsVisibility() {
+        const files = filePond.getFiles();
+        if (files.length > 0) {
+            viewFilesButtonContainer.show();
+        } else {
+            viewFilesButtonContainer.hide();
+            if (uploadedFilesModalElement.hasClass('in')) { // Si el modal está abierto y no hay archivos, ciérralo
+                uploadedFilesModal.modal('hide');
+            }
+        }
+    }
+
+    // Función para poblar el modal con los archivos y botones de eliminar
+    function populateFilesModal() {
+        uploadedFilesList.empty(); // Limpiar lista anterior
+        const files = filePond.getFiles();
+
+        if (files.length === 0) {
+            uploadedFilesList.append('<li class="list-group-item">No hay archivos adjuntos.</li>');
+            return;
+        }
+
+        files.forEach(file => {
+            const listItem = $(`
+                <li class="list-group-item d-flex justify-content-between align-items-center">
+                    <span class="file-name-modal">${file.filename}</span>
+                    <button type="button" class="btn btn-sm btn-outline-danger remove-file-btn" data-file-id="${file.id}" title="Eliminar archivo">
+                        <i class="bi bi-trash-fill"></i>
+                    </button>
+                </li>
+            `);
+            uploadedFilesList.append(listItem);
+        });
+    }
+
+        // Event listeners de FilePond
+    window.filePond.on('addfile', () => updateFileIconsVisibility());
+    window.filePond.on('removefile', () => {
+        updateFileIconsVisibility();
+        if (uploadedFilesModalElement.hasClass('in')) {
+            populateFilesModal();
+        }
+    });
+
+    // Event listeners de los botones de la UI
+    paperclipButton.on('click', () => window.filePond.browse());
+    viewFilesButton.on('click', () => {
+        populateFilesModal();
+        uploadedFilesModal.modal('show');
+    });
+    uploadedFilesList.on('click', '.remove-file-btn', function () {
+        const fileIdToRemove = $(this).data('file-id');
+        if (fileIdToRemove) {
+            window.filePond.removeFile(fileIdToRemove);
+        }
+    });
+
+    // Inicializar visibilidad al cargar
+    updateFileIconsVisibility();
+});
+

iatoolkit/static/js/chat_help_content.js

@@ -0,0 +1,124 @@
+$(document).ready(function () {
+
+    let helpContent = null; // Variable para cachear el contenido de ayuda
+
+    // Evento de clic en el botón de ayuda
+    $('#open-help-button').on('click', async function () {
+        const helpModal = new bootstrap.Modal(document.getElementById('helpModal'));
+        const accordionContainer = $('#help-accordion-container');
+        const spinner = $('#help-spinner');
+
+        // Si el contenido no se ha cargado, hacer la llamada a la API
+        if (helpContent) {
+            // Si el contenido ya está cacheado, solo muestra el modal
+            helpModal.show();
+            return;
+        }
+
+        spinner.show();
+        accordionContainer.hide();
+        helpModal.show();
+
+        try {
+            const helpContent = await callToolkit('/api/help-content', {}, "POST");
+
+            if (!helpContent) {
+                toastr.error('No se pudo cargar la guía de uso. Por favor, intente más tarde.');
+                spinner.hide();
+                helpModal.hide();
+                return;
+            }
+
+            // Construir el HTML del acordeón y mostrarlo
+            buildHelpAccordion(helpContent);
+            spinner.hide();
+            accordionContainer.show();
+
+        } catch (error) {
+            console.error("Error al cargar el contenido de ayuda:", error);
+            toastr.error('Ocurrió un error de red al cargar la guía.');
+            spinner.hide();
+            helpModal.hide();
+        }
+    });
+
+    /**
+     * Construye dinámicamente el HTML para el acordeón de ayuda a partir de los datos.
+     * @param {object} data El objeto JSON con el contenido de ayuda.
+     */
+    function buildHelpAccordion(data) {
+        const container = $('#help-accordion-container');
+        container.empty(); // Limpiar cualquier contenido previo
+
+        let accordionHtml = '';
+
+        if (data.example_questions) {
+            let contentHtml = '';
+            data.example_questions.forEach(cat => {
+                contentHtml += `<h6 class="fw-bold">${cat.category}</h6><ul>`;
+                cat.questions.forEach(q => contentHtml += `<li>${q}</li>`);
+                contentHtml += `</ul>`;
+            });
+            accordionHtml += createAccordionItem('examples', 'Preguntas de Ejemplo', contentHtml, true);
+        }
+
+        if (data.data_sources) {
+            let contentHtml = '<dl>';
+            data.data_sources.forEach(p => {
+                contentHtml += `<dt>${p.source}</dt><dd>${p.description}</dd>`;
+            });
+            contentHtml += `</dl>`;
+            accordionHtml += createAccordionItem('sources', 'Datos disponibles', contentHtml );
+        }
+
+        if (data.best_practices) {
+            let contentHtml = '<dl>';
+            data.best_practices.forEach(p => {
+                contentHtml += `<dt>${p.title}</dt><dd>${p.description}`;
+                if (p.example) {
+                    contentHtml += `<br><small class="text-muted"><em>Ej: "${p.example}"</em></small>`;
+                }
+                contentHtml += `</dd>`;
+            });
+            contentHtml += `</dl>`;
+            accordionHtml += createAccordionItem('practices', 'Mejores Prácticas', contentHtml);
+        }
+
+        if (data.capabilities) {
+            let contentHtml = `<div class="row">`;
+            contentHtml += `<div class="col-md-6"><h6 class="fw-bold">Puede hacer:</h6><ul>${data.capabilities.can_do.map(item => `<li>${item}</li>`).join('')}</ul></div>`;
+            contentHtml += `<div class="col-md-6"><h6 class="fw-bold">No puede hacer:</h6><ul>${data.capabilities.cannot_do.map(item => `<li>${item}</li>`).join('')}</ul></div>`;
+            contentHtml += `</div>`;
+            accordionHtml += createAccordionItem('capabilities', 'Capacidades y Límites', contentHtml);
+        }
+
+        container.html(accordionHtml);
+    }
+
+    /**
+     * Helper para crear un item del acordeón de Bootstrap.
+     * @param {string} id El ID base para los elementos.
+     * @param {string} title El título que se muestra en el botón del acordeón.
+     * @param {string} contentHtml El HTML que va dentro del cuerpo colapsable.
+     * @param {boolean} isOpen Si el item debe estar abierto por defecto.
+     * @returns {string} El string HTML del item del acordeón.
+     */
+    function createAccordionItem(id, title, contentHtml, isOpen = false) {
+        const showClass = isOpen ? 'show' : '';
+        const collapsedClass = isOpen ? '' : 'collapsed';
+
+        return `
+            <div class="accordion-item">
+                <h2 class="accordion-header" id="heading-${id}">
+                    <button class="accordion-button ${collapsedClass}" type="button" data-bs-toggle="collapse" data-bs-target="#collapse-${id}" aria-expanded="${isOpen}" aria-controls="collapse-${id}">
+                        ${title}
+                    </button>
+                </h2>
+                <div id="collapse-${id}" class="accordion-collapse collapse ${showClass}" aria-labelledby="heading-${id}" data-bs-parent="#help-accordion-container">
+                    <div class="accordion-body">
+                        ${contentHtml}
+                    </div>
+                </div>
+            </div>`;
+    }
+});

iatoolkit/static/js/chat_history_button.js

@@ -0,0 +1,112 @@
+$(document).ready(function () {
+    // Evento para abrir el modal de historial
+    const historyModal = $('#historyModal');
+
+    $('#history-button').on('click', function() {
+        historyModal.modal('show');
+        loadHistory();
+    });
+
+
+    // Función para cargar el historial
+    async function loadHistory() {
+        const historyLoading = $('#history-loading');
+        const historyContent = $('#history-content');
+        const historyTable = historyContent.find('table');
+        const noHistoryMessage = $('#no-history-message');
+
+        // prepare UI for loading
+        historyLoading.show();
+        historyContent.hide();
+        historyTable.show();
+        noHistoryMessage.hide();
+
+        // cal the toolkit, handle the response and errors
+        const data = await callToolkit("/api/history", {}, "POST");
+
+        if (!data || !data.history) {
+            toastr.error(t_js('error_loading_history'));
+            historyModal.modal('hide');
+            return;
+        }
+
+        if (data.history.length === 0) {
+            historyTable.hide();
+            noHistoryMessage.show();
+        } else
+            displayAllHistory(data.history);
+
+        historyLoading.hide();
+        historyContent.show();
+    }
+
+    // Función para mostrar todo el historial
+    function displayAllHistory(historyData) {
+        const historyTableBody = $('#history-table-body');
+
+        historyTableBody.empty();
+
+        // Filtrar solo consultas que son strings simples
+        const filteredHistory = historyData.filter(item => {
+            try {
+                JSON.parse(item.query);
+                return false;
+            } catch (e) {
+                return true;
+            }
+        });
+
+        // Poblar la tabla
+        filteredHistory.forEach((item, index) => {
+            const icon = $('<i>').addClass('bi bi-pencil-fill');
+
+            const link = $('<a>')
+                .attr('href', 'javascript:void(0);')
+                .addClass('edit-pencil')
+                .attr('title', t_js('edit_query'))
+                .data('query', item.query)
+                .append(icon);
+
+            const row = $('<tr>').append(
+                $('<td>').addClass('text-nowrap').text(formatDate(item.created_at)),
+                $('<td>').text(item.query),
+                $('<td>').append(link),
+            );
+
+            historyTableBody.append(row);
+        });
+    }
+
+    function formatDate(dateString) {
+        const date = new Date(dateString);
+
+        const padTo2Digits = (num) => num.toString().padStart(2, '0');
+
+        const day = padTo2Digits(date.getDate());
+        const month = padTo2Digits(date.getMonth() + 1);
+        const year = date.getFullYear();
+        const hours = padTo2Digits(date.getHours());
+        const minutes = padTo2Digits(date.getMinutes());
+
+        return `${day}-${month} ${hours}:${minutes}`;
+    }
+
+    // event handler for the edit pencil icon
+    $('#history-table-body').on('click', '.edit-pencil', function() {
+        const queryText = $(this).data('query');
+
+        // copy the text to the chat input box
+        if (queryText) {
+            $('#question').val(queryText);
+            autoResizeTextarea($('#question')[0]);
+            $('#send-button').removeClass('disabled');
+
+            // Cerrar el modal
+            $('#historyModal').modal('hide');
+
+            // Hacer focus en el textarea
+            if (window.innerWidth > 768)
+                $('#question').focus();
+        }
+    });
+});

iatoolkit/static/js/chat_logout_button.js

@@ -0,0 +1,36 @@
+document.addEventListener('DOMContentLoaded', function() {
+    const logoutButton = document.getElementById('logout-button');
+    if (!logoutButton) {
+        console.warn('El botón de logout con id "logout-button" no fue encontrado.');
+        return;
+    }
+
+    if (window.toastr) {
+        toastr.options = { "positionClass": "toast-bottom-right", "preventDuplicates": true };
+    }
+
+    logoutButton.addEventListener('click', async function(event) {
+        event.preventDefault();
+
+        try {
+            const apiPath = '/api/logout';
+            const data = await callToolkit(apiPath, null, 'GET');
+
+            // Procesar la respuesta
+            if (data && data.status === 'success' && data.url) {
+                window.top.location.href = data.url;
+            } else {
+                // Si algo falla, callToolkit usualmente muestra un error.
+                // Mostramos un toast como fallback.
+                if (window.toastr) {
+                    toastr.error('No se pudo procesar el cierre de sesión. Por favor, intente de nuevo.');
+                }
+            }
+        } catch (error) {
+            console.error('Error durante el logout:', error);
+            if (window.toastr) {
+                toastr.error('Ocurrió un error de red al intentar cerrar sesión.');
+            }
+        }
+    });
+});