⚡️ Speed up function sanitize_filename by 43%

[codeflash-ai]

📄 43% (0.43x) speedup for sanitize_filename in skyvern/forge/sdk/api/files.py

⏱️ Runtime : 722 microseconds → 505 microseconds (best of 250 runs)

📝 Explanation and details

The optimization achieves a 42% speedup by making two key changes to the filename sanitization logic:

What was optimized:

1. Set-based membership testing: Replaced the inline list ["-", "_", ".", "%", " "] with a pre-defined set allowed = {"-", "_", ".", "%", " "}
2. List comprehension over generator: Changed from generator expression (c for c in filename...) to list comprehension [c for c in filename...]

Why this is faster:

• Set lookup efficiency: Set membership testing (c in allowed) is O(1) average case, while list membership testing is O(n). The original code created and searched the list for every character, causing repeated linear scans.
• Reduced object creation overhead: The set is created once per function call rather than being recreated for each character check.
• List comprehension performance: When the result is immediately consumed by "".join(), list comprehensions are slightly more efficient than generator expressions due to reduced iterator protocol overhead.

Performance characteristics:
The optimization shows increasing benefits with longer filenames and more complex character compositions:

• Basic cases (short filenames): Modest 3-16% improvements
• Large scale cases: Dramatic 24-101% speedups, especially for files with many disallowed characters
• Best case scenario: 101% speedup when processing 1000 disallowed characters, where the O(1) vs O(n) difference is most pronounced

Test case patterns that benefit most:

• Long filenames with mixed allowed/disallowed characters (62-97% faster)
• Files with many consecutive disallowed characters (72-101% faster)
• Any scenario where the function processes substantial character volumes

The optimization maintains identical functionality while providing consistent performance gains across all input types, with the most significant improvements on the workloads that would benefit most from faster filename sanitization.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

import string # for generating large scale test cases

imports

import pytest # used for our unit tests
from skyvern.forge.sdk.api.files import sanitize_filename

unit tests

=========================

Basic Test Cases

=========================

def test_basic_alphanumeric():
# Should retain all alphanumeric characters
codeflash_output = sanitize_filename("abc123") # 1.51μs -> 1.63μs (7.26% slower)

def test_basic_allowed_symbols():
# Should retain allowed symbols
codeflash_output = sanitize_filename("file-name_1.0% test") # 2.23μs -> 2.15μs (3.63% faster)

def test_basic_disallowed_symbols():
# Should remove disallowed symbols
codeflash_output = sanitize_filename("file@name#1$") # 1.81μs -> 1.74μs (4.03% faster)

def test_basic_mixed():
# Should remove only disallowed and keep allowed
codeflash_output = sanitize_filename("a_b-c.d%e f@g!h") # 2.12μs -> 1.92μs (10.5% faster)

def test_basic_empty_string():
# Should return empty string for empty input
codeflash_output = sanitize_filename("") # 1.05μs -> 936ns (12.0% faster)

def test_basic_only_disallowed():
# Should return empty string if only disallowed chars
codeflash_output = sanitize_filename("@#$%^&*()[]{}") # 2.06μs -> 1.76μs (16.5% faster)

def test_basic_space_handling():
# Should keep spaces
codeflash_output = sanitize_filename("file name with spaces") # 2.20μs -> 2.08μs (6.12% faster)

=========================

Edge Test Cases

=========================

def test_edge_unicode_characters():
# Should remove non-ascii unicode characters
codeflash_output = sanitize_filename("文件名😊") # 1.96μs -> 1.96μs (0.153% faster)

def test_edge_combining_characters():
# Should remove combining accents
codeflash_output = sanitize_filename("áêïōű") # 1.90μs -> 2.06μs (7.85% slower)

def test_edge_control_characters():
# Should remove control characters
codeflash_output = sanitize_filename("file\x00name\x1F") # 1.61μs -> 1.65μs (1.88% slower)

def test_edge_only_allowed_symbols():
# Should keep all allowed symbols
codeflash_output = sanitize_filename("-_ .% ") # 1.63μs -> 1.53μs (6.34% faster)

def test_edge_leading_trailing_spaces():
# Should preserve leading/trailing spaces
codeflash_output = sanitize_filename(" file ") # 1.65μs -> 1.60μs (2.87% faster)

def test_edge_newlines_and_tabs():
# Should remove newlines and tabs
codeflash_output = sanitize_filename("file\nname\twith\rspecial") # 2.13μs -> 1.96μs (8.52% faster)

def test_edge_mixed_case():
# Should preserve case
codeflash_output = sanitize_filename("FileName123") # 1.62μs -> 1.63μs (0.369% slower)

def test_edge_dot_and_percent():
# Should keep dots and percent signs
codeflash_output = sanitize_filename("my.file%name") # 1.78μs -> 1.69μs (4.96% faster)

def test_edge_multiple_disallowed_in_row():
# Should remove consecutive disallowed characters
codeflash_output = sanitize_filename("file!!!@@@###$$%%%") # 2.28μs -> 1.92μs (18.5% faster)

def test_edge_only_space():
# Should allow single space
codeflash_output = sanitize_filename(" ") # 1.24μs -> 1.18μs (5.19% faster)

def test_edge_surrogate_pairs():
# Should remove surrogate pairs (emojis, etc.)
codeflash_output = sanitize_filename("test\U0001F600file") # 1.89μs -> 1.95μs (2.93% slower)

def test_edge_reserved_windows_names():
# Should not change reserved names if only allowed chars
codeflash_output = sanitize_filename("CON") # 1.24μs -> 1.29μs (3.57% slower)
codeflash_output = sanitize_filename("PRN") # 578ns -> 564ns (2.48% faster)

def test_edge_reserved_windows_names_with_symbols():
# Should remove disallowed symbols from reserved names
codeflash_output = sanitize_filename("CON<>") # 1.46μs -> 1.36μs (7.89% faster)

def test_edge_long_filename():
# Should handle long filenames correctly
long_name = "a" * 255
codeflash_output = sanitize_filename(long_name) # 8.26μs -> 6.90μs (19.8% faster)

=========================

Large Scale Test Cases

=========================

def test_large_mixed_characters():
# Generate a large filename with allowed and disallowed characters
allowed = string.ascii_letters + string.digits + "-_.% "
disallowed = "@#$^&*()[]{}|;:'",<>/?`~\"
# Create a filename of 1000 characters, half allowed, half disallowed
filename = (allowed * (1000 // len(allowed)))[:500] + (disallowed * (1000 // len(disallowed)))[:500]
codeflash_output = sanitize_filename(filename); sanitized = codeflash_output # 42.9μs -> 26.4μs (62.5% faster)
# Only allowed characters should remain
for c in sanitized:
pass

def test_large_only_disallowed():
# Large filename with only disallowed characters
disallowed = "@#$^&*()[]{}|;:'",<>/?`~\"
filename = disallowed * (1000 // len(disallowed))
codeflash_output = sanitize_filename(filename); sanitized = codeflash_output # 54.5μs -> 27.2μs (101% faster)

def test_large_only_allowed():
# Large filename with only allowed characters
allowed = string.ascii_letters + string.digits + "-_.% "
filename = allowed * (1000 // len(allowed))
codeflash_output = sanitize_filename(filename); sanitized = codeflash_output # 27.8μs -> 22.4μs (24.4% faster)

def test_large_random_filename():
# Large filename with random characters
import random
all_chars = string.ascii_letters + string.digits + "-_.% " + "@#$^&*()[]{}|;:'",<>/?`~\"
filename = ''.join(random.choices(all_chars, k=1000))
codeflash_output = sanitize_filename(filename); sanitized = codeflash_output # 44.5μs -> 34.3μs (29.6% faster)
# Only allowed characters should remain
for c in sanitized:
pass

def test_large_unicode_filename():
# Large filename with unicode characters
filename = "文件😊" * 250 # 1000 chars
codeflash_output = sanitize_filename(filename); sanitized = codeflash_output # 39.6μs -> 35.3μs (12.3% faster)

def test_large_spaces():
# Large filename with only spaces
filename = " " * 1000
codeflash_output = sanitize_filename(filename); sanitized = codeflash_output # 63.3μs -> 36.8μs (72.0% faster)

def test_large_dot_percent_mix():
# Large filename with only dots and percent signs
filename = "." * 500 + "%" * 500
codeflash_output = sanitize_filename(filename); sanitized = codeflash_output # 52.0μs -> 36.4μs (42.8% faster)

=========================

Mutation-sensitive tests

=========================

def test_mutation_sensitive_removal():
# If the function is mutated to allow '@', this test will fail
codeflash_output = sanitize_filename("test@file") # 1.60μs -> 1.57μs (1.91% faster)

def test_mutation_sensitive_allow_extra_symbol():
# If the function is mutated to allow '/', this test will fail
codeflash_output = sanitize_filename("file/name") # 1.47μs -> 1.54μs (4.48% slower)

def test_mutation_sensitive_disallow_space():
# If the function is mutated to remove spaces, this test will fail
codeflash_output = sanitize_filename("file name") # 1.62μs -> 1.51μs (7.36% faster)

def test_mutation_sensitive_disallow_dot():
# If the function is mutated to remove dots, this test will fail
codeflash_output = sanitize_filename("file.name") # 1.60μs -> 1.50μs (6.39% faster)

def test_mutation_sensitive_disallow_percent():
# If the function is mutated to remove percent, this test will fail
codeflash_output = sanitize_filename("file%name") # 1.59μs -> 1.47μs (8.66% faster)

def test_mutation_sensitive_disallow_dash_underscore():
# If the function is mutated to remove dash or underscore, this test will fail
codeflash_output = sanitize_filename("file-name_file") # 1.74μs -> 1.69μs (3.26% faster)

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

#------------------------------------------------
import string # used for generating large scale test cases

imports

import pytest # used for our unit tests
from skyvern.forge.sdk.api.files import sanitize_filename

unit tests

-------------------------

Basic Test Cases

-------------------------

def test_basic_alphanumeric():
# Only alphanumeric characters; should remain unchanged
codeflash_output = sanitize_filename("abc123XYZ") # 1.60μs -> 1.58μs (1.27% faster)

def test_basic_allowed_symbols():
# Allowed symbols should remain
codeflash_output = sanitize_filename("file-name_01.txt") # 1.95μs -> 1.88μs (3.62% faster)
codeflash_output = sanitize_filename("data%20set.csv") # 1.18μs -> 1.06μs (10.8% faster)
codeflash_output = sanitize_filename("my file.txt") # 824ns -> 765ns (7.71% faster)
codeflash_output = sanitize_filename("report_v1.2.pdf") # 1.02μs -> 909ns (12.3% faster)

def test_basic_mixed_allowed_and_disallowed():
# Disallowed characters should be removed
codeflash_output = sanitize_filename("hello@world!.txt") # 1.85μs -> 1.54μs (19.6% faster)
codeflash_output = sanitize_filename("foo#bar$baz.doc") # 1.13μs -> 964ns (17.3% faster)
codeflash_output = sanitize_filename("test:file|name?.csv") # 1.17μs -> 912ns (28.2% faster)

def test_basic_empty_string():
# Empty string should remain empty
codeflash_output = sanitize_filename("") # 952ns -> 819ns (16.2% faster)

def test_basic_only_disallowed():
# String with only disallowed characters should return empty string
codeflash_output = sanitize_filename("@#$%^&*()[]{};:'"\/|,<>~`") # 2.56μs -> 2.09μs (22.5% faster)

-------------------------

Edge Test Cases

-------------------------

def test_edge_spaces():
# Leading, trailing, and multiple consecutive spaces should be preserved
codeflash_output = sanitize_filename(" spaced out .txt ") # 2.35μs -> 2.02μs (16.6% faster)

def test_edge_unicode_letters():
# Non-ASCII letters should be removed (if not alnum)
codeflash_output = sanitize_filename("naïve_file.txt") # 2.03μs -> 1.86μs (9.07% faster)
codeflash_output = sanitize_filename("résumé.pdf") # 941ns -> 910ns (3.41% faster)
codeflash_output = sanitize_filename("файл.txt") # 1.13μs -> 1.25μs (9.46% slower)

def test_edge_unicode_digits():
# Unicode digits should be removed
codeflash_output = sanitize_filename("file１２３.txt") # 2.06μs -> 2.07μs (0.484% slower)

def test_edge_mixed_case():
# Upper and lower case letters should be preserved
codeflash_output = sanitize_filename("MyFile_Name-01.TXT") # 2.03μs -> 1.88μs (7.82% faster)

def test_edge_only_symbols():
# Only allowed symbols should remain
codeflash_output = sanitize_filename("-_ .%") # 1.47μs -> 1.41μs (4.32% faster)

def test_edge_dot_at_start_end():
# Dots at start and end should be preserved
codeflash_output = sanitize_filename(".hiddenfile.") # 1.59μs -> 1.62μs (2.16% slower)

def test_edge_percent_sign():
# Percent sign is allowed
codeflash_output = sanitize_filename("%percent%sign%.txt") # 2.00μs -> 1.81μs (10.4% faster)

def test_edge_long_repeated_disallowed():
# Long string of repeated disallowed characters should return empty or allowed
codeflash_output = sanitize_filename("!!!!!!!") # 1.60μs -> 1.24μs (29.1% faster)
codeflash_output = sanitize_filename("%%%%%%%") # 1.07μs -> 1.04μs (3.38% faster)

def test_edge_filename_with_newlines_and_tabs():
# Newlines and tabs are not allowed and should be removed
codeflash_output = sanitize_filename("file\nname\t.txt") # 1.77μs -> 1.70μs (4.48% faster)

def test_edge_filename_with_surrogate_pairs():
# Surrogate pairs (emojis, etc.) should be removed
codeflash_output = sanitize_filename("file😀name.txt") # 2.19μs -> 2.08μs (5.13% faster)

def test_edge_filename_with_multiple_dots():
# Multiple dots should be preserved
codeflash_output = sanitize_filename("archive.tar.gz") # 1.69μs -> 1.61μs (4.65% faster)

def test_edge_filename_with_mixed_whitespace():
# Tabs, newlines, carriage returns, etc. should be removed, spaces preserved
codeflash_output = sanitize_filename("a b\tc\nd\re f") # 1.75μs -> 1.61μs (9.01% faster)

def test_edge_filename_with_slashes():
# Slashes are not allowed
codeflash_output = sanitize_filename("folder/file.txt") # 1.82μs -> 1.71μs (6.25% faster)
codeflash_output = sanitize_filename("file/name/with/slash.txt") # 1.52μs -> 1.26μs (20.4% faster)

def test_edge_filename_with_quotes():
# Quotes are not allowed
codeflash_output = sanitize_filename("file'name".txt") # 1.78μs -> 1.54μs (16.1% faster)

def test_edge_filename_with_reserved_windows_chars():
# Reserved Windows filename characters are not allowed
codeflash_output = sanitize_filename("con<>:"/\|?*.txt") # 1.98μs -> 1.90μs (4.27% faster)

def test_edge_filename_with_reserved_unix_chars():
# Reserved Unix filename characters are not allowed
codeflash_output = sanitize_filename("file*name?.txt") # 1.75μs -> 1.65μs (6.07% faster)

def test_edge_filename_with_multiple_percent_signs():
# Multiple percent signs should be preserved
codeflash_output = sanitize_filename("100%%_complete.txt") # 2.08μs -> 1.97μs (5.58% faster)

def test_edge_filename_with_only_spaces():
# Only spaces should be preserved
codeflash_output = sanitize_filename(" ") # 1.55μs -> 1.41μs (10.0% faster)

def test_edge_filename_with_dot_and_space():
# Dot and space together should be preserved
codeflash_output = sanitize_filename(". . .") # 1.54μs -> 1.39μs (11.5% faster)

def test_edge_filename_with_long_sequence_of_disallowed():
# Long sequence of disallowed characters should be removed
codeflash_output = sanitize_filename("a" + "#"*100 + "b") # 6.80μs -> 3.95μs (72.2% faster)

-------------------------

Large Scale Test Cases

-------------------------

def test_large_scale_long_filename():
# Very long filename with mixed allowed/disallowed characters
allowed = string.ascii_letters + string.digits + "-_.% "
# Create a filename of length 1000 with every third char disallowed
filename = ""
for i in range(1000):
if i % 3 == 0:
filename += "@"
else:
filename += allowed[i % len(allowed)]
# The sanitized filename should have every third char removed
expected = "".join(allowed[i % len(allowed)] for i in range(1000) if i % 3 != 0)
codeflash_output = sanitize_filename(filename) # 37.8μs -> 24.5μs (54.3% faster)

def test_large_scale_all_allowed_chars():
# Filename of 1000 allowed characters should remain unchanged
allowed = (string.ascii_letters + string.digits + "-_.% ") * 10
filename = allowed[:1000]
codeflash_output = sanitize_filename(filename) # 20.3μs -> 16.5μs (23.2% faster)

def test_large_scale_all_disallowed_chars():
# Filename of 1000 disallowed characters should return empty string
disallowed = "@#$^&*()[]{};:'"\/|,<>~`\n\t" * 50
filename = disallowed[:1000]
codeflash_output = sanitize_filename(filename) # 54.4μs -> 27.6μs (97.3% faster)

def test_large_scale_alternating_allowed_disallowed():
# Alternating allowed and disallowed characters
allowed = string.ascii_letters
disallowed = "@#$%^&*"
filename = ""
for i in range(1000):
if i % 2 == 0:
filename += allowed[i % len(allowed)]
else:
filename += disallowed[i % len(disallowed)]
expected = "".join(allowed[i % len(allowed)] for i in range(1000) if i % 2 == 0)
codeflash_output = sanitize_filename(filename) # 40.2μs -> 24.0μs (67.3% faster)

def test_large_scale_spaces_and_dots():
# Large filename with only spaces and dots
filename = (" . " * 333)[:999]
codeflash_output = sanitize_filename(filename) # 59.4μs -> 36.6μs (62.4% faster)

def test_large_scale_filename_with_unicode():
# Large filename with interspersed unicode characters
base = string.ascii_letters + string.digits + "-_.% "
filename = ""
for i in range(1000):
if i % 10 == 0:
filename += "😀"
else:
filename += base[i % len(base)]
expected = "".join(base[i % len(base)] for i in range(1000) if i % 10 != 0)
codeflash_output = sanitize_filename(filename) # 35.1μs -> 27.8μs (26.1% faster)

def test_large_scale_filename_with_newlines():
# Large filename with lots of newlines
base = string.ascii_letters + string.digits + "-_.% "
filename = ""
for i in range(1000):
if i % 5 == 0:
filename += "\n"
else:
filename += base[i % len(base)]
expected = "".join(base[i % len(base)] for i in range(1000) if i % 5 != 0)
codeflash_output = sanitize_filename(filename) # 35.3μs -> 25.0μs (41.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-sanitize_filename-mhtylb1j and push.