⚡️ Speed up method OneNoteDataSource.me_onenote_delete_section_groups by 11%

[codeflash-ai]

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

⏱️ Runtime : 1.06 milliseconds → 959 microseconds (best of 163 runs)

📝 Explanation and details

The optimized code achieves a 10% runtime improvement primarily through reducing object allocations and improving configuration setup efficiency.

Key optimizations applied:

1. Eliminated redundant RequestConfiguration creation: The original code created two RequestConfiguration objects - first for query parameters, then for the actual config. The optimized version creates only one config object and directly accesses its query_parameters property.

2. Streamlined header handling: Instead of conditionally checking and creating headers, the optimized version pre-initializes config.headers = {} when no headers are provided, then conditionally calls headers.copy() only when needed. This reduces branching and ensures consistent header object creation.

3. Import reordering: Minor optimization moving imports to follow Python PEP 8 conventions (standard library imports first).

Why this leads to speedup:

• Fewer object allocations: Creating one RequestConfiguration instead of two reduces memory allocation overhead
• Better memory locality: Accessing config.query_parameters directly eliminates intermediate object references
• Reduced conditional branching: The header initialization pattern reduces the number of conditional checks during execution

Performance characteristics:

• The line profiler shows the configuration setup (lines with RequestConfiguration() and query parameter assignment) taking ~10.9% of total time in the optimized version vs ~10.4% in original, but with better overall efficiency
• The actual API call time (by_section_group_id().delete()) remains consistent at ~19-30% of total time
• Error handling performance is preserved with minimal variance

Impact on workloads:
This optimization is particularly beneficial for high-frequency OneNote operations where the method is called repeatedly, as the reduced object allocation overhead compounds across multiple invocations. The throughput remains constant (80,196 ops/sec) while individual operation latency improves by 10%, indicating better resource utilization per operation.

✅ Correctness verification report:

Test	Status
⚙️ Existing Unit Tests	🔘 None Found
🌀 Generated Regression Tests	✅ 522 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
# Dummy logger for OneNoteDataSource

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


class DummyDeleteEndpoint:
    """Simulates the delete endpoint for section groups."""

    def __init__(self, sectionGroup_id, responses):
        self.sectionGroup_id = sectionGroup_id
        self.responses = responses

    async def delete(self, request_configuration=None):
        # Simulate different responses based on sectionGroup_id
        if self.sectionGroup_id in self.responses:
            resp = self.responses[self.sectionGroup_id]
            if isinstance(resp, Exception):
                raise resp
            return resp
        # Default: success
        return {"deleted": True, "id": self.sectionGroup_id}


class DummySectionGroups:
    """Simulates section_groups property."""

    def __init__(self, responses):
        self.responses = responses

    def by_section_group_id(self, sectionGroup_id):
        return DummyDeleteEndpoint(sectionGroup_id, self.responses)


class DummyMeOneNote:
    """Simulates me.onenote property."""

    def __init__(self, responses):
        self.section_groups = DummySectionGroups(responses)


class DummyClient:
    """Simulates the MSGraphClient's client property."""

    def __init__(self, responses):
        self.me = DummyMeOneNote(responses)


class DummyMSGraphClient:
    """Simulates MSGraphClient wrapper."""

    def __init__(self, responses):
        self._client = DummyClient(responses)

    def get_client(self):
        return self

    def get_ms_graph_service_client(self):
        return self._client


# --- Unit Tests ---

# Basic Test Cases


@pytest.mark.asyncio
async def test_delete_section_group_basic_success():
    """Test basic successful deletion of a section group."""
    responses = {"abc123": {"deleted": True, "id": "abc123"}}
    client = DummyMSGraphClient(responses)
    ds = OneNoteDataSource(client)
    resp = await ds.me_onenote_delete_section_groups("abc123")


@pytest.mark.asyncio
async def test_delete_section_group_basic_not_found():
    """Test deletion of a section group that does not exist (default success)."""
    responses = {}
    client = DummyMSGraphClient(responses)
    ds = OneNoteDataSource(client)
    resp = await ds.me_onenote_delete_section_groups("doesnotexist")


@pytest.mark.asyncio
async def test_delete_section_group_with_headers_and_query_params():
    """Test passing headers and query parameters."""
    responses = {"group42": {"deleted": True, "id": "group42"}}
    client = DummyMSGraphClient(responses)
    ds = OneNoteDataSource(client)
    resp = await ds.me_onenote_delete_section_groups(
        "group42",
        headers={"Authorization": "Bearer token"},
        select=["id", "name"],
        expand=["sections"],
        filter="name eq 'Test'",
        orderby="name",
        search="Test",
        top=10,
        skip=0,
    )


# Edge Test Cases


@pytest.mark.asyncio
async def test_delete_section_group_error_response_dict():
    """Test error response returned as a dict with error info."""
    responses = {"badid": {"error": {"code": "404", "message": "Not found"}}}
    client = DummyMSGraphClient(responses)
    ds = OneNoteDataSource(client)
    resp = await ds.me_onenote_delete_section_groups("badid")


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

    class ErrorObj:
        error = "Something went wrong"

    responses = {"badobj": ErrorObj()}
    client = DummyMSGraphClient(responses)
    ds = OneNoteDataSource(client)
    resp = await ds.me_onenote_delete_section_groups("badobj")


@pytest.mark.asyncio
async def test_delete_section_group_exception_in_delete():
    """Test that an exception raised in delete is handled gracefully."""
    responses = {"errid": RuntimeError("API failure")}
    client = DummyMSGraphClient(responses)
    ds = OneNoteDataSource(client)
    resp = await ds.me_onenote_delete_section_groups("errid")


@pytest.mark.asyncio
async def test_delete_section_group_none_response():
    """Test that a None response is handled as error."""
    responses = {"noneid": None}
    client = DummyMSGraphClient(responses)
    ds = OneNoteDataSource(client)
    resp = await ds.me_onenote_delete_section_groups("noneid")


@pytest.mark.asyncio
async def test_delete_section_group_error_response_dict_str():
    """Test error response returned as a dict with error as string."""
    responses = {"strerrid": {"error": "Some error string"}}
    client = DummyMSGraphClient(responses)
    ds = OneNoteDataSource(client)
    resp = await ds.me_onenote_delete_section_groups("strerrid")


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

    class CodeMsgObj:
        code = "500"
        message = "Internal Server Error"

    responses = {"codemsgid": CodeMsgObj()}
    client = DummyMSGraphClient(responses)
    ds = OneNoteDataSource(client)
    resp = await ds.me_onenote_delete_section_groups("codemsgid")


# Large Scale Test Cases


@pytest.mark.asyncio
async def test_delete_section_group_concurrent_deletes():
    """Test concurrent deletion of multiple section groups."""
    ids = [f"group{i}" for i in range(10)]
    responses = {id_: {"deleted": True, "id": id_} for id_ in ids}
    client = DummyMSGraphClient(responses)
    ds = OneNoteDataSource(client)
    coros = [ds.me_onenote_delete_section_groups(id_) for id_ in ids]
    results = await asyncio.gather(*coros)
    for i, resp in enumerate(results):
        pass


@pytest.mark.asyncio
async def test_delete_section_group_concurrent_mixed_results():
    """Test concurrent deletion with mixed success/error results."""
    ids = ["ok1", "ok2", "bad1", "bad2"]
    responses = {
        "ok1": {"deleted": True, "id": "ok1"},
        "ok2": {"deleted": True, "id": "ok2"},
        "bad1": {"error": {"code": "404", "message": "Not found"}},
        "bad2": RuntimeError("API failure"),
    }
    client = DummyMSGraphClient(responses)
    ds = OneNoteDataSource(client)
    coros = [ds.me_onenote_delete_section_groups(id_) for id_ in ids]
    results = await asyncio.gather(*coros)


# Throughput Test Cases


@pytest.mark.asyncio
async def test_OneNoteDataSource_me_onenote_delete_section_groups_throughput_small_load():
    """Throughput test: small load of concurrent deletes."""
    ids = [f"small{i}" for i in range(5)]
    responses = {id_: {"deleted": True, "id": id_} for id_ in ids}
    client = DummyMSGraphClient(responses)
    ds = OneNoteDataSource(client)
    coros = [ds.me_onenote_delete_section_groups(id_) for id_ in ids]
    results = await asyncio.gather(*coros)


@pytest.mark.asyncio
async def test_OneNoteDataSource_me_onenote_delete_section_groups_throughput_medium_load():
    """Throughput test: medium load of concurrent deletes."""
    ids = [f"med{i}" for i in range(50)]
    responses = {id_: {"deleted": True, "id": id_} for id_ in ids}
    client = DummyMSGraphClient(responses)
    ds = OneNoteDataSource(client)
    coros = [ds.me_onenote_delete_section_groups(id_) for id_ in ids]
    results = await asyncio.gather(*coros)


@pytest.mark.asyncio
async def test_OneNoteDataSource_me_onenote_delete_section_groups_throughput_large_load():
    """Throughput test: large load of concurrent deletes (max 200)."""
    ids = [f"big{i}" for i in range(200)]
    responses = {id_: {"deleted": True, "id": id_} for id_ in ids}
    client = DummyMSGraphClient(responses)
    ds = OneNoteDataSource(client)
    coros = [ds.me_onenote_delete_section_groups(id_) for id_ in ids]
    results = await asyncio.gather(*coros)


@pytest.mark.asyncio
async def test_OneNoteDataSource_me_onenote_delete_section_groups_throughput_mixed_load():
    """Throughput test: mixed load with errors and successes."""
    ids = [f"mix{i}" for i in range(20)]
    responses = {id_: {"deleted": True, "id": id_} for id_ in ids[:10]}
    # Next 5: error dict, last 5: exception
    for i in range(10, 15):
        responses[f"mix{i}"] = {"error": {"code": "404", "message": "Not found"}}
    for i in range(15, 20):
        responses[f"mix{i}"] = RuntimeError("API failure")
    client = DummyMSGraphClient(responses)
    ds = OneNoteDataSource(client)
    coros = [ds.me_onenote_delete_section_groups(id_) for id_ in ids]
    results = await asyncio.gather(*coros)
    for i, resp in enumerate(results):
        if i < 10:
            pass
        elif i < 15:
            pass
        else:
            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  # used to run async functions
# Patch logger for OneNoteDataSource

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


class DummyDeleteEndpoint:
    def __init__(self, behavior):
        self.behavior = behavior

    async def delete(self, request_configuration=None):
        # Simulate different behaviors based on input
        if self.behavior == "success":
            return {"deleted": True}
        elif self.behavior == "error_dict":
            return {"error": {"code": "404", "message": "Not found"}}
        elif self.behavior == "error_attr":

            class ErrorObj:
                error = "Section group not found"

            return ErrorObj()
        elif self.behavior == "exception":
            raise Exception("API failure")
        elif self.behavior == "large":
            return {"deleted": True, "details": ["ok"] * 500}
        elif self.behavior == "etag_match":
            return {
                "deleted": True,
                "etag": request_configuration.headers.get("If-Match", None),
            }
        elif self.behavior == "concurrent":
            # Simulate concurrent call by returning unique id
            return {"deleted": True, "id": id(self)}
        elif self.behavior == "empty":
            return None
        else:
            return {"deleted": False}


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

    def by_section_group_id(self, sectionGroup_id):
        return DummyDeleteEndpoint(self.behavior)


class DummyMe:
    def __init__(self, behavior):
        self.behavior = behavior
        self.onenote = self

    @property
    def section_groups(self):
        return DummySectionGroups(self.behavior)


class DummyClient:
    def __init__(self, behavior):
        self.me = DummyMe(behavior)


class DummyMSGraphClient:
    def __init__(self, behavior):
        self.behavior = behavior

    def get_client(self):
        return self

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


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

# 1. Basic Test Cases


@pytest.mark.asyncio
async def test_me_onenote_delete_section_groups_success():
    """Test basic successful deletion."""
    ds = OneNoteDataSource(DummyMSGraphClient("success"))
    resp = await ds.me_onenote_delete_section_groups("sgid123")


@pytest.mark.asyncio
async def test_me_onenote_delete_section_groups_error_dict():
    """Test error response with error dict."""
    ds = OneNoteDataSource(DummyMSGraphClient("error_dict"))
    resp = await ds.me_onenote_delete_section_groups("sgid404")


@pytest.mark.asyncio
async def test_me_onenote_delete_section_groups_error_attr():
    """Test error response with error attribute."""
    ds = OneNoteDataSource(DummyMSGraphClient("error_attr"))
    resp = await ds.me_onenote_delete_section_groups("sgid404")


@pytest.mark.asyncio
async def test_me_onenote_delete_section_groups_empty_response():
    """Test handling of None response."""
    ds = OneNoteDataSource(DummyMSGraphClient("empty"))
    resp = await ds.me_onenote_delete_section_groups("sgid_none")


@pytest.mark.asyncio
async def test_me_onenote_delete_section_groups_exception():
    """Test handling of exception in delete call."""
    ds = OneNoteDataSource(DummyMSGraphClient("exception"))
    resp = await ds.me_onenote_delete_section_groups("sgid_fail")


# 2. Edge Test Cases


@pytest.mark.asyncio
async def test_me_onenote_delete_section_groups_etag_header():
    """Test If-Match header is passed through."""
    ds = OneNoteDataSource(DummyMSGraphClient("etag_match"))
    headers = {"If-Match": "etag123"}
    resp = await ds.me_onenote_delete_section_groups("sgid_etag", headers=headers)


@pytest.mark.asyncio
async def test_me_onenote_delete_section_groups_select_expand():
    """Test select and expand parameters."""
    ds = OneNoteDataSource(DummyMSGraphClient("success"))
    resp = await ds.me_onenote_delete_section_groups(
        "sgid_select", select=["id", "name"], expand=["sections"]
    )


@pytest.mark.asyncio
async def test_me_onenote_delete_section_groups_search_consistency_level():
    """Test that ConsistencyLevel header is set for search."""
    ds = OneNoteDataSource(DummyMSGraphClient("success"))
    resp = await ds.me_onenote_delete_section_groups("sgid_search", search="notebook")


@pytest.mark.asyncio
async def test_me_onenote_delete_section_groups_concurrent_calls():
    """Test concurrent execution of multiple deletions."""
    ds = OneNoteDataSource(DummyMSGraphClient("concurrent"))
    ids = [f"sgid_{i}" for i in range(10)]
    results = await asyncio.gather(
        *[ds.me_onenote_delete_section_groups(sgid) for sgid in ids]
    )


@pytest.mark.asyncio
async def test_me_onenote_delete_section_groups_invalid_client():
    """Test ValueError if client does not have 'me'."""

    class BadClient:
        def get_client(self):
            return self

        def get_ms_graph_service_client(self):
            return object()

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


# 3. Large Scale Test Cases


@pytest.mark.asyncio
async def test_me_onenote_delete_section_groups_large_payload():
    """Test with large simulated response."""
    ds = OneNoteDataSource(DummyMSGraphClient("large"))
    resp = await ds.me_onenote_delete_section_groups("sgid_large")


@pytest.mark.asyncio
async def test_me_onenote_delete_section_groups_many_concurrent():
    """Test many concurrent deletions for scalability."""
    ds = OneNoteDataSource(DummyMSGraphClient("concurrent"))
    ids = [f"sgid_{i}" for i in range(50)]
    results = await asyncio.gather(
        *[ds.me_onenote_delete_section_groups(sgid) for sgid in ids]
    )


# 4. Throughput Test Cases


@pytest.mark.asyncio
async def test_me_onenote_delete_section_groups_throughput_small_load():
    """Throughput: Small load of concurrent deletions."""
    ds = OneNoteDataSource(DummyMSGraphClient("success"))
    ids = [f"sgid_{i}" for i in range(5)]
    results = await asyncio.gather(
        *[ds.me_onenote_delete_section_groups(sgid) for sgid in ids]
    )


@pytest.mark.asyncio
async def test_me_onenote_delete_section_groups_throughput_medium_load():
    """Throughput: Medium load of concurrent deletions."""
    ds = OneNoteDataSource(DummyMSGraphClient("success"))
    ids = [f"sgid_{i}" for i in range(20)]
    results = await asyncio.gather(
        *[ds.me_onenote_delete_section_groups(sgid) for sgid in ids]
    )


@pytest.mark.asyncio
async def test_me_onenote_delete_section_groups_throughput_high_volume():
    """Throughput: High volume concurrent deletions."""
    ds = OneNoteDataSource(DummyMSGraphClient("success"))
    ids = [f"sgid_{i}" for i in range(100)]
    results = await asyncio.gather(
        *[ds.me_onenote_delete_section_groups(sgid) for sgid in ids]
    )


# 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_delete_section_groups-mjftalbf and push.