feat: add code generation from Graphs generated in Python

src/backend/base/langflow/code_gen/component.py

@@ -0,0 +1,52 @@
+from langflow.code_gen.generic import generate_import_statement, get_variable_name
+
+
+def generate_call_string(instance):
+    variable_name = get_variable_name(instance)
+    if hasattr(instance, "_call_inputs"):
+        args = ", ".join(
+            f"{key}={get_variable_name(value.__self__)}.{value.__name__}" if callable(value) else f"{key}={repr(value)}"
+            for key, value in instance._call_inputs.items()
+        )
+        if args:
+            return f"{variable_name}.set({args})"
+
+
+def generate_instantiation_string(instance):
+    if isinstance(instance, tuple):
+        raise ValueError(
+            "An instance of Component was expected, but a tuple was provided. You might be trying to call the component instead of calling the `set` method."
+        )
+    class_name = instance.__class__.__name__
+    instance_id = instance._id
+    variable_name = get_variable_name(instance)
+    return f"{variable_name} = {class_name}(_id='{instance_id}')"
+
+
+def generate_graph_instantiation_string(entry, _exit):
+    return f"graph = Graph(entry={get_variable_name(entry)}, exit={get_variable_name(_exit)})"
+
+
+def generate_script(*, instances, entry=None, exit=None):
+    import_statements = set()
+    instantiation_strings = []
+    call_strings = []
+
+    for instance in instances:
+        import_statements.add(generate_import_statement(instance))
+        instantiation_strings.append(generate_instantiation_string(instance))
+        call_string = generate_call_string(instance)
+
+        if call_string:
+            call_strings.append(call_string)
+
+    if entry is None or exit is None:
+        graph_instantiation_code = ""
+    else:
+        graph_instantiation_code = generate_graph_instantiation_string(entry, exit)
+        # Add Graph import statement to the beginning of the script
+        import_statements.add("from langflow.graph.graph.base import Graph")
+    import_code = "\n".join(sorted(import_statements))
+    instantiation_code = "\n".join(instantiation_strings)
+    call_code = "\n".join(call_strings)
+    return f"{import_code}\n\n{instantiation_code}\n\n{call_code}\n\n{graph_instantiation_code}".strip()

src/backend/base/langflow/code_gen/generic.py

@@ -0,0 +1,20 @@
+import re
+
+
+def get_variable_name(instance):
+    return re.sub(r"[^0-9a-zA-Z_]", "_", instance._id.lower())
+
+
+def generate_import_statement(instance):
+    class_name = instance.__class__.__name__
+    module_path = instance.__class__.__module__
+    if module_path == "langflow.utils.validate":
+        raise ValueError("Generating script from JSON is not yet supported.")
+    parts = module_path.split(".")
+
+    # Construct the correct import statement
+    if len(parts) > 2:
+        module_path = ".".join(parts)
+        return f"from {module_path} import {class_name}"
+    else:
+        return f"from {module_path} import {class_name}"

src/backend/base/langflow/code_gen/graph.py

@@ -0,0 +1,11 @@
+from git import TYPE_CHECKING
+
+from langflow.code_gen.component import generate_script
+
+if TYPE_CHECKING:
+    from langflow.graph.graph.base import Graph
+
+
+def generate_script_from_graph(graph: "Graph"):
+    script = generate_script(entry=graph.entry, exit=graph.exit, instances=graph.sort_components())
+    return script

src/backend/base/langflow/custom/custom_component/component.py

@@ -58,6 +58,7 @@ def __init__(self, **kwargs):
         self._parameters = inputs or {}
         self._edges: list[EdgeData] = []
         self._components: list[Component] = []
+        self._call_inputs: dict[str, Any] = {}
         self._current_output = ""
         self._event_manager: EventManager | None = None
         self._state_model = None
@@ -82,6 +83,9 @@ def __init__(self, **kwargs):
         self._set_output_types()
         self.set_class_code()
 
+    def _set_call_inputs(self, key: str, value: Any):
+        self._call_inputs[key] = value
+
     def set_event_manager(self, event_manager: EventManager | None = None):
         self._event_manager = event_manager
 
@@ -363,6 +367,7 @@ def _process_connection_or_parameter(self, key, value):
             self._connect_to_component(key, value, _input)
         else:
             self._set_parameter_or_attribute(key, value)
+        self._set_call_inputs(key, value)
 
     def _process_connection_or_parameters(self, key, value):
         # if value is a list of components, we need to process each component

src/backend/base/langflow/graph/graph/base.py

@@ -53,8 +53,8 @@
 
     def __init__(
         self,
-        start: Optional["Component"] = None,
-        end: Optional["Component"] = None,
+        entry: Optional["Component"] = None,
+        exit: Optional["Component"] = None,
         flow_id: str | None = None,
         flow_name: str | None = None,
         description: str | None = None,
@@ -71,9 +71,9 @@
         """
         if log_config:
             configure(**log_config)
         self._start = start
         self._state_model = None
         self._end = end
         self._prepared = False
         self._runs = 0
         self._updates = 0
@@ -110,6 +110,8 @@
         self._first_layer: list[str] = []
         self._lock = asyncio.Lock()
         self.raw_graph_data: GraphData = {"nodes": [], "edges": []}
+        self._entry = None
+        self._exit = None
         self._is_cyclic: bool | None = None
         self._cycles: list[tuple[str, str]] | None = None
         self._call_order: list[str] = []
@@ -119,10 +121,10 @@
         except Exception as exc:
             logger.error(f"Error getting tracing service: {exc}")
             self.tracing_service = None
-        if start is not None and end is not None:
-            self._set_start_and_end(start, end)
-            self.prepare(start_component_id=start._id)
-        if (start is not None and end is None) or (start is None and end is not None):
+        if entry is not None and exit is not None:
+            self._set_entry_and_exit(entry, exit)
+            self.prepare(start_component_id=entry._id)
+        if (entry is not None and exit is None) or (entry is None and exit is not None):
             raise ValueError("You must provide both input and output components")
 
     @property
@@ -225,13 +227,60 @@
 
         return component_id
 
-    def _set_start_and_end(self, start: "Component", end: "Component"):
-        if not hasattr(start, "to_frontend_node"):
-            raise TypeError(f"start must be a Component. Got {type(start)}")
-        if not hasattr(end, "to_frontend_node"):
-            raise TypeError(f"end must be a Component. Got {type(end)}")
-        self.add_component(start, start._id)
-        self.add_component(end, end._id)
+    def _find_entry(self):
+        # Find a vertex with a "ChatInput" component, overriding a "TextInput" component
+        found_entry = None
+        for vertex_id in self._is_input_vertices:
+            if "ChatInput" in vertex_id:
+                found_entry = vertex_id
+                break
+            elif found_entry is None and "TextInput" in vertex_id:
+                found_entry = vertex_id
+        vertex = self.get_vertex(found_entry) if found_entry else None
+        return vertex.get_component_instance() if vertex else None
+
+    @property
+    def entry(self):
+        if self._entry is None:
+            if entry := self._find_entry():
+                self._entry = entry
+            else:
+                raise ValueError(
+                    "Graph has no entry component or couldn't find a suitable entry component (e.g. ChatInput)"
+                )
+        return self._entry
+
+    def _find_exit(self):
+        # Find a vertex with a "ChatOutput" component, overriding a "TextOutput" component
+        found_exit = None
+        for vertex_id in self._is_output_vertices:
+            if "ChatOutput" in vertex_id:
+                found_exit = vertex_id
+                break
+            elif found_exit is None and "TextOutput" in vertex_id:
+                found_exit = vertex_id
+        vertex = self.get_vertex(found_exit) if found_exit else None
+
+        return vertex.get_component_instance() if vertex else None
+
+    @property
+    def exit(self):
+        if self._exit is None:
+            if _exit := self._find_exit():
+                self._exit = _exit
+            else:
+                raise ValueError("Graph has no exit component")
+        return self._exit
+
+    def _set_entry_and_exit(self, entry: "Component", exit: "Component"):
+        if not hasattr(entry, "to_frontend_node"):
+            raise TypeError(f"start must be a Component. Got {type(entry)}")
+        if not hasattr(exit, "to_frontend_node"):
+            raise TypeError(f"end must be a Component. Got {type(exit)}")
+        self._entry = entry
+        self._exit = exit
+        self.add_component(entry._id, entry)
+        self.add_component(exit._id, exit)
 
     def add_component_edge(self, source_id: str, output_input_tuple: tuple[str, str], target_id: str):
         source_vertex = self.get_vertex(source_id)
@@ -1886,12 +1935,12 @@
         vertex_ids = sort_up_to_vertex(dictionaryized_graph, vertex_id, is_start)
         return [self.get_vertex(vertex_id) for vertex_id in vertex_ids]
 
-    def sort_vertices(
+    def _sort_vertices(
         self,
         stop_component_id: str | None = None,
         start_component_id: str | None = None,
-    ) -> list[str]:
-        """Sorts the vertices in the graph."""
+        flatten: bool = False,
+    ):
         self.mark_all_vertices("ACTIVE")
         if stop_component_id is not None:
             self.stop_vertex = stop_component_id
@@ -1912,6 +1961,32 @@
         # Now we should sort each layer in a way that we make sure
         # vertex V does not depend on vertex V+1
         vertices_layers = self.sort_layer_by_dependency(vertices_layers)
+        if flatten:
+            vertices_layers = chain.from_iterable(vertices_layers)
+        return vertices_layers
+
+    def sort_components(
+        self, stop_component_id: Optional[str] = None, start_component_id: Optional[str] = None
+    ) -> List[str]:
+        """Sorts the vertices in the graph."""
+        vertices_layers = self._sort_vertices(
+            stop_component_id=stop_component_id, start_component_id=start_component_id, flatten=True
+        )
+        # Now get all the vertices instances
+        vertices = [self.get_vertex(vertex_id) for vertex_id in vertices_layers]
+        # Now we need to get the components
+        components = [vertex.get_component_instance() for vertex in vertices if hasattr(vertex, "_custom_component")]
+        return components
+
+    def sort_vertices(
+        self,
+        stop_component_id: Optional[str] = None,
+        start_component_id: Optional[str] = None,
+    ) -> List[str]:
+        """Sorts the vertices in the graph."""
+        vertices_layers = self._sort_vertices(
+            stop_component_id=stop_component_id, start_component_id=start_component_id
+        )
         self.increment_run_count()
         self._sorted_vertices_layers = vertices_layers
         first_layer = vertices_layers[0]

src/backend/base/langflow/graph/vertex/base.py

@@ -6,7 +6,8 @@
 import types
 from collections.abc import AsyncIterator, Callable, Iterator, Mapping
 from enum import Enum
-from typing import TYPE_CHECKING, Any, Optional
+from typing import TYPE_CHECKING, Any, AsyncIterator, Callable, Dict, Iterator, List, Mapping, Optional
+from uuid import UUID
 
 import pandas as pd
 from loguru import logger
@@ -24,6 +25,7 @@
 from langflow.schema.schema import INPUT_FIELD_NAME, OutputValue, build_output_logs
 from langflow.services.deps import get_storage_service
 from langflow.services.tracing.schema import Log
+from langflow.utils.async_helpers import run_until_complete
 from langflow.utils.constants import DIRECT_TYPES
 from langflow.utils.schemas import ChatOutputResponse
 from langflow.utils.util import sync_to_async, unescape_string
@@ -464,9 +466,7 @@
             raise ValueError(f"Base type for vertex {self.display_name} not found")
 
         if not self._custom_component:
-            custom_component, custom_params = await initialize.loading.instantiate_class(
-                user_id=user_id, vertex=self, event_manager=event_manager
-            )
+            custom_component, custom_params = await self._build_instance(user_id, event_manager)
         else:
             custom_component = self._custom_component
             self._custom_component.set_event_manager(event_manager)
@@ -482,7 +482,35 @@
 
         self._built = True
 
-    def extract_messages_from_artifacts(self, artifacts: dict[str, Any]) -> list[dict]:
+    async def _build_instance(self, user_id: Optional[str | UUID] = None, event_manager=None):
+        """
+        Builds the instance of the component.
+        """
+        if self._custom_component is not None:
+            raise ValueError("Component is already built.")
+        custom_component, custom_params = await initialize.loading.instantiate_class(
+            user_id=user_id, vertex=self, event_manager=event_manager
+        )
+        return custom_component, custom_params
+
+    def get_component_instance(self, user_id: Optional[str | UUID] = None):
+        """
+        Retrieves the instance of the component.
+
+        Args:
+            user_id (Optional[str | UUID], optional): The user ID. Defaults to None.
+
+        Returns:
+            Any: The instance of the component.
+
+        Raises:
+            ValueError: If the component is not built.
+        """
+        if not self._custom_component:
+            self._custom_component = run_until_complete(self._build_instance(user_id))[0]
+        return self._custom_component
+
+    def extract_messages_from_artifacts(self, artifacts: Dict[str, Any]) -> List[dict]:
         """
         Extracts messages from the artifacts.
 

src/backend/tests/unit/code_gen/test_component_codegen.py

@@ -0,0 +1,37 @@
+import pytest
+
+from langflow import components
+from langflow.code_gen.component import generate_instantiation_string, generate_script
+from langflow.code_gen.generic import generate_import_statement
+
+
+@pytest.fixture
+def client():
+    pass
+
+
+def test_generate_script():
+    chat_input = components.inputs.ChatInput(_id="chatInput-1230")
+    text_output = components.outputs.TextOutput.TextOutputComponent(_id="textoutput-1231")
+    text_output.set(input_value=chat_input.message_response)
+    script = generate_script(instances=(chat_input, text_output), entry=chat_input, exit=text_output)
+    assert (
+        script
+        == """from langflow.components.inputs.ChatInput import ChatInput
+from langflow.components.outputs.TextOutput import TextOutputComponent
+
+chatinput_1230 = ChatInput(_id='chatInput-1230')
+textoutput_1231 = TextOutputComponent(_id='textoutput-1231')
+
+textoutput_1231.set(input_value=chatinput_1230.message_response)
+
+graph = Graph(entry=chatinput_1230, exit=textoutput_1231)"""
+    )
+
+
+def test_generate_import_statement_and_instantiation_string():
+    chat_input_instance = components.inputs.ChatInput(_id="chatInput-1230")
+    import_statement = generate_import_statement(chat_input_instance)
+    instantiation_string = generate_instantiation_string(chat_input_instance)
+    assert import_statement == "from langflow.components.inputs.ChatInput import ChatInput"
+    assert instantiation_string == "chatinput_1230 = ChatInput(_id='chatInput-1230')"

src/backend/tests/unit/code_gen/test_graph_codegen.py

@@ -0,0 +1,27 @@
+from langflow import components
+from langflow.code_gen.graph import generate_script_from_graph
+from langflow.graph.graph.base import Graph
+
+
+def test_gerenate_script_from_graph():
+    chat_input = components.inputs.ChatInput(_id="chatInput-1230")
+    text_output = components.outputs.TextOutput.TextOutputComponent(_id="textoutput-1231")
+    text_output.set(input_value=chat_input.message_response)
+    chat_output = components.outputs.ChatOutput(input_value="test", _id="chatOutput-1232")
+    chat_output.set(input_value=text_output.text_response)
+
+    graph = Graph(chat_input, chat_output)
+    script = generate_script_from_graph(graph)
+    assert (
+        script
+        == """from langflow.components.inputs.ChatInput import ChatInput
+from langflow.components.outputs.ChatOutput import ChatOutput
+from langflow.components.outputs.TextOutput import TextOutputComponent
+
+chatinput_1230 = ChatInput(_id='chatInput-1230')
+textoutput_1231 = TextOutputComponent(_id='textoutput-1231')
+chatoutput_1232 = ChatOutput(_id='chatOutput-1232')
+
+textoutput_1231(input_value=chatinput_1230.message_response)
+chatoutput_1232(input_value=textoutput_1231.text_response)"""
+    )