�
lMg�V � �L � d dl Z d dlZd dlZd dlZd dlZd dlZd dlmZmZm Z m
Z
m Z m Z m
Z
mZmZmZ d dlmZ d dlmZmZmZ d dlmZ d dlmZmZm Z m Z m Z m Z m Z m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z* d dl+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3m4Z4m5Z5m6Z6m7Z7m8Z8m9Z9m:Z:m;Z;m<Z<m=Z=m>Z>m?Z?m@Z@mAZAmBZBmCZCmDZDmEZEmFZFmGZGmHZHmIZImJZJ d dlKmLZL d d lMmNZN d
d lOmPZPmQZQ erd dlRZSd d lTmUZUmVZV d d
lWmXZX ej� eZ� Z[ ej� d� Z] G d� d� Z^ G d� d� Z_ G d� de_� Z` G d� de_� Zay)� N)
�
TYPE_CHECKING�Any�
AsyncIterable�Dict�List�Literal�Optional�Set�Union�overload)�CaseInsensitiveDict)� ALL_INFERENCE_API_FRAMEWORKS�INFERENCE_ENDPOINT� MAIN_INFERENCE_API_FRAMEWORKS)�InferenceTimeoutError)�TASKS_EXPECTING_IMAGES�ContentT� ModelStatus�&_async_stream_chat_completion_response�&_async_stream_text_generation_response� _b64_encode�
_b64_to_image�_bytes_to_dict�_bytes_to_image�_bytes_to_list�_fetch_recommended_models�'_get_unsupported_text_generation_kwargs�
_import_numpy�_open_as_binary�_prepare_payload�'_set_unsupported_text_generation_kwargs�raise_text_generation_error) � AudioClassificationOutputElement�"AudioClassificationOutputTransform�AudioToAudioOutputElement� AutomaticSpeechRecognitionOutput� ChatCompletionInputGrammarType� ChatCompletionInputStreamOptions�ChatCompletionInputToolType�ChatCompletionOutput�ChatCompletionStreamOutput�&DocumentQuestionAnsweringOutputElement�FillMaskOutputElement� ImageClassificationOutputElement� ImageSegmentationOutputElement�ImageToTextOutput� ObjectDetectionOutputElement� QuestionAnsweringOutputElement�SummarizationOutput�#TableQuestionAnsweringOutputElement� TextClassificationOutputElement�!TextClassificationOutputTransform� TextGenerationInputGrammarType�TextGenerationOutput�TextGenerationStreamOutput�TextToImageTargetSize� TextToSpeechEarlyStoppingEnum� TokenClassificationOutputElement� ToolElement�TranslationOutput�$VisualQuestionAnsweringOutputElement�#ZeroShotClassificationOutputElement�(ZeroShotImageClassificationOutputElement)�build_hf_headers)�_deprecate_arguments� )�_async_yield_from�_import_aiohttp)�ClientResponse�
ClientSession)�ImagezAThe following `model_kwargs` are not used by the model: \[(.*?)\]c 6 �< � e Zd ZdZ d�ddddddddd�dee deeedf dee dee eef d ee eef d
ed ee
d ee d
ee ddfd�Z d� Z e
dddddd�deeee ef dee dee dee ded def d�� Ze
dddddd�deeee ef dee dee dee ded dee f d�� Ze
dddddd�deeee ef dee dee dee dedeeee f f d�� Zdddddd�deeee ef dee dee dee dedeeee f f d�Zd � Zd � Zd � Zd � Zdddd �d!edee d"ee d#ed$ dee f
d%�Zdd&�d!edee dee fd'�Z dd&�d!edee de fd(�Z e
ddddddddddddddddddd)�d*ee dee ded d+ee d,eee d-ee d.ee d/ee d0ee d1ee d2ee d3eee d4ee d5ee d6eee!ef d7ee d8eee" d9ee d:ee de#f(d;�� Z$e
ddddddddddddddddddd)�d*ee dee ded d+ee d,eee d-ee d.ee d/ee d0ee d1ee d2ee d3eee d4ee d5ee d6eee!ef d7ee d8eee" d9ee d:ee dee% f(d<�� Z$e
ddddddddddddddddddd)�d*ee dee ded+ee d,eee d-ee d.ee d/ee d0ee d1ee d2ee d3eee d4ee d5ee d6eee!ef d7ee d8eee" d9ee d:ee dee#ee% f f(d=�� Z$ddddddddddddddddddd)�d*ee dee ded+ee d,eee d-ee d.ee d/ee d0ee d1ee d2ee d3eee d4ee d5ee d6eee!ef d7ee d8eee" d9ee d:ee dee#ee% f f(d>�Z$d�dee defd?�Z&dddddddddd@� dAedBedee dCee dDee dEee dFee dGee dHee d"ee dIeeeee ef dee' fdJ�Z(ddddddK�dLedMee dNee dOee dPeedQ dee ddRfdS�Z)ddddT�dLedee dUeee d"ee dee* f
dV�Z+ddddW�dAedee d#eedX d"ee dee, f
dY�Z-ddddddZ�dAedee d[ee d\ee d]eed^ d_ee dee. fd`�Z/ d�ddddddda�dAedbee dcee ddee deee dfee dgee dee ddhfdi�Z0dd&�dAedee de1fdj�Z2 d�dkedeedl ee f de eee f fdm�Z3dddn�dAedee d_ee dee4 fdo�Z5dddddddddp�dBedqedee dree dCee dDee dFee dGee dHee d"ee dee6ee6 f fds�Z7dd&�dteduee dee dee fdv�Z8 e9dwdxgdy�z� dddddd{�dLedxee ee
f dee d|ee d}ee ee
f d~eed de:fd��� Z;ddd��d�e ee
f d�edee dxee ee
f de<f
d��Z=dd&�d�e ee
f dee dee fd��Z>dd&�d�e ee
f dee dee fd��Z?dddd �dLedee d"ee d#ed� dee@ f
d��ZAe
ddddddddddddddddddddddd��dbed�ed ded dee d�ee d�ee d�ee d�ee d+ee d�eeB d�ee d�ee d�ee d2ee d3eee d�eee d5ee d"ee d�ee d:ee dOee d�ee d�ee def0d��� ZCe
ddddddddddddddddddddddd��dbed�ed ded dee d�ee d�ee d�ee d�ee d+ee d�eeB d�ee d�ee d�ee d2ee d3eee d�eee d5ee d"ee d�ee d:ee dOee d�ee d�ee deDf0d��� ZCe
ddddddddddddddddddddddd��dbed�ed ded dee d�ee d�ee d�ee d�ee d+ee d�eeB d�ee d�ee d�ee d2ee d3eee d�eee d5ee d"ee d�ee d:ee dOee d�ee d�ee dee f0d��� ZCe
ddddddddddddddddddddddd��dbed�ed ded dee d�ee d�ee d�ee d�ee d+ee d�eeB d�ee d�ee d�ee d2ee d3eee d�eee d5ee d"ee d�ee d:ee dOee d�ee d�ee deeE f0d��� ZCe
ddddddddddddddddddddddd��dbed�ed dedee d�ee d�ee d�ee d�ee d+ee d�eeB d�ee d�ee d�ee d2ee d3eee d�eee d5ee d"ee d�ee d:ee dOee d�ee d�ee deeDeeE f f0d��� ZCddddddddddddddddddddddd��dbed�ededee d�ee d�ee d�ee d�ee d+ee d�eeB d�ee d�ee d�ee d2ee d3eee d�eee d5ee d"ee d�ee d:ee dOee d�ee d�ee deeeDee eeE f f0d��ZCdddddddddd�� dbedcee ddee deee dfee dgee dee d�ee d�eeF d2ee ddhfd��ZGdddddddddddddddddd��dLedee d�ee d�eeed�f d�ee d�ee d�ee d�ee d�ee d�ee d�ee d�ee d�ee d5ee d"ee d:ee d�ee d�ee def&d��ZHddddd��dLedee d�eed� d�eee d�ee deeI f d��ZJddddddd��dLedee d�ee d�ee d|ee d~eed d}ee ee
f deKfd��ZLddd��dAedBedee d"ee deeM f
d��ZNdddd��dLed�ee d�ed�ee dee deeO f d��ZPddd��dAed�ee dee d�ee deeQ f
d��ZRd�dee dd�fdZSd�dee dee defdÄZTeUdedefdĄ� ZVdd&�dee de ee
f fdńZWd�dee defdƄZXd�dee deYfdDŽZZe[d�dȄ� Z\y)��AsyncInferenceClienta6
Initialize a new Inference Client.
[`InferenceClient`] aims to provide a unified experience to perform inference. The client can be used
seamlessly with either the (free) Inference API or self-hosted Inference Endpoints.
Args:
model (`str`, `optional`):
The model to run inference with. Can be a model id hosted on the Hugging Face Hub, e.g. `meta-llama/Meta-Llama-3-8B-Instruct`
or a URL to a deployed Inference Endpoint. Defaults to None, in which case a recommended model is
automatically selected for the task.
Note: for better compatibility with OpenAI's client, `model` has been aliased as `base_url`. Those 2
arguments are mutually exclusive. If using `base_url` for chat completion, the `/chat/completions` suffix
path will be appended to the base URL (see the [TGI Messages API](https://huggingface.co/docs/text-generation-inference/en/messages_api)
documentation for details). When passing a URL as `model`, the client will not append any suffix path to it.
token (`str` or `bool`, *optional*):
Hugging Face token. Will default to the locally saved token if not provided.
Pass `token=False` if you don't want to send your token to the server.
Note: for better compatibility with OpenAI's client, `token` has been aliased as `api_key`. Those 2
arguments are mutually exclusive and have the exact same behavior.
timeout (`float`, `optional`):
The maximum number of seconds to wait for a response from the server. Loading a new model in Inference
API can take up to several minutes. Defaults to None, meaning it will loop until the server is available.
headers (`Dict[str, str]`, `optional`):
Additional headers to send to the server. By default only the authorization and user-agent headers are sent.
Values in this dictionary will override the default values.
cookies (`Dict[str, str]`, `optional`):
Additional cookies to send to the server.
trust_env ('bool', 'optional'):
Trust environment settings for proxy configuration if the parameter is `True` (`False` by default).
proxies (`Any`, `optional`):
Proxies to use for the request.
base_url (`str`, `optional`):
Base URL to run inference. This is a duplicated argument from `model` to make [`InferenceClient`]
follow the same pattern as `openai.OpenAI` client. Cannot be used if `model` is set. Defaults to None.
api_key (`str`, `optional`):
Token to use for authentication. This is a duplicated argument from `token` to make [`InferenceClient`]
follow the same pattern as `openai.OpenAI` client. Cannot be used if `token` is set. Defaults to None.
NF)�token�timeout�headers�cookies� trust_env�proxies�base_url�api_key�modelrL rM rN rO rP rQ rR rS �returnc �J � |�
|� t d� �|�
| � t d� �|| _ |�|n| | _ t t | j �� � | _ |�| j
j
|� || _ || _ || _ || _
|| _ t � | _
y )Nad Received both `model` and `base_url` arguments. Please provide only one of them. `base_url` is an alias for `model` to make the API compatible with OpenAI's client. If using `base_url` for chat completion, the `/chat/completions` suffix path will be appended to the base url. When passing a URL as `model`, the client will not append any suffix path to it.z�Received both `token` and `api_key` arguments. Please provide only one of them. `api_key` is an alias for `token` to make the API compatible with OpenAI's client. It has the exact same behavior as `token`.)rL )�
ValueErrorrT rL r
rB rN �updaterO rM rP rQ rR �dict� _sessions)
�selfrT rL rM rN rO rP rQ rR rS s
�~C:\Users\noahv\Documents\GitHub\clickup-operator\.venv\Lib\site-packages\huggingface_hub/inference/_generated/_async_client.py�__init__z AsyncInferenceClient.__init__� s� � � � ��!5� �d��
� � ��!4� �>��
� %*��
�6;�6G�U�W��
�*�+;�$�*�*�+M�N�� � � � �L�L� � �� (� �� � �� �"��� �� � !��
� HL�v��� c �X � d| j r | j nd� d| j � d�S )Nz<InferenceClient(model='� z ', timeout=z)>)rT rM �r[ s r\ �__repr__z AsyncInferenceClient.__repr__� s- � �)��
�
�$�*�*��)K�;�W[�Wc�Wc�Vd�df�g�gr^ .)�json�datarT �task�streamrc rd re rf c � � K � y �w�N� �r[ rc rd rT re rf s r\ �postzAsyncInferenceClient.post� s � �� � �� �Tc � � K � y �wrh ri rj s r\ rk zAsyncInferenceClient.post� s � �� � #�rl c � � K � y �wrh ri rj s r\ rk zAsyncInferenceClient.post� s � �� � .1�rl c � �2 K � t � }| j ||� }|�|�t j d� t � }|t
v r d|vrd|d< t
j � } | j }
t |� 5 } | j |�� } | j ||| | j �� � d{ ��� }
d}|
j dk7 r |
j � � d{ ��� }|
j � |rt! | |
� cddd� S |
j# � � d{ ��� }| j% � � d{ ��� |cddd� S 7 ��7 �h# t $ r Y �qw xY w7 �:7 �$# t& j( $ r-}| j% � � d{ ���7 t+ d|� �� |�d}~w|j, $ �r9}|_ | j% � � d{ ���7
j d k( r|�|xj0 d
|� d �z
c_ |
j d k( r�|
�Nt
j � | z
|
kD r4t+ d
|� d| j � d�|j2 |j4 �� |�t6 j9 d|� �� d|vr|j; t< � rd|d< t
j> d� |
�.tA | j t
j � | z
z
d� }
Y d}~ddd� ��j|�d}~wt $ r | j% � � d{ ���7 � w xY w# 1 sw Y nxY w����w)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, specific to each task. Defaults to None.
data (`Union[str, Path, bytes, BinaryIO]`, *optional*):
The content to send in the request body, specific to each task.
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. All available tasks can be found
[here](https://huggingface.co/tasks). 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.
`aiohttp.ClientResponseError`:
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)rN )rc rd �proxy�� zInference call timed out: i� z
. Make sure 'z!' task is supported by the model.i� z Model not loaded on the server: z/. Please retry with a higher timeout (current: z).)�request�responsez.Waiting for model to be loaded on the server: zX-wait-for-model�1� )!rF � _resolve_url�warnings�warnrY r �timerM r �_get_client_sessionrk rQ �statusrc � Exception�raise_for_statusrE �read�close�asyncio� TimeoutErrorr �ClientResponseError�response_error_payload�messagers rt �logger�info�
startswithr �sleep�max)r[ rc rd rT re rf �aiohttp�urlrN �t0rM �data_as_binary�sessionrt r� �content�errors r\ rk zAsyncInferenceClient.post� s� � �� �P "�#��� � ��t�,�� � �� 0� �M�M�J� K� �&�� �)� )�h�g�.E� +�G�H� �
�Y�Y�[���,�,��� ��&�.� �2�2�7�2�C��,�%,�\�\�#�D�~�]a�]i�]i�\�%j� j�H�-1�*� ���#�-�!�;C�=�=�?�5J� 2� �-�-�/� � 0��(� C� 1
� 1
�" )1�
�
��"7�� %�m�m�o�-�-� &�'1
� 1
� k�� 6K�� (� !� �!�� #8��-�� �+�+� _�!�-�-�/�)�)�/�2L�S�E�0R�S�Y^�^�� �2�2� �3I�E�0�!�-�-�/�)�)� ���#�-�$�2B� �
�
�=���>_�)`�`�
� ���#�-�"�.�4�9�9�;��3C�g�3M�"7�"B�3�%� H.�.2�l�l�^�2�!?�(-�
�
�).� � � # �
$)� )� � � �&T�UZ�T[�$\�]�-�W�<�� � �Pb�Ac�:=�G�$6� 7� �
�
�1�
�"�.�&)�$�,�,�$�)�)�+��:J�*K�Q�&O�G� �[1
� 1
�\ �K�� � �!�-�-�/�)�)����_ '�&�� �s� �A=L�?L �"E �5E�6E � E
� E� E
�$ E �
L� E � E� E �6E�7E �<
L�E �E
�
E�E �E�E �E � L�0F�F�F�L�+K �G�D K �L �
L� K � L�>L�?L�L � L� Lc � � K � | S �wrh ri ra s r\ �
__aenter__z AsyncInferenceClient.__aenter__I s � �� �� �s �c � �@ K � | j � � d { ��� y 7 ��wrh )r� )r[ �exc_type� exc_value� tracebacks r\ � __aexit__z AsyncInferenceClient.__aexit__L s � �� ��j�j�l���s � � � c �` � t | j � dkD rt j d� y y )Nr a4 Deleting 'AsyncInferenceClient' client but some sessions are still open. This can happen if you've stopped streaming data from the server before the stream was complete. To close the client properly, you must call `await client.close()` or use an async context (e.g. `async with AsyncInferenceClient(): ...`.)�lenrZ rx ry ra s r\ �__del__z AsyncInferenceClient.__del__O s* � � �t�~�~� �� "� �M�M�Z�
� #r^ c � � K � t j | j j � D �cg c] }|j � �� c}� � d{ ��� yc c}w 7 �
�w)a� Close all open sessions.
By default, 'aiohttp.ClientSession' objects are closed automatically when a call is completed. However, if you
are streaming data from the server and you stop before the stream is complete, you must call this method to
close the session properly.
Another possibility is to use an async context (e.g. `async with AsyncInferenceClient(): ...`).
N)r� �gatherrZ �keysr� )r[ r� s r\ r� zAsyncInferenceClient.closeX sD � �� � �n�n�d�n�n�>Q�>Q�>S� T�>S�7�w�}�}��>S� T�U�U�U�� T�U�s �,A�A�A� A�
A)rT �top_k�function_to_apply�audior� r� r$ c � � K � ||d�}t ||d�� } | j di |�|dd���� d{ ��� }t j |� S 7 ��w)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.
top_k (`int`, *optional*):
When specified, limits the output to the top K most probable classes.
function_to_apply (`"AudioClassificationOutputTransform"`, *optional*):
The function to apply to the output.
Returns:
`List[AudioClassificationOutputElement]`: List of [`AudioClassificationOutputElement`] items containing the predicted labels and their confidence.
Raises:
[`InferenceTimeoutError`]:
If the model is unavailable or the request times out.
`aiohttp.ClientResponseError`:
If the request fails with an HTTP error status code other than HTTP 503.
Example:
```py
# Must be run in an async context
>>> from huggingface_hub import AsyncInferenceClient
>>> client = AsyncInferenceClient()
>>> await client.audio_classification("audio.flac")
[
AudioClassificationOutputElement(score=0.4976358711719513, label='hap'),
AudioClassificationOutputElement(score=0.3677836060523987, label='neu'),
...
]
```
�r� r� T��
parameters�
expect_binaryzaudio-classification�rT re Nri )r rk r# �parse_obj_as_list)r[ r� rT r� r� r� �payloadrt s r\ �audio_classificationz)AsyncInferenceClient.audio_classificationc sV � �� �\ ,=�u�M�
�"�5�Z�t�T��"����W�W�W�E�@V�W�W��/�A�A�(�K�K� X�� �.A �A
�A )rT c � �� K � | j ||d�� � d{ ��� }t j |� }|D ]& }t j |j
� |_ �( |S 7 �F�w)a
Performs multiple tasks related to audio-to-audio depending on the model (eg: speech enhancement, source separation).
Args:
audio (Union[str, Path, bytes, BinaryIO]):
The audio content for the model. It can be raw audio bytes, a local audio file, or a URL pointing to an
audio file.
model (`str`, *optional*):
The model can be any model which takes an audio file and returns another audio file. 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_to_audio will be used.
Returns:
`List[AudioToAudioOutputElement]`: A list of [`AudioToAudioOutputElement`] items containing audios label, content-type, and audio content in blob.
Raises:
`InferenceTimeoutError`:
If the model is unavailable or the request times out.
`aiohttp.ClientResponseError`:
If the request fails with an HTTP error status code other than HTTP 503.
Example:
```py
# Must be run in an async context
>>> from huggingface_hub import AsyncInferenceClient
>>> client = AsyncInferenceClient()
>>> audio_output = await client.audio_to_audio("audio.flac")
>>> async for i, item in enumerate(audio_output):
>>> with open(f"output_{i}.flac", "wb") as f:
f.write(item.blob)
```
zaudio-to-audio�rd rT re N)rk r% r� �base64� b64decode�blob)r[ r� rT rt � audio_output�items r\ �audio_to_audioz#AsyncInferenceClient.audio_to_audio� s] � �� �L ����U�AQ��R�R��0�B�B�8�L� � �D� �(�(����3�D�I� !��� S�s �A#�A!�AA#c � �p K � | j ||d�� � d{ ��� }t j |� S 7 ��w)a�
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:
[`AutomaticSpeechRecognitionOutput`]: An item containing the transcribed text and optionally the timestamp chunks.
Raises:
[`InferenceTimeoutError`]:
If the model is unavailable or the request times out.
`aiohttp.ClientResponseError`:
If the request fails with an HTTP error status code other than HTTP 503.
Example:
```py
# Must be run in an async context
>>> from huggingface_hub import AsyncInferenceClient
>>> client = AsyncInferenceClient()
>>> await client.automatic_speech_recognition("hello_world.flac").text
"hello world"
```
z automatic-speech-recognitionr� N)rk r& �parse_obj_as_instance)r[ r� rT rt s r\ � automatic_speech_recognitionz1AsyncInferenceClient.automatic_speech_recognition� s8 � �� �D ����U�A_��`�`��/�E�E�h�O�O� a�s �6�4�6)rT rf �frequency_penalty�
logit_bias�logprobs�
max_tokens�n�presence_penalty�response_format�seed�stop�stream_options� temperature� tool_choice� tool_prompt�tools� top_logprobs�top_p�messagesr� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� c � � K � y �wrh ri �r[ r� rT rf r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� s r\ �chat_completionz$AsyncInferenceClient.chat_completion� s � �� �. #�rl c � � K � y �wrh ri r� s r\ r� z$AsyncInferenceClient.chat_completion s � �� �. 58�rl c � � K � y �wrh ri r� s r\ r� z$AsyncInferenceClient.chat_completion s
� �� �. RU�rl c � �� K � | j |� }|xs | j xs d}|j d� rd}t di d|�d|�d|�d|�d|�d|�d |�d
| �d |
�d | �d
| �d|�d|�d|�d|�d|�d|�d|�d|
��}|j � D ��ci c] \ }}|�� ||��
}}}| j |||�� � d{ ��� }|r t
|� S t j |� S c c}}w 7 �,�w)aZ:
A method for completing conversations using a specified language model.
<Tip>
The `client.chat_completion` method is aliased as `client.chat.completions.create` for compatibility with OpenAI's client.
Inputs and outputs are strictly the same and using either syntax will yield the same results.
Check out the [Inference guide](https://huggingface.co/docs/huggingface_hub/guides/inference#openai-compatibility)
for more details about OpenAI's compatibility.
</Tip>
Args:
messages (List of [`ChatCompletionInputMessage`]):
Conversation history consisting of roles and content pairs.
model (`str`, *optional*):
The model to use for chat-completion. 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 chat-based text-generation will be used.
See https://huggingface.co/tasks/text-generation for more details.
If `model` is a model ID, it is passed to the server as the `model` parameter. If you want to define a
custom URL while setting `model` in the request payload, you must set `base_url` when initializing [`InferenceClient`].
frequency_penalty (`float`, *optional*):
Penalizes new tokens based on their existing frequency
in the text so far. Range: [-2.0, 2.0]. Defaults to 0.0.
logit_bias (`List[float]`, *optional*):
Modify the likelihood of specified tokens appearing in the completion. Accepts a JSON object that maps tokens
(specified by their token ID in the tokenizer) to an associated bias value from -100 to 100. Mathematically,
the bias is added to the logits generated by the model prior to sampling. The exact effect will vary per model,
but values between -1 and 1 should decrease or increase likelihood of selection; values like -100 or 100 should
result in a ban or exclusive selection of the relevant token. Defaults to None.
logprobs (`bool`, *optional*):
Whether to return log probabilities of the output tokens or not. If true, returns the log
probabilities of each output token returned in the content of message.
max_tokens (`int`, *optional*):
Maximum number of tokens allowed in the response. Defaults to 20.
n (`int`, *optional*):
UNUSED.
presence_penalty (`float`, *optional*):
Number between -2.0 and 2.0. Positive values penalize new tokens based on whether they appear in the
text so far, increasing the model's likelihood to talk about new topics.
response_format ([`ChatCompletionInputGrammarType`], *optional*):
Grammar constraints. Can be either a JSONSchema or a regex.
seed (Optional[`int`], *optional*):
Seed for reproducible control flow. Defaults to None.
stop (Optional[`str`], *optional*):
Up to four strings which trigger the end of the response.
Defaults to None.
stream (`bool`, *optional*):
Enable realtime streaming of responses. Defaults to False.
stream_options ([`ChatCompletionInputStreamOptions`], *optional*):
Options for streaming completions.
temperature (`float`, *optional*):
Controls randomness of the generations. Lower values ensure
less random completions. Range: [0, 2]. Defaults to 1.0.
top_logprobs (`int`, *optional*):
An integer between 0 and 5 specifying the number of most likely tokens to return at each token
position, each with an associated log probability. logprobs must be set to true if this parameter is
used.
top_p (`float`, *optional*):
Fraction of the most likely next words to sample from.
Must be between 0 and 1. Defaults to 1.0.
tool_choice ([`ChatCompletionInputToolType`] or `str`, *optional*):
The tool to use for the completion. Defaults to "auto".
tool_prompt (`str`, *optional*):
A prompt to be appended before the tools.
tools (List of [`ToolElement`], *optional*):
A list of tools the model may call. Currently, only functions are supported as a tool. Use this to
provide a list of functions the model may generate JSON inputs for.
Returns:
[`ChatCompletionOutput`] or Iterable of [`ChatCompletionStreamOutput`]:
Generated text returned from the server:
- if `stream=False`, the generated text is returned as a [`ChatCompletionOutput`] (default).
- if `stream=True`, the generated text is returned token by token as a sequence of [`ChatCompletionStreamOutput`].
Raises:
[`InferenceTimeoutError`]:
If the model is unavailable or the request times out.
`aiohttp.ClientResponseError`:
If the request fails with an HTTP error status code other than HTTP 503.
Example:
```py
# Must be run in an async context
>>> from huggingface_hub import AsyncInferenceClient
>>> messages = [{"role": "user", "content": "What is the capital of France?"}]
>>> client = AsyncInferenceClient("meta-llama/Meta-Llama-3-8B-Instruct")
>>> await client.chat_completion(messages, max_tokens=100)
ChatCompletionOutput(
choices=[
ChatCompletionOutputComplete(
finish_reason='eos_token',
index=0,
message=ChatCompletionOutputMessage(
role='assistant',
content='The capital of France is Paris.',
name=None,
tool_calls=None
),
logprobs=None
)
],
created=1719907176,
id='',
model='meta-llama/Meta-Llama-3-8B-Instruct',
object='text_completion',
system_fingerprint='2.0.4-sha-f426a33',
usage=ChatCompletionOutputUsage(
completion_tokens=8,
prompt_tokens=17,
total_tokens=25
)
)
```
Example using streaming:
```py
# Must be run in an async context
>>> from huggingface_hub import AsyncInferenceClient
>>> messages = [{"role": "user", "content": "What is the capital of France?"}]
>>> client = AsyncInferenceClient("meta-llama/Meta-Llama-3-8B-Instruct")
>>> async for token in await client.chat_completion(messages, max_tokens=10, stream=True):
... print(token)
ChatCompletionStreamOutput(choices=[ChatCompletionStreamOutputChoice(delta=ChatCompletionStreamOutputDelta(content='The', role='assistant'), index=0, finish_reason=None)], created=1710498504)
ChatCompletionStreamOutput(choices=[ChatCompletionStreamOutputChoice(delta=ChatCompletionStreamOutputDelta(content=' capital', role='assistant'), index=0, finish_reason=None)], created=1710498504)
(...)
ChatCompletionStreamOutput(choices=[ChatCompletionStreamOutputChoice(delta=ChatCompletionStreamOutputDelta(content=' may', role='assistant'), index=0, finish_reason=None)], created=1710498504)
```
Example using OpenAI's syntax:
```py
# Must be run in an async context
# instead of `from openai import OpenAI`
from huggingface_hub import AsyncInferenceClient
# instead of `client = OpenAI(...)`
client = AsyncInferenceClient(
base_url=...,
api_key=...,
)
output = await client.chat.completions.create(
model="meta-llama/Meta-Llama-3-8B-Instruct",
messages=[
{"role": "system", "content": "You are a helpful assistant."},
{"role": "user", "content": "Count to 10"},
],
stream=True,
max_tokens=1024,
)
for chunk in output:
print(chunk.choices[0].delta.content)
```
Example using Image + Text as input:
```py
# Must be run in an async context
>>> from huggingface_hub import AsyncInferenceClient
# provide a remote URL
>>> image_url ="https://cdn.britannica.com/61/93061-050-99147DCE/Statue-of-Liberty-Island-New-York-Bay.jpg"
# or a base64-encoded image
>>> image_path = "/path/to/image.jpeg"
>>> with open(image_path, "rb") as f:
... base64_image = base64.b64encode(f.read()).decode("utf-8")
>>> image_url = f"data:image/jpeg;base64,{base64_image}"
>>> client = AsyncInferenceClient("meta-llama/Llama-3.2-11B-Vision-Instruct")
>>> output = await client.chat.completions.create(
... messages=[
... {
... "role": "user",
... "content": [
... {
... "type": "image_url",
... "image_url": {"url": image_url},
... },
... {
... "type": "text",
... "text": "Describe this image in one sentence.",
... },
... ],
... },
... ],
... )
>>> output
The image depicts the iconic Statue of Liberty situated in New York Harbor, New York, on a clear day.
```
Example using tools:
```py
# Must be run in an async context
>>> client = AsyncInferenceClient("meta-llama/Meta-Llama-3-70B-Instruct")
>>> messages = [
... {
... "role": "system",
... "content": "Don't make assumptions about what values to plug into functions. Ask for clarification if a user request is ambiguous.",
... },
... {
... "role": "user",
... "content": "What's the weather like the next 3 days in San Francisco, CA?",
... },
... ]
>>> tools = [
... {
... "type": "function",
... "function": {
... "name": "get_current_weather",
... "description": "Get the current weather",
... "parameters": {
... "type": "object",
... "properties": {
... "location": {
... "type": "string",
... "description": "The city and state, e.g. San Francisco, CA",
... },
... "format": {
... "type": "string",
... "enum": ["celsius", "fahrenheit"],
... "description": "The temperature unit to use. Infer this from the users location.",
... },
... },
... "required": ["location", "format"],
... },
... },
... },
... {
... "type": "function",
... "function": {
... "name": "get_n_day_weather_forecast",
... "description": "Get an N-day weather forecast",
... "parameters": {
... "type": "object",
... "properties": {
... "location": {
... "type": "string",
... "description": "The city and state, e.g. San Francisco, CA",
... },
... "format": {
... "type": "string",
... "enum": ["celsius", "fahrenheit"],
... "description": "The temperature unit to use. Infer this from the users location.",
... },
... "num_days": {
... "type": "integer",
... "description": "The number of days to forecast",
... },
... },
... "required": ["location", "format", "num_days"],
... },
... },
... },
... ]
>>> response = await client.chat_completion(
... model="meta-llama/Meta-Llama-3-70B-Instruct",
... messages=messages,
... tools=tools,
... tool_choice="auto",
... max_tokens=500,
... )
>>> response.choices[0].message.tool_calls[0].function
ChatCompletionOutputFunctionDefinition(
arguments={
'location': 'San Francisco, CA',
'format': 'fahrenheit',
'num_days': 3
},
name='get_n_day_weather_forecast',
description=None
)
```
Example using response_format:
```py
# Must be run in an async context
>>> from huggingface_hub import AsyncInferenceClient
>>> client = AsyncInferenceClient("meta-llama/Meta-Llama-3-70B-Instruct")
>>> messages = [
... {
... "role": "user",
... "content": "I saw a puppy a cat and a raccoon during my bike ride in the park. What did I saw and when?",
... },
... ]
>>> response_format = {
... "type": "json",
... "value": {
... "properties": {
... "location": {"type": "string"},
... "activity": {"type": "string"},
... "animals_seen": {"type": "integer", "minimum": 1, "maximum": 5},
... "animals": {"type": "array", "items": {"type": "string"}},
... },
... "required": ["location", "activity", "animals_seen", "animals"],
... },
... }
>>> response = await client.chat_completion(
... messages=messages,
... response_format=response_format,
... max_tokens=500,
)
>>> response.choices[0].message.content
'{
"activity": "bike ride",
"animals": ["puppy", "cat", "raccoon"],
"animals_seen": 3,
"location": "park"}'
```
�tgi��http://�https://rT r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� rf r� N)rT rc rf ri ) � _resolve_chat_completion_urlrT r� rY �itemsrk r r* r� )r[ r� rT rf r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� � model_url�model_idr� �key�valuerd s r\ r� z$AsyncInferenceClient.chat_completion2 sn � �� �X
�5�5�e�<� � �/�D�J�J�/�%�� � � � 6� 7� �H��
��
� �
� 0�
� "�
�
�
� "�
� �
� .�
� ,�
� �
� �
� $�
� $�
� $�
� �
� &�!
�" �#
�$ �%
�& *�'
��* 18�
�
��U��*�#�u�5�CT�3��:���U��Y�Y�Y�W�V�Y�L�L�� �9�$�?� ?�#�9�9�$�?�?��
V�L�s$ �BC)�
C!�C!� C)�:C'�;-C)c �. � | j xs# | j xs |xs | j d� }|j d� r|n| j |d�� }|j d� }|j
d� r|dz
}|j
d� s|dz
}|S )N�text-generationr� )re �/z/v1z/chat/completionsz/v1/chat/completions)rR rT �get_recommended_modelr� rw �rstrip�endswith)r[ rT �model_id_or_urlr� s r\ r� z1AsyncInferenceClient._resolve_chat_completion_url� s� � � �-�-�o�4�:�:�o��o�$�B\�B\�]n�Bo��
�)�)�*A�B�
��"�"�?�9J�"�K� � �$�$�S�)� � � � �e� $� �,� ,�I� �!�!�"5�6� �/� /�I��r^ ) rT �
doc_stride�handle_impossible_answer�lang�max_answer_len�max_question_len� max_seq_lenr� �
word_boxes�image�questionr� r� r� r� r� r� r� c � �� K � |t |� d�} |||||| |
| d�}
t | |
�� } | j di |�|dd���� d{ ��� }t j |� S 7 ��w)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.
doc_stride (`int`, *optional*):
If the words in the document are too long to fit with the question for the model, it will
be split in several chunks with some overlap. This argument controls the size of that
overlap.
handle_impossible_answer (`bool`, *optional*):
Whether to accept impossible as an answer.
lang (`str`, *optional*):
Language to use while running OCR.
max_answer_len (`int`, *optional*):
The maximum length of predicted answers (e.g., only answers with a shorter length are
considered).
max_question_len (`int`, *optional*):
The maximum length of the question after tokenization. It will be truncated if needed.
max_seq_len (`int`, *optional*):
The maximum length of the total sentence (context + question) in tokens of each chunk
passed to the model. The context will be split in several chunks (using doc_stride as
overlap) if needed.
top_k (`int`, *optional*):
The number of answers to return (will be chosen by order of likelihood). Can return less
than top_k answers if there are not enough options available within the context.
word_boxes (`List[Union[List[float], str]]`, *optional*):
A list of words and bounding boxes (normalized 0->1000). If provided, the inference will
skip the OCR step and use the provided bounding boxes instead.
Returns:
`List[DocumentQuestionAnsweringOutputElement]`: a list of [`DocumentQuestionAnsweringOutputElement`] items containing the predicted label, associated probability, word ids, and page number.
Raises:
[`InferenceTimeoutError`]:
If the model is unavailable or the request times out.
`aiohttp.ClientResponseError`:
If the request fails with an HTTP error status code other than HTTP 503.
Example:
```py
# Must be run in an async context
>>> from huggingface_hub import AsyncInferenceClient
>>> client = AsyncInferenceClient()
>>> await client.document_question_answering(image="https://huggingface.co/spaces/impira/docquery/resolve/2359223c1837a7587402bda0f2643382a6eefeab/invoice.png", question="What is the invoice number?")
[DocumentQuestionAnsweringOutputElement(answer='us-001', end=16, score=0.9999666213989258, start=16, words=None)]
```
�r� r� )r� r� r� r� r� r� r� r� �r� zdocument-question-answeringr� Nri )r r rk r, r� )r[ r� r� rT r� r� r� r� r� r� r� r� �inputsr� r� rt s r\ �document_question_answeringz0AsyncInferenceClient.document_question_answering� sz � �� �J /7��U�AS�!T��$�(@�� ,� 0�&��$�
�
� #�6�j�A��"����^�W�^�E�@]�^�^��5�G�G��Q�Q� _�s �AA �A �A )� normalize� prompt_name�truncate�truncation_directionrT �textr� r� r� r� )�Left�Rightz
np.ndarrayc � �� K � ||||d�}t ||�� } | j di |�|dd���� d{ ��� } t � }
|
j t | � d�� S 7 �+�w) 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.
normalize (`bool`, *optional*):
Whether to normalize the embeddings or not.
Only available on server powered by Text-Embedding-Inference.
prompt_name (`str`, *optional*):
The name of the prompt that should be used by for encoding. If not set, no prompt will be applied.
Must be a key in the `Sentence Transformers` configuration `prompts` dictionary.
For example if ``prompt_name`` is "query" and the ``prompts`` is {"query": "query: ",...},
then the sentence "What is the capital of France?" will be encoded as "query: What is the capital of France?"
because the prompt text will be prepended before any text to encode.
truncate (`bool`, *optional*):
Whether to truncate the embeddings or not.
Only available on server powered by Text-Embedding-Inference.
truncation_direction (`Literal["Left", "Right"]`, *optional*):
Which side of the input should be truncated when `truncate=True` is passed.
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.
`aiohttp.ClientResponseError`:
If the request fails with an HTTP error status code other than HTTP 503.
Example:
```py
# Must be run in an async context
>>> from huggingface_hub import AsyncInferenceClient
>>> client = AsyncInferenceClient()
>>> await 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)
```
)r� r� r� r� r� �feature-extractionr� N�float32)�dtyperi )r rk r �arrayr ) r[ r� r� r� r� r� rT r� r� rt �nps r\ �feature_extractionz'AsyncInferenceClient.feature_extraction sm � �� �r #�&� �$8�
�
� #�4�J�?��"����U�W�U�E�@T�U�U��
�_���r�x�x��x�0� �B�B� V�s �/A �A �,A )rT �targetsr� r� c � � K � ||d�}t ||�� } | j di |�|dd���� d{ ��� }t j |� S 7 ��w)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.
targets (`List[str]`, *optional*):
When passed, the model will limit the scores to the passed targets instead of looking up
in the whole vocabulary. If the provided targets are not in the model vocab, they will be
tokenized and the first resulting token will be used (with a warning, and that might be
slower).
top_k (`int`, *optional*):
When passed, overrides the number of predictions to return.
Returns:
`List[FillMaskOutputElement]`: a list of [`FillMaskOutputElement`] items containing the predicted label, associated
probability, token reference, and completed text.
Raises:
[`InferenceTimeoutError`]:
If the model is unavailable or the request times out.
`aiohttp.ClientResponseError`:
If the request fails with an HTTP error status code other than HTTP 503.
Example:
```py
# Must be run in an async context
>>> from huggingface_hub import AsyncInferenceClient
>>> client = AsyncInferenceClient()
>>> await client.fill_mask("The goal of life is <mask>.")
[
FillMaskOutputElement(score=0.06897063553333282, token=11098, token_str=' happiness', sequence='The goal of life is happiness.'),
FillMaskOutputElement(score=0.06554922461509705, token=45075, token_str=' immortality', sequence='The goal of life is immortality.')
]
```
)r� r� r� z fill-maskr� Nri )r rk r- r� )r[ r� rT r� r� r� r� rt s r\ � fill_maskz AsyncInferenceClient.fill_maskS sS � �� �\ ")�5�9�
�"�4�J�?��"����L�W�L�E� �L�L��$�6�6�x�@�@� M�� �-A �A �A )rT r� r� )�sigmoid�softmax�nonec � � K � ||d�}t ||d�� } | j di |�|dd���� d{ ��� }t j |� S 7 ��w)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.
function_to_apply (`Literal["sigmoid", "softmax", "none"]`, *optional*):
The function to apply to the output scores.
top_k (`int`, *optional*):
When specified, limits the output to the top K most probable classes.
Returns:
`List[ImageClassificationOutputElement]`: a list of [`ImageClassificationOutputElement`] items containing the predicted label and associated probability.
Raises:
[`InferenceTimeoutError`]:
If the model is unavailable or the request times out.
`aiohttp.ClientResponseError`:
If the request fails with an HTTP error status code other than HTTP 503.
Example:
```py
# Must be run in an async context
>>> from huggingface_hub import AsyncInferenceClient
>>> client = AsyncInferenceClient()
>>> await client.image_classification("https://upload.wikimedia.org/wikipedia/commons/thumb/4/43/Cute_dog.jpg/320px-Cute_dog.jpg")
[ImageClassificationOutputElement(label='Blenheim spaniel', score=0.9779096841812134), ...]
```
r� Tr� zimage-classificationr� Nri )r rk r. r� )r[ r� rT r� r� r� r� rt s r\ �image_classificationz)AsyncInferenceClient.image_classification� sV � �� �N ,=�u�M�
�"�5�Z�t�T��"����W�W�W�E�@V�W�W��/�A�A�(�K�K� X�r� )rT �mask_threshold�overlap_mask_area_threshold�subtask� thresholdr r r )�instance�panoptic�semanticr c � �� K � ||||d�}t ||d�� } | j di |�|dd���� d{ ��� } t j | � }
|
D ] } t | j
� | _ � |
S 7 �<�w)a5
Perform image segmentation on the given image using the specified model.
<Tip warning={true}>
You must have `PIL` installed if you want to work with images (`pip install Pillow`).
</Tip>
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.
mask_threshold (`float`, *optional*):
Threshold to use when turning the predicted masks into binary values.
overlap_mask_area_threshold (`float`, *optional*):
Mask overlap threshold to eliminate small, disconnected segments.
subtask (`Literal["instance", "panoptic", "semantic"]`, *optional*):
Segmentation task to be performed, depending on model capabilities.
threshold (`float`, *optional*):
Probability threshold to filter out predicted masks.
Returns:
`List[ImageSegmentationOutputElement]`: A list of [`ImageSegmentationOutputElement`] items containing the segmented masks and associated attributes.
Raises:
[`InferenceTimeoutError`]:
If the model is unavailable or the request times out.
`aiohttp.ClientResponseError`:
If the request fails with an HTTP error status code other than HTTP 503.
Example:
```py
# Must be run in an async context
>>> from huggingface_hub import AsyncInferenceClient
>>> client = AsyncInferenceClient()
>>> await client.image_segmentation("cat.jpg")
[ImageSegmentationOutputElement(score=0.989008, label='LABEL_184', mask=<PIL.PngImagePlugin.PngImageFile image mode=L size=400x300 at 0x7FDD2B129CC0>), ...]
```
)r r r r Tr� zimage-segmentationr� Nri )r rk r/ r� r �mask) r[ r� rT r r r r r� r� rt �outputr� s r\ �image_segmentationz'AsyncInferenceClient.image_segmentation� s � �� �h -�+F� �"�
�
� #�5�Z�t�T��"����U�W�U�E�@T�U�U��/�A�A�(�K���D�%�d�i�i�0�D�I� ��
� V�s �0A1�A/�=A1)�negative_prompt�height�width�num_inference_steps�guidance_scalerT �promptr r r r r rI c � � K � ||||||d�| �}
t ||
d�� } | j di | �|dd���� d{ ��� } t | � S 7 ��w)a�
Perform image-to-image translation using a specified model.
<Tip warning={true}>
You must have `PIL` installed if you want to work with images (`pip install Pillow`).
</Tip>
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.
`aiohttp.ClientResponseError`:
If the request fails with an HTTP error status code other than HTTP 503.
Example:
```py
# Must be run in an async context
>>> from huggingface_hub import AsyncInferenceClient
>>> client = AsyncInferenceClient()
>>> image = await client.image_to_image("cat.jpg", prompt="turn the cat into a tiger")
>>> image.save("tiger.jpg")
```
)r r r r r r Tr� zimage-to-imager� Nri �r rk r )
r[ r� r r r r r r rT �kwargsr� r� rt s
r\ �image_to_imagez#AsyncInferenceClient.image_to_image� sk � �� �| � .� ��#6� ,�
� �
�
� #�5�Z�t�T��"����Q�W�Q�E�@P�Q�Q�� �x�(�(� R�s �4A�A�Ac � � K � | j ||d�� � d{ ��� }t j |� }t |t � r|d S |S 7 �0�w)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:
[`ImageToTextOutput`]: The generated text.
Raises:
[`InferenceTimeoutError`]:
If the model is unavailable or the request times out.
`aiohttp.ClientResponseError`:
If the request fails with an HTTP error status code other than HTTP 503.
Example:
```py
# Must be run in an async context
>>> from huggingface_hub import AsyncInferenceClient
>>> client = AsyncInferenceClient()
>>> await client.image_to_text("cat.jpg")
'a cat standing in a grassy field '
>>> await 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� Nr )rk r0 � parse_obj�
isinstance�list)r[ r� rT rt r
s r\ �
image_to_textz"AsyncInferenceClient.image_to_text< sN � �� �D ����U� ��Q�Q��"�,�,�X�6�� &�v�t� 4�v�a�y�@�&�@� R�s �A
�A �1A
�
frameworks�allc � � � ��K � |�t }n |dk( rt }nt |t � r|g}t t |� � }i �dt dt t ddf�fd� �dt ddf�� fd� }ddl} |j |D �cg c]
} ||� �� c}� � d{ ��� �j � D ] \ }}t t |� d � �
� �|< �! �S c c}w 7 �=�w) an
List models deployed on the Serverless 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.
<Tip warning={true}>
This endpoint method does not return a live list of all models available for the Serverless Inference API service.
It searches over a cached list of models that were recently available and the list may not be up to date.
If you want to know the live status of a specific model, use [`~InferenceClient.get_model_status`].
</Tip>
<Tip>
This endpoint method 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`].
</Tip>
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:
```py
# Must be run in an async contextthon
>>> from huggingface_hub import AsyncInferenceClient
>>> client = AsyncInferenceClient()
# Discover zero-shot-classification models currently deployed
>>> models = await client.list_deployed_models()
>>> models["zero-shot-classification"]
['Narsil/deberta-large-mnli-zero-cls', 'facebook/bart-large-mnli', ...]
# List from only 1 framework
>>> await client.list_deployed_models("text-generation-inference")
{'text-generation': ['bigcode/starcoder', 'meta-llama/Llama-2-70b-chat-hf', ...], ...}
```
Nr � frameworkr� rU c �� �� |D ]w }| dk( rI�j dg � j |d � �j dg � j |d � �Q�j |d g � j |d � �y y )Nzsentence-transformersr� r� �sentence-similarityre )�
setdefault�append)r! r� rT �models_by_tasks �r\ �_unpack_responsezCAsyncInferenceClient.list_deployed_models.<locals>._unpack_response� s� �� � �� � 7�7� #�-�-�.B�B�G�N�N�u�U_�O`�a�"�-�-�.C�R�H�O�O�PU�V`�Pa�b�"�-�-�e�F�m�R�@�G�G��j�HY�Z� r^ c � �T �K � �j � 4 �d { ��� }|j t � d| � ��j �� � d { ��� }|j � �| |j � � d { ��� � d d d � �d { ��� y 7 �r7 �F7 � 7 � # 1 �d { ���7 sw Y y xY w�w)Nz /framework/�rq )r{ �getr rQ r~ rc )r! �clientrt r' r[ s ��r\ �_fetch_frameworkzCAsyncInferenceClient.list_deployed_models.<locals>._fetch_framework� s� �� �� ��/�/�1�1�V�!'���/A�.B�+�i�[�,Y�ae�am�am��!n�n���)�)�+� ��(�-�-�/�,A�B� 2�1�1��n��,A�� 2��1�1�1�sh �B(�B �B(�*B�B
�*B�1B �2B�: B(�B�B(�
B�B�B(�B%�B �B%�!B(r c �" � | j � S rh )�lower)�xs r\ �<lambda>z;AsyncInferenceClient.list_deployed_models.<locals>.<lambda>� s
� �Q�W�W�Yr^ )r� ) r r r �strr �setr r r� r� r� �sorted) r[ r r, r� r! re �modelsr' r& s ` @@r\ �list_deployed_modelsz)AsyncInferenceClient.list_deployed_modelsb s� �� �� �j � �6�J�
�5�
�5�J�
�
�C�
(�$� �J��#�j�/�*�
� 02�� [�� [�D��J� [�4� [� C�c� C�d� C� � �g�n�n�J� W�J�y� /� � :�J� W�X�X�X� +� 0� 0� 2�L�D�&�#)�#�f�+�;N�#O�N�4� � 3� � �� X�X�s �A=C�C�C�C�>C)rT r c � � K � d|i}t ||d�� } | j di |�|dd���� d{ ��� }t j |� S 7 ��w)a�
Perform object detection on the given image using the specified model.
<Tip warning={true}>
You must have `PIL` installed if you want to work with images (`pip install Pillow`).
</Tip>
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.
threshold (`float`, *optional*):
The probability necessary to make a prediction.
Returns:
`List[ObjectDetectionOutputElement]`: A list of [`ObjectDetectionOutputElement`] items containing the bounding boxes and associated attributes.
Raises:
[`InferenceTimeoutError`]:
If the model is unavailable or the request times out.
`aiohttp.ClientResponseError`:
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
# Must be run in an async context
>>> from huggingface_hub import AsyncInferenceClient
>>> client = AsyncInferenceClient()
>>> await client.object_detection("people.jpg")
[ObjectDetectionOutputElement(score=0.9486683011054993, label='person', box=ObjectDetectionBoundingBox(xmin=59, ymin=39, xmax=420, ymax=510)), ...]
```
r Tr� zobject-detectionr� Nri )r rk r1 r� )r[ r� rT r r� r� rt s r\ �object_detectionz%AsyncInferenceClient.object_detection� sZ � �� �R
��
�
� #�5�Z�t�T��"����S�W�S�E�@R�S�S��+�=�=�h�G�G� T�r� )rT �align_to_wordsr� r� r� r� r� r� �contextr8 c � � K � |||||| |
d�} ||d�} t | | �� }
| j di |
�|dd���� d{ ��� }t j |� }|S 7 ��w)aY
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.
align_to_words (`bool`, *optional*):
Attempts to align the answer to real words. Improves quality on space separated
languages. Might hurt on non-space-separated languages (like Japanese or Chinese).
doc_stride (`int`, *optional*):
If the context is too long to fit with the question for the model, it will be split in
several chunks with some overlap. This argument controls the size of that overlap.
handle_impossible_answer (`bool`, *optional*):
Whether to accept impossible as an answer.
max_answer_len (`int`, *optional*):
The maximum length of predicted answers (e.g., only answers with a shorter length are
considered).
max_question_len (`int`, *optional*):
The maximum length of the question after tokenization. It will be truncated if needed.
max_seq_len (`int`, *optional*):
The maximum length of the total sentence (context + question) in tokens of each chunk
passed to the model. The context will be split in several chunks (using docStride as
overlap) if needed.
top_k (`int`, *optional*):
The number of answers to return (will be chosen by order of likelihood). Note that we
return less than topk answers if there are not enough options available within the
context.
Returns:
Union[`QuestionAnsweringOutputElement`, List[`QuestionAnsweringOutputElement`]]:
When top_k is 1 or not provided, it returns a single `QuestionAnsweringOutputElement`.
When top_k is greater than 1, it returns a list of `QuestionAnsweringOutputElement`.
Raises:
[`InferenceTimeoutError`]:
If the model is unavailable or the request times out.
`aiohttp.ClientResponseError`:
If the request fails with an HTTP error status code other than HTTP 503.
Example:
```py
# Must be run in an async context
>>> from huggingface_hub import AsyncInferenceClient
>>> client = AsyncInferenceClient()
>>> await client.question_answering(question="What's my name?", context="My name is Clara and I live in Berkeley.")
QuestionAnsweringOutputElement(answer='Clara', end=16, score=0.9326565265655518, start=11)
```
)r8 r� r� r� r� r� r� )r� r9 r� zquestion-answeringr� Nri )r rk r2 r )r[ r� r9 rT r8 r� r� r� r� r� r� r� r� r� rt r
s r\ �question_answeringz'AsyncInferenceClient.question_answering� s� � �� �D -�$�(@� ,� 0�&��
�
� /7�7�!K��"�6�j�A��"����
��
��%�
�
�� 0�9�9�(�C���
�
�s �7A�A� A�sentence�other_sentencesc � �f K � | j d||d�i|d�� � d{ ��� }t |� S 7 ��w)aJ
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.
`aiohttp.ClientResponseError`:
If the request fails with an HTTP error status code other than HTTP 503.
Example:
```py
# Must be run in an async context
>>> from huggingface_hub import AsyncInferenceClient
>>> client = AsyncInferenceClient()
>>> await 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]
```
r� )�source_sentence� sentencesr# �rc rT re N�rk r )r[ r< r= rT rt s r\ �sentence_similarityz(AsyncInferenceClient.sentence_similarity? sF � �� �R ������ W�X��&� #�
�
��
�h�'�'�
�s � 1�/�1z0.29r� z�The `parameters` argument is deprecated and will be removed in a future version. Provide individual parameters instead: `clean_up_tokenization_spaces`, `generate_parameters`, and `truncation`.)�version�deprecated_args�custom_message)r� rT � clean_up_tokenization_spaces�generate_parameters�
truncationrG rH rI )�do_not_truncate�
longest_first�
only_first� only_secondc � � K � |�|||d�}t ||�� } | j di |�|dd���� d{ ��� }t j |� d S 7 � �w)a4
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. If not provided, the default recommended model for summarization will be used.
clean_up_tokenization_spaces (`bool`, *optional*):
Whether to clean up the potential extra spaces in the text output.
generate_parameters (`Dict[str, Any]`, *optional*):
Additional parametrization of the text generation algorithm.
truncation (`Literal["do_not_truncate", "longest_first", "only_first", "only_second"]`, *optional*):
The truncation strategy to use.
Returns:
[`SummarizationOutput`]: The generated summary text.
Raises:
[`InferenceTimeoutError`]:
If the model is unavailable or the request times out.
`aiohttp.ClientResponseError`:
If the request fails with an HTTP error status code other than HTTP 503.
Example:
```py
# Must be run in an async context
>>> from huggingface_hub import AsyncInferenceClient
>>> client = AsyncInferenceClient()
>>> await client.summarization("The Eiffel tower...")
SummarizationOutput(generated_text="The Eiffel tower is one of the most famous landmarks in the world....")
```
N)rG rH rI r� �
summarizationr� r ri )r rk r3 r� ) r[ r� r� rT rG rH rI r� rt s r\ rO z"AsyncInferenceClient.summarizationo sf � �� �l � �0L�':� (��J�
#�4�J�?��"����P�W�P�E��P�P��"�4�4�X�>�q�A�A� Q�s �0A�A� A)rT r� �table�queryc � � K � ||d�}t ||�� } | j di |�|dd���� d{ ��� }t j |� S 7 ��w)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.
parameters (`Dict[str, Any]`, *optional*):
Additional inference parameters. Defaults to None.
Returns:
[`TableQuestionAnsweringOutputElement`]: a 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.
`aiohttp.ClientResponseError`:
If the request fails with an HTTP error status code other than HTTP 503.
Example:
```py
# Must be run in an async context
>>> from huggingface_hub import AsyncInferenceClient
>>> client = AsyncInferenceClient()
>>> query = "How many stars does the transformers repository have?"
>>> table = {"Repository": ["Transformers", "Datasets", "Tokenizers"], "Stars": ["36542", "4512", "3934"]}
>>> await client.table_question_answering(table, query, model="google/tapas-base-finetuned-wtq")
TableQuestionAnsweringOutputElement(answer='36542', coordinates=[[0, 1]], cells=['36542'], aggregator='AVERAGE')
```
)rQ rP r� ztable-question-answeringr� Nri )r rk r4 r� )r[ rP rQ rT r� r� r� rt s r\ �table_question_answeringz-AsyncInferenceClient.table_question_answering� sd � �� �X ��
�� #�6�j�A��"����
��
��+�
�
��
3�H�H��R�R�
�r� c � �` K � | j d|i|d�� � d{ ��� }t |� S 7 ��w)a#
Classifying a target category (a group) based on a set of attributes.
Args:
table (`Dict[str, Any]`):
Set of attributes to classify.
model (`str`, *optional*):
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. If not provided, the default recommended tabular classification model will be used.
Defaults to None.
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.
`aiohttp.ClientResponseError`:
If the request fails with an HTTP error status code other than HTTP 503.
Example:
```py
# Must be run in an async context
>>> from huggingface_hub import AsyncInferenceClient
>>> client = AsyncInferenceClient()
>>> 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"],
... }
>>> await client.tabular_classification(table=table, model="julien-c/wine-quality")
["5", "5", "5"]
```
rP ztabular-classificationrA NrB �r[ rP rT rt s r\ �tabular_classificationz+AsyncInferenceClient.tabular_classification� sA � �� �V ����5�!��)� #�
�
��
�h�'�'�
�� �.�,�.c � �` K � | j d|i|d�� � d{ ��� }t |� S 7 ��w)aN
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`, *optional*):
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. If not provided, the default recommended tabular regression model will be used.
Defaults to None.
Returns:
`List`: a list of predicted numerical target values.
Raises:
[`InferenceTimeoutError`]:
If the model is unavailable or the request times out.
`aiohttp.ClientResponseError`:
If the request fails with an HTTP error status code other than HTTP 503.
Example:
```py
# Must be run in an async context
>>> from huggingface_hub import AsyncInferenceClient
>>> client = AsyncInferenceClient()
>>> 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"],
... }
>>> await client.tabular_regression(table, model="scikit-learn/Fish-Weight")
[110, 120, 130]
```
rP ztabular-regressionrA NrB rU s r\ �tabular_regressionz'AsyncInferenceClient.tabular_regression s7 � �� �L ����%�(8��L`��a�a�� �h�'�'� b�rW r6 c � � K � ||d�}t ||�� } | j di |�|dd���� d{ ��� }t j |� d S 7 � �w)aw
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.
top_k (`int`, *optional*):
When specified, limits the output to the top K most probable classes.
function_to_apply (`"TextClassificationOutputTransform"`, *optional*):
The function to apply to the output.
Returns:
`List[TextClassificationOutputElement]`: a list of [`TextClassificationOutputElement`] items containing the predicted label and associated probability.
Raises:
[`InferenceTimeoutError`]:
If the model is unavailable or the request times out.
`aiohttp.ClientResponseError`:
If the request fails with an HTTP error status code other than HTTP 503.
Example:
```py
# Must be run in an async context
>>> from huggingface_hub import AsyncInferenceClient
>>> client = AsyncInferenceClient()
>>> await client.text_classification("I like you")
[
TextClassificationOutputElement(label='POSITIVE', score=0.9998695850372314),
TextClassificationOutputElement(label='NEGATIVE', score=0.0001304351753788069),
]
```
r� r� ztext-classificationr� Nr ri )r rk r5 r� )r[ r� rT r� r� r� r� rt s r\ �text_classificationz(AsyncInferenceClient.text_classificationA si � �� �Z "3��
�
� #�4�J�?��"����
��
��&�
�
��
/�@�@��J�1�M�M�
�s �-A�A � A)�detailsrf rT �
adapter_id�best_of�decoder_input_details� do_sampler� �grammar�max_new_tokens�repetition_penalty�return_full_textr� r� �stop_sequencesr� r� � top_n_tokensr� r� � typical_p� watermarkr\ r] r^ r_ r` ra rb rc rd re rf rg rh c � � K � y �wrh ri �r[ r r\ rf rT r] r^ r_ r` r� ra rb rc rd r� r� re r� r� rf r� r� rg rh s r\ �text_generationz$AsyncInferenceClient.text_generationy s � �� �8 �rl c � � K � y �wrh ri rj s r\ rk z$AsyncInferenceClient.text_generation� s � �� �8 #�rl c � � K � y �wrh ri rj s r\ rk z$AsyncInferenceClient.text_generation� s � �� �8 !�rl c � � K � y �wrh ri rj s r\ rk z$AsyncInferenceClient.text_generation� s � �� �8 58�rl c � � K � y �wrh ri rj s r\ rk z$AsyncInferenceClient.text_generation� s
� �� �8 RU�rl c � �x K � |r|st j d� d}|�t j dt � |�|}i d|�d|�d|�d|�d |�d
| �d |
�d | �d
| �d|
�d|�d|�|ng �d|�d|�d|�d|�d|�||d��}|j � D ��ci c] \ }}|�� ||��
}}}|||d�}t |� } t | � dkD r�g } | D ]6 } |j
| � r| j | � |j | d� �8 t | � dkD r-t j ddj | � � d�t � |r t j d t � d}|r t d � � | j ||d |� � � d{ ��� } |r t3 |� S t5 � }$t7 |$t8 � r|$d }$|rt; j< |$� S |$d& S c c}}w 7 �T# t � j $ r�} t j! | j" d � }!| j$ d!k( r�|!r�|!j' d"� j) d#� D �"cg c] }"|"j+ d$� �� nc c}"w }#}"t- ||#� | j/ ||||||||| |
| | |
|||||||||�%� � d{ ���7 cY d} ~ S t1 | � Y d} ~ ��0d} ~ ww xY w�w)'aE,
Given a prompt, generate the following text.
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.
<Tip>
If you want to generate a response from chat messages, you should use the [`InferenceClient.chat_completion`] method.
It accepts a list of messages instead of a single text prompt and handles the chat templating for you.
</Tip>
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.
adapter_id (`str`, *optional*):
Lora adapter id.
best_of (`int`, *optional*):
Generate best_of sequences and return the one if the highest token logprobs.
decoder_input_details (`bool`, *optional*):
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`.
do_sample (`bool`, *optional*):
Activate logits sampling
frequency_penalty (`float`, *optional*):
Number between -2.0 and 2.0. Positive values penalize new tokens based on their existing frequency in
the text so far, decreasing the model's likelihood to repeat the same line verbatim.
grammar ([`TextGenerationInputGrammarType`], *optional*):
Grammar constraints. Can be either a JSONSchema or a regex.
max_new_tokens (`int`, *optional*):
Maximum number of generated tokens
repetition_penalty (`float`, *optional*):
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`, *optional*):
Whether to prepend the prompt to the generated text
seed (`int`, *optional*):
Random sampling seed
stop (`List[str]`, *optional*):
Stop generating tokens if a member of `stop` is generated.
stop_sequences (`List[str]`, *optional*):
Deprecated argument. Use `stop` instead.
temperature (`float`, *optional*):
The value used to module the logits distribution.
top_n_tokens (`int`, *optional*):
Return information about the `top_n_tokens` most likely tokens at each generation step, instead of
just the sampled token.
top_k (`int`, *optional`):
The number of highest probability vocabulary tokens to keep for top-k-filtering.
top_p (`float`, *optional`):
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`, *optional`):
Truncate inputs tokens to the given size.
typical_p (`float`, *optional`):
Typical Decoding mass
See [Typical Decoding for Natural Language Generation](https://arxiv.org/abs/2202.00666) for more information
watermark (`bool`, *optional`):
Watermarking with [A Watermark for Large Language Models](https://arxiv.org/abs/2301.10226)
Returns:
`Union[str, TextGenerationOutput, Iterable[str], Iterable[TextGenerationStreamOutput]]`:
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.TextGenerationOutput`]
- if `details=True` and `stream=True`, the generated text is returned token by token as a iterable of [`~huggingface_hub.TextGenerationStreamOutput`]
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.
`aiohttp.ClientResponseError`:
If the request fails with an HTTP error status code other than HTTP 503.
Example:
```py
# Must be run in an async context
>>> from huggingface_hub import AsyncInferenceClient
>>> client = AsyncInferenceClient()
# Case 1: generate text
>>> await 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.
>>> async for token in await 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.
>>> await client.text_generation("The huggingface_hub library is ", max_new_tokens=12, details=True)
TextGenerationOutput(
generated_text='100% open source and built to be easy to use.',
details=TextGenerationDetails(
finish_reason='length',
generated_tokens=12,
seed=None,
prefill=[
TextGenerationPrefillOutputToken(id=487, text='The', logprob=None),
TextGenerationPrefillOutputToken(id=53789, text=' hugging', logprob=-13.171875),
(...)
TextGenerationPrefillOutputToken(id=204, text=' ', logprob=-7.0390625)
],
tokens=[
TokenElement(id=1425, text='100', logprob=-1.0175781, special=False),
TokenElement(id=16, text='%', logprob=-0.0463562, special=False),
(...)
TokenElement(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.
>>> async for details in await client.text_generation("The huggingface_hub library is ", max_new_tokens=12, details=True, stream=True):
... print(details)
...
TextGenerationStreamOutput(token=TokenElement(id=1425, text='100', logprob=-1.0175781, special=False), generated_text=None, details=None)
TextGenerationStreamOutput(token=TokenElement(id=16, text='%', logprob=-0.0463562, special=False), generated_text=None, details=None)
TextGenerationStreamOutput(token=TokenElement(id=1314, text=' open', logprob=-1.3359375, special=False), generated_text=None, details=None)
TextGenerationStreamOutput(token=TokenElement(id=3178, text=' source', logprob=-0.28100586, special=False), generated_text=None, details=None)
TextGenerationStreamOutput(token=TokenElement(id=273, text=' and', logprob=-0.5961914, special=False), generated_text=None, details=None)
TextGenerationStreamOutput(token=TokenElement(id=3426, text=' built', logprob=-1.9423828, special=False), generated_text=None, details=None)
TextGenerationStreamOutput(token=TokenElement(id=271, text=' to', logprob=-1.4121094, special=False), generated_text=None, details=None)
TextGenerationStreamOutput(token=TokenElement(id=314, text=' be', logprob=-1.5224609, special=False), generated_text=None, details=None)
TextGenerationStreamOutput(token=TokenElement(id=1833, text=' easy', logprob=-2.1132812, special=False), generated_text=None, details=None)
TextGenerationStreamOutput(token=TokenElement(id=271, text=' to', logprob=-0.08520508, special=False), generated_text=None, details=None)
TextGenerationStreamOutput(token=TokenElement(id=745, text=' use', logprob=-0.39453125, special=False), generated_text=None, details=None)
TextGenerationStreamOutput(token=TokenElement(
id=25,
text='.',
logprob=-0.5703125,
special=False),
generated_text='100% open source and built to be easy to use.',
details=TextGenerationStreamOutputStreamDetails(finish_reason='length', generated_tokens=12, seed=None)
)
# Case 5: generate constrained output using grammar
>>> response = await client.text_generation(
... prompt="I saw a puppy a cat and a raccoon during my bike ride in the park",
... model="HuggingFaceH4/zephyr-orpo-141b-A35b-v0.1",
... max_new_tokens=100,
... repetition_penalty=1.3,
... grammar={
... "type": "json",
... "value": {
... "properties": {
... "location": {"type": "string"},
... "activity": {"type": "string"},
... "animals_seen": {"type": "integer", "minimum": 1, "maximum": 5},
... "animals": {"type": "array", "items": {"type": "string"}},
... },
... "required": ["location", "activity", "animals_seen", "animals"],
... },
... },
... )
>>> json.loads(response)
{
"activity": "bike riding",
"animals": ["puppy", "cat", "raccoon"],
"animals_seen": 3,
"location": "park"
}
```
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.FNz�`stop_sequences` is a deprecated argument for `text_generation` task and will be removed in version '0.28.0'. Use `stop` instead.r] r^ r_ r\ r` r� ra rb rc rd r� r� r� r� rf r� r� )rg rh )r� r� rf r z]API endpoint/model for text-generation is not served via TGI. Ignoring following parameters: z, �.z�API endpoint/model for text-generation is not served via TGI. Parameter `details=True` will be ignored meaning only the generated text will be returned.z�API endpoint/model for text-generation is not served via TGI. Cannot return output as a stream. Please pass `stream=False` as input.r� )rc rT re rf r� i� rv �,z' )r r\ rf rT r] r^ r_ r` r� ra rb rc rd r� r� r� r� rf r� r� rg rh �generated_text) rx ry �
FutureWarningr� r r� r* r% �pop�join� UserWarningrW rk rF r� �MODEL_KWARGS_NOT_USED_REGEX�searchr� r| �group�split�stripr! rk r" r r r r r8 r� )%r[ r r\ rf rT r] r^ r_ r` r� ra rb rc rd r� r� re r� r� rf r� r� rg rh r� �k�vr� �unsupported_kwargs�ignored_parametersr� � bytes_output�e�match�kwarg�
unused_paramsrd s% r\ rk z$AsyncInferenceClient.text_generation s� � �� �B !�� �M�M�A�
� %*� !� � %� �M�M�P� �
�
�<�!�D�
� �*�
� �w�
�
$�%:�
�
�w�
�
��
�
�!2�
�
�w�
�
�n�
�
!�"4�
�
� 0�
�
�D�
�
�D� ,�D�"�
�
�;�
�
�U�
�
�L�
�
�U�!
�"
��#
�$ #�"�'
�
�* (2�'7�'7�'9�K�'9�t�q�!�Q�]�a��d�'9�
�K� �$� �
�� E�U� K�� �!� "�Q� &�
"$� �)�� �>�>�#�&�&�-�-�c�2����s�D�)� *� �%�&��*��
�
�� � � �"4�5�6�a�9� ��
��
�
�T� ��
��� �<�� � +�!%����u�K\�ek��!l�l�L�B �9�,��P� P� �l�+�� �d�D� !���7�D�CJ�#�9�9�$�?�f�PT�Ue�Pf�f��e L�P m�� � �4�4� +�/�6�6�q�7O�7O�PW�7X�Y�E��x�x�3��5�@E� � �A��@T�@T�UX�@Y� Z�@Y�u����T�!2�@Y�� Z�
� Z�7��}�M� !� 1� 1�!� #�!� � )� #�*?� '�&7� #�#1�'9�%5� � � +� �!-� � %� '� '�- 2� � � � �0
(�� *� *��; +�s� �B
J:�
G �G � CJ:�%G �=G�>G �AJ:�G �J7�+AJ2� I�>J2�J�J2�J7� J:�! J2�,J:�2J7�7J:) r r r r r rT � scheduler� target_sizer� r� r� c � � K � ||||||| |
d�| �} t || �� }
| j di |
�|dd���� d{ ��� }t |� S 7 ��w)aG
Generate an image based on a given text using a specified model.
<Tip warning={true}>
You must have `PIL` installed if you want to work with images (`pip install Pillow`).
</Tip>
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. If not provided, the default recommended text-to-image model will be used.
Defaults to None.
scheduler (`str`, *optional*):
Override the scheduler with a compatible one.
target_size (`TextToImageTargetSize`, *optional*):
The size in pixel of the output image
seed (`int`, *optional*):
Seed for the random number generator.
Returns:
`Image`: The generated image.
Raises:
[`InferenceTimeoutError`]:
If the model is unavailable or the request times out.
`aiohttp.ClientResponseError`:
If the request fails with an HTTP error status code other than HTTP 503.
Example:
```py
# Must be run in an async context
>>> from huggingface_hub import AsyncInferenceClient
>>> client = AsyncInferenceClient()
>>> image = await client.text_to_image("An astronaut riding a horse on the moon.")
>>> image.save("astronaut.png")
>>> image = await 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")
```
)r r r r r r� r� r� r� z
text-to-imager� Nri r )r[ r r r r r r rT r� r� r� r r� r� rt s r\ �
text_to_imagez"AsyncInferenceClient.text_to_imagej sn � �� �\ /� ��#6� ,�"�&��
� �
�
� #�6�j�A��"����P�W�P�E��P�P�� �x�(�(� Q�s �5A �A�A )rT r` �early_stopping�epsilon_cutoff�
eta_cutoff�
max_lengthrb �
min_length�min_new_tokens�num_beam_groups� num_beams�
penalty_alphar� r� r� rg � use_cacher� r; r� r� r� r� r� r� r� r� r� c � �� K � i d|�d|�d|�d|�d|�d|�d| �d|
�d | �d
| �d |
�d |�d
|�d|�d|�d|�}t ||�� } | j di |�|dd���� d{ ��� }|S 7 ��w)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. If not provided, the default recommended text-to-speech model will be used.
Defaults to None.
do_sample (`bool`, *optional*):
Whether to use sampling instead of greedy decoding when generating new tokens.
early_stopping (`Union[bool, "TextToSpeechEarlyStoppingEnum"`, *optional*):
Controls the stopping condition for beam-based methods.
epsilon_cutoff (`float`, *optional*):
If set to float strictly between 0 and 1, only tokens with a conditional probability
greater than epsilon_cutoff will be sampled. In the paper, suggested values range from
3e-4 to 9e-4, depending on the size of the model. See [Truncation Sampling as Language
Model Desmoothing](https://hf.co/papers/2210.15191) for more details.
eta_cutoff (`float`, *optional*):
Eta sampling is a hybrid of locally typical sampling and epsilon sampling. If set to
float strictly between 0 and 1, a token is only considered if it is greater than either
eta_cutoff or sqrt(eta_cutoff) * exp(-entropy(softmax(next_token_logits))). The latter
term is intuitively the expected next token probability, scaled by sqrt(eta_cutoff). In
the paper, suggested values range from 3e-4 to 2e-3, depending on the size of the model.
See [Truncation Sampling as Language Model Desmoothing](https://hf.co/papers/2210.15191)
for more details.
max_length (`int`, *optional*):
The maximum length (in tokens) of the generated text, including the input.
max_new_tokens (`int`, *optional*):
The maximum number of tokens to generate. Takes precedence over maxLength.
min_length (`int`, *optional*):
The minimum length (in tokens) of the generated text, including the input.
min_new_tokens (`int`, *optional*):
The minimum number of tokens to generate. Takes precedence over maxLength.
num_beam_groups (`int`, *optional*):
Number of groups to divide num_beams into in order to ensure diversity among different
groups of beams. See [this paper](https://hf.co/papers/1610.02424) for more details.
num_beams (`int`, *optional*):
Number of beams to use for beam search.
penalty_alpha (`float`, *optional*):
The value balances the model confidence and the degeneration penalty in contrastive
search decoding.
temperature (`float`, *optional*):
The value used to modulate the next token probabilities.
top_k (`int`, *optional*):
The number of highest probability vocabulary tokens to keep for top-k-filtering.
top_p (`float`, *optional*):
If set to float < 1, only the smallest set of most probable tokens with probabilities
that add up to top_p or higher are kept for generation.
typical_p (`float`, *optional*):
Local typicality measures how similar the conditional probability of predicting a target token next is
to the expected conditional probability of predicting a random token next, given the partial text
already generated. If set to float < 1, the smallest set of the most locally typical tokens with
probabilities that add up to typical_p or higher are kept for generation. See [this
paper](https://hf.co/papers/2202.00666) for more details.
use_cache (`bool`, *optional*):
Whether the model should use the past last key/values attentions to speed up decoding
Returns:
`bytes`: The generated audio.
Raises:
[`InferenceTimeoutError`]:
If the model is unavailable or the request times out.
`aiohttp.ClientResponseError`:
If the request fails with an HTTP error status code other than HTTP 503.
Example:
```py
# Must be run in an async context
>>> from pathlib import Path
>>> from huggingface_hub import AsyncInferenceClient
>>> client = AsyncInferenceClient()
>>> audio = await client.text_to_speech("Hello world")
>>> Path("hello_world.flac").write_bytes(audio)
```
r` r� r� r� r� rb r� r� r� r� r� r� r� r� rg r� r� ztext-to-speechr� Nri )r rk )r[ r� rT r` r� r� r� r� rb r� r� r� r� r� r� r� r� rg r� r� r� rt s r\ �text_to_speechz#AsyncInferenceClient.text_to_speech� s � �� �J
� ��
� �n�
�
�n�
�
�*�
�
�*�
�
�n�
�
�*�
�
�n�
�
��
�
��
�
�]�
�
�;�
�
�U�
�
�U�
�
��
�
��!
�
�$ #�4�J�?��"����Q�W�Q�E�@P�Q�Q���� R�s �AA%� A#� A%)rT �aggregation_strategy�
ignore_labels�strider� )r �simple�first�averager� r� r� c � � K � |||d�}t ||�� } | j di |�|dd���� d{ ��� }t j |� S 7 ��w)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.
aggregation_strategy (`Literal["none", "simple", "first", "average", "max"]`, *optional*):
The strategy used to fuse tokens based on model predictions.
ignore_labels (`List[str]`, *optional*):
A list of labels to ignore.
stride (`int`, *optional*):
The number of overlapping tokens between chunks when splitting the input text.
Returns:
`List[TokenClassificationOutputElement]`: List of [`TokenClassificationOutputElement`] items containing the entity group, confidence score, word, start and end index.
Raises:
[`InferenceTimeoutError`]:
If the model is unavailable or the request times out.
`aiohttp.ClientResponseError`:
If the request fails with an HTTP error status code other than HTTP 503.
Example:
```py
# Must be run in an async context
>>> from huggingface_hub import AsyncInferenceClient
>>> client = AsyncInferenceClient()
>>> await client.token_classification("My name is Sarah Jessica Parker but you can call me Jessica")
[
TokenClassificationOutputElement(
entity_group='PER',
score=0.9971321225166321,
word='Sarah Jessica Parker',
start=11,
end=31,
),
TokenClassificationOutputElement(
entity_group='PER',
score=0.9773476123809814,
word='Jessica',
start=52,
end=59,
)
]
```
)r� r� r� r� ztoken-classificationr� Nri )r rk r< r� ) r[ r� rT r� r� r� r� r� rt s r\ �token_classificationz)AsyncInferenceClient.token_classificationA
sg � �� �| %9� *� �
�
�
#�4�J�?��"����
��
��'�
�
��
0�A�A�(�K�K�
�r� )rT �src_lang�tgt_langrG rI rH r� r� c � �� K � |�
|� t d� �|�
|� t d� �|||||d�}t ||�� } | j d i | �|dd���� d{ ��� }
t j |
� d S 7 � �w)
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 depend on the model.
However, it is possible to specify source and target languages for certain models. If you are working with one of these models,
you can use `src_lang` and `tgt_lang` arguments to pass the relevant information.
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.
src_lang (`str`, *optional*):
The source language of the text. Required for models that can translate from multiple languages.
tgt_lang (`str`, *optional*):
Target language to translate to. Required for models that can translate to multiple languages.
clean_up_tokenization_spaces (`bool`, *optional*):
Whether to clean up the potential extra spaces in the text output.
truncation (`Literal["do_not_truncate", "longest_first", "only_first", "only_second"]`, *optional*):
The truncation strategy to use.
generate_parameters (`Dict[str, Any]`, *optional*):
Additional parametrization of the text generation algorithm.
Returns:
[`TranslationOutput`]: The generated translated text.
Raises:
[`InferenceTimeoutError`]:
If the model is unavailable or the request times out.
`aiohttp.ClientResponseError`:
If the request fails with an HTTP error status code other than HTTP 503.
`ValueError`:
If only one of the `src_lang` and `tgt_lang` arguments are provided.
Example:
```py
# Must be run in an async context
>>> from huggingface_hub import AsyncInferenceClient
>>> client = AsyncInferenceClient()
>>> await client.translation("My name is Wolfgang and I live in Berlin")
'Mein Name ist Wolfgang und ich lebe in Berlin.'
>>> await client.translation("My name is Wolfgang and I live in Berlin", model="Helsinki-NLP/opus-mt-en-fr")
TranslationOutput(translation_text='Je m'appelle Wolfgang et je vis à Berlin.')
```
Specifying languages:
```py
>>> client.translation("My name is Sarah Jessica Parker but you can call me Jessica", model="facebook/mbart-large-50-many-to-many-mmt", src_lang="en_XX", tgt_lang="fr_XX")
"Mon nom est Sarah Jessica Parker mais vous pouvez m'appeler Jessica"
```
Nz<You cannot specify `src_lang` without specifying `tgt_lang`.z<You cannot specify `tgt_lang` without specifying `src_lang`.)r� r� rG rI rH r� � translationr� r ri )rW r rk r> r� ) r[ r� rT r� r� rG rI rH r� r� rt s r\ r� z AsyncInferenceClient.translation�
s� � �� �D � �H�$4� � [�\� \� � �� 4� � [�\� \� � �,H�$�#6�
�
� #�4�J�?��"����N�W�N�E�
�N�N�� �2�2�8�<�Q�?�?� O�s �AA/�A-� A/)rT r� c � � K � |t |� d�}|�||j di � d< | j ||d�� � d{ ��� }t j |� S 7 ��w)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.
top_k (`int`, *optional*):
The number of answers to return (will be chosen by order of likelihood). Note that we
return less than topk answers if there are not enough options available within the
context.
Returns:
`List[VisualQuestionAnsweringOutputElement]`: a list of [`VisualQuestionAnsweringOutputElement`] items containing the predicted label and associated probability.
Raises:
`InferenceTimeoutError`:
If the model is unavailable or the request times out.
`aiohttp.ClientResponseError`:
If the request fails with an HTTP error status code other than HTTP 503.
Example:
```py
# Must be run in an async context
>>> from huggingface_hub import AsyncInferenceClient
>>> client = AsyncInferenceClient()
>>> await client.visual_question_answering(
... image="https://huggingface.co/datasets/mishig/sample_images/resolve/main/tiger.jpg",
... question="What is the animal doing?"
... )
[
VisualQuestionAnsweringOutputElement(score=0.778609573841095, answer='laying down'),
VisualQuestionAnsweringOutputElement(score=0.6957435607910156, answer='sitting'),
]
```
r� Nr� r� zvisual-question-answeringrA )r r$ rk r? r� )r[ r� r� rT r� r� rt s r\ �visual_question_answeringz.AsyncInferenceClient.visual_question_answering�
sd � �� �` 08�+�e�BT�"U�� � �<A�G� � �|�R� 0�� 9� ����u�C^��_�_��3�E�E�h�O�O� `�s �=A�A� A)� multi_label�hypothesis_templaterT �labelsr� r� c � �
K � |||d�}t ||�� } | j d i |�d|d���� d{ ��� }t |� } t | d | d � D �
� cg c] \ }
} t j
|
| d�� �� c} }
S 7 �Jc c} }
w �w)
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 strings. Each string is the verbalization of a possible label for the input text.
multi_label (`bool`):
Boolean. If True, the probability for each label is evaluated independently and multiple labels can have a probability close to 1 simultaneously or all probabilities can be close to 0.
If False, the labels are considered mutually exclusive and the probability over all labels always sums to 1. Defaults to False.
hypothesis_template (`str`, *optional*):
A template sentence string with curly brackets to which the label strings are added. The label strings are added at the position of the curly brackets "{}".
Zero-shot classifiers are based on NLI models, which evaluate if a hypothesis is entailed in another text or not.
For example, with hypothesis_template="This text is about {}." and labels=["economics", "politics"], the system internally creates the two hypotheses "This text is about economics." and "This text is about politics.".
The model then evaluates for both hypotheses if they are entailed in the provided `text` or not.
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. If not provided, the default recommended zero-shot classification model will be used.
Returns:
`List[ZeroShotClassificationOutputElement]`: List of [`ZeroShotClassificationOutputElement`] items containing the predicted labels and their confidence.
Raises:
[`InferenceTimeoutError`]:
If the model is unavailable or the request times out.
`aiohttp.ClientResponseError`:
If the request fails with an HTTP error status code other than HTTP 503.
Example with `multi_label=False`:
```py
# Must be run in an async context
>>> from huggingface_hub import AsyncInferenceClient
>>> client = AsyncInferenceClient()
>>> 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"]
>>> await client.zero_shot_classification(text, labels)
[
ZeroShotClassificationOutputElement(label='scientific discovery', score=0.7961668968200684),
ZeroShotClassificationOutputElement(label='space & cosmos', score=0.18570658564567566),
ZeroShotClassificationOutputElement(label='microbiology', score=0.00730885099619627),
ZeroShotClassificationOutputElement(label='archeology', score=0.006258360575884581),
ZeroShotClassificationOutputElement(label='robots', score=0.004559356719255447),
]
>>> await client.zero_shot_classification(text, labels, multi_label=True)
[
ZeroShotClassificationOutputElement(label='scientific discovery', score=0.9829297661781311),
ZeroShotClassificationOutputElement(label='space & cosmos', score=0.755190908908844),
ZeroShotClassificationOutputElement(label='microbiology', score=0.0005462635890580714),
ZeroShotClassificationOutputElement(label='archeology', score=0.00047131875180639327),
ZeroShotClassificationOutputElement(label='robots', score=0.00030448526376858354),
]
```
Example with `multi_label=True` and a custom `hypothesis_template`:
```py
# Must be run in an async context
>>> from huggingface_hub import AsyncInferenceClient
>>> client = AsyncInferenceClient()
>>> await client.zero_shot_classification(
... text="I really like our dinner and I'm very happy. I don't like the weather though.",
... labels=["positive", "negative", "pessimistic", "optimistic"],
... multi_label=True,
... hypothesis_template="This text is {} towards the weather"
... )
[
ZeroShotClassificationOutputElement(label='negative', score=0.9231801629066467),
ZeroShotClassificationOutputElement(label='pessimistic', score=0.8760990500450134),
ZeroShotClassificationOutputElement(label='optimistic', score=0.0008674879791215062),
ZeroShotClassificationOutputElement(label='positive', score=0.0005250611575320363)
]
```
)�candidate_labelsr� r� r� zzero-shot-classification�re rT Nr� �scores)�label�scoreri )r rk r �zipr@ r� ) r[ r� r� r� r� rT r� r� rt r
r� r� s r\ �zero_shot_classificationz-AsyncInferenceClient.zero_shot_classification s� � �� �p !'�&�#6�
�
�
#�4�J�?��"����
��
�+��
�
��
��)�� !$�F�8�$4�f�X�6F� G�
� G� ��u�
0� E� E�PU�`e�Ff� g� G�
�
�
��
�s! �.B�A;�$B�"A=�7B�=B)rT r� c � � K � t |� dk r t d� �t |� dj |� d�}d|i}t ||�� } | j
d
i |�|dd���� d { ��� }t
j |� S 7 ��w) az
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. If not provided, the default recommended zero-shot image classification model will be used.
hypothesis_template (`str`, *optional*):
The sentence used in conjunction with `labels` to attempt the text classification by replacing the
placeholder with the candidate labels.
Returns:
`List[ZeroShotImageClassificationOutputElement]`: List of [`ZeroShotImageClassificationOutputElement`] items containing the predicted labels and their confidence.
Raises:
[`InferenceTimeoutError`]:
If the model is unavailable or the request times out.
`aiohttp.ClientResponseError`:
If the request fails with an HTTP error status code other than HTTP 503.
Example:
```py
# Must be run in an async context
>>> from huggingface_hub import AsyncInferenceClient
>>> client = AsyncInferenceClient()
>>> await 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"],
... )
[ZeroShotImageClassificationOutputElement(label='dog', score=0.956),...]
```
rD z/You must specify at least 2 classes to compare.rr )r� �candidateLabelsr� r� z zero-shot-image-classificationr� Nri )r� rW r rv r rk rA r� ) r[ r� r� rT r� r� r� r� rt s r\ � zero_shot_image_classificationz3AsyncInferenceClient.zero_shot_image_classification{ s� � �� �Z �v�;��?� � N�O� O�&�u�-�#�(�(�6�BR�S��+�-@�A�
�"�6�j�A��"����
��
��1�
�
��
8�I�I�(�S�S�
�s �A"B �$A>�%B rH c � � �� t � }� j j � }|�|j |� |j |� j
|j
� j � � j �� �t � � j �< �j �_ � �fd�}|�_ �j �_ � �fd�}|�_
�S )N)rN rO rM rP c � � �K � �j | |fi |��� d { ��� }�j � j |� |S 7 �$�wrh )�_wrapped_requestrZ �add)�methodr� r rt r[ r� s ��r\ �_requestz:AsyncInferenceClient._get_client_session.<locals>._request� sE �� �� � 5�W� 5� 5�f�c� L�V� L�L�H� �N�N�7� #� '� '�� 1��O� M�s �A�A �%Ac � �� �K � �j � D ] } | j � � �j � � d { ��� �j j �d � y 7 �!�wrh )rZ r� �_closeru )rt r[ r� s ��r\ �
close_sessionz?AsyncInferenceClient._get_client_session.<locals>.close_session� sM �� �� � �N�N�7� 3����� � 4��.�.�"� "� "� �N�N� � �w�� -�
#�s �8A �A �"A )rF rN �copyrX rH rO �
ClientTimeoutrM rP r2 rZ r� r� r� r� )r[ rN r� �client_headersr� r� r� s ` @r\ r{ z(AsyncInferenceClient._get_client_session� s� �� �!�#�� � � �*�*�,�� � � � !� !�'� *� �'�'�"��L�L��)�)�$�,�,�7��n�n� (�
�� #&�%����w� � $+�#3�#3�� � �
$���
!� � ��� .� &��
��r^ c �B � |xs | j xs | j }|�$|j d� s|j d� r|S |�=|� t d� �| j |� }t
j
d|� d|� d|� d�� |dv rt � d |� d
|� �S t � d |� �S ) Nr� r� z�You must specify at least a model (repo_id or URL) or a task, either when instantiating `InferenceClient` or when making a request.zUsing recommended model z
for task z7. Note that it is encouraged to explicitly set `model='zI'` as the recommended models list might get updated without prior notice.)r� r# z
/pipeline/r� �/models/)rT rR r� rW r� r� r� r )r[ rT re s r\ rw z!AsyncInferenceClient._resolve_url� s� � ��4����4�t�}�}�� � �%�"2�"2�9�"=��AQ�AQ�R\�A]��L� �=��|� �C�� � �.�.�t�4�E� �K�K�*�5�'��D�6� B9�9>�� @G�G�
� �D�D� "�"�*�T�F�!�E�7� ;�
�
'�'�x��w�7�
r^ c �Z � t � j | � }|�t d| � d�� �|S )a�
Get the model Hugging Face recommends for the input task.
Args:
task (`str`):
The Hugging Face task to get which model Hugging Face recommends.
All available tasks can be found [here](https://huggingface.co/tasks).
Returns:
`str`: Name of the model recommended for the input task.
Raises:
`ValueError`: If Hugging Face has no recommendation for the input task.
zTask zo has no recommended model. Please specify a model explicitly. Visit https://huggingface.co/tasks for more info.)r r* rW r� s r\ r� z*AsyncInferenceClient.get_recommended_model� sC � � *�+�/�/��5�� �=� ���v� Q� Q��
� � r^ c � �� K � |xs | j }|� t d� �|j d� r|j d� dz }n t � d|� d�}| j � 4 �d{ ��� }|j
|| j �� � d{ ��� }|j � |j � � d{ ��� cddd� �d{ ��� S 7 �b7 �?7 �7 � # 1 �d{ ���7 sw Y yxY w�w)a�
Get information about the deployed endpoint.
This endpoint is only available on endpoints powered by Text-Generation-Inference (TGI) or Text-Embedding-Inference (TEI).
Endpoints powered by `transformers` return an empty payload.
Args:
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:
`Dict[str, Any]`: Information about the endpoint.
Example:
```py
# Must be run in an async context
>>> from huggingface_hub import AsyncInferenceClient
>>> client = AsyncInferenceClient("meta-llama/Meta-Llama-3-70B-Instruct")
>>> await client.get_endpoint_info()
{
'model_id': 'meta-llama/Meta-Llama-3-70B-Instruct',
'model_sha': None,
'model_dtype': 'torch.float16',
'model_device_type': 'cuda',
'model_pipeline_tag': None,
'max_concurrent_requests': 128,
'max_best_of': 2,
'max_stop_sequences': 4,
'max_input_length': 8191,
'max_total_tokens': 8192,
'waiting_served_ratio': 0.3,
'max_batch_total_tokens': 1259392,
'max_waiting_tokens': 20,
'max_batch_size': None,
'validation_workers': 32,
'max_client_batch_size': 4,
'version': '2.0.2',
'sha': 'dccab72549635c7eb5ddb17f43f0b7cdff07c214',
'docker_label': 'sha-dccab72'
}
```
N�Model id not provided.r� r� z/infor� r) )
rT rW r� r� r r{ r* rQ r~ rc �r[ rT r� r+ rt s r\ �get_endpoint_infoz&AsyncInferenceClient.get_endpoint_info s� � �� �X �#����� �=� � 5�6� 6� � � � 3� 4��,�,�s�#�g�-�C�'�(����u�=�C��+�+�-�-�� #�Z�Z��4�<�<�Z� @�@�H� � %� %� '�!� � � �(� )� )� )�-��@��(�� )��-�-�-�sl �A$C&�&C �'C&�*!C� C � 'C�3C
�4C�7 C&�C�C&� C�
C�C&�C#�C �C#� C&c � � K � |xs | j }|� t d� �|j d� s t d� �|j d� dz }| j � 4 �d{ ��� }|j || j �� � d{ ��� }|j dk( cddd� �d{ ��� S 7 �I7 �&7 � # 1 �d{ ���7 sw Y yxY w�w) aT
Check the health of the deployed endpoint.
Health check is only available with Inference Endpoints powered by Text-Generation-Inference (TGI) or Text-Embedding-Inference (TEI).
For Inference API, please use [`InferenceClient.get_model_status`] instead.
Args:
model (`str`, *optional*):
URL of the Inference Endpoint. This parameter overrides the model defined at the instance level. Defaults to None.
Returns:
`bool`: True if everything is working fine.
Example:
```py
# Must be run in an async context
>>> from huggingface_hub import AsyncInferenceClient
>>> client = AsyncInferenceClient("https://jzgu0buei5.us-east-1.aws.endpoints.huggingface.cloud")
>>> await client.health_check()
True
```
Nr� r� zuModel must be an Inference Endpoint URL. For serverless Inference API, please use `InferenceClient.get_model_status`.r� z/healthr) rr )rT rW r� r� r{ r* rQ r| r� s r\ � health_checkz!AsyncInferenceClient.health_checkM s� � �� �. �#����� �=� � 5�6� 6�� � � 7�8� � H��
� �l�l�3� �)�+���+�+�-�-�� #�Z�Z��4�<�<�Z� @�@�H��?�?�c�)� *� *� *�-��@�� *��-�-�-�sZ �A"C �$B.�%C �(!B4� B0�
B4� C �(B2�)C �0B4�2C �4C�:B= �;C�C c � � K � |xs | j }|� t d� �|j d� r t d� �t � d|� �}| j � 4 �d{ ��� }|j
|| j �� � d{ ��� }|j � |j � � d{ ��� }ddd� �d{ ��� dv rt |d � �t |d |d |d
|d � � S 7 ��7 �k7 �E7 �7# 1 �d{ ���7 sw Y �GxY w�w)
a
Get the status of a model hosted on the Inference API.
<Tip>
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`].
</Tip>
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
# Must be run in an async context
>>> from huggingface_hub import AsyncInferenceClient
>>> client = AsyncInferenceClient()
>>> await client.get_model_status("meta-llama/Meta-Llama-3-8B-Instruct")
ModelStatus(loaded=True, state='Loaded', compute_type='gpu', framework='text-generation-inference')
```
Nr� r� z;Model status is only available for Inference API endpoints.z/status/r) r� �loaded�state� compute_typer! )r� r� r� r! ) rT rW r� �NotImplementedErrorr r{ r* rQ r~ rc r )r[ rT r� r+ rt �
response_datas r\ �get_model_statusz%AsyncInferenceClient.get_model_statusq s � �� �> �#����� �=� � 5�6� 6� � � �J� '�%�&c�d� d�#�$�H�U�G�4���+�+�-�-�� #�Z�Z��4�<�<�Z� @�@�H� � %� %� '�"*�-�-�/� 1�M� .�-�
�m� #� �]�7� 3�4� 4�� ��*� ��(�&�~�6�#�K�0�
�
� .��@�� 1�� .��-�-�-�sl �AD�C*� D� !C2� C,�'C2�(C.�)C2�- D�8C0�92D�,C2�.C2�0D�2D�8C; �9D� Dc � � t | � S rh )�ProxyClientChatra s r\ �chatzAsyncInferenceClient.chat� s
� � �t�$�$r^ rh )NN)rU r� )]�__name__�
__module__� __qualname__�__doc__r r1 r �bool�floatr r r] rb r r r r �bytesrk r r� r� r� r� �intr# r� r% r� r& r� r' r( r) r= r* r� r+ r� r, r� r� r- r� r. r r/ r r r0 r r5 r1 r7 r2 r; rC rC r3 rO r4 rS rV rY r5 r[ r7 rk r8 r9 r: r� r� r< r� r> r� r? r� r@ r� rA r� r{ rw � staticmethodr� r� r� r r� �propertyr� ri r^ r\ rK rK f s~ � �&�T $�*N� )-�#'�,0�,0� �!%�"&�!%�*N���}�*N� �S�$��_�%� *N�
�%� � *N� �$�s�C�x�.�)�
*N� �$�s�C�x�.�)�*N� �*N� �#� �*N� �3�-�*N� �#� �*N�
�*N�Xh� � 26�#'� #� "�!$�� �u�S�$��_�-�.�� �x� � �
��}� � �s�m�
� ����
�� �� � 26�#'� #� "� #�#� �u�S�$��_�-�.�#� �x� � #�
��}� #� �s�m�
#� ��
�#�
�u� �#� �#� � 26�#'� #� "� �1� �u�S�$��_�-�.�1� �x� � 1�
��}� 1� �s�m�
1� �1�
�u�m�E�*�*� +�1� �1� 26�#'� #� "� �h� �u�S�$��_�-�.�h� �x� � h�
��}� h� �s�m�
h� �h�
�u�m�E�*�*� +�h�T��� V� $� #�LP�
1L��1L� ��}� 1L�
��}� 1L� $�$H�I�
1L�
�.� /�1L�n $� * ��* � ��}� * �
�'� (� * �` $� #P��#P� ��}� #P�
*� #P�J �
$�!&�-1�,0�#'�$(� �,0�DH� "�$(�EI�'+�IM�%)�-1�&*�!%�+#��t�*�#� ��}� #�
��� #� $�E�?�
#� �T�%�[�)�#� �4�.�#� �S�M�#� �C�=�#� #�5�/�#� "�"@�A�#� �s�m�#� �t�C�y�!� #� !�!A�B� #� �e�_�!#�" �e�$?��$D� E�F�##�$ �c�]�%#�& ��[�)�*�'#�( �s�m�)#�* ���+#�,
�-#� �#�0 �
$� $�-1�,0�#'�$(� �,0�DH� "�$(�EI�'+�IM�%)�-1�&*�!%�+8��t�*�8� ��}� 8�
��
� 8� $�E�?�
8� �T�%�[�)�8� �4�.�8� �S�M�8� �C�=�8� #�5�/�8� "�"@�A�8� �s�m�8� �t�C�y�!� 8� !�!A�B� 8� �e�_�!8�" �e�$?��$D� E�F�#8�$ �c�]�%8�& ��[�)�*�'8�( �s�m�)8�* ���+8�,
�1� 2�-8� �8�0 �
$� �-1�,0�#'�$(� �,0�DH� "�$(�EI�'+�IM�%)�-1�&*�!%�+U��t�*�U� ��}� U�
� U� $�E�?�
U� �T�%�[�)�U� �4�.�U� �S�M�U� �C�=�U� #�5�/�U� "�"@�A�U� �s�m�U� �t�C�y�!� U� !�!A�B� U� �e�_�!U�" �e�$?��$D� E�F�#U�$ �c�]�%U�& ��[�)�*�'U�( �s�m�)U�* ���+U�,
�#�]�3M�%N�N� O�-U� �U�8 $� �-1�,0�#'�$(� �,0�DH� "�$(�EI�'+�IM�%)�-1�&*�!%�-o@��t�*�o@� ��}� o@�
� o@� $�E�?�o@� �T�%�[�)�o@� �4�.�o@� �S�M�o@� �C�=�o@� #�5�/�o@� "�"@�A�o@� �s�m� o@� �t�C�y�!� o@� !�!A�B�!o@�" �e�_�#o@�$ �e�$?��$D� E�F�%o@�& �c�]�'o@�( ��[�)�*�)o@�* �s�m�+o@�, ���-o@�.
�#�]�3M�%N�N� O�/o@�b �(�3�-� �3� �< $�$(�37� "�(,�*.�%)� #�>B�RR��RR� �RR�
��}� RR� �S�M�
RR� #+�4�.�RR� �s�m�RR� !��
�RR� #�3�-�RR� �c�]�RR� ��}�RR� �T�%��U� �S�(8�"9� :�;�RR�
�4� 5� RR�p %)�%)�#'�CG� #�AC��AC� �D�>� AC�
�c�]� AC� �4�.�
AC� '�w��'?� @�AC� ��}�AC�
�AC�N $�'+� #�
1A��1A� ��}� 1A�
�$�s�)�$� 1A� ��}�
1A�
�#� $�1A�n $�MQ� #�
*L��*L� ��}� *L�
$�G�,H�$I�J� *L� ��}�
*L�
�.� /�*L�` $�*.�7;�IM�%)�>��>� ��}� >�
!��� >� &.�e�_�
>� �'�"D�E�F�>� �E�?�>�
�,� -�>�F !%�H)�
*.� $� #�-1�*.� #�H)��H)� ��
�H)�
"�#� � H)� ��
�
H)� ��}�H)� &�c�]�H)� !���H)� ��}�H)�
�H)�T NR� $A�� $A�X�c�]� $A�Vg� $A�N IM�W � ��c�7�5�>�4��9� D�E�W �
�c�4��9�n� �W �t :>�\`�-H� �-H�)1�#� �-H�JR�SX�/�-H�
�*� +�-H�h $�)-�$(�37�(,�*.�%)� #�S��S� �S�
��}� S� !���
S� �S�M�S� #+�4�.�S� !��
�S� #�3�-�S� �c�]�S� ��}�S�
�-�t�4R�/S�S� T�S�l TX�.(��.(�.2�3�i�.(�CK�C�=�.(�
�e��.(�` ��%��
~� � 04� #�7;�8<�im�6B��6B� �T�#�s�(�^�,� 6B�
��}� 6B� '/�t�n�
6B� &�d�3��8�n� 5�6B� �W�%d� e�f�6B�
�6B��6B�z $�/3�
5S��C��H�~�5S� �5S�
��}� 5S� �T�#�s�(�^�,�
5S�
-�5S�n ]a� 0(�$�s�C�x�.� 0(�H�UX�M� 0(�ei�jm�en� 0(�d Y]� '(�d�3��8�n� '(��QT�
� '(�ae�fk�al� '(�Z $� #�KO�
6N��6N� ��}� 6N�
��}� 6N� $�$G�H�
6N�
�-� .�6N�p �
#&�!$� #�$(�!%�04�$)�-1�<@�(,�.2�+0� "�$(�.2�'+� #�&*�!%�"&�%)�$(�5��� �� � �
��� � ��}�
� �S�M�� �#� �� (��~�� �D�>�� $�E�?�� �8�9�� !��
� � %�U�O� � #�4�.�!�" �s�m�#�$ �t�C�y�!�%�& !��c��+�'�( �e�_�)�* ��}�+�, �s�m�-�. ���/�0 �3�-�1�2 �E�?�3�4 �D�>�5�6
�7� ��: �
"%�!$� #�$(�!%�04�$)�-1�<@�(,�.2�+0� "�$(�.2�'+� #�&*�!%�"&�%)�$(�5#��#� �� � #�
��� #� ��}�
#� �S�M�#� �#� �#� (��~�#� �D�>�#� $�E�?�#� �8�9�#� !��
� #� %�U�O� #� #�4�.�!#�" �s�m�##�$ �t�C�y�!�%#�& !��c��+�'#�( �e�_�)#�* ��}�+#�, �s�m�-#�. ���/#�0 �3�-�1#�2 �E�?�3#�4 �D�>�5#�6
�7#� �#�: �
#&� #� #�$(�!%�04�$)�-1�<@�(,�.2�+0� "�$(�.2�'+� #�&*�!%�"&�%)�$(�5!��!� �� � !�
��
� !� ��}�
!� �S�M�!� �#� �!� (��~�!� �D�>�!� $�E�?�!� �8�9�!� !��
� !� %�U�O� !� #�4�.�!!�" �s�m�#!�$ �t�C�y�!�%!�& !��c��+�'!�( �e�_�)!�* ��}�+!�, �s�m�-!�. ���/!�0 �3�-�1!�2 �E�?�3!�4 �D�>�5!�6
�s� �7!� �!�: �
"%� #� #�$(�!%�04�$)�-1�<@�(,�.2�+0� "�$(�.2�'+� #�&*�!%�"&�%)�$(�58��8� �� � 8�
��
� 8� ��}�
8� �S�M�8� �#� �8� (��~�8� �D�>�8� $�E�?�8� �8�9�8� !��
� 8� %�U�O� 8� #�4�.�!8�" �s�m�#8�$ �t�C�y�!�%8�& !��c��+�'8�( �e�_�)8�* ��}�+8�, �s�m�-8�. ���/8�0 �3�-�18�2 �E�?�38�4 �D�>�58�6
�1� 2�78� �8�: �
"%�� #�$(�!%�04�$)�-1�<@�(,�.2�+0� "�$(�.2�'+� #�&*�!%�"&�%)�$(�5U��U� �� � U�
� U� ��}�
U� �S�M�U� �#� �U� (��~�U� �D�>�U� $�E�?�U� �8�9�U� !��
� U� %�U�O� U� #�4�.�!U�" �s�m�#U�$ �t�C�y�!�%U�& !��c��+�'U�( �e�_�)U�* ��}�+U�, �s�m�-U�. ���/U�0 �3�-�1U�2 �E�?�3U�4 �D�>�5U�6
�#�]�3M�%N�N� O�7U� �U�B � � #�$(�!%�04�$)�-1�<@�(,�.2�+0� "�$(�.2�'+� #�&*�!%�"&�%)�$(�5Yg��Yg� � Yg�
� Yg� ��}�
Yg� �S�M�Yg� �#� �Yg� (��~�Yg� �D�>�Yg� $�E�?�Yg� �8�9�Yg� !��
� Yg� %�U�O� Yg� #�4�.�!Yg�" �s�m�#Yg�$ �t�C�y�!�%Yg�& !��c��+�'Yg�( �e�_�)Yg�* ��}�+Yg�, �s�m�-Yg�. ���/Yg�0 �3�-�1Yg�2 �E�?�3Yg�4 �D�>�5Yg�6
�s�(�-��*<�m�Lf�>g�g� h�7Yg�~
*.�"&�!%�/3�*.� #�#'�7;� "�Z)��Z)� "�#� � Z)�
��� Z)� ���
Z)� &�e�_�Z)� !���Z)� ��}�Z)� �C�=�Z)� � 3�4�Z)� �s�m�Z)�
� Z)�@ $�$(�QU�*.�&*�$(�(,�$(�(,�)-�#'�)-�'+� #�!%�%)�$(�)y��y� ��}� y�
�D�>� y� !��t�-L�'L�!M�N�
y� !���y� �U�O�y� �S�M�y� !��
�y� �S�M�y� !��
�y� "�#� �y� �C�=� y� ��� y� �e�_�!y�" ��}�#y�$ ���%y�& �E�?�'y�( �D�>�)y�*
�+y�~ $�_c�-1� $�HL��HL� ��}� HL�
'�w�/Z�'[� \� HL� ��S� �*�
HL� ��
�HL�
�.� /�HL�\ $�"&�"&�7;�im�8<�P@��P@� ��}� P@�
�3�-� P@� �3�-�
P@� '/�t�n�P@� �W�%d� e�f�P@� &�d�3��8�n� 5�P@�
�P@�n $� #�
4P��4P� �4P�
��}� 4P� ��}�
4P�
�2� 3�4P�v "�-1� #�f
��f
� �S� �f
�
� f
� &�c�]�
f
� ��}�f
�
�1� 2�f
�Z $�-1�
8T��8T� �S� �8T�
��}� 8T� &�c�]�
8T�
�6� 7�8T�t'�8�D�>� '�_� '�R
�(�3�-�
�h�s�m�
�WZ�
�< ��C� �C� � ��. AE� 7)���
� 7)��c�SV�h� � 7)�r"*���
� "*�� "*�H3
�H�S�M� 3
�[� 3
�j �%� �%r^ rK c � � e Zd ZdZdefd�Zy)� _ProxyClient�UProxy class to be able to call `client.chat.completion.create(...)` as OpenAI client.r+ c � � || _ y rh )�_client)r[ r+ s r\ r] z_ProxyClient.__init__� s � � �� r^ N)r� r� r� r� rK r] ri r^ r\ r� r� � s � �_� � 3� r^ r� c �" � e Zd ZdZedd�� Zy)r� r� c �, � t | j � S rh )�ProxyClientChatCompletionsr� ra s r\ � completionszProxyClientChat.completions� s � �)�$�,�,�7�7r^ N)rU r� )r� r� r� r� r� r� ri r^ r\ r� r� � s � �_�
�8� �8r^ r� c � � e Zd ZdZed� � Zy)r� r� c �. � | j j S rh )r� r� ra s r\ �createz!ProxyClientChatCompletions.create� s � ��|�|�+�+�+r^ N)r� r� r� r� r� r� ri r^ r\ r� r� � s � �_�
�,� �,r^ r� )br� r� �logging�rerz rx �typingr r r r r r r r
r r �requests.structuresr
�huggingface_hub.constantsr r r �huggingface_hub.errorsr �!huggingface_hub.inference._commonr r r r r r r r r r r r r r r r! r" �*huggingface_hub.inference._generated.typesr# r$ r% r& r' r( r) r* r+ r, r- r. r/ r0 r1 r2 r3 r4 r5 r6 r7 r8 r9 r: r; r< r= r> r? r@ rA �huggingface_hub.utilsrB �"huggingface_hub.utils._deprecationrC �_commonrE rF �numpyr� r� rG rH � PIL.ImagerI � getLoggerr� r� �compilerx rK r� r� r� ri r^ r\ �<module>r� s� ��* �
� � � � � i� i� i� 3� u� u� 8�� � � � �& � � � � � � � � �B 3� C� 8� ��5� � �� � �8� $�� )�b�j�j�)m� n� �B1%� B1%�Jb � �8�l� 8�,� � ,r^