View a markdown version of this page

Code - Amazon Quick
Expressions sur une seule ligneBloc de code personnalisé

Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

Code

Les actions de code dans Quick Automate vous permettent d'implémenter une logique personnalisée à l'aide de blocs de code Python, allant au-delà de ce que les actions d'automatisation standard prennent en charge. Ils sont parfaitement adaptés aux transformations de données et aux calculs complexes, et s'exécutent dans un environnement Python restreint pour garantir la sécurité.

Deux types d'actions de code :

  • Expressions sur une seule ligne : opérations rapides sur une ligne qui modifient des variables sans renvoyer de valeurs

  • Blocs de code personnalisés : fonctions Multi-line Python pour une logique complexe avec paramètres et valeurs de retour

Quand utiliser les actions de code :

Utilisez des blocs de code lorsque vous devez :

  • Réaliser des transformations de données complexes non disponibles dans les actions standard

  • Mettre en œuvre une logique métier ou des calculs personnalisés

  • Traiter ou manipuler des structures de données (listes, dictionnaires, JSON)

  • Travaillez avec les dates, les heures et les fuseaux horaires de manière personnalisée

  • Analyser ou formater des chaînes avec des modèles complexes

  • Optimisez les performances d'automatisation en consolidant plusieurs actions dans un seul bloc de code

Quand ne pas utiliser les actions de code :

Évitez les blocs de code lorsque :

  • Une action d'automatisation standard existe déjà pour votre cas d'utilisation

  • L'opération est assez simple pour les actions intégrées

  • Vous devez interagir avec des API externes (utilisez plutôt l'intégration des API REST)

  • Vous devez accéder à des systèmes de fichiers ou à des bases de données (utiliser les intégrations appropriées)

Comment accéder aux actions du code :

Les blocs de code sont disponibles via plusieurs interfaces :

  • Panneau d'actions (recommandé) :

    • Ouvrez votre automatisation dans le générateur d'automatisation

    • Cliquez sur le panneau d'actions sur le côté droit

    • Localisez « Bloc de code personnalisé » dans la section Actions de code

    • Glissez et déposez le bloc de code dans votre flux de travail d'automatisation

  • Construisez avec Assistant :

    • Disponible lors de la génération du plan lorsque l'assistant détermine qu'un code personnalisé est nécessaire

    • L'assistant suggère automatiquement des blocs de code pour les opérations complexes

    • Vous pouvez demander des blocs de code en décrivant vos besoins logiques personnalisés

Actions disponibles :

Expressions sur une seule ligne

Les expressions d'une seule ligne exécutent des instructions Python d'une ligne qui effectuent des opérations sans renvoyer de valeur. Elles sont idéales pour modifier rapidement des variables existantes, par exemple pour les ajouter à des listes, mettre à jour des dictionnaires ou effectuer des calculs simples qui modifient l'état.

Propriétés :

  • Expression (obligatoire) : expression Python à exécuter (par exemple, « my_list.append ('new item') »)

Exemples :

  • Ajouter à la liste

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

  • Supprimer des éléments de liste

    task_list.remove(completed_task)

Bloc de code personnalisé

Les blocs de code personnalisés sont des fonctions Python multilignes qui exécutent une logique complexe, acceptent des paramètres et renvoient des valeurs. Elles constituent l'option de secours lorsque les actions d'automatisation standard et les expressions unifilaires ne sont pas suffisantes pour répondre à vos besoins.

Propriétés :

  • Titre de la fonction (obligatoire) : identifiant du nom du bloc de code (par exemple, Calculate_Total « »)

  • Fonction (obligatoire) : bloc de code Python contenant votre logique personnalisée.

    • Étape 1 : définir les paramètres

      • Cliquez sur le bouton « Modifier » pour ouvrir l'éditeur de code

      • Dans le panneau Paramètres, cliquez sur « Ajouter » pour créer de nouveaux paramètres

      • Entrez les noms des paramètres qui correspondent à vos variables d'automatisation

      • Les paramètres sont disponibles sous forme d'arguments de fonction

    • Étape 2 : Écrivez votre code Python

  • Valeur de retour (facultatif) : nom de variable pour stocker la sortie de la fonction

    • Suivez la structure de bloc de code requise (voir ci-dessous)

    • Implémentez votre logique personnalisée dans la fonction

    • Utilisez uniquement des bibliothèques approuvées et des fonctions intégrées

    • Incluez une déclaration de retour si vous devez générer des données

Structure des blocs de code

Tous les blocs de code doivent respecter ce format spécifique :

@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

Built-in Fonctions Python et importations

Toutes les fonctions intégrées standard de Python sont disponibles sans importation (len, str, int, etc.)

Bibliothèques standard approuvées (sécurité restreinte)

Les blocs de code peuvent UNIQUEMENT importer ces bibliothèques standard :

  • base64- Base 64 encoding/decoding

  • datetime- Opérations relatives à la date et à l'heure

  • json- Analyse et génération de JSON

  • math- Fonctions mathématiques

  • re- Expressions régulières

  • zoneinfo- Gestion des fuseaux horaires

Note

  • Impossible d'importer des bibliothèques standard autres que celles répertoriées ci-dessus.

  • Impossible d'installer ou d'importer des bibliothèques tierces. pip installn'est pas pris en charge dans les blocs de code.

Limites

  • Environnement Python restreint avec accès limité aux bibliothèques. L'environnement d'exécution est basé sur RestrictedPython un sous-ensemble de Python 3.10.

  • Les blocs de code ne peuvent pas invoquer d'autres blocs de code ou actions

Bonnes pratiques

  • Gardez les blocs de code simples et ciblés

  • Utiliser des noms de fonctions descriptifs

  • Privilégiez toujours les actions prédéfinies lorsqu'elles sont disponibles

  • Testez soigneusement vos blocs de code (car les options de débogage ciblées sont limitées)

Exemples de cas d'utilisation

  • Opérations mathématiques (Calculer les propriétés du cercle - rayon comme paramètre)

    def function
(radius):

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

  • Se tenir au courant date/time

    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()
    }

  • Calcul des différences de dates - Date de début et date de fin en tant que paramètres

    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    }

  • Correspondance de modèles et manipulation de texte à l'aide d'expressions régulières (validation d'adresses e-mail, de numéros de téléphone, 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))
    }

  • Opérations de liste (liste de filtrage et de transformation)

    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"
        }