experiment: PEP810 test compute lazy loading#17594
Closed
hebaalazzeh wants to merge 2 commits into
Closed
Conversation
![gemini-code-assist[bot]](https://avatars.githubusercontent.com/in/956858?s=60&v=4){kind=small}
Contributor
There was a problem hiding this comment.
Code Review
This pull request introduces support for lazy-loading modules in Python 3.15+ by defining __lazy_modules__ in the package initialization templates and generated files. A critical issue was identified in the template where sys is used without being imported, which would lead to a NameError at runtime.
|
|
||
| from importlib import metadata | ||
|
|
||
| if sys.version_info >= (3, 15): |
Contributor
There was a problem hiding this comment.
The sys module is referenced here (sys.version_info) but it is not imported in this template. This will cause a NameError at runtime in the generated __init__.py files. Please import sys before using it.
import sys
if sys.version_info >= (3, 15):
hebaalazzeh
force-pushed
the
test-compute-lazy-loading
branch
from
dabf6bd to
aedbee9
Compare
Contributor
Author
|
/gemini |
hebaalazzeh
changed the title
hebaalazzeh
added a commit
that referenced
this pull request
Jun 30, 2026
## Overview
This is an initiative to resolve severe initialization bottlenecks
(~10s-13s) in generated client libraries by adopting **Native Python
3.15 Explicit Lazy Imports (PEP 0810)**.
To avoid introducing maintenance burdens or subtle breaking changes via
custom import hooks, this PR focuses *exclusively* on utilizing native
interpreter standards.
### Implementation Architecture
We modify the upstream GAPIC Generator to emit a native
`__lazy_modules__` set at the top of the `__init__.py` files,
immediately followed by the standard eager imports.
* **Python 3.15+ (Native Acceleration):** The Python 3.15 runtime
natively intercepts the standard imports referenced in the
`__lazy_modules__` set and treats them as fast C-level lazy proxies.
Startup times drop from ~13s to ~200ms, and peak RAM consumption drops
by up to 85%.
* **Python 3.14 and Older (Zero Blast Radius):** Older Python
environments safely ignore the `__lazy_modules__` variable and process
the standard eager imports exactly as they do today. This guarantees
100% backwards compatibility with zero risk.
* **Perfect Static Typing:** Because standard imports are still present
in the file, IDEs (IntelliSense) and static analyzers (MyPy) maintain
zero-friction support.
**Example Structure:**
```python
# 1. Native C-Level Lazy Proxying for Python 3.15+ (PEP 0810)
__lazy_modules__ = {
f"{__name__}.services.accelerator_types",
f"{__name__}.services.addresses",
f"{__name__}.types.compute",
}
# 2. Standard eager imports
# Evaluated instantly by older Python versions. Intercepted natively by Python 3.15.
from .services.accelerator_types import AcceleratorTypesClient
from .services.addresses import AddressesClient
from .types.compute import Address
__all__ = (
"AcceleratorTypesClient",
"AddressesClient",
"Address",
)
```
## 🚀 Performance Benchmarking Results (Disk-Level Cold Start)
We utilized our custom `profiler.py` script #17467 to run 5 iterations
measuring true disk-level cold starts (with `__pycache__` sweeps) on the
`google-cloud-compute` library. The results validate this Phase 1 PEP
810 Native Lazy Loading implementation:
### Python 3.14 (Current Eager Import)
* **Time (Median):** `23,246.97 ms` (~23.2 seconds)
* **Memory (Physical RSS):** `224.87 MB`
* **Code Volume:** Loaded `1,407` modules (`1,040,992` lines of code)
### Python 3.15.0b2 (Phase 1 PEP 810 Lazy Proxy)
* **Time (Median):** `1,062.87 ms` (~1.06 seconds)
* **Memory (Physical RSS):** `7.21 MB`
* **Code Volume:** Loaded `15` modules (`8,064` lines of code)
**Impact:** By natively deferring the 120+ submodules at the C-level, we
bypassed parsing over **1 million lines of code**. This resulted in an
**approximately 22x reduction in startup latency (~95% speedup)**, and a
staggering **96% reduction in peak RAM consumption** (dropping from
~225MB down to just ~7MB).
Related Links:
see #17594 for a demonstration of this generator change applied to
google-cloud-compute package.
Design Doc: go/sdk-performance-design
Towards googleapis/python-aiplatform#4749
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
1 participant
Add this suggestion to a batch that can be applied as a single commit.This suggestion is invalid because no changes were made to the code.Suggestions cannot be applied while the pull request is closed.Suggestions cannot be applied while viewing a subset of changes.Only one suggestion per line can be applied in a batch.Add this suggestion to a batch that can be applied as a single commit.Applying suggestions on deleted lines is not supported.You must change the existing code in this line in order to create a valid suggestion.Outdated suggestions cannot be applied.This suggestion has been applied or marked resolved.Suggestions cannot be applied from pending reviews.Suggestions cannot be applied on multi-line comments.Suggestions cannot be applied while the pull request is queued to merge.Suggestion cannot be applied right now. Please check back later.
Description
This PR is a proof-of-concept demonstrating the impact of native Python 3.15+ (PEP 810) lazy loading on a large generated GAPIC package (
google-cloud-compute).This PR applies the generator changes proposed in PR #17591 to the
google-cloud-computepackage. By utilizing the__lazy_modules__dictionary, the package defers importing underlying service modules until they are explicitly accessed, significantly reducing the initial import footprint and startup time.Note: This PR is currently for testing and review purposes to observe the generated diff and validate CI behavior. It depends on the generator changes in #17591
Changes Made
google-cloud-computeusing the updated gapic-generator templates.__lazy_modules__definition insidegoogle/cloud/compute_v1/__init__.pywrapped in anif sys.version_info >= (3, 15):block.ruff formatto ensure the generated dict aligns with CI formatting constraints.