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

services/dispatcher_service.py

@@ -1,351 +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 iatoolkit import current_iatoolkit
-from common.exceptions import IAToolkitException
-from services.prompt_manager_service import PromptService
-from services.api_service import ApiService
-from repositories.llm_query_repo import LLMQueryRepo
-from repositories.models import Company, Function
-from services.excel_service import ExcelService
-from services.mail_service import MailService
-from iatoolkit.company_registry import get_company_registry
-from common.session_manager import SessionManager
-from common.util import Utility
-from injector import inject
-import logging
-import os
-
-
-class Dispatcher:
-    @inject
-    def __init__(self,
-                 prompt_service: PromptService,
-                 llmquery_repo: LLMQueryRepo,
-                 util: Utility,
-                 api_service: ApiService,
-                 excel_service: ExcelService,
-                 mail_service: MailService):
-        self.prompt_service = prompt_service
-        self.llmquery_repo = llmquery_repo
-        self.api_service = api_service
-        self.util = util
-        self.excel_service = excel_service
-        self.mail_service = mail_service
-        self.system_functions = _FUNCTION_LIST
-        self.system_prompts = _SYSTEM_PROMPT
-
-        # Use the global registry
-        self.company_registry = get_company_registry()
-
-        # load into the dispatcher the configured companies
-        self.company_classes = {}
-        self.initialize_companies()
-
-        # run the statrtup logic for all companies
-        self.start_execution()
-
-        self.tool_handlers = {
-            "iat_generate_excel": self.excel_service.excel_generator,
-            "iat_send_email": self.mail_service.send_mail,
-            "iat_api_call": self.api_service.call_api
-        }
-
-    def initialize_companies(self):
-        """
-        Initializes and instantiates all registered company classes.
-        This method should be called *after* the main injector is fully configured
-        and the company registry is populated.
-        """
-        if self.company_classes: # Prevent re-initialization
-            return
-
-        # ✅ NOW it is safe to get the injector and instantiate companies.
-        injector = current_iatoolkit().get_injector()
-        self.company_registry.set_injector(injector)
-        self.company_classes = self.company_registry.instantiate_companies()
-
-    def start_execution(self):
-        """Runs the startup logic for all registered companies."""
-        for company_name, company_instance in self.company_classes.items():
-            logging.info(f'Starting execution for company: {company_name}')
-            company_instance.start_execution()
-
-        return True
-
-    def setup_all_companies(self):
-        # create system functions
-        for function in self.system_functions:
-            self.llmquery_repo.create_or_update_function(
-                Function(
-                    company_id=None,
-                    system_function=True,
-                    name=function['function_name'],
-                    description= function['description'],
-                    parameters=function['parameters']
-                )
-            )
-
-            # create the system prompts
-            i = 1
-            for prompt in self.system_prompts:
-                self.prompt_service.create_prompt(
-                    prompt_name=prompt['name'],
-                    description=prompt['description'],
-                    order=1,
-                    is_system_prompt=True
-                )
-                i += 1
-
-        # register in the database  every company class
-        for company in self.company_classes.values():
-            company.register_company()
-
-    def dispatch(self, company_name: str, action: str, **kwargs) -> str:
-        company_key = company_name.lower()
-
-        if company_key not in self.company_classes:
-            available_companies = list(self.company_classes.keys())
-            raise IAToolkitException(
-                IAToolkitException.ErrorType.EXTERNAL_SOURCE_ERROR,
-                f"Empresa '{company_name}' no configurada. Empresas disponibles: {available_companies}"
-            )
-
-        # check if action is a system function
-        if action in self.tool_handlers:
-            return  self.tool_handlers[action](**kwargs)
-
-        company_instance = self.company_classes[company_name]
-        try:
-            return company_instance.handle_request(action, **kwargs)
-        except IAToolkitException as e:
-            # Si ya es una IAToolkitException, la relanzamos para preservar el tipo de error original.
-            raise e
-
-        except Exception as e:
-            logging.exception(e)
-            raise IAToolkitException(IAToolkitException.ErrorType.EXTERNAL_SOURCE_ERROR,
-                               f"Error en function call '{action}': {str(e)}") from e
-
-    def get_company_context(self, company_name: str, **kwargs) -> str:
-        if company_name not in self.company_classes:
-            raise IAToolkitException(IAToolkitException.ErrorType.EXTERNAL_SOURCE_ERROR,
-                               f"Empresa no configurada: {company_name}")
-
-        company_context = ''
-
-        # read the company context from this list of markdown files,
-        # company brief, credits, operation description, etc.
-        context_dir = os.path.join(os.getcwd(), f'companies/{company_name}/context')
-        context_files = self.util.get_files_by_extension(context_dir, '.md', return_extension=True)
-        for file in context_files:
-            filepath = os.path.join(context_dir, file)
-            company_context += self.util.load_markdown_context(filepath)
-
-        # add the schemas for every table or function call responses
-        schema_dir = os.path.join(os.getcwd(), f'companies/{company_name}/schema')
-        schema_files = self.util.get_files_by_extension(schema_dir, '.yaml', return_extension=True)
-        for file in schema_files:
-            schema_name = file.split('_')[0]
-            filepath = os.path.join(schema_dir, file)
-            company_context += self.util.generate_context_for_schema(schema_name, filepath)
-
-        company_instance = self.company_classes[company_name]
-        try:
-            return company_context + company_instance.get_company_context(**kwargs)
-        except Exception as e:
-            logging.exception(e)
-            raise IAToolkitException(IAToolkitException.ErrorType.EXTERNAL_SOURCE_ERROR,
-                               f"Error en get_company_context de {company_name}: {str(e)}") from e
-
-    def get_company_services(self, company: Company) -> list[dict]:
-        # create the syntax with openai response syntax, for the company function list
-        tools = []
-        functions = self.llmquery_repo.get_company_functions(company)
-
-        for function in functions:
-            # make sure is always on
-            function.parameters["additionalProperties"] = False
-
-            ai_tool = {
-                "type": "function",
-                "name": function.name,
-                "description": function.description,
-                "parameters": function.parameters,
-                "strict": True
-            }
-            tools.append(ai_tool)
-        return tools
-
-    def get_user_info(self, company_name: str, user_identifier: str, is_local_user: bool) -> dict:
-        if company_name not in self.company_classes:
-            raise IAToolkitException(IAToolkitException.ErrorType.EXTERNAL_SOURCE_ERROR,
-                                     f"Empresa no configurada: {company_name}")
-
-        raw_user_data = {}
-        if is_local_user:
-            # source 1: local user login into IAToolkit
-            raw_user_data = SessionManager.get('user', {})
-        else:
-            # source 2: external company user
-            company_instance = self.company_classes[company_name]
-            try:
-                raw_user_data = company_instance.get_user_info(user_identifier)
-            except Exception as e:
-                logging.exception(e)
-                raise IAToolkitException(IAToolkitException.ErrorType.EXTERNAL_SOURCE_ERROR,
-                                         f"Error en get_user_info de {company_name}: {str(e)}") from e
-
-        # always normalize the data for consistent structure
-        return self._normalize_user_data(raw_user_data, is_local_user)
-
-    def _normalize_user_data(self, raw_data: dict, is_local: bool) -> dict:
-        """
-        Asegura que los datos del usuario siempre tengan una estructura consistente.
-        """
-        # Valores por defecto para un perfil robusto
-        normalized_user = {
-            "id": raw_data.get("id", 0),
-            "user_email": raw_data.get("email", ""),
-            "user_fullname": raw_data.get("user_fullname", ""),
-            "super_user": raw_data.get("super_user", False),
-            "company_id": raw_data.get("company_id", 0),
-            "company_name": raw_data.get("company", ""),
-            "company_short_name": raw_data.get("company_short_name", ""),
-            "is_local": is_local,
-            "extras": raw_data.get("extras", {})
-        }
-
-        # get the extras from the raw data, if any
-        extras = raw_data.get("extras", {})
-        if isinstance(extras, dict):
-            normalized_user.update(extras)
-
-        return normalized_user
-
-    def get_metadata_from_filename(self, company_name: str, filename: str) -> dict:
-        if company_name not in self.company_classes:
-            raise IAToolkitException(IAToolkitException.ErrorType.EXTERNAL_SOURCE_ERROR,
-                               f"Empresa no configurada: {company_name}")
-
-        company_instance = self.company_classes[company_name]
-        try:
-            return company_instance.get_metadata_from_filename(filename)
-        except Exception as e:
-            logging.exception(e)
-            raise IAToolkitException(IAToolkitException.ErrorType.EXTERNAL_SOURCE_ERROR,
-                               f"Error en get_metadata_from_filename de {company_name}: {str(e)}") from e
-
-    def get_company_instance(self, company_name: str):
-        """Returns the instance for a given company name."""
-        return self.company_classes.get(company_name)
-
-    def get_registered_companies(self) -> dict:
-        """Obtiene todas las empresas registradas (para debugging/admin)"""
-        return {
-            "registered_classes": list(self.company_registry.get_registered_companies().keys()),
-            "instantiated": list(self.company_classes.keys()),
-            "count": len(self.company_classes)
-        }
-
-
-# iatoolkit system prompts
-_SYSTEM_PROMPT = [
-    {'name': 'query_main', 'description':'main prompt de iatoolkit'},
-    {'name': 'format_styles', 'description':'formatos y estilos de salida'},
-    {'name': 'sql_rules', 'description':'instrucciones para generar sql'}
-]
-
-
-# iatoolkit  function calls
-_FUNCTION_LIST = [
-    {
-        "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",
-        "function_name": "iat_generate_excel",
-        "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"]
-        }
-    },
-    {
-        'name': 'Envio de mails',
-         'description':  "iatoolkit mail system. "        
-            "envia mails cuando un usuario lo solicita."
-            "Si no te indican quien envia el correo utiliza la dirección iatoolkit@iatoolkit.com",
-         'function_name': "iat_send_email",
-         'parameters': {
-            "type": "object",
-            "properties": {
-                "from_email": {"type": "string","description": "dirección de correo electrónico  que esta enviando el email."},
-                "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": ["from_email","recipient", "subject", "body", "attachments"]
-        }
-     }
-]

services/excel_service.py

@@ -1,98 +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 common.util import Utility
-import pandas as pd
-from uuid import uuid4
-from pathlib import Path
-from common.exceptions import IAToolkitException
-from injector import inject
-import os
-import logging
-from flask import current_app, jsonify
-
-EXCEL_MIME = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
-
-
-class ExcelService:
-    @inject
-    def __init__(self,util: Utility):
-        self.util = util
-
-    def excel_generator(self, **kwargs) -> str:
-        """
-                Genera un Excel a partir de una lista de diccionarios.
-
-                Parámetros esperados en kwargs:
-                  - filename: str (nombre lógico a mostrar, ej. "reporte_clientes.xlsx") [obligatorio]
-                  - data: list[dict] (filas del excel) [obligatorio]
-                  - sheet_name: str = "hoja 1"
-
-                Retorna:
-                     {
-                        "filename": "reporte.xlsx",
-                        "attachment_token": "8b7f8a66-...-c1c3.xlsx",
-                        "content_type": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
-                        "download_link": "/download/8b7f8a66-...-c1c3.xlsx"
-                        }
-                """
-        try:
-            # get the parameters
-            fname = kwargs.get('filename')
-            if not fname:
-                return 'falta el nombre del archivo de salida'
-
-            data = kwargs.get('data')
-            if not data or not isinstance(data, list):
-                return 'faltan los datos  o no es una lista de diccionarios'
-
-            sheet_name = kwargs.get('sheet_name', 'hoja 1')
-
-            # 1. convert dictionary to dataframe
-            df = pd.DataFrame(data)
-
-            # 3. create temporary name
-            token = f"{uuid4()}.xlsx"
-            filepath = Path("static/temp") / token
-            filepath.parent.mkdir(parents=True, exist_ok=True)
-
-            # 4. save excel file in temporary directory
-            df.to_excel(filepath, index=False, sheet_name=sheet_name)
-
-            # 5. return the  link to the LLM
-            return {
-                "filename": fname,
-                "attachment_token": token,
-                "content_type": EXCEL_MIME,
-                "download_link": f"/download/{token}"
-                }
-
-        except Exception as e:
-            raise IAToolkitException(IAToolkitException.ErrorType.CALL_ERROR,
-                               'error generating excel file') from e
-
-    def validate_file_access(self, filename):
-        try:
-            if not filename:
-                return jsonify({"error": "Nombre de archivo inválido"})
-            # Prevent path traversal attacks
-            if '..' in filename or filename.startswith('/') or '\\' in filename:
-                return jsonify({"error": "Nombre de archivo inválido"})
-
-            temp_dir = os.path.join(current_app.root_path, 'static', 'temp')
-            file_path = os.path.join(temp_dir, filename)
-
-            if not os.path.exists(file_path):
-                return jsonify({"error": "Archivo no encontrado"})
-
-            if not os.path.isfile(file_path):
-                return jsonify({"error": "La ruta no corresponde a un archivo"})
-
-            return None
-
-        except Exception as e:
-            error_msg = f"Error validando acceso al archivo {filename}: {str(e)}"
-            logging.error(error_msg)
-            return jsonify({"error": "Error validando archivo"})

services/history_service.py

@@ -1,45 +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.llm_query_repo import LLMQueryRepo
-from repositories.profile_repo import ProfileRepo
-from common.util import Utility
-
-
-class HistoryService:
-    @inject
-    def __init__(self, llm_query_repo: LLMQueryRepo,
-                 profile_repo: ProfileRepo,
-                 util: Utility):
-        self.llm_query_repo = llm_query_repo
-        self.profile_repo = profile_repo
-        self.util = util
-
-    def get_history(self,
-                     company_short_name: str,
-                     external_user_id: str = None,
-                     local_user_id: int = 0) -> dict:
-        try:
-            user_identifier, _ = self.util.resolve_user_identifier(external_user_id, local_user_id)
-            if not user_identifier:
-                return {'error': "No se pudo resolver el identificador del usuario"}
-
-            # validate company
-            company = self.profile_repo.get_company_by_short_name(company_short_name)
-            if not company:
-                return {'error': f'No existe la empresa: {company_short_name}'}
-
-            history = self.llm_query_repo.get_history(company, user_identifier)
-
-            if not history:
-                return {'error': 'No se pudo obtener el historial'}
-
-            history_list = [query.to_dict() for query in history]
-
-            return {'message': 'Historial obtenido correctamente', 'history': history_list}
-
-        except Exception as e:
-            return {'error': str(e)}

services/jwt_service.py

@@ -1,91 +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.
-
-import jwt
-import time
-import logging
-from injector import singleton, inject
-from typing import Optional, Dict, Any
-from flask import Flask
-
-
-@singleton
-class JWTService:
-    @inject
-    def __init__(self,  app: Flask):
-        # Acceder a la configuración directamente desde app.config
-        try:
-            self.secret_key = app.config['JWT_SECRET_KEY']
-            self.algorithm = app.config['JWT_ALGORITHM']
-        except KeyError as e:
-            logging.error(f"Configuración JWT faltante en app.config: {e}. JWTService no funcionará correctamente.")
-            raise RuntimeError(f"Configuración JWT esencial faltante: {e}")
-
-    def generate_chat_jwt(self,
-                          company_id: int,
-                          company_short_name: str,
-                          external_user_id: str,
-                          expires_delta_seconds: int) -> Optional[str]:
-        # generate a JWT for a chat session
-        try:
-            payload = {
-                'company_id': company_id,
-                'company_short_name': company_short_name,
-                'external_user_id': external_user_id,
-                'exp': time.time() + expires_delta_seconds,
-                'iat': time.time(),
-                'type': 'chat_session'  # Identificador del tipo de token
-            }
-            token = jwt.encode(payload, self.secret_key, algorithm=self.algorithm)
-            return token
-        except Exception as e:
-            logging.error(f"Error al generar JWT para company {company_id}, user {external_user_id}: {e}")
-            return None
-
-    def validate_chat_jwt(self, token: str, expected_company_short_name: str) -> Optional[Dict[str, Any]]:
-        """
-        Valida un JWT de sesión de chat.
-        Retorna el payload decodificado si es válido y coincide con la empresa, o None.
-        """
-        if not token:
-            return None
-        try:
-            payload = jwt.decode(token, self.secret_key, algorithms=[self.algorithm])
-
-            # Validaciones adicionales
-            if payload.get('type') != 'chat_session':
-                logging.warning(f"Validación JWT fallida: tipo incorrecto '{payload.get('type')}'")
-                return None
-
-            if payload.get('company_short_name') != expected_company_short_name:
-                logging.warning(
-                    f"Validación JWT fallida: company_short_name no coincide. "
-                    f"Esperado: {expected_company_short_name}, Obtenido: {payload.get('company_short_name')}"
-                )
-                return None
-
-            # external_user_id debe estar presente
-            if 'external_user_id' not in payload or not payload['external_user_id']:
-                logging.warning(f"Validación JWT fallida: external_user_id ausente o vacío.")
-                return None
-
-            # company_id debe estar presente
-            if 'company_id' not in payload or not isinstance(payload['company_id'], int):
-                logging.warning(f"Validación JWT fallida: company_id ausente o tipo incorrecto.")
-                return None
-
-            logging.debug(
-                f"JWT validado exitosamente para company: {payload.get('company_short_name')}, user: {payload.get('external_user_id')}")
-            return payload
-
-        except jwt.ExpiredSignatureError:
-            logging.info(f"Validación JWT fallida: token expirado para {expected_company_short_name}")
-            return None
-        except jwt.InvalidTokenError as e:
-            logging.warning(f"Validación JWT fallida: token inválido para {expected_company_short_name}. Error: {e}")
-            return None
-        except Exception as e:
-            logging.error(f"Error inesperado durante validación de JWT para {expected_company_short_name}: {e}")
-            return None