feat: import Graph without position information

.vscode/launch.json

@@ -1,7 +1,6 @@
 {
   "version": "0.2.0",
   "configurations": [
-
     {
       "name": "Debug Backend",
       "type": "debugpy",
@@ -18,7 +17,7 @@
         "--loop",
         "asyncio",
         "--reload-include",
-        "src/backend/*"
+        "./src/backend/*"
       ],
       "jinja": true,
       "justMyCode": false,

src/backend/base/langflow/components/helpers/Memory.py

@@ -1,13 +1,13 @@
+from langchain.memory import ConversationBufferMemory
+
 from langflow.custom import Component
+from langflow.field_typing import BaseChatMemory
 from langflow.helpers.data import data_to_text
 from langflow.inputs import HandleInput
 from langflow.io import DropdownInput, IntInput, MessageTextInput, MultilineInput, Output
-from langflow.memory import get_messages, LCBuiltinChatMemory
+from langflow.memory import LCBuiltinChatMemory, get_messages
 from langflow.schema import Data
 from langflow.schema.message import Message
-from langflow.field_typing import BaseChatMemory
-from langchain.memory import ConversationBufferMemory
-
 from langflow.utils.constants import MESSAGE_SENDER_AI, MESSAGE_SENDER_USER
 
 
@@ -118,5 +118,5 @@ def build_lc_memory(self) -> BaseChatMemory:
         if self.memory:
             chat_memory = self.memory
         else:
-            chat_memory = LCBuiltinChatMemory(flow_id=self.graph.flow_id, session_id=self.session_id)
+            chat_memory = LCBuiltinChatMemory(flow_id=self.flow_id, session_id=self.session_id)
         return ConversationBufferMemory(chat_memory=chat_memory)

src/backend/base/langflow/custom/__init__.py

@@ -1,4 +1,4 @@
-from langflow.custom.custom_component import CustomComponent
 from langflow.custom.custom_component.component import Component
+from langflow.custom.custom_component.custom_component import CustomComponent
 
 __all__ = ["CustomComponent", "Component"]

src/backend/base/langflow/custom/code_parser/code_parser.py

@@ -384,7 +384,7 @@ def parse_global_vars(self, node: ast.Assign) -> None:
 
     def execute_and_inspect_classes(self, code: str):
         custom_component_class = eval_custom_component_code(code)
-        custom_component = custom_component_class()
+        custom_component = custom_component_class(_code=code)
         dunder_class = custom_component.__class__
         # Get the base classes at two levels of inheritance
         bases = []

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

@@ -1,3 +0,0 @@
-from .custom_component import CustomComponent
-
-__all__ = ["CustomComponent"]

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

@@ -97,7 +97,7 @@ def build_template_config(self) -> dict:
             return {}
 
         cc_class = eval_custom_component_code(self._code)
-        component_instance = cc_class()
+        component_instance = cc_class(_code=self._code)
         template_config = self.get_template_config(component_instance)
         return template_config
 

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

@@ -6,9 +6,7 @@
 import yaml
 from pydantic import BaseModel
 
-from langflow.graph.edge.schema import EdgeData
 from langflow.helpers.custom import format_type
-from langflow.inputs.inputs import InputTypes
 from langflow.schema.artifact import get_artifact_type, post_process_raw
 from langflow.schema.data import Data
 from langflow.schema.message import Message
@@ -20,13 +18,15 @@
 from .custom_component import CustomComponent
 
 if TYPE_CHECKING:
+    from langflow.graph.edge.schema import EdgeData
     from langflow.graph.vertex.base import Vertex
+    from langflow.inputs.inputs import InputTypes
 
 BACKWARDS_COMPATIBLE_ATTRIBUTES = ["user_id", "vertex", "tracing_service"]
 
 
 class Component(CustomComponent):
-    inputs: List[InputTypes] = []
+    inputs: List["InputTypes"] = []
     outputs: List[Output] = []
     code_class_base_inheritance: ClassVar[str] = "Component"
     _output_logs: dict[str, Log] = {}
@@ -41,7 +41,7 @@ def __init__(self, **kwargs):
                 config[key] = value
             else:
                 inputs[key] = value
-        self._inputs: dict[str, InputTypes] = {}
+        self._inputs: dict[str, "InputTypes"] = {}
         self._outputs: dict[str, Output] = {}
         self._results: dict[str, Any] = {}
         self._attributes: dict[str, Any] = {}
@@ -64,6 +64,20 @@ def __init__(self, **kwargs):
             self.map_outputs(self.outputs)
         # Set output types
         self._set_output_types()
+        self.set_class_code()
+
+    def set_class_code(self):
+        # Get the source code of the calling class
+        if self._code:
+            return
+        try:
+            module = inspect.getmodule(self.__class__)
+            if module is None:
+                raise ValueError("Could not find module for class")
+            class_code = inspect.getsource(module)
+            self._code = class_code
+        except OSError:
+            raise ValueError(f"Could not find source code for {self.__class__.__name__}")
 
     def set(self, **kwargs):
         """
@@ -174,7 +188,7 @@ def map_outputs(self, outputs: List[Output]):
                 raise ValueError("Output name cannot be None.")
             self._outputs[output.name] = output
 
-    def map_inputs(self, inputs: List[InputTypes]):
+    def map_inputs(self, inputs: List["InputTypes"]):
         """
         Maps the given inputs to the component.
 
@@ -272,7 +286,7 @@ def _add_edge(self, component, key, output, _input):
                 "target": self._id,
                 "data": {
                     "sourceHandle": {
-                        "dataType": self.name,
+                        "dataType": component.name or component.__class__.__name__,
                         "id": component._id,
                         "name": output.name,
                         "output_types": output.types,
@@ -366,6 +380,21 @@ def to_frontend_node(self):
         self._map_parameters_on_template(frontend_node_dict["template"])
 
         frontend_node = ComponentFrontendNode.from_dict(frontend_node_dict)
+        if not self._code:
+            self.set_class_code()
+        code_field = Input(
+            dynamic=True,
+            required=True,
+            placeholder="",
+            multiline=True,
+            value=self._code,
+            password=False,
+            name="code",
+            advanced=True,
+            field_type="code",
+            is_list=False,
+        )
+        frontend_node.template.add_field(code_field)
 
         for output in frontend_node.outputs:
             if output.types:
@@ -379,7 +408,7 @@ def to_frontend_node(self):
         data = {
             "data": {
                 "node": frontend_node.to_dict(keep_name=False),
-                "type": self.__class__.__name__,
+                "type": self.name or self.__class__.__name__,
             }
         }
         return data

src/backend/base/langflow/custom/utils.py

@@ -283,7 +283,7 @@ def get_component_instance(custom_component: CustomComponent, user_id: Optional[
         ) from exc
 
     try:
-        custom_instance = custom_class(_user_id=user_id)
+        custom_instance = custom_class(_user_id=user_id, _code=custom_component._code)
         return custom_instance
     except Exception as exc:
         logger.error(f"Error while instantiating custom component: {str(exc)}")
@@ -339,7 +339,7 @@ def run_build_config(
         raise exc
 
 
-def add_code_field(frontend_node: CustomComponentFrontendNode, raw_code, field_config):
+def add_code_field(frontend_node: CustomComponentFrontendNode, raw_code):
     code_field = Input(
         dynamic=True,
         required=True,
@@ -364,7 +364,7 @@ def build_custom_component_template_from_inputs(
     cc_instance = get_component_instance(custom_component, user_id=user_id)
     field_config = cc_instance.get_template_config(cc_instance)
     frontend_node = ComponentFrontendNode.from_inputs(**field_config)
-    frontend_node = add_code_field(frontend_node, custom_component._code, field_config.get("code", {}))
+    frontend_node = add_code_field(frontend_node, custom_component._code)
     # But we now need to calculate the return_type of the methods in the outputs
     for output in frontend_node.outputs:
         if output.types:
@@ -408,7 +408,7 @@ def build_custom_component_template(
 
         add_extra_fields(frontend_node, field_config, entrypoint_args)
 
-        frontend_node = add_code_field(frontend_node, custom_component._code, field_config.get("code", {}))
+        frontend_node = add_code_field(frontend_node, custom_component._code)
 
         add_base_classes(frontend_node, custom_component.get_function_entrypoint_return_type)
         add_output_types(frontend_node, custom_component.get_function_entrypoint_return_type)