⚡️ Speed up method OneNoteDataSource.groups_onenote_section_groups_get_section_groups by 20%

[codeflash-ai]

📄 20% (0.20x) speedup for OneNoteDataSource.groups_onenote_section_groups_get_section_groups in backend/python/app/sources/external/microsoft/one_note/one_note.py

⏱️ Runtime : 762 microseconds → 634 microseconds (best of 5 runs)

📝 Explanation and details

The optimized code achieves a 20% runtime improvement by implementing lazy object instantiation - only creating expensive Microsoft Graph SDK objects when actually needed.

Key optimization:

• Conditional object creation: Added any_query_params check to determine if query parameters exist before instantiating OnenoteRequestBuilderGetQueryParameters() (10.2% → 0.4% of total time)
• Deferred config instantiation: Only creates OnenoteRequestBuilderGetRequestConfiguration() when query params, headers, or search are present (8.8% → 0.3% of total time)
• Early returns for common cases: When no parameters are provided (233 out of 235 test calls), both objects are set to None, avoiding unnecessary allocations

Why this works:
In Python, object instantiation has overhead, especially for complex SDK objects. The original code always created these objects regardless of whether they were needed. The optimization recognizes that many OneNote API calls use default parameters and skips object creation entirely for those cases.

Performance impact:

• Runtime: 762μs → 634μs (20% faster)
• Best case scenarios: API calls with no query parameters, headers, or search (the most common usage pattern based on test data)
• No throughput change: The optimization affects per-call overhead rather than concurrent processing capacity

The line profiler shows the Microsoft Graph API call itself remains the bottleneck (41.6% of time), but reducing setup overhead provides meaningful gains for high-frequency OneNote operations.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

import asyncio
# Patch the OneNoteDataSource's dependencies to use our dummy classes
# Patch the import for OnenoteRequestBuilder in the test module namespace

import pytest
from app.sources.external.microsoft.one_note.one_note import OneNoteDataSource

# --- Minimal stubs and mocks to support the test environment ---


class OneNoteResponse:
    """A simple response wrapper to mimic the real OneNoteResponse."""

    def __init__(self, success: bool, data=None, error=None):
        self.success = success
        self.data = data
        self.error = error

    def __eq__(self, other):
        if not isinstance(other, OneNoteResponse):
            return False
        return (
            self.success == other.success
            and self.data == other.data
            and self.error == other.error
        )


class DummySectionGroups:
    """Simulates the .section_groups property with .by_section_group_id().get()."""

    def __init__(self, responses=None, raise_exc=False):
        self.responses = responses or {}
        self.raise_exc = raise_exc

    def by_section_group_id(self, section_group_id):
        self.section_group_id = section_group_id
        return self

    async def get(self, request_configuration=None):
        if self.raise_exc:
            raise Exception("Simulated API error")
        # Simulate a unique response per section_group_id for test
        return self.responses.get(
            self.section_group_id,
            {
                "id": self.section_group_id,
                "name": f"SectionGroup-{self.section_group_id}",
            },
        )


class DummyOnenote:
    """Simulates the .onenote property with .section_groups."""

    def __init__(self, responses=None, raise_exc=False):
        self.section_groups = DummySectionGroups(responses, raise_exc=raise_exc)


class DummyGroups:
    """Simulates the .groups property with .by_group_id().onenote."""

    def __init__(self, responses=None, raise_exc=False):
        self.responses = responses or {}
        self.raise_exc = raise_exc

    def by_group_id(self, group_id):
        self.group_id = group_id
        return self

    @property
    def onenote(self):
        return DummyOnenote(self.responses, raise_exc=self.raise_exc)


class DummyClient:
    """Simulates the Microsoft Graph client with .groups."""

    def __init__(self, responses=None, raise_exc=False):
        self.groups = DummyGroups(responses, raise_exc=raise_exc)
        self.me = True  # To pass hasattr(self.client, "me") in OneNoteDataSource

    def get_ms_graph_service_client(self):
        return self


class DummyMSGraphClient:
    """Simulates the MSGraphClient wrapper."""

    def __init__(self, responses=None, raise_exc=False):
        self._client = DummyClient(responses, raise_exc=raise_exc)

    def get_client(self):
        return self._client


# --- Unit Tests ---


@pytest.mark.asyncio
async def test_basic_async_await_behavior():
    """Test that the function can be awaited and returns a coroutine."""
    client = DummyMSGraphClient()
    ds = OneNoteDataSource(client)
    codeflash_output = ds.groups_onenote_section_groups_get_section_groups(
        group_id="gid", sectionGroup_id="sgid", sectionGroup_id1="sgid2"
    )
    coro = codeflash_output
    resp = await coro


@pytest.mark.asyncio
async def test_with_select_and_expand():
    """Test select and expand parameters are accepted and used."""
    client = DummyMSGraphClient()
    ds = OneNoteDataSource(client)
    resp = await ds.groups_onenote_section_groups_get_section_groups(
        group_id="gid",
        sectionGroup_id="sgid",
        sectionGroup_id1="sgid3",
        select=["id", "name"],
        expand=["sections"],
    )


@pytest.mark.asyncio
async def test_with_headers_and_search():
    """Test that headers and search parameters are handled."""
    client = DummyMSGraphClient()
    ds = OneNoteDataSource(client)
    resp = await ds.groups_onenote_section_groups_get_section_groups(
        group_id="gid",
        sectionGroup_id="sgid",
        sectionGroup_id1="sgid4",
        headers={"Authorization": "Bearer token"},
        search="foo",
    )


@pytest.mark.asyncio
async def test_edge_case_none_response():
    """Test that a None response from the API returns a failed OneNoteResponse."""

    class NoneSectionGroups(DummySectionGroups):
        async def get(self, request_configuration=None):
            return None

    class NoneOnenote(DummyOnenote):
        def __init__(self):
            self.section_groups = NoneSectionGroups()

    class NoneGroups(DummyGroups):
        def by_group_id(self, group_id):
            self.group_id = group_id
            return self

        @property
        def onenote(self):
            return NoneOnenote()

    class NoneClient(DummyClient):
        def __init__(self):
            self.groups = NoneGroups()
            self.me = True

    class NoneMSGraphClient:
        def get_client(self):
            return NoneClient()

    ds = OneNoteDataSource(NoneMSGraphClient())
    resp = await ds.groups_onenote_section_groups_get_section_groups(
        group_id="gid", sectionGroup_id="sgid", sectionGroup_id1="sgid"
    )


@pytest.mark.asyncio
async def test_edge_case_api_error():
    """Test that an exception in the API call is handled and returned as error."""
    client = DummyMSGraphClient(raise_exc=True)
    ds = OneNoteDataSource(client)
    resp = await ds.groups_onenote_section_groups_get_section_groups(
        group_id="gid", sectionGroup_id="sgid", sectionGroup_id1="sgid"
    )


@pytest.mark.asyncio
async def test_edge_case_response_with_error_field():
    """Test that a response with an error field is handled as unsuccessful."""

    class ErrorSectionGroups(DummySectionGroups):
        async def get(self, request_configuration=None):
            return {"error": {"code": "BadRequest", "message": "Invalid section group"}}

    class ErrorOnenote(DummyOnenote):
        def __init__(self):
            self.section_groups = ErrorSectionGroups()

    class ErrorGroups(DummyGroups):
        def by_group_id(self, group_id):
            self.group_id = group_id
            return self

        @property
        def onenote(self):
            return ErrorOnenote()

    class ErrorClient(DummyClient):
        def __init__(self):
            self.groups = ErrorGroups()
            self.me = True

    class ErrorMSGraphClient:
        def get_client(self):
            return ErrorClient()

    ds = OneNoteDataSource(ErrorMSGraphClient())
    resp = await ds.groups_onenote_section_groups_get_section_groups(
        group_id="gid", sectionGroup_id="sgid", sectionGroup_id1="sgid"
    )


@pytest.mark.asyncio
async def test_concurrent_execution():
    """Test that multiple concurrent async calls return correct results."""
    responses = {
        "sgidA": {"id": "sgidA", "name": "SectionGroup-A"},
        "sgidB": {"id": "sgidB", "name": "SectionGroup-B"},
        "sgidC": {"id": "sgidC", "name": "SectionGroup-C"},
    }
    client = DummyMSGraphClient(responses=responses)
    ds = OneNoteDataSource(client)
    tasks = [
        ds.groups_onenote_section_groups_get_section_groups(
            group_id="gid", sectionGroup_id="sgid", sectionGroup_id1=sgid
        )
        for sgid in ["sgidA", "sgidB", "sgidC"]
    ]
    results = await asyncio.gather(*tasks)


@pytest.mark.asyncio
async def test_large_scale_concurrent_calls():
    """Test many concurrent calls for scalability and async safety."""
    responses = {
        f"sgid{i}": {"id": f"sgid{i}", "name": f"SectionGroup-{i}"} for i in range(20)
    }
    client = DummyMSGraphClient(responses=responses)
    ds = OneNoteDataSource(client)
    tasks = [
        ds.groups_onenote_section_groups_get_section_groups(
            group_id="gid", sectionGroup_id="sgid", sectionGroup_id1=f"sgid{i}"
        )
        for i in range(20)
    ]
    results = await asyncio.gather(*tasks)


@pytest.mark.asyncio
async def test_OneNoteDataSource_groups_onenote_section_groups_get_section_groups_throughput_high_load():
    """Throughput test: high concurrent load (but <1000)."""
    n = 100
    responses = {f"sgid{i}": {"id": f"sgid{i}"} for i in range(n)}
    client = DummyMSGraphClient(responses=responses)
    ds = OneNoteDataSource(client)
    tasks = [
        ds.groups_onenote_section_groups_get_section_groups(
            group_id="gid", sectionGroup_id="sgid", sectionGroup_id1=f"sgid{i}"
        )
        for i in range(n)
    ]
    results = await asyncio.gather(*tasks)


@pytest.mark.asyncio
async def test_OneNoteDataSource_groups_onenote_section_groups_get_section_groups_throughput_sustained_pattern():
    """Throughput test: sustained execution pattern with repeated calls."""
    responses = {f"sgid{i}": {"id": f"sgid{i}"} for i in range(10)}
    client = DummyMSGraphClient(responses=responses)
    ds = OneNoteDataSource(client)
    for _ in range(5):
        tasks = [
            ds.groups_onenote_section_groups_get_section_groups(
                group_id="gid", sectionGroup_id="sgid", sectionGroup_id1=f"sgid{i}"
            )
            for i in range(10)
        ]
        results = await asyncio.gather(*tasks)


# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

To edit these changes git checkout codeflash/optimize-OneNoteDataSource.groups_onenote_section_groups_get_section_groups-mjfercr1 and push.