Como criar funções do Python

Uma função do Python tem três partes: uma entrada digitada, uma saída digitada e uma função de ponto de entrada que mapeia uma para a outra. Esta página abrange cada um, além do tratamento de erros e expõe várias funções de um projeto.

Entrada e saída digitadas

Defina Input e Output como Python digitado. Use pydantic.dataclasses.dataclass — o que as amostras de SDK usam — para que o runtime valide a carga de entrada e exporte um Esquema JSON limpo, incluindo para campos opcionais, aninhados e autoreferenciados. Um pydastic BaseModel comporta-se da mesma maneira; um stdlib @dataclass também é aceito e é bom para entrada simples e fixa, mas não realiza validação e exporta esquemas menos completos para tipos complexos. Cada superfície de invocação renderiza esse esquema exportado para vincular variáveis — uma Tarefa de Serviço do Maestro, um Run Job do Orchestrator ou a atividade Run Job do Studio. O ponto de entrada pode ser uma sincronização def ou um async def — ambos são compatíveis.

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

Tipos compatíveis

• primitivos: str, int, float, bool
• Matrizes: list[str], list[dict]
• Dataclasses aninhadas ou modelos pydastic
• Campos nulos: Optional[X]

Dê aos campos valores padrão para que o esquema seja gerado corretamente e a função seja fácil de invocar com entrada parcial.

Pontos de Entrada

O arquivo uipath.json declara quais funções são chamáveis:

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

Vários pontos de entrada

Um único projeto pode expor várias funções. Liste cada um em uipath.json:

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

Execute uipath init após adicionar pontos de entrada para regenerar os esquemas de entrada/saída.

Tratamento de Erro

Uma função pode sinalizar um erro de negócios de duas maneiras. Ambos são compatíveis — escolha com base em como o processo de chamada lida com falhas:

• Retorne-o na saída. Adicione campos como um sinalizador de status ou um error_message ao seu Output. O trabalho é concluído com sucesso e o chamador — por exemplo, um processo do Maestro — ramifica-se nesses campos.
• Gera uma exceção. O trabalho falha com um erro de categoria USERe sua mensagem de exceção é preservada na falha, para que o chamador possa lidar com isso upstream — por exemplo, com um evento de limite em um processo do Maestro.

Para retornar um erro na saída, adicione os campos que você precisa e preencha-os no caminho de falha:

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

Capture apenas as exceções que você pode descrever de forma significativa. Deixe os erros inesperados se propagam para que as falhas de trabalho — isso os revela no histórico de trabalho do Orchestrator com a mensagem original intacta.

Próximas Etapas

• Acessar serviços de plataforma — leia ativos e arquivos no runtime.
• Rastreamento e observabilidade — torne as etapas de execução visíveis nos rastreamentos.