⚡️ Speed up function _prepare_position by 6%

[codeflash-ai]

📄 6% (0.06x) speedup for _prepare_position in plotly/shapeannotation.py

⏱️ Runtime : 390 microseconds → 368 microseconds (best of 636 runs)

📝 Explanation and details

Here’s an optimized version of your Python program.
Optimizations:

• Avoid unnecessary string split if only "inside" or "outside" need to be checked.
• Avoid unnecessary conversion into a set unless needed.
• Avoid redundant string operations.
• Remove unused list/set objects in fast paths.
• in on string is faster than splitting it, where possible.

Explanation:

• Only split and convert position to set ONCE.
• If position is None, keep the set constant ({"top", "right"}) so no split needed.
• Directly check content for 'inside' and 'outside' as set, no unnecessary splitting or string ops.
• Fast-path for default value avoids repeated operations.

Behavior and return values preserved.

✅ Correctness verification report:

Test	Status
⚙️ Existing Unit Tests	🔘 None Found
🌀 Generated Regression Tests	✅ 41 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.shapeannotation import _prepare_position

# unit tests

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

def test_default_none_position():
    # When position is None, should default to "top right"
    pos, pos_str = _prepare_position(None)

def test_basic_position_no_prepend():
    # Basic usage, no prepend
    pos, pos_str = _prepare_position("bottom left")

def test_basic_position_with_prepend_inside():
    # Prepend inside when not present
    pos, pos_str = _prepare_position("top left", prepend_inside=True)

def test_basic_position_with_inside_already_present():
    # Prepend inside, but "inside" already present
    pos, pos_str = _prepare_position("inside top", prepend_inside=True)

def test_basic_position_with_outside_already_present():
    # Prepend inside, but "outside" already present
    pos, pos_str = _prepare_position("outside bottom", prepend_inside=True)

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

def test_empty_string_position():
    # Empty string as position
    pos, pos_str = _prepare_position("")

def test_empty_string_position_with_prepend():
    # Empty string as position, with prepend_inside
    pos, pos_str = _prepare_position("", prepend_inside=True)

def test_position_with_extra_spaces():
    # Position string with extra/multiple spaces
    pos, pos_str = _prepare_position("  top   right  ")

def test_position_with_only_spaces():
    # String with only spaces
    pos, pos_str = _prepare_position("   ")

def test_position_with_special_characters():
    # Position string with special characters
    pos, pos_str = _prepare_position("top-left @center")

def test_position_with_duplicate_words():
    # Position string with duplicate words
    pos, pos_str = _prepare_position("top top right right")

def test_position_with_inside_and_outside():
    # Both "inside" and "outside" present
    pos, pos_str = _prepare_position("inside outside", prepend_inside=True)

def test_position_case_sensitivity():
    # Should be case-sensitive
    pos, pos_str = _prepare_position("Inside Top", prepend_inside=True)

def test_position_is_only_inside():
    # Only "inside", with prepend_inside
    pos, pos_str = _prepare_position("inside", prepend_inside=True)

def test_position_is_only_outside():
    # Only "outside", with prepend_inside
    pos, pos_str = _prepare_position("outside", prepend_inside=True)

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

def test_large_number_of_words():
    # Large number of unique words
    words = [f"word{i}" for i in range(1000)]
    pos_str = " ".join(words)
    pos, returned_pos_str = _prepare_position(pos_str)

def test_large_number_of_duplicate_words():
    # Large number of duplicate words
    words = ["repeat"] * 1000
    pos_str = " ".join(words)
    pos, returned_pos_str = _prepare_position(pos_str)

def test_large_with_prepend_inside():
    # Large number of words, none of which are "inside" or "outside"
    words = [f"word{i}" for i in range(1000)]
    pos_str = " ".join(words)
    pos, returned_pos_str = _prepare_position(pos_str, prepend_inside=True)

def test_large_with_prepend_inside_already_present():
    # Large number of words, one of which is "inside"
    words = [f"word{i}" for i in range(999)] + ["inside"]
    pos_str = " ".join(words)
    pos, returned_pos_str = _prepare_position(pos_str, prepend_inside=True)

def test_large_with_prepend_outside_already_present():
    # Large number of words, one of which is "outside"
    words = [f"word{i}" for i in range(999)] + ["outside"]
    pos_str = " ".join(words)
    pos, returned_pos_str = _prepare_position(pos_str, prepend_inside=True)
# 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.shapeannotation import _prepare_position

# unit tests

# -------------------------
# 1. Basic Test Cases
# -------------------------

def test_default_position_when_none():
    # When position is None, should default to "top right"
    pos, pos_str = _prepare_position(None)

def test_basic_position_string():
    # Should split a simple position string into a set
    pos, pos_str = _prepare_position("bottom left")

def test_basic_position_with_prepend_inside():
    # Should add "inside" if not present and prepend_inside=True
    pos, pos_str = _prepare_position("top left", prepend_inside=True)

def test_position_with_inside_already_present():
    # Should not add "inside" again if already present
    pos, pos_str = _prepare_position("inside top left", prepend_inside=True)

def test_position_with_outside_already_present():
    # Should not add "inside" if "outside" present
    pos, pos_str = _prepare_position("outside bottom right", prepend_inside=True)

def test_position_with_prepend_inside_false():
    # Should not add "inside" if prepend_inside is False
    pos, pos_str = _prepare_position("top left", prepend_inside=False)

# -------------------------
# 2. Edge Test Cases
# -------------------------

def test_empty_string_position():
    # Should handle empty string gracefully
    pos, pos_str = _prepare_position("")

def test_empty_string_with_prepend_inside():
    # Should add "inside" to set containing empty string
    pos, pos_str = _prepare_position("", prepend_inside=True)

def test_position_with_extra_spaces():
    # Should handle extra spaces between words
    pos, pos_str = _prepare_position("  top   right  ")

def test_position_with_duplicate_words():
    # Should handle duplicate words in position string
    pos, pos_str = _prepare_position("top top right right")

def test_position_with_only_inside():
    # Should handle "inside" as the only word
    pos, pos_str = _prepare_position("inside", prepend_inside=True)

def test_position_with_only_outside():
    # Should handle "outside" as the only word
    pos, pos_str = _prepare_position("outside", prepend_inside=True)

def test_position_with_inside_and_outside():
    # Should handle both "inside" and "outside" present
    pos, pos_str = _prepare_position("inside outside", prepend_inside=True)

def test_position_with_nonstandard_words():
    # Should handle nonstandard words (not top/bottom/left/right/inside/outside)
    pos, pos_str = _prepare_position("foo bar baz", prepend_inside=True)

def test_position_with_numeric_strings():
    # Should handle numeric strings as words
    pos, pos_str = _prepare_position("123 456", prepend_inside=True)

def test_position_with_special_characters():
    # Should handle special characters in position string
    pos, pos_str = _prepare_position("!@# $%^", prepend_inside=True)

# -------------------------
# 3. Large Scale Test Cases
# -------------------------

def test_large_number_of_position_words():
    # Should handle a large number of words (<=1000)
    words = [f"word{i}" for i in range(1000)]
    position_str = " ".join(words)
    pos, pos_str = _prepare_position(position_str, prepend_inside=True)
    # All words should be present, plus "inside"
    expected = set(words)
    expected.add("inside")

def test_large_number_of_duplicate_words():
    # Should handle many duplicate words
    words = ["foo"] * 500 + ["bar"] * 500
    position_str = " ".join(words)
    pos, pos_str = _prepare_position(position_str, prepend_inside=True)

def test_performance_with_long_position_string():
    # Should not be too slow with long input
    words = [f"pos{i}" for i in range(999)]
    position_str = " ".join(words)
    pos, pos_str = _prepare_position(position_str, prepend_inside=True)
    # All words plus "inside"
    expected = set(words)
    expected.add("inside")

def test_large_scale_with_inside_already_present():
    # Should not add "inside" if already present in large set
    words = [f"word{i}" for i in range(999)] + ["inside"]
    position_str = " ".join(words)
    pos, pos_str = _prepare_position(position_str, prepend_inside=True)
    expected = set(words)

def test_large_scale_with_outside_already_present():
    # Should not add "inside" if "outside" present in large set
    words = [f"word{i}" for i in range(999)] + ["outside"]
    position_str = " ".join(words)
    pos, pos_str = _prepare_position(position_str, prepend_inside=True)
    expected = set(words)
# 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-_prepare_position-mb2cl0cu and push.