iatoolkit 0.108.1__tar.gz → 1.21.0__tar.gz

{iatoolkit-0.108.1/src/iatoolkit.egg-info → iatoolkit-1.21.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: iatoolkit
-Version: 0.108.1
+Version: 1.21.0
 Summary: IAToolkit
 Author: Fernando Libedinsky
 License-Expression: MIT

{iatoolkit-0.108.1 → iatoolkit-1.21.0}/src/iatoolkit/__init__.py

@@ -3,7 +3,7 @@
 #
 # IAToolkit is open source software.
 
-__version__ = "0.108.1"
+__version__ = "1.21.0"
 
 # Expose main classes and functions at the top level of the package
 
@@ -17,9 +17,9 @@ from .base_company import BaseCompany
 # --- Services ---
 from iatoolkit.services.query_service import QueryService
 from iatoolkit.services.document_service import DocumentService
-from iatoolkit.services.search_service import SearchService
+from iatoolkit.services.knowledge_base_service import KnowledgeBaseService
 from iatoolkit.services.sql_service import SqlService
-from iatoolkit.services.load_documents_service import LoadDocumentsService
+from iatoolkit.services.ingestor_service import IngestorService
 from iatoolkit.infra.call_service import CallServiceClient
 from iatoolkit.services.profile_service import ProfileService
 from iatoolkit.services.mail_service import MailService
@@ -36,8 +36,8 @@ __all__ = [
     'QueryService',
     'SqlService',
     'DocumentService',
-    'SearchService',
-    'LoadDocumentsService',
+    'KnowledgeBaseService',
+    'IngestorService',
     'CallServiceClient',
     'ProfileService',
     'MailService',

{iatoolkit-0.108.1 → iatoolkit-1.21.0}/src/iatoolkit/cli_commands.py

@@ -7,6 +7,7 @@ import click
 import logging
 from iatoolkit.core import IAToolkit
 from iatoolkit.services.profile_service import ProfileService
+from iatoolkit.services.prompt_service import PromptService
 
 
 def register_core_commands(app):
@@ -32,6 +33,21 @@ def register_core_commands(app):
             logging.exception(e)
             click.echo(f"❌ unexpectd error during the configuration: {e}")
 
+    @app.cli.command("init-company")
+    @click.argument("company_short_name")
+    def init_company(company_short_name: str):
+        """⚙️ Bootstrap a new company."""
+        try:
+            prompt_service = IAToolkit.get_instance().get_injector().get(PromptService)
+            click.echo(f"🔑 Bootstrap company: '{company_short_name}'...")
+            result = prompt_service.register_system_prompts(company_short_name)
+
+            if result:
+                click.echo("✅ System prompts registered successfully!")
+        except Exception as e:
+            logging.exception(e)
+            click.echo(f"❌ unexpected error during the configuration: {e}")
+
     @app.cli.command("encrypt-key")
     @click.argument("key")
     def encrypt_llm_api_key(key: str):

{iatoolkit-0.108.1 → iatoolkit-1.21.0}/src/iatoolkit/common/interfaces/database_provider.py

@@ -9,14 +9,19 @@ class DatabaseProvider(abc.ABC):
 
     # --- Schema Methods ---
     @abc.abstractmethod
-    def get_all_table_names(self) -> List[str]:
-        pass
-
-    @abc.abstractmethod
-    def get_table_description(self,
-                              table_name: str,
-                              schema_object_name: str | None = None,
-                              exclude_columns: List[str] | None = None) -> str:
+    def get_database_structure(self) -> dict:
+        """
+        Returns the structure of the database (tables, columns, types)
+        Format:
+        {
+            "table_name": {
+                "columns": [
+                    {"name": "col1", "type": "VARCHAR", "nullable": True, "pk": True},
+                    ...
+                ]
+            }
+        }
+        """
         pass
 
     # --- Execution Methods ---

{iatoolkit-0.108.1 → iatoolkit-1.21.0}/src/iatoolkit/common/routes.py

@@ -24,13 +24,16 @@ def register_views(app):
     from iatoolkit.views.profile_api_view import UserLanguageApiView
     from iatoolkit.views.embedding_api_view import EmbeddingApiView
     from iatoolkit.views.login_view import LoginView, FinalizeContextView
-    from iatoolkit.views.load_company_configuration_api_view import LoadCompanyConfigurationApiView
+    from iatoolkit.views.configuration_api_view import ConfigurationApiView, ValidateConfigurationApiView
     from iatoolkit.views.logout_api_view import LogoutApiView
     from iatoolkit.views.home_view import HomeView
     from iatoolkit.views.chat_view import ChatView
     from iatoolkit.views.static_page_view import StaticPageView
     from iatoolkit.views.root_redirect_view import RootRedirectView
     from iatoolkit.views.users_api_view import UsersApiView
+    from iatoolkit.views.rag_api_view import RagApiView
+    from iatoolkit.views.categories_api_view import CategoriesApiView
+    from iatoolkit.views.ingestion_api_view import IngestionApiView
 
     # assign root '/' to our new redirect logic
     app.add_url_rule('/home', view_func=RootRedirectView.as_view('root_redirect'))
@@ -84,24 +87,73 @@ def register_views(app):
     # can be used also for executing iatoolkit prompts
     app.add_url_rule('/<company_short_name>/api/llm_query', view_func=LLMQueryApiView.as_view('llm_query_api'))
 
-    # open the promt directory
-    app.add_url_rule('/<company_short_name>/api/prompts', view_func=PromptApiView.as_view('prompt'))
-
+    # Categories Endpoint
+    app.add_url_rule('/<company_short_name>/api/categories',
+                     view_func=CategoriesApiView.as_view('categories_api'),
+                     methods=['GET', 'POST'])
+
+    # open the promt directory and specific prompt management
+    prompt_view = PromptApiView.as_view('prompt')
+    app.add_url_rule('/<company_short_name>/api/prompts',
+                     view_func=prompt_view,
+                     methods=['GET', 'POST'],
+                     defaults={'prompt_name': None})
+
+    app.add_url_rule('/<company_short_name>/api/prompts/<prompt_name>',
+                     view_func=prompt_view,
+                     methods=['GET', 'POST','PUT', 'DELETE'])
     # toolbar buttons
     app.add_url_rule('/<company_short_name>/api/feedback', view_func=UserFeedbackApiView.as_view('feedback'))
     app.add_url_rule('/<company_short_name>/api/history', view_func=HistoryApiView.as_view('history'))
     app.add_url_rule('/<company_short_name>/api/help-content', view_func=HelpContentApiView.as_view('help-content'))
 
+    # --- RAG API Routes ---
+    rag_view = RagApiView.as_view('rag_api')
+
+    # 1. List Files (POST for filters)
+    app.add_url_rule('/api/rag/<company_short_name>/files',
+                     view_func=rag_view,
+                     methods=['POST'],
+                     defaults={'action': 'list_files'})
+
+    # 2. Delete File
+    app.add_url_rule('/api/rag/<company_short_name>/files/<int:document_id>',
+                     view_func=rag_view,
+                     methods=['DELETE'],
+                     defaults={'action': 'delete_file'})
+
+    # 3. Search Lab
+    app.add_url_rule('/api/rag/<company_short_name>/search',
+                     view_func=rag_view,
+                     methods=['POST'],
+                     defaults={'action': 'search'})
+
+    # 4. Get File Content (View/Download)
+    app.add_url_rule('/api/rag/<company_short_name>/files/<int:document_id>/content',
+                     view_func=rag_view,
+                     methods=['GET'],
+                     defaults={'action': 'get_file_content'})
+
     # this endpoint is for upload documents into the vector store (api-key)
     app.add_url_rule('/api/load-document', view_func=LoadDocumentApiView.as_view('load-document'), methods=['POST'])
 
+    # Document ingestion
+    ingestion_view = IngestionApiView.as_view('ingestion_api')
+    app.add_url_rule('/<company_short_name>/api/ingestion-sources', view_func=ingestion_view, methods=['GET', 'POST'])
+    app.add_url_rule('/<company_short_name>/api/ingestion-sources/<int:source_id>/<action>', view_func=ingestion_view, methods=['POST'])
+
     # this endpoint is for generating embeddings for a given text
     app.add_url_rule('/<company_short_name>/api/embedding',
                      view_func=EmbeddingApiView.as_view('embedding_api'))
 
     # company configuration
-    app.add_url_rule('/<company_short_name>/api/load_configuration',
-                     view_func=LoadCompanyConfigurationApiView.as_view('load-configuration'))
+    app.add_url_rule('/<company_short_name>/api/configuration',
+                     view_func=ConfigurationApiView.as_view('configuration'),
+                     methods=['GET', 'POST', 'PATCH'],)
+
+    app.add_url_rule('/<company_short_name>/api/configuration/validate',
+                     view_func=ValidateConfigurationApiView.as_view('configuration-validate'),
+                     methods=['GET'])
 
     # static pages
     # url: /pages/foundation o /pages/implementation_plan

{iatoolkit-0.108.1 → iatoolkit-1.21.0}/src/iatoolkit/common/util.py

@@ -162,128 +162,33 @@ class Utility:
         Parses a YAML string into a dictionary securely.
         """
         try:
+            if not yaml_content:
+                return {}
+
+            # Normalizar tabulaciones que rompen YAML
             yaml_content = yaml_content.replace('\t', '  ')
-            return yaml.safe_load(yaml_content) or {}
+
+            loaded = yaml.safe_load(yaml_content)
+            # Asegurar que siempre retornamos un dict, incluso si el YAML es una lista o escalar
+            return loaded if isinstance(loaded, dict) else {}
         except yaml.YAMLError as e:
             logging.error(f"Error parsing YAML string: {e}")
             return {}
 
-    def generate_context_for_schema(self, entity_name: str, schema_file: str = None, schema: dict = {}) -> str:
-        if not schema_file and not schema:
-            raise IAToolkitException(IAToolkitException.ErrorType.FILE_IO_ERROR,
-                               f'No se pudo obtener schema de la entidad: {entity_name}')
-
-        try:
-            if schema_file:
-                schema = self.load_schema_from_yaml(schema_file)
-            table_schema = self.generate_schema_table(schema)
-            return table_schema
-        except Exception as e:
-            logging.exception(e)
-            raise IAToolkitException(IAToolkitException.ErrorType.FILE_IO_ERROR,
-                               f'No se pudo leer el schema de la entidad: {entity_name}') from e
-
-    def generate_schema_table(self, schema: dict) -> str:
+    def dump_yaml_to_string(self, config: dict) -> str:
         """
-        Genera una descripción detallada y formateada en Markdown de un esquema.
-        Esta función está diseñada para manejar el formato específico de nuestros
-        archivos YAML, donde el esquema se define bajo una única clave raíz.
+        Dumps a dictionary into a YAML formatted string.
+        It uses default flow style False to ensure block format (readable YAML).
         """
-        if not schema or not isinstance(schema, dict):
-            return ""
-
-        # Asumimos que el YAML tiene una única clave raíz que nombra a la entidad.
-        if len(schema) == 1:
-            root_name = list(schema.keys())[0]
-            root_details = schema[root_name]
-
-            if isinstance(root_details, dict):
-                # Las claves de metadatos describen el objeto en sí, no sus propiedades hijas.
-                METADATA_KEYS = ['description', 'type', 'format', 'items', 'properties']
-
-                # Las propiedades son las claves restantes en el diccionario.
-                properties = {
-                    k: v for k, v in root_details.items() if k not in METADATA_KEYS
-                }
-
-                # La descripción del objeto raíz.
-                root_description = root_details.get('description', '')
-
-                # Formatea las propiedades extraídas usando la función auxiliar recursiva.
-                formatted_properties = self._format_json_schema(properties, 0)
-
-                # Construcción del resultado final, incluyendo el nombre del objeto raíz.
-                output_parts = [f"\n\n### Objeto: `{root_name}`"]
-                if root_description:
-                    # Limpia la descripción para que se muestre bien
-                    cleaned_description = '\n'.join(line.strip() for line in root_description.strip().split('\n'))
-                    output_parts.append(f"{cleaned_description}")
-
-                if formatted_properties:
-                    output_parts.append(f"**Campos del objeto `{root_name}`:**\n{formatted_properties}")
-
-                return "\n".join(output_parts)
-
-        # Si el esquema (como tender_schema.yaml) no tiene un objeto raíz,
-        # se formatea directamente como una lista de propiedades.
-        return self._format_json_schema(schema, 0)
+        try:
+            # default_flow_style=False ensures lists and dicts are expanded (not inline like JSON)
+            # allow_unicode=True ensures characters like accents are preserved
+            return yaml.safe_dump(config, default_flow_style=False, allow_unicode=True, sort_keys=False)
+        except yaml.YAMLError as e:
+            logging.error(f"Error dumping YAML to string: {e}")
+            raise IAToolkitException(IAToolkitException.ErrorType.FILE_IO_ERROR,
+                                     f"Failed to generate YAML: {e}")
 
-    def _format_json_schema(self, properties: dict, indent_level: int) -> str:
-        """
-        Formatea de manera recursiva las propiedades de un esquema JSON/YAML.
-        """
-        output = []
-        indent_str = '  ' * indent_level
-
-        for name, details in properties.items():
-            if not isinstance(details, dict):
-                continue
-
-            description = details.get('description', '')
-            data_type = details.get('type', 'any')
-            output.append(f"{indent_str}- **`{name.lower()}`** ({data_type}): {description}")
-
-            child_indent_str = '  ' * (indent_level + 1)
-
-            # Manejo de 'oneOf' para mostrar valores constantes
-            if 'oneOf' in details:
-                for item in details['oneOf']:
-                    if 'const' in item:
-                        const_desc = item.get('description', '')
-                        output.append(f"{child_indent_str}- `{item['const']}`: {const_desc}")
-
-            # Manejo de 'items' para arrays
-            if 'items' in details:
-                items_details = details.get('items', {})
-                if isinstance(items_details, dict):
-                    item_description = items_details.get('description')
-                    if item_description:
-                        # Limpiamos y añadimos la descripción del item
-                        cleaned_description = '\n'.join(
-                            f"{line.strip()}" for line in item_description.strip().split('\n')
-                        )
-                        output.append(
-                            f"{child_indent_str}*Descripción de los elementos del array:*\n{child_indent_str}{cleaned_description}")
-
-                    if 'properties' in items_details:
-                        nested_properties = self._format_json_schema(items_details['properties'], indent_level + 1)
-                        output.append(nested_properties)
-
-            # Manejo de 'properties' para objetos anidados estándar
-            if 'properties' in details:
-                nested_properties = self._format_json_schema(details['properties'], indent_level + 1)
-                output.append(nested_properties)
-
-            elif 'additionalProperties' in details and 'properties' in details.get('additionalProperties', {}):
-                # Imprime un marcador de posición para la clave dinámica.
-                output.append(
-                    f"{child_indent_str}- **[*]** (object): Las claves de este objeto son dinámicas (ej. un ID).")
-                # Procesa las propiedades del objeto anidado.
-                nested_properties = self._format_json_schema(details['additionalProperties']['properties'],
-                                                             indent_level + 2)
-                output.append(nested_properties)
-
-        return '\n'.join(output)
 
     def load_markdown_context(self, filepath: str) -> str:
         with open(filepath, 'r', encoding='utf-8') as f:

{iatoolkit-0.108.1 → iatoolkit-1.21.0}/src/iatoolkit/core.py

@@ -58,6 +58,7 @@ class IAToolkit:
         self._injector = Injector()         # init empty injector
         self.version = IATOOLKIT_VERSION
         self.license = "Community Edition"
+        self.is_community = True
 
     @classmethod
     def get_instance(cls) -> 'IAToolkit':
@@ -321,7 +322,7 @@ class IAToolkit:
         from iatoolkit.services.prompt_service import PromptService
         from iatoolkit.services.excel_service import ExcelService
         from iatoolkit.services.mail_service import MailService
-        from iatoolkit.services.load_documents_service import LoadDocumentsService
+        from iatoolkit.services.ingestor_service import IngestorService
         from iatoolkit.services.profile_service import ProfileService
         from iatoolkit.services.jwt_service import JWTService
         from iatoolkit.services.dispatcher_service import Dispatcher
@@ -335,6 +336,7 @@ class IAToolkit:
         from iatoolkit.services.llm_client_service import llmClient
         from iatoolkit.services.auth_service import AuthService
         from iatoolkit.services.sql_service import SqlService
+        from iatoolkit.services.knowledge_base_service import KnowledgeBaseService
 
         binder.bind(QueryService, to=QueryService)
         binder.bind(BenchmarkService, to=BenchmarkService)
@@ -342,7 +344,7 @@ class IAToolkit:
         binder.bind(PromptService, to=PromptService)
         binder.bind(ExcelService, to=ExcelService)
         binder.bind(MailService, to=MailService)
-        binder.bind(LoadDocumentsService, to=LoadDocumentsService)
+        binder.bind(IngestorService, to=IngestorService)
         binder.bind(ProfileService, to=ProfileService)
         binder.bind(JWTService, to=JWTService)
         binder.bind(Dispatcher, to=Dispatcher)
@@ -356,6 +358,7 @@ class IAToolkit:
         binder.bind(llmClient, to=llmClient)
         binder.bind(AuthService, to=AuthService)
         binder.bind(SqlService, to=SqlService)
+        binder.bind(KnowledgeBaseService, to=KnowledgeBaseService)
 
     def _bind_infrastructure(self, binder: Binder):
         from iatoolkit.infra.llm_proxy import LLMProxy

iatoolkit-1.21.0/src/iatoolkit/infra/connectors/file_connector.py

@@ -0,0 +1,28 @@
+# Copyright (c) 2024 Fernando Libedinsky
+# Product: IAToolkit
+#
+# IAToolkit is open source software.
+
+from abc import ABC, abstractmethod
+from typing import List, Optional
+
+
+class FileConnector(ABC):
+    @abstractmethod
+    def list_files(self) -> List[str]:
+        pass
+
+    @abstractmethod
+    def get_file_content(self, file_path: str) -> bytes:
+        pass
+
+    @abstractmethod
+    def delete_file(self, file_path: str) -> None:
+        pass
+
+    @abstractmethod
+    def upload_file(self, file_path: str, content: bytes, content_type: str = None) -> None:
+        pass
+
+    def generate_presigned_url(self, file_path: str, expiration: int = 3600) -> Optional[str]:
+        return None

{iatoolkit-0.108.1 → iatoolkit-1.21.0}/src/iatoolkit/infra/connectors/file_connector_factory.py

@@ -1,29 +1,19 @@
-# Copyright (c) 2024 Fernando Libedinsky
-# Product: IAToolkit
-#
-# IAToolkit is open source software.
-
+# ... existing code ...
+import os
+from typing import Dict
 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
-
+from iatoolkit.infra.connectors.google_drive_connector import GoogleDriveConnector
 
 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
-        }
+        Crea un conector basado en un diccionario de configuración.
+        Permite pasar credenciales explícitas en 'auth' o 'service_account_path',
+        o dejar que el conector use sus defaults.
         """
         connector_type = config.get('type')
 
@@ -31,27 +21,33 @@ class FileConnectorFactory:
             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')
-            }
+            # Permite inyectar auth ya resuelto, o usar defaults de entorno
+            auth = config.get('auth')
+            if not auth:
+                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', ''),
+                folder=config.get('folder', ''),
                 auth=auth
             )
 
         elif connector_type == 'gdrive':
-            return GoogleDriveConnector(config['folder_id'],
-                    'service_account.json')
+            return GoogleDriveConnector(
+                folder_id=config['folder_id'],
+                service_account_path=config.get('service_account', 'service_account.json')
+            )
 
-        elif connector_type == 'gcs':
+        elif connector_type in ['gcs', 'google_cloud_storage']:
             return GoogleCloudStorageConnector(
                 bucket_name=config['bucket'],
-                service_account_path=config.get('service_account', 'service_account.json')
+                service_account_path=config.get('service_account_path', 'service_account.json')
             )
 
         else:
-            raise ValueError(f"Unknown connector type: {connector_type}")
+            raise ValueError(f"Unknown connector type: {connector_type}")

{iatoolkit-0.108.1 → iatoolkit-1.21.0}/src/iatoolkit/infra/connectors/google_cloud_storage_connector.py

@@ -51,3 +51,17 @@ class GoogleCloudStorageConnector(FileConnector):
         file_buffer = blob.download_as_bytes()  # Descarga el contenido como bytes
 
         return file_buffer
+
+    def delete_file(self, file_path: str) -> None:
+        """
+        Elimina un archivo del bucket dado su path.
+        """
+        blob = self.bucket.blob(file_path)
+        blob.delete()
+
+    def upload_file(self, file_path: str, content: bytes, content_type: str = None) -> None:
+        """
+        Sube un archivo al bucket.
+        """
+        blob = self.bucket.blob(file_path)
+        blob.upload_from_string(content, content_type=content_type)

{iatoolkit-0.108.1 → iatoolkit-1.21.0}/src/iatoolkit/infra/connectors/google_drive_connector.py

@@ -5,7 +5,7 @@
 
 from iatoolkit.infra.connectors.file_connector import FileConnector
 from googleapiclient.discovery import build
-from googleapiclient.http import MediaIoBaseDownload
+from googleapiclient.http import MediaIoBaseDownload, MediaIoBaseUpload
 from google.oauth2.service_account import Credentials
 import io
 from typing import List
@@ -66,3 +66,34 @@ class GoogleDriveConnector(FileConnector):
             status, done = downloader.next_chunk()
 
         return file_buffer.getvalue()
+
+    def upload_file(self, file_path: str, content: bytes, content_type: str = None) -> None:
+        """
+        Sube un archivo a Google Drive.
+        Nota: 'file_path' en este contexto se interpreta como el nombre del archivo,
+        ya que GDrive usa IDs para carpetas. El archivo se subirá a la carpeta configurada (self.folder_id).
+        """
+        file_metadata = {
+            'name': file_path, # Usamos file_path como nombre
+            'parents': [self.folder_id]
+        }
+
+        media = MediaIoBaseUpload(io.BytesIO(content), mimetype=content_type, resumable=True)
+
+        self.drive_service.files().create(
+            body=file_metadata,
+            media_body=media,
+            fields='id'
+        ).execute()
+
+    def delete_file(self, file_path: str) -> None:
+        """
+        Elimina un archivo de Google Drive.
+        Nota: 'file_path' aquí DEBE ser el ID del archivo (fileId), no su nombre.
+        """
+        try:
+            self.drive_service.files().delete(fileId=file_path).execute()
+        except Exception:
+            # Si falla (ej: no existe), podríamos loguear o ignorar según diseño.
+            # Aquí asumimos propagación de error o manejo silencioso si no crítico.
+            pass

{iatoolkit-0.108.1 → iatoolkit-1.21.0}/src/iatoolkit/infra/connectors/local_file_connector.py

@@ -44,3 +44,25 @@ class LocalFileConnector(FileConnector):
         except Exception as e:
             raise IAToolkitException(IAToolkitException.ErrorType.FILE_IO_ERROR,
                                f"Error leyendo el archivo {file_path}: {e}")
+
+    def upload_file(self, file_path: str, content: bytes, content_type: str = None) -> None:
+        # Nota: file_path debe ser relativo al directorio raíz configurado
+        full_path = os.path.join(self.directory, file_path)
+
+        # Asegurar que el directorio destino existe
+        try:
+            os.makedirs(os.path.dirname(full_path), exist_ok=True)
+            with open(full_path, 'wb') as f:
+                f.write(content)
+        except Exception as e:
+            raise IAToolkitException(IAToolkitException.ErrorType.FILE_IO_ERROR,
+                                     f"Error escribiendo el archivo {file_path}: {e}")
+
+    def delete_file(self, file_path: str) -> None:
+        full_path = os.path.join(self.directory, file_path)
+        try:
+            if os.path.exists(full_path):
+                os.remove(full_path)
+        except Exception as e:
+            raise IAToolkitException(IAToolkitException.ErrorType.FILE_IO_ERROR,
+                                     f"Error eliminando el archivo {file_path}: {e}")

iatoolkit-1.21.0/src/iatoolkit/infra/connectors/s3_connector.py

@@ -0,0 +1,61 @@
+# 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, folder: str, auth: dict):
+        self.bucket = bucket
+        self.prefix = prefix
+        self.folder = folder
+        self.s3 = boto3.client('s3', **auth)
+
+    def list_files(self) -> List[dict]:
+        # list all the files as dictionaries, with keys:  'path', 'name' y 'metadata'.
+        prefix = f'{self.prefix}/{self.folder}/'
+        response = self.s3.list_objects_v2(Bucket=self.bucket, Prefix=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()
+
+    def delete_file(self, file_path: str) -> None:
+        self.s3.delete_object(Bucket=self.bucket, Key=file_path)
+
+    def upload_file(self, file_path: str, content: bytes, content_type: str = None) -> None:
+        # If the path doesn't start with the prefix, add it (optional, depends on your logic)'
+        # Assuming file_path is either a full path or relative to the root of the bucket for flexibility
+        full_path = file_path
+
+        extra_args = {}
+        if content_type:
+            extra_args['ContentType'] = content_type
+
+        self.s3.put_object(
+            Bucket=self.bucket,
+            Key=full_path,
+            Body=content,
+            **extra_args
+        )
+
+    def generate_presigned_url(self, file_path: str, expiration: int = 3600) -> str:
+        return self.s3.generate_presigned_url(
+            'get_object',
+            Params={'Bucket': self.bucket, 'Key': file_path},
+            ExpiresIn=expiration
+        )