google-api-core 2.32.0__tar.gz → 2.34.0__tar.gz

{google_api_core-2.32.0 → google_api_core-2.34.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: google-api-core
-Version: 2.32.0
+Version: 2.34.0
 Summary: Google API client core library
 Author-email: Google LLC <googleapis-packages@google.com>
 License: Apache 2.0
@@ -22,21 +22,18 @@ Classifier: Topic :: Internet
 Requires-Python: >=3.10
 Description-Content-Type: text/x-rst
 License-File: LICENSE
-Requires-Dist: googleapis-common-protos<2.0.0,>=1.63.2
-Requires-Dist: protobuf<8.0.0,>=5.29.6
-Requires-Dist: proto-plus<2.0.0,>=1.24.0
-Requires-Dist: proto-plus<2.0.0,>=1.25.0; python_version >= "3.13"
+Requires-Dist: googleapis-common-protos<2.0.0,>=1.69.2
+Requires-Dist: protobuf<8.0.0,>=6.33.5
+Requires-Dist: proto-plus<2.0.0,>=1.26.1
 Requires-Dist: google-auth<3.0.0,>=2.14.1
 Requires-Dist: requests<3.0.0,>=2.33.0
 Provides-Extra: async-rest
 Requires-Dist: google-auth[aiohttp]<3.0.0,>=2.14.1; extra == "async-rest"
 Requires-Dist: aiohttp>=3.13.4; extra == "async-rest"
 Provides-Extra: grpc
-Requires-Dist: grpcio<2.0.0,>=1.41.0; extra == "grpc"
-Requires-Dist: grpcio<2.0.0,>=1.49.1; python_version >= "3.11" and extra == "grpc"
+Requires-Dist: grpcio<2.0.0,>=1.59.0; extra == "grpc"
 Requires-Dist: grpcio<2.0.0,>=1.75.1; python_version >= "3.14" and extra == "grpc"
-Requires-Dist: grpcio-status<2.0.0,>=1.41.0; extra == "grpc"
-Requires-Dist: grpcio-status<2.0.0,>=1.49.1; python_version >= "3.11" and extra == "grpc"
+Requires-Dist: grpcio-status<2.0.0,>=1.59.0; extra == "grpc"
 Requires-Dist: grpcio-status<2.0.0,>=1.75.1; python_version >= "3.14" and extra == "grpc"
 Dynamic: license-file
 

{google_api_core-2.32.0 → google_api_core-2.34.0}/google/api_core/__init__.py

@@ -17,8 +17,7 @@
 This package contains common code and utilities used by Google client libraries.
 """
 
-from google.api_core import _python_package_support
-from google.api_core import _python_version_support
+from google.api_core import _python_package_support, _python_version_support
 from google.api_core import version as api_core_version
 
 __version__ = api_core_version.__version__

google_api_core-2.34.0/google/api_core/_feature_gating_helpers.py

@@ -0,0 +1,139 @@
+# -*- coding: utf-8 -*-
+# Copyright 2026 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.
+#
+
+"""Observability environment variable and client options resolution helpers."""
+
+import os
+import warnings
+from typing import Any
+
+# We import ClientOptions for type hinting
+from google.api_core.client_options import ClientOptions
+
+# Allowed truthy and falsy patterns for environment variables
+_TRUTHY_VALUES = ("y", "yes", "t", "true", "on", "1")
+_FALSY_VALUES = ("n", "no", "f", "false", "off", "0")
+
+
+class FeatureGatingError(ValueError):
+    """Raised when feature gating resolution fails or is misconfigured."""
+
+    pass
+
+
+def _strtobool(val: str) -> bool | None:
+    """Convert a string representation of truth to a boolean."""
+    clean_val = val.lower().strip()
+    if not clean_val:
+        return None
+    if clean_val in _TRUTHY_VALUES:
+        return True
+    if clean_val in _FALSY_VALUES:
+        return False
+    raise ValueError(f"Invalid truth value: {val!r}")
+
+
+def _get_env_bool(name: str) -> bool | None:
+    """Retrieve the boolean value of an environment variable."""
+    val = os.getenv(name)
+    if val is None:
+        return None
+    try:
+        return _strtobool(val)
+    except ValueError as e:
+        warnings.warn(f"Ignored invalid value for {name}: {e}", RuntimeWarning)
+        return None
+
+
+def _has_feature_key(
+    *, configuration: ClientOptions | dict[str, Any] | None, feature_key: str
+) -> bool:
+    """Checks if a specific feature key is present and not None in configuration."""
+    if configuration is None:
+        return False
+
+    if feature_key.startswith("__"):
+        return False
+
+    if isinstance(configuration, dict):
+        return configuration.get(feature_key) is not None
+
+    return getattr(configuration, feature_key, None) is not None
+
+
+def resolve_feature_flags(
+    *,
+    env_var: str,
+    feature_key: str,
+    configuration: ClientOptions | dict[str, Any] | None = None,
+) -> bool:
+    """Determines if a feature is enabled based on environment variables and configuration.
+
+    Behavior depends on whether the `env_var` name contains "EXPERIMENTAL":
+
+    - **Experimental Path** (env_var contains "EXPERIMENTAL"):
+      Strict control. Requires the environment variable to be explicitly 'true'.
+      If a programmatic feature key is passed but the environment variable is not 'true',
+      raises FeatureGatingError (Fail Fast).
+
+    - **GA Path** (env_var does not contain "EXPERIMENTAL"):
+      Standard precedence. Enabled if a programmatic feature key is passed,
+      otherwise falls back to the environment variable value.
+
+    Args:
+        env_var: The name of the environment variable controlling this feature.
+        feature_key: The key in configuration/attributes for the programmatic configuration.
+        configuration: Optional. A dictionary or object containing client configuration.
+
+    Returns:
+        bool: True if the feature is resolved to enabled, False otherwise.
+
+    Raises:
+        FeatureGatingError: If a feature key is provided for an experimental feature without enabling the experimental environment variable.
+    """
+
+    # Check for programmatic feature configuration
+    has_feature_key = _has_feature_key(
+        configuration=configuration, feature_key=feature_key
+    )
+
+    # Read environment variable
+    env_var_setting = _get_env_bool(env_var)
+
+    # EXPERIMENTAL PATH:
+    # Resolution Hierarchy:
+    #   1. EXPERIMENTAL Environment Variable
+    #   2. Fail Fast if Feature Key present but EXPERIMENTAL Environment Variable is not enabled
+    if "EXPERIMENTAL" in env_var:
+        # Fail Fast if feature key present but experimental environment variable is not enabled
+        if env_var_setting is not True and has_feature_key:
+            raise FeatureGatingError(
+                f"Experimental feature requires {env_var} to be set to 'true' to use programmatic configuration."
+            )
+
+        return bool(env_var_setting)
+
+    # GENERAL AVAILABILITY PATH:
+    # Resolution Hierarchy:
+    #   1. Programmatic Configuration (Feature Key)
+    #   2. Environment Variable
+
+    # Check Programmatic Configuration
+    if has_feature_key:
+        return True
+
+    # Check Environment Variable
+    return bool(env_var_setting)

{google_api_core-2.32.0 → google_api_core-2.34.0}/google/api_core/_python_package_support.py

@@ -15,17 +15,15 @@
 """Code to check versions of dependencies used by Google Cloud Client Libraries."""
 
 import warnings
-from typing import Optional, Tuple
-
 from collections import namedtuple
+from importlib import metadata
+from typing import Optional, Tuple
 
 from ._python_version_support import (
     _flatten_message,
     _get_distribution_and_import_packages,
 )
 
-from importlib import metadata
-
 ParsedVersion = Tuple[int, ...]
 
 # Here we list all the packages for which we want to issue warnings
@@ -37,7 +35,7 @@ DependencyConstraint = namedtuple(
 _PACKAGE_DEPENDENCY_WARNINGS = [
     DependencyConstraint(
         "google.protobuf",
-        minimum_fully_supported_version="4.25.8",
+        minimum_fully_supported_version="6.33.5",
         recommended_version="6.x",
     )
 ]
@@ -52,7 +50,7 @@ UNKNOWN_VERSION_STRING = "--"
 def parse_version_to_tuple(version_string: str) -> ParsedVersion:
     """Safely converts a semantic version string to a comparable tuple of integers.
 
-    Example: "4.25.8" -> (4, 25, 8)
+    Example: "6.33.5" -> (6, 33, 5)
     Ignores non-numeric parts and handles common version formats.
 
     Args:

{google_api_core-2.32.0 → google_api_core-2.34.0}/google/api_core/_python_version_support.py

@@ -17,13 +17,12 @@
 import datetime
 import enum
 import functools
-from importlib import metadata
 import logging
-import warnings
 import sys
 import textwrap
-from typing import Any, List, NamedTuple, Optional, Dict, Tuple
-
+import warnings
+from importlib import metadata
+from typing import Any, Dict, List, NamedTuple, Optional, Tuple
 
 _LOGGER = logging.getLogger(__name__)
 

{google_api_core-2.32.0 → google_api_core-2.34.0}/google/api_core/bidi.py

@@ -113,7 +113,7 @@ class _RequestQueueGenerator(object):
             except queue_module.Empty:
                 if not self._is_active():
                     _LOGGER.debug(
-                        "Empty queue and inactive call, exiting request " "generator."
+                        "Empty queue and inactive call, exiting request generator."
                     )
                     return
                 else:

{google_api_core-2.32.0 → google_api_core-2.34.0}/google/api_core/bidi_async.py

@@ -18,14 +18,12 @@ import asyncio
 import logging
 from typing import Callable, Optional, Union
 
+from google.protobuf.message import Message as ProtobufMessage
 from grpc import aio
 
 from google.api_core import exceptions
 from google.api_core.bidi_base import BidiRpcBase
 
-from google.protobuf.message import Message as ProtobufMessage
-
-
 _LOGGER = logging.getLogger(__name__)
 
 

{google_api_core-2.32.0 → google_api_core-2.34.0}/google/api_core/client_logging.py

@@ -1,7 +1,6 @@
-import logging
 import json
+import logging
 import os
-
 from typing import List, Optional
 
 _LOGGING_INITIALIZED = False

{google_api_core-2.32.0 → google_api_core-2.34.0}/google/api_core/datetime_helpers.py

@@ -20,7 +20,6 @@ import re
 
 from google.protobuf import timestamp_pb2
 
-
 _UTC_EPOCH = datetime.datetime(1970, 1, 1, tzinfo=datetime.timezone.utc)
 _RFC3339_MICROS = "%Y-%m-%dT%H:%M:%S.%fZ"
 _RFC3339_NO_FRACTION = "%Y-%m-%dT%H:%M:%S"

{google_api_core-2.32.0 → google_api_core-2.34.0}/google/api_core/future/_helpers.py

@@ -17,7 +17,6 @@
 import logging
 import threading
 
-
 _LOGGER = logging.getLogger(__name__)
 
 

{google_api_core-2.32.0 → google_api_core-2.34.0}/google/api_core/future/async_future.py

@@ -16,9 +16,7 @@
 
 import asyncio
 
-from google.api_core import exceptions
-from google.api_core import retry
-from google.api_core import retry_async
+from google.api_core import exceptions, retry, retry_async
 from google.api_core.future import base
 
 
@@ -101,7 +99,7 @@ class AsyncFuture(base.Future):
             await retry_(self._done_or_raise)()
         except exceptions.RetryError:
             raise asyncio.TimeoutError(
-                "Operation did not complete within the designated " "timeout."
+                "Operation did not complete within the designated timeout."
             )
 
     async def result(self, timeout=None):

{google_api_core-2.32.0 → google_api_core-2.34.0}/google/api_core/future/polling.py

@@ -19,8 +19,7 @@ import concurrent.futures
 
 from google.api_core import exceptions
 from google.api_core import retry as retries
-from google.api_core.future import _helpers
-from google.api_core.future import base
+from google.api_core.future import _helpers, base
 
 
 class _OperationNotComplete(Exception):

{google_api_core-2.32.0 → google_api_core-2.34.0}/google/api_core/gapic_v1/__init__.py

@@ -25,9 +25,10 @@ _has_grpc = importlib.util.find_spec("grpc") is not None
 # Older Python versions safely ignore this variable.
 __lazy_modules__: Set[str] = {
     "google.api_core.gapic_v1.client_info",
+    "google.api_core.gapic_v1.requests",
     "google.api_core.gapic_v1.routing_header",
 }
-__all__ = ["client_info", "routing_header"]
+__all__ = ["client_info", "requests", "routing_header"]
 
 if _has_grpc:
     __lazy_modules__.update(
@@ -41,6 +42,7 @@ if _has_grpc:
 
 from google.api_core.gapic_v1 import (  # noqa: E402
     client_info,
+    requests,
     routing_header,
 )
 

{google_api_core-2.32.0 → google_api_core-2.34.0}/google/api_core/gapic_v1/client_info.py

@@ -20,7 +20,6 @@ such as the library and Python version, to API services.
 
 from google.api_core import client_info
 
-
 METRICS_METADATA_KEY = "x-goog-api-client"
 
 

{google_api_core-2.32.0 → google_api_core-2.34.0}/google/api_core/gapic_v1/config.py

@@ -22,10 +22,7 @@ import collections
 
 import grpc
 
-from google.api_core import exceptions
-from google.api_core import retry
-from google.api_core import timeout
-
+from google.api_core import exceptions, retry, timeout
 
 _MILLIS_PER_SECOND = 1000.0
 

{google_api_core-2.32.0 → google_api_core-2.34.0}/google/api_core/gapic_v1/method.py

@@ -20,6 +20,7 @@ compression, pagination, and long-running operations to gRPC methods.
 
 import enum
 import functools
+from typing import List, Tuple
 
 from google.api_core import grpc_helpers
 from google.api_core.gapic_v1 import client_info
@@ -57,6 +58,52 @@ def _apply_decorators(func, decorators):
     return func
 
 
+def _deduplicate_metadata_tokens(*headers: str | None) -> str:
+    """
+    Given one or more metadata payload strings, create a combined
+    string with deduplicated tokens, while preserving token order.
+
+    Inputs are expected to contain a set of metadata tokens separated by spaces
+    Example: `gl-python/3.14.0 grpc/1.76.0 gax/2.29.0 gapic/3.8.0 pb/6.33.4`
+
+    Args:
+      *headers: one or more metadata payload strings
+
+    Returns:
+        a single combined payload string
+    """
+    # Split all non-empty headers into individual tokens
+    token_list = " ".join(filter(None, headers)).split()
+    # Deduplicate while preserving order
+    return " ".join(dict.fromkeys(token_list))
+
+
+def _extract_metrics_header(metadata) -> Tuple[str, List[Tuple[str, str]]]:
+    """Extract x-google-api-client header from metadata list.
+
+    Args:
+        metadata (Sequence[Tuple[str, str]]): The metadata to extract from.
+
+    Returns:
+        A tuple containing:
+            - a string representing the header value.
+            - A sequence of remaining metadata tuples.
+    """
+    if not metadata:
+        return "", []
+
+    key_to_find = client_info.METRICS_METADATA_KEY
+
+    metric_str = _deduplicate_metadata_tokens(
+        " ".join([v for k, v in metadata if k == key_to_find])
+    )
+    if not metric_str:
+        return "", list(metadata)
+
+    arbitrary_metadata = [item for item in metadata if item[0] != key_to_find]
+    return metric_str, arbitrary_metadata
+
+
 class _GapicCallable(object):
     """Callable that applies retry, timeout, and metadata logic.
 
@@ -90,7 +137,16 @@ class _GapicCallable(object):
         self._retry = retry
         self._timeout = timeout
         self._compression = compression
-        self._metadata = metadata
+        # Pre-extract the x-goog-api-client header from the initialized metadata.
+        self._x_goog_api_client, remaining = _extract_metrics_header(metadata)
+        self._static_metadata = tuple(remaining)
+        if self._x_goog_api_client:
+            self._default_metadata = (
+                (client_info.METRICS_METADATA_KEY, self._x_goog_api_client),
+                *self._static_metadata,
+            )
+        else:
+            self._default_metadata = self._static_metadata
 
     def __call__(
         self, *args, timeout=DEFAULT, retry=DEFAULT, compression=DEFAULT, **kwargs
@@ -112,16 +168,21 @@ class _GapicCallable(object):
         # Apply all applicable decorators.
         wrapped_func = _apply_decorators(self._target, [retry, timeout])
 
-        # Add the user agent metadata to the call.
-        if self._metadata is not None:
-            metadata = kwargs.get("metadata", [])
-            # Due to the nature of invocation, None should be treated the same
-            # as not specified.
-            if metadata is None:
-                metadata = []
-            metadata = list(metadata)
-            metadata.extend(self._metadata)
-            kwargs["metadata"] = metadata
+        if user_metadata := kwargs.get("metadata"):
+            # Add the user agent metadata to the call.
+            final_metadata = list(self._static_metadata)
+            user_x_goog, remaining = _extract_metrics_header(user_metadata)
+
+            merged_header = _deduplicate_metadata_tokens(
+                self._x_goog_api_client, user_x_goog
+            )
+            if merged_header:
+                final_metadata.append((client_info.METRICS_METADATA_KEY, merged_header))
+            final_metadata.extend(remaining)
+            kwargs["metadata"] = final_metadata
+        elif self._default_metadata:
+            kwargs["metadata"] = self._default_metadata
+
         if self._compression is not None:
             kwargs["compression"] = compression
 

{google_api_core-2.32.0 → google_api_core-2.34.0}/google/api_core/gapic_v1/method_async.py

@@ -21,9 +21,11 @@ import functools
 
 from google.api_core import grpc_helpers_async
 from google.api_core.gapic_v1 import client_info
-from google.api_core.gapic_v1.method import _GapicCallable
-from google.api_core.gapic_v1.method import DEFAULT  # noqa: F401
-from google.api_core.gapic_v1.method import USE_DEFAULT_METADATA  # noqa: F401
+from google.api_core.gapic_v1.method import (  # noqa: F401
+    DEFAULT,
+    USE_DEFAULT_METADATA,
+    _GapicCallable,
+)
 
 _DEFAULT_ASYNC_TRANSPORT_KIND = "grpc_asyncio"
 

google_api_core-2.34.0/google/api_core/gapic_v1/requests.py

@@ -0,0 +1,100 @@
+# -*- coding: utf-8 -*-
+# Copyright 2026 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.
+#
+
+"""Helpers for preparing and structuring API requests.
+
+This module provides utilities to preprocess request parameters and objects
+before invoking API methods, such as automatically generating request IDs
+if they are not already set.
+"""
+
+import uuid
+from typing import TYPE_CHECKING, Union
+
+import google.protobuf.message
+
+if TYPE_CHECKING:  # pragma: NO COVER
+    import proto  # type: ignore[import-untyped]
+
+
+def setup_request_id(
+    request: Union[google.protobuf.message.Message, "proto.Message", dict, None],
+    field_name: str,
+    is_proto3_optional: bool,
+) -> None:
+    """Populate a UUID4 field in the request if it is not already set.
+
+    This helper is used to ensure request idempotency by automatically
+    generating a unique identifier (such as `request_id`) for requests
+    that support it. If a request is retried, the same identifier can be
+    sent on subsequent retries, allowing the server to recognize the retried
+    request and prevent duplicate processing (e.g., creating duplicate
+    resources).
+
+    Args:
+        request (Union[google.protobuf.message.Message, proto.Message, dict, None]): The
+            request object or dictionary.
+        field_name (str): The name of the field to populate (e.g., "request_id").
+        is_proto3_optional (bool): Whether the field supports explicit presence
+            (defined with `optional` in proto3 syntax). When True, empty strings ("")
+            are preserved as explicit user input per AIP-4235, and UUID auto-population
+            occurs only if the field is unset. When False, any empty or falsy value is
+            populated with a UUID.
+    """
+    if request is None:
+        return
+
+    # Evaluate whether the field is considered "unset" and needs auto-population.
+    #
+    # According to AIP-4235, optional request ID fields must be populated
+    # if and only if they have explicit presence (`is_proto3_optional=True`)
+    # and were not set by the user (i.e. unset). Explicitly provided empty
+    # strings ('') must be preserved when `is_proto3_optional=True`.
+    should_populate = False
+    if isinstance(request, dict):
+        if is_proto3_optional:
+            # Case 1a: Dictionary request with explicit presence (`is_proto3_optional=True`).
+            # Per AIP-4235, auto-populate only if the key is completely missing from
+            # the dictionary or its value is explicitly set to None.
+            # An explicit empty string ('') must NOT be overwritten.
+            should_populate = field_name not in request or request[field_name] is None
+        else:
+            # Case 1b: Dictionary request without explicit presence (`is_proto3_optional=False`).
+            # Auto-populate if the key is missing, None, or falsy (e.g., empty string '').
+            should_populate = not request.get(field_name)
+    else:
+        if is_proto3_optional:
+            # Case 2a: Proto request with explicit presence (`is_proto3_optional=True`)
+            # (proto-plus wrapper or pure protobuf message).
+            # Extract the protobuf from proto-plus if wrapped.
+            pure_pb: google.protobuf.message.Message = getattr(request, "_pb", request)
+            try:
+                should_populate = not pure_pb.HasField(field_name)
+            except (AttributeError, ValueError):
+                # Fall back if `HasField` fails or is unsupported.
+                should_populate = getattr(pure_pb, field_name, None) is None
+        else:
+            # Case 2b: Proto request without explicit presence (`is_proto3_optional=False`).
+            # Auto-populate if the field value is falsy (None or empty string '').
+            should_populate = not bool(getattr(request, field_name, False))
+
+    # If the field was found to be empty, set random id
+    if should_populate:
+        generated_id = str(uuid.uuid4())
+        if isinstance(request, dict):
+            request[field_name] = generated_id
+        else:
+            setattr(request, field_name, generated_id)

{google_api_core-2.32.0 → google_api_core-2.34.0}/google/api_core/grpc_helpers.py

@@ -13,10 +13,11 @@
 # limitations under the License.
 
 """Helpers for :mod:`grpc`."""
+
 import collections
 import functools
-from typing import Generic, Iterator, Optional, TypeVar
 import warnings
+from typing import Generic, Iterator, Optional, TypeVar
 
 import google.auth
 import google.auth.credentials
@@ -27,7 +28,6 @@ import grpc
 
 from google.api_core import exceptions, general_helpers
 
-
 # The list of gRPC Callable interfaces that return iterators.
 _STREAM_WRAP_CLASSES = (grpc.UnaryStreamMultiCallable, grpc.StreamStreamMultiCallable)
 
@@ -254,11 +254,20 @@ def _create_composite_credentials(
     request = google.auth.transport.requests.Request()
 
     # Create the metadata plugin for inserting the authorization header.
-    metadata_plugin = google.auth.transport.grpc.AuthMetadataPlugin(
-        credentials,
-        request,
-        default_host=default_host,
-    )
+    try:
+        metadata_plugin = google.auth.transport.grpc.AuthMetadataPlugin(
+            credentials,
+            request,
+            default_host=default_host,
+            suppress_metrics_header=True,
+        )
+    except TypeError:
+        # Support older versions of google-auth that do not accept suppress_metrics_header
+        metadata_plugin = google.auth.transport.grpc.AuthMetadataPlugin(
+            credentials,
+            request,
+            default_host=default_host,
+        )
 
     # Create a set of grpc.CallCredentials using the metadata plugin.
     google_auth_credentials = grpc.metadata_call_credentials(metadata_plugin)

{google_api_core-2.32.0 → google_api_core-2.34.0}/google/api_core/grpc_helpers_async.py

@@ -21,7 +21,6 @@ functions. This module is implementing the same surface with AsyncIO semantics.
 import asyncio
 import functools
 import warnings
-
 from typing import AsyncGenerator, Generic, Iterator, Optional, TypeVar
 
 import grpc

{google_api_core-2.32.0 → google_api_core-2.34.0}/google/api_core/operation.py

@@ -39,13 +39,13 @@ Or asynchronously using callbacks and :meth:`Operation.add_done_callback`:
 import functools
 import threading
 
-from google.api_core import exceptions
-from google.api_core import protobuf_helpers
-from google.api_core.future import polling
 from google.longrunning import operations_pb2
 from google.protobuf import json_format
 from google.rpc import code_pb2
 
+from google.api_core import exceptions, protobuf_helpers
+from google.api_core.future import polling
+
 
 class Operation(polling.PollingFuture):
     """A Future for interacting with a Google API Long-Running Operation.