iatoolkit 0.71.2__py3-none-any.whl → 0.91.1__py3-none-any.whl

iatoolkit/services/history_manager_service.py

@@ -0,0 +1,189 @@
+import logging
+import json
+from typing import Dict, Any, Tuple, Optional
+from iatoolkit.services.user_session_context_service import UserSessionContextService
+from iatoolkit.services.i18n_service import I18nService
+from iatoolkit.infra.llm_client 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
+
+    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)
+
+        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)
+            self.session_context.save_initial_response_id(company_short_name, user_identifier, response_id)
+            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)
+            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.
+        """
+        if handle.type == self.TYPE_SERVER_SIDE:
+            previous_response_id = None
+            if ignore_history:
+                previous_response_id = self.session_context.get_initial_response_id(handle.company_short_name,
+                                                                                    handle.user_identifier)
+            else:
+                previous_response_id = self.session_context.get_last_response_id(handle.company_short_name,
+                                                                                 handle.user_identifier)
+
+            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) 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]]
+
+            # For Gemini, we 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
+
+        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"])
+
+        elif history_type == self.TYPE_CLIENT_SIDE:
+            context_history = self.session_context.get_context_history(company_short_name,
+                                                                       user_identifier) or []
+            # 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('output'):
+                context_history.append({"role": "model", "content": response['output']})
+
+            self.session_context.save_context_history(company_short_name, user_identifier, context_history)
+
+    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
+
+    # --- Database History Management (Legacy HistoryService) ---
+
+    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/jwt_service.py

@@ -17,7 +17,7 @@ class JWTService:
     def __init__(self,  app: Flask):
         # Acceder a la configuración directamente desde app.config
         try:
-            self.secret_key = app.config['JWT_SECRET_KEY']
+            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}.")

iatoolkit/services/language_service.py

@@ -48,6 +48,7 @@ class LanguageService:
     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').
@@ -56,6 +57,12 @@ class LanguageService:
             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:
@@ -74,10 +81,9 @@ class LanguageService:
                     g.lang = company_language
                     return g.lang
         except Exception as e:
-            logging.info(f"Could not determine language, falling back to default. Reason: {e}")
             pass
 
         # Priority 3: System-wide fallback
-        logging.info(f"Language determined by system fallback: {self.FALLBACK_LANGUAGE}")
+        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)

iatoolkit/services/mail_service.py

@@ -3,43 +3,40 @@
 #
 # IAToolkit is open source software.
 
-from iatoolkit.infra.mail_app import MailApp
+from iatoolkit.services.configuration_service import ConfigurationService
 from iatoolkit.services.i18n_service import I18nService
+from iatoolkit.infra.brevo_mail_app import BrevoMailApp
 from injector import inject
 from pathlib import Path
-from iatoolkit.common.exceptions import IAToolkitException
 import base64
+import os
+import smtplib
+from email.message import EmailMessage
+from iatoolkit.common.exceptions import IAToolkitException
+
 
 TEMP_DIR = Path("static/temp")
 
 class MailService:
     @inject
     def __init__(self,
-                 mail_app: MailApp,
-                 i18n_service: I18nService):
+                 config_service: ConfigurationService,
+                 mail_app: BrevoMailApp,
+                 i18n_service: I18nService,
+                 brevo_mail_app: BrevoMailApp):
         self.mail_app = mail_app
+        self.config_service = config_service
         self.i18n_service = i18n_service
+        self.brevo_mail_app = brevo_mail_app
 
 
-    def _read_token_bytes(self, token: str) -> bytes:
-        # Defensa simple contra path traversal
-        if not token or "/" in token or "\\" in token or token.startswith("."):
-            raise IAToolkitException(IAToolkitException.ErrorType.MAIL_ERROR,
-                               "attachment_token invalid")
-        path = TEMP_DIR / token
-        if not path.is_file():
-            raise IAToolkitException(IAToolkitException.ErrorType.MAIL_ERROR,
-                               f"attach file not found: {token}")
-        return path.read_bytes()
-
-    def send_mail(self, **kwargs):
-        from_email = kwargs.get('from_email', 'iatoolkit@iatoolkit.com')
+    def send_mail(self, company_short_name: str, **kwargs):
         recipient = kwargs.get('recipient')
         subject = kwargs.get('subject')
         body = kwargs.get('body')
         attachments = kwargs.get('attachments')
 
-        # Normalizar a payload de MailApp (name + base64 content)
+        # Normalizar a payload de BrevoMailApp (name + base64 content)
         norm_attachments = []
         for a in attachments or []:
             if a.get("attachment_token"):
@@ -55,13 +52,162 @@ class MailService:
                     "content": a["content"]
                 })
 
-        self.sender = {"email": from_email, "name": "IAToolkit"}
+        # build provider configuration from company.yaml
+        provider, provider_config = self._build_provider_config(company_short_name)
+
+        # define the email sender
+        sender = {
+            "email": provider_config.get("sender_email"),
+            "name": provider_config.get("sender_name"),
+        }
 
-        response = self.mail_app.send_email(
-            sender=self.sender,
-            to=recipient,
-            subject=subject,
-            body=body,
-            attachments=norm_attachments)
+        # select provider and send the email through it
+        if provider == "brevo_mail":
+            response = self.brevo_mail_app.send_email(
+                provider_config=provider_config,
+                sender=sender,
+                to=recipient,
+                subject=subject,
+                body=body,
+                attachments=norm_attachments
+            )
+        elif provider == "smtplib":
+            response = self._send_with_smtplib(
+                provider_config=provider_config,
+                sender=sender,
+                recipient=recipient,
+                subject=subject,
+                body=body,
+                attachments=norm_attachments,
+            )
+            response = None
+        else:
+            raise IAToolkitException(
+                IAToolkitException.ErrorType.MAIL_ERROR,
+                f"Unknown mail provider '{provider}'"
+            )
 
         return self.i18n_service.t('services.mail_sent')
+
+    def _build_provider_config(self, company_short_name: str) -> tuple[str, dict]:
+        """
+        Determina el provider activo (brevo_mail / smtplib) y construye
+        el diccionario de configuración a partir de las variables de entorno
+        cuyos nombres están en company.yaml (mail_provider).
+        """
+        # get company mail configuration and provider
+        mail_config = self.config_service.get_configuration(company_short_name, "mail_provider")
+        provider = mail_config.get("provider", "brevo_mail")
+
+        # get mail common parameteres
+        sender_email = mail_config.get("sender_email")
+        sender_name = mail_config.get("sender_name")
+
+        # get parameters depending on provider
+        if provider == "brevo_mail":
+            brevo_cfg = mail_config.get("brevo_mail", {})
+            api_key_env = brevo_cfg.get("brevo_api", "BREVO_API_KEY")
+            return provider, {
+                "api_key": os.getenv(api_key_env),
+                "sender_name": sender_name,
+                "sender_email": sender_email,
+            }
+
+        if provider == "smtplib":
+            smtp_cfg = mail_config.get("smtplib", {})
+            host = os.getenv(smtp_cfg.get("host_env", "SMTP_HOST"))
+            port = os.getenv(smtp_cfg.get("port_env", "SMTP_PORT"))
+            username = os.getenv(smtp_cfg.get("username_env", "SMTP_USERNAME"))
+            password = os.getenv(smtp_cfg.get("password_env", "SMTP_PASSWORD"))
+            use_tls = os.getenv(smtp_cfg.get("use_tls_env", "SMTP_USE_TLS"))
+            use_ssl = os.getenv(smtp_cfg.get("use_ssl_env", "SMTP_USE_SSL"))
+
+            return provider, {
+                "host": host,
+                "port": int(port) if port is not None else None,
+                "username": username,
+                "password": password,
+                "use_tls": str(use_tls).lower() == "true",
+                "use_ssl": str(use_ssl).lower() == "true",
+                "sender_name": sender_name,
+                "sender_email": sender_email,
+            }
+
+        # Fallback simple si el provider no es reconocido
+        raise IAToolkitException(IAToolkitException.ErrorType.MAIL_ERROR,
+                                 f"missing mail provider in mail configuration for company '{company_short_name}'")
+
+    def _send_with_smtplib(self,
+                           provider_config: dict,
+                           sender: dict,
+                           recipient: str,
+                           subject: str,
+                           body: str,
+                           attachments: list[dict] | None):
+        """
+        Envía correo usando smtplib, utilizando la configuración normalizada
+        en provider_config.
+        """
+        host = provider_config.get("host")
+        port = provider_config.get("port")
+        username = provider_config.get("username")
+        password = provider_config.get("password")
+        use_tls = provider_config.get("use_tls")
+        use_ssl = provider_config.get("use_ssl")
+
+        if not host or not port:
+            raise IAToolkitException(
+                IAToolkitException.ErrorType.MAIL_ERROR,
+                "smtplib configuration is incomplete (host/port missing)"
+            )
+
+        msg = EmailMessage()
+        msg["From"] = f"{sender.get('name', '')} <{sender.get('email')}>"
+        msg["To"] = recipient
+        msg["Subject"] = subject
+        msg.set_content(body, subtype="html")
+
+        # Adjuntos: ya vienen como filename + base64 content
+        for a in attachments or []:
+            filename = a.get("filename")
+            content_b64 = a.get("content")
+            if not filename or not content_b64:
+                continue
+            try:
+                raw = base64.b64decode(content_b64, validate=True)
+            except Exception:
+                raise IAToolkitException(
+                    IAToolkitException.ErrorType.MAIL_ERROR,
+                    f"Invalid base64 for attachment '{filename}'"
+                )
+            msg.add_attachment(
+                raw,
+                maintype="application",
+                subtype="octet-stream",
+                filename=filename,
+            )
+
+        if use_ssl:
+            with smtplib.SMTP_SSL(host, port) as server:
+                if username and password:
+                    server.login(username, password)
+                server.send_message(msg)
+        else:
+            with smtplib.SMTP(host, port) as server:
+                if use_tls:
+                    server.starttls()
+                if username and password:
+                    server.login(username, password)
+                server.send_message(msg)
+
+
+    def _read_token_bytes(self, token: str) -> bytes:
+        # Defensa simple contra path traversal
+        if not token or "/" in token or "\\" in token or token.startswith("."):
+            raise IAToolkitException(IAToolkitException.ErrorType.MAIL_ERROR,
+                               "attachment_token invalid")
+        path = TEMP_DIR / token
+        if not path.is_file():
+            raise IAToolkitException(IAToolkitException.ErrorType.MAIL_ERROR,
+                               f"attach file not found: {token}")
+        return path.read_bytes()