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

iatoolkit/services/tool_service.py

@@ -0,0 +1,246 @@
+# Copyright (c) 2024 Fernando Libedinsky
+# Product: IAToolkit
+#
+# IAToolkit is open source software.
+
+from injector import inject
+from iatoolkit.repositories.llm_query_repo import LLMQueryRepo
+from iatoolkit.repositories.profile_repo import ProfileRepo
+from iatoolkit.repositories.models import Company, Tool
+from iatoolkit.common.exceptions import IAToolkitException
+from iatoolkit.services.sql_service import SqlService
+from iatoolkit.services.excel_service import ExcelService
+from iatoolkit.services.mail_service import MailService
+
+
+_SYSTEM_TOOLS = [
+    {
+        "function_name": "iat_generate_excel",
+        "description": "Generador de Excel."
+                       "Genera un archivo Excel (.xlsx) a partir de una lista de diccionarios. "
+                       "Cada diccionario representa una fila del archivo. "
+                       "el archivo se guarda en directorio de descargas."
+                       "retorna diccionario con filename, attachment_token (para enviar archivo por mail)"
+                       "content_type y download_link",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "filename": {
+                    "type": "string",
+                    "description": "Nombre del archivo de salida (ejemplo: 'reporte.xlsx')",
+                    "pattern": "^.+\\.xlsx?$"
+                },
+                "sheet_name": {
+                    "type": "string",
+                    "description": "Nombre de la hoja dentro del Excel",
+                    "minLength": 1
+                },
+                "data": {
+                    "type": "array",
+                    "description": "Lista de diccionarios. Cada diccionario representa una fila.",
+                    "minItems": 1,
+                    "items": {
+                        "type": "object",
+                        "properties": {},
+                        "additionalProperties": {
+                            "anyOf": [
+                                {"type": "string"},
+                                {"type": "number"},
+                                {"type": "boolean"},
+                                {"type": "null"},
+                                {
+                                    "type": "string",
+                                    "format": "date"
+                                }
+                            ]
+                        }
+                    }
+                }
+            },
+            "required": ["filename", "sheet_name", "data"]
+        }
+    },
+    {
+        'function_name': "iat_send_email",
+        'description': "iatoolkit mail system. "
+                       "envia mails cuando un usuario lo solicita.",
+        'parameters': {
+            "type": "object",
+            "properties": {
+                "recipient": {"type": "string", "description": "email del destinatario"},
+                "subject": {"type": "string", "description": "asunto del email"},
+                "body": {"type": "string", "description": "HTML del email"},
+                "attachments": {
+                    "type": "array",
+                    "description": "Lista de archivos adjuntos codificados en base64",
+                    "items": {
+                        "type": "object",
+                        "properties": {
+                            "filename": {
+                                "type": "string",
+                                "description": "Nombre del archivo con su extensión (ej. informe.pdf)"
+                            },
+                            "content": {
+                                "type": "string",
+                                "description": "Contenido del archivo en b64."
+                            },
+                            "attachment_token": {
+                                "type": "string",
+                                "description": "token para descargar el archivo."
+                            }
+                        },
+                        "required": ["filename", "content", "attachment_token"],
+                        "additionalProperties": False
+                    }
+                }
+            },
+            "required": ["recipient", "subject", "body", "attachments"]
+        }
+    },
+    {
+        "function_name": "iat_sql_query",
+        "description": "Servicio SQL de IAToolkit: debes utilizar este servicio para todas las consultas SQL a bases de datos.",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "database_key": {
+                    "type": "string",
+                    "description": "IMPORTANT: nombre de la base de datos a consultar."
+                },
+                "query": {
+                    "type": "string",
+                    "description": "string con la consulta en sql"
+                },
+            },
+            "required": ["database_key", "query"]
+        }
+    }
+]
+
+
+class ToolService:
+    @inject
+    def __init__(self,
+                 llm_query_repo: LLMQueryRepo,
+                 profile_repo: ProfileRepo,
+                 sql_service: SqlService,
+                 excel_service: ExcelService,
+                 mail_service: MailService):
+        self.llm_query_repo = llm_query_repo
+        self.profile_repo = profile_repo
+        self.sql_service = sql_service
+        self.excel_service = excel_service
+        self.mail_service = mail_service
+
+        # execution mapper for system tools
+        self.system_handlers = {
+            "iat_generate_excel": self.excel_service.excel_generator,
+            "iat_send_email": self.mail_service.send_mail,
+            "iat_sql_query": self.sql_service.exec_sql
+        }
+
+    def register_system_tools(self):
+        """Creates or updates system functions in the database."""
+        try:
+            # delete all system tools
+            self.llm_query_repo.delete_system_tools()
+
+            # create new system tools
+            for function in _SYSTEM_TOOLS:
+                new_tool = Tool(
+                    company_id=None,
+                    system_function=True,
+                    name=function['function_name'],
+                    description=function['description'],
+                    parameters=function['parameters']
+                )
+                self.llm_query_repo.create_or_update_tool(new_tool)
+
+            self.llm_query_repo.commit()
+        except Exception as e:
+            self.llm_query_repo.rollback()
+            raise IAToolkitException(IAToolkitException.ErrorType.DATABASE_ERROR, str(e))
+
+    def sync_company_tools(self, company_short_name: str, tools_config: list):
+        """
+        Synchronizes tools from YAML config to Database (Create/Update/Delete strategy).
+        """
+        if not tools_config:
+            return
+
+        company = self.profile_repo.get_company_by_short_name(company_short_name)
+        if not company:
+            raise IAToolkitException(IAToolkitException.ErrorType.INVALID_NAME,
+                                     f'Company {company_short_name} not found')
+
+        try:
+            # 1. Get existing tools map for later cleanup
+            existing_tools = {
+                f.name: f for f in self.llm_query_repo.get_company_tools(company)
+            }
+            defined_tool_names = set()
+
+            # 2. Sync (Create or Update) from Config
+            for tool_data in tools_config:
+                name = tool_data['function_name']
+                defined_tool_names.add(name)
+
+                # Construct the tool object with current config values
+                # We create a new transient object and let the repo merge it
+                tool_obj = Tool(
+                    company_id=company.id,
+                    name=name,
+                    description=tool_data['description'],
+                    parameters=tool_data['params'],
+                    system_function=False
+                )
+
+                # Always call create_or_update. The repo handles checking for existence by name.
+                self.llm_query_repo.create_or_update_tool(tool_obj)
+
+            # 3. Cleanup: Delete tools present in DB but not in Config
+            for name, tool in existing_tools.items():
+                # Ensure we don't delete system functions or active tools accidentally if logic changes,
+                # though get_company_tools filters by company_id so system functions shouldn't be here usually.
+                if not tool.system_function and (name not in defined_tool_names):
+                    self.llm_query_repo.delete_tool(tool)
+
+            self.llm_query_repo.commit()
+
+        except Exception as e:
+            self.llm_query_repo.rollback()
+            raise IAToolkitException(IAToolkitException.ErrorType.DATABASE_ERROR, str(e))
+
+
+    def get_tools_for_llm(self, company: Company) -> list[dict]:
+        """
+        Returns the list of tools (System + Company) formatted for the LLM (OpenAI Schema).
+        """
+        tools = []
+
+        # get all the tools for the company and system
+        company_tools = self.llm_query_repo.get_company_tools(company)
+
+        for function in company_tools:
+            # clone for no modify the SQLAlchemy session object
+            params = function.parameters.copy() if function.parameters else {}
+            params["additionalProperties"] = False
+
+            ai_tool = {
+                "type": "function",
+                "name": function.name,
+                "description": function.description,
+                "parameters": params,
+                "strict": True
+            }
+            if function.name == 'iat_sql_query':
+                params['properties']['database_key']['enum'] = self.sql_service.get_db_names(company.short_name)
+
+            tools.append(ai_tool)
+        return tools
+
+    def get_system_handler(self, function_name: str):
+        return self.system_handlers.get(function_name)
+
+    def is_system_tool(self, function_name: str) -> bool:
+        return function_name in self.system_handlers

iatoolkit/services/user_feedback_service.py

@@ -0,0 +1,117 @@
+# Copyright (c) 2024 Fernando Libedinsky
+# Product: IAToolkit
+#
+# IAToolkit is open source software.
+
+from iatoolkit.repositories.models import UserFeedback, Company
+from injector import inject
+from iatoolkit.repositories.profile_repo import ProfileRepo
+from iatoolkit.services.i18n_service import I18nService
+from iatoolkit.infra.google_chat_app import GoogleChatApp
+from iatoolkit.services.mail_service import MailService
+import logging
+
+
+class UserFeedbackService:
+    @inject
+    def __init__(self,
+                 profile_repo: ProfileRepo,
+                 i18n_service: I18nService,
+                 google_chat_app: GoogleChatApp,
+                 mail_service: MailService):
+        self.profile_repo = profile_repo
+        self.i18n_service = i18n_service
+        self.google_chat_app = google_chat_app
+        self.mail_service = mail_service
+
+    def _send_google_chat_notification(self, space_name: str, message_text: str):
+        """Envía una notificación de feedback a un espacio de Google Chat."""
+        try:
+            chat_data = {
+                "type": "MESSAGE_TRIGGER",
+                "space": {"name": space_name},
+                "message": {"text": message_text}
+            }
+            chat_result = self.google_chat_app.send_message(message_data=chat_data)
+            if not chat_result.get('success'):
+                logging.warning(f"error sending notification to Google Chat: {chat_result.get('message')}")
+        except Exception as e:
+            logging.exception(f"error sending notification to Google Chat: {e}")
+
+    def _send_email_notification(self,
+                                 company_short_name: str,
+                                 destination_email: str,
+                                 company_name: str,
+                                 message_text: str):
+        """Envía una notificación de feedback por correo electrónico."""
+        try:
+            subject = f"Nuevo Feedback de {company_name}"
+            # Convertir el texto plano a un HTML simple para mantener los saltos de línea
+            html_body = message_text.replace('\n', '<br>')
+            self.mail_service.send_mail(
+                company_short_name=company_short_name,
+                to=destination_email,
+                subject=subject,
+                body=html_body)
+        except Exception as e:
+            logging.exception(f"error sending email de feedback: {e}")
+
+    def _handle_notification(self, company: Company, message_text: str):
+        """Lee la configuración de la empresa y envía la notificación al canal correspondiente."""
+        feedback_params = company.parameters.get('user_feedback')
+        if not isinstance(feedback_params, dict):
+            logging.warning(f"missing 'user_feedback' configuration for company: {company.short_name}.")
+            return
+
+        # get channel and destination
+        channel = feedback_params.get('channel')
+        destination = feedback_params.get('destination')
+        if not channel or not destination:
+            logging.warning(f"invalid 'user_feedback' configuration for: {company.short_name}. Faltan 'channel' o 'destination'.")
+            return
+
+        if channel == 'google_chat':
+            self._send_google_chat_notification(space_name=destination, message_text=message_text)
+        elif channel == 'email':
+            self._send_email_notification(
+                company_short_name=company.short_name,
+                destination_email=destination,
+                company_name=company.short_name,
+                message_text=message_text)
+        else:
+            logging.warning(f"unknown feedback channel: '{channel}' for company {company.short_name}.")
+
+    def new_feedback(self,
+                     company_short_name: str,
+                     message: str,
+                     user_identifier: str,
+                     rating: int = None) -> dict:
+        try:
+            company = self.profile_repo.get_company_by_short_name(company_short_name)
+            if not company:
+                return {'error': self.i18n_service.t('errors.company_not_found', company_short_name=company_short_name)}
+
+            # 2. send notification using company configuration
+            notification_text = (f"*Nuevo feedback de {company_short_name}*:\n"
+                                 f"*Usuario:* {user_identifier}\n"
+                                 f"*Mensaje:* {message}\n"
+                                 f"*Calificación:* {rating if rating is not None else 'N/A'}")
+            self._handle_notification(company, notification_text)
+
+            # 3. always save the feedback in the database
+            new_feedback_obj = UserFeedback(
+                company_id=company.id,
+                message=message,
+                user_identifier=user_identifier,
+                rating=rating
+            )
+            saved_feedback = self.profile_repo.save_feedback(new_feedback_obj)
+            if not saved_feedback:
+                logging.error(f"can't save feedback for user {user_identifier}/{company_short_name}")
+                return {'error': 'can not save the feedback'}
+
+            return {'success': True, 'message': 'Feedback guardado correctamente'}
+
+        except Exception as e:
+            logging.exception(f"Error crítico en el servicio de feedback: {e}")
+            return {'error': str(e)}

iatoolkit/services/user_session_context_service.py

@@ -0,0 +1,213 @@
+# 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, model: str = None) -> 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
+
+        model_key = "" if not model else f"-{model}"
+        return f"session:{company_short_name}/{user_identifier}{model_key}"
+
+    def clear_all_context(self, company_short_name: str, user_identifier: str, model: str = None):
+        """Clears LLM-related context for a user (history and response IDs), preserving profile_data."""
+        session_key = self._get_session_key(company_short_name, user_identifier, model=model)
+        if 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, model: str = None):
+        """Clears only LLM history fields (last_response_id and context_history)."""
+        session_key = self._get_session_key(company_short_name, user_identifier, model=model)
+        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, model: str = None) -> Optional[str]:
+        """Returns the last LLM response ID for this user/model combination."""
+        session_key = self._get_session_key(company_short_name, user_identifier, model=model)
+        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,
+        model: str = None,
+    ):
+        """Persists the last LLM response ID for this user/model combination."""
+        session_key = self._get_session_key(company_short_name, user_identifier, model=model)
+        if session_key:
+            RedisSessionManager.hset(session_key, "last_response_id", response_id)
+
+    def get_initial_response_id(self,
+        company_short_name: str,
+        user_identifier: str,
+        model: str = None,
+    ) -> Optional[str]:
+        """
+        Returns the initial LLM response ID for this user/model combination.
+        This ID represents the state right after the context was set on the LLM.
+        """
+        session_key = self._get_session_key(company_short_name, user_identifier, model=model)
+        if not session_key:
+            return None
+        return RedisSessionManager.hget(session_key, "initial_response_id")
+
+    def save_initial_response_id(self,
+            company_short_name: str,
+            user_identifier: str,
+            response_id: str,
+            model: str = None,
+    ):
+        """Persists the initial LLM response ID for this user/model combination."""
+        session_key = self._get_session_key(company_short_name, user_identifier, model=model)
+        if session_key:
+            RedisSessionManager.hset(session_key, "initial_response_id", response_id)
+
+    def save_context_history(
+            self,
+            company_short_name: str,
+            user_identifier: str,
+            context_history: List[Dict],
+            model: str = None,
+    ):
+        """Serializes and stores the context history for this user/model combination."""
+        session_key = self._get_session_key(company_short_name, user_identifier, model=model)
+        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 serializing context_history for {session_key}: {e}")
+
+    def get_context_history(
+            self,
+            company_short_name: str,
+            user_identifier: str,
+            model: str = None,
+    ) -> Optional[List[Dict]]:
+        """Reads and deserializes the context history for this user/model combination."""
+        session_key = self._get_session_key(company_short_name, user_identifier, model=model)
+        if not session_key:
+            return []
+
+        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,
+            model: str = None,
+        ):
+        """Saves the context version for this user/model combination."""
+        session_key = self._get_session_key(company_short_name, user_identifier, model=model)
+        if session_key:
+            RedisSessionManager.hset(session_key, "context_version", version)
+
+    def get_context_version(self,
+            company_short_name: str,
+            user_identifier: str,
+            model: str = None,
+            ) -> Optional[str]:
+        """Returns the context version for this user/model combination."""
+        session_key = self._get_session_key(company_short_name, user_identifier, model=model)
+        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,
+            model: str = None,
+            ):
+        """Stores a pre-rendered system context and its version, ready to be sent to the LLM."""
+        session_key = self._get_session_key(company_short_name, user_identifier, model=model)
+        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,
+            model: str = None,
+            ) -> tuple:
+        """
+        Atomically retrieves the prepared context and its version and then deletes them
+        to guarantee they are consumed only once.
+        """
+        session_key = self._get_session_key(company_short_name, user_identifier, model=model)
+        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] is the context, results[1] is the version
+        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');
+});
+
+// Tool 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');
+    });
+
+});