⚡️ Speed up method OneNoteDataSource.me_onenote_notebooks_notebook_sections_onenote_section_copy_to_section_group by 9%

[codeflash-ai]

📄 9% (0.09x) speedup for OneNoteDataSource.me_onenote_notebooks_notebook_sections_onenote_section_copy_to_section_group in backend/python/app/sources/external/microsoft/one_note/one_note.py

⏱️ Runtime : 1.10 milliseconds → 1.01 milliseconds (best of 171 runs)

📝 Explanation and details

The optimization achieves a 9% runtime speedup by eliminating unnecessary object creation and attribute assignments when no query parameters are provided.

Key optimization: The original code always created a RequestConfiguration() object for query_params and assigned it to config.query_parameters, even when no query parameters were specified. The optimized version uses conditional lazy initialization - it only creates the query_params object when at least one parameter (select, expand, filter, etc.) is actually provided.

Why this works: From the line profiler data, the original code spent significant time on:

• query_params = RequestConfiguration() (463,863 ns, 10.7% of total time)
• config.query_parameters = query_params (120,416 ns, 2.8% of total time)

These operations occurred on every call (417 hits), but were often unnecessary since most calls don't provide query parameters. The optimization reduces this overhead by checking if select or expand or filter or orderby or search or top is not None or skip is not None: before creating the query parameters object.

Performance impact: The test results show this optimization is particularly effective for basic API calls without query parameters (most common use case), while maintaining identical functionality. The 9% speedup comes from avoiding approximately 13.5% of the original function's object allocation overhead when no parameters are needed.

Workload benefits: This optimization benefits high-frequency OneNote API operations where most calls use only the required notebook_id and onenoteSection_id parameters without additional query options - a common pattern in bulk operations or simple data retrieval scenarios.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

import asyncio
# Dummy logger

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


# Dummy classes to stand in for real dependencies
class DummyCopyToSectionGroup:
    def __init__(self, response):
        self._response = response
        self._call_count = 0
        self._last_args = None
        self._last_kwargs = None

    async def post(self, body=None, request_configuration=None):
        self._call_count += 1
        self._last_args = (body, request_configuration)
        self._last_kwargs = {}
        # Simulate async operation
        await asyncio.sleep(0)
        if isinstance(self._response, Exception):
            raise self._response
        return self._response


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

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


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

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


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

    @property
    def onenote(self):
        return self

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


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

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


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

    def get_client(self):
        return self

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


# Dummy OneNoteResponse
class OneNoteResponse:
    def __init__(self, success, data=None, error=None):
        self.success = success
        self.data = data
        self.error = error


# ------------------ UNIT TESTS BEGIN HERE ------------------

# 1. Basic Test Cases


@pytest.mark.asyncio
async def test_basic_success_response():
    """Test basic successful response with required parameters."""
    expected_data = {"id": "section123", "name": "Section A"}
    ms_client = DummyMSGraphClient(response=expected_data)
    ds = OneNoteDataSource(ms_client)
    resp = await ds.me_onenote_notebooks_notebook_sections_onenote_section_copy_to_section_group(
        notebook_id="notebook1", onenoteSection_id="section1"
    )


@pytest.mark.asyncio
async def test_basic_with_all_parameters():
    """Test with all possible parameters set."""
    expected_data = {"id": "section456", "name": "Section B"}
    ms_client = DummyMSGraphClient(response=expected_data)
    ds = OneNoteDataSource(ms_client)
    resp = await ds.me_onenote_notebooks_notebook_sections_onenote_section_copy_to_section_group(
        notebook_id="notebook2",
        onenoteSection_id="section2",
        select=["id", "name"],
        expand=["pages"],
        filter="name eq 'Section B'",
        orderby="name",
        search="Section",
        top=5,
        skip=1,
        request_body={"groupId": "group1"},
        headers={"Authorization": "Bearer token"},
    )


@pytest.mark.asyncio
async def test_basic_async_await_behavior():
    """Test that the function returns a coroutine and can be awaited."""
    ms_client = DummyMSGraphClient(response={"id": "section789"})
    ds = OneNoteDataSource(ms_client)
    codeflash_output = (
        ds.me_onenote_notebooks_notebook_sections_onenote_section_copy_to_section_group(
            notebook_id="notebook3", onenoteSection_id="section3"
        )
    )
    coro = codeflash_output
    resp = await coro


# 2. Edge Test Cases


@pytest.mark.asyncio
async def test_edge_error_response_dict():
    """Test when the response is a dict with an error key."""
    error_dict = {"error": {"code": "BadRequest", "message": "Invalid section"}}
    ms_client = DummyMSGraphClient(response=error_dict)
    ds = OneNoteDataSource(ms_client)
    resp = await ds.me_onenote_notebooks_notebook_sections_onenote_section_copy_to_section_group(
        notebook_id="notebook4", onenoteSection_id="section4"
    )


@pytest.mark.asyncio
async def test_edge_error_response_object():
    """Test when the response is an object with error attribute."""

    class ErrorObj:
        error = "Something went wrong"

    ms_client = DummyMSGraphClient(response=ErrorObj())
    ds = OneNoteDataSource(ms_client)
    resp = await ds.me_onenote_notebooks_notebook_sections_onenote_section_copy_to_section_group(
        notebook_id="notebook5", onenoteSection_id="section5"
    )


@pytest.mark.asyncio
async def test_edge_exception_in_post():
    """Test when the client.post raises an exception."""
    ms_client = DummyMSGraphClient(response=RuntimeError("Network failure"))

    # Patch DummyCopyToSectionGroup to raise exception
    class FailingCopyToSectionGroup(DummyCopyToSectionGroup):
        async def post(self, body=None, request_configuration=None):
            raise RuntimeError("Network failure")

    class FailingSections(DummySections):
        def by_onenote_section_id(self, onenoteSection_id):
            return FailingCopyToSectionGroup(None)

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

    class FailingMe(DummyMe):
        @property
        def notebooks(self):
            return FailingNotebooks(None)

    class FailingClient(DummyClient):
        @property
        def me(self):
            return FailingMe(None)

    class FailingMSGraphClient(DummyMSGraphClient):
        def get_client(self):
            return self

        def get_ms_graph_service_client(self):
            return FailingClient(None)

    ds = OneNoteDataSource(FailingMSGraphClient(None))
    resp = await ds.me_onenote_notebooks_notebook_sections_onenote_section_copy_to_section_group(
        notebook_id="notebook6", onenoteSection_id="section6"
    )


@pytest.mark.asyncio
async def test_edge_concurrent_execution():
    """Test concurrent execution of multiple async calls."""
    ms_client = DummyMSGraphClient(response={"id": "section_concurrent"})
    ds = OneNoteDataSource(ms_client)
    coros = [
        ds.me_onenote_notebooks_notebook_sections_onenote_section_copy_to_section_group(
            notebook_id=f"notebook{i}", onenoteSection_id=f"section{i}"
        )
        for i in range(5)
    ]
    results = await asyncio.gather(*coros)
    for result in results:
        pass


@pytest.mark.asyncio
async def test_edge_none_response():
    """Test when the response is None (should return error)."""
    ms_client = DummyMSGraphClient(response=None)
    ds = OneNoteDataSource(ms_client)
    resp = await ds.me_onenote_notebooks_notebook_sections_onenote_section_copy_to_section_group(
        notebook_id="notebook7", onenoteSection_id="section7"
    )


@pytest.mark.asyncio
async def test_edge_search_adds_consistency_level_header():
    """Test that search parameter adds ConsistencyLevel header."""

    class HeaderSpyCopyToSectionGroup(DummyCopyToSectionGroup):
        async def post(self, body=None, request_configuration=None):
            self._last_config = request_configuration
            await asyncio.sleep(0)
            return {"id": "section_with_search"}

    class HeaderSpySections(DummySections):
        def by_onenote_section_id(self, onenoteSection_id):
            return HeaderSpyCopyToSectionGroup({"id": "section_with_search"})

    class HeaderSpyNotebooks(DummyNotebooks):
        def by_notebook_id(self, notebook_id):
            return HeaderSpySections({"id": "section_with_search"})

    class HeaderSpyMe(DummyMe):
        @property
        def notebooks(self):
            return HeaderSpyNotebooks({"id": "section_with_search"})

    class HeaderSpyClient(DummyClient):
        @property
        def me(self):
            return HeaderSpyMe({"id": "section_with_search"})

    class HeaderSpyMSGraphClient(DummyMSGraphClient):
        def get_client(self):
            return self

        def get_ms_graph_service_client(self):
            return HeaderSpyClient({"id": "section_with_search"})

    ds = OneNoteDataSource(HeaderSpyMSGraphClient(None))
    # We can't directly inspect the config inside the test, but we can check the response is correct
    resp = await ds.me_onenote_notebooks_notebook_sections_onenote_section_copy_to_section_group(
        notebook_id="notebook_search",
        onenoteSection_id="section_search",
        search="something",
    )


# 3. Large Scale Test Cases


@pytest.mark.asyncio
async def test_large_scale_many_concurrent_calls():
    """Test with a large number of concurrent async calls (but <100)."""
    ms_client = DummyMSGraphClient(response={"id": "section_large"})
    ds = OneNoteDataSource(ms_client)
    coros = [
        ds.me_onenote_notebooks_notebook_sections_onenote_section_copy_to_section_group(
            notebook_id=f"notebook{i}", onenoteSection_id=f"section{i}"
        )
        for i in range(50)
    ]
    results = await asyncio.gather(*coros)
    for res in results:
        pass


@pytest.mark.asyncio
async def test_large_scale_varied_parameters():
    """Test large scale with varied parameters for each call."""
    ms_client = DummyMSGraphClient(response={"id": "section_varied"})
    ds = OneNoteDataSource(ms_client)
    coros = [
        ds.me_onenote_notebooks_notebook_sections_onenote_section_copy_to_section_group(
            notebook_id=f"notebook_varied_{i}",
            onenoteSection_id=f"section_varied_{i}",
            select=["id"],
            top=i,
        )
        for i in range(20)
    ]
    results = await asyncio.gather(*coros)
    for res in results:
        pass


# 4. Throughput Test Cases


@pytest.mark.asyncio
async def test_OneNoteDataSource_me_onenote_notebooks_notebook_sections_onenote_section_copy_to_section_group_throughput_small_load():
    """Throughput test: small load (10 calls)."""
    ms_client = DummyMSGraphClient(response={"id": "section_small"})
    ds = OneNoteDataSource(ms_client)
    coros = [
        ds.me_onenote_notebooks_notebook_sections_onenote_section_copy_to_section_group(
            notebook_id=f"nb_small_{i}", onenoteSection_id=f"sec_small_{i}"
        )
        for i in range(10)
    ]
    results = await asyncio.gather(*coros)


@pytest.mark.asyncio
async def test_OneNoteDataSource_me_onenote_notebooks_notebook_sections_onenote_section_copy_to_section_group_throughput_medium_load():
    """Throughput test: medium load (50 calls)."""
    ms_client = DummyMSGraphClient(response={"id": "section_medium"})
    ds = OneNoteDataSource(ms_client)
    coros = [
        ds.me_onenote_notebooks_notebook_sections_onenote_section_copy_to_section_group(
            notebook_id=f"nb_medium_{i}", onenoteSection_id=f"sec_medium_{i}"
        )
        for i in range(50)
    ]
    results = await asyncio.gather(*coros)


@pytest.mark.asyncio
async def test_OneNoteDataSource_me_onenote_notebooks_notebook_sections_onenote_section_copy_to_section_group_throughput_large_load():
    """Throughput test: large load (100 calls)."""
    ms_client = DummyMSGraphClient(response={"id": "section_large"})
    ds = OneNoteDataSource(ms_client)
    coros = [
        ds.me_onenote_notebooks_notebook_sections_onenote_section_copy_to_section_group(
            notebook_id=f"nb_large_{i}", onenoteSection_id=f"sec_large_{i}"
        )
        for i in range(100)
    ]
    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 ---


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


class DummyCopyToSectionGroup:
    def __init__(self, should_raise=False, return_error=False, error_obj=None):
        self.should_raise = should_raise
        self.return_error = return_error
        self.error_obj = error_obj

    async def post(self, body=None, request_configuration=None):
        if self.should_raise:
            raise Exception("Simulated network error")
        if self.return_error:
            return self.error_obj
        # Simulate a valid response object
        return {"copied": True, "body": body, "config": request_configuration}


class DummySections:
    def __init__(self, should_raise=False, return_error=False, error_obj=None):
        self.should_raise = should_raise
        self.return_error = return_error
        self.error_obj = error_obj

    def by_onenote_section_id(self, section_id):
        return DummyCopyToSectionGroup(
            self.should_raise, self.return_error, self.error_obj
        )


class DummyNotebooks:
    def __init__(self, should_raise=False, return_error=False, error_obj=None):
        self.should_raise = should_raise
        self.return_error = return_error
        self.error_obj = error_obj

    def by_notebook_id(self, notebook_id):
        return DummySections(self.should_raise, self.return_error, self.error_obj)


class DummyMe:
    def __init__(self, should_raise=False, return_error=False, error_obj=None):
        self.onenote = DummyOnenote(should_raise, return_error, error_obj)


class DummyOnenote:
    def __init__(self, should_raise=False, return_error=False, error_obj=None):
        self.notebooks = DummyNotebooks(should_raise, return_error, error_obj)


class DummyMSGraphServiceClient:
    def __init__(self, should_raise=False, return_error=False, error_obj=None):
        self.me = DummyMe(should_raise, return_error, error_obj)


class DummyMSGraphClient:
    def __init__(self, should_raise=False, return_error=False, error_obj=None):
        self.should_raise = should_raise
        self.return_error = return_error
        self.error_obj = error_obj

    def get_client(self):
        return self

    def get_ms_graph_service_client(self):
        return DummyMSGraphServiceClient(
            self.should_raise, self.return_error, self.error_obj
        )


# --- TESTS ---

# 1. Basic Test Cases


@pytest.mark.asyncio
async def test_copy_to_section_group_basic_success():
    """Test basic successful copy operation with required parameters."""
    ds = OneNoteDataSource(DummyMSGraphClient())
    resp = await ds.me_onenote_notebooks_notebook_sections_onenote_section_copy_to_section_group(
        notebook_id="notebook1", onenoteSection_id="sectionA"
    )


@pytest.mark.asyncio
async def test_copy_to_section_group_with_all_parameters():
    """Test with all optional parameters filled."""
    ds = OneNoteDataSource(DummyMSGraphClient())
    resp = await ds.me_onenote_notebooks_notebook_sections_onenote_section_copy_to_section_group(
        notebook_id="notebook2",
        onenoteSection_id="sectionB",
        select=["id", "name"],
        expand=["pages"],
        filter="name eq 'Section1'",
        orderby="name",
        search="important",
        top=10,
        skip=2,
        request_body={"destinationId": "group1"},
        headers={"Custom-Header": "Value"},
    )


@pytest.mark.asyncio
async def test_copy_to_section_group_returns_error_dict():
    """Test when the response is a dict with an 'error' key."""
    error_obj = {"error": {"code": "BadRequest", "message": "Invalid section"}}
    ds = OneNoteDataSource(DummyMSGraphClient(return_error=True, error_obj=error_obj))
    resp = await ds.me_onenote_notebooks_notebook_sections_onenote_section_copy_to_section_group(
        notebook_id="nb", onenoteSection_id="sec"
    )


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

    class ErrorObj:
        error = "Something went wrong"

    ds = OneNoteDataSource(DummyMSGraphClient(return_error=True, error_obj=ErrorObj()))
    resp = await ds.me_onenote_notebooks_notebook_sections_onenote_section_copy_to_section_group(
        notebook_id="nb2", onenoteSection_id="sec2"
    )


@pytest.mark.asyncio
async def test_copy_to_section_group_returns_none():
    """Test when the response is None."""

    class DummyNoneCopyToSectionGroup:
        async def post(self, body=None, request_configuration=None):
            return None

    class DummyNoneSections:
        def by_onenote_section_id(self, section_id):
            return DummyNoneCopyToSectionGroup()

    class DummyNoneNotebooks:
        def by_notebook_id(self, notebook_id):
            return DummyNoneSections()

    class DummyNoneOnenote:
        def __init__(self):
            self.notebooks = DummyNoneNotebooks()

    class DummyNoneMe:
        def __init__(self):
            self.onenote = DummyNoneOnenote()

    class DummyNoneMSGraphServiceClient:
        def __init__(self):
            self.me = DummyNoneMe()

    class DummyNoneMSGraphClient:
        def get_client(self):
            return self

        def get_ms_graph_service_client(self):
            return DummyNoneMSGraphServiceClient()

    ds = OneNoteDataSource(DummyNoneMSGraphClient())
    resp = await ds.me_onenote_notebooks_notebook_sections_onenote_section_copy_to_section_group(
        notebook_id="nb3", onenoteSection_id="sec3"
    )


# 2. Edge Test Cases


@pytest.mark.asyncio
async def test_copy_to_section_group_concurrent_calls():
    """Test concurrent execution of the function."""
    ds = OneNoteDataSource(DummyMSGraphClient())
    tasks = [
        ds.me_onenote_notebooks_notebook_sections_onenote_section_copy_to_section_group(
            notebook_id=f"nb{i}", onenoteSection_id=f"sec{i}"
        )
        for i in range(10)
    ]
    results = await asyncio.gather(*tasks)
    for i, resp in enumerate(results):
        pass


@pytest.mark.asyncio
async def test_copy_to_section_group_exception_handling():
    """Test that exceptions in the async call are caught and returned as error."""
    ds = OneNoteDataSource(DummyMSGraphClient(should_raise=True))
    resp = await ds.me_onenote_notebooks_notebook_sections_onenote_section_copy_to_section_group(
        notebook_id="nbX", onenoteSection_id="secX"
    )


@pytest.mark.asyncio
async def test_copy_to_section_group_error_object_with_code_and_message():
    """Test error object with code and message attributes."""

    class ErrorObj:
        code = "Forbidden"
        message = "Access denied"

    ds = OneNoteDataSource(DummyMSGraphClient(return_error=True, error_obj=ErrorObj()))
    resp = await ds.me_onenote_notebooks_notebook_sections_onenote_section_copy_to_section_group(
        notebook_id="nbY", onenoteSection_id="secY"
    )


@pytest.mark.asyncio
async def test_copy_to_section_group_kwargs_passthrough():
    """Test that extra kwargs do not break the function."""
    ds = OneNoteDataSource(DummyMSGraphClient())
    resp = await ds.me_onenote_notebooks_notebook_sections_onenote_section_copy_to_section_group(
        notebook_id="nbZ", onenoteSection_id="secZ", custom_param="custom_value"
    )


# 3. Large Scale Test Cases


@pytest.mark.asyncio
async def test_copy_to_section_group_large_scale_concurrency():
    """Test the function under a moderately large number of concurrent calls."""
    ds = OneNoteDataSource(DummyMSGraphClient())
    N = 50
    tasks = [
        ds.me_onenote_notebooks_notebook_sections_onenote_section_copy_to_section_group(
            notebook_id=f"nb{i}", onenoteSection_id=f"sec{i}"
        )
        for i in range(N)
    ]
    results = await asyncio.gather(*tasks)
    for resp in results:
        pass


@pytest.mark.asyncio
async def test_copy_to_section_group_large_payload():
    """Test with a large request_body and headers."""
    ds = OneNoteDataSource(DummyMSGraphClient())
    big_body = {str(i): i for i in range(100)}
    big_headers = {f"Header-{i}": str(i) for i in range(100)}
    resp = await ds.me_onenote_notebooks_notebook_sections_onenote_section_copy_to_section_group(
        notebook_id="large_nb",
        onenoteSection_id="large_sec",
        request_body=big_body,
        headers=big_headers,
    )


# 4. Throughput Test Cases


@pytest.mark.asyncio
async def test_OneNoteDataSource_me_onenote_notebooks_notebook_sections_onenote_section_copy_to_section_group_throughput_small_load():
    """Throughput test: small batch of concurrent requests."""
    ds = OneNoteDataSource(DummyMSGraphClient())
    tasks = [
        ds.me_onenote_notebooks_notebook_sections_onenote_section_copy_to_section_group(
            notebook_id=f"nb{i}", onenoteSection_id=f"sec{i}"
        )
        for i in range(5)
    ]
    results = await asyncio.gather(*tasks)


@pytest.mark.asyncio
async def test_OneNoteDataSource_me_onenote_notebooks_notebook_sections_onenote_section_copy_to_section_group_throughput_medium_load():
    """Throughput test: medium batch of concurrent requests."""
    ds = OneNoteDataSource(DummyMSGraphClient())
    tasks = [
        ds.me_onenote_notebooks_notebook_sections_onenote_section_copy_to_section_group(
            notebook_id=f"nb{i}", onenoteSection_id=f"sec{i}"
        )
        for i in range(20)
    ]
    results = await asyncio.gather(*tasks)


@pytest.mark.asyncio
async def test_OneNoteDataSource_me_onenote_notebooks_notebook_sections_onenote_section_copy_to_section_group_throughput_large_load():
    """Throughput test: larger batch of concurrent requests."""
    ds = OneNoteDataSource(DummyMSGraphClient())
    tasks = [
        ds.me_onenote_notebooks_notebook_sections_onenote_section_copy_to_section_group(
            notebook_id=f"nb{i}", onenoteSection_id=f"sec{i}"
        )
        for i in range(80)
    ]
    results = await asyncio.gather(*tasks)


# 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_notebook_sections_onenote_section_copy_to_section_group-mjcfiac7 and push.