iatoolkit 0.63.1__py3-none-any.whl → 0.67.0__py3-none-any.whl

iatoolkit/repositories/profile_repo.py

@@ -74,10 +74,6 @@ class ProfileRepo:
         if company:
             if company.parameters != new_company.parameters:
                 company.parameters = new_company.parameters
-            if company.branding != new_company.branding:
-                company.branding = new_company.branding
-            if company.onboarding_cards != new_company.onboarding_cards:
-                company.onboarding_cards = new_company.onboarding_cards
         else:
             # Si la compañía no existe, la añade a la sesión.
             self.session.add(new_company)

iatoolkit/services/auth_service.py

@@ -7,6 +7,7 @@ from flask import request
 from injector import inject
 from iatoolkit.services.profile_service import ProfileService
 from iatoolkit.services.jwt_service import JWTService
+from iatoolkit.services.i18n_service import I18nService
 from iatoolkit.repositories.database_manager import DatabaseManager
 from iatoolkit.repositories.models import AccessLog
 from flask import request
@@ -23,18 +24,20 @@ class AuthService:
     @inject
     def __init__(self, profile_service: ProfileService,
                  jwt_service: JWTService,
-                 db_manager: DatabaseManager
+                 db_manager: DatabaseManager,
+                 i18n_service: I18nService
                  ):
         self.profile_service = profile_service
         self.jwt_service = jwt_service
         self.db_manager = db_manager
+        self.i18n_service = i18n_service
 
     def login_local_user(self, company_short_name: str, email: str, password: str) -> dict:
         # try to autenticate a local user, register the event and return the result
         auth_response = self.profile_service.login(
             company_short_name=company_short_name,
             email=email,
-            password=password
+            password=password,
         )
 
         if not auth_response.get('success'):
@@ -66,7 +69,7 @@ class AuthService:
                 outcome='failure',
                 reason_code='JWT_INVALID'
             )
-            return {'success': False, 'error': 'Token inválido o expirado'}
+            return {'success': False, 'error': self.i18n_service.t('errors.auth.invalid_or_expired_token')}
 
         # 2. if token is valid, extract the user_identifier
         user_identifier = payload.get('user_identifier')
@@ -81,7 +84,7 @@ class AuthService:
             )
             return {'success': True, 'user_identifier': user_identifier}
         except Exception as e:
-            logging.error(f"Error al crear la sesión desde token para {user_identifier}: {e}")
+            logging.error(f"error creeating session for Token of {user_identifier}: {e}")
             self.log_access(
                 company_short_name=company_short_name,
                 auth_type='redeem_token',
@@ -89,7 +92,7 @@ class AuthService:
                 reason_code='SESSION_CREATION_FAILED',
                 user_identifier=user_identifier
             )
-            return {'success': False, 'error': 'No se pudo crear la sesión del usuario'}
+            return {'success': False, 'error': self.i18n_service.t('errors.auth.session_creation_failed')}
 
     def verify(self, anonymous: bool = False) -> dict:
         """
@@ -123,14 +126,15 @@ class AuthService:
             # --- Failure: No valid credentials found ---
             logging.info(f"Authentication required. No session cookie or API Key provided.")
             return {"success": False,
-                    "error_message": "Authentication required. No session cookie or API Key provided.",
+                    "error_message": self.i18n_service.t('errors.auth.authentication_required'),
                     "status_code": 401}
 
         # check if the api-key is valid and active
         api_key_entry = self.profile_service.get_active_api_key_entry(api_key)
         if not api_key_entry:
             logging.info(f"Invalid or inactive API Key {api_key}")
-            return {"success": False, "error_message": "Invalid or inactive API Key",
+            return {"success": False,
+                    "error_message": self.i18n_service.t('errors.auth.invalid_api_key'),
                     "status_code": 402}
 
         # get the company from the api_key_entry
@@ -141,7 +145,8 @@ class AuthService:
         user_identifier = data.get('user_identifier', '')
         if not anonymous and not user_identifier:
             logging.info(f"No user_identifier provided for API call.")
-            return {"success": False, "error_message": "No user_identifier provided for API call.",
+            return {"success": False,
+                    "error_message": self.i18n_service.t('errors.auth.no_user_identifier_api'),
                     "status_code": 403}
 
         return {
@@ -184,5 +189,5 @@ class AuthService:
             session.commit()
 
         except Exception as e:
-            logging.error(f"Fallo al escribir en AccessLog: {e}", exc_info=False)
+            logging.error(f"error writting to AccessLog: {e}", exc_info=False)
             session.rollback()

iatoolkit/services/branding_service.py

@@ -4,14 +4,17 @@
 # IAToolkit is open source software.
 
 from iatoolkit.repositories.models import Company
+from iatoolkit.services.configuration_service import ConfigurationService
+from injector import inject
 
 
 class BrandingService:
     """
-    Servicio centralizado que gestiona la configuración de branding.
+    Branding configuration for IAToolkit
     """
-
-    def __init__(self):
+    @inject
+    def __init__(self, config_service: ConfigurationService):
+        self.config_service = config_service
         """
         Define los estilos de branding por defecto para la aplicación.
         """
@@ -19,13 +22,16 @@ class BrandingService:
             # --- Estilos del Encabezado Principal ---
             "header_background_color": "#FFFFFF",
             "header_text_color": "#6C757D",
-            "primary_font_weight": "bold",
-            "primary_font_size": "1rem",
-            "secondary_font_weight": "600",
-            "secondary_font_size": "0.875rem",
-            "tertiary_font_weight": "normal",
-            "tertiary_font_size": "0.75rem",
-            "tertiary_opacity": "0.8",
+            "primary_font_weight": "600",
+            "primary_font_size": "1.2rem",
+            "secondary_font_weight": "400",
+            "secondary_font_size": "0.9rem",
+            "tertiary_font_weight": "300",
+            "tertiary_font_size": "0.8rem",
+            "tertiary_opacity": "0.7",
+
+            # headings
+            "brand_text_heading_color": "#334155",  # Gris pizarra por defecto
 
             # Estilos Globales de la Marca ---
             "brand_primary_color": "#0d6efd",  # Azul de Bootstrap por defecto
@@ -40,25 +46,27 @@ class BrandingService:
             "brand_danger_border": "#f5c2c7",  # Borde rojo intermedio
 
             # Estilos para Alertas Informativas ---
-            "brand_info_bg": "#cff4fc",  # Fondo celeste pálido
-            "brand_info_text": "#055160",  # Texto azul oscuro
-            "brand_info_border": "#b6effb",
+            "brand_info_bg": "#F0F4F8",         # Un fondo de gris azulado muy pálido
+            "brand_info_text": "#0d6efd",       # Texto en el color primario
+            "brand_info_border": "#D9E2EC",     # Borde de gris azulado pálido
 
             # Estilos para el Asistente de Prompts ---
             "prompt_assistant_bg": "#f8f9fa",
             "prompt_assistant_border": "#dee2e6",
-            "prompt_assistant_icon_color": "#6c757d",
             "prompt_assistant_button_bg": "#FFFFFF",
             "prompt_assistant_button_text": "#495057",
             "prompt_assistant_button_border": "#ced4da",
             "prompt_assistant_dropdown_bg": "#f8f9fa",
             "prompt_assistant_header_bg": "#e9ecef",
             "prompt_assistant_header_text": "#495057",
-            "prompt_assistant_item_hover_bg": None,  # Usará el primario por defecto
-            "prompt_assistant_item_hover_text": None,  # Usará el texto sobre primario
+
+            # this use the primary by default
+            "prompt_assistant_icon_color": None,
+            "prompt_assistant_item_hover_bg": None,
+            "prompt_assistant_item_hover_text": None,
 
             # Color para el botón de Enviar ---
-            "send_button_color": "#212529"  # Gris oscuro/casi negro por defecto
+            "send_button_color": "#212529"          # Gris oscuro/casi negro por defecto
         }
 
     def get_company_branding(self, company: Company | None) -> dict:
@@ -68,8 +76,9 @@ class BrandingService:
         """
         final_branding_values = self._default_branding.copy()
 
-        if company and company.branding:
-            final_branding_values.update(company.branding)
+        if company:
+            branding_data = self.config_service.get_company_content(company.short_name, 'branding')
+            final_branding_values.update(branding_data)
 
         # Función para convertir HEX a RGB
         def hex_to_rgb(hex_color):
@@ -101,6 +110,7 @@ class BrandingService:
                 --brand-secondary-color: {final_branding_values['brand_secondary_color']};
                 --brand-header-bg: {final_branding_values['header_background_color']};
                 --brand-header-text: {final_branding_values['header_text_color']};
+                --brand-text-heading-color: {final_branding_values['brand_text_heading_color']};
 
                 --brand-primary-color-rgb: {', '.join(map(str, primary_rgb))};
                 --brand-secondary-color-rgb: {', '.join(map(str, secondary_rgb))};
@@ -113,11 +123,11 @@ class BrandingService:
                 --brand-danger-text: {final_branding_values['brand_danger_text']};
                 --brand-danger-border: {final_branding_values['brand_danger_border']};
                 --brand-info-bg: {final_branding_values['brand_info_bg']};
-                --brand-info-text: {final_branding_values['brand_info_text']};
+                --brand-info-text: {final_branding_values['brand_info_text'] or final_branding_values['brand_primary_color']};
                 --brand-info-border: {final_branding_values['brand_info_border']};
                 --brand-prompt-assistant-bg: {final_branding_values['prompt_assistant_bg']};
                 --brand-prompt-assistant-border: {final_branding_values['prompt_assistant_border']};
-                --brand-prompt-assistant-icon-color: {final_branding_values['prompt_assistant_icon_color']};
+                --brand-prompt-assistant-icon-color: {final_branding_values['prompt_assistant_icon_color'] or final_branding_values['brand_primary_color']};
                 --brand-prompt-assistant-button-bg: {final_branding_values['prompt_assistant_button_bg']};
                 --brand-prompt-assistant-button-text: {final_branding_values['prompt_assistant_button_text']};
                 --brand-prompt-assistant-button-border: {final_branding_values['prompt_assistant_button_border']};
@@ -137,5 +147,5 @@ class BrandingService:
             "tertiary_text_style": tertiary_text_style,
             "header_text_color": final_branding_values['header_text_color'],
             "css_variables": css_variables,
-            "send_button_color": final_branding_values['send_button_color']
+            "send_button_color": final_branding_values['brand_primary_color']
         }

iatoolkit/services/configuration_service.py

@@ -0,0 +1,140 @@
+# iatoolkit/services/configuration_service.py
+# Copyright (c) 2024 Fernando Libedinsky
+# Product: IAToolkit
+
+from pathlib import Path
+from iatoolkit import BaseCompany
+from iatoolkit.repositories.profile_repo import ProfileRepo
+from iatoolkit.repositories.models import Company
+from iatoolkit.common.util import Utility
+from injector import inject
+import logging
+
+class ConfigurationService:
+    """
+    Orchestrates the configuration of a Company by reading its YAML files
+    and using the BaseCompany's protected methods to register settings.
+    """
+
+    @inject
+    def __init__(self,
+                 profile_repo: ProfileRepo,
+                 utility: Utility):
+        self.profile_repo = profile_repo
+        self.utility = utility
+        self._loaded_configs = {}   # cache for store loaded configurations
+
+    def get_company_content(self, company_short_name: str, content_key: str) -> dict | list | None:
+        """
+        Public method to provide a specific section of a company's configuration.
+        It uses a cache to avoid reading files from disk on every call.
+        """
+        self._ensure_config_loaded(company_short_name)
+        return self._loaded_configs[company_short_name].get(content_key)
+
+    def register_company(self, company_short_name: str, company_instance: BaseCompany):
+        """
+        Main entry point for configuring a company instance.
+        This method is invoked by the dispatcher for each registered company.
+        """
+        logging.info(f"⚙️  Starting configuration for company '{company_short_name}'...")
+
+        # 1. identify the instance with his name and load info from database
+        company_instance.id = company_short_name
+        company_instance.company = self.profile_repo.get_company_by_short_name(company_short_name)
+
+        # 2. Load the main configuration file and supplementary content files
+        config = self._load_and_merge_configs(company_short_name)
+
+        # 3. Register core company details and get the database object
+        company_db_object = self._register_core_details(company_instance, config)
+
+        # 4. Register tools (functions)
+        self._register_tools(company_instance, config.get('tools', []))
+
+        # 5. Register prompt categories and prompts
+        self._register_prompts(company_instance, config)
+
+        # 6. Link the persisted Company object back to the running instance
+        company_instance.company = company_db_object
+
+        logging.info(f"✅ Company '{company_short_name}' configured successfully.")
+
+    def _ensure_config_loaded(self, company_short_name: str):
+        """
+        Checks if the configuration for a company is in the cache.
+        If not, it loads it from files and stores it.
+        """
+        if company_short_name not in self._loaded_configs:
+            self._loaded_configs[company_short_name] = self._load_and_merge_configs(company_short_name)
+
+    def _load_and_merge_configs(self, company_short_name: str) -> dict:
+        """
+        Loads the main company.yaml and merges data from supplementary files
+        specified in the 'content_files' section.
+        """
+        config_dir = Path("companies") / company_short_name / "config"
+        main_config_path = config_dir / "company.yaml"
+
+        if not main_config_path.exists():
+            raise FileNotFoundError(f"Main configuration file not found: {main_config_path}")
+
+        config = self.utility.load_schema_from_yaml(main_config_path)
+
+        # Load and merge supplementary content files (e.g., onboarding_cards)
+        for key, file_path in config.get('help_files', {}).items():
+            supplementary_path = config_dir / file_path
+            if supplementary_path.exists():
+                config[key] = self.utility.load_schema_from_yaml(supplementary_path)
+            else:
+                logging.warning(f"⚠️  Warning: Content file not found: {supplementary_path}")
+                config[key] = None  # Ensure the key exists but is empty
+
+        return config
+
+    def _register_core_details(self, company_instance: BaseCompany, config: dict) -> Company:
+        """Calls _create_company with data from the merged YAML config."""
+        return company_instance._create_company(
+            name=config['name'],
+            short_name=config['id'],
+            parameters=config.get('parameters', {})
+        )
+
+    def _register_tools(self, company_instance: BaseCompany, tools_config: list):
+        """Calls _create_function for each tool defined in the YAML."""
+        for tool in tools_config:
+            company_instance._create_function(
+                function_name=tool['function_name'],
+                description=tool['description'],
+                params=tool['params']
+            )
+
+    def _register_prompts(self, company_instance: BaseCompany, config: dict):
+        """
+        Creates prompt categories first, then creates each prompt and assigns
+        it to its respective category.
+        """
+        prompts_config = config.get('prompts', [])
+        categories_config = config.get('prompt_categories', [])
+
+        created_categories = {}
+        for i, category_name in enumerate(categories_config):
+            category_obj = company_instance._create_prompt_category(name=category_name, order=i + 1)
+            created_categories[category_name] = category_obj
+
+        for prompt_data in prompts_config:
+            category_name = prompt_data.get('category')
+            if not category_name or category_name not in created_categories:
+                logging.info(f"⚠️  Warning: Prompt '{prompt_data['name']}' has an invalid or missing category. Skipping.")
+                continue
+
+            category_obj = created_categories[category_name]
+
+            company_instance._create_prompt(
+                prompt_name=prompt_data['name'],
+                description=prompt_data['description'],
+                order=prompt_data['order'],
+                category=category_obj,
+                active=prompt_data.get('active', True),
+                custom_fields=prompt_data.get('custom_fields', [])
+            )

iatoolkit/services/dispatcher_service.py

@@ -6,7 +6,7 @@
 from iatoolkit.common.exceptions import IAToolkitException
 from iatoolkit.services.prompt_manager_service import PromptService
 from iatoolkit.repositories.llm_query_repo import LLMQueryRepo
-
+from iatoolkit.services.configuration_service import ConfigurationService
 from iatoolkit.repositories.models import Company, Function
 from iatoolkit.services.excel_service import ExcelService
 from iatoolkit.services.mail_service import MailService
@@ -19,11 +19,13 @@ import os
 class Dispatcher:
     @inject
     def __init__(self,
+                 config_service: ConfigurationService,
                  prompt_service: PromptService,
                  llmquery_repo: LLMQueryRepo,
                  util: Utility,
                  excel_service: ExcelService,
                  mail_service: MailService):
+        self.config_service = config_service
         self.prompt_service = prompt_service
         self.llmquery_repo = llmquery_repo
         self.util = util
@@ -55,14 +57,18 @@ class Dispatcher:
             self._company_instances = self.company_registry.get_all_company_instances()
         return self._company_instances
 
-    def start_execution(self):
+    def load_company_configs(self):
         # initialize the system functions and prompts
         self.setup_iatoolkit_system()
 
-        """Runs the startup logic for all registered companies."""
-        for company in self.company_instances.values():
-            company.register_company()
-            company.start_execution()
+        """Loads the configuration of every company"""
+        for company_name, company_instance in self.company_instances.items():
+            try:
+                # register the company configuration
+                self.config_service.register_company(company_name, company_instance)
+            except Exception as e:
+                logging.error(f"❌ Failed to register configuration for '{company_name}': {e}")
+                continue
 
         return True
 
@@ -90,9 +96,6 @@ class Dispatcher:
             )
             i += 1
 
-        # register in the database  every company class
-        for company in self.company_instances.values():
-            company.register_company()
 
     def dispatch(self, company_name: str, action: str, **kwargs) -> dict:
         company_key = company_name.lower()
@@ -149,7 +152,7 @@ class Dispatcher:
         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
+                               f"Error getting company context of: {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
@@ -173,7 +176,7 @@ class Dispatcher:
     def get_user_info(self, company_name: str, user_identifier: str) -> dict:
         if company_name not in self.company_instances:
             raise IAToolkitException(IAToolkitException.ErrorType.EXTERNAL_SOURCE_ERROR,
-                                     f"Empresa no configurada: {company_name}")
+                                     f"company not configured: {company_name}")
 
         # source 2: external company user
         company_instance = self.company_instances[company_name]
@@ -182,14 +185,14 @@ class Dispatcher:
         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
+                                     f"Error in get_user_info: {company_name}: {str(e)}") from e
 
         return external_user_profile
 
     def get_metadata_from_filename(self, company_name: str, filename: str) -> dict:
         if company_name not in self.company_instances:
             raise IAToolkitException(IAToolkitException.ErrorType.EXTERNAL_SOURCE_ERROR,
-                               f"Empresa no configurada: {company_name}")
+                               f"company not configured: {company_name}")
 
         company_instance = self.company_instances[company_name]
         try:
@@ -197,7 +200,7 @@ class Dispatcher:
         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
+                               f"Error in get_metadata_from_filename: {company_name}: {str(e)}") from e
 
     def get_company_instance(self, company_name: str):
         """Returns the instance for a given company name."""
@@ -207,12 +210,11 @@ class Dispatcher:
 
 # 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'}
+    {'name': 'query_main', 'description':'iatoolkit main prompt'},
+    {'name': 'format_styles', 'description':'output format styles'},
+    {'name': 'sql_rules', 'description':'instructions  for SQL queries'}
 ]
 
-
 # iatoolkit  function calls
 _FUNCTION_LIST = [
     {

iatoolkit/services/document_service.py

@@ -11,10 +11,13 @@ import os
 import pytesseract
 from injector import inject
 from iatoolkit.common.exceptions import IAToolkitException
+from iatoolkit.services.i18n_service import I18nService
 
 class DocumentService:
     @inject
-    def __init__(self):
+    def __init__(self, i18n_service: I18nService):
+        self.i18n_service = i18n_service
+
         # max number of pages to load
         self.max_doc_pages = int(os.getenv("MAX_DOC_PAGES", "200"))
 
@@ -29,7 +32,7 @@ class DocumentService:
                         file_content = file_content.decode('utf-8')
                     except UnicodeDecodeError:
                         raise IAToolkitException(IAToolkitException.ErrorType.FILE_FORMAT_ERROR,
-                                           "El archivo no es texto o la codificación no es UTF-8")
+                                           self.i18n_service.t('errors.services.no_text_file'))
 
                 return file_content
             elif filename.lower().endswith('.pdf'):

iatoolkit/services/excel_service.py

@@ -8,6 +8,7 @@ import pandas as pd
 from uuid import uuid4
 from pathlib import Path
 from iatoolkit.common.exceptions import IAToolkitException
+from iatoolkit.services.i18n_service import I18nService
 from injector import inject
 import os
 import logging
@@ -18,8 +19,11 @@ EXCEL_MIME = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
 
 class ExcelService:
     @inject
-    def __init__(self,util: Utility):
+    def __init__(self,
+                 util: Utility,
+                 i18n_service: I18nService):
         self.util = util
+        self.i18n_service = i18n_service
 
     def excel_generator(self, **kwargs) -> str:
         """
@@ -42,11 +46,11 @@ class ExcelService:
             # get the parameters
             fname = kwargs.get('filename')
             if not fname:
-                return 'falta el nombre del archivo de salida'
+                return self.i18n_service.t('errors.services.no_output_file')
 
             data = kwargs.get('data')
             if not data or not isinstance(data, list):
-                return 'faltan los datos  o no es una lista de diccionarios'
+                return self.i18n_service.t('errors.services.no_data_for_excel')
 
             sheet_name = kwargs.get('sheet_name', 'hoja 1')
 
@@ -58,7 +62,7 @@ class ExcelService:
 
             # 4. check that download directory is configured
             if 'IATOOLKIT_DOWNLOAD_DIR' not in current_app.config:
-                return 'no esta configurado el directorio temporal para guardar excels'
+                return self.i18n_service.t('errors.services.no_download_directory')
 
             download_dir = current_app.config['IATOOLKIT_DOWNLOAD_DIR']
             filepath = Path(download_dir) / token
@@ -77,28 +81,28 @@ class ExcelService:
 
         except Exception as e:
             raise IAToolkitException(IAToolkitException.ErrorType.CALL_ERROR,
-                               'error generating excel file') from e
+                               self.i18n_service.t('errors.services.cannot_create_excel')) from e
 
     def validate_file_access(self, filename):
         try:
             if not filename:
-                return jsonify({"error": "Nombre de archivo inválido"})
+                return jsonify({"error": self.i18n_service.t('errors.services.invalid_filename')})
             # Prevent path traversal attacks
             if '..' in filename or filename.startswith('/') or '\\' in filename:
-                return jsonify({"error": "Nombre de archivo inválido"})
+                return jsonify({"error": self.i18n_service.t('errors.services.invalid_filename')})
 
             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"})
+                return jsonify({"error": self.i18n_service.t('errors.services.file_not_exist')})
 
             if not os.path.isfile(file_path):
-                return jsonify({"error": "La ruta no corresponde a un archivo"})
+                return jsonify({"error": self.i18n_service.t('errors.services.path_is_not_a_file')})
 
             return None
 
         except Exception as e:
-            error_msg = f"Error validando acceso al archivo {filename}: {str(e)}"
+            error_msg = f"File validation error {filename}: {str(e)}"
             logging.error(error_msg)
-            return jsonify({"error": "Error validando archivo"})
+            return jsonify({"error": self.i18n_service.t('errors.services.file_validation_error')})

iatoolkit/services/file_processor_service.py

@@ -52,27 +52,19 @@ class FileProcessor:
                  logger: Optional[logging.Logger] = None):
         self.connector = connector
         self.config = config
-        self.logger = logger or self._setup_logger()
         self.processed_files = 0
 
-    def _setup_logger(self):
-        logging.basicConfig(
-            filename=self.config.log_file,
-            level=logging.INFO,
-            format='%(asctime)s - %(levelname)s - %(message)s'
-        )
-        return logging.getLogger(__name__)
 
     def process_files(self):
         # Fetches files from the connector, filters them, and processes them.
         try:
             files = self.connector.list_files()
         except Exception as e:
-            self.logger.error(f"Error fetching files: {e}")
+            logging.error(f"Error fetching files: {e}")
             return False
 
         if self.config.echo:
-            print(f'cargando un total de {len(files)} archivos')
+            print(f'loading {len(files)} files')
 
         for file_info in files:
             file_path = file_info['path']
@@ -95,10 +87,10 @@ class FileProcessor:
                                      context=self.config.context)
                 self.processed_files += 1
 
-                self.logger.info(f"Successfully processed file: {file_path}")
+                logging.info(f"Successfully processed file: {file_path}")
 
             except Exception as e:
-                self.logger.error(f"Error processing {file_path}: {e}")
+                logging.error(f"Error processing {file_path}: {e}")
                 if not self.config.continue_on_error:
                     raise e