# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT!
"""Client and server classes corresponding to protobuf-defined services."""
import grpc
import warnings

import longchain.plugins.bag.api.bag_pb2 as bag__pb2

GRPC_GENERATED_VERSION = '1.65.4'
GRPC_VERSION = grpc.__version__
EXPECTED_ERROR_RELEASE = '1.66.0'
SCHEDULED_RELEASE_DATE = 'August 6, 2024'
_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:
    warnings.warn(
        f'The grpc package installed is at version {GRPC_VERSION},'
        + f' but the generated code in bag_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}.'
        + f' This warning will become an error in {EXPECTED_ERROR_RELEASE},'
        + f' scheduled for release on {SCHEDULED_RELEASE_DATE}.',
        RuntimeWarning
    )


class BagServiceStub(object):
    """Missing associated documentation comment in .proto file."""

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

        Args:
            channel: A grpc.Channel.
        """
        self.CreateApp = channel.unary_unary(
                '/bag.BagService/CreateApp',
                request_serializer=bag__pb2.CreateAppRequest.SerializeToString,
                response_deserializer=bag__pb2.CreateAppResponse.FromString,
                _registered_method=True)
        self.CreateInstances = channel.unary_unary(
                '/bag.BagService/CreateInstances',
                request_serializer=bag__pb2.CreateInstancesRequest.SerializeToString,
                response_deserializer=bag__pb2.CreateInstancesResponse.FromString,
                _registered_method=True)
        self.CreateInstance = channel.unary_unary(
                '/bag.BagService/CreateInstance',
                request_serializer=bag__pb2.CreateInstanceRequest.SerializeToString,
                response_deserializer=bag__pb2.CreateInstanceResponse.FromString,
                _registered_method=True)
        self.CreateItem = channel.unary_unary(
                '/bag.BagService/CreateItem',
                request_serializer=bag__pb2.CreateItemRequest.SerializeToString,
                response_deserializer=bag__pb2.CreateItemResponse.FromString,
                _registered_method=True)
        self.CreateRecipe = channel.unary_unary(
                '/bag.BagService/CreateRecipe',
                request_serializer=bag__pb2.CreateRecipeRequest.SerializeToString,
                response_deserializer=bag__pb2.CreateRecipeResponse.FromString,
                _registered_method=True)
        self.CreateAction = channel.unary_unary(
                '/bag.BagService/CreateAction',
                request_serializer=bag__pb2.CreateActionRequest.SerializeToString,
                response_deserializer=bag__pb2.CreateActionResponse.FromString,
                _registered_method=True)
        self.CreateTrade = channel.unary_unary(
                '/bag.BagService/CreateTrade',
                request_serializer=bag__pb2.CreateTradeRequest.SerializeToString,
                response_deserializer=bag__pb2.CreateTradeResponse.FromString,
                _registered_method=True)
        self.GetIdentities = channel.unary_unary(
                '/bag.BagService/GetIdentities',
                request_serializer=bag__pb2.GetIdentitiesRequest.SerializeToString,
                response_deserializer=bag__pb2.GetIdentitiesResponse.FromString,
                _registered_method=True)
        self.GetIdentity = channel.unary_unary(
                '/bag.BagService/GetIdentity',
                request_serializer=bag__pb2.GetIdentityRequest.SerializeToString,
                response_deserializer=bag__pb2.GetIdentityResponse.FromString,
                _registered_method=True)
        self.GetInventory = channel.unary_unary(
                '/bag.BagService/GetInventory',
                request_serializer=bag__pb2.GetInventoryRequest.SerializeToString,
                response_deserializer=bag__pb2.GetInventoryResponse.FromString,
                _registered_method=True)
        self.GetItem = channel.unary_unary(
                '/bag.BagService/GetItem',
                request_serializer=bag__pb2.GetItemRequest.SerializeToString,
                response_deserializer=bag__pb2.GetItemResponse.FromString,
                _registered_method=True)
        self.GetItems = channel.unary_unary(
                '/bag.BagService/GetItems',
                request_serializer=bag__pb2.GetItemsRequest.SerializeToString,
                response_deserializer=bag__pb2.GetItemsResponse.FromString,
                _registered_method=True)
        self.GetInstance = channel.unary_unary(
                '/bag.BagService/GetInstance',
                request_serializer=bag__pb2.GetInstanceRequest.SerializeToString,
                response_deserializer=bag__pb2.GetInstanceResponse.FromString,
                _registered_method=True)
        self.GetApp = channel.unary_unary(
                '/bag.BagService/GetApp',
                request_serializer=bag__pb2.GetAppRequest.SerializeToString,
                response_deserializer=bag__pb2.GetAppResponse.FromString,
                _registered_method=True)
        self.GetTrade = channel.unary_unary(
                '/bag.BagService/GetTrade',
                request_serializer=bag__pb2.GetTradeRequest.SerializeToString,
                response_deserializer=bag__pb2.GetTradeResponse.FromString,
                _registered_method=True)
        self.GetTrades = channel.unary_unary(
                '/bag.BagService/GetTrades',
                request_serializer=bag__pb2.GetTradesRequest.SerializeToString,
                response_deserializer=bag__pb2.GetTradesResponse.FromString,
                _registered_method=True)
        self.GetRecipes = channel.unary_unary(
                '/bag.BagService/GetRecipes',
                request_serializer=bag__pb2.GetRecipesRequest.SerializeToString,
                response_deserializer=bag__pb2.GetRecipesResponse.FromString,
                _registered_method=True)
        self.GetRecipe = channel.unary_unary(
                '/bag.BagService/GetRecipe',
                request_serializer=bag__pb2.GetRecipeRequest.SerializeToString,
                response_deserializer=bag__pb2.GetRecipeResponse.FromString,
                _registered_method=True)
        self.GetAction = channel.unary_unary(
                '/bag.BagService/GetAction',
                request_serializer=bag__pb2.GetActionRequest.SerializeToString,
                response_deserializer=bag__pb2.GetActionResponse.FromString,
                _registered_method=True)
        self.UpdateIdentityMetadata = channel.unary_unary(
                '/bag.BagService/UpdateIdentityMetadata',
                request_serializer=bag__pb2.UpdateIdentityMetadataRequest.SerializeToString,
                response_deserializer=bag__pb2.UpdateIdentityMetadataResponse.FromString,
                _registered_method=True)
        self.UpdateInstance = channel.unary_unary(
                '/bag.BagService/UpdateInstance',
                request_serializer=bag__pb2.UpdateInstanceRequest.SerializeToString,
                response_deserializer=bag__pb2.UpdateInstanceResponse.FromString,
                _registered_method=True)
        self.UpdateItem = channel.unary_unary(
                '/bag.BagService/UpdateItem',
                request_serializer=bag__pb2.UpdateItemRequest.SerializeToString,
                response_deserializer=bag__pb2.UpdateItemResponse.FromString,
                _registered_method=True)
        self.UpdateApp = channel.unary_unary(
                '/bag.BagService/UpdateApp',
                request_serializer=bag__pb2.UpdateAppRequest.SerializeToString,
                response_deserializer=bag__pb2.UpdateAppResponse.FromString,
                _registered_method=True)
        self.UpdateTrade = channel.unary_unary(
                '/bag.BagService/UpdateTrade',
                request_serializer=bag__pb2.UpdateTradeRequest.SerializeToString,
                response_deserializer=bag__pb2.UpdateTradeResponse.FromString,
                _registered_method=True)
        self.UpdateRecipe = channel.unary_unary(
                '/bag.BagService/UpdateRecipe',
                request_serializer=bag__pb2.UpdateRecipeRequest.SerializeToString,
                response_deserializer=bag__pb2.UpdateRecipeResponse.FromString,
                _registered_method=True)
        self.UpdateAction = channel.unary_unary(
                '/bag.BagService/UpdateAction',
                request_serializer=bag__pb2.UpdateActionRequest.SerializeToString,
                response_deserializer=bag__pb2.UpdateActionResponse.FromString,
                _registered_method=True)
        self.DeleteApp = channel.unary_unary(
                '/bag.BagService/DeleteApp',
                request_serializer=bag__pb2.DeleteAppRequest.SerializeToString,
                response_deserializer=bag__pb2.DeleteAppResponse.FromString,
                _registered_method=True)
        self.DeleteInstance = channel.unary_unary(
                '/bag.BagService/DeleteInstance',
                request_serializer=bag__pb2.DeleteInstanceRequest.SerializeToString,
                response_deserializer=bag__pb2.DeleteInstanceResponse.FromString,
                _registered_method=True)
        self.DeleteTrade = channel.unary_unary(
                '/bag.BagService/DeleteTrade',
                request_serializer=bag__pb2.DeleteTradeRequest.SerializeToString,
                response_deserializer=bag__pb2.DeleteTradeResponse.FromString,
                _registered_method=True)
        self.CloseTrade = channel.unary_unary(
                '/bag.BagService/CloseTrade',
                request_serializer=bag__pb2.CloseTradeRequest.SerializeToString,
                response_deserializer=bag__pb2.CloseTradeResponse.FromString,
                _registered_method=True)
        self.VerifyKey = channel.unary_unary(
                '/bag.BagService/VerifyKey',
                request_serializer=bag__pb2.VerifyKeyRequest.SerializeToString,
                response_deserializer=bag__pb2.VerifyKeyResponse.FromString,
                _registered_method=True)
        self.RunGive = channel.unary_unary(
                '/bag.BagService/RunGive',
                request_serializer=bag__pb2.RunGiveRequest.SerializeToString,
                response_deserializer=bag__pb2.RunGiveResponse.FromString,
                _registered_method=True)
        self.RunCraft = channel.unary_unary(
                '/bag.BagService/RunCraft',
                request_serializer=bag__pb2.RunCraftRequest.SerializeToString,
                response_deserializer=bag__pb2.RunCraftResponse.FromString,
                _registered_method=True)
        self.GetCraftStatus = channel.unary_unary(
                '/bag.BagService/GetCraftStatus',
                request_serializer=bag__pb2.GetCraftStatusRequest.SerializeToString,
                response_deserializer=bag__pb2.GetCraftStatusResponse.FromString,
                _registered_method=True)
        self.MakeOffer = channel.unary_unary(
                '/bag.BagService/MakeOffer',
                request_serializer=bag__pb2.MakeOfferRequest.SerializeToString,
                response_deserializer=bag__pb2.MakeOfferResponse.FromString,
                _registered_method=True)


class BagServiceServicer(object):
    """Missing associated documentation comment in .proto file."""

    def CreateApp(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 CreateInstances(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 CreateInstance(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 CreateItem(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 CreateRecipe(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 CreateAction(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 CreateTrade(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 GetIdentities(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 GetIdentity(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 GetInventory(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 GetItem(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 GetItems(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 GetInstance(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 GetApp(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 GetTrade(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 GetTrades(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 GetRecipes(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 GetRecipe(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 GetAction(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 UpdateIdentityMetadata(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 UpdateInstance(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 UpdateItem(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 UpdateApp(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 UpdateTrade(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 UpdateRecipe(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 UpdateAction(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 DeleteApp(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 DeleteInstance(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 DeleteTrade(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 CloseTrade(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 VerifyKey(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 RunGive(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 RunCraft(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 GetCraftStatus(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 MakeOffer(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_BagServiceServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'CreateApp': grpc.unary_unary_rpc_method_handler(
                    servicer.CreateApp,
                    request_deserializer=bag__pb2.CreateAppRequest.FromString,
                    response_serializer=bag__pb2.CreateAppResponse.SerializeToString,
            ),
            'CreateInstances': grpc.unary_unary_rpc_method_handler(
                    servicer.CreateInstances,
                    request_deserializer=bag__pb2.CreateInstancesRequest.FromString,
                    response_serializer=bag__pb2.CreateInstancesResponse.SerializeToString,
            ),
            'CreateInstance': grpc.unary_unary_rpc_method_handler(
                    servicer.CreateInstance,
                    request_deserializer=bag__pb2.CreateInstanceRequest.FromString,
                    response_serializer=bag__pb2.CreateInstanceResponse.SerializeToString,
            ),
            'CreateItem': grpc.unary_unary_rpc_method_handler(
                    servicer.CreateItem,
                    request_deserializer=bag__pb2.CreateItemRequest.FromString,
                    response_serializer=bag__pb2.CreateItemResponse.SerializeToString,
            ),
            'CreateRecipe': grpc.unary_unary_rpc_method_handler(
                    servicer.CreateRecipe,
                    request_deserializer=bag__pb2.CreateRecipeRequest.FromString,
                    response_serializer=bag__pb2.CreateRecipeResponse.SerializeToString,
            ),
            'CreateAction': grpc.unary_unary_rpc_method_handler(
                    servicer.CreateAction,
                    request_deserializer=bag__pb2.CreateActionRequest.FromString,
                    response_serializer=bag__pb2.CreateActionResponse.SerializeToString,
            ),
            'CreateTrade': grpc.unary_unary_rpc_method_handler(
                    servicer.CreateTrade,
                    request_deserializer=bag__pb2.CreateTradeRequest.FromString,
                    response_serializer=bag__pb2.CreateTradeResponse.SerializeToString,
            ),
            'GetIdentities': grpc.unary_unary_rpc_method_handler(
                    servicer.GetIdentities,
                    request_deserializer=bag__pb2.GetIdentitiesRequest.FromString,
                    response_serializer=bag__pb2.GetIdentitiesResponse.SerializeToString,
            ),
            'GetIdentity': grpc.unary_unary_rpc_method_handler(
                    servicer.GetIdentity,
                    request_deserializer=bag__pb2.GetIdentityRequest.FromString,
                    response_serializer=bag__pb2.GetIdentityResponse.SerializeToString,
            ),
            'GetInventory': grpc.unary_unary_rpc_method_handler(
                    servicer.GetInventory,
                    request_deserializer=bag__pb2.GetInventoryRequest.FromString,
                    response_serializer=bag__pb2.GetInventoryResponse.SerializeToString,
            ),
            'GetItem': grpc.unary_unary_rpc_method_handler(
                    servicer.GetItem,
                    request_deserializer=bag__pb2.GetItemRequest.FromString,
                    response_serializer=bag__pb2.GetItemResponse.SerializeToString,
            ),
            'GetItems': grpc.unary_unary_rpc_method_handler(
                    servicer.GetItems,
                    request_deserializer=bag__pb2.GetItemsRequest.FromString,
                    response_serializer=bag__pb2.GetItemsResponse.SerializeToString,
            ),
            'GetInstance': grpc.unary_unary_rpc_method_handler(
                    servicer.GetInstance,
                    request_deserializer=bag__pb2.GetInstanceRequest.FromString,
                    response_serializer=bag__pb2.GetInstanceResponse.SerializeToString,
            ),
            'GetApp': grpc.unary_unary_rpc_method_handler(
                    servicer.GetApp,
                    request_deserializer=bag__pb2.GetAppRequest.FromString,
                    response_serializer=bag__pb2.GetAppResponse.SerializeToString,
            ),
            'GetTrade': grpc.unary_unary_rpc_method_handler(
                    servicer.GetTrade,
                    request_deserializer=bag__pb2.GetTradeRequest.FromString,
                    response_serializer=bag__pb2.GetTradeResponse.SerializeToString,
            ),
            'GetTrades': grpc.unary_unary_rpc_method_handler(
                    servicer.GetTrades,
                    request_deserializer=bag__pb2.GetTradesRequest.FromString,
                    response_serializer=bag__pb2.GetTradesResponse.SerializeToString,
            ),
            'GetRecipes': grpc.unary_unary_rpc_method_handler(
                    servicer.GetRecipes,
                    request_deserializer=bag__pb2.GetRecipesRequest.FromString,
                    response_serializer=bag__pb2.GetRecipesResponse.SerializeToString,
            ),
            'GetRecipe': grpc.unary_unary_rpc_method_handler(
                    servicer.GetRecipe,
                    request_deserializer=bag__pb2.GetRecipeRequest.FromString,
                    response_serializer=bag__pb2.GetRecipeResponse.SerializeToString,
            ),
            'GetAction': grpc.unary_unary_rpc_method_handler(
                    servicer.GetAction,
                    request_deserializer=bag__pb2.GetActionRequest.FromString,
                    response_serializer=bag__pb2.GetActionResponse.SerializeToString,
            ),
            'UpdateIdentityMetadata': grpc.unary_unary_rpc_method_handler(
                    servicer.UpdateIdentityMetadata,
                    request_deserializer=bag__pb2.UpdateIdentityMetadataRequest.FromString,
                    response_serializer=bag__pb2.UpdateIdentityMetadataResponse.SerializeToString,
            ),
            'UpdateInstance': grpc.unary_unary_rpc_method_handler(
                    servicer.UpdateInstance,
                    request_deserializer=bag__pb2.UpdateInstanceRequest.FromString,
                    response_serializer=bag__pb2.UpdateInstanceResponse.SerializeToString,
            ),
            'UpdateItem': grpc.unary_unary_rpc_method_handler(
                    servicer.UpdateItem,
                    request_deserializer=bag__pb2.UpdateItemRequest.FromString,
                    response_serializer=bag__pb2.UpdateItemResponse.SerializeToString,
            ),
            'UpdateApp': grpc.unary_unary_rpc_method_handler(
                    servicer.UpdateApp,
                    request_deserializer=bag__pb2.UpdateAppRequest.FromString,
                    response_serializer=bag__pb2.UpdateAppResponse.SerializeToString,
            ),
            'UpdateTrade': grpc.unary_unary_rpc_method_handler(
                    servicer.UpdateTrade,
                    request_deserializer=bag__pb2.UpdateTradeRequest.FromString,
                    response_serializer=bag__pb2.UpdateTradeResponse.SerializeToString,
            ),
            'UpdateRecipe': grpc.unary_unary_rpc_method_handler(
                    servicer.UpdateRecipe,
                    request_deserializer=bag__pb2.UpdateRecipeRequest.FromString,
                    response_serializer=bag__pb2.UpdateRecipeResponse.SerializeToString,
            ),
            'UpdateAction': grpc.unary_unary_rpc_method_handler(
                    servicer.UpdateAction,
                    request_deserializer=bag__pb2.UpdateActionRequest.FromString,
                    response_serializer=bag__pb2.UpdateActionResponse.SerializeToString,
            ),
            'DeleteApp': grpc.unary_unary_rpc_method_handler(
                    servicer.DeleteApp,
                    request_deserializer=bag__pb2.DeleteAppRequest.FromString,
                    response_serializer=bag__pb2.DeleteAppResponse.SerializeToString,
            ),
            'DeleteInstance': grpc.unary_unary_rpc_method_handler(
                    servicer.DeleteInstance,
                    request_deserializer=bag__pb2.DeleteInstanceRequest.FromString,
                    response_serializer=bag__pb2.DeleteInstanceResponse.SerializeToString,
            ),
            'DeleteTrade': grpc.unary_unary_rpc_method_handler(
                    servicer.DeleteTrade,
                    request_deserializer=bag__pb2.DeleteTradeRequest.FromString,
                    response_serializer=bag__pb2.DeleteTradeResponse.SerializeToString,
            ),
            'CloseTrade': grpc.unary_unary_rpc_method_handler(
                    servicer.CloseTrade,
                    request_deserializer=bag__pb2.CloseTradeRequest.FromString,
                    response_serializer=bag__pb2.CloseTradeResponse.SerializeToString,
            ),
            'VerifyKey': grpc.unary_unary_rpc_method_handler(
                    servicer.VerifyKey,
                    request_deserializer=bag__pb2.VerifyKeyRequest.FromString,
                    response_serializer=bag__pb2.VerifyKeyResponse.SerializeToString,
            ),
            'RunGive': grpc.unary_unary_rpc_method_handler(
                    servicer.RunGive,
                    request_deserializer=bag__pb2.RunGiveRequest.FromString,
                    response_serializer=bag__pb2.RunGiveResponse.SerializeToString,
            ),
            'RunCraft': grpc.unary_unary_rpc_method_handler(
                    servicer.RunCraft,
                    request_deserializer=bag__pb2.RunCraftRequest.FromString,
                    response_serializer=bag__pb2.RunCraftResponse.SerializeToString,
            ),
            'GetCraftStatus': grpc.unary_unary_rpc_method_handler(
                    servicer.GetCraftStatus,
                    request_deserializer=bag__pb2.GetCraftStatusRequest.FromString,
                    response_serializer=bag__pb2.GetCraftStatusResponse.SerializeToString,
            ),
            'MakeOffer': grpc.unary_unary_rpc_method_handler(
                    servicer.MakeOffer,
                    request_deserializer=bag__pb2.MakeOfferRequest.FromString,
                    response_serializer=bag__pb2.MakeOfferResponse.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'bag.BagService', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))
    server.add_registered_method_handlers('bag.BagService', rpc_method_handlers)


 # This class is part of an EXPERIMENTAL API.
class BagService(object):
    """Missing associated documentation comment in .proto file."""

    @staticmethod
    def CreateApp(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,
            '/bag.BagService/CreateApp',
            bag__pb2.CreateAppRequest.SerializeToString,
            bag__pb2.CreateAppResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def CreateInstances(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,
            '/bag.BagService/CreateInstances',
            bag__pb2.CreateInstancesRequest.SerializeToString,
            bag__pb2.CreateInstancesResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def CreateInstance(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,
            '/bag.BagService/CreateInstance',
            bag__pb2.CreateInstanceRequest.SerializeToString,
            bag__pb2.CreateInstanceResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def CreateItem(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,
            '/bag.BagService/CreateItem',
            bag__pb2.CreateItemRequest.SerializeToString,
            bag__pb2.CreateItemResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def CreateRecipe(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,
            '/bag.BagService/CreateRecipe',
            bag__pb2.CreateRecipeRequest.SerializeToString,
            bag__pb2.CreateRecipeResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def CreateAction(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,
            '/bag.BagService/CreateAction',
            bag__pb2.CreateActionRequest.SerializeToString,
            bag__pb2.CreateActionResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def CreateTrade(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,
            '/bag.BagService/CreateTrade',
            bag__pb2.CreateTradeRequest.SerializeToString,
            bag__pb2.CreateTradeResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetIdentities(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,
            '/bag.BagService/GetIdentities',
            bag__pb2.GetIdentitiesRequest.SerializeToString,
            bag__pb2.GetIdentitiesResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetIdentity(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,
            '/bag.BagService/GetIdentity',
            bag__pb2.GetIdentityRequest.SerializeToString,
            bag__pb2.GetIdentityResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetInventory(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,
            '/bag.BagService/GetInventory',
            bag__pb2.GetInventoryRequest.SerializeToString,
            bag__pb2.GetInventoryResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetItem(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,
            '/bag.BagService/GetItem',
            bag__pb2.GetItemRequest.SerializeToString,
            bag__pb2.GetItemResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetItems(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,
            '/bag.BagService/GetItems',
            bag__pb2.GetItemsRequest.SerializeToString,
            bag__pb2.GetItemsResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetInstance(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,
            '/bag.BagService/GetInstance',
            bag__pb2.GetInstanceRequest.SerializeToString,
            bag__pb2.GetInstanceResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetApp(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,
            '/bag.BagService/GetApp',
            bag__pb2.GetAppRequest.SerializeToString,
            bag__pb2.GetAppResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetTrade(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,
            '/bag.BagService/GetTrade',
            bag__pb2.GetTradeRequest.SerializeToString,
            bag__pb2.GetTradeResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetTrades(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,
            '/bag.BagService/GetTrades',
            bag__pb2.GetTradesRequest.SerializeToString,
            bag__pb2.GetTradesResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetRecipes(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,
            '/bag.BagService/GetRecipes',
            bag__pb2.GetRecipesRequest.SerializeToString,
            bag__pb2.GetRecipesResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetRecipe(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,
            '/bag.BagService/GetRecipe',
            bag__pb2.GetRecipeRequest.SerializeToString,
            bag__pb2.GetRecipeResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetAction(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,
            '/bag.BagService/GetAction',
            bag__pb2.GetActionRequest.SerializeToString,
            bag__pb2.GetActionResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def UpdateIdentityMetadata(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,
            '/bag.BagService/UpdateIdentityMetadata',
            bag__pb2.UpdateIdentityMetadataRequest.SerializeToString,
            bag__pb2.UpdateIdentityMetadataResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def UpdateInstance(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,
            '/bag.BagService/UpdateInstance',
            bag__pb2.UpdateInstanceRequest.SerializeToString,
            bag__pb2.UpdateInstanceResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def UpdateItem(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,
            '/bag.BagService/UpdateItem',
            bag__pb2.UpdateItemRequest.SerializeToString,
            bag__pb2.UpdateItemResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def UpdateApp(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,
            '/bag.BagService/UpdateApp',
            bag__pb2.UpdateAppRequest.SerializeToString,
            bag__pb2.UpdateAppResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def UpdateTrade(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,
            '/bag.BagService/UpdateTrade',
            bag__pb2.UpdateTradeRequest.SerializeToString,
            bag__pb2.UpdateTradeResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def UpdateRecipe(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,
            '/bag.BagService/UpdateRecipe',
            bag__pb2.UpdateRecipeRequest.SerializeToString,
            bag__pb2.UpdateRecipeResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def UpdateAction(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,
            '/bag.BagService/UpdateAction',
            bag__pb2.UpdateActionRequest.SerializeToString,
            bag__pb2.UpdateActionResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def DeleteApp(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,
            '/bag.BagService/DeleteApp',
            bag__pb2.DeleteAppRequest.SerializeToString,
            bag__pb2.DeleteAppResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def DeleteInstance(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,
            '/bag.BagService/DeleteInstance',
            bag__pb2.DeleteInstanceRequest.SerializeToString,
            bag__pb2.DeleteInstanceResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def DeleteTrade(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,
            '/bag.BagService/DeleteTrade',
            bag__pb2.DeleteTradeRequest.SerializeToString,
            bag__pb2.DeleteTradeResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def CloseTrade(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,
            '/bag.BagService/CloseTrade',
            bag__pb2.CloseTradeRequest.SerializeToString,
            bag__pb2.CloseTradeResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def VerifyKey(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,
            '/bag.BagService/VerifyKey',
            bag__pb2.VerifyKeyRequest.SerializeToString,
            bag__pb2.VerifyKeyResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def RunGive(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,
            '/bag.BagService/RunGive',
            bag__pb2.RunGiveRequest.SerializeToString,
            bag__pb2.RunGiveResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def RunCraft(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,
            '/bag.BagService/RunCraft',
            bag__pb2.RunCraftRequest.SerializeToString,
            bag__pb2.RunCraftResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetCraftStatus(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,
            '/bag.BagService/GetCraftStatus',
            bag__pb2.GetCraftStatusRequest.SerializeToString,
            bag__pb2.GetCraftStatusResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def MakeOffer(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,
            '/bag.BagService/MakeOffer',
            bag__pb2.MakeOfferRequest.SerializeToString,
            bag__pb2.MakeOfferResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)
