U 9%eE@sRddlZddlZddlZddlmZddlmZmZmZm Z m Z m Z m Z m Z mZddlmZddlmZddlmZmZmZddlmZmZmZmZmZmZmZmZm Z m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&ddl'm(Z(m)Z)m*Z*m+Z+m,Z,dd l-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3m4Z4m5Z5dd l6m7Z7m8Z8m9Z9m:Z:er6ddl;ZZ>e?e@ZAGd d d ZBdS)N)asdict) TYPE_CHECKINGAnyDictIterableListLiteralOptionalUnionoverload) HTTPError)CaseInsensitiveDict)ALL_INFERENCE_API_FRAMEWORKSINFERENCE_ENDPOINTMAIN_INFERENCE_API_FRAMEWORKS)TASKS_EXPECTING_IMAGESContentTInferenceTimeoutError ModelStatus _b64_encode _b64_to_image_bytes_to_dict_bytes_to_image_bytes_to_list_get_recommended_model _import_numpy_is_tgi_server_open_as_binary_set_as_non_tgi _stream_text_generation_response)TextGenerationParametersTextGenerationRequestTextGenerationResponseTextGenerationStreamResponseraise_text_generation_error)ClassificationOutputConversationalOutputFillMaskOutputImageSegmentationOutputObjectDetectionOutputQuestionAnsweringOutputTableQuestionAnsweringOutputTokenClassificationOutput)BadRequestErrorbuild_hf_headers get_sessionhf_raise_for_status)Imagec@seZdZdZdleeeeedfeeee eefee eefddddZ ddZ e dddddd eeee e feeeeeeed ed d d Ze dddddd eeee e feeeeeeedeed dd Zddddd d eeee e feeeeeeeeeeefd dd Zddeeee edddZddeeeedddZdmdddeee eee eee eefeeedddZddeeeee edddZddeeeee edddZddeeed d!d"d#Zddeeee ed!d$d%Zddeeee ed&d'd(Zddeeee e d&d)d*Z!dnddddddd+eeeeeee"ee"ee"eeeed,d- d.d/Z#ddeeeed&d0d1Z$doedeed2e efe ee efd3d4d5Z%ddeeee e&d&d6d7Z'ddeeeeed8d9d:Z(ddee eeee ed;dd?d@Z*dde eefeeee+dAdBdCZ,e eefee edDdEdFZ-e eefee edDdGdHZ.ddeeee ed!dIdJZ/e dddd dKddd dddddddd dLeed ed eeee"ee"eeeee"ee eeeee"eeee"eeeedMdNdOZ0e dddd dKddd dddddddd dLeeded eeee"ee"eeeee"ee eeeee"eeee"eeee1dMdPdOZ0e dddd dKddd dddddddd dLeed edeeee"ee"eeeee"ee eeeee"eeee"eeeeedMdQdOZ0e dddd dKddd dddddddd dLeededeeee"ee"eeeee"ee eeeee"eeee"eeeee2dMdRdOZ0d d dd dKddd dddddddd d dSeeeeeee"ee"eeeee"ee eeeee"eeee"eeeeeee1eeee2fdTdUdOZ0ddddddd+eeeeeeeeeeeeed,dVdWdXZ3ddeeeed!dYdZZ4ddeeee e5d!d[d\Z6ddeeeed!d]d^Z7d dd_ee eeeee ed`dadbZ8ddee eeee edcdddeZ9dpeeeeedfdgdhZ:dqeee;didjdkZ)r3r5)r:r;r;r<__repr__szInferenceClient.__repr__.)jsondatar3taskstreamF)r@rAr3rBrCr8cCsdSNr;r:r@rAr3rBrCr;r;r<posts zInferenceClient.postTcCsdSrDr;rEr;r;r<rFs c Cs|||}|dk r&|dk r&td|j}|tkrHd|krHd|d<t}|j} t|\} z"t j ||| ||j |j|d} Wn2t k r} zt d|| W5d} ~ XYnXW5QRXzt| |r| n| jWStk r} z| jjdkrx| dk r4t|| kr4t d|d |jd | td | td | dk rpt|jt|d } WYqVW5d} ~ XYqVXqVdS) a  Make a POST request to the inference server. Args: json (`Union[str, Dict, List]`, *optional*): The JSON data to send in the request body. Defaults to None. data (`Union[str, Path, bytes, BinaryIO]`, *optional*): The content to send in the request body. It can be raw bytes, a pointer to an opened file, a local file path, or a URL to an online resource (image, audio file,...). If both `json` and `data` are passed, `data` will take precedence. At least `json` or `data` must be provided. Defaults to None. model (`str`, *optional*): The model to use for inference. Can be a model ID hosted on the Hugging Face Hub or a URL to a deployed Inference Endpoint. Will override the model defined at the instance level. Defaults to None. task (`str`, *optional*): The task to perform on the inference. Used only to default to a recommended model if `model` is not provided. At least `model` or `task` must be provided. Defaults to None. stream (`bool`, *optional*): Whether to iterate over streaming APIs. Returns: bytes: The raw bytes returned by the server. Raises: [`InferenceTimeoutError`]: If the model is unavailable or the request times out. `HTTPError`: If the request fails with an HTTP error status code other than HTTP 503. Nz.Ignoring `json` as `data` is passed as binary.Acceptz image/png)r@rAr6r7r5rCzInference call timed out: iz Model not loaded on the server: z/. Please retry with a higher timeout (current: z).z.Waiting for model to be loaded on the server: ) _resolve_urlwarningswarnr6copyrtimer5rr/rFr7 TimeoutErrorrr0 iter_linescontentr response status_codeloggerinfosleepmax) r:r@rAr3rBrCurlr6t0r5Zdata_as_binaryrQerrorr;r;r<rFsL%     ,  )r3)audior3r8cCs|j||dd}t|S)a Perform audio classification on the provided audio content. Args: audio (Union[str, Path, bytes, BinaryIO]): The audio content to classify. It can be raw audio bytes, a local audio file, or a URL pointing to an audio file. model (`str`, *optional*): The model to use for audio classification. Can be a model ID hosted on the Hugging Face Hub or a URL to a deployed Inference Endpoint. If not provided, the default recommended model for audio classification will be used. Returns: `List[Dict]`: The classification output containing the predicted label and its confidence. Raises: [`InferenceTimeoutError`]: If the model is unavailable or the request times out. `HTTPError`: If the request fails with an HTTP error status code other than HTTP 503. Example: ```py >>> from huggingface_hub import InferenceClient >>> client = InferenceClient() >>> client.audio_classification("audio.flac") [{'score': 0.4976358711719513, 'label': 'hap'}, {'score': 0.3677836060523987, 'label': 'neu'},...] ``` zaudio-classificationrAr3rBrFrr:rZr3rQr;r;r<audio_classifications#z$InferenceClient.audio_classificationcCs|j||dd}t|dS)a2 Perform automatic speech recognition (ASR or audio-to-text) on the given audio content. Args: audio (Union[str, Path, bytes, BinaryIO]): The content to transcribe. It can be raw audio bytes, local audio file, or a URL to an audio file. model (`str`, *optional*): The model to use for ASR. Can be a model ID hosted on the Hugging Face Hub or a URL to a deployed Inference Endpoint. If not provided, the default recommended model for ASR will be used. Returns: str: The transcribed text. Raises: [`InferenceTimeoutError`]: If the model is unavailable or the request times out. `HTTPError`: If the request fails with an HTTP error status code other than HTTP 503. Example: ```py >>> from huggingface_hub import InferenceClient >>> client = InferenceClient() >>> client.automatic_speech_recognition("hello_world.flac") "hello world" ``` zautomatic-speech-recognitionr[textrFrr]r;r;r<automatic_speech_recognition&s!z,InferenceClient.automatic_speech_recognition) parametersr3)r_generated_responsespast_user_inputsrbr3r8cCs\dd|ii}|dk r ||dd<|dk r4||dd<|dk rD||d<|j||dd}t|S) a Generate conversational responses based on the given input text (i.e. chat with the API). Args: text (`str`): The last input from the user in the conversation. generated_responses (`List[str]`, *optional*): A list of strings corresponding to the earlier replies from the model. Defaults to None. past_user_inputs (`List[str]`, *optional*): A list of strings corresponding to the earlier replies from the user. Should be the same length as `generated_responses`. Defaults to None. parameters (`Dict[str, Any]`, *optional*): Additional parameters for the conversational task. Defaults to None. For more details about the available parameters, please refer to [this page](https://huggingface.co/docs/api-inference/detailed_parameters#conversational-task) model (`str`, *optional*): The model to use for the conversational task. Can be a model ID hosted on the Hugging Face Hub or a URL to a deployed Inference Endpoint. If not provided, the default recommended conversational model will be used. Defaults to None. Returns: `Dict`: The generated conversational output. Raises: [`InferenceTimeoutError`]: If the model is unavailable or the request times out. `HTTPError`: If the request fails with an HTTP error status code other than HTTP 503. Example: ```py >>> from huggingface_hub import InferenceClient >>> client = InferenceClient() >>> output = client.conversational("Hi, who are you?") >>> output {'generated_text': 'I am the one who knocks.', 'conversation': {'generated_responses': ['I am the one who knocks.'], 'past_user_inputs': ['Hi, who are you?']}, 'warnings': ['Setting `pad_token_id` to `eos_token_id`:50256 for open-end generation.']} >>> client.conversational( ... "Wow, that's scary!", ... generated_responses=output["conversation"]["generated_responses"], ... past_user_inputs=output["conversation"]["past_user_inputs"], ... ) ``` inputsr_Nrcrdrbconversationalr@r3rBr`)r:r_rcrdrbr3payloadrQr;r;r<rfJs3   zInferenceClient.conversational)imagequestionr3r8cCs&|t|d}|j||dd}t|S)a Answering open-ended questions based on an image. Args: image (`Union[str, Path, bytes, BinaryIO]`): The input image for the context. It can be raw bytes, an image file, or a URL to an online image. question (`str`): Question to be answered. model (`str`, *optional*): The model to use for the visual question answering task. Can be a model ID hosted on the Hugging Face Hub or a URL to a deployed Inference Endpoint. If not provided, the default recommended visual question answering model will be used. Defaults to None. Returns: `List[Dict]`: a list of dictionaries containing the predicted label and associated probability. Raises: `InferenceTimeoutError`: If the model is unavailable or the request times out. `HTTPError`: If the request fails with an HTTP error status code other than HTTP 503. Example: ```py >>> from huggingface_hub import InferenceClient >>> client = InferenceClient() >>> client.visual_question_answering( ... image="https://huggingface.co/datasets/mishig/sample_images/resolve/main/tiger.jpg", ... question="What is the animal doing?" ... ) [{'score': 0.778609573841095, 'answer': 'laying down'},{'score': 0.6957435607910156, 'answer': 'sitting'}, ...] ``` rjrizvisual-question-answeringrgrrFrr:rirjr3rhrQr;r;r<visual_question_answerings(z)InferenceClient.visual_question_answeringcCs&|t|d}|j||dd}t|S)a Answer questions on document images. Args: image (`Union[str, Path, bytes, BinaryIO]`): The input image for the context. It can be raw bytes, an image file, or a URL to an online image. question (`str`): Question to be answered. model (`str`, *optional*): The model to use for the document question answering task. Can be a model ID hosted on the Hugging Face Hub or a URL to a deployed Inference Endpoint. If not provided, the default recommended document question answering model will be used. Defaults to None. Returns: `List[Dict]`: a list of dictionaries containing the predicted label, associated probability, word ids, and page number. Raises: [`InferenceTimeoutError`]: If the model is unavailable or the request times out. `HTTPError`: If the request fails with an HTTP error status code other than HTTP 503. Example: ```py >>> from huggingface_hub import InferenceClient >>> client = InferenceClient() >>> client.document_question_answering(image="https://huggingface.co/spaces/impira/docquery/resolve/2359223c1837a7587402bda0f2643382a6eefeab/invoice.png", question="What is the invoice number?") [{'score': 0.42515629529953003, 'answer': 'us-001', 'start': 16, 'end': 16}] ``` rkzdocument-question-answeringrgrlrmr;r;r<document_question_answerings%z+InferenceClient.document_question_answeringz np.ndarray)r_r3r8cCs,|jd|i|dd}t}|jt|ddS)a  Generate embeddings for a given text. Args: text (`str`): The text to embed. model (`str`, *optional*): The model to use for the conversational task. Can be a model ID hosted on the Hugging Face Hub or a URL to a deployed Inference Endpoint. If not provided, the default recommended conversational model will be used. Defaults to None. Returns: `np.ndarray`: The embedding representing the input text as a float32 numpy array. Raises: [`InferenceTimeoutError`]: If the model is unavailable or the request times out. `HTTPError`: If the request fails with an HTTP error status code other than HTTP 503. Example: ```py >>> from huggingface_hub import InferenceClient >>> client = InferenceClient() >>> client.feature_extraction("Hi, who are you?") array([[ 2.424802 , 2.93384 , 1.1750331 , ..., 1.240499, -0.13776633, -0.7889173 ], [-0.42943227, -0.6364878 , -1.693462 , ..., 0.41978157, -2.4336355 , 0.6162071 ], ..., [ 0.28552425, -0.928395 , -1.2077185 , ..., 0.76810825, -2.1069427 , 0.6236161 ]], dtype=float32) ``` refeature-extractionrgZfloat32)Zdtype)rFrarrayr)r:r_r3rQnpr;r;r<feature_extractions z"InferenceClient.feature_extractioncCs|jd|i|dd}t|S)a Fill in a hole with a missing word (token to be precise). Args: text (`str`): a string to be filled from, must contain the [MASK] token (check model card for exact name of the mask). model (`str`, *optional*): The model to use for the fill mask task. Can be a model ID hosted on the Hugging Face Hub or a URL to a deployed Inference Endpoint. If not provided, the default recommended fill mask model will be used. Defaults to None. Returns: `List[Dict]`: a list of fill mask output dictionaries containing the predicted label, associated probability, token reference, and completed text. Raises: [`InferenceTimeoutError`]: If the model is unavailable or the request times out. `HTTPError`: If the request fails with an HTTP error status code other than HTTP 503. Example: ```py >>> from huggingface_hub import InferenceClient >>> client = InferenceClient() >>> client.fill_mask("The goal of life is .") [{'score': 0.06897063553333282, 'token': 11098, 'token_str': ' happiness', 'sequence': 'The goal of life is happiness.'}, {'score': 0.06554922461509705, 'token': 45075, 'token_str': ' immortality', 'sequence': 'The goal of life is immortality.'}] ``` rez fill-maskrgr\r:r_r3rQr;r;r< fill_masks%zInferenceClient.fill_mask)rir3r8cCs|j||dd}t|S)a Perform image classification on the given image using the specified model. Args: image (`Union[str, Path, bytes, BinaryIO]`): The image to classify. It can be raw bytes, an image file, or a URL to an online image. model (`str`, *optional*): The model to use for image classification. Can be a model ID hosted on the Hugging Face Hub or a URL to a deployed Inference Endpoint. If not provided, the default recommended model for image classification will be used. Returns: `List[Dict]`: a list of dictionaries containing the predicted label and associated probability. Raises: [`InferenceTimeoutError`]: If the model is unavailable or the request times out. `HTTPError`: If the request fails with an HTTP error status code other than HTTP 503. Example: ```py >>> from huggingface_hub import InferenceClient >>> client = InferenceClient() >>> client.image_classification("https://upload.wikimedia.org/wikipedia/commons/thumb/4/43/Cute_dog.jpg/320px-Cute_dog.jpg") [{'score': 0.9779096841812134, 'label': 'Blenheim spaniel'}, ...] ``` zimage-classificationr[r\r:rir3rQr;r;r<image_classification(s!z$InferenceClient.image_classificationcCsf|j||dd}t|}t|tsHtdt|dt|ddd|D]}t|d|d<qL|S) ap Perform image segmentation on the given image using the specified model. You must have `PIL` installed if you want to work with images (`pip install Pillow`). Args: image (`Union[str, Path, bytes, BinaryIO]`): The image to segment. It can be raw bytes, an image file, or a URL to an online image. model (`str`, *optional*): The model to use for image segmentation. Can be a model ID hosted on the Hugging Face Hub or a URL to a deployed Inference Endpoint. If not provided, the default recommended model for image segmentation will be used. Returns: `List[Dict]`: A list of dictionaries containing the segmented masks and associated attributes. Raises: [`InferenceTimeoutError`]: If the model is unavailable or the request times out. `HTTPError`: If the request fails with an HTTP error status code other than HTTP 503. Example: ```py >>> from huggingface_hub import InferenceClient >>> client = InferenceClient() >>> client.image_segmentation("cat.jpg"): [{'score': 0.989008, 'label': 'LABEL_184', 'mask': }, ...] ``` zimage-segmentationr["Server output must be a list. Got : N...mask)rFr isinstancelist ValueErrortypestrr)r:rir3rQoutputitemr;r;r<image_segmentationLs) &z"InferenceClient.image_segmentation)negative_promptheightwidthnum_inference_stepsguidance_scaler3r1) ripromptrrrrrr3r8cKs||||||d| } tdd| Dr6|} d} n:d} dt|i} | D] \} }|dk rN|| di| <qN|j| | |dd}t|S) a; Perform image-to-image translation using a specified model. You must have `PIL` installed if you want to work with images (`pip install Pillow`). Args: image (`Union[str, Path, bytes, BinaryIO]`): The input image for translation. It can be raw bytes, an image file, or a URL to an online image. prompt (`str`, *optional*): The text prompt to guide the image generation. negative_prompt (`str`, *optional*): A negative prompt to guide the translation process. height (`int`, *optional*): The height in pixels of the generated image. width (`int`, *optional*): The width in pixels of the generated image. num_inference_steps (`int`, *optional*): The number of denoising steps. More denoising steps usually lead to a higher quality image at the expense of slower inference. guidance_scale (`float`, *optional*): Higher guidance scale encourages to generate images that are closely linked to the text `prompt`, usually at the expense of lower image quality. model (`str`, *optional*): The model to use for inference. Can be a model ID hosted on the Hugging Face Hub or a URL to a deployed Inference Endpoint. This parameter overrides the model defined at the instance level. Defaults to None. Returns: `Image`: The translated image. Raises: [`InferenceTimeoutError`]: If the model is unavailable or the request times out. `HTTPError`: If the request fails with an HTTP error status code other than HTTP 503. Example: ```py >>> from huggingface_hub import InferenceClient >>> client = InferenceClient() >>> image = client.image_to_image("cat.jpg", prompt="turn the cat into a tiger") >>> image.save("tiger.jpg") ``` )rrrrrrcss|]}|dkVqdSrDr;).0Z parameterr;r;r< sz1InferenceClient.image_to_image..Nrerbzimage-to-image)r@rAr3rB)allvaluesritems setdefaultrFr)r:rirrrrrrr3kwargsrbrArhkeyvaluerQr;r;r<image_to_images&=  zInferenceClient.image_to_imagecCs |j||dd}t|ddS)a Takes an input image and return text. Models can have very different outputs depending on your use case (image captioning, optical character recognition (OCR), Pix2Struct, etc). Please have a look to the model card to learn more about a model's specificities. Args: image (`Union[str, Path, bytes, BinaryIO]`): The input image to caption. It can be raw bytes, an image file, or a URL to an online image.. model (`str`, *optional*): The model to use for inference. Can be a model ID hosted on the Hugging Face Hub or a URL to a deployed Inference Endpoint. This parameter overrides the model defined at the instance level. Defaults to None. Returns: `str`: The generated text. Raises: [`InferenceTimeoutError`]: If the model is unavailable or the request times out. `HTTPError`: If the request fails with an HTTP error status code other than HTTP 503. Example: ```py >>> from huggingface_hub import InferenceClient >>> client = InferenceClient() >>> client.image_to_text("cat.jpg") 'a cat standing in a grassy field ' >>> client.image_to_text("https://upload.wikimedia.org/wikipedia/commons/thumb/4/43/Cute_dog.jpg/320px-Cute_dog.jpg") 'a dog laying on the grass next to a flower pot ' ``` z image-to-textr[rgenerated_textr`rvr;r;r< image_to_texts!zInferenceClient.image_to_textr) frameworksr8cs|dkrt}n|dkrt}nt|tr,|g}tt|}itttddfdd }|D]6}tj t d||j d}t |||| qZD] \}}tt|dd d |<qS) a List models currently deployed on the Inference API service. This helper checks deployed models framework by framework. By default, it will check the 4 main frameworks that are supported and account for 95% of the hosted models. However, if you want a complete list of models you can specify `frameworks="all"` as input. Alternatively, if you know before-hand which framework you are interested in, you can also restrict to search to this one (e.g. `frameworks="text-generation-inference"`). The more frameworks are checked, the more time it will take. This endpoint is mostly useful for discoverability. If you already know which model you want to use and want to check its availability, you can directly use [`~InferenceClient.get_model_status`]. Args: frameworks (`Literal["all"]` or `List[str]` or `str`, *optional*): The frameworks to filter on. By default only a subset of the available frameworks are tested. If set to "all", all available frameworks will be tested. It is also possible to provide a single framework or a custom set of frameworks to check. Returns: `Dict[str, List[str]]`: A dictionary mapping task names to a sorted list of model IDs. Example: ```python >>> from huggingface_hub import InferenceClient >>> client = InferenceClient() # Discover zero-shot-classification models currently deployed >>> models = client.list_deployed_models() >>> models["zero-shot-classification"] ['Narsil/deberta-large-mnli-zero-cls', 'facebook/bart-large-mnli', ...] # List from only 1 framework >>> client.list_deployed_models("text-generation-inference") {'text-generation': ['bigcode/starcoder', 'meta-llama/Llama-2-70b-chat-hf', ...], ...} ``` Nr) frameworkrr8cs^|D]T}|dkr>dg|ddg|dq|dg|dqdS)Nzsentence-transformersrpZmodel_idsentence-similarityrB)rappend)rrr3Zmodels_by_taskr;r<_unpack_response.s z>InferenceClient.list_deployed_models.._unpack_responsez /framework/r6cSs|SrD)lower)xr;r;r<?z6InferenceClient.list_deployed_models..)r)rrr}rr~setrrr/getrr6r0r@rsorted)r:rrrrQrBmodelsr;rr<list_deployed_modelss ,   z$InferenceClient.list_deployed_modelscCsL|j||dd}t|}t|tsHtdt|dt|ddd|S)a Perform object detection on the given image using the specified model. You must have `PIL` installed if you want to work with images (`pip install Pillow`). Args: image (`Union[str, Path, bytes, BinaryIO]`): The image to detect objects on. It can be raw bytes, an image file, or a URL to an online image. model (`str`, *optional*): The model to use for object detection. Can be a model ID hosted on the Hugging Face Hub or a URL to a deployed Inference Endpoint. If not provided, the default recommended model for object detection (DETR) will be used. Returns: `List[ObjectDetectionOutput]`: A list of dictionaries containing the bounding boxes and associated attributes. Raises: [`InferenceTimeoutError`]: If the model is unavailable or the request times out. `HTTPError`: If the request fails with an HTTP error status code other than HTTP 503. `ValueError`: If the request output is not a List. Example: ```py >>> from huggingface_hub import InferenceClient >>> client = InferenceClient() >>> client.object_detection("people.jpg"): [{"score":0.9486683011054993,"label":"person","box":{"xmin":59,"ymin":39,"xmax":420,"ymax":510}}, ... ] ``` zobject-detectionr[rxryNrzr{)rFrr}r~rrr)r:rir3rQrr;r;r<object_detectionBs * &z InferenceClient.object_detection)rjcontextr3r8cCs"||d}|j||dd}t|S)a{ Retrieve the answer to a question from a given text. Args: question (`str`): Question to be answered. context (`str`): The context of the question. model (`str`): The model to use for the question answering task. Can be a model ID hosted on the Hugging Face Hub or a URL to a deployed Inference Endpoint. Returns: `Dict`: a dictionary of question answering output containing the score, start index, end index, and answer. Raises: [`InferenceTimeoutError`]: If the model is unavailable or the request times out. `HTTPError`: If the request fails with an HTTP error status code other than HTTP 503. Example: ```py >>> from huggingface_hub import InferenceClient >>> client = InferenceClient() >>> client.question_answering(question="What's my name?", context="My name is Clara and I live in Berkeley.") {'score': 0.9326562285423279, 'start': 11, 'end': 16, 'answer': 'Clara'} ``` )rjrzquestion-answeringrgr`)r:rjrr3rhrQr;r;r<question_answeringrs! z"InferenceClient.question_answering)sentenceother_sentencesr3r8cCs"|jd||di|dd}t|S)a Compute the semantic similarity between a sentence and a list of other sentences by comparing their embeddings. Args: sentence (`str`): The main sentence to compare to others. other_sentences (`List[str]`): The list of sentences to compare to. model (`str`, *optional*): The model to use for the conversational task. Can be a model ID hosted on the Hugging Face Hub or a URL to a deployed Inference Endpoint. If not provided, the default recommended conversational model will be used. Defaults to None. Returns: `List[float]`: The embedding representing the input text. Raises: [`InferenceTimeoutError`]: If the model is unavailable or the request times out. `HTTPError`: If the request fails with an HTTP error status code other than HTTP 503. Example: ```py >>> from huggingface_hub import InferenceClient >>> client = InferenceClient() >>> client.sentence_similarity( ... "Machine learning is so easy.", ... other_sentences=[ ... "Deep learning is so straightforward.", ... "This is so difficult, like rocket science.", ... "I can't believe how much I struggled with this.", ... ], ... ) [0.7785726189613342, 0.45876261591911316, 0.2906220555305481] ``` re)Zsource_sentenceZ sentencesrrgr\)r:rrr3rQr;r;r<sentence_similaritys ( z#InferenceClient.sentence_similarity)r_rbr3r8cCs8d|i}|dk r||d<|j||dd}t|ddS)a Generate a summary of a given text using a specified model. Args: text (`str`): The input text to summarize. parameters (`Dict[str, Any]`, *optional*): Additional parameters for summarization. Check out this [page](https://huggingface.co/docs/api-inference/detailed_parameters#summarization-task) for more details. model (`str`, *optional*): The model to use for inference. Can be a model ID hosted on the Hugging Face Hub or a URL to a deployed Inference Endpoint. This parameter overrides the model defined at the instance level. Defaults to None. Returns: `str`: The generated summary text. Raises: [`InferenceTimeoutError`]: If the model is unavailable or the request times out. `HTTPError`: If the request fails with an HTTP error status code other than HTTP 503. Example: ```py >>> from huggingface_hub import InferenceClient >>> client = InferenceClient() >>> client.summarization("The Eiffel tower...") 'The Eiffel tower is one of the most famous landmarks in the world....' ``` reNrb summarizationrgrZ summary_textr`)r:r_rbr3rhrQr;r;r<rs %zInferenceClient.summarization)tablequeryr3r8cCs|j||d|dd}t|S)a Retrieve the answer to a question from information given in a table. Args: table (`str`): A table of data represented as a dict of lists where entries are headers and the lists are all the values, all lists must have the same size. query (`str`): The query in plain text that you want to ask the table. model (`str`): The model to use for the table-question-answering task. Can be a model ID hosted on the Hugging Face Hub or a URL to a deployed Inference Endpoint. Returns: `Dict`: a dictionary of table question answering output containing the answer, coordinates, cells and the aggregator used. Raises: [`InferenceTimeoutError`]: If the model is unavailable or the request times out. `HTTPError`: If the request fails with an HTTP error status code other than HTTP 503. Example: ```py >>> from huggingface_hub import InferenceClient >>> client = InferenceClient() >>> query = "How many stars does the transformers repository have?" >>> table = {"Repository": ["Transformers", "Datasets", "Tokenizers"], "Stars": ["36542", "4512", "3934"]} >>> client.table_question_answering(table, query, model="google/tapas-base-finetuned-wtq") {'answer': 'AVERAGE > 36542', 'coordinates': [[0, 1]], 'cells': ['36542'], 'aggregator': 'AVERAGE'} ``` )rrztable-question-answeringrgr`)r:rrr3rQr;r;r<table_question_answerings#z(InferenceClient.table_question_answering)rr3r8cCs|jd|i|dd}t|S)aU Classifying a target category (a group) based on a set of attributes. Args: table (`Dict[str, Any]`): Set of attributes to classify. model (`str`): The model to use for the tabular-classification task. Can be a model ID hosted on the Hugging Face Hub or a URL to a deployed Inference Endpoint. Returns: `List`: a list of labels, one per row in the initial table. Raises: [`InferenceTimeoutError`]: If the model is unavailable or the request times out. `HTTPError`: If the request fails with an HTTP error status code other than HTTP 503. Example: ```py >>> from huggingface_hub import InferenceClient >>> client = InferenceClient() >>> table = { ... "fixed_acidity": ["7.4", "7.8", "10.3"], ... "volatile_acidity": ["0.7", "0.88", "0.32"], ... "citric_acid": ["0", "0", "0.45"], ... "residual_sugar": ["1.9", "2.6", "6.4"], ... "chlorides": ["0.076", "0.098", "0.073"], ... "free_sulfur_dioxide": ["11", "25", "5"], ... "total_sulfur_dioxide": ["34", "67", "13"], ... "density": ["0.9978", "0.9968", "0.9976"], ... "pH": ["3.51", "3.2", "3.23"], ... "sulphates": ["0.56", "0.68", "0.82"], ... "alcohol": ["9.4", "9.8", "12.6"], ... } >>> client.tabular_classification(table=table, model="julien-c/wine-quality") ["5", "5", "5"] ``` rztabular-classificationrgr\r:rr3rQr;r;r<tabular_classification"s)z&InferenceClient.tabular_classificationcCs|jd|i|dd}t|S)a Predicting a numerical target value given a set of attributes/features in a table. Args: table (`Dict[str, Any]`): Set of attributes stored in a table. The attributes used to predict the target can be both numerical and categorical. model (`str`): The model to use for the tabular-regression task. Can be a model ID hosted on the Hugging Face Hub or a URL to a deployed Inference Endpoint. Returns: `List`: a list of predicted numerical target values. Raises: [`InferenceTimeoutError`]: If the model is unavailable or the request times out. `HTTPError`: If the request fails with an HTTP error status code other than HTTP 503. Example: ```py >>> from huggingface_hub import InferenceClient >>> client = InferenceClient() >>> table = { ... "Height": ["11.52", "12.48", "12.3778"], ... "Length1": ["23.2", "24", "23.9"], ... "Length2": ["25.4", "26.3", "26.5"], ... "Length3": ["30", "31.2", "31.1"], ... "Species": ["Bream", "Bream", "Bream"], ... "Width": ["4.02", "4.3056", "4.6961"], ... } >>> client.tabular_regression(table, model="scikit-learn/Fish-Weight") [110, 120, 130] ``` rztabular-regressionrgr\rr;r;r<tabular_regressionNs$z"InferenceClient.tabular_regressioncCs |jd|i|dd}t|dS)a Perform text classification (e.g. sentiment-analysis) on the given text. Args: text (`str`): A string to be classified. model (`str`, *optional*): The model to use for the text classification task. Can be a model ID hosted on the Hugging Face Hub or a URL to a deployed Inference Endpoint. If not provided, the default recommended text classification model will be used. Defaults to None. Returns: `List[Dict]`: a list of dictionaries containing the predicted label and associated probability. Raises: [`InferenceTimeoutError`]: If the model is unavailable or the request times out. `HTTPError`: If the request fails with an HTTP error status code other than HTTP 503. Example: ```py >>> from huggingface_hub import InferenceClient >>> client = InferenceClient() >>> client.text_classification("I like you") [{'label': 'POSITIVE', 'score': 0.9998695850372314}, {'label': 'NEGATIVE', 'score': 0.0001304351753788069}] ``` reztext-classificationrgrr\rtr;r;r<text_classificationusz#InferenceClient.text_classification)detailsrCr3 do_samplemax_new_tokensbest_ofrepetition_penaltyreturn_full_textseedstop_sequences temperaturetop_ktop_ptruncate typical_p watermark)rrrCr3rrrrrrrrrrrrrr8cCsdSrDr;r:rrrCr3rrrrrrrrrrrrrr;r;r<text_generationszInferenceClient.text_generationcCsdSrDr;rr;r;r<rscCsdSrDr;rr;r;r<rscCsdSrDr;rr;r;r<rs)rrCr3rrrrrrrrrrrrrdecoder_input_details)rrrCr3rrrrrrrrrrrrrrr8cCs|r|stdd}t|||||| | | dk r2| ng| | |||||d}t|||d}t|}t|sg}dD](}|d|dk r|||d|=qnt|dkrtd |d t|rtd td}|rt d z|j ||d |d}Wnt k rr}zdt |t rZdt|krZt||j||||||||| | | | | |||||dWYSt|W5d}~XYnX|rt||St|d}|rtf|S|dS)a" Given a prompt, generate the following text. It is recommended to have Pydantic installed in order to get inputs validated. This is preferable as it allow early failures. API endpoint is supposed to run with the `text-generation-inference` backend (TGI). This backend is the go-to solution to run large language models at scale. However, for some smaller models (e.g. "gpt2") the default `transformers` + `api-inference` solution is still in use. Both approaches have very similar APIs, but not exactly the same. This method is compatible with both approaches but some parameters are only available for `text-generation-inference`. If some parameters are ignored, a warning message is triggered but the process continues correctly. To learn more about the TGI project, please refer to https://github.com/huggingface/text-generation-inference. Args: prompt (`str`): Input text. details (`bool`, *optional*): By default, text_generation returns a string. Pass `details=True` if you want a detailed output (tokens, probabilities, seed, finish reason, etc.). Only available for models running on with the `text-generation-inference` backend. stream (`bool`, *optional*): By default, text_generation returns the full generated text. Pass `stream=True` if you want a stream of tokens to be returned. Only available for models running on with the `text-generation-inference` backend. model (`str`, *optional*): The model to use for inference. Can be a model ID hosted on the Hugging Face Hub or a URL to a deployed Inference Endpoint. This parameter overrides the model defined at the instance level. Defaults to None. do_sample (`bool`): Activate logits sampling max_new_tokens (`int`): Maximum number of generated tokens best_of (`int`): Generate best_of sequences and return the one if the highest token logprobs repetition_penalty (`float`): The parameter for repetition penalty. 1.0 means no penalty. See [this paper](https://arxiv.org/pdf/1909.05858.pdf) for more details. return_full_text (`bool`): Whether to prepend the prompt to the generated text seed (`int`): Random sampling seed stop_sequences (`List[str]`): Stop generating tokens if a member of `stop_sequences` is generated temperature (`float`): The value used to module the logits distribution. top_k (`int`): The number of highest probability vocabulary tokens to keep for top-k-filtering. top_p (`float`): If set to < 1, only the smallest set of most probable tokens with probabilities that add up to `top_p` or higher are kept for generation. truncate (`int`): Truncate inputs tokens to the given size typical_p (`float`): Typical Decoding mass See [Typical Decoding for Natural Language Generation](https://arxiv.org/abs/2202.00666) for more information watermark (`bool`): Watermarking with [A Watermark for Large Language Models](https://arxiv.org/abs/2301.10226) decoder_input_details (`bool`): Return the decoder input token logprobs and ids. You must set `details=True` as well for it to be taken into account. Defaults to `False`. Returns: `Union[str, TextGenerationResponse, Iterable[str], Iterable[TextGenerationStreamResponse]]`: Generated text returned from the server: - if `stream=False` and `details=False`, the generated text is returned as a `str` (default) - if `stream=True` and `details=False`, the generated text is returned token by token as a `Iterable[str]` - if `stream=False` and `details=True`, the generated text is returned with more details as a [`~huggingface_hub.inference._text_generation.TextGenerationResponse`] - if `details=True` and `stream=True`, the generated text is returned token by token as a iterable of [`~huggingface_hub.inference._text_generation.TextGenerationStreamResponse`] Raises: `ValidationError`: If input values are not valid. No HTTP call is made to the server. [`InferenceTimeoutError`]: If the model is unavailable or the request times out. `HTTPError`: If the request fails with an HTTP error status code other than HTTP 503. Example: ```py >>> from huggingface_hub import InferenceClient >>> client = InferenceClient() # Case 1: generate text >>> client.text_generation("The huggingface_hub library is ", max_new_tokens=12) '100% open source and built to be easy to use.' # Case 2: iterate over the generated tokens. Useful for large generation. >>> for token in client.text_generation("The huggingface_hub library is ", max_new_tokens=12, stream=True): ... print(token) 100 % open source and built to be easy to use . # Case 3: get more details about the generation process. >>> client.text_generation("The huggingface_hub library is ", max_new_tokens=12, details=True) TextGenerationResponse( generated_text='100% open source and built to be easy to use.', details=Details( finish_reason=, generated_tokens=12, seed=None, prefill=[ InputToken(id=487, text='The', logprob=None), InputToken(id=53789, text=' hugging', logprob=-13.171875), (...) InputToken(id=204, text=' ', logprob=-7.0390625) ], tokens=[ Token(id=1425, text='100', logprob=-1.0175781, special=False), Token(id=16, text='%', logprob=-0.0463562, special=False), (...) Token(id=25, text='.', logprob=-0.5703125, special=False) ], best_of_sequences=None ) ) # Case 4: iterate over the generated tokens with more details. # Last object is more complete, containing the full generated text and the finish reason. >>> for details in client.text_generation("The huggingface_hub library is ", max_new_tokens=12, details=True, stream=True): ... print(details) ... TextGenerationStreamResponse(token=Token(id=1425, text='100', logprob=-1.0175781, special=False), generated_text=None, details=None) TextGenerationStreamResponse(token=Token(id=16, text='%', logprob=-0.0463562, special=False), generated_text=None, details=None) TextGenerationStreamResponse(token=Token(id=1314, text=' open', logprob=-1.3359375, special=False), generated_text=None, details=None) TextGenerationStreamResponse(token=Token(id=3178, text=' source', logprob=-0.28100586, special=False), generated_text=None, details=None) TextGenerationStreamResponse(token=Token(id=273, text=' and', logprob=-0.5961914, special=False), generated_text=None, details=None) TextGenerationStreamResponse(token=Token(id=3426, text=' built', logprob=-1.9423828, special=False), generated_text=None, details=None) TextGenerationStreamResponse(token=Token(id=271, text=' to', logprob=-1.4121094, special=False), generated_text=None, details=None) TextGenerationStreamResponse(token=Token(id=314, text=' be', logprob=-1.5224609, special=False), generated_text=None, details=None) TextGenerationStreamResponse(token=Token(id=1833, text=' easy', logprob=-2.1132812, special=False), generated_text=None, details=None) TextGenerationStreamResponse(token=Token(id=271, text=' to', logprob=-0.08520508, special=False), generated_text=None, details=None) TextGenerationStreamResponse(token=Token(id=745, text=' use', logprob=-0.39453125, special=False), generated_text=None, details=None) TextGenerationStreamResponse(token=Token( id=25, text='.', logprob=-0.5703125, special=False), generated_text='100% open source and built to be easy to use.', details=StreamDetails(finish_reason=, generated_tokens=12, seed=None) ) ``` z`decoder_input_details=True` has been passed to the server but `details=False` is set meaning that the output from the server will be truncated.FN)rrrrrrrstoprrrrrrr)rerCrb)rrrrrbrzRAPI endpoint/model for text-generation is not served via TGI. Ignoring parameters .zAPI endpoint/model for text-generation is not served via TGI. Parameter `details=True` will be ignored meaning only the generated text will be returned.zAPI endpoint/model for text-generation is not served via TGI. Cannot return output as a stream. Please pass `stream=False` as input.ztext-generation)r@r3rBrCz6The following `model_kwargs` are not used by the model)rrrCr3rrrrrrrrrrrrrrr)rJrKr r!rrrlen UserWarningrrFr r}r-rrrr$rrr")r:rrrCr3rrrrrrrrrrrrrrrbrequestrhZignored_parametersrZ bytes_outputerAr;r;r<rs3      )rrrrrrr3r8cKs^d|i} |||||d|} | D] \} } | dk r$| | di| <q$|j| |dd} t| S)a Generate an image based on a given text using a specified model. You must have `PIL` installed if you want to work with images (`pip install Pillow`). Args: prompt (`str`): The prompt to generate an image from. negative_prompt (`str`, *optional*): An optional negative prompt for the image generation. height (`float`, *optional*): The height in pixels of the image to generate. width (`float`, *optional*): The width in pixels of the image to generate. num_inference_steps (`int`, *optional*): The number of denoising steps. More denoising steps usually lead to a higher quality image at the expense of slower inference. guidance_scale (`float`, *optional*): Higher guidance scale encourages to generate images that are closely linked to the text `prompt`, usually at the expense of lower image quality. model (`str`, *optional*): The model to use for inference. Can be a model ID hosted on the Hugging Face Hub or a URL to a deployed Inference Endpoint. This parameter overrides the model defined at the instance level. Defaults to None. Returns: `Image`: The generated image. Raises: [`InferenceTimeoutError`]: If the model is unavailable or the request times out. `HTTPError`: If the request fails with an HTTP error status code other than HTTP 503. Example: ```py >>> from huggingface_hub import InferenceClient >>> client = InferenceClient() >>> image = client.text_to_image("An astronaut riding a horse on the moon.") >>> image.save("astronaut.png") >>> image = client.text_to_image( ... "An astronaut riding a horse on the moon.", ... negative_prompt="low resolution, blurry", ... model="stabilityai/stable-diffusion-2-1", ... ) >>> image.save("better_astronaut.png") ``` re)rrrrrNrbz text-to-imagerg)rrrFr)r:rrrrrrr3rrhrbrrrQr;r;r< text_to_imagesAzInferenceClient.text_to_imagecCs|jd|i|ddS)a Synthesize an audio of a voice pronouncing a given text. Args: text (`str`): The text to synthesize. model (`str`, *optional*): The model to use for inference. Can be a model ID hosted on the Hugging Face Hub or a URL to a deployed Inference Endpoint. This parameter overrides the model defined at the instance level. Defaults to None. Returns: `bytes`: The generated audio. Raises: [`InferenceTimeoutError`]: If the model is unavailable or the request times out. `HTTPError`: If the request fails with an HTTP error status code other than HTTP 503. Example: ```py >>> from pathlib import Path >>> from huggingface_hub import InferenceClient >>> client = InferenceClient() >>> audio = client.text_to_speech("Hello world") >>> Path("hello_world.flac").write_bytes(audio) ``` reztext-to-speechrg)rF)r:r_r3r;r;r<text_to_speechPszInferenceClient.text_to_speechcCs d|i}|j||dd}t|S)a  Perform token classification on the given text. Usually used for sentence parsing, either grammatical, or Named Entity Recognition (NER) to understand keywords contained within text. Args: text (`str`): A string to be classified. model (`str`, *optional*): The model to use for the token classification task. Can be a model ID hosted on the Hugging Face Hub or a URL to a deployed Inference Endpoint. If not provided, the default recommended token classification model will be used. Defaults to None. Returns: `List[Dict]`: List of token classification outputs containing the entity group, confidence score, word, start and end index. Raises: [`InferenceTimeoutError`]: If the model is unavailable or the request times out. `HTTPError`: If the request fails with an HTTP error status code other than HTTP 503. Example: ```py >>> from huggingface_hub import InferenceClient >>> client = InferenceClient() >>> client.token_classification("My name is Sarah Jessica Parker but you can call me Jessica") [{'entity_group': 'PER', 'score': 0.9971321225166321, 'word': 'Sarah Jessica Parker', 'start': 11, 'end': 31}, {'entity_group': 'PER', 'score': 0.9773476123809814, 'word': 'Jessica', 'start': 52, 'end': 59}] ``` reztoken-classificationrgr\)r:r_r3rhrQr;r;r<token_classificationps'z$InferenceClient.token_classificationcCs$|jd|i|dd}t|ddS)u Convert text from one language to another. Check out https://huggingface.co/tasks/translation for more information on how to choose the best model for your specific use case. Source and target languages usually depends on the model. Args: text (`str`): A string to be translated. model (`str`, *optional*): The model to use for the translation task. Can be a model ID hosted on the Hugging Face Hub or a URL to a deployed Inference Endpoint. If not provided, the default recommended translation model will be used. Defaults to None. Returns: `str`: The generated translated text. Raises: [`InferenceTimeoutError`]: If the model is unavailable or the request times out. `HTTPError`: If the request fails with an HTTP error status code other than HTTP 503. Example: ```py >>> from huggingface_hub import InferenceClient >>> client = InferenceClient() >>> client.translation("My name is Wolfgang and I live in Berlin") 'Mein Name ist Wolfgang und ich lebe in Berlin.' >>> client.translation("My name is Wolfgang and I live in Berlin", model="Helsinki-NLP/opus-mt-en-fr") "Je m'appelle Wolfgang et je vis à Berlin." ``` re translationrgrZtranslation_textr`rtr;r;r<rs"zInferenceClient.translation) multi_labelr3)r_labelsrr3r8cCsZt|dkrtd|j|d||dd|dd}t|}dd t|d |d DS) a Provide as input a text and a set of candidate labels to classify the input text. Args: text (`str`): The input text to classify. labels (`List[str]`): List of string possible labels. There must be at least 2 labels. multi_label (`bool`): Boolean that is set to True if classes can overlap. model (`str`, *optional*): The model to use for inference. Can be a model ID hosted on the Hugging Face Hub or a URL to a deployed Inference Endpoint. This parameter overrides the model defined at the instance level. Defaults to None. Returns: `List[Dict]`: List of classification outputs containing the predicted labels and their confidence. Raises: [`InferenceTimeoutError`]: If the model is unavailable or the request times out. `HTTPError`: If the request fails with an HTTP error status code other than HTTP 503. Example: ```py >>> from huggingface_hub import InferenceClient >>> client = InferenceClient() >>> text = ( ... "A new model offers an explanation for how the Galilean satellites formed around the solar system's" ... "largest world. Konstantin Batygin did not set out to solve one of the solar system's most puzzling" ... " mysteries when he went for a run up a hill in Nice, France." ... ) >>> labels = ["space & cosmos", "scientific discovery", "microbiology", "robots", "archeology"] >>> client.zero_shot_classification(text, labels) [ {"label": "scientific discovery", "score": 0.7961668968200684}, {"label": "space & cosmos", "score": 0.18570658564567566}, {"label": "microbiology", "score": 0.00730885099619627}, {"label": "archeology", "score": 0.006258360575884581}, {"label": "robots", "score": 0.004559356719255447}, ] >>> client.zero_shot_classification(text, labels, multi_label=True) [ {"label": "scientific discovery", "score": 0.9829297661781311}, {"label": "space & cosmos", "score": 0.755190908908844}, {"label": "microbiology", "score": 0.0005462635890580714}, {"label": "archeology", "score": 0.00047131875180639327}, {"label": "robots", "score": 0.00030448526376858354}, ] ``` /You must specify at least 2 classes to compare.,)candidate_labelsr)rerbzzero-shot-classificationrgcSsg|]\}}||dqS))labelscorer;)rrrr;r;r< sz.rZscores)rrrFjoinrzip)r:r_rrr3rQrr;r;r<zero_shot_classifications7  z(InferenceClient.zero_shot_classification)rirr3r8cCs@t|dkrtd|jt|dd|id|dd}t|S)a Provide input image and text labels to predict text labels for the image. Args: image (`Union[str, Path, bytes, BinaryIO]`): The input image to caption. It can be raw bytes, an image file, or a URL to an online image. labels (`List[str]`): List of string possible labels. There must be at least 2 labels. model (`str`, *optional*): The model to use for inference. Can be a model ID hosted on the Hugging Face Hub or a URL to a deployed Inference Endpoint. This parameter overrides the model defined at the instance level. Defaults to None. Returns: `List[Dict]`: List of classification outputs containing the predicted labels and their confidence. Raises: [`InferenceTimeoutError`]: If the model is unavailable or the request times out. `HTTPError`: If the request fails with an HTTP error status code other than HTTP 503. Example: ```py >>> from huggingface_hub import InferenceClient >>> client = InferenceClient() >>> client.zero_shot_image_classification( ... "https://upload.wikimedia.org/wikipedia/commons/thumb/4/43/Cute_dog.jpg/320px-Cute_dog.jpg", ... labels=["dog", "cat", "horse"], ... ) [{"label": "dog", "score": 0.956}, ...] ``` rrrr)rirbzzero-shot-image-classificationrg)rrrFrrr)r:rirr3rQr;r;r<zero_shot_image_classification s% z.InferenceClient.zero_shot_image_classification)r3rBr8cCst|p|j}|dk r*|ds&|dr*|S|dkrJ|dkrBtdt|}|dkrftd|d|Std|S)Nzhttp://https://zYou must specify at least a model (repo_id or URL) or a task, either when instantiating `InferenceClient` or when making a request.)rprz /pipeline//z/models/)r3 startswithrrr)r:r3rBr;r;r<rI;s  zInferenceClient._resolve_url)r3r8cCs|p|j}|dkrtd|dr,tdtd|}tj||jd}t|| }d|krpt|dt |d|d |d |d d S) a Get the status of a model hosted on the Inference API. This endpoint is mostly useful when you already know which model you want to use and want to check its availability. If you want to discover already deployed models, you should rather use [`~InferenceClient.list_deployed_models`]. Args: model (`str`, *optional*): Identifier of the model for witch the status gonna be checked. If model is not provided, the model associated with this instance of [`InferenceClient`] will be used. Only InferenceAPI service can be checked so the identifier cannot be a URL. Returns: [`ModelStatus`]: An instance of ModelStatus dataclass, containing information, about the state of the model: load, state, compute type and framework. Example: ```py >>> from huggingface_hub import InferenceClient >>> client = InferenceClient() >>> client.get_model_status("bigcode/starcoder") ModelStatus(loaded=True, state='Loaded', compute_type='gpu', framework='text-generation-inference') ``` NzModel id not provided.rz;Model status is only available for Inference API endpoints.z/status/rrYloadedstate compute_typer)rrrr) r3rrNotImplementedErrorrr/rr6r0r@r)r:r3rWrQZ response_datar;r;r<get_model_statusTs"   z InferenceClient.get_model_status)NNNNN)NN)N)N)NN)N)=__name__ __module__ __qualname____doc__r rr boolfloatrr=r?r rrrbytesrFrr%r^rarr&rfrnr*rorsr'rurwr(rintrrrr)rrrrr+rrrrrr"r#rrr,rrrrrIrrr;r;r;r<r2is    X * '   B 1 )$ , ( 6 T% O 1 * 3 ,  -,'        P /& I /r2)CloggingrMrJ dataclassesrtypingrrrrrrr r r requestsr Zrequests.structuresr Zhuggingface_hub.constantsrrrZ!huggingface_hub.inference._commonrrrrrrrrrrrrrrrZ*huggingface_hub.inference._text_generationr r!r"r#r$Z huggingface_hub.inference._typesr%r&r'r(r)r*r+r,Zhuggingface_hub.utilsr-r.r/r0numpyrrZPILr1 getLoggerrrSr2r;r;r;r<$s  ,  D(