⚡️ Speed up function validate_coerce_format by 13%

[codeflash-ai]

📄 13% (0.13x) speedup for validate_coerce_format in plotly/io/_orca.py

⏱️ Runtime : 5.19 milliseconds → 4.59 milliseconds (best of 78 runs)

📝 Explanation and details

The optimized code achieves a 12% speedup through two key optimizations:

1. Reduced String Formatting Overhead in Error Messages

• Changed valid_formats=sorted(format_conversions.keys()) to valid_formats=', '.join(sorted(format_conversions.keys()))
• This pre-formats the valid formats as a comma-separated string instead of letting Python's string formatter handle list conversion, reducing formatting overhead when exceptions are raised

2. Optimized String Processing Logic

• Added fmt_len = len(fmt) to avoid multiple length calculations
• Reorganized the dot-stripping and lowercasing logic to call .lower() only once per execution path
• Original code always called fmt.lower() early, then potentially stripped the dot, requiring string operations on already-processed strings
• Optimized version strips the dot first (if present), then applies .lower() only once, reducing string allocations

Performance Benefits by Test Case:

• Error cases see the biggest gains (5-21% faster): Invalid formats, non-string types, and malformed inputs benefit most from the streamlined string processing
• Valid format cases are slightly slower (10-15% slower): The additional length check adds minor overhead for successful validations
• Large-scale operations show mixed results: Error-heavy workloads benefit significantly, while valid-format-heavy workloads see modest slowdowns

The optimization particularly excels when handling invalid inputs (which trigger exceptions) while maintaining identical correctness for all valid inputs.

✅ Correctness verification report:

Test	Status
⚙️ Existing Unit Tests	🔘 None Found
🌀 Generated Regression Tests	✅ 8012 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 plotly.io._orca import validate_coerce_format

# function to test
# Valid image format constants
# ----------------------------

valid_formats = ("png", "jpeg", "webp", "svg", "pdf", "eps")
format_conversions = {fmt: fmt for fmt in valid_formats}
from plotly.io._orca import validate_coerce_format

# unit tests

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

def test_none_input_returns_none():
    """Test that None input returns None."""
    codeflash_output = validate_coerce_format(None) # 363ns -> 367ns (1.09% slower)

@pytest.mark.parametrize("fmt", valid_formats)
def test_valid_formats_lowercase(fmt):
    """Test that valid lowercase formats are accepted and returned as is."""
    codeflash_output = validate_coerce_format(fmt) # 5.97μs -> 7.03μs (15.0% slower)

@pytest.mark.parametrize("fmt", valid_formats)
def test_valid_formats_uppercase(fmt):
    """Test that valid uppercase formats are accepted and returned as lowercase."""
    codeflash_output = validate_coerce_format(fmt.upper()) # 5.67μs -> 6.39μs (11.3% slower)

@pytest.mark.parametrize("fmt", valid_formats)
def test_valid_formats_mixed_case(fmt):
    """Test that valid mixed-case formats are accepted and returned as lowercase."""
    mixed = fmt.capitalize()
    codeflash_output = validate_coerce_format(mixed) # 5.86μs -> 6.58μs (10.9% slower)

@pytest.mark.parametrize("fmt", valid_formats)
def test_valid_formats_with_leading_dot(fmt):
    """Test that valid formats with leading dot are accepted and returned without dot."""
    codeflash_output = validate_coerce_format(f".{fmt}") # 6.80μs -> 8.03μs (15.3% slower)

@pytest.mark.parametrize("fmt", valid_formats)
def test_valid_formats_with_leading_dot_and_uppercase(fmt):
    """Test that valid formats with leading dot and uppercase are accepted and returned as lowercase."""
    codeflash_output = validate_coerce_format(f".{fmt.upper()}") # 6.45μs -> 7.64μs (15.6% slower)

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

def test_empty_string_raises():
    """Test that empty string input raises ValueError."""
    with pytest.raises(ValueError):
        validate_coerce_format("") # 6.93μs -> 5.72μs (21.1% faster)

@pytest.mark.parametrize("fmt", ["JPG", ".JPG", "jpg", ".jpg"])
def test_jpg_is_invalid(fmt):
    """Test that 'jpg' and its variants are NOT accepted (only 'jpeg' is valid)."""
    with pytest.raises(ValueError):
        validate_coerce_format(fmt)

@pytest.mark.parametrize("fmt", ["tiff", ".tiff", "bmp", ".bmp", "gif", ".gif"])
def test_invalid_formats_raise(fmt):
    """Test that completely invalid formats raise ValueError."""
    with pytest.raises(ValueError):
        validate_coerce_format(fmt) # 34.7μs -> 32.3μs (7.60% faster)

@pytest.mark.parametrize("fmt", [123, 0.5, [], {}, (), True, False])
def test_non_string_types_raise(fmt):
    """Test that non-string types raise ValueError."""
    with pytest.raises(ValueError):
        validate_coerce_format(fmt) # 37.4μs -> 35.4μs (5.83% faster)

def test_string_with_multiple_leading_dots():
    """Test that string with multiple leading dots is invalid."""
    with pytest.raises(ValueError):
        validate_coerce_format("..png") # 5.50μs -> 5.24μs (4.96% faster)

def test_string_with_trailing_dot():
    """Test that string with trailing dot is invalid."""
    with pytest.raises(ValueError):
        validate_coerce_format("png.") # 4.95μs -> 4.79μs (3.30% faster)

def test_string_with_spaces():
    """Test that string with spaces is invalid."""
    with pytest.raises(ValueError):
        validate_coerce_format(" png ") # 4.81μs -> 4.66μs (3.33% faster)
    with pytest.raises(ValueError):
        validate_coerce_format(". png") # 3.07μs -> 2.93μs (4.75% faster)

def test_string_with_embedded_null_char():
    """Test that string with embedded null character is invalid."""
    with pytest.raises(ValueError):
        validate_coerce_format("pn\x00g") # 4.54μs -> 4.19μs (8.38% faster)

def test_string_with_leading_and_trailing_whitespace():
    """Test that string with leading/trailing whitespace is invalid."""
    with pytest.raises(ValueError):
        validate_coerce_format(" png") # 4.36μs -> 4.13μs (5.64% faster)
    with pytest.raises(ValueError):
        validate_coerce_format("png ") # 2.61μs -> 2.43μs (7.57% faster)

def test_string_with_leading_dot_and_trailing_dot():
    """Test that string with both leading and trailing dots is invalid."""
    with pytest.raises(ValueError):
        validate_coerce_format(".png.") # 4.35μs -> 4.48μs (2.84% slower)

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

def test_large_list_of_valid_formats():
    """Test that a large list of valid formats all pass."""
    for fmt in valid_formats * 100:  # 600 elements
        codeflash_output = validate_coerce_format(fmt) # 145μs -> 156μs (6.84% slower)

def test_large_list_of_valid_formats_with_dot_and_case():
    """Test that a large list of valid formats with leading dot and mixed case all pass."""
    for i, fmt in enumerate(valid_formats * 100):  # 600 elements
        # alternate between uppercase and lowercase and leading dot
        if i % 2 == 0:
            val = "." + fmt.upper()
        else:
            val = "." + fmt.lower()
        codeflash_output = validate_coerce_format(val) # 164μs -> 179μs (8.51% slower)

def test_large_list_of_invalid_formats():
    """Test that a large list of invalid formats all raise ValueError."""
    invalids = ["tiff", "bmp", "gif", "jpg", "JPG", "Jpeg2000", "PNG8", "svgz", "pdfa"]
    for fmt in invalids * 100:  # 900 elements
        with pytest.raises(ValueError):
            validate_coerce_format(fmt)

def test_large_list_of_none():
    """Test that a large list of None inputs all return None."""
    for _ in range(1000):
        codeflash_output = validate_coerce_format(None) # 111μs -> 114μs (2.61% slower)

def test_large_list_of_non_string_types():
    """Test that a large list of non-string types all raise ValueError."""
    invalids = [123, 0.5, [], {}, (), True, False]
    for fmt in invalids * 100:  # 700 elements
        with pytest.raises(ValueError):
            validate_coerce_format(fmt)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
import pytest
from plotly.io._orca import validate_coerce_format

# function to test
# Valid image format constants
valid_formats = ("png", "jpeg", "webp", "svg", "pdf", "eps")
format_conversions = {fmt: fmt for fmt in valid_formats}
from plotly.io._orca import validate_coerce_format

# unit tests

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

def test_none_input_returns_none():
    # None should pass through unchanged
    codeflash_output = validate_coerce_format(None) # 361ns -> 362ns (0.276% slower)

@pytest.mark.parametrize("fmt", ["png", "jpeg", "webp", "svg", "pdf", "eps"])
def test_valid_formats_lowercase(fmt):
    # Lowercase valid formats should return themselves
    codeflash_output = validate_coerce_format(fmt) # 6.29μs -> 7.22μs (12.8% slower)

@pytest.mark.parametrize("fmt,expected", [
    ("PNG", "png"),
    ("JpEg", "jpeg"),
    ("WEBP", "webp"),
    ("SVG", "svg"),
    ("PDF", "pdf"),
    ("EPS", "eps"),
])
def test_valid_formats_uppercase_and_mixed(fmt, expected):
    # Uppercase and mixed case should be converted to lowercase
    codeflash_output = validate_coerce_format(fmt) # 5.79μs -> 6.71μs (13.6% slower)

@pytest.mark.parametrize("fmt,expected", [
    (".png", "png"),
    (".JPEG", "jpeg"),
    (".webp", "webp"),
    (".Svg", "svg"),
    (".pdf", "pdf"),
    (".EPS", "eps"),
])
def test_valid_formats_with_leading_dot(fmt, expected):
    # Leading dot should be stripped and format coerced to lowercase
    codeflash_output = validate_coerce_format(fmt) # 6.76μs -> 7.87μs (14.1% slower)

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

@pytest.mark.parametrize("fmt", [
    "",  # empty string
    " ",  # whitespace
    ".jpg",  # jpg is not a valid format
    "jpg",   # jpg is not a valid format
    "tiff",  # not a valid format
    ".tiff", # not a valid format
    "PNG ",  # trailing space
    " png",  # leading space
    "pn g",  # embedded space
    "jpeg2", # invalid suffix
    "svgz",  # invalid format
])
def test_invalid_strings_raise(fmt):
    # These strings should raise ValueError
    with pytest.raises(ValueError):
        validate_coerce_format(fmt) # 52.9μs -> 48.8μs (8.40% faster)

@pytest.mark.parametrize("fmt", [
    123,             # integer
    12.3,            # float
    [],              # list
    {},              # dict
    set(),           # set
    (1, 2),          # tuple
    True,            # boolean
    False,           # boolean
    object(),        # generic object
])
def test_non_string_types_raise(fmt):
    # Non-string types should raise ValueError
    with pytest.raises(ValueError):
        validate_coerce_format(fmt) # 48.5μs -> 45.6μs (6.37% faster)

def test_string_with_multiple_leading_dots():
    # Only one leading dot is stripped, so '..png' is invalid
    with pytest.raises(ValueError):
        validate_coerce_format("..png") # 5.58μs -> 5.29μs (5.45% faster)

def test_string_with_trailing_dot():
    # 'png.' is not valid
    with pytest.raises(ValueError):
        validate_coerce_format("png.") # 4.96μs -> 4.71μs (5.46% faster)

def test_string_with_leading_and_trailing_whitespace():
    # Whitespace is not stripped, so ' png' and 'png ' are invalid
    with pytest.raises(ValueError):
        validate_coerce_format(" png") # 4.93μs -> 4.64μs (6.31% faster)
    with pytest.raises(ValueError):
        validate_coerce_format("png ") # 2.83μs -> 2.52μs (12.0% faster)

def test_string_with_embedded_null_char():
    # Embedded null character is not valid
    with pytest.raises(ValueError):
        validate_coerce_format("pn\x00g") # 4.50μs -> 4.18μs (7.48% faster)

def test_string_with_unicode_characters():
    # Unicode characters should not be valid unless they match
    with pytest.raises(ValueError):
        validate_coerce_format("pñg") # 5.81μs -> 5.56μs (4.59% faster)
    with pytest.raises(ValueError):
        validate_coerce_format(".jpeɡ") # 4.25μs -> 4.03μs (5.46% faster)

def test_string_with_long_length():
    # Excessively long but invalid format
    long_invalid = "p" * 100
    with pytest.raises(ValueError):
        validate_coerce_format(long_invalid) # 4.79μs -> 4.45μs (7.78% faster)

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

def test_large_list_of_valid_formats():
    # Make a list of 1000 valid formats (cycling through valid ones)
    formats = [fmt for fmt in valid_formats]
    for i in range(1000):
        fmt = formats[i % len(formats)]
        # Should not raise and return the correct format
        codeflash_output = validate_coerce_format(fmt) # 244μs -> 258μs (5.11% slower)

def test_large_list_of_invalid_formats():
    # Make a list of 1000 invalid formats
    invalid_formats = ["invalid{}".format(i) for i in range(1000)]
    for fmt in invalid_formats:
        with pytest.raises(ValueError):
            validate_coerce_format(fmt)

def test_large_list_of_mixed_valid_and_invalid_formats():
    # Mix valid and invalid formats
    mixed_formats = []
    for i in range(1000):
        if i % 2 == 0:
            mixed_formats.append(valid_formats[i % len(valid_formats)])
        else:
            mixed_formats.append("badformat{}".format(i))
    for i, fmt in enumerate(mixed_formats):
        if i % 2 == 0:
            codeflash_output = validate_coerce_format(fmt)
        else:
            with pytest.raises(ValueError):
                validate_coerce_format(fmt)

def test_large_list_of_formats_with_leading_dot():
    # 1000 valid formats with leading dot
    for i in range(1000):
        fmt = "." + valid_formats[i % len(valid_formats)]
        expected = valid_formats[i % len(valid_formats)]
        codeflash_output = validate_coerce_format(fmt) # 274μs -> 296μs (7.39% slower)

def test_large_list_of_none_inputs():
    # 1000 None inputs should all return None
    for _ in range(1000):
        codeflash_output = validate_coerce_format(None) # 110μs -> 114μs (3.34% slower)

# ----------- Mutation-sensitive Tests -----------


def test_valid_formats_are_not_stripped_of_internal_spaces():
    # 'pn g' is not valid
    with pytest.raises(ValueError):
        validate_coerce_format("pn g") # 7.64μs -> 6.85μs (11.4% faster)

def test_leading_period_only_stripped_once():
    # '..png' is not valid
    with pytest.raises(ValueError):
        validate_coerce_format("..png") # 5.94μs -> 5.61μs (6.01% faster)

def test_empty_string_raises():
    # Empty string should raise
    with pytest.raises(ValueError):
        validate_coerce_format("") # 4.97μs -> 4.62μs (7.55% faster)

def test_whitespace_string_raises():
    # Whitespace only string should raise
    with pytest.raises(ValueError):
        validate_coerce_format("   ") # 5.33μs -> 4.97μs (7.16% 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-validate_coerce_format-mhgexa6s and push.