⚡️ Speed up method OneNoteDataSource.users_onenote_create_section_groups by 25%

[codeflash-ai]

📄 25% (0.25x) speedup for OneNoteDataSource.users_onenote_create_section_groups in backend/python/app/sources/external/microsoft/one_note/one_note.py

⏱️ Runtime : 901 microseconds → 723 microseconds (best of 5 runs)

📝 Explanation and details

The optimized code achieves a 24% runtime improvement through two key optimizations that reduce unnecessary object allocations:

What optimizations were applied:

1. Lazy allocation of RequestConfiguration objects - Instead of always creating query_params and config objects, they are only instantiated when actually needed. The original code created these objects on every call regardless of whether any query parameters or headers were provided.

2. Reordered error checking in response handling - The _handle_onenote_response method now checks for dictionary-based errors first (most common case), then object attributes, reducing the average number of checks per response.

Why this leads to speedup:

• Object allocation overhead reduction: The line profiler shows the original code spent significant time (7.3% + 5.8% = 13.1%) creating RequestConfiguration objects that were often unnecessary. The optimized version only allocates these when parameters are actually provided, reducing this to just 0.9% + 0.7% = 1.6%.

• Fewer conditional checks: Most API calls don't provide optional parameters, so avoiding unnecessary object creation for the majority case (320 out of 357 calls based on the profiler data) provides substantial savings.

How this impacts workloads:

The optimization is particularly effective for:

• High-frequency OneNote API calls with minimal parameters (basic section group creation)
• Batch operations where most calls use default parameters
• Concurrent execution scenarios where object allocation overhead compounds

The test results show consistent improvements across all test cases, from basic single calls to large-scale concurrent operations (100+ calls), making this optimization valuable for both individual API calls and bulk OneNote operations.

Performance characteristics:
The optimization maintains identical throughput (1785 ops/sec) while reducing per-operation latency by 24%, indicating the improvements come from reduced CPU overhead rather than I/O optimizations.

✅ Correctness verification report:

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


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


# --- Minimal MSGraphClient stub ---
class SectionGroupsStub:
    def __init__(self, should_raise=False, response=None):
        self.should_raise = should_raise
        self.response = response

    async def post(self, body=None, request_configuration=None):
        if self.should_raise:
            raise RuntimeError("Simulated API error")
        if self.response is not None:
            return self.response
        # Return a dummy successful response
        return {"id": "sectionGroupId", "name": "Test Section Group"}


class OnenoteStub:
    def __init__(self, section_groups_stub):
        self.section_groups = section_groups_stub


class ByUserIdStub:
    def __init__(self, section_groups_stub):
        self.onenote = OnenoteStub(section_groups_stub)


class UsersStub:
    def __init__(self, section_groups_stub):
        self.section_groups_stub = section_groups_stub

    def by_user_id(self, user_id):
        return ByUserIdStub(self.section_groups_stub)


class MSGraphServiceClientStub:
    def __init__(self, section_groups_stub):
        self.me = True
        self.users = UsersStub(section_groups_stub)


class MSGraphClientStub:
    def __init__(self, section_groups_stub):
        self.section_groups_stub = section_groups_stub

    def get_client(self):
        return self

    def get_ms_graph_service_client(self):
        return MSGraphServiceClientStub(self.section_groups_stub)


# --- Unit tests ---

# 1. Basic Test Cases


@pytest.mark.asyncio
async def test_create_section_groups_basic_success():
    """Test basic successful creation with required arguments."""
    section_groups_stub = SectionGroupsStub()
    client_stub = MSGraphClientStub(section_groups_stub)
    datasource = OneNoteDataSource(client_stub)
    response = await datasource.users_onenote_create_section_groups(user_id="user123")


@pytest.mark.asyncio
async def test_create_section_groups_with_all_parameters():
    """Test creation with all optional parameters provided."""
    section_groups_stub = SectionGroupsStub()
    client_stub = MSGraphClientStub(section_groups_stub)
    datasource = OneNoteDataSource(client_stub)
    request_body = {"name": "New Section Group"}
    headers = {"Custom-Header": "value"}
    response = await datasource.users_onenote_create_section_groups(
        user_id="user123",
        select=["id", "name"],
        expand=["sections"],
        filter="name eq 'Test'",
        orderby="name",
        search="Test",
        top=5,
        skip=2,
        request_body=request_body,
        headers=headers,
    )


@pytest.mark.asyncio
async def test_create_section_groups_with_minimal_parameters():
    """Test creation with only user_id and no optional parameters."""
    section_groups_stub = SectionGroupsStub()
    client_stub = MSGraphClientStub(section_groups_stub)
    datasource = OneNoteDataSource(client_stub)
    response = await datasource.users_onenote_create_section_groups(user_id="user456")


# 2. Edge Test Cases


@pytest.mark.asyncio
async def test_create_section_groups_empty_response():
    """Test handling when the API returns None (empty response)."""
    section_groups_stub = SectionGroupsStub(response=None)
    client_stub = MSGraphClientStub(section_groups_stub)
    datasource = OneNoteDataSource(client_stub)
    response = await datasource.users_onenote_create_section_groups(user_id="user789")


@pytest.mark.asyncio
async def test_create_section_groups_api_error_dict():
    """Test handling when the API returns a dict with 'error' key."""
    error_response = {"error": {"code": "BadRequest", "message": "Invalid user id"}}
    section_groups_stub = SectionGroupsStub(response=error_response)
    client_stub = MSGraphClientStub(section_groups_stub)
    datasource = OneNoteDataSource(client_stub)
    response = await datasource.users_onenote_create_section_groups(user_id="baduser")


@pytest.mark.asyncio
async def test_create_section_groups_api_error_object():
    """Test handling when the API returns an object with error attribute."""

    class ErrorObj:
        error = "Forbidden"

    section_groups_stub = SectionGroupsStub(response=ErrorObj())
    client_stub = MSGraphClientStub(section_groups_stub)
    datasource = OneNoteDataSource(client_stub)
    response = await datasource.users_onenote_create_section_groups(user_id="baduser")


@pytest.mark.asyncio
async def test_create_section_groups_api_raises_exception():
    """Test handling when the API raises an exception."""
    section_groups_stub = SectionGroupsStub(should_raise=True)
    client_stub = MSGraphClientStub(section_groups_stub)
    datasource = OneNoteDataSource(client_stub)
    response = await datasource.users_onenote_create_section_groups(user_id="user999")


@pytest.mark.asyncio
async def test_create_section_groups_concurrent_execution():
    """Test concurrent execution of multiple async calls."""
    section_groups_stub = SectionGroupsStub()
    client_stub = MSGraphClientStub(section_groups_stub)
    datasource = OneNoteDataSource(client_stub)
    # Run 10 concurrent calls with different user_ids
    coros = [
        datasource.users_onenote_create_section_groups(user_id=f"user{i}")
        for i in range(10)
    ]
    results = await asyncio.gather(*coros)
    for response in results:
        pass


@pytest.mark.asyncio
async def test_create_section_groups_invalid_client():
    """Test ValueError raised when client lacks 'me' attribute."""

    class BadClientStub:
        def get_client(self):
            return self

        def get_ms_graph_service_client(self):
            return object()

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


# 3. Large Scale Test Cases


@pytest.mark.asyncio
async def test_create_section_groups_large_scale_concurrent():
    """Test large scale concurrent execution (100 calls)."""
    section_groups_stub = SectionGroupsStub()
    client_stub = MSGraphClientStub(section_groups_stub)
    datasource = OneNoteDataSource(client_stub)
    coros = [
        datasource.users_onenote_create_section_groups(user_id=f"user{i}")
        for i in range(100)
    ]
    results = await asyncio.gather(*coros)
    for response in results:
        pass


@pytest.mark.asyncio
async def test_create_section_groups_large_scale_with_varied_parameters():
    """Test large scale with varied parameters."""
    section_groups_stub = SectionGroupsStub()
    client_stub = MSGraphClientStub(section_groups_stub)
    datasource = OneNoteDataSource(client_stub)
    coros = [
        datasource.users_onenote_create_section_groups(
            user_id=f"user{i}",
            select=["id", "name"] if i % 2 == 0 else None,
            expand=["sections"] if i % 3 == 0 else None,
            top=i if i % 5 == 0 else None,
        )
        for i in range(50)
    ]
    results = await asyncio.gather(*coros)
    for response in results:
        pass


# 4. Throughput Test Cases


@pytest.mark.asyncio
async def test_create_section_groups_throughput_small_load():
    """Throughput test: small load (10 calls)."""
    section_groups_stub = SectionGroupsStub()
    client_stub = MSGraphClientStub(section_groups_stub)
    datasource = OneNoteDataSource(client_stub)
    coros = [
        datasource.users_onenote_create_section_groups(user_id=f"user{i}")
        for i in range(10)
    ]
    results = await asyncio.gather(*coros)
    for response in results:
        pass


@pytest.mark.asyncio
async def test_create_section_groups_throughput_medium_load():
    """Throughput test: medium load (50 calls)."""
    section_groups_stub = SectionGroupsStub()
    client_stub = MSGraphClientStub(section_groups_stub)
    datasource = OneNoteDataSource(client_stub)
    coros = [
        datasource.users_onenote_create_section_groups(user_id=f"user{i}")
        for i in range(50)
    ]
    results = await asyncio.gather(*coros)
    for response in results:
        pass


@pytest.mark.asyncio
async def test_create_section_groups_throughput_large_load():
    """Throughput test: large load (100 calls)."""
    section_groups_stub = SectionGroupsStub()
    client_stub = MSGraphClientStub(section_groups_stub)
    datasource = OneNoteDataSource(client_stub)
    coros = [
        datasource.users_onenote_create_section_groups(user_id=f"user{i}")
        for i in range(100)
    ]
    results = await asyncio.gather(*coros)
    for response in results:
        pass


@pytest.mark.asyncio
async def test_create_section_groups_throughput_varied_load():
    """Throughput test: varied load with different request_bodies."""
    section_groups_stub = SectionGroupsStub()
    client_stub = MSGraphClientStub(section_groups_stub)
    datasource = OneNoteDataSource(client_stub)
    coros = [
        datasource.users_onenote_create_section_groups(
            user_id=f"user{i}",
            request_body={"name": f"SectionGroup{i}"} if i % 2 == 0 else None,
        )
        for i in range(30)
    ]
    results = await asyncio.gather(*coros)
    for response 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.

To edit these changes git checkout codeflash/optimize-OneNoteDataSource.users_onenote_create_section_groups-mjge5fzq and push.