⚡️ Speed up method OneNoteDataSource.me_onenote_notebooks_section_groups_sections_delete_pages_content by 8%

[codeflash-ai]

📄 8% (0.08x) speedup for OneNoteDataSource.me_onenote_notebooks_section_groups_sections_delete_pages_content in backend/python/app/sources/external/microsoft/one_note/one_note.py

⏱️ Runtime : 1.49 milliseconds → 1.37 milliseconds (best of 124 runs)

📝 Explanation and details

The optimization eliminates unnecessary object creation by conditionally instantiating the query_params RequestConfiguration object only when query parameters are actually needed.

What was optimized:

• Conditional object creation: The original code always created a query_params RequestConfiguration object, even when no query parameters were provided. The optimized version only creates this object when at least one query parameter (select, expand, filter, orderby, search, top, skip) is present.
• Reduced attribute assignments: By avoiding the creation of unused objects, the optimization eliminates unnecessary attribute assignments and memory allocations.

Why this leads to speedup:

• Object instantiation overhead: RequestConfiguration object creation involves constructor calls, memory allocation, and initialization overhead. When no query parameters are needed (which appears common based on the profiler showing 419 out of 464 calls had no query parameters), this overhead is completely avoided.
• Reduced memory pressure: Fewer object allocations reduce garbage collection pressure and memory fragmentation.

Performance impact:
The line profiler shows the optimization saves approximately 0.09ms per call (8% speedup), primarily by eliminating the query_params = RequestConfiguration() line execution in cases where no query parameters are used. The most significant savings come from avoiding object creation when calls use only basic parameters without query filters.

Test case benefits:
The optimization is particularly effective for test cases like test_delete_pages_content_basic_success() and test_delete_pages_content_with_headers() that don't use query parameters, representing common usage patterns where only required IDs and optional headers are provided. The throughput remains stable at 57,536 ops/sec, indicating the optimization doesn't impact concurrent execution performance.

✅ Correctness verification report:

Test	Status
⚙️ Existing Unit Tests	🔘 None Found
🌀 Generated Regression Tests	✅ 540 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 Optional

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


# Mocks for dependencies and response types
class OneNoteResponse:
    def __init__(self, success: bool, data=None, error: Optional[str] = None):
        self.success = success
        self.data = data
        self.error = error


class DummyPageContentDelete:
    def __init__(self, should_fail=False, error_msg=None, response_data=None):
        self.should_fail = should_fail
        self.error_msg = error_msg
        self.response_data = response_data or {"deleted": True}

    async def delete(self, request_configuration=None):
        # Simulate async deletion
        if self.should_fail:
            raise Exception(self.error_msg or "Simulated API failure")
        return self.response_data


class DummyPages:
    def __init__(self, should_fail=False, error_msg=None, response_data=None):
        self.should_fail = should_fail
        self.error_msg = error_msg
        self.response_data = response_data

    def by_onenote_page_id(self, onenotePage_id):
        return DummyPageContentDelete(
            should_fail=self.should_fail,
            error_msg=self.error_msg,
            response_data=self.response_data,
        )


class DummySections:
    def __init__(self, should_fail=False, error_msg=None, response_data=None):
        self.should_fail = should_fail
        self.error_msg = error_msg
        self.response_data = response_data

    def by_onenote_section_id(self, onenoteSection_id):
        return DummyPages(
            should_fail=self.should_fail,
            error_msg=self.error_msg,
            response_data=self.response_data,
        )


class DummySectionGroups:
    def __init__(self, should_fail=False, error_msg=None, response_data=None):
        self.should_fail = should_fail
        self.error_msg = error_msg
        self.response_data = response_data

    def by_section_group_id(self, sectionGroup_id):
        return DummySections(
            should_fail=self.should_fail,
            error_msg=self.error_msg,
            response_data=self.response_data,
        )


class DummyNotebooks:
    def __init__(self, should_fail=False, error_msg=None, response_data=None):
        self.should_fail = should_fail
        self.error_msg = error_msg
        self.response_data = response_data

    def by_notebook_id(self, notebook_id):
        return DummySectionGroups(
            should_fail=self.should_fail,
            error_msg=self.error_msg,
            response_data=self.response_data,
        )


class DummyMe:
    def __init__(self, should_fail=False, error_msg=None, response_data=None):
        self.should_fail = should_fail
        self.error_msg = error_msg
        self.response_data = response_data
        self.onenote = self

    @property
    def notebooks(self):
        return DummyNotebooks(
            should_fail=self.should_fail,
            error_msg=self.error_msg,
            response_data=self.response_data,
        )


class DummyClient:
    def __init__(self, should_fail=False, error_msg=None, response_data=None):
        self.me = DummyMe(
            should_fail=should_fail, error_msg=error_msg, response_data=response_data
        )

    def get_client(self):
        return self

    def get_ms_graph_service_client(self):
        return self


# ---------------------- UNIT TESTS ----------------------

# 1. Basic Test Cases


@pytest.mark.asyncio
async def test_delete_pages_content_basic_success():
    """Test basic successful deletion with valid IDs."""
    client = DummyClient()
    ds = OneNoteDataSource(client)
    result = await ds.me_onenote_notebooks_section_groups_sections_delete_pages_content(
        notebook_id="notebook1",
        sectionGroup_id="sg1",
        onenoteSection_id="section1",
        onenotePage_id="page1",
    )


@pytest.mark.asyncio
async def test_delete_pages_content_basic_with_select_expand():
    """Test deletion with select and expand query parameters."""
    client = DummyClient()
    ds = OneNoteDataSource(client)
    select = ["id", "title"]
    expand = ["parentNotebook"]
    result = await ds.me_onenote_notebooks_section_groups_sections_delete_pages_content(
        notebook_id="notebook1",
        sectionGroup_id="sg1",
        onenoteSection_id="section1",
        onenotePage_id="page1",
        select=select,
        expand=expand,
    )


@pytest.mark.asyncio
async def test_delete_pages_content_basic_with_headers():
    """Test deletion with custom headers."""
    client = DummyClient()
    ds = OneNoteDataSource(client)
    headers = {"Authorization": "Bearer token"}
    result = await ds.me_onenote_notebooks_section_groups_sections_delete_pages_content(
        notebook_id="notebook1",
        sectionGroup_id="sg1",
        onenoteSection_id="section1",
        onenotePage_id="page1",
        headers=headers,
    )


# 2. Edge Test Cases


@pytest.mark.asyncio
async def test_delete_pages_content_missing_ids():
    """Test deletion with missing or empty IDs (should still call the method)."""
    client = DummyClient()
    ds = OneNoteDataSource(client)
    result = await ds.me_onenote_notebooks_section_groups_sections_delete_pages_content(
        notebook_id="", sectionGroup_id="", onenoteSection_id="", onenotePage_id=""
    )


@pytest.mark.asyncio
async def test_delete_pages_content_api_failure():
    """Test API failure propagates error in OneNoteResponse."""
    client = DummyClient(should_fail=True, error_msg="API error occurred")
    ds = OneNoteDataSource(client)
    result = await ds.me_onenote_notebooks_section_groups_sections_delete_pages_content(
        notebook_id="notebook1",
        sectionGroup_id="sg1",
        onenoteSection_id="section1",
        onenotePage_id="page1",
    )


@pytest.mark.asyncio
async def test_delete_pages_content_handles_none_response():
    """Test the function handles None response gracefully."""

    # Patch DummyPageContentDelete to return None
    class DummyPageContentDeleteNone(DummyPageContentDelete):
        async def delete(self, request_configuration=None):
            return None

    class DummyPagesNone(DummyPages):
        def by_onenote_page_id(self, onenotePage_id):
            return DummyPageContentDeleteNone()

    class DummySectionsNone(DummySections):
        def by_onenote_section_id(self, onenoteSection_id):
            return DummyPagesNone()

    class DummySectionGroupsNone(DummySectionGroups):
        def by_section_group_id(self, sectionGroup_id):
            return DummySectionsNone()

    class DummyNotebooksNone(DummyNotebooks):
        def by_notebook_id(self, notebook_id):
            return DummySectionGroupsNone()

    class DummyMeNone(DummyMe):
        @property
        def notebooks(self):
            return DummyNotebooksNone()

    class DummyClientNone(DummyClient):
        def __init__(self):
            self.me = DummyMeNone()

        def get_client(self):
            return self

        def get_ms_graph_service_client(self):
            return self

    client = DummyClientNone()
    ds = OneNoteDataSource(client)
    result = await ds.me_onenote_notebooks_section_groups_sections_delete_pages_content(
        notebook_id="notebook1",
        sectionGroup_id="sg1",
        onenoteSection_id="section1",
        onenotePage_id="page1",
    )


@pytest.mark.asyncio
async def test_delete_pages_content_concurrent_execution():
    """Test concurrent execution of multiple deletions."""
    client = DummyClient()
    ds = OneNoteDataSource(client)
    coros = [
        ds.me_onenote_notebooks_section_groups_sections_delete_pages_content(
            notebook_id=f"notebook{i}",
            sectionGroup_id=f"sg{i}",
            onenoteSection_id=f"section{i}",
            onenotePage_id=f"page{i}",
        )
        for i in range(5)
    ]
    results = await asyncio.gather(*coros)
    for result in results:
        pass


@pytest.mark.asyncio
async def test_delete_pages_content_with_search_and_headers():
    """Test search query parameter triggers ConsistencyLevel header."""
    client = DummyClient()
    ds = OneNoteDataSource(client)
    result = await ds.me_onenote_notebooks_section_groups_sections_delete_pages_content(
        notebook_id="notebook1",
        sectionGroup_id="sg1",
        onenoteSection_id="section1",
        onenotePage_id="page1",
        search="meeting notes",
    )


# 3. Large Scale Test Cases


@pytest.mark.asyncio
async def test_delete_pages_content_large_scale_concurrent():
    """Test large scale concurrent deletions (50 requests)."""
    client = DummyClient()
    ds = OneNoteDataSource(client)
    coros = [
        ds.me_onenote_notebooks_section_groups_sections_delete_pages_content(
            notebook_id=f"notebook{i}",
            sectionGroup_id=f"sg{i}",
            onenoteSection_id=f"section{i}",
            onenotePage_id=f"page{i}",
        )
        for i in range(50)
    ]
    results = await asyncio.gather(*coros)
    for result in results:
        pass


@pytest.mark.asyncio
async def test_delete_pages_content_large_scale_with_varied_params():
    """Test large scale concurrent deletions with varied query params."""
    client = DummyClient()
    ds = OneNoteDataSource(client)
    coros = []
    for i in range(30):
        select = ["id"] if i % 2 == 0 else None
        expand = ["parentNotebook"] if i % 3 == 0 else None
        search = "notes" if i % 5 == 0 else None
        coros.append(
            ds.me_onenote_notebooks_section_groups_sections_delete_pages_content(
                notebook_id=f"notebook{i}",
                sectionGroup_id=f"sg{i}",
                onenoteSection_id=f"section{i}",
                onenotePage_id=f"page{i}",
                select=select,
                expand=expand,
                search=search,
            )
        )
    results = await asyncio.gather(*coros)
    for result in results:
        pass


# 4. Throughput Test Cases


@pytest.mark.asyncio
async def test_OneNoteDataSource_me_onenote_notebooks_section_groups_sections_delete_pages_content_throughput_small_load():
    """Throughput test: small load (5 requests)."""
    client = DummyClient()
    ds = OneNoteDataSource(client)
    coros = [
        ds.me_onenote_notebooks_section_groups_sections_delete_pages_content(
            notebook_id=f"notebook{i}",
            sectionGroup_id=f"sg{i}",
            onenoteSection_id=f"section{i}",
            onenotePage_id=f"page{i}",
        )
        for i in range(5)
    ]
    results = await asyncio.gather(*coros)
    for result in results:
        pass


@pytest.mark.asyncio
async def test_OneNoteDataSource_me_onenote_notebooks_section_groups_sections_delete_pages_content_throughput_medium_load():
    """Throughput test: medium load (20 requests)."""
    client = DummyClient()
    ds = OneNoteDataSource(client)
    coros = [
        ds.me_onenote_notebooks_section_groups_sections_delete_pages_content(
            notebook_id=f"notebook{i}",
            sectionGroup_id=f"sg{i}",
            onenoteSection_id=f"section{i}",
            onenotePage_id=f"page{i}",
        )
        for i in range(20)
    ]
    results = await asyncio.gather(*coros)
    for result in results:
        pass


@pytest.mark.asyncio
async def test_OneNoteDataSource_me_onenote_notebooks_section_groups_sections_delete_pages_content_throughput_high_volume():
    """Throughput test: high volume (100 requests)."""
    client = DummyClient()
    ds = OneNoteDataSource(client)
    coros = [
        ds.me_onenote_notebooks_section_groups_sections_delete_pages_content(
            notebook_id=f"notebook{i}",
            sectionGroup_id=f"sg{i}",
            onenoteSection_id=f"section{i}",
            onenotePage_id=f"page{i}",
        )
        for i in range(100)
    ]
    results = await asyncio.gather(*coros)
    for result 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.

import asyncio

# Dummy logger for the tested class
from typing import Optional

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

# --- Minimal stubs for dependencies to allow isolated testing ---


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


class DummyPagesContent:
    """Simulates the .content property with an async .delete method"""

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

    async def delete(self, request_configuration=None):
        # Simulate async deletion, return the response object
        return self._response


class DummyPages:
    """Simulates the .pages property, returning DummyPagesContent for a given page id"""

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

    def by_onenote_page_id(self, onenotePage_id):
        return DummyPagesContent(self._response)


class DummySections:
    """Simulates the .sections property, returning DummyPages for a given section id"""

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

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


class DummySectionGroups:
    """Simulates the .section_groups property, returning DummySections for a given section group id"""

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

    def by_section_group_id(self, sectionGroup_id):
        return DummySections(self._response)


class DummyNotebooks:
    """Simulates the .notebooks property, returning DummySectionGroups for a given notebook id"""

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

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


class DummyMe:
    """Simulates the .me property, returning DummyNotebooks"""

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

    @property
    def onenote(self):
        return self

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


class DummyMSGraphServiceClient:
    """Simulates the MSGraphServiceClient with .me property"""

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

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


class DummyMSGraphClient:
    """Simulates the MSGraphClient with .get_client() and .get_ms_graph_service_client()"""

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

    def get_client(self):
        return self

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


# --- TESTS ---

# 1. Basic Test Cases


@pytest.mark.asyncio
async def test_delete_pages_content_basic_success():
    """Test successful async deletion with valid IDs returns success=True and correct data."""
    # Simulate a successful response object
    response_obj = object()
    client = DummyMSGraphClient(response_obj)
    ds = OneNoteDataSource(client)
    result = await ds.me_onenote_notebooks_section_groups_sections_delete_pages_content(
        notebook_id="notebook1",
        sectionGroup_id="sg1",
        onenoteSection_id="sec1",
        onenotePage_id="page1",
    )


@pytest.mark.asyncio
async def test_delete_pages_content_basic_error_attribute():
    """Test response with .error attribute returns success=False and correct error message."""

    class Resp:
        error = "Page not found"

    client = DummyMSGraphClient(Resp())
    ds = OneNoteDataSource(client)
    result = await ds.me_onenote_notebooks_section_groups_sections_delete_pages_content(
        notebook_id="notebook1",
        sectionGroup_id="sg1",
        onenoteSection_id="sec1",
        onenotePage_id="page1",
    )


@pytest.mark.asyncio
async def test_delete_pages_content_basic_error_dict():
    """Test response as dict with 'error' key returns success=False and error message."""
    resp = {"error": {"code": "404", "message": "Not found"}}
    client = DummyMSGraphClient(resp)
    ds = OneNoteDataSource(client)
    result = await ds.me_onenote_notebooks_section_groups_sections_delete_pages_content(
        notebook_id="notebook1",
        sectionGroup_id="sg1",
        onenoteSection_id="sec1",
        onenotePage_id="page1",
    )


@pytest.mark.asyncio
async def test_delete_pages_content_basic_error_code_message():
    """Test response with .code and .message attributes returns success=False and error message."""

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

    client = DummyMSGraphClient(Resp())
    ds = OneNoteDataSource(client)
    result = await ds.me_onenote_notebooks_section_groups_sections_delete_pages_content(
        notebook_id="notebook1",
        sectionGroup_id="sg1",
        onenoteSection_id="sec1",
        onenotePage_id="page1",
    )


@pytest.mark.asyncio
async def test_delete_pages_content_basic_empty_response():
    """Test None response returns success=False and specific error message."""
    client = DummyMSGraphClient(None)
    ds = OneNoteDataSource(client)
    result = await ds.me_onenote_notebooks_section_groups_sections_delete_pages_content(
        notebook_id="notebook1",
        sectionGroup_id="sg1",
        onenoteSection_id="sec1",
        onenotePage_id="page1",
    )


# 2. Edge Test Cases


@pytest.mark.asyncio
async def test_delete_pages_content_concurrent_unique_ids():
    """Test concurrent async deletion with unique IDs returns correct results."""
    client = DummyMSGraphClient("ok")
    ds = OneNoteDataSource(client)

    async def call(i):
        return (
            await ds.me_onenote_notebooks_section_groups_sections_delete_pages_content(
                notebook_id=f"nb{i}",
                sectionGroup_id=f"sg{i}",
                onenoteSection_id=f"sec{i}",
                onenotePage_id=f"pg{i}",
            )
        )

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


@pytest.mark.asyncio
async def test_delete_pages_content_concurrent_same_ids():
    """Test concurrent async deletion with same IDs returns correct results."""
    client = DummyMSGraphClient("ok")
    ds = OneNoteDataSource(client)

    async def call():
        return (
            await ds.me_onenote_notebooks_section_groups_sections_delete_pages_content(
                notebook_id="nb",
                sectionGroup_id="sg",
                onenoteSection_id="sec",
                onenotePage_id="pg",
            )
        )

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


@pytest.mark.asyncio
async def test_delete_pages_content_exception_handling():
    """Test that exceptions in the delete chain are caught and wrapped in OneNoteResponse."""

    class FailingDummyPagesContent(DummyPagesContent):
        async def delete(self, request_configuration=None):
            raise RuntimeError("Simulated API failure")

    class FailingDummyPages(DummyPages):
        def by_onenote_page_id(self, onenotePage_id):
            return FailingDummyPagesContent(None)

    class FailingDummySections(DummySections):
        def by_onenote_section_id(self, onenoteSection_id):
            return FailingDummyPages(None)

    class FailingDummySectionGroups(DummySectionGroups):
        def by_section_group_id(self, sectionGroup_id):
            return FailingDummySections(None)

    class FailingDummyNotebooks(DummyNotebooks):
        def by_notebook_id(self, notebook_id):
            return FailingDummySectionGroups(None)

    class FailingDummyMe(DummyMe):
        @property
        def notebooks(self):
            return FailingDummyNotebooks(None)

    class FailingDummyMSGraphServiceClient(DummyMSGraphServiceClient):
        @property
        def me(self):
            return FailingDummyMe(None)

    class FailingDummyMSGraphClient(DummyMSGraphClient):
        def get_ms_graph_service_client(self):
            return FailingDummyMSGraphServiceClient(None)

    client = FailingDummyMSGraphClient(None)
    ds = OneNoteDataSource(client)
    result = await ds.me_onenote_notebooks_section_groups_sections_delete_pages_content(
        notebook_id="nb",
        sectionGroup_id="sg",
        onenoteSection_id="sec",
        onenotePage_id="pg",
    )


@pytest.mark.asyncio
async def test_delete_pages_content_with_all_optional_params():
    """Test that all optional params are accepted and passed through."""
    response_obj = object()
    client = DummyMSGraphClient(response_obj)
    ds = OneNoteDataSource(client)
    result = await ds.me_onenote_notebooks_section_groups_sections_delete_pages_content(
        notebook_id="nb",
        sectionGroup_id="sg",
        onenoteSection_id="sec",
        onenotePage_id="pg",
        If_Match="etag",
        select=["id", "title"],
        expand=["parentNotebook"],
        filter="title eq 'Test'",
        orderby="title",
        search="Test Content",
        top=10,
        skip=2,
        headers={"Authorization": "Bearer X"},
    )


# 3. Large Scale Test Cases


@pytest.mark.asyncio
async def test_delete_pages_content_large_concurrent_load():
    """Test function under a moderate concurrent load (50 calls)."""
    client = DummyMSGraphClient("ok")
    ds = OneNoteDataSource(client)

    async def call(i):
        return (
            await ds.me_onenote_notebooks_section_groups_sections_delete_pages_content(
                notebook_id=f"nb{i}",
                sectionGroup_id=f"sg{i}",
                onenoteSection_id=f"sec{i}",
                onenotePage_id=f"pg{i}",
            )
        )

    results = await asyncio.gather(*(call(i) for i in range(50)))


@pytest.mark.asyncio
async def test_delete_pages_content_large_concurrent_with_failures():
    """Test function under concurrent load with some failures."""

    class MixedDummyPagesContent(DummyPagesContent):
        def __init__(self, response, fail=False):
            super().__init__(response)
            self.fail = fail

        async def delete(self, request_configuration=None):
            if self.fail:
                raise RuntimeError("Simulated failure")
            return self._response

    class MixedDummyPages(DummyPages):
        def __init__(self, response, fail=False):
            self._response = response
            self._fail = fail

        def by_onenote_page_id(self, onenotePage_id):
            return MixedDummyPagesContent(self._response, fail=self._fail)

    class MixedDummySections(DummySections):
        def __init__(self, response, fail=False):
            self._response = response
            self._fail = fail

        def by_onenote_section_id(self, onenoteSection_id):
            return MixedDummyPages(self._response, fail=self._fail)

    class MixedDummySectionGroups(DummySectionGroups):
        def __init__(self, response, fail=False):
            self._response = response
            self._fail = fail

        def by_section_group_id(self, sectionGroup_id):
            return MixedDummySections(self._response, fail=self._fail)

    class MixedDummyNotebooks(DummyNotebooks):
        def __init__(self, response, fail=False):
            self._response = response
            self._fail = fail

        def by_notebook_id(self, notebook_id):
            return MixedDummySectionGroups(self._response, fail=self._fail)

    class MixedDummyMe(DummyMe):
        def __init__(self, response, fail=False):
            self._response = response
            self._fail = fail

        @property
        def notebooks(self):
            return MixedDummyNotebooks(self._response, fail=self._fail)

    class MixedDummyMSGraphServiceClient(DummyMSGraphServiceClient):
        def __init__(self, response, fail=False):
            self._response = response
            self._fail = fail

        @property
        def me(self):
            return MixedDummyMe(self._response, fail=self._fail)

    class MixedDummyMSGraphClient(DummyMSGraphClient):
        def __init__(self, response, fail=False):
            self._response = response
            self._fail = fail

        def get_ms_graph_service_client(self):
            return MixedDummyMSGraphServiceClient(self._response, fail=self._fail)

    # 25 successes, 25 failures
    async def call(i):
        fail = i % 2 == 1
        client = MixedDummyMSGraphClient("ok", fail=fail)
        ds = OneNoteDataSource(client)
        return (
            await ds.me_onenote_notebooks_section_groups_sections_delete_pages_content(
                notebook_id=f"nb{i}",
                sectionGroup_id=f"sg{i}",
                onenoteSection_id=f"sec{i}",
                onenotePage_id=f"pg{i}",
            )
        )

    results = await asyncio.gather(*(call(i) for i in range(50)))


# 4. Throughput Test Cases


@pytest.mark.asyncio
async def test_OneNoteDataSource_me_onenote_notebooks_section_groups_sections_delete_pages_content_throughput_small_load():
    """Throughput test: small load (10 concurrent calls)."""
    client = DummyMSGraphClient("ok")
    ds = OneNoteDataSource(client)

    async def call():
        return (
            await ds.me_onenote_notebooks_section_groups_sections_delete_pages_content(
                notebook_id="nb",
                sectionGroup_id="sg",
                onenoteSection_id="sec",
                onenotePage_id="pg",
            )
        )

    results = await asyncio.gather(*(call() for _ in range(10)))


@pytest.mark.asyncio
async def test_OneNoteDataSource_me_onenote_notebooks_section_groups_sections_delete_pages_content_throughput_medium_load():
    """Throughput test: medium load (100 concurrent calls)."""
    client = DummyMSGraphClient("ok")
    ds = OneNoteDataSource(client)

    async def call(i):
        return (
            await ds.me_onenote_notebooks_section_groups_sections_delete_pages_content(
                notebook_id=f"nb{i}",
                sectionGroup_id=f"sg{i}",
                onenoteSection_id=f"sec{i}",
                onenotePage_id=f"pg{i}",
            )
        )

    results = await asyncio.gather(*(call(i) for i in range(100)))


@pytest.mark.asyncio
async def test_OneNoteDataSource_me_onenote_notebooks_section_groups_sections_delete_pages_content_throughput_with_headers_and_search():
    """Throughput test: concurrent calls with headers and search param."""
    client = DummyMSGraphClient("ok")
    ds = OneNoteDataSource(client)

    async def call(i):
        return (
            await ds.me_onenote_notebooks_section_groups_sections_delete_pages_content(
                notebook_id=f"nb{i}",
                sectionGroup_id=f"sg{i}",
                onenoteSection_id=f"sec{i}",
                onenotePage_id=f"pg{i}",
                headers={"Authorization": f"Bearer {i}"},
                search="findme",
            )
        )

    results = await asyncio.gather(*(call(i) for i in range(20)))


# 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_sections_delete_pages_content-mjc2ntzq and push.