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

iatoolkit/repositories/models.py

@@ -57,12 +57,8 @@ class Company(Base):
     # encrypted api-key
     openai_api_key = Column(String, nullable=True)
     gemini_api_key = Column(String, nullable=True)
-
-    branding = Column(JSON, nullable=True)
-    onboarding_cards = Column(JSON, nullable=True)
     parameters = Column(JSON, nullable=True)
     created_at = Column(DateTime, default=datetime.now)
-    allow_jwt = Column(Boolean, default=True, nullable=True)
 
     documents = relationship("Document",
                              back_populates="company",
@@ -107,6 +103,7 @@ class User(Base):
     created_at = Column(DateTime, default=datetime.now)
     password = Column(String, nullable=False)
     verified = Column(Boolean, nullable=False, default=False)
+    preferred_language = Column(String(5), nullable=True)
     verification_url = Column(String, nullable=True)
     temp_code = Column(String, nullable=True)
 

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,36 +46,38 @@ 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:
+    def get_company_branding(self, company_short_name: str) -> dict:
         """
         Retorna los estilos de branding finales para una compañía,
         fusionando los valores por defecto con los personalizados.
         """
         final_branding_values = self._default_branding.copy()
+        branding_data = self.config_service.get_configuration(company_short_name, 'branding')
+        final_branding_values.update(branding_data)
 
-        if company and company.branding:
-            final_branding_values.update(company.branding)
 
         # Función para convertir HEX a RGB
         def hex_to_rgb(hex_color):
@@ -101,6 +109,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 +122,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']};
@@ -130,12 +139,15 @@ class BrandingService:
             }}
         """
 
+        # get the company name from configuration for the branding render
+        company_name = self.config_service.get_configuration(company_short_name, 'name')
+
         return {
-            "name": company.name if company else "IAToolkit",
+            "name": company_name,
             "primary_text_style": primary_text_style,
             "secondary_text_style": secondary_text_style,
             "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/company_context_service.py

@@ -0,0 +1,145 @@
+# Copyright (c) 2024 Fernando Libedinsky
+# Product: IAToolkit
+#
+# IAToolkit is open source software.
+
+from iatoolkit.common.util import Utility
+from iatoolkit.services.configuration_service import ConfigurationService
+from iatoolkit.services.sql_service import SqlService
+from iatoolkit.common.exceptions import IAToolkitException
+import logging
+from injector import inject
+import os
+
+
+class CompanyContextService:
+    """
+    Responsible for building the complete context string for a given company
+    to be sent to the Language Model.
+    """
+
+    @inject
+    def __init__(self,
+                 sql_service: SqlService,
+                 utility: Utility,
+                 config_service: ConfigurationService):
+        self.sql_service = sql_service
+        self.utility = utility
+        self.config_service = config_service
+
+    def get_company_context(self, company_short_name: str) -> str:
+        """
+        Builds the full context by aggregating three sources:
+        1. Static context files (Markdown).
+        2. Static schema files (YAML for APIs, etc.).
+        3. Dynamic SQL database schema from the live connection.
+        """
+        context_parts = []
+
+        # 1. Context from Markdown (context/*.md) and yaml (schema/*.yaml) files
+        try:
+            md_context = self._get_static_file_context(company_short_name)
+            if md_context:
+                context_parts.append(md_context)
+        except Exception as e:
+            logging.warning(f"Could not load Markdown context for '{company_short_name}': {e}")
+
+        # 2. Context from company-specific Python logic (SQL schemas)
+        try:
+            sql_context = self._get_sql_schema_context(company_short_name)
+            if sql_context:
+                context_parts.append(sql_context)
+        except Exception as e:
+            logging.warning(f"Could not generate SQL context for '{company_short_name}': {e}")
+
+        # Join all parts with a clear separator
+        return "\n\n---\n\n".join(context_parts)
+
+    def _get_static_file_context(self, company_short_name: str) -> str:
+        # Get context from .md and .yaml schema files.
+        static_context = ''
+
+        # Part 1: Markdown context files
+        context_dir = f'companies/{company_short_name}/context'
+        if os.path.exists(context_dir):
+            context_files = self.utility.get_files_by_extension(context_dir, '.md', return_extension=True)
+            for file in context_files:
+                filepath = os.path.join(context_dir, file)
+                static_context += self.utility.load_markdown_context(filepath)
+
+        # Part 2: YAML schema files
+        schema_dir = f'companies/{company_short_name}/schema'
+        if os.path.exists(schema_dir):
+            schema_files = self.utility.get_files_by_extension(schema_dir, '.yaml', return_extension=True)
+            for file in schema_files:
+                schema_name = file.split('.')[0]  # Use full filename as entity name
+                filepath = os.path.join(schema_dir, file)
+                static_context += self.utility.generate_context_for_schema(schema_name, filepath)
+
+        return static_context
+
+    def _get_sql_schema_context(self, company_short_name: str) -> str:
+        """
+        Generates the SQL schema context by inspecting live database connections
+        based on the flexible company.yaml configuration.
+        It supports including all tables and providing specific overrides for a subset of them.
+        """
+        data_sources_config = self.config_service.get_configuration(company_short_name, 'data_sources')
+        if not data_sources_config or not data_sources_config.get('sql'):
+            return ''
+
+        sql_context = ''
+        for source in data_sources_config.get('sql', []):
+            db_name = source.get('database')
+            if not db_name:
+                continue
+
+            try:
+                db_manager = self.sql_service.get_database_manager(db_name)
+            except IAToolkitException as e:
+                logging.warning(f"Could not get DB manager for '{db_name}': {e}")
+                continue
+
+            db_description = source.get('description', '')
+            sql_context += f"{db_description}\n" if db_description else ""
+
+            # 1. get the list of tables to process.
+            tables_to_process = []
+            if source.get('include_all_tables', False):
+                all_tables = db_manager.get_all_table_names()
+                tables_to_exclude = set(source.get('exclude_tables', []))
+                tables_to_process = [t for t in all_tables if t not in tables_to_exclude]
+            elif 'tables' in source:
+                # if not include_all_tables, use the list of tables explicitly specified in the map.
+                tables_to_process = list(source['tables'].keys())
+
+            # 2. get the global list of columns to exclude.
+            global_exclude_columns = source.get('exclude_columns', [])
+
+            # 3. get the overrides for specific tables.
+            table_overrides = source.get('tables', {})
+
+            # 3. iterate over the tables.
+            for table_name in tables_to_process:
+                try:
+                    # 4. get the table specific configuration.
+                    table_config = table_overrides.get(table_name, {})
+
+                    # 5. define the schema name, using the override if it exists.
+                    schema_name = table_config.get('schema_name', table_name)
+
+                    # 6. define the list of columns to exclude, (local vs. global).
+                    local_exclude_columns = table_config.get('exclude_columns')
+                    final_exclude_columns = local_exclude_columns if local_exclude_columns is not None else global_exclude_columns
+
+                    # 7. get the table schema definition.
+                    table_definition = db_manager.get_table_schema(
+                        table_name=table_name,
+                        schema_name=schema_name,
+                        exclude_columns=final_exclude_columns
+                    )
+                    sql_context += table_definition
+                except (KeyError, RuntimeError) as e:
+                    logging.warning(f"Could not generate schema for table '{table_name}': {e}")
+
+        return sql_context

iatoolkit/services/configuration_service.py

@@ -0,0 +1,133 @@
+# iatoolkit/services/configuration_service.py
+# Copyright (c) 2024 Fernando Libedinsky
+# Product: IAToolkit
+
+from pathlib import Path
+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,
+                 utility: Utility):
+        self.utility = utility
+        self._loaded_configs = {}   # cache for store loaded configurations
+
+    def get_configuration(self, company_short_name: str, content_key: str):
+        """
+        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 load_configuration(self, company_short_name: str, company_instance):
+        """
+        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. Load the main configuration file and supplementary content files
+        config = self._load_and_merge_configs(company_short_name)
+
+        # 2. Register core company details and get the database object
+        company_db_object = self._register_core_details(company_instance, config)
+
+        # 3. Register tools (functions)
+        self._register_tools(company_instance, config.get('tools', []))
+
+        # 4. Register prompt categories and prompts
+        self._register_prompts(company_instance, config)
+
+        # 5. Link the persisted Company object back to the running instance
+        company_instance.company_short_name = company_short_name
+        company_instance.company = company_db_object
+        company_instance.id = company_instance.company.id
+
+        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, config: dict) -> Company:
+        """Calls _create_company with data from the merged YAML config."""
+        return company_instance._create_company(
+            short_name=config['id'],
+            name=config['name'],
+            parameters=config.get('parameters', {})
+        )
+
+    def _register_tools(self, company_instance, 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, 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', [])
+            )