huggingface-hub 0.23.5__py3-none-any.whl → 0.24.0rc0__py3-none-any.whl

huggingface_hub/inference/_generated/types/__init__.py

@@ -20,10 +20,13 @@ from .base import BaseInferenceType
 from .chat_completion import (
     ChatCompletionInput,
     ChatCompletionInputFunctionDefinition,
+    ChatCompletionInputFunctionName,
+    ChatCompletionInputGrammarType,
     ChatCompletionInputMessage,
+    ChatCompletionInputMessageChunk,
     ChatCompletionInputTool,
-    ChatCompletionInputToolCall,
     ChatCompletionInputToolTypeClass,
+    ChatCompletionInputURL,
     ChatCompletionOutput,
     ChatCompletionOutputComplete,
     ChatCompletionOutputFunctionDefinition,

huggingface_hub/inference/_generated/types/chat_completion.py

@@ -10,33 +10,55 @@ from .base import BaseInferenceType
 
 
 @dataclass
-class ChatCompletionInputFunctionDefinition(BaseInferenceType):
-    arguments: Any
-    name: str
-    description: Optional[str] = None
+class ChatCompletionInputURL(BaseInferenceType):
+    url: str
+
+
+ChatCompletionInputMessageChunkType = Literal["text", "image_url"]
 
 
 @dataclass
-class ChatCompletionInputToolCall(BaseInferenceType):
-    function: ChatCompletionInputFunctionDefinition
-    id: int
-    type: str
+class ChatCompletionInputMessageChunk(BaseInferenceType):
+    type: "ChatCompletionInputMessageChunkType"
+    image_url: Optional[ChatCompletionInputURL] = None
+    text: Optional[str] = None
 
 
 @dataclass
 class ChatCompletionInputMessage(BaseInferenceType):
+    content: Union[List[ChatCompletionInputMessageChunk], str]
     role: str
-    content: Optional[str] = None
     name: Optional[str] = None
-    tool_calls: Optional[List[ChatCompletionInputToolCall]] = None
+
+
+ChatCompletionInputGrammarTypeType = Literal["json", "regex"]
+
+
+@dataclass
+class ChatCompletionInputGrammarType(BaseInferenceType):
+    type: "ChatCompletionInputGrammarTypeType"
+    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 ChatCompletionInputFunctionName(BaseInferenceType):
+    name: str
 
 
 @dataclass
 class ChatCompletionInputToolTypeClass(BaseInferenceType):
-    function_name: str
+    function: Optional[ChatCompletionInputFunctionName] = None
 
 
-ChatCompletionInputToolTypeEnum = Literal["OneOf"]
+@dataclass
+class ChatCompletionInputFunctionDefinition(BaseInferenceType):
+    arguments: Any
+    name: str
+    description: Optional[str] = None
 
 
 @dataclass
@@ -55,10 +77,6 @@ class ChatCompletionInput(BaseInferenceType):
 
     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,
@@ -83,6 +101,10 @@ class ChatCompletionInput(BaseInferenceType):
     """
     max_tokens: Optional[int] = None
     """The maximum number of tokens that can be generated in the chat completion."""
+    model: Optional[str] = None
+    """[UNUSED] ID of the model to use. See the model endpoint compatibility table for details
+    on which models work with the Chat API.
+    """
     n: Optional[int] = None
     """UNUSED
     How many chat completion choices to generate for each input message. Note that you will
@@ -94,6 +116,7 @@ class ChatCompletionInput(BaseInferenceType):
     appear in the text so far,
     increasing the model's likelihood to talk about new topics
     """
+    response_format: Optional[ChatCompletionInputGrammarType] = None
     seed: Optional[int] = None
     stop: Optional[List[str]] = None
     """Up to 4 sequences where the API will stop generating further tokens."""
@@ -104,7 +127,7 @@ class ChatCompletionInput(BaseInferenceType):
     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_choice: Optional[Union[ChatCompletionInputToolTypeClass, str]] = None
     tool_prompt: Optional[str] = None
     """A prompt to be appended before the tools"""
     tools: Optional[List[ChatCompletionInputTool]] = None
@@ -153,7 +176,7 @@ class ChatCompletionOutputFunctionDefinition(BaseInferenceType):
 @dataclass
 class ChatCompletionOutputToolCall(BaseInferenceType):
     function: ChatCompletionOutputFunctionDefinition
-    id: int
+    id: str
     type: str
 
 
@@ -161,7 +184,6 @@ class ChatCompletionOutputToolCall(BaseInferenceType):
 class ChatCompletionOutputMessage(BaseInferenceType):
     role: str
     content: Optional[str] = None
-    name: Optional[str] = None
     tool_calls: Optional[List[ChatCompletionOutputToolCall]] = None
 
 
@@ -192,7 +214,6 @@ class ChatCompletionOutput(BaseInferenceType):
     created: int
     id: str
     model: str
-    object: str
     system_fingerprint: str
     usage: ChatCompletionOutputUsage
 
@@ -256,5 +277,4 @@ class ChatCompletionStreamOutput(BaseInferenceType):
     created: int
     id: str
     model: str
-    object: str
     system_fingerprint: str

huggingface_hub/inference/_generated/types/feature_extraction.py

@@ -4,16 +4,34 @@
 #   - 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 Any, Dict, Optional
+from typing import Literal, Optional
 
 from .base import BaseInferenceType
 
 
+FeatureExtractionInputTruncationDirection = Literal["Left", "Right"]
+
+
 @dataclass
 class FeatureExtractionInput(BaseInferenceType):
-    """Inputs for Text Embedding inference"""
+    """Feature Extraction Input.
+    Auto-generated from TEI specs.
+    For more details, check out
+    https://github.com/huggingface/huggingface.js/blob/main/packages/tasks/scripts/inference-tei-import.ts.
+    """
 
     inputs: str
-    """The text to get the embeddings of"""
-    parameters: Optional[Dict[str, Any]] = None
-    """Additional inference parameters"""
+    """The text to embed."""
+    normalize: Optional[bool] = None
+    prompt_name: Optional[str] = None
+    """The name of the prompt that should be used by for encoding. If not set, no prompt
+    will be applied.
+    Must be a key in the `Sentence Transformers` configuration `prompts` dictionary.
+    For example if ``prompt_name`` is "query" and the ``prompts`` is {"query": "query: ",
+    ...},
+    then the sentence "What is the capital of France?" will be encoded as
+    "query: What is the capital of France?" because the prompt text will be prepended before
+    any text to encode.
+    """
+    truncate: Optional[bool] = None
+    truncation_direction: Optional["FeatureExtractionInputTruncationDirection"] = None

huggingface_hub/inference/_generated/types/text_generation.py

@@ -24,24 +24,53 @@ class TextGenerationInputGrammarType(BaseInferenceType):
 
 @dataclass
 class TextGenerationInputGenerateParameters(BaseInferenceType):
+    adapter_id: Optional[str] = None
+    """Lora adapter id"""
     best_of: Optional[int] = None
+    """Generate best_of sequences and return the one if the highest token logprobs."""
     decoder_input_details: Optional[bool] = None
+    """Whether to return decoder input token logprobs and ids."""
     details: Optional[bool] = None
+    """Whether to return generation details."""
     do_sample: Optional[bool] = None
+    """Activate logits sampling."""
     frequency_penalty: Optional[float] = None
+    """The parameter for frequency penalty. 1.0 means no penalty
+    Penalize new tokens based on their existing frequency in the text so far,
+    decreasing the model's likelihood to repeat the same line verbatim.
+    """
     grammar: Optional[TextGenerationInputGrammarType] = None
     max_new_tokens: Optional[int] = None
+    """Maximum number of tokens to generate."""
     repetition_penalty: Optional[float] = None
+    """The parameter for repetition penalty. 1.0 means no penalty.
+    See [this paper](https://arxiv.org/pdf/1909.05858.pdf) for more details.
+    """
     return_full_text: Optional[bool] = None
+    """Whether to prepend the prompt to the generated text"""
     seed: Optional[int] = None
+    """Random sampling seed."""
     stop: Optional[List[str]] = None
+    """Stop generating tokens if a member of `stop` is generated."""
     temperature: Optional[float] = None
+    """The value used to module 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
+    """The number of highest probability vocabulary tokens to keep for top-n-filtering."""
     top_p: Optional[float] = None
+    """Top-p value for nucleus sampling."""
     truncate: Optional[int] = None
+    """Truncate inputs tokens to the given size."""
     typical_p: Optional[float] = None
+    """Typical Decoding mass
+    See [Typical Decoding for Natural Language Generation](https://arxiv.org/abs/2202.00666)
+    for more information.
+    """
     watermark: Optional[bool] = None
+    """Watermarking with [A Watermark for Large Language
+    Models](https://arxiv.org/abs/2301.10226).
+    """
 
 
 @dataclass

huggingface_hub/lfs.py

@@ -134,9 +134,10 @@ def post_lfs_batch_info(
             - Second element is an list of errors, if any
 
     Raises:
-        `ValueError`: If an argument is invalid or the server response is malformed
-
-        `HTTPError`: If the server returned an error
+        [`ValueError`](https://docs.python.org/3/library/exceptions.html#ValueError)
+            If an argument is invalid or the server response is malformed.
+        [`HTTPError`](https://requests.readthedocs.io/en/latest/api/#requests.HTTPError)
+            If the server returned an error.
     """
     endpoint = endpoint if endpoint is not None else ENDPOINT
     url_prefix = ""
@@ -211,8 +212,10 @@ def lfs_upload(
             Headers to include in the request, including authentication and user agent headers.
 
     Raises:
-        - `ValueError` if `lfs_batch_action` is improperly formatted
-        - `HTTPError` if the upload resulted in an error
+        [`ValueError`](https://docs.python.org/3/library/exceptions.html#ValueError)
+            If `lfs_batch_action` is improperly formatted
+        [`HTTPError`](https://requests.readthedocs.io/en/latest/api/#requests.HTTPError)
+            If the upload resulted in an error
     """
     # 0. If LFS file is already present, skip upload
     _validate_batch_actions(lfs_batch_action)
@@ -307,7 +310,9 @@ def _upload_single_part(operation: "CommitOperationAdd", upload_url: str) -> Non
 
     Returns: `requests.Response`
 
-    Raises: `requests.HTTPError` if the upload resulted in an error
+    Raises:
+     [`HTTPError`](https://requests.readthedocs.io/en/latest/api/#requests.HTTPError)
+        If the upload resulted in an error.
     """
     with operation.as_file(with_tqdm=True) as fileobj:
         # S3 might raise a transient 500 error -> let's retry if that happens

huggingface_hub/repocard_data.py

@@ -55,7 +55,7 @@ class EvalResult:
         source_name (`str`, *optional*):
             The name of the source of the evaluation result. Example: "Open LLM Leaderboard".
         source_url (`str`, *optional*):
-            The URL of the source of the evaluation result. Example: "https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard".
+            The URL of the source of the evaluation result. Example: "https://huggingface.co/spaces/open-llm-leaderboard/open_llm_leaderboard".
     """
 
     # Required
@@ -128,7 +128,7 @@ class EvalResult:
     source_name: Optional[str] = None
 
     # The URL of the source of the evaluation result.
-    # Example: https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard
+    # Example: https://huggingface.co/spaces/open-llm-leaderboard/open_llm_leaderboard
     source_url: Optional[str] = None
 
     @property
@@ -350,7 +350,7 @@ class ModelCardData(CardData):
         super().__init__(**kwargs)
 
         if self.eval_results:
-            if type(self.eval_results) == EvalResult:
+            if isinstance(self.eval_results, EvalResult):
                 self.eval_results = [self.eval_results]
             if self.model_name is None:
                 raise ValueError("Passing `eval_results` requires `model_name` to be set.")

huggingface_hub/repository.py

@@ -507,8 +507,8 @@ class Repository:
                 instance will be created if this is left to `None`.
 
         Raises:
-            - [`EnvironmentError`](https://docs.python.org/3/library/exceptions.html#EnvironmentError)
-              if the remote repository set in `clone_from` does not exist.
+            [`EnvironmentError`](https://docs.python.org/3/library/exceptions.html#EnvironmentError)
+                If the remote repository set in `clone_from` does not exist.
         """
         if isinstance(local_dir, Path):
             local_dir = str(local_dir)
@@ -542,10 +542,10 @@ class Repository:
             user = self.client.whoami(self.huggingface_token)
 
             if git_email is None:
-                git_email = user["email"]
+                git_email = user.get("email")
 
             if git_user is None:
-                git_user = user["fullname"]
+                git_user = user.get("fullname")
 
         if git_user is not None or git_email is not None:
             self.git_config_username_and_email(git_user, git_email)
@@ -580,8 +580,8 @@ class Repository:
         Checks that `git` and `git-lfs` can be run.
 
         Raises:
-            - [`EnvironmentError`](https://docs.python.org/3/library/exceptions.html#EnvironmentError)
-              if `git` or `git-lfs` are not installed.
+            [`EnvironmentError`](https://docs.python.org/3/library/exceptions.html#EnvironmentError)
+                If `git` or `git-lfs` are not installed.
         """
         try:
             git_version = run_subprocess("git --version", self.local_dir).stdout.strip()

huggingface_hub/serialization/__init__.py

@@ -15,6 +15,11 @@
 """Contains helpers to serialize tensors."""
 
 from ._base import StateDictSplit, split_state_dict_into_shards_factory
-from ._numpy import split_numpy_state_dict_into_shards
-from ._tensorflow import split_tf_state_dict_into_shards
-from ._torch import split_torch_state_dict_into_shards
+from ._tensorflow import get_tf_storage_size, split_tf_state_dict_into_shards
+from ._torch import (
+    get_torch_storage_id,
+    get_torch_storage_size,
+    save_torch_model,
+    save_torch_state_dict,
+    split_torch_state_dict_into_shards,
+)

huggingface_hub/serialization/_base.py

@@ -23,8 +23,14 @@ TensorT = TypeVar("TensorT")
 TensorSizeFn_T = Callable[[TensorT], int]
 StorageIDFn_T = Callable[[TensorT], Optional[Any]]
 
-MAX_SHARD_SIZE = 5_000_000_000  # 5GB
-FILENAME_PATTERN = "model{suffix}.safetensors"
+MAX_SHARD_SIZE = "5GB"
+SIZE_UNITS = {
+    "TB": 10**12,
+    "GB": 10**9,
+    "MB": 10**6,
+    "KB": 10**3,
+}
+
 
 logger = logging.get_logger(__file__)
 
@@ -43,9 +49,9 @@ class StateDictSplit:
 def split_state_dict_into_shards_factory(
     state_dict: Dict[str, TensorT],
     *,
-    get_tensor_size: TensorSizeFn_T,
+    get_storage_size: TensorSizeFn_T,
+    filename_pattern: str,
     get_storage_id: StorageIDFn_T = lambda tensor: None,
-    filename_pattern: str = FILENAME_PATTERN,
     max_shard_size: Union[int, str] = MAX_SHARD_SIZE,
 ) -> StateDictSplit:
     """
@@ -66,8 +72,8 @@ def split_state_dict_into_shards_factory(
     Args:
         state_dict (`Dict[str, Tensor]`):
             The state dictionary to save.
-        get_tensor_size (`Callable[[Tensor], int]`):
-            A function that returns the size of a tensor in bytes.
+        get_storage_size (`Callable[[Tensor], int]`):
+            A function that returns the size of a tensor when saved on disk in bytes.
         get_storage_id (`Callable[[Tensor], Optional[Any]]`, *optional*):
             A function that returns a unique identifier to a tensor storage. Multiple different tensors can share the
             same underlying storage. This identifier is guaranteed to be unique and constant for this tensor's storage
@@ -75,7 +81,6 @@ def split_state_dict_into_shards_factory(
         filename_pattern (`str`, *optional*):
             The pattern to generate the files names in which the model will be saved. Pattern must be a string that
             can be formatted with `filename_pattern.format(suffix=...)` and must contain the keyword `suffix`
-            Defaults to `"model{suffix}.safetensors"`.
         max_shard_size (`int` or `str`, *optional*):
             The maximum size of each shard, in bytes. Defaults to 5GB.
 
@@ -112,7 +117,7 @@ def split_state_dict_into_shards_factory(
                 storage_id_to_tensors[storage_id] = [key]
 
         # Compute tensor size
-        tensor_size = get_tensor_size(tensor)
+        tensor_size = get_storage_size(tensor)
 
         # If this tensor is bigger than the maximal size, we put it in its own shard
         if tensor_size > max_shard_size:
@@ -172,14 +177,6 @@ def split_state_dict_into_shards_factory(
     )
 
 
-SIZE_UNITS = {
-    "TB": 10**12,
-    "GB": 10**9,
-    "MB": 10**6,
-    "KB": 10**3,
-}
-
-
 def parse_size_to_int(size_as_str: str) -> int:
     """
     Parse a size expressed as a string with digits and unit (like `"5MB"`) to an integer (in bytes).

huggingface_hub/serialization/_tensorflow.py

@@ -17,6 +17,7 @@ import math
 import re
 from typing import TYPE_CHECKING, Dict, Union
 
+from .. import constants
 from ._base import MAX_SHARD_SIZE, StateDictSplit, split_state_dict_into_shards_factory
 
 
@@ -27,7 +28,7 @@ if TYPE_CHECKING:
 def split_tf_state_dict_into_shards(
     state_dict: Dict[str, "tf.Tensor"],
     *,
-    filename_pattern: str = "tf_model{suffix}.h5",
+    filename_pattern: str = constants.TF2_WEIGHTS_FILE_PATTERN,
     max_shard_size: Union[int, str] = MAX_SHARD_SIZE,
 ) -> StateDictSplit:
     """
@@ -62,11 +63,11 @@ def split_tf_state_dict_into_shards(
         state_dict,
         max_shard_size=max_shard_size,
         filename_pattern=filename_pattern,
-        get_tensor_size=get_tensor_size,
+        get_storage_size=get_tf_storage_size,
     )
 
 
-def get_tensor_size(tensor: "tf.Tensor") -> int:
+def get_tf_storage_size(tensor: "tf.Tensor") -> int:
     # Return `math.ceil` since dtype byte size can be a float (e.g., 0.125 for tf.bool).
     # Better to overestimate than underestimate.
     return math.ceil(tensor.numpy().size * _dtype_byte_size_tf(tensor.dtype))