Only add text-generation and conversational task from feedback

Author: eliasto

docs/source/en/guides/inference.md

@@ -192,7 +192,7 @@ For more details, refer to the [Inference Providers pricing documentation](https
 
 [`InferenceClient`]'s goal is to provide the easiest interface to run inference on Hugging Face models, on any provider. It has a simple API that supports the most common tasks. Here is a table showing which providers support which tasks:
 
-| Task                                                | Black Forest Labs | Cerebras | Clarifai | Cohere | fal-ai | Featherless AI | Fireworks AI | Groq | HF Inference | Hyperbolic | Nebius AI Studio | Novita AI | Nscale | OVHcloud | Public AI | Replicate | Sambanova | Scaleway | Together | Wavespeed | Zai |
+| Task                                                | Black Forest Labs | Cerebras | Clarifai | Cohere | fal-ai | Featherless AI | Fireworks AI | Groq | HF Inference | Hyperbolic | Nebius AI Studio | Novita AI | Nscale | OVHcloud AI Endpoints | Public AI | Replicate | Sambanova | Scaleway | Together | Wavespeed | Zai |
 | --------------------------------------------------- | ----------------- | -------- | -------- | ------ | ------ | -------------- | ------------ | ---- | ------------ | ---------- | ---------------- | --------- | ------ | -------- | ---------- | --------- | --------- | --------- | -------- | --------- | ---- |
 | [`~InferenceClient.audio_classification`]           | ❌                 | ❌        | ❌        | ❌      | ❌      | ❌              | ❌            | ❌    | ✅            | ❌          | ❌                | ❌         | ❌         | ❌        | ❌         | ❌        | ❌      | ❌          | ❌         | ❌         | ❌   |
 | [`~InferenceClient.audio_to_audio`]                 | ❌                 | ❌        | ❌        | ❌      | ❌      | ❌              | ❌            | ❌    | ✅            | ❌          | ❌                | ❌         | ❌         | ❌        | ❌         | ❌        | ❌      | ❌          | ❌         | ❌         | ❌   |

src/huggingface_hub/inference/_providers/__init__.py

@@ -38,7 +38,7 @@
 from .novita import NovitaConversationalTask, NovitaTextGenerationTask, NovitaTextToVideoTask
 from .nscale import NscaleConversationalTask, NscaleTextToImageTask
 from .openai import OpenAIConversationalTask
-from .ovhcloud import OVHcloudAIEndpointsAutomaticSpeechRecognitionTask, OVHcloudAIEndpointsConversationalTask, OVHcloudAIEndpointsFeatureExtractionTask, OVHcloudAIEndpointsTextToImageTask
+from .ovhcloud import OVHcloudAIEndpointsConversationalTask, OVHcloudAIEndpointsTextGenerationTask
 from .publicai import PublicAIConversationalTask
 from .replicate import (
     ReplicateAutomaticSpeechRecognitionTask,
@@ -176,9 +176,7 @@
     },
     "ovhcloud": {
         "conversational": OVHcloudAIEndpointsConversationalTask(),
-        "text-to-image": OVHcloudAIEndpointsTextToImageTask(),
-        "feature-extraction": OVHcloudAIEndpointsFeatureExtractionTask(),
-        "automatic-speech-recognition": OVHcloudAIEndpointsAutomaticSpeechRecognitionTask(),
+        "text-generation": OVHcloudAIEndpointsTextGenerationTask(),
     },
     "publicai": {
         "conversational": PublicAIConversationalTask(),

src/huggingface_hub/inference/_providers/ovhcloud.py

@@ -1,84 +1,34 @@
-import base64
-from abc import ABC
-from typing import Any, Dict, Optional, Union
+from typing import Any, Optional, Union
 
-from huggingface_hub.hf_api import InferenceProviderMapping
 from huggingface_hub.inference._common import RequestParameters, _as_dict
-from huggingface_hub.inference._providers._common import (
-    TaskProviderHelper,
-    filter_none,
-)
+from huggingface_hub.inference._providers._common import BaseConversationalTask, BaseTextGenerationTask
+
 
 _PROVIDER = "ovhcloud"
 _BASE_URL = "https://oai.endpoints.kepler.ai.cloud.ovh.net"
 
-class OVHcloudAIEndpointsTask(TaskProviderHelper, ABC):
-    def __init__(self, task: str):
-        super().__init__(provider=_PROVIDER, base_url=_BASE_URL, task=task)
-
-    def _prepare_route(self, mapped_model: str, api_key: str) -> str:
-        if self.task == "text-to-image":
-            return "/v1/images/generations"
-        elif self.task == "conversational":
-            return "/v1/chat/completions"
-        elif self.task == "feature-extraction":
-            return "/v1/embeddings"
-        elif self.task == "automatic-speech-recognition":
-            return "/v1/audio/transcriptions"
-        raise ValueError(f"Unsupported task '{self.task}' for OVHcloud AI Endpoints.")
-    
-    def _prepare_payload_as_dict(
-        self, messages: Any, parameters: Dict, provider_mapping_info: InferenceProviderMapping
-    ) -> Optional[Dict]:
-        return {"messages": messages, "model": provider_mapping_info.provider_id, **filter_none(parameters)}
-
-
-class OVHcloudAIEndpointsConversationalTask(OVHcloudAIEndpointsTask):
-    def __init__(self):
-        super().__init__("conversational")
-
-    def _prepare_payload_as_dict(
-        self, messages: Any, parameters: dict, provider_mapping_info: InferenceProviderMapping
-    ) -> Optional[dict]:
-        return super()._prepare_payload_as_dict(messages, parameters, provider_mapping_info)
-        
 
-class OVHcloudAIEndpointsTextToImageTask(OVHcloudAIEndpointsTask):
+class OVHcloudAIEndpointsConversationalTask(BaseConversationalTask):
     def __init__(self):
-        super().__init__("text-to-image")
+        super().__init__(provider=_PROVIDER, base_url=_BASE_URL)
 
-    def _prepare_payload_as_dict(
-        self, inputs: Any, parameters: dict, provider_mapping_info: InferenceProviderMapping
-    ) -> Optional[dict]:
-        mapped_model = provider_mapping_info.provider_id
-        return {"prompt": inputs, "model": mapped_model, **filter_none(parameters)}
+    def _prepare_route(self, mapped_model: str, api_key: str) -> str:
+        return "/v1/chat/completions"
 
-    def get_response(self, response: Union[bytes, dict], request_params: Optional[RequestParameters] = None) -> Any:
-        response_dict = _as_dict(response)
-        return base64.b64decode(response_dict["data"][0]["b64_json"])
-    
-class OVHcloudAIEndpointsFeatureExtractionTask(OVHcloudAIEndpointsTask):
-    def __init__(self):
-        super().__init__("feature-extraction")
 
-    def _prepare_payload_as_dict(
-        self, inputs: Any, parameters: Dict, provider_mapping_info: InferenceProviderMapping
-    ) -> Optional[Dict]:
-        return {"input": inputs, "model": provider_mapping_info.provider_id, **filter_none(parameters)}
-    
-    def get_response(self, response: Union[bytes, dict], request_params: Optional[RequestParameters] = None) -> Any:
-        embeddings = _as_dict(response)["data"]
-        return [embedding["embedding"] for embedding in embeddings]
-    
-class OVHcloudAIEndpointsAutomaticSpeechRecognitionTask(OVHcloudAIEndpointsTask):
+class OVHcloudAIEndpointsTextGenerationTask(BaseTextGenerationTask):
     def __init__(self):
-        super().__init__("automatic-speech-recognition")
+        super().__init__(provider=_PROVIDER, base_url=_BASE_URL)
 
-    def _prepare_payload_as_dict(
-        self, inputs: Any, parameters: dict, provider_mapping_info: InferenceProviderMapping
-    ) -> Optional[dict]:
-        return {"file": inputs, "model": provider_mapping_info.provider_id, **filter_none(parameters)}
+    def _prepare_route(self, mapped_model: str, api_key: str) -> str:
+        return "/v1/chat/completions"
 
     def get_response(self, response: Union[bytes, dict], request_params: Optional[RequestParameters] = None) -> Any:
-        response_dict = _as_dict(response)
-        return response_dict["text"]
+        output = _as_dict(response)["choices"][0]
+        return {
+            "generated_text": output["text"],
+            "details": {
+                "finish_reason": output.get("finish_reason"),
+                "seed": output.get("seed"),
+            },
+        }

tests/test_inference_client.py

@@ -118,10 +118,8 @@
         "conversational": "meta-llama/Llama-3.1-8B-Instruct",
     },
     "ovhcloud": {
-        "automatic-speech-recognition": "openai/whisper-large-v3",
         "conversational": "meta-llama/Llama-3.1-8B-Instruct",
-        "feature-extraction": "BAAI/bge-m3",
-        "text-to-image": "stabilityai/stable-diffusion-xl-base-1.0",
+        "text-generation": "meta-llama/Llama-3.1-8B-Instruct",
     },
     "replicate": {
         "text-to-image": "ByteDance/SDXL-Lightning",

tests/test_inference_providers.py

@@ -46,7 +46,10 @@
 from huggingface_hub.inference._providers.novita import NovitaConversationalTask, NovitaTextGenerationTask
 from huggingface_hub.inference._providers.nscale import NscaleConversationalTask, NscaleTextToImageTask
 from huggingface_hub.inference._providers.openai import OpenAIConversationalTask
-from huggingface_hub.inference._providers.ovhcloud import OVHcloudAIEndpointsAutomaticSpeechRecognitionTask, OVHcloudAIEndpointsConversationalTask, OVHcloudAIEndpointsFeatureExtractionTask, OVHcloudAIEndpointsTextToImageTask
+from huggingface_hub.inference._providers.ovhcloud import (
+    OVHcloudAIEndpointsConversationalTask,
+    OVHcloudAIEndpointsTextGenerationTask,
+)
 from huggingface_hub.inference._providers.publicai import PublicAIConversationalTask
 from huggingface_hub.inference._providers.replicate import (
     ReplicateAutomaticSpeechRecognitionTask,
@@ -1470,94 +1473,62 @@ def test_prepare_payload_as_dict(self):
             "top_p": 1,
         }
 
-    def test_prepare_url_feature_extraction(self):
-        helper = OVHcloudAIEndpointsFeatureExtractionTask()
-        assert (
-            helper._prepare_url("hf_token", "username/repo_name")
-            == "https://router.huggingface.co/ovhcloud/v1/embeddings"
-        )
+    def test_prepare_route_conversational(self):
+        helper = OVHcloudAIEndpointsConversationalTask()
+        assert helper._prepare_route("username/repo_name", "hf_token") == "/v1/chat/completions"
 
-    def test_prepare_payload_as_dict_feature_extraction(self):
-        helper = OVHcloudAIEndpointsFeatureExtractionTask()
-        payload = helper._prepare_payload_as_dict(
-            "Example text to embed",
-            {"truncate": True},
-            InferenceProviderMapping(
-                provider="ovhcloud",
-                hf_model_id="BAAI/bge-m3",
-                providerId="BGE-M3",
-                task="feature-extraction",
-                status="live",
-            ),
-        )
-        assert payload == {"input": "Example text to embed", "model": "BGE-M3", "truncate": True}
+    def test_prepare_url_text_generation(self):
+        helper = OVHcloudAIEndpointsTextGenerationTask()
+        url = helper._prepare_url("hf_token", "username/repo_name")
+        assert url == "https://router.huggingface.co/ovhcloud/v1/chat/completions"
 
-    def test_prepare_url_text_to_image(self):
-        helper = OVHcloudAIEndpointsTextToImageTask()
-        assert (
-            helper._prepare_url("hf_token", "username/repo_name")
-            == "https://router.huggingface.co/ovhcloud/v1/images/generations"
-        )
-        
         url = helper._prepare_url("ovhcloud_token", "username/repo_name")
-        assert url == "https://oai.endpoints.kepler.ai.cloud.ovh.net/v1/images/generations"
-
-    def test_prepare_payload_as_dict_text_to_image(self):
-        helper = OVHcloudAIEndpointsTextToImageTask()
-        payload = helper._prepare_payload_as_dict(
-            inputs="a beautiful cat",
-            provider_mapping_info=InferenceProviderMapping(
-                provider="ovhcloud",
-                hf_model_id="stabilityai/stable-diffusion-xl-base-1.0",
-                providerId="stable-diffusion-xl-base-v10",
-                task="text-to-image",
-                status="live",
-            ),
-            parameters={}
-        )
-        assert payload == {
-            "prompt": "a beautiful cat",
-            "model": "stable-diffusion-xl-base-v10",
-        }
-
-    def test_text_to_image_get_response(self):
-        helper = OVHcloudAIEndpointsTextToImageTask()
-        response = helper.get_response({"data": [{"b64_json": base64.b64encode(b"image_bytes").decode()}]})
-        assert response == b"image_bytes"
+        assert url == "https://oai.endpoints.kepler.ai.cloud.ovh.net/v1/chat/completions"
 
-    def test_prepare_url_automatic_speech_recognition(self):
-        helper = OVHcloudAIEndpointsAutomaticSpeechRecognitionTask()
-        assert (
-            helper._prepare_url("hf_token", "username/repo_name")
-            == "https://router.huggingface.co/ovhcloud/v1/audio/transcriptions"
-        )
-        
-        url = helper._prepare_url("ovhcloud_token", "username/repo_name")
-        assert url == "https://oai.endpoints.kepler.ai.cloud.ovh.net/v1/audio/transcriptions"
+    def test_prepare_route_text_generation(self):
+        helper = OVHcloudAIEndpointsTextGenerationTask()
+        assert helper._prepare_route("username/repo_name", "hf_token") == "/v1/chat/completions"
 
-    def test_prepare_payload_as_dict_automatic_speech_recognition(self):
-        helper = OVHcloudAIEndpointsAutomaticSpeechRecognitionTask()
-        
+    def test_prepare_payload_as_dict_text_generation(self):
+        helper = OVHcloudAIEndpointsTextGenerationTask()
         payload = helper._prepare_payload_as_dict(
-            f"data:audio/mpeg;base64,{base64.b64encode(b'dummy_audio_data').decode()}",
-            {},
+            "Once upon a time",
+            {"temperature": 0.7, "max_tokens": 100},
             InferenceProviderMapping(
                 provider="ovhcloud",
-                hf_model_id="openai/whisper-large-v3",
-                providerId="whisper-large-v3",
-                task="automatic-speech-recognition",
+                hf_model_id="meta-llama/Llama-3.1-8B-Instruct",
+                providerId="Llama-3.1-8B-Instruct",
+                task="text-generation",
                 status="live",
             ),
         )
         assert payload == {
-            "file": f"data:audio/mpeg;base64,{base64.b64encode(b'dummy_audio_data').decode()}",
-            "model": "whisper-large-v3",
+            "prompt": "Once upon a time",
+            "temperature": 0.7,
+            "max_tokens": 100,
+            "model": "Llama-3.1-8B-Instruct",
         }
 
-    def test_automatic_speech_recognition_get_response(self):
-        helper = OVHcloudAIEndpointsAutomaticSpeechRecognitionTask()
-        response = helper.get_response({"text": "Hello world"})
-        assert response == "Hello world"
+    def test_text_generation_get_response(self):
+        helper = OVHcloudAIEndpointsTextGenerationTask()
+        response = helper.get_response(
+            {
+                "choices": [
+                    {
+                        "text": " there was a beautiful princess",
+                        "finish_reason": "stop",
+                        "seed": 42,
+                    }
+                ]
+            }
+        )
+        assert response == {
+            "generated_text": " there was a beautiful princess",
+            "details": {
+                "finish_reason": "stop",
+                "seed": 42,
+            },
+        }
 
 
 class TestReplicateProvider: