⚡️ Speed up method OneNoteDataSource.groups_onenote_notebooks_sections_get_parent_section_group by 13%

[codeflash-ai]

📄 13% (0.13x) speedup for OneNoteDataSource.groups_onenote_notebooks_sections_get_parent_section_group in backend/python/app/sources/external/microsoft/one_note/one_note.py

⏱️ Runtime : 867 microseconds → 770 microseconds (best of 5 runs)

📝 Explanation and details

The optimized code achieves a 12% runtime improvement through two key optimizations that reduce unnecessary object creation and method calls:

What was optimized:

1. Conditional query parameter creation: Instead of always creating a NotebooksRequestBuilderGetQueryParameters object, the code now only creates it when OData parameters (select, expand, filter, etc.) are actually provided. This is achieved by checking has_odata_params = bool(select or expand or filter or orderby or search or top is not None or skip is not None) first.

2. Cached attribute chain lookups: The long method chain self.client.groups.by_group_id(group_id).onenote.notebooks.by_notebook_id(notebook_id).sections.by_onenote_section_id(onenoteSection_id).parent_section_group is broken into intermediate variables (group_ref, notebook_ref, section_ref, parent_section_group_ref).

Why this speeds up the code:

• Reduced object instantiation overhead: The line profiler shows the original code spent 16.6% of time (478,469ns) creating query parameter objects on every call. The optimized version only does this when needed (2 out of 215 calls in the test), dramatically reducing this overhead.
• Fewer attribute lookups: Breaking the method chain into cached references reduces the number of attribute resolution operations the Python interpreter must perform, though this provides a smaller benefit.

Performance characteristics:
The optimization is most effective when calls use default parameters (no OData queries), which appears to be the common case based on the profiler results showing only 2 out of 215 calls actually needed query parameters. For calls that do use OData parameters, the performance is essentially identical since the same objects still get created.

The 12% runtime improvement with unchanged throughput suggests this optimization primarily reduces per-call overhead rather than improving the async I/O performance of the actual API calls.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

import asyncio
# Patch imports for the function
import sys
import types

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

# --- Mock classes and helpers ---

class OneNoteResponse:
    """Simple OneNoteResponse mock for testing."""
    def __init__(self, success: bool, data=None, error=None):
        self.success = success
        self.data = data
        self.error = error

class DummyParentSectionGroup:
    """Dummy return value for parent_section_group.get()."""
    def __init__(self, value=None, error=None, code=None, message=None):
        self.value = value
        self.error = error
        self.code = code
        self.message = message

class DummyParentSectionGroupRequest:
    """Mock for .parent_section_group.get()"""
    def __init__(self, response):
        self._response = response
        self.called_with_config = None

    async def get(self, request_configuration=None):
        self.called_with_config = request_configuration
        # Simulate async call
        await asyncio.sleep(0)
        if isinstance(self._response, Exception):
            raise self._response
        return self._response

class DummySections:
    """Mock for .sections.by_onenote_section_id()"""
    def __init__(self, response):
        self._response = response

    def by_onenote_section_id(self, onenoteSection_id):
        return DummyParentSectionGroupRequest(self._response)

class DummyNotebooks:
    """Mock for .notebooks.by_notebook_id()"""
    def __init__(self, response):
        self._response = response

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

class DummyOnenote:
    """Mock for .onenote"""
    def __init__(self, response):
        self._response = response

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

class DummyGroup:
    """Mock for .groups.by_group_id()"""
    def __init__(self, response):
        self._response = response

    @property
    def onenote(self):
        return DummyOnenote(self._response)

class DummyGroups:
    """Mock for .groups"""
    def __init__(self, response):
        self._response = response

    def by_group_id(self, group_id):
        return DummyGroup(self._response)

class DummyGraphClient:
    """Mock for the GraphServiceClient."""
    def __init__(self, response):
        self._response = response

    @property
    def groups(self):
        return DummyGroups(self._response)

    @property
    def me(self):
        # Simulate attribute for client check
        return True

class DummyMSGraphClient:
    """Mock for MSGraphClient."""
    def __init__(self, response):
        self._response = response

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

class DummyMSGraphClientWrapper:
    """Mock for the wrapper class MSGraphClient."""
    def __init__(self, response):
        self._response = response

    def get_client(self):
        return DummyMSGraphClient(self._response)

# --- TESTS ---

# 1. Basic Test Cases

@pytest.mark.asyncio
async def test_basic_success_returns_expected_response():
    """Test basic successful call returns a OneNoteResponse with success True and correct data."""
    expected_data = {"id": "parent-section-group-1", "displayName": "Test Section Group"}
    response_obj = DummyParentSectionGroup(value="ignored")  # value is not used
    # Attach extra fields to simulate API response
    response_obj.id = expected_data["id"]
    response_obj.displayName = expected_data["displayName"]
    ds = OneNoteDataSource(DummyMSGraphClientWrapper(response_obj))
    result = await ds.groups_onenote_notebooks_sections_get_parent_section_group(
        group_id="g1", notebook_id="n1", onenoteSection_id="s1"
    )

@pytest.mark.asyncio
async def test_basic_returns_error_when_response_has_error_attr():
    """Test that if the response object has an error attribute, success is False and error is set."""
    response_obj = DummyParentSectionGroup(error="Some error occurred")
    ds = OneNoteDataSource(DummyMSGraphClientWrapper(response_obj))
    result = await ds.groups_onenote_notebooks_sections_get_parent_section_group(
        group_id="g1", notebook_id="n1", onenoteSection_id="s1"
    )

@pytest.mark.asyncio
async def test_basic_returns_error_when_response_is_dict_with_error_key():
    """Test that if the response is a dict with 'error', error is extracted."""
    response_obj = {"error": {"code": "403", "message": "Forbidden"}}
    ds = OneNoteDataSource(DummyMSGraphClientWrapper(response_obj))
    result = await ds.groups_onenote_notebooks_sections_get_parent_section_group(
        group_id="g1", notebook_id="n1", onenoteSection_id="s1"
    )

@pytest.mark.asyncio
async def test_basic_returns_error_when_response_is_none():
    """Test that a None response returns a OneNoteResponse with success=False and error message."""
    response_obj = None
    ds = OneNoteDataSource(DummyMSGraphClientWrapper(response_obj))
    result = await ds.groups_onenote_notebooks_sections_get_parent_section_group(
        group_id="g1", notebook_id="n1", onenoteSection_id="s1"
    )

@pytest.mark.asyncio
async def test_basic_handles_code_and_message_attrs():
    """Test that if the response has code and message attributes, error is formatted."""
    response_obj = DummyParentSectionGroup(code="404", message="Not Found")
    ds = OneNoteDataSource(DummyMSGraphClientWrapper(response_obj))
    result = await ds.groups_onenote_notebooks_sections_get_parent_section_group(
        group_id="g1", notebook_id="n1", onenoteSection_id="s1"
    )

# 2. Edge Test Cases

@pytest.mark.asyncio
async def test_edge_concurrent_execution():
    """Test concurrent calls with different parameters return expected results."""
    resp1 = DummyParentSectionGroup()
    resp1.id = "id1"
    resp1.displayName = "SectionGroup1"
    resp2 = DummyParentSectionGroup(error="Error2")
    ds = OneNoteDataSource(DummyMSGraphClientWrapper(resp1))
    ds2 = OneNoteDataSource(DummyMSGraphClientWrapper(resp2))

    async def call1():
        return await ds.groups_onenote_notebooks_sections_get_parent_section_group(
            group_id="g1", notebook_id="n1", onenoteSection_id="s1"
        )

    async def call2():
        return await ds2.groups_onenote_notebooks_sections_get_parent_section_group(
            group_id="g2", notebook_id="n2", onenoteSection_id="s2"
        )

    results = await asyncio.gather(call1(), call2())

@pytest.mark.asyncio
async def test_edge_exception_handling_in_async_context():
    """Test that exceptions in the async call are caught and returned as error."""
    exception = RuntimeError("Simulated network error")
    # The DummyParentSectionGroupRequest will raise this exception
    class ExplodingSections(DummySections):
        def by_onenote_section_id(self, onenoteSection_id):
            class ExplodingParentSectionGroupRequest:
                async def get(self, request_configuration=None):
                    await asyncio.sleep(0)
                    raise exception
            return ExplodingParentSectionGroupRequest()
    class ExplodingNotebooks(DummyNotebooks):
        def by_notebook_id(self, notebook_id):
            return ExplodingSections(None)
    class ExplodingOnenote(DummyOnenote):
        @property
        def notebooks(self):
            return ExplodingNotebooks(None)
    class ExplodingGroup(DummyGroup):
        @property
        def onenote(self):
            return ExplodingOnenote(None)
    class ExplodingGroups(DummyGroups):
        def by_group_id(self, group_id):
            return ExplodingGroup(None)
    class ExplodingGraphClient(DummyGraphClient):
        @property
        def groups(self):
            return ExplodingGroups(None)
    class ExplodingMSGraphClient(DummyMSGraphClient):
        def get_ms_graph_service_client(self):
            return ExplodingGraphClient(None)
    class ExplodingMSGraphClientWrapper:
        def get_client(self):
            return ExplodingMSGraphClient(None)

    ds = OneNoteDataSource(ExplodingMSGraphClientWrapper())
    result = await ds.groups_onenote_notebooks_sections_get_parent_section_group(
        group_id="g1", notebook_id="n1", onenoteSection_id="s1"
    )

@pytest.mark.asyncio
async def test_edge_select_and_expand_parameters():
    """Test that select and expand parameters are handled and passed as lists."""
    resp = DummyParentSectionGroup()
    resp.id = "id123"
    ds = OneNoteDataSource(DummyMSGraphClientWrapper(resp))
    result = await ds.groups_onenote_notebooks_sections_get_parent_section_group(
        group_id="g", notebook_id="n", onenoteSection_id="s",
        select=["id", "displayName"], expand="sections"
    )

@pytest.mark.asyncio
async def test_edge_headers_and_search_consistency_level():
    """Test that headers and search parameters result in ConsistencyLevel header being set."""
    class HeaderCheckParentSectionGroupRequest(DummyParentSectionGroupRequest):
        async def get(self, request_configuration=None):
            await asyncio.sleep(0)
            return DummyParentSectionGroup()
    class HeaderCheckSections(DummySections):
        def by_onenote_section_id(self, onenoteSection_id):
            return HeaderCheckParentSectionGroupRequest(DummyParentSectionGroup())
    class HeaderCheckNotebooks(DummyNotebooks):
        def by_notebook_id(self, notebook_id):
            return HeaderCheckSections(None)
    class HeaderCheckOnenote(DummyOnenote):
        @property
        def notebooks(self):
            return HeaderCheckNotebooks(None)
    class HeaderCheckGroup(DummyGroup):
        @property
        def onenote(self):
            return HeaderCheckOnenote(None)
    class HeaderCheckGroups(DummyGroups):
        def by_group_id(self, group_id):
            return HeaderCheckGroup(None)
    class HeaderCheckGraphClient(DummyGraphClient):
        @property
        def groups(self):
            return HeaderCheckGroups(None)
    class HeaderCheckMSGraphClient(DummyMSGraphClient):
        def get_ms_graph_service_client(self):
            return HeaderCheckGraphClient(None)
    class HeaderCheckMSGraphClientWrapper:
        def get_client(self):
            return HeaderCheckMSGraphClient(None)

    ds = OneNoteDataSource(HeaderCheckMSGraphClientWrapper())
    result = await ds.groups_onenote_notebooks_sections_get_parent_section_group(
        group_id="g", notebook_id="n", onenoteSection_id="s",
        search="foo", headers={"Custom": "X"}
    )

# 3. Large Scale Test Cases

@pytest.mark.asyncio

async def test_large_scale_with_mixed_success_and_failure():
    """Test a mix of successful and failing calls concurrently."""
    N = 20
    def make_resp(i):
        if i % 2 == 0:
            resp = DummyParentSectionGroup()
            resp.id = f"id{i}"
            return resp
        else:
            return DummyParentSectionGroup(error=f"error{i}")
    ds_list = [OneNoteDataSource(DummyMSGraphClientWrapper(make_resp(i))) for i in range(N)]

    async def call(ds, idx):
        return await ds.groups_onenote_notebooks_sections_get_parent_section_group(
            group_id=f"g{idx}", notebook_id=f"n{idx}", onenoteSection_id=f"s{idx}"
        )

    results = await asyncio.gather(*[call(ds_list[i], i) for i in range(N)])
    for i, result in enumerate(results):
        if i % 2 == 0:
            pass
        else:
            pass

# 4. Throughput Test Cases

@pytest.mark.asyncio

To edit these changes git checkout codeflash/optimize-OneNoteDataSource.groups_onenote_notebooks_sections_get_parent_section_group-mjbdwy40 and push.