Thanks to visit codestin.com
Credit goes to github.com

Skip to content

⚡️ Speed up function _prepare_position by 6% #108

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom
Open
wants to merge 1 commit into
base: main
Choose a base branch
from
Open

⚡️ Speed up function _prepare_position by 6% #108

wants to merge 1 commit into from

Conversation

codeflash-ai[bot]
Copy link

@codeflash-ai codeflash-ai bot commented May 24, 2025

📄 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.

Codeflash

@codeflash-ai
⚡️ Speed up function _prepare_position by 6%
42cd6d9 
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.
@codeflash-ai codeflash-ai bot added the ⚡️ codeflash Optimization PR opened by Codeflash AI label May 24, 2025
@codeflash-ai codeflash-ai bot requested a review from misrasaurabh1 May 24, 2025 14:51
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
Reviewers

@misrasaurabh1 misrasaurabh1 Awaiting requested review from misrasaurabh1

Assignees
No one assigned
Labels
⚡️ codeflash Optimization PR opened by Codeflash AI
Projects
None yet
Milestone
No milestone
Development

Successfully merging this pull request may close these issues.
0 participants