⚡️ Speed up function apply_tweaks by 14% in PR #10880 (fix/image-upload-gemini-anthropic-chat-output)

[codeflash-ai]

⚡️ This pull request contains optimizations for PR #10880

If you approve this dependent PR, these changes will be merged into the original PR branch fix/image-upload-gemini-anthropic-chat-output.

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

---

📄 14% (0.14x) speedup for apply_tweaks in src/backend/base/langflow/processing/process.py

⏱️ Runtime : 2.22 milliseconds → 1.96 milliseconds (best of 149 runs)

📝 Explanation and details

The optimized code achieves a 13% speedup through several targeted micro-optimizations that reduce Python method call overhead and dictionary lookup costs in the hot loop:

Key Performance Improvements:

1. Early returns for missing data: The original code used chained .get() calls (node.get("data", {}).get("node", {}).get("template")) which creates temporary empty dictionaries. The optimized version splits this into separate checks with early returns, avoiding unnecessary object creation when data is missing.

2. Cached method references: Pre-fetches template_data.get and entry.__setitem__ to avoid repeated attribute lookups in the tight loop. This is particularly beneficial since the loop processes 5,000+ iterations in the profiler data.

3. String constant hoisting: Moves frequently-used string literals ("code", "NestedDict", "file_path", etc.) outside the loop to eliminate repeated string object creation and interning overhead.

4. Reduced dictionary operations: Instead of checking tweak_name not in template_data followed by tweak_name in template_data, it directly calls template_data.get(tweak_name) and checks for None, eliminating one dictionary lookup per iteration.

5. Optimized inner loops: For the isinstance(tweak_value, dict) branch, caches entry.__setitem__ to avoid repeated method lookups when updating multiple key-value pairs.

Impact on Performance:
The profiler shows the main bottlenecks are in the dictionary operations and the validate_and_repair_json call (which remains unchanged). The optimizations primarily target the ~70% of execution time spent on dictionary lookups and method calls, explaining the meaningful 13% improvement.

Test Case Analysis:
The optimizations are most effective for large-scale scenarios like test_large_scale_many_fields (1000 fields) and test_large_scale_partial_tweaks, where the reduced per-iteration overhead compounds significantly. Basic functionality remains identical across all test cases.

✅ Correctness verification report:

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

⚙️ Existing Unit Tests and Runtime

🌀 Generated Regression Tests and Runtime

from typing import Any

# imports
import pytest
from langflow.processing.process import apply_tweaks


# Dummy logger and validate_and_repair_json for testing (since we can't import real ones)
class DummyLogger:
    def __init__(self):
        self.warnings = []
    def warning(self, msg):
        self.warnings.append(msg)

test_logger = DummyLogger()

def validate_and_repair_json(value):
    # For testing, just return the value unchanged unless it's a string
    if isinstance(value, str):
        # Simulate "repair": try to parse as dict if possible
        import json
        try:
            return json.loads(value)
        except Exception:
            return value
    return value
from langflow.processing.process import apply_tweaks

# --- Unit tests ---

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

def test_basic_value_override():
    # Test overriding a simple value field
    node = {
        "data": {
            "node": {
                "template": {
                    "param1": {"type": "str", "value": "old"}
                }
            }
        }
    }
    tweaks = {"param1": "new"}
    apply_tweaks(node, tweaks)

def test_basic_ignore_missing_tweak():
    # Tweak not present in template should be ignored
    node = {
        "data": {
            "node": {
                "template": {
                    "param1": {"type": "str", "value": "old"}
                }
            }
        }
    }
    tweaks = {"nonexistent": "value"}
    apply_tweaks(node, tweaks)

def test_basic_file_type_override():
    # For "file" type, should set "file_path" instead of "value"
    node = {
        "data": {
            "node": {
                "template": {
                    "upload": {"type": "file", "file_path": "old/path.txt"}
                }
            }
        }
    }
    tweaks = {"upload": "new/path.txt"}
    apply_tweaks(node, tweaks)

def test_basic_dict_tweak():
    # If tweak_value is a dict, should update keys in the field dict
    node = {
        "data": {
            "node": {
                "template": {
                    "settings": {"type": "dict", "value": {"a": 1}}
                }
            }
        }
    }
    tweaks = {"settings": {"a": 2, "b": 3}}
    apply_tweaks(node, tweaks)

def test_basic_mcp_type():
    # For mcp type, value should be set directly
    node = {
        "data": {
            "node": {
                "template": {
                    "mcp_field": {"type": "mcp", "value": {"x": 1}}
                }
            }
        }
    }
    tweaks = {"mcp_field": {"x": 2, "y": 3}}
    apply_tweaks(node, tweaks)

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

def test_edge_template_data_not_dict():
    # Should warn and not fail if template is not a dict
    node = {
        "id": "test1",
        "data": {
            "node": {
                "template": None
            }
        }
    }
    tweaks = {"param": "value"}
    test_logger.warnings.clear()
    apply_tweaks(node, tweaks)

def test_edge_code_field_not_overridden():
    # Should warn and NOT override code fields
    node = {
        "data": {
            "node": {
                "template": {
                    "code": {"type": "str", "value": "safe"}
                }
            }
        }
    }
    tweaks = {"code": "malicious"}
    test_logger.warnings.clear()
    apply_tweaks(node, tweaks)

def test_edge_nested_dict_type():
    # For NestedDict, should use validate_and_repair_json
    node = {
        "data": {
            "node": {
                "template": {
                    "config": {"type": "NestedDict", "value": {"x": 1}}
                }
            }
        }
    }
    tweaks = {"config": '{"x":2,"y":3}'}
    apply_tweaks(node, tweaks)

def test_edge_file_type_with_dict():
    # For file type, if tweak_value is a dict, should set file_path for each key
    node = {
        "data": {
            "node": {
                "template": {
                    "upload": {"type": "file", "file_path": "old/path.txt"}
                }
            }
        }
    }
    tweaks = {"upload": {"main": "main.txt", "backup": "backup.txt"}}
    apply_tweaks(node, tweaks)
    # The dict keys are replaced by "file_path" for each, so only one key, overwritten

def test_edge_tweak_value_is_none():
    # If tweak value is None, should set field to None
    node = {
        "data": {
            "node": {
                "template": {
                    "param1": {"type": "str", "value": "old"}
                }
            }
        }
    }
    tweaks = {"param1": None}
    apply_tweaks(node, tweaks)

def test_edge_template_missing():
    # If template is missing, should not throw
    node = {
        "data": {
            "node": {
                # no template key
            }
        }
    }
    tweaks = {"param": "value"}
    test_logger.warnings.clear()
    apply_tweaks(node, tweaks)

def test_edge_empty_tweaks():
    # If tweaks is empty, nothing should change
    node = {
        "data": {
            "node": {
                "template": {
                    "param1": {"type": "str", "value": "old"}
                }
            }
        }
    }
    tweaks = {}
    apply_tweaks(node, tweaks)

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

def test_large_scale_many_fields():
    # Test with a template with 1000 fields and 1000 tweaks
    N = 1000
    node = {
        "data": {
            "node": {
                "template": {f"field{i}": {"type": "str", "value": f"old{i}"} for i in range(N)}
            }
        }
    }
    tweaks = {f"field{i}": f"new{i}" for i in range(N)}
    apply_tweaks(node, tweaks)
    for i in range(N):
        pass

def test_large_scale_partial_tweaks():
    # Only half of the fields are tweaked
    N = 1000
    node = {
        "data": {
            "node": {
                "template": {f"field{i}": {"type": "str", "value": f"old{i}"} for i in range(N)}
            }
        }
    }
    tweaks = {f"field{i}": f"new{i}" for i in range(0, N, 2)}
    apply_tweaks(node, tweaks)
    for i in range(N):
        expected = f"new{i}" if i % 2 == 0 else f"old{i}"

def test_large_scale_nested_dict():
    # 100 NestedDict fields with JSON string tweaks
    N = 100
    node = {
        "data": {
            "node": {
                "template": {
                    f"nd{i}": {"type": "NestedDict", "value": {"x": i}} for i in range(N)
                }
            }
        }
    }
    tweaks = {f"nd{i}": f'{{"x":{i+1}}}' for i in range(N)}
    apply_tweaks(node, tweaks)
    for i in range(N):
        pass

def test_large_scale_mcp_fields():
    # 100 mcp fields, each with a dict
    N = 100
    node = {
        "data": {
            "node": {
                "template": {
                    f"mcp{i}": {"type": "mcp", "value": {"y": i}} for i in range(N)
                }
            }
        }
    }
    tweaks = {f"mcp{i}": {"y": i+1, "z": i+2} for i in range(N)}
    apply_tweaks(node, tweaks)
    for i in range(N):
        pass

def test_large_scale_file_type_dicts():
    # 100 file fields, each with a dict tweak
    N = 100
    node = {
        "data": {
            "node": {
                "template": {
                    f"file{i}": {"type": "file", "file_path": f"old{i}.txt"} for i in range(N)
                }
            }
        }
    }
    tweaks = {f"file{i}": {"main": f"main{i}.txt", "backup": f"backup{i}.txt"} for i in range(N)}
    apply_tweaks(node, tweaks)
    for i in range(N):
        pass
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
from typing import Any

# imports
import pytest
from langflow.processing.process import apply_tweaks


# Dummy logger and validate_and_repair_json for test isolation
class DummyLogger:
    def __init__(self):
        self.warnings = []
    def warning(self, msg):
        self.warnings.append(msg)
logger = DummyLogger()

def validate_and_repair_json(value):
    # For testing: return value unchanged if dict, else raise error
    if isinstance(value, dict):
        return value
    raise ValueError("Invalid JSON")
from langflow.processing.process import apply_tweaks

# --- Unit tests ---

# ----------- BASIC TEST CASES -----------
def test_basic_value_update():
    # Test updating a simple value field
    node = {
        "data": {
            "node": {
                "template": {
                    "param": {"type": "str", "value": "old"}
                }
            }
        }
    }
    tweaks = {"param": "new"}
    apply_tweaks(node, tweaks)

def test_basic_file_type_update():
    # Test updating a file type field
    node = {
        "data": {
            "node": {
                "template": {
                    "file_param": {"type": "file", "file_path": "/old/path"}
                }
            }
        }
    }
    tweaks = {"file_param": "/new/path"}
    apply_tweaks(node, tweaks)

def test_basic_dict_update():
    # Test updating a dict field (not NestedDict)
    node = {
        "data": {
            "node": {
                "template": {
                    "dict_param": {"type": "dict", "value": {"a": 1}}
                }
            }
        }
    }
    tweaks = {"dict_param": {"b": 2}}
    apply_tweaks(node, tweaks)

def test_basic_mcp_update():
    # Test updating an mcp type field
    node = {
        "data": {
            "node": {
                "template": {
                    "mcp_param": {"type": "mcp", "value": {"x": 1}}
                }
            }
        }
    }
    tweaks = {"mcp_param": {"y": 2}}
    apply_tweaks(node, tweaks)

def test_basic_nested_dict_update():
    # Test updating a NestedDict type field
    node = {
        "data": {
            "node": {
                "template": {
                    "nested_param": {"type": "NestedDict", "value": {"foo": "bar"}}
                }
            }
        }
    }
    tweaks = {"nested_param": {"baz": "qux"}}
    apply_tweaks(node, tweaks)

# ----------- EDGE TEST CASES -----------
def test_template_data_not_dict():
    # If template_data is not a dict, should log warning and not change node
    node = {
        "id": "node1",
        "data": {
            "node": {
                "template": "not_a_dict"
            }
        }
    }
    tweaks = {"param": "new"}
    logger.warnings.clear()
    apply_tweaks(node, tweaks)

def test_tweak_name_not_in_template():
    # If tweak_name not in template, should skip
    node = {
        "data": {
            "node": {
                "template": {
                    "param": {"type": "str", "value": "old"}
                }
            }
        }
    }
    tweaks = {"not_in_template": "new"}
    apply_tweaks(node, tweaks)

def test_code_field_cannot_be_overridden():
    # If tweak_name is 'code', should log warning and skip
    node = {
        "data": {
            "node": {
                "template": {
                    "code": {"type": "str", "value": "print('hello')"}
                }
            }
        }
    }
    tweaks = {"code": "print('malicious code')"}
    logger.warnings.clear()
    apply_tweaks(node, tweaks)

def test_file_type_dict_update():
    # If tweak_value is dict and type is file, should update file_path
    node = {
        "data": {
            "node": {
                "template": {
                    "file_param": {"type": "file", "file_path": "/old/path"}
                }
            }
        }
    }
    tweaks = {"file_param": {"file_path": "/new/path", "other": "ignored"}}
    apply_tweaks(node, tweaks)


def test_empty_tweaks():
    # If tweaks is empty, nothing should change
    node = {
        "data": {
            "node": {
                "template": {
                    "param": {"type": "str", "value": "old"}
                }
            }
        }
    }
    tweaks = {}
    apply_tweaks(node, tweaks)

def test_missing_template_key():
    # If node['data']['node']['template'] is missing, should not fail
    node = {
        "data": {
            "node": {
                # No 'template' key
            }
        }
    }
    tweaks = {"param": "new"}
    apply_tweaks(node, tweaks)  # Should not raise

def test_missing_data_key():
    # If node['data'] is missing, should not fail
    node = {}
    tweaks = {"param": "new"}
    apply_tweaks(node, tweaks)  # Should not raise

def test_missing_node_key():
    # If node['data']['node'] is missing, should not fail
    node = {"data": {}}
    tweaks = {"param": "new"}
    apply_tweaks(node, tweaks)  # Should not raise

def test_tweak_value_dict_non_file_type():
    # If tweak_value is dict and type is not file, should update keys directly
    node = {
        "data": {
            "node": {
                "template": {
                    "dict_param": {"type": "dict", "value": {"a": 1}}
                }
            }
        }
    }
    tweaks = {"dict_param": {"b": 2, "c": 3}}
    apply_tweaks(node, tweaks)

# ----------- LARGE SCALE TEST CASES -----------
def test_large_number_of_tweaks():
    # Test with 1000 tweaks
    template = {f"param{i}": {"type": "str", "value": f"old{i}"} for i in range(1000)}
    node = {
        "data": {
            "node": {
                "template": template
            }
        }
    }
    tweaks = {f"param{i}": f"new{i}" for i in range(1000)}
    apply_tweaks(node, tweaks)
    for i in range(1000):
        pass

def test_large_nested_dicts():
    # Test with 500 NestedDict fields
    template = {f"nested{i}": {"type": "NestedDict", "value": {"old": i}} for i in range(500)}
    node = {
        "data": {
            "node": {
                "template": template
            }
        }
    }
    tweaks = {f"nested{i}": {"new": i} for i in range(500)}
    apply_tweaks(node, tweaks)
    for i in range(500):
        pass

def test_large_mcp_fields():
    # Test with 500 mcp fields
    template = {f"mcp{i}": {"type": "mcp", "value": {"old": i}} for i in range(500)}
    node = {
        "data": {
            "node": {
                "template": template
            }
        }
    }
    tweaks = {f"mcp{i}": {"new": i} for i in range(500)}
    apply_tweaks(node, tweaks)
    for i in range(500):
        pass

def test_large_file_fields():
    # Test with 500 file fields, updating file_path
    template = {f"file{i}": {"type": "file", "file_path": f"/old/{i}"} for i in range(500)}
    node = {
        "data": {
            "node": {
                "template": template
            }
        }
    }
    tweaks = {f"file{i}": f"/new/{i}" for i in range(500)}
    apply_tweaks(node, tweaks)
    for i in range(500):
        pass

def test_large_mixed_types():
    # Test with a mix of types and tweaks
    template = {
        f"param{i}": {"type": "str", "value": f"old{i}"} for i in range(250)
    }
    template.update({
        f"nested{i}": {"type": "NestedDict", "value": {"old": i}} for i in range(250)
    })
    template.update({
        f"file{i}": {"type": "file", "file_path": f"/old/{i}"} for i in range(250)
    })
    node = {
        "data": {
            "node": {
                "template": template
            }
        }
    }
    tweaks = {f"param{i}": f"new{i}" for i in range(250)}
    tweaks.update({f"nested{i}": {"new": i} for i in range(250)})
    tweaks.update({f"file{i}": f"/new/{i}" for i in range(250)})
    apply_tweaks(node, tweaks)
    for i in range(250):
        pass
# 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-pr10880-2025-12-04T19.03.38 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.}

[github-actions]

Frontend Unit Test Coverage Report

Coverage Summary

Lines	Statements	Branches	Functions
	15.45% (4251/27504)	8.62% (1812/21011)	9.7% (588/6059)

Unit Test Results

Tests	Skipped	Failures	Errors	Time
1671	0 💤	0 ❌	0 🔥	21.986s ⏱️

[codecov]

Codecov Report

❌ Patch coverage is 19.44444% with 174 lines in your changes missing coverage. Please review.
✅ Project coverage is 32.54%. Comparing base (a1ce944) to head (2c10967).
⚠️ Report is 57 commits behind head on release-1.7.0.

Files with missing lines	Patch %	Lines
...nd/src/pages/Playground/PlaygroundPage.stories.tsx	0.00%	97 Missing ⚠️
...rc/lfx/src/lfx/base/embeddings/embeddings_class.py	0.00%	21 Missing ⚠️
src/backend/base/langflow/processing/process.py	70.27%	11 Missing ⚠️
src/backend/base/langflow/api/v1/files.py	41.66%	7 Missing ⚠️
src/frontend/src/controllers/API/index.ts	14.28%	6 Missing ⚠️
src/lfx/src/lfx/base/agents/agent.py	0.00%	5 Missing ⚠️
src/frontend/src/icons/vLLM/index.tsx	0.00%	4 Missing ⚠️
...ntend/src/customization/utils/custom-buildUtils.ts	25.00%	3 Missing ⚠️
...l/components/IOFieldView/components/file-input.tsx	0.00%	3 Missing ⚠️
...c/controllers/API/queries/health/use-get-health.ts	0.00%	2 Missing ⚠️
... and 11 more

❌ Your patch status has failed because the patch coverage (19.44%) is below the target coverage (40.00%). You can increase the patch coverage or adjust the target coverage.
❌ Your project status has failed because the head coverage (39.95%) 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                @@
##           release-1.7.0   #10889      +/-   ##
=================================================
+ Coverage          32.45%   32.54%   +0.09%     
=================================================
  Files               1367     1370       +3     
  Lines              63315    63565     +250     
  Branches            9357     9393      +36     
=================================================
+ Hits               20547    20690     +143     
- Misses             41736    41835      +99     
- Partials            1032     1040       +8     

Flag	Coverage Δ
backend	51.53% <63.26%> (+0.24%)	⬆️
frontend	14.30% <5.30%> (+0.17%)	⬆️
lfx	39.95% <11.42%> (-0.09%)	⬇️

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

Files with missing lines	Coverage Δ
src/frontend/src/CustomNodes/NoteNode/index.tsx	0.00% <ø> (ø)
...d/src/components/core/appHeaderComponent/index.tsx	0.00% <ø> (ø)
src/frontend/src/constants/constants.ts	95.26% <ø> (-0.05%)	⬇️
src/frontend/src/utils/styleUtils.ts	49.12% <ø> (ø)
src/lfx/src/lfx/base/tools/component_tool.py	40.62% <100.00%> (ø)
src/lfx/src/lfx/utils/image.py	84.00% <100.00%> (+6.22%)	⬆️
.../appHeaderComponent/components/langflow-counts.tsx	0.00% <0.00%> (ø)
.../frontend/src/controllers/API/helpers/constants.ts	60.00% <66.66%> (+4.44%)	⬆️
src/frontend/src/icons/eagerIconImports.ts	0.00% <0.00%> (ø)
src/frontend/src/icons/lazyIconImports.ts	0.52% <0.00%> (-0.01%)	⬇️
... and 17 more

... and 27 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.