huggingface-hub 0.22.1__py3-none-any.whl → 0.23.0__py3-none-any.whl

huggingface_hub/inference/_generated/types/__init__.py

@@ -19,13 +19,28 @@ from .automatic_speech_recognition import (
 from .base import BaseInferenceType
 from .chat_completion import (
     ChatCompletionInput,
+    ChatCompletionInputFunctionDefinition,
     ChatCompletionInputMessage,
+    ChatCompletionInputTool,
+    ChatCompletionInputToolCall,
+    ChatCompletionInputToolTypeClass,
     ChatCompletionOutput,
-    ChatCompletionOutputChoice,
-    ChatCompletionOutputChoiceMessage,
+    ChatCompletionOutputComplete,
+    ChatCompletionOutputFunctionDefinition,
+    ChatCompletionOutputLogprob,
+    ChatCompletionOutputLogprobs,
+    ChatCompletionOutputMessage,
+    ChatCompletionOutputToolCall,
+    ChatCompletionOutputTopLogprob,
+    ChatCompletionOutputUsage,
     ChatCompletionStreamOutput,
     ChatCompletionStreamOutputChoice,
     ChatCompletionStreamOutputDelta,
+    ChatCompletionStreamOutputDeltaToolCall,
+    ChatCompletionStreamOutputFunction,
+    ChatCompletionStreamOutputLogprob,
+    ChatCompletionStreamOutputLogprobs,
+    ChatCompletionStreamOutputTopLogprob,
 )
 from .depth_estimation import DepthEstimationInput, DepthEstimationOutput
 from .document_question_answering import (
@@ -67,14 +82,16 @@ from .text2text_generation import Text2TextGenerationInput, Text2TextGenerationO
 from .text_classification import TextClassificationInput, TextClassificationOutputElement, TextClassificationParameters
 from .text_generation import (
     TextGenerationInput,
+    TextGenerationInputGenerateParameters,
+    TextGenerationInputGrammarType,
     TextGenerationOutput,
+    TextGenerationOutputBestOfSequence,
     TextGenerationOutputDetails,
-    TextGenerationOutputSequenceDetails,
+    TextGenerationOutputPrefillToken,
     TextGenerationOutputToken,
-    TextGenerationParameters,
-    TextGenerationPrefillToken,
-    TextGenerationStreamDetails,
     TextGenerationStreamOutput,
+    TextGenerationStreamOutputStreamDetails,
+    TextGenerationStreamOutputToken,
 )
 from .text_to_audio import TextToAudioGenerationParameters, TextToAudioInput, TextToAudioOutput, TextToAudioParameters
 from .text_to_image import TextToImageInput, TextToImageOutput, TextToImageParameters, TextToImageTargetSize

huggingface_hub/inference/_generated/types/chat_completion.py

@@ -4,103 +4,257 @@
 #   - script: https://github.com/huggingface/huggingface.js/blob/main/packages/tasks/scripts/inference-codegen.ts
 #   - specs:  https://github.com/huggingface/huggingface.js/tree/main/packages/tasks/src/tasks.
 from dataclasses import dataclass
-from typing import List, Literal, Optional, Union
+from typing import Any, List, Literal, Optional, Union
 
 from .base import BaseInferenceType
 
 
-ChatCompletionMessageRole = Literal["assistant", "system", "user"]
+@dataclass
+class ChatCompletionInputFunctionDefinition(BaseInferenceType):
+    arguments: Any
+    name: str
+    description: Optional[str] = None
+
+
+@dataclass
+class ChatCompletionInputToolCall(BaseInferenceType):
+    function: ChatCompletionInputFunctionDefinition
+    id: int
+    type: str
 
 
 @dataclass
 class ChatCompletionInputMessage(BaseInferenceType):
-    content: str
-    """The content of the message."""
-    role: "ChatCompletionMessageRole"
+    role: str
+    content: Optional[str] = None
+    name: Optional[str] = None
+    tool_calls: Optional[List[ChatCompletionInputToolCall]] = None
+
+
+@dataclass
+class ChatCompletionInputToolTypeClass(BaseInferenceType):
+    function_name: str
+
+
+ChatCompletionInputToolTypeEnum = Literal["OneOf"]
+
+
+@dataclass
+class ChatCompletionInputTool(BaseInferenceType):
+    function: ChatCompletionInputFunctionDefinition
+    type: str
 
 
 @dataclass
 class ChatCompletionInput(BaseInferenceType):
-    """Inputs for ChatCompletion inference"""
+    """Chat Completion Input.
+    Auto-generated from TGI specs.
+    For more details, check out
+    https://github.com/huggingface/huggingface.js/blob/main/packages/tasks/scripts/inference-tgi-import.ts.
+    """
 
     messages: List[ChatCompletionInputMessage]
+    """A list of messages comprising the conversation so far."""
+    model: str
+    """[UNUSED] ID of the model to use. See the model endpoint compatibility table for details
+    on which models work with the Chat API.
+    """
     frequency_penalty: Optional[float] = None
     """Number between -2.0 and 2.0. Positive values penalize new tokens based on their existing
-    frequency in the text so far, decreasing the model's likelihood to repeat the same line
-    verbatim.
+    frequency in the text so far,
+    decreasing the model's likelihood to repeat the same line verbatim.
+    """
+    logit_bias: Optional[List[float]] = None
+    """UNUSED
+    Modify the likelihood of specified tokens appearing in the completion. Accepts a JSON
+    object that maps tokens
+    (specified by their token ID in the tokenizer) to an associated bias value from -100 to
+    100. Mathematically,
+    the bias is added to the logits generated by the model prior to sampling. The exact
+    effect will vary per model,
+    but values between -1 and 1 should decrease or increase likelihood of selection; values
+    like -100 or 100 should
+    result in a ban or exclusive selection of the relevant token.
+    """
+    logprobs: Optional[bool] = None
+    """Whether to return log probabilities of the output tokens or not. If true, returns the log
+    probabilities of each
+    output token returned in the content of message.
     """
     max_tokens: Optional[int] = None
     """The maximum number of tokens that can be generated in the chat completion."""
+    n: Optional[int] = None
+    """UNUSED
+    How many chat completion choices to generate for each input message. Note that you will
+    be charged based on the
+    number of generated tokens across all of the choices. Keep n as 1 to minimize costs.
+    """
+    presence_penalty: Optional[float] = None
+    """Number between -2.0 and 2.0. Positive values penalize new tokens based on whether they
+    appear in the text so far,
+    increasing the model's likelihood to talk about new topics
+    """
     seed: Optional[int] = None
-    """The random sampling seed."""
-    stop: Optional[Union[List[str], str]] = None
-    """Stop generating tokens if a stop token is generated."""
+    stop: Optional[List[str]] = None
+    """Up to 4 sequences where the API will stop generating further tokens."""
     stream: Optional[bool] = None
-    """If set, partial message deltas will be sent."""
     temperature: Optional[float] = None
-    """The value used to modulate the logits distribution."""
+    """What sampling temperature to use, between 0 and 2. Higher values like 0.8 will make the
+    output more random, while
+    lower values like 0.2 will make it more focused and deterministic.
+    We generally recommend altering this or `top_p` but not both.
+    """
+    tool_choice: Optional[Union[ChatCompletionInputToolTypeClass, "ChatCompletionInputToolTypeEnum"]] = None
+    tool_prompt: Optional[str] = None
+    """A prompt to be appended before the tools"""
+    tools: Optional[List[ChatCompletionInputTool]] = None
+    """A list of tools the model may call. Currently, only functions are supported as a tool.
+    Use this to provide a list of
+    functions the model may generate JSON inputs for.
+    """
+    top_logprobs: Optional[int] = None
+    """An integer between 0 and 5 specifying the number of most likely tokens to return at each
+    token position, each with
+    an associated log probability. logprobs must be set to true if this parameter is used.
+    """
     top_p: Optional[float] = None
-    """If set to < 1, only the smallest set of most probable tokens with probabilities that add
-    up to `top_p` or higher are kept for generation.
+    """An alternative to sampling with temperature, called nucleus sampling, where the model
+    considers the results of the
+    tokens with top_p probability mass. So 0.1 means only the tokens comprising the top 10%
+    probability mass are considered.
     """
 
 
-ChatCompletionFinishReason = Literal["length", "eos_token", "stop_sequence"]
+@dataclass
+class ChatCompletionOutputTopLogprob(BaseInferenceType):
+    logprob: float
+    token: str
 
 
 @dataclass
-class ChatCompletionOutputChoiceMessage(BaseInferenceType):
-    content: str
-    """The content of the chat completion message."""
-    role: "ChatCompletionMessageRole"
+class ChatCompletionOutputLogprob(BaseInferenceType):
+    logprob: float
+    token: str
+    top_logprobs: List[ChatCompletionOutputTopLogprob]
 
 
 @dataclass
-class ChatCompletionOutputChoice(BaseInferenceType):
-    finish_reason: "ChatCompletionFinishReason"
-    """The reason why the generation was stopped."""
+class ChatCompletionOutputLogprobs(BaseInferenceType):
+    content: List[ChatCompletionOutputLogprob]
+
+
+@dataclass
+class ChatCompletionOutputFunctionDefinition(BaseInferenceType):
+    arguments: Any
+    name: str
+    description: Optional[str] = None
+
+
+@dataclass
+class ChatCompletionOutputToolCall(BaseInferenceType):
+    function: ChatCompletionOutputFunctionDefinition
+    id: int
+    type: str
+
+
+@dataclass
+class ChatCompletionOutputMessage(BaseInferenceType):
+    role: str
+    content: Optional[str] = None
+    name: Optional[str] = None
+    tool_calls: Optional[List[ChatCompletionOutputToolCall]] = None
+
+
+@dataclass
+class ChatCompletionOutputComplete(BaseInferenceType):
+    finish_reason: str
     index: int
-    """The index of the choice in the list of choices."""
-    message: ChatCompletionOutputChoiceMessage
+    message: ChatCompletionOutputMessage
+    logprobs: Optional[ChatCompletionOutputLogprobs] = None
+
+
+@dataclass
+class ChatCompletionOutputUsage(BaseInferenceType):
+    completion_tokens: int
+    prompt_tokens: int
+    total_tokens: int
 
 
 @dataclass
 class ChatCompletionOutput(BaseInferenceType):
-    """Outputs for Chat Completion inference"""
+    """Chat Completion Output.
+    Auto-generated from TGI specs.
+    For more details, check out
+    https://github.com/huggingface/huggingface.js/blob/main/packages/tasks/scripts/inference-tgi-import.ts.
+    """
 
-    choices: List[ChatCompletionOutputChoice]
-    """A list of chat completion choices."""
+    choices: List[ChatCompletionOutputComplete]
     created: int
-    """The Unix timestamp (in seconds) of when the chat completion was created."""
+    id: str
+    model: str
+    object: str
+    system_fingerprint: str
+    usage: ChatCompletionOutputUsage
 
 
 @dataclass
-class ChatCompletionStreamOutputDelta(BaseInferenceType):
-    """A chat completion delta generated by streamed model responses."""
+class ChatCompletionStreamOutputFunction(BaseInferenceType):
+    arguments: str
+    name: Optional[str] = None
+
+
+@dataclass
+class ChatCompletionStreamOutputDeltaToolCall(BaseInferenceType):
+    function: ChatCompletionStreamOutputFunction
+    id: str
+    index: int
+    type: str
 
+
+@dataclass
+class ChatCompletionStreamOutputDelta(BaseInferenceType):
+    role: str
     content: Optional[str] = None
-    """The contents of the chunk message."""
-    role: Optional[str] = None
-    """The role of the author of this message."""
+    tool_calls: Optional[ChatCompletionStreamOutputDeltaToolCall] = None
+
+
+@dataclass
+class ChatCompletionStreamOutputTopLogprob(BaseInferenceType):
+    logprob: float
+    token: str
+
+
+@dataclass
+class ChatCompletionStreamOutputLogprob(BaseInferenceType):
+    logprob: float
+    token: str
+    top_logprobs: List[ChatCompletionStreamOutputTopLogprob]
+
+
+@dataclass
+class ChatCompletionStreamOutputLogprobs(BaseInferenceType):
+    content: List[ChatCompletionStreamOutputLogprob]
 
 
 @dataclass
 class ChatCompletionStreamOutputChoice(BaseInferenceType):
     delta: ChatCompletionStreamOutputDelta
-    """A chat completion delta generated by streamed model responses."""
     index: int
-    """The index of the choice in the list of choices."""
-    finish_reason: Optional["ChatCompletionFinishReason"] = None
-    """The reason why the generation was stopped."""
+    finish_reason: Optional[str] = None
+    logprobs: Optional[ChatCompletionStreamOutputLogprobs] = None
 
 
 @dataclass
 class ChatCompletionStreamOutput(BaseInferenceType):
-    """Chat Completion Stream Output"""
+    """Chat Completion Stream Output.
+    Auto-generated from TGI specs.
+    For more details, check out
+    https://github.com/huggingface/huggingface.js/blob/main/packages/tasks/scripts/inference-tgi-import.ts.
+    """
 
     choices: List[ChatCompletionStreamOutputChoice]
-    """A list of chat completion choices."""
     created: int
-    """The Unix timestamp (in seconds) of when the chat completion was created. Each chunk has
-    the same timestamp.
-    """
+    id: str
+    model: str
+    object: str
+    system_fingerprint: str

huggingface_hub/inference/_generated/types/text_generation.py

@@ -4,158 +4,136 @@
 #   - script: https://github.com/huggingface/huggingface.js/blob/main/packages/tasks/scripts/inference-codegen.ts
 #   - specs:  https://github.com/huggingface/huggingface.js/tree/main/packages/tasks/src/tasks.
 from dataclasses import dataclass
-from typing import List, Literal, Optional
+from typing import Any, List, Literal, Optional
 
 from .base import BaseInferenceType
 
 
+TypeEnum = Literal["json", "regex"]
+
+
 @dataclass
-class TextGenerationParameters(BaseInferenceType):
-    """Additional inference parameters
-    Additional inference parameters for Text Generation
+class TextGenerationInputGrammarType(BaseInferenceType):
+    type: "TypeEnum"
+    value: Any
+    """A string that represents a [JSON Schema](https://json-schema.org/).
+    JSON Schema is a declarative language that allows to annotate JSON documents
+    with types and descriptions.
     """
 
+
+@dataclass
+class TextGenerationInputGenerateParameters(BaseInferenceType):
     best_of: Optional[int] = None
-    """The number of sampling queries to run. Only the best one (in terms of total logprob) will
-    be returned.
-    """
     decoder_input_details: Optional[bool] = None
-    """Whether or not to output decoder input details"""
     details: Optional[bool] = None
-    """Whether or not to output details"""
     do_sample: Optional[bool] = None
-    """Whether to use logits sampling instead of greedy decoding when generating new tokens."""
+    frequency_penalty: Optional[float] = None
+    grammar: Optional[TextGenerationInputGrammarType] = None
     max_new_tokens: Optional[int] = None
-    """The maximum number of tokens to generate."""
     repetition_penalty: Optional[float] = None
-    """The parameter for repetition penalty. A value of 1.0 means no penalty. See [this
-    paper](https://hf.co/papers/1909.05858) for more details.
-    """
     return_full_text: Optional[bool] = None
-    """Whether to prepend the prompt to the generated text."""
     seed: Optional[int] = None
-    """The random sampling seed."""
-    stop_sequences: Optional[List[str]] = None
-    """Stop generating tokens if a member of `stop_sequences` is generated."""
+    stop: Optional[List[str]] = None
     temperature: Optional[float] = None
-    """The value used to modulate the logits distribution."""
     top_k: Optional[int] = None
-    """The number of highest probability vocabulary tokens to keep for top-k-filtering."""
+    top_n_tokens: Optional[int] = None
     top_p: Optional[float] = None
-    """If set to < 1, only the smallest set of most probable tokens with probabilities that add
-    up to `top_p` or higher are kept for generation.
-    """
     truncate: Optional[int] = None
-    """Truncate input tokens to the given size."""
     typical_p: Optional[float] = None
-    """Typical Decoding mass. See [Typical Decoding for Natural Language
-    Generation](https://hf.co/papers/2202.00666) for more information
-    """
     watermark: Optional[bool] = None
-    """Watermarking with [A Watermark for Large Language Models](https://hf.co/papers/2301.10226)"""
 
 
 @dataclass
 class TextGenerationInput(BaseInferenceType):
-    """Inputs for Text Generation inference"""
+    """Text Generation Input.
+    Auto-generated from TGI specs.
+    For more details, check out
+    https://github.com/huggingface/huggingface.js/blob/main/packages/tasks/scripts/inference-tgi-import.ts.
+    """
 
     inputs: str
-    """The text to initialize generation with"""
-    parameters: Optional[TextGenerationParameters] = None
-    """Additional inference parameters"""
+    parameters: Optional[TextGenerationInputGenerateParameters] = None
     stream: Optional[bool] = None
-    """Whether to stream output tokens"""
 
 
-TextGenerationFinishReason = Literal["length", "eos_token", "stop_sequence"]
+TextGenerationOutputFinishReason = Literal["length", "eos_token", "stop_sequence"]
 
 
 @dataclass
-class TextGenerationPrefillToken(BaseInferenceType):
+class TextGenerationOutputPrefillToken(BaseInferenceType):
     id: int
     logprob: float
     text: str
-    """The text associated with that token"""
 
 
 @dataclass
 class TextGenerationOutputToken(BaseInferenceType):
-    """Generated token."""
-
     id: int
+    logprob: float
     special: bool
-    """Whether or not that token is a special one"""
     text: str
-    """The text associated with that token"""
-    logprob: Optional[float] = None
 
 
 @dataclass
-class TextGenerationOutputSequenceDetails(BaseInferenceType):
-    finish_reason: "TextGenerationFinishReason"
+class TextGenerationOutputBestOfSequence(BaseInferenceType):
+    finish_reason: "TextGenerationOutputFinishReason"
     generated_text: str
-    """The generated text"""
     generated_tokens: int
-    """The number of generated tokens"""
-    prefill: List[TextGenerationPrefillToken]
+    prefill: List[TextGenerationOutputPrefillToken]
     tokens: List[TextGenerationOutputToken]
-    """The generated tokens and associated details"""
     seed: Optional[int] = None
-    """The random seed used for generation"""
     top_tokens: Optional[List[List[TextGenerationOutputToken]]] = None
-    """Most likely tokens"""
 
 
 @dataclass
 class TextGenerationOutputDetails(BaseInferenceType):
-    """When enabled, details about the generation"""
-
-    finish_reason: "TextGenerationFinishReason"
-    """The reason why the generation was stopped."""
+    finish_reason: "TextGenerationOutputFinishReason"
     generated_tokens: int
-    """The number of generated tokens"""
-    prefill: List[TextGenerationPrefillToken]
+    prefill: List[TextGenerationOutputPrefillToken]
     tokens: List[TextGenerationOutputToken]
-    """The generated tokens and associated details"""
-    best_of_sequences: Optional[List[TextGenerationOutputSequenceDetails]] = None
-    """Details about additional sequences when best_of is provided"""
+    best_of_sequences: Optional[List[TextGenerationOutputBestOfSequence]] = None
     seed: Optional[int] = None
-    """The random seed used for generation"""
     top_tokens: Optional[List[List[TextGenerationOutputToken]]] = None
-    """Most likely tokens"""
 
 
 @dataclass
 class TextGenerationOutput(BaseInferenceType):
-    """Outputs for Text Generation inference"""
+    """Text Generation Output.
+    Auto-generated from TGI specs.
+    For more details, check out
+    https://github.com/huggingface/huggingface.js/blob/main/packages/tasks/scripts/inference-tgi-import.ts.
+    """
 
     generated_text: str
-    """The generated text"""
     details: Optional[TextGenerationOutputDetails] = None
-    """When enabled, details about the generation"""
 
 
 @dataclass
-class TextGenerationStreamDetails(BaseInferenceType):
-    """Generation details. Only available when the generation is finished."""
-
-    finish_reason: "TextGenerationFinishReason"
-    """The reason why the generation was stopped."""
+class TextGenerationStreamOutputStreamDetails(BaseInferenceType):
+    finish_reason: "TextGenerationOutputFinishReason"
     generated_tokens: int
-    """The number of generated tokens"""
-    seed: int
-    """The random seed used for generation"""
+    seed: Optional[int] = None
+
+
+@dataclass
+class TextGenerationStreamOutputToken(BaseInferenceType):
+    id: int
+    logprob: float
+    special: bool
+    text: str
 
 
 @dataclass
 class TextGenerationStreamOutput(BaseInferenceType):
-    """Text Generation Stream Output"""
+    """Text Generation Stream Output.
+    Auto-generated from TGI specs.
+    For more details, check out
+    https://github.com/huggingface/huggingface.js/blob/main/packages/tasks/scripts/inference-tgi-import.ts.
+    """
 
-    token: TextGenerationOutputToken
-    """Generated token."""
-    details: Optional[TextGenerationStreamDetails] = None
-    """Generation details. Only available when the generation is finished."""
+    index: int
+    token: TextGenerationStreamOutputToken
+    details: Optional[TextGenerationStreamOutputStreamDetails] = None
     generated_text: Optional[str] = None
-    """The complete generated text. Only available when the generation is finished."""
-    index: Optional[int] = None
-    """The token index within the stream. Optional to support older clients that omit it."""
+    top_tokens: Optional[List[TextGenerationStreamOutputToken]] = None

huggingface_hub/inference/_templating.py

@@ -1,11 +1,9 @@
 from functools import lru_cache
 from typing import Callable, Dict, List, Optional, Union
 
-from ..utils import HfHubHTTPError, RepositoryNotFoundError, is_minijinja_available
-
+from huggingface_hub.errors import TemplateError
 
-class TemplateError(Exception):
-    """Any error raised while trying to fetch or render a chat template."""
+from ..utils import HfHubHTTPError, RepositoryNotFoundError, is_minijinja_available
 
 
 def _import_minijinja():

huggingface_hub/keras_mixin.py

@@ -265,9 +265,6 @@ def from_pretrained_keras(*args, **kwargs) -> "KerasModelHubMixin":
         force_download (`bool`, *optional*, defaults to `False`):
             Whether to force the (re-)download of the model weights and
             configuration files, overriding the cached versions if they exist.
-        resume_download (`bool`, *optional*, defaults to `False`):
-            Whether to delete incompletely received files. Will attempt to
-            resume the download if such a file exists.
         proxies (`Dict[str, str]`, *optional*):
             A dictionary of proxy servers to use by protocol or endpoint, e.g.,
             `{'http': 'foo.bar:3128', 'http://hostname': 'foo.bar:4012'}`. The

huggingface_hub/lfs.py

@@ -31,6 +31,7 @@ from huggingface_hub.constants import ENDPOINT, HF_HUB_ENABLE_HF_TRANSFER, REPO_
 
 from .utils import (
     build_hf_headers,
+    fix_hf_endpoint_in_url,
     get_session,
     hf_raise_for_status,
     http_backoff,
@@ -193,6 +194,7 @@ def lfs_upload(
     lfs_batch_action: Dict,
     token: Optional[str] = None,
     headers: Optional[Dict[str, str]] = None,
+    endpoint: Optional[str] = None,
 ) -> None:
     """
     Handles uploading a given object to the Hub with the LFS protocol.
@@ -230,6 +232,7 @@ def lfs_upload(
     # 2. Upload file (either single part or multi-part)
     header = upload_action.get("header", {})
     chunk_size = header.get("chunk_size")
+    upload_url = fix_hf_endpoint_in_url(upload_action["href"], endpoint=endpoint)
     if chunk_size is not None:
         try:
             chunk_size = int(chunk_size)
@@ -237,15 +240,16 @@ def lfs_upload(
             raise ValueError(
                 f"Malformed response from LFS batch endpoint: `chunk_size` should be an integer. Got '{chunk_size}'."
             )
-        _upload_multi_part(operation=operation, header=header, chunk_size=chunk_size, upload_url=upload_action["href"])
+        _upload_multi_part(operation=operation, header=header, chunk_size=chunk_size, upload_url=upload_url)
     else:
-        _upload_single_part(operation=operation, upload_url=upload_action["href"])
+        _upload_single_part(operation=operation, upload_url=upload_url)
 
     # 3. Verify upload went well
     if verify_action is not None:
         _validate_lfs_action(verify_action)
+        verify_url = fix_hf_endpoint_in_url(verify_action["href"], endpoint)
         verify_resp = get_session().post(
-            verify_action["href"],
+            verify_url,
             headers=build_hf_headers(token=token, headers=headers),
             json={"oid": operation.upload_info.sha256.hex(), "size": operation.upload_info.size},
         )
@@ -426,7 +430,15 @@ def _upload_parts_hf_transfer(
     # see https://github.com/huggingface/huggingface_hub/pull/2000
     disable = True if (logger.getEffectiveLevel() == logging.NOTSET) else None
 
-    with tqdm(unit="B", unit_scale=True, total=total, initial=0, desc=desc, disable=disable) as progress:
+    with tqdm(
+        unit="B",
+        unit_scale=True,
+        total=total,
+        initial=0,
+        desc=desc,
+        disable=disable,
+        name="huggingface_hub.lfs_upload",
+    ) as progress:
         try:
             output = multipart_upload(
                 file_path=operation.path_or_fileobj,

huggingface_hub/repository.py

@@ -395,6 +395,7 @@ def _lfs_log_progress():
                         unit="B",
                         unit_scale=True,
                         unit_divisor=1024,
+                        name="huggingface_hub.lfs_upload",
                     ),
                     "past_bytes": int(current_bytes),
                 }