⚡️ Speed up function strip_version_data by 526% in PR #11859 (workflow-history)

[codeflash-ai]

⚡️ This pull request contains optimizations for PR #11859

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

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

---

📄 526% (5.26x) speedup for strip_version_data in src/backend/base/langflow/api/v1/flow_version.py

⏱️ Runtime : 14.1 milliseconds → 2.26 milliseconds (best of 150 runs)

📝 Explanation and details

The optimization replaces copy.deepcopy(data) (which recursively copies the entire flow structure) with _copy_data_for_stripping, a helper that shallow-copies only the nested path nodes → node["data"] → node["data"]["node"] → template → template values that remove_api_keys mutates. Line profiler shows deepcopy consumed 94% of runtime at ~4 ms per call; the targeted copy drops this to ~250 µs (51% of new runtime). Because flow data typically contains large immutable subtrees (IDs, metadata) that don't need copying, this selective approach yields a 5.25× speedup with identical semantics—mutations to stripped output never affect the original input.

✅ Correctness verification report:

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

🌀 Click to see Generated Regression Tests

import pytest  # used for our unit tests
from langflow.api.v1.flow_version import strip_version_data


def test_none_input_returns_none():
    # If input is None, function should return None (no attempt to modify anything)
    codeflash_output = strip_version_data(None)


def test_basic_strip_removes_api_key_and_preserves_original():
    # Construct a simple, valid flow data dict containing one node that should have its secret removed.
    original = {
        "nodes": [
            {
                "data": {
                    "node": {
                        "template": {
                            "api_field": {
                                "name": "my_api_key",   # contains "api" and "key" -> matches has_api_terms
                                "password": True,      # truthy -> should be treated as secret
                                "value": "SECRET_123",  # secret that should be nulled
                            }
                        }
                    }
                }
            }
        ]
    }
    # Call function under test
    codeflash_output = strip_version_data(original); stripped = codeflash_output


def test_non_matching_name_not_cleared_even_with_password_true():
    # If the name does not contain the required terms ("api" + ("key" or "token")), it must not be cleared.
    data = {
        "nodes": [
            {
                "data": {
                    "node": {
                        "template": {
                            "user_field": {
                                "name": "username",  # does not mention api/key/token
                                "password": True,
                                "value": "user_secret",
                            }
                        }
                    }
                }
            }
        ]
    }
    codeflash_output = strip_version_data(data); result = codeflash_output


def test_password_false_or_missing_not_cleared():
    # Even if the name looks like an API key, if "password" is falsy or missing, the value must not be cleared.
    cases = [
        {"name": "service_api_key", "password": False, "value": "S1"},
        {"name": "service_api_key", "value": "S2"},  # password missing => treated as falsy
    ]
    data = {
        "nodes": [
            {"data": {"node": {"template": {"a": cases[0]}}}},
            {"data": {"node": {"template": {"b": cases[1]}}}},
        ]
    }
    codeflash_output = strip_version_data(data); res = codeflash_output


def test_api_tokens_substring_excluded_from_clearing():
    # has_api_terms excludes names where "tokens" appears (plural). Ensure such names are NOT treated as secrets.
    data = {
        "nodes": [
            {
                "data": {
                    "node": {
                        "template": {
                            "tokens_field": {
                                "name": "my_api_tokens",  # contains "tokens" -> should NOT be matched
                                "password": True,
                                "value": "TOK_SECRET",
                            }
                        }
                    }
                }
            }
        ]
    }
    codeflash_output = strip_version_data(data); result = codeflash_output


def test_apitoken_name_cleared_when_contains_api_and_token():
    # Names like "apitoken" (containing "api" and "token") should be considered API creds and cleared.
    data = {
        "nodes": [
            {
                "data": {
                    "node": {
                        "template": {
                            "t": {
                                "name": "apitoken",  # contains "api" and "token"
                                "password": True,
                                "value": "SECRET_TOKEN",
                            }
                        }
                    }
                }
            }
        ]
    }
    codeflash_output = strip_version_data(data); res = codeflash_output


def test_malformed_data_that_causes_internal_error_returns_none_string_input():
    # If the provided data is not a dict (e.g., a string), remove_api_keys will attempt to call .get on it
    # leading to an AttributeError, which strip_version_data must catch and return None.
    bad = "I am not a dict"
    codeflash_output = strip_version_data(bad)


def test_malformed_nodes_none_returns_none():
    # If "nodes" is present but not iterable (e.g., None), iterating will raise a TypeError and function should return None.
    bad = {"nodes": None}
    codeflash_output = strip_version_data(bad)


def test_mixed_templates_only_matching_entries_cleared():
    # Multiple entries in the same template: only those matching both name pattern and having a truthy password should be cleared.
    data = {
        "nodes": [
            {
                "data": {
                    "node": {
                        "template": {
                            "keep_me": {"name": "not_api_related", "password": True, "value": "KEEP"},
                            "clear_me": {"name": "super_api_key", "password": True, "value": "CLEAR"},
                            "also_keep": {"name": "my_api_tokens_extra", "password": True, "value": "KEEP2"},
                        }
                    }
                }
            }
        ]
    }
    codeflash_output = strip_version_data(data); result = codeflash_output
    # Only "clear_me" should be nulled.
    t = result["nodes"][0]["data"]["node"]["template"]


def test_deep_copy_behavior_original_unchanged_for_large_structure():
    # Ensure deep copy semantics: returned structure may be mutated, original stays the same.
    original = {
        "nodes": [
            {
                "data": {
                    "node": {
                        "template": {
                            "k": {"name": "api_key", "password": True, "value": "ORIG"}
                        }
                    }
                }
            }
        ]
    }
    # Keep a shallow copy of nested object references before calling (to compare identity)
    orig_nested_value = original["nodes"][0]["data"]["node"]["template"]["k"]["value"]
    codeflash_output = strip_version_data(original); result = codeflash_output


def test_large_scale_clearing_1000_nodes_performance_and_correctness():
    # Build a large flow with 1000 nodes, each containing an API-like secret that should be cleared.
    large_nodes = []
    for i in range(1000):
        # Each node contains one template entry that matches "api" + "key" and has password True.
        large_nodes.append(
            {
                "data": {
                    "node": {
                        "template": {
                            f"field_{i}": {
                                "name": f"service_api_key_{i}",  # matches has_api_terms
                                "password": True,
                                "value": f"SECRET_{i}",
                            }
                        }
                    }
                }
            }
        )
    large_data = {"nodes": large_nodes}

    # Call the function under test. This should complete reasonably quickly and clear all values.
    codeflash_output = strip_version_data(large_data); stripped = codeflash_output
    for idx in range(1000):
        v = stripped["nodes"][idx]["data"]["node"]["template"][f"field_{idx}"]["value"]

    # The original large_data should remain unmodified (deep copy semantics).
    for idx in range(1000):
        orig_v = large_data["nodes"][idx]["data"]["node"]["template"][f"field_{idx}"]["value"]
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
import copy

# imports
import pytest
from langflow.api.v1.flow_version import strip_version_data


def test_strip_version_data_with_none_input():
    """Test that None input returns None without error."""
    codeflash_output = strip_version_data(None); result = codeflash_output


def test_strip_version_data_with_empty_dict():
    """Test that empty dict input returns empty dict."""
    codeflash_output = strip_version_data({}); result = codeflash_output


def test_strip_version_data_with_simple_dict():
    """Test that simple dict without nodes is returned unchanged."""
    input_data = {"key": "value", "number": 42}
    codeflash_output = strip_version_data(input_data); result = codeflash_output


def test_strip_version_data_does_not_modify_input():
    """Test that strip_version_data does not modify the original input dict."""
    input_data = {"test": "value"}
    original_copy = copy.deepcopy(input_data)
    strip_version_data(input_data)


def test_strip_version_data_with_no_api_keys():
    """Test that data without API keys is returned unchanged."""
    input_data = {
        "nodes": [
            {
                "data": {
                    "node": {
                        "template": {
                            "regular_param": {"name": "regular_param", "value": "some_value"}
                        }
                    }
                }
            }
        ]
    }
    codeflash_output = strip_version_data(input_data); result = codeflash_output


def test_strip_version_data_removes_api_key():
    """Test that API key fields are stripped from the data."""
    input_data = {
        "nodes": [
            {
                "data": {
                    "node": {
                        "template": {
                            "api_key": {
                                "name": "api_key",
                                "value": "secret_key_123",
                                "password": True
                            }
                        }
                    }
                }
            }
        ]
    }
    codeflash_output = strip_version_data(input_data); result = codeflash_output


def test_strip_version_data_removes_api_token():
    """Test that API token fields are stripped from the data."""
    input_data = {
        "nodes": [
            {
                "data": {
                    "node": {
                        "template": {
                            "api_token": {
                                "name": "api_token",
                                "value": "token_xyz",
                                "password": True
                            }
                        }
                    }
                }
            }
        ]
    }
    codeflash_output = strip_version_data(input_data); result = codeflash_output


def test_strip_version_data_preserves_non_password_fields():
    """Test that non-password fields are not modified even if they have API in the name."""
    input_data = {
        "nodes": [
            {
                "data": {
                    "node": {
                        "template": {
                            "api_key": {
                                "name": "api_key",
                                "value": "secret_key_123",
                                "password": False
                            }
                        }
                    }
                }
            }
        ]
    }
    codeflash_output = strip_version_data(input_data); result = codeflash_output


def test_strip_version_data_handles_multiple_nodes():
    """Test that API keys are stripped from multiple nodes."""
    input_data = {
        "nodes": [
            {
                "data": {
                    "node": {
                        "template": {
                            "api_key": {
                                "name": "api_key",
                                "value": "key1",
                                "password": True
                            }
                        }
                    }
                }
            },
            {
                "data": {
                    "node": {
                        "template": {
                            "api_token": {
                                "name": "api_token",
                                "value": "token1",
                                "password": True
                            }
                        }
                    }
                }
            }
        ]
    }
    codeflash_output = strip_version_data(input_data); result = codeflash_output


def test_strip_version_data_handles_mixed_nodes():
    """Test that only API keys are stripped, other fields remain."""
    input_data = {
        "nodes": [
            {
                "data": {
                    "node": {
                        "template": {
                            "api_key": {
                                "name": "api_key",
                                "value": "secret",
                                "password": True
                            },
                            "regular_param": {
                                "name": "regular_param",
                                "value": "keep_this"
                            }
                        }
                    }
                }
            }
        ]
    }
    codeflash_output = strip_version_data(input_data); result = codeflash_output


def test_strip_version_data_with_missing_data_key():
    """Test that missing 'data' key returns the input as-is."""
    input_data = {"something": "else"}
    codeflash_output = strip_version_data(input_data); result = codeflash_output


def test_strip_version_data_with_non_dict_node_data():
    """Test that non-dict node data is skipped gracefully."""
    input_data = {
        "nodes": [
            {
                "data": "not_a_dict"
            }
        ]
    }
    codeflash_output = strip_version_data(input_data); result = codeflash_output


def test_strip_version_data_with_non_dict_node_inner():
    """Test that non-dict node inner data is skipped gracefully."""
    input_data = {
        "nodes": [
            {
                "data": {
                    "node": "not_a_dict"
                }
            }
        ]
    }
    codeflash_output = strip_version_data(input_data); result = codeflash_output


def test_strip_version_data_with_non_dict_template():
    """Test that non-dict template is skipped gracefully."""
    input_data = {
        "nodes": [
            {
                "data": {
                    "node": {
                        "template": "not_a_dict"
                    }
                }
            }
        ]
    }
    codeflash_output = strip_version_data(input_data); result = codeflash_output


def test_strip_version_data_with_empty_nodes_list():
    """Test that empty nodes list returns empty structure."""
    input_data = {"nodes": []}
    codeflash_output = strip_version_data(input_data); result = codeflash_output


def test_strip_version_data_with_malformed_template_value():
    """Test that non-dict template values are skipped."""
    input_data = {
        "nodes": [
            {
                "data": {
                    "node": {
                        "template": {
                            "field": "not_a_dict"
                        }
                    }
                }
            }
        ]
    }
    codeflash_output = strip_version_data(input_data); result = codeflash_output


def test_strip_version_data_with_missing_name_in_template_value():
    """Test that template values without 'name' key are skipped."""
    input_data = {
        "nodes": [
            {
                "data": {
                    "node": {
                        "template": {
                            "field": {
                                "value": "something",
                                "password": True
                            }
                        }
                    }
                }
            }
        ]
    }
    codeflash_output = strip_version_data(input_data); result = codeflash_output


def test_strip_version_data_with_missing_password_flag():
    """Test that template values without 'password' key are not stripped."""
    input_data = {
        "nodes": [
            {
                "data": {
                    "node": {
                        "template": {
                            "api_key": {
                                "name": "api_key",
                                "value": "secret"
                            }
                        }
                    }
                }
            }
        ]
    }
    codeflash_output = strip_version_data(input_data); result = codeflash_output


def test_strip_version_data_with_false_password_flag():
    """Test that fields with password=False are not stripped."""
    input_data = {
        "nodes": [
            {
                "data": {
                    "node": {
                        "template": {
                            "api_key": {
                                "name": "api_key",
                                "value": "secret",
                                "password": False
                            }
                        }
                    }
                }
            }
        ]
    }
    codeflash_output = strip_version_data(input_data); result = codeflash_output


def test_strip_version_data_with_tokens_plural():
    """Test that 'tokens' (plural) fields are not stripped."""
    input_data = {
        "nodes": [
            {
                "data": {
                    "node": {
                        "template": {
                            "api_tokens": {
                                "name": "api_tokens",
                                "value": "token_list",
                                "password": True
                            }
                        }
                    }
                }
            }
        ]
    }
    codeflash_output = strip_version_data(input_data); result = codeflash_output


def test_strip_version_data_with_deeply_nested_structure():
    """Test that deeply nested structures are handled correctly."""
    input_data = {
        "nodes": [
            {
                "id": "node1",
                "data": {
                    "node": {
                        "template": {
                            "api_key": {
                                "name": "api_key",
                                "value": "secret",
                                "password": True,
                                "extra_nested": {"deep": "value"}
                            }
                        }
                    }
                }
            }
        ]
    }
    codeflash_output = strip_version_data(input_data); result = codeflash_output


def test_strip_version_data_handles_error_with_non_dict_input():
    """Test that non-dict input (but not None) is handled gracefully."""
    # This tests the error handling in strip_version_data
    try:
        codeflash_output = strip_version_data("not_a_dict"); result = codeflash_output
    except Exception:
        # If it raises, that's acceptable for non-dict input
        pass


def test_strip_version_data_does_not_modify_original_deeply():
    """Test that deep copy prevents modification of nested original structures."""
    original_value = {"nested": "data"}
    input_data = {
        "nodes": [
            {
                "data": {
                    "node": {
                        "template": {
                            "field": original_value
                        }
                    }
                }
            }
        ]
    }
    codeflash_output = strip_version_data(input_data); result = codeflash_output


def test_strip_version_data_with_empty_string_value():
    """Test that empty string values in API keys are stripped."""
    input_data = {
        "nodes": [
            {
                "data": {
                    "node": {
                        "template": {
                            "api_key": {
                                "name": "api_key",
                                "value": "",
                                "password": True
                            }
                        }
                    }
                }
            }
        ]
    }
    codeflash_output = strip_version_data(input_data); result = codeflash_output


def test_strip_version_data_with_none_value():
    """Test that None values in API keys are set to None again."""
    input_data = {
        "nodes": [
            {
                "data": {
                    "node": {
                        "template": {
                            "api_key": {
                                "name": "api_key",
                                "value": None,
                                "password": True
                            }
                        }
                    }
                }
            }
        ]
    }
    codeflash_output = strip_version_data(input_data); result = codeflash_output


def test_strip_version_data_with_numeric_value():
    """Test that numeric values in API keys are stripped."""
    input_data = {
        "nodes": [
            {
                "data": {
                    "node": {
                        "template": {
                            "api_key": {
                                "name": "api_key",
                                "value": 12345,
                                "password": True
                            }
                        }
                    }
                }
            }
        ]
    }
    codeflash_output = strip_version_data(input_data); result = codeflash_output


def test_strip_version_data_with_case_insensitive_api_check():
    """Test that API term detection works with different cases."""
    # Testing lowercase "api" in the field name
    input_data = {
        "nodes": [
            {
                "data": {
                    "node": {
                        "template": {
                            "api_key": {
                                "name": "api_key",
                                "value": "secret",
                                "password": True
                            }
                        }
                    }
                }
            }
        ]
    }
    codeflash_output = strip_version_data(input_data); result = codeflash_output


def test_strip_version_data_with_uppercase_api():
    """Test that uppercase API in field name is detected (if applicable)."""
    # This tests if the implementation is case-sensitive
    input_data = {
        "nodes": [
            {
                "data": {
                    "node": {
                        "template": {
                            "API_KEY": {
                                "name": "API_KEY",
                                "value": "secret",
                                "password": True
                            }
                        }
                    }
                }
            }
        ]
    }
    codeflash_output = strip_version_data(input_data); result = codeflash_output


def test_strip_version_data_with_multiple_api_fields():
    """Test that multiple API fields in one template are all stripped."""
    input_data = {
        "nodes": [
            {
                "data": {
                    "node": {
                        "template": {
                            "api_key": {
                                "name": "api_key",
                                "value": "key1",
                                "password": True
                            },
                            "api_token": {
                                "name": "api_token",
                                "value": "token1",
                                "password": True
                            },
                            "regular_field": {
                                "name": "regular_field",
                                "value": "keep_this"
                            }
                        }
                    }
                }
            }
        ]
    }
    codeflash_output = strip_version_data(input_data); result = codeflash_output


def test_strip_version_data_with_many_nodes():
    """Test that strip_version_data handles large number of nodes efficiently."""
    # Create 100 nodes with mixed content
    nodes = []
    for i in range(100):
        nodes.append({
            "data": {
                "node": {
                    "template": {
                        "api_key": {
                            "name": "api_key",
                            "value": f"secret_{i}",
                            "password": True
                        },
                        "regular_param": {
                            "name": "regular_param",
                            "value": f"value_{i}"
                        }
                    }
                }
            }
        })
    input_data = {"nodes": nodes}
    codeflash_output = strip_version_data(input_data); result = codeflash_output
    # Verify all API keys were stripped
    for i in range(100):
        pass


def test_strip_version_data_with_large_template():
    """Test that strip_version_data handles templates with many fields."""
    # Create a template with 200 fields
    template = {}
    for i in range(200):
        if i % 2 == 0:
            # Make some API keys
            template[f"api_key_{i}"] = {
                "name": f"api_key_{i}",
                "value": f"secret_{i}",
                "password": True
            }
        else:
            # Make some regular fields
            template[f"field_{i}"] = {
                "name": f"field_{i}",
                "value": f"value_{i}"
            }
    
    input_data = {
        "nodes": [
            {
                "data": {
                    "node": {
                        "template": template
                    }
                }
            }
        ]
    }
    codeflash_output = strip_version_data(input_data); result = codeflash_output
    
    # Verify API keys were stripped
    for i in range(200):
        if i % 2 == 0:
            pass
        else:
            pass


def test_strip_version_data_with_many_nodes_and_large_templates():
    """Test strip_version_data with a large combined dataset."""
    # Create 50 nodes, each with 50 template fields
    nodes = []
    for node_idx in range(50):
        template = {}
        for field_idx in range(50):
            if (node_idx + field_idx) % 3 == 0:
                # API key fields
                template[f"api_key_{node_idx}_{field_idx}"] = {
                    "name": f"api_key_{node_idx}_{field_idx}",
                    "value": f"secret_{node_idx}_{field_idx}",
                    "password": True
                }
            else:
                # Regular fields
                template[f"field_{node_idx}_{field_idx}"] = {
                    "name": f"field_{node_idx}_{field_idx}",
                    "value": f"value_{node_idx}_{field_idx}"
                }
        
        nodes.append({
            "data": {
                "node": {
                    "template": template
                }
            }
        })
    
    input_data = {"nodes": nodes}
    codeflash_output = strip_version_data(input_data); result = codeflash_output
    # Sample check: verify some API keys were stripped
    api_key_found = False
    for node in result["nodes"]:
        for field_name, field_data in node["data"]["node"]["template"].items():
            if "api_key" in field_name:
                api_key_found = True


def test_strip_version_data_performance_with_varied_structures():
    """Test performance with varied and realistic structures."""
    nodes = []
    for i in range(100):
        # Mix of different node structures
        if i % 3 == 0:
            # Full structure
            nodes.append({
                "id": f"node_{i}",
                "data": {
                    "node": {
                        "template": {
                            "api_key": {
                                "name": "api_key",
                                "value": f"secret_{i}",
                                "password": True
                            },
                            "param1": {
                                "name": "param1",
                                "value": f"val1_{i}"
                            }
                        }
                    }
                }
            })
        elif i % 3 == 1:
            # Minimal structure
            nodes.append({
                "data": {
                    "node": {
                        "template": {}
                    }
                }
            })
        else:
            # Structure missing some required nesting
            nodes.append({
                "data": None
            })
    
    input_data = {"nodes": nodes}
    codeflash_output = strip_version_data(input_data); 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.

To edit these changes git checkout codeflash/optimize-pr11859-2026-03-02T16.24.03 and push.

[github-actions]

Frontend Unit Test Coverage Report

Coverage Summary

Lines	Statements	Branches	Functions
	22.42% (7810/34822)	15.27% (4172/27315)	15.21% (1119/7355)

Unit Test Results

Tests	Skipped	Failures	Errors	Time
2527	0 💤	0 ❌	0 🔥	43.066s ⏱️

[codecov]

Codecov Report

❌ Patch coverage is 42.10526% with 22 lines in your changes missing coverage. Please review.
✅ Project coverage is 33.35%. Comparing base (9a14aa6) to head (fba5833).
⚠️ Report is 20 commits behind head on workflow-history.

Files with missing lines	Patch %	Lines
src/backend/base/langflow/api/v1/flow_version.py	42.10%	22 Missing ⚠️

❌ Your project status has failed because the head coverage (41.47%) is below the target coverage (60.00%). You can increase the head coverage or adjust the target coverage.

Additional details and impacted files

@@                 Coverage Diff                  @@
##           workflow-history   #11971      +/-   ##
====================================================
- Coverage             36.45%   33.35%   -3.10%     
====================================================
  Files                  1590     1594       +4     
  Lines                 77133    77409     +276     
  Branches              11740    11740              
====================================================
- Hits                  28117    25823    -2294     
- Misses                47406    49976    +2570     
  Partials               1610     1610              

Flag	Coverage Δ
backend	44.82% <42.10%> (-11.59%)	⬇️
frontend	20.14% <ø> (ø)
lfx	41.47% <ø> (ø)

Flags with carried forward coverage won't be shown. Click here to find out more.

Files with missing lines	Coverage Δ
src/backend/base/langflow/api/v1/flow_version.py	41.33% <42.10%> (ø)

... and 123 files with indirect coverage changes

🚀 New features to boost your workflow:

• ❄️ Test Analytics: Detect flaky tests, report on failures, and find test suite problems.
• 📦 JS Bundle Analysis: Save yourself from yourself by tracking and limiting bundle sizes in JS merges.

[ogabrielluiz]

Closing automated codeflash PR.