feat: make it possible to load graphs using get_graph function in scripts

[ogabrielluiz]

Makes how to define Graph scripts that require async calls a bit clearer

Summary by CodeRabbit

• New Features
  • Scripts can now expose a get_graph entry point (async or sync) for building flows.
  • CLI commands seamlessly load graphs asynchronously from Python scripts or JSON, with backward compatibility for existing graph variables.
• Refactor
  • Migrated graph-loading paths to async for more reliable initialization and tooling setup.
  • Serve command updated to support async execution without changing usage.
• Tests
  • Converted related unit and integration tests to async to validate new loading behavior.

[coderabbitai]

Important

Review skipped

Auto incremental reviews are disabled on this repository.

Please check the settings in the CodeRabbit UI or the .coderabbit.yaml file in this repository. 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.

Walkthrough

The codebase shifts graph construction and loading to an asynchronous model. Scripts now expose an async get_graph() factory (fallback to module-level graph remains). CLI loaders and serve command were updated to await async paths. Unit tests were converted to async accordingly, with imports and calls adjusted.

Changes

Cohort / File(s)	Summary
Async graph factory in test data script src/backend/tests/data/simple_agent.py	Replaces module-level graph with async get_graph() that builds components, awaits URL toolkit creation, and returns Graph; removes import-time side effects.
CLI serve command async wrapper src/lfx/src/lfx/cli/commands.py	Converts serve_command to async, decorates with syncify wrapper, and awaits load_graph_from_path/load_graph_from_script; imports updated.
Common loader async src/lfx/src/lfx/cli/common.py	Makes load_graph_from_path async; awaits Python-script loader path; JSON path unchanged.
Run path awaiting src/lfx/src/lfx/cli/run.py	Awaits load_graph_from_script for Python scripts; aligns with async loading.
Script loader supports get_graph src/lfx/src/lfx/cli/script_loader.py	load_graph_from_script becomes async; detects and invokes get_graph (awaits if coroutine) or falls back to module.graph; enhances AST discovery to include get_graph metadata; validates Graph instance.
Tests: lfx common src/lfx/tests/unit/cli/test_common.py	Marks tests async; awaits load_graph_from_path; adds verbose error assertion.
Tests: script loader src/lfx/tests/unit/cli/test_script_loader.py	Converts tests to async; awaits loader; updates expectations; adds tests for async/sync get_graph; updates integration tests accordingly.
Tests: serve components src/lfx/tests/unit/cli/test_serve_components.py	Converts tests to async; awaits load_graph_from_path; maintains mocks; adapts integration flow.
Unit test referencing script content src/backend/tests/unit/test_simple_agent_in_lfx_run.py	Updates assertions to expect async get_graph(), awaiting url_component.to_toolkit(), and returning Graph inside get_graph.

Sequence Diagram(s)

sequenceDiagram
  autonumber
  actor User
  participant CLI as CLI (serve_command)
  participant Common as common.load_graph_from_path
  participant Loader as script_loader.load_graph_from_script
  participant Mod as Target Script Module
  participant Graph as Graph Instance

  User->>CLI: Invoke serve (path or script)
  note over CLI: serve_command is async (syncified)
  alt JSON file
    CLI->>Common: await load_graph_from_path(path)
    Common-->>CLI: Graph
  else Python script
    CLI->>Loader: await load_graph_from_script(script_path)
    alt get_graph exists
      Loader->>Mod: get_graph()
      opt async get_graph
        Loader->>Mod: await get_graph()
      end
      Mod-->>Loader: Graph
    else legacy graph variable
      Loader->>Mod: access module.graph
      Mod-->>Loader: Graph
    else none
      Loader-->>CLI: Error (no graph or get_graph)
    end
    Loader-->>CLI: Graph
  end
  CLI->>Graph: use returned Graph
  CLI-->>User: Server started with Graph

Loading

Estimated code review effort

🎯 4 (Complex) | ⏱️ ~60 minutes

Suggested labels

enhancement, refactor, size:M, lgtm

Suggested reviewers

• edwinjosechittilappilly
• jordanrfrazier
• mfortman11

Pre-merge checks and finishing touches

✅ Passed checks (3 passed)

Check name	Status	Explanation
Title Check	✅ Passed	The PR title accurately and succinctly summarizes the main change: adding support for loading graphs via a get_graph() function in scripts, which aligns with the edits to the script loader, CLI, agent scripts, and tests that add async/sync get_graph handling.
Docstring Coverage	✅ Passed	Docstring coverage is 89.29% which is sufficient. The required threshold is 80.00%.
Description Check	✅ Passed	Check skipped - CodeRabbit’s high-level summary is enabled.

---

Thanks for using CodeRabbit! It's free for OSS, and your support helps us grow. If you like it, consider giving us a shout-out.

❤️ Share

• X
• Mastodon
• Reddit
• LinkedIn

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

[ogabrielluiz]

@Cristhianzl this will fix some of the changes you made in #9901

[codecov]

Codecov Report

❌ Patch coverage is 67.85714% with 9 lines in your changes missing coverage. Please review.
✅ Project coverage is 31.61%. Comparing base (927f96b) to head (981f96e).
⚠️ Report is 3 commits behind head on main.

Files with missing lines	Patch %	Lines
src/lfx/src/lfx/cli/script_loader.py	63.15%	5 Missing and 2 partials ⚠️
src/lfx/src/lfx/cli/commands.py	83.33%	1 Missing ⚠️
src/lfx/src/lfx/cli/common.py	50.00%	1 Missing ⚠️

❌ Your project status has failed because the head coverage (38.94%) 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           @@
##             main    #9913   +/-   ##
=======================================
  Coverage   31.61%   31.61%           
=======================================
  Files        1348     1348           
  Lines       61117    61117           
  Branches     9134     9134           
=======================================
+ Hits        19324    19325    +1     
  Misses      40878    40878           
+ Partials      915      914    -1     

Flag	Coverage Δ
backend	51.77% <ø> (ø)
frontend	13.59% <ø> (ø)
lfx	38.94% <67.85%> (+<0.01%)	⬆️

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

Files with missing lines	Coverage Δ
src/lfx/src/lfx/cli/run.py	73.85% <100.00%> (ø)
src/lfx/src/lfx/cli/commands.py	53.20% <83.33%> (ø)
src/lfx/src/lfx/cli/common.py	39.74% <50.00%> (ø)
src/lfx/src/lfx/cli/script_loader.py	81.39% <63.15%> (ø)

... and 1 file 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.

[coderabbitai]

Actionable comments posted: 0

Caution

Some comments are outside the diff and can’t be posted inline due to platform limitations.

⚠️ Outside diff range comments (2)

src/backend/tests/unit/test_simple_agent_in_lfx_run.py (1)

328-359: Async mismatch: to_toolkit must be awaited; make test async.

Also mark with pytest.mark.asyncio.

-    @pytest.mark.skipif(not os.getenv("OPENAI_API_KEY"), reason="OPENAI_API_KEY required for integration test")
-    def test_complete_workflow_integration(self):
+    @pytest.mark.skipif(not os.getenv("OPENAI_API_KEY"), reason="OPENAI_API_KEY required for integration test")
+    @pytest.mark.asyncio
+    async def test_complete_workflow_integration(self):
@@
-        tools = url_component.to_toolkit()
+        tools = await url_component.to_toolkit()

src/lfx/src/lfx/cli/common.py (1)

246-263: Don’t hard‑fail when no 'graph' variable; allow get_graph‑only scripts.

Current precheck raises if the script lacks a module‑level graph, which blocks the PR goal (support get_graph()). We should proceed to runtime loading and let load_graph_from_script handle get_graph() or graph. Also, tweak the log to reflect this behavior.

Apply this diff:

         if file_extension == ".py":
             verbose_print("Analyzing Python script...")
             graph_var = find_graph_variable(script_path)
             if graph_var:
                 source_info = graph_var.get("source", "Unknown")
                 type_info = graph_var.get("type", "Unknown")
                 line_no = graph_var.get("line", "Unknown")
                 verbose_print(f"✓ Found 'graph' variable at line {line_no}")
                 verbose_print(f"  Type: {type_info}")
                 verbose_print(f"  Source: {source_info}")
             else:
-                error_msg = "No 'graph' variable found in script"
-                verbose_print(f"✗ {error_msg}")
-                raise ValueError(error_msg)
+                # Don't fail fast: allow get_graph() at runtime
+                verbose_print("No static 'graph' variable detected; will attempt to resolve via get_graph() at runtime.")
 
             verbose_print("Loading graph...")
-            graph = await load_graph_from_script(script_path)
+            graph = await load_graph_from_script(script_path)

🧹 Nitpick comments (22)

src/backend/tests/data/simple_agent.py (3)

29-32: Docstring: avoid “run_until_complete” (loader now awaits).

Simplify wording to reflect that the CLI loader awaits get_graph().

-    blocking the module loading process. The script loader will detect this
-    async function and handle it appropriately using run_until_complete.
+    blocking the module loading process. The script loader detects this
+    async function and awaits it in the CLI loader.

---

45-48: Guard URLComponent config before awaiting to_toolkit().

If no URLs are set, tool creation may be empty or error depending on defaults. Read from env for flexibility.

-    url_component = cp.URLComponent()
-    tools = await url_component.to_toolkit()
+    url_component = cp.URLComponent()
+    urls_env = os.getenv("AGENT_URLS")
+    if urls_env:
+        url_component.set(urls=[u.strip() for u in urls_env.split(",") if u.strip()])
+    tools = await url_component.to_toolkit()

---

49-55: Explicit API key handling.

Consider validating OPENAI_API_KEY early to fail-fast with a clear message.

-    agent.set(
+    api_key = os.getenv("OPENAI_API_KEY")
+    # Optional: raise if missing to avoid late failures
+    # if not api_key:
+    #     raise RuntimeError("OPENAI_API_KEY not set")
+    agent.set(
         model_name="gpt-4o-mini",
         agent_llm="OpenAI",
-        api_key=os.getenv("OPENAI_API_KEY"),
+        api_key=api_key,

src/backend/tests/unit/test_simple_agent_in_lfx_run.py (3)

160-160: Mark async test with pytest.mark.asyncio.

Required by backend test guidelines for async tests.

-    async def test_agent_workflow_direct_execution(self):
+    @pytest.mark.asyncio
+    async def test_agent_workflow_direct_execution(self):

---

229-229: Mark async test with pytest.mark.asyncio.

-    async def test_url_component_to_toolkit_functionality(self):
+    @pytest.mark.asyncio
+    async def test_url_component_to_toolkit_functionality(self):

---

193-196: Missing link: ChatOutput should receive agent.message_response.

Without this, the graph lacks the final edge.

-        chat_output = cp.ChatOutput()
+        chat_output = cp.ChatOutput().set(input_value=agent.message_response)

src/lfx/src/lfx/cli/script_loader.py (3)

3-5: Module docstring: include get_graph entrypoint.

-This module provides functionality to load and validate Python scripts
-containing LFX graph variables.
+This module provides functionality to load and validate Python scripts
+containing an LFX graph variable or a get_graph() entrypoint.

---

95-104: Handle functions that return awaitables (decorated async).

If get_graph() returns an awaitable but isn’t defined as a coroutinefunction, await the result.

-            if inspect.iscoroutinefunction(get_graph_func):
-                graph_obj = await get_graph_func()
-            else:
-                graph_obj = get_graph_func()
+            if inspect.iscoroutinefunction(get_graph_func):
+                graph_obj = await get_graph_func()
+            else:
+                graph_obj = get_graph_func()
+                if inspect.isawaitable(graph_obj):
+                    graph_obj = await graph_obj

---

210-238: Simplify AST detection for get_graph (sync/async) in one branch.

-        for node in ast.walk(tree):
-            # Check for get_graph function definition
-            if isinstance(node, ast.FunctionDef) and node.name == "get_graph":
-                line_number = node.lineno
-                is_async = isinstance(node, ast.AsyncFunctionDef)
-
-                return {
-                    "line_number": line_number,
-                    "type": "function_definition",
-                    "function": "get_graph",
-                    "is_async": is_async,
-                    "arg_count": len(node.args.args),
-                    "source_line": content.split("\n")[line_number - 1].strip(),
-                }
-
-            # Check for async get_graph function definition
-            if isinstance(node, ast.AsyncFunctionDef) and node.name == "get_graph":
-                line_number = node.lineno
-
-                return {
-                    "line_number": line_number,
-                    "type": "function_definition",
-                    "function": "get_graph",
-                    "is_async": True,
-                    "arg_count": len(node.args.args),
-                    "source_line": content.split("\n")[line_number - 1].strip(),
-                }
+        for node in ast.walk(tree):
+            # get_graph function definition (sync or async)
+            if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)) and node.name == "get_graph":
+                line_number = node.lineno
+                is_async = isinstance(node, ast.AsyncFunctionDef)
+                return {
+                    "line_number": line_number,
+                    "type": "function_definition",
+                    "function": "get_graph",
+                    "is_async": is_async,
+                    "arg_count": len(node.args.args),
+                    "source_line": content.split("\n")[line_number - 1].strip(),
+                }

src/lfx/src/lfx/cli/run.py (2)

180-189: Error/verbose text should include get_graph as entrypoint.

-            if not graph_info:
-                error_msg = (
-                    "No 'graph' variable found in the script. Expected to find an assignment like: graph = Graph(...)"
-                )
+            if not graph_info:
+                error_msg = (
+                    "No 'graph' entry point found. Expected get_graph() or a 'graph = Graph(...)' assignment."
+                )
                 raise ValueError(error_msg)
-            verbose_print(f"Found 'graph' variable at line {graph_info['line_number']}")
+            entry = "get_graph()" if graph_info.get("type") == "function_definition" else "graph variable"
+            verbose_print(f"Found {entry} at line {graph_info['line_number']}")
             verbose_print(f"Type: {graph_info['type']}")
             verbose_print(f"Source: {graph_info['source_line']}")

---

243-249: Component types debug should use vertex.custom_component.display_name.

-            component_types = set()
-            for vertex in graph.vertices:
-                if hasattr(vertex, "display_name"):
-                    component_types.add(vertex.display_name)
+            component_types = set()
+            for vertex in graph.vertices:
+                name = getattr(getattr(vertex, "custom_component", None), "display_name", None)
+                if name:
+                    component_types.add(name)

src/lfx/tests/unit/cli/test_script_loader.py (7)

173-177: Mark async test with pytest.mark.asyncio.

-    async def test_load_graph_from_script_success(self, simple_chat_py):
+    @pytest.mark.asyncio
+    async def test_load_graph_from_script_success(self, simple_chat_py):

---

188-197: Mark async test with pytest.mark.asyncio.

-    async def test_load_graph_from_script_no_graph_variable(self):
+    @pytest.mark.asyncio
+    async def test_load_graph_from_script_no_graph_variable(self):

---

200-206: Mark async test with pytest.mark.asyncio.

-    async def test_load_graph_from_script_import_error(self):
+    @pytest.mark.asyncio
+    async def test_load_graph_from_script_import_error(self):

---

207-233: Mark async test with pytest.mark.asyncio.

-    async def test_load_graph_from_script_with_async_get_graph(self):
+    @pytest.mark.asyncio
+    async def test_load_graph_from_script_with_async_get_graph(self):

---

234-260: Mark async test with pytest.mark.asyncio.

-    async def test_load_graph_from_script_with_sync_get_graph(self):
+    @pytest.mark.asyncio
+    async def test_load_graph_from_script_with_sync_get_graph(self):

---

562-566: Mark async test with pytest.mark.asyncio.

-    async def test_load_and_validate_real_script(self, simple_chat_py):
+    @pytest.mark.asyncio
+    async def test_load_and_validate_real_script(self, simple_chat_py):

---

577-581: Mark async test with pytest.mark.asyncio.

-    async def test_execute_real_flow_with_results(self, simple_chat_py):
+    @pytest.mark.asyncio
+    async def test_execute_real_flow_with_results(self, simple_chat_py):

src/lfx/src/lfx/cli/common.py (1)

267-273: Optional: surface ValueError messages even when not in verbose mode.

Right now ValueErrors are wrapped into typer.Exit(1) without echoing. Consider echoing the message when verbose is False to avoid silent exits.

Example:

     except ValueError as e:
-        # Re-raise ValueError as typer.Exit to preserve the error message
-        raise typer.Exit(1) from e
+        if not verbose:
+            typer.echo(f"✗ {e}", err=True)
+        raise typer.Exit(1) from e

src/lfx/src/lfx/cli/commands.py (2)

9-9: Prefer explicit decorator call over functools.partial for syncify.

@syncify(raise_sync_error=False) is clearer than @partial(syncify, ...) and avoids confusion about decorator semantics.

Apply this diff:

-from functools import partial
...
-from asyncer import syncify
+from asyncer import syncify
...
-@partial(syncify, raise_sync_error=False)
+@syncify(raise_sync_error=False)
 async def serve_command(

Also applies to: 14-15, 37-38

---

300-313: Nested event loop risk: uvicorn.run inside a syncified async function.

Because serve_command runs under syncify (which drives an event loop), calling uvicorn.run inside it can conflict with an already running loop in some environments. In practice this often works, but it’s brittle.

• Option A (verify): Manually run lfx serve in a context where an event loop is active (e.g., inside IPython/Jupyter) and confirm no “asyncio.run() cannot be called from a running event loop” or loop reuse errors appear.
• Option B (refactor): Keep serve_command as a plain sync function and syncify only the loader calls:

-@syncify(raise_sync_error=False)
-async def serve_command(...):
+def serve_command(...):
     ...
-    if resolved_path.suffix == ".json":
-        graph = await load_graph_from_path(...)
+    from asyncer import syncify as _syncify
+    _load_from_path_sync = _syncify(load_graph_from_path, raise_sync_error=False)
+    _load_from_script_sync = _syncify(load_graph_from_script, raise_sync_error=False)
+    if resolved_path.suffix == ".json":
+        graph = _load_from_path_sync(resolved_path, resolved_path.suffix, verbose_print, verbose=verbose)
     elif resolved_path.suffix == ".py":
-        graph = await load_graph_from_script(resolved_path)
+        graph = _load_from_script_sync(resolved_path)
     ...
     uvicorn.run(serve_app, ...)

This limits event‑loop usage to short-lived sections before starting Uvicorn.

src/lfx/tests/unit/cli/test_serve_components.py (1)

202-205: Add a unit test covering Python scripts that only expose get_graph().

Given the feature goal, add a test that patches a temp .py script with only async def get_graph(): ... and asserts load_graph_from_path(..., ".py", ...) succeeds.

I can draft a focused test that writes a temp script exposing only get_graph() (async and sync variants) and validates both paths. Want me to add it?

📜 Review details

Configuration used: Path: .coderabbit.yaml

Review profile: CHILL

Plan: Pro

📥 Commits

Reviewing files that changed from the base of the PR and between 780bc77 and 74b6875.

📒 Files selected for processing (9)

• src/backend/tests/data/simple_agent.py (1 hunks)
• src/backend/tests/unit/test_simple_agent_in_lfx_run.py (4 hunks)
• src/lfx/src/lfx/cli/commands.py (3 hunks)
• src/lfx/src/lfx/cli/common.py (2 hunks)
• src/lfx/src/lfx/cli/run.py (1 hunks)
• src/lfx/src/lfx/cli/script_loader.py (4 hunks)
• src/lfx/tests/unit/cli/test_common.py (2 hunks)
• src/lfx/tests/unit/cli/test_script_loader.py (4 hunks)
• src/lfx/tests/unit/cli/test_serve_components.py (5 hunks)

🧰 Additional context used

📓 Path-based instructions (3)

{src/backend/**/*.py,tests/**/*.py,Makefile}

📄 CodeRabbit inference engine (.cursor/rules/backend_development.mdc)

{src/backend/**/*.py,tests/**/*.py,Makefile}: Run make format_backend to format Python code before linting or committing changes
Run make lint to perform linting checks on backend Python code

Files:

• src/backend/tests/unit/test_simple_agent_in_lfx_run.py
• src/backend/tests/data/simple_agent.py

src/backend/tests/unit/**/*.py

📄 CodeRabbit inference engine (.cursor/rules/backend_development.mdc)

Test component integration within flows using create_flow, build_flow, and get_build_events utilities

Files:

• src/backend/tests/unit/test_simple_agent_in_lfx_run.py

src/backend/tests/**/*.py

📄 CodeRabbit inference engine (.cursor/rules/testing.mdc)

src/backend/tests/**/*.py: Unit tests for backend code must be located in the 'src/backend/tests/' directory, with component tests organized by component subdirectory under 'src/backend/tests/unit/components/'.
Test files should use the same filename as the component under test, with an appropriate test prefix or suffix (e.g., 'my_component.py' → 'test_my_component.py').
Use the 'client' fixture (an async httpx.AsyncClient) for API tests in backend Python tests, as defined in 'src/backend/tests/conftest.py'.
When writing component tests, inherit from the appropriate base class in 'src/backend/tests/base.py' (ComponentTestBase, ComponentTestBaseWithClient, or ComponentTestBaseWithoutClient) and provide the required fixtures: 'component_class', 'default_kwargs', and 'file_names_mapping'.
Each test in backend Python test files should have a clear docstring explaining its purpose, and complex setups or mocks should be well-commented.
Test both sync and async code paths in backend Python tests, using '@pytest.mark.asyncio' for async tests.
Mock external dependencies appropriately in backend Python tests to isolate unit tests from external services.
Test error handling and edge cases in backend Python tests, including using 'pytest.raises' and asserting error messages.
Validate input/output behavior and test component initialization and configuration in backend Python tests.
Use the 'no_blockbuster' pytest marker to skip the blockbuster plugin in tests when necessary.
Be aware of ContextVar propagation in async tests; test both direct event loop execution and 'asyncio.to_thread' scenarios to ensure proper context isolation.
Test error handling by mocking internal functions using monkeypatch in backend Python tests.
Test resource cleanup in backend Python tests by using fixtures that ensure proper initialization and cleanup of resources.
Test timeout and performance constraints in backend Python tests using 'asyncio.wait_for' and timing assertions.
Test Langflow's Messag...

Files:

• src/backend/tests/unit/test_simple_agent_in_lfx_run.py
• src/backend/tests/data/simple_agent.py

🧠 Learnings (6)

📚 Learning: 2025-07-21T14:16:14.125Z

Learnt from: CR
PR: langflow-ai/langflow#0
File: .cursor/rules/testing.mdc:0-0
Timestamp: 2025-07-21T14:16:14.125Z
Learning: Applies to src/backend/tests/**/*.py : Test both sync and async code paths in backend Python tests, using 'pytest.mark.asyncio' for async tests.

Applied to files:

• src/lfx/tests/unit/cli/test_common.py
• src/lfx/tests/unit/cli/test_script_loader.py
• src/lfx/tests/unit/cli/test_serve_components.py

📚 Learning: 2025-07-21T14:16:14.125Z

Learnt from: CR
PR: langflow-ai/langflow#0
File: .cursor/rules/testing.mdc:0-0
Timestamp: 2025-07-21T14:16:14.125Z
Learning: Applies to src/backend/tests/**/*.py : Use 'anyio' and 'aiofiles' for async file operations in backend Python tests that involve file handling.

Applied to files:

• src/lfx/tests/unit/cli/test_common.py
• src/lfx/tests/unit/cli/test_serve_components.py

📚 Learning: 2025-07-18T18:25:54.486Z

Learnt from: CR
PR: langflow-ai/langflow#0
File: .cursor/rules/backend_development.mdc:0-0
Timestamp: 2025-07-18T18:25:54.486Z
Learning: Applies to src/backend/base/langflow/components/**/*.py : Implement async component methods using async def and await for asynchronous operations

Applied to files:

• src/lfx/tests/unit/cli/test_serve_components.py

📚 Learning: 2025-07-21T14:16:14.125Z

Learnt from: CR
PR: langflow-ai/langflow#0
File: .cursor/rules/testing.mdc:0-0
Timestamp: 2025-07-21T14:16:14.125Z
Learning: Applies to src/backend/tests/**/*.py : Test Langflow's REST API endpoints in backend Python tests using the async client fixture and asserting response codes and payloads.

Applied to files:

• src/lfx/tests/unit/cli/test_serve_components.py

📚 Learning: 2025-07-18T18:25:54.487Z

Learnt from: CR
PR: langflow-ai/langflow#0
File: .cursor/rules/backend_development.mdc:0-0
Timestamp: 2025-07-18T18:25:54.487Z
Learning: Applies to src/backend/tests/unit/**/*.py : Test component integration within flows using create_flow, build_flow, and get_build_events utilities

Applied to files:

• src/lfx/tests/unit/cli/test_serve_components.py

📚 Learning: 2025-08-05T22:51:27.961Z

Learnt from: edwinjosechittilappilly
PR: langflow-ai/langflow#0
File: :0-0
Timestamp: 2025-08-05T22:51:27.961Z
Learning: The TestComposioComponentAuth test in src/backend/tests/unit/components/bundles/composio/test_base_composio.py demonstrates proper integration testing patterns for external API components, including real API calls with mocking for OAuth completion, comprehensive resource cleanup, and proper environment variable handling with pytest.skip() fallbacks.

Applied to files:

• src/lfx/tests/unit/cli/test_serve_components.py

🧬 Code graph analysis (7)

src/lfx/src/lfx/cli/run.py (1)

src/lfx/src/lfx/cli/script_loader.py (1)

• load_graph_from_script (75-120)

src/lfx/tests/unit/cli/test_common.py (2)

src/lfx/tests/unit/cli/test_serve_components.py (9)

• test_load_graph_from_path_success (204-218)
• verbose_print (186-187)
• verbose_print (196-197)
• verbose_print (213-214)
• verbose_print (230-231)
• verbose_print (265-266)
• verbose_print (280-281)
• verbose_print (301-302)
• verbose_print (449-450)

src/lfx/src/lfx/cli/common.py (1)

• load_graph_from_path (227-274)

src/backend/tests/data/simple_agent.py (2)

src/lfx/src/lfx/custom/custom_component/component.py (1)

• to_toolkit (1314-1335)

src/backend/base/langflow/__main__.py (1)

• api_key (847-895)

src/lfx/src/lfx/cli/common.py (1)

src/lfx/src/lfx/cli/script_loader.py (1)

• load_graph_from_script (75-120)

src/lfx/tests/unit/cli/test_script_loader.py (1)

src/lfx/src/lfx/cli/script_loader.py (1)

• load_graph_from_script (75-120)

src/lfx/tests/unit/cli/test_serve_components.py (2)

src/lfx/tests/unit/cli/test_common.py (1)

• test_load_graph_from_path_success (172-186)

src/lfx/src/lfx/cli/common.py (1)

• load_graph_from_path (227-274)

src/lfx/src/lfx/cli/commands.py (2)

src/lfx/src/lfx/cli/common.py (1)

• load_graph_from_path (227-274)

src/lfx/src/lfx/cli/script_loader.py (1)

• load_graph_from_script (75-120)

⏰ Context from checks skipped due to timeout of 90000ms. You can increase the timeout in your CodeRabbit configuration to a maximum of 15 minutes (900000ms). (11)

• GitHub Check: Lint Backend / Run Mypy (3.10)
• GitHub Check: Run Backend Tests / Unit Tests - Python 3.10 - Group 4
• GitHub Check: Lint Backend / Run Mypy (3.11)
• GitHub Check: Lint Backend / Run Mypy (3.12)
• GitHub Check: Lint Backend / Run Mypy (3.13)
• GitHub Check: Run Backend Tests / Unit Tests - Python 3.10 - Group 5
• GitHub Check: Run Backend Tests / Unit Tests - Python 3.10 - Group 2
• GitHub Check: Run Backend Tests / Unit Tests - Python 3.10 - Group 3
• GitHub Check: Run Backend Tests / Unit Tests - Python 3.10 - Group 1
• GitHub Check: Test Starter Templates
• GitHub Check: Run Backend Tests / Integration Tests - Python 3.10

🔇 Additional comments (9)

src/backend/tests/data/simple_agent.py (1)

56-58: LGTM: graph construction and wiring look correct.

src/backend/tests/unit/test_simple_agent_in_lfx_run.py (2)

115-120: Script content assertions: good coverage of async get_graph path.

---

1-1: Backend test hygiene — run format + lint.

Verification failed here: /bin/bash: line 3: make: command not found. Run make format_backend and make lint locally or in CI and commit any resulting fixes (target: src/backend/tests/unit/test_simple_agent_in_lfx_run.py).

src/lfx/tests/unit/cli/test_common.py (2)

171-173: Async test conversion looks correct.

Awaiting load_graph_from_path and marking the test with pytest.mark.asyncio matches the new async API. Assertions for verbose behavior and disable_logs are solid.

Also applies to: 181-181

---

188-190: Failure-path assertions are accurate.

Mocking the loader to raise and asserting Typer exit + error log ensures the async error path is covered.

Also applies to: 196-201

src/lfx/src/lfx/cli/commands.py (1)

201-209: LGTM: async awaits for loaders in serve path.

Awaiting both JSON and Python script loaders matches the new async interfaces and keeps logs consistent.

src/lfx/tests/unit/cli/test_serve_components.py (3)

203-205: Async migration of success test is correct.

Awaiting load_graph_from_path and asserting disable_logs=False when verbose=True is spot on.

Also applies to: 216-216

---

221-223: Error-path test updated correctly.

Awaiting the async loader and asserting disable_logs=True verifies the quiet mode path.

Also applies to: 233-235

---

435-436: Integration test aligns with async API.

End‑to‑end uses of load_graph_from_path are consistent and validate flow ID + app wiring.

Also applies to: 453-454

[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

[jordanrfrazier]

Nice. Tested this locally, works great.