rboto-sfn

rboto is an independent project maintained by Ferrumio. It is not affiliated with, sponsored by, or endorsed by Amazon Web Services (AWS).

Preview (Alpha). rboto is under active development. APIs may change between releases.

rboto provides an async-only, typed Python client for AWS Step Functions, powered by Rust. This package contains StepFunctionsClient and 37 operations.

Installation

Requires Python 3.12 or newer and a native wheel for your Python version and platform.

python -m pip install "rboto[sfn]"

You can also install rboto-sfn directly; it installs the matching rboto package. Only the selected service is installed.

These are the package names to use when a release is available on your package index. If your index has no release yet, follow the source installation instructions.

Usage

Configure credentials through your environment, shared profile, or workload role. The example uses us-east-1; select a region where your service and resources are available. Resource names, identifiers, input files, and model IDs in the example are placeholders to replace with your own.

import asyncio

from rboto import StepFunctionsClient


async def main() -> None:
    client = StepFunctionsClient(region="us-east-1")
    response = await client.start_execution(
        state_machine_arn="arn:aws:states:us-east-1:123456789012:stateMachine:example",
        input='{"order_id":"123"}',
    )
    print(response.execution_arn)


if __name__ == "__main__":
    asyncio.run(main())

In an application with an event loop, call await main() instead of asyncio.run(main()). Reuse the client across calls. Constructing a client does not send a request.

API conventions

• Import the client with from rboto import StepFunctionsClient.

• Every operation is asynchronous: use await client.method(...).

• Operation arguments are keyword-only and use the Python names listed below.

• Structured inputs use typed dictionaries and tagged unions from rboto_sfn.types.

• Regular responses expose typed attributes; response.to_dict() converts them to a dictionary.

• Event-stream responses may be typed dictionaries containing async iterators. Follow the declared return type; consume event streams with async for.

• Byte streams are consumed asynchronously. await stream.read() buffers the complete body; iterate the stream when processing a large response.

• Direct operation calls return one page.

• Use async for page in client.paginators.method(...) for supported paginated operations. Paginators accept the same typed arguments as the corresponding client method.

• Catch modeled exceptions from rboto_sfn.exceptions. Their error_code, message, and operation_name identify service failures.

Clients also accept profile, endpoint_url, or shared Session settings. See configuration, errors, and streaming.

Operations

This is the complete operation catalog for this generated package. “Required arguments” lists arguments without defaults in the Python signature. Service-side conditions may require additional arguments. Each method links to its complete signature, including optional arguments. Nested input definitions are in rboto_sfn.types; native response definitions are in the package's _native.pyi.

Method	Required arguments	Return type
create_activity	name: str	CreateActivityOutput
create_state_machine	name: str, definition: str, role_arn: str	CreateStateMachineOutput
create_state_machine_alias	name: str, routing_configuration: Sequence[RoutingConfigurationListItem]	CreateStateMachineAliasOutput
delete_activity	activity_arn: str	DeleteActivityOutput
delete_state_machine	state_machine_arn: str	DeleteStateMachineOutput
delete_state_machine_alias	state_machine_alias_arn: str	DeleteStateMachineAliasOutput
delete_state_machine_version	state_machine_version_arn: str	DeleteStateMachineVersionOutput
describe_activity	activity_arn: str	DescribeActivityOutput
describe_execution	execution_arn: str	DescribeExecutionOutput
describe_map_run	map_run_arn: str	DescribeMapRunOutput
describe_state_machine	state_machine_arn: str	DescribeStateMachineOutput
describe_state_machine_alias	state_machine_alias_arn: str	DescribeStateMachineAliasOutput
describe_state_machine_for_execution	execution_arn: str	DescribeStateMachineForExecutionOutput
get_activity_task	activity_arn: str	GetActivityTaskOutput
get_execution_history	execution_arn: str	GetExecutionHistoryOutput
list_activities	None	ListActivitiesOutput
list_executions	None	ListExecutionsOutput
list_map_runs	execution_arn: str	ListMapRunsOutput
list_state_machine_aliases	state_machine_arn: str	ListStateMachineAliasesOutput
list_state_machine_versions	state_machine_arn: str	ListStateMachineVersionsOutput
list_state_machines	None	ListStateMachinesOutput
list_tags_for_resource	resource_arn: str	ListTagsForResourceOutput
publish_state_machine_version	state_machine_arn: str	PublishStateMachineVersionOutput
redrive_execution	execution_arn: str	RedriveExecutionOutput
send_task_failure	task_token: str	SendTaskFailureOutput
send_task_heartbeat	task_token: str	SendTaskHeartbeatOutput
send_task_success	task_token: str, output: str	SendTaskSuccessOutput
start_execution	state_machine_arn: str	StartExecutionOutput
start_sync_execution	state_machine_arn: str	StartSyncExecutionOutput
stop_execution	execution_arn: str	StopExecutionOutput
tag_resource	resource_arn: str, tags: Sequence[Tag]	TagResourceOutput
test_state	definition: str	TestStateOutput
untag_resource	resource_arn: str, tag_keys: Sequence[str]	UntagResourceOutput
update_map_run	map_run_arn: str	UpdateMapRunOutput
update_state_machine	state_machine_arn: str	UpdateStateMachineOutput
update_state_machine_alias	state_machine_alias_arn: str	UpdateStateMachineAliasOutput
validate_state_machine_definition	definition: str	ValidateStateMachineDefinitionOutput

Complete signatures

create_activity

async def create_activity(
    *,
    name: str,
    tags: Sequence[Tag] | None = None,
    encryption_configuration: EncryptionConfiguration | None = None,
) -> CreateActivityOutput: ...

create_state_machine

async def create_state_machine(
    *,
    name: str,
    definition: str,
    role_arn: str,
    type: StateMachineType | None = None,
    logging_configuration: LoggingConfiguration | None = None,
    tags: Sequence[Tag] | None = None,
    tracing_configuration: TracingConfiguration | None = None,
    publish: bool | None = None,
    version_description: str | None = None,
    encryption_configuration: EncryptionConfiguration | None = None,
) -> CreateStateMachineOutput: ...

create_state_machine_alias

async def create_state_machine_alias(
    *,
    name: str,
    routing_configuration: Sequence[RoutingConfigurationListItem],
    description: str | None = None,
) -> CreateStateMachineAliasOutput: ...

delete_activity

async def delete_activity(
    *,
    activity_arn: str,
) -> DeleteActivityOutput: ...

delete_state_machine

async def delete_state_machine(
    *,
    state_machine_arn: str,
) -> DeleteStateMachineOutput: ...

delete_state_machine_alias

async def delete_state_machine_alias(
    *,
    state_machine_alias_arn: str,
) -> DeleteStateMachineAliasOutput: ...

delete_state_machine_version

async def delete_state_machine_version(
    *,
    state_machine_version_arn: str,
) -> DeleteStateMachineVersionOutput: ...

describe_activity

async def describe_activity(
    *,
    activity_arn: str,
) -> DescribeActivityOutput: ...

describe_execution

async def describe_execution(
    *,
    execution_arn: str,
    included_data: IncludedData | None = None,
) -> DescribeExecutionOutput: ...

describe_map_run

async def describe_map_run(
    *,
    map_run_arn: str,
) -> DescribeMapRunOutput: ...

describe_state_machine

async def describe_state_machine(
    *,
    state_machine_arn: str,
    included_data: IncludedData | None = None,
) -> DescribeStateMachineOutput: ...

describe_state_machine_alias

async def describe_state_machine_alias(
    *,
    state_machine_alias_arn: str,
) -> DescribeStateMachineAliasOutput: ...

describe_state_machine_for_execution

async def describe_state_machine_for_execution(
    *,
    execution_arn: str,
    included_data: IncludedData | None = None,
) -> DescribeStateMachineForExecutionOutput: ...

get_activity_task

async def get_activity_task(
    *,
    activity_arn: str,
    worker_name: str | None = None,
) -> GetActivityTaskOutput: ...

get_execution_history

async def get_execution_history(
    *,
    execution_arn: str,
    max_results: int | None = None,
    reverse_order: bool | None = None,
    next_token: str | None = None,
    include_execution_data: bool | None = None,
) -> GetExecutionHistoryOutput: ...

Also available as client.paginators.get_execution_history(...), returning an async iterator of the response type above.

list_activities

async def list_activities(
    *,
    max_results: int | None = None,
    next_token: str | None = None,
) -> ListActivitiesOutput: ...

Also available as client.paginators.list_activities(...), returning an async iterator of the response type above.

list_executions

async def list_executions(
    *,
    state_machine_arn: str | None = None,
    status_filter: ExecutionStatus | None = None,
    max_results: int | None = None,
    next_token: str | None = None,
    map_run_arn: str | None = None,
    redrive_filter: ExecutionRedriveFilter | None = None,
) -> ListExecutionsOutput: ...

Also available as client.paginators.list_executions(...), returning an async iterator of the response type above.

list_map_runs

async def list_map_runs(
    *,
    execution_arn: str,
    max_results: int | None = None,
    next_token: str | None = None,
) -> ListMapRunsOutput: ...

Also available as client.paginators.list_map_runs(...), returning an async iterator of the response type above.

list_state_machine_aliases

async def list_state_machine_aliases(
    *,
    state_machine_arn: str,
    next_token: str | None = None,
    max_results: int | None = None,
) -> ListStateMachineAliasesOutput: ...

list_state_machine_versions

async def list_state_machine_versions(
    *,
    state_machine_arn: str,
    next_token: str | None = None,
    max_results: int | None = None,
) -> ListStateMachineVersionsOutput: ...

list_state_machines

async def list_state_machines(
    *,
    max_results: int | None = None,
    next_token: str | None = None,
) -> ListStateMachinesOutput: ...

Also available as client.paginators.list_state_machines(...), returning an async iterator of the response type above.

list_tags_for_resource

async def list_tags_for_resource(
    *,
    resource_arn: str,
) -> ListTagsForResourceOutput: ...

publish_state_machine_version

async def publish_state_machine_version(
    *,
    state_machine_arn: str,
    revision_id: str | None = None,
    description: str | None = None,
) -> PublishStateMachineVersionOutput: ...

redrive_execution

async def redrive_execution(
    *,
    execution_arn: str,
    client_token: str | None = None,
) -> RedriveExecutionOutput: ...

send_task_failure

async def send_task_failure(
    *,
    task_token: str,
    error: str | None = None,
    cause: str | None = None,
) -> SendTaskFailureOutput: ...

send_task_heartbeat

async def send_task_heartbeat(
    *,
    task_token: str,
) -> SendTaskHeartbeatOutput: ...

send_task_success

async def send_task_success(
    *,
    task_token: str,
    output: str,
) -> SendTaskSuccessOutput: ...

start_execution

async def start_execution(
    *,
    state_machine_arn: str,
    name: str | None = None,
    input: str | None = None,
    trace_header: str | None = None,
) -> StartExecutionOutput: ...

start_sync_execution

async def start_sync_execution(
    *,
    state_machine_arn: str,
    name: str | None = None,
    input: str | None = None,
    trace_header: str | None = None,
    included_data: IncludedData | None = None,
) -> StartSyncExecutionOutput: ...

stop_execution

async def stop_execution(
    *,
    execution_arn: str,
    error: str | None = None,
    cause: str | None = None,
) -> StopExecutionOutput: ...

tag_resource

async def tag_resource(
    *,
    resource_arn: str,
    tags: Sequence[Tag],
) -> TagResourceOutput: ...

test_state

async def test_state(
    *,
    definition: str,
    role_arn: str | None = None,
    input: str | None = None,
    inspection_level: InspectionLevel | None = None,
    reveal_secrets: bool | None = None,
    variables: str | None = None,
    state_name: str | None = None,
    mock: MockInput | None = None,
    context: str | None = None,
    state_configuration: TestStateConfiguration | None = None,
) -> TestStateOutput: ...

untag_resource

async def untag_resource(
    *,
    resource_arn: str,
    tag_keys: Sequence[str],
) -> UntagResourceOutput: ...

update_map_run

async def update_map_run(
    *,
    map_run_arn: str,
    max_concurrency: int | None = None,
    tolerated_failure_percentage: float | None = None,
    tolerated_failure_count: int | None = None,
) -> UpdateMapRunOutput: ...

update_state_machine

async def update_state_machine(
    *,
    state_machine_arn: str,
    definition: str | None = None,
    role_arn: str | None = None,
    logging_configuration: LoggingConfiguration | None = None,
    tracing_configuration: TracingConfiguration | None = None,
    publish: bool | None = None,
    version_description: str | None = None,
    encryption_configuration: EncryptionConfiguration | None = None,
) -> UpdateStateMachineOutput: ...

update_state_machine_alias

async def update_state_machine_alias(
    *,
    state_machine_alias_arn: str,
    description: str | None = None,
    routing_configuration: Sequence[RoutingConfigurationListItem] | None = None,
) -> UpdateStateMachineAliasOutput: ...

validate_state_machine_definition

async def validate_state_machine_definition(
    *,
    definition: str,
    type: StateMachineType | None = None,
    severity: ValidateStateMachineDefinitionSeverity | None = None,
    max_results: int | None = None,
) -> ValidateStateMachineDefinitionOutput: ...

Links

• Service guide
• Repository
• Issues
• Releases

Licensed under Apache-2.0.