Temporal Python API

https://python.temporal.io
Admin
The Temporal Python API is an SDK for developing durable, scalable applications and workflows that...
Tokens:985,643
Snippets:6,460
Trust Score:10
Update:14 hours ago
Show doc for...
Tokens:
Raw
### Create Nexus client and start operation

Source: https://python.temporal.io/temporalio.workflow._nexus.NexusClient.html

Example from the class documentation showing how to create a Nexus client with workflow.create_nexus_client, start an operation with start_operation, and await the result. Uses MyService, MyOperationInput, and a schedule_to_close_timeout of 10 seconds.

```python
nexus_client = workflow.create_nexus_client(
    endpoint=my_nexus_endpoint,
    service=MyService,
)
handle = await nexus_client.start_operation(
    operation=MyService.my_operation,
    input=MyOperationInput(value="hello"),
    schedule_to_close_timeout=timedelta(seconds=10),
)
result = await handle.result()
```

--------------------------------

### start

Source: https://python.temporal.io/temporalio.nexus.TemporalOperationHandler.html

Start the Nexus operation using a Nexus-aware Temporal client.

```APIDOC
## start

### Description
Start the Nexus operation using a Nexus-aware Temporal client.

### Method
Async Method

### Signature
async def start(self, ctx: StartOperationContext, input: InputT)

### Parameters
- **ctx** (StartOperationContext) - Required - The start operation context.
- **input** (InputT) - Required - The input to the operation.
```

--------------------------------

### start_operation

Source: https://python.temporal.io/temporalio.nexus.TemporalOperationHandler.html

Start the Temporal-backed Nexus operation.

```APIDOC
## start_operation

### Description
Start the Temporal-backed Nexus operation.

### Method
Async Method

### Signature
async def start_operation(self, ctx: StartOperationContext, input: InputT)

### Parameters
- **ctx** (StartOperationContext) - Required - The start operation context.
- **input** (InputT) - Required - The input to the operation.
```

--------------------------------

### Client.get_activity_handle

Source: https://python.temporal.io/temporalio.client.Client.html

Gets a handle to an existing activity as the caller of that activity. The activity must not have been started by a workflow.

```APIDOC
## Client.get_activity_handle

### Description
Get a handle to an existing activity, as the caller of that activity. The activity must not have been started by a workflow. To get a handle to an activity execution that you control for manual completion and heartbeating, see `Client.get_async_activity_handle`.

### Method
N/A (SDK method)

### Endpoint
N/A (SDK method)

### Parameters
#### Parameters
- **activity_id** (str) - Required - The activity ID.
- **run_id** (str | None) - Optional - The activity run ID. If not provided, targets the latest run.
- **result_type** (type | None) - Optional - The result type to deserialize into.

### Request Example
No request example available.

### Response
#### Success Response
- **ActivityHandle[Any]** - A handle to the activity.

#### Response Example
No response example available.
```

--------------------------------

### Client.__init__(runtime, ref)

Source: https://python.temporal.io/temporalio.bridge.client.Client.html

Initialize the client with an underlying SDK Core reference.

```APIDOC
## Client.__init__(runtime, ref)

### Description
Initialize the client with an underlying SDK Core reference.

### Method
Constructor

### Signature
`def __init__(self, runtime: temporalio.bridge.runtime.Runtime, ref: temporalio.bridge.temporal_sdk_bridge.ClientRef)`

### Parameters
- **runtime** (temporalio.bridge.runtime.Runtime) - Required - The runtime.
- **ref** (temporalio.bridge.temporal_sdk_bridge.ClientRef) - Required - The underlying SDK Core reference.

```

--------------------------------

### start_local

Source: https://python.temporal.io/temporalio.testing._workflow._V1WorkflowEnvironment.html

Start a full Temporal server locally, downloading if necessary.

```APIDOC
## start_local

### Description
Start a full Temporal server locally, downloading if necessary.

### Method
Async Class Method

### Signature
`async start_local()`

### Returns
A WorkflowEnvironment instance.
```

--------------------------------

### Quick start: Install CloudRunIdPlugin and run a Temporal worker

Source: https://python.temporal.io/temporalio.contrib.gcp.cloud_run.id.html

Shows how to connect a Temporal client with the CloudRunIdPlugin installed, which propagates to workers automatically. The worker runs with a task queue and references MyWorkflow and my_activity, which are not defined in the snippet.

```python
import asyncio

from temporalio.client import Client
from temporalio.contrib.gcp.cloud_run.id import CloudRunIdPlugin
from temporalio.worker import Worker

async def main() -> None:
    # Install the plugin on the client; it propagates to workers automatically.
    client = await Client.connect(
        "localhost:7233",
        plugins=[CloudRunIdPlugin()],
    )

    worker = Worker(
        client,
        task_queue="my-task-queue",
        workflows=[MyWorkflow],
        activities=[my_activity],
    )
    await worker.run()

asyncio.run(main())
```

--------------------------------

### Runtime.__init__

Source: https://python.temporal.io/temporalio.bridge.runtime.Runtime.html

Creates an SDK Core runtime instance with the provided options.

```APIDOC
## Runtime.__init__

### Description
Creates an SDK Core runtime instance with the provided options.

### Method
Constructor

### Signature
`def __init__(self, *, options: RuntimeOptions)`

### Parameters
- **options** (RuntimeOptions) - Required - The runtime options for the SDK Core.

### Returns
None
```

--------------------------------

### get_activity_handle

Source: https://python.temporal.io/temporalio.client.Client.html

Gets a handle to an activity started by a client or workflow. Supports multiple ways to identify the activity: by workflow_id, run_id, and activity_id, or by task_token alone.

```APIDOC
## get_activity_handle

### Description
Gets a handle to an activity started by a client or workflow. To get a handle to an activity started by a workflow, supply workflow_id, run_id, and activity_id, or supply the activity task_token alone. To get a handle to an activity not started by a workflow, supply activity_id and run_id.

### Method
Client method

### Signature
```python
def get_activity_handle(self, workflow_id: str | None, run_id: str | None, activity_id: str | None, task_token: bytes | None) -> AsyncActivityHandle
```

### Parameters
- **workflow_id** (str | None) - Workflow ID for the activity, or None if not a workflow activity. Cannot be set if task_token is set.
- **run_id** (str | None) - Run ID for the activity or workflow. Cannot be set if task_token is set.
- **activity_id** (str | None) - ID for the activity. Cannot be set if task_token is set.
- **task_token** (bytes | None) - Task token for the activity. Cannot be set with other fields.

### Returns
- **AsyncActivityHandle** - A handle that can be used for completion or heartbeating.
```

--------------------------------

### get_current_details

Source: https://python.temporal.io/temporalio.workflow._context.html

Get the current details of the workflow which may appear in the UI/CLI. Unlike static details set at start, this value can be updated throughout the life of the workflow and is independent of the static details.

```APIDOC
## get_current_details

### Description
Get the current details of the workflow which may appear in the UI/CLI. Unlike static details set at start, this value can be updated throughout the life of the workflow and is independent of the static details.

### Function Signature
`get_current_details() -> str`

### Returns
- **str** - The current details of the workflow.

```

--------------------------------

### __init__(config)

Source: https://python.temporal.io/temporalio.client.ServiceClient.html

Initialize the base service client with the given configuration.

```APIDOC
## __init__(config)

### Description
Initialize the base service client.

### Method
Constructor

### Signature
`def __init__(self, config: ConnectConfig)`

### Parameters
- **config** (ConnectConfig) - Required - Configuration for the service client.
```

--------------------------------

### with_time_skipping_disabled

Source: https://python.temporal.io/temporalio.testing.TimeSkipper.html

Context manager that suspends time-skipping config stamping on newly-started workflows within the block. Workflows started via the client inside the block do not get their time_skipping_config set; existing workflows are unaffected.

```APIDOC
## with_time_skipping_disabled

### Description
Context manager that suspends time-skipping config stamping on newly-started workflows within the block. Workflows started via the client inside the block do not get their time_skipping_config set; existing workflows are unaffected.

### Method
@contextmanager
def with_time_skipping_disabled(self) -> Iterator[None]

### Returns
- **Iterator[None]** - A context manager that disables time-skipping config stamping for the duration of the block.
```

--------------------------------

### start_local

Source: https://python.temporal.io/temporalio.testing.WorkflowEnvironment.html

Creates a local test environment using the Temporal CLI dev server. This environment does not support time skipping and uses actual time. It downloads the CLI to a temporary directory by default unless dev_server_existing_path is set.

```APIDOC
## start_local

### Description
Creates a local test environment using the Temporal CLI dev server. This environment does not support time skipping and uses actual time. It downloads the CLI to a temporary directory by default unless dev_server_existing_path is set.

### Method
start_local

### Parameters
- **namespace** (str) - Namespace name to use for this environment.
- **data_converter** (temporalio.converter.DataConverter) - See parameter of the same name on temporalio.client.Client.connect.
- **interceptors** (Sequence[temporalio.client.Interceptor]) - See parameter of the same name on temporalio.client.Client.connect.
- **plugins** (Sequence[temporalio.client.Plugin]) - Undocumented.
- **default_workflow_query_reject_condition** (None | temporalio.common.QueryRejectCondition) - See parameter of the same name on temporalio.client.Client.connect.
- **retry_config** (temporalio.service.RetryConfig | None) - See parameter of the same name on temporalio.client.Client.connect.
- **rpc_metadata** (Mapping[str, str | bytes]) - See parameter of the same name on temporalio.client.Client.connect.
- **identity** (str | None) - See parameter of the same name on temporalio.client.Client.connect.
- **tls** (bool | temporalio.service.TLSConfig) - See parameter of the same name on temporalio.client.Client.connect.
- **ip** (str) - IP address to bind to, or 127.0.0.1 by default.
- **port** (int | None) - Port number to bind to, or an OS-provided port by default.

### Notes
- This environment does not support time skipping; supports_time_skipping_v1 and supports_time_skipping_v2 both return False.
- sleep will sleep the actual amount of time and get_current_time will return the current time.
- Internally uses the Temporal CLI dev server from https://github.com/temporalio/cli.
- The CLI is downloaded to a temporary directory by default if not already downloaded and dev_server_existing_path is not set.
- All dev_server_ prefixed parameters are dev-server specific and may not apply to newer versions.
```

--------------------------------

### Quick start: run_worker with configure callback

Source: https://python.temporal.io/temporalio.contrib.aws.lambda_worker.html

Shows the minimal setup for running a Temporal worker in AWS Lambda. The configure callback is invoked once per invocation and can be synchronous or asynchronous. It receives a LambdaWorkerConfig dataclass with Lambda-appropriate defaults; override fields directly in the callback.

```python
from temporalio.common import WorkerDeploymentVersion
from temporalio.contrib.aws.lambda_worker import LambdaWorkerConfig, run_worker

def configure(config: LambdaWorkerConfig) -> None:
    config.worker_config["task_queue"] = "my-task-queue"
    config.worker_config["workflows"] = [MyWorkflow]
    config.worker_config["activities"] = [my_activity]

lambda_handler = run_worker(
    WorkerDeploymentVersion(
        deployment_name="my-service",
        build_id="v1.0",
    ),
    configure,
)
```

--------------------------------

### ActivityHandle.__init__

Source: https://python.temporal.io/temporalio.client.ActivityHandle.html

Create an activity handle.

```APIDOC
## ActivityHandle.__init__

### Description
Create an activity handle.

### Method
Constructor

### Signature
`ActivityHandle(client, id, run_id, result_type)`

### Parameters
- **client** - The Temporal client.
- **id** - The activity ID.
- **run_id** - The run ID of the activity.
- **result_type** - The type of the activity result.

```

--------------------------------

### EphemeralServer.__init__(ref)

Source: https://python.temporal.io/temporalio.bridge.testing.EphemeralServer.html

Initializes an ephemeral server with a reference to a Rust ephemeral server.

```APIDOC
## __init__(ref)

### Description
Initializes an ephemeral server.

### Method
Constructor

### Signature
`def __init__(self, ref: temporalio.bridge.temporal_sdk_bridge.EphemeralServerRef)`

### Parameters
- **ref** (temporalio.bridge.temporal_sdk_bridge.EphemeralServerRef) - Required - Reference to the Rust ephemeral server.
```

--------------------------------

### ScheduleOverlapPolicy.BUFFER_ONE

Source: https://python.temporal.io/temporalio.client.ScheduleOverlapPolicy.html

Start the workflow again soon as the current one completes, but only buffer one start in this way. If another start is supposed to happen when the workflow is running, and one is already buffered, then only the first one will be started after the running workflow finishes.

```APIDOC
## ScheduleOverlapPolicy.BUFFER_ONE

### Description
Start the workflow again soon as the current one completes, but only buffer one start in this way. If another start is supposed to happen when the workflow is running, and one is already buffered, then only the first one will be started after the running workflow finishes.

### Value
```
int(temporalio.api.enums.v1.ScheduleOverlapPolicy.SCHEDULE_OVERLAP_POLICY_BUFFER_ONE)
```
```

--------------------------------

### WorkflowEnvironment.start_local(namespace, data_converter, interceptors, plugins, ...)

Source: https://python.temporal.io/temporalio.testing.WorkflowEnvironment.html

Starts a full Temporal server locally, downloading it if necessary. This is an async class method that sets up a local server for testing workflows.

```APIDOC
## WorkflowEnvironment.start_local(namespace, data_converter, interceptors, plugins, ...)

### Description
Starts a full Temporal server locally, downloading it if necessary. This is an async class method that provides a local, full-featured Temporal server for testing workflows.

### Method
Async Class Method

### Signature
`async start_local(namespace, data_converter, interceptors, plugins, ...)`

### Parameters
- **namespace** - The namespace to use for the local server.
- **data_converter** - Optional data converter for serialization.
- **interceptors** - Optional interceptors for client calls.
- **plugins** - Optional plugins for the environment.
- **...** - Additional parameters as supported by the implementation.

### Returns
A `WorkflowEnvironment` instance.

### Usage Example
```python
async with await WorkflowEnvironment.start_local() as env:
    # use env.client
```
```

--------------------------------

### signal_with_start_workflow

Source: https://python.temporal.io/temporalio.nexus.system.workflow_service.html

Starts a workflow and sends a signal to it in a single operation. This is useful for ensuring the signal is delivered before the workflow starts. Returns an ExternalWorkflowHandle for the started workflow.

```APIDOC
## signal_with_start_workflow

### Description
Starts a workflow and sends a signal to it in a single operation. This is useful for ensuring the signal is delivered before the workflow starts. Returns an ExternalWorkflowHandle for the started workflow.

### Method
Function call

### Signature
```python
async def signal_with_start_workflow(
    workflow: collections.abc.Callable[[SelfType, Unpack[WorkflowArgs]], Awaitable[WorkflowResult]],
    *args: Unpack[WorkflowArgs],
    id: str,
    task_queue: str,
    signal: str,
    signal_args: list[Any] | None = ...,
    execution_timeout: datetime.timedelta | None = ...,
    run_timeout: datetime.timedelta | None = ...,
    task_timeout: datetime.timedelta | None = ...,
    id_reuse_policy: temporalio.common.WorkflowIDReusePolicy = ...,
    id_conflict_policy: temporalio.common.WorkflowIDConflictPolicy | None = ...,
    retry_policy: temporalio.common.RetryPolicy | None = ...,
    cron_schedule: str | None = ...,
    memo: Mapping[str, Any] | None = ...,
    search_attributes: temporalio.common.TypedSearchAttributes | None = ...,
    priority: temporalio.common.Priority | None = ...,
    versioning_override: temporalio.common.VersioningOverride | None = ...,
    start_delay: datetime.timedelta | None = ...,
    static_summary: str | None = ...,
    static_details: str | None = ...
) -> ExternalWorkflowHandle[SelfType]
```

### Parameters
- **workflow** (collections.abc.Callable) - Required - The workflow function to start.
- **args** (Unpack[WorkflowArgs]) - Required - Arguments to pass to the workflow function.
- **id** (str) - Required - The workflow ID.
- **task_queue** (str) - Required - The task queue to use.
- **signal** (str) - Required - The name of the signal to send.
- **signal_args** (list[Any] | None) - Optional - Arguments to pass to the signal.
- **execution_timeout** (datetime.timedelta | None) - Optional - Timeout for the entire workflow execution.
- **run_timeout** (datetime.timedelta | None) - Optional - Timeout for a single workflow run.
- **task_timeout** (datetime.timedelta | None) - Optional - Timeout for a single workflow task.
- **id_reuse_policy** (temporalio.common.WorkflowIDReusePolicy) - Optional - Policy for reusing workflow IDs.
- **id_conflict_policy** (temporalio.common.WorkflowIDConflictPolicy | None) - Optional - Policy for handling workflow ID conflicts.
- **retry_policy** (temporalio.common.RetryPolicy | None) - Optional - Retry policy for the workflow.
- **cron_schedule** (str | None) - Optional - Cron schedule for the workflow.
- **memo** (Mapping[str, Any] | None) - Optional - Memo to attach to the workflow.
- **search_attributes** (temporalio.common.TypedSearchAttributes | None) - Optional - Search attributes for the workflow.
- **priority** (temporalio.common.Priority | None) - Optional - Priority for the workflow.
- **versioning_override** (temporalio.common.VersioningOverride | None) - Optional - Versioning override for the workflow.
- **start_delay** (datetime.timedelta | None) - Optional - Delay before starting the workflow.
- **static_summary** (str | None) - Optional - Static summary for the workflow.
- **static_details** (str | None) - Optional - Static details for the workflow.

### Returns
- **ExternalWorkflowHandle[SelfType]** - A handle to the started workflow.

```

--------------------------------

### start_workflow

Source: https://python.temporal.io/temporalio.nexus.system.workflow_service.html

Starts a workflow execution with configurable options including versioning overrides, start delay, and static metadata. Returns a workflow handle to the started workflow.

```APIDOC
## start_workflow

### Description
Starts a workflow execution with configurable options including versioning overrides, start delay, and static metadata. Returns a workflow handle to the started workflow.

### Parameters
#### Request Body
- **versioning_override** (`temporalio.common.VersioningOverride`) - Optional - Override for workflow versioning behavior.
- **start_delay** (`datetime.timedelta`) - Optional - Amount of time to wait before starting the workflow. This does not work with cron-schedule.
- **static_summary** (`str`) - Optional - Single-line fixed summary for the workflow execution that may appear in UI and CLI. This can be in single-line Temporal Markdown format.
- **static_details** (`str`) - Optional - General fixed details for the workflow execution that may appear in UI and CLI. This can be in Temporal Markdown format and can span multiple lines. This value is fixed on the workflow execution and cannot be updated.

### Response
#### Success Response
- **ExternalWorkflowHandle** (`ExternalWorkflowHandle[typing.Any]`) - A workflow handle to the started workflow.

```

--------------------------------

### WorkflowRunOperationHandler.start

Source: https://python.temporal.io/temporalio.nexus._operation_handlers.WorkflowRunOperationHandler.html

Starts the operation by starting a workflow and completing asynchronously.

```APIDOC
## WorkflowRunOperationHandler.start

### Description
Starts the operation by starting a workflow and completing asynchronously.

### Method
Async Method

### Signature
```python
async def start(self, ctx: StartOperationContext, input: InputT) -> StartOperationResultAsync
```

### Parameters
- **ctx** (StartOperationContext) - Required - The start operation context.
- **input** (InputT) - Required - The input to the operation.

### Returns
- **StartOperationResultAsync** - The asynchronous start operation result.
```

--------------------------------

### AsyncActivityHandle.__init__

Source: https://python.temporal.io/temporalio.client.AsyncActivityHandle.html

Create an async activity handle.

```APIDOC
## AsyncActivityHandle.__init__

### Description
Create an async activity handle.

### Method
Constructor

### Signature
```python
def __init__(self, client: Client, id_or_token: AsyncActivityIDReference | bytes, data_converter_override: DataConverter | None = None)
```

### Parameters
- **client** (Client) - Required - The Temporal client.
- **id_or_token** (AsyncActivityIDReference | bytes) - Required - The activity ID reference or token.
- **data_converter_override** (DataConverter | None) - Optional - Data converter override.

```

--------------------------------

### __init__

Source: https://python.temporal.io/temporalio.testing._workflow._HasAServer.html

Creates a workflow environment from a client. Most users would use a factory method instead.

```APIDOC
## __init__

### Description
Creates a workflow environment from a client. Most users would use a factory method instead.

### Method
def __init__(self, client: temporalio.client.Client, server: temporalio.bridge.testing.EphemeralServer)

### Parameters
- **client** (temporalio.client.Client) - Required - The client to use for this environment.
- **server** (temporalio.bridge.testing.EphemeralServer) - Required - The ephemeral server to use.

### Returns
None

### Example
```python
env = _HasAServer(client, server)
```
```

--------------------------------

### start_activity

Source: https://python.temporal.io/temporalio.client._ClientImpl.html

Start an activity and return a handle to it.

```APIDOC
## start_activity

### Description
Start an activity and return a handle to it.

### Method
Async Method

### Endpoint
`temporalio.client._ClientImpl.start_activity`
```

--------------------------------

### Workflow Start Options

Source: https://python.temporal.io/temporalio.nexus.system.workflow_service.html

Parameters for starting a workflow execution in the Temporal Python SDK.

```APIDOC
## Workflow Start Options

### Description
Options for starting a workflow execution in the Temporal Python SDK.

### Parameters

- **positional_args** (object) - Optional - Positional arguments for workflow. Cannot be set if args is set.
- **args** (list[typing.Any]) - Optional - List-form arguments for workflow. Cannot be set if positional_args are set. For typed workflow callables, list contents are not statically typechecked; pass workflow arguments positionally for precise typechecking.
- **id** (str) - Required - Unique identifier for the workflow execution. Must be nonempty.
- **task_queue** (str) - Required - Task queue to run the workflow on.
- **signal** (str | collections.abc.Callable[..., None] | collections.abc.Awaitable[None]) - Optional - Signal name or callable to send with the start request.
- **signal_args** (object | list[typing.Any] | None) - Optional - Argument value, or list of argument values, for signal. For typed single-argument signals, scalar signal_args values are statically typechecked. List-form signal_args values are not precisely typechecked. To pass a single signal argument that is itself a list, wrap it in another list; otherwise the list is interpreted as multiple signal arguments.
- **execution_timeout** (datetime.timedelta | None) - Optional - Total workflow execution timeout, including retries and continue-as-new. Defaults to unlimited.
- **run_timeout** (datetime.timedelta | None) - Optional - Timeout of a single workflow run. Defaults to the workflow execution timeout.
- **task_timeout** (datetime.timedelta | None) - Optional - Timeout of a single workflow task. Defaults to 10 seconds.
- **id_reuse_policy** (temporalio.common.WorkflowIDReusePolicy) - Optional - Behavior when a closed workflow with the same ID exists. Default is allow-duplicate.
- **id_conflict_policy** (temporalio.common.WorkflowIDConflictPolicy | None) - Optional - Behavior when a workflow is currently running with the same ID. Set to use-existing for idempotent deduplication on workflow ID. Cannot be set if id-reuse-policy is terminate-if-running. Defaults to use-existing.
- **retry_policy** (temporalio.common.RetryPolicy | None) - Optional - Retry policy for the workflow.
- **cron_schedule** (str | None) - Optional - Cron schedule for recurring workflow executions. See https://docs.temporal.io/cron-job.
- **memo** (collections.abc.Mapping[str, typing.Any] | None) - Optional - Memo for the workflow.
- **search_attributes** (temporalio.common.TypedSearchAttributes | None) - Optional - Typed search attributes for the workflow.
- **priority** (temporalio.common.Priority | None) - Optional - Priority of the workflow execution.
```

--------------------------------

### __init__(client=None)

Source: https://python.temporal.io/temporalio.testing.ActivityEnvironment.html

Constructor for ActivityEnvironment. Creates an ActivityEnvironment for running activity code.

```APIDOC
## __init__(client=None)

### Description
Create an ActivityEnvironment for running activity code.

### Method
Constructor

### Signature
`def __init__(self, client: Client | None = None)`

### Parameters
- `client` (Client | None) - Optional. The Temporal client to use.
```

--------------------------------

### start_operation

Source: https://python.temporal.io/temporalio.workflow._nexus.NexusClient.html

Starts a Nexus operation with the given operation handler and input. Returns a NexusOperationHandle for the started operation.

```APIDOC
## start_operation

### Description
Starts a Nexus operation with the given operation handler and input. Returns a NexusOperationHandle for the started operation.

### Method
async def start_operation(self, operation, input, *, output_type=None, schedule_to_close_timeout=None, schedule_to_start_timeout=None, start_to_close_timeout=None, cancellation_type=NexusOperationCancellationType.WAIT_COMPLETED, headers=None, summary=None, event_groups=None) -> NexusOperationHandle[OutputT]

### Parameters
- **operation** (Callable[[NexusServiceType], OperationHandler[InputT, OutputT]]) - Required - The operation handler to invoke.
- **input** (InputT) - Required - The input to pass to the operation.
- **output_type** (type[OutputT] | None) - Optional - The expected output type.
- **schedule_to_close_timeout** (timedelta | None) - Optional - Timeout for the entire operation.
- **schedule_to_start_timeout** (timedelta | None) - Optional - Timeout for the operation to start.
- **start_to_close_timeout** (timedelta | None) - Optional - Timeout for the operation to complete after starting.
- **cancellation_type** (NexusOperationCancellationType) - Optional - How to handle cancellation. Defaults to WAIT_COMPLETED.
- **headers** (Mapping[str, str] | None) - Optional - Additional headers for the operation.
- **summary** (str | None) - Optional - Summary of the operation.
- **event_groups** (Sequence[EventGroup] | None) - Optional - Event groups associated with the operation.

### Returns
- **NexusOperationHandle[OutputT]** - A handle to the started operation.

```

--------------------------------

### signal_with_start_workflow

Source: https://python.temporal.io/temporalio.nexus.system.workflow_service.html

Asynchronously starts a workflow and sends a signal to it in a single operation. Returns an ExternalWorkflowHandle for the started workflow.

```APIDOC
## signal_with_start_workflow

### Description
Asynchronously starts a workflow and sends a signal to it in a single operation. Returns an ExternalWorkflowHandle for the started workflow.

### Method
async def signal_with_start_workflow

### Signature
```python
async def signal_with_start_workflow(
    workflow: str,
    *,
    args: list[Any] | None = ...,
    id: str,
    task_queue: str,
    signal: Callable[[SelfType, SignalArg], None | Awaitable[None]],
    signal_args: SignalArg,
    execution_timeout: timedelta | None = ...,
    run_timeout: timedelta | None = ...,
    task_timeout: timedelta | None = ...,
    id_reuse_policy: WorkflowIDReusePolicy = ...,
    id_conflict_policy: WorkflowIDConflictPolicy | None = ...,
    retry_policy: RetryPolicy | None = ...,
    cron_schedule: str | None = ...,
    memo: Mapping[str, Any] | None = ...,
    search_attributes: TypedSearchAttributes | None = ...,
    priority: Priority | None = ...,
    versioning_override: VersioningOverride | None = ...,
    start_delay: timedelta | None = ...,
    static_summary: str | None = ...,
    static_details: str | None = ...
) -> ExternalWorkflowHandle[SelfType]
```

### Parameters
#### Positional Parameters
- **workflow** (str) - Required - The workflow type name or function to start.

#### Keyword-Only Parameters
- **args** (list[Any] | None) - Optional - Arguments to pass to the workflow.
- **id** (str) - Required - The workflow ID.
- **task_queue** (str) - Required - The task queue to use for the workflow.
- **signal** (Callable[[SelfType, SignalArg], None | Awaitable[None]]) - Required - The signal method to call on the workflow.
- **signal_args** (SignalArg) - Required - Arguments to pass to the signal.
- **execution_timeout** (timedelta | None) - Optional - Total workflow execution timeout.
- **run_timeout** (timedelta | None) - Optional - Timeout for a single workflow run.
- **task_timeout** (timedelta | None) - Optional - Timeout for a single workflow task.
- **id_reuse_policy** (WorkflowIDReusePolicy) - Optional - Policy for reusing workflow IDs.
- **id_conflict_policy** (WorkflowIDConflictPolicy | None) - Optional - Policy for handling workflow ID conflicts.
- **retry_policy** (RetryPolicy | None) - Optional - Retry policy for the workflow.
- **cron_schedule** (str | None) - Optional - Cron schedule for the workflow.
- **memo** (Mapping[str, Any] | None) - Optional - Memo to attach to the workflow.
- **search_attributes** (TypedSearchAttributes | None) - Optional - Search attributes for the workflow.
- **priority** (Priority | None) - Optional - Priority for the workflow.
- **versioning_override** (VersioningOverride | None) - Optional - Versioning override for the workflow.
- **start_delay** (timedelta | None) - Optional - Delay before starting the workflow.
- **static_summary** (str | None) - Optional - Static summary for the workflow.
- **static_details** (str | None) - Optional - Static details for the workflow.

### Returns
- **ExternalWorkflowHandle[SelfType]** - A handle to the started workflow.

```

--------------------------------

### __init__

Source: https://python.temporal.io/temporalio.workflow._NexusClient.html

Create a Nexus client with the specified endpoint and service.

```APIDOC
## __init__

### Description
Create a Nexus client.

### Method
Constructor

### Signature
```python
def __init__(self, *, endpoint: str, service: type[NexusServiceType] | str)
```

### Parameters
- **endpoint** (str) - Required - The Nexus endpoint.
- **service** (type[NexusServiceType] | str) - Required - The Nexus service.
```

--------------------------------

### WorkflowRunOperationHandler.__init__

Source: https://python.temporal.io/temporalio.nexus._operation_handlers.WorkflowRunOperationHandler.html

Initializes the workflow run operation handler with a start callable that must use WorkflowRunOperationContext.start_workflow to start the workflow.

```APIDOC
## WorkflowRunOperationHandler.__init__

### Description
Initializes the workflow run operation handler with a start callable that must use WorkflowRunOperationContext.start_workflow to start the workflow.

### Method
Constructor

### Signature
```python
def __init__(self, start: Callable[[StartOperationContext, InputT], Awaitable[WorkflowHandle[OutputT]]])
```

### Parameters
- **start** (Callable[[StartOperationContext, InputT], Awaitable[WorkflowHandle[OutputT]]]) - Required - The start method that starts the workflow.
```

--------------------------------

### start_activity

Source: https://python.temporal.io/temporalio.client.Client.html

Asynchronously starts an activity execution with the given callable and options, returning an ActivityHandle for the activity.

```APIDOC
## start_activity

### Description
Starts an activity execution asynchronously. The activity is identified by a callable and scheduled on the specified task queue with configurable timeouts and policies.

### Method
async def start_activity

### Signature
```python
async def start_activity(
    self,
    activity: CallableSyncNoParam[ReturnType],
    *,
    id: str,
    task_queue: str,
    schedule_to_close_timeout: timedelta | None = None,
    schedule_to_start_timeout: timedelta | None = None,
    start_to_close_timeout: timedelta | None = None,
    heartbeat_timeout: timedelta | None = None,
    id_reuse_policy: temporalio.common.ActivityIDReusePolicy = temporalio.common.ActivityIDReusePolicy.ALLOW_DUPLICATE,
    id_conflict_policy: temporalio.common.ActivityIDConflictPolicy = temporalio.common.ActivityIDConflictPolicy.FAIL,
    retry_policy: temporalio.common.RetryPolicy | None = None,
    search_attributes: temporalio.common.TypedSearchAttributes | None = None,
    summary: str | None = None,
    priority: temporalio.common.Priority = temporalio.common.Priority.default,
    start_delay: timedelta | None = None,
    rpc_metadata: Mapping[str, str | bytes] = {},
    rpc_timeout: timedelta | None = None
) -> ActivityHandle[ReturnType]
```

### Parameters
#### Positional Parameters
- **activity** (CallableSyncNoParam[ReturnType]) - Required - The activity function to execute.

#### Keyword-Only Parameters
- **id** (str) - Required - The unique identifier for the activity execution.
- **task_queue** (str) - Required - The task queue on which the activity will be scheduled.
- **schedule_to_close_timeout** (timedelta | None) - Optional - Timeout from schedule to completion.
- **schedule_to_start_timeout** (timedelta | None) - Optional - Timeout from schedule to start.
- **start_to_close_timeout** (timedelta | None) - Optional - Timeout from start to completion.
- **heartbeat_timeout** (timedelta | None) - Optional - Timeout between heartbeats.
- **id_reuse_policy** (temporalio.common.ActivityIDReusePolicy) - Optional - Policy for reusing activity IDs. Default: ALLOW_DUPLICATE.
- **id_conflict_policy** (temporalio.common.ActivityIDConflictPolicy) - Optional - Policy for handling ID conflicts. Default: FAIL.
- **retry_policy** (temporalio.common.RetryPolicy | None) - Optional - Retry policy for the activity.
- **search_attributes** (temporalio.common.TypedSearchAttributes | None) - Optional - Search attributes to attach to the activity.
- **summary** (str | None) - Optional - Summary of the activity.
- **priority** (temporalio.common.Priority) - Optional - Priority of the activity. Default: default.
- **start_delay** (timedelta | None) - Optional - Delay before the activity starts.
- **rpc_metadata** (Mapping[str, str | bytes]) - Optional - Metadata for the RPC call. Default: {}.
- **rpc_timeout** (timedelta | None) - Optional - Timeout for the RPC call.

### Returns
- **ActivityHandle[ReturnType]** - A handle to the started activity, allowing further interaction.

### Notes
This is an overloaded method; the provided signature is one variant.
```

--------------------------------

### _HasAServer._bootstrap_dev_server

Source: https://python.temporal.io/temporalio.testing._workflow._V2WorkflowEnvironment.html

Start a CLI dev server and connect a client. Shared by non-ts and V2.

```APIDOC
## _HasAServer._bootstrap_dev_server

### Description
Start a CLI dev server and connect a client. Shared by non-ts and V2.

### Method
Async Class Method

### Signature
```python
@classmethod
async def _bootstrap_dev_server(...)
```

### Parameters
No parameters documented.

### Returns
A tuple of client and server.
```

--------------------------------

### Client.start_workflow

Source: https://python.temporal.io/temporalio.client.Client.html

Starts a workflow execution with the given workflow type, arguments, and options. Returns a WorkflowHandle for the started workflow.

```APIDOC
## Client.start_workflow

### Description
Starts a workflow execution with the given workflow type, arguments, and options. Returns a WorkflowHandle for the started workflow.

### Method
async def start_workflow

### Signature
```python
async def start_workflow(self, workflow: str, arg: Any = temporalio.common._arg_unset, *, args: Sequence[Any] = [], id: str, task_queue: str, result_type: type | None = None, execution_timeout: timedelta | None = None, run_timeout: timedelta | None = None, task_timeout: timedelta | None = None, id_reuse_policy: temporalio.common.WorkflowIDReusePolicy = temporalio.common.WorkflowIDReusePolicy.ALLOW_DUPLICATE, id_conflict_policy: temporalio.common.WorkflowIDConflictPolicy = temporalio.common.WorkflowIDConflictPolicy.UNSPECIFIED, retry_policy: temporalio.common.RetryPolicy | None = None, cron_schedule: str = '', memo: Mapping[str, Any] | None = None, search_attributes: None | temporalio.common.TypedSearchAttributes | temporalio.common.SearchAttributes = None, static_summary: str | None = None, static_details: str | None = None, start_delay: timedelta | None = None, start_signal: str | None = None, start_signal_args: Sequence[Any] = [], rpc_metadata: Mapping[str, str | bytes] = {}, rpc_timeout: timedelta | None = None, request_eager_start: bool = False, priority: temporalio.common.Priority = temporalio.common.Priority.default, versioning_override: temporalio.common.VersioningOverride | None = None) -> WorkflowHandle[Any, Any]
```

### Parameters
#### Positional Parameters
- **workflow** (str) - Required - The workflow type name.
- **arg** (Any) - Optional - The single argument to pass to the workflow. Defaults to temporalio.common._arg_unset.

#### Keyword-Only Parameters
- **args** (Sequence[Any]) - Optional - A sequence of arguments to pass to the workflow. Defaults to [].
- **id** (str) - Required - The workflow ID.
- **task_queue** (str) - Required - The task queue to run the workflow on.
- **result_type** (type | None) - Optional - The type of the workflow result. Defaults to None.
- **execution_timeout** (timedelta | None) - Optional - The execution timeout for the workflow. Defaults to None.
- **run_timeout** (timedelta | None) - Optional - The run timeout for the workflow. Defaults to None.
- **task_timeout** (timedelta | None) - Optional - The task timeout for the workflow. Defaults to None.
- **id_reuse_policy** (temporalio.common.WorkflowIDReusePolicy) - Optional - The workflow ID reuse policy. Defaults to temporalio.common.WorkflowIDReusePolicy.ALLOW_DUPLICATE.
- **id_conflict_policy** (temporalio.common.WorkflowIDConflictPolicy) - Optional - The workflow ID conflict policy. Defaults to temporalio.common.WorkflowIDConflictPolicy.UNSPECIFIED.
- **retry_policy** (temporalio.common.RetryPolicy | None) - Optional - The retry policy for the workflow. Defaults to None.
- **cron_schedule** (str) - Optional - The cron schedule for the workflow. Defaults to ''.
- **memo** (Mapping[str, Any] | None) - Optional - A memo to attach to the workflow. Defaults to None.
- **search_attributes** (None | temporalio.common.TypedSearchAttributes | temporalio.common.SearchAttributes) - Optional - Search attributes for the workflow. Defaults to None.
- **static_summary** (str | None) - Optional - A static summary for the workflow. Defaults to None.
- **static_details** (str | None) - Optional - Static details for the workflow. Defaults to None.
- **start_delay** (timedelta | None) - Optional - A delay before the workflow starts. Defaults to None.
- **start_signal** (str | None) - Optional - A signal to send when the workflow starts. Defaults to None.
- **start_signal_args** (Sequence[Any]) - Optional - Arguments for the start signal. Defaults to [].
- **rpc_metadata** (Mapping[str, str | bytes]) - Optional - Metadata for the RPC call. Defaults to {}.
- **rpc_timeout** (timedelta | None) - Optional - Timeout for the RPC call. Defaults to None.
- **request_eager_start** (bool) - Optional - Whether to request an eager start. Defaults to False.
- **priority** (temporalio.common.Priority) - Optional - The priority for the workflow. Defaults to temporalio.common.Priority.default.
- **versioning_override** (temporalio.common.VersioningOverride | None) - Optional - A versioning override for the workflow. Defaults to None.

### Returns
- **WorkflowHandle[Any, Any]** - A handle to the started workflow.

```

--------------------------------

### ScheduleActionStartWorkflow.__init__

Source: https://python.temporal.io/temporalio.client.ScheduleActionStartWorkflow.html

Create a start-workflow action. See Client.start_workflow for details on parameter values.

```APIDOC
## ScheduleActionStartWorkflow.__init__

### Description
Create a start-workflow action. See `Client.start_workflow` for details on these parameter values.

### Method
Constructor

### Signature
```python
def __init__(self, workflow: str, arg: Any = temporalio.common._arg_unset, *, args: Sequence[Any] = [], id: str, task_queue: str, execution_timeout: timedelta | None = None, run_timeout: timedelta | None = None, task_timeout: timedelta | None = None, retry_policy: temporalio.common.RetryPolicy | None = None, memo: Mapping[str, Any] | None = None, typed_search_attributes: temporalio.common.TypedSearchAttributes = temporalio.common.TypedSearchAttributes.empty, static_summary: str | None = None, static_details: str | None = None, priority: temporalio.common.Priority = temporalio.common.Priority.default)
```

### Parameters
- **workflow** (str) - Required - The workflow type name.
- **arg** (Any) - Optional - Single argument to pass to the workflow.
- **args** (Sequence[Any]) - Optional - Sequence of arguments to pass to the workflow.
- **id** (str) - Required - Workflow ID.
- **task_queue** (str) - Required - Task queue to run the workflow on.
- **execution_timeout** (timedelta | None) - Optional - Execution timeout.
- **run_timeout** (timedelta | None) - Optional - Run timeout.
- **task_timeout** (timedelta | None) - Optional - Task timeout.
- **retry_policy** (temporalio.common.RetryPolicy | None) - Optional - Retry policy.
- **memo** (Mapping[str, Any] | None) - Optional - Memo for the workflow.
- **typed_search_attributes** (temporalio.common.TypedSearchAttributes) - Optional - Typed search attributes.
- **static_summary** (str | None) - Optional - Static summary.
- **static_details** (str | None) - Optional - Static details.
- **priority** (temporalio.common.Priority) - Optional - Priority.

### Overload
```python
@overload
def __init__(self, workflow: str, *, raw_info: temporalio.api.workflow.v1.NewWorkflowExecutionInfo)
```

### Overload Parameters
- **workflow** (str) - Required - The workflow type name.
- **raw_info** (temporalio.api.workflow.v1.NewWorkflowExecutionInfo) - Required - Raw workflow execution info.

### Attributes
- **args** (Sequence[Any] | Sequence[temporalio.api.common.v1.Payload]) - Undocumented.
- **execution_timeout** (timedelta | None) - Undocumented.
- **headers** (Mapping[str, temporalio.api.common.v1.Payload] | None) - Headers may still be encoded by the payload codec if present.
- **id** (str) - Undocumented.
```

--------------------------------

### Client.start_workflow

Source: https://python.temporal.io/temporalio.client.Client.html

Starts a workflow execution with the given workflow type, arguments, and options. Returns a WorkflowHandle for the started workflow.

```APIDOC
## Client.start_workflow

### Description
Starts a workflow execution with the given workflow type, arguments, and options. Returns a WorkflowHandle for the started workflow.

### Method
async def start_workflow

### Signature
async def start_workflow(self, workflow, arg, *, id, task_queue, execution_timeout=None, run_timeout=None, task_timeout=None, id_reuse_policy=ALLOW_DUPLICATE, id_conflict_policy=UNSPECIFIED, ...) -> WorkflowHandle

### Parameters
- **workflow** (MethodAsyncSingleParam) - Required - The workflow type to start.
- **arg** (ParamType) - Required - The argument to pass to the workflow.
- **id** (str) - Required - The workflow ID.
- **task_queue** (str) - Required - The task queue to use.
- **execution_timeout** (timedelta | None) - Optional - Total workflow execution timeout.
- **run_timeout** (timedelta | None) - Optional - Timeout for a single workflow run.
- **task_timeout** (timedelta | None) - Optional - Timeout for a single workflow task.
- **id_reuse_policy** (WorkflowIDReusePolicy) - Optional - Policy for reusing workflow IDs.
- **id_conflict_policy** (WorkflowIDConflictPolicy) - Optional - Policy for handling workflow ID conflicts.
- **search_attributes** (TypedSearchAttributes | SearchAttributes | None) - Optional - Search attributes for the workflow.
- **static_summary** (str | None) - Optional - Static summary for the workflow.
- **static_details** (str | None) - Optional - Static details for the workflow.
- **start_delay** (timedelta | None) - Optional - Delay before starting the workflow.
- **start_signal** (str | None) - Optional - Signal to send when starting.
- **start_signal_args** (Sequence[Any]) - Optional - Arguments for the start signal.
- **rpc_metadata** (Mapping[str, str | bytes]) - Optional - Metadata for the RPC call.
- **rpc_timeout** (timedelta | None) - Optional - Timeout for the RPC call.
- **request_eager_start** (bool) - Optional - Whether to request eager start.
- **priority** (Priority) - Optional - Priority for the workflow.
- **versioning_override** (VersioningOverride | None) - Optional - Versioning override.

### Returns
- **WorkflowHandle** - A handle to the started workflow.
```
Tokens:
Raw