iatoolkit 1.7.0__py3-none-any.whl → 1.9.0__py3-none-any.whl

iatoolkit/services/prompt_service.py

@@ -9,7 +9,8 @@ from iatoolkit.repositories.llm_query_repo import LLMQueryRepo
 from iatoolkit.services.i18n_service import I18nService
 from iatoolkit.repositories.profile_repo import ProfileRepo
 from collections import defaultdict
-from iatoolkit.repositories.models import Prompt, PromptCategory, Company
+from iatoolkit.repositories.models import (Prompt, PromptCategory,
+                                           Company, PromptType)
 from iatoolkit.common.exceptions import IAToolkitException
 import importlib.resources
 import logging
@@ -34,14 +35,14 @@ class PromptService:
         self.profile_repo = profile_repo
         self.i18n_service = i18n_service
 
-    def sync_company_prompts(self, company_short_name: str, prompts_config: list, categories_config: list):
+    def sync_company_prompts(self, company_short_name: str, prompt_list: list, categories_config: list):
         """
         Synchronizes prompt categories and prompts from YAML config to Database.
         Strategies:
         - Categories: Create or Update existing based on name.
         - Prompts: Create or Update existing based on name. Soft-delete or Delete unused.
         """
-        if not prompts_config:
+        if not prompt_list:
             return
 
         company = self.profile_repo.get_company_by_short_name(company_short_name)
@@ -49,6 +50,7 @@ class PromptService:
             raise IAToolkitException(IAToolkitException.ErrorType.INVALID_NAME,
                                      f'Company {company_short_name} not found')
 
+        self._register_system_prompts(company)
         try:
             # 1. Sync Categories
             category_map = {}
@@ -66,7 +68,7 @@ class PromptService:
             # 2. Sync Prompts
             defined_prompt_names = set()
 
-            for prompt_data in prompts_config:
+            for prompt_data in prompt_list:
                 category_name = prompt_data.get('category')
                 if not category_name or category_name not in category_map:
                     logging.warning(
@@ -86,7 +88,7 @@ class PromptService:
                     order=prompt_data.get('order'),
                     category_id=category_obj.id,
                     active=prompt_data.get('active', True),
-                    is_system_prompt=False,
+                    prompt_type=PromptType.COMPANY.value,
                     filename=filename,
                     custom_fields=prompt_data.get('custom_fields', [])
                 )
@@ -106,7 +108,7 @@ class PromptService:
             self.llm_query_repo.rollback()
             raise IAToolkitException(IAToolkitException.ErrorType.DATABASE_ERROR, str(e))
 
-    def register_system_prompts(self):
+    def _register_system_prompts(self, company: Company):
         """
         Synchronizes system prompts defined in Dispatcher/Code to Database.
         """
@@ -116,20 +118,26 @@ class PromptService:
             for i, prompt_data in enumerate(_SYSTEM_PROMPTS):
                 prompt_name = prompt_data['name']
                 defined_names.add(prompt_name)
+                prompt_filename = f"{prompt_name}.prompt"
 
                 new_prompt = Prompt(
-                    company_id=None,  # System prompts have no company
+                    company_id=company.id,
                     name=prompt_name,
                     description=prompt_data['description'],
                     order=i + 1,
                     category_id=None,
                     active=True,
-                    is_system_prompt=True,
-                    filename=f"{prompt_name}.prompt",
+                    prompt_type=PromptType.SYSTEM.value,
+                    filename=prompt_filename,
                     custom_fields=[]
                 )
                 self.llm_query_repo.create_or_update_prompt(new_prompt)
 
+                # add prompt to company assets
+                if not self.asset_repo.exists(company.short_name, AssetType.PROMPT, prompt_filename):
+                    prompt_content = importlib.resources.read_text('iatoolkit.system_prompts', prompt_filename)
+                    self.asset_repo.write_text(company.short_name, AssetType.PROMPT, prompt_filename, prompt_content)
+
             # Cleanup old system prompts
             existing_sys_prompts = self.llm_query_repo.get_system_prompts()
             for p in existing_sys_prompts:
@@ -149,7 +157,7 @@ class PromptService:
                       company: Company = None,
                       category: PromptCategory = None,
                       active: bool = True,
-                      is_system_prompt: bool = False,
+                      prompt_type: PromptType = PromptType.COMPANY,
                       custom_fields: list = []
                       ):
         """
@@ -157,7 +165,7 @@ class PromptService:
             Validates file existence before creating DB entry.
         """
         prompt_filename = prompt_name.lower() + '.prompt'
-        if is_system_prompt:
+        if prompt_type == PromptType.SYSTEM:
             if not importlib.resources.files('iatoolkit.system_prompts').joinpath(prompt_filename).is_file():
                 raise IAToolkitException(IAToolkitException.ErrorType.INVALID_NAME,
                                 f'missing system prompt file: {prompt_filename}')
@@ -181,10 +189,10 @@ class PromptService:
                 name=prompt_name,
                 description=description,
                 order=order,
-                category_id=category.id if category and not is_system_prompt else None,
+                category_id=category.id if category and prompt_type != PromptType.SYSTEM else None,
                 active=active,
                 filename=prompt_filename,
-                is_system_prompt=is_system_prompt,
+                prompt_type=prompt_type.value,
                 custom_fields=custom_fields
             )
 
@@ -196,21 +204,25 @@ class PromptService:
 
     def get_prompt_content(self, company: Company, prompt_name: str):
         try:
-            # get the user prompt
-            user_prompt = self.llm_query_repo.get_prompt_by_name(company, prompt_name)
-            if not user_prompt:
+            # get the prompt
+            prompt = self.llm_query_repo.get_prompt_by_name(company, prompt_name)
+            if not prompt:
                 raise IAToolkitException(IAToolkitException.ErrorType.DOCUMENT_NOT_FOUND,
-                                   f"prompt not found '{prompt_name}' for company '{company.short_name}'")
+                                   f"prompt not found '{prompt}' for company '{company.short_name}'")
 
             try:
-                user_prompt_content = self.asset_repo.read_text(
-                    company.short_name,
-                    AssetType.PROMPT,
-                    user_prompt.filename
-                )
+                if (prompt.prompt_type == PromptType.SYSTEM.value and
+                        not self.asset_repo.exists(company.short_name, AssetType.PROMPT, prompt.filename)):
+                            user_prompt_content = importlib.resources.read_text('iatoolkit.system_prompts', prompt.filename)
+                else:
+                    user_prompt_content = self.asset_repo.read_text(
+                        company.short_name,
+                        AssetType.PROMPT,
+                        prompt.filename
+                    )
             except FileNotFoundError:
                 raise IAToolkitException(IAToolkitException.ErrorType.FILE_IO_ERROR,
-                                         f"prompt file '{user_prompt.filename}' does not exist for company '{company.short_name}'")
+                                         f"prompt file '{prompt.filename}' does not exist for company '{company.short_name}'")
             except Exception as e:
                 raise IAToolkitException(IAToolkitException.ErrorType.FILE_IO_ERROR,
                                          f"error while reading prompt: '{prompt_name}': {e}")
@@ -225,6 +237,114 @@ class PromptService:
             raise IAToolkitException(IAToolkitException.ErrorType.PROMPT_ERROR,
                                f'error loading prompt "{prompt_name}" content for company {company.short_name}: {str(e)}')
 
+    def save_prompt(self, company_short_name: str, prompt_name: str, data: dict):
+        """
+        Create or Update a prompt.
+        1. Saves the Jinja content to the .prompt file.
+        2. Updates the Metadata (params, description) in company.yaml using ConfigurationService.
+        3. Updates the Database.
+        """
+        company = self.profile_repo.get_company_by_short_name(company_short_name)
+        if not company:
+            raise IAToolkitException(IAToolkitException.ErrorType.INVALID_NAME,
+                                     f"Company {company_short_name} not found")
+
+        # Validate category if present
+        category_id = None
+        if 'category' in data:
+             # simple lookup, assuming category names are unique per company
+             cat = self.llm_query_repo.get_category_by_name(company.id, data['category'])
+             if cat:
+                 category_id = cat.id
+
+        # 1. save the phisical part of the prompt (content)
+        if 'content' in data:
+            filename = f"{prompt_name}.prompt"
+            filename = filename.lower().replace(' ', '_')
+            self.asset_repo.write_text(company_short_name, AssetType.PROMPT, filename, data['content'])
+
+        # 2. Sync the metadata with company.yaml (lazy import here)
+        # Extract the fields that go to the YAML
+        yaml_metadata = {
+            'name': prompt_name,
+            'description': data.get('description', ''),
+            'category': data.get('category'),
+            'prompt_type': data.get('prompt_type', 'company'),
+            'order': data.get('order', 1),
+            'active': data.get('active', True),
+            'custom_fields': data.get('custom_fields', [])
+        }
+
+        self._sync_to_configuration(company_short_name, yaml_metadata)
+
+        # 3. Reflejar cambios en la BD inmediatamente (para no esperar recarga)
+        # Esto es opcional si confías en que _sync_to_configuration recargará la config,
+        # pero es más seguro actualizar la entidad actual.
+        prompt_db = self.llm_query_repo.get_prompt_by_name(company, prompt_name)
+        if not prompt_db:
+             # Create new prompt in DB immediately for responsiveness
+             new_prompt = Prompt(
+                company_id=company.id,
+                name=prompt_name,
+                description=yaml_metadata['description'],
+                order=yaml_metadata['order'],
+                category_id=category_id,
+                active=yaml_metadata['active'],
+                prompt_type=yaml_metadata['prompt_type'],
+                filename=f"{prompt_name.lower().replace(' ', '_')}.prompt",
+                custom_fields=yaml_metadata['custom_fields']
+            )
+             self.llm_query_repo.create_or_update_prompt(new_prompt)
+        else:
+            prompt_db.description = yaml_metadata['description']
+            prompt_db.category_id = category_id
+            prompt_db.order = yaml_metadata['order']
+            prompt_db.custom_fields = yaml_metadata['custom_fields']
+            prompt_db.active = yaml_metadata['active']
+            self.llm_query_repo.create_or_update_prompt(prompt_db)
+
+    def _sync_to_configuration(self, company_short_name: str, prompt_data: dict):
+        """
+        Usa ConfigurationService para inyectar este prompt en la lista 'prompts.prompt_list' del YAML.
+        """
+        # --- LAZY IMPORT para evitar Circular Dependency ---
+        from iatoolkit import current_iatoolkit
+        from iatoolkit.services.configuration_service import ConfigurationService
+
+        config_service = current_iatoolkit().get_injector().get(ConfigurationService)
+
+        # 1. Obtenemos la configuración actual cruda (sin objetos Python)
+        #    Necesitamos leer la estructura para encontrar si el prompt ya existe en la lista.
+        full_config = config_service._load_and_merge_configs(company_short_name)
+
+        prompts_config = full_config.get('prompts', {})
+        # Normalizar estructura si prompts es una lista o un dict
+        if isinstance(prompts_config, list):
+            # Estructura antigua o simple, la convertimos a dict
+            prompts_config = {'prompt_list': prompts_config, 'prompt_categories': []}
+
+        prompt_list = prompts_config.get('prompt_list', [])
+
+        # 2. Buscar si el prompt ya existe en la lista
+        found_index = -1
+        for i, p in enumerate(prompt_list):
+            if p.get('name') == prompt_data['name']:
+                found_index = i
+                break
+
+        # 3. Construir la ruta de actualización (key path)
+        if found_index >= 0:
+            # Actualizar existente: "prompts.prompt_list.3"
+            # Nota: prompt_data contiene keys como 'description', 'custom_fields', etc.
+            # ConfigurationService.update_configuration_key espera una clave y un valor.
+            # Podríamos actualizar todo el objeto del prompt en la lista.
+            key_path = f"prompts.prompt_list.{found_index}"
+            config_service.update_configuration_key(company_short_name, key_path, prompt_data)
+        else:
+            # Crear nuevo: Agregar a la lista
+            # Usamos el método add_configuration_key que creaste anteriormente
+            config_service.add_configuration_key(company_short_name, "prompts.prompt_list", str(len(prompt_list)), prompt_data)
+
     def get_system_prompt(self):
         try:
             system_prompt_content = []
@@ -253,7 +373,7 @@ class PromptService:
             raise IAToolkitException(IAToolkitException.ErrorType.PROMPT_ERROR,
                                f'error reading the system prompts": {str(e)}')
 
-    def get_user_prompts(self, company_short_name: str) -> dict:
+    def get_user_prompts(self, company_short_name: str, include_all: bool = False) -> dict:
         try:
             # validate company
             company = self.profile_repo.get_company_by_short_name(company_short_name)
@@ -261,15 +381,31 @@ class PromptService:
                 return {"error": self.i18n_service.t('errors.company_not_found', company_short_name=company_short_name)}
 
             # get all the prompts
-            all_prompts = self.llm_query_repo.get_prompts(company)
+            # If include_all is True, repo should return everything for the company
+            all_prompts = self.llm_query_repo.get_prompts(company, include_all=include_all)
+
+            # Deduplicate prompts by id
+            all_prompts = list({p.id: p for p in all_prompts}.values())
 
             # group by category
             prompts_by_category = defaultdict(list)
             for prompt in all_prompts:
-                if prompt.active:
-                    if prompt.category:
-                        cat_key = (prompt.category.order, prompt.category.name)
-                        prompts_by_category[cat_key].append(prompt)
+                # Filter logic moved here or in repo.
+                # If include_all is False, we only want active prompts (and maybe only specific types)
+                if not include_all:
+                    if not prompt.active:
+                        continue
+                    # Standard user view: usually excludes system/agent hidden prompts if any?
+                    # Current requirement: "solo los de tipo company, activos" for end users
+                    if prompt.prompt_type != PromptType.COMPANY.value:
+                        continue
+
+                # Grouping logic
+                cat_key = (0, "Uncategorized") # Default
+                if prompt.category:
+                    cat_key = (prompt.category.order, prompt.category.name)
+
+                prompts_by_category[cat_key].append(prompt)
 
             # sort each category by order
             for cat_key in prompts_by_category:
@@ -288,6 +424,8 @@ class PromptService:
                         {
                             'prompt': p.name,
                             'description': p.description,
+                            'type': p.prompt_type,
+                            'active': p.active,
                             'custom_fields': p.custom_fields,
                             'order': p.order
                         }
@@ -301,3 +439,46 @@ class PromptService:
             logging.error(f"error in get_prompts: {e}")
             return {'error': str(e)}
 
+    def delete_prompt(self, company_short_name: str, prompt_name: str):
+        """
+        Deletes a prompt:
+        1. Removes from DB.
+        2. Removes from YAML config.
+        3. (Optional) Deletes/Archives physical file.
+        """
+        company = self.profile_repo.get_company_by_short_name(company_short_name)
+        if not company:
+            raise IAToolkitException(IAToolkitException.ErrorType.INVALID_NAME, f"Company not found")
+
+        prompt_db = self.llm_query_repo.get_prompt_by_name(company, prompt_name)
+        if not prompt_db:
+            raise IAToolkitException(IAToolkitException.ErrorType.DOCUMENT_NOT_FOUND, f"Prompt {prompt_name} not found")
+
+        # 1. Remove from DB
+        self.llm_query_repo.delete_prompt(prompt_db)
+
+        # 2. Remove from Configuration (Lazy import)
+        from iatoolkit import current_iatoolkit
+        from iatoolkit.services.configuration_service import ConfigurationService
+        config_service = current_iatoolkit().get_injector().get(ConfigurationService)
+
+        # We need to find the index to remove it from the list in YAML
+        full_config = config_service._load_and_merge_configs(company_short_name)
+        prompts_list = full_config.get('prompts', {}).get('prompt_list', [])
+
+        found_index = -1
+        for i, p in enumerate(prompts_list):
+            if p.get('name') == prompt_name:
+                found_index = i
+                break
+
+        if found_index >= 0:
+            # This is tricky with current ConfigService if it doesn't support list item deletion easily.
+            # Assuming we might need to implement a 'delete_configuration_key' or similar,
+            # OR just leave it in config but update DB. For now, let's assume manual config cleanup or
+            # implement a specific removal if ConfigService supports it.
+            # If ConfigService doesn't support removal, we might just mark it inactive in config.
+            pass
+            # config_service.remove_list_item(company_short_name, "prompts.prompt_list", found_index)
+
+

iatoolkit/views/categories_api_view.py

@@ -0,0 +1,71 @@
+# Copyright (c) 2024 Fernando Libedinsky
+# Product: IAToolkit
+#
+# IAToolkit is open source software.
+
+from flask import jsonify
+from flask.views import MethodView
+from injector import inject
+from iatoolkit.services.auth_service import AuthService
+from iatoolkit.services.profile_service import ProfileService
+from iatoolkit.services.configuration_service import ConfigurationService
+from iatoolkit.services.knowledge_base_service import KnowledgeBaseService
+from iatoolkit.repositories.llm_query_repo import LLMQueryRepo
+from iatoolkit.repositories.models import PromptType, PromptCategory
+import logging
+
+class CategoriesApiView(MethodView):
+    """
+    Endpoint to retrieve all available categories and types in the system.
+    Useful for populating dropdowns in the frontend.
+    """
+    @inject
+    def __init__(self,
+                 auth_service: AuthService,
+                 profile_service: ProfileService,
+                 configuration_service: ConfigurationService,
+                 knowledge_base_service: KnowledgeBaseService,
+                 llm_query_repo: LLMQueryRepo):
+        self.auth_service = auth_service
+        self.profile_service = profile_service
+        self.knowledge_base_service = knowledge_base_service
+        self.llm_query_repo = llm_query_repo
+        self.configuration_service = configuration_service
+
+    def get(self, company_short_name):
+        try:
+            # 1. Verify Authentication
+            auth_result = self.auth_service.verify()
+            if not auth_result.get("success"):
+                return jsonify(auth_result), 401
+
+            # 2. Get Company
+            company = self.profile_service.get_company_by_short_name(company_short_name)
+            if not company:
+                return jsonify({"error": "Company not found"}), 404
+
+            # 3. Gather Categories
+            response_data = {
+                "prompt_types": [t.value for t in PromptType],
+                "prompt_categories": [],
+                "collection_types": [],
+                # Future categories can be added here (e.g., tool_types, user_roles)
+            }
+
+            # A. Prompt Categories (from DB)
+            prompt_cats = self.llm_query_repo.get_all_categories(company_id=company.id)
+            response_data["prompt_categories"] = [c.name for c in prompt_cats]
+
+            # B. Collection Types (from KnowledgeBaseService)
+            response_data["collection_types"] = self.knowledge_base_service.get_collection_names(company_short_name)
+
+            # C. LLM Models (from ConfigurationService)
+            _, llm_models = self.configuration_service.get_llm_configuration(company_short_name)
+            # Extract only IDs
+            response_data["llm_models"] = [m['id'] for m in llm_models if 'id' in m]
+
+            return jsonify(response_data)
+
+        except Exception as e:
+            logging.exception(f"Error fetching categories for {company_short_name}: {e}")
+            return jsonify({"status": "error", "message": str(e)}), 500

iatoolkit/views/configuration_api_view.py

@@ -62,7 +62,7 @@ class ConfigurationApiView(MethodView):
         Body: { "key": "llm.model", "value": "gpt-4" }
         """
         try:
-            auth_result = self.auth_service.verify(anonymous=False) # Require valid user for updates
+            auth_result = self.auth_service.verify()
             if not auth_result.get("success"):
                 return jsonify(auth_result), 401
 

iatoolkit/views/prompt_api_view.py

@@ -3,9 +3,11 @@
 #
 # IAToolkit is open source software.
 
-from flask import jsonify
+from flask import jsonify, request
 from flask.views import MethodView
 from iatoolkit.services.prompt_service import PromptService
+from iatoolkit.services.profile_service import ProfileService
+from iatoolkit.repositories.llm_query_repo import LLMQueryRepo
 from iatoolkit.services.auth_service import AuthService
 from injector import inject
 import logging
@@ -15,23 +17,102 @@ class PromptApiView(MethodView):
     @inject
     def __init__(self,
                  auth_service: AuthService,
-                 prompt_service: PromptService ):
+                 prompt_service: PromptService,
+                 profile_service: ProfileService,
+                 llm_query_repo: LLMQueryRepo):
         self.auth_service = auth_service
         self.prompt_service = prompt_service
+        self.profile_service = profile_service
+        self.llm_query_repo = llm_query_repo
 
-    def get(self, company_short_name):
+    def get(self, company_short_name, prompt_name=None):
+        """
+        GET /: Lista el árbol de prompts (Categorías > Prompts).
+        GET /<name>: Devuelve detalle completo: metadata + contenido texto.
+        """
         try:
             # get access credentials
             auth_result = self.auth_service.verify(anonymous=True)
             if not auth_result.get("success"):
                 return jsonify(auth_result), auth_result.get('status_code')
 
-            response = self.prompt_service.get_user_prompts(company_short_name)
-            if "error" in response:
-                return {'error_message': response["error"]}, 402
+            company = self.profile_service.get_company_by_short_name(company_short_name)
+            if not company:
+                 return jsonify({"error": "Company not found"}), 404
+
+            if prompt_name:
+                # get the prompt object from database
+                prompt_obj = self.llm_query_repo.get_prompt_by_name(company, prompt_name)
+                if not prompt_obj:
+                     return jsonify({"error": "Prompt not found"}), 404
+
+                # get the prompt content
+                content = self.prompt_service.get_prompt_content(company, prompt_name)
+
+                return jsonify({
+                    "meta": prompt_obj.to_dict(),
+                    "content": content
+                })
+            else:
+                # Check for query param to include all prompts (admin view)
+                include_all = request.args.get('all', 'false').lower() == 'true'
+
+                # return prompts based on filter
+                return jsonify(self.prompt_service.get_user_prompts(company_short_name, include_all=include_all))
 
-            return response, 200
         except Exception as e:
             logging.exception(
                 f"unexpected error getting company prompts: {e}")
             return jsonify({"error_message": str(e)}), 500
+
+    def put(self, company_short_name, prompt_name):
+        try:
+            auth_result = self.auth_service.verify()
+            if not auth_result.get("success"):
+                return jsonify(auth_result), 401
+
+            data = request.get_json()
+
+            # The service handles file magic and YAML sync
+            self.prompt_service.save_prompt(company_short_name, prompt_name, data)
+
+            return jsonify({"status": "success"})
+        except Exception as e:
+            logging.exception(f"Error saving prompt {prompt_name}: {e}")
+            return jsonify({"status": "error", "message": str(e)}), 500
+
+    def post(self, company_short_name, prompt_name=None):
+        """Creates a new prompt."""
+        try:
+            auth_result = self.auth_service.verify()
+            if not auth_result.get("success"):
+                return jsonify(auth_result), 401
+
+            data = request.get_json()
+            # If prompt_name is not in URL, check body
+            target_name = prompt_name if prompt_name else data.get('name')
+
+            if not target_name:
+                return jsonify({"status": "error", "message": "Prompt name is required"}), 400
+
+            # Reuse save_prompt logic which handles create/update
+            self.prompt_service.save_prompt(company_short_name, target_name, data)
+
+            return jsonify({"status": "success"})
+        except Exception as e:
+            logging.exception(f"Error creating prompt: {e}")
+            return jsonify({"status": "error", "message": str(e)}), 500
+
+    def delete(self, company_short_name, prompt_name):
+        """Deletes a prompt."""
+        try:
+            auth_result = self.auth_service.verify()
+            if not auth_result.get("success"):
+                return jsonify(auth_result), 401
+
+            self.prompt_service.delete_prompt(company_short_name, prompt_name)
+
+            return jsonify({"status": "success"})
+        except Exception as e:
+            logging.exception(f"Error deleting prompt {prompt_name}: {e}")
+            return jsonify({"status": "error", "message": str(e)}), 500

{iatoolkit-1.7.0.dist-info → iatoolkit-1.9.0.dist-info}/METADATA

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