huggingface-huggingface-hub-2528

-rw-r--r-- 1 root root  6969 Sep 30 17:31 README.md
-rw-r--r-- 1 root root  6703 Sep 30 17:31 README_cn.md
-rw-r--r-- 1 root root  7696 Sep 30 17:31 README_de.md
-rw-r--r-- 1 root root 11862 Sep 30 17:31 README_hi.md
-rw-r--r-- 1 root root  7806 Sep 30 17:31 README_ko.md
-rw-r--r-- 1 root root   310 Sep 30 17:31 codecov.yml
drwxr-xr-x 1 root root  4096 Sep 30 17:31 contrib
drwxr-xr-x 1 root root  4096 Sep 30 17:31 docs
-rw-r--r-- 1 root root  1241 Sep 30 17:31 pyproject.toml
-rw-r--r-- 1 root root  4088 Sep 30 17:31 setup.py
drwxr-xr-x 1 root root  4096 Sep 30 17:32 src
drwxr-xr-x 1 root root  4096 Sep 30 17:31 tests
drwxr-xr-x 1 root root  4096 Sep 30 17:31 utils
bash: line 6: rg: command not found

tests/test_inference_async_client.py:457:    session = client._get_client_session()
tests/test_inference_endpoints.py:7:    AsyncInferenceClient,
tests/test_inference_endpoints.py:174:    assert isinstance(async_client, AsyncInferenceClient)

    [`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 clie
…[8630 chars omitted]…

    # Watermark is ignored (+ warning)
    with pytest.warns(UserWarning):
        await tgi_client.text_generation("4 5 6", model="gpt2", max_new_tokens=10, watermark=True)

    # Return as detail even if details=True (+ warning)
    with pytest.warns(UserWarning):
        text = await tgi_client.text_generation("0 1 2", model="gpt2", max_new_tokens=10, details=True)
    assert isinstance(text, str)

        self.proxies = proxies

        # OpenAI compatibility
        self.base_url = base_url

        # Keep track of the sessions to close them properly
        self._sessions: Set["ClientSession"] = set()

    def __repr__(self):
        return f"<InferenceClient(model='{self.model if self.model else '
…[8629 chars omitted]…
generated_text":"I am the one who knocks.","conversation":{"generated_responses":["I
tests/cassettes/InferenceClientVCRTest.test_conversational.yaml:50:    body: '{"inputs": {"text": "Wow, that''s scary!", "generated_responses": ["I am
tests/cassettes/InferenceClientVCRTest.test_conversational.yaml:70:      string: '{"generated_text":"I am the one who knocks.","conversation":{"generated_responses":["I

        t0 = time.time()
        timeout = self.timeout
        while True:
            with _open_as_binary(data) as data_as_binary:
                # Do not use context manager as we don't want to close the connection immediately when returning
                # a stream
                session = self._get_client_session(headers=headers)

                try:
                    response = await session.post(url, json=json, data=data_as_binary, proxy=self.proxies)
                    response_error
…[7297 chars omitted]…
yClientChatCompletions(self._client)


class ProxyClientChatCompletions(_ProxyClient):
    """Proxy class to be able to call `client.chat.completion.create(...)` as OpenAI client."""

337:    async def __aenter__(self):
340:    async def __aexit__(self, exc_type, exc_value, traceback):
343:    def __del__(self):
2636:    def _get_client_session(self, headers: Optional[Dict] = None) -> "ClientSession":

            task="zero-shot-image-classification",
        )
        return ZeroShotImageClassificationOutputElement.parse_obj_as_list(response)

    def _get_client_session(self, headers: Optional[Dict] = None) -> "ClientSession":
        aiohttp = _import_aiohttp()
        client_headers = self.headers.copy()
        if headers is not None:
            client_headers.update(headers)

        # R
…[2364 chars omitted]…
ion_on_post_error(mock_close: Mock, mock_post: Mock) -> None:
417:async def test_http_session_correctly_closed() -> None:
432:    assert len(client._sessions) == 1
433:    await list(client._sessions)[0].close()
434:    assert len(client._sessions) == 0
441:    assert len(client._sessions) == 3
443:    assert len(client._sessions) == 0
455:async def test_warns_if_client_deleted_with_opened_sessions():

        return f"<InferenceClient(model='{self.model if self.model else ''}', timeout={self.timeout})>"

    @overload
    async def post(  # type: ignore[misc]
        self,
        *,
        json: Optional[Union[str, Dict, List]] = None,
        data: Optional[ContentT] = None,
        model: Optional[str] = None,
                "or use an async context (e.g. `async with AsyncInferenceClient(): ...`."
            )

    async def close(self):
        """Close all open sessions.

        By default, 'aiohttp.ClientSes
…[2158 chars omitted]…
close that response.
        request = session._request

        async def request_with_tracking(*args, **kwargs):
            response = await request(*args, **kwargs)
            self._responses.add(response)
            return response

        session._request = request_with_tracking

        # Override the 'close' method to deregister the session when closed
        session._close = session.close

)
from huggingface_hub.utils._deprecation import _deprecate_positional_args

from .._common import _async_yield_from, _import_aiohttp


if TYPE_CHECKING:
    import numpy as np
    from aiohttp import ClientSession
    from PIL.Image import Image

logger = logging.getLogger(__name__)


MODEL_KWARGS_NOT_USED_REGEX = re.compile(r"The following `model_kwargs` are not used by the model: \[(.*?)\]")


class AsyncInferenceClient:
    """
            return response

        session._request = request_with_tracking

 
…[6622 chars omitted]…

============================== slowest durations ===============================
0.03s setup    tests/test_inference_async_client.py::test_http_session_correctly_closed
0.01s call     tests/test_inference_async_client.py::test_http_session_correctly_closed

(7 durations < 0.005s hidden.  Use -vv to show these durations.)
======================= 3 passed, 22 deselected in 2.20s =======================

+        # Keep track of the sessions and responses to close them properly.
         self._sessions: Set["ClientSession"] = set()
+        self._responses: Set["ClientResponse"] = set()
 
     def __repr__(self):
         return f"<InferenceClient(model='{self.model if self.model else ''}', time
…[1084 chars omitted]…
sponse.
+        request = session._request
+
+        async def request_with_tracking(*args, **kwargs):
+            response = await request(*args, **kwargs)
+            self._responses.add(response)
+            return response
+
+        session._request = request_with_tracking
+
         # Override the 'close' method to deregister the session when closed
         session._close = session.close

(6 durations < 0.005s hidden.  Use -vv to show these durations.)
=========================== short test summary info ============================
FAILED tests/test_inference_async_client.py::test_get_status_too_big_model - ...
!!!!!!!!!!!!!!!!!!!!!!!!!! stopping after 1 failures !!!!!!!!!!!!!!!!!!!!!!!!!!!
================== 1 failed, 1 passed, 15 deselected in 1.54s ==================

============================== slowest durations ===============================
0.01s setup    tests/test_inference_async_client.py::test_http_session_correctly_closed

(14 durations < 0.005s hidden.  Use -vv to show these durations.)
======================= 5 passed, 20 deselected in 0.86s =======================

-rw-r--r-- 1 root root  6969 Sep 30 17:33 README.md
-rw-r--r-- 1 root root  6703 Sep 30 17:33 README_cn.md
-rw-r--r-- 1 root root  7696 Sep 30 17:33 README_de.md
-rw-r--r-- 1 root root 11862 Sep 30 17:33 README_hi.md
-rw-r--r-- 1 root root  7806 Sep 30 17:33 README_ko.md
-rw-r--r-- 1 root root   310 Sep 30 
…[3167 chars omitted]…
apshot_download.py
./src/huggingface_hub/_space_api.py
./src/huggingface_hub/_tensorboard_logger.py
./src/huggingface_hub/_upload_large_folder.py
./src/huggingface_hub/_webhooks_payload.py
./src/huggingface_hub/_webhooks_server.py
./src/huggingface_hub/__init__.py
./src/huggingface_hub.egg-info/dependency_links.txt
./src/huggingface_hub.egg-info/entry_points.txt
./src/huggingface_hub.egg-info/PKG-INFO

        base_url: Optional[str] = None,
        api_key: Optional[str] = None,
    ) -> None:
        if model is not None and base_url is not None:
            raise ValueError(
                "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 wil
…[8630 chars omitted]…
gingface_hub.AsyncInferenceClient.close") as mock_close:
        async with AsyncInferenceClient():
            pass
    mock_close.assert_called_once()


@pytest.mark.asyncio
async def test_warns_if_client_deleted_with_opened_sessions():
    client = AsyncInferenceClient()
    session = client._get_client_session()
    with pytest.warns(UserWarning):
        client.__del__()
    await session.close()

        url = self._resolve_url(model, task)

        if data is not None and json is not None:
            warnings.warn("Ignoring `json` as `data` is passed as binary.")

        # Set Accept header if relevant
        headers = dict()
        if task in TASKS_EXPECTING_IMAGES and "Accept" not in headers:
            headers["Accept"] = "image/png"

        t0 = time.time()
        timeout = self.timeout
        while True:
            with _open_as_binary(data) as data_as_binary:
                # Do not u
…[6948 chars omitted]…
odel is None:
            raise ValueError(
                f"Task {task} has no recommended model. Please specify a model"
                " explicitly. Visit https://huggingface.co/tasks for more info."
            )
        return model
340:    async def __aexit__(self, exc_type, exc_value, traceback):
343:    def __del__(self):
352:    async def close(self):
2656:        async def close_session():

        # Return a new aiohttp ClientSession with correct settings.
        session = aiohttp.ClientSession(
            headers=client_headers,
            cookies=self.cookies,
            timeout=aiohttp.ClientTimeout(self.timeout),
            trust_env=self.trust_env,
        )

        # Keep track of sessions to close them later
        self._sessions.add(session)

      
…[8434 chars omitted]…
34:    assert len(client._sessions) == 0
tests/test_inference_async_client.py:441:    assert len(client._sessions) == 3
tests/test_inference_async_client.py:443:    assert len(client._sessions) == 0
tests/test_inference_async_client.py:455:async def test_warns_if_client_deleted_with_opened_sessions():
tests/test_utils_http.py:21:    reset_sessions,
tests/test_utils_http.py:247:        reset_sessions()

    byte_payload: bytes,
) -> Optional[ChatCompletionStreamOutput]:
    if not byte_payload.startswith(b"data:"):
        return None  # empty line

    if byte_payload.strip() == b"data: [DONE]":
        raise StopIteration("[DONE] signal received.")

    # Decode payload
    payload = byte_payload.decode("utf-8")
    json_payload = json.loads(payload.lstrip("data:").rstrip("/n"))
    return ChatCompletionStreamOutput.parse_obj_as_instance(json_payload)


async def _async_yield_from(client: "ClientSession", response: "Clie
…[1376 chars omitted]…
nsupported_kwargs: List[str]) -> None:
    _UNSUPPORTED_TEXT_GENERATION_KWARGS.setdefault(model, []).extend(unsupported_kwargs)


def _get_unsupported_text_generation_kwargs(model: Optional[str]) -> List[str]:
    return _UNSUPPORTED_TEXT_GENERATION_KWARGS.get(model, [])


Makefile:13:	python utils/generate_async_inference_client.py
Makefile:21:	python utils/generate_async_inference_client.py --update

# See the License for the specific language governing permissions and
# limitations under the License.
"""Contains a tool to generate `src/huggingface_hub/inference/_generated/_async_client.py`."""

import argparse
import os
import re
import tempfile
from pathlib import Path
from typing import NoReturn

from ruff.__main__ import find_ruff_bin


ASYNC_CLIENT_FILE_PATH = (
    Path(__f
…[2368 chars omitted]…
ient_code = ASYNC_CLIENT_FILE_PATH.read_text()

    raw_async_client_code = generate_async_client_code(sync_client_code)

utils/generate_async_inference_client.py:266:    async def close(self):
utils/generate_async_inference_client.py:523:    def _get_client_session(self, headers: Optional[Dict] = None) -> "ClientSession":
utils/generate_async_inference_client.py:543:        async def close_session():

    code = _add_before(
        code,
        "\n        proxies (`Any`, `optional`):",
        """
        trust_env ('bool', 'optional'):
            Trust environment settings for proxy configuration if the parameter is `True` (`False` by default).""",
    )

    # insert `_get_client_session` before `_resolve_url` method
    client_session_code = """

    def _get_client_session(self, headers: 
…[2769 chars omitted]…

            .*? # implementation (to be overwritten)
        (\n\W*def ) # Group2: next method
160:            + "from typing import Set\n"
192:        # Set Accept header if relevant
523:    def _get_client_session(self, headers: Optional[Dict] = None) -> "ClientSession":
557:        "\n        # Keep track of the sessions to close them properly\n        self._sessions: Set['ClientSession']= set()",

        except OSError as exc:
            if exc.errno is None and isinstance(exc, asyncio.TimeoutError):
                raise
            # in case of proxy it is not ClientProxyConnectionError
            # it is problem of resolving proxy ip itself
>           raise ClientConnectorDNSEr
…[1430 chars omitted]…
ce_similarity

(27 durations < 0.005s hidden.  Use -vv to show these durations.)
=========================== short test summary info ============================
FAILED tests/test_inference_async_client.py::test_get_status_too_big_model - ...
!!!!!!!!!!!!!!!!!!!!!!!!!! stopping after 1 failures !!!!!!!!!!!!!!!!!!!!!!!!!!!
========================= 1 failed, 12 passed in 1.50s =========================

+            responses.clear()
+            try:
+                for response in responses_to_close:
+                    response.close()
+            finally:
+                await session._close()
+                self._sessions.discard(session)
 
         session.close = close_session
         return session

        "def __init__(self, client: AsyncInferenceClient):",
    )


def _add_before(code: str, pattern: str, addition: str) -> str:
    index = code.find(pattern)
    assert index != -1, f"Pattern '{pattern}' not found in code."
    return code[:index] + addition + code[index:]


if __name__ == "__main__":
    parser = argparse.ArgumentParser()
    parser.add_argument(
        "--update",
        action="store_true",
        help=(
            "Whether to re-generate `./src/huggingface_hub/inference/_generated/_async_client.py` if a change is"
            " detected."
        ),
    )
    args = parser.parse_args()

    check_async_client(update=args.update)

-rw-r--r-- 1 root root  6969 Sep 30 17:38 README.md
-rw-r--r-- 1 root root  6703 Sep 30 17:38 README_cn.md
-rw-r--r-- 1 root root  7696 Sep 30 17:38 README_de.md
-rw-r--r-- 1 root root 11862 Sep 30 17:38 README_hi.md
-rw-r--r-- 1 root root  7806 Sep 30 17:38 README_ko.md
-rw-r--r-- 1 root root   310 Sep 30 17:38 codecov.yml
drwxr-xr-x 1 root root  4096 Sep 30 17:38 contrib
drwxr-xr-x 1 root root  4096 Sep 30 17:38 docs
-rw-r--r-- 1 root root  1241 Sep 30 17:38 pyproject.toml
-rw-r--r-- 1 root root  4088 Sep 30 17:38 setup.py
drwxr-xr-x 1 root root  4096 Sep 30 17:39 src
drwxr-xr-x 1 root root  4096 Sep 30 17:38 tests
drwxr-xr-x 1 root root  4096 Sep 30 17:38 utils
bash: line 6: rg: command not found

tests/test_inference_async_client.py:449:        async with AsyncInferenceClient():
tests/test_inference_async_client.py:456:    client = AsyncInferenceClient()
tests/test_inference_async_client.py:457:    session = client._get_client_session()
tests/test_inference_endpoints.py:7:    AsyncInferenceClient,
tests/test_inference_endpoints.py:174:    assert isinstance(async_client, AsyncInferenceClient)

    [`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 clie
…[8630 chars omitted]…
   # Otherwise, fallback to default error
    raise http_error


def _parse_text_generation_error(error: Optional[str], error_type: Optional[str]) -> TextGenerationError:
    if error_type == "generation":
        return GenerationError(error)  # type: ignore
    if error_type == "incomplete_generation":
        return IncompleteGenerationError(error)  # type: ignore
    if error_type == "overloaded":

        # Keep track of the sessions to close them properly
        self._sessions: Set["ClientSession"] = set()

    def __repr__(self):
        return f"<InferenceClient(model='{self.model if self.model else ''}', timeout={self.timeout})>"

    @overload
    async def post(  # type: ignore[misc]
        self,
        *,
        json: Optional[Union[str, Dict, List]] = None,
        data: Optional[ContentT] = None,
        mode
…[8629 chars omitted]…
gingface_hub.AsyncInferenceClient.close") as mock_close:
        async with AsyncInferenceClient():
            pass
    mock_close.assert_called_once()


@pytest.mark.asyncio
async def test_warns_if_client_deleted_with_opened_sessions():
    client = AsyncInferenceClient()
    session = client._get_client_session()
    with pytest.warns(UserWarning):
        client.__del__()
    await session.close()

                # Do not use context manager as we don't want to close the connection immediately when returning
                # a stream
                session = self._get_client_session(headers=headers)

                try:
                    response = await session.post(url, json=json, data=data_as_binary, proxy=self.proxies)
                    response_error_payload = None
                    if response.status != 200:
                     
…[7726 chars omitted]…
 or self.get_recommended_model("text-generation")
        is_url = model_id_or_url.startswith(("http://", "https://"))

        # First, resolve the model chat completions URL
340:    async def __aexit__(self, exc_type, exc_value, traceback):
352:    async def close(self):
2636:    def _get_client_session(self, headers: Optional[Dict] = None) -> "ClientSession":
2656:        async def close_session():

        [ZeroShotImageClassificationOutputElement(label='dog', score=0.956),...]
        ```
        """
        # Raise ValueError if input is less than 2 labels
        if len(labels) < 2:
            raise ValueError("You must specify at least 2 classes to compare.")

        response = await self.post(
            json={"image": _b64_encode(image), "parameters": {"candidate_labels": ",".join(l
…[1641 chars omitted]…
at least a model (repo_id or URL) or a task, either when instantiating"
                    " `InferenceClient` or when making a request."
                )
            model = self.get_recommended_model(task)
            logger.info(
                f"Using recommended model {model} for task {task}. Note that it is"
                f" encouraged to explicitly set `model='{model}'` as the recommended"

    def __repr__(self):
        return f"<InferenceClient(model='{self.model if self.model else ''}', timeout={self.timeout})>"

    @overload
    async def post(  # type: ignore[misc]
        self,
        *,
        json: Optional[Union[str, Dict, List]] = None,

    def __del__(self):
        if len(self._sessions) > 0:
            warnings.warn(
                "Deleting 'AsyncInferenceClient' client but some sessions are still
…[1602 chars omitted]…
        close the session properly.

        Another possibility is to use an async context (e.g. `async with AsyncInferenceClient(): ...`).
        """
        await asyncio.gather(*[session.close() for session in self._sessions])

    async def audio_classification(
        self,
        audio: ContentT,
        *,
        model: Optional[str] = None,
    ) -> List[AudioClassificationOutputElement]:

        if len(self._sessions) > 0:
            warnings.warn(
                "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(): ...`."
            )

    async def close(self):
        """Close all open responses and sessions.

        By default, 'aiohttp.ClientSession' objects are
…[2382 chars omitted]…
     self._responses.append(response)
            return response

        session._request = request_and_track

        # Override the 'close' method to deregister the session when closed
        session._close = session.close

        async def close_session():
            await session._close()
            self._sessions.discard(session)

        session.close = close_session
        return session

tests/test_inference_async_client.py::test_warns_if_client_deleted_with_opened_sessions PASSED

============================== slowest durations ===============================

(9 durations < 0.005s hidden.  Use -vv to show these durations.)
======================= 3 passed, 22 deselected in 1.15s =======================

# See the License for the specific language governing permissions and
# limitations under the License.
#
# WARNING
# This entire file has been adapted from the sync-client code in `src/huggingface_hub/inference/_client.py`.
# Any change in InferenceClient will be automatically reflected in AsyncInferenceClient.
# To re-generate the code, run `make style` or `python ./utils/generate_a
…[5020 chars omitted]…
st_original = session._request
+
+        async def request_and_track(*args, **kwargs):
+            response = await session._request_original(*args, **kwargs)
+            self._responses.append(response)
+            return response
+
+        session._request = request_and_track
+
         # Override the 'close' method to deregister the session when closed
         session._close = session.close

…[8631 chars omitted]…
ce_similarity

(27 durations < 0.005s hidden.  Use -vv to show these durations.)
=========================== short test summary info ============================
FAILED tests/test_inference_async_client.py::test_get_status_too_big_model - ...
!!!!!!!!!!!!!!!!!!!!!!!!!! stopping after 1 failures !!!!!!!!!!!!!!!!!!!!!!!!!!!
========================= 1 failed, 12 passed in 1.49s =========================

============================== slowest durations ===============================

(9 durations < 0.005s hidden.  Use -vv to show these durations.)
======================= 3 passed, 22 deselected in 0.90s =======================
 .../inference/_generated/_async_client.py          | 30 +++++++++++++++++++++-
 1 file changed, 29 insertions(+), 1 deletion(-)

-rw-r--r-- 1 root root  6969 Sep 30 17:40 README.md
-rw-r--r-- 1 root root  6703 Sep 30 17:40 README_cn.md
-rw-r--r-- 1 root root  7696 Sep 30 17:40 README_de.md
-rw-r--r-- 1 root root 11862 Sep 30 17:40 README_hi.md
-rw-r--r-- 1 root root  7806 Sep 30 17:40 README_ko.md
-rw-r--r-- 1 root root   310 Sep 30 17:40 codecov.yml
drwxr-xr-x 1 root root  4096 Sep 30 17:40 contrib
drwxr-xr-x 1 root root  4096 Sep 30 17:40 docs
-rw-r--r-- 1 root root  1241 Sep 30 17:40 pyproject.toml
-rw-r--r-- 1 root root  4088 Sep 30 17:40 setup.py
drwxr-xr-x 1 root root  4096 Sep 30 17:41 src
drwxr-xr-x 1 root root  4096 Sep 30 17:40 tests
drwxr-xr-x 1 root root  4096 Sep 30 17:40 utils
bash: line 6: rg: command not found

src/huggingface_hub/_login.py
src/huggingface_hub/_multi_commits.py
src/huggingface_hub/_snapshot_download.py
src/huggingface_hub/_space_api.py
src/huggingface_hub/_tensorboard_logger.py
src/huggingface_hub/_upload_large_folder.py
src/huggingface_hub/_webhooks_payload.py
src/huggingface_hub/_webhooks_server.py
src/huggingface_hub/commands/__init__.py
src/huggingface_hub/commands/_cli_utils.py
src/huggingface_hub/co
…[8694 chars omitted]…
sts/test_keras_integration.py
tests/test_lfs.py
tests/test_local_folder.py
tests/test_login_utils.py
tests/test_offline_utils.py
tests/test_repocard.py
tests/test_repocard_data.py
tests/test_repository.py
tests/test_serialization.py
tests/test_snapshot_download.py
tests/test_testing_configuration.py
tests/test_tf_import.py
tests/test_utils_assets.py
tests/test_utils_cache.py
tests/test_utils_chunks.py

:            self._sessions.discard(session)
src/huggingface_hub/inference/_generated/_async_client.py:2769:        async with self._get_client_session() as client:
src/huggingface_hub/inference/_generated/_async_client.py:2806:        async with self._get_client_session() as client:
src/huggingface_hub/inference/_generated/_async_client.py:2848:        async with self._get_client_session() as client:

        Example:
        ```py
        # Must be run in an async context
        >>> from huggingface_hub import AsyncInferenceClient
        >>> client = AsyncInferenceClient()

        >>> await client.z
…[5817 chars omitted]…
etLogger(__name__)


MODEL_KWARGS_NOT_USED_REGEX = re.compile(r"The following `model_kwargs` are not used by the model: \[(.*?)\]")


class AsyncInferenceClient:
    """
    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.

+        responses = []
+        request = session._request
+
+        async def request_with_tracking(*args, **kwarg
…[538 chars omitted]…
        # close the same response more than once.
+            responses_to_close = responses[:]
+            responses.clear()
+            for response in responses_to_close:
+                response.close()
+            try:
+                await session._close()
+            finally:
+                self._sessions.discard(session)
 
         session.close = close_session
         return session

(27 durations < 0.005s hidden.  Use -vv to show these durations.)
=========================== short test summary info ============================
FAILED tests/test_inference_async_client.py::test_get_status_too_big_model - ...
!!!!!!!!!!!!!!!!!!!!!!!!!! stopping after 1 failures !!!!!!!!!!!!!!!!!!!!!!!!!!!
========================= 1 failed, 12 passed in 1.70s =========================

============================== slowest durations ===============================

(9 durations < 0.005s hidden.  Use -vv to show these durations.)
======================= 3 passed, 22 deselected in 0.77s =======================

        url = self._resolve_url(model, task)

        if data is not None and json is not None:
            warnings.warn("Ignoring `json` as `data` is passed as binary.")

        # Set Accept header if relevant
        headers = dict()
        if task in TASKS_EXPECTING_IMAGES and "Accept" not in headers:
            headers["Accept"] = "image/png"

        t0 = time.time()
        timeout = self.timeout
        while True:
            with _open_as_binary(data) as data_as_binary:
                # Do not u
…[5022 chars omitted]…
         trust_env=self.trust_env,
        )

        # Keep track of sessions to close them later
        self._sessions.add(session)

        # Override the 'close' method to deregister the session when closed
        session._close = session.close

        async def close_session():
            await session._close()
            self._sessions.discard(session)

        session.close = close_session

            if task is None:
                raise ValueError(
                    "You must specify at least a model (repo_id or URL) or a task, either when instantiating"
                    " `InferenceClient` or when making a request."
                )
            model = self.get_recommended_model(task)
            logger.info(
                f"Using recommended model {model} f
…[742 chars omitted]…
-            await session._close()
2658-            self._sessions.discard(session)
2659-
2660-        session.close = close_session
2661-        return session
2662-
2663-    def _resolve_url(self, model: Optional[str] = None, task: Optional[str] = None) -> str:
2664-        model = model or self.model or self.base_url
2665-
2666-        # If model is already a URL, ignore `task` and return directly

    assert len(client._sessions) == 3
    await client.close()
    assert len(client._sessions) == 0


@pytest.mark.asyncio
async def test_use_async_with_inference_client():
    with 
…[10 chars omitted]…
gingface_hub.AsyncInferenceClient.close") as mock_close:
        async with AsyncInferenceClient():
            pass
    mock_close.assert_called_once()


@pytest.mark.asyncio
async def test_warns_if_client_deleted_with_opened_sessions():
    client = AsyncInferenceClient()
    session = client._get_client_session()
    with pytest.warns(UserWarning):
        client.__del__()
    await session.close()

Dropped refs/stash@{0} (cca335539887c6ca8e69b5fab00e79a2340cf224)