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

iatoolkit/repositories/vs_repo.py

@@ -4,40 +4,38 @@
 # IAToolkit is open source software.
 
 from sqlalchemy import  text
-from huggingface_hub import InferenceClient
 from injector import inject
 from iatoolkit.common.exceptions import IAToolkitException
 from iatoolkit.repositories.database_manager import DatabaseManager
-from iatoolkit.repositories.models import Document, VSDoc
-import os
+from iatoolkit.services.embedding_service import EmbeddingService
+from iatoolkit.repositories.models import Document, VSDoc, Company
 import logging
 
+
 class VSRepo:
     @inject
-    def __init__(self, db_manager: DatabaseManager):
+    def __init__(self,
+                 db_manager: DatabaseManager,
+                 embedding_service: EmbeddingService):
         self.session = db_manager.get_session()
-
-        # Inicializar el modelo de embeddings
-        self.embedder = InferenceClient(
-            model="sentence-transformers/all-MiniLM-L6-v2",
-            token=os.getenv('HF_TOKEN'))
+        self.embedding_service = embedding_service
 
 
-    def add_document(self, vs_chunk_list: list[VSDoc]):
+    def add_document(self, company_short_name, vs_chunk_list: list[VSDoc]):
         try:
             for doc in vs_chunk_list:
                 # calculate the embedding for the text
-                doc.embedding = self.embedder.feature_extraction(doc.text)
+                doc.embedding = self.embedding_service.embed_text(company_short_name, doc.text)
                 self.session.add(doc)
             self.session.commit()
         except Exception as e:
-            logging.error(f"Error insertando documentos en PostgreSQL: {str(e)}")
+            logging.error(f"Error inserting documents into PostgreSQL: {str(e)}")
             self.session.rollback()
             raise IAToolkitException(IAToolkitException.ErrorType.VECTOR_STORE_ERROR,
-                               f"Error insertando documentos en PostgreSQL: {str(e)}")
+                               f"Error inserting documents into PostgreSQL: {str(e)}")
 
     def query(self,
-              company_id: int,
+              company_short_name: str,
               query_text: str,
               n_results=5,
               metadata_filter=None
@@ -46,18 +44,25 @@ class VSRepo:
         search documents similar to the query for a company
 
         Args:
-            company_id:
+            company_short_name: The company's unique short name.
             query_text: query text
             n_results: max number of results to return
-            metadata_filter:  (ej: {"document_type": "certificate"})
+            metadata_filter:  (e.g., {"document_type": "certificate"})
 
         Returns:
             list of documents matching the query and filters
         """
-        # Generate the embedding with the query text
-        query_embedding = self.embedder.feature_extraction([query_text])[0]
+        # Generate the embedding with the query text for the specific company
+        query_embedding = self.embedding_service.embed_text(company_short_name, query_text)
 
+        sql_query, params = None, None
         try:
+            # Get company ID from its short name for the SQL query
+            company = self.session.query(Company).filter(Company.short_name == company_short_name).one_or_none()
+            if not company:
+                raise IAToolkitException(IAToolkitException.ErrorType.VECTOR_STORE_ERROR,
+                                   f"Company with short name '{company_short_name}' not found.")
+
             # build the SQL query
             sql_query_parts = ["""
                                SELECT iat_documents.id, \
@@ -73,11 +78,12 @@ class VSRepo:
 
             # query parameters
             params = {
-                "company_id": company_id,
+                "company_id": company.id,
                 "query_embedding": query_embedding,
                 "n_results": n_results
             }
 
+
             # add metadata filter, if exists
             if metadata_filter and isinstance(metadata_filter, dict):
                 for key, value in metadata_filter.items():
@@ -108,7 +114,7 @@ class VSRepo:
                 meta_data = row[4] if len(row) > 4 and row[4] is not None else {}
                 doc = Document(
                     id=row[0],
-                    company_id=company_id,
+                    company_id=company.id,
                     filename=row[1],
                     content=row[2],
                     content_b64=row[3],

iatoolkit/services/auth_service.py

@@ -84,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',
@@ -189,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,16 +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
     """
-
     @inject
-    def __init__(self):
+    def __init__(self, config_service: ConfigurationService):
+        self.config_service = config_service
         """
         Define los estilos de branding por defecto para la aplicación.
         """
@@ -68,15 +69,15 @@ class BrandingService:
             "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):
@@ -138,8 +139,11 @@ 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,

iatoolkit/services/company_context_service.py

@@ -0,0 +1,155 @@
+# 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'***Base de datos (database_name)***: {db_name}\n'
+            sql_context += f"**Descripción:**: {db_description}\n" if db_description else ""
+            sql_context += "Para consultar esta base de datos debes utilizar el servicio ***iat_sql_query***.\n"
+
+            # 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 settings and overrides.
+            global_exclude_columns = source.get('exclude_columns', [])
+            table_prefix = source.get('table_prefix')
+            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.
+                    # Priority 1: Explicit override from the 'tables' map.
+                    schema_name = table_config.get('schema_name')
+
+                    if not schema_name:
+                        # Priority 2: Automatic prefix stripping.
+                        if table_prefix and table_name.startswith(table_prefix):
+                            schema_name = table_name[len(table_prefix):]
+                        else:
+                            # Priority 3: Default to the table name itself.
+                            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', [])
+            )