⚡️ Speed up method OneNoteDataSource.groups_onenote_notebooks_sections_update_pages by 5%

[codeflash-ai]

📄 5% (0.05x) speedup for OneNoteDataSource.groups_onenote_notebooks_sections_update_pages in backend/python/app/sources/external/microsoft/one_note/one_note.py

⏱️ Runtime : 627 microseconds → 595 microseconds (best of 5 runs)

📝 Explanation and details

The optimization achieves a 5% runtime improvement by reducing unnecessary object allocations and improving code locality in the OneNote API method.

Key optimizations applied:

1. Conditional object creation: The original code always created RequestConfiguration() objects regardless of whether any query parameters were provided. The optimized version only creates these objects when needed by checking any_query_param = select or expand or filter or orderby or search or top is not None or skip is not None first.

2. Method chain locality: The long Microsoft Graph API call chain is now stored in a local variable patch_builder before calling .patch(). This avoids potential repeated attribute lookups and improves CPU cache locality when accessing the method chain.

Why this leads to speedup:

• Reduced allocations: In the common case where no query parameters are provided (which appears to be ~98% based on profiler hits), the optimization eliminates unnecessary RequestConfiguration object creation and attribute assignments. Object allocation in Python has overhead due to memory management and initialization.

• Improved cache locality: Breaking the long method chain into a separate variable reduces the complexity of the final patch call, potentially improving instruction cache performance and reducing repeated attribute resolution.

Performance characteristics:

• The optimization is most effective for calls with minimal query parameters (the common case)
• Shows consistent 5% runtime improvement across test scenarios
• Maintains identical throughput characteristics since the core async operation remains unchanged
• All error handling and API behavior is preserved exactly

This optimization is particularly valuable in high-throughput OneNote integration scenarios where this method may be called frequently with minimal parameters.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

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

import pytest  # used for our unit tests
from app.sources.external.microsoft.one_note.one_note import OneNoteDataSource


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


# --- Mock MSGraphClient and its chain for patch ---
class PatchMock:
    def __init__(self, patch_return):
        self._patch_return = patch_return

    async def patch(self, body, request_configuration):
        # Simulate async patch operation
        return self._patch_return


class PagesMock:
    def __init__(self, patch_return):
        self._patch_return = patch_return

    def by_onenote_page_id(self, onenotePage_id):
        return PatchMock(self._patch_return)


class SectionsMock:
    def __init__(self, patch_return):
        self._patch_return = patch_return

    def by_onenote_section_id(self, onenoteSection_id):
        return PagesMock(self._patch_return)


class NotebooksMock:
    def __init__(self, patch_return):
        self._patch_return = patch_return

    def by_notebook_id(self, notebook_id):
        return SectionsMock(self._patch_return)


class OnenoteMock:
    def __init__(self, patch_return):
        self._patch_return = patch_return

    @property
    def notebooks(self):
        return NotebooksMock(self._patch_return)


class ByGroupIdMock:
    def __init__(self, patch_return):
        self._patch_return = patch_return

    @property
    def onenote(self):
        return OnenoteMock(self._patch_return)


class GroupsMock:
    def __init__(self, patch_return):
        self._patch_return = patch_return

    def by_group_id(self, group_id):
        return ByGroupIdMock(self._patch_return)


class ClientMock:
    def __init__(self, patch_return):
        self.groups = GroupsMock(patch_return)
        self.me = True  # To pass hasattr(self.client, "me")


class MSGraphClientMock:
    def __init__(self, patch_return):
        self._patch_return = patch_return

    def get_client(self):
        return self

    def get_ms_graph_service_client(self):
        return ClientMock(self._patch_return)


# ---- Unit Tests ----


@pytest.mark.asyncio
async def test_basic_success_response():
    """Basic: Test successful async update with minimal required parameters."""
    # Simulate a successful patch response
    patch_return = {"id": "page123", "title": "Updated Page"}
    client = MSGraphClientMock(patch_return)
    ds = OneNoteDataSource(client)
    resp = await ds.groups_onenote_notebooks_sections_update_pages(
        group_id="group1",
        notebook_id="notebook1",
        onenoteSection_id="section1",
        onenotePage_id="page123",
        request_body={"title": "Updated Page"},
    )


@pytest.mark.asyncio
async def test_basic_with_all_parameters():
    """Basic: Test update with all optional parameters set."""
    patch_return = {"id": "page456", "title": "Another Update"}
    client = MSGraphClientMock(patch_return)
    ds = OneNoteDataSource(client)
    resp = await ds.groups_onenote_notebooks_sections_update_pages(
        group_id="group2",
        notebook_id="notebook2",
        onenoteSection_id="section2",
        onenotePage_id="page456",
        select=["id", "title"],
        expand=["parentNotebook"],
        filter="title eq 'Another Update'",
        orderby="title",
        search="Update",
        top=10,
        skip=1,
        request_body={"title": "Another Update"},
        headers={"Custom-Header": "value"},
    )


@pytest.mark.asyncio
async def test_basic_none_response():
    """Basic: Test when patch returns None (API empty response)."""
    patch_return = None
    client = MSGraphClientMock(patch_return)
    ds = OneNoteDataSource(client)
    resp = await ds.groups_onenote_notebooks_sections_update_pages(
        group_id="group3",
        notebook_id="notebook3",
        onenoteSection_id="section3",
        onenotePage_id="page789",
        request_body={"title": "Should Fail"},
    )


@pytest.mark.asyncio
async def test_basic_error_in_response_attribute():
    """Basic: Test when patch returns object with .error attribute."""

    class ErrorObj:
        error = "Some error occurred"

    patch_return = ErrorObj()
    client = MSGraphClientMock(patch_return)
    ds = OneNoteDataSource(client)
    resp = await ds.groups_onenote_notebooks_sections_update_pages(
        group_id="group4",
        notebook_id="notebook4",
        onenoteSection_id="section4",
        onenotePage_id="page000",
        request_body={"title": "Error Page"},
    )


@pytest.mark.asyncio
async def test_basic_error_in_response_dict():
    """Basic: Test when patch returns dict with 'error' key."""
    patch_return = {"error": {"code": "BadRequest", "message": "Invalid request"}}
    client = MSGraphClientMock(patch_return)
    ds = OneNoteDataSource(client)
    resp = await ds.groups_onenote_notebooks_sections_update_pages(
        group_id="group5",
        notebook_id="notebook5",
        onenoteSection_id="section5",
        onenotePage_id="page001",
        request_body={"title": "Error Dict"},
    )


@pytest.mark.asyncio
async def test_basic_error_in_response_code_message():
    """Basic: Test when patch returns object with code/message attributes."""

    class CodeMsgObj:
        code = "404"
        message = "Not Found"

    patch_return = CodeMsgObj()
    client = MSGraphClientMock(patch_return)
    ds = OneNoteDataSource(client)
    resp = await ds.groups_onenote_notebooks_sections_update_pages(
        group_id="group6",
        notebook_id="notebook6",
        onenoteSection_id="section6",
        onenotePage_id="page002",
        request_body={"title": "Error CodeMsg"},
    )


# ---- Edge Cases ----


@pytest.mark.asyncio
async def test_edge_invalid_client_missing_me():
    """Edge: Test ValueError when client lacks 'me' attribute."""

    class BadClient:
        pass

    class MSGraphClientBadMock:
        def get_client(self):
            return self

        def get_ms_graph_service_client(self):
            return BadClient()

    with pytest.raises(ValueError):
        OneNoteDataSource(MSGraphClientBadMock())


@pytest.mark.asyncio
async def test_edge_patch_raises_exception():
    """Edge: Simulate patch raising an exception, should return OneNoteResponse with error."""

    class PatchMockExc(PatchMock):
        async def patch(self, body, request_configuration):
            raise RuntimeError("API failure!")

    class PagesMockExc(PagesMock):
        def by_onenote_page_id(self, onenotePage_id):
            return PatchMockExc(None)

    class SectionsMockExc(SectionsMock):
        def by_onenote_section_id(self, onenoteSection_id):
            return PagesMockExc(None)

    class NotebooksMockExc(NotebooksMock):
        def by_notebook_id(self, notebook_id):
            return SectionsMockExc(None)

    class OnenoteMockExc(OnenoteMock):
        @property
        def notebooks(self):
            return NotebooksMockExc(None)

    class ByGroupIdMockExc(ByGroupIdMock):
        @property
        def onenote(self):
            return OnenoteMockExc(None)

    class GroupsMockExc(GroupsMock):
        def by_group_id(self, group_id):
            return ByGroupIdMockExc(None)

    class ClientMockExc(ClientMock):
        def __init__(self):
            self.groups = GroupsMockExc(None)
            self.me = True

    class MSGraphClientMockExc(MSGraphClientMock):
        def get_client(self):
            return self

        def get_ms_graph_service_client(self):
            return ClientMockExc()

    ds = OneNoteDataSource(MSGraphClientMockExc(None))
    resp = await ds.groups_onenote_notebooks_sections_update_pages(
        group_id="group7",
        notebook_id="notebook7",
        onenoteSection_id="section7",
        onenotePage_id="page003",
        request_body={"title": "Exception"},
    )


@pytest.mark.asyncio
async def test_edge_concurrent_execution():
    """Edge: Run multiple concurrent updates and ensure all succeed."""
    patch_return = {"id": "page_concurrent", "title": "Concurrent"}
    client = MSGraphClientMock(patch_return)
    ds = OneNoteDataSource(client)
    tasks = [
        ds.groups_onenote_notebooks_sections_update_pages(
            group_id=f"group{i}",
            notebook_id=f"notebook{i}",
            onenoteSection_id=f"section{i}",
            onenotePage_id=f"page{i}",
            request_body={"title": f"Concurrent {i}"},
        )
        for i in range(5)
    ]
    results = await asyncio.gather(*tasks)
    for resp in results:
        pass


@pytest.mark.asyncio
async def test_edge_select_expand_as_string():
    """Edge: Test select/expand passed as string instead of list."""
    patch_return = {"id": "page_string", "title": "String Params"}
    client = MSGraphClientMock(patch_return)
    ds = OneNoteDataSource(client)
    resp = await ds.groups_onenote_notebooks_sections_update_pages(
        group_id="group8",
        notebook_id="notebook8",
        onenoteSection_id="section8",
        onenotePage_id="page004",
        select="id",
        expand="parentNotebook",
        request_body={"title": "String Params"},
    )


@pytest.mark.asyncio
async def test_edge_headers_none_and_search():
    """Edge: Test headers=None and search set, triggers ConsistencyLevel header."""
    patch_return = {"id": "page_search", "title": "Search"}
    client = MSGraphClientMock(patch_return)
    ds = OneNoteDataSource(client)
    resp = await ds.groups_onenote_notebooks_sections_update_pages(
        group_id="group9",
        notebook_id="notebook9",
        onenoteSection_id="section9",
        onenotePage_id="page005",
        search="FindMe",
        request_body={"title": "Search"},
    )


# ---- Large Scale ----


@pytest.mark.asyncio
async def test_large_scale_many_concurrent_updates():
    """Large Scale: Test 50 concurrent updates for scalability."""
    patch_return = {"id": "page_bulk", "title": "Bulk Update"}
    client = MSGraphClientMock(patch_return)
    ds = OneNoteDataSource(client)
    tasks = [
        ds.groups_onenote_notebooks_sections_update_pages(
            group_id=f"group_bulk_{i}",
            notebook_id=f"notebook_bulk_{i}",
            onenoteSection_id=f"section_bulk_{i}",
            onenotePage_id=f"page_bulk_{i}",
            request_body={"title": f"Bulk {i}"},
        )
        for i in range(50)
    ]
    results = await asyncio.gather(*tasks)
    for resp in results:
        pass


# ---- Throughput ----


@pytest.mark.asyncio
async def test_OneNoteDataSource_groups_onenote_notebooks_sections_update_pages_throughput_small_load():
    """Throughput: Small load (5 requests) should succeed quickly."""
    patch_return = {"id": "page_small", "title": "Small Load"}
    client = MSGraphClientMock(patch_return)
    ds = OneNoteDataSource(client)
    tasks = [
        ds.groups_onenote_notebooks_sections_update_pages(
            group_id=f"group_small_{i}",
            notebook_id=f"notebook_small_{i}",
            onenoteSection_id=f"section_small_{i}",
            onenotePage_id=f"page_small_{i}",
            request_body={"title": f"Small {i}"},
        )
        for i in range(5)
    ]
    results = await asyncio.gather(*tasks)
    for resp in results:
        pass


@pytest.mark.asyncio
async def test_OneNoteDataSource_groups_onenote_notebooks_sections_update_pages_throughput_medium_load():
    """Throughput: Medium load (20 requests) should succeed."""
    patch_return = {"id": "page_medium", "title": "Medium Load"}
    client = MSGraphClientMock(patch_return)
    ds = OneNoteDataSource(client)
    tasks = [
        ds.groups_onenote_notebooks_sections_update_pages(
            group_id=f"group_medium_{i}",
            notebook_id=f"notebook_medium_{i}",
            onenoteSection_id=f"section_medium_{i}",
            onenotePage_id=f"page_medium_{i}",
            request_body={"title": f"Medium {i}"},
        )
        for i in range(20)
    ]
    results = await asyncio.gather(*tasks)
    for resp in results:
        pass


@pytest.mark.asyncio
async def test_OneNoteDataSource_groups_onenote_notebooks_sections_update_pages_throughput_large_load():
    """Throughput: Large load (100 requests) should succeed."""
    patch_return = {"id": "page_large", "title": "Large Load"}
    client = MSGraphClientMock(patch_return)
    ds = OneNoteDataSource(client)
    tasks = [
        ds.groups_onenote_notebooks_sections_update_pages(
            group_id=f"group_large_{i}",
            notebook_id=f"notebook_large_{i}",
            onenoteSection_id=f"section_large_{i}",
            onenotePage_id=f"page_large_{i}",
            request_body={"title": f"Large {i}"},
        )
        for i in range(100)
    ]
    results = await asyncio.gather(*tasks)
    for resp in results:
        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.groups_onenote_notebooks_sections_update_pages-mjb5xnv3 and push.