# 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 nexosim._proto import simulation_pb2 as nexosim_dot___proto_dot_simulation__pb2

GRPC_GENERATED_VERSION = '1.71.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 nexosim/_proto/simulation_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 SimulationStub(object):
    """---------
    Service
    ---------

    """

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

        Args:
            channel: A grpc.Channel.
        """
        self.Build = channel.unary_unary(
                '/simulation.v1.Simulation/Build',
                request_serializer=nexosim_dot___proto_dot_simulation__pb2.BuildRequest.SerializeToString,
                response_deserializer=nexosim_dot___proto_dot_simulation__pb2.BuildReply.FromString,
                _registered_method=True)
        self.Init = channel.unary_unary(
                '/simulation.v1.Simulation/Init',
                request_serializer=nexosim_dot___proto_dot_simulation__pb2.InitRequest.SerializeToString,
                response_deserializer=nexosim_dot___proto_dot_simulation__pb2.InitReply.FromString,
                _registered_method=True)
        self.InitAndRun = channel.unary_unary(
                '/simulation.v1.Simulation/InitAndRun',
                request_serializer=nexosim_dot___proto_dot_simulation__pb2.InitAndRunRequest.SerializeToString,
                response_deserializer=nexosim_dot___proto_dot_simulation__pb2.InitAndRunReply.FromString,
                _registered_method=True)
        self.Halt = channel.unary_unary(
                '/simulation.v1.Simulation/Halt',
                request_serializer=nexosim_dot___proto_dot_simulation__pb2.HaltRequest.SerializeToString,
                response_deserializer=nexosim_dot___proto_dot_simulation__pb2.HaltReply.FromString,
                _registered_method=True)
        self.Terminate = channel.unary_unary(
                '/simulation.v1.Simulation/Terminate',
                request_serializer=nexosim_dot___proto_dot_simulation__pb2.TerminateRequest.SerializeToString,
                response_deserializer=nexosim_dot___proto_dot_simulation__pb2.TerminateReply.FromString,
                _registered_method=True)
        self.Save = channel.unary_unary(
                '/simulation.v1.Simulation/Save',
                request_serializer=nexosim_dot___proto_dot_simulation__pb2.SaveRequest.SerializeToString,
                response_deserializer=nexosim_dot___proto_dot_simulation__pb2.SaveReply.FromString,
                _registered_method=True)
        self.Restore = channel.unary_unary(
                '/simulation.v1.Simulation/Restore',
                request_serializer=nexosim_dot___proto_dot_simulation__pb2.RestoreRequest.SerializeToString,
                response_deserializer=nexosim_dot___proto_dot_simulation__pb2.RestoreReply.FromString,
                _registered_method=True)
        self.RestoreAndRun = channel.unary_unary(
                '/simulation.v1.Simulation/RestoreAndRun',
                request_serializer=nexosim_dot___proto_dot_simulation__pb2.RestoreAndRunRequest.SerializeToString,
                response_deserializer=nexosim_dot___proto_dot_simulation__pb2.RestoreAndRunReply.FromString,
                _registered_method=True)
        self.Time = channel.unary_unary(
                '/simulation.v1.Simulation/Time',
                request_serializer=nexosim_dot___proto_dot_simulation__pb2.TimeRequest.SerializeToString,
                response_deserializer=nexosim_dot___proto_dot_simulation__pb2.TimeReply.FromString,
                _registered_method=True)
        self.Step = channel.unary_unary(
                '/simulation.v1.Simulation/Step',
                request_serializer=nexosim_dot___proto_dot_simulation__pb2.StepRequest.SerializeToString,
                response_deserializer=nexosim_dot___proto_dot_simulation__pb2.StepReply.FromString,
                _registered_method=True)
        self.StepUntil = channel.unary_unary(
                '/simulation.v1.Simulation/StepUntil',
                request_serializer=nexosim_dot___proto_dot_simulation__pb2.StepUntilRequest.SerializeToString,
                response_deserializer=nexosim_dot___proto_dot_simulation__pb2.StepUntilReply.FromString,
                _registered_method=True)
        self.Run = channel.unary_unary(
                '/simulation.v1.Simulation/Run',
                request_serializer=nexosim_dot___proto_dot_simulation__pb2.RunRequest.SerializeToString,
                response_deserializer=nexosim_dot___proto_dot_simulation__pb2.RunReply.FromString,
                _registered_method=True)
        self.ListEventSources = channel.unary_unary(
                '/simulation.v1.Simulation/ListEventSources',
                request_serializer=nexosim_dot___proto_dot_simulation__pb2.ListEventSourcesRequest.SerializeToString,
                response_deserializer=nexosim_dot___proto_dot_simulation__pb2.ListEventSourcesReply.FromString,
                _registered_method=True)
        self.GetEventSourceSchemas = channel.unary_unary(
                '/simulation.v1.Simulation/GetEventSourceSchemas',
                request_serializer=nexosim_dot___proto_dot_simulation__pb2.GetEventSourceSchemasRequest.SerializeToString,
                response_deserializer=nexosim_dot___proto_dot_simulation__pb2.GetEventSourceSchemasReply.FromString,
                _registered_method=True)
        self.ListQuerySources = channel.unary_unary(
                '/simulation.v1.Simulation/ListQuerySources',
                request_serializer=nexosim_dot___proto_dot_simulation__pb2.ListQuerySourcesRequest.SerializeToString,
                response_deserializer=nexosim_dot___proto_dot_simulation__pb2.ListQuerySourcesReply.FromString,
                _registered_method=True)
        self.GetQuerySourceSchemas = channel.unary_unary(
                '/simulation.v1.Simulation/GetQuerySourceSchemas',
                request_serializer=nexosim_dot___proto_dot_simulation__pb2.GetQuerySourceSchemasRequest.SerializeToString,
                response_deserializer=nexosim_dot___proto_dot_simulation__pb2.GetQuerySourceSchemasReply.FromString,
                _registered_method=True)
        self.ListEventSinks = channel.unary_unary(
                '/simulation.v1.Simulation/ListEventSinks',
                request_serializer=nexosim_dot___proto_dot_simulation__pb2.ListEventSinksRequest.SerializeToString,
                response_deserializer=nexosim_dot___proto_dot_simulation__pb2.ListEventSinksReply.FromString,
                _registered_method=True)
        self.GetEventSinkSchemas = channel.unary_unary(
                '/simulation.v1.Simulation/GetEventSinkSchemas',
                request_serializer=nexosim_dot___proto_dot_simulation__pb2.GetEventSinkSchemasRequest.SerializeToString,
                response_deserializer=nexosim_dot___proto_dot_simulation__pb2.GetEventSinkSchemasReply.FromString,
                _registered_method=True)
        self.InjectEvent = channel.unary_unary(
                '/simulation.v1.Simulation/InjectEvent',
                request_serializer=nexosim_dot___proto_dot_simulation__pb2.InjectEventRequest.SerializeToString,
                response_deserializer=nexosim_dot___proto_dot_simulation__pb2.InjectEventReply.FromString,
                _registered_method=True)
        self.ScheduleEvent = channel.unary_unary(
                '/simulation.v1.Simulation/ScheduleEvent',
                request_serializer=nexosim_dot___proto_dot_simulation__pb2.ScheduleEventRequest.SerializeToString,
                response_deserializer=nexosim_dot___proto_dot_simulation__pb2.ScheduleEventReply.FromString,
                _registered_method=True)
        self.CancelEvent = channel.unary_unary(
                '/simulation.v1.Simulation/CancelEvent',
                request_serializer=nexosim_dot___proto_dot_simulation__pb2.CancelEventRequest.SerializeToString,
                response_deserializer=nexosim_dot___proto_dot_simulation__pb2.CancelEventReply.FromString,
                _registered_method=True)
        self.ProcessEvent = channel.unary_unary(
                '/simulation.v1.Simulation/ProcessEvent',
                request_serializer=nexosim_dot___proto_dot_simulation__pb2.ProcessEventRequest.SerializeToString,
                response_deserializer=nexosim_dot___proto_dot_simulation__pb2.ProcessEventReply.FromString,
                _registered_method=True)
        self.ProcessQuery = channel.unary_unary(
                '/simulation.v1.Simulation/ProcessQuery',
                request_serializer=nexosim_dot___proto_dot_simulation__pb2.ProcessQueryRequest.SerializeToString,
                response_deserializer=nexosim_dot___proto_dot_simulation__pb2.ProcessQueryReply.FromString,
                _registered_method=True)
        self.TryReadEvents = channel.unary_unary(
                '/simulation.v1.Simulation/TryReadEvents',
                request_serializer=nexosim_dot___proto_dot_simulation__pb2.TryReadEventsRequest.SerializeToString,
                response_deserializer=nexosim_dot___proto_dot_simulation__pb2.TryReadEventsReply.FromString,
                _registered_method=True)
        self.ReadEvent = channel.unary_unary(
                '/simulation.v1.Simulation/ReadEvent',
                request_serializer=nexosim_dot___proto_dot_simulation__pb2.ReadEventRequest.SerializeToString,
                response_deserializer=nexosim_dot___proto_dot_simulation__pb2.ReadEventReply.FromString,
                _registered_method=True)
        self.EnableSink = channel.unary_unary(
                '/simulation.v1.Simulation/EnableSink',
                request_serializer=nexosim_dot___proto_dot_simulation__pb2.EnableSinkRequest.SerializeToString,
                response_deserializer=nexosim_dot___proto_dot_simulation__pb2.EnableSinkReply.FromString,
                _registered_method=True)
        self.DisableSink = channel.unary_unary(
                '/simulation.v1.Simulation/DisableSink',
                request_serializer=nexosim_dot___proto_dot_simulation__pb2.DisableSinkRequest.SerializeToString,
                response_deserializer=nexosim_dot___proto_dot_simulation__pb2.DisableSinkReply.FromString,
                _registered_method=True)


class SimulationServicer(object):
    """---------
    Service
    ---------

    """

    def Build(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 Init(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 InitAndRun(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 Halt(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 Terminate(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 Save(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 Restore(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 RestoreAndRun(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 Time(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 Step(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 StepUntil(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 Run(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 ListEventSources(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 GetEventSourceSchemas(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 ListQuerySources(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 GetQuerySourceSchemas(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 ListEventSinks(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 GetEventSinkSchemas(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 InjectEvent(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 ScheduleEvent(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 CancelEvent(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 ProcessEvent(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 ProcessQuery(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 TryReadEvents(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 ReadEvent(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 EnableSink(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 DisableSink(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_SimulationServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'Build': grpc.unary_unary_rpc_method_handler(
                    servicer.Build,
                    request_deserializer=nexosim_dot___proto_dot_simulation__pb2.BuildRequest.FromString,
                    response_serializer=nexosim_dot___proto_dot_simulation__pb2.BuildReply.SerializeToString,
            ),
            'Init': grpc.unary_unary_rpc_method_handler(
                    servicer.Init,
                    request_deserializer=nexosim_dot___proto_dot_simulation__pb2.InitRequest.FromString,
                    response_serializer=nexosim_dot___proto_dot_simulation__pb2.InitReply.SerializeToString,
            ),
            'InitAndRun': grpc.unary_unary_rpc_method_handler(
                    servicer.InitAndRun,
                    request_deserializer=nexosim_dot___proto_dot_simulation__pb2.InitAndRunRequest.FromString,
                    response_serializer=nexosim_dot___proto_dot_simulation__pb2.InitAndRunReply.SerializeToString,
            ),
            'Halt': grpc.unary_unary_rpc_method_handler(
                    servicer.Halt,
                    request_deserializer=nexosim_dot___proto_dot_simulation__pb2.HaltRequest.FromString,
                    response_serializer=nexosim_dot___proto_dot_simulation__pb2.HaltReply.SerializeToString,
            ),
            'Terminate': grpc.unary_unary_rpc_method_handler(
                    servicer.Terminate,
                    request_deserializer=nexosim_dot___proto_dot_simulation__pb2.TerminateRequest.FromString,
                    response_serializer=nexosim_dot___proto_dot_simulation__pb2.TerminateReply.SerializeToString,
            ),
            'Save': grpc.unary_unary_rpc_method_handler(
                    servicer.Save,
                    request_deserializer=nexosim_dot___proto_dot_simulation__pb2.SaveRequest.FromString,
                    response_serializer=nexosim_dot___proto_dot_simulation__pb2.SaveReply.SerializeToString,
            ),
            'Restore': grpc.unary_unary_rpc_method_handler(
                    servicer.Restore,
                    request_deserializer=nexosim_dot___proto_dot_simulation__pb2.RestoreRequest.FromString,
                    response_serializer=nexosim_dot___proto_dot_simulation__pb2.RestoreReply.SerializeToString,
            ),
            'RestoreAndRun': grpc.unary_unary_rpc_method_handler(
                    servicer.RestoreAndRun,
                    request_deserializer=nexosim_dot___proto_dot_simulation__pb2.RestoreAndRunRequest.FromString,
                    response_serializer=nexosim_dot___proto_dot_simulation__pb2.RestoreAndRunReply.SerializeToString,
            ),
            'Time': grpc.unary_unary_rpc_method_handler(
                    servicer.Time,
                    request_deserializer=nexosim_dot___proto_dot_simulation__pb2.TimeRequest.FromString,
                    response_serializer=nexosim_dot___proto_dot_simulation__pb2.TimeReply.SerializeToString,
            ),
            'Step': grpc.unary_unary_rpc_method_handler(
                    servicer.Step,
                    request_deserializer=nexosim_dot___proto_dot_simulation__pb2.StepRequest.FromString,
                    response_serializer=nexosim_dot___proto_dot_simulation__pb2.StepReply.SerializeToString,
            ),
            'StepUntil': grpc.unary_unary_rpc_method_handler(
                    servicer.StepUntil,
                    request_deserializer=nexosim_dot___proto_dot_simulation__pb2.StepUntilRequest.FromString,
                    response_serializer=nexosim_dot___proto_dot_simulation__pb2.StepUntilReply.SerializeToString,
            ),
            'Run': grpc.unary_unary_rpc_method_handler(
                    servicer.Run,
                    request_deserializer=nexosim_dot___proto_dot_simulation__pb2.RunRequest.FromString,
                    response_serializer=nexosim_dot___proto_dot_simulation__pb2.RunReply.SerializeToString,
            ),
            'ListEventSources': grpc.unary_unary_rpc_method_handler(
                    servicer.ListEventSources,
                    request_deserializer=nexosim_dot___proto_dot_simulation__pb2.ListEventSourcesRequest.FromString,
                    response_serializer=nexosim_dot___proto_dot_simulation__pb2.ListEventSourcesReply.SerializeToString,
            ),
            'GetEventSourceSchemas': grpc.unary_unary_rpc_method_handler(
                    servicer.GetEventSourceSchemas,
                    request_deserializer=nexosim_dot___proto_dot_simulation__pb2.GetEventSourceSchemasRequest.FromString,
                    response_serializer=nexosim_dot___proto_dot_simulation__pb2.GetEventSourceSchemasReply.SerializeToString,
            ),
            'ListQuerySources': grpc.unary_unary_rpc_method_handler(
                    servicer.ListQuerySources,
                    request_deserializer=nexosim_dot___proto_dot_simulation__pb2.ListQuerySourcesRequest.FromString,
                    response_serializer=nexosim_dot___proto_dot_simulation__pb2.ListQuerySourcesReply.SerializeToString,
            ),
            'GetQuerySourceSchemas': grpc.unary_unary_rpc_method_handler(
                    servicer.GetQuerySourceSchemas,
                    request_deserializer=nexosim_dot___proto_dot_simulation__pb2.GetQuerySourceSchemasRequest.FromString,
                    response_serializer=nexosim_dot___proto_dot_simulation__pb2.GetQuerySourceSchemasReply.SerializeToString,
            ),
            'ListEventSinks': grpc.unary_unary_rpc_method_handler(
                    servicer.ListEventSinks,
                    request_deserializer=nexosim_dot___proto_dot_simulation__pb2.ListEventSinksRequest.FromString,
                    response_serializer=nexosim_dot___proto_dot_simulation__pb2.ListEventSinksReply.SerializeToString,
            ),
            'GetEventSinkSchemas': grpc.unary_unary_rpc_method_handler(
                    servicer.GetEventSinkSchemas,
                    request_deserializer=nexosim_dot___proto_dot_simulation__pb2.GetEventSinkSchemasRequest.FromString,
                    response_serializer=nexosim_dot___proto_dot_simulation__pb2.GetEventSinkSchemasReply.SerializeToString,
            ),
            'InjectEvent': grpc.unary_unary_rpc_method_handler(
                    servicer.InjectEvent,
                    request_deserializer=nexosim_dot___proto_dot_simulation__pb2.InjectEventRequest.FromString,
                    response_serializer=nexosim_dot___proto_dot_simulation__pb2.InjectEventReply.SerializeToString,
            ),
            'ScheduleEvent': grpc.unary_unary_rpc_method_handler(
                    servicer.ScheduleEvent,
                    request_deserializer=nexosim_dot___proto_dot_simulation__pb2.ScheduleEventRequest.FromString,
                    response_serializer=nexosim_dot___proto_dot_simulation__pb2.ScheduleEventReply.SerializeToString,
            ),
            'CancelEvent': grpc.unary_unary_rpc_method_handler(
                    servicer.CancelEvent,
                    request_deserializer=nexosim_dot___proto_dot_simulation__pb2.CancelEventRequest.FromString,
                    response_serializer=nexosim_dot___proto_dot_simulation__pb2.CancelEventReply.SerializeToString,
            ),
            'ProcessEvent': grpc.unary_unary_rpc_method_handler(
                    servicer.ProcessEvent,
                    request_deserializer=nexosim_dot___proto_dot_simulation__pb2.ProcessEventRequest.FromString,
                    response_serializer=nexosim_dot___proto_dot_simulation__pb2.ProcessEventReply.SerializeToString,
            ),
            'ProcessQuery': grpc.unary_unary_rpc_method_handler(
                    servicer.ProcessQuery,
                    request_deserializer=nexosim_dot___proto_dot_simulation__pb2.ProcessQueryRequest.FromString,
                    response_serializer=nexosim_dot___proto_dot_simulation__pb2.ProcessQueryReply.SerializeToString,
            ),
            'TryReadEvents': grpc.unary_unary_rpc_method_handler(
                    servicer.TryReadEvents,
                    request_deserializer=nexosim_dot___proto_dot_simulation__pb2.TryReadEventsRequest.FromString,
                    response_serializer=nexosim_dot___proto_dot_simulation__pb2.TryReadEventsReply.SerializeToString,
            ),
            'ReadEvent': grpc.unary_unary_rpc_method_handler(
                    servicer.ReadEvent,
                    request_deserializer=nexosim_dot___proto_dot_simulation__pb2.ReadEventRequest.FromString,
                    response_serializer=nexosim_dot___proto_dot_simulation__pb2.ReadEventReply.SerializeToString,
            ),
            'EnableSink': grpc.unary_unary_rpc_method_handler(
                    servicer.EnableSink,
                    request_deserializer=nexosim_dot___proto_dot_simulation__pb2.EnableSinkRequest.FromString,
                    response_serializer=nexosim_dot___proto_dot_simulation__pb2.EnableSinkReply.SerializeToString,
            ),
            'DisableSink': grpc.unary_unary_rpc_method_handler(
                    servicer.DisableSink,
                    request_deserializer=nexosim_dot___proto_dot_simulation__pb2.DisableSinkRequest.FromString,
                    response_serializer=nexosim_dot___proto_dot_simulation__pb2.DisableSinkReply.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'simulation.v1.Simulation', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))
    server.add_registered_method_handlers('simulation.v1.Simulation', rpc_method_handlers)


 # This class is part of an EXPERIMENTAL API.
class Simulation(object):
    """---------
    Service
    ---------

    """

    @staticmethod
    def Build(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,
            '/simulation.v1.Simulation/Build',
            nexosim_dot___proto_dot_simulation__pb2.BuildRequest.SerializeToString,
            nexosim_dot___proto_dot_simulation__pb2.BuildReply.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def Init(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,
            '/simulation.v1.Simulation/Init',
            nexosim_dot___proto_dot_simulation__pb2.InitRequest.SerializeToString,
            nexosim_dot___proto_dot_simulation__pb2.InitReply.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def InitAndRun(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,
            '/simulation.v1.Simulation/InitAndRun',
            nexosim_dot___proto_dot_simulation__pb2.InitAndRunRequest.SerializeToString,
            nexosim_dot___proto_dot_simulation__pb2.InitAndRunReply.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def Halt(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,
            '/simulation.v1.Simulation/Halt',
            nexosim_dot___proto_dot_simulation__pb2.HaltRequest.SerializeToString,
            nexosim_dot___proto_dot_simulation__pb2.HaltReply.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def Terminate(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,
            '/simulation.v1.Simulation/Terminate',
            nexosim_dot___proto_dot_simulation__pb2.TerminateRequest.SerializeToString,
            nexosim_dot___proto_dot_simulation__pb2.TerminateReply.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def Save(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,
            '/simulation.v1.Simulation/Save',
            nexosim_dot___proto_dot_simulation__pb2.SaveRequest.SerializeToString,
            nexosim_dot___proto_dot_simulation__pb2.SaveReply.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def Restore(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,
            '/simulation.v1.Simulation/Restore',
            nexosim_dot___proto_dot_simulation__pb2.RestoreRequest.SerializeToString,
            nexosim_dot___proto_dot_simulation__pb2.RestoreReply.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def RestoreAndRun(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,
            '/simulation.v1.Simulation/RestoreAndRun',
            nexosim_dot___proto_dot_simulation__pb2.RestoreAndRunRequest.SerializeToString,
            nexosim_dot___proto_dot_simulation__pb2.RestoreAndRunReply.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def Time(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,
            '/simulation.v1.Simulation/Time',
            nexosim_dot___proto_dot_simulation__pb2.TimeRequest.SerializeToString,
            nexosim_dot___proto_dot_simulation__pb2.TimeReply.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def Step(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,
            '/simulation.v1.Simulation/Step',
            nexosim_dot___proto_dot_simulation__pb2.StepRequest.SerializeToString,
            nexosim_dot___proto_dot_simulation__pb2.StepReply.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def StepUntil(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,
            '/simulation.v1.Simulation/StepUntil',
            nexosim_dot___proto_dot_simulation__pb2.StepUntilRequest.SerializeToString,
            nexosim_dot___proto_dot_simulation__pb2.StepUntilReply.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def Run(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,
            '/simulation.v1.Simulation/Run',
            nexosim_dot___proto_dot_simulation__pb2.RunRequest.SerializeToString,
            nexosim_dot___proto_dot_simulation__pb2.RunReply.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def ListEventSources(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,
            '/simulation.v1.Simulation/ListEventSources',
            nexosim_dot___proto_dot_simulation__pb2.ListEventSourcesRequest.SerializeToString,
            nexosim_dot___proto_dot_simulation__pb2.ListEventSourcesReply.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetEventSourceSchemas(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,
            '/simulation.v1.Simulation/GetEventSourceSchemas',
            nexosim_dot___proto_dot_simulation__pb2.GetEventSourceSchemasRequest.SerializeToString,
            nexosim_dot___proto_dot_simulation__pb2.GetEventSourceSchemasReply.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def ListQuerySources(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,
            '/simulation.v1.Simulation/ListQuerySources',
            nexosim_dot___proto_dot_simulation__pb2.ListQuerySourcesRequest.SerializeToString,
            nexosim_dot___proto_dot_simulation__pb2.ListQuerySourcesReply.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetQuerySourceSchemas(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,
            '/simulation.v1.Simulation/GetQuerySourceSchemas',
            nexosim_dot___proto_dot_simulation__pb2.GetQuerySourceSchemasRequest.SerializeToString,
            nexosim_dot___proto_dot_simulation__pb2.GetQuerySourceSchemasReply.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def ListEventSinks(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,
            '/simulation.v1.Simulation/ListEventSinks',
            nexosim_dot___proto_dot_simulation__pb2.ListEventSinksRequest.SerializeToString,
            nexosim_dot___proto_dot_simulation__pb2.ListEventSinksReply.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetEventSinkSchemas(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,
            '/simulation.v1.Simulation/GetEventSinkSchemas',
            nexosim_dot___proto_dot_simulation__pb2.GetEventSinkSchemasRequest.SerializeToString,
            nexosim_dot___proto_dot_simulation__pb2.GetEventSinkSchemasReply.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def InjectEvent(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,
            '/simulation.v1.Simulation/InjectEvent',
            nexosim_dot___proto_dot_simulation__pb2.InjectEventRequest.SerializeToString,
            nexosim_dot___proto_dot_simulation__pb2.InjectEventReply.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def ScheduleEvent(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,
            '/simulation.v1.Simulation/ScheduleEvent',
            nexosim_dot___proto_dot_simulation__pb2.ScheduleEventRequest.SerializeToString,
            nexosim_dot___proto_dot_simulation__pb2.ScheduleEventReply.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def CancelEvent(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,
            '/simulation.v1.Simulation/CancelEvent',
            nexosim_dot___proto_dot_simulation__pb2.CancelEventRequest.SerializeToString,
            nexosim_dot___proto_dot_simulation__pb2.CancelEventReply.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def ProcessEvent(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,
            '/simulation.v1.Simulation/ProcessEvent',
            nexosim_dot___proto_dot_simulation__pb2.ProcessEventRequest.SerializeToString,
            nexosim_dot___proto_dot_simulation__pb2.ProcessEventReply.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def ProcessQuery(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,
            '/simulation.v1.Simulation/ProcessQuery',
            nexosim_dot___proto_dot_simulation__pb2.ProcessQueryRequest.SerializeToString,
            nexosim_dot___proto_dot_simulation__pb2.ProcessQueryReply.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def TryReadEvents(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,
            '/simulation.v1.Simulation/TryReadEvents',
            nexosim_dot___proto_dot_simulation__pb2.TryReadEventsRequest.SerializeToString,
            nexosim_dot___proto_dot_simulation__pb2.TryReadEventsReply.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def ReadEvent(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,
            '/simulation.v1.Simulation/ReadEvent',
            nexosim_dot___proto_dot_simulation__pb2.ReadEventRequest.SerializeToString,
            nexosim_dot___proto_dot_simulation__pb2.ReadEventReply.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def EnableSink(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,
            '/simulation.v1.Simulation/EnableSink',
            nexosim_dot___proto_dot_simulation__pb2.EnableSinkRequest.SerializeToString,
            nexosim_dot___proto_dot_simulation__pb2.EnableSinkReply.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def DisableSink(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,
            '/simulation.v1.Simulation/DisableSink',
            nexosim_dot___proto_dot_simulation__pb2.DisableSinkRequest.SerializeToString,
            nexosim_dot___proto_dot_simulation__pb2.DisableSinkReply.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)
