iatoolkit 0.3.9__py3-none-any.whl → 0.107.4__py3-none-any.whl

iatoolkit/__init__.py

@@ -1,54 +1,46 @@
-"""
-IAToolkit Package
-"""
+# Copyright (c) 2024 Fernando Libedinsky
+# Product: IAToolkit
+#
+# IAToolkit is open source software.
 
-# Expose main classes and functions at the top level of the package
+__version__ = "0.107.4"
 
-# Assuming 'toolkit.py' contains the IAToolkit class
-from .iatoolkit import IAToolkit, create_app
-from .iatoolkit import current_iatoolkit
+# Expose main classes and functions at the top level of the package
 
-# Assuming 'app_factory.py' contains create_app and register_company
-from .company_registry import register_company
+# main IAToolkit class
+from iatoolkit.core import IAToolkit, create_app, current_iatoolkit
 
-# Assuming 'base_company.py' contains BaseCompany
+# for registering the client companies
+from .company_registry import register_company, set_company_registry
 from .base_company import BaseCompany
 
 # --- Services ---
-# Assuming they are in a 'services' sub-package
-from services.sql_service import SqlService
-from services.excel_service import ExcelService
-from services.dispatcher_service import Dispatcher
-from services.document_service import DocumentService
-from services.search_service import SearchService
-from services.query_service import QueryService
-from repositories.profile_repo import ProfileRepo
-from repositories.llm_query_repo import LLMQueryRepo
-from repositories.database_manager import DatabaseManager
-from infra.call_service import CallServiceClient
-from common.util import Utility
-from repositories.models import Base, Company, Function, TaskType
-
+from iatoolkit.services.query_service import QueryService
+from iatoolkit.services.document_service import DocumentService
+from iatoolkit.services.search_service import SearchService
+from iatoolkit.services.sql_service import SqlService
+from iatoolkit.services.load_documents_service import LoadDocumentsService
+from iatoolkit.infra.call_service import CallServiceClient
+from iatoolkit.services.profile_service import ProfileService
+from iatoolkit.services.mail_service import MailService
+from iatoolkit.repositories.models import Base as OrmModel
+from iatoolkit.base_company import BaseCompany
 
 __all__ = [
     'IAToolkit',
     'create_app',
     'current_iatoolkit',
     'register_company',
+    'set_company_registry',
     'BaseCompany',
+    'QueryService',
     'SqlService',
-    'ExcelService',
-    'Dispatcher',
     'DocumentService',
-    'QueryService',
     'SearchService',
-    'ProfileRepo',
-    'LLMQueryRepo',
-    'DatabaseManager',
+    'LoadDocumentsService',
     'CallServiceClient',
-    'Utility',
-    'Company',
-    'Function',
-    'TaskType',
-    'Base',
+    'ProfileService',
+    'MailService',
+    'OrmModel',
+    'BaseCompany',
 ]

iatoolkit/base_company.py

@@ -1,32 +1,12 @@
 # Copyright (c) 2024 Fernando Libedinsky
-# Producto: IAToolkit
-# Todos los derechos reservados.
-# En trámite de registro en el Registro de Propiedad Intelectual de Chile.
+# Product: IAToolkit
+#
+# IAToolkit is open source software.
 
 # companies/base_company.py
 from abc import ABC, abstractmethod
-from typing import Any
-
 
 class BaseCompany(ABC):
-    def __init__(self, profile_repo: Any = None, llm_query_repo: Any = None):
-        self.profile_repo = profile_repo
-        self.llm_query_repo = llm_query_repo
-
-    @abstractmethod
-    # initialize all the database tables  needed
-    def register_company(self):
-        raise NotImplementedError("La subclase debe implementar el método create_company()")
-
-    @abstractmethod
-    # get context specific for this company
-    def get_company_context(self, **kwargs) -> str:
-        raise NotImplementedError("La subclase debe implementar el método get_company_context()")
-
-    @abstractmethod
-    # get context specific for this company
-    def get_user_info(self, **kwargs) -> str:
-        raise NotImplementedError("La subclase debe implementar el método get_user_info()")
 
     @abstractmethod
     # execute the specific action configured in the intent table
@@ -34,19 +14,7 @@ class BaseCompany(ABC):
         raise NotImplementedError("La subclase debe implementar el método handle_request()")
 
     @abstractmethod
-    # get context specific for the query
-    def start_execution(self):
-        raise NotImplementedError("La subclase debe implementar el método start_execution()")
-
-    @abstractmethod
-    # get context specific for the query
-    def get_metadata_from_filename(self, filename: str) -> dict:
-        raise NotImplementedError("La subclase debe implementar el método get_query_context()")
-
     def register_cli_commands(self, app):
-        """
-        optional method for a company definition of it's cli commands
-        """
         pass
 
     def unsupported_operation(self, tag):

iatoolkit/cli_commands.py

@@ -1,77 +1,48 @@
+# Copyright (c) 2024 Fernando Libedinsky
+# Product: IAToolkit
+#
+# IAToolkit is open source software.
+
 import click
 import logging
-from iatoolkit import IAToolkit
-from services.dispatcher_service import Dispatcher
-from services.profile_service import ProfileService
+from iatoolkit.core import IAToolkit
+from iatoolkit.services.profile_service import ProfileService
+
 
 def register_core_commands(app):
     """Registra los comandos CLI del núcleo de IAToolkit."""
-    
-    @app.cli.command("setup-all-companies")
-    def setup_all_companies():
-        """🗄️ Inicializa todas las compañías registradas en la base de datos."""
-        try:
-            dispatcher = IAToolkit.get_instance().get_injector().get(Dispatcher)
-            click.echo("🚀 Inicializando base de datos y compañías...")
-            dispatcher.setup_all_companies()
-            click.echo("✅ Base de datos y compañías inicializadas correctamente.")
-        except Exception as e:
-            logging.exception(e)
-            click.echo(f"❌ Error: {e}")
 
-    @app.cli.command("setup-company")
+    @app.cli.command("api-key")
     @click.argument("company_short_name")
-    def setup_company(company_short_name: str):
+    def api_key(company_short_name: str):
         """⚙️ Genera una nueva API key para una compañía ya registrada."""
         try:
             profile_service = IAToolkit.get_instance().get_injector().get(ProfileService)
-            click.echo(f"🔑 Generando API key para '{company_short_name}'...")
+            click.echo(f"🔑 Generating API-KEY for company: '{company_short_name}'...")
             result = profile_service.new_api_key(company_short_name)
 
             if 'error' in result:
                 click.echo(f"❌ Error: {result['error']}")
-                click.echo("👉 Asegúrate de que el nombre de la compañía es correcto y está registrada.")
+                click.echo("👉 Make sure the company is registered and valid.")
             else:
-                click.echo("✅ ¡Configuración lista! Agrega esta variable a tu entorno:")
-                click.echo(f"IATOOLKIT_API_KEY={result['api-key']}")
+                click.echo("✅ ¡Api-key is ready! add this variable to your environment:")
+                click.echo(f"IATOOLKIT_API_KEY='{result['api-key']}'")
         except Exception as e:
             logging.exception(e)
-            click.echo(f"❌ Ocurrió un error inesperado durante la configuración: {e}")
+            click.echo(f"❌ unexpectd error during the configuration: {e}")
 
     @app.cli.command("encrypt-key")
     @click.argument("key")
-    def api_key(key: str):
-        from common.util import Utility
+    def encrypt_llm_api_key(key: str):
+        from iatoolkit.common.util import Utility
 
         util = IAToolkit.get_instance().get_injector().get(Utility)
         try:
             encrypt_key = util.encrypt_key(key)
-            click.echo(f'la clave encriptada es: {encrypt_key} \n')
+            click.echo(f'la api-key del LLM encriptada es: {encrypt_key} \n')
         except Exception as e:
             logging.exception(e)
             click.echo(f"Error: {str(e)}")
 
-    @app.cli.command("exec-tasks")
-    @click.argument("company_short_name")
-    def exec_pending_tasks(company_short_name: str):
-        from services.tasks_service import TaskService
-        task_service = IAToolkit.get_instance().get_injector().get(TaskService)
 
-        try:
-            result = task_service.trigger_pending_tasks(company_short_name)
-            click.echo(result['message'])
-        except Exception as e:
-            logging.exception(e)
-            click.echo(f"Error: {str(e)}")
 
-    @app.cli.command("load")
-    def load_documents():
-        from services.load_documents_service import LoadDocumentsService
-
-        load_documents_service = IAToolkit.get_instance().get_injector().get(LoadDocumentsService)
-        try:
-            result = load_documents_service.load()
-            click.echo(result['message'])
-        except Exception as e:
-            logging.exception(e)
-            click.echo(f"Error: {str(e)}")

iatoolkit/common/exceptions.py

@@ -0,0 +1,48 @@
+# 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
+        EMBEDDING_ERROR = 28
+        MODEL = 29
+
+
+
+    def __init__(self, error_type: ErrorType = ErrorType.SYSTEM_ERROR, message=None):
+        self.error_type = error_type
+        self.message = message
+        super().__init__(self.message)

iatoolkit/common/interfaces/asset_storage.py

@@ -0,0 +1,34 @@
+from enum import Enum
+from typing import List
+import abc
+
+
+class AssetType(Enum):
+    CONFIG = "config"
+    PROMPT = "prompts"
+    SCHEMA = "schema"
+    CONTEXT = "context"
+
+
+class AssetRepository(abc.ABC):
+    @abc.abstractmethod
+    def exists(self, company_short_name: str, asset_type: AssetType, filename: str) -> bool:
+        pass
+
+    @abc.abstractmethod
+    def read_text(self, company_short_name: str, asset_type: AssetType, filename: str) -> str:
+        pass
+
+    @abc.abstractmethod
+    def list_files(self, company_short_name: str, asset_type: AssetType, extension: str = None) -> List[str]:
+        pass
+
+    @abc.abstractmethod
+    def write_text(self, company_short_name: str, asset_type: AssetType, filename: str, content: str) -> None:
+        """Creates or updates a text asset."""
+        pass
+
+    @abc.abstractmethod
+    def delete(self, company_short_name: str, asset_type: AssetType, filename: str) -> None:
+        """Deletes an asset if it exists."""
+        pass

iatoolkit/common/interfaces/database_provider.py

@@ -0,0 +1,39 @@
+import abc
+from typing import Any, List, Dict, Union
+
+class DatabaseProvider(abc.ABC):
+    """
+    Abstract interface for interacting with a database source.
+    Handles both metadata introspection and query execution.
+    """
+
+    # --- Schema Methods ---
+    @abc.abstractmethod
+    def get_all_table_names(self) -> List[str]:
+        pass
+
+    @abc.abstractmethod
+    def get_table_schema(self,
+                         table_name: str,
+                         db_schema: str,
+                         schema_object_name: str | None = None,
+                         exclude_columns: List[str] | None = None) -> str:
+        pass
+
+    # --- Execution Methods ---
+    @abc.abstractmethod
+    def execute_query(self, query: str, commit: bool = False) -> Union[List[Dict[str, Any]], Dict[str, int]]:
+        """
+        Executes a query and returns:
+         - A list of dicts for SELECT (rows).
+         - A dict {'rowcount': N} for INSERT/UPDATE/DELETE.
+        """
+        pass
+
+    @abc.abstractmethod
+    def commit(self) -> None:
+        pass
+
+    @abc.abstractmethod
+    def rollback(self) -> None:
+        pass

iatoolkit/common/model_registry.py

@@ -0,0 +1,159 @@
+# Copyright (c) 2024 Fernando Libedinsky
+# Product: IAToolkit
+#
+# IAToolkit is open source software.
+
+# Copyright (c) 2024 Fernando Libedinsky
+# Product: IAToolkit
+#
+# IAToolkit is open source software.
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from injector import inject, singleton
+from typing import Literal
+
+
+HistoryType = Literal["server_side", "client_side"]
+ProviderType = Literal["openai", "gemini", "deepseek", "xai", "anthropic", "unknown"]
+
+
+@dataclass(frozen=True)
+class ModelMetadata:
+    """Static metadata for a logical family of models."""
+    provider: ProviderType
+    history_type: HistoryType
+
+
+@singleton
+class ModelRegistry:
+    """
+    Central registry for model metadata.
+
+    Responsibilities:
+    - Map a model name to its provider (openai, gemini, deepseek, etc.).
+    - Decide which history strategy to use for a model (server_side / client_side).
+    - Provide convenience helpers (is_openai, is_gemini, is_deepseek, etc.).
+    """
+
+    @inject
+    def __init__(self):
+        # Hardcoded rules for now; can be extended or loaded from config later.
+        # The order of patterns matters: first match wins.
+        self._provider_patterns: dict[ProviderType, tuple[str, ...]] = {
+            "openai": ("gpt", "gpt-5", "gpt-5-mini", "gpt-5.1"),
+            "gemini": ("gemini", "gemini-3"),
+            "deepseek": ("deepseek",),
+            "xai": ("grok", "grok-1", "grok-beta"),
+            "anthropic": ("claude", "claude-3", "claude-2"),
+        }
+
+    # ------------------------------------------------------------------
+    # Public API
+    # ------------------------------------------------------------------
+
+    def get_provider(self, model: str) -> ProviderType:
+        """
+        Returns the logical provider for a given model name.
+
+        Examples:
+            "gpt-4o"        -> "openai"
+            "gemini-pro"    -> "gemini"
+            "deepseek-chat" -> "deepseek"
+        """
+        if not model:
+            return "unknown"
+
+        model_lower = model.lower()
+        for provider, patterns in self._provider_patterns.items():
+            if any(pat in model_lower for pat in patterns):
+                return provider
+
+        return "unknown"
+
+    def get_request_defaults(self, model: str) -> dict:
+        """
+        Return per-model request defaults to keep model-specific policy centralized.
+
+        Notes:
+        - This should only include keys that are supported by the target provider.
+        - Callers should merge these defaults with user-provided params (do not mutate inputs).
+        """
+        model_lower = (model or "").lower()
+        provider = self.get_provider(model_lower)
+
+        # Conservative defaults: do not send provider-specific knobs unless we know they are supported.
+        defaults = {"text": {}, "reasoning": {}}
+
+        # OpenAI/xAI (OpenAI-compatible) support 'text.verbosity' and 'reasoning.effort' in our current integration.
+        if provider in ("openai", "xai"):
+            defaults["text"] = {"verbosity": "low"}
+
+            # Fine-grained per-model tuning.
+            if model_lower in ("gpt-5", "gpt-5-mini"):
+                defaults["reasoning"] = {"effort": "minimal"}
+            elif model_lower == "gpt-5.1":
+                defaults["reasoning"] = {"effort": "low", "summary": "auto"}
+
+        # Gemini/DeepSeek/unknown: keep defaults empty to avoid sending unsupported parameters.
+        return defaults
+
+    def resolve_request_params(self, model: str, text: dict | None = None, reasoning: dict | None = None) -> dict:
+        """
+        Resolve provider/model defaults and merge them with caller-provided overrides.
+
+        Rules:
+        - Defaults come from get_request_defaults(model).
+        - Caller overrides win over defaults.
+        - Input dictionaries are never mutated.
+        """
+        defaults = self.get_request_defaults(model)
+
+        merged_text: dict = {}
+        merged_text.update(defaults.get("text") or {})
+        merged_text.update(text or {})
+
+        merged_reasoning: dict = {}
+        merged_reasoning.update(defaults.get("reasoning") or {})
+        merged_reasoning.update(reasoning or {})
+
+        return {
+            "text": merged_text,
+            "reasoning": merged_reasoning,
+        }
+
+    def get_history_type(self, model: str) -> HistoryType:
+        """
+        Returns the history strategy for a given model.
+
+        Current rules:
+        - openai/xai/anthropic: server_side (API manages conversation state via ids)
+        - gemini/deepseek/unknown: client_side (we manage full message history)
+        """
+        provider = self.get_provider(model)
+
+        if provider in ("openai", "xai", "anthropic"):
+            return "server_side"
+
+        # Default for gemini, deepseek and any unknown provider
+        return "client_side"
+
+    # ------------------------------------------------------------------
+    # Convenience helpers (used during migration)
+    # ------------------------------------------------------------------
+
+    def is_openai_model(self, model: str) -> bool:
+        return self.get_provider(model) == "openai"
+
+    def is_gemini_model(self, model: str) -> bool:
+        return self.get_provider(model) == "gemini"
+
+    def is_deepseek_model(self, model: str) -> bool:
+        return self.get_provider(model) == "deepseek"
+
+    def is_xai_model(self, model: str) -> bool:
+        return self.get_provider(model) == "xai"
+
+    def is_anthropic_model(self, model: str) -> bool:
+        return self.get_provider(model) == "anthropic"

iatoolkit/common/routes.py

@@ -0,0 +1,138 @@
+# Copyright (c) 2024 Fernando Libedinsky
+# Product: IAToolkit
+#
+# IAToolkit is open source software.
+
+from flask import render_template, redirect, url_for,send_from_directory, current_app, abort
+from flask import jsonify
+
+
+# this function register all the views
+def register_views(app):
+
+    from iatoolkit.views.init_context_api_view import InitContextApiView
+    from iatoolkit.views.llmquery_api_view import LLMQueryApiView
+    from iatoolkit.views.signup_view import SignupView
+    from iatoolkit.views.verify_user_view import VerifyAccountView
+    from iatoolkit.views.forgot_password_view import ForgotPasswordView
+    from iatoolkit.views.change_password_view import ChangePasswordView
+    from iatoolkit.views.load_document_api_view import LoadDocumentApiView
+    from iatoolkit.views.user_feedback_api_view import UserFeedbackApiView
+    from iatoolkit.views.prompt_api_view import PromptApiView
+    from iatoolkit.views.history_api_view import HistoryApiView
+    from iatoolkit.views.help_content_api_view import HelpContentApiView
+    from iatoolkit.views.profile_api_view import UserLanguageApiView
+    from iatoolkit.views.embedding_api_view import EmbeddingApiView
+    from iatoolkit.views.login_view import LoginView, FinalizeContextView
+    from iatoolkit.views.load_company_configuration_api_view import LoadCompanyConfigurationApiView
+    from iatoolkit.views.logout_api_view import LogoutApiView
+    from iatoolkit.views.home_view import HomeView
+    from iatoolkit.views.chat_view import ChatView
+    from iatoolkit.views.static_page_view import StaticPageView
+    from iatoolkit.views.root_redirect_view import RootRedirectView
+    from iatoolkit.views.users_api_view import UsersApiView
+
+    # assign root '/' to our new redirect logic
+    app.add_url_rule('/home', view_func=RootRedirectView.as_view('root_redirect'))
+
+    # company home view
+    app.add_url_rule('/<company_short_name>/home', view_func=HomeView.as_view('home'))
+
+    # login for the iatoolkit integrated frontend
+    app.add_url_rule('/<company_short_name>/login', view_func=LoginView.as_view('login'))
+
+    # Chat Route (Direct Access)
+    app.add_url_rule('/<company_short_name>/chat',
+                     view_func=ChatView.as_view('chat'))
+
+    # this endpoint is called when onboarding_shell finish the context load
+    app.add_url_rule(
+        '/<company_short_name>/finalize',
+        view_func=FinalizeContextView.as_view('finalize_no_token')
+    )
+
+    app.add_url_rule(
+        '/<company_short_name>/finalize/<token>',
+        view_func=FinalizeContextView.as_view('finalize_with_token')
+    )
+
+    app.add_url_rule(
+        '/api/profile/language',
+        view_func=UserLanguageApiView.as_view('user_language_api')
+    )
+
+    # logout
+    app.add_url_rule('/<company_short_name>/api/logout',
+                     view_func=LogoutApiView.as_view('logout'))
+
+    # init (reset) the company context
+    app.add_url_rule('/<company_short_name>/api/init-context',
+                     view_func=InitContextApiView.as_view('init-context'),
+                     methods=['POST', 'OPTIONS'])
+
+    # register new user, account verification and forgot password
+    app.add_url_rule('/<company_short_name>/signup',view_func=SignupView.as_view('signup'))
+    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'))
+    app.add_url_rule(
+        '/<string:company_short_name>/api/company-users',
+        view_func=UsersApiView.as_view('company-users')
+    )
+
+    # main chat query, used by the JS in the browser (with credentials)
+    # 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'))
+
+    # 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'))
+    app.add_url_rule('/<company_short_name>/api/help-content', view_func=HelpContentApiView.as_view('help-content'))
+
+    # this endpoint is for upload documents into the vector store (api-key)
+    app.add_url_rule('/api/load-document', view_func=LoadDocumentApiView.as_view('load-document'), methods=['POST'])
+
+    # this endpoint is for generating embeddings for a given text
+    app.add_url_rule('/<company_short_name>/api/embedding',
+                     view_func=EmbeddingApiView.as_view('embedding_api'))
+
+    # company configuration
+    app.add_url_rule('/<company_short_name>/api/load_configuration',
+                     view_func=LoadCompanyConfigurationApiView.as_view('load-configuration'))
+
+    # static pages
+    # url: /pages/foundation o /pages/implementation_plan
+    static_view = StaticPageView.as_view('static_pages')
+    app.add_url_rule('/pages/<page_name>', view_func=static_view, methods=['GET'])
+
+    @app.route('/download/<path:filename>')
+    def download_file(filename):
+        """
+        Esta vista sirve un archivo previamente generado desde el directorio
+        configurado en IATOOLKIT_DOWNLOAD_DIR.
+        """
+        # Valida que la configuración exista
+        if 'IATOOLKIT_DOWNLOAD_DIR' not in current_app.config:
+            abort(500, "Error de configuración: IATOOLKIT_DOWNLOAD_DIR no está definido.")
+
+        download_dir = current_app.config['IATOOLKIT_DOWNLOAD_DIR']
+
+        try:
+            return send_from_directory(
+                download_dir,
+                filename,
+                as_attachment=True  # Fuerza la descarga en lugar de la visualización
+            )
+        except FileNotFoundError:
+            abort(404)
+
+
+    app.add_url_rule('/version', 'version',
+                     lambda: jsonify({"iatoolkit_version": current_app.config.get('VERSION', 'N/A')}))
+
+
+
+