⚡️ Speed up function _replacer by 73%

[codeflash-ai]

📄 73% (0.73x) speedup for _replacer in pandas/core/computation/scope.py

⏱️ Runtime : 717 microseconds → 415 microseconds (best of 112 runs)

📝 Explanation and details

The optimization replaces exception handling with explicit type checking, delivering a 72% speedup by avoiding the performance penalty of Python's try/except mechanism.

Key changes:

• Replaced try: ord(x) except TypeError: x with if isinstance(x, int): x else: ord(x)
• This eliminates exception handling for the common case where x is already an integer

Why this is faster:
In Python, exception handling has significant overhead even when exceptions don't occur - the try block setup itself costs time. The line profiler shows the original code spent 35.8% of time in ord(x) and 15.2% handling TypeError. The optimized version uses isinstance() which is a fast C-level type check, spending only 37.1% of time on type detection and 20.6% on the integer assignment.

Performance characteristics:

• Integer inputs (the common case based on function usage): 100-270% faster - no exception handling overhead
• Character inputs: 2-15% slower - adds one extra isinstance() check before calling ord()
• Error cases: 20-50% faster - faster failure path through isinstance() vs exception handling

Context impact:
This function is called from _raw_hex_id() which processes packed struct data (likely integers from id() pointers). In typical usage, most inputs are integers from the packed bytes, making this optimization highly effective for the hot path while maintaining identical behavior and error handling.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

from __future__ import annotations

# imports
import pytest  # used for our unit tests
from pandas.core.computation.scope import _replacer

# unit tests

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


def test_ascii_character():
    # Test with a typical ASCII character
    codeflash_output = _replacer("A")  # 853ns -> 975ns (12.5% slower)


def test_ascii_digit():
    # Test with a digit character
    codeflash_output = _replacer("7")  # 721ns -> 820ns (12.1% slower)


def test_ascii_lowercase():
    # Test with a lowercase character
    codeflash_output = _replacer("z")  # 765ns -> 826ns (7.38% slower)


def test_integer_input():
    # Test with a small integer input
    codeflash_output = _replacer(10)  # 1.60μs -> 670ns (139% faster)


def test_large_integer_input():
    # Test with a larger integer
    codeflash_output = _replacer(255)  # 1.62μs -> 629ns (158% faster)


def test_zero_integer():
    # Test with zero
    codeflash_output = _replacer(0)  # 1.47μs -> 663ns (121% faster)


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


def test_unicode_character():
    # Test with a unicode character outside ASCII range
    codeflash_output = _replacer("é")  # 773ns -> 844ns (8.41% slower)


def test_high_unicode_character():
    # Test with a high unicode character (emoji)
    emoji = "😀"
    codeflash_output = _replacer(emoji)  # 856ns -> 875ns (2.17% slower)


def test_negative_integer():
    # Test with a negative integer
    codeflash_output = _replacer(-42)  # 1.58μs -> 665ns (138% faster)


def test_large_integer():
    # Test with a very large integer
    big = 2**64
    codeflash_output = _replacer(big)  # 1.62μs -> 732ns (122% faster)


def test_byte_value():
    # Test with a byte value (as int)
    codeflash_output = _replacer(0x41)  # 1.48μs -> 635ns (133% faster)


def test_float_input():
    # Test with a float input (should fail, as hex(float) returns a float hex, not int hex)
    with pytest.raises(TypeError):
        _replacer(3.14)  # 2.40μs -> 1.59μs (51.0% faster)


def test_none_input():
    # Test with None input (should fail)
    with pytest.raises(TypeError):
        _replacer(None)  # 1.90μs -> 1.49μs (27.5% faster)


def test_empty_string():
    # Test with empty string (should raise TypeError in ord)
    with pytest.raises(TypeError):
        _replacer("")  # 2.98μs -> 2.43μs (22.5% faster)


def test_string_longer_than_one():
    # Test with string longer than one character (should raise TypeError in ord)
    with pytest.raises(TypeError):
        _replacer("AB")  # 2.66μs -> 2.10μs (26.8% faster)


def test_bool_input():
    # Test with boolean input (True is 1, False is 0)
    codeflash_output = _replacer(True)  # 1.64μs -> 797ns (106% faster)
    codeflash_output = _replacer(False)  # 703ns -> 380ns (85.0% faster)


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


def test_many_ascii_characters():
    # Test all ASCII characters (0-127)
    for i in range(128):
        char = chr(i)
        codeflash_output = _replacer(char)  # 25.9μs -> 30.2μs (14.2% slower)


def test_many_integers():
    # Test a large range of integers
    for i in range(-100, 100):
        codeflash_output = _replacer(i)  # 80.6μs -> 38.8μs (108% faster)


def test_many_unicode_characters():
    # Test a range of Unicode characters (e.g., 0x1000 to 0x10FF)
    for codepoint in range(0x1000, 0x1100):
        char = chr(codepoint)
        codeflash_output = _replacer(char)  # 49.3μs -> 58.5μs (15.8% slower)


def test_large_random_integers():
    # Test with large random integers up to 1000 elements
    import random

    nums = random.sample(range(-1000000000000, -999999999000), 1000)
    for n in nums:
        codeflash_output = _replacer(n)  # 395μs -> 194μs (103% faster)


def test_all_byte_values():
    # Test all possible byte values (0-255) as ints
    for i in range(256):
        codeflash_output = _replacer(i)  # 101μs -> 49.3μs (106% faster)


# -----------------------------
# Mutation Testing Guards
# -----------------------------


def test_mutation_guard_ord_vs_int():
    # If the function always uses ord(), this will fail for ints
    codeflash_output = _replacer(123)  # 1.31μs -> 554ns (136% faster)
    # If the function always uses int(), this will fail for characters
    codeflash_output = _replacer("A")  # 416ns -> 524ns (20.6% slower)


def test_mutation_guard_negative_hex():
    # Ensure negative numbers are represented with a '-' sign
    codeflash_output = _replacer(-255)  # 1.37μs -> 629ns (117% faster)


# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

from __future__ import annotations

# imports
import pytest  # used for our unit tests
from pandas.core.computation.scope import _replacer

# unit tests

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


def test_basic_ascii_char():
    # Test with a basic ASCII character
    codeflash_output = _replacer("A")  # 728ns -> 739ns (1.49% slower)
    codeflash_output = _replacer("z")  # 322ns -> 367ns (12.3% slower)
    codeflash_output = _replacer("0")  # 210ns -> 237ns (11.4% slower)


def test_basic_integer():
    # Test with a basic integer
    codeflash_output = _replacer(10)  # 1.47μs -> 603ns (143% faster)
    codeflash_output = _replacer(255)  # 613ns -> 303ns (102% faster)
    codeflash_output = _replacer(0)  # 464ns -> 222ns (109% faster)


def test_basic_bytes():
    # Test with a single byte (int, as per Python3 iteration over bytes)
    b = b"A"
    # b'A' is bytes([65]), so iter(b'A') yields 65
    codeflash_output = _replacer(b[0])  # 1.47μs -> 589ns (149% faster)


def test_basic_unicode_char():
    # Test with a Unicode character outside ASCII
    codeflash_output = _replacer("é")  # 811ns -> 784ns (3.44% faster)
    codeflash_output = _replacer("Ω")  # 402ns -> 429ns (6.29% slower)


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


def test_empty_string():
    # Test with empty string should raise TypeError (ord('') is invalid)
    with pytest.raises(TypeError):
        _replacer("")  # 3.03μs -> 2.50μs (21.2% faster)


def test_non_string_non_int():
    # Test with a non-string, non-int type (e.g. float, list, dict)
    with pytest.raises(TypeError):
        _replacer(3.14)  # 1.99μs -> 1.49μs (33.9% faster)
    with pytest.raises(TypeError):
        _replacer([1, 2, 3])  # 1.12μs -> 764ns (46.9% faster)
    with pytest.raises(TypeError):
        _replacer({"a": 1})  # 853ns -> 562ns (51.8% faster)


def test_negative_integer():
    # Test with negative integer
    codeflash_output = _replacer(-1)  # 1.39μs -> 669ns (108% faster)
    codeflash_output = _replacer(-255)  # 755ns -> 392ns (92.6% faster)


def test_large_integer():
    # Test with a very large integer
    large_int = 2**64
    codeflash_output = _replacer(large_int)  # 1.45μs -> 710ns (104% faster)


def test_string_longer_than_one_char():
    # Test with string longer than one character (ord() only works for single char)
    with pytest.raises(TypeError):
        _replacer("AB")  # 3.67μs -> 2.84μs (29.2% faster)
    with pytest.raises(TypeError):
        _replacer("Hello")  # 1.18μs -> 918ns (28.3% faster)


def test_bool_type():
    # Test with boolean values
    # In Python, bool is subclass of int, so hex(True) == '0x1', hex(False) == '0x0'
    codeflash_output = _replacer(True)  # 1.59μs -> 772ns (106% faster)
    codeflash_output = _replacer(False)  # 647ns -> 349ns (85.4% faster)


def test_none_type():
    # Test with NoneType should raise TypeError
    with pytest.raises(TypeError):
        _replacer(None)  # 1.81μs -> 1.42μs (27.6% faster)


def test_object_type():
    # Test with a custom object should raise TypeError
    class Dummy:
        pass

    with pytest.raises(TypeError):
        _replacer(Dummy())  # 1.84μs -> 1.70μs (8.12% faster)


def test_surrogate_unicode_char():
    # Surrogate pairs are not valid Unicode code points for ord()
    # But Python allows ord('\ud800'), so test it
    codeflash_output = _replacer("\ud800")  # 891ns -> 979ns (8.99% slower)


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


def test_mutation_sensitivity_ascii_vs_int():
    # Ensure that passing 'A' (char) and 65 (int) produce same result
    codeflash_output = _replacer("A")
    # But passing b'A' (bytes) should raise TypeError
    with pytest.raises(TypeError):
        _replacer(b"A")


def test_mutation_sensitivity_ord_vs_hex():
    # Ensure that for single-char string, ord is used, for int, hex is used
    codeflash_output = _replacer("A")  # 927ns -> 951ns (2.52% slower)
    codeflash_output = _replacer(65)  # 1.19μs -> 323ns (270% faster)
    # Changing the function to always use hex(x) would fail for 'A'


def test_mutation_sensitivity_typeerror():
    # Ensure that changing try/except block would break these cases
    with pytest.raises(TypeError):
        _replacer([65])  # 2.04μs -> 1.56μs (30.3% faster)
    with pytest.raises(TypeError):
        _replacer({"x": 65})  # 1.12μs -> 805ns (38.6% faster)
    with pytest.raises(TypeError):
        _replacer(object())  # 1.02μs -> 845ns (20.2% 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-_replacer-mj9uwdja and push.