dex-python-sdk 0.0.1__py3-none-any.whl

dex/dexpb/dex_pb2_grpc.py

@@ -0,0 +1,1126 @@
+# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT!
+"""Client and server classes corresponding to protobuf-defined services."""
+import grpc
+import warnings
+
+from . import dex_pb2 as dex__pb2
+from google.protobuf import empty_pb2 as google_dot_protobuf_dot_empty__pb2
+
+GRPC_GENERATED_VERSION = '1.83.0'
+GRPC_VERSION = grpc.__version__
+_version_not_supported = False
+
+try:
+    from grpc._utilities import first_version_is_lower
+    _version_not_supported = first_version_is_lower(GRPC_VERSION, GRPC_GENERATED_VERSION)
+except ImportError:
+    _version_not_supported = True
+
+if _version_not_supported:
+    raise RuntimeError(
+        f'The grpc package installed is at version {GRPC_VERSION},'
+        + ' but the generated code in dex_pb2_grpc.py depends on'
+        + f' grpcio>={GRPC_GENERATED_VERSION}.'
+        + f' Please upgrade your grpc module to grpcio>={GRPC_GENERATED_VERSION}'
+        + f' or downgrade your generated code using grpcio-tools<={GRPC_VERSION}.'
+    )
+
+
+class FlowServiceStub:
+    """---------------------------------------------------------------------------
+    FlowService error handling
+
+    Failures return a gRPC status with dexpb.ErrorResponse in status details
+    (see ErrorResponse / ErrorSubStatus). Clients should read both the gRPC code
+    and ErrorResponse.sub_status / detail / original_worker_error_*.
+
+    Common gRPC codes (all RPCs unless noted):
+    InvalidArgument   — bad request / invalid Value / empty lock keys, etc.
+    sub_status usually UNCATEGORIZED
+    AlreadyExists     — StartFlow when ID already running
+    sub_status FLOW_ALREADY_STARTED
+    NotFound          — unknown flow/run
+    sub_status FLOW_NOT_EXISTS
+    FailedPrecondition — closed/invalid flow state; blob-backed WaitForAttribute;
+    Dex application WorkerService failures (business errors
+    and unreachable/dial/transport to the app worker). These
+    must not use Unavailable so they do not count against
+    server SLA/SLO. sub_status WORKER_API_ERROR when from
+    WorkerService; raw worker code/detail/type in
+    original_worker_error_* when available
+    Aborted           — locking RPC attribute lock contention
+    sub_status WORKER_API_ERROR
+    ResourceExhausted — worker connection pool / message size limits
+    DeadlineExceeded  — wait past effective deadline (WaitForFlow,
+    WaitForStepCompletion, WaitForAttribute)
+    sub_status LONG_POLL_TIME_OUT
+    Canceled          — caller canceled the RPC context
+    Unavailable       — Temporal/Cadence backend (workflow engine) unavailable
+    only — never Dex application WorkerService
+    Internal          — unexpected / violated trusted invariant
+    Unimplemented     — Cadence: WaitForStepCompletion, WaitForAttribute,
+    locking InvokeRPC (Temporal sync update required)
+
+    Notable per-RPC behavior:
+    InvokeRPC — empty LockAttributeKeys: API calls WorkerService then may signal;
+    WorkerService errors (app or transport-to-worker) → FailedPrecondition +
+    WORKER_API_ERROR + OriginalWorker* when present.
+    non-empty LockAttributeKeys: Temporal sync update; same worker mapping via
+    handleError; Cadence → Unimplemented.
+    WaitForStepCompletion / WaitForAttribute — Temporal-only sync updates; API
+    retries CONTINUE_AS_NEW_PREEMPTED (not exposed as Internal). Timeout →
+    DeadlineExceeded + LONG_POLL_TIME_OUT. WaitForAttribute rejects waiting on
+    blob-backed stored attributes with FailedPrecondition.
+    WaitForFlow — long-poll timeout while still running → DeadlineExceeded +
+    LONG_POLL_TIME_OUT.
+    ---------------------------------------------------------------------------
+
+    Hosted by Dex server; SDKs call these RPCs.
+    """
+
+    def __init__(self, channel):
+        """Constructor.
+
+        Args:
+            channel: A grpc.Channel.
+        """
+        self.StartFlow = channel.unary_unary(
+                '/dex.FlowService/StartFlow',
+                request_serializer=dex__pb2.StartFlowRequest.SerializeToString,
+                response_deserializer=dex__pb2.StartFlowResponse.FromString,
+                _registered_method=True)
+        self.PublishToChannel = channel.unary_unary(
+                '/dex.FlowService/PublishToChannel',
+                request_serializer=dex__pb2.PublishToChannelRequest.SerializeToString,
+                response_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
+                _registered_method=True)
+        self.StopFlow = channel.unary_unary(
+                '/dex.FlowService/StopFlow',
+                request_serializer=dex__pb2.StopFlowRequest.SerializeToString,
+                response_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
+                _registered_method=True)
+        self.GetAttributes = channel.unary_unary(
+                '/dex.FlowService/GetAttributes',
+                request_serializer=dex__pb2.GetAttributesRequest.SerializeToString,
+                response_deserializer=dex__pb2.GetAttributesResponse.FromString,
+                _registered_method=True)
+        self.SetAttributes = channel.unary_unary(
+                '/dex.FlowService/SetAttributes',
+                request_serializer=dex__pb2.SetAttributesRequest.SerializeToString,
+                response_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
+                _registered_method=True)
+        self.LoadBlobs = channel.unary_unary(
+                '/dex.FlowService/LoadBlobs',
+                request_serializer=dex__pb2.LoadBlobsRequest.SerializeToString,
+                response_deserializer=dex__pb2.LoadBlobsResponse.FromString,
+                _registered_method=True)
+        self.WaitForFlow = channel.unary_unary(
+                '/dex.FlowService/WaitForFlow',
+                request_serializer=dex__pb2.WaitForFlowRequest.SerializeToString,
+                response_deserializer=dex__pb2.WaitForFlowResponse.FromString,
+                _registered_method=True)
+        self.SearchFlows = channel.unary_unary(
+                '/dex.FlowService/SearchFlows',
+                request_serializer=dex__pb2.SearchFlowsRequest.SerializeToString,
+                response_deserializer=dex__pb2.SearchFlowsResponse.FromString,
+                _registered_method=True)
+        self.ResetFlow = channel.unary_unary(
+                '/dex.FlowService/ResetFlow',
+                request_serializer=dex__pb2.ResetFlowRequest.SerializeToString,
+                response_deserializer=dex__pb2.ResetFlowResponse.FromString,
+                _registered_method=True)
+        self.InvokeRPC = channel.unary_unary(
+                '/dex.FlowService/InvokeRPC',
+                request_serializer=dex__pb2.InvokeRPCRequest.SerializeToString,
+                response_deserializer=dex__pb2.InvokeRPCResponse.FromString,
+                _registered_method=True)
+        self.SkipTimer = channel.unary_unary(
+                '/dex.FlowService/SkipTimer',
+                request_serializer=dex__pb2.SkipTimerRequest.SerializeToString,
+                response_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
+                _registered_method=True)
+        self.UpdateFlowConfig = channel.unary_unary(
+                '/dex.FlowService/UpdateFlowConfig',
+                request_serializer=dex__pb2.UpdateFlowConfigRequest.SerializeToString,
+                response_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
+                _registered_method=True)
+        self.WaitForStepCompletion = channel.unary_unary(
+                '/dex.FlowService/WaitForStepCompletion',
+                request_serializer=dex__pb2.WaitForStepCompletionRequest.SerializeToString,
+                response_deserializer=dex__pb2.WaitForStepCompletionResponse.FromString,
+                _registered_method=True)
+        self.WaitForAttribute = channel.unary_unary(
+                '/dex.FlowService/WaitForAttribute',
+                request_serializer=dex__pb2.WaitForAttributeRequest.SerializeToString,
+                response_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
+                _registered_method=True)
+        self.TriggerContinueAsNew = channel.unary_unary(
+                '/dex.FlowService/TriggerContinueAsNew',
+                request_serializer=dex__pb2.TriggerContinueAsNewRequest.SerializeToString,
+                response_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
+                _registered_method=True)
+        self.HealthCheck = channel.unary_unary(
+                '/dex.FlowService/HealthCheck',
+                request_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
+                response_deserializer=dex__pb2.HealthInfo.FromString,
+                _registered_method=True)
+
+
+class FlowServiceServicer:
+    """---------------------------------------------------------------------------
+    FlowService error handling
+
+    Failures return a gRPC status with dexpb.ErrorResponse in status details
+    (see ErrorResponse / ErrorSubStatus). Clients should read both the gRPC code
+    and ErrorResponse.sub_status / detail / original_worker_error_*.
+
+    Common gRPC codes (all RPCs unless noted):
+    InvalidArgument   — bad request / invalid Value / empty lock keys, etc.
+    sub_status usually UNCATEGORIZED
+    AlreadyExists     — StartFlow when ID already running
+    sub_status FLOW_ALREADY_STARTED
+    NotFound          — unknown flow/run
+    sub_status FLOW_NOT_EXISTS
+    FailedPrecondition — closed/invalid flow state; blob-backed WaitForAttribute;
+    Dex application WorkerService failures (business errors
+    and unreachable/dial/transport to the app worker). These
+    must not use Unavailable so they do not count against
+    server SLA/SLO. sub_status WORKER_API_ERROR when from
+    WorkerService; raw worker code/detail/type in
+    original_worker_error_* when available
+    Aborted           — locking RPC attribute lock contention
+    sub_status WORKER_API_ERROR
+    ResourceExhausted — worker connection pool / message size limits
+    DeadlineExceeded  — wait past effective deadline (WaitForFlow,
+    WaitForStepCompletion, WaitForAttribute)
+    sub_status LONG_POLL_TIME_OUT
+    Canceled          — caller canceled the RPC context
+    Unavailable       — Temporal/Cadence backend (workflow engine) unavailable
+    only — never Dex application WorkerService
+    Internal          — unexpected / violated trusted invariant
+    Unimplemented     — Cadence: WaitForStepCompletion, WaitForAttribute,
+    locking InvokeRPC (Temporal sync update required)
+
+    Notable per-RPC behavior:
+    InvokeRPC — empty LockAttributeKeys: API calls WorkerService then may signal;
+    WorkerService errors (app or transport-to-worker) → FailedPrecondition +
+    WORKER_API_ERROR + OriginalWorker* when present.
+    non-empty LockAttributeKeys: Temporal sync update; same worker mapping via
+    handleError; Cadence → Unimplemented.
+    WaitForStepCompletion / WaitForAttribute — Temporal-only sync updates; API
+    retries CONTINUE_AS_NEW_PREEMPTED (not exposed as Internal). Timeout →
+    DeadlineExceeded + LONG_POLL_TIME_OUT. WaitForAttribute rejects waiting on
+    blob-backed stored attributes with FailedPrecondition.
+    WaitForFlow — long-poll timeout while still running → DeadlineExceeded +
+    LONG_POLL_TIME_OUT.
+    ---------------------------------------------------------------------------
+
+    Hosted by Dex server; SDKs call these RPCs.
+    """
+
+    def StartFlow(self, request, context):
+        """Missing associated documentation comment in .proto file."""
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+    def PublishToChannel(self, request, context):
+        """Missing associated documentation comment in .proto file."""
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+    def StopFlow(self, request, context):
+        """Missing associated documentation comment in .proto file."""
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+    def GetAttributes(self, request, context):
+        """Missing associated documentation comment in .proto file."""
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+    def SetAttributes(self, request, context):
+        """Missing associated documentation comment in .proto file."""
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+    def LoadBlobs(self, request, context):
+        """Missing associated documentation comment in .proto file."""
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+    def WaitForFlow(self, request, context):
+        """Missing associated documentation comment in .proto file."""
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+    def SearchFlows(self, request, context):
+        """Missing associated documentation comment in .proto file."""
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+    def ResetFlow(self, request, context):
+        """Missing associated documentation comment in .proto file."""
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+    def InvokeRPC(self, request, context):
+        """Missing associated documentation comment in .proto file."""
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+    def SkipTimer(self, request, context):
+        """Missing associated documentation comment in .proto file."""
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+    def UpdateFlowConfig(self, request, context):
+        """Missing associated documentation comment in .proto file."""
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+    def WaitForStepCompletion(self, request, context):
+        """Missing associated documentation comment in .proto file."""
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+    def WaitForAttribute(self, request, context):
+        """Missing associated documentation comment in .proto file."""
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+    def TriggerContinueAsNew(self, request, context):
+        """Missing associated documentation comment in .proto file."""
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+    def HealthCheck(self, request, context):
+        """Missing associated documentation comment in .proto file."""
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+
+def add_FlowServiceServicer_to_server(servicer, server):
+    rpc_method_handlers = {
+            'StartFlow': grpc.unary_unary_rpc_method_handler(
+                    servicer.StartFlow,
+                    request_deserializer=dex__pb2.StartFlowRequest.FromString,
+                    response_serializer=dex__pb2.StartFlowResponse.SerializeToString,
+            ),
+            'PublishToChannel': grpc.unary_unary_rpc_method_handler(
+                    servicer.PublishToChannel,
+                    request_deserializer=dex__pb2.PublishToChannelRequest.FromString,
+                    response_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
+            ),
+            'StopFlow': grpc.unary_unary_rpc_method_handler(
+                    servicer.StopFlow,
+                    request_deserializer=dex__pb2.StopFlowRequest.FromString,
+                    response_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
+            ),
+            'GetAttributes': grpc.unary_unary_rpc_method_handler(
+                    servicer.GetAttributes,
+                    request_deserializer=dex__pb2.GetAttributesRequest.FromString,
+                    response_serializer=dex__pb2.GetAttributesResponse.SerializeToString,
+            ),
+            'SetAttributes': grpc.unary_unary_rpc_method_handler(
+                    servicer.SetAttributes,
+                    request_deserializer=dex__pb2.SetAttributesRequest.FromString,
+                    response_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
+            ),
+            'LoadBlobs': grpc.unary_unary_rpc_method_handler(
+                    servicer.LoadBlobs,
+                    request_deserializer=dex__pb2.LoadBlobsRequest.FromString,
+                    response_serializer=dex__pb2.LoadBlobsResponse.SerializeToString,
+            ),
+            'WaitForFlow': grpc.unary_unary_rpc_method_handler(
+                    servicer.WaitForFlow,
+                    request_deserializer=dex__pb2.WaitForFlowRequest.FromString,
+                    response_serializer=dex__pb2.WaitForFlowResponse.SerializeToString,
+            ),
+            'SearchFlows': grpc.unary_unary_rpc_method_handler(
+                    servicer.SearchFlows,
+                    request_deserializer=dex__pb2.SearchFlowsRequest.FromString,
+                    response_serializer=dex__pb2.SearchFlowsResponse.SerializeToString,
+            ),
+            'ResetFlow': grpc.unary_unary_rpc_method_handler(
+                    servicer.ResetFlow,
+                    request_deserializer=dex__pb2.ResetFlowRequest.FromString,
+                    response_serializer=dex__pb2.ResetFlowResponse.SerializeToString,
+            ),
+            'InvokeRPC': grpc.unary_unary_rpc_method_handler(
+                    servicer.InvokeRPC,
+                    request_deserializer=dex__pb2.InvokeRPCRequest.FromString,
+                    response_serializer=dex__pb2.InvokeRPCResponse.SerializeToString,
+            ),
+            'SkipTimer': grpc.unary_unary_rpc_method_handler(
+                    servicer.SkipTimer,
+                    request_deserializer=dex__pb2.SkipTimerRequest.FromString,
+                    response_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
+            ),
+            'UpdateFlowConfig': grpc.unary_unary_rpc_method_handler(
+                    servicer.UpdateFlowConfig,
+                    request_deserializer=dex__pb2.UpdateFlowConfigRequest.FromString,
+                    response_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
+            ),
+            'WaitForStepCompletion': grpc.unary_unary_rpc_method_handler(
+                    servicer.WaitForStepCompletion,
+                    request_deserializer=dex__pb2.WaitForStepCompletionRequest.FromString,
+                    response_serializer=dex__pb2.WaitForStepCompletionResponse.SerializeToString,
+            ),
+            'WaitForAttribute': grpc.unary_unary_rpc_method_handler(
+                    servicer.WaitForAttribute,
+                    request_deserializer=dex__pb2.WaitForAttributeRequest.FromString,
+                    response_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
+            ),
+            'TriggerContinueAsNew': grpc.unary_unary_rpc_method_handler(
+                    servicer.TriggerContinueAsNew,
+                    request_deserializer=dex__pb2.TriggerContinueAsNewRequest.FromString,
+                    response_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
+            ),
+            'HealthCheck': grpc.unary_unary_rpc_method_handler(
+                    servicer.HealthCheck,
+                    request_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
+                    response_serializer=dex__pb2.HealthInfo.SerializeToString,
+            ),
+    }
+    generic_handler = grpc.method_handlers_generic_handler(
+            'dex.FlowService', rpc_method_handlers)
+    server.add_generic_rpc_handlers((generic_handler,))
+    server.add_registered_method_handlers('dex.FlowService', rpc_method_handlers)
+
+
+ # This class is part of an EXPERIMENTAL API.
+class FlowService:
+    """---------------------------------------------------------------------------
+    FlowService error handling
+
+    Failures return a gRPC status with dexpb.ErrorResponse in status details
+    (see ErrorResponse / ErrorSubStatus). Clients should read both the gRPC code
+    and ErrorResponse.sub_status / detail / original_worker_error_*.
+
+    Common gRPC codes (all RPCs unless noted):
+    InvalidArgument   — bad request / invalid Value / empty lock keys, etc.
+    sub_status usually UNCATEGORIZED
+    AlreadyExists     — StartFlow when ID already running
+    sub_status FLOW_ALREADY_STARTED
+    NotFound          — unknown flow/run
+    sub_status FLOW_NOT_EXISTS
+    FailedPrecondition — closed/invalid flow state; blob-backed WaitForAttribute;
+    Dex application WorkerService failures (business errors
+    and unreachable/dial/transport to the app worker). These
+    must not use Unavailable so they do not count against
+    server SLA/SLO. sub_status WORKER_API_ERROR when from
+    WorkerService; raw worker code/detail/type in
+    original_worker_error_* when available
+    Aborted           — locking RPC attribute lock contention
+    sub_status WORKER_API_ERROR
+    ResourceExhausted — worker connection pool / message size limits
+    DeadlineExceeded  — wait past effective deadline (WaitForFlow,
+    WaitForStepCompletion, WaitForAttribute)
+    sub_status LONG_POLL_TIME_OUT
+    Canceled          — caller canceled the RPC context
+    Unavailable       — Temporal/Cadence backend (workflow engine) unavailable
+    only — never Dex application WorkerService
+    Internal          — unexpected / violated trusted invariant
+    Unimplemented     — Cadence: WaitForStepCompletion, WaitForAttribute,
+    locking InvokeRPC (Temporal sync update required)
+
+    Notable per-RPC behavior:
+    InvokeRPC — empty LockAttributeKeys: API calls WorkerService then may signal;
+    WorkerService errors (app or transport-to-worker) → FailedPrecondition +
+    WORKER_API_ERROR + OriginalWorker* when present.
+    non-empty LockAttributeKeys: Temporal sync update; same worker mapping via
+    handleError; Cadence → Unimplemented.
+    WaitForStepCompletion / WaitForAttribute — Temporal-only sync updates; API
+    retries CONTINUE_AS_NEW_PREEMPTED (not exposed as Internal). Timeout →
+    DeadlineExceeded + LONG_POLL_TIME_OUT. WaitForAttribute rejects waiting on
+    blob-backed stored attributes with FailedPrecondition.
+    WaitForFlow — long-poll timeout while still running → DeadlineExceeded +
+    LONG_POLL_TIME_OUT.
+    ---------------------------------------------------------------------------
+
+    Hosted by Dex server; SDKs call these RPCs.
+    """
+
+    @staticmethod
+    def StartFlow(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,
+            '/dex.FlowService/StartFlow',
+            dex__pb2.StartFlowRequest.SerializeToString,
+            dex__pb2.StartFlowResponse.FromString,
+            options,
+            channel_credentials,
+            insecure,
+            call_credentials,
+            compression,
+            wait_for_ready,
+            timeout,
+            metadata,
+            _registered_method=True)
+
+    @staticmethod
+    def PublishToChannel(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,
+            '/dex.FlowService/PublishToChannel',
+            dex__pb2.PublishToChannelRequest.SerializeToString,
+            google_dot_protobuf_dot_empty__pb2.Empty.FromString,
+            options,
+            channel_credentials,
+            insecure,
+            call_credentials,
+            compression,
+            wait_for_ready,
+            timeout,
+            metadata,
+            _registered_method=True)
+
+    @staticmethod
+    def StopFlow(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,
+            '/dex.FlowService/StopFlow',
+            dex__pb2.StopFlowRequest.SerializeToString,
+            google_dot_protobuf_dot_empty__pb2.Empty.FromString,
+            options,
+            channel_credentials,
+            insecure,
+            call_credentials,
+            compression,
+            wait_for_ready,
+            timeout,
+            metadata,
+            _registered_method=True)
+
+    @staticmethod
+    def GetAttributes(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,
+            '/dex.FlowService/GetAttributes',
+            dex__pb2.GetAttributesRequest.SerializeToString,
+            dex__pb2.GetAttributesResponse.FromString,
+            options,
+            channel_credentials,
+            insecure,
+            call_credentials,
+            compression,
+            wait_for_ready,
+            timeout,
+            metadata,
+            _registered_method=True)
+
+    @staticmethod
+    def SetAttributes(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,
+            '/dex.FlowService/SetAttributes',
+            dex__pb2.SetAttributesRequest.SerializeToString,
+            google_dot_protobuf_dot_empty__pb2.Empty.FromString,
+            options,
+            channel_credentials,
+            insecure,
+            call_credentials,
+            compression,
+            wait_for_ready,
+            timeout,
+            metadata,
+            _registered_method=True)
+
+    @staticmethod
+    def LoadBlobs(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,
+            '/dex.FlowService/LoadBlobs',
+            dex__pb2.LoadBlobsRequest.SerializeToString,
+            dex__pb2.LoadBlobsResponse.FromString,
+            options,
+            channel_credentials,
+            insecure,
+            call_credentials,
+            compression,
+            wait_for_ready,
+            timeout,
+            metadata,
+            _registered_method=True)
+
+    @staticmethod
+    def WaitForFlow(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,
+            '/dex.FlowService/WaitForFlow',
+            dex__pb2.WaitForFlowRequest.SerializeToString,
+            dex__pb2.WaitForFlowResponse.FromString,
+            options,
+            channel_credentials,
+            insecure,
+            call_credentials,
+            compression,
+            wait_for_ready,
+            timeout,
+            metadata,
+            _registered_method=True)
+
+    @staticmethod
+    def SearchFlows(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,
+            '/dex.FlowService/SearchFlows',
+            dex__pb2.SearchFlowsRequest.SerializeToString,
+            dex__pb2.SearchFlowsResponse.FromString,
+            options,
+            channel_credentials,
+            insecure,
+            call_credentials,
+            compression,
+            wait_for_ready,
+            timeout,
+            metadata,
+            _registered_method=True)
+
+    @staticmethod
+    def ResetFlow(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,
+            '/dex.FlowService/ResetFlow',
+            dex__pb2.ResetFlowRequest.SerializeToString,
+            dex__pb2.ResetFlowResponse.FromString,
+            options,
+            channel_credentials,
+            insecure,
+            call_credentials,
+            compression,
+            wait_for_ready,
+            timeout,
+            metadata,
+            _registered_method=True)
+
+    @staticmethod
+    def InvokeRPC(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,
+            '/dex.FlowService/InvokeRPC',
+            dex__pb2.InvokeRPCRequest.SerializeToString,
+            dex__pb2.InvokeRPCResponse.FromString,
+            options,
+            channel_credentials,
+            insecure,
+            call_credentials,
+            compression,
+            wait_for_ready,
+            timeout,
+            metadata,
+            _registered_method=True)
+
+    @staticmethod
+    def SkipTimer(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,
+            '/dex.FlowService/SkipTimer',
+            dex__pb2.SkipTimerRequest.SerializeToString,
+            google_dot_protobuf_dot_empty__pb2.Empty.FromString,
+            options,
+            channel_credentials,
+            insecure,
+            call_credentials,
+            compression,
+            wait_for_ready,
+            timeout,
+            metadata,
+            _registered_method=True)
+
+    @staticmethod
+    def UpdateFlowConfig(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,
+            '/dex.FlowService/UpdateFlowConfig',
+            dex__pb2.UpdateFlowConfigRequest.SerializeToString,
+            google_dot_protobuf_dot_empty__pb2.Empty.FromString,
+            options,
+            channel_credentials,
+            insecure,
+            call_credentials,
+            compression,
+            wait_for_ready,
+            timeout,
+            metadata,
+            _registered_method=True)
+
+    @staticmethod
+    def WaitForStepCompletion(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,
+            '/dex.FlowService/WaitForStepCompletion',
+            dex__pb2.WaitForStepCompletionRequest.SerializeToString,
+            dex__pb2.WaitForStepCompletionResponse.FromString,
+            options,
+            channel_credentials,
+            insecure,
+            call_credentials,
+            compression,
+            wait_for_ready,
+            timeout,
+            metadata,
+            _registered_method=True)
+
+    @staticmethod
+    def WaitForAttribute(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,
+            '/dex.FlowService/WaitForAttribute',
+            dex__pb2.WaitForAttributeRequest.SerializeToString,
+            google_dot_protobuf_dot_empty__pb2.Empty.FromString,
+            options,
+            channel_credentials,
+            insecure,
+            call_credentials,
+            compression,
+            wait_for_ready,
+            timeout,
+            metadata,
+            _registered_method=True)
+
+    @staticmethod
+    def TriggerContinueAsNew(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,
+            '/dex.FlowService/TriggerContinueAsNew',
+            dex__pb2.TriggerContinueAsNewRequest.SerializeToString,
+            google_dot_protobuf_dot_empty__pb2.Empty.FromString,
+            options,
+            channel_credentials,
+            insecure,
+            call_credentials,
+            compression,
+            wait_for_ready,
+            timeout,
+            metadata,
+            _registered_method=True)
+
+    @staticmethod
+    def HealthCheck(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,
+            '/dex.FlowService/HealthCheck',
+            google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
+            dex__pb2.HealthInfo.FromString,
+            options,
+            channel_credentials,
+            insecure,
+            call_credentials,
+            compression,
+            wait_for_ready,
+            timeout,
+            metadata,
+            _registered_method=True)
+
+
+class WorkerServiceStub:
+    """Hosted by Dex worker; server calls these RPCs.
+    """
+
+    def __init__(self, channel):
+        """Constructor.
+
+        Args:
+            channel: A grpc.Channel.
+        """
+        self.InvokeWaitForMethod = channel.unary_unary(
+                '/dex.WorkerService/InvokeWaitForMethod',
+                request_serializer=dex__pb2.InvokeWaitForMethodRequest.SerializeToString,
+                response_deserializer=dex__pb2.InvokeWaitForMethodResponse.FromString,
+                _registered_method=True)
+        self.InvokeExecuteMethod = channel.unary_unary(
+                '/dex.WorkerService/InvokeExecuteMethod',
+                request_serializer=dex__pb2.InvokeExecuteMethodRequest.SerializeToString,
+                response_deserializer=dex__pb2.InvokeExecuteMethodResponse.FromString,
+                _registered_method=True)
+        self.InvokeWorkerRPC = channel.unary_unary(
+                '/dex.WorkerService/InvokeWorkerRPC',
+                request_serializer=dex__pb2.InvokeWorkerRPCRequest.SerializeToString,
+                response_deserializer=dex__pb2.InvokeWorkerRPCResponse.FromString,
+                _registered_method=True)
+
+
+class WorkerServiceServicer:
+    """Hosted by Dex worker; server calls these RPCs.
+    """
+
+    def InvokeWaitForMethod(self, request, context):
+        """Missing associated documentation comment in .proto file."""
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+    def InvokeExecuteMethod(self, request, context):
+        """Missing associated documentation comment in .proto file."""
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+    def InvokeWorkerRPC(self, request, context):
+        """Missing associated documentation comment in .proto file."""
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+
+def add_WorkerServiceServicer_to_server(servicer, server):
+    rpc_method_handlers = {
+            'InvokeWaitForMethod': grpc.unary_unary_rpc_method_handler(
+                    servicer.InvokeWaitForMethod,
+                    request_deserializer=dex__pb2.InvokeWaitForMethodRequest.FromString,
+                    response_serializer=dex__pb2.InvokeWaitForMethodResponse.SerializeToString,
+            ),
+            'InvokeExecuteMethod': grpc.unary_unary_rpc_method_handler(
+                    servicer.InvokeExecuteMethod,
+                    request_deserializer=dex__pb2.InvokeExecuteMethodRequest.FromString,
+                    response_serializer=dex__pb2.InvokeExecuteMethodResponse.SerializeToString,
+            ),
+            'InvokeWorkerRPC': grpc.unary_unary_rpc_method_handler(
+                    servicer.InvokeWorkerRPC,
+                    request_deserializer=dex__pb2.InvokeWorkerRPCRequest.FromString,
+                    response_serializer=dex__pb2.InvokeWorkerRPCResponse.SerializeToString,
+            ),
+    }
+    generic_handler = grpc.method_handlers_generic_handler(
+            'dex.WorkerService', rpc_method_handlers)
+    server.add_generic_rpc_handlers((generic_handler,))
+    server.add_registered_method_handlers('dex.WorkerService', rpc_method_handlers)
+
+
+ # This class is part of an EXPERIMENTAL API.
+class WorkerService:
+    """Hosted by Dex worker; server calls these RPCs.
+    """
+
+    @staticmethod
+    def InvokeWaitForMethod(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,
+            '/dex.WorkerService/InvokeWaitForMethod',
+            dex__pb2.InvokeWaitForMethodRequest.SerializeToString,
+            dex__pb2.InvokeWaitForMethodResponse.FromString,
+            options,
+            channel_credentials,
+            insecure,
+            call_credentials,
+            compression,
+            wait_for_ready,
+            timeout,
+            metadata,
+            _registered_method=True)
+
+    @staticmethod
+    def InvokeExecuteMethod(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,
+            '/dex.WorkerService/InvokeExecuteMethod',
+            dex__pb2.InvokeExecuteMethodRequest.SerializeToString,
+            dex__pb2.InvokeExecuteMethodResponse.FromString,
+            options,
+            channel_credentials,
+            insecure,
+            call_credentials,
+            compression,
+            wait_for_ready,
+            timeout,
+            metadata,
+            _registered_method=True)
+
+    @staticmethod
+    def InvokeWorkerRPC(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,
+            '/dex.WorkerService/InvokeWorkerRPC',
+            dex__pb2.InvokeWorkerRPCRequest.SerializeToString,
+            dex__pb2.InvokeWorkerRPCResponse.FromString,
+            options,
+            channel_credentials,
+            insecure,
+            call_credentials,
+            compression,
+            wait_for_ready,
+            timeout,
+            metadata,
+            _registered_method=True)
+
+
+class InternalServiceStub:
+    """Server-internal only (interpreter CAN activity → API). Not SDK-facing.
+    """
+
+    def __init__(self, channel):
+        """Constructor.
+
+        Args:
+            channel: A grpc.Channel.
+        """
+        self.DumpFlowForContinueAsNew = channel.unary_unary(
+                '/dex.InternalService/DumpFlowForContinueAsNew',
+                request_serializer=dex__pb2.ContinueAsNewDumpRequest.SerializeToString,
+                response_deserializer=dex__pb2.ContinueAsNewDumpResponse.FromString,
+                _registered_method=True)
+
+
+class InternalServiceServicer:
+    """Server-internal only (interpreter CAN activity → API). Not SDK-facing.
+    """
+
+    def DumpFlowForContinueAsNew(self, request, context):
+        """Missing associated documentation comment in .proto file."""
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+
+def add_InternalServiceServicer_to_server(servicer, server):
+    rpc_method_handlers = {
+            'DumpFlowForContinueAsNew': grpc.unary_unary_rpc_method_handler(
+                    servicer.DumpFlowForContinueAsNew,
+                    request_deserializer=dex__pb2.ContinueAsNewDumpRequest.FromString,
+                    response_serializer=dex__pb2.ContinueAsNewDumpResponse.SerializeToString,
+            ),
+    }
+    generic_handler = grpc.method_handlers_generic_handler(
+            'dex.InternalService', rpc_method_handlers)
+    server.add_generic_rpc_handlers((generic_handler,))
+    server.add_registered_method_handlers('dex.InternalService', rpc_method_handlers)
+
+
+ # This class is part of an EXPERIMENTAL API.
+class InternalService:
+    """Server-internal only (interpreter CAN activity → API). Not SDK-facing.
+    """
+
+    @staticmethod
+    def DumpFlowForContinueAsNew(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,
+            '/dex.InternalService/DumpFlowForContinueAsNew',
+            dex__pb2.ContinueAsNewDumpRequest.SerializeToString,
+            dex__pb2.ContinueAsNewDumpResponse.FromString,
+            options,
+            channel_credentials,
+            insecure,
+            call_credentials,
+            compression,
+            wait_for_ready,
+            timeout,
+            metadata,
+            _registered_method=True)