mirror of
https://github.com/deepset-ai/haystack.git
synced 2025-07-04 07:26:15 +00:00
5514676b5e
* Deprecate max_loops_allowed in favour of new argument max_runs_per_component * Add missing test file * Some enhancements * Add version that will remove deprecate stuff
1631 lines
70 KiB
Python
1631 lines
70 KiB
Python
# SPDX-FileCopyrightText: 2022-present deepset GmbH <info@deepset.ai>
|
|
#
|
|
# SPDX-License-Identifier: Apache-2.0
|
|
import logging
|
|
from typing import List, Optional
|
|
from unittest.mock import patch
|
|
|
|
import pytest
|
|
|
|
from haystack import Document
|
|
from haystack.components.builders import PromptBuilder, AnswerBuilder
|
|
from haystack.components.joiners import BranchJoiner
|
|
from haystack.core.component import component
|
|
from haystack.core.component.types import InputSocket, OutputSocket, Variadic
|
|
from haystack.core.errors import DeserializationError, PipelineConnectError, PipelineDrawingError, PipelineError
|
|
from haystack.core.pipeline import Pipeline, PredefinedPipeline
|
|
from haystack.core.pipeline.base import (
|
|
_add_missing_input_defaults,
|
|
_enqueue_component,
|
|
_dequeue_component,
|
|
_enqueue_waiting_component,
|
|
_dequeue_waiting_component,
|
|
)
|
|
from haystack.core.serialization import DeserializationCallbacks
|
|
from haystack.testing.factory import component_class
|
|
from haystack.testing.sample_components import AddFixedValue, Double, Greet
|
|
|
|
logging.basicConfig(level=logging.DEBUG)
|
|
|
|
|
|
@component
|
|
class FakeComponent:
|
|
def __init__(self, an_init_param: Optional[str] = None):
|
|
pass
|
|
|
|
@component.output_types(value=str)
|
|
def run(self, input_: str):
|
|
return {"value": input_}
|
|
|
|
|
|
@component
|
|
class FakeComponentSquared:
|
|
def __init__(self, an_init_param: Optional[str] = None):
|
|
self.an_init_param = an_init_param
|
|
self.inner = FakeComponent()
|
|
|
|
@component.output_types(value=str)
|
|
def run(self, input_: str):
|
|
return {"value": input_}
|
|
|
|
|
|
class TestPipeline:
|
|
"""
|
|
This class contains only unit tests for the Pipeline class.
|
|
It doesn't test Pipeline.run(), that is done separately in a different way.
|
|
"""
|
|
|
|
def test_pipeline_dumps_with_deprecated_max_loops_allowed(self, test_files_path):
|
|
pipeline = Pipeline(max_loops_allowed=99)
|
|
pipeline.add_component("Comp1", FakeComponent("Foo"))
|
|
pipeline.add_component("Comp2", FakeComponent())
|
|
pipeline.connect("Comp1.value", "Comp2.input_")
|
|
result = pipeline.dumps()
|
|
with open(f"{test_files_path}/yaml/test_pipeline.yaml", "r") as f:
|
|
assert f.read() == result
|
|
|
|
def test_pipeline_dumps(self, test_files_path):
|
|
pipeline = Pipeline(max_runs_per_component=99)
|
|
pipeline.add_component("Comp1", FakeComponent("Foo"))
|
|
pipeline.add_component("Comp2", FakeComponent())
|
|
pipeline.connect("Comp1.value", "Comp2.input_")
|
|
result = pipeline.dumps()
|
|
with open(f"{test_files_path}/yaml/test_pipeline.yaml", "r") as f:
|
|
assert f.read() == result
|
|
|
|
def test_pipeline_loads_with_deprecated_max_loops_allowed(self, test_files_path):
|
|
with open(f"{test_files_path}/yaml/test_pipeline_deprecated.yaml", "r") as f:
|
|
pipeline = Pipeline.loads(f.read())
|
|
assert pipeline.max_loops_allowed == 99
|
|
assert pipeline._max_runs_per_component == 99
|
|
assert isinstance(pipeline.get_component("Comp1"), FakeComponent)
|
|
assert isinstance(pipeline.get_component("Comp2"), FakeComponent)
|
|
|
|
def test_pipeline_loads_invalid_data(self):
|
|
invalid_yaml = """components:
|
|
Comp1:
|
|
init_parameters:
|
|
an_init_param: null
|
|
type: test.core.pipeline.test_pipeline.FakeComponent
|
|
Comp2*
|
|
init_parameters:
|
|
an_init_param: null
|
|
type: test.core.pipeline.test_pipeline.FakeComponent
|
|
connections:
|
|
* receiver: Comp2.input_
|
|
sender: Comp1.value
|
|
max_loops_allowed: 99
|
|
metadata:
|
|
"""
|
|
|
|
with pytest.raises(DeserializationError, match="unmarshalling serialized"):
|
|
pipeline = Pipeline.loads(invalid_yaml)
|
|
|
|
invalid_init_parameter_yaml = """components:
|
|
Comp1:
|
|
init_parameters:
|
|
unknown: null
|
|
type: test.core.pipeline.test_pipeline.FakeComponent
|
|
Comp2:
|
|
init_parameters:
|
|
an_init_param: null
|
|
type: test.core.pipeline.test_pipeline.FakeComponent
|
|
connections:
|
|
- receiver: Comp2.input_
|
|
sender: Comp1.value
|
|
max_loops_allowed: 99
|
|
metadata: {}
|
|
"""
|
|
|
|
with pytest.raises(DeserializationError, match=".*Comp1.*unknown.*"):
|
|
pipeline = Pipeline.loads(invalid_init_parameter_yaml)
|
|
|
|
def test_pipeline_dump_with_deprecated_max_loops_allowed(self, test_files_path, tmp_path):
|
|
pipeline = Pipeline(max_loops_allowed=99)
|
|
pipeline.add_component("Comp1", FakeComponent("Foo"))
|
|
pipeline.add_component("Comp2", FakeComponent())
|
|
pipeline.connect("Comp1.value", "Comp2.input_")
|
|
with open(tmp_path / "out.yaml", "w") as f:
|
|
pipeline.dump(f)
|
|
# re-open and ensure it's the same data as the test file
|
|
with open(f"{test_files_path}/yaml/test_pipeline.yaml", "r") as test_f, open(tmp_path / "out.yaml", "r") as f:
|
|
assert f.read() == test_f.read()
|
|
|
|
def test_pipeline_dump(self, test_files_path, tmp_path):
|
|
pipeline = Pipeline(max_runs_per_component=99)
|
|
pipeline.add_component("Comp1", FakeComponent("Foo"))
|
|
pipeline.add_component("Comp2", FakeComponent())
|
|
pipeline.connect("Comp1.value", "Comp2.input_")
|
|
with open(tmp_path / "out.yaml", "w") as f:
|
|
pipeline.dump(f)
|
|
# re-open and ensure it's the same data as the test file
|
|
with open(f"{test_files_path}/yaml/test_pipeline.yaml", "r") as test_f, open(tmp_path / "out.yaml", "r") as f:
|
|
assert f.read() == test_f.read()
|
|
|
|
def test_pipeline_load_with_deprecated_max_loops_allowed(self, test_files_path):
|
|
with open(f"{test_files_path}/yaml/test_pipeline_deprecated.yaml", "r") as f:
|
|
pipeline = Pipeline.load(f)
|
|
assert pipeline.max_loops_allowed == 99
|
|
assert pipeline._max_runs_per_component == 99
|
|
assert isinstance(pipeline.get_component("Comp1"), FakeComponent)
|
|
assert isinstance(pipeline.get_component("Comp2"), FakeComponent)
|
|
|
|
def test_pipeline_load(self, test_files_path):
|
|
with open(f"{test_files_path}/yaml/test_pipeline.yaml", "r") as f:
|
|
pipeline = Pipeline.load(f)
|
|
assert pipeline.max_loops_allowed == 99
|
|
assert pipeline._max_runs_per_component == 99
|
|
assert isinstance(pipeline.get_component("Comp1"), FakeComponent)
|
|
assert isinstance(pipeline.get_component("Comp2"), FakeComponent)
|
|
|
|
@patch("haystack.core.pipeline.base._to_mermaid_image")
|
|
@patch("haystack.core.pipeline.base.is_in_jupyter")
|
|
@patch("IPython.display.Image")
|
|
@patch("IPython.display.display")
|
|
def test_show_in_notebook(
|
|
self, mock_ipython_display, mock_ipython_image, mock_is_in_jupyter, mock_to_mermaid_image
|
|
):
|
|
pipe = Pipeline()
|
|
|
|
mock_to_mermaid_image.return_value = b"some_image_data"
|
|
mock_is_in_jupyter.return_value = True
|
|
|
|
pipe.show()
|
|
mock_ipython_image.assert_called_once_with(b"some_image_data")
|
|
mock_ipython_display.assert_called_once()
|
|
|
|
@patch("haystack.core.pipeline.base.is_in_jupyter")
|
|
def test_show_not_in_notebook(self, mock_is_in_jupyter):
|
|
pipe = Pipeline()
|
|
|
|
mock_is_in_jupyter.return_value = False
|
|
|
|
with pytest.raises(PipelineDrawingError):
|
|
pipe.show()
|
|
|
|
@patch("haystack.core.pipeline.base._to_mermaid_image")
|
|
def test_draw(self, mock_to_mermaid_image, tmp_path):
|
|
pipe = Pipeline()
|
|
mock_to_mermaid_image.return_value = b"some_image_data"
|
|
|
|
image_path = tmp_path / "test.png"
|
|
pipe.draw(path=image_path)
|
|
assert image_path.read_bytes() == mock_to_mermaid_image.return_value
|
|
|
|
# UNIT
|
|
def test_add_component_to_different_pipelines(self):
|
|
first_pipe = Pipeline()
|
|
second_pipe = Pipeline()
|
|
some_component = component_class("Some")()
|
|
|
|
assert some_component.__haystack_added_to_pipeline__ is None
|
|
first_pipe.add_component("some", some_component)
|
|
assert some_component.__haystack_added_to_pipeline__ is first_pipe
|
|
|
|
with pytest.raises(PipelineError):
|
|
second_pipe.add_component("some", some_component)
|
|
|
|
def test_remove_component_raises_if_invalid_component_name(self):
|
|
pipe = Pipeline()
|
|
component = component_class("Some")()
|
|
|
|
pipe.add_component("1", component)
|
|
|
|
with pytest.raises(ValueError):
|
|
pipe.remove_component("2")
|
|
|
|
def test_remove_component_removes_component_and_its_edges(self):
|
|
pipe = Pipeline()
|
|
component_1 = component_class("Type1")()
|
|
component_2 = component_class("Type2")()
|
|
component_3 = component_class("Type3")()
|
|
component_4 = component_class("Type4")()
|
|
|
|
pipe.add_component("1", component_1)
|
|
pipe.add_component("2", component_2)
|
|
pipe.add_component("3", component_3)
|
|
pipe.add_component("4", component_4)
|
|
|
|
pipe.connect("1", "2")
|
|
pipe.connect("2", "3")
|
|
pipe.connect("3", "4")
|
|
|
|
pipe.remove_component("2")
|
|
|
|
assert ["1", "3", "4"] == sorted(pipe.graph.nodes)
|
|
assert [("3", "4")] == sorted([(u, v) for (u, v) in pipe.graph.edges()])
|
|
|
|
def test_remove_component_allows_you_to_reuse_the_component(self):
|
|
pipe = Pipeline()
|
|
Some = component_class("Some", input_types={"in": int}, output_types={"out": int})
|
|
|
|
pipe.add_component("component_1", Some())
|
|
pipe.add_component("component_2", Some())
|
|
pipe.add_component("component_3", Some())
|
|
pipe.connect("component_1", "component_2")
|
|
pipe.connect("component_2", "component_3")
|
|
component_2 = pipe.remove_component("component_2")
|
|
|
|
assert component_2.__haystack_added_to_pipeline__ is None
|
|
assert component_2.__haystack_input__._sockets_dict == {"in": InputSocket(name="in", type=int, senders=[])}
|
|
assert component_2.__haystack_output__._sockets_dict == {
|
|
"out": OutputSocket(name="out", type=int, receivers=[])
|
|
}
|
|
|
|
pipe2 = Pipeline()
|
|
pipe2.add_component("component_4", Some())
|
|
pipe2.add_component("component_2", component_2)
|
|
pipe2.add_component("component_5", Some())
|
|
|
|
pipe2.connect("component_4", "component_2")
|
|
pipe2.connect("component_2", "component_5")
|
|
assert component_2.__haystack_added_to_pipeline__ is pipe2
|
|
assert component_2.__haystack_input__._sockets_dict == {
|
|
"in": InputSocket(name="in", type=int, senders=["component_4"])
|
|
}
|
|
assert component_2.__haystack_output__._sockets_dict == {
|
|
"out": OutputSocket(name="out", type=int, receivers=["component_5"])
|
|
}
|
|
|
|
# instance = pipe2.get_component("some")
|
|
# assert instance == component
|
|
|
|
# UNIT
|
|
def test_get_component_name(self):
|
|
pipe = Pipeline()
|
|
some_component = component_class("Some")()
|
|
pipe.add_component("some", some_component)
|
|
|
|
assert pipe.get_component_name(some_component) == "some"
|
|
|
|
# UNIT
|
|
def test_get_component_name_not_added_to_pipeline(self):
|
|
pipe = Pipeline()
|
|
some_component = component_class("Some")()
|
|
|
|
assert pipe.get_component_name(some_component) == ""
|
|
|
|
# UNIT
|
|
def test_repr(self):
|
|
pipe = Pipeline(metadata={"test": "test"}, max_loops_allowed=42)
|
|
pipe.add_component("add_two", AddFixedValue(add=2))
|
|
pipe.add_component("add_default", AddFixedValue())
|
|
pipe.add_component("double", Double())
|
|
pipe.connect("add_two", "double")
|
|
pipe.connect("double", "add_default")
|
|
|
|
expected_repr = (
|
|
f"{object.__repr__(pipe)}\n"
|
|
"🧱 Metadata\n"
|
|
" - test: test\n"
|
|
"🚅 Components\n"
|
|
" - add_two: AddFixedValue\n"
|
|
" - add_default: AddFixedValue\n"
|
|
" - double: Double\n"
|
|
"🛤️ Connections\n"
|
|
" - add_two.result -> double.value (int)\n"
|
|
" - double.value -> add_default.value (int)\n"
|
|
)
|
|
|
|
assert repr(pipe) == expected_repr
|
|
|
|
# UNIT
|
|
def test_to_dict(self):
|
|
add_two = AddFixedValue(add=2)
|
|
add_default = AddFixedValue()
|
|
double = Double()
|
|
pipe = Pipeline(metadata={"test": "test"}, max_loops_allowed=42)
|
|
pipe.add_component("add_two", add_two)
|
|
pipe.add_component("add_default", add_default)
|
|
pipe.add_component("double", double)
|
|
pipe.connect("add_two", "double")
|
|
pipe.connect("double", "add_default")
|
|
|
|
res = pipe.to_dict()
|
|
expected = {
|
|
"metadata": {"test": "test"},
|
|
"max_runs_per_component": 42,
|
|
"components": {
|
|
"add_two": {
|
|
"type": "haystack.testing.sample_components.add_value.AddFixedValue",
|
|
"init_parameters": {"add": 2},
|
|
},
|
|
"add_default": {
|
|
"type": "haystack.testing.sample_components.add_value.AddFixedValue",
|
|
"init_parameters": {"add": 1},
|
|
},
|
|
"double": {"type": "haystack.testing.sample_components.double.Double", "init_parameters": {}},
|
|
},
|
|
"connections": [
|
|
{"sender": "add_two.result", "receiver": "double.value"},
|
|
{"sender": "double.value", "receiver": "add_default.value"},
|
|
],
|
|
}
|
|
assert res == expected
|
|
|
|
# UNIT
|
|
def test_from_dict_with_deprecated_max_loops_allowed(self):
|
|
data = {
|
|
"metadata": {"test": "test"},
|
|
"max_loops_allowed": 101,
|
|
"components": {
|
|
"add_two": {
|
|
"type": "haystack.testing.sample_components.add_value.AddFixedValue",
|
|
"init_parameters": {"add": 2},
|
|
},
|
|
"add_default": {
|
|
"type": "haystack.testing.sample_components.add_value.AddFixedValue",
|
|
"init_parameters": {"add": 1},
|
|
},
|
|
"double": {"type": "haystack.testing.sample_components.double.Double", "init_parameters": {}},
|
|
},
|
|
"connections": [
|
|
{"sender": "add_two.result", "receiver": "double.value"},
|
|
{"sender": "double.value", "receiver": "add_default.value"},
|
|
],
|
|
}
|
|
pipe = Pipeline.from_dict(data)
|
|
|
|
assert pipe.metadata == {"test": "test"}
|
|
assert pipe.max_loops_allowed == 101
|
|
assert pipe._max_runs_per_component == 101
|
|
|
|
# Components
|
|
assert len(pipe.graph.nodes) == 3
|
|
## add_two
|
|
add_two = pipe.graph.nodes["add_two"]
|
|
assert add_two["instance"].add == 2
|
|
assert add_two["input_sockets"] == {
|
|
"value": InputSocket(name="value", type=int),
|
|
"add": InputSocket(name="add", type=Optional[int], default_value=None),
|
|
}
|
|
assert add_two["output_sockets"] == {"result": OutputSocket(name="result", type=int, receivers=["double"])}
|
|
assert add_two["visits"] == 0
|
|
|
|
## add_default
|
|
add_default = pipe.graph.nodes["add_default"]
|
|
assert add_default["instance"].add == 1
|
|
assert add_default["input_sockets"] == {
|
|
"value": InputSocket(name="value", type=int, senders=["double"]),
|
|
"add": InputSocket(name="add", type=Optional[int], default_value=None),
|
|
}
|
|
assert add_default["output_sockets"] == {"result": OutputSocket(name="result", type=int)}
|
|
assert add_default["visits"] == 0
|
|
|
|
## double
|
|
double = pipe.graph.nodes["double"]
|
|
assert double["instance"]
|
|
assert double["input_sockets"] == {"value": InputSocket(name="value", type=int, senders=["add_two"])}
|
|
assert double["output_sockets"] == {"value": OutputSocket(name="value", type=int, receivers=["add_default"])}
|
|
assert double["visits"] == 0
|
|
|
|
# Connections
|
|
connections = list(pipe.graph.edges(data=True))
|
|
assert len(connections) == 2
|
|
assert connections[0] == (
|
|
"add_two",
|
|
"double",
|
|
{
|
|
"conn_type": "int",
|
|
"from_socket": OutputSocket(name="result", type=int, receivers=["double"]),
|
|
"to_socket": InputSocket(name="value", type=int, senders=["add_two"]),
|
|
"mandatory": True,
|
|
},
|
|
)
|
|
assert connections[1] == (
|
|
"double",
|
|
"add_default",
|
|
{
|
|
"conn_type": "int",
|
|
"from_socket": OutputSocket(name="value", type=int, receivers=["add_default"]),
|
|
"to_socket": InputSocket(name="value", type=int, senders=["double"]),
|
|
"mandatory": True,
|
|
},
|
|
)
|
|
|
|
def test_from_dict(self):
|
|
data = {
|
|
"metadata": {"test": "test"},
|
|
"max_runs_per_component": 101,
|
|
"components": {
|
|
"add_two": {
|
|
"type": "haystack.testing.sample_components.add_value.AddFixedValue",
|
|
"init_parameters": {"add": 2},
|
|
},
|
|
"add_default": {
|
|
"type": "haystack.testing.sample_components.add_value.AddFixedValue",
|
|
"init_parameters": {"add": 1},
|
|
},
|
|
"double": {"type": "haystack.testing.sample_components.double.Double", "init_parameters": {}},
|
|
},
|
|
"connections": [
|
|
{"sender": "add_two.result", "receiver": "double.value"},
|
|
{"sender": "double.value", "receiver": "add_default.value"},
|
|
],
|
|
}
|
|
pipe = Pipeline.from_dict(data)
|
|
|
|
assert pipe.metadata == {"test": "test"}
|
|
assert pipe.max_loops_allowed == 101
|
|
assert pipe._max_runs_per_component == 101
|
|
|
|
# Components
|
|
assert len(pipe.graph.nodes) == 3
|
|
## add_two
|
|
add_two = pipe.graph.nodes["add_two"]
|
|
assert add_two["instance"].add == 2
|
|
assert add_two["input_sockets"] == {
|
|
"value": InputSocket(name="value", type=int),
|
|
"add": InputSocket(name="add", type=Optional[int], default_value=None),
|
|
}
|
|
assert add_two["output_sockets"] == {"result": OutputSocket(name="result", type=int, receivers=["double"])}
|
|
assert add_two["visits"] == 0
|
|
|
|
## add_default
|
|
add_default = pipe.graph.nodes["add_default"]
|
|
assert add_default["instance"].add == 1
|
|
assert add_default["input_sockets"] == {
|
|
"value": InputSocket(name="value", type=int, senders=["double"]),
|
|
"add": InputSocket(name="add", type=Optional[int], default_value=None),
|
|
}
|
|
assert add_default["output_sockets"] == {"result": OutputSocket(name="result", type=int)}
|
|
assert add_default["visits"] == 0
|
|
|
|
## double
|
|
double = pipe.graph.nodes["double"]
|
|
assert double["instance"]
|
|
assert double["input_sockets"] == {"value": InputSocket(name="value", type=int, senders=["add_two"])}
|
|
assert double["output_sockets"] == {"value": OutputSocket(name="value", type=int, receivers=["add_default"])}
|
|
assert double["visits"] == 0
|
|
|
|
# Connections
|
|
connections = list(pipe.graph.edges(data=True))
|
|
assert len(connections) == 2
|
|
assert connections[0] == (
|
|
"add_two",
|
|
"double",
|
|
{
|
|
"conn_type": "int",
|
|
"from_socket": OutputSocket(name="result", type=int, receivers=["double"]),
|
|
"to_socket": InputSocket(name="value", type=int, senders=["add_two"]),
|
|
"mandatory": True,
|
|
},
|
|
)
|
|
assert connections[1] == (
|
|
"double",
|
|
"add_default",
|
|
{
|
|
"conn_type": "int",
|
|
"from_socket": OutputSocket(name="value", type=int, receivers=["add_default"]),
|
|
"to_socket": InputSocket(name="value", type=int, senders=["double"]),
|
|
"mandatory": True,
|
|
},
|
|
)
|
|
|
|
# TODO: Remove this, this should be a component test.
|
|
# The pipeline can't handle this in any case nor way.
|
|
def test_from_dict_with_callbacks(self):
|
|
data = {
|
|
"metadata": {"test": "test"},
|
|
"max_loops_allowed": 101,
|
|
"components": {
|
|
"add_two": {
|
|
"type": "haystack.testing.sample_components.add_value.AddFixedValue",
|
|
"init_parameters": {"add": 2},
|
|
},
|
|
"add_default": {
|
|
"type": "haystack.testing.sample_components.add_value.AddFixedValue",
|
|
"init_parameters": {"add": 1},
|
|
},
|
|
"double": {"type": "haystack.testing.sample_components.double.Double", "init_parameters": {}},
|
|
"greet": {
|
|
"type": "haystack.testing.sample_components.greet.Greet",
|
|
"init_parameters": {"message": "test"},
|
|
},
|
|
},
|
|
"connections": [
|
|
{"sender": "add_two.result", "receiver": "double.value"},
|
|
{"sender": "double.value", "receiver": "add_default.value"},
|
|
],
|
|
}
|
|
|
|
components_seen_in_callback = []
|
|
|
|
def component_pre_init_callback(name, component_cls, init_params):
|
|
assert name in ["add_two", "add_default", "double", "greet"]
|
|
assert component_cls in [AddFixedValue, Double, Greet]
|
|
|
|
if name == "add_two":
|
|
assert init_params == {"add": 2}
|
|
elif name == "add_default":
|
|
assert init_params == {"add": 1}
|
|
elif name == "greet":
|
|
assert init_params == {"message": "test"}
|
|
|
|
components_seen_in_callback.append(name)
|
|
|
|
pipe = Pipeline.from_dict(
|
|
data, callbacks=DeserializationCallbacks(component_pre_init=component_pre_init_callback)
|
|
)
|
|
assert components_seen_in_callback == ["add_two", "add_default", "double", "greet"]
|
|
add_two = pipe.graph.nodes["add_two"]["instance"]
|
|
assert add_two.add == 2
|
|
add_default = pipe.graph.nodes["add_default"]["instance"]
|
|
assert add_default.add == 1
|
|
greet = pipe.graph.nodes["greet"]["instance"]
|
|
assert greet.message == "test"
|
|
assert greet.log_level == "INFO"
|
|
|
|
def component_pre_init_callback_modify(name, component_cls, init_params):
|
|
assert name in ["add_two", "add_default", "double", "greet"]
|
|
assert component_cls in [AddFixedValue, Double, Greet]
|
|
|
|
if name == "add_two":
|
|
init_params["add"] = 3
|
|
elif name == "add_default":
|
|
init_params["add"] = 0
|
|
elif name == "greet":
|
|
init_params["message"] = "modified test"
|
|
init_params["log_level"] = "DEBUG"
|
|
|
|
pipe = Pipeline.from_dict(
|
|
data, callbacks=DeserializationCallbacks(component_pre_init=component_pre_init_callback_modify)
|
|
)
|
|
add_two = pipe.graph.nodes["add_two"]["instance"]
|
|
assert add_two.add == 3
|
|
add_default = pipe.graph.nodes["add_default"]["instance"]
|
|
assert add_default.add == 0
|
|
greet = pipe.graph.nodes["greet"]["instance"]
|
|
assert greet.message == "modified test"
|
|
assert greet.log_level == "DEBUG"
|
|
|
|
# Test with a component that internally instantiates another component
|
|
def component_pre_init_callback_check_class(name, component_cls, init_params):
|
|
assert name == "fake_component_squared"
|
|
assert component_cls == FakeComponentSquared
|
|
|
|
pipe = Pipeline()
|
|
pipe.add_component("fake_component_squared", FakeComponentSquared())
|
|
pipe = Pipeline.from_dict(
|
|
pipe.to_dict(),
|
|
callbacks=DeserializationCallbacks(component_pre_init=component_pre_init_callback_check_class),
|
|
)
|
|
assert type(pipe.graph.nodes["fake_component_squared"]["instance"].inner) == FakeComponent
|
|
|
|
# UNIT
|
|
def test_from_dict_with_empty_dict(self):
|
|
assert Pipeline() == Pipeline.from_dict({})
|
|
|
|
# TODO: UNIT, consider deprecating this argument
|
|
def test_from_dict_with_components_instances(self):
|
|
add_two = AddFixedValue(add=2)
|
|
add_default = AddFixedValue()
|
|
components = {"add_two": add_two, "add_default": add_default}
|
|
data = {
|
|
"metadata": {"test": "test"},
|
|
"max_loops_allowed": 100,
|
|
"components": {
|
|
"add_two": {},
|
|
"add_default": {},
|
|
"double": {"type": "haystack.testing.sample_components.double.Double", "init_parameters": {}},
|
|
},
|
|
"connections": [
|
|
{"sender": "add_two.result", "receiver": "double.value"},
|
|
{"sender": "double.value", "receiver": "add_default.value"},
|
|
],
|
|
}
|
|
pipe = Pipeline.from_dict(data, components=components)
|
|
assert pipe.metadata == {"test": "test"}
|
|
assert pipe.max_loops_allowed == 100
|
|
|
|
# Components
|
|
assert len(pipe.graph.nodes) == 3
|
|
## add_two
|
|
add_two_data = pipe.graph.nodes["add_two"]
|
|
assert add_two_data["instance"] is add_two
|
|
assert add_two_data["instance"].add == 2
|
|
assert add_two_data["input_sockets"] == {
|
|
"value": InputSocket(name="value", type=int),
|
|
"add": InputSocket(name="add", type=Optional[int], default_value=None),
|
|
}
|
|
assert add_two_data["output_sockets"] == {"result": OutputSocket(name="result", type=int, receivers=["double"])}
|
|
assert add_two_data["visits"] == 0
|
|
|
|
## add_default
|
|
add_default_data = pipe.graph.nodes["add_default"]
|
|
assert add_default_data["instance"] is add_default
|
|
assert add_default_data["instance"].add == 1
|
|
assert add_default_data["input_sockets"] == {
|
|
"value": InputSocket(name="value", type=int, senders=["double"]),
|
|
"add": InputSocket(name="add", type=Optional[int], default_value=None),
|
|
}
|
|
assert add_default_data["output_sockets"] == {"result": OutputSocket(name="result", type=int, receivers=[])}
|
|
assert add_default_data["visits"] == 0
|
|
|
|
## double
|
|
double = pipe.graph.nodes["double"]
|
|
assert double["instance"]
|
|
assert double["input_sockets"] == {"value": InputSocket(name="value", type=int, senders=["add_two"])}
|
|
assert double["output_sockets"] == {"value": OutputSocket(name="value", type=int, receivers=["add_default"])}
|
|
assert double["visits"] == 0
|
|
|
|
# Connections
|
|
connections = list(pipe.graph.edges(data=True))
|
|
assert len(connections) == 2
|
|
assert connections[0] == (
|
|
"add_two",
|
|
"double",
|
|
{
|
|
"conn_type": "int",
|
|
"from_socket": OutputSocket(name="result", type=int, receivers=["double"]),
|
|
"to_socket": InputSocket(name="value", type=int, senders=["add_two"]),
|
|
"mandatory": True,
|
|
},
|
|
)
|
|
assert connections[1] == (
|
|
"double",
|
|
"add_default",
|
|
{
|
|
"conn_type": "int",
|
|
"from_socket": OutputSocket(name="value", type=int, receivers=["add_default"]),
|
|
"to_socket": InputSocket(name="value", type=int, senders=["double"]),
|
|
"mandatory": True,
|
|
},
|
|
)
|
|
|
|
# UNIT
|
|
def test_from_dict_without_component_type(self):
|
|
data = {
|
|
"metadata": {"test": "test"},
|
|
"max_loops_allowed": 100,
|
|
"components": {"add_two": {"init_parameters": {"add": 2}}},
|
|
"connections": [],
|
|
}
|
|
with pytest.raises(PipelineError) as err:
|
|
Pipeline.from_dict(data)
|
|
|
|
err.match("Missing 'type' in component 'add_two'")
|
|
|
|
# UNIT
|
|
def test_from_dict_without_registered_component_type(self, request):
|
|
data = {
|
|
"metadata": {"test": "test"},
|
|
"max_loops_allowed": 100,
|
|
"components": {"add_two": {"type": "foo.bar.baz", "init_parameters": {"add": 2}}},
|
|
"connections": [],
|
|
}
|
|
with pytest.raises(PipelineError) as err:
|
|
Pipeline.from_dict(data)
|
|
|
|
err.match(r"Component .+ not imported.")
|
|
|
|
# UNIT
|
|
def test_from_dict_without_connection_sender(self):
|
|
data = {
|
|
"metadata": {"test": "test"},
|
|
"max_loops_allowed": 100,
|
|
"components": {},
|
|
"connections": [{"receiver": "some.receiver"}],
|
|
}
|
|
with pytest.raises(PipelineError) as err:
|
|
Pipeline.from_dict(data)
|
|
|
|
err.match("Missing sender in connection: {'receiver': 'some.receiver'}")
|
|
|
|
# UNIT
|
|
def test_from_dict_without_connection_receiver(self):
|
|
data = {
|
|
"metadata": {"test": "test"},
|
|
"max_loops_allowed": 100,
|
|
"components": {},
|
|
"connections": [{"sender": "some.sender"}],
|
|
}
|
|
with pytest.raises(PipelineError) as err:
|
|
Pipeline.from_dict(data)
|
|
|
|
err.match("Missing receiver in connection: {'sender': 'some.sender'}")
|
|
|
|
def test_describe_input_only_no_inputs_components(self):
|
|
A = component_class("A", input_types={}, output={"x": 0})
|
|
B = component_class("B", input_types={}, output={"y": 0})
|
|
C = component_class("C", input_types={"x": int, "y": int}, output={"z": 0})
|
|
p = Pipeline()
|
|
p.add_component("a", A())
|
|
p.add_component("b", B())
|
|
p.add_component("c", C())
|
|
p.connect("a.x", "c.x")
|
|
p.connect("b.y", "c.y")
|
|
assert p.inputs() == {}
|
|
assert p.inputs(include_components_with_connected_inputs=True) == {
|
|
"c": {"x": {"type": int, "is_mandatory": True}, "y": {"type": int, "is_mandatory": True}}
|
|
}
|
|
|
|
def test_describe_input_some_components_with_no_inputs(self):
|
|
A = component_class("A", input_types={}, output={"x": 0})
|
|
B = component_class("B", input_types={"y": int}, output={"y": 0})
|
|
C = component_class("C", input_types={"x": int, "y": int}, output={"z": 0})
|
|
p = Pipeline()
|
|
p.add_component("a", A())
|
|
p.add_component("b", B())
|
|
p.add_component("c", C())
|
|
p.connect("a.x", "c.x")
|
|
p.connect("b.y", "c.y")
|
|
assert p.inputs() == {"b": {"y": {"type": int, "is_mandatory": True}}}
|
|
assert p.inputs(include_components_with_connected_inputs=True) == {
|
|
"b": {"y": {"type": int, "is_mandatory": True}},
|
|
"c": {"x": {"type": int, "is_mandatory": True}, "y": {"type": int, "is_mandatory": True}},
|
|
}
|
|
|
|
def test_describe_input_all_components_have_inputs(self):
|
|
A = component_class("A", input_types={"x": Optional[int]}, output={"x": 0})
|
|
B = component_class("B", input_types={"y": int}, output={"y": 0})
|
|
C = component_class("C", input_types={"x": int, "y": int}, output={"z": 0})
|
|
p = Pipeline()
|
|
p.add_component("a", A())
|
|
p.add_component("b", B())
|
|
p.add_component("c", C())
|
|
p.connect("a.x", "c.x")
|
|
p.connect("b.y", "c.y")
|
|
assert p.inputs() == {
|
|
"a": {"x": {"type": Optional[int], "is_mandatory": True}},
|
|
"b": {"y": {"type": int, "is_mandatory": True}},
|
|
}
|
|
assert p.inputs(include_components_with_connected_inputs=True) == {
|
|
"a": {"x": {"type": Optional[int], "is_mandatory": True}},
|
|
"b": {"y": {"type": int, "is_mandatory": True}},
|
|
"c": {"x": {"type": int, "is_mandatory": True}, "y": {"type": int, "is_mandatory": True}},
|
|
}
|
|
|
|
def test_describe_output_multiple_possible(self):
|
|
"""
|
|
This pipeline has two outputs:
|
|
{"b": {"output_b": {"type": str}}, "a": {"output_a": {"type": str}}}
|
|
"""
|
|
A = component_class("A", input_types={"input_a": str}, output={"output_a": "str", "output_b": "str"})
|
|
B = component_class("B", input_types={"input_b": str}, output={"output_b": "str"})
|
|
|
|
pipe = Pipeline()
|
|
pipe.add_component("a", A())
|
|
pipe.add_component("b", B())
|
|
pipe.connect("a.output_b", "b.input_b")
|
|
|
|
assert pipe.outputs() == {"b": {"output_b": {"type": str}}, "a": {"output_a": {"type": str}}}
|
|
assert pipe.outputs(include_components_with_connected_outputs=True) == {
|
|
"a": {"output_a": {"type": str}, "output_b": {"type": str}},
|
|
"b": {"output_b": {"type": str}},
|
|
}
|
|
|
|
def test_describe_output_single(self):
|
|
"""
|
|
This pipeline has one output:
|
|
{"c": {"z": {"type": int}}}
|
|
"""
|
|
A = component_class("A", input_types={"x": Optional[int]}, output={"x": 0})
|
|
B = component_class("B", input_types={"y": int}, output={"y": 0})
|
|
C = component_class("C", input_types={"x": int, "y": int}, output={"z": 0})
|
|
p = Pipeline()
|
|
p.add_component("a", A())
|
|
p.add_component("b", B())
|
|
p.add_component("c", C())
|
|
p.connect("a.x", "c.x")
|
|
p.connect("b.y", "c.y")
|
|
|
|
assert p.outputs() == {"c": {"z": {"type": int}}}
|
|
assert p.outputs(include_components_with_connected_outputs=True) == {
|
|
"a": {"x": {"type": int}},
|
|
"b": {"y": {"type": int}},
|
|
"c": {"z": {"type": int}},
|
|
}
|
|
|
|
def test_describe_no_outputs(self):
|
|
"""
|
|
This pipeline sets up elaborate connections between three components but in fact it has no outputs:
|
|
Check that p.outputs() == {}
|
|
"""
|
|
A = component_class("A", input_types={"x": Optional[int]}, output={"x": 0})
|
|
B = component_class("B", input_types={"y": int}, output={"y": 0})
|
|
C = component_class("C", input_types={"x": int, "y": int}, output={})
|
|
p = Pipeline()
|
|
p.add_component("a", A())
|
|
p.add_component("b", B())
|
|
p.add_component("c", C())
|
|
p.connect("a.x", "c.x")
|
|
p.connect("b.y", "c.y")
|
|
assert p.outputs() == {}
|
|
assert p.outputs(include_components_with_connected_outputs=True) == {
|
|
"a": {"x": {"type": int}},
|
|
"b": {"y": {"type": int}},
|
|
}
|
|
|
|
def test_from_template(self, monkeypatch):
|
|
monkeypatch.setenv("OPENAI_API_KEY", "fake_key")
|
|
pipe = Pipeline.from_template(PredefinedPipeline.INDEXING)
|
|
assert pipe.get_component("cleaner")
|
|
|
|
def test_walk_pipeline_with_no_cycles(self):
|
|
"""
|
|
This pipeline has two source nodes, source1 and source2, one hello3 node in between, and one sink node, joiner.
|
|
pipeline.walk() should return each component exactly once. The order is not guaranteed.
|
|
"""
|
|
|
|
@component
|
|
class Hello:
|
|
@component.output_types(output=str)
|
|
def run(self, word: str):
|
|
"""
|
|
Takes a string in input and returns "Hello, <string>!" in output.
|
|
"""
|
|
return {"output": f"Hello, {word}!"}
|
|
|
|
@component
|
|
class Joiner:
|
|
@component.output_types(output=str)
|
|
def run(self, word1: str, word2: str):
|
|
"""
|
|
Takes two strings in input and returns "Hello, <string1> and <string2>!" in output.
|
|
"""
|
|
return {"output": f"Hello, {word1} and {word2}!"}
|
|
|
|
pipeline = Pipeline()
|
|
source1 = Hello()
|
|
source2 = Hello()
|
|
hello3 = Hello()
|
|
joiner = Joiner()
|
|
pipeline.add_component("source1", source1)
|
|
pipeline.add_component("source2", source2)
|
|
pipeline.add_component("hello3", hello3)
|
|
pipeline.add_component("joiner", joiner)
|
|
|
|
pipeline.connect("source1", "joiner.word1")
|
|
pipeline.connect("source2", "hello3")
|
|
pipeline.connect("hello3", "joiner.word2")
|
|
|
|
expected_components = [("source1", source1), ("source2", source2), ("joiner", joiner), ("hello3", hello3)]
|
|
assert sorted(expected_components) == sorted(pipeline.walk())
|
|
|
|
def test_walk_pipeline_with_cycles(self):
|
|
"""
|
|
This pipeline consists of one component, which would run three times in a loop.
|
|
pipeline.walk() should return this component exactly once. The order is not guaranteed.
|
|
"""
|
|
|
|
@component
|
|
class Hello:
|
|
def __init__(self):
|
|
self.iteration_counter = 0
|
|
|
|
@component.output_types(intermediate=str, final=str)
|
|
def run(self, word: str, intermediate: Optional[str] = None):
|
|
"""
|
|
Takes a string in input and returns "Hello, <string>!" in output.
|
|
"""
|
|
if self.iteration_counter < 3:
|
|
self.iteration_counter += 1
|
|
return {"intermediate": f"Hello, {intermediate or word}!"}
|
|
return {"final": f"Hello, {intermediate or word}!"}
|
|
|
|
pipeline = Pipeline()
|
|
hello = Hello()
|
|
pipeline.add_component("hello", hello)
|
|
pipeline.connect("hello.intermediate", "hello.intermediate")
|
|
assert [("hello", hello)] == list(pipeline.walk())
|
|
|
|
def test__init_graph(self):
|
|
pipe = Pipeline()
|
|
pipe.add_component("greet", Greet())
|
|
pipe.add_component("adder", AddFixedValue())
|
|
pipe.connect("greet", "adder")
|
|
pipe._init_graph()
|
|
for node in pipe.graph.nodes:
|
|
assert pipe.graph.nodes[node]["visits"] == 0
|
|
|
|
def test__init_run_queue(self):
|
|
ComponentWithVariadic = component_class(
|
|
"ComponentWithVariadic", input_types={"in": Variadic[int]}, output_types={"out": int}
|
|
)
|
|
ComponentWithNoInputs = component_class("ComponentWithNoInputs", input_types={}, output_types={"out": int})
|
|
ComponentWithSingleInput = component_class(
|
|
"ComponentWithSingleInput", input_types={"in": int}, output_types={"out": int}
|
|
)
|
|
ComponentWithMultipleInputs = component_class(
|
|
"ComponentWithMultipleInputs", input_types={"in1": int, "in2": int}, output_types={"out": int}
|
|
)
|
|
|
|
pipe = Pipeline()
|
|
pipe.add_component("with_variadic", ComponentWithVariadic())
|
|
pipe.add_component("with_no_inputs", ComponentWithNoInputs())
|
|
pipe.add_component("with_single_input", ComponentWithSingleInput())
|
|
pipe.add_component("another_with_single_input", ComponentWithSingleInput())
|
|
pipe.add_component("yet_another_with_single_input", ComponentWithSingleInput())
|
|
pipe.add_component("with_multiple_inputs", ComponentWithMultipleInputs())
|
|
|
|
pipe.connect("yet_another_with_single_input.out", "with_variadic.in")
|
|
pipe.connect("with_no_inputs.out", "with_variadic.in")
|
|
pipe.connect("with_single_input.out", "another_with_single_input.in")
|
|
pipe.connect("another_with_single_input.out", "with_multiple_inputs.in1")
|
|
pipe.connect("with_multiple_inputs.out", "with_variadic.in")
|
|
|
|
data = {"yet_another_with_single_input": {"in": 1}}
|
|
run_queue = pipe._init_run_queue(data)
|
|
assert len(run_queue) == 6
|
|
assert run_queue[0][0] == "with_no_inputs"
|
|
assert run_queue[1][0] == "with_single_input"
|
|
assert run_queue[2][0] == "yet_another_with_single_input"
|
|
assert run_queue[3][0] == "another_with_single_input"
|
|
assert run_queue[4][0] == "with_multiple_inputs"
|
|
assert run_queue[5][0] == "with_variadic"
|
|
|
|
def test__init_inputs_state(self):
|
|
pipe = Pipeline()
|
|
template = """
|
|
Answer the following questions:
|
|
{{ questions | join("\n") }}
|
|
"""
|
|
pipe.add_component("prompt_builder", PromptBuilder(template=template))
|
|
pipe.add_component("branch_joiner", BranchJoiner(type_=int))
|
|
questions = ["What is the capital of Italy?", "What is the capital of France?"]
|
|
data = {
|
|
"prompt_builder": {"questions": questions},
|
|
"branch_joiner": {"value": 1},
|
|
"not_a_component": "some input data",
|
|
}
|
|
res = pipe._init_inputs_state(data)
|
|
assert res == {
|
|
"prompt_builder": {"questions": ["What is the capital of Italy?", "What is the capital of France?"]},
|
|
"branch_joiner": {"value": [1]},
|
|
"not_a_component": "some input data",
|
|
}
|
|
assert id(questions) != id(res["prompt_builder"]["questions"])
|
|
|
|
def test__prepare_component_input_data(self):
|
|
MockComponent = component_class("MockComponent", input_types={"x": List[str], "y": str})
|
|
pipe = Pipeline()
|
|
pipe.add_component("first_mock", MockComponent())
|
|
pipe.add_component("second_mock", MockComponent())
|
|
|
|
res = pipe._prepare_component_input_data({"x": ["some data"], "y": "some other data"})
|
|
assert res == {
|
|
"first_mock": {"x": ["some data"], "y": "some other data"},
|
|
"second_mock": {"x": ["some data"], "y": "some other data"},
|
|
}
|
|
assert id(res["first_mock"]["x"]) != id(res["second_mock"]["x"])
|
|
|
|
def test__prepare_component_input_data_with_connected_inputs(self):
|
|
MockComponent = component_class(
|
|
"MockComponent", input_types={"x": List[str], "y": str}, output_types={"z": str}
|
|
)
|
|
pipe = Pipeline()
|
|
pipe.add_component("first_mock", MockComponent())
|
|
pipe.add_component("second_mock", MockComponent())
|
|
pipe.connect("first_mock.z", "second_mock.y")
|
|
|
|
res = pipe._prepare_component_input_data({"x": ["some data"], "y": "some other data"})
|
|
assert res == {"first_mock": {"x": ["some data"], "y": "some other data"}, "second_mock": {"x": ["some data"]}}
|
|
assert id(res["first_mock"]["x"]) != id(res["second_mock"]["x"])
|
|
|
|
def test__prepare_component_input_data_with_non_existing_input(self, caplog):
|
|
pipe = Pipeline()
|
|
res = pipe._prepare_component_input_data({"input_name": 1})
|
|
assert res == {}
|
|
assert (
|
|
"Inputs ['input_name'] were not matched to any component inputs, "
|
|
"please check your run parameters." in caplog.text
|
|
)
|
|
|
|
def test_connect(self):
|
|
comp1 = component_class("Comp1", output_types={"value": int})()
|
|
comp2 = component_class("Comp2", input_types={"value": int})()
|
|
pipe = Pipeline()
|
|
pipe.add_component("comp1", comp1)
|
|
pipe.add_component("comp2", comp2)
|
|
assert pipe.connect("comp1.value", "comp2.value") is pipe
|
|
|
|
assert comp1.__haystack_output__.value.receivers == ["comp2"]
|
|
assert comp2.__haystack_input__.value.senders == ["comp1"]
|
|
assert list(pipe.graph.edges) == [("comp1", "comp2", "value/value")]
|
|
|
|
def test_connect_already_connected(self):
|
|
comp1 = component_class("Comp1", output_types={"value": int})()
|
|
comp2 = component_class("Comp2", input_types={"value": int})()
|
|
pipe = Pipeline()
|
|
pipe.add_component("comp1", comp1)
|
|
pipe.add_component("comp2", comp2)
|
|
pipe.connect("comp1.value", "comp2.value")
|
|
pipe.connect("comp1.value", "comp2.value")
|
|
|
|
assert comp1.__haystack_output__.value.receivers == ["comp2"]
|
|
assert comp2.__haystack_input__.value.senders == ["comp1"]
|
|
assert list(pipe.graph.edges) == [("comp1", "comp2", "value/value")]
|
|
|
|
def test_connect_with_sender_component_name(self):
|
|
comp1 = component_class("Comp1", output_types={"value": int})()
|
|
comp2 = component_class("Comp2", input_types={"value": int})()
|
|
pipe = Pipeline()
|
|
pipe.add_component("comp1", comp1)
|
|
pipe.add_component("comp2", comp2)
|
|
pipe.connect("comp1", "comp2.value")
|
|
|
|
assert comp1.__haystack_output__.value.receivers == ["comp2"]
|
|
assert comp2.__haystack_input__.value.senders == ["comp1"]
|
|
assert list(pipe.graph.edges) == [("comp1", "comp2", "value/value")]
|
|
|
|
def test_connect_with_receiver_component_name(self):
|
|
comp1 = component_class("Comp1", output_types={"value": int})()
|
|
comp2 = component_class("Comp2", input_types={"value": int})()
|
|
pipe = Pipeline()
|
|
pipe.add_component("comp1", comp1)
|
|
pipe.add_component("comp2", comp2)
|
|
pipe.connect("comp1.value", "comp2")
|
|
|
|
assert comp1.__haystack_output__.value.receivers == ["comp2"]
|
|
assert comp2.__haystack_input__.value.senders == ["comp1"]
|
|
assert list(pipe.graph.edges) == [("comp1", "comp2", "value/value")]
|
|
|
|
def test_connect_with_sender_and_receiver_component_name(self):
|
|
comp1 = component_class("Comp1", output_types={"value": int})()
|
|
comp2 = component_class("Comp2", input_types={"value": int})()
|
|
pipe = Pipeline()
|
|
pipe.add_component("comp1", comp1)
|
|
pipe.add_component("comp2", comp2)
|
|
pipe.connect("comp1", "comp2")
|
|
|
|
assert comp1.__haystack_output__.value.receivers == ["comp2"]
|
|
assert comp2.__haystack_input__.value.senders == ["comp1"]
|
|
assert list(pipe.graph.edges) == [("comp1", "comp2", "value/value")]
|
|
|
|
def test_connect_with_sender_not_in_pipeline(self):
|
|
comp2 = component_class("Comp2", input_types={"value": int})()
|
|
pipe = Pipeline()
|
|
pipe.add_component("comp2", comp2)
|
|
with pytest.raises(ValueError):
|
|
pipe.connect("comp1.value", "comp2.value")
|
|
|
|
def test_connect_with_receiver_not_in_pipeline(self):
|
|
comp1 = component_class("Comp1", output_types={"value": int})()
|
|
pipe = Pipeline()
|
|
pipe.add_component("comp1", comp1)
|
|
with pytest.raises(ValueError):
|
|
pipe.connect("comp1.value", "comp2.value")
|
|
|
|
def test_connect_with_sender_socket_name_not_in_pipeline(self):
|
|
comp1 = component_class("Comp1", output_types={"value": int})()
|
|
comp2 = component_class("Comp2", input_types={"value": int})()
|
|
pipe = Pipeline()
|
|
pipe.add_component("comp1", comp1)
|
|
pipe.add_component("comp2", comp2)
|
|
with pytest.raises(PipelineConnectError):
|
|
pipe.connect("comp1.non_existing", "comp2.value")
|
|
|
|
def test_connect_with_receiver_socket_name_not_in_pipeline(self):
|
|
comp1 = component_class("Comp1", output_types={"value": int})()
|
|
comp2 = component_class("Comp2", input_types={"value": int})()
|
|
pipe = Pipeline()
|
|
pipe.add_component("comp1", comp1)
|
|
pipe.add_component("comp2", comp2)
|
|
with pytest.raises(PipelineConnectError):
|
|
pipe.connect("comp1.value", "comp2.non_existing")
|
|
|
|
def test_connect_with_no_matching_types_and_same_names(self):
|
|
comp1 = component_class("Comp1", output_types={"value": int})()
|
|
comp2 = component_class("Comp2", input_types={"value": str})()
|
|
pipe = Pipeline()
|
|
pipe.add_component("comp1", comp1)
|
|
pipe.add_component("comp2", comp2)
|
|
with pytest.raises(PipelineConnectError):
|
|
pipe.connect("comp1", "comp2")
|
|
|
|
def test_connect_with_multiple_sender_connections_with_same_type_and_differing_name(self):
|
|
comp1 = component_class("Comp1", output_types={"val1": int, "val2": int})()
|
|
comp2 = component_class("Comp2", input_types={"value": int})()
|
|
pipe = Pipeline()
|
|
pipe.add_component("comp1", comp1)
|
|
pipe.add_component("comp2", comp2)
|
|
with pytest.raises(PipelineConnectError):
|
|
pipe.connect("comp1", "comp2")
|
|
|
|
def test_connect_with_multiple_receiver_connections_with_same_type_and_differing_name(self):
|
|
comp1 = component_class("Comp1", output_types={"value": int})()
|
|
comp2 = component_class("Comp2", input_types={"val1": int, "val2": int})()
|
|
pipe = Pipeline()
|
|
pipe.add_component("comp1", comp1)
|
|
pipe.add_component("comp2", comp2)
|
|
with pytest.raises(PipelineConnectError):
|
|
pipe.connect("comp1", "comp2")
|
|
|
|
def test_connect_with_multiple_sender_connections_with_same_type_and_same_name(self):
|
|
comp1 = component_class("Comp1", output_types={"value": int, "other": int})()
|
|
comp2 = component_class("Comp2", input_types={"value": int})()
|
|
pipe = Pipeline()
|
|
pipe.add_component("comp1", comp1)
|
|
pipe.add_component("comp2", comp2)
|
|
pipe.connect("comp1", "comp2")
|
|
|
|
assert comp1.__haystack_output__.value.receivers == ["comp2"]
|
|
assert comp2.__haystack_input__.value.senders == ["comp1"]
|
|
assert list(pipe.graph.edges) == [("comp1", "comp2", "value/value")]
|
|
|
|
def test_connect_with_multiple_receiver_connections_with_same_type_and_same_name(self):
|
|
comp1 = component_class("Comp1", output_types={"value": int})()
|
|
comp2 = component_class("Comp2", input_types={"value": int, "other": int})()
|
|
pipe = Pipeline()
|
|
pipe.add_component("comp1", comp1)
|
|
pipe.add_component("comp2", comp2)
|
|
pipe.connect("comp1", "comp2")
|
|
|
|
assert comp1.__haystack_output__.value.receivers == ["comp2"]
|
|
assert comp2.__haystack_input__.value.senders == ["comp1"]
|
|
assert list(pipe.graph.edges) == [("comp1", "comp2", "value/value")]
|
|
|
|
def test_connect_multiple_outputs_to_non_variadic_input(self):
|
|
comp1 = component_class("Comp1", output_types={"value": int})()
|
|
comp2 = component_class("Comp2", output_types={"value": int})()
|
|
comp3 = component_class("Comp3", input_types={"value": int})()
|
|
pipe = Pipeline()
|
|
pipe.add_component("comp1", comp1)
|
|
pipe.add_component("comp2", comp2)
|
|
pipe.add_component("comp3", comp3)
|
|
pipe.connect("comp1.value", "comp3.value")
|
|
with pytest.raises(PipelineConnectError):
|
|
pipe.connect("comp2.value", "comp3.value")
|
|
|
|
def test_connect_multiple_outputs_to_variadic_input(self):
|
|
comp1 = component_class("Comp1", output_types={"value": int})()
|
|
comp2 = component_class("Comp2", output_types={"value": int})()
|
|
comp3 = component_class("Comp3", input_types={"value": Variadic[int]})()
|
|
pipe = Pipeline()
|
|
pipe.add_component("comp1", comp1)
|
|
pipe.add_component("comp2", comp2)
|
|
pipe.add_component("comp3", comp3)
|
|
pipe.connect("comp1.value", "comp3.value")
|
|
pipe.connect("comp2.value", "comp3.value")
|
|
|
|
assert comp1.__haystack_output__.value.receivers == ["comp3"]
|
|
assert comp2.__haystack_output__.value.receivers == ["comp3"]
|
|
assert comp3.__haystack_input__.value.senders == ["comp1", "comp2"]
|
|
assert list(pipe.graph.edges) == [("comp1", "comp3", "value/value"), ("comp2", "comp3", "value/value")]
|
|
|
|
def test__run_component(self, spying_tracer, caplog):
|
|
caplog.set_level(logging.INFO)
|
|
sentence_builder = component_class(
|
|
"SentenceBuilder", input_types={"words": List[str]}, output={"text": "some words"}
|
|
)()
|
|
document_builder = component_class(
|
|
"DocumentBuilder", input_types={"text": str}, output={"doc": Document(content="some words")}
|
|
)()
|
|
document_cleaner = component_class(
|
|
"DocumentCleaner",
|
|
input_types={"doc": Document},
|
|
output={"cleaned_doc": Document(content="some cleaner words")},
|
|
)()
|
|
|
|
pipe = Pipeline()
|
|
pipe.add_component("sentence_builder", sentence_builder)
|
|
pipe.add_component("document_builder", document_builder)
|
|
pipe.add_component("document_cleaner", document_cleaner)
|
|
pipe.connect("sentence_builder.text", "document_builder.text")
|
|
pipe.connect("document_builder.doc", "document_cleaner.doc")
|
|
assert spying_tracer.spans == []
|
|
res = pipe._run_component("document_builder", {"text": "whatever"})
|
|
assert res == {"doc": Document(content="some words")}
|
|
|
|
assert len(spying_tracer.spans) == 1
|
|
span = spying_tracer.spans[0]
|
|
assert span.operation_name == "haystack.component.run"
|
|
assert span.tags == {
|
|
"haystack.component.name": "document_builder",
|
|
"haystack.component.type": "DocumentBuilder",
|
|
"haystack.component.input_types": {"text": "str"},
|
|
"haystack.component.input_spec": {"text": {"type": "str", "senders": ["sentence_builder"]}},
|
|
"haystack.component.output_spec": {"doc": {"type": "Document", "receivers": ["document_cleaner"]}},
|
|
"haystack.component.visits": 1,
|
|
}
|
|
|
|
assert caplog.messages == ["Running component document_builder"]
|
|
|
|
def test__run_component_with_variadic_input(self):
|
|
document_joiner = component_class("DocumentJoiner", input_types={"docs": Variadic[Document]})()
|
|
|
|
pipe = Pipeline()
|
|
pipe.add_component("document_joiner", document_joiner)
|
|
inputs = {"docs": [Document(content="doc1"), Document(content="doc2")]}
|
|
pipe._run_component("document_joiner", inputs)
|
|
assert inputs == {"docs": []}
|
|
|
|
def test__component_has_enough_inputs_to_run(self):
|
|
sentence_builder = component_class("SentenceBuilder", input_types={"words": List[str]})()
|
|
pipe = Pipeline()
|
|
pipe.add_component("sentence_builder", sentence_builder)
|
|
|
|
assert not pipe._component_has_enough_inputs_to_run("sentence_builder", {})
|
|
assert not pipe._component_has_enough_inputs_to_run(
|
|
"sentence_builder", {"sentence_builder": {"wrong_input_name": "blah blah"}}
|
|
)
|
|
assert pipe._component_has_enough_inputs_to_run(
|
|
"sentence_builder", {"sentence_builder": {"words": ["blah blah"]}}
|
|
)
|
|
|
|
def test__find_components_that_will_receive_no_input(self):
|
|
sentence_builder = component_class(
|
|
"SentenceBuilder", input_types={"words": List[str]}, output_types={"text": str}
|
|
)()
|
|
document_builder = component_class(
|
|
"DocumentBuilder", input_types={"text": str}, output_types={"doc": Document}
|
|
)()
|
|
conditional_document_builder = component_class(
|
|
"ConditionalDocumentBuilder", output_types={"doc": Document, "noop": None}
|
|
)()
|
|
|
|
document_joiner = component_class("DocumentJoiner", input_types={"docs": Variadic[Document]})()
|
|
|
|
pipe = Pipeline()
|
|
pipe.add_component("sentence_builder", sentence_builder)
|
|
pipe.add_component("document_builder", document_builder)
|
|
pipe.add_component("document_joiner", document_joiner)
|
|
pipe.add_component("conditional_document_builder", conditional_document_builder)
|
|
pipe.connect("sentence_builder.text", "document_builder.text")
|
|
pipe.connect("document_builder.doc", "document_joiner.docs")
|
|
pipe.connect("conditional_document_builder.doc", "document_joiner.docs")
|
|
|
|
res = pipe._find_components_that_will_receive_no_input("sentence_builder", {}, {})
|
|
assert res == {("document_builder", document_builder), ("document_joiner", document_joiner)}
|
|
|
|
res = pipe._find_components_that_will_receive_no_input("sentence_builder", {"text": "some text"}, {})
|
|
assert res == set()
|
|
|
|
res = pipe._find_components_that_will_receive_no_input("conditional_document_builder", {"noop": None}, {})
|
|
assert res == {("document_joiner", document_joiner)}
|
|
|
|
res = pipe._find_components_that_will_receive_no_input(
|
|
"conditional_document_builder", {"noop": None}, {"document_joiner": {"docs": []}}
|
|
)
|
|
assert res == {("document_joiner", document_joiner)}
|
|
|
|
res = pipe._find_components_that_will_receive_no_input(
|
|
"conditional_document_builder", {"noop": None}, {"document_joiner": {"docs": [Document("some text")]}}
|
|
)
|
|
assert res == set()
|
|
|
|
def test__distribute_output(self):
|
|
document_builder = component_class(
|
|
"DocumentBuilder", input_types={"text": str}, output_types={"doc": Document, "another_doc": Document}
|
|
)()
|
|
document_cleaner = component_class(
|
|
"DocumentCleaner", input_types={"doc": Document}, output_types={"cleaned_doc": Document}
|
|
)()
|
|
document_joiner = component_class("DocumentJoiner", input_types={"docs": Variadic[Document]})()
|
|
|
|
pipe = Pipeline()
|
|
pipe.add_component("document_builder", document_builder)
|
|
pipe.add_component("document_cleaner", document_cleaner)
|
|
pipe.add_component("document_joiner", document_joiner)
|
|
pipe.connect("document_builder.doc", "document_cleaner.doc")
|
|
pipe.connect("document_builder.another_doc", "document_joiner.docs")
|
|
|
|
inputs = {"document_builder": {"text": "some text"}}
|
|
run_queue = []
|
|
waiting_queue = [("document_joiner", document_joiner)]
|
|
res = pipe._distribute_output(
|
|
"document_builder",
|
|
{"doc": Document("some text"), "another_doc": Document()},
|
|
inputs,
|
|
run_queue,
|
|
waiting_queue,
|
|
)
|
|
|
|
assert res == {}
|
|
assert inputs == {
|
|
"document_builder": {"text": "some text"},
|
|
"document_cleaner": {"doc": Document("some text")},
|
|
"document_joiner": {"docs": [Document()]},
|
|
}
|
|
assert run_queue == [("document_cleaner", document_cleaner)]
|
|
assert waiting_queue == [("document_joiner", document_joiner)]
|
|
|
|
def test__find_next_runnable_component(self):
|
|
document_builder = component_class(
|
|
"DocumentBuilder", input_types={"text": str}, output_types={"doc": Document}
|
|
)()
|
|
pipe = Pipeline()
|
|
components_inputs = {"document_builder": {"text": "some text"}}
|
|
waiting_queue = [("document_builder", document_builder)]
|
|
pair = pipe._find_next_runnable_component(components_inputs, waiting_queue)
|
|
assert pair == ("document_builder", document_builder)
|
|
|
|
def test__find_next_runnable_component_without_component_inputs(self):
|
|
document_builder = component_class(
|
|
"DocumentBuilder", input_types={"text": str}, output_types={"doc": Document}
|
|
)()
|
|
pipe = Pipeline()
|
|
components_inputs = {}
|
|
waiting_queue = [("document_builder", document_builder)]
|
|
pair = pipe._find_next_runnable_component(components_inputs, waiting_queue)
|
|
assert pair == ("document_builder", document_builder)
|
|
|
|
def test__find_next_runnable_component_with_component_with_only_variadic_non_greedy_input(self):
|
|
document_joiner = component_class("DocumentJoiner", input_types={"docs": Variadic[Document]})()
|
|
|
|
pipe = Pipeline()
|
|
components_inputs = {}
|
|
waiting_queue = [("document_joiner", document_joiner)]
|
|
pair = pipe._find_next_runnable_component(components_inputs, waiting_queue)
|
|
assert pair == ("document_joiner", document_joiner)
|
|
|
|
def test__find_next_runnable_component_with_component_with_only_default_input(self):
|
|
prompt_builder = PromptBuilder(template="{{ questions | join('\n') }}")
|
|
|
|
pipe = Pipeline()
|
|
components_inputs = {}
|
|
waiting_queue = [("prompt_builder", prompt_builder)]
|
|
pair = pipe._find_next_runnable_component(components_inputs, waiting_queue)
|
|
|
|
assert pair == ("prompt_builder", prompt_builder)
|
|
|
|
def test__find_next_runnable_component_with_component_with_variadic_non_greedy_and_default_input(self):
|
|
document_joiner = component_class("DocumentJoiner", input_types={"docs": Variadic[Document]})()
|
|
prompt_builder = PromptBuilder(template="{{ questions | join('\n') }}")
|
|
|
|
pipe = Pipeline()
|
|
components_inputs = {}
|
|
waiting_queue = [("prompt_builder", prompt_builder), ("document_joiner", document_joiner)]
|
|
pair = pipe._find_next_runnable_component(components_inputs, waiting_queue)
|
|
|
|
assert pair == ("document_joiner", document_joiner)
|
|
|
|
def test__find_next_runnable_component_with_different_components_inputs(self):
|
|
document_builder = component_class(
|
|
"DocumentBuilder", input_types={"text": str}, output_types={"doc": Document}
|
|
)()
|
|
document_joiner = component_class("DocumentJoiner", input_types={"docs": Variadic[Document]})()
|
|
prompt_builder = PromptBuilder(template="{{ questions | join('\n') }}")
|
|
|
|
pipe = Pipeline()
|
|
components_inputs = {"document_builder": {"text": "some text"}}
|
|
waiting_queue = [
|
|
("prompt_builder", prompt_builder),
|
|
("document_builder", document_builder),
|
|
("document_joiner", document_joiner),
|
|
]
|
|
pair = pipe._find_next_runnable_component(components_inputs, waiting_queue)
|
|
|
|
assert pair == ("document_builder", document_builder)
|
|
|
|
def test__find_next_runnable_component_with_different_components_without_any_input(self):
|
|
document_builder = component_class(
|
|
"DocumentBuilder", input_types={"text": str}, output_types={"doc": Document}
|
|
)()
|
|
document_joiner = component_class("DocumentJoiner", input_types={"docs": Variadic[Document]})()
|
|
prompt_builder = PromptBuilder(template="{{ questions | join('\n') }}")
|
|
|
|
pipe = Pipeline()
|
|
components_inputs = {}
|
|
waiting_queue = [
|
|
("prompt_builder", prompt_builder),
|
|
("document_builder", document_builder),
|
|
("document_joiner", document_joiner),
|
|
]
|
|
pair = pipe._find_next_runnable_component(components_inputs, waiting_queue)
|
|
|
|
assert pair == ("document_builder", document_builder)
|
|
|
|
def test__is_stuck_in_a_loop(self):
|
|
document_builder = component_class(
|
|
"DocumentBuilder", input_types={"text": str}, output_types={"doc": Document}
|
|
)()
|
|
document_joiner = component_class("DocumentJoiner", input_types={"docs": Variadic[Document]})()
|
|
prompt_builder = PromptBuilder(template="{{ questions | join('\n') }}")
|
|
|
|
pipe = Pipeline()
|
|
|
|
waiting_queue = [("document_builder", document_builder)]
|
|
assert pipe._is_stuck_in_a_loop(waiting_queue)
|
|
|
|
waiting_queue = [("document_joiner", document_joiner)]
|
|
assert pipe._is_stuck_in_a_loop(waiting_queue)
|
|
|
|
waiting_queue = [("prompt_builder", prompt_builder)]
|
|
assert pipe._is_stuck_in_a_loop(waiting_queue)
|
|
|
|
waiting_queue = [("document_joiner", document_joiner), ("prompt_builder", prompt_builder)]
|
|
assert not pipe._is_stuck_in_a_loop(waiting_queue)
|
|
|
|
waiting_queue = [("document_builder", document_joiner), ("prompt_builder", prompt_builder)]
|
|
assert not pipe._is_stuck_in_a_loop(waiting_queue)
|
|
|
|
waiting_queue = [("document_builder", document_joiner), ("document_joiner", document_joiner)]
|
|
assert not pipe._is_stuck_in_a_loop(waiting_queue)
|
|
|
|
def test__enqueue_component(self):
|
|
document_builder = component_class(
|
|
"DocumentBuilder", input_types={"text": str}, output_types={"doc": Document}
|
|
)()
|
|
document_joiner = component_class("DocumentJoiner", input_types={"docs": Variadic[Document]})()
|
|
|
|
run_queue = []
|
|
waiting_queue = []
|
|
_enqueue_component(("document_builder", document_builder), run_queue, waiting_queue)
|
|
assert run_queue == [("document_builder", document_builder)]
|
|
assert waiting_queue == []
|
|
|
|
run_queue = [("document_builder", document_builder)]
|
|
waiting_queue = []
|
|
_enqueue_component(("document_builder", document_builder), run_queue, waiting_queue)
|
|
assert run_queue == [("document_builder", document_builder)]
|
|
assert waiting_queue == []
|
|
|
|
run_queue = []
|
|
waiting_queue = [("document_builder", document_builder)]
|
|
_enqueue_component(("document_builder", document_builder), run_queue, waiting_queue)
|
|
assert run_queue == [("document_builder", document_builder)]
|
|
assert waiting_queue == []
|
|
|
|
run_queue = []
|
|
waiting_queue = [("document_joiner", document_joiner)]
|
|
_enqueue_component(("document_builder", document_builder), run_queue, waiting_queue)
|
|
assert run_queue == [("document_builder", document_builder)]
|
|
assert waiting_queue == [("document_joiner", document_joiner)]
|
|
|
|
run_queue = [("document_joiner", document_joiner)]
|
|
waiting_queue = []
|
|
_enqueue_component(("document_builder", document_builder), run_queue, waiting_queue)
|
|
assert run_queue == [("document_joiner", document_joiner), ("document_builder", document_builder)]
|
|
assert waiting_queue == []
|
|
|
|
def test__dequeue_component(self):
|
|
document_builder = component_class(
|
|
"DocumentBuilder", input_types={"text": str}, output_types={"doc": Document}
|
|
)()
|
|
document_joiner = component_class("DocumentJoiner", input_types={"docs": Variadic[Document]})()
|
|
|
|
run_queue = []
|
|
waiting_queue = []
|
|
_dequeue_component(("document_builder", document_builder), run_queue, waiting_queue)
|
|
assert run_queue == []
|
|
assert waiting_queue == []
|
|
|
|
run_queue = [("document_builder", document_builder)]
|
|
waiting_queue = []
|
|
_dequeue_component(("document_builder", document_builder), run_queue, waiting_queue)
|
|
assert run_queue == []
|
|
assert waiting_queue == []
|
|
|
|
run_queue = []
|
|
waiting_queue = [("document_builder", document_builder)]
|
|
_dequeue_component(("document_builder", document_builder), run_queue, waiting_queue)
|
|
assert run_queue == []
|
|
assert waiting_queue == []
|
|
|
|
run_queue = [("document_builder", document_builder)]
|
|
waiting_queue = [("document_builder", document_builder)]
|
|
_dequeue_component(("document_builder", document_builder), run_queue, waiting_queue)
|
|
assert run_queue == []
|
|
assert waiting_queue == []
|
|
|
|
run_queue = [("document_builder", document_builder)]
|
|
waiting_queue = [("document_builder", document_builder)]
|
|
_dequeue_component(("document_joiner", document_joiner), run_queue, waiting_queue)
|
|
assert run_queue == [("document_builder", document_builder)]
|
|
assert waiting_queue == [("document_builder", document_builder)]
|
|
|
|
def test__add_missing_input_defaults(self):
|
|
name = "prompt_builder"
|
|
prompt_builder = PromptBuilder(template="{{ questions | join('\n') }}")
|
|
components_inputs = {}
|
|
_add_missing_input_defaults(name, prompt_builder, components_inputs)
|
|
assert components_inputs == {"prompt_builder": {"questions": "", "template": None, "template_variables": None}}
|
|
|
|
name = "answer_builder"
|
|
answer_builder = AnswerBuilder()
|
|
components_inputs = {"answer_builder": {"query": "What is the answer?"}}
|
|
_add_missing_input_defaults(name, answer_builder, components_inputs)
|
|
assert components_inputs == {
|
|
"answer_builder": {
|
|
"query": "What is the answer?",
|
|
"meta": None,
|
|
"documents": None,
|
|
"pattern": None,
|
|
"reference_pattern": None,
|
|
}
|
|
}
|
|
|
|
name = "branch_joiner"
|
|
branch_joiner = BranchJoiner(int)
|
|
components_inputs = {}
|
|
_add_missing_input_defaults(name, branch_joiner, components_inputs)
|
|
assert components_inputs == {"branch_joiner": {}}
|
|
|
|
def test__find_next_runnable_lazy_variadic_or_default_component(self):
|
|
document_builder = component_class(
|
|
"DocumentBuilder", input_types={"text": str}, output_types={"doc": Document}
|
|
)()
|
|
document_joiner = component_class("DocumentJoiner", input_types={"docs": Variadic[Document]})()
|
|
prompt_builder = PromptBuilder(template="{{ questions | join('\n') }}")
|
|
pipe = Pipeline()
|
|
|
|
waiting_queue = [("document_builder", document_builder)]
|
|
pair = pipe._find_next_runnable_lazy_variadic_or_default_component(waiting_queue)
|
|
assert pair == ("document_builder", document_builder)
|
|
|
|
waiting_queue = [("document_joiner", document_joiner)]
|
|
pair = pipe._find_next_runnable_lazy_variadic_or_default_component(waiting_queue)
|
|
assert pair == ("document_joiner", document_joiner)
|
|
|
|
waiting_queue = [("prompt_builder", prompt_builder)]
|
|
pair = pipe._find_next_runnable_lazy_variadic_or_default_component(waiting_queue)
|
|
assert pair == ("prompt_builder", prompt_builder)
|
|
|
|
waiting_queue = [
|
|
("document_builder", document_builder),
|
|
("document_joiner", document_joiner),
|
|
("prompt_builder", prompt_builder),
|
|
]
|
|
pair = pipe._find_next_runnable_lazy_variadic_or_default_component(waiting_queue)
|
|
assert pair == ("document_joiner", document_joiner)
|
|
|
|
waiting_queue = [
|
|
("prompt_builder", prompt_builder),
|
|
("document_builder", document_builder),
|
|
("document_joiner", document_joiner),
|
|
]
|
|
pair = pipe._find_next_runnable_lazy_variadic_or_default_component(waiting_queue)
|
|
assert pair == ("prompt_builder", prompt_builder)
|
|
|
|
waiting_queue = [
|
|
("document_builder", document_builder),
|
|
("document_joiner", document_joiner),
|
|
("prompt_builder", prompt_builder),
|
|
]
|
|
pair = pipe._find_next_runnable_lazy_variadic_or_default_component(waiting_queue)
|
|
assert pair == ("document_joiner", document_joiner)
|
|
|
|
waiting_queue = [
|
|
("document_builder", document_builder),
|
|
("prompt_builder", prompt_builder),
|
|
("document_joiner", document_joiner),
|
|
]
|
|
pair = pipe._find_next_runnable_lazy_variadic_or_default_component(waiting_queue)
|
|
assert pair == ("prompt_builder", prompt_builder)
|
|
|
|
def test__enqueue_waiting_component(self):
|
|
document_builder = component_class(
|
|
"DocumentBuilder", input_types={"text": str}, output_types={"doc": Document}
|
|
)()
|
|
document_joiner = component_class("DocumentJoiner", input_types={"docs": Variadic[Document]})()
|
|
|
|
waiting_queue = []
|
|
_enqueue_waiting_component(("document_builder", document_builder), waiting_queue)
|
|
assert waiting_queue == [("document_builder", document_builder)]
|
|
|
|
waiting_queue = [("document_builder", document_builder)]
|
|
_enqueue_waiting_component(("document_builder", document_builder), waiting_queue)
|
|
assert waiting_queue == [("document_builder", document_builder)]
|
|
|
|
waiting_queue = [("document_joiner", document_joiner)]
|
|
_enqueue_waiting_component(("document_builder", document_builder), waiting_queue)
|
|
assert waiting_queue == [("document_joiner", document_joiner), ("document_builder", document_builder)]
|
|
|
|
waiting_queue = [("document_builder", document_builder), ("document_joiner", document_joiner)]
|
|
_enqueue_waiting_component(("document_builder", document_builder), waiting_queue)
|
|
assert waiting_queue == [("document_builder", document_builder), ("document_joiner", document_joiner)]
|
|
|
|
def test__dequeue_waiting_component(self):
|
|
document_builder = component_class(
|
|
"DocumentBuilder", input_types={"text": str}, output_types={"doc": Document}
|
|
)()
|
|
document_joiner = component_class("DocumentJoiner", input_types={"docs": Variadic[Document]})()
|
|
|
|
waiting_queue = []
|
|
_dequeue_waiting_component(("document_builder", document_builder), waiting_queue)
|
|
assert waiting_queue == []
|
|
|
|
waiting_queue = [("document_builder", document_builder)]
|
|
_dequeue_waiting_component(("document_builder", document_builder), waiting_queue)
|
|
assert waiting_queue == []
|
|
|
|
waiting_queue = [("document_joiner", document_joiner)]
|
|
_dequeue_waiting_component(("document_builder", document_builder), waiting_queue)
|
|
assert waiting_queue == [("document_joiner", document_joiner)]
|
|
|
|
waiting_queue = [("document_builder", document_builder), ("document_joiner", document_joiner)]
|
|
_dequeue_waiting_component(("document_builder", document_builder), waiting_queue)
|
|
assert waiting_queue == [("document_joiner", document_joiner)]
|