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

iatoolkit/iatoolkit.py

@@ -1,25 +1,25 @@
 # Copyright (c) 2024 Fernando Libedinsky
-# Producto: IAToolkit Core
-# Framework opensource para chatbots empresariales con IA
+# Product: IAToolkit
+#
+# IAToolkit is open source software.
 
-from flask import Flask, url_for, current_app
+from flask import Flask, url_for, get_flashed_messages
 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 iatoolkit.common.exceptions import IAToolkitException
 from urllib.parse import urlparse
 import redis
 import logging
 import os
 from typing import Optional, Dict, Any
-from repositories.database_manager import DatabaseManager
-from injector import Binder, singleton, Injector
+from iatoolkit.repositories.database_manager import DatabaseManager
+from werkzeug.middleware.proxy_fix import ProxyFix
+from injector import Binder, Injector, singleton
 from importlib.metadata import version as _pkg_version, PackageNotFoundError
 
+IATOOLKIT_VERSION = "0.66.2"
 
 # global variable for the unique instance of IAToolkit
 _iatoolkit_instance: Optional['IAToolkit'] = None
@@ -52,13 +52,11 @@ class IAToolkit:
         self.app = None
         self.db_manager = None
         self._injector = None
-        self.version = "0.0.0+dev"
+        self.version = IATOOLKIT_VERSION    # default version
 
     @classmethod
     def get_instance(cls) -> 'IAToolkit':
-        """
-        Obtiene la instancia única de IAToolkit
-        """
+        # get the global IAToolkit instance
         global _iatoolkit_instance
         if _iatoolkit_instance is None:
             _iatoolkit_instance = cls()
@@ -90,29 +88,48 @@ class IAToolkit:
         # and other integrations, as views are handled manually.
         FlaskInjector(app=self.app, injector=self._injector)
 
-        # Step 6: Finalize setup within the application context
+        # Step 6: initialize dispatcher and registered companies
+        self._init_dispatcher_and_company_instances()
+
+        # Step 7: Finalize setup within the application context
         self._setup_redis_sessions()
         self._setup_cors()
         self._setup_additional_services()
         self._setup_cli_commands()
+        self._setup_request_globals()
         self._setup_context_processors()
 
-        try:
-            self.version = _pkg_version("iatoolkit")
-        except PackageNotFoundError:
-            pass
+        # Step 8: define the download_dir for excel's
+        self._setup_download_dir()
 
         logging.info(f"🎉 IAToolkit v{self.version} inicializado correctamente")
         self._initialized = True
         return self.app
 
     def _get_config_value(self, key: str, default=None):
-        """Obtiene un valor de configuración, primero del dict config, luego de env vars"""
+        # get a value from the config dict or the environment variable
         return self.config.get(key, os.getenv(key, default))
 
+    def _setup_request_globals(self):
+        """
+        Configures functions to run before each request to set up
+        request-global variables, such as language.
+        """
+        injector = self._injector
+
+        @self.app.before_request
+        def set_request_language():
+            """
+            Determines and caches the language for the current request in g.lang.
+            """
+            from iatoolkit.services.language_service import LanguageService
+            language_service = injector.get(LanguageService)
+            language_service.get_current_language()
+
     def _setup_logging(self):
-        log_level_str = self._get_config_value('FLASK_ENV', 'production')
-        log_level = logging.INFO if log_level_str in ('dev', 'development') else logging.WARNING
+        # Lee el nivel de log desde una variable de entorno, con 'INFO' como valor por defecto.
+        log_level_name = os.getenv('LOG_LEVEL', 'INFO').upper()
+        log_level = getattr(logging, log_level_name, logging.INFO)
 
         logging.basicConfig(
             level=log_level,
@@ -123,7 +140,7 @@ class IAToolkit:
 
     def _register_routes(self):
         """Registers routes by passing the configured injector."""
-        from common.routes import register_views
+        from iatoolkit.common.routes import register_views
 
         # Pass the injector to the view registration function
         register_views(self._injector, self.app)
@@ -141,11 +158,21 @@ class IAToolkit:
         is_https = self._get_config_value('USE_HTTPS', 'false').lower() == 'true'
         is_dev = self._get_config_value('FLASK_ENV') == 'development'
 
+        # get the iatoolkit domain
+        parsed_url = urlparse(os.getenv('IATOOLKIT_BASE_URL'))
+        domain = parsed_url.netloc
+
+        try:
+            self.version = _pkg_version("iatoolkit")
+        except PackageNotFoundError:
+            pass
+
+
         self.app.config.update({
             'VERSION': self.version,
             'SECRET_KEY': self._get_config_value('FLASK_SECRET_KEY', 'iatoolkit-default-secret'),
-            'SESSION_COOKIE_SAMESITE': "None" if is_https else "Lax",
-            'SESSION_COOKIE_SECURE': is_https,
+            'SESSION_COOKIE_SAMESITE': "None",
+            'SESSION_COOKIE_SECURE': True,
             'SESSION_PERMANENT': False,
             'SESSION_USE_SIGNER': True,
             'JWT_SECRET_KEY': self._get_config_value('JWT_SECRET_KEY', 'iatoolkit-jwt-secret'),
@@ -153,6 +180,12 @@ class IAToolkit:
             'JWT_EXPIRATION_SECONDS_CHAT': int(self._get_config_value('JWT_EXPIRATION_SECONDS_CHAT', 3600))
         })
 
+        if parsed_url.scheme == 'https':
+            self.app.config['PREFERRED_URL_SCHEME'] = 'https'
+
+        # 2. ProxyFix para no tener problemas con iframes y rutas
+        self.app.wsgi_app = ProxyFix(self.app.wsgi_app, x_proto=1)
+
         # Configuración para tokenizers en desarrollo
         if is_dev:
             os.environ["TOKENIZERS_PARALLELISM"] = "false"
@@ -169,6 +202,15 @@ class IAToolkit:
         self.db_manager.create_all()
         logging.info("✅ Base de datos configurada correctamente")
 
+        @self.app.teardown_appcontext
+        def remove_session(exception=None):
+            """
+            Flask calls this after each request.
+            It ensures the SQLAlchemy session is properly closed
+            and the DB connection is returned to the pool.
+            """
+            self.db_manager.scoped_session.remove()
+
     def _setup_redis_sessions(self):
         redis_url = self._get_config_value('REDIS_URL')
         if not redis_url:
@@ -199,19 +241,19 @@ class IAToolkit:
 
     def _setup_cors(self):
         """🌐 Configura CORS"""
-        # Origins por defecto para desarrollo
+        from iatoolkit.company_registry import get_company_registry
+
+        # default CORS origin
         default_origins = [
-            "http://localhost:5001",
-            "http://127.0.0.1:5001",
             os.getenv('IATOOLKIT_BASE_URL')
         ]
 
-        # Obtener origins adicionales desde configuración/env
+        # Iterate through the registered company names
         extra_origins = []
-        for i in range(1, 11):  # Soporte para CORS_ORIGIN_1 a CORS_ORIGIN_10
-            origin = self._get_config_value(f'CORS_ORIGIN_{i}')
-            if origin:
-                extra_origins.append(origin)
+        all_company_instances = get_company_registry().get_all_company_instances()
+        for company_name, company_instance in all_company_instances.items():
+            cors_origin = company_instance.company.parameters.get('cors_origin', [])
+            extra_origins += cors_origin
 
         all_origins = default_origins + extra_origins
 
@@ -226,19 +268,17 @@ class IAToolkit:
 
         logging.info(f"✅ CORS configurado para: {all_origins}")
 
-
     def _configure_core_dependencies(self, binder: Binder):
         """⚙️ Configures all system dependencies."""
         try:
             # Core dependencies
-            binder.bind(Flask, to=self.app, scope=singleton)
+            binder.bind(Flask, to=self.app)
             binder.bind(DatabaseManager, to=self.db_manager, scope=singleton)
 
             # Bind all application components by calling the specific methods
             self._bind_repositories(binder)
             self._bind_services(binder)
             self._bind_infrastructure(binder)
-            self._bind_views(binder)
 
             logging.info("✅ Dependencias configuradas correctamente")
 
@@ -250,11 +290,12 @@ class IAToolkit:
             )
 
     def _bind_repositories(self, binder: Binder):
-        from repositories.document_repo import DocumentRepo
-        from repositories.profile_repo import ProfileRepo
-        from repositories.llm_query_repo import LLMQueryRepo
-        from repositories.vs_repo import VSRepo
-        from repositories.tasks_repo import TaskRepo
+        from iatoolkit.repositories.document_repo import DocumentRepo
+        from iatoolkit.repositories.profile_repo import ProfileRepo
+        from iatoolkit.repositories.llm_query_repo import LLMQueryRepo
+
+        from iatoolkit.repositories.vs_repo import VSRepo
+        from iatoolkit.repositories.tasks_repo import TaskRepo
 
         binder.bind(DocumentRepo, to=DocumentRepo)
         binder.bind(ProfileRepo, to=ProfileRepo)
@@ -263,17 +304,20 @@ class IAToolkit:
         binder.bind(TaskRepo, to=TaskRepo)
 
     def _bind_services(self, binder: Binder):
-        from services.query_service import QueryService
-        from services.tasks_service import TaskService
-        from services.benchmark_service import BenchmarkService
-        from services.document_service import DocumentService
-        from services.prompt_manager_service import PromptService
-        from services.excel_service import ExcelService
-        from services.mail_service import MailService
-        from services.load_documents_service import LoadDocumentsService
-        from services.profile_service import ProfileService
-        from services.jwt_service import JWTService
-        from services.dispatcher_service import Dispatcher
+        from iatoolkit.services.query_service import QueryService
+        from iatoolkit.services.tasks_service import TaskService
+        from iatoolkit.services.benchmark_service import BenchmarkService
+        from iatoolkit.services.document_service import DocumentService
+        from iatoolkit.services.prompt_manager_service import PromptService
+        from iatoolkit.services.excel_service import ExcelService
+        from iatoolkit.services.mail_service import MailService
+        from iatoolkit.services.load_documents_service import LoadDocumentsService
+        from iatoolkit.services.profile_service import ProfileService
+        from iatoolkit.services.jwt_service import JWTService
+        from iatoolkit.services.dispatcher_service import Dispatcher
+        from iatoolkit.services.branding_service import BrandingService
+        from iatoolkit.services.i18n_service import I18nService
+        from iatoolkit.services.language_service import LanguageService
 
         binder.bind(QueryService, to=QueryService)
         binder.bind(TaskService, to=TaskService)
@@ -285,41 +329,42 @@ class IAToolkit:
         binder.bind(LoadDocumentsService, to=LoadDocumentsService)
         binder.bind(ProfileService, to=ProfileService)
         binder.bind(JWTService, to=JWTService)
-        binder.bind(Dispatcher, to=Dispatcher, scope=singleton)
+        binder.bind(Dispatcher, to=Dispatcher)
+        binder.bind(BrandingService, to=BrandingService)
+        binder.bind(I18nService, to=I18nService)
+        binder.bind(LanguageService, to=LanguageService)
 
     def _bind_infrastructure(self, binder: Binder):
-        from infra.llm_client import llmClient
-        from infra.llm_proxy import LLMProxy
-        from infra.google_chat_app import GoogleChatApp
-        from infra.mail_app import MailApp
-
-        binder.bind(LLMProxy, to=LLMProxy, scope=singleton)
-        binder.bind(llmClient, to=llmClient, scope=singleton)
+        from iatoolkit.infra.llm_client import llmClient
+        from iatoolkit.infra.llm_proxy import LLMProxy
+        from iatoolkit.infra.google_chat_app import GoogleChatApp
+        from iatoolkit.infra.mail_app import MailApp
+        from iatoolkit.services.auth_service import AuthService
+        from iatoolkit.common.util import Utility
+
+        binder.bind(LLMProxy, to=LLMProxy)
+        binder.bind(llmClient, to=llmClient)
         binder.bind(GoogleChatApp, to=GoogleChatApp)
         binder.bind(MailApp, to=MailApp)
-        binder.bind(IAuthentication, to=IAuthentication)
+        binder.bind(AuthService, to=AuthService)
         binder.bind(Utility, to=Utility)
 
-    def _bind_views(self, binder: Binder):
-        """Vincula las vistas después de que el injector ha sido creado"""
-        from views.llmquery_view import LLMQueryView
-        from views.home_view import HomeView
-        from views.chat_view import ChatView
-        from views.change_password_view import ChangePasswordView
+    def _setup_additional_services(self):
+        Bcrypt(self.app)
 
-        binder.bind(HomeView, to=HomeView)
-        binder.bind(ChatView, to=ChatView)
-        binder.bind(ChangePasswordView, to=ChangePasswordView)
-        binder.bind(LLMQueryView, to=LLMQueryView)
+    def _init_dispatcher_and_company_instances(self):
+        from iatoolkit.company_registry import get_company_registry
+        from iatoolkit.services.dispatcher_service import Dispatcher
 
-        logging.info("✅ Views configuradas correctamente")
+        # instantiate all the registered companies
+        get_company_registry().instantiate_companies(self._injector)
 
-    def _setup_additional_services(self):
-        Bcrypt(self.app)
+        # use the dispatcher to start the execution of every company
+        dispatcher = self._injector.get(Dispatcher)
+        dispatcher.start_execution()
 
     def _setup_cli_commands(self):
         from iatoolkit.cli_commands import register_core_commands
-        from services.dispatcher_service import Dispatcher
         from iatoolkit.company_registry import get_company_registry
 
         # 1. Register core commands
@@ -328,16 +373,10 @@ class IAToolkit:
 
         # 2. Register company-specific commands
         try:
-            # Get the dispatcher, which holds the company instances
-            dispatcher = self.get_injector().get(Dispatcher)
-            registry = get_company_registry()
-
             # Iterate through the registered company names
-            for company_name in registry.get_registered_companies():
-                company_instance = dispatcher.get_company_instance(company_name)
-                if company_instance:
-                    company_instance.register_cli_commands(self.app)
-                    logging.info(f"✅ Comandos CLI para la compañía '{company_name}' registrados.")
+            all_company_instances = get_company_registry().get_all_company_instances()
+            for company_name, company_instance in all_company_instances.items():
+                company_instance.register_cli_commands(self.app)
 
         except Exception as e:
             logging.error(f"❌ Error durante el registro de comandos de compañías: {e}")
@@ -346,27 +385,46 @@ class IAToolkit:
         # Configura context processors para templates
         @self.app.context_processor
         def inject_globals():
+            from iatoolkit.common.session_manager import SessionManager
+            from iatoolkit.services.profile_service import ProfileService
+            from iatoolkit.services.i18n_service import I18nService
+
+            # Get services from the injector
+            profile_service = self._injector.get(ProfileService)
+            i18n_service = self._injector.get(I18nService)
+
+            # The 't' function wrapper no longer needs to determine the language itself.
+            # It will be automatically handled by the refactored I18nService.
+            def translate_for_template(key: str, **kwargs):
+                return i18n_service.t(key, **kwargs)
+
+            # Get user profile if a session exists
+            user_profile = profile_service.get_current_session_info().get('profile', {})
+
             return {
                 'url_for': url_for,
                 'iatoolkit_version': self.version,
                 'app_name': 'IAToolkit',
-                'user': SessionManager.get('user'),
-                'user_company': SessionManager.get('company_short_name'),
+                'user_identifier': SessionManager.get('user_identifier'),
+                'company_short_name': SessionManager.get('company_short_name'),
+                'user_is_local': user_profile.get('user_is_local'),
+                'user_email': user_profile.get('user_email'),
+                'iatoolkit_base_url': os.environ.get('IATOOLKIT_BASE_URL', ''),
+                'flashed_messages': get_flashed_messages(with_categories=True),
+                't': translate_for_template
             }
 
     def _get_default_static_folder(self) -> str:
         try:
             current_dir = os.path.dirname(os.path.abspath(__file__))  # .../src/iatoolkit
-            src_dir = os.path.dirname(current_dir)  # .../src
-            return os.path.join(src_dir, "static")
+            return os.path.join(current_dir, "static")
         except:
             return 'static'
 
     def _get_default_template_folder(self) -> str:
         try:
             current_dir = os.path.dirname(os.path.abspath(__file__))  # .../src/iatoolkit
-            src_dir = os.path.dirname(current_dir)  # .../src
-            return os.path.join(src_dir, "templates")
+            return os.path.join(current_dir, "templates")
         except:
             return 'templates'
 
@@ -380,7 +438,7 @@ class IAToolkit:
         return self._injector
 
     def get_dispatcher(self):
-        from services.dispatcher_service import Dispatcher
+        from iatoolkit.services.dispatcher_service import Dispatcher
         if not self._injector:
             raise IAToolkitException(
                 IAToolkitException.ErrorType.CONFIG_ERROR,
@@ -396,18 +454,33 @@ class IAToolkit:
             )
         return self.db_manager
 
+    def _setup_download_dir(self):
+        # 1. set the default download directory
+        default_download_dir = os.path.join(os.getcwd(), 'iatoolkit-downloads')
+
+        # 3. if user specified one, use it
+        download_dir = self.app.config.get('IATOOLKIT_DOWNLOAD_DIR', default_download_dir)
+
+        # 3. save it in the app config
+        self.app.config['IATOOLKIT_DOWNLOAD_DIR'] = download_dir
+
+        # 4. make sure the directory exists
+        try:
+            os.makedirs(download_dir, exist_ok=True)
+        except OSError as e:
+            raise IAToolkitException(
+                IAToolkitException.ErrorType.CONFIG_ERROR,
+                "No se pudo crear el directorio de descarga. Verifique que el directorio existe y tenga permisos de escritura."
+            )
+        logging.info(f"✅ download dir created in: {download_dir}")
+
 
 def current_iatoolkit() -> IAToolkit:
     return IAToolkit.get_instance()
 
-# 🚀 Función de conveniencia para inicialización rápida
+# Función de conveniencia para inicialización rápida
 def create_app(config: Optional[Dict[str, Any]] = None) -> Flask:
     toolkit = IAToolkit(config)
     toolkit.create_iatoolkit()
 
     return toolkit.app
-
-if __name__ == "__main__":
-    app = create_app()
-    if app:
-        app.run(debug=True)

iatoolkit/infra/__init__.py

@@ -0,0 +1,5 @@
+# Copyright (c) 2024 Fernando Libedinsky
+# Product: IAToolkit
+#
+# IAToolkit is open source software.
+

iatoolkit/infra/call_service.py

@@ -0,0 +1,140 @@
+# Copyright (c) 2024 Fernando Libedinsky
+# Product: IAToolkit
+#
+# IAToolkit is open source software.
+
+from iatoolkit.common.exceptions import IAToolkitException
+from injector import inject
+# call_service.py
+import requests
+from typing import Optional, Dict, Any, Tuple, Union
+from requests import RequestException
+
+class CallServiceClient:
+    @inject
+    def __init__(self):
+        self.headers = {'Content-Type': 'application/json'}
+
+    def _merge_headers(self, extra: Optional[Dict[str, str]]) -> Dict[str, str]:
+        if not extra:
+            return dict(self.headers)
+        merged = dict(self.headers)
+        merged.update(extra)
+        return merged
+
+    def _normalize_timeout(self, timeout: Union[int, float, Tuple[int, int], Tuple[float, float]]) -> Tuple[float, float]:
+        # Si pasan un solo número → (connect, read) = (10, timeout)
+        if isinstance(timeout, (int, float)):
+            return (10, float(timeout))
+        return (float(timeout[0]), float(timeout[1]))
+
+    def _deserialize_response(self, response) -> Tuple[Any, int]:
+        try:
+            return response.json(), response.status_code
+        except ValueError:
+            # No es JSON → devolver texto
+            return response.text, response.status_code
+
+    def get(
+        self,
+        endpoint: str,
+        params: Optional[Dict[str, Any]] = None,
+        headers: Optional[Dict[str, str]] = None,
+        timeout: Union[int, float, Tuple[int, int]] = 10
+    ):
+        try:
+            response = requests.get(
+                endpoint,
+                params=params,
+                headers=self._merge_headers(headers),
+                timeout=self._normalize_timeout(timeout)
+            )
+        except RequestException as e:
+            raise IAToolkitException(IAToolkitException.ErrorType.REQUEST_ERROR, str(e))
+        return self._deserialize_response(response)
+
+    def post(
+        self,
+        endpoint: str,
+        json_dict: Optional[Dict[str, Any]] = None,
+        params: Optional[Dict[str, Any]] = None,
+        headers: Optional[Dict[str, str]] = None,
+        timeout: Union[int, float, Tuple[int, int]] = 10
+    ):
+        try:
+            response = requests.post(
+                endpoint,
+                params=params,
+                json=json_dict,
+                headers=self._merge_headers(headers),
+                timeout=self._normalize_timeout(timeout)
+            )
+        except RequestException as e:
+            raise IAToolkitException(IAToolkitException.ErrorType.REQUEST_ERROR, str(e))
+        return self._deserialize_response(response)
+
+    def put(
+        self,
+        endpoint: str,
+        json_dict: Optional[Dict[str, Any]] = None,
+        params: Optional[Dict[str, Any]] = None,
+        headers: Optional[Dict[str, str]] = None,
+        timeout: Union[int, float, Tuple[int, int]] = 10
+    ):
+        try:
+            response = requests.put(
+                endpoint,
+                params=params,
+                json=json_dict,
+                headers=self._merge_headers(headers),
+                timeout=self._normalize_timeout(timeout)
+            )
+        except RequestException as e:
+            raise IAToolkitException(IAToolkitException.ErrorType.REQUEST_ERROR, str(e))
+        return self._deserialize_response(response)
+
+    def delete(
+        self,
+        endpoint: str,
+        json_dict: Optional[Dict[str, Any]] = None,
+        params: Optional[Dict[str, Any]] = None,
+        headers: Optional[Dict[str, str]] = None,
+        timeout: Union[int, float, Tuple[int, int]] = 10
+    ):
+        try:
+            response = requests.delete(
+                endpoint,
+                params=params,
+                json=json_dict,
+                headers=self._merge_headers(headers),
+                timeout=self._normalize_timeout(timeout)
+            )
+        except RequestException as e:
+            raise IAToolkitException(IAToolkitException.ErrorType.REQUEST_ERROR, str(e))
+        return self._deserialize_response(response)
+
+    def post_files(
+        self,
+        endpoint: str,
+        data: Dict[str, Any],
+        params: Optional[Dict[str, Any]] = None,
+        headers: Optional[Dict[str, str]] = None,
+        timeout: Union[int, float, Tuple[int, int]] = 10
+    ):
+        # Para multipart/form-data no imponemos Content-Type por defecto
+        merged_headers = dict(self.headers)
+        merged_headers.pop('Content-Type', None)
+        if headers:
+            merged_headers.update(headers)
+
+        try:
+            response = requests.post(
+                endpoint,
+                params=params,
+                files=data,
+                headers=merged_headers,
+                timeout=self._normalize_timeout(timeout)
+            )
+        except RequestException as e:
+            raise IAToolkitException(IAToolkitException.ErrorType.REQUEST_ERROR, str(e))
+        return self._deserialize_response(response)

iatoolkit/infra/connectors/__init__.py

@@ -0,0 +1,5 @@
+# Copyright (c) 2024 Fernando Libedinsky
+# Product: IAToolkit
+#
+# IAToolkit is open source software.
+

iatoolkit/infra/connectors/file_connector.py

@@ -0,0 +1,17 @@
+# Copyright (c) 2024 Fernando Libedinsky
+# Product: IAToolkit
+#
+# IAToolkit is open source software.
+
+from abc import ABC, abstractmethod
+from typing import List
+
+
+class FileConnector(ABC):
+    @abstractmethod
+    def list_files(self) -> List[str]:
+        pass
+
+    @abstractmethod
+    def get_file_content(self, file_path: str) -> bytes:
+        pass