transformers-haystack 0.1.0__py3-none-any.whl

haystack_integrations/components/routers/transformers/text_router.py

@@ -0,0 +1,196 @@
+# SPDX-FileCopyrightText: 2022-present deepset GmbH <info@deepset.ai>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from typing import Any
+
+from haystack import component, default_from_dict, default_to_dict
+from haystack.utils import ComponentDevice, Secret
+from haystack.utils.hf import deserialize_hf_model_kwargs, serialize_hf_model_kwargs
+
+from haystack_integrations.components.common.transformers.utils import _resolve_hf_pipeline_kwargs
+from transformers import AutoConfig, Pipeline, pipeline
+
+
+@component
+class TransformersTextRouter:
+    """
+    Routes the text strings to different connections based on a category label.
+
+    The labels are specific to each model and can be found it its description on Hugging Face.
+
+    ### Usage example
+    ```python
+    from haystack.components.builders import PromptBuilder
+    from haystack.components.generators import HuggingFaceLocalGenerator
+    from haystack.core.pipeline import Pipeline
+
+    from haystack_integrations.components.routers.transformers import TransformersTextRouter
+
+    p = Pipeline()
+    p.add_component(
+        instance=TransformersTextRouter(model="papluca/xlm-roberta-base-language-detection"),
+        name="text_router"
+    )
+    p.add_component(
+        instance=PromptBuilder(template="Answer the question: {{query}}\\nAnswer:"),
+        name="english_prompt_builder"
+    )
+    p.add_component(
+        instance=PromptBuilder(template="Beantworte die Frage: {{query}}\\nAntwort:"),
+        name="german_prompt_builder"
+    )
+
+    p.add_component(
+        instance=HuggingFaceLocalGenerator(model="DiscoResearch/Llama3-DiscoLeo-Instruct-8B-v0.1"),
+        name="german_llm"
+    )
+    p.add_component(
+        instance=HuggingFaceLocalGenerator(model="microsoft/Phi-3-mini-4k-instruct"),
+        name="english_llm"
+    )
+
+    p.connect("text_router.en", "english_prompt_builder.query")
+    p.connect("text_router.de", "german_prompt_builder.query")
+    p.connect("english_prompt_builder.prompt", "english_llm.prompt")
+    p.connect("german_prompt_builder.prompt", "german_llm.prompt")
+
+    # English Example
+    print(p.run({"text_router": {"text": "What is the capital of Germany?"}}))
+
+    # German Example
+    print(p.run({"text_router": {"text": "Was ist die Hauptstadt von Deutschland?"}}))
+    ```
+    """
+
+    def __init__(
+        self,
+        model: str,
+        labels: list[str] | None = None,
+        device: ComponentDevice | None = None,
+        token: Secret | None = Secret.from_env_var(["HF_API_TOKEN", "HF_TOKEN"], strict=False),
+        huggingface_pipeline_kwargs: dict[str, Any] | None = None,
+    ) -> None:
+        """
+        Initializes the TransformersTextRouter component.
+
+        :param model: The name or path of a Hugging Face model for text classification.
+        :param labels: The list of labels. If not provided, the component fetches the labels
+            from the model configuration file hosted on the Hugging Face Hub using
+            `transformers.AutoConfig.from_pretrained`.
+        :param device: The device for loading the model. If `None`, automatically selects the default device.
+            If a device or device map is specified in `huggingface_pipeline_kwargs`, it overrides this parameter.
+        :param token: The API token used to download private models from Hugging Face.
+            If `True`, uses either `HF_API_TOKEN` or `HF_TOKEN` environment variables.
+            To generate these tokens, run `transformers-cli login`.
+        :param huggingface_pipeline_kwargs: A dictionary of keyword arguments for initializing the Hugging Face
+            text classification pipeline.
+        """
+        self.token = token
+
+        huggingface_pipeline_kwargs = _resolve_hf_pipeline_kwargs(
+            huggingface_pipeline_kwargs=huggingface_pipeline_kwargs or {},
+            model=model,
+            task="text-classification",
+            supported_tasks=["text-classification"],
+            device=device,
+            token=token,
+        )
+        self.huggingface_pipeline_kwargs = huggingface_pipeline_kwargs
+
+        if labels is None:
+            config = AutoConfig.from_pretrained(
+                huggingface_pipeline_kwargs["model"], token=huggingface_pipeline_kwargs["token"]
+            )
+            self.labels = list(config.label2id.keys())
+        else:
+            self.labels = labels
+        component.set_output_types(self, **dict.fromkeys(self.labels, str))
+
+        self.pipeline: Pipeline | None = None
+
+    def _get_telemetry_data(self) -> dict[str, Any]:
+        """
+        Data that is sent to Posthog for usage analytics.
+        """
+        if isinstance(self.huggingface_pipeline_kwargs["model"], str):
+            return {"model": self.huggingface_pipeline_kwargs["model"]}
+        return {"model": f"[object of type {type(self.huggingface_pipeline_kwargs['model'])}]"}
+
+    def warm_up(self) -> None:
+        """
+        Initializes the component.
+        """
+        if self.pipeline is None:
+            self.pipeline = pipeline(**self.huggingface_pipeline_kwargs)
+
+        # Verify labels from the model configuration file match provided labels
+        label2id = self.pipeline.model.config.label2id
+        if label2id is not None:
+            labels = set(label2id.keys())
+            if set(self.labels) != labels:
+                msg = (
+                    f"The provided labels do not match the labels in the model configuration file. "
+                    f"Provided labels: {self.labels}. Model labels: {labels}"
+                )
+                raise ValueError(msg)
+
+    def to_dict(self) -> dict[str, Any]:
+        """
+        Serializes the component to a dictionary.
+
+        :returns:
+            Dictionary with serialized data.
+        """
+        serialization_dict = default_to_dict(
+            self,
+            labels=self.labels,
+            model=self.huggingface_pipeline_kwargs["model"],
+            huggingface_pipeline_kwargs=self.huggingface_pipeline_kwargs,
+            token=self.token,
+        )
+
+        huggingface_pipeline_kwargs = serialization_dict["init_parameters"]["huggingface_pipeline_kwargs"]
+        huggingface_pipeline_kwargs.pop("token", None)
+
+        serialize_hf_model_kwargs(huggingface_pipeline_kwargs)
+        return serialization_dict
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> "TransformersTextRouter":
+        """
+        Deserializes the component from a dictionary.
+
+        :param data:
+            Dictionary to deserialize from.
+        :returns:
+            Deserialized component.
+        """
+        if data["init_parameters"].get("huggingface_pipeline_kwargs") is not None:
+            deserialize_hf_model_kwargs(data["init_parameters"]["huggingface_pipeline_kwargs"])
+        return default_from_dict(cls, data)
+
+    def run(self, text: str) -> dict[str, str]:
+        """
+        Routes the text strings to different connections based on a category label.
+
+        :param text: A string of text to route.
+        :returns:
+            A dictionary with the label as key and the text as value.
+
+        :raises TypeError:
+            If the input is not a str.
+        """
+        if self.pipeline is None:
+            self.warm_up()
+
+        if not isinstance(text, str):
+            msg = "TransformersTextRouter expects a str as input."
+            raise TypeError(msg)
+
+        # mypy doesn't know this is set in warm_up
+        prediction = self.pipeline(  # type: ignore[misc]
+            [text], return_all_scores=False, function_to_apply="none"
+        )
+        label = prediction[0]["label"]
+        return {label: text}

haystack_integrations/components/routers/transformers/zero_shot_text_router.py

@@ -0,0 +1,205 @@
+# SPDX-FileCopyrightText: 2022-present deepset GmbH <info@deepset.ai>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from typing import Any
+
+from haystack import component, default_from_dict, default_to_dict
+from haystack.utils import ComponentDevice, Secret
+from haystack.utils.hf import deserialize_hf_model_kwargs, serialize_hf_model_kwargs
+
+from haystack_integrations.components.common.transformers.utils import _resolve_hf_pipeline_kwargs
+from transformers import Pipeline as HfPipeline
+from transformers import pipeline
+
+
+@component
+class TransformersZeroShotTextRouter:
+    """
+    Routes the text strings to different connections based on a category label.
+
+    Specify the set of labels for categorization when initializing the component.
+
+    ### Usage example
+
+    ```python
+    from haystack import Document
+    from haystack.components.embedders import SentenceTransformersTextEmbedder, SentenceTransformersDocumentEmbedder
+    from haystack.components.retrievers import InMemoryEmbeddingRetriever
+    from haystack.core.pipeline import Pipeline
+    from haystack.document_stores.in_memory import InMemoryDocumentStore
+
+    from haystack_integrations.components.routers.transformers import TransformersZeroShotTextRouter
+
+    document_store = InMemoryDocumentStore()
+    doc_embedder = SentenceTransformersDocumentEmbedder(model="intfloat/e5-base-v2")
+    docs = [
+        Document(
+            content="Germany, officially the Federal Republic of Germany, is a country in the western region of "
+            "Central Europe. The nation's capital and most populous city is Berlin and its main financial centre "
+            "is Frankfurt; the largest urban area is the Ruhr."
+        ),
+        Document(
+            content="France, officially the French Republic, is a country located primarily in Western Europe. "
+            "France is a unitary semi-presidential republic with its capital in Paris, the country's largest city "
+            "and main cultural and commercial centre; other major urban areas include Marseille, Lyon, Toulouse, "
+            "Lille, Bordeaux, Strasbourg, Nantes and Nice."
+        )
+    ]
+    docs_with_embeddings = doc_embedder.run(docs)
+    document_store.write_documents(docs_with_embeddings["documents"])
+
+    p = Pipeline()
+    p.add_component(instance=TransformersZeroShotTextRouter(labels=["passage", "query"]), name="text_router")
+    p.add_component(
+        instance=SentenceTransformersTextEmbedder(model="intfloat/e5-base-v2", prefix="passage: "),
+        name="passage_embedder"
+    )
+    p.add_component(
+        instance=SentenceTransformersTextEmbedder(model="intfloat/e5-base-v2", prefix="query: "),
+        name="query_embedder"
+    )
+    p.add_component(
+        instance=InMemoryEmbeddingRetriever(document_store=document_store),
+        name="query_retriever"
+    )
+    p.add_component(
+        instance=InMemoryEmbeddingRetriever(document_store=document_store),
+        name="passage_retriever"
+    )
+
+    p.connect("text_router.passage", "passage_embedder.text")
+    p.connect("passage_embedder.embedding", "passage_retriever.query_embedding")
+    p.connect("text_router.query", "query_embedder.text")
+    p.connect("query_embedder.embedding", "query_retriever.query_embedding")
+
+    # Query Example
+    p.run({"text_router": {"text": "What is the capital of Germany?"}})
+
+    # Passage Example
+    p.run({
+        "text_router":{
+            "text": "The United Kingdom of Great Britain and Northern Ireland, commonly known as the "\
+            "United Kingdom (UK) or Britain, is a country in Northwestern Europe, off the north-western coast of "\
+            "the continental mainland."
+        }
+    })
+    ```
+    """
+
+    def __init__(
+        self,
+        labels: list[str],
+        multi_label: bool = False,
+        model: str = "MoritzLaurer/deberta-v3-base-zeroshot-v1.1-all-33",
+        device: ComponentDevice | None = None,
+        token: Secret | None = Secret.from_env_var(["HF_API_TOKEN", "HF_TOKEN"], strict=False),
+        huggingface_pipeline_kwargs: dict[str, Any] | None = None,
+    ) -> None:
+        """
+        Initializes the TransformersZeroShotTextRouter component.
+
+        :param labels: The set of labels to use for classification. Can be a single label,
+            a string of comma-separated labels, or a list of labels.
+        :param multi_label:
+            Indicates if multiple labels can be true.
+            If `False`, label scores are normalized so their sum equals 1 for each sequence.
+            If `True`, the labels are considered independent and probabilities are normalized for each candidate by
+            doing a softmax of the entailment score vs. the contradiction score.
+        :param model: The name or path of a Hugging Face model for zero-shot text classification.
+        :param device: The device for loading the model. If `None`, automatically selects the default device.
+            If a device or device map is specified in `huggingface_pipeline_kwargs`, it overrides this parameter.
+        :param token: The API token used to download private models from Hugging Face.
+            If `True`, uses either `HF_API_TOKEN` or `HF_TOKEN` environment variables.
+            To generate these tokens, run `transformers-cli login`.
+        :param huggingface_pipeline_kwargs: A dictionary of keyword arguments for initializing the Hugging Face
+            zero shot text classification.
+        """
+        self.token = token
+        self.labels = labels
+        self.multi_label = multi_label
+        component.set_output_types(self, **dict.fromkeys(labels, str))
+
+        huggingface_pipeline_kwargs = _resolve_hf_pipeline_kwargs(
+            huggingface_pipeline_kwargs=huggingface_pipeline_kwargs or {},
+            model=model,
+            task="zero-shot-classification",
+            supported_tasks=["zero-shot-classification"],
+            device=device,
+            token=token,
+        )
+        self.huggingface_pipeline_kwargs = huggingface_pipeline_kwargs
+        self.pipeline: HfPipeline | None = None
+
+    def _get_telemetry_data(self) -> dict[str, Any]:
+        """
+        Data that is sent to Posthog for usage analytics.
+        """
+        if isinstance(self.huggingface_pipeline_kwargs["model"], str):
+            return {"model": self.huggingface_pipeline_kwargs["model"]}
+        return {"model": f"[object of type {type(self.huggingface_pipeline_kwargs['model'])}]"}
+
+    def warm_up(self) -> None:
+        """
+        Initializes the component.
+        """
+        if self.pipeline is None:
+            self.pipeline = pipeline(**self.huggingface_pipeline_kwargs)
+
+    def to_dict(self) -> dict[str, Any]:
+        """
+        Serializes the component to a dictionary.
+
+        :returns:
+            Dictionary with serialized data.
+        """
+        serialization_dict = default_to_dict(
+            self, labels=self.labels, huggingface_pipeline_kwargs=self.huggingface_pipeline_kwargs, token=self.token
+        )
+
+        huggingface_pipeline_kwargs = serialization_dict["init_parameters"]["huggingface_pipeline_kwargs"]
+        huggingface_pipeline_kwargs.pop("token", None)
+
+        serialize_hf_model_kwargs(huggingface_pipeline_kwargs)
+        return serialization_dict
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> "TransformersZeroShotTextRouter":
+        """
+        Deserializes the component from a dictionary.
+
+        :param data:
+            Dictionary to deserialize from.
+        :returns:
+            Deserialized component.
+        """
+        if data["init_parameters"].get("huggingface_pipeline_kwargs") is not None:
+            deserialize_hf_model_kwargs(data["init_parameters"]["huggingface_pipeline_kwargs"])
+        return default_from_dict(cls, data)
+
+    def run(self, text: str) -> dict[str, str]:
+        """
+        Routes the text strings to different connections based on a category label.
+
+        :param text: A string of text to route.
+        :returns:
+            A dictionary with the label as key and the text as value.
+
+        :raises TypeError:
+            If the input is not a str.
+        """
+        if self.pipeline is None:
+            self.warm_up()
+
+        if not isinstance(text, str):
+            msg = "TransformersZeroShotTextRouter expects a str as input."
+            raise TypeError(msg)
+
+        # mypy doesn't know this is set in warm_up
+        prediction = self.pipeline(  # type: ignore[misc]
+            [text], candidate_labels=self.labels, multi_label=self.multi_label
+        )
+        predicted_scores = prediction[0]["scores"]
+        max_score_index = max(range(len(predicted_scores)), key=predicted_scores.__getitem__)
+        label = prediction[0]["labels"][max_score_index]
+        return {label: text}

transformers_haystack-0.1.0.dist-info/METADATA

@@ -0,0 +1,38 @@
+Metadata-Version: 2.4
+Name: transformers-haystack
+Version: 0.1.0
+Summary: Haystack integration for transformers
+Project-URL: Documentation, https://github.com/deepset-ai/haystack-core-integrations/tree/main/integrations/transformers#readme
+Project-URL: Issues, https://github.com/deepset-ai/haystack-core-integrations/issues
+Project-URL: Source, https://github.com/deepset-ai/haystack-core-integrations/tree/main/integrations/transformers
+Author-email: deepset GmbH <info@deepset.ai>
+License-Expression: Apache-2.0
+License-File: LICENSE.txt
+Classifier: Development Status :: 4 - Beta
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Requires-Python: >=3.10
+Requires-Dist: haystack-ai>=2.30.0
+Requires-Dist: transformers[sentencepiece,torch]>=4.57.0
+Description-Content-Type: text/markdown
+
+# transformers-haystack
+
+[![PyPI - Version](https://img.shields.io/pypi/v/transformers-haystack.svg)](https://pypi.org/project/transformers-haystack)
+[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/transformers-haystack.svg)](https://pypi.org/project/transformers-haystack)
+
+- [Integration page](https://haystack.deepset.ai/integrations/huggingface)
+- [Changelog](https://github.com/deepset-ai/haystack-core-integrations/blob/main/integrations/transformers/CHANGELOG.md)
+
+---
+
+## Contributing
+
+Refer to the general [Contribution Guidelines](https://github.com/deepset-ai/haystack-core-integrations/blob/main/CONTRIBUTING.md).

transformers_haystack-0.1.0.dist-info/RECORD

@@ -0,0 +1,24 @@
+haystack_integrations/components/classifiers/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+haystack_integrations/components/classifiers/transformers/__init__.py,sha256=xFmrrKECbqO8i0E883s7-K6bUAlPuWzXWaQ2-miBzTY,246
+haystack_integrations/components/classifiers/transformers/zero_shot_document_classifier.py,sha256=fw33Kq1UmqvFnbrVaR6QJ43M6SYdLt-DuQz7FzT2Dd0,10530
+haystack_integrations/components/common/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+haystack_integrations/components/common/transformers/__init__.py,sha256=eHD7xrty2PCky_gG3ty19rpM4WfV32TyytM7gJODwl4,110
+haystack_integrations/components/common/transformers/utils.py,sha256=ObCY0oTqctum-5uaouqk_7RbqR48-grLWozp0stkYTs,10023
+haystack_integrations/components/extractors/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+haystack_integrations/components/extractors/transformers/__init__.py,sha256=MfTYvVt05ffO59XmRbwnECpCOueD_fWnB7jmaP9WVKs,275
+haystack_integrations/components/extractors/transformers/named_entity_extractor.py,sha256=65K2nR9x2hQ0jc9DCBeaXV-xRzTlWhjHibhSYf_SbaY,9188
+haystack_integrations/components/generators/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+haystack_integrations/components/generators/transformers/__init__.py,sha256=RP5_IZLPbCgd_9STdnnNy5qLS8Opj6LsfWLRIJeQCqw,210
+haystack_integrations/components/generators/transformers/chat/__init__.py,sha256=eHD7xrty2PCky_gG3ty19rpM4WfV32TyytM7gJODwl4,110
+haystack_integrations/components/generators/transformers/chat/chat_generator.py,sha256=Z-GOA2vW2gHfuPsRXkL9pUPgB4NBtA4gCZuzkqJBT0Y,31340
+haystack_integrations/components/readers/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+haystack_integrations/components/readers/transformers/__init__.py,sha256=iZdcE2OMB7Ww16bTK4iLOqOFIkfw50P3ENlegxJRlpk,214
+haystack_integrations/components/readers/transformers/extractive_reader.py,sha256=GaZjA6dEkHV04xw7cPQztmZ9qWKZm-wYL72LAFy-Nr0,30082
+haystack_integrations/components/routers/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+haystack_integrations/components/routers/transformers/__init__.py,sha256=yeWWf1-Ubz9ekT-FJKjGQHLPuEXxvYIe79HgXVd7Ghs,296
+haystack_integrations/components/routers/transformers/text_router.py,sha256=8kLzEiWUpT9M0NzLlqa3KJ1mFRDQ8E0E_-alvlJ0kDQ,7591
+haystack_integrations/components/routers/transformers/zero_shot_text_router.py,sha256=nS0ufLG6e4FHIcBcMzdrbHyvYEJzGKsZEjEBijXXpYU,8751
+transformers_haystack-0.1.0.dist-info/METADATA,sha256=FhtSX9PBR0_1juZlHsoFXDym6951Z4U-afuEppa5tqk,1886
+transformers_haystack-0.1.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+transformers_haystack-0.1.0.dist-info/licenses/LICENSE.txt,sha256=OrAtTu4aPmrTjKDSTzkSPgo_ji6NOMWO2N9JOTFyAzM,11350
+transformers_haystack-0.1.0.dist-info/RECORD,,

transformers_haystack-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.30.1
+Root-Is-Purelib: true
+Tag: py3-none-any

transformers_haystack-0.1.0.dist-info/licenses/LICENSE.txt

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2023-present deepset GmbH
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.