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

iatoolkit/infra/connectors/file_connector_factory.py

@@ -0,0 +1,57 @@
+# Copyright (c) 2024 Fernando Libedinsky
+# Product: IAToolkit
+#
+# IAToolkit is open source software.
+
+from iatoolkit.infra.connectors.file_connector import FileConnector
+from iatoolkit.infra.connectors.local_file_connector import LocalFileConnector
+from iatoolkit.infra.connectors.s3_connector import S3Connector
+from iatoolkit.infra.connectors.google_drive_connector import GoogleDriveConnector
+from iatoolkit.infra.connectors.google_cloud_storage_connector import GoogleCloudStorageConnector
+from typing import Dict
+import os
+
+
+class FileConnectorFactory:
+    @staticmethod
+    def create(config: Dict) -> FileConnector:
+        """
+        Configuración esperada:
+        {
+            "type": "local" | "s3" | "gdrive" | "gcs",
+            "path": "/ruta/local",  # solo para local
+            "bucket": "mi-bucket", "prefix": "datos/", "auth": {...},  # solo para S3
+            "folder_id": "xxxxxxx",  # solo para Google Drive
+            "bucket": "mi-bucket", "service_account": "/ruta/service_account.json"  # solo para GCS
+        }
+        """
+        connector_type = config.get('type')
+
+        if connector_type == 'local':
+            return LocalFileConnector(config['path'])
+
+        elif connector_type == 's3':
+            auth = {
+                'aws_access_key_id': os.getenv('AWS_ACCESS_KEY_ID'),
+                'aws_secret_access_key': os.getenv('AWS_SECRET_ACCESS_KEY'),
+                'region_name': os.getenv('AWS_REGION', 'us-east-1')
+            }
+
+            return S3Connector(
+                bucket=config['bucket'],
+                prefix=config.get('prefix', ''),
+                auth=auth
+            )
+
+        elif connector_type == 'gdrive':
+            return GoogleDriveConnector(config['folder_id'],
+                    'service_account.json')
+
+        elif connector_type == 'gcs':
+            return GoogleCloudStorageConnector(
+                bucket_name=config['bucket'],
+                service_account_path=config.get('service_account', 'service_account.json')
+            )
+
+        else:
+            raise ValueError(f"Unknown connector type: {connector_type}")

iatoolkit/infra/connectors/google_cloud_storage_connector.py

@@ -0,0 +1,53 @@
+# Copyright (c) 2024 Fernando Libedinsky
+# Product: IAToolkit
+#
+# IAToolkit is open source software.
+
+from iatoolkit.infra.connectors.file_connector import FileConnector
+from google.cloud import storage
+from typing import List
+
+
+class GoogleCloudStorageConnector(FileConnector):
+    def __init__(self, bucket_name: str, service_account_path: str = "service_account.json"):
+        """
+        Inicializa el conector de Google Cloud Storage utilizando la API oficial de Google.
+        :param bucket_name: Nombre del bucket en Google Cloud Storage.
+        :param service_account_path: Ruta al archivo JSON de la cuenta de servicio.
+        """
+        self.bucket_name = bucket_name
+        self.service_account_path = service_account_path
+        self.storage_client = self._authenticate()
+        self.bucket = self.storage_client.bucket(bucket_name)
+
+    def _authenticate(self):
+        """
+        Autentica en Google Cloud Storage utilizando una cuenta de servicio.
+        """
+        # Crear cliente de GCS con las credenciales
+        client = storage.Client.from_service_account_json(self.service_account_path)
+        return client
+
+    def list_files(self) -> List[dict]:
+        """
+        Lista todos los archivos en el bucket de GCS como diccionarios con claves 'path', 'name' y 'metadata'.
+        """
+        blobs = self.bucket.list_blobs()
+
+        return [
+            {
+                "path": blob.name,  # Nombre o "ruta" del blob en el bucket
+                "name": blob.name.split("/")[-1],  # Nombre del archivo (última parte del path)
+                "metadata": {"size": blob.size}  # Incluye tamaño como metadata (u otros metadatos relevantes)
+            }
+            for blob in blobs
+        ]
+
+    def get_file_content(self, file_path: str) -> bytes:
+        """
+        Descarga el contenido de un archivo en GCS dado su path (nombre del blob).
+        """
+        blob = self.bucket.blob(file_path)
+        file_buffer = blob.download_as_bytes()  # Descarga el contenido como bytes
+
+        return file_buffer

iatoolkit/infra/connectors/google_drive_connector.py

@@ -0,0 +1,68 @@
+# Copyright (c) 2024 Fernando Libedinsky
+# Product: IAToolkit
+#
+# IAToolkit is open source software.
+
+from iatoolkit.infra.connectors.file_connector import FileConnector
+from googleapiclient.discovery import build
+from googleapiclient.http import MediaIoBaseDownload
+from google.oauth2.service_account import Credentials
+import io
+from typing import List
+
+
+class GoogleDriveConnector(FileConnector):
+    def __init__(self, folder_id: str, service_account_path: str = "service_account.json"):
+        """
+        Inicializa el conector de Google Drive utilizando la API oficial de Google.
+        :param folder_id: ID de la carpeta en Google Drive.
+        :param service_account_path: Ruta al archivo JSON de la cuenta de servicio.
+        """
+        self.folder_id = folder_id
+        self.service_account_path = service_account_path
+        self.drive_service = self._authenticate()
+
+    def _authenticate(self):
+        """
+        Autentica en Google Drive utilizando una cuenta de servicio.
+        """
+        # Cargar credenciales desde el archivo de servicio
+        credentials = Credentials.from_service_account_file(
+            self.service_account_path,
+            scopes=["https://www.googleapis.com/auth/drive"]
+        )
+
+        # Crear el cliente de Google Drive API
+        service = build('drive', 'v3', credentials=credentials)
+        return service
+
+    def list_files(self) -> List[dict]:
+        """
+        Estándar: Lista todos los archivos como diccionarios con claves 'path', 'name' y 'metadata'.
+        """
+        query = f"'{self.folder_id}' in parents and trashed=false"
+        results = self.drive_service.files().list(q=query, fields="files(id, name)").execute()
+        files = results.get('files', [])
+
+        return [
+            {
+                "path": file['id'],  # ID único del archivo en Google Drive
+                "name": file['name'],  # Nombre del archivo en Google Drive
+                "metadata": {}  # No hay metadatos adicionales en este caso
+            }
+            for file in files
+        ]
+
+    def get_file_content(self, file_path: str) -> bytes:
+        """
+        Obtiene el contenido de un archivo en Google Drive utilizando su ID (file_path).
+        """
+        request = self.drive_service.files().get_media(fileId=file_path)
+        file_buffer = io.BytesIO()
+        downloader = MediaIoBaseDownload(file_buffer, request)
+
+        done = False
+        while not done:
+            status, done = downloader.next_chunk()
+
+        return file_buffer.getvalue()

iatoolkit/infra/connectors/local_file_connector.py

@@ -0,0 +1,46 @@
+# Copyright (c) 2024 Fernando Libedinsky
+# Product: IAToolkit
+#
+# IAToolkit is open source software.
+
+import os
+from iatoolkit.infra.connectors.file_connector import FileConnector
+from typing import List
+from iatoolkit.common.exceptions import IAToolkitException
+
+
+class LocalFileConnector(FileConnector):
+    def __init__(self, directory: str):
+        local_root = os.getenv("ROOT_DIR_LOCAL_FILES", '')
+        self.directory = os.path.join(local_root, directory)
+
+    def list_files(self) -> List[dict]:
+        """
+        Estándar: Lista todos los archivos como diccionarios con claves 'path', 'name' y 'metadata'.
+        """
+        try:
+            files = [
+                os.path.join(self.directory, f)
+                for f in os.listdir(self.directory)
+                if os.path.isfile(os.path.join(self.directory, f))
+            ]
+
+            return [
+                {
+                    "path": file,  # Ruta completa al archivo local
+                    "name": os.path.basename(file),  # Nombre del archivo
+                    "metadata": {"size": os.path.getsize(file), "last_modified": os.path.getmtime(file)}
+                }
+                for file in files
+            ]
+        except Exception as e:
+            raise IAToolkitException(IAToolkitException.ErrorType.FILE_IO_ERROR,
+                               f"Error procesando el directorio {self.directory}: {e}")
+
+    def get_file_content(self, file_path: str) -> bytes:
+        try:
+            with open(file_path, 'rb') as f:
+                return f.read()
+        except Exception as e:
+            raise IAToolkitException(IAToolkitException.ErrorType.FILE_IO_ERROR,
+                               f"Error leyendo el archivo {file_path}: {e}")

iatoolkit/infra/connectors/s3_connector.py

@@ -0,0 +1,33 @@
+# Copyright (c) 2024 Fernando Libedinsky
+# Product: IAToolkit
+#
+# IAToolkit is open source software.
+
+import boto3
+from iatoolkit.infra.connectors.file_connector import FileConnector
+from typing import List
+
+
+class S3Connector(FileConnector):
+    def __init__(self, bucket: str, prefix: str, auth: dict):
+        self.bucket = bucket
+        self.prefix = prefix
+        self.s3 = boto3.client('s3', **auth)
+
+    def list_files(self) -> List[dict]:
+        # list all the files as dictionaries, with keys:  'path', 'name' y 'metadata'.
+        response = self.s3.list_objects_v2(Bucket=self.bucket, Prefix=self.prefix)
+        files = response.get('Contents', [])
+
+        return [
+            {
+                "path": obj['Key'],  # s3 key
+                "name": obj['Key'].split('/')[-1],  # filename
+                "metadata": {"size": obj.get('Size'), "last_modified": obj.get('LastModified')}
+            }
+            for obj in files
+        ]
+
+    def get_file_content(self, file_path: str) -> bytes:
+        response = self.s3.get_object(Bucket=self.bucket, Key=file_path)
+        return response['Body'].read()

iatoolkit/infra/gemini_adapter.py

@@ -0,0 +1,356 @@
+# Copyright (c) 2024 Fernando Libedinsky
+# Product: IAToolkit
+#
+# IAToolkit is open source software.
+
+from iatoolkit.infra.llm_response import LLMResponse, ToolCall, Usage
+from typing import Dict, List, Optional
+from google.generativeai.types import HarmCategory, HarmBlockThreshold
+from google.protobuf.json_format import MessageToDict
+from iatoolkit.common.exceptions import IAToolkitException
+import logging
+import json
+import uuid
+
+class GeminiAdapter:
+    """Adaptador para la API de Gemini"""
+
+    def __init__(self, gemini_client):
+        """Inicializar con cliente Gemini ya configurado"""
+        self.client = gemini_client
+
+        # Configuración de seguridad - permitir contenido que podría ser bloqueado por defecto
+        self.safety_settings = {
+            HarmCategory.HARM_CATEGORY_HATE_SPEECH: HarmBlockThreshold.BLOCK_NONE,
+            HarmCategory.HARM_CATEGORY_HARASSMENT: HarmBlockThreshold.BLOCK_NONE,
+            HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT: HarmBlockThreshold.BLOCK_NONE,
+            HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT: HarmBlockThreshold.BLOCK_NONE,
+        }
+
+    def create_response(self,
+                        model: str,
+                        input: List[Dict],
+                        previous_response_id: Optional[str] = None,
+                        context_history: Optional[List[Dict]] = None,
+                        tools: Optional[List[Dict]] = None,
+                        text: Optional[Dict] = None,
+                        reasoning: Optional[Dict] = None,
+                        tool_choice: str = "auto",
+                        ) -> LLMResponse:
+        """Llamada a la API de Gemini y mapeo a estructura común"""
+        try:
+            # Inicializar el modelo de Gemini usando el cliente configurado
+            gemini_model = self.client.GenerativeModel(
+                model_name=self._map_model_name(model),
+                safety_settings=self.safety_settings
+            )
+
+            # Preparar el contenido para Gemini
+            if context_history:
+                # Concatenar el historial de conversación con el input actual
+                contents = self._prepare_gemini_contents(context_history + input)
+            else:
+                # Usar solo el input actual si no hay historial
+                contents = self._prepare_gemini_contents(input)
+
+            # Preparar herramientas si están disponibles
+            gemini_tools = self._prepare_gemini_tools(tools) if tools else None
+
+            # Configurar generación
+            generation_config = self._prepare_generation_config(text, tool_choice)
+
+            # Llamar a Gemini
+            if gemini_tools:
+                # Con herramientas
+                response = gemini_model.generate_content(
+                    contents,
+                    tools=gemini_tools,
+                    generation_config=generation_config
+                )
+            else:
+                # Sin herramientas
+                response = gemini_model.generate_content(
+                    contents,
+                    generation_config=generation_config
+                )
+
+            # map the answer to a common structure
+            llm_response = self._map_gemini_response(response, model)
+
+            # add the model answer to the history
+            if context_history and llm_response.output_text:
+                context_history.append(
+                    {
+                        'role': 'assistant',
+                        'context': llm_response.output_text
+                    }
+                )
+
+            return llm_response
+
+        except Exception as e:
+            error_message = f"Error calling Gemini API: {str(e)}"
+            logging.error(error_message)
+
+            # handle gemini specific errors
+            if "quota" in str(e).lower():
+                error_message = "Se ha excedido la cuota de la API de Gemini"
+            elif "blocked" in str(e).lower():
+                error_message = "El contenido fue bloqueado por las políticas de seguridad de Gemini"
+            elif "token" in str(e).lower():
+                error_message = "Tu consulta supera el límite de contexto de Gemini"
+
+            raise IAToolkitException(IAToolkitException.ErrorType.LLM_ERROR, error_message)
+
+    # ... rest of the methods keep the same ...
+    def _map_model_name(self, model: str) -> str:
+        """Mapear nombre del modelo a formato de Gemini"""
+        model_mapping = {
+            "gemini-pro": "gemini-2.5-pro",
+            "gemini": "gemini-2.5-pro",
+            "gemini-1.5": "gemini-2.5-pro",
+            "gemini-flash": "gemini-1.5-flash",
+            "gemini-2.0": "gemini-2.0-flash-exp"
+        }
+        return model_mapping.get(model.lower(), model)
+
+    def _prepare_gemini_contents(self, input: List[Dict]) -> List[Dict]:
+        """Convertir mensajes de formato OpenAI a formato Gemini"""
+        gemini_contents = []
+
+        for message in input:
+            if message.get("role") == "system":
+                gemini_contents.append({
+                    "role": "user",
+                    "parts": [{"text": f"[INSTRUCCIONES DEL SISTEMA]\n{message.get('content', '')}"}]
+                })
+            elif message.get("role") == "user":
+                gemini_contents.append({
+                    "role": "user",
+                    "parts": [{"text": message.get("content", "")}]
+                })
+            elif message.get("type") == "function_call_output":
+                gemini_contents.append({
+                    "role": "function",
+                    "parts": [{
+                        "function_response": {
+                            "name": "tool_result",
+                            "response": {"output": message.get("output", "")}
+                        }
+                    }]
+                })
+
+        return gemini_contents
+
+    def _prepare_gemini_tools(self, tools: List[Dict]) -> List[Dict]:
+        """Convertir herramientas de formato OpenAI a formato Gemini"""
+        if not tools:
+            return None
+
+        function_declarations = []
+        for i, tool in enumerate(tools):
+            # Verificar estructura básica
+            tool_type = tool.get("type")
+
+            if tool_type != "function":
+                logging.warning(f"Herramienta {i} no es de tipo 'function': {tool_type}")
+                continue
+
+            # Extraer datos de la herramienta (estructura plana)
+            function_name = tool.get("name")
+            function_description = tool.get("description", "")
+            function_parameters = tool.get("parameters", {})
+
+            # Verificar si el nombre existe y no está vacío
+            if not function_name or not isinstance(function_name, str) or not function_name.strip():
+                logging.error(f"PROBLEMA: Herramienta {i} sin nombre válido")
+                continue
+
+            # Preparar la declaración de función para Gemini
+            gemini_function = {
+                "name": function_name,
+                "description": function_description,
+            }
+
+            # Agregar parámetros si existen y limpiar campos específicos de OpenAI
+            if function_parameters:
+                clean_parameters = self._clean_openai_specific_fields(function_parameters)
+                gemini_function["parameters"] = clean_parameters
+
+            function_declarations.append(gemini_function)
+
+        if function_declarations:
+            final_tools = [{
+                "function_declarations": function_declarations
+            }]
+
+            # Log de la estructura final para debug
+            # logging.info("Estructura final de herramientas para Gemini:")
+            # logging.info(f"{json.dumps(final_tools, indent=2)}")
+
+            return final_tools
+
+        return None
+
+
+    def _clean_openai_specific_fields(self, parameters: Dict) -> Dict:
+        """Limpiar campos específicos de OpenAI que Gemini no entiende"""
+        clean_params = {}
+
+        # Campos permitidos por Gemini según su Schema protobuf
+        # Estos son los únicos campos que Gemini acepta en sus esquemas
+        allowed_fields = {
+            "type",  # Tipo de datos: string, number, object, array, boolean
+            "properties",  # Para objetos: define las propiedades
+            "required",  # Array de propiedades requeridas
+            "items",  # Para arrays: define el tipo de elementos
+            "description",  # Descripción del campo
+            "enum",  # Lista de valores permitidos
+            # Gemini NO soporta estos campos comunes de JSON Schema:
+            # "pattern", "format", "minimum", "maximum", "minItems", "maxItems",
+            # "minLength", "maxLength", "additionalProperties", "strict"
+        }
+
+        for key, value in parameters.items():
+            if key in allowed_fields:
+                if key == "properties" and isinstance(value, dict):
+                    # Limpiar recursivamente las propiedades
+                    clean_props = {}
+                    for prop_name, prop_def in value.items():
+                        if isinstance(prop_def, dict):
+                            clean_props[prop_name] = self._clean_openai_specific_fields(prop_def)
+                        else:
+                            clean_props[prop_name] = prop_def
+                    clean_params[key] = clean_props
+                elif key == "items" and isinstance(value, dict):
+                    # Limpiar recursivamente los items de array
+                    clean_params[key] = self._clean_openai_specific_fields(value)
+                else:
+                    clean_params[key] = value
+            else:
+                logging.debug(f"Campo '{key}' removido (no soportado por Gemini)")
+
+        return clean_params
+
+    def _prepare_generation_config(self, text: Optional[Dict], tool_choice: str) -> Dict:
+        """Preparar configuración de generación para Gemini"""
+        config = {"candidate_count": 1}
+
+        if text:
+            if "temperature" in text:
+                config["temperature"] = float(text["temperature"])
+            if "max_tokens" in text:
+                config["max_output_tokens"] = int(text["max_tokens"])
+            if "top_p" in text:
+                config["top_p"] = float(text["top_p"])
+
+        return config
+
+    def _map_gemini_response(self, gemini_response, model: str) -> LLMResponse:
+        """Mapear respuesta de Gemini a estructura común"""
+        response_id = str(uuid.uuid4())
+        output_text = ""
+        tool_calls = []
+
+        if gemini_response.candidates and len(gemini_response.candidates) > 0:
+            candidate = gemini_response.candidates[0]
+
+            for part in candidate.content.parts:
+                if hasattr(part, 'text') and part.text:
+                    output_text += part.text
+                elif hasattr(part, 'function_call') and part.function_call:
+                    func_call = part.function_call
+                    tool_calls.append(ToolCall(
+                        call_id=f"call_{uuid.uuid4().hex[:8]}",
+                        type="function_call",
+                        name=func_call.name,
+                        arguments=json.dumps(MessageToDict(func_call._pb).get('args', {}))
+                    ))
+
+        # Determinar status
+        status = "completed"
+        if gemini_response.candidates:
+            candidate = gemini_response.candidates[0]
+            if hasattr(candidate, 'finish_reason'):
+                # Manejar finish_reason tanto como objeto con .name como entero/enum directo
+                finish_reason = candidate.finish_reason
+
+                # Si finish_reason tiene un atributo .name, usarlo
+                if hasattr(finish_reason, 'name'):
+                    finish_reason_name = finish_reason.name
+                else:
+                    # Si es un entero o enum directo, convertirlo a string
+                    finish_reason_name = str(finish_reason)
+
+                if finish_reason_name in ["SAFETY", "RECITATION", "3", "4"]:  # Agregar valores numéricos también
+                    status = "blocked"
+                elif finish_reason_name in ["MAX_TOKENS", "LENGTH", "2"]:  # Agregar valores numéricos también
+                    status = "length_exceeded"
+
+        # Calcular usage de tokens
+        usage = self._extract_usage_metadata(gemini_response)
+
+        # Estimación básica si no hay datos de usage
+        if usage.total_tokens == 0:
+            estimated_output_tokens = len(output_text) // 4
+            usage = Usage(
+                input_tokens=0,
+                output_tokens=estimated_output_tokens,
+                total_tokens=estimated_output_tokens
+            )
+
+        return LLMResponse(
+            id=response_id,
+            model=model,
+            status=status,
+            output_text=output_text,
+            output=tool_calls,
+            usage=usage
+        )
+
+    def _extract_usage_metadata(self, gemini_response) -> Usage:
+        """Extraer información de uso de tokens de manera segura"""
+        input_tokens = 0
+        output_tokens = 0
+        total_tokens = 0
+
+        try:
+            # Verificar si existe usage_metadata
+            if hasattr(gemini_response, 'usage_metadata') and gemini_response.usage_metadata:
+                usage_metadata = gemini_response.usage_metadata
+
+                # Acceder a los atributos directamente, no con .get()
+                if hasattr(usage_metadata, 'prompt_token_count'):
+                    input_tokens = usage_metadata.prompt_token_count
+                if hasattr(usage_metadata, 'candidates_token_count'):
+                    output_tokens = usage_metadata.candidates_token_count
+                if hasattr(usage_metadata, 'total_token_count'):
+                    total_tokens = usage_metadata.total_token_count
+
+        except Exception as e:
+            logging.warning(f"No se pudo extraer usage_metadata de Gemini: {e}")
+
+        # Si no hay datos de usage o son cero, hacer estimación básica
+        if total_tokens == 0 and output_tokens == 0:
+            # Obtener texto de salida para estimación
+            output_text = ""
+            if (hasattr(gemini_response, 'candidates') and
+                    gemini_response.candidates and
+                    len(gemini_response.candidates) > 0):
+
+                candidate = gemini_response.candidates[0]
+                if hasattr(candidate, 'content') and hasattr(candidate.content, 'parts'):
+                    for part in candidate.content.parts:
+                        if hasattr(part, 'text') and part.text:
+                            output_text += part.text
+
+            # Estimación básica (4 caracteres por token aproximadamente)
+            estimated_output_tokens = len(output_text) // 4 if output_text else 0
+            output_tokens = estimated_output_tokens
+            total_tokens = estimated_output_tokens
+
+        return Usage(
+            input_tokens=input_tokens,
+            output_tokens=output_tokens,
+            total_tokens=total_tokens
+        )

iatoolkit/infra/google_chat_app.py

@@ -0,0 +1,57 @@
+# Copyright (c) 2024 Fernando Libedinsky
+# Product: IAToolkit
+#
+# IAToolkit is open source software.
+
+from injector import inject
+from iatoolkit.infra.call_service import CallServiceClient
+import logging
+import os
+from typing import Dict, Any
+
+
+class GoogleChatApp:
+    @inject
+    def __init__(self, call_service: CallServiceClient):
+        self.call_service = call_service
+
+    def send_message(self, message_data: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Sends a message to Google Chat.
+
+        Args:
+            message_data: Complete message data structure with type, space, and message
+
+        Returns:
+            Dict with the service response
+        """
+        try:
+            # get the bot URL from environment variables
+            bot_url = os.getenv('GOOGLE_CHAT_BOT_URL')
+            if not bot_url:
+                raise Exception('GOOGLE_CHAT_BOT_URL no está configurada en las variables de entorno')
+
+            # send the POST request with the complete message data
+            response, status_code = self.call_service.post(bot_url, message_data)
+
+            if status_code == 200:
+                return {
+                    "success": True,
+                    "message": "Mensaje enviado correctamente",
+                    "response": response
+                }
+            else:
+                logging.error(f"Error al enviar mensaje a Google Chat. Status: {status_code}, Response: {response}")
+                return {
+                    "success": False,
+                    "message": f"Error al enviar mensaje. Status: {status_code}",
+                    "response": response
+                }
+
+        except Exception as e:
+            logging.exception(f"Error inesperado al enviar mensaje a Google Chat: {e}")
+            return {
+                "success": False,
+                "message": f"Error interno del servidor: {str(e)}",
+                "response": None
+            }