Créer des fonctions Python

Une fonction Python comporte trois parties: une entrée saisie, une sortie saisie et une fonction de point d'entrée qui se mappe l'une à l'autre. Cette page couvre chaque, plus la gestion des erreurs et exposant plusieurs fonctions d'un même projet.

Entrée et sortie saisies

Définissez Input et Output comme Python saisi. Utilisez pydantic.dataclasses.dataclass — ce que les exemples SDK utilisent — afin que le runtime valide la charge utile entrante et exporte un schéma JSON propre, y compris pour les champs facultatifs, imbriqués et auto-référencés. Un pydentique BaseModel se comporte de la même manière; un stdlib @dataclass est également accepté et convient pour une entrée simple et plate, mais il n’effectue aucune validation et exporte des schémas moins complets pour les types complexes. Chaque surface d'invocation affiche ce schéma exporté pour lier les variables: une tâche de service Maestro, une tâche d'exécution d'Orchestrator ou une activité Exécuter la tâche de Studio. Le point d’entrée peut être un def de synchronisation ou un async def — les deux sont pris en charge.

from pydantic.dataclasses import dataclass


@dataclass
class Input:
    document_id: str = ""
    amount: float = 0.0


@dataclass
class Output:
    result_id: str = ""
    status: str = ""


def main(input: Input) -> Output:
    # business logic
    return Output(result_id="123", status="success")

Types pris en charge

• primitifs: str, int, float, bool
• Tableaux: list[str], list[dict]
• Classes de données ou modèles pythontiques imbriqués
• Champs nuls: Optional[X]

Donnez aux champs des valeurs par défaut afin que le schéma soit généré proprement et que la fonction soit facile à invoquer avec une entrée partielle.

Points d’entrée

Le fichier uipath.json indique les fonctions qui sont appelables:

{
  "functions": {
    "main": "main.py:main"
  }
}

Points d’entrée multiples

Un même projet peut exposer plusieurs fonctions. Lister chacun dans uipath.json:

{
  "functions": {
    "extract": "main.py:extract_data",
    "validate": "main.py:validate_data",
    "post_erp": "main.py:post_to_erp"
  }
}

Exécutez uipath init après avoir ajouté des points d’entrée pour régénérer les schémas d’entrée/de sortie.

Gestion des erreurs

Une fonction peut signaler une erreur métier de deux manières. Les deux sont pris en charge. Choisissez en fonction de la façon dont le processus d'appel gère les échecs:

• Renvoyez-le dans la sortie. Ajoutez des champs tels qu'un indicateur de statut ou une error_message à votre Output. La tâche se termine avec succès et l'appelant, par exemple un processus Maestro, se ramifie sur ces champs.
• Levez une exception. La tâche se déclenche avec une erreur de catégorie USERet votre message d'exception est conservé dans la défaillance, afin que l'appelant puisse la gérer en amont, par exemple avec un événement limite dans un processus Maestro.

Pour renvoyer une erreur dans la sortie, ajoutez les champs dont vous avez besoin et remplissez-les sur le chemin d'échec:

from pydantic.dataclasses import dataclass


@dataclass
class Output:
    result_id: str = ""
    status: str = ""
    error_type: str = ""
    error_message: str = ""


def main(input: Input) -> Output:
    try:
        result = process_data(input)
        return Output(result_id=result, status="success")
    except ValidationError as exc:
        return Output(status="error", error_type="VALIDATION_ERROR", error_message=str(exc))

Détectez uniquement les exceptions que vous pouvez décrire de manière significative. Permettre aux erreurs inattendues de se propager dans les défaillances de la tâche, ce qui les fait apparaître dans l’historique des tâches d’Orchestrator avec le message d’origine intact.

Prochaines étapes

• Accéder aux services de la plateforme — lisez les ressources et les fichiers au moment du runtime.
• Traçage et observabilité — rendre les étapes d’exécution visibles dans les traces.