rebase.Workflow

Signature

class rebase.Workflow(
    fn: Callable | None = None,
    *,
    name: str | None = None,
    project: str | None = None,
    description: str | None = None,
    schedule: rebase.Cron | dict | None = None,
    trigger: rebase.OnWorkflow | rebase.OnUpdate | dict | None = None,
    default_parameters: dict[str, Any] | None = None,
    mode: str | None = None,
    isolation: str | None = None,
    run_type: str | None = None,
    enabled: bool = True,
    endpoint: rebase.EndpointConfig | dict | None = None,
    deploy_source: str | None = None,
    dependencies: list[str] | tuple[str, ...] | None = None,
    image: rebase.Image | dict | None = None,
    env: dict[str, str] | None = None,
    secrets: dict[str, str] | list[rebase.Secret | str] | None = None,
    buckets: list[rebase.Bucket | str] | list[dict] | None = None,
    min_instances: int | None = None,
    concurrency: int | None = None,
    cpu: float | int | str | None = None,
    memory: int | float | str | None = None,
    timeout_seconds: int | None = None,
    resources: dict[str, Any] | None = None,
    client: rebase.Client | None = None,
)

Most code should create workflows with @rebase.workflow(...) or @project.workflow(...). Use the class constructor when you need an explicit handle.

Helper

rebase.workflow(
    fn: Callable | None = None,
    *,
    project: str | None = None,
    name: str | None = None,
    description: str | None = None,
    schedule: rebase.Cron | dict | None = None,
    trigger: rebase.OnWorkflow | rebase.OnUpdate | dict | None = None,
    default_parameters: dict[str, Any] | None = None,
    mode: str | None = None,
    isolation: str | None = None,
    run_type: str | None = None,
    enabled: bool = True,
    endpoint: rebase.EndpointConfig | dict | None = None,
    deploy_source: str | None = None,
    dependencies: list[str] | tuple[str, ...] | None = None,
    image: rebase.Image | dict | None = None,
    buckets: list[rebase.Bucket | str] | None = None,
    min_instances: int | None = None,
    concurrency: int | None = None,
    cpu: float | int | str | None = None,
    memory: int | float | str | None = None,
    timeout_seconds: int | None = None,
    resources: dict[str, Any] | None = None,
) -> Callable[[Callable], rebase.Workflow] | rebase.Workflow

The module-level @rebase.workflow(...) decorator does not accept env= or secrets=. To give a workflow environment variables or secret bundles, declare it with @project.workflow(...) or construct rebase.Workflow(...) directly — both accept the two parameters below.

Parameters

Parameter	Type	Description
`fn`	`Callable	None`
`name`	`str	None`
`project`	`str	None`
`description`	`str	None`
`schedule`	`rebase.Cron	dict
`trigger`	`rebase.OnWorkflow \| rebase.OnUpdate \| dict \| None`	Optional event trigger (see Triggers).
`default_parameters`	`dict	None`
`mode`	`str	None`
`isolation`	`str	None`
`run_type`	`str	None`
`enabled`	`bool`	Whether the workflow can be run.
`endpoint`	`rebase.EndpointConfig	dict
`deploy_source`	`str	None`
`dependencies`	`list[str]	None`
`image`	`rebase.Image	dict
`env`	`dict[str, str]	None`
`secrets`	`dict[str, str]	list[rebase.Secret
`buckets`	`list[rebase.Bucket \| str] \| None`	Buckets to attach (see rebase.Bucket). Each injects `REBASE_BUCKET_<NAME>` into runs.
`min_instances`	`int	None`
`concurrency`	`int	None`
`cpu`	`float \| int \| str \| None`	vCPU for the workflow's own container, as cores (`2`) or a Cloud Run string (`"2000m"`). Requires `mode="job"`. Bounded by the workspace's `max_cloud_run_cpu_milli`.
`memory`	`int \| float \| str \| None`	Memory for the workflow's own container, as MiB (`2048`) or a Cloud Run string (`"2Gi"`). Requires `mode="job"`. Bounded by the workspace's `max_cloud_run_memory_mib`.
`timeout_seconds`	`int \| None`	Hard bound for a whole run. Omitted, the platform derives it from the steps: the sum of every step's `timeout_seconds × (retries + 1)` plus a startup margin. If any step declares no timeout the run falls back to the platform default and `deploy()` warns which step is why. A step longer than the workflow is refused at deploy. Bounded by the workspace's `max_job_timeout_seconds` for `mode="job"` and by `max_run_timeout_seconds` (at most 3600) for interactive workflows.
`resources`	`dict \| None`	Per-step resource annotations recorded on the step graph. This does not size the workflow's own container — use `cpu`/`memory` for that.

Constructors

rebase.Workflow.from_name(project: str, name: str, *, client: rebase.Client | None = None) -> rebase.Workflow

Methods

workflow.deploy(*, replace: bool = False, deploy_source: str | None = None,
                environment: str | None = None) -> rebase.Workflow
workflow.spawn(**parameters) -> rebase.Run
workflow.remote(**parameters) -> Any
workflow.run(**parameters) -> rebase.Run
workflow.ephemeral_run(**parameters) -> rebase.Run

Method	Description
`from_name(project, name)`	Resolve a deployed workflow handle.
`deploy()`	Register or update the immutable workflow version.
`spawn(**parameters)`	Start a run and return immediately.
`remote(**parameters)`	Start a run and wait for the result.
`run(**parameters)`	Alias for `spawn(**parameters)`.
`ephemeral_run(**parameters)`	Run local source without deploying it persistently.