⚡️ Speed up function get_message by 10% in PR #9765 (fix/building_splittext)

[codeflash-ai]

⚡️ This pull request contains optimizations for PR #9765

If you approve this dependent PR, these changes will be merged into the original PR branch fix/building_splittext.

This PR will be automatically closed if the original PR is merged.

---

📄 10% (0.10x) speedup for get_message in langflow/schema/schema.py

⏱️ Runtime : 648 microseconds → 588 microseconds (best of 93 runs)

📝 Explanation and details

The optimized code achieves a 10% speedup by replacing expensive hasattr() calls with more efficient getattr() operations and restructuring the control flow to minimize redundant checks.

Key optimizations:

1. Replaced hasattr + attribute access pattern: The original code used hasattr(payload, "data") followed by payload.data, performing two attribute lookups. The optimized version uses getattr(payload, "data", None), which does a single lookup and returns None if the attribute doesn't exist.

2. Eliminated redundant attribute checks: Instead of checking hasattr(payload, "model_dump") and then calling payload.model_dump(), the optimized code uses getattr(payload, "model_dump", None) and checks if it's callable before invoking it.

3. Restructured control flow: The optimized version uses a single if message is None: block to handle all fallback cases, avoiding multiple separate conditional branches that could lead to redundant type checking.

4. Tuple syntax for isinstance: Changed isinstance(payload, dict | str | Data) to isinstance(payload, (dict, str, Data)) - while functionally equivalent, the tuple form can be slightly more efficient.

Performance impact by test type:

• Objects with data attributes (most common case): ~17% improvement due to single getattr vs hasattr + attribute access
• Objects with model_dump methods: Similar improvement from consolidated attribute checking
• Fallback cases (dict/str/Data): Minimal change since these hit the same isinstance checks
• Large payloads: Improvements scale well since the optimization is in attribute access, not data processing

The line profiler shows the biggest time reduction comes from eliminating the redundant hasattr calls (lines 4-5 in original), which accounted for over 25% of the function's runtime.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

from types import SimpleNamespace

import pandas as pd
# imports
import pytest  # used for our unit tests
# function to test
from langflow.schema.data import Data
from langflow.schema.schema import get_message
from pandas import Series

# ------------------ UNIT TESTS ------------------

# ------------------ BASIC TEST CASES ------------------

def test_payload_with_data_attribute_returns_data():
    # Object with 'data' attribute should return that attribute
    class ObjWithData:
        def __init__(self):
            self.data = "hello"
    payload = ObjWithData()
    codeflash_output = get_message(payload)

def test_payload_with_model_dump_returns_model_dump():
    # Object with 'model_dump' method should return its output
    class ObjWithModelDump:
        def model_dump(self):
            return {"foo": "bar"}
    payload = ObjWithModelDump()
    codeflash_output = get_message(payload)

def test_payload_is_dict_returns_dict():
    # Dict input should return the dict itself
    d = {"a": 1}
    codeflash_output = get_message(d)

def test_payload_is_str_returns_str():
    # String input should return the string itself
    s = "test string"
    codeflash_output = get_message(s)


def test_payload_is_series_returns_series():
    # Non-empty pandas Series input should return the Series itself
    ser = pd.Series([1, 2, 3])
    codeflash_output = get_message(ser); result = codeflash_output

def test_payload_is_empty_series_returns_payload():
    # Empty pandas Series returns the original payload (the empty Series)
    ser = pd.Series([], dtype=int)
    codeflash_output = get_message(ser)

# ------------------ EDGE TEST CASES ------------------

def test_payload_with_data_none_returns_none():
    # Object with 'data' attribute set to None should return None
    class ObjWithData:
        data = None
    payload = ObjWithData()
    codeflash_output = get_message(payload)

def test_payload_with_model_dump_returns_none_returns_payload():
    # If model_dump returns None, should fall back to payload
    class ObjWithModelDump:
        def model_dump(self):
            return None
    payload = ObjWithModelDump()
    codeflash_output = get_message(payload)

def test_payload_with_both_data_and_model_dump_prefers_data():
    # If object has both 'data' and 'model_dump', 'data' is preferred
    class ObjBoth:
        data = "dataval"
        def model_dump(self):
            return "modelval"
    payload = ObjBoth()
    codeflash_output = get_message(payload)

def test_payload_is_none_returns_none():
    # None input should return None
    codeflash_output = get_message(None)

def test_payload_is_falsey_value():
    # Falsey value (e.g., 0, False, '') should return the value itself
    codeflash_output = get_message(0)
    codeflash_output = get_message(False)
    codeflash_output = get_message('')

def test_payload_is_object_without_any_special_handling():
    # Object with no 'data' or 'model_dump' and not dict/str/Data/Series
    class Plain:
        pass
    obj = Plain()
    codeflash_output = get_message(obj)

def test_payload_is_data_with_data_none_returns_none():
    # Data instance with data=None should return None
    data = Data(data=None)
    codeflash_output = get_message(data)

def test_payload_is_series_with_nan_values():
    # Series with NaN values should still be returned if not empty
    ser = pd.Series([float('nan'), 1, 2])
    codeflash_output = get_message(ser); result = codeflash_output

def test_payload_is_series_with_all_nan_returns_series():
    # Series with all NaN is not empty, so should return the Series
    ser = pd.Series([float('nan'), float('nan')])
    codeflash_output = get_message(ser); result = codeflash_output

def test_payload_is_series_with_index_but_no_values():
    # Series with index but no values (empty) should return the Series itself
    ser = pd.Series([], index=pd.Index([], dtype=int))
    codeflash_output = get_message(ser)

# ------------------ LARGE SCALE TEST CASES ------------------

def test_large_dict_payload():
    # Large dictionary input should be returned as is
    d = {str(i): i for i in range(1000)}
    codeflash_output = get_message(d)

def test_large_string_payload():
    # Large string input should be returned as is
    s = "x" * 1000
    codeflash_output = get_message(s)

def test_large_series_payload():
    # Large Series should be returned as is
    ser = pd.Series(range(1000))
    codeflash_output = get_message(ser); result = codeflash_output


def test_large_object_with_data_attribute():
    # Object with large 'data' attribute should return it
    class ObjWithData:
        def __init__(self, data):
            self.data = data
    obj = ObjWithData(data=list(range(1000)))
    codeflash_output = get_message(obj)

def test_large_object_with_model_dump():
    # Object with large model_dump output should return it
    class ObjWithModelDump:
        def model_dump(self):
            return {str(i): i for i in range(1000)}
    obj = ObjWithModelDump()
    codeflash_output = get_message(obj)

# ------------------ ADDITIONAL EDGE CASES ------------------

def test_payload_is_tuple():
    # Tuple input should be returned as is (not handled specially)
    t = (1, 2, 3)
    codeflash_output = get_message(t)

def test_payload_is_list():
    # List input should be returned as is (not handled specially)
    l = [1, 2, 3]
    codeflash_output = get_message(l)

def test_payload_is_set():
    # Set input should be returned as is (not handled specially)
    s = {1, 2, 3}
    codeflash_output = get_message(s)

def test_payload_is_bytes():
    # Bytes input should be returned as is (not handled specially)
    b = b"hello"
    codeflash_output = get_message(b)

def test_payload_is_object_with_data_and_data_is_series():
    # Object with 'data' attribute being a Series should return the Series if not empty
    class ObjWithData:
        def __init__(self):
            self.data = pd.Series([1, 2, 3])
    obj = ObjWithData()
    codeflash_output = get_message(obj); result = codeflash_output

def test_payload_is_object_with_data_and_data_is_empty_series():
    # Object with 'data' attribute being an empty Series should return the payload itself
    class ObjWithData:
        def __init__(self):
            self.data = pd.Series([], dtype=int)
    obj = ObjWithData()
    codeflash_output = get_message(obj)

def test_payload_is_object_with_model_dump_returning_series():
    # Object with model_dump returning a Series should return the Series if not empty
    class ObjWithModelDump:
        def model_dump(self):
            return pd.Series([1, 2, 3])
    obj = ObjWithModelDump()
    codeflash_output = get_message(obj); result = codeflash_output

def test_payload_is_object_with_model_dump_returning_empty_series():
    # Object with model_dump returning empty Series should return the payload itself
    class ObjWithModelDump:
        def model_dump(self):
            return pd.Series([], dtype=int)
    obj = ObjWithModelDump()
    codeflash_output = get_message(obj)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
from collections import namedtuple
# function to test
from types import SimpleNamespace

# imports
import pytest  # used for our unit tests
from langflow.schema.schema import get_message


# Dummy Data class to mimic langflow.schema.data.Data
class Data:
    def __init__(self, data):
        self.data = data

# Dummy pandas.Series replacement for testing
class DummySeries:
    def __init__(self, data):
        self._data = list(data)
        self.empty = not bool(self._data)
    def __bool__(self):
        # Should be True if not empty
        return not self.empty
    def __eq__(self, other):
        # For assert comparison in tests
        if not isinstance(other, DummySeries):
            return False
        return self._data == other._data
    def __repr__(self):
        return f"DummySeries({self._data})"
from langflow.schema.schema import get_message

# ---------------------------
# Unit Tests for get_message
# ---------------------------

# 1. Basic Test Cases

def test_dict_payload():
    # Should return the dict itself
    payload = {"foo": "bar"}
    codeflash_output = get_message(payload)

def test_string_payload():
    # Should return the string itself
    payload = "hello world"
    codeflash_output = get_message(payload)

def test_data_payload():
    # Should extract .data attribute
    payload = Data({"msg": 42})
    codeflash_output = get_message(payload)

def test_object_with_data_attr():
    # Should extract .data attribute
    class Obj:
        def __init__(self):
            self.data = 123
    payload = Obj()
    codeflash_output = get_message(payload)

def test_object_with_model_dump():
    # Should call .model_dump() method
    class Obj:
        def model_dump(self):
            return {"dumped": True}
    payload = Obj()
    codeflash_output = get_message(payload)

def test_object_with_both_data_and_model_dump():
    # .data should take precedence over .model_dump()
    class Obj:
        def __init__(self):
            self.data = "DATA"
        def model_dump(self):
            return "MODEL_DUMP"
    payload = Obj()
    codeflash_output = get_message(payload)

# 2. Edge Test Cases

def test_payload_is_none():
    # Should return None
    codeflash_output = get_message(None)

def test_object_with_no_data_or_model_dump():
    # Should return the object itself
    class Obj:
        pass
    payload = Obj()
    codeflash_output = get_message(payload)

def test_data_with_none_data():
    # Should extract .data even if it's None
    payload = Data(None)
    codeflash_output = get_message(payload)

def test_empty_dict():
    # Should return the empty dict
    payload = {}
    codeflash_output = get_message(payload)

def test_empty_string():
    # Should return the empty string
    payload = ""
    codeflash_output = get_message(payload)

def test_data_with_empty_string():
    # Should extract .data even if it's empty string
    payload = Data("")
    codeflash_output = get_message(payload)

def test_data_with_empty_dict():
    # Should extract .data even if it's empty dict
    payload = Data({})
    codeflash_output = get_message(payload)

def test_payload_is_dummy_series_nonempty():
    # Should return the DummySeries itself if not empty
    s = DummySeries([1, 2, 3])
    codeflash_output = get_message(s)

def test_payload_is_dummy_series_empty():
    # Should return the original payload (empty DummySeries)
    s = DummySeries([])
    codeflash_output = get_message(s)

def test_data_with_dummy_series_nonempty():
    # Should extract .data and return DummySeries if not empty
    s = DummySeries([5, 6])
    payload = Data(s)
    codeflash_output = get_message(payload)

def test_data_with_dummy_series_empty():
    # Should extract .data, see it's empty DummySeries, and return payload
    s = DummySeries([])
    payload = Data(s)
    codeflash_output = get_message(payload)

def test_object_with_data_attr_none():
    # Should extract .data even if it's None
    class Obj:
        def __init__(self):
            self.data = None
    payload = Obj()
    codeflash_output = get_message(payload)

def test_object_with_model_dump_none():
    # Should call .model_dump() and get None
    class Obj:
        def model_dump(self):
            return None
    payload = Obj()
    codeflash_output = get_message(payload)

def test_object_with_data_attr_falsey():
    # Should extract .data even if it's a falsey value (e.g., 0)
    class Obj:
        def __init__(self):
            self.data = 0
    payload = Obj()
    codeflash_output = get_message(payload)

def test_data_with_data_attr_falsey():
    # Should extract .data even if it's a falsey value (e.g., 0)
    payload = Data(0)
    codeflash_output = get_message(payload)

def test_object_with_model_dump_falsey():
    # Should call .model_dump() and get a falsey value (e.g., 0)
    class Obj:
        def model_dump(self):
            return 0
    payload = Obj()
    codeflash_output = get_message(payload)

def test_object_with_data_and_model_dump_falsey():
    # .data should take precedence even if falsey
    class Obj:
        def __init__(self):
            self.data = 0
        def model_dump(self):
            return 1
    payload = Obj()
    codeflash_output = get_message(payload)

def test_object_with_data_and_model_dump_none():
    # .data should take precedence even if None
    class Obj:
        def __init__(self):
            self.data = None
        def model_dump(self):
            return 1
    payload = Obj()
    codeflash_output = get_message(payload)

def test_object_with_model_dump_raises():
    # Should not call .model_dump() if .data exists
    class Obj:
        def __init__(self):
            self.data = "SAFE"
        def model_dump(self):
            raise RuntimeError("Should not be called")
    payload = Obj()
    codeflash_output = get_message(payload)

def test_object_with_data_and_model_dump_both_none():
    # .data should take precedence even if None
    class Obj:
        def __init__(self):
            self.data = None
        def model_dump(self):
            return None
    payload = Obj()
    codeflash_output = get_message(payload)

def test_namedtuple_with_data_field():
    # Should extract .data from namedtuple
    NT = namedtuple("NT", ["data"])
    payload = NT(data="namedtuple_data")
    codeflash_output = get_message(payload)

def test_simple_namespace_with_data():
    # Should extract .data from SimpleNamespace
    payload = SimpleNamespace(data="namespace_data")
    codeflash_output = get_message(payload)

def test_data_with_data_is_dummy_series_empty():
    # Should return payload if .data is DummySeries and empty
    s = DummySeries([])
    payload = Data(s)
    codeflash_output = get_message(payload)

def test_data_with_data_is_dummy_series_nonempty():
    # Should return DummySeries if not empty
    s = DummySeries([1])
    payload = Data(s)
    codeflash_output = get_message(payload)

# 3. Large Scale Test Cases

def test_large_dict_payload():
    # Should handle large dicts
    payload = {str(i): i for i in range(1000)}
    codeflash_output = get_message(payload)

def test_large_string_payload():
    # Should handle large strings
    payload = "a" * 1000
    codeflash_output = get_message(payload)

def test_large_data_payload():
    # Should extract .data from Data containing large dict
    large_data = {str(i): i for i in range(1000)}
    payload = Data(large_data)
    codeflash_output = get_message(payload)

def test_large_dummy_series_payload():
    # Should return DummySeries itself if not empty
    s = DummySeries(range(1000))
    codeflash_output = get_message(s)

def test_large_data_with_dummy_series_payload():
    # Should extract .data and return DummySeries if not empty
    s = DummySeries(range(1000))
    payload = Data(s)
    codeflash_output = get_message(payload)

def test_large_data_with_empty_dummy_series_payload():
    # Should return payload if .data is DummySeries and empty
    s = DummySeries([])
    payload = Data(s)
    codeflash_output = get_message(payload)

def test_large_object_with_data_attr():
    # Should extract .data from object with large data
    class Obj:
        def __init__(self, data):
            self.data = data
    large_data = {str(i): i for i in range(1000)}
    payload = Obj(large_data)
    codeflash_output = get_message(payload)

def test_large_object_with_model_dump():
    # Should call .model_dump() returning large data
    class Obj:
        def model_dump(self):
            return {str(i): i for i in range(1000)}
    payload = Obj()
    codeflash_output = get_message(payload)

def test_large_object_with_data_and_model_dump():
    # .data should take precedence over .model_dump(), even if both are large
    class Obj:
        def __init__(self):
            self.data = {str(i): i for i in range(1000)}
        def model_dump(self):
            return "should not be used"
    payload = Obj()
    codeflash_output = get_message(payload)
# 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-pr9765-2025-09-09T12.18.36 and push.

[coderabbitai]

Important

Review skipped

Bot user detected.

To trigger a single review, invoke the @coderabbitai review command.

You can disable this status message by setting the reviews.review_status to false in the CodeRabbit configuration file.

---

_{Comment @coderabbitai help to get the list of available commands and usage tips.}

[sonarqubecloud]

Quality Gate passed

Issues
0 New issues
0 Accepted issues

Measures
0 Security Hotspots
0.0% Coverage on New Code
0.0% Duplication on New Code

See analysis details on SonarQube Cloud

[codeflash-ai]

This PR has been automatically closed because the original PR #9765 by italojohnny was closed.