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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: google-api-core
-Version: 2.35.0
+Version: 2.36.0
 Summary: Google API client core library
 Author-email: Google LLC <googleapis-packages@google.com>
 License: Apache 2.0
@@ -27,6 +27,7 @@ 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
+Requires-Dist: opentelemetry-api<2.0.0,>=1.44.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"
@@ -35,6 +36,10 @@ 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.59.0; extra == "grpc"
 Requires-Dist: grpcio-status<2.0.0,>=1.75.1; python_version >= "3.14" and extra == "grpc"
+Provides-Extra: tracing
+Requires-Dist: opentelemetry-instrumentation-grpc<1.0.0,>=0.65b0; extra == "tracing"
+Provides-Extra: testing
+Requires-Dist: opentelemetry-sdk<2.0.0,>=1.44.0; extra == "testing"
 Dynamic: license-file
 
 Core Library for Google Client Libraries

google_api_core-2.36.0/google/api_core/_observability.py

@@ -0,0 +1,135 @@
+# -*- 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.
+#
+
+"""OpenTelemetry helpers for resolving and instantiating interceptors."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Callable, Sequence
+
+from google.api_core import _feature_gating_helpers
+from google.api_core.client_options import ClientOptions
+
+if TYPE_CHECKING:
+    # flake8: grpc, trace, and ClientInterceptor are imported only for static analysis and type annotations
+    # The `# noqa: F401` comment avoids flake8 "imported but not used" errors.
+    import grpc  # noqa: F401
+    import opentelemetry.trace  # noqa: F401
+
+    from google.api_core.grpc_helpers import ClientInterceptor  # noqa: F401
+
+_TRACER_PROVIDER = "tracer_provider"
+
+
+def is_otel_capabilities_enabled(
+    client_options: ClientOptions | dict[str, Any] | None = None,
+    env_var: str = "GOOGLE_SDK_EXPERIMENTAL_PYTHON_TRACING_ENABLED",
+) -> bool:
+    """Checks if OTel capabilities are enabled and installed.
+
+    Args:
+        client_options: The client options object or dictionary.
+        env_var: The environment variable to check for enablement.
+
+    Returns:
+        bool: True if enabled and installed, False otherwise.
+    """
+    is_tracing_enabled = _feature_gating_helpers.resolve_feature_flags(
+        env_var=env_var,
+        feature_key=_TRACER_PROVIDER,
+        configuration=client_options,
+    )
+
+    if is_tracing_enabled:
+        try:
+            import opentelemetry.instrumentation.grpc as otel_grpc  # type: ignore[import-not-found] # noqa: F401
+
+            return True
+        except ImportError:
+            pass
+
+    return False
+
+
+def _get_tracer_provider(
+    client_options: ClientOptions | dict[str, Any] | None = None,
+) -> opentelemetry.trace.TracerProvider | None:
+    """Extracts the OpenTelemetry tracer provider from client options if present.
+
+    Args:
+        client_options: The client options object or dictionary.
+
+    Returns:
+        opentelemetry.trace.TracerProvider | None: The tracer provider if present,
+            None otherwise.
+    """
+    if isinstance(client_options, dict):
+        return client_options.get(_TRACER_PROVIDER)
+    elif client_options is not None:
+        return getattr(client_options, _TRACER_PROVIDER, None)
+    return None
+
+
+def get_otel_interceptor(
+    client_options: ClientOptions | dict[str, Any] | None = None,
+) -> Callable[[grpc.Channel], grpc.Channel] | None:
+    """Returns an interceptor callable that wraps a sync gRPC channel with OpenTelemetry tracing.
+
+    Args:
+        client_options: The client options object or dictionary used for feature gating
+            and extracting the tracer provider.
+
+    Returns:
+        Callable[[grpc.Channel], grpc.Channel] | None: An interceptor callable if OpenTelemetry
+            tracing is enabled and installed, None otherwise.
+    """
+    if not is_otel_capabilities_enabled(client_options):
+        return None
+
+    import opentelemetry.instrumentation.grpc as otel_grpc  # type: ignore[import-not-found]
+
+    interceptor: ClientInterceptor = otel_grpc.client_interceptor(
+        tracer_provider=_get_tracer_provider(client_options)
+    )
+
+    def otel_interceptor(channel: grpc.Channel) -> grpc.Channel:
+        return otel_grpc.intercept_channel(channel, interceptor)
+
+    return otel_interceptor
+
+
+def get_otel_async_interceptor(
+    client_options: ClientOptions | dict[str, Any] | None = None,
+) -> Sequence[grpc.aio.ClientInterceptor] | None:
+    """Returns async gRPC client interceptors for OpenTelemetry tracing.
+
+    Args:
+        client_options: The client options object or dictionary used for feature gating
+            and extracting the tracer provider.
+
+    Returns:
+        Sequence[grpc.aio.ClientInterceptor] | None: Instantiated OpenTelemetry async
+            client interceptors if tracing is enabled and installed, None otherwise.
+    """
+    if not is_otel_capabilities_enabled(client_options):
+        return None
+
+    # Ignored by mypy: Optional dependency only loaded if early-return is skipped
+    import opentelemetry.instrumentation.grpc as otel_grpc  # type: ignore[import-not-found]
+
+    return otel_grpc.aio_client_interceptors(
+        tracer_provider=_get_tracer_provider(client_options)
+    )

{google_api_core-2.35.0 → google_api_core-2.36.0}/google/api_core/client_options.py

@@ -48,9 +48,13 @@ You can also pass a mapping object.
 
 """
 
+import typing
 import warnings
 from typing import Callable, Mapping, Optional, Sequence, Tuple
 
+if typing.TYPE_CHECKING:
+    import opentelemetry.trace
+
 from google.api_core import general_helpers
 
 
@@ -98,6 +102,8 @@ class ClientOptions(object):
             `googleapis.com`. If both `api_endpoint` and `universe_domain` are set,
             then `api_endpoint` is used as the service endpoint. If `api_endpoint` is
             not specified, the format will be `{service}.{universe_domain}`.
+        tracer_provider (Optional["opentelemetry.trace.TracerProvider"]): The OpenTelemetry tracer provider to use
+            for tracing in supported libraries.
 
     Raises:
         ValueError: If both ``client_cert_source`` and ``client_encrypted_cert_source``
@@ -117,6 +123,7 @@ class ClientOptions(object):
         api_key: Optional[str] = None,
         api_audience: Optional[str] = None,
         universe_domain: Optional[str] = None,
+        tracer_provider: Optional["opentelemetry.trace.TracerProvider"] = None,
     ):
         if credentials_file is not None:
             warnings.warn(general_helpers._CREDENTIALS_FILE_WARNING, DeprecationWarning)
@@ -136,6 +143,7 @@ class ClientOptions(object):
         self.api_key = api_key
         self.api_audience = api_audience
         self.universe_domain = universe_domain
+        self.tracer_provider = tracer_provider
 
     def __repr__(self) -> str:
         return "ClientOptions: " + repr(self.__dict__)

{google_api_core-2.35.0 → google_api_core-2.36.0}/google/api_core/exceptions.py

@@ -510,6 +510,8 @@ def format_http_response_error(
             :class:`GoogleAPICallError`, with the message and errors populated
             from the response.
     """
+    if isinstance(payload, list):
+        payload = next((item for item in payload if isinstance(item, dict)), {})
     payload = {} if not payload else payload
     error_message = payload.get("error", {}).get("message", "unknown error")
     errors = payload.get("error", {}).get("errors", ())

{google_api_core-2.35.0 → google_api_core-2.36.0}/google/api_core/grpc_helpers.py

@@ -17,7 +17,17 @@
 import collections
 import functools
 import warnings
-from typing import Generic, Iterator, Optional, TypeVar
+from typing import (
+    Callable,
+    Generic,
+    Iterator,
+    Optional,
+    Sequence,
+    TypeAlias,
+    TypeVar,
+    cast,
+    get_args,
+)
 
 import google.auth
 import google.auth.credentials
@@ -34,6 +44,17 @@ _STREAM_WRAP_CLASSES = (grpc.UnaryStreamMultiCallable, grpc.StreamStreamMultiCal
 # denotes the proto response type for grpc calls
 P = TypeVar("P")
 
+# Type alias representing any client-side gRPC interceptor
+ClientInterceptor: TypeAlias = (
+    grpc.UnaryUnaryClientInterceptor
+    | grpc.UnaryStreamClientInterceptor
+    | grpc.StreamUnaryClientInterceptor
+    | grpc.StreamStreamClientInterceptor
+)
+
+# Runtime tuple of gRPC client interceptor base classes for isinstance checks
+_CLIENT_INTERCEPTOR_CLASSES = get_args(ClientInterceptor)
+
 
 def _patch_callable_name(callable_):
     """Fix-up gRPC callable attributes.
@@ -419,6 +440,52 @@ def _modify_target_for_direct_path(target: str) -> str:
     return target
 
 
+def apply_channel_interceptors(
+    channel: grpc.Channel,
+    interceptors: (
+        Sequence[ClientInterceptor | Callable[[grpc.Channel], grpc.Channel]] | None
+    ) = None,
+) -> grpc.Channel:
+    """Applies client interceptors or channel-intercepting callables to a gRPC channel.
+
+    Executes in reverse order so the first interceptor in the sequence becomes the
+    outermost layer on outbound requests and the innermost layer on inbound responses,
+    aligning with the behavior of ``grpc.intercept_channel``.
+
+    Args:
+        channel (grpc.Channel): The channel to intercept.
+        interceptors (Optional[Sequence[Union[ClientInterceptor, Callable[[grpc.Channel], grpc.Channel]]]]):
+            Additional interceptors (or callables that apply interceptors) to apply to the gRPC channel.
+
+    Returns:
+        grpc.Channel: The intercepted channel, or the original channel if no
+            interceptors were provided.
+
+    Raises:
+        TypeError: If an item in ``interceptors`` is neither a gRPC ClientInterceptor
+            nor a Callable[[Channel], Channel].
+    """
+    if not interceptors:
+        return channel
+
+    modified_channel = channel
+    # Reverse the inputs to align with the behavior of grpc.create_channel(*interceptors)
+    for interceptor in reversed(list(interceptors)):
+        if isinstance(interceptor, _CLIENT_INTERCEPTOR_CLASSES):
+            modified_channel = grpc.intercept_channel(modified_channel, interceptor)
+        elif callable(interceptor):
+            interceptor_callable = cast(
+                Callable[[grpc.Channel], grpc.Channel], interceptor
+            )
+            modified_channel = interceptor_callable(modified_channel)
+        else:
+            raise TypeError(
+                f"Expected ClientInterceptor or Callable[[Channel], Channel], got {type(interceptor).__name__}"
+            )
+
+    return modified_channel
+
+
 _MethodCall = collections.namedtuple(
     "_MethodCall", ("request", "timeout", "metadata", "credentials", "compression")
 )

{google_api_core-2.35.0 → google_api_core-2.36.0}/google/api_core/path_template.py

@@ -123,7 +123,7 @@ def _expand_variable_match(positional_vars, named_vars, match):
         try:
             val = str(named_vars[name])
             _extract_and_validate_wildcards(val, template, name)
-            return urllib.parse.quote(val, safe="/")
+            return val
         except KeyError:
             raise ValueError(
                 "Named variable '{}' not specified and needed by template "
@@ -133,7 +133,7 @@ def _expand_variable_match(positional_vars, named_vars, match):
         try:
             val = str(positional_vars.pop(0))
             _extract_and_validate_wildcards(val, positional, "positional variable")
-            return urllib.parse.quote(val, safe="/")
+            return val
         except IndexError:
             raise ValueError(
                 "Positional variable not specified and needed by template "
@@ -215,12 +215,17 @@ def _generate_pattern_for_template(tmpl):
     return _VARIABLE_RE.sub(_replace_variable_with_pattern, tmpl)
 
 
-def get_field(request, field):
+def get_field(request, field, encode=False):
     """Get the value of a field from a given dictionary.
 
     Args:
         request (dict | Message): A dictionary or a Message object.
         field (str): The key to the request in dot notation.
+        encode (bool): Whether to percent-encode the field value. If enabled,
+            will encode all characters except `[-_.~/0-9a-zA-Z]` for URI path
+            variable parts per
+            https://github.com/googleapis/googleapis/blob/master/google/api/http.proto#L44-L312.
+            Defaults to False.
 
     Returns:
         The value of the field.
@@ -235,6 +240,8 @@ def get_field(request, field):
             value = value.get(part)
     if isinstance(value, dict):
         return
+    if encode and value is not None:
+        return urllib.parse.quote(str(value), safe="/")
     return value
 
 
@@ -327,7 +334,10 @@ def transcode(http_options, message=None, **request_kwargs):
         ]
         bindings.append((uri_template, fields))
 
-        path_args = {field: get_field(transcoded_value, field) for field, _ in fields}
+        path_args = {
+            field: get_field(transcoded_value, field, encode=True)
+            for field, _ in fields
+        }
         request["uri"] = expand(uri_template, **path_args)
 
         if not validate(uri_template, request["uri"]) or not all(path_args.values()):

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

@@ -19,9 +19,10 @@ 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
 
+from google.api_core import path_template
+
 __all__ = ["flatten_query_params", "transcode", "transcode_request"]
 
 

{google_api_core-2.35.0 → google_api_core-2.36.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.35.0"
+__version__ = "2.36.0"

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: google-api-core
-Version: 2.35.0
+Version: 2.36.0
 Summary: Google API client core library
 Author-email: Google LLC <googleapis-packages@google.com>
 License: Apache 2.0
@@ -27,6 +27,7 @@ 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
+Requires-Dist: opentelemetry-api<2.0.0,>=1.44.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"
@@ -35,6 +36,10 @@ 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.59.0; extra == "grpc"
 Requires-Dist: grpcio-status<2.0.0,>=1.75.1; python_version >= "3.14" and extra == "grpc"
+Provides-Extra: tracing
+Requires-Dist: opentelemetry-instrumentation-grpc<1.0.0,>=0.65b0; extra == "tracing"
+Provides-Extra: testing
+Requires-Dist: opentelemetry-sdk<2.0.0,>=1.44.0; extra == "testing"
 Dynamic: license-file
 
 Core Library for Google Client Libraries

{google_api_core-2.35.0 → google_api_core-2.36.0}/google_api_core.egg-info/SOURCES.txt

@@ -6,6 +6,7 @@ setup.cfg
 setup.py
 google/api_core/__init__.py
 google/api_core/_feature_gating_helpers.py
+google/api_core/_observability.py
 google/api_core/_python_package_support.py
 google/api_core/_python_version_support.py
 google/api_core/_rest_streaming_base.py
@@ -104,6 +105,7 @@ tests/unit/test_extended_operation.py
 tests/unit/test_feature_gating_helpers.py
 tests/unit/test_grpc_helpers.py
 tests/unit/test_iam.py
+tests/unit/test_observability.py
 tests/unit/test_operation.py
 tests/unit/test_packaging.py
 tests/unit/test_page_iterator.py

{google_api_core-2.35.0 → google_api_core-2.36.0}/google_api_core.egg-info/requires.txt

@@ -3,6 +3,7 @@ protobuf<8.0.0,>=6.33.5
 proto-plus<2.0.0,>=1.26.1
 google-auth<3.0.0,>=2.14.1
 requests<3.0.0,>=2.33.0
+opentelemetry-api<2.0.0,>=1.44.0
 
 [async_rest]
 google-auth[aiohttp]<3.0.0,>=2.14.1
@@ -15,3 +16,9 @@ grpcio-status<2.0.0,>=1.59.0
 [grpc:python_version >= "3.14"]
 grpcio<2.0.0,>=1.75.1
 grpcio-status<2.0.0,>=1.75.1
+
+[testing]
+opentelemetry-sdk<2.0.0,>=1.44.0
+
+[tracing]
+opentelemetry-instrumentation-grpc<1.0.0,>=0.65b0

{google_api_core-2.35.0 → google_api_core-2.36.0}/pyproject.toml

@@ -48,6 +48,7 @@ dependencies = [
   "proto-plus >= 1.26.1, < 2.0.0",
   "google-auth >= 2.14.1, < 3.0.0",
   "requests >= 2.33.0, < 3.0.0",
+  "opentelemetry-api >= 1.44.0, < 2.0.0",
 ]
 dynamic = ["version"]
 
@@ -64,6 +65,12 @@ grpc = [
   "grpcio-status >= 1.59.0, < 2.0.0",
   "grpcio-status >= 1.75.1, < 2.0.0; python_version >= '3.14'",
 ]
+tracing = [
+  "opentelemetry-instrumentation-grpc >= 0.65b0, < 1.0.0",
+]
+testing = [
+  "opentelemetry-sdk >= 1.44.0, < 2.0.0",
+]
 
 
 [tool.setuptools.dynamic]

{google_api_core-2.35.0 → google_api_core-2.36.0}/tests/unit/test_client_options.py

@@ -30,6 +30,7 @@ def get_client_encrypted_cert():
 
 
 def test_constructor():
+    mock_tracer_provider = object()
     with warn_deprecated_credentials_file():
         options = client_options.ClientOptions(
             api_endpoint="foo.googleapis.com",
@@ -42,6 +43,7 @@ def test_constructor():
             ],
             api_audience="foo2.googleapis.com",
             universe_domain="googleapis.com",
+            tracer_provider=mock_tracer_provider,
         )
 
     assert options.api_endpoint == "foo.googleapis.com"
@@ -54,6 +56,7 @@ def test_constructor():
     ]
     assert options.api_audience == "foo2.googleapis.com"
     assert options.universe_domain == "googleapis.com"
+    assert options.tracer_provider is mock_tracer_provider
 
 
 def test_constructor_with_encrypted_cert_source():
@@ -162,6 +165,7 @@ def test_repr():
             "scopes",
             "api_key",
             "api_audience",
+            "tracer_provider",
         ]
     )
     options = client_options.ClientOptions(api_endpoint="foo.googleapis.com")

{google_api_core-2.35.0 → google_api_core-2.36.0}/tests/unit/test_exceptions.py

@@ -132,6 +132,31 @@ def test_from_http_response_json_content():
     assert exception.errors == ["1", "2"]
 
 
+def test_from_http_response_json_list_content():
+    response = make_response(
+        json.dumps(
+            [{"error": {"message": "json message", "errors": ["1", "2"]}}]
+        ).encode("utf-8")
+    )
+
+    exception = exceptions.from_http_response(response)
+
+    assert isinstance(exception, exceptions.NotFound)
+    assert exception.code == http.client.NOT_FOUND
+    assert exception.message == "POST https://example.com/: json message"
+    assert exception.errors == ["1", "2"]
+
+
+def test_from_http_response_json_list_content_without_error_dict():
+    response = make_response(json.dumps(["error message"]).encode("utf-8"))
+
+    exception = exceptions.from_http_response(response)
+
+    assert isinstance(exception, exceptions.NotFound)
+    assert exception.code == http.client.NOT_FOUND
+    assert exception.message == "POST https://example.com/: unknown error"
+
+
 def test_from_http_response_bad_json_content():
     response = make_response(json.dumps({"meep": "moop"}).encode("utf-8"))
 

{google_api_core-2.35.0 → google_api_core-2.36.0}/tests/unit/test_feature_gating_helpers.py

@@ -13,6 +13,7 @@
 # limitations under the License.
 
 import pytest
+
 from google.api_core import _feature_gating_helpers
 from google.api_core._feature_gating_helpers import (
     FeatureGatingError,

{google_api_core-2.35.0 → google_api_core-2.36.0}/tests/unit/test_grpc_helpers.py

@@ -932,3 +932,104 @@ class TestChannelStub(object):
     def test_close(self):
         channel = grpc_helpers.ChannelStub()
         assert channel.close() is None
+
+
+@pytest.mark.parametrize("falsy_interceptors", [None, [], ()])
+def test_apply_channel_interceptors_passthrough(falsy_interceptors):
+    """Verify that falsy or empty interceptor sequences return the channel unmodified."""
+    mock_base_channel = mock.Mock(name="base_channel")
+    result = grpc_helpers.apply_channel_interceptors(
+        mock_base_channel, falsy_interceptors
+    )
+    assert result is mock_base_channel
+
+
+def test_apply_channel_interceptors_grpc_client_interceptors():
+    """Verify that standard gRPC ClientInterceptor instances are applied via grpc.intercept_channel."""
+
+    class DummyUnaryInterceptor(grpc.UnaryUnaryClientInterceptor):
+        def intercept_unary_unary(self, continuation, client_call_details, request):
+            return continuation(client_call_details, request)
+
+    class DummyStreamInterceptor(grpc.StreamStreamClientInterceptor):
+        def intercept_stream_stream(
+            self, continuation, client_call_details, request_iterator
+        ):
+            return continuation(client_call_details, request_iterator)
+
+    interceptor1 = DummyUnaryInterceptor()
+    interceptor2 = DummyStreamInterceptor()
+
+    mock_base_channel = mock.Mock(name="base_channel")
+    mock_chan_after_i2 = mock.Mock(name="chan_after_i2")
+    mock_chan_after_i1 = mock.Mock(name="chan_after_i1")
+
+    with mock.patch(
+        "grpc.intercept_channel",
+        side_effect=[mock_chan_after_i2, mock_chan_after_i1],
+    ) as mock_intercept:
+        result = grpc_helpers.apply_channel_interceptors(
+            mock_base_channel, [interceptor1, interceptor2]
+        )
+
+    assert result is mock_chan_after_i1
+    assert mock_intercept.call_count == 2
+    # Executed in reverse order so interceptor1 is outermost
+    mock_intercept.assert_has_calls(
+        [
+            mock.call(mock_base_channel, interceptor2),
+            mock.call(mock_chan_after_i2, interceptor1),
+        ]
+    )
+
+
+def test_apply_channel_interceptors_callables():
+    """Verify that channel-intercepting callables Callable[[Channel], Channel] are invoked in sequence."""
+    mock_base_channel = mock.Mock(name="base_channel")
+    mock_chan_1 = mock.Mock(name="chan_1")
+    mock_chan_2 = mock.Mock(name="chan_2")
+
+    interceptor1 = mock.Mock(side_effect=lambda ch: mock_chan_2)
+    interceptor2 = mock.Mock(side_effect=lambda ch: mock_chan_1)
+
+    result = grpc_helpers.apply_channel_interceptors(
+        mock_base_channel, [interceptor1, interceptor2]
+    )
+
+    assert result is mock_chan_2
+    # Executed in reverse order: interceptor2 runs first on base channel, then interceptor1
+    interceptor2.assert_called_once_with(mock_base_channel)
+    interceptor1.assert_called_once_with(mock_chan_1)
+
+
+def test_apply_channel_interceptors_interspersed():
+    """Verify that a mixed sequence of gRPC interceptors and interceptor callables are applied."""
+
+    class DummyUnaryInterceptor(grpc.UnaryUnaryClientInterceptor):
+        def intercept_unary_unary(self, continuation, client_call_details, request):
+            return continuation(client_call_details, request)
+
+    interceptor = DummyUnaryInterceptor()
+    mock_base_channel = mock.Mock(name="base_channel")
+    mock_chan_after_callable = mock.Mock(name="chan_after_callable")
+    mock_chan_after_interceptor = mock.Mock(name="chan_after_interceptor")
+
+    interceptor_callable = mock.Mock(return_value=mock_chan_after_callable)
+
+    with mock.patch(
+        "grpc.intercept_channel", return_value=mock_chan_after_interceptor
+    ) as mock_intercept:
+        result = grpc_helpers.apply_channel_interceptors(
+            mock_base_channel, [interceptor, interceptor_callable]
+        )
+
+    assert result is mock_chan_after_interceptor
+    interceptor_callable.assert_called_once_with(mock_base_channel)
+    mock_intercept.assert_called_once_with(mock_chan_after_callable, interceptor)
+
+
+def test_apply_channel_interceptors_invalid_type_raises():
+    """Verify that passing an invalid object that is neither an interceptor nor callable raises TypeError."""
+    mock_base_channel = mock.Mock(name="base_channel")
+    with pytest.raises(TypeError, match="Expected ClientInterceptor or Callable"):
+        grpc_helpers.apply_channel_interceptors(mock_base_channel, [12345])