⚡️ Speed up method SyncCursorPage.next_page_info by 933%

[codeflash-ai]

📄 933% (9.33x) speedup for SyncCursorPage.next_page_info in src/openai/pagination.py

⏱️ Runtime : 211 microseconds → 20.4 microseconds (best of 138 runs)

📝 Explanation and details

The optimized code achieves a 933% speedup by eliminating an expensive isinstance check and unnecessary type casting.

Key optimizations:

1. Removed cast(Any, data[-1]): The original code unnecessarily cast the last item to Any, which adds runtime overhead without providing any functional benefit since we only need to check for the id attribute.

2. Replaced isinstance(item, CursorPageItem) with hasattr(item, "id"): The isinstance check was the primary bottleneck (90% of execution time in the profiler). Using hasattr leverages Python's duck typing approach - we only care if the object has an id attribute, not its exact type. This is much faster than class hierarchy checking.

3. Used getattr(item, "id", None) for safe attribute access: This provides the same null-checking behavior as item.id is None but works safely with any object type.

Performance impact by test case type:

• Empty data cases: Modest 42% improvement due to reduced import overhead
• Valid cursor items: 600-650% speedup - benefits from both optimizations
• Invalid/edge cases: 1400-2800% speedup - these benefit most since they previously triggered the expensive isinstance check that always failed
• Large lists: Similar relative improvements (600-1800%) since the optimization only affects the last item check

The optimization maintains identical behavior while being much more efficient for Python's dynamic typing model.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

from typing import Any, Dict, List, Optional

# imports
import pytest  # used for our unit tests
from openai.pagination import SyncCursorPage

# --- Minimal stubs for dependencies ---

class PageInfo:
    def __init__(self, params: Dict[str, Any]):
        self.params = params

    def __eq__(self, other):
        if not isinstance(other, PageInfo):
            return False
        return self.params == other.params

class CursorPageItem:
    def __init__(self, id: Optional[str]):
        self.id = id
from openai.pagination import SyncCursorPage

# --- Unit Tests ---

# 1. Basic Test Cases


















#------------------------------------------------
from dataclasses import dataclass
# function to test
from typing import Any, Generic, List, Optional, TypeVar, cast

# imports
import pytest
from openai.pagination import SyncCursorPage

_T = TypeVar("_T")

# Minimal stub for CursorPageItem for testing
@dataclass
class CursorPageItem:
    id: Optional[str] = None

@dataclass
class PageInfo:
    params: dict

class BasePage(Generic[_T]):
    pass

class BaseSyncPage(Generic[_T]):
    pass
from openai.pagination import SyncCursorPage

# unit tests

# ---------------------------
# 1. Basic Test Cases
# ---------------------------

def test_next_page_info_returns_none_for_empty_data():
    # Test: Empty data list should return None
    page = SyncCursorPage(data=[])
    codeflash_output = page.next_page_info() # 871ns -> 611ns (42.6% faster)

def test_next_page_info_returns_pageinfo_for_valid_cursor_item():
    # Test: Last item is CursorPageItem with id, should return PageInfo
    items = [CursorPageItem(id="abc"), CursorPageItem(id="def")]
    page = SyncCursorPage(data=items)
    codeflash_output = page.next_page_info(); result = codeflash_output # 14.3μs -> 1.89μs (655% faster)

def test_next_page_info_returns_none_for_non_cursor_item():
    # Test: Last item is not CursorPageItem, should return None
    items = [CursorPageItem(id="abc"), "not_a_cursor_item"]
    page = SyncCursorPage(data=items)
    codeflash_output = page.next_page_info() # 11.0μs -> 705ns (1461% faster)

def test_next_page_info_returns_none_for_cursor_item_with_none_id():
    # Test: Last item is CursorPageItem with id=None, should return None
    items = [CursorPageItem(id="abc"), CursorPageItem(id=None)]
    page = SyncCursorPage(data=items)
    codeflash_output = page.next_page_info() # 10.9μs -> 747ns (1358% faster)

def test_next_page_info_returns_pageinfo_for_single_cursor_item():
    # Test: Single item with valid id
    page = SyncCursorPage(data=[CursorPageItem(id="xyz")])
    codeflash_output = page.next_page_info(); result = codeflash_output # 11.6μs -> 1.61μs (624% faster)

# ---------------------------
# 2. Edge Test Cases
# ---------------------------

def test_next_page_info_returns_none_for_last_item_missing_id_attribute():
    # Test: Last item is CursorPageItem but has no 'id' attribute
    class NoIdCursorPageItem:
        pass
    items = [CursorPageItem(id="abc"), NoIdCursorPageItem()]
    page = SyncCursorPage(data=items)
    codeflash_output = page.next_page_info() # 22.1μs -> 743ns (2879% faster)

def test_next_page_info_returns_none_for_last_item_id_empty_string():
    # Test: Last item is CursorPageItem with id="", which is valid (not None)
    items = [CursorPageItem(id="abc"), CursorPageItem(id="")]
    page = SyncCursorPage(data=items)
    codeflash_output = page.next_page_info(); result = codeflash_output # 11.7μs -> 1.61μs (623% faster)

def test_next_page_info_returns_none_for_last_item_id_is_falsey_but_not_none():
    # Test: Last item is CursorPageItem with id=0 (falsey but not None)
    items = [CursorPageItem(id="abc"), CursorPageItem(id=0)]
    codeflash_output = SyncCursorPage(data=items).next_page_info(); result = codeflash_output # 11.1μs -> 1.44μs (672% faster)

def test_next_page_info_returns_none_for_last_item_is_none():
    # Test: Last item is None
    items = [CursorPageItem(id="abc"), None]
    page = SyncCursorPage(data=items)
    codeflash_output = page.next_page_info() # 9.95μs -> 638ns (1460% faster)

def test_next_page_info_returns_none_for_last_item_is_int():
    # Test: Last item is int
    items = [CursorPageItem(id="abc"), 123]
    page = SyncCursorPage(data=items)
    codeflash_output = page.next_page_info() # 10.6μs -> 627ns (1593% faster)

def test_next_page_info_returns_none_for_last_item_is_dict_with_id():
    # Test: Last item is dict with 'id' key, but not a CursorPageItem
    items = [CursorPageItem(id="abc"), {"id": "def"}]
    page = SyncCursorPage(data=items)
    codeflash_output = page.next_page_info() # 10.0μs -> 595ns (1586% faster)

def test_next_page_info_returns_none_for_last_item_is_cursor_item_with_id_none_and_has_more_true():
    # Test: Last item is CursorPageItem with id=None, has_more True
    items = [CursorPageItem(id="abc"), CursorPageItem(id=None)]
    page = SyncCursorPage(data=items, has_more=True)
    codeflash_output = page.next_page_info() # 10.4μs -> 694ns (1400% faster)

def test_next_page_info_returns_pageinfo_for_last_item_is_cursor_item_with_id_and_has_more_false():
    # Test: Last item is CursorPageItem with id, has_more False
    items = [CursorPageItem(id="abc"), CursorPageItem(id="def")]
    page = SyncCursorPage(data=items, has_more=False)
    codeflash_output = page.next_page_info(); result = codeflash_output # 11.5μs -> 1.67μs (585% faster)

# ---------------------------
# 3. Large Scale Test Cases
# ---------------------------

def test_next_page_info_large_list_returns_pageinfo_for_last_cursor_item():
    # Test: Large list of CursorPageItem, last item has valid id
    items = [CursorPageItem(id=str(i)) for i in range(999)]
    page = SyncCursorPage(data=items)
    codeflash_output = page.next_page_info(); result = codeflash_output # 13.5μs -> 1.82μs (641% faster)

def test_next_page_info_large_list_last_item_non_cursor_item():
    # Test: Large list, last item is not CursorPageItem
    items = [CursorPageItem(id=str(i)) for i in range(998)] + ["not_a_cursor_item"]
    page = SyncCursorPage(data=items)
    codeflash_output = page.next_page_info() # 12.3μs -> 636ns (1833% faster)

def test_next_page_info_large_list_last_item_cursor_item_with_none_id():
    # Test: Large list, last item is CursorPageItem with id=None
    items = [CursorPageItem(id=str(i)) for i in range(998)] + [CursorPageItem(id=None)]
    page = SyncCursorPage(data=items)
    codeflash_output = page.next_page_info() # 12.2μs -> 748ns (1526% faster)

def test_next_page_info_large_list_last_item_cursor_item_with_valid_id():
    # Test: Large list, last item is CursorPageItem with valid id (string)
    items = [CursorPageItem(id=str(i)) for i in range(998)] + [CursorPageItem(id="final_id")]
    page = SyncCursorPage(data=items)
    codeflash_output = page.next_page_info(); result = codeflash_output # 13.3μs -> 1.88μs (610% faster)

def test_next_page_info_large_list_last_item_cursor_item_with_id_is_zero():
    # Test: Large list, last item is CursorPageItem with id=0
    items = [CursorPageItem(id=str(i)) for i in range(998)] + [CursorPageItem(id=0)]
    page = SyncCursorPage(data=items)
    codeflash_output = page.next_page_info(); result = codeflash_output # 13.2μs -> 1.70μs (674% faster)
# 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-SyncCursorPage.next_page_info-mhdiwirf and push.