⚡️ Speed up function is_remote_url by 103%

[codeflash-ai]

📄 103% (1.03x) speedup for is_remote_url in python/sglang/srt/utils/common.py

⏱️ Runtime : 2.87 milliseconds → 1.42 milliseconds (best of 44 runs)

📝 Explanation and details

The optimization precompiles the regex pattern as a module-level constant _REMOTE_URL_PATTERN instead of recreating it on every function call. This eliminates the expensive regex compilation overhead that was consuming 66.7% of the original function's runtime.

Key changes:

• Moved regex pattern compilation outside the function to module initialization
• Simplified the pattern from r"(.+)://(.*)" to r".+://.*" since capture groups aren't used
• Replaced re.match() with the precompiled pattern's .match() method

Why this is faster:
In Python, re.match() compiles the pattern every time it's called. The line profiler shows this compilation step took 6.59ms out of 9.87ms total runtime (66.7%). By precompiling, we eliminate this per-call overhead, reducing total function time from 9.87ms to 3.38ms - a 102% speedup.

Impact on workloads:
The function references show is_remote_url() is called during model loading and server argument handling - critical initialization paths where this optimization provides meaningful speedup. The annotated tests demonstrate consistent 70-300% performance improvements across all URL types, with the largest gains on complex URLs and batch processing scenarios.

Test case performance:

• Simple URLs: 70-100% faster
• Complex/long URLs: 200-300% faster
• Batch processing: 120-130% faster
• Path objects: Minimal impact (expected, as they short-circuit before regex)

This optimization is particularly valuable for applications that validate many URLs during startup or configuration parsing.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

from pathlib import Path

# imports
import pytest  # used for our unit tests
from sglang.srt.utils.common import is_remote_url

# unit tests

# 1. Basic Test Cases

def test_basic_http_url():
    # Typical HTTP URL
    codeflash_output = is_remote_url("http://localhost:8000/model") # 3.67μs -> 2.10μs (74.6% faster)

def test_basic_https_url():
    # Typical HTTPS URL
    codeflash_output = is_remote_url("https://example.com") # 2.67μs -> 1.38μs (92.7% faster)

def test_basic_custom_connector():
    # Custom connector type
    codeflash_output = is_remote_url("myconnector://host:1234/model") # 2.69μs -> 1.45μs (85.9% faster)

def test_basic_ftp_url():
    # FTP URL
    codeflash_output = is_remote_url("ftp://ftp.example.com/resource") # 2.46μs -> 1.38μs (78.8% faster)

def test_basic_ws_url():
    # WebSocket URL
    codeflash_output = is_remote_url("ws://host:9000/path") # 2.41μs -> 1.32μs (83.3% faster)

def test_basic_path_object():
    # Path object should always return False
    codeflash_output = is_remote_url(Path("/some/local/path")) # 370ns -> 374ns (1.07% slower)

def test_basic_local_path_string():
    # Local path as string should return False
    codeflash_output = is_remote_url("/usr/local/model") # 2.49μs -> 1.23μs (102% faster)

def test_basic_relative_path_string():
    # Relative path as string should return False
    codeflash_output = is_remote_url("models/model1") # 2.28μs -> 1.12μs (104% faster)

def test_basic_windows_path_string():
    # Windows-style path as string should return False
    codeflash_output = is_remote_url("C:\\models\\model1") # 2.17μs -> 1.13μs (92.9% faster)

def test_basic_file_url():
    # file:// URLs are technically remote by pattern
    codeflash_output = is_remote_url("file://localhost/path/to/file") # 2.51μs -> 1.24μs (102% faster)

# 2. Edge Test Cases

def test_edge_empty_string():
    # Empty string should not match
    codeflash_output = is_remote_url("") # 1.79μs -> 812ns (121% faster)

def test_edge_only_scheme():
    # Only scheme and slashes, no host
    codeflash_output = is_remote_url("http://") # 2.46μs -> 1.26μs (94.1% faster)

def test_edge_missing_scheme():
    # Missing scheme, just slashes
    codeflash_output = is_remote_url("//host:1234/model") # 2.31μs -> 1.17μs (97.3% faster)

def test_edge_colon_in_path():
    # Colon in path, not a scheme
    codeflash_output = is_remote_url("/foo:bar/baz") # 2.15μs -> 975ns (121% faster)

def test_edge_scheme_with_plus():
    # Scheme with plus sign (valid in URLs)
    codeflash_output = is_remote_url("grpc+http://host:1234/model") # 2.52μs -> 1.31μs (92.3% faster)

def test_edge_scheme_with_numbers():
    # Scheme with numbers
    codeflash_output = is_remote_url("s3v2://bucket/key") # 2.25μs -> 1.16μs (94.6% faster)

def test_edge_scheme_with_dash():
    # Scheme with dash
    codeflash_output = is_remote_url("foo-bar://host/path") # 2.39μs -> 1.21μs (97.5% faster)

def test_edge_scheme_with_underscore():
    # Scheme with underscore (technically allowed)
    codeflash_output = is_remote_url("foo_bar://host/path") # 2.35μs -> 1.23μs (91.3% faster)

def test_edge_no_slashes():
    # No slashes after colon
    codeflash_output = is_remote_url("http:host/path") # 2.15μs -> 1.10μs (95.8% faster)

def test_edge_weird_but_valid_url():
    # Unusual but valid URL
    codeflash_output = is_remote_url("a1+foo-bar_2://host") # 2.24μs -> 1.18μs (89.7% faster)

def test_edge_path_object_with_url_string():
    # Path object containing a URL-like string should return False
    codeflash_output = is_remote_url(Path("http://host:1234/model")) # 403ns -> 363ns (11.0% faster)

def test_edge_url_with_spaces():
    # URL with spaces (still matches the pattern)
    codeflash_output = is_remote_url("http://host:1234/with space") # 3.61μs -> 2.08μs (73.1% faster)

def test_edge_url_with_unicode():
    # Unicode in URL
    codeflash_output = is_remote_url("http://höst:1234/model") # 2.88μs -> 1.63μs (77.2% faster)

def test_edge_url_with_query():
    # URL with query string
    codeflash_output = is_remote_url("http://host:1234/model?param=value") # 2.73μs -> 1.40μs (95.9% faster)

def test_edge_url_with_fragment():
    # URL with fragment
    codeflash_output = is_remote_url("http://host:1234/model#section") # 2.66μs -> 1.39μs (91.6% faster)

def test_edge_url_with_multiple_colons():
    # URL with multiple colons in path
    codeflash_output = is_remote_url("foo://host:1234/path:with:colons") # 2.70μs -> 1.46μs (85.3% faster)

def test_edge_url_with_no_host():
    # Scheme but no host
    codeflash_output = is_remote_url("foo://") # 2.32μs -> 1.27μs (83.1% faster)

def test_edge_url_with_weird_scheme():
    # Scheme with special chars
    codeflash_output = is_remote_url("!@#://host") # 2.41μs -> 1.12μs (114% faster)

# 3. Large Scale Test Cases

def test_large_scale_many_urls():
    # Test a large list of valid and invalid URLs
    valid_prefixes = ["http", "https", "ftp", "ws", "grpc", "custom", "foo-bar", "s3v2"]
    invalid_prefixes = ["", " ", "/", ":", "model", "file", "C", "usr"]
    valid_urls = [f"{prefix}://host{i}:1234/model{i}" for i, prefix in enumerate(valid_prefixes*100)]
    invalid_urls = [f"{prefix}/host{i}/model{i}" for i, prefix in enumerate(invalid_prefixes*100)]

    # All valid URLs should return True
    for url in valid_urls:
        codeflash_output = is_remote_url(url) # 662μs -> 294μs (125% faster)

    # All invalid URLs should return False
    for url in invalid_urls:
        codeflash_output = is_remote_url(url) # 568μs -> 242μs (134% faster)

def test_large_scale_path_objects():
    # Test a large number of Path objects (should all return False)
    paths = [Path(f"/some/path/model{i}") for i in range(1000)]
    for p in paths:
        codeflash_output = is_remote_url(p) # 148μs -> 143μs (3.87% faster)

from pathlib import Path

# imports
import pytest  # used for our unit tests
from sglang.srt.utils.common import is_remote_url

# unit tests

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

def test_basic_valid_remote_url():
    # Standard remote URL
    codeflash_output = is_remote_url("grpc://localhost:1234/model") # 3.53μs -> 1.96μs (79.7% faster)
    # Remote URL with different connector type
    codeflash_output = is_remote_url("http://example.com:8080/model") # 1.30μs -> 673ns (93.9% faster)
    # Remote URL with connector type and no port
    codeflash_output = is_remote_url("https://host/model") # 860ns -> 480ns (79.2% faster)
    # Remote URL with connector type and no path
    codeflash_output = is_remote_url("ftp://host") # 855ns -> 443ns (93.0% faster)

def test_basic_invalid_local_paths():
    # Local filesystem path (absolute)
    codeflash_output = is_remote_url("/home/user/model") # 2.33μs -> 1.15μs (103% faster)
    # Local filesystem path (relative)
    codeflash_output = is_remote_url("models/model.bin") # 1.01μs -> 483ns (109% faster)
    # Local filesystem path as Path object
    codeflash_output = is_remote_url(Path("/home/user/model")) # 277ns -> 253ns (9.49% faster)
    codeflash_output = is_remote_url(Path("models/model.bin")) # 177ns -> 165ns (7.27% faster)

def test_edge_empty_and_whitespace():
    # Empty string
    codeflash_output = is_remote_url("") # 2.86μs -> 1.51μs (89.5% faster)
    # String with only whitespace
    codeflash_output = is_remote_url("   ") # 916ns -> 407ns (125% faster)

def test_edge_connector_only():
    # Connector type only, no ://
    codeflash_output = is_remote_url("grpc") # 2.31μs -> 1.12μs (106% faster)
    # Connector type with colon, no slashes
    codeflash_output = is_remote_url("grpc:") # 1.01μs -> 604ns (66.6% faster)
    # Connector type with one slash
    codeflash_output = is_remote_url("grpc:/") # 811ns -> 444ns (82.7% faster)
    # Connector type with three slashes
    codeflash_output = is_remote_url("grpc:///host/model") # 1.12μs -> 678ns (65.5% faster)

def test_edge_missing_connector_type():
    # Missing connector type but has '://'
    codeflash_output = is_remote_url("://host/model") # 2.17μs -> 1.02μs (112% faster)

def test_edge_unusual_connector_types():
    # Numeric connector type
    codeflash_output = is_remote_url("123://host/model") # 2.38μs -> 1.27μs (87.6% faster)
    # Special characters in connector type
    codeflash_output = is_remote_url("g!@#rpc://host/model") # 1.11μs -> 546ns (104% faster)
    # Unicode connector type
    codeflash_output = is_remote_url("连接器://host/model") # 1.71μs -> 1.22μs (39.9% faster)

def test_edge_url_with_query_and_fragment():
    # URL with query string
    codeflash_output = is_remote_url("http://host/model?version=2") # 2.32μs -> 1.06μs (118% faster)
    # URL with fragment
    codeflash_output = is_remote_url("http://host/model#fragment") # 1.15μs -> 635ns (81.3% faster)

def test_edge_url_with_spaces():
    # Spaces in host
    codeflash_output = is_remote_url("grpc://local host/model") # 2.28μs -> 1.25μs (82.1% faster)
    # Spaces in model name
    codeflash_output = is_remote_url("grpc://localhost:1234/model name") # 1.35μs -> 697ns (93.8% faster)

def test_edge_invalid_url_like_strings():
    # Looks like a URL but no connector type
    codeflash_output = is_remote_url("localhost:1234/model") # 2.24μs -> 1.05μs (113% faster)
    # Looks like a URL but wrong separator
    codeflash_output = is_remote_url("grpc:/localhost/model") # 1.10μs -> 575ns (92.2% faster)
    # Only slashes
    codeflash_output = is_remote_url("////") # 687ns -> 436ns (57.6% faster)

def test_edge_path_with_colons():
    # Path with colon, but not a URL
    codeflash_output = is_remote_url("/home/user/model:latest") # 2.34μs -> 1.15μs (103% faster)
    # Path with double colon
    codeflash_output = is_remote_url("/home/user/model::latest") # 1.17μs -> 554ns (112% faster)

def test_edge_path_with_url_like_substring():
    # Local path with embedded URL substring
    codeflash_output = is_remote_url("/data/grpc://localhost/model") # 2.50μs -> 1.20μs (108% faster)

def test_edge_path_object_with_url_like_str():
    # Path object containing URL-like string
    codeflash_output = is_remote_url(Path("grpc://localhost/model")) # 364ns -> 370ns (1.62% slower)

def test_edge_connector_type_with_spaces():
    # Connector type with spaces
    codeflash_output = is_remote_url("gr pc://host/model") # 2.48μs -> 1.33μs (85.9% faster)

def test_edge_connector_type_with_slash():
    # Connector type with slash
    codeflash_output = is_remote_url("gr/pc://host/model") # 2.53μs -> 1.26μs (101% faster)

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

def test_large_scale_many_remote_urls():
    # Generate 500 valid remote URLs
    for i in range(500):
        url = f"grpc://host{i}:1234/model{i}"
        codeflash_output = is_remote_url(url) # 410μs -> 183μs (123% faster)

def test_large_scale_many_local_paths():
    # Generate 500 local paths
    for i in range(500):
        path = f"/models/model_{i}.bin"
        codeflash_output = is_remote_url(path) # 401μs -> 178μs (124% faster)
        codeflash_output = is_remote_url(Path(path))

def test_large_scale_long_url_strings():
    # Very long (but <1000 chars) valid remote URL
    connector = "grpc"
    host = "host" * 100
    port = "1234"
    model = "model" * 100
    url = f"{connector}://{host}:{port}/{model}"
    codeflash_output = is_remote_url(url) # 8.96μs -> 2.79μs (222% faster)

    # Very long invalid local path
    path = "/" + "models/" * 100 + "model.bin"
    codeflash_output = is_remote_url(path) # 5.62μs -> 1.36μs (314% faster)

def test_large_scale_url_with_special_characters():
    # URLs with many special characters
    for i in range(100):
        connector = "gr!@#$%^&*()_+-=pc"
        host = f"host_{i}!@#$%^&*()"
        url = f"{connector}://{host}/model_{i}"
        codeflash_output = is_remote_url(url) # 89.9μs -> 41.3μs (118% faster)

def test_large_scale_empty_and_none_inputs():
    # Many empty strings and None values
    for _ in range(100):
        codeflash_output = is_remote_url("")
        codeflash_output = is_remote_url(None)
# 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_remote_url-mijn71vl and push.