Add files using upload-large-folder tool

testbed/deepset-ai__haystack/haystack/__init__.py

@@ -0,0 +1,34 @@
+# SPDX-FileCopyrightText: 2022-present deepset GmbH <info@deepset.ai>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+import haystack.logging
+import haystack.tracing
+from haystack.core.component import component
+from haystack.core.errors import ComponentError, DeserializationError
+from haystack.core.pipeline import Pipeline, PredefinedPipeline
+from haystack.core.serialization import default_from_dict, default_to_dict
+from haystack.dataclasses import Answer, Document, ExtractedAnswer, GeneratedAnswer
+
+# Initialize the logging configuration
+# This is a no-op unless `structlog` is installed
+haystack.logging.configure_logging()
+
+# Same for tracing (no op if `opentelemetry` or `ddtrace` is not installed)
+haystack.tracing.auto_enable_tracing()
+
+__all__ = [
+    "component",
+    "default_from_dict",
+    "default_to_dict",
+    "DeserializationError",
+    "ComponentError",
+    "Pipeline",
+    "PredefinedPipeline",
+    "Document",
+    "Answer",
+    "GeneratedAnswer",
+    "ExtractedAnswer",
+]
+
+# FIXME: remove before merging PR

testbed/deepset-ai__haystack/haystack/components/__init__.py

@@ -0,0 +1,3 @@
+# SPDX-FileCopyrightText: 2022-present deepset GmbH <info@deepset.ai>
+#
+# SPDX-License-Identifier: Apache-2.0

testbed/deepset-ai__haystack/haystack/components/connectors/__init__.py

@@ -0,0 +1,7 @@
+# SPDX-FileCopyrightText: 2022-present deepset GmbH <info@deepset.ai>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from haystack.components.connectors.openapi_service import OpenAPIServiceConnector
+
+__all__ = ["OpenAPIServiceConnector"]

testbed/deepset-ai__haystack/haystack/components/connectors/openapi_service.py

@@ -0,0 +1,270 @@
+# SPDX-FileCopyrightText: 2022-present deepset GmbH <info@deepset.ai>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+import json
+from collections import defaultdict
+from copy import copy
+from typing import Any, Dict, List, Optional, Union
+
+from haystack import component, logging
+from haystack.dataclasses import ChatMessage, ChatRole
+from haystack.lazy_imports import LazyImport
+
+logger = logging.getLogger(__name__)
+
+with LazyImport("Run 'pip install openapi3'") as openapi_imports:
+    from openapi3 import OpenAPI
+
+
+@component
+class OpenAPIServiceConnector:
+    """
+    A component which connects the Haystack framework to OpenAPI services.
+
+    The `OpenAPIServiceConnector` component connects the Haystack framework to OpenAPI services, enabling it to call
+    operations as defined in the OpenAPI specification of the service.
+
+    It integrates with `ChatMessage` dataclass, where the payload in messages is used to determine the method to be
+    called and the parameters to be passed. The message payload should be an OpenAI JSON formatted function calling
+    string consisting of the method name and the parameters to be passed to the method. The method name and parameters
+    are then used to invoke the method on the OpenAPI service. The response from the service is returned as a
+    `ChatMessage`.
+
+    Before using this component, users usually resolve service endpoint parameters with a help of
+    `OpenAPIServiceToFunctions` component.
+
+    The example below demonstrates how to use the `OpenAPIServiceConnector` to invoke a method on a https://serper.dev/
+    service specified via OpenAPI specification.
+
+    Note, however, that `OpenAPIServiceConnector` is usually not meant to be used directly, but rather as part of a
+    pipeline that includes the `OpenAPIServiceToFunctions` component and an `OpenAIChatGenerator` component using LLM
+    with the function calling capabilities. In the example below we use the function calling payload directly, but in a
+    real-world scenario, the function calling payload would usually be generated by the `OpenAIChatGenerator` component.
+
+    Usage example:
+
+    ```python
+    import json
+    import requests
+
+    from haystack.components.connectors import OpenAPIServiceConnector
+    from haystack.dataclasses import ChatMessage
+
+
+    fc_payload = [{'function': {'arguments': '{"q": "Why was Sam Altman ousted from OpenAI?"}', 'name': 'search'},
+                   'id': 'call_PmEBYvZ7mGrQP5PUASA5m9wO', 'type': 'function'}]
+
+    serper_token = <your_serper_dev_token>
+    serperdev_openapi_spec = json.loads(requests.get("https://bit.ly/serper_dev_spec").text)
+    service_connector = OpenAPIServiceConnector()
+    result = service_connector.run(messages=[ChatMessage.from_assistant(json.dumps(fc_payload))],
+                                   service_openapi_spec=serperdev_openapi_spec, service_credentials=serper_token)
+    print(result)
+
+    >> {'service_response': [ChatMessage(content='{"searchParameters": {"q": "Why was Sam Altman ousted from OpenAI?",
+    >> "type": "search", "engine": "google"}, "answerBox": {"snippet": "Concerns over AI safety and OpenAI\'s role
+    >> in protecting were at the center of Altman\'s brief ouster from the company."...
+    ```
+
+    """
+
+    def __init__(self):
+        """
+        Initializes the OpenAPIServiceConnector instance
+        """
+        openapi_imports.check()
+
+    @component.output_types(service_response=Dict[str, Any])
+    def run(
+        self,
+        messages: List[ChatMessage],
+        service_openapi_spec: Dict[str, Any],
+        service_credentials: Optional[Union[dict, str]] = None,
+    ) -> Dict[str, List[ChatMessage]]:
+        """
+        Processes a list of chat messages to invoke a method on an OpenAPI service.
+
+        It parses the last message in the list, expecting it to contain an OpenAI function calling descriptor
+        (name & parameters) in JSON format.
+
+        :param messages: A list of `ChatMessage` objects containing the messages to be processed. The last message
+        should contain the function invocation payload in OpenAI function calling format. See the example in the class
+        docstring for the expected format.
+        :param service_openapi_spec: The OpenAPI JSON specification object of the service to be invoked. All the refs
+        should already be resolved.
+        :param service_credentials: The credentials to be used for authentication with the service.
+        Currently, only the http and apiKey OpenAPI security schemes are supported.
+
+        :return: A dictionary with the following keys:
+            - `service_response`:  a list of `ChatMessage` objects, each containing the response from the service. The
+                                   response is in JSON format, and the `content` attribute of the `ChatMessage` contains
+                                   the JSON string.
+
+        :raises ValueError: If the last message is not from the assistant or if it does not contain the correct payload
+        to invoke a method on the service.
+        """
+
+        last_message = messages[-1]
+        if not last_message.is_from(ChatRole.ASSISTANT):
+            raise ValueError(f"{last_message} is not from the assistant.")
+
+        function_invocation_payloads = self._parse_message(last_message)
+
+        # instantiate the OpenAPI service for the given specification
+        openapi_service = OpenAPI(service_openapi_spec)
+        self._authenticate_service(openapi_service, service_credentials)
+
+        response_messages = []
+        for method_invocation_descriptor in function_invocation_payloads:
+            service_response = self._invoke_method(openapi_service, method_invocation_descriptor)
+            # openapi3 parses the JSON service response into a model object, which is not our focus at the moment.
+            # Instead, we require direct access to the raw JSON data of the response, rather than the model objects
+            # provided by the openapi3 library. This approach helps us avoid issues related to (de)serialization.
+            # By accessing the raw JSON response through `service_response._raw_data`, we can serialize this data
+            # into a string. Finally, we use this string to create a ChatMessage object.
+            response_messages.append(ChatMessage.from_user(json.dumps(service_response._raw_data)))
+
+        return {"service_response": response_messages}
+
+    def _parse_message(self, message: ChatMessage) -> List[Dict[str, Any]]:
+        """
+        Parses the message to extract the method invocation descriptor.
+
+        :param message: ChatMessage containing the tools calls
+        :return: A list of function invocation payloads
+        :raises ValueError: If the content is not valid JSON or lacks required fields.
+        """
+        function_payloads = []
+        try:
+            tool_calls = json.loads(message.content)
+        except json.JSONDecodeError:
+            raise ValueError("Invalid JSON content, expected OpenAI tools message.", message.content)
+
+        for tool_call in tool_calls:
+            # this should never happen, but just in case do a sanity check
+            if "type" not in tool_call:
+                raise ValueError("Message payload doesn't seem to be a tool invocation descriptor", message.content)
+
+            # In OpenAPIServiceConnector we know how to handle functions tools only
+            if tool_call["type"] == "function":
+                function_call = tool_call["function"]
+                function_payloads.append(
+                    {"arguments": json.loads(function_call["arguments"]), "name": function_call["name"]}
+                )
+        return function_payloads
+
+    def _authenticate_service(self, openapi_service: OpenAPI, credentials: Optional[Union[dict, str]] = None):
+        """
+        Authentication with an OpenAPI service.
+
+        Authenticates with the OpenAPI service if required, supporting both single (str) and multiple
+        authentication methods (dict).
+
+        OpenAPI spec v3 supports the following security schemes:
+        http – for Basic, Bearer and other HTTP authentications schemes
+        apiKey – for API keys and cookie authentication
+        oauth2 – for OAuth 2
+        openIdConnect – for OpenID Connect Discovery
+
+        Currently, only the http and apiKey schemes are supported. Multiple security schemes can be defined in the
+        OpenAPI spec, and the credentials should be provided as a dictionary with keys matching the security scheme
+        names. If only one security scheme is defined, the credentials can be provided as a simple string.
+
+        :param openapi_service: The OpenAPI service instance.
+        :param credentials: Credentials for authentication, which can be either a string (e.g. token) or a dictionary
+        with keys matching the authentication method names.
+        :raises ValueError: If authentication fails, is not found, or if appropriate credentials are missing.
+        """
+        if openapi_service.raw_element.get("components", {}).get("securitySchemes"):
+            service_name = openapi_service.info.title
+            if not credentials:
+                raise ValueError(f"Service {service_name} requires authentication but no credentials were provided.")
+
+            # a dictionary of security schemes defined in the OpenAPI spec
+            # each key is the name of the security scheme, and the value is the scheme definition
+            security_schemes = openapi_service.components.securitySchemes.raw_element
+            supported_schemes = ["http", "apiKey"]  # todo: add support for oauth2 and openIdConnect
+
+            authenticated = False
+            for scheme_name, scheme in security_schemes.items():
+                if scheme["type"] in supported_schemes:
+                    auth_credentials = None
+                    if isinstance(credentials, str):
+                        auth_credentials = credentials
+                    elif isinstance(credentials, dict) and scheme_name in credentials:
+                        auth_credentials = credentials[scheme_name]
+                    if auth_credentials:
+                        openapi_service.authenticate(scheme_name, auth_credentials)
+                        authenticated = True
+                        break
+
+                    raise ValueError(
+                        f"Service {service_name} requires {scheme_name} security scheme but no "
+                        f"credentials were provided for it. Check the service configuration and credentials."
+                    )
+            if not authenticated:
+                raise ValueError(
+                    f"Service {service_name} requires authentication but no credentials were provided "
+                    f"for it. Check the service configuration and credentials."
+                )
+
+    def _invoke_method(self, openapi_service: OpenAPI, method_invocation_descriptor: Dict[str, Any]) -> Any:
+        """
+        Invokes the specified method on the OpenAPI service.
+
+        The method name and arguments are passed in the method_invocation_descriptor.
+
+        :param openapi_service: The OpenAPI service instance.
+        :param method_invocation_descriptor: The method name and arguments to be passed to the method. The payload
+        should contain the method name (key: "name") and the arguments (key: "arguments"). The name is a string, and
+        the arguments are a dictionary of key-value pairs.
+        :return: A service JSON response.
+        :raises RuntimeError: If the method is not found or invocation fails.
+        """
+        name = method_invocation_descriptor.get("name")
+        invocation_arguments = copy(method_invocation_descriptor.get("arguments", {}))
+        if not name or not invocation_arguments:
+            raise ValueError(
+                f"Invalid function calling descriptor: {method_invocation_descriptor} . It should contain "
+                f"a method name and arguments."
+            )
+
+        # openapi3 specific method to call the operation, do we have it?
+        method_to_call = getattr(openapi_service, f"call_{name}", None)
+        if not callable(method_to_call):
+            raise RuntimeError(f"Operation {name} not found in OpenAPI specification {openapi_service.info.title}")
+
+        # get the operation reference from the method_to_call
+        operation = method_to_call.operation.__self__
+        operation_dict = operation.raw_element
+
+        # Pack URL/query parameters under "parameters" key
+        method_call_params: Dict[str, Dict[str, Any]] = defaultdict(dict)
+        parameters = operation_dict.get("parameters", [])
+        request_body = operation_dict.get("requestBody", {})
+
+        for param in parameters:
+            param_name = param["name"]
+            param_value = invocation_arguments.get(param_name)
+            if param_value:
+                method_call_params["parameters"][param_name] = param_value
+            else:
+                if param.get("required", False):
+                    raise ValueError(f"Missing parameter: '{param_name}' required for the '{name}' operation.")
+
+        # Pack request body parameters under "data" key
+        if request_body:
+            schema = request_body.get("content", {}).get("application/json", {}).get("schema", {})
+            required_params = schema.get("required", [])
+            for param_name in schema.get("properties", {}):
+                param_value = invocation_arguments.get(param_name)
+                if param_value:
+                    method_call_params["data"][param_name] = param_value
+                else:
+                    if param_name in required_params:
+                        raise ValueError(
+                            f"Missing requestBody parameter: '{param_name}' required for the '{name}' operation."
+                        )
+        # call the underlying service REST API with the parameters
+        return method_to_call(**method_call_params)

testbed/deepset-ai__haystack/haystack/components/evaluators/__init__.py

@@ -0,0 +1,25 @@
+# SPDX-FileCopyrightText: 2022-present deepset GmbH <info@deepset.ai>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from .answer_exact_match import AnswerExactMatchEvaluator
+from .context_relevance import ContextRelevanceEvaluator
+from .document_map import DocumentMAPEvaluator
+from .document_mrr import DocumentMRREvaluator
+from .document_ndcg import DocumentNDCGEvaluator
+from .document_recall import DocumentRecallEvaluator
+from .faithfulness import FaithfulnessEvaluator
+from .llm_evaluator import LLMEvaluator
+from .sas_evaluator import SASEvaluator
+
+__all__ = [
+    "AnswerExactMatchEvaluator",
+    "ContextRelevanceEvaluator",
+    "DocumentMAPEvaluator",
+    "DocumentMRREvaluator",
+    "DocumentNDCGEvaluator",
+    "DocumentRecallEvaluator",
+    "FaithfulnessEvaluator",
+    "LLMEvaluator",
+    "SASEvaluator",
+]

testbed/deepset-ai__haystack/haystack/components/evaluators/answer_exact_match.py

@@ -0,0 +1,69 @@
+# SPDX-FileCopyrightText: 2022-present deepset GmbH <info@deepset.ai>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from typing import Any, Dict, List
+
+from haystack.core.component import component
+
+
+@component
+class AnswerExactMatchEvaluator:
+    """
+    An answer exact match evaluator class.
+
+    The evaluator that checks if the predicted answers matches any of the ground truth answers exactly.
+    The result is a number from 0.0 to 1.0, it represents the proportion of predicted answers
+    that matched one of the ground truth answers.
+    There can be multiple ground truth answers and multiple predicted answers as input.
+
+
+    Usage example:
+    ```python
+    from haystack.components.evaluators import AnswerExactMatchEvaluator
+
+    evaluator = AnswerExactMatchEvaluator()
+    result = evaluator.run(
+        ground_truth_answers=["Berlin", "Paris"],
+        predicted_answers=["Berlin", "Lyon"],
+    )
+
+    print(result["individual_scores"])
+    # [1, 0]
+    print(result["score"])
+    # 0.5
+    ```
+    """
+
+    @component.output_types(individual_scores=List[int], score=float)
+    def run(self, ground_truth_answers: List[str], predicted_answers: List[str]) -> Dict[str, Any]:
+        """
+        Run the AnswerExactMatchEvaluator on the given inputs.
+
+        The `ground_truth_answers` and `retrieved_answers` must have the same length.
+
+        :param ground_truth_answers:
+            A list of expected answers.
+        :param predicted_answers:
+            A list of predicted answers.
+        :returns:
+            A dictionary with the following outputs:
+            - `individual_scores` - A list of 0s and 1s, where 1 means that the predicted answer matched one of the
+                ground truth.
+            - `score` - A number from 0.0 to 1.0 that represents the proportion of questions where any predicted
+                         answer matched one of the ground truth answers.
+        """
+        if not len(ground_truth_answers) == len(predicted_answers):
+            raise ValueError("The length of ground_truth_answers and predicted_answers must be the same.")
+
+        matches = []
+        for truth, extracted in zip(ground_truth_answers, predicted_answers):
+            if truth == extracted:
+                matches.append(1)
+            else:
+                matches.append(0)
+
+        # The proportion of questions where any predicted answer matched one of the ground truth answers
+        average = sum(matches) / len(predicted_answers)
+
+        return {"individual_scores": matches, "score": average}

testbed/deepset-ai__haystack/haystack/components/evaluators/context_relevance.py

@@ -0,0 +1,222 @@
+# SPDX-FileCopyrightText: 2022-present deepset GmbH <info@deepset.ai>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from statistics import mean
+from typing import Any, Dict, List, Optional
+
+from haystack import component, default_from_dict, default_to_dict
+from haystack.components.evaluators.llm_evaluator import LLMEvaluator
+from haystack.utils import Secret, deserialize_secrets_inplace
+
+# Private global variable for default examples to include in the prompt if the user does not provide any examples
+_DEFAULT_EXAMPLES = [
+    {
+        "inputs": {
+            "questions": "What is the capital of Germany?",
+            "contexts": ["Berlin is the capital of Germany. Berlin and was founded in 1244."],
+        },
+        "outputs": {"relevant_statements": ["Berlin is the capital of Germany."]},
+    },
+    {
+        "inputs": {
+            "questions": "What is the capital of France?",
+            "contexts": [
+                "Berlin is the capital of Germany and was founded in 1244.",
+                "Europe is a continent with 44 countries.",
+                "Madrid is the capital of Spain.",
+            ],
+        },
+        "outputs": {"relevant_statements": []},
+    },
+    {
+        "inputs": {"questions": "What is the capital of Italy?", "contexts": ["Rome is the capital of Italy."]},
+        "outputs": {"relevant_statements": ["Rome is the capital of Italy."]},
+    },
+]
+
+
+@component
+class ContextRelevanceEvaluator(LLMEvaluator):
+    """
+    Evaluator that checks if a provided context is relevant to the question.
+
+    An LLM breaks up a context into multiple statements and checks whether each statement
+    is relevant for answering a question.
+    The score for each context is either binary score of 1 or 0, where 1 indicates that the context is relevant
+    to the question and 0 indicates that the context is not relevant.
+    The evaluator also provides the relevant statements from the context and an average score over all the provided
+    input questions contexts pairs.
+
+    Usage example:
+    ```python
+    from haystack.components.evaluators import ContextRelevanceEvaluator
+
+    questions = ["Who created the Python language?", "Why does Java needs a JVM?", "Is C++ better than Python?"]
+    contexts = [
+        [(
+            "Python, created by Guido van Rossum in the late 1980s, is a high-level general-purpose programming "
+            "language. Its design philosophy emphasizes code readability, and its language constructs aim to help "
+            "programmers write clear, logical code for both small and large-scale software projects."
+        )],
+        [(
+            "Java is a high-level, class-based, object-oriented programming language that is designed to have as few "
+            "implementation dependencies as possible. The JVM has two primary functions: to allow Java programs to run"
+            "on any device or operating system (known as the 'write once, run anywhere' principle), and to manage and"
+            "optimize program memory."
+        )],
+        [(
+            "C++ is a general-purpose programming language created by Bjarne Stroustrup as an extension of the C "
+            "programming language."
+        )],
+    ]
+
+    evaluator = ContextRelevanceEvaluator()
+    result = evaluator.run(questions=questions, contexts=contexts)
+    print(result["score"])
+    # 0.67
+    print(result["individual_scores"])
+    # [1,1,0]
+    print(result["results"])
+    # [{
+    #   'relevant_statements': ['Python, created by Guido van Rossum in the late 1980s.'],
+    #    'score': 1.0
+    #  },
+    #  {
+    #   'relevant_statements': ['The JVM has two primary functions: to allow Java programs to run on any device or
+    #                           operating system (known as the "write once, run anywhere" principle), and to manage and
+    #                           optimize program memory'],
+    #   'score': 1.0
+    #  },
+    #  {
+    #   'relevant_statements': [],
+    #   'score': 0.0
+    #  }]
+    ```
+    """
+
+    def __init__(
+        self,
+        examples: Optional[List[Dict[str, Any]]] = None,
+        progress_bar: bool = True,
+        api: str = "openai",
+        api_key: Secret = Secret.from_env_var("OPENAI_API_KEY"),
+        api_params: Optional[Dict[str, Any]] = None,
+        raise_on_failure: bool = True,
+    ):
+        """
+        Creates an instance of ContextRelevanceEvaluator.
+
+        :param examples:
+            Optional few-shot examples conforming to the expected input and output format of ContextRelevanceEvaluator.
+            Default examples will be used if none are provided.
+            Each example must be a dictionary with keys "inputs" and "outputs".
+            "inputs" must be a dictionary with keys "questions" and "contexts".
+            "outputs" must be a dictionary with "relevant_statements".
+            Expected format:
+            [{
+                "inputs": {
+                    "questions": "What is the capital of Italy?", "contexts": ["Rome is the capital of Italy."],
+                },
+                "outputs": {
+                    "relevant_statements": ["Rome is the capital of Italy."],
+                },
+            }]
+        :param progress_bar:
+            Whether to show a progress bar during the evaluation.
+        :param api:
+            The API to use for calling an LLM through a Generator.
+            Supported APIs: "openai".
+        :param api_key:
+            The API key.
+        :param api_params:
+            Parameters for an OpenAI API compatible completions call.
+        :param raise_on_failure:
+            Whether to raise an exception if the API call fails.
+
+        """
+
+        self.instructions = (
+            "Please extract only sentences from the provided context which are absolutely relevant and "
+            "required to answer the following question. If no relevant sentences are found, or if you "
+            "believe the question cannot be answered from the given context, return an empty list, example: []"
+        )
+        self.inputs = [("questions", List[str]), ("contexts", List[List[str]])]
+        self.outputs = ["relevant_statements"]
+        self.examples = examples or _DEFAULT_EXAMPLES
+        self.api = api
+        self.api_key = api_key
+        self.api_params = api_params or {}
+
+        super(ContextRelevanceEvaluator, self).__init__(
+            instructions=self.instructions,
+            inputs=self.inputs,
+            outputs=self.outputs,
+            examples=self.examples,
+            api=self.api,
+            api_key=self.api_key,
+            api_params=self.api_params,
+            raise_on_failure=raise_on_failure,
+            progress_bar=progress_bar,
+        )
+
+    @component.output_types(score=float, results=List[Dict[str, Any]])
+    def run(self, **inputs) -> Dict[str, Any]:
+        """
+        Run the LLM evaluator.
+
+        :param questions:
+            A list of questions.
+        :param contexts:
+            A list of lists of contexts. Each list of contexts corresponds to one question.
+        :returns:
+            A dictionary with the following outputs:
+                - `score`: Mean context relevance score over all the provided input questions.
+                - `results`: A list of dictionaries with `relevant_statements` and `score` for each input context.
+        """
+        result = super(ContextRelevanceEvaluator, self).run(**inputs)
+
+        for idx, res in enumerate(result["results"]):
+            if res is None:
+                result["results"][idx] = {"relevant_statements": [], "score": float("nan")}
+                continue
+            if len(res["relevant_statements"]) > 0:
+                res["score"] = 1
+            else:
+                res["score"] = 0
+
+        # calculate average context relevance score over all queries
+        result["score"] = mean([res["score"] for res in result["results"]])
+        result["individual_scores"] = [res["score"] for res in result["results"]]  # useful for the EvaluationRunResult
+
+        return result
+
+    def to_dict(self) -> Dict[str, Any]:
+        """
+        Serialize this component to a dictionary.
+
+        :returns:
+            A dictionary with serialized data.
+        """
+        return default_to_dict(
+            self,
+            api=self.api,
+            api_key=self.api_key.to_dict() if self.api_key else None,
+            examples=self.examples,
+            progress_bar=self.progress_bar,
+            api_params=self.api_params,
+            raise_on_failure=self.raise_on_failure,
+        )
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "ContextRelevanceEvaluator":
+        """
+        Deserialize this component from a dictionary.
+
+        :param data:
+            The dictionary representation of this component.
+        :returns:
+            The deserialized component instance.
+        """
+        deserialize_secrets_inplace(data["init_parameters"], keys=["api_key"])
+        return default_from_dict(cls, data)

testbed/deepset-ai__haystack/haystack/components/evaluators/document_map.py

@@ -0,0 +1,90 @@
+# SPDX-FileCopyrightText: 2022-present deepset GmbH <info@deepset.ai>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from typing import Any, Dict, List
+
+from haystack import Document, component
+
+
+@component
+class DocumentMAPEvaluator:
+    """
+    A Mean Average Precision (MAP) evaluator for documents.
+
+    Evaluator that calculates the mean average precision of the retrieved documents, a metric
+    that measures how high retrieved documents are ranked.
+    Each question can have multiple ground truth documents and multiple retrieved documents.
+
+    `DocumentMAPEvaluator` doesn't normalize its inputs, the `DocumentCleaner` component
+    should be used to clean and normalize the documents before passing them to this evaluator.
+
+    Usage example:
+    ```python
+    from haystack import Document
+    from haystack.components.evaluators import DocumentMAPEvaluator
+
+    evaluator = DocumentMAPEvaluator()
+    result = evaluator.run(
+        ground_truth_documents=[
+            [Document(content="France")],
+            [Document(content="9th century"), Document(content="9th")],
+        ],
+        retrieved_documents=[
+            [Document(content="France")],
+            [Document(content="9th century"), Document(content="10th century"), Document(content="9th")],
+        ],
+    )
+
+    print(result["individual_scores"])
+    # [1.0, 0.8333333333333333]
+    print(result["score"])
+    # 0.9166666666666666
+    ```
+    """
+
+    # Refer to https://www.pinecone.io/learn/offline-evaluation/ for the algorithm.
+    @component.output_types(score=float, individual_scores=List[float])
+    def run(
+        self, ground_truth_documents: List[List[Document]], retrieved_documents: List[List[Document]]
+    ) -> Dict[str, Any]:
+        """
+        Run the DocumentMAPEvaluator on the given inputs.
+
+        All lists must have the same length.
+
+        :param ground_truth_documents:
+            A list of expected documents for each question.
+        :param retrieved_documents:
+            A list of retrieved documents for each question.
+        :returns:
+            A dictionary with the following outputs:
+            - `score` - The average of calculated scores.
+            - `individual_scores` - A list of numbers from 0.0 to 1.0 that represents how high retrieved documents
+                are ranked.
+        """
+        if len(ground_truth_documents) != len(retrieved_documents):
+            msg = "The length of ground_truth_documents and retrieved_documents must be the same."
+            raise ValueError(msg)
+
+        individual_scores = []
+
+        for ground_truth, retrieved in zip(ground_truth_documents, retrieved_documents):
+            average_precision = 0.0
+            average_precision_numerator = 0.0
+            relevant_documents = 0
+
+            ground_truth_contents = [doc.content for doc in ground_truth if doc.content is not None]
+            for rank, retrieved_document in enumerate(retrieved):
+                if retrieved_document.content is None:
+                    continue
+
+                if retrieved_document.content in ground_truth_contents:
+                    relevant_documents += 1
+                    average_precision_numerator += relevant_documents / (rank + 1)
+            if relevant_documents > 0:
+                average_precision = average_precision_numerator / relevant_documents
+            individual_scores.append(average_precision)
+
+        score = sum(individual_scores) / len(ground_truth_documents)
+        return {"score": score, "individual_scores": individual_scores}

testbed/deepset-ai__haystack/haystack/components/evaluators/document_mrr.py

@@ -0,0 +1,84 @@
+# SPDX-FileCopyrightText: 2022-present deepset GmbH <info@deepset.ai>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from typing import Any, Dict, List
+
+from haystack import Document, component
+
+
+@component
+class DocumentMRREvaluator:
+    """
+    Evaluator that calculates the mean reciprocal rank of the retrieved documents.
+
+    MRR measures how high the first retrieved document is ranked.
+    Each question can have multiple ground truth documents and multiple retrieved documents.
+
+    `DocumentMRREvaluator` doesn't normalize its inputs, the `DocumentCleaner` component
+    should be used to clean and normalize the documents before passing them to this evaluator.
+
+    Usage example:
+    ```python
+    from haystack import Document
+    from haystack.components.evaluators import DocumentMRREvaluator
+
+    evaluator = DocumentMRREvaluator()
+    result = evaluator.run(
+        ground_truth_documents=[
+            [Document(content="France")],
+            [Document(content="9th century"), Document(content="9th")],
+        ],
+        retrieved_documents=[
+            [Document(content="France")],
+            [Document(content="9th century"), Document(content="10th century"), Document(content="9th")],
+        ],
+    )
+    print(result["individual_scores"])
+    # [1.0, 1.0]
+    print(result["score"])
+    # 1.0
+    ```
+    """
+
+    # Refer to https://www.pinecone.io/learn/offline-evaluation/ for the algorithm.
+    @component.output_types(score=float, individual_scores=List[float])
+    def run(
+        self, ground_truth_documents: List[List[Document]], retrieved_documents: List[List[Document]]
+    ) -> Dict[str, Any]:
+        """
+        Run the DocumentMRREvaluator on the given inputs.
+
+        `ground_truth_documents` and `retrieved_documents` must have the same length.
+
+        :param ground_truth_documents:
+            A list of expected documents for each question.
+        :param retrieved_documents:
+            A list of retrieved documents for each question.
+        :returns:
+            A dictionary with the following outputs:
+            - `score` - The average of calculated scores.
+            - `individual_scores` - A list of numbers from 0.0 to 1.0 that represents how high the first retrieved
+                document is ranked.
+        """
+        if len(ground_truth_documents) != len(retrieved_documents):
+            msg = "The length of ground_truth_documents and retrieved_documents must be the same."
+            raise ValueError(msg)
+
+        individual_scores = []
+
+        for ground_truth, retrieved in zip(ground_truth_documents, retrieved_documents):
+            reciprocal_rank = 0.0
+
+            ground_truth_contents = [doc.content for doc in ground_truth if doc.content is not None]
+            for rank, retrieved_document in enumerate(retrieved):
+                if retrieved_document.content is None:
+                    continue
+                if retrieved_document.content in ground_truth_contents:
+                    reciprocal_rank = 1 / (rank + 1)
+                    break
+            individual_scores.append(reciprocal_rank)
+
+        score = sum(individual_scores) / len(ground_truth_documents)
+
+        return {"score": score, "individual_scores": individual_scores}

testbed/deepset-ai__haystack/haystack/components/evaluators/document_ndcg.py

@@ -0,0 +1,133 @@
+# SPDX-FileCopyrightText: 2022-present deepset GmbH <info@deepset.ai>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from math import log2
+from typing import Any, Dict, List
+
+from haystack import Document, component
+
+
+@component
+class DocumentNDCGEvaluator:
+    """
+    Evaluator that calculates the normalized discounted cumulative gain (NDCG) of retrieved documents.
+
+    Each question can have multiple ground truth documents and multiple retrieved documents.
+    If the ground truth documents have relevance scores, the NDCG calculation uses these scores.
+    Otherwise, it assumes binary relevance of all ground truth documents.
+
+    Usage example:
+    ```python
+    from haystack import Document
+    from haystack.components.evaluators import DocumentNDCGEvaluator
+
+    evaluator = DocumentNDCGEvaluator()
+    result = evaluator.run(
+        ground_truth_documents=[[Document(content="France", score=1.0), Document(content="Paris", score=0.5)]],
+        retrieved_documents=[[Document(content="France"), Document(content="Germany"), Document(content="Paris")]],
+    )
+    print(result["individual_scores"])
+    # [0.8869]
+    print(result["score"])
+    # 0.8869
+    ```
+    """
+
+    @component.output_types(score=float, individual_scores=List[float])
+    def run(
+        self, ground_truth_documents: List[List[Document]], retrieved_documents: List[List[Document]]
+    ) -> Dict[str, Any]:
+        """
+        Run the DocumentNDCGEvaluator on the given inputs.
+
+        `ground_truth_documents` and `retrieved_documents` must have the same length.
+        The list items within `ground_truth_documents` and `retrieved_documents` can differ in length.
+
+        :param ground_truth_documents:
+            Lists of expected documents, one list per question. Binary relevance is used if documents have no scores.
+        :param retrieved_documents:
+            Lists of retrieved documents, one list per question.
+        :returns:
+            A dictionary with the following outputs:
+            - `score` - The average of calculated scores.
+            - `individual_scores` - A list of numbers from 0.0 to 1.0 that represents the NDCG for each question.
+        """
+        self.validate_inputs(ground_truth_documents, retrieved_documents)
+
+        individual_scores = []
+
+        for gt_docs, ret_docs in zip(ground_truth_documents, retrieved_documents):
+            dcg = self.calculate_dcg(gt_docs, ret_docs)
+            idcg = self.calculate_idcg(gt_docs)
+            ndcg = dcg / idcg if idcg > 0 else 0
+            individual_scores.append(ndcg)
+
+        score = sum(individual_scores) / len(ground_truth_documents)
+
+        return {"score": score, "individual_scores": individual_scores}
+
+    @staticmethod
+    def validate_inputs(gt_docs: List[List[Document]], ret_docs: List[List[Document]]):
+        """
+        Validate the input parameters.
+
+        :param gt_docs:
+            The ground_truth_documents to validate.
+        :param ret_docs:
+            The retrieved_documents to validate.
+
+        :raises ValueError:
+            If the ground_truth_documents or the retrieved_documents are an empty a list.
+            If the length of ground_truth_documents and retrieved_documents differs.
+            If any list of documents in ground_truth_documents contains a mix of documents with and without a score.
+        """
+        if len(gt_docs) == 0 or len(ret_docs) == 0:
+            msg = "ground_truth_documents and retrieved_documents must be provided."
+            raise ValueError(msg)
+
+        if len(gt_docs) != len(ret_docs):
+            msg = "The length of ground_truth_documents and retrieved_documents must be the same."
+            raise ValueError(msg)
+
+        for docs in gt_docs:
+            if any(doc.score is not None for doc in docs) and any(doc.score is None for doc in docs):
+                msg = "Either none or all documents in each list of ground_truth_documents must have a score."
+                raise ValueError(msg)
+
+    @staticmethod
+    def calculate_dcg(gt_docs: List[Document], ret_docs: List[Document]) -> float:
+        """
+        Calculate the discounted cumulative gain (DCG) of the retrieved documents.
+
+        :param gt_docs:
+            The ground truth documents.
+        :param ret_docs:
+            The retrieved documents.
+        :returns:
+            The discounted cumulative gain (DCG) of the retrieved
+            documents based on the ground truth documents.
+        """
+        dcg = 0.0
+        relevant_id_to_score = {doc.id: doc.score if doc.score is not None else 1 for doc in gt_docs}
+        for i, doc in enumerate(ret_docs):
+            if doc.id in relevant_id_to_score:  # TODO Related to https://github.com/deepset-ai/haystack/issues/8412
+                dcg += relevant_id_to_score[doc.id] / log2(i + 2)  # i + 2 because i is 0-indexed
+        return dcg
+
+    @staticmethod
+    def calculate_idcg(gt_docs: List[Document]) -> float:
+        """
+        Calculate the ideal discounted cumulative gain (IDCG) of the ground truth documents.
+
+        :param gt_docs:
+            The ground truth documents.
+        :returns:
+            The ideal discounted cumulative gain (IDCG) of the ground truth documents.
+        """
+        idcg = 0.0
+        for i, doc in enumerate(sorted(gt_docs, key=lambda x: x.score if x.score is not None else 1, reverse=True)):
+            # If the document has a score, use it; otherwise, use 1 for binary relevance.
+            relevance = doc.score if doc.score is not None else 1
+            idcg += relevance / log2(i + 2)  # i + 2 because i is 0-indexed
+        return idcg

testbed/deepset-ai__haystack/haystack/components/evaluators/document_recall.py

@@ -0,0 +1,133 @@
+# SPDX-FileCopyrightText: 2022-present deepset GmbH <info@deepset.ai>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from enum import Enum
+from typing import Any, Dict, List, Union
+
+from haystack import component, default_to_dict
+from haystack.dataclasses import Document
+
+
+class RecallMode(Enum):
+    """
+    Enum for the mode to use for calculating the recall score.
+    """
+
+    # Score is based on whether any document is retrieved.
+    SINGLE_HIT = "single_hit"
+    # Score is based on how many documents were retrieved.
+    MULTI_HIT = "multi_hit"
+
+    def __str__(self):
+        return self.value
+
+    @staticmethod
+    def from_str(string: str) -> "RecallMode":
+        """
+        Convert a string to a RecallMode enum.
+        """
+        enum_map = {e.value: e for e in RecallMode}
+        mode = enum_map.get(string)
+        if mode is None:
+            msg = f"Unknown recall mode '{string}'. Supported modes are: {list(enum_map.keys())}"
+            raise ValueError(msg)
+        return mode
+
+
+@component
+class DocumentRecallEvaluator:
+    """
+    Evaluator that calculates the Recall score for a list of documents.
+
+    Returns both a list of scores for each question and the average.
+    There can be multiple ground truth documents and multiple predicted documents as input.
+
+    Usage example:
+    ```python
+    from haystack import Document
+    from haystack.components.evaluators import DocumentRecallEvaluator
+
+    evaluator = DocumentRecallEvaluator()
+    result = evaluator.run(
+        ground_truth_documents=[
+            [Document(content="France")],
+            [Document(content="9th century"), Document(content="9th")],
+        ],
+        retrieved_documents=[
+            [Document(content="France")],
+            [Document(content="9th century"), Document(content="10th century"), Document(content="9th")],
+        ],
+    )
+    print(result["individual_scores"])
+    # [1.0, 1.0]
+    print(result["score"])
+    # 1.0
+    ```
+    """
+
+    def __init__(self, mode: Union[str, RecallMode] = RecallMode.SINGLE_HIT):
+        """
+        Create a DocumentRecallEvaluator component.
+
+        :param mode:
+            Mode to use for calculating the recall score.
+        """
+        if isinstance(mode, str):
+            mode = RecallMode.from_str(mode)
+
+        mode_functions = {RecallMode.SINGLE_HIT: self._recall_single_hit, RecallMode.MULTI_HIT: self._recall_multi_hit}
+        self.mode_function = mode_functions[mode]
+        self.mode = mode
+
+    def _recall_single_hit(self, ground_truth_documents: List[Document], retrieved_documents: List[Document]) -> float:
+        unique_truths = {g.content for g in ground_truth_documents}
+        unique_retrievals = {p.content for p in retrieved_documents}
+        retrieved_ground_truths = unique_truths.intersection(unique_retrievals)
+
+        return float(len(retrieved_ground_truths) > 0)
+
+    def _recall_multi_hit(self, ground_truth_documents: List[Document], retrieved_documents: List[Document]) -> float:
+        unique_truths = {g.content for g in ground_truth_documents}
+        unique_retrievals = {p.content for p in retrieved_documents}
+        retrieved_ground_truths = unique_truths.intersection(unique_retrievals)
+
+        return len(retrieved_ground_truths) / len(ground_truth_documents)
+
+    @component.output_types(score=float, individual_scores=List[float])
+    def run(
+        self, ground_truth_documents: List[List[Document]], retrieved_documents: List[List[Document]]
+    ) -> Dict[str, Any]:
+        """
+        Run the DocumentRecallEvaluator on the given inputs.
+
+        `ground_truth_documents` and `retrieved_documents` must have the same length.
+
+        :param ground_truth_documents:
+            A list of expected documents for each question.
+        :param retrieved_documents:
+            A list of retrieved documents for each question.
+        A dictionary with the following outputs:
+            - `score` - The average of calculated scores.
+            - `invididual_scores` - A list of numbers from 0.0 to 1.0 that represents the proportion of matching
+                documents retrieved. If the mode is `single_hit`, the individual scores are 0 or 1.
+        """
+        if len(ground_truth_documents) != len(retrieved_documents):
+            msg = "The length of ground_truth_documents and retrieved_documents must be the same."
+            raise ValueError(msg)
+
+        scores = []
+        for ground_truth, retrieved in zip(ground_truth_documents, retrieved_documents):
+            score = self.mode_function(ground_truth, retrieved)
+            scores.append(score)
+
+        return {"score": sum(scores) / len(retrieved_documents), "individual_scores": scores}
+
+    def to_dict(self) -> Dict[str, Any]:
+        """
+        Serializes the component to a dictionary.
+
+        :returns:
+            Dictionary with serialized data.
+        """
+        return default_to_dict(self, mode=str(self.mode))

testbed/deepset-ai__haystack/haystack/components/evaluators/faithfulness.py

@@ -0,0 +1,216 @@
+# SPDX-FileCopyrightText: 2022-present deepset GmbH <info@deepset.ai>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from typing import Any, Dict, List, Optional
+
+from numpy import mean as np_mean
+
+from haystack import component, default_from_dict, default_to_dict
+from haystack.components.evaluators.llm_evaluator import LLMEvaluator
+from haystack.utils import Secret, deserialize_secrets_inplace
+
+# Default examples to include in the prompt if the user does not provide any examples
+_DEFAULT_EXAMPLES = [
+    {
+        "inputs": {
+            "questions": "What is the capital of Germany and when was it founded?",
+            "contexts": ["Berlin is the capital of Germany and was founded in 1244."],
+            "predicted_answers": "The capital of Germany, Berlin, was founded in the 13th century.",
+        },
+        "outputs": {
+            "statements": ["Berlin is the capital of Germany.", "Berlin was founded in 1244."],
+            "statement_scores": [1, 1],
+        },
+    },
+    {
+        "inputs": {
+            "questions": "What is the capital of France?",
+            "contexts": ["Berlin is the capital of Germany."],
+            "predicted_answers": "Paris",
+        },
+        "outputs": {"statements": ["Paris is the capital of France."], "statement_scores": [0]},
+    },
+    {
+        "inputs": {
+            "questions": "What is the capital of Italy?",
+            "contexts": ["Rome is the capital of Italy."],
+            "predicted_answers": "Rome is the capital of Italy with more than 4 million inhabitants.",
+        },
+        "outputs": {
+            "statements": ["Rome is the capital of Italy.", "Rome has more than 4 million inhabitants."],
+            "statement_scores": [1, 0],
+        },
+    },
+]
+
+
+@component
+class FaithfulnessEvaluator(LLMEvaluator):
+    """
+    Evaluator that checks if a generated answer can be inferred from the provided contexts.
+
+    An LLM separates the answer into multiple statements and checks whether the statement can be inferred from the
+    context or not. The final score for the full answer is a number from 0.0 to 1.0. It represents the proportion of
+    statements that can be inferred from the provided contexts.
+
+    Usage example:
+    ```python
+    from haystack.components.evaluators import FaithfulnessEvaluator
+
+    questions = ["Who created the Python language?"]
+    contexts = [
+        [(
+            "Python, created by Guido van Rossum in the late 1980s, is a high-level general-purpose programming "
+            "language. Its design philosophy emphasizes code readability, and its language constructs aim to help "
+            "programmers write clear, logical code for both small and large-scale software projects."
+        )],
+    ]
+    predicted_answers = [
+        "Python is a high-level general-purpose programming language that was created by George Lucas."
+    ]
+    evaluator = FaithfulnessEvaluator()
+    result = evaluator.run(questions=questions, contexts=contexts, predicted_answers=predicted_answers)
+
+    print(result["individual_scores"])
+    # [0.5]
+    print(result["score"])
+    # 0.5
+    print(result["results"])
+    # [{'statements': ['Python is a high-level general-purpose programming language.',
+    'Python was created by George Lucas.'], 'statement_scores': [1, 0], 'score': 0.5}]
+    ```
+    """
+
+    def __init__(
+        self,
+        examples: Optional[List[Dict[str, Any]]] = None,
+        progress_bar: bool = True,
+        api: str = "openai",
+        api_key: Secret = Secret.from_env_var("OPENAI_API_KEY"),
+        api_params: Optional[Dict[str, Any]] = None,
+        raise_on_failure: bool = True,
+    ):
+        """
+        Creates an instance of FaithfulnessEvaluator.
+
+        :param examples:
+            Optional few-shot examples conforming to the expected input and output format of FaithfulnessEvaluator.
+            Default examples will be used if none are provided.
+            Each example must be a dictionary with keys "inputs" and "outputs".
+            "inputs" must be a dictionary with keys "questions", "contexts", and "predicted_answers".
+            "outputs" must be a dictionary with "statements" and "statement_scores".
+            Expected format:
+            [{
+                "inputs": {
+                    "questions": "What is the capital of Italy?", "contexts": ["Rome is the capital of Italy."],
+                    "predicted_answers": "Rome is the capital of Italy with more than 4 million inhabitants.",
+                },
+                "outputs": {
+                    "statements": ["Rome is the capital of Italy.", "Rome has more than 4 million inhabitants."],
+                    "statement_scores": [1, 0],
+                },
+            }]
+        :param progress_bar:
+            Whether to show a progress bar during the evaluation.
+        :param api:
+            The API to use for calling an LLM through a Generator.
+            Supported APIs: "openai".
+        :param api_key:
+            The API key.
+        :param api_params:
+            Parameters for an OpenAI API compatible completions call.
+        :param raise_on_failure:
+            Whether to raise an exception if the API call fails.
+
+        """
+        self.instructions = (
+            "Your task is to judge the faithfulness or groundedness of statements based "
+            "on context information. First, please extract statements from a provided "
+            "predicted answer to a question. Second, calculate a faithfulness score for each "
+            "statement made in the predicted answer. The score is 1 if the statement can be "
+            "inferred from the provided context or 0 if it cannot be inferred."
+        )
+        self.inputs = [("questions", List[str]), ("contexts", List[List[str]]), ("predicted_answers", List[str])]
+        self.outputs = ["statements", "statement_scores"]
+        self.examples = examples or _DEFAULT_EXAMPLES
+        self.api = api
+        self.api_key = api_key
+        self.api_params = api_params or {}
+
+        super(FaithfulnessEvaluator, self).__init__(
+            instructions=self.instructions,
+            inputs=self.inputs,
+            outputs=self.outputs,
+            examples=self.examples,
+            api=self.api,
+            api_key=self.api_key,
+            api_params=self.api_params,
+            raise_on_failure=raise_on_failure,
+            progress_bar=progress_bar,
+        )
+
+    @component.output_types(individual_scores=List[int], score=float, results=List[Dict[str, Any]])
+    def run(self, **inputs) -> Dict[str, Any]:
+        """
+        Run the LLM evaluator.
+
+        :param questions:
+            A list of questions.
+        :param contexts:
+            A nested list of contexts that correspond to the questions.
+        :param predicted_answers:
+            A list of predicted answers.
+        :returns:
+            A dictionary with the following outputs:
+                - `score`: Mean faithfulness score over all the provided input answers.
+                - `individual_scores`: A list of faithfulness scores for each input answer.
+                - `results`: A list of dictionaries with `statements` and `statement_scores` for each input answer.
+        """
+        result = super(FaithfulnessEvaluator, self).run(**inputs)
+
+        # calculate average statement faithfulness score per query
+        for idx, res in enumerate(result["results"]):
+            if res is None:
+                result["results"][idx] = {"statements": [], "statement_scores": [], "score": float("nan")}
+                continue
+            if not res["statements"]:
+                res["score"] = 0
+            else:
+                res["score"] = np_mean(res["statement_scores"])
+
+        # calculate average answer faithfulness score over all queries
+        result["score"] = np_mean([res["score"] for res in result["results"]])
+        result["individual_scores"] = [res["score"] for res in result["results"]]
+
+        return result
+
+    def to_dict(self) -> Dict[str, Any]:
+        """
+        Serialize this component to a dictionary.
+
+        :returns:
+            A dictionary with serialized data.
+        """
+        return default_to_dict(
+            self,
+            api=self.api,
+            api_key=self.api_key.to_dict() if self.api_key else None,
+            api_params=self.api_params,
+            examples=self.examples,
+            progress_bar=self.progress_bar,
+            raise_on_failure=self.raise_on_failure,
+        )
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "FaithfulnessEvaluator":
+        """
+        Deserialize this component from a dictionary.
+
+        :param data:
+            The dictionary representation of this component.
+        :returns:
+            The deserialized component instance.
+        """
+        deserialize_secrets_inplace(data["init_parameters"], keys=["api_key"])
+        return default_from_dict(cls, data)

testbed/deepset-ai__haystack/haystack/components/evaluators/llm_evaluator.py

@@ -0,0 +1,387 @@
+# SPDX-FileCopyrightText: 2022-present deepset GmbH <info@deepset.ai>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+import json
+from typing import Any, Dict, List, Optional, Tuple, Type
+from warnings import warn
+
+from tqdm import tqdm
+
+from haystack import component, default_from_dict, default_to_dict
+from haystack.components.builders import PromptBuilder
+from haystack.components.generators import OpenAIGenerator
+from haystack.utils import Secret, deserialize_secrets_inplace, deserialize_type, serialize_type
+
+
+@component
+class LLMEvaluator:
+    """
+    Uses an LLM to evaluate inputs based on a prompt containing instructions and examples.
+
+    The default API requires an OpenAI API key to be provided as an environment variable "OPENAI_API_KEY".
+    The inputs are lists that are user-defined depending on the desired metric.
+    The output is a dictionary with a key `results` containing a list of evaluation results.
+    Each result is a dictionary with user-defined keys and values of either 0 for FALSE or 1 for TRUE respectively.
+
+    Usage example:
+    ```python
+    from typing import List
+    from haystack.components.evaluators import LLMEvaluator
+    evaluator = LLMEvaluator(
+        instructions="Is this answer problematic for children?",
+        inputs=[("predicted_answers", List[str])],
+        outputs=["score"],
+        examples=[
+            {"inputs": {"predicted_answers": "Damn, this is straight outta hell!!!"}, "outputs": {"score": 1}},
+            {"inputs": {"predicted_answers": "Football is the most popular sport."}, "outputs": {"score": 0}},
+        ],
+    )
+    predicted_answers = [
+        "Football is the most popular sport with around 4 billion followers worldwide",
+        "Python language was created by Guido van Rossum.",
+    ]
+    results = evaluator.run(predicted_answers=predicted_answers)
+    print(results)
+    # {'results': [{'score': 0}, {'score': 0}]}
+    ```
+    """
+
+    def __init__(
+        self,
+        instructions: str,
+        inputs: List[Tuple[str, Type[List]]],
+        outputs: List[str],
+        examples: List[Dict[str, Any]],
+        progress_bar: bool = True,
+        *,
+        raise_on_failure: bool = True,
+        api: str = "openai",
+        api_key: Optional[Secret] = None,
+        api_params: Optional[Dict[str, Any]] = None,
+    ):
+        """
+        Creates an instance of LLMEvaluator.
+
+        :param instructions:
+            The prompt instructions to use for evaluation.
+            Should be a question about the inputs that can be answered with yes or no.
+        :param inputs:
+            The inputs that the component expects as incoming connections and that it evaluates.
+            Each input is a tuple of an input name and input type. Input types must be lists.
+        :param outputs:
+            Output names of the evaluation results. They correspond to keys in the output dictionary.
+        :param examples:
+            Few-shot examples conforming to the expected input and output format as defined in the `inputs` and
+             `outputs` parameters.
+            Each example is a dictionary with keys "inputs" and "outputs"
+            They contain the input and output as dictionaries respectively.
+        :param raise_on_failure:
+            If True, the component will raise an exception on an unsuccessful API call.
+        :param progress_bar:
+            Whether to show a progress bar during the evaluation.
+        :param api:
+            The API to use for calling an LLM through a Generator.
+            Supported APIs: "openai".
+        :param api_key:
+            The API key to be passed to a LLM provider. It may not be necessary when using a locally hosted model.
+        :param api_params:
+            Parameters for an OpenAI API compatible completions call.
+
+        """
+        self.validate_init_parameters(inputs, outputs, examples)
+        self.raise_on_failure = raise_on_failure
+        self.instructions = instructions
+        self.inputs = inputs
+        self.outputs = outputs
+        self.examples = examples
+        self.api = api
+        self.api_key = api_key
+        self.api_params = api_params or {}
+        self.progress_bar = progress_bar
+
+        default_generation_kwargs = {"response_format": {"type": "json_object"}, "seed": 42}
+        user_generation_kwargs = self.api_params.get("generation_kwargs", {})
+        merged_generation_kwargs = {**default_generation_kwargs, **user_generation_kwargs}
+        self.api_params["generation_kwargs"] = merged_generation_kwargs
+
+        if api == "openai":
+            generator_kwargs = {**self.api_params}
+            if api_key:
+                generator_kwargs["api_key"] = api_key
+            self.generator = OpenAIGenerator(**generator_kwargs)
+        else:
+            raise ValueError(f"Unsupported API: {api}")
+
+        template = self.prepare_template()
+        self.builder = PromptBuilder(template=template)
+
+        component.set_input_types(self, **dict(inputs))
+
+    @staticmethod
+    def validate_init_parameters(
+        inputs: List[Tuple[str, Type[List]]], outputs: List[str], examples: List[Dict[str, Any]]
+    ):
+        """
+        Validate the init parameters.
+
+        :param inputs:
+            The inputs to validate.
+        :param outputs:
+            The outputs to validate.
+        :param examples:
+            The examples to validate.
+
+        :raises ValueError:
+            If the inputs are not a list of tuples with a string and a type of list.
+            If the outputs are not a list of strings.
+            If the examples are not a list of dictionaries.
+            If any example does not have keys "inputs" and "outputs" with values that are dictionaries with string keys.
+        """
+        # Validate inputs
+        if (
+            not isinstance(inputs, list)
+            or not all(isinstance(_input, tuple) for _input in inputs)
+            or not all(isinstance(_input[0], str) and _input[1] is not list and len(_input) == 2 for _input in inputs)
+        ):
+            msg = (
+                f"LLM evaluator expects inputs to be a list of tuples. Each tuple must contain an input name and "
+                f"type of list but received {inputs}."
+            )
+            raise ValueError(msg)
+
+        # Validate outputs
+        if not isinstance(outputs, list) or not all(isinstance(output, str) for output in outputs):
+            msg = f"LLM evaluator expects outputs to be a list of str but received {outputs}."
+            raise ValueError(msg)
+
+        # Validate examples are lists of dicts
+        if not isinstance(examples, list) or not all(isinstance(example, dict) for example in examples):
+            msg = f"LLM evaluator expects examples to be a list of dictionaries but received {examples}."
+            raise ValueError(msg)
+
+        # Validate each example
+        for example in examples:
+            if (
+                {"inputs", "outputs"} != example.keys()
+                or not all(isinstance(example[param], dict) for param in ["inputs", "outputs"])
+                or not all(isinstance(key, str) for param in ["inputs", "outputs"] for key in example[param])
+            ):
+                msg = (
+                    f"LLM evaluator expects each example to have keys `inputs` and `outputs` with values that are "
+                    f"dictionaries with str keys but received {example}."
+                )
+                raise ValueError(msg)
+
+    @component.output_types(results=List[Dict[str, Any]])
+    def run(self, **inputs) -> Dict[str, Any]:
+        """
+        Run the LLM evaluator.
+
+        :param inputs:
+            The input values to evaluate. The keys are the input names and the values are lists of input values.
+        :returns:
+            A dictionary with a `results` entry that contains a list of results.
+            Each result is a dictionary containing the keys as defined in the `outputs` parameter of the LLMEvaluator
+            and the evaluation results as the values. If an exception occurs for a particular input value, the result
+            will be `None` for that entry.
+            If the API is "openai" and the response contains a "meta" key, the metadata from OpenAI will be included
+            in the output dictionary, under the key "meta".
+        :raises ValueError:
+            Only in the case that  `raise_on_failure` is set to True and the received inputs are not lists or have
+            different lengths, or if the output is not a valid JSON or doesn't contain the expected keys.
+        """
+        self.validate_input_parameters(dict(self.inputs), inputs)
+
+        # inputs is a dictionary with keys being input names and values being a list of input values
+        # We need to iterate through the lists in parallel for all keys of the dictionary
+        input_names, values = inputs.keys(), list(zip(*inputs.values()))
+        list_of_input_names_to_values = [dict(zip(input_names, v)) for v in values]
+
+        results: List[Optional[Dict[str, Any]]] = []
+        metadata = None
+        errors = 0
+        for input_names_to_values in tqdm(list_of_input_names_to_values, disable=not self.progress_bar):
+            prompt = self.builder.run(**input_names_to_values)
+            try:
+                result = self.generator.run(prompt=prompt["prompt"])
+            except Exception as e:
+                msg = f"Error while generating response for prompt: {prompt}. Error: {e}"
+                if self.raise_on_failure:
+                    raise ValueError(msg)
+                warn(msg)
+                results.append(None)
+                errors += 1
+                continue
+
+            if self.is_valid_json_and_has_expected_keys(expected=self.outputs, received=result["replies"][0]):
+                parsed_result = json.loads(result["replies"][0])
+                results.append(parsed_result)
+            else:
+                results.append(None)
+                errors += 1
+
+            if self.api == "openai" and "meta" in result:
+                metadata = result["meta"]
+
+        if errors > 0:
+            msg = f"LLM evaluator failed for {errors} out of {len(list_of_input_names_to_values)} inputs."
+            warn(msg)
+
+        return {"results": results, "meta": metadata}
+
+    def prepare_template(self) -> str:
+        """
+        Prepare the prompt template.
+
+        Combine instructions, inputs, outputs, and examples into one prompt template with the following format:
+        Instructions:
+        <instructions>
+
+        Generate the response in JSON format with the following keys:
+        <list of output keys>
+        Consider the instructions and the examples below to determine those values.
+
+        Examples:
+        <examples>
+
+        Inputs:
+        <inputs>
+        Outputs:
+
+        :returns:
+            The prompt template.
+        """
+        inputs_section = (
+            "{" + ", ".join([f'"{input_socket[0]}": {{{{ {input_socket[0]} }}}}' for input_socket in self.inputs]) + "}"
+        )
+
+        examples_section = "\n".join(
+            [
+                "Inputs:\n" + json.dumps(example["inputs"]) + "\nOutputs:\n" + json.dumps(example["outputs"])
+                for example in self.examples
+            ]
+        )
+        return (
+            f"Instructions:\n"
+            f"{self.instructions}\n\n"
+            f"Generate the response in JSON format with the following keys:\n"
+            f"{json.dumps(self.outputs)}\n"
+            f"Consider the instructions and the examples below to determine those values.\n\n"
+            f"Examples:\n"
+            f"{examples_section}\n\n"
+            f"Inputs:\n"
+            f"{inputs_section}\n"
+            f"Outputs:\n"
+        )
+
+    def to_dict(self) -> Dict[str, Any]:
+        """
+        Serialize this component to a dictionary.
+
+        :returns:
+            The serialized component as a dictionary.
+        """
+        # Since we cannot currently serialize tuples, convert the inputs to a list.
+        inputs = [[name, serialize_type(type_)] for name, type_ in self.inputs]
+        return default_to_dict(
+            self,
+            instructions=self.instructions,
+            inputs=inputs,
+            outputs=self.outputs,
+            examples=self.examples,
+            api=self.api,
+            api_key=self.api_key and self.api_key.to_dict(),
+            api_params=self.api_params,
+            progress_bar=self.progress_bar,
+        )
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "LLMEvaluator":
+        """
+        Deserialize this component from a dictionary.
+
+        :param data:
+            The dictionary representation of this component.
+        :returns:
+            The deserialized component instance.
+        """
+        data["init_parameters"]["inputs"] = [
+            (name, deserialize_type(type_)) for name, type_ in data["init_parameters"]["inputs"]
+        ]
+
+        deserialize_secrets_inplace(data["init_parameters"], keys=["api_key"])
+        return default_from_dict(cls, data)
+
+    @staticmethod
+    def validate_input_parameters(expected: Dict[str, Any], received: Dict[str, Any]) -> None:
+        """
+        Validate the input parameters.
+
+        :param expected:
+            The expected input parameters.
+        :param received:
+            The received input parameters.
+
+        :raises ValueError:
+            If not all expected inputs are present in the received inputs
+            If the received inputs are not lists or have different lengths
+        """
+        # Validate that all expected inputs are present in the received inputs
+        for param in expected.keys():
+            if param not in received:
+                msg = f"LLM evaluator expected input parameter '{param}' but received only {received.keys()}."
+                raise ValueError(msg)
+
+        # Validate that all received inputs are lists
+        if not all(isinstance(_input, list) for _input in received.values()):
+            msg = (
+                "LLM evaluator expects all input values to be lists but received "
+                f"{[type(_input) for _input in received.values()]}."
+            )
+            raise ValueError(msg)
+
+        # Validate that all received inputs are of the same length
+        inputs = received.values()
+        length = len(next(iter(inputs)))
+        if not all(len(_input) == length for _input in inputs):
+            msg = (
+                f"LLM evaluator expects all input lists to have the same length but received {inputs} with lengths "
+                f"{[len(_input) for _input in inputs]}."
+            )
+            raise ValueError(msg)
+
+    def is_valid_json_and_has_expected_keys(self, expected: List[str], received: str) -> bool:
+        """
+        Output must be a valid JSON with the expected keys.
+
+        :param expected:
+            Names of expected outputs
+        :param received:
+            Names of received outputs
+
+        :raises ValueError:
+            If the output is not a valid JSON with the expected keys:
+            - with `raise_on_failure` set to True a ValueError is raised.
+            - with `raise_on_failure` set to False a warning is issued and False is returned.
+
+        :returns:
+            True if the received output is a valid JSON with the expected keys, False otherwise.
+        """
+        try:
+            parsed_output = json.loads(received)
+        except json.JSONDecodeError:
+            msg = "Response from LLM evaluator is not a valid JSON."
+            if self.raise_on_failure:
+                raise ValueError(msg)
+            warn(msg)
+            return False
+
+        if not all(output in parsed_output for output in expected):
+            msg = f"Expected response from LLM evaluator to be JSON with keys {expected}, got {received}."
+            if self.raise_on_failure:
+                raise ValueError(msg)
+            warn(msg)
+            return False
+
+        return True

testbed/deepset-ai__haystack/haystack/components/evaluators/sas_evaluator.py

@@ -0,0 +1,201 @@
+# SPDX-FileCopyrightText: 2022-present deepset GmbH <info@deepset.ai>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from typing import Any, Dict, List, Optional
+
+from numpy import mean as np_mean
+
+from haystack import component, default_from_dict, default_to_dict
+from haystack.lazy_imports import LazyImport
+from haystack.utils import ComponentDevice, expit
+from haystack.utils.auth import Secret, deserialize_secrets_inplace
+
+with LazyImport(message="Run 'pip install \"sentence-transformers>=3.0.0\"'") as sas_import:
+    from sentence_transformers import CrossEncoder, SentenceTransformer, util
+    from transformers import AutoConfig
+
+
+@component
+class SASEvaluator:
+    """
+    SASEvaluator computes the Semantic Answer Similarity (SAS) between a list of predictions and a one of ground truths.
+
+    It's usually used in Retrieval Augmented Generation (RAG) pipelines to evaluate the quality of the generated
+    answers. The SAS is computed using a pre-trained model from the Hugging Face model hub. The model can be either a
+    Bi-Encoder or a Cross-Encoder. The choice of the model is based on the `model` parameter.
+
+    Usage example:
+    ```python
+    from haystack.components.evaluators.sas_evaluator import SASEvaluator
+
+    evaluator = SASEvaluator(model="cross-encoder/ms-marco-MiniLM-L-6-v2")
+    evaluator.warm_up()
+    ground_truths = [
+        "A construction budget of US $2.3 billion",
+        "The Eiffel Tower, completed in 1889, symbolizes Paris's cultural magnificence.",
+        "The Meiji Restoration in 1868 transformed Japan into a modernized world power.",
+    ]
+    predictions = [
+        "A construction budget of US $2.3 billion",
+        "The Eiffel Tower, completed in 1889, symbolizes Paris's cultural magnificence.",
+        "The Meiji Restoration in 1868 transformed Japan into a modernized world power.",
+    ]
+    result = evaluator.run(
+        ground_truths_answers=ground_truths, predicted_answers=predictions
+    )
+
+    print(result["score"])
+    # 0.9999673763910929
+
+    print(result["individual_scores"])
+    # [0.9999765157699585, 0.999968409538269, 0.9999572038650513]
+    ```
+    """
+
+    def __init__(
+        self,
+        model: str = "sentence-transformers/paraphrase-multilingual-mpnet-base-v2",
+        batch_size: int = 32,
+        device: Optional[ComponentDevice] = None,
+        token: Secret = Secret.from_env_var(["HF_API_TOKEN", "HF_TOKEN"], strict=False),
+    ):
+        """
+        Creates a new instance of SASEvaluator.
+
+        :param model:
+            SentenceTransformers semantic textual similarity model, should be path or string pointing to a downloadable
+            model.
+        :param batch_size:
+            Number of prediction-label pairs to encode at once.
+        :param device:
+            The device on which the model is loaded. If `None`, the default device is automatically selected.
+        :param token:
+            The Hugging Face token for HTTP bearer authorization.
+            You can find your HF token in your [account settings](https://huggingface.co/settings/tokens)
+        """
+        sas_import.check()
+
+        self._model = model
+        self._batch_size = batch_size
+        self._device = device
+        self._token = token
+        self._similarity_model = None
+
+    def to_dict(self) -> Dict[str, Any]:
+        """
+        Serialize this component to a dictionary.
+
+        :returns:
+            The serialized component as a dictionary.
+        """
+        return default_to_dict(
+            self,
+            model=self._model,
+            batch_size=self._batch_size,
+            device=self._device.to_dict() if self._device else None,
+            token=self._token.to_dict() if self._token else None,
+        )
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "SASEvaluator":
+        """
+        Deserialize this component from a dictionary.
+
+        :param data:
+            The dictionary representation of this component.
+        :returns:
+            The deserialized component instance.
+        """
+        deserialize_secrets_inplace(data["init_parameters"], keys=["token"])
+        if device := data.get("init_parameters", {}).get("device"):
+            data["init_parameters"]["device"] = ComponentDevice.from_dict(device)
+        return default_from_dict(cls, data)
+
+    def warm_up(self):
+        """
+        Initializes the component.
+        """
+        if self._similarity_model:
+            return
+
+        token = self._token.resolve_value() if self._token else None
+        config = AutoConfig.from_pretrained(self._model, use_auth_token=token)
+        cross_encoder_used = False
+        if config.architectures:
+            cross_encoder_used = any(arch.endswith("ForSequenceClassification") for arch in config.architectures)
+        device = ComponentDevice.resolve_device(self._device).to_torch_str()
+        # Based on the Model string we can load either Bi-Encoders or Cross Encoders.
+        # Similarity computation changes for both approaches
+        if cross_encoder_used:
+            self._similarity_model = CrossEncoder(
+                self._model,
+                device=device,
+                tokenizer_args={"use_auth_token": token},
+                automodel_args={"use_auth_token": token},
+            )
+        else:
+            self._similarity_model = SentenceTransformer(self._model, device=device, use_auth_token=token)
+
+    @component.output_types(score=float, individual_scores=List[float])
+    def run(self, ground_truth_answers: List[str], predicted_answers: List[str]) -> Dict[str, Any]:
+        """
+        SASEvaluator component run method.
+
+        Run the SASEvaluator to compute the Semantic Answer Similarity (SAS) between a list of predicted answers
+        and a list of ground truth answers. Both must be list of strings of same length.
+
+        :param ground_truth_answers:
+            A list of expected answers for each question.
+        :param predicted_answers:
+            A list of generated answers for each question.
+        :returns:
+            A dictionary with the following outputs:
+                - `score`: Mean SAS score over all the predictions/ground-truth pairs.
+                - `individual_scores`: A list of similarity scores for each prediction/ground-truth pair.
+        """
+        if len(ground_truth_answers) != len(predicted_answers):
+            raise ValueError("The number of predictions and labels must be the same.")
+
+        if any(answer is None for answer in predicted_answers):
+            raise ValueError("Predicted answers must not contain None values.")
+
+        if len(predicted_answers) == 0:
+            return {"score": 0.0, "individual_scores": [0.0]}
+
+        if not self._similarity_model:
+            msg = "The model has not been initialized. Call warm_up() before running the evaluator."
+            raise RuntimeError(msg)
+
+        if isinstance(self._similarity_model, CrossEncoder):
+            # For Cross Encoders we create a list of pairs of predictions and labels
+            sentence_pairs = list(zip(predicted_answers, ground_truth_answers))
+            similarity_scores = self._similarity_model.predict(
+                sentence_pairs, batch_size=self._batch_size, convert_to_numpy=True
+            )
+
+            # All Cross Encoders do not return a set of logits scores that are normalized
+            # We normalize scores if they are larger than 1
+            if (similarity_scores > 1).any():
+                similarity_scores = expit(similarity_scores)
+
+            # Convert scores to list of floats from numpy array
+            similarity_scores = similarity_scores.tolist()
+
+        else:
+            # For Bi-encoders we create embeddings separately for predictions and labels
+            predictions_embeddings = self._similarity_model.encode(
+                predicted_answers, batch_size=self._batch_size, convert_to_tensor=True
+            )
+            label_embeddings = self._similarity_model.encode(
+                ground_truth_answers, batch_size=self._batch_size, convert_to_tensor=True
+            )
+
+            # Compute cosine-similarities
+            similarity_scores = [
+                float(util.cos_sim(p, l).cpu().numpy()) for p, l in zip(predictions_embeddings, label_embeddings)
+            ]
+
+        sas_score = np_mean(similarity_scores)
+
+        return {"score": sas_score, "individual_scores": similarity_scores}

testbed/deepset-ai__haystack/haystack/components/extractors/__init__.py

@@ -0,0 +1,11 @@
+# SPDX-FileCopyrightText: 2022-present deepset GmbH <info@deepset.ai>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from haystack.components.extractors.named_entity_extractor import (
+    NamedEntityAnnotation,
+    NamedEntityExtractor,
+    NamedEntityExtractorBackend,
+)
+
+__all__ = ["NamedEntityExtractor", "NamedEntityExtractorBackend", "NamedEntityAnnotation"]

testbed/deepset-ai__haystack/haystack/components/extractors/named_entity_extractor.py

@@ -0,0 +1,485 @@
+# SPDX-FileCopyrightText: 2022-present deepset GmbH <info@deepset.ai>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from abc import ABC, abstractmethod
+from contextlib import contextmanager
+from dataclasses import dataclass
+from enum import Enum
+from typing import Any, Dict, List, Optional, Union
+
+from haystack import ComponentError, DeserializationError, Document, component, default_from_dict, default_to_dict
+from haystack.lazy_imports import LazyImport
+from haystack.utils.device import ComponentDevice
+
+with LazyImport(message="Run 'pip install \"transformers[torch]\"'") as transformers_import:
+    from transformers import AutoModelForTokenClassification, AutoTokenizer, pipeline
+    from transformers import Pipeline as HfPipeline
+
+with LazyImport(message="Run 'pip install spacy'") as spacy_import:
+    import spacy
+    from spacy import Language as SpacyPipeline
+
+
+class NamedEntityExtractorBackend(Enum):
+    """
+    NLP backend to use for Named Entity Recognition.
+    """
+
+    #: Uses an Hugging Face model and pipeline.
+    HUGGING_FACE = "hugging_face"
+
+    #: Uses a spaCy model and pipeline.
+    SPACY = "spacy"
+
+    def __str__(self):
+        return self.value
+
+    @staticmethod
+    def from_str(string: str) -> "NamedEntityExtractorBackend":
+        """
+        Convert a string to a NamedEntityExtractorBackend enum.
+        """
+        enum_map = {e.value: e for e in NamedEntityExtractorBackend}
+        mode = enum_map.get(string)
+        if mode is None:
+            msg = (
+                f"Invalid backend '{string}' for named entity extractor. "
+                f"Supported backends are: {list(enum_map.keys())}"
+            )
+            raise ComponentError(msg)
+        return mode
+
+
+@dataclass
+class NamedEntityAnnotation:
+    """
+    Describes a single NER annotation.
+
+    :param entity:
+        Entity label.
+    :param start:
+        Start index of the entity in the document.
+    :param end:
+        End index of the entity in the document.
+    :param score:
+        Score calculated by the model.
+    """
+
+    entity: str
+    start: int
+    end: int
+    score: Optional[float] = None
+
+
+@component
+class NamedEntityExtractor:
+    """
+    Annotates named entities in a collection of documents.
+
+    The component supports two backends: Hugging Face and spaCy. The
+    former can be used with any sequence classification model from the
+    [Hugging Face model hub](https://huggingface.co/models), while the
+    latter can be used with any [spaCy model](https://spacy.io/models)
+    that contains an NER component. Annotations are stored as metadata
+    in the documents.
+
+    Usage example:
+    ```python
+    from haystack import Document
+    from haystack.components.extractors.named_entity_extractor import NamedEntityExtractor
+
+    documents = [
+        Document(content="I'm Merlin, the happy pig!"),
+        Document(content="My name is Clara and I live in Berkeley, California."),
+    ]
+    extractor = NamedEntityExtractor(backend="hugging_face", model="dslim/bert-base-NER")
+    extractor.warm_up()
+    results = extractor.run(documents=documents)["documents"]
+    annotations = [NamedEntityExtractor.get_stored_annotations(doc) for doc in results]
+    print(annotations)
+    ```
+    """
+
+    _METADATA_KEY = "named_entities"
+
+    def __init__(
+        self,
+        *,
+        backend: Union[str, NamedEntityExtractorBackend],
+        model: str,
+        pipeline_kwargs: Optional[Dict[str, Any]] = None,
+        device: Optional[ComponentDevice] = None,
+    ) -> None:
+        """
+        Create a Named Entity extractor component.
+
+        :param backend:
+            Backend to use for NER.
+        :param model:
+            Name of the model or a path to the model on
+            the local disk. Dependent on the backend.
+        :param pipeline_kwargs:
+            Keyword arguments passed to the pipeline. The
+            pipeline can override these arguments. Dependent on the backend.
+        :param device:
+            The device on which the model is loaded. If `None`,
+            the default device is automatically selected. If a
+            device/device map is specified in `pipeline_kwargs`,
+            it overrides this parameter (only applicable to the
+            HuggingFace backend).
+        """
+
+        if isinstance(backend, str):
+            backend = NamedEntityExtractorBackend.from_str(backend)
+
+        self._backend: _NerBackend
+        self._warmed_up: bool = False
+        device = ComponentDevice.resolve_device(device)
+
+        if backend == NamedEntityExtractorBackend.HUGGING_FACE:
+            self._backend = _HfBackend(model_name_or_path=model, device=device, pipeline_kwargs=pipeline_kwargs)
+        elif backend == NamedEntityExtractorBackend.SPACY:
+            self._backend = _SpacyBackend(model_name_or_path=model, device=device, pipeline_kwargs=pipeline_kwargs)
+        else:
+            raise ComponentError(f"Unknown NER backend '{type(backend).__name__}' for extractor")
+
+    def warm_up(self):
+        """
+        Initialize the component.
+
+        :raises ComponentError:
+            If the backend fails to initialize successfully.
+        """
+        if self._warmed_up:
+            return
+
+        try:
+            self._backend.initialize()
+            self._warmed_up = True
+        except Exception as e:
+            raise ComponentError(
+                f"Named entity extractor with backend '{self._backend.type} failed to initialize."
+            ) from e
+
+    @component.output_types(documents=List[Document])
+    def run(self, documents: List[Document], batch_size: int = 1) -> Dict[str, Any]:
+        """
+        Annotate named entities in each document and store the annotations in the document's metadata.
+
+        :param documents:
+            Documents to process.
+        :param batch_size:
+            Batch size used for processing the documents.
+        :returns:
+            Processed documents.
+        :raises ComponentError:
+            If the backend fails to process a document.
+        """
+        if not self._warmed_up:
+            msg = "The component NamedEntityExtractor was not warmed up. Call warm_up() before running the component."
+            raise RuntimeError(msg)
+
+        texts = [doc.content if doc.content is not None else "" for doc in documents]
+        annotations = self._backend.annotate(texts, batch_size=batch_size)
+
+        if len(annotations) != len(documents):
+            raise ComponentError(
+                "NER backend did not return the correct number of annotations; "
+                f"got {len(annotations)} but expected {len(documents)}"
+            )
+
+        for doc, doc_annotations in zip(documents, annotations):
+            doc.meta[self._METADATA_KEY] = doc_annotations
+
+        return {"documents": documents}
+
+    def to_dict(self) -> Dict[str, Any]:
+        """
+        Serializes the component to a dictionary.
+
+        :returns:
+            Dictionary with serialized data.
+        """
+        return default_to_dict(
+            self,
+            backend=self._backend.type.name,
+            model=self._backend.model_name,
+            device=self._backend.device.to_dict(),
+            pipeline_kwargs=self._backend._pipeline_kwargs,
+        )
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "NamedEntityExtractor":
+        """
+        Deserializes the component from a dictionary.
+
+        :param data:
+            Dictionary to deserialize from.
+        :returns:
+            Deserialized component.
+        """
+        try:
+            init_params = data["init_parameters"]
+            if init_params.get("device") is not None:
+                init_params["device"] = ComponentDevice.from_dict(init_params["device"])
+            init_params["backend"] = NamedEntityExtractorBackend[init_params["backend"]]
+            return default_from_dict(cls, data)
+        except Exception as e:
+            raise DeserializationError(f"Couldn't deserialize {cls.__name__} instance") from e
+
+    @property
+    def initialized(self) -> bool:
+        """
+        Returns if the extractor is ready to annotate text.
+        """
+        return self._backend.initialized
+
+    @classmethod
+    def get_stored_annotations(cls, document: Document) -> Optional[List[NamedEntityAnnotation]]:
+        """
+        Returns the document's named entity annotations stored in its metadata, if any.
+
+        :param document:
+            Document whose annotations are to be fetched.
+        :returns:
+            The stored annotations.
+        """
+
+        return document.meta.get(cls._METADATA_KEY)
+
+
+class _NerBackend(ABC):
+    """
+    Base class for NER backends.
+    """
+
+    def __init__(
+        self,
+        _type: NamedEntityExtractorBackend,
+        device: ComponentDevice,
+        pipeline_kwargs: Optional[Dict[str, Any]] = None,
+    ) -> None:
+        super().__init__()
+
+        self._type = _type
+        self._device = device
+        self._pipeline_kwargs = pipeline_kwargs if pipeline_kwargs is not None else {}
+
+    @abstractmethod
+    def initialize(self):
+        """
+        Initializes the backend. This would usually entail loading models, pipelines, and so on.
+        """
+
+    @property
+    @abstractmethod
+    def initialized(self) -> bool:
+        """
+        Returns if the backend has been initialized, for example, ready to annotate text.
+        """
+
+    @abstractmethod
+    def annotate(self, texts: List[str], *, batch_size: int = 1) -> List[List[NamedEntityAnnotation]]:
+        """
+        Predict annotations for a collection of documents.
+
+        :param texts:
+            Raw texts to be annotated.
+        :param batch_size:
+            Size of text batches that are
+            passed to the model.
+        :returns:
+            NER annotations.
+        """
+
+    @property
+    @abstractmethod
+    def model_name(self) -> str:
+        """
+        Returns the model name or path on the local disk.
+        """
+
+    @property
+    def device(self) -> ComponentDevice:
+        """
+        The device on which the backend's model is loaded.
+
+        :returns:
+            The device on which the backend's model is loaded.
+        """
+        return self._device
+
+    @property
+    def type(self) -> NamedEntityExtractorBackend:
+        """
+        Returns the type of the backend.
+        """
+        return self._type
+
+
+class _HfBackend(_NerBackend):
+    """
+    Hugging Face backend for NER.
+    """
+
+    def __init__(
+        self, *, model_name_or_path: str, device: ComponentDevice, pipeline_kwargs: Optional[Dict[str, Any]] = None
+    ) -> None:
+        """
+        Construct a Hugging Face NER backend.
+
+        :param model_name_or_path:
+            Name of the model or a path to the Hugging Face
+            model on the local disk.
+        :param device:
+            The device on which the model is loaded. If `None`,
+            the default device is automatically selected.
+
+            If a device/device map is specified in `pipeline_kwargs`,
+            it overrides this parameter.
+        :param pipeline_kwargs:
+            Keyword arguments passed to the pipeline. The
+            pipeline can override these arguments.
+        """
+        super().__init__(NamedEntityExtractorBackend.HUGGING_FACE, device, pipeline_kwargs)
+
+        transformers_import.check()
+
+        self._model_name_or_path = model_name_or_path
+        self.tokenizer: Optional[AutoTokenizer] = None
+        self.model: Optional[AutoModelForTokenClassification] = None
+        self.pipeline: Optional[HfPipeline] = None
+
+    def initialize(self):
+        self.tokenizer = AutoTokenizer.from_pretrained(self._model_name_or_path)
+        self.model = AutoModelForTokenClassification.from_pretrained(self._model_name_or_path)
+
+        pipeline_params = {
+            "task": "ner",
+            "model": self.model,
+            "tokenizer": self.tokenizer,
+            "aggregation_strategy": "simple",
+        }
+        pipeline_params.update({k: v for k, v in self._pipeline_kwargs.items() if k not in pipeline_params})
+        self.device.update_hf_kwargs(pipeline_params, overwrite=False)
+        self.pipeline = pipeline(**pipeline_params)
+
+    def annotate(self, texts: List[str], *, batch_size: int = 1) -> List[List[NamedEntityAnnotation]]:
+        if not self.initialized:
+            raise ComponentError("Hugging Face NER backend was not initialized - Did you call `warm_up()`?")
+
+        assert self.pipeline is not None
+        outputs = self.pipeline(texts, batch_size=batch_size)
+        return [
+            [
+                NamedEntityAnnotation(
+                    entity=annotation["entity"] if "entity" in annotation else annotation["entity_group"],
+                    start=annotation["start"],
+                    end=annotation["end"],
+                    score=annotation["score"],
+                )
+                for annotation in annotations
+            ]
+            for annotations in outputs
+        ]
+
+    @property
+    def initialized(self) -> bool:
+        return self.tokenizer is not None and self.model is not None or self.pipeline is not None
+
+    @property
+    def model_name(self) -> str:
+        return self._model_name_or_path
+
+
+class _SpacyBackend(_NerBackend):
+    """
+    spaCy backend for NER.
+    """
+
+    def __init__(
+        self, *, model_name_or_path: str, device: ComponentDevice, pipeline_kwargs: Optional[Dict[str, Any]] = None
+    ) -> None:
+        """
+        Construct a spaCy NER backend.
+
+        :param model_name_or_path:
+            Name of the model or a path to the spaCy
+            model on the local disk.
+        :param device:
+            The device on which the model is loaded. If `None`,
+            the default device is automatically selected.
+        :param pipeline_kwargs:
+            Keyword arguments passed to the pipeline. The
+            pipeline can override these arguments.
+        """
+        super().__init__(NamedEntityExtractorBackend.SPACY, device, pipeline_kwargs)
+
+        spacy_import.check()
+
+        self._model_name_or_path = model_name_or_path
+        self.pipeline: Optional[SpacyPipeline] = None
+
+        if self.device.has_multiple_devices:
+            raise ValueError("spaCy backend for named entity extractor only supports inference on single devices")
+
+    def initialize(self):
+        # We need to initialize the model on the GPU if needed.
+        with self._select_device():
+            self.pipeline = spacy.load(self._model_name_or_path)
+
+        if not self.pipeline.has_pipe("ner"):
+            raise ComponentError(f"spaCy pipeline '{self._model_name_or_path}' does not contain an NER component")
+
+        # Disable unnecessary pipes.
+        pipes_to_keep = ("ner", "tok2vec", "transformer", "curated_transformer")
+        for name in self.pipeline.pipe_names:
+            if name not in pipes_to_keep:
+                self.pipeline.disable_pipe(name)
+
+        self._pipeline_kwargs = {k: v for k, v in self._pipeline_kwargs.items() if k not in ("texts", "batch_size")}
+
+    def annotate(self, texts: List[str], *, batch_size: int = 1) -> List[List[NamedEntityAnnotation]]:
+        if not self.initialized:
+            raise ComponentError("spaCy NER backend was not initialized - Did you call `warm_up()`?")
+
+        assert self.pipeline is not None
+        with self._select_device():
+            outputs = list(self.pipeline.pipe(texts=texts, batch_size=batch_size, **self._pipeline_kwargs))
+
+        return [
+            [
+                NamedEntityAnnotation(entity=entity.label_, start=entity.start_char, end=entity.end_char)
+                for entity in doc.ents
+            ]
+            for doc in outputs
+        ]
+
+    @property
+    def initialized(self) -> bool:
+        return self.pipeline is not None
+
+    @property
+    def model_name(self) -> str:
+        return self._model_name_or_path
+
+    @contextmanager
+    def _select_device(self):
+        """
+        Context manager used to run spaCy models on a specific GPU in a scoped manner.
+        """
+
+        # TODO: This won't restore the active device.
+        # Since there are no opaque API functions to determine
+        # the active device in spaCy/Thinc, we can't do much
+        # about it as a consumer unless we start poking into their
+        # internals.
+        device_id = self._device.to_spacy()
+        try:
+            if device_id >= 0:
+                spacy.require_gpu(device_id)
+            yield
+        finally:
+            if device_id >= 0:
+                spacy.require_cpu()

testbed/deepset-ai__haystack/haystack/components/joiners/answer_joiner.py

@@ -0,0 +1,172 @@
+# SPDX-FileCopyrightText: 2022-present deepset GmbH <info@deepset.ai>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+import itertools
+from enum import Enum
+from math import inf
+from typing import Any, Callable, Dict, List, Optional, Union
+
+from haystack import component, default_from_dict, default_to_dict, logging
+from haystack.core.component.types import Variadic
+from haystack.dataclasses.answer import ExtractedAnswer, ExtractedTableAnswer, GeneratedAnswer
+
+AnswerType = Union[GeneratedAnswer, ExtractedTableAnswer, ExtractedAnswer]
+
+logger = logging.getLogger(__name__)
+
+
+class JoinMode(Enum):
+    """
+    Enum for AnswerJoiner join modes.
+    """
+
+    CONCATENATE = "concatenate"
+
+    def __str__(self):
+        return self.value
+
+    @staticmethod
+    def from_str(string: str) -> "JoinMode":
+        """
+        Convert a string to a JoinMode enum.
+        """
+        enum_map = {e.value: e for e in JoinMode}
+        mode = enum_map.get(string)
+        if mode is None:
+            msg = f"Unknown join mode '{string}'. Supported modes in AnswerJoiner are: {list(enum_map.keys())}"
+            raise ValueError(msg)
+        return mode
+
+
+@component
+class AnswerJoiner:
+    """
+    Merges multiple lists of `Answer` objects into a single list.
+
+    Use this component to combine answers from different Generators into a single list.
+    Currently, the component supports only one join mode: `CONCATENATE`.
+    This mode concatenates multiple lists of answers into a single list.
+
+    ### Usage example
+
+    In this example, AnswerJoiner merges answers from two different Generators:
+
+    ```python
+    from haystack.components.builders import AnswerBuilder
+    from haystack.components.joiners import AnswerJoiner
+
+    from haystack.core.pipeline import Pipeline
+
+    from haystack.components.generators.chat import OpenAIChatGenerator
+    from haystack.dataclasses import ChatMessage
+
+
+    query = "What's Natural Language Processing?"
+    messages = [ChatMessage.from_system("You are a helpful, respectful and honest assistant. Be super concise."),
+                ChatMessage.from_user(query)]
+
+    pipe = Pipeline()
+    pipe.add_component("gpt-4o", OpenAIChatGenerator(model="gpt-4o"))
+    pipe.add_component("llama", OpenAIChatGenerator(model="gpt-3.5-turbo"))
+    pipe.add_component("aba", AnswerBuilder())
+    pipe.add_component("abb", AnswerBuilder())
+    pipe.add_component("joiner", AnswerJoiner())
+
+    pipe.connect("gpt-4o.replies", "aba")
+    pipe.connect("llama.replies", "abb")
+    pipe.connect("aba.answers", "joiner")
+    pipe.connect("abb.answers", "joiner")
+
+    results = pipe.run(data={"gpt-4o": {"messages": messages},
+                                "llama": {"messages": messages},
+                                "aba": {"query": query},
+                                "abb": {"query": query}})
+    ```
+    """
+
+    def __init__(
+        self,
+        join_mode: Union[str, JoinMode] = JoinMode.CONCATENATE,
+        top_k: Optional[int] = None,
+        sort_by_score: bool = False,
+    ):
+        """
+        Creates an AnswerJoiner component.
+
+        :param join_mode:
+            Specifies the join mode to use. Available modes:
+            - `concatenate`: Concatenates multiple lists of Answers into a single list.
+        :param top_k:
+            The maximum number of Answers to return.
+        :param sort_by_score:
+            If `True`, sorts the documents by score in descending order.
+            If a document has no score, it is handled as if its score is -infinity.
+        """
+        if isinstance(join_mode, str):
+            join_mode = JoinMode.from_str(join_mode)
+        join_mode_functions: Dict[JoinMode, Callable[[List[List[AnswerType]]], List[AnswerType]]] = {
+            JoinMode.CONCATENATE: self._concatenate
+        }
+        self.join_mode_function: Callable[[List[List[AnswerType]]], List[AnswerType]] = join_mode_functions[join_mode]
+        self.join_mode = join_mode
+        self.top_k = top_k
+        self.sort_by_score = sort_by_score
+
+    @component.output_types(answers=List[AnswerType])
+    def run(self, answers: Variadic[List[AnswerType]], top_k: Optional[int] = None):
+        """
+        Joins multiple lists of Answers into a single list depending on the `join_mode` parameter.
+
+        :param answers:
+            Nested list of Answers to be merged.
+
+        :param top_k:
+            The maximum number of Answers to return. Overrides the instance's `top_k` if provided.
+
+        :returns:
+            A dictionary with the following keys:
+            - `answers`: Merged list of Answers
+        """
+        answers_list = list(answers)
+        join_function = self.join_mode_function
+        output_answers: List[AnswerType] = join_function(answers_list)
+
+        if self.sort_by_score:
+            output_answers = sorted(
+                output_answers, key=lambda answer: answer.score if hasattr(answer, "score") else -inf, reverse=True
+            )
+
+        top_k = top_k or self.top_k
+        if top_k:
+            output_answers = output_answers[:top_k]
+        return {"answers": output_answers}
+
+    def _concatenate(self, answer_lists: List[List[AnswerType]]) -> List[AnswerType]:
+        """
+        Concatenate multiple lists of Answers, flattening them into a single list and sorting by score.
+
+        :param answer_lists: List of lists of Answers to be flattened.
+        """
+        return list(itertools.chain.from_iterable(answer_lists))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """
+        Serializes the component to a dictionary.
+
+        :returns:
+            Dictionary with serialized data.
+        """
+        return default_to_dict(self, join_mode=str(self.join_mode), top_k=self.top_k, sort_by_score=self.sort_by_score)
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "AnswerJoiner":
+        """
+        Deserializes the component from a dictionary.
+
+        :param data:
+            The dictionary to deserialize from.
+        :returns:
+            The deserialized component.
+        """
+        return default_from_dict(cls, data)

testbed/deepset-ai__haystack/haystack/components/joiners/branch.py

@@ -0,0 +1,141 @@
+# SPDX-FileCopyrightText: 2022-present deepset GmbH <info@deepset.ai>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from typing import Any, Dict, Type
+
+from haystack import component, default_from_dict, default_to_dict, logging
+from haystack.core.component.types import GreedyVariadic
+from haystack.utils import deserialize_type, serialize_type
+
+logger = logging.getLogger(__name__)
+
+
+@component()
+class BranchJoiner:
+    """
+    A component to join different branches of a pipeline into one single output.
+
+    `BranchJoiner` receives multiple data connections of the same type from other components and passes the first
+    value coming to its single output, possibly distributing it to various other components.
+
+    `BranchJoiner` is fundamental to close loops in a pipeline, where the two branches it joins are the ones
+    coming from the previous component and one coming back from a loop. For example, `BranchJoiner` could be used
+    to send data to a component evaluating errors. `BranchJoiner` would receive two connections, one to get the
+    original data and another one to get modified data in case there was an error. In both cases, `BranchJoiner`
+    would send (or re-send in case of a loop) data to the component evaluating errors. See "Usage example" below.
+
+    Another use case with a need for `BranchJoiner` is to reconcile multiple branches coming out of a decision
+    or Classifier component. For example, in a RAG pipeline, there might be a "query language classifier" component
+    sending the query to different retrievers, selecting one specifically according to the detected language. After the
+    retrieval step the pipeline would ideally continue with a `PromptBuilder`, and since we don't know in advance the
+    language of the query, all the retrievers should be ideally connected to the single `PromptBuilder`. Since the
+    `PromptBuilder` won't accept more than one connection in input, we would connect all the retrievers to a
+    `BranchJoiner` component and reconcile them in a single output that can be connected to the `PromptBuilder`
+    downstream.
+
+    Usage example:
+
+    ```python
+    import json
+    from typing import List
+
+    from haystack import Pipeline
+    from haystack.components.converters import OutputAdapter
+    from haystack.components.generators.chat import OpenAIChatGenerator
+    from haystack.components.joiners import BranchJoiner
+    from haystack.components.validators import JsonSchemaValidator
+    from haystack.dataclasses import ChatMessage
+
+    person_schema = {
+        "type": "object",
+        "properties": {
+            "first_name": {"type": "string", "pattern": "^[A-Z][a-z]+$"},
+            "last_name": {"type": "string", "pattern": "^[A-Z][a-z]+$"},
+            "nationality": {"type": "string", "enum": ["Italian", "Portuguese", "American"]},
+        },
+        "required": ["first_name", "last_name", "nationality"]
+    }
+
+    # Initialize a pipeline
+    pipe = Pipeline()
+
+    # Add components to the pipeline
+    pipe.add_component('joiner', BranchJoiner(List[ChatMessage]))
+    pipe.add_component('fc_llm', OpenAIChatGenerator(model="gpt-4o-mini"))
+    pipe.add_component('validator', JsonSchemaValidator(json_schema=person_schema))
+    pipe.add_component('adapter', OutputAdapter("{{chat_message}}", List[ChatMessage])),
+    # And connect them
+    pipe.connect("adapter", "joiner")
+    pipe.connect("joiner", "fc_llm")
+    pipe.connect("fc_llm.replies", "validator.messages")
+    pipe.connect("validator.validation_error", "joiner")
+
+    result = pipe.run(data={"fc_llm": {"generation_kwargs": {"response_format": {"type": "json_object"}}},
+                            "adapter": {"chat_message": [ChatMessage.from_user("Create json from Peter Parker")]}})
+
+    print(json.loads(result["validator"]["validated"][0].content))
+
+
+    >> {'first_name': 'Peter', 'last_name': 'Parker', 'nationality': 'American', 'name': 'Spider-Man', 'occupation':
+    >> 'Superhero', 'age': 23, 'location': 'New York City'}
+    ```
+
+    Note that `BranchJoiner` can manage only one data type at a time. In this case, `BranchJoiner` is created for
+    passing `List[ChatMessage]`. This determines the type of data that `BranchJoiner` will receive from the upstream
+    connected components and also the type of data that `BranchJoiner` will send through its output.
+
+    In the code example, `BranchJoiner` receives a looped back `List[ChatMessage]` from the `JsonSchemaValidator` and
+    sends it down to the `OpenAIChatGenerator` for re-generation. We can have multiple loopback connections in the
+    pipeline. In this instance, the downstream component is only one (the `OpenAIChatGenerator`), but the pipeline might
+    have more than one downstream component.
+    """
+
+    def __init__(self, type_: Type):
+        """
+        Create a `BranchJoiner` component.
+
+        :param type_: The type of data that the `BranchJoiner` will receive from the upstream connected components and
+                        distribute to the downstream connected components.
+        """
+        self.type_ = type_
+        # type_'s type can't be determined statically
+        component.set_input_types(self, value=GreedyVariadic[type_])  # type: ignore
+        component.set_output_types(self, value=type_)
+
+    def to_dict(self):
+        """
+        Serializes the component to a dictionary.
+
+        :returns:
+            Dictionary with serialized data.
+        """
+        return default_to_dict(self, type_=serialize_type(self.type_))
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "BranchJoiner":
+        """
+        Deserializes the component from a dictionary.
+
+        :param data:
+            Dictionary to deserialize from.
+        :returns:
+              Deserialized component.
+        """
+        data["init_parameters"]["type_"] = deserialize_type(data["init_parameters"]["type_"])
+        return default_from_dict(cls, data)
+
+    def run(self, **kwargs):
+        """
+        The run method of the `BranchJoiner` component.
+
+        Multiplexes the input data from the upstream connected components and distributes it to the downstream connected
+        components.
+
+        :param **kwargs: The input data. Must be of the type declared in `__init__`.
+        :return: A dictionary with the following keys:
+            - `value`: The input data.
+        """
+        if (inputs_count := len(kwargs["value"])) != 1:
+            raise ValueError(f"BranchJoiner expects only one input, but {inputs_count} were received.")
+        return {"value": kwargs["value"][0]}

testbed/deepset-ai__haystack/haystack/components/joiners/document_joiner.py

@@ -0,0 +1,264 @@
+# SPDX-FileCopyrightText: 2022-present deepset GmbH <info@deepset.ai>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+import itertools
+from collections import defaultdict
+from enum import Enum
+from math import inf
+from typing import Any, Dict, List, Optional, Union
+
+from haystack import Document, component, default_from_dict, default_to_dict, logging
+from haystack.core.component.types import Variadic
+
+logger = logging.getLogger(__name__)
+
+
+class JoinMode(Enum):
+    """
+    Enum for join mode.
+    """
+
+    CONCATENATE = "concatenate"
+    MERGE = "merge"
+    RECIPROCAL_RANK_FUSION = "reciprocal_rank_fusion"
+    DISTRIBUTION_BASED_RANK_FUSION = "distribution_based_rank_fusion"
+
+    def __str__(self):
+        return self.value
+
+    @staticmethod
+    def from_str(string: str) -> "JoinMode":
+        """
+        Convert a string to a JoinMode enum.
+        """
+        enum_map = {e.value: e for e in JoinMode}
+        mode = enum_map.get(string)
+        if mode is None:
+            msg = f"Unknown join mode '{string}'. Supported modes in DocumentJoiner are: {list(enum_map.keys())}"
+            raise ValueError(msg)
+        return mode
+
+
+@component
+class DocumentJoiner:
+    """
+    Joins multiple lists of documents into a single list.
+
+    It supports different join modes:
+    - concatenate: Keeps the highest-scored document in case of duplicates.
+    - merge: Calculates a weighted sum of scores for duplicates and merges them.
+    - reciprocal_rank_fusion: Merges and assigns scores based on reciprocal rank fusion.
+    - distribution_based_rank_fusion: Merges and assigns scores based on scores distribution in each Retriever.
+
+    ### Usage example:
+
+    ```python
+    document_store = InMemoryDocumentStore()
+    p = Pipeline()
+    p.add_component(instance=InMemoryBM25Retriever(document_store=document_store), name="bm25_retriever")
+    p.add_component(
+            instance=SentenceTransformersTextEmbedder(model="sentence-transformers/all-MiniLM-L6-v2"),
+            name="text_embedder",
+        )
+    p.add_component(instance=InMemoryEmbeddingRetriever(document_store=document_store), name="embedding_retriever")
+    p.add_component(instance=DocumentJoiner(), name="joiner")
+    p.connect("bm25_retriever", "joiner")
+    p.connect("embedding_retriever", "joiner")
+    p.connect("text_embedder", "embedding_retriever")
+    query = "What is the capital of France?"
+    p.run(data={"query": query})
+    ```
+    """
+
+    def __init__(
+        self,
+        join_mode: Union[str, JoinMode] = JoinMode.CONCATENATE,
+        weights: Optional[List[float]] = None,
+        top_k: Optional[int] = None,
+        sort_by_score: bool = True,
+    ):
+        """
+        Creates a DocumentJoiner component.
+
+        :param join_mode:
+            Specifies the join mode to use. Available modes:
+            - `concatenate`: Keeps the highest-scored document in case of duplicates.
+            - `merge`: Calculates a weighted sum of scores for duplicates and merges them.
+            - `reciprocal_rank_fusion`: Merges and assigns scores based on reciprocal rank fusion.
+            - `distribution_based_rank_fusion`: Merges and assigns scores based on scores
+            distribution in each Retriever.
+        :param weights:
+            Assign importance to each list of documents to influence how they're joined.
+            This parameter is ignored for
+            `concatenate` or `distribution_based_rank_fusion` join modes.
+            Weight for each list of documents must match the number of inputs.
+        :param top_k:
+            The maximum number of documents to return.
+        :param sort_by_score:
+            If `True`, sorts the documents by score in descending order.
+            If a document has no score, it is handled as if its score is -infinity.
+        """
+        if isinstance(join_mode, str):
+            join_mode = JoinMode.from_str(join_mode)
+        join_mode_functions = {
+            JoinMode.CONCATENATE: self._concatenate,
+            JoinMode.MERGE: self._merge,
+            JoinMode.RECIPROCAL_RANK_FUSION: self._reciprocal_rank_fusion,
+            JoinMode.DISTRIBUTION_BASED_RANK_FUSION: self._distribution_based_rank_fusion,
+        }
+        self.join_mode_function = join_mode_functions[join_mode]
+        self.join_mode = join_mode
+        self.weights = [float(i) / sum(weights) for i in weights] if weights else None
+        self.top_k = top_k
+        self.sort_by_score = sort_by_score
+
+    @component.output_types(documents=List[Document])
+    def run(self, documents: Variadic[List[Document]], top_k: Optional[int] = None):
+        """
+        Joins multiple lists of Documents into a single list depending on the `join_mode` parameter.
+
+        :param documents:
+            List of list of documents to be merged.
+        :param top_k:
+            The maximum number of documents to return. Overrides the instance's `top_k` if provided.
+
+        :returns:
+            A dictionary with the following keys:
+            - `documents`: Merged list of Documents
+        """
+        output_documents = []
+
+        documents = list(documents)
+        output_documents = self.join_mode_function(documents)
+
+        if self.sort_by_score:
+            output_documents = sorted(
+                output_documents, key=lambda doc: doc.score if doc.score is not None else -inf, reverse=True
+            )
+            if any(doc.score is None for doc in output_documents):
+                logger.info(
+                    "Some of the Documents DocumentJoiner got have score=None. It was configured to sort Documents by "
+                    "score, so those with score=None were sorted as if they had a score of -infinity."
+                )
+
+        if top_k:
+            output_documents = output_documents[:top_k]
+        elif self.top_k:
+            output_documents = output_documents[: self.top_k]
+
+        return {"documents": output_documents}
+
+    def _concatenate(self, document_lists: List[List[Document]]) -> List[Document]:
+        """
+        Concatenate multiple lists of Documents and return only the Document with the highest score for duplicates.
+        """
+        output = []
+        docs_per_id = defaultdict(list)
+        for doc in itertools.chain.from_iterable(document_lists):
+            docs_per_id[doc.id].append(doc)
+        for docs in docs_per_id.values():
+            doc_with_best_score = max(docs, key=lambda doc: doc.score if doc.score else -inf)
+            output.append(doc_with_best_score)
+        return output
+
+    def _merge(self, document_lists: List[List[Document]]) -> List[Document]:
+        """
+        Merge multiple lists of Documents and calculate a weighted sum of the scores of duplicate Documents.
+        """
+        scores_map: dict = defaultdict(int)
+        documents_map = {}
+        weights = self.weights if self.weights else [1 / len(document_lists)] * len(document_lists)
+
+        for documents, weight in zip(document_lists, weights):
+            for doc in documents:
+                scores_map[doc.id] += (doc.score if doc.score else 0) * weight
+                documents_map[doc.id] = doc
+
+        for doc in documents_map.values():
+            doc.score = scores_map[doc.id]
+
+        return list(documents_map.values())
+
+    def _reciprocal_rank_fusion(self, document_lists: List[List[Document]]) -> List[Document]:
+        """
+        Merge multiple lists of Documents and assign scores based on reciprocal rank fusion.
+
+        The constant k is set to 61 (60 was suggested by the original paper,
+        plus 1 as python lists are 0-based and the paper used 1-based ranking).
+        """
+        k = 61
+
+        scores_map: dict = defaultdict(int)
+        documents_map = {}
+        weights = self.weights if self.weights else [1 / len(document_lists)] * len(document_lists)
+
+        # Calculate weighted reciprocal rank fusion score
+        for documents, weight in zip(document_lists, weights):
+            for rank, doc in enumerate(documents):
+                scores_map[doc.id] += (weight * len(document_lists)) / (k + rank)
+                documents_map[doc.id] = doc
+
+        # Normalize scores. Note: len(results) / k is the maximum possible score,
+        # achieved by being ranked first in all doc lists with non-zero weight.
+        for _id in scores_map:
+            scores_map[_id] /= len(document_lists) / k
+
+        for doc in documents_map.values():
+            doc.score = scores_map[doc.id]
+
+        return list(documents_map.values())
+
+    def _distribution_based_rank_fusion(self, document_lists: List[List[Document]]) -> List[Document]:
+        """
+        Merge multiple lists of Documents and assign scores based on Distribution-Based Score Fusion.
+
+        (https://medium.com/plain-simple-software/distribution-based-score-fusion-dbsf-a-new-approach-to-vector-search-ranking-f87c37488b18)
+        If a Document is in more than one retriever, the one with the highest score is used.
+        """
+        for documents in document_lists:
+            scores_list = []
+
+            for doc in documents:
+                scores_list.append(doc.score if doc.score is not None else 0)
+
+            mean_score = sum(scores_list) / len(scores_list)
+            std_dev = (sum((x - mean_score) ** 2 for x in scores_list) / len(scores_list)) ** 0.5
+            min_score = mean_score - 3 * std_dev
+            max_score = mean_score + 3 * std_dev
+            delta_score = max_score - min_score
+
+            for doc in documents:
+                doc.score = (doc.score - min_score) / delta_score if delta_score != 0.0 else 0.0
+                # if all docs have the same score delta_score is 0, the docs are uninformative for the query
+
+        output = self._concatenate(document_lists=document_lists)
+
+        return output
+
+    def to_dict(self) -> Dict[str, Any]:
+        """
+        Serializes the component to a dictionary.
+
+        :returns:
+            Dictionary with serialized data.
+        """
+        return default_to_dict(
+            self,
+            join_mode=str(self.join_mode),
+            weights=self.weights,
+            top_k=self.top_k,
+            sort_by_score=self.sort_by_score,
+        )
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "DocumentJoiner":
+        """
+        Deserializes the component from a dictionary.
+
+        :param data:
+            The dictionary to deserialize from.
+        :returns:
+            The deserialized component.
+        """
+        return default_from_dict(cls, data)

testbed/deepset-ai__haystack/haystack/components/joiners/string_joiner.py

@@ -0,0 +1,59 @@
+# SPDX-FileCopyrightText: 2022-present deepset GmbH <info@deepset.ai>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from typing import List
+
+from haystack import component, logging
+from haystack.core.component.types import Variadic
+
+logger = logging.getLogger(__name__)
+
+
+@component
+class StringJoiner:
+    """
+    Component to join strings from different components to a list of strings.
+
+    ### Usage example
+
+    ```python
+    from haystack.components.joiners import StringJoiner
+    from haystack.components.builders import PromptBuilder
+    from haystack.core.pipeline import Pipeline
+
+    from haystack.components.generators.chat import OpenAIChatGenerator
+    from haystack.dataclasses import ChatMessage
+
+    string_1 = "What's Natural Language Processing?"
+    string_2 = "What is life?"
+
+    pipeline = Pipeline()
+    pipeline.add_component("prompt_builder_1", PromptBuilder("Builder 1: {{query}}"))
+    pipeline.add_component("prompt_builder_2", PromptBuilder("Builder 2: {{query}}"))
+    pipeline.add_component("string_joiner", StringJoiner())
+
+    pipeline.connect("prompt_builder_1.prompt", "string_joiner.strings")
+    pipeline.connect("prompt_builder_2.prompt", "string_joiner.strings")
+
+    print(pipeline.run(data={"prompt_builder_1": {"query": string_1}, "prompt_builder_2": {"query": string_2}}))
+
+    >> {"string_joiner": {"strings": ["Builder 1: What's Natural Language Processing?", "Builder 2: What is life?"]}}
+    ```
+    """
+
+    @component.output_types(strings=List[str])
+    def run(self, strings: Variadic[str]):
+        """
+        Joins strings into a list of strings
+
+        :param strings:
+            strings from different components
+
+        :returns:
+            A dictionary with the following keys:
+            - `strings`: Merged list of strings
+        """
+
+        out_strings = list(strings)
+        return {"strings": out_strings}

testbed/deepset-ai__haystack/haystack/components/retrievers/__init__.py

@@ -0,0 +1,10 @@
+# SPDX-FileCopyrightText: 2022-present deepset GmbH <info@deepset.ai>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from haystack.components.retrievers.filter_retriever import FilterRetriever
+from haystack.components.retrievers.in_memory.bm25_retriever import InMemoryBM25Retriever
+from haystack.components.retrievers.in_memory.embedding_retriever import InMemoryEmbeddingRetriever
+from haystack.components.retrievers.sentence_window_retriever import SentenceWindowRetriever
+
+__all__ = ["FilterRetriever", "InMemoryEmbeddingRetriever", "InMemoryBM25Retriever", "SentenceWindowRetriever"]

testbed/deepset-ai__haystack/haystack/components/retrievers/sentence_window_retriever.py

@@ -0,0 +1,197 @@
+# SPDX-FileCopyrightText: 2022-present deepset GmbH <info@deepset.ai>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from typing import Any, Dict, List, Optional
+
+from haystack import Document, component, default_from_dict, default_to_dict
+from haystack.document_stores.types import DocumentStore
+from haystack.utils import deserialize_document_store_in_init_params_inplace
+
+
+@component
+class SentenceWindowRetriever:
+    """
+    Retrieves documents adjacent to a given document in the Document Store.
+
+    During indexing, documents are broken into smaller chunks, or sentences. When you submit a query,
+    the Retriever fetches the most relevant sentence. To provide full context,
+    SentenceWindowRetriever fetches a number of neighboring sentences before and after each
+    relevant one. You can set this number with the `window_size` parameter.
+    It uses `source_id` and `doc.meta['split_id']` to locate the surrounding documents.
+
+    This component works with existing Retrievers, like BM25Retriever or
+    EmbeddingRetriever. First, use a Retriever to find documents based on a query and then use
+    SentenceWindowRetriever to get the surrounding documents for context.
+
+    The SentenceWindowRetriever is compatible with the following DocumentStores:
+    - [Astra](https://docs.haystack.deepset.ai/docs/astradocumentstore)
+    - [Elasticsearch](https://docs.haystack.deepset.ai/docs/elasticsearch-document-store)
+    - [OpenSearch](https://docs.haystack.deepset.ai/docs/opensearch-document-store)
+    - [Pgvector](https://docs.haystack.deepset.ai/docs/pgvectordocumentstore)
+    - [Pinecone](https://docs.haystack.deepset.ai/docs/pinecone-document-store)
+    - [Qdrant](https://docs.haystack.deepset.ai/docs/qdrant-document-store)
+
+    ### Usage example
+
+    ```python
+    from haystack import Document, Pipeline
+    from haystack.components.retrievers.in_memory import InMemoryBM25Retriever
+    from haystack.components.retrievers import SentenceWindowRetriever
+    from haystack.components.preprocessors import DocumentSplitter
+    from haystack.document_stores.in_memory import InMemoryDocumentStore
+
+    splitter = DocumentSplitter(split_length=10, split_overlap=5, split_by="word")
+    text = (
+            "This is a text with some words. There is a second sentence. And there is also a third sentence. "
+            "It also contains a fourth sentence. And a fifth sentence. And a sixth sentence. And a seventh sentence"
+    )
+    doc = Document(content=text)
+    docs = splitter.run([doc])
+    doc_store = InMemoryDocumentStore()
+    doc_store.write_documents(docs["documents"])
+
+
+    rag = Pipeline()
+    rag.add_component("bm25_retriever", InMemoryBM25Retriever(doc_store, top_k=1))
+    rag.add_component("sentence_window_retriever", SentenceWindowRetriever(document_store=doc_store, window_size=2))
+    rag.connect("bm25_retriever", "sentence_window_retriever")
+
+    rag.run({'bm25_retriever': {"query":"third"}})
+
+    >> {'sentence_window_retriever': {'context_windows': ['some words. There is a second sentence.
+    >> And there is also a third sentence. It also contains a fourth sentence. And a fifth sentence. And a sixth
+    >> sentence. And a'], 'context_documents': [[Document(id=..., content: 'some words. There is a second sentence.
+    >> And there is ', meta: {'source_id': '...', 'page_number': 1, 'split_id': 1, 'split_idx_start': 20,
+    >> '_split_overlap': [{'doc_id': '...', 'range': (20, 43)}, {'doc_id': '...', 'range': (0, 30)}]}),
+    >> Document(id=..., content: 'second sentence. And there is also a third sentence. It ',
+    >> meta: {'source_id': '74ea87deb38012873cf8c07e...f19d01a26a098447113e1d7b83efd30c02987114', 'page_number': 1,
+    >> 'split_id': 2, 'split_idx_start': 43, '_split_overlap': [{'doc_id': '...', 'range': (23, 53)}, {'doc_id': '...',
+    >> 'range': (0, 26)}]}), Document(id=..., content: 'also a third sentence. It also contains a fourth sentence. ',
+    >> meta: {'source_id': '...', 'page_number': 1, 'split_id': 3, 'split_idx_start': 73, '_split_overlap':
+    >> [{'doc_id': '...', 'range': (30, 56)}, {'doc_id': '...', 'range': (0, 33)}]}), Document(id=..., content:
+    >> 'also contains a fourth sentence. And a fifth sentence. And ', meta: {'source_id': '...', 'page_number': 1,
+    >> 'split_id': 4, 'split_idx_start': 99, '_split_overlap': [{'doc_id': '...', 'range': (26, 59)},
+    >> {'doc_id': '...', 'range': (0, 26)}]}), Document(id=..., content: 'And a fifth sentence. And a sixth sentence.
+    >> And a ', meta: {'source_id': '...', 'page_number': 1, 'split_id': 5, 'split_idx_start': 132,
+    >> '_split_overlap': [{'doc_id': '...', 'range': (33, 59)}, {'doc_id': '...', 'range': (0, 24)}]})]]}}}}
+    ```
+    """
+
+    def __init__(self, document_store: DocumentStore, window_size: int = 3):
+        """
+        Creates a new SentenceWindowRetriever component.
+
+        :param document_store: The Document Store to retrieve the surrounding documents from.
+        :param window_size: The number of documents to retrieve before and after the relevant one.
+                For example, `window_size: 2` fetches 2 preceding and 2 following documents.
+        """
+        if window_size < 1:
+            raise ValueError("The window_size parameter must be greater than 0.")
+
+        self.window_size = window_size
+        self.document_store = document_store
+
+    @staticmethod
+    def merge_documents_text(documents: List[Document]) -> str:
+        """
+        Merge a list of document text into a single string.
+
+        This functions concatenates the textual content of a list of documents into a single string, eliminating any
+        overlapping content.
+
+        :param documents: List of Documents to merge.
+        """
+        sorted_docs = sorted(documents, key=lambda doc: doc.meta["split_idx_start"])
+        merged_text = ""
+        last_idx_end = 0
+        for doc in sorted_docs:
+            start = doc.meta["split_idx_start"]  # start of the current content
+
+            # if the start of the current content is before the end of the last appended content, adjust it
+            start = max(start, last_idx_end)
+
+            # append the non-overlapping part to the merged text
+            merged_text += doc.content[start - doc.meta["split_idx_start"] :]  # type: ignore
+
+            # update the last end index
+            last_idx_end = doc.meta["split_idx_start"] + len(doc.content)  # type: ignore
+
+        return merged_text
+
+    def to_dict(self) -> Dict[str, Any]:
+        """
+        Serializes the component to a dictionary.
+
+        :returns:
+            Dictionary with serialized data.
+        """
+        docstore = self.document_store.to_dict()
+        return default_to_dict(self, document_store=docstore, window_size=self.window_size)
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "SentenceWindowRetriever":
+        """
+        Deserializes the component from a dictionary.
+
+        :returns:
+            Deserialized component.
+        """
+        # deserialize the document store
+        deserialize_document_store_in_init_params_inplace(data)
+
+        # deserialize the component
+        return default_from_dict(cls, data)
+
+    @component.output_types(context_windows=List[str], context_documents=List[List[Document]])
+    def run(self, retrieved_documents: List[Document], window_size: Optional[int] = None):
+        """
+        Based on the `source_id` and on the `doc.meta['split_id']` get surrounding documents from the document store.
+
+        Implements the logic behind the sentence-window technique, retrieving the surrounding documents of a given
+        document from the document store.
+
+        :param retrieved_documents: List of retrieved documents from the previous retriever.
+        :param window_size: The number of documents to retrieve before and after the relevant one. This will overwrite
+                            the `window_size` parameter set in the constructor.
+        :returns:
+            A dictionary with the following keys:
+                - `context_windows`: A list of strings, where each string represents the concatenated text from the
+                                     context window of the corresponding document in `retrieved_documents`.
+                - `context_documents`: A list of lists of `Document` objects, where each inner list contains the
+                                     documents that come from the context window for the corresponding document in
+                                     `retrieved_documents`.
+
+        """
+        window_size = window_size or self.window_size
+
+        if window_size < 1:
+            raise ValueError("The window_size parameter must be greater than 0.")
+
+        if not all("split_id" in doc.meta for doc in retrieved_documents):
+            raise ValueError("The retrieved documents must have 'split_id' in the metadata.")
+
+        if not all("source_id" in doc.meta for doc in retrieved_documents):
+            raise ValueError("The retrieved documents must have 'source_id' in the metadata.")
+
+        context_text = []
+        context_documents = []
+        for doc in retrieved_documents:
+            source_id = doc.meta["source_id"]
+            split_id = doc.meta["split_id"]
+            min_before = min(list(range(split_id - 1, split_id - window_size - 1, -1)))
+            max_after = max(list(range(split_id + 1, split_id + window_size + 1, 1)))
+            context_docs = self.document_store.filter_documents(
+                {
+                    "operator": "AND",
+                    "conditions": [
+                        {"field": "meta.source_id", "operator": "==", "value": source_id},
+                        {"field": "meta.split_id", "operator": ">=", "value": min_before},
+                        {"field": "meta.split_id", "operator": "<=", "value": max_after},
+                    ],
+                }
+            )
+            context_text.append(self.merge_documents_text(context_docs))
+            context_documents.append(context_docs)
+
+        return {"context_windows": context_text, "context_documents": context_documents}

testbed/deepset-ai__haystack/haystack/components/routers/file_type_router.py

@@ -0,0 +1,184 @@
+# SPDX-FileCopyrightText: 2022-present deepset GmbH <info@deepset.ai>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+import mimetypes
+import re
+from collections import defaultdict
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Union
+
+from haystack import component, default_from_dict, default_to_dict, logging
+from haystack.components.converters.utils import get_bytestream_from_source, normalize_metadata
+from haystack.dataclasses import ByteStream
+
+logger = logging.getLogger(__name__)
+
+
+# we add markdown because it is not added by the mimetypes module
+# see https://github.com/python/cpython/pull/17995
+CUSTOM_MIMETYPES = {".md": "text/markdown", ".markdown": "text/markdown"}
+
+
+@component
+class FileTypeRouter:
+    """
+    Categorizes files or byte streams by their MIME types, helping in context-based routing.
+
+    FileTypeRouter supports both exact MIME type matching and regex patterns.
+
+    For file paths, MIME types come from extensions, while byte streams use metadata.
+    You can use regex patterns in the `mime_types` parameter to set broad categories
+    (such as 'audio/*' or 'text/*') or specific types.
+    MIME types without regex patterns are treated as exact matches.
+
+    ### Usage example
+
+    ```python
+    from haystack.components.routers import FileTypeRouter
+    from pathlib import Path
+
+    # For exact MIME type matching
+    router = FileTypeRouter(mime_types=["text/plain", "application/pdf"])
+
+    # For flexible matching using regex, to handle all audio types
+    router_with_regex = FileTypeRouter(mime_types=[r"audio/.*", r"text/plain"])
+
+    sources = [Path("file.txt"), Path("document.pdf"), Path("song.mp3")]
+    print(router.run(sources=sources))
+    print(router_with_regex.run(sources=sources))
+
+    # Expected output:
+    # {'text/plain': [
+    #   PosixPath('file.txt')], 'application/pdf': [PosixPath('document.pdf')], 'unclassified': [PosixPath('song.mp3')
+    # ]}
+    # {'audio/.*': [
+    #   PosixPath('song.mp3')], 'text/plain': [PosixPath('file.txt')], 'unclassified': [PosixPath('document.pdf')
+    # ]}
+    ```
+    """
+
+    def __init__(self, mime_types: List[str], additional_mimetypes: Optional[Dict[str, str]] = None):
+        """
+        Initialize the FileTypeRouter component.
+
+        :param mime_types:
+            A list of MIME types or regex patterns to classify the input files or byte streams.
+            (for example: `["text/plain", "audio/x-wav", "image/jpeg"]`).
+
+        :param additional_mimetypes:
+            A dictionary containing the MIME type to add to the mimetypes package to prevent unsupported or non native
+            packages from being unclassified.
+            (for example: `{"application/vnd.openxmlformats-officedocument.wordprocessingml.document": ".docx"}`).
+        """
+        if not mime_types:
+            raise ValueError("The list of mime types cannot be empty.")
+
+        if additional_mimetypes:
+            for mime, ext in additional_mimetypes.items():
+                mimetypes.add_type(mime, ext)
+
+        self.mime_type_patterns = []
+        for mime_type in mime_types:
+            try:
+                pattern = re.compile(mime_type)
+            except re.error:
+                raise ValueError(f"Invalid regex pattern '{mime_type}'.")
+            self.mime_type_patterns.append(pattern)
+
+        # the actual output type is List[Union[Path, ByteStream]],
+        # but this would cause PipelineConnectError with Converters
+        component.set_output_types(
+            self,
+            unclassified=List[Union[str, Path, ByteStream]],
+            **{mime_type: List[Union[str, Path, ByteStream]] for mime_type in mime_types},
+        )
+        self.mime_types = mime_types
+        self._additional_mimetypes = additional_mimetypes
+
+    def to_dict(self) -> Dict[str, Any]:
+        """
+        Serializes the component to a dictionary.
+
+        :returns:
+            Dictionary with serialized data.
+        """
+        return default_to_dict(self, mime_types=self.mime_types, additional_mimetypes=self._additional_mimetypes)
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "FileTypeRouter":
+        """
+        Deserializes the component from a dictionary.
+
+        :param data:
+            The dictionary to deserialize from.
+        :returns:
+            The deserialized component.
+        """
+        return default_from_dict(cls, data)
+
+    def run(
+        self,
+        sources: List[Union[str, Path, ByteStream]],
+        meta: Optional[Union[Dict[str, Any], List[Dict[str, Any]]]] = None,
+    ) -> Dict[str, List[Union[ByteStream, Path]]]:
+        """
+        Categorize files or byte streams according to their MIME types.
+
+        :param sources:
+            A list of file paths or byte streams to categorize.
+
+        :param meta:
+            Optional metadata to attach to the sources.
+            When provided, the sources are internally converted to ByteStream objects and the metadata is added.
+            This value can be a list of dictionaries or a single dictionary.
+            If it's a single dictionary, its content is added to the metadata of all ByteStream objects.
+            If it's a list, its length must match the number of sources, as they are zipped together.
+
+        :returns: A dictionary where the keys are MIME types (or `"unclassified"`) and the values are lists of data
+            sources.
+        """
+
+        mime_types = defaultdict(list)
+        meta_list = normalize_metadata(meta=meta, sources_count=len(sources))
+
+        for source, meta_dict in zip(sources, meta_list):
+            if isinstance(source, str):
+                source = Path(source)
+
+            if isinstance(source, Path):
+                mime_type = self._get_mime_type(source)
+            elif isinstance(source, ByteStream):
+                mime_type = source.mime_type
+            else:
+                raise ValueError(f"Unsupported data source type: {type(source).__name__}")
+
+            # If we have metadata, we convert the source to ByteStream and add the metadata
+            if meta_dict:
+                source = get_bytestream_from_source(source)
+                source.meta.update(meta_dict)
+
+            matched = False
+            if mime_type:
+                for pattern in self.mime_type_patterns:
+                    if pattern.fullmatch(mime_type):
+                        mime_types[pattern.pattern].append(source)
+                        matched = True
+                        break
+            if not matched:
+                mime_types["unclassified"].append(source)
+
+        return dict(mime_types)
+
+    def _get_mime_type(self, path: Path) -> Optional[str]:
+        """
+        Get the MIME type of the provided file path.
+
+        :param path: The file path to get the MIME type for.
+
+        :returns: The MIME type of the provided file path, or `None` if the MIME type cannot be determined.
+        """
+        extension = path.suffix.lower()
+        mime_type = mimetypes.guess_type(path.as_posix())[0]
+        # lookup custom mappings if the mime type is not found
+        return CUSTOM_MIMETYPES.get(extension, mime_type)

testbed/deepset-ai__haystack/haystack/components/routers/text_language_router.py

@@ -0,0 +1,102 @@
+# SPDX-FileCopyrightText: 2022-present deepset GmbH <info@deepset.ai>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from typing import Dict, List, Optional
+
+from haystack import component, logging
+from haystack.lazy_imports import LazyImport
+
+logger = logging.getLogger(__name__)
+
+with LazyImport("Run 'pip install langdetect'") as langdetect_import:
+    import langdetect
+
+
+@component
+class TextLanguageRouter:
+    """
+    Routes text strings to different output connections based on their language.
+
+    Provide a list of languages during initialization. If the document's text doesn't match any of the
+    specified languages, the metadata value is set to "unmatched".
+    For routing documents based on their language, use the DocumentLanguageClassifier component,
+    followed by the MetaDataRouter.
+
+    ### Usage example
+
+    ```python
+    from haystack import Pipeline, Document
+    from haystack.components.routers import TextLanguageRouter
+    from haystack.document_stores.in_memory import InMemoryDocumentStore
+    from haystack.components.retrievers.in_memory import InMemoryBM25Retriever
+
+    document_store = InMemoryDocumentStore()
+    document_store.write_documents([Document(content="Elvis Presley was an American singer and actor.")])
+
+    p = Pipeline()
+    p.add_component(instance=TextLanguageRouter(languages=["en"]), name="text_language_router")
+    p.add_component(instance=InMemoryBM25Retriever(document_store=document_store), name="retriever")
+    p.connect("text_language_router.en", "retriever.query")
+
+    result = p.run({"text_language_router": {"text": "Who was Elvis Presley?"}})
+    assert result["retriever"]["documents"][0].content == "Elvis Presley was an American singer and actor."
+
+    result = p.run({"text_language_router": {"text": "ένα ελληνικό κείμενο"}})
+    assert result["text_language_router"]["unmatched"] == "ένα ελληνικό κείμενο"
+    ```
+    """
+
+    def __init__(self, languages: Optional[List[str]] = None):
+        """
+        Initialize the TextLanguageRouter component.
+
+        :param languages: A list of ISO language codes.
+            See the supported languages in [`langdetect` documentation](https://github.com/Mimino666/langdetect#languages).
+            If not specified, defaults to ["en"].
+        """
+        langdetect_import.check()
+        if not languages:
+            languages = ["en"]
+        self.languages = languages
+        component.set_output_types(self, unmatched=str, **{language: str for language in languages})
+
+    def run(self, text: str) -> Dict[str, str]:
+        """
+        Routes the text strings to different output connections based on their language.
+
+        If the document's text doesn't match any of the specified languages, the metadata value is set to "unmatched".
+
+        :param text: A text string to route.
+
+        :returns: A dictionary in which the key is the language (or `"unmatched"`),
+            and the value is the text.
+
+        :raises TypeError: If the input is not a string.
+        """
+        if not isinstance(text, str):
+            msg = (
+                "TextLanguageRouter expects a string as input. In case you want to classify a document, please use "
+                "the DocumentLanguageClassifier and MetaDataRouter."
+            )
+            raise TypeError(msg)
+
+        output: Dict[str, str] = {}
+
+        detected_language = self._detect_language(text)
+        if detected_language in self.languages:
+            output[detected_language] = text
+        else:
+            output["unmatched"] = text
+
+        return output
+
+    def _detect_language(self, text: str) -> Optional[str]:
+        try:
+            language = langdetect.detect(text)
+        except langdetect.LangDetectException as exception:
+            logger.warning("Langdetect cannot detect the language of text. Error: {error}", error=exception)
+            # Only log the text in debug mode, as it might contain sensitive information
+            logger.debug("Langdetect cannot detect the language of text: {text}", text=text)
+            language = None
+        return language

testbed/deepset-ai__haystack/haystack/components/samplers/top_p.py

@@ -0,0 +1,177 @@
+# SPDX-FileCopyrightText: 2022-present deepset GmbH <info@deepset.ai>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from typing import List, Optional, Tuple
+
+from haystack import Document, component, logging
+from haystack.lazy_imports import LazyImport
+
+logger = logging.getLogger(__name__)
+
+
+with LazyImport(message="Run 'pip install \"torch>=1.13\"'") as torch_import:
+    import torch
+
+
+@component
+class TopPSampler:
+    """
+    Implements top-p (nucleus) sampling for document filtering based on cumulative probability scores.
+
+    This component provides functionality to filter a list of documents by selecting those whose scores fall
+    within the top 'p' percent of the cumulative distribution. It is useful for focusing on high-probability
+    documents while filtering out less relevant ones based on their assigned scores.
+
+    Usage example:
+
+    ```python
+    from haystack import Document
+    from haystack.components.samplers import TopPSampler
+
+    sampler = TopPSampler(top_p=0.95, score_field="similarity_score")
+    docs = [
+        Document(content="Berlin", meta={"similarity_score": -10.6}),
+        Document(content="Belgrade", meta={"similarity_score": -8.9}),
+        Document(content="Sarajevo", meta={"similarity_score": -4.6}),
+    ]
+    output = sampler.run(documents=docs)
+    docs = output["documents"]
+    assert len(docs) == 1
+    assert docs[0].content == "Sarajevo"
+    ```
+    """
+
+    def __init__(self, top_p: float = 1.0, score_field: Optional[str] = None, min_top_k: Optional[int] = None):
+        """
+        Creates an instance of TopPSampler.
+
+        :param top_p: Float between 0 and 1 representing the cumulative probability threshold for document selection.
+            A value of 1.0 indicates no filtering (all documents are retained).
+        :param score_field: Name of the field in each document's metadata that contains the score. If None, the default
+            document score field is used.
+        :param min_top_k: If specified, the minimum number of documents to return. If the top_p selects
+            fewer documents, additional ones with the next highest scores are added to the selection.
+        """
+        torch_import.check()
+
+        self.top_p = top_p
+        if not 0 <= top_p <= 1:
+            raise ValueError(f"top_p must be between 0 and 1. Got {top_p}.")
+        self.score_field = score_field
+        self.min_top_k = min_top_k
+
+    @component.output_types(documents=List[Document])
+    def run(self, documents: List[Document], top_p: Optional[float] = None):
+        """
+        Filters documents using top-p sampling based on their scores.
+
+        If the specified top_p results in no documents being selected (especially in cases of a low top_p value), the
+        method returns the document with the highest score.
+
+        :param documents: List of Document objects to be filtered.
+        :param top_p: If specified, a float to override the cumulative probability threshold set during initialization.
+
+        :returns: A dictionary with the following key:
+            - `documents`: List of Document objects that have been selected based on the top-p sampling.
+        :raises ValueError: If the top_p value is not within the range [0, 1].
+        """
+        if not documents:
+            return {"documents": []}
+
+        top_p = top_p or self.top_p
+        if not 0 <= top_p <= 1:
+            raise ValueError(f"top_p must be between 0 and 1. Got {top_p}.")
+
+        documents_with_scores, scores = self._get_documents_and_scores(documents)
+        if len(documents_with_scores) == 0:
+            logger.warning("No documents with scores found. Returning the original documents.")
+            return {"documents": documents}
+
+        sorted_docs_with_scores = sorted(zip(documents_with_scores, scores), key=lambda x: x[1], reverse=True)
+        sorted_documents, sorted_scores = [list(t) for t in zip(*sorted_docs_with_scores)]
+
+        tensor_scores = torch.tensor(sorted_scores, dtype=torch.float32)
+        probs = torch.nn.functional.softmax(tensor_scores, dim=-1)
+        cumulative_probs = torch.cumsum(probs, dim=-1)
+
+        # Check if the cumulative probabilities are close to top_p with a 1e-6 tolerance
+        close_to_top_p = torch.isclose(cumulative_probs, torch.tensor(top_p, device=cumulative_probs.device), atol=1e-6)
+
+        # Combine the close_to_top_p with original condition using logical OR
+        condition = (cumulative_probs <= top_p) | close_to_top_p
+
+        # Find the indices with cumulative probabilities that exceed top_p
+        top_p_indices = torch.where(torch.BoolTensor(condition))[0]
+
+        # Map the selected indices back to their original indices
+        selected_docs = [sorted_documents[i.item()] for i in top_p_indices]
+
+        if self.min_top_k and len(selected_docs) < self.min_top_k:
+            selected_docs = sorted_documents[: self.min_top_k]
+
+        # If low p resulted in no documents being selected, then return at least one document
+        if len(selected_docs) == 0:
+            logger.warning(
+                "Top-p sampling with p={top_p} resulted in no documents being selected. "
+                "Returning the document with the highest score.",
+                top_p=top_p,
+            )
+            selected_docs = [sorted_documents[0]]
+
+        return {"documents": selected_docs}
+
+    @staticmethod
+    def _get_doc_score(doc: Document, score_field: Optional[str] = None) -> Optional[float]:
+        """
+        Get the score of a document.
+
+        :param doc: Document object.
+        :param score_field: Name of the field in the document's metadata that contains the score.
+            If None, the document score field is used.
+
+        :return: Score of the document.
+        """
+        if score_field:
+            score = doc.meta.get(score_field)
+        else:
+            score = doc.score
+
+        if not isinstance(score, float):
+            score = None
+        return score
+
+    def _get_documents_and_scores(self, documents: List[Document]) -> Tuple[List[Document], List[float]]:
+        """
+        Checks if documents have scores in their metadata or score field and returns the documents with scores.
+
+        :param documents: List of Documents.
+        :return: List of scores.
+        """
+        docs_with_scores = []
+        scores = []
+        docs_missing_scores = []
+        for doc in documents:
+            score = self._get_doc_score(doc=doc, score_field=self.score_field)
+            if score is None:
+                docs_missing_scores.append(doc)
+            else:
+                scores.append(score)
+                docs_with_scores.append(doc)
+
+        if len(docs_missing_scores) > 0:
+            missing_scores_docs_ids = [d.id for d in docs_missing_scores if d.id]
+            if self.score_field:
+                logger.warning(
+                    "Score field '{score_field}' not found in metadata of documents with IDs: {doc_ids}."
+                    "Make sure that all documents have a score field '{score_field_2}' in their metadata.",
+                    score_field=self.score_field,
+                    doc_ids=",".join(missing_scores_docs_ids),
+                    score_field_2=self.score_field,
+                )
+            else:
+                logger.warning(
+                    "Ensure all documents have a valid score value. These documents {doc_ids} are missing scores.",
+                    doc_ids=",".join(missing_scores_docs_ids),
+                )
+        return docs_with_scores, scores

testbed/deepset-ai__haystack/haystack/components/validators/__init__.py

@@ -0,0 +1,7 @@
+# SPDX-FileCopyrightText: 2022-present deepset GmbH <info@deepset.ai>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from haystack.components.validators.json_schema import JsonSchemaValidator
+
+__all__ = ["JsonSchemaValidator"]

testbed/deepset-ai__haystack/haystack/components/validators/json_schema.py

@@ -0,0 +1,263 @@
+# SPDX-FileCopyrightText: 2022-present deepset GmbH <info@deepset.ai>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+import json
+from typing import Any, Dict, List, Optional
+
+from haystack import component
+from haystack.dataclasses import ChatMessage
+from haystack.lazy_imports import LazyImport
+
+with LazyImport(message="Run 'pip install jsonschema'") as jsonschema_import:
+    from jsonschema import ValidationError, validate
+
+
+def is_valid_json(s: str) -> bool:
+    """
+    Check if the provided string is a valid JSON.
+
+    :param s: The string to be checked.
+    :returns: `True` if the string is a valid JSON; otherwise, `False`.
+    """
+    try:
+        json.loads(s)
+    except ValueError:
+        return False
+    return True
+
+
+@component
+class JsonSchemaValidator:
+    """
+    Validates JSON content of `ChatMessage` against a specified [JSON Schema](https://json-schema.org/).
+
+    If JSON content of a message conforms to the provided schema, the message is passed along the "validated" output.
+    If the JSON content does not conform to the schema, the message is passed along the "validation_error" output.
+    In the latter case, the error message is constructed using the provided `error_template` or a default template.
+    These error ChatMessages can be used by LLMs in Haystack 2.x recovery loops.
+
+    Usage example:
+
+    ```python
+    from typing import List
+
+    from haystack import Pipeline
+    from haystack.components.generators.chat import OpenAIChatGenerator
+    from haystack.components.joiners import BranchJoiner
+    from haystack.components.validators import JsonSchemaValidator
+    from haystack import component
+    from haystack.dataclasses import ChatMessage
+
+
+    @component
+    class MessageProducer:
+
+        @component.output_types(messages=List[ChatMessage])
+        def run(self, messages: List[ChatMessage]) -> dict:
+            return {"messages": messages}
+
+
+    p = Pipeline()
+    p.add_component("llm", OpenAIChatGenerator(model="gpt-4-1106-preview",
+                                               generation_kwargs={"response_format": {"type": "json_object"}}))
+    p.add_component("schema_validator", JsonSchemaValidator())
+    p.add_component("joiner_for_llm", BranchJoiner(List[ChatMessage]))
+    p.add_component("message_producer", MessageProducer())
+
+    p.connect("message_producer.messages", "joiner_for_llm")
+    p.connect("joiner_for_llm", "llm")
+    p.connect("llm.replies", "schema_validator.messages")
+    p.connect("schema_validator.validation_error", "joiner_for_llm")
+
+    result = p.run(data={
+        "message_producer": {
+            "messages":[ChatMessage.from_user("Generate JSON for person with name 'John' and age 30")]},
+            "schema_validator": {
+                "json_schema": {
+                    "type": "object",
+                    "properties": {"name": {"type": "string"},
+                    "age": {"type": "integer"}
+                }
+            }
+        }
+    })
+    print(result)
+    >> {'schema_validator': {'validated': [ChatMessage(content='\\n{\\n  "name": "John",\\n  "age": 30\\n}',
+    role=<ChatRole.ASSISTANT: 'assistant'>, name=None, meta={'model': 'gpt-4-1106-preview', 'index': 0,
+    'finish_reason': 'stop', 'usage': {'completion_tokens': 17, 'prompt_tokens': 20, 'total_tokens': 37}})]}}
+    ```
+    """
+
+    # Default error description template
+    default_error_template = (
+        "The following generated JSON does not conform to the provided schema.\n"
+        "Generated JSON: {failing_json}\n"
+        "Error details:\n- Message: {error_message}\n"
+        "- Error Path in JSON: {error_path}\n"
+        "- Schema Path: {error_schema_path}\n"
+        "Please match the following schema:\n"
+        "{json_schema}\n"
+        "and provide the corrected JSON content ONLY. Please do not output anything else than the raw corrected "
+        "JSON string, this is the most important part of the task. Don't use any markdown and don't add any comment."
+    )
+
+    def __init__(self, json_schema: Optional[Dict[str, Any]] = None, error_template: Optional[str] = None):
+        """
+        Initialize the JsonSchemaValidator component.
+
+        :param json_schema: A dictionary representing the [JSON schema](https://json-schema.org/) against which
+            the messages' content is validated.
+        :param error_template: A custom template string for formatting the error message in case of validation failure.
+        """
+        jsonschema_import.check()
+        self.json_schema = json_schema
+        self.error_template = error_template
+
+    @component.output_types(validated=List[ChatMessage], validation_error=List[ChatMessage])
+    def run(
+        self,
+        messages: List[ChatMessage],
+        json_schema: Optional[Dict[str, Any]] = None,
+        error_template: Optional[str] = None,
+    ) -> Dict[str, List[ChatMessage]]:
+        """
+        Validates the last of the provided messages against the specified json schema.
+
+        If it does, the message is passed along the "validated" output. If it does not, the message is passed along
+        the "validation_error" output.
+
+        :param messages: A list of ChatMessage instances to be validated. The last message in this list is the one
+            that is validated.
+        :param json_schema: A dictionary representing the [JSON schema](https://json-schema.org/)
+            against which the messages' content is validated. If not provided, the schema from the component init
+            is used.
+        :param error_template: A custom template string for formatting the error message in case of validation. If not
+            provided, the `error_template` from the component init is used.
+        :return:  A dictionary with the following keys:
+            - "validated": A list of messages if the last message is valid.
+            - "validation_error": A list of messages if the last message is invalid.
+        :raises ValueError: If no JSON schema is provided or if the message content is not a dictionary or a list of
+            dictionaries.
+        """
+        last_message = messages[-1]
+        if not is_valid_json(last_message.content):
+            return {
+                "validation_error": [
+                    ChatMessage.from_user(
+                        f"The message '{last_message.content}' is not a valid JSON object. "
+                        f"Please provide only a valid JSON object in string format."
+                        f"Don't use any markdown and don't add any comment."
+                    )
+                ]
+            }
+
+        last_message_content = json.loads(last_message.content)
+        json_schema = json_schema or self.json_schema
+        error_template = error_template or self.error_template or self.default_error_template
+
+        if not json_schema:
+            raise ValueError("Provide a JSON schema for validation either in the run method or in the component init.")
+        # fc payload is json object but subtree `parameters` is string - we need to convert to json object
+        # we need complete json to validate it against schema
+        last_message_json = self._recursive_json_to_object(last_message_content)
+        using_openai_schema: bool = self._is_openai_function_calling_schema(json_schema)
+        if using_openai_schema:
+            validation_schema = json_schema["parameters"]
+        else:
+            validation_schema = json_schema
+        try:
+            last_message_json = [last_message_json] if not isinstance(last_message_json, list) else last_message_json
+            for content in last_message_json:
+                if using_openai_schema:
+                    validate(instance=content["function"]["arguments"], schema=validation_schema)
+                else:
+                    validate(instance=content, schema=validation_schema)
+
+            return {"validated": [last_message]}
+        except ValidationError as e:
+            error_path = " -> ".join(map(str, e.absolute_path)) if e.absolute_path else "N/A"
+            error_schema_path = " -> ".join(map(str, e.absolute_schema_path)) if e.absolute_schema_path else "N/A"
+
+            error_template = error_template or self.default_error_template
+
+            recovery_prompt = self._construct_error_recovery_message(
+                error_template,
+                str(e),
+                error_path,
+                error_schema_path,
+                validation_schema,
+                failing_json=last_message.content,
+            )
+            return {"validation_error": [ChatMessage.from_user(recovery_prompt)]}
+
+    def _construct_error_recovery_message(
+        self,
+        error_template: str,
+        error_message: str,
+        error_path: str,
+        error_schema_path: str,
+        json_schema: Dict[str, Any],
+        failing_json: str,
+    ) -> str:
+        """
+        Constructs an error recovery message using a specified template or the default one if none is provided.
+
+        :param error_template: A custom template string for formatting the error message in case of validation failure.
+        :param error_message: The error message returned by the JSON schema validator.
+        :param error_path: The path in the JSON content where the error occurred.
+        :param error_schema_path: The path in the JSON schema where the error occurred.
+        :param json_schema: The JSON schema against which the content is validated.
+        :param failing_json: The generated invalid JSON string.
+        """
+        error_template = error_template or self.default_error_template
+
+        return error_template.format(
+            error_message=error_message,
+            error_path=error_path,
+            error_schema_path=error_schema_path,
+            json_schema=json_schema,
+            failing_json=failing_json,
+        )
+
+    def _is_openai_function_calling_schema(self, json_schema: Dict[str, Any]) -> bool:
+        """
+        Checks if the provided schema is a valid OpenAI function calling schema.
+
+        :param json_schema: The JSON schema to check
+        :return: `True` if the schema is a valid OpenAI function calling schema; otherwise, `False`.
+        """
+        return all(key in json_schema for key in ["name", "description", "parameters"])
+
+    def _recursive_json_to_object(self, data: Any) -> Any:
+        """
+        Convert any string values that are valid JSON objects into dictionary objects.
+
+        Returns a new data structure.
+
+        :param data: The data structure to be traversed.
+        :return: A new data structure with JSON strings converted to dictionary objects.
+        """
+        if isinstance(data, list):
+            return [self._recursive_json_to_object(item) for item in data]
+
+        if isinstance(data, dict):
+            new_dict = {}
+            for key, value in data.items():
+                if isinstance(value, str):
+                    try:
+                        json_value = json.loads(value)
+                        if isinstance(json_value, (dict, list)):
+                            new_dict[key] = self._recursive_json_to_object(json_value)
+                        else:
+                            new_dict[key] = value  # Preserve the original string value
+                    except json.JSONDecodeError:
+                        new_dict[key] = value
+                elif isinstance(value, dict):
+                    new_dict[key] = self._recursive_json_to_object(value)
+                else:
+                    new_dict[key] = value
+            return new_dict
+
+        # If it's neither a list nor a dictionary, return the value directly
+        raise ValueError("Input must be a dictionary or a list of dictionaries.")

testbed/deepset-ai__haystack/haystack/components/websearch/__init__.py

@@ -0,0 +1,8 @@
+# SPDX-FileCopyrightText: 2022-present deepset GmbH <info@deepset.ai>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from haystack.components.websearch.searchapi import SearchApiWebSearch
+from haystack.components.websearch.serper_dev import SerperDevWebSearch
+
+__all__ = ["SerperDevWebSearch", "SearchApiWebSearch"]

testbed/deepset-ai__haystack/haystack/components/websearch/searchapi.py

@@ -0,0 +1,179 @@
+# SPDX-FileCopyrightText: 2022-present deepset GmbH <info@deepset.ai>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from typing import Any, Dict, List, Optional, Union
+
+import requests
+
+from haystack import ComponentError, Document, component, default_from_dict, default_to_dict, logging
+from haystack.utils import Secret, deserialize_secrets_inplace
+
+logger = logging.getLogger(__name__)
+
+
+SEARCHAPI_BASE_URL = "https://www.searchapi.io/api/v1/search"
+
+
+class SearchApiError(ComponentError): ...
+
+
+@component
+class SearchApiWebSearch:
+    """
+    Uses [SearchApi](https://www.searchapi.io/) to search the web for relevant documents.
+
+    Usage example:
+    ```python
+    from haystack.components.websearch import SearchApiWebSearch
+    from haystack.utils import Secret
+
+    websearch = SearchApiWebSearch(top_k=10, api_key=Secret.from_token("test-api-key"))
+    results = websearch.run(query="Who is the boyfriend of Olivia Wilde?")
+
+    assert results["documents"]
+    assert results["links"]
+    ```
+    """
+
+    def __init__(
+        self,
+        api_key: Secret = Secret.from_env_var("SEARCHAPI_API_KEY"),
+        top_k: Optional[int] = 10,
+        allowed_domains: Optional[List[str]] = None,
+        search_params: Optional[Dict[str, Any]] = None,
+    ):
+        """
+        Initialize the SearchApiWebSearch component.
+
+        :param api_key: API key for the SearchApi API
+        :param top_k: Number of documents to return.
+        :param allowed_domains: List of domains to limit the search to.
+        :param search_params: Additional parameters passed to the SearchApi API.
+            For example, you can set 'num' to 100 to increase the number of search results.
+            See the [SearchApi website](https://www.searchapi.io/) for more details.
+
+            The default search engine is Google, however, users can change it by setting the `engine`
+            parameter in the `search_params`.
+        """
+
+        self.api_key = api_key
+        self.top_k = top_k
+        self.allowed_domains = allowed_domains
+        self.search_params = search_params or {}
+        if "engine" not in self.search_params:
+            self.search_params["engine"] = "google"
+
+        # Ensure that the API key is resolved.
+        _ = self.api_key.resolve_value()
+
+    def to_dict(self) -> Dict[str, Any]:
+        """
+        Serializes the component to a dictionary.
+
+        :returns:
+              Dictionary with serialized data.
+        """
+        return default_to_dict(
+            self,
+            top_k=self.top_k,
+            allowed_domains=self.allowed_domains,
+            search_params=self.search_params,
+            api_key=self.api_key.to_dict(),
+        )
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "SearchApiWebSearch":
+        """
+        Deserializes the component from a dictionary.
+
+        :param data:
+            The dictionary to deserialize from.
+        :returns:
+                The deserialized component.
+        """
+        deserialize_secrets_inplace(data["init_parameters"], keys=["api_key"])
+        return default_from_dict(cls, data)
+
+    @component.output_types(documents=List[Document], links=List[str])
+    def run(self, query: str) -> Dict[str, Union[List[Document], List[str]]]:
+        """
+        Uses [SearchApi](https://www.searchapi.io/) to search the web.
+
+        :param query: Search query.
+        :returns: A dictionary with the following keys:
+            - "documents": List of documents returned by the search engine.
+            - "links": List of links returned by the search engine.
+        :raises TimeoutError: If the request to the SearchApi API times out.
+        :raises SearchApiError: If an error occurs while querying the SearchApi API.
+        """
+        query_prepend = "OR ".join(f"site:{domain} " for domain in self.allowed_domains) if self.allowed_domains else ""
+        payload = {"q": query_prepend + " " + query, **self.search_params}
+        headers = {"Authorization": f"Bearer {self.api_key.resolve_value()}", "X-SearchApi-Source": "Haystack"}
+        try:
+            response = requests.get(SEARCHAPI_BASE_URL, headers=headers, params=payload, timeout=90)
+            response.raise_for_status()  # Will raise an HTTPError for bad responses
+        except requests.Timeout as error:
+            raise TimeoutError(f"Request to {self.__class__.__name__} timed out.") from error
+
+        except requests.RequestException as e:
+            raise SearchApiError(f"An error occurred while querying {self.__class__.__name__}. Error: {e}") from e
+
+        # Request succeeded
+        json_result = response.json()
+
+        # organic results are the main results from the search engine
+        organic_results = []
+        if "organic_results" in json_result:
+            for result in json_result["organic_results"]:
+                organic_results.append(
+                    Document.from_dict({"title": result["title"], "content": result["snippet"], "link": result["link"]})
+                )
+
+        # answer box has a direct answer to the query
+        answer_box = []
+        if "answer_box" in json_result:
+            answer_box = [
+                Document.from_dict(
+                    {
+                        "title": json_result["answer_box"].get("title", ""),
+                        "content": json_result["answer_box"].get("answer", ""),
+                        "link": json_result["answer_box"].get("link", ""),
+                    }
+                )
+            ]
+
+        knowledge_graph = []
+        if "knowledge_graph" in json_result:
+            knowledge_graph = [
+                Document.from_dict(
+                    {
+                        "title": json_result["knowledge_graph"].get("title", ""),
+                        "content": json_result["knowledge_graph"].get("description", ""),
+                    }
+                )
+            ]
+
+        related_questions = []
+        if "related_questions" in json_result:
+            for result in json_result["related_questions"]:
+                related_questions.append(
+                    Document.from_dict(
+                        {
+                            "title": result["question"],
+                            "content": result["answer"] if result.get("answer") else result.get("answer_highlight", ""),
+                            "link": result.get("source", {}).get("link", ""),
+                        }
+                    )
+                )
+
+        documents = answer_box + knowledge_graph + organic_results + related_questions
+
+        links = [result["link"] for result in json_result["organic_results"]]
+
+        logger.debug(
+            "SearchApi returned {number_documents} documents for the query '{query}'",
+            number_documents=len(documents),
+            query=query,
+        )
+        return {"documents": documents[: self.top_k], "links": links[: self.top_k]}

testbed/deepset-ai__haystack/haystack/components/writers/__init__.py

@@ -0,0 +1,7 @@
+# SPDX-FileCopyrightText: 2022-present deepset GmbH <info@deepset.ai>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from haystack.components.writers.document_writer import DocumentWriter
+
+__all__ = ["DocumentWriter"]

testbed/deepset-ai__haystack/haystack/components/writers/document_writer.py

@@ -0,0 +1,102 @@
+# SPDX-FileCopyrightText: 2022-present deepset GmbH <info@deepset.ai>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from typing import Any, Dict, List, Optional
+
+from haystack import Document, component, default_from_dict, default_to_dict, logging
+from haystack.document_stores.types import DocumentStore, DuplicatePolicy
+from haystack.utils import deserialize_document_store_in_init_params_inplace
+
+logger = logging.getLogger(__name__)
+
+
+@component
+class DocumentWriter:
+    """
+    Writes documents to a DocumentStore.
+
+    ### Usage example
+    ```python
+    from haystack import Document
+    from haystack.components.writers import DocumentWriter
+    from haystack.document_stores.in_memory import InMemoryDocumentStore
+    docs = [
+        Document(content="Python is a popular programming language"),
+    ]
+    doc_store = InMemoryDocumentStore()
+    doc_store.write_documents(docs)
+    ```
+    """
+
+    def __init__(self, document_store: DocumentStore, policy: DuplicatePolicy = DuplicatePolicy.NONE):
+        """
+        Create a DocumentWriter component.
+
+        :param document_store:
+            The instance of the document store where you want to store your documents.
+        :param policy:
+            The policy to apply when a Document with the same ID already exists in the DocumentStore.
+            - `DuplicatePolicy.NONE`: Default policy, relies on the DocumentStore settings.
+            - `DuplicatePolicy.SKIP`: Skips documents with the same ID and doesn't write them to the DocumentStore.
+            - `DuplicatePolicy.OVERWRITE`: Overwrites documents with the same ID.
+            - `DuplicatePolicy.FAIL`: Raises an error if a Document with the same ID is already in the DocumentStore.
+        """
+        self.document_store = document_store
+        self.policy = policy
+
+    def _get_telemetry_data(self) -> Dict[str, Any]:
+        """
+        Data that is sent to Posthog for usage analytics.
+        """
+        return {"document_store": type(self.document_store).__name__}
+
+    def to_dict(self) -> Dict[str, Any]:
+        """
+        Serializes the component to a dictionary.
+
+        :returns:
+            Dictionary with serialized data.
+        """
+        return default_to_dict(self, document_store=self.document_store.to_dict(), policy=self.policy.name)
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "DocumentWriter":
+        """
+        Deserializes the component from a dictionary.
+
+        :param data:
+            The dictionary to deserialize from.
+        :returns:
+            The deserialized component.
+
+        :raises DeserializationError:
+            If the document store is not properly specified in the serialization data or its type cannot be imported.
+        """
+        # deserialize the document store
+        deserialize_document_store_in_init_params_inplace(data)
+
+        data["init_parameters"]["policy"] = DuplicatePolicy[data["init_parameters"]["policy"]]
+
+        return default_from_dict(cls, data)
+
+    @component.output_types(documents_written=int)
+    def run(self, documents: List[Document], policy: Optional[DuplicatePolicy] = None):
+        """
+        Run the DocumentWriter on the given input data.
+
+        :param documents:
+            A list of documents to write to the document store.
+        :param policy:
+            The policy to use when encountering duplicate documents.
+        :returns:
+            Number of documents written to the document store.
+
+        :raises ValueError:
+            If the specified document store is not found.
+        """
+        if policy is None:
+            policy = self.policy
+
+        documents_written = self.document_store.write_documents(documents=documents, policy=policy)
+        return {"documents_written": documents_written}

testbed/deepset-ai__haystack/haystack/core/__init__.py

@@ -0,0 +1,3 @@
+# SPDX-FileCopyrightText: 2022-present deepset GmbH <info@deepset.ai>
+#
+# SPDX-License-Identifier: Apache-2.0

testbed/deepset-ai__haystack/haystack/core/component/__init__.py

@@ -0,0 +1,8 @@
+# SPDX-FileCopyrightText: 2022-present deepset GmbH <info@deepset.ai>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from haystack.core.component.component import Component, component
+from haystack.core.component.types import InputSocket, OutputSocket
+
+__all__ = ["component", "Component", "InputSocket", "OutputSocket"]

testbed/deepset-ai__haystack/haystack/core/component/component.py

@@ -0,0 +1,560 @@
+# SPDX-FileCopyrightText: 2022-present deepset GmbH <info@deepset.ai>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+"""
+Attributes:
+
+    component: Marks a class as a component. Any class decorated with `@component` can be used by a Pipeline.
+
+All components must follow the contract below. This docstring is the source of truth for components contract.
+
+<hr>
+
+`@component` decorator
+
+All component classes must be decorated with the `@component` decorator. This allows Canals to discover them.
+
+<hr>
+
+`__init__(self, **kwargs)`
+
+Optional method.
+
+Components may have an `__init__` method where they define:
+
+- `self.init_parameters = {same parameters that the __init__ method received}`:
+    In this dictionary you can store any state the components wish to be persisted when they are saved.
+    These values will be given to the `__init__` method of a new instance when the pipeline is loaded.
+    Note that by default the `@component` decorator saves the arguments automatically.
+    However, if a component sets their own `init_parameters` manually in `__init__()`, that will be used instead.
+    Note: all of the values contained here **must be JSON serializable**. Serialize them manually if needed.
+
+Components should take only "basic" Python types as parameters of their `__init__` function, or iterables and
+dictionaries containing only such values. Anything else (objects, functions, etc) will raise an exception at init
+time. If there's the need for such values, consider serializing them to a string.
+
+_(TODO explain how to use classes and functions in init. In the meantime see `test/components/test_accumulate.py`)_
+
+The `__init__` must be extremely lightweight, because it's a frequent operation during the construction and
+validation of the pipeline. If a component has some heavy state to initialize (models, backends, etc...) refer to
+the `warm_up()` method.
+
+<hr>
+
+`warm_up(self)`
+
+Optional method.
+
+This method is called by Pipeline before the graph execution. Make sure to avoid double-initializations,
+because Pipeline will not keep track of which components it called `warm_up()` on.
+
+<hr>
+
+`run(self, data)`
+
+Mandatory method.
+
+This is the method where the main functionality of the component should be carried out. It's called by
+`Pipeline.run()`.
+
+When the component should run, Pipeline will call this method with an instance of the dataclass returned by the
+method decorated with `@component.input`. This dataclass contains:
+
+- all the input values coming from other components connected to it,
+- if any is missing, the corresponding value defined in `self.defaults`, if it exists.
+
+`run()` must return a single instance of the dataclass declared through the method decorated with
+`@component.output`.
+
+"""
+
+import inspect
+import sys
+import warnings
+from collections.abc import Callable
+from contextlib import contextmanager
+from contextvars import ContextVar
+from copy import deepcopy
+from dataclasses import dataclass
+from types import new_class
+from typing import Any, Dict, Optional, Protocol, Type, runtime_checkable
+
+from haystack import logging
+from haystack.core.errors import ComponentError
+
+from .sockets import Sockets
+from .types import InputSocket, OutputSocket, _empty
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class PreInitHookPayload:
+    """
+    Payload for the hook called before a component instance is initialized.
+
+    :param callback:
+        Receives the following inputs: component class and init parameter keyword args.
+    :param in_progress:
+        Flag to indicate if the hook is currently being executed.
+        Used to prevent it from being called recursively (if the component's constructor
+        instantiates another component).
+    """
+
+    callback: Callable
+    in_progress: bool = False
+
+
+_COMPONENT_PRE_INIT_HOOK: ContextVar[Optional[PreInitHookPayload]] = ContextVar("component_pre_init_hook", default=None)
+
+
+@contextmanager
+def _hook_component_init(callback: Callable):
+    """
+    Context manager to set a callback that will be invoked before a component's constructor is called.
+
+    The callback receives the component class and the init parameters (as keyword arguments) and can modify the init
+    parameters in place.
+
+    :param callback:
+        Callback function to invoke.
+    """
+    token = _COMPONENT_PRE_INIT_HOOK.set(PreInitHookPayload(callback))
+    try:
+        yield
+    finally:
+        _COMPONENT_PRE_INIT_HOOK.reset(token)
+
+
+@runtime_checkable
+class Component(Protocol):
+    """
+    Note this is only used by type checking tools.
+
+    In order to implement the `Component` protocol, custom components need to
+    have a `run` method. The signature of the method and its return value
+    won't be checked, i.e. classes with the following methods:
+
+        def run(self, param: str) -> Dict[str, Any]:
+            ...
+
+    and
+
+        def run(self, **kwargs):
+            ...
+
+    will be both considered as respecting the protocol. This makes the type
+    checking much weaker, but we have other places where we ensure code is
+    dealing with actual Components.
+
+    The protocol is runtime checkable so it'll be possible to assert:
+
+        isinstance(MyComponent, Component)
+    """
+
+    # This is the most reliable way to define the protocol for the `run` method.
+    # Defining a method doesn't work as different Components will have different
+    # arguments. Even defining here a method with `**kwargs` doesn't work as the
+    # expected signature must be identical.
+    # This makes most Language Servers and type checkers happy and shows less errors.
+    # NOTE: This check can be removed when we drop Python 3.8 support.
+    if sys.version_info >= (3, 9):
+        run: Callable[..., Dict[str, Any]]
+    else:
+        run: Callable
+
+
+class ComponentMeta(type):
+    @staticmethod
+    def _positional_to_kwargs(cls_type, args) -> Dict[str, Any]:
+        """
+        Convert positional arguments to keyword arguments based on the signature of the `__init__` method.
+        """
+        init_signature = inspect.signature(cls_type.__init__)
+        init_params = {name: info for name, info in init_signature.parameters.items() if name != "self"}
+
+        out = {}
+        for arg, (name, info) in zip(args, init_params.items()):
+            if info.kind == inspect.Parameter.VAR_POSITIONAL:
+                raise ComponentError(
+                    "Pre-init hooks do not support components with variadic positional args in their init method"
+                )
+
+            assert info.kind in (inspect.Parameter.POSITIONAL_OR_KEYWORD, inspect.Parameter.POSITIONAL_ONLY)
+            out[name] = arg
+        return out
+
+    @staticmethod
+    def _parse_and_set_output_sockets(instance: Any):
+        has_async_run = hasattr(instance, "run_async")
+
+        # If `component.set_output_types()` was called in the component constructor,
+        # `__haystack_output__` is already populated, no need to do anything.
+        if not hasattr(instance, "__haystack_output__"):
+            # If that's not the case, we need to populate `__haystack_output__`
+            #
+            # If either of the run methods were decorated, they'll have a field assigned that
+            # stores the output specification. If both run methods were decorated, we ensure that
+            # outputs are the same. We deepcopy the content of the cache to transfer ownership from
+            # the class method to the actual instance, so that different instances of the same class
+            # won't share this data.
+
+            run_output_types = getattr(instance.run, "_output_types_cache", {})
+            async_run_output_types = getattr(instance.run_async, "_output_types_cache", {}) if has_async_run else {}
+
+            if has_async_run and run_output_types != async_run_output_types:
+                raise ComponentError("Output type specifications of 'run' and 'run_async' methods must be the same")
+            output_types_cache = run_output_types
+
+            instance.__haystack_output__ = Sockets(instance, deepcopy(output_types_cache), OutputSocket)
+
+    @staticmethod
+    def _parse_and_set_input_sockets(component_cls: Type, instance: Any):
+        def inner(method, sockets):
+            from inspect import Parameter
+
+            run_signature = inspect.signature(method)
+
+            for param_name, param_info in run_signature.parameters.items():
+                if param_name == "self" or param_info.kind in (Parameter.VAR_POSITIONAL, Parameter.VAR_KEYWORD):
+                    continue
+
+                socket_kwargs = {"name": param_name, "type": param_info.annotation}
+                if param_info.default != Parameter.empty:
+                    socket_kwargs["default_value"] = param_info.default
+
+                new_socket = InputSocket(**socket_kwargs)
+
+                # Also ensure that new sockets don't override existing ones.
+                existing_socket = sockets.get(param_name)
+                if existing_socket is not None and existing_socket != new_socket:
+                    raise ComponentError(
+                        "set_input_types()/set_input_type() cannot override the parameters of the 'run' method"
+                    )
+
+                sockets[param_name] = new_socket
+
+            return run_signature
+
+        # Create the sockets if set_input_types() wasn't called in the constructor.
+        if not hasattr(instance, "__haystack_input__"):
+            instance.__haystack_input__ = Sockets(instance, {}, InputSocket)
+
+        inner(getattr(component_cls, "run"), instance.__haystack_input__)
+
+        # Ensure that the sockets are the same for the async method, if it exists.
+        async_run = getattr(component_cls, "run_async", None)
+        if async_run is not None:
+            run_sockets = Sockets(instance, {}, InputSocket)
+            async_run_sockets = Sockets(instance, {}, InputSocket)
+
+            # Can't use the sockets from above as they might contain
+            # values set with set_input_types().
+            run_sig = inner(getattr(component_cls, "run"), run_sockets)
+            async_run_sig = inner(async_run, async_run_sockets)
+
+            if async_run_sockets != run_sockets or run_sig != async_run_sig:
+                raise ComponentError("Parameters of 'run' and 'run_async' methods must be the same")
+
+    def __call__(cls, *args, **kwargs):
+        """
+        This method is called when clients instantiate a Component and runs before __new__ and __init__.
+        """
+        # This will call __new__ then __init__, giving us back the Component instance
+        pre_init_hook = _COMPONENT_PRE_INIT_HOOK.get()
+        if pre_init_hook is None or pre_init_hook.in_progress:
+            instance = super().__call__(*args, **kwargs)
+        else:
+            try:
+                pre_init_hook.in_progress = True
+                named_positional_args = ComponentMeta._positional_to_kwargs(cls, args)
+                assert (
+                    set(named_positional_args.keys()).intersection(kwargs.keys()) == set()
+                ), "positional and keyword arguments overlap"
+                kwargs.update(named_positional_args)
+                pre_init_hook.callback(cls, kwargs)
+                instance = super().__call__(**kwargs)
+            finally:
+                pre_init_hook.in_progress = False
+
+        # Before returning, we have the chance to modify the newly created
+        # Component instance, so we take the chance and set up the I/O sockets
+        has_async_run = hasattr(instance, "run_async")
+        if has_async_run and not inspect.iscoroutinefunction(instance.run_async):
+            raise ComponentError(f"Method 'run_async' of component '{cls.__name__}' must be a coroutine")
+        instance.__haystack_supports_async__ = has_async_run
+
+        ComponentMeta._parse_and_set_input_sockets(cls, instance)
+        ComponentMeta._parse_and_set_output_sockets(instance)
+
+        # Since a Component can't be used in multiple Pipelines at the same time
+        # we need to know if it's already owned by a Pipeline when adding it to one.
+        # We use this flag to check that.
+        instance.__haystack_added_to_pipeline__ = None
+
+        return instance
+
+
+def _component_repr(component: Component) -> str:
+    """
+    All Components override their __repr__ method with this one.
+
+    It prints the component name and the input/output sockets.
+    """
+    result = object.__repr__(component)
+    if pipeline := getattr(component, "__haystack_added_to_pipeline__", None):
+        # This Component has been added in a Pipeline, let's get the name from there.
+        result += f"\n{pipeline.get_component_name(component)}"
+
+    # We're explicitly ignoring the type here because we're sure that the component
+    # has the __haystack_input__ and __haystack_output__ attributes at this point
+    return (
+        f'{result}\n{getattr(component, "__haystack_input__", "<invalid_input_sockets>")}'
+        f'\n{getattr(component, "__haystack_output__", "<invalid_output_sockets>")}'
+    )
+
+
+def _component_run_has_kwargs(component_cls: Type) -> bool:
+    run_method = getattr(component_cls, "run", None)
+    if run_method is None:
+        return False
+    else:
+        return any(
+            param.kind == inspect.Parameter.VAR_KEYWORD for param in inspect.signature(run_method).parameters.values()
+        )
+
+
+class _Component:
+    """
+    See module's docstring.
+
+    Args:
+        class_: the class that Canals should use as a component.
+        serializable: whether to check, at init time, if the component can be saved with
+        `save_pipelines()`.
+
+    Returns:
+        A class that can be recognized as a component.
+
+    Raises:
+        ComponentError: if the class provided has no `run()` method or otherwise doesn't respect the component contract.
+    """
+
+    def __init__(self):
+        self.registry = {}
+
+    def set_input_type(
+        self,
+        instance,
+        name: str,
+        type: Any,  # noqa: A002
+        default: Any = _empty,
+    ):
+        """
+        Add a single input socket to the component instance.
+
+        Replaces any existing input socket with the same name.
+
+        :param instance: Component instance where the input type will be added.
+        :param name: name of the input socket.
+        :param type: type of the input socket.
+        :param default: default value of the input socket, defaults to _empty
+        """
+        if not _component_run_has_kwargs(instance.__class__):
+            raise ComponentError(
+                "Cannot set input types on a component that doesn't have a kwargs parameter in the 'run' method"
+            )
+
+        if not hasattr(instance, "__haystack_input__"):
+            instance.__haystack_input__ = Sockets(instance, {}, InputSocket)
+        instance.__haystack_input__[name] = InputSocket(name=name, type=type, default_value=default)
+
+    def set_input_types(self, instance, **types):
+        """
+        Method that specifies the input types when 'kwargs' is passed to the run method.
+
+        Use as:
+
+        ```python
+        @component
+        class MyComponent:
+
+            def __init__(self, value: int):
+                component.set_input_types(self, value_1=str, value_2=str)
+                ...
+
+            @component.output_types(output_1=int, output_2=str)
+            def run(self, **kwargs):
+                return {"output_1": kwargs["value_1"], "output_2": ""}
+        ```
+
+        Note that if the `run()` method also specifies some parameters, those will take precedence.
+
+        For example:
+
+        ```python
+        @component
+        class MyComponent:
+
+            def __init__(self, value: int):
+                component.set_input_types(self, value_1=str, value_2=str)
+                ...
+
+            @component.output_types(output_1=int, output_2=str)
+            def run(self, value_0: str, value_1: Optional[str] = None, **kwargs):
+                return {"output_1": kwargs["value_1"], "output_2": ""}
+        ```
+
+        would add a mandatory `value_0` parameters, make the `value_1`
+        parameter optional with a default None, and keep the `value_2`
+        parameter mandatory as specified in `set_input_types`.
+
+        """
+        if not _component_run_has_kwargs(instance.__class__):
+            raise ComponentError(
+                "Cannot set input types on a component that doesn't have a kwargs parameter in the 'run' method"
+            )
+
+        instance.__haystack_input__ = Sockets(
+            instance, {name: InputSocket(name=name, type=type_) for name, type_ in types.items()}, InputSocket
+        )
+
+    def set_output_types(self, instance, **types):
+        """
+        Method that specifies the output types when the 'run' method is not decorated with 'component.output_types'.
+
+        Use as:
+
+        ```python
+        @component
+        class MyComponent:
+
+            def __init__(self, value: int):
+                component.set_output_types(self, output_1=int, output_2=str)
+                ...
+
+            # no decorators here
+            def run(self, value: int):
+                return {"output_1": 1, "output_2": "2"}
+        ```
+        """
+        has_decorator = hasattr(instance.run, "_output_types_cache")
+        if has_decorator:
+            raise ComponentError(
+                "Cannot call `set_output_types` on a component that already has "
+                "the 'output_types' decorator on its `run` method"
+            )
+
+        instance.__haystack_output__ = Sockets(
+            instance, {name: OutputSocket(name=name, type=type_) for name, type_ in types.items()}, OutputSocket
+        )
+
+    def output_types(self, **types):
+        """
+        Decorator factory that specifies the output types of a component.
+
+        Use as:
+
+        ```python
+        @component
+        class MyComponent:
+            @component.output_types(output_1=int, output_2=str)
+            def run(self, value: int):
+                return {"output_1": 1, "output_2": "2"}
+        ```
+        """
+
+        def output_types_decorator(run_method):
+            """
+            Decorator that sets the output types of the decorated method.
+
+            This happens at class creation time, and since we don't have the decorated
+            class available here, we temporarily store the output types as an attribute of
+            the decorated method. The ComponentMeta metaclass will use this data to create
+            sockets at instance creation time.
+            """
+            method_name = run_method.__name__
+            if method_name not in ("run", "run_async"):
+                raise ComponentError("'output_types' decorator can only be used on 'run' and 'run_async' methods")
+
+            setattr(
+                run_method,
+                "_output_types_cache",
+                {name: OutputSocket(name=name, type=type_) for name, type_ in types.items()},
+            )
+            return run_method
+
+        return output_types_decorator
+
+    def _component(self, cls, is_greedy: Optional[bool] = None):
+        """
+        Decorator validating the structure of the component and registering it in the components registry.
+        """
+        logger.debug("Registering {component} as a component", component=cls)
+
+        if is_greedy is not None:
+            msg = (
+                "The 'is_greedy' argument is deprecated and will be removed in version '2.7.0'. "
+                "Change the 'Variadic' input of your Component to 'GreedyVariadic' instead."
+            )
+            warnings.warn(msg, DeprecationWarning)
+        else:
+            is_greedy = False
+
+        # Check for required methods and fail as soon as possible
+        if not hasattr(cls, "run"):
+            raise ComponentError(f"{cls.__name__} must have a 'run()' method. See the docs for more information.")
+
+        def copy_class_namespace(namespace):
+            """
+            This is the callback that `typing.new_class` will use to populate the newly created class.
+
+            Simply copy the whole namespace from the decorated class.
+            """
+            for key, val in dict(cls.__dict__).items():
+                # __dict__ and __weakref__ are class-bound, we should let Python recreate them.
+                if key in ("__dict__", "__weakref__"):
+                    continue
+                namespace[key] = val
+
+        # Recreate the decorated component class so it uses our metaclass.
+        # We must explicitly redefine the type of the class to make sure language servers
+        # and type checkers understand that the class is of the correct type.
+        # mypy doesn't like that we do this though so we explicitly ignore the type check.
+        cls: cls.__name__ = new_class(cls.__name__, cls.__bases__, {"metaclass": ComponentMeta}, copy_class_namespace)  # type: ignore[no-redef]
+
+        # Save the component in the class registry (for deserialization)
+        class_path = f"{cls.__module__}.{cls.__name__}"
+        if class_path in self.registry:
+            # Corner case, but it may occur easily in notebooks when re-running cells.
+            logger.debug(
+                "Component {component} is already registered. Previous imported from '{module_name}', \
+                new imported from '{new_module_name}'",
+                component=class_path,
+                module_name=self.registry[class_path],
+                new_module_name=cls,
+            )
+        self.registry[class_path] = cls
+        logger.debug("Registered Component {component}", component=cls)
+
+        # Override the __repr__ method with a default one
+        cls.__repr__ = _component_repr
+
+        return cls
+
+    def __call__(self, cls: Optional[type] = None, is_greedy: Optional[bool] = None):
+        # We must wrap the call to the decorator in a function for it to work
+        # correctly with or without parens
+        def wrap(cls):
+            return self._component(cls, is_greedy=is_greedy)
+
+        if cls:
+            # Decorator is called without parens
+            return wrap(cls)
+
+        # Decorator is called with parens
+        return wrap
+
+
+component = _Component()

testbed/deepset-ai__haystack/haystack/core/component/sockets.py

@@ -0,0 +1,148 @@
+# SPDX-FileCopyrightText: 2022-present deepset GmbH <info@deepset.ai>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from typing import Dict, Optional, Type, Union
+
+from haystack import logging
+from haystack.core.type_utils import _type_name
+
+from .types import InputSocket, OutputSocket
+
+logger = logging.getLogger(__name__)
+
+SocketsDict = Dict[str, Union[InputSocket, OutputSocket]]
+SocketsIOType = Union[Type[InputSocket], Type[OutputSocket]]
+
+
+class Sockets:
+    """
+    Represents the inputs or outputs of a `Component`.
+
+    Depending on the type passed to the constructor, it will represent either the inputs or the outputs of
+    the `Component`.
+
+    Usage:
+    ```python
+    from typing import Any
+    from haystack.components.builders.prompt_builder import PromptBuilder
+    from haystack.core.component.sockets import Sockets
+    from haystack.core.component.types import InputSocket, OutputSocket
+
+
+    prompt_template = \"""
+    Given these documents, answer the question.\nDocuments:
+    {% for doc in documents %}
+        {{ doc.content }}
+    {% endfor %}
+
+    \nQuestion: {{question}}
+    \nAnswer:
+    \"""
+
+    prompt_builder = PromptBuilder(template=prompt_template)
+    sockets = {"question": InputSocket("question", Any), "documents": InputSocket("documents", Any)}
+    inputs = Sockets(component=prompt_builder, sockets_dict=sockets, sockets_io_type=InputSocket)
+    inputs
+    >>> Inputs:
+    >>>   - question: Any
+    >>>   - documents: Any
+
+    inputs.question
+    >>> InputSocket(name='question', type=typing.Any, default_value=<class 'haystack.core.component.types._empty'>, ...
+    ```
+    """
+
+    # We're using a forward declaration here to avoid a circular import.
+    def __init__(
+        self,
+        component: "Component",  # type: ignore[name-defined] # noqa: F821
+        sockets_dict: SocketsDict,
+        sockets_io_type: SocketsIOType,
+    ):
+        """
+        Create a new Sockets object.
+
+        We don't do any enforcement on the types of the sockets here, the `sockets_type` is only used for
+        the `__repr__` method.
+        We could do without it and use the type of a random value in the `sockets` dict, but that wouldn't
+        work for components that have no sockets at all. Either input or output.
+
+        :param component:
+            The component that these sockets belong to.
+        :param sockets_dict:
+            A dictionary of sockets.
+        :param sockets_io_type:
+            The type of the sockets.
+        """
+        self._sockets_io_type = sockets_io_type
+        self._component = component
+        self._sockets_dict = sockets_dict
+        self.__dict__.update(sockets_dict)
+
+    def __eq__(self, value: object) -> bool:
+        if not isinstance(value, Sockets):
+            return False
+
+        return (
+            self._sockets_io_type == value._sockets_io_type
+            and self._component == value._component
+            and self._sockets_dict == value._sockets_dict
+        )
+
+    def __setitem__(self, key: str, socket: Union[InputSocket, OutputSocket]):
+        """
+        Adds a new socket to this Sockets object.
+
+        This eases a bit updating the list of sockets after Sockets has been created.
+        That should happen only in the `component` decorator.
+        """
+        self._sockets_dict[key] = socket
+        self.__dict__[key] = socket
+
+    def __contains__(self, key: str) -> bool:
+        return key in self._sockets_dict
+
+    def get(
+        self, key: str, default: Optional[Union[InputSocket, OutputSocket]] = None
+    ) -> Optional[Union[InputSocket, OutputSocket]]:
+        """
+        Get a socket from the Sockets object.
+
+        :param key:
+            The name of the socket to get.
+        :param default:
+            The value to return if the key is not found.
+        :returns:
+            The socket with the given key or `default` if the key is not found.
+        """
+        return self._sockets_dict.get(key, default)
+
+    def _component_name(self) -> str:
+        if pipeline := getattr(self._component, "__haystack_added_to_pipeline__"):
+            # This Component has been added in a Pipeline, let's get the name from there.
+            return pipeline.get_component_name(self._component)
+
+        # This Component has not been added to a Pipeline yet, so we can't know its name.
+        # Let's use default __repr__. We don't call repr() directly as Components have a custom
+        # __repr__ method and that would lead to infinite recursion since we call Sockets.__repr__ in it.
+        return object.__repr__(self._component)
+
+    def __getattribute__(self, name):
+        try:
+            sockets = object.__getattribute__(self, "_sockets")
+            if name in sockets:
+                return sockets[name]
+        except AttributeError:
+            pass
+
+        return object.__getattribute__(self, name)
+
+    def __repr__(self) -> str:
+        result = ""
+        if self._sockets_io_type == InputSocket:
+            result = "Inputs:\n"
+        elif self._sockets_io_type == OutputSocket:
+            result = "Outputs:\n"
+
+        return result + "\n".join([f"  - {n}: {_type_name(s.type)}" for n, s in self._sockets_dict.items()])

testbed/deepset-ai__haystack/haystack/core/component/types.py

@@ -0,0 +1,111 @@
+# SPDX-FileCopyrightText: 2022-present deepset GmbH <info@deepset.ai>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from dataclasses import dataclass, field
+from typing import Any, Iterable, List, Type, TypeVar, get_args
+
+from typing_extensions import Annotated, TypeAlias  # Python 3.8 compatibility
+
+HAYSTACK_VARIADIC_ANNOTATION = "__haystack__variadic_t"
+HAYSTACK_GREEDY_VARIADIC_ANNOTATION = "__haystack__greedy_variadic_t"
+
+# # Generic type variable used in the Variadic container
+T = TypeVar("T")
+
+
+# Variadic is a custom annotation type we use to mark input types.
+# This type doesn't do anything else than "marking" the contained
+# type so it can be used in the `InputSocket` creation where we
+# check that its annotation equals to HAYSTACK_VARIADIC_ANNOTATION
+Variadic: TypeAlias = Annotated[Iterable[T], HAYSTACK_VARIADIC_ANNOTATION]
+
+# GreedyVariadic type is similar to Variadic.
+# The only difference is the way it's treated by the Pipeline when input is received
+# in a socket with this type.
+# Instead of waiting for other inputs to be received, Components that have a GreedyVariadic
+# input will be run right after receiving the first input.
+# Even if there are multiple connections to that socket.
+GreedyVariadic: TypeAlias = Annotated[Iterable[T], HAYSTACK_GREEDY_VARIADIC_ANNOTATION]
+
+
+class _empty:
+    """Custom object for marking InputSocket.default_value as not set."""
+
+
+@dataclass
+class InputSocket:
+    """
+    Represents an input of a `Component`.
+
+    :param name:
+        The name of the input.
+    :param type:
+        The type of the input.
+    :param default_value:
+        The default value of the input. If not set, the input is mandatory.
+    :param is_variadic:
+        Whether the input is variadic or not.
+    :param is_greedy
+        Whether the input is a greedy variadic or not.
+    :param senders:
+        The list of components that send data to this input.
+    """
+
+    name: str
+    type: Type
+    default_value: Any = _empty
+    is_variadic: bool = field(init=False)
+    is_greedy: bool = field(init=False)
+    senders: List[str] = field(default_factory=list)
+
+    @property
+    def is_mandatory(self):
+        """Check if the input is mandatory."""
+        return self.default_value == _empty
+
+    def __post_init__(self):
+        try:
+            # __metadata__ is a tuple
+            self.is_variadic = self.type.__metadata__[0] in [
+                HAYSTACK_VARIADIC_ANNOTATION,
+                HAYSTACK_GREEDY_VARIADIC_ANNOTATION,
+            ]
+            self.is_greedy = self.type.__metadata__[0] == HAYSTACK_GREEDY_VARIADIC_ANNOTATION
+        except AttributeError:
+            self.is_variadic = False
+            self.is_greedy = False
+        if self.is_variadic:
+            # We need to "unpack" the type inside the Variadic annotation,
+            # otherwise the pipeline connection api will try to match
+            # `Annotated[type, HAYSTACK_VARIADIC_ANNOTATION]`.
+            #
+            # Note1: Variadic is expressed as an annotation of one single type,
+            # so the return value of get_args will always be a one-item tuple.
+            #
+            # Note2: a pipeline always passes a list of items when a component
+            # input is declared as Variadic, so the type itself always wraps
+            # an iterable of the declared type. For example, Variadic[int]
+            # is eventually an alias for Iterable[int]. Since we're interested
+            # in getting the inner type `int`, we call `get_args` twice: the
+            # first time to get `List[int]` out of `Variadic`, the second time
+            # to get `int` out of `List[int]`.
+            self.type = get_args(get_args(self.type)[0])[0]
+
+
+@dataclass
+class OutputSocket:
+    """
+    Represents an output of a `Component`.
+
+    :param name:
+        The name of the output.
+    :param type:
+        The type of the output.
+    :param receivers:
+        The list of components that receive the output of this component.
+    """
+
+    name: str
+    type: type
+    receivers: List[str] = field(default_factory=list)

testbed/deepset-ai__haystack/haystack/core/errors.py

@@ -0,0 +1,47 @@
+# SPDX-FileCopyrightText: 2022-present deepset GmbH <info@deepset.ai>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+
+class PipelineError(Exception):
+    pass
+
+
+class PipelineRuntimeError(Exception):
+    pass
+
+
+class PipelineConnectError(PipelineError):
+    pass
+
+
+class PipelineValidationError(PipelineError):
+    pass
+
+
+class PipelineDrawingError(PipelineError):
+    pass
+
+
+class PipelineMaxComponentRuns(PipelineError):
+    pass
+
+
+class PipelineUnmarshalError(PipelineError):
+    pass
+
+
+class ComponentError(Exception):
+    pass
+
+
+class ComponentDeserializationError(Exception):
+    pass
+
+
+class DeserializationError(Exception):
+    pass
+
+
+class SerializationError(Exception):
+    pass

testbed/deepset-ai__haystack/haystack/core/pipeline/__init__.py

@@ -0,0 +1,8 @@
+# SPDX-FileCopyrightText: 2022-present deepset GmbH <info@deepset.ai>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from .pipeline import Pipeline
+from .template import PredefinedPipeline
+
+__all__ = ["Pipeline", "PredefinedPipeline"]

testbed/deepset-ai__haystack/haystack/core/pipeline/base.py

@@ -0,0 +1,1375 @@
+# SPDX-FileCopyrightText: 2022-present deepset GmbH <info@deepset.ai>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+import importlib
+import itertools
+from collections import defaultdict
+from copy import deepcopy
+from datetime import datetime
+from pathlib import Path
+from typing import Any, Dict, Iterator, List, Optional, Set, TextIO, Tuple, Type, TypeVar, Union
+
+import networkx  # type:ignore
+
+from haystack import logging
+from haystack.core.component import Component, InputSocket, OutputSocket, component
+from haystack.core.errors import (
+    DeserializationError,
+    PipelineConnectError,
+    PipelineDrawingError,
+    PipelineError,
+    PipelineRuntimeError,
+    PipelineUnmarshalError,
+    PipelineValidationError,
+)
+from haystack.core.serialization import DeserializationCallbacks, component_from_dict, component_to_dict
+from haystack.core.type_utils import _type_name, _types_are_compatible
+from haystack.marshal import Marshaller, YamlMarshaller
+from haystack.utils import is_in_jupyter
+
+from .descriptions import find_pipeline_inputs, find_pipeline_outputs
+from .draw import _to_mermaid_image
+from .template import PipelineTemplate, PredefinedPipeline
+from .utils import parse_connect_string
+
+DEFAULT_MARSHALLER = YamlMarshaller()
+
+# We use a generic type to annotate the return value of classmethods,
+# so that static analyzers won't be confused when derived classes
+# use those methods.
+T = TypeVar("T", bound="PipelineBase")
+
+logger = logging.getLogger(__name__)
+
+
+class PipelineBase:
+    """
+    Components orchestration engine.
+
+    Builds a graph of components and orchestrates their execution according to the execution graph.
+    """
+
+    def __init__(self, metadata: Optional[Dict[str, Any]] = None, max_runs_per_component: int = 100):
+        """
+        Creates the Pipeline.
+
+        :param metadata:
+            Arbitrary dictionary to store metadata about this `Pipeline`. Make sure all the values contained in
+            this dictionary can be serialized and deserialized if you wish to save this `Pipeline` to file.
+        :param max_runs_per_component:
+            How many times the `Pipeline` can run the same Component.
+            If this limit is reached a `PipelineMaxComponentRuns` exception is raised.
+            If not set defaults to 100 runs per Component.
+        """
+        self._telemetry_runs = 0
+        self._last_telemetry_sent: Optional[datetime] = None
+        self.metadata = metadata or {}
+        self.graph = networkx.MultiDiGraph()
+        self._max_runs_per_component = max_runs_per_component
+
+    def __eq__(self, other) -> bool:
+        """
+        Pipeline equality is defined by their type and the equality of their serialized form.
+
+        Pipelines of the same type share every metadata, node and edge, but they're not required to use
+        the same node instances: this allows pipeline saved and then loaded back to be equal to themselves.
+        """
+        if not isinstance(self, type(other)):
+            return False
+        return self.to_dict() == other.to_dict()
+
+    def __repr__(self) -> str:
+        """
+        Returns a text representation of the Pipeline.
+        """
+        res = f"{object.__repr__(self)}\n"
+        if self.metadata:
+            res += "🧱 Metadata\n"
+            for k, v in self.metadata.items():
+                res += f"  - {k}: {v}\n"
+
+        res += "🚅 Components\n"
+        for name, instance in self.graph.nodes(data="instance"):  # type: ignore # type wrongly defined in networkx
+            res += f"  - {name}: {instance.__class__.__name__}\n"
+
+        res += "🛤️ Connections\n"
+        for sender, receiver, edge_data in self.graph.edges(data=True):
+            sender_socket = edge_data["from_socket"].name
+            receiver_socket = edge_data["to_socket"].name
+            res += f"  - {sender}.{sender_socket} -> {receiver}.{receiver_socket} ({edge_data['conn_type']})\n"
+
+        return res
+
+    def to_dict(self) -> Dict[str, Any]:
+        """
+        Serializes the pipeline to a dictionary.
+
+        This is meant to be an intermediate representation but it can be also used to save a pipeline to file.
+
+        :returns:
+            Dictionary with serialized data.
+        """
+        components = {}
+        for name, instance in self.graph.nodes(data="instance"):  # type:ignore
+            components[name] = component_to_dict(instance, name)
+
+        connections = []
+        for sender, receiver, edge_data in self.graph.edges.data():
+            sender_socket = edge_data["from_socket"].name
+            receiver_socket = edge_data["to_socket"].name
+            connections.append({"sender": f"{sender}.{sender_socket}", "receiver": f"{receiver}.{receiver_socket}"})
+        return {
+            "metadata": self.metadata,
+            "max_runs_per_component": self._max_runs_per_component,
+            "components": components,
+            "connections": connections,
+        }
+
+    @classmethod
+    def from_dict(
+        cls: Type[T], data: Dict[str, Any], callbacks: Optional[DeserializationCallbacks] = None, **kwargs
+    ) -> T:
+        """
+        Deserializes the pipeline from a dictionary.
+
+        :param data:
+            Dictionary to deserialize from.
+        :param callbacks:
+            Callbacks to invoke during deserialization.
+        :param kwargs:
+            `components`: a dictionary of {name: instance} to reuse instances of components instead of creating new
+            ones.
+        :returns:
+            Deserialized component.
+        """
+        data_copy = deepcopy(data)  # to prevent modification of original data
+        metadata = data_copy.get("metadata", {})
+        max_runs_per_component = data_copy.get("max_runs_per_component", 100)
+        pipe = cls(metadata=metadata, max_runs_per_component=max_runs_per_component)
+        components_to_reuse = kwargs.get("components", {})
+        for name, component_data in data_copy.get("components", {}).items():
+            if name in components_to_reuse:
+                # Reuse an instance
+                instance = components_to_reuse[name]
+            else:
+                if "type" not in component_data:
+                    raise PipelineError(f"Missing 'type' in component '{name}'")
+
+                if component_data["type"] not in component.registry:
+                    try:
+                        # Import the module first...
+                        module, _ = component_data["type"].rsplit(".", 1)
+                        logger.debug("Trying to import module {module_name}", module_name=module)
+                        importlib.import_module(module)
+                        # ...then try again
+                        if component_data["type"] not in component.registry:
+                            raise PipelineError(
+                                f"Successfully imported module {module} but can't find it in the component registry."
+                                "This is unexpected and most likely a bug."
+                            )
+                    except (ImportError, PipelineError) as e:
+                        raise PipelineError(f"Component '{component_data['type']}' not imported.") from e
+
+                # Create a new one
+                component_class = component.registry[component_data["type"]]
+
+                try:
+                    instance = component_from_dict(component_class, component_data, name, callbacks)
+                except Exception as e:
+                    msg = (
+                        f"Couldn't deserialize component '{name}' of class '{component_class.__name__}' "
+                        f"with the following data: {str(component_data)}. Possible reasons include "
+                        "malformed serialized data, mismatch between the serialized component and the "
+                        "loaded one (due to a breaking change, see "
+                        "https://github.com/deepset-ai/haystack/releases), etc."
+                    )
+                    raise DeserializationError(msg) from e
+            pipe.add_component(name=name, instance=instance)
+
+        for connection in data.get("connections", []):
+            if "sender" not in connection:
+                raise PipelineError(f"Missing sender in connection: {connection}")
+            if "receiver" not in connection:
+                raise PipelineError(f"Missing receiver in connection: {connection}")
+            pipe.connect(sender=connection["sender"], receiver=connection["receiver"])
+
+        return pipe
+
+    def dumps(self, marshaller: Marshaller = DEFAULT_MARSHALLER) -> str:
+        """
+        Returns the string representation of this pipeline according to the format dictated by the `Marshaller` in use.
+
+        :param marshaller:
+            The Marshaller used to create the string representation. Defaults to `YamlMarshaller`.
+        :returns:
+            A string representing the pipeline.
+        """
+        return marshaller.marshal(self.to_dict())
+
+    def dump(self, fp: TextIO, marshaller: Marshaller = DEFAULT_MARSHALLER):
+        """
+        Writes the string representation of this pipeline to the file-like object passed in the `fp` argument.
+
+        :param fp:
+            A file-like object ready to be written to.
+        :param marshaller:
+            The Marshaller used to create the string representation. Defaults to `YamlMarshaller`.
+        """
+        fp.write(marshaller.marshal(self.to_dict()))
+
+    @classmethod
+    def loads(
+        cls: Type[T],
+        data: Union[str, bytes, bytearray],
+        marshaller: Marshaller = DEFAULT_MARSHALLER,
+        callbacks: Optional[DeserializationCallbacks] = None,
+    ) -> T:
+        """
+        Creates a `Pipeline` object from the string representation passed in the `data` argument.
+
+        :param data:
+            The string representation of the pipeline, can be `str`, `bytes` or `bytearray`.
+        :param marshaller:
+            The Marshaller used to create the string representation. Defaults to `YamlMarshaller`.
+        :param callbacks:
+            Callbacks to invoke during deserialization.
+        :raises DeserializationError:
+            If an error occurs during deserialization.
+        :returns:
+            A `Pipeline` object.
+        """
+        try:
+            deserialized_data = marshaller.unmarshal(data)
+        except Exception as e:
+            raise DeserializationError(
+                "Error while unmarshalling serialized pipeline data. This is usually "
+                "caused by malformed or invalid syntax in the serialized representation."
+            ) from e
+
+        return cls.from_dict(deserialized_data, callbacks)
+
+    @classmethod
+    def load(
+        cls: Type[T],
+        fp: TextIO,
+        marshaller: Marshaller = DEFAULT_MARSHALLER,
+        callbacks: Optional[DeserializationCallbacks] = None,
+    ) -> T:
+        """
+        Creates a `Pipeline` object a string representation.
+
+        The string representation is read from the file-like object passed in the `fp` argument.
+
+
+        :param fp:
+            A file-like object ready to be read from.
+        :param marshaller:
+            The Marshaller used to create the string representation. Defaults to `YamlMarshaller`.
+        :param callbacks:
+            Callbacks to invoke during deserialization.
+        :raises DeserializationError:
+            If an error occurs during deserialization.
+        :returns:
+            A `Pipeline` object.
+        """
+        return cls.loads(fp.read(), marshaller, callbacks)
+
+    def add_component(self, name: str, instance: Component) -> None:
+        """
+        Add the given component to the pipeline.
+
+        Components are not connected to anything by default: use `Pipeline.connect()` to connect components together.
+        Component names must be unique, but component instances can be reused if needed.
+
+        :param name:
+            The name of the component to add.
+        :param instance:
+            The component instance to add.
+
+        :raises ValueError:
+            If a component with the same name already exists.
+        :raises PipelineValidationError:
+            If the given instance is not a Canals component.
+        """
+        # Component names are unique
+        if name in self.graph.nodes:
+            raise ValueError(f"A component named '{name}' already exists in this pipeline: choose another name.")
+
+        # Components can't be named `_debug`
+        if name == "_debug":
+            raise ValueError("'_debug' is a reserved name for debug output. Choose another name.")
+
+        # Component instances must be components
+        if not isinstance(instance, Component):
+            raise PipelineValidationError(
+                f"'{type(instance)}' doesn't seem to be a component. Is this class decorated with @component?"
+            )
+
+        if getattr(instance, "__haystack_added_to_pipeline__", None):
+            msg = (
+                "Component has already been added in another Pipeline. Components can't be shared between Pipelines. "
+                "Create a new instance instead."
+            )
+            raise PipelineError(msg)
+
+        setattr(instance, "__haystack_added_to_pipeline__", self)
+
+        # Add component to the graph, disconnected
+        logger.debug("Adding component '{component_name}' ({component})", component_name=name, component=instance)
+        # We're completely sure the fields exist so we ignore the type error
+        self.graph.add_node(
+            name,
+            instance=instance,
+            input_sockets=instance.__haystack_input__._sockets_dict,  # type: ignore[attr-defined]
+            output_sockets=instance.__haystack_output__._sockets_dict,  # type: ignore[attr-defined]
+            visits=0,
+        )
+
+    def remove_component(self, name: str) -> Component:
+        """
+        Remove and returns component from the pipeline.
+
+        Remove an existing component from the pipeline by providing its name.
+        All edges that connect to the component will also be deleted.
+
+        :param name:
+            The name of the component to remove.
+        :returns:
+            The removed Component instance.
+
+        :raises ValueError:
+            If there is no component with that name already in the Pipeline.
+        """
+
+        # Check that a component with that name is in the Pipeline
+        try:
+            instance = self.get_component(name)
+        except ValueError as exc:
+            raise ValueError(
+                f"There is no component named '{name}' in the pipeline. The valid component names are: ",
+                ", ".join(n for n in self.graph.nodes),
+            ) from exc
+
+        # Delete component from the graph, deleting all its connections
+        self.graph.remove_node(name)
+
+        # Reset the Component sockets' senders and receivers
+        input_sockets = instance.__haystack_input__._sockets_dict  # type: ignore[attr-defined]
+        for socket in input_sockets.values():
+            socket.senders = []
+
+        output_sockets = instance.__haystack_output__._sockets_dict  # type: ignore[attr-defined]
+        for socket in output_sockets.values():
+            socket.receivers = []
+
+        # Reset the Component's pipeline reference
+        setattr(instance, "__haystack_added_to_pipeline__", None)
+
+        return instance
+
+    def connect(self, sender: str, receiver: str) -> "PipelineBase":  # noqa: PLR0915
+        """
+        Connects two components together.
+
+        All components to connect must exist in the pipeline.
+        If connecting to a component that has several output connections, specify the inputs and output names as
+        'component_name.connections_name'.
+
+        :param sender:
+            The component that delivers the value. This can be either just a component name or can be
+            in the format `component_name.connection_name` if the component has multiple outputs.
+        :param receiver:
+            The component that receives the value. This can be either just a component name or can be
+            in the format `component_name.connection_name` if the component has multiple inputs.
+        :returns:
+            The Pipeline instance.
+
+        :raises PipelineConnectError:
+            If the two components cannot be connected (for example if one of the components is
+            not present in the pipeline, or the connections don't match by type, and so on).
+        """
+        # Edges may be named explicitly by passing 'node_name.edge_name' to connect().
+        sender_component_name, sender_socket_name = parse_connect_string(sender)
+        receiver_component_name, receiver_socket_name = parse_connect_string(receiver)
+
+        if sender_component_name == receiver_component_name:
+            raise PipelineConnectError("Connecting a Component to itself is not supported.")
+
+        # Get the nodes data.
+        try:
+            from_sockets = self.graph.nodes[sender_component_name]["output_sockets"]
+        except KeyError as exc:
+            raise ValueError(f"Component named {sender_component_name} not found in the pipeline.") from exc
+        try:
+            to_sockets = self.graph.nodes[receiver_component_name]["input_sockets"]
+        except KeyError as exc:
+            raise ValueError(f"Component named {receiver_component_name} not found in the pipeline.") from exc
+
+        # If the name of either socket is given, get the socket
+        sender_socket: Optional[OutputSocket] = None
+        if sender_socket_name:
+            sender_socket = from_sockets.get(sender_socket_name)
+            if not sender_socket:
+                raise PipelineConnectError(
+                    f"'{sender} does not exist. "
+                    f"Output connections of {sender_component_name} are: "
+                    + ", ".join([f"{name} (type {_type_name(socket.type)})" for name, socket in from_sockets.items()])
+                )
+
+        receiver_socket: Optional[InputSocket] = None
+        if receiver_socket_name:
+            receiver_socket = to_sockets.get(receiver_socket_name)
+            if not receiver_socket:
+                raise PipelineConnectError(
+                    f"'{receiver} does not exist. "
+                    f"Input connections of {receiver_component_name} are: "
+                    + ", ".join([f"{name} (type {_type_name(socket.type)})" for name, socket in to_sockets.items()])
+                )
+
+        # Look for a matching connection among the possible ones.
+        # Note that if there is more than one possible connection but two sockets match by name, they're paired.
+        sender_socket_candidates: List[OutputSocket] = [sender_socket] if sender_socket else list(from_sockets.values())
+        receiver_socket_candidates: List[InputSocket] = (
+            [receiver_socket] if receiver_socket else list(to_sockets.values())
+        )
+
+        # Find all possible connections between these two components
+        possible_connections = [
+            (sender_sock, receiver_sock)
+            for sender_sock, receiver_sock in itertools.product(sender_socket_candidates, receiver_socket_candidates)
+            if _types_are_compatible(sender_sock.type, receiver_sock.type)
+        ]
+
+        # We need this status for error messages, since we might need it in multiple places we calculate it here
+        status = _connections_status(
+            sender_node=sender_component_name,
+            sender_sockets=sender_socket_candidates,
+            receiver_node=receiver_component_name,
+            receiver_sockets=receiver_socket_candidates,
+        )
+
+        if not possible_connections:
+            # There's no possible connection between these two components
+            if len(sender_socket_candidates) == len(receiver_socket_candidates) == 1:
+                msg = (
+                    f"Cannot connect '{sender_component_name}.{sender_socket_candidates[0].name}' with "
+                    f"'{receiver_component_name}.{receiver_socket_candidates[0].name}': "
+                    f"their declared input and output types do not match.\n{status}"
+                )
+            else:
+                msg = (
+                    f"Cannot connect '{sender_component_name}' with '{receiver_component_name}': "
+                    f"no matching connections available.\n{status}"
+                )
+            raise PipelineConnectError(msg)
+
+        if len(possible_connections) == 1:
+            # There's only one possible connection, use it
+            sender_socket = possible_connections[0][0]
+            receiver_socket = possible_connections[0][1]
+
+        if len(possible_connections) > 1:
+            # There are multiple possible connection, let's try to match them by name
+            name_matches = [
+                (out_sock, in_sock) for out_sock, in_sock in possible_connections if in_sock.name == out_sock.name
+            ]
+            if len(name_matches) != 1:
+                # There's are either no matches or more than one, we can't pick one reliably
+                msg = (
+                    f"Cannot connect '{sender_component_name}' with "
+                    f"'{receiver_component_name}': more than one connection is possible "
+                    "between these components. Please specify the connection name, like: "
+                    f"pipeline.connect('{sender_component_name}.{possible_connections[0][0].name}', "
+                    f"'{receiver_component_name}.{possible_connections[0][1].name}').\n{status}"
+                )
+                raise PipelineConnectError(msg)
+
+            # Get the only possible match
+            sender_socket = name_matches[0][0]
+            receiver_socket = name_matches[0][1]
+
+        # Connection must be valid on both sender/receiver sides
+        if not sender_socket or not receiver_socket or not sender_component_name or not receiver_component_name:
+            if sender_component_name and sender_socket:
+                sender_repr = f"{sender_component_name}.{sender_socket.name} ({_type_name(sender_socket.type)})"
+            else:
+                sender_repr = "input needed"
+
+            if receiver_component_name and receiver_socket:
+                receiver_repr = f"({_type_name(receiver_socket.type)}) {receiver_component_name}.{receiver_socket.name}"
+            else:
+                receiver_repr = "output"
+            msg = f"Connection must have both sender and receiver: {sender_repr} -> {receiver_repr}"
+            raise PipelineConnectError(msg)
+
+        logger.debug(
+            "Connecting '{sender_component}.{sender_socket_name}' to '{receiver_component}.{receiver_socket_name}'",
+            sender_component=sender_component_name,
+            sender_socket_name=sender_socket.name,
+            receiver_component=receiver_component_name,
+            receiver_socket_name=receiver_socket.name,
+        )
+
+        if receiver_component_name in sender_socket.receivers and sender_component_name in receiver_socket.senders:
+            # This is already connected, nothing to do
+            return self
+
+        if receiver_socket.senders and not receiver_socket.is_variadic:
+            # Only variadic input sockets can receive from multiple senders
+            msg = (
+                f"Cannot connect '{sender_component_name}.{sender_socket.name}' with "
+                f"'{receiver_component_name}.{receiver_socket.name}': "
+                f"{receiver_component_name}.{receiver_socket.name} is already connected to {receiver_socket.senders}.\n"
+            )
+            raise PipelineConnectError(msg)
+
+        # Update the sockets with the new connection
+        sender_socket.receivers.append(receiver_component_name)
+        receiver_socket.senders.append(sender_component_name)
+
+        # Create the new connection
+        self.graph.add_edge(
+            sender_component_name,
+            receiver_component_name,
+            key=f"{sender_socket.name}/{receiver_socket.name}",
+            conn_type=_type_name(sender_socket.type),
+            from_socket=sender_socket,
+            to_socket=receiver_socket,
+            mandatory=receiver_socket.is_mandatory,
+        )
+        return self
+
+    def get_component(self, name: str) -> Component:
+        """
+        Get the component with the specified name from the pipeline.
+
+        :param name:
+            The name of the component.
+        :returns:
+            The instance of that component.
+
+        :raises ValueError:
+            If a component with that name is not present in the pipeline.
+        """
+        try:
+            return self.graph.nodes[name]["instance"]
+        except KeyError as exc:
+            raise ValueError(f"Component named {name} not found in the pipeline.") from exc
+
+    def get_component_name(self, instance: Component) -> str:
+        """
+        Returns the name of the Component instance if it has been added to this Pipeline or an empty string otherwise.
+
+        :param instance:
+            The Component instance to look for.
+        :returns:
+            The name of the Component instance.
+        """
+        for name, inst in self.graph.nodes(data="instance"):  # type: ignore # type wrongly defined in networkx
+            if inst == instance:
+                return name
+        return ""
+
+    def inputs(self, include_components_with_connected_inputs: bool = False) -> Dict[str, Dict[str, Any]]:
+        """
+        Returns a dictionary containing the inputs of a pipeline.
+
+        Each key in the dictionary corresponds to a component name, and its value is another dictionary that describes
+        the input sockets of that component, including their types and whether they are optional.
+
+        :param include_components_with_connected_inputs:
+            If `False`, only components that have disconnected input edges are
+            included in the output.
+        :returns:
+            A dictionary where each key is a pipeline component name and each value is a dictionary of
+            inputs sockets of that component.
+        """
+        inputs: Dict[str, Dict[str, Any]] = {}
+        for component_name, data in find_pipeline_inputs(self.graph, include_components_with_connected_inputs).items():
+            sockets_description = {}
+            for socket in data:
+                sockets_description[socket.name] = {"type": socket.type, "is_mandatory": socket.is_mandatory}
+                if not socket.is_mandatory:
+                    sockets_description[socket.name]["default_value"] = socket.default_value
+
+            if sockets_description:
+                inputs[component_name] = sockets_description
+        return inputs
+
+    def outputs(self, include_components_with_connected_outputs: bool = False) -> Dict[str, Dict[str, Any]]:
+        """
+        Returns a dictionary containing the outputs of a pipeline.
+
+        Each key in the dictionary corresponds to a component name, and its value is another dictionary that describes
+        the output sockets of that component.
+
+        :param include_components_with_connected_outputs:
+            If `False`, only components that have disconnected output edges are
+            included in the output.
+        :returns:
+            A dictionary where each key is a pipeline component name and each value is a dictionary of
+            output sockets of that component.
+        """
+        outputs = {
+            comp: {socket.name: {"type": socket.type} for socket in data}
+            for comp, data in find_pipeline_outputs(self.graph, include_components_with_connected_outputs).items()
+            if data
+        }
+        return outputs
+
+    def show(self) -> None:
+        """
+        If running in a Jupyter notebook, display an image representing this `Pipeline`.
+
+        """
+        if is_in_jupyter():
+            from IPython.display import Image, display  # type: ignore
+
+            image_data = _to_mermaid_image(self.graph)
+
+            display(Image(image_data))
+        else:
+            msg = "This method is only supported in Jupyter notebooks. Use Pipeline.draw() to save an image locally."
+            raise PipelineDrawingError(msg)
+
+    def draw(self, path: Path) -> None:
+        """
+        Save an image representing this `Pipeline` to `path`.
+
+        :param path:
+            The path to save the image to.
+        """
+        # Before drawing we edit a bit the graph, to avoid modifying the original that is
+        # used for running the pipeline we copy it.
+        image_data = _to_mermaid_image(self.graph)
+        Path(path).write_bytes(image_data)
+
+    def walk(self) -> Iterator[Tuple[str, Component]]:
+        """
+        Visits each component in the pipeline exactly once and yields its name and instance.
+
+        No guarantees are provided on the visiting order.
+
+        :returns:
+            An iterator of tuples of component name and component instance.
+        """
+        for component_name, instance in self.graph.nodes(data="instance"):  # type: ignore # type is wrong in networkx
+            yield component_name, instance
+
+    def warm_up(self):
+        """
+        Make sure all nodes are warm.
+
+        It's the node's responsibility to make sure this method can be called at every `Pipeline.run()`
+        without re-initializing everything.
+        """
+        for node in self.graph.nodes:
+            if hasattr(self.graph.nodes[node]["instance"], "warm_up"):
+                logger.info("Warming up component {node}...", node=node)
+                self.graph.nodes[node]["instance"].warm_up()
+
+    def _validate_input(self, data: Dict[str, Any]):
+        """
+        Validates pipeline input data.
+
+        Validates that data:
+        * Each Component name actually exists in the Pipeline
+        * Each Component is not missing any input
+        * Each Component has only one input per input socket, if not variadic
+        * Each Component doesn't receive inputs that are already sent by another Component
+
+        :param data:
+            A dictionary of inputs for the pipeline's components. Each key is a component name.
+
+        :raises ValueError:
+            If inputs are invalid according to the above.
+        """
+        for component_name, component_inputs in data.items():
+            if component_name not in self.graph.nodes:
+                raise ValueError(f"Component named {component_name} not found in the pipeline.")
+            instance = self.graph.nodes[component_name]["instance"]
+            for socket_name, socket in instance.__haystack_input__._sockets_dict.items():
+                if socket.senders == [] and socket.is_mandatory and socket_name not in component_inputs:
+                    raise ValueError(f"Missing input for component {component_name}: {socket_name}")
+            for input_name in component_inputs.keys():
+                if input_name not in instance.__haystack_input__._sockets_dict:
+                    raise ValueError(f"Input {input_name} not found in component {component_name}.")
+
+        for component_name in self.graph.nodes:
+            instance = self.graph.nodes[component_name]["instance"]
+            for socket_name, socket in instance.__haystack_input__._sockets_dict.items():
+                component_inputs = data.get(component_name, {})
+                if socket.senders == [] and socket.is_mandatory and socket_name not in component_inputs:
+                    raise ValueError(f"Missing input for component {component_name}: {socket_name}")
+                if socket.senders and socket_name in component_inputs and not socket.is_variadic:
+                    raise ValueError(
+                        f"Input {socket_name} for component {component_name} is already sent by {socket.senders}."
+                    )
+
+    def _prepare_component_input_data(self, data: Dict[str, Any]) -> Dict[str, Dict[str, Any]]:
+        """
+        Prepares input data for pipeline components.
+
+        Organizes input data for pipeline components and identifies any inputs that are not matched to any
+        component's input slots. Deep-copies data items to avoid sharing mutables across multiple components.
+
+        This method processes a flat dictionary of input data, where each key-value pair represents an input name
+        and its corresponding value. It distributes these inputs to the appropriate pipeline components based on
+        their input requirements. Inputs that don't match any component's input slots are classified as unresolved.
+
+        :param data:
+            A dictionary potentially having input names as keys and input values as values.
+
+        :returns:
+            A dictionary mapping component names to their respective matched inputs.
+        """
+        # check whether the data is a nested dictionary of component inputs where each key is a component name
+        # and each value is a dictionary of input parameters for that component
+        is_nested_component_input = all(isinstance(value, dict) for value in data.values())
+        if not is_nested_component_input:
+            # flat input, a dict where keys are input names and values are the corresponding values
+            # we need to convert it to a nested dictionary of component inputs and then run the pipeline
+            # just like in the previous case
+            pipeline_input_data: Dict[str, Dict[str, Any]] = defaultdict(dict)
+            unresolved_kwargs = {}
+
+            # Retrieve the input slots for each component in the pipeline
+            available_inputs: Dict[str, Dict[str, Any]] = self.inputs()
+
+            # Go through all provided to distribute them to the appropriate component inputs
+            for input_name, input_value in data.items():
+                resolved_at_least_once = False
+
+                # Check each component to see if it has a slot for the current kwarg
+                for component_name, component_inputs in available_inputs.items():
+                    if input_name in component_inputs:
+                        # If a match is found, add the kwarg to the component's input data
+                        pipeline_input_data[component_name][input_name] = input_value
+                        resolved_at_least_once = True
+
+                if not resolved_at_least_once:
+                    unresolved_kwargs[input_name] = input_value
+
+            if unresolved_kwargs:
+                logger.warning(
+                    "Inputs {input_keys} were not matched to any component inputs, please check your run parameters.",
+                    input_keys=list(unresolved_kwargs.keys()),
+                )
+
+            data = dict(pipeline_input_data)
+
+        # deepcopying the inputs prevents the Pipeline run logic from being altered unexpectedly
+        # when the same input reference is passed to multiple components.
+        for component_name, component_inputs in data.items():
+            data[component_name] = {k: deepcopy(v) for k, v in component_inputs.items()}
+
+        return data
+
+    def _normalize_varidiac_input_data(self, data: Dict[str, Dict[str, Any]]) -> Dict[str, Dict[str, Any]]:
+        """
+        Variadic inputs expect their value to be a list, this utility method creates that list from the user's input.
+        """
+        for component_name, component_inputs in data.items():
+            if component_name not in self.graph.nodes:
+                # This is not a component name, it must be the name of one or more input sockets.
+                # Those are handled in a different way, so we skip them here.
+                continue
+            instance = self.graph.nodes[component_name]["instance"]
+            for component_input, input_value in component_inputs.items():
+                if instance.__haystack_input__._sockets_dict[component_input].is_variadic:
+                    # Components that have variadic inputs need to receive lists as input.
+                    # We don't want to force the user to always pass lists, so we convert single values to lists here.
+                    # If it's already a list we assume the component takes a variadic input of lists, so we
+                    # convert it in any case.
+                    data[component_name][component_input] = [input_value]
+
+        return {**data}
+
+    @classmethod
+    def from_template(
+        cls, predefined_pipeline: PredefinedPipeline, template_params: Optional[Dict[str, Any]] = None
+    ) -> "PipelineBase":
+        """
+        Create a Pipeline from a predefined template. See `PredefinedPipeline` for available options.
+
+        :param predefined_pipeline:
+            The predefined pipeline to use.
+        :param template_params:
+            An optional dictionary of parameters to use when rendering the pipeline template.
+        :returns:
+            An instance of `Pipeline`.
+        """
+        tpl = PipelineTemplate.from_predefined(predefined_pipeline)
+        # If tpl.render() fails, we let bubble up the original error
+        rendered = tpl.render(template_params)
+
+        # If there was a problem with the rendered version of the
+        # template, we add it to the error stack for debugging
+        try:
+            return cls.loads(rendered)
+        except Exception as e:
+            msg = f"Error unmarshalling pipeline: {e}\n"
+            msg += f"Source:\n{rendered}"
+            raise PipelineUnmarshalError(msg)
+
+    def _init_graph(self):
+        """Resets the visits count for each component"""
+        for node in self.graph.nodes:
+            self.graph.nodes[node]["visits"] = 0
+
+    def _find_receivers_from(self, component_name: str) -> List[Tuple[str, OutputSocket, InputSocket]]:
+        """
+        Utility function to find all Components that receive input form `component_name`.
+
+        :param component_name:
+            Name of the sender Component
+
+        :returns:
+            List of tuples containing name of the receiver Component and sender OutputSocket
+            and receiver InputSocket instances
+        """
+        res = []
+        for _, receiver_name, connection in self.graph.edges(nbunch=component_name, data=True):
+            sender_socket: OutputSocket = connection["from_socket"]
+            receiver_socket: InputSocket = connection["to_socket"]
+            res.append((receiver_name, sender_socket, receiver_socket))
+        return res
+
+    def _distribute_output(  # pylint: disable=too-many-positional-arguments
+        self,
+        receiver_components: List[Tuple[str, OutputSocket, InputSocket]],
+        component_result: Dict[str, Any],
+        components_inputs: Dict[str, Dict[str, Any]],
+        run_queue: List[Tuple[str, Component]],
+        waiting_queue: List[Tuple[str, Component]],
+    ) -> Dict[str, Any]:
+        """
+        Distributes the output of a Component to the next Components that need it.
+
+        This also updates the queues that keep track of which Components are ready to run and which are waiting for
+        input.
+
+        :param receiver_components:
+            List of tuples containing name of receiver Components and relative sender OutputSocket
+            and receiver InputSocket instances
+        :param component_result:
+            The output of the Component
+        :param components_inputs:
+            The current state of the inputs divided by Component name
+        :param run_queue:
+            Queue of Components to run
+        :param waiting_queue:
+            Queue of Components waiting for input
+
+        :returns:
+            The updated output of the Component without the keys that were distributed to other Components
+        """
+        # We keep track of which keys to remove from component_result at the end of the loop.
+        # This is done after the output has been distributed to the next components, so that
+        # we're sure all components that need this output have received it.
+        to_remove_from_component_result = set()
+
+        for receiver_name, sender_socket, receiver_socket in receiver_components:
+            if sender_socket.name not in component_result:
+                # This output wasn't created by the sender, nothing we can do.
+                #
+                # Some Components might have conditional outputs, so we need to check if they actually returned
+                # some output while iterating over their output sockets.
+                #
+                # A perfect example of this would be the ConditionalRouter, which will have an output for each
+                # condition it has been initialized with.
+                # Though it will return only one output at a time.
+                continue
+
+            if receiver_name not in components_inputs:
+                components_inputs[receiver_name] = {}
+
+            # We keep track of the keys that were distributed to other Components.
+            # This key will be removed from component_result at the end of the loop.
+            to_remove_from_component_result.add(sender_socket.name)
+
+            value = component_result[sender_socket.name]
+
+            if receiver_socket.is_variadic:
+                # Usually Component inputs can only be received from one sender, the Variadic type allows
+                # instead to receive inputs from multiple senders.
+                #
+                # To keep track of all the inputs received internally we always store them in a list.
+                if receiver_socket.name not in components_inputs[receiver_name]:
+                    # Create the list if it doesn't exist
+                    components_inputs[receiver_name][receiver_socket.name] = []
+                else:
+                    # Check if the value is actually a list
+                    assert isinstance(components_inputs[receiver_name][receiver_socket.name], list)
+                components_inputs[receiver_name][receiver_socket.name].append(value)
+            else:
+                components_inputs[receiver_name][receiver_socket.name] = value
+
+            receiver = self.graph.nodes[receiver_name]["instance"]
+            pair = (receiver_name, receiver)
+
+            if receiver_socket.is_variadic:
+                if receiver_socket.is_greedy:
+                    # If the receiver is greedy, we can run it as soon as possible.
+                    # First we remove it from the status lists it's in if it's there or
+                    # we risk running it multiple times.
+                    if pair in run_queue:
+                        run_queue.remove(pair)
+                    if pair in waiting_queue:
+                        waiting_queue.remove(pair)
+                    run_queue.insert(0, pair)
+                else:
+                    # If the receiver Component has a variadic input that is not greedy
+                    # we put it in the waiting queue.
+                    # This make sure that we don't run it earlier than necessary and we can collect
+                    # as many inputs as we can before running it.
+                    if pair not in waiting_queue:
+                        waiting_queue.append(pair)
+
+            if pair not in waiting_queue and pair not in run_queue:
+                # Queue up the Component that received this input to run, only if it's not already waiting
+                # for input or already ready to run.
+                run_queue.append(pair)
+
+        # Returns the output without the keys that were distributed to other Components
+        return {k: v for k, v in component_result.items() if k not in to_remove_from_component_result}
+
+    def _find_next_runnable_component(
+        self, components_inputs: Dict[str, Dict[str, Any]], waiting_queue: List[Tuple[str, Component]]
+    ) -> Tuple[str, Component]:
+        """
+        Finds the next Component that can be run and returns it.
+
+        :param components_inputs: The current state of the inputs divided by Component name
+        :param waiting_queue: Queue of Components waiting for input
+
+        :returns: The name and the instance of the next Component that can be run
+        """
+        all_lazy_variadic = True
+        all_with_default_inputs = True
+
+        filtered_waiting_queue = []
+
+        for name, comp in waiting_queue:
+            if not _is_lazy_variadic(comp):
+                # Components with variadic inputs that are not greedy must be removed only if there's nothing else to
+                # run at this stage.
+                # We need to wait as long as possible to run them, so we can collect as most inputs as we can.
+                all_lazy_variadic = False
+
+            if not _has_all_inputs_with_defaults(comp):
+                # Components that have defaults for all their inputs must be treated the same identical way as we treat
+                # lazy variadic components. If there are only components with defaults we can run them.
+                # If we don't do this the order of execution of the Pipeline's Components will be affected cause we
+                # enqueue the Components in `run_queue` at the start using the order they are added in the Pipeline.
+                # If a Component A with defaults is added before a Component B that has no defaults, but in the Pipeline
+                # logic A must be executed after B. However, B could run before A if we don't do this check.
+                all_with_default_inputs = False
+
+            if not _is_lazy_variadic(comp) and not _has_all_inputs_with_defaults(comp):
+                # Keep track of the Components that are not lazy variadic and don't have all inputs with defaults.
+                # We'll handle these later if necessary.
+                filtered_waiting_queue.append((name, comp))
+
+        # If all Components are lazy variadic or all Components have all inputs with defaults we can get one to run
+        if all_lazy_variadic or all_with_default_inputs:
+            return waiting_queue[0]
+
+        for name, comp in filtered_waiting_queue:
+            # Find the first component that has all the inputs it needs to run
+            has_enough_inputs = True
+            for input_socket in comp.__haystack_input__._sockets_dict.values():  # type: ignore
+                if input_socket.name not in components_inputs.get(name, {}) and input_socket.is_mandatory:
+                    has_enough_inputs = False
+                    break
+
+            if has_enough_inputs:
+                return name, comp
+
+        # If we reach this point it means that we found no Component that has enough inputs to run.
+        # Ideally we should never reach this point, though we can't raise an exception either as
+        # existing use cases rely on this behavior.
+        # So we return the last Component, that could be the last from waiting_queue or filtered_waiting_queue.
+        return name, comp
+
+    def _find_next_runnable_lazy_variadic_or_default_component(
+        self, waiting_queue: List[Tuple[str, Component]]
+    ) -> Tuple[str, Component]:
+        """
+        Finds the next Component that can be run and has a lazy variadic input or all inputs with default values.
+
+        :param waiting_queue: Queue of Components waiting for input
+
+        :returns: The name and the instance of the next Component that can be run
+        """
+        for name, comp in waiting_queue:
+            is_lazy_variadic = _is_lazy_variadic(comp)
+            has_only_defaults = _has_all_inputs_with_defaults(comp)
+            if is_lazy_variadic or has_only_defaults:
+                return name, comp
+
+        # If we reach this point it means that we found no Component that has a lazy variadic input or all inputs with
+        # default values to run.
+        # Similar to `_find_next_runnable_component` we might not find the Component we want, so we optimistically
+        # return the last Component in the list.
+        # We're probably stuck in a loop in this case, but we can't raise an exception as existing use cases might
+        # rely on this behaviour.
+        # The loop detection will be handled later on.
+        return name, comp
+
+    def _find_components_that_will_receive_no_input(
+        self, component_name: str, component_result: Dict[str, Any], components_inputs: Dict[str, Dict[str, Any]]
+    ) -> Set[Tuple[str, Component]]:
+        """
+        Find all the Components that are connected to component_name and didn't receive any input from it.
+
+        Components that have a Variadic input and received already some input from other Components
+        but not from component_name won't be returned as they have enough inputs to run.
+
+        This includes the descendants of the Components that didn't receive any input from component_name.
+        That is necessary to avoid getting stuck into infinite loops waiting for inputs that will never arrive.
+
+        :param component_name: Name of the Component that created the output
+        :param component_result: Output of the Component
+        :param components_inputs: The current state of the inputs divided by Component name
+        :return: A set of Components that didn't receive any input from component_name
+        """
+
+        # Simplifies the check if a Component is Variadic and received some input from other Components.
+        def has_variadic_socket_with_existing_inputs(
+            component: Component, component_name: str, sender_name: str, components_inputs: Dict[str, Dict[str, Any]]
+        ) -> bool:
+            for socket in component.__haystack_input__._sockets_dict.values():  # type: ignore
+                if sender_name not in socket.senders:
+                    continue
+                if socket.is_variadic and len(components_inputs.get(component_name, {}).get(socket.name, [])) > 0:
+                    return True
+            return False
+
+        # Makes it easier to verify if all connections between two Components are optional
+        def all_connections_are_optional(sender_name: str, receiver: Component) -> bool:
+            for socket in receiver.__haystack_input__._sockets_dict.values():  # type: ignore
+                if sender_name not in socket.senders:
+                    continue
+                if socket.is_mandatory:
+                    return False
+            return True
+
+        # Eases checking if other connections that are not between sender_name and receiver_name
+        # already received inputs
+        def other_connections_received_input(sender_name: str, receiver_name: str) -> bool:
+            receiver: Component = self.graph.nodes[receiver_name]["instance"]
+            for receiver_socket in receiver.__haystack_input__._sockets_dict.values():  # type: ignore
+                if sender_name in receiver_socket.senders:
+                    continue
+                if components_inputs.get(receiver_name, {}).get(receiver_socket.name) is not None:
+                    return True
+            return False
+
+        components = set()
+        instance: Component = self.graph.nodes[component_name]["instance"]
+        for socket_name, socket in instance.__haystack_output__._sockets_dict.items():  # type: ignore
+            if socket_name in component_result:
+                continue
+            for receiver in socket.receivers:
+                receiver_instance: Component = self.graph.nodes[receiver]["instance"]
+
+                if has_variadic_socket_with_existing_inputs(
+                    receiver_instance, receiver, component_name, components_inputs
+                ):
+                    # Components with Variadic input that already received some input
+                    # can still run, even if branch is skipped.
+                    # If we remove them they won't run.
+                    continue
+
+                if all_connections_are_optional(component_name, receiver_instance) and other_connections_received_input(
+                    component_name, receiver
+                ):
+                    # If all the connections between component_name and receiver are optional
+                    # and receiver received other inputs already it still has enough inputs to run.
+                    # Even if it didn't receive input from component_name, so we can't remove it or its
+                    # descendants.
+                    continue
+
+                components.add((receiver, receiver_instance))
+                # Get the descendants too. When we remove a Component that received no input
+                # it's extremely likely that its descendants will receive no input as well.
+                # This is fine even if the Pipeline will merge back into a single Component
+                # at a certain point. The merging Component will be put back into the run
+                # queue at a later stage.
+                for descendant_name in networkx.descendants(self.graph, receiver):
+                    descendant = self.graph.nodes[descendant_name]["instance"]
+
+                    # Components with Variadic input that already received some input
+                    # can still run, even if branch is skipped.
+                    # If we remove them they won't run.
+                    if has_variadic_socket_with_existing_inputs(
+                        descendant, descendant_name, receiver, components_inputs
+                    ):
+                        continue
+
+                    components.add((descendant_name, descendant))
+
+        return components
+
+    def _is_stuck_in_a_loop(self, waiting_queue: List[Tuple[str, Component]]) -> bool:
+        """
+        Checks if the Pipeline is stuck in a loop.
+
+        :param waiting_queue: Queue of Components waiting for input
+
+        :returns: True if the Pipeline is stuck in a loop, False otherwise
+        """
+        # Are we actually stuck or there's a lazy variadic or a component with has only default inputs
+        # waiting for input?
+        # This is our last resort, if there's no lazy variadic or component with only default inputs
+        # waiting for input we're stuck for real and we can't make any progress.
+        component_found = False
+        for _, comp in waiting_queue:
+            if _is_lazy_variadic(comp) or _has_all_inputs_with_defaults(comp):
+                component_found = True
+                break
+
+        if not component_found:
+            # We're stuck in a loop for real, we can't make any progress.
+            # BAIL!
+            return True
+
+        # If we have a single component with no variadic input or only default inputs waiting for input
+        # it means it has been waiting for input for at least 2 iterations.
+        # This will never run.
+        # BAIL!
+        return len(waiting_queue) == 1
+
+    def _component_has_enough_inputs_to_run(self, name: str, inputs: Dict[str, Dict[str, Any]]) -> bool:
+        """
+        Returns True if the Component has all the inputs it needs to run.
+
+        :param name: Name of the Component as defined in the Pipeline.
+        :param inputs: The current state of the inputs divided by Component name.
+
+        :return: Whether the Component can run or not.
+        """
+        instance: Component = self.graph.nodes[name]["instance"]
+        if name not in inputs:
+            return False
+        expected_inputs = instance.__haystack_input__._sockets_dict.keys()  # type: ignore
+        current_inputs = inputs[name].keys()
+        return expected_inputs == current_inputs
+
+    def _break_supported_cycles_in_graph(self) -> Tuple[networkx.MultiDiGraph, Dict[str, List[List[str]]]]:
+        """
+        Utility function to remove supported cycles in the Pipeline's graph.
+
+        Given that the Pipeline execution would wait to run a Component until it has received
+        all its mandatory inputs, it doesn't make sense for us to try and break cycles by
+        removing a connection to a mandatory input. The Pipeline would just get stuck at a later time.
+
+        So we can only break connections in cycles that have a Variadic or GreedyVariadic type or a default value.
+
+        This will raise a PipelineRuntimeError if we there are cycles that can't be broken.
+        That is bound to happen when at least one of the inputs in a cycle is mandatory.
+
+        If the Pipeline's graph doesn't have any cycle it will just return that graph and an empty dictionary.
+
+        :returns:
+            A tuple containing:
+                * A copy of the Pipeline's graph without cycles
+                * A dictionary of Component's names and a list of all the cycles they were part of.
+                  The cycles are a list of Component's names that create that cycle.
+        """
+        if networkx.is_directed_acyclic_graph(self.graph):
+            return self.graph, {}
+
+        temp_graph: networkx.MultiDiGraph = self.graph.copy()
+        # A list of all the cycles that are found in the graph, each inner list contains
+        # the Component names that create that cycle.
+        cycles: List[List[str]] = list(networkx.simple_cycles(self.graph))
+        # Maps a Component name to a list of its output socket names that have been broken
+        edges_removed: Dict[str, List[str]] = defaultdict(list)
+        # This keeps track of all the cycles that a component is part of.
+        # Maps a Component name to a list of cycles, each inner list contains
+        # the Component names that create that cycle (the key will also be
+        # an element in each list). The last Component in each list is implicitly
+        # connected to the first.
+        components_in_cycles: Dict[str, List[List[str]]] = defaultdict(list)
+
+        # Used to minimize the number of time we check whether the graph has any more
+        # cycles left to break or not.
+        graph_has_cycles = True
+
+        # Iterate all the cycles to find the least amount of connections that we can remove
+        # to make the Pipeline graph acyclic.
+        # As soon as the graph is acyclic we stop breaking connections and return.
+        for cycle in cycles:
+            for comp in cycle:
+                components_in_cycles[comp].append(cycle)
+
+            # Iterate this cycle, we zip the cycle with itself so that at the last iteration
+            # sender_comp will be the last element of cycle and receiver_comp will be the first.
+            # So if cycle is [1, 2, 3, 4] we would call zip([1, 2, 3, 4], [2, 3, 4, 1]).
+            for sender_comp, receiver_comp in zip(cycle, cycle[1:] + cycle[:1]):
+                # We get the key and iterate those as we want to edit the graph data while
+                # iterating the edges and that would raise.
+                # Even though the connection key set in Pipeline.connect() uses only the
+                # sockets name we don't have clashes since it's only used to differentiate
+                # multiple edges between two nodes.
+                edge_keys = list(temp_graph.get_edge_data(sender_comp, receiver_comp).keys())
+                for edge_key in edge_keys:
+                    edge_data = temp_graph.get_edge_data(sender_comp, receiver_comp)[edge_key]
+                    receiver_socket = edge_data["to_socket"]
+                    if not receiver_socket.is_variadic and receiver_socket.is_mandatory:
+                        continue
+
+                    # We found a breakable edge
+                    sender_socket = edge_data["from_socket"]
+                    edges_removed[sender_comp].append(sender_socket.name)
+                    temp_graph.remove_edge(sender_comp, receiver_comp, edge_key)
+
+                    graph_has_cycles = not networkx.is_directed_acyclic_graph(temp_graph)
+                    if not graph_has_cycles:
+                        # We removed all the cycles, we can stop
+                        break
+
+            if not graph_has_cycles:
+                # We removed all the cycles, nice
+                break
+
+        if graph_has_cycles:
+            msg = "Pipeline contains a cycle that we can't execute"
+            raise PipelineRuntimeError(msg)
+
+        return temp_graph, components_in_cycles
+
+
+def _connections_status(
+    sender_node: str, receiver_node: str, sender_sockets: List[OutputSocket], receiver_sockets: List[InputSocket]
+):
+    """
+    Lists the status of the sockets, for error messages.
+    """
+    sender_sockets_entries = []
+    for sender_socket in sender_sockets:
+        sender_sockets_entries.append(f" - {sender_socket.name}: {_type_name(sender_socket.type)}")
+    sender_sockets_list = "\n".join(sender_sockets_entries)
+
+    receiver_sockets_entries = []
+    for receiver_socket in receiver_sockets:
+        if receiver_socket.senders:
+            sender_status = f"sent by {','.join(receiver_socket.senders)}"
+        else:
+            sender_status = "available"
+        receiver_sockets_entries.append(
+            f" - {receiver_socket.name}: {_type_name(receiver_socket.type)} ({sender_status})"
+        )
+    receiver_sockets_list = "\n".join(receiver_sockets_entries)
+
+    return f"'{sender_node}':\n{sender_sockets_list}\n'{receiver_node}':\n{receiver_sockets_list}"
+
+
+def _is_lazy_variadic(c: Component) -> bool:
+    """
+    Small utility function to check if a Component has at least a Variadic input and no GreedyVariadic input.
+    """
+    is_variadic = any(
+        socket.is_variadic
+        for socket in c.__haystack_input__._sockets_dict.values()  # type: ignore
+    )
+    if not is_variadic:
+        return False
+    return not any(
+        socket.is_greedy
+        for socket in c.__haystack_input__._sockets_dict.values()  # type: ignore
+    )
+
+
+def _has_all_inputs_with_defaults(c: Component) -> bool:
+    """
+    Small utility function to check if a Component has all inputs with defaults.
+    """
+    return all(
+        not socket.is_mandatory
+        for socket in c.__haystack_input__._sockets_dict.values()  # type: ignore
+    )
+
+
+def _add_missing_input_defaults(name: str, comp: Component, components_inputs: Dict[str, Dict[str, Any]]):
+    """
+    Updates the inputs with the default values for the inputs that are missing
+
+    :param name: Name of the Component
+    :param comp: Instance of the Component
+    :param components_inputs: The current state of the inputs divided by Component name
+    """
+    if name not in components_inputs:
+        components_inputs[name] = {}
+
+    for input_socket in comp.__haystack_input__._sockets_dict.values():  # type: ignore
+        if input_socket.is_mandatory:
+            continue
+
+        if input_socket.name not in components_inputs[name]:
+            components_inputs[name][input_socket.name] = input_socket.default_value
+
+
+def _enqueue_component(
+    component_pair: Tuple[str, Component],
+    run_queue: List[Tuple[str, Component]],
+    waiting_queue: List[Tuple[str, Component]],
+):
+    """
+    Append a Component in the queue of Components to run if not already in it.
+
+    Remove it from the waiting list if it's there.
+
+    :param component_pair: Tuple of Component name and instance
+    :param run_queue: Queue of Components to run
+    :param waiting_queue: Queue of Components waiting for input
+    """
+    if component_pair in waiting_queue:
+        waiting_queue.remove(component_pair)
+
+    if component_pair not in run_queue:
+        run_queue.append(component_pair)
+
+
+def _dequeue_component(
+    component_pair: Tuple[str, Component],
+    run_queue: List[Tuple[str, Component]],
+    waiting_queue: List[Tuple[str, Component]],
+):
+    """
+    Removes a Component both from the queue of Components to run and the waiting list.
+
+    :param component_pair: Tuple of Component name and instance
+    :param run_queue: Queue of Components to run
+    :param waiting_queue: Queue of Components waiting for input
+    """
+    if component_pair in waiting_queue:
+        waiting_queue.remove(component_pair)
+
+    if component_pair in run_queue:
+        run_queue.remove(component_pair)
+
+
+def _enqueue_waiting_component(component_pair: Tuple[str, Component], waiting_queue: List[Tuple[str, Component]]):
+    """
+    Append a Component in the queue of Components that are waiting for inputs if not already in it.
+
+    :param component_pair: Tuple of Component name and instance
+    :param waiting_queue: Queue of Components waiting for input
+    """
+    if component_pair not in waiting_queue:
+        waiting_queue.append(component_pair)
+
+
+def _dequeue_waiting_component(component_pair: Tuple[str, Component], waiting_queue: List[Tuple[str, Component]]):
+    """
+    Removes a Component from the queue of Components that are waiting for inputs.
+
+    :param component_pair: Tuple of Component name and instance
+    :param waiting_queue: Queue of Components waiting for input
+    """
+    if component_pair in waiting_queue:
+        waiting_queue.remove(component_pair)

testbed/deepset-ai__haystack/haystack/core/pipeline/descriptions.py

@@ -0,0 +1,73 @@
+# SPDX-FileCopyrightText: 2022-present deepset GmbH <info@deepset.ai>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from typing import Dict, List
+
+import networkx  # type:ignore
+
+from haystack import logging
+from haystack.core.component.types import InputSocket, OutputSocket
+from haystack.core.type_utils import _type_name
+
+logger = logging.getLogger(__name__)
+
+
+def find_pipeline_inputs(
+    graph: networkx.MultiDiGraph, include_connected_sockets: bool = False
+) -> Dict[str, List[InputSocket]]:
+    """
+    Collect components that have disconnected/connected input sockets.
+
+    Note that this method returns *ALL* disconnected input sockets, including all such sockets with default values.
+    """
+    return {
+        name: [
+            socket
+            for socket in data.get("input_sockets", {}).values()
+            if socket.is_variadic or (include_connected_sockets or not socket.senders)
+        ]
+        for name, data in graph.nodes(data=True)
+    }
+
+
+def find_pipeline_outputs(
+    graph: networkx.MultiDiGraph, include_connected_sockets: bool = False
+) -> Dict[str, List[OutputSocket]]:
+    """
+    Collect components that have disconnected/connected output sockets. They define the pipeline output.
+    """
+    return {
+        name: [
+            socket
+            for socket in data.get("output_sockets", {}).values()
+            if (include_connected_sockets or not socket.receivers)
+        ]
+        for name, data in graph.nodes(data=True)
+    }
+
+
+def describe_pipeline_inputs(graph: networkx.MultiDiGraph):
+    """
+    Returns a dictionary with the input names and types that this pipeline accepts.
+    """
+    inputs = {
+        comp: {socket.name: {"type": socket.type, "is_mandatory": socket.is_mandatory} for socket in data}
+        for comp, data in find_pipeline_inputs(graph).items()
+        if data
+    }
+    return inputs
+
+
+def describe_pipeline_inputs_as_string(graph: networkx.MultiDiGraph):
+    """
+    Returns a string representation of the input names and types that this pipeline accepts.
+    """
+    inputs = describe_pipeline_inputs(graph)
+    message = "This pipeline expects the following inputs:\n"
+    for comp, sockets in inputs.items():
+        if sockets:
+            message += f"- {comp}:\n"
+            for name, socket in sockets.items():
+                message += f"    - {name}: {_type_name(socket['type'])}\n"
+    return message

testbed/deepset-ai__haystack/haystack/core/pipeline/draw.py

@@ -0,0 +1,154 @@
+# SPDX-FileCopyrightText: 2022-present deepset GmbH <info@deepset.ai>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+import base64
+
+import networkx  # type:ignore
+import requests
+
+from haystack import logging
+from haystack.core.errors import PipelineDrawingError
+from haystack.core.pipeline.descriptions import find_pipeline_inputs, find_pipeline_outputs
+from haystack.core.type_utils import _type_name
+
+logger = logging.getLogger(__name__)
+
+
+def _prepare_for_drawing(graph: networkx.MultiDiGraph) -> networkx.MultiDiGraph:
+    """
+    Add some extra nodes to show the inputs and outputs of the pipeline.
+
+    Also adds labels to edges.
+    """
+    # Label the edges
+    for inp, outp, key, data in graph.edges(keys=True, data=True):
+        data["label"] = (
+            f"{data['from_socket'].name} -> {data['to_socket'].name}{' (opt.)' if not data['mandatory'] else ''}"
+        )
+        graph.add_edge(inp, outp, key=key, **data)
+
+    # Add inputs fake node
+    graph.add_node("input")
+    for node, in_sockets in find_pipeline_inputs(graph).items():
+        for in_socket in in_sockets:
+            if not in_socket.senders and in_socket.is_mandatory:
+                # If this socket has no sender it could be a socket that receives input
+                # directly when running the Pipeline. We can't know that for sure, in doubt
+                # we draw it as receiving input directly.
+                graph.add_edge("input", node, label=in_socket.name, conn_type=_type_name(in_socket.type))
+
+    # Add outputs fake node
+    graph.add_node("output")
+    for node, out_sockets in find_pipeline_outputs(graph).items():
+        for out_socket in out_sockets:
+            graph.add_edge(node, "output", label=out_socket.name, conn_type=_type_name(out_socket.type))
+
+    return graph
+
+
+ARROWTAIL_MANDATORY = "--"
+ARROWTAIL_OPTIONAL = "-."
+ARROWHEAD_MANDATORY = "-->"
+ARROWHEAD_OPTIONAL = ".->"
+MERMAID_STYLED_TEMPLATE = """
+%%{{ init: {{'theme': 'neutral' }} }}%%
+
+graph TD;
+
+{connections}
+
+classDef component text-align:center;
+"""
+
+
+def _to_mermaid_image(graph: networkx.MultiDiGraph):
+    """
+    Renders a pipeline using Mermaid (hosted version at 'https://mermaid.ink'). Requires Internet access.
+    """
+    # Copy the graph to avoid modifying the original
+    graph_styled = _to_mermaid_text(graph.copy())
+
+    graphbytes = graph_styled.encode("ascii")
+    base64_bytes = base64.b64encode(graphbytes)
+    base64_string = base64_bytes.decode("ascii")
+    url = f"https://mermaid.ink/img/{base64_string}?type=png"
+
+    logger.debug("Rendering graph at {url}", url=url)
+    try:
+        resp = requests.get(url, timeout=10)
+        if resp.status_code >= 400:
+            logger.warning(
+                "Failed to draw the pipeline: https://mermaid.ink/img/ returned status {status_code}",
+                status_code=resp.status_code,
+            )
+            logger.info("Exact URL requested: {url}", url=url)
+            logger.warning("No pipeline diagram will be saved.")
+            resp.raise_for_status()
+
+    except Exception as exc:  # pylint: disable=broad-except
+        logger.warning(
+            "Failed to draw the pipeline: could not connect to https://mermaid.ink/img/ ({error})", error=exc
+        )
+        logger.info("Exact URL requested: {url}", url=url)
+        logger.warning("No pipeline diagram will be saved.")
+        raise PipelineDrawingError(
+            "There was an issue with https://mermaid.ink/, see the stacktrace for details."
+        ) from exc
+
+    return resp.content
+
+
+def _to_mermaid_text(graph: networkx.MultiDiGraph) -> str:
+    """
+    Converts a Networkx graph into Mermaid syntax.
+
+    The output of this function can be used in the documentation with `mermaid` codeblocks and will be
+    automatically rendered.
+    """
+    # Copy the graph to avoid modifying the original
+    graph = _prepare_for_drawing(graph.copy())
+    sockets = {
+        comp: "".join(
+            [
+                f"<li>{name} ({_type_name(socket.type)})</li>"
+                for name, socket in data.get("input_sockets", {}).items()
+                if (not socket.is_mandatory and not socket.senders) or socket.is_variadic
+            ]
+        )
+        for comp, data in graph.nodes(data=True)
+    }
+    optional_inputs = {
+        comp: f"<br><br>Optional inputs:<ul style='text-align:left;'>{sockets}</ul>" if sockets else ""
+        for comp, sockets in sockets.items()
+    }
+
+    states = {
+        comp: f"{comp}[\"<b>{comp}</b><br><small><i>{type(data['instance']).__name__}{optional_inputs[comp]}</i></small>\"]:::component"  # noqa
+        for comp, data in graph.nodes(data=True)
+        if comp not in ["input", "output"]
+    }
+
+    connections_list = []
+    for from_comp, to_comp, conn_data in graph.edges(data=True):
+        if from_comp != "input" and to_comp != "output":
+            arrowtail = ARROWTAIL_MANDATORY if conn_data["mandatory"] else ARROWTAIL_OPTIONAL
+            arrowhead = ARROWHEAD_MANDATORY if conn_data["mandatory"] else ARROWHEAD_OPTIONAL
+            label = f'"{conn_data["label"]}<br><small><i>{conn_data["conn_type"]}</i></small>"'
+            conn_string = f"{states[from_comp]} {arrowtail} {label} {arrowhead} {states[to_comp]}"
+            connections_list.append(conn_string)
+
+    input_connections = [
+        f"i{{&ast;}}--\"{conn_data['label']}<br><small><i>{conn_data['conn_type']}</i></small>\"--> {states[to_comp]}"
+        for _, to_comp, conn_data in graph.out_edges("input", data=True)
+    ]
+    output_connections = [
+        f"{states[from_comp]}--\"{conn_data['label']}<br><small><i>{conn_data['conn_type']}</i></small>\"--> o{{&ast;}}"
+        for from_comp, _, conn_data in graph.in_edges("output", data=True)
+    ]
+    connections = "\n".join(connections_list + input_connections + output_connections)
+
+    graph_styled = MERMAID_STYLED_TEMPLATE.format(connections=connections)
+    logger.debug("Mermaid diagram:\n{diagram}", diagram=graph_styled)
+
+    return graph_styled

testbed/deepset-ai__haystack/haystack/core/pipeline/pipeline.py

@@ -0,0 +1,550 @@
+# SPDX-FileCopyrightText: 2022-present deepset GmbH <info@deepset.ai>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from copy import deepcopy
+from typing import Any, Dict, List, Mapping, Optional, Set, Tuple
+from warnings import warn
+
+import networkx as nx
+
+from haystack import logging, tracing
+from haystack.core.component import Component
+from haystack.core.errors import PipelineMaxComponentRuns, PipelineRuntimeError
+from haystack.core.pipeline.base import (
+    _dequeue_component,
+    _dequeue_waiting_component,
+    _enqueue_component,
+    _enqueue_waiting_component,
+)
+from haystack.telemetry import pipeline_running
+
+from .base import PipelineBase, _add_missing_input_defaults, _is_lazy_variadic
+
+logger = logging.getLogger(__name__)
+
+
+class Pipeline(PipelineBase):
+    """
+    Synchronous version of the orchestration engine.
+
+    Orchestrates component execution according to the execution graph, one after the other.
+    """
+
+    def _run_component(
+        self, name: str, inputs: Dict[str, Any], parent_span: Optional[tracing.Span] = None
+    ) -> Dict[str, Any]:
+        """
+        Runs a Component with the given inputs.
+
+        :param name: Name of the Component as defined in the Pipeline.
+        :param inputs: Inputs for the Component.
+        :param parent_span: The parent span to use for the newly created span.
+            This is to allow tracing to be correctly linked to the pipeline run.
+        :raises PipelineRuntimeError: If Component doesn't return a dictionary.
+        :return: The output of the Component.
+        """
+        instance: Component = self.graph.nodes[name]["instance"]
+
+        with tracing.tracer.trace(
+            "haystack.component.run",
+            tags={
+                "haystack.component.name": name,
+                "haystack.component.type": instance.__class__.__name__,
+                "haystack.component.input_types": {k: type(v).__name__ for k, v in inputs.items()},
+                "haystack.component.input_spec": {
+                    key: {
+                        "type": (value.type.__name__ if isinstance(value.type, type) else str(value.type)),
+                        "senders": value.senders,
+                    }
+                    for key, value in instance.__haystack_input__._sockets_dict.items()  # type: ignore
+                },
+                "haystack.component.output_spec": {
+                    key: {
+                        "type": (value.type.__name__ if isinstance(value.type, type) else str(value.type)),
+                        "receivers": value.receivers,
+                    }
+                    for key, value in instance.__haystack_output__._sockets_dict.items()  # type: ignore
+                },
+            },
+            parent_span=parent_span,
+        ) as span:
+            # We deepcopy the inputs otherwise we might lose that information
+            # when we delete them in case they're sent to other Components
+            span.set_content_tag("haystack.component.input", deepcopy(inputs))
+            logger.info("Running component {component_name}", component_name=name)
+            res: Dict[str, Any] = instance.run(**inputs)
+            self.graph.nodes[name]["visits"] += 1
+
+            # After a Component that has variadic inputs is run, we need to reset the variadic inputs that were consumed
+            for socket in instance.__haystack_input__._sockets_dict.values():  # type: ignore
+                if socket.name not in inputs:
+                    continue
+                if socket.is_variadic:
+                    inputs[socket.name] = []
+
+            if not isinstance(res, Mapping):
+                raise PipelineRuntimeError(
+                    f"Component '{name}' didn't return a dictionary. "
+                    "Components must always return dictionaries: check the documentation."
+                )
+            span.set_tag("haystack.component.visits", self.graph.nodes[name]["visits"])
+            span.set_content_tag("haystack.component.output", res)
+
+            return res
+
+    def _run_subgraph(  # noqa: PLR0915
+        self,
+        cycle: List[str],
+        component_name: str,
+        components_inputs: Dict[str, Dict[str, Any]],
+        include_outputs_from: Optional[Set[str]] = None,
+    ) -> Tuple[Dict[str, Any], Dict[str, Any]]:
+        """
+        Runs a `cycle` in the Pipeline starting from `component_name`.
+
+        This will return once there are no inputs for the Components in `cycle`.
+
+        This is an internal method meant to be used in `Pipeline.run()` only.
+
+        :param cycle:
+            List of Components that are part of the cycle being run
+        :param component_name:
+            Name of the Component that will start execution of the cycle
+        :param components_inputs:
+            Components inputs, this might include inputs for Components that are not part
+            of the cycle but part of the wider Pipeline's graph
+        :param include_outputs_from:
+            Set of component names whose individual outputs are to be
+            included in the cycle's output. In case a Component is executed multiple times
+            only the last-produced output is included.
+        :returns:
+            Outputs of all the Components that are not connected to other Components in `cycle`.
+            If `include_outputs_from` is set those Components' outputs will be included.
+        :raises PipelineMaxComponentRuns:
+            If a Component reaches the maximum number of times it can be run in this Pipeline
+        """
+        waiting_queue: List[Tuple[str, Component]] = []
+        run_queue: List[Tuple[str, Component]] = []
+
+        # Create the run queue starting with the component that needs to run first
+        start_index = cycle.index(component_name)
+        for node in cycle[start_index:]:
+            run_queue.append((node, self.graph.nodes[node]["instance"]))
+
+        include_outputs_from = set() if include_outputs_from is None else include_outputs_from
+
+        before_last_waiting_queue: Optional[Set[str]] = None
+        last_waiting_queue: Optional[Set[str]] = None
+
+        subgraph_outputs = {}
+        # These are outputs that are sent to other Components but the user explicitly
+        # asked to include them in the final output.
+        extra_outputs = {}
+
+        # This variable is used to keep track if we still need to run the cycle or not.
+        # When a Component doesn't send outputs to another Component
+        # that's inside the subgraph, we stop running this subgraph.
+        cycle_received_inputs = False
+
+        while not cycle_received_inputs:
+            # Here we run the Components
+            name, comp = run_queue.pop(0)
+            if _is_lazy_variadic(comp) and not all(_is_lazy_variadic(comp) for _, comp in run_queue):
+                # We run Components with lazy variadic inputs only if there only Components with
+                # lazy variadic inputs left to run
+                _enqueue_waiting_component((name, comp), waiting_queue)
+                continue
+
+            # As soon as a Component returns only output that is not part of the cycle, we can stop
+            if self._component_has_enough_inputs_to_run(name, components_inputs):
+                if self.graph.nodes[name]["visits"] > self._max_runs_per_component:
+                    msg = f"Maximum run count {self._max_runs_per_component} reached for component '{name}'"
+                    raise PipelineMaxComponentRuns(msg)
+
+                res: Dict[str, Any] = self._run_component(name, components_inputs[name])
+
+                # Delete the inputs that were consumed by the Component and are not received from
+                # the user or from Components that are part of this cycle
+                sockets = list(components_inputs[name].keys())
+                for socket_name in sockets:
+                    senders = comp.__haystack_input__._sockets_dict[socket_name].senders  # type: ignore
+                    if not senders:
+                        # We keep inputs that came from the user
+                        continue
+                    all_senders_in_cycle = all(sender in cycle for sender in senders)
+                    if all_senders_in_cycle:
+                        # All senders are in the cycle, we can remove the input.
+                        # We'll receive it later at a certain point.
+                        del components_inputs[name][socket_name]
+
+                if name in include_outputs_from:
+                    # Deepcopy the outputs to prevent downstream nodes from modifying them
+                    # We don't care about loops - Always store the last output.
+                    extra_outputs[name] = deepcopy(res)
+
+                # Reset the waiting for input previous states, we managed to run a component
+                before_last_waiting_queue = None
+                last_waiting_queue = None
+
+                # Check if a component doesn't send any output to components that are part of the cycle
+                final_output_reached = False
+                for output_socket in res.keys():
+                    for receiver in comp.__haystack_output__._sockets_dict[output_socket].receivers:  # type: ignore
+                        if receiver in cycle:
+                            final_output_reached = True
+                            break
+                    if final_output_reached:
+                        break
+
+                if not final_output_reached:
+                    # We stop only if the Component we just ran doesn't send any output to sockets that
+                    # are part of the cycle
+                    cycle_received_inputs = True
+
+                # We manage to run this component that was in the waiting list, we can remove it.
+                # This happens when a component was put in the waiting list but we reached it from another edge.
+                _dequeue_waiting_component((name, comp), waiting_queue)
+                for pair in self._find_components_that_will_receive_no_input(name, res, components_inputs):
+                    _dequeue_component(pair, run_queue, waiting_queue)
+
+                receivers = [item for item in self._find_receivers_from(name) if item[0] in cycle]
+
+                res = self._distribute_output(receivers, res, components_inputs, run_queue, waiting_queue)
+
+                # We treat a cycle as a completely independent graph, so we keep track of output
+                # that is not sent inside the cycle.
+                # This output is going to get distributed to the wider graph after we finish running
+                # a cycle.
+                # All values that are left at this point go outside the cycle.
+                if len(res) > 0:
+                    subgraph_outputs[name] = res
+            else:
+                # This component doesn't have enough inputs so we can't run it yet
+                _enqueue_waiting_component((name, comp), waiting_queue)
+
+            if len(run_queue) == 0 and len(waiting_queue) > 0:
+                # Check if we're stuck in a loop.
+                # It's important to check whether previous waitings are None as it could be that no
+                # Component has actually been run yet.
+                if (
+                    before_last_waiting_queue is not None
+                    and last_waiting_queue is not None
+                    and before_last_waiting_queue == last_waiting_queue
+                ):
+                    if self._is_stuck_in_a_loop(waiting_queue):
+                        # We're stuck! We can't make any progress.
+                        msg = (
+                            "Pipeline is stuck running in a loop. Partial outputs will be returned. "
+                            "Check the Pipeline graph for possible issues."
+                        )
+                        warn(RuntimeWarning(msg))
+                        break
+
+                    (name, comp) = self._find_next_runnable_lazy_variadic_or_default_component(waiting_queue)
+                    _add_missing_input_defaults(name, comp, components_inputs)
+                    _enqueue_component((name, comp), run_queue, waiting_queue)
+                    continue
+
+                before_last_waiting_queue = last_waiting_queue.copy() if last_waiting_queue is not None else None
+                last_waiting_queue = {item[0] for item in waiting_queue}
+
+                (name, comp) = self._find_next_runnable_component(components_inputs, waiting_queue)
+                _add_missing_input_defaults(name, comp, components_inputs)
+                _enqueue_component((name, comp), run_queue, waiting_queue)
+
+        return subgraph_outputs, extra_outputs
+
+    def run(  # noqa: PLR0915, PLR0912
+        self, data: Dict[str, Any], include_outputs_from: Optional[Set[str]] = None
+    ) -> Dict[str, Any]:
+        """
+        Runs the Pipeline with given input data.
+
+        Usage:
+        ```python
+        from haystack import Pipeline, Document
+        from haystack.utils import Secret
+        from haystack.document_stores.in_memory import InMemoryDocumentStore
+        from haystack.components.retrievers.in_memory import InMemoryBM25Retriever
+        from haystack.components.generators import OpenAIGenerator
+        from haystack.components.builders.answer_builder import AnswerBuilder
+        from haystack.components.builders.prompt_builder import PromptBuilder
+
+        # Write documents to InMemoryDocumentStore
+        document_store = InMemoryDocumentStore()
+        document_store.write_documents([
+            Document(content="My name is Jean and I live in Paris."),
+            Document(content="My name is Mark and I live in Berlin."),
+            Document(content="My name is Giorgio and I live in Rome.")
+        ])
+
+        prompt_template = \"\"\"
+        Given these documents, answer the question.
+        Documents:
+        {% for doc in documents %}
+            {{ doc.content }}
+        {% endfor %}
+        Question: {{question}}
+        Answer:
+        \"\"\"
+
+        retriever = InMemoryBM25Retriever(document_store=document_store)
+        prompt_builder = PromptBuilder(template=prompt_template)
+        llm = OpenAIGenerator(api_key=Secret.from_token(api_key))
+
+        rag_pipeline = Pipeline()
+        rag_pipeline.add_component("retriever", retriever)
+        rag_pipeline.add_component("prompt_builder", prompt_builder)
+        rag_pipeline.add_component("llm", llm)
+        rag_pipeline.connect("retriever", "prompt_builder.documents")
+        rag_pipeline.connect("prompt_builder", "llm")
+
+        # Ask a question
+        question = "Who lives in Paris?"
+        results = rag_pipeline.run(
+            {
+                "retriever": {"query": question},
+                "prompt_builder": {"question": question},
+            }
+        )
+
+        print(results["llm"]["replies"])
+        # Jean lives in Paris
+        ```
+
+        :param data:
+            A dictionary of inputs for the pipeline's components. Each key is a component name
+            and its value is a dictionary of that component's input parameters:
+            ```
+            data = {
+                "comp1": {"input1": 1, "input2": 2},
+            }
+            ```
+            For convenience, this format is also supported when input names are unique:
+            ```
+            data = {
+                "input1": 1, "input2": 2,
+            }
+            ```
+        :param include_outputs_from:
+            Set of component names whose individual outputs are to be
+            included in the pipeline's output. For components that are
+            invoked multiple times (in a loop), only the last-produced
+            output is included.
+        :returns:
+            A dictionary where each entry corresponds to a component name
+            and its output. If `include_outputs_from` is `None`, this dictionary
+            will only contain the outputs of leaf components, i.e., components
+            without outgoing connections.
+
+        :raises PipelineRuntimeError:
+            If the Pipeline contains cycles with unsupported connections that would cause
+            it to get stuck and fail running.
+            Or if a Component fails or returns output in an unsupported type.
+        :raises PipelineMaxComponentRuns:
+            If a Component reaches the maximum number of times it can be run in this Pipeline.
+        """
+        pipeline_running(self)
+
+        # Reset the visits count for each component
+        self._init_graph()
+
+        # TODO: Remove this warmup once we can check reliably whether a component has been warmed up or not
+        # As of now it's here to make sure we don't have failing tests that assume warm_up() is called in run()
+        self.warm_up()
+
+        # normalize `data`
+        data = self._prepare_component_input_data(data)
+
+        # Raise if input is malformed in some way
+        self._validate_input(data)
+
+        # Normalize the input data
+        components_inputs: Dict[str, Dict[str, Any]] = self._normalize_varidiac_input_data(data)
+
+        # These variables are used to detect when we're stuck in a loop.
+        # Stuck loops can happen when one or more components are waiting for input but
+        # no other component is going to run.
+        # This can happen when a whole branch of the graph is skipped for example.
+        # When we find that two consecutive iterations of the loop where the waiting_queue is the same,
+        # we know we're stuck in a loop and we can't make any progress.
+        #
+        # They track the previous two states of the waiting_queue. So if waiting_queue would n,
+        # before_last_waiting_queue would be n-2 and last_waiting_queue would be n-1.
+        # When we run a component, we reset both.
+        before_last_waiting_queue: Optional[Set[str]] = None
+        last_waiting_queue: Optional[Set[str]] = None
+
+        # The waiting_for_input list is used to keep track of components that are waiting for input.
+        waiting_queue: List[Tuple[str, Component]] = []
+
+        include_outputs_from = set() if include_outputs_from is None else include_outputs_from
+
+        # This is what we'll return at the end
+        final_outputs: Dict[Any, Any] = {}
+
+        # Break cycles in case there are, this is a noop if no cycle is found.
+        # This will raise if a cycle can't be broken.
+        graph_without_cycles, components_in_cycles = self._break_supported_cycles_in_graph()
+
+        run_queue: List[Tuple[str, Component]] = []
+        for node in nx.topological_sort(graph_without_cycles):
+            run_queue.append((node, self.graph.nodes[node]["instance"]))
+
+        # Set defaults inputs for those sockets that don't receive input neither from the user
+        # nor from other Components.
+        # If they have no default nothing is done.
+        # This is important to ensure correct order execution, otherwise some variadic
+        # Components that receive input from the user might be run before than they should.
+        for name, comp in self.graph.nodes(data="instance"):
+            if name not in components_inputs:
+                components_inputs[name] = {}
+            for socket_name, socket in comp.__haystack_input__._sockets_dict.items():
+                if socket_name in components_inputs[name]:
+                    continue
+                if not socket.senders:
+                    value = socket.default_value
+                    if socket.is_variadic:
+                        value = [value]
+                    components_inputs[name][socket_name] = value
+
+        with tracing.tracer.trace(
+            "haystack.pipeline.run",
+            tags={
+                "haystack.pipeline.input_data": data,
+                "haystack.pipeline.output_data": final_outputs,
+                "haystack.pipeline.metadata": self.metadata,
+                "haystack.pipeline.max_runs_per_component": self._max_runs_per_component,
+            },
+        ) as span:
+            # Cache for extra outputs, if enabled.
+            extra_outputs: Dict[Any, Any] = {}
+
+            while len(run_queue) > 0:
+                name, comp = run_queue.pop(0)
+
+                if _is_lazy_variadic(comp) and not all(_is_lazy_variadic(comp) for _, comp in run_queue):
+                    # We run Components with lazy variadic inputs only if there only Components with
+                    # lazy variadic inputs left to run
+                    _enqueue_waiting_component((name, comp), waiting_queue)
+                    continue
+                if self._component_has_enough_inputs_to_run(name, components_inputs) and components_in_cycles.get(
+                    name, []
+                ):
+                    cycles = components_in_cycles.get(name, [])
+
+                    # This component is part of one or more cycles, let's get the first one and run it.
+                    # We can reliably pick any of the cycles if there are multiple ones, the way cycles
+                    # are run doesn't make a different whether we pick the first or any of the others a
+                    # Component is part of.
+                    subgraph_output, subgraph_extra_output = self._run_subgraph(
+                        cycles[0], name, components_inputs, include_outputs_from
+                    )
+
+                    # After a cycle is run the previous run_queue can't be correct anymore cause it's
+                    # not modified when running the subgraph.
+                    # So we reset it given the output returned by the subgraph.
+                    run_queue = []
+
+                    # Reset the waiting for input previous states, we managed to run at least one component
+                    before_last_waiting_queue = None
+                    last_waiting_queue = None
+
+                    # Merge the extra outputs
+                    extra_outputs.update(subgraph_extra_output)
+
+                    for component_name, component_output in subgraph_output.items():
+                        receivers = self._find_receivers_from(component_name)
+                        component_output = self._distribute_output(
+                            receivers, component_output, components_inputs, run_queue, waiting_queue
+                        )
+
+                        if len(component_output) > 0:
+                            final_outputs[component_name] = component_output
+
+                elif self._component_has_enough_inputs_to_run(name, components_inputs):
+                    if self.graph.nodes[name]["visits"] > self._max_runs_per_component:
+                        msg = f"Maximum run count {self._max_runs_per_component} reached for component '{name}'"
+                        raise PipelineMaxComponentRuns(msg)
+
+                    res: Dict[str, Any] = self._run_component(name, components_inputs[name], parent_span=span)
+
+                    # Delete the inputs that were consumed by the Component and are not received from the user
+                    sockets = list(components_inputs[name].keys())
+                    for socket_name in sockets:
+                        senders = comp.__haystack_input__._sockets_dict[socket_name].senders
+                        if senders:
+                            # Delete all inputs that are received from other Components
+                            del components_inputs[name][socket_name]
+                        # We keep inputs that came from the user
+
+                    if name in include_outputs_from:
+                        # Deepcopy the outputs to prevent downstream nodes from modifying them
+                        # We don't care about loops - Always store the last output.
+                        extra_outputs[name] = deepcopy(res)
+
+                    # Reset the waiting for input previous states, we managed to run a component
+                    before_last_waiting_queue = None
+                    last_waiting_queue = None
+
+                    # We manage to run this component that was in the waiting list, we can remove it.
+                    # This happens when a component was put in the waiting list but we reached it from another edge.
+                    _dequeue_waiting_component((name, comp), waiting_queue)
+
+                    for pair in self._find_components_that_will_receive_no_input(name, res, components_inputs):
+                        _dequeue_component(pair, run_queue, waiting_queue)
+                    receivers = self._find_receivers_from(name)
+                    res = self._distribute_output(receivers, res, components_inputs, run_queue, waiting_queue)
+
+                    if len(res) > 0:
+                        final_outputs[name] = res
+                else:
+                    # This component doesn't have enough inputs so we can't run it yet
+                    _enqueue_waiting_component((name, comp), waiting_queue)
+
+                if len(run_queue) == 0 and len(waiting_queue) > 0:
+                    # Check if we're stuck in a loop.
+                    # It's important to check whether previous waitings are None as it could be that no
+                    # Component has actually been run yet.
+                    if (
+                        before_last_waiting_queue is not None
+                        and last_waiting_queue is not None
+                        and before_last_waiting_queue == last_waiting_queue
+                    ):
+                        if self._is_stuck_in_a_loop(waiting_queue):
+                            # We're stuck! We can't make any progress.
+                            msg = (
+                                "Pipeline is stuck running in a loop. Partial outputs will be returned. "
+                                "Check the Pipeline graph for possible issues."
+                            )
+                            warn(RuntimeWarning(msg))
+                            break
+
+                        (name, comp) = self._find_next_runnable_lazy_variadic_or_default_component(waiting_queue)
+                        _add_missing_input_defaults(name, comp, components_inputs)
+                        _enqueue_component((name, comp), run_queue, waiting_queue)
+                        continue
+
+                    before_last_waiting_queue = last_waiting_queue.copy() if last_waiting_queue is not None else None
+                    last_waiting_queue = {item[0] for item in waiting_queue}
+
+                    (name, comp) = self._find_next_runnable_component(components_inputs, waiting_queue)
+                    _add_missing_input_defaults(name, comp, components_inputs)
+                    _enqueue_component((name, comp), run_queue, waiting_queue)
+
+            if len(include_outputs_from) > 0:
+                for name, output in extra_outputs.items():
+                    inner = final_outputs.get(name)
+                    if inner is None:
+                        final_outputs[name] = output
+                    else:
+                        # Let's not override any keys that are already
+                        # in the final_outputs as they might be different
+                        # from what we cached in extra_outputs, e.g. when loops
+                        # are involved.
+                        for k, v in output.items():
+                            if k not in inner:
+                                inner[k] = v
+
+            return final_outputs

testbed/deepset-ai__haystack/haystack/core/pipeline/predefined/chat_with_website.yaml.jinja2

@@ -0,0 +1,52 @@
+components:
+  converter:
+    type: haystack.components.converters.html.HTMLToDocument
+    init_parameters:
+      extraction_kwargs: null
+
+  fetcher:
+    init_parameters:
+      raise_on_failure: true
+      retry_attempts: 2
+      timeout: 3
+      user_agents:
+      - haystack/LinkContentFetcher/2.0.0b8
+    type: haystack.components.fetchers.link_content.LinkContentFetcher
+
+  llm:
+    init_parameters:
+      api_base_url: null
+      api_key:
+        env_vars:
+        - OPENAI_API_KEY
+        strict: true
+        type: env_var
+      generation_kwargs: {}
+      model: gpt-4o-mini
+      streaming_callback: null
+      system_prompt: null
+    type: haystack.components.generators.openai.OpenAIGenerator
+
+  prompt:
+    init_parameters:
+      template: |
+      {% raw %}
+        "According to the contents of this website:
+        {% for document in documents %}
+          {{document.content}}
+        {% endfor %}
+        Answer the given question: {{query}}
+        Answer:
+        "
+      {% endraw %}
+    type: haystack.components.builders.prompt_builder.PromptBuilder
+
+connections:
+- receiver: converter.sources
+  sender: fetcher.streams
+- receiver: prompt.documents
+  sender: converter.documents
+- receiver: llm.prompt
+  sender: prompt.prompt
+
+metadata: {}

testbed/deepset-ai__haystack/haystack/core/pipeline/predefined/generative_qa.yaml.jinja2

@@ -0,0 +1,24 @@
+---
+
+components:
+  generator:
+    init_parameters:
+      api_key:
+        env_vars: [ "OPENAI_API_KEY" ]
+        strict: true
+        type: "env_var"
+      model: "gpt-4o-mini"
+    type: "haystack.components.generators.openai.OpenAIGenerator"
+
+  prompt_builder:
+    init_parameters:
+      template: "{% raw %}Answer the question {{question}}.\n Answer:\n{% endraw %}"
+    type: "haystack.components.builders.prompt_builder.PromptBuilder"
+
+
+connections:
+- receiver: generator.prompt
+  sender: prompt_builder.prompt
+
+metadata:
+  {}

testbed/deepset-ai__haystack/haystack/core/pipeline/predefined/indexing.yaml.jinja2

@@ -0,0 +1,67 @@
+---
+
+components:
+  cleaner:
+    init_parameters:
+      remove_empty_lines: true
+      remove_extra_whitespaces: true
+      remove_regex: null
+      remove_repeated_substrings: false
+      remove_substrings: null
+    type: haystack.components.preprocessors.document_cleaner.DocumentCleaner
+
+  converter:
+    init_parameters:
+      encoding: utf-8
+    type: haystack.components.converters.txt.TextFileToDocument
+
+  embedder:
+    init_parameters:
+      api_base_url: null
+      api_key:
+        env_vars:
+        - OPENAI_API_KEY
+        strict: true
+        type: env_var
+      batch_size: 32
+      dimensions: null
+      embedding_separator: '\n'
+      meta_fields_to_embed: []
+      model: text-embedding-ada-002
+      organization: null
+      prefix: ''
+      progress_bar: true
+      suffix: ''
+    type: haystack.components.embedders.openai_document_embedder.OpenAIDocumentEmbedder
+
+  splitter:
+    init_parameters:
+      split_by: word
+      split_length: 200
+      split_overlap: 0
+    type: haystack.components.preprocessors.document_splitter.DocumentSplitter
+
+  writer:
+    init_parameters:
+      document_store:
+        init_parameters:
+          bm25_tokenization_regex: (?u)\b\w\w+\b
+          bm25_algorithm: BM25L
+          bm25_parameters: {}
+          embedding_similarity_function: dot_product
+          index: documents
+        type: haystack.document_stores.in_memory.document_store.InMemoryDocumentStore
+      policy: NONE
+    type: haystack.components.writers.document_writer.DocumentWriter
+
+connections:
+- receiver: cleaner.documents
+  sender: converter.documents
+- receiver: splitter.documents
+  sender: cleaner.documents
+- receiver: embedder.documents
+  sender: splitter.documents
+- receiver: writer.documents
+  sender: embedder.documents
+
+metadata: {}

testbed/deepset-ai__haystack/haystack/core/pipeline/predefined/rag.yaml.jinja2

@@ -0,0 +1,70 @@
+---
+
+components:
+  llm:
+    init_parameters:
+      api_base_url: null
+      api_key:
+        env_vars:
+        - OPENAI_API_KEY
+        strict: true
+        type: env_var
+      generation_kwargs: {}
+      model: gpt-4o-mini
+      streaming_callback: null
+      system_prompt: null
+    type: haystack.components.generators.openai.OpenAIGenerator
+
+  prompt_builder:
+    init_parameters:
+      template: |
+      {% raw %}
+        "Given these documents, answer the question.
+        Documents:
+        {% for doc in documents %}\
+        {{ doc.content }}
+        {% endfor %}
+        Question: {{query}}
+
+        Answer:"
+      {% endraw %}
+    type: haystack.components.builders.prompt_builder.PromptBuilder
+
+  retriever:
+    init_parameters:
+      document_store:
+        init_parameters:
+          bm25_tokenization_regex: (?u)\b\w\w+\b
+          bm25_algorithm: BM25L
+          bm25_parameters: {}
+          embedding_similarity_function: dot_product
+          index: documents
+        type: haystack.document_stores.in_memory.document_store.InMemoryDocumentStore
+      filters: null
+      top_k: 10
+    type: haystack.components.retrievers.in_memory.embedding_retriever.InMemoryEmbeddingRetriever
+
+  text_embedder:
+    init_parameters:
+      api_base_url: null
+      api_key:
+        env_vars:
+        - OPENAI_API_KEY
+        strict: true
+        type: env_var
+      dimensions: null
+      model: text-embedding-ada-002
+      organization: null
+      prefix: ''
+      suffix: ''
+    type: haystack.components.embedders.openai_text_embedder.OpenAITextEmbedder
+
+connections:
+- receiver: retriever.query_embedding
+  sender: text_embedder.embedding
+- receiver: prompt_builder.documents
+  sender: retriever.documents
+- receiver: llm.prompt
+  sender: prompt_builder.prompt
+
+metadata: {}

testbed/deepset-ai__haystack/haystack/core/pipeline/template.py

@@ -0,0 +1,130 @@
+# SPDX-FileCopyrightText: 2022-present deepset GmbH <info@deepset.ai>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from enum import Enum
+from pathlib import Path
+from typing import Any, Dict, Optional, Union
+
+from jinja2 import PackageLoader, TemplateSyntaxError, meta
+from jinja2.sandbox import SandboxedEnvironment
+
+TEMPLATE_FILE_EXTENSION = ".yaml.jinja2"
+TEMPLATE_HOME_DIR = Path(__file__).resolve().parent / "predefined"
+
+
+class PredefinedPipeline(Enum):
+    """
+    Enumeration of predefined pipeline templates that can be used to create a `PipelineTemplate`.
+    """
+
+    # Maintain 1-to-1 mapping between the enum name and the template file name in templates directory
+    GENERATIVE_QA = "generative_qa"
+    RAG = "rag"
+    INDEXING = "indexing"
+    CHAT_WITH_WEBSITE = "chat_with_website"
+
+
+class PipelineTemplate:
+    """
+    The PipelineTemplate enables the creation of flexible and configurable pipelines.
+
+    The PipelineTemplate class enables the straightforward creation of flexible and configurable pipelines using
+    Jinja2 templated YAML files. Specifically designed to simplify the setup of complex data processing pipelines for
+    a range of NLP tasks—including question answering, retriever augmented generation (RAG), document indexing, among
+    others - PipelineTemplate empowers users to dynamically generate pipeline configurations from templates and
+    customize components as necessary. Its design philosophy centers on providing an accessible, yet powerful, tool
+    for constructing pipelines that accommodate both common use cases and specialized requirements with ease.
+
+    Examples of usage:
+
+    - **Default Build**: Instantiating a pipeline with default settings for a "question answering" (qa) task.
+      ```python
+      from haystack.templates import PipelineTemplate, PredefinedPipeline
+
+      # Create a pipeline with default components for an extractive QA task
+      pipe = PipelineTemplate.from_predefined(PredefinedPipeline.GENERATIVE_QA).build()
+      print(pipe.run(data={"question": "What's the capital of Bosnia and Herzegovina? Be brief"}))
+      ```
+
+    - **Customizing for Specific Tasks**: Building a pipeline for document indexing with specific components tailored
+    to the task.
+      ```python
+      from haystack.components.embedders import SentenceTransformersDocumentEmbedder
+      from haystack.templates import PipelineTemplate, PredefinedPipeline
+
+      # Customize the pipeline for document indexing with specific components, include PDF file converter
+      pt = PipelineTemplate.from_predefined(PredefinedTemplate.INDEXING)
+      pipe = pt.build(template_params={"use_pdf_file_converter": True})
+
+      result = pipe.run(data={"sources": ["some_text_file.txt", "another_pdf_file.pdf"]})
+      print(result)
+      ```
+
+    The `PipelineTemplate` is designed to offer both ease of use for common pipeline configurations and the
+    flexibility to customize and extend pipelines as required by advanced users and specific use cases.
+    """
+
+    def __init__(self, template_content: str):
+        """
+        Initialize a PipelineTemplate.
+
+        Besides calling the constructor directly, a set of utility methods is provided to conveniently create an
+        instance of `PipelineTemplate` from different sources. See `from_string`, `from_file`, `from_predefined`
+        and `from_url`.
+
+        :param template_content: The raw template source to use in the template.
+        """
+        env = SandboxedEnvironment(
+            loader=PackageLoader("haystack.core.pipeline", "predefined"), trim_blocks=True, lstrip_blocks=True
+        )
+        try:
+            self._template = env.from_string(template_content)
+        except TemplateSyntaxError as e:
+            raise ValueError(f"Invalid pipeline template: {e.message}") from e
+
+        # Store the list of undefined variables in the template. Components' names will be part of this list
+        self.template_variables = meta.find_undeclared_variables(env.parse(template_content))
+        self._template_content = template_content
+
+    def render(self, template_params: Optional[Dict[str, Any]] = None) -> str:
+        """
+        Constructs a `Pipeline` instance based on the template.
+
+        :param template_params: An optional dictionary of parameters to use when rendering the pipeline template.
+
+        :returns: An instance of `Pipeline` constructed from the rendered template and custom component configurations.
+        """
+        template_params = template_params or {}
+        return self._template.render(**template_params)
+
+    @classmethod
+    def from_file(cls, file_path: Union[Path, str]) -> "PipelineTemplate":
+        """
+        Create a PipelineTemplate from a file.
+
+        :param file_path: The path to the file containing the template. Must contain valid Jinja2 syntax.
+        :returns: An instance of `PipelineTemplate`.
+        """
+        with open(file_path, "r") as file:
+            return cls(file.read())
+
+    @classmethod
+    def from_predefined(cls, predefined_pipeline: PredefinedPipeline) -> "PipelineTemplate":
+        """
+        Create a PipelineTemplate from a predefined template.
+
+        See `PredefinedPipeline` for available options.
+
+        :param predefined_pipeline: The predefined pipeline to use.
+        :returns: An instance of `PipelineTemplate `.
+        """
+        template_path = f"{TEMPLATE_HOME_DIR}/{predefined_pipeline.value}{TEMPLATE_FILE_EXTENSION}"
+        return cls.from_file(template_path)
+
+    @property
+    def template_content(self) -> str:
+        """
+        Returns the raw template string as a read-only property.
+        """
+        return self._template_content

testbed/deepset-ai__haystack/haystack/core/pipeline/utils.py

@@ -0,0 +1,20 @@
+# SPDX-FileCopyrightText: 2022-present deepset GmbH <info@deepset.ai>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from typing import Optional, Tuple
+
+
+def parse_connect_string(connection: str) -> Tuple[str, Optional[str]]:
+    """
+    Returns component-connection pairs from a connect_to/from string.
+
+    :param connection:
+        The connection string.
+    :returns:
+        A tuple containing the component name and the connection name.
+    """
+    if "." in connection:
+        split_str = connection.split(".", maxsplit=1)
+        return (split_str[0], split_str[1])
+    return connection, None

testbed/deepset-ai__haystack/haystack/core/serialization.py

@@ -0,0 +1,259 @@
+# SPDX-FileCopyrightText: 2022-present deepset GmbH <info@deepset.ai>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+import inspect
+from collections.abc import Callable
+from dataclasses import dataclass
+from importlib import import_module
+from typing import Any, Dict, Iterable, Optional, Type
+
+from haystack.core.component.component import _hook_component_init, logger
+from haystack.core.errors import DeserializationError, SerializationError
+
+
+@dataclass(frozen=True)
+class DeserializationCallbacks:
+    """
+    Callback functions that are invoked in specific stages of the pipeline deserialization process.
+
+    :param component_pre_init:
+        Invoked just before a component instance is
+        initialized. Receives the following inputs:
+        `component_name` (`str`), `component_class` (`Type`), `init_params` (`Dict[str, Any]`).
+
+        The callback is allowed to modify the `init_params`
+        dictionary, which contains all the parameters that
+        are passed to the component's constructor.
+    """
+
+    component_pre_init: Optional[Callable] = None
+
+
+def component_to_dict(obj: Any, name: str) -> Dict[str, Any]:
+    """
+    Converts a component instance into a dictionary.
+
+    If a `to_dict` method is present in the component instance, that will be used instead of the default method.
+
+    :param obj:
+        The component to be serialized.
+    :param name:
+        The name of the component.
+    :returns:
+        A dictionary representation of the component.
+
+    :raises SerializationError:
+        If the component doesn't have a `to_dict` method.
+        If the values of the init parameters can't be determined.
+        If a non-basic Python type is used in the serialized data.
+    """
+    if hasattr(obj, "to_dict"):
+        data = obj.to_dict()
+    else:
+        init_parameters = {}
+        for param_name, param in inspect.signature(obj.__init__).parameters.items():
+            # Ignore `args` and `kwargs`, used by the default constructor
+            if param_name in ("args", "kwargs"):
+                continue
+            try:
+                # This only works if the Component constructor assigns the init
+                # parameter to an instance variable or property with the same name
+                param_value = getattr(obj, param_name)
+            except AttributeError as e:
+                # If the parameter doesn't have a default value, raise an error
+                if param.default is param.empty:
+                    raise SerializationError(
+                        f"Cannot determine the value of the init parameter '{param_name}' "
+                        f"for the class {obj.__class__.__name__}."
+                        f"You can fix this error by assigning 'self.{param_name} = {param_name}' or adding a "
+                        f"custom serialization method 'to_dict' to the class."
+                    ) from e
+                # In case the init parameter was not assigned, we use the default value
+                param_value = param.default
+            init_parameters[param_name] = param_value
+
+        data = default_to_dict(obj, **init_parameters)
+
+    _validate_component_to_dict_output(obj, name, data)
+    return data
+
+
+def _validate_component_to_dict_output(component: Any, name: str, data: Dict[str, Any]) -> None:
+    # Ensure that only basic Python types are used in the serde data.
+    def is_allowed_type(obj: Any) -> bool:
+        return isinstance(obj, (str, int, float, bool, list, dict, set, tuple, type(None)))
+
+    def check_iterable(l: Iterable[Any]):
+        for v in l:
+            if not is_allowed_type(v):
+                raise SerializationError(
+                    f"Component '{name}' of type '{type(component).__name__}' has an unsupported value "
+                    f"of type '{type(v).__name__}' in the serialized data."
+                )
+            if isinstance(v, (list, set, tuple)):
+                check_iterable(v)
+            elif isinstance(v, dict):
+                check_dict(v)
+
+    def check_dict(d: Dict[str, Any]):
+        if any(not isinstance(k, str) for k in data.keys()):
+            raise SerializationError(
+                f"Component '{name}' of type '{type(component).__name__}' has a non-string key in the serialized data."
+            )
+
+        for k, v in d.items():
+            if not is_allowed_type(v):
+                raise SerializationError(
+                    f"Component '{name}' of type '{type(component).__name__}' has an unsupported value "
+                    f"of type '{type(v).__name__}' in the serialized data under key '{k}'."
+                )
+            if isinstance(v, (list, set, tuple)):
+                check_iterable(v)
+            elif isinstance(v, dict):
+                check_dict(v)
+
+    check_dict(data)
+
+
+def generate_qualified_class_name(cls: Type[object]) -> str:
+    """
+    Generates a qualified class name for a class.
+
+    :param cls:
+        The class whose qualified name is to be generated.
+    :returns:
+        The qualified name of the class.
+    """
+    return f"{cls.__module__}.{cls.__name__}"
+
+
+def component_from_dict(
+    cls: Type[object], data: Dict[str, Any], name: str, callbacks: Optional[DeserializationCallbacks] = None
+) -> Any:
+    """
+    Creates a component instance from a dictionary.
+
+    If a `from_dict` method is present in the component class, that will be used instead of the default method.
+
+    :param cls:
+        The class to be used for deserialization.
+    :param data:
+        The serialized data.
+    :param name:
+        The name of the component.
+    :param callbacks:
+        Callbacks to invoke during deserialization.
+    :returns:
+        The deserialized component.
+    """
+
+    def component_pre_init_callback(component_cls, init_params):
+        assert callbacks is not None
+        assert callbacks.component_pre_init is not None
+        callbacks.component_pre_init(name, component_cls, init_params)
+
+    def do_from_dict():
+        if hasattr(cls, "from_dict"):
+            return cls.from_dict(data)
+
+        return default_from_dict(cls, data)
+
+    if callbacks is None or callbacks.component_pre_init is None:
+        return do_from_dict()
+
+    with _hook_component_init(component_pre_init_callback):
+        return do_from_dict()
+
+
+def default_to_dict(obj: Any, **init_parameters) -> Dict[str, Any]:
+    """
+    Utility function to serialize an object to a dictionary.
+
+    This is mostly necessary for components but can be used by any object.
+    `init_parameters` are parameters passed to the object class `__init__`.
+    They must be defined explicitly as they'll be used when creating a new
+    instance of `obj` with `from_dict`. Omitting them might cause deserialisation
+    errors or unexpected behaviours later, when calling `from_dict`.
+
+    An example usage:
+
+    ```python
+    class MyClass:
+        def __init__(self, my_param: int = 10):
+            self.my_param = my_param
+
+        def to_dict(self):
+            return default_to_dict(self, my_param=self.my_param)
+
+
+    obj = MyClass(my_param=1000)
+    data = obj.to_dict()
+    assert data == {
+        "type": "MyClass",
+        "init_parameters": {
+            "my_param": 1000,
+        },
+    }
+    ```
+
+    :param obj:
+        The object to be serialized.
+    :param init_parameters:
+        The parameters used to create a new instance of the class.
+    :returns:
+        A dictionary representation of the instance.
+    """
+    return {"type": generate_qualified_class_name(type(obj)), "init_parameters": init_parameters}
+
+
+def default_from_dict(cls: Type[object], data: Dict[str, Any]) -> Any:
+    """
+    Utility function to deserialize a dictionary to an object.
+
+    This is mostly necessary for components but can be used by any object.
+
+    The function will raise a `DeserializationError` if the `type` field in `data` is
+    missing or it doesn't match the type of `cls`.
+
+    If `data` contains an `init_parameters` field it will be used as parameters to create
+    a new instance of `cls`.
+
+    :param cls:
+        The class to be used for deserialization.
+    :param data:
+        The serialized data.
+    :returns:
+        The deserialized object.
+
+    :raises DeserializationError:
+        If the `type` field in `data` is missing or it doesn't match the type of `cls`.
+    """
+    init_params = data.get("init_parameters", {})
+    if "type" not in data:
+        raise DeserializationError("Missing 'type' in serialization data")
+    if data["type"] != generate_qualified_class_name(cls):
+        raise DeserializationError(f"Class '{data['type']}' can't be deserialized as '{cls.__name__}'")
+    return cls(**init_params)
+
+
+def import_class_by_name(fully_qualified_name: str) -> Type[object]:
+    """
+    Utility function to import (load) a class object based on its fully qualified class name.
+
+    This function dynamically imports a class based on its string name.
+    It splits the name into module path and class name, imports the module,
+    and returns the class object.
+
+    :param fully_qualified_name: the fully qualified class name as a string
+    :returns: the class object.
+    :raises ImportError: If the class cannot be imported or found.
+    """
+    try:
+        module_path, class_name = fully_qualified_name.rsplit(".", 1)
+        logger.debug(f"Attempting to import class '{class_name}' from module '{module_path}'")
+        module = import_module(module_path)
+        return getattr(module, class_name)
+    except (ImportError, AttributeError) as error:
+        logger.error(f"Failed to import class '{fully_qualified_name}'")
+        raise ImportError(f"Could not import class '{fully_qualified_name}'") from error

testbed/deepset-ai__haystack/haystack/core/type_utils.py

@@ -0,0 +1,84 @@
+# SPDX-FileCopyrightText: 2022-present deepset GmbH <info@deepset.ai>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from typing import Any, Union, get_args, get_origin
+
+from haystack import logging
+
+logger = logging.getLogger(__name__)
+
+
+def _is_optional(type_: type) -> bool:
+    """
+    Utility method that returns whether a type is Optional.
+    """
+    return get_origin(type_) is Union and type(None) in get_args(type_)
+
+
+def _types_are_compatible(sender, receiver):  # pylint: disable=too-many-return-statements
+    """
+    Checks whether the source type is equal or a subtype of the destination type. Used to validate pipeline connections.
+
+    Note: this method has no pretense to perform proper type matching. It especially does not deal with aliasing of
+    typing classes such as `List` or `Dict` to their runtime counterparts `list` and `dict`. It also does not deal well
+    with "bare" types, so `List` is treated differently from `List[Any]`, even though they should be the same.
+
+    Consider simplifying the typing of your components if you observe unexpected errors during component connection.
+    """
+    if sender == receiver or receiver is Any:
+        return True
+
+    if sender is Any:
+        return False
+
+    try:
+        if issubclass(sender, receiver):
+            return True
+    except TypeError:  # typing classes can't be used with issubclass, so we deal with them below
+        pass
+
+    sender_origin = get_origin(sender)
+    receiver_origin = get_origin(receiver)
+
+    if sender_origin is not Union and receiver_origin is Union:
+        return any(_types_are_compatible(sender, union_arg) for union_arg in get_args(receiver))
+
+    if not sender_origin or not receiver_origin or sender_origin != receiver_origin:
+        return False
+
+    sender_args = get_args(sender)
+    receiver_args = get_args(receiver)
+    if len(sender_args) > len(receiver_args):
+        return False
+
+    return all(_types_are_compatible(*args) for args in zip(sender_args, receiver_args))
+
+
+def _type_name(type_):
+    """
+    Util methods to get a nice readable representation of a type.
+
+    Handles Optional and Literal in a special way to make it more readable.
+    """
+    # Literal args are strings, so we wrap them in quotes to make it clear
+    if isinstance(type_, str):
+        return f"'{type_}'"
+
+    name = getattr(type_, "__name__", str(type_))
+
+    if name.startswith("typing."):
+        name = name[7:]
+    if "[" in name:
+        name = name.split("[")[0]
+    args = get_args(type_)
+    if name == "Union" and type(None) in args and len(args) == 2:
+        # Optional is technically a Union of type and None
+        # but we want to display it as Optional
+        name = "Optional"
+
+    if args:
+        args = ", ".join([_type_name(a) for a in args if a is not type(None)])
+        return f"{name}[{args}]"
+
+    return f"{name}"