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

iatoolkit/__init__.py

@@ -3,7 +3,7 @@
 #
 # IAToolkit is open source software.
 
-__version__ = "1.7.0"
+__version__ = "1.15.3"
 
 # Expose main classes and functions at the top level of the package
 

iatoolkit/common/routes.py

@@ -32,6 +32,7 @@ def register_views(app):
     from iatoolkit.views.root_redirect_view import RootRedirectView
     from iatoolkit.views.users_api_view import UsersApiView
     from iatoolkit.views.rag_api_view import RagApiView
+    from iatoolkit.views.categories_api_view import CategoriesApiView
 
     # assign root '/' to our new redirect logic
     app.add_url_rule('/home', view_func=RootRedirectView.as_view('root_redirect'))
@@ -85,9 +86,21 @@ def register_views(app):
     # can be used also for executing iatoolkit prompts
     app.add_url_rule('/<company_short_name>/api/llm_query', view_func=LLMQueryApiView.as_view('llm_query_api'))
 
-    # open the promt directory
-    app.add_url_rule('/<company_short_name>/api/prompts', view_func=PromptApiView.as_view('prompt'))
-
+    # Categories Endpoint
+    app.add_url_rule('/<company_short_name>/api/categories',
+                     view_func=CategoriesApiView.as_view('categories_api'),
+                     methods=['GET', 'POST'])
+
+    # open the promt directory and specific prompt management
+    prompt_view = PromptApiView.as_view('prompt')
+    app.add_url_rule('/<company_short_name>/api/prompts',
+                     view_func=prompt_view,
+                     methods=['GET', 'POST'],
+                     defaults={'prompt_name': None})
+
+    app.add_url_rule('/<company_short_name>/api/prompts/<prompt_name>',
+                     view_func=prompt_view,
+                     methods=['GET', 'POST','PUT', 'DELETE'])
     # toolbar buttons
     app.add_url_rule('/<company_short_name>/api/feedback', view_func=UserFeedbackApiView.as_view('feedback'))
     app.add_url_rule('/<company_short_name>/api/history', view_func=HistoryApiView.as_view('history'))

iatoolkit/common/util.py

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

iatoolkit/core.py

@@ -58,6 +58,7 @@ class IAToolkit:
         self._injector = Injector()         # init empty injector
         self.version = IATOOLKIT_VERSION
         self.license = "Community Edition"
+        self.is_community = True
 
     @classmethod
     def get_instance(cls) -> 'IAToolkit':

iatoolkit/infra/connectors/file_connector.py

@@ -4,7 +4,7 @@
 # IAToolkit is open source software.
 
 from abc import ABC, abstractmethod
-from typing import List
+from typing import List, Optional
 
 
 class FileConnector(ABC):
@@ -14,4 +14,12 @@ class FileConnector(ABC):
 
     @abstractmethod
     def get_file_content(self, file_path: str) -> bytes:
-        pass
+        pass
+
+
+    @abstractmethod
+    def upload_file(self, file_path: str, content: bytes, content_type: str = None) -> None:
+        pass
+
+    def generate_presigned_url(self, file_path: str, expiration: int = 3600) -> Optional[str]:
+        return None

iatoolkit/infra/connectors/google_drive_connector.py

@@ -66,3 +66,6 @@ class GoogleDriveConnector(FileConnector):
             status, done = downloader.next_chunk()
 
         return file_buffer.getvalue()
+
+    def upload_file(self, file_path: str, content: bytes, content_type: str = None) -> None:
+        return

iatoolkit/infra/connectors/local_file_connector.py

@@ -44,3 +44,6 @@ class LocalFileConnector(FileConnector):
         except Exception as e:
             raise IAToolkitException(IAToolkitException.ErrorType.FILE_IO_ERROR,
                                f"Error leyendo el archivo {file_path}: {e}")
+
+    def upload_file(self, file_path: str, content: bytes, content_type: str = None) -> None:
+        return

iatoolkit/infra/connectors/s3_connector.py

@@ -32,4 +32,27 @@ class S3Connector(FileConnector):
 
     def get_file_content(self, file_path: str) -> bytes:
         response = self.s3.get_object(Bucket=self.bucket, Key=file_path)
-        return response['Body'].read()
+        return response['Body'].read()
+
+    def upload_file(self, file_path: str, content: bytes, content_type: str = None) -> None:
+        # If the path doesn't start with the prefix, add it (optional, depends on your logic)'
+        # Assuming file_path is either a full path or relative to the root of the bucket for flexibility
+        full_path = file_path
+
+        extra_args = {}
+        if content_type:
+            extra_args['ContentType'] = content_type
+
+        self.s3.put_object(
+            Bucket=self.bucket,
+            Key=full_path,
+            Body=content,
+            **extra_args
+        )
+
+    def generate_presigned_url(self, file_path: str, expiration: int = 3600) -> str:
+        return self.s3.generate_presigned_url(
+            'get_object',
+            Params={'Bucket': self.bucket, 'Key': file_path},
+            ExpiresIn=expiration
+        )

iatoolkit/infra/llm_providers/deepseek_adapter.py

@@ -40,6 +40,13 @@ class DeepseekAdapter:
         tools = kwargs.get("tools") or []
         tool_choice = kwargs.get("tool_choice", "auto")
         context_history = kwargs.get("context_history") or []
+        images = kwargs.get("images") or []
+
+        if images:
+            logging.warning(
+                f"[DeepseekAdapter] Images provided but DeepSeek models are not multimodal. "
+                f"Ignoring {len(images)} images."
+            )
 
         try:
             # 1) Build messages from history (if any)
@@ -232,6 +239,7 @@ class DeepseekAdapter:
 
         # If the model produced tool calls, fills this list
         tool_calls_out: List[ToolCall] = []
+        content_parts: List[Dict] = []  # Initialize content_parts
 
         tool_calls = getattr(message, "tool_calls", None) or []
         if not tool_calls:
@@ -239,6 +247,13 @@ class DeepseekAdapter:
             output_text = getattr(message, "content", "") or ""
             status = "completed"
 
+            # Fill content_parts for text response
+            if output_text:
+                content_parts.append({
+                    "type": "text",
+                    "text": output_text
+                })
+
         else:
             logging.debug(f"[DeepSeek] RAW tool_calls: {tool_calls}")
 
@@ -274,5 +289,6 @@ class DeepseekAdapter:
             output_text=output_text,
             output=tool_calls_out,
             usage=usage,
-            reasoning_content=reasoning_content
+            reasoning_content=reasoning_content,
+            content_parts=content_parts  # Pass content_parts
         )

iatoolkit/infra/llm_providers/gemini_adapter.py

@@ -11,6 +11,9 @@ from iatoolkit.common.exceptions import IAToolkitException
 import logging
 import json
 import uuid
+import mimetypes
+import re
+
 
 class GeminiAdapter:
 
@@ -34,6 +37,7 @@ class GeminiAdapter:
                         text: Optional[Dict] = None,
                         reasoning: Optional[Dict] = None,
                         tool_choice: str = "auto",
+                        images: Optional[List[Dict]] = None,
                         ) -> LLMResponse:
         try:
             # init the model with the configured client
@@ -43,11 +47,12 @@ class GeminiAdapter:
             )
 
             # prepare the content for gemini
+            # We pass images here because they need to be merged into the content
             if context_history:
                 # concat the history with the current input
-                contents = self._prepare_gemini_contents(context_history + input)
+                contents = self._prepare_gemini_contents(context_history + input, images)
             else:
-                contents = self._prepare_gemini_contents(input)
+                contents = self._prepare_gemini_contents(input, images)
 
             # prepare tools
             gemini_tools = self._prepare_gemini_tools(tools) if tools else None
@@ -108,31 +113,67 @@ class GeminiAdapter:
         }
         return model_mapping.get(model.lower(), model)
 
-    def _prepare_gemini_contents(self, input: List[Dict]) -> List[Dict]:
+    def _prepare_gemini_contents(self, input: List[Dict], images: Optional[List[Dict]] = None) -> List[Dict]:
         # convert input messages to Gemini format
         gemini_contents = []
 
-        for message in input:
+        # Find the last user message to attach images to
+        last_user_msg_index = -1
+        if images:
+            for i in range(len(input) - 1, -1, -1):
+                if input[i].get("role") == "user":
+                    last_user_msg_index = i
+                    break
+
+        for i, message in enumerate(input):
+            parts = []
+
             if message.get("role") == "system":
+                # System prompts are usually passed as user role with special text in Gemini 1.0/1.5 API
+                # unless using the explicit system_instruction parameter (which is model-init time).
+                # Here we keep the existing logic of prepending to user role.
                 gemini_contents.append({
                     "role": "user",
                     "parts": [{"text": f"[INSTRUCCIONES DEL SISTEMA]\n{message.get('content', '')}"}]
                 })
+                continue # Skip the rest for this iteration
+
             elif message.get("role") == "user":
-                gemini_contents.append({
-                    "role": "user",
-                    "parts": [{"text": message.get("content", "")}]
-                })
+                role = "user"
+                parts.append({"text": message.get("content", "")})
+
+                # Attach images to the LAST user message only
+                if images and i == last_user_msg_index:
+                    for img in images:
+                        filename = img.get('name', '')
+                        mime_type, _ = mimetypes.guess_type(filename)
+                        if not mime_type:
+                            mime_type = 'image/jpeg'
+
+                        parts.append({
+                            "inline_data": {
+                                "mime_type": mime_type,
+                                "data": img.get('base64', '')
+                            }
+                        })
+
             elif message.get("type") == "function_call_output":
-                gemini_contents.append({
-                    "role": "function",
-                    "parts": [{
-                        "function_response": {
-                            "name": "tool_result",
-                            "response": {"output": message.get("output", "")}
-                        }
-                    }]
+                role = "function"
+                parts.append({
+                    "function_response": {
+                        "name": "tool_result",
+                        "response": {"output": message.get("output", "")}
+                    }
                 })
+            else:
+                # Handle assistant messages or others if present in history
+                # Assuming role mapping is correct or handled elsewhere if needed
+                continue
+
+            gemini_contents.append({
+                "role": role,
+                "parts": parts
+            })
 
         return gemini_contents
 
@@ -245,13 +286,37 @@ class GeminiAdapter:
         response_id = str(uuid.uuid4())
         output_text = ""
         tool_calls = []
+        content_parts = []
 
         if gemini_response.candidates and len(gemini_response.candidates) > 0:
             candidate = gemini_response.candidates[0]
 
             for part in candidate.content.parts:
+                # 1. Caso Texto
                 if hasattr(part, 'text') and part.text:
-                    output_text += part.text
+                    text_chunk = part.text
+
+                    # Buscar imágenes incrustadas como Markdown en el texto
+                    # Pattern: ![Alt text](URL)
+                    markdown_images = re.findall(r'!\[([^\]]*)\]\((https?://[^)]+)\)', text_chunk)
+
+                    for alt_text, url in markdown_images:
+                        content_parts.append({
+                            "type": "image",
+                            "source": {
+                                "type": "url",
+                                "media_type": "image/webp", # Asumimos webp por defecto en generación moderna
+                                "url": url
+                            }
+                        })
+
+                    output_text += text_chunk
+                    content_parts.append({
+                        "type": "text",
+                        "text": text_chunk
+                    })
+
+                # 2. Caso Función (Tool Call)
                 elif hasattr(part, 'function_call') and part.function_call:
                     func_call = part.function_call
                     tool_calls.append(ToolCall(
@@ -261,6 +326,39 @@ class GeminiAdapter:
                         arguments=json.dumps(MessageToDict(func_call._pb).get('args', {}))
                     ))
 
+                # 3. Caso Imagen (Inline Data / Base64 directo de Gemini)
+                elif hasattr(part, 'inline_data') and part.inline_data:
+                    # Gemini devuelve imagenes generadas aqui
+                    mime_type = part.inline_data.mime_type
+                    data_base64 = part.inline_data.data # Esto son bytes o str base64
+
+                    content_parts.append({
+                        "type": "image",
+                        "source": {
+                            "type": "base64",
+                            "media_type": mime_type,
+                            "data": data_base64
+                        }
+                    })
+
+                    # Opcional: Agregar un placeholder al texto plano para logs
+                    output_text += "\n[Imagen Generada]\n"
+
+                # 4. Caso Archivo (File Data / URI)
+                elif hasattr(part, 'file_data') and part.file_data:
+                    mime_type = part.file_data.mime_type
+                    file_uri = part.file_data.file_uri
+
+                    content_parts.append({
+                        "type": "image",
+                        "source": {
+                            "type": "url",
+                            "media_type": mime_type,
+                            "url": file_uri
+                        }
+                    })
+                    output_text += f"\n[Imagen Generada: {file_uri}]\n"
+
         # Determinar status
         status = "completed"
         if gemini_response.candidates:
@@ -299,7 +397,8 @@ class GeminiAdapter:
             status=status,
             output_text=output_text,
             output=tool_calls,
-            usage=usage
+            usage=usage,
+            content_parts=content_parts
         )
 
     def _extract_usage_metadata(self, gemini_response) -> Usage: