query_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 query_pb2 as query__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 query_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 DpQueryServiceStub:
    """
    ------------------- RPC Interfaces ---------------------------



    The Query Service Interface

    Defines RPC operations for data and stats queries.
    """

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

        Args:
            channel: A grpc.Channel.
        """
        self.queryData = channel.unary_unary(
                '/dp.service.query.DpQueryService/queryData',
                request_serializer=query__pb2.QueryDataRequest.SerializeToString,
                response_deserializer=query__pb2.QueryDataResponse.FromString,
                _registered_method=True)
        self.queryDataStream = channel.unary_stream(
                '/dp.service.query.DpQueryService/queryDataStream',
                request_serializer=query__pb2.QueryDataRequest.SerializeToString,
                response_deserializer=query__pb2.QueryDataResponse.FromString,
                _registered_method=True)
        self.queryDataBidiStream = channel.stream_stream(
                '/dp.service.query.DpQueryService/queryDataBidiStream',
                request_serializer=query__pb2.QueryDataRequest.SerializeToString,
                response_deserializer=query__pb2.QueryDataResponse.FromString,
                _registered_method=True)
        self.queryTable = channel.unary_unary(
                '/dp.service.query.DpQueryService/queryTable',
                request_serializer=query__pb2.QueryTableRequest.SerializeToString,
                response_deserializer=query__pb2.QueryTableResponse.FromString,
                _registered_method=True)
        self.queryPvStats = channel.unary_unary(
                '/dp.service.query.DpQueryService/queryPvStats',
                request_serializer=query__pb2.QueryPvStatsRequest.SerializeToString,
                response_deserializer=query__pb2.QueryPvStatsResponse.FromString,
                _registered_method=True)
        self.queryProviders = channel.unary_unary(
                '/dp.service.query.DpQueryService/queryProviders',
                request_serializer=query__pb2.QueryProvidersRequest.SerializeToString,
                response_deserializer=query__pb2.QueryProvidersResponse.FromString,
                _registered_method=True)
        self.queryProviderStats = channel.unary_unary(
                '/dp.service.query.DpQueryService/queryProviderStats',
                request_serializer=query__pb2.QueryProviderStatsRequest.SerializeToString,
                response_deserializer=query__pb2.QueryProviderStatsResponse.FromString,
                _registered_method=True)
        self.queryBuckets = channel.unary_unary(
                '/dp.service.query.DpQueryService/queryBuckets',
                request_serializer=query__pb2.QueryBucketsRequest.SerializeToString,
                response_deserializer=query__pb2.QueryBucketsResponse.FromString,
                _registered_method=True)
        self.queryBucketsStream = channel.unary_stream(
                '/dp.service.query.DpQueryService/queryBucketsStream',
                request_serializer=query__pb2.QueryBucketsRequest.SerializeToString,
                response_deserializer=query__pb2.QueryBucketsResponse.FromString,
                _registered_method=True)
        self.querySamples = channel.unary_unary(
                '/dp.service.query.DpQueryService/querySamples',
                request_serializer=query__pb2.QuerySamplesRequest.SerializeToString,
                response_deserializer=query__pb2.QuerySamplesResponse.FromString,
                _registered_method=True)
        self.querySamplesStream = channel.unary_stream(
                '/dp.service.query.DpQueryService/querySamplesStream',
                request_serializer=query__pb2.QuerySamplesRequest.SerializeToString,
                response_deserializer=query__pb2.QuerySamplesResponse.FromString,
                _registered_method=True)


class DpQueryServiceServicer:
    """
    ------------------- RPC Interfaces ---------------------------



    The Query Service Interface

    Defines RPC operations for data and stats queries.
    """

    def queryData(self, request, context):
        """
        queryData: Unary (non-streaming) time series data query.

        Client sends a single QueryDataRequest with the query parameters, and receives a single QueryDataResponse with the
        query results. The response may indicate rejection or error in handling, or otherwise contains the data
        matching the query specification.  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 queryDataStream(self, request, context):
        """
        queryDataStream: Server-side streaming time series data query.

        Client sends a single QueryDataRequest with the query parameters, and receives a stream of QueryDataResponse
        messages with the query results. The response may indicate rejection or error in handling, or otherwise
        contains the data matching the query specification.  A query matching no data returns an empty result, not an
        ExceptionalResult.  Results are sent in the response stream until the MongoDB cursor for the query is
        exhausted, or an error is encountered in processing.

        The response stream is closed by the server in case of rejection, if there is an error in processing, or the
        result cursor is exhausted.

        We expect this to be the best performing RPC for time series data query.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def queryDataBidiStream(self, request_iterator, context):
        """
        queryDataBidiStream: Bidirectional streaming time series data query.

        Client sends a QueryDataRequest with the query parameters, and receives an initial QueryDataResponse message
        with the query results.

        While the MongoDB cursor for the query result contains additional details, the client sends a QueryDataRequest
        message with a CursorOperation payload to receive the next QueryDataResponse message in the stream.  This should
        continue in a loop until the query result is exhausted.

        The server closes the response stream if a request is rejected, or when the result is exhausted or an error
        is encountered.

        Each individual response may indicate rejection or error in handling, or otherwise contains the data
        matching the query specification.  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 queryTable(self, request, context):
        """
        queryTable: Unary (non-streaming) time series data query with tabular result.

        This time series data query returns its result in a tabular format, for use by the Data Platform web application.
        The client sends a single QueryTableRequest with the query parameters and receives a single QueryTableResponse.
        The response content may indicate an exception in handling such as rejection or database error, or otherwise
        contains the tabular data matching the query specification.  A query matching no data returns an empty table
        result, not an ExceptionalResult.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def queryPvStats(self, request, context):
        """
        queryPvStats(): Unary (non-streaming) PV archive statistics query.

        (Renamed from queryPvMetadata() — returns archive ingestion statistics,
        not user-defined PV metadata.  See DpAnnotationService.queryPvMetadata()
        for user-defined metadata queries.)

        This RPC is used by clients to learn about data sources (PVs/columns)
        available in the archive.  Client sends a single QueryPvStatsRequest
        with the query parameters, and receives a single QueryPvStatsResponse
        with the query results.  The response may indicate rejection or error in
        handling, or otherwise contains the archive statistics matching the query
        specification.  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 queryProviders(self, request, context):
        """
        queryProviders(): Unary Providers query.

        This rpc is used by clients to retrieve details about ingestion data Providers defined in the archive.
        It accepts a single "QueryProvidersRequest" containing the query parameters and returns a single
        "QueryProvidersResponse".  The response may indicate an exceptional result such as rejection or error in handling
        the request, otherwise it contains information about each Provider matching the query criteria.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def queryProviderStats(self, request, context):
        """
        queryProviderStats(): Unary Provider archive statistics query.

        (Renamed from queryProviderMetadata() — returns archive ingestion
        statistics, not user-defined provider metadata.)

        This RPC is used by clients to retrieve ingestion statistics for data
        Providers defined in the archive.  It accepts a single
        QueryProviderStatsRequest containing the query parameters and returns a
        single QueryProviderStatsResponse.  The response may indicate an
        exceptional result such as rejection or error in handling the request,
        otherwise it contains ingestion statistics for the specified data provider.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def queryBuckets(self, request, context):
        """
        ------------------- Query API V2 methods ---------------------------

        Query API V2 introduces a common QuerySpec shared by all methods below.
        QuerySpec describes WHAT data to retrieve (time range, PV selection,
        configuration filtering) independently of HOW results are represented.
        Each request bundles a QuerySpec with optional ExecutionOptions (paging) and
        ResultRepresentation (format flags).  V1 methods above remain available for
        backward compatibility.



        queryBuckets(): Unary bucket-oriented time-series query (V2).

        Executes the supplied QuerySpec and returns one page of DataBucket objects,
        each corresponding closely to the underlying archive storage model.
        Additional pages are retrieved by resubmitting the same QuerySpec with the
        nextPageToken from the previous response placed in ExecutionOptions.pageToken.

        Boundary buckets are returned WHOLE (not trimmed): a bucket overlapping the
        TimeRange is returned intact, so its first/last bucket may contain individual
        samples outside [beginTime, endTime).  Callers wanting samples strictly
        within the range should use querySamples(), which trims.

        QuerySpec.sampleStatusSelector is not supported by the bucket-oriented
        methods (buckets are returned whole and cannot represent per-sample
        filtering); a request with sampleStatusSelector set is rejected with an
        ExceptionalResult.

        Intended for Java applications, archive export, infrastructure services, and
        high-performance retrieval.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def queryBucketsStream(self, request, context):
        """
        queryBucketsStream(): Server-streaming bucket-oriented query (V2).

        Executes the supplied QuerySpec and streams QueryBucketsResponse messages
        until the result is exhausted, the client cancels, or an error occurs.
        Replaces the V1 bidirectional cursor protocol; the client is not responsible
        for advancing server-side cursors.

        Paging semantics for streaming: ExecutionOptions.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); ExecutionOptions.pageToken must be empty (a non-empty token is
        rejected with an ExceptionalResult).  Use unary queryBuckets() when
        resumable paging is required.

        QuerySpec.sampleStatusSelector is not supported (rejected with an
        ExceptionalResult); see queryBuckets().
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def querySamples(self, request, context):
        """
        querySamples(): Unary sample-oriented time-series query (V2).

        Executes the supplied QuerySpec and returns one page of aligned sample data
        as a column-oriented table.  The server assembles bucket data internally to
        present a continuous view of the requested interval; bucket boundaries are
        hidden from the client.

        Samples are TRIMMED to the half-open TimeRange [beginTime, endTime): the
        server retrieves overlapping buckets and drops edge samples that fall outside
        the range, so every returned timestamp satisfies beginTime <= t < endTime.
        (This carries forward the trimming behavior of the V1 queryTable processor.)

        Supports QuerySpec.sampleStatusSelector for restricting returned samples by
        sample status (see SampleStatusSelector and the Sample Status API in
        annotation.proto).

        Expected to become the preferred method for the Python client library,
        interactive analysis, data science, machine learning, and visualization.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def querySamplesStream(self, request, context):
        """
        querySamplesStream(): Server-streaming sample-oriented query (V2).

        Streams aligned sample data as successive ColumnTable pages.  Paging
        semantics match queryBucketsStream(): ExecutionOptions.limit controls the
        number of timestamps (rows) per streamed response; streaming is
        fire-and-consume (no continuation tokens; ExecutionOptions.pageToken must be
        empty, a non-empty token rejected with an ExceptionalResult).  Use unary
        querySamples() when resumable paging is required.

        Supports QuerySpec.sampleStatusSelector for restricting returned samples by
        sample status; see querySamples().
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')


def add_DpQueryServiceServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'queryData': grpc.unary_unary_rpc_method_handler(
                    servicer.queryData,
                    request_deserializer=query__pb2.QueryDataRequest.FromString,
                    response_serializer=query__pb2.QueryDataResponse.SerializeToString,
            ),
            'queryDataStream': grpc.unary_stream_rpc_method_handler(
                    servicer.queryDataStream,
                    request_deserializer=query__pb2.QueryDataRequest.FromString,
                    response_serializer=query__pb2.QueryDataResponse.SerializeToString,
            ),
            'queryDataBidiStream': grpc.stream_stream_rpc_method_handler(
                    servicer.queryDataBidiStream,
                    request_deserializer=query__pb2.QueryDataRequest.FromString,
                    response_serializer=query__pb2.QueryDataResponse.SerializeToString,
            ),
            'queryTable': grpc.unary_unary_rpc_method_handler(
                    servicer.queryTable,
                    request_deserializer=query__pb2.QueryTableRequest.FromString,
                    response_serializer=query__pb2.QueryTableResponse.SerializeToString,
            ),
            'queryPvStats': grpc.unary_unary_rpc_method_handler(
                    servicer.queryPvStats,
                    request_deserializer=query__pb2.QueryPvStatsRequest.FromString,
                    response_serializer=query__pb2.QueryPvStatsResponse.SerializeToString,
            ),
            'queryProviders': grpc.unary_unary_rpc_method_handler(
                    servicer.queryProviders,
                    request_deserializer=query__pb2.QueryProvidersRequest.FromString,
                    response_serializer=query__pb2.QueryProvidersResponse.SerializeToString,
            ),
            'queryProviderStats': grpc.unary_unary_rpc_method_handler(
                    servicer.queryProviderStats,
                    request_deserializer=query__pb2.QueryProviderStatsRequest.FromString,
                    response_serializer=query__pb2.QueryProviderStatsResponse.SerializeToString,
            ),
            'queryBuckets': grpc.unary_unary_rpc_method_handler(
                    servicer.queryBuckets,
                    request_deserializer=query__pb2.QueryBucketsRequest.FromString,
                    response_serializer=query__pb2.QueryBucketsResponse.SerializeToString,
            ),
            'queryBucketsStream': grpc.unary_stream_rpc_method_handler(
                    servicer.queryBucketsStream,
                    request_deserializer=query__pb2.QueryBucketsRequest.FromString,
                    response_serializer=query__pb2.QueryBucketsResponse.SerializeToString,
            ),
            'querySamples': grpc.unary_unary_rpc_method_handler(
                    servicer.querySamples,
                    request_deserializer=query__pb2.QuerySamplesRequest.FromString,
                    response_serializer=query__pb2.QuerySamplesResponse.SerializeToString,
            ),
            'querySamplesStream': grpc.unary_stream_rpc_method_handler(
                    servicer.querySamplesStream,
                    request_deserializer=query__pb2.QuerySamplesRequest.FromString,
                    response_serializer=query__pb2.QuerySamplesResponse.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'dp.service.query.DpQueryService', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))
    server.add_registered_method_handlers('dp.service.query.DpQueryService', rpc_method_handlers)


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



    The Query Service Interface

    Defines RPC operations for data and stats queries.
    """

    @staticmethod
    def queryData(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.query.DpQueryService/queryData',
            query__pb2.QueryDataRequest.SerializeToString,
            query__pb2.QueryDataResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def queryDataStream(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.query.DpQueryService/queryDataStream',
            query__pb2.QueryDataRequest.SerializeToString,
            query__pb2.QueryDataResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def queryDataBidiStream(request_iterator,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.stream_stream(
            request_iterator,
            target,
            '/dp.service.query.DpQueryService/queryDataBidiStream',
            query__pb2.QueryDataRequest.SerializeToString,
            query__pb2.QueryDataResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def queryTable(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.query.DpQueryService/queryTable',
            query__pb2.QueryTableRequest.SerializeToString,
            query__pb2.QueryTableResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def queryPvStats(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.query.DpQueryService/queryPvStats',
            query__pb2.QueryPvStatsRequest.SerializeToString,
            query__pb2.QueryPvStatsResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def queryProviders(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.query.DpQueryService/queryProviders',
            query__pb2.QueryProvidersRequest.SerializeToString,
            query__pb2.QueryProvidersResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def queryProviderStats(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.query.DpQueryService/queryProviderStats',
            query__pb2.QueryProviderStatsRequest.SerializeToString,
            query__pb2.QueryProviderStatsResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def queryBuckets(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.query.DpQueryService/queryBuckets',
            query__pb2.QueryBucketsRequest.SerializeToString,
            query__pb2.QueryBucketsResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def queryBucketsStream(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.query.DpQueryService/queryBucketsStream',
            query__pb2.QueryBucketsRequest.SerializeToString,
            query__pb2.QueryBucketsResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def querySamples(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.query.DpQueryService/querySamples',
            query__pb2.QuerySamplesRequest.SerializeToString,
            query__pb2.QuerySamplesResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def querySamplesStream(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.query.DpQueryService/querySamplesStream',
            query__pb2.QuerySamplesRequest.SerializeToString,
            query__pb2.QuerySamplesResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)