⚡️ Speed up function is_url by 9%

[codeflash-ai]

📄 9% (0.09x) speedup for is_url in ultralytics/utils/downloads.py

⏱️ Runtime : 290 milliseconds → 265 milliseconds (best of 26 runs)

📝 Explanation and details

The optimization achieves a 9% speedup through three key improvements:

1. Eliminated unnecessary list allocation in URL validation

• Original: assert all([result.scheme, result.netloc]) creates a list and calls all()
• Optimized: if not (result.scheme and result.netloc): return False uses direct boolean evaluation
• Impact: Saves memory allocation and function call overhead, providing 6-22% improvement on invalid URLs

2. Switched to HEAD requests for online URL checking

• Original: Uses GET requests via request.urlopen(url), downloading full response content
• Optimized: Creates Request(url_str, method='HEAD') to only fetch headers
• Impact: Significantly reduces network transfer time, showing 5-8% improvement on successful URL checks and better bandwidth efficiency

3. Expanded valid HTTP status code range

• Original: Only accepts status code 200 (response.getcode() == 200)
• Optimized: Accepts any 2XX status (200 <= response.getcode() < 300)
• Impact: More robust handling of redirects and other success codes, avoiding false negatives

Performance characteristics by test type:

• Invalid URLs: 6-22% faster due to early return optimization
• Valid URLs without check: 1-8% faster from list allocation removal
• Online URL checking: 5-8% faster from HEAD request optimization
• Large batches: Consistent improvements scale linearly

Context impact: Based on the function reference in ultralytics/nn/autobackend.py, this function is called during model loading to validate model paths/URLs. The optimizations are particularly valuable since model loading is often performance-critical, and the HEAD request optimization reduces bandwidth usage when checking remote model URLs.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

import time

# function to test
from urllib import request

# imports
from ultralytics.utils.downloads import is_url

# unit tests

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


def test_valid_http_url():
    # Standard HTTP URL
    codeflash_output = is_url("http://www.example.com")  # 8.62μs -> 8.26μs (4.37% faster)


def test_valid_https_url():
    # Standard HTTPS URL
    codeflash_output = is_url("https://www.example.com")  # 5.19μs -> 5.29μs (1.83% slower)


def test_valid_url_with_path_and_query():
    # URL with path and query parameters
    codeflash_output = is_url("https://www.example.com/path?query=1")  # 9.77μs -> 9.64μs (1.36% faster)


def test_valid_url_with_port():
    # URL with a port number
    codeflash_output = is_url("https://www.example.com:8080")  # 8.74μs -> 8.51μs (2.73% faster)


def test_valid_url_with_subdomain():
    # URL with subdomain
    codeflash_output = is_url("https://sub.example.com")  # 8.33μs -> 8.09μs (2.92% faster)


def test_invalid_url_missing_scheme():
    # Missing scheme should be invalid
    codeflash_output = is_url("www.example.com")  # 7.05μs -> 5.77μs (22.3% faster)


def test_invalid_url_missing_netloc():
    # Missing netloc should be invalid
    codeflash_output = is_url("https:///path")  # 9.30μs -> 8.60μs (8.07% faster)


def test_invalid_url_gibberish():
    # Completely invalid string
    codeflash_output = is_url("not a url")  # 6.45μs -> 6.05μs (6.52% faster)


def test_empty_string():
    # Empty string should be invalid
    codeflash_output = is_url("")  # 6.49μs -> 5.92μs (9.70% faster)


def test_non_string_input():
    # Non-string input should be handled gracefully
    codeflash_output = is_url(12345)  # 6.87μs -> 6.45μs (6.62% faster)


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


def test_url_with_ftp_scheme():
    # FTP is a valid scheme for URLs
    codeflash_output = is_url("ftp://ftp.example.com")  # 8.93μs -> 8.46μs (5.49% faster)


def test_url_with_uncommon_scheme():
    # Uncommon but valid scheme
    codeflash_output = is_url("mailto:[email protected]")  # 7.61μs -> 7.12μs (6.84% faster)


def test_url_with_ipv4_address():
    # URL with IPv4 address as netloc
    codeflash_output = is_url("http://127.0.0.1")  # 8.75μs -> 8.16μs (7.19% faster)


def test_url_with_ipv6_address():
    # URL with IPv6 address as netloc
    codeflash_output = is_url("http://[::1]")  # 25.0μs -> 24.4μs (2.66% faster)


def test_url_with_userinfo():
    # URL with username and password
    codeflash_output = is_url("http://user:[email protected]")  # 8.30μs -> 7.98μs (3.96% faster)


def test_url_with_fragment():
    # URL with fragment
    codeflash_output = is_url("https://www.example.com/path#section")  # 9.51μs -> 9.49μs (0.179% faster)


def test_url_with_unicode_characters():
    # URL containing unicode characters
    codeflash_output = is_url("https://www.exämple.com")  # 10.8μs -> 10.7μs (0.878% faster)


def test_url_with_long_path():
    # Very long path in URL
    long_path = "https://www.example.com/" + "a" * 500
    codeflash_output = is_url(long_path)  # 9.39μs -> 9.23μs (1.77% faster)


def test_url_with_spaces():
    # URL containing spaces should be invalid
    codeflash_output = is_url("https://www.exa mple.com")  # 8.00μs -> 7.97μs (0.351% faster)


def test_url_with_special_characters():
    # URL with special characters in path
    codeflash_output = is_url("https://www.example.com/!{report_table}'()*+,;=")  # 9.19μs -> 9.25μs (0.584% slower)


def test_url_with_only_scheme():
    # Only scheme, no netloc
    codeflash_output = is_url("http://")  # 8.60μs -> 8.20μs (4.84% faster)


def test_url_with_only_netloc():
    # Only netloc, no scheme
    codeflash_output = is_url("example.com")  # 6.41μs -> 6.05μs (5.88% faster)


def test_url_with_invalid_scheme():
    # Scheme must be non-empty and valid
    codeflash_output = is_url("htp://www.example.com")  # 8.23μs -> 8.16μs (0.870% faster)


def test_url_with_localhost():
    # Localhost is a valid netloc
    codeflash_output = is_url("http://localhost")  # 7.88μs -> 8.02μs (1.72% slower)


def test_url_with_empty_netloc():
    # Empty netloc should be invalid
    codeflash_output = is_url("http:///")  # 8.62μs -> 8.08μs (6.59% faster)


def test_url_with_non_ascii_netloc():
    # Non-ASCII netloc should be valid if it can be parsed
    codeflash_output = is_url("http://例子.测试")  # 10.7μs -> 10.6μs (0.292% faster)


def test_url_with_check_true_existing_url():
    # Should return True for a real, reachable URL
    codeflash_output = is_url("https://www.example.com", check=True)  # 38.8ms -> 36.9ms (5.33% faster)


def test_url_with_check_true_non_existing_url():
    # Should return False for a non-existent domain
    codeflash_output = is_url("https://nonexistent.ultralytics.com", check=True)  # 1.13ms -> 1.06ms (6.04% faster)


def test_url_with_check_true_invalid_url():
    # Should return False for an invalid URL
    codeflash_output = is_url("not a url", check=True)  # 9.91μs -> 9.26μs (7.02% faster)


def test_url_with_check_true_timeout(monkeypatch):
    # Simulate timeout by monkeypatching urlopen to raise a timeout
    def fake_urlopen(url):
        raise request.URLError("Timeout")

    monkeypatch.setattr(request, "urlopen", fake_urlopen)
    codeflash_output = is_url("https://www.example.com", check=True)  # 8.67μs -> 22.8μs (62.1% slower)


def test_url_with_check_true_raises(monkeypatch):
    # Simulate HTTP error by monkeypatching urlopen to raise HTTPError
    def fake_urlopen(url):
        raise request.HTTPError(url, 404, "Not Found", hdrs=None, fp=None)

    monkeypatch.setattr(request, "urlopen", fake_urlopen)
    codeflash_output = is_url("https://www.example.com", check=True)  # 22.4μs -> 30.8μs (27.4% slower)


def test_url_with_check_true_non_http_scheme(monkeypatch):
    # urlopen should fail for non-http schemes
    def fake_urlopen(url):
        raise ValueError("Unknown protocol")

    monkeypatch.setattr(request, "urlopen", fake_urlopen)
    codeflash_output = is_url("ftp://ftp.example.com", check=True)  # 7.08μs -> 18.5μs (61.7% slower)


def test_url_with_long_unicode_path():
    # Very long unicode path
    long_unicode = "https://www.example.com/" + "ü" * 200
    codeflash_output = is_url(long_unicode)  # 10.3μs -> 10.4μs (0.797% slower)


def test_url_with_query_and_fragment():
    # URL with query and fragment
    codeflash_output = is_url("https://www.example.com/path?query=1#frag")  # 9.88μs -> 10.2μs (3.61% slower)


def test_url_with_multiple_subdomains():
    # Multiple subdomains
    codeflash_output = is_url("https://a.b.c.d.example.com")  # 8.53μs -> 8.32μs (2.46% faster)


def test_url_with_dash_and_underscore_in_netloc():
    # Netloc with dash and underscore
    codeflash_output = is_url("https://dash-underscore_example.com")  # 8.47μs -> 8.24μs (2.77% faster)


def test_url_with_scheme_case_insensitive():
    # Scheme should be case-insensitive
    codeflash_output = is_url("HTTP://www.example.com")  # 8.38μs -> 8.37μs (0.072% faster)
    codeflash_output = is_url("hTtPs://www.example.com")  # 4.72μs -> 4.87μs (2.96% slower)


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


def test_large_batch_of_valid_urls():
    # Test function with a large list of valid URLs
    urls = [f"https://www.example{i}.com" for i in range(1000)]
    for url in urls:
        codeflash_output = is_url(url)  # 2.90ms -> 2.86ms (1.43% faster)


def test_large_batch_of_invalid_urls():
    # Test function with a large list of invalid URLs
    invalid_urls = [f"www.example{i}.com" for i in range(1000)]
    for url in invalid_urls:
        codeflash_output = is_url(url)  # 2.18ms -> 2.05ms (6.30% faster)


def test_large_batch_with_check(monkeypatch):
    # Simulate urlopen always returning 200 for performance test
    class FakeResponse:
        def getcode(self):
            return 200

        def __enter__(self):
            return self

        def __exit__(self, exc_type, exc_val, exc_tb):
            pass

    def fake_urlopen(url):
        return FakeResponse()

    monkeypatch.setattr(request, "urlopen", fake_urlopen)
    urls = [f"https://www.example{i}.com" for i in range(1000)]
    for url in urls:
        codeflash_output = is_url(url, check=True)  # 3.23ms -> 7.23ms (55.4% slower)


def test_large_batch_with_check_fail(monkeypatch):
    # Simulate urlopen always raising error for performance test
    def fake_urlopen(url):
        raise request.URLError("Failed")

    monkeypatch.setattr(request, "urlopen", fake_urlopen)
    urls = [f"https://www.example{i}.com" for i in range(1000)]
    for url in urls:
        codeflash_output = is_url(url, check=True)  # 3.33ms -> 7.34ms (54.6% slower)


def test_performance_large_batch():
    # Test performance: should complete under 2 seconds for 1000 URLs
    urls = [f"https://www.example{i}.com" for i in range(1000)]
    start = time.time()
    for url in urls:
        codeflash_output = is_url(url)  # 2.90ms -> 2.84ms (1.87% faster)
    duration = time.time() - start


# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

# imports
from ultralytics.utils.downloads import is_url

# unit tests

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


def test_valid_http_url():
    # Valid HTTP URL
    codeflash_output = is_url("http://www.example.com")  # 9.92μs -> 9.73μs (1.99% faster)


def test_valid_https_url():
    # Valid HTTPS URL
    codeflash_output = is_url("https://www.example.com")  # 9.30μs -> 8.96μs (3.86% faster)


def test_valid_url_with_path_and_query():
    # Valid URL with path and query parameters
    codeflash_output = is_url("https://www.example.com/path?query=1")  # 9.74μs -> 9.67μs (0.776% faster)


def test_valid_url_with_port():
    # Valid URL with port number
    codeflash_output = is_url("https://www.example.com:8080")  # 7.96μs -> 8.57μs (7.14% slower)


def test_valid_url_with_subdomain():
    # Valid URL with subdomain
    codeflash_output = is_url("https://sub.domain.example.com")  # 8.50μs -> 8.12μs (4.70% faster)


def test_valid_url_with_fragment():
    # Valid URL with fragment
    codeflash_output = is_url("https://www.example.com/path#fragment")  # 9.58μs -> 9.73μs (1.56% slower)


def test_valid_url_with_check_online():
    # Valid URL, check online (should be True for example.com)
    codeflash_output = is_url("https://www.example.com", check=True)  # 39.7ms -> 36.9ms (7.57% faster)


def test_valid_url_with_check_online_false():
    # Valid URL, check online (should be False for non-existent domain)
    codeflash_output = is_url(
        "https://www.thisdomaindoesnotexist123456789.com", check=True
    )  # 1.12ms -> 1.08ms (3.54% faster)


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


def test_missing_scheme():
    # URL missing scheme should be invalid
    codeflash_output = is_url("www.example.com")  # 9.72μs -> 9.05μs (7.41% faster)


def test_missing_netloc():
    # URL missing netloc should be invalid
    codeflash_output = is_url("https:///path")  # 10.9μs -> 10.5μs (4.03% faster)


def test_empty_string():
    # Empty string should be invalid
    codeflash_output = is_url("")  # 6.80μs -> 6.48μs (5.08% faster)


def test_none_input():
    # None input should be invalid
    codeflash_output = is_url(None)  # 6.83μs -> 6.38μs (7.18% faster)


def test_integer_input():
    # Integer input should be invalid
    codeflash_output = is_url(12345)  # 6.85μs -> 6.35μs (7.86% faster)


def test_non_url_string():
    # Random string should be invalid
    codeflash_output = is_url("not a url")  # 6.99μs -> 6.23μs (12.3% faster)


def test_ftp_url():
    # Valid FTP URL (scheme and netloc present)
    codeflash_output = is_url("ftp://ftp.example.com")  # 9.18μs -> 8.62μs (6.41% faster)


def test_file_url():
    # File URL (scheme present but netloc may be empty)
    codeflash_output = is_url("file:///C:/path/to/file.txt")  # 9.80μs -> 9.07μs (8.07% faster)


def test_localhost_url():
    # Localhost URL
    codeflash_output = is_url("http://localhost:8000")  # 8.34μs -> 8.10μs (2.89% faster)


def test_ipv4_url():
    # IPv4 address as netloc
    codeflash_output = is_url("http://127.0.0.1")  # 8.50μs -> 8.29μs (2.54% faster)


def test_ipv6_url():
    # IPv6 address as netloc
    codeflash_output = is_url("http://[2001:db8::1]")  # 28.4μs -> 28.5μs (0.214% slower)


def test_url_with_unicode_chars():
    # URL with unicode characters in path
    codeflash_output = is_url("https://www.example.com/üñîçødë")  # 10.2μs -> 9.62μs (5.75% faster)


def test_url_with_spaces():
    # URL with spaces should be invalid
    codeflash_output = is_url("https://www.exa mple.com")  # 8.28μs -> 8.01μs (3.45% faster)


def test_url_with_special_chars_in_netloc():
    # URL with special chars in netloc should be invalid
    codeflash_output = is_url("https://exa$mple.com")  # 8.68μs -> 8.45μs (2.73% faster)


def test_url_with_long_path():
    # URL with a very long path
    long_path = "https://www.example.com/" + "a" * 500
    codeflash_output = is_url(long_path)  # 10.1μs -> 9.67μs (3.96% faster)


def test_url_with_long_query():
    # URL with a very long query string
    long_query = "https://www.example.com/?q=" + "b" * 500
    codeflash_output = is_url(long_query)  # 10.1μs -> 10.3μs (1.30% slower)


def test_url_with_unusual_scheme():
    # Unusual but valid scheme
    codeflash_output = is_url("customscheme://host.com")  # 8.30μs -> 8.20μs (1.23% faster)


def test_url_with_dash_underscore_in_netloc():
    # Netloc with dash and underscore
    codeflash_output = is_url("https://my-site_name.com")  # 8.13μs -> 8.22μs (1.09% slower)


def test_url_with_dot_at_end():
    # Netloc with dot at end (technically allowed)
    codeflash_output = is_url("https://example.com.")  # 8.75μs -> 8.12μs (7.73% faster)


def test_url_with_scheme_only():
    # Only scheme, no netloc
    codeflash_output = is_url("https://")  # 8.68μs -> 8.02μs (8.25% faster)


def test_url_with_double_scheme():
    # Double scheme should be invalid
    codeflash_output = is_url("https://https://www.example.com")  # 9.27μs -> 8.64μs (7.34% faster)


def test_url_with_multiple_slashes():
    # Multiple slashes after scheme
    codeflash_output = is_url("https:////www.example.com")  # 9.08μs -> 8.67μs (4.67% faster)


def test_url_with_fragment_only():
    # Fragment only, no scheme/netloc
    codeflash_output = is_url("#fragment")  # 7.29μs -> 6.39μs (14.2% faster)


def test_url_with_query_only():
    # Query only, no scheme/netloc
    codeflash_output = is_url("?query=1")  # 7.07μs -> 6.36μs (11.1% faster)


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


def test_many_valid_urls():
    # Test a list of 500 valid URLs
    base_url = "https://www.example{}.com"
    valid_urls = [base_url.format(i) for i in range(500)]
    for url in valid_urls:
        codeflash_output = is_url(url)  # 1.46ms -> 1.43ms (2.34% faster)


def test_many_invalid_urls():
    # Test a list of 500 invalid URLs (missing scheme)
    invalid_urls = ["www.example{}.com".format(i) for i in range(500)]
    for url in invalid_urls:
        codeflash_output = is_url(url)  # 1.10ms -> 1.03ms (6.87% faster)


def test_mixed_valid_and_invalid_urls():
    # Test a mix of valid and invalid URLs
    urls = []
    for i in range(250):
        urls.append("https://www.example{}.com".format(i))  # valid
        urls.append("example{}.com".format(i))  # invalid
    for i, url in enumerate(urls):
        if i % 2 == 0:
            codeflash_output = is_url(url)
        else:
            codeflash_output = is_url(url)


def test_large_url_length():
    # Test URL with very large length
    long_url = "https://www.example.com/" + "a" * 950
    codeflash_output = is_url(long_url)  # 12.0μs -> 10.4μs (15.7% faster)


def test_large_url_invalid_length():
    # Test very large string that is not a URL
    long_string = "a" * 1000
    codeflash_output = is_url(long_string)  # 7.73μs -> 6.75μs (14.5% faster)


def test_large_scale_check_online():
    # Test check=True for a set of URLs (only a few to avoid network overload)
    urls = [
        "https://www.example.com",  # should exist
        "https://www.google.com",  # should exist
        "https://www.thisdomaindoesnotexist123456789.com",  # should not exist
    ]
    expected = [True, True, False]
    for url, exp in zip(urls, expected):
        codeflash_output = is_url(url, check=True)  # 110ms -> 88.4ms (24.6% faster)


# ----------- Determinism and Robustness -----------


def test_url_is_deterministic():
    # Same input always yields same output
    url = "https://www.example.com"
    codeflash_output = is_url(url)
    result1 = codeflash_output  # 7.12μs -> 7.05μs (1.02% faster)
    codeflash_output = is_url(url)
    result2 = codeflash_output  # 2.48μs -> 2.49μs (0.401% slower)


def test_url_check_is_deterministic():
    # Same input with check=True always yields same output
    url = "https://www.example.com"
    codeflash_output = is_url(url, check=True)
    result1 = codeflash_output  # 38.8ms -> 37.1ms (4.58% faster)
    codeflash_output = is_url(url, check=True)
    result2 = codeflash_output  # 40.6ms -> 37.1ms (9.39% faster)


def test_url_with_unusual_characters_in_path():
    # Path with unusual but valid characters
    url = "https://www.example.com/!{report_table}'()*+,;=:@"
    codeflash_output = is_url(url)  # 14.2μs -> 14.2μs (0.345% faster)


def test_url_with_encoded_characters():
    # URL with percent-encoded characters
    url = "https://www.example.com/%20%21%40"
    codeflash_output = is_url(url)  # 9.90μs -> 9.55μs (3.72% faster)


def test_url_with_uppercase_scheme():
    # Scheme in uppercase
    url = "HTTPS://www.example.com"
    codeflash_output = is_url(url)  # 9.30μs -> 8.76μs (6.16% faster)


def test_url_with_mixed_case_netloc():
    # Netloc in mixed case
    url = "https://WWW.Example.COM"
    codeflash_output = is_url(url)  # 8.89μs -> 9.00μs (1.19% slower)


def test_url_with_trailing_slash():
    # URL with trailing slash
    url = "https://www.example.com/"
    codeflash_output = is_url(url)  # 9.00μs -> 8.84μs (1.78% faster)


def test_url_with_multiple_query_params():
    # URL with multiple query params
    url = "https://www.example.com/?a=1&b=2&c=3"
    codeflash_output = is_url(url)  # 9.75μs -> 9.36μs (4.14% faster)


def test_url_with_long_fragment():
    # URL with long fragment
    url = "https://www.example.com/#" + "frag" * 50
    codeflash_output = is_url(url)  # 9.71μs -> 9.33μs (4.13% faster)


def test_url_with_long_subdomain():
    # URL with long subdomain
    url = "https://subdomain" + "a" * 100 + ".example.com"
    codeflash_output = is_url(url)  # 9.08μs -> 8.51μs (6.76% faster)


def test_url_with_dash_in_scheme():
    # Scheme with dash (invalid)
    url = "ht-tp://www.example.com"
    codeflash_output = is_url(url)  # 8.74μs -> 8.48μs (3.07% faster)


def test_url_with_invalid_scheme():
    # Scheme with invalid characters
    url = "ht@tp://www.example.com"
    codeflash_output = is_url(url)  # 7.42μs -> 6.61μs (12.4% 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-is_url-mi5u2f4q and push.