iatoolkit 0.7.2__tar.gz → 0.7.5__tar.gz

{iatoolkit-0.7.2 → iatoolkit-0.7.5}/PKG-INFO

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

{iatoolkit-0.7.2 → iatoolkit-0.7.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "iatoolkit"
-version = "0.7.2"
+version = "0.7.5"
 requires-python = ">=3.11"
 description = "IAToolkit"
 readme = "readme.md"
@@ -19,7 +19,7 @@ package-dir = {"" = "src"}
 
 [tool.setuptools.packages.find]
 where = ["src"]
-include = ["iatoolkit*", "services*"]
+include = ["iatoolkit*", "services*", "common*"]
 
 [tool.setuptools.dynamic]
 dependencies = { file = ["requirements.txt"] }

iatoolkit-0.7.5/src/common/auth.py

@@ -0,0 +1,200 @@
+# Copyright (c) 2024 Fernando Libedinsky
+# Product: IAToolkit
+#
+# IAToolkit is open source software.
+
+from flask import redirect, url_for
+from common.session_manager import SessionManager
+from datetime import datetime, timezone
+from injector import inject
+from repositories.profile_repo import ProfileRepo
+from services.jwt_service import JWTService
+import logging
+from flask import request
+from typing import Optional
+
+MAX_INACTIVITY_SECONDS = 60*30
+
+class IAuthentication:
+    @inject
+
+    def __init__(self,
+                 profile_repo: ProfileRepo,
+                 jwt_service: JWTService):
+        self.profile_repo = profile_repo
+        self.jwt_service = jwt_service
+
+    def verify(self, company_short_name: str, body_external_user_id: str = None) -> dict:
+        # authentication is in this orden: JWT, API Key, Sesión
+        local_user_id = None
+        company_id = None
+        auth_method = None
+        external_user_id = None  # for JWT or API Key
+        
+        # 1. try auth via JWT
+        jwt_company_id, jwt_external_user_id, jwt_error_info = self._authenticate_via_chat_jwt(company_short_name)
+
+        if jwt_company_id is not None and jwt_external_user_id is not None:
+            auth_method = "JWT"
+            company_id = jwt_company_id
+            external_user_id = jwt_external_user_id
+            local_user_id = 0
+        elif jwt_error_info is not None:
+            # explicit error in JWT (inválido, expirado, etc.)
+            logging.warning(f"Fallo de autenticación JWT: {jwt_error_info}")
+            return {"error_message": "Fallo de autenticación JWT"} 
+        else:
+            # 2. JWT not apply, try by API Key
+            api_key_company_id, api_key_error_info = self._authenticate_via_api_key(company_short_name)
+
+            if api_key_company_id is not None:
+                auth_method = "API Key"
+                company_id = api_key_company_id
+                external_user_id = body_external_user_id  # API Key usa external_user_id del body
+                local_user_id = 0
+            elif api_key_error_info is not None:
+                # explicit error in API Key (inválida, incorrecta, error interno)
+                logging.warning(f"Fallo de autenticación API Key: {api_key_error_info}")
+                return {"error_message": "Fallo de autenticación API Key"}
+            else:
+                # 3. no JWT and API Key auth, try by Session
+                self.check_if_user_is_logged_in(company_short_name)  # raise exception or redirect if not logged in
+
+                # In case not logged in check_if_user_is_logged_in redirects to login page
+                auth_method = "Session"
+                local_user_id = SessionManager.get('user_id')
+                company_id = SessionManager.get('company_id')
+                external_user_id = ""
+
+                if not company_id or not local_user_id:
+                    logging.error(
+                        f"Sesión válida para {company_short_name} pero falta company_id o user_id en SessionManager.")
+                    return {"error_message": "Fallo interno en la autenticación o no autenticado"}
+
+        # last verification of authentication
+        if company_id is None or auth_method is None or local_user_id is None:
+            # this condition should never happen,
+            logging.error(
+                f"Fallo inesperado en la lógica de autenticación para {company_short_name}. Ningún método tuvo éxito o devolvió error.")
+            return {"error_message": "Fallo interno en la autenticación o no autenticado"}
+
+        return {
+            'success': True,
+            "auth_method": auth_method,
+            "company_id": company_id,
+            "auth_method": auth_method,
+            "local_user_id": local_user_id,
+            "external_user_id": external_user_id
+        }
+
+    def _authenticate_via_api_key(self, company_short_name_from_url: str):
+        """
+        try to authenticate using an API Key from the header 'Authorization'.
+        Retorna (company_id, None) en éxito.
+        Retorna (None, error_message) en fallo.
+        """
+        api_key_header = request.headers.get('Authorization')
+        api_key_value = None
+
+        # extract the key
+        if api_key_header and api_key_header.startswith('Bearer '):
+            api_key_value = api_key_header.split('Bearer ')[1]
+        else:
+            # there is no key in the headers expected
+            return None, None
+
+        # validate the api-key using ProfileRepo
+        try:
+            api_key_entry = self.profile_repo.get_active_api_key_entry(api_key_value)
+            if not api_key_entry:
+                logging.warning(f"Intento de acceso con API Key inválida o inactiva: {api_key_value[:5]}...")
+                return None, "API Key inválida o inactiva"
+
+            # check that the key belongs to the company
+            # api_key_entry.company already loaded by joinedload
+            if not api_key_entry.company or api_key_entry.company.short_name != company_short_name_from_url:
+                return None, f"API Key no es válida para la compañía {company_short_name_from_url}"
+
+            # successfull auth by API Key
+            company_id = api_key_entry.company_id
+
+            return company_id, None
+
+        except Exception as e:
+            logging.exception(f"Error interno durante validación de API Key: {e}")
+            return None, "Error interno del servidor al validar API Key"
+
+    def _authenticate_via_chat_jwt(self, company_short_name_from_url: str) -> tuple[
+        Optional[int], Optional[str], Optional[str]]:
+        """
+        authenticate using an JWT chat session in the del header 'X-Chat-Token'.
+        Return (company_id, external_user_id, None) on exit
+        Returns (None, None, error_message) on fail.
+        """
+        chat_jwt = request.headers.get('X-Chat-Token')
+        if not chat_jwt:
+            return None, None, None
+
+        # open the jwt token and retrieve the payload
+        jwt_payload = self.jwt_service.validate_chat_jwt(chat_jwt, company_short_name_from_url)
+        if not jwt_payload:
+            # validation fails (token expired, incorrect signature, company , etc.)
+            # validate_chat_jwt logs the specific failure
+            return None, None, "Token de chat expirado, debes reingresar al chat"
+
+        # JWT is validated: extract the company_id and external_user_id
+        company_id = jwt_payload.get('company_id')
+        external_user_id = jwt_payload.get('external_user_id')
+
+        # Sanity check aditional, should never happen
+        if not isinstance(company_id, int) or not external_user_id:
+            logging.error(
+                f"LLMQuery: JWT payload incompleto tras validación exitosa. CompanyID: {company_id}, UserID: {external_user_id}")
+            return None, None, "Token de chat con formato interno incorrecto"
+
+        return company_id, external_user_id, None
+
+    def check_if_user_is_logged_in(self, company_short_name: str):
+        if not SessionManager.get('user'):
+            if company_short_name:
+                return redirect(url_for('login', company_short_name=company_short_name))
+            else:
+                return redirect(url_for('home'))
+
+        if company_short_name != SessionManager.get('company_short_name'):
+            return redirect(url_for('login', company_short_name=company_short_name))
+
+        # check session timeout
+        if not self.check_session_timeout():
+            SessionManager.clear()
+            return redirect(url_for('login', company_short_name=company_short_name))
+
+        # update last_activity
+        SessionManager.set('last_activity', datetime.now(timezone.utc).timestamp())
+
+    def check_session_timeout(self):
+        # get last activity from session manager
+        last_activity = SessionManager.get('last_activity')
+        if not last_activity:
+            return False
+
+        # Tiempo actual en timestamp
+        current_time = datetime.now(timezone.utc).timestamp()
+
+        # get inactivity duration
+        inactivity_duration = current_time - last_activity
+
+        # verify if inactivity duration is greater than MAX_INACTIVITY_SECONDS
+        if inactivity_duration > MAX_INACTIVITY_SECONDS:
+            # close session
+            return False
+
+        # update last activity timestamp
+        SessionManager.set('last_activity', current_time)
+
+        return True  # session is active
+
+
+
+
+

iatoolkit-0.7.5/src/common/exceptions.py

@@ -0,0 +1,46 @@
+# Copyright (c) 2024 Fernando Libedinsky
+# Product: IAToolkit
+#
+# IAToolkit is open source software.
+
+from enum import Enum
+
+
+class IAToolkitException(Exception):
+
+    class ErrorType(Enum):
+        SYSTEM_ERROR = 0
+        DATABASE_ERROR = 1
+        LLM_ERROR = 2
+        CLOUD_STORAGE_ERROR = 3
+        DOCUMENT_NOT_FOUND = 4
+        INVALID_PARAMETER = 5
+        MISSING_PARAMETER = 6
+        PARAM_NOT_FILLED = 7
+        PERMISSION = 8
+        EXIST = 9
+        API_KEY = 10
+        CALL_ERROR = 11
+        PROMPT_ERROR = 12
+        FILE_FORMAT_ERROR = 13
+        FILE_IO_ERROR = 14
+        TEMPLATE_ERROR = 15
+        EXTERNAL_SOURCE_ERROR = 16
+        MAIL_ERROR = 17
+        CONFIG_ERROR = 18
+        INVALID_NAME = 19
+        REQUEST_ERROR = 20
+        TASK_EXECUTION_ERROR = 21
+        TASK_NOT_FOUND = 22
+        INVALID_STATE = 23
+        CRYPT_ERROR = 24
+        LOAD_DOCUMENT_ERROR = 25
+        INVALID_USER = 26
+        VECTOR_STORE_ERROR = 27
+
+
+
+    def __init__(self, error_type: ErrorType = ErrorType.SYSTEM_ERROR, message=None):
+        self.error_type = error_type
+        self.message = message
+        super().__init__(self.message)

iatoolkit-0.7.5/src/common/routes.py

@@ -0,0 +1,86 @@
+# Copyright (c) 2024 Fernando Libedinsky
+# Product: IAToolkit
+#
+# IAToolkit is open source software.
+
+from flask import render_template, redirect, flash, url_for,send_from_directory, current_app
+from common.session_manager import SessionManager
+from flask import jsonify
+from views.history_view import HistoryView
+import os
+
+
+def logout(company_short_name: str):
+    SessionManager.clear()
+    flash("Has cerrado sesión correctamente", "info")
+    if company_short_name:
+        return redirect(url_for('login', company_short_name=company_short_name))
+    else:
+        return redirect(url_for('home'))
+
+
+# this function register all the views
+def register_views(injector, app):
+
+    from views.llmquery_view import LLMQueryView
+    from views.tasks_view import TaskView
+    from views.tasks_review_view import TaskReviewView
+    from views.home_view import HomeView
+    from views.chat_view import ChatView
+    from views.login_view import LoginView
+    from views.external_chat_login_view import ExternalChatLoginView
+    from views.signup_view import SignupView
+    from views.verify_user_view import VerifyAccountView
+    from views.forgot_password_view import ForgotPasswordView
+    from views.change_password_view import ChangePasswordView
+    from views.file_store_view import FileStoreView
+    from views.user_feedback_view import UserFeedbackView
+    from views.prompt_view import PromptView
+    from views.chat_token_request_view import ChatTokenRequestView
+    from views.external_login_view import ExternalLoginView
+    from views.download_file_view import DownloadFileView
+
+    app.add_url_rule('/', view_func=HomeView.as_view('home'))
+
+    # main chat for iatoolkit front
+    app.add_url_rule('/<company_short_name>/chat', view_func=ChatView.as_view('chat'))
+
+    # front if the company internal portal
+    app.add_url_rule('/<company_short_name>/chat_login', view_func=ExternalChatLoginView.as_view('external_chat_login'))
+    app.add_url_rule('/<company_short_name>/external_login/<external_user_id>', view_func=ExternalLoginView.as_view('external_login'))
+    app.add_url_rule('/auth/chat_token', view_func=ChatTokenRequestView.as_view('chat-token'))
+
+    # main pages for the iatoolkit frontend
+    app.add_url_rule('/<company_short_name>/login', view_func=LoginView.as_view('login'))
+    app.add_url_rule('/<company_short_name>/signup',view_func=SignupView.as_view('signup'))
+    app.add_url_rule('/<company_short_name>/logout', 'logout', logout)
+    app.add_url_rule('/logout', 'logout', logout)
+    app.add_url_rule('/<company_short_name>/verify/<token>', view_func=VerifyAccountView.as_view('verify_account'))
+    app.add_url_rule('/<company_short_name>/forgot-password', view_func=ForgotPasswordView.as_view('forgot_password'))
+    app.add_url_rule('/<company_short_name>/change-password/<token>', view_func=ChangePasswordView.as_view('change_password'))
+
+    # this are backend endpoints mainly
+    app.add_url_rule('/<company_short_name>/llm_query', view_func=LLMQueryView.as_view('llm_query'))
+    app.add_url_rule('/<company_short_name>/feedback', view_func=UserFeedbackView.as_view('feedback'))
+    app.add_url_rule('/<company_short_name>/prompts', view_func=PromptView.as_view('prompt'))
+    app.add_url_rule('/<company_short_name>/history', view_func=HistoryView.as_view('history'))
+    app.add_url_rule('/tasks', view_func=TaskView.as_view('tasks'))
+    app.add_url_rule('/tasks/review/<int:task_id>', view_func=TaskReviewView.as_view('tasks-review'))
+    app.add_url_rule('/load', view_func=FileStoreView.as_view('load'))
+
+    app.add_url_rule(
+        '/about',  # URL de la ruta
+        view_func=lambda: render_template('about.html'))
+
+    app.add_url_rule('/version', 'version',
+                     lambda: jsonify({"version": app.config['VERSION']}))
+
+    app.add_url_rule('/<company_short_name>/<external_user_id>/download-file/<path:filename>',
+                     view_func=DownloadFileView.as_view('download-file'))
+
+    @app.route('/download/<path:filename>')
+    def download_file(filename):
+        temp_dir = os.path.join(current_app.root_path, 'static', 'temp')
+        return send_from_directory(temp_dir, filename, as_attachment=True)
+
+

iatoolkit-0.7.5/src/common/session_manager.py

@@ -0,0 +1,25 @@
+# Copyright (c) 2024 Fernando Libedinsky
+# Product: IAToolkit
+#
+# IAToolkit is open source software.
+
+from flask import session
+
+
+class SessionManager:
+    @staticmethod
+    def set(key, value):
+        session[key] = value
+
+    @staticmethod
+    def get(key, default=None):
+        return session.get(key, default)
+
+    @staticmethod
+    def remove(key):
+        if key in session:
+            session.pop(key)
+
+    @staticmethod
+    def clear():
+        session.clear()

iatoolkit-0.7.5/src/common/util.py

@@ -0,0 +1,358 @@
+# Copyright (c) 2024 Fernando Libedinsky
+# Product: IAToolkit
+#
+# IAToolkit is open source software.
+
+import logging
+from typing import List
+from common.exceptions import IAToolkitException
+from injector import inject
+import os
+from jinja2 import Environment, FileSystemLoader
+from common.session_manager import SessionManager
+from datetime import datetime, date
+from decimal import Decimal
+import yaml
+from cryptography.fernet import Fernet
+import base64
+
+
+class Utility:
+    @inject
+    def __init__(self):
+        self.encryption_key = os.getenv('FERNET_KEY')
+
+    @staticmethod
+    def resolve_user_identifier(external_user_id: str = None, local_user_id: int = 0) -> tuple[str, bool]:
+        """
+        Resuelve un identificador único de usuario desde external_user_id o local_user_id.
+
+        Lógica:
+        - Si external_user_id existe y no está vacío: usar external_user_id
+        - Si no, y local_user_id > 0: obtener email de la sesión actual y retornarlo como ID
+        - Si ninguno: retornar string vacío
+
+        """
+        if external_user_id and external_user_id.strip():
+            return external_user_id.strip(), False
+        elif local_user_id and local_user_id > 0:
+            # get the user information from the session
+            user_data = SessionManager.get('user')
+            if user_data:
+                return user_data.get('email', ''), True
+
+        return "", False
+
+    def render_prompt_from_template(self,
+                                    template_pathname: str,
+                                    query: str = None,
+                                    client_data: dict = {},
+                                    **kwargs) -> str:
+
+        try:
+            # Normalizar la ruta para que funcione en cualquier SO
+            template_pathname = os.path.abspath(template_pathname)
+            template_dir = os.path.dirname(template_pathname)
+            template_file = os.path.basename(template_pathname)
+
+            env = Environment(loader=FileSystemLoader(template_dir))
+            template = env.get_template(template_file)
+
+            kwargs["query"] = query
+
+            # add all the keys in client_data to kwargs
+            kwargs.update(client_data)
+
+            # render my dynamic prompt
+            prompt = template.render(**kwargs)
+            return prompt
+        except Exception as e:
+            logging.exception(e)
+            raise IAToolkitException(IAToolkitException.ErrorType.TEMPLATE_ERROR,
+                               f'No se pudo renderizar el template: {template_pathname}, error: {str(e)}') from e
+
+    def render_prompt_from_string(self,
+                                  template_string: str,
+                                  searchpath: str | list[str] = None,
+                                  query: str = None,
+                                  client_data: dict = {},
+                                  **kwargs) -> str:
+        """
+        Renderiza un prompt a partir de un string de plantilla Jinja2.
+
+        :param template_string: El string que contiene la plantilla Jinja2.
+        :param searchpath: Una ruta o lista de rutas a directorios para buscar plantillas incluidas (con {% include %}).
+        :param query: El query principal a pasar a la plantilla.
+        :param client_data: Un diccionario con datos adicionales para la plantilla.
+        :param kwargs: Argumentos adicionales para la plantilla.
+        :return: El prompt renderizado como un string.
+        """
+        try:
+            # Si se proporciona un searchpath, se usa un FileSystemLoader para permitir includes.
+            if searchpath:
+                loader = FileSystemLoader(searchpath)
+            else:
+                loader = None  # Sin loader, no se pueden incluir plantillas desde archivos.
+
+            env = Environment(loader=loader)
+            template = env.from_string(template_string)
+
+            kwargs["query"] = query
+            kwargs.update(client_data)
+
+            prompt = template.render(**kwargs)
+            return prompt
+        except Exception as e:
+            logging.exception(e)
+            raise IAToolkitException(IAToolkitException.ErrorType.TEMPLATE_ERROR,
+                               f'No se pudo renderizar el template desde el string, error: {str(e)}') from e
+
+
+    def serialize(self, obj):
+        if isinstance(obj, datetime) or isinstance(obj, date):
+            return obj.isoformat()
+        elif isinstance(obj, Decimal):
+            return float(obj)
+        elif isinstance(obj, bytes):
+            return obj.decode('utf-8')
+        else:
+            raise TypeError(f"Type {type(obj)} not serializable")
+
+    def encrypt_key(self, key: str) -> str:
+        if not self.encryption_key:
+            raise IAToolkitException(IAToolkitException.ErrorType.CRYPT_ERROR,
+                               'No se pudo obtener variable de ambiente para encriptar')
+
+        if not key:
+            raise IAToolkitException(IAToolkitException.ErrorType.CRYPT_ERROR,
+                               'falta la clave a encriptar')
+        try:
+            cipher_suite = Fernet(self.encryption_key.encode('utf-8'))
+
+            encrypted_key = cipher_suite.encrypt(key.encode('utf-8'))
+            encrypted_key_str = base64.urlsafe_b64encode(encrypted_key).decode('utf-8')
+
+            return encrypted_key_str
+        except Exception as e:
+            raise IAToolkitException(IAToolkitException.ErrorType.CRYPT_ERROR,
+                               f'No se pudo encriptar la clave: {str(e)}') from e
+
+    def decrypt_key(self, encrypted_key: str) -> str:
+        if not self.encryption_key:
+            raise IAToolkitException(IAToolkitException.ErrorType.CRYPT_ERROR,
+                               'No se pudo obtener variable de ambiente para desencriptar')
+        if not encrypted_key:
+            raise IAToolkitException(IAToolkitException.ErrorType.CRYPT_ERROR,
+                               'falta la clave a encriptar')
+
+        try:
+            # transform to bytes first
+            encrypted_data_from_storage_bytes = base64.urlsafe_b64decode(encrypted_key.encode('utf-8'))
+
+            cipher_suite = Fernet(self.encryption_key.encode('utf-8'))
+            decrypted_key_bytes = cipher_suite.decrypt(encrypted_data_from_storage_bytes)
+            return decrypted_key_bytes.decode('utf-8')
+        except Exception as e:
+            raise IAToolkitException(IAToolkitException.ErrorType.CRYPT_ERROR,
+                               f'No se pudo desencriptar la clave: {str(e)}') from e
+
+    def load_schema_from_yaml(self, file_path):
+        with open(file_path, 'r', encoding='utf-8') as f:
+            schema = yaml.safe_load(f)
+        return schema
+
+    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]
+
+            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']
+
+                # 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}")
+
+            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:
+            return f.read()
+
+    @classmethod
+    def _get_verifier(self, rut: int):
+        value = 11 - sum([int(a) * int(b) for a, b in zip(str(rut).zfill(8), '32765432')]) % 11
+        return {10: 'K', 11: '0'}.get(value, str(value))
+
+    def validate_rut(self, rut_str):
+        if not rut_str or not isinstance(rut_str, str):
+            return False
+
+        rut_str = rut_str.strip().replace('.', '').upper()
+        parts = rut_str.split('-')
+        if not len(parts) == 2:
+            return False
+
+        try:
+            rut = int(parts[0])
+        except ValueError:
+            return False
+
+        if rut < 1000000:
+            return False
+
+        if not len(parts[1]) == 1:
+            return False
+
+        digit = parts[1].upper()
+        return digit == self._get_verifier(rut)
+
+    def get_files_by_extension(self, directory: str, extension: str, return_extension: bool = False) -> List[str]:
+        try:
+            # Normalizar la extensión (agregar punto si no lo tiene)
+            if not extension.startswith('.'):
+                extension = '.' + extension
+
+            # Verificar que el directorio existe
+            if not os.path.exists(directory):
+                raise IAToolkitException(IAToolkitException.ErrorType.FILE_IO_ERROR,
+                                   f'El directorio no existe: {directory}')
+
+            if not os.path.isdir(directory):
+                raise IAToolkitException(IAToolkitException.ErrorType.FILE_IO_ERROR,
+                                   f'La ruta no es un directorio: {directory}')
+
+            # Buscar archivos con la extensión especificada
+            files = []
+            for filename in os.listdir(directory):
+                file_path = os.path.join(directory, filename)
+                if os.path.isfile(file_path) and filename.endswith(extension):
+                    if return_extension:
+                        files.append(filename)
+                    else:
+                        name_without_extension = os.path.splitext(filename)[0]
+                        files.append(name_without_extension)
+
+            return sorted(files)  # Retornar lista ordenada alfabéticamente
+
+        except IAToolkitException:
+            raise
+        except Exception as e:
+            logging.exception(e)
+            raise IAToolkitException(IAToolkitException.ErrorType.FILE_IO_ERROR,
+                               f'Error al buscar archivos en el directorio {directory}: {str(e)}') from e
+
+    def is_openai_model(self, model: str) -> bool:
+        openai_models = [
+            'gpt-5', 'gpt'
+        ]
+        return any(openai_model in model.lower() for openai_model in openai_models)
+
+    def is_gemini_model(self, model: str) -> bool:
+        gemini_models = [
+            'gemini', 'gemini-2.5-pro'
+        ]
+        return any(gemini_model in model.lower() for gemini_model in gemini_models)

{iatoolkit-0.7.2 → iatoolkit-0.7.5}/src/iatoolkit/cli_commands.py

@@ -6,7 +6,6 @@
 import click
 import logging
 from iatoolkit import IAToolkit
-from services.dispatcher_service import Dispatcher
 from services.profile_service import ProfileService
 
 def register_core_commands(app):

{iatoolkit-0.7.2 → iatoolkit-0.7.5}/src/iatoolkit/iatoolkit.py

@@ -3,15 +3,12 @@
 #
 # IAToolkit is open source software.
 
-from flask import Flask, url_for, current_app
+from flask import Flask, url_for
 from flask_session import Session
 from flask_injector import FlaskInjector
 from flask_bcrypt import Bcrypt
 from flask_cors import CORS
-from common.auth import IAuthentication
-from common.util import Utility
 from common.exceptions import IAToolkitException
-from common.session_manager import SessionManager
 from urllib.parse import urlparse
 import redis
 import logging
@@ -294,6 +291,8 @@ class IAToolkit:
         from infra.llm_proxy import LLMProxy
         from infra.google_chat_app import GoogleChatApp
         from infra.mail_app import MailApp
+        from common.auth import IAuthentication
+        from common.util import Utility
 
         binder.bind(LLMProxy, to=LLMProxy, scope=singleton)
         binder.bind(llmClient, to=llmClient, scope=singleton)
@@ -352,6 +351,7 @@ class IAToolkit:
         # Configura context processors para templates
         @self.app.context_processor
         def inject_globals():
+            from common.session_manager import SessionManager
             return {
                 'url_for': url_for,
                 'iatoolkit_version': self.version,

{iatoolkit-0.7.2 → iatoolkit-0.7.5}/src/iatoolkit.egg-info/PKG-INFO

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

{iatoolkit-0.7.2 → iatoolkit-0.7.5}/src/iatoolkit.egg-info/SOURCES.txt

@@ -1,6 +1,12 @@
 pyproject.toml
 readme.md
 requirements.txt
+src/common/__init__.py
+src/common/auth.py
+src/common/exceptions.py
+src/common/routes.py
+src/common/session_manager.py
+src/common/util.py
 src/iatoolkit/__init__.py
 src/iatoolkit/base_company.py
 src/iatoolkit/cli_commands.py

{iatoolkit-0.7.2 → iatoolkit-0.7.5}/src/iatoolkit.egg-info/top_level.txt

@@ -1,2 +1,3 @@
+common
 iatoolkit
 services

{iatoolkit-0.7.2 → iatoolkit-0.7.5}/src/services/dispatcher_service.py

@@ -12,7 +12,6 @@ from services.mail_service import MailService
 from common.session_manager import SessionManager
 from common.util import Utility
 from injector import inject
-from typing import Dict
 import logging
 import os
 

{iatoolkit-0.7.2 → iatoolkit-0.7.5}/src/services/prompt_manager_service.py

@@ -11,7 +11,6 @@ from collections import defaultdict
 from repositories.models import Prompt, PromptCategory, Company
 import os
 from common.exceptions import IAToolkitException
-from pathlib import Path
 import importlib.resources
 
 

{iatoolkit-0.7.2 → iatoolkit-0.7.5}/src/services/query_service.py

@@ -17,7 +17,7 @@ from common.exceptions import IAToolkitException
 from injector import inject
 import base64
 import logging
-from typing import Optional, TYPE_CHECKING
+from typing import Optional
 import json
 import time
 import os