⚡️ Speed up method ErrorMessage._format_plain_reason by 47% in PR #6028 (PlaygroundPage)

[codeflash-ai]

⚡️ This pull request contains optimizations for PR #6028

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

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

---

📄 47% (0.47x) speedup for ErrorMessage._format_plain_reason in src/backend/base/langflow/schema/message.py

⏱️ Runtime : 41.8 microseconds → 28.5 microseconds (best of 52 runs)

📝 Explanation and details

To optimize the provided Python class ErrorMessage, we should focus on improving the _format_plain_reason method. We aim to streamline conditional checks and reduce overhead brought about by extensive usage of hasattr and isinstance checks.

Here's the optimized version.

Explanation.

1. Streamlined getattr usage: Instead of using hasattr, I used getattr to directly access body and its message key, which improves readability and skips an extra conditional check.

2. Removed redundant checks: As args is generally present in exceptions and checking its existence costs less than other attribute checks, I moved it up to be checked first if previous conditions are not met.

3. Early returns: Simplified the code by using early returns, which allows for immediate resolution rather than waiting to process every if-elif branch.

This optimized code should have reduced unnecessary checks, leading to better performance.

✅ Correctness verification report:

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

🌀 Generated Regression Tests Details

from __future__ import annotations

import re
import traceback
from uuid import UUID

# imports
import pytest  # used for our unit tests
from langflow.schema.content_block import ContentBlock
from langflow.schema.content_types import ErrorContent
from langflow.schema.message import ErrorMessage
from langflow.schema.properties import Properties, Source
from pydantic import ValidationError


class Message:
    pass
from langflow.schema.message import ErrorMessage

# unit tests

class CustomException(BaseException):
    def __init__(self, body=None, code=None, args=None):
        self.body = body
        self.code = code
        self.args = args if args else []

def test_body_with_message():
    # Test case where the exception has a body with a message
    exception = CustomException(body={"message": "This is a custom error message"})
    codeflash_output = ErrorMessage._format_plain_reason(exception)

def test_body_with_another_message():
    # Test case where the exception has a body with another message
    exception = CustomException(body={"message": "Another error occurred"})
    codeflash_output = ErrorMessage._format_plain_reason(exception)

def test_code_attribute():
    # Test case where the exception has a code attribute
    exception = CustomException(code=404)
    codeflash_output = ErrorMessage._format_plain_reason(exception)

def test_code_with_string():
    # Test case where the exception has a code attribute which is a string
    exception = CustomException(code="ERR001")
    codeflash_output = ErrorMessage._format_plain_reason(exception)

def test_args_attribute():
    # Test case where the exception has args attribute with one argument
    exception = CustomException(args=("Argument error message",))
    codeflash_output = ErrorMessage._format_plain_reason(exception)

def test_args_with_multiple_arguments():
    # Test case where the exception has args attribute with multiple arguments
    exception = CustomException(args=("First argument", "Second argument"))
    codeflash_output = ErrorMessage._format_plain_reason(exception)



def test_default_case():
    # Test case where the exception does not match any specific condition
    exception = CustomException()
    codeflash_output = ErrorMessage._format_plain_reason(exception)

def test_base_exception():
    # Test case where the exception is a base exception
    exception = BaseException()
    codeflash_output = ErrorMessage._format_plain_reason(exception)

def test_multiple_relevant_attributes():
    # Test case where the exception has multiple relevant attributes
    exception = CustomException(body={"message": "Body message"}, code=500, args=("Argument message",))
    codeflash_output = ErrorMessage._format_plain_reason(exception)

def test_code_and_args():
    # Test case where the exception has code and args attributes
    exception = CustomException(code=500, args=("Argument message",))
    codeflash_output = ErrorMessage._format_plain_reason(exception)

def test_body_not_a_dict():
    # Test case where the exception has a body that is not a dictionary
    exception = CustomException(body="Not a dictionary")
    codeflash_output = ErrorMessage._format_plain_reason(exception)

def test_body_without_message_key():
    # Test case where the exception has a body dictionary without a message key
    exception = CustomException(body={"not_message": "No message key"})
    codeflash_output = ErrorMessage._format_plain_reason(exception)

def test_large_body_message():
    # Large scale test case with a large body message
    exception = CustomException(body={"message": "A" * 10000})
    codeflash_output = ErrorMessage._format_plain_reason(exception)

def test_large_args_message():
    # Large scale test case with a large args message
    exception = CustomException(args=("B" * 10000,))
    codeflash_output = ErrorMessage._format_plain_reason(exception)

def test_special_characters_in_message():
    # Test case with special characters in the message
    exception = CustomException(body={"message": "Error with newline\ncharacter"})
    codeflash_output = ErrorMessage._format_plain_reason(exception)

def test_special_characters_in_args():
    # Test case with special characters in the args
    exception = CustomException(args=("Special characters: !@#$%^&*()",))
    codeflash_output = ErrorMessage._format_plain_reason(exception)

def test_nested_exception_body():
    # Test case with nested exception causing attributes
    exception = CustomException(body={"message": {"nested": "Nested error message"}})
    codeflash_output = ErrorMessage._format_plain_reason(exception)
# 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

import re
import traceback
from uuid import UUID

# imports
import pytest  # used for our unit tests
from langflow.schema.content_block import ContentBlock
from langflow.schema.content_types import ErrorContent
from langflow.schema.message import ErrorMessage
from langflow.schema.properties import Properties, Source
from pydantic import ValidationError


# unit tests
def test_exception_with_body_message():
    # Test when exception has a body attribute with a message
    class CustomException(Exception):
        def __init__(self, body):
            self.body = body

    exception = CustomException(body={"message": "An error occurred"})
    codeflash_output = ErrorMessage._format_plain_reason(exception)

def test_exception_with_code():
    # Test when exception has a code attribute
    class CustomException(Exception):
        def __init__(self, code):
            self.code = code

    exception = CustomException(code=404)
    codeflash_output = ErrorMessage._format_plain_reason(exception)

def test_exception_with_args():
    # Test when exception has args
    exception = Exception("File not found")
    codeflash_output = ErrorMessage._format_plain_reason(exception)


def test_unknown_error():
    # Test when exception has no recognized attributes
    exception = Exception()
    codeflash_output = ErrorMessage._format_plain_reason(exception)

def test_non_string_message_in_body():
    # Test when message in body is not a string
    class CustomException(Exception):
        def __init__(self, body):
            self.body = body

    exception = CustomException(body={"message": 12345})
    codeflash_output = ErrorMessage._format_plain_reason(exception)

def test_non_string_code():
    # Test when code is not a string or integer
    class CustomException(Exception):
        def __init__(self, code):
            self.code = code

    exception = CustomException(code=[404])
    codeflash_output = ErrorMessage._format_plain_reason(exception)

def test_non_tuple_args():
    # Test when args is not a tuple
    class CustomException(Exception):
        def __init__(self, args):
            self.args = args

    exception = CustomException(args=["File not found"])
    codeflash_output = ErrorMessage._format_plain_reason(exception)

def test_non_dict_body():
    # Test when body is not a dictionary
    class CustomException(Exception):
        def __init__(self, body):
            self.body = body

    exception = CustomException(body="An error occurred")
    codeflash_output = ErrorMessage._format_plain_reason(exception)

def test_empty_or_missing_attributes():
    # Test when attributes are empty or missing
    class CustomException(Exception):
        def __init__(self, body=None, code=None, args=None):
            self.body = body
            self.code = code
            self.args = args

    exception = CustomException(body={}, code="", args=())
    codeflash_output = ErrorMessage._format_plain_reason(exception)

def test_special_characters_in_attributes():
    # Test when attributes contain special characters
    class CustomException(Exception):
        def __init__(self, body=None, code=None, args=None):
            self.body = body
            self.code = code
            self.args = args

    exception = CustomException(body={"message": "Error\nOccurred"}, code="ERR\n404", args=("Error\tOccurred",))
    codeflash_output = ErrorMessage._format_plain_reason(exception)

def test_unicode_characters():
    # Test when attributes contain Unicode characters
    class CustomException(Exception):
        def __init__(self, body=None, code=None, args=None):
            self.body = body
            self.code = code
            self.args = args

    exception = CustomException(body={"message": "Ошибка произошла"}, code="错误代码", args=("エラーが発生しました",))
    codeflash_output = ErrorMessage._format_plain_reason(exception)

def test_deeply_nested_structures():
    # Test when attributes contain deeply nested structures
    class CustomException(Exception):
        def __init__(self, body=None, args=None):
            self.body = body
            self.args = args

    exception = CustomException(body={"message": {"detail": {"info": "Nested error"}}}, args=(["Nested", ["Error"]],))
    codeflash_output = ErrorMessage._format_plain_reason(exception)


def test_immutable_data_types():
    # Test when attributes contain immutable data types
    class CustomException(Exception):
        def __init__(self, body=None, args=None):
            self.body = body
            self.args = args

    exception = CustomException(body={"message": frozenset(["error"])}, args=(frozenset(["error"]),))
    codeflash_output = ErrorMessage._format_plain_reason(exception)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.