⚡️ Speed up method BulkImportRequestFactory.list_imports_paginated_args by 101%

[codeflash-ai]

📄 101% (1.01x) speedup for BulkImportRequestFactory.list_imports_paginated_args in pinecone/db_data/resources/sync/bulk_import_request_factory.py

⏱️ Runtime : 76.5 microseconds → 38.0 microseconds (best of 354 runs)

📝 Explanation and details

The optimized code achieves a 101% speedup by eliminating function call overhead and reducing dictionary creation overhead through two key changes:

1. Direct dictionary construction in list_imports_paginated_args:

• Original: Creates a list of tuples [("limit", limit), ("pagination_token", pagination_token)] and passes it to parse_non_empty_args()
• Optimized: Builds the result dictionary directly with simple if checks and assignments
• Why faster: Eliminates function call overhead, tuple creation, and list allocation for just 2 fixed parameters

2. Loop-based implementation in parse_non_empty_args:

• Original: Uses dictionary comprehension {arg_name: val for arg_name, val in args if val is not None}
• Optimized: Uses explicit for-loop with conditional assignment
• Why faster: Avoids comprehension overhead and reduces interpreter work per iteration

Performance characteristics based on test results:

• Best gains (167-179% faster): When no arguments are provided, avoiding all unnecessary work
• Consistent gains (84-118% faster): Across all test cases regardless of argument types or sizes
• Stable performance: Large objects (1000-element lists, 999-char strings) still see 87-105% improvements, showing the optimization scales well

The optimization is particularly effective for this use case because it's optimizing a very small, fixed-size operation (max 2 parameters) that's likely called frequently in API request construction, where every microsecond of latency matters.

✅ Correctness verification report:

Test	Status
⚙️ Existing Unit Tests	🔘 None Found
🌀 Generated Regression Tests	✅ 56 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.resources.sync.bulk_import_request_factory import \
    BulkImportRequestFactory

# unit tests

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

def test_limit_only():
    # Test with only 'limit' provided
    codeflash_output = BulkImportRequestFactory.list_imports_paginated_args(limit=10); result = codeflash_output # 1.47μs -> 698ns (111% faster)

def test_pagination_token_only():
    # Test with only 'pagination_token' provided
    codeflash_output = BulkImportRequestFactory.list_imports_paginated_args(pagination_token="abc123"); result = codeflash_output # 1.40μs -> 680ns (106% faster)

def test_both_args_provided():
    # Test with both 'limit' and 'pagination_token' provided
    codeflash_output = BulkImportRequestFactory.list_imports_paginated_args(limit=20, pagination_token="token456"); result = codeflash_output # 1.43μs -> 742ns (92.0% faster)

def test_no_args_provided():
    # Test with neither argument provided (defaults)
    codeflash_output = BulkImportRequestFactory.list_imports_paginated_args(); result = codeflash_output # 1.13μs -> 404ns (179% faster)

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

def test_limit_zero():
    # Test with limit=0 (edge numeric value)
    codeflash_output = BulkImportRequestFactory.list_imports_paginated_args(limit=0); result = codeflash_output # 1.39μs -> 704ns (97.7% faster)

def test_limit_negative():
    # Test with negative limit
    codeflash_output = BulkImportRequestFactory.list_imports_paginated_args(limit=-5); result = codeflash_output # 1.36μs -> 677ns (101% faster)

def test_limit_large_int():
    # Test with a very large integer for limit
    large_int = 10**12
    codeflash_output = BulkImportRequestFactory.list_imports_paginated_args(limit=large_int); result = codeflash_output # 1.34μs -> 618ns (118% faster)

def test_pagination_token_empty_string():
    # Test with empty string for pagination_token
    codeflash_output = BulkImportRequestFactory.list_imports_paginated_args(pagination_token=""); result = codeflash_output # 1.36μs -> 680ns (101% faster)

def test_limit_none_pagination_token_none():
    # Explicitly pass None for both arguments
    codeflash_output = BulkImportRequestFactory.list_imports_paginated_args(limit=None, pagination_token=None); result = codeflash_output # 1.30μs -> 657ns (98.5% faster)

def test_limit_none_pagination_token_non_none():
    # Test with limit=None and pagination_token set
    codeflash_output = BulkImportRequestFactory.list_imports_paginated_args(limit=None, pagination_token="xyz"); result = codeflash_output # 1.38μs -> 711ns (94.2% faster)

def test_limit_non_none_pagination_token_none():
    # Test with limit set and pagination_token=None
    codeflash_output = BulkImportRequestFactory.list_imports_paginated_args(limit=42, pagination_token=None); result = codeflash_output # 1.36μs -> 685ns (99.0% faster)

def test_limit_float():
    # Test with a float value for limit
    codeflash_output = BulkImportRequestFactory.list_imports_paginated_args(limit=3.14); result = codeflash_output # 1.34μs -> 703ns (90.6% faster)

def test_pagination_token_special_chars():
    # Test with special characters in pagination_token
    codeflash_output = BulkImportRequestFactory.list_imports_paginated_args(pagination_token="!@#$%^&*()"); result = codeflash_output # 1.37μs -> 697ns (96.7% faster)

def test_limit_bool():
    # Test with boolean value for limit
    codeflash_output = BulkImportRequestFactory.list_imports_paginated_args(limit=True); result = codeflash_output # 1.32μs -> 655ns (102% faster)

def test_limit_list():
    # Test with a list as limit (should accept any type)
    val = [1,2,3]
    codeflash_output = BulkImportRequestFactory.list_imports_paginated_args(limit=val); result = codeflash_output # 1.38μs -> 688ns (101% faster)

def test_pagination_token_dict():
    # Test with a dict as pagination_token (should accept any type)
    val = {"foo": "bar"}
    codeflash_output = BulkImportRequestFactory.list_imports_paginated_args(pagination_token=val); result = codeflash_output # 1.41μs -> 717ns (96.8% faster)

def test_kwargs_ignored():
    # Test that extra kwargs are ignored
    codeflash_output = BulkImportRequestFactory.list_imports_paginated_args(limit=1, pagination_token="tok", extra="should_be_ignored"); result = codeflash_output # 1.61μs -> 874ns (84.7% faster)

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

def test_large_scale_limit():
    # Test with a large value for limit
    large_limit = 999_999_999
    codeflash_output = BulkImportRequestFactory.list_imports_paginated_args(limit=large_limit); result = codeflash_output # 1.35μs -> 673ns (101% faster)

def test_large_scale_pagination_token():
    # Test with a very long pagination_token string
    long_token = "a" * 1000  # 1000-character string
    codeflash_output = BulkImportRequestFactory.list_imports_paginated_args(pagination_token=long_token); result = codeflash_output # 1.31μs -> 692ns (89.7% faster)

def test_large_scale_limit_and_token():
    # Test with both large limit and long token
    large_limit = 10**9
    long_token = "z" * 999
    codeflash_output = BulkImportRequestFactory.list_imports_paginated_args(limit=large_limit, pagination_token=long_token); result = codeflash_output # 1.45μs -> 725ns (100% faster)

def test_large_scale_limit_list():
    # Test with a large list as limit value
    large_list = list(range(1000))
    codeflash_output = BulkImportRequestFactory.list_imports_paginated_args(limit=large_list); result = codeflash_output # 1.42μs -> 755ns (87.7% faster)

def test_large_scale_pagination_token_dict():
    # Test with a large dict as pagination_token
    large_dict = {str(i): i for i in range(1000)}
    codeflash_output = BulkImportRequestFactory.list_imports_paginated_args(pagination_token=large_dict); result = codeflash_output # 1.41μs -> 720ns (96.0% faster)

# ----------- DETERMINISM AND TYPE GUARANTEE ------------

def test_return_type():
    # Test that the return type is always dict
    codeflash_output = BulkImportRequestFactory.list_imports_paginated_args(limit=1); result = codeflash_output # 1.37μs -> 677ns (103% faster)

def test_return_type_empty():
    # Test that return type is dict even when empty
    codeflash_output = BulkImportRequestFactory.list_imports_paginated_args(); result = codeflash_output # 1.13μs -> 423ns (167% faster)

def test_keys_are_strings():
    # Test that all keys in the returned dict are strings
    codeflash_output = BulkImportRequestFactory.list_imports_paginated_args(limit=1, pagination_token="tok"); result = codeflash_output # 1.45μs -> 739ns (95.9% faster)
    for k in result.keys():
        pass

# ----------- IMMUTABILITY ------------

def test_mutation_does_not_affect_original():
    # Test that mutating the result does not affect subsequent calls
    codeflash_output = BulkImportRequestFactory.list_imports_paginated_args(limit=2); result1 = codeflash_output # 1.39μs -> 705ns (96.6% faster)
    result1["limit"] = 999
    codeflash_output = BulkImportRequestFactory.list_imports_paginated_args(limit=2); result2 = codeflash_output # 664ns -> 399ns (66.4% 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.resources.sync.bulk_import_request_factory import \
    BulkImportRequestFactory

# unit tests

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

def test_both_args_none():
    # Both limit and pagination_token are None: should return empty dict
    codeflash_output = BulkImportRequestFactory.list_imports_paginated_args(); result = codeflash_output # 1.07μs -> 435ns (146% faster)

def test_limit_provided_only():
    # Only limit provided, pagination_token is None
    codeflash_output = BulkImportRequestFactory.list_imports_paginated_args(limit=10); result = codeflash_output # 1.34μs -> 636ns (111% faster)

def test_pagination_token_provided_only():
    # Only pagination_token provided, limit is None
    codeflash_output = BulkImportRequestFactory.list_imports_paginated_args(pagination_token="abc123"); result = codeflash_output # 1.34μs -> 668ns (100% faster)

def test_both_args_provided():
    # Both limit and pagination_token provided
    codeflash_output = BulkImportRequestFactory.list_imports_paginated_args(limit=50, pagination_token="xyz789"); result = codeflash_output # 1.52μs -> 738ns (106% faster)

def test_limit_zero():
    # Limit is zero, which is a valid int (not None)
    codeflash_output = BulkImportRequestFactory.list_imports_paginated_args(limit=0); result = codeflash_output # 1.35μs -> 690ns (95.4% faster)

def test_pagination_token_empty_string():
    # pagination_token is empty string, which is not None
    codeflash_output = BulkImportRequestFactory.list_imports_paginated_args(pagination_token=""); result = codeflash_output # 1.31μs -> 680ns (92.9% faster)

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

def test_limit_negative():
    # Limit is negative
    codeflash_output = BulkImportRequestFactory.list_imports_paginated_args(limit=-1); result = codeflash_output # 1.38μs -> 665ns (108% faster)

def test_limit_float():
    # Limit is a float, not an int
    codeflash_output = BulkImportRequestFactory.list_imports_paginated_args(limit=2.5); result = codeflash_output # 1.33μs -> 623ns (113% faster)

def test_pagination_token_special_chars():
    # pagination_token contains special characters
    token = "!@#$%^&*()_+"
    codeflash_output = BulkImportRequestFactory.list_imports_paginated_args(pagination_token=token); result = codeflash_output # 1.35μs -> 678ns (99.6% faster)

def test_limit_none_explicit():
    # Explicitly passing limit=None
    codeflash_output = BulkImportRequestFactory.list_imports_paginated_args(limit=None); result = codeflash_output # 1.35μs -> 581ns (132% faster)

def test_pagination_token_none_explicit():
    # Explicitly passing pagination_token=None
    codeflash_output = BulkImportRequestFactory.list_imports_paginated_args(pagination_token=None); result = codeflash_output # 1.25μs -> 594ns (110% faster)

def test_limit_bool_true():
    # Limit is boolean True
    codeflash_output = BulkImportRequestFactory.list_imports_paginated_args(limit=True); result = codeflash_output # 1.36μs -> 638ns (113% faster)

def test_limit_bool_false():
    # Limit is boolean False
    codeflash_output = BulkImportRequestFactory.list_imports_paginated_args(limit=False); result = codeflash_output # 1.35μs -> 618ns (118% faster)

def test_pagination_token_int():
    # pagination_token is an integer
    codeflash_output = BulkImportRequestFactory.list_imports_paginated_args(pagination_token=42); result = codeflash_output # 1.35μs -> 671ns (101% faster)

def test_limit_large_int():
    # Limit is a very large integer
    large_int = 999999999
    codeflash_output = BulkImportRequestFactory.list_imports_paginated_args(limit=large_int); result = codeflash_output # 1.33μs -> 645ns (107% faster)

def test_limit_list():
    # Limit is a list
    limit_list = [1, 2, 3]
    codeflash_output = BulkImportRequestFactory.list_imports_paginated_args(limit=limit_list); result = codeflash_output # 1.38μs -> 722ns (91.1% faster)

def test_pagination_token_list():
    # pagination_token is a list
    token_list = ["a", "b", "c"]
    codeflash_output = BulkImportRequestFactory.list_imports_paginated_args(pagination_token=token_list); result = codeflash_output # 1.39μs -> 728ns (90.7% faster)

def test_limit_dict():
    # Limit is a dict
    limit_dict = {"a": 1}
    codeflash_output = BulkImportRequestFactory.list_imports_paginated_args(limit=limit_dict); result = codeflash_output # 1.46μs -> 754ns (93.1% faster)

def test_pagination_token_dict():
    # pagination_token is a dict
    token_dict = {"token": "abc"}
    codeflash_output = BulkImportRequestFactory.list_imports_paginated_args(pagination_token=token_dict); result = codeflash_output # 1.40μs -> 695ns (101% faster)

def test_kwargs_ignored():
    # Extra kwargs should be ignored
    codeflash_output = BulkImportRequestFactory.list_imports_paginated_args(limit=5, pagination_token="tok", foo="bar", test=123); result = codeflash_output # 1.65μs -> 904ns (82.5% faster)

def test_limit_nan():
    # Limit is float('nan')
    import math
    codeflash_output = BulkImportRequestFactory.list_imports_paginated_args(limit=math.nan); result = codeflash_output # 1.39μs -> 685ns (102% faster)

def test_pagination_token_none_and_limit_value():
    # pagination_token is None, limit is set
    codeflash_output = BulkImportRequestFactory.list_imports_paginated_args(limit=123, pagination_token=None); result = codeflash_output # 1.41μs -> 726ns (93.7% faster)

def test_limit_none_and_pagination_token_value():
    # limit is None, pagination_token is set
    codeflash_output = BulkImportRequestFactory.list_imports_paginated_args(limit=None, pagination_token="tok"); result = codeflash_output # 1.38μs -> 702ns (96.6% faster)

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

def test_limit_large_list():
    # Limit is a large list (999 elements)
    large_list = list(range(999))
    codeflash_output = BulkImportRequestFactory.list_imports_paginated_args(limit=large_list); result = codeflash_output # 1.43μs -> 747ns (90.9% faster)

def test_pagination_token_large_string():
    # pagination_token is a large string (999 chars)
    large_str = "x" * 999
    codeflash_output = BulkImportRequestFactory.list_imports_paginated_args(pagination_token=large_str); result = codeflash_output # 1.42μs -> 709ns (99.7% faster)

def test_limit_large_dict():
    # Limit is a large dict (999 keys)
    large_dict = {str(i): i for i in range(999)}
    codeflash_output = BulkImportRequestFactory.list_imports_paginated_args(limit=large_dict); result = codeflash_output # 1.46μs -> 722ns (103% faster)

def test_pagination_token_large_dict():
    # pagination_token is a large dict (999 keys)
    large_dict = {str(i): i for i in range(999)}
    codeflash_output = BulkImportRequestFactory.list_imports_paginated_args(pagination_token=large_dict); result = codeflash_output # 1.45μs -> 706ns (105% faster)

def test_limit_and_pagination_token_large():
    # Both limit and pagination_token are large objects
    large_list = list(range(999))
    large_str = "y" * 999
    codeflash_output = BulkImportRequestFactory.list_imports_paginated_args(limit=large_list, pagination_token=large_str); result = codeflash_output # 1.51μs -> 780ns (93.5% faster)

def test_performance_large_scale():
    # Performance test: should not take excessive time for large input
    import time
    large_list = list(range(999))
    large_str = "z" * 999
    start = time.time()
    codeflash_output = BulkImportRequestFactory.list_imports_paginated_args(limit=large_list, pagination_token=large_str); result = codeflash_output # 1.45μs -> 732ns (98.5% faster)
    end = time.time()
# 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.resources.sync.bulk_import_request_factory import BulkImportRequestFactory

def test_BulkImportRequestFactory_list_imports_paginated_args():
    BulkImportRequestFactory.list_imports_paginated_args(limit=0, pagination_token='')

To edit these changes git checkout codeflash/optimize-BulkImportRequestFactory.list_imports_paginated_args-mh6eu01c and push.