⚡️ Speed up method OneNoteDataSource.me_onenote_section_groups_update_sections by 11%

[codeflash-ai]

📄 11% (0.11x) speedup for OneNoteDataSource.me_onenote_section_groups_update_sections in backend/python/app/sources/external/microsoft/one_note/one_note.py

⏱️ Runtime : 847 microseconds → 763 microseconds (best of 74 runs)

📝 Explanation and details

The optimization achieves an 11% runtime improvement by reducing unnecessary object creation and configuration overhead in the OneNote API method chain.

Key Optimizations Applied:

1. Conditional query parameter instantiation: The original code always created a RequestConfiguration() object for query parameters, even when no parameters were provided. The optimized version first checks if any query parameters exist using a single boolean expression, only creating the configuration object when needed.

2. Eliminated redundant object creation: By adding the has_query_params check, the optimization avoids creating unnecessary RequestConfiguration instances in the common case where all optional parameters are None or falsy values.

3. Streamlined configuration assignment: The optimized code only assigns config.query_parameters when query_params is not None, reducing unnecessary attribute assignments.

Why This Leads to Speedup:

• Object creation overhead: Python object instantiation has significant overhead. The RequestConfiguration() constructor, property assignments, and memory allocation are avoided when no query parameters are needed.
• Reduced attribute lookups: Fewer property assignments on configuration objects means fewer dictionary lookups and attribute setting operations.
• Better CPU cache usage: Less object creation means better memory locality and reduced garbage collection pressure.

Performance Impact Analysis:

The line profiler shows the optimization is most effective when query parameters are absent (which appears to be the common case based on test patterns). In scenarios with 370 out of 374 calls having no query parameters, the optimization eliminates substantial unnecessary work. The 11% runtime improvement translates to meaningful gains in high-throughput OneNote API scenarios.

Test Case Performance Patterns:

The optimization performs well across all test scenarios - basic success cases, error handling, and concurrent execution patterns all benefit from reduced configuration overhead. The throughput tests with medium to high loads (50-100 concurrent calls) would particularly benefit from this optimization in production environments.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

import asyncio
from typing import Any, Optional

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

# --- Minimal mocks for dependencies ---


class OneNoteResponse:
    """Simple response wrapper for testing."""

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


class DummyPatchCall:
    """Simulates the final patch call in the chain."""

    def __init__(self, return_value=None, raise_exc: Exception = None):
        self._return_value = return_value
        self._raise_exc = raise_exc
        self.called_with = []

    async def patch(self, body=None, request_configuration=None):
        self.called_with.append((body, request_configuration))
        if self._raise_exc:
            raise self._raise_exc
        return self._return_value


class DummySectionGroups:
    """Simulates .section_groups in the chain."""

    def __init__(self, patch_call):
        self._patch_call = patch_call

    def by_section_group_id(self, sectionGroup_id):
        return self._patch_call


class DummyMe:
    """Simulates .me in the chain."""

    def __init__(self, patch_call):
        self.onenote = DummyOnenote(patch_call)


class DummyOnenote:
    """Simulates .onenote in the chain."""

    def __init__(self, patch_call):
        self.section_groups = DummySectionGroups(patch_call)


class DummyMSGraphServiceClient:
    """Simulates the MS Graph service client with .me attribute."""

    def __init__(self, patch_call):
        self.me = DummyMe(patch_call)


class DummyMSGraphClient:
    """Simulates the .get_client().get_ms_graph_service_client() chain."""

    def __init__(self, patch_call):
        self._patch_call = patch_call

    def get_client(self):
        return self

    def get_ms_graph_service_client(self):
        return DummyMSGraphServiceClient(self._patch_call)


# --- TESTS ---

# 1. Basic Test Cases


@pytest.mark.asyncio
async def test_update_sections_basic_success():
    """Basic: Should return OneNoteResponse(success=True) on valid patch response."""
    dummy_response = {"id": "section1", "name": "Section 1"}
    patch_call = DummyPatchCall(return_value=dummy_response)
    client = DummyMSGraphClient(patch_call)
    ds = OneNoteDataSource(client)
    result = await ds.me_onenote_section_groups_update_sections(
        sectionGroup_id="sgid",
        onenoteSection_id="sid",
        request_body={"name": "New Name"},
    )


@pytest.mark.asyncio
async def test_update_sections_basic_handles_none_response():
    """Basic: Should handle None response as error."""
    patch_call = DummyPatchCall(return_value=None)
    client = DummyMSGraphClient(patch_call)
    ds = OneNoteDataSource(client)
    result = await ds.me_onenote_section_groups_update_sections(
        sectionGroup_id="sgid", onenoteSection_id="sid"
    )


@pytest.mark.asyncio
async def test_update_sections_handles_patch_exception():
    """Edge: Should return OneNoteResponse(success=False) if patch raises exception."""
    patch_call = DummyPatchCall(raise_exc=RuntimeError("Simulated failure"))
    client = DummyMSGraphClient(patch_call)
    ds = OneNoteDataSource(client)
    result = await ds.me_onenote_section_groups_update_sections(
        sectionGroup_id="sgid", onenoteSection_id="sid"
    )


@pytest.mark.asyncio
async def test_update_sections_handles_error_in_response_object():
    """Edge: Should detect error attribute in response and set success=False."""

    class ErrorObj:
        error = "Something went wrong"

    patch_call = DummyPatchCall(return_value=ErrorObj())
    client = DummyMSGraphClient(patch_call)
    ds = OneNoteDataSource(client)
    result = await ds.me_onenote_section_groups_update_sections(
        sectionGroup_id="sgid", onenoteSection_id="sid"
    )


@pytest.mark.asyncio
async def test_update_sections_handles_error_in_response_dict():
    """Edge: Should detect error key in dict response and set success=False."""
    patch_call = DummyPatchCall(
        return_value={"error": {"code": "400", "message": "Bad request"}}
    )
    client = DummyMSGraphClient(patch_call)
    ds = OneNoteDataSource(client)
    result = await ds.me_onenote_section_groups_update_sections(
        sectionGroup_id="sgid", onenoteSection_id="sid"
    )


@pytest.mark.asyncio
async def test_update_sections_handles_code_and_message_attrs():
    """Edge: Should detect code/message attributes in response and set success=False."""

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

    patch_call = DummyPatchCall(return_value=Resp())
    client = DummyMSGraphClient(patch_call)
    ds = OneNoteDataSource(client)
    result = await ds.me_onenote_section_groups_update_sections(
        sectionGroup_id="sgid", onenoteSection_id="sid"
    )


@pytest.mark.asyncio
async def test_update_sections_concurrent_execution():
    """Edge: Should support concurrent execution without interference."""
    patch_call1 = DummyPatchCall(return_value={"id": "s1"})
    patch_call2 = DummyPatchCall(return_value={"id": "s2"})
    client1 = DummyMSGraphClient(patch_call1)
    client2 = DummyMSGraphClient(patch_call2)
    ds1 = OneNoteDataSource(client1)
    ds2 = OneNoteDataSource(client2)
    # Run both concurrently
    results = await asyncio.gather(
        ds1.me_onenote_section_groups_update_sections("sgid1", "sid1"),
        ds2.me_onenote_section_groups_update_sections("sgid2", "sid2"),
    )


@pytest.mark.asyncio
async def test_update_sections_large_scale_concurrent():
    """Large Scale: Many concurrent calls should all succeed and be isolated."""
    N = 50  # Reasonable for quick test
    patch_calls = [DummyPatchCall(return_value={"id": f"s{i}"}) for i in range(N)]
    clients = [DummyMSGraphClient(pc) for pc in patch_calls]
    ds_list = [OneNoteDataSource(cl) for cl in clients]
    coros = [
        ds.me_onenote_section_groups_update_sections(
            f"sgid{i}", f"sid{i}", request_body={"name": f"Section {i}"}
        )
        for i, ds in enumerate(ds_list)
    ]
    results = await asyncio.gather(*coros)
    for i, res in enumerate(results):
        pass


# 4. Throughput Test Cases


@pytest.mark.asyncio
async def test_OneNoteDataSource_me_onenote_section_groups_update_sections_throughput_small_load():
    """Throughput: Small batch of concurrent requests."""
    N = 5
    patch_calls = [DummyPatchCall(return_value={"id": f"s{i}"}) for i in range(N)]
    clients = [DummyMSGraphClient(pc) for pc in patch_calls]
    ds_list = [OneNoteDataSource(cl) for cl in clients]
    coros = [
        ds.me_onenote_section_groups_update_sections(
            f"sgid{i}", f"sid{i}", request_body={"name": f"Section {i}"}
        )
        for i, ds in enumerate(ds_list)
    ]
    results = await asyncio.gather(*coros)


@pytest.mark.asyncio
async def test_OneNoteDataSource_me_onenote_section_groups_update_sections_throughput_medium_load():
    """Throughput: Medium batch of concurrent requests."""
    N = 20
    patch_calls = [DummyPatchCall(return_value={"id": f"s{i}"}) for i in range(N)]
    clients = [DummyMSGraphClient(pc) for pc in patch_calls]
    ds_list = [OneNoteDataSource(cl) for cl in clients]
    coros = [
        ds.me_onenote_section_groups_update_sections(
            f"sgid{i}", f"sid{i}", request_body={"name": f"Section {i}"}
        )
        for i, ds in enumerate(ds_list)
    ]
    results = await asyncio.gather(*coros)


@pytest.mark.asyncio
async def test_OneNoteDataSource_me_onenote_section_groups_update_sections_throughput_large_load():
    """Throughput: Large batch of concurrent requests (stress test, but < 1000)."""
    N = 100
    patch_calls = [DummyPatchCall(return_value={"id": f"s{i}"}) for i in range(N)]
    clients = [DummyMSGraphClient(pc) for pc in patch_calls]
    ds_list = [OneNoteDataSource(cl) for cl in clients]
    coros = [
        ds.me_onenote_section_groups_update_sections(
            f"sgid{i}", f"sid{i}", request_body={"name": f"Section {i}"}
        )
        for i, ds in enumerate(ds_list)
    ]
    results = await asyncio.gather(*coros)


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

import asyncio
from typing import Any, Optional

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

# --- Minimal stubs for dependencies (do not mock, just stub for test instantiation) ---


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


class DummySectionPatch:
    """Dummy object to simulate the patch() async method chain."""

    def __init__(self, return_value=None, raise_exc: Exception = None):
        self._return_value = return_value
        self._raise_exc = raise_exc

    async def patch(self, body=None, request_configuration=None):
        if self._raise_exc:
            raise self._raise_exc
        # Simulate a patched section response
        return (
            self._return_value
            if self._return_value is not None
            else {"id": "section-id", "name": "Updated Section"}
        )


class DummySectionById:
    def __init__(self, patch_return=None, patch_exc=None):
        self._patch = DummySectionPatch(patch_return, patch_exc)

    def by_onenote_section_id(self, onenoteSection_id):
        return self._patch


class DummySections:
    def __init__(self, patch_return=None, patch_exc=None):
        self._byid = DummySectionById(patch_return, patch_exc)

    def by_onenote_section_id(self, onenoteSection_id):
        return self._byid.by_onenote_section_id(onenoteSection_id)


class DummySectionGroups:
    def __init__(self, patch_return=None, patch_exc=None):
        self._sections = DummySections(patch_return, patch_exc)

    def by_section_group_id(self, sectionGroup_id):
        return self._sections


class DummyMe:
    def __init__(self, patch_return=None, patch_exc=None):
        self.onenote = type("onenote", (), {})()
        self.onenote.section_groups = DummySectionGroups(patch_return, patch_exc)


class DummyGraphClient:
    def __init__(self, patch_return=None, patch_exc=None):
        self.me = DummyMe(patch_return, patch_exc)

    def get_ms_graph_service_client(self):
        return self


class DummyMSGraphClient:
    def __init__(self, patch_return=None, patch_exc=None):
        self._patch_return = patch_return
        self._patch_exc = patch_exc

    def get_client(self):
        return DummyGraphClient(self._patch_return, self._patch_exc)


# --- TESTS ---

# 1. Basic Test Cases


@pytest.mark.asyncio
async def test_me_onenote_section_groups_update_sections_basic_success():
    """Test basic successful update of a section."""
    # Arrange
    expected_response = {"id": "section-id", "name": "Updated Section"}
    ds = OneNoteDataSource(DummyMSGraphClient(patch_return=expected_response))
    # Act
    result = await ds.me_onenote_section_groups_update_sections(
        sectionGroup_id="sgid1",
        onenoteSection_id="secid1",
        request_body={"name": "Updated Section"},
    )


@pytest.mark.asyncio
async def test_me_onenote_section_groups_update_sections_basic_with_select_expand():
    """Test with select and expand parameters."""
    expected_response = {"id": "section-id", "name": "Updated Section", "extra": "foo"}
    ds = OneNoteDataSource(DummyMSGraphClient(patch_return=expected_response))
    result = await ds.me_onenote_section_groups_update_sections(
        sectionGroup_id="sgid2",
        onenoteSection_id="secid2",
        select=["id", "name"],
        expand=["pages"],
        request_body={"name": "Updated Section"},
    )


@pytest.mark.asyncio
async def test_me_onenote_section_groups_update_sections_basic_with_headers():
    """Test with custom headers."""
    expected_response = {"id": "section-id"}
    ds = OneNoteDataSource(DummyMSGraphClient(patch_return=expected_response))
    headers = {"Authorization": "Bearer token", "Custom-Header": "X"}
    result = await ds.me_onenote_section_groups_update_sections(
        sectionGroup_id="sgid3",
        onenoteSection_id="secid3",
        headers=headers,
        request_body={"name": "New Name"},
    )


# 2. Edge Test Cases


@pytest.mark.asyncio
async def test_me_onenote_section_groups_update_sections_empty_response():
    """Test handling of None response from patch (should be error)."""
    ds = OneNoteDataSource(DummyMSGraphClient(patch_return=None))
    result = await ds.me_onenote_section_groups_update_sections(
        sectionGroup_id="sgid4",
        onenoteSection_id="secid4",
        request_body={"name": "Should Fail"},
    )


@pytest.mark.asyncio
async def test_me_onenote_section_groups_update_sections_patch_raises_exception():
    """Test handling when the patch method raises an exception."""
    ds = OneNoteDataSource(DummyMSGraphClient(patch_exc=RuntimeError("patch failed")))
    result = await ds.me_onenote_section_groups_update_sections(
        sectionGroup_id="sgid5",
        onenoteSection_id="secid5",
        request_body={"name": "Should Fail"},
    )


@pytest.mark.asyncio
async def test_me_onenote_section_groups_update_sections_with_all_query_params():
    """Test all query parameters filled."""
    expected_response = {"id": "section-id", "name": "Updated Section"}
    ds = OneNoteDataSource(DummyMSGraphClient(patch_return=expected_response))
    result = await ds.me_onenote_section_groups_update_sections(
        sectionGroup_id="sgid6",
        onenoteSection_id="secid6",
        select=["id", "name"],
        expand=["pages"],
        filter="name eq 'foo'",
        orderby="name",
        search="foo",
        top=10,
        skip=3,
        request_body={"name": "Updated Section"},
    )


@pytest.mark.asyncio
async def test_me_onenote_section_groups_update_sections_error_dict_response():
    """Test when the response is a dict with an error key."""
    response = {"error": {"code": "400", "message": "Bad Request"}}
    ds = OneNoteDataSource(DummyMSGraphClient(patch_return=response))
    result = await ds.me_onenote_section_groups_update_sections(
        sectionGroup_id="sgid7",
        onenoteSection_id="secid7",
        request_body={"name": "fail"},
    )


@pytest.mark.asyncio
async def test_me_onenote_section_groups_update_sections_error_attr_response():
    """Test when the response has an error attribute."""

    class ErrorObj:
        error = "Something went wrong"

    ds = OneNoteDataSource(DummyMSGraphClient(patch_return=ErrorObj()))
    result = await ds.me_onenote_section_groups_update_sections(
        sectionGroup_id="sgid8",
        onenoteSection_id="secid8",
        request_body={"name": "fail"},
    )


@pytest.mark.asyncio
async def test_me_onenote_section_groups_update_sections_error_code_message_attrs():
    """Test when the response has code and message attributes."""

    class ErrorObj:
        code = "401"
        message = "Unauthorized"

    ds = OneNoteDataSource(DummyMSGraphClient(patch_return=ErrorObj()))
    result = await ds.me_onenote_section_groups_update_sections(
        sectionGroup_id="sgid9",
        onenoteSection_id="secid9",
        request_body={"name": "fail"},
    )


@pytest.mark.asyncio
async def test_me_onenote_section_groups_update_sections_concurrent():
    """Test concurrent execution of multiple updates."""
    expected_response = {"id": "section-id", "name": "Updated Section"}
    ds = OneNoteDataSource(DummyMSGraphClient(patch_return=expected_response))

    async def run_one(i):
        return await ds.me_onenote_section_groups_update_sections(
            sectionGroup_id=f"sgid{i}",
            onenoteSection_id=f"secid{i}",
            request_body={"name": f"Updated Section {i}"},
        )

    results = await asyncio.gather(*(run_one(i) for i in range(5)))
    for res in results:
        pass


# 3. Large Scale Test Cases


@pytest.mark.asyncio
async def test_me_onenote_section_groups_update_sections_large_scale_concurrent():
    """Test with a larger number of concurrent updates (scalability)."""
    expected_response = {"id": "section-id", "name": "Updated Section"}
    ds = OneNoteDataSource(DummyMSGraphClient(patch_return=expected_response))

    async def run_one(i):
        return await ds.me_onenote_section_groups_update_sections(
            sectionGroup_id=f"sgid{i}",
            onenoteSection_id=f"secid{i}",
            request_body={"name": f"Section {i}"},
        )

    # Run 20 concurrent updates (safe for test, not excessive)
    results = await asyncio.gather(*(run_one(i) for i in range(20)))
    for i, res in enumerate(results):
        pass


# 4. Throughput Test Cases


@pytest.mark.asyncio
async def test_me_onenote_section_groups_update_sections_throughput_small_load():
    """Throughput test with small load (5 concurrent calls)."""
    expected_response = {"id": "section-id", "name": "Updated"}
    ds = OneNoteDataSource(DummyMSGraphClient(patch_return=expected_response))

    async def run_one():
        return await ds.me_onenote_section_groups_update_sections(
            sectionGroup_id="sgid",
            onenoteSection_id="secid",
            request_body={"name": "Updated"},
        )

    results = await asyncio.gather(*(run_one() for _ in range(5)))
    for res in results:
        pass


@pytest.mark.asyncio
async def test_me_onenote_section_groups_update_sections_throughput_medium_load():
    """Throughput test with medium load (50 concurrent calls)."""
    expected_response = {"id": "section-id", "name": "Updated"}
    ds = OneNoteDataSource(DummyMSGraphClient(patch_return=expected_response))

    async def run_one():
        return await ds.me_onenote_section_groups_update_sections(
            sectionGroup_id="sgid",
            onenoteSection_id="secid",
            request_body={"name": "Updated"},
        )

    results = await asyncio.gather(*(run_one() for _ in range(50)))


@pytest.mark.asyncio
async def test_me_onenote_section_groups_update_sections_throughput_high_volume():
    """Throughput test with high volume (100 concurrent calls)."""
    expected_response = {"id": "section-id", "name": "Updated"}
    ds = OneNoteDataSource(DummyMSGraphClient(patch_return=expected_response))

    async def run_one():
        return await ds.me_onenote_section_groups_update_sections(
            sectionGroup_id="sgid",
            onenoteSection_id="secid",
            request_body={"name": "Updated"},
        )

    results = await asyncio.gather(*(run_one() for _ in range(100)))


# 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_section_groups_update_sections-mjg0l38l and push.