⚡️ Speed up method RESTResponse.getheader by 11%

[codeflash-ai]

📄 11% (0.11x) speedup for RESTResponse.getheader in pinecone/openapi_support/rest_utils.py

⏱️ Runtime : 565 microseconds → 510 microseconds (best of 316 runs)

📝 Explanation and details

The optimized code replaces dict.get(name, default) with a try/except pattern using direct dictionary access (self.headers[name]). This optimization leverages Python's EAFP (Easier to Ask for Forgiveness than Permission) principle.

Key Performance Improvement:

• Direct dictionary access (headers[name]) is faster than dict.get() when the key exists because it avoids the overhead of method call dispatch and internal default value handling
• The try/except overhead only occurs when keys are missing, which based on the test results appears to be rare (~27 out of 3060 calls, or <1%)

Performance Characteristics:

• Best case (key exists): ~12-17% faster for existing headers, which represents the majority of use cases
• Worst case (key missing): ~25-60% slower when headers don't exist, but this is infrequent
• Overall net gain: 10% speedup because the common case (header exists) dominates

Why This Works:
Dictionary __getitem__ is implemented in C and optimized for the happy path, while dict.get() has additional Python-level overhead to handle the default parameter. Since HTTP header lookups typically succeed (checking Content-Type, Authorization, etc.), optimizing for the success case yields better overall performance despite the penalty for missing keys.

The optimization is particularly effective for scenarios with large numbers of headers or frequent header access, as shown in the large-scale test cases.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

import io

# imports
import pytest  # used for our unit tests
from pinecone.openapi_support.rest_utils import RESTResponse

# unit tests

# 1. Basic Test Cases

def test_getheader_returns_existing_header():
    # Test that getheader returns the value of an existing header
    resp = RESTResponse(200, b'data', {'Content-Type': 'application/json'})
    codeflash_output = resp.getheader('Content-Type') # 439ns -> 389ns (12.9% faster)

def test_getheader_returns_default_for_missing_header():
    # Test that getheader returns the default value when header is missing
    resp = RESTResponse(200, b'data', {'Content-Type': 'application/json'})
    codeflash_output = resp.getheader('X-Not-Found', default='missing') # 645ns -> 902ns (28.5% slower)

def test_getheader_returns_none_for_missing_header_and_no_default():
    # Test that getheader returns None when header is missing and no default is provided
    resp = RESTResponse(200, b'data', {'Content-Type': 'application/json'})
    codeflash_output = resp.getheader('X-Not-Found') # 442ns -> 659ns (32.9% slower)

def test_getheader_with_multiple_headers():
    # Test that getheader works with multiple headers
    headers = {'Content-Type': 'application/json', 'X-Test': 'abc', 'X-Number': '123'}
    resp = RESTResponse(200, b'data', headers)
    codeflash_output = resp.getheader('X-Test') # 356ns -> 395ns (9.87% slower)
    codeflash_output = resp.getheader('X-Number') # 219ns -> 197ns (11.2% faster)
    codeflash_output = resp.getheader('Content-Type') # 166ns -> 142ns (16.9% faster)

# 2. Edge Test Cases

def test_getheader_with_empty_headers_dict():
    # Test that getheader returns default/None when headers dict is empty
    resp = RESTResponse(200, b'data', {})
    codeflash_output = resp.getheader('Any-Header') # 415ns -> 698ns (40.5% slower)
    codeflash_output = resp.getheader('Any-Header', default='nope') # 478ns -> 640ns (25.3% slower)

def test_getheader_with_header_value_none():
    # Test that getheader returns None if header value is None
    resp = RESTResponse(200, b'data', {'X-Null': None})
    codeflash_output = resp.getheader('X-Null') # 384ns -> 384ns (0.000% faster)
    # Should distinguish between header missing and header present with value None
    resp2 = RESTResponse(200, b'data', {})
    codeflash_output = resp2.getheader('X-Null') # 224ns -> 488ns (54.1% slower)

def test_getheader_with_non_string_header_name():
    # Test that getheader works with non-string header names if present
    resp = RESTResponse(200, b'data', {123: 'number', None: 'none'})
    codeflash_output = resp.getheader(123) # 439ns -> 398ns (10.3% faster)
    codeflash_output = resp.getheader(None) # 290ns -> 220ns (31.8% faster)
    # Should return default if not present
    codeflash_output = resp.getheader('missing', default='default') # 483ns -> 767ns (37.0% slower)

def test_getheader_with_empty_string_header_name():
    # Test that getheader works with empty string header name
    resp = RESTResponse(200, b'data', {'': 'empty'})
    codeflash_output = resp.getheader('') # 362ns -> 364ns (0.549% slower)
    codeflash_output = resp.getheader('nonexistent', default='default') # 508ns -> 790ns (35.7% slower)

def test_getheader_with_case_sensitive_names():
    # Test that getheader is case-sensitive (dict keys are case-sensitive)
    resp = RESTResponse(200, b'data', {'Content-Type': 'application/json', 'content-type': 'text/plain'})
    codeflash_output = resp.getheader('Content-Type') # 355ns -> 355ns (0.000% faster)
    codeflash_output = resp.getheader('content-type') # 236ns -> 225ns (4.89% faster)
    codeflash_output = resp.getheader('CONTENT-TYPE') # 185ns -> 474ns (61.0% slower)

def test_getheader_with_mutable_default():
    # Test that getheader returns the mutable default object itself if header missing
    default_list = []
    resp = RESTResponse(200, b'data', {})
    codeflash_output = resp.getheader('foo', default=default_list); result = codeflash_output # 605ns -> 868ns (30.3% slower)

def test_getheader_with_header_value_falsey():
    # Test that getheader returns falsey values correctly
    resp = RESTResponse(200, b'data', {'X-False': False, 'X-Zero': 0, 'X-EmptyStr': ''})
    codeflash_output = resp.getheader('X-False') # 336ns -> 355ns (5.35% slower)
    codeflash_output = resp.getheader('X-Zero') # 244ns -> 197ns (23.9% faster)
    codeflash_output = resp.getheader('X-EmptyStr') # 164ns -> 143ns (14.7% faster)

def test_getheader_with_header_value_object():
    # Test that getheader returns non-string values (e.g. dict, list)
    value = {'a': 1}
    resp = RESTResponse(200, b'data', {'X-Object': value})
    codeflash_output = resp.getheader('X-Object') # 381ns -> 356ns (7.02% faster)

def test_getheader_with_header_name_not_in_dict_and_no_default():
    # Test that getheader returns None if header not present and no default
    resp = RESTResponse(200, b'data', {'A': 'B'})
    codeflash_output = resp.getheader('C') # 408ns -> 670ns (39.1% slower)

# 3. Large Scale Test Cases

def test_getheader_with_many_headers():
    # Test that getheader works with a large number of headers
    headers = {f'Header-{i}': f'value-{i}' for i in range(1000)}
    resp = RESTResponse(200, b'data', headers)
    # Pick several random headers to check
    codeflash_output = resp.getheader('Header-0') # 455ns -> 418ns (8.85% faster)
    codeflash_output = resp.getheader('Header-999') # 326ns -> 297ns (9.76% faster)
    codeflash_output = resp.getheader('Header-500') # 204ns -> 193ns (5.70% faster)
    # Check missing header
    codeflash_output = resp.getheader('Header-1001', default='not found') # 488ns -> 779ns (37.4% slower)

def test_getheader_performance_with_large_headers(monkeypatch):
    # Test that getheader is fast with large headers (not timing, but functional)
    headers = {f'Key-{i}': f'Val-{i}' for i in range(1000)}
    resp = RESTResponse(200, b'data', headers)
    # Access every header and verify correctness
    for i in range(1000):
        codeflash_output = resp.getheader(f'Key-{i}') # 189μs -> 160μs (18.1% faster)
    # Check a missing header
    codeflash_output = resp.getheader('Key-10000', default='missing') # 627ns -> 1.23μs (49.1% slower)

def test_getheader_with_large_header_values():
    # Test that getheader works with very large header values
    large_value = 'x' * 10000  # 10,000 characters
    resp = RESTResponse(200, b'data', {'Large-Header': large_value})
    codeflash_output = resp.getheader('Large-Header') # 429ns -> 392ns (9.44% faster)
    # Check missing header
    codeflash_output = resp.getheader('Missing-Header', default='default') # 509ns -> 771ns (34.0% slower)

def test_getheader_with_large_headers_and_non_string_keys():
    # Test that getheader works with large headers and non-string keys
    headers = {i: f'value-{i}' for i in range(1000)}
    resp = RESTResponse(200, b'data', headers)
    for i in range(1000):
        codeflash_output = resp.getheader(i) # 167μs -> 153μs (9.07% faster)
    # Check missing numeric key
    codeflash_output = resp.getheader(1001, default='missing') # 570ns -> 1.20μs (52.5% slower)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
import io

# imports
import pytest  # used for our unit tests
from pinecone.openapi_support.rest_utils import RESTResponse

# unit tests

# ---- Basic Test Cases ----

def test_getheader_existing_key():
    """Test retrieving an existing header key."""
    resp = RESTResponse(200, b'OK', {'Content-Type': 'application/json'})
    codeflash_output = resp.getheader('Content-Type') # 432ns -> 432ns (0.000% faster)

def test_getheader_missing_key_with_default():
    """Test retrieving a missing header key with a provided default value."""
    resp = RESTResponse(200, b'OK', {'Content-Type': 'application/json'})
    codeflash_output = resp.getheader('Authorization', default='Bearer token') # 572ns -> 912ns (37.3% slower)

def test_getheader_missing_key_without_default():
    """Test retrieving a missing header key without a default value (should return None)."""
    resp = RESTResponse(200, b'OK', {'Content-Type': 'application/json'})
    codeflash_output = resp.getheader('Authorization') # 381ns -> 629ns (39.4% slower)

def test_getheader_case_sensitive():
    """Test that header lookup is case-sensitive (dict default)."""
    resp = RESTResponse(200, b'OK', {'Content-Type': 'application/json'})
    codeflash_output = resp.getheader('content-type') # 412ns -> 666ns (38.1% slower)

def test_getheader_multiple_headers():
    """Test retrieving values from multiple headers."""
    headers = {'A': '1', 'B': '2', 'C': '3'}
    resp = RESTResponse(200, b'OK', headers)
    codeflash_output = resp.getheader('A') # 403ns -> 400ns (0.750% faster)
    codeflash_output = resp.getheader('B') # 272ns -> 223ns (22.0% faster)
    codeflash_output = resp.getheader('C') # 166ns -> 194ns (14.4% slower)

# ---- Edge Test Cases ----

def test_getheader_empty_headers_dict():
    """Test behavior when headers dict is empty."""
    resp = RESTResponse(200, b'OK', {})
    codeflash_output = resp.getheader('Anything') # 406ns -> 643ns (36.9% slower)
    codeflash_output = resp.getheader('Anything', default='NotFound') # 503ns -> 710ns (29.2% slower)

def test_getheader_none_key():
    """Test behavior when key is None."""
    resp = RESTResponse(200, b'OK', {None: 'NullKey'})
    codeflash_output = resp.getheader(None) # 431ns -> 366ns (17.8% faster)
    # If None is not present, should return default
    resp2 = RESTResponse(200, b'OK', {})
    codeflash_output = resp2.getheader(None, default='DefaultValue') # 555ns -> 871ns (36.3% slower)

def test_getheader_empty_string_key():
    """Test behavior when key is empty string."""
    resp = RESTResponse(200, b'OK', {'': 'EmptyKey'})
    codeflash_output = resp.getheader('') # 387ns -> 366ns (5.74% faster)
    resp2 = RESTResponse(200, b'OK', {})
    codeflash_output = resp2.getheader('', default='DefaultEmpty') # 513ns -> 800ns (35.9% slower)

def test_getheader_key_with_special_characters():
    """Test behavior with keys containing special characters."""
    headers = {'X-Auth@Token!': 'abc123', 'X-Header#': 'value'}
    resp = RESTResponse(200, b'OK', headers)
    codeflash_output = resp.getheader('X-Auth@Token!') # 377ns -> 365ns (3.29% faster)
    codeflash_output = resp.getheader('X-Header#') # 231ns -> 214ns (7.94% faster)
    codeflash_output = resp.getheader('X-Auth@token!') # 180ns -> 455ns (60.4% slower)

def test_getheader_value_is_none():
    """Test when the header value itself is None."""
    headers = {'NullValue': None}
    resp = RESTResponse(200, b'OK', headers)
    # Should return None, not the default, because the key exists
    codeflash_output = resp.getheader('NullValue', default='DefaultIfMissing') # 562ns -> 527ns (6.64% faster)

def test_getheader_default_is_none_explicit():
    """Test default value is None explicitly."""
    resp = RESTResponse(200, b'OK', {})
    codeflash_output = resp.getheader('MissingKey', default=None) # 532ns -> 873ns (39.1% slower)

# ---- Large Scale Test Cases ----

def test_getheader_large_number_of_headers():
    """Test with a large number of headers (scalability)."""
    large_headers = {f'Header-{i}': f'Value-{i}' for i in range(1000)}
    resp = RESTResponse(200, b'OK', large_headers)
    # Check a few random headers
    codeflash_output = resp.getheader('Header-0') # 449ns -> 440ns (2.05% faster)
    codeflash_output = resp.getheader('Header-999') # 314ns -> 317ns (0.946% slower)
    codeflash_output = resp.getheader('Header-500') # 192ns -> 184ns (4.35% faster)
    # Check missing header
    codeflash_output = resp.getheader('Header-1000') # 182ns -> 437ns (58.4% slower)
    codeflash_output = resp.getheader('Header-1001', default='NotFound') # 451ns -> 575ns (21.6% slower)

def test_getheader_large_values():
    """Test with very large header values."""
    big_value = 'x' * 1000  # 1000 characters
    headers = {'Big-Header': big_value}
    resp = RESTResponse(200, b'OK', headers)
    codeflash_output = resp.getheader('Big-Header') # 375ns -> 354ns (5.93% faster)

def test_getheader_performance_on_many_lookups():
    """Test performance and correctness when calling getheader many times."""
    headers = {f'K{i}': f'V{i}' for i in range(1000)}
    resp = RESTResponse(200, b'OK', headers)
    # Check all keys
    for i in range(1000):
        codeflash_output = resp.getheader(f'K{i}') # 184μs -> 164μs (11.8% faster)
    # Check for a missing key
    codeflash_output = resp.getheader('K1000') # 195ns -> 758ns (74.3% slower)

def test_getheader_large_headers_with_special_keys():
    """Test with large number of headers including special character keys."""
    headers = {f'Key!@#{i}': f'Value*(&{i}' for i in range(1000)}
    resp = RESTResponse(200, b'OK', headers)
    # Check a few
    codeflash_output = resp.getheader('Key!@#0') # 418ns -> 441ns (5.22% slower)
    codeflash_output = resp.getheader('Key!@#999') # 283ns -> 290ns (2.41% slower)
    # Check missing
    codeflash_output = resp.getheader('Key!@#1000', default='Missing') # 486ns -> 829ns (41.4% slower)
# 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-RESTResponse.getheader-mh9wn5lo and push.