huggingface-hub 0.18.0rc0__py3-none-any.whl → 0.19.0__py3-none-any.whl

huggingface_hub/hf_file_system.py

@@ -4,13 +4,14 @@ import re
 import tempfile
 from dataclasses import dataclass
 from datetime import datetime
-from typing import Any, Dict, List, Optional, Tuple, Union
+from typing import Any, Dict, List, NoReturn, Optional, Tuple, Union
 from urllib.parse import quote, unquote
 
 import fsspec
 
 from ._commit_api import CommitOperationCopy, CommitOperationDelete
 from .constants import DEFAULT_REVISION, ENDPOINT, REPO_TYPE_MODEL, REPO_TYPES_MAPPING, REPO_TYPES_URL_PREFIXES
+from .file_download import hf_hub_url
 from .hf_api import HfApi
 from .utils import (
     EntryNotFoundError,
@@ -45,10 +46,8 @@ class HfFileSystemResolvedPath:
     path_in_repo: str
 
     def unresolve(self) -> str:
-        return (
-            f"{REPO_TYPES_URL_PREFIXES.get(self.repo_type, '') + self.repo_id}@{safe_revision(self.revision)}/{self.path_in_repo}"
-            .rstrip("/")
-        )
+        repo_path = REPO_TYPES_URL_PREFIXES.get(self.repo_type, "") + self.repo_id
+        return f"{repo_path}@{safe_revision(self.revision)}/{self.path_in_repo}".rstrip("/")
 
 
 class HfFileSystem(fsspec.AbstractFileSystem):
@@ -181,7 +180,7 @@ class HfFileSystem(fsspec.AbstractFileSystem):
                 revision = _align_revision_in_path_with_revision(revision_in_path, revision)
                 repo_and_revision_exist, err = self._repo_and_revision_exist(repo_type, repo_id, revision)
                 if not repo_and_revision_exist:
-                    raise FileNotFoundError(path) from err
+                    _raise_file_not_found(path, err)
             else:
                 repo_id_with_namespace = "/".join(path.split("/")[:2])
                 path_in_repo_with_namespace = "/".join(path.split("/")[2:])
@@ -196,9 +195,9 @@ class HfFileSystem(fsspec.AbstractFileSystem):
                         path_in_repo = path_in_repo_without_namespace
                         repo_and_revision_exist, _ = self._repo_and_revision_exist(repo_type, repo_id, revision)
                         if not repo_and_revision_exist:
-                            raise FileNotFoundError(path) from err
+                            _raise_file_not_found(path, err)
                     else:
-                        raise FileNotFoundError(path) from err
+                        _raise_file_not_found(path, err)
         else:
             repo_id = path
             path_in_repo = ""
@@ -230,7 +229,7 @@ class HfFileSystem(fsspec.AbstractFileSystem):
         revision: Optional[str] = None,
         **kwargs,
     ) -> "HfFileSystemFile":
-        if mode == "ab":
+        if "a" in mode:
             raise NotImplementedError("Appending to remote files is not yet supported.")
         return HfFileSystemFile(self, path, mode=mode, revision=revision, **kwargs)
 
@@ -392,20 +391,55 @@ class HfFileSystem(fsspec.AbstractFileSystem):
             return {"name": name, "size": 0, "type": "directory"}
         return super().info(path, **kwargs)
 
+    @property
+    def transaction(self):
+        """A context within which files are committed together upon exit
+
+        Requires the file class to implement `.commit()` and `.discard()`
+        for the normal and exception cases.
+        """
+        # Taken from https://github.com/fsspec/filesystem_spec/blob/3fbb6fee33b46cccb015607630843dea049d3243/fsspec/spec.py#L231
+        # See https://github.com/huggingface/huggingface_hub/issues/1733
+        raise NotImplementedError("Transactional commits are not supported.")
+
+    def start_transaction(self):
+        """Begin write transaction for deferring files, non-context version"""
+        # Taken from https://github.com/fsspec/filesystem_spec/blob/3fbb6fee33b46cccb015607630843dea049d3243/fsspec/spec.py#L241
+        # See https://github.com/huggingface/huggingface_hub/issues/1733
+        raise NotImplementedError("Transactional commits are not supported.")
+
 
 class HfFileSystemFile(fsspec.spec.AbstractBufferedFile):
     def __init__(self, fs: HfFileSystem, path: str, revision: Optional[str] = None, **kwargs):
         super().__init__(fs, path, **kwargs)
         self.fs: HfFileSystem
-        self.resolved_path = fs.resolve_path(path, revision=revision)
+
+        mode = kwargs.get("mode", "r")
+        try:
+            self.resolved_path = fs.resolve_path(path, revision=revision)
+        except FileNotFoundError as e:
+            if "w" in mode:
+                raise FileNotFoundError(
+                    f"{e}.\nMake sure the repository and revision exist before writing data."
+                ) from e
+
+    def __del__(self):
+        if not hasattr(self, "resolved_path"):
+            # Means that the constructor failed. Nothing to do.
+            return
+        return super().__del__()
 
     def _fetch_range(self, start: int, end: int) -> bytes:
         headers = {
             "range": f"bytes={start}-{end - 1}",
             **self.fs._api._build_hf_headers(),
         }
-        url = (
-            f"{self.fs.endpoint}/{REPO_TYPES_URL_PREFIXES.get(self.resolved_path.repo_type, '') + self.resolved_path.repo_id}/resolve/{safe_quote(self.resolved_path.revision)}/{safe_quote(self.resolved_path.path_in_repo)}"
+        url = hf_hub_url(
+            repo_id=self.resolved_path.repo_id,
+            revision=self.resolved_path.revision,
+            filename=self.resolved_path.path_in_repo,
+            repo_type=self.resolved_path.repo_type,
+            endpoint=self.fs.endpoint,
         )
         r = http_backoff("GET", url, headers=headers)
         hf_raise_for_status(r)
@@ -442,3 +476,14 @@ def safe_revision(revision: str) -> str:
 
 def safe_quote(s: str) -> str:
     return quote(s, safe="")
+
+
+def _raise_file_not_found(path: str, err: Optional[Exception]) -> NoReturn:
+    msg = path
+    if isinstance(err, RepositoryNotFoundError):
+        msg = f"{path} (repository not found)"
+    elif isinstance(err, RevisionNotFoundError):
+        msg = f"{path} (revision not found)"
+    elif isinstance(err, HFValidationError):
+        msg = f"{path} (invalid repository id)"
+    raise FileNotFoundError(msg) from err

huggingface_hub/hub_mixin.py

@@ -3,12 +3,10 @@ import os
 from pathlib import Path
 from typing import Dict, List, Optional, Type, TypeVar, Union
 
-import requests
-
 from .constants import CONFIG_NAME, PYTORCH_WEIGHTS_NAME
 from .file_download import hf_hub_download, is_torch_available
 from .hf_api import HfApi
-from .utils import SoftTemporaryDirectory, logging, validate_hf_hub_args
+from .utils import HfHubHTTPError, SoftTemporaryDirectory, logging, validate_hf_hub_args
 
 
 if is_torch_available():
@@ -148,8 +146,8 @@ class ModelHubMixin:
                     token=token,
                     local_files_only=local_files_only,
                 )
-            except requests.exceptions.RequestException:
-                logger.warning(f"{CONFIG_NAME} not found in HuggingFace Hub.")
+            except HfHubHTTPError:
+                logger.info(f"{CONFIG_NAME} not found in HuggingFace Hub.")
 
         if config_file is not None:
             with open(config_file, "r", encoding="utf-8") as f:

huggingface_hub/inference/_client.py

@@ -63,7 +63,7 @@ from huggingface_hub.inference._common import (
     _bytes_to_dict,
     _bytes_to_image,
     _bytes_to_list,
-    _get_recommended_model,
+    _fetch_recommended_models,
     _import_numpy,
     _is_tgi_server,
     _open_as_binary,
@@ -146,7 +146,7 @@ class InferenceClient:
         return f"<InferenceClient(model='{self.model if self.model else ''}', timeout={self.timeout})>"
 
     @overload
-    def post(  # type: ignore
+    def post(  # type: ignore[misc]
         self,
         *,
         json: Optional[Union[str, Dict, List]] = None,
@@ -158,7 +158,7 @@ class InferenceClient:
         pass
 
     @overload
-    def post(  # type: ignore
+    def post(
         self,
         *,
         json: Optional[Union[str, Dict, List]] = None,
@@ -183,16 +183,18 @@ class InferenceClient:
 
         Args:
             json (`Union[str, Dict, List]`, *optional*):
-                The JSON data to send in the request body. Defaults to None.
+                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. 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,
+                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. Used only to default to a recommended model if `model` is not
+                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.
@@ -238,6 +240,10 @@ class InferenceClient:
                 hf_raise_for_status(response)
                 return response.iter_lines() if stream else response.content
             except HTTPError as error:
+                if error.response.status_code == 422 and task is not None:
+                    error.args = (
+                        f"{error.args[0]}\nMake sure '{task}' task is supported by the model.",
+                    ) + error.args[1:]
                 if error.response.status_code == 503:
                     # If Model is unavailable, either raise a TimeoutError...
                     if timeout is not None and time.time() - t0 > timeout:
@@ -1864,7 +1870,12 @@ class InferenceClient:
                     "You must specify at least a model (repo_id or URL) or a task, either when instantiating"
                     " `InferenceClient` or when making a request."
                 )
-            model = _get_recommended_model(task)
+            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"
+                " models list might get updated without prior notice."
+            )
 
         # Compute InferenceAPI url
         return (
@@ -1875,6 +1886,30 @@ class InferenceClient:
             else f"{INFERENCE_ENDPOINT}/models/{model}"
         )
 
+    @staticmethod
+    def get_recommended_model(task: str) -> str:
+        """
+        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.
+        """
+        model = _fetch_recommended_models().get(task)
+        if model 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
+
     def get_model_status(self, model: Optional[str] = None) -> ModelStatus:
         """
         Get the status of a model hosted on the Inference API.

huggingface_hub/inference/_common.py

@@ -75,9 +75,15 @@ class ModelStatus:
 
     Args:
         loaded (`bool`):
-            If the model is currently loaded.
+            If the model is currently loaded into Hugging Face's InferenceAPI. Models
+            are loaded on-demand, leading to the user's first request taking longer.
+            If a model is loaded, you can be assured that it is in a healthy state.
         state (`str`):
-            The current state of the model. This can be 'Loaded', 'Loadable', 'TooBig'
+            The current state of the model. This can be 'Loaded', 'Loadable', 'TooBig'.
+            If a model's state is 'Loadable', it's not too big and has a supported
+            backend. Loadable models are automatically loaded when the user first
+            requests inference on the endpoint. This means it is transparent for the
+            user to load a model, except that the first call takes longer to complete.
         compute_type (`str`):
             The type of compute resource the model is using or will use, such as 'gpu' or 'cpu'.
         framework (`str`):
@@ -134,20 +140,6 @@ def _import_pil_image():
 _RECOMMENDED_MODELS: Optional[Dict[str, Optional[str]]] = None
 
 
-def _get_recommended_model(task: str) -> str:
-    model = _fetch_recommended_models().get(task)
-    if model is None:
-        raise ValueError(
-            f"Task {task} has no recommended task. Please specify a model explicitly. Visit"
-            " https://huggingface.co/tasks for more info."
-        )
-    logger.info(
-        f"Using recommended model {model} for task {task}. Note that it is encouraged to explicitly set"
-        f" `model='{model}'` as the recommended models list might get updated without prior notice."
-    )
-    return model
-
-
 def _fetch_recommended_models() -> Dict[str, Optional[str]]:
     global _RECOMMENDED_MODELS
     if _RECOMMENDED_MODELS is None:

huggingface_hub/inference/_generated/_async_client.py

@@ -49,7 +49,7 @@ from huggingface_hub.inference._common import (
     _bytes_to_dict,
     _bytes_to_image,
     _bytes_to_list,
-    _get_recommended_model,
+    _fetch_recommended_models,
     _import_numpy,
     _is_tgi_server,
     _open_as_binary,
@@ -130,7 +130,7 @@ class AsyncInferenceClient:
         return f"<InferenceClient(model='{self.model if self.model else ''}', timeout={self.timeout})>"
 
     @overload
-    async def post(  # type: ignore
+    async def post(  # type: ignore[misc]
         self,
         *,
         json: Optional[Union[str, Dict, List]] = None,
@@ -142,7 +142,7 @@ class AsyncInferenceClient:
         pass
 
     @overload
-    async def post(  # type: ignore
+    async def post(
         self,
         *,
         json: Optional[Union[str, Dict, List]] = None,
@@ -167,16 +167,18 @@ class AsyncInferenceClient:
 
         Args:
             json (`Union[str, Dict, List]`, *optional*):
-                The JSON data to send in the request body. Defaults to None.
+                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. 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,
+                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. Used only to default to a recommended model if `model` is not
+                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.
@@ -235,6 +237,8 @@ class AsyncInferenceClient:
                 except aiohttp.ClientResponseError as error:
                     error.response_error_payload = response_error_payload
                     await client.close()
+                    if response.status == 422 and task is not None:
+                        error.message += f". Make sure '{task}' task is supported by the model."
                     if response.status == 503:
                         # If Model is unavailable, either raise a TimeoutError...
                         if timeout is not None and time.time() - t0 > timeout:
@@ -1894,7 +1898,12 @@ class AsyncInferenceClient:
                     "You must specify at least a model (repo_id or URL) or a task, either when instantiating"
                     " `InferenceClient` or when making a request."
                 )
-            model = _get_recommended_model(task)
+            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"
+                " models list might get updated without prior notice."
+            )
 
         # Compute InferenceAPI url
         return (
@@ -1905,6 +1914,30 @@ class AsyncInferenceClient:
             else f"{INFERENCE_ENDPOINT}/models/{model}"
         )
 
+    @staticmethod
+    def get_recommended_model(task: str) -> str:
+        """
+        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.
+        """
+        model = _fetch_recommended_models().get(task)
+        if model 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
+
     async def get_model_status(self, model: Optional[str] = None) -> ModelStatus:
         """
         Get the status of a model hosted on the Inference API.

huggingface_hub/inference/_text_generation.py

@@ -214,6 +214,12 @@ class TextGenerationRequest:
             raise ValueError("`best_of` != 1 is not supported when `stream` == True")
         return field_value
 
+    def __post_init__(self):
+        if not is_pydantic_available():
+            # If pydantic is not installed, we need to instantiate the nested dataclasses manually
+            if self.parameters is not None and isinstance(self.parameters, dict):
+                self.parameters = TextGenerationParameters(**self.parameters)
+
 
 # Decoder input tokens
 @dataclass
@@ -312,6 +318,15 @@ class BestOfSequence:
     # Generated tokens
     tokens: List[Token] = field(default_factory=lambda: [])
 
+    def __post_init__(self):
+        if not is_pydantic_available():
+            # If pydantic is not installed, we need to instantiate the nested dataclasses manually
+            self.prefill = [
+                InputToken(**input_token) if isinstance(input_token, dict) else input_token
+                for input_token in self.prefill
+            ]
+            self.tokens = [Token(**token) if isinstance(token, dict) else token for token in self.tokens]
+
 
 # `generate` details
 @dataclass
@@ -347,6 +362,20 @@ class Details:
     # Additional sequences when using the `best_of` parameter
     best_of_sequences: Optional[List[BestOfSequence]] = None
 
+    def __post_init__(self):
+        if not is_pydantic_available():
+            # If pydantic is not installed, we need to instantiate the nested dataclasses manually
+            self.prefill = [
+                InputToken(**input_token) if isinstance(input_token, dict) else input_token
+                for input_token in self.prefill
+            ]
+            self.tokens = [Token(**token) if isinstance(token, dict) else token for token in self.tokens]
+            if self.best_of_sequences is not None:
+                self.best_of_sequences = [
+                    BestOfSequence(**best_of_sequence) if isinstance(best_of_sequence, dict) else best_of_sequence
+                    for best_of_sequence in self.best_of_sequences
+                ]
+
 
 # `generate` return value
 @dataclass
@@ -368,6 +397,12 @@ class TextGenerationResponse:
     # Generation details
     details: Optional[Details] = None
 
+    def __post_init__(self):
+        if not is_pydantic_available():
+            # If pydantic is not installed, we need to instantiate the nested dataclasses manually
+            if self.details is not None and isinstance(self.details, dict):
+                self.details = Details(**self.details)
+
 
 # `generate_stream` details
 @dataclass
@@ -418,6 +453,14 @@ class TextGenerationStreamResponse:
     # Only available when the generation is finished
     details: Optional[StreamDetails] = None
 
+    def __post_init__(self):
+        if not is_pydantic_available():
+            # If pydantic is not installed, we need to instantiate the nested dataclasses manually
+            if isinstance(self.token, dict):
+                self.token = Token(**self.token)
+            if self.details is not None and isinstance(self.details, dict):
+                self.details = StreamDetails(**self.details)
+
 
 # TEXT GENERATION ERRORS
 # ----------------------

huggingface_hub/inference_api.py

@@ -92,7 +92,7 @@ class InferenceApi:
 
     @validate_hf_hub_args
     @_deprecate_method(
-        version="0.19.0",
+        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:"

huggingface_hub/lfs.py

@@ -13,6 +13,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 """Git LFS related type definitions and utilities"""
+import inspect
 import io
 import os
 import re
@@ -29,7 +30,7 @@ from requests.auth import HTTPBasicAuth
 from huggingface_hub.constants import ENDPOINT, HF_HUB_ENABLE_HF_TRANSFER, REPO_TYPES_URL_PREFIXES
 from huggingface_hub.utils import get_session
 
-from .utils import get_token_to_send, hf_raise_for_status, http_backoff, logging, validate_hf_hub_args
+from .utils import get_token_to_send, hf_raise_for_status, http_backoff, logging, tqdm, validate_hf_hub_args
 from .utils.sha import sha256, sha_fileobj
 
 
@@ -389,20 +390,37 @@ def _upload_parts_hf_transfer(
             " not available in your environment. Try `pip install hf_transfer`."
         )
 
-    try:
-        return multipart_upload(
-            file_path=operation.path_or_fileobj,
-            parts_urls=sorted_parts_urls,
-            chunk_size=chunk_size,
-            max_files=128,
-            parallel_failures=127,  # could be removed
-            max_retries=5,
+    supports_callback = "callback" in inspect.signature(multipart_upload).parameters
+    if not supports_callback:
+        warnings.warn(
+            "You are using an outdated version of `hf_transfer`. Consider upgrading to latest version to enable progress bars using `pip install -U hf_transfer`."
         )
-    except Exception as e:
-        raise RuntimeError(
-            "An error occurred while uploading using `hf_transfer`. Consider disabling HF_HUB_ENABLE_HF_TRANSFER for"
-            " better error handling."
-        ) from e
+
+    total = operation.upload_info.size
+    desc = operation.path_in_repo
+    if len(desc) > 40:
+        desc = f"(…){desc[-40:]}"
+    disable = bool(logger.getEffectiveLevel() == logging.NOTSET)
+
+    with tqdm(unit="B", unit_scale=True, total=total, initial=0, desc=desc, disable=disable) as progress:
+        try:
+            output = multipart_upload(
+                file_path=operation.path_or_fileobj,
+                parts_urls=sorted_parts_urls,
+                chunk_size=chunk_size,
+                max_files=128,
+                parallel_failures=127,  # could be removed
+                max_retries=5,
+                **({"callback": progress.update} if supports_callback else {}),
+            )
+        except Exception as e:
+            raise RuntimeError(
+                "An error occurred while uploading using `hf_transfer`. Consider disabling HF_HUB_ENABLE_HF_TRANSFER for"
+                " better error handling."
+            ) from e
+        if not supports_callback:
+            progress.update(total)
+        return output
 
 
 class SliceFileObj(AbstractContextManager):

huggingface_hub/repocard_data.py

@@ -194,6 +194,9 @@ class CardData:
         return yaml_dump(self.to_dict(), sort_keys=False, line_break=line_break).strip()
 
     def __repr__(self):
+        return repr(self.__dict__)
+
+    def __str__(self):
         return self.to_yaml()
 
     def get(self, key: str, default: Any = None) -> Any:
@@ -216,6 +219,10 @@ class CardData:
         """Check if a given metadata key is set."""
         return key in self.__dict__
 
+    def __len__(self) -> int:
+        """Return the number of metadata keys set."""
+        return len(self.__dict__)
+
 
 class ModelCardData(CardData):
     """Model Card Metadata that is used by Hugging Face Hub when included at the top of your README.md

huggingface_hub/repository.py

@@ -22,6 +22,7 @@ from .utils import (
     tqdm,
     validate_hf_hub_args,
 )
+from .utils._deprecation import _deprecate_method
 
 
 logger = logging.get_logger(__name__)
@@ -421,6 +422,14 @@ def _lfs_log_progress():
             os.environ["GIT_LFS_PROGRESS"] = current_lfs_progress_value
 
 
+@_deprecate_method(
+    version="1.0",
+    message=(
+        "Please prefer the http-based alternatives instead. Given its large adoption in legacy code, the complete"
+        " removal is only planned on next major release.\nFor more details, please read"
+        " https://huggingface.co/docs/huggingface_hub/concepts/git_vs_http."
+    ),
+)
 class Repository:
     """
     Helper class to wrap the git and git-lfs commands.
@@ -428,6 +437,15 @@ class Repository:
     The aim is to facilitate interacting with huggingface.co hosted model or
     dataset repos, though not a lot here (if any) is actually specific to
     huggingface.co.
+
+    <Tip warning={true}>
+
+    [`Repository`] is deprecated in favor of the http-based alternatives implemented in
+    [`HfApi`]. Given its large adoption in legacy code, the complete removal of
+    [`Repository`] will only happen in release `v1.0`. For more details, please read
+    https://huggingface.co/docs/huggingface_hub/concepts/git_vs_http.
+
+    </Tip>
     """
 
     command_queue: List[CommandInProgress]
@@ -1367,9 +1385,7 @@ class Repository:
         files_to_stage = files_to_be_staged(".", folder=self.local_dir)
 
         if len(files_to_stage):
-            if len(files_to_stage) > 5:
-                files_in_msg = str(files_to_stage[:5])[:-1] + ", ...]"
-
+            files_in_msg = str(files_to_stage[:5])[:-1] + ", ...]" if len(files_to_stage) > 5 else str(files_to_stage)
             logger.error(
                 "There exists some updated files in the local repository that are not"
                 f" committed: {files_in_msg}. This may lead to errors if checking out"