huggingface-hub 0.12.1__py3-none-any.whl → 0.13.0rc0__py3-none-any.whl

huggingface_hub/hf_api.py

@@ -13,19 +13,22 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 import json
-import os
+import pprint
 import re
+import textwrap
 import warnings
 from dataclasses import dataclass, field
+from datetime import datetime
 from itertools import islice
 from pathlib import Path
 from typing import Any, BinaryIO, Dict, Iterable, Iterator, List, Optional, Tuple, Union
 from urllib.parse import quote
 
 import requests
-from huggingface_hub.utils import EntryNotFoundError, RepositoryNotFoundError
 from requests.exceptions import HTTPError
 
+from huggingface_hub.utils import EntryNotFoundError, RepositoryNotFoundError
+
 from ._commit_api import (
     CommitOperation,
     CommitOperationAdd,
@@ -90,9 +93,18 @@ _REGEX_DISCUSSION_URL = re.compile(r".*/discussions/(\d+)$")
 logger = logging.get_logger(__name__)
 
 
-def repo_type_and_id_from_hf_id(
-    hf_id: str, hub_url: Optional[str] = None
-) -> Tuple[Optional[str], Optional[str], str]:
+class ReprMixin:
+    """Mixin to create the __repr__ for a class"""
+
+    def __repr__(self):
+        formatted_value = pprint.pformat(self.__dict__, width=119, compact=True, sort_dicts=False)
+        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
     repository
@@ -139,6 +151,10 @@ def repo_type_and_id_from_hf_id(
             namespace = None
         if len(url_segments) > 2 and hub_url not in url_segments[-3]:
             repo_type = url_segments[-3]
+        elif namespace in REPO_TYPES_MAPPING:
+            # Mean canonical dataset or model
+            repo_type = REPO_TYPES_MAPPING[namespace]
+            namespace = None
         else:
             repo_type = None
     elif is_hf_id:
@@ -146,17 +162,21 @@ def repo_type_and_id_from_hf_id(
             # Passed <repo_type>/<user>/<model_id> or <repo_type>/<org>/<model_id>
             repo_type, namespace, repo_id = url_segments[-3:]
         elif len(url_segments) == 2:
-            # Passed <user>/<model_id> or <org>/<model_id>
-            namespace, repo_id = hf_id.split("/")[-2:]
-            repo_type = None
+            if url_segments[0] in REPO_TYPES_MAPPING:
+                # Passed '<model_id>' or 'datasets/<dataset_id>' for a canonical model or dataset
+                repo_type = REPO_TYPES_MAPPING[url_segments[0]]
+                namespace = None
+                repo_id = hf_id.split("/")[-1]
+            else:
+                # Passed <user>/<model_id> or <org>/<model_id>
+                namespace, repo_id = hf_id.split("/")[-2:]
+                repo_type = None
         else:
             # Passed <model_id>
             repo_id = url_segments[0]
             namespace, repo_type = None, None
     else:
-        raise ValueError(
-            f"Unable to retrieve user and repo ID from the passed HF ID: {hf_id}"
-        )
+        raise ValueError(f"Unable to retrieve user and repo ID from the passed HF ID: {hf_id}")
 
     # Check if repo type is known (mapping "spaces" => "space" + empty value => `None`)
     if repo_type in REPO_TYPES_MAPPING:
@@ -237,6 +257,7 @@ class RepoUrl(str):
     compatibility. At initialization, the URL is parsed to populate properties:
     - endpoint (`str`)
     - namespace (`Optional[str]`)
+    - repo_name (`str`)
     - repo_id (`str`)
     - repo_type (`Literal["model", "dataset", "space"]`)
     - url (`str`)
@@ -276,24 +297,20 @@ class RepoUrl(str):
         super().__init__()
         # Parse URL
         self.endpoint = endpoint or ENDPOINT
-        repo_type, namespace, repo_name = repo_type_and_id_from_hf_id(
-            self, hub_url=self.endpoint
-        )
+        repo_type, namespace, repo_name = repo_type_and_id_from_hf_id(self, hub_url=self.endpoint)
 
         # Populate fields
         self.namespace = namespace
+        self.repo_name = repo_name
         self.repo_id = repo_name if namespace is None else f"{namespace}/{repo_name}"
         self.repo_type = repo_type or REPO_TYPE_MODEL
         self.url = str(self)  # just in case it's needed
 
     def __repr__(self) -> str:
-        return (
-            f"RepoUrl('{self}', endpoint='{self.endpoint}',"
-            f" repo_type='{self.repo_type}', repo_id='{self.repo_id}')"
-        )
+        return f"RepoUrl('{self}', endpoint='{self.endpoint}', repo_type='{self.repo_type}', repo_id='{self.repo_id}')"
 
 
-class RepoFile:
+class RepoFile(ReprMixin):
     """
     Data structure that represents a public file inside a repo, accessible from
     huggingface.co
@@ -334,12 +351,8 @@ class RepoFile:
         for k, v in kwargs.items():
             setattr(self, k, v)
 
-    def __repr__(self):
-        items = (f"{k}='{v}'" for k, v in self.__dict__.items())
-        return f"{self.__class__.__name__}({', '.join(items)})"
-
 
-class ModelInfo:
+class ModelInfo(ReprMixin):
     """
     Info about a model accessible from huggingface.co
 
@@ -389,9 +402,7 @@ class ModelInfo:
         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.siblings = [RepoFile(**x) for x in siblings] if siblings is not None else []
         self.private = private
         self.author = author
         self.config = config
@@ -399,12 +410,6 @@ class ModelInfo:
         for k, v in kwargs.items():
             setattr(self, k, v)
 
-    def __repr__(self):
-        s = f"{self.__class__.__name__}:" + " {"
-        for key, val in self.__dict__.items():
-            s += f"\n\t{key}: {val}"
-        return s + "\n}"
-
     def __str__(self):
         r = f"Model Name: {self.modelId}, Tags: {self.tags}"
         if self.pipeline_tag:
@@ -412,7 +417,7 @@ class ModelInfo:
         return r
 
 
-class DatasetInfo:
+class DatasetInfo(ReprMixin):
     """
     Info about a dataset accessible from huggingface.co
 
@@ -423,7 +428,7 @@ class DatasetInfo:
             repo sha at this particular revision
         lastModified (`str`, *optional*):
             date of last commit to repo
-        tags (`Listr[str]`, *optional*):
+        tags (`List[str]`, *optional*):
             List of tags.
         siblings (`List[RepoFile]`, *optional*):
             list of [`huggingface_hub.hf_api.RepoFile`] objects that constitute the dataset.
@@ -465,9 +470,7 @@ class DatasetInfo:
         self.description = description
         self.citation = citation
         self.cardData = cardData
-        self.siblings = (
-            [RepoFile(**x) for x in siblings] if siblings is not None else []
-        )
+        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)
@@ -475,18 +478,12 @@ class DatasetInfo:
         for k, v in kwargs.items():
             setattr(self, k, v)
 
-    def __repr__(self):
-        s = f"{self.__class__.__name__}:" + " {"
-        for key, val in self.__dict__.items():
-            s += f"\n\t{key}: {val}"
-        return s + "\n}"
-
     def __str__(self):
         r = f"Dataset Name: {self.id}, Tags: {self.tags}"
         return r
 
 
-class SpaceInfo:
+class SpaceInfo(ReprMixin):
     """
     Info about a Space accessible from huggingface.co
 
@@ -524,22 +521,14 @@ class SpaceInfo:
         self.id = id
         self.sha = sha
         self.lastModified = lastModified
-        self.siblings = (
-            [RepoFile(**x) for x in siblings] if siblings is not None else []
-        )
+        self.siblings = [RepoFile(**x) for x in siblings] if siblings is not None else []
         self.private = private
         self.author = author
         for k, v in kwargs.items():
             setattr(self, k, v)
 
-    def __repr__(self):
-        s = f"{self.__class__.__name__}:" + " {"
-        for key, val in self.__dict__.items():
-            s += f"\n\t{key}: {val}"
-        return s + "\n}"
-
 
-class MetricInfo:
+class MetricInfo(ReprMixin):
     """
     Info about a public metric accessible from huggingface.co
     """
@@ -562,12 +551,6 @@ class MetricInfo:
         for k, v in kwargs.items():
             setattr(self, k, v)
 
-    def __repr__(self):
-        s = f"{self.__class__.__name__}:" + " {"
-        for key, val in self.__dict__.items():
-            s += f"\n\t{key}: {val}"
-        return s + "\n}"
-
     def __str__(self):
         r = f"Metric Name: {self.id}"
         return r
@@ -719,6 +702,49 @@ class GitRefs:
     tags: List[GitRefInfo]
 
 
+@dataclass
+class GitCommitInfo:
+    """
+    Contains information about a git commit for a repo on the Hub. Check out [`list_repo_commits`] for more details.
+
+    Args:
+        commit_id (`str`):
+            OID of the commit (e.g. `"e7da7f221d5bf496a48136c0cd264e630fe9fcc8"`)
+        authors (`List[str]`):
+            List of authors of the commit.
+        created_at (`datetime`):
+            Datetime when the commit was created.
+        title (`str`):
+            Title of the commit. This is a free-text value entered by the authors.
+        message (`str`):
+            Description of the commit. This is a free-text value entered by the authors.
+        formatted_title (`str`):
+            Title of the commit formatted as HTML. Only returned if `formatted=True` is set.
+        formatted_message (`str`):
+            Description of the commit formatted as HTML. Only returned if `formatted=True` is set.
+    """
+
+    commit_id: str
+
+    authors: List[str]
+    created_at: datetime
+    title: str
+    message: str
+
+    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:
     """
@@ -1030,10 +1056,7 @@ class HfApi:
 
         if emissions_thresholds is not None:
             if cardData is None:
-                raise ValueError(
-                    "`emissions_thresholds` were passed without setting"
-                    " `cardData=True`."
-                )
+                raise ValueError("`emissions_thresholds` were passed without setting `cardData=True`.")
             else:
                 return _filter_emissions(items, *emissions_thresholds)
 
@@ -1058,11 +1081,7 @@ class HfApi:
 
         # Handling tasks
         if model_filter.task is not None:
-            filter_list.extend(
-                [model_filter.task]
-                if isinstance(model_filter.task, str)
-                else model_filter.task
-            )
+            filter_list.extend([model_filter.task] if isinstance(model_filter.task, str) else model_filter.task)
 
         # Handling dataset
         if model_filter.trained_dataset is not None:
@@ -1076,18 +1095,12 @@ class HfApi:
         # Handling library
         if model_filter.library:
             filter_list.extend(
-                [model_filter.library]
-                if isinstance(model_filter.library, str)
-                else model_filter.library
+                [model_filter.library] if isinstance(model_filter.library, str) else model_filter.library
             )
 
         # Handling tags
         if model_filter.tags:
-            tags.extend(
-                [model_filter.tags]
-                if isinstance(model_filter.tags, str)
-                else model_filter.tags
-            )
+            tags.extend([model_filter.tags] if isinstance(model_filter.tags, str) else model_filter.tags)
 
         query_dict: Dict[str, Any] = {}
         if model_str is not None:
@@ -1520,8 +1533,7 @@ class HfApi:
                 user = me["name"]
             else:
                 raise ValueError(
-                    "Cannot list liked repos. You must provide a 'user' as input or be"
-                    " logged in as a user."
+                    "Cannot list liked repos. You must provide a 'user' as input or be logged in as a user."
                 )
 
         path = f"{self.endpoint}/api/users/{user}/likes"
@@ -1540,21 +1552,9 @@ class HfApi:
         return UserLikes(
             user=user,
             total=len(likes),
-            models=[
-                like["repo"]["name"]
-                for like in likes
-                if like["repo"]["type"] == "model"
-            ],
-            datasets=[
-                like["repo"]["name"]
-                for like in likes
-                if like["repo"]["type"] == "dataset"
-            ],
-            spaces=[
-                like["repo"]["name"]
-                for like in likes
-                if like["repo"]["type"] == "space"
-            ],
+            models=[like["repo"]["name"] for like in likes if like["repo"]["type"] == "model"],
+            datasets=[like["repo"]["name"] for like in likes if like["repo"]["type"] == "dataset"],
+            spaces=[like["repo"]["name"] for like in likes if like["repo"]["type"] == "space"],
         )
 
     @validate_hf_hub_args
@@ -1613,9 +1613,7 @@ class HfApi:
         path = (
             f"{self.endpoint}/api/models/{repo_id}"
             if revision is None
-            else (
-                f"{self.endpoint}/api/models/{repo_id}/revision/{quote(revision, safe='')}"
-            )
+            else (f"{self.endpoint}/api/models/{repo_id}/revision/{quote(revision, safe='')}")
         )
         params = {}
         if securityStatus:
@@ -1679,9 +1677,7 @@ class HfApi:
         path = (
             f"{self.endpoint}/api/datasets/{repo_id}"
             if revision is None
-            else (
-                f"{self.endpoint}/api/datasets/{repo_id}/revision/{quote(revision, safe='')}"
-            )
+            else (f"{self.endpoint}/api/datasets/{repo_id}/revision/{quote(revision, safe='')}")
         )
         params = {}
         if files_metadata:
@@ -1744,9 +1740,7 @@ class HfApi:
         path = (
             f"{self.endpoint}/api/spaces/{repo_id}"
             if revision is None
-            else (
-                f"{self.endpoint}/api/spaces/{repo_id}/revision/{quote(revision, safe='')}"
-            )
+            else (f"{self.endpoint}/api/spaces/{repo_id}/revision/{quote(revision, safe='')}")
         )
         params = {}
         if files_metadata:
@@ -1778,6 +1772,9 @@ class HfApi:
             revision (`str`, *optional*):
                 The revision of the repository from which to get the
                 information.
+            repo_type (`str`, *optional*):
+                Set to `"dataset"` or `"space"` if getting repository info from a dataset or a space,
+                `None` or `"model"` if getting repository info from a model. Default is `None`.
             timeout (`float`, *optional*):
                 Whether to set a timeout for the request to the Hub.
             files_metadata (`bool`, *optional*):
@@ -1857,6 +1854,7 @@ class HfApi:
         Returns:
             `List[str]`: the list of files in a given repository.
         """
+        # TODO: use https://huggingface.co/api/{repo_type}/{repo_id}/tree/{revision}/{subfolder}
         repo_info = self.repo_info(
             repo_id,
             revision=revision,
@@ -1927,6 +1925,84 @@ class HfApi:
             tags=[GitRefInfo(item) for item in data["tags"]],
         )
 
+    @validate_hf_hub_args
+    def list_repo_commits(
+        self,
+        repo_id: str,
+        *,
+        repo_type: Optional[str] = None,
+        token: Optional[Union[bool, str]] = None,
+        revision: Optional[str] = None,
+        formatted: bool = False,
+    ) -> List[GitCommitInfo]:
+        """
+        Get the list of commits of a given revision for a repo on the Hub.
+
+        Commits are sorted by date (last commit first).
+
+        Args:
+            repo_id (`str`):
+                A namespace (user or an organization) and a repo name separated by a `/`.
+            repo_type (`str`, *optional*):
+                Set to `"dataset"` or `"space"` if listing commits from a dataset or a Space, `None` or `"model"` if
+                listing from a model. Default is `None`.
+            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.
+            revision (`str`, *optional*):
+                The git revision to commit from. Defaults to the head of the `"main"` branch.
+            formatted (`bool`):
+                Whether to return the HTML-formatted title and description of the commits. Defaults to False.
+
+        Example:
+        ```py
+        >>> from huggingface_hub import HfApi
+        >>> api = HfApi()
+
+        # Commits are sorted by date (last commit first)
+        >>> initial_commit = api.list_repo_commits("gpt2")[-1]
+
+        # Initial commit is always a system commit containing the `.gitattributes` file.
+        >>> initial_commit
+        GitCommitInfo(
+            commit_id='9b865efde13a30c13e0a33e536cf3e4a5a9d71d8',
+            authors=['system'],
+            created_at=datetime.datetime(2019, 2, 18, 10, 36, 15, tzinfo=datetime.timezone.utc),
+            title='initial commit',
+            message='',
+            formatted_title=None,
+            formatted_message=None
+        )
+
+        # Create an empty branch by deriving from initial commit
+        >>> api.create_branch("gpt2", "new_empty_branch", revision=initial_commit.commit_id)
+        ```
+
+        Returns:
+            List[[`GitCommitInfo`]]: list of objects containing information about the commits for a repo on the Hub.
+
+        Raises:
+            [`~utils.RepositoryNotFoundError`]:
+                If repository is not found (error 404): wrong repo_id/repo_type, private but not authenticated or repo
+                does not exist.
+            [`~utils.RevisionNotFoundError`]:
+                If revision is not found (error 404) on the repo.
+        """
+        repo_type = repo_type or REPO_TYPE_MODEL
+        revision = quote(revision, safe="") if revision is not None else DEFAULT_REVISION
+
+        # Paginate over results and return the list of commits.
+        return [
+            GitCommitInfo(item)
+            for item in paginate(
+                f"{self.endpoint}/api/{repo_type}s/{repo_id}/commits/{revision}",
+                headers=self._build_hf_headers(token=token),
+                params={"expand[]": "formatted"} if formatted else {},
+            )
+        ]
+
     @validate_hf_hub_args
     def create_repo(
         self,
@@ -1981,23 +2057,17 @@ class HfApi:
                     f" of {SPACES_SDK_TYPES} when repo_type is 'space'`"
                 )
             if space_sdk not in SPACES_SDK_TYPES:
-                raise ValueError(
-                    f"Invalid space_sdk. Please choose one of {SPACES_SDK_TYPES}."
-                )
+                raise ValueError(f"Invalid space_sdk. Please choose one of {SPACES_SDK_TYPES}.")
             json["sdk"] = space_sdk
 
         if space_sdk is not None and repo_type != "space":
-            warnings.warn(
-                "Ignoring provided space_sdk because repo_type is not 'space'."
-            )
+            warnings.warn("Ignoring provided space_sdk because repo_type is not 'space'.")
 
         if space_hardware is not None:
             if repo_type == "space":
                 json["hardware"] = space_hardware
             else:
-                warnings.warn(
-                    "Ignoring provided space_hardware because repo_type is not 'space'."
-                )
+                warnings.warn("Ignoring provided space_hardware because repo_type is not 'space'.")
 
         if getattr(self, "_lfsmultipartthresh", None):
             # Testing purposes only.
@@ -2012,6 +2082,15 @@ class HfApi:
             if exist_ok and err.response.status_code == 409:
                 # Repo already exists and `exist_ok=True`
                 pass
+            elif exist_ok and err.response.status_code == 403:
+                # No write permission on the namespace but repo might already exist
+                try:
+                    self.repo_info(repo_id=repo_id, repo_type=repo_type, token=token)
+                    if repo_type is None or repo_type == REPO_TYPE_MODEL:
+                        return RepoUrl(f"{self.endpoint}/{repo_id}")
+                    return RepoUrl(f"{self.endpoint}/{repo_type}/{repo_id}")
+                except HfHubHTTPError:
+                    raise
             else:
                 raise
 
@@ -2164,16 +2243,10 @@ class HfApi:
         </Tip>
         """
         if len(from_id.split("/")) != 2:
-            raise ValueError(
-                f"Invalid repo_id: {from_id}. It should have a namespace"
-                " (:namespace:/:repo_name:)"
-            )
+            raise ValueError(f"Invalid repo_id: {from_id}. It should have a namespace (:namespace:/:repo_name:)")
 
         if len(to_id.split("/")) != 2:
-            raise ValueError(
-                f"Invalid repo_id: {to_id}. It should have a namespace"
-                " (:namespace:/:repo_name:)"
-            )
+            raise ValueError(f"Invalid repo_id: {to_id}. It should have a namespace (:namespace:/:repo_name:)")
 
         if repo_type is None:
             repo_type = REPO_TYPE_MODEL  # Hub won't accept `None`.
@@ -2298,22 +2371,17 @@ class HfApi:
 
         if parent_commit is not None and not REGEX_COMMIT_OID.fullmatch(parent_commit):
             raise ValueError(
-                "`parent_commit` is not a valid commit OID. It must match the"
-                f" following regex: {REGEX_COMMIT_OID}"
+                f"`parent_commit` is not a valid commit OID. It must match the following regex: {REGEX_COMMIT_OID}"
             )
 
         if commit_message is None or len(commit_message) == 0:
             raise ValueError("`commit_message` can't be empty, please pass a value.")
 
-        commit_description = (
-            commit_description if commit_description is not None else ""
-        )
+        commit_description = commit_description if commit_description is not None else ""
         repo_type = repo_type if repo_type is not None else REPO_TYPE_MODEL
         if repo_type not in REPO_TYPES:
             raise ValueError(f"Invalid repo type, must be one of {REPO_TYPES}")
-        revision = (
-            quote(revision, safe="") if revision is not None else DEFAULT_REVISION
-        )
+        revision = quote(revision, safe="") if revision is not None else DEFAULT_REVISION
         create_pr = create_pr if create_pr is not None else False
 
         operations = list(operations)
@@ -2321,10 +2389,7 @@ class HfApi:
         nb_additions = len(additions)
         nb_deletions = len(operations) - nb_additions
 
-        logger.debug(
-            f"About to commit to the hub: {len(additions)} addition(s) and"
-            f" {nb_deletions} deletion(s)."
-        )
+        logger.debug(f"About to commit to the hub: {len(additions)} addition(s) and {nb_deletions} deletion(s).")
 
         # If updating twice the same file or update then delete a file in a single commit
         warn_on_overwriting_operations(operations)
@@ -2344,11 +2409,7 @@ class HfApi:
             raise
 
         upload_lfs_files(
-            additions=[
-                addition
-                for addition in additions
-                if upload_modes[addition.path_in_repo] == "lfs"
-            ],
+            additions=[addition for addition in additions if upload_modes[addition.path_in_repo] == "lfs"],
             repo_type=repo_type,
             repo_id=repo_id,
             token=token or self.token,
@@ -2374,14 +2435,11 @@ class HfApi:
             "Content-Type": "application/x-ndjson",
             **self._build_hf_headers(token=token, is_write_action=True),
         }
+        data = b"".join(_payload_as_ndjson())
+        params = {"create_pr": "1"} if create_pr else None
 
         try:
-            commit_resp = requests.post(
-                url=commit_url,
-                headers=headers,
-                data=_payload_as_ndjson(),  # type: ignore
-                params={"create_pr": "1"} if create_pr else None,
-            )
+            commit_resp = requests.post(url=commit_url, headers=headers, data=data, params=params)
             hf_raise_for_status(commit_resp, endpoint_name="commit")
         except RepositoryNotFoundError as e:
             e.append_to_message(_CREATE_COMMIT_NO_REPO_ERROR_MESSAGE)
@@ -2525,9 +2583,7 @@ class HfApi:
             raise ValueError(f"Invalid repo type, must be one of {REPO_TYPES}")
 
         commit_message = (
-            commit_message
-            if commit_message is not None
-            else f"Upload {path_in_repo} with huggingface_hub"
+            commit_message if commit_message is not None else f"Upload {path_in_repo} with huggingface_hub"
         )
         operation = CommitOperationAdd(
             path_or_fileobj=path_or_fileobj,
@@ -2570,21 +2626,25 @@ class HfApi:
         parent_commit: Optional[str] = None,
         allow_patterns: Optional[Union[List[str], str]] = None,
         ignore_patterns: Optional[Union[List[str], str]] = None,
+        delete_patterns: Optional[Union[List[str], str]] = None,
     ):
         """
-        Upload a local folder to the given repo. The upload is done
-        through a HTTP requests, and doesn't require git or git-lfs to be
-        installed.
+        Upload a local folder to the given repo. The upload is done through a HTTP request and doesn't require git or
+        git-lfs to be installed.
+
+        The structure of the folder will be preserved. Files with the same name already present in the repository will
+        be overwritten. Others will be left untouched.
 
-        The structure of the folder will be preserved. Files with the same name
-        already present in the repository will be overwritten, others will be left untouched.
+        Use the `allow_patterns` and `ignore_patterns` arguments to specify which files to upload. These parameters
+        accept either a single pattern or a list of patterns. Patterns are Standard Wildcards (globbing patterns) as
+        documented [here](https://tldp.org/LDP/GNU-Linux-Tools-Summary/html/x11655.htm). If both `allow_patterns` and
+        `ignore_patterns` are provided, both constraints apply. By default, all files from the folder are uploaded.
 
-        Use the `allow_patterns` and `ignore_patterns` arguments to specify which files
-        to upload. These parameters accept either a single pattern or a list of
-        patterns. Patterns are Standard Wildcards (globbing patterns) as documented
-        [here](https://tldp.org/LDP/GNU-Linux-Tools-Summary/html/x11655.htm). If both
-        `allow_patterns` and `ignore_patterns` are provided, both constraints apply. By
-        default, all files from the folder are uploaded.
+        Use the `delete_patterns` argument to specify remote files you want to delete. Input type is the same as for
+        `allow_patterns` (see above). If `path_in_repo` is also provided, the patterns are matched against paths
+        relative to this folder. For example, `upload_folder(..., path_in_repo="experiment", delete_patterns="logs/*")`
+        will delete any remote file under `experiment/logs/`. Note that the `.gitattributes` file will not be deleted
+        even if it matches the patterns.
 
         Uses `HfApi.create_commit` under the hood.
 
@@ -2627,6 +2687,10 @@ class HfApi:
                 If provided, only files matching at least one pattern are uploaded.
             ignore_patterns (`List[str]` or `str`, *optional*):
                 If provided, files matching any of the patterns are not uploaded.
+            delete_patterns (`List[str]` or `str`, *optional*):
+                If provided, remote files matching any of the patterns will be deleted from the repo while committing
+                new files. This is useful if you don't know which files have already been uploaded.
+                Note: to avoid discrepancies the `.gitattributes` file is not deleted even if it matches the pattern.
 
         Returns:
             `str`: A URL to visualize the uploaded folder on the hub
@@ -2644,16 +2708,16 @@ class HfApi:
 
         <Tip warning={true}>
 
-        `upload_folder` assumes that the repo already exists on the Hub. If you get a
-        Client error 404, please make sure you are authenticated and that `repo_id` and
-        `repo_type` are set correctly. If repo does not exist, create it first using
-        [`~hf_api.create_repo`].
+        `upload_folder` assumes that the repo already exists on the Hub. If you get a Client error 404, please make
+        sure you are authenticated and that `repo_id` and `repo_type` are set correctly. If repo does not exist, create
+        it first using [`~hf_api.create_repo`].
 
         </Tip>
 
         Example:
 
         ```python
+        # Upload checkpoints folder except the log files
         >>> upload_folder(
         ...     folder_path="local/checkpoints",
         ...     path_in_repo="remote/experiment/checkpoints",
@@ -2664,6 +2728,19 @@ class HfApi:
         ... )
         # "https://huggingface.co/datasets/username/my-dataset/tree/main/remote/experiment/checkpoints"
 
+        # Upload checkpoints folder including logs while deleting existing logs from the repo
+        # Useful if you don't know exactly which log files have already being pushed
+        >>> upload_folder(
+        ...     folder_path="local/checkpoints",
+        ...     path_in_repo="remote/experiment/checkpoints",
+        ...     repo_id="username/my-dataset",
+        ...     repo_type="datasets",
+        ...     token="my_token",
+        ...     delete_patterns="**/logs/*.txt",
+        ... )
+        "https://huggingface.co/datasets/username/my-dataset/tree/main/remote/experiment/checkpoints"
+
+        # Upload checkpoints folder while creating a PR
         >>> upload_folder(
         ...     folder_path="local/checkpoints",
         ...     path_in_repo="remote/experiment/checkpoints",
@@ -2684,22 +2761,36 @@ class HfApi:
             path_in_repo = ""
 
         commit_message = (
-            commit_message
-            if commit_message is not None
-            else f"Upload {path_in_repo} with huggingface_hub"
+            commit_message if commit_message is not None else f"Upload {path_in_repo} with huggingface_hub"
         )
 
-        files_to_add = _prepare_upload_folder_commit(
+        delete_operations = self._prepare_upload_folder_deletions(
+            repo_id=repo_id,
+            repo_type=repo_type,
+            revision=DEFAULT_REVISION if create_pr else revision,
+            token=token,
+            path_in_repo=path_in_repo,
+            delete_patterns=delete_patterns,
+        )
+        add_operations = _prepare_upload_folder_additions(
             folder_path,
             path_in_repo,
             allow_patterns=allow_patterns,
             ignore_patterns=ignore_patterns,
         )
 
+        # Optimize operations: if some files will be overwritten, we don't need to delete them first
+        if len(add_operations) > 0:
+            added_paths = set(op.path_in_repo for op in add_operations)
+            delete_operations = [
+                delete_op for delete_op in delete_operations if delete_op.path_in_repo not in added_paths
+            ]
+        commit_operations = delete_operations + add_operations
+
         commit_info = self.create_commit(
             repo_type=repo_type,
             repo_id=repo_id,
-            operations=files_to_add,
+            operations=commit_operations,
             commit_message=commit_message,
             commit_description=commit_description,
             token=token,
@@ -2787,9 +2878,7 @@ class HfApi:
 
         """
         commit_message = (
-            commit_message
-            if commit_message is not None
-            else f"Delete {path_in_repo} with huggingface_hub"
+            commit_message if commit_message is not None else f"Delete {path_in_repo} with huggingface_hub"
         )
 
         operations = [CommitOperationDelete(path_in_repo=path_in_repo)]
@@ -2861,14 +2950,10 @@ class HfApi:
             repo_id=repo_id,
             repo_type=repo_type,
             token=token,
-            operations=[
-                CommitOperationDelete(path_in_repo=path_in_repo, is_folder=True)
-            ],
+            operations=[CommitOperationDelete(path_in_repo=path_in_repo, is_folder=True)],
             revision=revision,
             commit_message=(
-                commit_message
-                if commit_message is not None
-                else f"Delete folder {path_in_repo} with huggingface_hub"
+                commit_message if commit_message is not None else f"Delete folder {path_in_repo} with huggingface_hub"
             ),
             commit_description=commit_description,
             create_pr=create_pr,
@@ -2887,7 +2972,8 @@ class HfApi:
         exist_ok: bool = False,
     ) -> None:
         """
-        Create a new branch from `main` on a repo on the Hub.
+        Create a new branch for a repo on the Hub, starting from the specified revision (defaults to `main`).
+        To find a revision suiting your needs, you can use [`list_repo_refs`] or [`list_repo_commits`].
 
         Args:
             repo_id (`str`):
@@ -3044,9 +3130,7 @@ class HfApi:
         """
         if repo_type is None:
             repo_type = REPO_TYPE_MODEL
-        revision = (
-            quote(revision, safe="") if revision is not None else DEFAULT_REVISION
-        )
+        revision = quote(revision, safe="") if revision is not None else DEFAULT_REVISION
 
         # Prepare request
         tag_url = f"{self.endpoint}/api/{repo_type}s/{repo_id}/tag/{revision}"
@@ -3196,9 +3280,7 @@ class HfApi:
         headers = self._build_hf_headers(token=token)
 
         def _fetch_discussion_page(page_index: int):
-            path = (
-                f"{self.endpoint}/api/{repo_type}s/{repo_id}/discussions?p={page_index}"
-            )
+            path = f"{self.endpoint}/api/{repo_type}s/{repo_id}/discussions?p={page_index}"
             resp = requests.get(path, headers=headers)
             hf_raise_for_status(resp)
             paginated_discussions = resp.json()
@@ -3272,9 +3354,7 @@ class HfApi:
         if repo_type is None:
             repo_type = REPO_TYPE_MODEL
 
-        path = (
-            f"{self.endpoint}/api/{repo_type}s/{repo_id}/discussions/{discussion_num}"
-        )
+        path = f"{self.endpoint}/api/{repo_type}s/{repo_id}/discussions/{discussion_num}"
         headers = self._build_hf_headers(token=token)
         resp = requests.get(path, params={"diff": "1"}, headers=headers)
         hf_raise_for_status(resp)
@@ -3282,17 +3362,9 @@ class HfApi:
         discussion_details = resp.json()
         is_pull_request = discussion_details["isPullRequest"]
 
-        target_branch = (
-            discussion_details["changes"]["base"] if is_pull_request else None
-        )
-        conflicting_files = (
-            discussion_details["filesWithConflicts"] if is_pull_request else None
-        )
-        merge_commit_oid = (
-            discussion_details["changes"].get("mergeCommitId", None)
-            if is_pull_request
-            else None
-        )
+        target_branch = discussion_details["changes"]["base"] if is_pull_request else None
+        conflicting_files = discussion_details["filesWithConflicts"] if is_pull_request else None
+        merge_commit_oid = discussion_details["changes"].get("mergeCommitId", None) if is_pull_request else None
 
         return DiscussionWithDetails(
             title=discussion_details["title"],
@@ -3413,7 +3485,7 @@ class HfApi:
 
         Creating a Pull Request with changes can also be done at once with [`HfApi.create_commit`];
 
-        This is a wrapper around [`HfApi.create_discusssion`].
+        This is a wrapper around [`HfApi.create_discussion`].
 
         Args:
             repo_id (`str`):
@@ -3860,8 +3932,7 @@ class HfApi:
         </Tip>
         """
         warnings.warn(
-            "Hidden comments' content cannot be retrieved anymore. Hiding a comment is"
-            " irreversible.",
+            "Hidden comments' content cannot be retrieved anymore. Hiding a comment is irreversible.",
             UserWarning,
         )
         resp = self._post_discussion_changes(
@@ -3874,9 +3945,7 @@ class HfApi:
         return deserialize_event(resp.json()["updatedComment"])  # type: ignore
 
     @validate_hf_hub_args
-    def add_space_secret(
-        self, repo_id: str, key: str, value: str, *, token: Optional[str] = None
-    ) -> None:
+    def add_space_secret(self, repo_id: str, key: str, value: str, *, token: Optional[str] = None) -> None:
         """Adds or updates a secret in a Space.
 
         Secrets allow to set secret keys or tokens to a Space without hardcoding them.
@@ -3900,9 +3969,7 @@ class HfApi:
         hf_raise_for_status(r)
 
     @validate_hf_hub_args
-    def delete_space_secret(
-        self, repo_id: str, key: str, *, token: Optional[str] = None
-    ) -> None:
+    def delete_space_secret(self, repo_id: str, key: str, *, token: Optional[str] = None) -> None:
         """Deletes a secret from a Space.
 
         Secrets allow to set secret keys or tokens to a Space without hardcoding them.
@@ -3924,9 +3991,7 @@ class HfApi:
         hf_raise_for_status(r)
 
     @validate_hf_hub_args
-    def get_space_runtime(
-        self, repo_id: str, *, token: Optional[str] = None
-    ) -> SpaceRuntime:
+    def get_space_runtime(self, repo_id: str, *, token: Optional[str] = None) -> SpaceRuntime:
         """Gets runtime information about a Space.
 
         Args:
@@ -3936,26 +4001,14 @@ class HfApi:
                 Hugging Face token. Will default to the locally saved token if
                 not provided.
         Returns:
-            `SpaceRuntime`: dataclass containing runtime information about a Space
-             including Space stage and hardware.
+            [`SpaceRuntime`]: Runtime information about a Space including Space stage and hardware.
         """
-        r = requests.get(
-            f"{self.endpoint}/api/spaces/{repo_id}/runtime",
-            headers=self._build_hf_headers(token=token),
-        )
+        r = requests.get(f"{self.endpoint}/api/spaces/{repo_id}/runtime", headers=self._build_hf_headers(token=token))
         hf_raise_for_status(r)
-        data = r.json()
-        return SpaceRuntime(
-            stage=data["stage"],
-            hardware=data["hardware"]["current"],
-            requested_hardware=data["hardware"]["requested"],
-            raw=data,
-        )
+        return SpaceRuntime(r.json())
 
     @validate_hf_hub_args
-    def request_space_hardware(
-        self, repo_id: str, hardware: SpaceHardware, *, token: Optional[str] = None
-    ) -> None:
+    def request_space_hardware(self, repo_id: str, hardware: SpaceHardware, *, token: Optional[str] = None) -> None:
         """Request new hardware for a Space.
 
         Args:
@@ -3968,8 +4021,7 @@ class HfApi:
 
         <Tip>
 
-        It is also possible to request hardware directly when creating the Space repo!
-        See [`create_repo`] for details.
+        It is also possible to request hardware directly when creating the Space repo! See [`create_repo`] for details.
 
         </Tip>
         """
@@ -3980,6 +4032,161 @@ class HfApi:
         )
         hf_raise_for_status(r)
 
+    @validate_hf_hub_args
+    def pause_space(self, repo_id: str, *, token: Optional[str] = None) -> SpaceRuntime:
+        """Pause your Space.
+
+        A paused Space stops executing until manually restarted by its owner. This is different from the sleeping
+        state in which free Spaces go after 72h of inactivity. Paused time is not billed to your account, no matter the
+        hardware you've selected. To restart your Space, use [`restart_space`] and go to your Space settings page.
+
+        For more details, please visit [the docs](https://huggingface.co/docs/hub/spaces-gpus#pause).
+
+        Args:
+            repo_id (`str`):
+                ID of the Space to pause. Example: `"Salesforce/BLIP2"`.
+            token (`str`, *optional*):
+                Hugging Face token. Will default to the locally saved token if not provided.
+
+        Returns:
+            [`SpaceRuntime`]: Runtime information about your Space including `stage=PAUSED` and requested hardware.
+
+        Raises:
+            [`~utils.RepositoryNotFoundError`]:
+                If your Space is not found (error 404). Most probably wrong repo_id or your space is private but you
+                are not authenticated.
+            [`~utils.HfHubHTTPError`]:
+                403 Forbidden: only the owner of a Space can pause it. If you want to manage a Space that you don't
+                own, either ask the owner by opening a Discussion or duplicate the Space.
+            [`~utils.BadRequestError`]:
+                If your Space is a static Space. Static Spaces are always running and never billed. If you want to hide
+                a static Space, you can set it to private.
+        """
+        r = requests.post(f"{self.endpoint}/api/spaces/{repo_id}/pause", headers=self._build_hf_headers(token=token))
+        hf_raise_for_status(r)
+        return SpaceRuntime(r.json())
+
+    @validate_hf_hub_args
+    def restart_space(self, repo_id: str, *, token: Optional[str] = None) -> SpaceRuntime:
+        """Restart your Space.
+
+        This is the only way to programmatically restart a Space if you've put it on Pause (see [`pause_space`]). You
+        must be the owner of the Space to restart it. If you are using an upgraded hardware, your account will be
+        billed as soon as the Space is restarted. You can trigger a restart no matter the current state of a Space.
+
+        For more details, please visit [the docs](https://huggingface.co/docs/hub/spaces-gpus#pause).
+
+        Args:
+            repo_id (`str`):
+                ID of the Space to restart. Example: `"Salesforce/BLIP2"`.
+            token (`str`, *optional*):
+                Hugging Face token. Will default to the locally saved token if not provided.
+
+        Returns:
+            [`SpaceRuntime`]: Runtime information about your Space.
+
+        Raises:
+            [`~utils.RepositoryNotFoundError`]:
+                If your Space is not found (error 404). Most probably wrong repo_id or your space is private but you
+                are not authenticated.
+            [`~utils.HfHubHTTPError`]:
+                403 Forbidden: only the owner of a Space can restart it. If you want to restart a Space that you don't
+                own, either ask the owner by opening a Discussion or duplicate the Space.
+            [`~utils.BadRequestError`]:
+                If your Space is a static Space. Static Spaces are always running and never billed. If you want to hide
+                a static Space, you can set it to private.
+        """
+        r = requests.post(f"{self.endpoint}/api/spaces/{repo_id}/restart", headers=self._build_hf_headers(token=token))
+        hf_raise_for_status(r)
+        return SpaceRuntime(r.json())
+
+    @validate_hf_hub_args
+    def duplicate_space(
+        self,
+        from_id: str,
+        to_id: Optional[str] = None,
+        *,
+        private: Optional[bool] = None,
+        token: Optional[str] = None,
+        exist_ok: bool = False,
+    ) -> str:
+        """Duplicate a Space.
+
+        Programmatically duplicate a Space. The new Space will be created in your account and will be in the same state
+        as the original Space (running or paused). You can duplicate a Space no matter the current state of a Space.
+
+        Args:
+            from_id (`str`):
+                ID of the Space to duplicate. Example: `"pharma/CLIP-Interrogator"`.
+            to_id (`str`, *optional*):
+                ID of the new Space. Example: `"dog/CLIP-Interrogator"`. If not provided, the new Space will have the same
+                name as the original Space, but in your account.
+            private (`bool`, *optional*):
+                Whether the new Space should be private or not. Defaults to the same privacy as the original Space.
+            token (`str`, *optional*):
+                Hugging Face token. Will default to the locally saved token if not provided.
+            exist_ok (`bool`, *optional*, defaults to `False`):
+                If `True`, do not raise an error if repo already exists.
+
+        Returns:
+            [`RepoUrl`]: URL to the newly created repo. Value is a subclass of `str` containing
+            attributes like `endpoint`, `repo_type` and `repo_id`.
+
+        Raises:
+            - [`HTTPError`](https://2.python-requests.org/en/master/api/#requests.HTTPError)
+              if the HuggingFace API returned an error
+            - [`~utils.RepositoryNotFoundError`]
+              If one of `from_id` or `to_id` cannot be found. This may be because it doesn't exist,
+              or because it is set to `private` and you do not have access.
+
+        Example:
+        ```python
+        >>> from huggingface_hub import duplicate_space
+
+        # Duplicate a Space to your account
+        >>> duplicate_space("multimodalart/dreambooth-training")
+        RepoUrl('https://huggingface.co/spaces/nateraw/dreambooth-training',...)
+
+        # Can set custom destination id and visibility flag.
+        >>> duplicate_space("multimodalart/dreambooth-training", to_id="my-dreambooth", private=True)
+        RepoUrl('https://huggingface.co/spaces/nateraw/my-dreambooth',...)
+        ```
+        """
+        # Parse to_id if provided
+        parsed_to_id = RepoUrl(to_id) if to_id is not None else None
+
+        # Infer target repo_id
+        to_namespace = (  # set namespace manually or default to username
+            parsed_to_id.namespace
+            if parsed_to_id is not None and parsed_to_id.namespace is not None
+            else self.whoami(token)["name"]
+        )
+        to_repo_name = parsed_to_id.repo_name if to_id is not None else RepoUrl(from_id).repo_name  # type: ignore
+
+        # repository must be a valid repo_id (namespace/repo_name).
+        payload: Dict[str, Any] = {"repository": f"{to_namespace}/{to_repo_name}"}
+
+        # private is optional with this endpoint, with None defaulting to the original space's privacy.
+        if private is not None:
+            payload["private"] = private
+
+        r = requests.post(
+            f"{self.endpoint}/api/spaces/{from_id}/duplicate",
+            headers=self._build_hf_headers(token=token, is_write_action=True),
+            json=payload,
+        )
+
+        try:
+            hf_raise_for_status(r)
+        except HTTPError as err:
+            if exist_ok and err.response.status_code == 409:
+                # Repo already exists and `exist_ok=True`
+                pass
+            else:
+                raise
+
+        return RepoUrl(r.json()["url"], endpoint=self.endpoint)
+
     def _build_hf_headers(
         self,
         token: Optional[Union[bool, str]] = None,
@@ -4003,8 +4210,48 @@ class HfApi:
             user_agent=user_agent or self.user_agent,
         )
 
+    def _prepare_upload_folder_deletions(
+        self,
+        repo_id: str,
+        repo_type: Optional[str],
+        revision: Optional[str],
+        token: Optional[str],
+        path_in_repo: str,
+        delete_patterns: Optional[Union[List[str], str]],
+    ) -> List[CommitOperationDelete]:
+        """Generate the list of Delete operations for a commit to delete files from a repo.
 
-def _prepare_upload_folder_commit(
+        List remote files and match them against the `delete_patterns` constraints. Returns a list of [`CommitOperationDelete`]
+        with the matching items.
+
+        Note: `.gitattributes` file is essential to make a repo work properly on the Hub. This file will always be
+              kept even if it matches the `delete_patterns` constraints.
+        """
+        if delete_patterns is None:
+            # If no delete patterns, no need to list and filter remote files
+            return []
+
+        # List remote files
+        filenames = self.list_repo_files(repo_id=repo_id, revision=revision, repo_type=repo_type, token=token)
+
+        # Compute relative path in repo
+        if path_in_repo:
+            path_in_repo = path_in_repo.strip("/") + "/"  # harmonize
+            relpath_to_abspath = {
+                file[len(path_in_repo) :]: file for file in filenames if file.startswith(path_in_repo)
+            }
+        else:
+            relpath_to_abspath = {file: file for file in filenames}
+
+        # Apply filter on relative paths and return
+        return [
+            CommitOperationDelete(path_in_repo=relpath_to_abspath[relpath], is_folder=False)
+            for relpath in filter_repo_objects(relpath_to_abspath.keys(), allow_patterns=delete_patterns)
+            if relpath_to_abspath[relpath] != ".gitattributes"
+        ]
+
+
+def _prepare_upload_folder_additions(
     folder_path: Union[str, Path],
     path_in_repo: str,
     allow_patterns: Optional[Union[List[str], str]] = None,
@@ -4015,32 +4262,29 @@ def _prepare_upload_folder_commit(
     Files not matching the `allow_patterns` (allowlist) and `ignore_patterns` (denylist)
     constraints are discarded.
     """
-    folder_path = os.path.normpath(os.path.expanduser(folder_path))
-    if not os.path.isdir(folder_path):
+    folder_path = Path(folder_path).expanduser().resolve()
+    if not folder_path.is_dir():
         raise ValueError(f"Provided path: '{folder_path}' is not a directory")
 
-    files_to_add: List[CommitOperationAdd] = []
-    for dirpath, _, filenames in os.walk(folder_path):
-        for filename in filenames:
-            abs_path = os.path.join(dirpath, filename)
-            rel_path = os.path.relpath(abs_path, folder_path)
-            files_to_add.append(
-                CommitOperationAdd(
-                    path_or_fileobj=abs_path,
-                    path_in_repo=os.path.normpath(
-                        os.path.join(path_in_repo, rel_path)
-                    ).replace(os.sep, "/"),
-                )
-            )
-
-    return list(
-        filter_repo_objects(
-            files_to_add,
-            allow_patterns=allow_patterns,
-            ignore_patterns=ignore_patterns,
-            key=lambda x: x.path_in_repo,
+    # List files from folder
+    relpath_to_abspath = {
+        path.relative_to(folder_path).as_posix(): path
+        for path in sorted(folder_path.glob("**/*"))  # sorted to be deterministic
+        if path.is_file()
+    }
+
+    # Filter files and return
+    # Patterns are applied on the path relative to `folder_path`. `path_in_repo` is prefixed after the filtering.
+    prefix = f"{path_in_repo.strip('/')}/" if path_in_repo else ""
+    return [
+        CommitOperationAdd(
+            path_or_fileobj=relpath_to_abspath[relpath],  # absolute path on disk
+            path_in_repo=prefix + relpath,  # "absolute" path in repo
         )
-    )
+        for relpath in filter_repo_objects(
+            relpath_to_abspath.keys(), allow_patterns=allow_patterns, ignore_patterns=ignore_patterns
+        )
+    ]
 
 
 def _parse_revision_from_pr_url(pr_url: str) -> str:
@@ -4054,10 +4298,7 @@ def _parse_revision_from_pr_url(pr_url: str) -> str:
     """
     re_match = re.match(_REGEX_DISCUSSION_URL, pr_url)
     if re_match is None:
-        raise RuntimeError(
-            "Unexpected response from the hub, expected a Pull Request URL but got:"
-            f" '{pr_url}'"
-        )
+        raise RuntimeError(f"Unexpected response from the hub, expected a Pull Request URL but got: '{pr_url}'")
     return f"refs/pr/{re_match[1]}"
 
 
@@ -4080,6 +4321,7 @@ space_info = api.space_info
 repo_info = api.repo_info
 list_repo_files = api.list_repo_files
 list_repo_refs = api.list_repo_refs
+list_repo_commits = api.list_repo_commits
 
 list_metrics = api.list_metrics
 
@@ -4122,3 +4364,6 @@ add_space_secret = api.add_space_secret
 delete_space_secret = api.delete_space_secret
 get_space_runtime = api.get_space_runtime
 request_space_hardware = api.request_space_hardware
+pause_space = api.pause_space
+restart_space = api.restart_space
+duplicate_space = api.duplicate_space