⚡️ Speed up method OneNoteDataSource.me_onenote_notebooks_section_groups_get_section_groups by 38%

[codeflash-ai]

📄 38% (0.38x) speedup for OneNoteDataSource.me_onenote_notebooks_section_groups_get_section_groups in backend/python/app/sources/external/microsoft/one_note/one_note.py

⏱️ Runtime : 536 microseconds → 389 microseconds (best of 5 runs)

📝 Explanation and details

The optimized code achieves a 38% runtime improvement (536μs → 389μs) through several key micro-optimizations that reduce object creation overhead and attribute access costs:

Primary Optimizations:

1. Builder chain caching: The original code repeatedly traversed the long attribute chain self.client.me.onenote.notebooks.by_notebook_id(notebook_id).section_groups.by_section_group_id(sectionGroup_id).section_groups.by_section_group_id(sectionGroup_id1) on line 140. The optimized version caches this chain in a builder variable, eliminating redundant attribute lookups.

2. Conditional object creation: The original code always instantiated NotebooksRequestBuilderGetQueryParameters() and NotebooksRequestBuilderGetRequestConfiguration() objects regardless of whether query parameters were needed. The optimized version uses a need_query check to only create the query parameters object when at least one parameter is provided, reducing unnecessary allocations when no filtering/pagination is needed.

3. Reduced attribute assignments: By conditionally creating objects, the optimized version avoids setting unused properties on the query parameters object, reducing the number of attribute assignment operations.

Performance Impact Analysis:

From the line profiler data, the most expensive operations in the original code were:

• Object instantiation (16.4% of time for query_params, 8.3% for config)
• The actual API call (38% of time)
• Multiple conditional checks and assignments (cumulative ~10% of time)

The optimization successfully reduces the object creation overhead while preserving the API call cost, leading to the observed 38% speedup.

Test Case Performance:

The optimization is most beneficial for:

• Simple calls with few/no query parameters (majority of test cases) - avoids unnecessary object creation
• High-frequency scenarios - the reduced per-call overhead compounds with scale
• Error cases - still benefit from reduced setup overhead before exceptions occur

The throughput remains the same (575 ops/sec) because the optimization primarily reduces per-call latency rather than changing concurrency characteristics, but the 38% runtime reduction directly translates to improved response times in OneNote API integrations.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

import asyncio
from typing import Optional

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

# --- Minimal stubs for dependencies (to allow testing the function as-is) ---


class OneNoteResponse:
    def __init__(self, success: bool, data=None, error: Optional[str] = None):
        self.success = success
        self.data = data
        self.error = error


class DummySectionGroupsById:
    def __init__(self, response):
        self._response = response

    async def get(self, request_configuration=None):
        # Simulate async call
        return self._response


class DummySectionGroups:
    def __init__(self, response):
        self._response = response

    def by_section_group_id(self, section_group_id):
        return DummySectionGroupsById(self._response)


class DummyNotebooksById:
    def __init__(self, response):
        self._response = response

    @property
    def section_groups(self):
        return DummySectionGroups(self._response)


class DummyNotebooks:
    def __init__(self, response):
        self._response = response

    def by_notebook_id(self, notebook_id):
        return DummyNotebooksById(self._response)


class DummyMe:
    def __init__(self, response):
        self._response = response

    @property
    def onenote(self):
        return self

    @property
    def notebooks(self):
        return DummyNotebooks(self._response)


class DummyClient:
    def __init__(self, response):
        self._response = response

    @property
    def me(self):
        return DummyMe(self._response)


class DummyMSGraphClient:
    def __init__(self, response):
        self._response = response

    def get_client(self):
        return self

    def get_ms_graph_service_client(self):
        return DummyClient(self._response)


# --- TESTS ---

# Basic Test Cases


@pytest.mark.asyncio
async def test_me_onenote_notebooks_section_groups_get_section_groups_basic_with_optional_params():
    """Test with filter, orderby, search, top, skip, and headers."""
    dummy_response = {"id": "sg3", "name": "FilteredGroup"}
    client = DummyMSGraphClient(dummy_response)
    ds = OneNoteDataSource(client)
    result = await ds.me_onenote_notebooks_section_groups_get_section_groups(
        notebook_id="nb1",
        sectionGroup_id="sg0",
        sectionGroup_id1="sg3",
        filter="name eq 'FilteredGroup'",
        orderby="name",
        search="Filtered",
        top=10,
        skip=5,
        headers={"Authorization": "Bearer token"},
    )


# Edge Test Cases


@pytest.mark.asyncio
async def test_me_onenote_notebooks_section_groups_get_section_groups_error_response_object():
    """Test when the API returns an object with an error attribute."""

    class ErrorObj:
        error = "Some error"

    client = DummyMSGraphClient(ErrorObj())
    ds = OneNoteDataSource(client)
    result = await ds.me_onenote_notebooks_section_groups_get_section_groups(
        notebook_id="nb1", sectionGroup_id="sg0", sectionGroup_id1="sg4"
    )


@pytest.mark.asyncio
async def test_me_onenote_notebooks_section_groups_get_section_groups_error_response_dict():
    """Test when the API returns a dict with 'error' key."""
    dummy_response = {
        "error": {"code": "NotFound", "message": "Section group not found"}
    }
    client = DummyMSGraphClient(dummy_response)
    ds = OneNoteDataSource(client)
    result = await ds.me_onenote_notebooks_section_groups_get_section_groups(
        notebook_id="nb1", sectionGroup_id="sg0", sectionGroup_id1="sg5"
    )


@pytest.mark.asyncio
async def test_me_onenote_notebooks_section_groups_get_section_groups_error_response_code_message():
    """Test when the API returns an object with code and message attributes."""

    class ErrorObj:
        code = "403"
        message = "Forbidden"

    client = DummyMSGraphClient(ErrorObj())
    ds = OneNoteDataSource(client)
    result = await ds.me_onenote_notebooks_section_groups_get_section_groups(
        notebook_id="nb1", sectionGroup_id="sg0", sectionGroup_id1="sg6"
    )


@pytest.mark.asyncio
async def test_me_onenote_notebooks_section_groups_get_section_groups_none_response():
    """Test when the API returns None (should be handled as error)."""
    client = DummyMSGraphClient(None)
    ds = OneNoteDataSource(client)
    result = await ds.me_onenote_notebooks_section_groups_get_section_groups(
        notebook_id="nb1", sectionGroup_id="sg0", sectionGroup_id1="sg7"
    )


@pytest.mark.asyncio
async def test_me_onenote_notebooks_section_groups_get_section_groups_exception_in_get():
    """Test when an exception is raised during the get call."""

    class FailingSectionGroupsById:
        async def get(self, request_configuration=None):
            raise RuntimeError("Simulated failure")

    class FailingSectionGroups:
        def by_section_group_id(self, section_group_id):
            return FailingSectionGroupsById()

    class FailingNotebooksById:
        @property
        def section_groups(self):
            return FailingSectionGroups()

    class FailingNotebooks:
        def by_notebook_id(self, notebook_id):
            return FailingNotebooksById()

    class FailingMe:
        @property
        def onenote(self):
            return self

        @property
        def notebooks(self):
            return FailingNotebooks()

    class FailingClient:
        @property
        def me(self):
            return FailingMe()

    class FailingMSGraphClient:
        def get_client(self):
            return self

        def get_ms_graph_service_client(self):
            return FailingClient()

    client = FailingMSGraphClient()
    ds = OneNoteDataSource(client)
    result = await ds.me_onenote_notebooks_section_groups_get_section_groups(
        notebook_id="nb1", sectionGroup_id="sg0", sectionGroup_id1="sg8"
    )


@pytest.mark.asyncio
async def test_me_onenote_notebooks_section_groups_get_section_groups_large_scale_concurrent():
    """Test many concurrent calls for scalability."""
    responses = [{"id": f"sg{i}", "name": f"Group{i}"} for i in range(20)]
    clients = [DummyMSGraphClient(resp) for resp in responses]
    ds_list = [OneNoteDataSource(client) for client in clients]
    coros = [
        ds.me_onenote_notebooks_section_groups_get_section_groups(
            notebook_id="nb1", sectionGroup_id="sg0", sectionGroup_id1=f"sg{i}"
        )
        for i, ds in enumerate(ds_list)
    ]
    results = await asyncio.gather(*coros)
    for i, result in enumerate(results):
        pass


# Throughput Test Cases


@pytest.mark.asyncio
async def test_me_onenote_notebooks_section_groups_get_section_groups_throughput_varied_inputs():
    """Throughput test: varied inputs and responses."""
    responses = [{"id": f"sg{i}", "name": f"Group{i}"} for i in range(15)]
    clients = [DummyMSGraphClient(resp) for resp in responses]
    ds_list = [OneNoteDataSource(client) for client in clients]
    coros = [
        ds.me_onenote_notebooks_section_groups_get_section_groups(
            notebook_id="nb1", sectionGroup_id="sg0", sectionGroup_id1=f"sg{i}"
        )
        for i, ds in enumerate(ds_list)
    ]
    results = await asyncio.gather(*coros)
    for i, result in enumerate(results):
        pass


@pytest.mark.asyncio
async def test_me_onenote_notebooks_section_groups_get_section_groups_throughput_error_responses():
    """Throughput test: mix of success and error responses."""

    # Success and error responses mixed
    class ErrorObj:
        error = "API Error"

    responses = [
        {"id": f"sg{i}", "name": f"Group{i}"} if i % 2 == 0 else ErrorObj()
        for i in range(10)
    ]
    clients = [DummyMSGraphClient(resp) for resp in responses]
    ds_list = [OneNoteDataSource(client) for client in clients]
    coros = [
        ds.me_onenote_notebooks_section_groups_get_section_groups(
            notebook_id="nb1", sectionGroup_id="sg0", sectionGroup_id1=f"sg{i}"
        )
        for i, ds in enumerate(ds_list)
    ]
    results = await asyncio.gather(*coros)
    for i, result in enumerate(results):
        if i % 2 == 0:
            pass
        else:
            pass


# 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.me_onenote_notebooks_section_groups_get_section_groups-mjbu0fdw and push.