google-api-core 2.33.0__tar.gz → 2.35.0__tar.gz

{google_api_core-2.33.0/google_api_core.egg-info → google_api_core-2.35.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: google-api-core
-Version: 2.33.0
+Version: 2.35.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.35.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.33.0 → google_api_core-2.35.0}/google/api_core/_python_package_support.py

@@ -30,14 +30,37 @@ ParsedVersion = Tuple[int, ...]
 # about deprecated and unsupported versions.
 DependencyConstraint = namedtuple(
     "DependencyConstraint",
-    ["package_name", "minimum_fully_supported_version", "recommended_version"],
+    [
+        "package_name",
+        "minimum_fully_supported_version",
+        "recommended_version",
+        "message_template",
+    ],
+    defaults=(None, None),
 )
+
+PQC_GRPC_WARNING_TEMPLATE = (
+    "Package {consumer_package} depends on {dependency_package}, currently installed at version {version_used_string}. "
+    "grpcio < 1.83.0 does not support Post-Quantum Cryptography (PQC). "
+    "Support for non-PQC environments is deprecated. In October 2026, "
+    "Google Cloud Python packages will raise their minimum requirements "
+    "(including google-api-core, grpcio, and grpcio-status) to enforce grpcio >= 1.83.0. "
+    "For more details on Google Cloud's post-quantum security migration, visit: "
+    "https://cloud.google.com/security/resources/post-quantum-cryptography"
+)
+
 _PACKAGE_DEPENDENCY_WARNINGS = [
     DependencyConstraint(
         "google.protobuf",
-        minimum_fully_supported_version="4.25.8",
+        minimum_fully_supported_version="6.33.5",
         recommended_version="6.x",
-    )
+    ),
+    DependencyConstraint(
+        "grpcio",
+        minimum_fully_supported_version="1.83.0",
+        recommended_version="1.83.x",
+        message_template=PQC_GRPC_WARNING_TEMPLATE,
+    ),
 ]
 
 
@@ -50,7 +73,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:
@@ -162,7 +185,7 @@ def warn_deprecation_for_versions_less_than(
         ) = _get_distribution_and_import_packages(consumer_import_package)
 
         recommendation = (
-            " (we recommend {recommended_version})" if recommended_version else ""
+            f" (we recommend {recommended_version})" if recommended_version else ""
         )
         message_template = message_template or _flatten_message(
             """
@@ -222,4 +245,5 @@ def check_dependency_versions(
             package_info.package_name,
             package_info.minimum_fully_supported_version,
             recommended_version=package_info.recommended_version,
+            message_template=package_info.message_template,
         )

{google_api_core-2.33.0 → google_api_core-2.35.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.35.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.33.0 → google_api_core-2.35.0}/google/api_core/grpc_helpers.py

@@ -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.33.0 → google_api_core-2.35.0}/google/api_core/path_template.py

@@ -28,6 +28,7 @@ from __future__ import unicode_literals
 import copy
 import functools
 import re
+import urllib.parse
 from collections import deque
 
 # Regular expression for extracting variable parts from a path template.
@@ -62,6 +63,41 @@ _SINGLE_SEGMENT_PATTERN = r"([^/]+)"
 _MULTI_SEGMENT_PATTERN = r"(.+)"
 
 
+def _extract_and_validate_wildcards(
+    val: str, template_str: str | None, property_name: str = "property"
+) -> None:
+    """Extract and validate wildcard variables against path traversal.
+
+    Ensures that values matched against single-segment wildcards ('*') are
+    not '.' or '..', and values matched against multi-segment wildcards ('**')
+    do not contain '.' or '..' segments.
+
+    If the value does not match the sub-template structure, validation is
+    deferred to allow subsequent bindings to be evaluated.
+
+    Args:
+        val (str): The raw string value to validate.
+        template_str (str | None): The template string of the variable (e.g.
+            'projects/*/locations/*').
+        property_name (str): The name of the property being validated, for use
+            in error messages.
+
+    Raises:
+        ValueError: If a wildcard value contains invalid dot segments.
+    """
+    tmpl = template_str or "*"
+    m = re.fullmatch(_generate_pattern_for_template(tmpl), val)
+    if m is not None:
+        groups = m.groups()
+        for g in groups:
+            if "." in g and any(seg in (".", "..") for seg in g.split("/")):
+                if "**" in tmpl or "/" in tmpl:
+                    raise ValueError(
+                        f"Value for {property_name} must not contain segments that are exactly . or .. ."
+                    )
+                raise ValueError(f"Invalid value {g} for {property_name}.")
+
+
 def _expand_variable_match(positional_vars, named_vars, match):
     """Expand a matched variable with its value.
 
@@ -81,9 +117,13 @@ def _expand_variable_match(positional_vars, named_vars, match):
     """
     positional = match.group("positional")
     name = match.group("name")
+    template = match.group("template")
+
     if name is not None:
         try:
-            return str(named_vars[name])
+            val = str(named_vars[name])
+            _extract_and_validate_wildcards(val, template, name)
+            return urllib.parse.quote(val, safe="/")
         except KeyError:
             raise ValueError(
                 "Named variable '{}' not specified and needed by template "
@@ -91,7 +131,9 @@ def _expand_variable_match(positional_vars, named_vars, match):
             )
     elif positional is not None:
         try:
-            return str(positional_vars.pop(0))
+            val = str(positional_vars.pop(0))
+            _extract_and_validate_wildcards(val, positional, "positional variable")
+            return urllib.parse.quote(val, safe="/")
         except IndexError:
             raise ValueError(
                 "Positional variable not specified and needed by template "
@@ -159,6 +201,7 @@ def _replace_variable_with_pattern(match):
         raise ValueError("Unknown template expression {}".format(match.group(0)))
 
 
+@functools.lru_cache(maxsize=256)
 def _generate_pattern_for_template(tmpl):
     """Generate a pattern that can validate a path template.
 

{google_api_core-2.33.0 → google_api_core-2.35.0}/google/api_core/rest_helpers.py

@@ -15,7 +15,14 @@
 """Helpers for rest transports."""
 
 import functools
+import json
 import operator
+from typing import Any, Dict, List, Optional, Tuple
+
+from google.api_core import path_template
+from google.protobuf import json_format
+
+__all__ = ["flatten_query_params", "transcode", "transcode_request"]
 
 
 def flatten_query_params(obj, strict=False):
@@ -107,3 +114,64 @@ def _canonicalize(obj, strict=False):
             value = value.lower()
         return value
     return obj
+
+
+def transcode_request(
+    http_options: List[Dict[str, str]],
+    request: Any,
+    required_fields_default_values: Optional[Dict[str, Any]] = None,
+    rest_numeric_enums: bool = False,
+) -> Tuple[Dict[str, Any], Optional[str], Dict[str, Any]]:
+    """Transcodes a request into HTTP method, URI, body, and query parameters.
+
+    Args:
+        http_options (List[Dict[str, str]]): List of HTTP transcoding rules.
+        request (Any): The protobuf or proto-plus request message.
+        required_fields_default_values (Optional[Dict[str, Any]]): Dictionary
+            of required fields default values to merge into query parameters if missing.
+        rest_numeric_enums (bool): Whether to encode enums as integers.
+
+    Returns:
+        Tuple[Dict[str, Any], Optional[str], Dict[str, Any]]: A tuple containing:
+            - The raw transcoded request dictionary (containing keys like 'uri', 'method').
+            - The serialized request body JSON string, or None if no body.
+            - The query parameters dictionary.
+    """
+    if request is None:
+        raise TypeError("request cannot be None")
+
+    # Convert proto-plus message to its underlying protobuf message if needed
+    pb_request = getattr(request, "_pb", request)
+
+    transcoded_request = path_template.transcode(http_options, pb_request)
+
+    body_json = None
+    if transcoded_request.get("body") is not None:
+        body_json = json_format.MessageToJson(
+            transcoded_request["body"],
+            use_integers_for_enums=rest_numeric_enums,
+        )
+
+    query_params_json = {}
+    if transcoded_request.get("query_params") is not None:
+        query_params_json = json.loads(
+            json_format.MessageToJson(
+                transcoded_request["query_params"],
+                use_integers_for_enums=rest_numeric_enums,
+            )
+        )
+
+    # If required_fields_default_values is provided, we merge default values for missing
+    # required fields into the query parameters.
+    if required_fields_default_values:
+        for k, v in required_fields_default_values.items():
+            if k not in query_params_json:
+                query_params_json[k] = v
+
+    if rest_numeric_enums:
+        query_params_json["$alt"] = "json;enum-encoding=int"
+
+    return transcoded_request, body_json, query_params_json
+
+
+transcode = transcode_request

{google_api_core-2.33.0 → google_api_core-2.35.0}/google/api_core/version.py

@@ -12,4 +12,4 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-__version__ = "2.33.0"
+__version__ = "2.35.0"