huggingface-hub 0.24.6__py3-none-any.whl → 0.25.0rc0__py3-none-any.whl

huggingface_hub/utils/_errors.py

@@ -1,397 +0,0 @@
-import re
-from typing import Optional
-
-from requests import HTTPError, Response
-
-from ._fixes import JSONDecodeError
-
-
-REPO_API_REGEX = re.compile(
-    r"""
-        # staging or production endpoint
-        ^https://[^/]+
-        (
-            # on /api/repo_type/repo_id
-            /api/(models|datasets|spaces)/(.+)
-            |
-            # or /repo_id/resolve/revision/...
-            /(.+)/resolve/(.+)
-        )
-    """,
-    flags=re.VERBOSE,
-)
-
-
-class FileMetadataError(OSError):
-    """Error triggered when the metadata of a file on the Hub cannot be retrieved (missing ETag or commit_hash).
-
-    Inherits from `OSError` for backward compatibility.
-    """
-
-
-class HfHubHTTPError(HTTPError):
-    """
-    HTTPError to inherit from for any custom HTTP Error raised in HF Hub.
-
-    Any HTTPError is converted at least into a `HfHubHTTPError`. If some information is
-    sent back by the server, it will be added to the error message.
-
-    Added details:
-    - Request id from "X-Request-Id" header if exists.
-    - Server error message from the header "X-Error-Message".
-    - Server error message if we can found one in the response body.
-
-    Example:
-    ```py
-        import requests
-        from huggingface_hub.utils import get_session, hf_raise_for_status, HfHubHTTPError
-
-        response = get_session().post(...)
-        try:
-            hf_raise_for_status(response)
-        except HfHubHTTPError as e:
-            print(str(e)) # formatted message
-            e.request_id, e.server_message # details returned by server
-
-            # Complete the error message with additional information once it's raised
-            e.append_to_message("\n`create_commit` expects the repository to exist.")
-            raise
-    ```
-    """
-
-    request_id: Optional[str] = None
-    server_message: Optional[str] = None
-
-    def __init__(self, message: str, response: Optional[Response] = None):
-        # Parse server information if any.
-        if response is not None:
-            self.request_id = response.headers.get("X-Request-Id")
-            try:
-                server_data = response.json()
-            except JSONDecodeError:
-                server_data = {}
-
-            # Retrieve server error message from multiple sources
-            server_message_from_headers = response.headers.get("X-Error-Message")
-            server_message_from_body = server_data.get("error")
-            server_multiple_messages_from_body = "\n".join(
-                error["message"] for error in server_data.get("errors", []) if "message" in error
-            )
-
-            # Concatenate error messages
-            _server_message = ""
-            if server_message_from_headers is not None:  # from headers
-                _server_message += server_message_from_headers + "\n"
-            if server_message_from_body is not None:  # from body "error"
-                if isinstance(server_message_from_body, list):
-                    server_message_from_body = "\n".join(server_message_from_body)
-                if server_message_from_body not in _server_message:
-                    _server_message += server_message_from_body + "\n"
-            if server_multiple_messages_from_body is not None:  # from body "errors"
-                if server_multiple_messages_from_body not in _server_message:
-                    _server_message += server_multiple_messages_from_body + "\n"
-            _server_message = _server_message.strip()
-
-            # Set message to `HfHubHTTPError` (if any)
-            if _server_message != "":
-                self.server_message = _server_message
-
-        super().__init__(
-            _format_error_message(
-                message,
-                request_id=self.request_id,
-                server_message=self.server_message,
-            ),
-            response=response,  # type: ignore
-            request=response.request if response is not None else None,  # type: ignore
-        )
-
-    def append_to_message(self, additional_message: str) -> None:
-        """Append additional information to the `HfHubHTTPError` initial message."""
-        self.args = (self.args[0] + additional_message,) + self.args[1:]
-
-
-class RepositoryNotFoundError(HfHubHTTPError):
-    """
-    Raised when trying to access a hf.co URL with an invalid repository name, or
-    with a private repo name the user does not have access to.
-
-    Example:
-
-    ```py
-    >>> from huggingface_hub import model_info
-    >>> model_info("<non_existent_repository>")
-    (...)
-    huggingface_hub.utils._errors.RepositoryNotFoundError: 401 Client Error. (Request ID: PvMw_VjBMjVdMz53WKIzP)
-
-    Repository Not Found for url: https://huggingface.co/api/models/%3Cnon_existent_repository%3E.
-    Please make sure you specified the correct `repo_id` and `repo_type`.
-    If the repo is private, make sure you are authenticated.
-    Invalid username or password.
-    ```
-    """
-
-
-class GatedRepoError(RepositoryNotFoundError):
-    """
-    Raised when trying to access a gated repository for which the user is not on the
-    authorized list.
-
-    Note: derives from `RepositoryNotFoundError` to ensure backward compatibility.
-
-    Example:
-
-    ```py
-    >>> from huggingface_hub import model_info
-    >>> model_info("<gated_repository>")
-    (...)
-    huggingface_hub.utils._errors.GatedRepoError: 403 Client Error. (Request ID: ViT1Bf7O_026LGSQuVqfa)
-
-    Cannot access gated repo for url https://huggingface.co/api/models/ardent-figment/gated-model.
-    Access to model ardent-figment/gated-model is restricted and you are not in the authorized list.
-    Visit https://huggingface.co/ardent-figment/gated-model to ask for access.
-    ```
-    """
-
-
-class DisabledRepoError(HfHubHTTPError):
-    """
-    Raised when trying to access a repository that has been disabled by its author.
-
-    Example:
-
-    ```py
-    >>> from huggingface_hub import dataset_info
-    >>> dataset_info("laion/laion-art")
-    (...)
-    huggingface_hub.utils._errors.DisabledRepoError: 403 Client Error. (Request ID: Root=1-659fc3fa-3031673e0f92c71a2260dbe2;bc6f4dfb-b30a-4862-af0a-5cfe827610d8)
-
-    Cannot access repository for url https://huggingface.co/api/datasets/laion/laion-art.
-    Access to this resource is disabled.
-    ```
-    """
-
-
-class RevisionNotFoundError(HfHubHTTPError):
-    """
-    Raised when trying to access a hf.co URL with a valid repository but an invalid
-    revision.
-
-    Example:
-
-    ```py
-    >>> from huggingface_hub import hf_hub_download
-    >>> hf_hub_download('bert-base-cased', 'config.json', revision='<non-existent-revision>')
-    (...)
-    huggingface_hub.utils._errors.RevisionNotFoundError: 404 Client Error. (Request ID: Mwhe_c3Kt650GcdKEFomX)
-
-    Revision Not Found for url: https://huggingface.co/bert-base-cased/resolve/%3Cnon-existent-revision%3E/config.json.
-    ```
-    """
-
-
-class EntryNotFoundError(HfHubHTTPError):
-    """
-    Raised when trying to access a hf.co URL with a valid repository and revision
-    but an invalid filename.
-
-    Example:
-
-    ```py
-    >>> from huggingface_hub import hf_hub_download
-    >>> hf_hub_download('bert-base-cased', '<non-existent-file>')
-    (...)
-    huggingface_hub.utils._errors.EntryNotFoundError: 404 Client Error. (Request ID: 53pNl6M0MxsnG5Sw8JA6x)
-
-    Entry Not Found for url: https://huggingface.co/bert-base-cased/resolve/main/%3Cnon-existent-file%3E.
-    ```
-    """
-
-
-class LocalEntryNotFoundError(EntryNotFoundError, FileNotFoundError, ValueError):
-    """
-    Raised when trying to access a file or snapshot that is not on the disk when network is
-    disabled or unavailable (connection issue). The entry may exist on the Hub.
-
-    Note: `ValueError` type is to ensure backward compatibility.
-    Note: `LocalEntryNotFoundError` derives from `HTTPError` because of `EntryNotFoundError`
-          even when it is not a network issue.
-
-    Example:
-
-    ```py
-    >>> from huggingface_hub import hf_hub_download
-    >>> hf_hub_download('bert-base-cased', '<non-cached-file>',  local_files_only=True)
-    (...)
-    huggingface_hub.utils._errors.LocalEntryNotFoundError: Cannot find the requested files in the disk cache and outgoing traffic has been disabled. To enable hf.co look-ups and downloads online, set 'local_files_only' to False.
-    ```
-    """
-
-    def __init__(self, message: str):
-        super().__init__(message, response=None)
-
-
-class BadRequestError(HfHubHTTPError, ValueError):
-    """
-    Raised by `hf_raise_for_status` when the server returns a HTTP 400 error.
-
-    Example:
-
-    ```py
-    >>> resp = requests.post("hf.co/api/check", ...)
-    >>> hf_raise_for_status(resp, endpoint_name="check")
-    huggingface_hub.utils._errors.BadRequestError: Bad request for check endpoint: {details} (Request ID: XXX)
-    ```
-    """
-
-
-def hf_raise_for_status(response: Response, endpoint_name: Optional[str] = None) -> None:
-    """
-    Internal version of `response.raise_for_status()` that will refine a
-    potential HTTPError. Raised exception will be an instance of `HfHubHTTPError`.
-
-    This helper is meant to be the unique method to raise_for_status when making a call
-    to the Hugging Face Hub.
-
-    Example:
-    ```py
-        import requests
-        from huggingface_hub.utils import get_session, hf_raise_for_status, HfHubHTTPError
-
-        response = get_session().post(...)
-        try:
-            hf_raise_for_status(response)
-        except HfHubHTTPError as e:
-            print(str(e)) # formatted message
-            e.request_id, e.server_message # details returned by server
-
-            # Complete the error message with additional information once it's raised
-            e.append_to_message("\n`create_commit` expects the repository to exist.")
-            raise
-    ```
-
-    Args:
-        response (`Response`):
-            Response from the server.
-        endpoint_name (`str`, *optional*):
-            Name of the endpoint that has been called. If provided, the error message
-            will be more complete.
-
-    <Tip warning={true}>
-
-    Raises when the request has failed:
-
-        - [`~utils.RepositoryNotFoundError`]
-            If the repository to download from cannot be found. This may be because it
-            doesn't exist, because `repo_type` is not set correctly, or because the repo
-            is `private` and you do not have access.
-        - [`~utils.GatedRepoError`]
-            If the repository exists but is gated and the user is not on the authorized
-            list.
-        - [`~utils.RevisionNotFoundError`]
-            If the repository exists but the revision couldn't be find.
-        - [`~utils.EntryNotFoundError`]
-            If the repository exists but the entry (e.g. the requested file) couldn't be
-            find.
-        - [`~utils.BadRequestError`]
-            If request failed with a HTTP 400 BadRequest error.
-        - [`~utils.HfHubHTTPError`]
-            If request failed for a reason not listed above.
-
-    </Tip>
-    """
-    try:
-        response.raise_for_status()
-    except HTTPError as e:
-        error_code = response.headers.get("X-Error-Code")
-        error_message = response.headers.get("X-Error-Message")
-
-        if error_code == "RevisionNotFound":
-            message = f"{response.status_code} Client Error." + "\n\n" + f"Revision Not Found for url: {response.url}."
-            raise RevisionNotFoundError(message, response) from e
-
-        elif error_code == "EntryNotFound":
-            message = f"{response.status_code} Client Error." + "\n\n" + f"Entry Not Found for url: {response.url}."
-            raise EntryNotFoundError(message, response) from e
-
-        elif error_code == "GatedRepo":
-            message = (
-                f"{response.status_code} Client Error." + "\n\n" + f"Cannot access gated repo for url {response.url}."
-            )
-            raise GatedRepoError(message, response) from e
-
-        elif error_message == "Access to this resource is disabled.":
-            message = (
-                f"{response.status_code} Client Error."
-                + "\n\n"
-                + f"Cannot access repository for url {response.url}."
-                + "\n"
-                + "Access to this resource is disabled."
-            )
-            raise DisabledRepoError(message, response) from e
-
-        elif error_code == "RepoNotFound" or (
-            response.status_code == 401
-            and response.request is not None
-            and response.request.url is not None
-            and REPO_API_REGEX.search(response.request.url) is not None
-        ):
-            # 401 is misleading as it is returned for:
-            #    - private and gated repos if user is not authenticated
-            #    - missing repos
-            # => for now, we process them as `RepoNotFound` anyway.
-            # See https://gist.github.com/Wauplin/46c27ad266b15998ce56a6603796f0b9
-            message = (
-                f"{response.status_code} Client Error."
-                + "\n\n"
-                + f"Repository Not Found for url: {response.url}."
-                + "\nPlease make sure you specified the correct `repo_id` and"
-                " `repo_type`.\nIf you are trying to access a private or gated repo,"
-                " make sure you are authenticated."
-            )
-            raise RepositoryNotFoundError(message, response) from e
-
-        elif response.status_code == 400:
-            message = (
-                f"\n\nBad request for {endpoint_name} endpoint:" if endpoint_name is not None else "\n\nBad request:"
-            )
-            raise BadRequestError(message, response=response) from e
-
-        elif response.status_code == 403:
-            message = (
-                f"\n\n{response.status_code} Forbidden: {error_message}."
-                + f"\nCannot access content at: {response.url}."
-                + "\nIf you are trying to create or update content, "
-                + "make sure you have a token with the `write` role."
-            )
-            raise HfHubHTTPError(message, response=response) from e
-
-        # Convert `HTTPError` into a `HfHubHTTPError` to display request information
-        # as well (request id and/or server error message)
-        raise HfHubHTTPError(str(e), response=response) from e
-
-
-def _format_error_message(message: str, request_id: Optional[str], server_message: Optional[str]) -> str:
-    """
-    Format the `HfHubHTTPError` error message based on initial message and information
-    returned by the server.
-
-    Used when initializing `HfHubHTTPError`.
-    """
-    # Add message from response body
-    if server_message is not None and len(server_message) > 0 and server_message.lower() not in message.lower():
-        if "\n\n" in message:
-            message += "\n" + server_message
-        else:
-            message += "\n\n" + server_message
-
-    # Add Request ID
-    if request_id is not None and str(request_id).lower() not in message.lower():
-        request_id_message = f" (Request ID: {request_id})"
-        if "\n" in message:
-            newline_index = message.index("\n")
-            message = message[:newline_index] + request_id_message + message[newline_index:]
-        else:
-            message += request_id_message
-
-    return message