⚡️ Speed up function get_op_result_name by 21%

[codeflash-ai]

📄 21% (0.21x) speedup for get_op_result_name in pandas/core/ops/common.py

⏱️ Runtime : 2.69 milliseconds → 2.22 milliseconds (best of 83 runs)

📝 Explanation and details

The optimization achieves a 21% speedup through two key changes that reduce redundant operations:

1. Fast Path for Same-Type Objects in get_op_result_name:
Added if type(right) is type(left) and hasattr(right, "name"): before the expensive isinstance check. This optimization significantly benefits when both objects are the same pandas type (Series-Series or Index-Index operations), which is common in pandas operations. The test results show substantial gains for same-type scenarios (38-62% faster for large same-name tests).

2. Reduced Attribute Access in _maybe_match_name:
Replaced multiple hasattr calls and direct attribute access with cached getattr(obj, "name", None). This eliminates redundant attribute lookups - the original code accessed .name multiple times per object, while the optimized version caches the result. Also combined TypeError and ValueError exception handling since both are handled identically.

Performance Characteristics:

• Best for same-type operations: When left and right are both Series or both Index, the fast path avoids expensive isinstance checks
• Excellent for matching names: Tests show 25-58% improvements when names are equal or both None/NaN
• Slight regression for mixed types: 4-10% slower for Index-Series combinations due to the additional type check, but this is the less common case

The optimization particularly shines in high-frequency scenarios like vectorized operations where the same pattern (same types, matching names) repeats thousands of times.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

from types import SimpleNamespace

# imports
import pytest
from pandas.core.ops.common import get_op_result_name

# --- Minimal mocks for pandas types and is_matching_na function ---

class ABCSeries:
    """Mock of pandas.core.dtypes.generic.ABCSeries"""
    def __init__(self, name=None):
        self.name = name

class ABCIndex:
    """Mock of pandas.core.dtypes.generic.ABCIndex"""
    def __init__(self, name=None):
        self.name = name

class _NA:
    """Mock for pd.NA"""
    pass
from pandas.core.ops.common import get_op_result_name

# --- Unit tests ---

# BASIC TEST CASES

def test_same_name_string():
    # Both are Series, same string name
    left = ABCSeries(name="foo")
    right = ABCSeries(name="foo")
    codeflash_output = get_op_result_name(left, right) # 1.54μs -> 1.43μs (7.11% faster)

def test_different_name_string():
    # Both are Series, different string names
    left = ABCSeries(name="foo")
    right = ABCSeries(name="bar")
    codeflash_output = get_op_result_name(left, right) # 1.33μs -> 2.07μs (35.7% slower)

def test_left_only_has_name():
    # Only left has name
    left = ABCSeries(name="foo")
    right = SimpleNamespace()  # not a Series/Index
    codeflash_output = get_op_result_name(left, right) # 1.46μs -> 2.15μs (31.8% slower)


def test_both_none_name():
    # Both have name=None
    left = ABCSeries(name=None)
    right = ABCSeries(name=None)
    codeflash_output = get_op_result_name(left, right) # 2.32μs -> 1.52μs (52.0% faster)

def test_left_none_right_string():
    # left name=None, right name="baz"
    left = ABCSeries(name=None)
    right = ABCSeries(name="baz")
    codeflash_output = get_op_result_name(left, right) # 1.50μs -> 1.78μs (15.9% slower)

def test_left_string_right_none():
    # left name="baz", right name=None
    left = ABCSeries(name="baz")
    right = ABCSeries(name=None)
    codeflash_output = get_op_result_name(left, right) # 1.46μs -> 1.92μs (24.2% slower)

def test_index_and_series_same_name():
    # Index and Series, same name
    left = ABCIndex(name="idx")
    right = ABCSeries(name="idx")
    codeflash_output = get_op_result_name(left, right) # 1.43μs -> 2.48μs (42.5% slower)

def test_index_and_series_different_name():
    # Index and Series, different name
    left = ABCIndex(name="idx1")
    right = ABCSeries(name="idx2")
    codeflash_output = get_op_result_name(left, right) # 1.41μs -> 2.00μs (29.2% slower)

def test_index_and_non_index():
    # Index and non-Index object
    left = ABCIndex(name="idx")
    right = 123
    codeflash_output = get_op_result_name(left, right) # 1.45μs -> 1.78μs (18.8% slower)

def test_series_and_non_series():
    # Series and non-Series object
    left = ABCSeries(name="foo")
    right = [1, 2, 3]
    codeflash_output = get_op_result_name(left, right) # 1.40μs -> 1.77μs (20.5% slower)

# EDGE TEST CASES

def test_both_name_nan():
    # Both names are float('nan')
    nan = float('nan')
    left = ABCSeries(name=nan)
    right = ABCSeries(name=nan)
    codeflash_output = get_op_result_name(left, right); result = codeflash_output # 1.44μs -> 1.92μs (25.0% slower)

def test_left_name_nan_right_none():
    # left name is nan, right name is None
    nan = float('nan')
    left = ABCSeries(name=nan)
    right = ABCSeries(name=None)
    codeflash_output = get_op_result_name(left, right); result = codeflash_output # 1.43μs -> 1.80μs (20.6% slower)

def test_left_name_none_right_nan():
    # left name is None, right name is nan
    nan = float('nan')
    left = ABCSeries(name=None)
    right = ABCSeries(name=nan)
    codeflash_output = get_op_result_name(left, right) # 1.41μs -> 1.64μs (14.0% slower)

def test_both_name_custom_na():
    # Both names are custom NA object
    na = _NA()
    left = ABCSeries(name=na)
    right = ABCSeries(name=na)
    codeflash_output = get_op_result_name(left, right) # 1.42μs -> 1.20μs (18.9% faster)

def test_left_name_custom_na_right_none():
    # left name is custom NA, right name is None
    na = _NA()
    left = ABCSeries(name=na)
    right = ABCSeries(name=None)
    codeflash_output = get_op_result_name(left, right) # 1.34μs -> 1.97μs (31.8% slower)

def test_left_name_none_right_custom_na():
    # left name is None, right name is custom NA
    na = _NA()
    left = ABCSeries(name=None)
    right = ABCSeries(name=na)
    codeflash_output = get_op_result_name(left, right) # 1.36μs -> 1.61μs (15.5% slower)

def test_left_name_tuple_right_name_tuple_same():
    # Both names are same tuple
    t = (1, 2)
    left = ABCSeries(name=t)
    right = ABCSeries(name=t)
    codeflash_output = get_op_result_name(left, right) # 1.43μs -> 1.16μs (22.6% faster)

def test_left_name_tuple_right_name_tuple_different():
    # Both names are different tuples
    left = ABCSeries(name=(1, 2))
    right = ABCSeries(name=(2, 1))
    codeflash_output = get_op_result_name(left, right) # 1.36μs -> 1.85μs (26.7% slower)

def test_left_name_int_right_name_int_same():
    # Both names are same int
    left = ABCSeries(name=42)
    right = ABCSeries(name=42)
    codeflash_output = get_op_result_name(left, right) # 1.46μs -> 1.16μs (25.8% faster)

def test_left_name_int_right_name_int_different():
    # Both names are different int
    left = ABCSeries(name=42)
    right = ABCSeries(name=43)
    codeflash_output = get_op_result_name(left, right) # 1.41μs -> 1.85μs (24.1% slower)


def test_right_has_no_name_attr_left_has_name():
    # right has no name attribute, left has name
    left = ABCSeries(name="bar")
    right = object()
    codeflash_output = get_op_result_name(left, right) # 2.30μs -> 2.53μs (9.12% slower)


def test_left_name_typeerror():
    # left.name and right.name raise TypeError in comparison
    class WeirdName:
        def __eq__(self, other):
            raise TypeError
    left = ABCSeries(name=WeirdName())
    right = ABCSeries(name=WeirdName())
    # Both are NA-like, so is_matching_na returns False, so result is None
    codeflash_output = get_op_result_name(left, right) # 2.31μs -> 3.37μs (31.5% slower)

def test_left_name_valueerror():
    # left.name and right.name raise ValueError in comparison
    class WeirdName:
        def __eq__(self, other):
            raise ValueError
    left = ABCSeries(name=WeirdName())
    right = ABCSeries(name=WeirdName())
    codeflash_output = get_op_result_name(left, right) # 1.54μs -> 2.60μs (41.0% slower)

# LARGE SCALE TEST CASES

def test_large_same_names():
    # Many pairs with same names
    for i in range(1000):
        left = ABCSeries(name=f"name_{i}")
        right = ABCSeries(name=f"name_{i}")
        codeflash_output = get_op_result_name(left, right) # 431μs -> 310μs (38.8% faster)

def test_large_different_names():
    # Many pairs with different names
    for i in range(1000):
        left = ABCSeries(name=f"name_{i}")
        right = ABCSeries(name=f"name_{i+1}")
        codeflash_output = get_op_result_name(left, right) # 433μs -> 360μs (20.1% faster)

def test_large_none_names():
    # Many pairs with None names
    for _ in range(1000):
        left = ABCSeries(name=None)
        right = ABCSeries(name=None)
        codeflash_output = get_op_result_name(left, right) # 430μs -> 343μs (25.2% faster)

def test_large_mixed_types():
    # Mix Index and Series with same names
    for i in range(500):
        left = ABCIndex(name=f"idx_{i}")
        right = ABCSeries(name=f"idx_{i}")
        codeflash_output = get_op_result_name(left, right) # 218μs -> 231μs (5.56% slower)
    for i in range(500):
        left = ABCIndex(name=f"idx_{i}")
        right = ABCSeries(name=f"idx_{i+1}")
        codeflash_output = get_op_result_name(left, right) # 216μs -> 227μs (4.86% slower)

def test_large_nan_names():
    # Many pairs with nan names
    nan = float('nan')
    for _ in range(1000):
        left = ABCSeries(name=nan)
        right = ABCSeries(name=nan)
        codeflash_output = get_op_result_name(left, right); result = codeflash_output # 431μs -> 338μs (27.7% faster)

def test_large_custom_na_names():
    # Many pairs with custom NA names
    na = _NA()
    for _ in range(1000):
        left = ABCSeries(name=na)
        right = ABCSeries(name=na)
        codeflash_output = get_op_result_name(left, right) # 431μs -> 309μs (39.2% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
import numpy as np
import pandas as pd
# imports
import pytest
from pandas.core.ops.common import get_op_result_name

# ========================
# Unit tests start here
# ========================

# 1. Basic Test Cases

def test_both_names_equal_string():
    # Both Series, same name
    s1 = pd.Series([1, 2], name="foo")
    s2 = pd.Series([3, 4], name="foo")
    codeflash_output = get_op_result_name(s1, s2) # 2.79μs -> 1.76μs (58.8% faster)

def test_both_names_equal_int():
    # Both Index, same integer name
    i1 = pd.Index([1, 2], name=42)
    i2 = pd.Index([3, 4], name=42)
    codeflash_output = get_op_result_name(i1, i2) # 3.04μs -> 1.87μs (62.2% faster)

def test_left_has_name_right_has_none():
    # Left has name, right has None
    s1 = pd.Series([1, 2], name="bar")
    s2 = pd.Series([3, 4], name=None)
    codeflash_output = get_op_result_name(s1, s2) # 3.27μs -> 2.67μs (22.3% faster)

def test_right_has_name_left_has_none():
    # Left has None, right has name
    s1 = pd.Series([1, 2], name=None)
    s2 = pd.Series([3, 4], name="baz")
    codeflash_output = get_op_result_name(s1, s2) # 2.84μs -> 2.14μs (32.5% faster)

def test_both_names_none():
    # Both names are None
    s1 = pd.Series([1, 2], name=None)
    s2 = pd.Series([3, 4], name=None)
    codeflash_output = get_op_result_name(s1, s2) # 2.23μs -> 1.80μs (23.8% faster)

def test_names_differ():
    # Both names, but different
    s1 = pd.Series([1, 2], name="a")
    s2 = pd.Series([3, 4], name="b")
    codeflash_output = get_op_result_name(s1, s2) # 3.16μs -> 2.49μs (26.9% faster)

def test_right_not_series_or_index():
    # Right is a scalar
    s1 = pd.Series([1, 2], name="scalar")
    codeflash_output = get_op_result_name(s1, 5) # 1.18μs -> 1.38μs (14.7% slower)

def test_left_has_no_name_attribute():
    # Left is a custom object with no name
    class Dummy: pass
    dummy = Dummy()
    s2 = pd.Series([3, 4], name="baz")
    # Should return s2's name since left has no name
    codeflash_output = get_op_result_name(dummy, s2) # 2.22μs -> 2.77μs (20.0% slower)

def test_right_has_no_name_attribute():
    # Right is a custom object with no name
    s1 = pd.Series([1, 2], name="foo")
    class Dummy: pass
    dummy = Dummy()
    codeflash_output = get_op_result_name(s1, dummy) # 1.35μs -> 1.66μs (18.7% slower)

# 2. Edge Test Cases

def test_both_names_nan():
    # Both names are np.nan
    s1 = pd.Series([1, 2], name=np.nan)
    s2 = pd.Series([3, 4], name=np.nan)

def test_both_names_pdNA():
    # Both names are pd.NA
    s1 = pd.Series([1, 2], name=pd.NA)
    s2 = pd.Series([3, 4], name=pd.NA)

def test_name_npnan_and_none():
    # One name is np.nan, other is None
    s1 = pd.Series([1, 2], name=np.nan)
    s2 = pd.Series([3, 4], name=None)

def test_name_pdNA_and_none():
    # One name is pd.NA, other is None
    s1 = pd.Series([1, 2], name=pd.NA)
    s2 = pd.Series([3, 4], name=None)

def test_name_npnan_and_pdNA():
    # One name is np.nan, other is pd.NA
    s1 = pd.Series([1, 2], name=np.nan)
    s2 = pd.Series([3, 4], name=pd.NA)

def test_names_tuple_and_int():
    # Names are different types
    s1 = pd.Series([1, 2], name=(1, 2))
    s2 = pd.Series([3, 4], name=1)
    # Should return None
    codeflash_output = get_op_result_name(s1, s2) # 3.25μs -> 2.67μs (21.7% faster)

def test_name_int_and_tuple_with_same_value():
    # Name is int vs tuple containing same int
    s1 = pd.Series([1, 2], name=1)
    s2 = pd.Series([3, 4], name=(1,))
    codeflash_output = get_op_result_name(s1, s2) # 3.14μs -> 2.50μs (25.5% faster)

def test_left_is_index_right_is_series_same_name():
    # Left is Index, right is Series, same name
    i1 = pd.Index([1, 2], name="foo")
    s2 = pd.Series([3, 4], name="foo")
    codeflash_output = get_op_result_name(i1, s2) # 2.56μs -> 2.67μs (4.04% slower)

def test_left_is_series_right_is_index_different_names():
    # Left is Series, right is Index, different names
    s1 = pd.Series([1, 2], name="foo")
    i2 = pd.Index([3, 4], name="bar")
    codeflash_output = get_op_result_name(s1, i2) # 4.17μs -> 4.01μs (4.07% faster)

def test_left_is_series_right_is_index_none_name():
    # Left is Series with name, right is Index with None
    s1 = pd.Series([1, 2], name="foo")
    i2 = pd.Index([3, 4], name=None)
    codeflash_output = get_op_result_name(s1, i2) # 4.22μs -> 4.06μs (3.92% faster)

def test_left_is_index_right_is_series_none_name():
    # Left is Index with None, right is Series with name
    i1 = pd.Index([1, 2], name=None)
    s2 = pd.Series([3, 4], name="foo")
    codeflash_output = get_op_result_name(i1, s2) # 3.15μs -> 3.28μs (4.05% slower)


def test_left_is_series_right_is_index_both_none():
    # Both left and right are Series/Index with None name
    s1 = pd.Series([1, 2], name=None)
    i2 = pd.Index([3, 4], name=None)
    codeflash_output = get_op_result_name(s1, i2) # 3.38μs -> 3.65μs (7.46% slower)

def test_left_is_series_right_is_index_both_nan():
    # Both left and right are Series/Index with np.nan name
    s1 = pd.Series([1, 2], name=np.nan)
    i2 = pd.Index([3, 4], name=np.nan)

def test_left_is_series_right_is_index_both_pdNA():
    # Both left and right are Series/Index with pd.NA name
    s1 = pd.Series([1, 2], name=pd.NA)
    i2 = pd.Index([3, 4], name=pd.NA)

def test_left_is_series_right_is_index_nan_and_none():
    # One is np.nan, other is None
    s1 = pd.Series([1, 2], name=np.nan)
    i2 = pd.Index([3, 4], name=None)

def test_left_is_series_right_is_index_pdNA_and_none():
    # One is pd.NA, other is None
    s1 = pd.Series([1, 2], name=pd.NA)
    i2 = pd.Index([3, 4], name=None)

# 3. Large Scale Test Cases

def test_large_series_names_match():
    # Large Series, same name
    s1 = pd.Series(range(1000), name="big")
    s2 = pd.Series(range(1000, 2000), name="big")
    codeflash_output = get_op_result_name(s1, s2) # 2.72μs -> 1.90μs (43.0% faster)

def test_large_series_names_different():
    # Large Series, different names
    s1 = pd.Series(range(1000), name="big1")
    s2 = pd.Series(range(1000, 2000), name="big2")
    codeflash_output = get_op_result_name(s1, s2) # 3.20μs -> 2.60μs (23.3% faster)

def test_large_index_and_series_same_name():
    # Large Index and Series, same name
    i1 = pd.Index(range(1000), name="huge")
    s2 = pd.Series(range(1000), name="huge")
    codeflash_output = get_op_result_name(i1, s2) # 2.71μs -> 3.04μs (10.7% slower)

def test_large_index_and_series_different_names():
    # Large Index and Series, different names
    i1 = pd.Index(range(1000), name="huge1")
    s2 = pd.Series(range(1000), name="huge2")
    codeflash_output = get_op_result_name(i1, s2) # 3.63μs -> 3.44μs (5.56% faster)

def test_large_series_right_not_series_or_index():
    # Large Series, right is scalar
    s1 = pd.Series(range(1000), name="scalar")
    codeflash_output = get_op_result_name(s1, 12345) # 1.20μs -> 1.45μs (17.4% slower)

def test_large_series_left_has_no_name():
    # Large Series, no name, right is Series with name
    s1 = pd.Series(range(1000), name=None)
    s2 = pd.Series(range(1000), name="rightname")
    codeflash_output = get_op_result_name(s1, s2) # 2.93μs -> 2.27μs (29.0% faster)

def test_large_series_both_none():
    # Both large, both names None
    s1 = pd.Series(range(1000), name=None)
    s2 = pd.Series(range(1000), name=None)
    codeflash_output = get_op_result_name(s1, s2) # 2.21μs -> 1.77μs (24.9% faster)

def test_large_series_both_nan():
    # Both large, both names np.nan
    s1 = pd.Series(range(1000), name=np.nan)
    s2 = pd.Series(range(1000), name=np.nan)

def test_large_series_both_pdNA():
    # Both large, both names pd.NA
    s1 = pd.Series(range(1000), name=pd.NA)
    s2 = pd.Series(range(1000), name=pd.NA)
# 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-get_op_result_name-mhchq3ko and push.