google-cloud-bigtable 2.30.0__py3-none-any.whl

google/cloud/bigtable_v2/types/feature_flags.py

@@ -0,0 +1,119 @@
+# -*- coding: utf-8 -*-
+# Copyright 2024 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+from __future__ import annotations
+
+from typing import MutableMapping, MutableSequence
+
+import proto  # type: ignore
+
+
+__protobuf__ = proto.module(
+    package="google.bigtable.v2",
+    manifest={
+        "FeatureFlags",
+    },
+)
+
+
+class FeatureFlags(proto.Message):
+    r"""Feature flags supported or enabled by a client. This is intended to
+    be sent as part of request metadata to assure the server that
+    certain behaviors are safe to enable. This proto is meant to be
+    serialized and websafe-base64 encoded under the
+    ``bigtable-features`` metadata key. The value will remain constant
+    for the lifetime of a client and due to HTTP2's HPACK compression,
+    the request overhead will be tiny. This is an internal
+    implementation detail and should not be used by end users directly.
+
+    Attributes:
+        reverse_scans (bool):
+            Notify the server that the client supports
+            reverse scans. The server will reject
+            ReadRowsRequests with the reverse bit set when
+            this is absent.
+        mutate_rows_rate_limit (bool):
+            Notify the server that the client enables
+            batch write flow control by requesting
+            RateLimitInfo from MutateRowsResponse. Due to
+            technical reasons, this disables partial
+            retries.
+        mutate_rows_rate_limit2 (bool):
+            Notify the server that the client enables
+            batch write flow control by requesting
+            RateLimitInfo from MutateRowsResponse. With
+            partial retries enabled.
+        last_scanned_row_responses (bool):
+            Notify the server that the client supports the
+            last_scanned_row field in ReadRowsResponse for long-running
+            scans.
+        routing_cookie (bool):
+            Notify the server that the client supports
+            using encoded routing cookie strings to retry
+            requests with.
+        retry_info (bool):
+            Notify the server that the client supports
+            using retry info back off durations to retry
+            requests with.
+        client_side_metrics_enabled (bool):
+            Notify the server that the client has client
+            side metrics enabled.
+        traffic_director_enabled (bool):
+            Notify the server that the client using
+            Traffic Director endpoint.
+        direct_access_requested (bool):
+            Notify the server that the client explicitly
+            opted in for Direct Access.
+    """
+
+    reverse_scans: bool = proto.Field(
+        proto.BOOL,
+        number=1,
+    )
+    mutate_rows_rate_limit: bool = proto.Field(
+        proto.BOOL,
+        number=3,
+    )
+    mutate_rows_rate_limit2: bool = proto.Field(
+        proto.BOOL,
+        number=5,
+    )
+    last_scanned_row_responses: bool = proto.Field(
+        proto.BOOL,
+        number=4,
+    )
+    routing_cookie: bool = proto.Field(
+        proto.BOOL,
+        number=6,
+    )
+    retry_info: bool = proto.Field(
+        proto.BOOL,
+        number=7,
+    )
+    client_side_metrics_enabled: bool = proto.Field(
+        proto.BOOL,
+        number=8,
+    )
+    traffic_director_enabled: bool = proto.Field(
+        proto.BOOL,
+        number=9,
+    )
+    direct_access_requested: bool = proto.Field(
+        proto.BOOL,
+        number=10,
+    )
+
+
+__all__ = tuple(sorted(__protobuf__.manifest))

google/cloud/bigtable_v2/types/request_stats.py

@@ -0,0 +1,171 @@
+# -*- coding: utf-8 -*-
+# Copyright 2024 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+from __future__ import annotations
+
+from typing import MutableMapping, MutableSequence
+
+import proto  # type: ignore
+
+from google.protobuf import duration_pb2  # type: ignore
+
+
+__protobuf__ = proto.module(
+    package="google.bigtable.v2",
+    manifest={
+        "ReadIterationStats",
+        "RequestLatencyStats",
+        "FullReadStatsView",
+        "RequestStats",
+    },
+)
+
+
+class ReadIterationStats(proto.Message):
+    r"""ReadIterationStats captures information about the iteration
+    of rows or cells over the course of a read, e.g. how many
+    results were scanned in a read operation versus the results
+    returned.
+
+    Attributes:
+        rows_seen_count (int):
+            The rows seen (scanned) as part of the
+            request. This includes the count of rows
+            returned, as captured below.
+        rows_returned_count (int):
+            The rows returned as part of the request.
+        cells_seen_count (int):
+            The cells seen (scanned) as part of the
+            request. This includes the count of cells
+            returned, as captured below.
+        cells_returned_count (int):
+            The cells returned as part of the request.
+    """
+
+    rows_seen_count: int = proto.Field(
+        proto.INT64,
+        number=1,
+    )
+    rows_returned_count: int = proto.Field(
+        proto.INT64,
+        number=2,
+    )
+    cells_seen_count: int = proto.Field(
+        proto.INT64,
+        number=3,
+    )
+    cells_returned_count: int = proto.Field(
+        proto.INT64,
+        number=4,
+    )
+
+
+class RequestLatencyStats(proto.Message):
+    r"""RequestLatencyStats provides a measurement of the latency of
+    the request as it interacts with different systems over its
+    lifetime, e.g. how long the request took to execute within a
+    frontend server.
+
+    Attributes:
+        frontend_server_latency (google.protobuf.duration_pb2.Duration):
+            The latency measured by the frontend server
+            handling this request, from when the request was
+            received, to when this value is sent back in the
+            response. For more context on the component that
+            is measuring this latency, see:
+            https://cloud.google.com/bigtable/docs/overview
+
+            Note: This value may be slightly shorter than
+            the value reported into aggregate latency
+            metrics in Monitoring for this request
+            (https://cloud.google.com/bigtable/docs/monitoring-instance)
+            as this value needs to be sent in the response
+            before the latency measurement including that
+            transmission is finalized.
+
+            Note: This value includes the end-to-end latency
+            of contacting nodes in the targeted cluster,
+            e.g. measuring from when the first byte arrives
+            at the frontend server, to when this value is
+            sent back as the last value in the response,
+            including any latency incurred by contacting
+            nodes, waiting for results from nodes, and
+            finally sending results from nodes back to the
+            caller.
+    """
+
+    frontend_server_latency: duration_pb2.Duration = proto.Field(
+        proto.MESSAGE,
+        number=1,
+        message=duration_pb2.Duration,
+    )
+
+
+class FullReadStatsView(proto.Message):
+    r"""FullReadStatsView captures all known information about a
+    read.
+
+    Attributes:
+        read_iteration_stats (google.cloud.bigtable_v2.types.ReadIterationStats):
+            Iteration stats describe how efficient the
+            read is, e.g. comparing rows seen vs. rows
+            returned or cells seen vs cells returned can
+            provide an indication of read efficiency (the
+            higher the ratio of seen to retuned the better).
+        request_latency_stats (google.cloud.bigtable_v2.types.RequestLatencyStats):
+            Request latency stats describe the time taken
+            to complete a request, from the server side.
+    """
+
+    read_iteration_stats: "ReadIterationStats" = proto.Field(
+        proto.MESSAGE,
+        number=1,
+        message="ReadIterationStats",
+    )
+    request_latency_stats: "RequestLatencyStats" = proto.Field(
+        proto.MESSAGE,
+        number=2,
+        message="RequestLatencyStats",
+    )
+
+
+class RequestStats(proto.Message):
+    r"""RequestStats is the container for additional information pertaining
+    to a single request, helpful for evaluating the performance of the
+    sent request. Currently, there are the following supported methods:
+
+    -  google.bigtable.v2.ReadRows
+
+
+    .. _oneof: https://proto-plus-python.readthedocs.io/en/stable/fields.html#oneofs-mutually-exclusive-fields
+
+    Attributes:
+        full_read_stats_view (google.cloud.bigtable_v2.types.FullReadStatsView):
+            Available with the
+            ReadRowsRequest.RequestStatsView.REQUEST_STATS_FULL view,
+            see package google.bigtable.v2.
+
+            This field is a member of `oneof`_ ``stats_view``.
+    """
+
+    full_read_stats_view: "FullReadStatsView" = proto.Field(
+        proto.MESSAGE,
+        number=1,
+        oneof="stats_view",
+        message="FullReadStatsView",
+    )
+
+
+__all__ = tuple(sorted(__protobuf__.manifest))

google/cloud/bigtable_v2/types/response_params.py

@@ -0,0 +1,64 @@
+# -*- coding: utf-8 -*-
+# Copyright 2024 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+from __future__ import annotations
+
+from typing import MutableMapping, MutableSequence
+
+import proto  # type: ignore
+
+
+__protobuf__ = proto.module(
+    package="google.bigtable.v2",
+    manifest={
+        "ResponseParams",
+    },
+)
+
+
+class ResponseParams(proto.Message):
+    r"""Response metadata proto This is an experimental feature that will be
+    used to get zone_id and cluster_id from response trailers to tag the
+    metrics. This should not be used by customers directly
+
+
+    .. _oneof: https://proto-plus-python.readthedocs.io/en/stable/fields.html#oneofs-mutually-exclusive-fields
+
+    Attributes:
+        zone_id (str):
+            The cloud bigtable zone associated with the
+            cluster.
+
+            This field is a member of `oneof`_ ``_zone_id``.
+        cluster_id (str):
+            Identifier for a cluster that represents set
+            of bigtable resources.
+
+            This field is a member of `oneof`_ ``_cluster_id``.
+    """
+
+    zone_id: str = proto.Field(
+        proto.STRING,
+        number=1,
+        optional=True,
+    )
+    cluster_id: str = proto.Field(
+        proto.STRING,
+        number=2,
+        optional=True,
+    )
+
+
+__all__ = tuple(sorted(__protobuf__.manifest))