huggingface-hub 0.31.0rc0__py3-none-any.whl → 1.1.3__py3-none-any.whl

huggingface_hub/commands/upload_large_folder.py

@@ -1,129 +0,0 @@
-# coding=utf-8
-# Copyright 2023-present, the HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Contains command to upload a large folder with the CLI."""
-
-import os
-from argparse import Namespace, _SubParsersAction
-from typing import List, Optional
-
-from huggingface_hub import logging
-from huggingface_hub.commands import BaseHuggingfaceCLICommand
-from huggingface_hub.hf_api import HfApi
-from huggingface_hub.utils import disable_progress_bars
-
-from ._cli_utils import ANSI
-
-
-logger = logging.get_logger(__name__)
-
-
-class UploadLargeFolderCommand(BaseHuggingfaceCLICommand):
-    @staticmethod
-    def register_subcommand(parser: _SubParsersAction):
-        subparser = parser.add_parser("upload-large-folder", help="Upload a large folder to a repo on the Hub")
-        subparser.add_argument(
-            "repo_id", type=str, help="The ID of the repo to upload to (e.g. `username/repo-name`)."
-        )
-        subparser.add_argument("local_path", type=str, help="Local path to the file or folder to upload.")
-        subparser.add_argument(
-            "--repo-type",
-            choices=["model", "dataset", "space"],
-            help="Type of the repo to upload to (e.g. `dataset`).",
-        )
-        subparser.add_argument(
-            "--revision",
-            type=str,
-            help=("An optional Git revision to push to. It can be a branch name or a PR reference."),
-        )
-        subparser.add_argument(
-            "--private",
-            action="store_true",
-            help=(
-                "Whether to create a private repo if repo doesn't exist on the Hub. Ignored if the repo already exists."
-            ),
-        )
-        subparser.add_argument("--include", nargs="*", type=str, help="Glob patterns to match files to upload.")
-        subparser.add_argument("--exclude", nargs="*", type=str, help="Glob patterns to exclude from files to upload.")
-        subparser.add_argument(
-            "--token", type=str, help="A User Access Token generated from https://huggingface.co/settings/tokens"
-        )
-        subparser.add_argument(
-            "--num-workers", type=int, help="Number of workers to use to hash, upload and commit files."
-        )
-        subparser.add_argument("--no-report", action="store_true", help="Whether to disable regular status report.")
-        subparser.add_argument("--no-bars", action="store_true", help="Whether to disable progress bars.")
-        subparser.set_defaults(func=UploadLargeFolderCommand)
-
-    def __init__(self, args: Namespace) -> None:
-        self.repo_id: str = args.repo_id
-        self.local_path: str = args.local_path
-        self.repo_type: str = args.repo_type
-        self.revision: Optional[str] = args.revision
-        self.private: bool = args.private
-
-        self.include: Optional[List[str]] = args.include
-        self.exclude: Optional[List[str]] = args.exclude
-
-        self.api: HfApi = HfApi(token=args.token, library_name="huggingface-cli")
-
-        self.num_workers: Optional[int] = args.num_workers
-        self.no_report: bool = args.no_report
-        self.no_bars: bool = args.no_bars
-
-        if not os.path.isdir(self.local_path):
-            raise ValueError("Large upload is only supported for folders.")
-
-    def run(self) -> None:
-        logging.set_verbosity_info()
-
-        print(
-            ANSI.yellow(
-                "You are about to upload a large folder to the Hub using `huggingface-cli upload-large-folder`. "
-                "This is a new feature so feedback is very welcome!\n"
-                "\n"
-                "A few things to keep in mind:\n"
-                "  - Repository limits still apply: https://huggingface.co/docs/hub/repositories-recommendations\n"
-                "  - Do not start several processes in parallel.\n"
-                "  - You can interrupt and resume the process at any time. "
-                "The script will pick up where it left off except for partially uploaded files that would have to be entirely reuploaded.\n"
-                "  - Do not upload the same folder to several repositories. If you need to do so, you must delete the `./.cache/huggingface/` folder first.\n"
-                "\n"
-                f"Some temporary metadata will be stored under `{self.local_path}/.cache/huggingface`.\n"
-                "  - You must not modify those files manually.\n"
-                "  - You must not delete the `./.cache/huggingface/` folder while a process is running.\n"
-                "  - You can delete the `./.cache/huggingface/` folder to reinitialize the upload state when process is not running. Files will have to be hashed and preuploaded again, except for already committed files.\n"
-                "\n"
-                "If the process output is too verbose, you can disable the progress bars with `--no-bars`. "
-                "You can also entirely disable the status report with `--no-report`.\n"
-                "\n"
-                "For more details, run `huggingface-cli upload-large-folder --help` or check the documentation at "
-                "https://huggingface.co/docs/huggingface_hub/guides/upload#upload-a-large-folder."
-            )
-        )
-
-        if self.no_bars:
-            disable_progress_bars()
-
-        self.api.upload_large_folder(
-            repo_id=self.repo_id,
-            folder_path=self.local_path,
-            repo_type=self.repo_type,
-            revision=self.revision,
-            private=self.private,
-            allow_patterns=self.include,
-            ignore_patterns=self.exclude,
-            num_workers=self.num_workers,
-            print_report=not self.no_report,
-        )

huggingface_hub/commands/user.py

@@ -1,304 +0,0 @@
-# Copyright 2020 The HuggingFace Team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Contains commands to authenticate to the Hugging Face Hub and interact with your repositories.
-
-Usage:
-    # login and save token locally.
-    huggingface-cli login --token=hf_*** --add-to-git-credential
-
-    # switch between tokens
-    huggingface-cli auth switch
-
-    # list all tokens
-    huggingface-cli auth list
-
-    # logout from a specific token, if no token-name is provided, all tokens will be deleted from your machine.
-    huggingface-cli logout --token-name=your_token_name
-
-    # find out which huggingface.co account you are logged in as
-    huggingface-cli whoami
-
-    # create a new dataset repo on the Hub
-    huggingface-cli repo create mydataset --type=dataset
-
-"""
-
-import subprocess
-from argparse import _SubParsersAction
-from typing import List, Optional
-
-from requests.exceptions import HTTPError
-
-from huggingface_hub.commands import BaseHuggingfaceCLICommand
-from huggingface_hub.constants import ENDPOINT, REPO_TYPES, REPO_TYPES_URL_PREFIXES, SPACES_SDK_TYPES
-from huggingface_hub.hf_api import HfApi
-
-from .._login import (  # noqa: F401 # for backward compatibility  # noqa: F401 # for backward compatibility
-    NOTEBOOK_LOGIN_PASSWORD_HTML,
-    NOTEBOOK_LOGIN_TOKEN_HTML_END,
-    NOTEBOOK_LOGIN_TOKEN_HTML_START,
-    auth_list,
-    auth_switch,
-    login,
-    logout,
-    notebook_login,
-)
-from ..utils import get_stored_tokens, get_token, logging
-from ._cli_utils import ANSI
-
-
-logger = logging.get_logger(__name__)
-
-try:
-    from InquirerPy import inquirer
-    from InquirerPy.base.control import Choice
-
-    _inquirer_py_available = True
-except ImportError:
-    _inquirer_py_available = False
-
-
-class UserCommands(BaseHuggingfaceCLICommand):
-    @staticmethod
-    def register_subcommand(parser: _SubParsersAction):
-        login_parser = parser.add_parser("login", help="Log in using a token from huggingface.co/settings/tokens")
-        login_parser.add_argument(
-            "--token",
-            type=str,
-            help="Token generated from https://huggingface.co/settings/tokens",
-        )
-        login_parser.add_argument(
-            "--add-to-git-credential",
-            action="store_true",
-            help="Optional: Save token to git credential helper.",
-        )
-        login_parser.set_defaults(func=lambda args: LoginCommand(args))
-        whoami_parser = parser.add_parser("whoami", help="Find out which huggingface.co account you are logged in as.")
-        whoami_parser.set_defaults(func=lambda args: WhoamiCommand(args))
-
-        logout_parser = parser.add_parser("logout", help="Log out")
-        logout_parser.add_argument(
-            "--token-name",
-            type=str,
-            help="Optional: Name of the access token to log out from.",
-        )
-        logout_parser.set_defaults(func=lambda args: LogoutCommand(args))
-
-        auth_parser = parser.add_parser("auth", help="Other authentication related commands")
-        auth_subparsers = auth_parser.add_subparsers(help="Authentication subcommands")
-        auth_switch_parser = auth_subparsers.add_parser("switch", help="Switch between access tokens")
-        auth_switch_parser.add_argument(
-            "--token-name",
-            type=str,
-            help="Optional: Name of the access token to switch to.",
-        )
-        auth_switch_parser.add_argument(
-            "--add-to-git-credential",
-            action="store_true",
-            help="Optional: Save token to git credential helper.",
-        )
-        auth_switch_parser.set_defaults(func=lambda args: AuthSwitchCommand(args))
-        auth_list_parser = auth_subparsers.add_parser("list", help="List all stored access tokens")
-        auth_list_parser.set_defaults(func=lambda args: AuthListCommand(args))
-        # new system: git-based repo system
-        repo_parser = parser.add_parser("repo", help="{create} Commands to interact with your huggingface.co repos.")
-        repo_subparsers = repo_parser.add_subparsers(help="huggingface.co repos related commands")
-        repo_create_parser = repo_subparsers.add_parser("create", help="Create a new repo on huggingface.co")
-        repo_create_parser.add_argument(
-            "name",
-            type=str,
-            help="Name for your repo. Will be namespaced under your username to build the repo id.",
-        )
-        repo_create_parser.add_argument(
-            "--type",
-            type=str,
-            help='Optional: repo_type: set to "dataset" or "space" if creating a dataset or space, default is model.',
-        )
-        repo_create_parser.add_argument("--organization", type=str, help="Optional: organization namespace.")
-        repo_create_parser.add_argument(
-            "--space_sdk",
-            type=str,
-            help='Optional: Hugging Face Spaces SDK type. Required when --type is set to "space".',
-            choices=SPACES_SDK_TYPES,
-        )
-        repo_create_parser.add_argument(
-            "-y",
-            "--yes",
-            action="store_true",
-            help="Optional: answer Yes to the prompt",
-        )
-        repo_create_parser.set_defaults(func=lambda args: RepoCreateCommand(args))
-
-
-class BaseUserCommand:
-    def __init__(self, args):
-        self.args = args
-        self._api = HfApi()
-
-
-class LoginCommand(BaseUserCommand):
-    def run(self):
-        logging.set_verbosity_info()
-        login(
-            token=self.args.token,
-            add_to_git_credential=self.args.add_to_git_credential,
-        )
-
-
-class LogoutCommand(BaseUserCommand):
-    def run(self):
-        logging.set_verbosity_info()
-        logout(token_name=self.args.token_name)
-
-
-class AuthSwitchCommand(BaseUserCommand):
-    def run(self):
-        logging.set_verbosity_info()
-        token_name = self.args.token_name
-        if token_name is None:
-            token_name = self._select_token_name()
-
-        if token_name is None:
-            print("No token name provided. Aborting.")
-            exit()
-        auth_switch(token_name, add_to_git_credential=self.args.add_to_git_credential)
-
-    def _select_token_name(self) -> Optional[str]:
-        token_names = list(get_stored_tokens().keys())
-
-        if not token_names:
-            logger.error("No stored tokens found. Please login first.")
-            return None
-
-        if _inquirer_py_available:
-            return self._select_token_name_tui(token_names)
-        # if inquirer is not available, use a simpler terminal UI
-        print("Available stored tokens:")
-        for i, token_name in enumerate(token_names, 1):
-            print(f"{i}. {token_name}")
-        while True:
-            try:
-                choice = input("Enter the number of the token to switch to (or 'q' to quit): ")
-                if choice.lower() == "q":
-                    return None
-                index = int(choice) - 1
-                if 0 <= index < len(token_names):
-                    return token_names[index]
-                else:
-                    print("Invalid selection. Please try again.")
-            except ValueError:
-                print("Invalid input. Please enter a number or 'q' to quit.")
-
-    def _select_token_name_tui(self, token_names: List[str]) -> Optional[str]:
-        choices = [Choice(token_name, name=token_name) for token_name in token_names]
-        try:
-            return inquirer.select(
-                message="Select a token to switch to:",
-                choices=choices,
-                default=None,
-            ).execute()
-        except KeyboardInterrupt:
-            logger.info("Token selection cancelled.")
-            return None
-
-
-class AuthListCommand(BaseUserCommand):
-    def run(self):
-        logging.set_verbosity_info()
-        auth_list()
-
-
-class WhoamiCommand(BaseUserCommand):
-    def run(self):
-        token = get_token()
-        if token is None:
-            print("Not logged in")
-            exit()
-        try:
-            info = self._api.whoami(token)
-            print(info["name"])
-            orgs = [org["name"] for org in info["orgs"]]
-            if orgs:
-                print(ANSI.bold("orgs: "), ",".join(orgs))
-
-            if ENDPOINT != "https://huggingface.co":
-                print(f"Authenticated through private endpoint: {ENDPOINT}")
-        except HTTPError as e:
-            print(e)
-            print(ANSI.red(e.response.text))
-            exit(1)
-
-
-class RepoCreateCommand(BaseUserCommand):
-    def run(self):
-        token = get_token()
-        if token is None:
-            print("Not logged in")
-            exit(1)
-        try:
-            stdout = subprocess.check_output(["git", "--version"]).decode("utf-8")
-            print(ANSI.gray(stdout.strip()))
-        except FileNotFoundError:
-            print("Looks like you do not have git installed, please install.")
-
-        try:
-            stdout = subprocess.check_output(["git-lfs", "--version"]).decode("utf-8")
-            print(ANSI.gray(stdout.strip()))
-        except FileNotFoundError:
-            print(
-                ANSI.red(
-                    "Looks like you do not have git-lfs installed, please install."
-                    " You can install from https://git-lfs.github.com/."
-                    " Then run `git lfs install` (you only have to do this once)."
-                )
-            )
-        print("")
-
-        user = self._api.whoami(token)["name"]
-        namespace = self.args.organization if self.args.organization is not None else user
-
-        repo_id = f"{namespace}/{self.args.name}"
-
-        if self.args.type not in REPO_TYPES:
-            print("Invalid repo --type")
-            exit(1)
-
-        if self.args.type in REPO_TYPES_URL_PREFIXES:
-            prefixed_repo_id = REPO_TYPES_URL_PREFIXES[self.args.type] + repo_id
-        else:
-            prefixed_repo_id = repo_id
-
-        print(f"You are about to create {ANSI.bold(prefixed_repo_id)}")
-
-        if not self.args.yes:
-            choice = input("Proceed? [Y/n] ").lower()
-            if not (choice == "" or choice == "y" or choice == "yes"):
-                print("Abort")
-                exit()
-        try:
-            url = self._api.create_repo(
-                repo_id=repo_id,
-                token=token,
-                repo_type=self.args.type,
-                space_sdk=self.args.space_sdk,
-            )
-        except HTTPError as e:
-            print(e)
-            print(ANSI.red(e.response.text))
-            exit(1)
-        print("\nYour repo now lives at:")
-        print(f"  {ANSI.bold(url)}")
-        print("\nYou can clone it locally with the command below, and commit/push as usual.")
-        print(f"\n  git clone {url}")
-        print("")

huggingface_hub/commands/version.py

@@ -1,37 +0,0 @@
-# Copyright 2022 The HuggingFace Team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Contains command to print information about the version.
-
-Usage:
-    huggingface-cli version
-"""
-
-from argparse import _SubParsersAction
-
-from huggingface_hub import __version__
-
-from . import BaseHuggingfaceCLICommand
-
-
-class VersionCommand(BaseHuggingfaceCLICommand):
-    def __init__(self, args):
-        self.args = args
-
-    @staticmethod
-    def register_subcommand(parser: _SubParsersAction):
-        version_parser = parser.add_parser("version", help="Print information about the huggingface-cli version.")
-        version_parser.set_defaults(func=VersionCommand)
-
-    def run(self) -> None:
-        print(f"huggingface_hub version: {__version__}")

huggingface_hub/inference_api.py

@@ -1,217 +0,0 @@
-import io
-from typing import Any, Dict, List, Optional, Union
-
-from . import constants
-from .hf_api import HfApi
-from .utils import build_hf_headers, get_session, is_pillow_available, logging, validate_hf_hub_args
-from .utils._deprecation import _deprecate_method
-
-
-logger = logging.get_logger(__name__)
-
-
-ALL_TASKS = [
-    # NLP
-    "text-classification",
-    "token-classification",
-    "table-question-answering",
-    "question-answering",
-    "zero-shot-classification",
-    "translation",
-    "summarization",
-    "conversational",
-    "feature-extraction",
-    "text-generation",
-    "text2text-generation",
-    "fill-mask",
-    "sentence-similarity",
-    # Audio
-    "text-to-speech",
-    "automatic-speech-recognition",
-    "audio-to-audio",
-    "audio-classification",
-    "voice-activity-detection",
-    # Computer vision
-    "image-classification",
-    "object-detection",
-    "image-segmentation",
-    "text-to-image",
-    "image-to-image",
-    # Others
-    "tabular-classification",
-    "tabular-regression",
-]
-
-
-class InferenceApi:
-    """Client to configure requests and make calls to the HuggingFace Inference API.
-
-    Example:
-
-    ```python
-    >>> from huggingface_hub.inference_api import InferenceApi
-
-    >>> # Mask-fill example
-    >>> inference = InferenceApi("bert-base-uncased")
-    >>> inference(inputs="The goal of life is [MASK].")
-    [{'sequence': 'the goal of life is life.', 'score': 0.10933292657136917, 'token': 2166, 'token_str': 'life'}]
-
-    >>> # Question Answering example
-    >>> inference = InferenceApi("deepset/roberta-base-squad2")
-    >>> inputs = {
-    ...     "question": "What's my name?",
-    ...     "context": "My name is Clara and I live in Berkeley.",
-    ... }
-    >>> inference(inputs)
-    {'score': 0.9326569437980652, 'start': 11, 'end': 16, 'answer': 'Clara'}
-
-    >>> # Zero-shot example
-    >>> inference = InferenceApi("typeform/distilbert-base-uncased-mnli")
-    >>> inputs = "Hi, I recently bought a device from your company but it is not working as advertised and I would like to get reimbursed!"
-    >>> params = {"candidate_labels": ["refund", "legal", "faq"]}
-    >>> inference(inputs, params)
-    {'sequence': 'Hi, I recently bought a device from your company but it is not working as advertised and I would like to get reimbursed!', 'labels': ['refund', 'faq', 'legal'], 'scores': [0.9378499388694763, 0.04914155602455139, 0.013008488342165947]}
-
-    >>> # Overriding configured task
-    >>> inference = InferenceApi("bert-base-uncased", task="feature-extraction")
-
-    >>> # Text-to-image
-    >>> inference = InferenceApi("stabilityai/stable-diffusion-2-1")
-    >>> inference("cat")
-    <PIL.PngImagePlugin.PngImageFile image (...)>
-
-    >>> # Return as raw response to parse the output yourself
-    >>> inference = InferenceApi("mio/amadeus")
-    >>> response = inference("hello world", raw_response=True)
-    >>> response.headers
-    {"Content-Type": "audio/flac", ...}
-    >>> response.content # raw bytes from server
-    b'(...)'
-    ```
-    """
-
-    @validate_hf_hub_args
-    @_deprecate_method(
-        version="1.0",
-        message=(
-            "`InferenceApi` client is deprecated in favor of the more feature-complete `InferenceClient`. Check out"
-            " this guide to learn how to convert your script to use it:"
-            " https://huggingface.co/docs/huggingface_hub/guides/inference#legacy-inferenceapi-client."
-        ),
-    )
-    def __init__(
-        self,
-        repo_id: str,
-        task: Optional[str] = None,
-        token: Optional[str] = None,
-        gpu: bool = False,
-    ):
-        """Inits headers and API call information.
-
-        Args:
-            repo_id (``str``):
-                Id of repository (e.g. `user/bert-base-uncased`).
-            task (``str``, `optional`, defaults ``None``):
-                Whether to force a task instead of using task specified in the
-                repository.
-            token (`str`, `optional`):
-                The API token to use as HTTP bearer authorization. This is not
-                the authentication token. You can find the token in
-                https://huggingface.co/settings/token. Alternatively, you can
-                find both your organizations and personal API tokens using
-                `HfApi().whoami(token)`.
-            gpu (`bool`, `optional`, defaults `False`):
-                Whether to use GPU instead of CPU for inference(requires Startup
-                plan at least).
-        """
-        self.options = {"wait_for_model": True, "use_gpu": gpu}
-        self.headers = build_hf_headers(token=token)
-
-        # Configure task
-        model_info = HfApi(token=token).model_info(repo_id=repo_id)
-        if not model_info.pipeline_tag and not task:
-            raise ValueError(
-                "Task not specified in the repository. Please add it to the model card"
-                " using pipeline_tag"
-                " (https://huggingface.co/docs#how-is-a-models-type-of-inference-api-and-widget-determined)"
-            )
-
-        if task and task != model_info.pipeline_tag:
-            if task not in ALL_TASKS:
-                raise ValueError(f"Invalid task {task}. Make sure it's valid.")
-
-            logger.warning(
-                "You're using a different task than the one specified in the"
-                " repository. Be sure to know what you're doing :)"
-            )
-            self.task = task
-        else:
-            assert model_info.pipeline_tag is not None, "Pipeline tag cannot be None"
-            self.task = model_info.pipeline_tag
-
-        self.api_url = f"{constants.INFERENCE_ENDPOINT}/pipeline/{self.task}/{repo_id}"
-
-    def __repr__(self):
-        # Do not add headers to repr to avoid leaking token.
-        return f"InferenceAPI(api_url='{self.api_url}', task='{self.task}', options={self.options})"
-
-    def __call__(
-        self,
-        inputs: Optional[Union[str, Dict, List[str], List[List[str]]]] = None,
-        params: Optional[Dict] = None,
-        data: Optional[bytes] = None,
-        raw_response: bool = False,
-    ) -> Any:
-        """Make a call to the Inference API.
-
-        Args:
-            inputs (`str` or `Dict` or `List[str]` or `List[List[str]]`, *optional*):
-                Inputs for the prediction.
-            params (`Dict`, *optional*):
-                Additional parameters for the models. Will be sent as `parameters` in the
-                payload.
-            data (`bytes`, *optional*):
-                Bytes content of the request. In this case, leave `inputs` and `params` empty.
-            raw_response (`bool`, defaults to `False`):
-                If `True`, the raw `Response` object is returned. You can parse its content
-                as preferred. By default, the content is parsed into a more practical format
-                (json dictionary or PIL Image for example).
-        """
-        # Build payload
-        payload: Dict[str, Any] = {
-            "options": self.options,
-        }
-        if inputs:
-            payload["inputs"] = inputs
-        if params:
-            payload["parameters"] = params
-
-        # Make API call
-        response = get_session().post(self.api_url, headers=self.headers, json=payload, data=data)
-
-        # Let the user handle the response
-        if raw_response:
-            return response
-
-        # By default, parse the response for the user.
-        content_type = response.headers.get("Content-Type") or ""
-        if content_type.startswith("image"):
-            if not is_pillow_available():
-                raise ImportError(
-                    f"Task '{self.task}' returned as image but Pillow is not installed."
-                    " Please install it (`pip install Pillow`) or pass"
-                    " `raw_response=True` to get the raw `Response` object and parse"
-                    " the image by yourself."
-                )
-
-            from PIL import Image
-
-            return Image.open(io.BytesIO(response.content))
-        elif content_type == "application/json":
-            return response.json()
-        else:
-            raise NotImplementedError(
-                f"{content_type} output type is not implemented yet. You can pass"
-                " `raw_response=True` to get the raw `Response` object and parse the"
-                " output by yourself."
-            )