⚡️ Speed up method RestClientInterface.HEAD by 8%

[codeflash-ai]

📄 8% (0.08x) speedup for RestClientInterface.HEAD in pinecone/openapi_support/rest_utils.py

⏱️ Runtime : 491 microseconds → 455 microseconds (best of 399 runs)

📝 Explanation and details

The optimization converts the HEAD method's call to request() from using keyword arguments to positional arguments. Instead of passing headers=headers, _preload_content=_preload_content, etc., the optimized version passes arguments in the exact order they appear in the request() method signature: query_params, headers, None, None, _preload_content, _request_timeout.

Key changes:

• Eliminates keyword argument overhead by passing arguments positionally
• Explicitly passes None for body and post_params parameters that HEAD doesn't use
• Maintains identical behavior and parameter mapping

Why this is faster:
In Python, keyword arguments require additional dictionary lookups and parameter name matching at runtime. Positional arguments are directly mapped by position, avoiding this overhead. The 8% speedup comes from eliminating the cost of keyword argument processing in the function call.

Test case performance:
The optimization shows consistent 2-8% improvements across most test cases, with particularly good results for:

• Large-scale operations (8.92% faster for 1000 sequential calls)
• Tests with multiple parameters (7-8% faster)
• Basic usage patterns (2-7% faster)

Some individual test cases show slight slowdowns, but the overall trend and aggregated performance (8% speedup) demonstrates the optimization's effectiveness, especially for high-frequency API calls typical in REST client usage.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

from abc import ABC, abstractmethod
from unittest.mock import MagicMock

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


# Concrete implementation for testing
class DummyRestClient(RestClientInterface):
    def __init__(self, configuration, **kwargs):
        super().__init__(configuration, **kwargs)
        self.last_request_args = None

    def request(
        self,
        method,
        url,
        query_params=None,
        headers=None,
        body=None,
        post_params=None,
        _preload_content=True,
        _request_timeout=None,
    ):
        # Save all arguments for verification
        self.last_request_args = {
            "method": method,
            "url": url,
            "query_params": query_params,
            "headers": headers,
            "body": body,
            "post_params": post_params,
            "_preload_content": _preload_content,
            "_request_timeout": _request_timeout,
        }
        # Return a dummy response for demonstration
        return {"status": "dummy", "method": method, "url": url}

# ---------------------------
# Unit tests for HEAD method
# ---------------------------

# 1. Basic Test Cases

def test_head_basic_url_only():
    """Test HEAD with only the required url argument."""
    client = DummyRestClient(configuration={})
    codeflash_output = client.HEAD("http://example.com"); resp = codeflash_output # 1.34μs -> 1.31μs (2.52% faster)

def test_head_with_headers_and_query_params():
    """Test HEAD with headers and query_params provided."""
    client = DummyRestClient(configuration={})
    headers = {"Authorization": "Bearer token"}
    query_params = {"search": "test"}
    codeflash_output = client.HEAD(
        "http://example.com/api",
        headers=headers,
        query_params=query_params,
        _preload_content=False,
        _request_timeout=10
    ); resp = codeflash_output # 1.65μs -> 1.53μs (7.31% faster)

def test_head_empty_headers_and_query_params():
    """Test HEAD with empty headers and empty query_params."""
    client = DummyRestClient(configuration={})
    codeflash_output = client.HEAD(
        "http://example.com/test",
        headers={},
        query_params={}
    ); resp = codeflash_output # 1.51μs -> 1.46μs (3.14% faster)

# 2. Edge Test Cases

def test_head_url_is_empty_string():
    """Test HEAD with an empty string as url."""
    client = DummyRestClient(configuration={})
    codeflash_output = client.HEAD(""); resp = codeflash_output # 1.25μs -> 1.17μs (6.86% faster)

def test_head_url_is_none():
    """Test HEAD with None as url."""
    client = DummyRestClient(configuration={})
    codeflash_output = client.HEAD(None); resp = codeflash_output # 1.20μs -> 1.19μs (1.26% faster)

def test_head_headers_with_unusual_types():
    """Test HEAD with headers containing unusual types."""
    client = DummyRestClient(configuration={})
    headers = {"X-Test": 123, "X-None": None, "X-List": [1,2,3]}
    codeflash_output = client.HEAD(
        "http://example.com/weird",
        headers=headers
    ); resp = codeflash_output # 1.52μs -> 1.40μs (8.36% faster)

def test_head_query_params_with_special_characters():
    """Test HEAD with query_params containing special characters."""
    client = DummyRestClient(configuration={})
    query_params = {"q": "a+b&c=d", "emoji": "😀"}
    codeflash_output = client.HEAD(
        "http://example.com/special",
        query_params=query_params
    ); resp = codeflash_output # 1.48μs -> 1.42μs (4.30% faster)

def test_head_with_falsey_values():
    """Test HEAD with headers and query_params as falsey values."""
    client = DummyRestClient(configuration={})
    codeflash_output = client.HEAD(
        "http://example.com/falsey",
        headers=None,
        query_params=None,
        _preload_content=False,
        _request_timeout=0
    ); resp = codeflash_output # 1.56μs -> 1.52μs (2.70% faster)

def test_head_with_maximum_timeout():
    """Test HEAD with a very large _request_timeout value."""
    client = DummyRestClient(configuration={})
    codeflash_output = client.HEAD(
        "http://example.com/timeout",
        _request_timeout=999999
    ); resp = codeflash_output # 1.40μs -> 1.31μs (6.39% faster)

def test_head_with_unusual_url_types():
    """Test HEAD with non-string url types."""
    client = DummyRestClient(configuration={})
    # url as integer
    codeflash_output = client.HEAD(12345); resp = codeflash_output # 1.22μs -> 1.19μs (3.20% faster)
    # url as list
    codeflash_output = client.HEAD(["http://example.com"]); resp = codeflash_output # 849ns -> 807ns (5.20% faster)

# 3. Large Scale Test Cases

def test_head_large_headers_and_query_params():
    """Test HEAD with large headers and query_params dictionaries."""
    client = DummyRestClient(configuration={})
    large_headers = {f"Header-{i}": f"Value-{i}" for i in range(1000)}
    large_query_params = {f"param{i}": i for i in range(1000)}
    codeflash_output = client.HEAD(
        "http://example.com/large",
        headers=large_headers,
        query_params=large_query_params
    ); resp = codeflash_output # 1.69μs -> 1.61μs (4.85% faster)

def test_head_multiple_calls_consistency():
    """Test HEAD called multiple times with different parameters."""
    client = DummyRestClient(configuration={})
    for i in range(10):
        url = f"http://example.com/{i}"
        headers = {"X-Index": i}
        query_params = {"q": i}
        codeflash_output = client.HEAD(url, headers=headers, query_params=query_params); resp = codeflash_output # 6.93μs -> 6.41μs (8.24% faster)

def test_head_performance_large_scale():
    """Test HEAD with 1000 sequential calls to check performance and memory."""
    client = DummyRestClient(configuration={})
    for i in range(1000):
        url = f"http://example.com/{i}"
        codeflash_output = client.HEAD(url); resp = codeflash_output # 435μs -> 399μs (8.92% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
from abc import ABC, abstractmethod

# imports
import pytest
from pinecone.openapi_support.rest_utils import RestClientInterface


# --- UNIT TESTS ---
# We'll define a concrete subclass for testing purposes.
class DummyRestClient(RestClientInterface):
    """Dummy implementation of RestClientInterface for testing HEAD method."""
    def __init__(self, configuration=None, **kwargs):
        super().__init__(configuration, **kwargs)
        self.last_request = None

    def request(
        self,
        method,
        url,
        query_params=None,
        headers=None,
        body=None,
        post_params=None,
        _preload_content=True,
        _request_timeout=None,
    ):
        # Store the received arguments for assertion
        self.last_request = {
            "method": method,
            "url": url,
            "query_params": query_params,
            "headers": headers,
            "body": body,
            "post_params": post_params,
            "_preload_content": _preload_content,
            "_request_timeout": _request_timeout,
        }
        # Return the arguments for test validation
        return self.last_request

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

def test_head_basic_url_only():
    """Test HEAD with only URL argument."""
    client = DummyRestClient()
    codeflash_output = client.HEAD("http://example.com/resource"); result = codeflash_output # 1.18μs -> 1.38μs (14.6% slower)

def test_head_with_headers():
    """Test HEAD with custom headers."""
    client = DummyRestClient()
    headers = {"Authorization": "Bearer token", "Accept": "application/json"}
    codeflash_output = client.HEAD("http://example.com/api", headers=headers); result = codeflash_output # 1.46μs -> 1.50μs (3.19% slower)

def test_head_with_query_params():
    """Test HEAD with query parameters."""
    client = DummyRestClient()
    query_params = {"q": "test", "page": "2"}
    codeflash_output = client.HEAD("http://example.com/search", query_params=query_params); result = codeflash_output # 1.40μs -> 1.47μs (4.70% slower)

def test_head_with_all_arguments():
    """Test HEAD with all possible arguments."""
    client = DummyRestClient()
    codeflash_output = client.HEAD(
        "http://example.com/data",
        headers={"X-Test": "true"},
        query_params={"id": "123"},
        _preload_content=False,
        _request_timeout=10,
    ); result = codeflash_output # 1.58μs -> 1.53μs (2.94% faster)

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

def test_head_url_empty_string():
    """Test HEAD with empty URL string."""
    client = DummyRestClient()
    codeflash_output = client.HEAD(""); result = codeflash_output # 1.17μs -> 1.17μs (0.000% faster)

def test_head_headers_empty_dict():
    """Test HEAD with empty headers dict."""
    client = DummyRestClient()
    codeflash_output = client.HEAD("http://example.com", headers={}); result = codeflash_output # 1.37μs -> 1.40μs (1.93% slower)

def test_head_query_params_empty_dict():
    """Test HEAD with empty query_params dict."""
    client = DummyRestClient()
    codeflash_output = client.HEAD("http://example.com", query_params={}); result = codeflash_output # 1.42μs -> 1.45μs (2.41% slower)

def test_head_none_arguments():
    """Test HEAD with None for all optional arguments."""
    client = DummyRestClient()
    codeflash_output = client.HEAD("http://example.com", headers=None, query_params=None, _preload_content=None, _request_timeout=None); result = codeflash_output # 1.49μs -> 1.50μs (0.998% slower)

def test_head_special_characters_in_url():
    """Test HEAD with URL containing special characters."""
    client = DummyRestClient()
    url = "http://example.com/äöü?param=ß"
    codeflash_output = client.HEAD(url); result = codeflash_output # 1.17μs -> 1.18μs (0.761% slower)

def test_head_headers_with_unusual_values():
    """Test HEAD with headers containing unusual values."""
    client = DummyRestClient()
    headers = {"X-Strange": "\n\t\r", "X-Empty": ""}
    codeflash_output = client.HEAD("http://example.com", headers=headers); result = codeflash_output # 1.39μs -> 1.38μs (0.723% faster)

def test_head_query_params_with_special_values():
    """Test HEAD with query parameters containing special values."""
    client = DummyRestClient()
    query_params = {"emoji": "😀", "space": "a b", "unicode": "你好"}
    codeflash_output = client.HEAD("http://example.com", query_params=query_params); result = codeflash_output # 1.40μs -> 1.38μs (1.30% faster)

def test_head_with_false_preload_content():
    """Test HEAD with _preload_content set to False."""
    client = DummyRestClient()
    codeflash_output = client.HEAD("http://example.com", _preload_content=False); result = codeflash_output # 1.34μs -> 1.37μs (2.04% slower)

def test_head_with_zero_timeout():
    """Test HEAD with _request_timeout set to zero."""
    client = DummyRestClient()
    codeflash_output = client.HEAD("http://example.com", _request_timeout=0); result = codeflash_output # 1.30μs -> 1.35μs (4.00% slower)

def test_head_with_negative_timeout():
    """Test HEAD with _request_timeout set to negative value."""
    client = DummyRestClient()
    codeflash_output = client.HEAD("http://example.com", _request_timeout=-5); result = codeflash_output # 1.24μs -> 1.29μs (3.34% slower)

def test_head_with_large_integer_timeout():
    """Test HEAD with _request_timeout set to a large integer."""
    client = DummyRestClient()
    codeflash_output = client.HEAD("http://example.com", _request_timeout=999999); result = codeflash_output # 1.27μs -> 1.26μs (1.11% faster)

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

def test_head_large_headers():
    """Test HEAD with a large number of headers."""
    client = DummyRestClient()
    headers = {f"Header-{i}": str(i) for i in range(1000)}
    codeflash_output = client.HEAD("http://example.com", headers=headers); result = codeflash_output # 1.49μs -> 1.61μs (7.75% slower)

def test_head_large_query_params():
    """Test HEAD with a large number of query parameters."""
    client = DummyRestClient()
    query_params = {f"param{i}": str(i) for i in range(1000)}
    codeflash_output = client.HEAD("http://example.com", query_params=query_params); result = codeflash_output # 1.50μs -> 1.57μs (4.58% slower)

def test_head_long_url():
    """Test HEAD with a very long URL."""
    client = DummyRestClient()
    url = "http://example.com/" + "a" * 990  # total length ~1000
    codeflash_output = client.HEAD(url); result = codeflash_output # 1.21μs -> 1.22μs (1.15% slower)

def test_head_combination_large_headers_and_query_params():
    """Test HEAD with both large headers and query_params."""
    client = DummyRestClient()
    headers = {f"H{i}": str(i) for i in range(500)}
    query_params = {f"Q{i}": str(i) for i in range(500)}
    codeflash_output = client.HEAD("http://example.com", headers=headers, query_params=query_params); result = codeflash_output # 1.54μs -> 1.54μs (0.453% slower)

def test_head_maximum_arguments():
    """Test HEAD with maximum reasonable argument sizes."""
    client = DummyRestClient()
    headers = {f"Header-{i}": "x" * 10 for i in range(1000)}
    query_params = {f"param{i}": "y" * 10 for i in range(1000)}
    url = "http://example.com/" + "z" * 900
    codeflash_output = client.HEAD(url, headers=headers, query_params=query_params, _preload_content=False, _request_timeout=999); result = codeflash_output # 1.64μs -> 1.64μs (0.244% slower)

# ------------------------ FUNCTIONALITY AND MUTATION CHECKS ------------------------

def test_head_method_is_always_HEAD():
    """Test that HEAD always passes 'HEAD' as method, regardless of input."""
    client = DummyRestClient()
    # Try to sneak in a method via headers/query_params
    codeflash_output = client.HEAD("http://example.com", headers={"method": "POST"}); result = codeflash_output # 1.48μs -> 1.44μs (2.99% faster)

def test_head_does_not_pass_body_or_post_params():
    """Test that HEAD does not pass body or post_params to request."""
    client = DummyRestClient()
    codeflash_output = client.HEAD("http://example.com"); result = codeflash_output # 1.25μs -> 1.18μs (5.41% faster)

def test_head_argument_forwarding():
    """Test that all arguments are forwarded correctly to request."""
    client = DummyRestClient()
    url = "http://example.com/test"
    headers = {"A": "B"}
    query_params = {"C": "D"}
    preload = False
    timeout = 30
    codeflash_output = client.HEAD(url, headers=headers, query_params=query_params, _preload_content=preload, _request_timeout=timeout); result = codeflash_output # 1.55μs -> 1.52μs (2.24% 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-RestClientInterface.HEAD-mh9x0vso and push.