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

iatoolkit/repositories/tasks_repo.py

@@ -0,0 +1,52 @@
+# Copyright (c) 2024 Fernando Libedinsky
+# Product: IAToolkit
+#
+# IAToolkit is open source software.
+
+from injector import inject
+from datetime import datetime
+from iatoolkit.repositories.models import Task, TaskStatus, TaskType
+from iatoolkit.repositories.database_manager import DatabaseManager
+from sqlalchemy import or_
+
+
+class TaskRepo:
+    @inject
+    def __init__(self, db_manager: DatabaseManager):
+        self.session = db_manager.get_session()
+
+    def create_task(self, new_task: Task) -> Task:
+        self.session.add(new_task)
+        self.session.commit()
+        return new_task
+
+    def update_task(self, task: Task) -> Task:
+        self.session.commit()
+        return task
+
+    def get_task_by_id(self, task_id: int):
+        return self.session.query(Task).filter_by(id=task_id).first()
+
+    def create_or_update_task_type(self, new_task_type: TaskType):
+        task_type = self.session.query(TaskType).filter_by(name=new_task_type.name).first()
+        if task_type:
+            task_type.prompt_template = new_task_type.prompt_template
+            task_type.template_args = new_task_type.template_args
+        else:
+            self.session.add(new_task_type)
+            task_type = new_task_type
+        self.session.commit()
+        return task_type
+
+    def get_task_type(self, name: str):
+        task_type = self.session.query(TaskType).filter_by(name=name).first()
+        return task_type
+
+    def get_pending_tasks(self, company_id: int):
+        now = datetime.now()
+        tasks = self.session.query(Task).filter(
+            Task.company_id == company_id,
+            Task.status == TaskStatus.pendiente,
+            or_(Task.execute_at == None, Task.execute_at <= now)
+        ).all()
+        return tasks

iatoolkit/repositories/vs_repo.py

@@ -0,0 +1,139 @@
+# Copyright (c) 2024 Fernando Libedinsky
+# Product: IAToolkit
+#
+# IAToolkit is open source software.
+
+from sqlalchemy import  text
+from huggingface_hub import InferenceClient
+from injector import inject
+from iatoolkit.common.exceptions import IAToolkitException
+from iatoolkit.repositories.database_manager import DatabaseManager
+from iatoolkit.repositories.models import Document, VSDoc
+import os
+import logging
+
+class VSRepo:
+    @inject
+    def __init__(self, db_manager: DatabaseManager):
+        self.session = db_manager.get_session()
+
+        # Inicializar el modelo de embeddings
+        self.embedder = InferenceClient(
+            model="sentence-transformers/all-MiniLM-L6-v2",
+            token=os.getenv('HF_TOKEN'))
+
+
+    def add_document(self, vs_chunk_list: list[VSDoc]):
+        try:
+            for doc in vs_chunk_list:
+                # calculate the embedding for the text
+                doc.embedding = self.embedder.feature_extraction(doc.text)
+                self.session.add(doc)
+            self.session.commit()
+        except Exception as e:
+            logging.error(f"Error insertando documentos en PostgreSQL: {str(e)}")
+            self.session.rollback()
+            raise IAToolkitException(IAToolkitException.ErrorType.VECTOR_STORE_ERROR,
+                               f"Error insertando documentos en PostgreSQL: {str(e)}")
+
+    def query(self,
+              company_id: int,
+              query_text: str,
+              n_results=5,
+              metadata_filter=None
+              ) -> list[Document]:
+        """
+        search documents similar to the query for a company
+
+        Args:
+            company_id:
+            query_text: query text
+            n_results: max number of results to return
+            metadata_filter:  (ej: {"document_type": "certificate"})
+
+        Returns:
+            list of documents matching the query and filters
+        """
+        # Generate the embedding with the query text
+        query_embedding = self.embedder.feature_extraction([query_text])[0]
+
+        try:
+            # build the SQL query
+            sql_query_parts = ["""
+                               SELECT iat_documents.id, \
+                                      iat_documents.filename, \
+                                      iat_documents.content, \
+                                      iat_documents.content_b64, \
+                                      iat_documents.meta
+                               FROM iat_vsdocs, \
+                                    iat_documents
+                               WHERE iat_vsdocs.company_id = :company_id
+                                 AND iat_vsdocs.document_id = iat_documents.id \
+                               """]
+
+            # query parameters
+            params = {
+                "company_id": company_id,
+                "query_embedding": query_embedding,
+                "n_results": n_results
+            }
+
+            # add metadata filter, if exists
+            if metadata_filter and isinstance(metadata_filter, dict):
+                for key, value in metadata_filter.items():
+                    # Usar el operador ->> para extraer el valor del JSON como texto.
+                    # La clave del JSON se interpola directamente.
+                    # El valor se pasa como parámetro para evitar inyección SQL.
+                    param_name = f"value_{key}_filter"
+                    sql_query_parts.append(f" AND documents.meta->>'{key}' = :{param_name}")
+                    params[param_name] = str(value)     # parametros como string
+
+            # join all the query parts
+            sql_query = "".join(sql_query_parts)
+
+            # add sorting and limit of results
+            sql_query += " ORDER BY embedding <-> :query_embedding LIMIT :n_results"
+
+            logging.debug(f"Executing SQL query: {sql_query}")
+            logging.debug(f"With parameters: {params}")
+
+            # execute the query
+            result = self.session.execute(text(sql_query), params)
+
+            rows = result.fetchall()
+            vs_documents = []
+
+            for row in rows:
+                # create the document object with the data
+                meta_data = row[4] if len(row) > 4 and row[4] is not None else {}
+                doc = Document(
+                    id=row[0],
+                    company_id=company_id,
+                    filename=row[1],
+                    content=row[2],
+                    content_b64=row[3],
+                    meta=meta_data
+                )
+                vs_documents.append(doc)
+
+            return self.remove_duplicates_by_id(vs_documents)
+
+        except Exception as e:
+            logging.error(f"Error en la consulta de documentos: {str(e)}")
+            logging.error(f"Failed SQL: {sql_query}")
+            logging.error(f"Failed params: {params}")
+            raise IAToolkitException(IAToolkitException.ErrorType.VECTOR_STORE_ERROR,
+                               f"Error en la consulta: {str(e)}")
+        finally:
+            self.session.close()
+
+    def remove_duplicates_by_id(self, objects):
+        unique_by_id = {}
+        result = []
+
+        for obj in objects:
+            if obj.id not in unique_by_id:
+                unique_by_id[obj.id] = True
+                result.append(obj)
+
+        return result

iatoolkit/services/__init__.py

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

iatoolkit/services/auth_service.py

@@ -0,0 +1,193 @@
+# Copyright (c) 2024 Fernando Libedinsky
+# Product: IAToolkit
+#
+# IAToolkit is open source software.
+
+from flask import request
+from injector import inject
+from iatoolkit.services.profile_service import ProfileService
+from iatoolkit.services.jwt_service import JWTService
+from iatoolkit.services.i18n_service import I18nService
+from iatoolkit.repositories.database_manager import DatabaseManager
+from iatoolkit.repositories.models import AccessLog
+from flask import request
+import logging
+import hashlib
+
+
+class AuthService:
+    """
+    Centralized service for handling authentication for all incoming requests.
+    It determines the user's identity based on either a Flask session cookie or an API Key.
+    """
+
+    @inject
+    def __init__(self, profile_service: ProfileService,
+                 jwt_service: JWTService,
+                 db_manager: DatabaseManager,
+                 i18n_service: I18nService
+                 ):
+        self.profile_service = profile_service
+        self.jwt_service = jwt_service
+        self.db_manager = db_manager
+        self.i18n_service = i18n_service
+
+    def login_local_user(self, company_short_name: str, email: str, password: str) -> dict:
+        # try to autenticate a local user, register the event and return the result
+        auth_response = self.profile_service.login(
+            company_short_name=company_short_name,
+            email=email,
+            password=password,
+        )
+
+        if not auth_response.get('success'):
+            self.log_access(
+                company_short_name=company_short_name,
+                user_identifier=email,
+                auth_type='local',
+                outcome='failure',
+                reason_code='INVALID_CREDENTIALS',
+            )
+        else:
+            self.log_access(
+                company_short_name=company_short_name,
+                auth_type='local',
+                outcome='success',
+                user_identifier=auth_response.get('user_identifier')
+            )
+
+        return auth_response
+
+    def redeem_token_for_session(self, company_short_name: str, token: str) -> dict:
+        # redeem a token for a session, register the event and return the result
+        payload = self.jwt_service.validate_chat_jwt(token)
+
+        if not payload:
+            self.log_access(
+                company_short_name=company_short_name,
+                auth_type='redeem_token',
+                outcome='failure',
+                reason_code='JWT_INVALID'
+            )
+            return {'success': False, 'error': self.i18n_service.t('errors.auth.invalid_or_expired_token')}
+
+        # 2. if token is valid, extract the user_identifier
+        user_identifier = payload.get('user_identifier')
+        try:
+            # create the Flask session
+            self.profile_service.set_session_for_user(company_short_name, user_identifier)
+            self.log_access(
+                company_short_name=company_short_name,
+                auth_type='redeem_token',
+                outcome='success',
+                user_identifier=user_identifier
+            )
+            return {'success': True, 'user_identifier': user_identifier}
+        except Exception as e:
+            logging.error(f"Error al crear la sesión desde token para {user_identifier}: {e}")
+            self.log_access(
+                company_short_name=company_short_name,
+                auth_type='redeem_token',
+                outcome='failure',
+                reason_code='SESSION_CREATION_FAILED',
+                user_identifier=user_identifier
+            )
+            return {'success': False, 'error': self.i18n_service.t('errors.auth.session_creation_failed')}
+
+    def verify(self, anonymous: bool = False) -> dict:
+        """
+        Verifies the current request and identifies the user.
+        If anonymous is True the non-presence of use_identifier is ignored
+
+        Returns a dictionary with:
+        - success: bool
+        - user_identifier: str (if successful)
+        - company_short_name: str (if successful)
+        - error_message: str (on failure)
+        - status_code: int (on failure)
+        """
+        # --- Priority 1: Check for a valid Flask web session ---
+        session_info = self.profile_service.get_current_session_info()
+        if session_info and session_info.get('user_identifier'):
+            # User is authenticated via a web session cookie.
+            return {
+                "success": True,
+                "company_short_name": session_info['company_short_name'],
+                "user_identifier": session_info['user_identifier'],
+            }
+
+        # --- Priority 2: Check for a valid API Key in headers ---
+        api_key = None
+        auth = request.headers.get('Authorization', '')
+        if isinstance(auth, str) and auth.lower().startswith('bearer '):
+            api_key =  auth.split(' ', 1)[1].strip()
+
+        if not api_key:
+            # --- Failure: No valid credentials found ---
+            logging.info(f"Authentication required. No session cookie or API Key provided.")
+            return {"success": False,
+                    "error_message": self.i18n_service.t('errors.auth.authentication_required'),
+                    "status_code": 401}
+
+        # check if the api-key is valid and active
+        api_key_entry = self.profile_service.get_active_api_key_entry(api_key)
+        if not api_key_entry:
+            logging.info(f"Invalid or inactive API Key {api_key}")
+            return {"success": False,
+                    "error_message": self.i18n_service.t('errors.auth.invalid_api_key'),
+                    "status_code": 402}
+
+        # get the company from the api_key_entry
+        company = api_key_entry.company
+
+        # For API calls, the external_user_id must be provided in the request.
+        data = request.get_json(silent=True) or {}
+        user_identifier = data.get('user_identifier', '')
+        if not anonymous and not user_identifier:
+            logging.info(f"No user_identifier provided for API call.")
+            return {"success": False,
+                    "error_message": self.i18n_service.t('errors.auth.no_user_identifier_api'),
+                    "status_code": 403}
+
+        return {
+            "success": True,
+            "company_short_name": company.short_name,
+            "user_identifier": user_identifier
+        }
+
+
+    def log_access(self,
+                   company_short_name: str,
+                   auth_type: str,
+                   outcome: str,
+                   user_identifier: str = None,
+                   reason_code: str = None):
+        """
+        Registra un intento de acceso en la base de datos.
+        Es "best-effort" y no debe interrumpir el flujo de autenticación.
+        """
+        session = self.db_manager.scoped_session()
+        try:
+            # Capturar datos del contexto de la petición de Flask
+            source_ip = request.headers.get('X-Forwarded-For', request.remote_addr)
+            path = request.path
+            ua = request.headers.get('User-Agent', '')
+            ua_hash = hashlib.sha256(ua.encode()).hexdigest()[:16] if ua else None
+
+            # Crear la entrada de log
+            log_entry = AccessLog(
+                company_short_name=company_short_name,
+                user_identifier=user_identifier,
+                auth_type=auth_type,
+                outcome=outcome,
+                reason_code=reason_code,
+                source_ip=source_ip,
+                user_agent_hash=ua_hash,
+                request_path=path,
+            )
+            session.add(log_entry)
+            session.commit()
+
+        except Exception as e:
+            logging.error(f"Fallo al escribir en AccessLog: {e}", exc_info=False)
+            session.rollback()

{services → iatoolkit/services}/benchmark_service.py

@@ -1,15 +1,15 @@
 # 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.
 
 import pandas as pd
 import time
 import logging
 from injector import inject
-from services.query_service import QueryService
-from repositories.profile_repo import ProfileRepo
-from common.exceptions import IAToolkitException
+from iatoolkit.services.query_service import QueryService
+from iatoolkit.repositories.profile_repo import ProfileRepo
+from iatoolkit.common.exceptions import IAToolkitException
 
 
 class BenchmarkService:

iatoolkit/services/branding_service.py

@@ -0,0 +1,149 @@
+# Copyright (c) 2024 Fernando Libedinsky
+# Product: IAToolkit
+#
+# IAToolkit is open source software.
+
+from iatoolkit.repositories.models import Company
+from injector import inject
+
+
+class BrandingService:
+    """
+    Servicio centralizado que gestiona la configuración de branding.
+    """
+
+    @inject
+    def __init__(self):
+        """
+        Define los estilos de branding por defecto para la aplicación.
+        """
+        self._default_branding = {
+            # --- Estilos del Encabezado Principal ---
+            "header_background_color": "#FFFFFF",
+            "header_text_color": "#6C757D",
+            "primary_font_weight": "600",
+            "primary_font_size": "1.2rem",
+            "secondary_font_weight": "400",
+            "secondary_font_size": "0.9rem",
+            "tertiary_font_weight": "300",
+            "tertiary_font_size": "0.8rem",
+            "tertiary_opacity": "0.7",
+
+            # headings
+            "brand_text_heading_color": "#334155",  # Gris pizarra por defecto
+
+            # Estilos Globales de la Marca ---
+            "brand_primary_color": "#0d6efd",  # Azul de Bootstrap por defecto
+            "brand_secondary_color": "#6c757d",  # Gris de Bootstrap por defecto
+            "brand_text_on_primary": "#FFFFFF",  # Texto blanco sobre color primario
+            "brand_text_on_secondary": "#FFFFFF",  # Texto blanco sobre color secundario
+
+            # Estilos para Alertas de Error ---
+            "brand_danger_color": "#dc3545",  # Rojo principal para alertas
+            "brand_danger_bg": "#f8d7da",  # Fondo rojo pálido
+            "brand_danger_text": "#842029",  # Texto rojo oscuro
+            "brand_danger_border": "#f5c2c7",  # Borde rojo intermedio
+
+            # Estilos para Alertas Informativas ---
+            "brand_info_bg": "#F0F4F8",         # Un fondo de gris azulado muy pálido
+            "brand_info_text": "#0d6efd",       # Texto en el color primario
+            "brand_info_border": "#D9E2EC",     # Borde de gris azulado pálido
+
+            # Estilos para el Asistente de Prompts ---
+            "prompt_assistant_bg": "#f8f9fa",
+            "prompt_assistant_border": "#dee2e6",
+            "prompt_assistant_button_bg": "#FFFFFF",
+            "prompt_assistant_button_text": "#495057",
+            "prompt_assistant_button_border": "#ced4da",
+            "prompt_assistant_dropdown_bg": "#f8f9fa",
+            "prompt_assistant_header_bg": "#e9ecef",
+            "prompt_assistant_header_text": "#495057",
+
+            # this use the primary by default
+            "prompt_assistant_icon_color": None,
+            "prompt_assistant_item_hover_bg": None,
+            "prompt_assistant_item_hover_text": None,
+
+            # Color para el botón de Enviar ---
+            "send_button_color": "#212529"          # Gris oscuro/casi negro por defecto
+        }
+
+    def get_company_branding(self, company: Company | None) -> dict:
+        """
+        Retorna los estilos de branding finales para una compañía,
+        fusionando los valores por defecto con los personalizados.
+        """
+        final_branding_values = self._default_branding.copy()
+
+        if company and company.branding:
+            final_branding_values.update(company.branding)
+
+        # Función para convertir HEX a RGB
+        def hex_to_rgb(hex_color):
+            hex_color = hex_color.lstrip('#')
+            return tuple(int(hex_color[i:i + 2], 16) for i in (0, 2, 4))
+
+        primary_rgb = hex_to_rgb(final_branding_values['brand_primary_color'])
+        secondary_rgb = hex_to_rgb(final_branding_values['brand_secondary_color'])
+
+        # --- CONSTRUCCIÓN DE ESTILOS Y VARIABLES CSS ---
+        primary_text_style = (
+            f"font-weight: {final_branding_values['primary_font_weight']}; "
+            f"font-size: {final_branding_values['primary_font_size']};"
+        )
+        secondary_text_style = (
+            f"font-weight: {final_branding_values['secondary_font_weight']}; "
+            f"font-size: {final_branding_values['secondary_font_size']};"
+        )
+        tertiary_text_style = (
+            f"font-weight: {final_branding_values['tertiary_font_weight']}; "
+            f"font-size: {final_branding_values['tertiary_font_size']}; "
+            f"opacity: {final_branding_values['tertiary_opacity']};"
+        )
+
+        # Generamos el bloque de variables CSS
+        css_variables = f"""
+            :root {{
+                --brand-primary-color: {final_branding_values['brand_primary_color']};
+                --brand-secondary-color: {final_branding_values['brand_secondary_color']};
+                --brand-header-bg: {final_branding_values['header_background_color']};
+                --brand-header-text: {final_branding_values['header_text_color']};
+                --brand-text-heading-color: {final_branding_values['brand_text_heading_color']};
+
+                --brand-primary-color-rgb: {', '.join(map(str, primary_rgb))};
+                --brand-secondary-color-rgb: {', '.join(map(str, secondary_rgb))};
+                --brand-text-on-primary: {final_branding_values['brand_text_on_primary']};
+                --brand-text-on-secondary: {final_branding_values['brand_text_on_secondary']};
+                --brand-modal-header-bg: {final_branding_values['header_background_color']};
+                --brand-modal-header-text: {final_branding_values['header_text_color']};
+                --brand-danger-color: {final_branding_values['brand_danger_color']};
+                --brand-danger-bg: {final_branding_values['brand_danger_bg']};
+                --brand-danger-text: {final_branding_values['brand_danger_text']};
+                --brand-danger-border: {final_branding_values['brand_danger_border']};
+                --brand-info-bg: {final_branding_values['brand_info_bg']};
+                --brand-info-text: {final_branding_values['brand_info_text'] or final_branding_values['brand_primary_color']};
+                --brand-info-border: {final_branding_values['brand_info_border']};
+                --brand-prompt-assistant-bg: {final_branding_values['prompt_assistant_bg']};
+                --brand-prompt-assistant-border: {final_branding_values['prompt_assistant_border']};
+                --brand-prompt-assistant-icon-color: {final_branding_values['prompt_assistant_icon_color'] or final_branding_values['brand_primary_color']};
+                --brand-prompt-assistant-button-bg: {final_branding_values['prompt_assistant_button_bg']};
+                --brand-prompt-assistant-button-text: {final_branding_values['prompt_assistant_button_text']};
+                --brand-prompt-assistant-button-border: {final_branding_values['prompt_assistant_button_border']};
+                --brand-prompt-assistant-dropdown-bg: {final_branding_values['prompt_assistant_dropdown_bg']};
+                --brand-prompt-assistant-header-bg: {final_branding_values['prompt_assistant_header_bg']};
+                --brand-prompt-assistant-header-text: {final_branding_values['prompt_assistant_header_text']};
+                --brand-prompt-assistant-item-hover-bg: {final_branding_values['prompt_assistant_item_hover_bg'] or final_branding_values['brand_primary_color']};
+                --brand-prompt-assistant-item-hover-text: {final_branding_values['prompt_assistant_item_hover_text'] or final_branding_values['brand_text_on_primary']};
+
+            }}
+        """
+
+        return {
+            "name": company.name if company else "IAToolkit",
+            "primary_text_style": primary_text_style,
+            "secondary_text_style": secondary_text_style,
+            "tertiary_text_style": tertiary_text_style,
+            "header_text_color": final_branding_values['header_text_color'],
+            "css_variables": css_variables,
+            "send_button_color": final_branding_values['brand_primary_color']
+        }