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

iatoolkit/services/history_manager_service.py

@@ -0,0 +1,208 @@
+# Copyright (c) 2024 Fernando Libedinsky
+# Product: IAToolkit
+#
+# IAToolkit is open source software.
+
+
+import logging
+import json
+from typing import Dict, Any, Optional
+from iatoolkit.services.user_session_context_service import UserSessionContextService
+from iatoolkit.services.i18n_service import I18nService
+from iatoolkit.services.llm_client_service import llmClient
+from iatoolkit.repositories.models import Company
+from iatoolkit.repositories.llm_query_repo import LLMQueryRepo
+from iatoolkit.repositories.profile_repo import ProfileRepo
+from injector import inject
+
+
+class HistoryManagerService:
+    """
+    Manages conversation history for LLMs in a unified way.
+    Handles:
+    1. Server-side history (e.g., OpenAI response_ids).
+    2. Client-side history (e.g., Gemini message lists).
+    3. Database persistence retrieval (full chat history).
+    """
+    TYPE_SERVER_SIDE = 'server_side'  # For models like OpenAI
+    TYPE_CLIENT_SIDE = 'client_side'  # For models like Gemini and Deepseek
+
+    GEMINI_MAX_TOKENS_CONTEXT_HISTORY = 200000
+
+
+    @inject
+    def __init__(self,
+                 session_context: UserSessionContextService,
+                 i18n: I18nService,
+                 llm_query_repo: LLMQueryRepo,
+                 profile_repo: ProfileRepo,
+                 llm_client: Optional[llmClient] = None):
+        self.session_context = session_context
+        self.i18n = i18n
+        self.llm_query_repo = llm_query_repo
+        self.profile_repo = profile_repo
+        self.llm_client = llm_client
+
+    def initialize_context(self,
+                           company_short_name: str,
+                           user_identifier: str,
+                           history_type: str,
+                           prepared_context: str,
+                           company: Company, model: str) -> Dict[str, Any]:
+        """
+        Initializes a new conversation history.
+        """
+        # 1. Clear existing history
+        self.session_context.clear_llm_history(company_short_name, user_identifier, model=model)
+
+        if history_type == self.TYPE_SERVER_SIDE:
+            # OpenAI: Send system prompt to API and store the resulting ID
+            response_id = self.llm_client.set_company_context(
+                company=company,
+                company_base_context=prepared_context,
+                model=model
+            )
+            self.session_context.save_last_response_id(company_short_name, user_identifier, response_id, model=model)
+            self.session_context.save_initial_response_id(company_short_name, user_identifier, response_id, model=model)
+            return {'response_id': response_id}
+
+        elif history_type == self.TYPE_CLIENT_SIDE:
+            # Gemini: Store system prompt as the first message in the list
+            context_history = [{"role": "user", "content": prepared_context}]
+            self.session_context.save_context_history(company_short_name, user_identifier, context_history, model=model)
+            return {}
+
+        return {}
+
+    def populate_request_params(self,
+                                handle: Any,
+                                user_turn_prompt: str,
+                                ignore_history: bool = False) -> bool:
+        """
+        Populates the request_params within the HistoryHandle.
+        Returns True if a rebuild is needed, False otherwise.
+        """
+        model = getattr(handle, "model", None)
+
+        if handle.type == self.TYPE_SERVER_SIDE:
+            if ignore_history:
+                previous_response_id = self.session_context.get_initial_response_id(
+                    handle.company_short_name,handle.user_identifier,model=model)
+            else:
+                previous_response_id = self.session_context.get_last_response_id(
+                    handle.company_short_name,handle.user_identifier,model=model)
+
+
+            if not previous_response_id:
+                handle.request_params = {}
+                return True  # Needs rebuild
+
+            handle.request_params = {'previous_response_id': previous_response_id}
+            return False
+
+        elif handle.type == self.TYPE_CLIENT_SIDE:
+            context_history = self.session_context.get_context_history(
+                handle.company_short_name,handle.user_identifier,model=model) or []
+
+            if not context_history:
+                handle.request_params = {}
+                return True  # Needs rebuild
+
+            if ignore_history and len(context_history) > 1:
+                # Keep only system prompt
+                context_history = [context_history[0]]
+
+            # Append the current user turn to the context sent to the API
+            context_history.append({"role": "user", "content": user_turn_prompt})
+
+            self._trim_context_history(context_history)
+
+            handle.request_params = {'context_history': context_history}
+            return False
+
+        handle.request_params = {}
+        return False
+
+    def update_history(self,
+                       history_handle: Any,
+                       user_turn_prompt: str,
+                       response: Dict[str, Any]):
+        """Saves or updates the history after a successful LLM call."""
+
+        # We access the type from the handle
+        history_type = history_handle.type
+        company_short_name = history_handle.company_short_name
+        user_identifier = history_handle.user_identifier
+        model = getattr(history_handle, "model", None)
+
+        if history_type == self.TYPE_SERVER_SIDE:
+            if "response_id" in response:
+                self.session_context.save_last_response_id(
+                    company_short_name,
+                    user_identifier,
+                    response["response_id"],
+                    model=model)
+
+        elif history_type == self.TYPE_CLIENT_SIDE:
+            # get the history for this company/user/model
+            context_history = self.session_context.get_context_history(
+                company_short_name,
+                user_identifier,
+                model=model)
+
+            # Ensure the user prompt is recorded if not already.
+            # We check content equality to handle the case where the previous message was
+            # also 'user' (e.g., System Prompt) but different content.
+            last_content = context_history[-1].get("content") if context_history else None
+
+            if last_content != user_turn_prompt:
+                context_history.append({"role": "user", "content": user_turn_prompt})
+
+            if response.get('answer'):
+                context_history.append({"role": "assistant", "content": response.get('answer', '')})
+
+            self.session_context.save_context_history(
+                company_short_name,
+                user_identifier,
+                context_history,
+                model=model)
+
+    def _trim_context_history(self, context_history: list):
+        """Internal helper to keep token usage within limits for client-side history."""
+        if not context_history or len(context_history) <= 1:
+            return
+        try:
+            total_tokens = sum(self.llm_client.count_tokens(json.dumps(message)) for message in context_history)
+        except Exception as e:
+            logging.error(f"Error counting tokens for history: {e}.")
+            return
+
+        while total_tokens > self.GEMINI_MAX_TOKENS_CONTEXT_HISTORY and len(context_history) > 1:
+            try:
+                # Remove the oldest message after system prompt
+                removed_message = context_history.pop(1)
+                removed_tokens = self.llm_client.count_tokens(json.dumps(removed_message))
+                total_tokens -= removed_tokens
+                logging.warning(
+                    f"History tokens exceed limit. Removed old message. New total: {total_tokens} tokens."
+                )
+            except IndexError:
+                break
+
+    # --- this is for the history popup in the chat page
+    def get_full_history(self, company_short_name: str, user_identifier: str) -> dict:
+        """Retrieves the full persisted history from the database."""
+        try:
+            company = self.profile_repo.get_company_by_short_name(company_short_name)
+            if not company:
+                return {"error": self.i18n.t('errors.company_not_found', company_short_name=company_short_name)}
+
+            history = self.llm_query_repo.get_history(company, user_identifier)
+            if not history:
+                return {'message': 'empty history', 'history': []}
+
+            history_list = [query.to_dict() for query in history]
+            return {'message': 'history loaded ok', 'history': history_list}
+
+        except Exception as e:
+            return {'error': str(e)}

iatoolkit/services/i18n_service.py

@@ -0,0 +1,104 @@
+# iatoolkit/services/i18n_service.py
+import os
+import logging
+from injector import inject, singleton
+from iatoolkit.common.util import Utility
+from iatoolkit.services.language_service import LanguageService
+
+@singleton
+class I18nService:
+    """
+    Servicio centralizado para manejar la internacionalización (i18n).
+    Carga todas las traducciones desde archivos YAML en memoria al iniciar.
+    """
+    FALLBACK_LANGUAGE = 'es'
+
+    @inject
+    def __init__(self, util: Utility, language_service: LanguageService):
+        self.util = util
+        self.language_service = language_service
+
+        self.translations = {}
+        self._load_translations()
+
+    def _load_translations(self):
+        """
+        Carga todos los archivos .yaml del directorio 'locales' en memoria.
+        """
+        locales_dir = os.path.join(os.path.dirname(__file__), '..', 'locales')
+        if not os.path.exists(locales_dir):
+            logging.error("Directory 'locales' not found.")
+            return
+
+        for filename in os.listdir(locales_dir):
+            if filename.endswith('.yaml'):
+                lang_code = filename.split('.')[0]
+                filepath = os.path.join(locales_dir, filename)
+                try:
+                    self.translations[lang_code] = self.util.load_schema_from_yaml(filepath)
+                except Exception as e:
+                    logging.error(f"Error while loading the translation file {filepath}: {e}")
+
+    def _get_nested_key(self, lang: str, key: str):
+        """
+        Obtiene un valor de un diccionario anidado usando una clave con puntos.
+        """
+        data = self.translations.get(lang, {})
+        keys = key.split('.')
+        for k in keys:
+            if isinstance(data, dict) and k in data:
+                data = data[k]
+            else:
+                return None
+        return data
+
+    def get_translation_block(self, key: str, lang: str = None) -> dict:
+        """
+        Gets a whole dictionary block from the translations.
+        Useful for passing a set of translations to JavaScript.
+        """
+        if lang is None:
+            lang = self.language_service.get_current_language()
+
+        # 1. Try to get the block in the requested language
+        block = self._get_nested_key(lang, key)
+
+        # 2. If not found, try the fallback language
+        if not isinstance(block, dict):
+            block = self._get_nested_key(self.FALLBACK_LANGUAGE, key)
+
+        return block if isinstance(block, dict) else {}
+
+    def t(self, key: str, lang: str = None, **kwargs) -> str:
+        """
+        Gets the translation for a given key.
+        If 'lang' is provided, it's used. Otherwise, it's determined automatically.
+        """
+        # If no specific language is requested, determine it from the current context.
+        if lang is None:
+            lang = self.language_service.get_current_language()
+
+        # 1. Attempt to get the translation in the requested language
+        message = self._get_nested_key(lang, key)
+
+        # 2. If not found, try the fallback language
+        if message is None and lang != self.FALLBACK_LANGUAGE:
+            logging.warning(
+                f"Translation key '{key}' not found for language '{lang}'. Attempting fallback to '{self.FALLBACK_LANGUAGE}'.")
+            message = self._get_nested_key(self.FALLBACK_LANGUAGE, key)
+
+        # 3. If still not found, return the key itself as a last resort
+        if message is None:
+            logging.error(
+                f"Translation key '{key}' not found, even in fallback '{self.FALLBACK_LANGUAGE}'.")
+            return key
+
+        # 4. If variables are provided, format the message
+        if kwargs:
+            try:
+                return message.format(**kwargs)
+            except KeyError as e:
+                logging.error(f"Error formatting key '{key}': missing variable {e} in arguments.")
+                return message
+
+        return message

iatoolkit/services/jwt_service.py

@@ -0,0 +1,80 @@
+# Copyright (c) 2024 Fernando Libedinsky
+# Product: IAToolkit
+#
+# IAToolkit is open source software.
+
+import jwt
+import time
+import logging
+from injector import singleton, inject
+from typing import Optional, Dict, Any
+from flask import Flask
+
+
+@singleton
+class JWTService:
+    @inject
+    def __init__(self,  app: Flask):
+        # Acceder a la configuración directamente desde app.config
+        try:
+            self.secret_key = app.config['IATOOLKIT_SECRET_KEY']
+            self.algorithm = app.config['JWT_ALGORITHM']
+        except KeyError as e:
+            logging.error(f"missing JWT configuration: {e}.")
+            raise RuntimeError(f"missing JWT configuration variables: {e}")
+
+    def generate_chat_jwt(self,
+                          company_short_name: str,
+                          user_identifier: str,
+                          expires_delta_seconds: int) -> Optional[str]:
+        # generate a JWT for a chat session
+        try:
+            if not company_short_name or not user_identifier:
+                logging.error(f"Missing token ID: {company_short_name}/{user_identifier}")
+                return None
+
+            payload = {
+                'company_short_name': company_short_name,
+                'user_identifier': user_identifier,
+                'exp': time.time() + expires_delta_seconds,
+                'iat': time.time(),
+                'type': 'chat_session'  # Identificador del tipo de token
+            }
+            token = jwt.encode(payload, self.secret_key, algorithm=self.algorithm)
+            return token
+        except Exception as e:
+            logging.error(f"Error al generar JWT para {company_short_name}/{user_identifier}: {e}")
+            return None
+
+    def validate_chat_jwt(self, token: str) -> Optional[Dict[str, Any]]:
+        """
+        Valida un JWT de sesión de chat.
+        Retorna el payload decodificado si es válido y coincide con la empresa, o None.
+        """
+        if not token:
+            return None
+        try:
+            payload = jwt.decode(token, self.secret_key, algorithms=[self.algorithm])
+
+            # Validaciones adicionales
+            if payload.get('type') != 'chat_session':
+                logging.warning(f"Invalid JWT type '{payload.get('type')}'")
+                return None
+
+            # user_identifier debe estar presente
+            if not payload.get('user_identifier'):
+                logging.warning(f"missing user_identifier in JWT payload.")
+                return None
+
+            if not payload.get('company_short_name'):
+                logging.warning(f"missing company_short_name in JWT payload.")
+                return None
+
+            return payload
+
+        except jwt.InvalidTokenError as e:
+            logging.warning(f"Invalid JWT token:: {e}")
+            return None
+        except Exception as e:
+            logging.error(f"unexpected error during JWT validation: {e}")
+            return None

iatoolkit/services/language_service.py

@@ -0,0 +1,89 @@
+# iatoolkit/services/language_service.py
+
+import logging
+from injector import inject, singleton
+from flask import g, request
+from iatoolkit.repositories.profile_repo import ProfileRepo
+from iatoolkit.services.configuration_service import ConfigurationService
+from iatoolkit.common.session_manager import SessionManager
+
+@singleton
+class LanguageService:
+    """
+    Determines the correct language for the current request
+    based on a defined priority order (session, URL, etc.)
+    and caches it in the Flask 'g' object for the request's lifecycle.
+    """
+
+    FALLBACK_LANGUAGE = 'es'
+
+    @inject
+    def __init__(self,
+                 config_service: ConfigurationService,
+                 profile_repo: ProfileRepo):
+        self.config_service = config_service
+        self.profile_repo = profile_repo
+
+    def _get_company_short_name(self) -> str | None:
+        """
+        Gets the company_short_name from the current request context.
+        This handles different scenarios like web sessions, public URLs, and API calls.
+
+        Priority Order:
+        1. Flask Session (for logged-in web users).
+        2. URL rule variable (for public pages and API endpoints).
+        """
+        # 1. Check session for logged-in users
+        company_short_name = SessionManager.get('company_short_name')
+        if company_short_name:
+            return company_short_name
+
+        # 2. Check URL arguments (e.g., /<company_short_name>/login)
+        # This covers public pages and most API calls.
+        if request.view_args and 'company_short_name' in request.view_args:
+            return request.view_args['company_short_name']
+
+        return None
+
+    def get_current_language(self) -> str:
+        """
+        Determines and caches the language for the current request using a priority order:
+        0. Query parameter '?lang=<code>' (highest priority; e.g., 'en', 'es').
+        1. User's preference (from their profile).
+        2. Company's default language.
+        3. System-wide fallback language ('es').
+        """
+        if 'lang' in g:
+            return g.lang
+
+        try:
+            # Priority 0: Explicit query parameter (?lang=)
+            lang_arg = request.args.get('lang')
+            if lang_arg:
+                g.lang = lang_arg
+                return g.lang
+
+            # Priority 1: User's preferred language
+            user_identifier = SessionManager.get('user_identifier')
+            if user_identifier:
+                user = self.profile_repo.get_user_by_email(user_identifier)
+                if user and user.preferred_language:
+                    logging.debug(f"Language determined by user preference: {user.preferred_language}")
+                    g.lang = user.preferred_language
+                    return g.lang
+
+            # Priority 2: Company's default language
+            company_short_name = self._get_company_short_name()
+            if company_short_name:
+                locale = self.config_service.get_configuration(company_short_name, 'locale')
+                if locale:
+                    company_language = locale.split('_')[0]
+                    g.lang = company_language
+                    return g.lang
+        except Exception as e:
+            pass
+
+        # Priority 3: System-wide fallback
+        logging.debug(f"Language determined by system fallback: {self.FALLBACK_LANGUAGE}")
+        g.lang = self.FALLBACK_LANGUAGE
+        return g.lang

iatoolkit/services/license_service.py

@@ -0,0 +1,82 @@
+# Copyright (c) 2024 Fernando Libedinsky
+# Product: IAToolkit
+#
+# IAToolkit is open source software.
+
+import jwt
+import os
+import logging
+from pathlib import Path
+from iatoolkit.common.exceptions import IAToolkitException
+from injector import inject, singleton
+
+
+@singleton
+class LicenseService:
+    """
+    Manages system restrictions and features based on a license (JWT).
+    If no license or an invalid license is provided, Community Edition limits apply.
+    """
+    @inject
+    def __init__(self):
+        self.limits = self._load_limits()
+
+    def _load_limits(self):
+        # 1. Define default limits (Community Edition)
+        default_limits = {
+            "license_type": "Community Edition",
+            "plan": "Open Source (Community Edition)",
+            "max_companies": 1,
+            "max_tools": 3,
+            "features": {
+                "multi_tenant": False,
+                "rag_advanced": False,
+            }
+        }
+        return default_limits
+
+
+    # --- Information Getters ---
+    def get_license_type(self) -> str:
+        return self.limits.get("license_type", "Community Edition")
+
+    def get_plan_name(self) -> str:
+        return self.limits.get("plan", "Unknown")
+
+    def get_max_companies(self) -> int:
+        return self.limits.get("max_companies", 1)
+
+    def get_max_tools_per_company(self) -> int:
+        return self.limits.get("max_tools", 3)
+
+    def get_license_info(self) -> str:
+        return f"Plan: {self.get_plan_name()}, Companies: {self.get_max_companies()}, Tools: {self.get_max_tools_per_company()}"
+
+    # --- Restriction Validators ---
+
+    def validate_company_limit(self, current_count: int):
+        """Raises exception if the limit of active companies is exceeded."""
+        limit = self.get_max_companies()
+        # -1 means unlimited
+        if limit != -1 and current_count > limit:
+            raise IAToolkitException(
+                IAToolkitException.ErrorType.PERMISSION,
+                f"Company limit ({limit}) reached for plan '{self.get_plan_name()}'."
+            )
+
+
+    def validate_tool_config_limit(self, tools_config: list):
+        """Validates a configuration list before processing it."""
+        limit = self.get_max_tools_per_company()
+        if limit != -1 and len(tools_config) > limit:
+            raise IAToolkitException(
+                IAToolkitException.ErrorType.PERMISSION,
+                f"Configuration defines {len(tools_config)} tools, but limit is {limit}."
+            )
+
+    # --- Feature Gating Validators ---
+
+    def has_feature(self, feature_key: str) -> bool:
+        """Checks if a specific feature is enabled in the license."""
+        features = self.limits.get("features", {})
+        return features.get(feature_key, False)