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

huggingface_hub/hf_api.py

@@ -16,9 +16,7 @@ from __future__ import annotations
 
 import inspect
 import json
-import pprint
 import re
-import textwrap
 import warnings
 from concurrent.futures import Future, ThreadPoolExecutor
 from dataclasses import dataclass, field
@@ -69,6 +67,7 @@ from ._commit_api import (
     _upload_lfs_files,
     _warn_on_overwriting_operations,
 )
+from ._inference_endpoints import InferenceEndpoint, InferenceEndpointType
 from ._multi_commits import (
     MULTI_COMMIT_PR_CLOSE_COMMENT_FAILURE_BAD_REQUEST_TEMPLATE,
     MULTI_COMMIT_PR_CLOSE_COMMENT_FAILURE_NO_CHANGES_TEMPLATE,
@@ -92,8 +91,10 @@ from .community import (
     deserialize_event,
 )
 from .constants import (
+    DEFAULT_ETAG_TIMEOUT,
     DEFAULT_REVISION,
     ENDPOINT,
+    INFERENCE_ENDPOINTS_ENDPOINT,
     REGEX_COMMIT_OID,
     REPO_TYPE_MODEL,
     REPO_TYPES,
@@ -105,6 +106,7 @@ from .file_download import (
     get_hf_file_metadata,
     hf_hub_url,
 )
+from .repocard_data import DatasetCardData, ModelCardData, SpaceCardData
 from .utils import (  # noqa: F401 # imported for backward compatibility
     BadRequestError,
     HfFolder,
@@ -122,12 +124,9 @@ from .utils._deprecation import (
 )
 from .utils._typing import CallableT
 from .utils.endpoint_helpers import (
-    AttributeDictionary,
     DatasetFilter,
-    DatasetTags,
     ModelFilter,
-    ModelTags,
-    _filter_emissions,
+    _is_emission_within_treshold,
 )
 
 
@@ -145,24 +144,6 @@ _CREATE_COMMIT_NO_REPO_ERROR_MESSAGE = (
 logger = logging.get_logger(__name__)
 
 
-class ReprMixin:
-    """Mixin to create the __repr__ for a class"""
-
-    def __init__(self, **kwargs) -> None:
-        # Store all the other fields returned by the API
-        # Hack to ensure backward compatibility with future versions of the API.
-        # See discussion in https://github.com/huggingface/huggingface_hub/pull/951#discussion_r926460408
-        for k, v in kwargs.items():
-            setattr(self, k, v)
-
-    def __repr__(self):
-        formatted_value = pprint.pformat(self.__dict__, width=119, compact=True)
-        if "\n" in formatted_value:
-            return f"{self.__class__.__name__}: {{ \n{textwrap.indent(formatted_value, '  ')}\n}}"
-        else:
-            return f"{self.__class__.__name__}: {formatted_value}"
-
-
 def repo_type_and_id_from_hf_id(hf_id: str, hub_url: Optional[str] = None) -> Tuple[Optional[str], Optional[str], str]:
     """
     Returns the repo type and ID from a huggingface.co URL linking to a
@@ -254,13 +235,38 @@ class BlobLfsInfo(TypedDict, total=False):
     pointer_size: int
 
 
+class BlobLastCommitInfo(TypedDict, total=False):
+    oid: str
+    title: str
+    date: datetime
+
+
+class BlobSecurityInfo(TypedDict, total=False):
+    safe: bool
+    av_scan: Optional[Dict]
+    pickle_import_scan: Optional[Dict]
+
+
+class TransformersInfo(TypedDict, total=False):
+    auto_model: str
+    custom_class: Optional[str]
+    # possible `pipeline_tag` values: https://github.com/huggingface/hub-docs/blob/f2003d2fca9d4c971629e858e314e0a5c05abf9d/js/src/lib/interfaces/Types.ts#L79
+    pipeline_tag: Optional[str]
+    processor: Optional[str]
+
+
+class SafeTensorsInfo(TypedDict, total=False):
+    parameters: List[Dict[str, int]]
+    total: int
+
+
 @dataclass
 class CommitInfo:
     """Data structure containing information about a newly created commit.
 
     Returned by [`create_commit`].
 
-    Args:
+    Attributes:
         commit_url (`str`):
             Url where to find the commit.
 
@@ -370,251 +376,431 @@ class RepoUrl(str):
         return f"RepoUrl('{self}', endpoint='{self.endpoint}', repo_type='{self.repo_type}', repo_id='{self.repo_id}')"
 
 
-class RepoFile(ReprMixin):
+@dataclass
+class RepoSibling:
     """
-    Data structure that represents a public file inside a repo, accessible from huggingface.co
+    Contains basic information about a repo file inside a repo on the Hub.
 
-    Args:
+    Attributes:
         rfilename (str):
-            file name, relative to the repo root. This is the only attribute that's guaranteed to be here, but under
-            certain conditions there can certain other stuff.
+            file name, relative to the repo root.
         size (`int`, *optional*):
-            The file's size, in bytes. This attribute is present when `files_metadata` argument of [`repo_info`] is set
+            The file's size, in bytes. This attribute is defined when `files_metadata` argument of [`repo_info`] is set
             to `True`. It's `None` otherwise.
         blob_id (`str`, *optional*):
-            The file's git OID. This attribute is present when `files_metadata` argument of [`repo_info`] is set to
+            The file's git OID. This attribute is defined when `files_metadata` argument of [`repo_info`] is set to
             `True`. It's `None` otherwise.
         lfs (`BlobLfsInfo`, *optional*):
-            The file's LFS metadata. This attribute is present when`files_metadata` argument of [`repo_info`] is set to
+            The file's LFS metadata. This attribute is defined when`files_metadata` argument of [`repo_info`] is set to
             `True` and the file is stored with Git LFS. It's `None` otherwise.
     """
 
-    def __init__(
-        self,
-        rfilename: str,
-        size: Optional[int] = None,
-        blobId: Optional[str] = None,
-        lfs: Optional[BlobLfsInfo] = None,
-        **kwargs,
-    ):
-        self.rfilename = rfilename  # filename relative to the repo root
+    rfilename: str
+    size: Optional[int] = None
+    blob_id: Optional[str] = None
+    lfs: Optional[BlobLfsInfo] = None
 
-        # Optional file metadata
-        self.size = size
-        self.blob_id = blobId
-        self.lfs = lfs
 
-        # Store all the other fields returned by the API
-        super().__init__(**kwargs)
+@dataclass
+class RepoFile:
+    """
+    Contains information about a model on the Hub.
+
+    Attributes:
+        path (str):
+            file path relative to the repo root.
+        size (`int`):
+            The file's size, in bytes.
+        blob_id (`str`):
+            The file's git OID.
+        lfs (`BlobLfsInfo`):
+            The file's LFS metadata.
+        last_commit (`BlobLastCommitInfo`, *optional*):
+            The file's last commit metadata. Only defined if [`list_files_info`] is called with `expand=True`
+        security (`BlobSecurityInfo`, *optional*):
+            The file's security scan metadata. Only defined if [`list_files_info`] is called with `expand=True`.
+    """
+
+    path: str
+    size: int
+    blob_id: str
+    lfs: Optional[BlobLfsInfo] = None
+    last_commit: Optional[BlobLastCommitInfo] = None
+    security: Optional[BlobSecurityInfo] = None
+
+    def __post_init__(self):
+        # backwards compatibility
+        self.rfilename = self.path
+        self.lastCommit = self.last_commit
 
 
-class ModelInfo(ReprMixin):
+@dataclass
+class ModelInfo:
     """
-    Info about a model accessible from huggingface.co
+    Contains information about a model on the Hub.
 
     Attributes:
-        modelId (`str`, *optional*):
-            ID of model repository.
+        id (`str`):
+            ID of dataset.
+        author (`str`, *optional*):
+            Author of the dataset.
         sha (`str`, *optional*):
-            repo sha at this particular revision
-        lastModified (`str`, *optional*):
-            date of last commit to repo
-        tags (`List[str]`, *optional*):
-            List of tags.
+            Repo SHA at this particular revision.
+        last_modified (`datetime`, *optional*):
+            Date of last commit to the repo.
+        private (`bool`):
+            Is the repo private.
+        disabled (`bool`, *optional*):
+            Is the repo disabled.
+        gated (`bool`, *optional*):
+            Is the repo gated.
+        downloads (`int`):
+            Number of downloads of the dataset.
+        likes (`int`):
+            Number of likes of the dataset.
+        library_name (`str`, *optional*):
+            Library associated with the model.
+        tags (`List[str]`):
+            List of tags of the model. Compared to `card_data.tags`, contains extra tags computed by the Hub
+            (e.g. supported libraries, model's arXiv).
         pipeline_tag (`str`, *optional*):
-            Pipeline tag to identify the correct widget.
-        siblings (`List[RepoFile]`, *optional*):
-            list of ([`huggingface_hub.hf_api.RepoFile`]) objects that constitute the model.
-        private (`bool`, *optional*, defaults to `False`):
-            is the repo private
-        author (`str`, *optional*):
-            repo author
+            Pipeline tag associated with the model.
+        mask_token (`str`, *optional*):
+            Mask token used by the model.
+        widget_data (`Any`, *optional*):
+            Widget data associated with the model.
+        model_index (`Dict`, *optional*):
+            Model index for evaluation.
         config (`Dict`, *optional*):
-            Model configuration information
-        securityStatus (`Dict`, *optional*):
-            Security status of the model.
-            Example: `{"containsInfected": False}`
-        kwargs (`Dict`, *optional*):
-            Kwargs that will be become attributes of the class.
+            Model configuration.
+        transformers_info (`TransformersInfo`, *optional*):
+            Transformers-specific info (auto class, processor, etc.) associated with the model.
+        card_data (`ModelCardData`, *optional*):
+            Model Card Metadata  as a [`huggingface_hub.repocard_data.ModelCardData`] object.
+        siblings (`List[RepoSibling]`):
+            List of [`huggingface_hub.hf_api.RepoSibling`] objects that constitute the model.
+        spaces (`List[str]`, *optional*):
+            List of spaces using the model.
+        safetensors (`SafeTensorsInfo`, *optional*):
+            Model's safetensors information.
     """
 
-    def __init__(
-        self,
-        *,
-        modelId: Optional[str] = None,
-        sha: Optional[str] = None,
-        lastModified: Optional[str] = None,
-        tags: Optional[List[str]] = None,
-        pipeline_tag: Optional[str] = None,
-        siblings: Optional[List[Dict]] = None,
-        private: bool = False,
-        author: Optional[str] = None,
-        config: Optional[Dict] = None,
-        securityStatus: Optional[Dict] = None,
-        **kwargs,
-    ):
-        self.modelId = modelId
-        self.sha = sha
-        self.lastModified = lastModified
-        self.tags = tags
-        self.pipeline_tag = pipeline_tag
-        self.siblings = [RepoFile(**x) for x in siblings] if siblings is not None else []
-        self.private = private
-        self.author = author
-        self.config = config
-        self.securityStatus = securityStatus
-
-        # Store all the other fields returned by the API
-        super().__init__(**kwargs)
-
-    def __str__(self):
-        r = f"Model Name: {self.modelId}, Tags: {self.tags}"
-        if self.pipeline_tag:
-            r += f", Task: {self.pipeline_tag}"
-        return r
-
-
-class DatasetInfo(ReprMixin):
+    id: str
+    author: Optional[str]
+    sha: Optional[str]
+    last_modified: Optional[datetime]
+    private: bool
+    gated: Optional[bool]
+    disabled: Optional[bool]
+    downloads: int
+    likes: int
+    library_name: Optional[str]
+    tags: List[str]
+    pipeline_tag: Optional[str]
+    mask_token: Optional[str]
+    card_data: Optional[ModelCardData]
+    widget_data: Optional[Any]
+    model_index: Optional[Dict]
+    config: Optional[Dict]
+    transformers_info: Optional[TransformersInfo]
+    siblings: Optional[List[RepoSibling]]
+    spaces: Optional[List[str]]
+    safetensors: Optional[SafeTensorsInfo]
+
+    def __init__(self, **kwargs):
+        self.id = kwargs.pop("id")
+        self.author = kwargs.pop("author", None)
+        self.sha = kwargs.pop("sha", None)
+        last_modified = kwargs.pop("lastModified", None) or kwargs.pop("last_modified", None)
+        self.last_modified = parse_datetime(last_modified) if last_modified else None
+        self.private = kwargs.pop("private")
+        self.gated = kwargs.pop("gated", None)
+        self.disabled = kwargs.pop("disabled", None)
+        self.downloads = kwargs.pop("downloads")
+        self.likes = kwargs.pop("likes")
+        self.library_name = kwargs.pop("library_name", None)
+        self.tags = kwargs.pop("tags")
+        self.pipeline_tag = kwargs.pop("pipeline_tag", None)
+        self.mask_token = kwargs.pop("mask_token", None)
+        card_data = kwargs.pop("cardData", None) or kwargs.pop("card_data", None)
+        self.card_data = (
+            ModelCardData(**card_data, ignore_metadata_errors=True) if isinstance(card_data, dict) else card_data
+        )
+
+        self.widget_data = kwargs.pop("widget_data", None)
+        self.model_index = kwargs.pop("model-index", None) or kwargs.pop("model_index", None)
+        self.config = kwargs.pop("config", None)
+        transformers_info = kwargs.pop("transformersInfo", None) or kwargs.pop("transformers_info", None)
+        self.transformers_info = TransformersInfo(**transformers_info) if transformers_info else None
+        siblings = kwargs.pop("siblings", None)
+        self.siblings = (
+            [
+                RepoSibling(
+                    rfilename=sibling["rfilename"],
+                    size=sibling.get("size"),
+                    blob_id=sibling.get("blobId"),
+                    lfs=(
+                        BlobLfsInfo(
+                            size=sibling["lfs"]["size"],
+                            sha256=sibling["lfs"]["sha256"],
+                            pointer_size=sibling["lfs"]["pointerSize"],
+                        )
+                        if sibling.get("lfs")
+                        else None
+                    ),
+                )
+                for sibling in siblings
+            ]
+            if siblings
+            else None
+        )
+        self.spaces = kwargs.pop("spaces", None)
+        safetensors = kwargs.pop("safetensors", None)
+        self.safetensors = SafeTensorsInfo(**safetensors) if safetensors else None
+
+        # backwards compatibility
+        self.lastModified = self.last_modified
+        self.cardData = self.card_data
+        self.transformersInfo = self.transformers_info
+        self.__dict__.update(**kwargs)
+
+
+@dataclass
+class DatasetInfo:
     """
-    Info about a dataset accessible from huggingface.co
+    Contains information about a dataset on the Hub.
 
     Attributes:
-        id (`str`, *optional*):
-            ID of dataset repository.
-        sha (`str`, *optional*):
-            repo sha at this particular revision
-        lastModified (`str`, *optional*):
-            date of last commit to repo
-        tags (`List[str]`, *optional*):
-            List of tags.
-        siblings (`List[RepoFile]`, *optional*):
-            list of [`huggingface_hub.hf_api.RepoFile`] objects that constitute the dataset.
-        private (`bool`, *optional*, defaults to `False`):
-            is the repo private
-        author (`str`, *optional*):
-            repo author
-        description (`str`, *optional*):
-            Description of the dataset
-        citation (`str`, *optional*):
-            Dataset citation
-        cardData (`Dict`, *optional*):
-            Metadata of the model card as a dictionary.
-        kwargs (`Dict`, *optional*):
-            Kwargs that will be become attributes of the class.
+        id (`str`):
+            ID of dataset.
+        author (`str`):
+            Author of the dataset.
+        sha (`str`):
+            Repo SHA at this particular revision.
+        last_modified (`datetime`, *optional*):
+            Date of last commit to the repo.
+        private (`bool`):
+            Is the repo private.
+        disabled (`bool`, *optional*):
+            Is the repo disabled.
+        gated (`bool`, *optional*):
+            Is the repo gated.
+        downloads (`int`):
+            Number of downloads of the dataset.
+        likes (`int`):
+            Number of likes of the dataset.
+        tags (`List[str]`):
+            List of tags of the dataset.
+        card_data (`DatasetCardData`, *optional*):
+            Model Card Metadata  as a [`huggingface_hub.repocard_data.DatasetCardData`] object.
+        siblings (`List[RepoSibling]`):
+            List of [`huggingface_hub.hf_api.RepoSibling`] objects that constitute the dataset.
     """
 
-    def __init__(
-        self,
-        *,
-        id: Optional[str] = None,
-        sha: Optional[str] = None,
-        lastModified: Optional[str] = None,
-        tags: Optional[List[str]] = None,
-        siblings: Optional[List[Dict]] = None,
-        private: bool = False,
-        author: Optional[str] = None,
-        description: Optional[str] = None,
-        citation: Optional[str] = None,
-        cardData: Optional[dict] = None,
-        **kwargs,
-    ):
-        self.id = id
-        self.sha = sha
-        self.lastModified = lastModified
-        self.tags = tags
-        self.private = private
-        self.author = author
-        self.description = description
-        self.citation = citation
-        self.cardData = cardData
-        self.siblings = [RepoFile(**x) for x in siblings] if siblings is not None else []
-        # Legacy stuff, "key" is always returned with an empty string
-        # because of old versions of the datasets lib that need this field
-        kwargs.pop("key", None)
-        # Store all the other fields returned by the API
-        super().__init__(**kwargs)
-
-    def __str__(self):
-        r = f"Dataset Name: {self.id}, Tags: {self.tags}"
-        return r
-
-
-class SpaceInfo(ReprMixin):
-    """
-    Info about a Space accessible from huggingface.co
+    id: str
+    author: Optional[str]
+    sha: Optional[str]
+    last_modified: Optional[datetime]
+    private: bool
+    gated: Optional[bool]
+    disabled: Optional[bool]
+    downloads: int
+    likes: int
+    paperswithcode_id: Optional[str]
+    tags: List[str]
+    card_data: Optional[DatasetCardData]
+    siblings: Optional[List[RepoSibling]]
+
+    def __init__(self, **kwargs):
+        self.id = kwargs.pop("id")
+        self.author = kwargs.pop("author", None)
+        self.sha = kwargs.pop("sha", None)
+        last_modified = kwargs.pop("lastModified", None) or kwargs.pop("last_modified", None)
+        self.last_modified = parse_datetime(last_modified) if last_modified else None
+        self.private = kwargs.pop("private")
+        self.gated = kwargs.pop("gated", None)
+        self.disabled = kwargs.pop("disabled", None)
+        self.downloads = kwargs.pop("downloads")
+        self.likes = kwargs.pop("likes")
+        self.paperswithcode_id = kwargs.pop("paperswithcode_id", None)
+        self.tags = kwargs.pop("tags")
+        card_data = kwargs.pop("cardData", None) or kwargs.pop("card_data", None)
+        self.card_data = (
+            DatasetCardData(**card_data, ignore_metadata_errors=True) if isinstance(card_data, dict) else card_data
+        )
+        siblings = kwargs.pop("siblings", None)
+        self.siblings = (
+            [
+                RepoSibling(
+                    rfilename=sibling["rfilename"],
+                    size=sibling.get("size"),
+                    blob_id=sibling.get("blobId"),
+                    lfs=(
+                        BlobLfsInfo(
+                            size=sibling["lfs"]["size"],
+                            sha256=sibling["lfs"]["sha256"],
+                            pointer_size=sibling["lfs"]["pointerSize"],
+                        )
+                        if sibling.get("lfs")
+                        else None
+                    ),
+                )
+                for sibling in siblings
+            ]
+            if siblings
+            else None
+        )
+
+        # backwards compatibility
+        self.lastModified = self.last_modified
+        self.cardData = self.card_data
+        self.__dict__.update(**kwargs)
 
-    This is a "dataclass" like container that just sets on itself any attribute
-    passed by the server.
+
+@dataclass
+class SpaceInfo:
+    """
+    Contains information about a Space on the Hub.
 
     Attributes:
-        id (`str`, *optional*):
-            id of space
-        sha (`str`, *optional*):
-            repo sha at this particular revision
-        lastModified (`str`, *optional*):
-            date of last commit to repo
-        siblings (`List[RepoFile]`, *optional*):
-            list of [`huggingface_hub.hf_api.RepoFIle`] objects that constitute the Space
-        private (`bool`, *optional*, defaults to `False`):
-            is the repo private
+        id (`str`):
+            ID of the Space.
         author (`str`, *optional*):
-            repo author
-        kwargs (`Dict`, *optional*):
-            Kwargs that will be become attributes of the class.
+            Author of the Space.
+        sha (`str`, *optional*):
+            Repo SHA at this particular revision.
+        last_modified (`datetime`, *optional*):
+            Date of last commit to the repo.
+        private (`bool`):
+            Is the repo private.
+        gated (`bool`, *optional*):
+            Is the repo gated.
+        disabled (`bool`, *optional*):
+            Is the Space disabled.
+        host (`str`, *optional*):
+            Host URL of the Space.
+        subdomain (`str`, *optional*):
+            Subdomain of the Space.
+        likes (`int`):
+            Number of likes of the Space.
+        tags (`List[str]`):
+            List of tags of the Space.
+        siblings (`List[RepoSibling]`):
+            List of [`huggingface_hub.hf_api.RepoSibling`] objects that constitute the Space.
+        card_data (`SpaceCardData`, *optional*):
+            Space Card Metadata  as a [`huggingface_hub.repocard_data.SpaceCardData`] object.
+        runtime (`SpaceRuntime`, *optional*):
+            Space runtime information as a [`huggingface_hub.hf_api.SpaceRuntime`] object.
+        sdk (`str`, *optional*):
+            SDK used by the Space.
+        models (`List[str]`, *optional*):
+            List of models used by the Space.
+        datasets (`List[str]`, *optional*):
+            List of datasets used by the Space.
     """
 
-    def __init__(
-        self,
-        *,
-        id: Optional[str] = None,
-        sha: Optional[str] = None,
-        lastModified: Optional[str] = None,
-        siblings: Optional[List[Dict]] = None,
-        private: bool = False,
-        author: Optional[str] = None,
-        **kwargs,
-    ):
-        self.id = id
-        self.sha = sha
-        self.lastModified = lastModified
-        self.siblings = [RepoFile(**x) for x in siblings] if siblings is not None else []
-        self.private = private
-        self.author = author
-        # Store all the other fields returned by the API
-        super().__init__(**kwargs)
+    id: str
+    author: Optional[str]
+    sha: Optional[str]
+    last_modified: Optional[datetime]
+    private: bool
+    gated: Optional[bool]
+    disabled: Optional[bool]
+    host: Optional[str]
+    subdomain: Optional[str]
+    likes: int
+    sdk: Optional[str]
+    tags: List[str]
+    siblings: Optional[List[RepoSibling]]
+    card_data: Optional[SpaceCardData]
+    runtime: Optional[SpaceRuntime]
+    models: Optional[List[str]]
+    datasets: Optional[List[str]]
+
+    def __init__(self, **kwargs):
+        self.id = kwargs.pop("id")
+        self.author = kwargs.pop("author", None)
+        self.sha = kwargs.pop("sha", None)
+        last_modified = kwargs.pop("lastModified", None) or kwargs.pop("last_modified", None)
+        self.last_modified = parse_datetime(last_modified) if last_modified else None
+        self.private = kwargs.pop("private")
+        self.gated = kwargs.pop("gated", None)
+        self.disabled = kwargs.pop("disabled", None)
+        self.host = kwargs.pop("host", None)
+        self.subdomain = kwargs.pop("subdomain", None)
+        self.likes = kwargs.pop("likes")
+        self.sdk = kwargs.pop("sdk", None)
+        self.tags = kwargs.pop("tags")
+        card_data = kwargs.pop("cardData", None) or kwargs.pop("card_data", None)
+        self.card_data = (
+            SpaceCardData(**card_data, ignore_metadata_errors=True) if isinstance(card_data, dict) else card_data
+        )
+        siblings = kwargs.pop("siblings", None)
+        self.siblings = (
+            [
+                RepoSibling(
+                    rfilename=sibling["rfilename"],
+                    size=sibling.get("size"),
+                    blob_id=sibling.get("blobId"),
+                    lfs=(
+                        BlobLfsInfo(
+                            size=sibling["lfs"]["size"],
+                            sha256=sibling["lfs"]["sha256"],
+                            pointer_size=sibling["lfs"]["pointerSize"],
+                        )
+                        if sibling.get("lfs")
+                        else None
+                    ),
+                )
+                for sibling in siblings
+            ]
+            if siblings
+            else None
+        )
+        runtime = kwargs.pop("runtime", None)
+        self.runtime = SpaceRuntime(runtime) if runtime else None
+        self.models = kwargs.pop("models", None)
+        self.datasets = kwargs.pop("datasets", None)
 
+        # backwards compatibility
+        self.lastModified = self.last_modified
+        self.cardData = self.card_data
+        self.__dict__.update(**kwargs)
 
-class MetricInfo(ReprMixin):
+
+@dataclass
+class MetricInfo:
     """
-    Info about a public metric accessible from huggingface.co
+    Contains information about a metric on the Hub.
+
+    Attributes:
+        id (`str`):
+            ID of the metric. E.g. `"accuracy"`.
+        space_id (`str`):
+            ID of the space associated with the metric. E.g. `"Accuracy"`.
+        description (`str`):
+            Description of the metric.
     """
 
-    def __init__(
-        self,
-        *,
-        id: Optional[str] = None,  # id of metric
-        description: Optional[str] = None,
-        citation: Optional[str] = None,
-        **kwargs,
-    ):
-        self.id = id
-        self.description = description
-        self.citation = citation
-        # Legacy stuff, "key" is always returned with an empty string
-        # because of old versions of the datasets lib that need this field
-        kwargs.pop("key", None)
-        # Store all the other fields returned by the API
-        super().__init__(**kwargs)
+    id: str
+    space_id: str
+    description: Optional[str]
 
-    def __str__(self):
-        r = f"Metric Name: {self.id}"
-        return r
+    def __init__(self, **kwargs):
+        self.id = kwargs.pop("id")
+        self.space_id = kwargs.pop("spaceId")
+        self.description = kwargs.pop("description", None)
+        # backwards compatibility
+        self.spaceId = self.space_id
+        self.__dict__.update(**kwargs)
 
 
-class CollectionItem(ReprMixin):
-    """Contains information about an item of a Collection (model, dataset, Space or paper).
+@dataclass
+class CollectionItem:
+    """
+    Contains information about an item of a Collection (model, dataset, Space or paper).
 
-    Args:
+    Attributes:
         item_object_id (`str`):
             Unique ID of the item in the collection.
         item_id (`str`):
@@ -626,11 +812,14 @@ class CollectionItem(ReprMixin):
             Position of the item in the collection.
         note (`str`, *optional*):
             Note associated with the item, as plain text.
-        kwargs (`Dict`, *optional*):
-            Any other attribute returned by the server. Those attributes depend on the `item_type`: "author", "private",
-            "lastModified", "gated", "title", "likes", "upvotes", etc.
     """
 
+    item_object_id: str  # id in database
+    item_id: str  # repo_id or paper id
+    item_type: str
+    position: int
+    note: Optional[str] = None
+
     def __init__(
         self, _id: str, id: str, type: CollectionItemType_T, position: int, note: Optional[Dict] = None, **kwargs
     ) -> None:
@@ -640,23 +829,19 @@ class CollectionItem(ReprMixin):
         self.position: int = position
         self.note: str = note["text"] if note is not None else None
 
-        # Store all the other fields returned by the API
-        super().__init__(**kwargs)
-
 
-class Collection(ReprMixin):
+@dataclass
+class Collection:
     """
     Contains information about a Collection on the Hub.
 
-    Args:
+    Attributes:
         slug (`str`):
             Slug of the collection. E.g. `"TheBloke/recent-models-64f9a55bb3115b4f513ec026"`.
         title (`str`):
             Title of the collection. E.g. `"Recent models"`.
         owner (`str`):
             Owner of the collection. E.g. `"TheBloke"`.
-        description (`str`, *optional*):
-            Description of the collection, as plain text.
         items (`List[CollectionItem]`):
             List of items in the collection.
         last_updated (`datetime`):
@@ -667,139 +852,45 @@ class Collection(ReprMixin):
             Whether the collection is private or not.
         theme (`str`):
             Theme of the collection. E.g. `"green"`.
+        upvotes (`int`):
+            Number of upvotes of the collection.
+        description (`str`, *optional*):
+            Description of the collection, as plain text.
         url (`str`):
-            URL for the collection on the Hub.
+            (property) URL of the collection on the Hub.
     """
 
     slug: str
     title: str
     owner: str
-    description: Optional[str]
     items: List[CollectionItem]
-
     last_updated: datetime
     position: int
     private: bool
     theme: str
+    upvotes: int
+    description: Optional[str] = None
 
-    def __init__(self, data: Dict, endpoint: Optional[str] = None) -> None:
-        # Collection info
-        self.slug = data["slug"]
-        self.title = data["title"]
-        self.owner = data["owner"]["name"]
-        self.description = data.get("description")
-        self.items = [CollectionItem(**item) for item in data["items"]]
-
-        # Metadata
-        self.last_updated = parse_datetime(data["lastUpdated"])
-        self.private = data["private"]
-        self.position = data["position"]
-        self.theme = data["theme"]
-
-        # (internal)
+    def __init__(self, **kwargs) -> None:
+        self.slug = kwargs.pop("slug")
+        self.title = kwargs.pop("title")
+        self.owner = kwargs.pop("owner")
+        self.items = [CollectionItem(**item) for item in kwargs.pop("items")]
+        self.last_updated = parse_datetime(kwargs.pop("lastUpdated"))
+        self.position = kwargs.pop("position")
+        self.private = kwargs.pop("private")
+        self.theme = kwargs.pop("theme")
+        self.upvotes = kwargs.pop("upvotes")
+        self.description = kwargs.pop("description", None)
+        endpoint = kwargs.pop("endpoint", None)
         if endpoint is None:
             endpoint = ENDPOINT
-        self.url = f"{ENDPOINT}/collections/{self.slug}"
-
-
-class ModelSearchArguments(AttributeDictionary):
-    """
-    A nested namespace object holding all possible values for properties of
-    models currently hosted in the Hub with tab-completion. If a value starts
-    with a number, it will only exist in the dictionary
-
-    Example:
-
-    ```python
-    >>> args = ModelSearchArguments()
-
-    >>> args.author.huggingface
-    'huggingface'
-
-    >>> args.language.en
-    'en'
-    ```
-
-    <Tip warning={true}>
-
-    `ModelSearchArguments` is a legacy class meant for exploratory purposes only. Its
-    initialization requires listing all models on the Hub which makes it increasingly
-    slower as the number of repos on the Hub increases.
-
-    </Tip>
-    """
-
-    def __init__(self, api: Optional["HfApi"] = None):
-        self._api = api if api is not None else HfApi()
-        tags = self._api.get_model_tags()
-        super().__init__(tags)
-        self._process_models()
-
-    def _process_models(self):
-        def clean(s: str) -> str:
-            return s.replace(" ", "").replace("-", "_").replace(".", "_")
-
-        models = self._api.list_models()
-        author_dict, model_name_dict = AttributeDictionary(), AttributeDictionary()
-        for model in models:
-            if "/" in model.modelId:
-                author, name = model.modelId.split("/")
-                author_dict[author] = clean(author)
-            else:
-                name = model.modelId
-            model_name_dict[name] = clean(name)
-        self["model_name"] = model_name_dict
-        self["author"] = author_dict
-
-
-class DatasetSearchArguments(AttributeDictionary):
-    """
-    A nested namespace object holding all possible values for properties of
-    datasets currently hosted in the Hub with tab-completion. If a value starts
-    with a number, it will only exist in the dictionary
-
-    Example:
-
-    ```python
-    >>> args = DatasetSearchArguments()
-
-    >>> args.author.huggingface
-    'huggingface'
-
-    >>> args.language.en
-    'language:en'
-    ```
-
-    <Tip warning={true}>
-
-    `DatasetSearchArguments` is a legacy class meant for exploratory purposes only. Its
-    initialization requires listing all datasets on the Hub which makes it increasingly
-    slower as the number of repos on the Hub increases.
-
-    </Tip>
-    """
+        self._url = f"{endpoint}/collections/{self.slug}"
 
-    def __init__(self, api: Optional["HfApi"] = None):
-        self._api = api if api is not None else HfApi()
-        tags = self._api.get_dataset_tags()
-        super().__init__(tags)
-        self._process_models()
-
-    def _process_models(self):
-        def clean(s: str):
-            return s.replace(" ", "").replace("-", "_").replace(".", "_")
-
-        datasets = self._api.list_datasets()
-        author_dict, dataset_name_dict = AttributeDictionary(), AttributeDictionary()
-        for dataset in datasets:
-            if "/" in dataset.id:
-                author, name = dataset.id.split("/")
-                author_dict[author] = clean(author)
-            else:
-                name = dataset.id
-            dataset_name_dict[name] = clean(name)
-        self["dataset_name"] = dataset_name_dict
-        self["author"] = author_dict
+    @property
+    def url(self) -> str:
+        """Returns the URL of the collection on the Hub."""
+        return self._url
 
 
 @dataclass
@@ -807,7 +898,7 @@ class GitRefInfo:
     """
     Contains information about a git reference for a repo on the Hub.
 
-    Args:
+    Attributes:
         name (`str`):
             Name of the reference (e.g. tag name or branch name).
         ref (`str`):
@@ -820,11 +911,6 @@ class GitRefInfo:
     ref: str
     target_commit: str
 
-    def __init__(self, data: Dict) -> None:
-        self.name = data["name"]
-        self.ref = data["ref"]
-        self.target_commit = data["targetCommit"]
-
 
 @dataclass
 class GitRefs:
@@ -833,7 +919,7 @@ class GitRefs:
 
     Object is returned by [`list_repo_refs`].
 
-    Args:
+    Attributes:
         branches (`List[GitRefInfo]`):
             A list of [`GitRefInfo`] containing information about branches on the repo.
         converts (`List[GitRefInfo]`):
@@ -853,7 +939,7 @@ class GitCommitInfo:
     """
     Contains information about a git commit for a repo on the Hub. Check out [`list_repo_commits`] for more details.
 
-    Args:
+    Attributes:
         commit_id (`str`):
             OID of the commit (e.g. `"e7da7f221d5bf496a48136c0cd264e630fe9fcc8"`)
         authors (`List[str]`):
@@ -880,23 +966,13 @@ class GitCommitInfo:
     formatted_title: Optional[str]
     formatted_message: Optional[str]
 
-    def __init__(self, data: Dict) -> None:
-        self.commit_id = data["id"]
-        self.authors = [author["user"] for author in data["authors"]]
-        self.created_at = parse_datetime(data["date"])
-        self.title = data["title"]
-        self.message = data["message"]
-
-        self.formatted_title = data.get("formatted", {}).get("title")
-        self.formatted_message = data.get("formatted", {}).get("message")
-
 
 @dataclass
 class UserLikes:
     """
     Contains information about a user likes on the Hub.
 
-    Args:
+    Attributes:
         user (`str`):
             Name of the user for which we fetched the likes.
         total (`int`):
@@ -924,7 +1000,7 @@ class User:
     """
     Contains information about a user on the Hub.
 
-    Args:
+    Attributes:
         avatar_url (`str`):
             URL of the user's avatar.
         username (`str`):
@@ -989,9 +1065,6 @@ class HfApi:
         directly at the root of `huggingface_hub`.
 
         Args:
-            endpoint (`str`, *optional*):
-                Hugging Face Hub base url. Will default to https://huggingface.co/. Otherwise,
-                one can set the `HF_ENDPOINT` environment variable.
             token (`str`, *optional*):
                 Hugging Face token. Will default to the locally saved token if
                 not provided.
@@ -1101,25 +1174,23 @@ class HfApi:
         except (LocalTokenNotFoundError, HTTPError):
             return None
 
-    def get_model_tags(self) -> ModelTags:
+    def get_model_tags(self) -> Dict:
         """
         List all valid model tags as a nested namespace object
         """
         path = f"{self.endpoint}/api/models-tags-by-type"
         r = get_session().get(path)
         hf_raise_for_status(r)
-        d = r.json()
-        return ModelTags(d)
+        return r.json()
 
-    def get_dataset_tags(self) -> DatasetTags:
+    def get_dataset_tags(self) -> Dict:
         """
         List all valid dataset tags as a nested namespace object.
         """
         path = f"{self.endpoint}/api/datasets-tags-by-type"
         r = get_session().get(path)
         hf_raise_for_status(r)
-        d = r.json()
-        return DatasetTags(d)
+        return r.json()
 
     @validate_hf_hub_args
     def list_models(
@@ -1129,7 +1200,7 @@ class HfApi:
         author: Optional[str] = None,
         search: Optional[str] = None,
         emissions_thresholds: Optional[Tuple[float, float]] = None,
-        sort: Union[Literal["lastModified"], str, None] = None,
+        sort: Union[Literal["last_modified"], str, None] = None,
         direction: Optional[Literal[-1]] = None,
         limit: Optional[int] = None,
         full: Optional[bool] = None,
@@ -1152,7 +1223,7 @@ class HfApi:
             emissions_thresholds (`Tuple`, *optional*):
                 A tuple of two ints or floats representing a minimum and maximum
                 carbon footprint to filter the resulting models with in grams.
-            sort (`Literal["lastModified"]` or `str`, *optional*):
+            sort (`Literal["last_modified"]` or `str`, *optional*):
                 The key with which to sort the resulting models. Possible values
                 are the properties of the [`huggingface_hub.hf_api.ModelInfo`] class.
             direction (`Literal[-1]` or `int`, *optional*):
@@ -1162,7 +1233,7 @@ class HfApi:
                 The limit on the number of models fetched. Leaving this option
                 to `None` fetches all models.
             full (`bool`, *optional*):
-                Whether to fetch all model data, including the `lastModified`,
+                Whether to fetch all model data, including the `last_modified`,
                 the `sha`, the files and the `tags`. This is set to `True` by
                 default when using a filter.
             cardData (`bool`, *optional*):
@@ -1191,29 +1262,15 @@ class HfApi:
         >>> # List all models
         >>> api.list_models()
 
-        >>> # Get all valid search arguments
-        >>> args = ModelSearchArguments()
-
         >>> # List only the text classification models
         >>> api.list_models(filter="text-classification")
         >>> # Using the `ModelFilter`
         >>> filt = ModelFilter(task="text-classification")
-        >>> # With `ModelSearchArguments`
-        >>> filt = ModelFilter(task=args.pipeline_tags.TextClassification)
-        >>> api.list_models(filter=filt)
-
-        >>> # Using `ModelFilter` and `ModelSearchArguments` to find text classification in both PyTorch and TensorFlow
-        >>> filt = ModelFilter(
-        ...     task=args.pipeline_tags.TextClassification,
-        ...     library=[args.library.PyTorch, args.library.TensorFlow],
-        ... )
-        >>> api.list_models(filter=filt)
+
 
         >>> # List only models from the AllenNLP library
         >>> api.list_models(filter="allennlp")
-        >>> # Using `ModelFilter` and `ModelSearchArguments`
-        >>> filt = ModelFilter(library=args.library.allennlp)
-        ```
+
 
         Example usage with the `search` argument:
 
@@ -1246,7 +1303,7 @@ class HfApi:
         if search is not None:
             params.update({"search": search})
         if sort is not None:
-            params.update({"sort": sort})
+            params.update({"sort": "lastModified" if sort == "last_modified" else sort})
         if direction is not None:
             params.update({"direction": direction})
         if limit is not None:
@@ -1265,10 +1322,12 @@ class HfApi:
         items = paginate(path, params=params, headers=headers)
         if limit is not None:
             items = islice(items, limit)  # Do not iterate over all pages
-        if emissions_thresholds is not None:
-            items = _filter_emissions(items, *emissions_thresholds)
         for item in items:
-            yield ModelInfo(**item)
+            if "siblings" not in item:
+                item["siblings"] = None
+            model_info = ModelInfo(**item)
+            if emissions_thresholds is None or _is_emission_within_treshold(model_info, *emissions_thresholds):
+                yield model_info
 
     def _unpack_model_filter(self, model_filter: ModelFilter):
         """
@@ -1326,7 +1385,7 @@ class HfApi:
         filter: Union[DatasetFilter, str, Iterable[str], None] = None,
         author: Optional[str] = None,
         search: Optional[str] = None,
-        sort: Union[Literal["lastModified"], str, None] = None,
+        sort: Union[Literal["last_modified"], str, None] = None,
         direction: Optional[Literal[-1]] = None,
         limit: Optional[int] = None,
         full: Optional[bool] = None,
@@ -1343,7 +1402,7 @@ class HfApi:
                 A string which identify the author of the returned datasets.
             search (`str`, *optional*):
                 A string that will be contained in the returned datasets.
-            sort (`Literal["lastModified"]` or `str`, *optional*):
+            sort (`Literal["last_modified"]` or `str`, *optional*):
                 The key with which to sort the resulting datasets. Possible
                 values are the properties of the [`huggingface_hub.hf_api.DatasetInfo`] class.
             direction (`Literal[-1]` or `int`, *optional*):
@@ -1353,8 +1412,8 @@ class HfApi:
                 The limit on the number of datasets fetched. Leaving this option
                 to `None` fetches all datasets.
             full (`bool`, *optional*):
-                Whether to fetch all dataset data, including the `lastModified`
-                and the `cardData`. Can contain useful information such as the
+                Whether to fetch all dataset data, including the `last_modified`,
+                the `card_data` and  the files. Can contain useful information such as the
                 PapersWithCode ID.
             token (`bool` or `str`, *optional*):
                 A valid authentication token (see https://huggingface.co/settings/token).
@@ -1375,16 +1434,12 @@ class HfApi:
         >>> # List all datasets
         >>> api.list_datasets()
 
-        >>> # Get all valid search arguments
-        >>> args = DatasetSearchArguments()
 
         >>> # List only the text classification datasets
         >>> api.list_datasets(filter="task_categories:text-classification")
         >>> # Using the `DatasetFilter`
         >>> filt = DatasetFilter(task_categories="text-classification")
-        >>> # With `DatasetSearchArguments`
-        >>> filt = DatasetFilter(task=args.task_categories.text_classification)
-        >>> api.list_models(filter=filt)
+
 
         >>> # List only the datasets in russian for language modeling
         >>> api.list_datasets(
@@ -1392,11 +1447,7 @@ class HfApi:
         ... )
         >>> # Using the `DatasetFilter`
         >>> filt = DatasetFilter(language="ru", task_ids="language-modeling")
-        >>> # With `DatasetSearchArguments`
-        >>> filt = DatasetFilter(
-        ...     language=args.language.ru,
-        ...     task_ids=args.task_ids.language_modeling,
-        ... )
+
         >>> api.list_datasets(filter=filt)
         ```
 
@@ -1427,7 +1478,7 @@ class HfApi:
         if search is not None:
             params.update({"search": search})
         if sort is not None:
-            params.update({"sort": sort})
+            params.update({"sort": "lastModified" if sort == "last_modified" else sort})
         if direction is not None:
             params.update({"direction": direction})
         if limit is not None:
@@ -1439,6 +1490,8 @@ class HfApi:
         if limit is not None:
             items = islice(items, limit)  # Do not iterate over all pages
         for item in items:
+            if "siblings" not in item:
+                item["siblings"] = None
             yield DatasetInfo(**item)
 
     def _unpack_dataset_filter(self, dataset_filter: DatasetFilter):
@@ -1502,7 +1555,7 @@ class HfApi:
         filter: Union[str, Iterable[str], None] = None,
         author: Optional[str] = None,
         search: Optional[str] = None,
-        sort: Union[Literal["lastModified"], str, None] = None,
+        sort: Union[Literal["last_modified"], str, None] = None,
         direction: Optional[Literal[-1]] = None,
         limit: Optional[int] = None,
         datasets: Union[str, Iterable[str], None] = None,
@@ -1521,7 +1574,7 @@ class HfApi:
                 A string which identify the author of the returned Spaces.
             search (`str`, *optional*):
                 A string that will be contained in the returned Spaces.
-            sort (`Literal["lastModified"]` or `str`, *optional*):
+            sort (`Literal["last_modified"]` or `str`, *optional*):
                 The key with which to sort the resulting Spaces. Possible
                 values are the properties of the [`huggingface_hub.hf_api.SpaceInfo`]` class.
             direction (`Literal[-1]` or `int`, *optional*):
@@ -1539,8 +1592,8 @@ class HfApi:
             linked (`bool`, *optional*):
                 Whether to return Spaces that make use of either a model or a dataset.
             full (`bool`, *optional*):
-                Whether to fetch all Spaces data, including the `lastModified`
-                and the `cardData`.
+                Whether to fetch all Spaces data, including the `last_modified`, `siblings`
+                and `card_data` fields.
             token (`bool` or `str`, *optional*):
                 A valid authentication token (see https://huggingface.co/settings/token).
                 If `None` or `True` and machine is logged in (through `huggingface-cli login`
@@ -1560,7 +1613,7 @@ class HfApi:
         if search is not None:
             params.update({"search": search})
         if sort is not None:
-            params.update({"sort": sort})
+            params.update({"sort": "lastModified" if sort == "last_modified" else sort})
         if direction is not None:
             params.update({"direction": direction})
         if limit is not None:
@@ -1578,6 +1631,8 @@ class HfApi:
         if limit is not None:
             items = islice(items, limit)  # Do not iterate over all pages
         for item in items:
+            if "siblings" not in item:
+                item["siblings"] = None
             yield SpaceInfo(**item)
 
     @validate_hf_hub_args
@@ -1865,8 +1920,8 @@ class HfApi:
             params["blobs"] = True
         r = get_session().get(path, headers=headers, timeout=timeout, params=params)
         hf_raise_for_status(r)
-        d = r.json()
-        return ModelInfo(**d)
+        data = r.json()
+        return ModelInfo(**data)
 
     @validate_hf_hub_args
     def dataset_info(
@@ -1928,8 +1983,8 @@ class HfApi:
 
         r = get_session().get(path, headers=headers, timeout=timeout, params=params)
         hf_raise_for_status(r)
-        d = r.json()
-        return DatasetInfo(**d)
+        data = r.json()
+        return DatasetInfo(**data)
 
     @validate_hf_hub_args
     def space_info(
@@ -1991,8 +2046,8 @@ class HfApi:
 
         r = get_session().get(path, headers=headers, timeout=timeout, params=params)
         hf_raise_for_status(r)
-        d = r.json()
-        return SpaceInfo(**d)
+        data = r.json()
+        return SpaceInfo(**data)
 
     @validate_hf_hub_args
     def repo_info(
@@ -2231,8 +2286,8 @@ class HfApi:
             <generator object HfApi.list_files_info at 0x7f93b848e730>
             >>> list(files_info)
             [
-                RepoFile: {"blob_id": "43bd404b159de6fba7c2f4d3264347668d43af25", "lfs": None, "rfilename": "README.md", "size": 391},
-                RepoFile: {"blob_id": "2f9618c3a19b9a61add74f70bfb121335aeef666", "lfs": None, "rfilename": "config.json", "size": 554},
+                RepoFile(path='README.md', size=391, blob_id='43bd404b159de6fba7c2f4d3264347668d43af25', lfs=None, last_commit=None, security=None),
+                RepoFile(path='config.json', size=554, blob_id='2f9618c3a19b9a61add74f70bfb121335aeef666', lfs=None, last_commit=None, security=None)
             ]
             ```
 
@@ -2242,44 +2297,56 @@ class HfApi:
             >>> files_info = list_files_info("prompthero/openjourney-v4", expand=True)
             >>> list(files_info)
             [
-                RepoFile: {
-                {'blob_id': '815004af1a321eaed1d93f850b2e94b0c0678e42',
-                'lastCommit': {'date': '2023-03-21T09:05:27.000Z',
-                                'id': '47b62b20b20e06b9de610e840282b7e6c3d51190',
-                                'title': 'Upload diffusers weights (#48)'},
-                'lfs': None,
-                'rfilename': 'model_index.json',
-                'security': {'avScan': {'virusFound': False, 'virusNames': None},
-                                'blobId': '815004af1a321eaed1d93f850b2e94b0c0678e42',
-                                'name': 'model_index.json',
-                                'pickleImportScan': None,
-                                'repositoryId': 'models/prompthero/openjourney-v4',
-                                'safe': True},
-                'size': 584}
-                },
-                RepoFile: {
-                {'blob_id': 'd2343d78b33ac03dade1d525538b02b130d0a3a0',
-                'lastCommit': {'date': '2023-03-21T09:05:27.000Z',
-                                'id': '47b62b20b20e06b9de610e840282b7e6c3d51190',
-                                'title': 'Upload diffusers weights (#48)'},
-                'lfs': {'pointer_size': 134,
-                        'sha256': 'dcf4507d99b88db73f3916e2a20169fe74ada6b5582e9af56cfa80f5f3141765',
-                        'size': 334711857},
-                'rfilename': 'vae/diffusion_pytorch_model.bin',
-                'security': {'avScan': {'virusFound': False, 'virusNames': None},
-                                'blobId': 'd2343d78b33ac03dade1d525538b02b130d0a3a0',
-                                'name': 'vae/diffusion_pytorch_model.bin',
-                                'pickleImportScan': {'highestSafetyLevel': 'innocuous',
-                                                    'imports': [{'module': 'torch._utils',
-                                                                'name': '_rebuild_tensor_v2',
-                                                                'safety': 'innocuous'},
-                                                                {'module': 'collections', 'name': 'OrderedDict', 'safety': 'innocuous'},
-                                                                {'module': 'torch', 'name': 'FloatStorage', 'safety': 'innocuous'}]},
-                                'repositoryId': 'models/prompthero/openjourney-v4',
-                                'safe': True},
-                'size': 334711857}
-                },
-                (...)
+                RepoFile(
+                    path='safety_checker/pytorch_model.bin',
+                    size=1216064769,
+                    blob_id='c8835557a0d3af583cb06c7c154b7e54a069c41d',
+                    lfs={
+                        'size': 1216064769,
+                        'sha256': '16d28f2b37109f222cdc33620fdd262102ac32112be0352a7f77e9614b35a394',
+                        'pointer_size': 135
+                    },
+                    last_commit={
+                        'oid': '47b62b20b20e06b9de610e840282b7e6c3d51190',
+                        'title': 'Upload diffusers weights (#48)',
+                        'date': datetime.datetime(2023, 3, 21, 10, 5, 27, tzinfo=datetime.timezone.utc)
+                    },
+                    security={
+                        'safe': True,
+                        'av_scan': {
+                            'virusFound': False,
+                            'virusNames': None
+                        },
+                        'pickle_import_scan': {
+                            'highestSafetyLevel': 'innocuous',
+                            'imports': [
+                                {'module': 'torch', 'name': 'FloatStorage', 'safety': 'innocuous'},
+                                {'module': 'collections', 'name': 'OrderedDict', 'safety': 'innocuous'},
+                                {'module': 'torch', 'name': 'LongStorage', 'safety': 'innocuous'},
+                                {'module': 'torch._utils', 'name': '_rebuild_tensor_v2', 'safety': 'innocuous'}
+                            ]
+                        }
+                    }
+                ),
+                RepoFile(
+                    path='scheduler/scheduler_config.json',
+                    size=465,
+                    blob_id='70d55e3e9679f41cbc66222831b38d5abce683dd',
+                    lfs=None,
+                    last_commit={
+                        'oid': '47b62b20b20e06b9de610e840282b7e6c3d51190',
+                        'title': 'Upload diffusers weights (#48)',
+                        'date': datetime.datetime(2023, 3, 21, 10, 5, 27, tzinfo=datetime.timezone.utc)},
+                        security={
+                            'safe': True,
+                            'av_scan': {
+                                'virusFound': False,
+                                'virusNames': None
+                            },
+                            'pickle_import_scan': None
+                        }
+                ),
+                ...
             ]
             ```
 
@@ -2287,14 +2354,14 @@ class HfApi:
 
             ```py
             >>> from huggingface_hub import list_files_info
-            >>> [info.rfilename for info in list_files_info("stabilityai/stable-diffusion-2", "vae") if info.lfs is not None]
+            >>> [info.path for info in list_files_info("stabilityai/stable-diffusion-2", "vae") if info.lfs is not None]
             ['vae/diffusion_pytorch_model.bin', 'vae/diffusion_pytorch_model.safetensors']
             ```
 
             List all files on a repo.
             ```py
             >>> from huggingface_hub import list_files_info
-            >>> [info.rfilename for info in list_files_info("glue", repo_type="dataset")]
+            >>> [info.path for info in list_files_info("glue", repo_type="dataset")]
             ['.gitattributes', 'README.md', 'dataset_infos.json', 'glue.py']
             ```
         """
@@ -2305,14 +2372,24 @@ class HfApi:
         def _format_as_repo_file(info: Dict) -> RepoFile:
             # Quick alias very specific to the server return type of /paths-info and /tree endpoints. Let's keep this
             # logic here.
-            rfilename = info.pop("path")
+            path = info.pop("path")
             size = info.pop("size")
-            blobId = info.pop("oid")
+            blob_id = info.pop("oid")
             lfs = info.pop("lfs", None)
+            last_commit = info.pop("lastCommit", None)
+            security = info.pop("security", None)
             info.pop("type", None)  # "file" or "folder" -> not needed in practice since we know it's a file
+            if last_commit is not None:
+                last_commit = BlobLastCommitInfo(
+                    oid=last_commit["id"], title=last_commit["title"], date=parse_datetime(last_commit["date"])
+                )
+            if security is not None:
+                security = BlobSecurityInfo(
+                    safe=security["safe"], av_scan=security["avScan"], pickle_import_scan=security["pickleImportScan"]
+                )
             if lfs is not None:
                 lfs = BlobLfsInfo(size=lfs["size"], sha256=lfs["oid"], pointer_size=lfs["pointerSize"])
-            return RepoFile(rfilename=rfilename, size=size, blobId=blobId, lfs=lfs, **info)
+            return RepoFile(path=path, size=size, blob_id=blob_id, lfs=lfs, last_commit=last_commit, security=security)
 
         folder_paths = []
         if paths is None:
@@ -2327,7 +2404,7 @@ class HfApi:
                 f"{self.endpoint}/api/{repo_type}s/{repo_id}/paths-info/{revision}",
                 data={
                     "paths": paths if isinstance(paths, list) else [paths],
-                    "expand": True,
+                    "expand": expand,
                 },
                 headers=headers,
             )
@@ -2440,10 +2517,14 @@ class HfApi:
         )
         hf_raise_for_status(response)
         data = response.json()
+
+        def _format_as_git_ref_info(item: Dict) -> GitRefInfo:
+            return GitRefInfo(name=item["name"], ref=item["ref"], target_commit=item["targetCommit"])
+
         return GitRefs(
-            branches=[GitRefInfo(item) for item in data["branches"]],
-            converts=[GitRefInfo(item) for item in data["converts"]],
-            tags=[GitRefInfo(item) for item in data["tags"]],
+            branches=[_format_as_git_ref_info(item) for item in data["branches"]],
+            converts=[_format_as_git_ref_info(item) for item in data["converts"]],
+            tags=[_format_as_git_ref_info(item) for item in data["tags"]],
         )
 
     @validate_hf_hub_args
@@ -2516,7 +2597,15 @@ class HfApi:
 
         # Paginate over results and return the list of commits.
         return [
-            GitCommitInfo(item)
+            GitCommitInfo(
+                commit_id=item["id"],
+                authors=[author["user"] for author in item["authors"]],
+                created_at=parse_datetime(item["date"]),
+                title=item["title"],
+                message=item["message"],
+                formatted_title=item.get("formatted", {}).get("title"),
+                formatted_message=item.get("formatted", {}).get("message"),
+            )
             for item in paginate(
                 f"{self.endpoint}/api/{repo_type}s/{repo_id}/commits/{revision}",
                 headers=self._build_hf_headers(token=token),
@@ -4235,8 +4324,9 @@ class HfApi:
         force_download: bool = False,
         force_filename: Optional[str] = None,
         proxies: Optional[Dict] = None,
-        etag_timeout: float = 10,
+        etag_timeout: float = DEFAULT_ETAG_TIMEOUT,
         resume_download: bool = False,
+        token: Optional[Union[str, bool]] = None,
         local_files_only: bool = False,
         legacy_cache_layout: bool = False,
     ) -> str:
@@ -4298,9 +4388,6 @@ class HfApi:
             revision (`str`, *optional*):
                 An optional Git revision id which can be a branch name, a tag, or a
                 commit hash.
-            endpoint (`str`, *optional*):
-                Hugging Face Hub base url. Will default to https://huggingface.co/. Otherwise, one can set the `HF_ENDPOINT`
-                environment variable.
             cache_dir (`str`, `Path`, *optional*):
                 Path to the folder where cached files are stored.
             local_dir (`str` or `Path`, *optional*):
@@ -4322,6 +4409,11 @@ class HfApi:
                 data before giving up which is passed to `requests.request`.
             resume_download (`bool`, *optional*, defaults to `False`):
                 If `True`, resume a previously interrupted download.
+            token (`bool` or `str`, *optional*):
+                A valid authentication token (see https://huggingface.co/settings/token).
+                If `None` or `True` and machine is logged in (through `huggingface-cli login`
+                or [`~huggingface_hub.login`]), token will be retrieved from the cache.
+                If `False`, token is not sent in the request header.
             local_files_only (`bool`, *optional*, defaults to `False`):
                 If `True`, avoid downloading the file and return the path to the
                 local cached file if it exists.
@@ -4358,6 +4450,10 @@ class HfApi:
         """
         from .file_download import hf_hub_download
 
+        if token is None:
+            # Cannot do `token = token or self.token` as token can be `False`.
+            token = self.token
+
         return hf_hub_download(
             repo_id=repo_id,
             filename=filename,
@@ -4376,7 +4472,7 @@ class HfApi:
             proxies=proxies,
             etag_timeout=etag_timeout,
             resume_download=resume_download,
-            token=self.token,
+            token=token,
             local_files_only=local_files_only,
             legacy_cache_layout=legacy_cache_layout,
         )
@@ -4392,9 +4488,10 @@ class HfApi:
         local_dir: Union[str, Path, None] = None,
         local_dir_use_symlinks: Union[bool, Literal["auto"]] = "auto",
         proxies: Optional[Dict] = None,
-        etag_timeout: float = 10,
+        etag_timeout: float = DEFAULT_ETAG_TIMEOUT,
         resume_download: bool = False,
         force_download: bool = False,
+        token: Optional[Union[str, bool]] = None,
         local_files_only: bool = False,
         allow_patterns: Optional[Union[List[str], str]] = None,
         ignore_patterns: Optional[Union[List[str], str]] = None,
@@ -4455,6 +4552,11 @@ class HfApi:
                 If `True`, resume a previously interrupted download.
             force_download (`bool`, *optional*, defaults to `False`):
                 Whether the file should be downloaded even if it already exists in the local cache.
+            token (`bool` or `str`, *optional*):
+                A valid authentication token (see https://huggingface.co/settings/token).
+                If `None` or `True` and machine is logged in (through `huggingface-cli login`
+                or [`~huggingface_hub.login`]), token will be retrieved from the cache.
+                If `False`, token is not sent in the request header.
             local_files_only (`bool`, *optional*, defaults to `False`):
                 If `True`, avoid downloading the file and return the path to the
                 local cached file if it exists.
@@ -4490,6 +4592,10 @@ class HfApi:
         """
         from ._snapshot_download import snapshot_download
 
+        if token is None:
+            # Cannot do `token = token or self.token` as token can be `False`.
+            token = self.token
+
         return snapshot_download(
             repo_id=repo_id,
             repo_type=repo_type,
@@ -4505,7 +4611,7 @@ class HfApi:
             etag_timeout=etag_timeout,
             resume_download=resume_download,
             force_download=force_download,
-            token=self.token,
+            token=token,
             local_files_only=local_files_only,
             allow_patterns=allow_patterns,
             ignore_patterns=ignore_patterns,
@@ -6002,6 +6108,446 @@ class HfApi:
         hf_raise_for_status(r)
         return SpaceRuntime(r.json())
 
+    #######################
+    # Inference Endpoints #
+    #######################
+
+    def list_inference_endpoints(
+        self, namespace: Optional[str] = None, *, token: Optional[str] = None
+    ) -> List[InferenceEndpoint]:
+        """Lists all inference endpoints for the given namespace.
+
+        Args:
+            namespace (`str`, *optional*):
+                The namespace to list endpoints for. Defaults to the current user. Set to `"*"` to list all endpoints
+                from all namespaces (i.e. personal namespace and all orgs the user belongs to).
+            token (`str`, *optional*):
+                An authentication token (See https://huggingface.co/settings/token).
+
+        Returns:
+            List[`InferenceEndpoint`]: A list of all inference endpoints for the given namespace.
+
+        Example:
+        ```python
+        >>> from huggingface_hub import HfApi
+        >>> api = HfApi()
+        >>> api.list_inference_endpoints()
+        [InferenceEndpoint(name='my-endpoint', ...), ...]
+        ```
+        """
+        # Special case: list all endpoints for all namespaces the user has access to
+        if namespace == "*":
+            user = self.whoami(token=token)
+
+            # List personal endpoints first
+            endpoints: List[InferenceEndpoint] = list_inference_endpoints(namespace=self._get_namespace(token=token))
+
+            # Then list endpoints for all orgs the user belongs to and ignore 401 errors (no billing or no access)
+            for org in user.get("orgs", []):
+                try:
+                    endpoints += list_inference_endpoints(namespace=org["name"], token=token)
+                except HfHubHTTPError as error:
+                    if error.response.status_code == 401:  # Either no billing or user don't have access)
+                        logger.debug("Cannot list Inference Endpoints for org '%s': %s", org["name"], error)
+                    pass
+
+            return endpoints
+
+        # Normal case: list endpoints for a specific namespace
+        namespace = namespace or self._get_namespace(token=token)
+
+        response = get_session().get(
+            f"{INFERENCE_ENDPOINTS_ENDPOINT}/endpoint/{namespace}",
+            headers=self._build_hf_headers(token=token),
+        )
+        hf_raise_for_status(response)
+
+        return [
+            InferenceEndpoint.from_raw(endpoint, namespace=namespace, token=token)
+            for endpoint in response.json()["items"]
+        ]
+
+    def create_inference_endpoint(
+        self,
+        name: str,
+        *,
+        repository: str,
+        framework: str,
+        accelerator: str,
+        instance_size: str,
+        instance_type: str,
+        region: str,
+        vendor: str,
+        account_id: Optional[str] = None,
+        min_replica: int = 0,
+        max_replica: int = 1,
+        revision: Optional[str] = None,
+        task: Optional[str] = None,
+        type: InferenceEndpointType = InferenceEndpointType.PROTECTED,
+        namespace: Optional[str] = None,
+        token: Optional[str] = None,
+    ) -> InferenceEndpoint:
+        """Create a new Inference Endpoint.
+
+        Args:
+            name (`str`):
+                The unique name for the new Inference Endpoint.
+            repository (`str`):
+                The name of the model repository associated with the Inference Endpoint (e.g. `"gpt2"`).
+            framework (`str`):
+                The machine learning framework used for the model (e.g. `"custom"`).
+            accelerator (`str`):
+                The hardware accelerator to be used for inference (e.g. `"cpu"`).
+            instance_size (`str`):
+                The size or type of the instance to be used for hosting the model (e.g. `"large"`).
+            instance_type (`str`):
+                The cloud instance type where the Inference Endpoint will be deployed (e.g. `"c6i"`).
+            region (`str`):
+                The cloud region in which the Inference Endpoint will be created (e.g. `"us-east-1"`).
+            vendor (`str`):
+                The cloud provider or vendor where the Inference Endpoint will be hosted (e.g. `"aws"`).
+            account_id (`str`, *optional*):
+                The account ID used to link a VPC to a private Inference Endpoint (if applicable).
+            min_replica (`int`, *optional*):
+                The minimum number of replicas (instances) to keep running for the Inference Endpoint. Defaults to 0.
+            max_replica (`int`, *optional*):
+                The maximum number of replicas (instances) to scale to for the Inference Endpoint. Defaults to 1.
+            revision (`str`, *optional*):
+                The specific model revision to deploy on the Inference Endpoint (e.g. `"6c0e6080953db56375760c0471a8c5f2929baf11"`).
+            task (`str`, *optional*):
+                The task on which to deploy the model (e.g. `"text-classification"`).
+            type ([`InferenceEndpointType]`, *optional*):
+                The type of the Inference Endpoint, which can be `"protected"` (default), `"public"` or `"private"`.
+            namespace (`str`, *optional*):
+                The namespace where the Inference Endpoint will be created. Defaults to the current user's namespace.
+            token (`str`, *optional*):
+                An authentication token (See https://huggingface.co/settings/token).
+
+            Returns:
+                [`InferenceEndpoint`]: information about the updated Inference Endpoint.
+
+            Example:
+            ```python
+            >>> from huggingface_hub import HfApi
+            >>> api = HfApi()
+            >>> create_inference_endpoint(
+            ...     "my-endpoint-name",
+            ...     repository="gpt2",
+            ...     framework="pytorch",
+            ...     task="text-generation",
+            ...     accelerator="cpu",
+            ...     vendor="aws",
+            ...     region="us-east-1",
+            ...     type="protected",
+            ...     instance_size="medium",
+            ...     instance_type="c6i"
+            ... )
+            >>> endpoint
+            InferenceEndpoint(name='my-endpoint-name', status="pending",...)
+
+            # Run inference on the endpoint
+            >>> endpoint.client.text_generation(...)
+            "..."
+            ```
+        """
+        namespace = namespace or self._get_namespace(token=token)
+
+        payload: Dict = {
+            "accountId": account_id,
+            "compute": {
+                "accelerator": accelerator,
+                "instanceSize": instance_size,
+                "instanceType": instance_type,
+                "scaling": {
+                    "maxReplica": max_replica,
+                    "minReplica": min_replica,
+                },
+            },
+            "model": {
+                "framework": framework,
+                "repository": repository,
+                "revision": revision,
+                "task": task,
+                "image": {"huggingface": {}},
+            },
+            "name": name,
+            "provider": {
+                "region": region,
+                "vendor": vendor,
+            },
+            "type": type,
+        }
+
+        response = get_session().post(
+            f"{INFERENCE_ENDPOINTS_ENDPOINT}/endpoint/{namespace}",
+            headers=self._build_hf_headers(token=token),
+            json=payload,
+        )
+        hf_raise_for_status(response)
+
+        return InferenceEndpoint.from_raw(response.json(), namespace=namespace, token=token)
+
+    def get_inference_endpoint(
+        self, name: str, *, namespace: Optional[str] = None, token: Optional[str] = None
+    ) -> InferenceEndpoint:
+        """Get information about an Inference Endpoint.
+
+        Args:
+            name (`str`):
+                The name of the Inference Endpoint to retrieve information about.
+            namespace (`str`, *optional*):
+                The namespace in which the Inference Endpoint is located. Defaults to the current user.
+            token (`str`, *optional*):
+                An authentication token (See https://huggingface.co/settings/token).
+
+        Returns:
+            [`InferenceEndpoint`]: information about the requested Inference Endpoint.
+
+        Example:
+        ```python
+        >>> from huggingface_hub import HfApi
+        >>> api = HfApi()
+        >>> endpoint = api.get_inference_endpoint("my-text-to-image")
+        >>> endpoint
+        InferenceEndpoint(name='my-text-to-image', ...)
+
+        # Get status
+        >>> endpoint.status
+        'running'
+        >>> endpoint.url
+        'https://my-text-to-image.region.vendor.endpoints.huggingface.cloud'
+
+        # Run inference
+        >>> endpoint.client.text_to_image(...)
+        ```
+        """
+        namespace = namespace or self._get_namespace(token=token)
+
+        response = get_session().get(
+            f"{INFERENCE_ENDPOINTS_ENDPOINT}/endpoint/{namespace}/{name}",
+            headers=self._build_hf_headers(token=token),
+        )
+        hf_raise_for_status(response)
+
+        return InferenceEndpoint.from_raw(response.json(), namespace=namespace, token=token)
+
+    def update_inference_endpoint(
+        self,
+        name: str,
+        *,
+        # Compute update
+        accelerator: Optional[str] = None,
+        instance_size: Optional[str] = None,
+        instance_type: Optional[str] = None,
+        min_replica: Optional[int] = None,
+        max_replica: Optional[int] = None,
+        # Model update
+        repository: Optional[str] = None,
+        framework: Optional[str] = None,
+        revision: Optional[str] = None,
+        task: Optional[str] = None,
+        # Other
+        namespace: Optional[str] = None,
+        token: Optional[str] = None,
+    ) -> InferenceEndpoint:
+        """Update an Inference Endpoint.
+
+        This method allows the update of either the compute configuration, the deployed model, or both. All arguments are
+        optional but at least one must be provided.
+
+        For convenience, you can also update an Inference Endpoint using [`InferenceEndpoint.update`].
+
+        Args:
+            name (`str`):
+                The name of the Inference Endpoint to update.
+
+            accelerator (`str`, *optional*):
+                The hardware accelerator to be used for inference (e.g. `"cpu"`).
+            instance_size (`str`, *optional*):
+                The size or type of the instance to be used for hosting the model (e.g. `"large"`).
+            instance_type (`str`, *optional*):
+                The cloud instance type where the Inference Endpoint will be deployed (e.g. `"c6i"`).
+            min_replica (`int`, *optional*):
+                The minimum number of replicas (instances) to keep running for the Inference Endpoint.
+            max_replica (`int`, *optional*):
+                The maximum number of replicas (instances) to scale to for the Inference Endpoint.
+
+            repository (`str`, *optional*):
+                The name of the model repository associated with the Inference Endpoint (e.g. `"gpt2"`).
+            framework (`str`, *optional*):
+                The machine learning framework used for the model (e.g. `"custom"`).
+            revision (`str`, *optional*):
+                The specific model revision to deploy on the Inference Endpoint (e.g. `"6c0e6080953db56375760c0471a8c5f2929baf11"`).
+            task (`str`, *optional*):
+                The task on which to deploy the model (e.g. `"text-classification"`).
+
+            namespace (`str`, *optional*):
+                The namespace where the Inference Endpoint will be updated. Defaults to the current user's namespace.
+            token (`str`, *optional*):
+                An authentication token (See https://huggingface.co/settings/token).
+
+        Returns:
+            [`InferenceEndpoint`]: information about the updated Inference Endpoint.
+        """
+        namespace = namespace or self._get_namespace(token=token)
+
+        payload: Dict = {}
+        if any(value is not None for value in (accelerator, instance_size, instance_type, min_replica, max_replica)):
+            payload["compute"] = {
+                "accelerator": accelerator,
+                "instanceSize": instance_size,
+                "instanceType": instance_type,
+                "scaling": {
+                    "maxReplica": max_replica,
+                    "minReplica": min_replica,
+                },
+            }
+        if any(value is not None for value in (repository, framework, revision, task)):
+            payload["model"] = {
+                "framework": framework,
+                "repository": repository,
+                "revision": revision,
+                "task": task,
+                "image": {"huggingface": {}},
+            }
+
+        response = get_session().put(
+            f"{INFERENCE_ENDPOINTS_ENDPOINT}/endpoint/{namespace}/{name}",
+            headers=self._build_hf_headers(token=token),
+            json=payload,
+        )
+        hf_raise_for_status(response)
+
+        return InferenceEndpoint.from_raw(response.json(), namespace=namespace, token=token)
+
+    def delete_inference_endpoint(
+        self, name: str, *, namespace: Optional[str] = None, token: Optional[str] = None
+    ) -> None:
+        """Delete an Inference Endpoint.
+
+        This operation is not reversible. If you don't want to be charged for an Inference Endpoint, it is preferable
+        to pause it with [`pause_inference_endpoint`] or scale it to zero with [`scale_to_zero_inference_endpoint`].
+
+        For convenience, you can also delete an Inference Endpoint using [`InferenceEndpoint.delete`].
+
+        Args:
+            name (`str`):
+                The name of the Inference Endpoint to delete.
+            namespace (`str`, *optional*):
+                The namespace in which the Inference Endpoint is located. Defaults to the current user.
+            token (`str`, *optional*):
+                An authentication token (See https://huggingface.co/settings/token).
+        """
+        namespace = namespace or self._get_namespace(token=token)
+        response = get_session().delete(
+            f"{INFERENCE_ENDPOINTS_ENDPOINT}/endpoint/{namespace}/{name}",
+            headers=self._build_hf_headers(token=token),
+        )
+        hf_raise_for_status(response)
+
+    def pause_inference_endpoint(
+        self, name: str, *, namespace: Optional[str] = None, token: Optional[str] = None
+    ) -> InferenceEndpoint:
+        """Pause an Inference Endpoint.
+
+        A paused Inference Endpoint will not be charged. It can be resumed at any time using [`resume_inference_endpoint`].
+        This is different than scaling the Inference Endpoint to zero with [`scale_to_zero_inference_endpoint`], which
+        would be automatically restarted when a request is made to it.
+
+        For convenience, you can also pause an Inference Endpoint using [`pause_inference_endpoint`].
+
+        Args:
+            name (`str`):
+                The name of the Inference Endpoint to pause.
+            namespace (`str`, *optional*):
+                The namespace in which the Inference Endpoint is located. Defaults to the current user.
+            token (`str`, *optional*):
+                An authentication token (See https://huggingface.co/settings/token).
+
+        Returns:
+            [`InferenceEndpoint`]: information about the paused Inference Endpoint.
+        """
+        namespace = namespace or self._get_namespace(token=token)
+
+        response = get_session().post(
+            f"{INFERENCE_ENDPOINTS_ENDPOINT}/endpoint/{namespace}/{name}/pause",
+            headers=self._build_hf_headers(token=token),
+        )
+        hf_raise_for_status(response)
+
+        return InferenceEndpoint.from_raw(response.json(), namespace=namespace, token=token)
+
+    def resume_inference_endpoint(
+        self, name: str, *, namespace: Optional[str] = None, token: Optional[str] = None
+    ) -> InferenceEndpoint:
+        """Resume an Inference Endpoint.
+
+        For convenience, you can also resume an Inference Endpoint using [`InferenceEndpoint.resume`].
+
+        Args:
+            name (`str`):
+                The name of the Inference Endpoint to resume.
+            namespace (`str`, *optional*):
+                The namespace in which the Inference Endpoint is located. Defaults to the current user.
+            token (`str`, *optional*):
+                An authentication token (See https://huggingface.co/settings/token).
+
+        Returns:
+            [`InferenceEndpoint`]: information about the resumed Inference Endpoint.
+        """
+        namespace = namespace or self._get_namespace(token=token)
+
+        response = get_session().post(
+            f"{INFERENCE_ENDPOINTS_ENDPOINT}/endpoint/{namespace}/{name}/resume",
+            headers=self._build_hf_headers(token=token),
+        )
+        hf_raise_for_status(response)
+
+        return InferenceEndpoint.from_raw(response.json(), namespace=namespace, token=token)
+
+    def scale_to_zero_inference_endpoint(
+        self, name: str, *, namespace: Optional[str] = None, token: Optional[str] = None
+    ) -> InferenceEndpoint:
+        """Scale Inference Endpoint to zero.
+
+        An Inference Endpoint scaled to zero will not be charged. It will be resume on the next request to it, with a
+        cold start delay. This is different than pausing the Inference Endpoint with [`pause_inference_endpoint`], which
+        would require a manual resume with [`resume_inference_endpoint`].
+
+        For convenience, you can also scale an Inference Endpoint to zero using [`InferenceEndpoint.scale_to_zero`].
+
+        Args:
+            name (`str`):
+                The name of the Inference Endpoint to scale to zero.
+            namespace (`str`, *optional*):
+                The namespace in which the Inference Endpoint is located. Defaults to the current user.
+            token (`str`, *optional*):
+                An authentication token (See https://huggingface.co/settings/token).
+
+        Returns:
+            [`InferenceEndpoint`]: information about the scaled-to-zero Inference Endpoint.
+        """
+        namespace = namespace or self._get_namespace(token=token)
+
+        response = get_session().post(
+            f"{INFERENCE_ENDPOINTS_ENDPOINT}/endpoint/{namespace}/{name}/scale-to-zero",
+            headers=self._build_hf_headers(token=token),
+        )
+        hf_raise_for_status(response)
+
+        return InferenceEndpoint.from_raw(response.json(), namespace=namespace, token=token)
+
+    def _get_namespace(self, token: Optional[str] = None) -> str:
+        """Get the default namespace for the current user."""
+        me = self.whoami(token=token)
+        if me["type"] == "user":
+            return me["name"]
+        else:
+            raise ValueError(
+                "Cannot determine default namespace. You must provide a 'namespace' as input or be logged in as a"
+                " user."
+            )
+
     ########################
     # Collection Endpoints #
     ########################
@@ -6027,21 +6573,20 @@ class HfApi:
         >>> len(collection.items)
         37
         >>> collection.items[0]
-        CollectionItem: {
-            {'item_object_id': '6507f6d5423b46492ee1413e',
-            'item_id': 'TheBloke/TigerBot-70B-Chat-GPTQ',
-            'author': 'TheBloke',
-            'item_type': 'model',
-            'lastModified': '2023-09-19T12:55:21.000Z',
-            (...)
-        }}
+        CollectionItem(
+            item_object_id='651446103cd773a050bf64c2',
+            item_id='TheBloke/U-Amethyst-20B-AWQ',
+            item_type='model',
+            position=88,
+            note=None
+        )
         ```
         """
         r = get_session().get(
             f"{self.endpoint}/api/collections/{collection_slug}", headers=self._build_hf_headers(token=token)
         )
         hf_raise_for_status(r)
-        return Collection(r.json(), endpoint=self.endpoint)
+        return Collection(**{**r.json(), "endpoint": self.endpoint})
 
     def create_collection(
         self,
@@ -6106,7 +6651,7 @@ class HfApi:
                 return self.get_collection(slug, token=token)
             else:
                 raise
-        return Collection(r.json(), endpoint=self.endpoint)
+        return Collection(**{**r.json(), "endpoint": self.endpoint})
 
     def update_collection_metadata(
         self,
@@ -6171,7 +6716,7 @@ class HfApi:
             json={key: value for key, value in payload.items() if value is not None},
         )
         hf_raise_for_status(r)
-        return Collection(r.json()["data"], endpoint=self.endpoint)
+        return Collection(**{**r.json()["data"], "endpoint": self.endpoint})
 
     def delete_collection(
         self, collection_slug: str, *, missing_ok: bool = False, token: Optional[str] = None
@@ -6279,7 +6824,7 @@ class HfApi:
                 return self.get_collection(collection_slug, token=token)
             else:
                 raise
-        return Collection(r.json(), endpoint=self.endpoint)
+        return Collection(**{**r.json(), "endpoint": self.endpoint})
 
     def update_collection_item(
         self,
@@ -6297,7 +6842,7 @@ class HfApi:
                 Slug of the collection to update. Example: `"TheBloke/recent-models-64f9a55bb3115b4f513ec026"`.
             item_object_id (`str`):
                 ID of the item in the collection. This is not the id of the item on the Hub (repo_id or paper id).
-                It must be retrieved from a [`CollectionItem`] object. Example: `collection.items[0]._id`.
+                It must be retrieved from a [`CollectionItem`] object. Example: `collection.items[0].item_object_id`.
             note (`str`, *optional*):
                 A note to attach to the item in the collection. The maximum size for a note is 500 characters.
             position (`int`, *optional*):
@@ -6575,6 +7120,16 @@ duplicate_space = api.duplicate_space
 request_space_storage = api.request_space_storage
 delete_space_storage = api.delete_space_storage
 
+# Inference Endpoint API
+list_inference_endpoints = api.list_inference_endpoints
+create_inference_endpoint = api.create_inference_endpoint
+get_inference_endpoint = api.get_inference_endpoint
+update_inference_endpoint = api.update_inference_endpoint
+delete_inference_endpoint = api.delete_inference_endpoint
+pause_inference_endpoint = api.pause_inference_endpoint
+resume_inference_endpoint = api.resume_inference_endpoint
+scale_to_zero_inference_endpoint = api.scale_to_zero_inference_endpoint
+
 # Collections API
 get_collection = api.get_collection
 create_collection = api.create_collection