gapic-generator 1.30.5__py3-none-any.whl → 1.30.7__py3-none-any.whl

gapic/cli/generate.py

@@ -23,6 +23,7 @@ from google.protobuf.compiler import plugin_pb2
 from gapic import generator
 from gapic.schema import api
 from gapic.utils import Options
+from gapic.utils.cache import generation_cache_context
 
 
 @click.command()
@@ -38,7 +39,7 @@ from gapic.utils import Options
     "--output",
     type=click.File("wb"),
     default=sys.stdout.buffer,
-    help="Where to output the `CodeGeneratorResponse`. " "Defaults to stdout.",
+    help="Where to output the `CodeGeneratorResponse`. Defaults to stdout.",
 )
 def generate(request: typing.BinaryIO, output: typing.BinaryIO) -> None:
     """Generate a full API client description."""
@@ -56,15 +57,23 @@ def generate(request: typing.BinaryIO, output: typing.BinaryIO) -> None:
         [p.package for p in req.proto_file if p.name in req.file_to_generate]
     ).rstrip(".")
 
-    # Build the API model object.
-    # This object is a frozen representation of the whole API, and is sent
-    # to each template in the rendering step.
-    api_schema = api.API.build(req.proto_file, opts=opts, package=package)
+    # Create the generation cache context.
+    # This provides the shared storage for the @cached_proto_context decorator.
+    # 1. Performance: Memoizes `with_context` calls, speeding up generation significantly.
+    # 2. Safety: The decorator uses this storage to "pin" Proto objects in memory.
+    #    This prevents Python's Garbage Collector from deleting objects created during
+    #    `API.build` while `Generator.get_response` is still using their IDs.
+    #    (See `gapic.utils.cache.cached_proto_context` for the specific pinning logic).
+    with generation_cache_context():
+        # Build the API model object.
+        # This object is a frozen representation of the whole API, and is sent
+        # to each template in the rendering step.
+        api_schema = api.API.build(req.proto_file, opts=opts, package=package)
 
-    # Translate into a protobuf CodeGeneratorResponse; this reads the
-    # individual templates and renders them.
-    # If there are issues, error out appropriately.
-    res = generator.Generator(opts).get_response(api_schema, opts)
+        # Translate into a protobuf CodeGeneratorResponse; this reads the
+        # individual templates and renders them.
+        # If there are issues, error out appropriately.
+        res = generator.Generator(opts).get_response(api_schema, opts)
 
     # Output the serialized response.
     output.write(res.SerializeToString())

gapic/generator/generator.py

@@ -131,9 +131,7 @@ class Generator:
             )
 
         # Return the CodeGeneratorResponse output.
-        res = CodeGeneratorResponse(
-            file=[i for i in output_files.values()]
-        )  # type: ignore
+        res = CodeGeneratorResponse(file=[i for i in output_files.values()])  # type: ignore
         res.supported_features |= CodeGeneratorResponse.Feature.FEATURE_PROTO3_OPTIONAL  # type: ignore
         return res
 

gapic/samplegen_utils/snippet_index.py

@@ -117,7 +117,9 @@ class SnippetIndex:
         self.metadata_index.client_library.name = (
             api_schema.naming.warehouse_package_name
         )
-        self.metadata_index.client_library.language = snippet_metadata_pb2.Language.PYTHON  # type: ignore
+        self.metadata_index.client_library.language = (
+            snippet_metadata_pb2.Language.PYTHON  # type: ignore
+        )
 
         self.metadata_index.client_library.version = api_schema.gapic_version
 

gapic/samplegen_utils/yaml.py

@@ -116,7 +116,9 @@ class Map(Element):
         return next(
             iter(
                 [
-                    e.val for e in self.elements if e.key == key  # type: ignore
+                    e.val
+                    for e in self.elements
+                    if e.key == key  # type: ignore
                 ]  # type: ignore
             ),
             default,

gapic/schema/api.py

@@ -941,11 +941,7 @@ class API:
             selective_gapic_errors = {}
             # TODO(https://github.com/googleapis/gapic-generator-python/issues/2446):
             # Workaround issue in Python 3.14 related to code coverage by adding `# pragma: no branch`
-            for (
-                method_name
-            ) in (
-                library_settings.python_settings.common.selective_gapic_generation.methods
-            ):  # pragma: no branch
+            for method_name in library_settings.python_settings.common.selective_gapic_generation.methods:  # pragma: no branch
                 if method_name not in self.all_methods:
                     selective_gapic_errors[method_name] = "Method does not exist."
                 elif not method_name.startswith(library_settings.version):
@@ -1180,8 +1176,7 @@ class _ProtoBuilder:
                 object.__setattr__(field, "enum", maybe_enum_type)
             else:
                 raise TypeError(
-                    f"Unknown type referenced in "
-                    f"{self.file_descriptor.name}: '{key}'"
+                    f"Unknown type referenced in {self.file_descriptor.name}: '{key}'"
                 )
 
         # Only generate the service if this is a target file to be generated.

gapic/schema/imp.py

@@ -26,11 +26,21 @@ class Import:
         return self.package == other.package and self.module == other.module
 
     def __str__(self) -> str:
+        # Determine if we need to suppress type checking for this import.
+        # We do this for protobuf generated files (_pb2) and api_core
+        # internals where type information might be missing or incomplete.
+        needs_type_ignore = self.module.endswith("_pb2") or "api_core" in self.package
+        if needs_type_ignore:
+            # Use 'import absolute.path as module' syntax to prevent Ruff/isort
+            # from combining this with other imports. This ensures the
+            # '# type: ignore' comment remains effective for this specific import.
+            full_module = ".".join(self.package + (self.module,))
+            alias = self.alias or self.module
+            return f"import {full_module} as {alias}  # type: ignore"
+
         answer = f"import {self.module}"
         if self.package:
             answer = f"from {'.'.join(self.package)} {answer}"
         if self.alias:
             answer += f" as {self.alias}"
-        if self.module.endswith("_pb2") or "api_core" in self.package:
-            answer += "  # type: ignore"
         return answer

gapic/schema/metadata.py

@@ -35,6 +35,7 @@ from google.protobuf import descriptor_pb2
 from gapic.schema import imp
 from gapic.schema import naming
 from gapic.utils import cached_property
+from gapic.utils import cached_proto_context
 from gapic.utils import RESERVED_NAMES
 
 # This class is a minor hack to optimize Address's __eq__ method.
@@ -356,9 +357,10 @@ class Address(BaseAddress):
             str: An absolute selector.
         """
         if "." not in selector:
-            return f'{".".join(self.package)}.{selector}'
+            return f"{'.'.join(self.package)}.{selector}"
         return selector
 
+    @cached_proto_context
     def with_context(self, *, collisions: Set[str]) -> "Address":
         """Return a derivative of this address with the provided context.
 
@@ -398,6 +400,7 @@ class Metadata:
             return "\n\n".join(self.documentation.leading_detached_comments)
         return ""
 
+    @cached_proto_context
     def with_context(self, *, collisions: Set[str]) -> "Metadata":
         """Return a derivative of this metadata with the provided context.
 

gapic/schema/naming.py

@@ -86,7 +86,7 @@ class Naming(abc.ABC):
                 "The protos provided do not share a common root package. "
                 "Ensure that all explicitly-specified protos are for a "
                 "single API. "
-                f'The packages we got are: {", ".join(proto_packages)}'
+                f"The packages we got are: {', '.join(proto_packages)}"
             )
 
         # Define the valid regex to split the package.

gapic/schema/wrappers.py

@@ -67,6 +67,7 @@ from google.protobuf.json_format import MessageToDict  # type: ignore
 
 from gapic import utils
 from gapic.schema import metadata
+from gapic.utils import cached_proto_context
 from gapic.utils import uri_sample
 from gapic.utils import make_private
 
@@ -410,6 +411,7 @@ class Field:
             "This code should not be reachable; please file a bug."
         )
 
+    @cached_proto_context
     def with_context(
         self,
         *,
@@ -797,7 +799,7 @@ class MessageType:
         # Quick check: If this cursor has no message, there is a problem.
         if not cursor.message:
             raise KeyError(
-                f'Field {".".join(field_path)} could not be resolved from '
+                f"Field {'.'.join(field_path)} could not be resolved from "
                 f"{cursor.name}.",
             )
 
@@ -805,6 +807,7 @@ class MessageType:
         # message.
         return cursor.message.get_field(*field_path[1:], collisions=collisions)
 
+    @cached_proto_context
     def with_context(
         self,
         *,
@@ -937,6 +940,7 @@ class EnumType:
         """Return the identifier data to be used in templates."""
         return self.meta.address
 
+    @cached_proto_context
     def with_context(self, *, collisions: Set[str]) -> "EnumType":
         """Return a derivative of this enum with the provided context.
 
@@ -1058,6 +1062,7 @@ class ExtendedOperationInfo:
     request_type: MessageType
     operation_type: MessageType
 
+    @cached_proto_context
     def with_context(
         self,
         *,
@@ -1127,6 +1132,7 @@ class OperationInfo:
     response_type: MessageType
     metadata_type: MessageType
 
+    @cached_proto_context
     def with_context(
         self,
         *,
@@ -1937,6 +1943,7 @@ class Method:
         """Return True if this method has no return value, False otherwise."""
         return self.output.ident.proto == "google.protobuf.Empty"
 
+    @cached_proto_context
     def with_context(
         self,
         *,
@@ -2357,6 +2364,7 @@ class Service:
     def is_internal(self) -> bool:
         return any(m.is_internal for m in self.methods.values())
 
+    @cached_proto_context
     def with_context(
         self,
         *,

gapic/templates/%namespace/%name_%version/%sub/services/%service/_shared_macros.j2

@@ -196,8 +196,9 @@ def _get_http_options():
         body_spec (str): The http options body i.e. method.http_options[0].body
         method_name (str): The method name.
         service: The service.
-        is_async (bool): Used to determine the code path i.e. whether for sync or async call. #}
-{% macro rest_call_method_common(body_spec, method_name, service, is_async=False, is_proto_plus_type=False) %}
+        is_async (bool): Used to determine the code path i.e. whether for sync or async call.
+        is_request_message_proto_plus_type (bool): Used to determine whether the request message is a proto-plus type. #}
+{% macro rest_call_method_common(body_spec, method_name, service, is_async=False, is_request_message_proto_plus_type=False) %}
 {% set service_name = service.name %}
 {% set await_prefix = "await " if is_async else "" %}
 {% set async_class_prefix = "Async" if is_async else "" %}
@@ -218,7 +219,7 @@ def _get_http_options():
         request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri'])
         method = transcoded_request['method']
         try:
-            request_payload = {% if is_proto_plus_type %}type(request).to_json(request){% else %}json_format.MessageToJson(request){% endif %}
+            request_payload = {% if is_request_message_proto_plus_type %}type(request).to_json(request){% else %}json_format.MessageToJson(request){% endif %}
 
         except:
             {# TODO(https://github.com/googleapis/gapic-generator-python/issues/2282): Remove try/except and correctly parse request payload. #}

gapic/templates/%namespace/%name_%version/%sub/services/%service/async_client.py.j2

@@ -98,7 +98,8 @@ class {{ service.async_client_name }}:
         Returns:
             {{ service.async_client_name }}: The constructed client.
         """
-        return {{ service.client_name }}.from_service_account_info.__func__({{ service.async_client_name }}, info, *args, **kwargs)  # type: ignore
+        sa_info_func = {{ service.client_name }}.from_service_account_info.__func__  # type: ignore
+        return sa_info_func({{ service.async_client_name }}, info, *args, **kwargs)
 
     @classmethod
     def from_service_account_file(cls, filename: str, *args, **kwargs):
@@ -114,7 +115,8 @@ class {{ service.async_client_name }}:
         Returns:
             {{ service.async_client_name }}: The constructed client.
         """
-        return {{ service.client_name }}.from_service_account_file.__func__({{ service.async_client_name }}, filename, *args, **kwargs)  # type: ignore
+        sa_file_func = {{ service.client_name }}.from_service_account_file.__func__  # type: ignore
+        return sa_file_func({{ service.async_client_name }}, filename, *args, **kwargs)
 
     from_service_account_json = from_service_account_file
 

gapic/templates/%namespace/%name_%version/%sub/services/%service/transports/rest.py.j2

@@ -240,7 +240,7 @@ class {{service.name}}RestTransport(_Base{{ service.name }}RestTransport):
             {% endif %}
             """
 
-            {{ shared_macros.rest_call_method_common(body_spec, method.name, service, False, method.output.ident.is_proto_plus_type)|indent(8) }}
+            {{ shared_macros.rest_call_method_common(body_spec, method.name, service, False, method.input.ident.is_proto_plus_type)|indent(8) }}
 
             {% if not method.void %}
             # Return the response

gapic/templates/%namespace/%name_%version/%sub/services/%service/transports/rest_asyncio.py.j2

@@ -202,7 +202,7 @@ class Async{{service.name}}RestTransport(_Base{{ service.name }}RestTransport):
             {% endif %}
             """
 
-            {{ shared_macros.rest_call_method_common(body_spec, method.name, service, True, method.output.ident.is_proto_plus_type)|indent(8) }}
+            {{ shared_macros.rest_call_method_common(body_spec, method.name, service, True, method.input.ident.is_proto_plus_type)|indent(8) }}
 
             {% if not method.void %}
             # Return the response

gapic/templates/docs/common_setup.py.j2

@@ -0,0 +1,35 @@
+{% macro sphinx_imports() -%}
+import logging
+from typing import Any
+{%- endmacro %}
+
+{% macro sphinx_setup() -%}
+class UnexpectedUnindentFilter(logging.Filter):
+    """Filter out warnings about unexpected unindentation following bullet lists."""
+
+    def filter(self, record: logging.LogRecord) -> bool:
+        """Filter the log record.
+
+        Args:
+            record (logging.LogRecord): The log record.
+
+        Returns:
+            bool: False to suppress the warning, True to allow it.
+        """
+        msg = record.getMessage()
+        if "Bullet list ends without a blank line" in msg:
+            return False
+        return True
+
+
+def setup(app: Any) -> None:
+    """Setup the Sphinx application.
+
+    Args:
+        app (Any): The Sphinx application.
+    """
+    # Sphinx's logger is hierarchical. Adding a filter to the
+    # root 'sphinx' logger will catch warnings from all sub-loggers.
+    logger = logging.getLogger('sphinx')
+    logger.addFilter(UnexpectedUnindentFilter())
+{%- endmacro %}

gapic/templates/docs/conf.py.j2

@@ -1,7 +1,7 @@
 {% extends '_base.py.j2' %}
 
 {% block content %}
-
+{% from "docs/common_setup.py.j2" import sphinx_imports, sphinx_setup %}
 #
 # {{ api.naming.warehouse_package_name }} documentation build configuration file
 #
@@ -14,9 +14,11 @@
 # All configuration values have a default; values that are commented out
 # serve to show the default.
 
-import sys
+import logging
 import os
 import shlex
+import sys
+{{ sphinx_imports() }}
 
 # If extensions (or modules to document with autodoc) are in another directory,
 # add these directories to sys.path here. If the directory is relative to the
@@ -372,4 +374,7 @@ napoleon_use_admonition_for_references = False
 napoleon_use_ivar = False
 napoleon_use_param = True
 napoleon_use_rtype = True
+
+# Setup for sphinx behaviors such as warning filters.
+{{ sphinx_setup() }}
 {% endblock %}

gapic/templates/noxfile.py.j2

@@ -12,8 +12,7 @@ import warnings
 
 import nox
 
-BLACK_VERSION = "black[jupyter]==23.7.0"
-ISORT_VERSION = "isort==5.11.0"
+RUFF_VERSION = "ruff==0.14.14"
 
 {% if api.naming.module_namespace %}
 LINT_PATHS = ["docs", "{{ api.naming.module_namespace[0] }}", "tests", "noxfile.py", "setup.py"]
@@ -147,13 +146,18 @@ def lint(session):
     Returns a failure if the linters find linting errors or sufficiently
     serious code quality issues.
     """
-    session.install("flake8", BLACK_VERSION)
+    session.install("flake8", RUFF_VERSION)
+
+    # 2. Check formatting
     session.run(
-        "black",
+        "ruff", "format",
         "--check",
+        f"--target-version=py{ALL_PYTHON[0].replace('.', '')}",
+        "--line-length=88", 
         *LINT_PATHS,
     )
 
+
 {% if api.naming.module_namespace %}
     session.run("flake8", "{{ api.naming.module_namespace[0] }}", "tests")
 {% else %}
@@ -163,10 +167,15 @@ def lint(session):
 
 @nox.session(python=DEFAULT_PYTHON_VERSION)
 def blacken(session):
-    """Run black. Format code to uniform standard."""
-    session.install(BLACK_VERSION)
+    """(Deprecated) Legacy session. Please use 'nox -s format'."""
+    session.log("WARNING: The 'blacken' session is deprecated and will be removed in a future release. Please use 'nox -s format' in the future.")
+    
+    # Just run the ruff formatter (keeping legacy behavior of only formatting, not sorting imports)
+    session.install(RUFF_VERSION)
     session.run(
-        "black",
+        "ruff", "format",
+        f"--target-version=py{ALL_PYTHON[0].replace('.', '')}",
+        "--line-length=88",
         *LINT_PATHS,
     )
 
@@ -174,19 +183,28 @@ def blacken(session):
 @nox.session(python=DEFAULT_PYTHON_VERSION)
 def format(session):
     """
-    Run isort to sort imports. Then run black
-    to format code to uniform standard.
+    Run ruff to sort imports and format code.
     """
-    session.install(BLACK_VERSION, ISORT_VERSION)
-    # Use the --fss option to sort imports using strict alphabetical order.
-    # See https://pycqa.github.io/isort/docs/configuration/options.html#force-sort-within-sections
+    # 1. Install ruff (skipped automatically if you run with --no-venv)
+    session.install(RUFF_VERSION)
+
+    # 2. Run Ruff to fix imports
+    # check --select I: Enables strict import sorting
+    # --fix: Applies the changes automatically
     session.run(
-        "isort",
-        "--fss",
+        "ruff", "check",
+        "--select", "I",
+        "--fix",
+        f"--target-version=py{ALL_PYTHON[0].replace('.', '')}",
+        "--line-length=88",  # Standard Black line length
         *LINT_PATHS,
     )
+
+    # 3. Run Ruff to format code
     session.run(
-        "black",
+        "ruff", "format",
+        f"--target-version=py{ALL_PYTHON[0].replace('.', '')}",
+        "--line-length=88",  # Standard Black line length
         *LINT_PATHS,
     )
 

gapic/templates/tests/unit/gapic/%name_%version/%sub/test_%service.py.j2

@@ -26,6 +26,7 @@ from google.protobuf import json_format
 import json
 import math
 import pytest
+from collections.abc import Sequence, Mapping
 from google.api_core import api_core_version
 from proto.marshal.rules.dates import DurationRule, TimestampRule
 from proto.marshal.rules import wrappers

gapic/templates/tests/unit/gapic/%name_%version/%sub/test_macros.j2

@@ -752,8 +752,18 @@ def test_{{ method_name }}_pager(transport_name: str = "grpc"):
 
         results = list(pager)
         assert len(results) == 6
+        {% if method.paged_result_field.type.ident|string == 'struct_pb2.ListValue' %}
+        assert all(isinstance(i, Sequence)
+                   for i in results)
+        {% elif method.paged_result_field.type.ident|string == 'struct_pb2.Struct' %}
+        assert all(isinstance(i, Mapping)
+                   for i in results)
+        {% elif method.paged_result_field.type.ident|string == 'struct_pb2.Value' %}
+        assert all(True for i in results)
+        {% else %}
         assert all(isinstance(i, {{ method.paged_result_field.type.ident }})
                    for i in results)
+        {% endif %}
 {% endif %}
 def test_{{ method_name }}_pages(transport_name: str = "grpc"):
     client = {{ service.client_name }}(
@@ -913,9 +923,19 @@ async def test_{{ method_name }}_async_pager():
         assert async_pager.get('a') is None
         assert isinstance(async_pager.get('h'), {{ method.paged_result_field.type.fields.get('value').ident }})
         {% else %}
+        {% if method.paged_result_field.type.ident|string == 'struct_pb2.ListValue' %}
+        assert all(isinstance(i, Sequence)
+                for i in responses)
+        {% elif method.paged_result_field.type.ident|string == 'struct_pb2.Struct' %}
+        assert all(isinstance(i, Mapping)
+                for i in responses)
+        {% elif method.paged_result_field.type.ident|string == 'struct_pb2.Value' %}
+        assert all(True for i in responses)
+        {% else %}
         assert all(isinstance(i, {{ method.paged_result_field.type.ident }})
                 for i in responses)
         {% endif %}
+        {% endif %}
 
 
 @pytest.mark.asyncio
@@ -1412,9 +1432,19 @@ def test_{{ method_name }}_rest_pager(transport: str = 'rest'):
         assert pager.get('a') is None
         assert isinstance(pager.get('h'), {{ method.paged_result_field.type.fields.get('value').ident }})
         {% else %}
+        {% if method.paged_result_field.type.ident|string == 'struct_pb2.ListValue' %}
+        assert all(isinstance(i, Sequence)
+                for i in results)
+        {% elif method.paged_result_field.type.ident|string == 'struct_pb2.Struct' %}
+        assert all(isinstance(i, Mapping)
+                for i in results)
+        {% elif method.paged_result_field.type.ident|string == 'struct_pb2.Value' %}
+        assert all(True for i in results)
+        {% else %}
         assert all(isinstance(i, {{ method.paged_result_field.type.ident }})
                 for i in results)
         {% endif %}
+        {% endif %}
 
         pages = list(client.{{ method_name }}(request=sample_request).pages)
         for page_, token in zip(pages, ['abc','def','ghi', '']):

gapic/utils/__init__.py

@@ -13,6 +13,7 @@
 # limitations under the License.
 
 from gapic.utils.cache import cached_property
+from gapic.utils.cache import cached_proto_context
 from gapic.utils.case import to_snake_case
 from gapic.utils.case import to_camel_case
 from gapic.utils.checks import is_msg_field_pb
@@ -34,6 +35,7 @@ from gapic.utils.uri_conv import convert_uri_fieldnames
 
 __all__ = (
     "cached_property",
+    "cached_proto_context",
     "convert_uri_fieldnames",
     "doc",
     "empty",

gapic/utils/cache.py

@@ -13,6 +13,8 @@
 # limitations under the License.
 
 import functools
+import contextlib
+import threading
 
 
 def cached_property(fx):
@@ -43,3 +45,92 @@ def cached_property(fx):
         return self._cached_values[fx.__name__]
 
     return property(inner)
+
+
+# Thread-local storage for the simple cache dictionary.
+# This ensures that parallel generation tasks (if any) do not corrupt each other's cache.
+_proto_collisions_cache_state = threading.local()
+
+
+@contextlib.contextmanager
+def generation_cache_context():
+    """Context manager to explicitly manage the lifecycle of the generation cache.
+
+    This manager initializes a fresh dictionary in thread-local storage when entering
+    the context and strictly deletes it when exiting.
+
+    **Memory Management:**
+    The cache stores strong references to Proto objects to "pin" them in memory
+    (see `cached_proto_context`). It is critical that this context manager deletes
+    the dictionary in the `finally` block. Deleting the dictionary breaks the
+    reference chain, allowing Python's Garbage Collector to finally free all the
+    large Proto objects that were pinned during generation.
+    """
+    # Initialize the cache as a standard dictionary.
+    _proto_collisions_cache_state.resolved_collisions = {}
+    try:
+        yield
+    finally:
+        # Delete the dictionary to free all memory and pinned objects.
+        # This is essential to prevent memory leaks in long-running processes.
+        del _proto_collisions_cache_state.resolved_collisions
+
+
+def cached_proto_context(func):
+    """Decorator to memoize `with_context` calls based on object identity and collisions.
+
+    This mechanism provides a significant performance boost by preventing
+    redundant recalculations of naming collisions during template rendering.
+
+    Since the Proto wrapper objects are unhashable (mutable), we use `id(self)` as
+    the primary cache key. Normally, this is dangerous: if the object is garbage
+    collected, Python might reuse its memory address for a *new* object, leading to
+    a cache collision (the "Zombie ID" bug).
+
+    To prevent this, this decorator stores the value as a tuple: `(result, self)`.
+    By keeping a reference to `self` in the cache value, we "pin" the object in
+    memory. This forces the Garbage Collector to keep the object alive, guaranteeing
+    that `id(self)` remains unique for the entire lifespan of the `generation_cache_context`.
+
+    Args:
+        func (Callable): The function to decorate (usually `with_context`).
+
+    Returns:
+        Callable: The wrapped function with caching and pinning logic.
+    """
+
+    @functools.wraps(func)
+    def wrapper(self, *, collisions, **kwargs):
+        # 1. Check for active cache (returns None if context is not active)
+        context_cache = getattr(
+            _proto_collisions_cache_state, "resolved_collisions", None
+        )
+
+        # If we are not inside a generation_cache_context (e.g. unit tests),
+        # bypass the cache entirely.
+        if context_cache is None:
+            return func(self, collisions=collisions, **kwargs)
+
+        # 2. Create the cache key
+        # We use frozenset for collisions to make it hashable.
+        # We use id(self) because 'self' is not hashable.
+        collisions_key = frozenset(collisions) if collisions else None
+        key = (id(self), collisions_key)
+
+        # 3. Check Cache
+        if key in context_cache:
+            # The cache stores (result, pinned_object). We return just the result.
+            return context_cache[key][0]
+
+        # 4. Execute the actual function
+        # We ensure context_cache is passed down to the recursive calls
+        result = func(self, collisions=collisions, **kwargs)
+
+        # 5. Update Cache & Pin Object
+        # We store (result, self). The reference to 'self' prevents garbage collection,
+        # ensuring that 'id(self)' cannot be reused for a new object while this
+        # cache entry exists.
+        context_cache[key] = (result, self)
+        return result
+
+    return wrapper

{gapic_generator-1.30.5.dist-info → gapic_generator-1.30.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gapic-generator
-Version: 1.30.5
+Version: 1.30.7
 Summary: Google API Client Generator for Python
 Home-page: https://github.com/googleapis/gapic-generator-python
 Author: Google LLC