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

services/query_service.py

@@ -1,334 +0,0 @@
-# Copyright (c) 2024 Fernando Libedinsky
-# Producto: IAToolkit
-# Todos los derechos reservados.
-# En trámite de registro en el Registro de Propiedad Intelectual de Chile.
-
-from infra.llm_client import llmClient
-from repositories.document_repo import DocumentRepo
-from repositories.profile_repo import ProfileRepo
-from services.document_service import DocumentService
-from repositories.llm_query_repo import LLMQueryRepo
-from repositories.models import Task
-from services.dispatcher_service import Dispatcher
-from services.prompt_manager_service import PromptService
-from services.user_session_context_service import UserSessionContextService
-from common.util import Utility
-from common.exceptions import IAToolkitException
-from injector import inject
-import base64
-import logging
-from typing import Optional, TYPE_CHECKING
-import json
-import time
-import os
-
-
-GEMINI_MAX_TOKENS_CONTEXT_HISTORY = 200000
-
-class QueryService:
-    @inject
-    def __init__(self,
-                 llm_client: llmClient,
-                 document_service: DocumentService,
-                 document_repo: DocumentRepo,
-                 llmquery_repo: LLMQueryRepo,
-                 profile_repo: ProfileRepo,
-                 prompt_service: PromptService,
-                 util: Utility,
-                 dispatcher: Dispatcher,
-                 session_context: UserSessionContextService
-                 ):
-        self.document_service = document_service
-        self.document_repo = document_repo
-        self.llmquery_repo = llmquery_repo
-        self.profile_repo = profile_repo
-        self.prompt_service = prompt_service
-        self.util = util
-        self.dispatcher = dispatcher
-        self.session_context = session_context
-        self.llm_client = llm_client
-
-        # Obtener el modelo de las variables de entorno
-        self.model = os.getenv("LLM_MODEL", "")
-        if not self.model:
-            raise IAToolkitException(IAToolkitException.ErrorType.API_KEY,
-                               "La variable de entorno 'LLM_MODEL' no está configurada.")
-
-
-    def llm_init_context(self,
-                         company_short_name: str,
-                         external_user_id: str = None,
-                         local_user_id: int = 0,
-                         model: str = ''):
-        start_time = time.time()
-        if not model:
-            model = self.model
-
-        # Validate the user and company
-        user_identifier, is_local_user = self.util.resolve_user_identifier(external_user_id, local_user_id)
-        if not user_identifier:
-            raise IAToolkitException(IAToolkitException.ErrorType.INVALID_USER,
-                        "No se pudo resolver el identificador del usuario")
-
-        company = self.profile_repo.get_company_by_short_name(company_short_name)
-        if not company:
-            raise IAToolkitException(IAToolkitException.ErrorType.INVALID_NAME,
-                               f"Empresa no encontrada: {company_short_name}")
-
-        logging.info(f"Inicializando contexto para {company_short_name}/{user_identifier} con modelo {model}  ...")
-        try:
-            # 1. clean any previous context for company/user
-            self.session_context.clear_all_context(
-                company_short_name=company_short_name,
-                user_identifier=user_identifier
-            )
-
-            # 2. get dictionary with user information from company DB
-            # user roles are read at this point from company db
-            user_profile = self.dispatcher.get_user_info(
-                company_name=company_short_name,
-                user_identifier=user_identifier,
-                is_local_user=is_local_user
-            )
-
-            # add the user logged in to the user_info dictionary
-            user_profile['user_id'] = user_identifier
-
-            # save the user information in the session context
-            # it's needed for the jinja predefined prompts (filtering)
-            self.session_context.save_user_session_data(company_short_name, user_identifier, user_profile)
-
-            # 3. render the iatoolkit main system prompt with the company/user information
-            system_prompt_template = self.prompt_service.get_system_prompt()
-            rendered_system_prompt = self.util.render_prompt_from_string(
-                template_string=system_prompt_template,
-                question=None,
-                client_data=user_profile,
-                company=company,
-                service_list=self.dispatcher.get_company_services(company)
-            )
-
-            # 4. add more company context: schemas, database models, .md files
-            company_specific_context = self.dispatcher.get_company_context(company_name=company_short_name)
-
-            # 5. merge contexts
-            final_system_context = f"{company_specific_context}\n{rendered_system_prompt}"
-
-            if self.util.is_gemini_model(model):
-                # save the initial context as `context_history` (list of messages)
-                context_history = [{"role": "user", "content": final_system_context}]
-                self.session_context.save_context_history(company_short_name, user_identifier, context_history)
-                logging.info(f"Contexto inicial para Gemini guardado en sesión")
-                return "gemini-context-initialized"
-
-            elif self.util.is_openai_model(model):
-
-                # 6. set the company/user context as the initial context for the LLM
-                response_id = self.llm_client.set_company_context(
-                    company=company,
-                    company_base_context=final_system_context,
-                    model=model
-                )
-
-                # 7. save response_id in the session context
-                self.session_context.save_last_response_id(company_short_name, user_identifier, response_id)
-
-                logging.info(f"Contexto inicial de company '{company_short_name}/{user_identifier}' ha sido establecido en {int(time.time() - start_time)} seg.")
-                return response_id
-
-        except Exception as e:
-            logging.exception(f"Error al inicializar el contexto del LLM para {company_short_name}: {e}")
-            raise e
-
-    def llm_query(self,
-                  company_short_name: str,
-                  external_user_id: Optional[str] = None,
-                  local_user_id: int = 0,
-                  task: Optional[Task] = None,
-                  prompt_name: str = None,
-                  question: str = '',
-                  client_data: dict = {},
-                  files: list = []) -> dict:
-        try:
-            user_identifier, is_local_user = self.util.resolve_user_identifier(external_user_id, local_user_id)
-            if not user_identifier:
-                return {"error": True,
-                        "error_message": "No se pudo identificar al usuario"}
-
-            company = self.profile_repo.get_company_by_short_name(short_name=company_short_name)
-            if not company:
-                return {"error": True,
-                        "error_message": f'No existe Company ID: {company_short_name}'}
-
-            if not prompt_name and not question:
-                return {"error": True,
-                        "error_message": f'Hola, cual es tu pregunta?'}
-
-            # get the previous response_id and context history
-            previous_response_id = None
-            context_history = self.session_context.get_context_history(company.short_name, user_identifier) or []
-
-            if self.util.is_openai_model(self.model):
-                # get user context
-                previous_response_id = self.session_context.get_last_response_id(company.short_name, user_identifier)
-                if not previous_response_id:
-                    # try to initialize the company/user context
-                    previous_response_id = self.llm_init_context(company.short_name, external_user_id, local_user_id)
-                    if not previous_response_id:
-                        return {'error': True,
-                                "error_message": f"FATAL: No se encontró 'previous_response_id' para '{company.short_name}/{user_identifier}'. La conversación no puede continuar."
-                                }
-            elif self.util.is_gemini_model(self.model):
-                # check the length of the context_history and remove old messages
-                self._trim_context_history(context_history)
-
-            # get the user data from the session context
-            user_info_from_session = self.session_context.get_user_session_data(company.short_name, user_identifier)
-
-            # Combinar datos: los datos de la tarea/request tienen prioridad sobre los de la sesión
-            final_client_data = (user_info_from_session or {}).copy()
-            final_client_data.update(client_data)
-            final_client_data['user_id'] = user_identifier
-
-            # Load attached files into the context
-            files_context = self.load_files_for_context(files)
-
-            # Initialize prompt_content. It will be an empty string for direct questions.
-            main_prompt = ""
-            if prompt_name:
-                # For task-based queries, wrap data into a JSON string and get the specific prompt template
-                question_dict = {'prompt': prompt_name, 'data': final_client_data }
-                question = json.dumps(question_dict)
-                prompt_content = self.prompt_service.get_prompt_content(company, prompt_name)
-
-                # Render the main user prompt using the appropriate template (or an empty one)
-                main_prompt = self.util.render_prompt_from_string(
-                    template_string=prompt_content,
-                    question=question,
-                    client_data=final_client_data,
-                    external_user_id=external_user_id,
-                    company=company,
-                )
-
-            # client profile
-            client_profile = ''
-            if final_client_data.get('client_identity'):
-                client_profile = f"cliente sobre el cual se esta consultando se identifica como ´client_identity´ y tiene el valor: {final_client_data.get('client_identity')}"
-
-
-            # This is the final user-facing prompt for this specific turn
-            user_turn_prompt = f"{main_prompt}\n{client_profile}\n{files_context}"
-            if not prompt_name:
-                user_turn_prompt += f"\n### La pregunta que debes responder es: {question}"
-            else:
-                user_turn_prompt += f'\n### Contexto Adicional: El usuario ha aportado este contexto puede ayudar: {question}'
-
-            # add to the history context
-            if self.util.is_gemini_model(self.model):
-                context_history.append({"role": "user", "content": user_turn_prompt})
-
-            # service list for the function calls
-            tools = self.dispatcher.get_company_services(company)
-
-            # openai structured output instructions
-            output_schema = {}
-
-            # Now send the instructions to the llm
-            response = self.llm_client.invoke(
-                company=company,
-                user_identifier=user_identifier,
-                previous_response_id=previous_response_id,
-                context_history=context_history if self.util.is_gemini_model(self.model) else None,
-                question=question,
-                context=user_turn_prompt,
-                tools=tools,
-                text=output_schema
-            )
-
-            if not response.get('valid_response'):
-                response['error'] = True
-
-            # save last_response_id for the history chain
-            if "response_id" in response:
-                self.session_context.save_last_response_id(company.short_name, user_identifier, response["response_id"])
-            if self.util.is_gemini_model(self.model):
-                self.session_context.save_context_history(company.short_name, user_identifier, context_history)
-
-            return response
-        except Exception as e:
-            logging.exception(e)
-            return {'error': True, "error_message": f"{str(e)}"}
-
-    def load_files_for_context(self, files: list) -> str:
-        """
-        Processes a list of attached files, decodes their content,
-        and formats them into a string context for the LLM.
-        """
-        if not files:
-            return ''
-
-        context = f"""
-            A continuación encontraras una lista de documentos adjuntos
-            enviados por el usuario que hace la pregunta, 
-            en total son: {len(files)} documentos adjuntos
-            """
-        for document in files:
-            # Support both 'file_id' and 'filename' for robustness
-            filename = document.get('file_id') or document.get('filename')
-            if not filename:
-                context += "\n<error>Documento adjunto sin nombre ignorado.</error>\n"
-                continue
-
-            # Support both 'base64' and 'content' for robustness
-            base64_content = document.get('base64') or document.get('content')
-
-            if not base64_content:
-                # Handles the case where a file is referenced but no content is provided
-                context += f"\n<error>El archivo '{filename}' no fue encontrado y no pudo ser cargado.</error>\n"
-                continue
-
-            try:
-                # Ensure content is bytes before decoding
-                if isinstance(base64_content, str):
-                    base64_content = base64_content.encode('utf-8')
-
-                file_content = base64.b64decode(base64_content)
-                document_text = self.document_service.file_to_txt(filename, file_content)
-                context += f"\n<document name='{filename}'>\n{document_text}\n</document>\n"
-            except Exception as e:
-                # Catches errors from b64decode or file_to_txt
-                logging.error(f"Failed to process file {filename}: {e}")
-                context += f"\n<error>Error al procesar el archivo {filename}: {str(e)}</error>\n"
-                continue
-
-        return context
-
-    def _trim_context_history(self, context_history: list):
-        """
-        Verifica el tamaño del historial de contexto y elimina los mensajes más antiguos
-        si supera un umbral, conservando siempre el mensaje del sistema (índice 0).
-        """
-        if not context_history or len(context_history) <= 1:
-            return  # nothing to remember
-
-        # calculate total tokens
-        try:
-            total_tokens = sum(self.llm_client.count_tokens(json.dumps(message)) for message in context_history)
-        except Exception as e:
-            logging.error(f"Error al calcular tokens del historial: {e}. No se pudo recortar el contexto.")
-            return
-
-        # Si se excede el límite, eliminar mensajes antiguos (empezando por el segundo)
-        while total_tokens > GEMINI_MAX_TOKENS_CONTEXT_HISTORY and len(context_history) > 1:
-            try:
-                # Eliminar el mensaje más antiguo después del prompt del sistema
-                removed_message = context_history.pop(1)
-                removed_tokens = self.llm_client.count_tokens(json.dumps(removed_message))
-                total_tokens -= removed_tokens
-                logging.warning(
-                    f"Historial de contexto ({total_tokens + removed_tokens} tokens) excedía el límite de {GEMINI_MAX_TOKENS_CONTEXT_HISTORY}. "
-                    f"Nuevo total: {total_tokens} tokens."
-                )
-            except IndexError:
-                # Se produce si solo queda el mensaje del sistema, el bucle debería detenerse.
-                break

services/search_service.py

@@ -1,32 +0,0 @@
-# Copyright (c) 2024 Fernando Libedinsky
-# Producto: IAToolkit
-# Todos los derechos reservados.
-# En trámite de registro en el Registro de Propiedad Intelectual de Chile.
-
-from repositories.vs_repo import VSRepo
-from repositories.document_repo import DocumentRepo
-from injector import inject
-
-
-class SearchService:
-    @inject
-    def __init__(self,
-                 doc_repo: DocumentRepo,
-                 vs_repo: VSRepo):
-        super().__init__()
-        self.vs_repo = vs_repo
-        self.doc_repo = doc_repo
-
-    def search(self, company_id:  int, query: str, metadata_filter: dict = None) -> str:
-        document_list = self.vs_repo.query(company_id=company_id,
-                                           query_text=query,
-                                           metadata_filter=metadata_filter)
-
-        search_context = ''
-        for doc in document_list:
-            search_context += f'documento "{doc.filename}"'
-            if doc.meta and 'document_type' in doc.meta:
-                search_context += f' tipo: {doc.meta.get('document_type', '')}'
-            search_context += f': {doc.content}\n'
-
-        return search_context

services/sql_service.py

@@ -1,42 +0,0 @@
-# Copyright (c) 2024 Fernando Libedinsky
-# Producto: IAToolkit
-# Todos los derechos reservados.
-# En trámite de registro en el Registro de Propiedad Intelectual de Chile.
-
-from repositories.database_manager import DatabaseManager
-from common.util import Utility
-from sqlalchemy import text
-from injector import inject
-import json
-from common.exceptions import IAToolkitException
-
-
-class SqlService:
-    @inject
-    def __init__(self,util: Utility):
-        self.util = util
-
-    def exec_sql(self, db_manager: DatabaseManager, sql_statement: str) -> str:
-        try:
-            # here the SQL is executed
-            result = db_manager.get_session().execute(text(sql_statement))
-
-            # get the column names
-            cols = result.keys()
-
-            # convert rows to dict
-            rows_context = [dict(zip(cols, row)) for row in result.fetchall()]
-
-            # Serialize to JSON with type convertion
-            sql_result_json = json.dumps(rows_context, default=self.util.serialize)
-
-            return sql_result_json
-        except Exception as e:
-            db_manager.get_session().rollback()
-
-            error_message = str(e)
-            if 'timed out' in str(e):
-                error_message = 'Intentalo de nuevo, se agoto el tiempo de espera'
-
-            raise IAToolkitException(IAToolkitException.ErrorType.DATABASE_ERROR,
-                                     error_message) from e

services/tasks_service.py

@@ -1,188 +0,0 @@
-# Copyright (c) 2024 Fernando Libedinsky
-# Producto: IAToolkit
-# Todos los derechos reservados.
-# En trámite de registro en el Registro de Propiedad Intelectual de Chile.
-
-from injector import inject
-from repositories.models import Task, TaskStatus
-from services.query_service import QueryService
-from repositories.tasks_repo import TaskRepo
-from repositories.profile_repo import ProfileRepo
-from infra.call_service import CallServiceClient
-from common.exceptions import IAToolkitException
-from datetime import datetime
-from werkzeug.utils import secure_filename
-
-
-class TaskService:
-    @inject
-    def __init__(self,
-                 task_repo: TaskRepo,
-                 query_service: QueryService,
-                 profile_repo: ProfileRepo,
-                 call_service: CallServiceClient):
-        self.task_repo = task_repo
-        self.query_service = query_service
-        self.profile_repo = profile_repo
-        self.call_service = call_service
-
-    def create_task(self,
-                    company_short_name: str,
-                    task_type_name: str,
-                    client_data: dict,
-                    company_task_id: int= 0,
-                    execute_at: datetime = None,
-                    files: list = []
-                    ) -> Task:
-
-        # validate company
-        company = self.profile_repo.get_company_by_short_name(company_short_name)
-        if not company:
-            raise IAToolkitException(IAToolkitException.ErrorType.INVALID_NAME,
-                               f'No existe la empresa: {company_short_name}')
-
-        # validate task_type
-        task_type = self.task_repo.get_task_type(task_type_name)
-        if not task_type:
-            raise IAToolkitException(IAToolkitException.ErrorType.INVALID_NAME,
-                               f'No existe el task_type: {task_type_name}')
-
-        # process the task files
-        task_files = self.get_task_files(files)
-
-        # create Task object
-        new_task = Task(
-            company_id=company.id,
-            task_type_id=task_type.id,
-            company_task_id=company_task_id,
-            client_data=client_data,
-            execute_at=execute_at,
-            files=task_files
-        )
-        new_task = self.task_repo.create_task(new_task)
-        if execute_at and execute_at > datetime.now():
-            self.execute_task(new_task)
-
-        return new_task
-
-    def review_task(self, task_id: int, review_user: str, approved: bool, comment: str):
-        # get the task
-        task = self.task_repo.get_task_by_id(task_id)
-        if not task:
-            raise IAToolkitException(IAToolkitException.ErrorType.TASK_NOT_FOUND,
-                               f'No existe la tarea: {task_id}')
-
-        if task.status != TaskStatus.ejecutado:
-            raise IAToolkitException(IAToolkitException.ErrorType.INVALID_STATE,
-                               f'La tarea debe estar en estado ejecutada: {task_id}')
-
-        # update the task
-        task.approved = approved
-        task.status = TaskStatus.aprobada if approved else TaskStatus.rechazada
-        task.review_user = review_user
-        task.comment = comment
-        task.review_date = datetime.now()
-        self.task_repo.update_task(task)
-        return task
-
-    def execute_task(self, task: Task):
-        # in this case do nothing
-        if (task.status != TaskStatus.pendiente or
-                (task.execute_at and task.execute_at > datetime.now())):
-            return task
-
-        # get the Task template prompt
-        if not task.task_type.prompt_template:
-            raise IAToolkitException(IAToolkitException.ErrorType.INVALID_NAME,
-                               f'No existe el prompt_template para el task_type: {task.task_type.name}')
-
-        template_dir = f'companies/{task.company.short_name}/prompts'
-
-        # call the IA
-        response = self.query_service.llm_query(
-            task=task,
-            local_user_id=0,
-            company_short_name=task.company.short_name,
-            prompt_name=task.task_type.name,
-            client_data=task.client_data,
-            files=task.files
-        )
-        if 'error' in response:
-            raise IAToolkitException(IAToolkitException.ErrorType.LLM_ERROR,
-                                     response.get('error'))
-
-        # update the Task with the response from llm_query
-        task.llm_query_id = response.get('query_id', 0)
-
-        # update task status
-        if not response.get('valid_response'):
-            task.status = TaskStatus.fallida
-        else:
-            task.status = TaskStatus.ejecutado
-        self.task_repo.update_task(task)
-
-        # call the callback url
-        if task.callback_url:
-            self.notify_callback(task, response)
-
-        return task
-
-    def notify_callback(self, task: Task, response: dict):
-        response_data = {
-            'task_id': task.id,
-            'company_task_id': task.company_task_id,
-            'status': task.status.name,
-            'answer': response.get('answer', ''),
-            'additional_data': response.get('additional_data', {}),
-            'client_data': task.client_data,
-        }
-        try:
-            response, status_code = self.call_service.post(task.callback_url, response_data)
-        except Exception as e:
-            raise IAToolkitException(
-                IAToolkitException.ErrorType.REQUEST_ERROR,
-                f"Error al notificar callback {task.callback_url}: {str(e)}"
-            )
-
-    def get_task_files(self, uploaded_files):
-        files_info = []
-
-        for file in uploaded_files:
-            filename = secure_filename(file.filename)
-
-            try:
-                # the file is already in base64
-                file_content = file.read().decode('utf-8')
-            except Exception as e:
-                raise IAToolkitException(
-                    IAToolkitException.ErrorType.FILE_IO_ERROR,
-                    f"Error al extraer el contenido del archivo {filename}: {str(e)}"
-                )
-
-            files_info.append({
-                'filename': filename,
-                'content': file_content,  # file in base64
-                'type': file.content_type
-            })
-
-        return files_info
-
-    def trigger_pending_tasks(self, company_short_name: str):
-        n_tasks = 0
-        try:
-            company = self.profile_repo.get_company_by_short_name(company_short_name)
-            pending_tasks = self.task_repo.get_pending_tasks(company.id)
-            for task in pending_tasks:
-                self.execute_task(task)
-                n_tasks += 1
-        except Exception as e:
-            raise IAToolkitException(
-                IAToolkitException.ErrorType.TASK_EXECUTION_ERROR,
-                f"Error ejecutando tareas pendientes: {str(e)}"
-            )
-
-        return {'message': f'{n_tasks} tareas ejecutadas.'}
-
-
-
-

services/user_feedback_service.py

@@ -1,67 +0,0 @@
-# Copyright (c) 2024 Fernando Libedinsky
-# Producto: IAToolkit
-# Todos los derechos reservados.
-# En trámite de registro en el Registro de Propiedad Intelectual de Chile.
-
-from repositories.models import UserFeedback
-from injector import inject
-from repositories.profile_repo import ProfileRepo
-from infra.google_chat_app import GoogleChatApp
-import logging
-
-
-class UserFeedbackService:
-    @inject
-    def __init__(self, profile_repo: ProfileRepo, google_chat_app: GoogleChatApp):
-        self.profile_repo = profile_repo
-        self.google_chat_app = google_chat_app
-
-    def new_feedback(self,
-                     company_short_name: str,
-                     message: str,
-                     external_user_id: str = None,
-                     local_user_id: int = 0,
-                     space: str = None,
-                     type: str = None,
-                     rating: int = None) -> dict:
-        try:
-            # validate company
-            company = self.profile_repo.get_company_by_short_name(company_short_name)
-            if not company:
-                return {'error': f'No existe la empresa: {company_short_name}'}
-
-            # send notification to Google Chat
-            chat_message = f"*Nuevo feedback de {company_short_name}*:\n*Usuario:* {external_user_id or local_user_id}\n*Mensaje:* {message}\n*Calificación:* {rating}"
-
-            # TO DO: get the space and type from the input data
-            chat_data = {
-                "type": type,
-                "space": {
-                    "name": space
-                },
-                "message": {
-                    "text": chat_message
-                }
-            }
-
-            chat_result = self.google_chat_app.send_message(message_data=chat_data)
-
-            if not chat_result.get('success'):
-                logging.warning(f"Error al enviar notificación a Google Chat: {chat_result.get('message')}")
-
-            # create the UserFeedback object
-            new_feedback = UserFeedback(
-                company_id=company.id,
-                message=message,
-                local_user_id=local_user_id,
-                external_user_id=external_user_id,
-                rating=rating
-            )
-            new_feedback = self.profile_repo.save_feedback(new_feedback)
-            if not new_feedback:
-                return {'error': 'No se pudo guardar el feedback'}
-
-            return {'message': 'Feedback guardado correctamente'}
-
-        except Exception as e:
-            return {'error': str(e)}