⚡️ Speed up method IndexRequestFactory.list_paginated_args by 17%

[codeflash-ai]

📄 17% (0.17x) speedup for IndexRequestFactory.list_paginated_args in pinecone/db_data/request_factory.py

⏱️ Runtime : 111 microseconds → 95.4 microseconds (best of 271 runs)

📝 Explanation and details

The optimized code achieves a 16% speedup through two key changes:

1. Eliminated Intermediate List Allocation:
Changed from creating a list [("prefix", prefix), ...] to using a tuple (("prefix", prefix), ...). This avoids allocating an unnecessary intermediate list structure since the data is immediately consumed by parse_non_empty_args.

2. Replaced Dict Comprehension with Explicit Loop:
The parse_non_empty_args function now uses a manual for-loop instead of a dict comprehension. For small collections like this (4 items), the explicit loop with pre-allocated dictionary is more efficient than the comprehension's internal machinery.

Why This Works:

• Memory efficiency: Tuples have less overhead than lists and avoid dynamic resizing
• Reduced function call overhead: The explicit loop eliminates intermediate iterator creation that comprehensions use
• Better type flexibility: Changed signature to Iterable allows for more efficient input types

Test Case Performance:
The optimization shows consistent 10-25% improvements across all test scenarios, with particularly strong gains when many arguments are None (up to 24.8% faster), indicating the loop optimization is especially effective when early filtering occurs.

✅ Correctness verification report:

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

# imports
import pytest  # used for our unit tests
from pinecone.db_data.request_factory import IndexRequestFactory

# unit tests

# ----------- BASIC TEST CASES -----------

def test_all_arguments_provided():
    # All arguments are provided and non-None
    codeflash_output = IndexRequestFactory.list_paginated_args(
        prefix="abc", limit=10, pagination_token="token123", namespace="ns"
    ); result = codeflash_output # 1.93μs -> 1.72μs (12.4% faster)

def test_some_arguments_none():
    # Some arguments are None, should be omitted from result
    codeflash_output = IndexRequestFactory.list_paginated_args(
        prefix="abc", limit=None, pagination_token=None, namespace="ns"
    ); result = codeflash_output # 1.81μs -> 1.51μs (19.7% faster)

def test_all_arguments_none():
    # All arguments are None, should return empty dict
    codeflash_output = IndexRequestFactory.list_paginated_args(
        prefix=None, limit=None, pagination_token=None, namespace=None
    ); result = codeflash_output # 1.56μs -> 1.35μs (15.5% faster)

def test_only_one_argument_provided():
    # Only one argument is provided, rest are None
    codeflash_output = IndexRequestFactory.list_paginated_args(
        prefix=None, limit=5, pagination_token=None, namespace=None
    ); result = codeflash_output # 1.66μs -> 1.40μs (18.3% faster)

def test_mixed_types():
    # Arguments have different types
    codeflash_output = IndexRequestFactory.list_paginated_args(
        prefix="prefix", limit=0, pagination_token="", namespace=None
    ); result = codeflash_output # 1.65μs -> 1.39μs (18.9% faster)

# ----------- EDGE TEST CASES -----------

def test_limit_zero():
    # limit is zero, which is a valid int value
    codeflash_output = IndexRequestFactory.list_paginated_args(limit=0); result = codeflash_output # 1.57μs -> 1.40μs (11.8% faster)

def test_empty_string_arguments():
    # Arguments are empty strings, which are not None
    codeflash_output = IndexRequestFactory.list_paginated_args(
        prefix="", limit=None, pagination_token="", namespace=""
    ); result = codeflash_output # 1.79μs -> 1.53μs (17.3% faster)

def test_limit_negative():
    # limit is negative, should be included
    codeflash_output = IndexRequestFactory.list_paginated_args(limit=-100); result = codeflash_output # 1.66μs -> 1.45μs (14.3% faster)

def test_limit_float():
    # limit is a float, should be included
    codeflash_output = IndexRequestFactory.list_paginated_args(limit=1.5); result = codeflash_output # 1.60μs -> 1.38μs (15.9% faster)

def test_namespace_special_characters():
    # namespace has special characters
    codeflash_output = IndexRequestFactory.list_paginated_args(namespace="ns!@#"); result = codeflash_output # 1.57μs -> 1.43μs (9.94% faster)

def test_pagination_token_none_and_empty():
    # pagination_token is None and then empty string
    codeflash_output = IndexRequestFactory.list_paginated_args(pagination_token=None); result_none = codeflash_output # 1.53μs -> 1.23μs (24.8% faster)
    codeflash_output = IndexRequestFactory.list_paginated_args(pagination_token=""); result_empty = codeflash_output # 968ns -> 794ns (21.9% faster)

def test_prefix_with_spaces():
    # prefix is a string with spaces
    codeflash_output = IndexRequestFactory.list_paginated_args(prefix="   "); result = codeflash_output # 1.40μs -> 1.29μs (8.42% faster)

def test_limit_large_integer():
    # limit is a large integer
    large_int = 10**12
    codeflash_output = IndexRequestFactory.list_paginated_args(limit=large_int); result = codeflash_output # 1.42μs -> 1.28μs (11.3% faster)

# ----------- LARGE SCALE TEST CASES -----------

def test_large_scale_limit():
    # limit is at upper reasonable bound
    codeflash_output = IndexRequestFactory.list_paginated_args(limit=999); result = codeflash_output # 1.47μs -> 1.30μs (13.1% faster)

def test_large_scale_string_arguments():
    # Test with large strings
    large_prefix = "p" * 1000
    large_namespace = "n" * 1000
    large_token = "t" * 1000
    codeflash_output = IndexRequestFactory.list_paginated_args(
        prefix=large_prefix, limit=1000, pagination_token=large_token, namespace=large_namespace
    ); result = codeflash_output # 1.85μs -> 1.56μs (18.7% faster)

def test_large_scale_empty_strings():
    # All arguments are empty strings (not None)
    codeflash_output = IndexRequestFactory.list_paginated_args(
        prefix="", limit=None, pagination_token="", namespace=""
    ); result = codeflash_output # 1.68μs -> 1.51μs (11.0% faster)

def test_large_scale_all_none():
    # All arguments are None, even with large kwargs (should ignore kwargs)
    codeflash_output = IndexRequestFactory.list_paginated_args(
        prefix=None, limit=None, pagination_token=None, namespace=None,
        extra1=None, extra2=None, extra3=None
    ); result = codeflash_output # 2.13μs -> 1.83μs (16.3% faster)

def test_large_scale_with_kwargs_ignored():
    # Extra kwargs are ignored, only main args are processed
    codeflash_output = IndexRequestFactory.list_paginated_args(
        prefix="main", limit=1, pagination_token="token", namespace="ns",
        extra1="should_be_ignored", extra2=999
    ); result = codeflash_output # 2.11μs -> 1.84μs (15.1% faster)

# ----------- ADDITIONAL EDGE CASES -----------

def test_limit_is_bool():
    # limit is a boolean, which is not None
    codeflash_output = IndexRequestFactory.list_paginated_args(limit=True); result_true = codeflash_output # 1.58μs -> 1.43μs (9.98% faster)
    codeflash_output = IndexRequestFactory.list_paginated_args(limit=False); result_false = codeflash_output # 885ns -> 737ns (20.1% faster)

def test_all_args_falsey_but_not_none():
    # All arguments are falsey but not None, should be included
    codeflash_output = IndexRequestFactory.list_paginated_args(
        prefix="", limit=0, pagination_token="", namespace=""
    ); result = codeflash_output # 1.78μs -> 1.54μs (16.1% faster)

def test_limit_is_list():
    # limit is a list, which is not None
    codeflash_output = IndexRequestFactory.list_paginated_args(limit=[1,2,3]); result = codeflash_output # 1.58μs -> 1.32μs (19.6% faster)

def test_limit_is_dict():
    # limit is a dict, which is not None
    codeflash_output = IndexRequestFactory.list_paginated_args(limit={"a": 1}); result = codeflash_output # 1.54μs -> 1.31μs (17.6% faster)

def test_namespace_is_empty_list():
    # namespace is empty list, which is not None
    codeflash_output = IndexRequestFactory.list_paginated_args(namespace=[]); result = codeflash_output # 1.66μs -> 1.42μs (17.0% faster)

def test_prefix_is_none_and_others_falsey():
    # prefix is None, others are falsey but not None
    codeflash_output = IndexRequestFactory.list_paginated_args(
        prefix=None, limit=0, pagination_token="", namespace=""
    ); result = codeflash_output # 1.75μs -> 1.59μs (10.2% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
from typing import Any, Dict, List, Optional, Tuple

# imports
import pytest  # used for our unit tests
from pinecone.db_data.request_factory import IndexRequestFactory

# unit tests

# ----------------------
# BASIC TEST CASES
# ----------------------

def test_all_args_none_returns_empty_dict():
    # All arguments are None, should return empty dict
    codeflash_output = IndexRequestFactory.list_paginated_args(); result = codeflash_output # 1.29μs -> 1.12μs (15.0% faster)

def test_only_prefix_set():
    # Only prefix is set
    codeflash_output = IndexRequestFactory.list_paginated_args(prefix="abc"); result = codeflash_output # 1.67μs -> 1.38μs (21.4% faster)

def test_only_limit_set():
    # Only limit is set
    codeflash_output = IndexRequestFactory.list_paginated_args(limit=10); result = codeflash_output # 1.58μs -> 1.38μs (14.5% faster)

def test_only_namespace_set():
    # Only namespace is set
    codeflash_output = IndexRequestFactory.list_paginated_args(namespace="ns"); result = codeflash_output # 1.64μs -> 1.36μs (19.8% faster)

def test_only_pagination_token_set():
    # Only pagination_token is set
    codeflash_output = IndexRequestFactory.list_paginated_args(pagination_token="token123"); result = codeflash_output # 1.57μs -> 1.37μs (14.9% faster)

def test_multiple_args_set():
    # Multiple arguments are set
    codeflash_output = IndexRequestFactory.list_paginated_args(prefix="abc", limit=5, namespace="ns"); result = codeflash_output # 1.79μs -> 1.56μs (14.6% faster)

def test_all_args_set():
    # All arguments are set
    codeflash_output = IndexRequestFactory.list_paginated_args(prefix="abc", limit=5, namespace="ns", pagination_token="token"); result = codeflash_output # 1.82μs -> 1.56μs (16.5% faster)

def test_limit_zero():
    # Limit is set to zero
    codeflash_output = IndexRequestFactory.list_paginated_args(limit=0); result = codeflash_output # 1.62μs -> 1.39μs (16.6% faster)

def test_limit_negative():
    # Limit is set to negative value
    codeflash_output = IndexRequestFactory.list_paginated_args(limit=-1); result = codeflash_output # 1.60μs -> 1.34μs (19.3% faster)

def test_limit_large():
    # Limit is set to a large value
    codeflash_output = IndexRequestFactory.list_paginated_args(limit=999); result = codeflash_output # 1.54μs -> 1.35μs (14.4% faster)

# ----------------------
# EDGE TEST CASES
# ----------------------

def test_prefix_empty_string():
    # Prefix is an empty string
    codeflash_output = IndexRequestFactory.list_paginated_args(prefix=""); result = codeflash_output # 1.59μs -> 1.38μs (15.4% faster)

def test_namespace_empty_string():
    # Namespace is an empty string
    codeflash_output = IndexRequestFactory.list_paginated_args(namespace=""); result = codeflash_output # 1.60μs -> 1.39μs (15.5% faster)

def test_pagination_token_empty_string():
    # Pagination token is an empty string
    codeflash_output = IndexRequestFactory.list_paginated_args(pagination_token=""); result = codeflash_output # 1.58μs -> 1.37μs (15.0% faster)

def test_limit_is_none():
    # Limit is explicitly set to None
    codeflash_output = IndexRequestFactory.list_paginated_args(limit=None); result = codeflash_output # 1.48μs -> 1.22μs (20.8% faster)

def test_prefix_is_none():
    # Prefix is explicitly set to None
    codeflash_output = IndexRequestFactory.list_paginated_args(prefix=None); result = codeflash_output # 1.54μs -> 1.23μs (24.8% faster)

def test_namespace_is_none():
    # Namespace is explicitly set to None
    codeflash_output = IndexRequestFactory.list_paginated_args(namespace=None); result = codeflash_output # 1.50μs -> 1.25μs (20.4% faster)

def test_pagination_token_is_none():
    # Pagination token is explicitly set to None
    codeflash_output = IndexRequestFactory.list_paginated_args(pagination_token=None); result = codeflash_output # 1.52μs -> 1.23μs (23.4% faster)

def test_prefix_is_false():
    # Prefix is False (should be included)
    codeflash_output = IndexRequestFactory.list_paginated_args(prefix=False); result = codeflash_output # 1.56μs -> 1.34μs (15.8% faster)

def test_limit_is_false():
    # Limit is False (should be included)
    codeflash_output = IndexRequestFactory.list_paginated_args(limit=False); result = codeflash_output # 1.58μs -> 1.37μs (14.9% faster)

def test_namespace_is_false():
    # Namespace is False (should be included)
    codeflash_output = IndexRequestFactory.list_paginated_args(namespace=False); result = codeflash_output # 1.57μs -> 1.42μs (10.7% faster)

def test_pagination_token_is_false():
    # Pagination token is False (should be included)
    codeflash_output = IndexRequestFactory.list_paginated_args(pagination_token=False); result = codeflash_output # 1.55μs -> 1.33μs (16.4% faster)

def test_prefix_is_empty_list():
    # Prefix is an empty list (should be included)
    codeflash_output = IndexRequestFactory.list_paginated_args(prefix=[]); result = codeflash_output # 1.62μs -> 1.38μs (17.4% faster)

def test_limit_is_empty_list():
    # Limit is an empty list (should be included)
    codeflash_output = IndexRequestFactory.list_paginated_args(limit=[]); result = codeflash_output # 1.61μs -> 1.43μs (12.9% faster)

def test_namespace_is_empty_list():
    # Namespace is an empty list (should be included)
    codeflash_output = IndexRequestFactory.list_paginated_args(namespace=[]); result = codeflash_output # 1.65μs -> 1.38μs (19.3% faster)

def test_pagination_token_is_empty_list():
    # Pagination token is an empty list (should be included)
    codeflash_output = IndexRequestFactory.list_paginated_args(pagination_token=[]); result = codeflash_output # 1.62μs -> 1.36μs (19.4% faster)

def test_prefix_is_empty_dict():
    # Prefix is an empty dict (should be included)
    codeflash_output = IndexRequestFactory.list_paginated_args(prefix={}); result = codeflash_output # 1.60μs -> 1.38μs (15.7% faster)

def test_limit_is_empty_dict():
    # Limit is an empty dict (should be included)
    codeflash_output = IndexRequestFactory.list_paginated_args(limit={}); result = codeflash_output # 1.64μs -> 1.31μs (24.8% faster)

def test_namespace_is_empty_dict():
    # Namespace is an empty dict (should be included)
    codeflash_output = IndexRequestFactory.list_paginated_args(namespace={}); result = codeflash_output # 1.61μs -> 1.42μs (13.8% faster)

def test_pagination_token_is_empty_dict():
    # Pagination token is an empty dict (should be included)
    codeflash_output = IndexRequestFactory.list_paginated_args(pagination_token={}); result = codeflash_output # 1.64μs -> 1.35μs (21.4% faster)

def test_limit_is_float():
    # Limit is a float value
    codeflash_output = IndexRequestFactory.list_paginated_args(limit=3.14); result = codeflash_output # 1.63μs -> 1.38μs (17.7% faster)

def test_limit_is_string():
    # Limit is a string value
    codeflash_output = IndexRequestFactory.list_paginated_args(limit="ten"); result = codeflash_output # 1.60μs -> 1.36μs (17.1% faster)

def test_all_args_false():
    # All arguments are False
    codeflash_output = IndexRequestFactory.list_paginated_args(prefix=False, limit=False, namespace=False, pagination_token=False); result = codeflash_output # 1.90μs -> 1.65μs (15.2% faster)

def test_all_args_empty_string():
    # All arguments are empty strings
    codeflash_output = IndexRequestFactory.list_paginated_args(prefix="", limit="", namespace="", pagination_token=""); result = codeflash_output # 1.85μs -> 1.53μs (21.2% faster)

def test_all_args_empty_list():
    # All arguments are empty lists
    codeflash_output = IndexRequestFactory.list_paginated_args(prefix=[], limit=[], namespace=[], pagination_token=[]); result = codeflash_output # 1.81μs -> 1.51μs (19.4% faster)

def test_all_args_empty_dict():
    # All arguments are empty dicts
    codeflash_output = IndexRequestFactory.list_paginated_args(prefix={}, limit={}, namespace={}, pagination_token={}); result = codeflash_output # 1.77μs -> 1.50μs (18.0% faster)

def test_args_with_special_characters():
    # Arguments with special characters
    codeflash_output = IndexRequestFactory.list_paginated_args(prefix="!@#", namespace="中文", pagination_token="💡", limit=42); result = codeflash_output # 1.83μs -> 1.52μs (20.9% faster)

# ----------------------
# LARGE SCALE TEST CASES
# ----------------------

def test_large_string_values():
    # Arguments with large string values
    large_str = "x" * 1000
    codeflash_output = IndexRequestFactory.list_paginated_args(prefix=large_str, namespace=large_str, pagination_token=large_str, limit=1000); result = codeflash_output # 1.78μs -> 1.53μs (16.8% faster)

def test_large_numeric_limit():
    # Limit is set to a large number
    large_limit = 999999
    codeflash_output = IndexRequestFactory.list_paginated_args(limit=large_limit); result = codeflash_output # 1.66μs -> 1.40μs (19.0% faster)

def test_large_list_as_arg():
    # Arguments are large lists
    large_list = list(range(1000))
    codeflash_output = IndexRequestFactory.list_paginated_args(prefix=large_list, namespace=large_list, pagination_token=large_list, limit=large_list); result = codeflash_output # 1.89μs -> 1.62μs (17.0% faster)

def test_large_dict_as_arg():
    # Arguments are large dicts
    large_dict = {str(i): i for i in range(1000)}
    codeflash_output = IndexRequestFactory.list_paginated_args(prefix=large_dict, namespace=large_dict, pagination_token=large_dict, limit=large_dict); result = codeflash_output # 1.97μs -> 1.66μs (18.4% faster)

def test_mixed_large_and_none():
    # Some arguments large, some None
    large_str = "y" * 1000
    codeflash_output = IndexRequestFactory.list_paginated_args(prefix=large_str, limit=None, namespace=None, pagination_token=large_str); result = codeflash_output # 1.76μs -> 1.52μs (15.9% faster)

def test_large_scale_all_none():
    # All arguments None, even in large scale test
    codeflash_output = IndexRequestFactory.list_paginated_args(prefix=None, limit=None, namespace=None, pagination_token=None); result = codeflash_output # 1.61μs -> 1.35μs (18.7% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
from pinecone.db_data.request_factory import IndexRequestFactory

def test_IndexRequestFactory_list_paginated_args():
    IndexRequestFactory.list_paginated_args(prefix='', limit=0, pagination_token='', namespace='')

To edit these changes git checkout codeflash/optimize-IndexRequestFactory.list_paginated_args-mh9ur1mx and push.