Skip to content

Secure, Fast, and Extensible Sandbox runtime for AI agents.

28.7 KB
Raw Blame
# pyright: reportAttributeAccessIssue=false
# protobuf-generated modules expose dynamic attributes.

# 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 fastpath_pb2 as fastpath__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 fastpath_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 FastPathServiceStub:
    """Missing associated documentation comment in .proto file."""

    def __init__(self, channel):
        """Constructor.

        Args:
            channel: A grpc.Channel.
        """
        self.CreateSandbox = channel.unary_unary(
                '/fastpath.v2.FastPathService/CreateSandbox',
                request_serializer=fastpath__pb2.CreateSandboxRequest.SerializeToString,
                response_deserializer=fastpath__pb2.CreateSandboxResponse.FromString,
                _registered_method=True)
        self.DeleteSandbox = channel.unary_unary(
                '/fastpath.v2.FastPathService/DeleteSandbox',
                request_serializer=fastpath__pb2.DeleteRequest.SerializeToString,
                response_deserializer=fastpath__pb2.DeleteResponse.FromString,
                _registered_method=True)
        self.UpdateSandbox = channel.unary_unary(
                '/fastpath.v2.FastPathService/UpdateSandbox',
                request_serializer=fastpath__pb2.UpdateSandboxRequest.SerializeToString,
                response_deserializer=fastpath__pb2.UpdateSandboxResponse.FromString,
                _registered_method=True)
        self.ListSandboxes = channel.unary_unary(
                '/fastpath.v2.FastPathService/ListSandboxes',
                request_serializer=fastpath__pb2.ListSandboxesRequest.SerializeToString,
                response_deserializer=fastpath__pb2.ListSandboxesResponse.FromString,
                _registered_method=True)
        self.GetSandbox = channel.unary_unary(
                '/fastpath.v2.FastPathService/GetSandbox',
                request_serializer=fastpath__pb2.GetSandboxRequest.SerializeToString,
                response_deserializer=fastpath__pb2.GetSandboxResponse.FromString,
                _registered_method=True)
        self.GetSandboxDiagnostics = channel.unary_unary(
                '/fastpath.v2.FastPathService/GetSandboxDiagnostics',
                request_serializer=fastpath__pb2.SandboxDiagnosticsRequest.SerializeToString,
                response_deserializer=fastpath__pb2.SandboxDiagnosticsResponse.FromString,
                _registered_method=True)
        self.ResolveEndpoint = channel.unary_unary(
                '/fastpath.v2.FastPathService/ResolveEndpoint',
                request_serializer=fastpath__pb2.ResolveEndpointRequest.SerializeToString,
                response_deserializer=fastpath__pb2.ResolveEndpointResponse.FromString,
                _registered_method=True)
        self.GetPool = channel.unary_unary(
                '/fastpath.v2.FastPathService/GetPool',
                request_serializer=fastpath__pb2.GetPoolRequest.SerializeToString,
                response_deserializer=fastpath__pb2.PoolInfo.FromString,
                _registered_method=True)
        self.ListPools = channel.unary_unary(
                '/fastpath.v2.FastPathService/ListPools',
                request_serializer=fastpath__pb2.ListPoolsRequest.SerializeToString,
                response_deserializer=fastpath__pb2.ListPoolsResponse.FromString,
                _registered_method=True)
        self.CreateSandboxSnapshot = channel.unary_unary(
                '/fastpath.v2.FastPathService/CreateSandboxSnapshot',
                request_serializer=fastpath__pb2.CreateSandboxSnapshotRequest.SerializeToString,
                response_deserializer=fastpath__pb2.CreateSandboxSnapshotResponse.FromString,
                _registered_method=True)
        self.GetSandboxSnapshot = channel.unary_unary(
                '/fastpath.v2.FastPathService/GetSandboxSnapshot',
                request_serializer=fastpath__pb2.GetSandboxSnapshotRequest.SerializeToString,
                response_deserializer=fastpath__pb2.GetSandboxSnapshotResponse.FromString,
                _registered_method=True)
        self.DeleteSandboxSnapshot = channel.unary_unary(
                '/fastpath.v2.FastPathService/DeleteSandboxSnapshot',
                request_serializer=fastpath__pb2.DeleteSandboxSnapshotRequest.SerializeToString,
                response_deserializer=fastpath__pb2.DeleteSandboxSnapshotResponse.FromString,
                _registered_method=True)
        self.PauseSandbox = channel.unary_unary(
                '/fastpath.v2.FastPathService/PauseSandbox',
                request_serializer=fastpath__pb2.PauseSandboxRequest.SerializeToString,
                response_deserializer=fastpath__pb2.PauseSandboxResponse.FromString,
                _registered_method=True)
        self.ResumeSandbox = channel.unary_unary(
                '/fastpath.v2.FastPathService/ResumeSandbox',
                request_serializer=fastpath__pb2.ResumeSandboxRequest.SerializeToString,
                response_deserializer=fastpath__pb2.ResumeSandboxResponse.FromString,
                _registered_method=True)
        self.InvokeHandlerAction = channel.unary_unary(
                '/fastpath.v2.FastPathService/InvokeHandlerAction',
                request_serializer=fastpath__pb2.InvokeHandlerActionRequest.SerializeToString,
                response_deserializer=fastpath__pb2.InvokeHandlerActionResponse.FromString,
                _registered_method=True)


class FastPathServiceServicer:
    """Missing associated documentation comment in .proto file."""

    def CreateSandbox(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 DeleteSandbox(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 UpdateSandbox(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 ListSandboxes(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 GetSandbox(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 GetSandboxDiagnostics(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 ResolveEndpoint(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 GetPool(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 ListPools(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 CreateSandboxSnapshot(self, request, context):
        """CreateSandboxSnapshot snapshots a running Sandbox and publishes the
        artifact set to the artifact store under the snapshot's template name.
        It returns after the intent is persisted and the snapshot is triggered;
        completion is observed via GetSandboxSnapshot.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetSandboxSnapshot(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 DeleteSandboxSnapshot(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 PauseSandbox(self, request, context):
        """PauseSandbox checkpoints a Ready Sandbox to the artifact store and
        releases its runtime. It returns after the desired state is persisted;
        completion (runtime_state PAUSED with the checkpoint durable) is
        observed via GetSandbox. Pause is a desired state, not a one-shot
        object: replaying the call with the same effect is idempotent.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def ResumeSandbox(self, request, context):
        """ResumeSandbox flips the desired state back to Running and schedules the
        checkpointed Sandbox again, possibly on another Fastlet. Completion
        (runtime_state READY) is observed via GetSandbox.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def InvokeHandlerAction(self, request, context):
        """InvokeHandlerAction relays an opaque payload to a Pool-declared Action
        Handler of the Sandbox's Pool through the hosting Fastlet, and returns
        the handler's HTTP status and body verbatim as the per-handler result.
        The control plane validates the tenant-scoped sandbox ownership and the
        handler declaration, but never interprets the payload or the handler's
        response: the handler's response is the synchronous ack.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')


def add_FastPathServiceServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'CreateSandbox': grpc.unary_unary_rpc_method_handler(
                    servicer.CreateSandbox,
                    request_deserializer=fastpath__pb2.CreateSandboxRequest.FromString,
                    response_serializer=fastpath__pb2.CreateSandboxResponse.SerializeToString,
            ),
            'DeleteSandbox': grpc.unary_unary_rpc_method_handler(
                    servicer.DeleteSandbox,
                    request_deserializer=fastpath__pb2.DeleteRequest.FromString,
                    response_serializer=fastpath__pb2.DeleteResponse.SerializeToString,
            ),
            'UpdateSandbox': grpc.unary_unary_rpc_method_handler(
                    servicer.UpdateSandbox,
                    request_deserializer=fastpath__pb2.UpdateSandboxRequest.FromString,
                    response_serializer=fastpath__pb2.UpdateSandboxResponse.SerializeToString,
            ),
            'ListSandboxes': grpc.unary_unary_rpc_method_handler(
                    servicer.ListSandboxes,
                    request_deserializer=fastpath__pb2.ListSandboxesRequest.FromString,
                    response_serializer=fastpath__pb2.ListSandboxesResponse.SerializeToString,
            ),
            'GetSandbox': grpc.unary_unary_rpc_method_handler(
                    servicer.GetSandbox,
                    request_deserializer=fastpath__pb2.GetSandboxRequest.FromString,
                    response_serializer=fastpath__pb2.GetSandboxResponse.SerializeToString,
            ),
            'GetSandboxDiagnostics': grpc.unary_unary_rpc_method_handler(
                    servicer.GetSandboxDiagnostics,
                    request_deserializer=fastpath__pb2.SandboxDiagnosticsRequest.FromString,
                    response_serializer=fastpath__pb2.SandboxDiagnosticsResponse.SerializeToString,
            ),
            'ResolveEndpoint': grpc.unary_unary_rpc_method_handler(
                    servicer.ResolveEndpoint,
                    request_deserializer=fastpath__pb2.ResolveEndpointRequest.FromString,
                    response_serializer=fastpath__pb2.ResolveEndpointResponse.SerializeToString,
            ),
            'GetPool': grpc.unary_unary_rpc_method_handler(
                    servicer.GetPool,
                    request_deserializer=fastpath__pb2.GetPoolRequest.FromString,
                    response_serializer=fastpath__pb2.PoolInfo.SerializeToString,
            ),
            'ListPools': grpc.unary_unary_rpc_method_handler(
                    servicer.ListPools,
                    request_deserializer=fastpath__pb2.ListPoolsRequest.FromString,
                    response_serializer=fastpath__pb2.ListPoolsResponse.SerializeToString,
            ),
            'CreateSandboxSnapshot': grpc.unary_unary_rpc_method_handler(
                    servicer.CreateSandboxSnapshot,
                    request_deserializer=fastpath__pb2.CreateSandboxSnapshotRequest.FromString,
                    response_serializer=fastpath__pb2.CreateSandboxSnapshotResponse.SerializeToString,
            ),
            'GetSandboxSnapshot': grpc.unary_unary_rpc_method_handler(
                    servicer.GetSandboxSnapshot,
                    request_deserializer=fastpath__pb2.GetSandboxSnapshotRequest.FromString,
                    response_serializer=fastpath__pb2.GetSandboxSnapshotResponse.SerializeToString,
            ),
            'DeleteSandboxSnapshot': grpc.unary_unary_rpc_method_handler(
                    servicer.DeleteSandboxSnapshot,
                    request_deserializer=fastpath__pb2.DeleteSandboxSnapshotRequest.FromString,
                    response_serializer=fastpath__pb2.DeleteSandboxSnapshotResponse.SerializeToString,
            ),
            'PauseSandbox': grpc.unary_unary_rpc_method_handler(
                    servicer.PauseSandbox,
                    request_deserializer=fastpath__pb2.PauseSandboxRequest.FromString,
                    response_serializer=fastpath__pb2.PauseSandboxResponse.SerializeToString,
            ),
            'ResumeSandbox': grpc.unary_unary_rpc_method_handler(
                    servicer.ResumeSandbox,
                    request_deserializer=fastpath__pb2.ResumeSandboxRequest.FromString,
                    response_serializer=fastpath__pb2.ResumeSandboxResponse.SerializeToString,
            ),
            'InvokeHandlerAction': grpc.unary_unary_rpc_method_handler(
                    servicer.InvokeHandlerAction,
                    request_deserializer=fastpath__pb2.InvokeHandlerActionRequest.FromString,
                    response_serializer=fastpath__pb2.InvokeHandlerActionResponse.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'fastpath.v2.FastPathService', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))
    server.add_registered_method_handlers('fastpath.v2.FastPathService', rpc_method_handlers)


 # This class is part of an EXPERIMENTAL API.
class FastPathService:
    """Missing associated documentation comment in .proto file."""

    @staticmethod
    def CreateSandbox(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,
            '/fastpath.v2.FastPathService/CreateSandbox',
            fastpath__pb2.CreateSandboxRequest.SerializeToString,
            fastpath__pb2.CreateSandboxResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def DeleteSandbox(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,
            '/fastpath.v2.FastPathService/DeleteSandbox',
            fastpath__pb2.DeleteRequest.SerializeToString,
            fastpath__pb2.DeleteResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def UpdateSandbox(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,
            '/fastpath.v2.FastPathService/UpdateSandbox',
            fastpath__pb2.UpdateSandboxRequest.SerializeToString,
            fastpath__pb2.UpdateSandboxResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def ListSandboxes(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,
            '/fastpath.v2.FastPathService/ListSandboxes',
            fastpath__pb2.ListSandboxesRequest.SerializeToString,
            fastpath__pb2.ListSandboxesResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetSandbox(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,
            '/fastpath.v2.FastPathService/GetSandbox',
            fastpath__pb2.GetSandboxRequest.SerializeToString,
            fastpath__pb2.GetSandboxResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetSandboxDiagnostics(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,
            '/fastpath.v2.FastPathService/GetSandboxDiagnostics',
            fastpath__pb2.SandboxDiagnosticsRequest.SerializeToString,
            fastpath__pb2.SandboxDiagnosticsResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def ResolveEndpoint(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,
            '/fastpath.v2.FastPathService/ResolveEndpoint',
            fastpath__pb2.ResolveEndpointRequest.SerializeToString,
            fastpath__pb2.ResolveEndpointResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetPool(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,
            '/fastpath.v2.FastPathService/GetPool',
            fastpath__pb2.GetPoolRequest.SerializeToString,
            fastpath__pb2.PoolInfo.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def ListPools(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,
            '/fastpath.v2.FastPathService/ListPools',
            fastpath__pb2.ListPoolsRequest.SerializeToString,
            fastpath__pb2.ListPoolsResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def CreateSandboxSnapshot(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,
            '/fastpath.v2.FastPathService/CreateSandboxSnapshot',
            fastpath__pb2.CreateSandboxSnapshotRequest.SerializeToString,
            fastpath__pb2.CreateSandboxSnapshotResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetSandboxSnapshot(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,
            '/fastpath.v2.FastPathService/GetSandboxSnapshot',
            fastpath__pb2.GetSandboxSnapshotRequest.SerializeToString,
            fastpath__pb2.GetSandboxSnapshotResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def DeleteSandboxSnapshot(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,
            '/fastpath.v2.FastPathService/DeleteSandboxSnapshot',
            fastpath__pb2.DeleteSandboxSnapshotRequest.SerializeToString,
            fastpath__pb2.DeleteSandboxSnapshotResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def PauseSandbox(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,
            '/fastpath.v2.FastPathService/PauseSandbox',
            fastpath__pb2.PauseSandboxRequest.SerializeToString,
            fastpath__pb2.PauseSandboxResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def ResumeSandbox(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,
            '/fastpath.v2.FastPathService/ResumeSandbox',
            fastpath__pb2.ResumeSandboxRequest.SerializeToString,
            fastpath__pb2.ResumeSandboxResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def InvokeHandlerAction(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,
            '/fastpath.v2.FastPathService/InvokeHandlerAction',
            fastpath__pb2.InvokeHandlerActionRequest.SerializeToString,
            fastpath__pb2.InvokeHandlerActionResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)