diff --git a/cross-sdk-design.md b/cross-sdk-design.md new file mode 100644 index 000000000..b1be57c65 --- /dev/null +++ b/cross-sdk-design.md @@ -0,0 +1,2328 @@ +# Standalone Activities Cross-SDK design (draft) + +# Open questions + +[Standalone Activities SDK design - open questions](https://www.notion.so/Standalone-Activities-SDK-design-open-questions-2c58fc567738803996b6c43e3332c327?pvs=21) + +# Approval list + +*Everyone feel free to add your names here.* + +.NET (owners: @Chad Retz, @Maciej Dudkowski) + +- Approved by: +- Blocked by: + +Go (owners: @Quinn Klassen, @Andrew Yuan) + +- Approved by: Andrew (defer to Quinn for final approve) +- Blocked by: + +Java (owners: @Quinn Klassen, @Maciej Dudkowski) + +- Approved by: +- Blocked by: + +Ruby (owners: @Chad Retz, @Chris Olszewski) + +- Approved by: +- Blocked by: + +Python (owners: @Tim Conley, @Alex Mazzeo, @Thomas Hardy) + +- Approved by: +- Blocked by: + +TypeScript (owners: @James Watkins, @Thomas Hardy, @Chris Olszewski) + +- Approved by: +- Blocked by: + +# High-level summary of changes + +1. New client calls: + 1. Start activity (async) + 2. Execute activity (wait for result) + 3. Get activity execution result + 4. Get activity execution info + 5. List activity executions (no interceptor for now) + 6. Count activity executions + 7. Cancel activity execution + 8. Terminate activity +2. Activity info changes: + 1. **BREAKING CHANGE:** `workflow_id`, `workflow_run_id`, `workflow_type` and `workflow_namespace` fields become nullable. + 1. Workflow activities: always set + 2. Standalone activities: always null + 3. Exact implementation varies by language. + 2. `workflow_namespace` is deprecated in favor of new field `namespace`. + 1. Both fields always have the same value, regardless of whether activity is in workflow or standalone. This behavior will be stated in documentation for `workflow_namespace` field. + 3. New field: `activity_run_id` (optional string). + 1. Workflow activities: always null + 2. Standalone activities: always set + 4. New field: `is_workflow_activity` (boolean). + 1. Calculated property where possible - details vary by language. +3. Async activities: + 1. Workflow ID becomes optional in client calls. + 2. Run ID refers to either workflow or activity run ID based on presence of workflow ID. +4. Serialization context: + 1. Where applicable, standalone activities will have their own serialization context type separate from workflow activity context type. This is to avoid breaking changes for existing data converters, as converters written for workflow activities are unlikely to work correctly outside of workflow context. + +# Core SDK + +## 1. Changes to SDK Proto `coresdk.activity_task.Start` + +1. `workflow_namespace` is renamed to `namespace` +2. `workflow_type` and `workflow_execution` are empty if activity is standalone. +3. New field: `string activity_run_id = 18;` - empty if activity is in workflow. + +# .NET + +## 1. New methods in `Client.ITemporalClient` + +A. `StartActivityAsync` and `ExecuteActivityAsync` + +Both methods have multiple overloads for different ways to pass the activity name and arguments, same as `Workflows.Workflow.ExecuteActivityAsync`. One overload takes activity name as a string and arguments as a list or arbitrary objects. The other overloads take a lambda expression describing the activity invocation with arguments in place. + +`StartActivityAsync` can be called with or without generic argument, returning generic `ActivityHandle` or non-generic `ActivityHandle`. + +`ExecuteActivityAsync` can be called with or without generic argument. Generic variant returns the activity result deserialized to given type. Non-generic variant waits for completion but doesn’t return result. + +- Method signatures + + ```tsx + public Task> StartActivityAsync( + Expression> activityCall, + ActivityOptions options) + + public Task StartActivityAsync( + Expression activityCall, + ActivityOptions options) + + public Task> StartActivityAsync( + Expression> activityCall, + ActivityOptions options) + + public Task StartActivityAsync( + Expression> activityCall, + ActivityOptions options) + + public Task> StartActivityAsync( + Expression>> activityCall, + ActivityOptions options) + + public Task StartActivityAsync( + Expression> activityCall, + ActivityOptions options) + + public Task> StartActivityAsync( + Expression>> activityCall, + ActivityOptions options) + + public Task> StartActivityAsync( + Expression> activityCall, + ActivityOptions options) + + public Task> StartActivityAsync( + string activity, + IReadOnlyCollection args + ActivityOptions options) + + public Task StartActivityAsync( + string activity, + IReadOnlyCollection args + ActivityOptions options) + + public Task ExecuteActivityAsync( + Expression> activityCall, + ActivityOptions options) + + public Task ExecuteActivityAsync( + Expression activityCall, + ActivityOptions options) + + public Task ExecuteActivityAsync( + Expression> activityCall, + ActivityOptions options) + + public Task ExecuteActivityAsync( + Expression> activityCall, + ActivityOptions options) + + public Task ExecuteActivityAsync( + Expression>> activityCall, + ActivityOptions options) + + public Task ExecuteActivityAsync( + Expression> activityCall, + ActivityOptions options) + + public Task ExecuteActivityAsync( + Expression>> activityCall, + ActivityOptions options) + + public Task ExecuteActivityAsync( + Expression> activityCall, + ActivityOptions options) + + public Task ExecuteActivityAsync( + string activity, + IReadOnlyCollection args + ActivityOptions options) + + public Task ExecuteActivityAsync( + string activity, + IReadOnlyCollection args + ActivityOptions options) + ``` + + +B. Other methods + +```csharp +public ActivityHandle GetActivityHandle( + string activityId, string? activityRunId); + +public ActivityHandle GetActivityHandle( + string activityId, string? activityRunId); + +#if NETCOREAPP3_0_OR_GREATER +public IAsyncEnumerable ListActivitiesAsync( + string query, ActivityListOptions? options = null); +#endif + +public Task CountActivitiesAsync( + string query, ActivityListOptions? options = null); +``` + +## 2. New types + +```csharp +namespace Temporalio.Client { + public record ActivityHandle( + ITemporalClient client, + string activityId, + string? activityRunId) + { + public async Task GetResultAsync( + ActivityGetResultOptions? options = null); + + public async Task GetResultAsync( + ActivityGetResultOptions? options = null); + + public async Task DescribeAsync( + ActivityDescribeOptions? options = null); + + public async Task CancelAsync( + string? reason = null, + ActivityCancelOptions? options = null); + + public async Task TerminateAsync( + string? reason = null, + ActivityTerminateOptions? options = null); + } + + public class ActivityHandle : ActivityHandle + { + public new async Task GetResultAsync( + ActivityGetResultOptions? options = null); + } + + public class ActivityOptions : ICloneable + { + public ActivityOptions(); + public ActivityOptions(string id, string taskQueue); + + public string? Id { get; set; } // required + public string? TaskQueue { get; set; } // required + + public TimeSpan? ScheduleToCloseTimeout { get; set; } + public TimeSpan? ScheduleToStartTimeout { get; set; } + public TimeSpan? StartToCloseTimeout { get; set; } + public TimeSpan? HeartbeatTimeout { get; set; } + public RetryPolicy? RetryPolicy { get; set; } + public string? Summary { get; set; } + public Priority? Priority { get; set; } + public SearchAttributeCollection? SearchAttributes { get; set; } + public ActivityIdReusePolicy IdReusePolicy { get; set; } = + ActivityIdReusePolicy.AllowDuplicate; // imported from proto + public ActivityIdConflictPolicy IdConflictPolicy { get; set; } = + ActivityIdConflictPolicy.Fail; // imported from proto + + public RpcOptions? Rpc { get; set; } + + public virtual object Clone(); + } + + public class ActivityGetResultOptions : ICloneable + { + public RpcOptions? Rpc { get; set; } + public virtual object Clone(); + } + + public class ActivityDescribeOptions : ICloneable + { + public RpcOptions? Rpc { get; set; } + public virtual object Clone(); + } + + public class ActivityCancelOptions : ICloneable + { + public RpcOptions? Rpc { get; set; } + public virtual object Clone(); + } + + public class ActivityTerminateOptions : ICloneable + { + public RpcOptions? Rpc { get; set; } + public virtual object Clone(); + } + + public class ActivityListOptions : ICloneable + { + public RpcOptions? Rpc { get; set; } + public virtual object Clone(); + } + + public class ActivityCountOptions : ICloneable + { + public RpcOptions? Rpc { get; set; } + public virtual object Clone(); + } + + // Not a record so that there's a way to seamlessly add + // lazy deserialization of future fields, e.g. memo. + public class ActivityExecution + { + protected internal ActivityExecution(); + + public Api.v1.ActivityExecutionListInfo? RawListInfo { get; internal init; } + public string ActivityId { get; internal init; } + public string ActivityRunId { get; internal init; } + public string ActivityType { get; internal init; } + public DateTime? ScheduleTime { get; internal init; } + public DateTime? CloseTime { get; internal init; } + public ActivityExecutionStatus Status { get; internal init; } + public SearchAttributeCollection SearchAttributes { get; internal init; } + public string TaskQueue { get; internal init; } + public DateTime? ExecutionDuration { get; internal init; } + } + + public class ActivityExecutionDescription { + protected internal ActivityExecutionDescription(); + + public Api.v1.ActivityExecutionInfo? RawInfo { get; internal init; } + public DateTime? LastHeartbeatTime { get; internal init; } + public DateTime? LastStartedTime { get; internal init; } + public RetryPolicy? RetryPolicy { get; internal init; } + public DateTime? ExpirationTime { get; internal init; } + public string? LastWorkerIdentity { get; internal init; } + public DateTime? CurrentRetryInterval { get; internal init; } + public DateTime? LastAttemptCompleteTime { get; internal init; } + public DateTime? NextAttemptScheduleTime { get; internal init; } + public WorkerDeploymentVersion LastDeploymentVersion { get; internal init; } + public Priority? Priority { get; internal init; } + public string? CanceledReason { get; internal init; } + } + + public record ActivityExecutionCount( + long Count, + IReadOnlyCollection Groups) + { + public record AggregationGroup( + long Count, + IReadOnlyCollection GroupValues); + } +} + +namespace Temporalio.Client.Interceptors +{ + public record StartActivityInput( + string Activity, + IReadOnlyCollection Args, + ActivityOptions Options, + IDictionary? Headers); + + public record StartActivityOutput( + string RunId); + + public record GetActivityResultInput( + string ActivityId, + string? ActivityRunId, + ActivityGetResultOptions Options); + + public record DescribeActivityInput( + string ActivityId, + string? ActivityRunId, + ActivityDescribeOptions Options); + + public record CancelActivityInput( + string ActivityId, + string? ActivityRunId, + string? Reason, + ActivityCancelOptions Options); + + public record TerminateActivityInput( + string ActivityId, + string? ActivityRunId, + string? Reason, + ActivityTerminateOptions Options); + + public record ListActivitiesInput( + string query, + ActivityListOptions Options); + + public record CountActivitiesInput( + string query, + ActivityCountOptions Options); +} +``` + +## 3. Changes to `Converters.ISerializationContext` + +The following interface definitions replace the existing definitions in backward-compatible way. + +```csharp +namespace Temporalio.Converters +{ + public interface ISerializationContext + { + public interface IHasWorkflow + { + string Namespace { get; } + string WorkflowId { get; } + } + + public sealed record Activity( + string Namespace, + string WorkflowId, + string WorkflowType, + string ActivityType, + string ActivityTaskQueue, + bool IsLocal) : IHasWorkflow + { + // Throws if info is not from a workflow activity + public Activity(Activities.ActivityInfo info); + } + + public sealed record Workflow( + string Namespace, + string WorkflowId) : IHasWorkflow; + + public sealed record NonWorkflowActivity( + string Namespace, + string ActivityId, + string ActivityType, + string ActivityTaskQueue) + { + // Throws if info is from a workflow activity + public NonWorkflowActivity(Activities.ActivityInfo info); + } + } +} +``` + +## 4. Other changes to existing types + +A. `Activities.ActivityInfo` + +```csharp +// new record fields + +string? ActivityRunId, // null if in workflow +string Namespace, + +// changed record fields + +string? WorkflowId, // null if standalone +string? WorkflowNamespace, // deprecated, null if standalone +string? WorkflowRunId, // null if standalone +string? WorkflowType, // null if standalone + +// new calculated property + +bool IsInWorkflow => WorkflowId is not null; +``` + +B. `Client.AsyncActivityHandle.IdReference` + +```csharp +public record IdReference( + string? WorkflowId, // null if standalone + string? RunId, // either workflow run ID or activity run ID or null + string ActivityId) : Reference; +``` + +C. `Client.Interceptors.ClientOutboundInterceptor` + +New methods: + +```csharp +public virtual Task StartActivityAsync( + StartActivityInput input); + +public virtual Task GetActivityResultAsync( + GetActivityResultInput input); + +public virtual Task AsyncDescribeActivity( + DescribeActivityInput input); + +public virtual Task CancelActivityAsync(CancelActivityInput input); + +public virtual Task TerminateActivityAsync(TerminateActivityInput input); + +public virtual Task ListActivitiesAsync(StartActivityInput input); + +#if NETCOREAPP3_0_OR_GREATER +public IAsyncEnumerable ListActivitiesAsync( + ListActivitiesInput input); +#endif + +public virtual Task CountActivitiesAsync( + CountActivitiesInput input); +``` + +# Go + +## 1. New types in `client` module + +```go +import activitypb "go.temporal.io/api/activity/v1" + +type ( + ActivityHandle interface { + ActivityID() string + ActivityRunID() string // can be empty + Get(ctx context.Context, valuePtr any) error + + Describe( + ctx context.Context, + options DescribeActivityOptions + ) (ActivityExecutionDescription, error) + + Cancel( + ctx context.Context, + options CancelActivityOptions + ) error + + Terminate( + ctx context.Context, + options TerminateActivityOptions + ) error + } + + StartActivityOptions struct { + ID string + TaskQueue string + ScheduleToCloseTimeout time.Duration + ScheduleToStartTimeout time.Duration + StartToCloseTimeout time.Duration + HeartbeatTimeout time.Duration + IDConflictPolicy enumspb.ActivityIdConflictPolicy + IDReusePolicy enumspb.ActivityIdReusePolicy + RetryPolicy *RetryPolicy + SearchAttributes SearchAttributes + Summary string + Priority Priority + } + + DescribeActivityOptions struct {} // for future compatibility + + CancelActivityOptions struct { + Reason string + } + + TerminateActivityOptions struct { + Reason string + } + + ActivityExecutionMetadata struct { + // nil if part of ActivityExecutionDescription + RawExecutionListInfo *activitypb.ActivityExecutionListInfo + ActivityID string + ActivityRunID string + ActivityType string + ScheduledTime time.Duration + CloseTime time.Duration + Status enumspb.ActivityExecutionStatus + SearchAttributes SearchAttributes + TaskQueue string + HasStateTransitionCount bool + StateTransitionCount int64 + StateSizeBytes int64 + ExecutionDuration time.Duration + } + + ActivityExecutionDescription struct { + ActivityExecutionMetadata + RawExecutionInfo *activitypb.ActivityExecutionInfo + RunState enumspb.PendingActivityState + LastHeartbeatTime time.Duration + LastStartedTime time.Duration + Attempt int + RetryPolicy *RetryPolicy + ExpirationTime time.Duration + LastWorkerIdentity string + CurrentRetryInterval time.Duration + LastAttemptCompleteTime time.Duration + NextAttemptScheduleTime time.Duration + LastDeploymentVersion WorkerDeploymentVersion + Priority Priority + EagerExecutionRequested bool + CanceledReason string + dc converter.DataConverter + } +) + +// valuePtr must be a pointer to an array +func (a *ActivityExecutionDescription) HeartbeatDetails(valuePtr any) error + +func (a *ActivityExecutionDescription) LastFailure() error +func (a *ActivityExecutionDescription) HeaderReader() HeaderReader +func (a *ActivityExecutionDescription) Summary() (string, error) + +type ( + ListActivitiesOptions struct { + Query string + } + + CountActivitiesOptions struct { + Query string + } + + CountActivitiesResult struct { + Count int64 + Groups []ActivityAggregationGroup + } + + ActivityAggregationGroup struct { + GroupValues []any + Count int64 + } +) +` +``` + +## 2. Changes to `client.Client` interface + +```go +// New methods + +ExecuteActivity( + ctx context.Context, + options StartActivityOptions, + activity any, + args ...any +) (ActivityHandle, error) + +GetActivityHandle( + activityID string, + activityRunID string // can be empty +) (ActivityHandle, error) + +ListActivities( + ctx context.Context, + options ListActivitiesOptions +) iter.Seq2[*ActivityExecutionMetadata, error] + +CountActivities( + ctx context.Context, + options CountActivitiesOptions +) (*CountActivitiesResult, error) + +// Semantic-only changes + +// workflowID can be empty. If it's empty, then activityID refers to +// non-workflow activity, and runID refers to activity run ID. +CompleteActivityByID( + ctx context.Context, + namespace string, + workflowID string, + runID string, + activityID string, + result interface{}, + err error +) error + +// workflowID can be empty. If it's empty, then activityID refers to +// non-workflow activity, and runID refers to activity run ID. +RecordActivityHeartbeatByID( + ctx context.Context, + namespace string, + workflowID string, + runID string, + activityID string, + details ...interface{} +) error +``` + +## 3. Changes to `activity.Info` type + +```go +// New fields + +ActivityRunID string // empty if in workflow +InWorkflow bool +Namespace string + +// Deprecated fields + +WorkflowNamespace string // empty if standalone + +// Semantic-only changes + +WorkflowExecution WorkflowExecution // both ID and RunID empty if standalone +WorkflowType *WorkflowType // nil if standalone +``` + +## 4. Changes to `testsuite` module + +```go +// New method: +// SetRunActivitiesInWorkflow sets how activities are run in test environment. +// If set to true, activities are run inside a fake workflow. +// If set to false, activities are run without a workflow. +// Defaults to true. +func (t *TestActivityEnvironment) SetRunActivitiesInWorkflow( + runActivitiesInWorkflow bool +) t *TestActivityEnvironment + +// Documentation change: panics if SetRunActivitiesInWorkflow is set to false +func (t *TestActivityEnvironmentNoWorkflow) ExecuteLocalActivity( + activityFn interface{}, args ...interface{} +) (converter.EncodedValue, error) +``` + +## 5. Changes to `interceptor` module + +A. New methods in `ClientOutboundInterceptor` interface + +```go +ExecuteActivity( + context.Context, *ClientExecuteActivityInput +) (ActivityHandle, error) + +GetActivityResult( + context.Context, *ClientGetActivityResultInput +) error + +DescribeActivity( + context.Context, *ClientDescribeActivityInput +) (ActivityExecutionDescription, error) + +CancelActivity( + context.Context, *ClientCancelActivityInput +) error + +TerminateActivity( + context.Context, *ClientTerminateActivityInput +) error + +ListActivities( + context.Context, *ClientListActivitiesInput +) iter.Seq2[ActivityExecutionMetadata, error] + +CountActivities( + context.Context, *ClientCountActivitiesInput +) (CountActivitiesResult, error) +``` + +B. New types + +```go +type ( + ClientExecuteActivityInput struct { + Options *StartActivityOptions + ActivityType string + Args []any + } + + ClientGetActivityResultInput struct { + ActivityID string + ActivityRunID string + valuePtr any + } + + ClientDescribeActivityInput struct { + ActivityID string + ActivityRunID string + Options *DescribeActivityOptions + } + + ClientCancelActivityInput struct { + ActivityID string + ActivityRunID string + Options *CancelActivityOptions + } + + ClientTerminateActivityInput struct { + ActivityID string + ActivityRunID string + Options *TerminateActivityOptions + } + + ClientListActivitiesInput struct { + ActivityID string + ActivityRunID string + Options *ListActivitiesOptions + } + + ClientCountActivitiesInput struct { + + ActivityID string + ActivityRunID string + Options *CountActivitiesOptions + } +) +``` + +# Java + +## 1. New types + +- A. `io.temporal.client` + + ```java + /* + Example use: + + @ActivityInterface + interface MyActivity { + @ActivityMethod + String activity(int a, int b); + } + + WorkflowClient client = ...; + ActivityOptions options = ...; + + // sync execution + String result = client.newActivityClient().execute( + MyActivity.class, MyActivity::activity, options, 1, 2); + + // async execution + ActivityHandle handle = client.newActivityClient().start( + MyActivity.class, MyActivity::activity, options, 1, 2); + String result = handle.getResult(); + + */ + public interface ActivityClient { + /// Obtains untyped handle to existing activity execution. + UntypedActivityHandle getHandle( + String activityId, + @Nullable String activityRunId); + + /// Obtains typed handle to existing activity execution. + ActivityHandle getHandle( + String activityId, + @Nullable String activityRunId, + Class resultClass); + + /// Obtains typed handle to existing activity execution. + /// For use with generic return types. + ActivityHandle getHandle( + String activityId, + @Nullable String activityRunId, + Class resultClass, + @Nullable Type resultType); + + /// Asynchronously starts activity. + UntypedActivityHandle start( + String activity, + ActivityOptions options, + @Nullable Object... args); + + ActivityHandle start( + String activity, + Class resultClass, + ActivityOptions options, + @Nullable Object... args); + + ActivityHandle start( + String activity, + Class resultClass, + Type resultType, + ActivityOptions options, + @Nullable Object... args); + + ActivityHandle start( + Class activityInterface, + Functions.Proc1 activity, + ActivityOptions options); + + ActivityHandle start( + Class activityInterface, + Functions.Proc2 activity, + ActivityOptions options, + A1 arg1); + + ActivityHandle start( + Class activityInterface, + Functions.Func1 activity, + ActivityOptions options); + + ActivityHandle start( + Class activityInterface, + Functions.Func2 activity, + ActivityOptions options, + A1 arg1); + + /// Synchronously executes activity. Ignores result. + void execute( + String activity, + ActivityOptions options, + @Nullable Object... args); + + /// Synchronously executes activity. + R execute( + String activity, + Class resultClass, + ActivityOptions options, + @Nullable Object... args); + + R execute( + String activity, + Class resultClass, + Type resultType, + ActivityOptions options, + @Nullable Object... args); + + void execute( + Class activityInterface, + Functions.Proc1 activity, + ActivityOptions options); + + void execute( + Class activityInterface, + Functions.Proc2 activity, + ActivityOptions options, + A1 arg1); + + R execute( + Class activityInterface, + Functions.Func1 activity, + ActivityOptions options); + + R execute( + Class activityInterface, + Functions.Func2 activity, + ActivityOptions options, + A1 arg1); + + /// Asynchronously executes activity. Returns a void future (ignores result). + CompletableFuture executeAsync( + String activity, + ActivityOptions options, + @Nullable Object... args); + + /// Asynchronously executes activity. Returns a future with result. + CompletableFuture executeAsync( + String activity, + Class resultClass, + ActivityOptions options, + @Nullable Object... args); + + CompletableFuture executeAsync( + String activity, + Class resultClass, + Type resultType, + ActivityOptions options, + @Nullable Object... args); + + CompletableFuture executeAsync( + Class activityInterface, + Functions.Proc1 activity, + ActivityOptions options); + + CompletableFuture executeAsync( + Class activityInterface, + Class activityInterface, + Functions.Proc2 activity, + ActivityOptions options, + A1 arg1); + + CompletableFuture executeAsync( + Class activityInterface, + Functions.Func1 activity, + ActivityOptions options); + + CompletableFuture executeAsync( + Class activityInterface, + Functions.Func2 activity, + ActivityOptions options, + A1 arg1); + + // Additional overloads of start, execute and executeAsync + // for Proc3...Proc7, Func3...Func7 (up to 6 activity arguments). + + + + Stream listExecutions(String query); + + ActivityExecutionCount countExecutions(String query); + } + + public interface UntypedActivityHandle { + String getActivityId(); + + /// Present if the handle was returned by `start` method + /// or if it was set when calling `getActivityHandle`. + /// Null if `getActivityHandle` was called with null run ID + /// - in that case, use `describe` to get current run ID. + @Nullable String getActivityRunId(); + + R getResult(Class resultClass); + R getResult(Class resultClass, @Nullable Type resultType); + CompletableFuture getResultAsync(Class resultClass); + CompletableFuture getResultAsync( + Class resultClass, @Nullable Type resultType); + ActivityExecutionDescription describe(); + void cancel(); + void cancel(@Nullable String reason); + void terminate(); + void terminate(@Nullable String reason); + } + + public interface ActivityHandle extends UntypedActivityHandle { + public R getResult(); + public CompletableFuture getResultAsync(); + } + + public class ActivityOptions { + private String id; + private String taskQueue; + private Duration scheduleToCloseTimeout; + private Duration scheduleToStartTimeout; + private Duration startToCloseTimeout; + private Duration heartbeatTimeout; + private RetryOptions retryOptions; + private String summary; + private Priority priority; + private SearchAttributes searchAttributes; + private ActivityIdReusePolicy idReusePolicy; + private ActivityIdConflictPolicy idConflictPolicy; + + // + public getter for each field + + private ActivityOptions(...); + + public Builder newBuilder(); + + public static class Builder { + // setter for each field + + public ActivityOptions build(); + } + } + + public class ActivityExecutionMetadata { + public ActivityExecutionMetadata( + @Nullable ActivityExecutionListInfo info, + DataConverter dataConverter /* for future compatibility */); + + @Nullable + public ActivityExecutionListInfo getRawListInfo(); + + public String getActivityId(); + public String getActivityRunId(); + public String getActivityType(); + public Instant getScheduledTime(); + public Instant getCloseTime(); + public SearchAttributes getSearchAttributes(); + public String getTaskQueue(); + public Instant getExecutionDuration(); + } + + public class ActivityExecutionDescription extends ActivityExecutionMetadata { + public ActivityExecutionDescription( + @Nonnull ActivityExecutionInfo info, + DataConverter dataConverter /* for future compatibility */) { + super(null, dataConverter); + ... + } + + @Nonnull + public ActivityExecutionInfo getRawInfo(); + + @Override + public String getActivityId(); + @Override + public String getActivityRunId(); + @Override + public String getActivityType(); + @Override + public Instant getScheduledTime(); + @Override + public Instant getCloseTime(); + @Override + public SearchAttributes getSearchAttributes(); + @Override + public String getTaskQueue(); + @Override + public Instant getExecutionDuration(); + + public Instant getLastHeartbeatTime(); + public Instant getLastStartedTime(); + public RetryOptions getRetryOptions(); + public Instant getExpirationTime(); + public String getLastWorkerIdentity(); + public Duration getCurrentRetryInterval(); + public Instant getLastAttemptCompleteTime(); + public Instant getNextAttemptScheduleTime(); + public WorkerDeploymentVersion getWorkerDeploymentVersion(); + public Priority getPriority(); + public String getCanceledReason(); + } + + public class ActivityExecutonCount { + public ActivityExecutonCount( + long count, List groups); + + public long getCount(); + + /// Returns unmodifiable list. + public List getGroups(); + + public static class AggregationGroup { + public AggregationGroup(long count, List groupValues); + + public long getCount(); + + /// Returns unmodifiable list. + public List getGroupValues(); + } + } + ``` + + +B. `io.temporal.workflow.Functions` + +```java +@FunctionalInterface +public interface Proc7 + extends TemporalFunctionalInterfaceMarker, Serializable { + void apply(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7); +} + +@FunctionalInterface +public interface Func7 + extends TemporalFunctionalInterfaceMarker, Serializable { + R apply(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7); +} +``` + +C. `io.temporal.common.interceptors` + +```java +public interface ActivityClientCallsInterceptor { + UntypedActivityHandle start(ActivityStartInput input); + Payload getResult(ActivityGetResultInput input); + ActivityExecutionDescription describe(ActivityDescribeInput input); + void cancel(ActivityCancelInput input); + void terminate(ActivityTerminateInput input); + ActivityExecutonCount count(ActivityCountInput input); + + static class ActivityStartInput { + public ActivityStartInput( + @Nonnull String activityId, + @Nonnull String activityType, + @Nonnull client.ActivityOptions options, + @Nonnull Object[] arguments, + @Nonnull Header header); + + public String getActivityId(); + public String getActivityType(); + public client.ActivityOptions getOptions(); + public Object[] getArguments(); + public Header getHeader(); + } + + static class ActivityGetResultInput { + public ActivityGetResultInput( + @Nonnull String activityId, + @Nullable String activityRunId); + + public String getActivityId(); + public String getActivityRunId(); + } + + static class ActivityDescribeInput { + public ActivityDescribeInput( + @Nonnull String activityId, + @Nullable String activityRunId); + + public String getActivityId(); + public String getActivityRunId(); + } + + static class ActivityCancelInput { + public ActivityCancelInput( + @Nonnull String activityId, + @Nullable String activityRunId, + @Nullable String reason); + + public String getActivityId(); + public String getActivityRunId(); + public @Nullable String getReason(); + } + + static class ActivityTerminateInput { + public ActivityTerminateInput( + @Nonnull String activityId, + @Nullable String activityRunId, + @Nullable String reason); + + public String getActivityId(); + public String getActivityRunId(); + public @Nullable String getReason(); + } + + static class ActivityCountInput { + public ActivityCountInput( + @Nonnull String query); + + public String getQuery(); + } +} + +public class ActivityClientCallsInterceptorBase + implements ActivityClientCallsInterceptor { + + protected final WorkflowClientCallsInterceptor next; + + public ActivityClientCallsInterceptorBase( + ActivityClientCallsInterceptor next); + + @Override + public UntypedActivityHandle start(ActivityStartInput input) { + return next.start(input); + } + + // etc. for other methods +} +``` + +## 2. Changes to existing types + +A. `io.temporal.client.WorkflowClient` + +```java +// New method + +ActivityClient newActivityClient(); +``` + +B. `io.temporal.activity.ActivityInfo` + +```java +// New methods + +@Nullable String getActivityRunId(); +@Nullable String getWorkflowRunId(); +boolean isInWorkflow(); + +// Changed methods + +@Deprecated @Nullable String getRunId(); // replaced by getWorkflowRunId +@Nullable String getWorkflowId(); +@Nullable String getWorkflowType(); + +``` + +C. `io.temporal.activity.ActivityOptions` + +- Documentation change: options for workflow activities only. + +D. `io.temporal.client.ActivityCompletionClient` + +```java +// New methods + + void complete( + String activityId, + Optional activityRunId, + R result) + throws ActivityCompletionException; + +void completeExceptionally( + String activityId, + Optional activityRunId, + Exception result) + throws ActivityCompletionException; + + void reportCancellation( + String activityId, + Optional activityRunId, + V details) + throws ActivityCompletionException; + + void heartbeat( + String activityId, + Optional activityRunId, + V details) + throws ActivityCompletionException; +``` + +E. `io.temporal.common.interceptors.WorkflowClientInterceptor` + +```java +// New method + +ActivityClientCallsInterceptor activityClientCallsInterceptor( + ActivityClientCallsInterceptor next); +``` + +## 3. Changes to `io.temporal.payload.context` + +1. In `HasWorkflowSerializationContext`, field `workflowId` is made nullable. +2. In `ActivitySerializationContext`, fields `workflowId` and `workflowType` are made nullable. + +# Ruby + +The design is written in terms of signature files (.rbs). + +## 1. New types + +A. `Temporalio` + +```ruby +module ActivityIDReusePolicy + type enum = Integer + # maps to Api::Enums::V1::ActivityIdReusePolicy +end + +module ActivityIDConflictPolicy + type enum = Integer + # maps to Api::Enums::V1::ActivityIdConflictPolicy +end +``` + +B. `Temporalio.Client` + +```ruby +class ActivityHandle + attr_reader activity_id: String + attr_reader activity_run_id: String? + attr_reader result_hint: Object? + + def initialize: ( + client: Client, + activity_id: String, + activity_run_id: String?, + result_hint: Object? + ) -> void + + def result: ( + ?rpc_options: RPCOptions? + ) -> Object? + + def describe: ( + ?rpc_options: RPCOptions? + ) -> ActivityExecution::Description + + def cancel: ( + ?String? reason, + ?rpc_options: RPCOptions? + ) -> void + + def terminate: ( + ?String? reason, + ?rpc_options: RPCOptions? + ) -> void +end + +class ActivityExecution + attr_reader raw: untyped + + def initialize: ( + untyped raw, + Converters::DataConverter data_converter # for future compatibility + ) -> void + + def activity_id: -> String + def activity_type: -> String + def activity_run_id: -> String + def close_time: -> Time + def execution_duration: -> duration + def namespace: -> String # not present in proto, copied from client + def scheduled_time: -> Time + def search_attributes: -> SearchAttributes + def status: -> String + def task_queue: -> String + + class Description < ActivityExecution + def initialize: ( + untyped raw, + Converters::DataConverter data_converter # for future compatibility + ) -> void + + def attempt: -> Integer + def canceled_reason: -> String? + def current_retry_interval: -> duration? + def eager_execution_requested?: bool + def last_attempt_complete_time: -> Time? + def last_heartbeat_time: -> Time? + def last_started_time: -> Time? + def last_worker_identity: -> String? + def retry_policy: -> RetryPolicy? + def next_attempt_schedule_time: -> Time? + def paused?: bool + end +end + +class ActivityExecutionCount + attr_reader count: Integer + attr_reader groups: Array[AggregationGroup] + + def initialize: ( + Integer count, + Array[AggregationGroup] groups + ) -> void + + class AggregationGroup + attr_reader count: Integer + attr_reader group_values: Array[Object?] + + def initialize: ( + Integer count, + Array[Object?] group_values + ) -> void + end +end + +module ActivityExecutionStatus + type enum = Integer + # maps to Api::Enums::V1::ActivityExecutionStatus +end +``` + +C. `Temporalio.Error` + +```ruby +class ActivityAlreadyStartedError < Failure + attr_reader activity_id: String + attr_reader activity_type: String + attr_reader activity_run_id: String? + + # @!visibility private + def initialize( + activity_id: String, + activity_type: String, + activity_run_id: String? + ) -> void +end +``` + +## 2. New methods in `Client` + +```ruby +def start_activity( + singleton(Activity::Definition) | Activity::Definition::Info + | Symbol | String activity**, + ***Object? args, + id: String, + task_queue: String, + ?schedule_to_close_timeout: duration?, + ?schedule_to_start_timeout: duration?, + ?start_to_close_timeout: duration?, + ?heartbeat_timeout: duration?, + ?id_reuse_policy: ActivityIDReusePolicy # default ALLOW_DUPLICATE, + ?id_conflict_policy: ActivityIDConflictPolicy # default FAIL, + ?retry_policy: RetryPolicy?, +**** ?search_attributes: SearchAttributes?, + ?summary: String?**,** + ?priority: Priority, # default Priority.default + ?arg_hints: Array[Object]?, + ?result_hint: Object?, + ?rpc_options: RPCOptions? +) -> ActivityHandle + +def execute_activity( + singleton(Activity::Definition) | Activity::Definition::Info + | Symbol | String activity**, + ***Object? args, + id: String, + task_queue: String, + ?schedule_to_close_timeout: duration?, + ?schedule_to_start_timeout: duration?, + ?start_to_close_timeout: duration?, + ?heartbeat_timeout: duration?, + ?id_reuse_policy: ActivityIDReusePolicy # default ALLOW_DUPLICATE, + ?id_conflict_policy: ActivityIDConflictPolicy # default FAIL, + ?retry_policy: RetryPolicy?, +**** ?search_attributes: SearchAttributes?, + ?summary: String?**,** + ?priority: Priority, # default Priority.default + ?arg_hints: Array[Object]?, + ?result_hint: Object?, + ?rpc_options: RPCOptions? +) -> Object? + +def activity_handle( + String activity_id, + ?activity_run_id: String?, + ?result_hint: Object? +) -> ActivityHandle + +def list_activities( + String query, + ?rpc_options: RPCOptions? +) -> Enumerator[ActivityExecution, ActivityExecution] + +def count_activities( + String query, + ?rpc_options: RPCOptions? +) -> ActivityExecutionCount +``` + +## 3. Changes to other types + +A. `Temporalio.Activity.Info` + +```ruby +# New items + +attr_reader activity_run_id: String? # nil if in workflow +attr_reader in_workflow?: bool +attr_reader namespace: String + +# Changed items + +attr_reader workflow_id: String? # nil if standalone +attr_reader workflow_run_id: String? # nil if standalone +attr_reader workflow_type: String? # nil if standalone + +# Deprecated, nil if standalone +attr_reader workflow_namespace: String? +``` + +B. `Temporalio.Client.ActivityIDReference` - new definition. + +```ruby +class ActivityIDReference + attr_reader activity_id: String + attr_reader activity_run_id: String? + attr_reader workflow_id: String? + attr_reader workflow_run_id: String? + + # either activity_run_id or workflow_run_id + attr_reader run_id: String? + + def initialize: ( + workflow_id: String, + run_id: String?, + activity_id: String + ) -> void + | ( + activity_id: String, + activity_run_id: String? + ) -> void +end +``` + +C. `Temporalio.Client.Interceptor` + +```ruby +# New methods in OutboundInterceptor + +def start_activity: (StartActivityInput input) -> ActivityHandle + +def describe_activity: ( + DescribeActivityInput input +) -> ActivityExecution::Description + +def cancel_activity: (CancelActivityInput input) -> void + +def terminate_activity: (TerminateActivityInput input) -> void + +def count_activities: ( + CountActivitiesInput input +) -> ActivityExecutionCount + +# New types in Interceptor + +class StartActivityInput + attr_reader activity: String + attr_reader args: Array[Object?] + attr_reader activity_id: String + attr_reader task_queue: String + attr_reader schedule_to_close_timeout: duration? + attr_reader schedule_to_start_timeout: duration? + attr_reader start_to_close_timeout: duration? + attr_reader heartbeat_timeout: duration? + attr_reader id_reuse_policy: ActivityIDReusePolicy + attr_reader id_conflict_policy: ActivityIDConflictPolicy + attr_reader retry_policy: RetryPolicy? + attr_reader search_attributes: SearchAttributes? + attr_reader summary: String? + attr_reader arg_hints: Array[Object]? + attr_reader result_hint: Object? + attr_reader rpc_options: RPCOptions? + + def initialize: (...) -> void +end + +class DescribeActivityInput + attr_reader activity_id: String + attr_reader activity_run_id: String? + attr_reader rpc_options: RPCOptions? + + def initialize: (...) -> void +end + +class CancelActivityInput + attr_reader activity_id: String + attr_reader activity_run_id: String? + attr_reader reason: String? + attr_reader rpc_options: RPCOptions? + + def initialize: (...) -> void +end + +class TerminateActivityInput + attr_reader activity_id: String + attr_reader activity_run_id: String? + attr_reader reason: String? + attr_reader rpc_options: RPCOptions? + + def initialize: (...) -> void +end + +class CountActivitiesInput + attr_reader query: String + attr_reader rpc_options: RPCOptions? + + def initialize: (...) -> void +end +``` + +# Python + +## 1. New types + +`temporalio.common` + +```python +# Maps to temporalio.api.enums.v1.ActivityIdReusePolicy +class ActivityIDReusePolicy(IntEnum): + ... + +# Maps to temporalio.api.enums.v1.ActivityIdConflictPolicy +class ActivityIDConflictPolicy(IntEnum): + ... + +# Maps to temporalio.api.enums.v1.ActivityExecutionStatus +class ActivityExecutionStatus(IntEnum): + ... +``` + +`temporalio.client` + +```python +class ActivityHandle(Generic[ReturnType]): + @property + def activity_id(self) -> str: + ... + + @property + def activity_run_id(self) -> Option[str]: + ... + + async def result( + self, + *, + rpc_metadata: Mapping[str, Union[str, bytes]] = {}, + rpc_timeout: Optional[timedelta] = None, + ) -> ReturnType: + ... + + async def describe( + self, + *, + rpc_metadata: Mapping[str, Union[str, bytes]] = {}, + rpc_timeout: Optional[timedelta] = None, + ) -> ActivityExecutionDescription: + ... + + async def cancel( + self, + *, + reason: Optional[str] = None, + rpc_metadata: Mapping[str, Union[str, bytes]] = {}, + rpc_timeout: Optional[timedelta] = None, + ) -> None: + ... + + async def terminate( + self, + *, + reason: Optional[str] = None, + rpc_metadata: Mapping[str, Union[str, bytes]] = {}, + rpc_timeout: Optional[timedelta] = None, + ) -> None: + ... + +@dataclass(frozen=True) +class ActivityExecution: + ****activity_id: str + ****activity_type: str + ****activity_run_id: Optional[str] + close_time: Optional[datetime] + execution_duration: Optional[timedelta] + namespace: str # not present in proto, copied from calling client + raw_info: Union[ + temporalio.api.activity.v1.ActivityExecutionListInfo, + temporalio.api.activity.v1.ActivityExecutionInfo + ] + scheduled_time: datetime + search_attributes: temporalio.common.SearchAttributes + state_transition_count: Optional[int] # not always present on List operation, see proto docs for details + status: temporalio.common.ActivityExecutionStatus + task_queue: str +**** +@dataclass(frozen=True) +class ActivityExecutionDescription(ActivityExecution): + attempt: int + canceled_reason: Optional[str] + current_retry_interval: Optional[timedelta] + eager_execution_requested: bool + expiration_time: datetime + heartbeat_details: Sequence[Any] + last_attempt_complete_time: Optional[datetime] + last_failure: Optional[Exception] + last_heartbeat_time: Optional[datetime] + last_started_time: Optional[datetime] + last_worker_identity: str + retry_policy: Optional[temporalio.common.RetryPolicy] + next_attempt_schedule_time: Optional[datetime] + paused: bool + run_state: Optional[temporalio.common.PendingActivityState] + + +class ActivityExecutionAsyncIterator: + def __init__( + self, + client: Client, + input: ListActivitiesInput, + ) -> None: + ... + + @property + def current_page_index(self) -> int: + ... + + @property + def current_page( + self, + ) -> Optional[Sequence[ActivityExecution]]: + ... + + @property + def next_page_token(self) -> Optional[bytes]: + ... + + async def fetch_next_page( + self, *, page_size: Optional[int] = None + ) -> None: + ... + + def __aiter__(self) -> ActivityExecutionAsyncIterator: + ... + + async def __anext__(self) -> ActivityExecution: + ... + +@dataclass +class ActivityExecutionCount: + count: int + groups: Sequence[ActivityExecutionCountAggregationGroup] + +@dataclass +class ActivityExecutionCountAggregationGroup: + count: int + group_values: Sequence[temporalio.common.SearchAttributeValue] +``` + +## 2. New methods in `client.Client` + +A. Start activity methods: + +1. Same set of methods as for workflow activities: +`start_activity`, `start_activity_class`, `start_activity_method`, `execute_activity`, `execute_activity_class`, `execute_activity_method` +2. All `start_activity` methods are async and return `ActivityHandle[Any]`. +3. All `execute_activity` methods are async, wait for activity completion and return the result as `Any`. +4. All listed methods have overloads for specific activity types (`str`, various `Callable` types), same as workflow activities. For `Callable` overloads, a specific return type is used instead of `Any`. +5. All listed methods have the same set of arguments. + +```python +# Bolded arguments are differences from the prototype. +async def start_activity( + self, + **activity: Any,** + *, + args: Sequence[Any] = [], + # Note: workflow's start_activity() has activity_id argument instead of id. + # The mismatch is intentional - because activity_id should never be set + # except in rare circumstances, but this id should always have meaningful + # value, giving them different names avoids potential copy-paste errors. + id: str, + task_queue: str, + result_type: Optional[type] = None, + schedule_to_close_timeout: Optional[timedelta] = None, + schedule_to_start_timeout: Optional[timedelta] = None, + start_to_close_timeout: Optional[timedelta] = None, + heartbeat_timeout: Optional[timedelta] = None, + id_reuse_policy: temporalio.common.ActivityIDReusePolicy = temporalio.common.ActivityIDReusePolicy.ALLOW_DUPLICATE, + id_conflict_policy: temporalio.common.ActivityIDConflictPolicy = temporalio.common.ActivityIDConflictPolicy.FAIL, + retry_policy: Optional[temporalio.common.RetryPolicy] = None, + ****search_attributes: Optional[temporalio.common.TypedSearchAttributes] = None, + **summary: Optional[str] = None,** + # no static_details (matches workflow activity API) + priority: temporalio.common.Priority = temporalio.common.Priority.default, + rpc_metadata: Mapping[str, Union[str, bytes]] = {}, + rpc_timeout: Optional[timedelta] = None, +) -> temporalio.client.ActivityHandle[Any]: + ... +``` + +B. Other methods: + +```python +def list_activities( + self, + query: Optional[str] = None, + *, + limit: Optional[int] = None, + page_size: int = 1000, + next_page_token: Optional[bytes] = None, + rpc_metadata: Mapping[str, Union[str, bytes]] = {}, + rpc_timeout: Optional[timedelta] = None, +) -> ActivityExecutionAsyncIterator: + ... + +async def count_activities( + self, + query: Optional[str] = None, + *, + rpc_metadata: Mapping[str, Union[str, bytes]] = {}, + rpc_timeout: Optional[timedelta] = None, +) -> ActivityExecutionCount: + ... + +@overload +def get_activity_handle( + self, + activity_id: str, + * + activity_run_id: Optional[str] = None +) -> ActivityHandle[Any]: + ... + +@overload +def get_activity_handle( + self, + activity_id: str, + * + result_type: type[ReturnType], + activity_run_id: Optional[str] = None, +) -> ActivityHandle[ReturnType]: + ... + +def get_activity_handle( + self, + activity_id: str, + * + result_type: Optional[type] = None, + activity_run_id: Optional[str] = None +) -> ActivityHandle[ReturnType]: + ... +``` + +## 3. New methods in `client.OutboundInterceptor` + +```python +async def start_activity( + self, input: StartActivityInput +) -> ActivityHandle[Any]: + ... + +async def get_activity_result( + self, input: GetActivityResultInput[ReturnType] +) -> ReturnType: + ... + +async def describe_activity( + self, input: DescribeActivityInput +) -> ActivityExecutionDescription: + ... + +async def cancel_activity( + self, input: CancelActivityInput +) -> None: + ... + +async def terminate_activity( + self, input: TerminateActivityInput +) -> None: + ... + +def list_activities( + self, input: ListActivitiesInput +) -> ActivityExecutionAsyncIterator: + ... + +async def count_activities( + self, input: CountActivitiesInput +) -> ExecutionCount: + ... + +@dataclass +class StartActivityInput: + activity_type: str + args: Sequence[Any] + id: str + task_queue: str + result_type: Optional[type] + schedule_to_close_timeout: Optional[timedelta] + schedule_to_start_timeout: Optional[timedelta] + start_to_close_timeout: Optional[timedelta] + heartbeat_timeout: Optional[timedelta] + id_reuse_policy: temporalio.common.ActivityIDReusePolicy + id_conflict_policy: temporalio.common.ActivityIDConflictPolicy + retry_policy: Optional[temporalio.common.RetryPolicy] + search_attributes: Optional[temporalio.common.TypedSearchAttributes] + summary: Optional[str] + priority: temporalio.common.Priority + headers: Mapping[str, temporalio.api.common.v1.Payload] + rpc_metadata: Mapping[str, Union[str, bytes]] + rpc_timeout: Optional[timedelta] + +@dataclass +class DescribeActivityInput: + activity_id: str + activity_run_id: Optional[str] + rpc_metadata: Mapping[str, Union[str, bytes]] + rpc_timeout: Optional[timedelta] + +@dataclass +class GetActivityResultInput[ReturnType]: + activity_id: str + activity_run_id: Optional[str] + result_type: type[ReturnType] + rpc_metadata: Mapping[str, Union[str, bytes]] + rpc_timeout: Optional[timedelta] + +@dataclass +class CancelActivityInput: + activity_id: str + activity_run_id: Optional[str] + reason: Optional[str] + wait_for_cancel_completed: bool + rpc_metadata: Mapping[str, Union[str, bytes]] + rpc_timeout: Optional[timedelta] + +@dataclass +class TerminateActivityInput: + activity_id: str + activity_run_id: Optional[str] + reason: Optional[str] + rpc_metadata: Mapping[str, Union[str, bytes]] + rpc_timeout: Optional[timedelta] + +@dataclass +class ListActivitiesInput: + query: Optional[str] + limit: Optional[int] + page_size: int + next_page_token: Optional[bytes] + rpc_metadata: Mapping[str, Union[str, bytes]] + rpc_timeout: Optional[timedelta] + +@dataclass +class CountActivitiesInput: + query: Optional[str] + rpc_metadata: Mapping[str, Union[str, bytes]] + rpc_timeout: Optional[timedelta] +``` + +## 4. Other changes to existing types + +A. `activity.Info` + +```python +# new fields +namespace: str +activity_run_id: Optional[str] # None if in workflow + +@property +def in_workflow(self) -> bool: + return workflow_id is not None + +# changed signature +workflow_id: Optional[str] # None if standalone +workflow_namespace: Optional[str] # DEPRECATED, None if standalone +workflow_run_id: Optional[str] # None if standalone +workflow_type: Optional[str] # None if standalone +``` + +B. `client.AsyncActivityIDReference` + +```python +# changed signature +workflow_id: Optional[str] +``` + +## 5. Serialization context (TODO) + +## 6. [AI-generated] Python Implementation Notes (Current Status) + +The following discrepancies exist between the spec above and the current Python SDK implementation: + +### Intentionally Deferred (Would Require Significant Work) + +1. **`GetActivityResultInput` and `get_activity_result` interceptor method**: Not implemented. The current implementation caches the result directly in `ActivityHandle._known_outcome` and doesn't expose a separate interceptor point for getting results. Adding this would require refactoring the result caching logic. + +2. **`ActivityExecutionDescription` does not extend `ActivityExecution`**: Python frozen dataclasses don't support inheritance well. The two classes are separate with duplicated fields. This is a stylistic difference that doesn't affect functionality. + +3. **Overload methods `start_activity_class`, `start_activity_method`, `execute_activity_class`, `execute_activity_method`**: Not implemented. Only the base `start_activity` and `execute_activity` methods exist. These additional overloads would provide better type inference for class-based and method-based activity definitions. + +4. **`get_activity_handle` is incomplete**: The method exists but raises `NotImplementedError`. When implemented, should include `result_type` parameter per spec. + +### Missing Fields + +1. **`ActivityExecution.state_transition_count: Optional[int]`**: Removed from implementation. The spec says it should be present (though not always populated). + +2. **`ActivityExecutionDescription.eager_execution_requested: bool`**: Missing from implementation. + +3. **`ActivityExecutionDescription.paused: bool`**: Missing from implementation. + +4. **`ActivityExecutionCountAggregationGroup.group_values`**: Spec says `Sequence[temporalio.common.SearchAttributeValue]`, implementation uses `Sequence[Any]`. + +### Extra Items (Not in Spec) + +2. **`ActivityExecutionDescription.input: Sequence[Any]`**: Extra field providing deserialized activity input. Not in spec but useful for debugging. + +3. **`PendingActivityState` enum**: Added to `temporalio.common` to support `ActivityExecutionDescription.run_state`. Should be added to spec. + +4. **`ActivityFailedError` exception class**: New error for standalone activity failures. Should be added to spec. + +### Minor Type Differences + +1. **`ActivityHandle.activity_run_id`**: Returns `str` (always set from `StartActivityExecution` response) but spec shows `Optional[str]`. The non-optional type is correct since start always returns a run_id. + +2. **`ActivityExecutionDescription.retry_policy`**: Not optional in implementation, but spec says `Optional`. Should verify proto field optionality. + +### Implemented Correctly + +- All `ActivityIDReusePolicy`, `ActivityIDConflictPolicy`, `ActivityExecutionStatus` enums +- `ActivityHandle` with `activity_id`, `activity_run_id`, `result()`, `describe()`, `cancel()`, `terminate()` +- `ActivityExecution` with core fields (except `state_transition_count`) +- `ActivityExecutionDescription` with most fields (except `eager_execution_requested`, `paused`) +- `ActivityExecutionAsyncIterator` for listing +- `ActivityExecutionCount` and `ActivityExecutionCountAggregationGroup` +- `Client.start_activity()`, `execute_activity()`, `list_activities()`, `count_activities()` +- `OutboundInterceptor` methods: `start_activity`, `describe_activity`, `cancel_activity`, `terminate_activity`, `list_activities`, `count_activities` +- All input dataclasses: `StartActivityInput`, `DescribeActivityInput`, `CancelActivityInput`, `TerminateActivityInput`, `ListActivitiesInput`, `CountActivitiesInput` +- `activity.Info` changes: `namespace`, `activity_run_id`, `in_workflow` property, optional workflow fields +- `AsyncActivityIDReference.workflow_id` is now `Optional[str]` + +# TypeScript + +## 1. New module `client.activity-client` + +```tsx +/* Example use: + +interface MyActivity { + doWork(x: number): Promise; +} + +const connection = await Connection.connect({ address: 'localhost:7233' }); +const client = new Client({ connection }); +const opts = { + taskQueue: 'task-queue', + startToCloseTimeout: '1 minute' +}; + +// Typed activity start +const handle = await client.activity.typed().start( + 'doWork', { id: 'activity1', ...opts }, 1 +); +const result = await handle.result(); + +// Typed activity execution +const result = await client.activity.typed().execute( + 'doWork', { id: 'activity2', ...opts }, 1 +); + +// Untyped activity execution +const result = await client.activity.execute( + 'doWork', { id: 'activity3', ...opts }, 'abc' +); + +*/ + +import { AsyncCompletionClient, ActivityNotFoundError } from './async-completion-client' + +export ActivityNotFoundError; +export type ActivityClientOptions = BaseClientOptions; +export type LoadedActivityClientOptions = LoadedWithDefaults; + +export class ActivityClient + extends AsyncCompletionClient + implements TypedActivityClient +{ + public constructor(options?: ActivityClientOptions); + + public typed(): TypedActivityClient { return this; } + + public async start( + activity: string, options: ActivityOptions, ...args: any[] + ): Promise; + + public async execute( + activity: string, options: ActivityOptions, ...args: any[] + ): Promise; + + public getHandle( + activityId: string, activityRunId?: string + ): ActivityHandle; + + public list(string query): AsyncIterable; + + public async count(string query): Promise; +} + +// An instance of ActivityHandle is bound to the client it's created with. +export interface ActivityHandle { + readonly activityId: string; + readonly activityRunId: string; + result(): Promise; + describe(): Promise; + cancel(string reason): Promise; + terminate(string reason): Promise; +} + +export interface ActivityOptions { + id: string; + taskQueue: string; + heartbeatTimeout?: Duration; + retry?: RetryPolicy; + startToCloseTimeout?: Duration; + scheduleToStartTimeout?: Duration; + scheduleToCloseTimeout?: Duration; + summary?: string; + priority?: Priority; + idReusePolicy?: ActivityIdReusePolicy; + idConflictPolicy?: ActivityIdConflictPolicy; + typedSearchAttributes?: SearchAttributePair[] | TypedSearchAttributes; +} + +export type ActivityKey = { + [K in keyof T & string]: + T[K] extends ActivityFunction ? K : never; +}[keyof T & string]; + +export type ActivityArgs> = + T[K] extends ActivityFunction ? P : never; + +export type ActivityResult> = + T[K] extends ActivityFunction ? R : never; + +interface TypedActivityClient { + start>( + activity: K, + options: ActivityOptions, + ...args: ActivityArgs + ): Promise>>; + + execute>( + activity: K, + options: ActivityOptions, + ...args: ActivityArgs + ): Promise>; + +``` + +## 2. New types in `client.types` + +```tsx +export interface CountActivitiesResult { + readonly count: number; + readonly groups: { + readonly count: number; + readonly groupValues: TypedSearchAttributeValue[]; + }[]; +} + +export type RawActivityExecutionInfo = proto.temporal.api.activity.v1.IActivityExecutionInfo; +export type RawActivityExecutionListInfo = proto.temporal.api.activity.v1.IActivityExecutionListInfo; + +export interface ActivityExecutionInfo { + rawListInfo?: RawActivityExecutionListInfo; + activityId: string; + activityRunId: string; + activityType: string; + scheduledTime: Date; + closeTime: Date; + searchAttributes: TypedSearchAttributes; + taskQueue: string; + stateTransitionCount?: number; + stateSizeBytes: number; + executionDuration: Date; +} + +export interface ActivityExecutionDescription extends ActivityExecutionInfo { + rawInfo: RawActivityExecutionInfo; + lastHeartbeatTime: Date; + lastStartedTime: Date; + attempt: number; + retryPolicy: RetryPolicy; + expirationTime: Date; + lastWorkerIdentity: string; + currentRetryInterval: Date; + lastAttemptCompleteTime: Date; + nextAttemptScheduleTime: Date; + lastDeploymentVersion: WorkerDeploymentVersion; + priority: Priority; + eagerExecutionRequested: bool; + canceledReason: string; +}; + +// Maps to temporal.api.enums.v1.ActivityIdReusePolicy +export const ActivityIdReusePolicy { ... } +export type ActivityIdReusePolicy = + (typeof ActivityIdReusePolicy)[keyof typeof ActivityIdReusePolicy]; +export const [encodeActivityIdReusePolicy, decodeActivityIdReusePolicy] = + makeProtoEnumConverters<...>(...); + +// Maps to temporal.api.enums.v1.ActivityIdConflictPolicy +export const ActivityIdConflictPolicy { ... } +export type ActivityIdConflictPolicy = + (typeof ActivityIdConflictPolicy)[keyof typeof ActivityIdConflictPolicy]; +export const [encodeActivityIdConflictPolicy, decodeActivityIdConflictPolicy] = + makeProtoEnumConverters<...>(...); + +// Maps to temporal.api.enums.v1.ActivityExecutionStatus +export const ActivityExecutionStatus { ... } +export type ActivityExecutionStatus = + (typeof ActivityExecutionStatus)[keyof typeof ActivityExecutionStatus]; +export const [encodeActivityExecutionStatus, decodeActivityExecutionStatus] = + makeProtoEnumConverters<...>(...); + +``` + +## 3. Changes to `client.interceptors` + +A. `ClientInterceptors` has new field `activity?: ActivityClientInterceptor[];`. + +B. New types: + +```tsx +export interface ActivityClientInterceptor { + start?: ( + input: ActivityStartInput, next: Next + ) => Promise; + + getResult?: ( + input: ActivityGetResultInput, next: Next + ) => Promise; + + describe?: ( + input: ActivityDescribeInput, next: Next + ) => Promise; + + cancel?: ( + input: ActivityCancelInput, next: Next + ) => Promise; + + terminate?: ( + input: ActivityTerminateInput, next: Next + ) => Promise; + + list?: ( + input: ActivityListInput, next: Next + ) => AsyncIterable; + + count?: ( + input: ActivityCountInput, next: Next + ) => Promise; +} + +export interface ActivityStartInput { + readonly activityType: string; + readonly args: any[]; + readonly options: ActivityOptions; + readonly headers: Headers; +} + +export interface ActivityGetResultInput { + readonly activityId: string; + readonly activityRunId: string; + readonly headers: Headers; +} + +export interface ActivityDescribeInput { + readonly activityId: string; + readonly activityRunId: string; + readonly headers: Headers; +} + +export interface ActivityCancelInput { + readonly activityId: string; + readonly activityRunId: string; + readonly reason: string; + readonly headers: Headers; +} + +export interface ActivityTerminateInput { + readonly activityId: string; + readonly activityRunId: string; + readonly reason: string; + readonly headers: Headers; +} + +export interface ActivityListInput { + readonly query: string; + readonly headers: Headers; +} + +export interface ActivityCountInput { + readonly query: string; + readonly headers: Headers; +} +``` + +## 4. Other changes to existing types + +A. `activity.Info` + +```tsx +// new fields + +readonly namespace: string; +readonly activityRunId?: string; // undefined if in workflow +readonly inWorkflow: boolean; // calculated property: false if workflowExecution is undefined + +// changed fields + +readonly activityNamespace: string // deprecated, same as namespace +readonly workflowNamespace?: string // deprecated, undefined if standalone +readonly workflowExecution?: interface { ... } // undefined if standalone +readonly workflowType?: string // undefined if standalone +``` + +B. `client.async-completion-client.FullActivityId` + +```tsx +export interface FullActivityId { + workflowId?: string; // undefined if standalone + runId?: string; // either workflow run ID or activity run ID + activityId: string; +} +``` + +C. `common.activity-options.ActivityOptions` + +- Documentation change: options for starting an activity in workflow. + - Open questions: + - Should the package be moved to `workflow.activity-options` and the old one deprecated? + - Should `client.activity-client.ActivityOptions` have its own package, or moved to `client.types`? \ No newline at end of file diff --git a/temporalio/activity.py b/temporalio/activity.py index ea6ce6458..d428104a3 100644 --- a/temporalio/activity.py +++ b/temporalio/activity.py @@ -22,12 +22,8 @@ from typing import ( TYPE_CHECKING, Any, - List, NoReturn, - Optional, - Tuple, Type, - Union, overload, ) @@ -109,16 +105,26 @@ class Info: heartbeat_details: Sequence[Any] heartbeat_timeout: timedelta | None is_local: bool + namespace: str + """Namespace the activity is running in.""" schedule_to_close_timeout: timedelta | None scheduled_time: datetime start_to_close_timeout: timedelta | None started_time: datetime task_queue: str task_token: bytes - workflow_id: str - workflow_namespace: str - workflow_run_id: str - workflow_type: str + workflow_id: str | None + """ID of the workflow that started this activity. None for standalone activities.""" + workflow_namespace: str | None + """Namespace of the workflow that started this activity. None for standalone activities. + + .. deprecated:: + Use :py:attr:`namespace` instead. + """ + workflow_run_id: str | None + """Run ID of the workflow that started this activity. None for standalone activities.""" + workflow_type: str | None + """Type of the workflow that started this activity. None for standalone activities.""" priority: temporalio.common.Priority retry_policy: temporalio.common.RetryPolicy | None """The retry policy of this activity. @@ -127,6 +133,14 @@ class Info: If the value is None, it means the server didn't send information about retry policy (e.g. due to old server version), but it may still be defined server-side.""" + activity_run_id: str | None = None + """Run ID of this standalone activity. None for workflow activities.""" + + @property + def in_workflow(self) -> bool: + """Whether this activity was started by a workflow (vs. standalone).""" + return self.workflow_id is not None + # TODO(cretz): Consider putting identity on here for "worker_id" for logger? def _logger_details(self) -> Mapping[str, Any]: @@ -134,7 +148,7 @@ def _logger_details(self) -> Mapping[str, Any]: "activity_id": self.activity_id, "activity_type": self.activity_type, "attempt": self.attempt, - "namespace": self.workflow_namespace, + "namespace": self.namespace, "task_queue": self.task_queue, "workflow_id": self.workflow_id, "workflow_run_id": self.workflow_run_id, @@ -243,7 +257,7 @@ def metric_meter(self) -> temporalio.common.MetricMeter: info = self.info() self._metric_meter = self.runtime_metric_meter.with_additional_attributes( { - "namespace": info.workflow_namespace, + "namespace": info.namespace, "task_queue": info.task_queue, "activity_type": info.activity_type, } @@ -582,6 +596,20 @@ def must_from_callable(fn: Callable) -> _Definition: f"Activity {fn_name} missing attributes, was it decorated with @activity.defn?" ) + @classmethod + def get_name_and_result_type( + cls, name_or_run_fn: str | Callable[..., Any] + ) -> tuple[str, Type | None]: + if isinstance(name_or_run_fn, str): + return name_or_run_fn, None + elif callable(name_or_run_fn): + defn = cls.must_from_callable(name_or_run_fn) + if not defn.name: + raise ValueError(f"Activity {name_or_run_fn} definition has no name") + return defn.name, defn.ret_type + else: + raise TypeError("Activity must be a string or callable") + @staticmethod def _apply_to_callable( fn: Callable, diff --git a/temporalio/api/activity/v1/__init__.py b/temporalio/api/activity/v1/__init__.py index a6e54842f..e86b0ef71 100644 --- a/temporalio/api/activity/v1/__init__.py +++ b/temporalio/api/activity/v1/__init__.py @@ -1,5 +1,13 @@ -from .message_pb2 import ActivityOptions +from .message_pb2 import ( + ActivityExecutionInfo, + ActivityExecutionListInfo, + ActivityExecutionOutcome, + ActivityOptions, +) __all__ = [ + "ActivityExecutionInfo", + "ActivityExecutionListInfo", + "ActivityExecutionOutcome", "ActivityOptions", ] diff --git a/temporalio/api/activity/v1/message_pb2.py b/temporalio/api/activity/v1/message_pb2.py index baf769c7c..a7209baed 100644 --- a/temporalio/api/activity/v1/message_pb2.py +++ b/temporalio/api/activity/v1/message_pb2.py @@ -15,20 +15,52 @@ from google.protobuf import duration_pb2 as google_dot_protobuf_dot_duration__pb2 +from google.protobuf import timestamp_pb2 as google_dot_protobuf_dot_timestamp__pb2 from temporalio.api.common.v1 import ( message_pb2 as temporal_dot_api_dot_common_dot_v1_dot_message__pb2, ) +from temporalio.api.deployment.v1 import ( + message_pb2 as temporal_dot_api_dot_deployment_dot_v1_dot_message__pb2, +) +from temporalio.api.enums.v1 import ( + activity_pb2 as temporal_dot_api_dot_enums_dot_v1_dot_activity__pb2, +) +from temporalio.api.enums.v1 import ( + workflow_pb2 as temporal_dot_api_dot_enums_dot_v1_dot_workflow__pb2, +) +from temporalio.api.failure.v1 import ( + message_pb2 as temporal_dot_api_dot_failure_dot_v1_dot_message__pb2, +) +from temporalio.api.sdk.v1 import ( + user_metadata_pb2 as temporal_dot_api_dot_sdk_dot_v1_dot_user__metadata__pb2, +) from temporalio.api.taskqueue.v1 import ( message_pb2 as temporal_dot_api_dot_taskqueue_dot_v1_dot_message__pb2, ) DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile( - b"\n&temporal/api/activity/v1/message.proto\x12\x18temporal.api.activity.v1\x1a$temporal/api/common/v1/message.proto\x1a'temporal/api/taskqueue/v1/message.proto\x1a\x1egoogle/protobuf/duration.proto\"\xf3\x02\n\x0f\x41\x63tivityOptions\x12\x38\n\ntask_queue\x18\x01 \x01(\x0b\x32$.temporal.api.taskqueue.v1.TaskQueue\x12<\n\x19schedule_to_close_timeout\x18\x02 \x01(\x0b\x32\x19.google.protobuf.Duration\x12<\n\x19schedule_to_start_timeout\x18\x03 \x01(\x0b\x32\x19.google.protobuf.Duration\x12\x39\n\x16start_to_close_timeout\x18\x04 \x01(\x0b\x32\x19.google.protobuf.Duration\x12\x34\n\x11heartbeat_timeout\x18\x05 \x01(\x0b\x32\x19.google.protobuf.Duration\x12\x39\n\x0cretry_policy\x18\x06 \x01(\x0b\x32#.temporal.api.common.v1.RetryPolicyB\x93\x01\n\x1bio.temporal.api.activity.v1B\x0cMessageProtoP\x01Z'go.temporal.io/api/activity/v1;activity\xaa\x02\x1aTemporalio.Api.Activity.V1\xea\x02\x1dTemporalio::Api::Activity::V1b\x06proto3" + b'\n&temporal/api/activity/v1/message.proto\x12\x18temporal.api.activity.v1\x1a\x1egoogle/protobuf/duration.proto\x1a\x1fgoogle/protobuf/timestamp.proto\x1a$temporal/api/common/v1/message.proto\x1a(temporal/api/deployment/v1/message.proto\x1a$temporal/api/enums/v1/activity.proto\x1a$temporal/api/enums/v1/workflow.proto\x1a%temporal/api/failure/v1/message.proto\x1a\'temporal/api/taskqueue/v1/message.proto\x1a\'temporal/api/sdk/v1/user_metadata.proto"\x8c\x01\n\x18\x41\x63tivityExecutionOutcome\x12\x32\n\x06result\x18\x01 \x01(\x0b\x32 .temporal.api.common.v1.PayloadsH\x00\x12\x33\n\x07\x66\x61ilure\x18\x02 \x01(\x0b\x32 .temporal.api.failure.v1.FailureH\x00\x42\x07\n\x05value"\xf3\x02\n\x0f\x41\x63tivityOptions\x12\x38\n\ntask_queue\x18\x01 \x01(\x0b\x32$.temporal.api.taskqueue.v1.TaskQueue\x12<\n\x19schedule_to_close_timeout\x18\x02 \x01(\x0b\x32\x19.google.protobuf.Duration\x12<\n\x19schedule_to_start_timeout\x18\x03 \x01(\x0b\x32\x19.google.protobuf.Duration\x12\x39\n\x16start_to_close_timeout\x18\x04 \x01(\x0b\x32\x19.google.protobuf.Duration\x12\x34\n\x11heartbeat_timeout\x18\x05 \x01(\x0b\x32\x19.google.protobuf.Duration\x12\x39\n\x0cretry_policy\x18\x06 \x01(\x0b\x32#.temporal.api.common.v1.RetryPolicy"\xdf\x0c\n\x15\x41\x63tivityExecutionInfo\x12\x13\n\x0b\x61\x63tivity_id\x18\x01 \x01(\t\x12\x0e\n\x06run_id\x18\x02 \x01(\t\x12;\n\ractivity_type\x18\x03 \x01(\x0b\x32$.temporal.api.common.v1.ActivityType\x12>\n\x06status\x18\x04 \x01(\x0e\x32..temporal.api.enums.v1.ActivityExecutionStatus\x12>\n\trun_state\x18\x05 \x01(\x0e\x32+.temporal.api.enums.v1.PendingActivityState\x12\x12\n\ntask_queue\x18\x06 \x01(\t\x12<\n\x19schedule_to_close_timeout\x18\x07 \x01(\x0b\x32\x19.google.protobuf.Duration\x12<\n\x19schedule_to_start_timeout\x18\x08 \x01(\x0b\x32\x19.google.protobuf.Duration\x12\x39\n\x16start_to_close_timeout\x18\t \x01(\x0b\x32\x19.google.protobuf.Duration\x12\x34\n\x11heartbeat_timeout\x18\n \x01(\x0b\x32\x19.google.protobuf.Duration\x12\x39\n\x0cretry_policy\x18\x0b \x01(\x0b\x32#.temporal.api.common.v1.RetryPolicy\x12;\n\x11heartbeat_details\x18\x0c \x01(\x0b\x32 .temporal.api.common.v1.Payloads\x12\x37\n\x13last_heartbeat_time\x18\r \x01(\x0b\x32\x1a.google.protobuf.Timestamp\x12\x35\n\x11last_started_time\x18\x0e \x01(\x0b\x32\x1a.google.protobuf.Timestamp\x12\x0f\n\x07\x61ttempt\x18\x0f \x01(\x05\x12\x35\n\x12\x65xecution_duration\x18\x10 \x01(\x0b\x32\x19.google.protobuf.Duration\x12\x31\n\rschedule_time\x18\x11 \x01(\x0b\x32\x1a.google.protobuf.Timestamp\x12\x33\n\x0f\x65xpiration_time\x18\x12 \x01(\x0b\x32\x1a.google.protobuf.Timestamp\x12.\n\nclose_time\x18\x13 \x01(\x0b\x32\x1a.google.protobuf.Timestamp\x12\x36\n\x0clast_failure\x18\x14 \x01(\x0b\x32 .temporal.api.failure.v1.Failure\x12\x1c\n\x14last_worker_identity\x18\x15 \x01(\t\x12\x39\n\x16\x63urrent_retry_interval\x18\x16 \x01(\x0b\x32\x19.google.protobuf.Duration\x12>\n\x1alast_attempt_complete_time\x18\x17 \x01(\x0b\x32\x1a.google.protobuf.Timestamp\x12>\n\x1anext_attempt_schedule_time\x18\x18 \x01(\x0b\x32\x1a.google.protobuf.Timestamp\x12T\n\x17last_deployment_version\x18\x19 \x01(\x0b\x32\x33.temporal.api.deployment.v1.WorkerDeploymentVersion\x12\x32\n\x08priority\x18\x1a \x01(\x0b\x32 .temporal.api.common.v1.Priority\x12\x1e\n\x16state_transition_count\x18\x1b \x01(\x03\x12\x18\n\x10state_size_bytes\x18\x1c \x01(\x03\x12\x43\n\x11search_attributes\x18\x1d \x01(\x0b\x32(.temporal.api.common.v1.SearchAttributes\x12.\n\x06header\x18\x1e \x01(\x0b\x32\x1e.temporal.api.common.v1.Header\x12\x38\n\ruser_metadata\x18\x1f \x01(\x0b\x32!.temporal.api.sdk.v1.UserMetadata\x12\x17\n\x0f\x63\x61nceled_reason\x18 \x01(\t"\xea\x03\n\x19\x41\x63tivityExecutionListInfo\x12\x13\n\x0b\x61\x63tivity_id\x18\x01 \x01(\t\x12\x0e\n\x06run_id\x18\x02 \x01(\t\x12;\n\ractivity_type\x18\x03 \x01(\x0b\x32$.temporal.api.common.v1.ActivityType\x12\x31\n\rschedule_time\x18\x04 \x01(\x0b\x32\x1a.google.protobuf.Timestamp\x12.\n\nclose_time\x18\x05 \x01(\x0b\x32\x1a.google.protobuf.Timestamp\x12>\n\x06status\x18\x06 \x01(\x0e\x32..temporal.api.enums.v1.ActivityExecutionStatus\x12\x43\n\x11search_attributes\x18\x07 \x01(\x0b\x32(.temporal.api.common.v1.SearchAttributes\x12\x12\n\ntask_queue\x18\x08 \x01(\t\x12\x1e\n\x16state_transition_count\x18\t \x01(\x03\x12\x18\n\x10state_size_bytes\x18\n \x01(\x03\x12\x35\n\x12\x65xecution_duration\x18\x0b \x01(\x0b\x32\x19.google.protobuf.DurationB\x93\x01\n\x1bio.temporal.api.activity.v1B\x0cMessageProtoP\x01Z\'go.temporal.io/api/activity/v1;activity\xaa\x02\x1aTemporalio.Api.Activity.V1\xea\x02\x1dTemporalio::Api::Activity::V1b\x06proto3' ) +_ACTIVITYEXECUTIONOUTCOME = DESCRIPTOR.message_types_by_name["ActivityExecutionOutcome"] _ACTIVITYOPTIONS = DESCRIPTOR.message_types_by_name["ActivityOptions"] +_ACTIVITYEXECUTIONINFO = DESCRIPTOR.message_types_by_name["ActivityExecutionInfo"] +_ACTIVITYEXECUTIONLISTINFO = DESCRIPTOR.message_types_by_name[ + "ActivityExecutionListInfo" +] +ActivityExecutionOutcome = _reflection.GeneratedProtocolMessageType( + "ActivityExecutionOutcome", + (_message.Message,), + { + "DESCRIPTOR": _ACTIVITYEXECUTIONOUTCOME, + "__module__": "temporalio.api.activity.v1.message_pb2", + # @@protoc_insertion_point(class_scope:temporal.api.activity.v1.ActivityExecutionOutcome) + }, +) +_sym_db.RegisterMessage(ActivityExecutionOutcome) + ActivityOptions = _reflection.GeneratedProtocolMessageType( "ActivityOptions", (_message.Message,), @@ -40,9 +72,37 @@ ) _sym_db.RegisterMessage(ActivityOptions) +ActivityExecutionInfo = _reflection.GeneratedProtocolMessageType( + "ActivityExecutionInfo", + (_message.Message,), + { + "DESCRIPTOR": _ACTIVITYEXECUTIONINFO, + "__module__": "temporalio.api.activity.v1.message_pb2", + # @@protoc_insertion_point(class_scope:temporal.api.activity.v1.ActivityExecutionInfo) + }, +) +_sym_db.RegisterMessage(ActivityExecutionInfo) + +ActivityExecutionListInfo = _reflection.GeneratedProtocolMessageType( + "ActivityExecutionListInfo", + (_message.Message,), + { + "DESCRIPTOR": _ACTIVITYEXECUTIONLISTINFO, + "__module__": "temporalio.api.activity.v1.message_pb2", + # @@protoc_insertion_point(class_scope:temporal.api.activity.v1.ActivityExecutionListInfo) + }, +) +_sym_db.RegisterMessage(ActivityExecutionListInfo) + if _descriptor._USE_C_DESCRIPTORS == False: DESCRIPTOR._options = None DESCRIPTOR._serialized_options = b"\n\033io.temporal.api.activity.v1B\014MessageProtoP\001Z'go.temporal.io/api/activity/v1;activity\252\002\032Temporalio.Api.Activity.V1\352\002\035Temporalio::Api::Activity::V1" - _ACTIVITYOPTIONS._serialized_start = 180 - _ACTIVITYOPTIONS._serialized_end = 551 + _ACTIVITYEXECUTIONOUTCOME._serialized_start = 411 + _ACTIVITYEXECUTIONOUTCOME._serialized_end = 551 + _ACTIVITYOPTIONS._serialized_start = 554 + _ACTIVITYOPTIONS._serialized_end = 925 + _ACTIVITYEXECUTIONINFO._serialized_start = 928 + _ACTIVITYEXECUTIONINFO._serialized_end = 2559 + _ACTIVITYEXECUTIONLISTINFO._serialized_start = 2562 + _ACTIVITYEXECUTIONLISTINFO._serialized_end = 3052 # @@protoc_insertion_point(module_scope) diff --git a/temporalio/api/activity/v1/message_pb2.pyi b/temporalio/api/activity/v1/message_pb2.pyi index 373c5f18f..387213c88 100644 --- a/temporalio/api/activity/v1/message_pb2.pyi +++ b/temporalio/api/activity/v1/message_pb2.pyi @@ -9,8 +9,14 @@ import sys import google.protobuf.descriptor import google.protobuf.duration_pb2 import google.protobuf.message +import google.protobuf.timestamp_pb2 import temporalio.api.common.v1.message_pb2 +import temporalio.api.deployment.v1.message_pb2 +import temporalio.api.enums.v1.activity_pb2 +import temporalio.api.enums.v1.workflow_pb2 +import temporalio.api.failure.v1.message_pb2 +import temporalio.api.sdk.v1.user_metadata_pb2 import temporalio.api.taskqueue.v1.message_pb2 if sys.version_info >= (3, 8): @@ -20,6 +26,43 @@ else: DESCRIPTOR: google.protobuf.descriptor.FileDescriptor +class ActivityExecutionOutcome(google.protobuf.message.Message): + """The outcome of a completed activity execution: either a successful result or a failure.""" + + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + RESULT_FIELD_NUMBER: builtins.int + FAILURE_FIELD_NUMBER: builtins.int + @property + def result(self) -> temporalio.api.common.v1.message_pb2.Payloads: + """The result if the activity completed successfully.""" + @property + def failure(self) -> temporalio.api.failure.v1.message_pb2.Failure: + """The failure if the activity completed unsuccessfully.""" + def __init__( + self, + *, + result: temporalio.api.common.v1.message_pb2.Payloads | None = ..., + failure: temporalio.api.failure.v1.message_pb2.Failure | None = ..., + ) -> None: ... + def HasField( + self, + field_name: typing_extensions.Literal[ + "failure", b"failure", "result", b"result", "value", b"value" + ], + ) -> builtins.bool: ... + def ClearField( + self, + field_name: typing_extensions.Literal[ + "failure", b"failure", "result", b"result", "value", b"value" + ], + ) -> None: ... + def WhichOneof( + self, oneof_group: typing_extensions.Literal["value", b"value"] + ) -> typing_extensions.Literal["result", "failure"] | None: ... + +global___ActivityExecutionOutcome = ActivityExecutionOutcome + class ActivityOptions(google.protobuf.message.Message): DESCRIPTOR: google.protobuf.descriptor.Descriptor @@ -62,7 +105,8 @@ class ActivityOptions(google.protobuf.message.Message): def heartbeat_timeout(self) -> google.protobuf.duration_pb2.Duration: """Maximum permitted time between successful worker heartbeats.""" @property - def retry_policy(self) -> temporalio.api.common.v1.message_pb2.RetryPolicy: ... + def retry_policy(self) -> temporalio.api.common.v1.message_pb2.RetryPolicy: + """The retry policy for the activity. Will never exceed `schedule_to_close_timeout`.""" def __init__( self, *, @@ -109,3 +153,426 @@ class ActivityOptions(google.protobuf.message.Message): ) -> None: ... global___ActivityOptions = ActivityOptions + +class ActivityExecutionInfo(google.protobuf.message.Message): + """Information about a standalone activity.""" + + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + ACTIVITY_ID_FIELD_NUMBER: builtins.int + RUN_ID_FIELD_NUMBER: builtins.int + ACTIVITY_TYPE_FIELD_NUMBER: builtins.int + STATUS_FIELD_NUMBER: builtins.int + RUN_STATE_FIELD_NUMBER: builtins.int + TASK_QUEUE_FIELD_NUMBER: builtins.int + SCHEDULE_TO_CLOSE_TIMEOUT_FIELD_NUMBER: builtins.int + SCHEDULE_TO_START_TIMEOUT_FIELD_NUMBER: builtins.int + START_TO_CLOSE_TIMEOUT_FIELD_NUMBER: builtins.int + HEARTBEAT_TIMEOUT_FIELD_NUMBER: builtins.int + RETRY_POLICY_FIELD_NUMBER: builtins.int + HEARTBEAT_DETAILS_FIELD_NUMBER: builtins.int + LAST_HEARTBEAT_TIME_FIELD_NUMBER: builtins.int + LAST_STARTED_TIME_FIELD_NUMBER: builtins.int + ATTEMPT_FIELD_NUMBER: builtins.int + EXECUTION_DURATION_FIELD_NUMBER: builtins.int + SCHEDULE_TIME_FIELD_NUMBER: builtins.int + EXPIRATION_TIME_FIELD_NUMBER: builtins.int + CLOSE_TIME_FIELD_NUMBER: builtins.int + LAST_FAILURE_FIELD_NUMBER: builtins.int + LAST_WORKER_IDENTITY_FIELD_NUMBER: builtins.int + CURRENT_RETRY_INTERVAL_FIELD_NUMBER: builtins.int + LAST_ATTEMPT_COMPLETE_TIME_FIELD_NUMBER: builtins.int + NEXT_ATTEMPT_SCHEDULE_TIME_FIELD_NUMBER: builtins.int + LAST_DEPLOYMENT_VERSION_FIELD_NUMBER: builtins.int + PRIORITY_FIELD_NUMBER: builtins.int + STATE_TRANSITION_COUNT_FIELD_NUMBER: builtins.int + STATE_SIZE_BYTES_FIELD_NUMBER: builtins.int + SEARCH_ATTRIBUTES_FIELD_NUMBER: builtins.int + HEADER_FIELD_NUMBER: builtins.int + USER_METADATA_FIELD_NUMBER: builtins.int + CANCELED_REASON_FIELD_NUMBER: builtins.int + activity_id: builtins.str + """Unique identifier of this activity within its namespace along with run ID (below).""" + run_id: builtins.str + @property + def activity_type(self) -> temporalio.api.common.v1.message_pb2.ActivityType: + """The type of the activity, a string that maps to a registered activity on a worker.""" + status: temporalio.api.enums.v1.activity_pb2.ActivityExecutionStatus.ValueType + """A general status for this activity, indicates whether it is currently running or in one of the terminal statuses.""" + run_state: temporalio.api.enums.v1.workflow_pb2.PendingActivityState.ValueType + """More detailed breakdown of ACTIVITY_EXECUTION_STATUS_RUNNING.""" + task_queue: builtins.str + @property + def schedule_to_close_timeout(self) -> google.protobuf.duration_pb2.Duration: + """Indicates how long the caller is willing to wait for an activity completion. Limits how long + retries will be attempted. + + (-- api-linter: core::0140::prepositions=disabled + aip.dev/not-precedent: "to" is used to indicate interval. --) + """ + @property + def schedule_to_start_timeout(self) -> google.protobuf.duration_pb2.Duration: + """Limits time an activity task can stay in a task queue before a worker picks it up. This + timeout is always non retryable, as all a retry would achieve is to put it back into the same + queue. Defaults to `schedule_to_close_timeout`. + + (-- api-linter: core::0140::prepositions=disabled + aip.dev/not-precedent: "to" is used to indicate interval. --) + """ + @property + def start_to_close_timeout(self) -> google.protobuf.duration_pb2.Duration: + """Maximum time a single activity attempt is allowed to execute after being picked up by a worker. This + timeout is always retryable. + + (-- api-linter: core::0140::prepositions=disabled + aip.dev/not-precedent: "to" is used to indicate interval. --) + """ + @property + def heartbeat_timeout(self) -> google.protobuf.duration_pb2.Duration: + """Maximum permitted time between successful worker heartbeats.""" + @property + def retry_policy(self) -> temporalio.api.common.v1.message_pb2.RetryPolicy: + """The retry policy for the activity. Will never exceed `schedule_to_close_timeout`.""" + @property + def heartbeat_details(self) -> temporalio.api.common.v1.message_pb2.Payloads: + """Details provided in the last recorded activity heartbeat.""" + @property + def last_heartbeat_time(self) -> google.protobuf.timestamp_pb2.Timestamp: + """Time the last heartbeat was recorded.""" + @property + def last_started_time(self) -> google.protobuf.timestamp_pb2.Timestamp: + """Time the last attempt was started.""" + attempt: builtins.int + """The attempt this activity is currently on. Incremented each time a new attempt is scheduled.""" + @property + def execution_duration(self) -> google.protobuf.duration_pb2.Duration: + """How long this activity has been running for, including all attempts and backoff between attempts.""" + @property + def schedule_time(self) -> google.protobuf.timestamp_pb2.Timestamp: + """Time the activity was originally scheduled via a StartActivityExecution request.""" + @property + def expiration_time(self) -> google.protobuf.timestamp_pb2.Timestamp: + """Scheduled time + schedule to close timeout.""" + @property + def close_time(self) -> google.protobuf.timestamp_pb2.Timestamp: + """Time when the activity transitioned to a closed state.""" + @property + def last_failure(self) -> temporalio.api.failure.v1.message_pb2.Failure: + """Failure details from the last failed attempt.""" + last_worker_identity: builtins.str + @property + def current_retry_interval(self) -> google.protobuf.duration_pb2.Duration: + """Time from the last attempt failure to the next activity retry. + If the activity is currently running, this represents the next retry interval in case the attempt fails. + If activity is currently backing off between attempt, this represents the current retry interval. + If there is no next retry allowed, this field will be null. + This interval is typically calculated from the specified retry policy, but may be modified if an activity fails + with a retryable application failure specifying a retry delay. + """ + @property + def last_attempt_complete_time(self) -> google.protobuf.timestamp_pb2.Timestamp: + """The time when the last activity attempt completed. If activity has not been completed yet, it will be null.""" + @property + def next_attempt_schedule_time(self) -> google.protobuf.timestamp_pb2.Timestamp: + """The time when the next activity attempt will be scheduled. + If activity is currently scheduled or started, this field will be null. + """ + @property + def last_deployment_version( + self, + ) -> temporalio.api.deployment.v1.message_pb2.WorkerDeploymentVersion: + """The Worker Deployment Version this activity was dispatched to most recently. + If nil, the activity has not yet been dispatched or was last dispatched to an unversioned worker. + """ + @property + def priority(self) -> temporalio.api.common.v1.message_pb2.Priority: + """Priority metadata.""" + state_transition_count: builtins.int + """Incremented each time the activity's state is mutated in persistence.""" + state_size_bytes: builtins.int + """Updated once on scheduled and once on terminal status.""" + @property + def search_attributes( + self, + ) -> temporalio.api.common.v1.message_pb2.SearchAttributes: ... + @property + def header(self) -> temporalio.api.common.v1.message_pb2.Header: ... + @property + def user_metadata(self) -> temporalio.api.sdk.v1.user_metadata_pb2.UserMetadata: + """Metadata for use by user interfaces to display the fixed as-of-start summary and details of the activity.""" + canceled_reason: builtins.str + """Set if activity cancelation was requested.""" + def __init__( + self, + *, + activity_id: builtins.str = ..., + run_id: builtins.str = ..., + activity_type: temporalio.api.common.v1.message_pb2.ActivityType | None = ..., + status: temporalio.api.enums.v1.activity_pb2.ActivityExecutionStatus.ValueType = ..., + run_state: temporalio.api.enums.v1.workflow_pb2.PendingActivityState.ValueType = ..., + task_queue: builtins.str = ..., + schedule_to_close_timeout: google.protobuf.duration_pb2.Duration | None = ..., + schedule_to_start_timeout: google.protobuf.duration_pb2.Duration | None = ..., + start_to_close_timeout: google.protobuf.duration_pb2.Duration | None = ..., + heartbeat_timeout: google.protobuf.duration_pb2.Duration | None = ..., + retry_policy: temporalio.api.common.v1.message_pb2.RetryPolicy | None = ..., + heartbeat_details: temporalio.api.common.v1.message_pb2.Payloads | None = ..., + last_heartbeat_time: google.protobuf.timestamp_pb2.Timestamp | None = ..., + last_started_time: google.protobuf.timestamp_pb2.Timestamp | None = ..., + attempt: builtins.int = ..., + execution_duration: google.protobuf.duration_pb2.Duration | None = ..., + schedule_time: google.protobuf.timestamp_pb2.Timestamp | None = ..., + expiration_time: google.protobuf.timestamp_pb2.Timestamp | None = ..., + close_time: google.protobuf.timestamp_pb2.Timestamp | None = ..., + last_failure: temporalio.api.failure.v1.message_pb2.Failure | None = ..., + last_worker_identity: builtins.str = ..., + current_retry_interval: google.protobuf.duration_pb2.Duration | None = ..., + last_attempt_complete_time: google.protobuf.timestamp_pb2.Timestamp + | None = ..., + next_attempt_schedule_time: google.protobuf.timestamp_pb2.Timestamp + | None = ..., + last_deployment_version: temporalio.api.deployment.v1.message_pb2.WorkerDeploymentVersion + | None = ..., + priority: temporalio.api.common.v1.message_pb2.Priority | None = ..., + state_transition_count: builtins.int = ..., + state_size_bytes: builtins.int = ..., + search_attributes: temporalio.api.common.v1.message_pb2.SearchAttributes + | None = ..., + header: temporalio.api.common.v1.message_pb2.Header | None = ..., + user_metadata: temporalio.api.sdk.v1.user_metadata_pb2.UserMetadata + | None = ..., + canceled_reason: builtins.str = ..., + ) -> None: ... + def HasField( + self, + field_name: typing_extensions.Literal[ + "activity_type", + b"activity_type", + "close_time", + b"close_time", + "current_retry_interval", + b"current_retry_interval", + "execution_duration", + b"execution_duration", + "expiration_time", + b"expiration_time", + "header", + b"header", + "heartbeat_details", + b"heartbeat_details", + "heartbeat_timeout", + b"heartbeat_timeout", + "last_attempt_complete_time", + b"last_attempt_complete_time", + "last_deployment_version", + b"last_deployment_version", + "last_failure", + b"last_failure", + "last_heartbeat_time", + b"last_heartbeat_time", + "last_started_time", + b"last_started_time", + "next_attempt_schedule_time", + b"next_attempt_schedule_time", + "priority", + b"priority", + "retry_policy", + b"retry_policy", + "schedule_time", + b"schedule_time", + "schedule_to_close_timeout", + b"schedule_to_close_timeout", + "schedule_to_start_timeout", + b"schedule_to_start_timeout", + "search_attributes", + b"search_attributes", + "start_to_close_timeout", + b"start_to_close_timeout", + "user_metadata", + b"user_metadata", + ], + ) -> builtins.bool: ... + def ClearField( + self, + field_name: typing_extensions.Literal[ + "activity_id", + b"activity_id", + "activity_type", + b"activity_type", + "attempt", + b"attempt", + "canceled_reason", + b"canceled_reason", + "close_time", + b"close_time", + "current_retry_interval", + b"current_retry_interval", + "execution_duration", + b"execution_duration", + "expiration_time", + b"expiration_time", + "header", + b"header", + "heartbeat_details", + b"heartbeat_details", + "heartbeat_timeout", + b"heartbeat_timeout", + "last_attempt_complete_time", + b"last_attempt_complete_time", + "last_deployment_version", + b"last_deployment_version", + "last_failure", + b"last_failure", + "last_heartbeat_time", + b"last_heartbeat_time", + "last_started_time", + b"last_started_time", + "last_worker_identity", + b"last_worker_identity", + "next_attempt_schedule_time", + b"next_attempt_schedule_time", + "priority", + b"priority", + "retry_policy", + b"retry_policy", + "run_id", + b"run_id", + "run_state", + b"run_state", + "schedule_time", + b"schedule_time", + "schedule_to_close_timeout", + b"schedule_to_close_timeout", + "schedule_to_start_timeout", + b"schedule_to_start_timeout", + "search_attributes", + b"search_attributes", + "start_to_close_timeout", + b"start_to_close_timeout", + "state_size_bytes", + b"state_size_bytes", + "state_transition_count", + b"state_transition_count", + "status", + b"status", + "task_queue", + b"task_queue", + "user_metadata", + b"user_metadata", + ], + ) -> None: ... + +global___ActivityExecutionInfo = ActivityExecutionInfo + +class ActivityExecutionListInfo(google.protobuf.message.Message): + """Limited activity information returned in the list response. + When adding fields here, ensure that it is also present in ActivityExecutionInfo (note that it + may already be present in ActivityExecutionInfo but not at the top-level). + """ + + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + ACTIVITY_ID_FIELD_NUMBER: builtins.int + RUN_ID_FIELD_NUMBER: builtins.int + ACTIVITY_TYPE_FIELD_NUMBER: builtins.int + SCHEDULE_TIME_FIELD_NUMBER: builtins.int + CLOSE_TIME_FIELD_NUMBER: builtins.int + STATUS_FIELD_NUMBER: builtins.int + SEARCH_ATTRIBUTES_FIELD_NUMBER: builtins.int + TASK_QUEUE_FIELD_NUMBER: builtins.int + STATE_TRANSITION_COUNT_FIELD_NUMBER: builtins.int + STATE_SIZE_BYTES_FIELD_NUMBER: builtins.int + EXECUTION_DURATION_FIELD_NUMBER: builtins.int + activity_id: builtins.str + """A unique identifier of this activity within its namespace along with run ID (below).""" + run_id: builtins.str + """The run ID of the standalone activity.""" + @property + def activity_type(self) -> temporalio.api.common.v1.message_pb2.ActivityType: + """The type of the activity, a string that maps to a registered activity on a worker.""" + @property + def schedule_time(self) -> google.protobuf.timestamp_pb2.Timestamp: + """Time the activity was originally scheduled via a StartActivityExecution request.""" + @property + def close_time(self) -> google.protobuf.timestamp_pb2.Timestamp: + """If the activity is in a terminal status, this field represents the time the activity transitioned to that status.""" + status: temporalio.api.enums.v1.activity_pb2.ActivityExecutionStatus.ValueType + """Only scheduled and terminal statuses appear here. More detailed information in PendingActivityInfo but not + available in the list response. + """ + @property + def search_attributes( + self, + ) -> temporalio.api.common.v1.message_pb2.SearchAttributes: + """Search attributes from the start request.""" + task_queue: builtins.str + """The task queue this activity was scheduled on when it was originally started, updated on activity options update.""" + state_transition_count: builtins.int + """Updated on terminal status.""" + state_size_bytes: builtins.int + """Updated once on scheduled and once on terminal status.""" + @property + def execution_duration(self) -> google.protobuf.duration_pb2.Duration: + """The difference between close time and scheduled time. + This field is only populated if the activity is closed. + """ + def __init__( + self, + *, + activity_id: builtins.str = ..., + run_id: builtins.str = ..., + activity_type: temporalio.api.common.v1.message_pb2.ActivityType | None = ..., + schedule_time: google.protobuf.timestamp_pb2.Timestamp | None = ..., + close_time: google.protobuf.timestamp_pb2.Timestamp | None = ..., + status: temporalio.api.enums.v1.activity_pb2.ActivityExecutionStatus.ValueType = ..., + search_attributes: temporalio.api.common.v1.message_pb2.SearchAttributes + | None = ..., + task_queue: builtins.str = ..., + state_transition_count: builtins.int = ..., + state_size_bytes: builtins.int = ..., + execution_duration: google.protobuf.duration_pb2.Duration | None = ..., + ) -> None: ... + def HasField( + self, + field_name: typing_extensions.Literal[ + "activity_type", + b"activity_type", + "close_time", + b"close_time", + "execution_duration", + b"execution_duration", + "schedule_time", + b"schedule_time", + "search_attributes", + b"search_attributes", + ], + ) -> builtins.bool: ... + def ClearField( + self, + field_name: typing_extensions.Literal[ + "activity_id", + b"activity_id", + "activity_type", + b"activity_type", + "close_time", + b"close_time", + "execution_duration", + b"execution_duration", + "run_id", + b"run_id", + "schedule_time", + b"schedule_time", + "search_attributes", + b"search_attributes", + "state_size_bytes", + b"state_size_bytes", + "state_transition_count", + b"state_transition_count", + "status", + b"status", + "task_queue", + b"task_queue", + ], + ) -> None: ... + +global___ActivityExecutionListInfo = ActivityExecutionListInfo diff --git a/temporalio/api/enums/v1/__init__.py b/temporalio/api/enums/v1/__init__.py index 156d02e86..7a8f96107 100644 --- a/temporalio/api/enums/v1/__init__.py +++ b/temporalio/api/enums/v1/__init__.py @@ -1,3 +1,8 @@ +from .activity_pb2 import ( + ActivityExecutionStatus, + ActivityIdConflictPolicy, + ActivityIdReusePolicy, +) from .batch_operation_pb2 import BatchOperationState, BatchOperationType from .command_type_pb2 import CommandType from .common_pb2 import ( @@ -55,6 +60,9 @@ ) __all__ = [ + "ActivityExecutionStatus", + "ActivityIdConflictPolicy", + "ActivityIdReusePolicy", "ApplicationErrorCategory", "ArchivalState", "BatchOperationState", diff --git a/temporalio/api/enums/v1/activity_pb2.py b/temporalio/api/enums/v1/activity_pb2.py new file mode 100644 index 000000000..ba5fddd25 --- /dev/null +++ b/temporalio/api/enums/v1/activity_pb2.py @@ -0,0 +1,53 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: temporal/api/enums/v1/activity.proto +"""Generated protocol buffer code.""" + +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import message as _message +from google.protobuf import reflection as _reflection +from google.protobuf import symbol_database as _symbol_database +from google.protobuf.internal import enum_type_wrapper + +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile( + b"\n$temporal/api/enums/v1/activity.proto\x12\x15temporal.api.enums.v1*\xb5\x02\n\x17\x41\x63tivityExecutionStatus\x12)\n%ACTIVITY_EXECUTION_STATUS_UNSPECIFIED\x10\x00\x12%\n!ACTIVITY_EXECUTION_STATUS_RUNNING\x10\x01\x12'\n#ACTIVITY_EXECUTION_STATUS_COMPLETED\x10\x02\x12$\n ACTIVITY_EXECUTION_STATUS_FAILED\x10\x03\x12&\n\"ACTIVITY_EXECUTION_STATUS_CANCELED\x10\x04\x12(\n$ACTIVITY_EXECUTION_STATUS_TERMINATED\x10\x05\x12'\n#ACTIVITY_EXECUTION_STATUS_TIMED_OUT\x10\x06*\xd8\x01\n\x15\x41\x63tivityIdReusePolicy\x12(\n$ACTIVITY_ID_REUSE_POLICY_UNSPECIFIED\x10\x00\x12,\n(ACTIVITY_ID_REUSE_POLICY_ALLOW_DUPLICATE\x10\x01\x12\x38\n4ACTIVITY_ID_REUSE_POLICY_ALLOW_DUPLICATE_FAILED_ONLY\x10\x02\x12-\n)ACTIVITY_ID_REUSE_POLICY_REJECT_DUPLICATE\x10\x03*\x9b\x01\n\x18\x41\x63tivityIdConflictPolicy\x12+\n'ACTIVITY_ID_CONFLICT_POLICY_UNSPECIFIED\x10\x00\x12$\n ACTIVITY_ID_CONFLICT_POLICY_FAIL\x10\x01\x12,\n(ACTIVITY_ID_CONFLICT_POLICY_USE_EXISTING\x10\x02\x42\x85\x01\n\x18io.temporal.api.enums.v1B\rActivityProtoP\x01Z!go.temporal.io/api/enums/v1;enums\xaa\x02\x17Temporalio.Api.Enums.V1\xea\x02\x1aTemporalio::Api::Enums::V1b\x06proto3" +) + +_ACTIVITYEXECUTIONSTATUS = DESCRIPTOR.enum_types_by_name["ActivityExecutionStatus"] +ActivityExecutionStatus = enum_type_wrapper.EnumTypeWrapper(_ACTIVITYEXECUTIONSTATUS) +_ACTIVITYIDREUSEPOLICY = DESCRIPTOR.enum_types_by_name["ActivityIdReusePolicy"] +ActivityIdReusePolicy = enum_type_wrapper.EnumTypeWrapper(_ACTIVITYIDREUSEPOLICY) +_ACTIVITYIDCONFLICTPOLICY = DESCRIPTOR.enum_types_by_name["ActivityIdConflictPolicy"] +ActivityIdConflictPolicy = enum_type_wrapper.EnumTypeWrapper(_ACTIVITYIDCONFLICTPOLICY) +ACTIVITY_EXECUTION_STATUS_UNSPECIFIED = 0 +ACTIVITY_EXECUTION_STATUS_RUNNING = 1 +ACTIVITY_EXECUTION_STATUS_COMPLETED = 2 +ACTIVITY_EXECUTION_STATUS_FAILED = 3 +ACTIVITY_EXECUTION_STATUS_CANCELED = 4 +ACTIVITY_EXECUTION_STATUS_TERMINATED = 5 +ACTIVITY_EXECUTION_STATUS_TIMED_OUT = 6 +ACTIVITY_ID_REUSE_POLICY_UNSPECIFIED = 0 +ACTIVITY_ID_REUSE_POLICY_ALLOW_DUPLICATE = 1 +ACTIVITY_ID_REUSE_POLICY_ALLOW_DUPLICATE_FAILED_ONLY = 2 +ACTIVITY_ID_REUSE_POLICY_REJECT_DUPLICATE = 3 +ACTIVITY_ID_CONFLICT_POLICY_UNSPECIFIED = 0 +ACTIVITY_ID_CONFLICT_POLICY_FAIL = 1 +ACTIVITY_ID_CONFLICT_POLICY_USE_EXISTING = 2 + + +if _descriptor._USE_C_DESCRIPTORS == False: + DESCRIPTOR._options = None + DESCRIPTOR._serialized_options = b"\n\030io.temporal.api.enums.v1B\rActivityProtoP\001Z!go.temporal.io/api/enums/v1;enums\252\002\027Temporalio.Api.Enums.V1\352\002\032Temporalio::Api::Enums::V1" + _ACTIVITYEXECUTIONSTATUS._serialized_start = 64 + _ACTIVITYEXECUTIONSTATUS._serialized_end = 373 + _ACTIVITYIDREUSEPOLICY._serialized_start = 376 + _ACTIVITYIDREUSEPOLICY._serialized_end = 592 + _ACTIVITYIDCONFLICTPOLICY._serialized_start = 595 + _ACTIVITYIDCONFLICTPOLICY._serialized_end = 750 +# @@protoc_insertion_point(module_scope) diff --git a/temporalio/api/enums/v1/activity_pb2.pyi b/temporalio/api/enums/v1/activity_pb2.pyi new file mode 100644 index 000000000..73d846050 --- /dev/null +++ b/temporalio/api/enums/v1/activity_pb2.pyi @@ -0,0 +1,192 @@ +""" +@generated by mypy-protobuf. Do not edit manually! +isort:skip_file +""" + +import builtins +import sys +import typing + +import google.protobuf.descriptor +import google.protobuf.internal.enum_type_wrapper + +if sys.version_info >= (3, 10): + import typing as typing_extensions +else: + import typing_extensions + +DESCRIPTOR: google.protobuf.descriptor.FileDescriptor + +class _ActivityExecutionStatus: + ValueType = typing.NewType("ValueType", builtins.int) + V: typing_extensions.TypeAlias = ValueType + +class _ActivityExecutionStatusEnumTypeWrapper( + google.protobuf.internal.enum_type_wrapper._EnumTypeWrapper[ + _ActivityExecutionStatus.ValueType + ], + builtins.type, +): # noqa: F821 + DESCRIPTOR: google.protobuf.descriptor.EnumDescriptor + ACTIVITY_EXECUTION_STATUS_UNSPECIFIED: _ActivityExecutionStatus.ValueType # 0 + ACTIVITY_EXECUTION_STATUS_RUNNING: _ActivityExecutionStatus.ValueType # 1 + """The activity has not reached a terminal status. See PendingActivityState for the run state + (SCHEDULED, STARTED, or CANCEL_REQUESTED). + """ + ACTIVITY_EXECUTION_STATUS_COMPLETED: _ActivityExecutionStatus.ValueType # 2 + """The activity completed successfully. An activity can complete even after cancellation is + requested if the worker calls RespondActivityTaskCompleted before acknowledging cancellation. + """ + ACTIVITY_EXECUTION_STATUS_FAILED: _ActivityExecutionStatus.ValueType # 3 + """The activity failed. Causes: + - Worker returned a non-retryable failure + - RetryPolicy.maximum_attempts exhausted + - Attempt failed after cancellation was requested (retries blocked) + """ + ACTIVITY_EXECUTION_STATUS_CANCELED: _ActivityExecutionStatus.ValueType # 4 + """The activity was canceled. Reached when: + - Cancellation requested while SCHEDULED (immediate), or + - Cancellation requested while STARTED and worker called RespondActivityTaskCanceled. + + Workers discover cancellation requests via heartbeat responses (cancel_requested=true). + Activities that do not heartbeat will not learn of cancellation and may complete, fail, or + time out normally. CANCELED requires explicit worker acknowledgment or immediate cancellation + of a SCHEDULED activity. + """ + ACTIVITY_EXECUTION_STATUS_TERMINATED: _ActivityExecutionStatus.ValueType # 5 + """The activity was terminated. Immediate; does not wait for worker acknowledgment.""" + ACTIVITY_EXECUTION_STATUS_TIMED_OUT: _ActivityExecutionStatus.ValueType # 6 + """The activity timed out. See TimeoutType for the specific timeout. + - SCHEDULE_TO_START and SCHEDULE_TO_CLOSE timeouts always result in TIMED_OUT. + - START_TO_CLOSE and HEARTBEAT may retry if RetryPolicy permits; TIMED_OUT is + reached when retry is blocked (RetryPolicy.maximum_attempts exhausted, + SCHEDULE_TO_CLOSE would be exceeded, or cancellation has been requested). + """ + +class ActivityExecutionStatus( + _ActivityExecutionStatus, metaclass=_ActivityExecutionStatusEnumTypeWrapper +): + """Status of a standalone activity. + The status is updated once, when the activity is originally scheduled, and again when the activity reaches a terminal + status. + (-- api-linter: core::0216::synonyms=disabled + aip.dev/not-precedent: Named consistently with WorkflowExecutionStatus. --) + """ + +ACTIVITY_EXECUTION_STATUS_UNSPECIFIED: ActivityExecutionStatus.ValueType # 0 +ACTIVITY_EXECUTION_STATUS_RUNNING: ActivityExecutionStatus.ValueType # 1 +"""The activity has not reached a terminal status. See PendingActivityState for the run state +(SCHEDULED, STARTED, or CANCEL_REQUESTED). +""" +ACTIVITY_EXECUTION_STATUS_COMPLETED: ActivityExecutionStatus.ValueType # 2 +"""The activity completed successfully. An activity can complete even after cancellation is +requested if the worker calls RespondActivityTaskCompleted before acknowledging cancellation. +""" +ACTIVITY_EXECUTION_STATUS_FAILED: ActivityExecutionStatus.ValueType # 3 +"""The activity failed. Causes: +- Worker returned a non-retryable failure +- RetryPolicy.maximum_attempts exhausted +- Attempt failed after cancellation was requested (retries blocked) +""" +ACTIVITY_EXECUTION_STATUS_CANCELED: ActivityExecutionStatus.ValueType # 4 +"""The activity was canceled. Reached when: +- Cancellation requested while SCHEDULED (immediate), or +- Cancellation requested while STARTED and worker called RespondActivityTaskCanceled. + +Workers discover cancellation requests via heartbeat responses (cancel_requested=true). +Activities that do not heartbeat will not learn of cancellation and may complete, fail, or +time out normally. CANCELED requires explicit worker acknowledgment or immediate cancellation +of a SCHEDULED activity. +""" +ACTIVITY_EXECUTION_STATUS_TERMINATED: ActivityExecutionStatus.ValueType # 5 +"""The activity was terminated. Immediate; does not wait for worker acknowledgment.""" +ACTIVITY_EXECUTION_STATUS_TIMED_OUT: ActivityExecutionStatus.ValueType # 6 +"""The activity timed out. See TimeoutType for the specific timeout. +- SCHEDULE_TO_START and SCHEDULE_TO_CLOSE timeouts always result in TIMED_OUT. +- START_TO_CLOSE and HEARTBEAT may retry if RetryPolicy permits; TIMED_OUT is + reached when retry is blocked (RetryPolicy.maximum_attempts exhausted, + SCHEDULE_TO_CLOSE would be exceeded, or cancellation has been requested). +""" +global___ActivityExecutionStatus = ActivityExecutionStatus + +class _ActivityIdReusePolicy: + ValueType = typing.NewType("ValueType", builtins.int) + V: typing_extensions.TypeAlias = ValueType + +class _ActivityIdReusePolicyEnumTypeWrapper( + google.protobuf.internal.enum_type_wrapper._EnumTypeWrapper[ + _ActivityIdReusePolicy.ValueType + ], + builtins.type, +): # noqa: F821 + DESCRIPTOR: google.protobuf.descriptor.EnumDescriptor + ACTIVITY_ID_REUSE_POLICY_UNSPECIFIED: _ActivityIdReusePolicy.ValueType # 0 + ACTIVITY_ID_REUSE_POLICY_ALLOW_DUPLICATE: _ActivityIdReusePolicy.ValueType # 1 + """Always allow starting an activity using the same activity ID.""" + ACTIVITY_ID_REUSE_POLICY_ALLOW_DUPLICATE_FAILED_ONLY: ( + _ActivityIdReusePolicy.ValueType + ) # 2 + """Allow starting an activity using the same ID only when the last activity's final state is one + of {failed, canceled, terminated, timed out}. + """ + ACTIVITY_ID_REUSE_POLICY_REJECT_DUPLICATE: _ActivityIdReusePolicy.ValueType # 3 + """Do not permit re-use of the ID for this activity. Future start requests could potentially change the policy, + allowing re-use of the ID. + """ + +class ActivityIdReusePolicy( + _ActivityIdReusePolicy, metaclass=_ActivityIdReusePolicyEnumTypeWrapper +): + """Defines whether to allow re-using an activity ID from a previously *closed* activity. + If the request is denied, the server returns an `ActivityExecutionAlreadyStarted` error. + + See `ActivityIdConflictPolicy` for handling ID duplication with a *running* activity. + """ + +ACTIVITY_ID_REUSE_POLICY_UNSPECIFIED: ActivityIdReusePolicy.ValueType # 0 +ACTIVITY_ID_REUSE_POLICY_ALLOW_DUPLICATE: ActivityIdReusePolicy.ValueType # 1 +"""Always allow starting an activity using the same activity ID.""" +ACTIVITY_ID_REUSE_POLICY_ALLOW_DUPLICATE_FAILED_ONLY: ( + ActivityIdReusePolicy.ValueType +) # 2 +"""Allow starting an activity using the same ID only when the last activity's final state is one +of {failed, canceled, terminated, timed out}. +""" +ACTIVITY_ID_REUSE_POLICY_REJECT_DUPLICATE: ActivityIdReusePolicy.ValueType # 3 +"""Do not permit re-use of the ID for this activity. Future start requests could potentially change the policy, +allowing re-use of the ID. +""" +global___ActivityIdReusePolicy = ActivityIdReusePolicy + +class _ActivityIdConflictPolicy: + ValueType = typing.NewType("ValueType", builtins.int) + V: typing_extensions.TypeAlias = ValueType + +class _ActivityIdConflictPolicyEnumTypeWrapper( + google.protobuf.internal.enum_type_wrapper._EnumTypeWrapper[ + _ActivityIdConflictPolicy.ValueType + ], + builtins.type, +): # noqa: F821 + DESCRIPTOR: google.protobuf.descriptor.EnumDescriptor + ACTIVITY_ID_CONFLICT_POLICY_UNSPECIFIED: _ActivityIdConflictPolicy.ValueType # 0 + ACTIVITY_ID_CONFLICT_POLICY_FAIL: _ActivityIdConflictPolicy.ValueType # 1 + """Don't start a new activity; instead return `ActivityExecutionAlreadyStarted` error.""" + ACTIVITY_ID_CONFLICT_POLICY_USE_EXISTING: _ActivityIdConflictPolicy.ValueType # 2 + """Don't start a new activity; instead return a handle for the running activity.""" + +class ActivityIdConflictPolicy( + _ActivityIdConflictPolicy, metaclass=_ActivityIdConflictPolicyEnumTypeWrapper +): + """Defines what to do when trying to start an activity with the same ID as a *running* activity. + Note that it is *never* valid to have two running instances of the same activity ID. + + See `ActivityIdReusePolicy` for handling activity ID duplication with a *closed* activity. + """ + +ACTIVITY_ID_CONFLICT_POLICY_UNSPECIFIED: ActivityIdConflictPolicy.ValueType # 0 +ACTIVITY_ID_CONFLICT_POLICY_FAIL: ActivityIdConflictPolicy.ValueType # 1 +"""Don't start a new activity; instead return `ActivityExecutionAlreadyStarted` error.""" +ACTIVITY_ID_CONFLICT_POLICY_USE_EXISTING: ActivityIdConflictPolicy.ValueType # 2 +"""Don't start a new activity; instead return a handle for the running activity.""" +global___ActivityIdConflictPolicy = ActivityIdConflictPolicy diff --git a/temporalio/api/errordetails/v1/__init__.py b/temporalio/api/errordetails/v1/__init__.py index 2afb6ec95..5d4b5671f 100644 --- a/temporalio/api/errordetails/v1/__init__.py +++ b/temporalio/api/errordetails/v1/__init__.py @@ -1,4 +1,5 @@ from .message_pb2 import ( + ActivityExecutionAlreadyStartedFailure, CancellationAlreadyRequestedFailure, ClientVersionNotSupportedFailure, MultiOperationExecutionFailure, @@ -19,6 +20,7 @@ ) __all__ = [ + "ActivityExecutionAlreadyStartedFailure", "CancellationAlreadyRequestedFailure", "ClientVersionNotSupportedFailure", "MultiOperationExecutionFailure", diff --git a/temporalio/api/errordetails/v1/message_pb2.py b/temporalio/api/errordetails/v1/message_pb2.py index 772238c02..669c4ff08 100644 --- a/temporalio/api/errordetails/v1/message_pb2.py +++ b/temporalio/api/errordetails/v1/message_pb2.py @@ -30,7 +30,7 @@ ) DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile( - b'\n*temporal/api/errordetails/v1/message.proto\x12\x1ctemporal.api.errordetails.v1\x1a\x19google/protobuf/any.proto\x1a$temporal/api/common/v1/message.proto\x1a(temporal/api/enums/v1/failed_cause.proto\x1a%temporal/api/enums/v1/namespace.proto\x1a%temporal/api/failure/v1/message.proto"B\n\x0fNotFoundFailure\x12\x17\n\x0f\x63urrent_cluster\x18\x01 \x01(\t\x12\x16\n\x0e\x61\x63tive_cluster\x18\x02 \x01(\t"R\n&WorkflowExecutionAlreadyStartedFailure\x12\x18\n\x10start_request_id\x18\x01 \x01(\t\x12\x0e\n\x06run_id\x18\x02 \x01(\t"_\n\x19NamespaceNotActiveFailure\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x17\n\x0f\x63urrent_cluster\x18\x02 \x01(\t\x12\x16\n\x0e\x61\x63tive_cluster\x18\x03 \x01(\t"0\n\x1bNamespaceUnavailableFailure\x12\x11\n\tnamespace\x18\x01 \x01(\t"\xa6\x01\n\x1cNamespaceInvalidStateFailure\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x34\n\x05state\x18\x02 \x01(\x0e\x32%.temporal.api.enums.v1.NamespaceState\x12=\n\x0e\x61llowed_states\x18\x03 \x03(\x0e\x32%.temporal.api.enums.v1.NamespaceState"-\n\x18NamespaceNotFoundFailure\x12\x11\n\tnamespace\x18\x01 \x01(\t"\x1f\n\x1dNamespaceAlreadyExistsFailure"k\n ClientVersionNotSupportedFailure\x12\x16\n\x0e\x63lient_version\x18\x01 \x01(\t\x12\x13\n\x0b\x63lient_name\x18\x02 \x01(\t\x12\x1a\n\x12supported_versions\x18\x03 \x01(\t"d\n ServerVersionNotSupportedFailure\x12\x16\n\x0eserver_version\x18\x01 \x01(\t\x12(\n client_supported_server_versions\x18\x02 \x01(\t"%\n#CancellationAlreadyRequestedFailure"G\n\x12QueryFailedFailure\x12\x31\n\x07\x66\x61ilure\x18\x01 \x01(\x0b\x32 .temporal.api.failure.v1.Failure")\n\x17PermissionDeniedFailure\x12\x0e\n\x06reason\x18\x01 \x01(\t"\x96\x01\n\x18ResourceExhaustedFailure\x12<\n\x05\x63\x61use\x18\x01 \x01(\x0e\x32-.temporal.api.enums.v1.ResourceExhaustedCause\x12<\n\x05scope\x18\x02 \x01(\x0e\x32-.temporal.api.enums.v1.ResourceExhaustedScope"v\n\x15SystemWorkflowFailure\x12\x45\n\x12workflow_execution\x18\x01 \x01(\x0b\x32).temporal.api.common.v1.WorkflowExecution\x12\x16\n\x0eworkflow_error\x18\x02 \x01(\t"\x19\n\x17WorkflowNotReadyFailure"3\n\x17NewerBuildExistsFailure\x12\x18\n\x10\x64\x65\x66\x61ult_build_id\x18\x01 \x01(\t"\xd9\x01\n\x1eMultiOperationExecutionFailure\x12^\n\x08statuses\x18\x01 \x03(\x0b\x32L.temporal.api.errordetails.v1.MultiOperationExecutionFailure.OperationStatus\x1aW\n\x0fOperationStatus\x12\x0c\n\x04\x63ode\x18\x01 \x01(\x05\x12\x0f\n\x07message\x18\x02 \x01(\t\x12%\n\x07\x64\x65tails\x18\x03 \x03(\x0b\x32\x14.google.protobuf.AnyB\xa7\x01\n\x1fio.temporal.api.errordetails.v1B\x0cMessageProtoP\x01Z/go.temporal.io/api/errordetails/v1;errordetails\xaa\x02\x1eTemporalio.Api.ErrorDetails.V1\xea\x02!Temporalio::Api::ErrorDetails::V1b\x06proto3' + b'\n*temporal/api/errordetails/v1/message.proto\x12\x1ctemporal.api.errordetails.v1\x1a\x19google/protobuf/any.proto\x1a$temporal/api/common/v1/message.proto\x1a(temporal/api/enums/v1/failed_cause.proto\x1a%temporal/api/enums/v1/namespace.proto\x1a%temporal/api/failure/v1/message.proto"B\n\x0fNotFoundFailure\x12\x17\n\x0f\x63urrent_cluster\x18\x01 \x01(\t\x12\x16\n\x0e\x61\x63tive_cluster\x18\x02 \x01(\t"R\n&WorkflowExecutionAlreadyStartedFailure\x12\x18\n\x10start_request_id\x18\x01 \x01(\t\x12\x0e\n\x06run_id\x18\x02 \x01(\t"_\n\x19NamespaceNotActiveFailure\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x17\n\x0f\x63urrent_cluster\x18\x02 \x01(\t\x12\x16\n\x0e\x61\x63tive_cluster\x18\x03 \x01(\t"0\n\x1bNamespaceUnavailableFailure\x12\x11\n\tnamespace\x18\x01 \x01(\t"\xa6\x01\n\x1cNamespaceInvalidStateFailure\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x34\n\x05state\x18\x02 \x01(\x0e\x32%.temporal.api.enums.v1.NamespaceState\x12=\n\x0e\x61llowed_states\x18\x03 \x03(\x0e\x32%.temporal.api.enums.v1.NamespaceState"-\n\x18NamespaceNotFoundFailure\x12\x11\n\tnamespace\x18\x01 \x01(\t"\x1f\n\x1dNamespaceAlreadyExistsFailure"k\n ClientVersionNotSupportedFailure\x12\x16\n\x0e\x63lient_version\x18\x01 \x01(\t\x12\x13\n\x0b\x63lient_name\x18\x02 \x01(\t\x12\x1a\n\x12supported_versions\x18\x03 \x01(\t"d\n ServerVersionNotSupportedFailure\x12\x16\n\x0eserver_version\x18\x01 \x01(\t\x12(\n client_supported_server_versions\x18\x02 \x01(\t"%\n#CancellationAlreadyRequestedFailure"G\n\x12QueryFailedFailure\x12\x31\n\x07\x66\x61ilure\x18\x01 \x01(\x0b\x32 .temporal.api.failure.v1.Failure")\n\x17PermissionDeniedFailure\x12\x0e\n\x06reason\x18\x01 \x01(\t"\x96\x01\n\x18ResourceExhaustedFailure\x12<\n\x05\x63\x61use\x18\x01 \x01(\x0e\x32-.temporal.api.enums.v1.ResourceExhaustedCause\x12<\n\x05scope\x18\x02 \x01(\x0e\x32-.temporal.api.enums.v1.ResourceExhaustedScope"v\n\x15SystemWorkflowFailure\x12\x45\n\x12workflow_execution\x18\x01 \x01(\x0b\x32).temporal.api.common.v1.WorkflowExecution\x12\x16\n\x0eworkflow_error\x18\x02 \x01(\t"\x19\n\x17WorkflowNotReadyFailure"3\n\x17NewerBuildExistsFailure\x12\x18\n\x10\x64\x65\x66\x61ult_build_id\x18\x01 \x01(\t"\xd9\x01\n\x1eMultiOperationExecutionFailure\x12^\n\x08statuses\x18\x01 \x03(\x0b\x32L.temporal.api.errordetails.v1.MultiOperationExecutionFailure.OperationStatus\x1aW\n\x0fOperationStatus\x12\x0c\n\x04\x63ode\x18\x01 \x01(\x05\x12\x0f\n\x07message\x18\x02 \x01(\t\x12%\n\x07\x64\x65tails\x18\x03 \x03(\x0b\x32\x14.google.protobuf.Any"R\n&ActivityExecutionAlreadyStartedFailure\x12\x18\n\x10start_request_id\x18\x01 \x01(\t\x12\x0e\n\x06run_id\x18\x02 \x01(\tB\xa7\x01\n\x1fio.temporal.api.errordetails.v1B\x0cMessageProtoP\x01Z/go.temporal.io/api/errordetails/v1;errordetails\xaa\x02\x1eTemporalio.Api.ErrorDetails.V1\xea\x02!Temporalio::Api::ErrorDetails::V1b\x06proto3' ) @@ -72,6 +72,9 @@ _MULTIOPERATIONEXECUTIONFAILURE_OPERATIONSTATUS = ( _MULTIOPERATIONEXECUTIONFAILURE.nested_types_by_name["OperationStatus"] ) +_ACTIVITYEXECUTIONALREADYSTARTEDFAILURE = DESCRIPTOR.message_types_by_name[ + "ActivityExecutionAlreadyStartedFailure" +] NotFoundFailure = _reflection.GeneratedProtocolMessageType( "NotFoundFailure", (_message.Message,), @@ -269,6 +272,17 @@ _sym_db.RegisterMessage(MultiOperationExecutionFailure) _sym_db.RegisterMessage(MultiOperationExecutionFailure.OperationStatus) +ActivityExecutionAlreadyStartedFailure = _reflection.GeneratedProtocolMessageType( + "ActivityExecutionAlreadyStartedFailure", + (_message.Message,), + { + "DESCRIPTOR": _ACTIVITYEXECUTIONALREADYSTARTEDFAILURE, + "__module__": "temporalio.api.errordetails.v1.message_pb2", + # @@protoc_insertion_point(class_scope:temporal.api.errordetails.v1.ActivityExecutionAlreadyStartedFailure) + }, +) +_sym_db.RegisterMessage(ActivityExecutionAlreadyStartedFailure) + if _descriptor._USE_C_DESCRIPTORS == False: DESCRIPTOR._options = None DESCRIPTOR._serialized_options = b"\n\037io.temporal.api.errordetails.v1B\014MessageProtoP\001Z/go.temporal.io/api/errordetails/v1;errordetails\252\002\036Temporalio.Api.ErrorDetails.V1\352\002!Temporalio::Api::ErrorDetails::V1" @@ -308,4 +322,6 @@ _MULTIOPERATIONEXECUTIONFAILURE._serialized_end = 1746 _MULTIOPERATIONEXECUTIONFAILURE_OPERATIONSTATUS._serialized_start = 1659 _MULTIOPERATIONEXECUTIONFAILURE_OPERATIONSTATUS._serialized_end = 1746 + _ACTIVITYEXECUTIONALREADYSTARTEDFAILURE._serialized_start = 1748 + _ACTIVITYEXECUTIONALREADYSTARTEDFAILURE._serialized_end = 1830 # @@protoc_insertion_point(module_scope) diff --git a/temporalio/api/errordetails/v1/message_pb2.pyi b/temporalio/api/errordetails/v1/message_pb2.pyi index 4857dbf31..a5e832d09 100644 --- a/temporalio/api/errordetails/v1/message_pb2.pyi +++ b/temporalio/api/errordetails/v1/message_pb2.pyi @@ -440,3 +440,30 @@ class MultiOperationExecutionFailure(google.protobuf.message.Message): ) -> None: ... global___MultiOperationExecutionFailure = MultiOperationExecutionFailure + +class ActivityExecutionAlreadyStartedFailure(google.protobuf.message.Message): + """An error indicating that an activity execution failed to start. Returned when there is an existing activity with the + given activity ID, and the given ID reuse and conflict policies do not permit starting a new one or attaching to an + existing one. + """ + + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + START_REQUEST_ID_FIELD_NUMBER: builtins.int + RUN_ID_FIELD_NUMBER: builtins.int + start_request_id: builtins.str + run_id: builtins.str + def __init__( + self, + *, + start_request_id: builtins.str = ..., + run_id: builtins.str = ..., + ) -> None: ... + def ClearField( + self, + field_name: typing_extensions.Literal[ + "run_id", b"run_id", "start_request_id", b"start_request_id" + ], + ) -> None: ... + +global___ActivityExecutionAlreadyStartedFailure = ActivityExecutionAlreadyStartedFailure diff --git a/temporalio/api/workflowservice/v1/__init__.py b/temporalio/api/workflowservice/v1/__init__.py index 0ca53de25..87f58ca56 100644 --- a/temporalio/api/workflowservice/v1/__init__.py +++ b/temporalio/api/workflowservice/v1/__init__.py @@ -1,10 +1,14 @@ from .request_response_pb2 import ( + CountActivityExecutionsRequest, + CountActivityExecutionsResponse, CountWorkflowExecutionsRequest, CountWorkflowExecutionsResponse, CreateScheduleRequest, CreateScheduleResponse, CreateWorkflowRuleRequest, CreateWorkflowRuleResponse, + DeleteActivityExecutionRequest, + DeleteActivityExecutionResponse, DeleteScheduleRequest, DeleteScheduleResponse, DeleteWorkerDeploymentRequest, @@ -17,6 +21,8 @@ DeleteWorkflowRuleResponse, DeprecateNamespaceRequest, DeprecateNamespaceResponse, + DescribeActivityExecutionRequest, + DescribeActivityExecutionResponse, DescribeBatchOperationRequest, DescribeBatchOperationResponse, DescribeDeploymentRequest, @@ -61,6 +67,8 @@ GetWorkflowExecutionHistoryResponse, GetWorkflowExecutionHistoryReverseRequest, GetWorkflowExecutionHistoryReverseResponse, + ListActivityExecutionsRequest, + ListActivityExecutionsResponse, ListArchivedWorkflowExecutionsRequest, ListArchivedWorkflowExecutionsResponse, ListBatchOperationsRequest, @@ -91,6 +99,8 @@ PatchScheduleResponse, PauseActivityRequest, PauseActivityResponse, + PollActivityExecutionRequest, + PollActivityExecutionResponse, PollActivityTaskQueueRequest, PollActivityTaskQueueResponse, PollNexusTaskQueueRequest, @@ -109,6 +119,8 @@ RecordWorkerHeartbeatResponse, RegisterNamespaceRequest, RegisterNamespaceResponse, + RequestCancelActivityExecutionRequest, + RequestCancelActivityExecutionResponse, RequestCancelWorkflowExecutionRequest, RequestCancelWorkflowExecutionResponse, ResetActivityRequest, @@ -155,12 +167,16 @@ SignalWithStartWorkflowExecutionResponse, SignalWorkflowExecutionRequest, SignalWorkflowExecutionResponse, + StartActivityExecutionRequest, + StartActivityExecutionResponse, StartBatchOperationRequest, StartBatchOperationResponse, StartWorkflowExecutionRequest, StartWorkflowExecutionResponse, StopBatchOperationRequest, StopBatchOperationResponse, + TerminateActivityExecutionRequest, + TerminateActivityExecutionResponse, TerminateWorkflowExecutionRequest, TerminateWorkflowExecutionResponse, TriggerWorkflowRuleRequest, @@ -190,12 +206,16 @@ ) __all__ = [ + "CountActivityExecutionsRequest", + "CountActivityExecutionsResponse", "CountWorkflowExecutionsRequest", "CountWorkflowExecutionsResponse", "CreateScheduleRequest", "CreateScheduleResponse", "CreateWorkflowRuleRequest", "CreateWorkflowRuleResponse", + "DeleteActivityExecutionRequest", + "DeleteActivityExecutionResponse", "DeleteScheduleRequest", "DeleteScheduleResponse", "DeleteWorkerDeploymentRequest", @@ -208,6 +228,8 @@ "DeleteWorkflowRuleResponse", "DeprecateNamespaceRequest", "DeprecateNamespaceResponse", + "DescribeActivityExecutionRequest", + "DescribeActivityExecutionResponse", "DescribeBatchOperationRequest", "DescribeBatchOperationResponse", "DescribeDeploymentRequest", @@ -252,6 +274,8 @@ "GetWorkflowExecutionHistoryResponse", "GetWorkflowExecutionHistoryReverseRequest", "GetWorkflowExecutionHistoryReverseResponse", + "ListActivityExecutionsRequest", + "ListActivityExecutionsResponse", "ListArchivedWorkflowExecutionsRequest", "ListArchivedWorkflowExecutionsResponse", "ListBatchOperationsRequest", @@ -282,6 +306,8 @@ "PatchScheduleResponse", "PauseActivityRequest", "PauseActivityResponse", + "PollActivityExecutionRequest", + "PollActivityExecutionResponse", "PollActivityTaskQueueRequest", "PollActivityTaskQueueResponse", "PollNexusTaskQueueRequest", @@ -300,6 +326,8 @@ "RecordWorkerHeartbeatResponse", "RegisterNamespaceRequest", "RegisterNamespaceResponse", + "RequestCancelActivityExecutionRequest", + "RequestCancelActivityExecutionResponse", "RequestCancelWorkflowExecutionRequest", "RequestCancelWorkflowExecutionResponse", "ResetActivityRequest", @@ -346,12 +374,16 @@ "SignalWithStartWorkflowExecutionResponse", "SignalWorkflowExecutionRequest", "SignalWorkflowExecutionResponse", + "StartActivityExecutionRequest", + "StartActivityExecutionResponse", "StartBatchOperationRequest", "StartBatchOperationResponse", "StartWorkflowExecutionRequest", "StartWorkflowExecutionResponse", "StopBatchOperationRequest", "StopBatchOperationResponse", + "TerminateActivityExecutionRequest", + "TerminateActivityExecutionResponse", "TerminateWorkflowExecutionRequest", "TerminateWorkflowExecutionResponse", "TriggerWorkflowRuleRequest", diff --git a/temporalio/api/workflowservice/v1/request_response_pb2.py b/temporalio/api/workflowservice/v1/request_response_pb2.py index c7cce3d1a..7660eefb2 100644 --- a/temporalio/api/workflowservice/v1/request_response_pb2.py +++ b/temporalio/api/workflowservice/v1/request_response_pb2.py @@ -33,6 +33,9 @@ from temporalio.api.deployment.v1 import ( message_pb2 as temporal_dot_api_dot_deployment_dot_v1_dot_message__pb2, ) +from temporalio.api.enums.v1 import ( + activity_pb2 as temporal_dot_api_dot_enums_dot_v1_dot_activity__pb2, +) from temporalio.api.enums.v1 import ( batch_operation_pb2 as temporal_dot_api_dot_enums_dot_v1_dot_batch__operation__pb2, ) @@ -119,7 +122,7 @@ ) DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile( - b'\n6temporal/api/workflowservice/v1/request_response.proto\x12\x1ftemporal.api.workflowservice.v1\x1a+temporal/api/enums/v1/batch_operation.proto\x1a"temporal/api/enums/v1/common.proto\x1a$temporal/api/enums/v1/workflow.proto\x1a%temporal/api/enums/v1/namespace.proto\x1a(temporal/api/enums/v1/failed_cause.proto\x1a!temporal/api/enums/v1/query.proto\x1a!temporal/api/enums/v1/reset.proto\x1a&temporal/api/enums/v1/task_queue.proto\x1a&temporal/api/enums/v1/deployment.proto\x1a"temporal/api/enums/v1/update.proto\x1a&temporal/api/activity/v1/message.proto\x1a$temporal/api/common/v1/message.proto\x1a%temporal/api/history/v1/message.proto\x1a&temporal/api/workflow/v1/message.proto\x1a%temporal/api/command/v1/message.proto\x1a(temporal/api/deployment/v1/message.proto\x1a%temporal/api/failure/v1/message.proto\x1a$temporal/api/filter/v1/message.proto\x1a&temporal/api/protocol/v1/message.proto\x1a\'temporal/api/namespace/v1/message.proto\x1a#temporal/api/query/v1/message.proto\x1a)temporal/api/replication/v1/message.proto\x1a#temporal/api/rules/v1/message.proto\x1a\'temporal/api/sdk/v1/worker_config.proto\x1a&temporal/api/schedule/v1/message.proto\x1a\'temporal/api/taskqueue/v1/message.proto\x1a$temporal/api/update/v1/message.proto\x1a%temporal/api/version/v1/message.proto\x1a#temporal/api/batch/v1/message.proto\x1a\x30temporal/api/sdk/v1/task_complete_metadata.proto\x1a\'temporal/api/sdk/v1/user_metadata.proto\x1a#temporal/api/nexus/v1/message.proto\x1a$temporal/api/worker/v1/message.proto\x1a\x1egoogle/protobuf/duration.proto\x1a google/protobuf/field_mask.proto\x1a\x1fgoogle/protobuf/timestamp.proto"\x88\x05\n\x18RegisterNamespaceRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x13\n\x0b\x64\x65scription\x18\x02 \x01(\t\x12\x13\n\x0bowner_email\x18\x03 \x01(\t\x12\x46\n#workflow_execution_retention_period\x18\x04 \x01(\x0b\x32\x19.google.protobuf.Duration\x12G\n\x08\x63lusters\x18\x05 \x03(\x0b\x32\x35.temporal.api.replication.v1.ClusterReplicationConfig\x12\x1b\n\x13\x61\x63tive_cluster_name\x18\x06 \x01(\t\x12Q\n\x04\x64\x61ta\x18\x07 \x03(\x0b\x32\x43.temporal.api.workflowservice.v1.RegisterNamespaceRequest.DataEntry\x12\x16\n\x0esecurity_token\x18\x08 \x01(\t\x12\x1b\n\x13is_global_namespace\x18\t \x01(\x08\x12\x44\n\x16history_archival_state\x18\n \x01(\x0e\x32$.temporal.api.enums.v1.ArchivalState\x12\x1c\n\x14history_archival_uri\x18\x0b \x01(\t\x12G\n\x19visibility_archival_state\x18\x0c \x01(\x0e\x32$.temporal.api.enums.v1.ArchivalState\x12\x1f\n\x17visibility_archival_uri\x18\r \x01(\t\x1a+\n\tDataEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\t:\x02\x38\x01"\x1b\n\x19RegisterNamespaceResponse"\x89\x01\n\x15ListNamespacesRequest\x12\x11\n\tpage_size\x18\x01 \x01(\x05\x12\x17\n\x0fnext_page_token\x18\x02 \x01(\x0c\x12\x44\n\x10namespace_filter\x18\x03 \x01(\x0b\x32*.temporal.api.namespace.v1.NamespaceFilter"\x81\x01\n\x16ListNamespacesResponse\x12N\n\nnamespaces\x18\x01 \x03(\x0b\x32:.temporal.api.workflowservice.v1.DescribeNamespaceResponse\x12\x17\n\x0fnext_page_token\x18\x02 \x01(\x0c"9\n\x18\x44\x65scribeNamespaceRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\n\n\x02id\x18\x02 \x01(\t"\xec\x02\n\x19\x44\x65scribeNamespaceResponse\x12@\n\x0enamespace_info\x18\x01 \x01(\x0b\x32(.temporal.api.namespace.v1.NamespaceInfo\x12:\n\x06\x63onfig\x18\x02 \x01(\x0b\x32*.temporal.api.namespace.v1.NamespaceConfig\x12S\n\x12replication_config\x18\x03 \x01(\x0b\x32\x37.temporal.api.replication.v1.NamespaceReplicationConfig\x12\x18\n\x10\x66\x61ilover_version\x18\x04 \x01(\x03\x12\x1b\n\x13is_global_namespace\x18\x05 \x01(\x08\x12\x45\n\x10\x66\x61ilover_history\x18\x06 \x03(\x0b\x32+.temporal.api.replication.v1.FailoverStatus"\xcf\x02\n\x16UpdateNamespaceRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x43\n\x0bupdate_info\x18\x02 \x01(\x0b\x32..temporal.api.namespace.v1.UpdateNamespaceInfo\x12:\n\x06\x63onfig\x18\x03 \x01(\x0b\x32*.temporal.api.namespace.v1.NamespaceConfig\x12S\n\x12replication_config\x18\x04 \x01(\x0b\x32\x37.temporal.api.replication.v1.NamespaceReplicationConfig\x12\x16\n\x0esecurity_token\x18\x05 \x01(\t\x12\x19\n\x11\x64\x65lete_bad_binary\x18\x06 \x01(\t\x12\x19\n\x11promote_namespace\x18\x07 \x01(\x08"\xa3\x02\n\x17UpdateNamespaceResponse\x12@\n\x0enamespace_info\x18\x01 \x01(\x0b\x32(.temporal.api.namespace.v1.NamespaceInfo\x12:\n\x06\x63onfig\x18\x02 \x01(\x0b\x32*.temporal.api.namespace.v1.NamespaceConfig\x12S\n\x12replication_config\x18\x03 \x01(\x0b\x32\x37.temporal.api.replication.v1.NamespaceReplicationConfig\x12\x18\n\x10\x66\x61ilover_version\x18\x04 \x01(\x03\x12\x1b\n\x13is_global_namespace\x18\x05 \x01(\x08"F\n\x19\x44\x65precateNamespaceRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x16\n\x0esecurity_token\x18\x02 \x01(\t"\x1c\n\x1a\x44\x65precateNamespaceResponse"\x87\x0c\n\x1dStartWorkflowExecutionRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x13\n\x0bworkflow_id\x18\x02 \x01(\t\x12;\n\rworkflow_type\x18\x03 \x01(\x0b\x32$.temporal.api.common.v1.WorkflowType\x12\x38\n\ntask_queue\x18\x04 \x01(\x0b\x32$.temporal.api.taskqueue.v1.TaskQueue\x12/\n\x05input\x18\x05 \x01(\x0b\x32 .temporal.api.common.v1.Payloads\x12=\n\x1aworkflow_execution_timeout\x18\x06 \x01(\x0b\x32\x19.google.protobuf.Duration\x12\x37\n\x14workflow_run_timeout\x18\x07 \x01(\x0b\x32\x19.google.protobuf.Duration\x12\x38\n\x15workflow_task_timeout\x18\x08 \x01(\x0b\x32\x19.google.protobuf.Duration\x12\x10\n\x08identity\x18\t \x01(\t\x12\x12\n\nrequest_id\x18\n \x01(\t\x12N\n\x18workflow_id_reuse_policy\x18\x0b \x01(\x0e\x32,.temporal.api.enums.v1.WorkflowIdReusePolicy\x12T\n\x1bworkflow_id_conflict_policy\x18\x16 \x01(\x0e\x32/.temporal.api.enums.v1.WorkflowIdConflictPolicy\x12\x39\n\x0cretry_policy\x18\x0c \x01(\x0b\x32#.temporal.api.common.v1.RetryPolicy\x12\x15\n\rcron_schedule\x18\r \x01(\t\x12*\n\x04memo\x18\x0e \x01(\x0b\x32\x1c.temporal.api.common.v1.Memo\x12\x43\n\x11search_attributes\x18\x0f \x01(\x0b\x32(.temporal.api.common.v1.SearchAttributes\x12.\n\x06header\x18\x10 \x01(\x0b\x32\x1e.temporal.api.common.v1.Header\x12\x1f\n\x17request_eager_execution\x18\x11 \x01(\x08\x12;\n\x11\x63ontinued_failure\x18\x12 \x01(\x0b\x32 .temporal.api.failure.v1.Failure\x12@\n\x16last_completion_result\x18\x13 \x01(\x0b\x32 .temporal.api.common.v1.Payloads\x12\x37\n\x14workflow_start_delay\x18\x14 \x01(\x0b\x32\x19.google.protobuf.Duration\x12>\n\x14\x63ompletion_callbacks\x18\x15 \x03(\x0b\x32 .temporal.api.common.v1.Callback\x12\x38\n\ruser_metadata\x18\x17 \x01(\x0b\x32!.temporal.api.sdk.v1.UserMetadata\x12+\n\x05links\x18\x18 \x03(\x0b\x32\x1c.temporal.api.common.v1.Link\x12I\n\x13versioning_override\x18\x19 \x01(\x0b\x32,.temporal.api.workflow.v1.VersioningOverride\x12H\n\x13on_conflict_options\x18\x1a \x01(\x0b\x32+.temporal.api.workflow.v1.OnConflictOptions\x12\x32\n\x08priority\x18\x1b \x01(\x0b\x32 .temporal.api.common.v1.Priority\x12\\\n\x1f\x65\x61ger_worker_deployment_options\x18\x1c \x01(\x0b\x32\x33.temporal.api.deployment.v1.WorkerDeploymentOptions"\x8a\x02\n\x1eStartWorkflowExecutionResponse\x12\x0e\n\x06run_id\x18\x01 \x01(\t\x12\x0f\n\x07started\x18\x03 \x01(\x08\x12>\n\x06status\x18\x05 \x01(\x0e\x32..temporal.api.enums.v1.WorkflowExecutionStatus\x12[\n\x13\x65\x61ger_workflow_task\x18\x02 \x01(\x0b\x32>.temporal.api.workflowservice.v1.PollWorkflowTaskQueueResponse\x12*\n\x04link\x18\x04 \x01(\x0b\x32\x1c.temporal.api.common.v1.Link"\xaa\x02\n"GetWorkflowExecutionHistoryRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12<\n\texecution\x18\x02 \x01(\x0b\x32).temporal.api.common.v1.WorkflowExecution\x12\x19\n\x11maximum_page_size\x18\x03 \x01(\x05\x12\x17\n\x0fnext_page_token\x18\x04 \x01(\x0c\x12\x16\n\x0ewait_new_event\x18\x05 \x01(\x08\x12P\n\x19history_event_filter_type\x18\x06 \x01(\x0e\x32-.temporal.api.enums.v1.HistoryEventFilterType\x12\x15\n\rskip_archival\x18\x07 \x01(\x08"\xba\x01\n#GetWorkflowExecutionHistoryResponse\x12\x31\n\x07history\x18\x01 \x01(\x0b\x32 .temporal.api.history.v1.History\x12\x35\n\x0braw_history\x18\x02 \x03(\x0b\x32 .temporal.api.common.v1.DataBlob\x12\x17\n\x0fnext_page_token\x18\x03 \x01(\x0c\x12\x10\n\x08\x61rchived\x18\x04 \x01(\x08"\xb0\x01\n)GetWorkflowExecutionHistoryReverseRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12<\n\texecution\x18\x02 \x01(\x0b\x32).temporal.api.common.v1.WorkflowExecution\x12\x19\n\x11maximum_page_size\x18\x03 \x01(\x05\x12\x17\n\x0fnext_page_token\x18\x04 \x01(\x0c"x\n*GetWorkflowExecutionHistoryReverseResponse\x12\x31\n\x07history\x18\x01 \x01(\x0b\x32 .temporal.api.history.v1.History\x12\x17\n\x0fnext_page_token\x18\x03 \x01(\x0c"\x8a\x03\n\x1cPollWorkflowTaskQueueRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x38\n\ntask_queue\x18\x02 \x01(\x0b\x32$.temporal.api.taskqueue.v1.TaskQueue\x12\x10\n\x08identity\x18\x03 \x01(\t\x12\x1b\n\x0f\x62inary_checksum\x18\x04 \x01(\tB\x02\x18\x01\x12Z\n\x1bworker_version_capabilities\x18\x05 \x01(\x0b\x32\x31.temporal.api.common.v1.WorkerVersionCapabilitiesB\x02\x18\x01\x12O\n\x12\x64\x65ployment_options\x18\x06 \x01(\x0b\x32\x33.temporal.api.deployment.v1.WorkerDeploymentOptions\x12\x41\n\x10worker_heartbeat\x18\x07 \x01(\x0b\x32\'.temporal.api.worker.v1.WorkerHeartbeat"\x91\x07\n\x1dPollWorkflowTaskQueueResponse\x12\x12\n\ntask_token\x18\x01 \x01(\x0c\x12\x45\n\x12workflow_execution\x18\x02 \x01(\x0b\x32).temporal.api.common.v1.WorkflowExecution\x12;\n\rworkflow_type\x18\x03 \x01(\x0b\x32$.temporal.api.common.v1.WorkflowType\x12!\n\x19previous_started_event_id\x18\x04 \x01(\x03\x12\x18\n\x10started_event_id\x18\x05 \x01(\x03\x12\x0f\n\x07\x61ttempt\x18\x06 \x01(\x05\x12\x1a\n\x12\x62\x61\x63klog_count_hint\x18\x07 \x01(\x03\x12\x31\n\x07history\x18\x08 \x01(\x0b\x32 .temporal.api.history.v1.History\x12\x17\n\x0fnext_page_token\x18\t \x01(\x0c\x12\x33\n\x05query\x18\n \x01(\x0b\x32$.temporal.api.query.v1.WorkflowQuery\x12K\n\x1dworkflow_execution_task_queue\x18\x0b \x01(\x0b\x32$.temporal.api.taskqueue.v1.TaskQueue\x12\x32\n\x0escheduled_time\x18\x0c \x01(\x0b\x32\x1a.google.protobuf.Timestamp\x12\x30\n\x0cstarted_time\x18\r \x01(\x0b\x32\x1a.google.protobuf.Timestamp\x12\\\n\x07queries\x18\x0e \x03(\x0b\x32K.temporal.api.workflowservice.v1.PollWorkflowTaskQueueResponse.QueriesEntry\x12\x33\n\x08messages\x18\x0f \x03(\x0b\x32!.temporal.api.protocol.v1.Message\x12Q\n\x17poller_scaling_decision\x18\x10 \x01(\x0b\x32\x30.temporal.api.taskqueue.v1.PollerScalingDecision\x1aT\n\x0cQueriesEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\x33\n\x05value\x18\x02 \x01(\x0b\x32$.temporal.api.query.v1.WorkflowQuery:\x02\x38\x01"\xb5\t\n#RespondWorkflowTaskCompletedRequest\x12\x12\n\ntask_token\x18\x01 \x01(\x0c\x12\x32\n\x08\x63ommands\x18\x02 \x03(\x0b\x32 .temporal.api.command.v1.Command\x12\x10\n\x08identity\x18\x03 \x01(\t\x12O\n\x11sticky_attributes\x18\x04 \x01(\x0b\x32\x34.temporal.api.taskqueue.v1.StickyExecutionAttributes\x12 \n\x18return_new_workflow_task\x18\x05 \x01(\x08\x12&\n\x1e\x66orce_create_new_workflow_task\x18\x06 \x01(\x08\x12\x1b\n\x0f\x62inary_checksum\x18\x07 \x01(\tB\x02\x18\x01\x12m\n\rquery_results\x18\x08 \x03(\x0b\x32V.temporal.api.workflowservice.v1.RespondWorkflowTaskCompletedRequest.QueryResultsEntry\x12\x11\n\tnamespace\x18\t \x01(\t\x12L\n\x14worker_version_stamp\x18\n \x01(\x0b\x32*.temporal.api.common.v1.WorkerVersionStampB\x02\x18\x01\x12\x33\n\x08messages\x18\x0b \x03(\x0b\x32!.temporal.api.protocol.v1.Message\x12H\n\x0csdk_metadata\x18\x0c \x01(\x0b\x32\x32.temporal.api.sdk.v1.WorkflowTaskCompletedMetadata\x12\x43\n\x11metering_metadata\x18\r \x01(\x0b\x32(.temporal.api.common.v1.MeteringMetadata\x12g\n\x0c\x63\x61pabilities\x18\x0e \x01(\x0b\x32Q.temporal.api.workflowservice.v1.RespondWorkflowTaskCompletedRequest.Capabilities\x12>\n\ndeployment\x18\x0f \x01(\x0b\x32&.temporal.api.deployment.v1.DeploymentB\x02\x18\x01\x12\x46\n\x13versioning_behavior\x18\x10 \x01(\x0e\x32).temporal.api.enums.v1.VersioningBehavior\x12O\n\x12\x64\x65ployment_options\x18\x11 \x01(\x0b\x32\x33.temporal.api.deployment.v1.WorkerDeploymentOptions\x1a_\n\x11QueryResultsEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\x39\n\x05value\x18\x02 \x01(\x0b\x32*.temporal.api.query.v1.WorkflowQueryResult:\x02\x38\x01\x1a\x45\n\x0c\x43\x61pabilities\x12\x35\n-discard_speculative_workflow_task_with_events\x18\x01 \x01(\x08"\xf5\x01\n$RespondWorkflowTaskCompletedResponse\x12U\n\rworkflow_task\x18\x01 \x01(\x0b\x32>.temporal.api.workflowservice.v1.PollWorkflowTaskQueueResponse\x12V\n\x0e\x61\x63tivity_tasks\x18\x02 \x03(\x0b\x32>.temporal.api.workflowservice.v1.PollActivityTaskQueueResponse\x12\x1e\n\x16reset_history_event_id\x18\x03 \x01(\x03"\xf8\x03\n RespondWorkflowTaskFailedRequest\x12\x12\n\ntask_token\x18\x01 \x01(\x0c\x12=\n\x05\x63\x61use\x18\x02 \x01(\x0e\x32..temporal.api.enums.v1.WorkflowTaskFailedCause\x12\x31\n\x07\x66\x61ilure\x18\x03 \x01(\x0b\x32 .temporal.api.failure.v1.Failure\x12\x10\n\x08identity\x18\x04 \x01(\t\x12\x1b\n\x0f\x62inary_checksum\x18\x05 \x01(\tB\x02\x18\x01\x12\x11\n\tnamespace\x18\x06 \x01(\t\x12\x33\n\x08messages\x18\x07 \x03(\x0b\x32!.temporal.api.protocol.v1.Message\x12\x46\n\x0eworker_version\x18\x08 \x01(\x0b\x32*.temporal.api.common.v1.WorkerVersionStampB\x02\x18\x01\x12>\n\ndeployment\x18\t \x01(\x0b\x32&.temporal.api.deployment.v1.DeploymentB\x02\x18\x01\x12O\n\x12\x64\x65ployment_options\x18\n \x01(\x0b\x32\x33.temporal.api.deployment.v1.WorkerDeploymentOptions"#\n!RespondWorkflowTaskFailedResponse"\xb8\x03\n\x1cPollActivityTaskQueueRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x38\n\ntask_queue\x18\x02 \x01(\x0b\x32$.temporal.api.taskqueue.v1.TaskQueue\x12\x10\n\x08identity\x18\x03 \x01(\t\x12I\n\x13task_queue_metadata\x18\x04 \x01(\x0b\x32,.temporal.api.taskqueue.v1.TaskQueueMetadata\x12Z\n\x1bworker_version_capabilities\x18\x05 \x01(\x0b\x32\x31.temporal.api.common.v1.WorkerVersionCapabilitiesB\x02\x18\x01\x12O\n\x12\x64\x65ployment_options\x18\x06 \x01(\x0b\x32\x33.temporal.api.deployment.v1.WorkerDeploymentOptions\x12\x41\n\x10worker_heartbeat\x18\x07 \x01(\x0b\x32\'.temporal.api.worker.v1.WorkerHeartbeat"\xef\x07\n\x1dPollActivityTaskQueueResponse\x12\x12\n\ntask_token\x18\x01 \x01(\x0c\x12\x1a\n\x12workflow_namespace\x18\x02 \x01(\t\x12;\n\rworkflow_type\x18\x03 \x01(\x0b\x32$.temporal.api.common.v1.WorkflowType\x12\x45\n\x12workflow_execution\x18\x04 \x01(\x0b\x32).temporal.api.common.v1.WorkflowExecution\x12;\n\ractivity_type\x18\x05 \x01(\x0b\x32$.temporal.api.common.v1.ActivityType\x12\x13\n\x0b\x61\x63tivity_id\x18\x06 \x01(\t\x12.\n\x06header\x18\x07 \x01(\x0b\x32\x1e.temporal.api.common.v1.Header\x12/\n\x05input\x18\x08 \x01(\x0b\x32 .temporal.api.common.v1.Payloads\x12;\n\x11heartbeat_details\x18\t \x01(\x0b\x32 .temporal.api.common.v1.Payloads\x12\x32\n\x0escheduled_time\x18\n \x01(\x0b\x32\x1a.google.protobuf.Timestamp\x12\x42\n\x1e\x63urrent_attempt_scheduled_time\x18\x0b \x01(\x0b\x32\x1a.google.protobuf.Timestamp\x12\x30\n\x0cstarted_time\x18\x0c \x01(\x0b\x32\x1a.google.protobuf.Timestamp\x12\x0f\n\x07\x61ttempt\x18\r \x01(\x05\x12<\n\x19schedule_to_close_timeout\x18\x0e \x01(\x0b\x32\x19.google.protobuf.Duration\x12\x39\n\x16start_to_close_timeout\x18\x0f \x01(\x0b\x32\x19.google.protobuf.Duration\x12\x34\n\x11heartbeat_timeout\x18\x10 \x01(\x0b\x32\x19.google.protobuf.Duration\x12\x39\n\x0cretry_policy\x18\x11 \x01(\x0b\x32#.temporal.api.common.v1.RetryPolicy\x12Q\n\x17poller_scaling_decision\x18\x12 \x01(\x0b\x32\x30.temporal.api.taskqueue.v1.PollerScalingDecision\x12\x32\n\x08priority\x18\x13 \x01(\x0b\x32 .temporal.api.common.v1.Priority"\x90\x01\n"RecordActivityTaskHeartbeatRequest\x12\x12\n\ntask_token\x18\x01 \x01(\x0c\x12\x31\n\x07\x64\x65tails\x18\x02 \x01(\x0b\x32 .temporal.api.common.v1.Payloads\x12\x10\n\x08identity\x18\x03 \x01(\t\x12\x11\n\tnamespace\x18\x04 \x01(\t"p\n#RecordActivityTaskHeartbeatResponse\x12\x18\n\x10\x63\x61ncel_requested\x18\x01 \x01(\x08\x12\x17\n\x0f\x61\x63tivity_paused\x18\x02 \x01(\x08\x12\x16\n\x0e\x61\x63tivity_reset\x18\x03 \x01(\x08"\xba\x01\n&RecordActivityTaskHeartbeatByIdRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x13\n\x0bworkflow_id\x18\x02 \x01(\t\x12\x0e\n\x06run_id\x18\x03 \x01(\t\x12\x13\n\x0b\x61\x63tivity_id\x18\x04 \x01(\t\x12\x31\n\x07\x64\x65tails\x18\x05 \x01(\x0b\x32 .temporal.api.common.v1.Payloads\x12\x10\n\x08identity\x18\x06 \x01(\t"t\n\'RecordActivityTaskHeartbeatByIdResponse\x12\x18\n\x10\x63\x61ncel_requested\x18\x01 \x01(\x08\x12\x17\n\x0f\x61\x63tivity_paused\x18\x02 \x01(\x08\x12\x16\n\x0e\x61\x63tivity_reset\x18\x03 \x01(\x08"\xe9\x02\n#RespondActivityTaskCompletedRequest\x12\x12\n\ntask_token\x18\x01 \x01(\x0c\x12\x30\n\x06result\x18\x02 \x01(\x0b\x32 .temporal.api.common.v1.Payloads\x12\x10\n\x08identity\x18\x03 \x01(\t\x12\x11\n\tnamespace\x18\x04 \x01(\t\x12\x46\n\x0eworker_version\x18\x05 \x01(\x0b\x32*.temporal.api.common.v1.WorkerVersionStampB\x02\x18\x01\x12>\n\ndeployment\x18\x06 \x01(\x0b\x32&.temporal.api.deployment.v1.DeploymentB\x02\x18\x01\x12O\n\x12\x64\x65ployment_options\x18\x07 \x01(\x0b\x32\x33.temporal.api.deployment.v1.WorkerDeploymentOptions"&\n$RespondActivityTaskCompletedResponse"\xba\x01\n\'RespondActivityTaskCompletedByIdRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x13\n\x0bworkflow_id\x18\x02 \x01(\t\x12\x0e\n\x06run_id\x18\x03 \x01(\t\x12\x13\n\x0b\x61\x63tivity_id\x18\x04 \x01(\t\x12\x30\n\x06result\x18\x05 \x01(\x0b\x32 .temporal.api.common.v1.Payloads\x12\x10\n\x08identity\x18\x06 \x01(\t"*\n(RespondActivityTaskCompletedByIdResponse"\xa9\x03\n RespondActivityTaskFailedRequest\x12\x12\n\ntask_token\x18\x01 \x01(\x0c\x12\x31\n\x07\x66\x61ilure\x18\x02 \x01(\x0b\x32 .temporal.api.failure.v1.Failure\x12\x10\n\x08identity\x18\x03 \x01(\t\x12\x11\n\tnamespace\x18\x04 \x01(\t\x12@\n\x16last_heartbeat_details\x18\x05 \x01(\x0b\x32 .temporal.api.common.v1.Payloads\x12\x46\n\x0eworker_version\x18\x06 \x01(\x0b\x32*.temporal.api.common.v1.WorkerVersionStampB\x02\x18\x01\x12>\n\ndeployment\x18\x07 \x01(\x0b\x32&.temporal.api.deployment.v1.DeploymentB\x02\x18\x01\x12O\n\x12\x64\x65ployment_options\x18\x08 \x01(\x0b\x32\x33.temporal.api.deployment.v1.WorkerDeploymentOptions"W\n!RespondActivityTaskFailedResponse\x12\x32\n\x08\x66\x61ilures\x18\x01 \x03(\x0b\x32 .temporal.api.failure.v1.Failure"\xfa\x01\n$RespondActivityTaskFailedByIdRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x13\n\x0bworkflow_id\x18\x02 \x01(\t\x12\x0e\n\x06run_id\x18\x03 \x01(\t\x12\x13\n\x0b\x61\x63tivity_id\x18\x04 \x01(\t\x12\x31\n\x07\x66\x61ilure\x18\x05 \x01(\x0b\x32 .temporal.api.failure.v1.Failure\x12\x10\n\x08identity\x18\x06 \x01(\t\x12@\n\x16last_heartbeat_details\x18\x07 \x01(\x0b\x32 .temporal.api.common.v1.Payloads"[\n%RespondActivityTaskFailedByIdResponse\x12\x32\n\x08\x66\x61ilures\x18\x01 \x03(\x0b\x32 .temporal.api.failure.v1.Failure"\xe9\x02\n"RespondActivityTaskCanceledRequest\x12\x12\n\ntask_token\x18\x01 \x01(\x0c\x12\x31\n\x07\x64\x65tails\x18\x02 \x01(\x0b\x32 .temporal.api.common.v1.Payloads\x12\x10\n\x08identity\x18\x03 \x01(\t\x12\x11\n\tnamespace\x18\x04 \x01(\t\x12\x46\n\x0eworker_version\x18\x05 \x01(\x0b\x32*.temporal.api.common.v1.WorkerVersionStampB\x02\x18\x01\x12>\n\ndeployment\x18\x06 \x01(\x0b\x32&.temporal.api.deployment.v1.DeploymentB\x02\x18\x01\x12O\n\x12\x64\x65ployment_options\x18\x07 \x01(\x0b\x32\x33.temporal.api.deployment.v1.WorkerDeploymentOptions"%\n#RespondActivityTaskCanceledResponse"\x8b\x02\n&RespondActivityTaskCanceledByIdRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x13\n\x0bworkflow_id\x18\x02 \x01(\t\x12\x0e\n\x06run_id\x18\x03 \x01(\t\x12\x13\n\x0b\x61\x63tivity_id\x18\x04 \x01(\t\x12\x31\n\x07\x64\x65tails\x18\x05 \x01(\x0b\x32 .temporal.api.common.v1.Payloads\x12\x10\n\x08identity\x18\x06 \x01(\t\x12O\n\x12\x64\x65ployment_options\x18\x07 \x01(\x0b\x32\x33.temporal.api.deployment.v1.WorkerDeploymentOptions")\n\'RespondActivityTaskCanceledByIdResponse"\x84\x02\n%RequestCancelWorkflowExecutionRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x45\n\x12workflow_execution\x18\x02 \x01(\x0b\x32).temporal.api.common.v1.WorkflowExecution\x12\x10\n\x08identity\x18\x03 \x01(\t\x12\x12\n\nrequest_id\x18\x04 \x01(\t\x12\x1e\n\x16\x66irst_execution_run_id\x18\x05 \x01(\t\x12\x0e\n\x06reason\x18\x06 \x01(\t\x12+\n\x05links\x18\x07 \x03(\x0b\x32\x1c.temporal.api.common.v1.Link"(\n&RequestCancelWorkflowExecutionResponse"\xde\x02\n\x1eSignalWorkflowExecutionRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x45\n\x12workflow_execution\x18\x02 \x01(\x0b\x32).temporal.api.common.v1.WorkflowExecution\x12\x13\n\x0bsignal_name\x18\x03 \x01(\t\x12/\n\x05input\x18\x04 \x01(\x0b\x32 .temporal.api.common.v1.Payloads\x12\x10\n\x08identity\x18\x05 \x01(\t\x12\x12\n\nrequest_id\x18\x06 \x01(\t\x12\x13\n\x07\x63ontrol\x18\x07 \x01(\tB\x02\x18\x01\x12.\n\x06header\x18\x08 \x01(\x0b\x32\x1e.temporal.api.common.v1.Header\x12+\n\x05links\x18\n \x03(\x0b\x32\x1c.temporal.api.common.v1.LinkJ\x04\x08\t\x10\n"!\n\x1fSignalWorkflowExecutionResponse"\xf1\t\n\'SignalWithStartWorkflowExecutionRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x13\n\x0bworkflow_id\x18\x02 \x01(\t\x12;\n\rworkflow_type\x18\x03 \x01(\x0b\x32$.temporal.api.common.v1.WorkflowType\x12\x38\n\ntask_queue\x18\x04 \x01(\x0b\x32$.temporal.api.taskqueue.v1.TaskQueue\x12/\n\x05input\x18\x05 \x01(\x0b\x32 .temporal.api.common.v1.Payloads\x12=\n\x1aworkflow_execution_timeout\x18\x06 \x01(\x0b\x32\x19.google.protobuf.Duration\x12\x37\n\x14workflow_run_timeout\x18\x07 \x01(\x0b\x32\x19.google.protobuf.Duration\x12\x38\n\x15workflow_task_timeout\x18\x08 \x01(\x0b\x32\x19.google.protobuf.Duration\x12\x10\n\x08identity\x18\t \x01(\t\x12\x12\n\nrequest_id\x18\n \x01(\t\x12N\n\x18workflow_id_reuse_policy\x18\x0b \x01(\x0e\x32,.temporal.api.enums.v1.WorkflowIdReusePolicy\x12T\n\x1bworkflow_id_conflict_policy\x18\x16 \x01(\x0e\x32/.temporal.api.enums.v1.WorkflowIdConflictPolicy\x12\x13\n\x0bsignal_name\x18\x0c \x01(\t\x12\x36\n\x0csignal_input\x18\r \x01(\x0b\x32 .temporal.api.common.v1.Payloads\x12\x13\n\x07\x63ontrol\x18\x0e \x01(\tB\x02\x18\x01\x12\x39\n\x0cretry_policy\x18\x0f \x01(\x0b\x32#.temporal.api.common.v1.RetryPolicy\x12\x15\n\rcron_schedule\x18\x10 \x01(\t\x12*\n\x04memo\x18\x11 \x01(\x0b\x32\x1c.temporal.api.common.v1.Memo\x12\x43\n\x11search_attributes\x18\x12 \x01(\x0b\x32(.temporal.api.common.v1.SearchAttributes\x12.\n\x06header\x18\x13 \x01(\x0b\x32\x1e.temporal.api.common.v1.Header\x12\x37\n\x14workflow_start_delay\x18\x14 \x01(\x0b\x32\x19.google.protobuf.Duration\x12\x38\n\ruser_metadata\x18\x17 \x01(\x0b\x32!.temporal.api.sdk.v1.UserMetadata\x12+\n\x05links\x18\x18 \x03(\x0b\x32\x1c.temporal.api.common.v1.Link\x12I\n\x13versioning_override\x18\x19 \x01(\x0b\x32,.temporal.api.workflow.v1.VersioningOverride\x12\x32\n\x08priority\x18\x1a \x01(\x0b\x32 .temporal.api.common.v1.PriorityJ\x04\x08\x15\x10\x16"K\n(SignalWithStartWorkflowExecutionResponse\x12\x0e\n\x06run_id\x18\x01 \x01(\t\x12\x0f\n\x07started\x18\x02 \x01(\x08"\xc1\x03\n\x1dResetWorkflowExecutionRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x45\n\x12workflow_execution\x18\x02 \x01(\x0b\x32).temporal.api.common.v1.WorkflowExecution\x12\x0e\n\x06reason\x18\x03 \x01(\t\x12%\n\x1dworkflow_task_finish_event_id\x18\x04 \x01(\x03\x12\x12\n\nrequest_id\x18\x05 \x01(\t\x12G\n\x12reset_reapply_type\x18\x06 \x01(\x0e\x32\'.temporal.api.enums.v1.ResetReapplyTypeB\x02\x18\x01\x12S\n\x1breset_reapply_exclude_types\x18\x07 \x03(\x0e\x32..temporal.api.enums.v1.ResetReapplyExcludeType\x12K\n\x15post_reset_operations\x18\x08 \x03(\x0b\x32,.temporal.api.workflow.v1.PostResetOperation\x12\x10\n\x08identity\x18\t \x01(\t"0\n\x1eResetWorkflowExecutionResponse\x12\x0e\n\x06run_id\x18\x01 \x01(\t"\x9f\x02\n!TerminateWorkflowExecutionRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x45\n\x12workflow_execution\x18\x02 \x01(\x0b\x32).temporal.api.common.v1.WorkflowExecution\x12\x0e\n\x06reason\x18\x03 \x01(\t\x12\x31\n\x07\x64\x65tails\x18\x04 \x01(\x0b\x32 .temporal.api.common.v1.Payloads\x12\x10\n\x08identity\x18\x05 \x01(\t\x12\x1e\n\x16\x66irst_execution_run_id\x18\x06 \x01(\t\x12+\n\x05links\x18\x07 \x03(\x0b\x32\x1c.temporal.api.common.v1.Link"$\n"TerminateWorkflowExecutionResponse"z\n\x1e\x44\x65leteWorkflowExecutionRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x45\n\x12workflow_execution\x18\x02 \x01(\x0b\x32).temporal.api.common.v1.WorkflowExecution"!\n\x1f\x44\x65leteWorkflowExecutionResponse"\xc9\x02\n!ListOpenWorkflowExecutionsRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x19\n\x11maximum_page_size\x18\x02 \x01(\x05\x12\x17\n\x0fnext_page_token\x18\x03 \x01(\x0c\x12\x42\n\x11start_time_filter\x18\x04 \x01(\x0b\x32\'.temporal.api.filter.v1.StartTimeFilter\x12K\n\x10\x65xecution_filter\x18\x05 \x01(\x0b\x32/.temporal.api.filter.v1.WorkflowExecutionFilterH\x00\x12\x41\n\x0btype_filter\x18\x06 \x01(\x0b\x32*.temporal.api.filter.v1.WorkflowTypeFilterH\x00\x42\t\n\x07\x66ilters"\x82\x01\n"ListOpenWorkflowExecutionsResponse\x12\x43\n\nexecutions\x18\x01 \x03(\x0b\x32/.temporal.api.workflow.v1.WorkflowExecutionInfo\x12\x17\n\x0fnext_page_token\x18\x02 \x01(\x0c"\x8a\x03\n#ListClosedWorkflowExecutionsRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x19\n\x11maximum_page_size\x18\x02 \x01(\x05\x12\x17\n\x0fnext_page_token\x18\x03 \x01(\x0c\x12\x42\n\x11start_time_filter\x18\x04 \x01(\x0b\x32\'.temporal.api.filter.v1.StartTimeFilter\x12K\n\x10\x65xecution_filter\x18\x05 \x01(\x0b\x32/.temporal.api.filter.v1.WorkflowExecutionFilterH\x00\x12\x41\n\x0btype_filter\x18\x06 \x01(\x0b\x32*.temporal.api.filter.v1.WorkflowTypeFilterH\x00\x12=\n\rstatus_filter\x18\x07 \x01(\x0b\x32$.temporal.api.filter.v1.StatusFilterH\x00\x42\t\n\x07\x66ilters"\x84\x01\n$ListClosedWorkflowExecutionsResponse\x12\x43\n\nexecutions\x18\x01 \x03(\x0b\x32/.temporal.api.workflow.v1.WorkflowExecutionInfo\x12\x17\n\x0fnext_page_token\x18\x02 \x01(\x0c"m\n\x1dListWorkflowExecutionsRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x11\n\tpage_size\x18\x02 \x01(\x05\x12\x17\n\x0fnext_page_token\x18\x03 \x01(\x0c\x12\r\n\x05query\x18\x04 \x01(\t"~\n\x1eListWorkflowExecutionsResponse\x12\x43\n\nexecutions\x18\x01 \x03(\x0b\x32/.temporal.api.workflow.v1.WorkflowExecutionInfo\x12\x17\n\x0fnext_page_token\x18\x02 \x01(\x0c"u\n%ListArchivedWorkflowExecutionsRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x11\n\tpage_size\x18\x02 \x01(\x05\x12\x17\n\x0fnext_page_token\x18\x03 \x01(\x0c\x12\r\n\x05query\x18\x04 \x01(\t"\x86\x01\n&ListArchivedWorkflowExecutionsResponse\x12\x43\n\nexecutions\x18\x01 \x03(\x0b\x32/.temporal.api.workflow.v1.WorkflowExecutionInfo\x12\x17\n\x0fnext_page_token\x18\x02 \x01(\x0c"m\n\x1dScanWorkflowExecutionsRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x11\n\tpage_size\x18\x02 \x01(\x05\x12\x17\n\x0fnext_page_token\x18\x03 \x01(\x0c\x12\r\n\x05query\x18\x04 \x01(\t"~\n\x1eScanWorkflowExecutionsResponse\x12\x43\n\nexecutions\x18\x01 \x03(\x0b\x32/.temporal.api.workflow.v1.WorkflowExecutionInfo\x12\x17\n\x0fnext_page_token\x18\x02 \x01(\x0c"B\n\x1e\x43ountWorkflowExecutionsRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\r\n\x05query\x18\x02 \x01(\t"\xed\x01\n\x1f\x43ountWorkflowExecutionsResponse\x12\r\n\x05\x63ount\x18\x01 \x01(\x03\x12\x61\n\x06groups\x18\x02 \x03(\x0b\x32Q.temporal.api.workflowservice.v1.CountWorkflowExecutionsResponse.AggregationGroup\x1aX\n\x10\x41ggregationGroup\x12\x35\n\x0cgroup_values\x18\x01 \x03(\x0b\x32\x1f.temporal.api.common.v1.Payload\x12\r\n\x05\x63ount\x18\x02 \x01(\x03"\x1c\n\x1aGetSearchAttributesRequest"\xc9\x01\n\x1bGetSearchAttributesResponse\x12T\n\x04keys\x18\x01 \x03(\x0b\x32\x46.temporal.api.workflowservice.v1.GetSearchAttributesResponse.KeysEntry\x1aT\n\tKeysEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\x36\n\x05value\x18\x02 \x01(\x0e\x32\'.temporal.api.enums.v1.IndexedValueType:\x02\x38\x01"\xd0\x02\n RespondQueryTaskCompletedRequest\x12\x12\n\ntask_token\x18\x01 \x01(\x0c\x12>\n\x0e\x63ompleted_type\x18\x02 \x01(\x0e\x32&.temporal.api.enums.v1.QueryResultType\x12\x36\n\x0cquery_result\x18\x03 \x01(\x0b\x32 .temporal.api.common.v1.Payloads\x12\x15\n\rerror_message\x18\x04 \x01(\t\x12\x11\n\tnamespace\x18\x06 \x01(\t\x12\x31\n\x07\x66\x61ilure\x18\x07 \x01(\x0b\x32 .temporal.api.failure.v1.Failure\x12=\n\x05\x63\x61use\x18\x08 \x01(\x0e\x32..temporal.api.enums.v1.WorkflowTaskFailedCauseJ\x04\x08\x05\x10\x06"#\n!RespondQueryTaskCompletedResponse"n\n\x1bResetStickyTaskQueueRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12<\n\texecution\x18\x02 \x01(\x0b\x32).temporal.api.common.v1.WorkflowExecution"\x1e\n\x1cResetStickyTaskQueueResponse"\xaa\x01\n\x15ShutdownWorkerRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x19\n\x11sticky_task_queue\x18\x02 \x01(\t\x12\x10\n\x08identity\x18\x03 \x01(\t\x12\x0e\n\x06reason\x18\x04 \x01(\t\x12\x41\n\x10worker_heartbeat\x18\x05 \x01(\x0b\x32\'.temporal.api.worker.v1.WorkerHeartbeat"\x18\n\x16ShutdownWorkerResponse"\xe9\x01\n\x14QueryWorkflowRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12<\n\texecution\x18\x02 \x01(\x0b\x32).temporal.api.common.v1.WorkflowExecution\x12\x33\n\x05query\x18\x03 \x01(\x0b\x32$.temporal.api.query.v1.WorkflowQuery\x12K\n\x16query_reject_condition\x18\x04 \x01(\x0e\x32+.temporal.api.enums.v1.QueryRejectCondition"\x8d\x01\n\x15QueryWorkflowResponse\x12\x36\n\x0cquery_result\x18\x01 \x01(\x0b\x32 .temporal.api.common.v1.Payloads\x12<\n\x0equery_rejected\x18\x02 \x01(\x0b\x32$.temporal.api.query.v1.QueryRejected"s\n DescribeWorkflowExecutionRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12<\n\texecution\x18\x02 \x01(\x0b\x32).temporal.api.common.v1.WorkflowExecution"\x99\x05\n!DescribeWorkflowExecutionResponse\x12K\n\x10\x65xecution_config\x18\x01 \x01(\x0b\x32\x31.temporal.api.workflow.v1.WorkflowExecutionConfig\x12P\n\x17workflow_execution_info\x18\x02 \x01(\x0b\x32/.temporal.api.workflow.v1.WorkflowExecutionInfo\x12I\n\x12pending_activities\x18\x03 \x03(\x0b\x32-.temporal.api.workflow.v1.PendingActivityInfo\x12M\n\x10pending_children\x18\x04 \x03(\x0b\x32\x33.temporal.api.workflow.v1.PendingChildExecutionInfo\x12P\n\x15pending_workflow_task\x18\x05 \x01(\x0b\x32\x31.temporal.api.workflow.v1.PendingWorkflowTaskInfo\x12\x39\n\tcallbacks\x18\x06 \x03(\x0b\x32&.temporal.api.workflow.v1.CallbackInfo\x12U\n\x18pending_nexus_operations\x18\x07 \x03(\x0b\x32\x33.temporal.api.workflow.v1.PendingNexusOperationInfo\x12W\n\x16workflow_extended_info\x18\x08 \x01(\x0b\x32\x37.temporal.api.workflow.v1.WorkflowExecutionExtendedInfo"\x90\x04\n\x18\x44\x65scribeTaskQueueRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x38\n\ntask_queue\x18\x02 \x01(\x0b\x32$.temporal.api.taskqueue.v1.TaskQueue\x12=\n\x0ftask_queue_type\x18\x03 \x01(\x0e\x32$.temporal.api.enums.v1.TaskQueueType\x12\x14\n\x0creport_stats\x18\x08 \x01(\x08\x12\x15\n\rreport_config\x18\x0b \x01(\x08\x12%\n\x19include_task_queue_status\x18\x04 \x01(\x08\x42\x02\x18\x01\x12\x42\n\x08\x61pi_mode\x18\x05 \x01(\x0e\x32,.temporal.api.enums.v1.DescribeTaskQueueModeB\x02\x18\x01\x12J\n\x08versions\x18\x06 \x01(\x0b\x32\x34.temporal.api.taskqueue.v1.TaskQueueVersionSelectionB\x02\x18\x01\x12\x42\n\x10task_queue_types\x18\x07 \x03(\x0e\x32$.temporal.api.enums.v1.TaskQueueTypeB\x02\x18\x01\x12\x1a\n\x0ereport_pollers\x18\t \x01(\x08\x42\x02\x18\x01\x12$\n\x18report_task_reachability\x18\n \x01(\x08\x42\x02\x18\x01"\xec\x07\n\x19\x44\x65scribeTaskQueueResponse\x12\x36\n\x07pollers\x18\x01 \x03(\x0b\x32%.temporal.api.taskqueue.v1.PollerInfo\x12\x38\n\x05stats\x18\x05 \x01(\x0b\x32).temporal.api.taskqueue.v1.TaskQueueStats\x12q\n\x15stats_by_priority_key\x18\x08 \x03(\x0b\x32R.temporal.api.workflowservice.v1.DescribeTaskQueueResponse.StatsByPriorityKeyEntry\x12K\n\x0fversioning_info\x18\x04 \x01(\x0b\x32\x32.temporal.api.taskqueue.v1.TaskQueueVersioningInfo\x12:\n\x06\x63onfig\x18\x06 \x01(\x0b\x32*.temporal.api.taskqueue.v1.TaskQueueConfig\x12k\n\x14\x65\x66\x66\x65\x63tive_rate_limit\x18\x07 \x01(\x0b\x32M.temporal.api.workflowservice.v1.DescribeTaskQueueResponse.EffectiveRateLimit\x12I\n\x11task_queue_status\x18\x02 \x01(\x0b\x32*.temporal.api.taskqueue.v1.TaskQueueStatusB\x02\x18\x01\x12g\n\rversions_info\x18\x03 \x03(\x0b\x32L.temporal.api.workflowservice.v1.DescribeTaskQueueResponse.VersionsInfoEntryB\x02\x18\x01\x1a\x64\n\x17StatsByPriorityKeyEntry\x12\x0b\n\x03key\x18\x01 \x01(\x05\x12\x38\n\x05value\x18\x02 \x01(\x0b\x32).temporal.api.taskqueue.v1.TaskQueueStats:\x02\x38\x01\x1at\n\x12\x45\x66\x66\x65\x63tiveRateLimit\x12\x1b\n\x13requests_per_second\x18\x01 \x01(\x02\x12\x41\n\x11rate_limit_source\x18\x02 \x01(\x0e\x32&.temporal.api.enums.v1.RateLimitSource\x1a\x64\n\x11VersionsInfoEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12>\n\x05value\x18\x02 \x01(\x0b\x32/.temporal.api.taskqueue.v1.TaskQueueVersionInfo:\x02\x38\x01"\x17\n\x15GetClusterInfoRequest"\xd1\x03\n\x16GetClusterInfoResponse\x12h\n\x11supported_clients\x18\x01 \x03(\x0b\x32M.temporal.api.workflowservice.v1.GetClusterInfoResponse.SupportedClientsEntry\x12\x16\n\x0eserver_version\x18\x02 \x01(\t\x12\x12\n\ncluster_id\x18\x03 \x01(\t\x12:\n\x0cversion_info\x18\x04 \x01(\x0b\x32$.temporal.api.version.v1.VersionInfo\x12\x14\n\x0c\x63luster_name\x18\x05 \x01(\t\x12\x1b\n\x13history_shard_count\x18\x06 \x01(\x05\x12\x19\n\x11persistence_store\x18\x07 \x01(\t\x12\x18\n\x10visibility_store\x18\x08 \x01(\t\x12 \n\x18initial_failover_version\x18\t \x01(\x03\x12"\n\x1a\x66\x61ilover_version_increment\x18\n \x01(\x03\x1a\x37\n\x15SupportedClientsEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\t:\x02\x38\x01"\x16\n\x14GetSystemInfoRequest"\xf4\x03\n\x15GetSystemInfoResponse\x12\x16\n\x0eserver_version\x18\x01 \x01(\t\x12Y\n\x0c\x63\x61pabilities\x18\x02 \x01(\x0b\x32\x43.temporal.api.workflowservice.v1.GetSystemInfoResponse.Capabilities\x1a\xe7\x02\n\x0c\x43\x61pabilities\x12\x1f\n\x17signal_and_query_header\x18\x01 \x01(\x08\x12&\n\x1einternal_error_differentiation\x18\x02 \x01(\x08\x12*\n"activity_failure_include_heartbeat\x18\x03 \x01(\x08\x12\x1a\n\x12supports_schedules\x18\x04 \x01(\x08\x12"\n\x1a\x65ncoded_failure_attributes\x18\x05 \x01(\x08\x12!\n\x19\x62uild_id_based_versioning\x18\x06 \x01(\x08\x12\x13\n\x0bupsert_memo\x18\x07 \x01(\x08\x12\x1c\n\x14\x65\x61ger_workflow_start\x18\x08 \x01(\x08\x12\x14\n\x0csdk_metadata\x18\t \x01(\x08\x12\'\n\x1f\x63ount_group_by_execution_status\x18\n \x01(\x08\x12\r\n\x05nexus\x18\x0b \x01(\x08"m\n\x1eListTaskQueuePartitionsRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x38\n\ntask_queue\x18\x02 \x01(\x0b\x32$.temporal.api.taskqueue.v1.TaskQueue"\xdf\x01\n\x1fListTaskQueuePartitionsResponse\x12]\n\x1e\x61\x63tivity_task_queue_partitions\x18\x01 \x03(\x0b\x32\x35.temporal.api.taskqueue.v1.TaskQueuePartitionMetadata\x12]\n\x1eworkflow_task_queue_partitions\x18\x02 \x03(\x0b\x32\x35.temporal.api.taskqueue.v1.TaskQueuePartitionMetadata"\xcc\x02\n\x15\x43reateScheduleRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x13\n\x0bschedule_id\x18\x02 \x01(\t\x12\x34\n\x08schedule\x18\x03 \x01(\x0b\x32".temporal.api.schedule.v1.Schedule\x12>\n\rinitial_patch\x18\x04 \x01(\x0b\x32\'.temporal.api.schedule.v1.SchedulePatch\x12\x10\n\x08identity\x18\x05 \x01(\t\x12\x12\n\nrequest_id\x18\x06 \x01(\t\x12*\n\x04memo\x18\x07 \x01(\x0b\x32\x1c.temporal.api.common.v1.Memo\x12\x43\n\x11search_attributes\x18\x08 \x01(\x0b\x32(.temporal.api.common.v1.SearchAttributes"0\n\x16\x43reateScheduleResponse\x12\x16\n\x0e\x63onflict_token\x18\x01 \x01(\x0c"A\n\x17\x44\x65scribeScheduleRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x13\n\x0bschedule_id\x18\x02 \x01(\t"\x8f\x02\n\x18\x44\x65scribeScheduleResponse\x12\x34\n\x08schedule\x18\x01 \x01(\x0b\x32".temporal.api.schedule.v1.Schedule\x12\x34\n\x04info\x18\x02 \x01(\x0b\x32&.temporal.api.schedule.v1.ScheduleInfo\x12*\n\x04memo\x18\x03 \x01(\x0b\x32\x1c.temporal.api.common.v1.Memo\x12\x43\n\x11search_attributes\x18\x04 \x01(\x0b\x32(.temporal.api.common.v1.SearchAttributes\x12\x16\n\x0e\x63onflict_token\x18\x05 \x01(\x0c"\xf8\x01\n\x15UpdateScheduleRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x13\n\x0bschedule_id\x18\x02 \x01(\t\x12\x34\n\x08schedule\x18\x03 \x01(\x0b\x32".temporal.api.schedule.v1.Schedule\x12\x16\n\x0e\x63onflict_token\x18\x04 \x01(\x0c\x12\x10\n\x08identity\x18\x05 \x01(\t\x12\x12\n\nrequest_id\x18\x06 \x01(\t\x12\x43\n\x11search_attributes\x18\x07 \x01(\x0b\x32(.temporal.api.common.v1.SearchAttributes"\x18\n\x16UpdateScheduleResponse"\x9c\x01\n\x14PatchScheduleRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x13\n\x0bschedule_id\x18\x02 \x01(\t\x12\x36\n\x05patch\x18\x03 \x01(\x0b\x32\'.temporal.api.schedule.v1.SchedulePatch\x12\x10\n\x08identity\x18\x04 \x01(\t\x12\x12\n\nrequest_id\x18\x05 \x01(\t"\x17\n\x15PatchScheduleResponse"\xa8\x01\n ListScheduleMatchingTimesRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x13\n\x0bschedule_id\x18\x02 \x01(\t\x12.\n\nstart_time\x18\x03 \x01(\x0b\x32\x1a.google.protobuf.Timestamp\x12,\n\x08\x65nd_time\x18\x04 \x01(\x0b\x32\x1a.google.protobuf.Timestamp"S\n!ListScheduleMatchingTimesResponse\x12.\n\nstart_time\x18\x01 \x03(\x0b\x32\x1a.google.protobuf.Timestamp"Q\n\x15\x44\x65leteScheduleRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x13\n\x0bschedule_id\x18\x02 \x01(\t\x12\x10\n\x08identity\x18\x03 \x01(\t"\x18\n\x16\x44\x65leteScheduleResponse"l\n\x14ListSchedulesRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x19\n\x11maximum_page_size\x18\x02 \x01(\x05\x12\x17\n\x0fnext_page_token\x18\x03 \x01(\x0c\x12\r\n\x05query\x18\x04 \x01(\t"p\n\x15ListSchedulesResponse\x12>\n\tschedules\x18\x01 \x03(\x0b\x32+.temporal.api.schedule.v1.ScheduleListEntry\x12\x17\n\x0fnext_page_token\x18\x02 \x01(\x0c"\x86\x05\n\'UpdateWorkerBuildIdCompatibilityRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x12\n\ntask_queue\x18\x02 \x01(\t\x12-\n#add_new_build_id_in_new_default_set\x18\x03 \x01(\tH\x00\x12\x87\x01\n\x1b\x61\x64\x64_new_compatible_build_id\x18\x04 \x01(\x0b\x32`.temporal.api.workflowservice.v1.UpdateWorkerBuildIdCompatibilityRequest.AddNewCompatibleVersionH\x00\x12!\n\x17promote_set_by_build_id\x18\x05 \x01(\tH\x00\x12%\n\x1bpromote_build_id_within_set\x18\x06 \x01(\tH\x00\x12h\n\nmerge_sets\x18\x07 \x01(\x0b\x32R.temporal.api.workflowservice.v1.UpdateWorkerBuildIdCompatibilityRequest.MergeSetsH\x00\x1ao\n\x17\x41\x64\x64NewCompatibleVersion\x12\x14\n\x0cnew_build_id\x18\x01 \x01(\t\x12$\n\x1c\x65xisting_compatible_build_id\x18\x02 \x01(\t\x12\x18\n\x10make_set_default\x18\x03 \x01(\x08\x1aI\n\tMergeSets\x12\x1c\n\x14primary_set_build_id\x18\x01 \x01(\t\x12\x1e\n\x16secondary_set_build_id\x18\x02 \x01(\tB\x0b\n\toperation"@\n(UpdateWorkerBuildIdCompatibilityResponseJ\x04\x08\x01\x10\x02R\x0eversion_set_id"_\n$GetWorkerBuildIdCompatibilityRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x12\n\ntask_queue\x18\x02 \x01(\t\x12\x10\n\x08max_sets\x18\x03 \x01(\x05"t\n%GetWorkerBuildIdCompatibilityResponse\x12K\n\x12major_version_sets\x18\x01 \x03(\x0b\x32/.temporal.api.taskqueue.v1.CompatibleVersionSet"\xb5\r\n"UpdateWorkerVersioningRulesRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x12\n\ntask_queue\x18\x02 \x01(\t\x12\x16\n\x0e\x63onflict_token\x18\x03 \x01(\x0c\x12\x81\x01\n\x16insert_assignment_rule\x18\x04 \x01(\x0b\x32_.temporal.api.workflowservice.v1.UpdateWorkerVersioningRulesRequest.InsertBuildIdAssignmentRuleH\x00\x12\x83\x01\n\x17replace_assignment_rule\x18\x05 \x01(\x0b\x32`.temporal.api.workflowservice.v1.UpdateWorkerVersioningRulesRequest.ReplaceBuildIdAssignmentRuleH\x00\x12\x81\x01\n\x16\x64\x65lete_assignment_rule\x18\x06 \x01(\x0b\x32_.temporal.api.workflowservice.v1.UpdateWorkerVersioningRulesRequest.DeleteBuildIdAssignmentRuleH\x00\x12\x8c\x01\n\x1c\x61\x64\x64_compatible_redirect_rule\x18\x07 \x01(\x0b\x32\x64.temporal.api.workflowservice.v1.UpdateWorkerVersioningRulesRequest.AddCompatibleBuildIdRedirectRuleH\x00\x12\x94\x01\n replace_compatible_redirect_rule\x18\x08 \x01(\x0b\x32h.temporal.api.workflowservice.v1.UpdateWorkerVersioningRulesRequest.ReplaceCompatibleBuildIdRedirectRuleH\x00\x12\x92\x01\n\x1f\x64\x65lete_compatible_redirect_rule\x18\t \x01(\x0b\x32g.temporal.api.workflowservice.v1.UpdateWorkerVersioningRulesRequest.DeleteCompatibleBuildIdRedirectRuleH\x00\x12l\n\x0f\x63ommit_build_id\x18\n \x01(\x0b\x32Q.temporal.api.workflowservice.v1.UpdateWorkerVersioningRulesRequest.CommitBuildIdH\x00\x1aq\n\x1bInsertBuildIdAssignmentRule\x12\x12\n\nrule_index\x18\x01 \x01(\x05\x12>\n\x04rule\x18\x02 \x01(\x0b\x32\x30.temporal.api.taskqueue.v1.BuildIdAssignmentRule\x1a\x81\x01\n\x1cReplaceBuildIdAssignmentRule\x12\x12\n\nrule_index\x18\x01 \x01(\x05\x12>\n\x04rule\x18\x02 \x01(\x0b\x32\x30.temporal.api.taskqueue.v1.BuildIdAssignmentRule\x12\r\n\x05\x66orce\x18\x03 \x01(\x08\x1a@\n\x1b\x44\x65leteBuildIdAssignmentRule\x12\x12\n\nrule_index\x18\x01 \x01(\x05\x12\r\n\x05\x66orce\x18\x02 \x01(\x08\x1aj\n AddCompatibleBuildIdRedirectRule\x12\x46\n\x04rule\x18\x01 \x01(\x0b\x32\x38.temporal.api.taskqueue.v1.CompatibleBuildIdRedirectRule\x1an\n$ReplaceCompatibleBuildIdRedirectRule\x12\x46\n\x04rule\x18\x01 \x01(\x0b\x32\x38.temporal.api.taskqueue.v1.CompatibleBuildIdRedirectRule\x1a>\n#DeleteCompatibleBuildIdRedirectRule\x12\x17\n\x0fsource_build_id\x18\x01 \x01(\t\x1a\x37\n\rCommitBuildId\x12\x17\n\x0ftarget_build_id\x18\x01 \x01(\t\x12\r\n\x05\x66orce\x18\x02 \x01(\x08\x42\x0b\n\toperation"\xfc\x01\n#UpdateWorkerVersioningRulesResponse\x12U\n\x10\x61ssignment_rules\x18\x01 \x03(\x0b\x32;.temporal.api.taskqueue.v1.TimestampedBuildIdAssignmentRule\x12\x66\n\x19\x63ompatible_redirect_rules\x18\x02 \x03(\x0b\x32\x43.temporal.api.taskqueue.v1.TimestampedCompatibleBuildIdRedirectRule\x12\x16\n\x0e\x63onflict_token\x18\x03 \x01(\x0c"H\n\x1fGetWorkerVersioningRulesRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x12\n\ntask_queue\x18\x02 \x01(\t"\xf9\x01\n GetWorkerVersioningRulesResponse\x12U\n\x10\x61ssignment_rules\x18\x01 \x03(\x0b\x32;.temporal.api.taskqueue.v1.TimestampedBuildIdAssignmentRule\x12\x66\n\x19\x63ompatible_redirect_rules\x18\x02 \x03(\x0b\x32\x43.temporal.api.taskqueue.v1.TimestampedCompatibleBuildIdRedirectRule\x12\x16\n\x0e\x63onflict_token\x18\x03 \x01(\x0c"\x9c\x01\n GetWorkerTaskReachabilityRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x11\n\tbuild_ids\x18\x02 \x03(\t\x12\x13\n\x0btask_queues\x18\x03 \x03(\t\x12=\n\x0creachability\x18\x04 \x01(\x0e\x32\'.temporal.api.enums.v1.TaskReachability"r\n!GetWorkerTaskReachabilityResponse\x12M\n\x15\x62uild_id_reachability\x18\x01 \x03(\x0b\x32..temporal.api.taskqueue.v1.BuildIdReachability"\x85\x02\n\x1eUpdateWorkflowExecutionRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x45\n\x12workflow_execution\x18\x02 \x01(\x0b\x32).temporal.api.common.v1.WorkflowExecution\x12\x1e\n\x16\x66irst_execution_run_id\x18\x03 \x01(\t\x12\x37\n\x0bwait_policy\x18\x04 \x01(\x0b\x32".temporal.api.update.v1.WaitPolicy\x12\x30\n\x07request\x18\x05 \x01(\x0b\x32\x1f.temporal.api.update.v1.Request"\xd7\x01\n\x1fUpdateWorkflowExecutionResponse\x12\x35\n\nupdate_ref\x18\x01 \x01(\x0b\x32!.temporal.api.update.v1.UpdateRef\x12\x30\n\x07outcome\x18\x02 \x01(\x0b\x32\x1f.temporal.api.update.v1.Outcome\x12K\n\x05stage\x18\x03 \x01(\x0e\x32<.temporal.api.enums.v1.UpdateWorkflowExecutionLifecycleStage"\xf4\x07\n\x1aStartBatchOperationRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x18\n\x10visibility_query\x18\x02 \x01(\t\x12\x0e\n\x06job_id\x18\x03 \x01(\t\x12\x0e\n\x06reason\x18\x04 \x01(\t\x12=\n\nexecutions\x18\x05 \x03(\x0b\x32).temporal.api.common.v1.WorkflowExecution\x12!\n\x19max_operations_per_second\x18\x06 \x01(\x02\x12Q\n\x15termination_operation\x18\n \x01(\x0b\x32\x30.temporal.api.batch.v1.BatchOperationTerminationH\x00\x12G\n\x10signal_operation\x18\x0b \x01(\x0b\x32+.temporal.api.batch.v1.BatchOperationSignalH\x00\x12S\n\x16\x63\x61ncellation_operation\x18\x0c \x01(\x0b\x32\x31.temporal.api.batch.v1.BatchOperationCancellationH\x00\x12K\n\x12\x64\x65letion_operation\x18\r \x01(\x0b\x32-.temporal.api.batch.v1.BatchOperationDeletionH\x00\x12\x45\n\x0freset_operation\x18\x0e \x01(\x0b\x32*.temporal.api.batch.v1.BatchOperationResetH\x00\x12p\n!update_workflow_options_operation\x18\x0f \x01(\x0b\x32\x43.temporal.api.batch.v1.BatchOperationUpdateWorkflowExecutionOptionsH\x00\x12^\n\x1cunpause_activities_operation\x18\x10 \x01(\x0b\x32\x36.temporal.api.batch.v1.BatchOperationUnpauseActivitiesH\x00\x12Z\n\x1areset_activities_operation\x18\x11 \x01(\x0b\x32\x34.temporal.api.batch.v1.BatchOperationResetActivitiesH\x00\x12g\n!update_activity_options_operation\x18\x12 \x01(\x0b\x32:.temporal.api.batch.v1.BatchOperationUpdateActivityOptionsH\x00\x42\x0b\n\toperation"\x1d\n\x1bStartBatchOperationResponse"`\n\x19StopBatchOperationRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x0e\n\x06job_id\x18\x02 \x01(\t\x12\x0e\n\x06reason\x18\x03 \x01(\t\x12\x10\n\x08identity\x18\x04 \x01(\t"\x1c\n\x1aStopBatchOperationResponse"B\n\x1d\x44\x65scribeBatchOperationRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x0e\n\x06job_id\x18\x02 \x01(\t"\x92\x03\n\x1e\x44\x65scribeBatchOperationResponse\x12\x41\n\x0eoperation_type\x18\x01 \x01(\x0e\x32).temporal.api.enums.v1.BatchOperationType\x12\x0e\n\x06job_id\x18\x02 \x01(\t\x12\x39\n\x05state\x18\x03 \x01(\x0e\x32*.temporal.api.enums.v1.BatchOperationState\x12.\n\nstart_time\x18\x04 \x01(\x0b\x32\x1a.google.protobuf.Timestamp\x12.\n\nclose_time\x18\x05 \x01(\x0b\x32\x1a.google.protobuf.Timestamp\x12\x1d\n\x15total_operation_count\x18\x06 \x01(\x03\x12 \n\x18\x63omplete_operation_count\x18\x07 \x01(\x03\x12\x1f\n\x17\x66\x61ilure_operation_count\x18\x08 \x01(\x03\x12\x10\n\x08identity\x18\t \x01(\t\x12\x0e\n\x06reason\x18\n \x01(\t"[\n\x1aListBatchOperationsRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x11\n\tpage_size\x18\x02 \x01(\x05\x12\x17\n\x0fnext_page_token\x18\x03 \x01(\x0c"y\n\x1bListBatchOperationsResponse\x12\x41\n\x0eoperation_info\x18\x01 \x03(\x0b\x32).temporal.api.batch.v1.BatchOperationInfo\x12\x17\n\x0fnext_page_token\x18\x02 \x01(\x0c"\xb9\x01\n"PollWorkflowExecutionUpdateRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x35\n\nupdate_ref\x18\x02 \x01(\x0b\x32!.temporal.api.update.v1.UpdateRef\x12\x10\n\x08identity\x18\x03 \x01(\t\x12\x37\n\x0bwait_policy\x18\x04 \x01(\x0b\x32".temporal.api.update.v1.WaitPolicy"\xdb\x01\n#PollWorkflowExecutionUpdateResponse\x12\x30\n\x07outcome\x18\x01 \x01(\x0b\x32\x1f.temporal.api.update.v1.Outcome\x12K\n\x05stage\x18\x02 \x01(\x0e\x32<.temporal.api.enums.v1.UpdateWorkflowExecutionLifecycleStage\x12\x35\n\nupdate_ref\x18\x03 \x01(\x0b\x32!.temporal.api.update.v1.UpdateRef"\xea\x02\n\x19PollNexusTaskQueueRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x10\n\x08identity\x18\x02 \x01(\t\x12\x38\n\ntask_queue\x18\x03 \x01(\x0b\x32$.temporal.api.taskqueue.v1.TaskQueue\x12Z\n\x1bworker_version_capabilities\x18\x04 \x01(\x0b\x32\x31.temporal.api.common.v1.WorkerVersionCapabilitiesB\x02\x18\x01\x12O\n\x12\x64\x65ployment_options\x18\x06 \x01(\x0b\x32\x33.temporal.api.deployment.v1.WorkerDeploymentOptions\x12\x41\n\x10worker_heartbeat\x18\x07 \x03(\x0b\x32\'.temporal.api.worker.v1.WorkerHeartbeat"\xb4\x01\n\x1aPollNexusTaskQueueResponse\x12\x12\n\ntask_token\x18\x01 \x01(\x0c\x12/\n\x07request\x18\x02 \x01(\x0b\x32\x1e.temporal.api.nexus.v1.Request\x12Q\n\x17poller_scaling_decision\x18\x03 \x01(\x0b\x32\x30.temporal.api.taskqueue.v1.PollerScalingDecision"\x8e\x01\n RespondNexusTaskCompletedRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x10\n\x08identity\x18\x02 \x01(\t\x12\x12\n\ntask_token\x18\x03 \x01(\x0c\x12\x31\n\x08response\x18\x04 \x01(\x0b\x32\x1f.temporal.api.nexus.v1.Response"#\n!RespondNexusTaskCompletedResponse"\x8c\x01\n\x1dRespondNexusTaskFailedRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x10\n\x08identity\x18\x02 \x01(\t\x12\x12\n\ntask_token\x18\x03 \x01(\x0c\x12\x32\n\x05\x65rror\x18\x04 \x01(\x0b\x32#.temporal.api.nexus.v1.HandlerError" \n\x1eRespondNexusTaskFailedResponse"\xdf\x02\n\x1c\x45xecuteMultiOperationRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12[\n\noperations\x18\x02 \x03(\x0b\x32G.temporal.api.workflowservice.v1.ExecuteMultiOperationRequest.Operation\x1a\xce\x01\n\tOperation\x12X\n\x0estart_workflow\x18\x01 \x01(\x0b\x32>.temporal.api.workflowservice.v1.StartWorkflowExecutionRequestH\x00\x12Z\n\x0fupdate_workflow\x18\x02 \x01(\x0b\x32?.temporal.api.workflowservice.v1.UpdateWorkflowExecutionRequestH\x00\x42\x0b\n\toperation"\xcc\x02\n\x1d\x45xecuteMultiOperationResponse\x12Z\n\tresponses\x18\x01 \x03(\x0b\x32G.temporal.api.workflowservice.v1.ExecuteMultiOperationResponse.Response\x1a\xce\x01\n\x08Response\x12Y\n\x0estart_workflow\x18\x01 \x01(\x0b\x32?.temporal.api.workflowservice.v1.StartWorkflowExecutionResponseH\x00\x12[\n\x0fupdate_workflow\x18\x02 \x01(\x0b\x32@.temporal.api.workflowservice.v1.UpdateWorkflowExecutionResponseH\x00\x42\n\n\x08response"\xd0\x02\n\x1cUpdateActivityOptionsRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12<\n\texecution\x18\x02 \x01(\x0b\x32).temporal.api.common.v1.WorkflowExecution\x12\x10\n\x08identity\x18\x03 \x01(\t\x12\x43\n\x10\x61\x63tivity_options\x18\x04 \x01(\x0b\x32).temporal.api.activity.v1.ActivityOptions\x12/\n\x0bupdate_mask\x18\x05 \x01(\x0b\x32\x1a.google.protobuf.FieldMask\x12\x0c\n\x02id\x18\x06 \x01(\tH\x00\x12\x0e\n\x04type\x18\x07 \x01(\tH\x00\x12\x13\n\tmatch_all\x18\t \x01(\x08H\x00\x12\x18\n\x10restore_original\x18\x08 \x01(\x08\x42\n\n\x08\x61\x63tivity"d\n\x1dUpdateActivityOptionsResponse\x12\x43\n\x10\x61\x63tivity_options\x18\x01 \x01(\x0b\x32).temporal.api.activity.v1.ActivityOptions"\xb3\x01\n\x14PauseActivityRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12<\n\texecution\x18\x02 \x01(\x0b\x32).temporal.api.common.v1.WorkflowExecution\x12\x10\n\x08identity\x18\x03 \x01(\t\x12\x0c\n\x02id\x18\x04 \x01(\tH\x00\x12\x0e\n\x04type\x18\x05 \x01(\tH\x00\x12\x0e\n\x06reason\x18\x06 \x01(\tB\n\n\x08\x61\x63tivity"\x17\n\x15PauseActivityResponse"\x98\x02\n\x16UnpauseActivityRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12<\n\texecution\x18\x02 \x01(\x0b\x32).temporal.api.common.v1.WorkflowExecution\x12\x10\n\x08identity\x18\x03 \x01(\t\x12\x0c\n\x02id\x18\x04 \x01(\tH\x00\x12\x0e\n\x04type\x18\x05 \x01(\tH\x00\x12\x15\n\x0bunpause_all\x18\x06 \x01(\x08H\x00\x12\x16\n\x0ereset_attempts\x18\x07 \x01(\x08\x12\x17\n\x0freset_heartbeat\x18\x08 \x01(\x08\x12)\n\x06jitter\x18\t \x01(\x0b\x32\x19.google.protobuf.DurationB\n\n\x08\x61\x63tivity"\x19\n\x17UnpauseActivityResponse"\xb3\x02\n\x14ResetActivityRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12<\n\texecution\x18\x02 \x01(\x0b\x32).temporal.api.common.v1.WorkflowExecution\x12\x10\n\x08identity\x18\x03 \x01(\t\x12\x0c\n\x02id\x18\x04 \x01(\tH\x00\x12\x0e\n\x04type\x18\x05 \x01(\tH\x00\x12\x13\n\tmatch_all\x18\n \x01(\x08H\x00\x12\x17\n\x0freset_heartbeat\x18\x06 \x01(\x08\x12\x13\n\x0bkeep_paused\x18\x07 \x01(\x08\x12)\n\x06jitter\x18\x08 \x01(\x0b\x32\x19.google.protobuf.Duration\x12 \n\x18restore_original_options\x18\t \x01(\x08\x42\n\n\x08\x61\x63tivity"\x17\n\x15ResetActivityResponse"\x8a\x02\n%UpdateWorkflowExecutionOptionsRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x45\n\x12workflow_execution\x18\x02 \x01(\x0b\x32).temporal.api.common.v1.WorkflowExecution\x12V\n\x1aworkflow_execution_options\x18\x03 \x01(\x0b\x32\x32.temporal.api.workflow.v1.WorkflowExecutionOptions\x12/\n\x0bupdate_mask\x18\x04 \x01(\x0b\x32\x1a.google.protobuf.FieldMask"\x80\x01\n&UpdateWorkflowExecutionOptionsResponse\x12V\n\x1aworkflow_execution_options\x18\x01 \x01(\x0b\x32\x32.temporal.api.workflow.v1.WorkflowExecutionOptions"j\n\x19\x44\x65scribeDeploymentRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12:\n\ndeployment\x18\x02 \x01(\x0b\x32&.temporal.api.deployment.v1.Deployment"a\n\x1a\x44\x65scribeDeploymentResponse\x12\x43\n\x0f\x64\x65ployment_info\x18\x01 \x01(\x0b\x32*.temporal.api.deployment.v1.DeploymentInfo"\xc2\x01\n&DescribeWorkerDeploymentVersionRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x13\n\x07version\x18\x02 \x01(\tB\x02\x18\x01\x12O\n\x12\x64\x65ployment_version\x18\x03 \x01(\x0b\x32\x33.temporal.api.deployment.v1.WorkerDeploymentVersion\x12\x1f\n\x17report_task_queue_stats\x18\x04 \x01(\x08"\x8c\x05\n\'DescribeWorkerDeploymentVersionResponse\x12_\n\x1eworker_deployment_version_info\x18\x01 \x01(\x0b\x32\x37.temporal.api.deployment.v1.WorkerDeploymentVersionInfo\x12v\n\x13version_task_queues\x18\x02 \x03(\x0b\x32Y.temporal.api.workflowservice.v1.DescribeWorkerDeploymentVersionResponse.VersionTaskQueue\x1a\x87\x03\n\x10VersionTaskQueue\x12\x0c\n\x04name\x18\x01 \x01(\t\x12\x32\n\x04type\x18\x02 \x01(\x0e\x32$.temporal.api.enums.v1.TaskQueueType\x12\x38\n\x05stats\x18\x03 \x01(\x0b\x32).temporal.api.taskqueue.v1.TaskQueueStats\x12\x90\x01\n\x15stats_by_priority_key\x18\x04 \x03(\x0b\x32q.temporal.api.workflowservice.v1.DescribeWorkerDeploymentVersionResponse.VersionTaskQueue.StatsByPriorityKeyEntry\x1a\x64\n\x17StatsByPriorityKeyEntry\x12\x0b\n\x03key\x18\x01 \x01(\x05\x12\x38\n\x05value\x18\x02 \x01(\x0b\x32).temporal.api.taskqueue.v1.TaskQueueStats:\x02\x38\x01"M\n\x1f\x44\x65scribeWorkerDeploymentRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x17\n\x0f\x64\x65ployment_name\x18\x02 \x01(\t"\x8c\x01\n DescribeWorkerDeploymentResponse\x12\x16\n\x0e\x63onflict_token\x18\x01 \x01(\x0c\x12P\n\x16worker_deployment_info\x18\x02 \x01(\x0b\x32\x30.temporal.api.deployment.v1.WorkerDeploymentInfo"l\n\x16ListDeploymentsRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x11\n\tpage_size\x18\x02 \x01(\x05\x12\x17\n\x0fnext_page_token\x18\x03 \x01(\x0c\x12\x13\n\x0bseries_name\x18\x04 \x01(\t"w\n\x17ListDeploymentsResponse\x12\x17\n\x0fnext_page_token\x18\x01 \x01(\x0c\x12\x43\n\x0b\x64\x65ployments\x18\x02 \x03(\x0b\x32..temporal.api.deployment.v1.DeploymentListInfo"\xcd\x01\n\x1bSetCurrentDeploymentRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12:\n\ndeployment\x18\x02 \x01(\x0b\x32&.temporal.api.deployment.v1.Deployment\x12\x10\n\x08identity\x18\x03 \x01(\t\x12M\n\x0fupdate_metadata\x18\x04 \x01(\x0b\x32\x34.temporal.api.deployment.v1.UpdateDeploymentMetadata"\xb9\x01\n\x1cSetCurrentDeploymentResponse\x12K\n\x17\x63urrent_deployment_info\x18\x01 \x01(\x0b\x32*.temporal.api.deployment.v1.DeploymentInfo\x12L\n\x18previous_deployment_info\x18\x02 \x01(\x0b\x32*.temporal.api.deployment.v1.DeploymentInfo"\xe5\x01\n(SetWorkerDeploymentCurrentVersionRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x17\n\x0f\x64\x65ployment_name\x18\x02 \x01(\t\x12\x13\n\x07version\x18\x03 \x01(\tB\x02\x18\x01\x12\x10\n\x08\x62uild_id\x18\x07 \x01(\t\x12\x16\n\x0e\x63onflict_token\x18\x04 \x01(\x0c\x12\x10\n\x08identity\x18\x05 \x01(\t\x12"\n\x1aignore_missing_task_queues\x18\x06 \x01(\x08\x12\x18\n\x10\x61llow_no_pollers\x18\t \x01(\x08"\xbb\x01\n)SetWorkerDeploymentCurrentVersionResponse\x12\x16\n\x0e\x63onflict_token\x18\x01 \x01(\x0c\x12\x1c\n\x10previous_version\x18\x02 \x01(\tB\x02\x18\x01\x12X\n\x1bprevious_deployment_version\x18\x03 \x01(\x0b\x32\x33.temporal.api.deployment.v1.WorkerDeploymentVersion"\xf9\x01\n(SetWorkerDeploymentRampingVersionRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x17\n\x0f\x64\x65ployment_name\x18\x02 \x01(\t\x12\x13\n\x07version\x18\x03 \x01(\tB\x02\x18\x01\x12\x10\n\x08\x62uild_id\x18\x08 \x01(\t\x12\x12\n\npercentage\x18\x04 \x01(\x02\x12\x16\n\x0e\x63onflict_token\x18\x05 \x01(\x0c\x12\x10\n\x08identity\x18\x06 \x01(\t\x12"\n\x1aignore_missing_task_queues\x18\x07 \x01(\x08\x12\x18\n\x10\x61llow_no_pollers\x18\n \x01(\x08"\xd8\x01\n)SetWorkerDeploymentRampingVersionResponse\x12\x16\n\x0e\x63onflict_token\x18\x01 \x01(\x0c\x12\x1c\n\x10previous_version\x18\x02 \x01(\tB\x02\x18\x01\x12X\n\x1bprevious_deployment_version\x18\x04 \x01(\x0b\x32\x33.temporal.api.deployment.v1.WorkerDeploymentVersion\x12\x1b\n\x13previous_percentage\x18\x03 \x01(\x02"]\n\x1cListWorkerDeploymentsRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x11\n\tpage_size\x18\x02 \x01(\x05\x12\x17\n\x0fnext_page_token\x18\x03 \x01(\x0c"\x9f\x05\n\x1dListWorkerDeploymentsResponse\x12\x17\n\x0fnext_page_token\x18\x01 \x01(\x0c\x12r\n\x12worker_deployments\x18\x02 \x03(\x0b\x32V.temporal.api.workflowservice.v1.ListWorkerDeploymentsResponse.WorkerDeploymentSummary\x1a\xf0\x03\n\x17WorkerDeploymentSummary\x12\x0c\n\x04name\x18\x01 \x01(\t\x12/\n\x0b\x63reate_time\x18\x02 \x01(\x0b\x32\x1a.google.protobuf.Timestamp\x12\x41\n\x0erouting_config\x18\x03 \x01(\x0b\x32).temporal.api.deployment.v1.RoutingConfig\x12o\n\x16latest_version_summary\x18\x04 \x01(\x0b\x32O.temporal.api.deployment.v1.WorkerDeploymentInfo.WorkerDeploymentVersionSummary\x12p\n\x17\x63urrent_version_summary\x18\x05 \x01(\x0b\x32O.temporal.api.deployment.v1.WorkerDeploymentInfo.WorkerDeploymentVersionSummary\x12p\n\x17ramping_version_summary\x18\x06 \x01(\x0b\x32O.temporal.api.deployment.v1.WorkerDeploymentInfo.WorkerDeploymentVersionSummary"\xc8\x01\n$DeleteWorkerDeploymentVersionRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x13\n\x07version\x18\x02 \x01(\tB\x02\x18\x01\x12O\n\x12\x64\x65ployment_version\x18\x05 \x01(\x0b\x32\x33.temporal.api.deployment.v1.WorkerDeploymentVersion\x12\x15\n\rskip_drainage\x18\x03 \x01(\x08\x12\x10\n\x08identity\x18\x04 \x01(\t"\'\n%DeleteWorkerDeploymentVersionResponse"]\n\x1d\x44\x65leteWorkerDeploymentRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x17\n\x0f\x64\x65ployment_name\x18\x02 \x01(\t\x12\x10\n\x08identity\x18\x03 \x01(\t" \n\x1e\x44\x65leteWorkerDeploymentResponse"\xa2\x03\n,UpdateWorkerDeploymentVersionMetadataRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x13\n\x07version\x18\x02 \x01(\tB\x02\x18\x01\x12O\n\x12\x64\x65ployment_version\x18\x05 \x01(\x0b\x32\x33.temporal.api.deployment.v1.WorkerDeploymentVersion\x12x\n\x0eupsert_entries\x18\x03 \x03(\x0b\x32`.temporal.api.workflowservice.v1.UpdateWorkerDeploymentVersionMetadataRequest.UpsertEntriesEntry\x12\x16\n\x0eremove_entries\x18\x04 \x03(\t\x12\x10\n\x08identity\x18\x06 \x01(\t\x1aU\n\x12UpsertEntriesEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12.\n\x05value\x18\x02 \x01(\x0b\x32\x1f.temporal.api.common.v1.Payload:\x02\x38\x01"n\n-UpdateWorkerDeploymentVersionMetadataResponse\x12=\n\x08metadata\x18\x01 \x01(\x0b\x32+.temporal.api.deployment.v1.VersionMetadata"\xbd\x01\n!SetWorkerDeploymentManagerRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x17\n\x0f\x64\x65ployment_name\x18\x02 \x01(\t\x12\x1a\n\x10manager_identity\x18\x03 \x01(\tH\x00\x12\x0e\n\x04self\x18\x04 \x01(\x08H\x00\x12\x16\n\x0e\x63onflict_token\x18\x05 \x01(\x0c\x12\x10\n\x08identity\x18\x06 \x01(\tB\x16\n\x14new_manager_identity"_\n"SetWorkerDeploymentManagerResponse\x12\x16\n\x0e\x63onflict_token\x18\x01 \x01(\x0c\x12!\n\x19previous_manager_identity\x18\x02 \x01(\t"E\n\x1bGetCurrentDeploymentRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x13\n\x0bseries_name\x18\x02 \x01(\t"k\n\x1cGetCurrentDeploymentResponse\x12K\n\x17\x63urrent_deployment_info\x18\x01 \x01(\x0b\x32*.temporal.api.deployment.v1.DeploymentInfo"q\n GetDeploymentReachabilityRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12:\n\ndeployment\x18\x02 \x01(\x0b\x32&.temporal.api.deployment.v1.Deployment"\xe3\x01\n!GetDeploymentReachabilityResponse\x12\x43\n\x0f\x64\x65ployment_info\x18\x01 \x01(\x0b\x32*.temporal.api.deployment.v1.DeploymentInfo\x12\x43\n\x0creachability\x18\x02 \x01(\x0e\x32-.temporal.api.enums.v1.DeploymentReachability\x12\x34\n\x10last_update_time\x18\x03 \x01(\x0b\x32\x1a.google.protobuf.Timestamp"\xb4\x01\n\x19\x43reateWorkflowRuleRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x35\n\x04spec\x18\x02 \x01(\x0b\x32\'.temporal.api.rules.v1.WorkflowRuleSpec\x12\x12\n\nforce_scan\x18\x03 \x01(\x08\x12\x12\n\nrequest_id\x18\x04 \x01(\t\x12\x10\n\x08identity\x18\x05 \x01(\t\x12\x13\n\x0b\x64\x65scription\x18\x06 \x01(\t"_\n\x1a\x43reateWorkflowRuleResponse\x12\x31\n\x04rule\x18\x01 \x01(\x0b\x32#.temporal.api.rules.v1.WorkflowRule\x12\x0e\n\x06job_id\x18\x02 \x01(\t"A\n\x1b\x44\x65scribeWorkflowRuleRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x0f\n\x07rule_id\x18\x02 \x01(\t"Q\n\x1c\x44\x65scribeWorkflowRuleResponse\x12\x31\n\x04rule\x18\x01 \x01(\x0b\x32#.temporal.api.rules.v1.WorkflowRule"?\n\x19\x44\x65leteWorkflowRuleRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x0f\n\x07rule_id\x18\x02 \x01(\t"\x1c\n\x1a\x44\x65leteWorkflowRuleResponse"F\n\x18ListWorkflowRulesRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x17\n\x0fnext_page_token\x18\x02 \x01(\x0c"h\n\x19ListWorkflowRulesResponse\x12\x32\n\x05rules\x18\x01 \x03(\x0b\x32#.temporal.api.rules.v1.WorkflowRule\x12\x17\n\x0fnext_page_token\x18\x02 \x01(\x0c"\xce\x01\n\x1aTriggerWorkflowRuleRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12<\n\texecution\x18\x02 \x01(\x0b\x32).temporal.api.common.v1.WorkflowExecution\x12\x0c\n\x02id\x18\x04 \x01(\tH\x00\x12\x37\n\x04spec\x18\x05 \x01(\x0b\x32\'.temporal.api.rules.v1.WorkflowRuleSpecH\x00\x12\x10\n\x08identity\x18\x03 \x01(\tB\x06\n\x04rule".\n\x1bTriggerWorkflowRuleResponse\x12\x0f\n\x07\x61pplied\x18\x01 \x01(\x08"\x86\x01\n\x1cRecordWorkerHeartbeatRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x10\n\x08identity\x18\x02 \x01(\t\x12\x41\n\x10worker_heartbeat\x18\x03 \x03(\x0b\x32\'.temporal.api.worker.v1.WorkerHeartbeat"\x1f\n\x1dRecordWorkerHeartbeatResponse"b\n\x12ListWorkersRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x11\n\tpage_size\x18\x02 \x01(\x05\x12\x17\n\x0fnext_page_token\x18\x03 \x01(\x0c\x12\r\n\x05query\x18\x04 \x01(\t"h\n\x13ListWorkersResponse\x12\x38\n\x0cworkers_info\x18\x01 \x03(\x0b\x32".temporal.api.worker.v1.WorkerInfo\x12\x17\n\x0fnext_page_token\x18\x02 \x01(\x0c"\xe2\x03\n\x1cUpdateTaskQueueConfigRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x10\n\x08identity\x18\x02 \x01(\t\x12\x12\n\ntask_queue\x18\x03 \x01(\t\x12=\n\x0ftask_queue_type\x18\x04 \x01(\x0e\x32$.temporal.api.enums.v1.TaskQueueType\x12n\n\x17update_queue_rate_limit\x18\x05 \x01(\x0b\x32M.temporal.api.workflowservice.v1.UpdateTaskQueueConfigRequest.RateLimitUpdate\x12}\n&update_fairness_key_rate_limit_default\x18\x06 \x01(\x0b\x32M.temporal.api.workflowservice.v1.UpdateTaskQueueConfigRequest.RateLimitUpdate\x1a[\n\x0fRateLimitUpdate\x12\x38\n\nrate_limit\x18\x01 \x01(\x0b\x32$.temporal.api.taskqueue.v1.RateLimit\x12\x0e\n\x06reason\x18\x02 \x01(\t"[\n\x1dUpdateTaskQueueConfigResponse\x12:\n\x06\x63onfig\x18\x01 \x01(\x0b\x32*.temporal.api.taskqueue.v1.TaskQueueConfig"\x89\x01\n\x18\x46\x65tchWorkerConfigRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x10\n\x08identity\x18\x02 \x01(\t\x12\x0e\n\x06reason\x18\x03 \x01(\t\x12\x38\n\x08selector\x18\x06 \x01(\x0b\x32&.temporal.api.common.v1.WorkerSelector"U\n\x19\x46\x65tchWorkerConfigResponse\x12\x38\n\rworker_config\x18\x01 \x01(\x0b\x32!.temporal.api.sdk.v1.WorkerConfig"\xf5\x01\n\x19UpdateWorkerConfigRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x10\n\x08identity\x18\x02 \x01(\t\x12\x0e\n\x06reason\x18\x03 \x01(\t\x12\x38\n\rworker_config\x18\x04 \x01(\x0b\x32!.temporal.api.sdk.v1.WorkerConfig\x12/\n\x0bupdate_mask\x18\x05 \x01(\x0b\x32\x1a.google.protobuf.FieldMask\x12\x38\n\x08selector\x18\x06 \x01(\x0b\x32&.temporal.api.common.v1.WorkerSelector"d\n\x1aUpdateWorkerConfigResponse\x12:\n\rworker_config\x18\x01 \x01(\x0b\x32!.temporal.api.sdk.v1.WorkerConfigH\x00\x42\n\n\x08response"G\n\x15\x44\x65scribeWorkerRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x1b\n\x13worker_instance_key\x18\x02 \x01(\t"Q\n\x16\x44\x65scribeWorkerResponse\x12\x37\n\x0bworker_info\x18\x01 \x01(\x0b\x32".temporal.api.worker.v1.WorkerInfoB\xbe\x01\n"io.temporal.api.workflowservice.v1B\x14RequestResponseProtoP\x01Z5go.temporal.io/api/workflowservice/v1;workflowservice\xaa\x02!Temporalio.Api.WorkflowService.V1\xea\x02$Temporalio::Api::WorkflowService::V1b\x06proto3' + b'\n6temporal/api/workflowservice/v1/request_response.proto\x12\x1ftemporal.api.workflowservice.v1\x1a+temporal/api/enums/v1/batch_operation.proto\x1a"temporal/api/enums/v1/common.proto\x1a$temporal/api/enums/v1/workflow.proto\x1a%temporal/api/enums/v1/namespace.proto\x1a(temporal/api/enums/v1/failed_cause.proto\x1a!temporal/api/enums/v1/query.proto\x1a!temporal/api/enums/v1/reset.proto\x1a&temporal/api/enums/v1/task_queue.proto\x1a&temporal/api/enums/v1/deployment.proto\x1a"temporal/api/enums/v1/update.proto\x1a$temporal/api/enums/v1/activity.proto\x1a&temporal/api/activity/v1/message.proto\x1a$temporal/api/common/v1/message.proto\x1a%temporal/api/history/v1/message.proto\x1a&temporal/api/workflow/v1/message.proto\x1a%temporal/api/command/v1/message.proto\x1a(temporal/api/deployment/v1/message.proto\x1a%temporal/api/failure/v1/message.proto\x1a$temporal/api/filter/v1/message.proto\x1a&temporal/api/protocol/v1/message.proto\x1a\'temporal/api/namespace/v1/message.proto\x1a#temporal/api/query/v1/message.proto\x1a)temporal/api/replication/v1/message.proto\x1a#temporal/api/rules/v1/message.proto\x1a\'temporal/api/sdk/v1/worker_config.proto\x1a&temporal/api/schedule/v1/message.proto\x1a\'temporal/api/taskqueue/v1/message.proto\x1a$temporal/api/update/v1/message.proto\x1a%temporal/api/version/v1/message.proto\x1a#temporal/api/batch/v1/message.proto\x1a\x30temporal/api/sdk/v1/task_complete_metadata.proto\x1a\'temporal/api/sdk/v1/user_metadata.proto\x1a#temporal/api/nexus/v1/message.proto\x1a$temporal/api/worker/v1/message.proto\x1a\x1egoogle/protobuf/duration.proto\x1a google/protobuf/field_mask.proto\x1a\x1fgoogle/protobuf/timestamp.proto"\x88\x05\n\x18RegisterNamespaceRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x13\n\x0b\x64\x65scription\x18\x02 \x01(\t\x12\x13\n\x0bowner_email\x18\x03 \x01(\t\x12\x46\n#workflow_execution_retention_period\x18\x04 \x01(\x0b\x32\x19.google.protobuf.Duration\x12G\n\x08\x63lusters\x18\x05 \x03(\x0b\x32\x35.temporal.api.replication.v1.ClusterReplicationConfig\x12\x1b\n\x13\x61\x63tive_cluster_name\x18\x06 \x01(\t\x12Q\n\x04\x64\x61ta\x18\x07 \x03(\x0b\x32\x43.temporal.api.workflowservice.v1.RegisterNamespaceRequest.DataEntry\x12\x16\n\x0esecurity_token\x18\x08 \x01(\t\x12\x1b\n\x13is_global_namespace\x18\t \x01(\x08\x12\x44\n\x16history_archival_state\x18\n \x01(\x0e\x32$.temporal.api.enums.v1.ArchivalState\x12\x1c\n\x14history_archival_uri\x18\x0b \x01(\t\x12G\n\x19visibility_archival_state\x18\x0c \x01(\x0e\x32$.temporal.api.enums.v1.ArchivalState\x12\x1f\n\x17visibility_archival_uri\x18\r \x01(\t\x1a+\n\tDataEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\t:\x02\x38\x01"\x1b\n\x19RegisterNamespaceResponse"\x89\x01\n\x15ListNamespacesRequest\x12\x11\n\tpage_size\x18\x01 \x01(\x05\x12\x17\n\x0fnext_page_token\x18\x02 \x01(\x0c\x12\x44\n\x10namespace_filter\x18\x03 \x01(\x0b\x32*.temporal.api.namespace.v1.NamespaceFilter"\x81\x01\n\x16ListNamespacesResponse\x12N\n\nnamespaces\x18\x01 \x03(\x0b\x32:.temporal.api.workflowservice.v1.DescribeNamespaceResponse\x12\x17\n\x0fnext_page_token\x18\x02 \x01(\x0c"9\n\x18\x44\x65scribeNamespaceRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\n\n\x02id\x18\x02 \x01(\t"\xec\x02\n\x19\x44\x65scribeNamespaceResponse\x12@\n\x0enamespace_info\x18\x01 \x01(\x0b\x32(.temporal.api.namespace.v1.NamespaceInfo\x12:\n\x06\x63onfig\x18\x02 \x01(\x0b\x32*.temporal.api.namespace.v1.NamespaceConfig\x12S\n\x12replication_config\x18\x03 \x01(\x0b\x32\x37.temporal.api.replication.v1.NamespaceReplicationConfig\x12\x18\n\x10\x66\x61ilover_version\x18\x04 \x01(\x03\x12\x1b\n\x13is_global_namespace\x18\x05 \x01(\x08\x12\x45\n\x10\x66\x61ilover_history\x18\x06 \x03(\x0b\x32+.temporal.api.replication.v1.FailoverStatus"\xcf\x02\n\x16UpdateNamespaceRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x43\n\x0bupdate_info\x18\x02 \x01(\x0b\x32..temporal.api.namespace.v1.UpdateNamespaceInfo\x12:\n\x06\x63onfig\x18\x03 \x01(\x0b\x32*.temporal.api.namespace.v1.NamespaceConfig\x12S\n\x12replication_config\x18\x04 \x01(\x0b\x32\x37.temporal.api.replication.v1.NamespaceReplicationConfig\x12\x16\n\x0esecurity_token\x18\x05 \x01(\t\x12\x19\n\x11\x64\x65lete_bad_binary\x18\x06 \x01(\t\x12\x19\n\x11promote_namespace\x18\x07 \x01(\x08"\xa3\x02\n\x17UpdateNamespaceResponse\x12@\n\x0enamespace_info\x18\x01 \x01(\x0b\x32(.temporal.api.namespace.v1.NamespaceInfo\x12:\n\x06\x63onfig\x18\x02 \x01(\x0b\x32*.temporal.api.namespace.v1.NamespaceConfig\x12S\n\x12replication_config\x18\x03 \x01(\x0b\x32\x37.temporal.api.replication.v1.NamespaceReplicationConfig\x12\x18\n\x10\x66\x61ilover_version\x18\x04 \x01(\x03\x12\x1b\n\x13is_global_namespace\x18\x05 \x01(\x08"F\n\x19\x44\x65precateNamespaceRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x16\n\x0esecurity_token\x18\x02 \x01(\t"\x1c\n\x1a\x44\x65precateNamespaceResponse"\x87\x0c\n\x1dStartWorkflowExecutionRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x13\n\x0bworkflow_id\x18\x02 \x01(\t\x12;\n\rworkflow_type\x18\x03 \x01(\x0b\x32$.temporal.api.common.v1.WorkflowType\x12\x38\n\ntask_queue\x18\x04 \x01(\x0b\x32$.temporal.api.taskqueue.v1.TaskQueue\x12/\n\x05input\x18\x05 \x01(\x0b\x32 .temporal.api.common.v1.Payloads\x12=\n\x1aworkflow_execution_timeout\x18\x06 \x01(\x0b\x32\x19.google.protobuf.Duration\x12\x37\n\x14workflow_run_timeout\x18\x07 \x01(\x0b\x32\x19.google.protobuf.Duration\x12\x38\n\x15workflow_task_timeout\x18\x08 \x01(\x0b\x32\x19.google.protobuf.Duration\x12\x10\n\x08identity\x18\t \x01(\t\x12\x12\n\nrequest_id\x18\n \x01(\t\x12N\n\x18workflow_id_reuse_policy\x18\x0b \x01(\x0e\x32,.temporal.api.enums.v1.WorkflowIdReusePolicy\x12T\n\x1bworkflow_id_conflict_policy\x18\x16 \x01(\x0e\x32/.temporal.api.enums.v1.WorkflowIdConflictPolicy\x12\x39\n\x0cretry_policy\x18\x0c \x01(\x0b\x32#.temporal.api.common.v1.RetryPolicy\x12\x15\n\rcron_schedule\x18\r \x01(\t\x12*\n\x04memo\x18\x0e \x01(\x0b\x32\x1c.temporal.api.common.v1.Memo\x12\x43\n\x11search_attributes\x18\x0f \x01(\x0b\x32(.temporal.api.common.v1.SearchAttributes\x12.\n\x06header\x18\x10 \x01(\x0b\x32\x1e.temporal.api.common.v1.Header\x12\x1f\n\x17request_eager_execution\x18\x11 \x01(\x08\x12;\n\x11\x63ontinued_failure\x18\x12 \x01(\x0b\x32 .temporal.api.failure.v1.Failure\x12@\n\x16last_completion_result\x18\x13 \x01(\x0b\x32 .temporal.api.common.v1.Payloads\x12\x37\n\x14workflow_start_delay\x18\x14 \x01(\x0b\x32\x19.google.protobuf.Duration\x12>\n\x14\x63ompletion_callbacks\x18\x15 \x03(\x0b\x32 .temporal.api.common.v1.Callback\x12\x38\n\ruser_metadata\x18\x17 \x01(\x0b\x32!.temporal.api.sdk.v1.UserMetadata\x12+\n\x05links\x18\x18 \x03(\x0b\x32\x1c.temporal.api.common.v1.Link\x12I\n\x13versioning_override\x18\x19 \x01(\x0b\x32,.temporal.api.workflow.v1.VersioningOverride\x12H\n\x13on_conflict_options\x18\x1a \x01(\x0b\x32+.temporal.api.workflow.v1.OnConflictOptions\x12\x32\n\x08priority\x18\x1b \x01(\x0b\x32 .temporal.api.common.v1.Priority\x12\\\n\x1f\x65\x61ger_worker_deployment_options\x18\x1c \x01(\x0b\x32\x33.temporal.api.deployment.v1.WorkerDeploymentOptions"\x8a\x02\n\x1eStartWorkflowExecutionResponse\x12\x0e\n\x06run_id\x18\x01 \x01(\t\x12\x0f\n\x07started\x18\x03 \x01(\x08\x12>\n\x06status\x18\x05 \x01(\x0e\x32..temporal.api.enums.v1.WorkflowExecutionStatus\x12[\n\x13\x65\x61ger_workflow_task\x18\x02 \x01(\x0b\x32>.temporal.api.workflowservice.v1.PollWorkflowTaskQueueResponse\x12*\n\x04link\x18\x04 \x01(\x0b\x32\x1c.temporal.api.common.v1.Link"\xaa\x02\n"GetWorkflowExecutionHistoryRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12<\n\texecution\x18\x02 \x01(\x0b\x32).temporal.api.common.v1.WorkflowExecution\x12\x19\n\x11maximum_page_size\x18\x03 \x01(\x05\x12\x17\n\x0fnext_page_token\x18\x04 \x01(\x0c\x12\x16\n\x0ewait_new_event\x18\x05 \x01(\x08\x12P\n\x19history_event_filter_type\x18\x06 \x01(\x0e\x32-.temporal.api.enums.v1.HistoryEventFilterType\x12\x15\n\rskip_archival\x18\x07 \x01(\x08"\xba\x01\n#GetWorkflowExecutionHistoryResponse\x12\x31\n\x07history\x18\x01 \x01(\x0b\x32 .temporal.api.history.v1.History\x12\x35\n\x0braw_history\x18\x02 \x03(\x0b\x32 .temporal.api.common.v1.DataBlob\x12\x17\n\x0fnext_page_token\x18\x03 \x01(\x0c\x12\x10\n\x08\x61rchived\x18\x04 \x01(\x08"\xb0\x01\n)GetWorkflowExecutionHistoryReverseRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12<\n\texecution\x18\x02 \x01(\x0b\x32).temporal.api.common.v1.WorkflowExecution\x12\x19\n\x11maximum_page_size\x18\x03 \x01(\x05\x12\x17\n\x0fnext_page_token\x18\x04 \x01(\x0c"x\n*GetWorkflowExecutionHistoryReverseResponse\x12\x31\n\x07history\x18\x01 \x01(\x0b\x32 .temporal.api.history.v1.History\x12\x17\n\x0fnext_page_token\x18\x03 \x01(\x0c"\x8a\x03\n\x1cPollWorkflowTaskQueueRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x38\n\ntask_queue\x18\x02 \x01(\x0b\x32$.temporal.api.taskqueue.v1.TaskQueue\x12\x10\n\x08identity\x18\x03 \x01(\t\x12\x1b\n\x0f\x62inary_checksum\x18\x04 \x01(\tB\x02\x18\x01\x12Z\n\x1bworker_version_capabilities\x18\x05 \x01(\x0b\x32\x31.temporal.api.common.v1.WorkerVersionCapabilitiesB\x02\x18\x01\x12O\n\x12\x64\x65ployment_options\x18\x06 \x01(\x0b\x32\x33.temporal.api.deployment.v1.WorkerDeploymentOptions\x12\x41\n\x10worker_heartbeat\x18\x07 \x01(\x0b\x32\'.temporal.api.worker.v1.WorkerHeartbeat"\x91\x07\n\x1dPollWorkflowTaskQueueResponse\x12\x12\n\ntask_token\x18\x01 \x01(\x0c\x12\x45\n\x12workflow_execution\x18\x02 \x01(\x0b\x32).temporal.api.common.v1.WorkflowExecution\x12;\n\rworkflow_type\x18\x03 \x01(\x0b\x32$.temporal.api.common.v1.WorkflowType\x12!\n\x19previous_started_event_id\x18\x04 \x01(\x03\x12\x18\n\x10started_event_id\x18\x05 \x01(\x03\x12\x0f\n\x07\x61ttempt\x18\x06 \x01(\x05\x12\x1a\n\x12\x62\x61\x63klog_count_hint\x18\x07 \x01(\x03\x12\x31\n\x07history\x18\x08 \x01(\x0b\x32 .temporal.api.history.v1.History\x12\x17\n\x0fnext_page_token\x18\t \x01(\x0c\x12\x33\n\x05query\x18\n \x01(\x0b\x32$.temporal.api.query.v1.WorkflowQuery\x12K\n\x1dworkflow_execution_task_queue\x18\x0b \x01(\x0b\x32$.temporal.api.taskqueue.v1.TaskQueue\x12\x32\n\x0escheduled_time\x18\x0c \x01(\x0b\x32\x1a.google.protobuf.Timestamp\x12\x30\n\x0cstarted_time\x18\r \x01(\x0b\x32\x1a.google.protobuf.Timestamp\x12\\\n\x07queries\x18\x0e \x03(\x0b\x32K.temporal.api.workflowservice.v1.PollWorkflowTaskQueueResponse.QueriesEntry\x12\x33\n\x08messages\x18\x0f \x03(\x0b\x32!.temporal.api.protocol.v1.Message\x12Q\n\x17poller_scaling_decision\x18\x10 \x01(\x0b\x32\x30.temporal.api.taskqueue.v1.PollerScalingDecision\x1aT\n\x0cQueriesEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\x33\n\x05value\x18\x02 \x01(\x0b\x32$.temporal.api.query.v1.WorkflowQuery:\x02\x38\x01"\xb5\t\n#RespondWorkflowTaskCompletedRequest\x12\x12\n\ntask_token\x18\x01 \x01(\x0c\x12\x32\n\x08\x63ommands\x18\x02 \x03(\x0b\x32 .temporal.api.command.v1.Command\x12\x10\n\x08identity\x18\x03 \x01(\t\x12O\n\x11sticky_attributes\x18\x04 \x01(\x0b\x32\x34.temporal.api.taskqueue.v1.StickyExecutionAttributes\x12 \n\x18return_new_workflow_task\x18\x05 \x01(\x08\x12&\n\x1e\x66orce_create_new_workflow_task\x18\x06 \x01(\x08\x12\x1b\n\x0f\x62inary_checksum\x18\x07 \x01(\tB\x02\x18\x01\x12m\n\rquery_results\x18\x08 \x03(\x0b\x32V.temporal.api.workflowservice.v1.RespondWorkflowTaskCompletedRequest.QueryResultsEntry\x12\x11\n\tnamespace\x18\t \x01(\t\x12L\n\x14worker_version_stamp\x18\n \x01(\x0b\x32*.temporal.api.common.v1.WorkerVersionStampB\x02\x18\x01\x12\x33\n\x08messages\x18\x0b \x03(\x0b\x32!.temporal.api.protocol.v1.Message\x12H\n\x0csdk_metadata\x18\x0c \x01(\x0b\x32\x32.temporal.api.sdk.v1.WorkflowTaskCompletedMetadata\x12\x43\n\x11metering_metadata\x18\r \x01(\x0b\x32(.temporal.api.common.v1.MeteringMetadata\x12g\n\x0c\x63\x61pabilities\x18\x0e \x01(\x0b\x32Q.temporal.api.workflowservice.v1.RespondWorkflowTaskCompletedRequest.Capabilities\x12>\n\ndeployment\x18\x0f \x01(\x0b\x32&.temporal.api.deployment.v1.DeploymentB\x02\x18\x01\x12\x46\n\x13versioning_behavior\x18\x10 \x01(\x0e\x32).temporal.api.enums.v1.VersioningBehavior\x12O\n\x12\x64\x65ployment_options\x18\x11 \x01(\x0b\x32\x33.temporal.api.deployment.v1.WorkerDeploymentOptions\x1a_\n\x11QueryResultsEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\x39\n\x05value\x18\x02 \x01(\x0b\x32*.temporal.api.query.v1.WorkflowQueryResult:\x02\x38\x01\x1a\x45\n\x0c\x43\x61pabilities\x12\x35\n-discard_speculative_workflow_task_with_events\x18\x01 \x01(\x08"\xf5\x01\n$RespondWorkflowTaskCompletedResponse\x12U\n\rworkflow_task\x18\x01 \x01(\x0b\x32>.temporal.api.workflowservice.v1.PollWorkflowTaskQueueResponse\x12V\n\x0e\x61\x63tivity_tasks\x18\x02 \x03(\x0b\x32>.temporal.api.workflowservice.v1.PollActivityTaskQueueResponse\x12\x1e\n\x16reset_history_event_id\x18\x03 \x01(\x03"\xf8\x03\n RespondWorkflowTaskFailedRequest\x12\x12\n\ntask_token\x18\x01 \x01(\x0c\x12=\n\x05\x63\x61use\x18\x02 \x01(\x0e\x32..temporal.api.enums.v1.WorkflowTaskFailedCause\x12\x31\n\x07\x66\x61ilure\x18\x03 \x01(\x0b\x32 .temporal.api.failure.v1.Failure\x12\x10\n\x08identity\x18\x04 \x01(\t\x12\x1b\n\x0f\x62inary_checksum\x18\x05 \x01(\tB\x02\x18\x01\x12\x11\n\tnamespace\x18\x06 \x01(\t\x12\x33\n\x08messages\x18\x07 \x03(\x0b\x32!.temporal.api.protocol.v1.Message\x12\x46\n\x0eworker_version\x18\x08 \x01(\x0b\x32*.temporal.api.common.v1.WorkerVersionStampB\x02\x18\x01\x12>\n\ndeployment\x18\t \x01(\x0b\x32&.temporal.api.deployment.v1.DeploymentB\x02\x18\x01\x12O\n\x12\x64\x65ployment_options\x18\n \x01(\x0b\x32\x33.temporal.api.deployment.v1.WorkerDeploymentOptions"#\n!RespondWorkflowTaskFailedResponse"\xb8\x03\n\x1cPollActivityTaskQueueRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x38\n\ntask_queue\x18\x02 \x01(\x0b\x32$.temporal.api.taskqueue.v1.TaskQueue\x12\x10\n\x08identity\x18\x03 \x01(\t\x12I\n\x13task_queue_metadata\x18\x04 \x01(\x0b\x32,.temporal.api.taskqueue.v1.TaskQueueMetadata\x12Z\n\x1bworker_version_capabilities\x18\x05 \x01(\x0b\x32\x31.temporal.api.common.v1.WorkerVersionCapabilitiesB\x02\x18\x01\x12O\n\x12\x64\x65ployment_options\x18\x06 \x01(\x0b\x32\x33.temporal.api.deployment.v1.WorkerDeploymentOptions\x12\x41\n\x10worker_heartbeat\x18\x07 \x01(\x0b\x32\'.temporal.api.worker.v1.WorkerHeartbeat"\xef\x07\n\x1dPollActivityTaskQueueResponse\x12\x12\n\ntask_token\x18\x01 \x01(\x0c\x12\x1a\n\x12workflow_namespace\x18\x02 \x01(\t\x12;\n\rworkflow_type\x18\x03 \x01(\x0b\x32$.temporal.api.common.v1.WorkflowType\x12\x45\n\x12workflow_execution\x18\x04 \x01(\x0b\x32).temporal.api.common.v1.WorkflowExecution\x12;\n\ractivity_type\x18\x05 \x01(\x0b\x32$.temporal.api.common.v1.ActivityType\x12\x13\n\x0b\x61\x63tivity_id\x18\x06 \x01(\t\x12.\n\x06header\x18\x07 \x01(\x0b\x32\x1e.temporal.api.common.v1.Header\x12/\n\x05input\x18\x08 \x01(\x0b\x32 .temporal.api.common.v1.Payloads\x12;\n\x11heartbeat_details\x18\t \x01(\x0b\x32 .temporal.api.common.v1.Payloads\x12\x32\n\x0escheduled_time\x18\n \x01(\x0b\x32\x1a.google.protobuf.Timestamp\x12\x42\n\x1e\x63urrent_attempt_scheduled_time\x18\x0b \x01(\x0b\x32\x1a.google.protobuf.Timestamp\x12\x30\n\x0cstarted_time\x18\x0c \x01(\x0b\x32\x1a.google.protobuf.Timestamp\x12\x0f\n\x07\x61ttempt\x18\r \x01(\x05\x12<\n\x19schedule_to_close_timeout\x18\x0e \x01(\x0b\x32\x19.google.protobuf.Duration\x12\x39\n\x16start_to_close_timeout\x18\x0f \x01(\x0b\x32\x19.google.protobuf.Duration\x12\x34\n\x11heartbeat_timeout\x18\x10 \x01(\x0b\x32\x19.google.protobuf.Duration\x12\x39\n\x0cretry_policy\x18\x11 \x01(\x0b\x32#.temporal.api.common.v1.RetryPolicy\x12Q\n\x17poller_scaling_decision\x18\x12 \x01(\x0b\x32\x30.temporal.api.taskqueue.v1.PollerScalingDecision\x12\x32\n\x08priority\x18\x13 \x01(\x0b\x32 .temporal.api.common.v1.Priority"\x90\x01\n"RecordActivityTaskHeartbeatRequest\x12\x12\n\ntask_token\x18\x01 \x01(\x0c\x12\x31\n\x07\x64\x65tails\x18\x02 \x01(\x0b\x32 .temporal.api.common.v1.Payloads\x12\x10\n\x08identity\x18\x03 \x01(\t\x12\x11\n\tnamespace\x18\x04 \x01(\t"p\n#RecordActivityTaskHeartbeatResponse\x12\x18\n\x10\x63\x61ncel_requested\x18\x01 \x01(\x08\x12\x17\n\x0f\x61\x63tivity_paused\x18\x02 \x01(\x08\x12\x16\n\x0e\x61\x63tivity_reset\x18\x03 \x01(\x08"\xba\x01\n&RecordActivityTaskHeartbeatByIdRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x13\n\x0bworkflow_id\x18\x02 \x01(\t\x12\x0e\n\x06run_id\x18\x03 \x01(\t\x12\x13\n\x0b\x61\x63tivity_id\x18\x04 \x01(\t\x12\x31\n\x07\x64\x65tails\x18\x05 \x01(\x0b\x32 .temporal.api.common.v1.Payloads\x12\x10\n\x08identity\x18\x06 \x01(\t"t\n\'RecordActivityTaskHeartbeatByIdResponse\x12\x18\n\x10\x63\x61ncel_requested\x18\x01 \x01(\x08\x12\x17\n\x0f\x61\x63tivity_paused\x18\x02 \x01(\x08\x12\x16\n\x0e\x61\x63tivity_reset\x18\x03 \x01(\x08"\xe9\x02\n#RespondActivityTaskCompletedRequest\x12\x12\n\ntask_token\x18\x01 \x01(\x0c\x12\x30\n\x06result\x18\x02 \x01(\x0b\x32 .temporal.api.common.v1.Payloads\x12\x10\n\x08identity\x18\x03 \x01(\t\x12\x11\n\tnamespace\x18\x04 \x01(\t\x12\x46\n\x0eworker_version\x18\x05 \x01(\x0b\x32*.temporal.api.common.v1.WorkerVersionStampB\x02\x18\x01\x12>\n\ndeployment\x18\x06 \x01(\x0b\x32&.temporal.api.deployment.v1.DeploymentB\x02\x18\x01\x12O\n\x12\x64\x65ployment_options\x18\x07 \x01(\x0b\x32\x33.temporal.api.deployment.v1.WorkerDeploymentOptions"&\n$RespondActivityTaskCompletedResponse"\xba\x01\n\'RespondActivityTaskCompletedByIdRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x13\n\x0bworkflow_id\x18\x02 \x01(\t\x12\x0e\n\x06run_id\x18\x03 \x01(\t\x12\x13\n\x0b\x61\x63tivity_id\x18\x04 \x01(\t\x12\x30\n\x06result\x18\x05 \x01(\x0b\x32 .temporal.api.common.v1.Payloads\x12\x10\n\x08identity\x18\x06 \x01(\t"*\n(RespondActivityTaskCompletedByIdResponse"\xa9\x03\n RespondActivityTaskFailedRequest\x12\x12\n\ntask_token\x18\x01 \x01(\x0c\x12\x31\n\x07\x66\x61ilure\x18\x02 \x01(\x0b\x32 .temporal.api.failure.v1.Failure\x12\x10\n\x08identity\x18\x03 \x01(\t\x12\x11\n\tnamespace\x18\x04 \x01(\t\x12@\n\x16last_heartbeat_details\x18\x05 \x01(\x0b\x32 .temporal.api.common.v1.Payloads\x12\x46\n\x0eworker_version\x18\x06 \x01(\x0b\x32*.temporal.api.common.v1.WorkerVersionStampB\x02\x18\x01\x12>\n\ndeployment\x18\x07 \x01(\x0b\x32&.temporal.api.deployment.v1.DeploymentB\x02\x18\x01\x12O\n\x12\x64\x65ployment_options\x18\x08 \x01(\x0b\x32\x33.temporal.api.deployment.v1.WorkerDeploymentOptions"W\n!RespondActivityTaskFailedResponse\x12\x32\n\x08\x66\x61ilures\x18\x01 \x03(\x0b\x32 .temporal.api.failure.v1.Failure"\xfa\x01\n$RespondActivityTaskFailedByIdRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x13\n\x0bworkflow_id\x18\x02 \x01(\t\x12\x0e\n\x06run_id\x18\x03 \x01(\t\x12\x13\n\x0b\x61\x63tivity_id\x18\x04 \x01(\t\x12\x31\n\x07\x66\x61ilure\x18\x05 \x01(\x0b\x32 .temporal.api.failure.v1.Failure\x12\x10\n\x08identity\x18\x06 \x01(\t\x12@\n\x16last_heartbeat_details\x18\x07 \x01(\x0b\x32 .temporal.api.common.v1.Payloads"[\n%RespondActivityTaskFailedByIdResponse\x12\x32\n\x08\x66\x61ilures\x18\x01 \x03(\x0b\x32 .temporal.api.failure.v1.Failure"\xe9\x02\n"RespondActivityTaskCanceledRequest\x12\x12\n\ntask_token\x18\x01 \x01(\x0c\x12\x31\n\x07\x64\x65tails\x18\x02 \x01(\x0b\x32 .temporal.api.common.v1.Payloads\x12\x10\n\x08identity\x18\x03 \x01(\t\x12\x11\n\tnamespace\x18\x04 \x01(\t\x12\x46\n\x0eworker_version\x18\x05 \x01(\x0b\x32*.temporal.api.common.v1.WorkerVersionStampB\x02\x18\x01\x12>\n\ndeployment\x18\x06 \x01(\x0b\x32&.temporal.api.deployment.v1.DeploymentB\x02\x18\x01\x12O\n\x12\x64\x65ployment_options\x18\x07 \x01(\x0b\x32\x33.temporal.api.deployment.v1.WorkerDeploymentOptions"%\n#RespondActivityTaskCanceledResponse"\x8b\x02\n&RespondActivityTaskCanceledByIdRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x13\n\x0bworkflow_id\x18\x02 \x01(\t\x12\x0e\n\x06run_id\x18\x03 \x01(\t\x12\x13\n\x0b\x61\x63tivity_id\x18\x04 \x01(\t\x12\x31\n\x07\x64\x65tails\x18\x05 \x01(\x0b\x32 .temporal.api.common.v1.Payloads\x12\x10\n\x08identity\x18\x06 \x01(\t\x12O\n\x12\x64\x65ployment_options\x18\x07 \x01(\x0b\x32\x33.temporal.api.deployment.v1.WorkerDeploymentOptions")\n\'RespondActivityTaskCanceledByIdResponse"\x84\x02\n%RequestCancelWorkflowExecutionRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x45\n\x12workflow_execution\x18\x02 \x01(\x0b\x32).temporal.api.common.v1.WorkflowExecution\x12\x10\n\x08identity\x18\x03 \x01(\t\x12\x12\n\nrequest_id\x18\x04 \x01(\t\x12\x1e\n\x16\x66irst_execution_run_id\x18\x05 \x01(\t\x12\x0e\n\x06reason\x18\x06 \x01(\t\x12+\n\x05links\x18\x07 \x03(\x0b\x32\x1c.temporal.api.common.v1.Link"(\n&RequestCancelWorkflowExecutionResponse"\xde\x02\n\x1eSignalWorkflowExecutionRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x45\n\x12workflow_execution\x18\x02 \x01(\x0b\x32).temporal.api.common.v1.WorkflowExecution\x12\x13\n\x0bsignal_name\x18\x03 \x01(\t\x12/\n\x05input\x18\x04 \x01(\x0b\x32 .temporal.api.common.v1.Payloads\x12\x10\n\x08identity\x18\x05 \x01(\t\x12\x12\n\nrequest_id\x18\x06 \x01(\t\x12\x13\n\x07\x63ontrol\x18\x07 \x01(\tB\x02\x18\x01\x12.\n\x06header\x18\x08 \x01(\x0b\x32\x1e.temporal.api.common.v1.Header\x12+\n\x05links\x18\n \x03(\x0b\x32\x1c.temporal.api.common.v1.LinkJ\x04\x08\t\x10\n"!\n\x1fSignalWorkflowExecutionResponse"\xf1\t\n\'SignalWithStartWorkflowExecutionRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x13\n\x0bworkflow_id\x18\x02 \x01(\t\x12;\n\rworkflow_type\x18\x03 \x01(\x0b\x32$.temporal.api.common.v1.WorkflowType\x12\x38\n\ntask_queue\x18\x04 \x01(\x0b\x32$.temporal.api.taskqueue.v1.TaskQueue\x12/\n\x05input\x18\x05 \x01(\x0b\x32 .temporal.api.common.v1.Payloads\x12=\n\x1aworkflow_execution_timeout\x18\x06 \x01(\x0b\x32\x19.google.protobuf.Duration\x12\x37\n\x14workflow_run_timeout\x18\x07 \x01(\x0b\x32\x19.google.protobuf.Duration\x12\x38\n\x15workflow_task_timeout\x18\x08 \x01(\x0b\x32\x19.google.protobuf.Duration\x12\x10\n\x08identity\x18\t \x01(\t\x12\x12\n\nrequest_id\x18\n \x01(\t\x12N\n\x18workflow_id_reuse_policy\x18\x0b \x01(\x0e\x32,.temporal.api.enums.v1.WorkflowIdReusePolicy\x12T\n\x1bworkflow_id_conflict_policy\x18\x16 \x01(\x0e\x32/.temporal.api.enums.v1.WorkflowIdConflictPolicy\x12\x13\n\x0bsignal_name\x18\x0c \x01(\t\x12\x36\n\x0csignal_input\x18\r \x01(\x0b\x32 .temporal.api.common.v1.Payloads\x12\x13\n\x07\x63ontrol\x18\x0e \x01(\tB\x02\x18\x01\x12\x39\n\x0cretry_policy\x18\x0f \x01(\x0b\x32#.temporal.api.common.v1.RetryPolicy\x12\x15\n\rcron_schedule\x18\x10 \x01(\t\x12*\n\x04memo\x18\x11 \x01(\x0b\x32\x1c.temporal.api.common.v1.Memo\x12\x43\n\x11search_attributes\x18\x12 \x01(\x0b\x32(.temporal.api.common.v1.SearchAttributes\x12.\n\x06header\x18\x13 \x01(\x0b\x32\x1e.temporal.api.common.v1.Header\x12\x37\n\x14workflow_start_delay\x18\x14 \x01(\x0b\x32\x19.google.protobuf.Duration\x12\x38\n\ruser_metadata\x18\x17 \x01(\x0b\x32!.temporal.api.sdk.v1.UserMetadata\x12+\n\x05links\x18\x18 \x03(\x0b\x32\x1c.temporal.api.common.v1.Link\x12I\n\x13versioning_override\x18\x19 \x01(\x0b\x32,.temporal.api.workflow.v1.VersioningOverride\x12\x32\n\x08priority\x18\x1a \x01(\x0b\x32 .temporal.api.common.v1.PriorityJ\x04\x08\x15\x10\x16"K\n(SignalWithStartWorkflowExecutionResponse\x12\x0e\n\x06run_id\x18\x01 \x01(\t\x12\x0f\n\x07started\x18\x02 \x01(\x08"\xc1\x03\n\x1dResetWorkflowExecutionRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x45\n\x12workflow_execution\x18\x02 \x01(\x0b\x32).temporal.api.common.v1.WorkflowExecution\x12\x0e\n\x06reason\x18\x03 \x01(\t\x12%\n\x1dworkflow_task_finish_event_id\x18\x04 \x01(\x03\x12\x12\n\nrequest_id\x18\x05 \x01(\t\x12G\n\x12reset_reapply_type\x18\x06 \x01(\x0e\x32\'.temporal.api.enums.v1.ResetReapplyTypeB\x02\x18\x01\x12S\n\x1breset_reapply_exclude_types\x18\x07 \x03(\x0e\x32..temporal.api.enums.v1.ResetReapplyExcludeType\x12K\n\x15post_reset_operations\x18\x08 \x03(\x0b\x32,.temporal.api.workflow.v1.PostResetOperation\x12\x10\n\x08identity\x18\t \x01(\t"0\n\x1eResetWorkflowExecutionResponse\x12\x0e\n\x06run_id\x18\x01 \x01(\t"\x9f\x02\n!TerminateWorkflowExecutionRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x45\n\x12workflow_execution\x18\x02 \x01(\x0b\x32).temporal.api.common.v1.WorkflowExecution\x12\x0e\n\x06reason\x18\x03 \x01(\t\x12\x31\n\x07\x64\x65tails\x18\x04 \x01(\x0b\x32 .temporal.api.common.v1.Payloads\x12\x10\n\x08identity\x18\x05 \x01(\t\x12\x1e\n\x16\x66irst_execution_run_id\x18\x06 \x01(\t\x12+\n\x05links\x18\x07 \x03(\x0b\x32\x1c.temporal.api.common.v1.Link"$\n"TerminateWorkflowExecutionResponse"z\n\x1e\x44\x65leteWorkflowExecutionRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x45\n\x12workflow_execution\x18\x02 \x01(\x0b\x32).temporal.api.common.v1.WorkflowExecution"!\n\x1f\x44\x65leteWorkflowExecutionResponse"\xc9\x02\n!ListOpenWorkflowExecutionsRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x19\n\x11maximum_page_size\x18\x02 \x01(\x05\x12\x17\n\x0fnext_page_token\x18\x03 \x01(\x0c\x12\x42\n\x11start_time_filter\x18\x04 \x01(\x0b\x32\'.temporal.api.filter.v1.StartTimeFilter\x12K\n\x10\x65xecution_filter\x18\x05 \x01(\x0b\x32/.temporal.api.filter.v1.WorkflowExecutionFilterH\x00\x12\x41\n\x0btype_filter\x18\x06 \x01(\x0b\x32*.temporal.api.filter.v1.WorkflowTypeFilterH\x00\x42\t\n\x07\x66ilters"\x82\x01\n"ListOpenWorkflowExecutionsResponse\x12\x43\n\nexecutions\x18\x01 \x03(\x0b\x32/.temporal.api.workflow.v1.WorkflowExecutionInfo\x12\x17\n\x0fnext_page_token\x18\x02 \x01(\x0c"\x8a\x03\n#ListClosedWorkflowExecutionsRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x19\n\x11maximum_page_size\x18\x02 \x01(\x05\x12\x17\n\x0fnext_page_token\x18\x03 \x01(\x0c\x12\x42\n\x11start_time_filter\x18\x04 \x01(\x0b\x32\'.temporal.api.filter.v1.StartTimeFilter\x12K\n\x10\x65xecution_filter\x18\x05 \x01(\x0b\x32/.temporal.api.filter.v1.WorkflowExecutionFilterH\x00\x12\x41\n\x0btype_filter\x18\x06 \x01(\x0b\x32*.temporal.api.filter.v1.WorkflowTypeFilterH\x00\x12=\n\rstatus_filter\x18\x07 \x01(\x0b\x32$.temporal.api.filter.v1.StatusFilterH\x00\x42\t\n\x07\x66ilters"\x84\x01\n$ListClosedWorkflowExecutionsResponse\x12\x43\n\nexecutions\x18\x01 \x03(\x0b\x32/.temporal.api.workflow.v1.WorkflowExecutionInfo\x12\x17\n\x0fnext_page_token\x18\x02 \x01(\x0c"m\n\x1dListWorkflowExecutionsRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x11\n\tpage_size\x18\x02 \x01(\x05\x12\x17\n\x0fnext_page_token\x18\x03 \x01(\x0c\x12\r\n\x05query\x18\x04 \x01(\t"~\n\x1eListWorkflowExecutionsResponse\x12\x43\n\nexecutions\x18\x01 \x03(\x0b\x32/.temporal.api.workflow.v1.WorkflowExecutionInfo\x12\x17\n\x0fnext_page_token\x18\x02 \x01(\x0c"u\n%ListArchivedWorkflowExecutionsRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x11\n\tpage_size\x18\x02 \x01(\x05\x12\x17\n\x0fnext_page_token\x18\x03 \x01(\x0c\x12\r\n\x05query\x18\x04 \x01(\t"\x86\x01\n&ListArchivedWorkflowExecutionsResponse\x12\x43\n\nexecutions\x18\x01 \x03(\x0b\x32/.temporal.api.workflow.v1.WorkflowExecutionInfo\x12\x17\n\x0fnext_page_token\x18\x02 \x01(\x0c"m\n\x1dScanWorkflowExecutionsRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x11\n\tpage_size\x18\x02 \x01(\x05\x12\x17\n\x0fnext_page_token\x18\x03 \x01(\x0c\x12\r\n\x05query\x18\x04 \x01(\t"~\n\x1eScanWorkflowExecutionsResponse\x12\x43\n\nexecutions\x18\x01 \x03(\x0b\x32/.temporal.api.workflow.v1.WorkflowExecutionInfo\x12\x17\n\x0fnext_page_token\x18\x02 \x01(\x0c"B\n\x1e\x43ountWorkflowExecutionsRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\r\n\x05query\x18\x02 \x01(\t"\xed\x01\n\x1f\x43ountWorkflowExecutionsResponse\x12\r\n\x05\x63ount\x18\x01 \x01(\x03\x12\x61\n\x06groups\x18\x02 \x03(\x0b\x32Q.temporal.api.workflowservice.v1.CountWorkflowExecutionsResponse.AggregationGroup\x1aX\n\x10\x41ggregationGroup\x12\x35\n\x0cgroup_values\x18\x01 \x03(\x0b\x32\x1f.temporal.api.common.v1.Payload\x12\r\n\x05\x63ount\x18\x02 \x01(\x03"\x1c\n\x1aGetSearchAttributesRequest"\xc9\x01\n\x1bGetSearchAttributesResponse\x12T\n\x04keys\x18\x01 \x03(\x0b\x32\x46.temporal.api.workflowservice.v1.GetSearchAttributesResponse.KeysEntry\x1aT\n\tKeysEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\x36\n\x05value\x18\x02 \x01(\x0e\x32\'.temporal.api.enums.v1.IndexedValueType:\x02\x38\x01"\xd0\x02\n RespondQueryTaskCompletedRequest\x12\x12\n\ntask_token\x18\x01 \x01(\x0c\x12>\n\x0e\x63ompleted_type\x18\x02 \x01(\x0e\x32&.temporal.api.enums.v1.QueryResultType\x12\x36\n\x0cquery_result\x18\x03 \x01(\x0b\x32 .temporal.api.common.v1.Payloads\x12\x15\n\rerror_message\x18\x04 \x01(\t\x12\x11\n\tnamespace\x18\x06 \x01(\t\x12\x31\n\x07\x66\x61ilure\x18\x07 \x01(\x0b\x32 .temporal.api.failure.v1.Failure\x12=\n\x05\x63\x61use\x18\x08 \x01(\x0e\x32..temporal.api.enums.v1.WorkflowTaskFailedCauseJ\x04\x08\x05\x10\x06"#\n!RespondQueryTaskCompletedResponse"n\n\x1bResetStickyTaskQueueRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12<\n\texecution\x18\x02 \x01(\x0b\x32).temporal.api.common.v1.WorkflowExecution"\x1e\n\x1cResetStickyTaskQueueResponse"\xaa\x01\n\x15ShutdownWorkerRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x19\n\x11sticky_task_queue\x18\x02 \x01(\t\x12\x10\n\x08identity\x18\x03 \x01(\t\x12\x0e\n\x06reason\x18\x04 \x01(\t\x12\x41\n\x10worker_heartbeat\x18\x05 \x01(\x0b\x32\'.temporal.api.worker.v1.WorkerHeartbeat"\x18\n\x16ShutdownWorkerResponse"\xe9\x01\n\x14QueryWorkflowRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12<\n\texecution\x18\x02 \x01(\x0b\x32).temporal.api.common.v1.WorkflowExecution\x12\x33\n\x05query\x18\x03 \x01(\x0b\x32$.temporal.api.query.v1.WorkflowQuery\x12K\n\x16query_reject_condition\x18\x04 \x01(\x0e\x32+.temporal.api.enums.v1.QueryRejectCondition"\x8d\x01\n\x15QueryWorkflowResponse\x12\x36\n\x0cquery_result\x18\x01 \x01(\x0b\x32 .temporal.api.common.v1.Payloads\x12<\n\x0equery_rejected\x18\x02 \x01(\x0b\x32$.temporal.api.query.v1.QueryRejected"s\n DescribeWorkflowExecutionRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12<\n\texecution\x18\x02 \x01(\x0b\x32).temporal.api.common.v1.WorkflowExecution"\x99\x05\n!DescribeWorkflowExecutionResponse\x12K\n\x10\x65xecution_config\x18\x01 \x01(\x0b\x32\x31.temporal.api.workflow.v1.WorkflowExecutionConfig\x12P\n\x17workflow_execution_info\x18\x02 \x01(\x0b\x32/.temporal.api.workflow.v1.WorkflowExecutionInfo\x12I\n\x12pending_activities\x18\x03 \x03(\x0b\x32-.temporal.api.workflow.v1.PendingActivityInfo\x12M\n\x10pending_children\x18\x04 \x03(\x0b\x32\x33.temporal.api.workflow.v1.PendingChildExecutionInfo\x12P\n\x15pending_workflow_task\x18\x05 \x01(\x0b\x32\x31.temporal.api.workflow.v1.PendingWorkflowTaskInfo\x12\x39\n\tcallbacks\x18\x06 \x03(\x0b\x32&.temporal.api.workflow.v1.CallbackInfo\x12U\n\x18pending_nexus_operations\x18\x07 \x03(\x0b\x32\x33.temporal.api.workflow.v1.PendingNexusOperationInfo\x12W\n\x16workflow_extended_info\x18\x08 \x01(\x0b\x32\x37.temporal.api.workflow.v1.WorkflowExecutionExtendedInfo"\x90\x04\n\x18\x44\x65scribeTaskQueueRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x38\n\ntask_queue\x18\x02 \x01(\x0b\x32$.temporal.api.taskqueue.v1.TaskQueue\x12=\n\x0ftask_queue_type\x18\x03 \x01(\x0e\x32$.temporal.api.enums.v1.TaskQueueType\x12\x14\n\x0creport_stats\x18\x08 \x01(\x08\x12\x15\n\rreport_config\x18\x0b \x01(\x08\x12%\n\x19include_task_queue_status\x18\x04 \x01(\x08\x42\x02\x18\x01\x12\x42\n\x08\x61pi_mode\x18\x05 \x01(\x0e\x32,.temporal.api.enums.v1.DescribeTaskQueueModeB\x02\x18\x01\x12J\n\x08versions\x18\x06 \x01(\x0b\x32\x34.temporal.api.taskqueue.v1.TaskQueueVersionSelectionB\x02\x18\x01\x12\x42\n\x10task_queue_types\x18\x07 \x03(\x0e\x32$.temporal.api.enums.v1.TaskQueueTypeB\x02\x18\x01\x12\x1a\n\x0ereport_pollers\x18\t \x01(\x08\x42\x02\x18\x01\x12$\n\x18report_task_reachability\x18\n \x01(\x08\x42\x02\x18\x01"\xec\x07\n\x19\x44\x65scribeTaskQueueResponse\x12\x36\n\x07pollers\x18\x01 \x03(\x0b\x32%.temporal.api.taskqueue.v1.PollerInfo\x12\x38\n\x05stats\x18\x05 \x01(\x0b\x32).temporal.api.taskqueue.v1.TaskQueueStats\x12q\n\x15stats_by_priority_key\x18\x08 \x03(\x0b\x32R.temporal.api.workflowservice.v1.DescribeTaskQueueResponse.StatsByPriorityKeyEntry\x12K\n\x0fversioning_info\x18\x04 \x01(\x0b\x32\x32.temporal.api.taskqueue.v1.TaskQueueVersioningInfo\x12:\n\x06\x63onfig\x18\x06 \x01(\x0b\x32*.temporal.api.taskqueue.v1.TaskQueueConfig\x12k\n\x14\x65\x66\x66\x65\x63tive_rate_limit\x18\x07 \x01(\x0b\x32M.temporal.api.workflowservice.v1.DescribeTaskQueueResponse.EffectiveRateLimit\x12I\n\x11task_queue_status\x18\x02 \x01(\x0b\x32*.temporal.api.taskqueue.v1.TaskQueueStatusB\x02\x18\x01\x12g\n\rversions_info\x18\x03 \x03(\x0b\x32L.temporal.api.workflowservice.v1.DescribeTaskQueueResponse.VersionsInfoEntryB\x02\x18\x01\x1a\x64\n\x17StatsByPriorityKeyEntry\x12\x0b\n\x03key\x18\x01 \x01(\x05\x12\x38\n\x05value\x18\x02 \x01(\x0b\x32).temporal.api.taskqueue.v1.TaskQueueStats:\x02\x38\x01\x1at\n\x12\x45\x66\x66\x65\x63tiveRateLimit\x12\x1b\n\x13requests_per_second\x18\x01 \x01(\x02\x12\x41\n\x11rate_limit_source\x18\x02 \x01(\x0e\x32&.temporal.api.enums.v1.RateLimitSource\x1a\x64\n\x11VersionsInfoEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12>\n\x05value\x18\x02 \x01(\x0b\x32/.temporal.api.taskqueue.v1.TaskQueueVersionInfo:\x02\x38\x01"\x17\n\x15GetClusterInfoRequest"\xd1\x03\n\x16GetClusterInfoResponse\x12h\n\x11supported_clients\x18\x01 \x03(\x0b\x32M.temporal.api.workflowservice.v1.GetClusterInfoResponse.SupportedClientsEntry\x12\x16\n\x0eserver_version\x18\x02 \x01(\t\x12\x12\n\ncluster_id\x18\x03 \x01(\t\x12:\n\x0cversion_info\x18\x04 \x01(\x0b\x32$.temporal.api.version.v1.VersionInfo\x12\x14\n\x0c\x63luster_name\x18\x05 \x01(\t\x12\x1b\n\x13history_shard_count\x18\x06 \x01(\x05\x12\x19\n\x11persistence_store\x18\x07 \x01(\t\x12\x18\n\x10visibility_store\x18\x08 \x01(\t\x12 \n\x18initial_failover_version\x18\t \x01(\x03\x12"\n\x1a\x66\x61ilover_version_increment\x18\n \x01(\x03\x1a\x37\n\x15SupportedClientsEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\t:\x02\x38\x01"\x16\n\x14GetSystemInfoRequest"\xf4\x03\n\x15GetSystemInfoResponse\x12\x16\n\x0eserver_version\x18\x01 \x01(\t\x12Y\n\x0c\x63\x61pabilities\x18\x02 \x01(\x0b\x32\x43.temporal.api.workflowservice.v1.GetSystemInfoResponse.Capabilities\x1a\xe7\x02\n\x0c\x43\x61pabilities\x12\x1f\n\x17signal_and_query_header\x18\x01 \x01(\x08\x12&\n\x1einternal_error_differentiation\x18\x02 \x01(\x08\x12*\n"activity_failure_include_heartbeat\x18\x03 \x01(\x08\x12\x1a\n\x12supports_schedules\x18\x04 \x01(\x08\x12"\n\x1a\x65ncoded_failure_attributes\x18\x05 \x01(\x08\x12!\n\x19\x62uild_id_based_versioning\x18\x06 \x01(\x08\x12\x13\n\x0bupsert_memo\x18\x07 \x01(\x08\x12\x1c\n\x14\x65\x61ger_workflow_start\x18\x08 \x01(\x08\x12\x14\n\x0csdk_metadata\x18\t \x01(\x08\x12\'\n\x1f\x63ount_group_by_execution_status\x18\n \x01(\x08\x12\r\n\x05nexus\x18\x0b \x01(\x08"m\n\x1eListTaskQueuePartitionsRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x38\n\ntask_queue\x18\x02 \x01(\x0b\x32$.temporal.api.taskqueue.v1.TaskQueue"\xdf\x01\n\x1fListTaskQueuePartitionsResponse\x12]\n\x1e\x61\x63tivity_task_queue_partitions\x18\x01 \x03(\x0b\x32\x35.temporal.api.taskqueue.v1.TaskQueuePartitionMetadata\x12]\n\x1eworkflow_task_queue_partitions\x18\x02 \x03(\x0b\x32\x35.temporal.api.taskqueue.v1.TaskQueuePartitionMetadata"\xcc\x02\n\x15\x43reateScheduleRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x13\n\x0bschedule_id\x18\x02 \x01(\t\x12\x34\n\x08schedule\x18\x03 \x01(\x0b\x32".temporal.api.schedule.v1.Schedule\x12>\n\rinitial_patch\x18\x04 \x01(\x0b\x32\'.temporal.api.schedule.v1.SchedulePatch\x12\x10\n\x08identity\x18\x05 \x01(\t\x12\x12\n\nrequest_id\x18\x06 \x01(\t\x12*\n\x04memo\x18\x07 \x01(\x0b\x32\x1c.temporal.api.common.v1.Memo\x12\x43\n\x11search_attributes\x18\x08 \x01(\x0b\x32(.temporal.api.common.v1.SearchAttributes"0\n\x16\x43reateScheduleResponse\x12\x16\n\x0e\x63onflict_token\x18\x01 \x01(\x0c"A\n\x17\x44\x65scribeScheduleRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x13\n\x0bschedule_id\x18\x02 \x01(\t"\x8f\x02\n\x18\x44\x65scribeScheduleResponse\x12\x34\n\x08schedule\x18\x01 \x01(\x0b\x32".temporal.api.schedule.v1.Schedule\x12\x34\n\x04info\x18\x02 \x01(\x0b\x32&.temporal.api.schedule.v1.ScheduleInfo\x12*\n\x04memo\x18\x03 \x01(\x0b\x32\x1c.temporal.api.common.v1.Memo\x12\x43\n\x11search_attributes\x18\x04 \x01(\x0b\x32(.temporal.api.common.v1.SearchAttributes\x12\x16\n\x0e\x63onflict_token\x18\x05 \x01(\x0c"\xf8\x01\n\x15UpdateScheduleRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x13\n\x0bschedule_id\x18\x02 \x01(\t\x12\x34\n\x08schedule\x18\x03 \x01(\x0b\x32".temporal.api.schedule.v1.Schedule\x12\x16\n\x0e\x63onflict_token\x18\x04 \x01(\x0c\x12\x10\n\x08identity\x18\x05 \x01(\t\x12\x12\n\nrequest_id\x18\x06 \x01(\t\x12\x43\n\x11search_attributes\x18\x07 \x01(\x0b\x32(.temporal.api.common.v1.SearchAttributes"\x18\n\x16UpdateScheduleResponse"\x9c\x01\n\x14PatchScheduleRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x13\n\x0bschedule_id\x18\x02 \x01(\t\x12\x36\n\x05patch\x18\x03 \x01(\x0b\x32\'.temporal.api.schedule.v1.SchedulePatch\x12\x10\n\x08identity\x18\x04 \x01(\t\x12\x12\n\nrequest_id\x18\x05 \x01(\t"\x17\n\x15PatchScheduleResponse"\xa8\x01\n ListScheduleMatchingTimesRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x13\n\x0bschedule_id\x18\x02 \x01(\t\x12.\n\nstart_time\x18\x03 \x01(\x0b\x32\x1a.google.protobuf.Timestamp\x12,\n\x08\x65nd_time\x18\x04 \x01(\x0b\x32\x1a.google.protobuf.Timestamp"S\n!ListScheduleMatchingTimesResponse\x12.\n\nstart_time\x18\x01 \x03(\x0b\x32\x1a.google.protobuf.Timestamp"Q\n\x15\x44\x65leteScheduleRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x13\n\x0bschedule_id\x18\x02 \x01(\t\x12\x10\n\x08identity\x18\x03 \x01(\t"\x18\n\x16\x44\x65leteScheduleResponse"l\n\x14ListSchedulesRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x19\n\x11maximum_page_size\x18\x02 \x01(\x05\x12\x17\n\x0fnext_page_token\x18\x03 \x01(\x0c\x12\r\n\x05query\x18\x04 \x01(\t"p\n\x15ListSchedulesResponse\x12>\n\tschedules\x18\x01 \x03(\x0b\x32+.temporal.api.schedule.v1.ScheduleListEntry\x12\x17\n\x0fnext_page_token\x18\x02 \x01(\x0c"\x86\x05\n\'UpdateWorkerBuildIdCompatibilityRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x12\n\ntask_queue\x18\x02 \x01(\t\x12-\n#add_new_build_id_in_new_default_set\x18\x03 \x01(\tH\x00\x12\x87\x01\n\x1b\x61\x64\x64_new_compatible_build_id\x18\x04 \x01(\x0b\x32`.temporal.api.workflowservice.v1.UpdateWorkerBuildIdCompatibilityRequest.AddNewCompatibleVersionH\x00\x12!\n\x17promote_set_by_build_id\x18\x05 \x01(\tH\x00\x12%\n\x1bpromote_build_id_within_set\x18\x06 \x01(\tH\x00\x12h\n\nmerge_sets\x18\x07 \x01(\x0b\x32R.temporal.api.workflowservice.v1.UpdateWorkerBuildIdCompatibilityRequest.MergeSetsH\x00\x1ao\n\x17\x41\x64\x64NewCompatibleVersion\x12\x14\n\x0cnew_build_id\x18\x01 \x01(\t\x12$\n\x1c\x65xisting_compatible_build_id\x18\x02 \x01(\t\x12\x18\n\x10make_set_default\x18\x03 \x01(\x08\x1aI\n\tMergeSets\x12\x1c\n\x14primary_set_build_id\x18\x01 \x01(\t\x12\x1e\n\x16secondary_set_build_id\x18\x02 \x01(\tB\x0b\n\toperation"@\n(UpdateWorkerBuildIdCompatibilityResponseJ\x04\x08\x01\x10\x02R\x0eversion_set_id"_\n$GetWorkerBuildIdCompatibilityRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x12\n\ntask_queue\x18\x02 \x01(\t\x12\x10\n\x08max_sets\x18\x03 \x01(\x05"t\n%GetWorkerBuildIdCompatibilityResponse\x12K\n\x12major_version_sets\x18\x01 \x03(\x0b\x32/.temporal.api.taskqueue.v1.CompatibleVersionSet"\xb5\r\n"UpdateWorkerVersioningRulesRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x12\n\ntask_queue\x18\x02 \x01(\t\x12\x16\n\x0e\x63onflict_token\x18\x03 \x01(\x0c\x12\x81\x01\n\x16insert_assignment_rule\x18\x04 \x01(\x0b\x32_.temporal.api.workflowservice.v1.UpdateWorkerVersioningRulesRequest.InsertBuildIdAssignmentRuleH\x00\x12\x83\x01\n\x17replace_assignment_rule\x18\x05 \x01(\x0b\x32`.temporal.api.workflowservice.v1.UpdateWorkerVersioningRulesRequest.ReplaceBuildIdAssignmentRuleH\x00\x12\x81\x01\n\x16\x64\x65lete_assignment_rule\x18\x06 \x01(\x0b\x32_.temporal.api.workflowservice.v1.UpdateWorkerVersioningRulesRequest.DeleteBuildIdAssignmentRuleH\x00\x12\x8c\x01\n\x1c\x61\x64\x64_compatible_redirect_rule\x18\x07 \x01(\x0b\x32\x64.temporal.api.workflowservice.v1.UpdateWorkerVersioningRulesRequest.AddCompatibleBuildIdRedirectRuleH\x00\x12\x94\x01\n replace_compatible_redirect_rule\x18\x08 \x01(\x0b\x32h.temporal.api.workflowservice.v1.UpdateWorkerVersioningRulesRequest.ReplaceCompatibleBuildIdRedirectRuleH\x00\x12\x92\x01\n\x1f\x64\x65lete_compatible_redirect_rule\x18\t \x01(\x0b\x32g.temporal.api.workflowservice.v1.UpdateWorkerVersioningRulesRequest.DeleteCompatibleBuildIdRedirectRuleH\x00\x12l\n\x0f\x63ommit_build_id\x18\n \x01(\x0b\x32Q.temporal.api.workflowservice.v1.UpdateWorkerVersioningRulesRequest.CommitBuildIdH\x00\x1aq\n\x1bInsertBuildIdAssignmentRule\x12\x12\n\nrule_index\x18\x01 \x01(\x05\x12>\n\x04rule\x18\x02 \x01(\x0b\x32\x30.temporal.api.taskqueue.v1.BuildIdAssignmentRule\x1a\x81\x01\n\x1cReplaceBuildIdAssignmentRule\x12\x12\n\nrule_index\x18\x01 \x01(\x05\x12>\n\x04rule\x18\x02 \x01(\x0b\x32\x30.temporal.api.taskqueue.v1.BuildIdAssignmentRule\x12\r\n\x05\x66orce\x18\x03 \x01(\x08\x1a@\n\x1b\x44\x65leteBuildIdAssignmentRule\x12\x12\n\nrule_index\x18\x01 \x01(\x05\x12\r\n\x05\x66orce\x18\x02 \x01(\x08\x1aj\n AddCompatibleBuildIdRedirectRule\x12\x46\n\x04rule\x18\x01 \x01(\x0b\x32\x38.temporal.api.taskqueue.v1.CompatibleBuildIdRedirectRule\x1an\n$ReplaceCompatibleBuildIdRedirectRule\x12\x46\n\x04rule\x18\x01 \x01(\x0b\x32\x38.temporal.api.taskqueue.v1.CompatibleBuildIdRedirectRule\x1a>\n#DeleteCompatibleBuildIdRedirectRule\x12\x17\n\x0fsource_build_id\x18\x01 \x01(\t\x1a\x37\n\rCommitBuildId\x12\x17\n\x0ftarget_build_id\x18\x01 \x01(\t\x12\r\n\x05\x66orce\x18\x02 \x01(\x08\x42\x0b\n\toperation"\xfc\x01\n#UpdateWorkerVersioningRulesResponse\x12U\n\x10\x61ssignment_rules\x18\x01 \x03(\x0b\x32;.temporal.api.taskqueue.v1.TimestampedBuildIdAssignmentRule\x12\x66\n\x19\x63ompatible_redirect_rules\x18\x02 \x03(\x0b\x32\x43.temporal.api.taskqueue.v1.TimestampedCompatibleBuildIdRedirectRule\x12\x16\n\x0e\x63onflict_token\x18\x03 \x01(\x0c"H\n\x1fGetWorkerVersioningRulesRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x12\n\ntask_queue\x18\x02 \x01(\t"\xf9\x01\n GetWorkerVersioningRulesResponse\x12U\n\x10\x61ssignment_rules\x18\x01 \x03(\x0b\x32;.temporal.api.taskqueue.v1.TimestampedBuildIdAssignmentRule\x12\x66\n\x19\x63ompatible_redirect_rules\x18\x02 \x03(\x0b\x32\x43.temporal.api.taskqueue.v1.TimestampedCompatibleBuildIdRedirectRule\x12\x16\n\x0e\x63onflict_token\x18\x03 \x01(\x0c"\x9c\x01\n GetWorkerTaskReachabilityRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x11\n\tbuild_ids\x18\x02 \x03(\t\x12\x13\n\x0btask_queues\x18\x03 \x03(\t\x12=\n\x0creachability\x18\x04 \x01(\x0e\x32\'.temporal.api.enums.v1.TaskReachability"r\n!GetWorkerTaskReachabilityResponse\x12M\n\x15\x62uild_id_reachability\x18\x01 \x03(\x0b\x32..temporal.api.taskqueue.v1.BuildIdReachability"\x85\x02\n\x1eUpdateWorkflowExecutionRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x45\n\x12workflow_execution\x18\x02 \x01(\x0b\x32).temporal.api.common.v1.WorkflowExecution\x12\x1e\n\x16\x66irst_execution_run_id\x18\x03 \x01(\t\x12\x37\n\x0bwait_policy\x18\x04 \x01(\x0b\x32".temporal.api.update.v1.WaitPolicy\x12\x30\n\x07request\x18\x05 \x01(\x0b\x32\x1f.temporal.api.update.v1.Request"\xd7\x01\n\x1fUpdateWorkflowExecutionResponse\x12\x35\n\nupdate_ref\x18\x01 \x01(\x0b\x32!.temporal.api.update.v1.UpdateRef\x12\x30\n\x07outcome\x18\x02 \x01(\x0b\x32\x1f.temporal.api.update.v1.Outcome\x12K\n\x05stage\x18\x03 \x01(\x0e\x32<.temporal.api.enums.v1.UpdateWorkflowExecutionLifecycleStage"\xf4\x07\n\x1aStartBatchOperationRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x18\n\x10visibility_query\x18\x02 \x01(\t\x12\x0e\n\x06job_id\x18\x03 \x01(\t\x12\x0e\n\x06reason\x18\x04 \x01(\t\x12=\n\nexecutions\x18\x05 \x03(\x0b\x32).temporal.api.common.v1.WorkflowExecution\x12!\n\x19max_operations_per_second\x18\x06 \x01(\x02\x12Q\n\x15termination_operation\x18\n \x01(\x0b\x32\x30.temporal.api.batch.v1.BatchOperationTerminationH\x00\x12G\n\x10signal_operation\x18\x0b \x01(\x0b\x32+.temporal.api.batch.v1.BatchOperationSignalH\x00\x12S\n\x16\x63\x61ncellation_operation\x18\x0c \x01(\x0b\x32\x31.temporal.api.batch.v1.BatchOperationCancellationH\x00\x12K\n\x12\x64\x65letion_operation\x18\r \x01(\x0b\x32-.temporal.api.batch.v1.BatchOperationDeletionH\x00\x12\x45\n\x0freset_operation\x18\x0e \x01(\x0b\x32*.temporal.api.batch.v1.BatchOperationResetH\x00\x12p\n!update_workflow_options_operation\x18\x0f \x01(\x0b\x32\x43.temporal.api.batch.v1.BatchOperationUpdateWorkflowExecutionOptionsH\x00\x12^\n\x1cunpause_activities_operation\x18\x10 \x01(\x0b\x32\x36.temporal.api.batch.v1.BatchOperationUnpauseActivitiesH\x00\x12Z\n\x1areset_activities_operation\x18\x11 \x01(\x0b\x32\x34.temporal.api.batch.v1.BatchOperationResetActivitiesH\x00\x12g\n!update_activity_options_operation\x18\x12 \x01(\x0b\x32:.temporal.api.batch.v1.BatchOperationUpdateActivityOptionsH\x00\x42\x0b\n\toperation"\x1d\n\x1bStartBatchOperationResponse"`\n\x19StopBatchOperationRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x0e\n\x06job_id\x18\x02 \x01(\t\x12\x0e\n\x06reason\x18\x03 \x01(\t\x12\x10\n\x08identity\x18\x04 \x01(\t"\x1c\n\x1aStopBatchOperationResponse"B\n\x1d\x44\x65scribeBatchOperationRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x0e\n\x06job_id\x18\x02 \x01(\t"\x92\x03\n\x1e\x44\x65scribeBatchOperationResponse\x12\x41\n\x0eoperation_type\x18\x01 \x01(\x0e\x32).temporal.api.enums.v1.BatchOperationType\x12\x0e\n\x06job_id\x18\x02 \x01(\t\x12\x39\n\x05state\x18\x03 \x01(\x0e\x32*.temporal.api.enums.v1.BatchOperationState\x12.\n\nstart_time\x18\x04 \x01(\x0b\x32\x1a.google.protobuf.Timestamp\x12.\n\nclose_time\x18\x05 \x01(\x0b\x32\x1a.google.protobuf.Timestamp\x12\x1d\n\x15total_operation_count\x18\x06 \x01(\x03\x12 \n\x18\x63omplete_operation_count\x18\x07 \x01(\x03\x12\x1f\n\x17\x66\x61ilure_operation_count\x18\x08 \x01(\x03\x12\x10\n\x08identity\x18\t \x01(\t\x12\x0e\n\x06reason\x18\n \x01(\t"[\n\x1aListBatchOperationsRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x11\n\tpage_size\x18\x02 \x01(\x05\x12\x17\n\x0fnext_page_token\x18\x03 \x01(\x0c"y\n\x1bListBatchOperationsResponse\x12\x41\n\x0eoperation_info\x18\x01 \x03(\x0b\x32).temporal.api.batch.v1.BatchOperationInfo\x12\x17\n\x0fnext_page_token\x18\x02 \x01(\x0c"\xb9\x01\n"PollWorkflowExecutionUpdateRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x35\n\nupdate_ref\x18\x02 \x01(\x0b\x32!.temporal.api.update.v1.UpdateRef\x12\x10\n\x08identity\x18\x03 \x01(\t\x12\x37\n\x0bwait_policy\x18\x04 \x01(\x0b\x32".temporal.api.update.v1.WaitPolicy"\xdb\x01\n#PollWorkflowExecutionUpdateResponse\x12\x30\n\x07outcome\x18\x01 \x01(\x0b\x32\x1f.temporal.api.update.v1.Outcome\x12K\n\x05stage\x18\x02 \x01(\x0e\x32<.temporal.api.enums.v1.UpdateWorkflowExecutionLifecycleStage\x12\x35\n\nupdate_ref\x18\x03 \x01(\x0b\x32!.temporal.api.update.v1.UpdateRef"\xea\x02\n\x19PollNexusTaskQueueRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x10\n\x08identity\x18\x02 \x01(\t\x12\x38\n\ntask_queue\x18\x03 \x01(\x0b\x32$.temporal.api.taskqueue.v1.TaskQueue\x12Z\n\x1bworker_version_capabilities\x18\x04 \x01(\x0b\x32\x31.temporal.api.common.v1.WorkerVersionCapabilitiesB\x02\x18\x01\x12O\n\x12\x64\x65ployment_options\x18\x06 \x01(\x0b\x32\x33.temporal.api.deployment.v1.WorkerDeploymentOptions\x12\x41\n\x10worker_heartbeat\x18\x07 \x03(\x0b\x32\'.temporal.api.worker.v1.WorkerHeartbeat"\xb4\x01\n\x1aPollNexusTaskQueueResponse\x12\x12\n\ntask_token\x18\x01 \x01(\x0c\x12/\n\x07request\x18\x02 \x01(\x0b\x32\x1e.temporal.api.nexus.v1.Request\x12Q\n\x17poller_scaling_decision\x18\x03 \x01(\x0b\x32\x30.temporal.api.taskqueue.v1.PollerScalingDecision"\x8e\x01\n RespondNexusTaskCompletedRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x10\n\x08identity\x18\x02 \x01(\t\x12\x12\n\ntask_token\x18\x03 \x01(\x0c\x12\x31\n\x08response\x18\x04 \x01(\x0b\x32\x1f.temporal.api.nexus.v1.Response"#\n!RespondNexusTaskCompletedResponse"\x8c\x01\n\x1dRespondNexusTaskFailedRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x10\n\x08identity\x18\x02 \x01(\t\x12\x12\n\ntask_token\x18\x03 \x01(\x0c\x12\x32\n\x05\x65rror\x18\x04 \x01(\x0b\x32#.temporal.api.nexus.v1.HandlerError" \n\x1eRespondNexusTaskFailedResponse"\xdf\x02\n\x1c\x45xecuteMultiOperationRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12[\n\noperations\x18\x02 \x03(\x0b\x32G.temporal.api.workflowservice.v1.ExecuteMultiOperationRequest.Operation\x1a\xce\x01\n\tOperation\x12X\n\x0estart_workflow\x18\x01 \x01(\x0b\x32>.temporal.api.workflowservice.v1.StartWorkflowExecutionRequestH\x00\x12Z\n\x0fupdate_workflow\x18\x02 \x01(\x0b\x32?.temporal.api.workflowservice.v1.UpdateWorkflowExecutionRequestH\x00\x42\x0b\n\toperation"\xcc\x02\n\x1d\x45xecuteMultiOperationResponse\x12Z\n\tresponses\x18\x01 \x03(\x0b\x32G.temporal.api.workflowservice.v1.ExecuteMultiOperationResponse.Response\x1a\xce\x01\n\x08Response\x12Y\n\x0estart_workflow\x18\x01 \x01(\x0b\x32?.temporal.api.workflowservice.v1.StartWorkflowExecutionResponseH\x00\x12[\n\x0fupdate_workflow\x18\x02 \x01(\x0b\x32@.temporal.api.workflowservice.v1.UpdateWorkflowExecutionResponseH\x00\x42\n\n\x08response"\xd0\x02\n\x1cUpdateActivityOptionsRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12<\n\texecution\x18\x02 \x01(\x0b\x32).temporal.api.common.v1.WorkflowExecution\x12\x10\n\x08identity\x18\x03 \x01(\t\x12\x43\n\x10\x61\x63tivity_options\x18\x04 \x01(\x0b\x32).temporal.api.activity.v1.ActivityOptions\x12/\n\x0bupdate_mask\x18\x05 \x01(\x0b\x32\x1a.google.protobuf.FieldMask\x12\x0c\n\x02id\x18\x06 \x01(\tH\x00\x12\x0e\n\x04type\x18\x07 \x01(\tH\x00\x12\x13\n\tmatch_all\x18\t \x01(\x08H\x00\x12\x18\n\x10restore_original\x18\x08 \x01(\x08\x42\n\n\x08\x61\x63tivity"d\n\x1dUpdateActivityOptionsResponse\x12\x43\n\x10\x61\x63tivity_options\x18\x01 \x01(\x0b\x32).temporal.api.activity.v1.ActivityOptions"\xb3\x01\n\x14PauseActivityRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12<\n\texecution\x18\x02 \x01(\x0b\x32).temporal.api.common.v1.WorkflowExecution\x12\x10\n\x08identity\x18\x03 \x01(\t\x12\x0c\n\x02id\x18\x04 \x01(\tH\x00\x12\x0e\n\x04type\x18\x05 \x01(\tH\x00\x12\x0e\n\x06reason\x18\x06 \x01(\tB\n\n\x08\x61\x63tivity"\x17\n\x15PauseActivityResponse"\x98\x02\n\x16UnpauseActivityRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12<\n\texecution\x18\x02 \x01(\x0b\x32).temporal.api.common.v1.WorkflowExecution\x12\x10\n\x08identity\x18\x03 \x01(\t\x12\x0c\n\x02id\x18\x04 \x01(\tH\x00\x12\x0e\n\x04type\x18\x05 \x01(\tH\x00\x12\x15\n\x0bunpause_all\x18\x06 \x01(\x08H\x00\x12\x16\n\x0ereset_attempts\x18\x07 \x01(\x08\x12\x17\n\x0freset_heartbeat\x18\x08 \x01(\x08\x12)\n\x06jitter\x18\t \x01(\x0b\x32\x19.google.protobuf.DurationB\n\n\x08\x61\x63tivity"\x19\n\x17UnpauseActivityResponse"\xb3\x02\n\x14ResetActivityRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12<\n\texecution\x18\x02 \x01(\x0b\x32).temporal.api.common.v1.WorkflowExecution\x12\x10\n\x08identity\x18\x03 \x01(\t\x12\x0c\n\x02id\x18\x04 \x01(\tH\x00\x12\x0e\n\x04type\x18\x05 \x01(\tH\x00\x12\x13\n\tmatch_all\x18\n \x01(\x08H\x00\x12\x17\n\x0freset_heartbeat\x18\x06 \x01(\x08\x12\x13\n\x0bkeep_paused\x18\x07 \x01(\x08\x12)\n\x06jitter\x18\x08 \x01(\x0b\x32\x19.google.protobuf.Duration\x12 \n\x18restore_original_options\x18\t \x01(\x08\x42\n\n\x08\x61\x63tivity"\x17\n\x15ResetActivityResponse"\x8a\x02\n%UpdateWorkflowExecutionOptionsRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x45\n\x12workflow_execution\x18\x02 \x01(\x0b\x32).temporal.api.common.v1.WorkflowExecution\x12V\n\x1aworkflow_execution_options\x18\x03 \x01(\x0b\x32\x32.temporal.api.workflow.v1.WorkflowExecutionOptions\x12/\n\x0bupdate_mask\x18\x04 \x01(\x0b\x32\x1a.google.protobuf.FieldMask"\x80\x01\n&UpdateWorkflowExecutionOptionsResponse\x12V\n\x1aworkflow_execution_options\x18\x01 \x01(\x0b\x32\x32.temporal.api.workflow.v1.WorkflowExecutionOptions"j\n\x19\x44\x65scribeDeploymentRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12:\n\ndeployment\x18\x02 \x01(\x0b\x32&.temporal.api.deployment.v1.Deployment"a\n\x1a\x44\x65scribeDeploymentResponse\x12\x43\n\x0f\x64\x65ployment_info\x18\x01 \x01(\x0b\x32*.temporal.api.deployment.v1.DeploymentInfo"\xc2\x01\n&DescribeWorkerDeploymentVersionRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x13\n\x07version\x18\x02 \x01(\tB\x02\x18\x01\x12O\n\x12\x64\x65ployment_version\x18\x03 \x01(\x0b\x32\x33.temporal.api.deployment.v1.WorkerDeploymentVersion\x12\x1f\n\x17report_task_queue_stats\x18\x04 \x01(\x08"\x8c\x05\n\'DescribeWorkerDeploymentVersionResponse\x12_\n\x1eworker_deployment_version_info\x18\x01 \x01(\x0b\x32\x37.temporal.api.deployment.v1.WorkerDeploymentVersionInfo\x12v\n\x13version_task_queues\x18\x02 \x03(\x0b\x32Y.temporal.api.workflowservice.v1.DescribeWorkerDeploymentVersionResponse.VersionTaskQueue\x1a\x87\x03\n\x10VersionTaskQueue\x12\x0c\n\x04name\x18\x01 \x01(\t\x12\x32\n\x04type\x18\x02 \x01(\x0e\x32$.temporal.api.enums.v1.TaskQueueType\x12\x38\n\x05stats\x18\x03 \x01(\x0b\x32).temporal.api.taskqueue.v1.TaskQueueStats\x12\x90\x01\n\x15stats_by_priority_key\x18\x04 \x03(\x0b\x32q.temporal.api.workflowservice.v1.DescribeWorkerDeploymentVersionResponse.VersionTaskQueue.StatsByPriorityKeyEntry\x1a\x64\n\x17StatsByPriorityKeyEntry\x12\x0b\n\x03key\x18\x01 \x01(\x05\x12\x38\n\x05value\x18\x02 \x01(\x0b\x32).temporal.api.taskqueue.v1.TaskQueueStats:\x02\x38\x01"M\n\x1f\x44\x65scribeWorkerDeploymentRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x17\n\x0f\x64\x65ployment_name\x18\x02 \x01(\t"\x8c\x01\n DescribeWorkerDeploymentResponse\x12\x16\n\x0e\x63onflict_token\x18\x01 \x01(\x0c\x12P\n\x16worker_deployment_info\x18\x02 \x01(\x0b\x32\x30.temporal.api.deployment.v1.WorkerDeploymentInfo"l\n\x16ListDeploymentsRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x11\n\tpage_size\x18\x02 \x01(\x05\x12\x17\n\x0fnext_page_token\x18\x03 \x01(\x0c\x12\x13\n\x0bseries_name\x18\x04 \x01(\t"w\n\x17ListDeploymentsResponse\x12\x17\n\x0fnext_page_token\x18\x01 \x01(\x0c\x12\x43\n\x0b\x64\x65ployments\x18\x02 \x03(\x0b\x32..temporal.api.deployment.v1.DeploymentListInfo"\xcd\x01\n\x1bSetCurrentDeploymentRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12:\n\ndeployment\x18\x02 \x01(\x0b\x32&.temporal.api.deployment.v1.Deployment\x12\x10\n\x08identity\x18\x03 \x01(\t\x12M\n\x0fupdate_metadata\x18\x04 \x01(\x0b\x32\x34.temporal.api.deployment.v1.UpdateDeploymentMetadata"\xb9\x01\n\x1cSetCurrentDeploymentResponse\x12K\n\x17\x63urrent_deployment_info\x18\x01 \x01(\x0b\x32*.temporal.api.deployment.v1.DeploymentInfo\x12L\n\x18previous_deployment_info\x18\x02 \x01(\x0b\x32*.temporal.api.deployment.v1.DeploymentInfo"\xe5\x01\n(SetWorkerDeploymentCurrentVersionRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x17\n\x0f\x64\x65ployment_name\x18\x02 \x01(\t\x12\x13\n\x07version\x18\x03 \x01(\tB\x02\x18\x01\x12\x10\n\x08\x62uild_id\x18\x07 \x01(\t\x12\x16\n\x0e\x63onflict_token\x18\x04 \x01(\x0c\x12\x10\n\x08identity\x18\x05 \x01(\t\x12"\n\x1aignore_missing_task_queues\x18\x06 \x01(\x08\x12\x18\n\x10\x61llow_no_pollers\x18\t \x01(\x08"\xbb\x01\n)SetWorkerDeploymentCurrentVersionResponse\x12\x16\n\x0e\x63onflict_token\x18\x01 \x01(\x0c\x12\x1c\n\x10previous_version\x18\x02 \x01(\tB\x02\x18\x01\x12X\n\x1bprevious_deployment_version\x18\x03 \x01(\x0b\x32\x33.temporal.api.deployment.v1.WorkerDeploymentVersion"\xf9\x01\n(SetWorkerDeploymentRampingVersionRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x17\n\x0f\x64\x65ployment_name\x18\x02 \x01(\t\x12\x13\n\x07version\x18\x03 \x01(\tB\x02\x18\x01\x12\x10\n\x08\x62uild_id\x18\x08 \x01(\t\x12\x12\n\npercentage\x18\x04 \x01(\x02\x12\x16\n\x0e\x63onflict_token\x18\x05 \x01(\x0c\x12\x10\n\x08identity\x18\x06 \x01(\t\x12"\n\x1aignore_missing_task_queues\x18\x07 \x01(\x08\x12\x18\n\x10\x61llow_no_pollers\x18\n \x01(\x08"\xd8\x01\n)SetWorkerDeploymentRampingVersionResponse\x12\x16\n\x0e\x63onflict_token\x18\x01 \x01(\x0c\x12\x1c\n\x10previous_version\x18\x02 \x01(\tB\x02\x18\x01\x12X\n\x1bprevious_deployment_version\x18\x04 \x01(\x0b\x32\x33.temporal.api.deployment.v1.WorkerDeploymentVersion\x12\x1b\n\x13previous_percentage\x18\x03 \x01(\x02"]\n\x1cListWorkerDeploymentsRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x11\n\tpage_size\x18\x02 \x01(\x05\x12\x17\n\x0fnext_page_token\x18\x03 \x01(\x0c"\x9f\x05\n\x1dListWorkerDeploymentsResponse\x12\x17\n\x0fnext_page_token\x18\x01 \x01(\x0c\x12r\n\x12worker_deployments\x18\x02 \x03(\x0b\x32V.temporal.api.workflowservice.v1.ListWorkerDeploymentsResponse.WorkerDeploymentSummary\x1a\xf0\x03\n\x17WorkerDeploymentSummary\x12\x0c\n\x04name\x18\x01 \x01(\t\x12/\n\x0b\x63reate_time\x18\x02 \x01(\x0b\x32\x1a.google.protobuf.Timestamp\x12\x41\n\x0erouting_config\x18\x03 \x01(\x0b\x32).temporal.api.deployment.v1.RoutingConfig\x12o\n\x16latest_version_summary\x18\x04 \x01(\x0b\x32O.temporal.api.deployment.v1.WorkerDeploymentInfo.WorkerDeploymentVersionSummary\x12p\n\x17\x63urrent_version_summary\x18\x05 \x01(\x0b\x32O.temporal.api.deployment.v1.WorkerDeploymentInfo.WorkerDeploymentVersionSummary\x12p\n\x17ramping_version_summary\x18\x06 \x01(\x0b\x32O.temporal.api.deployment.v1.WorkerDeploymentInfo.WorkerDeploymentVersionSummary"\xc8\x01\n$DeleteWorkerDeploymentVersionRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x13\n\x07version\x18\x02 \x01(\tB\x02\x18\x01\x12O\n\x12\x64\x65ployment_version\x18\x05 \x01(\x0b\x32\x33.temporal.api.deployment.v1.WorkerDeploymentVersion\x12\x15\n\rskip_drainage\x18\x03 \x01(\x08\x12\x10\n\x08identity\x18\x04 \x01(\t"\'\n%DeleteWorkerDeploymentVersionResponse"]\n\x1d\x44\x65leteWorkerDeploymentRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x17\n\x0f\x64\x65ployment_name\x18\x02 \x01(\t\x12\x10\n\x08identity\x18\x03 \x01(\t" \n\x1e\x44\x65leteWorkerDeploymentResponse"\xa2\x03\n,UpdateWorkerDeploymentVersionMetadataRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x13\n\x07version\x18\x02 \x01(\tB\x02\x18\x01\x12O\n\x12\x64\x65ployment_version\x18\x05 \x01(\x0b\x32\x33.temporal.api.deployment.v1.WorkerDeploymentVersion\x12x\n\x0eupsert_entries\x18\x03 \x03(\x0b\x32`.temporal.api.workflowservice.v1.UpdateWorkerDeploymentVersionMetadataRequest.UpsertEntriesEntry\x12\x16\n\x0eremove_entries\x18\x04 \x03(\t\x12\x10\n\x08identity\x18\x06 \x01(\t\x1aU\n\x12UpsertEntriesEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12.\n\x05value\x18\x02 \x01(\x0b\x32\x1f.temporal.api.common.v1.Payload:\x02\x38\x01"n\n-UpdateWorkerDeploymentVersionMetadataResponse\x12=\n\x08metadata\x18\x01 \x01(\x0b\x32+.temporal.api.deployment.v1.VersionMetadata"\xbd\x01\n!SetWorkerDeploymentManagerRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x17\n\x0f\x64\x65ployment_name\x18\x02 \x01(\t\x12\x1a\n\x10manager_identity\x18\x03 \x01(\tH\x00\x12\x0e\n\x04self\x18\x04 \x01(\x08H\x00\x12\x16\n\x0e\x63onflict_token\x18\x05 \x01(\x0c\x12\x10\n\x08identity\x18\x06 \x01(\tB\x16\n\x14new_manager_identity"_\n"SetWorkerDeploymentManagerResponse\x12\x16\n\x0e\x63onflict_token\x18\x01 \x01(\x0c\x12!\n\x19previous_manager_identity\x18\x02 \x01(\t"E\n\x1bGetCurrentDeploymentRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x13\n\x0bseries_name\x18\x02 \x01(\t"k\n\x1cGetCurrentDeploymentResponse\x12K\n\x17\x63urrent_deployment_info\x18\x01 \x01(\x0b\x32*.temporal.api.deployment.v1.DeploymentInfo"q\n GetDeploymentReachabilityRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12:\n\ndeployment\x18\x02 \x01(\x0b\x32&.temporal.api.deployment.v1.Deployment"\xe3\x01\n!GetDeploymentReachabilityResponse\x12\x43\n\x0f\x64\x65ployment_info\x18\x01 \x01(\x0b\x32*.temporal.api.deployment.v1.DeploymentInfo\x12\x43\n\x0creachability\x18\x02 \x01(\x0e\x32-.temporal.api.enums.v1.DeploymentReachability\x12\x34\n\x10last_update_time\x18\x03 \x01(\x0b\x32\x1a.google.protobuf.Timestamp"\xb4\x01\n\x19\x43reateWorkflowRuleRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x35\n\x04spec\x18\x02 \x01(\x0b\x32\'.temporal.api.rules.v1.WorkflowRuleSpec\x12\x12\n\nforce_scan\x18\x03 \x01(\x08\x12\x12\n\nrequest_id\x18\x04 \x01(\t\x12\x10\n\x08identity\x18\x05 \x01(\t\x12\x13\n\x0b\x64\x65scription\x18\x06 \x01(\t"_\n\x1a\x43reateWorkflowRuleResponse\x12\x31\n\x04rule\x18\x01 \x01(\x0b\x32#.temporal.api.rules.v1.WorkflowRule\x12\x0e\n\x06job_id\x18\x02 \x01(\t"A\n\x1b\x44\x65scribeWorkflowRuleRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x0f\n\x07rule_id\x18\x02 \x01(\t"Q\n\x1c\x44\x65scribeWorkflowRuleResponse\x12\x31\n\x04rule\x18\x01 \x01(\x0b\x32#.temporal.api.rules.v1.WorkflowRule"?\n\x19\x44\x65leteWorkflowRuleRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x0f\n\x07rule_id\x18\x02 \x01(\t"\x1c\n\x1a\x44\x65leteWorkflowRuleResponse"F\n\x18ListWorkflowRulesRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x17\n\x0fnext_page_token\x18\x02 \x01(\x0c"h\n\x19ListWorkflowRulesResponse\x12\x32\n\x05rules\x18\x01 \x03(\x0b\x32#.temporal.api.rules.v1.WorkflowRule\x12\x17\n\x0fnext_page_token\x18\x02 \x01(\x0c"\xce\x01\n\x1aTriggerWorkflowRuleRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12<\n\texecution\x18\x02 \x01(\x0b\x32).temporal.api.common.v1.WorkflowExecution\x12\x0c\n\x02id\x18\x04 \x01(\tH\x00\x12\x37\n\x04spec\x18\x05 \x01(\x0b\x32\'.temporal.api.rules.v1.WorkflowRuleSpecH\x00\x12\x10\n\x08identity\x18\x03 \x01(\tB\x06\n\x04rule".\n\x1bTriggerWorkflowRuleResponse\x12\x0f\n\x07\x61pplied\x18\x01 \x01(\x08"\x86\x01\n\x1cRecordWorkerHeartbeatRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x10\n\x08identity\x18\x02 \x01(\t\x12\x41\n\x10worker_heartbeat\x18\x03 \x03(\x0b\x32\'.temporal.api.worker.v1.WorkerHeartbeat"\x1f\n\x1dRecordWorkerHeartbeatResponse"b\n\x12ListWorkersRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x11\n\tpage_size\x18\x02 \x01(\x05\x12\x17\n\x0fnext_page_token\x18\x03 \x01(\x0c\x12\r\n\x05query\x18\x04 \x01(\t"h\n\x13ListWorkersResponse\x12\x38\n\x0cworkers_info\x18\x01 \x03(\x0b\x32".temporal.api.worker.v1.WorkerInfo\x12\x17\n\x0fnext_page_token\x18\x02 \x01(\x0c"\xe2\x03\n\x1cUpdateTaskQueueConfigRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x10\n\x08identity\x18\x02 \x01(\t\x12\x12\n\ntask_queue\x18\x03 \x01(\t\x12=\n\x0ftask_queue_type\x18\x04 \x01(\x0e\x32$.temporal.api.enums.v1.TaskQueueType\x12n\n\x17update_queue_rate_limit\x18\x05 \x01(\x0b\x32M.temporal.api.workflowservice.v1.UpdateTaskQueueConfigRequest.RateLimitUpdate\x12}\n&update_fairness_key_rate_limit_default\x18\x06 \x01(\x0b\x32M.temporal.api.workflowservice.v1.UpdateTaskQueueConfigRequest.RateLimitUpdate\x1a[\n\x0fRateLimitUpdate\x12\x38\n\nrate_limit\x18\x01 \x01(\x0b\x32$.temporal.api.taskqueue.v1.RateLimit\x12\x0e\n\x06reason\x18\x02 \x01(\t"[\n\x1dUpdateTaskQueueConfigResponse\x12:\n\x06\x63onfig\x18\x01 \x01(\x0b\x32*.temporal.api.taskqueue.v1.TaskQueueConfig"\x89\x01\n\x18\x46\x65tchWorkerConfigRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x10\n\x08identity\x18\x02 \x01(\t\x12\x0e\n\x06reason\x18\x03 \x01(\t\x12\x38\n\x08selector\x18\x06 \x01(\x0b\x32&.temporal.api.common.v1.WorkerSelector"U\n\x19\x46\x65tchWorkerConfigResponse\x12\x38\n\rworker_config\x18\x01 \x01(\x0b\x32!.temporal.api.sdk.v1.WorkerConfig"\xf5\x01\n\x19UpdateWorkerConfigRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x10\n\x08identity\x18\x02 \x01(\t\x12\x0e\n\x06reason\x18\x03 \x01(\t\x12\x38\n\rworker_config\x18\x04 \x01(\x0b\x32!.temporal.api.sdk.v1.WorkerConfig\x12/\n\x0bupdate_mask\x18\x05 \x01(\x0b\x32\x1a.google.protobuf.FieldMask\x12\x38\n\x08selector\x18\x06 \x01(\x0b\x32&.temporal.api.common.v1.WorkerSelector"d\n\x1aUpdateWorkerConfigResponse\x12:\n\rworker_config\x18\x01 \x01(\x0b\x32!.temporal.api.sdk.v1.WorkerConfigH\x00\x42\n\n\x08response"G\n\x15\x44\x65scribeWorkerRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x1b\n\x13worker_instance_key\x18\x02 \x01(\t"Q\n\x16\x44\x65scribeWorkerResponse\x12\x37\n\x0bworker_info\x18\x01 \x01(\x0b\x32".temporal.api.worker.v1.WorkerInfo"\xb4\x07\n\x1dStartActivityExecutionRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x10\n\x08identity\x18\x02 \x01(\t\x12\x12\n\nrequest_id\x18\x03 \x01(\t\x12\x13\n\x0b\x61\x63tivity_id\x18\x04 \x01(\t\x12;\n\ractivity_type\x18\x05 \x01(\x0b\x32$.temporal.api.common.v1.ActivityType\x12\x38\n\ntask_queue\x18\x06 \x01(\x0b\x32$.temporal.api.taskqueue.v1.TaskQueue\x12<\n\x19schedule_to_close_timeout\x18\x07 \x01(\x0b\x32\x19.google.protobuf.Duration\x12<\n\x19schedule_to_start_timeout\x18\x08 \x01(\x0b\x32\x19.google.protobuf.Duration\x12\x39\n\x16start_to_close_timeout\x18\t \x01(\x0b\x32\x19.google.protobuf.Duration\x12\x34\n\x11heartbeat_timeout\x18\n \x01(\x0b\x32\x19.google.protobuf.Duration\x12\x39\n\x0cretry_policy\x18\x0b \x01(\x0b\x32#.temporal.api.common.v1.RetryPolicy\x12/\n\x05input\x18\x0c \x01(\x0b\x32 .temporal.api.common.v1.Payloads\x12\x45\n\x0fid_reuse_policy\x18\r \x01(\x0e\x32,.temporal.api.enums.v1.ActivityIdReusePolicy\x12K\n\x12id_conflict_policy\x18\x0e \x01(\x0e\x32/.temporal.api.enums.v1.ActivityIdConflictPolicy\x12\x43\n\x11search_attributes\x18\x0f \x01(\x0b\x32(.temporal.api.common.v1.SearchAttributes\x12.\n\x06header\x18\x10 \x01(\x0b\x32\x1e.temporal.api.common.v1.Header\x12\x38\n\ruser_metadata\x18\x11 \x01(\x0b\x32!.temporal.api.sdk.v1.UserMetadata\x12\x32\n\x08priority\x18\x12 \x01(\x0b\x32 .temporal.api.common.v1.Priority"A\n\x1eStartActivityExecutionResponse\x12\x0e\n\x06run_id\x18\x01 \x01(\t\x12\x0f\n\x07started\x18\x02 \x01(\x08"\xa3\x01\n DescribeActivityExecutionRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x13\n\x0b\x61\x63tivity_id\x18\x02 \x01(\t\x12\x0e\n\x06run_id\x18\x03 \x01(\t\x12\x15\n\rinclude_input\x18\x04 \x01(\x08\x12\x17\n\x0finclude_outcome\x18\x05 \x01(\x08\x12\x17\n\x0flong_poll_token\x18\x06 \x01(\x0c"\x81\x02\n!DescribeActivityExecutionResponse\x12\x0e\n\x06run_id\x18\x01 \x01(\t\x12=\n\x04info\x18\x02 \x01(\x0b\x32/.temporal.api.activity.v1.ActivityExecutionInfo\x12/\n\x05input\x18\x03 \x01(\x0b\x32 .temporal.api.common.v1.Payloads\x12\x43\n\x07outcome\x18\x04 \x01(\x0b\x32\x32.temporal.api.activity.v1.ActivityExecutionOutcome\x12\x17\n\x0flong_poll_token\x18\x05 \x01(\x0c"V\n\x1cPollActivityExecutionRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x13\n\x0b\x61\x63tivity_id\x18\x02 \x01(\t\x12\x0e\n\x06run_id\x18\x03 \x01(\t"t\n\x1dPollActivityExecutionResponse\x12\x0e\n\x06run_id\x18\x01 \x01(\t\x12\x43\n\x07outcome\x18\x02 \x01(\x0b\x32\x32.temporal.api.activity.v1.ActivityExecutionOutcome"m\n\x1dListActivityExecutionsRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x11\n\tpage_size\x18\x02 \x01(\x05\x12\x17\n\x0fnext_page_token\x18\x03 \x01(\x0c\x12\r\n\x05query\x18\x04 \x01(\t"\x82\x01\n\x1eListActivityExecutionsResponse\x12G\n\nexecutions\x18\x01 \x03(\x0b\x32\x33.temporal.api.activity.v1.ActivityExecutionListInfo\x12\x17\n\x0fnext_page_token\x18\x02 \x01(\x0c"B\n\x1e\x43ountActivityExecutionsRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\r\n\x05query\x18\x02 \x01(\t"\xed\x01\n\x1f\x43ountActivityExecutionsResponse\x12\r\n\x05\x63ount\x18\x01 \x01(\x03\x12\x61\n\x06groups\x18\x02 \x03(\x0b\x32Q.temporal.api.workflowservice.v1.CountActivityExecutionsResponse.AggregationGroup\x1aX\n\x10\x41ggregationGroup\x12\x35\n\x0cgroup_values\x18\x01 \x03(\x0b\x32\x1f.temporal.api.common.v1.Payload\x12\r\n\x05\x63ount\x18\x02 \x01(\x03"\x95\x01\n%RequestCancelActivityExecutionRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x13\n\x0b\x61\x63tivity_id\x18\x02 \x01(\t\x12\x0e\n\x06run_id\x18\x03 \x01(\t\x12\x10\n\x08identity\x18\x04 \x01(\t\x12\x12\n\nrequest_id\x18\x05 \x01(\t\x12\x0e\n\x06reason\x18\x06 \x01(\t"(\n&RequestCancelActivityExecutionResponse"\x91\x01\n!TerminateActivityExecutionRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x13\n\x0b\x61\x63tivity_id\x18\x02 \x01(\t\x12\x0e\n\x06run_id\x18\x03 \x01(\t\x12\x10\n\x08identity\x18\x04 \x01(\t\x12\x12\n\nrequest_id\x18\x05 \x01(\t\x12\x0e\n\x06reason\x18\x06 \x01(\t"$\n"TerminateActivityExecutionResponse"X\n\x1e\x44\x65leteActivityExecutionRequest\x12\x11\n\tnamespace\x18\x01 \x01(\t\x12\x13\n\x0b\x61\x63tivity_id\x18\x02 \x01(\t\x12\x0e\n\x06run_id\x18\x03 \x01(\t"!\n\x1f\x44\x65leteActivityExecutionResponseB\xbe\x01\n"io.temporal.api.workflowservice.v1B\x14RequestResponseProtoP\x01Z5go.temporal.io/api/workflowservice/v1;workflowservice\xaa\x02!Temporalio.Api.WorkflowService.V1\xea\x02$Temporalio::Api::WorkflowService::V1b\x06proto3' ) @@ -704,6 +707,57 @@ ] _DESCRIBEWORKERREQUEST = DESCRIPTOR.message_types_by_name["DescribeWorkerRequest"] _DESCRIBEWORKERRESPONSE = DESCRIPTOR.message_types_by_name["DescribeWorkerResponse"] +_STARTACTIVITYEXECUTIONREQUEST = DESCRIPTOR.message_types_by_name[ + "StartActivityExecutionRequest" +] +_STARTACTIVITYEXECUTIONRESPONSE = DESCRIPTOR.message_types_by_name[ + "StartActivityExecutionResponse" +] +_DESCRIBEACTIVITYEXECUTIONREQUEST = DESCRIPTOR.message_types_by_name[ + "DescribeActivityExecutionRequest" +] +_DESCRIBEACTIVITYEXECUTIONRESPONSE = DESCRIPTOR.message_types_by_name[ + "DescribeActivityExecutionResponse" +] +_POLLACTIVITYEXECUTIONREQUEST = DESCRIPTOR.message_types_by_name[ + "PollActivityExecutionRequest" +] +_POLLACTIVITYEXECUTIONRESPONSE = DESCRIPTOR.message_types_by_name[ + "PollActivityExecutionResponse" +] +_LISTACTIVITYEXECUTIONSREQUEST = DESCRIPTOR.message_types_by_name[ + "ListActivityExecutionsRequest" +] +_LISTACTIVITYEXECUTIONSRESPONSE = DESCRIPTOR.message_types_by_name[ + "ListActivityExecutionsResponse" +] +_COUNTACTIVITYEXECUTIONSREQUEST = DESCRIPTOR.message_types_by_name[ + "CountActivityExecutionsRequest" +] +_COUNTACTIVITYEXECUTIONSRESPONSE = DESCRIPTOR.message_types_by_name[ + "CountActivityExecutionsResponse" +] +_COUNTACTIVITYEXECUTIONSRESPONSE_AGGREGATIONGROUP = ( + _COUNTACTIVITYEXECUTIONSRESPONSE.nested_types_by_name["AggregationGroup"] +) +_REQUESTCANCELACTIVITYEXECUTIONREQUEST = DESCRIPTOR.message_types_by_name[ + "RequestCancelActivityExecutionRequest" +] +_REQUESTCANCELACTIVITYEXECUTIONRESPONSE = DESCRIPTOR.message_types_by_name[ + "RequestCancelActivityExecutionResponse" +] +_TERMINATEACTIVITYEXECUTIONREQUEST = DESCRIPTOR.message_types_by_name[ + "TerminateActivityExecutionRequest" +] +_TERMINATEACTIVITYEXECUTIONRESPONSE = DESCRIPTOR.message_types_by_name[ + "TerminateActivityExecutionResponse" +] +_DELETEACTIVITYEXECUTIONREQUEST = DESCRIPTOR.message_types_by_name[ + "DeleteActivityExecutionRequest" +] +_DELETEACTIVITYEXECUTIONRESPONSE = DESCRIPTOR.message_types_by_name[ + "DeleteActivityExecutionResponse" +] RegisterNamespaceRequest = _reflection.GeneratedProtocolMessageType( "RegisterNamespaceRequest", (_message.Message,), @@ -3052,6 +3106,192 @@ ) _sym_db.RegisterMessage(DescribeWorkerResponse) +StartActivityExecutionRequest = _reflection.GeneratedProtocolMessageType( + "StartActivityExecutionRequest", + (_message.Message,), + { + "DESCRIPTOR": _STARTACTIVITYEXECUTIONREQUEST, + "__module__": "temporalio.api.workflowservice.v1.request_response_pb2", + # @@protoc_insertion_point(class_scope:temporal.api.workflowservice.v1.StartActivityExecutionRequest) + }, +) +_sym_db.RegisterMessage(StartActivityExecutionRequest) + +StartActivityExecutionResponse = _reflection.GeneratedProtocolMessageType( + "StartActivityExecutionResponse", + (_message.Message,), + { + "DESCRIPTOR": _STARTACTIVITYEXECUTIONRESPONSE, + "__module__": "temporalio.api.workflowservice.v1.request_response_pb2", + # @@protoc_insertion_point(class_scope:temporal.api.workflowservice.v1.StartActivityExecutionResponse) + }, +) +_sym_db.RegisterMessage(StartActivityExecutionResponse) + +DescribeActivityExecutionRequest = _reflection.GeneratedProtocolMessageType( + "DescribeActivityExecutionRequest", + (_message.Message,), + { + "DESCRIPTOR": _DESCRIBEACTIVITYEXECUTIONREQUEST, + "__module__": "temporalio.api.workflowservice.v1.request_response_pb2", + # @@protoc_insertion_point(class_scope:temporal.api.workflowservice.v1.DescribeActivityExecutionRequest) + }, +) +_sym_db.RegisterMessage(DescribeActivityExecutionRequest) + +DescribeActivityExecutionResponse = _reflection.GeneratedProtocolMessageType( + "DescribeActivityExecutionResponse", + (_message.Message,), + { + "DESCRIPTOR": _DESCRIBEACTIVITYEXECUTIONRESPONSE, + "__module__": "temporalio.api.workflowservice.v1.request_response_pb2", + # @@protoc_insertion_point(class_scope:temporal.api.workflowservice.v1.DescribeActivityExecutionResponse) + }, +) +_sym_db.RegisterMessage(DescribeActivityExecutionResponse) + +PollActivityExecutionRequest = _reflection.GeneratedProtocolMessageType( + "PollActivityExecutionRequest", + (_message.Message,), + { + "DESCRIPTOR": _POLLACTIVITYEXECUTIONREQUEST, + "__module__": "temporalio.api.workflowservice.v1.request_response_pb2", + # @@protoc_insertion_point(class_scope:temporal.api.workflowservice.v1.PollActivityExecutionRequest) + }, +) +_sym_db.RegisterMessage(PollActivityExecutionRequest) + +PollActivityExecutionResponse = _reflection.GeneratedProtocolMessageType( + "PollActivityExecutionResponse", + (_message.Message,), + { + "DESCRIPTOR": _POLLACTIVITYEXECUTIONRESPONSE, + "__module__": "temporalio.api.workflowservice.v1.request_response_pb2", + # @@protoc_insertion_point(class_scope:temporal.api.workflowservice.v1.PollActivityExecutionResponse) + }, +) +_sym_db.RegisterMessage(PollActivityExecutionResponse) + +ListActivityExecutionsRequest = _reflection.GeneratedProtocolMessageType( + "ListActivityExecutionsRequest", + (_message.Message,), + { + "DESCRIPTOR": _LISTACTIVITYEXECUTIONSREQUEST, + "__module__": "temporalio.api.workflowservice.v1.request_response_pb2", + # @@protoc_insertion_point(class_scope:temporal.api.workflowservice.v1.ListActivityExecutionsRequest) + }, +) +_sym_db.RegisterMessage(ListActivityExecutionsRequest) + +ListActivityExecutionsResponse = _reflection.GeneratedProtocolMessageType( + "ListActivityExecutionsResponse", + (_message.Message,), + { + "DESCRIPTOR": _LISTACTIVITYEXECUTIONSRESPONSE, + "__module__": "temporalio.api.workflowservice.v1.request_response_pb2", + # @@protoc_insertion_point(class_scope:temporal.api.workflowservice.v1.ListActivityExecutionsResponse) + }, +) +_sym_db.RegisterMessage(ListActivityExecutionsResponse) + +CountActivityExecutionsRequest = _reflection.GeneratedProtocolMessageType( + "CountActivityExecutionsRequest", + (_message.Message,), + { + "DESCRIPTOR": _COUNTACTIVITYEXECUTIONSREQUEST, + "__module__": "temporalio.api.workflowservice.v1.request_response_pb2", + # @@protoc_insertion_point(class_scope:temporal.api.workflowservice.v1.CountActivityExecutionsRequest) + }, +) +_sym_db.RegisterMessage(CountActivityExecutionsRequest) + +CountActivityExecutionsResponse = _reflection.GeneratedProtocolMessageType( + "CountActivityExecutionsResponse", + (_message.Message,), + { + "AggregationGroup": _reflection.GeneratedProtocolMessageType( + "AggregationGroup", + (_message.Message,), + { + "DESCRIPTOR": _COUNTACTIVITYEXECUTIONSRESPONSE_AGGREGATIONGROUP, + "__module__": "temporalio.api.workflowservice.v1.request_response_pb2", + # @@protoc_insertion_point(class_scope:temporal.api.workflowservice.v1.CountActivityExecutionsResponse.AggregationGroup) + }, + ), + "DESCRIPTOR": _COUNTACTIVITYEXECUTIONSRESPONSE, + "__module__": "temporalio.api.workflowservice.v1.request_response_pb2", + # @@protoc_insertion_point(class_scope:temporal.api.workflowservice.v1.CountActivityExecutionsResponse) + }, +) +_sym_db.RegisterMessage(CountActivityExecutionsResponse) +_sym_db.RegisterMessage(CountActivityExecutionsResponse.AggregationGroup) + +RequestCancelActivityExecutionRequest = _reflection.GeneratedProtocolMessageType( + "RequestCancelActivityExecutionRequest", + (_message.Message,), + { + "DESCRIPTOR": _REQUESTCANCELACTIVITYEXECUTIONREQUEST, + "__module__": "temporalio.api.workflowservice.v1.request_response_pb2", + # @@protoc_insertion_point(class_scope:temporal.api.workflowservice.v1.RequestCancelActivityExecutionRequest) + }, +) +_sym_db.RegisterMessage(RequestCancelActivityExecutionRequest) + +RequestCancelActivityExecutionResponse = _reflection.GeneratedProtocolMessageType( + "RequestCancelActivityExecutionResponse", + (_message.Message,), + { + "DESCRIPTOR": _REQUESTCANCELACTIVITYEXECUTIONRESPONSE, + "__module__": "temporalio.api.workflowservice.v1.request_response_pb2", + # @@protoc_insertion_point(class_scope:temporal.api.workflowservice.v1.RequestCancelActivityExecutionResponse) + }, +) +_sym_db.RegisterMessage(RequestCancelActivityExecutionResponse) + +TerminateActivityExecutionRequest = _reflection.GeneratedProtocolMessageType( + "TerminateActivityExecutionRequest", + (_message.Message,), + { + "DESCRIPTOR": _TERMINATEACTIVITYEXECUTIONREQUEST, + "__module__": "temporalio.api.workflowservice.v1.request_response_pb2", + # @@protoc_insertion_point(class_scope:temporal.api.workflowservice.v1.TerminateActivityExecutionRequest) + }, +) +_sym_db.RegisterMessage(TerminateActivityExecutionRequest) + +TerminateActivityExecutionResponse = _reflection.GeneratedProtocolMessageType( + "TerminateActivityExecutionResponse", + (_message.Message,), + { + "DESCRIPTOR": _TERMINATEACTIVITYEXECUTIONRESPONSE, + "__module__": "temporalio.api.workflowservice.v1.request_response_pb2", + # @@protoc_insertion_point(class_scope:temporal.api.workflowservice.v1.TerminateActivityExecutionResponse) + }, +) +_sym_db.RegisterMessage(TerminateActivityExecutionResponse) + +DeleteActivityExecutionRequest = _reflection.GeneratedProtocolMessageType( + "DeleteActivityExecutionRequest", + (_message.Message,), + { + "DESCRIPTOR": _DELETEACTIVITYEXECUTIONREQUEST, + "__module__": "temporalio.api.workflowservice.v1.request_response_pb2", + # @@protoc_insertion_point(class_scope:temporal.api.workflowservice.v1.DeleteActivityExecutionRequest) + }, +) +_sym_db.RegisterMessage(DeleteActivityExecutionRequest) + +DeleteActivityExecutionResponse = _reflection.GeneratedProtocolMessageType( + "DeleteActivityExecutionResponse", + (_message.Message,), + { + "DESCRIPTOR": _DELETEACTIVITYEXECUTIONRESPONSE, + "__module__": "temporalio.api.workflowservice.v1.request_response_pb2", + # @@protoc_insertion_point(class_scope:temporal.api.workflowservice.v1.DeleteActivityExecutionResponse) + }, +) +_sym_db.RegisterMessage(DeleteActivityExecutionResponse) + if _descriptor._USE_C_DESCRIPTORS == False: DESCRIPTOR._options = None DESCRIPTOR._serialized_options = b'\n"io.temporal.api.workflowservice.v1B\024RequestResponseProtoP\001Z5go.temporal.io/api/workflowservice/v1;workflowservice\252\002!Temporalio.Api.WorkflowService.V1\352\002$Temporalio::Api::WorkflowService::V1' @@ -3231,444 +3471,478 @@ _UPDATEWORKERDEPLOYMENTVERSIONMETADATAREQUEST.fields_by_name[ "version" ]._serialized_options = b"\030\001" - _REGISTERNAMESPACEREQUEST._serialized_start = 1492 - _REGISTERNAMESPACEREQUEST._serialized_end = 2140 - _REGISTERNAMESPACEREQUEST_DATAENTRY._serialized_start = 2097 - _REGISTERNAMESPACEREQUEST_DATAENTRY._serialized_end = 2140 - _REGISTERNAMESPACERESPONSE._serialized_start = 2142 - _REGISTERNAMESPACERESPONSE._serialized_end = 2169 - _LISTNAMESPACESREQUEST._serialized_start = 2172 - _LISTNAMESPACESREQUEST._serialized_end = 2309 - _LISTNAMESPACESRESPONSE._serialized_start = 2312 - _LISTNAMESPACESRESPONSE._serialized_end = 2441 - _DESCRIBENAMESPACEREQUEST._serialized_start = 2443 - _DESCRIBENAMESPACEREQUEST._serialized_end = 2500 - _DESCRIBENAMESPACERESPONSE._serialized_start = 2503 - _DESCRIBENAMESPACERESPONSE._serialized_end = 2867 - _UPDATENAMESPACEREQUEST._serialized_start = 2870 - _UPDATENAMESPACEREQUEST._serialized_end = 3205 - _UPDATENAMESPACERESPONSE._serialized_start = 3208 - _UPDATENAMESPACERESPONSE._serialized_end = 3499 - _DEPRECATENAMESPACEREQUEST._serialized_start = 3501 - _DEPRECATENAMESPACEREQUEST._serialized_end = 3571 - _DEPRECATENAMESPACERESPONSE._serialized_start = 3573 - _DEPRECATENAMESPACERESPONSE._serialized_end = 3601 - _STARTWORKFLOWEXECUTIONREQUEST._serialized_start = 3604 - _STARTWORKFLOWEXECUTIONREQUEST._serialized_end = 5147 - _STARTWORKFLOWEXECUTIONRESPONSE._serialized_start = 5150 - _STARTWORKFLOWEXECUTIONRESPONSE._serialized_end = 5416 - _GETWORKFLOWEXECUTIONHISTORYREQUEST._serialized_start = 5419 - _GETWORKFLOWEXECUTIONHISTORYREQUEST._serialized_end = 5717 - _GETWORKFLOWEXECUTIONHISTORYRESPONSE._serialized_start = 5720 - _GETWORKFLOWEXECUTIONHISTORYRESPONSE._serialized_end = 5906 - _GETWORKFLOWEXECUTIONHISTORYREVERSEREQUEST._serialized_start = 5909 - _GETWORKFLOWEXECUTIONHISTORYREVERSEREQUEST._serialized_end = 6085 - _GETWORKFLOWEXECUTIONHISTORYREVERSERESPONSE._serialized_start = 6087 - _GETWORKFLOWEXECUTIONHISTORYREVERSERESPONSE._serialized_end = 6207 - _POLLWORKFLOWTASKQUEUEREQUEST._serialized_start = 6210 - _POLLWORKFLOWTASKQUEUEREQUEST._serialized_end = 6604 - _POLLWORKFLOWTASKQUEUERESPONSE._serialized_start = 6607 - _POLLWORKFLOWTASKQUEUERESPONSE._serialized_end = 7520 - _POLLWORKFLOWTASKQUEUERESPONSE_QUERIESENTRY._serialized_start = 7436 - _POLLWORKFLOWTASKQUEUERESPONSE_QUERIESENTRY._serialized_end = 7520 - _RESPONDWORKFLOWTASKCOMPLETEDREQUEST._serialized_start = 7523 - _RESPONDWORKFLOWTASKCOMPLETEDREQUEST._serialized_end = 8728 - _RESPONDWORKFLOWTASKCOMPLETEDREQUEST_QUERYRESULTSENTRY._serialized_start = 8562 - _RESPONDWORKFLOWTASKCOMPLETEDREQUEST_QUERYRESULTSENTRY._serialized_end = 8657 - _RESPONDWORKFLOWTASKCOMPLETEDREQUEST_CAPABILITIES._serialized_start = 8659 - _RESPONDWORKFLOWTASKCOMPLETEDREQUEST_CAPABILITIES._serialized_end = 8728 - _RESPONDWORKFLOWTASKCOMPLETEDRESPONSE._serialized_start = 8731 - _RESPONDWORKFLOWTASKCOMPLETEDRESPONSE._serialized_end = 8976 - _RESPONDWORKFLOWTASKFAILEDREQUEST._serialized_start = 8979 - _RESPONDWORKFLOWTASKFAILEDREQUEST._serialized_end = 9483 - _RESPONDWORKFLOWTASKFAILEDRESPONSE._serialized_start = 9485 - _RESPONDWORKFLOWTASKFAILEDRESPONSE._serialized_end = 9520 - _POLLACTIVITYTASKQUEUEREQUEST._serialized_start = 9523 - _POLLACTIVITYTASKQUEUEREQUEST._serialized_end = 9963 - _POLLACTIVITYTASKQUEUERESPONSE._serialized_start = 9966 - _POLLACTIVITYTASKQUEUERESPONSE._serialized_end = 10973 - _RECORDACTIVITYTASKHEARTBEATREQUEST._serialized_start = 10976 - _RECORDACTIVITYTASKHEARTBEATREQUEST._serialized_end = 11120 - _RECORDACTIVITYTASKHEARTBEATRESPONSE._serialized_start = 11122 - _RECORDACTIVITYTASKHEARTBEATRESPONSE._serialized_end = 11234 - _RECORDACTIVITYTASKHEARTBEATBYIDREQUEST._serialized_start = 11237 - _RECORDACTIVITYTASKHEARTBEATBYIDREQUEST._serialized_end = 11423 - _RECORDACTIVITYTASKHEARTBEATBYIDRESPONSE._serialized_start = 11425 - _RECORDACTIVITYTASKHEARTBEATBYIDRESPONSE._serialized_end = 11541 - _RESPONDACTIVITYTASKCOMPLETEDREQUEST._serialized_start = 11544 - _RESPONDACTIVITYTASKCOMPLETEDREQUEST._serialized_end = 11905 - _RESPONDACTIVITYTASKCOMPLETEDRESPONSE._serialized_start = 11907 - _RESPONDACTIVITYTASKCOMPLETEDRESPONSE._serialized_end = 11945 - _RESPONDACTIVITYTASKCOMPLETEDBYIDREQUEST._serialized_start = 11948 - _RESPONDACTIVITYTASKCOMPLETEDBYIDREQUEST._serialized_end = 12134 - _RESPONDACTIVITYTASKCOMPLETEDBYIDRESPONSE._serialized_start = 12136 - _RESPONDACTIVITYTASKCOMPLETEDBYIDRESPONSE._serialized_end = 12178 - _RESPONDACTIVITYTASKFAILEDREQUEST._serialized_start = 12181 - _RESPONDACTIVITYTASKFAILEDREQUEST._serialized_end = 12606 - _RESPONDACTIVITYTASKFAILEDRESPONSE._serialized_start = 12608 - _RESPONDACTIVITYTASKFAILEDRESPONSE._serialized_end = 12695 - _RESPONDACTIVITYTASKFAILEDBYIDREQUEST._serialized_start = 12698 - _RESPONDACTIVITYTASKFAILEDBYIDREQUEST._serialized_end = 12948 - _RESPONDACTIVITYTASKFAILEDBYIDRESPONSE._serialized_start = 12950 - _RESPONDACTIVITYTASKFAILEDBYIDRESPONSE._serialized_end = 13041 - _RESPONDACTIVITYTASKCANCELEDREQUEST._serialized_start = 13044 - _RESPONDACTIVITYTASKCANCELEDREQUEST._serialized_end = 13405 - _RESPONDACTIVITYTASKCANCELEDRESPONSE._serialized_start = 13407 - _RESPONDACTIVITYTASKCANCELEDRESPONSE._serialized_end = 13444 - _RESPONDACTIVITYTASKCANCELEDBYIDREQUEST._serialized_start = 13447 - _RESPONDACTIVITYTASKCANCELEDBYIDREQUEST._serialized_end = 13714 - _RESPONDACTIVITYTASKCANCELEDBYIDRESPONSE._serialized_start = 13716 - _RESPONDACTIVITYTASKCANCELEDBYIDRESPONSE._serialized_end = 13757 - _REQUESTCANCELWORKFLOWEXECUTIONREQUEST._serialized_start = 13760 - _REQUESTCANCELWORKFLOWEXECUTIONREQUEST._serialized_end = 14020 - _REQUESTCANCELWORKFLOWEXECUTIONRESPONSE._serialized_start = 14022 - _REQUESTCANCELWORKFLOWEXECUTIONRESPONSE._serialized_end = 14062 - _SIGNALWORKFLOWEXECUTIONREQUEST._serialized_start = 14065 - _SIGNALWORKFLOWEXECUTIONREQUEST._serialized_end = 14415 - _SIGNALWORKFLOWEXECUTIONRESPONSE._serialized_start = 14417 - _SIGNALWORKFLOWEXECUTIONRESPONSE._serialized_end = 14450 - _SIGNALWITHSTARTWORKFLOWEXECUTIONREQUEST._serialized_start = 14453 - _SIGNALWITHSTARTWORKFLOWEXECUTIONREQUEST._serialized_end = 15718 - _SIGNALWITHSTARTWORKFLOWEXECUTIONRESPONSE._serialized_start = 15720 - _SIGNALWITHSTARTWORKFLOWEXECUTIONRESPONSE._serialized_end = 15795 - _RESETWORKFLOWEXECUTIONREQUEST._serialized_start = 15798 - _RESETWORKFLOWEXECUTIONREQUEST._serialized_end = 16247 - _RESETWORKFLOWEXECUTIONRESPONSE._serialized_start = 16249 - _RESETWORKFLOWEXECUTIONRESPONSE._serialized_end = 16297 - _TERMINATEWORKFLOWEXECUTIONREQUEST._serialized_start = 16300 - _TERMINATEWORKFLOWEXECUTIONREQUEST._serialized_end = 16587 - _TERMINATEWORKFLOWEXECUTIONRESPONSE._serialized_start = 16589 - _TERMINATEWORKFLOWEXECUTIONRESPONSE._serialized_end = 16625 - _DELETEWORKFLOWEXECUTIONREQUEST._serialized_start = 16627 - _DELETEWORKFLOWEXECUTIONREQUEST._serialized_end = 16749 - _DELETEWORKFLOWEXECUTIONRESPONSE._serialized_start = 16751 - _DELETEWORKFLOWEXECUTIONRESPONSE._serialized_end = 16784 - _LISTOPENWORKFLOWEXECUTIONSREQUEST._serialized_start = 16787 - _LISTOPENWORKFLOWEXECUTIONSREQUEST._serialized_end = 17116 - _LISTOPENWORKFLOWEXECUTIONSRESPONSE._serialized_start = 17119 - _LISTOPENWORKFLOWEXECUTIONSRESPONSE._serialized_end = 17249 - _LISTCLOSEDWORKFLOWEXECUTIONSREQUEST._serialized_start = 17252 - _LISTCLOSEDWORKFLOWEXECUTIONSREQUEST._serialized_end = 17646 - _LISTCLOSEDWORKFLOWEXECUTIONSRESPONSE._serialized_start = 17649 - _LISTCLOSEDWORKFLOWEXECUTIONSRESPONSE._serialized_end = 17781 - _LISTWORKFLOWEXECUTIONSREQUEST._serialized_start = 17783 - _LISTWORKFLOWEXECUTIONSREQUEST._serialized_end = 17892 - _LISTWORKFLOWEXECUTIONSRESPONSE._serialized_start = 17894 - _LISTWORKFLOWEXECUTIONSRESPONSE._serialized_end = 18020 - _LISTARCHIVEDWORKFLOWEXECUTIONSREQUEST._serialized_start = 18022 - _LISTARCHIVEDWORKFLOWEXECUTIONSREQUEST._serialized_end = 18139 - _LISTARCHIVEDWORKFLOWEXECUTIONSRESPONSE._serialized_start = 18142 - _LISTARCHIVEDWORKFLOWEXECUTIONSRESPONSE._serialized_end = 18276 - _SCANWORKFLOWEXECUTIONSREQUEST._serialized_start = 18278 - _SCANWORKFLOWEXECUTIONSREQUEST._serialized_end = 18387 - _SCANWORKFLOWEXECUTIONSRESPONSE._serialized_start = 18389 - _SCANWORKFLOWEXECUTIONSRESPONSE._serialized_end = 18515 - _COUNTWORKFLOWEXECUTIONSREQUEST._serialized_start = 18517 - _COUNTWORKFLOWEXECUTIONSREQUEST._serialized_end = 18583 - _COUNTWORKFLOWEXECUTIONSRESPONSE._serialized_start = 18586 - _COUNTWORKFLOWEXECUTIONSRESPONSE._serialized_end = 18823 - _COUNTWORKFLOWEXECUTIONSRESPONSE_AGGREGATIONGROUP._serialized_start = 18735 - _COUNTWORKFLOWEXECUTIONSRESPONSE_AGGREGATIONGROUP._serialized_end = 18823 - _GETSEARCHATTRIBUTESREQUEST._serialized_start = 18825 - _GETSEARCHATTRIBUTESREQUEST._serialized_end = 18853 - _GETSEARCHATTRIBUTESRESPONSE._serialized_start = 18856 - _GETSEARCHATTRIBUTESRESPONSE._serialized_end = 19057 - _GETSEARCHATTRIBUTESRESPONSE_KEYSENTRY._serialized_start = 18973 - _GETSEARCHATTRIBUTESRESPONSE_KEYSENTRY._serialized_end = 19057 - _RESPONDQUERYTASKCOMPLETEDREQUEST._serialized_start = 19060 - _RESPONDQUERYTASKCOMPLETEDREQUEST._serialized_end = 19396 - _RESPONDQUERYTASKCOMPLETEDRESPONSE._serialized_start = 19398 - _RESPONDQUERYTASKCOMPLETEDRESPONSE._serialized_end = 19433 - _RESETSTICKYTASKQUEUEREQUEST._serialized_start = 19435 - _RESETSTICKYTASKQUEUEREQUEST._serialized_end = 19545 - _RESETSTICKYTASKQUEUERESPONSE._serialized_start = 19547 - _RESETSTICKYTASKQUEUERESPONSE._serialized_end = 19577 - _SHUTDOWNWORKERREQUEST._serialized_start = 19580 - _SHUTDOWNWORKERREQUEST._serialized_end = 19750 - _SHUTDOWNWORKERRESPONSE._serialized_start = 19752 - _SHUTDOWNWORKERRESPONSE._serialized_end = 19776 - _QUERYWORKFLOWREQUEST._serialized_start = 19779 - _QUERYWORKFLOWREQUEST._serialized_end = 20012 - _QUERYWORKFLOWRESPONSE._serialized_start = 20015 - _QUERYWORKFLOWRESPONSE._serialized_end = 20156 - _DESCRIBEWORKFLOWEXECUTIONREQUEST._serialized_start = 20158 - _DESCRIBEWORKFLOWEXECUTIONREQUEST._serialized_end = 20273 - _DESCRIBEWORKFLOWEXECUTIONRESPONSE._serialized_start = 20276 - _DESCRIBEWORKFLOWEXECUTIONRESPONSE._serialized_end = 20941 - _DESCRIBETASKQUEUEREQUEST._serialized_start = 20944 - _DESCRIBETASKQUEUEREQUEST._serialized_end = 21472 - _DESCRIBETASKQUEUERESPONSE._serialized_start = 21475 - _DESCRIBETASKQUEUERESPONSE._serialized_end = 22479 - _DESCRIBETASKQUEUERESPONSE_STATSBYPRIORITYKEYENTRY._serialized_start = 22159 - _DESCRIBETASKQUEUERESPONSE_STATSBYPRIORITYKEYENTRY._serialized_end = 22259 - _DESCRIBETASKQUEUERESPONSE_EFFECTIVERATELIMIT._serialized_start = 22261 - _DESCRIBETASKQUEUERESPONSE_EFFECTIVERATELIMIT._serialized_end = 22377 - _DESCRIBETASKQUEUERESPONSE_VERSIONSINFOENTRY._serialized_start = 22379 - _DESCRIBETASKQUEUERESPONSE_VERSIONSINFOENTRY._serialized_end = 22479 - _GETCLUSTERINFOREQUEST._serialized_start = 22481 - _GETCLUSTERINFOREQUEST._serialized_end = 22504 - _GETCLUSTERINFORESPONSE._serialized_start = 22507 - _GETCLUSTERINFORESPONSE._serialized_end = 22972 - _GETCLUSTERINFORESPONSE_SUPPORTEDCLIENTSENTRY._serialized_start = 22917 - _GETCLUSTERINFORESPONSE_SUPPORTEDCLIENTSENTRY._serialized_end = 22972 - _GETSYSTEMINFOREQUEST._serialized_start = 22974 - _GETSYSTEMINFOREQUEST._serialized_end = 22996 - _GETSYSTEMINFORESPONSE._serialized_start = 22999 - _GETSYSTEMINFORESPONSE._serialized_end = 23499 - _GETSYSTEMINFORESPONSE_CAPABILITIES._serialized_start = 23140 - _GETSYSTEMINFORESPONSE_CAPABILITIES._serialized_end = 23499 - _LISTTASKQUEUEPARTITIONSREQUEST._serialized_start = 23501 - _LISTTASKQUEUEPARTITIONSREQUEST._serialized_end = 23610 - _LISTTASKQUEUEPARTITIONSRESPONSE._serialized_start = 23613 - _LISTTASKQUEUEPARTITIONSRESPONSE._serialized_end = 23836 - _CREATESCHEDULEREQUEST._serialized_start = 23839 - _CREATESCHEDULEREQUEST._serialized_end = 24171 - _CREATESCHEDULERESPONSE._serialized_start = 24173 - _CREATESCHEDULERESPONSE._serialized_end = 24221 - _DESCRIBESCHEDULEREQUEST._serialized_start = 24223 - _DESCRIBESCHEDULEREQUEST._serialized_end = 24288 - _DESCRIBESCHEDULERESPONSE._serialized_start = 24291 - _DESCRIBESCHEDULERESPONSE._serialized_end = 24562 - _UPDATESCHEDULEREQUEST._serialized_start = 24565 - _UPDATESCHEDULEREQUEST._serialized_end = 24813 - _UPDATESCHEDULERESPONSE._serialized_start = 24815 - _UPDATESCHEDULERESPONSE._serialized_end = 24839 - _PATCHSCHEDULEREQUEST._serialized_start = 24842 - _PATCHSCHEDULEREQUEST._serialized_end = 24998 - _PATCHSCHEDULERESPONSE._serialized_start = 25000 - _PATCHSCHEDULERESPONSE._serialized_end = 25023 - _LISTSCHEDULEMATCHINGTIMESREQUEST._serialized_start = 25026 - _LISTSCHEDULEMATCHINGTIMESREQUEST._serialized_end = 25194 - _LISTSCHEDULEMATCHINGTIMESRESPONSE._serialized_start = 25196 - _LISTSCHEDULEMATCHINGTIMESRESPONSE._serialized_end = 25279 - _DELETESCHEDULEREQUEST._serialized_start = 25281 - _DELETESCHEDULEREQUEST._serialized_end = 25362 - _DELETESCHEDULERESPONSE._serialized_start = 25364 - _DELETESCHEDULERESPONSE._serialized_end = 25388 - _LISTSCHEDULESREQUEST._serialized_start = 25390 - _LISTSCHEDULESREQUEST._serialized_end = 25498 - _LISTSCHEDULESRESPONSE._serialized_start = 25500 - _LISTSCHEDULESRESPONSE._serialized_end = 25612 - _UPDATEWORKERBUILDIDCOMPATIBILITYREQUEST._serialized_start = 25615 - _UPDATEWORKERBUILDIDCOMPATIBILITYREQUEST._serialized_end = 26261 - _UPDATEWORKERBUILDIDCOMPATIBILITYREQUEST_ADDNEWCOMPATIBLEVERSION._serialized_start = 26062 + _REGISTERNAMESPACEREQUEST._serialized_start = 1530 + _REGISTERNAMESPACEREQUEST._serialized_end = 2178 + _REGISTERNAMESPACEREQUEST_DATAENTRY._serialized_start = 2135 + _REGISTERNAMESPACEREQUEST_DATAENTRY._serialized_end = 2178 + _REGISTERNAMESPACERESPONSE._serialized_start = 2180 + _REGISTERNAMESPACERESPONSE._serialized_end = 2207 + _LISTNAMESPACESREQUEST._serialized_start = 2210 + _LISTNAMESPACESREQUEST._serialized_end = 2347 + _LISTNAMESPACESRESPONSE._serialized_start = 2350 + _LISTNAMESPACESRESPONSE._serialized_end = 2479 + _DESCRIBENAMESPACEREQUEST._serialized_start = 2481 + _DESCRIBENAMESPACEREQUEST._serialized_end = 2538 + _DESCRIBENAMESPACERESPONSE._serialized_start = 2541 + _DESCRIBENAMESPACERESPONSE._serialized_end = 2905 + _UPDATENAMESPACEREQUEST._serialized_start = 2908 + _UPDATENAMESPACEREQUEST._serialized_end = 3243 + _UPDATENAMESPACERESPONSE._serialized_start = 3246 + _UPDATENAMESPACERESPONSE._serialized_end = 3537 + _DEPRECATENAMESPACEREQUEST._serialized_start = 3539 + _DEPRECATENAMESPACEREQUEST._serialized_end = 3609 + _DEPRECATENAMESPACERESPONSE._serialized_start = 3611 + _DEPRECATENAMESPACERESPONSE._serialized_end = 3639 + _STARTWORKFLOWEXECUTIONREQUEST._serialized_start = 3642 + _STARTWORKFLOWEXECUTIONREQUEST._serialized_end = 5185 + _STARTWORKFLOWEXECUTIONRESPONSE._serialized_start = 5188 + _STARTWORKFLOWEXECUTIONRESPONSE._serialized_end = 5454 + _GETWORKFLOWEXECUTIONHISTORYREQUEST._serialized_start = 5457 + _GETWORKFLOWEXECUTIONHISTORYREQUEST._serialized_end = 5755 + _GETWORKFLOWEXECUTIONHISTORYRESPONSE._serialized_start = 5758 + _GETWORKFLOWEXECUTIONHISTORYRESPONSE._serialized_end = 5944 + _GETWORKFLOWEXECUTIONHISTORYREVERSEREQUEST._serialized_start = 5947 + _GETWORKFLOWEXECUTIONHISTORYREVERSEREQUEST._serialized_end = 6123 + _GETWORKFLOWEXECUTIONHISTORYREVERSERESPONSE._serialized_start = 6125 + _GETWORKFLOWEXECUTIONHISTORYREVERSERESPONSE._serialized_end = 6245 + _POLLWORKFLOWTASKQUEUEREQUEST._serialized_start = 6248 + _POLLWORKFLOWTASKQUEUEREQUEST._serialized_end = 6642 + _POLLWORKFLOWTASKQUEUERESPONSE._serialized_start = 6645 + _POLLWORKFLOWTASKQUEUERESPONSE._serialized_end = 7558 + _POLLWORKFLOWTASKQUEUERESPONSE_QUERIESENTRY._serialized_start = 7474 + _POLLWORKFLOWTASKQUEUERESPONSE_QUERIESENTRY._serialized_end = 7558 + _RESPONDWORKFLOWTASKCOMPLETEDREQUEST._serialized_start = 7561 + _RESPONDWORKFLOWTASKCOMPLETEDREQUEST._serialized_end = 8766 + _RESPONDWORKFLOWTASKCOMPLETEDREQUEST_QUERYRESULTSENTRY._serialized_start = 8600 + _RESPONDWORKFLOWTASKCOMPLETEDREQUEST_QUERYRESULTSENTRY._serialized_end = 8695 + _RESPONDWORKFLOWTASKCOMPLETEDREQUEST_CAPABILITIES._serialized_start = 8697 + _RESPONDWORKFLOWTASKCOMPLETEDREQUEST_CAPABILITIES._serialized_end = 8766 + _RESPONDWORKFLOWTASKCOMPLETEDRESPONSE._serialized_start = 8769 + _RESPONDWORKFLOWTASKCOMPLETEDRESPONSE._serialized_end = 9014 + _RESPONDWORKFLOWTASKFAILEDREQUEST._serialized_start = 9017 + _RESPONDWORKFLOWTASKFAILEDREQUEST._serialized_end = 9521 + _RESPONDWORKFLOWTASKFAILEDRESPONSE._serialized_start = 9523 + _RESPONDWORKFLOWTASKFAILEDRESPONSE._serialized_end = 9558 + _POLLACTIVITYTASKQUEUEREQUEST._serialized_start = 9561 + _POLLACTIVITYTASKQUEUEREQUEST._serialized_end = 10001 + _POLLACTIVITYTASKQUEUERESPONSE._serialized_start = 10004 + _POLLACTIVITYTASKQUEUERESPONSE._serialized_end = 11011 + _RECORDACTIVITYTASKHEARTBEATREQUEST._serialized_start = 11014 + _RECORDACTIVITYTASKHEARTBEATREQUEST._serialized_end = 11158 + _RECORDACTIVITYTASKHEARTBEATRESPONSE._serialized_start = 11160 + _RECORDACTIVITYTASKHEARTBEATRESPONSE._serialized_end = 11272 + _RECORDACTIVITYTASKHEARTBEATBYIDREQUEST._serialized_start = 11275 + _RECORDACTIVITYTASKHEARTBEATBYIDREQUEST._serialized_end = 11461 + _RECORDACTIVITYTASKHEARTBEATBYIDRESPONSE._serialized_start = 11463 + _RECORDACTIVITYTASKHEARTBEATBYIDRESPONSE._serialized_end = 11579 + _RESPONDACTIVITYTASKCOMPLETEDREQUEST._serialized_start = 11582 + _RESPONDACTIVITYTASKCOMPLETEDREQUEST._serialized_end = 11943 + _RESPONDACTIVITYTASKCOMPLETEDRESPONSE._serialized_start = 11945 + _RESPONDACTIVITYTASKCOMPLETEDRESPONSE._serialized_end = 11983 + _RESPONDACTIVITYTASKCOMPLETEDBYIDREQUEST._serialized_start = 11986 + _RESPONDACTIVITYTASKCOMPLETEDBYIDREQUEST._serialized_end = 12172 + _RESPONDACTIVITYTASKCOMPLETEDBYIDRESPONSE._serialized_start = 12174 + _RESPONDACTIVITYTASKCOMPLETEDBYIDRESPONSE._serialized_end = 12216 + _RESPONDACTIVITYTASKFAILEDREQUEST._serialized_start = 12219 + _RESPONDACTIVITYTASKFAILEDREQUEST._serialized_end = 12644 + _RESPONDACTIVITYTASKFAILEDRESPONSE._serialized_start = 12646 + _RESPONDACTIVITYTASKFAILEDRESPONSE._serialized_end = 12733 + _RESPONDACTIVITYTASKFAILEDBYIDREQUEST._serialized_start = 12736 + _RESPONDACTIVITYTASKFAILEDBYIDREQUEST._serialized_end = 12986 + _RESPONDACTIVITYTASKFAILEDBYIDRESPONSE._serialized_start = 12988 + _RESPONDACTIVITYTASKFAILEDBYIDRESPONSE._serialized_end = 13079 + _RESPONDACTIVITYTASKCANCELEDREQUEST._serialized_start = 13082 + _RESPONDACTIVITYTASKCANCELEDREQUEST._serialized_end = 13443 + _RESPONDACTIVITYTASKCANCELEDRESPONSE._serialized_start = 13445 + _RESPONDACTIVITYTASKCANCELEDRESPONSE._serialized_end = 13482 + _RESPONDACTIVITYTASKCANCELEDBYIDREQUEST._serialized_start = 13485 + _RESPONDACTIVITYTASKCANCELEDBYIDREQUEST._serialized_end = 13752 + _RESPONDACTIVITYTASKCANCELEDBYIDRESPONSE._serialized_start = 13754 + _RESPONDACTIVITYTASKCANCELEDBYIDRESPONSE._serialized_end = 13795 + _REQUESTCANCELWORKFLOWEXECUTIONREQUEST._serialized_start = 13798 + _REQUESTCANCELWORKFLOWEXECUTIONREQUEST._serialized_end = 14058 + _REQUESTCANCELWORKFLOWEXECUTIONRESPONSE._serialized_start = 14060 + _REQUESTCANCELWORKFLOWEXECUTIONRESPONSE._serialized_end = 14100 + _SIGNALWORKFLOWEXECUTIONREQUEST._serialized_start = 14103 + _SIGNALWORKFLOWEXECUTIONREQUEST._serialized_end = 14453 + _SIGNALWORKFLOWEXECUTIONRESPONSE._serialized_start = 14455 + _SIGNALWORKFLOWEXECUTIONRESPONSE._serialized_end = 14488 + _SIGNALWITHSTARTWORKFLOWEXECUTIONREQUEST._serialized_start = 14491 + _SIGNALWITHSTARTWORKFLOWEXECUTIONREQUEST._serialized_end = 15756 + _SIGNALWITHSTARTWORKFLOWEXECUTIONRESPONSE._serialized_start = 15758 + _SIGNALWITHSTARTWORKFLOWEXECUTIONRESPONSE._serialized_end = 15833 + _RESETWORKFLOWEXECUTIONREQUEST._serialized_start = 15836 + _RESETWORKFLOWEXECUTIONREQUEST._serialized_end = 16285 + _RESETWORKFLOWEXECUTIONRESPONSE._serialized_start = 16287 + _RESETWORKFLOWEXECUTIONRESPONSE._serialized_end = 16335 + _TERMINATEWORKFLOWEXECUTIONREQUEST._serialized_start = 16338 + _TERMINATEWORKFLOWEXECUTIONREQUEST._serialized_end = 16625 + _TERMINATEWORKFLOWEXECUTIONRESPONSE._serialized_start = 16627 + _TERMINATEWORKFLOWEXECUTIONRESPONSE._serialized_end = 16663 + _DELETEWORKFLOWEXECUTIONREQUEST._serialized_start = 16665 + _DELETEWORKFLOWEXECUTIONREQUEST._serialized_end = 16787 + _DELETEWORKFLOWEXECUTIONRESPONSE._serialized_start = 16789 + _DELETEWORKFLOWEXECUTIONRESPONSE._serialized_end = 16822 + _LISTOPENWORKFLOWEXECUTIONSREQUEST._serialized_start = 16825 + _LISTOPENWORKFLOWEXECUTIONSREQUEST._serialized_end = 17154 + _LISTOPENWORKFLOWEXECUTIONSRESPONSE._serialized_start = 17157 + _LISTOPENWORKFLOWEXECUTIONSRESPONSE._serialized_end = 17287 + _LISTCLOSEDWORKFLOWEXECUTIONSREQUEST._serialized_start = 17290 + _LISTCLOSEDWORKFLOWEXECUTIONSREQUEST._serialized_end = 17684 + _LISTCLOSEDWORKFLOWEXECUTIONSRESPONSE._serialized_start = 17687 + _LISTCLOSEDWORKFLOWEXECUTIONSRESPONSE._serialized_end = 17819 + _LISTWORKFLOWEXECUTIONSREQUEST._serialized_start = 17821 + _LISTWORKFLOWEXECUTIONSREQUEST._serialized_end = 17930 + _LISTWORKFLOWEXECUTIONSRESPONSE._serialized_start = 17932 + _LISTWORKFLOWEXECUTIONSRESPONSE._serialized_end = 18058 + _LISTARCHIVEDWORKFLOWEXECUTIONSREQUEST._serialized_start = 18060 + _LISTARCHIVEDWORKFLOWEXECUTIONSREQUEST._serialized_end = 18177 + _LISTARCHIVEDWORKFLOWEXECUTIONSRESPONSE._serialized_start = 18180 + _LISTARCHIVEDWORKFLOWEXECUTIONSRESPONSE._serialized_end = 18314 + _SCANWORKFLOWEXECUTIONSREQUEST._serialized_start = 18316 + _SCANWORKFLOWEXECUTIONSREQUEST._serialized_end = 18425 + _SCANWORKFLOWEXECUTIONSRESPONSE._serialized_start = 18427 + _SCANWORKFLOWEXECUTIONSRESPONSE._serialized_end = 18553 + _COUNTWORKFLOWEXECUTIONSREQUEST._serialized_start = 18555 + _COUNTWORKFLOWEXECUTIONSREQUEST._serialized_end = 18621 + _COUNTWORKFLOWEXECUTIONSRESPONSE._serialized_start = 18624 + _COUNTWORKFLOWEXECUTIONSRESPONSE._serialized_end = 18861 + _COUNTWORKFLOWEXECUTIONSRESPONSE_AGGREGATIONGROUP._serialized_start = 18773 + _COUNTWORKFLOWEXECUTIONSRESPONSE_AGGREGATIONGROUP._serialized_end = 18861 + _GETSEARCHATTRIBUTESREQUEST._serialized_start = 18863 + _GETSEARCHATTRIBUTESREQUEST._serialized_end = 18891 + _GETSEARCHATTRIBUTESRESPONSE._serialized_start = 18894 + _GETSEARCHATTRIBUTESRESPONSE._serialized_end = 19095 + _GETSEARCHATTRIBUTESRESPONSE_KEYSENTRY._serialized_start = 19011 + _GETSEARCHATTRIBUTESRESPONSE_KEYSENTRY._serialized_end = 19095 + _RESPONDQUERYTASKCOMPLETEDREQUEST._serialized_start = 19098 + _RESPONDQUERYTASKCOMPLETEDREQUEST._serialized_end = 19434 + _RESPONDQUERYTASKCOMPLETEDRESPONSE._serialized_start = 19436 + _RESPONDQUERYTASKCOMPLETEDRESPONSE._serialized_end = 19471 + _RESETSTICKYTASKQUEUEREQUEST._serialized_start = 19473 + _RESETSTICKYTASKQUEUEREQUEST._serialized_end = 19583 + _RESETSTICKYTASKQUEUERESPONSE._serialized_start = 19585 + _RESETSTICKYTASKQUEUERESPONSE._serialized_end = 19615 + _SHUTDOWNWORKERREQUEST._serialized_start = 19618 + _SHUTDOWNWORKERREQUEST._serialized_end = 19788 + _SHUTDOWNWORKERRESPONSE._serialized_start = 19790 + _SHUTDOWNWORKERRESPONSE._serialized_end = 19814 + _QUERYWORKFLOWREQUEST._serialized_start = 19817 + _QUERYWORKFLOWREQUEST._serialized_end = 20050 + _QUERYWORKFLOWRESPONSE._serialized_start = 20053 + _QUERYWORKFLOWRESPONSE._serialized_end = 20194 + _DESCRIBEWORKFLOWEXECUTIONREQUEST._serialized_start = 20196 + _DESCRIBEWORKFLOWEXECUTIONREQUEST._serialized_end = 20311 + _DESCRIBEWORKFLOWEXECUTIONRESPONSE._serialized_start = 20314 + _DESCRIBEWORKFLOWEXECUTIONRESPONSE._serialized_end = 20979 + _DESCRIBETASKQUEUEREQUEST._serialized_start = 20982 + _DESCRIBETASKQUEUEREQUEST._serialized_end = 21510 + _DESCRIBETASKQUEUERESPONSE._serialized_start = 21513 + _DESCRIBETASKQUEUERESPONSE._serialized_end = 22517 + _DESCRIBETASKQUEUERESPONSE_STATSBYPRIORITYKEYENTRY._serialized_start = 22197 + _DESCRIBETASKQUEUERESPONSE_STATSBYPRIORITYKEYENTRY._serialized_end = 22297 + _DESCRIBETASKQUEUERESPONSE_EFFECTIVERATELIMIT._serialized_start = 22299 + _DESCRIBETASKQUEUERESPONSE_EFFECTIVERATELIMIT._serialized_end = 22415 + _DESCRIBETASKQUEUERESPONSE_VERSIONSINFOENTRY._serialized_start = 22417 + _DESCRIBETASKQUEUERESPONSE_VERSIONSINFOENTRY._serialized_end = 22517 + _GETCLUSTERINFOREQUEST._serialized_start = 22519 + _GETCLUSTERINFOREQUEST._serialized_end = 22542 + _GETCLUSTERINFORESPONSE._serialized_start = 22545 + _GETCLUSTERINFORESPONSE._serialized_end = 23010 + _GETCLUSTERINFORESPONSE_SUPPORTEDCLIENTSENTRY._serialized_start = 22955 + _GETCLUSTERINFORESPONSE_SUPPORTEDCLIENTSENTRY._serialized_end = 23010 + _GETSYSTEMINFOREQUEST._serialized_start = 23012 + _GETSYSTEMINFOREQUEST._serialized_end = 23034 + _GETSYSTEMINFORESPONSE._serialized_start = 23037 + _GETSYSTEMINFORESPONSE._serialized_end = 23537 + _GETSYSTEMINFORESPONSE_CAPABILITIES._serialized_start = 23178 + _GETSYSTEMINFORESPONSE_CAPABILITIES._serialized_end = 23537 + _LISTTASKQUEUEPARTITIONSREQUEST._serialized_start = 23539 + _LISTTASKQUEUEPARTITIONSREQUEST._serialized_end = 23648 + _LISTTASKQUEUEPARTITIONSRESPONSE._serialized_start = 23651 + _LISTTASKQUEUEPARTITIONSRESPONSE._serialized_end = 23874 + _CREATESCHEDULEREQUEST._serialized_start = 23877 + _CREATESCHEDULEREQUEST._serialized_end = 24209 + _CREATESCHEDULERESPONSE._serialized_start = 24211 + _CREATESCHEDULERESPONSE._serialized_end = 24259 + _DESCRIBESCHEDULEREQUEST._serialized_start = 24261 + _DESCRIBESCHEDULEREQUEST._serialized_end = 24326 + _DESCRIBESCHEDULERESPONSE._serialized_start = 24329 + _DESCRIBESCHEDULERESPONSE._serialized_end = 24600 + _UPDATESCHEDULEREQUEST._serialized_start = 24603 + _UPDATESCHEDULEREQUEST._serialized_end = 24851 + _UPDATESCHEDULERESPONSE._serialized_start = 24853 + _UPDATESCHEDULERESPONSE._serialized_end = 24877 + _PATCHSCHEDULEREQUEST._serialized_start = 24880 + _PATCHSCHEDULEREQUEST._serialized_end = 25036 + _PATCHSCHEDULERESPONSE._serialized_start = 25038 + _PATCHSCHEDULERESPONSE._serialized_end = 25061 + _LISTSCHEDULEMATCHINGTIMESREQUEST._serialized_start = 25064 + _LISTSCHEDULEMATCHINGTIMESREQUEST._serialized_end = 25232 + _LISTSCHEDULEMATCHINGTIMESRESPONSE._serialized_start = 25234 + _LISTSCHEDULEMATCHINGTIMESRESPONSE._serialized_end = 25317 + _DELETESCHEDULEREQUEST._serialized_start = 25319 + _DELETESCHEDULEREQUEST._serialized_end = 25400 + _DELETESCHEDULERESPONSE._serialized_start = 25402 + _DELETESCHEDULERESPONSE._serialized_end = 25426 + _LISTSCHEDULESREQUEST._serialized_start = 25428 + _LISTSCHEDULESREQUEST._serialized_end = 25536 + _LISTSCHEDULESRESPONSE._serialized_start = 25538 + _LISTSCHEDULESRESPONSE._serialized_end = 25650 + _UPDATEWORKERBUILDIDCOMPATIBILITYREQUEST._serialized_start = 25653 + _UPDATEWORKERBUILDIDCOMPATIBILITYREQUEST._serialized_end = 26299 + _UPDATEWORKERBUILDIDCOMPATIBILITYREQUEST_ADDNEWCOMPATIBLEVERSION._serialized_start = 26100 _UPDATEWORKERBUILDIDCOMPATIBILITYREQUEST_ADDNEWCOMPATIBLEVERSION._serialized_end = ( - 26173 + 26211 ) - _UPDATEWORKERBUILDIDCOMPATIBILITYREQUEST_MERGESETS._serialized_start = 26175 - _UPDATEWORKERBUILDIDCOMPATIBILITYREQUEST_MERGESETS._serialized_end = 26248 - _UPDATEWORKERBUILDIDCOMPATIBILITYRESPONSE._serialized_start = 26263 - _UPDATEWORKERBUILDIDCOMPATIBILITYRESPONSE._serialized_end = 26327 - _GETWORKERBUILDIDCOMPATIBILITYREQUEST._serialized_start = 26329 - _GETWORKERBUILDIDCOMPATIBILITYREQUEST._serialized_end = 26424 - _GETWORKERBUILDIDCOMPATIBILITYRESPONSE._serialized_start = 26426 - _GETWORKERBUILDIDCOMPATIBILITYRESPONSE._serialized_end = 26542 - _UPDATEWORKERVERSIONINGRULESREQUEST._serialized_start = 26545 - _UPDATEWORKERVERSIONINGRULESREQUEST._serialized_end = 28262 - _UPDATEWORKERVERSIONINGRULESREQUEST_INSERTBUILDIDASSIGNMENTRULE._serialized_start = 27597 + _UPDATEWORKERBUILDIDCOMPATIBILITYREQUEST_MERGESETS._serialized_start = 26213 + _UPDATEWORKERBUILDIDCOMPATIBILITYREQUEST_MERGESETS._serialized_end = 26286 + _UPDATEWORKERBUILDIDCOMPATIBILITYRESPONSE._serialized_start = 26301 + _UPDATEWORKERBUILDIDCOMPATIBILITYRESPONSE._serialized_end = 26365 + _GETWORKERBUILDIDCOMPATIBILITYREQUEST._serialized_start = 26367 + _GETWORKERBUILDIDCOMPATIBILITYREQUEST._serialized_end = 26462 + _GETWORKERBUILDIDCOMPATIBILITYRESPONSE._serialized_start = 26464 + _GETWORKERBUILDIDCOMPATIBILITYRESPONSE._serialized_end = 26580 + _UPDATEWORKERVERSIONINGRULESREQUEST._serialized_start = 26583 + _UPDATEWORKERVERSIONINGRULESREQUEST._serialized_end = 28300 + _UPDATEWORKERVERSIONINGRULESREQUEST_INSERTBUILDIDASSIGNMENTRULE._serialized_start = 27635 _UPDATEWORKERVERSIONINGRULESREQUEST_INSERTBUILDIDASSIGNMENTRULE._serialized_end = ( - 27710 + 27748 ) - _UPDATEWORKERVERSIONINGRULESREQUEST_REPLACEBUILDIDASSIGNMENTRULE._serialized_start = 27713 + _UPDATEWORKERVERSIONINGRULESREQUEST_REPLACEBUILDIDASSIGNMENTRULE._serialized_start = 27751 _UPDATEWORKERVERSIONINGRULESREQUEST_REPLACEBUILDIDASSIGNMENTRULE._serialized_end = ( - 27842 + 27880 ) - _UPDATEWORKERVERSIONINGRULESREQUEST_DELETEBUILDIDASSIGNMENTRULE._serialized_start = 27844 + _UPDATEWORKERVERSIONINGRULESREQUEST_DELETEBUILDIDASSIGNMENTRULE._serialized_start = 27882 _UPDATEWORKERVERSIONINGRULESREQUEST_DELETEBUILDIDASSIGNMENTRULE._serialized_end = ( - 27908 + 27946 ) - _UPDATEWORKERVERSIONINGRULESREQUEST_ADDCOMPATIBLEBUILDIDREDIRECTRULE._serialized_start = 27910 - _UPDATEWORKERVERSIONINGRULESREQUEST_ADDCOMPATIBLEBUILDIDREDIRECTRULE._serialized_end = 28016 - _UPDATEWORKERVERSIONINGRULESREQUEST_REPLACECOMPATIBLEBUILDIDREDIRECTRULE._serialized_start = 28018 - _UPDATEWORKERVERSIONINGRULESREQUEST_REPLACECOMPATIBLEBUILDIDREDIRECTRULE._serialized_end = 28128 - _UPDATEWORKERVERSIONINGRULESREQUEST_DELETECOMPATIBLEBUILDIDREDIRECTRULE._serialized_start = 28130 - _UPDATEWORKERVERSIONINGRULESREQUEST_DELETECOMPATIBLEBUILDIDREDIRECTRULE._serialized_end = 28192 - _UPDATEWORKERVERSIONINGRULESREQUEST_COMMITBUILDID._serialized_start = 28194 - _UPDATEWORKERVERSIONINGRULESREQUEST_COMMITBUILDID._serialized_end = 28249 - _UPDATEWORKERVERSIONINGRULESRESPONSE._serialized_start = 28265 - _UPDATEWORKERVERSIONINGRULESRESPONSE._serialized_end = 28517 - _GETWORKERVERSIONINGRULESREQUEST._serialized_start = 28519 - _GETWORKERVERSIONINGRULESREQUEST._serialized_end = 28591 - _GETWORKERVERSIONINGRULESRESPONSE._serialized_start = 28594 - _GETWORKERVERSIONINGRULESRESPONSE._serialized_end = 28843 - _GETWORKERTASKREACHABILITYREQUEST._serialized_start = 28846 - _GETWORKERTASKREACHABILITYREQUEST._serialized_end = 29002 - _GETWORKERTASKREACHABILITYRESPONSE._serialized_start = 29004 - _GETWORKERTASKREACHABILITYRESPONSE._serialized_end = 29118 - _UPDATEWORKFLOWEXECUTIONREQUEST._serialized_start = 29121 - _UPDATEWORKFLOWEXECUTIONREQUEST._serialized_end = 29382 - _UPDATEWORKFLOWEXECUTIONRESPONSE._serialized_start = 29385 - _UPDATEWORKFLOWEXECUTIONRESPONSE._serialized_end = 29600 - _STARTBATCHOPERATIONREQUEST._serialized_start = 29603 - _STARTBATCHOPERATIONREQUEST._serialized_end = 30615 - _STARTBATCHOPERATIONRESPONSE._serialized_start = 30617 - _STARTBATCHOPERATIONRESPONSE._serialized_end = 30646 - _STOPBATCHOPERATIONREQUEST._serialized_start = 30648 - _STOPBATCHOPERATIONREQUEST._serialized_end = 30744 - _STOPBATCHOPERATIONRESPONSE._serialized_start = 30746 - _STOPBATCHOPERATIONRESPONSE._serialized_end = 30774 - _DESCRIBEBATCHOPERATIONREQUEST._serialized_start = 30776 - _DESCRIBEBATCHOPERATIONREQUEST._serialized_end = 30842 - _DESCRIBEBATCHOPERATIONRESPONSE._serialized_start = 30845 - _DESCRIBEBATCHOPERATIONRESPONSE._serialized_end = 31247 - _LISTBATCHOPERATIONSREQUEST._serialized_start = 31249 - _LISTBATCHOPERATIONSREQUEST._serialized_end = 31340 - _LISTBATCHOPERATIONSRESPONSE._serialized_start = 31342 - _LISTBATCHOPERATIONSRESPONSE._serialized_end = 31463 - _POLLWORKFLOWEXECUTIONUPDATEREQUEST._serialized_start = 31466 - _POLLWORKFLOWEXECUTIONUPDATEREQUEST._serialized_end = 31651 - _POLLWORKFLOWEXECUTIONUPDATERESPONSE._serialized_start = 31654 - _POLLWORKFLOWEXECUTIONUPDATERESPONSE._serialized_end = 31873 - _POLLNEXUSTASKQUEUEREQUEST._serialized_start = 31876 - _POLLNEXUSTASKQUEUEREQUEST._serialized_end = 32238 - _POLLNEXUSTASKQUEUERESPONSE._serialized_start = 32241 - _POLLNEXUSTASKQUEUERESPONSE._serialized_end = 32421 - _RESPONDNEXUSTASKCOMPLETEDREQUEST._serialized_start = 32424 - _RESPONDNEXUSTASKCOMPLETEDREQUEST._serialized_end = 32566 - _RESPONDNEXUSTASKCOMPLETEDRESPONSE._serialized_start = 32568 - _RESPONDNEXUSTASKCOMPLETEDRESPONSE._serialized_end = 32603 - _RESPONDNEXUSTASKFAILEDREQUEST._serialized_start = 32606 - _RESPONDNEXUSTASKFAILEDREQUEST._serialized_end = 32746 - _RESPONDNEXUSTASKFAILEDRESPONSE._serialized_start = 32748 - _RESPONDNEXUSTASKFAILEDRESPONSE._serialized_end = 32780 - _EXECUTEMULTIOPERATIONREQUEST._serialized_start = 32783 - _EXECUTEMULTIOPERATIONREQUEST._serialized_end = 33134 - _EXECUTEMULTIOPERATIONREQUEST_OPERATION._serialized_start = 32928 - _EXECUTEMULTIOPERATIONREQUEST_OPERATION._serialized_end = 33134 - _EXECUTEMULTIOPERATIONRESPONSE._serialized_start = 33137 - _EXECUTEMULTIOPERATIONRESPONSE._serialized_end = 33469 - _EXECUTEMULTIOPERATIONRESPONSE_RESPONSE._serialized_start = 33263 - _EXECUTEMULTIOPERATIONRESPONSE_RESPONSE._serialized_end = 33469 - _UPDATEACTIVITYOPTIONSREQUEST._serialized_start = 33472 - _UPDATEACTIVITYOPTIONSREQUEST._serialized_end = 33808 - _UPDATEACTIVITYOPTIONSRESPONSE._serialized_start = 33810 - _UPDATEACTIVITYOPTIONSRESPONSE._serialized_end = 33910 - _PAUSEACTIVITYREQUEST._serialized_start = 33913 - _PAUSEACTIVITYREQUEST._serialized_end = 34092 - _PAUSEACTIVITYRESPONSE._serialized_start = 34094 - _PAUSEACTIVITYRESPONSE._serialized_end = 34117 - _UNPAUSEACTIVITYREQUEST._serialized_start = 34120 - _UNPAUSEACTIVITYREQUEST._serialized_end = 34400 - _UNPAUSEACTIVITYRESPONSE._serialized_start = 34402 - _UNPAUSEACTIVITYRESPONSE._serialized_end = 34427 - _RESETACTIVITYREQUEST._serialized_start = 34430 - _RESETACTIVITYREQUEST._serialized_end = 34737 - _RESETACTIVITYRESPONSE._serialized_start = 34739 - _RESETACTIVITYRESPONSE._serialized_end = 34762 - _UPDATEWORKFLOWEXECUTIONOPTIONSREQUEST._serialized_start = 34765 - _UPDATEWORKFLOWEXECUTIONOPTIONSREQUEST._serialized_end = 35031 - _UPDATEWORKFLOWEXECUTIONOPTIONSRESPONSE._serialized_start = 35034 - _UPDATEWORKFLOWEXECUTIONOPTIONSRESPONSE._serialized_end = 35162 - _DESCRIBEDEPLOYMENTREQUEST._serialized_start = 35164 - _DESCRIBEDEPLOYMENTREQUEST._serialized_end = 35270 - _DESCRIBEDEPLOYMENTRESPONSE._serialized_start = 35272 - _DESCRIBEDEPLOYMENTRESPONSE._serialized_end = 35369 - _DESCRIBEWORKERDEPLOYMENTVERSIONREQUEST._serialized_start = 35372 - _DESCRIBEWORKERDEPLOYMENTVERSIONREQUEST._serialized_end = 35566 - _DESCRIBEWORKERDEPLOYMENTVERSIONRESPONSE._serialized_start = 35569 - _DESCRIBEWORKERDEPLOYMENTVERSIONRESPONSE._serialized_end = 36221 - _DESCRIBEWORKERDEPLOYMENTVERSIONRESPONSE_VERSIONTASKQUEUE._serialized_start = 35830 - _DESCRIBEWORKERDEPLOYMENTVERSIONRESPONSE_VERSIONTASKQUEUE._serialized_end = 36221 - _DESCRIBEWORKERDEPLOYMENTVERSIONRESPONSE_VERSIONTASKQUEUE_STATSBYPRIORITYKEYENTRY._serialized_start = 22159 - _DESCRIBEWORKERDEPLOYMENTVERSIONRESPONSE_VERSIONTASKQUEUE_STATSBYPRIORITYKEYENTRY._serialized_end = 22259 - _DESCRIBEWORKERDEPLOYMENTREQUEST._serialized_start = 36223 - _DESCRIBEWORKERDEPLOYMENTREQUEST._serialized_end = 36300 - _DESCRIBEWORKERDEPLOYMENTRESPONSE._serialized_start = 36303 - _DESCRIBEWORKERDEPLOYMENTRESPONSE._serialized_end = 36443 - _LISTDEPLOYMENTSREQUEST._serialized_start = 36445 - _LISTDEPLOYMENTSREQUEST._serialized_end = 36553 - _LISTDEPLOYMENTSRESPONSE._serialized_start = 36555 - _LISTDEPLOYMENTSRESPONSE._serialized_end = 36674 - _SETCURRENTDEPLOYMENTREQUEST._serialized_start = 36677 - _SETCURRENTDEPLOYMENTREQUEST._serialized_end = 36882 - _SETCURRENTDEPLOYMENTRESPONSE._serialized_start = 36885 - _SETCURRENTDEPLOYMENTRESPONSE._serialized_end = 37070 - _SETWORKERDEPLOYMENTCURRENTVERSIONREQUEST._serialized_start = 37073 - _SETWORKERDEPLOYMENTCURRENTVERSIONREQUEST._serialized_end = 37302 - _SETWORKERDEPLOYMENTCURRENTVERSIONRESPONSE._serialized_start = 37305 - _SETWORKERDEPLOYMENTCURRENTVERSIONRESPONSE._serialized_end = 37492 - _SETWORKERDEPLOYMENTRAMPINGVERSIONREQUEST._serialized_start = 37495 - _SETWORKERDEPLOYMENTRAMPINGVERSIONREQUEST._serialized_end = 37744 - _SETWORKERDEPLOYMENTRAMPINGVERSIONRESPONSE._serialized_start = 37747 - _SETWORKERDEPLOYMENTRAMPINGVERSIONRESPONSE._serialized_end = 37963 - _LISTWORKERDEPLOYMENTSREQUEST._serialized_start = 37965 - _LISTWORKERDEPLOYMENTSREQUEST._serialized_end = 38058 - _LISTWORKERDEPLOYMENTSRESPONSE._serialized_start = 38061 - _LISTWORKERDEPLOYMENTSRESPONSE._serialized_end = 38732 - _LISTWORKERDEPLOYMENTSRESPONSE_WORKERDEPLOYMENTSUMMARY._serialized_start = 38236 - _LISTWORKERDEPLOYMENTSRESPONSE_WORKERDEPLOYMENTSUMMARY._serialized_end = 38732 - _DELETEWORKERDEPLOYMENTVERSIONREQUEST._serialized_start = 38735 - _DELETEWORKERDEPLOYMENTVERSIONREQUEST._serialized_end = 38935 - _DELETEWORKERDEPLOYMENTVERSIONRESPONSE._serialized_start = 38937 - _DELETEWORKERDEPLOYMENTVERSIONRESPONSE._serialized_end = 38976 - _DELETEWORKERDEPLOYMENTREQUEST._serialized_start = 38978 - _DELETEWORKERDEPLOYMENTREQUEST._serialized_end = 39071 - _DELETEWORKERDEPLOYMENTRESPONSE._serialized_start = 39073 - _DELETEWORKERDEPLOYMENTRESPONSE._serialized_end = 39105 - _UPDATEWORKERDEPLOYMENTVERSIONMETADATAREQUEST._serialized_start = 39108 - _UPDATEWORKERDEPLOYMENTVERSIONMETADATAREQUEST._serialized_end = 39526 - _UPDATEWORKERDEPLOYMENTVERSIONMETADATAREQUEST_UPSERTENTRIESENTRY._serialized_start = 39441 + _UPDATEWORKERVERSIONINGRULESREQUEST_ADDCOMPATIBLEBUILDIDREDIRECTRULE._serialized_start = 27948 + _UPDATEWORKERVERSIONINGRULESREQUEST_ADDCOMPATIBLEBUILDIDREDIRECTRULE._serialized_end = 28054 + _UPDATEWORKERVERSIONINGRULESREQUEST_REPLACECOMPATIBLEBUILDIDREDIRECTRULE._serialized_start = 28056 + _UPDATEWORKERVERSIONINGRULESREQUEST_REPLACECOMPATIBLEBUILDIDREDIRECTRULE._serialized_end = 28166 + _UPDATEWORKERVERSIONINGRULESREQUEST_DELETECOMPATIBLEBUILDIDREDIRECTRULE._serialized_start = 28168 + _UPDATEWORKERVERSIONINGRULESREQUEST_DELETECOMPATIBLEBUILDIDREDIRECTRULE._serialized_end = 28230 + _UPDATEWORKERVERSIONINGRULESREQUEST_COMMITBUILDID._serialized_start = 28232 + _UPDATEWORKERVERSIONINGRULESREQUEST_COMMITBUILDID._serialized_end = 28287 + _UPDATEWORKERVERSIONINGRULESRESPONSE._serialized_start = 28303 + _UPDATEWORKERVERSIONINGRULESRESPONSE._serialized_end = 28555 + _GETWORKERVERSIONINGRULESREQUEST._serialized_start = 28557 + _GETWORKERVERSIONINGRULESREQUEST._serialized_end = 28629 + _GETWORKERVERSIONINGRULESRESPONSE._serialized_start = 28632 + _GETWORKERVERSIONINGRULESRESPONSE._serialized_end = 28881 + _GETWORKERTASKREACHABILITYREQUEST._serialized_start = 28884 + _GETWORKERTASKREACHABILITYREQUEST._serialized_end = 29040 + _GETWORKERTASKREACHABILITYRESPONSE._serialized_start = 29042 + _GETWORKERTASKREACHABILITYRESPONSE._serialized_end = 29156 + _UPDATEWORKFLOWEXECUTIONREQUEST._serialized_start = 29159 + _UPDATEWORKFLOWEXECUTIONREQUEST._serialized_end = 29420 + _UPDATEWORKFLOWEXECUTIONRESPONSE._serialized_start = 29423 + _UPDATEWORKFLOWEXECUTIONRESPONSE._serialized_end = 29638 + _STARTBATCHOPERATIONREQUEST._serialized_start = 29641 + _STARTBATCHOPERATIONREQUEST._serialized_end = 30653 + _STARTBATCHOPERATIONRESPONSE._serialized_start = 30655 + _STARTBATCHOPERATIONRESPONSE._serialized_end = 30684 + _STOPBATCHOPERATIONREQUEST._serialized_start = 30686 + _STOPBATCHOPERATIONREQUEST._serialized_end = 30782 + _STOPBATCHOPERATIONRESPONSE._serialized_start = 30784 + _STOPBATCHOPERATIONRESPONSE._serialized_end = 30812 + _DESCRIBEBATCHOPERATIONREQUEST._serialized_start = 30814 + _DESCRIBEBATCHOPERATIONREQUEST._serialized_end = 30880 + _DESCRIBEBATCHOPERATIONRESPONSE._serialized_start = 30883 + _DESCRIBEBATCHOPERATIONRESPONSE._serialized_end = 31285 + _LISTBATCHOPERATIONSREQUEST._serialized_start = 31287 + _LISTBATCHOPERATIONSREQUEST._serialized_end = 31378 + _LISTBATCHOPERATIONSRESPONSE._serialized_start = 31380 + _LISTBATCHOPERATIONSRESPONSE._serialized_end = 31501 + _POLLWORKFLOWEXECUTIONUPDATEREQUEST._serialized_start = 31504 + _POLLWORKFLOWEXECUTIONUPDATEREQUEST._serialized_end = 31689 + _POLLWORKFLOWEXECUTIONUPDATERESPONSE._serialized_start = 31692 + _POLLWORKFLOWEXECUTIONUPDATERESPONSE._serialized_end = 31911 + _POLLNEXUSTASKQUEUEREQUEST._serialized_start = 31914 + _POLLNEXUSTASKQUEUEREQUEST._serialized_end = 32276 + _POLLNEXUSTASKQUEUERESPONSE._serialized_start = 32279 + _POLLNEXUSTASKQUEUERESPONSE._serialized_end = 32459 + _RESPONDNEXUSTASKCOMPLETEDREQUEST._serialized_start = 32462 + _RESPONDNEXUSTASKCOMPLETEDREQUEST._serialized_end = 32604 + _RESPONDNEXUSTASKCOMPLETEDRESPONSE._serialized_start = 32606 + _RESPONDNEXUSTASKCOMPLETEDRESPONSE._serialized_end = 32641 + _RESPONDNEXUSTASKFAILEDREQUEST._serialized_start = 32644 + _RESPONDNEXUSTASKFAILEDREQUEST._serialized_end = 32784 + _RESPONDNEXUSTASKFAILEDRESPONSE._serialized_start = 32786 + _RESPONDNEXUSTASKFAILEDRESPONSE._serialized_end = 32818 + _EXECUTEMULTIOPERATIONREQUEST._serialized_start = 32821 + _EXECUTEMULTIOPERATIONREQUEST._serialized_end = 33172 + _EXECUTEMULTIOPERATIONREQUEST_OPERATION._serialized_start = 32966 + _EXECUTEMULTIOPERATIONREQUEST_OPERATION._serialized_end = 33172 + _EXECUTEMULTIOPERATIONRESPONSE._serialized_start = 33175 + _EXECUTEMULTIOPERATIONRESPONSE._serialized_end = 33507 + _EXECUTEMULTIOPERATIONRESPONSE_RESPONSE._serialized_start = 33301 + _EXECUTEMULTIOPERATIONRESPONSE_RESPONSE._serialized_end = 33507 + _UPDATEACTIVITYOPTIONSREQUEST._serialized_start = 33510 + _UPDATEACTIVITYOPTIONSREQUEST._serialized_end = 33846 + _UPDATEACTIVITYOPTIONSRESPONSE._serialized_start = 33848 + _UPDATEACTIVITYOPTIONSRESPONSE._serialized_end = 33948 + _PAUSEACTIVITYREQUEST._serialized_start = 33951 + _PAUSEACTIVITYREQUEST._serialized_end = 34130 + _PAUSEACTIVITYRESPONSE._serialized_start = 34132 + _PAUSEACTIVITYRESPONSE._serialized_end = 34155 + _UNPAUSEACTIVITYREQUEST._serialized_start = 34158 + _UNPAUSEACTIVITYREQUEST._serialized_end = 34438 + _UNPAUSEACTIVITYRESPONSE._serialized_start = 34440 + _UNPAUSEACTIVITYRESPONSE._serialized_end = 34465 + _RESETACTIVITYREQUEST._serialized_start = 34468 + _RESETACTIVITYREQUEST._serialized_end = 34775 + _RESETACTIVITYRESPONSE._serialized_start = 34777 + _RESETACTIVITYRESPONSE._serialized_end = 34800 + _UPDATEWORKFLOWEXECUTIONOPTIONSREQUEST._serialized_start = 34803 + _UPDATEWORKFLOWEXECUTIONOPTIONSREQUEST._serialized_end = 35069 + _UPDATEWORKFLOWEXECUTIONOPTIONSRESPONSE._serialized_start = 35072 + _UPDATEWORKFLOWEXECUTIONOPTIONSRESPONSE._serialized_end = 35200 + _DESCRIBEDEPLOYMENTREQUEST._serialized_start = 35202 + _DESCRIBEDEPLOYMENTREQUEST._serialized_end = 35308 + _DESCRIBEDEPLOYMENTRESPONSE._serialized_start = 35310 + _DESCRIBEDEPLOYMENTRESPONSE._serialized_end = 35407 + _DESCRIBEWORKERDEPLOYMENTVERSIONREQUEST._serialized_start = 35410 + _DESCRIBEWORKERDEPLOYMENTVERSIONREQUEST._serialized_end = 35604 + _DESCRIBEWORKERDEPLOYMENTVERSIONRESPONSE._serialized_start = 35607 + _DESCRIBEWORKERDEPLOYMENTVERSIONRESPONSE._serialized_end = 36259 + _DESCRIBEWORKERDEPLOYMENTVERSIONRESPONSE_VERSIONTASKQUEUE._serialized_start = 35868 + _DESCRIBEWORKERDEPLOYMENTVERSIONRESPONSE_VERSIONTASKQUEUE._serialized_end = 36259 + _DESCRIBEWORKERDEPLOYMENTVERSIONRESPONSE_VERSIONTASKQUEUE_STATSBYPRIORITYKEYENTRY._serialized_start = 22197 + _DESCRIBEWORKERDEPLOYMENTVERSIONRESPONSE_VERSIONTASKQUEUE_STATSBYPRIORITYKEYENTRY._serialized_end = 22297 + _DESCRIBEWORKERDEPLOYMENTREQUEST._serialized_start = 36261 + _DESCRIBEWORKERDEPLOYMENTREQUEST._serialized_end = 36338 + _DESCRIBEWORKERDEPLOYMENTRESPONSE._serialized_start = 36341 + _DESCRIBEWORKERDEPLOYMENTRESPONSE._serialized_end = 36481 + _LISTDEPLOYMENTSREQUEST._serialized_start = 36483 + _LISTDEPLOYMENTSREQUEST._serialized_end = 36591 + _LISTDEPLOYMENTSRESPONSE._serialized_start = 36593 + _LISTDEPLOYMENTSRESPONSE._serialized_end = 36712 + _SETCURRENTDEPLOYMENTREQUEST._serialized_start = 36715 + _SETCURRENTDEPLOYMENTREQUEST._serialized_end = 36920 + _SETCURRENTDEPLOYMENTRESPONSE._serialized_start = 36923 + _SETCURRENTDEPLOYMENTRESPONSE._serialized_end = 37108 + _SETWORKERDEPLOYMENTCURRENTVERSIONREQUEST._serialized_start = 37111 + _SETWORKERDEPLOYMENTCURRENTVERSIONREQUEST._serialized_end = 37340 + _SETWORKERDEPLOYMENTCURRENTVERSIONRESPONSE._serialized_start = 37343 + _SETWORKERDEPLOYMENTCURRENTVERSIONRESPONSE._serialized_end = 37530 + _SETWORKERDEPLOYMENTRAMPINGVERSIONREQUEST._serialized_start = 37533 + _SETWORKERDEPLOYMENTRAMPINGVERSIONREQUEST._serialized_end = 37782 + _SETWORKERDEPLOYMENTRAMPINGVERSIONRESPONSE._serialized_start = 37785 + _SETWORKERDEPLOYMENTRAMPINGVERSIONRESPONSE._serialized_end = 38001 + _LISTWORKERDEPLOYMENTSREQUEST._serialized_start = 38003 + _LISTWORKERDEPLOYMENTSREQUEST._serialized_end = 38096 + _LISTWORKERDEPLOYMENTSRESPONSE._serialized_start = 38099 + _LISTWORKERDEPLOYMENTSRESPONSE._serialized_end = 38770 + _LISTWORKERDEPLOYMENTSRESPONSE_WORKERDEPLOYMENTSUMMARY._serialized_start = 38274 + _LISTWORKERDEPLOYMENTSRESPONSE_WORKERDEPLOYMENTSUMMARY._serialized_end = 38770 + _DELETEWORKERDEPLOYMENTVERSIONREQUEST._serialized_start = 38773 + _DELETEWORKERDEPLOYMENTVERSIONREQUEST._serialized_end = 38973 + _DELETEWORKERDEPLOYMENTVERSIONRESPONSE._serialized_start = 38975 + _DELETEWORKERDEPLOYMENTVERSIONRESPONSE._serialized_end = 39014 + _DELETEWORKERDEPLOYMENTREQUEST._serialized_start = 39016 + _DELETEWORKERDEPLOYMENTREQUEST._serialized_end = 39109 + _DELETEWORKERDEPLOYMENTRESPONSE._serialized_start = 39111 + _DELETEWORKERDEPLOYMENTRESPONSE._serialized_end = 39143 + _UPDATEWORKERDEPLOYMENTVERSIONMETADATAREQUEST._serialized_start = 39146 + _UPDATEWORKERDEPLOYMENTVERSIONMETADATAREQUEST._serialized_end = 39564 + _UPDATEWORKERDEPLOYMENTVERSIONMETADATAREQUEST_UPSERTENTRIESENTRY._serialized_start = 39479 _UPDATEWORKERDEPLOYMENTVERSIONMETADATAREQUEST_UPSERTENTRIESENTRY._serialized_end = ( - 39526 + 39564 ) - _UPDATEWORKERDEPLOYMENTVERSIONMETADATARESPONSE._serialized_start = 39528 - _UPDATEWORKERDEPLOYMENTVERSIONMETADATARESPONSE._serialized_end = 39638 - _SETWORKERDEPLOYMENTMANAGERREQUEST._serialized_start = 39641 - _SETWORKERDEPLOYMENTMANAGERREQUEST._serialized_end = 39830 - _SETWORKERDEPLOYMENTMANAGERRESPONSE._serialized_start = 39832 - _SETWORKERDEPLOYMENTMANAGERRESPONSE._serialized_end = 39927 - _GETCURRENTDEPLOYMENTREQUEST._serialized_start = 39929 - _GETCURRENTDEPLOYMENTREQUEST._serialized_end = 39998 - _GETCURRENTDEPLOYMENTRESPONSE._serialized_start = 40000 - _GETCURRENTDEPLOYMENTRESPONSE._serialized_end = 40107 - _GETDEPLOYMENTREACHABILITYREQUEST._serialized_start = 40109 - _GETDEPLOYMENTREACHABILITYREQUEST._serialized_end = 40222 - _GETDEPLOYMENTREACHABILITYRESPONSE._serialized_start = 40225 - _GETDEPLOYMENTREACHABILITYRESPONSE._serialized_end = 40452 - _CREATEWORKFLOWRULEREQUEST._serialized_start = 40455 - _CREATEWORKFLOWRULEREQUEST._serialized_end = 40635 - _CREATEWORKFLOWRULERESPONSE._serialized_start = 40637 - _CREATEWORKFLOWRULERESPONSE._serialized_end = 40732 - _DESCRIBEWORKFLOWRULEREQUEST._serialized_start = 40734 - _DESCRIBEWORKFLOWRULEREQUEST._serialized_end = 40799 - _DESCRIBEWORKFLOWRULERESPONSE._serialized_start = 40801 - _DESCRIBEWORKFLOWRULERESPONSE._serialized_end = 40882 - _DELETEWORKFLOWRULEREQUEST._serialized_start = 40884 - _DELETEWORKFLOWRULEREQUEST._serialized_end = 40947 - _DELETEWORKFLOWRULERESPONSE._serialized_start = 40949 - _DELETEWORKFLOWRULERESPONSE._serialized_end = 40977 - _LISTWORKFLOWRULESREQUEST._serialized_start = 40979 - _LISTWORKFLOWRULESREQUEST._serialized_end = 41049 - _LISTWORKFLOWRULESRESPONSE._serialized_start = 41051 - _LISTWORKFLOWRULESRESPONSE._serialized_end = 41155 - _TRIGGERWORKFLOWRULEREQUEST._serialized_start = 41158 - _TRIGGERWORKFLOWRULEREQUEST._serialized_end = 41364 - _TRIGGERWORKFLOWRULERESPONSE._serialized_start = 41366 - _TRIGGERWORKFLOWRULERESPONSE._serialized_end = 41412 - _RECORDWORKERHEARTBEATREQUEST._serialized_start = 41415 - _RECORDWORKERHEARTBEATREQUEST._serialized_end = 41549 - _RECORDWORKERHEARTBEATRESPONSE._serialized_start = 41551 - _RECORDWORKERHEARTBEATRESPONSE._serialized_end = 41582 - _LISTWORKERSREQUEST._serialized_start = 41584 - _LISTWORKERSREQUEST._serialized_end = 41682 - _LISTWORKERSRESPONSE._serialized_start = 41684 - _LISTWORKERSRESPONSE._serialized_end = 41788 - _UPDATETASKQUEUECONFIGREQUEST._serialized_start = 41791 - _UPDATETASKQUEUECONFIGREQUEST._serialized_end = 42273 - _UPDATETASKQUEUECONFIGREQUEST_RATELIMITUPDATE._serialized_start = 42182 - _UPDATETASKQUEUECONFIGREQUEST_RATELIMITUPDATE._serialized_end = 42273 - _UPDATETASKQUEUECONFIGRESPONSE._serialized_start = 42275 - _UPDATETASKQUEUECONFIGRESPONSE._serialized_end = 42366 - _FETCHWORKERCONFIGREQUEST._serialized_start = 42369 - _FETCHWORKERCONFIGREQUEST._serialized_end = 42506 - _FETCHWORKERCONFIGRESPONSE._serialized_start = 42508 - _FETCHWORKERCONFIGRESPONSE._serialized_end = 42593 - _UPDATEWORKERCONFIGREQUEST._serialized_start = 42596 - _UPDATEWORKERCONFIGREQUEST._serialized_end = 42841 - _UPDATEWORKERCONFIGRESPONSE._serialized_start = 42843 - _UPDATEWORKERCONFIGRESPONSE._serialized_end = 42943 - _DESCRIBEWORKERREQUEST._serialized_start = 42945 - _DESCRIBEWORKERREQUEST._serialized_end = 43016 - _DESCRIBEWORKERRESPONSE._serialized_start = 43018 - _DESCRIBEWORKERRESPONSE._serialized_end = 43099 + _UPDATEWORKERDEPLOYMENTVERSIONMETADATARESPONSE._serialized_start = 39566 + _UPDATEWORKERDEPLOYMENTVERSIONMETADATARESPONSE._serialized_end = 39676 + _SETWORKERDEPLOYMENTMANAGERREQUEST._serialized_start = 39679 + _SETWORKERDEPLOYMENTMANAGERREQUEST._serialized_end = 39868 + _SETWORKERDEPLOYMENTMANAGERRESPONSE._serialized_start = 39870 + _SETWORKERDEPLOYMENTMANAGERRESPONSE._serialized_end = 39965 + _GETCURRENTDEPLOYMENTREQUEST._serialized_start = 39967 + _GETCURRENTDEPLOYMENTREQUEST._serialized_end = 40036 + _GETCURRENTDEPLOYMENTRESPONSE._serialized_start = 40038 + _GETCURRENTDEPLOYMENTRESPONSE._serialized_end = 40145 + _GETDEPLOYMENTREACHABILITYREQUEST._serialized_start = 40147 + _GETDEPLOYMENTREACHABILITYREQUEST._serialized_end = 40260 + _GETDEPLOYMENTREACHABILITYRESPONSE._serialized_start = 40263 + _GETDEPLOYMENTREACHABILITYRESPONSE._serialized_end = 40490 + _CREATEWORKFLOWRULEREQUEST._serialized_start = 40493 + _CREATEWORKFLOWRULEREQUEST._serialized_end = 40673 + _CREATEWORKFLOWRULERESPONSE._serialized_start = 40675 + _CREATEWORKFLOWRULERESPONSE._serialized_end = 40770 + _DESCRIBEWORKFLOWRULEREQUEST._serialized_start = 40772 + _DESCRIBEWORKFLOWRULEREQUEST._serialized_end = 40837 + _DESCRIBEWORKFLOWRULERESPONSE._serialized_start = 40839 + _DESCRIBEWORKFLOWRULERESPONSE._serialized_end = 40920 + _DELETEWORKFLOWRULEREQUEST._serialized_start = 40922 + _DELETEWORKFLOWRULEREQUEST._serialized_end = 40985 + _DELETEWORKFLOWRULERESPONSE._serialized_start = 40987 + _DELETEWORKFLOWRULERESPONSE._serialized_end = 41015 + _LISTWORKFLOWRULESREQUEST._serialized_start = 41017 + _LISTWORKFLOWRULESREQUEST._serialized_end = 41087 + _LISTWORKFLOWRULESRESPONSE._serialized_start = 41089 + _LISTWORKFLOWRULESRESPONSE._serialized_end = 41193 + _TRIGGERWORKFLOWRULEREQUEST._serialized_start = 41196 + _TRIGGERWORKFLOWRULEREQUEST._serialized_end = 41402 + _TRIGGERWORKFLOWRULERESPONSE._serialized_start = 41404 + _TRIGGERWORKFLOWRULERESPONSE._serialized_end = 41450 + _RECORDWORKERHEARTBEATREQUEST._serialized_start = 41453 + _RECORDWORKERHEARTBEATREQUEST._serialized_end = 41587 + _RECORDWORKERHEARTBEATRESPONSE._serialized_start = 41589 + _RECORDWORKERHEARTBEATRESPONSE._serialized_end = 41620 + _LISTWORKERSREQUEST._serialized_start = 41622 + _LISTWORKERSREQUEST._serialized_end = 41720 + _LISTWORKERSRESPONSE._serialized_start = 41722 + _LISTWORKERSRESPONSE._serialized_end = 41826 + _UPDATETASKQUEUECONFIGREQUEST._serialized_start = 41829 + _UPDATETASKQUEUECONFIGREQUEST._serialized_end = 42311 + _UPDATETASKQUEUECONFIGREQUEST_RATELIMITUPDATE._serialized_start = 42220 + _UPDATETASKQUEUECONFIGREQUEST_RATELIMITUPDATE._serialized_end = 42311 + _UPDATETASKQUEUECONFIGRESPONSE._serialized_start = 42313 + _UPDATETASKQUEUECONFIGRESPONSE._serialized_end = 42404 + _FETCHWORKERCONFIGREQUEST._serialized_start = 42407 + _FETCHWORKERCONFIGREQUEST._serialized_end = 42544 + _FETCHWORKERCONFIGRESPONSE._serialized_start = 42546 + _FETCHWORKERCONFIGRESPONSE._serialized_end = 42631 + _UPDATEWORKERCONFIGREQUEST._serialized_start = 42634 + _UPDATEWORKERCONFIGREQUEST._serialized_end = 42879 + _UPDATEWORKERCONFIGRESPONSE._serialized_start = 42881 + _UPDATEWORKERCONFIGRESPONSE._serialized_end = 42981 + _DESCRIBEWORKERREQUEST._serialized_start = 42983 + _DESCRIBEWORKERREQUEST._serialized_end = 43054 + _DESCRIBEWORKERRESPONSE._serialized_start = 43056 + _DESCRIBEWORKERRESPONSE._serialized_end = 43137 + _STARTACTIVITYEXECUTIONREQUEST._serialized_start = 43140 + _STARTACTIVITYEXECUTIONREQUEST._serialized_end = 44088 + _STARTACTIVITYEXECUTIONRESPONSE._serialized_start = 44090 + _STARTACTIVITYEXECUTIONRESPONSE._serialized_end = 44155 + _DESCRIBEACTIVITYEXECUTIONREQUEST._serialized_start = 44158 + _DESCRIBEACTIVITYEXECUTIONREQUEST._serialized_end = 44321 + _DESCRIBEACTIVITYEXECUTIONRESPONSE._serialized_start = 44324 + _DESCRIBEACTIVITYEXECUTIONRESPONSE._serialized_end = 44581 + _POLLACTIVITYEXECUTIONREQUEST._serialized_start = 44583 + _POLLACTIVITYEXECUTIONREQUEST._serialized_end = 44669 + _POLLACTIVITYEXECUTIONRESPONSE._serialized_start = 44671 + _POLLACTIVITYEXECUTIONRESPONSE._serialized_end = 44787 + _LISTACTIVITYEXECUTIONSREQUEST._serialized_start = 44789 + _LISTACTIVITYEXECUTIONSREQUEST._serialized_end = 44898 + _LISTACTIVITYEXECUTIONSRESPONSE._serialized_start = 44901 + _LISTACTIVITYEXECUTIONSRESPONSE._serialized_end = 45031 + _COUNTACTIVITYEXECUTIONSREQUEST._serialized_start = 45033 + _COUNTACTIVITYEXECUTIONSREQUEST._serialized_end = 45099 + _COUNTACTIVITYEXECUTIONSRESPONSE._serialized_start = 45102 + _COUNTACTIVITYEXECUTIONSRESPONSE._serialized_end = 45339 + _COUNTACTIVITYEXECUTIONSRESPONSE_AGGREGATIONGROUP._serialized_start = 18773 + _COUNTACTIVITYEXECUTIONSRESPONSE_AGGREGATIONGROUP._serialized_end = 18861 + _REQUESTCANCELACTIVITYEXECUTIONREQUEST._serialized_start = 45342 + _REQUESTCANCELACTIVITYEXECUTIONREQUEST._serialized_end = 45491 + _REQUESTCANCELACTIVITYEXECUTIONRESPONSE._serialized_start = 45493 + _REQUESTCANCELACTIVITYEXECUTIONRESPONSE._serialized_end = 45533 + _TERMINATEACTIVITYEXECUTIONREQUEST._serialized_start = 45536 + _TERMINATEACTIVITYEXECUTIONREQUEST._serialized_end = 45681 + _TERMINATEACTIVITYEXECUTIONRESPONSE._serialized_start = 45683 + _TERMINATEACTIVITYEXECUTIONRESPONSE._serialized_end = 45719 + _DELETEACTIVITYEXECUTIONREQUEST._serialized_start = 45721 + _DELETEACTIVITYEXECUTIONREQUEST._serialized_end = 45809 + _DELETEACTIVITYEXECUTIONRESPONSE._serialized_start = 45811 + _DELETEACTIVITYEXECUTIONRESPONSE._serialized_end = 45844 # @@protoc_insertion_point(module_scope) diff --git a/temporalio/api/workflowservice/v1/request_response_pb2.pyi b/temporalio/api/workflowservice/v1/request_response_pb2.pyi index 0cb4e2710..4845382e5 100644 --- a/temporalio/api/workflowservice/v1/request_response_pb2.pyi +++ b/temporalio/api/workflowservice/v1/request_response_pb2.pyi @@ -19,6 +19,7 @@ import temporalio.api.batch.v1.message_pb2 import temporalio.api.command.v1.message_pb2 import temporalio.api.common.v1.message_pb2 import temporalio.api.deployment.v1.message_pb2 +import temporalio.api.enums.v1.activity_pb2 import temporalio.api.enums.v1.batch_operation_pb2 import temporalio.api.enums.v1.common_pb2 import temporalio.api.enums.v1.deployment_pb2 @@ -1913,6 +1914,7 @@ class PollActivityTaskQueueResponse(google.protobuf.message.Message): """The autogenerated or user specified identifier of this activity. Can be used to complete the activity via `RespondActivityTaskCompletedById`. May be re-used as long as the last usage has resolved, but unique IDs for every activity invocation is a good idea. + Note that only a workflow activity ID may be autogenerated. """ @property def header(self) -> temporalio.api.common.v1.message_pb2.Header: @@ -2167,9 +2169,11 @@ class RecordActivityTaskHeartbeatByIdRequest(google.protobuf.message.Message): namespace: builtins.str """Namespace of the workflow which scheduled this activity""" workflow_id: builtins.str - """Id of the workflow which scheduled this activity""" + """Id of the workflow which scheduled this activity, leave empty to target a standalone activity""" run_id: builtins.str - """Run Id of the workflow which scheduled this activity""" + """For a workflow activity - the run ID of the workflow which scheduled this activity. + For a standalone activity - the run ID of the activity. + """ activity_id: builtins.str """Id of the activity we're heartbeating""" @property @@ -2354,9 +2358,11 @@ class RespondActivityTaskCompletedByIdRequest(google.protobuf.message.Message): namespace: builtins.str """Namespace of the workflow which scheduled this activity""" workflow_id: builtins.str - """Id of the workflow which scheduled this activity""" + """Id of the workflow which scheduled this activity, leave empty to target a standalone activity""" run_id: builtins.str - """Run Id of the workflow which scheduled this activity""" + """For a workflow activity - the run ID of the workflow which scheduled this activity. + For a standalone activity - the run ID of the activity. + """ activity_id: builtins.str """Id of the activity to complete""" @property @@ -2544,9 +2550,11 @@ class RespondActivityTaskFailedByIdRequest(google.protobuf.message.Message): namespace: builtins.str """Namespace of the workflow which scheduled this activity""" workflow_id: builtins.str - """Id of the workflow which scheduled this activity""" + """Id of the workflow which scheduled this activity, leave empty to target a standalone activity""" run_id: builtins.str - """Run Id of the workflow which scheduled this activity""" + """For a workflow activity - the run ID of the workflow which scheduled this activity. + For a standalone activity - the run ID of the activity. + """ activity_id: builtins.str """Id of the activity to fail""" @property @@ -2730,9 +2738,11 @@ class RespondActivityTaskCanceledByIdRequest(google.protobuf.message.Message): namespace: builtins.str """Namespace of the workflow which scheduled this activity""" workflow_id: builtins.str - """Id of the workflow which scheduled this activity""" + """Id of the workflow which scheduled this activity, leave empty to target a standalone activity""" run_id: builtins.str - """Run Id of the workflow which scheduled this activity""" + """For a workflow activity - the run ID of the workflow which scheduled this activity. + For a standalone activity - the run ID of the activity. + """ activity_id: builtins.str """Id of the activity to confirm is cancelled""" @property @@ -10152,3 +10162,712 @@ class DescribeWorkerResponse(google.protobuf.message.Message): ) -> None: ... global___DescribeWorkerResponse = DescribeWorkerResponse + +class StartActivityExecutionRequest(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + NAMESPACE_FIELD_NUMBER: builtins.int + IDENTITY_FIELD_NUMBER: builtins.int + REQUEST_ID_FIELD_NUMBER: builtins.int + ACTIVITY_ID_FIELD_NUMBER: builtins.int + ACTIVITY_TYPE_FIELD_NUMBER: builtins.int + TASK_QUEUE_FIELD_NUMBER: builtins.int + SCHEDULE_TO_CLOSE_TIMEOUT_FIELD_NUMBER: builtins.int + SCHEDULE_TO_START_TIMEOUT_FIELD_NUMBER: builtins.int + START_TO_CLOSE_TIMEOUT_FIELD_NUMBER: builtins.int + HEARTBEAT_TIMEOUT_FIELD_NUMBER: builtins.int + RETRY_POLICY_FIELD_NUMBER: builtins.int + INPUT_FIELD_NUMBER: builtins.int + ID_REUSE_POLICY_FIELD_NUMBER: builtins.int + ID_CONFLICT_POLICY_FIELD_NUMBER: builtins.int + SEARCH_ATTRIBUTES_FIELD_NUMBER: builtins.int + HEADER_FIELD_NUMBER: builtins.int + USER_METADATA_FIELD_NUMBER: builtins.int + PRIORITY_FIELD_NUMBER: builtins.int + namespace: builtins.str + identity: builtins.str + """The identity of the client who initiated this request""" + request_id: builtins.str + """A unique identifier for this start request. Typically UUIDv4.""" + activity_id: builtins.str + """Identifier for this activity. Required. This identifier should be meaningful in the user's + own system. It must be unique among activities in the same namespace, subject to the rules + imposed by id_reuse_policy and id_conflict_policy. + """ + @property + def activity_type(self) -> temporalio.api.common.v1.message_pb2.ActivityType: + """The type of the activity, a string that corresponds to a registered activity on a worker.""" + @property + def task_queue(self) -> temporalio.api.taskqueue.v1.message_pb2.TaskQueue: + """Task queue to schedule this activity on.""" + @property + def schedule_to_close_timeout(self) -> google.protobuf.duration_pb2.Duration: + """Indicates how long the caller is willing to wait for an activity completion. Limits how long + retries will be attempted. Either this or `start_to_close_timeout` must be specified. + + (-- api-linter: core::0140::prepositions=disabled + aip.dev/not-precedent: "to" is used to indicate interval. --) + """ + @property + def schedule_to_start_timeout(self) -> google.protobuf.duration_pb2.Duration: + """Limits time an activity task can stay in a task queue before a worker picks it up. This + timeout is always non retryable, as all a retry would achieve is to put it back into the same + queue. Defaults to `schedule_to_close_timeout` if not specified. + + (-- api-linter: core::0140::prepositions=disabled + aip.dev/not-precedent: "to" is used to indicate interval. --) + """ + @property + def start_to_close_timeout(self) -> google.protobuf.duration_pb2.Duration: + """Maximum time an activity is allowed to execute after being picked up by a worker. This + timeout is always retryable. Either this or `schedule_to_close_timeout` must be + specified. + + (-- api-linter: core::0140::prepositions=disabled + aip.dev/not-precedent: "to" is used to indicate interval. --) + """ + @property + def heartbeat_timeout(self) -> google.protobuf.duration_pb2.Duration: + """Maximum permitted time between successful worker heartbeats.""" + @property + def retry_policy(self) -> temporalio.api.common.v1.message_pb2.RetryPolicy: + """The retry policy for the activity. Will never exceed `schedule_to_close_timeout`.""" + @property + def input(self) -> temporalio.api.common.v1.message_pb2.Payloads: + """Serialized arguments to the activity. These are passed as arguments to the activity function.""" + id_reuse_policy: ( + temporalio.api.enums.v1.activity_pb2.ActivityIdReusePolicy.ValueType + ) + """Defines whether to allow re-using the activity id from a previously *closed* activity. + The default policy is ACTIVITY_ID_REUSE_POLICY_ALLOW_DUPLICATE. + """ + id_conflict_policy: ( + temporalio.api.enums.v1.activity_pb2.ActivityIdConflictPolicy.ValueType + ) + """Defines how to resolve an activity id conflict with a *running* activity. + The default policy is ACTIVITY_ID_CONFLICT_POLICY_FAIL. + """ + @property + def search_attributes( + self, + ) -> temporalio.api.common.v1.message_pb2.SearchAttributes: + """Search attributes for indexing.""" + @property + def header(self) -> temporalio.api.common.v1.message_pb2.Header: + """Header for context propagation and tracing purposes.""" + @property + def user_metadata(self) -> temporalio.api.sdk.v1.user_metadata_pb2.UserMetadata: + """Metadata for use by user interfaces to display the fixed as-of-start summary and details of the activity.""" + @property + def priority(self) -> temporalio.api.common.v1.message_pb2.Priority: + """Priority metadata.""" + def __init__( + self, + *, + namespace: builtins.str = ..., + identity: builtins.str = ..., + request_id: builtins.str = ..., + activity_id: builtins.str = ..., + activity_type: temporalio.api.common.v1.message_pb2.ActivityType | None = ..., + task_queue: temporalio.api.taskqueue.v1.message_pb2.TaskQueue | None = ..., + schedule_to_close_timeout: google.protobuf.duration_pb2.Duration | None = ..., + schedule_to_start_timeout: google.protobuf.duration_pb2.Duration | None = ..., + start_to_close_timeout: google.protobuf.duration_pb2.Duration | None = ..., + heartbeat_timeout: google.protobuf.duration_pb2.Duration | None = ..., + retry_policy: temporalio.api.common.v1.message_pb2.RetryPolicy | None = ..., + input: temporalio.api.common.v1.message_pb2.Payloads | None = ..., + id_reuse_policy: temporalio.api.enums.v1.activity_pb2.ActivityIdReusePolicy.ValueType = ..., + id_conflict_policy: temporalio.api.enums.v1.activity_pb2.ActivityIdConflictPolicy.ValueType = ..., + search_attributes: temporalio.api.common.v1.message_pb2.SearchAttributes + | None = ..., + header: temporalio.api.common.v1.message_pb2.Header | None = ..., + user_metadata: temporalio.api.sdk.v1.user_metadata_pb2.UserMetadata + | None = ..., + priority: temporalio.api.common.v1.message_pb2.Priority | None = ..., + ) -> None: ... + def HasField( + self, + field_name: typing_extensions.Literal[ + "activity_type", + b"activity_type", + "header", + b"header", + "heartbeat_timeout", + b"heartbeat_timeout", + "input", + b"input", + "priority", + b"priority", + "retry_policy", + b"retry_policy", + "schedule_to_close_timeout", + b"schedule_to_close_timeout", + "schedule_to_start_timeout", + b"schedule_to_start_timeout", + "search_attributes", + b"search_attributes", + "start_to_close_timeout", + b"start_to_close_timeout", + "task_queue", + b"task_queue", + "user_metadata", + b"user_metadata", + ], + ) -> builtins.bool: ... + def ClearField( + self, + field_name: typing_extensions.Literal[ + "activity_id", + b"activity_id", + "activity_type", + b"activity_type", + "header", + b"header", + "heartbeat_timeout", + b"heartbeat_timeout", + "id_conflict_policy", + b"id_conflict_policy", + "id_reuse_policy", + b"id_reuse_policy", + "identity", + b"identity", + "input", + b"input", + "namespace", + b"namespace", + "priority", + b"priority", + "request_id", + b"request_id", + "retry_policy", + b"retry_policy", + "schedule_to_close_timeout", + b"schedule_to_close_timeout", + "schedule_to_start_timeout", + b"schedule_to_start_timeout", + "search_attributes", + b"search_attributes", + "start_to_close_timeout", + b"start_to_close_timeout", + "task_queue", + b"task_queue", + "user_metadata", + b"user_metadata", + ], + ) -> None: ... + +global___StartActivityExecutionRequest = StartActivityExecutionRequest + +class StartActivityExecutionResponse(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + RUN_ID_FIELD_NUMBER: builtins.int + STARTED_FIELD_NUMBER: builtins.int + run_id: builtins.str + """The run ID of the activity that was started - or used (via ACTIVITY_ID_CONFLICT_POLICY_USE_EXISTING).""" + started: builtins.bool + """If true, a new activity was started.""" + def __init__( + self, + *, + run_id: builtins.str = ..., + started: builtins.bool = ..., + ) -> None: ... + def ClearField( + self, + field_name: typing_extensions.Literal[ + "run_id", b"run_id", "started", b"started" + ], + ) -> None: ... + +global___StartActivityExecutionResponse = StartActivityExecutionResponse + +class DescribeActivityExecutionRequest(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + NAMESPACE_FIELD_NUMBER: builtins.int + ACTIVITY_ID_FIELD_NUMBER: builtins.int + RUN_ID_FIELD_NUMBER: builtins.int + INCLUDE_INPUT_FIELD_NUMBER: builtins.int + INCLUDE_OUTCOME_FIELD_NUMBER: builtins.int + LONG_POLL_TOKEN_FIELD_NUMBER: builtins.int + namespace: builtins.str + activity_id: builtins.str + run_id: builtins.str + """Activity run ID. If empty the request targets the latest run.""" + include_input: builtins.bool + """Include the input field in the response.""" + include_outcome: builtins.bool + """Include the outcome (result/failure) in the response if the activity has completed.""" + long_poll_token: builtins.bytes + """Token from a previous DescribeActivityExecutionResponse. If present, long-poll until activity + state changes from the state encoded in this token. If absent, return current state immediately. + If present, run_id must also be present. + Note that activity state may change multiple times between requests, therefore it is not + guaranteed that a client making a sequence of long-poll requests will see a complete + sequence of state changes. + """ + def __init__( + self, + *, + namespace: builtins.str = ..., + activity_id: builtins.str = ..., + run_id: builtins.str = ..., + include_input: builtins.bool = ..., + include_outcome: builtins.bool = ..., + long_poll_token: builtins.bytes = ..., + ) -> None: ... + def ClearField( + self, + field_name: typing_extensions.Literal[ + "activity_id", + b"activity_id", + "include_input", + b"include_input", + "include_outcome", + b"include_outcome", + "long_poll_token", + b"long_poll_token", + "namespace", + b"namespace", + "run_id", + b"run_id", + ], + ) -> None: ... + +global___DescribeActivityExecutionRequest = DescribeActivityExecutionRequest + +class DescribeActivityExecutionResponse(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + RUN_ID_FIELD_NUMBER: builtins.int + INFO_FIELD_NUMBER: builtins.int + INPUT_FIELD_NUMBER: builtins.int + OUTCOME_FIELD_NUMBER: builtins.int + LONG_POLL_TOKEN_FIELD_NUMBER: builtins.int + run_id: builtins.str + """The run ID of the activity, useful when run_id was not specified in the request.""" + @property + def info(self) -> temporalio.api.activity.v1.message_pb2.ActivityExecutionInfo: + """Information about the activity execution.""" + @property + def input(self) -> temporalio.api.common.v1.message_pb2.Payloads: + """Serialized activity input, passed as arguments to the activity function. + Only set if include_input was true in the request. + """ + @property + def outcome( + self, + ) -> temporalio.api.activity.v1.message_pb2.ActivityExecutionOutcome: + """Only set if the activity is completed and include_outcome was true in the request.""" + long_poll_token: builtins.bytes + """Token for follow-on long-poll requests. Absent only if the activity is complete.""" + def __init__( + self, + *, + run_id: builtins.str = ..., + info: temporalio.api.activity.v1.message_pb2.ActivityExecutionInfo | None = ..., + input: temporalio.api.common.v1.message_pb2.Payloads | None = ..., + outcome: temporalio.api.activity.v1.message_pb2.ActivityExecutionOutcome + | None = ..., + long_poll_token: builtins.bytes = ..., + ) -> None: ... + def HasField( + self, + field_name: typing_extensions.Literal[ + "info", b"info", "input", b"input", "outcome", b"outcome" + ], + ) -> builtins.bool: ... + def ClearField( + self, + field_name: typing_extensions.Literal[ + "info", + b"info", + "input", + b"input", + "long_poll_token", + b"long_poll_token", + "outcome", + b"outcome", + "run_id", + b"run_id", + ], + ) -> None: ... + +global___DescribeActivityExecutionResponse = DescribeActivityExecutionResponse + +class PollActivityExecutionRequest(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + NAMESPACE_FIELD_NUMBER: builtins.int + ACTIVITY_ID_FIELD_NUMBER: builtins.int + RUN_ID_FIELD_NUMBER: builtins.int + namespace: builtins.str + activity_id: builtins.str + run_id: builtins.str + """Activity run ID. If empty the request targets the latest run.""" + def __init__( + self, + *, + namespace: builtins.str = ..., + activity_id: builtins.str = ..., + run_id: builtins.str = ..., + ) -> None: ... + def ClearField( + self, + field_name: typing_extensions.Literal[ + "activity_id", + b"activity_id", + "namespace", + b"namespace", + "run_id", + b"run_id", + ], + ) -> None: ... + +global___PollActivityExecutionRequest = PollActivityExecutionRequest + +class PollActivityExecutionResponse(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + RUN_ID_FIELD_NUMBER: builtins.int + OUTCOME_FIELD_NUMBER: builtins.int + run_id: builtins.str + """The run ID of the activity, useful when run_id was not specified in the request.""" + @property + def outcome( + self, + ) -> temporalio.api.activity.v1.message_pb2.ActivityExecutionOutcome: ... + def __init__( + self, + *, + run_id: builtins.str = ..., + outcome: temporalio.api.activity.v1.message_pb2.ActivityExecutionOutcome + | None = ..., + ) -> None: ... + def HasField( + self, field_name: typing_extensions.Literal["outcome", b"outcome"] + ) -> builtins.bool: ... + def ClearField( + self, + field_name: typing_extensions.Literal[ + "outcome", b"outcome", "run_id", b"run_id" + ], + ) -> None: ... + +global___PollActivityExecutionResponse = PollActivityExecutionResponse + +class ListActivityExecutionsRequest(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + NAMESPACE_FIELD_NUMBER: builtins.int + PAGE_SIZE_FIELD_NUMBER: builtins.int + NEXT_PAGE_TOKEN_FIELD_NUMBER: builtins.int + QUERY_FIELD_NUMBER: builtins.int + namespace: builtins.str + page_size: builtins.int + """Max number of executions to return per page.""" + next_page_token: builtins.bytes + """Token returned in ListActivityExecutionsResponse.""" + query: builtins.str + """Visibility query, see https://docs.temporal.io/list-filter for the syntax.""" + def __init__( + self, + *, + namespace: builtins.str = ..., + page_size: builtins.int = ..., + next_page_token: builtins.bytes = ..., + query: builtins.str = ..., + ) -> None: ... + def ClearField( + self, + field_name: typing_extensions.Literal[ + "namespace", + b"namespace", + "next_page_token", + b"next_page_token", + "page_size", + b"page_size", + "query", + b"query", + ], + ) -> None: ... + +global___ListActivityExecutionsRequest = ListActivityExecutionsRequest + +class ListActivityExecutionsResponse(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + EXECUTIONS_FIELD_NUMBER: builtins.int + NEXT_PAGE_TOKEN_FIELD_NUMBER: builtins.int + @property + def executions( + self, + ) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[ + temporalio.api.activity.v1.message_pb2.ActivityExecutionListInfo + ]: ... + next_page_token: builtins.bytes + """Token to use to fetch the next page. If empty, there is no next page.""" + def __init__( + self, + *, + executions: collections.abc.Iterable[ + temporalio.api.activity.v1.message_pb2.ActivityExecutionListInfo + ] + | None = ..., + next_page_token: builtins.bytes = ..., + ) -> None: ... + def ClearField( + self, + field_name: typing_extensions.Literal[ + "executions", b"executions", "next_page_token", b"next_page_token" + ], + ) -> None: ... + +global___ListActivityExecutionsResponse = ListActivityExecutionsResponse + +class CountActivityExecutionsRequest(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + NAMESPACE_FIELD_NUMBER: builtins.int + QUERY_FIELD_NUMBER: builtins.int + namespace: builtins.str + query: builtins.str + """Visibility query, see https://docs.temporal.io/list-filter for the syntax.""" + def __init__( + self, + *, + namespace: builtins.str = ..., + query: builtins.str = ..., + ) -> None: ... + def ClearField( + self, + field_name: typing_extensions.Literal[ + "namespace", b"namespace", "query", b"query" + ], + ) -> None: ... + +global___CountActivityExecutionsRequest = CountActivityExecutionsRequest + +class CountActivityExecutionsResponse(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + class AggregationGroup(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + GROUP_VALUES_FIELD_NUMBER: builtins.int + COUNT_FIELD_NUMBER: builtins.int + @property + def group_values( + self, + ) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[ + temporalio.api.common.v1.message_pb2.Payload + ]: ... + count: builtins.int + def __init__( + self, + *, + group_values: collections.abc.Iterable[ + temporalio.api.common.v1.message_pb2.Payload + ] + | None = ..., + count: builtins.int = ..., + ) -> None: ... + def ClearField( + self, + field_name: typing_extensions.Literal[ + "count", b"count", "group_values", b"group_values" + ], + ) -> None: ... + + COUNT_FIELD_NUMBER: builtins.int + GROUPS_FIELD_NUMBER: builtins.int + count: builtins.int + """If `query` is not grouping by any field, the count is an approximate number + of activities that match the query. + If `query` is grouping by a field, the count is simply the sum of the counts + of the groups returned in the response. This number can be smaller than the + total number of activities matching the query. + """ + @property + def groups( + self, + ) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[ + global___CountActivityExecutionsResponse.AggregationGroup + ]: + """Contains the groups if the request is grouping by a field. + The list might not be complete, and the counts of each group is approximate. + """ + def __init__( + self, + *, + count: builtins.int = ..., + groups: collections.abc.Iterable[ + global___CountActivityExecutionsResponse.AggregationGroup + ] + | None = ..., + ) -> None: ... + def ClearField( + self, + field_name: typing_extensions.Literal["count", b"count", "groups", b"groups"], + ) -> None: ... + +global___CountActivityExecutionsResponse = CountActivityExecutionsResponse + +class RequestCancelActivityExecutionRequest(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + NAMESPACE_FIELD_NUMBER: builtins.int + ACTIVITY_ID_FIELD_NUMBER: builtins.int + RUN_ID_FIELD_NUMBER: builtins.int + IDENTITY_FIELD_NUMBER: builtins.int + REQUEST_ID_FIELD_NUMBER: builtins.int + REASON_FIELD_NUMBER: builtins.int + namespace: builtins.str + activity_id: builtins.str + run_id: builtins.str + """Activity run ID, targets the latest run if run_id is empty.""" + identity: builtins.str + """The identity of the worker/client.""" + request_id: builtins.str + """Used to de-dupe cancellation requests.""" + reason: builtins.str + """Reason for requesting the cancellation, recorded and available via the PollActivityExecution API. + Not propagated to a worker if an activity attempt is currently running. + """ + def __init__( + self, + *, + namespace: builtins.str = ..., + activity_id: builtins.str = ..., + run_id: builtins.str = ..., + identity: builtins.str = ..., + request_id: builtins.str = ..., + reason: builtins.str = ..., + ) -> None: ... + def ClearField( + self, + field_name: typing_extensions.Literal[ + "activity_id", + b"activity_id", + "identity", + b"identity", + "namespace", + b"namespace", + "reason", + b"reason", + "request_id", + b"request_id", + "run_id", + b"run_id", + ], + ) -> None: ... + +global___RequestCancelActivityExecutionRequest = RequestCancelActivityExecutionRequest + +class RequestCancelActivityExecutionResponse(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +global___RequestCancelActivityExecutionResponse = RequestCancelActivityExecutionResponse + +class TerminateActivityExecutionRequest(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + NAMESPACE_FIELD_NUMBER: builtins.int + ACTIVITY_ID_FIELD_NUMBER: builtins.int + RUN_ID_FIELD_NUMBER: builtins.int + IDENTITY_FIELD_NUMBER: builtins.int + REQUEST_ID_FIELD_NUMBER: builtins.int + REASON_FIELD_NUMBER: builtins.int + namespace: builtins.str + activity_id: builtins.str + run_id: builtins.str + """Activity run ID, targets the latest run if run_id is empty.""" + identity: builtins.str + """The identity of the worker/client.""" + request_id: builtins.str + """Used to de-dupe termination requests.""" + reason: builtins.str + """Reason for requesting the termination, recorded in in the activity's result failure outcome.""" + def __init__( + self, + *, + namespace: builtins.str = ..., + activity_id: builtins.str = ..., + run_id: builtins.str = ..., + identity: builtins.str = ..., + request_id: builtins.str = ..., + reason: builtins.str = ..., + ) -> None: ... + def ClearField( + self, + field_name: typing_extensions.Literal[ + "activity_id", + b"activity_id", + "identity", + b"identity", + "namespace", + b"namespace", + "reason", + b"reason", + "request_id", + b"request_id", + "run_id", + b"run_id", + ], + ) -> None: ... + +global___TerminateActivityExecutionRequest = TerminateActivityExecutionRequest + +class TerminateActivityExecutionResponse(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +global___TerminateActivityExecutionResponse = TerminateActivityExecutionResponse + +class DeleteActivityExecutionRequest(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + NAMESPACE_FIELD_NUMBER: builtins.int + ACTIVITY_ID_FIELD_NUMBER: builtins.int + RUN_ID_FIELD_NUMBER: builtins.int + namespace: builtins.str + activity_id: builtins.str + run_id: builtins.str + """Activity run ID, targets the latest run if run_id is empty.""" + def __init__( + self, + *, + namespace: builtins.str = ..., + activity_id: builtins.str = ..., + run_id: builtins.str = ..., + ) -> None: ... + def ClearField( + self, + field_name: typing_extensions.Literal[ + "activity_id", + b"activity_id", + "namespace", + b"namespace", + "run_id", + b"run_id", + ], + ) -> None: ... + +global___DeleteActivityExecutionRequest = DeleteActivityExecutionRequest + +class DeleteActivityExecutionResponse(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +global___DeleteActivityExecutionResponse = DeleteActivityExecutionResponse diff --git a/temporalio/api/workflowservice/v1/service_pb2.py b/temporalio/api/workflowservice/v1/service_pb2.py index fd664f39f..2b5cfd5f4 100644 --- a/temporalio/api/workflowservice/v1/service_pb2.py +++ b/temporalio/api/workflowservice/v1/service_pb2.py @@ -21,7 +21,7 @@ ) DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile( - b'\n-temporal/api/workflowservice/v1/service.proto\x12\x1ftemporal.api.workflowservice.v1\x1a\x36temporal/api/workflowservice/v1/request_response.proto\x1a\x1cgoogle/api/annotations.proto2\xfb\xc1\x01\n\x0fWorkflowService\x12\xc3\x01\n\x11RegisterNamespace\x12\x39.temporal.api.workflowservice.v1.RegisterNamespaceRequest\x1a:.temporal.api.workflowservice.v1.RegisterNamespaceResponse"7\x82\xd3\xe4\x93\x02\x31"\x13/cluster/namespaces:\x01*Z\x17"\x12/api/v1/namespaces:\x01*\x12\xd5\x01\n\x11\x44\x65scribeNamespace\x12\x39.temporal.api.workflowservice.v1.DescribeNamespaceRequest\x1a:.temporal.api.workflowservice.v1.DescribeNamespaceResponse"I\x82\xd3\xe4\x93\x02\x43\x12\x1f/cluster/namespaces/{namespace}Z \x12\x1e/api/v1/namespaces/{namespace}\x12\xb4\x01\n\x0eListNamespaces\x12\x36.temporal.api.workflowservice.v1.ListNamespacesRequest\x1a\x37.temporal.api.workflowservice.v1.ListNamespacesResponse"1\x82\xd3\xe4\x93\x02+\x12\x13/cluster/namespacesZ\x14\x12\x12/api/v1/namespaces\x12\xe3\x01\n\x0fUpdateNamespace\x12\x37.temporal.api.workflowservice.v1.UpdateNamespaceRequest\x1a\x38.temporal.api.workflowservice.v1.UpdateNamespaceResponse"]\x82\xd3\xe4\x93\x02W"&/cluster/namespaces/{namespace}/update:\x01*Z*"%/api/v1/namespaces/{namespace}/update:\x01*\x12\x8f\x01\n\x12\x44\x65precateNamespace\x12:.temporal.api.workflowservice.v1.DeprecateNamespaceRequest\x1a;.temporal.api.workflowservice.v1.DeprecateNamespaceResponse"\x00\x12\x92\x02\n\x16StartWorkflowExecution\x12>.temporal.api.workflowservice.v1.StartWorkflowExecutionRequest\x1a?.temporal.api.workflowservice.v1.StartWorkflowExecutionResponse"w\x82\xd3\xe4\x93\x02q"//namespaces/{namespace}/workflows/{workflow_id}:\x01*Z;"6/api/v1/namespaces/{namespace}/workflows/{workflow_id}:\x01*\x12\xa5\x02\n\x15\x45xecuteMultiOperation\x12=.temporal.api.workflowservice.v1.ExecuteMultiOperationRequest\x1a>.temporal.api.workflowservice.v1.ExecuteMultiOperationResponse"\x8c\x01\x82\xd3\xe4\x93\x02\x85\x01"9/namespaces/{namespace}/workflows/execute-multi-operation:\x01*ZE"@/api/v1/namespaces/{namespace}/workflows/execute-multi-operation:\x01*\x12\xc1\x02\n\x1bGetWorkflowExecutionHistory\x12\x43.temporal.api.workflowservice.v1.GetWorkflowExecutionHistoryRequest\x1a\x44.temporal.api.workflowservice.v1.GetWorkflowExecutionHistoryResponse"\x96\x01\x82\xd3\xe4\x93\x02\x8f\x01\x12\x41/namespaces/{namespace}/workflows/{execution.workflow_id}/historyZJ\x12H/api/v1/namespaces/{namespace}/workflows/{execution.workflow_id}/history\x12\xe6\x02\n"GetWorkflowExecutionHistoryReverse\x12J.temporal.api.workflowservice.v1.GetWorkflowExecutionHistoryReverseRequest\x1aK.temporal.api.workflowservice.v1.GetWorkflowExecutionHistoryReverseResponse"\xa6\x01\x82\xd3\xe4\x93\x02\x9f\x01\x12I/namespaces/{namespace}/workflows/{execution.workflow_id}/history-reverseZR\x12P/api/v1/namespaces/{namespace}/workflows/{execution.workflow_id}/history-reverse\x12\x98\x01\n\x15PollWorkflowTaskQueue\x12=.temporal.api.workflowservice.v1.PollWorkflowTaskQueueRequest\x1a>.temporal.api.workflowservice.v1.PollWorkflowTaskQueueResponse"\x00\x12\xad\x01\n\x1cRespondWorkflowTaskCompleted\x12\x44.temporal.api.workflowservice.v1.RespondWorkflowTaskCompletedRequest\x1a\x45.temporal.api.workflowservice.v1.RespondWorkflowTaskCompletedResponse"\x00\x12\xa4\x01\n\x19RespondWorkflowTaskFailed\x12\x41.temporal.api.workflowservice.v1.RespondWorkflowTaskFailedRequest\x1a\x42.temporal.api.workflowservice.v1.RespondWorkflowTaskFailedResponse"\x00\x12\x98\x01\n\x15PollActivityTaskQueue\x12=.temporal.api.workflowservice.v1.PollActivityTaskQueueRequest\x1a>.temporal.api.workflowservice.v1.PollActivityTaskQueueResponse"\x00\x12\x9b\x02\n\x1bRecordActivityTaskHeartbeat\x12\x43.temporal.api.workflowservice.v1.RecordActivityTaskHeartbeatRequest\x1a\x44.temporal.api.workflowservice.v1.RecordActivityTaskHeartbeatResponse"q\x82\xd3\xe4\x93\x02k",/namespaces/{namespace}/activities/heartbeat:\x01*Z8"3/api/v1/namespaces/{namespace}/activities/heartbeat:\x01*\x12\xb3\x02\n\x1fRecordActivityTaskHeartbeatById\x12G.temporal.api.workflowservice.v1.RecordActivityTaskHeartbeatByIdRequest\x1aH.temporal.api.workflowservice.v1.RecordActivityTaskHeartbeatByIdResponse"}\x82\xd3\xe4\x93\x02w"2/namespaces/{namespace}/activities/heartbeat-by-id:\x01*Z>"9/api/v1/namespaces/{namespace}/activities/heartbeat-by-id:\x01*\x12\x9c\x02\n\x1cRespondActivityTaskCompleted\x12\x44.temporal.api.workflowservice.v1.RespondActivityTaskCompletedRequest\x1a\x45.temporal.api.workflowservice.v1.RespondActivityTaskCompletedResponse"o\x82\xd3\xe4\x93\x02i"+/namespaces/{namespace}/activities/complete:\x01*Z7"2/api/v1/namespaces/{namespace}/activities/complete:\x01*\x12\xb4\x02\n RespondActivityTaskCompletedById\x12H.temporal.api.workflowservice.v1.RespondActivityTaskCompletedByIdRequest\x1aI.temporal.api.workflowservice.v1.RespondActivityTaskCompletedByIdResponse"{\x82\xd3\xe4\x93\x02u"1/namespaces/{namespace}/activities/complete-by-id:\x01*Z="8/api/v1/namespaces/{namespace}/activities/complete-by-id:\x01*\x12\x8b\x02\n\x19RespondActivityTaskFailed\x12\x41.temporal.api.workflowservice.v1.RespondActivityTaskFailedRequest\x1a\x42.temporal.api.workflowservice.v1.RespondActivityTaskFailedResponse"g\x82\xd3\xe4\x93\x02\x61"\'/namespaces/{namespace}/activities/fail:\x01*Z3"./api/v1/namespaces/{namespace}/activities/fail:\x01*\x12\xa3\x02\n\x1dRespondActivityTaskFailedById\x12\x45.temporal.api.workflowservice.v1.RespondActivityTaskFailedByIdRequest\x1a\x46.temporal.api.workflowservice.v1.RespondActivityTaskFailedByIdResponse"s\x82\xd3\xe4\x93\x02m"-/namespaces/{namespace}/activities/fail-by-id:\x01*Z9"4/api/v1/namespaces/{namespace}/activities/fail-by-id:\x01*\x12\x95\x02\n\x1bRespondActivityTaskCanceled\x12\x43.temporal.api.workflowservice.v1.RespondActivityTaskCanceledRequest\x1a\x44.temporal.api.workflowservice.v1.RespondActivityTaskCanceledResponse"k\x82\xd3\xe4\x93\x02\x65")/namespaces/{namespace}/activities/cancel:\x01*Z5"0/api/v1/namespaces/{namespace}/activities/cancel:\x01*\x12\xad\x02\n\x1fRespondActivityTaskCanceledById\x12G.temporal.api.workflowservice.v1.RespondActivityTaskCanceledByIdRequest\x1aH.temporal.api.workflowservice.v1.RespondActivityTaskCanceledByIdResponse"w\x82\xd3\xe4\x93\x02q"//namespaces/{namespace}/activities/cancel-by-id:\x01*Z;"6/api/v1/namespaces/{namespace}/activities/cancel-by-id:\x01*\x12\xe0\x02\n\x1eRequestCancelWorkflowExecution\x12\x46.temporal.api.workflowservice.v1.RequestCancelWorkflowExecutionRequest\x1aG.temporal.api.workflowservice.v1.RequestCancelWorkflowExecutionResponse"\xac\x01\x82\xd3\xe4\x93\x02\xa5\x01"I/namespaces/{namespace}/workflows/{workflow_execution.workflow_id}/cancel:\x01*ZU"P/api/v1/namespaces/{namespace}/workflows/{workflow_execution.workflow_id}/cancel:\x01*\x12\xe7\x02\n\x17SignalWorkflowExecution\x12?.temporal.api.workflowservice.v1.SignalWorkflowExecutionRequest\x1a@.temporal.api.workflowservice.v1.SignalWorkflowExecutionResponse"\xc8\x01\x82\xd3\xe4\x93\x02\xc1\x01"W/namespaces/{namespace}/workflows/{workflow_execution.workflow_id}/signal/{signal_name}:\x01*Zc"^/api/v1/namespaces/{namespace}/workflows/{workflow_execution.workflow_id}/signal/{signal_name}:\x01*\x12\xf2\x02\n SignalWithStartWorkflowExecution\x12H.temporal.api.workflowservice.v1.SignalWithStartWorkflowExecutionRequest\x1aI.temporal.api.workflowservice.v1.SignalWithStartWorkflowExecutionResponse"\xb8\x01\x82\xd3\xe4\x93\x02\xb1\x01"O/namespaces/{namespace}/workflows/{workflow_id}/signal-with-start/{signal_name}:\x01*Z["V/api/v1/namespaces/{namespace}/workflows/{workflow_id}/signal-with-start/{signal_name}:\x01*\x12\xc6\x02\n\x16ResetWorkflowExecution\x12>.temporal.api.workflowservice.v1.ResetWorkflowExecutionRequest\x1a?.temporal.api.workflowservice.v1.ResetWorkflowExecutionResponse"\xaa\x01\x82\xd3\xe4\x93\x02\xa3\x01"H/namespaces/{namespace}/workflows/{workflow_execution.workflow_id}/reset:\x01*ZT"O/api/v1/namespaces/{namespace}/workflows/{workflow_execution.workflow_id}/reset:\x01*\x12\xda\x02\n\x1aTerminateWorkflowExecution\x12\x42.temporal.api.workflowservice.v1.TerminateWorkflowExecutionRequest\x1a\x43.temporal.api.workflowservice.v1.TerminateWorkflowExecutionResponse"\xb2\x01\x82\xd3\xe4\x93\x02\xab\x01"L/namespaces/{namespace}/workflows/{workflow_execution.workflow_id}/terminate:\x01*ZX"S/api/v1/namespaces/{namespace}/workflows/{workflow_execution.workflow_id}/terminate:\x01*\x12\x9e\x01\n\x17\x44\x65leteWorkflowExecution\x12?.temporal.api.workflowservice.v1.DeleteWorkflowExecutionRequest\x1a@.temporal.api.workflowservice.v1.DeleteWorkflowExecutionResponse"\x00\x12\xa7\x01\n\x1aListOpenWorkflowExecutions\x12\x42.temporal.api.workflowservice.v1.ListOpenWorkflowExecutionsRequest\x1a\x43.temporal.api.workflowservice.v1.ListOpenWorkflowExecutionsResponse"\x00\x12\xad\x01\n\x1cListClosedWorkflowExecutions\x12\x44.temporal.api.workflowservice.v1.ListClosedWorkflowExecutionsRequest\x1a\x45.temporal.api.workflowservice.v1.ListClosedWorkflowExecutionsResponse"\x00\x12\xf0\x01\n\x16ListWorkflowExecutions\x12>.temporal.api.workflowservice.v1.ListWorkflowExecutionsRequest\x1a?.temporal.api.workflowservice.v1.ListWorkflowExecutionsResponse"U\x82\xd3\xe4\x93\x02O\x12!/namespaces/{namespace}/workflowsZ*\x12(/api/v1/namespaces/{namespace}/workflows\x12\x9a\x02\n\x1eListArchivedWorkflowExecutions\x12\x46.temporal.api.workflowservice.v1.ListArchivedWorkflowExecutionsRequest\x1aG.temporal.api.workflowservice.v1.ListArchivedWorkflowExecutionsResponse"g\x82\xd3\xe4\x93\x02\x61\x12*/namespaces/{namespace}/archived-workflowsZ3\x12\x31/api/v1/namespaces/{namespace}/archived-workflows\x12\x9b\x01\n\x16ScanWorkflowExecutions\x12>.temporal.api.workflowservice.v1.ScanWorkflowExecutionsRequest\x1a?.temporal.api.workflowservice.v1.ScanWorkflowExecutionsResponse"\x00\x12\xfd\x01\n\x17\x43ountWorkflowExecutions\x12?.temporal.api.workflowservice.v1.CountWorkflowExecutionsRequest\x1a@.temporal.api.workflowservice.v1.CountWorkflowExecutionsResponse"_\x82\xd3\xe4\x93\x02Y\x12&/namespaces/{namespace}/workflow-countZ/\x12-/api/v1/namespaces/{namespace}/workflow-count\x12\x92\x01\n\x13GetSearchAttributes\x12;.temporal.api.workflowservice.v1.GetSearchAttributesRequest\x1a<.temporal.api.workflowservice.v1.GetSearchAttributesResponse"\x00\x12\xa4\x01\n\x19RespondQueryTaskCompleted\x12\x41.temporal.api.workflowservice.v1.RespondQueryTaskCompletedRequest\x1a\x42.temporal.api.workflowservice.v1.RespondQueryTaskCompletedResponse"\x00\x12\x95\x01\n\x14ResetStickyTaskQueue\x12<.temporal.api.workflowservice.v1.ResetStickyTaskQueueRequest\x1a=.temporal.api.workflowservice.v1.ResetStickyTaskQueueResponse"\x00\x12\x83\x01\n\x0eShutdownWorker\x12\x36.temporal.api.workflowservice.v1.ShutdownWorkerRequest\x1a\x37.temporal.api.workflowservice.v1.ShutdownWorkerResponse"\x00\x12\xbf\x02\n\rQueryWorkflow\x12\x35.temporal.api.workflowservice.v1.QueryWorkflowRequest\x1a\x36.temporal.api.workflowservice.v1.QueryWorkflowResponse"\xbe\x01\x82\xd3\xe4\x93\x02\xb7\x01"R/namespaces/{namespace}/workflows/{execution.workflow_id}/query/{query.query_type}:\x01*Z^"Y/api/v1/namespaces/{namespace}/workflows/{execution.workflow_id}/query/{query.query_type}:\x01*\x12\xaa\x02\n\x19\x44\x65scribeWorkflowExecution\x12\x41.temporal.api.workflowservice.v1.DescribeWorkflowExecutionRequest\x1a\x42.temporal.api.workflowservice.v1.DescribeWorkflowExecutionResponse"\x85\x01\x82\xd3\xe4\x93\x02\x7f\x12\x39/namespaces/{namespace}/workflows/{execution.workflow_id}ZB\x12@/api/v1/namespaces/{namespace}/workflows/{execution.workflow_id}\x12\x89\x02\n\x11\x44\x65scribeTaskQueue\x12\x39.temporal.api.workflowservice.v1.DescribeTaskQueueRequest\x1a:.temporal.api.workflowservice.v1.DescribeTaskQueueResponse"}\x82\xd3\xe4\x93\x02w\x12\x35/namespaces/{namespace}/task-queues/{task_queue.name}Z>\x12/namespaces/{namespace}/schedules/{schedule_id}/matching-timesZG\x12\x45/api/v1/namespaces/{namespace}/schedules/{schedule_id}/matching-times\x12\xf4\x01\n\x0e\x44\x65leteSchedule\x12\x36.temporal.api.workflowservice.v1.DeleteScheduleRequest\x1a\x37.temporal.api.workflowservice.v1.DeleteScheduleResponse"q\x82\xd3\xe4\x93\x02k*//namespaces/{namespace}/schedules/{schedule_id}Z8*6/api/v1/namespaces/{namespace}/schedules/{schedule_id}\x12\xd5\x01\n\rListSchedules\x12\x35.temporal.api.workflowservice.v1.ListSchedulesRequest\x1a\x36.temporal.api.workflowservice.v1.ListSchedulesResponse"U\x82\xd3\xe4\x93\x02O\x12!/namespaces/{namespace}/schedulesZ*\x12(/api/v1/namespaces/{namespace}/schedules\x12\xb9\x01\n UpdateWorkerBuildIdCompatibility\x12H.temporal.api.workflowservice.v1.UpdateWorkerBuildIdCompatibilityRequest\x1aI.temporal.api.workflowservice.v1.UpdateWorkerBuildIdCompatibilityResponse"\x00\x12\xe1\x02\n\x1dGetWorkerBuildIdCompatibility\x12\x45.temporal.api.workflowservice.v1.GetWorkerBuildIdCompatibilityRequest\x1a\x46.temporal.api.workflowservice.v1.GetWorkerBuildIdCompatibilityResponse"\xb0\x01\x82\xd3\xe4\x93\x02\xa9\x01\x12N/namespaces/{namespace}/task-queues/{task_queue}/worker-build-id-compatibilityZW\x12U/api/v1/namespaces/{namespace}/task-queues/{task_queue}/worker-build-id-compatibility\x12\xaa\x01\n\x1bUpdateWorkerVersioningRules\x12\x43.temporal.api.workflowservice.v1.UpdateWorkerVersioningRulesRequest\x1a\x44.temporal.api.workflowservice.v1.UpdateWorkerVersioningRulesResponse"\x00\x12\xc6\x02\n\x18GetWorkerVersioningRules\x12@.temporal.api.workflowservice.v1.GetWorkerVersioningRulesRequest\x1a\x41.temporal.api.workflowservice.v1.GetWorkerVersioningRulesResponse"\xa4\x01\x82\xd3\xe4\x93\x02\x9d\x01\x12H/namespaces/{namespace}/task-queues/{task_queue}/worker-versioning-rulesZQ\x12O/api/v1/namespaces/{namespace}/task-queues/{task_queue}/worker-versioning-rules\x12\x97\x02\n\x19GetWorkerTaskReachability\x12\x41.temporal.api.workflowservice.v1.GetWorkerTaskReachabilityRequest\x1a\x42.temporal.api.workflowservice.v1.GetWorkerTaskReachabilityResponse"s\x82\xd3\xe4\x93\x02m\x12\x30/namespaces/{namespace}/worker-task-reachabilityZ9\x12\x37/api/v1/namespaces/{namespace}/worker-task-reachability\x12\xc8\x02\n\x12\x44\x65scribeDeployment\x12:.temporal.api.workflowservice.v1.DescribeDeploymentRequest\x1a;.temporal.api.workflowservice.v1.DescribeDeploymentResponse"\xb8\x01\x82\xd3\xe4\x93\x02\xb1\x01\x12R/namespaces/{namespace}/deployments/{deployment.series_name}/{deployment.build_id}Z[\x12Y/api/v1/namespaces/{namespace}/deployments/{deployment.series_name}/{deployment.build_id}\x12\xb5\x03\n\x1f\x44\x65scribeWorkerDeploymentVersion\x12G.temporal.api.workflowservice.v1.DescribeWorkerDeploymentVersionRequest\x1aH.temporal.api.workflowservice.v1.DescribeWorkerDeploymentVersionResponse"\xfe\x01\x82\xd3\xe4\x93\x02\xf7\x01\x12u/namespaces/{namespace}/worker-deployment-versions/{deployment_version.deployment_name}/{deployment_version.build_id}Z~\x12|/api/v1/namespaces/{namespace}/worker-deployment-versions/{deployment_version.deployment_name}/{deployment_version.build_id}\x12\xdf\x01\n\x0fListDeployments\x12\x37.temporal.api.workflowservice.v1.ListDeploymentsRequest\x1a\x38.temporal.api.workflowservice.v1.ListDeploymentsResponse"Y\x82\xd3\xe4\x93\x02S\x12#/namespaces/{namespace}/deploymentsZ,\x12*/api/v1/namespaces/{namespace}/deployments\x12\xf7\x02\n\x19GetDeploymentReachability\x12\x41.temporal.api.workflowservice.v1.GetDeploymentReachabilityRequest\x1a\x42.temporal.api.workflowservice.v1.GetDeploymentReachabilityResponse"\xd2\x01\x82\xd3\xe4\x93\x02\xcb\x01\x12_/namespaces/{namespace}/deployments/{deployment.series_name}/{deployment.build_id}/reachabilityZh\x12\x66/api/v1/namespaces/{namespace}/deployments/{deployment.series_name}/{deployment.build_id}/reachability\x12\x99\x02\n\x14GetCurrentDeployment\x12<.temporal.api.workflowservice.v1.GetCurrentDeploymentRequest\x1a=.temporal.api.workflowservice.v1.GetCurrentDeploymentResponse"\x83\x01\x82\xd3\xe4\x93\x02}\x12\x38/namespaces/{namespace}/current-deployment/{series_name}ZA\x12?/api/v1/namespaces/{namespace}/current-deployment/{series_name}\x12\xb6\x02\n\x14SetCurrentDeployment\x12<.temporal.api.workflowservice.v1.SetCurrentDeploymentRequest\x1a=.temporal.api.workflowservice.v1.SetCurrentDeploymentResponse"\xa0\x01\x82\xd3\xe4\x93\x02\x99\x01"C/namespaces/{namespace}/current-deployment/{deployment.series_name}:\x01*ZO"J/api/v1/namespaces/{namespace}/current-deployment/{deployment.series_name}:\x01*\x12\xf7\x02\n!SetWorkerDeploymentCurrentVersion\x12I.temporal.api.workflowservice.v1.SetWorkerDeploymentCurrentVersionRequest\x1aJ.temporal.api.workflowservice.v1.SetWorkerDeploymentCurrentVersionResponse"\xba\x01\x82\xd3\xe4\x93\x02\xb3\x01"P/namespaces/{namespace}/worker-deployments/{deployment_name}/set-current-version:\x01*Z\\"W/api/v1/namespaces/{namespace}/worker-deployments/{deployment_name}/set-current-version:\x01*\x12\xae\x02\n\x18\x44\x65scribeWorkerDeployment\x12@.temporal.api.workflowservice.v1.DescribeWorkerDeploymentRequest\x1a\x41.temporal.api.workflowservice.v1.DescribeWorkerDeploymentResponse"\x8c\x01\x82\xd3\xe4\x93\x02\x85\x01\x12.temporal.api.workflowservice.v1.DeleteWorkerDeploymentRequest\x1a?.temporal.api.workflowservice.v1.DeleteWorkerDeploymentResponse"\x8c\x01\x82\xd3\xe4\x93\x02\x85\x01*.temporal.api.workflowservice.v1.ListWorkerDeploymentsResponse"g\x82\xd3\xe4\x93\x02\x61\x12*/namespaces/{namespace}/worker-deploymentsZ3\x12\x31/api/v1/namespaces/{namespace}/worker-deployments\x12\xf0\x03\n%UpdateWorkerDeploymentVersionMetadata\x12M.temporal.api.workflowservice.v1.UpdateWorkerDeploymentVersionMetadataRequest\x1aN.temporal.api.workflowservice.v1.UpdateWorkerDeploymentVersionMetadataResponse"\xa7\x02\x82\xd3\xe4\x93\x02\xa0\x02"\x85\x01/namespaces/{namespace}/worker-deployment-versions/{deployment_version.deployment_name}/{deployment_version.build_id}/update-metadata:\x01*Z\x92\x01"\x8c\x01/api/v1/namespaces/{namespace}/worker-deployment-versions/{deployment_version.deployment_name}/{deployment_version.build_id}/update-metadata:\x01*\x12\xd2\x02\n\x1aSetWorkerDeploymentManager\x12\x42.temporal.api.workflowservice.v1.SetWorkerDeploymentManagerRequest\x1a\x43.temporal.api.workflowservice.v1.SetWorkerDeploymentManagerResponse"\xaa\x01\x82\xd3\xe4\x93\x02\xa3\x01"H/namespaces/{namespace}/worker-deployments/{deployment_name}/set-manager:\x01*ZT"O/api/v1/namespaces/{namespace}/worker-deployments/{deployment_name}/set-manager:\x01*\x12\xf5\x02\n\x17UpdateWorkflowExecution\x12?.temporal.api.workflowservice.v1.UpdateWorkflowExecutionRequest\x1a@.temporal.api.workflowservice.v1.UpdateWorkflowExecutionResponse"\xd6\x01\x82\xd3\xe4\x93\x02\xcf\x01"^/namespaces/{namespace}/workflows/{workflow_execution.workflow_id}/update/{request.input.name}:\x01*Zj"e/api/v1/namespaces/{namespace}/workflows/{workflow_execution.workflow_id}/update/{request.input.name}:\x01*\x12\xaa\x01\n\x1bPollWorkflowExecutionUpdate\x12\x43.temporal.api.workflowservice.v1.PollWorkflowExecutionUpdateRequest\x1a\x44.temporal.api.workflowservice.v1.PollWorkflowExecutionUpdateResponse"\x00\x12\x8d\x02\n\x13StartBatchOperation\x12;.temporal.api.workflowservice.v1.StartBatchOperationRequest\x1a<.temporal.api.workflowservice.v1.StartBatchOperationResponse"{\x82\xd3\xe4\x93\x02u"1/namespaces/{namespace}/batch-operations/{job_id}:\x01*Z="8/api/v1/namespaces/{namespace}/batch-operations/{job_id}:\x01*\x12\x95\x02\n\x12StopBatchOperation\x12:.temporal.api.workflowservice.v1.StopBatchOperationRequest\x1a;.temporal.api.workflowservice.v1.StopBatchOperationResponse"\x85\x01\x82\xd3\xe4\x93\x02\x7f"6/namespaces/{namespace}/batch-operations/{job_id}/stop:\x01*ZB"=/api/v1/namespaces/{namespace}/batch-operations/{job_id}/stop:\x01*\x12\x90\x02\n\x16\x44\x65scribeBatchOperation\x12>.temporal.api.workflowservice.v1.DescribeBatchOperationRequest\x1a?.temporal.api.workflowservice.v1.DescribeBatchOperationResponse"u\x82\xd3\xe4\x93\x02o\x12\x31/namespaces/{namespace}/batch-operations/{job_id}Z:\x12\x38/api/v1/namespaces/{namespace}/batch-operations/{job_id}\x12\xf5\x01\n\x13ListBatchOperations\x12;.temporal.api.workflowservice.v1.ListBatchOperationsRequest\x1a<.temporal.api.workflowservice.v1.ListBatchOperationsResponse"c\x82\xd3\xe4\x93\x02]\x12(/namespaces/{namespace}/batch-operationsZ1\x12//api/v1/namespaces/{namespace}/batch-operations\x12\x8f\x01\n\x12PollNexusTaskQueue\x12:.temporal.api.workflowservice.v1.PollNexusTaskQueueRequest\x1a;.temporal.api.workflowservice.v1.PollNexusTaskQueueResponse"\x00\x12\xa4\x01\n\x19RespondNexusTaskCompleted\x12\x41.temporal.api.workflowservice.v1.RespondNexusTaskCompletedRequest\x1a\x42.temporal.api.workflowservice.v1.RespondNexusTaskCompletedResponse"\x00\x12\x9b\x01\n\x16RespondNexusTaskFailed\x12>.temporal.api.workflowservice.v1.RespondNexusTaskFailedRequest\x1a?.temporal.api.workflowservice.v1.RespondNexusTaskFailedResponse"\x00\x12\x93\x02\n\x15UpdateActivityOptions\x12=.temporal.api.workflowservice.v1.UpdateActivityOptionsRequest\x1a>.temporal.api.workflowservice.v1.UpdateActivityOptionsResponse"{\x82\xd3\xe4\x93\x02u"1/namespaces/{namespace}/activities/update-options:\x01*Z="8/api/v1/namespaces/{namespace}/activities/update-options:\x01*\x12\xf0\x02\n\x1eUpdateWorkflowExecutionOptions\x12\x46.temporal.api.workflowservice.v1.UpdateWorkflowExecutionOptionsRequest\x1aG.temporal.api.workflowservice.v1.UpdateWorkflowExecutionOptionsResponse"\xbc\x01\x82\xd3\xe4\x93\x02\xb5\x01"Q/namespaces/{namespace}/workflows/{workflow_execution.workflow_id}/update-options:\x01*Z]"X/api/v1/namespaces/{namespace}/workflows/{workflow_execution.workflow_id}/update-options:\x01*\x12\xe9\x01\n\rPauseActivity\x12\x35.temporal.api.workflowservice.v1.PauseActivityRequest\x1a\x36.temporal.api.workflowservice.v1.PauseActivityResponse"i\x82\xd3\xe4\x93\x02\x63"(/namespaces/{namespace}/activities/pause:\x01*Z4"//api/v1/namespaces/{namespace}/activities/pause:\x01*\x12\xf3\x01\n\x0fUnpauseActivity\x12\x37.temporal.api.workflowservice.v1.UnpauseActivityRequest\x1a\x38.temporal.api.workflowservice.v1.UnpauseActivityResponse"m\x82\xd3\xe4\x93\x02g"*/namespaces/{namespace}/activities/unpause:\x01*Z6"1/api/v1/namespaces/{namespace}/activities/unpause:\x01*\x12\xe9\x01\n\rResetActivity\x12\x35.temporal.api.workflowservice.v1.ResetActivityRequest\x1a\x36.temporal.api.workflowservice.v1.ResetActivityResponse"i\x82\xd3\xe4\x93\x02\x63"(/namespaces/{namespace}/activities/reset:\x01*Z4"//api/v1/namespaces/{namespace}/activities/reset:\x01*\x12\xf4\x01\n\x12\x43reateWorkflowRule\x12:.temporal.api.workflowservice.v1.CreateWorkflowRuleRequest\x1a;.temporal.api.workflowservice.v1.CreateWorkflowRuleResponse"e\x82\xd3\xe4\x93\x02_"&/namespaces/{namespace}/workflow-rules:\x01*Z2"-/api/v1/namespaces/{namespace}/workflow-rules:\x01*\x12\x88\x02\n\x14\x44\x65scribeWorkflowRule\x12<.temporal.api.workflowservice.v1.DescribeWorkflowRuleRequest\x1a=.temporal.api.workflowservice.v1.DescribeWorkflowRuleResponse"s\x82\xd3\xe4\x93\x02m\x12\x30/namespaces/{namespace}/workflow-rules/{rule_id}Z9\x12\x37/api/v1/namespaces/{namespace}/workflow-rules/{rule_id}\x12\x82\x02\n\x12\x44\x65leteWorkflowRule\x12:.temporal.api.workflowservice.v1.DeleteWorkflowRuleRequest\x1a;.temporal.api.workflowservice.v1.DeleteWorkflowRuleResponse"s\x82\xd3\xe4\x93\x02m*0/namespaces/{namespace}/workflow-rules/{rule_id}Z9*7/api/v1/namespaces/{namespace}/workflow-rules/{rule_id}\x12\xeb\x01\n\x11ListWorkflowRules\x12\x39.temporal.api.workflowservice.v1.ListWorkflowRulesRequest\x1a:.temporal.api.workflowservice.v1.ListWorkflowRulesResponse"_\x82\xd3\xe4\x93\x02Y\x12&/namespaces/{namespace}/workflow-rulesZ/\x12-/api/v1/namespaces/{namespace}/workflow-rules\x12\xb9\x02\n\x13TriggerWorkflowRule\x12;.temporal.api.workflowservice.v1.TriggerWorkflowRuleRequest\x1a<.temporal.api.workflowservice.v1.TriggerWorkflowRuleResponse"\xa6\x01\x82\xd3\xe4\x93\x02\x9f\x01"F/namespaces/{namespace}/workflows/{execution.workflow_id}/trigger-rule:\x01*ZR"M/api/v1/namespaces/{namespace}/workflows/{execution.workflow_id}/trigger-rule:\x01*\x12\x83\x02\n\x15RecordWorkerHeartbeat\x12=.temporal.api.workflowservice.v1.RecordWorkerHeartbeatRequest\x1a>.temporal.api.workflowservice.v1.RecordWorkerHeartbeatResponse"k\x82\xd3\xe4\x93\x02\x65")/namespaces/{namespace}/workers/heartbeat:\x01*Z5"0/api/v1/namespaces/{namespace}/workers/heartbeat:\x01*\x12\xcb\x01\n\x0bListWorkers\x12\x33.temporal.api.workflowservice.v1.ListWorkersRequest\x1a\x34.temporal.api.workflowservice.v1.ListWorkersResponse"Q\x82\xd3\xe4\x93\x02K\x12\x1f/namespaces/{namespace}/workersZ(\x12&/api/v1/namespaces/{namespace}/workers\x12\xaf\x02\n\x15UpdateTaskQueueConfig\x12=.temporal.api.workflowservice.v1.UpdateTaskQueueConfigRequest\x1a>.temporal.api.workflowservice.v1.UpdateTaskQueueConfigResponse"\x96\x01\x82\xd3\xe4\x93\x02\x8f\x01">/namespaces/{namespace}/task-queues/{task_queue}/update-config:\x01*ZJ"E/api/v1/namespaces/{namespace}/task-queues/{task_queue}/update-config:\x01*\x12\xfd\x01\n\x11\x46\x65tchWorkerConfig\x12\x39.temporal.api.workflowservice.v1.FetchWorkerConfigRequest\x1a:.temporal.api.workflowservice.v1.FetchWorkerConfigResponse"q\x82\xd3\xe4\x93\x02k",/namespaces/{namespace}/workers/fetch-config:\x01*Z8"3/api/v1/namespaces/{namespace}/workers/fetch-config:\x01*\x12\x82\x02\n\x12UpdateWorkerConfig\x12:.temporal.api.workflowservice.v1.UpdateWorkerConfigRequest\x1a;.temporal.api.workflowservice.v1.UpdateWorkerConfigResponse"s\x82\xd3\xe4\x93\x02m"-/namespaces/{namespace}/workers/update-config:\x01*Z9"4/api/v1/namespaces/{namespace}/workers/update-config:\x01*\x12\x94\x02\n\x0e\x44\x65scribeWorker\x12\x36.temporal.api.workflowservice.v1.DescribeWorkerRequest\x1a\x37.temporal.api.workflowservice.v1.DescribeWorkerResponse"\x90\x01\x82\xd3\xe4\x93\x02\x89\x01\x12>/namespaces/{namespace}/workers/describe/{worker_instance_key}ZG\x12\x45/api/v1/namespaces/{namespace}/workers/describe/{worker_instance_key}B\xb6\x01\n"io.temporal.api.workflowservice.v1B\x0cServiceProtoP\x01Z5go.temporal.io/api/workflowservice/v1;workflowservice\xaa\x02!Temporalio.Api.WorkflowService.V1\xea\x02$Temporalio::Api::WorkflowService::V1b\x06proto3' + b'\n-temporal/api/workflowservice/v1/service.proto\x12\x1ftemporal.api.workflowservice.v1\x1a\x36temporal/api/workflowservice/v1/request_response.proto\x1a\x1cgoogle/api/annotations.proto2\xd9\xd2\x01\n\x0fWorkflowService\x12\xc3\x01\n\x11RegisterNamespace\x12\x39.temporal.api.workflowservice.v1.RegisterNamespaceRequest\x1a:.temporal.api.workflowservice.v1.RegisterNamespaceResponse"7\x82\xd3\xe4\x93\x02\x31"\x13/cluster/namespaces:\x01*Z\x17"\x12/api/v1/namespaces:\x01*\x12\xd5\x01\n\x11\x44\x65scribeNamespace\x12\x39.temporal.api.workflowservice.v1.DescribeNamespaceRequest\x1a:.temporal.api.workflowservice.v1.DescribeNamespaceResponse"I\x82\xd3\xe4\x93\x02\x43\x12\x1f/cluster/namespaces/{namespace}Z \x12\x1e/api/v1/namespaces/{namespace}\x12\xb4\x01\n\x0eListNamespaces\x12\x36.temporal.api.workflowservice.v1.ListNamespacesRequest\x1a\x37.temporal.api.workflowservice.v1.ListNamespacesResponse"1\x82\xd3\xe4\x93\x02+\x12\x13/cluster/namespacesZ\x14\x12\x12/api/v1/namespaces\x12\xe3\x01\n\x0fUpdateNamespace\x12\x37.temporal.api.workflowservice.v1.UpdateNamespaceRequest\x1a\x38.temporal.api.workflowservice.v1.UpdateNamespaceResponse"]\x82\xd3\xe4\x93\x02W"&/cluster/namespaces/{namespace}/update:\x01*Z*"%/api/v1/namespaces/{namespace}/update:\x01*\x12\x8f\x01\n\x12\x44\x65precateNamespace\x12:.temporal.api.workflowservice.v1.DeprecateNamespaceRequest\x1a;.temporal.api.workflowservice.v1.DeprecateNamespaceResponse"\x00\x12\x92\x02\n\x16StartWorkflowExecution\x12>.temporal.api.workflowservice.v1.StartWorkflowExecutionRequest\x1a?.temporal.api.workflowservice.v1.StartWorkflowExecutionResponse"w\x82\xd3\xe4\x93\x02q"//namespaces/{namespace}/workflows/{workflow_id}:\x01*Z;"6/api/v1/namespaces/{namespace}/workflows/{workflow_id}:\x01*\x12\xa5\x02\n\x15\x45xecuteMultiOperation\x12=.temporal.api.workflowservice.v1.ExecuteMultiOperationRequest\x1a>.temporal.api.workflowservice.v1.ExecuteMultiOperationResponse"\x8c\x01\x82\xd3\xe4\x93\x02\x85\x01"9/namespaces/{namespace}/workflows/execute-multi-operation:\x01*ZE"@/api/v1/namespaces/{namespace}/workflows/execute-multi-operation:\x01*\x12\xc1\x02\n\x1bGetWorkflowExecutionHistory\x12\x43.temporal.api.workflowservice.v1.GetWorkflowExecutionHistoryRequest\x1a\x44.temporal.api.workflowservice.v1.GetWorkflowExecutionHistoryResponse"\x96\x01\x82\xd3\xe4\x93\x02\x8f\x01\x12\x41/namespaces/{namespace}/workflows/{execution.workflow_id}/historyZJ\x12H/api/v1/namespaces/{namespace}/workflows/{execution.workflow_id}/history\x12\xe6\x02\n"GetWorkflowExecutionHistoryReverse\x12J.temporal.api.workflowservice.v1.GetWorkflowExecutionHistoryReverseRequest\x1aK.temporal.api.workflowservice.v1.GetWorkflowExecutionHistoryReverseResponse"\xa6\x01\x82\xd3\xe4\x93\x02\x9f\x01\x12I/namespaces/{namespace}/workflows/{execution.workflow_id}/history-reverseZR\x12P/api/v1/namespaces/{namespace}/workflows/{execution.workflow_id}/history-reverse\x12\x98\x01\n\x15PollWorkflowTaskQueue\x12=.temporal.api.workflowservice.v1.PollWorkflowTaskQueueRequest\x1a>.temporal.api.workflowservice.v1.PollWorkflowTaskQueueResponse"\x00\x12\xad\x01\n\x1cRespondWorkflowTaskCompleted\x12\x44.temporal.api.workflowservice.v1.RespondWorkflowTaskCompletedRequest\x1a\x45.temporal.api.workflowservice.v1.RespondWorkflowTaskCompletedResponse"\x00\x12\xa4\x01\n\x19RespondWorkflowTaskFailed\x12\x41.temporal.api.workflowservice.v1.RespondWorkflowTaskFailedRequest\x1a\x42.temporal.api.workflowservice.v1.RespondWorkflowTaskFailedResponse"\x00\x12\x98\x01\n\x15PollActivityTaskQueue\x12=.temporal.api.workflowservice.v1.PollActivityTaskQueueRequest\x1a>.temporal.api.workflowservice.v1.PollActivityTaskQueueResponse"\x00\x12\x9b\x02\n\x1bRecordActivityTaskHeartbeat\x12\x43.temporal.api.workflowservice.v1.RecordActivityTaskHeartbeatRequest\x1a\x44.temporal.api.workflowservice.v1.RecordActivityTaskHeartbeatResponse"q\x82\xd3\xe4\x93\x02k",/namespaces/{namespace}/activities/heartbeat:\x01*Z8"3/api/v1/namespaces/{namespace}/activities/heartbeat:\x01*\x12\xb3\x02\n\x1fRecordActivityTaskHeartbeatById\x12G.temporal.api.workflowservice.v1.RecordActivityTaskHeartbeatByIdRequest\x1aH.temporal.api.workflowservice.v1.RecordActivityTaskHeartbeatByIdResponse"}\x82\xd3\xe4\x93\x02w"2/namespaces/{namespace}/activities/heartbeat-by-id:\x01*Z>"9/api/v1/namespaces/{namespace}/activities/heartbeat-by-id:\x01*\x12\x9c\x02\n\x1cRespondActivityTaskCompleted\x12\x44.temporal.api.workflowservice.v1.RespondActivityTaskCompletedRequest\x1a\x45.temporal.api.workflowservice.v1.RespondActivityTaskCompletedResponse"o\x82\xd3\xe4\x93\x02i"+/namespaces/{namespace}/activities/complete:\x01*Z7"2/api/v1/namespaces/{namespace}/activities/complete:\x01*\x12\xb4\x02\n RespondActivityTaskCompletedById\x12H.temporal.api.workflowservice.v1.RespondActivityTaskCompletedByIdRequest\x1aI.temporal.api.workflowservice.v1.RespondActivityTaskCompletedByIdResponse"{\x82\xd3\xe4\x93\x02u"1/namespaces/{namespace}/activities/complete-by-id:\x01*Z="8/api/v1/namespaces/{namespace}/activities/complete-by-id:\x01*\x12\x8b\x02\n\x19RespondActivityTaskFailed\x12\x41.temporal.api.workflowservice.v1.RespondActivityTaskFailedRequest\x1a\x42.temporal.api.workflowservice.v1.RespondActivityTaskFailedResponse"g\x82\xd3\xe4\x93\x02\x61"\'/namespaces/{namespace}/activities/fail:\x01*Z3"./api/v1/namespaces/{namespace}/activities/fail:\x01*\x12\xa3\x02\n\x1dRespondActivityTaskFailedById\x12\x45.temporal.api.workflowservice.v1.RespondActivityTaskFailedByIdRequest\x1a\x46.temporal.api.workflowservice.v1.RespondActivityTaskFailedByIdResponse"s\x82\xd3\xe4\x93\x02m"-/namespaces/{namespace}/activities/fail-by-id:\x01*Z9"4/api/v1/namespaces/{namespace}/activities/fail-by-id:\x01*\x12\x95\x02\n\x1bRespondActivityTaskCanceled\x12\x43.temporal.api.workflowservice.v1.RespondActivityTaskCanceledRequest\x1a\x44.temporal.api.workflowservice.v1.RespondActivityTaskCanceledResponse"k\x82\xd3\xe4\x93\x02\x65")/namespaces/{namespace}/activities/cancel:\x01*Z5"0/api/v1/namespaces/{namespace}/activities/cancel:\x01*\x12\xad\x02\n\x1fRespondActivityTaskCanceledById\x12G.temporal.api.workflowservice.v1.RespondActivityTaskCanceledByIdRequest\x1aH.temporal.api.workflowservice.v1.RespondActivityTaskCanceledByIdResponse"w\x82\xd3\xe4\x93\x02q"//namespaces/{namespace}/activities/cancel-by-id:\x01*Z;"6/api/v1/namespaces/{namespace}/activities/cancel-by-id:\x01*\x12\xe0\x02\n\x1eRequestCancelWorkflowExecution\x12\x46.temporal.api.workflowservice.v1.RequestCancelWorkflowExecutionRequest\x1aG.temporal.api.workflowservice.v1.RequestCancelWorkflowExecutionResponse"\xac\x01\x82\xd3\xe4\x93\x02\xa5\x01"I/namespaces/{namespace}/workflows/{workflow_execution.workflow_id}/cancel:\x01*ZU"P/api/v1/namespaces/{namespace}/workflows/{workflow_execution.workflow_id}/cancel:\x01*\x12\xe7\x02\n\x17SignalWorkflowExecution\x12?.temporal.api.workflowservice.v1.SignalWorkflowExecutionRequest\x1a@.temporal.api.workflowservice.v1.SignalWorkflowExecutionResponse"\xc8\x01\x82\xd3\xe4\x93\x02\xc1\x01"W/namespaces/{namespace}/workflows/{workflow_execution.workflow_id}/signal/{signal_name}:\x01*Zc"^/api/v1/namespaces/{namespace}/workflows/{workflow_execution.workflow_id}/signal/{signal_name}:\x01*\x12\xf2\x02\n SignalWithStartWorkflowExecution\x12H.temporal.api.workflowservice.v1.SignalWithStartWorkflowExecutionRequest\x1aI.temporal.api.workflowservice.v1.SignalWithStartWorkflowExecutionResponse"\xb8\x01\x82\xd3\xe4\x93\x02\xb1\x01"O/namespaces/{namespace}/workflows/{workflow_id}/signal-with-start/{signal_name}:\x01*Z["V/api/v1/namespaces/{namespace}/workflows/{workflow_id}/signal-with-start/{signal_name}:\x01*\x12\xc6\x02\n\x16ResetWorkflowExecution\x12>.temporal.api.workflowservice.v1.ResetWorkflowExecutionRequest\x1a?.temporal.api.workflowservice.v1.ResetWorkflowExecutionResponse"\xaa\x01\x82\xd3\xe4\x93\x02\xa3\x01"H/namespaces/{namespace}/workflows/{workflow_execution.workflow_id}/reset:\x01*ZT"O/api/v1/namespaces/{namespace}/workflows/{workflow_execution.workflow_id}/reset:\x01*\x12\xda\x02\n\x1aTerminateWorkflowExecution\x12\x42.temporal.api.workflowservice.v1.TerminateWorkflowExecutionRequest\x1a\x43.temporal.api.workflowservice.v1.TerminateWorkflowExecutionResponse"\xb2\x01\x82\xd3\xe4\x93\x02\xab\x01"L/namespaces/{namespace}/workflows/{workflow_execution.workflow_id}/terminate:\x01*ZX"S/api/v1/namespaces/{namespace}/workflows/{workflow_execution.workflow_id}/terminate:\x01*\x12\x9e\x01\n\x17\x44\x65leteWorkflowExecution\x12?.temporal.api.workflowservice.v1.DeleteWorkflowExecutionRequest\x1a@.temporal.api.workflowservice.v1.DeleteWorkflowExecutionResponse"\x00\x12\xa7\x01\n\x1aListOpenWorkflowExecutions\x12\x42.temporal.api.workflowservice.v1.ListOpenWorkflowExecutionsRequest\x1a\x43.temporal.api.workflowservice.v1.ListOpenWorkflowExecutionsResponse"\x00\x12\xad\x01\n\x1cListClosedWorkflowExecutions\x12\x44.temporal.api.workflowservice.v1.ListClosedWorkflowExecutionsRequest\x1a\x45.temporal.api.workflowservice.v1.ListClosedWorkflowExecutionsResponse"\x00\x12\xf0\x01\n\x16ListWorkflowExecutions\x12>.temporal.api.workflowservice.v1.ListWorkflowExecutionsRequest\x1a?.temporal.api.workflowservice.v1.ListWorkflowExecutionsResponse"U\x82\xd3\xe4\x93\x02O\x12!/namespaces/{namespace}/workflowsZ*\x12(/api/v1/namespaces/{namespace}/workflows\x12\x9a\x02\n\x1eListArchivedWorkflowExecutions\x12\x46.temporal.api.workflowservice.v1.ListArchivedWorkflowExecutionsRequest\x1aG.temporal.api.workflowservice.v1.ListArchivedWorkflowExecutionsResponse"g\x82\xd3\xe4\x93\x02\x61\x12*/namespaces/{namespace}/archived-workflowsZ3\x12\x31/api/v1/namespaces/{namespace}/archived-workflows\x12\x9b\x01\n\x16ScanWorkflowExecutions\x12>.temporal.api.workflowservice.v1.ScanWorkflowExecutionsRequest\x1a?.temporal.api.workflowservice.v1.ScanWorkflowExecutionsResponse"\x00\x12\xfd\x01\n\x17\x43ountWorkflowExecutions\x12?.temporal.api.workflowservice.v1.CountWorkflowExecutionsRequest\x1a@.temporal.api.workflowservice.v1.CountWorkflowExecutionsResponse"_\x82\xd3\xe4\x93\x02Y\x12&/namespaces/{namespace}/workflow-countZ/\x12-/api/v1/namespaces/{namespace}/workflow-count\x12\x92\x01\n\x13GetSearchAttributes\x12;.temporal.api.workflowservice.v1.GetSearchAttributesRequest\x1a<.temporal.api.workflowservice.v1.GetSearchAttributesResponse"\x00\x12\xa4\x01\n\x19RespondQueryTaskCompleted\x12\x41.temporal.api.workflowservice.v1.RespondQueryTaskCompletedRequest\x1a\x42.temporal.api.workflowservice.v1.RespondQueryTaskCompletedResponse"\x00\x12\x95\x01\n\x14ResetStickyTaskQueue\x12<.temporal.api.workflowservice.v1.ResetStickyTaskQueueRequest\x1a=.temporal.api.workflowservice.v1.ResetStickyTaskQueueResponse"\x00\x12\x83\x01\n\x0eShutdownWorker\x12\x36.temporal.api.workflowservice.v1.ShutdownWorkerRequest\x1a\x37.temporal.api.workflowservice.v1.ShutdownWorkerResponse"\x00\x12\xbf\x02\n\rQueryWorkflow\x12\x35.temporal.api.workflowservice.v1.QueryWorkflowRequest\x1a\x36.temporal.api.workflowservice.v1.QueryWorkflowResponse"\xbe\x01\x82\xd3\xe4\x93\x02\xb7\x01"R/namespaces/{namespace}/workflows/{execution.workflow_id}/query/{query.query_type}:\x01*Z^"Y/api/v1/namespaces/{namespace}/workflows/{execution.workflow_id}/query/{query.query_type}:\x01*\x12\xaa\x02\n\x19\x44\x65scribeWorkflowExecution\x12\x41.temporal.api.workflowservice.v1.DescribeWorkflowExecutionRequest\x1a\x42.temporal.api.workflowservice.v1.DescribeWorkflowExecutionResponse"\x85\x01\x82\xd3\xe4\x93\x02\x7f\x12\x39/namespaces/{namespace}/workflows/{execution.workflow_id}ZB\x12@/api/v1/namespaces/{namespace}/workflows/{execution.workflow_id}\x12\x89\x02\n\x11\x44\x65scribeTaskQueue\x12\x39.temporal.api.workflowservice.v1.DescribeTaskQueueRequest\x1a:.temporal.api.workflowservice.v1.DescribeTaskQueueResponse"}\x82\xd3\xe4\x93\x02w\x12\x35/namespaces/{namespace}/task-queues/{task_queue.name}Z>\x12/namespaces/{namespace}/schedules/{schedule_id}/matching-timesZG\x12\x45/api/v1/namespaces/{namespace}/schedules/{schedule_id}/matching-times\x12\xf4\x01\n\x0e\x44\x65leteSchedule\x12\x36.temporal.api.workflowservice.v1.DeleteScheduleRequest\x1a\x37.temporal.api.workflowservice.v1.DeleteScheduleResponse"q\x82\xd3\xe4\x93\x02k*//namespaces/{namespace}/schedules/{schedule_id}Z8*6/api/v1/namespaces/{namespace}/schedules/{schedule_id}\x12\xd5\x01\n\rListSchedules\x12\x35.temporal.api.workflowservice.v1.ListSchedulesRequest\x1a\x36.temporal.api.workflowservice.v1.ListSchedulesResponse"U\x82\xd3\xe4\x93\x02O\x12!/namespaces/{namespace}/schedulesZ*\x12(/api/v1/namespaces/{namespace}/schedules\x12\xb9\x01\n UpdateWorkerBuildIdCompatibility\x12H.temporal.api.workflowservice.v1.UpdateWorkerBuildIdCompatibilityRequest\x1aI.temporal.api.workflowservice.v1.UpdateWorkerBuildIdCompatibilityResponse"\x00\x12\xe1\x02\n\x1dGetWorkerBuildIdCompatibility\x12\x45.temporal.api.workflowservice.v1.GetWorkerBuildIdCompatibilityRequest\x1a\x46.temporal.api.workflowservice.v1.GetWorkerBuildIdCompatibilityResponse"\xb0\x01\x82\xd3\xe4\x93\x02\xa9\x01\x12N/namespaces/{namespace}/task-queues/{task_queue}/worker-build-id-compatibilityZW\x12U/api/v1/namespaces/{namespace}/task-queues/{task_queue}/worker-build-id-compatibility\x12\xaa\x01\n\x1bUpdateWorkerVersioningRules\x12\x43.temporal.api.workflowservice.v1.UpdateWorkerVersioningRulesRequest\x1a\x44.temporal.api.workflowservice.v1.UpdateWorkerVersioningRulesResponse"\x00\x12\xc6\x02\n\x18GetWorkerVersioningRules\x12@.temporal.api.workflowservice.v1.GetWorkerVersioningRulesRequest\x1a\x41.temporal.api.workflowservice.v1.GetWorkerVersioningRulesResponse"\xa4\x01\x82\xd3\xe4\x93\x02\x9d\x01\x12H/namespaces/{namespace}/task-queues/{task_queue}/worker-versioning-rulesZQ\x12O/api/v1/namespaces/{namespace}/task-queues/{task_queue}/worker-versioning-rules\x12\x97\x02\n\x19GetWorkerTaskReachability\x12\x41.temporal.api.workflowservice.v1.GetWorkerTaskReachabilityRequest\x1a\x42.temporal.api.workflowservice.v1.GetWorkerTaskReachabilityResponse"s\x82\xd3\xe4\x93\x02m\x12\x30/namespaces/{namespace}/worker-task-reachabilityZ9\x12\x37/api/v1/namespaces/{namespace}/worker-task-reachability\x12\xc8\x02\n\x12\x44\x65scribeDeployment\x12:.temporal.api.workflowservice.v1.DescribeDeploymentRequest\x1a;.temporal.api.workflowservice.v1.DescribeDeploymentResponse"\xb8\x01\x82\xd3\xe4\x93\x02\xb1\x01\x12R/namespaces/{namespace}/deployments/{deployment.series_name}/{deployment.build_id}Z[\x12Y/api/v1/namespaces/{namespace}/deployments/{deployment.series_name}/{deployment.build_id}\x12\xb5\x03\n\x1f\x44\x65scribeWorkerDeploymentVersion\x12G.temporal.api.workflowservice.v1.DescribeWorkerDeploymentVersionRequest\x1aH.temporal.api.workflowservice.v1.DescribeWorkerDeploymentVersionResponse"\xfe\x01\x82\xd3\xe4\x93\x02\xf7\x01\x12u/namespaces/{namespace}/worker-deployment-versions/{deployment_version.deployment_name}/{deployment_version.build_id}Z~\x12|/api/v1/namespaces/{namespace}/worker-deployment-versions/{deployment_version.deployment_name}/{deployment_version.build_id}\x12\xdf\x01\n\x0fListDeployments\x12\x37.temporal.api.workflowservice.v1.ListDeploymentsRequest\x1a\x38.temporal.api.workflowservice.v1.ListDeploymentsResponse"Y\x82\xd3\xe4\x93\x02S\x12#/namespaces/{namespace}/deploymentsZ,\x12*/api/v1/namespaces/{namespace}/deployments\x12\xf7\x02\n\x19GetDeploymentReachability\x12\x41.temporal.api.workflowservice.v1.GetDeploymentReachabilityRequest\x1a\x42.temporal.api.workflowservice.v1.GetDeploymentReachabilityResponse"\xd2\x01\x82\xd3\xe4\x93\x02\xcb\x01\x12_/namespaces/{namespace}/deployments/{deployment.series_name}/{deployment.build_id}/reachabilityZh\x12\x66/api/v1/namespaces/{namespace}/deployments/{deployment.series_name}/{deployment.build_id}/reachability\x12\x99\x02\n\x14GetCurrentDeployment\x12<.temporal.api.workflowservice.v1.GetCurrentDeploymentRequest\x1a=.temporal.api.workflowservice.v1.GetCurrentDeploymentResponse"\x83\x01\x82\xd3\xe4\x93\x02}\x12\x38/namespaces/{namespace}/current-deployment/{series_name}ZA\x12?/api/v1/namespaces/{namespace}/current-deployment/{series_name}\x12\xb6\x02\n\x14SetCurrentDeployment\x12<.temporal.api.workflowservice.v1.SetCurrentDeploymentRequest\x1a=.temporal.api.workflowservice.v1.SetCurrentDeploymentResponse"\xa0\x01\x82\xd3\xe4\x93\x02\x99\x01"C/namespaces/{namespace}/current-deployment/{deployment.series_name}:\x01*ZO"J/api/v1/namespaces/{namespace}/current-deployment/{deployment.series_name}:\x01*\x12\xf7\x02\n!SetWorkerDeploymentCurrentVersion\x12I.temporal.api.workflowservice.v1.SetWorkerDeploymentCurrentVersionRequest\x1aJ.temporal.api.workflowservice.v1.SetWorkerDeploymentCurrentVersionResponse"\xba\x01\x82\xd3\xe4\x93\x02\xb3\x01"P/namespaces/{namespace}/worker-deployments/{deployment_name}/set-current-version:\x01*Z\\"W/api/v1/namespaces/{namespace}/worker-deployments/{deployment_name}/set-current-version:\x01*\x12\xae\x02\n\x18\x44\x65scribeWorkerDeployment\x12@.temporal.api.workflowservice.v1.DescribeWorkerDeploymentRequest\x1a\x41.temporal.api.workflowservice.v1.DescribeWorkerDeploymentResponse"\x8c\x01\x82\xd3\xe4\x93\x02\x85\x01\x12.temporal.api.workflowservice.v1.DeleteWorkerDeploymentRequest\x1a?.temporal.api.workflowservice.v1.DeleteWorkerDeploymentResponse"\x8c\x01\x82\xd3\xe4\x93\x02\x85\x01*.temporal.api.workflowservice.v1.ListWorkerDeploymentsResponse"g\x82\xd3\xe4\x93\x02\x61\x12*/namespaces/{namespace}/worker-deploymentsZ3\x12\x31/api/v1/namespaces/{namespace}/worker-deployments\x12\xf0\x03\n%UpdateWorkerDeploymentVersionMetadata\x12M.temporal.api.workflowservice.v1.UpdateWorkerDeploymentVersionMetadataRequest\x1aN.temporal.api.workflowservice.v1.UpdateWorkerDeploymentVersionMetadataResponse"\xa7\x02\x82\xd3\xe4\x93\x02\xa0\x02"\x85\x01/namespaces/{namespace}/worker-deployment-versions/{deployment_version.deployment_name}/{deployment_version.build_id}/update-metadata:\x01*Z\x92\x01"\x8c\x01/api/v1/namespaces/{namespace}/worker-deployment-versions/{deployment_version.deployment_name}/{deployment_version.build_id}/update-metadata:\x01*\x12\xd2\x02\n\x1aSetWorkerDeploymentManager\x12\x42.temporal.api.workflowservice.v1.SetWorkerDeploymentManagerRequest\x1a\x43.temporal.api.workflowservice.v1.SetWorkerDeploymentManagerResponse"\xaa\x01\x82\xd3\xe4\x93\x02\xa3\x01"H/namespaces/{namespace}/worker-deployments/{deployment_name}/set-manager:\x01*ZT"O/api/v1/namespaces/{namespace}/worker-deployments/{deployment_name}/set-manager:\x01*\x12\xf5\x02\n\x17UpdateWorkflowExecution\x12?.temporal.api.workflowservice.v1.UpdateWorkflowExecutionRequest\x1a@.temporal.api.workflowservice.v1.UpdateWorkflowExecutionResponse"\xd6\x01\x82\xd3\xe4\x93\x02\xcf\x01"^/namespaces/{namespace}/workflows/{workflow_execution.workflow_id}/update/{request.input.name}:\x01*Zj"e/api/v1/namespaces/{namespace}/workflows/{workflow_execution.workflow_id}/update/{request.input.name}:\x01*\x12\xaa\x01\n\x1bPollWorkflowExecutionUpdate\x12\x43.temporal.api.workflowservice.v1.PollWorkflowExecutionUpdateRequest\x1a\x44.temporal.api.workflowservice.v1.PollWorkflowExecutionUpdateResponse"\x00\x12\x8d\x02\n\x13StartBatchOperation\x12;.temporal.api.workflowservice.v1.StartBatchOperationRequest\x1a<.temporal.api.workflowservice.v1.StartBatchOperationResponse"{\x82\xd3\xe4\x93\x02u"1/namespaces/{namespace}/batch-operations/{job_id}:\x01*Z="8/api/v1/namespaces/{namespace}/batch-operations/{job_id}:\x01*\x12\x95\x02\n\x12StopBatchOperation\x12:.temporal.api.workflowservice.v1.StopBatchOperationRequest\x1a;.temporal.api.workflowservice.v1.StopBatchOperationResponse"\x85\x01\x82\xd3\xe4\x93\x02\x7f"6/namespaces/{namespace}/batch-operations/{job_id}/stop:\x01*ZB"=/api/v1/namespaces/{namespace}/batch-operations/{job_id}/stop:\x01*\x12\x90\x02\n\x16\x44\x65scribeBatchOperation\x12>.temporal.api.workflowservice.v1.DescribeBatchOperationRequest\x1a?.temporal.api.workflowservice.v1.DescribeBatchOperationResponse"u\x82\xd3\xe4\x93\x02o\x12\x31/namespaces/{namespace}/batch-operations/{job_id}Z:\x12\x38/api/v1/namespaces/{namespace}/batch-operations/{job_id}\x12\xf5\x01\n\x13ListBatchOperations\x12;.temporal.api.workflowservice.v1.ListBatchOperationsRequest\x1a<.temporal.api.workflowservice.v1.ListBatchOperationsResponse"c\x82\xd3\xe4\x93\x02]\x12(/namespaces/{namespace}/batch-operationsZ1\x12//api/v1/namespaces/{namespace}/batch-operations\x12\x8f\x01\n\x12PollNexusTaskQueue\x12:.temporal.api.workflowservice.v1.PollNexusTaskQueueRequest\x1a;.temporal.api.workflowservice.v1.PollNexusTaskQueueResponse"\x00\x12\xa4\x01\n\x19RespondNexusTaskCompleted\x12\x41.temporal.api.workflowservice.v1.RespondNexusTaskCompletedRequest\x1a\x42.temporal.api.workflowservice.v1.RespondNexusTaskCompletedResponse"\x00\x12\x9b\x01\n\x16RespondNexusTaskFailed\x12>.temporal.api.workflowservice.v1.RespondNexusTaskFailedRequest\x1a?.temporal.api.workflowservice.v1.RespondNexusTaskFailedResponse"\x00\x12\x93\x02\n\x15UpdateActivityOptions\x12=.temporal.api.workflowservice.v1.UpdateActivityOptionsRequest\x1a>.temporal.api.workflowservice.v1.UpdateActivityOptionsResponse"{\x82\xd3\xe4\x93\x02u"1/namespaces/{namespace}/activities/update-options:\x01*Z="8/api/v1/namespaces/{namespace}/activities/update-options:\x01*\x12\xf0\x02\n\x1eUpdateWorkflowExecutionOptions\x12\x46.temporal.api.workflowservice.v1.UpdateWorkflowExecutionOptionsRequest\x1aG.temporal.api.workflowservice.v1.UpdateWorkflowExecutionOptionsResponse"\xbc\x01\x82\xd3\xe4\x93\x02\xb5\x01"Q/namespaces/{namespace}/workflows/{workflow_execution.workflow_id}/update-options:\x01*Z]"X/api/v1/namespaces/{namespace}/workflows/{workflow_execution.workflow_id}/update-options:\x01*\x12\xe9\x01\n\rPauseActivity\x12\x35.temporal.api.workflowservice.v1.PauseActivityRequest\x1a\x36.temporal.api.workflowservice.v1.PauseActivityResponse"i\x82\xd3\xe4\x93\x02\x63"(/namespaces/{namespace}/activities/pause:\x01*Z4"//api/v1/namespaces/{namespace}/activities/pause:\x01*\x12\xf3\x01\n\x0fUnpauseActivity\x12\x37.temporal.api.workflowservice.v1.UnpauseActivityRequest\x1a\x38.temporal.api.workflowservice.v1.UnpauseActivityResponse"m\x82\xd3\xe4\x93\x02g"*/namespaces/{namespace}/activities/unpause:\x01*Z6"1/api/v1/namespaces/{namespace}/activities/unpause:\x01*\x12\xe9\x01\n\rResetActivity\x12\x35.temporal.api.workflowservice.v1.ResetActivityRequest\x1a\x36.temporal.api.workflowservice.v1.ResetActivityResponse"i\x82\xd3\xe4\x93\x02\x63"(/namespaces/{namespace}/activities/reset:\x01*Z4"//api/v1/namespaces/{namespace}/activities/reset:\x01*\x12\xf4\x01\n\x12\x43reateWorkflowRule\x12:.temporal.api.workflowservice.v1.CreateWorkflowRuleRequest\x1a;.temporal.api.workflowservice.v1.CreateWorkflowRuleResponse"e\x82\xd3\xe4\x93\x02_"&/namespaces/{namespace}/workflow-rules:\x01*Z2"-/api/v1/namespaces/{namespace}/workflow-rules:\x01*\x12\x88\x02\n\x14\x44\x65scribeWorkflowRule\x12<.temporal.api.workflowservice.v1.DescribeWorkflowRuleRequest\x1a=.temporal.api.workflowservice.v1.DescribeWorkflowRuleResponse"s\x82\xd3\xe4\x93\x02m\x12\x30/namespaces/{namespace}/workflow-rules/{rule_id}Z9\x12\x37/api/v1/namespaces/{namespace}/workflow-rules/{rule_id}\x12\x82\x02\n\x12\x44\x65leteWorkflowRule\x12:.temporal.api.workflowservice.v1.DeleteWorkflowRuleRequest\x1a;.temporal.api.workflowservice.v1.DeleteWorkflowRuleResponse"s\x82\xd3\xe4\x93\x02m*0/namespaces/{namespace}/workflow-rules/{rule_id}Z9*7/api/v1/namespaces/{namespace}/workflow-rules/{rule_id}\x12\xeb\x01\n\x11ListWorkflowRules\x12\x39.temporal.api.workflowservice.v1.ListWorkflowRulesRequest\x1a:.temporal.api.workflowservice.v1.ListWorkflowRulesResponse"_\x82\xd3\xe4\x93\x02Y\x12&/namespaces/{namespace}/workflow-rulesZ/\x12-/api/v1/namespaces/{namespace}/workflow-rules\x12\xb9\x02\n\x13TriggerWorkflowRule\x12;.temporal.api.workflowservice.v1.TriggerWorkflowRuleRequest\x1a<.temporal.api.workflowservice.v1.TriggerWorkflowRuleResponse"\xa6\x01\x82\xd3\xe4\x93\x02\x9f\x01"F/namespaces/{namespace}/workflows/{execution.workflow_id}/trigger-rule:\x01*ZR"M/api/v1/namespaces/{namespace}/workflows/{execution.workflow_id}/trigger-rule:\x01*\x12\x83\x02\n\x15RecordWorkerHeartbeat\x12=.temporal.api.workflowservice.v1.RecordWorkerHeartbeatRequest\x1a>.temporal.api.workflowservice.v1.RecordWorkerHeartbeatResponse"k\x82\xd3\xe4\x93\x02\x65")/namespaces/{namespace}/workers/heartbeat:\x01*Z5"0/api/v1/namespaces/{namespace}/workers/heartbeat:\x01*\x12\xcb\x01\n\x0bListWorkers\x12\x33.temporal.api.workflowservice.v1.ListWorkersRequest\x1a\x34.temporal.api.workflowservice.v1.ListWorkersResponse"Q\x82\xd3\xe4\x93\x02K\x12\x1f/namespaces/{namespace}/workersZ(\x12&/api/v1/namespaces/{namespace}/workers\x12\xaf\x02\n\x15UpdateTaskQueueConfig\x12=.temporal.api.workflowservice.v1.UpdateTaskQueueConfigRequest\x1a>.temporal.api.workflowservice.v1.UpdateTaskQueueConfigResponse"\x96\x01\x82\xd3\xe4\x93\x02\x8f\x01">/namespaces/{namespace}/task-queues/{task_queue}/update-config:\x01*ZJ"E/api/v1/namespaces/{namespace}/task-queues/{task_queue}/update-config:\x01*\x12\xfd\x01\n\x11\x46\x65tchWorkerConfig\x12\x39.temporal.api.workflowservice.v1.FetchWorkerConfigRequest\x1a:.temporal.api.workflowservice.v1.FetchWorkerConfigResponse"q\x82\xd3\xe4\x93\x02k",/namespaces/{namespace}/workers/fetch-config:\x01*Z8"3/api/v1/namespaces/{namespace}/workers/fetch-config:\x01*\x12\x82\x02\n\x12UpdateWorkerConfig\x12:.temporal.api.workflowservice.v1.UpdateWorkerConfigRequest\x1a;.temporal.api.workflowservice.v1.UpdateWorkerConfigResponse"s\x82\xd3\xe4\x93\x02m"-/namespaces/{namespace}/workers/update-config:\x01*Z9"4/api/v1/namespaces/{namespace}/workers/update-config:\x01*\x12\x94\x02\n\x0e\x44\x65scribeWorker\x12\x36.temporal.api.workflowservice.v1.DescribeWorkerRequest\x1a\x37.temporal.api.workflowservice.v1.DescribeWorkerResponse"\x90\x01\x82\xd3\xe4\x93\x02\x89\x01\x12>/namespaces/{namespace}/workers/describe/{worker_instance_key}ZG\x12\x45/api/v1/namespaces/{namespace}/workers/describe/{worker_instance_key}\x12\x94\x02\n\x16StartActivityExecution\x12>.temporal.api.workflowservice.v1.StartActivityExecutionRequest\x1a?.temporal.api.workflowservice.v1.StartActivityExecutionResponse"y\x82\xd3\xe4\x93\x02s"0/namespaces/{namespace}/activities/{activity_id}:\x01*Z<"7/api/v1/namespaces/{namespace}/activities/{activity_id}:\x01*\x12\x97\x02\n\x19\x44\x65scribeActivityExecution\x12\x41.temporal.api.workflowservice.v1.DescribeActivityExecutionRequest\x1a\x42.temporal.api.workflowservice.v1.DescribeActivityExecutionResponse"s\x82\xd3\xe4\x93\x02m\x12\x30/namespaces/{namespace}/activities/{activity_id}Z9\x12\x37/api/v1/namespaces/{namespace}/activities/{activity_id}\x12\x9c\x02\n\x15PollActivityExecution\x12=.temporal.api.workflowservice.v1.PollActivityExecutionRequest\x1a>.temporal.api.workflowservice.v1.PollActivityExecutionResponse"\x83\x01\x82\xd3\xe4\x93\x02}\x12\x38/namespaces/{namespace}/activities/{activity_id}/outcomeZA\x12?/api/v1/namespaces/{namespace}/activities/{activity_id}/outcome\x12\xf2\x01\n\x16ListActivityExecutions\x12>.temporal.api.workflowservice.v1.ListActivityExecutionsRequest\x1a?.temporal.api.workflowservice.v1.ListActivityExecutionsResponse"W\x82\xd3\xe4\x93\x02Q\x12"/namespaces/{namespace}/activitiesZ+\x12)/api/v1/namespaces/{namespace}/activities\x12\xfd\x01\n\x17\x43ountActivityExecutions\x12?.temporal.api.workflowservice.v1.CountActivityExecutionsRequest\x1a@.temporal.api.workflowservice.v1.CountActivityExecutionsResponse"_\x82\xd3\xe4\x93\x02Y\x12&/namespaces/{namespace}/activity-countZ/\x12-/api/v1/namespaces/{namespace}/activity-count\x12\xbc\x02\n\x1eRequestCancelActivityExecution\x12\x46.temporal.api.workflowservice.v1.RequestCancelActivityExecutionRequest\x1aG.temporal.api.workflowservice.v1.RequestCancelActivityExecutionResponse"\x88\x01\x82\xd3\xe4\x93\x02\x81\x01"7/namespaces/{namespace}/activities/{activity_id}/cancel:\x01*ZC">/api/v1/namespaces/{namespace}/activities/{activity_id}/cancel:\x01*\x12\xb6\x02\n\x1aTerminateActivityExecution\x12\x42.temporal.api.workflowservice.v1.TerminateActivityExecutionRequest\x1a\x43.temporal.api.workflowservice.v1.TerminateActivityExecutionResponse"\x8e\x01\x82\xd3\xe4\x93\x02\x87\x01":/namespaces/{namespace}/activities/{activity_id}/terminate:\x01*ZF"A/api/v1/namespaces/{namespace}/activities/{activity_id}/terminate:\x01*\x12\x9e\x01\n\x17\x44\x65leteActivityExecution\x12?.temporal.api.workflowservice.v1.DeleteActivityExecutionRequest\x1a@.temporal.api.workflowservice.v1.DeleteActivityExecutionResponse"\x00\x42\xb6\x01\n"io.temporal.api.workflowservice.v1B\x0cServiceProtoP\x01Z5go.temporal.io/api/workflowservice/v1;workflowservice\xaa\x02!Temporalio.Api.WorkflowService.V1\xea\x02$Temporalio::Api::WorkflowService::V1b\x06proto3' ) @@ -337,6 +337,34 @@ _WORKFLOWSERVICE.methods_by_name[ "DescribeWorker" ]._serialized_options = b"\202\323\344\223\002\211\001\022>/namespaces/{namespace}/workers/describe/{worker_instance_key}ZG\022E/api/v1/namespaces/{namespace}/workers/describe/{worker_instance_key}" + _WORKFLOWSERVICE.methods_by_name["StartActivityExecution"]._options = None + _WORKFLOWSERVICE.methods_by_name[ + "StartActivityExecution" + ]._serialized_options = b'\202\323\344\223\002s"0/namespaces/{namespace}/activities/{activity_id}:\001*Z<"7/api/v1/namespaces/{namespace}/activities/{activity_id}:\001*' + _WORKFLOWSERVICE.methods_by_name["DescribeActivityExecution"]._options = None + _WORKFLOWSERVICE.methods_by_name[ + "DescribeActivityExecution" + ]._serialized_options = b"\202\323\344\223\002m\0220/namespaces/{namespace}/activities/{activity_id}Z9\0227/api/v1/namespaces/{namespace}/activities/{activity_id}" + _WORKFLOWSERVICE.methods_by_name["PollActivityExecution"]._options = None + _WORKFLOWSERVICE.methods_by_name[ + "PollActivityExecution" + ]._serialized_options = b"\202\323\344\223\002}\0228/namespaces/{namespace}/activities/{activity_id}/outcomeZA\022?/api/v1/namespaces/{namespace}/activities/{activity_id}/outcome" + _WORKFLOWSERVICE.methods_by_name["ListActivityExecutions"]._options = None + _WORKFLOWSERVICE.methods_by_name[ + "ListActivityExecutions" + ]._serialized_options = b'\202\323\344\223\002Q\022"/namespaces/{namespace}/activitiesZ+\022)/api/v1/namespaces/{namespace}/activities' + _WORKFLOWSERVICE.methods_by_name["CountActivityExecutions"]._options = None + _WORKFLOWSERVICE.methods_by_name[ + "CountActivityExecutions" + ]._serialized_options = b"\202\323\344\223\002Y\022&/namespaces/{namespace}/activity-countZ/\022-/api/v1/namespaces/{namespace}/activity-count" + _WORKFLOWSERVICE.methods_by_name["RequestCancelActivityExecution"]._options = None + _WORKFLOWSERVICE.methods_by_name[ + "RequestCancelActivityExecution" + ]._serialized_options = b'\202\323\344\223\002\201\001"7/namespaces/{namespace}/activities/{activity_id}/cancel:\001*ZC">/api/v1/namespaces/{namespace}/activities/{activity_id}/cancel:\001*' + _WORKFLOWSERVICE.methods_by_name["TerminateActivityExecution"]._options = None + _WORKFLOWSERVICE.methods_by_name[ + "TerminateActivityExecution" + ]._serialized_options = b'\202\323\344\223\002\207\001":/namespaces/{namespace}/activities/{activity_id}/terminate:\001*ZF"A/api/v1/namespaces/{namespace}/activities/{activity_id}/terminate:\001*' _WORKFLOWSERVICE._serialized_start = 170 - _WORKFLOWSERVICE._serialized_end = 24997 + _WORKFLOWSERVICE._serialized_end = 27139 # @@protoc_insertion_point(module_scope) diff --git a/temporalio/api/workflowservice/v1/service_pb2_grpc.py b/temporalio/api/workflowservice/v1/service_pb2_grpc.py index ebc0a353b..6c8ca23a4 100644 --- a/temporalio/api/workflowservice/v1/service_pb2_grpc.py +++ b/temporalio/api/workflowservice/v1/service_pb2_grpc.py @@ -498,6 +498,46 @@ def __init__(self, channel): request_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.DescribeWorkerRequest.SerializeToString, response_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.DescribeWorkerResponse.FromString, ) + self.StartActivityExecution = channel.unary_unary( + "/temporal.api.workflowservice.v1.WorkflowService/StartActivityExecution", + request_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.StartActivityExecutionRequest.SerializeToString, + response_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.StartActivityExecutionResponse.FromString, + ) + self.DescribeActivityExecution = channel.unary_unary( + "/temporal.api.workflowservice.v1.WorkflowService/DescribeActivityExecution", + request_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.DescribeActivityExecutionRequest.SerializeToString, + response_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.DescribeActivityExecutionResponse.FromString, + ) + self.PollActivityExecution = channel.unary_unary( + "/temporal.api.workflowservice.v1.WorkflowService/PollActivityExecution", + request_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.PollActivityExecutionRequest.SerializeToString, + response_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.PollActivityExecutionResponse.FromString, + ) + self.ListActivityExecutions = channel.unary_unary( + "/temporal.api.workflowservice.v1.WorkflowService/ListActivityExecutions", + request_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.ListActivityExecutionsRequest.SerializeToString, + response_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.ListActivityExecutionsResponse.FromString, + ) + self.CountActivityExecutions = channel.unary_unary( + "/temporal.api.workflowservice.v1.WorkflowService/CountActivityExecutions", + request_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.CountActivityExecutionsRequest.SerializeToString, + response_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.CountActivityExecutionsResponse.FromString, + ) + self.RequestCancelActivityExecution = channel.unary_unary( + "/temporal.api.workflowservice.v1.WorkflowService/RequestCancelActivityExecution", + request_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.RequestCancelActivityExecutionRequest.SerializeToString, + response_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.RequestCancelActivityExecutionResponse.FromString, + ) + self.TerminateActivityExecution = channel.unary_unary( + "/temporal.api.workflowservice.v1.WorkflowService/TerminateActivityExecution", + request_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.TerminateActivityExecutionRequest.SerializeToString, + response_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.TerminateActivityExecutionResponse.FromString, + ) + self.DeleteActivityExecution = channel.unary_unary( + "/temporal.api.workflowservice.v1.WorkflowService/DeleteActivityExecution", + request_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.DeleteActivityExecutionRequest.SerializeToString, + response_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.DeleteActivityExecutionResponse.FromString, + ) class WorkflowServiceServicer(object): @@ -675,10 +715,17 @@ def PollActivityTaskQueue(self, request, context): def RecordActivityTaskHeartbeat(self, request, context): """RecordActivityTaskHeartbeat is optionally called by workers while they execute activities. - If worker fails to heartbeat within the `heartbeat_timeout` interval for the activity task, - then it will be marked as timed out and an `ACTIVITY_TASK_TIMED_OUT` event will be written to - the workflow history. Calling `RecordActivityTaskHeartbeat` will fail with `NotFound` in - such situations, in that event, the SDK should request cancellation of the activity. + If a worker fails to heartbeat within the `heartbeat_timeout` interval for the activity task, + then the current attempt times out. Depending on RetryPolicy, this may trigger a retry or + time out the activity. + + For workflow activities, an `ACTIVITY_TASK_TIMED_OUT` event will be written to the workflow + history. Calling `RecordActivityTaskHeartbeat` will fail with `NotFound` in such situations, + in that event, the SDK should request cancellation of the activity. + + The request may contain response `details` which will be persisted by the server and may be + used by the activity to checkpoint progress. The `cancel_requested` field in the response + indicates whether cancellation has been requested for the activity. """ context.set_code(grpc.StatusCode.UNIMPLEMENTED) context.set_details("Method not implemented!") @@ -699,7 +746,7 @@ def RespondActivityTaskCompleted(self, request, context): """RespondActivityTaskCompleted is called by workers when they successfully complete an activity task. - This results in a new `ACTIVITY_TASK_COMPLETED` event being written to the workflow history + For workflow activities, this results in a new `ACTIVITY_TASK_COMPLETED` event being written to the workflow history and a new workflow task created for the workflow. Fails with `NotFound` if the task token is no longer valid due to activity timeout, already being completed, or never having existed. """ @@ -708,7 +755,7 @@ def RespondActivityTaskCompleted(self, request, context): raise NotImplementedError("Method not implemented!") def RespondActivityTaskCompletedById(self, request, context): - """See `RecordActivityTaskCompleted`. This version allows clients to record completions by + """See `RespondActivityTaskCompleted`. This version allows clients to record completions by namespace/workflow id/activity id instead of task token. (-- api-linter: core::0136::prepositions=disabled @@ -743,7 +790,7 @@ def RespondActivityTaskFailedById(self, request, context): def RespondActivityTaskCanceled(self, request, context): """RespondActivityTaskFailed is called by workers when processing an activity task fails. - This results in a new `ACTIVITY_TASK_CANCELED` event being written to the workflow history + For workflow activities, this results in a new `ACTIVITY_TASK_CANCELED` event being written to the workflow history and a new workflow task created for the workflow. Fails with `NotFound` if the task token is no longer valid due to activity timeout, already being completed, or never having existed. """ @@ -752,7 +799,7 @@ def RespondActivityTaskCanceled(self, request, context): raise NotImplementedError("Method not implemented!") def RespondActivityTaskCanceledById(self, request, context): - """See `RecordActivityTaskCanceled`. This version allows clients to record failures by + """See `RespondActivityTaskCanceled`. This version allows clients to record failures by namespace/workflow id/activity id instead of task token. (-- api-linter: core::0136::prepositions=disabled @@ -1325,6 +1372,8 @@ def RespondNexusTaskFailed(self, request, context): def UpdateActivityOptions(self, request, context): """UpdateActivityOptions is called by the client to update the options of an activity by its ID or type. If there are multiple pending activities of the provided type - all of them will be updated. + This API will be deprecated soon and replaced with a newer UpdateActivityExecutionOptions that is better named and + structured to work well for standalone activities. """ context.set_code(grpc.StatusCode.UNIMPLEMENTED) context.set_details("Method not implemented!") @@ -1353,6 +1402,8 @@ def PauseActivity(self, request, context): - The activity should respond to the cancellation accordingly. Returns a `NotFound` error if there is no pending activity with the provided ID or type + This API will be deprecated soon and replaced with a newer PauseActivityExecution that is better named and + structured to work well for standalone activities. """ context.set_code(grpc.StatusCode.UNIMPLEMENTED) context.set_details("Method not implemented!") @@ -1372,6 +1423,8 @@ def UnpauseActivity(self, request, context): 'reset_heartbeat': the activity heartbeat timer and heartbeats will be reset. Returns a `NotFound` error if there is no pending activity with the provided ID or type + This API will be deprecated soon and replaced with a newer UnpauseActivityExecution that is better named and + structured to work well for standalone activities. """ context.set_code(grpc.StatusCode.UNIMPLEMENTED) context.set_details("Method not implemented!") @@ -1395,6 +1448,8 @@ def ResetActivity(self, request, context): 'keep_paused': if the activity is paused, it will remain paused. Returns a `NotFound` error if there is no pending activity with the provided ID or type. + This API will be deprecated soon and replaced with a newer ResetActivityExecution that is better named and + structured to work well for standalone activities. """ context.set_code(grpc.StatusCode.UNIMPLEMENTED) context.set_details("Method not implemented!") @@ -1484,6 +1539,82 @@ def DescribeWorker(self, request, context): context.set_details("Method not implemented!") raise NotImplementedError("Method not implemented!") + def StartActivityExecution(self, request, context): + """StartActivityExecution starts a new activity execution. + + Returns an `ActivityExecutionAlreadyStarted` error if an instance already exists with same activity ID in this namespace + unless permitted by the specified ID conflict policy. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details("Method not implemented!") + raise NotImplementedError("Method not implemented!") + + def DescribeActivityExecution(self, request, context): + """DescribeActivityExecution returns information about an activity execution. + It can be used to: + - Get current activity info without waiting + - Long-poll for next state change and return new activity info + Response can optionally include activity input or outcome (if the activity has completed). + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details("Method not implemented!") + raise NotImplementedError("Method not implemented!") + + def PollActivityExecution(self, request, context): + """PollActivityExecution long-polls for an activity execution to complete and returns the + outcome (result or failure). + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details("Method not implemented!") + raise NotImplementedError("Method not implemented!") + + def ListActivityExecutions(self, request, context): + """ListActivityExecutions is a visibility API to list activity executions in a specific namespace.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details("Method not implemented!") + raise NotImplementedError("Method not implemented!") + + def CountActivityExecutions(self, request, context): + """CountActivityExecutions is a visibility API to count activity executions in a specific namespace.""" + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details("Method not implemented!") + raise NotImplementedError("Method not implemented!") + + def RequestCancelActivityExecution(self, request, context): + """RequestCancelActivityExecution requests cancellation of an activity execution. + + Cancellation is cooperative: this call records the request, but the activity must detect and + acknowledge it for the activity to reach CANCELED status. The cancellation signal is + delivered via `cancel_requested` in the heartbeat response; SDKs surface this via + language-idiomatic mechanisms (context cancellation, exceptions, abort signals). + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details("Method not implemented!") + raise NotImplementedError("Method not implemented!") + + def TerminateActivityExecution(self, request, context): + """TerminateActivityExecution terminates an existing activity execution immediately. + + Termination does not reach the worker and the activity code cannot react to it. A terminated activity may have a + running attempt. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details("Method not implemented!") + raise NotImplementedError("Method not implemented!") + + def DeleteActivityExecution(self, request, context): + """DeleteActivityExecution asynchronously deletes a specific activity execution (when + ActivityExecution.run_id is provided) or the latest activity execution (when + ActivityExecution.run_id is not provided). If the activity Execution is running, it will be + terminated before deletion. + + (-- api-linter: core::0127::http-annotation=disabled + aip.dev/not-precedent: Activity deletion not exposed to HTTP, users should use cancel or terminate. --) + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details("Method not implemented!") + raise NotImplementedError("Method not implemented!") + def add_WorkflowServiceServicer_to_server(servicer, server): rpc_method_handlers = { @@ -1957,6 +2088,46 @@ def add_WorkflowServiceServicer_to_server(servicer, server): request_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.DescribeWorkerRequest.FromString, response_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.DescribeWorkerResponse.SerializeToString, ), + "StartActivityExecution": grpc.unary_unary_rpc_method_handler( + servicer.StartActivityExecution, + request_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.StartActivityExecutionRequest.FromString, + response_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.StartActivityExecutionResponse.SerializeToString, + ), + "DescribeActivityExecution": grpc.unary_unary_rpc_method_handler( + servicer.DescribeActivityExecution, + request_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.DescribeActivityExecutionRequest.FromString, + response_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.DescribeActivityExecutionResponse.SerializeToString, + ), + "PollActivityExecution": grpc.unary_unary_rpc_method_handler( + servicer.PollActivityExecution, + request_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.PollActivityExecutionRequest.FromString, + response_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.PollActivityExecutionResponse.SerializeToString, + ), + "ListActivityExecutions": grpc.unary_unary_rpc_method_handler( + servicer.ListActivityExecutions, + request_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.ListActivityExecutionsRequest.FromString, + response_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.ListActivityExecutionsResponse.SerializeToString, + ), + "CountActivityExecutions": grpc.unary_unary_rpc_method_handler( + servicer.CountActivityExecutions, + request_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.CountActivityExecutionsRequest.FromString, + response_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.CountActivityExecutionsResponse.SerializeToString, + ), + "RequestCancelActivityExecution": grpc.unary_unary_rpc_method_handler( + servicer.RequestCancelActivityExecution, + request_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.RequestCancelActivityExecutionRequest.FromString, + response_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.RequestCancelActivityExecutionResponse.SerializeToString, + ), + "TerminateActivityExecution": grpc.unary_unary_rpc_method_handler( + servicer.TerminateActivityExecution, + request_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.TerminateActivityExecutionRequest.FromString, + response_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.TerminateActivityExecutionResponse.SerializeToString, + ), + "DeleteActivityExecution": grpc.unary_unary_rpc_method_handler( + servicer.DeleteActivityExecution, + request_deserializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.DeleteActivityExecutionRequest.FromString, + response_serializer=temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.DeleteActivityExecutionResponse.SerializeToString, + ), } generic_handler = grpc.method_handlers_generic_handler( "temporal.api.workflowservice.v1.WorkflowService", rpc_method_handlers @@ -4704,3 +4875,235 @@ def DescribeWorker( timeout, metadata, ) + + @staticmethod + def StartActivityExecution( + request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None, + ): + return grpc.experimental.unary_unary( + request, + target, + "/temporal.api.workflowservice.v1.WorkflowService/StartActivityExecution", + temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.StartActivityExecutionRequest.SerializeToString, + temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.StartActivityExecutionResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + ) + + @staticmethod + def DescribeActivityExecution( + request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None, + ): + return grpc.experimental.unary_unary( + request, + target, + "/temporal.api.workflowservice.v1.WorkflowService/DescribeActivityExecution", + temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.DescribeActivityExecutionRequest.SerializeToString, + temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.DescribeActivityExecutionResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + ) + + @staticmethod + def PollActivityExecution( + request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None, + ): + return grpc.experimental.unary_unary( + request, + target, + "/temporal.api.workflowservice.v1.WorkflowService/PollActivityExecution", + temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.PollActivityExecutionRequest.SerializeToString, + temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.PollActivityExecutionResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + ) + + @staticmethod + def ListActivityExecutions( + request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None, + ): + return grpc.experimental.unary_unary( + request, + target, + "/temporal.api.workflowservice.v1.WorkflowService/ListActivityExecutions", + temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.ListActivityExecutionsRequest.SerializeToString, + temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.ListActivityExecutionsResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + ) + + @staticmethod + def CountActivityExecutions( + request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None, + ): + return grpc.experimental.unary_unary( + request, + target, + "/temporal.api.workflowservice.v1.WorkflowService/CountActivityExecutions", + temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.CountActivityExecutionsRequest.SerializeToString, + temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.CountActivityExecutionsResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + ) + + @staticmethod + def RequestCancelActivityExecution( + request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None, + ): + return grpc.experimental.unary_unary( + request, + target, + "/temporal.api.workflowservice.v1.WorkflowService/RequestCancelActivityExecution", + temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.RequestCancelActivityExecutionRequest.SerializeToString, + temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.RequestCancelActivityExecutionResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + ) + + @staticmethod + def TerminateActivityExecution( + request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None, + ): + return grpc.experimental.unary_unary( + request, + target, + "/temporal.api.workflowservice.v1.WorkflowService/TerminateActivityExecution", + temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.TerminateActivityExecutionRequest.SerializeToString, + temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.TerminateActivityExecutionResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + ) + + @staticmethod + def DeleteActivityExecution( + request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + insecure=False, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None, + ): + return grpc.experimental.unary_unary( + request, + target, + "/temporal.api.workflowservice.v1.WorkflowService/DeleteActivityExecution", + temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.DeleteActivityExecutionRequest.SerializeToString, + temporal_dot_api_dot_workflowservice_dot_v1_dot_request__response__pb2.DeleteActivityExecutionResponse.FromString, + options, + channel_credentials, + insecure, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + ) diff --git a/temporalio/api/workflowservice/v1/service_pb2_grpc.pyi b/temporalio/api/workflowservice/v1/service_pb2_grpc.pyi index 967321474..1852bb3dc 100644 --- a/temporalio/api/workflowservice/v1/service_pb2_grpc.pyi +++ b/temporalio/api/workflowservice/v1/service_pb2_grpc.pyi @@ -175,10 +175,17 @@ class WorkflowServiceStub: ] """RecordActivityTaskHeartbeat is optionally called by workers while they execute activities. - If worker fails to heartbeat within the `heartbeat_timeout` interval for the activity task, - then it will be marked as timed out and an `ACTIVITY_TASK_TIMED_OUT` event will be written to - the workflow history. Calling `RecordActivityTaskHeartbeat` will fail with `NotFound` in - such situations, in that event, the SDK should request cancellation of the activity. + If a worker fails to heartbeat within the `heartbeat_timeout` interval for the activity task, + then the current attempt times out. Depending on RetryPolicy, this may trigger a retry or + time out the activity. + + For workflow activities, an `ACTIVITY_TASK_TIMED_OUT` event will be written to the workflow + history. Calling `RecordActivityTaskHeartbeat` will fail with `NotFound` in such situations, + in that event, the SDK should request cancellation of the activity. + + The request may contain response `details` which will be persisted by the server and may be + used by the activity to checkpoint progress. The `cancel_requested` field in the response + indicates whether cancellation has been requested for the activity. """ RecordActivityTaskHeartbeatById: grpc.UnaryUnaryMultiCallable[ temporalio.api.workflowservice.v1.request_response_pb2.RecordActivityTaskHeartbeatByIdRequest, @@ -197,7 +204,7 @@ class WorkflowServiceStub: """RespondActivityTaskCompleted is called by workers when they successfully complete an activity task. - This results in a new `ACTIVITY_TASK_COMPLETED` event being written to the workflow history + For workflow activities, this results in a new `ACTIVITY_TASK_COMPLETED` event being written to the workflow history and a new workflow task created for the workflow. Fails with `NotFound` if the task token is no longer valid due to activity timeout, already being completed, or never having existed. """ @@ -205,7 +212,7 @@ class WorkflowServiceStub: temporalio.api.workflowservice.v1.request_response_pb2.RespondActivityTaskCompletedByIdRequest, temporalio.api.workflowservice.v1.request_response_pb2.RespondActivityTaskCompletedByIdResponse, ] - """See `RecordActivityTaskCompleted`. This version allows clients to record completions by + """See `RespondActivityTaskCompleted`. This version allows clients to record completions by namespace/workflow id/activity id instead of task token. (-- api-linter: core::0136::prepositions=disabled @@ -237,7 +244,7 @@ class WorkflowServiceStub: ] """RespondActivityTaskFailed is called by workers when processing an activity task fails. - This results in a new `ACTIVITY_TASK_CANCELED` event being written to the workflow history + For workflow activities, this results in a new `ACTIVITY_TASK_CANCELED` event being written to the workflow history and a new workflow task created for the workflow. Fails with `NotFound` if the task token is no longer valid due to activity timeout, already being completed, or never having existed. """ @@ -245,7 +252,7 @@ class WorkflowServiceStub: temporalio.api.workflowservice.v1.request_response_pb2.RespondActivityTaskCanceledByIdRequest, temporalio.api.workflowservice.v1.request_response_pb2.RespondActivityTaskCanceledByIdResponse, ] - """See `RecordActivityTaskCanceled`. This version allows clients to record failures by + """See `RespondActivityTaskCanceled`. This version allows clients to record failures by namespace/workflow id/activity id instead of task token. (-- api-linter: core::0136::prepositions=disabled @@ -760,6 +767,8 @@ class WorkflowServiceStub: ] """UpdateActivityOptions is called by the client to update the options of an activity by its ID or type. If there are multiple pending activities of the provided type - all of them will be updated. + This API will be deprecated soon and replaced with a newer UpdateActivityExecutionOptions that is better named and + structured to work well for standalone activities. """ UpdateWorkflowExecutionOptions: grpc.UnaryUnaryMultiCallable[ temporalio.api.workflowservice.v1.request_response_pb2.UpdateWorkflowExecutionOptionsRequest, @@ -786,6 +795,8 @@ class WorkflowServiceStub: - The activity should respond to the cancellation accordingly. Returns a `NotFound` error if there is no pending activity with the provided ID or type + This API will be deprecated soon and replaced with a newer PauseActivityExecution that is better named and + structured to work well for standalone activities. """ UnpauseActivity: grpc.UnaryUnaryMultiCallable[ temporalio.api.workflowservice.v1.request_response_pb2.UnpauseActivityRequest, @@ -804,6 +815,8 @@ class WorkflowServiceStub: 'reset_heartbeat': the activity heartbeat timer and heartbeats will be reset. Returns a `NotFound` error if there is no pending activity with the provided ID or type + This API will be deprecated soon and replaced with a newer UnpauseActivityExecution that is better named and + structured to work well for standalone activities. """ ResetActivity: grpc.UnaryUnaryMultiCallable[ temporalio.api.workflowservice.v1.request_response_pb2.ResetActivityRequest, @@ -826,6 +839,8 @@ class WorkflowServiceStub: 'keep_paused': if the activity is paused, it will remain paused. Returns a `NotFound` error if there is no pending activity with the provided ID or type. + This API will be deprecated soon and replaced with a newer ResetActivityExecution that is better named and + structured to work well for standalone activities. """ CreateWorkflowRule: grpc.UnaryUnaryMultiCallable[ temporalio.api.workflowservice.v1.request_response_pb2.CreateWorkflowRuleRequest, @@ -900,6 +915,74 @@ class WorkflowServiceStub: temporalio.api.workflowservice.v1.request_response_pb2.DescribeWorkerResponse, ] """DescribeWorker returns information about the specified worker.""" + StartActivityExecution: grpc.UnaryUnaryMultiCallable[ + temporalio.api.workflowservice.v1.request_response_pb2.StartActivityExecutionRequest, + temporalio.api.workflowservice.v1.request_response_pb2.StartActivityExecutionResponse, + ] + """StartActivityExecution starts a new activity execution. + + Returns an `ActivityExecutionAlreadyStarted` error if an instance already exists with same activity ID in this namespace + unless permitted by the specified ID conflict policy. + """ + DescribeActivityExecution: grpc.UnaryUnaryMultiCallable[ + temporalio.api.workflowservice.v1.request_response_pb2.DescribeActivityExecutionRequest, + temporalio.api.workflowservice.v1.request_response_pb2.DescribeActivityExecutionResponse, + ] + """DescribeActivityExecution returns information about an activity execution. + It can be used to: + - Get current activity info without waiting + - Long-poll for next state change and return new activity info + Response can optionally include activity input or outcome (if the activity has completed). + """ + PollActivityExecution: grpc.UnaryUnaryMultiCallable[ + temporalio.api.workflowservice.v1.request_response_pb2.PollActivityExecutionRequest, + temporalio.api.workflowservice.v1.request_response_pb2.PollActivityExecutionResponse, + ] + """PollActivityExecution long-polls for an activity execution to complete and returns the + outcome (result or failure). + """ + ListActivityExecutions: grpc.UnaryUnaryMultiCallable[ + temporalio.api.workflowservice.v1.request_response_pb2.ListActivityExecutionsRequest, + temporalio.api.workflowservice.v1.request_response_pb2.ListActivityExecutionsResponse, + ] + """ListActivityExecutions is a visibility API to list activity executions in a specific namespace.""" + CountActivityExecutions: grpc.UnaryUnaryMultiCallable[ + temporalio.api.workflowservice.v1.request_response_pb2.CountActivityExecutionsRequest, + temporalio.api.workflowservice.v1.request_response_pb2.CountActivityExecutionsResponse, + ] + """CountActivityExecutions is a visibility API to count activity executions in a specific namespace.""" + RequestCancelActivityExecution: grpc.UnaryUnaryMultiCallable[ + temporalio.api.workflowservice.v1.request_response_pb2.RequestCancelActivityExecutionRequest, + temporalio.api.workflowservice.v1.request_response_pb2.RequestCancelActivityExecutionResponse, + ] + """RequestCancelActivityExecution requests cancellation of an activity execution. + + Cancellation is cooperative: this call records the request, but the activity must detect and + acknowledge it for the activity to reach CANCELED status. The cancellation signal is + delivered via `cancel_requested` in the heartbeat response; SDKs surface this via + language-idiomatic mechanisms (context cancellation, exceptions, abort signals). + """ + TerminateActivityExecution: grpc.UnaryUnaryMultiCallable[ + temporalio.api.workflowservice.v1.request_response_pb2.TerminateActivityExecutionRequest, + temporalio.api.workflowservice.v1.request_response_pb2.TerminateActivityExecutionResponse, + ] + """TerminateActivityExecution terminates an existing activity execution immediately. + + Termination does not reach the worker and the activity code cannot react to it. A terminated activity may have a + running attempt. + """ + DeleteActivityExecution: grpc.UnaryUnaryMultiCallable[ + temporalio.api.workflowservice.v1.request_response_pb2.DeleteActivityExecutionRequest, + temporalio.api.workflowservice.v1.request_response_pb2.DeleteActivityExecutionResponse, + ] + """DeleteActivityExecution asynchronously deletes a specific activity execution (when + ActivityExecution.run_id is provided) or the latest activity execution (when + ActivityExecution.run_id is not provided). If the activity Execution is running, it will be + terminated before deletion. + + (-- api-linter: core::0127::http-annotation=disabled + aip.dev/not-precedent: Activity deletion not exposed to HTTP, users should use cancel or terminate. --) + """ class WorkflowServiceServicer(metaclass=abc.ABCMeta): """WorkflowService API defines how Temporal SDKs and other clients interact with the Temporal server @@ -1098,10 +1181,17 @@ class WorkflowServiceServicer(metaclass=abc.ABCMeta): ) -> temporalio.api.workflowservice.v1.request_response_pb2.RecordActivityTaskHeartbeatResponse: """RecordActivityTaskHeartbeat is optionally called by workers while they execute activities. - If worker fails to heartbeat within the `heartbeat_timeout` interval for the activity task, - then it will be marked as timed out and an `ACTIVITY_TASK_TIMED_OUT` event will be written to - the workflow history. Calling `RecordActivityTaskHeartbeat` will fail with `NotFound` in - such situations, in that event, the SDK should request cancellation of the activity. + If a worker fails to heartbeat within the `heartbeat_timeout` interval for the activity task, + then the current attempt times out. Depending on RetryPolicy, this may trigger a retry or + time out the activity. + + For workflow activities, an `ACTIVITY_TASK_TIMED_OUT` event will be written to the workflow + history. Calling `RecordActivityTaskHeartbeat` will fail with `NotFound` in such situations, + in that event, the SDK should request cancellation of the activity. + + The request may contain response `details` which will be persisted by the server and may be + used by the activity to checkpoint progress. The `cancel_requested` field in the response + indicates whether cancellation has been requested for the activity. """ @abc.abstractmethod def RecordActivityTaskHeartbeatById( @@ -1124,7 +1214,7 @@ class WorkflowServiceServicer(metaclass=abc.ABCMeta): """RespondActivityTaskCompleted is called by workers when they successfully complete an activity task. - This results in a new `ACTIVITY_TASK_COMPLETED` event being written to the workflow history + For workflow activities, this results in a new `ACTIVITY_TASK_COMPLETED` event being written to the workflow history and a new workflow task created for the workflow. Fails with `NotFound` if the task token is no longer valid due to activity timeout, already being completed, or never having existed. """ @@ -1134,7 +1224,7 @@ class WorkflowServiceServicer(metaclass=abc.ABCMeta): request: temporalio.api.workflowservice.v1.request_response_pb2.RespondActivityTaskCompletedByIdRequest, context: grpc.ServicerContext, ) -> temporalio.api.workflowservice.v1.request_response_pb2.RespondActivityTaskCompletedByIdResponse: - """See `RecordActivityTaskCompleted`. This version allows clients to record completions by + """See `RespondActivityTaskCompleted`. This version allows clients to record completions by namespace/workflow id/activity id instead of task token. (-- api-linter: core::0136::prepositions=disabled @@ -1172,7 +1262,7 @@ class WorkflowServiceServicer(metaclass=abc.ABCMeta): ) -> temporalio.api.workflowservice.v1.request_response_pb2.RespondActivityTaskCanceledResponse: """RespondActivityTaskFailed is called by workers when processing an activity task fails. - This results in a new `ACTIVITY_TASK_CANCELED` event being written to the workflow history + For workflow activities, this results in a new `ACTIVITY_TASK_CANCELED` event being written to the workflow history and a new workflow task created for the workflow. Fails with `NotFound` if the task token is no longer valid due to activity timeout, already being completed, or never having existed. """ @@ -1182,7 +1272,7 @@ class WorkflowServiceServicer(metaclass=abc.ABCMeta): request: temporalio.api.workflowservice.v1.request_response_pb2.RespondActivityTaskCanceledByIdRequest, context: grpc.ServicerContext, ) -> temporalio.api.workflowservice.v1.request_response_pb2.RespondActivityTaskCanceledByIdResponse: - """See `RecordActivityTaskCanceled`. This version allows clients to record failures by + """See `RespondActivityTaskCanceled`. This version allows clients to record failures by namespace/workflow id/activity id instead of task token. (-- api-linter: core::0136::prepositions=disabled @@ -1817,6 +1907,8 @@ class WorkflowServiceServicer(metaclass=abc.ABCMeta): ) -> temporalio.api.workflowservice.v1.request_response_pb2.UpdateActivityOptionsResponse: """UpdateActivityOptions is called by the client to update the options of an activity by its ID or type. If there are multiple pending activities of the provided type - all of them will be updated. + This API will be deprecated soon and replaced with a newer UpdateActivityExecutionOptions that is better named and + structured to work well for standalone activities. """ @abc.abstractmethod def UpdateWorkflowExecutionOptions( @@ -1847,6 +1939,8 @@ class WorkflowServiceServicer(metaclass=abc.ABCMeta): - The activity should respond to the cancellation accordingly. Returns a `NotFound` error if there is no pending activity with the provided ID or type + This API will be deprecated soon and replaced with a newer PauseActivityExecution that is better named and + structured to work well for standalone activities. """ @abc.abstractmethod def UnpauseActivity( @@ -1867,6 +1961,8 @@ class WorkflowServiceServicer(metaclass=abc.ABCMeta): 'reset_heartbeat': the activity heartbeat timer and heartbeats will be reset. Returns a `NotFound` error if there is no pending activity with the provided ID or type + This API will be deprecated soon and replaced with a newer UnpauseActivityExecution that is better named and + structured to work well for standalone activities. """ @abc.abstractmethod def ResetActivity( @@ -1891,6 +1987,8 @@ class WorkflowServiceServicer(metaclass=abc.ABCMeta): 'keep_paused': if the activity is paused, it will remain paused. Returns a `NotFound` error if there is no pending activity with the provided ID or type. + This API will be deprecated soon and replaced with a newer ResetActivityExecution that is better named and + structured to work well for standalone activities. """ @abc.abstractmethod def CreateWorkflowRule( @@ -1991,6 +2089,90 @@ class WorkflowServiceServicer(metaclass=abc.ABCMeta): context: grpc.ServicerContext, ) -> temporalio.api.workflowservice.v1.request_response_pb2.DescribeWorkerResponse: """DescribeWorker returns information about the specified worker.""" + @abc.abstractmethod + def StartActivityExecution( + self, + request: temporalio.api.workflowservice.v1.request_response_pb2.StartActivityExecutionRequest, + context: grpc.ServicerContext, + ) -> temporalio.api.workflowservice.v1.request_response_pb2.StartActivityExecutionResponse: + """StartActivityExecution starts a new activity execution. + + Returns an `ActivityExecutionAlreadyStarted` error if an instance already exists with same activity ID in this namespace + unless permitted by the specified ID conflict policy. + """ + @abc.abstractmethod + def DescribeActivityExecution( + self, + request: temporalio.api.workflowservice.v1.request_response_pb2.DescribeActivityExecutionRequest, + context: grpc.ServicerContext, + ) -> temporalio.api.workflowservice.v1.request_response_pb2.DescribeActivityExecutionResponse: + """DescribeActivityExecution returns information about an activity execution. + It can be used to: + - Get current activity info without waiting + - Long-poll for next state change and return new activity info + Response can optionally include activity input or outcome (if the activity has completed). + """ + @abc.abstractmethod + def PollActivityExecution( + self, + request: temporalio.api.workflowservice.v1.request_response_pb2.PollActivityExecutionRequest, + context: grpc.ServicerContext, + ) -> temporalio.api.workflowservice.v1.request_response_pb2.PollActivityExecutionResponse: + """PollActivityExecution long-polls for an activity execution to complete and returns the + outcome (result or failure). + """ + @abc.abstractmethod + def ListActivityExecutions( + self, + request: temporalio.api.workflowservice.v1.request_response_pb2.ListActivityExecutionsRequest, + context: grpc.ServicerContext, + ) -> temporalio.api.workflowservice.v1.request_response_pb2.ListActivityExecutionsResponse: + """ListActivityExecutions is a visibility API to list activity executions in a specific namespace.""" + @abc.abstractmethod + def CountActivityExecutions( + self, + request: temporalio.api.workflowservice.v1.request_response_pb2.CountActivityExecutionsRequest, + context: grpc.ServicerContext, + ) -> temporalio.api.workflowservice.v1.request_response_pb2.CountActivityExecutionsResponse: + """CountActivityExecutions is a visibility API to count activity executions in a specific namespace.""" + @abc.abstractmethod + def RequestCancelActivityExecution( + self, + request: temporalio.api.workflowservice.v1.request_response_pb2.RequestCancelActivityExecutionRequest, + context: grpc.ServicerContext, + ) -> temporalio.api.workflowservice.v1.request_response_pb2.RequestCancelActivityExecutionResponse: + """RequestCancelActivityExecution requests cancellation of an activity execution. + + Cancellation is cooperative: this call records the request, but the activity must detect and + acknowledge it for the activity to reach CANCELED status. The cancellation signal is + delivered via `cancel_requested` in the heartbeat response; SDKs surface this via + language-idiomatic mechanisms (context cancellation, exceptions, abort signals). + """ + @abc.abstractmethod + def TerminateActivityExecution( + self, + request: temporalio.api.workflowservice.v1.request_response_pb2.TerminateActivityExecutionRequest, + context: grpc.ServicerContext, + ) -> temporalio.api.workflowservice.v1.request_response_pb2.TerminateActivityExecutionResponse: + """TerminateActivityExecution terminates an existing activity execution immediately. + + Termination does not reach the worker and the activity code cannot react to it. A terminated activity may have a + running attempt. + """ + @abc.abstractmethod + def DeleteActivityExecution( + self, + request: temporalio.api.workflowservice.v1.request_response_pb2.DeleteActivityExecutionRequest, + context: grpc.ServicerContext, + ) -> temporalio.api.workflowservice.v1.request_response_pb2.DeleteActivityExecutionResponse: + """DeleteActivityExecution asynchronously deletes a specific activity execution (when + ActivityExecution.run_id is provided) or the latest activity execution (when + ActivityExecution.run_id is not provided). If the activity Execution is running, it will be + terminated before deletion. + + (-- api-linter: core::0127::http-annotation=disabled + aip.dev/not-precedent: Activity deletion not exposed to HTTP, users should use cancel or terminate. --) + """ def add_WorkflowServiceServicer_to_server( servicer: WorkflowServiceServicer, server: grpc.Server diff --git a/temporalio/bridge/sdk-core b/temporalio/bridge/sdk-core index b5a473d42..924a0b1fc 160000 --- a/temporalio/bridge/sdk-core +++ b/temporalio/bridge/sdk-core @@ -1 +1 @@ -Subproject commit b5a473d425e7d63a49f3bbcb08767b9ff46207d0 +Subproject commit 924a0b1fc031de307b4ba18d9c6d955a08475ce6 diff --git a/temporalio/bridge/services_generated.py b/temporalio/bridge/services_generated.py index 34261a18a..7c3eb696b 100644 --- a/temporalio/bridge/services_generated.py +++ b/temporalio/bridge/services_generated.py @@ -27,6 +27,24 @@ def __init__(self, client: ServiceClient): self._client = client self._service = "workflow" + async def count_activity_executions( + self, + req: temporalio.api.workflowservice.v1.CountActivityExecutionsRequest, + retry: bool = False, + metadata: Mapping[str, str | bytes] = {}, + timeout: timedelta | None = None, + ) -> temporalio.api.workflowservice.v1.CountActivityExecutionsResponse: + """Invokes the WorkflowService.count_activity_executions rpc method.""" + return await self._client._rpc_call( + rpc="count_activity_executions", + req=req, + service=self._service, + resp_type=temporalio.api.workflowservice.v1.CountActivityExecutionsResponse, + retry=retry, + metadata=metadata, + timeout=timeout, + ) + async def count_workflow_executions( self, req: temporalio.api.workflowservice.v1.CountWorkflowExecutionsRequest, @@ -81,6 +99,24 @@ async def create_workflow_rule( timeout=timeout, ) + async def delete_activity_execution( + self, + req: temporalio.api.workflowservice.v1.DeleteActivityExecutionRequest, + retry: bool = False, + metadata: Mapping[str, str | bytes] = {}, + timeout: timedelta | None = None, + ) -> temporalio.api.workflowservice.v1.DeleteActivityExecutionResponse: + """Invokes the WorkflowService.delete_activity_execution rpc method.""" + return await self._client._rpc_call( + rpc="delete_activity_execution", + req=req, + service=self._service, + resp_type=temporalio.api.workflowservice.v1.DeleteActivityExecutionResponse, + retry=retry, + metadata=metadata, + timeout=timeout, + ) + async def delete_schedule( self, req: temporalio.api.workflowservice.v1.DeleteScheduleRequest, @@ -189,6 +225,24 @@ async def deprecate_namespace( timeout=timeout, ) + async def describe_activity_execution( + self, + req: temporalio.api.workflowservice.v1.DescribeActivityExecutionRequest, + retry: bool = False, + metadata: Mapping[str, str | bytes] = {}, + timeout: timedelta | None = None, + ) -> temporalio.api.workflowservice.v1.DescribeActivityExecutionResponse: + """Invokes the WorkflowService.describe_activity_execution rpc method.""" + return await self._client._rpc_call( + rpc="describe_activity_execution", + req=req, + service=self._service, + resp_type=temporalio.api.workflowservice.v1.DescribeActivityExecutionResponse, + retry=retry, + metadata=metadata, + timeout=timeout, + ) + async def describe_batch_operation( self, req: temporalio.api.workflowservice.v1.DescribeBatchOperationRequest, @@ -585,6 +639,24 @@ async def get_workflow_execution_history_reverse( timeout=timeout, ) + async def list_activity_executions( + self, + req: temporalio.api.workflowservice.v1.ListActivityExecutionsRequest, + retry: bool = False, + metadata: Mapping[str, str | bytes] = {}, + timeout: timedelta | None = None, + ) -> temporalio.api.workflowservice.v1.ListActivityExecutionsResponse: + """Invokes the WorkflowService.list_activity_executions rpc method.""" + return await self._client._rpc_call( + rpc="list_activity_executions", + req=req, + service=self._service, + resp_type=temporalio.api.workflowservice.v1.ListActivityExecutionsResponse, + retry=retry, + metadata=metadata, + timeout=timeout, + ) + async def list_archived_workflow_executions( self, req: temporalio.api.workflowservice.v1.ListArchivedWorkflowExecutionsRequest, @@ -855,6 +927,24 @@ async def pause_activity( timeout=timeout, ) + async def poll_activity_execution( + self, + req: temporalio.api.workflowservice.v1.PollActivityExecutionRequest, + retry: bool = False, + metadata: Mapping[str, str | bytes] = {}, + timeout: timedelta | None = None, + ) -> temporalio.api.workflowservice.v1.PollActivityExecutionResponse: + """Invokes the WorkflowService.poll_activity_execution rpc method.""" + return await self._client._rpc_call( + rpc="poll_activity_execution", + req=req, + service=self._service, + resp_type=temporalio.api.workflowservice.v1.PollActivityExecutionResponse, + retry=retry, + metadata=metadata, + timeout=timeout, + ) + async def poll_activity_task_queue( self, req: temporalio.api.workflowservice.v1.PollActivityTaskQueueRequest, @@ -1017,6 +1107,24 @@ async def register_namespace( timeout=timeout, ) + async def request_cancel_activity_execution( + self, + req: temporalio.api.workflowservice.v1.RequestCancelActivityExecutionRequest, + retry: bool = False, + metadata: Mapping[str, str | bytes] = {}, + timeout: timedelta | None = None, + ) -> temporalio.api.workflowservice.v1.RequestCancelActivityExecutionResponse: + """Invokes the WorkflowService.request_cancel_activity_execution rpc method.""" + return await self._client._rpc_call( + rpc="request_cancel_activity_execution", + req=req, + service=self._service, + resp_type=temporalio.api.workflowservice.v1.RequestCancelActivityExecutionResponse, + retry=retry, + metadata=metadata, + timeout=timeout, + ) + async def request_cancel_workflow_execution( self, req: temporalio.api.workflowservice.v1.RequestCancelWorkflowExecutionRequest, @@ -1431,6 +1539,24 @@ async def signal_workflow_execution( timeout=timeout, ) + async def start_activity_execution( + self, + req: temporalio.api.workflowservice.v1.StartActivityExecutionRequest, + retry: bool = False, + metadata: Mapping[str, str | bytes] = {}, + timeout: timedelta | None = None, + ) -> temporalio.api.workflowservice.v1.StartActivityExecutionResponse: + """Invokes the WorkflowService.start_activity_execution rpc method.""" + return await self._client._rpc_call( + rpc="start_activity_execution", + req=req, + service=self._service, + resp_type=temporalio.api.workflowservice.v1.StartActivityExecutionResponse, + retry=retry, + metadata=metadata, + timeout=timeout, + ) + async def start_batch_operation( self, req: temporalio.api.workflowservice.v1.StartBatchOperationRequest, @@ -1485,6 +1611,24 @@ async def stop_batch_operation( timeout=timeout, ) + async def terminate_activity_execution( + self, + req: temporalio.api.workflowservice.v1.TerminateActivityExecutionRequest, + retry: bool = False, + metadata: Mapping[str, str | bytes] = {}, + timeout: timedelta | None = None, + ) -> temporalio.api.workflowservice.v1.TerminateActivityExecutionResponse: + """Invokes the WorkflowService.terminate_activity_execution rpc method.""" + return await self._client._rpc_call( + rpc="terminate_activity_execution", + req=req, + service=self._service, + resp_type=temporalio.api.workflowservice.v1.TerminateActivityExecutionResponse, + retry=retry, + metadata=metadata, + timeout=timeout, + ) + async def terminate_workflow_execution( self, req: temporalio.api.workflowservice.v1.TerminateWorkflowExecutionRequest, diff --git a/temporalio/bridge/src/client_rpc_generated.rs b/temporalio/bridge/src/client_rpc_generated.rs index a8674c802..2cd89447c 100644 --- a/temporalio/bridge/src/client_rpc_generated.rs +++ b/temporalio/bridge/src/client_rpc_generated.rs @@ -20,6 +20,14 @@ impl ClientRef { let mut retry_client = self.retry_client.clone(); self.runtime.future_into_py(py, async move { let bytes = match call.rpc.as_str() { + "count_activity_executions" => { + rpc_call!( + retry_client, + call, + WorkflowService, + count_activity_executions + ) + } "count_workflow_executions" => { rpc_call!( retry_client, @@ -34,6 +42,14 @@ impl ClientRef { "create_workflow_rule" => { rpc_call!(retry_client, call, WorkflowService, create_workflow_rule) } + "delete_activity_execution" => { + rpc_call!( + retry_client, + call, + WorkflowService, + delete_activity_execution + ) + } "delete_schedule" => { rpc_call!(retry_client, call, WorkflowService, delete_schedule) } @@ -67,6 +83,14 @@ impl ClientRef { "deprecate_namespace" => { rpc_call!(retry_client, call, WorkflowService, deprecate_namespace) } + "describe_activity_execution" => { + rpc_call!( + retry_client, + call, + WorkflowService, + describe_activity_execution + ) + } "describe_batch_operation" => { rpc_call!( retry_client, @@ -183,6 +207,14 @@ impl ClientRef { get_workflow_execution_history_reverse ) } + "list_activity_executions" => { + rpc_call!( + retry_client, + call, + WorkflowService, + list_activity_executions + ) + } "list_archived_workflow_executions" => { rpc_call!( retry_client, @@ -258,6 +290,9 @@ impl ClientRef { "pause_activity" => { rpc_call!(retry_client, call, WorkflowService, pause_activity) } + "poll_activity_execution" => { + rpc_call!(retry_client, call, WorkflowService, poll_activity_execution) + } "poll_activity_task_queue" => { rpc_call!( retry_client, @@ -310,6 +345,14 @@ impl ClientRef { "register_namespace" => { rpc_call!(retry_client, call, WorkflowService, register_namespace) } + "request_cancel_activity_execution" => { + rpc_call!( + retry_client, + call, + WorkflowService, + request_cancel_activity_execution + ) + } "request_cancel_workflow_execution" => { rpc_call!( retry_client, @@ -474,6 +517,14 @@ impl ClientRef { signal_workflow_execution ) } + "start_activity_execution" => { + rpc_call!( + retry_client, + call, + WorkflowService, + start_activity_execution + ) + } "start_batch_operation" => { rpc_call!(retry_client, call, WorkflowService, start_batch_operation) } @@ -488,6 +539,14 @@ impl ClientRef { "stop_batch_operation" => { rpc_call!(retry_client, call, WorkflowService, stop_batch_operation) } + "terminate_activity_execution" => { + rpc_call!( + retry_client, + call, + WorkflowService, + terminate_activity_execution + ) + } "terminate_workflow_execution" => { rpc_call!( retry_client, diff --git a/temporalio/client.py b/temporalio/client.py index 07ccdc6b2..c9c16732d 100644 --- a/temporalio/client.py +++ b/temporalio/client.py @@ -28,14 +28,8 @@ from typing import ( Any, Concatenate, - Dict, - FrozenSet, Generic, - Optional, - Text, - Tuple, Type, - Union, cast, overload, ) @@ -46,6 +40,8 @@ from google.protobuf.internal.containers import MessageMap from typing_extensions import Required, Self, TypedDict +import temporalio.activity +import temporalio.api.activity.v1 import temporalio.api.common.v1 import temporalio.api.enums.v1 import temporalio.api.errordetails.v1 @@ -67,6 +63,7 @@ import temporalio.workflow from temporalio.activity import ActivityCancellationDetails from temporalio.converter import ( + ActivitySerializationContext, DataConverter, SerializationContext, WithSerializationContext, @@ -1271,6 +1268,246 @@ async def count_workflows( ) ) + # - TODO: Overloads for no-param, single-param, multi-param + # - TODO: Support sync and async activity functions + async def start_activity( + self, + activity: str | Callable[..., Awaitable[ReturnType]], + *, + args: Sequence[Any] = [], + id: str, + task_queue: str, + result_type: Type | None = None, + # Either schedule_to_close_timeout or start_to_close_timeout must be present + schedule_to_close_timeout: timedelta | None = None, + start_to_close_timeout: timedelta | None = None, + schedule_to_start_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, + rpc_metadata: Mapping[str, str | bytes] = {}, + rpc_timeout: timedelta | None = None, + ) -> ActivityHandle[ReturnType]: + """Start an activity and return its handle. + + .. warning:: + This API is experimental. + + Args: + activity: String name or callable activity function to execute. + args: Arguments to pass to the activity. + id: Unique identifier for the activity. Required. + task_queue: Task queue to send the activity to. + result_type: For string name activities, optional type to deserialize result into. + schedule_to_close_timeout: Total time allowed for the activity from schedule to completion. + start_to_close_timeout: Time allowed for a single execution attempt. + schedule_to_start_timeout: Time allowed for the activity to sit in the task queue. + heartbeat_timeout: Time between heartbeats before the activity is considered failed. + id_reuse_policy: How to handle reusing activity IDs from closed activities. + Default is ALLOW_DUPLICATE. + id_conflict_policy: How to handle activity ID conflicts with running activities. + Default is FAIL. + retry_policy: Retry policy for the activity. + search_attributes: Search attributes for the activity. + summary: A single-line fixed summary for this activity that may appear + in the UI/CLI. This can be in single-line Temporal markdown format. + priority: Priority of the activity execution. + rpc_metadata: Headers used on the RPC call. + rpc_timeout: Optional RPC deadline to set for the RPC call. + + Returns: + A handle to the started activity. + """ + name, result_type_from_type_annotation = ( + temporalio.activity._Definition.get_name_and_result_type(activity) + ) + return await self._impl.start_activity( + StartActivityInput( + activity_type=name, + args=args, + id=id, + task_queue=task_queue, + result_type=result_type or result_type_from_type_annotation, + schedule_to_close_timeout=schedule_to_close_timeout, + start_to_close_timeout=start_to_close_timeout, + schedule_to_start_timeout=schedule_to_start_timeout, + heartbeat_timeout=heartbeat_timeout, + id_reuse_policy=id_reuse_policy, + id_conflict_policy=id_conflict_policy, + retry_policy=retry_policy, + search_attributes=search_attributes, + summary=summary, + headers={}, + rpc_metadata=rpc_metadata, + rpc_timeout=rpc_timeout, + priority=priority, + ) + ) + + async def execute_activity( + self, + activity: str | Callable[..., Awaitable[ReturnType]], + *, + args: Sequence[Any] = [], + id: str, + task_queue: str, + result_type: Type | None = None, + # Either schedule_to_close_timeout or start_to_close_timeout must be present + schedule_to_close_timeout: timedelta | None = None, + start_to_close_timeout: timedelta | None = None, + schedule_to_start_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, + rpc_metadata: Mapping[str, str | bytes] = {}, + rpc_timeout: timedelta | None = None, + ) -> ReturnType: + """Start an activity, wait for it to complete, and return its result. + + .. warning:: + This API is experimental. + + This is a convenience method that combines :py:meth:`start_activity` and + :py:meth:`ActivityHandle.result`. + + Returns: + The result of the activity. + + Raises: + ActivityFailedError: If the activity completed with a failure. + """ + handle = await self.start_activity( + activity, + args=args, + id=id, + task_queue=task_queue, + result_type=result_type, + schedule_to_close_timeout=schedule_to_close_timeout, + start_to_close_timeout=start_to_close_timeout, + schedule_to_start_timeout=schedule_to_start_timeout, + heartbeat_timeout=heartbeat_timeout, + id_reuse_policy=id_reuse_policy, + id_conflict_policy=id_conflict_policy, + retry_policy=retry_policy, + search_attributes=search_attributes, + summary=summary, + priority=priority, + rpc_metadata=rpc_metadata, + rpc_timeout=rpc_timeout, + ) + return await handle.result() + + def list_activities( + self, + query: str | None = None, + *, + limit: int | None = None, + page_size: int = 1000, + next_page_token: bytes | None = None, + rpc_metadata: Mapping[str, str | bytes] = {}, + rpc_timeout: timedelta | None = None, + ) -> ActivityExecutionAsyncIterator: + """List activities. + + .. warning:: + This API is experimental. + + This does not make a request until the first iteration is attempted. + Therefore any errors will not occur until then. + + Args: + query: A Temporal visibility list filter for activities. + limit: Maximum number of activities to return. If unset, all + activities are returned. Only applies if using the + returned :py:class:`ActivityExecutionAsyncIterator` + as an async iterator. + page_size: Maximum number of results for each page. + next_page_token: A previously obtained next page token if doing + pagination. Usually not needed as the iterator automatically + starts from the beginning. + rpc_metadata: Headers used on each RPC call. Keys here override + client-level RPC metadata keys. + rpc_timeout: Optional RPC deadline to set for each RPC call. + + Returns: + An async iterator that can be used with ``async for``. + """ + return self._impl.list_activities( + ListActivitiesInput( + query=query, + page_size=page_size, + next_page_token=next_page_token, + rpc_metadata=rpc_metadata, + rpc_timeout=rpc_timeout, + limit=limit, + ) + ) + + async def count_activities( + self, + query: str | None = None, + *, + rpc_metadata: Mapping[str, str | bytes] = {}, + rpc_timeout: timedelta | None = None, + ) -> ActivityExecutionCount: + """Count activities matching the query. + + .. warning:: + This API is experimental. + + Args: + query: A Temporal visibility filter for activities. + rpc_metadata: Headers used on the RPC call. Keys here override + client-level RPC metadata keys. + rpc_timeout: Optional RPC deadline to set for the RPC call. + + Returns: + Count of activities. + """ + return await self._impl.count_activities( + CountActivitiesInput( + query=query, rpc_metadata=rpc_metadata, rpc_timeout=rpc_timeout + ) + ) + + def get_activity_handle( + self, + *, + activity_id: str, + activity_run_id: str | None = None, + ) -> ActivityHandle[Any]: + """Get a handle to an existing activity, as the caller of that activity. + + .. warning:: + This API is experimental. + + To get a handle to an activity execution that you control for manual completion and + heartbeating, see :py:meth:`Client.get_async_activity_handle`. + + Args: + activity_id: The activity ID. + activity_run_id: The activity run ID. If not provided, targets the + latest run. + + Returns: + A handle to the activity. + """ + raise NotImplementedError + + @overload + def get_async_activity_handle( + self, *, activity_id: str, run_id: str | None = None + ) -> AsyncActivityHandle: + pass + @overload def get_async_activity_handle( self, *, workflow_id: str, run_id: str | None, activity_id: str @@ -1281,6 +1518,7 @@ def get_async_activity_handle( def get_async_activity_handle(self, *, task_token: bytes) -> AsyncActivityHandle: pass + # TODO(dan): add typed API get_async_activity_handle_for? def get_async_activity_handle( self, *, @@ -1289,22 +1527,31 @@ def get_async_activity_handle( activity_id: str | None = None, task_token: bytes | None = None, ) -> AsyncActivityHandle: - """Get an async activity handle. + """Get a handle to an activity execution that you control, for manual completion and heartbeating. + + To get a handle to a standalone activity execution as the caller of that activity, see + :py:meth:`Client.get_activity_handle`. + + This function may be used to get a handle to a standalone activity started by a client, or + an activity started by a workflow. + + To get a handle to an activity started by a workflow, use one of the following two calls: + - Supply ``workflow_id``, ``run_id``, and ``activity_id`` + - Supply the activity ``task_token`` alone + + To get a handle to a standalone activity started by a client, supply ``activity_id`` and + ``run_id`` - Either the workflow_id, run_id, and activity_id can be provided, or a - singular task_token can be provided. Args: - workflow_id: Workflow ID for the activity. Cannot be set if - task_token is set. - run_id: Run ID for the activity. Cannot be set if task_token is set. - activity_id: ID for the activity. Cannot be set if task_token is - set. - task_token: Task token for the activity. Cannot be set if any of the - id parameters are set. + workflow_id: Workflow ID for the activity. + run_id: Run ID for the activity. Cannot be + set if task_token is set. + activity_id: ID for the activity. + task_token: Task token for the activity. Returns: - A handle that can be used for completion or heartbeat. + A handle that can be used for completion or heartbeating. """ if task_token is not None: if workflow_id is not None or run_id is not None or activity_id is not None: @@ -1321,7 +1568,18 @@ def get_async_activity_handle( workflow_id=workflow_id, run_id=run_id, activity_id=activity_id ), ) - raise ValueError("Task token or workflow/run/activity ID must be present") + elif activity_id is not None: + return AsyncActivityHandle( + self, + AsyncActivityIDReference( + activity_id=activity_id, + run_id=run_id, + workflow_id=None, + ), + ) + raise ValueError( + "Require task token, or workflow_id & run_id & activity_id, or activity_id & run_id" + ) async def create_schedule( self, @@ -1597,7 +1855,7 @@ def _data_converter(self) -> temporalio.converter.DataConverter: @property def id(self) -> str: - """ID for the workflow.""" + """ID of the workflow.""" return self._id @property @@ -2696,151 +2954,822 @@ async def workflow_handle(self) -> WorkflowHandle[SelfType, ReturnType]: return await self._workflow_handle -@dataclass(frozen=True) -class AsyncActivityIDReference: - """Reference to an async activity by its qualified ID.""" - - workflow_id: str - run_id: str | None - activity_id: str +class ActivityExecutionAsyncIterator: + """Asynchronous iterator for activity execution values. + You should typically use ``async for`` on this iterator and not call any of its methods. -class AsyncActivityHandle(WithSerializationContext): - """Handle representing an external activity for completion and heartbeat.""" + .. warning:: + This API is experimental. + """ def __init__( self, client: Client, - id_or_token: AsyncActivityIDReference | bytes, - data_converter_override: DataConverter | None = None, + input: ListActivitiesInput, ) -> None: - """Create an async activity handle.""" - self._client = client - self._id_or_token = id_or_token - self._data_converter_override = data_converter_override + """Create an asynchronous iterator for the given input. - async def heartbeat( - self, - *details: Any, - rpc_metadata: Mapping[str, str | bytes] = {}, - rpc_timeout: timedelta | None = None, - ) -> None: - """Record a heartbeat for the activity. + Users should not create this directly, but rather use + :py:meth:`Client.list_activities`. + """ + self._client = client + self._input = input + self._next_page_token = input.next_page_token + self._current_page: Sequence[ActivityExecution] | None = None + self._current_page_index = 0 + self._limit = input.limit + self._yielded = 0 - Args: - details: Details of the heartbeat. - rpc_metadata: Headers used on the RPC call. Keys here override - client-level RPC metadata keys. - rpc_timeout: Optional RPC deadline to set for the RPC call. + @property + def current_page_index(self) -> int: + """Index of the entry in the current page that will be returned from + the next :py:meth:`__anext__` call. """ - await self._client._impl.heartbeat_async_activity( - HeartbeatAsyncActivityInput( - id_or_token=self._id_or_token, - details=details, - rpc_metadata=rpc_metadata, - rpc_timeout=rpc_timeout, - data_converter_override=self._data_converter_override, - ), - ) + return self._current_page_index - async def complete( - self, - result: Any | None = temporalio.common._arg_unset, - *, - rpc_metadata: Mapping[str, str | bytes] = {}, - rpc_timeout: timedelta | None = None, - ) -> None: - """Complete the activity. + @property + def current_page(self) -> Sequence[ActivityExecution] | None: + """Current page, if it has been fetched yet.""" + return self._current_page + + @property + def next_page_token(self) -> bytes | None: + """Token for the next page request if any.""" + return self._next_page_token + + async def fetch_next_page(self, *, page_size: int | None = None) -> None: + """Fetch the next page of results. Args: - result: Result of the activity if any. - rpc_metadata: Headers used on the RPC call. Keys here override - client-level RPC metadata keys. - rpc_timeout: Optional RPC deadline to set for the RPC call. + page_size: Override the page size this iterator was originally + created with. """ - await self._client._impl.complete_async_activity( - CompleteAsyncActivityInput( - id_or_token=self._id_or_token, - result=result, - rpc_metadata=rpc_metadata, - rpc_timeout=rpc_timeout, - data_converter_override=self._data_converter_override, + page_size = page_size or self._input.page_size + if self._limit is not None and self._limit - self._yielded < page_size: + page_size = self._limit - self._yielded + + resp = await self._client.workflow_service.list_activity_executions( + temporalio.api.workflowservice.v1.ListActivityExecutionsRequest( + namespace=self._client.namespace, + page_size=page_size, + next_page_token=self._next_page_token or b"", + query=self._input.query or "", ), + retry=True, + metadata=self._input.rpc_metadata, + timeout=self._input.rpc_timeout, ) - async def fail( + self._current_page = [ + ActivityExecution._from_raw_info( + v, self._client.namespace, self._client.data_converter + ) + for v in resp.executions + ] + self._current_page_index = 0 + self._next_page_token = resp.next_page_token or None + + def __aiter__(self) -> ActivityExecutionAsyncIterator: + """Return self as the iterator.""" + return self + + async def __anext__(self) -> ActivityExecution: + """Get the next execution on this iterator, fetching next page if + necessary. + """ + if self._limit is not None and self._yielded >= self._limit: + raise StopAsyncIteration + while True: + # No page? fetch and continue + if self._current_page is None: + await self.fetch_next_page() + continue + # No more left in page? + if self._current_page_index >= len(self._current_page): + # If there is a next page token, try to get another page and try + # again + if self._next_page_token is not None: + await self.fetch_next_page() + continue + # No more pages means we're done + raise StopAsyncIteration + # Get current, increment page index, and return + ret = self._current_page[self._current_page_index] + self._current_page_index += 1 + self._yielded += 1 + return ret + + +@dataclass(frozen=True) +class ActivityExecution: + """Info for a standalone activity execution from list response. + + .. warning:: + This API is experimental. + """ + + activity_id: str + """Activity ID.""" + + activity_run_id: str | None + """Run ID of the activity.""" + + activity_type: str + """Type name of the activity.""" + + close_time: datetime | None + """Time the activity reached a terminal status, if closed.""" + + execution_duration: timedelta | None + """Duration from scheduled to close time, only populated if closed.""" + + namespace: str + """Namespace of the activity (copied from calling client).""" + + raw_info: temporalio.api.activity.v1.ActivityExecutionListInfo + """Underlying protobuf info.""" + + scheduled_time: datetime + """Time the activity was originally scheduled.""" + + search_attributes: temporalio.common.SearchAttributes + """Search attributes from the start request.""" + + status: temporalio.common.ActivityExecutionStatus + """Current status of the activity.""" + + task_queue: str + """Task queue the activity was scheduled on.""" + + @classmethod + def _from_raw_info( + cls, + info: temporalio.api.activity.v1.ActivityExecutionListInfo, + namespace: str, + converter: temporalio.converter.DataConverter, + ) -> Self: + """Create from raw proto activity list info.""" + return cls( + activity_id=info.activity_id, + activity_run_id=info.run_id or None, + activity_type=( + info.activity_type.name if info.HasField("activity_type") else "" + ), + close_time=( + info.close_time.ToDatetime().replace(tzinfo=timezone.utc) + if info.HasField("close_time") + else None + ), + execution_duration=( + info.execution_duration.ToTimedelta() + if info.HasField("execution_duration") + else None + ), + namespace=namespace, + raw_info=info, + scheduled_time=( + info.schedule_time.ToDatetime().replace(tzinfo=timezone.utc) + if info.HasField("schedule_time") + else datetime.min + ), + search_attributes=temporalio.converter.decode_search_attributes( + info.search_attributes + ), + status=( + temporalio.common.ActivityExecutionStatus(info.status) + if info.status + else temporalio.common.ActivityExecutionStatus.RUNNING + ), + task_queue=info.task_queue, + ) + + +@dataclass(frozen=True) +class ActivityExecutionCountAggregationGroup: + """A single aggregation group from a count activities call. + + .. warning:: + This API is experimental. + """ + + count: int + """Count for this group.""" + + group_values: Sequence[Any] + """Values that define this group.""" + + +@dataclass(frozen=True) +class ActivityExecutionCount: + """Representation of a count from a count activities call. + + .. warning:: + This API is experimental. + """ + + count: int + """Total count matching the filter, if any.""" + + groups: Sequence[ActivityExecutionCountAggregationGroup] + """Aggregation groups if requested.""" + + @staticmethod + def _from_raw( + resp: temporalio.api.workflowservice.v1.CountActivityExecutionsResponse, + ) -> ActivityExecutionCount: + """Create from raw proto response.""" + return ActivityExecutionCount( + count=resp.count, + groups=[ + ActivityExecutionCountAggregationGroup( + count=g.count, + group_values=list(g.group_values), + ) + for g in resp.groups + ], + ) + + +@dataclass(frozen=True) +class ActivityExecutionDescription: + """Detailed information about an activity execution from describe response. + + .. warning:: + This API is experimental. + """ + + activity_id: str + """Activity ID.""" + + activity_run_id: str | None + """Run ID of the activity.""" + + activity_type: str + """Type name of the activity.""" + + attempt: int + """Current attempt number.""" + + canceled_reason: str | None + """Reason for cancellation, if cancel was requested.""" + + close_time: datetime | None + """Time the activity reached a terminal status, if closed.""" + + current_retry_interval: timedelta | None + """Time until the next retry, if applicable.""" + + execution_duration: timedelta | None + """Duration from scheduled to close time, only populated if closed.""" + + expiration_time: datetime + """Scheduled time plus schedule_to_close_timeout.""" + + heartbeat_details: Sequence[Any] + """Details from the last heartbeat.""" + + input: Sequence[Any] + """Serialized activity input.""" + + last_attempt_complete_time: datetime | None + """Time when the last attempt completed.""" + + last_failure: Exception | None + """Failure from the last failed attempt, if any.""" + + last_heartbeat_time: datetime | None + """Time of the last heartbeat.""" + + last_started_time: datetime | None + """Time the last attempt was started.""" + + last_worker_identity: str + """Identity of the last worker that processed the activity.""" + + namespace: str + """Namespace of the activity (copied from calling client).""" + + next_attempt_schedule_time: datetime | None + """Time when the next attempt will be scheduled.""" + + raw_info: Any + """Raw proto response.""" + + retry_policy: temporalio.common.RetryPolicy + """Retry policy for the activity.""" + + run_state: temporalio.common.PendingActivityState | None + """More detailed breakdown if status is RUNNING.""" + + scheduled_time: datetime + """Time the activity was originally scheduled.""" + + search_attributes: temporalio.common.SearchAttributes + """Search attributes.""" + + status: temporalio.common.ActivityExecutionStatus + """Current status of the activity.""" + + task_queue: str + """Task queue the activity is scheduled on.""" + + @classmethod + async def _from_raw_info( + cls, + info: temporalio.api.activity.v1.ActivityExecutionInfo, + input: temporalio.api.common.v1.Payloads, + namespace: str, + data_converter: temporalio.converter.DataConverter, + ) -> Self: + """Create from raw proto activity info.""" + return cls( + activity_id=info.activity_id, + activity_run_id=info.run_id or None, + activity_type=( + info.activity_type.name if info.HasField("activity_type") else "" + ), + attempt=info.attempt, + canceled_reason=info.canceled_reason or None, + close_time=( + info.close_time.ToDatetime(tzinfo=timezone.utc) + if info.HasField("close_time") + else None + ), + current_retry_interval=( + info.current_retry_interval.ToTimedelta() + if info.HasField("current_retry_interval") + else None + ), + execution_duration=( + info.execution_duration.ToTimedelta() + if info.HasField("execution_duration") + else None + ), + expiration_time=( + info.expiration_time.ToDatetime(tzinfo=timezone.utc) + if info.HasField("expiration_time") + else datetime.min + ), + heartbeat_details=( + await data_converter.decode(info.heartbeat_details.payloads) + if info.HasField("heartbeat_details") + else [] + ), + input=await data_converter.decode(input.payloads), + last_attempt_complete_time=( + info.last_attempt_complete_time.ToDatetime(tzinfo=timezone.utc) + if info.HasField("last_attempt_complete_time") + else None + ), + last_failure=( + cast( + Exception | None, + await data_converter.decode_failure(info.last_failure), + ) + if info.HasField("last_failure") + else None + ), + last_heartbeat_time=( + info.last_heartbeat_time.ToDatetime(tzinfo=timezone.utc) + if info.HasField("last_heartbeat_time") + else None + ), + last_started_time=( + info.last_started_time.ToDatetime(tzinfo=timezone.utc) + if info.HasField("last_started_time") + else None + ), + last_worker_identity=info.last_worker_identity, + namespace=namespace, + next_attempt_schedule_time=( + info.next_attempt_schedule_time.ToDatetime(tzinfo=timezone.utc) + if info.HasField("next_attempt_schedule_time") + else None + ), + raw_info=info, + retry_policy=temporalio.common.RetryPolicy.from_proto(info.retry_policy), + run_state=( + temporalio.common.PendingActivityState(info.run_state) + if info.run_state + else None + ), + scheduled_time=(info.schedule_time.ToDatetime(tzinfo=timezone.utc)), + search_attributes=temporalio.converter.decode_search_attributes( + info.search_attributes + ), + status=( + temporalio.common.ActivityExecutionStatus(info.status) + if info.status + else temporalio.common.ActivityExecutionStatus.RUNNING + ), + task_queue=info.task_queue, + ) + + +@dataclass(frozen=True) +class ActivityIDReference: + """Information identifying an activity execution. + + .. warning:: + This API is experimental. + """ + + workflow_id: str | None + run_id: str | None + activity_id: str + + +# Deprecated alias +AsyncActivityIDReference = ActivityIDReference + + +class AsyncActivityHandle(WithSerializationContext): + """Handle representing an external activity for completion and heartbeat.""" + + def __init__( + self, + client: Client, + id_or_token: AsyncActivityIDReference | bytes, + data_converter_override: DataConverter | None = None, + ) -> None: + """Create an async activity handle.""" + self._client = client + self._id_or_token = id_or_token + self._data_converter_override = data_converter_override + + async def heartbeat( + self, + *details: Any, + rpc_metadata: Mapping[str, str | bytes] = {}, + rpc_timeout: timedelta | None = None, + ) -> None: + """Record a heartbeat for the activity. + + Args: + details: Details of the heartbeat. + rpc_metadata: Headers used on the RPC call. Keys here override + client-level RPC metadata keys. + rpc_timeout: Optional RPC deadline to set for the RPC call. + """ + await self._client._impl.heartbeat_async_activity( + HeartbeatAsyncActivityInput( + id_or_token=self._id_or_token, + details=details, + rpc_metadata=rpc_metadata, + rpc_timeout=rpc_timeout, + data_converter_override=self._data_converter_override, + ), + ) + + async def complete( + self, + result: Any | None = temporalio.common._arg_unset, + *, + rpc_metadata: Mapping[str, str | bytes] = {}, + rpc_timeout: timedelta | None = None, + ) -> None: + """Complete the activity. + + Args: + result: Result of the activity if any. + rpc_metadata: Headers used on the RPC call. Keys here override + client-level RPC metadata keys. + rpc_timeout: Optional RPC deadline to set for the RPC call. + """ + await self._client._impl.complete_async_activity( + CompleteAsyncActivityInput( + id_or_token=self._id_or_token, + result=result, + rpc_metadata=rpc_metadata, + rpc_timeout=rpc_timeout, + data_converter_override=self._data_converter_override, + ), + ) + + async def fail( + self, + error: Exception, + *, + last_heartbeat_details: Sequence[Any] = [], + rpc_metadata: Mapping[str, str | bytes] = {}, + rpc_timeout: timedelta | None = None, + ) -> None: + """Fail the activity. + + Args: + error: Error for the activity. + last_heartbeat_details: Last heartbeat details for the activity. + rpc_metadata: Headers used on the RPC call. Keys here override + client-level RPC metadata keys. + rpc_timeout: Optional RPC deadline to set for the RPC call. + """ + await self._client._impl.fail_async_activity( + FailAsyncActivityInput( + id_or_token=self._id_or_token, + error=error, + last_heartbeat_details=last_heartbeat_details, + rpc_metadata=rpc_metadata, + rpc_timeout=rpc_timeout, + data_converter_override=self._data_converter_override, + ), + ) + + async def report_cancellation( + self, + *details: Any, + rpc_metadata: Mapping[str, str | bytes] = {}, + rpc_timeout: timedelta | None = None, + ) -> None: + """Report the activity as cancelled. + + Args: + details: Cancellation details. + rpc_metadata: Headers used on the RPC call. Keys here override + client-level RPC metadata keys. + rpc_timeout: Optional RPC deadline to set for the RPC call. + """ + await self._client._impl.report_cancellation_async_activity( + ReportCancellationAsyncActivityInput( + id_or_token=self._id_or_token, + details=details, + rpc_metadata=rpc_metadata, + rpc_timeout=rpc_timeout, + data_converter_override=self._data_converter_override, + ), + ) + + def with_context(self, context: SerializationContext) -> Self: + """Create a new AsyncActivityHandle with a different serialization context. + + Payloads received by the activity will be decoded and deserialized using a data converter + with :py:class:`ActivitySerializationContext` set as context. If you are using a custom data + converter that makes use of this context then you can use this method to supply matching + context data to the data converter used to serialize and encode the outbound payloads. + """ + data_converter = self._client.data_converter.with_context(context) + if data_converter is self._client.data_converter: + return self + cls = type(self) + if cls.__init__ is not AsyncActivityHandle.__init__: + raise TypeError( + "If you have subclassed AsyncActivityHandle and overridden the __init__ method " + "then you must override with_context to return an instance of your class." + ) + return cls( + self._client, + self._id_or_token, + data_converter, + ) + + +# TODO: in the future when messages can be sent to activities, we will want the activity handle to +# be generic in the activity type in addition to the return type (as WorkflowHandle), to support +# static type inference for signal/query/update. +class ActivityHandle(Generic[ReturnType]): + """Handle representing a standalone activity execution. + + .. warning:: + This API is experimental. + """ + + def __init__( + self, + client: Client, + activity_id: str, + *, + activity_run_id: str, + result_type: Type | None = None, + data_converter_override: DataConverter | None = None, + ) -> None: + """Create activity handle.""" + self._client = client + self._activity_id = activity_id + self._activity_run_id = activity_run_id + self._result_type = result_type + self._data_converter_override = data_converter_override + self._known_outcome: ( + temporalio.api.activity.v1.ActivityExecutionOutcome | None + ) = None + + @property + def activity_id(self) -> str: + """ID of the activity.""" + return self._activity_id + + @property + def activity_run_id(self) -> str: + """Run ID of the activity.""" + return self._activity_run_id + + def with_context(self, context: SerializationContext) -> Self: + """Create a new ActivityHandle with a different serialization context. + + Payloads received by the activity will be decoded and deserialized using a data converter + with :py:class:`ActivitySerializationContext` set as context. If you are using a custom data + converter that makes use of this context then you can use this method to supply matching + context data to the data converter used to serialize and encode the outbound payloads. + """ + data_converter = self._client.data_converter.with_context(context) + if data_converter is self._client.data_converter: + return self + cls = type(self) + if cls.__init__ is not ActivityHandle.__init__: + raise TypeError( + "If you have subclassed ActivityHandle and overridden the __init__ method " + "then you must override with_context to return an instance of your class." + ) + return cls( + self._client, + activity_id=self._activity_id, + activity_run_id=self._activity_run_id, + result_type=self._result_type, + data_converter_override=data_converter, + ) + + async def result( + self, + *, + rpc_metadata: Mapping[str, str | bytes] = {}, + rpc_timeout: timedelta | None = None, + ) -> ReturnType: + """Wait for result of the activity. + + .. warning:: + This API is experimental. + + The result may already be known if this method has been called before, + in which case no network call is made. Otherwise the result will be + polled for until it is available. + + Args: + rpc_metadata: Headers used on the RPC call. Keys here override + client-level RPC metadata keys. + rpc_timeout: Optional RPC deadline to set for each RPC call. Note: + this is the timeout for each RPC call while polling, not a + timeout for the function as a whole. If an individual RPC + times out, it will be retried until the result is available. + + Returns: + The result of the activity. + + Raises: + ActivityFailureError: If the activity completed with a failure. + RPCError: Activity result could not be fetched for some reason. + """ + await self._poll_until_outcome( + rpc_metadata=rpc_metadata, rpc_timeout=rpc_timeout + ) + data_converter = self._data_converter_override or self._client.data_converter + assert self._known_outcome + if self._known_outcome.HasField("failure"): + raise ActivityFailedError( + cause=await data_converter.decode_failure(self._known_outcome.failure), + ) + payloads = self._known_outcome.result + if not payloads.payloads: + # E.g. a void workflow function in another language may not set any payloads. + return None # type: ignore + type_hints = [self._result_type] if self._result_type else None + results = await data_converter.decode(payloads.payloads, type_hints) + if not results: + # Following workflow/update/query result processing. Technically not necessary since + # from_payloads is documented to always return non-empty + return None # type: ignore + elif len(results) > 1: + warnings.warn(f"Expected single activity result, got {len(results)}") + return results[0] + + async def _poll_until_outcome( + self, + rpc_metadata: Mapping[str, str | bytes] = {}, + rpc_timeout: timedelta | None = None, + ) -> None: + """Poll for activity result until it's available.""" + if self._known_outcome: + return + + req = temporalio.api.workflowservice.v1.PollActivityExecutionRequest( + namespace=self._client.namespace, + activity_id=self._activity_id, + run_id=self._activity_run_id, + ) + + # Continue polling as long as we have no outcome + while True: + try: + res = await self._client.workflow_service.poll_activity_execution( + req, + retry=True, + metadata=rpc_metadata, + timeout=rpc_timeout, + ) + if res.HasField("outcome"): + self._known_outcome = res.outcome + return + except RPCError as err: + if err.status == RPCStatusCode.DEADLINE_EXCEEDED: + # Deadline exceeded is expected with long polling; retry + continue + elif err.status == RPCStatusCode.CANCELLED: + raise asyncio.CancelledError() from err + else: + raise + except asyncio.CancelledError: + raise + + async def cancel( + self, + *, + reason: str | None = None, + wait_for_cancel_completed: bool = False, + rpc_metadata: Mapping[str, str | bytes] = {}, + rpc_timeout: timedelta | None = None, + ) -> None: + """Request cancellation of the activity. + + .. warning:: + This API is experimental. + + Requesting cancellation of an activity does not automatically transition the activity to + canceled status. If the activity is heartbeating, a :py:class:`exceptions.CancelledError` + exception will be raised when receiving the heartbeat response; if the activity allows this + exception to bubble out, the activity will transition to canceled status. If the activity it + is not heartbeating, this method will have no effect on activity status. + + Args: + reason: Reason for the cancellation. Recorded and available via describe. + wait_for_cancel_completed: If True, wait for the activity to be canceled before returning. + rpc_metadata: Headers used on the RPC call. + rpc_timeout: Optional RPC deadline to set for the RPC call. + """ + await self._client._impl.cancel_activity( + CancelActivityInput( + activity_id=self._activity_id, + activity_run_id=self._activity_run_id, + reason=reason, + wait_for_cancel_completed=wait_for_cancel_completed, + rpc_metadata=rpc_metadata, + rpc_timeout=rpc_timeout, + ) + ) + + async def terminate( self, - error: Exception, *, - last_heartbeat_details: Sequence[Any] = [], + reason: str | None = None, rpc_metadata: Mapping[str, str | bytes] = {}, rpc_timeout: timedelta | None = None, ) -> None: - """Fail the activity. + """Terminate the activity execution immediately. + + .. warning:: + This API is experimental. + + Termination does not reach the worker and the activity code cannot react to it. + A terminated activity may have a running attempt and will be requested to be + canceled by the server when it heartbeats. Args: - error: Error for the activity. - last_heartbeat_details: Last heartbeat details for the activity. - rpc_metadata: Headers used on the RPC call. Keys here override - client-level RPC metadata keys. + reason: Reason for the termination. + rpc_metadata: Headers used on the RPC call. rpc_timeout: Optional RPC deadline to set for the RPC call. """ - await self._client._impl.fail_async_activity( - FailAsyncActivityInput( - id_or_token=self._id_or_token, - error=error, - last_heartbeat_details=last_heartbeat_details, + await self._client._impl.terminate_activity( + TerminateActivityInput( + activity_id=self._activity_id, + activity_run_id=self._activity_run_id, + reason=reason, rpc_metadata=rpc_metadata, rpc_timeout=rpc_timeout, - data_converter_override=self._data_converter_override, - ), + ) ) - async def report_cancellation( + async def describe( self, - *details: Any, + *, rpc_metadata: Mapping[str, str | bytes] = {}, rpc_timeout: timedelta | None = None, - ) -> None: - """Report the activity as cancelled. + ) -> ActivityExecutionDescription: + """Describe the activity execution. + + .. warning:: + This API is experimental. Args: - details: Cancellation details. - rpc_metadata: Headers used on the RPC call. Keys here override - client-level RPC metadata keys. + rpc_metadata: Headers used on the RPC call. rpc_timeout: Optional RPC deadline to set for the RPC call. + + Returns: + Activity execution description. """ - await self._client._impl.report_cancellation_async_activity( - ReportCancellationAsyncActivityInput( - id_or_token=self._id_or_token, - details=details, + return await self._client._impl.describe_activity( + DescribeActivityInput( + activity_id=self._activity_id, + activity_run_id=self._activity_run_id, rpc_metadata=rpc_metadata, rpc_timeout=rpc_timeout, - data_converter_override=self._data_converter_override, - ), - ) - - def with_context(self, context: SerializationContext) -> Self: - """Create a new AsyncActivityHandle with a different serialization context. - - Payloads received by the activity will be decoded and deserialized using a data converter - with :py:class:`ActivitySerializationContext` set as context. If you are using a custom data - converter that makes use of this context then you can use this method to supply matching - context data to the data converter used to serialize and encode the outbound payloads. - """ - data_converter = self._client.data_converter.with_context(context) - if data_converter is self._client.data_converter: - return self - cls = type(self) - if cls.__init__ is not AsyncActivityHandle.__init__: - raise TypeError( - "If you have subclassed AsyncActivityHandle and overridden the __init__ method " - "then you must override with_context to return an instance of your class." ) - return cls( - self._client, - self._id_or_token, - data_converter, ) @@ -5268,6 +6197,25 @@ def __init__(self) -> None: super().__init__("Timeout or cancellation waiting for update") +class ActivityFailedError(temporalio.exceptions.TemporalError): + """Error that occurs when a standalone activity is unsuccessful. + + .. warning:: + This API is experimental. + """ + + def __init__(self, *, cause: BaseException) -> None: + """Create activity failure error.""" + super().__init__("Activity execution failed") + self.__cause__ = cause + + @property + def cause(self) -> BaseException: + """Cause of the activity failure.""" + assert self.__cause__ + return self.__cause__ + + class AsyncActivityCancelledError(temporalio.exceptions.TemporalError): """Error that occurs when async activity attempted heartbeat but was cancelled.""" @@ -5422,6 +6370,108 @@ class TerminateWorkflowInput: rpc_timeout: timedelta | None +@dataclass +class StartActivityInput: + """Input for :py:meth:`OutboundInterceptor.start_activity`. + + .. warning:: + This API is experimental. + """ + + activity_type: str + args: Sequence[Any] + id: str + task_queue: str + result_type: Type | None + schedule_to_close_timeout: timedelta | None + start_to_close_timeout: timedelta | None + schedule_to_start_timeout: timedelta | None + heartbeat_timeout: timedelta | None + id_reuse_policy: temporalio.common.ActivityIDReusePolicy + id_conflict_policy: temporalio.common.ActivityIDConflictPolicy + retry_policy: temporalio.common.RetryPolicy | None + priority: temporalio.common.Priority + search_attributes: temporalio.common.TypedSearchAttributes | None + summary: str | None + headers: Mapping[str, temporalio.api.common.v1.Payload] + rpc_metadata: Mapping[str, str | bytes] + rpc_timeout: timedelta | None + + +@dataclass +class CancelActivityInput: + """Input for :py:meth:`OutboundInterceptor.cancel_activity`. + + .. warning:: + This API is experimental. + """ + + activity_id: str + activity_run_id: str | None + reason: str | None + wait_for_cancel_completed: bool + rpc_metadata: Mapping[str, str | bytes] + rpc_timeout: timedelta | None + + +@dataclass +class TerminateActivityInput: + """Input for :py:meth:`OutboundInterceptor.terminate_activity`. + + .. warning:: + This API is experimental. + """ + + activity_id: str + activity_run_id: str | None + reason: str | None + rpc_metadata: Mapping[str, str | bytes] + rpc_timeout: timedelta | None + + +@dataclass +class DescribeActivityInput: + """Input for :py:meth:`OutboundInterceptor.describe_activity`. + + .. warning:: + This API is experimental. + """ + + activity_id: str + activity_run_id: str | None + rpc_metadata: Mapping[str, str | bytes] + rpc_timeout: timedelta | None + + +@dataclass +class ListActivitiesInput: + """Input for :py:meth:`OutboundInterceptor.list_activities`. + + .. warning:: + This API is experimental. + """ + + query: str | None + page_size: int + next_page_token: bytes | None + rpc_metadata: Mapping[str, str | bytes] + rpc_timeout: timedelta | None + limit: int | None + + +@dataclass +class CountActivitiesInput: + """Input for :py:meth:`OutboundInterceptor.count_activities`. + + .. warning:: + This API is experimental. + """ + + query: str | None + rpc_metadata: Mapping[str, str | bytes] + rpc_timeout: timedelta | None + + @dataclass class StartWorkflowUpdateInput: """Input for :py:meth:`OutboundInterceptor.start_workflow_update`.""" @@ -5503,7 +6553,7 @@ class StartWorkflowUpdateWithStartInput: class HeartbeatAsyncActivityInput: """Input for :py:meth:`OutboundInterceptor.heartbeat_async_activity`.""" - id_or_token: AsyncActivityIDReference | bytes + id_or_token: ActivityIDReference | bytes details: Sequence[Any] rpc_metadata: Mapping[str, str | bytes] rpc_timeout: timedelta | None @@ -5514,7 +6564,7 @@ class HeartbeatAsyncActivityInput: class CompleteAsyncActivityInput: """Input for :py:meth:`OutboundInterceptor.complete_async_activity`.""" - id_or_token: AsyncActivityIDReference | bytes + id_or_token: ActivityIDReference | bytes result: Any | None rpc_metadata: Mapping[str, str | bytes] rpc_timeout: timedelta | None @@ -5525,7 +6575,7 @@ class CompleteAsyncActivityInput: class FailAsyncActivityInput: """Input for :py:meth:`OutboundInterceptor.fail_async_activity`.""" - id_or_token: AsyncActivityIDReference | bytes + id_or_token: ActivityIDReference | bytes error: Exception last_heartbeat_details: Sequence[Any] rpc_metadata: Mapping[str, str | bytes] @@ -5537,7 +6587,7 @@ class FailAsyncActivityInput: class ReportCancellationAsyncActivityInput: """Input for :py:meth:`OutboundInterceptor.report_cancellation_async_activity`.""" - id_or_token: AsyncActivityIDReference | bytes + id_or_token: ActivityIDReference | bytes details: Sequence[Any] rpc_metadata: Mapping[str, str | bytes] rpc_timeout: timedelta | None @@ -5756,6 +6806,62 @@ async def terminate_workflow(self, input: TerminateWorkflowInput) -> None: """Called for every :py:meth:`WorkflowHandle.terminate` call.""" await self.next.terminate_workflow(input) + ### Activity calls + + async def start_activity(self, input: StartActivityInput) -> ActivityHandle[Any]: + """Called for every :py:meth:`Client.start_activity` call. + + .. warning:: + This API is experimental. + """ + return await self.next.start_activity(input) + + async def cancel_activity(self, input: CancelActivityInput) -> None: + """Called for every :py:meth:`ActivityHandle.cancel` call. + + .. warning:: + This API is experimental. + """ + await self.next.cancel_activity(input) + + async def terminate_activity(self, input: TerminateActivityInput) -> None: + """Called for every :py:meth:`ActivityHandle.terminate` call. + + .. warning:: + This API is experimental. + """ + await self.next.terminate_activity(input) + + async def describe_activity( + self, input: DescribeActivityInput + ) -> ActivityExecutionDescription: + """Called for every :py:meth:`ActivityHandle.describe` call. + + .. warning:: + This API is experimental. + """ + return await self.next.describe_activity(input) + + def list_activities( + self, input: ListActivitiesInput + ) -> ActivityExecutionAsyncIterator: + """Called for every :py:meth:`Client.list_activities` call. + + .. warning:: + This API is experimental. + """ + return self.next.list_activities(input) + + async def count_activities( + self, input: CountActivitiesInput + ) -> ActivityExecutionCount: + """Called for every :py:meth:`Client.count_activities` call. + + .. warning:: + This API is experimental. + """ + return await self.next.count_activities(input) + async def start_workflow_update( self, input: StartWorkflowUpdateInput ) -> WorkflowUpdateHandle[Any]: @@ -6207,6 +7313,178 @@ async def terminate_workflow(self, input: TerminateWorkflowInput) -> None: req, retry=True, metadata=input.rpc_metadata, timeout=input.rpc_timeout ) + async def start_activity(self, input: StartActivityInput) -> ActivityHandle[Any]: + """Start an activity and return a handle to it.""" + if not (input.start_to_close_timeout or input.schedule_to_close_timeout): + raise ValueError( + "Activity must have start_to_close_timeout or schedule_to_close_timeout" + ) + req = await self._build_start_activity_execution_request(input) + + # TODO(dan): any counterpart of WorkflowExecutionAlreadyStartedFailure? + # If RPCError with err.status == RPCStatusCode.ALREADY_EXISTS + + resp = await self._client.workflow_service.start_activity_execution( + req, + retry=True, + metadata=input.rpc_metadata, + timeout=input.rpc_timeout, + ) + return ActivityHandle( + self._client, + activity_id=input.id, + activity_run_id=resp.run_id, + result_type=input.result_type, + ) + + async def _build_start_activity_execution_request( + self, input: StartActivityInput + ) -> temporalio.api.workflowservice.v1.StartActivityExecutionRequest: + """Build StartActivityExecutionRequest from input.""" + data_converter = self._client.data_converter.with_context( + ActivitySerializationContext( + namespace=self._client.namespace, + activity_id=input.id, + activity_type=input.activity_type, + activity_task_queue=input.task_queue, + is_local=False, + workflow_id=None, + workflow_type=None, + ) + ) + + req = temporalio.api.workflowservice.v1.StartActivityExecutionRequest( + namespace=self._client.namespace, + identity=self._client.identity, + activity_id=input.id, + activity_type=temporalio.api.common.v1.ActivityType( + name=input.activity_type + ), + task_queue=temporalio.api.taskqueue.v1.TaskQueue(name=input.task_queue), + id_reuse_policy=cast( + "temporalio.api.enums.v1.ActivityIdReusePolicy.ValueType", + int(input.id_reuse_policy), + ), + id_conflict_policy=cast( + "temporalio.api.enums.v1.ActivityIdConflictPolicy.ValueType", + int(input.id_conflict_policy), + ), + ) + + if input.schedule_to_close_timeout is not None: + req.schedule_to_close_timeout.FromTimedelta(input.schedule_to_close_timeout) + if input.start_to_close_timeout is not None: + req.start_to_close_timeout.FromTimedelta(input.start_to_close_timeout) + if input.schedule_to_start_timeout is not None: + req.schedule_to_start_timeout.FromTimedelta(input.schedule_to_start_timeout) + if input.heartbeat_timeout is not None: + req.heartbeat_timeout.FromTimedelta(input.heartbeat_timeout) + if input.retry_policy is not None: + input.retry_policy.apply_to_proto(req.retry_policy) + + # Set input payloads + if input.args: + req.input.payloads.extend(await data_converter.encode(input.args)) + + # Set search attributes + if input.search_attributes is not None: + temporalio.converter.encode_search_attributes( + input.search_attributes, req.search_attributes + ) + + # Set user metadata + metadata = await _encode_user_metadata(data_converter, input.summary, None) + if metadata is not None: + req.user_metadata.CopyFrom(metadata) + + # Set headers + if input.headers is not None: + await self._apply_headers(input.headers, req.header.fields) + + # Set priority + if input.priority is not None: + req.priority.CopyFrom(input.priority._to_proto()) + + return req + + async def cancel_activity(self, input: CancelActivityInput) -> None: + """Cancel a standalone activity.""" + await self._client.workflow_service.request_cancel_activity_execution( + temporalio.api.workflowservice.v1.RequestCancelActivityExecutionRequest( + namespace=self._client.namespace, + activity_id=input.activity_id, + run_id=input.activity_run_id or "", + identity=self._client.identity, + request_id=str(uuid.uuid4()), + reason=input.reason or "", + ), + retry=True, + metadata=input.rpc_metadata, + timeout=input.rpc_timeout, + ) + + async def terminate_activity(self, input: TerminateActivityInput) -> None: + """Terminate a standalone activity.""" + await self._client.workflow_service.terminate_activity_execution( + temporalio.api.workflowservice.v1.TerminateActivityExecutionRequest( + namespace=self._client.namespace, + activity_id=input.activity_id, + run_id=input.activity_run_id or "", + reason=input.reason or "", + identity=self._client.identity, + ), + retry=True, + metadata=input.rpc_metadata, + timeout=input.rpc_timeout, + ) + + async def describe_activity( + self, input: DescribeActivityInput + ) -> ActivityExecutionDescription: + """Describe a standalone activity.""" + resp = await self._client.workflow_service.describe_activity_execution( + temporalio.api.workflowservice.v1.DescribeActivityExecutionRequest( + namespace=self._client.namespace, + activity_id=input.activity_id, + run_id=input.activity_run_id or "", + include_input=True, + ), + retry=True, + metadata=input.rpc_metadata, + timeout=input.rpc_timeout, + ) + return await ActivityExecutionDescription._from_raw_info( + info=resp.info, + input=resp.input, + namespace=self._client.namespace, + data_converter=self._client.data_converter.with_context( + WorkflowSerializationContext( + namespace=self._client.namespace, + workflow_id=input.activity_id, # Using activity_id as workflow_id for standalone activities + ) + ), + ) + + def list_activities( + self, input: ListActivitiesInput + ) -> ActivityExecutionAsyncIterator: + return ActivityExecutionAsyncIterator(self._client, input) + + async def count_activities( + self, input: CountActivitiesInput + ) -> ActivityExecutionCount: + return ActivityExecutionCount._from_raw( + await self._client.workflow_service.count_activity_executions( + temporalio.api.workflowservice.v1.CountActivityExecutionsRequest( + namespace=self._client.namespace, + query=input.query or "", + ), + retry=True, + metadata=input.rpc_metadata, + timeout=input.rpc_timeout, + ) + ) + async def start_workflow_update( self, input: StartWorkflowUpdateInput ) -> WorkflowUpdateHandle[Any]: @@ -6450,7 +7728,7 @@ async def heartbeat_async_activity( if isinstance(input.id_or_token, AsyncActivityIDReference): resp_by_id = await self._client.workflow_service.record_activity_task_heartbeat_by_id( temporalio.api.workflowservice.v1.RecordActivityTaskHeartbeatByIdRequest( - workflow_id=input.id_or_token.workflow_id, + workflow_id=input.id_or_token.workflow_id or "", run_id=input.id_or_token.run_id or "", activity_id=input.id_or_token.activity_id, namespace=self._client.namespace, @@ -6505,7 +7783,7 @@ async def complete_async_activity(self, input: CompleteAsyncActivityInput) -> No if isinstance(input.id_or_token, AsyncActivityIDReference): await self._client.workflow_service.respond_activity_task_completed_by_id( temporalio.api.workflowservice.v1.RespondActivityTaskCompletedByIdRequest( - workflow_id=input.id_or_token.workflow_id, + workflow_id=input.id_or_token.workflow_id or "", run_id=input.id_or_token.run_id or "", activity_id=input.id_or_token.activity_id, namespace=self._client.namespace, @@ -6542,7 +7820,7 @@ async def fail_async_activity(self, input: FailAsyncActivityInput) -> None: if isinstance(input.id_or_token, AsyncActivityIDReference): await self._client.workflow_service.respond_activity_task_failed_by_id( temporalio.api.workflowservice.v1.RespondActivityTaskFailedByIdRequest( - workflow_id=input.id_or_token.workflow_id, + workflow_id=input.id_or_token.workflow_id or "", run_id=input.id_or_token.run_id or "", activity_id=input.id_or_token.activity_id, namespace=self._client.namespace, @@ -6580,7 +7858,7 @@ async def report_cancellation_async_activity( if isinstance(input.id_or_token, AsyncActivityIDReference): await self._client.workflow_service.respond_activity_task_canceled_by_id( temporalio.api.workflowservice.v1.RespondActivityTaskCanceledByIdRequest( - workflow_id=input.id_or_token.workflow_id, + workflow_id=input.id_or_token.workflow_id or "", run_id=input.id_or_token.run_id or "", activity_id=input.id_or_token.activity_id, namespace=self._client.namespace, diff --git a/temporalio/common.py b/temporalio/common.py index a4bb5f60a..40bbeb920 100644 --- a/temporalio/common.py +++ b/temporalio/common.py @@ -14,11 +14,6 @@ Any, ClassVar, Generic, - List, - Optional, - Text, - Tuple, - Type, TypeAlias, TypeVar, Union, @@ -152,6 +147,96 @@ class WorkflowIDConflictPolicy(IntEnum): ) +class ActivityIDReusePolicy(IntEnum): + """How already-closed activity IDs are handled on start. + + .. warning:: + This API is experimental. + + See :py:class:`temporalio.api.enums.v1.ActivityIdReusePolicy`. + """ + + UNSPECIFIED = int( + temporalio.api.enums.v1.ActivityIdReusePolicy.ACTIVITY_ID_REUSE_POLICY_UNSPECIFIED + ) + ALLOW_DUPLICATE = int( + temporalio.api.enums.v1.ActivityIdReusePolicy.ACTIVITY_ID_REUSE_POLICY_ALLOW_DUPLICATE + ) + ALLOW_DUPLICATE_FAILED_ONLY = int( + temporalio.api.enums.v1.ActivityIdReusePolicy.ACTIVITY_ID_REUSE_POLICY_ALLOW_DUPLICATE_FAILED_ONLY + ) + REJECT_DUPLICATE = int( + temporalio.api.enums.v1.ActivityIdReusePolicy.ACTIVITY_ID_REUSE_POLICY_REJECT_DUPLICATE + ) + + +class ActivityIDConflictPolicy(IntEnum): + """How already-running activity IDs are handled on start. + + .. warning:: + This API is experimental. + + See :py:class:`temporalio.api.enums.v1.ActivityIdConflictPolicy`. + """ + + UNSPECIFIED = int( + temporalio.api.enums.v1.ActivityIdConflictPolicy.ACTIVITY_ID_CONFLICT_POLICY_UNSPECIFIED + ) + FAIL = int( + temporalio.api.enums.v1.ActivityIdConflictPolicy.ACTIVITY_ID_CONFLICT_POLICY_FAIL + ) + USE_EXISTING = int( + temporalio.api.enums.v1.ActivityIdConflictPolicy.ACTIVITY_ID_CONFLICT_POLICY_USE_EXISTING + ) + + +class ActivityExecutionStatus(IntEnum): + """Status of a standalone activity execution. + + .. warning:: + This API is experimental. + + See :py:class:`temporalio.api.enums.v1.ActivityExecutionStatus`. + """ + + UNSPECIFIED = 0 # ACTIVITY_EXECUTION_STATUS_UNSPECIFIED + RUNNING = 1 # ACTIVITY_EXECUTION_STATUS_RUNNING + COMPLETED = 2 # ACTIVITY_EXECUTION_STATUS_COMPLETED + FAILED = 3 # ACTIVITY_EXECUTION_STATUS_FAILED + CANCELED = 4 # ACTIVITY_EXECUTION_STATUS_CANCELED + TERMINATED = 5 # ACTIVITY_EXECUTION_STATUS_TERMINATED + TIMED_OUT = 6 # ACTIVITY_EXECUTION_STATUS_TIMED_OUT + + +class PendingActivityState(IntEnum): + """State of a pending activity. + + .. warning:: + This API is experimental. + + See :py:class:`temporalio.api.enums.v1.PendingActivityState`. + """ + + UNSPECIFIED = int( + temporalio.api.enums.v1.PendingActivityState.PENDING_ACTIVITY_STATE_UNSPECIFIED + ) + SCHEDULED = int( + temporalio.api.enums.v1.PendingActivityState.PENDING_ACTIVITY_STATE_SCHEDULED + ) + STARTED = int( + temporalio.api.enums.v1.PendingActivityState.PENDING_ACTIVITY_STATE_STARTED + ) + CANCEL_REQUESTED = int( + temporalio.api.enums.v1.PendingActivityState.PENDING_ACTIVITY_STATE_CANCEL_REQUESTED + ) + PAUSED = int( + temporalio.api.enums.v1.PendingActivityState.PENDING_ACTIVITY_STATE_PAUSED + ) + PAUSE_REQUESTED = int( + temporalio.api.enums.v1.PendingActivityState.PENDING_ACTIVITY_STATE_PAUSE_REQUESTED + ) + + class QueryRejectCondition(IntEnum): """Whether a query should be rejected in certain conditions. diff --git a/temporalio/contrib/openai_agents/_mcp.py b/temporalio/contrib/openai_agents/_mcp.py index 76d558b82..d961ee4c8 100644 --- a/temporalio/contrib/openai_agents/_mcp.py +++ b/temporalio/contrib/openai_agents/_mcp.py @@ -441,7 +441,7 @@ def name(self) -> str: def _get_activities(self) -> Sequence[Callable]: def _server_id(): - return self.name + "@" + activity.info().workflow_run_id + return self.name + "@" + (activity.info().workflow_run_id or "") @activity.defn(name=self.name + "-list-tools") async def list_tools() -> list[MCPTool]: @@ -487,7 +487,7 @@ async def connect( ) -> None: heartbeat_task = asyncio.create_task(heartbeat_every(30)) - server_id = self.name + "@" + activity.info().workflow_run_id + server_id = self.name + "@" + (activity.info().workflow_run_id or "") if server_id in self._servers: raise ApplicationError( "Cannot connect to an already running server. Use a distinct name if running multiple servers in one workflow." diff --git a/temporalio/contrib/opentelemetry.py b/temporalio/contrib/opentelemetry.py index ef1e52bb2..3e08ea68d 100644 --- a/temporalio/contrib/opentelemetry.py +++ b/temporalio/contrib/opentelemetry.py @@ -355,14 +355,15 @@ async def execute_activity( self, input: temporalio.worker.ExecuteActivityInput ) -> Any: info = temporalio.activity.info() + attributes: dict[str, str] = {"temporalActivityID": info.activity_id} + if info.workflow_id: + attributes["temporalWorkflowID"] = info.workflow_id + if info.workflow_run_id: + attributes["temporalRunID"] = info.workflow_run_id with self.root._start_as_current_span( f"RunActivity:{info.activity_type}", context=self.root._context_from_headers(input.headers), - attributes={ - "temporalWorkflowID": info.workflow_id, - "temporalRunID": info.workflow_run_id, - "temporalActivityID": info.activity_id, - }, + attributes=attributes, kind=opentelemetry.trace.SpanKind.SERVER, ): return await super().execute_activity(input) diff --git a/temporalio/converter.py b/temporalio/converter.py index 8af1e1dc6..21a6d6d90 100644 --- a/temporalio/converter.py +++ b/temporalio/converter.py @@ -89,15 +89,7 @@ class SerializationContext(ABC): @dataclass(frozen=True) -class BaseWorkflowSerializationContext(SerializationContext): - """Base serialization context shared by workflow and activity serialization contexts.""" - - namespace: str - workflow_id: str - - -@dataclass(frozen=True) -class WorkflowSerializationContext(BaseWorkflowSerializationContext): +class WorkflowSerializationContext(SerializationContext): """Serialization context for workflows. See :py:class:`SerializationContext` for more details. @@ -110,30 +102,51 @@ class WorkflowSerializationContext(BaseWorkflowSerializationContext): when the workflow is created by the schedule. """ - pass + namespace: str + """Namespace.""" + + workflow_id: Optional[str] + """Workflow ID.""" @dataclass(frozen=True) -class ActivitySerializationContext(BaseWorkflowSerializationContext): +class ActivitySerializationContext(SerializationContext): """Serialization context for activities. See :py:class:`SerializationContext` for more details. Attributes: namespace: Workflow/activity namespace. - workflow_id: Workflow ID. Note, when creating/describing schedules, + activity_id: Activity ID. Optional if this is an activity started from a workflow. + activity_type: Activity type. + activity_task_queue: Activity task queue. + workflow_id: Workflow ID. Only set if this is an activity started from a workflow. Note, when creating/describing schedules, this may be the workflow ID prefix as configured, not the final workflow ID when the workflow is created by the schedule. - workflow_type: Workflow Type. - activity_type: Activity Type. - activity_task_queue: Activity task queue. - is_local: Whether the activity is a local activity. + workflow_type: Workflow Type. Only set if this is an activity started from a workflow. + is_local: Whether the activity is a local activity. False if this is a standalone activity started directly by a client. """ - workflow_type: str + namespace: str + """Namespace.""" + + activity_id: Optional[str] + """Activity ID. Optional if this is an activity started from a workflow.""" + activity_type: str + """Activity type.""" + activity_task_queue: str + """Activity task queue.""" + + workflow_id: Optional[str] + """Workflow ID if this is an activity started from a workflow.""" + + workflow_type: Optional[str] + """Workflow type if this is an activity started from a workflow.""" + is_local: bool + """Whether the activity is a local activity started from a workflow.""" class WithSerializationContext(ABC): diff --git a/temporalio/exceptions.py b/temporalio/exceptions.py index 61c04166d..41504f16c 100644 --- a/temporalio/exceptions.py +++ b/temporalio/exceptions.py @@ -248,6 +248,10 @@ class RetryState(IntEnum): ) +# TODO: This error class has required history event fields. I propose we retain it as +# workflow-specific and introduce client.ActivityFailureError for an error in a standalone activity. +# We could deprecate this name and introduce WorkflowActivityError as a preferred-going-forwards +# alias. class ActivityError(FailureError): """Error raised on activity failure.""" @@ -363,6 +367,8 @@ def retry_state(self) -> RetryState | None: return self._retry_state +# TODO: This error class has required history event fields. Would we retain it as workflow-specific +# and introduce client.NexusOperationFailureError? See related note on ActivityError above. class NexusOperationError(FailureError): """Error raised on Nexus operation failure inside a Workflow.""" diff --git a/temporalio/testing/_activity.py b/temporalio/testing/_activity.py index 99150381c..dec473a85 100644 --- a/temporalio/testing/_activity.py +++ b/temporalio/testing/_activity.py @@ -31,6 +31,7 @@ heartbeat_details=[], heartbeat_timeout=None, is_local=False, + namespace="default", schedule_to_close_timeout=timedelta(seconds=1), scheduled_time=_utc_zero, start_to_close_timeout=timedelta(seconds=1), @@ -43,6 +44,7 @@ workflow_type="test", priority=temporalio.common.Priority.default, retry_policy=None, + activity_run_id=None, ) diff --git a/temporalio/worker/_activity.py b/temporalio/worker/_activity.py index f74ee7872..f72b06e2f 100644 --- a/temporalio/worker/_activity.py +++ b/temporalio/worker/_activity.py @@ -21,8 +21,6 @@ from typing import ( Any, NoReturn, - Optional, - Union, ) import google.protobuf.duration_pb2 @@ -252,10 +250,11 @@ async def _heartbeat_async( data_converter = self._data_converter if activity.info: context = temporalio.converter.ActivitySerializationContext( - namespace=activity.info.workflow_namespace, + namespace=activity.info.namespace, workflow_id=activity.info.workflow_id, workflow_type=activity.info.workflow_type, activity_type=activity.info.activity_type, + activity_id=activity.info.activity_id, activity_task_queue=self._task_queue, is_local=activity.info.is_local, ) @@ -308,6 +307,7 @@ async def _handle_start_activity_task( workflow_id=start.workflow_execution.workflow_id, workflow_type=start.workflow_type, activity_type=start.activity_type, + activity_id=start.activity_id, activity_task_queue=self._task_queue, is_local=start.is_local, ) @@ -547,6 +547,8 @@ async def _execute_activity( ) from err # Build info + # Determine if this is a standalone activity + is_standalone = not start.workflow_execution.workflow_id info = temporalio.activity.Info( activity_id=start.activity_id, activity_type=start.activity_type, @@ -559,6 +561,7 @@ async def _execute_activity( if start.HasField("heartbeat_timeout") else None, is_local=start.is_local, + namespace=start.workflow_namespace or self._client.namespace, schedule_to_close_timeout=_proto_to_non_zero_timedelta( start.schedule_to_close_timeout ) @@ -573,14 +576,15 @@ async def _execute_activity( started_time=_proto_to_datetime(start.started_time), task_queue=self._task_queue, task_token=task_token, - workflow_id=start.workflow_execution.workflow_id, - workflow_namespace=start.workflow_namespace, - workflow_run_id=start.workflow_execution.run_id, - workflow_type=start.workflow_type, + workflow_id=start.workflow_execution.workflow_id or None, + workflow_namespace=start.workflow_namespace or None, + workflow_run_id=start.workflow_execution.run_id or None, + workflow_type=start.workflow_type or None, priority=temporalio.common.Priority._from_proto(start.priority), retry_policy=temporalio.common.RetryPolicy.from_proto(start.retry_policy) if start.HasField("retry_policy") else None, + activity_run_id=getattr(start, "run_id", None) if is_standalone else None, ) if self._encode_headers and data_converter.payload_codec is not None: diff --git a/temporalio/worker/_workflow_instance.py b/temporalio/worker/_workflow_instance.py index 1139be042..c2a81c4d6 100644 --- a/temporalio/worker/_workflow_instance.py +++ b/temporalio/worker/_workflow_instance.py @@ -794,6 +794,7 @@ def _apply_resolve_activity( workflow_id=self._info.workflow_id, workflow_type=self._info.workflow_type, activity_type=handle._input.activity, + activity_id=handle._input.activity_id, activity_task_queue=( handle._input.task_queue or self._info.task_queue if isinstance(handle._input, StartActivityInput) @@ -2129,6 +2130,7 @@ def get_serialization_context( workflow_id=self._info.workflow_id, workflow_type=self._info.workflow_type, activity_type=activity_handle._input.activity, + activity_id=activity_handle._input.activity_id, activity_task_queue=( activity_handle._input.task_queue if isinstance(activity_handle._input, StartActivityInput) @@ -2924,6 +2926,7 @@ def __init__( workflow_id=self._instance._info.workflow_id, workflow_type=self._instance._info.workflow_type, activity_type=self._input.activity, + activity_id=self._input.activity_id, activity_task_queue=( self._input.task_queue or self._instance._info.task_queue if isinstance(self._input, StartActivityInput) diff --git a/tests/test_activity.py b/tests/test_activity.py new file mode 100644 index 000000000..0aa5fe4de --- /dev/null +++ b/tests/test_activity.py @@ -0,0 +1,291 @@ +import asyncio +import uuid +from dataclasses import dataclass +from datetime import timedelta + +import pytest + +from temporalio import activity, workflow +from temporalio.client import ActivityFailedError, Client +from temporalio.common import ActivityExecutionStatus +from temporalio.exceptions import ApplicationError, CancelledError +from temporalio.worker import Worker + + +@activity.defn +async def increment(input: int) -> int: + return input + 1 + + +async def test_describe(client: Client): + activity_id = str(uuid.uuid4()) + task_queue = str(uuid.uuid4()) + + activity_handle = await client.start_activity( + increment, + args=(1,), + id=activity_id, + task_queue=task_queue, + start_to_close_timeout=timedelta(seconds=5), + ) + desc = await activity_handle.describe() + assert desc.activity_id == activity_id + assert desc.activity_run_id == activity_handle.activity_run_id + assert desc.activity_type == "increment" + assert desc.task_queue == task_queue + assert desc.status == ActivityExecutionStatus.RUNNING + + +async def test_get_result(client: Client): + activity_id = str(uuid.uuid4()) + task_queue = str(uuid.uuid4()) + + activity_handle = await client.start_activity( + increment, + args=(1,), + id=activity_id, + task_queue=task_queue, + start_to_close_timeout=timedelta(seconds=5), + ) + result_via_execute_activity = client.execute_activity( + increment, + args=(1,), + id=activity_id, + task_queue=task_queue, + start_to_close_timeout=timedelta(seconds=5), + ) + + async with Worker( + client, + task_queue=task_queue, + activities=[increment], + ): + assert await activity_handle.result() == 2 + assert await result_via_execute_activity == 2 + + +@dataclass +class ActivityInput: + wait_for_signal_workflow_id: str + wait_for_activity_start_workflow_id: str | None = None + + +@activity.defn +async def async_activity(input: ActivityInput) -> int: + # Notify test that the activity has started and is ready to be completed manually + await ( + activity.client() + .get_workflow_handle(input.wait_for_signal_workflow_id) + .signal(WaitForSignalWorkflow.signal) + ) + activity.raise_complete_async() + + +async def test_manual_completion(client: Client): + activity_id = str(uuid.uuid4()) + task_queue = str(uuid.uuid4()) + wait_for_signal_workflow_id = str(uuid.uuid4()) + + activity_handle = await client.start_activity( + async_activity, + args=( + ActivityInput(wait_for_signal_workflow_id=wait_for_signal_workflow_id), + ), # TODO: overloads + id=activity_id, + task_queue=task_queue, + start_to_close_timeout=timedelta(seconds=5), + ) + + async with Worker( + client, + task_queue=task_queue, + activities=[async_activity], + workflows=[WaitForSignalWorkflow], + ): + # Wait for activity to start + await client.execute_workflow( + WaitForSignalWorkflow.run, + id=wait_for_signal_workflow_id, + task_queue=task_queue, + ) + # Complete activity manually + async_activity_handle = client.get_async_activity_handle( + activity_id=activity_id, + run_id=activity_handle.activity_run_id, + ) + await async_activity_handle.complete(7) + assert await activity_handle.result() == 7 + + desc = await activity_handle.describe() + assert desc.status == ActivityExecutionStatus.COMPLETED + + +async def test_manual_cancellation(client: Client): + pytest.skip(reason="https://temporalio.atlassian.net/browse/ACT-647") + activity_id = str(uuid.uuid4()) + task_queue = str(uuid.uuid4()) + wait_for_signal_workflow_id = str(uuid.uuid4()) + + activity_handle = await client.start_activity( + async_activity, + args=( + ActivityInput(wait_for_signal_workflow_id=wait_for_signal_workflow_id), + ), # TODO: overloads + id=activity_id, + task_queue=task_queue, + start_to_close_timeout=timedelta(seconds=5), + ) + + async with Worker( + client, + task_queue=task_queue, + activities=[async_activity], + workflows=[WaitForSignalWorkflow], + ): + await client.execute_workflow( + WaitForSignalWorkflow.run, + id=wait_for_signal_workflow_id, + task_queue=task_queue, + ) + async_activity_handle = client.get_async_activity_handle( + activity_id=activity_id, + run_id=activity_handle.activity_run_id, + ) + await async_activity_handle.report_cancellation("Test cancellation") + with pytest.raises(ActivityFailedError) as err: + await activity_handle.result() + assert isinstance(err.value.cause, CancelledError) + assert list(err.value.cause.details) == ["Test cancellation"] + + desc = await activity_handle.describe() + assert desc.status == ActivityExecutionStatus.CANCELED + + +async def test_manual_failure(client: Client): + activity_id = str(uuid.uuid4()) + task_queue = str(uuid.uuid4()) + wait_for_signal_workflow_id = str(uuid.uuid4()) + + activity_handle = await client.start_activity( + async_activity, + args=( + ActivityInput(wait_for_signal_workflow_id=wait_for_signal_workflow_id), + ), # TODO: overloads + id=activity_id, + task_queue=task_queue, + start_to_close_timeout=timedelta(seconds=5), + ) + async with Worker( + client, + task_queue=task_queue, + activities=[async_activity], + workflows=[WaitForSignalWorkflow], + ): + await client.execute_workflow( + WaitForSignalWorkflow.run, + id=wait_for_signal_workflow_id, + task_queue=task_queue, + ) + async_activity_handle = client.get_async_activity_handle( + activity_id=activity_id, + run_id=activity_handle.activity_run_id, + ) + await async_activity_handle.fail( + ApplicationError("Test failure", non_retryable=True) + ) + with pytest.raises(ActivityFailedError) as err: + await activity_handle.result() + assert isinstance(err.value.cause, ApplicationError) + assert str(err.value.cause) == "Test failure" + + desc = await activity_handle.describe() + assert desc.status == ActivityExecutionStatus.FAILED + + +@activity.defn +async def activity_for_testing_heartbeat(input: ActivityInput) -> str: + info = activity.info() + if info.attempt == 1: + # Signal that activity has started (only on first attempt) + if input.wait_for_activity_start_workflow_id: + await ( + activity.client() + .get_workflow_handle( + workflow_id=input.wait_for_activity_start_workflow_id, + ) + .signal(WaitForSignalWorkflow.signal) + ) + wait_for_heartbeat_wf_handle = await activity.client().start_workflow( + WaitForSignalWorkflow.run, + id=input.wait_for_signal_workflow_id, + task_queue=activity.info().task_queue, + ) + # Wait for test to notify that it has sent heartbeat + await wait_for_heartbeat_wf_handle.result() + raise Exception("Intentional error to force retry") + elif info.attempt == 2: + [heartbeat_data] = info.heartbeat_details + assert isinstance(heartbeat_data, str) + return heartbeat_data + else: + raise AssertionError(f"Unexpected attempt number: {info.attempt}") + + +async def test_manual_heartbeat(client: Client): + activity_id = str(uuid.uuid4()) + task_queue = str(uuid.uuid4()) + wait_for_signal_workflow_id = str(uuid.uuid4()) + wait_for_activity_start_workflow_id = str(uuid.uuid4()) + + activity_handle = await client.start_activity( + activity_for_testing_heartbeat, + args=( + ActivityInput( + wait_for_signal_workflow_id=wait_for_signal_workflow_id, + wait_for_activity_start_workflow_id=wait_for_activity_start_workflow_id, + ), + ), # TODO: overloads + id=activity_id, + task_queue=task_queue, + start_to_close_timeout=timedelta(seconds=5), + ) + wait_for_activity_start_wf_handle = await client.start_workflow( + WaitForSignalWorkflow.run, + id=wait_for_activity_start_workflow_id, + task_queue=task_queue, + ) + async with Worker( + client, + task_queue=task_queue, + activities=[activity_for_testing_heartbeat], + workflows=[WaitForSignalWorkflow], + ): + async_activity_handle = client.get_async_activity_handle( + activity_id=activity_id, + run_id=activity_handle.activity_run_id, + ) + await wait_for_activity_start_wf_handle.result() + await async_activity_handle.heartbeat("Test heartbeat details") + await client.get_workflow_handle( + workflow_id=wait_for_signal_workflow_id, + ).signal(WaitForSignalWorkflow.signal) + assert await activity_handle.result() == "Test heartbeat details" + + +# Utilities + + +@workflow.defn +class WaitForSignalWorkflow: + # Like a global asyncio.Event() + + def __init__(self) -> None: + self.signal_received = asyncio.Event() + + @workflow.run + async def run(self) -> None: + await self.signal_received.wait() + + @workflow.signal + def signal(self) -> None: + self.signal_received.set() diff --git a/tests/test_serialization_context.py b/tests/test_serialization_context.py index 07d48bdd3..cc2797bb3 100644 --- a/tests/test_serialization_context.py +++ b/tests/test_serialization_context.py @@ -180,6 +180,7 @@ async def run(self, data: TraceData) -> TraceData: data, start_to_close_timeout=timedelta(seconds=10), heartbeat_timeout=timedelta(seconds=2), + activity_id="activity-id", ) data = await workflow.execute_child_workflow( EchoWorkflow.run, data, id=f"{workflow.info().workflow_id}_child" @@ -232,6 +233,7 @@ async def test_payload_conversion_calls_follow_expected_sequence_and_contexts( workflow_id=workflow_id, workflow_type=PayloadConversionWorkflow.__name__, activity_type=passthrough_activity.__name__, + activity_id="activity-id", activity_task_queue=task_queue, is_local=False, ) @@ -329,6 +331,7 @@ async def run(self) -> TraceData: initial_interval=timedelta(milliseconds=100), maximum_attempts=2, ), + activity_id="activity-id", ) @@ -371,6 +374,7 @@ async def test_heartbeat_details_payload_conversion(client: Client): workflow_id=workflow_id, workflow_type=HeartbeatDetailsSerializationContextTestWorkflow.__name__, activity_type=activity_with_heartbeat_details.__name__, + activity_id="activity-id", activity_task_queue=task_queue, is_local=False, ) @@ -420,6 +424,7 @@ async def run(self, data: TraceData) -> TraceData: local_activity, data, start_to_close_timeout=timedelta(seconds=10), + activity_id="activity-id", ) @@ -460,6 +465,7 @@ async def test_local_activity_payload_conversion(client: Client): workflow_id=workflow_id, workflow_type=LocalActivityWorkflow.__name__, activity_type=local_activity.__name__, + activity_id="activity-id", activity_task_queue=task_queue, is_local=True, ) @@ -505,7 +511,7 @@ async def test_local_activity_payload_conversion(client: Client): @workflow.defn -class EventWorkflow: +class WaitForSignalWorkflow: # Like a global asyncio.Event() def __init__(self) -> None: @@ -522,10 +528,11 @@ def signal(self) -> None: @activity.defn async def async_activity() -> TraceData: + # Notify test that the activity has started and is ready to be completed manually await ( activity.client() .get_workflow_handle("activity-started-wf-id") - .signal(EventWorkflow.signal) + .signal(WaitForSignalWorkflow.signal) ) activity.raise_complete_async() @@ -559,7 +566,7 @@ async def test_async_activity_completion_payload_conversion( task_queue=task_queue, workflows=[ AsyncActivityCompletionSerializationContextTestWorkflow, - EventWorkflow, + WaitForSignalWorkflow, ], activities=[async_activity], workflow_runner=UnsandboxedWorkflowRunner(), # so that we can use isinstance @@ -573,12 +580,13 @@ async def test_async_activity_completion_payload_conversion( workflow_id=workflow_id, workflow_type=AsyncActivityCompletionSerializationContextTestWorkflow.__name__, activity_type=async_activity.__name__, + activity_id="async-activity-id", activity_task_queue=task_queue, is_local=False, ) act_started_wf_handle = await client.start_workflow( - EventWorkflow.run, + WaitForSignalWorkflow.run, id="activity-started-wf-id", task_queue=task_queue, ) @@ -645,6 +653,7 @@ def test_subclassed_async_activity_handle(client: Client): workflow_id="workflow-id", workflow_type="workflow-type", activity_type="activity-type", + activity_id="activity-id", activity_task_queue="activity-task-queue", is_local=False, ) @@ -1059,11 +1068,12 @@ async def run(self) -> Never: failing_activity, start_to_close_timeout=timedelta(seconds=10), retry_policy=RetryPolicy(maximum_attempts=1), + activity_id="activity-id", ) raise Exception("Unreachable") -test_traces: dict[str, list[TraceItem]] = defaultdict(list) +test_traces: dict[Optional[str], list[TraceItem]] = defaultdict(list) class FailureConverterWithContext(DefaultFailureConverter, WithSerializationContext): @@ -1155,6 +1165,7 @@ async def test_failure_converter_with_context(client: Client): workflow_id=workflow_id, workflow_type=FailureConverterTestWorkflow.__name__, activity_type=failing_activity.__name__, + activity_id="activity-id", activity_task_queue=task_queue, is_local=False, ) @@ -1323,6 +1334,7 @@ async def run(self, data: str) -> str: codec_test_local_activity, data, start_to_close_timeout=timedelta(seconds=10), + activity_id="activity-id", ) @@ -1361,6 +1373,7 @@ async def test_local_activity_codec_with_context(client: Client): workflow_id=workflow_id, workflow_type=LocalActivityCodecTestWorkflow.__name__, activity_type=codec_test_local_activity.__name__, + activity_id="activity-id", activity_task_queue=task_queue, is_local=True, ) @@ -1594,6 +1607,7 @@ async def run(self, data: str) -> str: payload_encryption_activity, "outbound", start_to_close_timeout=timedelta(seconds=10), + activity_id="activity-id", ), workflow.execute_child_workflow( PayloadEncryptionChildWorkflow.run, diff --git a/tests/worker/test_activity.py b/tests/worker/test_activity.py index 7a9e27f84..4228a8950 100644 --- a/tests/worker/test_activity.py +++ b/tests/worker/test_activity.py @@ -1260,6 +1260,9 @@ def async_handle(self, client: Client, use_task_token: bool) -> AsyncActivityHan assert self._info if use_task_token: return client.get_async_activity_handle(task_token=self._info.task_token) + assert ( + self._info.workflow_id + ) # These tests are for workflow-triggered activities return client.get_async_activity_handle( workflow_id=self._info.workflow_id, run_id=self._info.workflow_run_id, @@ -1740,8 +1743,8 @@ async def wait_cancel() -> str: req = temporalio.api.workflowservice.v1.ResetActivityRequest( namespace=client.namespace, execution=temporalio.api.common.v1.WorkflowExecution( - workflow_id=activity.info().workflow_id, - run_id=activity.info().workflow_run_id, + workflow_id=activity.info().workflow_id or "", + run_id=activity.info().workflow_run_id or "", ), id=activity.info().activity_id, ) @@ -1760,8 +1763,8 @@ def sync_wait_cancel() -> str: req = temporalio.api.workflowservice.v1.ResetActivityRequest( namespace=client.namespace, execution=temporalio.api.common.v1.WorkflowExecution( - workflow_id=activity.info().workflow_id, - run_id=activity.info().workflow_run_id, + workflow_id=activity.info().workflow_id or "", + run_id=activity.info().workflow_run_id or "", ), id=activity.info().activity_id, ) @@ -1812,8 +1815,8 @@ async def wait_cancel() -> str: req = temporalio.api.workflowservice.v1.ResetActivityRequest( namespace=client.namespace, execution=temporalio.api.common.v1.WorkflowExecution( - workflow_id=activity.info().workflow_id, - run_id=activity.info().workflow_run_id, + workflow_id=activity.info().workflow_id or "", + run_id=activity.info().workflow_run_id or "", ), id=activity.info().activity_id, ) diff --git a/uv.lock b/uv.lock index 92edd6f73..76ce83f28 100644 --- a/uv.lock +++ b/uv.lock @@ -2976,7 +2976,7 @@ requires-dist = [ { name = "grpcio", marker = "extra == 'grpc'", specifier = ">=1.48.2,<2" }, { name = "mcp", marker = "extra == 'openai-agents'", specifier = ">=1.9.4,<2" }, { name = "nexus-rpc", specifier = "==1.3.0" }, - { name = "openai-agents", marker = "extra == 'openai-agents'", specifier = ">=0.6.3,<0.7" }, + { name = "openai-agents", marker = "extra == 'openai-agents'", specifier = ">=0.3,<0.7" }, { name = "opentelemetry-api", marker = "extra == 'opentelemetry'", specifier = ">=1.11.1,<2" }, { name = "opentelemetry-sdk", marker = "extra == 'opentelemetry'", specifier = ">=1.11.1,<2" }, { name = "protobuf", specifier = ">=3.20,<7.0.0" }, @@ -2996,8 +2996,8 @@ dev = [ { name = "maturin", specifier = ">=1.8.2" }, { name = "mypy", specifier = "==1.18.2" }, { name = "mypy-protobuf", specifier = ">=3.3.0,<4" }, - { name = "openai-agents", marker = "python_full_version >= '3.14'", specifier = ">=0.6.3,<0.7" }, - { name = "openai-agents", extras = ["litellm"], marker = "python_full_version < '3.14'", specifier = ">=0.6.3,<0.7" }, + { name = "openai-agents", marker = "python_full_version >= '3.14'", specifier = ">=0.3,<0.7" }, + { name = "openai-agents", extras = ["litellm"], marker = "python_full_version < '3.14'", specifier = ">=0.3,<0.7" }, { name = "psutil", specifier = ">=5.9.3,<6" }, { name = "pydocstyle", specifier = ">=6.3.0,<7" }, { name = "pydoctor", specifier = ">=25.10.1,<26" },