⚡️ Speed up method GoogleGmailDataSource.users_settings_get_language by 80%

[codeflash-ai]

📄 80% (0.80x) speedup for GoogleGmailDataSource.users_settings_get_language in backend/python/app/sources/external/google/gmail/gmail.py

⏱️ Runtime : 8.14 milliseconds → 4.51 milliseconds (best of 45 runs)

📝 Explanation and details

The optimized code achieves an 80% runtime speedup (8.14ms → 4.51ms) through two key optimizations:

1. Method Chain Caching: The most significant optimization caches the Gmail API method reference self.client.users().settings().getLanguage during initialization as self._get_language. The line profiler shows this eliminates the expensive method chain traversal that consumed 69.3% of execution time (21.8ms) in the original code, reducing it to just 47.5% (8.8ms) - a ~60% reduction in this critical path.

2. Conditional Dictionary Allocation: Replaces the always-allocating kwargs or {} pattern with conditional logic that only creates new dictionaries when necessary. When userId is None, it reuses the original kwargs directly instead of creating a copy.

The line profiler data clearly shows the optimization's impact: the method call line drops from 47,420ns per hit to 19,114ns per hit - a 60% reduction per operation. This optimization is particularly valuable for high-frequency Gmail API operations, as evidenced by the test cases showing concurrent calls and large-scale operations (100 calls).

Note that while runtime improves significantly, throughput shows a slight decrease (21,714 → 20,790 ops/sec, -4.3%). This suggests the optimization reduces individual call latency but may introduce slight overhead in high-concurrency scenarios, possibly due to the cached reference or memory access patterns. However, the substantial runtime improvement makes this trade-off beneficial for most real-world usage patterns where individual call performance matters more than peak theoretical throughput.

✅ Correctness verification report:

Test	Status
⚙️ Existing Unit Tests	🔘 None Found
🌀 Generated Regression Tests	✅ 290 Passed
⏪ Replay Tests	🔘 None Found
🔎 Concolic Coverage Tests	🔘 None Found
📊 Tests Coverage	100.0%

🌀 Generated Regression Tests and Runtime

import asyncio  # used to run async functions
from typing import Any, Dict

import pytest  # used for our unit tests
from app.sources.external.google.gmail.gmail import GoogleGmailDataSource


# --- Begin: Function under test (EXACT COPY, DO NOT MODIFY) ---
class DummyRequest:
    """A dummy request object to simulate the Gmail API's execute() method."""
    def __init__(self, response: Dict[str, Any]):
        self._response = response

    async def execute(self):
        # Simulate async API call
        return self._response

    # Synchronous execute for compatibility with original code
    def execute(self):
        return self._response

class DummySettings:
    """Simulates settings() in the Gmail API client."""
    def __init__(self, language_db):
        self.language_db = language_db

    def getLanguage(self, **kwargs):
        userId = kwargs.get('userId')
        if userId not in self.language_db:
            raise ValueError(f"UserId '{userId}' not found")
        return DummyRequest(self.language_db[userId])

class DummyUsers:
    """Simulates users() in the Gmail API client."""
    def __init__(self, language_db):
        self._settings = DummySettings(language_db)

    def settings(self):
        return self._settings

class DummyGoogleClient:
    """Simulates the GoogleClient used by GoogleGmailDataSource."""
    def __init__(self, language_db):
        self._users = DummyUsers(language_db)

    def users(self):
        return self._users
from app.sources.external.google.gmail.gmail import \
    GoogleGmailDataSource  # --- End: Function under test ---

# --- Begin: Unit Tests ---

@pytest.fixture
def gmail_data_source():
    # Setup a mock language database for test users
    language_db = {
        "me": {"language": "en", "displayLanguage": "English"},
        "alice@example.com": {"language": "fr", "displayLanguage": "Français"},
        "bob@example.com": {"language": "es", "displayLanguage": "Español"},
        "charlie@example.com": {"language": "ja", "displayLanguage": "日本語"},
        "empty@example.com": {},
    }
    client = DummyGoogleClient(language_db)
    return GoogleGmailDataSource(client)

# 1. Basic Test Cases

@pytest.mark.asyncio
async def test_users_settings_get_language_basic_me(gmail_data_source):
    # Test with special userId "me"
    result = await gmail_data_source.users_settings_get_language("me")

@pytest.mark.asyncio
async def test_users_settings_get_language_basic_known_user(gmail_data_source):
    # Test with a known user
    result = await gmail_data_source.users_settings_get_language("alice@example.com")

@pytest.mark.asyncio
async def test_users_settings_get_language_basic_empty_response(gmail_data_source):
    # Test with a user that has an empty language settings
    result = await gmail_data_source.users_settings_get_language("empty@example.com")

@pytest.mark.asyncio
async def test_users_settings_get_language_basic_with_kwargs(gmail_data_source):
    # Test passing extra kwargs (should not affect result)
    result = await gmail_data_source.users_settings_get_language("bob@example.com", foo="bar")

# 2. Edge Test Cases

@pytest.mark.asyncio
async def test_users_settings_get_language_edge_invalid_userid(gmail_data_source):
    # Test with an invalid userId (should raise ValueError)
    with pytest.raises(ValueError):
        await gmail_data_source.users_settings_get_language("unknown@example.com")

@pytest.mark.asyncio
async def test_users_settings_get_language_edge_none_userid(gmail_data_source):
    # Test with None as userId (should raise ValueError since userId is required)
    with pytest.raises(ValueError):
        await gmail_data_source.users_settings_get_language(None)

@pytest.mark.asyncio
async def test_users_settings_get_language_edge_concurrent_calls(gmail_data_source):
    # Test concurrent calls to different users
    coros = [
        gmail_data_source.users_settings_get_language("alice@example.com"),
        gmail_data_source.users_settings_get_language("bob@example.com"),
        gmail_data_source.users_settings_get_language("charlie@example.com"),
    ]
    results = await asyncio.gather(*coros)

@pytest.mark.asyncio
async def test_users_settings_get_language_edge_concurrent_same_user(gmail_data_source):
    # Test concurrent calls to the same user
    coros = [
        gmail_data_source.users_settings_get_language("me"),
        gmail_data_source.users_settings_get_language("me"),
    ]
    results = await asyncio.gather(*coros)

@pytest.mark.asyncio
async def test_users_settings_get_language_edge_missing_kwargs(gmail_data_source):
    # Test with missing kwargs (should work fine)
    result = await gmail_data_source.users_settings_get_language("charlie@example.com")

# 3. Large Scale Test Cases

@pytest.mark.asyncio
async def test_users_settings_get_language_large_scale_concurrent(gmail_data_source):
    # Test many concurrent calls (under 100 users)
    user_ids = ["me", "alice@example.com", "bob@example.com", "charlie@example.com", "empty@example.com"]
    coros = [
        gmail_data_source.users_settings_get_language(uid)
        for uid in user_ids * 20  # 100 calls total
    ]
    results = await asyncio.gather(*coros)
    # Check that all results are correct and in expected order
    for idx, result in enumerate(results):
        expected_uid = user_ids[idx % len(user_ids)]
        if expected_uid == "me":
            pass
        elif expected_uid == "alice@example.com":
            pass
        elif expected_uid == "bob@example.com":
            pass
        elif expected_uid == "charlie@example.com":
            pass
        elif expected_uid == "empty@example.com":
            pass

@pytest.mark.asyncio
async def test_users_settings_get_language_large_scale_concurrent_invalid(gmail_data_source):
    # Test concurrent calls with some invalid userIds
    user_ids = ["me", "unknown@example.com", "bob@example.com", "invalid@example.com"]
    coros = [
        gmail_data_source.users_settings_get_language(uid)
        for uid in user_ids
    ]
    # The invalid ones should raise ValueError
    results = []
    for coro in coros:
        try:
            result = await coro
            results.append(result)
        except ValueError:
            results.append("error")

# 4. Throughput Test Cases

@pytest.mark.asyncio

To edit these changes git checkout codeflash/optimize-GoogleGmailDataSource.users_settings_get_language-mir1hnb0 and push.