⚡️ Speed up method OneNoteDataSource.groups_group_onenote_notebooks_notebook_section_groups_section_group_sections_onenote_section_copy_to_notebook by 11%

[codeflash-ai]

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

⏱️ Runtime : 1.37 milliseconds → 1.24 milliseconds (best of 73 runs)

📝 Explanation and details

The optimized code achieves a 10% runtime improvement (1.37ms → 1.24ms) and 1.4% throughput increase through three key optimizations:

1. Eliminated Unnecessary Object Instantiation

• Replaced RequestConfiguration() object creation for query parameters with a simple dictionary (query_params = {}), only creating the RequestConfiguration object when actually needed
• Line profiler shows the original instantiation took 728,289ns (10.8% of execution time), now reduced to 154,415ns (2.3%)

2. Conditional Query Parameter Assignment

• Added if query_params: check before assigning to config.query_parameters, avoiding unnecessary assignment when no query parameters are provided
• This prevents creating empty query parameter objects for requests that don't need them

3. Optimized Method Chain Access

• Split the long chained method call into a variable (section_req) to avoid redundant property lookups during the API call
• The line profiler shows this reorganization improved performance by reducing repeated attribute access overhead

4. Input Protection Enhancement

• Added headers.copy() to prevent mutation of the input headers dictionary, improving safety without performance cost

These optimizations are particularly effective for high-volume OneNote API operations, as evidenced by the throughput tests showing consistent improvements across small (10), medium (50), and large (100) concurrent request loads. The optimizations reduce object creation overhead and method resolution time, which compounds when processing many concurrent requests typical in OneNote integration scenarios.

✅ Correctness verification report:

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

🌀 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 stubs for dependencies ---


class OneNoteResponse:
    """Minimal OneNoteResponse stub for testing."""

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


class DummyCopyToNotebookPost:
    """Stub for the .post method in the OneNote client chain."""

    async def post(self, body=None, request_configuration=None):
        # Simulate a successful response
        return {"copied": True, "body": body, "config": request_configuration}


class DummySections:
    """Stub for sections in the OneNote client chain."""

    def by_onenote_section_id(self, onenoteSection_id):
        return self

    copy_to_notebook = DummyCopyToNotebookPost()


class DummySectionGroups:
    """Stub for section_groups in the OneNote client chain."""

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


class DummyNotebooks:
    """Stub for notebooks in the OneNote client chain."""

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


class DummyOnenote:
    """Stub for onenote in the OneNote client chain."""

    notebooks = DummyNotebooks()
    section_groups = DummySectionGroups()


class DummyGroups:
    """Stub for groups in the OneNote client chain."""

    def by_group_id(self, group_id):
        return self

    onenote = DummyOnenote()


class DummyMSGraphServiceClient:
    """Stub for the MSGraphServiceClient."""

    groups = DummyGroups()
    me = True  # Used for validation in __init__


class DummyMSGraphClient:
    """Stub for MSGraphClient."""

    def get_client(self):
        return self

    def get_ms_graph_service_client(self):
        return DummyMSGraphServiceClient()


# --- Unit tests for the async function ---


@pytest.mark.asyncio
async def test_basic_success_case():
    """Basic test: Should return a successful OneNoteResponse with expected data."""
    ds = OneNoteDataSource(DummyMSGraphClient())
    result = await ds.groups_group_onenote_notebooks_notebook_section_groups_section_group_sections_onenote_section_copy_to_notebook(
        group_id="group1",
        notebook_id="notebook1",
        sectionGroup_id="sg1",
        onenoteSection_id="sec1",
    )


@pytest.mark.asyncio
async def test_with_select_and_expand():
    """Test select and expand parameters."""
    ds = OneNoteDataSource(DummyMSGraphClient())
    result = await ds.groups_group_onenote_notebooks_notebook_section_groups_section_group_sections_onenote_section_copy_to_notebook(
        group_id="group2",
        notebook_id="notebook2",
        sectionGroup_id="sg2",
        onenoteSection_id="sec2",
        select=["name", "id"],
        expand=["pages"],
    )


@pytest.mark.asyncio
async def test_with_filter_orderby_top_skip():
    """Test filter, orderby, top, skip parameters."""
    ds = OneNoteDataSource(DummyMSGraphClient())
    result = await ds.groups_group_onenote_notebooks_notebook_section_groups_section_group_sections_onenote_section_copy_to_notebook(
        group_id="group3",
        notebook_id="notebook3",
        sectionGroup_id="sg3",
        onenoteSection_id="sec3",
        filter="name eq 'Test'",
        orderby="createdDateTime desc",
        top=5,
        skip=2,
    )


@pytest.mark.asyncio
async def test_with_search_and_headers():
    """Test search and custom headers."""
    ds = OneNoteDataSource(DummyMSGraphClient())
    custom_headers = {"Authorization": "Bearer FAKE"}
    result = await ds.groups_group_onenote_notebooks_notebook_section_groups_section_group_sections_onenote_section_copy_to_notebook(
        group_id="group4",
        notebook_id="notebook4",
        sectionGroup_id="sg4",
        onenoteSection_id="sec4",
        search="important notes",
        headers=custom_headers,
    )


@pytest.mark.asyncio
async def test_with_request_body():
    """Test passing a request body."""
    ds = OneNoteDataSource(DummyMSGraphClient())
    body = {"targetNotebookId": "notebookX"}
    result = await ds.groups_group_onenote_notebooks_notebook_section_groups_section_group_sections_onenote_section_copy_to_notebook(
        group_id="group5",
        notebook_id="notebook5",
        sectionGroup_id="sg5",
        onenoteSection_id="sec5",
        request_body=body,
    )


@pytest.mark.asyncio
async def test_edge_missing_required_params():
    """Edge case: Missing required parameters should raise TypeError."""
    ds = OneNoteDataSource(DummyMSGraphClient())
    with pytest.raises(TypeError):
        await ds.groups_group_onenote_notebooks_notebook_section_groups_section_group_sections_onenote_section_copy_to_notebook(
            group_id="group6",
            notebook_id="notebook6",
            sectionGroup_id="sg6",
            # Missing onenoteSection_id
        )


@pytest.mark.asyncio
async def test_edge_invalid_types():
    """Edge case: Invalid types for parameters should not crash but may return error."""
    ds = OneNoteDataSource(DummyMSGraphClient())
    # Pass int instead of str for IDs
    result = await ds.groups_group_onenote_notebooks_notebook_section_groups_section_group_sections_onenote_section_copy_to_notebook(
        group_id=123, notebook_id=456, sectionGroup_id=789, onenoteSection_id=1011
    )


@pytest.mark.asyncio
async def test_edge_none_ids():
    """Edge case: None for required IDs should not crash but may return error."""
    ds = OneNoteDataSource(DummyMSGraphClient())
    result = await ds.groups_group_onenote_notebooks_notebook_section_groups_section_group_sections_onenote_section_copy_to_notebook(
        group_id=None, notebook_id=None, sectionGroup_id=None, onenoteSection_id=None
    )


@pytest.mark.asyncio
async def test_edge_empty_strings():
    """Edge case: Empty strings for required IDs."""
    ds = OneNoteDataSource(DummyMSGraphClient())
    result = await ds.groups_group_onenote_notebooks_notebook_section_groups_section_group_sections_onenote_section_copy_to_notebook(
        group_id="", notebook_id="", sectionGroup_id="", onenoteSection_id=""
    )


@pytest.mark.asyncio
async def test_concurrent_execution():
    """Edge case: Run several requests concurrently and ensure all succeed."""
    ds = OneNoteDataSource(DummyMSGraphClient())
    coros = [
        ds.groups_group_onenote_notebooks_notebook_section_groups_section_group_sections_onenote_section_copy_to_notebook(
            group_id=f"g{i}",
            notebook_id=f"n{i}",
            sectionGroup_id=f"sg{i}",
            onenoteSection_id=f"s{i}",
        )
        for i in range(10)
    ]
    results = await asyncio.gather(*coros)
    for result in results:
        pass


@pytest.mark.asyncio
async def test_exception_handling_in_chain():
    """Edge case: Simulate an exception in the chain and ensure error is returned."""

    class FailingCopyToNotebookPost:
        async def post(self, body=None, request_configuration=None):
            raise RuntimeError("Simulated failure")

    class FailingSections(DummySections):
        copy_to_notebook = FailingCopyToNotebookPost()

    class FailingSectionGroups(DummySectionGroups):
        def by_section_group_id(self, sectionGroup_id):
            return FailingSections()

    class FailingNotebooks(DummyNotebooks):
        def by_notebook_id(self, notebook_id):
            return FailingSectionGroups()

    class FailingOnenote(DummyOnenote):
        notebooks = FailingNotebooks()

    class FailingGroups(DummyGroups):
        onenote = FailingOnenote()

    class FailingMSGraphServiceClient(DummyMSGraphServiceClient):
        groups = FailingGroups()

    class FailingMSGraphClient(DummyMSGraphClient):
        def get_ms_graph_service_client(self):
            return FailingMSGraphServiceClient()

    ds = OneNoteDataSource(FailingMSGraphClient())
    result = await ds.groups_group_onenote_notebooks_notebook_section_groups_section_group_sections_onenote_section_copy_to_notebook(
        group_id="failgroup",
        notebook_id="failnotebook",
        sectionGroup_id="failsg",
        onenoteSection_id="failsec",
    )


# --- Large Scale Test Cases ---


@pytest.mark.asyncio
async def test_large_scale_many_concurrent_requests():
    """Large scale: Run many concurrent requests (up to 100) and check all succeed."""
    ds = OneNoteDataSource(DummyMSGraphClient())
    coros = [
        ds.groups_group_onenote_notebooks_notebook_section_groups_section_group_sections_onenote_section_copy_to_notebook(
            group_id=f"g{i}",
            notebook_id=f"n{i}",
            sectionGroup_id=f"sg{i}",
            onenoteSection_id=f"s{i}",
        )
        for i in range(100)
    ]
    results = await asyncio.gather(*coros)
    for result in results:
        pass


@pytest.mark.asyncio
async def test_large_scale_varied_parameters():
    """Large scale: Use varied parameters in concurrent requests."""
    ds = OneNoteDataSource(DummyMSGraphClient())
    coros = [
        ds.groups_group_onenote_notebooks_notebook_section_groups_section_group_sections_onenote_section_copy_to_notebook(
            group_id=f"g{i}",
            notebook_id=f"n{i}",
            sectionGroup_id=f"sg{i}",
            onenoteSection_id=f"s{i}",
            select=["id"] if i % 2 == 0 else ["name"],
            expand=["pages"] if i % 3 == 0 else None,
            filter="name eq 'Test'" if i % 5 == 0 else None,
            top=i % 10,
            skip=i % 7,
        )
        for i in range(50)
    ]
    results = await asyncio.gather(*coros)
    for result in results:
        pass


# --- Throughput Test Cases ---


@pytest.mark.asyncio
async def test_OneNoteDataSource_groups_group_onenote_notebooks_notebook_section_groups_section_group_sections_onenote_section_copy_to_notebook_throughput_small_load():
    """Throughput test: Small load (10 concurrent requests)."""
    ds = OneNoteDataSource(DummyMSGraphClient())
    coros = [
        ds.groups_group_onenote_notebooks_notebook_section_groups_section_group_sections_onenote_section_copy_to_notebook(
            group_id=f"tg{i}",
            notebook_id=f"tn{i}",
            sectionGroup_id=f"tsg{i}",
            onenoteSection_id=f"ts{i}",
        )
        for i in range(10)
    ]
    results = await asyncio.gather(*coros)
    for result in results:
        pass


@pytest.mark.asyncio
async def test_OneNoteDataSource_groups_group_onenote_notebooks_notebook_section_groups_section_group_sections_onenote_section_copy_to_notebook_throughput_medium_load():
    """Throughput test: Medium load (50 concurrent requests)."""
    ds = OneNoteDataSource(DummyMSGraphClient())
    coros = [
        ds.groups_group_onenote_notebooks_notebook_section_groups_section_group_sections_onenote_section_copy_to_notebook(
            group_id=f"mg{i}",
            notebook_id=f"mn{i}",
            sectionGroup_id=f"msg{i}",
            onenoteSection_id=f"ms{i}",
        )
        for i in range(50)
    ]
    results = await asyncio.gather(*coros)
    for result in results:
        pass


@pytest.mark.asyncio
async def test_OneNoteDataSource_groups_group_onenote_notebooks_notebook_section_groups_section_group_sections_onenote_section_copy_to_notebook_throughput_large_load():
    """Throughput test: Large load (100 concurrent requests)."""
    ds = OneNoteDataSource(DummyMSGraphClient())
    coros = [
        ds.groups_group_onenote_notebooks_notebook_section_groups_section_group_sections_onenote_section_copy_to_notebook(
            group_id=f"lg{i}",
            notebook_id=f"ln{i}",
            sectionGroup_id=f"lsg{i}",
            onenoteSection_id=f"ls{i}",
        )
        for i in range(100)
    ]
    results = await asyncio.gather(*coros)
    for result in results:
        pass


@pytest.mark.asyncio
async def test_OneNoteDataSource_groups_group_onenote_notebooks_notebook_section_groups_section_group_sections_onenote_section_copy_to_notebook_throughput_sustained_execution():
    """Throughput test: Sustained execution pattern (10 sequential batches of 10)."""
    ds = OneNoteDataSource(DummyMSGraphClient())
    for batch in range(10):
        coros = [
            ds.groups_group_onenote_notebooks_notebook_section_groups_section_group_sections_onenote_section_copy_to_notebook(
                group_id=f"sg{batch}_{i}",
                notebook_id=f"sn{batch}_{i}",
                sectionGroup_id=f"ssg{batch}_{i}",
                onenoteSection_id=f"ss{batch}_{i}",
            )
            for i in range(10)
        ]
        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
# Patch logger for the tested class (to avoid NameError)

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


# Mock and helper classes for testing
class OneNoteResponse:
    """Simple OneNoteResponse mock for testing."""

    def __init__(self, success, data=None, error=None):
        self.success = success
        self.data = data
        self.error = error


class DummyCopyToNotebook:
    """Dummy async .post() method for OneNote copy_to_notebook endpoint."""

    def __init__(self, response=None, raise_exc=None):
        self._response = response
        self._raise_exc = raise_exc
        self._called_with = None

    async def post(self, body=None, request_configuration=None):
        self._called_with = (body, request_configuration)
        if self._raise_exc:
            raise self._raise_exc
        return self._response


class DummySections:
    def __init__(self, copy_to_notebook):
        self.copy_to_notebook = copy_to_notebook

    def by_onenote_section_id(self, onenoteSection_id):
        return self


class DummySectionGroups:
    def __init__(self, sections):
        self.sections = sections

    def by_section_group_id(self, sectionGroup_id):
        return self


class DummyNotebooks:
    def __init__(self, section_groups):
        self.section_groups = section_groups

    def by_notebook_id(self, notebook_id):
        return self


class DummyOnenote:
    def __init__(self, notebooks):
        self.notebooks = notebooks


class DummyGroups:
    def __init__(self, onenote):
        self.onenote = onenote

    def by_group_id(self, group_id):
        return self


class DummyClient:
    """Dummy client chain for .groups.by_group_id..."""

    def __init__(self, response=None, raise_exc=None):
        # Compose the full chain
        self._copy_to_notebook = DummyCopyToNotebook(
            response=response, raise_exc=raise_exc
        )
        self._sections = DummySections(self._copy_to_notebook)
        self._section_groups = DummySectionGroups(self._sections)
        self._notebooks = DummyNotebooks(self._section_groups)
        self._onenote = DummyOnenote(self._notebooks)
        self.groups = DummyGroups(self._onenote)
        self.me = True  # for __init__ check

    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_copy_to_notebook_basic_success():
    """Test basic successful async call returns expected OneNoteResponse."""
    # Arrange
    expected_data = {"id": "section123", "name": "My Section"}
    dummy_response = expected_data
    dummy_client = DummyClient(response=dummy_response)
    ds = OneNoteDataSource(dummy_client)
    # Act
    result = await ds.groups_group_onenote_notebooks_notebook_section_groups_section_group_sections_onenote_section_copy_to_notebook(
        group_id="g1", notebook_id="n1", sectionGroup_id="sg1", onenoteSection_id="s1"
    )


@pytest.mark.asyncio
async def test_copy_to_notebook_basic_error_dict():
    """Test response with error key in dict sets success=False and error message."""
    error_dict = {"error": {"code": "BadRequest", "message": "Invalid request"}}
    dummy_client = DummyClient(response=error_dict)
    ds = OneNoteDataSource(dummy_client)
    result = await ds.groups_group_onenote_notebooks_notebook_section_groups_section_group_sections_onenote_section_copy_to_notebook(
        group_id="g1", notebook_id="n1", sectionGroup_id="sg1", onenoteSection_id="s1"
    )


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

    class Resp:
        error = "Something went wrong"

    dummy_client = DummyClient(response=Resp())
    ds = OneNoteDataSource(dummy_client)
    result = await ds.groups_group_onenote_notebooks_notebook_section_groups_section_group_sections_onenote_section_copy_to_notebook(
        group_id="g1", notebook_id="n1", sectionGroup_id="sg1", onenoteSection_id="s1"
    )


@pytest.mark.asyncio
async def test_copy_to_notebook_basic_handles_none_response():
    """Test that None response returns OneNoteResponse(success=False, error=...)"""
    dummy_client = DummyClient(response=None)
    ds = OneNoteDataSource(dummy_client)
    result = await ds.groups_group_onenote_notebooks_notebook_section_groups_section_group_sections_onenote_section_copy_to_notebook(
        group_id="g1", notebook_id="n1", sectionGroup_id="sg1", onenoteSection_id="s1"
    )


# 2. Edge Test Cases


@pytest.mark.asyncio
async def test_copy_to_notebook_with_all_parameters():
    """Test with all parameters (select, expand, filter, orderby, search, top, skip, headers, request_body)."""
    dummy_response = {"id": "abc", "status": "copied"}
    dummy_client = DummyClient(response=dummy_response)
    ds = OneNoteDataSource(dummy_client)
    result = await ds.groups_group_onenote_notebooks_notebook_section_groups_section_group_sections_onenote_section_copy_to_notebook(
        group_id="g1",
        notebook_id="n1",
        sectionGroup_id="sg1",
        onenoteSection_id="s1",
        select=["id", "name"],
        expand=["pages"],
        filter="name eq 'Test'",
        orderby="name",
        search="meeting notes",
        top=5,
        skip=2,
        request_body={"targetNotebookId": "n2"},
        headers={"Authorization": "Bearer token"},
    )


@pytest.mark.asyncio
async def test_copy_to_notebook_handles_exception():
    """Test that an exception in client.post is caught and returned as error."""
    dummy_client = DummyClient(raise_exc=RuntimeError("Simulated failure"))
    ds = OneNoteDataSource(dummy_client)
    result = await ds.groups_group_onenote_notebooks_notebook_section_groups_section_group_sections_onenote_section_copy_to_notebook(
        group_id="g1", notebook_id="n1", sectionGroup_id="sg1", onenoteSection_id="s1"
    )


@pytest.mark.asyncio
async def test_copy_to_notebook_with_kwargs():
    """Test that extra kwargs are accepted and do not break the call."""
    dummy_response = {"id": "xyz"}
    dummy_client = DummyClient(response=dummy_response)
    ds = OneNoteDataSource(dummy_client)
    # Pass extra keyword arguments
    result = await ds.groups_group_onenote_notebooks_notebook_section_groups_section_group_sections_onenote_section_copy_to_notebook(
        group_id="g1",
        notebook_id="n1",
        sectionGroup_id="sg1",
        onenoteSection_id="s1",
        custom_param1="foo",
        custom_param2=42,
    )


@pytest.mark.asyncio
async def test_copy_to_notebook_concurrent_invocations():
    """Test concurrent async calls do not interfere with each other."""
    dummy_response1 = {"id": "1"}
    dummy_response2 = {"id": "2"}
    client1 = DummyClient(response=dummy_response1)
    client2 = DummyClient(response=dummy_response2)
    ds1 = OneNoteDataSource(client1)
    ds2 = OneNoteDataSource(client2)
    # Run two async calls concurrently
    results = await asyncio.gather(
        ds1.groups_group_onenote_notebooks_notebook_section_groups_section_group_sections_onenote_section_copy_to_notebook(
            group_id="g1",
            notebook_id="n1",
            sectionGroup_id="sg1",
            onenoteSection_id="s1",
        ),
        ds2.groups_group_onenote_notebooks_notebook_section_groups_section_group_sections_onenote_section_copy_to_notebook(
            group_id="g2",
            notebook_id="n2",
            sectionGroup_id="sg2",
            onenoteSection_id="s2",
        ),
    )


@pytest.mark.asyncio
async def test_copy_to_notebook_handles_headers_and_search_consistency():
    """Test that search param sets ConsistencyLevel header even if headers is None."""
    dummy_response = {"id": "abc"}
    dummy_client = DummyClient(response=dummy_response)
    ds = OneNoteDataSource(dummy_client)
    # No headers, but search is set
    await ds.groups_group_onenote_notebooks_notebook_section_groups_section_group_sections_onenote_section_copy_to_notebook(
        group_id="g1",
        notebook_id="n1",
        sectionGroup_id="sg1",
        onenoteSection_id="s1",
        search="meeting",
    )
    # If the call did not raise, it passed (header logic is internal)


# 3. Large Scale Test Cases


@pytest.mark.asyncio
async def test_copy_to_notebook_large_scale_concurrent():
    """Test 50 concurrent async calls for scalability and isolation."""
    responses = [{"id": str(i)} for i in range(50)]
    clients = [DummyClient(response=resp) for resp in responses]
    ds_list = [OneNoteDataSource(client) for client in clients]
    coros = [
        ds.groups_group_onenote_notebooks_notebook_section_groups_section_group_sections_onenote_section_copy_to_notebook(
            group_id=f"g{i}",
            notebook_id=f"n{i}",
            sectionGroup_id=f"sg{i}",
            onenoteSection_id=f"s{i}",
        )
        for i, ds in enumerate(ds_list)
    ]
    results = await asyncio.gather(*coros)
    for i, result in enumerate(results):
        pass


# 4. Throughput Test Cases


@pytest.mark.asyncio
async def test_copy_to_notebook_throughput_small_load():
    """Throughput test: 5 concurrent async calls."""
    responses = [{"id": f"t{i}"} for i in range(5)]
    ds_list = [OneNoteDataSource(DummyClient(response=resp)) for resp in responses]
    coros = [
        ds.groups_group_onenote_notebooks_notebook_section_groups_section_group_sections_onenote_section_copy_to_notebook(
            group_id=f"tg{i}",
            notebook_id=f"tn{i}",
            sectionGroup_id=f"tsg{i}",
            onenoteSection_id=f"ts{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_copy_to_notebook_throughput_medium_load():
    """Throughput test: 20 concurrent async calls."""
    responses = [{"id": f"m{i}"} for i in range(20)]
    ds_list = [OneNoteDataSource(DummyClient(response=resp)) for resp in responses]
    coros = [
        ds.groups_group_onenote_notebooks_notebook_section_groups_section_group_sections_onenote_section_copy_to_notebook(
            group_id=f"mg{i}",
            notebook_id=f"mn{i}",
            sectionGroup_id=f"msg{i}",
            onenoteSection_id=f"ms{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_copy_to_notebook_throughput_large_load():
    """Throughput test: 100 concurrent async calls (upper bound for fast testing)."""
    responses = [{"id": f"L{i}"} for i in range(100)]
    ds_list = [OneNoteDataSource(DummyClient(response=resp)) for resp in responses]
    coros = [
        ds.groups_group_onenote_notebooks_notebook_section_groups_section_group_sections_onenote_section_copy_to_notebook(
            group_id=f"Lg{i}",
            notebook_id=f"Ln{i}",
            sectionGroup_id=f"Lsg{i}",
            onenoteSection_id=f"Ls{i}",
        )
        for i, ds in enumerate(ds_list)
    ]
    results = await asyncio.gather(*coros)
    for i, result in enumerate(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_group_onenote_notebooks_notebook_section_groups_section_group_sections_onenote_section_copy_to_notebook-mjaoazmw and push.