fixes

Author: nicoloboschi

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

@@ -474,8 +474,6 @@ def _map_parameters_on_template(self, template: dict):
         for name, value in self._parameters.items():
             try:
                 template[name]["value"] = value
-                if value and "load_from_db" in template[name]:
-                    template[name]["load_from_db"] = False
             except KeyError:
                 close_match = find_closest_match(name, list(template.keys()))
                 if close_match:
@@ -499,6 +497,8 @@ def to_frontend_node(self):
         #! works and then update this later
         field_config = self.get_template_config(self)
         frontend_node = ComponentFrontendNode.from_inputs(**field_config)
+        for key, value in self._inputs.items():
+            frontend_node.set_field_load_from_db_in_template(key, False)
         self._map_parameters_on_frontend_node(frontend_node)
 
         frontend_node_dict = frontend_node.to_dict(keep_name=False)

src/backend/base/langflow/interface/initialize/loading.py

@@ -112,8 +112,8 @@ def update_params_with_load_from_db_fields(
                 try:
                     key = custom_component.variables(params[field], field)
                 except ValueError as e:
-                    # check if "User id is not set" is in the error message
-                    if "User id is not set" in str(e) and not fallback_to_env_vars:
+                    # check if "User id is not set" is in the error message, this is an internal bug
+                    if "User id is not set" in str(e):
                         raise e
                     logger.debug(str(e))
                 if fallback_to_env_vars and key is None:

src/backend/base/langflow/template/frontend_node/base.py

@@ -184,3 +184,9 @@ def set_field_value_in_template(self, field_name, value):
             if field.name == field_name:
                 field.value = value
                 break
+
+    def set_field_load_from_db_in_template(self, field_name, value):
+        for field in self.template.fields:
+            if field.name == field_name and hasattr(field, "load_from_db"):
+                field.load_from_db = value
+                break

src/backend/tests/integration/components/astra/test_astra_component.py

@@ -1,10 +1,15 @@
 import os
+from typing import List
 
 from astrapy.db import AstraDB
 import pytest
 
+from langflow.components.embeddings import OpenAIEmbeddingsComponent
+from langflow.custom import Component
+from langflow.inputs import StrInput
+from langflow.template import Output
 from tests.api_keys import get_astradb_application_token, get_astradb_api_endpoint, get_openai_api_key
-from tests.integration.utils import MockEmbeddings, check_env_vars, valid_nvidia_vectorize_region
+from tests.integration.utils import MockEmbeddings, check_env_vars, valid_nvidia_vectorize_region, ComponentInputHandle
 from langchain_core.documents import Document
 
 
@@ -38,46 +43,51 @@ def astradb_client(request):
 
 @pytest.mark.api_key_required
 @pytest.mark.asyncio
-async def test_astra_setup(astradb_client: AstraDB):
+async def test_base(astradb_client: AstraDB):
     from langflow.components.embeddings import OpenAIEmbeddingsComponent
-    open_ai_embeddings = OpenAIEmbeddingsComponent(openai_api_key=get_openai_api_key())
     application_token = get_astradb_application_token()
     api_endpoint = get_astradb_api_endpoint()
-    #embedding = MockEmbeddings()
 
 
     results = await run_single_component(AstraVectorStoreComponent, inputs={
         "token": application_token,
         "api_endpoint": api_endpoint,
         "collection_name": BASIC_COLLECTION,
-        "embedding": open_ai_embeddings,
+        "embedding": ComponentInputHandle(clazz=OpenAIEmbeddingsComponent, inputs={"openai_api_key": get_openai_api_key()}, output_name="embeddings"),
     })
-    print(results)
+    from langchain_core.vectorstores import VectorStoreRetriever
+    assert isinstance(results["base_retriever"], VectorStoreRetriever)
+    assert results["vector_store"] is not None
+    assert results["search_results"] == []
     assert astradb_client.collection(BASIC_COLLECTION)
 
+
+class TextToData(Component):
+    inputs = [
+        StrInput(name="text_data",is_list=True)
+    ]
+    outputs = [
+        Output(name="data", display_name="Data", method="create_data")
+    ]
+    def create_data(self) -> List[Data]:
+        return [Data(text=t) for t in self.text_data]
 @pytest.mark.api_key_required
-def test_astra_embeds_and_search():
+@pytest.mark.asyncio
+async def test_astra_embeds_and_search():
     application_token = get_astradb_application_token()
     api_endpoint = get_astradb_api_endpoint()
-    embedding = MockEmbeddings()
-
-    documents = [Document(page_content="test1"), Document(page_content="test2")]
-    records = [Data.from_document(d) for d in documents]
-
-    component = AstraVectorStoreComponent()
-    component.build(
-        token=application_token,
-        api_endpoint=api_endpoint,
-        collection_name=SEARCH_COLLECTION,
-        embedding=embedding,
-        ingest_data=records,
-        search_input="test1",
-        number_of_results=1,
-    )
-    component.build_vector_store()
-    records = component.search_documents()
-
-    assert len(records) == 1
+
+    results = await run_single_component(AstraVectorStoreComponent, inputs={
+        "token": application_token,
+        "api_endpoint": api_endpoint,
+        "collection_name": BASIC_COLLECTION,
+        "number_of_results": 1,
+        "search_input":"test1",
+        "ingest_data": ComponentInputHandle(clazz=TextToData, inputs={"text_data": ["test1", "test2"]}, output_name="data"),
+        "embedding": ComponentInputHandle(clazz=OpenAIEmbeddingsComponent,
+                                          inputs={"openai_api_key": get_openai_api_key()}, output_name="embeddings"),
+    })
+    assert len(results["search_results"]) == 1
 
 
 

src/backend/tests/integration/utils.py

@@ -127,25 +127,38 @@ async def run_flow(graph: Graph, run_input: Optional[Any] = None,
     return outputs
 
 
-async def run_single_component(clazz: type, inputs: dict = None, run_input: Optional[Any] = None,
-                               session_id: Optional[str] = None) -> dict[str, Any]:
 
-    raw_inputs = {}
-    for key, value in inputs.items():
-        if not isinstance(value, BaseComponent):
-            raw_inputs[key] = value
-    component = clazz(
-        **raw_inputs
-    )
+@dataclasses.dataclass
+class ComponentInputHandle:
+    clazz: type
+    inputs: dict
+    output_name: str
 
+async def run_single_component(clazz: type, inputs: dict = None, run_input: Optional[Any] = None,
+                               session_id: Optional[str] = None) -> dict[str, Any]:
+    user_id = str(uuid.uuid4())
     flow_id = str(uuid.uuid4())
-    graph = Graph(user_id=str(uuid.uuid4()), flow_id=flow_id)
-    component_id = graph.add_component(component)
-    for input_name, input_value in inputs.items():
-        if isinstance(input_value, Component):
-            graph.add_component(input_value)
-            graph.add_component_edge(input_value._id, (input_value.outputs[0].name, input_name), component._id)
-            print("added edge")
+    graph = Graph(user_id=user_id, flow_id=flow_id)
+
+    def _add_component(clazz: type, inputs: dict = None) -> str:
+        raw_inputs = {}
+        for key, value in inputs.items():
+            if not isinstance(value, ComponentInputHandle):
+                raw_inputs[key] = value
+            if isinstance(value, Component):
+                raise ValueError("Component inputs must be wrapped in ComponentInputHandle")
+        component = clazz(
+            **raw_inputs,
+            _user_id=user_id
+        )
+        component_id = graph.add_component(component)
+        for input_name, handle in inputs.items():
+            if isinstance(handle, ComponentInputHandle):
+                handle_component_id = _add_component(handle.clazz, handle.inputs)
+                graph.add_component_edge(handle_component_id, (handle.output_name, input_name), component_id)
+        return component_id
+
+    component_id = _add_component(clazz, inputs)
     graph.prepare()
     if run_input:
         graph_run_inputs = [InputValueRequest(input_value=run_input, type="chat")]