# 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 neurion.crucible import tx_pb2 as neurion_dot_crucible_dot_tx__pb2

GRPC_GENERATED_VERSION = '1.70.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},'
        + f' but the generated code in neurion/crucible/tx_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 MsgStub(object):
    """Msg defines the Msg service.
    """

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

        Args:
            channel: A grpc.Channel.
        """
        self.UpdateParams = channel.unary_unary(
                '/neurion.crucible.Msg/UpdateParams',
                request_serializer=neurion_dot_crucible_dot_tx__pb2.MsgUpdateParams.SerializeToString,
                response_deserializer=neurion_dot_crucible_dot_tx__pb2.MsgUpdateParamsResponse.FromString,
                _registered_method=True)
        self.ApplyCreator = channel.unary_unary(
                '/neurion.crucible.Msg/ApplyCreator',
                request_serializer=neurion_dot_crucible_dot_tx__pb2.MsgApplyCreator.SerializeToString,
                response_deserializer=neurion_dot_crucible_dot_tx__pb2.MsgApplyCreatorResponse.FromString,
                _registered_method=True)
        self.ApproveApplication = channel.unary_unary(
                '/neurion.crucible.Msg/ApproveApplication',
                request_serializer=neurion_dot_crucible_dot_tx__pb2.MsgApproveApplication.SerializeToString,
                response_deserializer=neurion_dot_crucible_dot_tx__pb2.MsgApproveApplicationResponse.FromString,
                _registered_method=True)
        self.RejectApplication = channel.unary_unary(
                '/neurion.crucible.Msg/RejectApplication',
                request_serializer=neurion_dot_crucible_dot_tx__pb2.MsgRejectApplication.SerializeToString,
                response_deserializer=neurion_dot_crucible_dot_tx__pb2.MsgRejectApplicationResponse.FromString,
                _registered_method=True)
        self.CreateTask = channel.unary_unary(
                '/neurion.crucible.Msg/CreateTask',
                request_serializer=neurion_dot_crucible_dot_tx__pb2.MsgCreateTask.SerializeToString,
                response_deserializer=neurion_dot_crucible_dot_tx__pb2.MsgCreateTaskResponse.FromString,
                _registered_method=True)
        self.RegisterTrainer = channel.unary_unary(
                '/neurion.crucible.Msg/RegisterTrainer',
                request_serializer=neurion_dot_crucible_dot_tx__pb2.MsgRegisterTrainer.SerializeToString,
                response_deserializer=neurion_dot_crucible_dot_tx__pb2.MsgRegisterTrainerResponse.FromString,
                _registered_method=True)
        self.RegisterScorer = channel.unary_unary(
                '/neurion.crucible.Msg/RegisterScorer',
                request_serializer=neurion_dot_crucible_dot_tx__pb2.MsgRegisterScorer.SerializeToString,
                response_deserializer=neurion_dot_crucible_dot_tx__pb2.MsgRegisterScorerResponse.FromString,
                _registered_method=True)
        self.SubmitTrainingResult = channel.unary_unary(
                '/neurion.crucible.Msg/SubmitTrainingResult',
                request_serializer=neurion_dot_crucible_dot_tx__pb2.MsgSubmitTrainingResult.SerializeToString,
                response_deserializer=neurion_dot_crucible_dot_tx__pb2.MsgSubmitTrainingResultResponse.FromString,
                _registered_method=True)
        self.StakeToTask = channel.unary_unary(
                '/neurion.crucible.Msg/StakeToTask',
                request_serializer=neurion_dot_crucible_dot_tx__pb2.MsgStakeToTask.SerializeToString,
                response_deserializer=neurion_dot_crucible_dot_tx__pb2.MsgStakeToTaskResponse.FromString,
                _registered_method=True)
        self.RequestScoringTask = channel.unary_unary(
                '/neurion.crucible.Msg/RequestScoringTask',
                request_serializer=neurion_dot_crucible_dot_tx__pb2.MsgRequestScoringTask.SerializeToString,
                response_deserializer=neurion_dot_crucible_dot_tx__pb2.MsgRequestScoringTaskResponse.FromString,
                _registered_method=True)
        self.SubmitScore = channel.unary_unary(
                '/neurion.crucible.Msg/SubmitScore',
                request_serializer=neurion_dot_crucible_dot_tx__pb2.MsgSubmitScore.SerializeToString,
                response_deserializer=neurion_dot_crucible_dot_tx__pb2.MsgSubmitScoreResponse.FromString,
                _registered_method=True)
        self.SubmitFinalResult = channel.unary_unary(
                '/neurion.crucible.Msg/SubmitFinalResult',
                request_serializer=neurion_dot_crucible_dot_tx__pb2.MsgSubmitFinalResult.SerializeToString,
                response_deserializer=neurion_dot_crucible_dot_tx__pb2.MsgSubmitFinalResultResponse.FromString,
                _registered_method=True)
        self.ReportModelPlagiarism = channel.unary_unary(
                '/neurion.crucible.Msg/ReportModelPlagiarism',
                request_serializer=neurion_dot_crucible_dot_tx__pb2.MsgReportModelPlagiarism.SerializeToString,
                response_deserializer=neurion_dot_crucible_dot_tx__pb2.MsgReportModelPlagiarismResponse.FromString,
                _registered_method=True)
        self.AcceptPlagiarismReport = channel.unary_unary(
                '/neurion.crucible.Msg/AcceptPlagiarismReport',
                request_serializer=neurion_dot_crucible_dot_tx__pb2.MsgAcceptPlagiarismReport.SerializeToString,
                response_deserializer=neurion_dot_crucible_dot_tx__pb2.MsgAcceptPlagiarismReportResponse.FromString,
                _registered_method=True)
        self.RejectPlagiarismReport = channel.unary_unary(
                '/neurion.crucible.Msg/RejectPlagiarismReport',
                request_serializer=neurion_dot_crucible_dot_tx__pb2.MsgRejectPlagiarismReport.SerializeToString,
                response_deserializer=neurion_dot_crucible_dot_tx__pb2.MsgRejectPlagiarismReportResponse.FromString,
                _registered_method=True)
        self.DisputeSubmissionScore = channel.unary_unary(
                '/neurion.crucible.Msg/DisputeSubmissionScore',
                request_serializer=neurion_dot_crucible_dot_tx__pb2.MsgDisputeSubmissionScore.SerializeToString,
                response_deserializer=neurion_dot_crucible_dot_tx__pb2.MsgDisputeSubmissionScoreResponse.FromString,
                _registered_method=True)
        self.StartTask = channel.unary_unary(
                '/neurion.crucible.Msg/StartTask',
                request_serializer=neurion_dot_crucible_dot_tx__pb2.MsgStartTask.SerializeToString,
                response_deserializer=neurion_dot_crucible_dot_tx__pb2.MsgStartTaskResponse.FromString,
                _registered_method=True)
        self.AbortTask = channel.unary_unary(
                '/neurion.crucible.Msg/AbortTask',
                request_serializer=neurion_dot_crucible_dot_tx__pb2.MsgAbortTask.SerializeToString,
                response_deserializer=neurion_dot_crucible_dot_tx__pb2.MsgAbortTaskResponse.FromString,
                _registered_method=True)
        self.TriggerTaskToFinalSubmission = channel.unary_unary(
                '/neurion.crucible.Msg/TriggerTaskToFinalSubmission',
                request_serializer=neurion_dot_crucible_dot_tx__pb2.MsgTriggerTaskToFinalSubmission.SerializeToString,
                response_deserializer=neurion_dot_crucible_dot_tx__pb2.MsgTriggerTaskToFinalSubmissionResponse.FromString,
                _registered_method=True)
        self.TriggerTaskToFinalTesting = channel.unary_unary(
                '/neurion.crucible.Msg/TriggerTaskToFinalTesting',
                request_serializer=neurion_dot_crucible_dot_tx__pb2.MsgTriggerTaskToFinalTesting.SerializeToString,
                response_deserializer=neurion_dot_crucible_dot_tx__pb2.MsgTriggerTaskToFinalTestingResponse.FromString,
                _registered_method=True)
        self.TerminateTask = channel.unary_unary(
                '/neurion.crucible.Msg/TerminateTask',
                request_serializer=neurion_dot_crucible_dot_tx__pb2.MsgTerminateTask.SerializeToString,
                response_deserializer=neurion_dot_crucible_dot_tx__pb2.MsgTerminateTaskResponse.FromString,
                _registered_method=True)
        self.ClaimTaskReward = channel.unary_unary(
                '/neurion.crucible.Msg/ClaimTaskReward',
                request_serializer=neurion_dot_crucible_dot_tx__pb2.MsgClaimTaskReward.SerializeToString,
                response_deserializer=neurion_dot_crucible_dot_tx__pb2.MsgClaimTaskRewardResponse.FromString,
                _registered_method=True)
        self.UnstakeFromTask = channel.unary_unary(
                '/neurion.crucible.Msg/UnstakeFromTask',
                request_serializer=neurion_dot_crucible_dot_tx__pb2.MsgUnstakeFromTask.SerializeToString,
                response_deserializer=neurion_dot_crucible_dot_tx__pb2.MsgUnstakeFromTaskResponse.FromString,
                _registered_method=True)
        self.DisclaimCreatorStatus = channel.unary_unary(
                '/neurion.crucible.Msg/DisclaimCreatorStatus',
                request_serializer=neurion_dot_crucible_dot_tx__pb2.MsgDisclaimCreatorStatus.SerializeToString,
                response_deserializer=neurion_dot_crucible_dot_tx__pb2.MsgDisclaimCreatorStatusResponse.FromString,
                _registered_method=True)


class MsgServicer(object):
    """Msg defines the Msg service.
    """

    def UpdateParams(self, request, context):
        """UpdateParams defines a (governance) operation for updating the module
        parameters. The authority defaults to the x/gov module account.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def ApplyCreator(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 ApproveApplication(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 RejectApplication(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 CreateTask(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 RegisterTrainer(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 RegisterScorer(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 SubmitTrainingResult(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 StakeToTask(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 RequestScoringTask(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 SubmitScore(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 SubmitFinalResult(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 ReportModelPlagiarism(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 AcceptPlagiarismReport(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 RejectPlagiarismReport(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 DisputeSubmissionScore(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 StartTask(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 AbortTask(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 TriggerTaskToFinalSubmission(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 TriggerTaskToFinalTesting(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 TerminateTask(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 ClaimTaskReward(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 UnstakeFromTask(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 DisclaimCreatorStatus(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_MsgServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'UpdateParams': grpc.unary_unary_rpc_method_handler(
                    servicer.UpdateParams,
                    request_deserializer=neurion_dot_crucible_dot_tx__pb2.MsgUpdateParams.FromString,
                    response_serializer=neurion_dot_crucible_dot_tx__pb2.MsgUpdateParamsResponse.SerializeToString,
            ),
            'ApplyCreator': grpc.unary_unary_rpc_method_handler(
                    servicer.ApplyCreator,
                    request_deserializer=neurion_dot_crucible_dot_tx__pb2.MsgApplyCreator.FromString,
                    response_serializer=neurion_dot_crucible_dot_tx__pb2.MsgApplyCreatorResponse.SerializeToString,
            ),
            'ApproveApplication': grpc.unary_unary_rpc_method_handler(
                    servicer.ApproveApplication,
                    request_deserializer=neurion_dot_crucible_dot_tx__pb2.MsgApproveApplication.FromString,
                    response_serializer=neurion_dot_crucible_dot_tx__pb2.MsgApproveApplicationResponse.SerializeToString,
            ),
            'RejectApplication': grpc.unary_unary_rpc_method_handler(
                    servicer.RejectApplication,
                    request_deserializer=neurion_dot_crucible_dot_tx__pb2.MsgRejectApplication.FromString,
                    response_serializer=neurion_dot_crucible_dot_tx__pb2.MsgRejectApplicationResponse.SerializeToString,
            ),
            'CreateTask': grpc.unary_unary_rpc_method_handler(
                    servicer.CreateTask,
                    request_deserializer=neurion_dot_crucible_dot_tx__pb2.MsgCreateTask.FromString,
                    response_serializer=neurion_dot_crucible_dot_tx__pb2.MsgCreateTaskResponse.SerializeToString,
            ),
            'RegisterTrainer': grpc.unary_unary_rpc_method_handler(
                    servicer.RegisterTrainer,
                    request_deserializer=neurion_dot_crucible_dot_tx__pb2.MsgRegisterTrainer.FromString,
                    response_serializer=neurion_dot_crucible_dot_tx__pb2.MsgRegisterTrainerResponse.SerializeToString,
            ),
            'RegisterScorer': grpc.unary_unary_rpc_method_handler(
                    servicer.RegisterScorer,
                    request_deserializer=neurion_dot_crucible_dot_tx__pb2.MsgRegisterScorer.FromString,
                    response_serializer=neurion_dot_crucible_dot_tx__pb2.MsgRegisterScorerResponse.SerializeToString,
            ),
            'SubmitTrainingResult': grpc.unary_unary_rpc_method_handler(
                    servicer.SubmitTrainingResult,
                    request_deserializer=neurion_dot_crucible_dot_tx__pb2.MsgSubmitTrainingResult.FromString,
                    response_serializer=neurion_dot_crucible_dot_tx__pb2.MsgSubmitTrainingResultResponse.SerializeToString,
            ),
            'StakeToTask': grpc.unary_unary_rpc_method_handler(
                    servicer.StakeToTask,
                    request_deserializer=neurion_dot_crucible_dot_tx__pb2.MsgStakeToTask.FromString,
                    response_serializer=neurion_dot_crucible_dot_tx__pb2.MsgStakeToTaskResponse.SerializeToString,
            ),
            'RequestScoringTask': grpc.unary_unary_rpc_method_handler(
                    servicer.RequestScoringTask,
                    request_deserializer=neurion_dot_crucible_dot_tx__pb2.MsgRequestScoringTask.FromString,
                    response_serializer=neurion_dot_crucible_dot_tx__pb2.MsgRequestScoringTaskResponse.SerializeToString,
            ),
            'SubmitScore': grpc.unary_unary_rpc_method_handler(
                    servicer.SubmitScore,
                    request_deserializer=neurion_dot_crucible_dot_tx__pb2.MsgSubmitScore.FromString,
                    response_serializer=neurion_dot_crucible_dot_tx__pb2.MsgSubmitScoreResponse.SerializeToString,
            ),
            'SubmitFinalResult': grpc.unary_unary_rpc_method_handler(
                    servicer.SubmitFinalResult,
                    request_deserializer=neurion_dot_crucible_dot_tx__pb2.MsgSubmitFinalResult.FromString,
                    response_serializer=neurion_dot_crucible_dot_tx__pb2.MsgSubmitFinalResultResponse.SerializeToString,
            ),
            'ReportModelPlagiarism': grpc.unary_unary_rpc_method_handler(
                    servicer.ReportModelPlagiarism,
                    request_deserializer=neurion_dot_crucible_dot_tx__pb2.MsgReportModelPlagiarism.FromString,
                    response_serializer=neurion_dot_crucible_dot_tx__pb2.MsgReportModelPlagiarismResponse.SerializeToString,
            ),
            'AcceptPlagiarismReport': grpc.unary_unary_rpc_method_handler(
                    servicer.AcceptPlagiarismReport,
                    request_deserializer=neurion_dot_crucible_dot_tx__pb2.MsgAcceptPlagiarismReport.FromString,
                    response_serializer=neurion_dot_crucible_dot_tx__pb2.MsgAcceptPlagiarismReportResponse.SerializeToString,
            ),
            'RejectPlagiarismReport': grpc.unary_unary_rpc_method_handler(
                    servicer.RejectPlagiarismReport,
                    request_deserializer=neurion_dot_crucible_dot_tx__pb2.MsgRejectPlagiarismReport.FromString,
                    response_serializer=neurion_dot_crucible_dot_tx__pb2.MsgRejectPlagiarismReportResponse.SerializeToString,
            ),
            'DisputeSubmissionScore': grpc.unary_unary_rpc_method_handler(
                    servicer.DisputeSubmissionScore,
                    request_deserializer=neurion_dot_crucible_dot_tx__pb2.MsgDisputeSubmissionScore.FromString,
                    response_serializer=neurion_dot_crucible_dot_tx__pb2.MsgDisputeSubmissionScoreResponse.SerializeToString,
            ),
            'StartTask': grpc.unary_unary_rpc_method_handler(
                    servicer.StartTask,
                    request_deserializer=neurion_dot_crucible_dot_tx__pb2.MsgStartTask.FromString,
                    response_serializer=neurion_dot_crucible_dot_tx__pb2.MsgStartTaskResponse.SerializeToString,
            ),
            'AbortTask': grpc.unary_unary_rpc_method_handler(
                    servicer.AbortTask,
                    request_deserializer=neurion_dot_crucible_dot_tx__pb2.MsgAbortTask.FromString,
                    response_serializer=neurion_dot_crucible_dot_tx__pb2.MsgAbortTaskResponse.SerializeToString,
            ),
            'TriggerTaskToFinalSubmission': grpc.unary_unary_rpc_method_handler(
                    servicer.TriggerTaskToFinalSubmission,
                    request_deserializer=neurion_dot_crucible_dot_tx__pb2.MsgTriggerTaskToFinalSubmission.FromString,
                    response_serializer=neurion_dot_crucible_dot_tx__pb2.MsgTriggerTaskToFinalSubmissionResponse.SerializeToString,
            ),
            'TriggerTaskToFinalTesting': grpc.unary_unary_rpc_method_handler(
                    servicer.TriggerTaskToFinalTesting,
                    request_deserializer=neurion_dot_crucible_dot_tx__pb2.MsgTriggerTaskToFinalTesting.FromString,
                    response_serializer=neurion_dot_crucible_dot_tx__pb2.MsgTriggerTaskToFinalTestingResponse.SerializeToString,
            ),
            'TerminateTask': grpc.unary_unary_rpc_method_handler(
                    servicer.TerminateTask,
                    request_deserializer=neurion_dot_crucible_dot_tx__pb2.MsgTerminateTask.FromString,
                    response_serializer=neurion_dot_crucible_dot_tx__pb2.MsgTerminateTaskResponse.SerializeToString,
            ),
            'ClaimTaskReward': grpc.unary_unary_rpc_method_handler(
                    servicer.ClaimTaskReward,
                    request_deserializer=neurion_dot_crucible_dot_tx__pb2.MsgClaimTaskReward.FromString,
                    response_serializer=neurion_dot_crucible_dot_tx__pb2.MsgClaimTaskRewardResponse.SerializeToString,
            ),
            'UnstakeFromTask': grpc.unary_unary_rpc_method_handler(
                    servicer.UnstakeFromTask,
                    request_deserializer=neurion_dot_crucible_dot_tx__pb2.MsgUnstakeFromTask.FromString,
                    response_serializer=neurion_dot_crucible_dot_tx__pb2.MsgUnstakeFromTaskResponse.SerializeToString,
            ),
            'DisclaimCreatorStatus': grpc.unary_unary_rpc_method_handler(
                    servicer.DisclaimCreatorStatus,
                    request_deserializer=neurion_dot_crucible_dot_tx__pb2.MsgDisclaimCreatorStatus.FromString,
                    response_serializer=neurion_dot_crucible_dot_tx__pb2.MsgDisclaimCreatorStatusResponse.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'neurion.crucible.Msg', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))
    server.add_registered_method_handlers('neurion.crucible.Msg', rpc_method_handlers)


 # This class is part of an EXPERIMENTAL API.
class Msg(object):
    """Msg defines the Msg service.
    """

    @staticmethod
    def UpdateParams(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,
            '/neurion.crucible.Msg/UpdateParams',
            neurion_dot_crucible_dot_tx__pb2.MsgUpdateParams.SerializeToString,
            neurion_dot_crucible_dot_tx__pb2.MsgUpdateParamsResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def ApplyCreator(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,
            '/neurion.crucible.Msg/ApplyCreator',
            neurion_dot_crucible_dot_tx__pb2.MsgApplyCreator.SerializeToString,
            neurion_dot_crucible_dot_tx__pb2.MsgApplyCreatorResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def ApproveApplication(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,
            '/neurion.crucible.Msg/ApproveApplication',
            neurion_dot_crucible_dot_tx__pb2.MsgApproveApplication.SerializeToString,
            neurion_dot_crucible_dot_tx__pb2.MsgApproveApplicationResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def RejectApplication(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,
            '/neurion.crucible.Msg/RejectApplication',
            neurion_dot_crucible_dot_tx__pb2.MsgRejectApplication.SerializeToString,
            neurion_dot_crucible_dot_tx__pb2.MsgRejectApplicationResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def CreateTask(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,
            '/neurion.crucible.Msg/CreateTask',
            neurion_dot_crucible_dot_tx__pb2.MsgCreateTask.SerializeToString,
            neurion_dot_crucible_dot_tx__pb2.MsgCreateTaskResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def RegisterTrainer(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,
            '/neurion.crucible.Msg/RegisterTrainer',
            neurion_dot_crucible_dot_tx__pb2.MsgRegisterTrainer.SerializeToString,
            neurion_dot_crucible_dot_tx__pb2.MsgRegisterTrainerResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def RegisterScorer(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,
            '/neurion.crucible.Msg/RegisterScorer',
            neurion_dot_crucible_dot_tx__pb2.MsgRegisterScorer.SerializeToString,
            neurion_dot_crucible_dot_tx__pb2.MsgRegisterScorerResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def SubmitTrainingResult(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,
            '/neurion.crucible.Msg/SubmitTrainingResult',
            neurion_dot_crucible_dot_tx__pb2.MsgSubmitTrainingResult.SerializeToString,
            neurion_dot_crucible_dot_tx__pb2.MsgSubmitTrainingResultResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def StakeToTask(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,
            '/neurion.crucible.Msg/StakeToTask',
            neurion_dot_crucible_dot_tx__pb2.MsgStakeToTask.SerializeToString,
            neurion_dot_crucible_dot_tx__pb2.MsgStakeToTaskResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def RequestScoringTask(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,
            '/neurion.crucible.Msg/RequestScoringTask',
            neurion_dot_crucible_dot_tx__pb2.MsgRequestScoringTask.SerializeToString,
            neurion_dot_crucible_dot_tx__pb2.MsgRequestScoringTaskResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def SubmitScore(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,
            '/neurion.crucible.Msg/SubmitScore',
            neurion_dot_crucible_dot_tx__pb2.MsgSubmitScore.SerializeToString,
            neurion_dot_crucible_dot_tx__pb2.MsgSubmitScoreResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def SubmitFinalResult(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,
            '/neurion.crucible.Msg/SubmitFinalResult',
            neurion_dot_crucible_dot_tx__pb2.MsgSubmitFinalResult.SerializeToString,
            neurion_dot_crucible_dot_tx__pb2.MsgSubmitFinalResultResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def ReportModelPlagiarism(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,
            '/neurion.crucible.Msg/ReportModelPlagiarism',
            neurion_dot_crucible_dot_tx__pb2.MsgReportModelPlagiarism.SerializeToString,
            neurion_dot_crucible_dot_tx__pb2.MsgReportModelPlagiarismResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def AcceptPlagiarismReport(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,
            '/neurion.crucible.Msg/AcceptPlagiarismReport',
            neurion_dot_crucible_dot_tx__pb2.MsgAcceptPlagiarismReport.SerializeToString,
            neurion_dot_crucible_dot_tx__pb2.MsgAcceptPlagiarismReportResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def RejectPlagiarismReport(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,
            '/neurion.crucible.Msg/RejectPlagiarismReport',
            neurion_dot_crucible_dot_tx__pb2.MsgRejectPlagiarismReport.SerializeToString,
            neurion_dot_crucible_dot_tx__pb2.MsgRejectPlagiarismReportResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def DisputeSubmissionScore(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,
            '/neurion.crucible.Msg/DisputeSubmissionScore',
            neurion_dot_crucible_dot_tx__pb2.MsgDisputeSubmissionScore.SerializeToString,
            neurion_dot_crucible_dot_tx__pb2.MsgDisputeSubmissionScoreResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def StartTask(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,
            '/neurion.crucible.Msg/StartTask',
            neurion_dot_crucible_dot_tx__pb2.MsgStartTask.SerializeToString,
            neurion_dot_crucible_dot_tx__pb2.MsgStartTaskResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def AbortTask(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,
            '/neurion.crucible.Msg/AbortTask',
            neurion_dot_crucible_dot_tx__pb2.MsgAbortTask.SerializeToString,
            neurion_dot_crucible_dot_tx__pb2.MsgAbortTaskResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def TriggerTaskToFinalSubmission(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,
            '/neurion.crucible.Msg/TriggerTaskToFinalSubmission',
            neurion_dot_crucible_dot_tx__pb2.MsgTriggerTaskToFinalSubmission.SerializeToString,
            neurion_dot_crucible_dot_tx__pb2.MsgTriggerTaskToFinalSubmissionResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def TriggerTaskToFinalTesting(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,
            '/neurion.crucible.Msg/TriggerTaskToFinalTesting',
            neurion_dot_crucible_dot_tx__pb2.MsgTriggerTaskToFinalTesting.SerializeToString,
            neurion_dot_crucible_dot_tx__pb2.MsgTriggerTaskToFinalTestingResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def TerminateTask(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,
            '/neurion.crucible.Msg/TerminateTask',
            neurion_dot_crucible_dot_tx__pb2.MsgTerminateTask.SerializeToString,
            neurion_dot_crucible_dot_tx__pb2.MsgTerminateTaskResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def ClaimTaskReward(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,
            '/neurion.crucible.Msg/ClaimTaskReward',
            neurion_dot_crucible_dot_tx__pb2.MsgClaimTaskReward.SerializeToString,
            neurion_dot_crucible_dot_tx__pb2.MsgClaimTaskRewardResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def UnstakeFromTask(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,
            '/neurion.crucible.Msg/UnstakeFromTask',
            neurion_dot_crucible_dot_tx__pb2.MsgUnstakeFromTask.SerializeToString,
            neurion_dot_crucible_dot_tx__pb2.MsgUnstakeFromTaskResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def DisclaimCreatorStatus(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,
            '/neurion.crucible.Msg/DisclaimCreatorStatus',
            neurion_dot_crucible_dot_tx__pb2.MsgDisclaimCreatorStatus.SerializeToString,
            neurion_dot_crucible_dot_tx__pb2.MsgDisclaimCreatorStatusResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)
