⚡️ Speed up method OneNoteDataSource.groups_onenote_notebooks_sections_delete_pages_content by 9%

[codeflash-ai]

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

⏱️ Runtime : 785 microseconds → 719 microseconds (best of 5 runs)

📝 Explanation and details

The optimization achieves a 9% runtime improvement by eliminating unnecessary object instantiation when no query parameters are provided.

Key optimization:

• Conditional object creation: The original code always created a RequestConfiguration() object for query parameters, even when no parameters were provided. The optimized version only creates this object when at least one query parameter is actually needed.
• Early exit pattern: Uses query_params = None initially and only instantiates when select or expand or filter or orderby or search or (top is not None) or (skip is not None) evaluates to True.

Performance impact:

• 10.5% → 2.4% reduction in time spent on the initial RequestConfiguration() instantiation
• Object allocation savings: Avoids creating unnecessary objects in the common case where no query parameters are specified
• Memory efficiency: Reduces object creation overhead, particularly beneficial for high-volume API calls

Test case analysis:
The optimization is most effective for:

• Basic deletion operations without query parameters (most common case)
• High-volume concurrent operations where the cumulative effect of avoiding object creation is significant
• The large-scale tests (50+ concurrent operations) benefit most from this micro-optimization

Real-world impact:
While the throughput improvement is minimal (1045 ops/sec unchanged), the 9% runtime reduction translates to meaningful savings in high-frequency OneNote API operations, especially in batch processing scenarios where this method might be called hundreds or thousands of times.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

import asyncio

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


class DummyDeleteEndpoint:
    """Dummy endpoint for .content.delete() chain."""

    def __init__(self, behavior=None):
        self.behavior = behavior or {}

    async def delete(self, request_configuration=None):
        # Simulate different behaviors based on test input
        if self.behavior.get("raise"):
            raise self.behavior["raise"]
        return self.behavior.get("response", {"deleted": True})


class DummyPages:
    def __init__(self, behavior=None):
        self.behavior = behavior or {}

    def by_onenote_page_id(self, onenotePage_id):
        return DummyDeleteEndpoint(self.behavior)


class DummySections:
    def __init__(self, behavior=None):
        self.behavior = behavior or {}

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


class DummyNotebooks:
    def __init__(self, behavior=None):
        self.behavior = behavior or {}

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


class DummyOnenote:
    def __init__(self, behavior=None):
        self.behavior = behavior or {}

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


class DummyGroup:
    def __init__(self, behavior=None):
        self.behavior = behavior or {}

    @property
    def onenote(self):
        return DummyOnenote(self.behavior)


class DummyGroups:
    def __init__(self, behavior=None):
        self.behavior = behavior or {}

    def by_group_id(self, group_id):
        return DummyGroup(self.behavior)


class DummyClient:
    """Simulates the .groups property chain."""

    def __init__(self, behavior=None):
        self.behavior = behavior or {}
        self.me = True  # To pass hasattr(self.client, "me") in __init__

    @property
    def groups(self):
        return DummyGroups(self.behavior)

    # For .get_client().get_ms_graph_service_client()
    def get_client(self):
        return self

    def get_ms_graph_service_client(self):
        return self


# --- TESTS ---

# 1. Basic Test Cases


@pytest.mark.asyncio
async def test_delete_pages_content_basic_success():
    """Test normal successful deletion returns success response."""
    # Arrange
    dummy_behavior = {"response": {"deleted": True}}
    client = DummyClient(dummy_behavior)
    ds = OneNoteDataSource(client)
    # Act
    resp = await ds.groups_onenote_notebooks_sections_delete_pages_content(
        "group1", "notebook1", "section1", "page1"
    )


@pytest.mark.asyncio
async def test_delete_pages_content_basic_with_select_expand():
    """Test select and expand parameters are handled."""
    dummy_behavior = {
        "response": {"deleted": True, "select": ["id"], "expand": ["parent"]}
    }
    client = DummyClient(dummy_behavior)
    ds = OneNoteDataSource(client)
    resp = await ds.groups_onenote_notebooks_sections_delete_pages_content(
        "group1", "notebook1", "section1", "page1", select=["id"], expand=["parent"]
    )


@pytest.mark.asyncio
async def test_delete_pages_content_basic_with_headers():
    """Test that custom headers are passed and handled."""
    dummy_behavior = {"response": {"deleted": True, "headers": {"X-Test": "1"}}}
    client = DummyClient(dummy_behavior)
    ds = OneNoteDataSource(client)
    resp = await ds.groups_onenote_notebooks_sections_delete_pages_content(
        "group1", "notebook1", "section1", "page1", headers={"X-Test": "1"}
    )


# 2. Edge Test Cases


@pytest.mark.asyncio
async def test_delete_pages_content_error_dict_in_response():
    """Test error response as dict with error key."""
    dummy_behavior = {"response": {"error": {"code": "404", "message": "Not found"}}}
    client = DummyClient(dummy_behavior)
    ds = OneNoteDataSource(client)
    resp = await ds.groups_onenote_notebooks_sections_delete_pages_content(
        "g", "n", "s", "p"
    )


@pytest.mark.asyncio
async def test_delete_pages_content_error_as_attr():
    """Test error response as object with .error attribute."""

    class ErrorObj:
        error = "Permission denied"

    dummy_behavior = {"response": ErrorObj()}
    client = DummyClient(dummy_behavior)
    ds = OneNoteDataSource(client)
    resp = await ds.groups_onenote_notebooks_sections_delete_pages_content(
        "g", "n", "s", "p"
    )


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

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

    dummy_behavior = {"response": ErrorObj()}
    client = DummyClient(dummy_behavior)
    ds = OneNoteDataSource(client)
    resp = await ds.groups_onenote_notebooks_sections_delete_pages_content(
        "g", "n", "s", "p"
    )


@pytest.mark.asyncio
async def test_delete_pages_content_none_response():
    """Test None response returns unsuccessful OneNoteResponse."""
    dummy_behavior = {"response": None}
    client = DummyClient(dummy_behavior)
    ds = OneNoteDataSource(client)
    resp = await ds.groups_onenote_notebooks_sections_delete_pages_content(
        "g", "n", "s", "p"
    )


@pytest.mark.asyncio
async def test_delete_pages_content_with_search_adds_consistency_header():
    """Test search param triggers ConsistencyLevel header logic."""

    class HeaderCheckDeleteEndpoint(DummyDeleteEndpoint):
        async def delete(self, request_configuration=None):
            return {"deleted": True}

    class HeaderCheckPages(DummyPages):
        def by_onenote_page_id(self, onenotePage_id):
            return HeaderCheckDeleteEndpoint()

    class HeaderCheckSections(DummySections):
        def by_onenote_section_id(self, onenoteSection_id):
            return HeaderCheckPages()

    class HeaderCheckNotebooks(DummyNotebooks):
        def by_notebook_id(self, notebook_id):
            return HeaderCheckSections()

    class HeaderCheckOnenote(DummyOnenote):
        @property
        def notebooks(self):
            return HeaderCheckNotebooks()

    class HeaderCheckGroup(DummyGroup):
        @property
        def onenote(self):
            return HeaderCheckOnenote()

    class HeaderCheckGroups(DummyGroups):
        def by_group_id(self, group_id):
            return HeaderCheckGroup()

    class HeaderCheckClient(DummyClient):
        @property
        def groups(self):
            return HeaderCheckGroups()

    client = HeaderCheckClient()
    ds = OneNoteDataSource(client)
    resp = await ds.groups_onenote_notebooks_sections_delete_pages_content(
        "g", "n", "s", "p", search="foo"
    )


@pytest.mark.asyncio
async def test_delete_pages_content_concurrent_execution():
    """Test concurrent execution of the async function."""
    dummy_behavior = {"response": {"deleted": True}}
    client = DummyClient(dummy_behavior)
    ds = OneNoteDataSource(client)
    # Run 5 concurrent deletions
    coros = [
        ds.groups_onenote_notebooks_sections_delete_pages_content(
            f"group{i}", f"notebook{i}", f"section{i}", f"page{i}"
        )
        for i in range(5)
    ]
    results = await asyncio.gather(*coros)
    for i, resp in enumerate(results):
        pass


# 3. Large Scale Test Cases


@pytest.mark.asyncio
async def test_delete_pages_content_large_scale_concurrent():
    """Test many concurrent deletions (scalable but <100)."""
    dummy_behavior = {"response": {"deleted": True}}
    client = DummyClient(dummy_behavior)
    ds = OneNoteDataSource(client)
    N = 50  # Reasonable scale for unit test
    coros = [
        ds.groups_onenote_notebooks_sections_delete_pages_content(
            f"group{i}", f"notebook{i}", f"section{i}", f"page{i}"
        )
        for i in range(N)
    ]
    results = await asyncio.gather(*coros)


@pytest.mark.asyncio
async def test_delete_pages_content_large_scale_with_varied_inputs():
    """Test concurrent deletions with varied parameters."""
    dummy_behavior = {"response": {"deleted": True}}
    client = DummyClient(dummy_behavior)
    ds = OneNoteDataSource(client)
    coros = [
        ds.groups_onenote_notebooks_sections_delete_pages_content(
            f"group{i}",
            f"notebook{i}",
            f"section{i}",
            f"page{i}",
            select=["id"] if i % 2 == 0 else None,
            expand=["parent"] if i % 3 == 0 else None,
            filter="foo eq bar" if i % 5 == 0 else None,
            orderby="id" if i % 7 == 0 else None,
            search="test" if i % 11 == 0 else None,
            top=i if i % 13 == 0 else None,
            skip=i if i % 17 == 0 else None,
            headers={"X-Test": str(i)} if i % 19 == 0 else None,
        )
        for i in range(30)
    ]
    results = await asyncio.gather(*coros)


# 4. Throughput Test Cases


@pytest.mark.asyncio
async def test_delete_pages_content_throughput_high_volume():
    """Throughput test: high volume deletions (but <100 for unit test)."""
    dummy_behavior = {"response": {"deleted": True}}
    client = DummyClient(dummy_behavior)
    ds = OneNoteDataSource(client)
    N = 80
    coros = [
        ds.groups_onenote_notebooks_sections_delete_pages_content(
            "group", "notebook", "section", f"page{i}"
        )
        for i in range(N)
    ]
    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.

To edit these changes git checkout codeflash/optimize-OneNoteDataSource.groups_onenote_notebooks_sections_delete_pages_content-mjb73gnj and push.