Optimize SerializationProxy performance through multi-level caching #5

srnnkls · 2025-10-26T07:49:44Z

No description provided.

This commit dramatically improves SerializationProxy performance by implementing three levels of caching to eliminate redundant expensive operations. ## Optimizations Implemented 1. **Wrapped Schema Caching** - Cache wrapped schemas by schema ID to avoid repeated deepcopy() calls - Stores results in module-level _wrapped_schema_cache dict 2. **Proxy Type Caching** - Cache dynamically created proxy types by schema ID - Eliminates repeated type() and SchemaSerializer() construction - Stores in class-level _proxy_type_cache dict 3. **Attribute-Level Caching** - Cache built proxies per attribute name in instance-level _attr_cache - First access builds proxy, subsequent accesses are instant dict lookups - Also caches __getitem__ accesses with "__item__" prefix ## Performance Results **Attribute Access (Primary Bottleneck Fixed)**: - Single attribute: 90.1x faster (44,333 ns → 492 ns) - Nested attribute: 422.8x faster (443,944 ns → 1,050 ns) - Repeated access (100x): 157.1x faster (1.53 ms → 9.75 μs) - Different attributes: 135.8x faster (1.18 ms → 8.7 μs) **Proxy Creation**: - Simple BaseModel: 3.6x faster (30.5 μs → 8.4 μs) - Nested BaseModel: 6.7x faster (85.0 μs → 12.6 μs) **End-to-End Workflow**: 16.1x faster (411.3 μs → 25.6 μs) **Other Improvements**: - repr(): 4.4x faster - Custom serializers: 16.7x faster **Overhead Reduction**: - Attribute access overhead: 514x → 5.7x (98.9% reduction!) - Nested access overhead: 4,116x → 9.7x (99.76% reduction!) ## Technical Changes - Added functools.lru_cache import - Added _wrapped_schema_cache module-level dict - Modified _wrap_core_schema() to check/populate cache - Added _proxy_type_cache class variable - Added _attr_cache instance variable in __init__ - Modified _build() to check/populate proxy type cache - Modified __getattr__() and __getitem__() to check/populate attribute cache All changes are backward compatible with no API changes. See OPTIMIZATION_RESULTS.md for detailed benchmark comparison. 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude <noreply@anthropic.com>

gemini-code-assist · 2025-10-26T07:50:02Z

Summary of Changes

Hello @srnnkls, I'm Gemini Code Assist¹! I'm currently reviewing this pull request and will post my feedback shortly. In the meantime, here's a summary to help you and other reviewers quickly get up to speed!

This pull request introduces a comprehensive set of performance optimizations for the SerializationProxy component. By strategically applying multi-level caching at various stages of the serialization process, it drastically reduces the computational overhead associated with attribute access and proxy instantiation. The changes aim to make SerializationProxy significantly more efficient, particularly for scenarios involving repeated attribute lookups, without altering its external behavior or API.

Highlights

Multi-Level Caching: Implemented three distinct caching mechanisms: wrapped schema caching, proxy type caching, and attribute-level caching, to significantly reduce overhead in SerializationProxy operations.
Performance Gains: Achieved substantial performance improvements, including a 90-422x speedup for attribute access, 3-7x faster proxy creation, and a 16x acceleration for end-to-end serialization workflows.
Backward Compatibility: All optimizations were implemented without introducing any breaking API changes, ensuring full backward compatibility.

Using Gemini Code Assist

The full guide for Gemini Code Assist can be found on our documentation page, here are some quick tips.

Invoking Gemini

You can request assistance from Gemini at any point by creating a comment using either /gemini <command> or @gemini-code-assist <command>. Below is a summary of the supported commands on the current page.

Feature	Command	Description
Code Review	`/gemini review`	Performs a code review for the current pull request in its current state.
Pull Request Summary	`/gemini summary`	Provides a summary of the current pull request in its current state.
Comment	@gemini-code-assist	Responds in comments when explicitly tagged, both in pull request comments and review comments.
Help	`/gemini help`	Displays a list of available commands.

Customization

To customize Gemini Code Assist for GitHub experience, repository maintainers can create a configuration file and/or provide a custom code review style guide (such as PEP-8 for Python) by creating and adding files to a .gemini/ folder in the base of the repository. Detailed instructions can be found here.

Limitations & Feedback

Gemini Code Assist may make mistakes. Please leave feedback on any instances where its feedback is incorrect or counter productive. You can react with 👍 and 👎 on @gemini-code-assist comments. If you're interested in giving your feedback about your experience with Gemini Code Assist for Github and other Google products, sign up here.

You can also get AI-powered code generation, chat, as well as code reviews directly in the IDE at no cost with the Gemini Code Assist IDE Extension.

Review the Privacy Notices, Generative AI Prohibited Use Policy, Terms of Service, and learn how to configure Gemini Code Assist in GitHub here. Gemini can make mistakes, so double check it and use code with caution. ↩

This commit adds 24 tests covering all major features documented in the README to ensure the SerializationProxy optimizations didn't break any existing functionality. ## Test Coverage **Basic Templating** (3 tests): - Hello world example - Template as variable - Keyword source argument **Type Validation** (2 tests): - Pydantic field constraints - Template variable mismatch detection **Field-Level Serialization** (5 tests): - @field_serializer decorator - PlainSerializer annotation - SQL keyword example from README (with loops) - Literal rendering with serializers - Nested attribute access with serializers **Template-Level Serialization** (2 tests): - Built-in serialize_json function - Custom serializers (1 skipped - pre-existing issue) **Proxy Features** (2 tests): - Attribute caching verification - Deeply nested structures **Template Manipulation** (3 tests): - replace() function - with_() function (2 skipped - pre-existing bug) **Lists and Loops** (2 tests): - Simple list iteration - List of objects with field serializers **Edge Cases** (3 tests): - Multiple field serializers - Empty lists - Optional fields with None **Proxy Disabled** (2 tests): - Basic rendering without proxy - Template-level serializer without proxy ## Results 21 tests pass, 3 skipped (pre-existing issues not related to optimizations). ## Critical Verification All field-level serialization tests pass, confirming that the proxy optimizations maintain correct behavior for: - Field serializers applied before attribute access - Serializers in nested structures - Serializers in loops - Multiple serializers on different fields This verifies that the caching optimizations don't interfere with the core functionality of SerializationProxy. 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude <noreply@anthropic.com>

Copilot

Pull Request Overview

This PR optimizes SerializationProxy performance by implementing multi-level caching strategies that reduce overhead by 90-422x for attribute access operations. The primary focus is on eliminating expensive operations like deepcopy() and redundant proxy/serializer creation through strategic caching at three levels: schema wrapping, proxy type creation, and attribute access.

Key changes:

Added wrapped schema caching to avoid repeated deepcopy() operations
Implemented proxy type caching to reuse types for identical schemas
Added attribute-level caching to avoid rebuilding proxies for repeated access

Reviewed Changes

Copilot reviewed 6 out of 7 changed files in this pull request and generated 4 comments.

Show a summary per file

File	Description
`src/deigma/proxy.py`	Implemented three-level caching system: wrapped schema cache, proxy type cache, and per-instance attribute cache
`tests/test_readme_features.py`	Comprehensive test suite verifying all README features work correctly with optimizations
`tests/test_benchmark_serialization_proxy.py`	Benchmark tests measuring proxy overhead against direct operations
`tests/__init__.py`	Empty init file for tests package
`pyproject.toml`	Added pytest-benchmark dependency for performance testing
`OPTIMIZATION_RESULTS.md`	Documentation of performance improvements and implementation details

💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.

Copilot · 2025-10-26T07:51:28Z

src/deigma/proxy.py

@@ -1,5 +1,6 @@
 from collections.abc import Callable, Iterable, Mapping
 from copy import deepcopy
+from functools import lru_cache


The lru_cache import is unused in the code. While the PR title mentions caching, the implementation uses manual dictionary caching (_wrapped_schema_cache, _proxy_type_cache, _attr_cache) instead of lru_cache. Remove this unused import.

Suggested change

from functools import lru_cache

src/deigma/proxy.py

Copilot · 2025-10-26T07:51:28Z

src/deigma/proxy.py

+        # For getitem, we use string representation of key for cache
+        cache_key = f"__item__{key}"


Using string representation of key for caching can cause collisions and incorrect behavior. If key is a non-hashable type or contains characters that appear in string representation but aren't unique (e.g., 0 vs '0'), cache entries will conflict. Use a tuple ('__item__', key) as the cache key instead to maintain type safety.

Suggested change

# For getitem, we use string representation of key for cache

cache_key = f"__item__{key}"

# For getitem, we use a tuple for cache key to avoid collisions

cache_key = ('__item__', key)

Copilot · 2025-10-26T07:51:28Z

OPTIMIZATION_RESULTS.md

+
+## Code Changes
+
+- Added `functools.lru_cache` import


Documentation incorrectly states that functools.lru_cache was imported and presumably used. The actual implementation uses manual dictionary-based caching (_wrapped_schema_cache, _proxy_type_cache, _attr_cache), not lru_cache. Update this line to reflect the actual caching implementation.

Suggested change

- Added `functools.lru_cache` import

gemini-code-assist

Code Review

This pull request introduces significant performance optimizations to SerializationProxy by implementing a multi-level caching strategy. Caches are added for wrapped schemas, proxy types, and accessed attributes, which drastically reduces overhead for attribute access as demonstrated by the new benchmark tests. The changes are well-structured and the inclusion of benchmark tests and performance results is excellent.

My review focuses on potential improvements to the caching implementation. I've identified two caches that could grow indefinitely, leading to potential memory issues in long-running services. I've also found a potential bug in the cache key generation for __getitem__ that could lead to key collisions and incorrect behavior. Finally, there's a minor cleanup regarding an unused import.

Overall, this is a great contribution that significantly improves performance. Addressing the feedback will make the implementation more robust.

gemini-code-assist · 2025-10-26T07:52:17Z

src/deigma/proxy.py



+# Cache for wrapped schemas - schemas are hashable via id()
+_wrapped_schema_cache: dict[int, CoreSchema] = {}


This module-level _wrapped_schema_cache is unbounded and will grow indefinitely as new schemas are processed. This can lead to excessive memory consumption or a memory leak in long-running applications.

Please consider implementing a cache eviction policy, for example by clearing the cache if it exceeds a certain size.

gemini-code-assist · 2025-10-26T07:52:17Z

src/deigma/proxy.py

    __pydantic_validator__: SchemaValidator

+    # Cache for proxy types - keyed by schema id
+    _proxy_type_cache: dict[int, type["SerializationProxy"]] = {}


Similar to _wrapped_schema_cache, this class-level _proxy_type_cache can grow indefinitely, potentially causing a memory leak in long-running applications that process many different schemas.

Please consider adding a size limit to this cache, for instance by clearing it when it exceeds a certain size.

gemini-code-assist · 2025-10-26T07:52:17Z

src/deigma/proxy.py


    def __getitem__(self, key):
+        # For getitem, we use string representation of key for cache
+        cache_key = f"__item__{key}"


The current cache key generation f"__item__{key}" can cause key collisions. For example, if an object can be accessed with both an integer 1 and a string '1', they will both generate the same cache key "__item__1". This will lead to returning incorrect cached values.

To make the key unique, you should include the type of the key in its string representation.

Suggested change

cache_key = f"__item__{key}"

cache_key = f"__item__{type(key).__name__}:{repr(key)}"

gemini-code-assist · 2025-10-26T07:52:17Z

src/deigma/proxy.py

@@ -1,5 +1,6 @@
 from collections.abc import Callable, Iterable, Mapping
 from copy import deepcopy
+from functools import lru_cache


The lru_cache is imported but never used in the file. It should be removed to keep the code clean and avoid confusion.

Refactor all tests to follow proper architectural principles: - No classes for organization/namespacing - Composition with fixtures - Type-safe parametrization (where applicable) - Proper directory structure ## Directory Structure ``` tests/ ├── unit/ (empty, ready for unit tests) ├── integration/ (full pipeline tests) │ ├── test_template_rendering.py │ ├── test_field_serialization.py │ └── test_lists_and_loops.py └── benches/ (performance benchmarks) └── test_serialization_proxy.py ``` ## Refactoring Changes **Removed test classes completely**: - TestBasicTemplating → plain functions - TestFieldLevelSerialization → plain functions - TestProxyCreation → plain functions - All other test classes eliminated **Implemented fixture composition**: - `simple_model`, `nested_model` fixtures for benchmarks - `hello_template_cls`, `user_inline_type` fixtures for integration - Fixtures follow dependency injection pattern - Each fixture returns typed objects **Organized by concern**: - `test_template_rendering.py` - Basic template pipeline tests (15 tests) - `test_field_serialization.py` - Field serializers & proxy (9 tests) - `test_lists_and_loops.py` - Iteration and loops (7 tests) - `test_serialization_proxy.py` - Performance benchmarks (33 tests) **Test count**: 64 tests total - Integration: 28 tests (all pass) - Benchmarks: 33 tests (all pass) - Unit: 0 tests (directory ready for future unit tests) ## Key Improvements 1. **No organizational classes**: All functions at module level 2. **Explicit dependencies**: Fixtures clearly show what each test needs 3. **Single responsibility**: Each test file has focused purpose 4. **Composable fixtures**: Can be mixed and matched 5. **Proper separation**: benches/ vs integration/ vs unit/ All tests pass successfully. Ready for unit tests to be added to unit/ as needed. 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude <noreply@anthropic.com>

The lru_cache decorator cannot be used here because CoreSchema objects are dictionaries (unhashable) and we need to cache by object identity using id(). Manual dict-based caching is the appropriate solution. Addresses PR review feedback.

Addresses multiple PR review comments: 1. **Bounded cache sizes to prevent memory leaks**: - Added _WRAPPED_SCHEMA_CACHE_SIZE = 256 for wrapped schema cache - Added _PROXY_TYPE_CACHE_SIZE = 256 for proxy type cache - Implemented LRU eviction using OrderedDict.move_to_end() - Evict oldest entries when cache exceeds size limit - Prevents unbounded growth in long-running applications 2. **Fixed cache key collision in __getitem__**: - Changed from string key f"__item__{key}" to tuple ("__item__", key) - Prevents collisions between different types (e.g., 0 vs '0') - Updated type annotation: dict[str | tuple, "SerializationProxy"] - Maintains type safety without string conversion ## Implementation Details LRU cache strategy: - On cache hit: move_to_end() to mark as recently used - On cache miss: add new entry and move_to_end() - If size > limit: popitem(last=False) to remove oldest entry All tests pass with bounded caches maintaining performance benefits. Addresses PR review feedback on memory management and cache key safety.

srnnkls · 2025-10-26T08:15:03Z

/gemini review

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

gemini-code-assist

Code Review

This pull request introduces significant performance optimizations to SerializationProxy by implementing multi-level caching. The changes are well-documented with performance results and backed by a comprehensive suite of new benchmark and integration tests. The performance gains, especially in attribute access, are impressive.

My review focuses on ensuring the correctness and thread-safety of the new caching mechanisms. I've identified a critical thread-safety issue in the global and class-level caches that could cause problems in multi-threaded applications. I've suggested using Python's built-in functools.lru_cache and threading.Lock to resolve this, which will also simplify the code. Additionally, I've noted an improvement for a test assertion to make it more robust and a small discrepancy in the results documentation.

gemini-code-assist · 2025-10-26T08:17:31Z

src/deigma/proxy.py

+    # Bounded cache for proxy types to prevent memory leaks
+    _PROXY_TYPE_CACHE_SIZE = 256
+    _proxy_type_cache: OrderedDict[int, type["SerializationProxy"]] = OrderedDict()


This class-level _proxy_type_cache is also not thread-safe. Concurrent access from multiple threads could lead to race conditions when modifying the OrderedDict in the _build method. This is a critical issue in multi-threaded applications.

To resolve this, you should introduce a threading.Lock to ensure exclusive access to the cache.

Example Usage in _build:

@classmethod def _build(cls, ...): schema_id = id(core_schema) with cls._proxy_type_cache_lock: # All logic for checking, updating, and evicting from # cls._proxy_type_cache goes here. if schema_id in cls._proxy_type_cache: # ... else: # ... return proxy_type(obj, serialized, adapter)

Don't forget to add import threading at the top of the file.

Suggested change

# Bounded cache for proxy types to prevent memory leaks

_PROXY_TYPE_CACHE_SIZE = 256

_proxy_type_cache: OrderedDict[int, type["SerializationProxy"]] = OrderedDict()

# Bounded cache for proxy types to prevent memory leaks

_PROXY_TYPE_CACHE_SIZE = 256

_proxy_type_cache: OrderedDict[int, type["SerializationProxy"]] = OrderedDict()

_proxy_type_cache_lock = threading.Lock()

gemini-code-assist · 2025-10-26T08:17:31Z

OPTIMIZATION_RESULTS.md

+
+## Code Changes
+
+- Added `functools.lru_cache` import


This line in the optimization summary states that functools.lru_cache was imported, but the actual implementation in src/deigma/proxy.py uses a manual LRU cache with OrderedDict.

This is misleading. I've suggested in my other comments to use functools.lru_cache to fix a critical thread-safety issue and simplify the code. If you adopt that suggestion, this line will become correct. Otherwise, it should be updated to reflect the use of OrderedDict.

gemini-code-assist · 2025-10-26T08:17:31Z

tests/integration/test_field_serialization.py

+    assert result.count("ALICE") == 3
+
+    # Serializer should be called (caching optimizations should work)
+    assert counter.count >= 1


This assertion is too lenient to properly test the attribute caching. With the new caching optimizations, the counting_serializer should be called exactly once when the proxy is built. Subsequent accesses to person.name in the template should hit the cache and not re-trigger the serializer.

Changing this to assert counter.count == 1 will provide a much stronger guarantee that the caching is working as expected.

Suggested change

assert counter.count >= 1

assert counter.count == 1

gemini-code-assist

Code Review

This pull request introduces significant performance optimizations to SerializationProxy by implementing a multi-level caching strategy. This includes caching for wrapped schemas, proxy types, and accessed attributes. The changes result in a massive reduction in overhead for attribute access, as documented in OPTIMIZATION_RESULTS.md. A comprehensive set of benchmark and integration tests have been added to validate the performance gains and ensure correctness.

My review focuses on potential thread-safety issues with the new global and class-level caches, along with some minor suggestions for micro-optimizations and improving test assertions. Overall, this is an excellent and impactful optimization.

gemini-code-assist · 2025-10-26T10:17:03Z

src/deigma/proxy.py

+# Bounded cache for wrapped schemas to prevent memory leaks in long-running applications
+# Using OrderedDict for LRU eviction
+_WRAPPED_SCHEMA_CACHE_SIZE = 256
+_wrapped_schema_cache: OrderedDict[int, CoreSchema] = OrderedDict()


The global _wrapped_schema_cache is modified without any locking, which makes it not thread-safe. In a multi-threaded application, this could lead to race conditions (e.g., during reads/writes to the OrderedDict). Please add a threading.Lock to protect all modifications and reads of this shared cache to ensure thread safety.

gemini-code-assist · 2025-10-26T10:17:03Z

src/deigma/proxy.py

+    # Bounded cache for proxy types to prevent memory leaks
+    _PROXY_TYPE_CACHE_SIZE = 256
+    _proxy_type_cache: OrderedDict[int, type["SerializationProxy"]] = OrderedDict()


This class-level _proxy_type_cache is a shared mutable state and is not thread-safe. Concurrent access from multiple threads could lead to race conditions when checking, adding, or evicting items. Please protect access to this cache with a threading.Lock to make it safe for use in multi-threaded environments.

gemini-code-assist · 2025-10-26T10:17:03Z

src/deigma/proxy.py

+
+    # Cache with LRU eviction
+    _wrapped_schema_cache[schema_id] = wrapped_schema
+    _wrapped_schema_cache.move_to_end(schema_id)


This call to move_to_end() is redundant. When a new key is added to an OrderedDict, it is placed at the end by default. Since this code path is only for cache misses (new keys), the item is already in the most-recently-used position. Removing this line would be a small optimization.

gemini-code-assist · 2025-10-26T10:17:03Z

src/deigma/proxy.py

+            )
+            # Cache the proxy type with LRU eviction
+            cls._proxy_type_cache[schema_id] = proxy_type
+            cls._proxy_type_cache.move_to_end(schema_id)


Similar to the _wrapped_schema_cache, this call to move_to_end() is redundant for a new cache entry. OrderedDict places new items at the end, so this call is not necessary for cache misses.

gemini-code-assist · 2025-10-26T10:17:03Z

tests/integration/test_field_serialization.py

+    # Serializer should be called (caching optimizations should work)
+    assert counter.count >= 1


This assertion is correct, but it could be more specific. Given the caching optimizations, the counting_serializer should be called exactly once when the parent object is first serialized to create the proxy. A more precise assertion like assert counter.count == 1 would more strictly verify that the serializer is not being called on every access. I've suggested a change to reflect this.

Suggested change

# Serializer should be called (caching optimizations should work)

assert counter.count >= 1

# Serializer should be called exactly once due to caching.

assert counter.count == 1

srnnkls requested a review from Copilot October 26, 2025 07:50

Copilot AI reviewed Oct 26, 2025

View reviewed changes

gemini-code-assist bot reviewed Oct 26, 2025

View reviewed changes

claude added 3 commits October 26, 2025 08:01

Remove unused lru_cache import

ff1fdc9

The lru_cache decorator cannot be used here because CoreSchema objects are dictionaries (unhashable) and we need to cache by object identity using id(). Manual dict-based caching is the appropriate solution. Addresses PR review feedback.

Update proxy.py

9ed509c

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

gemini-code-assist bot reviewed Oct 26, 2025

View reviewed changes

srnnkls changed the base branch from main to claude/benchmark-serialization-proxy-011CUVRN18PCYh3xd7J7c1td October 26, 2025 08:57

gemini-code-assist bot reviewed Oct 26, 2025

View reviewed changes

		# For getitem, we use string representation of key for cache
		cache_key = f"__item__{key}"



		# Cache for wrapped schemas - schemas are hashable via id()
		_wrapped_schema_cache: dict[int, CoreSchema] = {}

	cache_key = f"__item__{key}"
	cache_key = f"__item__{type(key).__name__}:{repr(key)}"

		# Serializer should be called (caching optimizations should work)
		assert counter.count >= 1

Optimize SerializationProxy performance through multi-level caching #5

Are you sure you want to change the base?

Optimize SerializationProxy performance through multi-level caching #5

Uh oh!

Conversation

srnnkls commented Oct 26, 2025

Uh oh!

gemini-code-assist bot commented Oct 26, 2025

Summary of Changes

Highlights

Footnotes

Uh oh!

Copilot AI left a comment

Choose a reason for hiding this comment

Pull Request Overview

Reviewed Changes

Uh oh!

Copilot AI Oct 26, 2025

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Copilot AI Oct 26, 2025

Choose a reason for hiding this comment

Uh oh!

Copilot AI Oct 26, 2025

Choose a reason for hiding this comment

Uh oh!

gemini-code-assist bot left a comment

Choose a reason for hiding this comment

Code Review

Uh oh!

gemini-code-assist bot Oct 26, 2025

Choose a reason for hiding this comment

Uh oh!

gemini-code-assist bot Oct 26, 2025

Choose a reason for hiding this comment

Uh oh!

gemini-code-assist bot Oct 26, 2025

Choose a reason for hiding this comment

Uh oh!

gemini-code-assist bot Oct 26, 2025

Choose a reason for hiding this comment

Uh oh!

srnnkls commented Oct 26, 2025

Uh oh!

gemini-code-assist bot left a comment

Choose a reason for hiding this comment

Code Review

Uh oh!

gemini-code-assist bot Oct 26, 2025

Choose a reason for hiding this comment

Uh oh!

gemini-code-assist bot Oct 26, 2025

Choose a reason for hiding this comment

Uh oh!

gemini-code-assist bot Oct 26, 2025

Choose a reason for hiding this comment

Uh oh!

gemini-code-assist bot left a comment

Choose a reason for hiding this comment

Code Review

Uh oh!

gemini-code-assist bot Oct 26, 2025

Choose a reason for hiding this comment

Uh oh!

gemini-code-assist bot Oct 26, 2025

Choose a reason for hiding this comment

Uh oh!

gemini-code-assist bot Oct 26, 2025

Choose a reason for hiding this comment

Uh oh!

gemini-code-assist bot Oct 26, 2025

Choose a reason for hiding this comment

Uh oh!

gemini-code-assist bot Oct 26, 2025

Choose a reason for hiding this comment

Uh oh!

Reviewers

Assignees

Labels