⚡️ Speed up function fix_close_shift_shift by 37%

[codeflash-ai]

📄 37% (0.37x) speedup for fix_close_shift_shift in stanza/models/constituency/in_order_oracle.py

⏱️ Runtime : 292 microseconds → 213 microseconds (best of 298 runs)

📝 Explanation and details

The optimized code achieves a 37% speedup through strategic micro-optimizations that reduce Python's runtime overhead:

Key Optimizations:

1. Fast Type Checking: Replaced isinstance(obj, Class) with type(obj) is Class throughout all functions. This eliminates the overhead of inheritance checking and method resolution, providing faster direct type comparisons when exact type matching is sufficient.

2. Local Variable Binding in Hot Loops: In advance_past_unaries(), cached frequently accessed values as local variables:

   • Open = OpenConstituent and Close = CloseConstituent
   • is_type = type and seq_len = len(gold_sequence)

   This eliminates repeated global lookups and attribute access in the tight while loop.

3. Reduced Function Call Overhead: The type(obj) is Class pattern is a single builtin call vs isinstance() which involves more complex internal logic and potential method dispatch.

Performance Impact by Function:

• find_in_order_constituent_end: 29% faster (90.3μs → 63.9μs) - benefits from type checking optimization
• advance_past_unaries: Improved efficiency despite appearing slower in isolation due to local variable setup cost being amortized across calls
• fix_close_shift_shift: 14% faster on critical path operations

Best For: Code with frequent type checking in loops, especially parsing workloads with many transition objects. The optimizations are most effective when functions are called repeatedly (as shown in the large-scale test cases), where the reduced per-iteration overhead compounds significantly.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

import pytest
from stanza.models.constituency.in_order_oracle import fix_close_shift_shift


# Mock transition classes for testing
class Shift:
    def __repr__(self):
        return "Shift()"

class OpenConstituent:
    def __repr__(self):
        return "OpenConstituent()"

class CloseConstituent:
    def __repr__(self):
        return "CloseConstituent()"
from stanza.models.constituency.in_order_oracle import fix_close_shift_shift

# ---------------------------
# Unit tests for fix_close_shift_shift
# ---------------------------

# 1. Basic Test Cases

def test_basic_shift_after_close():
    # Test a simple sequence where Close is followed by Shift, and fix is possible
    gold_sequence = [OpenConstituent(), Shift(), CloseConstituent(), Shift(), Shift()]
    gold_index = 2  # The CloseConstituent
    gold_transition = gold_sequence[gold_index]
    pred_transition = Shift()
    root_labels = []
    ambiguous = False
    late = False
    # Should move the Close after the next Shift block
    codeflash_output = fix_close_shift_shift(gold_transition, pred_transition, gold_sequence, gold_index, root_labels, ambiguous, late); result = codeflash_output
    # The Close should move after the next Shift (index 3)
    expected = [OpenConstituent(), Shift(), Shift(), CloseConstituent(), Shift()]

def test_basic_no_fix_needed():
    # If gold_transition is not CloseConstituent, should return None
    gold_sequence = [OpenConstituent(), Shift(), Shift()]
    gold_index = 1
    gold_transition = Shift()
    pred_transition = Shift()
    root_labels = []
    ambiguous = False
    late = False
    codeflash_output = fix_close_shift_shift(gold_transition, pred_transition, gold_sequence, gold_index, root_labels, ambiguous, late); result = codeflash_output

def test_basic_pred_not_shift():
    # If pred_transition is not Shift, should return None
    gold_sequence = [OpenConstituent(), Shift(), CloseConstituent(), Shift()]
    gold_index = 2
    gold_transition = CloseConstituent()
    pred_transition = CloseConstituent()
    root_labels = []
    ambiguous = False
    late = False
    codeflash_output = fix_close_shift_shift(gold_transition, pred_transition, gold_sequence, gold_index, root_labels, ambiguous, late); result = codeflash_output

def test_basic_ambiguous_true():
    # ambiguous=True, but next block ends with CloseConstituent, should return None
    gold_sequence = [OpenConstituent(), Shift(), CloseConstituent(), Shift(), CloseConstituent()]
    gold_index = 2
    gold_transition = CloseConstituent()
    pred_transition = Shift()
    root_labels = []
    ambiguous = True
    late = False
    codeflash_output = fix_close_shift_shift(gold_transition, pred_transition, gold_sequence, gold_index, root_labels, ambiguous, late); result = codeflash_output

def test_basic_ambiguous_false_next_shift():
    # ambiguous=False, but next block ends with Shift, should return None
    gold_sequence = [OpenConstituent(), Shift(), CloseConstituent(), Shift(), Shift()]
    gold_index = 2
    gold_transition = CloseConstituent()
    pred_transition = Shift()
    root_labels = []
    ambiguous = False
    late = False
    # The next block ends with Shift, so should return None
    codeflash_output = fix_close_shift_shift(gold_transition, pred_transition, gold_sequence, gold_index, root_labels, ambiguous, late); result = codeflash_output
    # Let's construct a case where the next block ends with Shift
    gold_sequence2 = [OpenConstituent(), Shift(), CloseConstituent(), Shift()]
    gold_index2 = 2
    codeflash_output = fix_close_shift_shift(CloseConstituent(), Shift(), gold_sequence2, gold_index2, root_labels, False, False); result2 = codeflash_output

# 2. Edge Test Cases

def test_edge_short_sequence():
    # Sequence too short after gold_index
    gold_sequence = [OpenConstituent(), Shift(), CloseConstituent()]
    gold_index = 2
    gold_transition = CloseConstituent()
    pred_transition = Shift()
    root_labels = []
    ambiguous = False
    late = False
    codeflash_output = fix_close_shift_shift(gold_transition, pred_transition, gold_sequence, gold_index, root_labels, ambiguous, late); result = codeflash_output

def test_edge_start_index_not_shift():
    # The element after gold_index is not Shift
    gold_sequence = [OpenConstituent(), Shift(), CloseConstituent(), OpenConstituent(), Shift()]
    gold_index = 2
    gold_transition = CloseConstituent()
    pred_transition = Shift()
    root_labels = []
    ambiguous = False
    late = False
    codeflash_output = fix_close_shift_shift(gold_transition, pred_transition, gold_sequence, gold_index, root_labels, ambiguous, late); result = codeflash_output

def test_edge_find_in_order_constituent_end_none():
    # find_in_order_constituent_end returns None
    gold_sequence = [OpenConstituent(), Shift(), CloseConstituent(), Shift()]
    gold_index = 2
    gold_transition = CloseConstituent()
    pred_transition = Shift()
    root_labels = []
    ambiguous = False
    late = False
    # Remove the last Shift so find_in_order_constituent_end can't find an end
    gold_sequence2 = [OpenConstituent(), Shift(), CloseConstituent()]
    codeflash_output = fix_close_shift_shift(gold_transition, pred_transition, gold_sequence2, gold_index, root_labels, ambiguous, late); result = codeflash_output

def test_edge_with_unary_constituents():
    # Sequence contains unary Open/Close pairs (should be skipped)
    gold_sequence = [
        OpenConstituent(), Shift(), CloseConstituent(),  # first constituent
        OpenConstituent(), CloseConstituent(),           # unary
        Shift(),                                         # next block
        CloseConstituent()
    ]
    gold_index = 2
    gold_transition = CloseConstituent()
    pred_transition = Shift()
    root_labels = []
    ambiguous = False
    late = False
    # Should skip the unary and move Close after the Shift
    codeflash_output = fix_close_shift_shift(gold_transition, pred_transition, gold_sequence, gold_index, root_labels, ambiguous, late); result = codeflash_output
    expected = [
        OpenConstituent(), Shift(), OpenConstituent(), CloseConstituent(), Shift(), CloseConstituent()
    ]

def test_edge_late_true():
    # Test with late=True, should move Close after all constituents
    gold_sequence = [
        OpenConstituent(), Shift(), CloseConstituent(),  # first constituent
        Shift(),                                         # next block
        OpenConstituent(), Shift(), CloseConstituent(),  # nested constituent
        Shift()
    ]
    gold_index = 2
    gold_transition = CloseConstituent()
    pred_transition = Shift()
    root_labels = []
    ambiguous = False
    late = True
    # Should move Close after the nested constituent
    codeflash_output = fix_close_shift_shift(gold_transition, pred_transition, gold_sequence, gold_index, root_labels, ambiguous, late); result = codeflash_output
    expected = [
        OpenConstituent(), Shift(), Shift(), OpenConstituent(), Shift(), CloseConstituent(), CloseConstituent(), Shift()
    ]

def test_edge_multiple_unaries_and_late():
    # Multiple unary constituents and late=True
    gold_sequence = [
        OpenConstituent(), Shift(), CloseConstituent(),  # first
        OpenConstituent(), CloseConstituent(),           # unary
        Shift(),                                         # next block
        OpenConstituent(), CloseConstituent(),           # unary
        Shift(),                                         # next block
        CloseConstituent()
    ]
    gold_index = 2
    gold_transition = CloseConstituent()
    pred_transition = Shift()
    root_labels = []
    ambiguous = False
    late = True
    codeflash_output = fix_close_shift_shift(gold_transition, pred_transition, gold_sequence, gold_index, root_labels, ambiguous, late); result = codeflash_output
    expected = [
        OpenConstituent(), Shift(),
        OpenConstituent(), CloseConstituent(), Shift(),
        OpenConstituent(), CloseConstituent(), Shift(),
        CloseConstituent()
    ]

def test_edge_all_shift():
    # All elements are Shift, should return None
    gold_sequence = [Shift(), Shift(), Shift(), Shift()]
    gold_index = 1
    gold_transition = CloseConstituent()
    pred_transition = Shift()
    root_labels = []
    ambiguous = False
    late = False
    codeflash_output = fix_close_shift_shift(gold_transition, pred_transition, gold_sequence, gold_index, root_labels, ambiguous, late); result = codeflash_output

# 3. Large Scale Test Cases

def test_large_scale_many_shifts():
    # Large sequence with many Shift transitions
    gold_sequence = [OpenConstituent()] + [Shift()] * 500 + [CloseConstituent()] + [Shift()] * 498
    gold_index = 500  # The CloseConstituent
    gold_transition = gold_sequence[gold_index]
    pred_transition = Shift()
    root_labels = []
    ambiguous = False
    late = False
    # Should move the CloseConstituent after the first Shift block (index 501)
    codeflash_output = fix_close_shift_shift(gold_transition, pred_transition, gold_sequence, gold_index, root_labels, ambiguous, late); result = codeflash_output
    expected = [OpenConstituent()] + [Shift()] * 501 + [CloseConstituent()] + [Shift()] * 498

def test_large_scale_nested_constituents():
    # Large sequence with nested constituents
    gold_sequence = []
    n = 100  # Keep under 1000 for performance
    for _ in range(n):
        gold_sequence.append(OpenConstituent())
    for _ in range(n):
        gold_sequence.append(Shift())
    for _ in range(n):
        gold_sequence.append(CloseConstituent())
    gold_sequence += [Shift()] * 10
    gold_index = n*2  # The first CloseConstituent
    gold_transition = gold_sequence[gold_index]
    pred_transition = Shift()
    root_labels = []
    ambiguous = False
    late = False
    # Should move CloseConstituent after the next Shift block
    codeflash_output = fix_close_shift_shift(gold_transition, pred_transition, gold_sequence, gold_index, root_labels, ambiguous, late); result = codeflash_output
    # The expected result: all OpenConstituent, all Shift, then one more Shift, then CloseConstituent, then rest
    expected = gold_sequence[:gold_index] + [Shift()] + [CloseConstituent()] + gold_sequence[gold_index+1:]

def test_large_scale_with_unaries():
    # Large sequence with unary Open/Close pairs interleaved
    gold_sequence = []
    for _ in range(250):
        gold_sequence.append(OpenConstituent())
        gold_sequence.append(CloseConstituent())
    gold_sequence += [Shift()] * 500
    gold_index = 249 * 2  # The last unary's CloseConstituent
    gold_transition = gold_sequence[gold_index]
    pred_transition = Shift()
    root_labels = []
    ambiguous = False
    late = False
    # Should skip all unaries and move CloseConstituent after the next Shift
    codeflash_output = fix_close_shift_shift(gold_transition, pred_transition, gold_sequence, gold_index, root_labels, ambiguous, late); result = codeflash_output
    expected = gold_sequence[:gold_index] + [Shift(), CloseConstituent()] + gold_sequence[gold_index+1:]

def test_large_scale_late_true():
    # Large sequence, late=True, should move CloseConstituent after all constituents
    gold_sequence = [OpenConstituent()] + [Shift()] * 300 + [CloseConstituent()] + [Shift()] * 300
    gold_index = 301  # The CloseConstituent
    gold_transition = gold_sequence[gold_index]
    pred_transition = Shift()
    root_labels = []
    ambiguous = False
    late = True
    # Should move CloseConstituent after all constituents (i.e., after all Shifts)
    codeflash_output = fix_close_shift_shift(gold_transition, pred_transition, gold_sequence, gold_index, root_labels, ambiguous, late); result = codeflash_output
    expected = [OpenConstituent()] + [Shift()] * 301 + [CloseConstituent()] + [Shift()] * 300

def test_large_scale_ambiguous_true():
    # ambiguous=True, next block ends with CloseConstituent, should return None
    gold_sequence = [OpenConstituent()] + [Shift()] * 500 + [CloseConstituent()] + [Shift()] * 498 + [CloseConstituent()]
    gold_index = 500  # The CloseConstituent
    gold_transition = gold_sequence[gold_index]
    pred_transition = Shift()
    root_labels = []
    ambiguous = True
    late = False
    codeflash_output = fix_close_shift_shift(gold_transition, pred_transition, gold_sequence, gold_index, root_labels, ambiguous, late); result = codeflash_output
# 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 stanza.models.constituency.in_order_oracle import fix_close_shift_shift


# Minimal implementations of the transition classes for testing
class OpenConstituent:
    def __eq__(self, other):
        return isinstance(other, OpenConstituent)
    def __repr__(self):
        return "OpenConstituent()"

class CloseConstituent:
    def __eq__(self, other):
        return isinstance(other, CloseConstituent)
    def __repr__(self):
        return "CloseConstituent()"

class Shift:
    def __eq__(self, other):
        return isinstance(other, Shift)
    def __repr__(self):
        return "Shift()"
from stanza.models.constituency.in_order_oracle import fix_close_shift_shift

# ------------------- Unit Tests -------------------

# BASIC TEST CASES

def test_basic_close_shift_shift_repair():
    # Normal case: CloseConstituent, Shift, Open, Shift, Close, Shift
    gold_sequence = [
        OpenConstituent(), Shift(), CloseConstituent(),  # first constituent
        Shift(),                                         # second constituent
        CloseConstituent(),                              # close root
    ]
    # gold_index points to the first CloseConstituent (index 2)
    codeflash_output = fix_close_shift_shift(
        gold_transition=CloseConstituent(),
        pred_transition=Shift(),
        gold_sequence=gold_sequence,
        gold_index=2,
        root_labels=None,
        ambiguous=False,
        late=False
    ); result = codeflash_output
    # Should move the close after the next block (Shift at index 3)
    expected = [
        OpenConstituent(), Shift(),  # up to gold_index
        Shift(),                     # block after
        CloseConstituent(),          # moved close
        CloseConstituent(),          # remaining
    ]

def test_basic_returns_none_if_not_close():
    # gold_transition is not CloseConstituent
    gold_sequence = [Shift(), Shift()]
    codeflash_output = fix_close_shift_shift(Shift(), Shift(), gold_sequence, 0, None, False, False)

def test_basic_returns_none_if_not_shift_pred():
    # pred_transition is not Shift
    gold_sequence = [CloseConstituent(), Shift()]
    codeflash_output = fix_close_shift_shift(CloseConstituent(), CloseConstituent(), gold_sequence, 0, None, False, False)

def test_basic_returns_none_if_too_short():
    # gold_sequence is too short for gold_index+2
    gold_sequence = [CloseConstituent()]
    codeflash_output = fix_close_shift_shift(CloseConstituent(), Shift(), gold_sequence, 0, None, False, False)

def test_basic_returns_none_if_next_not_shift():
    # next transition after gold_index is not Shift
    gold_sequence = [CloseConstituent(), OpenConstituent(), CloseConstituent()]
    codeflash_output = fix_close_shift_shift(CloseConstituent(), Shift(), gold_sequence, 0, None, False, False)

def test_basic_returns_none_if_find_end_none():
    # find_in_order_constituent_end returns None (no matching block)
    gold_sequence = [CloseConstituent(), Shift(), OpenConstituent()]
    codeflash_output = fix_close_shift_shift(CloseConstituent(), Shift(), gold_sequence, 0, None, False, False)

def test_basic_returns_none_if_ambiguous_and_end_is_close():
    # ambiguous True, end is CloseConstituent
    gold_sequence = [
        CloseConstituent(), Shift(),
        OpenConstituent(), Shift(), CloseConstituent()
    ]
    codeflash_output = fix_close_shift_shift(CloseConstituent(), Shift(), gold_sequence, 0, None, True, False)

def test_basic_returns_none_if_not_ambiguous_and_end_is_shift():
    # ambiguous False, end is Shift
    gold_sequence = [
        CloseConstituent(), Shift(),
        Shift(), Shift()
    ]
    codeflash_output = fix_close_shift_shift(CloseConstituent(), Shift(), gold_sequence, 0, None, False, False)

def test_basic_late_true_moves_close_further():
    # late True, close moves to after all constituents
    gold_sequence = [
        CloseConstituent(), Shift(),
        OpenConstituent(), Shift(), CloseConstituent(),
        Shift(), OpenConstituent(), Shift(), CloseConstituent(),
        Shift()
    ]
    # gold_index = 0, next is Shift at 1, next block is Open/Shift/Close at 2-4, next block is Open/Shift/Close at 6-8
    codeflash_output = fix_close_shift_shift(
        gold_transition=CloseConstituent(),
        pred_transition=Shift(),
        gold_sequence=gold_sequence,
        gold_index=0,
        root_labels=None,
        ambiguous=False,
        late=True
    ); result = codeflash_output
    # Should move the close after all constituents (after index 8)
    expected = [
        Shift(),
        OpenConstituent(), Shift(), CloseConstituent(),
        Shift(), OpenConstituent(), Shift(), CloseConstituent(),
        CloseConstituent(),
        Shift()
    ]

# EDGE TEST CASES

def test_edge_unary_constituents_skipped():
    # gold_sequence with unary constituents (Open+Close pairs)
    gold_sequence = [
        CloseConstituent(), OpenConstituent(), CloseConstituent(), Shift(), Shift()
    ]
    # Should skip the unary pair at index 1, so start_index becomes 3
    codeflash_output = fix_close_shift_shift(
        gold_transition=CloseConstituent(),
        pred_transition=Shift(),
        gold_sequence=gold_sequence,
        gold_index=0,
        root_labels=None,
        ambiguous=False,
        late=False
    ); result = codeflash_output
    expected = [
        OpenConstituent(), CloseConstituent(), Shift(), CloseConstituent(), Shift()
    ]

def test_edge_multiple_unary_constituents_skipped():
    # Multiple unary pairs
    gold_sequence = [
        CloseConstituent(),
        OpenConstituent(), CloseConstituent(),
        OpenConstituent(), CloseConstituent(),
        Shift(), Shift()
    ]
    # Should skip both unary pairs; start_index becomes 5
    codeflash_output = fix_close_shift_shift(
        gold_transition=CloseConstituent(),
        pred_transition=Shift(),
        gold_sequence=gold_sequence,
        gold_index=0,
        root_labels=None,
        ambiguous=False,
        late=False
    ); result = codeflash_output
    expected = [
        OpenConstituent(), CloseConstituent(), OpenConstituent(), CloseConstituent(),
        Shift(), CloseConstituent(), Shift()
    ]

def test_edge_no_close_after_shift():
    # No CloseConstituent after a Shift, so nothing to repair
    gold_sequence = [CloseConstituent(), Shift(), Shift()]
    codeflash_output = fix_close_shift_shift(CloseConstituent(), Shift(), gold_sequence, 0, None, False, False)

def test_edge_find_end_returns_none_for_unbalanced():
    # Unbalanced Open/Close, so find_in_order_constituent_end returns None
    gold_sequence = [CloseConstituent(), Shift(), OpenConstituent()]
    codeflash_output = fix_close_shift_shift(CloseConstituent(), Shift(), gold_sequence, 0, None, False, False)

def test_edge_empty_sequence():
    # Empty gold_sequence
    gold_sequence = []
    codeflash_output = fix_close_shift_shift(CloseConstituent(), Shift(), gold_sequence, 0, None, False, False)

def test_edge_gold_index_at_end():
    # gold_index at last element
    gold_sequence = [OpenConstituent(), Shift(), CloseConstituent()]
    codeflash_output = fix_close_shift_shift(CloseConstituent(), Shift(), gold_sequence, 2, None, False, False)

def test_edge_gold_index_negative():
    # gold_index negative
    gold_sequence = [CloseConstituent(), Shift(), OpenConstituent()]
    codeflash_output = fix_close_shift_shift(CloseConstituent(), Shift(), gold_sequence, -1, None, False, False)

def test_edge_late_true_with_unary_constituents():
    # late True, with unary constituents to skip
    gold_sequence = [
        CloseConstituent(),
        OpenConstituent(), CloseConstituent(),
        Shift(),
        OpenConstituent(), Shift(), CloseConstituent(),
        Shift()
    ]
    codeflash_output = fix_close_shift_shift(
        gold_transition=CloseConstituent(),
        pred_transition=Shift(),
        gold_sequence=gold_sequence,
        gold_index=0,
        root_labels=None,
        ambiguous=False,
        late=True
    ); result = codeflash_output
    expected = [
        OpenConstituent(), CloseConstituent(), Shift(),
        OpenConstituent(), Shift(), CloseConstituent(),
        CloseConstituent(),
        Shift()
    ]

# LARGE SCALE TEST CASES

def test_large_scale_many_constituents():
    # Large gold_sequence with many constituents
    gold_sequence = [CloseConstituent()]
    # Add 100 Open/Shift/Close blocks
    for _ in range(100):
        gold_sequence += [OpenConstituent(), Shift(), CloseConstituent()]
    gold_sequence += [Shift()]
    codeflash_output = fix_close_shift_shift(
        gold_transition=CloseConstituent(),
        pred_transition=Shift(),
        gold_sequence=gold_sequence,
        gold_index=0,
        root_labels=None,
        ambiguous=False,
        late=False
    ); result = codeflash_output
    # Should move the close after the first block (Open/Shift/Close at index 1-3)
    expected = gold_sequence[1:4] + [CloseConstituent()] + gold_sequence[4:]

def test_large_scale_late_true_moves_close_to_end():
    # Large gold_sequence, late=True
    gold_sequence = [CloseConstituent()]
    for _ in range(50):
        gold_sequence += [OpenConstituent(), Shift(), CloseConstituent()]
    gold_sequence += [Shift()]
    codeflash_output = fix_close_shift_shift(
        gold_transition=CloseConstituent(),
        pred_transition=Shift(),
        gold_sequence=gold_sequence,
        gold_index=0,
        root_labels=None,
        ambiguous=False,
        late=True
    ); result = codeflash_output
    # Should move the close after all constituents (after index 150)
    expected = gold_sequence[1:-1] + [CloseConstituent()] + [Shift()]

def test_large_scale_unary_constituents_skipped():
    # Large gold_sequence with many unary constituents
    gold_sequence = [CloseConstituent()]
    for _ in range(100):
        gold_sequence += [OpenConstituent(), CloseConstituent()]
    gold_sequence += [Shift(), Shift()]
    codeflash_output = fix_close_shift_shift(
        gold_transition=CloseConstituent(),
        pred_transition=Shift(),
        gold_sequence=gold_sequence,
        gold_index=0,
        root_labels=None,
        ambiguous=False,
        late=False
    ); result = codeflash_output
    # Should skip all unary pairs and move the close after the first Shift
    expected = gold_sequence[1:]  # All unary pairs and shifts, then close
    expected = expected[:100*2+1] + [CloseConstituent()] + expected[100*2+1:]

def test_large_scale_returns_none_if_no_shift_after_unaries():
    # Large gold_sequence with only unary constituents, no Shift after
    gold_sequence = [CloseConstituent()]
    for _ in range(100):
        gold_sequence += [OpenConstituent(), CloseConstituent()]
    # No Shift after unaries
    codeflash_output = fix_close_shift_shift(CloseConstituent(), Shift(), gold_sequence, 0, None, False, False)

def test_large_scale_returns_none_if_find_end_none():
    # Large gold_sequence with unbalanced Open/Close
    gold_sequence = [CloseConstituent()]
    for _ in range(100):
        gold_sequence += [OpenConstituent()]
    gold_sequence += [Shift()]
    codeflash_output = fix_close_shift_shift(CloseConstituent(), Shift(), gold_sequence, 0, None, False, False)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

⏪ Replay Tests and Runtime

To edit these changes git checkout codeflash/optimize-fix_close_shift_shift-mh34u1z9 and push.