nvidia-haystack 1.0.0__tar.gz → 1.1.1__tar.gz

{nvidia_haystack-1.0.0 → nvidia_haystack-1.1.1}/CHANGELOG.md

@@ -1,5 +1,32 @@
 # Changelog
 
+## [integrations/nvidia-v1.1.0] - 2026-03-30
+
+### 🐛 Bug Fixes
+
+- Nvidia - fix structured output syntax (#3058)
+
+### 📚 Documentation
+
+- *(nvidia)* Remove explicit warm_up from examples (#2843)
+- Simplify pydoc configs (#2855)
+
+### 🧪 Testing
+
+- Test compatible integrations with python 3.14; update pyproject (#3001)
+
+### 🧹 Chores
+
+- Add ANN ruff ruleset to llama_cpp, llama_stack, mcp, meta_llama, mistral, mongodb_atlas, nvidia, ollama, openrouter, opensearch (#2991)
+- Enforce ruff docstring rules (D102/D103/D205/D209/D213/D417/D419) in integrations 21-30 (#3010)
+
+## [integrations/nvidia-v1.0.0] - 2026-01-13
+
+### 🧹 Chores
+
+- [**breaking**] Nvidia - drop Python 3.9 and use X|Y typing; fix default reranking model; improve tests (#2736)
+
+
 ## [integrations/nvidia-v0.5.0] - 2026-01-13
 
 ### 🚀 Features

{nvidia_haystack-1.0.0 → nvidia_haystack-1.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nvidia-haystack
-Version: 1.0.0
+Version: 1.1.1
 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
@@ -14,6 +14,7 @@ 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

nvidia_haystack-1.1.1/pydoc/config_docusaurus.yml

@@ -0,0 +1,19 @@
+loaders:
+  - modules:
+      - haystack_integrations.components.embedders.nvidia.document_embedder
+      - haystack_integrations.components.embedders.nvidia.text_embedder
+      - haystack_integrations.components.embedders.nvidia.truncate
+      - haystack_integrations.components.generators.nvidia.generator
+      - haystack_integrations.components.generators.nvidia.chat.chat_generator
+      - haystack_integrations.components.rankers.nvidia.ranker
+      - haystack_integrations.components.rankers.nvidia.truncate
+    search_path: [../src]
+processors:
+  - type: filter
+    documented_only: true
+    skip_empty_modules: true
+renderer:
+  description: Nvidia integration for Haystack
+  id: integrations-nvidia
+  filename: nvidia.md
+  title: Nvidia

{nvidia_haystack-1.0.0 → nvidia_haystack-1.1.1}/pyproject.toml

@@ -19,6 +19,7 @@ classifiers = [
   "Programming Language :: Python :: 3.11",
   "Programming Language :: Python :: 3.12",
   "Programming Language :: Python :: 3.13",
+  "Programming Language :: Python :: 3.14",
   "Programming Language :: Python :: Implementation :: CPython",
   "Programming Language :: Python :: Implementation :: PyPy",
 ]
@@ -45,7 +46,7 @@ installer = "uv"
 dependencies = ["haystack-pydoc-tools", "ruff"]
 
 [tool.hatch.envs.default.scripts]
-docs = ["pydoc-markdown pydoc/config_docusaurus.yml"]
+docs = ["haystack-pydoc pydoc/config_docusaurus.yml"]
 fmt = "ruff check --fix {args}; ruff format {args}"
 fmt-check = "ruff check {args} && ruff format --check {args}"
 
@@ -65,7 +66,8 @@ dependencies = [
 unit = 'pytest -m "not integration" {args:tests}'
 integration = 'pytest -m "integration" {args:tests}'
 all = 'pytest {args:tests}'
-cov-retry = 'pytest --cov=haystack_integrations --reruns 3 --reruns-delay 30 -x {args:tests}'
+unit-cov-retry = 'pytest --cov=haystack_integrations --reruns 3 --reruns-delay 30 -x -m "not integration" {args:tests}'
+integration-cov-append-retry = 'pytest --cov=haystack_integrations --cov-append --reruns 3 --reruns-delay 30 -x -m "integration" {args:tests}'
 
 types = """mypy -p haystack_integrations.components.embedders.nvidia \
 -p haystack_integrations.components.generators.nvidia \
@@ -86,9 +88,17 @@ line-length = 120
 [tool.ruff.lint]
 select = [
   "A",
+  "ANN",
   "ARG",
   "B",
   "C",
+  "D102",   # Missing docstring in public method
+  "D103",   # Missing docstring in public function
+  "D205",   # 1 blank line required between summary line and description
+  "D209",   # Closing triple quotes go to new line
+  "D213",   # summary lines must be positioned on the second physical line of the docstring
+  "D417",   # Missing argument descriptions in the docstring
+  "D419",   # Docstring is empty
   "DTZ",
   "E",
   "EM",
@@ -126,6 +136,8 @@ ignore = [
   # Misc
   "B008",
   "S101",
+  # Allow `Any` - used legitimately for dynamic types and SDK boundaries
+  "ANN401",
 ]
 
 [tool.ruff.lint.isort]
@@ -136,11 +148,12 @@ ban-relative-imports = "parents"
 
 [tool.ruff.lint.per-file-ignores]
 # Tests can use magic values, assertions, and relative imports
-"tests/**/*" = ["PLR2004", "S101", "TID252"]
+"tests/**/*" = ["D", "PLR2004", "S101", "TID252", "ANN"]
 
 [tool.coverage.run]
 source = ["haystack_integrations"]
 branch = true
+relative_files = true
 parallel = false
 
 

{nvidia_haystack-1.0.0 → nvidia_haystack-1.1.1}/src/haystack_integrations/components/embedders/nvidia/document_embedder.py

@@ -20,8 +20,7 @@ logger = logging.getLogger(__name__)
 @component
 class NvidiaDocumentEmbedder:
     """
-    A component for embedding documents using embedding models provided by
-    [NVIDIA NIMs](https://ai.nvidia.com).
+    A component for embedding documents using embedding models provided by [NVIDIA NIMs](https://ai.nvidia.com).
 
     Usage example:
     ```python
@@ -30,7 +29,7 @@ class NvidiaDocumentEmbedder:
     doc = Document(content="I love pizza!")
 
     text_embedder = NvidiaDocumentEmbedder(model="nvidia/nv-embedqa-e5-v5", api_url="https://integrate.api.nvidia.com/v1")
-    text_embedder.warm_up()
+    # Components warm up automatically on first run.
 
     result = document_embedder.run([doc])
     print(result["documents"][0].embedding)
@@ -107,6 +106,7 @@ class NvidiaDocumentEmbedder:
 
     @classmethod
     def class_name(cls) -> str:
+        """Return the class name identifier for serialization."""
         return "NvidiaDocumentEmbedder"
 
     def default_model(self) -> None:
@@ -253,7 +253,7 @@ class NvidiaDocumentEmbedder:
         if not self._initialized:
             self.warm_up()
 
-        elif not isinstance(documents, list) or (documents and not isinstance(documents[0], Document)):
+        if 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."

{nvidia_haystack-1.0.0 → nvidia_haystack-1.1.1}/src/haystack_integrations/components/embedders/nvidia/text_embedder.py

@@ -18,8 +18,7 @@ logger = logging.getLogger(__name__)
 @component
 class NvidiaTextEmbedder:
     """
-    A component for embedding strings using embedding models provided by
-    [NVIDIA NIMs](https://ai.nvidia.com).
+    A component for embedding strings using embedding models provided by [NVIDIA NIMs](https://ai.nvidia.com).
 
     For models that differentiate between query and document inputs,
     this component embeds the input string as a query.
@@ -31,7 +30,7 @@ class NvidiaTextEmbedder:
     text_to_embed = "I love pizza!"
 
     text_embedder = NvidiaTextEmbedder(model="nvidia/nv-embedqa-e5-v5", api_url="https://integrate.api.nvidia.com/v1")
-    text_embedder.warm_up()
+    # Components warm up automatically on first run.
 
     print(text_embedder.run(text_to_embed))
     ```
@@ -46,7 +45,7 @@ class NvidiaTextEmbedder:
         suffix: str = "",
         truncate: EmbeddingTruncateMode | str | None = None,
         timeout: float | None = None,
-    ):
+    ) -> None:
         """
         Create a NvidiaTextEmbedder component.
 
@@ -90,9 +89,10 @@ class NvidiaTextEmbedder:
 
     @classmethod
     def class_name(cls) -> str:
+        """Return the class name identifier for serialization."""
         return "NvidiaTextEmbedder"
 
-    def default_model(self):
+    def default_model(self) -> None:
         """Set default model in local NIM mode."""
         valid_models = [
             model.id for model in self.available_models if not model.base_model or model.base_model == model.id
@@ -119,7 +119,7 @@ class NvidiaTextEmbedder:
             error_message = "No locally hosted model was found."
             raise ValueError(error_message)
 
-    def warm_up(self):
+    def warm_up(self) -> None:
         """
         Initializes the component.
         """
@@ -205,13 +205,13 @@ class NvidiaTextEmbedder:
         if not self._initialized:
             self.warm_up()
 
-        elif not isinstance(text, str):
+        if not isinstance(text, str):
             msg = (
                 "NvidiaTextEmbedder expects a string as an input."
                 "In case you want to embed a list of Documents, please use the NvidiaDocumentEmbedder."
             )
             raise TypeError(msg)
-        elif not text:
+        if not text:
             msg = "Cannot embed an empty string."
             raise ValueError(msg)
 

{nvidia_haystack-1.0.0 → nvidia_haystack-1.1.1}/src/haystack_integrations/components/embedders/nvidia/truncate.py

@@ -8,6 +8,7 @@ from enum import Enum
 class EmbeddingTruncateMode(Enum):
     """
     Specifies how inputs to the NVIDIA embedding components are truncated.
+
     If START, the input will be truncated from the start.
     If END, the input will be truncated from the end.
     If NONE, an error will be returned (if the input is too long).
@@ -17,7 +18,7 @@ class EmbeddingTruncateMode(Enum):
     END = "END"
     NONE = "NONE"
 
-    def __str__(self):
+    def __str__(self) -> str:
         return self.value
 
     @classmethod

{nvidia_haystack-1.0.0 → nvidia_haystack-1.1.1}/src/haystack_integrations/components/generators/nvidia/chat/chat_generator.py

@@ -21,6 +21,7 @@ logger = logging.getLogger(__name__)
 class NvidiaChatGenerator(OpenAIChatGenerator):
     """
     Enables text generation using NVIDIA generative models.
+
     For supported models, see [NVIDIA Docs](https://build.nvidia.com/models).
 
     Users can pass any text generation parameters valid for the NVIDIA Chat Completion API
@@ -87,21 +88,22 @@ class NvidiaChatGenerator(OpenAIChatGenerator):
             - `stream`: Whether to stream back partial progress. If set, tokens will be sent as data-only server-sent
                 events as they become available, with the stream terminated by a data: [DONE] message.
             - `response_format`: For NVIDIA NIM servers, this parameter has limited support.
-                - The basic JSON mode with `{"type": "json_object"}` is supported by compatible models, to produce
+                The basic JSON mode with `{"type": "json_object"}` is supported by compatible models, to produce
                 valid JSON output.
-                To pass the JSON schema to the model, use the `guided_json` parameter in `extra_body`.
-                For example:
+                To generate structured JSON output, use the `response_format` parameter.
+                Example:
                 ```python
                 generation_kwargs={
-                    "extra_body": {
-                        "nvext": {
-                            "guided_json": {
-                                json_schema
-                        }
+                    "response_format": {
+                        "type": "json_schema",
+                        "json_schema": {
+                            "name": "my_schema",
+                            "schema": json_schema,
+                        },
                     }
                 }
                 ```
-                For more details, see the [NVIDIA NIM documentation](https://docs.nvidia.com/nim/large-language-models/latest/structured-generation.html).
+                For more details, see the [NVIDIA NIM documentation](https://docs.nvidia.com/nim/vision-language-models/latest/structured-generation.html).
         :param tools:
             A list of tools or a Toolset for which the model can prepare calls. This parameter can accept either a
             list of `Tool` objects or a `Toolset` instance.

{nvidia_haystack-1.0.0 → nvidia_haystack-1.1.1}/src/haystack_integrations/components/generators/nvidia/generator.py

@@ -15,8 +15,9 @@ from haystack_integrations.utils.nvidia import DEFAULT_API_URL, Client, Model, N
 @component
 class NvidiaGenerator:
     """
-    Generates text using generative models hosted with
-    [NVIDIA NIM](https://ai.nvidia.com) on the [NVIDIA API Catalog](https://build.nvidia.com/explore/discover).
+    Generates text using generative models hosted with [NVIDIA NIM](https://ai.nvidia.com).
+
+    Available via the [NVIDIA API Catalog](https://build.nvidia.com/explore/discover).
 
     ### Usage example
 
@@ -31,7 +32,7 @@ class NvidiaGenerator:
             "max_tokens": 1024,
         },
     )
-    generator.warm_up()
+    # Components warm up automatically on first run.
 
     result = generator.run(prompt="What is the answer?")
     print(result["replies"])
@@ -88,6 +89,7 @@ class NvidiaGenerator:
 
     @classmethod
     def class_name(cls) -> str:
+        """Return the class name identifier for serialization."""
         return "NvidiaGenerator"
 
     def default_model(self) -> None:
@@ -130,7 +132,7 @@ class NvidiaGenerator:
 
         if not self.is_hosted and not self._model:
             if self.backend.model:
-                self.model = self.backend.model
+                self._model = self.backend.model
             else:
                 self.default_model()
 

{nvidia_haystack-1.0.0 → nvidia_haystack-1.1.1}/src/haystack_integrations/components/rankers/nvidia/ranker.py

@@ -4,6 +4,7 @@
 
 import os
 import warnings
+from dataclasses import replace
 from typing import Any
 
 from haystack import Document, component, default_from_dict, default_to_dict, logging
@@ -18,8 +19,7 @@ logger = logging.getLogger(__name__)
 @component
 class NvidiaRanker:
     """
-    A component for ranking documents using ranking models provided by
-    [NVIDIA NIMs](https://ai.nvidia.com).
+    A component for ranking documents using ranking models provided by [NVIDIA NIMs](https://ai.nvidia.com).
 
     Usage example:
     ```python
@@ -31,7 +31,7 @@ class NvidiaRanker:
         model="nvidia/nv-rerankqa-mistral-4b-v3",
         api_key=Secret.from_env_var("NVIDIA_API_KEY"),
     )
-    ranker.warm_up()
+    # Components warm up automatically on first run.
 
     query = "What is the capital of Germany?"
     documents = [
@@ -120,6 +120,7 @@ class NvidiaRanker:
 
     @classmethod
     def class_name(cls) -> str:
+        """Return the class name identifier for serialization."""
         return "NvidiaRanker"
 
     def to_dict(self) -> dict[str, Any]:
@@ -236,11 +237,8 @@ class NvidiaRanker:
 
         # rank result is list[{index: int, logit: float}] sorted by logit
         sorted_indexes_and_scores = self.backend.rank(query_text=query_text, document_texts=document_texts)
-        sorted_documents = []
-        for item in sorted_indexes_and_scores[:top_k]:
-            # mutate (don't copy) the document because we're only updating the score
-            doc = documents[item["index"]]
-            doc.score = item["logit"]
-            sorted_documents.append(doc)
+        sorted_documents = [
+            replace(documents[item["index"]], score=item["logit"]) for item in sorted_indexes_and_scores[:top_k]
+        ]
 
         return {"documents": sorted_documents}

{nvidia_haystack-1.0.0 → nvidia_haystack-1.1.1}/src/haystack_integrations/components/rankers/nvidia/truncate.py

@@ -8,6 +8,7 @@ from enum import Enum
 class RankerTruncateMode(str, Enum):
     """
     Specifies how inputs to the NVIDIA ranker components are truncated.
+
     If NONE, the input will not be truncated and an error returned instead.
     If END, the input will be truncated from the end.
     """
@@ -15,7 +16,7 @@ class RankerTruncateMode(str, Enum):
     NONE = "NONE"
     END = "END"
 
-    def __str__(self):
+    def __str__(self) -> str:
         return self.value
 
     @classmethod

{nvidia_haystack-1.0.0 → nvidia_haystack-1.1.1}/src/haystack_integrations/utils/nvidia/models.py

@@ -35,7 +35,8 @@ class Model:
     def __hash__(self) -> int:
         return hash(self.id)
 
-    def validate(self):
+    def validate(self) -> int:
+        """Validate the model against the backend and return a sort key."""
         if self.client:
             client = self.client if isinstance(self.client, Client) else Client.from_str(self.client)
             supported = {

{nvidia_haystack-1.0.0 → nvidia_haystack-1.1.1}/src/haystack_integrations/utils/nvidia/nim_backend.py

@@ -29,7 +29,7 @@ class NimBackend:
         model_kwargs: dict[str, Any] | None = None,
         client: str | Client | None = None,
         timeout: float | None = None,
-    ):
+    ) -> None:
         headers = {
             "Content-Type": "application/json",
             "accept": "application/json",
@@ -74,6 +74,7 @@ class NimBackend:
         self.timeout = timeout
 
     def embed(self, texts: list[str]) -> tuple[list[list[float]], dict[str, Any]]:
+        """Compute embeddings for a list of texts via the NIM API."""
         url = f"{self.api_url}/embeddings"
 
         try:
@@ -99,6 +100,7 @@ class NimBackend:
         return embeddings, {"usage": data["usage"]}
 
     def generate(self, prompt: str) -> tuple[list[str], list[dict[str, Any]]]:
+        """Generate text completions for a prompt via the NIM API."""
         # We're using the chat completion endpoint as the NIM API doesn't support
         # the /completions endpoint. So both the non-chat and chat generator will use this.
         # This is the same for local containers and the cloud API.
@@ -152,6 +154,7 @@ class NimBackend:
         return replies, meta
 
     def models(self) -> list[Model]:
+        """Retrieve available models from the NIM API."""
         url = f"{self.api_url}/models"
 
         res = self.session.get(
@@ -175,6 +178,7 @@ class NimBackend:
         return models
 
     def rank(self, query_text: str, document_texts: list[str]) -> list[dict[str, Any]]:
+        """Rank documents by relevance to a query via the NIM API."""
         url = self.api_url
 
         try:

{nvidia_haystack-1.0.0 → nvidia_haystack-1.1.1}/src/haystack_integrations/utils/nvidia/utils.py

@@ -49,6 +49,7 @@ def is_hosted(api_url: str) -> bool:
 def lookup_model(name: str) -> Model | None:
     """
     Lookup a model by name, using only the table of known models.
+
     The name is either:
         - directly in the table
         - an alias in the table
@@ -66,8 +67,7 @@ def lookup_model(name: str) -> Model | None:
 
 def determine_model(name: str) -> Model | None:
     """
-    Determine the model to use based on a name, using
-    only the table of known models.
+    Determine the model to use based on a name, using only the table of known models.
 
     Raise a warning if the model is found to be
     an alias of a known model.

{nvidia_haystack-1.0.0 → nvidia_haystack-1.1.1}/tests/test_document_embedder.py

@@ -354,6 +354,13 @@ class TestNvidiaDocumentEmbedder:
         with pytest.raises(TypeError, match="NvidiaDocumentEmbedder expects a list of Documents as input"):
             embedder.run(documents=list_integers_input)
 
+    def test_run_validates_input_without_prior_warm_up(self):
+        api_key = Secret.from_token("fake-api-key")
+        embedder = NvidiaDocumentEmbedder("nvidia/nv-embedqa-e5-v5", api_key=api_key)
+
+        with pytest.raises(TypeError, match="NvidiaDocumentEmbedder expects a list of Documents as input"):
+            embedder.run(documents="text")
+
     def test_run_empty_document(self, caplog):
         model = "nvidia/nv-embedqa-e5-v5"
         api_key = Secret.from_token("fake-api-key")

{nvidia_haystack-1.0.0 → nvidia_haystack-1.1.1}/tests/test_generator.py

@@ -230,3 +230,73 @@ class TestNvidiaGenerator:
         )
         with pytest.raises(ValueError):
             generator1.warm_up()
+
+    @pytest.mark.usefixtures("mock_local_models")
+    def test_warm_up_falls_back_to_default_model(self, monkeypatch):
+        monkeypatch.setenv("NVIDIA_API_KEY", "fake-api-key")
+        generator = NvidiaGenerator(api_url="http://localhost:8080/v1")
+
+        with pytest.warns(UserWarning, match="Default model is set as:"):
+            generator.warm_up()
+
+        assert generator._model == "model1"
+        assert generator.backend.model == "model1"
+        assert generator.to_dict()["init_parameters"]["model"] == "model1"
+
+    def test_default_model_raises_when_no_valid_models(self, monkeypatch, requests_mock):
+        monkeypatch.setenv("NVIDIA_API_KEY", "fake-api-key")
+        requests_mock.get(
+            "http://localhost:8080/v1/models",
+            json={"data": [{"id": "derived-model", "object": "model", "root": "base-model"}]},
+        )
+        generator = NvidiaGenerator(api_url="http://localhost:8080/v1")
+
+        with pytest.raises(ValueError, match="No locally hosted model was found"):
+            generator.warm_up()
+
+    def test_warm_up_is_idempotent(self, monkeypatch):
+        monkeypatch.setenv("NVIDIA_API_KEY", "fake-api-key")
+        generator = NvidiaGenerator("meta/llama3-8b-instruct")
+        generator.warm_up()
+        backend = generator.backend
+        generator.warm_up()
+        assert generator.backend is backend
+
+    def test_available_models_without_backend(self, monkeypatch):
+        monkeypatch.setenv("NVIDIA_API_KEY", "fake-api-key")
+        generator = NvidiaGenerator("meta/llama3-8b-instruct")
+        assert generator.available_models == []
+
+    @pytest.mark.usefixtures("mock_local_models")
+    def test_available_models_with_backend(self, monkeypatch):
+        monkeypatch.setenv("NVIDIA_API_KEY", "fake-api-key")
+        generator = NvidiaGenerator(model="model1", api_url="http://localhost:8080/v1")
+        generator.warm_up()
+        models = generator.available_models
+        assert len(models) == 1
+        assert models[0].id == "model1"
+
+    def test_from_dict(self, monkeypatch):
+        monkeypatch.setenv("NVIDIA_API_KEY", "fake-api-key")
+        data = {
+            "type": "haystack_integrations.components.generators.nvidia.generator.NvidiaGenerator",
+            "init_parameters": {
+                "api_key": {"env_vars": ["NVIDIA_API_KEY"], "strict": True, "type": "env_var"},
+                "api_url": "https://my.url.com/v1",
+                "model": "meta/llama3-8b-instruct",
+                "model_arguments": {"temperature": 0.5},
+            },
+        }
+        generator = NvidiaGenerator.from_dict(data)
+        assert generator._model == "meta/llama3-8b-instruct"
+        assert generator.api_url == "https://my.url.com/v1"
+        assert generator._model_arguments == {"temperature": 0.5}
+
+    def test_run(self, monkeypatch, mock_local_chat_completion):  # noqa: ARG002
+        monkeypatch.setenv("NVIDIA_API_KEY", "fake-api-key")
+        generator = NvidiaGenerator(model="model1", api_url="http://localhost:8080/v1")
+
+        result = generator.run(prompt="What is the answer?")
+
+        assert result["replies"] == ["Hello!", "How are you?"]
+        assert len(result["meta"]) == 2

{nvidia_haystack-1.0.0 → nvidia_haystack-1.1.1}/tests/test_nim_backend.py

@@ -233,6 +233,36 @@ class TestNimBackend:
                 timeout=60.0,
             )
 
+    def test_embed_raises_on_http_error(self, monkeypatch):
+        error_response = requests.Response()
+        error_response.status_code = 500
+        error_response._content = b"server exploded"
+        with patch("requests.sessions.Session.post", return_value=error_response):
+            monkeypatch.setenv("NVIDIA_API_KEY", "fake-api-key")
+            backend = NimBackend(model="nvidia/nv-embedqa-e5-v5", api_url=DEFAULT_API_URL, client="NvidiaTextEmbedder")
+            with pytest.raises(ValueError, match="Failed to query embedding endpoint"):
+                backend.embed(texts=["a"])
+
+    def test_generate_raises_on_http_error(self, monkeypatch):
+        error_response = requests.Response()
+        error_response.status_code = 500
+        error_response._content = b"server exploded"
+        with patch("requests.sessions.Session.post", return_value=error_response):
+            monkeypatch.setenv("NVIDIA_API_KEY", "fake-api-key")
+            backend = NimBackend(model="meta/llama3-8b-instruct", api_url=DEFAULT_API_URL, client="NvidiaGenerator")
+            with pytest.raises(ValueError, match="Failed to query chat completion endpoint"):
+                backend.generate(prompt="hi")
+
+    def test_models_raises_when_empty(self, monkeypatch):
+        empty_response = requests.Response()
+        empty_response.status_code = 200
+        empty_response._content = json.dumps({"data": []}).encode()
+        with patch("requests.sessions.Session.get", return_value=empty_response):
+            monkeypatch.setenv("NVIDIA_API_KEY", "fake-api-key")
+            backend = NimBackend(model="custom-model", api_url="http://localhost:8000")
+            with pytest.raises(ValueError, match="No hosted model were found"):
+                backend.models()
+
     def test_rank(self, monkeypatch):
         with patch("requests.sessions.Session.post", side_effect=mock_rank_post_response) as mock_post:
             monkeypatch.setenv("NVIDIA_API_KEY", "fake-api-key")
@@ -258,3 +288,27 @@ class TestNimBackend:
                 },
                 timeout=60.0,
             )
+
+    def test_rank_raises_on_http_error(self, monkeypatch):
+        error_response = requests.Response()
+        error_response.status_code = 500
+        error_response._content = b"server exploded"
+        with patch("requests.sessions.Session.post", return_value=error_response):
+            monkeypatch.setenv("NVIDIA_API_KEY", "fake-api-key")
+            backend = NimBackend(
+                model="nvidia/llama-3.2-nv-rerankqa-1b-v2", api_url=DEFAULT_API_URL, client="NvidiaRanker"
+            )
+            with pytest.raises(ValueError, match="Failed to rank endpoint"):
+                backend.rank(query_text="q", document_texts=["a"])
+
+    def test_rank_raises_when_rankings_missing(self, monkeypatch):
+        response = requests.Response()
+        response.status_code = 200
+        response._content = json.dumps({"unexpected": "payload"}).encode()
+        with patch("requests.sessions.Session.post", return_value=response):
+            monkeypatch.setenv("NVIDIA_API_KEY", "fake-api-key")
+            backend = NimBackend(
+                model="nvidia/llama-3.2-nv-rerankqa-1b-v2", api_url=DEFAULT_API_URL, client="NvidiaRanker"
+            )
+            with pytest.raises(ValueError, match="Expected 'rankings' in response"):
+                backend.rank(query_text="q", document_texts=["a"])

{nvidia_haystack-1.0.0 → nvidia_haystack-1.1.1}/tests/test_nvidia_chat_generator.py

@@ -278,7 +278,7 @@ class TestNvidiaChatGenerator:
         reason="Export an env var called NVIDIA_API_KEY containing the NVIDIA API key to run this test.",
     )
     @pytest.mark.integration
-    def test_live_run_with_guided_json_schema(self):
+    def test_live_run_with_json_schema(self):
         json_schema = {
             "type": "object",
             "properties": {"title": {"type": "string"}, "rating": {"type": "number"}},
@@ -295,14 +295,22 @@ class TestNvidiaChatGenerator:
 
         component = NvidiaChatGenerator(
             model="meta/llama-3.1-70b-instruct",
-            generation_kwargs={"extra_body": {"nvext": {"guided_json": json_schema}}},
+            generation_kwargs={
+                "response_format": {
+                    "type": "json_schema",
+                    "json_schema": {
+                        "name": "movie_review",
+                        "schema": json_schema,
+                    },
+                },
+            },
         )
 
         results = component.run(chat_messages)
         assert len(results["replies"]) == 1
         message = results["replies"][0].text
         output = json.loads(message)
-        assert output["title"] == "Inception"
+        assert "Inception" in output["title"]
         assert "rating" in output
 
     @pytest.mark.skipif(

{nvidia_haystack-1.0.0 → nvidia_haystack-1.1.1}/tests/test_ranker.py

@@ -330,6 +330,20 @@ class TestNvidiaRanker:
         client.warm_up()
         assert client.backend.timeout == 45.0
 
+    def test_run_on_empty_list(self, monkeypatch):
+        monkeypatch.setenv("NVIDIA_API_KEY", "fake-api-key")
+        client = NvidiaRanker()
+        client.warm_up()
+        assert client.run(query="q", documents=[]) == {"documents": []}
+
+    def test_run_without_prior_warm_up(self, requests_mock, monkeypatch):
+        monkeypatch.setenv("NVIDIA_API_KEY", "fake-api-key")
+        requests_mock.post(re.compile(r".*ranking"), json={"rankings": [{"index": 0, "logit": 1.0}]})
+        client = NvidiaRanker()
+        result = client.run(query="q", documents=[Document(content="doc")])
+        assert client._initialized is True
+        assert len(result["documents"]) == 1
+
     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)

{nvidia_haystack-1.0.0 → nvidia_haystack-1.1.1}/tests/test_text_embedder.py

@@ -183,6 +183,20 @@ class TestNvidiaTextEmbedder:
         with pytest.raises(ValueError, match="empty string"):
             embedder.run(text="")
 
+    def test_run_validates_input_without_prior_warm_up(self):
+        api_key = Secret.from_token("fake-api-key")
+        embedder = NvidiaTextEmbedder("nvidia/nv-embedqa-e5-v5", api_key=api_key)
+
+        with pytest.raises(TypeError, match="NvidiaTextEmbedder expects a string as an input"):
+            embedder.run(text=[1, 2, 3])
+
+    def test_run_rejects_empty_string_without_prior_warm_up(self):
+        api_key = Secret.from_token("fake-api-key")
+        embedder = NvidiaTextEmbedder("nvidia/nv-embedqa-e5-v5", api_key=api_key)
+
+        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)

{nvidia_haystack-1.0.0 → nvidia_haystack-1.1.1}/tests/test_utils.py

@@ -5,7 +5,12 @@
 import pytest
 
 from haystack_integrations.utils.nvidia import Client, is_hosted
-from haystack_integrations.utils.nvidia.models import CHAT_MODEL_TABLE, EMBEDDING_MODEL_TABLE, RANKING_MODEL_TABLE
+from haystack_integrations.utils.nvidia.models import (
+    CHAT_MODEL_TABLE,
+    EMBEDDING_MODEL_TABLE,
+    RANKING_MODEL_TABLE,
+    Model,
+)
 from haystack_integrations.utils.nvidia.utils import (
     determine_model,
     lookup_model,
@@ -110,3 +115,39 @@ def test_validate_hosted_model_with_client() -> None:
     model = validate_hosted_model("meta/codellama-70b", Client.NVIDIA_GENERATOR)
     assert model is not None
     assert model.client == Client.NVIDIA_GENERATOR
+
+
+# Model
+def test_model_hash_uses_id() -> None:
+    assert hash(Model(id="foo")) == hash("foo")
+
+
+def test_model_validate_with_enum_client() -> None:
+    model = Model(id="foo", model_type="chat", client=Client.NVIDIA_GENERATOR)
+    assert model.validate() == hash("foo")
+
+
+def test_model_validate_with_string_client() -> None:
+    model = Model(id="foo", model_type="chat", client="NvidiaGenerator")
+    assert model.validate() == hash("foo")
+
+
+def test_model_validate_raises_on_incompatible_type() -> None:
+    model = Model(id="foo", model_type="embedding", client=Client.NVIDIA_GENERATOR)
+    with pytest.raises(ValueError, match="not supported by client"):
+        model.validate()
+
+
+def test_model_validate_without_client() -> None:
+    model = Model(id="foo", model_type="chat")
+    assert model.validate() == hash("foo")
+
+
+# Client
+def test_client_from_str_invalid() -> None:
+    with pytest.raises(ValueError, match="Unknown client"):
+        Client.from_str("NotARealClient")
+
+
+def test_client_str_returns_value() -> None:
+    assert str(Client.NVIDIA_GENERATOR) == "NvidiaGenerator"

nvidia_haystack-1.0.0/pydoc/config_docusaurus.yml

@@ -1,34 +0,0 @@
-loaders:
-- ignore_when_discovered:
-  - __init__
-  modules:
-  - haystack_integrations.components.embedders.nvidia.document_embedder
-  - haystack_integrations.components.embedders.nvidia.text_embedder
-  - haystack_integrations.components.embedders.nvidia.truncate
-  - haystack_integrations.components.generators.nvidia.generator
-  - haystack_integrations.components.generators.nvidia.chat.chat_generator
-  - haystack_integrations.components.rankers.nvidia.ranker
-  - haystack_integrations.components.rankers.nvidia.truncate
-  search_path:
-  - ../src
-  type: haystack_pydoc_tools.loaders.CustomPythonLoader
-processors:
-- do_not_filter_modules: false
-  documented_only: true
-  expression: null
-  skip_empty_modules: true
-  type: filter
-- type: smart
-- type: crossref
-renderer:
-  description: Nvidia integration for Haystack
-  id: integrations-nvidia
-  markdown:
-    add_member_class_prefix: false
-    add_method_class_prefix: true
-    classdef_code_block: false
-    descriptive_class_title: false
-    descriptive_module_title: true
-    filename: nvidia.md
-  title: Nvidia
-  type: haystack_pydoc_tools.renderers.DocusaurusRenderer