⚡️ Speed up function _is_proxy_artifact_path by 24%

[codeflash-ai]

📄 24% (0.24x) speedup for _is_proxy_artifact_path in mlflow/server/auth/__init__.py

⏱️ Runtime : 887 microseconds → 718 microseconds (best of 59 runs)

📝 Explanation and details

The optimization eliminates repeated string formatting operations by pre-computing the prefix pattern once at module load time. In the original code, the f-string f"{_REST_API_PATH_PREFIX}/mlflow-artifacts/artifacts/" was constructed on every function call (4,328 times in the profiler), performing string concatenation each time. The optimized version moves this computation to module initialization as _PROXY_ARTIFACT_PREFIX, so the startswith() method operates on a pre-built string constant.

Key Performance Impact:

• 23% speedup (887μs → 718μs) by eliminating redundant string operations
• Per-call improvement from 397ns to 328ns (17% faster per call)
• All test cases show consistent 18-42% improvements across different path patterns

Why This Works:
Python's f-string formatting involves runtime string concatenation and formatting overhead. By moving this to a module-level constant, we leverage Python's string interning and eliminate the repeated computational cost. The startswith() method now operates directly on a pre-existing string object rather than creating a new one each time.

Optimization Benefits:

• Short paths: 20-30% faster (basic prefix checks)
• Long paths: Similar gains since the optimization affects prefix computation, not path traversal
• High-frequency calls: Maximum benefit in loops or batch operations (as seen in large-scale tests with 1000+ iterations showing ~25% improvement)

This optimization is particularly valuable when _is_proxy_artifact_path() is called frequently in request processing pipelines, where even small per-call improvements compound significantly under load.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

import pytest # used for our unit tests
from mlflow.server.auth.init import _is_proxy_artifact_path

function to test

Simulate the _REST_API_PATH_PREFIX as it would be imported from mlflow.utils.rest_utils

_REST_API_PATH_PREFIX = "/api/2.0"
from mlflow.server.auth.init import _is_proxy_artifact_path

unit tests

1. Basic Test Cases

def test_basic_true_case():
# Path exactly matches the expected prefix
codeflash_output = _is_proxy_artifact_path("/api/2.0/mlflow-artifacts/artifacts/") # 805ns -> 628ns (28.2% faster)

def test_basic_true_case_with_extra_path():
# Path matches the prefix and has additional sub-paths
codeflash_output = _is_proxy_artifact_path("/api/2.0/mlflow-artifacts/artifacts/123/abc/file.txt") # 811ns -> 603ns (34.5% faster)

def test_basic_false_case_wrong_prefix():
# Path does not start with the expected REST API prefix
codeflash_output = _is_proxy_artifact_path("/api/1.0/mlflow-artifacts/artifacts/") # 758ns -> 610ns (24.3% faster)

def test_basic_false_case_similar_but_not_exact():
# Path is similar but missing a character in the prefix
codeflash_output = _is_proxy_artifact_path("/api/2.0/mlflow-artifact/artifacts/") # 742ns -> 552ns (34.4% faster)

def test_basic_false_case_wrong_artifact_path():
# Path starts with the prefix but not the artifact subpath
codeflash_output = _is_proxy_artifact_path("/api/2.0/mlflow-artifacts/foo/") # 750ns -> 580ns (29.3% faster)

2. Edge Test Cases

def test_edge_empty_string():
# Empty string should not match
codeflash_output = _is_proxy_artifact_path("") # 741ns -> 575ns (28.9% faster)

def test_edge_only_prefix_no_artifact_path():
# Only the REST API prefix, missing artifact path
codeflash_output = _is_proxy_artifact_path(_REST_API_PATH_PREFIX) # 772ns -> 559ns (38.1% faster)

def test_edge_prefix_with_trailing_slash():
# REST API prefix with trailing slash, missing artifact path
codeflash_output = _is_proxy_artifact_path(_REST_API_PATH_PREFIX + "/") # 744ns -> 527ns (41.2% faster)

def test_edge_prefix_with_partial_artifact_path():
# Prefix with partial artifact path
codeflash_output = _is_proxy_artifact_path(_REST_API_PATH_PREFIX + "/mlflow-artifacts/artifact/") # 740ns -> 561ns (31.9% faster)

def test_edge_prefix_with_similar_but_wrong_subpath():
# Prefix with similar but incorrect artifact subpath
codeflash_output = _is_proxy_artifact_path(_REST_API_PATH_PREFIX + "/mlflow-artifacts/artifactsX/") # 776ns -> 551ns (40.8% faster)

def test_edge_case_leading_whitespace():
# Leading whitespace should not match
codeflash_output = _is_proxy_artifact_path(" " + _REST_API_PATH_PREFIX + "/mlflow-artifacts/artifacts/") # 731ns -> 600ns (21.8% faster)

def test_edge_case_trailing_whitespace():
# Trailing whitespace should not affect matching
codeflash_output = _is_proxy_artifact_path(_REST_API_PATH_PREFIX + "/mlflow-artifacts/artifacts/ ") # 783ns -> 614ns (27.5% faster)

def test_edge_case_unicode_characters():
# Unicode characters before the prefix should not match
codeflash_output = _is_proxy_artifact_path("✨" + _REST_API_PATH_PREFIX + "/mlflow-artifacts/artifacts/") # 799ns -> 562ns (42.2% faster)

def test_edge_case_uppercase_path():
# Uppercase path should not match due to case sensitivity
codeflash_output = _is_proxy_artifact_path(_REST_API_PATH_PREFIX.upper() + "/MLFLOW-ARTIFACTS/ARTIFACTS/") # 785ns -> 585ns (34.2% faster)

def test_edge_case_prefix_substring():
# Path is a substring of the prefix
codeflash_output = _is_proxy_artifact_path(_REST_API_PATH_PREFIX[:5]) # 700ns -> 592ns (18.2% faster)

def test_edge_case_prefix_and_artifact_path_but_extra_slash():
# Extra slash between prefix and artifact path
codeflash_output = _is_proxy_artifact_path(_REST_API_PATH_PREFIX + "//mlflow-artifacts/artifacts/") # 744ns -> 615ns (21.0% faster)

def test_edge_case_prefix_and_artifact_path_but_missing_slash():
# Missing slash between prefix and artifact path
codeflash_output = _is_proxy_artifact_path(_REST_API_PATH_PREFIX + "mlflow-artifacts/artifacts/") # 747ns -> 561ns (33.2% faster)

def test_edge_case_path_is_bytes():
# Bytes are not valid input, should raise TypeError
with pytest.raises(TypeError):
_is_proxy_artifact_path(b"/api/2.0/mlflow-artifacts/artifacts/") # 2.88μs -> 2.64μs (9.33% faster)

3. Large Scale Test Cases

def test_large_scale_many_true_cases():
# Generate 500 valid paths with incrementing sub-paths
for i in range(500):
path = f"{_REST_API_PATH_PREFIX}/mlflow-artifacts/artifacts/{i}/file.txt"
codeflash_output = _is_proxy_artifact_path(path) # 98.6μs -> 80.9μs (21.8% faster)

def test_large_scale_many_false_cases():
# Generate 500 invalid paths with similar but incorrect prefixes
for i in range(500):
path = f"/api/2.{i}/mlflow-artifacts/artifacts/{i}/file.txt"
# Only /api/2.0 is valid, so all others should be False
if i == 0:
continue # skip i=0 which is valid
codeflash_output = _is_proxy_artifact_path(path) # 96.2μs -> 78.7μs (22.1% faster)

def test_large_scale_long_path():
# Very long valid path
long_subpath = "a" * 900
path = f"{_REST_API_PATH_PREFIX}/mlflow-artifacts/artifacts/{long_subpath}/file.txt"
codeflash_output = _is_proxy_artifact_path(path) # 801ns -> 641ns (25.0% faster)

def test_large_scale_long_invalid_path():
# Very long invalid path (wrong prefix)
long_subpath = "a" * 900
path = f"/api/3.0/mlflow-artifacts/artifacts/{long_subpath}/file.txt"
codeflash_output = _is_proxy_artifact_path(path) # 810ns -> 636ns (27.4% faster)

def test_large_scale_all_possible_prefixes():
# Test all possible one-character changes in the prefix
base = f"{_REST_API_PATH_PREFIX}/mlflow-artifacts/artifacts/"
for i in range(len(_REST_API_PATH_PREFIX)):
for c in "0123456789abcdefghijklmnopqrstuvwxyz":
if _REST_API_PATH_PREFIX[i] == c:
continue
test_prefix = _REST_API_PATH_PREFIX[:i] + c + _REST_API_PATH_PREFIX[i+1:]
path = f"{test_prefix}/mlflow-artifacts/artifacts/"
codeflash_output = _is_proxy_artifact_path(path)

def test_large_scale_path_with_special_characters():
# Path contains special characters after the prefix
special_chars = "!@#$%^&*()_+-=[]{}|;':,.<>/?"
path = f"{_REST_API_PATH_PREFIX}/mlflow-artifacts/artifacts/{special_chars}"
codeflash_output = _is_proxy_artifact_path(path) # 789ns -> 607ns (30.0% faster)

def test_large_scale_path_with_unicode_characters():
# Path contains unicode after the prefix
unicode_chars = "文件/файл/ملف"
path = f"{_REST_API_PATH_PREFIX}/mlflow-artifacts/artifacts/{unicode_chars}"
codeflash_output = _is_proxy_artifact_path(path) # 910ns -> 682ns (33.4% faster)

def test_large_scale_path_with_repeated_prefix():
# Path starts with the prefix, then repeats it (should still match)
path = f"{_REST_API_PATH_PREFIX}/mlflow-artifacts/artifacts/{_REST_API_PATH_PREFIX}/mlflow-artifacts/artifacts/"
codeflash_output = _is_proxy_artifact_path(path) # 773ns -> 598ns (29.3% faster)

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

#------------------------------------------------
import pytest # used for our unit tests
from mlflow.server.auth.init import _is_proxy_artifact_path

function to test

Simulate the _REST_API_PATH_PREFIX constant as in mlflow.utils.rest_utils

_REST_API_PATH_PREFIX = "/api/2.0"
from mlflow.server.auth.init import _is_proxy_artifact_path

unit tests

1. Basic Test Cases

def test_basic_valid_proxy_artifact_path():
# Test with a typical valid proxy artifact path
path = "/api/2.0/mlflow-artifacts/artifacts/my-artifact"
codeflash_output = _is_proxy_artifact_path(path) # 747ns -> 596ns (25.3% faster)

def test_basic_invalid_path_prefix():
# Path does not start with the required prefix
path = "/api/2.0/mlflow-artifacts/not-artifacts/my-artifact"
codeflash_output = _is_proxy_artifact_path(path) # 734ns -> 613ns (19.7% faster)

def test_basic_invalid_api_version():
# Path has a different API version prefix
path = "/api/1.0/mlflow-artifacts/artifacts/my-artifact"
codeflash_output = _is_proxy_artifact_path(path) # 790ns -> 606ns (30.4% faster)

def test_basic_valid_with_trailing_slash():
# Path with trailing slash after 'artifacts/'
path = "/api/2.0/mlflow-artifacts/artifacts/"
codeflash_output = _is_proxy_artifact_path(path) # 758ns -> 620ns (22.3% faster)

def test_basic_valid_with_subpath():
# Path with additional subdirectories after the prefix
path = "/api/2.0/mlflow-artifacts/artifacts/foo/bar/baz"
codeflash_output = _is_proxy_artifact_path(path) # 789ns -> 588ns (34.2% faster)

2. Edge Test Cases

def test_edge_empty_string():
# Empty string should return False
path = ""
codeflash_output = _is_proxy_artifact_path(path) # 774ns -> 572ns (35.3% faster)

def test_edge_only_prefix_no_artifacts():
# Only the prefix, missing 'artifacts/'
path = "/api/2.0/mlflow-artifacts/"
codeflash_output = _is_proxy_artifact_path(path) # 740ns -> 520ns (42.3% faster)

def test_edge_prefix_with_similar_but_not_exact_match():
# Path that is similar but not exact (missing final slash)
path = "/api/2.0/mlflow-artifacts/artifacts"
codeflash_output = _is_proxy_artifact_path(path) # 760ns -> 555ns (36.9% faster)

def test_edge_prefix_with_extra_slash():
# Path with double slash after 'artifacts/'
path = "/api/2.0/mlflow-artifacts/artifacts//foo"
codeflash_output = _is_proxy_artifact_path(path) # 768ns -> 595ns (29.1% faster)

def test_edge_prefix_with_case_sensitivity():
# Path with different case (should be case sensitive)
path = "/API/2.0/mlflow-artifacts/artifacts/foo"
codeflash_output = _is_proxy_artifact_path(path) # 771ns -> 631ns (22.2% faster)

def test_edge_prefix_with_leading_spaces():
# Path with leading spaces
path = " /api/2.0/mlflow-artifacts/artifacts/foo"
codeflash_output = _is_proxy_artifact_path(path) # 727ns -> 578ns (25.8% faster)

def test_edge_prefix_with_trailing_spaces():
# Path with trailing spaces
path = "/api/2.0/mlflow-artifacts/artifacts/foo "
codeflash_output = _is_proxy_artifact_path(path) # 769ns -> 564ns (36.3% faster)

def test_edge_prefix_with_unicode_characters():
# Path containing unicode characters after the prefix
path = "/api/2.0/mlflow-artifacts/artifacts/💾"
codeflash_output = _is_proxy_artifact_path(path) # 925ns -> 764ns (21.1% faster)

def test_edge_prefix_with_special_characters():
# Path containing special characters after the prefix
path = "/api/2.0/mlflow-artifacts/artifacts/!@#$%^&*()"
codeflash_output = _is_proxy_artifact_path(path) # 770ns -> 583ns (32.1% faster)

def test_edge_prefix_with_long_path():
# Path with a very long subpath after the prefix
long_subpath = "a" * 500
path = f"/api/2.0/mlflow-artifacts/artifacts/{long_subpath}"
codeflash_output = _is_proxy_artifact_path(path) # 793ns -> 608ns (30.4% faster)

def test_edge_prefix_with_partial_match():
# Path that partially matches the prefix but is missing a character
path = "/api/2.0/mlflow-artifacts/artifact/my-artifact"
codeflash_output = _is_proxy_artifact_path(path) # 764ns -> 608ns (25.7% faster)

def test_edge_prefix_with_query_parameters():
# Path with query parameters (should still match if prefix is correct)
path = "/api/2.0/mlflow-artifacts/artifacts/foo?version=1"
codeflash_output = _is_proxy_artifact_path(path) # 827ns -> 615ns (34.5% faster)

def test_edge_prefix_with_fragment():
# Path with a fragment (should still match)
path = "/api/2.0/mlflow-artifacts/artifacts/foo#section"
codeflash_output = _is_proxy_artifact_path(path) # 777ns -> 604ns (28.6% faster)

3. Large Scale Test Cases

def test_large_scale_many_valid_paths():
# Test with a large number of valid paths
for i in range(1000):
path = f"/api/2.0/mlflow-artifacts/artifacts/artifact_{i}"
codeflash_output = _is_proxy_artifact_path(path) # 199μs -> 159μs (24.9% faster)

def test_large_scale_many_invalid_paths():
# Test with a large number of invalid paths
for i in range(1000):
path = f"/api/2.0/mlflow-artifacts/not-artifacts/artifact_{i}"
codeflash_output = _is_proxy_artifact_path(path) # 196μs -> 157μs (24.8% faster)

def test_large_scale_mixed_paths():
# Test with a mix of valid and invalid paths
for i in range(500):
valid_path = f"/api/2.0/mlflow-artifacts/artifacts/artifact_{i}"
invalid_path = f"/api/2.0/mlflow-artifacts/artifact/artifact_{i}"
codeflash_output = _is_proxy_artifact_path(valid_path) # 104μs -> 84.7μs (23.5% faster)
codeflash_output = _is_proxy_artifact_path(invalid_path)

def test_large_scale_long_prefix():
# Test with a very long prefix (simulate REST API path prefix up to 1000 chars)
long_prefix = "/" + "a" * 995
path = f"{long_prefix}/mlflow-artifacts/artifacts/foo"
# Override the global prefix for this test
global _REST_API_PATH_PREFIX
old_prefix = _REST_API_PATH_PREFIX
_REST_API_PATH_PREFIX = long_prefix
try:
codeflash_output = _is_proxy_artifact_path(path)
# Path with similar but not exact long prefix
path_invalid = f"{long_prefix[:-1]}/mlflow-artifacts/artifacts/foo"
codeflash_output = _is_proxy_artifact_path(path_invalid)
finally:
_REST_API_PATH_PREFIX = old_prefix

def test_large_scale_path_near_limit():
# Path length near system limits (e.g., 1000 characters)
base = "/api/2.0/mlflow-artifacts/artifacts/"
long_tail = "x" * (1000 - len(base))
path = base + long_tail
codeflash_output = _is_proxy_artifact_path(path) # 762ns -> 654ns (16.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-_is_proxy_artifact_path-mhup9opj and push.