Nuevo Bot¶

La sección Nuevo Bot te guía paso a paso en el proceso completo de creación y subida de nuevos bots Python a la plataforma Unimate. Aquí cargas archivos ZIP con tu código y configuras los parámetros iniciales.

Interfaz de Creación¶

La interfaz de creación de nuevos bots presenta un formulario completo para configurar todos los aspectos del bot:

Secciones del formulario¶

Información General
- Nombre del bot: Identificador único y descriptivo
- Descripción: Explicación de la funcionalidad del bot
- Versión: Control de versiones del bot
Configuración de Archivo
- Subida de ZIP: Selector de archivo con validaciones
- Script principal: Archivo .py de entrada dentro del ZIP
- Validación: Verificación automática de estructura
Configuración de Parámetros
- Parámetros dinámicos: Lista configurable de argumentos
- Tipos de datos: Texto, número, booleano, lista
- Valores por defecto: Configuración de valores iniciales
- Validaciones: Reglas para cada parámetro

Preparación del Bot¶

Estructura recomendada del proyecto¶

mi_bot.zip
│
├── main.py              # ← Archivo principal (configurado en el formulario)
├── requirements.txt     # Dependencias del proyecto
├── config.json          # Configuraciones del bot (opcional)
├── README.md            # Documentación del bot
├── modules/             # Módulos adicionales del bot
│   ├── __init__.py
│   ├── data_processor.py
│   └── utils.py
└── assets/              # Recursos adicionales (opcional)
    ├── templates/
    └── data/

Requisitos del bot¶

Punto de entrada: Debe especificarse en el formulario (ej: main.py)
Compatibilidad: Python 3.8+ con soporte para argparse
Dependencias: Listadas en requirements.txt
Argumentos: Compatible con parámetros dinámicos configurados

Proceso de Creación Paso a Paso¶

Paso 1: Información General¶

Información Básica del Bot
├── Nombre: Mi Bot Procesador de Datos
├── Descripción: Procesa archivos Excel y genera reportes CSV
├── Versión: 1.0.0
└── Autor: [Tu nombre/equipo]

Campos obligatorios:

Nombre: Identificador único y descriptivo
Descripción: Explicación clara de la funcionalidad
Versión: Sistema de versionado semántico (1.0.0)

Paso 2: Subida del Archivo ZIP¶

Configuración de Archivo
├── Archivo ZIP: [ Seleccionar archivo... ] → mi_bot.zip
├── Tamaño: 2.3 MB
├── Validación: Estructura correcta
└── Script principal: main.py

Validaciones automáticas:

Estructura del ZIP: Verifica archivos obligatorios
Script principal: Debe existir y ser ejecutable
requirements.txt: Verifica dependencias válidas
Sintaxis Python: Valida que el código compile

Paso 3: Configuración del Script Principal¶

Configuración Python
├── Archivo principal: main.py
├── Punto de entrada: main()
├── Argumentos soportados: Sí (argparse detectado)
└── Dependencias: pandas, openpyxl, requests

Paso 4: Configuración de Parámetros¶

Ejemplo de configuración como se ve en el formulario:

Parámetros Dinámicos Configurados
│
├──archivo_entrada
│    ├── Tipo: Texto (String)
│    ├── Obligatorio: Sí
│    └── Desc: Ruta del archivo Excel a procesar
│
├──formato_salida
│    ├── Tipo: Lista de opciones
│    ├── Opciones: CSV, JSON, XLSX
│    ├── Obligatorio: No
│    ├── Por defecto: CSV
│    └── Desc: Formato del archivo de salida
│
└──limite_registros
     ├── Tipo: Número entero
     ├── Obligatorio: No
     ├── Por defecto: 1000
     ├── Mínimo: 1, Máximo: 100000
     └── Desc: Cantidad máxima de registros a procesar

Ejemplo de Código Compatible¶

Ejemplo completo de main.py optimizado para Unimate:

import argparse
import sys
import os
import pandas as pd
import json
from datetime import datetime

def main():
    # Configuración de argumentos (debe coincidir con parámetros configurados)
    parser = argparse.ArgumentParser(description='Bot Procesador de Datos Avanzado')

    # Parámetros configurados en el formulario
    parser.add_argument('--archivo_entrada',
                       type=str,
                       required=True,
                       help='Ruta del archivo Excel a procesar')

    parser.add_argument('--formato_salida',
                       type=str,
                       default='CSV',
                       choices=['CSV', 'JSON', 'XLSX'],
                       help='Formato del archivo de salida')

    parser.add_argument('--limite_registros',
                       type=int,
                       default=1000,
                       help='Cantidad máxima de registros a procesar')

    args = parser.parse_args()

    # Logs informativos (aparecen en tiempo real en Unimate)
    print(f"Bot Procesador iniciado - {datetime.now()}")
    print(f"Archivo entrada: {args.archivo_entrada}")
    print(f"Formato salida: {args.formato_salida}")
    print(f"Límite registros: {args.limite_registros}")

    try:
        # Validación de entrada
        print("Validando archivo de entrada...")
        if not os.path.exists(args.archivo_entrada):
            print(f"ERROR: Archivo no encontrado: {args.archivo_entrada}")
            sys.exit(1)

        # Procesamiento
        print("Cargando datos...")
        df = pd.read_excel(args.archivo_entrada)
        total = len(df)
        print(f"Cargados {total} registros")

        # Aplicar límite
        if total > args.limite_registros:
            df = df.head(args.limite_registros)
            print(f"Aplicando límite: {args.limite_registros} de {total}")

        # Procesamiento principal
        print("Procesando datos...")
        # Tu lógica de procesamiento aquí
        resultado = df  # Placeholder

        # Generar salida
        timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
        nombre_archivo = f"resultado_{timestamp}.{args.formato_salida.lower()}"

        print(f"Guardando resultado: {nombre_archivo}")

        if args.formato_salida == 'CSV':
            resultado.to_csv(nombre_archivo, index=False)
        elif args.formato_salida == 'JSON':
            resultado.to_json(nombre_archivo, orient='records')
        elif args.formato_salida == 'XLSX':
            resultado.to_excel(nombre_archivo, index=False)

        print(f"Proceso completado exitosamente")
        print(f"Archivo generado: {nombre_archivo}")
        print(f"Total procesados: {len(resultado)} registros")

    except Exception as e:
        print(f"ERROR: {str(e)}")
        sys.exit(1)

if __name__ == "__main__":
    main()

Validación Final y Envío¶

Antes de crear el bot, el sistema valida:

Validación Final
├── Información general completa
├── Archivo ZIP válido y procesable
├── Script principal ejecutable
├── Parámetros correctamente definidos
├── Dependencias resolubres
└── Sintaxis Python válida

Una vez validado:

Hace clic en «Crear Bot»
El sistema procesa y almacena el bot
Se crea la entrada en la lista de bots
Se instalan las dependencias automáticamente
El bot queda listo para ejecutar o programar

Consejos para Desarrollo¶

Estructura Recomendada¶

Usa logging con print() para monitoreo
Valida argumentos al inicio del script
Maneja excepciones apropiadamente
Incluye progress indicators para procesos largos
Documenta parámetros en el help de argparse

Optimizaciones¶

Procesa en chunks datasets grandes
Usa paths relativos cuando sea posible
Limpia archivos temporales al finalizar
Optimiza imports para reduir tiempo de carga
Usa caché para cálculos costosos repetitivos

Consideraciones Importantes¶

No uses paths absolutos hardcodeados
No asumas estructura de directorios del agente
Incluye timeouts en operaciones de red
Maneja encodings de archivos apropiadamente
Testea con diferentes tamaños de datos

    print(f"- Parámetro 1: {args.parametro1}")
    print(f"- Parámetro 2: {args.parametro2}")

    # Lógica principal del bot
    ejecutar_proceso(args.parametro1, args.parametro2)

def ejecutar_proceso(param1, param2):
    # Tu código aquí
    pass

    if __name__ == "__main__":
        main()

Compresión del Proyecto¶

Pasos para crear el archivo ZIP:

Selecciona todos los archivos del proyecto (no la carpeta contenedora)
Comprime en formato ZIP estándar
Verifica que el archivo no exceda el tamaño máximo permitido
Nombra el archivo de forma descriptiva: mi_bot_v1.0.zip

Importantes consideraciones:

No incluir archivos innecesarios (.pyc, __pycache__, .git)
Verificar que todas las dependencias estén en requirements.txt
Probar localmente antes de subir a la plataforma
Documentar parámetros y configuraciones en README.md

Proceso de Subida¶

Desde el Portal Unimate:

Accede al módulo «Gestión de Bots Personalizados»
Haz clic en «Subir Nuevo Bot»
Selecciona el archivo ZIP de tu proyecto
Completa la información del bot: - Nombre descriptivo - Descripción de funcionalidad - Versión - Categoría
Define los parámetros configurables (opcional)
Guarda y verifica la carga exitosa

Validaciones automáticas:

La plataforma verificará:

Formato ZIP válido
Presencia de archivo principal ejecutable
Sintaxis Python correcta
Estructura de proyecto coherente
Tamaño dentro de límites permitidos

Estados del bot tras la subida:

Validado: Listo para ejecución
Pendiente: En proceso de validación
Error: Requiere corrección de problemas detectados

Una vez subido exitosamente, el bot estará disponible para su ejecución y calendarización desde el portal.

Mejores Prácticas¶

Para optimizar la compatibilidad:

Usa rutas relativas en el código
Maneja excepciones apropiadamente
Incluye logging para facilitar el debugging
Documenta claramente los parámetros requeridos
Testa el bot con diferentes conjuntos de parámetros

Ejemplo de requirements.txt:

pandas>=1.3.0
requests>=2.25.0
openpyxl>=3.0.0
python-dotenv>=0.19.0