⚡️ Speed up method Mount.matches by 24%

[codeflash-ai]

📄 24% (0.24x) speedup for Mount.matches in starlette/routing.py

⏱️ Runtime : 106 microseconds → 85.0 microseconds (best of 28 runs)

📝 Explanation and details

The optimized version achieves a 24% speedup through several key micro-optimizations that reduce overhead in the hot path of route matching:

Key Optimizations:

1. Reduced dictionary lookups: Caches scope["type"] in a local variable and replaces the in operator check with explicit equality comparisons (scope_type == "http" or scope_type == "websocket"), eliminating tuple creation and membership testing overhead.

2. Optimized parameter conversion loop: Instead of iterating over matched_params.items() and doing dictionary lookups for each key-value pair, it extracts the "path" parameter first with pop(), then iterates only over remaining keys. This reduces the number of dictionary operations and avoids converting the path parameter twice.

3. Local variable caching: Stores self.param_convertors in a local variable convertors to avoid repeated attribute lookups during the conversion loop.

4. Conditional path_params handling: Instead of always calling dict(scope.get("path_params", {})) which creates a new dictionary, it checks if existing path_params exist first. If none exist, it directly uses matched_params; if they exist, it uses the more efficient .copy() method.

5. Reduced scope.get() calls: Pre-fetches app_root_path value instead of embedding the scope.get() call directly in the dictionary construction.

Performance Impact by Test Case:
The optimizations show consistent improvements across all test scenarios:

• Simple static paths: 37.6% faster
• Dynamic parameters: 23.5% faster
• Multiple parameters: 20-25% faster
• Large-scale tests (many params, long paths): 18-25% faster

The optimizations are particularly effective for common HTTP/WebSocket routing scenarios with path parameters, where the reduced dictionary operations and more efficient parameter processing provide measurable gains.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

import re

# imports
import pytest
from starlette.routing import Mount


# Minimal stubs for external dependencies to make the function testable
class Match:
    FULL = "full"
    NONE = "none"

# Dummy convertors for path parameters
class DummyConvertor:
    regex = "[^/]+"
    def convert(self, value):
        return value

class PathConvertor:
    regex = ".*"
    def convert(self, value):
        return value

CONVERTOR_TYPES = {
    "str": DummyConvertor(),
    "path": PathConvertor(),
    "int": DummyConvertor(),
}


def compile_path(path: str):
    PARAM_REGEX = re.compile("{([a-zA-Z_][a-zA-Z0-9_]*)(:[a-zA-Z_][a-zA-Z0-9_]*)?}")
    is_host = not path.startswith("/")
    path_regex = "^"
    path_format = ""
    duplicated_params = set()
    idx = 0
    param_convertors = {}
    for match in PARAM_REGEX.finditer(path):
        param_name, convertor_type = match.groups("str")
        convertor_type = convertor_type.lstrip(":")
        convertor = CONVERTOR_TYPES[convertor_type]
        path_regex += re.escape(path[idx : match.start()])
        path_regex += f"(?P<{param_name}>{convertor.regex})"
        path_format += path[idx : match.start()]
        path_format += "{%s}" % param_name
        if param_name in param_convertors:
            duplicated_params.add(param_name)
        param_convertors[param_name] = convertor
        idx = match.end()
    if duplicated_params:
        names = ", ".join(sorted(duplicated_params))
        ending = "s" if len(duplicated_params) > 1 else ""
        raise ValueError(f"Duplicated param name{ending} {names} at path {path}")
    if is_host:
        hostname = path[idx:].split(":")[0]
        path_regex += re.escape(hostname) + "$"
    else:
        path_regex += re.escape(path[idx:]) + "$"
    path_format += path[idx:]
    return re.compile(path_regex), path_format, param_convertors

class DummyApp:
    pass
from starlette.routing import Mount

# ------------------------
# UNIT TESTS FOR matches()
# ------------------------

# 1. BASIC TEST CASES












def test_edge_unknown_convertor():
    # Edge: unknown convertor type should raise AssertionError
    with pytest.raises(AssertionError):
        Mount("/users/{id:unknown}")









#------------------------------------------------
import re
# --- Minimal definitions to make 'matches' testable ---
from enum import Enum

# imports
import pytest
from starlette.routing import Mount


# Dummy Match enum to mimic starlette.routing.Match
class Match(Enum):
    FULL = "full"
    NONE = "none"

# Dummy convertor types for path parameters
class StringConvertor:
    regex = "[^/]+"
    def convert(self, value): return value

class IntConvertor:
    regex = "[0-9]+"
    def convert(self, value): return int(value)

class PathConvertor:
    regex = ".*"
    def convert(self, value): return value

CONVERTOR_TYPES = {
    "str": StringConvertor(),
    "int": IntConvertor(),
    "path": PathConvertor(),
}


PARAM_REGEX = re.compile(r"{([a-zA-Z_][a-zA-Z0-9_]*)(:[a-zA-Z_][a-zA-Z0-9_]*)?}")

def compile_path(path: str):
    is_host = not path.startswith("/")
    path_regex = "^"
    path_format = ""
    duplicated_params = set()
    idx = 0
    param_convertors = {}
    for match in PARAM_REGEX.finditer(path):
        param_name, convertor_type = match.groups("str")
        convertor_type = convertor_type.lstrip(":")
        convertor = CONVERTOR_TYPES[convertor_type]
        path_regex += re.escape(path[idx : match.start()])
        path_regex += f"(?P<{param_name}>{convertor.regex})"
        path_format += path[idx : match.start()]
        path_format += "{%s}" % param_name
        if param_name in param_convertors:
            duplicated_params.add(param_name)
        param_convertors[param_name] = convertor
        idx = match.end()
    if duplicated_params:
        names = ", ".join(sorted(duplicated_params))
        ending = "s" if len(duplicated_params) > 1 else ""
        raise ValueError(f"Duplicated param name{ending} {names} at path {path}")
    if is_host:
        hostname = path[idx:].split(":")[0]
        path_regex += re.escape(hostname) + "$"
    else:
        path_regex += re.escape(path[idx:]) + "$"
    path_format += path[idx:]
    return re.compile(path_regex), path_format, param_convertors

# Minimal BaseRoute and Mount class
class BaseRoute:
    pass

class DummyApp:
    def __call__(self, scope):
        return "dummy"
from starlette.routing import Mount

# --- Unit tests for Mount.matches ---

# 1. Basic Test Cases

def test_simple_static_path_match():
    # Test matching a simple static path
    mount = Mount("/static", app=DummyApp())
    scope = {"type": "http", "path": "/static/foo.png"}
    match_type, child_scope = mount.matches(scope) # 7.26μs -> 5.28μs (37.6% faster)

def test_simple_dynamic_path_match():
    # Test matching a path with a dynamic parameter
    mount = Mount("/user/{id:int}", app=DummyApp())
    scope = {"type": "http", "path": "/user/123/profile"}
    match_type, child_scope = mount.matches(scope) # 7.45μs -> 6.03μs (23.5% faster)

def test_no_match_for_wrong_path():
    # Test that non-matching paths return NONE
    mount = Mount("/api", app=DummyApp())
    scope = {"type": "http", "path": "/other"}
    match_type, child_scope = mount.matches(scope) # 2.28μs -> 2.16μs (5.60% faster)

def test_websocket_type_match():
    # Test matching with websocket type
    mount = Mount("/ws", app=DummyApp())
    scope = {"type": "websocket", "path": "/ws/chat"}
    match_type, child_scope = mount.matches(scope) # 5.80μs -> 4.59μs (26.6% faster)

def test_path_params_preserved_and_extended():
    # Test that existing path_params are preserved and extended
    mount = Mount("/blog/{slug:str}", app=DummyApp())
    scope = {"type": "http", "path": "/blog/hello-world/comments", "path_params": {"foo": "bar"}}
    match_type, child_scope = mount.matches(scope) # 6.69μs -> 6.01μs (11.5% faster)

# 2. Edge Test Cases

def test_empty_path_mount():
    # Mount at root, should match anything
    mount = Mount("", app=DummyApp())
    scope = {"type": "http", "path": "/anything"}
    match_type, child_scope = mount.matches(scope) # 5.70μs -> 4.45μs (28.2% faster)

def test_trailing_slash_handling():
    # Mount with trailing slash, should match correctly
    mount = Mount("/api/", app=DummyApp())
    scope = {"type": "http", "path": "/api/resource"}
    match_type, child_scope = mount.matches(scope) # 5.63μs -> 4.35μs (29.5% faster)

def test_path_with_multiple_parameters():
    # Mount with multiple dynamic parameters
    mount = Mount("/a/{x:int}/b/{y:str}", app=DummyApp())
    scope = {"type": "http", "path": "/a/42/b/foo/bar"}
    match_type, child_scope = mount.matches(scope) # 7.71μs -> 6.26μs (23.3% faster)

def test_path_with_path_convertor():
    # Mount with path convertor, should capture everything after
    mount = Mount("/files", app=DummyApp())
    scope = {"type": "http", "path": "/files/documents/report.pdf"}
    match_type, child_scope = mount.matches(scope) # 5.70μs -> 4.41μs (29.4% faster)

def test_duplicate_param_names_raises():
    # Mount with duplicate parameter names should raise ValueError
    with pytest.raises(ValueError):
        Mount("/a/{id:int}/b/{id:str}", app=DummyApp())

def test_unknown_convertor_type_raises():
    # Mount with unknown convertor type should raise AssertionError
    with pytest.raises(AssertionError):
        Mount("/foo/{bar:unknown}", app=DummyApp())

def test_match_none_for_non_http_types():
    # Should return NONE for non-http/websocket types
    mount = Mount("/api", app=DummyApp())
    scope = {"type": "lifespan", "path": "/api/resource"}
    match_type, child_scope = mount.matches(scope) # 982ns -> 1.02μs (4.20% slower)

def test_match_with_root_path_and_app_root_path():
    # Should set app_root_path and root_path correctly
    mount = Mount("/app", app=DummyApp())
    scope = {"type": "http", "path": "/app/dashboard", "root_path": "/prefix", "app_root_path": "/prefix"}
    match_type, child_scope = mount.matches(scope) # 6.77μs -> 5.12μs (32.3% faster)

def test_match_with_empty_remaining_path():
    # Mount with path that matches exactly, remaining path is '/'
    mount = Mount("/exact", app=DummyApp())
    scope = {"type": "http", "path": "/exact/"}
    match_type, child_scope = mount.matches(scope) # 5.88μs -> 4.37μs (34.4% faster)

def test_match_with_non_ascii_path():
    # Mount with unicode path
    mount = Mount("/üñîçødë", app=DummyApp())
    scope = {"type": "http", "path": "/üñîçødë/file"}
    match_type, child_scope = mount.matches(scope) # 6.08μs -> 4.66μs (30.5% faster)

# 3. Large Scale Test Cases


def test_long_path_parameter_value():
    # Test with a very long path parameter value
    long_value = "x" * 500
    mount = Mount("/long/{name:str}", app=DummyApp())
    scope = {"type": "http", "path": f"/long/{long_value}/foo"}
    match_type, child_scope = mount.matches(scope) # 8.16μs -> 6.53μs (25.0% faster)

def test_many_path_params():
    # Test with many path parameters
    path = "/".join([f"{{p{i}:int}}" for i in range(20)])
    mount = Mount(f"/{path}", app=DummyApp())
    values = "/".join(str(i) for i in range(20))
    scope = {"type": "http", "path": f"/{values}/extra"}
    match_type, child_scope = mount.matches(scope) # 14.9μs -> 12.4μs (20.8% faster)
    for i in range(20):
        pass

def test_large_path_segments():
    # Test matching with a large number of path segments
    mount = Mount("/base", app=DummyApp())
    segments = "/".join(f"seg{i}" for i in range(500))
    scope = {"type": "http", "path": f"/base/{segments}"}
    match_type, child_scope = mount.matches(scope) # 8.82μs -> 7.45μs (18.4% faster)

To edit these changes git checkout codeflash/optimize-Mount.matches-mhbmqcm5 and push.