# 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 getgauge.messages.messages_pb2 as messages__pb2

GRPC_GENERATED_VERSION = '1.66.1'
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 services_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 RunnerStub(object):
    """Missing associated documentation comment in .proto file."""

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

        Args:
            channel: A grpc.Channel.
        """
        self.ValidateStep = channel.unary_unary(
                '/gauge.messages.Runner/ValidateStep',
                request_serializer=messages__pb2.StepValidateRequest.SerializeToString,
                response_deserializer=messages__pb2.StepValidateResponse.FromString,
                _registered_method=True)
        self.InitializeSuiteDataStore = channel.unary_unary(
                '/gauge.messages.Runner/InitializeSuiteDataStore',
                request_serializer=messages__pb2.SuiteDataStoreInitRequest.SerializeToString,
                response_deserializer=messages__pb2.ExecutionStatusResponse.FromString,
                _registered_method=True)
        self.StartExecution = channel.unary_unary(
                '/gauge.messages.Runner/StartExecution',
                request_serializer=messages__pb2.ExecutionStartingRequest.SerializeToString,
                response_deserializer=messages__pb2.ExecutionStatusResponse.FromString,
                _registered_method=True)
        self.InitializeSpecDataStore = channel.unary_unary(
                '/gauge.messages.Runner/InitializeSpecDataStore',
                request_serializer=messages__pb2.SpecDataStoreInitRequest.SerializeToString,
                response_deserializer=messages__pb2.ExecutionStatusResponse.FromString,
                _registered_method=True)
        self.StartSpecExecution = channel.unary_unary(
                '/gauge.messages.Runner/StartSpecExecution',
                request_serializer=messages__pb2.SpecExecutionStartingRequest.SerializeToString,
                response_deserializer=messages__pb2.ExecutionStatusResponse.FromString,
                _registered_method=True)
        self.InitializeScenarioDataStore = channel.unary_unary(
                '/gauge.messages.Runner/InitializeScenarioDataStore',
                request_serializer=messages__pb2.ScenarioDataStoreInitRequest.SerializeToString,
                response_deserializer=messages__pb2.ExecutionStatusResponse.FromString,
                _registered_method=True)
        self.StartScenarioExecution = channel.unary_unary(
                '/gauge.messages.Runner/StartScenarioExecution',
                request_serializer=messages__pb2.ScenarioExecutionStartingRequest.SerializeToString,
                response_deserializer=messages__pb2.ExecutionStatusResponse.FromString,
                _registered_method=True)
        self.StartStepExecution = channel.unary_unary(
                '/gauge.messages.Runner/StartStepExecution',
                request_serializer=messages__pb2.StepExecutionStartingRequest.SerializeToString,
                response_deserializer=messages__pb2.ExecutionStatusResponse.FromString,
                _registered_method=True)
        self.ExecuteStep = channel.unary_unary(
                '/gauge.messages.Runner/ExecuteStep',
                request_serializer=messages__pb2.ExecuteStepRequest.SerializeToString,
                response_deserializer=messages__pb2.ExecutionStatusResponse.FromString,
                _registered_method=True)
        self.FinishStepExecution = channel.unary_unary(
                '/gauge.messages.Runner/FinishStepExecution',
                request_serializer=messages__pb2.StepExecutionEndingRequest.SerializeToString,
                response_deserializer=messages__pb2.ExecutionStatusResponse.FromString,
                _registered_method=True)
        self.FinishScenarioExecution = channel.unary_unary(
                '/gauge.messages.Runner/FinishScenarioExecution',
                request_serializer=messages__pb2.ScenarioExecutionEndingRequest.SerializeToString,
                response_deserializer=messages__pb2.ExecutionStatusResponse.FromString,
                _registered_method=True)
        self.FinishSpecExecution = channel.unary_unary(
                '/gauge.messages.Runner/FinishSpecExecution',
                request_serializer=messages__pb2.SpecExecutionEndingRequest.SerializeToString,
                response_deserializer=messages__pb2.ExecutionStatusResponse.FromString,
                _registered_method=True)
        self.FinishExecution = channel.unary_unary(
                '/gauge.messages.Runner/FinishExecution',
                request_serializer=messages__pb2.ExecutionEndingRequest.SerializeToString,
                response_deserializer=messages__pb2.ExecutionStatusResponse.FromString,
                _registered_method=True)
        self.CacheFile = channel.unary_unary(
                '/gauge.messages.Runner/CacheFile',
                request_serializer=messages__pb2.CacheFileRequest.SerializeToString,
                response_deserializer=messages__pb2.Empty.FromString,
                _registered_method=True)
        self.GetStepName = channel.unary_unary(
                '/gauge.messages.Runner/GetStepName',
                request_serializer=messages__pb2.StepNameRequest.SerializeToString,
                response_deserializer=messages__pb2.StepNameResponse.FromString,
                _registered_method=True)
        self.GetGlobPatterns = channel.unary_unary(
                '/gauge.messages.Runner/GetGlobPatterns',
                request_serializer=messages__pb2.Empty.SerializeToString,
                response_deserializer=messages__pb2.ImplementationFileGlobPatternResponse.FromString,
                _registered_method=True)
        self.GetStepNames = channel.unary_unary(
                '/gauge.messages.Runner/GetStepNames',
                request_serializer=messages__pb2.StepNamesRequest.SerializeToString,
                response_deserializer=messages__pb2.StepNamesResponse.FromString,
                _registered_method=True)
        self.GetStepPositions = channel.unary_unary(
                '/gauge.messages.Runner/GetStepPositions',
                request_serializer=messages__pb2.StepPositionsRequest.SerializeToString,
                response_deserializer=messages__pb2.StepPositionsResponse.FromString,
                _registered_method=True)
        self.GetImplementationFiles = channel.unary_unary(
                '/gauge.messages.Runner/GetImplementationFiles',
                request_serializer=messages__pb2.Empty.SerializeToString,
                response_deserializer=messages__pb2.ImplementationFileListResponse.FromString,
                _registered_method=True)
        self.ImplementStub = channel.unary_unary(
                '/gauge.messages.Runner/ImplementStub',
                request_serializer=messages__pb2.StubImplementationCodeRequest.SerializeToString,
                response_deserializer=messages__pb2.FileDiff.FromString,
                _registered_method=True)
        self.Refactor = channel.unary_unary(
                '/gauge.messages.Runner/Refactor',
                request_serializer=messages__pb2.RefactorRequest.SerializeToString,
                response_deserializer=messages__pb2.RefactorResponse.FromString,
                _registered_method=True)
        self.Kill = channel.unary_unary(
                '/gauge.messages.Runner/Kill',
                request_serializer=messages__pb2.KillProcessRequest.SerializeToString,
                response_deserializer=messages__pb2.Empty.FromString,
                _registered_method=True)
        self.NotifyConceptExecutionStarting = channel.unary_unary(
                '/gauge.messages.Runner/NotifyConceptExecutionStarting',
                request_serializer=messages__pb2.ConceptExecutionStartingRequest.SerializeToString,
                response_deserializer=messages__pb2.ExecutionStatusResponse.FromString,
                _registered_method=True)
        self.NotifyConceptExecutionEnding = channel.unary_unary(
                '/gauge.messages.Runner/NotifyConceptExecutionEnding',
                request_serializer=messages__pb2.ConceptExecutionEndingRequest.SerializeToString,
                response_deserializer=messages__pb2.ExecutionStatusResponse.FromString,
                _registered_method=True)


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

    def ValidateStep(self, request, context):
        """ValidateStep is a RPC to validate a given step.

        Accepts a StepValidateRequest message and returns a StepValidateResponse message
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def InitializeSuiteDataStore(self, request, context):
        """SuiteDataStoreInit is a RPC to initialize the suite level data store.

        Accepts a Empty message and returns a ExecutionStatusResponse message
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def StartExecution(self, request, context):
        """ExecutionStarting is a RPC to tell runner to execute Suite level hooks.

        Accepts a ExecutionStartingRequest message and returns a ExecutionStatusResponse message
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def InitializeSpecDataStore(self, request, context):
        """SpecDataStoreInit is a RPC to initialize the spec level data store.

        Accepts a Empty message and returns a ExecutionStatusResponse message
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def StartSpecExecution(self, request, context):
        """SpecExecutionStarting is a RPC to tell runner to execute spec level hooks.

        Accepts a SpecExecutionStartingRequest message and returns a ExecutionStatusResponse message
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def InitializeScenarioDataStore(self, request, context):
        """ScenarioDataStoreInit is a RPC to initialize the scenario level data store.

        Accepts a Empty message and returns a ExecutionStatusResponse message
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def StartScenarioExecution(self, request, context):
        """ScenarioExecutionStarting is a RPC to tell runner to execute scenario level hooks.

        Accepts a ScenarioExecutionStartingRequest message and returns a ExecutionStatusResponse message
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def StartStepExecution(self, request, context):
        """StepExecutionStarting is a RPC to tell runner to execute step level hooks.

        Accepts a StepExecutionStartingRequest message and returns a ExecutionStatusResponse message
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def ExecuteStep(self, request, context):
        """ExecuteStep is a RPC to tell runner to execute a step .

        Accepts a ExecuteStepRequest message and returns a ExecutionStatusResponse message
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def FinishStepExecution(self, request, context):
        """StepExecutionEnding is a RPC to tell runner to execute step level hooks.

        Accepts a StepExecutionEndingRequest message and returns a ExecutionStatusResponse message
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def FinishScenarioExecution(self, request, context):
        """ScenarioExecutionEnding is a RPC to tell runner to execute Scenario level hooks.

        Accepts a ScenarioExecutionEndingRequest message and returns a ExecutionStatusResponse message
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def FinishSpecExecution(self, request, context):
        """SpecExecutionEnding is a RPC to tell runner to execute spec level hooks.

        Accepts a SpecExecutionEndingRequest message and returns a ExecutionStatusResponse message
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def FinishExecution(self, request, context):
        """ExecutionEnding is a RPC to tell runner to execute suite level hooks.

        Accepts a ExecutionEndingRequest message and returns a ExecutionStatusResponse message
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def CacheFile(self, request, context):
        """CacheFile is a RPC to tell runner to load/reload/unload a implementation file.

        Accepts a CacheFileRequest message and returns a Empty message
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetStepName(self, request, context):
        """GetStepName is a RPC to get information about the given step.

        Accepts a StepNameRequest message and returns a StepNameResponse message.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetGlobPatterns(self, request, context):
        """GetGlobPatterns is a RPC to get the file path pattern which needs to be cached.

        Accepts a Empty message and returns a ImplementationFileGlobPatternResponse message.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetStepNames(self, request, context):
        """GetStepNames is a RPC to get all the available steps from the runner.

        Accepts a StepNamesRequest message and returns a StepNamesResponse
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetStepPositions(self, request, context):
        """GetStepPositions is a RPC to get positions of all available steps in a given file.

        Accepts a StepPositionsRequest message and returns a StepPositionsResponse message
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetImplementationFiles(self, request, context):
        """GetImplementationFiles is a RPC get all the existing implementation files.

        Accepts a Empty and returns a ImplementationFileListResponse message.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def ImplementStub(self, request, context):
        """ImplementStub is a RPC to to ask runner to add a given implementation to given file.

        Accepts a StubImplementationCodeRequest and returns a FileDiff message.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Refactor(self, request, context):
        """Refactor is a RPC to refactor a given step in implementation file.

        Accepts a RefactorRequest message and returns a RefactorResponse message.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Kill(self, request, context):
        """Kill is a RPC tell plugin to stop grpc server and kill the plugin process.

        Accepts a KillProcessRequest message and returns a Empty message.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def NotifyConceptExecutionStarting(self, request, context):
        """NotifyConceptExecutionStarting is a RPC to tell plugins that the concept execution has started.

        Accepts a ConceptExecutionStartingRequest message and returns an ExecutionStatusResponse message
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def NotifyConceptExecutionEnding(self, request, context):
        """NotifyConceptExecutionEnding is a RPC to tell plugins that the concept execution has finished.

        Accepts a ConceptExecutionEndingRequest message and returns an ExecutionStatusResponse message
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')


def add_RunnerServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'ValidateStep': grpc.unary_unary_rpc_method_handler(
                    servicer.ValidateStep,
                    request_deserializer=messages__pb2.StepValidateRequest.FromString,
                    response_serializer=messages__pb2.StepValidateResponse.SerializeToString,
            ),
            'InitializeSuiteDataStore': grpc.unary_unary_rpc_method_handler(
                    servicer.InitializeSuiteDataStore,
                    request_deserializer=messages__pb2.SuiteDataStoreInitRequest.FromString,
                    response_serializer=messages__pb2.ExecutionStatusResponse.SerializeToString,
            ),
            'StartExecution': grpc.unary_unary_rpc_method_handler(
                    servicer.StartExecution,
                    request_deserializer=messages__pb2.ExecutionStartingRequest.FromString,
                    response_serializer=messages__pb2.ExecutionStatusResponse.SerializeToString,
            ),
            'InitializeSpecDataStore': grpc.unary_unary_rpc_method_handler(
                    servicer.InitializeSpecDataStore,
                    request_deserializer=messages__pb2.SpecDataStoreInitRequest.FromString,
                    response_serializer=messages__pb2.ExecutionStatusResponse.SerializeToString,
            ),
            'StartSpecExecution': grpc.unary_unary_rpc_method_handler(
                    servicer.StartSpecExecution,
                    request_deserializer=messages__pb2.SpecExecutionStartingRequest.FromString,
                    response_serializer=messages__pb2.ExecutionStatusResponse.SerializeToString,
            ),
            'InitializeScenarioDataStore': grpc.unary_unary_rpc_method_handler(
                    servicer.InitializeScenarioDataStore,
                    request_deserializer=messages__pb2.ScenarioDataStoreInitRequest.FromString,
                    response_serializer=messages__pb2.ExecutionStatusResponse.SerializeToString,
            ),
            'StartScenarioExecution': grpc.unary_unary_rpc_method_handler(
                    servicer.StartScenarioExecution,
                    request_deserializer=messages__pb2.ScenarioExecutionStartingRequest.FromString,
                    response_serializer=messages__pb2.ExecutionStatusResponse.SerializeToString,
            ),
            'StartStepExecution': grpc.unary_unary_rpc_method_handler(
                    servicer.StartStepExecution,
                    request_deserializer=messages__pb2.StepExecutionStartingRequest.FromString,
                    response_serializer=messages__pb2.ExecutionStatusResponse.SerializeToString,
            ),
            'ExecuteStep': grpc.unary_unary_rpc_method_handler(
                    servicer.ExecuteStep,
                    request_deserializer=messages__pb2.ExecuteStepRequest.FromString,
                    response_serializer=messages__pb2.ExecutionStatusResponse.SerializeToString,
            ),
            'FinishStepExecution': grpc.unary_unary_rpc_method_handler(
                    servicer.FinishStepExecution,
                    request_deserializer=messages__pb2.StepExecutionEndingRequest.FromString,
                    response_serializer=messages__pb2.ExecutionStatusResponse.SerializeToString,
            ),
            'FinishScenarioExecution': grpc.unary_unary_rpc_method_handler(
                    servicer.FinishScenarioExecution,
                    request_deserializer=messages__pb2.ScenarioExecutionEndingRequest.FromString,
                    response_serializer=messages__pb2.ExecutionStatusResponse.SerializeToString,
            ),
            'FinishSpecExecution': grpc.unary_unary_rpc_method_handler(
                    servicer.FinishSpecExecution,
                    request_deserializer=messages__pb2.SpecExecutionEndingRequest.FromString,
                    response_serializer=messages__pb2.ExecutionStatusResponse.SerializeToString,
            ),
            'FinishExecution': grpc.unary_unary_rpc_method_handler(
                    servicer.FinishExecution,
                    request_deserializer=messages__pb2.ExecutionEndingRequest.FromString,
                    response_serializer=messages__pb2.ExecutionStatusResponse.SerializeToString,
            ),
            'CacheFile': grpc.unary_unary_rpc_method_handler(
                    servicer.CacheFile,
                    request_deserializer=messages__pb2.CacheFileRequest.FromString,
                    response_serializer=messages__pb2.Empty.SerializeToString,
            ),
            'GetStepName': grpc.unary_unary_rpc_method_handler(
                    servicer.GetStepName,
                    request_deserializer=messages__pb2.StepNameRequest.FromString,
                    response_serializer=messages__pb2.StepNameResponse.SerializeToString,
            ),
            'GetGlobPatterns': grpc.unary_unary_rpc_method_handler(
                    servicer.GetGlobPatterns,
                    request_deserializer=messages__pb2.Empty.FromString,
                    response_serializer=messages__pb2.ImplementationFileGlobPatternResponse.SerializeToString,
            ),
            'GetStepNames': grpc.unary_unary_rpc_method_handler(
                    servicer.GetStepNames,
                    request_deserializer=messages__pb2.StepNamesRequest.FromString,
                    response_serializer=messages__pb2.StepNamesResponse.SerializeToString,
            ),
            'GetStepPositions': grpc.unary_unary_rpc_method_handler(
                    servicer.GetStepPositions,
                    request_deserializer=messages__pb2.StepPositionsRequest.FromString,
                    response_serializer=messages__pb2.StepPositionsResponse.SerializeToString,
            ),
            'GetImplementationFiles': grpc.unary_unary_rpc_method_handler(
                    servicer.GetImplementationFiles,
                    request_deserializer=messages__pb2.Empty.FromString,
                    response_serializer=messages__pb2.ImplementationFileListResponse.SerializeToString,
            ),
            'ImplementStub': grpc.unary_unary_rpc_method_handler(
                    servicer.ImplementStub,
                    request_deserializer=messages__pb2.StubImplementationCodeRequest.FromString,
                    response_serializer=messages__pb2.FileDiff.SerializeToString,
            ),
            'Refactor': grpc.unary_unary_rpc_method_handler(
                    servicer.Refactor,
                    request_deserializer=messages__pb2.RefactorRequest.FromString,
                    response_serializer=messages__pb2.RefactorResponse.SerializeToString,
            ),
            'Kill': grpc.unary_unary_rpc_method_handler(
                    servicer.Kill,
                    request_deserializer=messages__pb2.KillProcessRequest.FromString,
                    response_serializer=messages__pb2.Empty.SerializeToString,
            ),
            'NotifyConceptExecutionStarting': grpc.unary_unary_rpc_method_handler(
                    servicer.NotifyConceptExecutionStarting,
                    request_deserializer=messages__pb2.ConceptExecutionStartingRequest.FromString,
                    response_serializer=messages__pb2.ExecutionStatusResponse.SerializeToString,
            ),
            'NotifyConceptExecutionEnding': grpc.unary_unary_rpc_method_handler(
                    servicer.NotifyConceptExecutionEnding,
                    request_deserializer=messages__pb2.ConceptExecutionEndingRequest.FromString,
                    response_serializer=messages__pb2.ExecutionStatusResponse.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'gauge.messages.Runner', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))
    server.add_registered_method_handlers('gauge.messages.Runner', rpc_method_handlers)


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

    @staticmethod
    def ValidateStep(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,
            '/gauge.messages.Runner/ValidateStep',
            messages__pb2.StepValidateRequest.SerializeToString,
            messages__pb2.StepValidateResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def InitializeSuiteDataStore(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,
            '/gauge.messages.Runner/InitializeSuiteDataStore',
            messages__pb2.SuiteDataStoreInitRequest.SerializeToString,
            messages__pb2.ExecutionStatusResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def StartExecution(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,
            '/gauge.messages.Runner/StartExecution',
            messages__pb2.ExecutionStartingRequest.SerializeToString,
            messages__pb2.ExecutionStatusResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def InitializeSpecDataStore(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,
            '/gauge.messages.Runner/InitializeSpecDataStore',
            messages__pb2.SpecDataStoreInitRequest.SerializeToString,
            messages__pb2.ExecutionStatusResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def StartSpecExecution(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,
            '/gauge.messages.Runner/StartSpecExecution',
            messages__pb2.SpecExecutionStartingRequest.SerializeToString,
            messages__pb2.ExecutionStatusResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def InitializeScenarioDataStore(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,
            '/gauge.messages.Runner/InitializeScenarioDataStore',
            messages__pb2.ScenarioDataStoreInitRequest.SerializeToString,
            messages__pb2.ExecutionStatusResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def StartScenarioExecution(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,
            '/gauge.messages.Runner/StartScenarioExecution',
            messages__pb2.ScenarioExecutionStartingRequest.SerializeToString,
            messages__pb2.ExecutionStatusResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def StartStepExecution(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,
            '/gauge.messages.Runner/StartStepExecution',
            messages__pb2.StepExecutionStartingRequest.SerializeToString,
            messages__pb2.ExecutionStatusResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def ExecuteStep(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,
            '/gauge.messages.Runner/ExecuteStep',
            messages__pb2.ExecuteStepRequest.SerializeToString,
            messages__pb2.ExecutionStatusResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def FinishStepExecution(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,
            '/gauge.messages.Runner/FinishStepExecution',
            messages__pb2.StepExecutionEndingRequest.SerializeToString,
            messages__pb2.ExecutionStatusResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def FinishScenarioExecution(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,
            '/gauge.messages.Runner/FinishScenarioExecution',
            messages__pb2.ScenarioExecutionEndingRequest.SerializeToString,
            messages__pb2.ExecutionStatusResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def FinishSpecExecution(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,
            '/gauge.messages.Runner/FinishSpecExecution',
            messages__pb2.SpecExecutionEndingRequest.SerializeToString,
            messages__pb2.ExecutionStatusResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def FinishExecution(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,
            '/gauge.messages.Runner/FinishExecution',
            messages__pb2.ExecutionEndingRequest.SerializeToString,
            messages__pb2.ExecutionStatusResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def CacheFile(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,
            '/gauge.messages.Runner/CacheFile',
            messages__pb2.CacheFileRequest.SerializeToString,
            messages__pb2.Empty.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetStepName(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,
            '/gauge.messages.Runner/GetStepName',
            messages__pb2.StepNameRequest.SerializeToString,
            messages__pb2.StepNameResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetGlobPatterns(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,
            '/gauge.messages.Runner/GetGlobPatterns',
            messages__pb2.Empty.SerializeToString,
            messages__pb2.ImplementationFileGlobPatternResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetStepNames(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,
            '/gauge.messages.Runner/GetStepNames',
            messages__pb2.StepNamesRequest.SerializeToString,
            messages__pb2.StepNamesResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetStepPositions(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,
            '/gauge.messages.Runner/GetStepPositions',
            messages__pb2.StepPositionsRequest.SerializeToString,
            messages__pb2.StepPositionsResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetImplementationFiles(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,
            '/gauge.messages.Runner/GetImplementationFiles',
            messages__pb2.Empty.SerializeToString,
            messages__pb2.ImplementationFileListResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def ImplementStub(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,
            '/gauge.messages.Runner/ImplementStub',
            messages__pb2.StubImplementationCodeRequest.SerializeToString,
            messages__pb2.FileDiff.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def Refactor(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,
            '/gauge.messages.Runner/Refactor',
            messages__pb2.RefactorRequest.SerializeToString,
            messages__pb2.RefactorResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def Kill(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,
            '/gauge.messages.Runner/Kill',
            messages__pb2.KillProcessRequest.SerializeToString,
            messages__pb2.Empty.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def NotifyConceptExecutionStarting(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,
            '/gauge.messages.Runner/NotifyConceptExecutionStarting',
            messages__pb2.ConceptExecutionStartingRequest.SerializeToString,
            messages__pb2.ExecutionStatusResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def NotifyConceptExecutionEnding(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,
            '/gauge.messages.Runner/NotifyConceptExecutionEnding',
            messages__pb2.ConceptExecutionEndingRequest.SerializeToString,
            messages__pb2.ExecutionStatusResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)


class ReporterStub(object):
    """Reporter services is meant for reporting plugins, or others plugins which are interested the live events
    """

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

        Args:
            channel: A grpc.Channel.
        """
        self.NotifyExecutionStarting = channel.unary_unary(
                '/gauge.messages.Reporter/NotifyExecutionStarting',
                request_serializer=messages__pb2.ExecutionStartingRequest.SerializeToString,
                response_deserializer=messages__pb2.Empty.FromString,
                _registered_method=True)
        self.NotifySpecExecutionStarting = channel.unary_unary(
                '/gauge.messages.Reporter/NotifySpecExecutionStarting',
                request_serializer=messages__pb2.SpecExecutionStartingRequest.SerializeToString,
                response_deserializer=messages__pb2.Empty.FromString,
                _registered_method=True)
        self.NotifyScenarioExecutionStarting = channel.unary_unary(
                '/gauge.messages.Reporter/NotifyScenarioExecutionStarting',
                request_serializer=messages__pb2.ScenarioExecutionStartingRequest.SerializeToString,
                response_deserializer=messages__pb2.Empty.FromString,
                _registered_method=True)
        self.NotifyConceptExecutionStarting = channel.unary_unary(
                '/gauge.messages.Reporter/NotifyConceptExecutionStarting',
                request_serializer=messages__pb2.ConceptExecutionStartingRequest.SerializeToString,
                response_deserializer=messages__pb2.Empty.FromString,
                _registered_method=True)
        self.NotifyConceptExecutionEnding = channel.unary_unary(
                '/gauge.messages.Reporter/NotifyConceptExecutionEnding',
                request_serializer=messages__pb2.ConceptExecutionEndingRequest.SerializeToString,
                response_deserializer=messages__pb2.Empty.FromString,
                _registered_method=True)
        self.NotifyStepExecutionStarting = channel.unary_unary(
                '/gauge.messages.Reporter/NotifyStepExecutionStarting',
                request_serializer=messages__pb2.StepExecutionStartingRequest.SerializeToString,
                response_deserializer=messages__pb2.Empty.FromString,
                _registered_method=True)
        self.NotifyStepExecutionEnding = channel.unary_unary(
                '/gauge.messages.Reporter/NotifyStepExecutionEnding',
                request_serializer=messages__pb2.StepExecutionEndingRequest.SerializeToString,
                response_deserializer=messages__pb2.Empty.FromString,
                _registered_method=True)
        self.NotifyScenarioExecutionEnding = channel.unary_unary(
                '/gauge.messages.Reporter/NotifyScenarioExecutionEnding',
                request_serializer=messages__pb2.ScenarioExecutionEndingRequest.SerializeToString,
                response_deserializer=messages__pb2.Empty.FromString,
                _registered_method=True)
        self.NotifySpecExecutionEnding = channel.unary_unary(
                '/gauge.messages.Reporter/NotifySpecExecutionEnding',
                request_serializer=messages__pb2.SpecExecutionEndingRequest.SerializeToString,
                response_deserializer=messages__pb2.Empty.FromString,
                _registered_method=True)
        self.NotifyExecutionEnding = channel.unary_unary(
                '/gauge.messages.Reporter/NotifyExecutionEnding',
                request_serializer=messages__pb2.ExecutionEndingRequest.SerializeToString,
                response_deserializer=messages__pb2.Empty.FromString,
                _registered_method=True)
        self.NotifySuiteResult = channel.unary_unary(
                '/gauge.messages.Reporter/NotifySuiteResult',
                request_serializer=messages__pb2.SuiteExecutionResult.SerializeToString,
                response_deserializer=messages__pb2.Empty.FromString,
                _registered_method=True)
        self.Kill = channel.unary_unary(
                '/gauge.messages.Reporter/Kill',
                request_serializer=messages__pb2.KillProcessRequest.SerializeToString,
                response_deserializer=messages__pb2.Empty.FromString,
                _registered_method=True)


class ReporterServicer(object):
    """Reporter services is meant for reporting plugins, or others plugins which are interested the live events
    """

    def NotifyExecutionStarting(self, request, context):
        """NotifyExecutionStarting is a RPC to tell plugins that the execution has started.

        Accepts a ExecutionStartingRequest message and returns a Empty message
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def NotifySpecExecutionStarting(self, request, context):
        """NotifySpecExecutionStarting is a RPC to tell plugins that the specification execution has started.

        Accepts a SpecExecutionStartingRequest message and returns a Empty message
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def NotifyScenarioExecutionStarting(self, request, context):
        """NotifyScenarioExecutionStarting is a RPC to tell plugins that the scenario execution has started.

        Accepts a ScenarioExecutionStartingRequest message and returns a Empty message
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def NotifyConceptExecutionStarting(self, request, context):
        """NotifyConceptExecutionStarting is a RPC to tell plugins that the concept execution has started.

        Accepts a ConceptExecutionStartingRequest message and returns a Empty message
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def NotifyConceptExecutionEnding(self, request, context):
        """NotifyConceptExecutionEnding is a RPC to tell plugins that the concept execution has finished.

        Accepts a ConceptExecutionEndingRequest message and returns a Empty message
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def NotifyStepExecutionStarting(self, request, context):
        """NotifyStepExecutionStarting is a RPC to tell plugins that the step execution has started.

        Accepts a StepExecutionStartingRequest message and returns a Empty message
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def NotifyStepExecutionEnding(self, request, context):
        """NotifyStepExecutionEnding is a RPC to tell plugins that the step execution has finished.

        Accepts a StepExecutionStartingRequest message and returns a Empty message
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def NotifyScenarioExecutionEnding(self, request, context):
        """NotifyScenarioExecutionEnding is a RPC to tell plugins that the scenario execution has finished.

        Accepts a ScenarioExecutionEndingRequest message and returns a Empty message
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def NotifySpecExecutionEnding(self, request, context):
        """NotifySpecExecutionEnding is a RPC to tell plugins that the specification execution has finished.

        Accepts a SpecExecutionStartingRequest message and returns a Empty message
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def NotifyExecutionEnding(self, request, context):
        """NotifyExecutionEnding is a RPC to tell plugins that the execution has finished.

        Accepts a ExecutionEndingRequest message and returns a Empty message
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def NotifySuiteResult(self, request, context):
        """NotifySuiteResult is a RPC to tell about the end result of execution

        Accepts a SuiteExecutionResult message and returns a Empty message.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Kill(self, request, context):
        """Kill is a RPC tell plugin to stop grpc server and kill the plugin process.

        Accepts a KillProcessRequest message and returns a Empty message.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')


def add_ReporterServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'NotifyExecutionStarting': grpc.unary_unary_rpc_method_handler(
                    servicer.NotifyExecutionStarting,
                    request_deserializer=messages__pb2.ExecutionStartingRequest.FromString,
                    response_serializer=messages__pb2.Empty.SerializeToString,
            ),
            'NotifySpecExecutionStarting': grpc.unary_unary_rpc_method_handler(
                    servicer.NotifySpecExecutionStarting,
                    request_deserializer=messages__pb2.SpecExecutionStartingRequest.FromString,
                    response_serializer=messages__pb2.Empty.SerializeToString,
            ),
            'NotifyScenarioExecutionStarting': grpc.unary_unary_rpc_method_handler(
                    servicer.NotifyScenarioExecutionStarting,
                    request_deserializer=messages__pb2.ScenarioExecutionStartingRequest.FromString,
                    response_serializer=messages__pb2.Empty.SerializeToString,
            ),
            'NotifyConceptExecutionStarting': grpc.unary_unary_rpc_method_handler(
                    servicer.NotifyConceptExecutionStarting,
                    request_deserializer=messages__pb2.ConceptExecutionStartingRequest.FromString,
                    response_serializer=messages__pb2.Empty.SerializeToString,
            ),
            'NotifyConceptExecutionEnding': grpc.unary_unary_rpc_method_handler(
                    servicer.NotifyConceptExecutionEnding,
                    request_deserializer=messages__pb2.ConceptExecutionEndingRequest.FromString,
                    response_serializer=messages__pb2.Empty.SerializeToString,
            ),
            'NotifyStepExecutionStarting': grpc.unary_unary_rpc_method_handler(
                    servicer.NotifyStepExecutionStarting,
                    request_deserializer=messages__pb2.StepExecutionStartingRequest.FromString,
                    response_serializer=messages__pb2.Empty.SerializeToString,
            ),
            'NotifyStepExecutionEnding': grpc.unary_unary_rpc_method_handler(
                    servicer.NotifyStepExecutionEnding,
                    request_deserializer=messages__pb2.StepExecutionEndingRequest.FromString,
                    response_serializer=messages__pb2.Empty.SerializeToString,
            ),
            'NotifyScenarioExecutionEnding': grpc.unary_unary_rpc_method_handler(
                    servicer.NotifyScenarioExecutionEnding,
                    request_deserializer=messages__pb2.ScenarioExecutionEndingRequest.FromString,
                    response_serializer=messages__pb2.Empty.SerializeToString,
            ),
            'NotifySpecExecutionEnding': grpc.unary_unary_rpc_method_handler(
                    servicer.NotifySpecExecutionEnding,
                    request_deserializer=messages__pb2.SpecExecutionEndingRequest.FromString,
                    response_serializer=messages__pb2.Empty.SerializeToString,
            ),
            'NotifyExecutionEnding': grpc.unary_unary_rpc_method_handler(
                    servicer.NotifyExecutionEnding,
                    request_deserializer=messages__pb2.ExecutionEndingRequest.FromString,
                    response_serializer=messages__pb2.Empty.SerializeToString,
            ),
            'NotifySuiteResult': grpc.unary_unary_rpc_method_handler(
                    servicer.NotifySuiteResult,
                    request_deserializer=messages__pb2.SuiteExecutionResult.FromString,
                    response_serializer=messages__pb2.Empty.SerializeToString,
            ),
            'Kill': grpc.unary_unary_rpc_method_handler(
                    servicer.Kill,
                    request_deserializer=messages__pb2.KillProcessRequest.FromString,
                    response_serializer=messages__pb2.Empty.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'gauge.messages.Reporter', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))
    server.add_registered_method_handlers('gauge.messages.Reporter', rpc_method_handlers)


 # This class is part of an EXPERIMENTAL API.
class Reporter(object):
    """Reporter services is meant for reporting plugins, or others plugins which are interested the live events
    """

    @staticmethod
    def NotifyExecutionStarting(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,
            '/gauge.messages.Reporter/NotifyExecutionStarting',
            messages__pb2.ExecutionStartingRequest.SerializeToString,
            messages__pb2.Empty.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def NotifySpecExecutionStarting(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,
            '/gauge.messages.Reporter/NotifySpecExecutionStarting',
            messages__pb2.SpecExecutionStartingRequest.SerializeToString,
            messages__pb2.Empty.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def NotifyScenarioExecutionStarting(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,
            '/gauge.messages.Reporter/NotifyScenarioExecutionStarting',
            messages__pb2.ScenarioExecutionStartingRequest.SerializeToString,
            messages__pb2.Empty.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def NotifyConceptExecutionStarting(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,
            '/gauge.messages.Reporter/NotifyConceptExecutionStarting',
            messages__pb2.ConceptExecutionStartingRequest.SerializeToString,
            messages__pb2.Empty.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def NotifyConceptExecutionEnding(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,
            '/gauge.messages.Reporter/NotifyConceptExecutionEnding',
            messages__pb2.ConceptExecutionEndingRequest.SerializeToString,
            messages__pb2.Empty.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def NotifyStepExecutionStarting(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,
            '/gauge.messages.Reporter/NotifyStepExecutionStarting',
            messages__pb2.StepExecutionStartingRequest.SerializeToString,
            messages__pb2.Empty.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def NotifyStepExecutionEnding(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,
            '/gauge.messages.Reporter/NotifyStepExecutionEnding',
            messages__pb2.StepExecutionEndingRequest.SerializeToString,
            messages__pb2.Empty.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def NotifyScenarioExecutionEnding(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,
            '/gauge.messages.Reporter/NotifyScenarioExecutionEnding',
            messages__pb2.ScenarioExecutionEndingRequest.SerializeToString,
            messages__pb2.Empty.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def NotifySpecExecutionEnding(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,
            '/gauge.messages.Reporter/NotifySpecExecutionEnding',
            messages__pb2.SpecExecutionEndingRequest.SerializeToString,
            messages__pb2.Empty.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def NotifyExecutionEnding(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,
            '/gauge.messages.Reporter/NotifyExecutionEnding',
            messages__pb2.ExecutionEndingRequest.SerializeToString,
            messages__pb2.Empty.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def NotifySuiteResult(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,
            '/gauge.messages.Reporter/NotifySuiteResult',
            messages__pb2.SuiteExecutionResult.SerializeToString,
            messages__pb2.Empty.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def Kill(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,
            '/gauge.messages.Reporter/Kill',
            messages__pb2.KillProcessRequest.SerializeToString,
            messages__pb2.Empty.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)


class DocumenterStub(object):
    """Reporter services is meant for documentation plugins
    """

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

        Args:
            channel: A grpc.Channel.
        """
        self.GenerateDocs = channel.unary_unary(
                '/gauge.messages.Documenter/GenerateDocs',
                request_serializer=messages__pb2.SpecDetails.SerializeToString,
                response_deserializer=messages__pb2.Empty.FromString,
                _registered_method=True)
        self.Kill = channel.unary_unary(
                '/gauge.messages.Documenter/Kill',
                request_serializer=messages__pb2.KillProcessRequest.SerializeToString,
                response_deserializer=messages__pb2.Empty.FromString,
                _registered_method=True)


class DocumenterServicer(object):
    """Reporter services is meant for documentation plugins
    """

    def GenerateDocs(self, request, context):
        """GenerateDocs is a RPC tell plugin to generate docs from the spec details.

        Accepts a SpecDetails message and returns a Empty message.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Kill(self, request, context):
        """Kill is a RPC tell plugin to stop grpc server and kill the plugin process.

        Accepts a KillProcessRequest message and returns a Empty message.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')


def add_DocumenterServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'GenerateDocs': grpc.unary_unary_rpc_method_handler(
                    servicer.GenerateDocs,
                    request_deserializer=messages__pb2.SpecDetails.FromString,
                    response_serializer=messages__pb2.Empty.SerializeToString,
            ),
            'Kill': grpc.unary_unary_rpc_method_handler(
                    servicer.Kill,
                    request_deserializer=messages__pb2.KillProcessRequest.FromString,
                    response_serializer=messages__pb2.Empty.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'gauge.messages.Documenter', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))
    server.add_registered_method_handlers('gauge.messages.Documenter', rpc_method_handlers)


 # This class is part of an EXPERIMENTAL API.
class Documenter(object):
    """Reporter services is meant for documentation plugins
    """

    @staticmethod
    def GenerateDocs(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,
            '/gauge.messages.Documenter/GenerateDocs',
            messages__pb2.SpecDetails.SerializeToString,
            messages__pb2.Empty.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def Kill(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,
            '/gauge.messages.Documenter/Kill',
            messages__pb2.KillProcessRequest.SerializeToString,
            messages__pb2.Empty.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)
