Código

Las acciones de código en Quick Automate le permiten implementar una lógica personalizada mediante bloques de código de Python, yendo más allá de lo que admiten las acciones de automatización estándar. Son adecuados para transformaciones y cálculos de datos complejos, y se ejecutan en un entorno Python restringido para mantener la seguridad.

Dos tipos de acciones de código:

• Expresiones de una sola línea: operaciones rápidas de una línea que modifican las variables sin devolver valores

• Bloques de código personalizados: funciones de Python multilínea para una lógica compleja con parámetros y valores de retorno

Cuándo usar acciones de código:

Usa bloques de código cuando necesites:

• Realice transformaciones de datos complejas que no están disponibles en las acciones estándar

• Implemente cálculos o lógica empresarial personalizados

• Procese o manipule estructuras de datos (listas, diccionarios, JSON)

• Trabaje con fechas, horas y zonas horarias de forma personalizada

• Analice o formatee cadenas con patrones complejos

• Optimice el rendimiento de la automatización mediante la consolidación de varias acciones en un bloque de código

Cuándo no usar acciones de código:

Evita los bloques de código cuando:

• Ya existe una acción de automatización estándar para su caso de uso

• La operación es lo suficientemente simple como para realizar acciones integradas

• Debe interactuar con un externo APIs (utilice la integración de la API REST en su lugar)

• Debe acceder a los sistemas de archivos o bases de datos (utilice las integraciones adecuadas)

Cómo acceder a las acciones del código:

Los bloques de código están disponibles a través de varias interfaces:

• Panel de acciones (recomendado):

  • Abre tu automatización en el generador de automatizaciones

  • Haga clic en el panel de acciones en el lado derecho

  • Busca el «Bloque de código personalizado» en la sección Acciones de código

  • Arrastra y suelta el bloque de código en tu flujo de trabajo de automatización

• Crea con Assistant:

  • Disponible durante la generación del plan cuando el asistente determina que se necesita un código personalizado

  • El asistente sugiere automáticamente bloques de códigos para operaciones complejas

  • Puede solicitar bloques de código describiendo sus necesidades lógicas personalizadas

Acciones disponibles:

Expresiones de una sola línea

Las expresiones de línea única ejecutan sentencias de Python de una línea que realizan operaciones sin devolver un valor. Son ideales para realizar modificaciones rápidas en variables existentes, como añadirlas a listas, actualizar diccionarios o realizar cálculos sencillos que modifiquen el estado.

Propiedades:

• Expresión (obligatoria): la expresión de Python que se va a ejecutar (por ejemplo, «my_list.append ('new item')»)

Ejemplos:

• Añadir a la lista

  my_list.append("1")
  my_list.append(new_item)

• Eliminar elementos de la lista

  task_list.remove(completed_task)

Bloque de código personalizado

Los bloques de código personalizados son funciones de Python multilínea que ejecutan una lógica compleja, aceptan parámetros y devuelven valores. Son la opción alternativa cuando las acciones de automatización estándar y las expresiones de línea única no son suficientes para tus necesidades.

Propiedades:

• Título de la función (obligatorio): identificador del nombre del bloque de códigos (por ejemplo, «Calculate_Total»)

• Función (obligatoria): bloque de código de Python que contiene tu lógica personalizada.

  • Paso 1: Definir los parámetros

    • Haga clic en el botón «Editar» para abrir el editor de código

    • En el panel de parámetros, haga clic en «Añadir» para crear nuevos parámetros

    • Introduzca los nombres de los parámetros que coincidan con las variables de automatización

    • Los parámetros están disponibles como argumentos de función

  • Paso 2: Escribe tu código en Python

• Valor de retorno (opcional): nombre de la variable para almacenar el resultado de la función

  • Siga la estructura de bloques de código requerida (ver más abajo)

  • Implemente su lógica personalizada dentro de la función

  • Utilice únicamente bibliotecas aprobadas y funciones integradas

  • Incluya una declaración de devolución si necesita generar datos

Estructura de bloques de código

Todos los bloques de código deben seguir este formato específico:

@code_block()
def your_function_name(parameter1, parameter2, parameter3):
-------------------------------------------------------------------------------------
    """
    Optional: Add a docstring describing what your function does
    """
    # Your custom logic here
    result = parameter1 + parameter2 + parameter3

    return result

Funciones e importaciones de Python integradas

Todas las funciones integradas estándar de Python están disponibles sin importaciones (len, str, int, etc.)

Bibliotecas estándar aprobadas (con restricciones de seguridad)

Los bloques de código SOLO pueden importar estas bibliotecas estándar:

• base64- Codificación/decodificación en Base64

• datetime- Operaciones de fecha y hora

• json- Análisis y generación de JSON

• math- Funciones matemáticas

• re- Expresiones regulares

• zoneinfo- Manejo de zonas horarias

nota

• No se pueden importar bibliotecas estándar distintas de las enumeradas anteriormente.

• No se pueden instalar ni importar bibliotecas de terceros. pip installno se admite en los bloques de código.

Limitaciones

• Entorno Python restringido con acceso limitado a la biblioteca. El entorno de ejecución se basa en RestrictedPython un subconjunto de Python 3.10.

• Los bloques de código no pueden invocar otros bloques de código o acciones

prácticas recomendadas

• Mantén los bloques de código simples y enfocados

• Utilice nombres de funciones descriptivos

• Prefiera siempre las acciones prediseñadas cuando estén disponibles

• Prueba tus bloques de código minuciosamente (las opciones de depuración específicas son limitadas)

Ejemplo de Casos de uso

• Operaciones matemáticas (calcule las propiedades del círculo con el radio como parámetro

  def function
  (radius):
  
      return {
          "radius": radius,
          "diameter": 2 * radius,
          "circumference": round(2 * math.pi * radius, 2),
          "area": round(math.pi * radius ** 2, 2)
      }

• Obtener la fecha/hora actuales

  def function
  ():
  
      now = datetime.datetime.now()
  
      return {
          "current_date": now.strftime("%Y-%m-%d"),
          "current_time": now.strftime("%H:%M:%S"),
          "formatted": now.strftime("%B %d, %Y at %I:%M %p"),
          "iso_format": now.isoformat(),
          "timestamp": now.timestamp()
      }

• Cálculo de las diferencias de fecha: fecha de inicio y fecha de finalización como parámetros

  def function
  _(start_date_str, end_date_str):
  
  # Parse date strings (format: YYYY-MM-DD)_
      start = datetime.datetime.strptime(start_date_str, "%Y-%m-%d")
      end = datetime.datetime.strptime(end_date_str, "%Y-%m-%d")
  
      _# Calculate difference_
      difference = end - start
      return {
          "days": difference.days,
          "weeks": difference.days // 7,
          "start": start_date_str,
          "end": end_date_str    }

• Coincidencia de patrones y manipulación de texto mediante expresiones regulares (validación de direcciones de correo electrónico, números de teléfono, etc.)

  def function
  (email, phone, zip_code):
  
      email_pattern = r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$'
      phone_pattern = r'^\d{3}-\d{3}-\d{4}$'
      zip_pattern = r'^\d{5}(-\d{4})?$'
  
      return {
          "email_valid": bool(re.match(email_pattern, email)),
          "phone_valid": bool(re.match(phone_pattern, phone)),
          "zip_valid": bool(re.match(zip_pattern, zip_code))
      }

• Operaciones de lista (lista de filtros y transformaciones)

  def function
  (numbers, threshold):
  
      # Filter numbers above threshold and calculate statistics
      filtered = [n for n in numbers if n > threshold]
  
      if filtered:
          return {
              "filtered_numbers": filtered,
              "count": len(filtered),
              "sum": sum(filtered),
              "average": sum(filtered) / len(filtered),
              "min": min(filtered),
              "max": max(filtered)
          }
      else:
          return {
              "filtered_numbers": [],
              "count": 0,
              "message": "No numbers above threshold"
          }