Entradas do script

Da assinatura ao formulário

Enquanto você digita, o editor lê a assinatura de main e redesenha o cartão Entradas à esquerda do código. O Python é lido no servidor com o próprio parser do Python — o código é analisado, nunca executado — então Literal, Optional, Annotated, enums e docstrings são entendidos exatamente como o Python os entende. As assinaturas de TypeScript e JavaScript são lidas no navegador; C e C++ declaram as entradas com linhas // @param.

["vip", "newsletter"]

1from typing import Literal2 3def main(4    name: str,5    times: int = 1,6    shout: bool = False,7    tone: Literal["warm", "formal"] = "warm",8    tags: list[str] = [],9):10    word = "Hello" if tone == "warm" else "Good day"11    text = f"{word}, {name}!"12    if shout:13        text = text.upper()14    return {"greetings": [text] * times, "tags": tags}

Cada campo mostra um pequeno chip com o tipo (string, integer, boolean, enum, date, list, json…) e a palavra obrigatório ou opcional. Embaixo do cartão, uma linha diz Pronto para executar · 3 entradas, ou Preencha customer para executar enquanto um campo obrigatório está vazio — o Rodar fica desativado até ele ser preenchido. Um script sem parâmetros não tem cartão nenhum.

Declare entradas tipadas

Um script, seis tipos de entrada. Cole num script novo e veja o cartão: um campo de texto obrigatório, um número, um toggle, um seletor com três opções, uma data opcional e um editor de lista.

from datetime import date
from typing import Annotated, Literal


def main(
    customer: Annotated[str, "Who placed the order"],
    quantity: int = 1,
    express: bool = False,
    region: Literal["br", "us", "eu"] = "br",
    ship_on: date | None = None,
    tags: list[str] = [],
):
    return {
        "customer": customer,
        "quantity": quantity,
        "express": express,
        "region": region,
        "shipOn": ship_on,
        "tags": tags,
    }

{
  "customer": "Ana Souza",
  "quantity": 2,
  "express": true,
  "region": "br",
  "shipOn": "2026-11-03",
  "tags": [
    "gift"
  ]
}

Obrigatório, opcional e nulo

• Um parâmetro com padrão é opcional; o campo já começa com esse padrão.
• Um parâmetro sem padrão é obrigatório — a menos que o tipo aceite nada: X | None, Optional[X] ou padrão None em Python, T | null ou T | undefined em TypeScript, ou um ? no nome.
• Um campo opcional deixado vazio envia o padrão do código; um que aceita nulo sem padrão envia null (None em Python).
• Em Python, um padrão que é uma constante do módulo é resolvido; um padrão que é uma chamada (datetime.now()) ainda torna a entrada opcional, mas o campo começa vazio.

Descrições (Python)

Uma entrada Python pode ter uma descrição, mostrada abaixo do campo. Escreva na docstring de main — os estilos Google (Args:), Sphinx (:param name:) e NumPy são lidos — ou como Annotated[str, "texto"]. Quando os dois existem, vale a docstring. Comentários nunca são lidos, e as outras linguagens não têm descrições.

def main(amount: float, currency: str = "BRL"):
    """Format an invoice line.

    Args:
        amount: Total in the currency's main unit, e.g. 129.90
        currency: Three-letter ISO code
    """
    return f"{currency} {amount:.2f}"

Qual campo cada tipo vira

Sem tipo, o padrão decide: = 3 é um número inteiro, = true um toggle, = [] uma lista. É assim que as entradas JavaScript são tipadas. O editor de lista tipa cada linha pelo tipo do item — linhas de list[int] são números, de list[bool] são toggles — e tem Adicionar item, Mover para cima, Mover para baixo e Remover item; uma lista vazia diz o que envia (Lista vazia — envia []).

Visual ou JSON

O seletor Visual / JSON no topo do cartão muda como você preenche, não o que é enviado. JSON mostra todas as entradas como um único objeto — prático para colar um payload que veio de uma API ou para copiar o que uma execução usou. Voltar para Visual lê o objeto para os campos; se ele não for válido aparece O JSON não é válido: … ou esperado um objeto JSON.

{
  "customer": "Ana Souza",
  "quantity": 2,
  "express": true,
  "region": "br",
  "ship_on": null,
  "tags": [
    "gift"
  ]
}

Para reutilizar as entradas de uma execução anterior, abra-a em Histórico e escolha Restaurar entradas: os valores que ainda batem com os parâmetros atuais são copiados para o cartão.

Como os valores são conferidos

Toda forma de iniciar uma execução — Rodar no editor, uma chamada de API, um agendamento, um passo de flow, um cliente MCP — passa pela mesma conferência contra as entradas declaradas antes de qualquer coisa entrar na fila. A conferência é tolerante onde dá: texto numérico vale para um número, "true" / "False" para um toggle, "None" ou um texto vazio para uma entrada que aceita nulo, 5.0 para um inteiro. Datas precisam ser YYYY-MM-DD; data e hora aceita T ou espaço e um fuso opcional. Um valor opcional ausente deixa valer o padrão do código.

Quando um valor não pode ser usado, a execução é recusada com HTTP 422 e o código invalid_parameter — e nada é enviado a um worker. No editor o campo fica vermelho com Espera integer · recebeu "2.5", e a aba de saída mostra Entrada inválida com Mostrar o campo. Editar o campo limpa a marca. Em Python, chaves que não são nome de parâmetro são descartadas (a menos que main receba **kwargs), e uma entrada obrigatória ausente é recusada como received nothing.

{
  "error": "Parameter \"quantity\" expects integer, received 2.5",
  "code": "invalid_parameter",
  "parameter": "quantity",
  "expected": "integer",
  "received": "2.5"
}

Limites

• Código Python de até 512 KB é lido para as entradas; a leitura leva no máximo um segundo. Se não der para ler, um leitor interno mais simples assume — uma execução nunca é recusada por isso.
• *args e **kwargs nunca viram campos.
• Se um arquivo tem vários def main no nível de cima, vale o último.
• Entradas de C e C++ só existem pelas linhas // @param; sem linha, sem campo.