⚡️ Speed up method BaseHTTPClient.resolve_url by 30%

[codeflash-ai]

📄 30% (0.30x) speedup for BaseHTTPClient.resolve_url in chromadb/api/base_http_client.py

⏱️ Runtime : 18.7 milliseconds → 14.4 milliseconds (best of 44 runs)

📝 Explanation and details

The optimized code achieves a 29% speedup through two key optimizations:

1. Conditional URL parsing in _validate_host:

• Only calls urlparse() when the host contains a "/" character (indicating a potential URL)
• This eliminates expensive parsing for simple hostnames like "localhost" - the most common case
• Line profiler shows parsing time reduced from 95.7% to 73.4% of function time, with far fewer calls (128 vs 2666)

2. Streamlined path handling in resolve_url:

• Reorganizes path concatenation logic to avoid redundant string operations
• Uses conditional concatenation (if default_api_path and not path.endswith(default_api_path)) instead of always checking endswith()
• Separates the URL quoting operation into a conditional to avoid unnecessary work when path is empty

Performance characteristics by test case:

• Simple hostnames (most common): 20-40% faster due to avoided URL parsing
• Full URLs: 5-12% faster from streamlined path handling
• Large-scale operations: Up to 40% faster, showing the optimizations scale well
• Unicode/special characters: 12-26% faster from more efficient quoting logic

The optimizations are particularly effective for the common case of simple hostname resolution while maintaining equivalent functionality for complex URL scenarios.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

import logging
from typing import Any, Dict, Optional, TypeVar
from urllib.parse import quote, urlparse, urlunparse

# imports
import pytest
from chromadb.api.base_http_client import BaseHTTPClient

# unit tests

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

def test_basic_http_host_with_default_port_and_path():
    # Basic: Hostname only, default port, no path
    codeflash_output = BaseHTTPClient.resolve_url("localhost"); url = codeflash_output # 21.6μs -> 17.4μs (24.4% faster)

def test_basic_http_host_with_ssl_enabled():
    # Basic: Hostname only, SSL enabled
    codeflash_output = BaseHTTPClient.resolve_url("localhost", chroma_server_ssl_enabled=True); url = codeflash_output # 15.5μs -> 12.8μs (21.2% faster)

def test_basic_http_host_with_custom_port():
    # Basic: Hostname only, custom port
    codeflash_output = BaseHTTPClient.resolve_url("localhost", chroma_server_http_port=1234); url = codeflash_output # 15.3μs -> 12.3μs (24.5% faster)

def test_basic_http_host_with_default_api_path():
    # Basic: Hostname only, default path
    codeflash_output = BaseHTTPClient.resolve_url("localhost", default_api_path="/api/v1"); url = codeflash_output # 18.5μs -> 15.7μs (18.0% faster)

def test_basic_url_with_scheme_and_port():
    # Basic: Full URL with scheme and port, should not append default port
    codeflash_output = BaseHTTPClient.resolve_url("http://localhost:1234"); url = codeflash_output # 20.1μs -> 18.7μs (7.37% faster)

def test_basic_url_with_scheme_and_path():
    # Basic: Full URL with scheme and path, should preserve path
    codeflash_output = BaseHTTPClient.resolve_url("http://localhost:1234/foo"); url = codeflash_output # 22.8μs -> 21.1μs (7.63% faster)

def test_basic_url_with_scheme_and_path_and_default_api_path():
    # Basic: Full URL with scheme and path, should append default_api_path if not present
    codeflash_output = BaseHTTPClient.resolve_url("http://localhost:1234/foo", default_api_path="/api"); url = codeflash_output # 16.8μs -> 15.3μs (9.38% faster)

def test_basic_url_with_scheme_and_path_and_default_api_path_already_present():
    # Basic: Full URL with scheme and path, default_api_path already present in path
    codeflash_output = BaseHTTPClient.resolve_url("http://localhost:1234/foo/api", default_api_path="/api"); url = codeflash_output # 22.2μs -> 20.8μs (6.75% faster)

def test_basic_https_url_with_ssl_enabled():
    # Basic: Full https URL, SSL enabled, should preserve https
    codeflash_output = BaseHTTPClient.resolve_url("https://localhost:1234", chroma_server_ssl_enabled=True); url = codeflash_output # 18.9μs -> 17.4μs (8.62% faster)

def test_basic_https_url_with_ssl_disabled():
    # Basic: Full https URL, SSL disabled, should preserve https
    codeflash_output = BaseHTTPClient.resolve_url("https://localhost:1234", chroma_server_ssl_enabled=False); url = codeflash_output # 13.6μs -> 11.4μs (19.6% faster)

def test_basic_url_with_no_port_and_default_api_path():
    # Basic: Hostname only, default_api_path, should append port and path
    codeflash_output = BaseHTTPClient.resolve_url("localhost", default_api_path="/api"); url = codeflash_output # 18.1μs -> 15.2μs (19.0% faster)

def test_basic_url_with_trailing_slash_in_path():
    # Basic: Hostname only, default_api_path with trailing slash
    codeflash_output = BaseHTTPClient.resolve_url("localhost", default_api_path="/api/"); url = codeflash_output # 17.7μs -> 14.2μs (24.7% faster)

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

def test_edge_host_is_ip_address():
    # Edge: Host is an IP address
    codeflash_output = BaseHTTPClient.resolve_url("127.0.0.1"); url = codeflash_output # 16.5μs -> 13.6μs (22.1% faster)

def test_edge_host_is_fqdn():
    # Edge: Host is a fully qualified domain name
    codeflash_output = BaseHTTPClient.resolve_url("example.com"); url = codeflash_output # 16.8μs -> 13.5μs (24.1% faster)

def test_edge_host_with_path_but_no_scheme_raises():
    # Edge: Host contains a slash but no scheme
    with pytest.raises(ValueError):
        BaseHTTPClient.resolve_url("localhost/foo") # 9.08μs -> 8.85μs (2.62% faster)

def test_edge_host_with_unsupported_scheme_raises():
    # Edge: Host contains a slash and unsupported scheme
    with pytest.raises(ValueError):
        BaseHTTPClient.resolve_url("ftp://localhost/foo") # 12.9μs -> 12.8μs (0.468% faster)

def test_edge_url_with_double_slash_in_path():
    # Edge: Path contains double slashes, should be normalized
    codeflash_output = BaseHTTPClient.resolve_url("localhost", default_api_path="//api//v1"); url = codeflash_output # 19.4μs -> 16.1μs (20.7% faster)

def test_edge_default_api_path_is_empty():
    # Edge: default_api_path is empty string, path should be omitted
    codeflash_output = BaseHTTPClient.resolve_url("localhost", default_api_path=""); url = codeflash_output # 15.1μs -> 11.9μs (26.7% faster)

def test_edge_default_api_path_is_none():
    # Edge: default_api_path is None, should behave as empty
    codeflash_output = BaseHTTPClient.resolve_url("localhost", default_api_path=None); url = codeflash_output # 14.8μs -> 11.8μs (25.2% faster)

def test_edge_port_is_none():
    # Edge: chroma_server_http_port is None, should not append port if scheme present
    codeflash_output = BaseHTTPClient.resolve_url("http://localhost", chroma_server_http_port=None); url = codeflash_output # 20.2μs -> 18.4μs (9.64% faster)

def test_edge_path_is_netloc():
    # Edge: Path is same as netloc, should use default_api_path
    codeflash_output = BaseHTTPClient.resolve_url("localhost", default_api_path="/api", chroma_server_http_port=8000); url = codeflash_output # 18.4μs -> 15.3μs (20.1% faster)

def test_edge_path_already_contains_default_api_path():
    # Edge: Path already ends with default_api_path, should not append again
    codeflash_output = BaseHTTPClient.resolve_url("localhost", default_api_path="/api", chroma_server_http_port=8000); url = codeflash_output # 17.8μs -> 14.7μs (21.1% faster)

def test_edge_path_without_leading_slash():
    # Edge: default_api_path without leading slash
    codeflash_output = BaseHTTPClient.resolve_url("localhost", default_api_path="api"); url = codeflash_output # 17.4μs -> 14.5μs (19.7% faster)

def test_edge_path_with_special_characters():
    # Edge: Path with special characters should be quoted
    codeflash_output = BaseHTTPClient.resolve_url("localhost", default_api_path="/api/üñîçødë"); url = codeflash_output # 31.0μs -> 27.6μs (12.3% faster)

def test_edge_path_with_query_and_fragment_ignored():
    # Edge: If host contains query or fragment, these should be ignored
    codeflash_output = BaseHTTPClient.resolve_url("http://localhost:1234/foo?bar=baz#frag"); url = codeflash_output # 23.9μs -> 22.0μs (8.63% faster)


def test_edge_path_is_slash():
    # Edge: Path is just a slash, should not duplicate slashes with default_api_path
    codeflash_output = BaseHTTPClient.resolve_url("localhost", default_api_path="/api"); url = codeflash_output # 22.3μs -> 18.6μs (20.0% faster)

def test_edge_path_and_default_api_path_both_have_slash():
    # Edge: Both path and default_api_path have slashes, should not duplicate
    codeflash_output = BaseHTTPClient.resolve_url("http://localhost/", default_api_path="/api"); url = codeflash_output # 25.3μs -> 23.7μs (6.63% faster)

def test_edge_path_and_default_api_path_both_missing_slash():
    # Edge: Both path and default_api_path missing leading slash
    codeflash_output = BaseHTTPClient.resolve_url("localhost", default_api_path="api"); url = codeflash_output # 18.3μs -> 15.4μs (19.0% faster)

def test_edge_path_is_root_and_default_api_path_is_empty():
    # Edge: Path is '/', default_api_path is empty
    codeflash_output = BaseHTTPClient.resolve_url("localhost", default_api_path="", chroma_server_http_port=8000); url = codeflash_output # 15.4μs -> 12.0μs (27.6% faster)

def test_edge_path_is_root_and_default_api_path_is_slash():
    # Edge: Path is '/', default_api_path is '/'
    codeflash_output = BaseHTTPClient.resolve_url("localhost", default_api_path="/", chroma_server_http_port=8000); url = codeflash_output # 17.7μs -> 14.4μs (22.5% faster)

def test_edge_path_is_root_and_default_api_path_is_subpath():
    # Edge: Path is '/', default_api_path is '/api'
    codeflash_output = BaseHTTPClient.resolve_url("localhost", default_api_path="/api", chroma_server_http_port=8000); url = codeflash_output # 18.1μs -> 14.6μs (24.2% faster)

def test_edge_unicode_hostname():
    # Edge: Unicode hostname should be preserved
    codeflash_output = BaseHTTPClient.resolve_url("üñîçødë.local"); url = codeflash_output # 18.9μs -> 15.5μs (21.7% faster)

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

def test_large_scale_many_hosts():
    # Large Scale: Test 1000 hosts with default path
    for i in range(1000):
        host = f"host{i}"
        codeflash_output = BaseHTTPClient.resolve_url(host, default_api_path="/api"); url = codeflash_output # 7.07ms -> 5.49ms (28.8% faster)

def test_large_scale_long_path():
    # Large Scale: Very long default_api_path (1000 characters)
    long_path = "/" + "a" * 999
    codeflash_output = BaseHTTPClient.resolve_url("localhost", default_api_path=long_path); url = codeflash_output # 26.5μs -> 22.5μs (17.8% faster)

def test_large_scale_long_hostname():
    # Large Scale: Very long hostname (253 chars, max FQDN length)
    long_host = "a" * 63 + "." + "b" * 63 + "." + "c" * 63 + "." + "d" * 61
    codeflash_output = BaseHTTPClient.resolve_url(long_host); url = codeflash_output # 17.0μs -> 13.7μs (23.9% faster)

def test_large_scale_all_ports():
    # Large Scale: Test a range of ports
    for port in range(8000, 8100):
        codeflash_output = BaseHTTPClient.resolve_url("localhost", chroma_server_http_port=port); url = codeflash_output # 594μs -> 424μs (40.1% faster)

def test_large_scale_varied_schemes_and_paths():
    # Large Scale: Mix of schemes, hosts, and paths
    for i in range(100):
        scheme = "https" if i % 2 == 0 else "http"
        host = f"host{i}.example.com"
        path = f"/api/v{i}"
        codeflash_output = BaseHTTPClient.resolve_url(f"{scheme}://{host}", default_api_path=path); url = codeflash_output # 793μs -> 757μs (4.78% faster)

def test_large_scale_unicode_paths():
    # Large Scale: Many unicode paths
    for i in range(100):
        path = f"/api/üñîçødë{i}"
        codeflash_output = BaseHTTPClient.resolve_url("localhost", default_api_path=path); url = codeflash_output # 795μs -> 637μs (24.8% faster)
        # Path should be quoted
        quoted = quote(path.replace("//", "/"))
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
import logging
from typing import Any, Dict, Optional, TypeVar
from urllib.parse import quote, urlparse, urlunparse

# imports
import pytest
from chromadb.api.base_http_client import BaseHTTPClient

# unit tests

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

def test_basic_host_with_default_port_and_path():
    # Standard host, default port, no path
    codeflash_output = BaseHTTPClient.resolve_url("localhost"); url = codeflash_output # 15.4μs -> 12.1μs (27.1% faster)

def test_basic_host_with_ssl_enabled():
    # SSL enabled, default port
    codeflash_output = BaseHTTPClient.resolve_url("localhost", chroma_server_ssl_enabled=True); url = codeflash_output # 14.7μs -> 12.2μs (21.0% faster)

def test_basic_host_with_custom_port():
    # Custom port, no path
    codeflash_output = BaseHTTPClient.resolve_url("localhost", chroma_server_http_port=1234); url = codeflash_output # 14.6μs -> 11.8μs (23.9% faster)

def test_basic_host_with_default_api_path():
    # Host with default API path
    codeflash_output = BaseHTTPClient.resolve_url("localhost", default_api_path="/api/v1"); url = codeflash_output # 18.0μs -> 15.1μs (18.7% faster)

def test_basic_full_url_with_path():
    # Full URL passed, should not append port, should preserve path
    codeflash_output = BaseHTTPClient.resolve_url("http://localhost:9000/api/v2"); url = codeflash_output # 23.7μs -> 22.4μs (5.94% faster)

def test_basic_full_url_with_ssl_enabled():
    # Full URL, SSL enabled, should override scheme to https
    codeflash_output = BaseHTTPClient.resolve_url("http://localhost:9000/api/v2", chroma_server_ssl_enabled=True); url = codeflash_output # 16.6μs -> 14.7μs (12.7% faster)

def test_basic_full_url_with_no_path_and_default_api_path():
    # Full URL with no path, default_api_path provided
    codeflash_output = BaseHTTPClient.resolve_url("http://localhost:9000", default_api_path="/api/v1"); url = codeflash_output # 21.3μs -> 20.0μs (6.34% faster)

def test_basic_host_with_trailing_slash_in_default_api_path():
    # Host with default_api_path that has a trailing slash
    codeflash_output = BaseHTTPClient.resolve_url("localhost", default_api_path="/api/v1/"); url = codeflash_output # 18.1μs -> 15.0μs (20.8% faster)



def test_edge_host_with_scheme_but_no_netloc():
    # Host with scheme but no netloc (should treat as host)
    codeflash_output = BaseHTTPClient.resolve_url("http://", default_api_path="/api"); url = codeflash_output # 28.4μs -> 26.5μs (7.19% faster)

def test_edge_host_with_unusual_but_valid_hostname():
    # Host with unusual but valid hostname
    codeflash_output = BaseHTTPClient.resolve_url("my-server_123.domain.com"); url = codeflash_output # 18.3μs -> 14.2μs (28.6% faster)

def test_edge_host_with_ip_address():
    # Host is an IP address
    codeflash_output = BaseHTTPClient.resolve_url("192.168.1.1"); url = codeflash_output # 17.1μs -> 13.7μs (24.1% faster)

def test_edge_full_url_with_port_and_path_and_ssl():
    # Full URL with custom port and path, SSL enabled
    codeflash_output = BaseHTTPClient.resolve_url("http://example.com:1234/test", chroma_server_ssl_enabled=True); url = codeflash_output # 23.3μs -> 22.2μs (4.84% faster)

def test_edge_full_url_with_double_slash_in_path():
    # Full URL with double slash in path, should be normalized
    codeflash_output = BaseHTTPClient.resolve_url("http://localhost:9000//api/v1"); url = codeflash_output # 22.6μs -> 20.3μs (11.0% faster)





def test_edge_host_with_port_in_hostname():
    # Host includes port in hostname
    codeflash_output = BaseHTTPClient.resolve_url("localhost:1234"); url = codeflash_output # 26.8μs -> 22.2μs (20.4% faster)


def test_edge_host_with_slash_but_no_protocol_raises():
    # Host with slash but no protocol should raise ValueError
    with pytest.raises(ValueError):
        BaseHTTPClient.resolve_url("localhost/foo/bar") # 11.9μs -> 11.5μs (3.46% faster)

def test_edge_host_with_invalid_protocol_raises():
    # Host with invalid protocol should raise ValueError
    with pytest.raises(ValueError):
        BaseHTTPClient.resolve_url("ftp://localhost/foo") # 13.7μs -> 13.9μs (1.46% slower)



def test_edge_default_api_path_with_special_chars():
    # default_api_path contains special chars, should be percent-encoded
    codeflash_output = BaseHTTPClient.resolve_url("localhost", default_api_path="/api/ü"); url = codeflash_output # 25.0μs -> 21.5μs (16.3% faster)

def test_edge_default_api_path_is_none():
    # default_api_path is None, should treat as empty string
    codeflash_output = BaseHTTPClient.resolve_url("localhost", default_api_path=None); url = codeflash_output # 16.2μs -> 12.8μs (26.6% faster)

def test_edge_default_api_path_is_empty_string():
    # default_api_path is empty string
    codeflash_output = BaseHTTPClient.resolve_url("localhost", default_api_path=""); url = codeflash_output # 15.4μs -> 12.1μs (27.5% faster)

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

def test_large_scale_many_hosts():
    # Test many hosts to ensure scalability and performance
    for i in range(1000):
        host = f"host{i}"
        codeflash_output = BaseHTTPClient.resolve_url(host); url = codeflash_output # 6.34ms -> 4.61ms (37.4% faster)

def test_large_scale_long_path():
    # Test a very long path
    long_path = "/" + "/".join([f"segment{i}" for i in range(100)])
    codeflash_output = BaseHTTPClient.resolve_url("localhost", default_api_path=long_path); url = codeflash_output # 26.8μs -> 23.8μs (13.0% faster)

def test_large_scale_long_hostname():
    # Test a very long hostname (max 253 chars per RFC)
    long_hostname = "a" * 63 + "." + "b" * 63 + "." + "c" * 63 + ".com"
    codeflash_output = BaseHTTPClient.resolve_url(long_hostname); url = codeflash_output # 17.0μs -> 12.8μs (33.2% faster)

def test_large_scale_full_url_with_long_path_and_ssl():
    # Full URL with long path and SSL
    long_path = "/" + "/".join([f"p{i}" for i in range(200)])
    codeflash_output = BaseHTTPClient.resolve_url(f"http://localhost:9000{long_path}", chroma_server_ssl_enabled=True); url = codeflash_output # 29.8μs -> 29.0μs (2.55% faster)

def test_large_scale_many_different_ports():
    # Test a wide range of ports
    for port in range(8000, 8100):
        codeflash_output = BaseHTTPClient.resolve_url("localhost", chroma_server_http_port=port); url = codeflash_output # 591μs -> 422μs (40.1% faster)

def test_large_scale_unicode_in_many_paths():
    # Test many unicode paths for correct encoding
    for i in range(100):
        path = f"/api/ü{i}"
        codeflash_output = BaseHTTPClient.resolve_url("localhost", default_api_path=path); url = codeflash_output # 748μs -> 593μs (26.1% faster)
        # "/api/ü0" -> "/api/%C3%BC0"
        expected_path = f"/api/%C3%BC{i}"

def test_large_scale_mixed_hosts_and_paths():
    # Test various combinations of hosts and paths
    for i in range(100):
        host = f"host{i}.domain.com"
        path = f"/api/v{i}"
        codeflash_output = BaseHTTPClient.resolve_url(host, default_api_path=path, chroma_server_http_port=8080+i); url = codeflash_output # 742μs -> 581μs (27.5% 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-BaseHTTPClient.resolve_url-mh9h87ik and push.