⚡️ Speed up method OneNoteDataSource.users_onenote_sections_pages_get_parent_section by 7%

[codeflash-ai]

📄 7% (0.07x) speedup for OneNoteDataSource.users_onenote_sections_pages_get_parent_section in backend/python/app/sources/external/microsoft/one_note/one_note.py

⏱️ Runtime : 2.37 milliseconds → 2.22 milliseconds (best of 25 runs)

📝 Explanation and details

The optimized code achieves a 6% runtime improvement through several strategic optimizations in the _handle_onenote_response method and parameter validation logic:

Key Optimizations:

1. Early Return Pattern in Error Handling: The optimized version eliminates intermediate variables (success, error_msg) and uses direct early returns for each error condition. This reduces variable assignments and branching logic, making the happy path more efficient.

2. Streamlined Control Flow: Instead of setting flags and constructing the response at the end, each error condition immediately returns the appropriate OneNoteResponse, reducing CPU cycles spent on variable management.

3. More Precise Null Checks: Changed loose truthiness checks (e.g., if select:) to explicit null checks (if select is not None:), preventing unnecessary processing when parameters are empty lists or falsy values.

4. Optimized Header Management: The header copying logic is consolidated into a single conditional assignment (config.headers = headers.copy() if headers is not None else None), reducing redundant condition checks.

Performance Impact:

The line profiler shows the _handle_onenote_response method improved from 1.61ms to 1.13ms (30% faster) - this method is called frequently in the OneNote API workflow. The main async method shows modest improvements in parameter validation overhead.

Use Case Benefits:

These optimizations are particularly effective for:

• High-frequency OneNote operations where response handling occurs repeatedly
• Batch processing scenarios with many concurrent calls (as shown in the large-scale tests)
• Error-prone environments where early returns prevent unnecessary processing

The 0% throughput improvement indicates these are micro-optimizations that reduce per-operation overhead without affecting the overall async concurrency model, making them valuable for sustained workloads without impacting the async execution pattern.

✅ Correctness verification report:

Test	Status
⚙️ Existing Unit Tests	🔘 None Found
🌀 Generated Regression Tests	✅ 503 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 Dict, List, 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:
    """Simple response wrapper for OneNote operations."""
    def __init__(self, success: bool, data=None, error=None):
        self.success = success
        self.data = data
        self.error = error

class DummyParentSection:
    """Dummy object to simulate parent section response."""
    def __init__(self, section_id, page_id, user_id, extra=None):
        self.section_id = section_id
        self.page_id = page_id
        self.user_id = user_id
        self.extra = extra or {}

class DummyPages:
    """Simulates .pages.by_onenote_page_id().parent_section.get()"""
    def __init__(self, section_id, user_id):
        self.section_id = section_id
        self.user_id = user_id
    def by_onenote_page_id(self, page_id):
        self.page_id = page_id
        return self
    class ParentSection:
        async def get(self, request_configuration=None):
            # Simulate a successful response
            return DummyParentSection("section123", "page456", "user789", extra={"request_configuration": request_configuration})
    @property
    def parent_section(self):
        return DummyPages.ParentSection()

class DummySections:
    """Simulates .sections.by_onenote_section_id().pages"""
    def __init__(self, user_id):
        self.user_id = user_id
    def by_onenote_section_id(self, section_id):
        return DummyPages(section_id, self.user_id)

class DummyOnenote:
    """Simulates .onenote.sections"""
    def __init__(self, user_id):
        self.user_id = user_id
    @property
    def sections(self):
        return DummySections(self.user_id)

class DummyUser:
    """Simulates .users.by_user_id().onenote"""
    def __init__(self, user_id):
        self.user_id = user_id
    def onenote(self):
        return DummyOnenote(self.user_id)
    @property
    def onenote(self):
        return DummyOnenote(self.user_id)

class DummyUsers:
    """Simulates .users.by_user_id()"""
    def by_user_id(self, user_id):
        return DummyUser(user_id)

class DummyClient:
    """Simulates the Microsoft Graph SDK client with .users"""
    def __init__(self):
        self.users = DummyUsers()
        self.me = True  # To pass the hasattr(self.client, "me") check

    def get_ms_graph_service_client(self):
        return self

class DummyMSGraphClient:
    """Simulates MSGraphClient.get_client()"""
    def __init__(self):
        self._client = DummyClient()
    def get_client(self):
        return self._client

# --- Unit tests ---

@pytest.mark.asyncio
async def test_basic_success():
    """Basic: Should return a successful OneNoteResponse with correct parent section data."""
    ds = OneNoteDataSource(DummyMSGraphClient())
    resp = await ds.users_onenote_sections_pages_get_parent_section(
        user_id="user789",
        onenoteSection_id="section123",
        onenotePage_id="page456"
    )

@pytest.mark.asyncio
async def test_basic_with_select_and_expand():
    """Basic: Should correctly handle select and expand parameters."""
    ds = OneNoteDataSource(DummyMSGraphClient())
    select = ["id", "name"]
    expand = ["pages"]
    resp = await ds.users_onenote_sections_pages_get_parent_section(
        user_id="user789",
        onenoteSection_id="section123",
        onenotePage_id="page456",
        select=select,
        expand=expand
    )

@pytest.mark.asyncio



async def test_edge_handle_none_response():
    """Edge: Should return OneNoteResponse with success=False if response is None."""
    class DummyBadParentSection:
        async def get(self, request_configuration=None):
            return None
    class DummyBadPages(DummyPages):
        @property
        def parent_section(self):
            return DummyBadParentSection()
    class DummyBadSections(DummySections):
        def by_onenote_section_id(self, section_id):
            return DummyBadPages(section_id, self.user_id)
    class DummyBadOnenote(DummyOnenote):
        @property
        def sections(self):
            return DummyBadSections(self.user_id)
    class DummyBadUser(DummyUser):
        @property
        def onenote(self):
            return DummyBadOnenote(self.user_id)
    class DummyBadUsers(DummyUsers):
        def by_user_id(self, user_id):
            return DummyBadUser(user_id)
    class DummyBadClient(DummyClient):
        def __init__(self):
            self.users = DummyBadUsers()
            self.me = True
    class DummyBadMSGraphClient(DummyMSGraphClient):
        def get_client(self):
            return DummyBadClient()
    ds = OneNoteDataSource(DummyBadMSGraphClient())
    resp = await ds.users_onenote_sections_pages_get_parent_section(
        user_id="user789",
        onenoteSection_id="section123",
        onenotePage_id="page456"
    )

@pytest.mark.asyncio
async def test_edge_handle_response_with_error_attr():
    """Edge: Should return OneNoteResponse with success=False if response has error attribute."""
    class DummyErrorParentSection:
        def __init__(self):
            self.error = "Some error occurred"
        async def get(self, request_configuration=None):
            return self
    class DummyErrorPages(DummyPages):
        @property
        def parent_section(self):
            return DummyErrorParentSection()
    class DummyErrorSections(DummySections):
        def by_onenote_section_id(self, section_id):
            return DummyErrorPages(section_id, self.user_id)
    class DummyErrorOnenote(DummyOnenote):
        @property
        def sections(self):
            return DummyErrorSections(self.user_id)
    class DummyErrorUser(DummyUser):
        @property
        def onenote(self):
            return DummyErrorOnenote(self.user_id)
    class DummyErrorUsers(DummyUsers):
        def by_user_id(self, user_id):
            return DummyErrorUser(user_id)
    class DummyErrorClient(DummyClient):
        def __init__(self):
            self.users = DummyErrorUsers()
            self.me = True
    class DummyErrorMSGraphClient(DummyMSGraphClient):
        def get_client(self):
            return DummyErrorClient()
    ds = OneNoteDataSource(DummyErrorMSGraphClient())
    resp = await ds.users_onenote_sections_pages_get_parent_section(
        user_id="user789",
        onenoteSection_id="section123",
        onenotePage_id="page456"
    )

@pytest.mark.asyncio
async def test_edge_handle_response_with_dict_error():
    """Edge: Should return error message from dict error response."""
    class DummyDictErrorParentSection:
        async def get(self, request_configuration=None):
            return {"error": {"code": "403", "message": "Forbidden"}}
    class DummyDictErrorPages(DummyPages):
        @property
        def parent_section(self):
            return DummyDictErrorParentSection()
    class DummyDictErrorSections(DummySections):
        def by_onenote_section_id(self, section_id):
            return DummyDictErrorPages(section_id, self.user_id)
    class DummyDictErrorOnenote(DummyOnenote):
        @property
        def sections(self):
            return DummyDictErrorSections(self.user_id)
    class DummyDictErrorUser(DummyUser):
        @property
        def onenote(self):
            return DummyDictErrorOnenote(self.user_id)
    class DummyDictErrorUsers(DummyUsers):
        def by_user_id(self, user_id):
            return DummyDictErrorUser(user_id)
    class DummyDictErrorClient(DummyClient):
        def __init__(self):
            self.users = DummyDictErrorUsers()
            self.me = True
    class DummyDictErrorMSGraphClient(DummyMSGraphClient):
        def get_client(self):
            return DummyDictErrorClient()
    ds = OneNoteDataSource(DummyDictErrorMSGraphClient())
    resp = await ds.users_onenote_sections_pages_get_parent_section(
        user_id="user789",
        onenoteSection_id="section123",
        onenotePage_id="page456"
    )

@pytest.mark.asyncio
async def test_edge_handle_response_with_code_message():
    """Edge: Should return error message from response with code and message attributes."""
    class DummyCodeMessageParentSection:
        code = "404"
        message = "Not Found"
        async def get(self, request_configuration=None):
            return self
    class DummyCodeMessagePages(DummyPages):
        @property
        def parent_section(self):
            return DummyCodeMessageParentSection()
    class DummyCodeMessageSections(DummySections):
        def by_onenote_section_id(self, section_id):
            return DummyCodeMessagePages(section_id, self.user_id)
    class DummyCodeMessageOnenote(DummyOnenote):
        @property
        def sections(self):
            return DummyCodeMessageSections(self.user_id)
    class DummyCodeMessageUser(DummyUser):
        @property
        def onenote(self):
            return DummyCodeMessageOnenote(self.user_id)
    class DummyCodeMessageUsers(DummyUsers):
        def by_user_id(self, user_id):
            return DummyCodeMessageUser(user_id)
    class DummyCodeMessageClient(DummyClient):
        def __init__(self):
            self.users = DummyCodeMessageUsers()
            self.me = True
    class DummyCodeMessageMSGraphClient(DummyMSGraphClient):
        def get_client(self):
            return DummyCodeMessageClient()
    ds = OneNoteDataSource(DummyCodeMessageMSGraphClient())
    resp = await ds.users_onenote_sections_pages_get_parent_section(
        user_id="user789",
        onenoteSection_id="section123",
        onenotePage_id="page456"
    )

@pytest.mark.asyncio
async def test_edge_exception_in_api_call():
    """Edge: Should return OneNoteResponse with success=False if exception is raised in API call."""
    class DummyExceptionParentSection:
        async def get(self, request_configuration=None):
            raise RuntimeError("Simulated API failure")
    class DummyExceptionPages(DummyPages):
        @property
        def parent_section(self):
            return DummyExceptionParentSection()
    class DummyExceptionSections(DummySections):
        def by_onenote_section_id(self, section_id):
            return DummyExceptionPages(section_id, self.user_id)
    class DummyExceptionOnenote(DummyOnenote):
        @property
        def sections(self):
            return DummyExceptionSections(self.user_id)
    class DummyExceptionUser(DummyUser):
        @property
        def onenote(self):
            return DummyExceptionOnenote(self.user_id)
    class DummyExceptionUsers(DummyUsers):
        def by_user_id(self, user_id):
            return DummyExceptionUser(user_id)
    class DummyExceptionClient(DummyClient):
        def __init__(self):
            self.users = DummyExceptionUsers()
            self.me = True
    class DummyExceptionMSGraphClient(DummyMSGraphClient):
        def get_client(self):
            return DummyExceptionClient()
    ds = OneNoteDataSource(DummyExceptionMSGraphClient())
    resp = await ds.users_onenote_sections_pages_get_parent_section(
        user_id="user789",
        onenoteSection_id="section123",
        onenotePage_id="page456"
    )

@pytest.mark.asyncio


async def test_large_scale_with_varied_parameters():
    """Large Scale: Should handle 20 concurrent calls with varied parameters."""
    ds = OneNoteDataSource(DummyMSGraphClient())
    tasks = []
    for i in range(20):
        params = {
            "user_id": f"user{i}",
            "onenoteSection_id": f"section{i}",
            "onenotePage_id": f"page{i}",
            "select": ["id", "name"] if i % 2 == 0 else None,
            "expand": ["pages"] if i % 3 == 0 else None,
            "filter": "name eq 'Test'" if i % 5 == 0 else None,
            "orderby": "name" if i % 7 == 0 else None,
            "top": i if i % 4 == 0 else None,
            "skip": i * 2 if i % 6 == 0 else None,
        }
        tasks.append(ds.users_onenote_sections_pages_get_parent_section(**params))
    results = await asyncio.gather(*tasks)
    for i, resp in enumerate(results):
        pass

# --- Throughput test cases ---

@pytest.mark.asyncio
async def test_OneNoteDataSource_users_onenote_sections_pages_get_parent_section_throughput_small_load():
    """Throughput: Should handle 10 sequential calls quickly and correctly."""
    ds = OneNoteDataSource(DummyMSGraphClient())
    for i in range(10):
        resp = await ds.users_onenote_sections_pages_get_parent_section(
            user_id=f"user{i}",
            onenoteSection_id=f"section{i}",
            onenotePage_id=f"page{i}"
        )

@pytest.mark.asyncio

import asyncio  # used to run async functions

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


class DummyParentSection:
    """Dummy object to simulate a parent section response."""

    def __init__(self, section_id, page_id):
        self.section_id = section_id
        self.page_id = page_id
        self.name = f"Section-{section_id}"
        self.pages = [page_id]


class DummyPages:
    """Stub for pages builder."""

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

    def by_onenote_page_id(self, page_id):
        return DummyPage(section_id=self.section_id, page_id=page_id)


class DummyPage:
    """Stub for page builder."""

    def __init__(self, section_id, page_id):
        self.section_id = section_id
        self.page_id = page_id
        self.parent_section = DummyParentSectionAPI(section_id, page_id)


class DummyParentSectionAPI:
    """Stub for parentSection API endpoint."""

    def __init__(self, section_id, page_id):
        self.section_id = section_id
        self.page_id = page_id

    async def get(self, request_configuration=None):
        # Simulate successful response with dummy data
        # If headers indicate search, simulate a different response
        if request_configuration and getattr(request_configuration, "headers", None):
            if request_configuration.headers.get("ConsistencyLevel") == "eventual":
                return {
                    "search": True,
                    "section_id": self.section_id,
                    "page_id": self.page_id,
                }
        return DummyParentSection(self.section_id, self.page_id)


class DummySections:
    """Stub for sections builder."""

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

    def by_onenote_section_id(self, section_id):
        return DummySection(user_id=self.user_id, section_id=section_id)


class DummySection:
    """Stub for section builder."""

    def __init__(self, user_id, section_id):
        self.user_id = user_id
        self.section_id = section_id
        self.pages = DummyPages(section_id=section_id)


class DummyOnenote:
    """Stub for onenote builder."""

    def __init__(self, user_id):
        self.sections = DummySections(user_id=user_id)


class DummyUser:
    """Stub for user builder."""

    def __init__(self, user_id):
        self.user_id = user_id
        self.onenote = DummyOnenote(user_id=user_id)


class DummyUsers:
    """Stub for users builder."""

    def by_user_id(self, user_id):
        return DummyUser(user_id=user_id)


class DummyClient:
    """Stub for Microsoft Graph SDK client."""

    def __init__(self):
        self.users = DummyUsers()
        self.me = True  # To pass hasattr(self.client, "me") check

    def get_ms_graph_service_client(self):
        return self


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

    def __init__(self):
        self.client = DummyClient()

    def get_client(self):
        return self.client


# --- Unit Tests ---


@pytest.mark.asyncio
async def test_basic_success_response():
    """Test basic async/await behavior and successful response."""
    ds = OneNoteDataSource(DummyMSGraphClient())
    resp = await ds.users_onenote_sections_pages_get_parent_section(
        user_id="user1", onenoteSection_id="secA", onenotePage_id="pg1"
    )


@pytest.mark.asyncio
async def test_basic_with_select_and_expand():
    """Test select and expand parameters are processed."""
    ds = OneNoteDataSource(DummyMSGraphClient())
    resp = await ds.users_onenote_sections_pages_get_parent_section(
        user_id="user2",
        onenoteSection_id="secB",
        onenotePage_id="pg2",
        select=["name", "pages"],
        expand=["parentNotebook"],
    )


@pytest.mark.asyncio
async def test_basic_with_headers():
    """Test passing custom headers."""
    ds = OneNoteDataSource(DummyMSGraphClient())
    resp = await ds.users_onenote_sections_pages_get_parent_section(
        user_id="user3",
        onenoteSection_id="secC",
        onenotePage_id="pg3",
        headers={"Authorization": "Bearer token"},
    )


@pytest.mark.asyncio
async def test_search_triggers_consistency_level_header():
    """Test that search parameter triggers ConsistencyLevel header."""
    ds = OneNoteDataSource(DummyMSGraphClient())
    resp = await ds.users_onenote_sections_pages_get_parent_section(
        user_id="user4",
        onenoteSection_id="secD",
        onenotePage_id="pg4",
        search="meeting notes",
    )


@pytest.mark.asyncio
async def test_edge_none_response_handling():
    """Test that None response is handled gracefully."""

    class DummyParentSectionAPIWithNone(DummyParentSectionAPI):
        async def get(self, request_configuration=None):
            return None

    class DummyPageWithNone(DummyPage):
        def __init__(self, section_id, page_id):
            self.section_id = section_id
            self.page_id = page_id
            self.parent_section = DummyParentSectionAPIWithNone(section_id, page_id)

    class DummyPagesWithNone(DummyPages):
        def by_onenote_page_id(self, page_id):
            return DummyPageWithNone(section_id=self.section_id, page_id=page_id)

    class DummySectionWithNone(DummySection):
        def __init__(self, user_id, section_id):
            self.user_id = user_id
            self.section_id = section_id
            self.pages = DummyPagesWithNone(section_id=section_id)

    class DummySectionsWithNone(DummySections):
        def by_onenote_section_id(self, section_id):
            return DummySectionWithNone(user_id=self.user_id, section_id=section_id)

    class DummyOnenoteWithNone(DummyOnenote):
        def __init__(self, user_id):
            self.sections = DummySectionsWithNone(user_id=user_id)

    class DummyUserWithNone(DummyUser):
        def __init__(self, user_id):
            self.user_id = user_id
            self.onenote = DummyOnenoteWithNone(user_id=user_id)

    class DummyUsersWithNone(DummyUsers):
        def by_user_id(self, user_id):
            return DummyUserWithNone(user_id=user_id)

    class DummyClientWithNone(DummyClient):
        def __init__(self):
            self.users = DummyUsersWithNone()
            self.me = True

        def get_ms_graph_service_client(self):
            return self

    class DummyMSGraphClientWithNone(DummyMSGraphClient):
        def __init__(self):
            self.client = DummyClientWithNone()

        def get_client(self):
            return self.client

    ds = OneNoteDataSource(DummyMSGraphClientWithNone())
    resp = await ds.users_onenote_sections_pages_get_parent_section(
        user_id="user5", onenoteSection_id="secE", onenotePage_id="pg5"
    )


@pytest.mark.asyncio
async def test_edge_error_response_handling():
    """Test that error attribute in response is handled."""

    class DummyParentSectionAPIWithError(DummyParentSectionAPI):
        async def get(self, request_configuration=None):
            class ErrorObj:
                error = "Something went wrong"

            return ErrorObj()

    class DummyPageWithError(DummyPage):
        def __init__(self, section_id, page_id):
            self.section_id = section_id
            self.page_id = page_id
            self.parent_section = DummyParentSectionAPIWithError(section_id, page_id)

    class DummyPagesWithError(DummyPages):
        def by_onenote_page_id(self, page_id):
            return DummyPageWithError(section_id=self.section_id, page_id=page_id)

    class DummySectionWithError(DummySection):
        def __init__(self, user_id, section_id):
            self.user_id = user_id
            self.section_id = section_id
            self.pages = DummyPagesWithError(section_id=section_id)

    class DummySectionsWithError(DummySections):
        def by_onenote_section_id(self, section_id):
            return DummySectionWithError(user_id=self.user_id, section_id=section_id)

    class DummyOnenoteWithError(DummyOnenote):
        def __init__(self, user_id):
            self.sections = DummySectionsWithError(user_id=user_id)

    class DummyUserWithError(DummyUser):
        def __init__(self, user_id):
            self.user_id = user_id
            self.onenote = DummyOnenoteWithError(user_id=user_id)

    class DummyUsersWithError(DummyUsers):
        def by_user_id(self, user_id):
            return DummyUserWithError(user_id=user_id)

    class DummyClientWithError(DummyClient):
        def __init__(self):
            self.users = DummyUsersWithError()
            self.me = True

        def get_ms_graph_service_client(self):
            return self

    class DummyMSGraphClientWithError(DummyMSGraphClient):
        def __init__(self):
            self.client = DummyClientWithError()

        def get_client(self):
            return self.client

    ds = OneNoteDataSource(DummyMSGraphClientWithError())
    resp = await ds.users_onenote_sections_pages_get_parent_section(
        user_id="user6", onenoteSection_id="secF", onenotePage_id="pg6"
    )


@pytest.mark.asyncio
async def test_edge_dict_error_response_handling():
    """Test that dict with error key is handled."""

    class DummyParentSectionAPIWithDictError(DummyParentSectionAPI):
        async def get(self, request_configuration=None):
            return {"error": {"code": "404", "message": "Not found"}}

    class DummyPageWithDictError(DummyPage):
        def __init__(self, section_id, page_id):
            self.section_id = section_id
            self.page_id = page_id
            self.parent_section = DummyParentSectionAPIWithDictError(
                section_id, page_id
            )

    class DummyPagesWithDictError(DummyPages):
        def by_onenote_page_id(self, page_id):
            return DummyPageWithDictError(section_id=self.section_id, page_id=page_id)

    class DummySectionWithDictError(DummySection):
        def __init__(self, user_id, section_id):
            self.user_id = user_id
            self.section_id = section_id
            self.pages = DummyPagesWithDictError(section_id=section_id)

    class DummySectionsWithDictError(DummySections):
        def by_onenote_section_id(self, section_id):
            return DummySectionWithDictError(
                user_id=self.user_id, section_id=section_id
            )

    class DummyOnenoteWithDictError(DummyOnenote):
        def __init__(self, user_id):
            self.sections = DummySectionsWithDictError(user_id=user_id)

    class DummyUserWithDictError(DummyUser):
        def __init__(self, user_id):
            self.user_id = user_id
            self.onenote = DummyOnenoteWithDictError(user_id=user_id)

    class DummyUsersWithDictError(DummyUsers):
        def by_user_id(self, user_id):
            return DummyUserWithDictError(user_id=user_id)

    class DummyClientWithDictError(DummyClient):
        def __init__(self):
            self.users = DummyUsersWithDictError()
            self.me = True

        def get_ms_graph_service_client(self):
            return self

    class DummyMSGraphClientWithDictError(DummyMSGraphClient):
        def __init__(self):
            self.client = DummyClientWithDictError()

        def get_client(self):
            return self.client

    ds = OneNoteDataSource(DummyMSGraphClientWithDictError())
    resp = await ds.users_onenote_sections_pages_get_parent_section(
        user_id="user7", onenoteSection_id="secG", onenotePage_id="pg7"
    )


@pytest.mark.asyncio
async def test_edge_exception_handling():
    """Test that exceptions in the API call are handled."""

    class DummyParentSectionAPIWithException(DummyParentSectionAPI):
        async def get(self, request_configuration=None):
            raise RuntimeError("Simulated API failure")

    class DummyPageWithException(DummyPage):
        def __init__(self, section_id, page_id):
            self.section_id = section_id
            self.page_id = page_id
            self.parent_section = DummyParentSectionAPIWithException(
                section_id, page_id
            )

    class DummyPagesWithException(DummyPages):
        def by_onenote_page_id(self, page_id):
            return DummyPageWithException(section_id=self.section_id, page_id=page_id)

    class DummySectionWithException(DummySection):
        def __init__(self, user_id, section_id):
            self.user_id = user_id
            self.section_id = section_id
            self.pages = DummyPagesWithException(section_id=section_id)

    class DummySectionsWithException(DummySections):
        def by_onenote_section_id(self, section_id):
            return DummySectionWithException(
                user_id=self.user_id, section_id=section_id
            )

    class DummyOnenoteWithException(DummyOnenote):
        def __init__(self, user_id):
            self.sections = DummySectionsWithException(user_id=user_id)

    class DummyUserWithException(DummyUser):
        def __init__(self, user_id):
            self.user_id = user_id
            self.onenote = DummyOnenoteWithException(user_id=user_id)

    class DummyUsersWithException(DummyUsers):
        def by_user_id(self, user_id):
            return DummyUserWithException(user_id=user_id)

    class DummyClientWithException(DummyClient):
        def __init__(self):
            self.users = DummyUsersWithException()
            self.me = True

        def get_ms_graph_service_client(self):
            return self

    class DummyMSGraphClientWithException(DummyMSGraphClient):
        def __init__(self):
            self.client = DummyClientWithException()

        def get_client(self):
            return self.client

    ds = OneNoteDataSource(DummyMSGraphClientWithException())
    resp = await ds.users_onenote_sections_pages_get_parent_section(
        user_id="user8", onenoteSection_id="secH", onenotePage_id="pg8"
    )


@pytest.mark.asyncio
async def test_large_scale_concurrent_execution():
    """Test large scale concurrent execution with 50 calls."""
    ds = OneNoteDataSource(DummyMSGraphClient())
    num_calls = 50
    tasks = [
        ds.users_onenote_sections_pages_get_parent_section(
            user_id=f"user{i}", onenoteSection_id=f"sec{i}", onenotePage_id=f"pg{i}"
        )
        for i in range(num_calls)
    ]
    results = await asyncio.gather(*tasks)
    for i, resp in enumerate(results):
        pass


@pytest.mark.asyncio
async def test_OneNoteDataSource_users_onenote_sections_pages_get_parent_section_throughput_small_load():
    """Throughput test: small load (10 concurrent calls)."""
    ds = OneNoteDataSource(DummyMSGraphClient())
    num_calls = 10
    tasks = [
        ds.users_onenote_sections_pages_get_parent_section(
            user_id=f"user{i}", onenoteSection_id=f"sec{i}", onenotePage_id=f"pg{i}"
        )
        for i in range(num_calls)
    ]
    results = await asyncio.gather(*tasks)
    for resp in results:
        pass


@pytest.mark.asyncio
async def test_OneNoteDataSource_users_onenote_sections_pages_get_parent_section_throughput_large_load():
    """Throughput test: large load (250 concurrent calls)."""
    ds = OneNoteDataSource(DummyMSGraphClient())
    num_calls = 250
    tasks = [
        ds.users_onenote_sections_pages_get_parent_section(
            user_id=f"user{i}", onenoteSection_id=f"sec{i}", onenotePage_id=f"pg{i}"
        )
        for i in range(num_calls)
    ]
    results = await asyncio.gather(*tasks)
    for resp in results:
        pass


@pytest.mark.asyncio
async def test_OneNoteDataSource_users_onenote_sections_pages_get_parent_section_throughput_varying_parameters():
    """Throughput test: varying parameters and headers."""
    ds = OneNoteDataSource(DummyMSGraphClient())
    num_calls = 20
    tasks = []
    for i in range(num_calls):
        kwargs = {}
        if i % 2 == 0:
            kwargs["select"] = ["name"]
        if i % 3 == 0:
            kwargs["expand"] = ["parentNotebook"]
        if i % 5 == 0:
            kwargs["headers"] = {"Custom-Header": f"Value-{i}"}
        tasks.append(
            ds.users_onenote_sections_pages_get_parent_section(
                user_id=f"user{i}",
                onenoteSection_id=f"sec{i}",
                onenotePage_id=f"pg{i}",
                **kwargs,
            )
        )
    results = await asyncio.gather(*tasks)
    for resp 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_sections_pages_get_parent_section-mjf95edt and push.