# 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 service_pb2 as service__pb2

GRPC_GENERATED_VERSION = '1.78.0'
GRPC_VERSION = grpc.__version__
_version_not_supported = False

try:
    from grpc._utilities import first_version_is_lower
    _version_not_supported = first_version_is_lower(GRPC_VERSION, GRPC_GENERATED_VERSION)
except ImportError:
    _version_not_supported = True

if _version_not_supported:
    raise RuntimeError(
        f'The grpc package installed is at version {GRPC_VERSION},'
        + ' but the generated code in service_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 ModelerServiceStub(object):
    """Missing associated documentation comment in .proto file."""

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

        Args:
            channel: A grpc.Channel.
        """
        self.getExperimentByName = channel.unary_unary(
                '/modeler.ModelerService/getExperimentByName',
                request_serializer=service__pb2.GetExperimentByName.SerializeToString,
                response_deserializer=service__pb2.GetExperimentByName.Response.FromString,
                _registered_method=True)
        self.createExperiment = channel.unary_unary(
                '/modeler.ModelerService/createExperiment',
                request_serializer=service__pb2.CreateExperiment.SerializeToString,
                response_deserializer=service__pb2.CreateExperiment.Response.FromString,
                _registered_method=True)
        self.listExperiments = channel.unary_unary(
                '/modeler.ModelerService/listExperiments',
                request_serializer=service__pb2.ListExperiments.SerializeToString,
                response_deserializer=service__pb2.ListExperiments.Response.FromString,
                _registered_method=True)
        self.getExperiment = channel.unary_unary(
                '/modeler.ModelerService/getExperiment',
                request_serializer=service__pb2.GetExperiment.SerializeToString,
                response_deserializer=service__pb2.GetExperiment.Response.FromString,
                _registered_method=True)
        self.deleteExperiment = channel.unary_unary(
                '/modeler.ModelerService/deleteExperiment',
                request_serializer=service__pb2.DeleteExperiment.SerializeToString,
                response_deserializer=service__pb2.DeleteExperiment.Response.FromString,
                _registered_method=True)
        self.restoreExperiment = channel.unary_unary(
                '/modeler.ModelerService/restoreExperiment',
                request_serializer=service__pb2.RestoreExperiment.SerializeToString,
                response_deserializer=service__pb2.RestoreExperiment.Response.FromString,
                _registered_method=True)
        self.updateExperiment = channel.unary_unary(
                '/modeler.ModelerService/updateExperiment',
                request_serializer=service__pb2.UpdateExperiment.SerializeToString,
                response_deserializer=service__pb2.UpdateExperiment.Response.FromString,
                _registered_method=True)
        self.createRun = channel.unary_unary(
                '/modeler.ModelerService/createRun',
                request_serializer=service__pb2.CreateRun.SerializeToString,
                response_deserializer=service__pb2.CreateRun.Response.FromString,
                _registered_method=True)
        self.updateRun = channel.unary_unary(
                '/modeler.ModelerService/updateRun',
                request_serializer=service__pb2.UpdateRun.SerializeToString,
                response_deserializer=service__pb2.UpdateRun.Response.FromString,
                _registered_method=True)
        self.deleteRun = channel.unary_unary(
                '/modeler.ModelerService/deleteRun',
                request_serializer=service__pb2.DeleteRun.SerializeToString,
                response_deserializer=service__pb2.DeleteRun.Response.FromString,
                _registered_method=True)
        self.restoreRun = channel.unary_unary(
                '/modeler.ModelerService/restoreRun',
                request_serializer=service__pb2.RestoreRun.SerializeToString,
                response_deserializer=service__pb2.RestoreRun.Response.FromString,
                _registered_method=True)
        self.logMetric = channel.unary_unary(
                '/modeler.ModelerService/logMetric',
                request_serializer=service__pb2.LogMetric.SerializeToString,
                response_deserializer=service__pb2.LogMetric.Response.FromString,
                _registered_method=True)
        self.logParam = channel.unary_unary(
                '/modeler.ModelerService/logParam',
                request_serializer=service__pb2.LogParam.SerializeToString,
                response_deserializer=service__pb2.LogParam.Response.FromString,
                _registered_method=True)
        self.setExperimentTag = channel.unary_unary(
                '/modeler.ModelerService/setExperimentTag',
                request_serializer=service__pb2.SetExperimentTag.SerializeToString,
                response_deserializer=service__pb2.SetExperimentTag.Response.FromString,
                _registered_method=True)
        self.setTag = channel.unary_unary(
                '/modeler.ModelerService/setTag',
                request_serializer=service__pb2.SetTag.SerializeToString,
                response_deserializer=service__pb2.SetTag.Response.FromString,
                _registered_method=True)
        self.deleteTag = channel.unary_unary(
                '/modeler.ModelerService/deleteTag',
                request_serializer=service__pb2.DeleteTag.SerializeToString,
                response_deserializer=service__pb2.DeleteTag.Response.FromString,
                _registered_method=True)
        self.getRun = channel.unary_unary(
                '/modeler.ModelerService/getRun',
                request_serializer=service__pb2.GetRun.SerializeToString,
                response_deserializer=service__pb2.GetRun.Response.FromString,
                _registered_method=True)
        self.searchRuns = channel.unary_unary(
                '/modeler.ModelerService/searchRuns',
                request_serializer=service__pb2.SearchRuns.SerializeToString,
                response_deserializer=service__pb2.SearchRuns.Response.FromString,
                _registered_method=True)
        self.listArtifacts = channel.unary_unary(
                '/modeler.ModelerService/listArtifacts',
                request_serializer=service__pb2.ListArtifacts.SerializeToString,
                response_deserializer=service__pb2.ListArtifacts.Response.FromString,
                _registered_method=True)
        self.getMetricHistory = channel.unary_unary(
                '/modeler.ModelerService/getMetricHistory',
                request_serializer=service__pb2.GetMetricHistory.SerializeToString,
                response_deserializer=service__pb2.GetMetricHistory.Response.FromString,
                _registered_method=True)
        self.logBatch = channel.unary_unary(
                '/modeler.ModelerService/logBatch',
                request_serializer=service__pb2.LogBatch.SerializeToString,
                response_deserializer=service__pb2.LogBatch.Response.FromString,
                _registered_method=True)
        self.logModel = channel.unary_unary(
                '/modeler.ModelerService/logModel',
                request_serializer=service__pb2.LogModel.SerializeToString,
                response_deserializer=service__pb2.LogModel.Response.FromString,
                _registered_method=True)


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

    def getExperimentByName(self, request, context):
        """Get metadata for an experiment.

        This endpoint will return deleted experiments, but prefers the active experiment
        if an active and deleted experiment share the same name. If multiple deleted
        experiments share the same name, the API will return one of them.

        Throws ``RESOURCE_DOES_NOT_EXIST`` if no experiment with the specified name exists.

        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def createExperiment(self, request, context):
        """Create an experiment with a name. Returns the ID of the newly created experiment.
        Validates that another experiment with the same name does not already exist and fails
        if another experiment with the same name already exists.


        Throws ``RESOURCE_ALREADY_EXISTS`` if a experiment with the given name exists.

        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def listExperiments(self, request, context):
        """Get a list of all experiments.

        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def getExperiment(self, request, context):
        """Get metadata for an experiment. This method works on deleted experiments.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def deleteExperiment(self, request, context):
        """Mark an experiment and associated metadata, runs, metrics, params, and tags for deletion.
        If the experiment uses FileStore, artifacts associated with experiment are also deleted.

        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def restoreExperiment(self, request, context):
        """Restore an experiment marked for deletion. This also restores
        associated metadata, runs, metrics, params, and tags. If experiment uses FileStore, underlying
        artifacts associated with experiment are also restored.

        Throws ``RESOURCE_DOES_NOT_EXIST`` if experiment was never created or was permanently deleted.

        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def updateExperiment(self, request, context):
        """Update experiment metadata.

        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def createRun(self, request, context):
        """Create a new run within an experiment. A run is usually a single execution of a
        machine learning or data ETL pipeline. MLflow uses runs to track :ref:`mlflowParam`,
        :ref:`mlflowMetric`, and :ref:`mlflowRunTag` associated with a single execution.

        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def updateRun(self, request, context):
        """Update run metadata.

        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def deleteRun(self, request, context):
        """Mark a run for deletion.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def restoreRun(self, request, context):
        """Restore a deleted run.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def logMetric(self, request, context):
        """Log a metric for a run. A metric is a key-value pair (string key, float value) with an
        associated timestamp. Examples include the various metrics that represent ML model accuracy.
        A metric can be logged multiple times.

        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def logParam(self, request, context):
        """Log a param used for a run. A param is a key-value pair (string key,
        string value). Examples include hyperparameters used for ML model training and
        constant dates and values used in an ETL pipeline. A param can be logged only once for a run.

        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def setExperimentTag(self, request, context):
        """Set a tag on an experiment. Experiment tags are metadata that can be updated.

        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def setTag(self, request, context):
        """Set a tag on a run. Tags are run metadata that can be updated during a run and after
        a run completes.

        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def deleteTag(self, request, context):
        """Delete a tag on a run. Tags are run metadata that can be updated during a run and after
        a run completes.

        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def getRun(self, request, context):
        """Get metadata, metrics, params, and tags for a run. In the case where multiple metrics
        with the same key are logged for a run, return only the value with the latest timestamp.
        If there are multiple values with the latest timestamp, return the maximum of these values.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def searchRuns(self, request, context):
        """Search for runs that satisfy expressions. Search expressions can use :ref:`mlflowMetric` and
        :ref:`mlflowParam` keys.

        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def listArtifacts(self, request, context):
        """List artifacts for a run. Takes an optional ``artifact_path`` prefix which if specified,
        the response contains only artifacts with the specified prefix.

        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def getMetricHistory(self, request, context):
        """Get a list of all values for the specified metric for a given run.

        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def logBatch(self, request, context):
        """Log a batch of metrics, params, and tags for a run.
        If any data failed to be persisted, the server will respond with an error (non-200 status code).
        In case of error (due to internal server error or an invalid request), partial data may
        be written.

        You can write metrics, params, and tags in interleaving fashion, but within a given entity
        type are guaranteed to follow the order specified in the request body. That is, for an API
        request like

        .. code-block:: json

        {
        "run_id": "2a14ed5c6a87499199e0106c3501eab8",
        "metrics": [
        {"key": "mae", "value": 2.5, "timestamp": 1552550804},
        {"key": "rmse", "value": 2.7, "timestamp": 1552550804},
        ],
        "params": [
        {"key": "model_class", "value": "LogisticRegression"},
        ]
        }

        the server is guaranteed to write metric "rmse" after "mae", though it may write param
        "model_class" before both metrics, after "mae", or after both metrics.

        The overwrite behavior for metrics, params, and tags is as follows:

        - Metrics: metric values are never overwritten. Logging a metric (key, value, timestamp) appends to the set of values for the metric with the provided key.

        - Tags: tag values can be overwritten by successive writes to the same tag key. That is, if multiple tag values with the same key are provided in the same API request, the last-provided tag value is written. Logging the same tag (key, value) is permitted - that is, logging a tag is idempotent.

        - Params: once written, param values cannot be changed (attempting to overwrite a param value will result in an error). However, logging the same param (key, value) is permitted - that is, logging a param is idempotent.

        Request Limits
        --------------
        A single JSON-serialized API request may be up to 1 MB in size and contain:

        - No more than 1000 metrics, params, and tags in total
        - Up to 1000 metrics
        - Up to 100 params
        - Up to 100 tags

        For example, a valid request might contain 900 metrics, 50 params, and 50 tags, but logging
        900 metrics, 50 params, and 51 tags is invalid. The following limits also apply
        to metric, param, and tag keys and values:

        - Metric, param, and tag keys can be up to 250 characters in length
        - Param and tag values can be up to 250 characters in length

        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def logModel(self, request, context):
        """.. note::
        Experimental: This API may change or be removed in a future release without warning.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')


def add_ModelerServiceServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'getExperimentByName': grpc.unary_unary_rpc_method_handler(
                    servicer.getExperimentByName,
                    request_deserializer=service__pb2.GetExperimentByName.FromString,
                    response_serializer=service__pb2.GetExperimentByName.Response.SerializeToString,
            ),
            'createExperiment': grpc.unary_unary_rpc_method_handler(
                    servicer.createExperiment,
                    request_deserializer=service__pb2.CreateExperiment.FromString,
                    response_serializer=service__pb2.CreateExperiment.Response.SerializeToString,
            ),
            'listExperiments': grpc.unary_unary_rpc_method_handler(
                    servicer.listExperiments,
                    request_deserializer=service__pb2.ListExperiments.FromString,
                    response_serializer=service__pb2.ListExperiments.Response.SerializeToString,
            ),
            'getExperiment': grpc.unary_unary_rpc_method_handler(
                    servicer.getExperiment,
                    request_deserializer=service__pb2.GetExperiment.FromString,
                    response_serializer=service__pb2.GetExperiment.Response.SerializeToString,
            ),
            'deleteExperiment': grpc.unary_unary_rpc_method_handler(
                    servicer.deleteExperiment,
                    request_deserializer=service__pb2.DeleteExperiment.FromString,
                    response_serializer=service__pb2.DeleteExperiment.Response.SerializeToString,
            ),
            'restoreExperiment': grpc.unary_unary_rpc_method_handler(
                    servicer.restoreExperiment,
                    request_deserializer=service__pb2.RestoreExperiment.FromString,
                    response_serializer=service__pb2.RestoreExperiment.Response.SerializeToString,
            ),
            'updateExperiment': grpc.unary_unary_rpc_method_handler(
                    servicer.updateExperiment,
                    request_deserializer=service__pb2.UpdateExperiment.FromString,
                    response_serializer=service__pb2.UpdateExperiment.Response.SerializeToString,
            ),
            'createRun': grpc.unary_unary_rpc_method_handler(
                    servicer.createRun,
                    request_deserializer=service__pb2.CreateRun.FromString,
                    response_serializer=service__pb2.CreateRun.Response.SerializeToString,
            ),
            'updateRun': grpc.unary_unary_rpc_method_handler(
                    servicer.updateRun,
                    request_deserializer=service__pb2.UpdateRun.FromString,
                    response_serializer=service__pb2.UpdateRun.Response.SerializeToString,
            ),
            'deleteRun': grpc.unary_unary_rpc_method_handler(
                    servicer.deleteRun,
                    request_deserializer=service__pb2.DeleteRun.FromString,
                    response_serializer=service__pb2.DeleteRun.Response.SerializeToString,
            ),
            'restoreRun': grpc.unary_unary_rpc_method_handler(
                    servicer.restoreRun,
                    request_deserializer=service__pb2.RestoreRun.FromString,
                    response_serializer=service__pb2.RestoreRun.Response.SerializeToString,
            ),
            'logMetric': grpc.unary_unary_rpc_method_handler(
                    servicer.logMetric,
                    request_deserializer=service__pb2.LogMetric.FromString,
                    response_serializer=service__pb2.LogMetric.Response.SerializeToString,
            ),
            'logParam': grpc.unary_unary_rpc_method_handler(
                    servicer.logParam,
                    request_deserializer=service__pb2.LogParam.FromString,
                    response_serializer=service__pb2.LogParam.Response.SerializeToString,
            ),
            'setExperimentTag': grpc.unary_unary_rpc_method_handler(
                    servicer.setExperimentTag,
                    request_deserializer=service__pb2.SetExperimentTag.FromString,
                    response_serializer=service__pb2.SetExperimentTag.Response.SerializeToString,
            ),
            'setTag': grpc.unary_unary_rpc_method_handler(
                    servicer.setTag,
                    request_deserializer=service__pb2.SetTag.FromString,
                    response_serializer=service__pb2.SetTag.Response.SerializeToString,
            ),
            'deleteTag': grpc.unary_unary_rpc_method_handler(
                    servicer.deleteTag,
                    request_deserializer=service__pb2.DeleteTag.FromString,
                    response_serializer=service__pb2.DeleteTag.Response.SerializeToString,
            ),
            'getRun': grpc.unary_unary_rpc_method_handler(
                    servicer.getRun,
                    request_deserializer=service__pb2.GetRun.FromString,
                    response_serializer=service__pb2.GetRun.Response.SerializeToString,
            ),
            'searchRuns': grpc.unary_unary_rpc_method_handler(
                    servicer.searchRuns,
                    request_deserializer=service__pb2.SearchRuns.FromString,
                    response_serializer=service__pb2.SearchRuns.Response.SerializeToString,
            ),
            'listArtifacts': grpc.unary_unary_rpc_method_handler(
                    servicer.listArtifacts,
                    request_deserializer=service__pb2.ListArtifacts.FromString,
                    response_serializer=service__pb2.ListArtifacts.Response.SerializeToString,
            ),
            'getMetricHistory': grpc.unary_unary_rpc_method_handler(
                    servicer.getMetricHistory,
                    request_deserializer=service__pb2.GetMetricHistory.FromString,
                    response_serializer=service__pb2.GetMetricHistory.Response.SerializeToString,
            ),
            'logBatch': grpc.unary_unary_rpc_method_handler(
                    servicer.logBatch,
                    request_deserializer=service__pb2.LogBatch.FromString,
                    response_serializer=service__pb2.LogBatch.Response.SerializeToString,
            ),
            'logModel': grpc.unary_unary_rpc_method_handler(
                    servicer.logModel,
                    request_deserializer=service__pb2.LogModel.FromString,
                    response_serializer=service__pb2.LogModel.Response.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'modeler.ModelerService', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))
    server.add_registered_method_handlers('modeler.ModelerService', rpc_method_handlers)


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

    @staticmethod
    def getExperimentByName(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,
            '/modeler.ModelerService/getExperimentByName',
            service__pb2.GetExperimentByName.SerializeToString,
            service__pb2.GetExperimentByName.Response.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def createExperiment(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,
            '/modeler.ModelerService/createExperiment',
            service__pb2.CreateExperiment.SerializeToString,
            service__pb2.CreateExperiment.Response.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def listExperiments(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,
            '/modeler.ModelerService/listExperiments',
            service__pb2.ListExperiments.SerializeToString,
            service__pb2.ListExperiments.Response.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def getExperiment(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,
            '/modeler.ModelerService/getExperiment',
            service__pb2.GetExperiment.SerializeToString,
            service__pb2.GetExperiment.Response.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def deleteExperiment(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,
            '/modeler.ModelerService/deleteExperiment',
            service__pb2.DeleteExperiment.SerializeToString,
            service__pb2.DeleteExperiment.Response.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def restoreExperiment(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,
            '/modeler.ModelerService/restoreExperiment',
            service__pb2.RestoreExperiment.SerializeToString,
            service__pb2.RestoreExperiment.Response.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def updateExperiment(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,
            '/modeler.ModelerService/updateExperiment',
            service__pb2.UpdateExperiment.SerializeToString,
            service__pb2.UpdateExperiment.Response.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def createRun(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,
            '/modeler.ModelerService/createRun',
            service__pb2.CreateRun.SerializeToString,
            service__pb2.CreateRun.Response.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def updateRun(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,
            '/modeler.ModelerService/updateRun',
            service__pb2.UpdateRun.SerializeToString,
            service__pb2.UpdateRun.Response.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def deleteRun(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,
            '/modeler.ModelerService/deleteRun',
            service__pb2.DeleteRun.SerializeToString,
            service__pb2.DeleteRun.Response.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def restoreRun(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,
            '/modeler.ModelerService/restoreRun',
            service__pb2.RestoreRun.SerializeToString,
            service__pb2.RestoreRun.Response.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def logMetric(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,
            '/modeler.ModelerService/logMetric',
            service__pb2.LogMetric.SerializeToString,
            service__pb2.LogMetric.Response.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def logParam(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,
            '/modeler.ModelerService/logParam',
            service__pb2.LogParam.SerializeToString,
            service__pb2.LogParam.Response.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def setExperimentTag(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,
            '/modeler.ModelerService/setExperimentTag',
            service__pb2.SetExperimentTag.SerializeToString,
            service__pb2.SetExperimentTag.Response.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def setTag(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,
            '/modeler.ModelerService/setTag',
            service__pb2.SetTag.SerializeToString,
            service__pb2.SetTag.Response.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def deleteTag(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,
            '/modeler.ModelerService/deleteTag',
            service__pb2.DeleteTag.SerializeToString,
            service__pb2.DeleteTag.Response.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def getRun(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,
            '/modeler.ModelerService/getRun',
            service__pb2.GetRun.SerializeToString,
            service__pb2.GetRun.Response.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def searchRuns(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,
            '/modeler.ModelerService/searchRuns',
            service__pb2.SearchRuns.SerializeToString,
            service__pb2.SearchRuns.Response.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def listArtifacts(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,
            '/modeler.ModelerService/listArtifacts',
            service__pb2.ListArtifacts.SerializeToString,
            service__pb2.ListArtifacts.Response.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def getMetricHistory(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,
            '/modeler.ModelerService/getMetricHistory',
            service__pb2.GetMetricHistory.SerializeToString,
            service__pb2.GetMetricHistory.Response.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def logBatch(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,
            '/modeler.ModelerService/logBatch',
            service__pb2.LogBatch.SerializeToString,
            service__pb2.LogBatch.Response.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def logModel(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,
            '/modeler.ModelerService/logModel',
            service__pb2.LogModel.SerializeToString,
            service__pb2.LogModel.Response.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)
