annotation_pb2_grpc.py

# 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 . import annotation_pb2 as annotation__pb2

GRPC_GENERATED_VERSION = '1.84.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 annotation_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 DpAnnotationServiceStub:
    """
    ------------------- RPC Interfaces ---------------------------



    Annotation Service Interface

    Interface for annotating archived data.
    """

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

        Args:
            channel: A grpc.Channel.
        """
        self.saveDataSet = channel.unary_unary(
                '/dp.service.annotation.DpAnnotationService/saveDataSet',
                request_serializer=annotation__pb2.SaveDataSetRequest.SerializeToString,
                response_deserializer=annotation__pb2.SaveDataSetResponse.FromString,
                _registered_method=True)
        self.getDataSet = channel.unary_unary(
                '/dp.service.annotation.DpAnnotationService/getDataSet',
                request_serializer=annotation__pb2.GetDataSetRequest.SerializeToString,
                response_deserializer=annotation__pb2.GetDataSetResponse.FromString,
                _registered_method=True)
        self.queryDataSets = channel.unary_unary(
                '/dp.service.annotation.DpAnnotationService/queryDataSets',
                request_serializer=annotation__pb2.QueryDataSetsRequest.SerializeToString,
                response_deserializer=annotation__pb2.QueryDataSetsResponse.FromString,
                _registered_method=True)
        self.deleteDataSet = channel.unary_unary(
                '/dp.service.annotation.DpAnnotationService/deleteDataSet',
                request_serializer=annotation__pb2.DeleteDataSetRequest.SerializeToString,
                response_deserializer=annotation__pb2.DeleteDataSetResponse.FromString,
                _registered_method=True)
        self.patchDataSet = channel.unary_unary(
                '/dp.service.annotation.DpAnnotationService/patchDataSet',
                request_serializer=annotation__pb2.PatchDataSetRequest.SerializeToString,
                response_deserializer=annotation__pb2.PatchDataSetResponse.FromString,
                _registered_method=True)
        self.saveAnnotation = channel.unary_unary(
                '/dp.service.annotation.DpAnnotationService/saveAnnotation',
                request_serializer=annotation__pb2.SaveAnnotationRequest.SerializeToString,
                response_deserializer=annotation__pb2.SaveAnnotationResponse.FromString,
                _registered_method=True)
        self.getAnnotation = channel.unary_unary(
                '/dp.service.annotation.DpAnnotationService/getAnnotation',
                request_serializer=annotation__pb2.GetAnnotationRequest.SerializeToString,
                response_deserializer=annotation__pb2.GetAnnotationResponse.FromString,
                _registered_method=True)
        self.queryAnnotations = channel.unary_unary(
                '/dp.service.annotation.DpAnnotationService/queryAnnotations',
                request_serializer=annotation__pb2.QueryAnnotationsRequest.SerializeToString,
                response_deserializer=annotation__pb2.QueryAnnotationsResponse.FromString,
                _registered_method=True)
        self.deleteAnnotation = channel.unary_unary(
                '/dp.service.annotation.DpAnnotationService/deleteAnnotation',
                request_serializer=annotation__pb2.DeleteAnnotationRequest.SerializeToString,
                response_deserializer=annotation__pb2.DeleteAnnotationResponse.FromString,
                _registered_method=True)
        self.patchAnnotation = channel.unary_unary(
                '/dp.service.annotation.DpAnnotationService/patchAnnotation',
                request_serializer=annotation__pb2.PatchAnnotationRequest.SerializeToString,
                response_deserializer=annotation__pb2.PatchAnnotationResponse.FromString,
                _registered_method=True)
        self.getCalculations = channel.unary_unary(
                '/dp.service.annotation.DpAnnotationService/getCalculations',
                request_serializer=annotation__pb2.GetCalculationsRequest.SerializeToString,
                response_deserializer=annotation__pb2.GetCalculationsResponse.FromString,
                _registered_method=True)
        self.exportData = channel.unary_unary(
                '/dp.service.annotation.DpAnnotationService/exportData',
                request_serializer=annotation__pb2.ExportDataRequest.SerializeToString,
                response_deserializer=annotation__pb2.ExportDataResponse.FromString,
                _registered_method=True)
        self.savePvMetadata = channel.unary_unary(
                '/dp.service.annotation.DpAnnotationService/savePvMetadata',
                request_serializer=annotation__pb2.SavePvMetadataRequest.SerializeToString,
                response_deserializer=annotation__pb2.SavePvMetadataResponse.FromString,
                _registered_method=True)
        self.queryPvMetadata = channel.unary_unary(
                '/dp.service.annotation.DpAnnotationService/queryPvMetadata',
                request_serializer=annotation__pb2.QueryPvMetadataRequest.SerializeToString,
                response_deserializer=annotation__pb2.QueryPvMetadataResponse.FromString,
                _registered_method=True)
        self.getPvMetadata = channel.unary_unary(
                '/dp.service.annotation.DpAnnotationService/getPvMetadata',
                request_serializer=annotation__pb2.GetPvMetadataRequest.SerializeToString,
                response_deserializer=annotation__pb2.GetPvMetadataResponse.FromString,
                _registered_method=True)
        self.patchPvMetadata = channel.unary_unary(
                '/dp.service.annotation.DpAnnotationService/patchPvMetadata',
                request_serializer=annotation__pb2.PatchPvMetadataRequest.SerializeToString,
                response_deserializer=annotation__pb2.PatchPvMetadataResponse.FromString,
                _registered_method=True)
        self.deletePvMetadata = channel.unary_unary(
                '/dp.service.annotation.DpAnnotationService/deletePvMetadata',
                request_serializer=annotation__pb2.DeletePvMetadataRequest.SerializeToString,
                response_deserializer=annotation__pb2.DeletePvMetadataResponse.FromString,
                _registered_method=True)
        self.bulkSavePvMetadata = channel.unary_unary(
                '/dp.service.annotation.DpAnnotationService/bulkSavePvMetadata',
                request_serializer=annotation__pb2.BulkSavePvMetadataRequest.SerializeToString,
                response_deserializer=annotation__pb2.BulkSavePvMetadataResponse.FromString,
                _registered_method=True)
        self.saveConfiguration = channel.unary_unary(
                '/dp.service.annotation.DpAnnotationService/saveConfiguration',
                request_serializer=annotation__pb2.SaveConfigurationRequest.SerializeToString,
                response_deserializer=annotation__pb2.SaveConfigurationResponse.FromString,
                _registered_method=True)
        self.getConfiguration = channel.unary_unary(
                '/dp.service.annotation.DpAnnotationService/getConfiguration',
                request_serializer=annotation__pb2.GetConfigurationRequest.SerializeToString,
                response_deserializer=annotation__pb2.GetConfigurationResponse.FromString,
                _registered_method=True)
        self.queryConfigurations = channel.unary_unary(
                '/dp.service.annotation.DpAnnotationService/queryConfigurations',
                request_serializer=annotation__pb2.QueryConfigurationsRequest.SerializeToString,
                response_deserializer=annotation__pb2.QueryConfigurationsResponse.FromString,
                _registered_method=True)
        self.deleteConfiguration = channel.unary_unary(
                '/dp.service.annotation.DpAnnotationService/deleteConfiguration',
                request_serializer=annotation__pb2.DeleteConfigurationRequest.SerializeToString,
                response_deserializer=annotation__pb2.DeleteConfigurationResponse.FromString,
                _registered_method=True)
        self.patchConfiguration = channel.unary_unary(
                '/dp.service.annotation.DpAnnotationService/patchConfiguration',
                request_serializer=annotation__pb2.PatchConfigurationRequest.SerializeToString,
                response_deserializer=annotation__pb2.PatchConfigurationResponse.FromString,
                _registered_method=True)
        self.bulkSaveConfiguration = channel.unary_unary(
                '/dp.service.annotation.DpAnnotationService/bulkSaveConfiguration',
                request_serializer=annotation__pb2.BulkSaveConfigurationRequest.SerializeToString,
                response_deserializer=annotation__pb2.BulkSaveConfigurationResponse.FromString,
                _registered_method=True)
        self.saveConfigurationActivation = channel.unary_unary(
                '/dp.service.annotation.DpAnnotationService/saveConfigurationActivation',
                request_serializer=annotation__pb2.SaveConfigurationActivationRequest.SerializeToString,
                response_deserializer=annotation__pb2.SaveConfigurationActivationResponse.FromString,
                _registered_method=True)
        self.getConfigurationActivation = channel.unary_unary(
                '/dp.service.annotation.DpAnnotationService/getConfigurationActivation',
                request_serializer=annotation__pb2.GetConfigurationActivationRequest.SerializeToString,
                response_deserializer=annotation__pb2.GetConfigurationActivationResponse.FromString,
                _registered_method=True)
        self.queryConfigurationActivations = channel.unary_unary(
                '/dp.service.annotation.DpAnnotationService/queryConfigurationActivations',
                request_serializer=annotation__pb2.QueryConfigurationActivationsRequest.SerializeToString,
                response_deserializer=annotation__pb2.QueryConfigurationActivationsResponse.FromString,
                _registered_method=True)
        self.deleteConfigurationActivation = channel.unary_unary(
                '/dp.service.annotation.DpAnnotationService/deleteConfigurationActivation',
                request_serializer=annotation__pb2.DeleteConfigurationActivationRequest.SerializeToString,
                response_deserializer=annotation__pb2.DeleteConfigurationActivationResponse.FromString,
                _registered_method=True)
        self.patchConfigurationActivation = channel.unary_unary(
                '/dp.service.annotation.DpAnnotationService/patchConfigurationActivation',
                request_serializer=annotation__pb2.PatchConfigurationActivationRequest.SerializeToString,
                response_deserializer=annotation__pb2.PatchConfigurationActivationResponse.FromString,
                _registered_method=True)
        self.bulkSaveConfigurationActivation = channel.unary_unary(
                '/dp.service.annotation.DpAnnotationService/bulkSaveConfigurationActivation',
                request_serializer=annotation__pb2.BulkSaveConfigurationActivationRequest.SerializeToString,
                response_deserializer=annotation__pb2.BulkSaveConfigurationActivationResponse.FromString,
                _registered_method=True)
        self.getActiveConfigurations = channel.unary_unary(
                '/dp.service.annotation.DpAnnotationService/getActiveConfigurations',
                request_serializer=annotation__pb2.GetActiveConfigurationsRequest.SerializeToString,
                response_deserializer=annotation__pb2.GetActiveConfigurationsResponse.FromString,
                _registered_method=True)
        self.saveSampleStatuses = channel.unary_unary(
                '/dp.service.annotation.DpAnnotationService/saveSampleStatuses',
                request_serializer=annotation__pb2.SaveSampleStatusesRequest.SerializeToString,
                response_deserializer=annotation__pb2.SaveSampleStatusesResponse.FromString,
                _registered_method=True)
        self.querySampleStatuses = channel.unary_unary(
                '/dp.service.annotation.DpAnnotationService/querySampleStatuses',
                request_serializer=annotation__pb2.QuerySampleStatusesRequest.SerializeToString,
                response_deserializer=annotation__pb2.QuerySampleStatusesResponse.FromString,
                _registered_method=True)
        self.querySampleStatusesStream = channel.unary_stream(
                '/dp.service.annotation.DpAnnotationService/querySampleStatusesStream',
                request_serializer=annotation__pb2.QuerySampleStatusesRequest.SerializeToString,
                response_deserializer=annotation__pb2.QuerySampleStatusesResponse.FromString,
                _registered_method=True)
        self.deleteSampleStatuses = channel.unary_unary(
                '/dp.service.annotation.DpAnnotationService/deleteSampleStatuses',
                request_serializer=annotation__pb2.DeleteSampleStatusesRequest.SerializeToString,
                response_deserializer=annotation__pb2.DeleteSampleStatusesResponse.FromString,
                _registered_method=True)
        self.saveSampleStatusDomain = channel.unary_unary(
                '/dp.service.annotation.DpAnnotationService/saveSampleStatusDomain',
                request_serializer=annotation__pb2.SaveSampleStatusDomainRequest.SerializeToString,
                response_deserializer=annotation__pb2.SaveSampleStatusDomainResponse.FromString,
                _registered_method=True)
        self.querySampleStatusDomains = channel.unary_unary(
                '/dp.service.annotation.DpAnnotationService/querySampleStatusDomains',
                request_serializer=annotation__pb2.QuerySampleStatusDomainsRequest.SerializeToString,
                response_deserializer=annotation__pb2.QuerySampleStatusDomainsResponse.FromString,
                _registered_method=True)


class DpAnnotationServiceServicer:
    """
    ------------------- RPC Interfaces ---------------------------



    Annotation Service Interface

    Interface for annotating archived data.
    """

    def saveDataSet(self, request, context):
        """
        ------------------- DataSet CRUD ---------------------------



        saveDataSet()

        Create or replace a DataSet.

        Full replace (upsert) semantics: if the request omits id a new DataSet is created and
        the server generates its id; if id is supplied, ALL fields of the existing DataSet
        (name, ownerId, description, dataBlocks, tags, attributes, modifiedBy) are replaced
        with the request contents.  Callers must supply the complete desired state on every
        call — fields omitted from the request are not preserved.  Use patchDataSet() (future)
        for partial updates.

        The response may indicate rejection, an error handling the request, or a
        SaveDataSetResult with the id of the created or updated DataSet.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def getDataSet(self, request, context):
        """
        getDataSet()

        Retrieve a single DataSet by id.

        This is the content-retrieval path for the dataSetIds returned by queryAnnotations():
        annotation query results carry dataset ids only, not embedded dataset content.  To
        retrieve many datasets at once, prefer queryDataSets() with an IdCriterion listing the
        ids — it is a single round trip, whereas a getDataSet() per id is not.

        The response may indicate rejection, an error handling the request, or a
        GetDataSetResult containing the matching record.  If no DataSet exists with the
        specified id, an ExceptionalResult is returned.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def queryDataSets(self, request, context):
        """
        queryDataSets(): Unary (non-streaming) DataSets query.

        Query DataSet records using structured search criteria.  Client sends a single
        QueryDataSetsRequest and receives a single QueryDataSetsResponse.

        Pagination: limit sets the maximum number of records in a page; an unset or zero limit
        means a server-configured default page size, NOT an unbounded result.  Clients must
        follow nextPageToken to retrieve all matching records.  pageToken is an opaque
        continuation token obtained from a previous response; a malformed token is rejected
        with an ExceptionalResult.

        Ordering: results are ordered by id ascending.  The id is unique, which makes paging
        stable, and is approximately insertion order.  Ordering is part of this method's
        contract — paging is only well defined under a deterministic sort.

        The response may indicate rejection, an error in handling, or otherwise contains the
        DataSets matching the query criteria.  A query matching no data returns an empty
        result, not an ExceptionalResult.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def deleteDataSet(self, request, context):
        """
        deleteDataSet()

        Delete the DataSet with the specified id.

        The request is rejected if any Annotation references the DataSet in its dataSetIds — a
        containment-strength association.  Delete or update those annotations first.  Use
        queryAnnotations() with a DataSetsCriterion to find them.

        The response may indicate rejection, an error handling the request, or a
        DeleteDataSetResult confirming the id of the deleted record.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def patchDataSet(self, request, context):
        """
        patchDataSet()

        Partial update of an existing DataSet.  Allows individual fields (name, description,
        dataBlocks, tags, attributes, modifiedBy) to be updated without replacing the entire
        record, unlike the full-replace semantics of saveDataSet().

        NOT YET IMPLEMENTED — calling this method returns an error response.
        Planned for a future release.  Field mask design is deferred.

        This method is defined now to reserve its name and message shapes as part
        of the standard CRUD pattern for metadata APIs in this service.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def saveAnnotation(self, request, context):
        """
        ------------------- Annotation CRUD ---------------------------



        saveAnnotation()

        Create or replace an Annotation.

        Full replace (upsert) semantics: if the request omits id a new Annotation is created
        and the server generates its id; if id is supplied, ALL fields of the existing
        Annotation (ownerId, dataSetIds, name, annotationIds, description, tags, attributes,
        calculations, modifiedBy) are replaced with the request contents.  Callers must supply
        the complete desired state on every call — fields omitted from the request are not
        preserved.  Use patchAnnotation() (future) for partial updates.

        WARNING: full replace applies to calculations as it does to every other field.  An
        update that omits calculations CLEARS the annotation's existing calculations.

        Calculations are created and replaced through this method — there is no
        saveCalculations().  The response returns calculationsId alongside annotationId when
        the request carried calculations, so the addressing key used by getCalculations(),
        CalculationsSpec, and ColumnProvenance is available without a further round trip.

        The response may indicate rejection, an error handling the request, or a
        SaveAnnotationResult with the id of the created or updated Annotation.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def getAnnotation(self, request, context):
        """
        getAnnotation()

        Retrieve a single Annotation by id, with its Calculations content populated inline as a
        one-hop convenience for the common "open this annotation" case.  This is the only
        method that returns calculations content within an Annotation; queryAnnotations()
        returns calculationsId only.

        Associated DataSets are returned as ids (dataSetIds), not content; use getDataSet() or
        queryDataSets() with an IdCriterion to retrieve them.

        The response may indicate rejection, an error handling the request, or a
        GetAnnotationResult containing the matching record.  If no Annotation exists with the
        specified id, an ExceptionalResult is returned.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def queryAnnotations(self, request, context):
        """
        queryAnnotations(): Unary (non-streaming) Annotations query.

        Query Annotation records using structured search criteria.  Client sends a single
        QueryAnnotationsRequest and receives a single QueryAnnotationsResponse.

        Results carry references, not embedded content: each returned Annotation has
        dataSetIds and calculationsId, and neither dataset content nor calculations content is
        included.  Retrieve dataset content with a single queryDataSets() call whose
        IdCriterion lists the ids gathered across the returned annotations, and calculations
        content with getCalculations() or getAnnotation().

        Pagination: limit sets the maximum number of records in a page; an unset or zero limit
        means a server-configured default page size, NOT an unbounded result.  Clients must
        follow nextPageToken to retrieve all matching records.  pageToken is an opaque
        continuation token obtained from a previous response; a malformed token is rejected
        with an ExceptionalResult.

        Ordering: results are ordered by id ascending.  The id is unique, which makes paging
        stable, and is approximately insertion order.  Ordering is part of this method's
        contract — paging is only well defined under a deterministic sort.

        The response may indicate rejection, an error in handling, or otherwise contains the
        Annotations matching the query criteria.  A query matching no data returns an empty
        result, not an ExceptionalResult.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def deleteAnnotation(self, request, context):
        """
        deleteAnnotation()

        Delete the Annotation with the specified id.  The Annotation's Calculations, if any,
        are deleted with it — their lifecycle belongs to the owning Annotation.

        Unlike deleteDataSet(), this delete is NOT blocked by incoming references.  Other
        Annotations listing this annotation's id in annotationIds, and
        ColumnProvenance.derivedFrom links naming its calculations, are soft associations and
        are permitted to dangle.  A soft link that resolves to nothing means the referenced
        record was deleted, and readers must tolerate it.

        The response may indicate rejection, an error handling the request, or a
        DeleteAnnotationResult confirming the id of the deleted record.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def patchAnnotation(self, request, context):
        """
        patchAnnotation()

        Partial update of an existing Annotation.  Allows individual fields (dataSetIds, name,
        annotationIds, description, tags, attributes, calculations, modifiedBy) to be updated
        without replacing the entire record, unlike the full-replace semantics of
        saveAnnotation().

        NOT YET IMPLEMENTED — calling this method returns an error response.
        Planned for a future release.  Field mask design is deferred.

        This method is defined now to reserve its name and message shapes as part
        of the standard CRUD pattern for metadata APIs in this service.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def getCalculations(self, request, context):
        """
        ------------------- Calculations Retrieval ---------------------------



        getCalculations()

        Retrieve a single Calculations object by id, without loading the owning Annotation's
        descriptive payload.  This is the click-through path: list annotations, pick one, then
        fetch exactly its calculations using the calculationsId the listing returned.

        Obtain calculationsId from SaveAnnotationResult, from Annotation.calculationsId in
        query or get results, or from a ColumnProvenance.CalculationsColumn provenance link.

        Calculations have no save, delete, or query method of their own, and the asymmetry is
        deliberate: they are written and replaced through saveAnnotation(), their lifecycle
        belongs to the owning Annotation (deleteAnnotation() removes them), and discovery goes
        through queryAnnotations().  Only retrieval needs a standalone path, because a client
        that already holds a calculationsId should not have to fetch an annotation to use it.

        The response may indicate rejection, an error handling the request, or a
        GetCalculationsResult containing the matching record.  If no Calculations object
        exists with the specified id, an ExceptionalResult is returned.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def exportData(self, request, context):
        """
        ------------------- Export ---------------------------



        exportData(): Export data to common file formats.

        This RPC is used by clients to export archived PV data and/or Annotation Calculations
        to file.  Client sends a single ExportDataRequest specifying the data to be exported
        and the desired output file format, and receives a single response.  The response may
        indicate a problem handling the request, or otherwise contains details about the
        exported file including the path and optional (if configured) URL for accessing the
        file.

        Data to export is specified by any combination of a saved DataSet (dataSetId), inline
        ad-hoc DataBlocks (dataBlocks), and Calculations (calculationsSpec).  At least one must
        be supplied; a request specifying none is rejected.  See ExportDataRequest.

        Output format restriction: the tabular formats (CSV, XLSX) can only represent scalar
        columns.  A DataSet or Calculations object containing array, image, or struct columns
        can be exported to HDF5, but a request to export it as CSV or XLSX is rejected.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def savePvMetadata(self, request, context):
        """
        savePvMetadata()

        Create or replace the metadata record for the specified PV.

        Full replace (upsert) semantics: if a record does not exist it is created;
        if a record already exists, ALL fields (aliases, tags, attributes,
        description, modifiedBy) are replaced with the request contents.
        Callers must supply the complete desired state on every call — fields
        omitted from the request are not preserved.  Use patchPvMetadata()
        (future) for partial updates.

        The response may indicate rejection, an error handling the request, or
        successful handling of the request.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def queryPvMetadata(self, request, context):
        """
        queryPvMetadata()

        Query PV metadata records using structured search criteria.

        Pagination: limit sets the maximum number of records in a page; an unset or zero limit
        means a server-configured default page size, NOT an unbounded result.  Clients must
        follow nextPageToken to retrieve all matching records.  pageToken is an opaque
        continuation token obtained from a previous response; a malformed token is rejected
        with an ExceptionalResult.

        Ordering: results are ordered by pvName ascending.  pvName is unique, which makes
        paging stable.  Ordering is part of this method's contract — paging is only well
        defined under a deterministic sort.

        The response may indicate rejection, an error handling the request, or
        a PvMetadataResult containing the matching records and pagination token.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def getPvMetadata(self, request, context):
        """
        getPvMetadata()

        Retrieve a single PV metadata record by canonical PV name or alias.
        Provided as a convenience over queryPvMetadata() for the common
        single-record lookup case.

        The response may indicate rejection, an error handling the request, or
        a GetPvMetadataResponse containing the matching record.  If no record
        is found for the specified name or alias, an ExceptionalResult is returned.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def patchPvMetadata(self, request, context):
        """
        patchPvMetadata()

        Partial update of an existing PV metadata record.  Allows individual
        fields (aliases, tags, attributes, description, modifiedBy) to be updated
        without replacing the entire record, unlike the full-replace semantics
        of savePvMetadata().

        NOT YET IMPLEMENTED — calling this method returns an error response.
        Planned for a future release.  Field mask design is deferred.

        This method is defined now to reserve its name and message shapes as part
        of the standard CRUD pattern for metadata APIs in this service.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def deletePvMetadata(self, request, context):
        """
        deletePvMetadata()

        Delete the metadata record for the specified canonical PV name or alias.

        The response may indicate rejection, an error handling the request, or
        a DeletePvMetadataResult confirming the name of the deleted record.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def bulkSavePvMetadata(self, request, context):
        """
        bulkSavePvMetadata()

        Bulk create or replace multiple PV metadata records in a single request.
        Each record uses the same full-replace upsert semantics as savePvMetadata().
        Intended for large initial imports or bulk synchronization use cases.

        NOT YET IMPLEMENTED — calling this method returns an error response.
        Planned for a future release.

        This method is defined now to reserve its name and message shapes as part
        of the standard bulk-write pattern for metadata APIs in this service.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def saveConfiguration(self, request, context):
        """
        ------------------- Configuration Definition CRUD ---------------------------



        saveConfiguration()

        Create or replace the metadata record for the specified machine configuration.

        Full replace (upsert) semantics: if a record does not exist it is created;
        if a record already exists, ALL fields (category, description,
        parentConfigurationName, tags, attributes, modifiedBy) are replaced with
        the request contents.  Callers must supply the complete desired state on
        every call — fields omitted from the request are not preserved.
        Use patchConfiguration() (future) for partial updates.

        The response may indicate rejection, an error handling the request, or
        successful handling of the request.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def getConfiguration(self, request, context):
        """
        getConfiguration()

        Retrieve a single Configuration record by configurationName.
        Provided as a convenience over queryConfigurations() for the common
        single-record lookup case.

        The response may indicate rejection, an error handling the request, or
        a GetConfigurationResult containing the matching record.  If no record
        is found, an ExceptionalResult is returned.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def queryConfigurations(self, request, context):
        """
        queryConfigurations()

        Query Configuration records using structured search criteria.

        Pagination: limit sets the maximum number of records in a page; an unset or zero limit
        means a server-configured default page size, NOT an unbounded result.  Clients must
        follow nextPageToken to retrieve all matching records.  pageToken is an opaque
        continuation token obtained from a previous response; a malformed token is rejected
        with an ExceptionalResult.

        Ordering: results are ordered by configurationName ascending.  configurationName is
        unique, which makes paging stable.  Ordering is part of this method's contract —
        paging is only well defined under a deterministic sort.

        The response may indicate rejection, an error handling the request, or
        a QueryConfigurationsResult containing the matching records and pagination token.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def deleteConfiguration(self, request, context):
        """
        deleteConfiguration()

        Delete the Configuration record for the specified configurationName.
        The request is rejected if ConfigurationActivation records exist for the
        configuration; delete associated activations first.

        The response may indicate rejection, an error handling the request, or
        a DeleteConfigurationResult confirming the name of the deleted record.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def patchConfiguration(self, request, context):
        """
        patchConfiguration()

        Partial update of an existing Configuration record.  Allows individual
        fields to be updated without replacing the entire record, unlike the
        full-replace semantics of saveConfiguration().

        NOT YET IMPLEMENTED — calling this method returns an error response.
        Planned for a future release.

        This method is defined now to reserve its name and message shapes as part
        of the standard CRUD pattern for metadata APIs in this service.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def bulkSaveConfiguration(self, request, context):
        """
        bulkSaveConfiguration()

        Bulk create or replace multiple Configuration records in a single request.
        Each record uses the same full-replace upsert semantics as saveConfiguration().
        Intended for large initial imports or bulk synchronization use cases.

        NOT YET IMPLEMENTED — calling this method returns an error response.
        Planned for a future release.

        This method is defined now to reserve its name and message shapes as part
        of the standard bulk-write pattern for metadata APIs in this service.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def saveConfigurationActivation(self, request, context):
        """
        ------------------- Configuration Activation CRUD ---------------------------



        saveConfigurationActivation()

        Create or replace an activation record indicating the time interval during
        which a Configuration was active.

        Full replace (upsert) semantics: if a record does not exist it is created;
        if a record already exists (matched by clientActivationId, or by composite
        key configurationName + startTime if clientActivationId is absent), ALL
        fields are replaced with the request contents.  Callers must supply the
        complete desired state on every call — fields omitted from the request are
        not preserved.  Use patchConfigurationActivation() (future) for partial updates.

        To close an open-ended activation, call saveConfigurationActivation() with
        endTime set to the desired close time.

        The response may indicate rejection, an error handling the request, or
        successful handling of the request.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def getConfigurationActivation(self, request, context):
        """
        getConfigurationActivation()

        Retrieve a single ConfigurationActivation record by clientActivationId or
        composite key (configurationName + startTime).

        The response may indicate rejection, an error handling the request, or
        a GetConfigurationActivationResult containing the matching record.  If no
        record is found, an ExceptionalResult is returned.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def queryConfigurationActivations(self, request, context):
        """
        queryConfigurationActivations()

        Query ConfigurationActivation records using structured search criteria.

        Pagination: limit sets the maximum number of records in a page; an unset or zero limit
        means a server-configured default page size, NOT an unbounded result.  Clients must
        follow nextPageToken to retrieve all matching records.  pageToken is an opaque
        continuation token obtained from a previous response; a malformed token is rejected
        with an ExceptionalResult.

        Ordering: results are ordered by startTime ascending, then configurationName
        ascending, then record id ascending.  startTime alone is not unique, and the
        tiebreakers are what make paging stable across records sharing a start time.
        Ordering is part of this method's contract — paging is only well defined under a
        deterministic sort.

        The response may indicate rejection, an error handling the request, or
        a QueryConfigurationActivationsResult containing the matching records and
        pagination token.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def deleteConfigurationActivation(self, request, context):
        """
        deleteConfigurationActivation()

        Delete a ConfigurationActivation record by clientActivationId or composite
        key (configurationName + startTime).

        The response may indicate rejection, an error handling the request, or
        a DeleteConfigurationActivationResult confirming the ID of the deleted record.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def patchConfigurationActivation(self, request, context):
        """
        patchConfigurationActivation()

        Partial update of an existing ConfigurationActivation record.  Allows
        individual fields to be updated without replacing the entire record, unlike
        the full-replace semantics of saveConfigurationActivation().

        NOT YET IMPLEMENTED — calling this method returns an error response.
        Planned for a future release.

        This method is defined now to reserve its name and message shapes as part
        of the standard CRUD pattern for metadata APIs in this service.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def bulkSaveConfigurationActivation(self, request, context):
        """
        bulkSaveConfigurationActivation()

        Bulk create or replace multiple ConfigurationActivation records in a single
        request.  Each record uses the same full-replace upsert semantics as
        saveConfigurationActivation().  Intended for bulk loading of activation
        records from operational calendars.

        NOT YET IMPLEMENTED — calling this method returns an error response.
        Planned for a future release.

        This method is defined now to reserve its name and message shapes as part
        of the standard bulk-write pattern for metadata APIs in this service.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def getActiveConfigurations(self, request, context):
        """
        ------------------- Active Configuration Query ---------------------------



        getActiveConfigurations()

        Returns all ConfigurationActivation records in effect at the specified
        timestamp, i.e., records where:
        startTime <= timestamp AND (endTime is absent OR endTime > timestamp)

        timestamp is required.  Requests with an absent (zero-value) timestamp
        are rejected with an ExceptionalResult.

        An empty result (no active configurations at the specified time) is
        returned as a GetActiveConfigurationsResult with an empty list, not
        an ExceptionalResult.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def saveSampleStatuses(self, request, context):
        """
        ------------------- Sample Status ---------------------------



        saveSampleStatuses()

        Batch upsert of sample statuses, assigning status codes to individual PV samples at
        specific timestamps.  The request contains one or more SampleStatusFrames, each carrying a
        (domain, layer), a DataTimestamps time axis, and one SampleStatusColumn per PV.

        Upsert semantics are per individual sample status, keyed by (pvName, timestamp, domain,
        layer): an entry REPLACES any existing status with the same key IN FULL — including the
        optional confidence and reasons — and creates a new status otherwise.  Statuses at other
        timestamps are unaffected — to cleanly re-label a time range (e.g., after re-running an ML
        model whose output timestamps changed), first call deleteSampleStatuses() for the range,
        then save.

        Frames are processed in request order.  If the same identity key appears in more than one
        frame of a request, the later frame's status wins (consistent with upsert across requests:
        last writer wins), and savedCount counts each write.

        The request is validated and rejected as a whole (no partial save on rejection).  If an
        error is encountered while writing a valid request, an ExceptionalResult with
        RESULT_STATUS_ERROR is returned and some frames may have been persisted.

        The response may indicate rejection, an error handling the request, or successful
        handling of the request.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def querySampleStatuses(self, request, context):
        """
        querySampleStatuses(): Unary sample status query.

        Query sample statuses over a time range, optionally filtered by PV name, domain, and
        layer (an empty pvNames list matches all PVs — e.g., to enumerate which PVs a layer has
        labeled).  Returns one page of SampleStatusBucket objects; additional pages are retrieved
        by resubmitting the request with the nextPageToken from the previous response as
        pageToken.  A malformed pageToken is rejected with an ExceptionalResult.

        Ordering: results are ordered by pvName ascending, then domain, then layer, then
        bucket start time.  Ordering is part of this method's contract — paging is only well
        defined under a deterministic sort.

        Bucket selection follows the TimeRange overlap test, and boundary buckets are returned
        WHOLE (not trimmed) — matching DpQueryService.queryBuckets() — so a returned bucket may
        contain individual statuses outside [beginTime, endTime).

        A query matching no data returns an empty result, not an ExceptionalResult.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def querySampleStatusesStream(self, request, context):
        """
        querySampleStatusesStream(): Server-streaming sample status query.

        Streams QuerySampleStatusesResponse messages until the result is exhausted, the client
        cancels, or an error occurs.  Paging semantics match DpQueryService.queryBucketsStream():
        limit controls the chunk size of each streamed response; streaming is fire-and-consume —
        the server streams to completion and does not emit continuation tokens (nextPageToken is
        empty on every streamed message); pageToken must be empty (a non-empty token is rejected
        with an ExceptionalResult).  Use unary querySampleStatuses() when resumable paging is
        required.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def deleteSampleStatuses(self, request, context):
        """
        deleteSampleStatuses()

        Delete sample statuses within the half-open time range [beginTime, endTime), for a single
        required (domain, layer).  pvNames restricts the delete to the listed PVs; an empty
        pvNames list is a deliberate wildcard deleting the (domain, layer)'s statuses for ALL PVs
        in the range.  Intended for cleanly re-labeling a range (delete then save) and for
        retiring an obsolete producer's statuses (wide time range + empty pvNames).

        Unlike query — which returns boundary buckets whole — deletion is EXACT at the sample
        axis: only statuses whose timestamps fall within the range are removed; the server splits
        or rewrites boundary storage buckets as needed.

        domain and layer are required, scoping each delete to a single producer stream.

        A delete matching no statuses is a successful result with deletedCount = 0, not an
        ExceptionalResult.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def saveSampleStatusDomain(self, request, context):
        """
        saveSampleStatusDomain()

        Create or replace a sample status domain registry record, documenting the status code
        mappings (code -> label / description) for a domain so that consumers can interpret status
        codes without out-of-band knowledge.

        NOT YET IMPLEMENTED — calling this method returns an error response.
        Planned for a future release.

        This method is defined now to reserve its name and message shapes as part
        of the standard CRUD pattern for metadata APIs in this service.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def querySampleStatusDomains(self, request, context):
        """
        querySampleStatusDomains()

        Query sample status domain registry records.

        NOT YET IMPLEMENTED — calling this method returns an error response.
        Planned for a future release.

        This method is defined now to reserve its name and message shapes as part
        of the standard CRUD pattern for metadata APIs in this service.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')


def add_DpAnnotationServiceServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'saveDataSet': grpc.unary_unary_rpc_method_handler(
                    servicer.saveDataSet,
                    request_deserializer=annotation__pb2.SaveDataSetRequest.FromString,
                    response_serializer=annotation__pb2.SaveDataSetResponse.SerializeToString,
            ),
            'getDataSet': grpc.unary_unary_rpc_method_handler(
                    servicer.getDataSet,
                    request_deserializer=annotation__pb2.GetDataSetRequest.FromString,
                    response_serializer=annotation__pb2.GetDataSetResponse.SerializeToString,
            ),
            'queryDataSets': grpc.unary_unary_rpc_method_handler(
                    servicer.queryDataSets,
                    request_deserializer=annotation__pb2.QueryDataSetsRequest.FromString,
                    response_serializer=annotation__pb2.QueryDataSetsResponse.SerializeToString,
            ),
            'deleteDataSet': grpc.unary_unary_rpc_method_handler(
                    servicer.deleteDataSet,
                    request_deserializer=annotation__pb2.DeleteDataSetRequest.FromString,
                    response_serializer=annotation__pb2.DeleteDataSetResponse.SerializeToString,
            ),
            'patchDataSet': grpc.unary_unary_rpc_method_handler(
                    servicer.patchDataSet,
                    request_deserializer=annotation__pb2.PatchDataSetRequest.FromString,
                    response_serializer=annotation__pb2.PatchDataSetResponse.SerializeToString,
            ),
            'saveAnnotation': grpc.unary_unary_rpc_method_handler(
                    servicer.saveAnnotation,
                    request_deserializer=annotation__pb2.SaveAnnotationRequest.FromString,
                    response_serializer=annotation__pb2.SaveAnnotationResponse.SerializeToString,
            ),
            'getAnnotation': grpc.unary_unary_rpc_method_handler(
                    servicer.getAnnotation,
                    request_deserializer=annotation__pb2.GetAnnotationRequest.FromString,
                    response_serializer=annotation__pb2.GetAnnotationResponse.SerializeToString,
            ),
            'queryAnnotations': grpc.unary_unary_rpc_method_handler(
                    servicer.queryAnnotations,
                    request_deserializer=annotation__pb2.QueryAnnotationsRequest.FromString,
                    response_serializer=annotation__pb2.QueryAnnotationsResponse.SerializeToString,
            ),
            'deleteAnnotation': grpc.unary_unary_rpc_method_handler(
                    servicer.deleteAnnotation,
                    request_deserializer=annotation__pb2.DeleteAnnotationRequest.FromString,
                    response_serializer=annotation__pb2.DeleteAnnotationResponse.SerializeToString,
            ),
            'patchAnnotation': grpc.unary_unary_rpc_method_handler(
                    servicer.patchAnnotation,
                    request_deserializer=annotation__pb2.PatchAnnotationRequest.FromString,
                    response_serializer=annotation__pb2.PatchAnnotationResponse.SerializeToString,
            ),
            'getCalculations': grpc.unary_unary_rpc_method_handler(
                    servicer.getCalculations,
                    request_deserializer=annotation__pb2.GetCalculationsRequest.FromString,
                    response_serializer=annotation__pb2.GetCalculationsResponse.SerializeToString,
            ),
            'exportData': grpc.unary_unary_rpc_method_handler(
                    servicer.exportData,
                    request_deserializer=annotation__pb2.ExportDataRequest.FromString,
                    response_serializer=annotation__pb2.ExportDataResponse.SerializeToString,
            ),
            'savePvMetadata': grpc.unary_unary_rpc_method_handler(
                    servicer.savePvMetadata,
                    request_deserializer=annotation__pb2.SavePvMetadataRequest.FromString,
                    response_serializer=annotation__pb2.SavePvMetadataResponse.SerializeToString,
            ),
            'queryPvMetadata': grpc.unary_unary_rpc_method_handler(
                    servicer.queryPvMetadata,
                    request_deserializer=annotation__pb2.QueryPvMetadataRequest.FromString,
                    response_serializer=annotation__pb2.QueryPvMetadataResponse.SerializeToString,
            ),
            'getPvMetadata': grpc.unary_unary_rpc_method_handler(
                    servicer.getPvMetadata,
                    request_deserializer=annotation__pb2.GetPvMetadataRequest.FromString,
                    response_serializer=annotation__pb2.GetPvMetadataResponse.SerializeToString,
            ),
            'patchPvMetadata': grpc.unary_unary_rpc_method_handler(
                    servicer.patchPvMetadata,
                    request_deserializer=annotation__pb2.PatchPvMetadataRequest.FromString,
                    response_serializer=annotation__pb2.PatchPvMetadataResponse.SerializeToString,
            ),
            'deletePvMetadata': grpc.unary_unary_rpc_method_handler(
                    servicer.deletePvMetadata,
                    request_deserializer=annotation__pb2.DeletePvMetadataRequest.FromString,
                    response_serializer=annotation__pb2.DeletePvMetadataResponse.SerializeToString,
            ),
            'bulkSavePvMetadata': grpc.unary_unary_rpc_method_handler(
                    servicer.bulkSavePvMetadata,
                    request_deserializer=annotation__pb2.BulkSavePvMetadataRequest.FromString,
                    response_serializer=annotation__pb2.BulkSavePvMetadataResponse.SerializeToString,
            ),
            'saveConfiguration': grpc.unary_unary_rpc_method_handler(
                    servicer.saveConfiguration,
                    request_deserializer=annotation__pb2.SaveConfigurationRequest.FromString,
                    response_serializer=annotation__pb2.SaveConfigurationResponse.SerializeToString,
            ),
            'getConfiguration': grpc.unary_unary_rpc_method_handler(
                    servicer.getConfiguration,
                    request_deserializer=annotation__pb2.GetConfigurationRequest.FromString,
                    response_serializer=annotation__pb2.GetConfigurationResponse.SerializeToString,
            ),
            'queryConfigurations': grpc.unary_unary_rpc_method_handler(
                    servicer.queryConfigurations,
                    request_deserializer=annotation__pb2.QueryConfigurationsRequest.FromString,
                    response_serializer=annotation__pb2.QueryConfigurationsResponse.SerializeToString,
            ),
            'deleteConfiguration': grpc.unary_unary_rpc_method_handler(
                    servicer.deleteConfiguration,
                    request_deserializer=annotation__pb2.DeleteConfigurationRequest.FromString,
                    response_serializer=annotation__pb2.DeleteConfigurationResponse.SerializeToString,
            ),
            'patchConfiguration': grpc.unary_unary_rpc_method_handler(
                    servicer.patchConfiguration,
                    request_deserializer=annotation__pb2.PatchConfigurationRequest.FromString,
                    response_serializer=annotation__pb2.PatchConfigurationResponse.SerializeToString,
            ),
            'bulkSaveConfiguration': grpc.unary_unary_rpc_method_handler(
                    servicer.bulkSaveConfiguration,
                    request_deserializer=annotation__pb2.BulkSaveConfigurationRequest.FromString,
                    response_serializer=annotation__pb2.BulkSaveConfigurationResponse.SerializeToString,
            ),
            'saveConfigurationActivation': grpc.unary_unary_rpc_method_handler(
                    servicer.saveConfigurationActivation,
                    request_deserializer=annotation__pb2.SaveConfigurationActivationRequest.FromString,
                    response_serializer=annotation__pb2.SaveConfigurationActivationResponse.SerializeToString,
            ),
            'getConfigurationActivation': grpc.unary_unary_rpc_method_handler(
                    servicer.getConfigurationActivation,
                    request_deserializer=annotation__pb2.GetConfigurationActivationRequest.FromString,
                    response_serializer=annotation__pb2.GetConfigurationActivationResponse.SerializeToString,
            ),
            'queryConfigurationActivations': grpc.unary_unary_rpc_method_handler(
                    servicer.queryConfigurationActivations,
                    request_deserializer=annotation__pb2.QueryConfigurationActivationsRequest.FromString,
                    response_serializer=annotation__pb2.QueryConfigurationActivationsResponse.SerializeToString,
            ),
            'deleteConfigurationActivation': grpc.unary_unary_rpc_method_handler(
                    servicer.deleteConfigurationActivation,
                    request_deserializer=annotation__pb2.DeleteConfigurationActivationRequest.FromString,
                    response_serializer=annotation__pb2.DeleteConfigurationActivationResponse.SerializeToString,
            ),
            'patchConfigurationActivation': grpc.unary_unary_rpc_method_handler(
                    servicer.patchConfigurationActivation,
                    request_deserializer=annotation__pb2.PatchConfigurationActivationRequest.FromString,
                    response_serializer=annotation__pb2.PatchConfigurationActivationResponse.SerializeToString,
            ),
            'bulkSaveConfigurationActivation': grpc.unary_unary_rpc_method_handler(
                    servicer.bulkSaveConfigurationActivation,
                    request_deserializer=annotation__pb2.BulkSaveConfigurationActivationRequest.FromString,
                    response_serializer=annotation__pb2.BulkSaveConfigurationActivationResponse.SerializeToString,
            ),
            'getActiveConfigurations': grpc.unary_unary_rpc_method_handler(
                    servicer.getActiveConfigurations,
                    request_deserializer=annotation__pb2.GetActiveConfigurationsRequest.FromString,
                    response_serializer=annotation__pb2.GetActiveConfigurationsResponse.SerializeToString,
            ),
            'saveSampleStatuses': grpc.unary_unary_rpc_method_handler(
                    servicer.saveSampleStatuses,
                    request_deserializer=annotation__pb2.SaveSampleStatusesRequest.FromString,
                    response_serializer=annotation__pb2.SaveSampleStatusesResponse.SerializeToString,
            ),
            'querySampleStatuses': grpc.unary_unary_rpc_method_handler(
                    servicer.querySampleStatuses,
                    request_deserializer=annotation__pb2.QuerySampleStatusesRequest.FromString,
                    response_serializer=annotation__pb2.QuerySampleStatusesResponse.SerializeToString,
            ),
            'querySampleStatusesStream': grpc.unary_stream_rpc_method_handler(
                    servicer.querySampleStatusesStream,
                    request_deserializer=annotation__pb2.QuerySampleStatusesRequest.FromString,
                    response_serializer=annotation__pb2.QuerySampleStatusesResponse.SerializeToString,
            ),
            'deleteSampleStatuses': grpc.unary_unary_rpc_method_handler(
                    servicer.deleteSampleStatuses,
                    request_deserializer=annotation__pb2.DeleteSampleStatusesRequest.FromString,
                    response_serializer=annotation__pb2.DeleteSampleStatusesResponse.SerializeToString,
            ),
            'saveSampleStatusDomain': grpc.unary_unary_rpc_method_handler(
                    servicer.saveSampleStatusDomain,
                    request_deserializer=annotation__pb2.SaveSampleStatusDomainRequest.FromString,
                    response_serializer=annotation__pb2.SaveSampleStatusDomainResponse.SerializeToString,
            ),
            'querySampleStatusDomains': grpc.unary_unary_rpc_method_handler(
                    servicer.querySampleStatusDomains,
                    request_deserializer=annotation__pb2.QuerySampleStatusDomainsRequest.FromString,
                    response_serializer=annotation__pb2.QuerySampleStatusDomainsResponse.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'dp.service.annotation.DpAnnotationService', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))
    server.add_registered_method_handlers('dp.service.annotation.DpAnnotationService', rpc_method_handlers)


 # This class is part of an EXPERIMENTAL API.
class DpAnnotationService:
    """
    ------------------- RPC Interfaces ---------------------------



    Annotation Service Interface

    Interface for annotating archived data.
    """

    @staticmethod
    def saveDataSet(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,
            '/dp.service.annotation.DpAnnotationService/saveDataSet',
            annotation__pb2.SaveDataSetRequest.SerializeToString,
            annotation__pb2.SaveDataSetResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def getDataSet(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,
            '/dp.service.annotation.DpAnnotationService/getDataSet',
            annotation__pb2.GetDataSetRequest.SerializeToString,
            annotation__pb2.GetDataSetResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def queryDataSets(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,
            '/dp.service.annotation.DpAnnotationService/queryDataSets',
            annotation__pb2.QueryDataSetsRequest.SerializeToString,
            annotation__pb2.QueryDataSetsResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def deleteDataSet(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,
            '/dp.service.annotation.DpAnnotationService/deleteDataSet',
            annotation__pb2.DeleteDataSetRequest.SerializeToString,
            annotation__pb2.DeleteDataSetResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def patchDataSet(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,
            '/dp.service.annotation.DpAnnotationService/patchDataSet',
            annotation__pb2.PatchDataSetRequest.SerializeToString,
            annotation__pb2.PatchDataSetResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def saveAnnotation(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,
            '/dp.service.annotation.DpAnnotationService/saveAnnotation',
            annotation__pb2.SaveAnnotationRequest.SerializeToString,
            annotation__pb2.SaveAnnotationResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def getAnnotation(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,
            '/dp.service.annotation.DpAnnotationService/getAnnotation',
            annotation__pb2.GetAnnotationRequest.SerializeToString,
            annotation__pb2.GetAnnotationResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def queryAnnotations(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,
            '/dp.service.annotation.DpAnnotationService/queryAnnotations',
            annotation__pb2.QueryAnnotationsRequest.SerializeToString,
            annotation__pb2.QueryAnnotationsResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def deleteAnnotation(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,
            '/dp.service.annotation.DpAnnotationService/deleteAnnotation',
            annotation__pb2.DeleteAnnotationRequest.SerializeToString,
            annotation__pb2.DeleteAnnotationResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def patchAnnotation(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,
            '/dp.service.annotation.DpAnnotationService/patchAnnotation',
            annotation__pb2.PatchAnnotationRequest.SerializeToString,
            annotation__pb2.PatchAnnotationResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def getCalculations(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,
            '/dp.service.annotation.DpAnnotationService/getCalculations',
            annotation__pb2.GetCalculationsRequest.SerializeToString,
            annotation__pb2.GetCalculationsResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def exportData(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,
            '/dp.service.annotation.DpAnnotationService/exportData',
            annotation__pb2.ExportDataRequest.SerializeToString,
            annotation__pb2.ExportDataResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def savePvMetadata(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,
            '/dp.service.annotation.DpAnnotationService/savePvMetadata',
            annotation__pb2.SavePvMetadataRequest.SerializeToString,
            annotation__pb2.SavePvMetadataResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def queryPvMetadata(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,
            '/dp.service.annotation.DpAnnotationService/queryPvMetadata',
            annotation__pb2.QueryPvMetadataRequest.SerializeToString,
            annotation__pb2.QueryPvMetadataResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def getPvMetadata(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,
            '/dp.service.annotation.DpAnnotationService/getPvMetadata',
            annotation__pb2.GetPvMetadataRequest.SerializeToString,
            annotation__pb2.GetPvMetadataResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def patchPvMetadata(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,
            '/dp.service.annotation.DpAnnotationService/patchPvMetadata',
            annotation__pb2.PatchPvMetadataRequest.SerializeToString,
            annotation__pb2.PatchPvMetadataResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def deletePvMetadata(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,
            '/dp.service.annotation.DpAnnotationService/deletePvMetadata',
            annotation__pb2.DeletePvMetadataRequest.SerializeToString,
            annotation__pb2.DeletePvMetadataResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def bulkSavePvMetadata(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,
            '/dp.service.annotation.DpAnnotationService/bulkSavePvMetadata',
            annotation__pb2.BulkSavePvMetadataRequest.SerializeToString,
            annotation__pb2.BulkSavePvMetadataResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def saveConfiguration(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,
            '/dp.service.annotation.DpAnnotationService/saveConfiguration',
            annotation__pb2.SaveConfigurationRequest.SerializeToString,
            annotation__pb2.SaveConfigurationResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def getConfiguration(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,
            '/dp.service.annotation.DpAnnotationService/getConfiguration',
            annotation__pb2.GetConfigurationRequest.SerializeToString,
            annotation__pb2.GetConfigurationResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def queryConfigurations(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,
            '/dp.service.annotation.DpAnnotationService/queryConfigurations',
            annotation__pb2.QueryConfigurationsRequest.SerializeToString,
            annotation__pb2.QueryConfigurationsResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def deleteConfiguration(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,
            '/dp.service.annotation.DpAnnotationService/deleteConfiguration',
            annotation__pb2.DeleteConfigurationRequest.SerializeToString,
            annotation__pb2.DeleteConfigurationResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def patchConfiguration(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,
            '/dp.service.annotation.DpAnnotationService/patchConfiguration',
            annotation__pb2.PatchConfigurationRequest.SerializeToString,
            annotation__pb2.PatchConfigurationResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def bulkSaveConfiguration(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,
            '/dp.service.annotation.DpAnnotationService/bulkSaveConfiguration',
            annotation__pb2.BulkSaveConfigurationRequest.SerializeToString,
            annotation__pb2.BulkSaveConfigurationResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def saveConfigurationActivation(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,
            '/dp.service.annotation.DpAnnotationService/saveConfigurationActivation',
            annotation__pb2.SaveConfigurationActivationRequest.SerializeToString,
            annotation__pb2.SaveConfigurationActivationResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def getConfigurationActivation(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,
            '/dp.service.annotation.DpAnnotationService/getConfigurationActivation',
            annotation__pb2.GetConfigurationActivationRequest.SerializeToString,
            annotation__pb2.GetConfigurationActivationResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def queryConfigurationActivations(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,
            '/dp.service.annotation.DpAnnotationService/queryConfigurationActivations',
            annotation__pb2.QueryConfigurationActivationsRequest.SerializeToString,
            annotation__pb2.QueryConfigurationActivationsResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def deleteConfigurationActivation(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,
            '/dp.service.annotation.DpAnnotationService/deleteConfigurationActivation',
            annotation__pb2.DeleteConfigurationActivationRequest.SerializeToString,
            annotation__pb2.DeleteConfigurationActivationResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def patchConfigurationActivation(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,
            '/dp.service.annotation.DpAnnotationService/patchConfigurationActivation',
            annotation__pb2.PatchConfigurationActivationRequest.SerializeToString,
            annotation__pb2.PatchConfigurationActivationResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def bulkSaveConfigurationActivation(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,
            '/dp.service.annotation.DpAnnotationService/bulkSaveConfigurationActivation',
            annotation__pb2.BulkSaveConfigurationActivationRequest.SerializeToString,
            annotation__pb2.BulkSaveConfigurationActivationResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def getActiveConfigurations(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,
            '/dp.service.annotation.DpAnnotationService/getActiveConfigurations',
            annotation__pb2.GetActiveConfigurationsRequest.SerializeToString,
            annotation__pb2.GetActiveConfigurationsResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def saveSampleStatuses(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,
            '/dp.service.annotation.DpAnnotationService/saveSampleStatuses',
            annotation__pb2.SaveSampleStatusesRequest.SerializeToString,
            annotation__pb2.SaveSampleStatusesResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def querySampleStatuses(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,
            '/dp.service.annotation.DpAnnotationService/querySampleStatuses',
            annotation__pb2.QuerySampleStatusesRequest.SerializeToString,
            annotation__pb2.QuerySampleStatusesResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def querySampleStatusesStream(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_stream(
            request,
            target,
            '/dp.service.annotation.DpAnnotationService/querySampleStatusesStream',
            annotation__pb2.QuerySampleStatusesRequest.SerializeToString,
            annotation__pb2.QuerySampleStatusesResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def deleteSampleStatuses(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,
            '/dp.service.annotation.DpAnnotationService/deleteSampleStatuses',
            annotation__pb2.DeleteSampleStatusesRequest.SerializeToString,
            annotation__pb2.DeleteSampleStatusesResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def saveSampleStatusDomain(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,
            '/dp.service.annotation.DpAnnotationService/saveSampleStatusDomain',
            annotation__pb2.SaveSampleStatusDomainRequest.SerializeToString,
            annotation__pb2.SaveSampleStatusDomainResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def querySampleStatusDomains(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,
            '/dp.service.annotation.DpAnnotationService/querySampleStatusDomains',
            annotation__pb2.QuerySampleStatusDomainsRequest.SerializeToString,
            annotation__pb2.QuerySampleStatusDomainsResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)