nvidia-haystack 0.1.0__tar.gz → 0.1.2__tar.gz

{nvidia_haystack-0.1.0 → nvidia_haystack-0.1.2}/CHANGELOG.md

@@ -1,15 +1,23 @@
 # Changelog
 
-## [unreleased]
+## [integrations/nvidia-v0.1.1] - 2024-11-14
+
+### 🐛 Bug Fixes
+
+- Fixes to NvidiaRanker (#1191)
+
+## [integrations/nvidia-v0.1.0] - 2024-11-13
 
 ### 🚀 Features
 
 - Update default embedding model to nvidia/nv-embedqa-e5-v5 (#1015)
 - Add NVIDIA NIM ranker support (#1023)
+- Raise error when attempting to embed empty documents/strings with Nvidia embedders (#1118)
 
 ### 🐛 Bug Fixes
 
 - Lints in `nvidia-haystack` (#993)
+- Missing Nvidia embedding truncate mode (#1043)
 
 ### 🚜 Refactor
 
@@ -27,6 +35,8 @@
 
 - Retry tests to reduce flakyness (#836)
 - Update ruff invocation to include check parameter (#853)
+- Update ruff linting scripts and settings (#1105)
+- Adopt uv as installer (#1142)
 
 ### Docs
 

{nvidia_haystack-0.1.0 → nvidia_haystack-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: nvidia-haystack
-Version: 0.1.0
+Version: 0.1.2
 Project-URL: Documentation, https://github.com/deepset-ai/haystack-core-integrations/tree/main/integrations/nvidia#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/nvidia
@@ -19,6 +19,7 @@ Classifier: Programming Language :: Python :: Implementation :: PyPy
 Requires-Python: >=3.8
 Requires-Dist: haystack-ai
 Requires-Dist: requests
+Requires-Dist: tqdm
 Description-Content-Type: text/markdown
 
 # nvidia-haystack
@@ -61,7 +62,7 @@ hatch run test
 To only run unit tests:
 
 ```
-hatch run test -m"not integration"
+hatch run test -m "not integration"
 ```
 
 To run the linters `ruff` and `mypy`:

{nvidia_haystack-0.1.0 → nvidia_haystack-0.1.2}/README.md

@@ -38,7 +38,7 @@ hatch run test
 To only run unit tests:
 
 ```
-hatch run test -m"not integration"
+hatch run test -m "not integration"
 ```
 
 To run the linters `ruff` and `mypy`:

{nvidia_haystack-0.1.0 → nvidia_haystack-0.1.2}/pyproject.toml

@@ -23,7 +23,7 @@ classifiers = [
   "Programming Language :: Python :: Implementation :: CPython",
   "Programming Language :: Python :: Implementation :: PyPy",
 ]
-dependencies = ["haystack-ai", "requests"]
+dependencies = ["haystack-ai", "requests", "tqdm"]
 
 [project.urls]
 Documentation = "https://github.com/deepset-ai/haystack-core-integrations/tree/main/integrations/nvidia#readme"

nvidia_haystack-0.1.2/src/haystack_integrations/components/__init__.py

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

nvidia_haystack-0.1.2/src/haystack_integrations/components/embedders/__init__.py

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

nvidia_haystack-0.1.2/src/haystack_integrations/components/embedders/nvidia/__init__.py

@@ -0,0 +1,9 @@
+# SPDX-FileCopyrightText: 2024-present deepset GmbH <info@deepset.ai>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from .document_embedder import NvidiaDocumentEmbedder
+from .text_embedder import NvidiaTextEmbedder
+from .truncate import EmbeddingTruncateMode
+
+__all__ = ["EmbeddingTruncateMode", "NvidiaDocumentEmbedder", "NvidiaTextEmbedder"]

{nvidia_haystack-0.1.0 → nvidia_haystack-0.1.2}/src/haystack_integrations/components/embedders/nvidia/document_embedder.py

@@ -1,13 +1,19 @@
+# SPDX-FileCopyrightText: 2024-present deepset GmbH <info@deepset.ai>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+import os
 import warnings
 from typing import Any, Dict, List, Optional, Tuple, Union
 
-from haystack import Document, component, default_from_dict, default_to_dict
+from haystack import Document, component, default_from_dict, default_to_dict, logging
 from haystack.utils import Secret, deserialize_secrets_inplace
 from tqdm import tqdm
 
+from haystack_integrations.components.embedders.nvidia.truncate import EmbeddingTruncateMode
 from haystack_integrations.utils.nvidia import NimBackend, is_hosted, url_validation
 
-from .truncate import EmbeddingTruncateMode
+logger = logging.getLogger(__name__)
 
 _DEFAULT_API_URL = "https://ai.api.nvidia.com/v1/retrieval/nvidia"
 
@@ -44,6 +50,7 @@ class NvidiaDocumentEmbedder:
         meta_fields_to_embed: Optional[List[str]] = None,
         embedding_separator: str = "\n",
         truncate: Optional[Union[EmbeddingTruncateMode, str]] = None,
+        timeout: Optional[float] = None,
     ):
         """
         Create a NvidiaTextEmbedder component.
@@ -71,8 +78,11 @@ class NvidiaDocumentEmbedder:
         :param embedding_separator:
             Separator used to concatenate the meta fields to the Document text.
         :param truncate:
-            Specifies how inputs longer that the maximum token length should be truncated.
+            Specifies how inputs longer than the maximum token length should be truncated.
             If None the behavior is model-dependent, see the official documentation for more information.
+        :param timeout:
+            Timeout for request calls, if not set it is inferred from the `NVIDIA_TIMEOUT` environment variable
+            or set to 60 by default.
         """
 
         self.api_key = api_key
@@ -95,6 +105,10 @@ class NvidiaDocumentEmbedder:
         if is_hosted(api_url) and not self.model:  # manually set default model
             self.model = "nvidia/nv-embedqa-e5-v5"
 
+        if timeout is None:
+            timeout = float(os.environ.get("NVIDIA_TIMEOUT", 60.0))
+        self.timeout = timeout
+
     def default_model(self):
         """Set default model in local NIM mode."""
         valid_models = [
@@ -125,10 +139,11 @@ class NvidiaDocumentEmbedder:
         if self.truncate is not None:
             model_kwargs["truncate"] = str(self.truncate)
         self.backend = NimBackend(
-            self.model,
+            model=self.model,
             api_url=self.api_url,
             api_key=self.api_key,
             model_kwargs=model_kwargs,
+            timeout=self.timeout,
         )
 
         self._initialized = True
@@ -155,6 +170,7 @@ class NvidiaDocumentEmbedder:
             meta_fields_to_embed=self.meta_fields_to_embed,
             embedding_separator=self.embedding_separator,
             truncate=str(self.truncate) if self.truncate is not None else None,
+            timeout=self.timeout,
         )
 
     @classmethod
@@ -167,7 +183,9 @@ class NvidiaDocumentEmbedder:
         :returns:
             The deserialized component.
         """
-        deserialize_secrets_inplace(data["init_parameters"], keys=["api_key"])
+        init_parameters = data.get("init_parameters", {})
+        if init_parameters:
+            deserialize_secrets_inplace(data["init_parameters"], keys=["api_key"])
         return default_from_dict(cls, data)
 
     def _prepare_texts_to_embed(self, documents: List[Document]) -> List[str]:
@@ -224,7 +242,7 @@ class NvidiaDocumentEmbedder:
         if not self._initialized:
             msg = "The embedding model has not been loaded. Please call warm_up() before running."
             raise RuntimeError(msg)
-        elif not isinstance(documents, list) or documents and not isinstance(documents[0], Document):
+        elif not isinstance(documents, list) or (documents and not isinstance(documents[0], Document)):
             msg = (
                 "NvidiaDocumentEmbedder expects a list of Documents as input."
                 "In case you want to embed a string, please use the NvidiaTextEmbedder."
@@ -233,8 +251,7 @@ class NvidiaDocumentEmbedder:
 
         for doc in documents:
             if not doc.content:
-                msg = f"Document '{doc.id}' has no content to embed."
-                raise ValueError(msg)
+                logger.warning(f"Document '{doc.id}' has no content to embed.")
 
         texts_to_embed = self._prepare_texts_to_embed(documents)
         embeddings, metadata = self._embed_batch(texts_to_embed, self.batch_size)

{nvidia_haystack-0.1.0 → nvidia_haystack-0.1.2}/src/haystack_integrations/components/embedders/nvidia/text_embedder.py

@@ -1,12 +1,18 @@
+# SPDX-FileCopyrightText: 2024-present deepset GmbH <info@deepset.ai>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+import os
 import warnings
 from typing import Any, Dict, List, Optional, Union
 
-from haystack import component, default_from_dict, default_to_dict
+from haystack import component, default_from_dict, default_to_dict, logging
 from haystack.utils import Secret, deserialize_secrets_inplace
 
+from haystack_integrations.components.embedders.nvidia.truncate import EmbeddingTruncateMode
 from haystack_integrations.utils.nvidia import NimBackend, is_hosted, url_validation
 
-from .truncate import EmbeddingTruncateMode
+logger = logging.getLogger(__name__)
 
 _DEFAULT_API_URL = "https://ai.api.nvidia.com/v1/retrieval/nvidia"
 
@@ -41,6 +47,7 @@ class NvidiaTextEmbedder:
         prefix: str = "",
         suffix: str = "",
         truncate: Optional[Union[EmbeddingTruncateMode, str]] = None,
+        timeout: Optional[float] = None,
     ):
         """
         Create a NvidiaTextEmbedder component.
@@ -61,6 +68,9 @@ class NvidiaTextEmbedder:
         :param truncate:
             Specifies how inputs longer that the maximum token length should be truncated.
             If None the behavior is model-dependent, see the official documentation for more information.
+        :param timeout:
+            Timeout for request calls, if not set it is inferred from the `NVIDIA_TIMEOUT` environment variable
+            or set to 60 by default.
         """
 
         self.api_key = api_key
@@ -79,6 +89,10 @@ class NvidiaTextEmbedder:
         if is_hosted(api_url) and not self.model:  # manually set default model
             self.model = "nvidia/nv-embedqa-e5-v5"
 
+        if timeout is None:
+            timeout = float(os.environ.get("NVIDIA_TIMEOUT", 60.0))
+        self.timeout = timeout
+
     def default_model(self):
         """Set default model in local NIM mode."""
         valid_models = [
@@ -86,6 +100,12 @@ class NvidiaTextEmbedder:
         ]
         name = next(iter(valid_models), None)
         if name:
+            logger.warning(
+                "Default model is set as: {model_name}. \n"
+                "Set model using model parameter. \n"
+                "To get available models use available_models property.",
+                model_name=name,
+            )
             warnings.warn(
                 f"Default model is set as: {name}. \n"
                 "Set model using model parameter. \n"
@@ -109,10 +129,11 @@ class NvidiaTextEmbedder:
         if self.truncate is not None:
             model_kwargs["truncate"] = str(self.truncate)
         self.backend = NimBackend(
-            self.model,
+            model=self.model,
             api_url=self.api_url,
             api_key=self.api_key,
             model_kwargs=model_kwargs,
+            timeout=self.timeout,
         )
 
         self._initialized = True
@@ -135,6 +156,7 @@ class NvidiaTextEmbedder:
             prefix=self.prefix,
             suffix=self.suffix,
             truncate=str(self.truncate) if self.truncate is not None else None,
+            timeout=self.timeout,
         )
 
     @classmethod
@@ -147,7 +169,9 @@ class NvidiaTextEmbedder:
         :returns:
             The deserialized component.
         """
-        deserialize_secrets_inplace(data["init_parameters"], keys=["api_key"])
+        init_parameters = data.get("init_parameters", {})
+        if init_parameters:
+            deserialize_secrets_inplace(data["init_parameters"], keys=["api_key"])
         return default_from_dict(cls, data)
 
     @component.output_types(embedding=List[float], meta=Dict[str, Any])
@@ -159,7 +183,7 @@ class NvidiaTextEmbedder:
             The text to embed.
         :returns:
             A dictionary with the following keys and values:
-            - `embedding` - Embeddng of the text.
+            - `embedding` - Embedding of the text.
             - `meta` - Metadata on usage statistics, etc.
         :raises RuntimeError:
             If the component was not initialized.

{nvidia_haystack-0.1.0 → nvidia_haystack-0.1.2}/src/haystack_integrations/components/embedders/nvidia/truncate.py

@@ -1,3 +1,7 @@
+# SPDX-FileCopyrightText: 2024-present deepset GmbH <info@deepset.ai>
+#
+# SPDX-License-Identifier: Apache-2.0
+
 from enum import Enum
 
 

nvidia_haystack-0.1.2/src/haystack_integrations/components/generators/__init__.py

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

{nvidia_haystack-0.1.0 → nvidia_haystack-0.1.2}/src/haystack_integrations/components/generators/nvidia/__init__.py

@@ -1,6 +1,7 @@
 # SPDX-FileCopyrightText: 2024-present deepset GmbH <info@deepset.ai>
 #
 # SPDX-License-Identifier: Apache-2.0
+
 from .generator import NvidiaGenerator
 
 __all__ = ["NvidiaGenerator"]

nvidia_haystack-0.1.2/src/haystack_integrations/components/generators/nvidia/chat/__init__.py

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

{nvidia_haystack-0.1.0 → nvidia_haystack-0.1.2}/src/haystack_integrations/components/generators/nvidia/generator.py

@@ -1,6 +1,8 @@
 # SPDX-FileCopyrightText: 2024-present deepset GmbH <info@deepset.ai>
 #
 # SPDX-License-Identifier: Apache-2.0
+
+import os
 import warnings
 from typing import Any, Dict, List, Optional
 
@@ -48,6 +50,7 @@ class NvidiaGenerator:
         api_url: str = _DEFAULT_API_URL,
         api_key: Optional[Secret] = Secret.from_env_var("NVIDIA_API_KEY"),
         model_arguments: Optional[Dict[str, Any]] = None,
+        timeout: Optional[float] = None,
     ):
         """
         Create a NvidiaGenerator component.
@@ -69,6 +72,9 @@ class NvidiaGenerator:
             specific to a model.
             Search your model in the [NVIDIA NIM](https://ai.nvidia.com)
             to find the arguments it accepts.
+        :param timeout:
+            Timeout for request calls, if not set it is inferred from the `NVIDIA_TIMEOUT` environment variable
+            or set to 60 by default.
         """
         self._model = model
         self._api_url = url_validation(api_url, _DEFAULT_API_URL, ["v1/chat/completions"])
@@ -78,6 +84,9 @@ class NvidiaGenerator:
         self._backend: Optional[Any] = None
 
         self.is_hosted = is_hosted(api_url)
+        if timeout is None:
+            timeout = float(os.environ.get("NVIDIA_TIMEOUT", 60.0))
+        self.timeout = timeout
 
     def default_model(self):
         """Set default model in local NIM mode."""
@@ -109,10 +118,11 @@ class NvidiaGenerator:
             msg = "API key is required for hosted NVIDIA NIMs."
             raise ValueError(msg)
         self._backend = NimBackend(
-            self._model,
+            model=self._model,
             api_url=self._api_url,
             api_key=self._api_key,
             model_kwargs=self._model_arguments,
+            timeout=self.timeout,
         )
 
         if not self.is_hosted and not self._model:

nvidia_haystack-0.1.2/src/haystack_integrations/components/rankers/__init__.py

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

nvidia_haystack-0.1.2/src/haystack_integrations/components/rankers/nvidia/__init__.py

@@ -0,0 +1,7 @@
+# SPDX-FileCopyrightText: 2024-present deepset GmbH <info@deepset.ai>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from .ranker import NvidiaRanker
+
+__all__ = ["NvidiaRanker"]

{nvidia_haystack-0.1.0 → nvidia_haystack-0.1.2}/src/haystack_integrations/components/rankers/nvidia/ranker.py

@@ -1,12 +1,18 @@
+# SPDX-FileCopyrightText: 2024-present deepset GmbH <info@deepset.ai>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+import os
 import warnings
 from typing import Any, Dict, List, Optional, Union
 
-from haystack import Document, component, default_from_dict, default_to_dict
+from haystack import Document, component, default_from_dict, default_to_dict, logging
 from haystack.utils import Secret, deserialize_secrets_inplace
 
+from haystack_integrations.components.rankers.nvidia.truncate import RankerTruncateMode
 from haystack_integrations.utils.nvidia import NimBackend, url_validation
 
-from .truncate import RankerTruncateMode
+logger = logging.getLogger(__name__)
 
 _DEFAULT_MODEL = "nvidia/nv-rerankqa-mistral-4b-v3"
 
@@ -51,8 +57,13 @@ class NvidiaRanker:
         model: Optional[str] = None,
         truncate: Optional[Union[RankerTruncateMode, str]] = None,
         api_url: Optional[str] = None,
-        api_key: Optional[Secret] = None,
+        api_key: Optional[Secret] = Secret.from_env_var("NVIDIA_API_KEY"),
         top_k: int = 5,
+        query_prefix: str = "",
+        document_prefix: str = "",
+        meta_fields_to_embed: Optional[List[str]] = None,
+        embedding_separator: str = "\n",
+        timeout: Optional[float] = None,
     ):
         """
         Create a NvidiaRanker component.
@@ -67,6 +78,19 @@ class NvidiaRanker:
             Custom API URL for the NVIDIA NIM.
         :param top_k:
             Number of documents to return.
+        :param query_prefix:
+            A string to add at the beginning of the query text before ranking.
+            Use it to prepend the text with an instruction, as required by reranking models like `bge`.
+        :param document_prefix:
+            A string to add at the beginning of each document before ranking. You can use it to prepend the document
+            with an instruction, as required by embedding models like `bge`.
+        :param meta_fields_to_embed:
+            List of metadata fields to embed with the document.
+        :param embedding_separator:
+            Separator to concatenate metadata fields to the document.
+        :param timeout:
+            Timeout for request calls, if not set it is inferred from the `NVIDIA_TIMEOUT` environment variable
+            or set to 60 by default.
         """
         if model is not None and not isinstance(model, str):
             msg = "Ranker expects the `model` parameter to be a string."
@@ -81,25 +105,34 @@ class NvidiaRanker:
             raise TypeError(msg)
 
         # todo: detect default in non-hosted case (when api_url is provided)
-        self._model = model or _DEFAULT_MODEL
-        self._truncate = truncate
-        self._api_key = api_key
+        self.model = model or _DEFAULT_MODEL
+        self.truncate = truncate
+        self.api_key = api_key
         # if no api_url is provided, we're using a hosted model and can
         #  - assume the default url will work, because there's only one model
         #  - assume we won't call backend.models()
         if api_url is not None:
-            self._api_url = url_validation(api_url, None, ["v1/ranking"])
-            self._endpoint = None  # we let backend.rank() handle the endpoint
+            self.api_url = url_validation(api_url, None, ["v1/ranking"])
+            self.endpoint = None  # we let backend.rank() handle the endpoint
         else:
-            if self._model not in _MODEL_ENDPOINT_MAP:
+            if self.model not in _MODEL_ENDPOINT_MAP:
                 msg = f"Model '{model}' is unknown. Please provide an api_url to access it."
                 raise ValueError(msg)
-            self._api_url = None  # we handle the endpoint
-            self._endpoint = _MODEL_ENDPOINT_MAP[self._model]
+            self.api_url = None  # we handle the endpoint
+            self.endpoint = _MODEL_ENDPOINT_MAP[self.model]
             if api_key is None:
                 self._api_key = Secret.from_env_var("NVIDIA_API_KEY")
-        self._top_k = top_k
+        self.top_k = top_k
         self._initialized = False
+        self._backend: Optional[Any] = None
+
+        self.query_prefix = query_prefix
+        self.document_prefix = document_prefix
+        self.meta_fields_to_embed = meta_fields_to_embed or []
+        self.embedding_separator = embedding_separator
+        if timeout is None:
+            timeout = float(os.environ.get("NVIDIA_TIMEOUT", 60.0))
+        self.timeout = timeout
 
     def to_dict(self) -> Dict[str, Any]:
         """
@@ -109,11 +142,16 @@ class NvidiaRanker:
         """
         return default_to_dict(
             self,
-            model=self._model,
-            top_k=self._top_k,
-            truncate=self._truncate,
-            api_url=self._api_url,
-            api_key=self._api_key,
+            model=self.model,
+            top_k=self.top_k,
+            truncate=self.truncate,
+            api_url=self.api_url,
+            api_key=self.api_key.to_dict() if self.api_key else None,
+            query_prefix=self.query_prefix,
+            document_prefix=self.document_prefix,
+            meta_fields_to_embed=self.meta_fields_to_embed,
+            embedding_separator=self.embedding_separator,
+            timeout=self.timeout,
         )
 
     @classmethod
@@ -124,7 +162,9 @@ class NvidiaRanker:
         :param data: A dictionary containing the ranker's attributes.
         :returns: The deserialized ranker.
         """
-        deserialize_secrets_inplace(data, keys=["api_key"])
+        init_parameters = data.get("init_parameters", {})
+        if init_parameters:
+            deserialize_secrets_inplace(data["init_parameters"], keys=["api_key"])
         return default_from_dict(cls, data)
 
     def warm_up(self):
@@ -135,18 +175,31 @@ class NvidiaRanker:
         """
         if not self._initialized:
             model_kwargs = {}
-            if self._truncate is not None:
-                model_kwargs.update(truncate=str(self._truncate))
+            if self.truncate is not None:
+                model_kwargs.update(truncate=str(self.truncate))
             self._backend = NimBackend(
-                self._model,
-                api_url=self._api_url,
-                api_key=self._api_key,
+                model=self.model,
+                api_url=self.api_url,
+                api_key=self.api_key,
                 model_kwargs=model_kwargs,
+                timeout=self.timeout,
             )
-            if not self._model:
-                self._model = _DEFAULT_MODEL
+            if not self.model:
+                self.model = _DEFAULT_MODEL
             self._initialized = True
 
+    def _prepare_documents_to_embed(self, documents: List[Document]) -> List[str]:
+        document_texts = []
+        for doc in documents:
+            meta_values_to_embed = [
+                str(doc.meta[key])
+                for key in self.meta_fields_to_embed
+                if key in doc.meta and doc.meta[key]  # noqa: RUF019
+            ]
+            text_to_embed = self.embedding_separator.join([*meta_values_to_embed, doc.content or ""])
+            document_texts.append(self.document_prefix + text_to_embed)
+        return document_texts
+
     @component.output_types(documents=List[Document])
     def run(
         self,
@@ -170,32 +223,37 @@ class NvidiaRanker:
             msg = "The ranker has not been loaded. Please call warm_up() before running."
             raise RuntimeError(msg)
         if not isinstance(query, str):
-            msg = "Ranker expects the `query` parameter to be a string."
+            msg = "NvidiaRanker expects the `query` parameter to be a string."
             raise TypeError(msg)
         if not isinstance(documents, list):
-            msg = "Ranker expects the `documents` parameter to be a list."
+            msg = "NvidiaRanker expects the `documents` parameter to be a list."
             raise TypeError(msg)
         if not all(isinstance(doc, Document) for doc in documents):
-            msg = "Ranker expects the `documents` parameter to be a list of Document objects."
+            msg = "NvidiaRanker expects the `documents` parameter to be a list of Document objects."
             raise TypeError(msg)
         if top_k is not None and not isinstance(top_k, int):
-            msg = "Ranker expects the `top_k` parameter to be an integer."
+            msg = "NvidiaRanker expects the `top_k` parameter to be an integer."
             raise TypeError(msg)
 
         if len(documents) == 0:
             return {"documents": []}
 
-        top_k = top_k if top_k is not None else self._top_k
+        top_k = top_k if top_k is not None else self.top_k
         if top_k < 1:
+            logger.warning("top_k should be at least 1, returning nothing")
             warnings.warn("top_k should be at least 1, returning nothing", stacklevel=2)
             return {"documents": []}
 
         assert self._backend is not None
+
+        query_text = self.query_prefix + query
+        document_texts = self._prepare_documents_to_embed(documents=documents)
+
         # rank result is list[{index: int, logit: float}] sorted by logit
         sorted_indexes_and_scores = self._backend.rank(
-            query,
-            documents,
-            endpoint=self._endpoint,
+            query_text=query_text,
+            document_texts=document_texts,
+            endpoint=self.endpoint,
         )
         sorted_documents = []
         for item in sorted_indexes_and_scores[:top_k]:

{nvidia_haystack-0.1.0 → nvidia_haystack-0.1.2}/src/haystack_integrations/components/rankers/nvidia/truncate.py

@@ -1,3 +1,7 @@
+# SPDX-FileCopyrightText: 2024-present deepset GmbH <info@deepset.ai>
+#
+# SPDX-License-Identifier: Apache-2.0
+
 from enum import Enum
 
 

nvidia_haystack-0.1.2/src/haystack_integrations/utils/__init__.py

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

nvidia_haystack-0.1.2/src/haystack_integrations/utils/nvidia/__init__.py

@@ -0,0 +1,8 @@
+# SPDX-FileCopyrightText: 2024-present deepset GmbH <info@deepset.ai>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from .nim_backend import Model, NimBackend
+from .utils import is_hosted, url_validation
+
+__all__ = ["Model", "NimBackend", "is_hosted", "url_validation"]

{nvidia_haystack-0.1.0 → nvidia_haystack-0.1.2}/src/haystack_integrations/utils/nvidia/nim_backend.py

@@ -1,11 +1,18 @@
+# SPDX-FileCopyrightText: 2024-present deepset GmbH <info@deepset.ai>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+import os
 from dataclasses import dataclass, field
 from typing import Any, Dict, List, Optional, Tuple
 
 import requests
-from haystack import Document
+from haystack import logging
 from haystack.utils import Secret
 
-REQUEST_TIMEOUT = 60
+logger = logging.getLogger(__name__)
+
+REQUEST_TIMEOUT = 60.0
 
 
 @dataclass
@@ -31,6 +38,7 @@ class NimBackend:
         api_url: str,
         api_key: Optional[Secret] = Secret.from_env_var("NVIDIA_API_KEY"),
         model_kwargs: Optional[Dict[str, Any]] = None,
+        timeout: Optional[float] = None,
     ):
         headers = {
             "Content-Type": "application/json",
@@ -46,6 +54,9 @@ class NimBackend:
         self.model = model
         self.api_url = api_url
         self.model_kwargs = model_kwargs or {}
+        if timeout is None:
+            timeout = float(os.environ.get("NVIDIA_TIMEOUT", REQUEST_TIMEOUT))
+        self.timeout = timeout
 
     def embed(self, texts: List[str]) -> Tuple[List[List[float]], Dict[str, Any]]:
         url = f"{self.api_url}/embeddings"
@@ -58,10 +69,11 @@ class NimBackend:
                     "input": texts,
                     **self.model_kwargs,
                 },
-                timeout=REQUEST_TIMEOUT,
+                timeout=self.timeout,
             )
             res.raise_for_status()
         except requests.HTTPError as e:
+            logger.error("Error when calling NIM embedding endpoint: Error - {error}", error=e.response.text)
             msg = f"Failed to query embedding endpoint: Error - {e.response.text}"
             raise ValueError(msg) from e
 
@@ -90,10 +102,11 @@ class NimBackend:
                     ],
                     **self.model_kwargs,
                 },
-                timeout=REQUEST_TIMEOUT,
+                timeout=self.timeout,
             )
             res.raise_for_status()
         except requests.HTTPError as e:
+            logger.error("Error when calling NIM chat completion endpoint: Error - {error}", error=e.response.text)
             msg = f"Failed to query chat completion endpoint: Error - {e.response.text}"
             raise ValueError(msg) from e
 
@@ -128,21 +141,22 @@ class NimBackend:
 
         res = self.session.get(
             url,
-            timeout=REQUEST_TIMEOUT,
+            timeout=self.timeout,
         )
         res.raise_for_status()
 
         data = res.json()["data"]
         models = [Model(element["id"]) for element in data if "id" in element]
         if not models:
+            logger.error("No hosted model were found at URL '{u}'.", u=url)
             msg = f"No hosted model were found at URL '{url}'."
             raise ValueError(msg)
         return models
 
     def rank(
         self,
-        query: str,
-        documents: List[Document],
+        query_text: str,
+        document_texts: List[str],
         endpoint: Optional[str] = None,
     ) -> List[Dict[str, Any]]:
         url = endpoint or f"{self.api_url}/ranking"
@@ -152,18 +166,22 @@ class NimBackend:
                 url,
                 json={
                     "model": self.model,
-                    "query": {"text": query},
-                    "passages": [{"text": doc.content} for doc in documents],
+                    "query": {"text": query_text},
+                    "passages": [{"text": text} for text in document_texts],
                     **self.model_kwargs,
                 },
-                timeout=REQUEST_TIMEOUT,
+                timeout=self.timeout,
             )
             res.raise_for_status()
         except requests.HTTPError as e:
+            logger.error("Error when calling NIM ranking endpoint: Error - {error}", error=e.response.text)
             msg = f"Failed to rank endpoint: Error - {e.response.text}"
             raise ValueError(msg) from e
 
         data = res.json()
-        assert "rankings" in data, f"Expected 'rankings' in response, got {data}"
+        if "rankings" not in data:
+            logger.error("Expected 'rankings' in response, got {d}", d=data)
+            msg = f"Expected 'rankings' in response, got {data}"
+            raise ValueError(msg)
 
         return data["rankings"]

{nvidia_haystack-0.1.0 → nvidia_haystack-0.1.2}/src/haystack_integrations/utils/nvidia/utils.py

@@ -1,9 +1,13 @@
+# SPDX-FileCopyrightText: 2024-present deepset GmbH <info@deepset.ai>
+#
+# SPDX-License-Identifier: Apache-2.0
+
 import warnings
-from typing import List
+from typing import List, Optional
 from urllib.parse import urlparse, urlunparse
 
 
-def url_validation(api_url: str, default_api_url: str, allowed_paths: List[str]) -> str:
+def url_validation(api_url: str, default_api_url: Optional[str], allowed_paths: List[str]) -> str:
     """
     Validate and normalize an API URL.
 

{nvidia_haystack-0.1.0 → nvidia_haystack-0.1.2}/tests/__init__.py

@@ -1,6 +1,7 @@
 # SPDX-FileCopyrightText: 2023-present deepset GmbH <info@deepset.ai>
 #
 # SPDX-License-Identifier: Apache-2.0
+
 from .conftest import MockBackend
 
 __all__ = ["MockBackend"]

{nvidia_haystack-0.1.0 → nvidia_haystack-0.1.2}/tests/conftest.py

@@ -1,3 +1,7 @@
+# SPDX-FileCopyrightText: 2024-present deepset GmbH <info@deepset.ai>
+#
+# SPDX-License-Identifier: Apache-2.0
+
 from typing import Any, Dict, List, Optional, Tuple
 
 import pytest

{nvidia_haystack-0.1.0 → nvidia_haystack-0.1.2}/tests/test_base_url.py

@@ -1,3 +1,7 @@
+# SPDX-FileCopyrightText: 2024-present deepset GmbH <info@deepset.ai>
+#
+# SPDX-License-Identifier: Apache-2.0
+
 import pytest
 
 from haystack_integrations.components.embedders.nvidia import NvidiaDocumentEmbedder, NvidiaTextEmbedder

{nvidia_haystack-0.1.0 → nvidia_haystack-0.1.2}/tests/test_document_embedder.py

@@ -1,3 +1,7 @@
+# SPDX-FileCopyrightText: 2024-present deepset GmbH <info@deepset.ai>
+#
+# SPDX-License-Identifier: Apache-2.0
+
 import os
 
 import pytest
@@ -71,6 +75,7 @@ class TestNvidiaDocumentEmbedder:
                 "meta_fields_to_embed": [],
                 "embedding_separator": "\n",
                 "truncate": None,
+                "timeout": 60.0,
             },
         }
 
@@ -86,6 +91,7 @@ class TestNvidiaDocumentEmbedder:
             meta_fields_to_embed=["test_field"],
             embedding_separator=" | ",
             truncate=EmbeddingTruncateMode.END,
+            timeout=45.0,
         )
         data = component.to_dict()
         assert data == {
@@ -101,10 +107,11 @@ class TestNvidiaDocumentEmbedder:
                 "meta_fields_to_embed": ["test_field"],
                 "embedding_separator": " | ",
                 "truncate": "END",
+                "timeout": 45.0,
             },
         }
 
-    def from_dict(self, monkeypatch):
+    def test_from_dict(self, monkeypatch):
         monkeypatch.setenv("NVIDIA_API_KEY", "fake-api-key")
         data = {
             "type": "haystack_integrations.components.embedders.nvidia.document_embedder.NvidiaDocumentEmbedder",
@@ -119,18 +126,38 @@ class TestNvidiaDocumentEmbedder:
                 "meta_fields_to_embed": ["test_field"],
                 "embedding_separator": " | ",
                 "truncate": "START",
+                "timeout": 45.0,
             },
         }
         component = NvidiaDocumentEmbedder.from_dict(data)
-        assert component.model == "nvolveqa_40k"
+        assert component.model == "playground_nvolveqa_40k"
         assert component.api_url == "https://example.com/v1"
         assert component.prefix == "prefix"
         assert component.suffix == "suffix"
+        assert component.batch_size == 10
+        assert component.progress_bar is False
+        assert component.meta_fields_to_embed == ["test_field"]
+        assert component.embedding_separator == " | "
+        assert component.truncate == EmbeddingTruncateMode.START
+        assert component.timeout == 45.0
+
+    def test_from_dict_defaults(self, monkeypatch):
+        monkeypatch.setenv("NVIDIA_API_KEY", "fake-api-key")
+        data = {
+            "type": "haystack_integrations.components.embedders.nvidia.document_embedder.NvidiaDocumentEmbedder",
+            "init_parameters": {},
+        }
+        component = NvidiaDocumentEmbedder.from_dict(data)
+        assert component.model == "nvidia/nv-embedqa-e5-v5"
+        assert component.api_url == "https://ai.api.nvidia.com/v1/retrieval/nvidia"
+        assert component.prefix == ""
+        assert component.suffix == ""
         assert component.batch_size == 32
         assert component.progress_bar
         assert component.meta_fields_to_embed == []
         assert component.embedding_separator == "\n"
-        assert component.truncate == EmbeddingTruncateMode.START
+        assert component.truncate is None
+        assert component.timeout == 60.0
 
     def test_prepare_texts_to_embed_w_metadata(self):
         documents = [
@@ -326,7 +353,7 @@ class TestNvidiaDocumentEmbedder:
         with pytest.raises(TypeError, match="NvidiaDocumentEmbedder expects a list of Documents as input"):
             embedder.run(documents=list_integers_input)
 
-    def test_run_empty_document(self):
+    def test_run_empty_document(self, caplog):
         model = "playground_nvolveqa_40k"
         api_key = Secret.from_token("fake-api-key")
         embedder = NvidiaDocumentEmbedder(model, api_key=api_key)
@@ -334,8 +361,10 @@ class TestNvidiaDocumentEmbedder:
         embedder.warm_up()
         embedder.backend = MockBackend(model=model, api_key=api_key)
 
-        with pytest.raises(ValueError, match="no content to embed"):
+        # Write check using caplog that a logger.warning is raised
+        with caplog.at_level("WARNING"):
             embedder.run(documents=[Document(content="")])
+            assert "has no content to embed." in caplog.text
 
     def test_run_on_empty_list(self):
         model = "playground_nvolveqa_40k"
@@ -351,6 +380,19 @@ class TestNvidiaDocumentEmbedder:
         assert result["documents"] is not None
         assert not result["documents"]  # empty list
 
+    def test_setting_timeout(self, monkeypatch):
+        monkeypatch.setenv("NVIDIA_API_KEY", "fake-api-key")
+        embedder = NvidiaDocumentEmbedder(timeout=10.0)
+        embedder.warm_up()
+        assert embedder.backend.timeout == 10.0
+
+    def test_setting_timeout_env(self, monkeypatch):
+        monkeypatch.setenv("NVIDIA_API_KEY", "fake-api-key")
+        monkeypatch.setenv("NVIDIA_TIMEOUT", "45")
+        embedder = NvidiaDocumentEmbedder()
+        embedder.warm_up()
+        assert embedder.backend.timeout == 45.0
+
     @pytest.mark.skipif(
         not os.environ.get("NVIDIA_API_KEY", None),
         reason="Export an env var called NVIDIA_API_KEY containing the Nvidia API key to run this test.",

{nvidia_haystack-0.1.0 → nvidia_haystack-0.1.2}/tests/test_embedding_truncate_mode.py

@@ -1,3 +1,7 @@
+# SPDX-FileCopyrightText: 2024-present deepset GmbH <info@deepset.ai>
+#
+# SPDX-License-Identifier: Apache-2.0
+
 import pytest
 
 from haystack_integrations.components.embedders.nvidia import EmbeddingTruncateMode

{nvidia_haystack-0.1.0 → nvidia_haystack-0.1.2}/tests/test_generator.py

@@ -1,6 +1,7 @@
 # SPDX-FileCopyrightText: 2024-present deepset GmbH <info@deepset.ai>
 #
 # SPDX-License-Identifier: Apache-2.0
+
 import os
 
 import pytest
@@ -123,6 +124,19 @@ class TestNvidiaGenerator:
             },
         }
 
+    def test_setting_timeout(self, monkeypatch):
+        monkeypatch.setenv("NVIDIA_API_KEY", "fake-api-key")
+        generator = NvidiaGenerator(timeout=10.0)
+        generator.warm_up()
+        assert generator._backend.timeout == 10.0
+
+    def test_setting_timeout_env(self, monkeypatch):
+        monkeypatch.setenv("NVIDIA_API_KEY", "fake-api-key")
+        monkeypatch.setenv("NVIDIA_TIMEOUT", "45")
+        generator = NvidiaGenerator()
+        generator.warm_up()
+        assert generator._backend.timeout == 45.0
+
     @pytest.mark.skipif(
         not os.environ.get("NVIDIA_NIM_GENERATOR_MODEL", None) or not os.environ.get("NVIDIA_NIM_ENDPOINT_URL", None),
         reason="Export an env var called NVIDIA_NIM_GENERATOR_MODEL containing the hosted model name and "

{nvidia_haystack-0.1.0 → nvidia_haystack-0.1.2}/tests/test_ranker.py

@@ -1,3 +1,7 @@
+# SPDX-FileCopyrightText: 2024-present deepset GmbH <info@deepset.ai>
+#
+# SPDX-License-Identifier: Apache-2.0
+
 import os
 import re
 from typing import Any, Optional, Union
@@ -15,8 +19,8 @@ class TestNvidiaRanker:
     def test_init_default(self, monkeypatch):
         monkeypatch.setenv("NVIDIA_API_KEY", "fake-api-key")
         client = NvidiaRanker()
-        assert client._model == _DEFAULT_MODEL
-        assert client._api_key == Secret.from_env_var("NVIDIA_API_KEY")
+        assert client.model == _DEFAULT_MODEL
+        assert client.api_key == Secret.from_env_var("NVIDIA_API_KEY")
 
     def test_init_with_parameters(self):
         client = NvidiaRanker(
@@ -25,10 +29,10 @@ class TestNvidiaRanker:
             top_k=3,
             truncate="END",
         )
-        assert client._api_key == Secret.from_token("fake-api-key")
-        assert client._model == _DEFAULT_MODEL
-        assert client._top_k == 3
-        assert client._truncate == RankerTruncateMode.END
+        assert client.api_key == Secret.from_token("fake-api-key")
+        assert client.model == _DEFAULT_MODEL
+        assert client.top_k == 3
+        assert client.truncate == RankerTruncateMode.END
 
     def test_init_fail_wo_api_key(self, monkeypatch):
         monkeypatch.delenv("NVIDIA_API_KEY", raising=False)
@@ -39,7 +43,7 @@ class TestNvidiaRanker:
     def test_init_pass_wo_api_key_w_api_url(self):
         url = "https://url.bogus/v1"
         client = NvidiaRanker(api_url=url)
-        assert client._api_url == url
+        assert client.api_url == url
 
     def test_warm_up_required(self):
         client = NvidiaRanker()
@@ -256,3 +260,104 @@ class TestNvidiaRanker:
         backend = client._backend
         client.warm_up()
         assert backend == client._backend
+
+    def test_to_dict(self) -> None:
+        client = NvidiaRanker()
+        assert client.to_dict() == {
+            "type": "haystack_integrations.components.rankers.nvidia.ranker.NvidiaRanker",
+            "init_parameters": {
+                "model": "nvidia/nv-rerankqa-mistral-4b-v3",
+                "top_k": 5,
+                "truncate": None,
+                "api_url": None,
+                "api_key": {"type": "env_var", "env_vars": ["NVIDIA_API_KEY"], "strict": True},
+                "query_prefix": "",
+                "document_prefix": "",
+                "meta_fields_to_embed": [],
+                "embedding_separator": "\n",
+                "timeout": 60.0,
+            },
+        }
+
+    def test_from_dict(self) -> None:
+        client = NvidiaRanker.from_dict(
+            {
+                "type": "haystack_integrations.components.rankers.nvidia.ranker.NvidiaRanker",
+                "init_parameters": {
+                    "model": "nvidia/nv-rerankqa-mistral-4b-v3",
+                    "top_k": 5,
+                    "truncate": None,
+                    "api_url": None,
+                    "api_key": {"type": "env_var", "env_vars": ["NVIDIA_API_KEY"], "strict": True},
+                    "query_prefix": "",
+                    "document_prefix": "",
+                    "meta_fields_to_embed": [],
+                    "embedding_separator": "\n",
+                    "timeout": 45.0,
+                },
+            }
+        )
+        assert client.model == "nvidia/nv-rerankqa-mistral-4b-v3"
+        assert client.top_k == 5
+        assert client.truncate is None
+        assert client.api_url is None
+        assert client.api_key == Secret.from_env_var("NVIDIA_API_KEY")
+        assert client.query_prefix == ""
+        assert client.document_prefix == ""
+        assert client.meta_fields_to_embed == []
+        assert client.embedding_separator == "\n"
+        assert client.timeout == 45.0
+
+    def test_from_dict_defaults(self) -> None:
+        client = NvidiaRanker.from_dict(
+            {
+                "type": "haystack_integrations.components.rankers.nvidia.ranker.NvidiaRanker",
+                "init_parameters": {},
+            }
+        )
+        assert client.model == "nvidia/nv-rerankqa-mistral-4b-v3"
+        assert client.top_k == 5
+        assert client.truncate is None
+        assert client.api_url is None
+        assert client.api_key == Secret.from_env_var("NVIDIA_API_KEY")
+        assert client.query_prefix == ""
+        assert client.document_prefix == ""
+        assert client.meta_fields_to_embed == []
+        assert client.embedding_separator == "\n"
+        assert client.timeout == 60.0
+
+    def test_setting_timeout(self, monkeypatch):
+        monkeypatch.setenv("NVIDIA_API_KEY", "fake-api-key")
+        client = NvidiaRanker(timeout=10.0)
+        client.warm_up()
+        assert client._backend.timeout == 10.0
+
+    def test_setting_timeout_env(self, monkeypatch):
+        monkeypatch.setenv("NVIDIA_API_KEY", "fake-api-key")
+        monkeypatch.setenv("NVIDIA_TIMEOUT", "45")
+        client = NvidiaRanker()
+        client.warm_up()
+        assert client._backend.timeout == 45.0
+
+    def test_prepare_texts_to_embed_w_metadata(self):
+        documents = [
+            Document(content=f"document number {i}:\ncontent", meta={"meta_field": f"meta_value {i}"}) for i in range(5)
+        ]
+
+        ranker = NvidiaRanker(
+            model=None,
+            api_key=Secret.from_token("fake-api-key"),
+            meta_fields_to_embed=["meta_field"],
+            embedding_separator=" | ",
+        )
+
+        prepared_texts = ranker._prepare_documents_to_embed(documents)
+
+        # note that newline is replaced by space
+        assert prepared_texts == [
+            "meta_value 0 | document number 0:\ncontent",
+            "meta_value 1 | document number 1:\ncontent",
+            "meta_value 2 | document number 2:\ncontent",
+            "meta_value 3 | document number 3:\ncontent",
+            "meta_value 4 | document number 4:\ncontent",
+        ]

{nvidia_haystack-0.1.0 → nvidia_haystack-0.1.2}/tests/test_text_embedder.py

@@ -1,3 +1,7 @@
+# SPDX-FileCopyrightText: 2024-present deepset GmbH <info@deepset.ai>
+#
+# SPDX-License-Identifier: Apache-2.0
+
 import os
 
 import pytest
@@ -52,6 +56,7 @@ class TestNvidiaTextEmbedder:
                 "prefix": "",
                 "suffix": "",
                 "truncate": None,
+                "timeout": 60.0,
             },
         }
 
@@ -63,6 +68,7 @@ class TestNvidiaTextEmbedder:
             prefix="prefix",
             suffix="suffix",
             truncate=EmbeddingTruncateMode.START,
+            timeout=10.0,
         )
         data = component.to_dict()
         assert data == {
@@ -74,10 +80,11 @@ class TestNvidiaTextEmbedder:
                 "prefix": "prefix",
                 "suffix": "suffix",
                 "truncate": "START",
+                "timeout": 10.0,
             },
         }
 
-    def from_dict(self, monkeypatch):
+    def test_from_dict(self, monkeypatch):
         monkeypatch.setenv("NVIDIA_API_KEY", "fake-api-key")
         data = {
             "type": "haystack_integrations.components.embedders.nvidia.text_embedder.NvidiaTextEmbedder",
@@ -88,6 +95,7 @@ class TestNvidiaTextEmbedder:
                 "prefix": "prefix",
                 "suffix": "suffix",
                 "truncate": "START",
+                "timeout": 10.0,
             },
         }
         component = NvidiaTextEmbedder.from_dict(data)
@@ -95,7 +103,21 @@ class TestNvidiaTextEmbedder:
         assert component.api_url == "https://example.com/v1"
         assert component.prefix == "prefix"
         assert component.suffix == "suffix"
-        assert component.truncate == "START"
+        assert component.truncate == EmbeddingTruncateMode.START
+        assert component.timeout == 10.0
+
+    def test_from_dict_defaults(self, monkeypatch):
+        monkeypatch.setenv("NVIDIA_API_KEY", "fake-api-key")
+        data = {
+            "type": "haystack_integrations.components.embedders.nvidia.text_embedder.NvidiaTextEmbedder",
+            "init_parameters": {},
+        }
+        component = NvidiaTextEmbedder.from_dict(data)
+        assert component.model == "nvidia/nv-embedqa-e5-v5"
+        assert component.api_url == "https://ai.api.nvidia.com/v1/retrieval/nvidia"
+        assert component.prefix == ""
+        assert component.suffix == ""
+        assert component.truncate is None
 
     @pytest.mark.usefixtures("mock_local_models")
     def test_run_default_model(self):
@@ -158,6 +180,19 @@ class TestNvidiaTextEmbedder:
         with pytest.raises(ValueError, match="empty string"):
             embedder.run(text="")
 
+    def test_setting_timeout(self, monkeypatch):
+        monkeypatch.setenv("NVIDIA_API_KEY", "fake-api-key")
+        embedder = NvidiaTextEmbedder(timeout=10.0)
+        embedder.warm_up()
+        assert embedder.backend.timeout == 10.0
+
+    def test_setting_timeout_env(self, monkeypatch):
+        monkeypatch.setenv("NVIDIA_API_KEY", "fake-api-key")
+        monkeypatch.setenv("NVIDIA_TIMEOUT", "45")
+        embedder = NvidiaTextEmbedder()
+        embedder.warm_up()
+        assert embedder.backend.timeout == 45.0
+
     @pytest.mark.skipif(
         not os.environ.get("NVIDIA_NIM_EMBEDDER_MODEL", None) or not os.environ.get("NVIDIA_NIM_ENDPOINT_URL", None),
         reason="Export an env var called NVIDIA_NIM_EMBEDDER_MODEL containing the hosted model name and "

nvidia_haystack-0.1.0/src/haystack_integrations/components/embedders/nvidia/__init__.py

@@ -1,5 +0,0 @@
-from .document_embedder import NvidiaDocumentEmbedder
-from .text_embedder import NvidiaTextEmbedder
-from .truncate import EmbeddingTruncateMode
-
-__all__ = ["NvidiaDocumentEmbedder", "NvidiaTextEmbedder", "EmbeddingTruncateMode"]

nvidia_haystack-0.1.0/src/haystack_integrations/components/rankers/nvidia/__init__.py

@@ -1,3 +0,0 @@
-from .ranker import NvidiaRanker
-
-__all__ = ["NvidiaRanker"]

nvidia_haystack-0.1.0/src/haystack_integrations/utils/nvidia/__init__.py

@@ -1,4 +0,0 @@
-from .nim_backend import Model, NimBackend
-from .utils import is_hosted, url_validation
-
-__all__ = ["NimBackend", "Model", "is_hosted", "url_validation"]