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

iatoolkit/infra/call_service.py

@@ -0,0 +1,140 @@
+# Copyright (c) 2024 Fernando Libedinsky
+# Product: IAToolkit
+#
+# IAToolkit is open source software.
+
+from iatoolkit.common.exceptions import IAToolkitException
+from injector import inject
+# call_service.py
+import requests
+from typing import Optional, Dict, Any, Tuple, Union
+from requests import RequestException
+
+class CallServiceClient:
+    @inject
+    def __init__(self):
+        self.headers = {'Content-Type': 'application/json'}
+
+    def _merge_headers(self, extra: Optional[Dict[str, str]]) -> Dict[str, str]:
+        if not extra:
+            return dict(self.headers)
+        merged = dict(self.headers)
+        merged.update(extra)
+        return merged
+
+    def _normalize_timeout(self, timeout: Union[int, float, Tuple[int, int], Tuple[float, float]]) -> Tuple[float, float]:
+        # Si pasan un solo número → (connect, read) = (10, timeout)
+        if isinstance(timeout, (int, float)):
+            return (10, float(timeout))
+        return (float(timeout[0]), float(timeout[1]))
+
+    def _deserialize_response(self, response) -> Tuple[Any, int]:
+        try:
+            return response.json(), response.status_code
+        except ValueError:
+            # No es JSON → devolver texto
+            return response.text, response.status_code
+
+    def get(
+        self,
+        endpoint: str,
+        params: Optional[Dict[str, Any]] = None,
+        headers: Optional[Dict[str, str]] = None,
+        timeout: Union[int, float, Tuple[int, int]] = 10
+    ):
+        try:
+            response = requests.get(
+                endpoint,
+                params=params,
+                headers=self._merge_headers(headers),
+                timeout=self._normalize_timeout(timeout)
+            )
+        except RequestException as e:
+            raise IAToolkitException(IAToolkitException.ErrorType.REQUEST_ERROR, str(e))
+        return self._deserialize_response(response)
+
+    def post(
+        self,
+        endpoint: str,
+        json_dict: Optional[Dict[str, Any]] = None,
+        params: Optional[Dict[str, Any]] = None,
+        headers: Optional[Dict[str, str]] = None,
+        timeout: Union[int, float, Tuple[int, int]] = 10
+    ):
+        try:
+            response = requests.post(
+                endpoint,
+                params=params,
+                json=json_dict,
+                headers=self._merge_headers(headers),
+                timeout=self._normalize_timeout(timeout)
+            )
+        except RequestException as e:
+            raise IAToolkitException(IAToolkitException.ErrorType.REQUEST_ERROR, str(e))
+        return self._deserialize_response(response)
+
+    def put(
+        self,
+        endpoint: str,
+        json_dict: Optional[Dict[str, Any]] = None,
+        params: Optional[Dict[str, Any]] = None,
+        headers: Optional[Dict[str, str]] = None,
+        timeout: Union[int, float, Tuple[int, int]] = 10
+    ):
+        try:
+            response = requests.put(
+                endpoint,
+                params=params,
+                json=json_dict,
+                headers=self._merge_headers(headers),
+                timeout=self._normalize_timeout(timeout)
+            )
+        except RequestException as e:
+            raise IAToolkitException(IAToolkitException.ErrorType.REQUEST_ERROR, str(e))
+        return self._deserialize_response(response)
+
+    def delete(
+        self,
+        endpoint: str,
+        json_dict: Optional[Dict[str, Any]] = None,
+        params: Optional[Dict[str, Any]] = None,
+        headers: Optional[Dict[str, str]] = None,
+        timeout: Union[int, float, Tuple[int, int]] = 10
+    ):
+        try:
+            response = requests.delete(
+                endpoint,
+                params=params,
+                json=json_dict,
+                headers=self._merge_headers(headers),
+                timeout=self._normalize_timeout(timeout)
+            )
+        except RequestException as e:
+            raise IAToolkitException(IAToolkitException.ErrorType.REQUEST_ERROR, str(e))
+        return self._deserialize_response(response)
+
+    def post_files(
+        self,
+        endpoint: str,
+        data: Dict[str, Any],
+        params: Optional[Dict[str, Any]] = None,
+        headers: Optional[Dict[str, str]] = None,
+        timeout: Union[int, float, Tuple[int, int]] = 10
+    ):
+        # Para multipart/form-data no imponemos Content-Type por defecto
+        merged_headers = dict(self.headers)
+        merged_headers.pop('Content-Type', None)
+        if headers:
+            merged_headers.update(headers)
+
+        try:
+            response = requests.post(
+                endpoint,
+                params=params,
+                files=data,
+                headers=merged_headers,
+                timeout=self._normalize_timeout(timeout)
+            )
+        except RequestException as e:
+            raise IAToolkitException(IAToolkitException.ErrorType.REQUEST_ERROR, str(e))
+        return self._deserialize_response(response)

iatoolkit/infra/connectors/__init__.py

@@ -0,0 +1,5 @@
+# Copyright (c) 2024 Fernando Libedinsky
+# Product: IAToolkit
+#
+# IAToolkit is open source software.
+

iatoolkit/infra/connectors/file_connector.py

@@ -0,0 +1,17 @@
+# Copyright (c) 2024 Fernando Libedinsky
+# Product: IAToolkit
+#
+# IAToolkit is open source software.
+
+from abc import ABC, abstractmethod
+from typing import List
+
+
+class FileConnector(ABC):
+    @abstractmethod
+    def list_files(self) -> List[str]:
+        pass
+
+    @abstractmethod
+    def get_file_content(self, file_path: str) -> bytes:
+        pass

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/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
+            }