⚡️ Speed up function _validate_coerce_subplot_type by 61%

[codeflash-ai]

📄 61% (0.61x) speedup for _validate_coerce_subplot_type in plotly/_subplots.py

⏱️ Runtime : 25.2 milliseconds → 15.7 milliseconds (best of 51 runs)

📝 Explanation and details

Here is an optimized version of your code, keeping all function signatures and return values identical, and leaving all comments unchanged except where code is edited.
Key optimizations.

• Import expensive modules only once, not at function call time.
• Use early returns.
• Replace repeated attribute access with local variables.
• Replace try/except in a loop with set lookup.
• Eliminate unnecessary object property assignment.
• Inline string method and membership test for speed.

Key behavioral notes:

• All return values and error messages remain the same.
• Imports, especially of heavy modules, are moved out of the function.
• Attribute lookups and string operations are minimized in hot code paths.
• Preserves all comments relating to logical structure and intent.

This will yield a faster program, especially when these functions are called many times.

✅ Correctness verification report:

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

🌀 Generated Regression Tests Details

import pytest  # used for our unit tests
from plotly._subplots import _validate_coerce_subplot_type

# function to test
# Constants
# ---------
# Subplot types that are each individually positioned with a domain
#
# Each of these subplot types has a `domain` property with `x`/`y`
# properties.
# Note that this set does not contain `xaxis`/`yaxis` because these behave a
# little differently.

_single_subplot_types = {"scene", "geo", "polar", "ternary", "map", "mapbox"}
_subplot_types = set.union(_single_subplot_types, {"xy", "domain"})
from plotly._subplots import _validate_coerce_subplot_type

# unit tests

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

@pytest.mark.parametrize(
    "input_type,expected",
    [
        # Directly supported subplot types, lowercase
        ("scene", "scene"),
        ("geo", "geo"),
        ("polar", "polar"),
        ("ternary", "ternary"),
        ("map", "map"),
        ("mapbox", "mapbox"),
        ("xy", "xy"),
        ("domain", "domain"),
        # Directly supported subplot types, uppercase/mixed case
        ("SCENE", "scene"),
        ("Geo", "geo"),
        ("PoLaR", "polar"),
        ("TeRnArY", "ternary"),
        ("MAP", "map"),
        ("MapBox", "mapbox"),
        ("XY", "xy"),
        ("DOMAIN", "domain"),
    ]
)
def test_validate_coerce_subplot_type_direct(input_type, expected):
    """Test direct subplot types, case insensitivity."""
    codeflash_output = _validate_coerce_subplot_type(input_type)

@pytest.mark.parametrize(
    "trace_type,expected",
    [
        # Trace types that map to subplot types
        ("scatter3d", "scene"),
        ("SCATTER3D", "scene"),
        ("scattergeo", "geo"),
        ("scatterpolar", "polar"),
        ("scatterternary", "ternary"),
        ("scattermapbox", "mapbox"),
        ("scattermap", "map"),
        ("scatter", "xy"),
        ("heatmap", "xy"),
        ("pie", "domain"),
        ("bar", "xy"),
        ("surface", "scene"),
        ("choropleth", "geo"),
        ("sunburst", "domain"),
        ("sankey", "domain"),
        ("funnel", "xy"),
        ("parcoords", "domain"),
        ("parcats", "domain"),
    ]
)
def test_validate_coerce_subplot_type_trace(trace_type, expected):
    """Test valid trace types mapping to subplot types."""
    codeflash_output = _validate_coerce_subplot_type(trace_type)

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

def test_validate_coerce_subplot_type_invalid():
    """Test invalid subplot/trace types raise ValueError."""
    # Completely invalid string
    with pytest.raises(ValueError, match="Unsupported subplot type: 'notasubplot'"):
        _validate_coerce_subplot_type("notasubplot")
    # Empty string
    with pytest.raises(ValueError, match="Unsupported subplot type: ''"):
        _validate_coerce_subplot_type("")
    # Whitespace string
    with pytest.raises(ValueError, match="Unsupported subplot type: '   '"):
        _validate_coerce_subplot_type("   ")
    # None as input
    with pytest.raises(AttributeError):
        _validate_coerce_subplot_type(None)
    # Numeric input
    with pytest.raises(AttributeError):
        _validate_coerce_subplot_type(123)
    # Special characters
    with pytest.raises(ValueError, match=r"Unsupported subplot type: '@#$%'"):
        _validate_coerce_subplot_type("@#$%")

def test_validate_coerce_subplot_type_similar_names():
    """Test similar but invalid names."""
    with pytest.raises(ValueError, match="Unsupported subplot type: 'scen'"):
        _validate_coerce_subplot_type("scen")
    with pytest.raises(ValueError, match="Unsupported subplot type: 'geoo'"):
        _validate_coerce_subplot_type("geoo")
    with pytest.raises(ValueError, match="Unsupported subplot type: 'xyy'"):
        _validate_coerce_subplot_type("xyy")

def test_validate_coerce_subplot_type_case_preservation():
    """Test that the error message preserves the original case."""
    with pytest.raises(ValueError, match="Unsupported subplot type: 'SCaTtEr3D'"):
        _validate_coerce_subplot_type("SCaTtEr3D1")  # not in mapping

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

def test_validate_coerce_subplot_type_large_batch_valid():
    """Test a large batch of valid subplot types and trace types."""
    # Mix of subplot types and trace types, random casing
    valid_types = [
        "scene", "geo", "polar", "ternary", "map", "mapbox", "xy", "domain",
        "SCENE", "Geo", "PoLaR", "TeRnArY", "MAP", "MapBox", "XY", "DOMAIN",
        "scatter3d", "SCATTER3D", "scattergeo", "scatterpolar", "scatterternary",
        "scattermapbox", "scattermap", "scatter", "heatmap", "pie", "bar", "surface",
        "choropleth", "sunburst", "sankey", "funnel", "parcoords", "parcats"
    ]
    # Repeat to make a list of 500 elements
    test_list = valid_types * (500 // len(valid_types))
    for t in test_list:
        # Should not raise and should return a valid subplot type
        codeflash_output = _validate_coerce_subplot_type(t); result = codeflash_output

def test_validate_coerce_subplot_type_large_batch_invalid():
    """Test a large batch of invalid subplot types."""
    invalid_types = [
        "scen", "geoo", "polarr", "ternarry", "mapp", "mapboxx", "xyy", "domaiin",
        "scatter3d1", "scattergeoo", "scatterpolarr", "scatterternarry", "scattermapboxx",
        "scattermapp", "scatterr", "heatmaap", "piee", "barr", "surfacee", "choroplethh",
        "sunburrst", "sankkey", "funnell", "parcoordss", "parcatss"
    ]
    # Repeat to make a list of 200 elements
    test_list = invalid_types * (200 // len(invalid_types))
    for t in test_list:
        with pytest.raises(ValueError):
            _validate_coerce_subplot_type(t)

def test_validate_coerce_subplot_type_performance():
    """Test that function does not slow down considerably with 1000 elements."""
    # Use only valid types for this test
    valid_types = [
        "scene", "geo", "polar", "ternary", "map", "mapbox", "xy", "domain",
        "scatter3d", "scattergeo", "scatterpolar", "scatterternary",
        "scattermapbox", "scattermap", "scatter", "heatmap", "pie", "bar", "surface",
        "choropleth", "sunburst", "sankey", "funnel", "parcoords", "parcats"
    ]
    test_list = valid_types * (1000 // len(valid_types))
    # Should complete quickly and all results are valid
    results = [_validate_coerce_subplot_type(t) for t in test_list]
# 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 plotly._subplots import _validate_coerce_subplot_type

# function to test
# Constants
# ---------
# Subplot types that are each individually positioned with a domain
#
# Each of these subplot types has a `domain` property with `x`/`y`
# properties.
# Note that this set does not contain `xaxis`/`yaxis` because these behave a
# little differently.

_single_subplot_types = {"scene", "geo", "polar", "ternary", "map", "mapbox"}
_subplot_types = set.union(_single_subplot_types, {"xy", "domain"})
from plotly._subplots import _validate_coerce_subplot_type

# unit tests

# 1. Basic Test Cases

@pytest.mark.parametrize(
    "input_type,expected",
    [
        # Direct subplot types
        ("scene", "scene"),
        ("geo", "geo"),
        ("polar", "polar"),
        ("ternary", "ternary"),
        ("map", "map"),
        ("mapbox", "mapbox"),
        ("xy", "xy"),
        ("domain", "domain"),
        # Case insensitivity
        ("SCENE", "scene"),
        ("Geo", "geo"),
        ("PoLaR", "polar"),
        # Trace types mapping to subplot types
        ("scatter", "xy"),
        ("scattergl", "xy"),
        ("bar", "xy"),
        ("histogram", "xy"),
        ("scatter3d", "scene"),
        ("surface", "scene"),
        ("mesh3d", "scene"),
        ("scattergeo", "geo"),
        ("choropleth", "geo"),
        ("scatterpolar", "polar"),
        ("barpolar", "polar"),
        ("scatterternary", "ternary"),
        ("scattermapbox", "mapbox"),
        ("densitymapbox", "mapbox"),
        ("scattermap", "map"),
        ("pie", "domain"),
        ("funnelarea", "domain"),
        ("sunburst", "domain"),
        ("treemap", "domain"),
    ]
)
def test_validate_coerce_subplot_type_basic(input_type, expected):
    # Test that known subplot and trace types are correctly recognized
    codeflash_output = _validate_coerce_subplot_type(input_type)


# 2. Edge Test Cases

@pytest.mark.parametrize(
    "input_type",
    [
        "",              # Empty string
        " ",             # Whitespace
        "unknown",       # Completely unknown type
        "scatter4d",     # Nonexistent trace type
        "scatTer3",      # Looks like a typo
        None,            # None as input
        123,             # Non-string input (int)
        12.5,            # Non-string input (float)
        object(),        # Non-string, non-numeric input
        "xyxy",          # Similar to valid type but not valid
        "domain2",       # Invalid variant
        "mapboxx",       # Typo
    ]
)
def test_validate_coerce_subplot_type_invalid(input_type):
    # All of these should raise ValueError for unsupported subplot type
    with pytest.raises(ValueError):
        _validate_coerce_subplot_type(input_type)


def test_validate_coerce_subplot_type_strips_case_and_ignores_whitespace():
    # Leading/trailing whitespace with valid types should still work
    codeflash_output = _validate_coerce_subplot_type("  scene  ")
    codeflash_output = _validate_coerce_subplot_type("\tgeo\n")
    # But whitespace-only should fail
    with pytest.raises(ValueError):
        _validate_coerce_subplot_type("   ")


def test_validate_coerce_subplot_type_non_string_input():
    # Non-string inputs should raise (since .lower() will fail)
    with pytest.raises(AttributeError):
        _validate_coerce_subplot_type(123)
    with pytest.raises(AttributeError):
        _validate_coerce_subplot_type(None)
    with pytest.raises(AttributeError):
        _validate_coerce_subplot_type(object())


def test_validate_coerce_subplot_type_case_insensitivity():
    # Mix of upper/lower case for valid types
    codeflash_output = _validate_coerce_subplot_type("SCENE")
    codeflash_output = _validate_coerce_subplot_type("Geo")
    codeflash_output = _validate_coerce_subplot_type("PoLaR")
    codeflash_output = _validate_coerce_subplot_type("SCATTER3D")
    codeflash_output = _validate_coerce_subplot_type("Pie")


# 3. Large Scale Test Cases


def test_validate_coerce_subplot_type_large_batch_invalid():
    # Test a large batch of invalid types
    invalid_types = ["invalidtype{}".format(i) for i in range(100)]
    for t in invalid_types:
        with pytest.raises(ValueError):
            _validate_coerce_subplot_type(t)


def test_validate_coerce_subplot_type_performance_large():
    # Test function on a large batch of mixed valid/invalid types
    valid_types = [
        "scene", "geo", "polar", "ternary", "map", "mapbox", "xy", "domain",
        "scatter", "bar", "histogram", "scatter3d", "surface", "mesh3d",
        "scattergeo", "choropleth", "scatterpolar", "barpolar", "scatterternary",
        "scattermapbox", "densitymapbox", "scattermap", "pie", "funnelarea",
        "sunburst", "treemap"
    ]
    invalid_types = ["badtype{}".format(i) for i in range(100)]
    # Mix them together
    mixed = []
    for i in range(500):
        if i % 2 == 0:
            mixed.append(valid_types[i % len(valid_types)])
        else:
            mixed.append(invalid_types[i % len(invalid_types)])

    # For valid types, should not raise
    for i in range(0, len(mixed), 2):
        codeflash_output = _validate_coerce_subplot_type(mixed[i])
    # For invalid types, should raise
    for i in range(1, len(mixed), 2):
        with pytest.raises(ValueError):
            _validate_coerce_subplot_type(mixed[i])
# 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_subplot_type-mb2hainm and push.