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

common/util.py

@@ -0,0 +1,358 @@
+# Copyright (c) 2024 Fernando Libedinsky
+# Product: IAToolkit
+#
+# IAToolkit is open source software.
+
+import logging
+from typing import List
+from common.exceptions import IAToolkitException
+from injector import inject
+import os
+from jinja2 import Environment, FileSystemLoader
+from common.session_manager import SessionManager
+from datetime import datetime, date
+from decimal import Decimal
+import yaml
+from cryptography.fernet import Fernet
+import base64
+
+
+class Utility:
+    @inject
+    def __init__(self):
+        self.encryption_key = os.getenv('FERNET_KEY')
+
+    @staticmethod
+    def resolve_user_identifier(external_user_id: str = None, local_user_id: int = 0) -> tuple[str, bool]:
+        """
+        Resuelve un identificador único de usuario desde external_user_id o local_user_id.
+
+        Lógica:
+        - Si external_user_id existe y no está vacío: usar external_user_id
+        - Si no, y local_user_id > 0: obtener email de la sesión actual y retornarlo como ID
+        - Si ninguno: retornar string vacío
+
+        """
+        if external_user_id and external_user_id.strip():
+            return external_user_id.strip(), False
+        elif local_user_id and local_user_id > 0:
+            # get the user information from the session
+            user_data = SessionManager.get('user')
+            if user_data:
+                return user_data.get('email', ''), True
+
+        return "", False
+
+    def render_prompt_from_template(self,
+                                    template_pathname: str,
+                                    query: str = None,
+                                    client_data: dict = {},
+                                    **kwargs) -> str:
+
+        try:
+            # Normalizar la ruta para que funcione en cualquier SO
+            template_pathname = os.path.abspath(template_pathname)
+            template_dir = os.path.dirname(template_pathname)
+            template_file = os.path.basename(template_pathname)
+
+            env = Environment(loader=FileSystemLoader(template_dir))
+            template = env.get_template(template_file)
+
+            kwargs["query"] = query
+
+            # add all the keys in client_data to kwargs
+            kwargs.update(client_data)
+
+            # render my dynamic prompt
+            prompt = template.render(**kwargs)
+            return prompt
+        except Exception as e:
+            logging.exception(e)
+            raise IAToolkitException(IAToolkitException.ErrorType.TEMPLATE_ERROR,
+                               f'No se pudo renderizar el template: {template_pathname}, error: {str(e)}') from e
+
+    def render_prompt_from_string(self,
+                                  template_string: str,
+                                  searchpath: str | list[str] = None,
+                                  query: str = None,
+                                  client_data: dict = {},
+                                  **kwargs) -> str:
+        """
+        Renderiza un prompt a partir de un string de plantilla Jinja2.
+
+        :param template_string: El string que contiene la plantilla Jinja2.
+        :param searchpath: Una ruta o lista de rutas a directorios para buscar plantillas incluidas (con {% include %}).
+        :param query: El query principal a pasar a la plantilla.
+        :param client_data: Un diccionario con datos adicionales para la plantilla.
+        :param kwargs: Argumentos adicionales para la plantilla.
+        :return: El prompt renderizado como un string.
+        """
+        try:
+            # Si se proporciona un searchpath, se usa un FileSystemLoader para permitir includes.
+            if searchpath:
+                loader = FileSystemLoader(searchpath)
+            else:
+                loader = None  # Sin loader, no se pueden incluir plantillas desde archivos.
+
+            env = Environment(loader=loader)
+            template = env.from_string(template_string)
+
+            kwargs["query"] = query
+            kwargs.update(client_data)
+
+            prompt = template.render(**kwargs)
+            return prompt
+        except Exception as e:
+            logging.exception(e)
+            raise IAToolkitException(IAToolkitException.ErrorType.TEMPLATE_ERROR,
+                               f'No se pudo renderizar el template desde el string, error: {str(e)}') from e
+
+
+    def serialize(self, obj):
+        if isinstance(obj, datetime) or isinstance(obj, date):
+            return obj.isoformat()
+        elif isinstance(obj, Decimal):
+            return float(obj)
+        elif isinstance(obj, bytes):
+            return obj.decode('utf-8')
+        else:
+            raise TypeError(f"Type {type(obj)} not serializable")
+
+    def encrypt_key(self, key: str) -> str:
+        if not self.encryption_key:
+            raise IAToolkitException(IAToolkitException.ErrorType.CRYPT_ERROR,
+                               'No se pudo obtener variable de ambiente para encriptar')
+
+        if not key:
+            raise IAToolkitException(IAToolkitException.ErrorType.CRYPT_ERROR,
+                               'falta la clave a encriptar')
+        try:
+            cipher_suite = Fernet(self.encryption_key.encode('utf-8'))
+
+            encrypted_key = cipher_suite.encrypt(key.encode('utf-8'))
+            encrypted_key_str = base64.urlsafe_b64encode(encrypted_key).decode('utf-8')
+
+            return encrypted_key_str
+        except Exception as e:
+            raise IAToolkitException(IAToolkitException.ErrorType.CRYPT_ERROR,
+                               f'No se pudo encriptar la clave: {str(e)}') from e
+
+    def decrypt_key(self, encrypted_key: str) -> str:
+        if not self.encryption_key:
+            raise IAToolkitException(IAToolkitException.ErrorType.CRYPT_ERROR,
+                               'No se pudo obtener variable de ambiente para desencriptar')
+        if not encrypted_key:
+            raise IAToolkitException(IAToolkitException.ErrorType.CRYPT_ERROR,
+                               'falta la clave a encriptar')
+
+        try:
+            # transform to bytes first
+            encrypted_data_from_storage_bytes = base64.urlsafe_b64decode(encrypted_key.encode('utf-8'))
+
+            cipher_suite = Fernet(self.encryption_key.encode('utf-8'))
+            decrypted_key_bytes = cipher_suite.decrypt(encrypted_data_from_storage_bytes)
+            return decrypted_key_bytes.decode('utf-8')
+        except Exception as e:
+            raise IAToolkitException(IAToolkitException.ErrorType.CRYPT_ERROR,
+                               f'No se pudo desencriptar la clave: {str(e)}') from e
+
+    def load_schema_from_yaml(self, file_path):
+        with open(file_path, 'r', encoding='utf-8') as f:
+            schema = yaml.safe_load(f)
+        return schema
+
+    def generate_context_for_schema(self, entity_name: str, schema_file: str = None, schema: dict = {}) -> str:
+        if not schema_file and not schema:
+            raise IAToolkitException(IAToolkitException.ErrorType.FILE_IO_ERROR,
+                               f'No se pudo obtener schema de la entidad: {entity_name}')
+
+        try:
+            if schema_file:
+                schema = self.load_schema_from_yaml(schema_file)
+            table_schema = self.generate_schema_table(schema)
+            return table_schema
+        except Exception as e:
+            logging.exception(e)
+            raise IAToolkitException(IAToolkitException.ErrorType.FILE_IO_ERROR,
+                               f'No se pudo leer el schema de la entidad: {entity_name}') from e
+
+    def generate_schema_table(self, schema: dict) -> str:
+        """
+        Genera una descripción detallada y formateada en Markdown de un esquema.
+        Esta función está diseñada para manejar el formato específico de nuestros
+        archivos YAML, donde el esquema se define bajo una única clave raíz.
+        """
+        if not schema or not isinstance(schema, dict):
+            return ""
+
+        # Asumimos que el YAML tiene una única clave raíz que nombra a la entidad.
+        if len(schema) == 1:
+            root_name = list(schema.keys())[0]
+            root_details = schema[root_name]
+
+            if isinstance(root_details, dict):
+                # Las claves de metadatos describen el objeto en sí, no sus propiedades hijas.
+                METADATA_KEYS = ['description', 'type', 'format', 'items', 'properties']
+
+                # Las propiedades son las claves restantes en el diccionario.
+                properties = {
+                    k: v for k, v in root_details.items() if k not in METADATA_KEYS
+                }
+
+                # La descripción del objeto raíz.
+                root_description = root_details.get('description', '')
+
+                # Formatea las propiedades extraídas usando la función auxiliar recursiva.
+                formatted_properties = self._format_json_schema(properties, 0)
+
+                # Construcción del resultado final, incluyendo el nombre del objeto raíz.
+                output_parts = [f"\n\n### Objeto: `{root_name}`"]
+                if root_description:
+                    # Limpia la descripción para que se muestre bien
+                    cleaned_description = '\n'.join(line.strip() for line in root_description.strip().split('\n'))
+                    output_parts.append(f"{cleaned_description}")
+
+                if formatted_properties:
+                    output_parts.append(f"**Campos del objeto `{root_name}`:**\n{formatted_properties}")
+
+                return "\n".join(output_parts)
+
+        # Si el esquema (como tender_schema.yaml) no tiene un objeto raíz,
+        # se formatea directamente como una lista de propiedades.
+        return self._format_json_schema(schema, 0)
+
+    def _format_json_schema(self, properties: dict, indent_level: int) -> str:
+        """
+        Formatea de manera recursiva las propiedades de un esquema JSON/YAML.
+        """
+        output = []
+        indent_str = '  ' * indent_level
+
+        for name, details in properties.items():
+            if not isinstance(details, dict):
+                continue
+
+            description = details.get('description', '')
+            data_type = details.get('type', 'any')
+            output.append(f"{indent_str}- **`{name.lower()}`** ({data_type}): {description}")
+
+            child_indent_str = '  ' * (indent_level + 1)
+
+            # Manejo de 'oneOf' para mostrar valores constantes
+            if 'oneOf' in details:
+                for item in details['oneOf']:
+                    if 'const' in item:
+                        const_desc = item.get('description', '')
+                        output.append(f"{child_indent_str}- `{item['const']}`: {const_desc}")
+
+            # Manejo de 'items' para arrays
+            if 'items' in details:
+                items_details = details.get('items', {})
+                if isinstance(items_details, dict):
+                    item_description = items_details.get('description')
+                    if item_description:
+                        # Limpiamos y añadimos la descripción del item
+                        cleaned_description = '\n'.join(
+                            f"{line.strip()}" for line in item_description.strip().split('\n')
+                        )
+                        output.append(
+                            f"{child_indent_str}*Descripción de los elementos del array:*\n{child_indent_str}{cleaned_description}")
+
+                    if 'properties' in items_details:
+                        nested_properties = self._format_json_schema(items_details['properties'], indent_level + 1)
+                        output.append(nested_properties)
+
+            # Manejo de 'properties' para objetos anidados estándar
+            if 'properties' in details:
+                nested_properties = self._format_json_schema(details['properties'], indent_level + 1)
+                output.append(nested_properties)
+
+            elif 'additionalProperties' in details and 'properties' in details.get('additionalProperties', {}):
+                # Imprime un marcador de posición para la clave dinámica.
+                output.append(
+                    f"{child_indent_str}- **[*]** (object): Las claves de este objeto son dinámicas (ej. un ID).")
+                # Procesa las propiedades del objeto anidado.
+                nested_properties = self._format_json_schema(details['additionalProperties']['properties'],
+                                                             indent_level + 2)
+                output.append(nested_properties)
+
+        return '\n'.join(output)
+
+    def load_markdown_context(self, filepath: str) -> str:
+        with open(filepath, 'r', encoding='utf-8') as f:
+            return f.read()
+
+    @classmethod
+    def _get_verifier(self, rut: int):
+        value = 11 - sum([int(a) * int(b) for a, b in zip(str(rut).zfill(8), '32765432')]) % 11
+        return {10: 'K', 11: '0'}.get(value, str(value))
+
+    def validate_rut(self, rut_str):
+        if not rut_str or not isinstance(rut_str, str):
+            return False
+
+        rut_str = rut_str.strip().replace('.', '').upper()
+        parts = rut_str.split('-')
+        if not len(parts) == 2:
+            return False
+
+        try:
+            rut = int(parts[0])
+        except ValueError:
+            return False
+
+        if rut < 1000000:
+            return False
+
+        if not len(parts[1]) == 1:
+            return False
+
+        digit = parts[1].upper()
+        return digit == self._get_verifier(rut)
+
+    def get_files_by_extension(self, directory: str, extension: str, return_extension: bool = False) -> List[str]:
+        try:
+            # Normalizar la extensión (agregar punto si no lo tiene)
+            if not extension.startswith('.'):
+                extension = '.' + extension
+
+            # Verificar que el directorio existe
+            if not os.path.exists(directory):
+                raise IAToolkitException(IAToolkitException.ErrorType.FILE_IO_ERROR,
+                                   f'El directorio no existe: {directory}')
+
+            if not os.path.isdir(directory):
+                raise IAToolkitException(IAToolkitException.ErrorType.FILE_IO_ERROR,
+                                   f'La ruta no es un directorio: {directory}')
+
+            # Buscar archivos con la extensión especificada
+            files = []
+            for filename in os.listdir(directory):
+                file_path = os.path.join(directory, filename)
+                if os.path.isfile(file_path) and filename.endswith(extension):
+                    if return_extension:
+                        files.append(filename)
+                    else:
+                        name_without_extension = os.path.splitext(filename)[0]
+                        files.append(name_without_extension)
+
+            return sorted(files)  # Retornar lista ordenada alfabéticamente
+
+        except IAToolkitException:
+            raise
+        except Exception as e:
+            logging.exception(e)
+            raise IAToolkitException(IAToolkitException.ErrorType.FILE_IO_ERROR,
+                               f'Error al buscar archivos en el directorio {directory}: {str(e)}') from e
+
+    def is_openai_model(self, model: str) -> bool:
+        openai_models = [
+            'gpt-5', 'gpt'
+        ]
+        return any(openai_model in model.lower() for openai_model in openai_models)
+
+    def is_gemini_model(self, model: str) -> bool:
+        gemini_models = [
+            'gemini', 'gemini-2.5-pro'
+        ]
+        return any(gemini_model in model.lower() for gemini_model in gemini_models)

iatoolkit/iatoolkit.py

@@ -8,10 +8,7 @@ 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 urllib.parse import urlparse
 import redis
 import logging
@@ -294,6 +291,8 @@ class IAToolkit:
         from infra.llm_proxy import LLMProxy
         from infra.google_chat_app import GoogleChatApp
         from infra.mail_app import MailApp
+        from common.auth import IAuthentication
+        from common.util import Utility
 
         binder.bind(LLMProxy, to=LLMProxy, scope=singleton)
         binder.bind(llmClient, to=llmClient, scope=singleton)
@@ -352,6 +351,7 @@ class IAToolkit:
         # Configura context processors para templates
         @self.app.context_processor
         def inject_globals():
+            from common.session_manager import SessionManager
             return {
                 'url_for': url_for,
                 'iatoolkit_version': self.version,

{iatoolkit-0.7.4.dist-info → iatoolkit-0.7.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: iatoolkit
-Version: 0.7.4
+Version: 0.7.6
 Summary: IAToolkit
 Author: Fernando Libedinsky
 License-Expression: MIT

iatoolkit-0.7.6.dist-info/RECORD

@@ -0,0 +1,80 @@
+common/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+common/auth.py,sha256=kKBvZoIm8RPpPFZ6KEm1oowHJfJwSO0mf10Yac8SG9k,8456
+common/exceptions.py,sha256=EXx40n5htp7UiOM6P1xfJ9U6NMcADqm62dlFaKz7ICU,1154
+common/routes.py,sha256=_1ywiXorwEeJ8IAamQwSxU9z8jlAAL_U64tMb01-zFg,4188
+common/session_manager.py,sha256=7D_RuJs60w-1zDr3fOGEz9JW7IZlSXuUHgUT87CzaUo,472
+common/util.py,sha256=5zw1wL_FdPBibGJbQAl1kozgTjUpsOZlPqT3tbWsHp4,15515
+iatoolkit/__init__.py,sha256=GkFxAQHKPifz4Kd8M73Rc8TWRVIxjxkl1N0nsPvb_sU,1743
+iatoolkit/base_company.py,sha256=WmD4o0qFC1n5DW5eRsRsuNfaGot9nxGFcJe3LmibSuE,4259
+iatoolkit/cli_commands.py,sha256=BGuThg19eoSssrBJIqzBNaWpMmyy7u4yRUz0JA7d-vc,2270
+iatoolkit/company_registry.py,sha256=tduqt3oV8iDX_IB1eA7KIgvIxE4edTcy-3qZIXh3Lzw,2549
+iatoolkit/iatoolkit.py,sha256=bbwLkLS_xZGNS0Dki3zX73RhAYMS32IshXDIdr_RVXg,15776
+iatoolkit/system_prompts/format_styles.prompt,sha256=MSMe1qvR3cF_0IbFshn8R0z6Wx6VCHQq1p37rpu5wwk,3576
+iatoolkit/system_prompts/query_main.prompt,sha256=w_9ybgWgiQH4V_RbAXqsvz0M7oOuiyhxcwf-D0CgfA4,3017
+iatoolkit/system_prompts/sql_rules.prompt,sha256=y4nURVnb9AyFwt-lrbMNBHHtZlhk6kC9grYoOhRnrJo,59174
+infra/__init__.py,sha256=5JqK9sZ6jBuK83zDQokUhxQ0wuJJJ9DXB8pYCLkX7X4,102
+infra/call_service.py,sha256=170qCNJb_9caUiEi8PprQaqSUS3Rj7XmU917J2-m62I,4919
+infra/gemini_adapter.py,sha256=MLesq8Oyx_Jd6-cSA_41zC1UtDM6CMino054NEybOJM,15031
+infra/google_chat_app.py,sha256=XHyFQyX92ztpJQLvNx4mKPjbR2x7_15t_dcpVqW25ZQ,1927
+infra/llm_client.py,sha256=cN1uaZxOP7H8LkmFpSpQMesBH3Pg1LKJuent4r1yovg,18548
+infra/llm_proxy.py,sha256=qBird4-k3Z8ABECvnWXbljXCQWx2q6RTmylJZQLDk4U,5684
+infra/llm_response.py,sha256=YUUQPBHzmP3Ce6-t0kKMRIpowvh7de1odSoefEByIvI,904
+infra/mail_app.py,sha256=eWSOz5uWf-KmZoUJbYFPad-0uWP2LekINAamDYbxYpg,6093
+infra/openai_adapter.py,sha256=roPrp-DJWcHHhOXdUttsgwfhJpMhHNy1RpkdzVKQMFo,3510
+infra/redis_session_manager.py,sha256=Dkwii8fns0_Vd9hm9GmotmrKtSCxVps868U5sqj7FAE,2278
+infra/connectors/__init__.py,sha256=5JqK9sZ6jBuK83zDQokUhxQ0wuJJJ9DXB8pYCLkX7X4,102
+infra/connectors/file_connector.py,sha256=HOjRTFd-WfDOcFyvHncAhnGNZuFgChIwC-P6osPo9ZM,352
+infra/connectors/file_connector_factory.py,sha256=xa4hphbeNVt0l4nn_mNbBT31lgn-OMlIQ8TtXpgN42M,2068
+infra/connectors/google_cloud_storage_connector.py,sha256=5KDZlT7ndgkqFOC3SebrmSQpP2zSb3KnSBVXWWt7Alg,2040
+infra/connectors/google_drive_connector.py,sha256=MyRECNWvLf5j-YvNwokcwihRS1WhZnBDUjx8tSup2L0,2527
+infra/connectors/local_file_connector.py,sha256=FO9_HFGKRE_GQqOjyWuIHyNFXYUgro39CxxqEcXUq1c,1719
+infra/connectors/s3_connector.py,sha256=M91gWnOgyCYIsoB0xka2oSaOTL4gDgjfjHwZi20jgnw,1113
+repositories/__init__.py,sha256=5JqK9sZ6jBuK83zDQokUhxQ0wuJJJ9DXB8pYCLkX7X4,102
+repositories/database_manager.py,sha256=UWOZhbUjNQV0yoL9xevuAnxV2OuBkMaxu5nqaqMuMQE,3098
+repositories/document_repo.py,sha256=dq41jj5hBOd6mRKdaSRMhyiHk12ukX43njVyLuuGl44,1094
+repositories/llm_query_repo.py,sha256=NF8Ybye_sMVvzeQGa_5MGJup0AFvl_P1Z0oCsr2Wz0Y,3592
+repositories/models.py,sha256=RJH0dtq2VIDJFaFDufV05NUnNW4WtNpdTjhONtfLyCw,13179
+repositories/profile_repo.py,sha256=JWbClu9SM18koUceLQdeuT5DA37h6ij5aeK-nwoRgIk,4042
+repositories/tasks_repo.py,sha256=cCg4uz8ou4tkx7yzmktEV4lfQjQBU-RylcqUof2dytY,1725
+repositories/vs_repo.py,sha256=PP6iPf0rt64rMyvqg-ffJk__sLbT2wgxx3dta3o8Vuo,5270
+services/__init__.py,sha256=5JqK9sZ6jBuK83zDQokUhxQ0wuJJJ9DXB8pYCLkX7X4,102
+services/benchmark_service.py,sha256=_ruKh9YzrTLtR0ZKrRNxqJQW0HdbwWuFz1gfLzJ9owA,5850
+services/dispatcher_service.py,sha256=y2J-TfrkoCcsOESr3E6E3q5bleJfRibT4ONxs9AxUSg,13959
+services/document_service.py,sha256=8MsJz0pihM9E9Z92PrPqDgQnpMAmpFrbogXr5HscMWM,5926
+services/excel_service.py,sha256=ATPaeAvkLwQAkPZ3AKIUpO73RVyRg0D8c6i37_mcql0,3559
+services/file_processor_service.py,sha256=98yWYF7nIq1nm7nh6IzMmTKaOMTIeqCFWYwXVtV-ZJI,4102
+services/history_service.py,sha256=j0QCqcIIyw7DBy3GrZrEZNk0I4m-uuRoG5g0Z2RCcOE,1586
+services/jwt_service.py,sha256=YoZ9h7_o9xBko-arNQv4MbcwnxoSWVNj4VbZmMo_QGY,3908
+services/load_documents_service.py,sha256=UGfomYz7seWFXawbDuk2t6CyoEr1vggR8vmrCUAeLBg,7190
+services/mail_service.py,sha256=_67pctxZO46DHnWBip51ayuYtWd4bEoS1kg29ACO7_I,2162
+services/profile_service.py,sha256=vTK9TvH_2AFdqgL3sGjhck9LyLGIbvdC2USoaRx82G8,17561
+services/prompt_manager_service.py,sha256=7SMC6N_T4BP4m5-ZNYAL3Y2YWHwl1bytXSgnEqu5bWI,8301
+services/query_service.py,sha256=gvUnq0Vpn4gv5ycQk8-fklh7NDFIXpO1Vt1lT2ugO6Q,15283
+services/search_service.py,sha256=bB3FWFxJi1iYsOdBxyu9tzIO406nQxcyeQzEowpmpjY,1803
+services/sql_service.py,sha256=s84K1ADlvMtum949wgMh8jsmqlOUeL-m_SWfAM4Wsv4,2141
+services/tasks_service.py,sha256=1DdbERlAxIkCpGEylnHDKC-KAsXRJugbaRSzRbPfL58,6790
+services/user_feedback_service.py,sha256=_LeNBYz4hHFapXfYTQVfkkD34gE8j2UeKnyOZ8H0nWo,2442
+services/user_session_context_service.py,sha256=GluNSgqP6W_hFke4oslSnfGnU_b-ph28BHH6jf3EIm0,3797
+views/__init__.py,sha256=5JqK9sZ6jBuK83zDQokUhxQ0wuJJJ9DXB8pYCLkX7X4,102
+views/change_password_view.py,sha256=KY6mf25Vc-rJn8pTLuJlkIHB7j9_NI0UoxIWod32qpM,3930
+views/chat_token_request_view.py,sha256=7Bgf7rOVdgo4u4nU4lZWk87wi_D9_-sYxB9zBuL8TcA,4388
+views/chat_view.py,sha256=XvKJApeJPU9uoH0XpHusehNbge3dDwwr72iMcuBveBY,2048
+views/download_file_view.py,sha256=AIHLURyPi7w0k_Rs_fqz0yOp1Hav8K73AC5Bxx4vzf4,1980
+views/external_chat_login_view.py,sha256=pz8EPmTSrYHpr3WbfYYBbPvSKaDJ9taOro4bMqTAZZE,3732
+views/external_login_view.py,sha256=2NPzdxIqw1zvRHcsKOVvL896mE9B4GCUI6gBW7LsZCU,1335
+views/file_store_view.py,sha256=591Kc2QR7SdxMrcJcL1ciMEwRopCpqYbmODL4XZ2SU8,1913
+views/forgot_password_view.py,sha256=7W2VP3nZlUdgGLv-zc7Pj5wa7OsT3K66t6fkntrSPzI,2705
+views/history_view.py,sha256=nkvV6Dg6SrVWZsWQJaCpy7D9VygwXDQF5FVanhzHdeo,2044
+views/home_view.py,sha256=lQvDYUJ1X-xu0GuJcZJwF9iW74d834_q8fCkLgqo6j4,1238
+views/llmquery_view.py,sha256=_CsbtFQFRuGCe50TWJDtTSUyaM3kMMwkn54kVuxMEQw,2412
+views/login_view.py,sha256=s2FQPo8EuJCWPoC2hs1Wyqh8rY6Dc_5HmiL9b9GLhho,2322
+views/prompt_view.py,sha256=ARuZ64EYjBhMAClUvjeFcr7zcgZUt2rEktbUvqpiE2U,1237
+views/signup_view.py,sha256=Jn2F0gGBDmyUYt4vo0fw2UMHoJblau-Be62zNAMas50,3795
+views/tasks_review_view.py,sha256=nvxdUJowfpgrJk0m8quxYg4iw5BZOhZhpDpPt5-wsDI,3368
+views/tasks_view.py,sha256=TWW48wzcJzqIPat1kSRx41Et92-wLr-wCkgypWYZ7dk,4090
+views/user_feedback_view.py,sha256=inZoNl5YnEq9_2FXOVvzKymXuSPELLmi9zPNG3zQxEQ,2632
+views/verify_user_view.py,sha256=0hRKIudox7KjxZDH973trUhw4fZtc7eiLz6R44QbIG8,2341
+iatoolkit-0.7.6.dist-info/METADATA,sha256=ewI228_gn4LwbqX0Dmd39uey9MCnkMRxpsL6Dcs5ujg,9300
+iatoolkit-0.7.6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+iatoolkit-0.7.6.dist-info/top_level.txt,sha256=ZXCST2AUsVPIeMiz49ZFn7WEfIiO4d8BfWY9QzUqP0s,51
+iatoolkit-0.7.6.dist-info/RECORD,,

iatoolkit-0.7.6.dist-info/top_level.txt

@@ -0,0 +1,6 @@
+common
+iatoolkit
+infra
+repositories
+services
+views

infra/__init__.py

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

infra/call_service.py

@@ -0,0 +1,140 @@
+# Copyright (c) 2024 Fernando Libedinsky
+# Product: IAToolkit
+#
+# IAToolkit is open source software.
+
+from 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)

infra/connectors/__init__.py

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

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