iatoolkit 0.7.5__py3-none-any.whl → 0.7.6__py3-none-any.whl

infra/mail_app.py

@@ -0,0 +1,145 @@
+# Copyright (c) 2024 Fernando Libedinsky
+# Product: IAToolkit
+#
+# IAToolkit is open source software.
+
+import sib_api_v3_sdk
+from sib_api_v3_sdk.rest import ApiException
+from common.exceptions import IAToolkitException
+import os
+import base64
+import logging
+
+MAX_ATTACH_BYTES = int(os.getenv("BREVO_MAX_ATTACH_BYTES", str(5 * 1024 * 1024)))  # 5MB seguro
+
+
+class MailApp:
+    def __init__(self,):
+        self.configuration = sib_api_v3_sdk.Configuration()
+        self.configuration.api_key['api-key'] = os.getenv('BREVO_API_KEY')
+        self.mail_api = sib_api_v3_sdk.TransactionalEmailsApi(sib_api_v3_sdk.ApiClient(self.configuration))
+        self.sender = {"email": "ia@iatoolkit.com", "name": "IA Toolkit"}
+
+    @staticmethod
+    def _strip_data_url_prefix(b64: str) -> str:
+        if not isinstance(b64, str):
+            return b64
+        i = b64.find("base64,")
+        return b64[i + 7:] if i != -1 else b64
+
+    def _normalize_attachments(self, attachments: list[dict] | None):
+        if not attachments:
+            return None
+        sdk_attachments = []
+        for idx, a in enumerate(attachments, start=1):
+            # 1) claves obligatorias
+            if "filename" not in a:
+                raise IAToolkitException(IAToolkitException.ErrorType.MAIL_ERROR,
+                                   f"Adjunto #{idx} inválido: falta 'filename'")
+            if "content" not in a:
+                raise IAToolkitException(IAToolkitException.ErrorType.MAIL_ERROR,
+                                   f"Adjunto '{a.get('filename', '(sin nombre)')}' inválido: falta 'content'")
+
+            name = a["filename"]
+            content_b64 = a["content"]
+
+            # 2) quitar prefijo data URL si vino así
+            content_b64 = self._strip_data_url_prefix(content_b64)
+
+            # 3) validar base64 (y que no esté vacío)
+            try:
+                raw = base64.b64decode(content_b64, validate=True)
+            except Exception:
+                logging.error("Adjunto '%s' con base64 inválido (primeros 16 chars: %r)",
+                              name, str(content_b64)[:16])
+                raise IAToolkitException(IAToolkitException.ErrorType.MAIL_ERROR,
+                                   f"Adjunto '{name}' trae base64 inválido")
+
+            if not raw:
+                raise IAToolkitException(IAToolkitException.ErrorType.MAIL_ERROR,
+                                   f"Adjunto '{name}' está vacío")
+
+            # 4) volver a base64 limpio (sin prefijos, sin espacios)
+            clean_b64 = base64.b64encode(raw).decode("utf-8")
+
+            # 5) construir objeto del SDK
+            sdk_attachments.append(
+                sib_api_v3_sdk.SendSmtpEmailAttachment(
+                    name=name,
+                    content=clean_b64
+                )
+            )
+            return sdk_attachments
+
+
+    def send_email(self,
+                   to: str,
+                   subject: str,
+                   body: str,
+                   sender: dict = None,
+                   attachments: list[dict] = None):
+        if not sender:
+            sender = self.sender
+
+        try:
+            sdk_attachments = self._normalize_attachments(attachments)
+            email = sib_api_v3_sdk.SendSmtpEmail(
+                to=[{"email": to}],
+                sender=sender,
+                subject=subject,
+                html_content=body,
+                attachment=sdk_attachments
+            )
+            api_response = self.mail_api.send_transac_email(email)
+
+            # Validación de respuesta
+            message_id = getattr(api_response, "message_id", None) or getattr(api_response, "messageId", None)
+            message_ids = getattr(api_response, "message_ids", None) or getattr(api_response, "messageIds", None)
+            if not ((isinstance(message_id, str) and message_id.strip()) or
+                    (isinstance(message_ids, (list, tuple)) and len(message_ids) > 0)):
+                logging.error("MAIL ERROR: Respuesta sin message_id(s): %r", api_response)
+                raise IAToolkitException(IAToolkitException.ErrorType.MAIL_ERROR,
+                                   "Brevo no retornó message_id; el envío podría haber fallado.")
+
+            return api_response
+
+        except ApiException as e:
+            logging.exception("MAIL ERROR (ApiException): status=%s reason=%s body=%s",
+                              getattr(e, "status", None), getattr(e, "reason", None), getattr(e, "body", None))
+            raise IAToolkitException(IAToolkitException.ErrorType.MAIL_ERROR,
+                               f"Error Brevo (status={getattr(e, 'status', 'N/A')}): {getattr(e, 'reason', str(e))}") from e
+        except Exception as e:
+            logging.exception("MAIL ERROR: %s", str(e))
+            raise IAToolkitException(IAToolkitException.ErrorType.MAIL_ERROR,
+                               f"No se pudo enviar correo: {str(e)}") from e
+''''
+    def send_template_email(self,
+                   subject: str,
+                   recipients: list,
+                   template_name: str,
+                   context: dict,
+                   sender=None):
+        try:
+            # Renderiza el template con el contexto proporcionado
+            with self.app.app_context():
+                html_message = render_template(template_name, **context)
+
+            # Crea el mensaje
+            msg = Message(
+                subject=subject,
+                recipients=recipients,
+                html=html_message,
+                sender=sender or self.app.config.get('MAIL_DEFAULT_SENDER')
+            )
+
+            # Envía el correo
+            # self.send_brevo_email(msg)
+            pass
+        except jinja2.exceptions.TemplateNotFound:
+            raise IAToolkitException(IAToolkitException.ErrorType.MAIL_ERROR,
+                               f"Error: No se encontró el template '{template_name}'.")
+        except Exception as e:
+            raise IAToolkitException(IAToolkitException.ErrorType.MAIL_ERROR,
+                               f'No se pudo enviar correo: {str(e)}') from e
+    
+    '''

infra/openai_adapter.py

@@ -0,0 +1,90 @@
+# Copyright (c) 2024 Fernando Libedinsky
+# Product: IAToolkit
+#
+# IAToolkit is open source software.
+
+import logging
+from typing import Dict, List, Optional
+from infra.llm_response import LLMResponse, ToolCall, Usage
+from common.exceptions import IAToolkitException
+
+
+class OpenAIAdapter:
+    """Adaptador para la API de OpenAI"""
+
+    def __init__(self, openai_client):
+        self.client = openai_client
+
+    def create_response(self,
+                        model: str,
+                        input: List[Dict],
+                        previous_response_id: Optional[str] = None,
+                        context_history: Optional[List[Dict]] = None,
+                        tools: Optional[List[Dict]] = None,
+                        text: Optional[Dict] = None,
+                        reasoning: Optional[Dict] = None,
+                        tool_choice: str = "auto") -> LLMResponse:
+        """Llamada a la API de OpenAI y mapeo a estructura común"""
+        try:
+            # Preparar parámetros para OpenAI
+            params = {
+                'model': model,
+                'input': input
+            }
+
+            if previous_response_id:
+                params['previous_response_id'] = previous_response_id
+            if tools:
+                params['tools'] = tools
+            if text:
+                params['text'] = text
+            if reasoning:
+                params['reasoning'] = reasoning
+            if tool_choice != "auto":
+                params['tool_choice'] = tool_choice
+
+            # Llamar a la API de OpenAI
+            openai_response = self.client.responses.create(**params)
+
+            # Mapear la respuesta a estructura común
+            return self._map_openai_response(openai_response)
+
+        except Exception as e:
+            error_message = f"Error calling OpenAI API: {str(e)}"
+            logging.error(error_message)
+
+            # En caso de error de contexto
+            if "context_length_exceeded" in str(e):
+                error_message = 'Tu consulta supera el limite de contexto, sale e ingresa de nuevo a IAToolkit'
+
+            raise IAToolkitException(IAToolkitException.ErrorType.LLM_ERROR, error_message)
+
+    def _map_openai_response(self, openai_response) -> LLMResponse:
+        """Mapear respuesta de OpenAI a estructura común"""
+        # Mapear tool calls
+        tool_calls = []
+        if hasattr(openai_response, 'output') and openai_response.output:
+            for tool_call in openai_response.output:
+                if hasattr(tool_call, 'type') and tool_call.type == "function_call":
+                    tool_calls.append(ToolCall(
+                        call_id=getattr(tool_call, 'call_id', ''),
+                        type=tool_call.type,
+                        name=getattr(tool_call, 'name', ''),
+                        arguments=getattr(tool_call, 'arguments', '{}')
+                    ))
+
+        # Mapear usage
+        usage = Usage(
+            input_tokens=openai_response.usage.input_tokens if openai_response.usage else 0,
+            output_tokens=openai_response.usage.output_tokens if openai_response.usage else 0,
+            total_tokens=openai_response.usage.total_tokens if openai_response.usage else 0
+        )
+
+        return LLMResponse(
+            id=openai_response.id,
+            model=openai_response.model,
+            status=openai_response.status,
+            output_text=getattr(openai_response, 'output_text', ''),
+            output=tool_calls,
+            usage=usage
+        )

infra/redis_session_manager.py

@@ -0,0 +1,76 @@
+# Copyright (c) 2024 Fernando Libedinsky
+# Product: IAToolkit
+#
+# IAToolkit is open source software.
+
+import logging
+import os
+import redis
+import json
+from urllib.parse import urlparse
+
+
+class RedisSessionManager:
+    """
+    SessionManager que usa Redis directamente para datos persistentes como llm_history.
+    Separado de Flask session para tener control total sobre el ciclo de vida de los datos.
+    """
+    _client = None
+
+    @classmethod
+    def _get_client(cls):
+        if cls._client is None:
+            # Usar exactamente los mismos parámetros que Flask-Session
+            url = urlparse(os.environ.get("REDIS_URL"))
+            cls._client = redis.Redis(
+                host=url.hostname,
+                port=url.port,
+                password=url.password,
+                ssl=(url.scheme == "rediss"),
+                ssl_cert_reqs=None,
+                decode_responses=True  # Importante para strings
+            )
+            # verify connection
+            cls._client.ping()
+            info = cls._client.info(section="server")
+            db = cls._client.connection_pool.connection_kwargs.get('db', 0)
+        return cls._client
+
+    @classmethod
+    def set(cls, key: str, value: str, ex: int = None):
+        client = cls._get_client()
+        result = client.set(key, value, ex=ex)
+        return result
+
+    @classmethod
+    def get(cls, key: str, default: str = ""):
+        client = cls._get_client()
+        value = client.get(key)
+        result = value if value is not None else default
+        return result
+
+    @classmethod
+    def remove(cls, key: str):
+        client = cls._get_client()
+        result = client.delete(key)
+        return result
+
+    @classmethod
+    def set_json(cls, key: str, value: dict, ex: int = None):
+        json_str = json.dumps(value)
+        return cls.set(key, json_str, ex=ex)
+
+    @classmethod
+    def get_json(cls, key: str, default: dict = None):
+        if default is None:
+            default = {}
+
+        json_str = cls.get(key, "")
+        if not json_str:
+            return default
+
+        try:
+            return json.loads(json_str)
+        except json.JSONDecodeError:
+            logging.warning(f"[RedisSessionManager] Invalid JSON in key '{key}': {json_str}")
+            return default

repositories/__init__.py

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

repositories/database_manager.py

@@ -0,0 +1,95 @@
+# Copyright (c) 2024 Fernando Libedinsky
+# Product: IAToolkit
+#
+# IAToolkit is open source software.
+
+# database_manager.py
+from sqlalchemy import create_engine, event, inspect
+from sqlalchemy.orm import sessionmaker, scoped_session
+from sqlalchemy.engine.url import make_url
+from repositories.models import Base
+from injector import inject
+from pgvector.psycopg2 import register_vector
+
+
+class DatabaseManager:
+    @inject
+    def __init__(self, database_url: str, register_pgvector: bool = True):
+        """
+        Inicializa el gestor de la base de datos.
+        :param database_url: URL de la base de datos.
+        :param echo: Si True, habilita logs de SQL.
+        """
+        self.url = make_url(database_url)
+        self._engine = create_engine(database_url, echo=False)
+        self.SessionFactory = sessionmaker(bind=self._engine)
+        self.scoped_session = scoped_session(self.SessionFactory)
+
+        # REGISTRAR pgvector para cada nueva conexión solo en postgres
+        if register_pgvector and self.url.get_backend_name() == 'postgresql':
+            event.listen(self._engine, 'connect', self.on_connect)
+
+    @staticmethod
+    def on_connect(dbapi_connection, connection_record):
+        """
+        Esta función se ejecuta cada vez que se establece una conexión.
+        dbapi_connection es la conexión psycopg2 real.
+        """
+        register_vector(dbapi_connection)
+
+    def get_session(self):
+        return self.scoped_session()
+
+    def get_connection(self):
+        return self._engine.connect()
+
+    def get_engine(self):
+        return self._engine
+
+    def create_all(self):
+        Base.metadata.create_all(self._engine)
+
+    def drop_all(self):
+        Base.metadata.drop_all(self._engine)
+
+    def remove_session(self):
+        self.scoped_session.remove()
+
+    def get_table_schema(self,
+                         table_name: str,
+                         schema_name: str | None = None,
+                         exclude_columns: list[str] | None = None) -> str:
+        inspector = inspect(self._engine)
+
+        if table_name not in inspector.get_table_names():
+            raise RuntimeError(f"La tabla '{table_name}' no existe en la BD.")
+
+        if exclude_columns is None:
+            exclude_columns = []
+
+        # get all thre table columns
+        columns = inspector.get_columns(table_name)
+
+        # construct a json dictionary with the table definition
+        json_dict = {
+            "table": table_name,
+            "description": f"Definición de la tabla {table_name}.",
+            "fields": []
+        }
+        if schema_name:
+            json_dict["description"] += f"Los detalles de cada campo están en el objeto **`{schema_name}`**."
+
+        # now add every column to the json dictionary
+        for col in columns:
+            name = col["name"]
+
+            # omit the excluded columns.
+            if name in exclude_columns:
+                continue
+
+            json_dict["fields"].append({
+                "name": name,
+                "type": str(col["type"]),
+            })
+
+        return "\n\n" + str(json_dict)

repositories/document_repo.py

@@ -0,0 +1,33 @@
+# Copyright (c) 2024 Fernando Libedinsky
+# Product: IAToolkit
+#
+# IAToolkit is open source software.
+
+from repositories.models import Document
+from injector import inject
+from repositories.database_manager import DatabaseManager
+from common.exceptions import IAToolkitException
+
+
+class DocumentRepo:
+    @inject
+    def __init__(self, db_manager: DatabaseManager):
+        self.session = db_manager.get_session()
+
+    def insert(self,new_document: Document):
+        self.session.add(new_document)
+        self.session.commit()
+        return new_document
+
+    def get(self, company_id, filename: str ) -> Document:
+        if not company_id or not filename:
+            raise IAToolkitException(IAToolkitException.ErrorType.PARAM_NOT_FILLED,
+                               'Falta empresa o filename')
+
+        return self.session.query(Document).filter_by(company_id=company_id, filename=filename).first()
+
+    def get_by_id(self, document_id: int) -> Document:
+        if not document_id:
+            return None
+
+        return self.session.query(Document).filter_by(id=document_id).first()

repositories/llm_query_repo.py

@@ -0,0 +1,91 @@
+# Copyright (c) 2024 Fernando Libedinsky
+# Product: IAToolkit
+#
+# IAToolkit is open source software.
+
+from repositories.models import LLMQuery, Function, Company, Prompt, PromptCategory
+from injector import inject
+from repositories.database_manager import DatabaseManager
+from sqlalchemy import or_
+
+class LLMQueryRepo:
+    @inject
+    def __init__(self, db_manager: DatabaseManager):
+        self.session = db_manager.get_session()
+
+    def add_query(self, query: LLMQuery):
+        self.session.add(query)
+        self.session.commit()
+        return query
+
+
+    def get_company_functions(self, company: Company) -> list[Function]:
+        return (
+            self.session.query(Function)
+            .filter(
+                Function.is_active.is_(True),
+                or_(
+                    Function.company_id == company.id,
+                    Function.system_function.is_(True)
+                )
+            )
+            .all()
+        )
+
+    def create_or_update_function(self, new_function: Function):
+        function = self.session.query(Function).filter_by(company_id=new_function.company_id,
+                                                 name=new_function.name).first()
+        if function:
+            function.description = new_function.description
+            function.parameters = new_function.parameters
+            function.system_function = new_function.system_function
+        else:
+            self.session.add(new_function)
+            function = new_function
+
+        self.session.commit()
+        return function
+
+    def create_or_update_prompt(self, new_prompt: Prompt):
+        prompt = self.session.query(Prompt).filter_by(company_id=new_prompt.company_id,
+                                                 name=new_prompt.name).first()
+        if prompt:
+            prompt.category_id = new_prompt.category_id
+            prompt.description = new_prompt.description
+            prompt.order = new_prompt.order
+            prompt.active = new_prompt.active
+            prompt.is_system_prompt = new_prompt.is_system_prompt
+            prompt.filename = new_prompt.filename
+            prompt.custom_fields = new_prompt.custom_fields
+        else:
+            self.session.add(new_prompt)
+            prompt = new_prompt
+
+        self.session.commit()
+        return prompt
+
+    def create_or_update_prompt_category(self, new_category: PromptCategory):
+        category = self.session.query(PromptCategory).filter_by(company_id=new_category.company_id,
+                                                      name=new_category.name).first()
+        if category:
+            category.order = new_category.order
+        else:
+            self.session.add(new_category)
+            category = new_category
+
+        self.session.commit()
+        return category
+
+    def get_history(self, company: Company, user_identifier: str) -> list[LLMQuery]:
+        return self.session.query(LLMQuery).filter(
+            LLMQuery.user_identifier == user_identifier,
+        ).filter_by(company_id=company.id).order_by(LLMQuery.created_at.desc()).limit(100).all()
+
+    def get_prompts(self, company: Company) -> list[Prompt]:
+        return self.session.query(Prompt).filter_by(company_id=company.id, is_system_prompt=False).all()
+
+    def get_system_prompts(self) -> list[Prompt]:
+        return self.session.query(Prompt).filter_by(is_system_prompt=True, active=True).order_by(Prompt.order).all()
+
+    def get_prompt_by_name(self, company: Company, prompt_name: str):
+        return self.session.query(Prompt).filter_by(company_id=company.id, name=prompt_name).first()