huggingface-hub 0.31.2__py3-none-any.whl → 0.31.3__py3-none-any.whl

huggingface_hub/__init__.py

@@ -46,7 +46,7 @@ import sys
 from typing import TYPE_CHECKING
 
 
-__version__ = "0.31.2"
+__version__ = "0.31.3"
 
 # Alphabetical order of definitions is ensured in tests
 # WARNING: any comment added in this dictionary definition will be lost when

huggingface_hub/constants.py

@@ -82,6 +82,17 @@ INFERENCE_ENDPOINT = os.environ.get("HF_INFERENCE_ENDPOINT", "https://api-infere
 INFERENCE_ENDPOINTS_ENDPOINT = "https://api.endpoints.huggingface.cloud/v2"
 INFERENCE_CATALOG_ENDPOINT = "https://endpoints.huggingface.co/api/catalog"
 
+# See https://api.endpoints.huggingface.cloud/#post-/v2/endpoint/-namespace-
+INFERENCE_ENDPOINT_IMAGE_KEYS = [
+    "custom",
+    "huggingface",
+    "huggingfaceNeuron",
+    "llamacpp",
+    "tei",
+    "tgi",
+    "tgiNeuron",
+]
+
 # Proxy for third-party providers
 INFERENCE_PROXY_TEMPLATE = "https://router.huggingface.co/{provider}"
 

huggingface_hub/dataclasses.py

@@ -0,0 +1,481 @@
+import inspect
+from dataclasses import _MISSING_TYPE, MISSING, Field, field, fields
+from functools import wraps
+from typing import (
+    Any,
+    Callable,
+    Dict,
+    List,
+    Literal,
+    Optional,
+    Tuple,
+    Type,
+    TypeVar,
+    Union,
+    get_args,
+    get_origin,
+    overload,
+)
+
+from .errors import (
+    StrictDataclassClassValidationError,
+    StrictDataclassDefinitionError,
+    StrictDataclassFieldValidationError,
+)
+
+
+Validator_T = Callable[[Any], None]
+T = TypeVar("T")
+
+
+# The overload decorator helps type checkers understand the different return types
+@overload
+def strict(cls: Type[T]) -> Type[T]: ...
+
+
+@overload
+def strict(*, accept_kwargs: bool = False) -> Callable[[Type[T]], Type[T]]: ...
+
+
+def strict(
+    cls: Optional[Type[T]] = None, *, accept_kwargs: bool = False
+) -> Union[Type[T], Callable[[Type[T]], Type[T]]]:
+    """
+    Decorator to add strict validation to a dataclass.
+
+    This decorator must be used on top of `@dataclass` to ensure IDEs and static typing tools
+    recognize the class as a dataclass.
+
+    Can be used with or without arguments:
+    - `@strict`
+    - `@strict(accept_kwargs=True)`
+
+    Args:
+        cls:
+            The class to convert to a strict dataclass.
+        accept_kwargs (`bool`, *optional*):
+            If True, allows arbitrary keyword arguments in `__init__`. Defaults to False.
+
+    Returns:
+        The enhanced dataclass with strict validation on field assignment.
+
+    Example:
+    ```py
+    >>> from dataclasses import dataclass
+    >>> from huggingface_hub.dataclasses import as_validated_field, strict, validated_field
+
+    >>> @as_validated_field
+    >>> def positive_int(value: int):
+    ...     if not value >= 0:
+    ...         raise ValueError(f"Value must be positive, got {value}")
+
+    >>> @strict(accept_kwargs=True)
+    ... @dataclass
+    ... class User:
+    ...     name: str
+    ...     age: int = positive_int(default=10)
+
+    # Initialize
+    >>> User(name="John")
+    User(name='John', age=10)
+
+    # Extra kwargs are accepted
+    >>> User(name="John", age=30, lastname="Doe")
+    User(name='John', age=30, *lastname='Doe')
+
+    # Invalid type => raises
+    >>> User(name="John", age="30")
+    huggingface_hub.errors.StrictDataclassFieldValidationError: Validation error for field 'age':
+        TypeError: Field 'age' expected int, got str (value: '30')
+
+    # Invalid value => raises
+    >>> User(name="John", age=-1)
+    huggingface_hub.errors.StrictDataclassFieldValidationError: Validation error for field 'age':
+        ValueError: Value must be positive, got -1
+    ```
+    """
+
+    def wrap(cls: Type[T]) -> Type[T]:
+        if not hasattr(cls, "__dataclass_fields__"):
+            raise StrictDataclassDefinitionError(
+                f"Class '{cls.__name__}' must be a dataclass before applying @strict."
+            )
+
+        # List and store validators
+        field_validators: Dict[str, List[Validator_T]] = {}
+        for f in fields(cls):  # type: ignore [arg-type]
+            validators = []
+            validators.append(_create_type_validator(f))
+            custom_validator = f.metadata.get("validator")
+            if custom_validator is not None:
+                if not isinstance(custom_validator, list):
+                    custom_validator = [custom_validator]
+                for validator in custom_validator:
+                    if not _is_validator(validator):
+                        raise StrictDataclassDefinitionError(
+                            f"Invalid validator for field '{f.name}': {validator}. Must be a callable taking a single argument."
+                        )
+                validators.extend(custom_validator)
+            field_validators[f.name] = validators
+        cls.__validators__ = field_validators  # type: ignore
+
+        # Override __setattr__ to validate fields on assignment
+        original_setattr = cls.__setattr__
+
+        def __strict_setattr__(self: Any, name: str, value: Any) -> None:
+            """Custom __setattr__ method for strict dataclasses."""
+            # Run all validators
+            for validator in self.__validators__.get(name, []):
+                try:
+                    validator(value)
+                except (ValueError, TypeError) as e:
+                    raise StrictDataclassFieldValidationError(field=name, cause=e) from e
+
+            # If validation passed, set the attribute
+            original_setattr(self, name, value)
+
+        cls.__setattr__ = __strict_setattr__  # type: ignore[method-assign]
+
+        if accept_kwargs:
+            # (optional) Override __init__ to accept arbitrary keyword arguments
+            original_init = cls.__init__
+
+            @wraps(original_init)
+            def __init__(self, **kwargs: Any) -> None:
+                # Extract only the fields that are part of the dataclass
+                dataclass_fields = {f.name for f in fields(cls)}  # type: ignore [arg-type]
+                standard_kwargs = {k: v for k, v in kwargs.items() if k in dataclass_fields}
+
+                # Call the original __init__ with standard fields
+                original_init(self, **standard_kwargs)
+
+                # Add any additional kwargs as attributes
+                for name, value in kwargs.items():
+                    if name not in dataclass_fields:
+                        self.__setattr__(name, value)
+
+            cls.__init__ = __init__  # type: ignore[method-assign]
+
+            # (optional) Override __repr__ to include additional kwargs
+            original_repr = cls.__repr__
+
+            @wraps(original_repr)
+            def __repr__(self) -> str:
+                # Call the original __repr__ to get the standard fields
+                standard_repr = original_repr(self)
+
+                # Get additional kwargs
+                additional_kwargs = [
+                    # add a '*' in front of additional kwargs to let the user know they are not part of the dataclass
+                    f"*{k}={v!r}"
+                    for k, v in self.__dict__.items()
+                    if k not in cls.__dataclass_fields__  # type: ignore [attr-defined]
+                ]
+                additional_repr = ", ".join(additional_kwargs)
+
+                # Combine both representations
+                return f"{standard_repr[:-1]}, {additional_repr})" if additional_kwargs else standard_repr
+
+            cls.__repr__ = __repr__  # type: ignore [method-assign]
+
+        # List all public methods starting with `validate_` => class validators.
+        class_validators = []
+
+        for name in dir(cls):
+            if not name.startswith("validate_"):
+                continue
+            method = getattr(cls, name)
+            if not callable(method):
+                continue
+            if len(inspect.signature(method).parameters) != 1:
+                raise StrictDataclassDefinitionError(
+                    f"Class '{cls.__name__}' has a class validator '{name}' that takes more than one argument."
+                    " Class validators must take only 'self' as an argument. Methods starting with 'validate_'"
+                    " are considered to be class validators."
+                )
+            class_validators.append(method)
+
+        cls.__class_validators__ = class_validators  # type: ignore [attr-defined]
+
+        # Add `validate` method to the class, but first check if it already exists
+        def validate(self: T) -> None:
+            """Run class validators on the instance."""
+            for validator in cls.__class_validators__:  # type: ignore [attr-defined]
+                try:
+                    validator(self)
+                except (ValueError, TypeError) as e:
+                    raise StrictDataclassClassValidationError(validator=validator.__name__, cause=e) from e
+
+        # Hack to be able to raise if `.validate()` already exists except if it was created by this decorator on a parent class
+        # (in which case we just override it)
+        validate.__is_defined_by_strict_decorator__ = True  # type: ignore [attr-defined]
+
+        if hasattr(cls, "validate"):
+            if not getattr(cls.validate, "__is_defined_by_strict_decorator__", False):  # type: ignore [attr-defined]
+                raise StrictDataclassDefinitionError(
+                    f"Class '{cls.__name__}' already implements a method called 'validate'."
+                    " This method name is reserved when using the @strict decorator on a dataclass."
+                    " If you want to keep your own method, please rename it."
+                )
+
+        cls.validate = validate  # type: ignore
+
+        # Run class validators after initialization
+        initial_init = cls.__init__
+
+        @wraps(initial_init)
+        def init_with_validate(self, *args, **kwargs) -> None:
+            """Run class validators after initialization."""
+            initial_init(self, *args, **kwargs)  # type: ignore [call-arg]
+            cls.validate(self)  # type: ignore [attr-defined]
+
+        setattr(cls, "__init__", init_with_validate)
+
+        return cls
+
+    # Return wrapped class or the decorator itself
+    return wrap(cls) if cls is not None else wrap
+
+
+def validated_field(
+    validator: Union[List[Validator_T], Validator_T],
+    default: Union[Any, _MISSING_TYPE] = MISSING,
+    default_factory: Union[Callable[[], Any], _MISSING_TYPE] = MISSING,
+    init: bool = True,
+    repr: bool = True,
+    hash: Optional[bool] = None,
+    compare: bool = True,
+    metadata: Optional[Dict] = None,
+    **kwargs: Any,
+) -> Any:
+    """
+    Create a dataclass field with a custom validator.
+
+    Useful to apply several checks to a field. If only applying one rule, check out the [`as_validated_field`] decorator.
+
+    Args:
+        validator (`Callable` or `List[Callable]`):
+            A method that takes a value as input and raises ValueError/TypeError if the value is invalid.
+            Can be a list of validators to apply multiple checks.
+        **kwargs:
+            Additional arguments to pass to `dataclasses.field()`.
+
+    Returns:
+        A field with the validator attached in metadata
+    """
+    if not isinstance(validator, list):
+        validator = [validator]
+    if metadata is None:
+        metadata = {}
+    metadata["validator"] = validator
+    return field(  # type: ignore
+        default=default,
+        default_factory=default_factory,
+        init=init,
+        repr=repr,
+        hash=hash,
+        compare=compare,
+        metadata=metadata,
+        **kwargs,
+    )
+
+
+def as_validated_field(validator: Validator_T):
+    """
+    Decorates a validator function as a [`validated_field`] (i.e. a dataclass field with a custom validator).
+
+    Args:
+        validator (`Callable`):
+            A method that takes a value as input and raises ValueError/TypeError if the value is invalid.
+    """
+
+    def _inner(
+        default: Union[Any, _MISSING_TYPE] = MISSING,
+        default_factory: Union[Callable[[], Any], _MISSING_TYPE] = MISSING,
+        init: bool = True,
+        repr: bool = True,
+        hash: Optional[bool] = None,
+        compare: bool = True,
+        metadata: Optional[Dict] = None,
+        **kwargs: Any,
+    ):
+        return validated_field(
+            validator,
+            default=default,
+            default_factory=default_factory,
+            init=init,
+            repr=repr,
+            hash=hash,
+            compare=compare,
+            metadata=metadata,
+            **kwargs,
+        )
+
+    return _inner
+
+
+def type_validator(name: str, value: Any, expected_type: Any) -> None:
+    """Validate that 'value' matches 'expected_type'."""
+    origin = get_origin(expected_type)
+    args = get_args(expected_type)
+
+    if expected_type is Any:
+        return
+    elif validator := _BASIC_TYPE_VALIDATORS.get(origin):
+        validator(name, value, args)
+    elif isinstance(expected_type, type):  # simple types
+        _validate_simple_type(name, value, expected_type)
+    else:
+        raise TypeError(f"Unsupported type for field '{name}': {expected_type}")
+
+
+def _validate_union(name: str, value: Any, args: Tuple[Any, ...]) -> None:
+    """Validate that value matches one of the types in a Union."""
+    errors = []
+    for t in args:
+        try:
+            type_validator(name, value, t)
+            return  # Valid if any type matches
+        except TypeError as e:
+            errors.append(str(e))
+
+    raise TypeError(
+        f"Field '{name}' with value {repr(value)} doesn't match any type in {args}. Errors: {'; '.join(errors)}"
+    )
+
+
+def _validate_literal(name: str, value: Any, args: Tuple[Any, ...]) -> None:
+    """Validate Literal type."""
+    if value not in args:
+        raise TypeError(f"Field '{name}' expected one of {args}, got {value}")
+
+
+def _validate_list(name: str, value: Any, args: Tuple[Any, ...]) -> None:
+    """Validate List[T] type."""
+    if not isinstance(value, list):
+        raise TypeError(f"Field '{name}' expected a list, got {type(value).__name__}")
+
+    # Validate each item in the list
+    item_type = args[0]
+    for i, item in enumerate(value):
+        try:
+            type_validator(f"{name}[{i}]", item, item_type)
+        except TypeError as e:
+            raise TypeError(f"Invalid item at index {i} in list '{name}'") from e
+
+
+def _validate_dict(name: str, value: Any, args: Tuple[Any, ...]) -> None:
+    """Validate Dict[K, V] type."""
+    if not isinstance(value, dict):
+        raise TypeError(f"Field '{name}' expected a dict, got {type(value).__name__}")
+
+    # Validate keys and values
+    key_type, value_type = args
+    for k, v in value.items():
+        try:
+            type_validator(f"{name}.key", k, key_type)
+            type_validator(f"{name}[{k!r}]", v, value_type)
+        except TypeError as e:
+            raise TypeError(f"Invalid key or value in dict '{name}'") from e
+
+
+def _validate_tuple(name: str, value: Any, args: Tuple[Any, ...]) -> None:
+    """Validate Tuple type."""
+    if not isinstance(value, tuple):
+        raise TypeError(f"Field '{name}' expected a tuple, got {type(value).__name__}")
+
+    # Handle variable-length tuples: Tuple[T, ...]
+    if len(args) == 2 and args[1] is Ellipsis:
+        for i, item in enumerate(value):
+            try:
+                type_validator(f"{name}[{i}]", item, args[0])
+            except TypeError as e:
+                raise TypeError(f"Invalid item at index {i} in tuple '{name}'") from e
+    # Handle fixed-length tuples: Tuple[T1, T2, ...]
+    elif len(args) != len(value):
+        raise TypeError(f"Field '{name}' expected a tuple of length {len(args)}, got {len(value)}")
+    else:
+        for i, (item, expected) in enumerate(zip(value, args)):
+            try:
+                type_validator(f"{name}[{i}]", item, expected)
+            except TypeError as e:
+                raise TypeError(f"Invalid item at index {i} in tuple '{name}'") from e
+
+
+def _validate_set(name: str, value: Any, args: Tuple[Any, ...]) -> None:
+    """Validate Set[T] type."""
+    if not isinstance(value, set):
+        raise TypeError(f"Field '{name}' expected a set, got {type(value).__name__}")
+
+    # Validate each item in the set
+    item_type = args[0]
+    for i, item in enumerate(value):
+        try:
+            type_validator(f"{name} item", item, item_type)
+        except TypeError as e:
+            raise TypeError(f"Invalid item in set '{name}'") from e
+
+
+def _validate_simple_type(name: str, value: Any, expected_type: type) -> None:
+    """Validate simple type (int, str, etc.)."""
+    if not isinstance(value, expected_type):
+        raise TypeError(
+            f"Field '{name}' expected {expected_type.__name__}, got {type(value).__name__} (value: {repr(value)})"
+        )
+
+
+def _create_type_validator(field: Field) -> Validator_T:
+    """Create a type validator function for a field."""
+    # Hacky: we cannot use a lambda here because of reference issues
+
+    def validator(value: Any) -> None:
+        type_validator(field.name, value, field.type)
+
+    return validator
+
+
+def _is_validator(validator: Any) -> bool:
+    """Check if a function is a validator.
+
+    A validator is a Callable that can be called with a single positional argument.
+    The validator can have more arguments with default values.
+
+    Basically, returns True if `validator(value)` is possible.
+    """
+    if not callable(validator):
+        return False
+
+    signature = inspect.signature(validator)
+    parameters = list(signature.parameters.values())
+    if len(parameters) == 0:
+        return False
+    if parameters[0].kind not in (
+        inspect.Parameter.POSITIONAL_OR_KEYWORD,
+        inspect.Parameter.POSITIONAL_ONLY,
+        inspect.Parameter.VAR_POSITIONAL,
+    ):
+        return False
+    for parameter in parameters[1:]:
+        if parameter.default == inspect.Parameter.empty:
+            return False
+    return True
+
+
+_BASIC_TYPE_VALIDATORS = {
+    Union: _validate_union,
+    Literal: _validate_literal,
+    list: _validate_list,
+    dict: _validate_dict,
+    tuple: _validate_tuple,
+    set: _validate_set,
+}
+
+
+__all__ = [
+    "strict",
+    "validated_field",
+    "Validator_T",
+    "StrictDataclassClassValidationError",
+    "StrictDataclassDefinitionError",
+    "StrictDataclassFieldValidationError",
+]

huggingface_hub/errors.py

@@ -329,6 +329,35 @@ class DDUFInvalidEntryNameError(DDUFExportError):
     """Exception thrown when the entry name is invalid."""
 
 
+# STRICT DATACLASSES ERRORS
+
+
+class StrictDataclassError(Exception):
+    """Base exception for strict dataclasses."""
+
+
+class StrictDataclassDefinitionError(StrictDataclassError):
+    """Exception thrown when a strict dataclass is defined incorrectly."""
+
+
+class StrictDataclassFieldValidationError(StrictDataclassError):
+    """Exception thrown when a strict dataclass fails validation for a given field."""
+
+    def __init__(self, field: str, cause: Exception):
+        error_message = f"Validation error for field '{field}':"
+        error_message += f"\n    {cause.__class__.__name__}: {cause}"
+        super().__init__(error_message)
+
+
+class StrictDataclassClassValidationError(StrictDataclassError):
+    """Exception thrown when a strict dataclass fails validation on a class validator."""
+
+    def __init__(self, validator: str, cause: Exception):
+        error_message = f"Class validation error for validator '{validator}':"
+        error_message += f"\n    {cause.__class__.__name__}: {cause}"
+        super().__init__(error_message)
+
+
 # XET ERRORS
 
 

huggingface_hub/hf_api.py

@@ -7698,7 +7698,15 @@ class HfApi:
         """
         namespace = namespace or self._get_namespace(token=token)
 
-        image = {"custom": custom_image} if custom_image is not None else {"huggingface": {}}
+        if custom_image is not None:
+            image = (
+                custom_image
+                if next(iter(custom_image)) in constants.INFERENCE_ENDPOINT_IMAGE_KEYS
+                else {"custom": custom_image}
+            )
+        else:
+            image = {"huggingface": {}}
+
         payload: Dict = {
             "accountId": account_id,
             "compute": {

huggingface_hub/hf_file_system.py

@@ -1009,7 +1009,9 @@ class HfFileSystemFile(fsspec.spec.AbstractBufferedFile):
         """
         if self.mode == "rb" and (length is None or length == -1) and self.loc == 0:
             with self.fs.open(self.path, "rb", block_size=0) as f:  # block_size=0 enables fast streaming
-                return f.read()
+                out = f.read()
+                self.loc += len(out)
+                return out
         return super().read(length)
 
     def url(self) -> str:
@@ -1057,7 +1059,7 @@ class HfFileSystemStreamFile(fsspec.spec.AbstractBufferedFile):
 
     def read(self, length: int = -1):
         read_args = (length,) if length >= 0 else ()
-        if self.response is None or self.response.raw.isclosed():
+        if self.response is None:
             url = hf_hub_url(
                 repo_id=self.resolved_path.repo_id,
                 revision=self.resolved_path.revision,

huggingface_hub/serialization/_torch.py

@@ -706,6 +706,15 @@ def _get_unique_id(tensor: "torch.Tensor") -> Union[int, Tuple[Any, ...]]:
     if the input is a wrapper tensor subclass Tensor
     """
 
+    try:
+        from torch.distributed.tensor import DTensor
+
+        if isinstance(tensor, DTensor):
+            local_tensor = tensor.to_local()
+            return local_tensor.storage().data_ptr()
+    except ImportError:
+        pass
+
     try:
         # for torch 2.1 and above we can also handle tensor subclasses
         from torch.utils._python_dispatch import is_traceable_wrapper_subclass
@@ -753,6 +762,15 @@ def get_torch_storage_size(tensor: "torch.Tensor") -> int:
     """
     Taken from https://github.com/huggingface/safetensors/blob/08db34094e9e59e2f9218f2df133b7b4aaff5a99/bindings/python/py_src/safetensors/torch.py#L31C1-L41C59
     """
+    try:
+        from torch.distributed.tensor import DTensor
+
+        if isinstance(tensor, DTensor):
+            # this returns the size of the FULL tensor in bytes
+            return tensor.nbytes
+    except ImportError:
+        pass
+
     try:
         # for torch 2.1 and above we can also handle tensor subclasses
         from torch.utils._python_dispatch import is_traceable_wrapper_subclass

huggingface_hub/utils/__init__.py

@@ -14,7 +14,6 @@
 # limitations under the License
 
 # ruff: noqa: F401
-
 from huggingface_hub.errors import (
     BadRequestError,
     CacheNotFound,

{huggingface_hub-0.31.2.dist-info → huggingface_hub-0.31.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: huggingface-hub
-Version: 0.31.2
+Version: 0.31.3
 Summary: Client library to download and publish models, datasets and other repos on the huggingface.co hub
 Home-page: https://github.com/huggingface/huggingface_hub
 Author: Hugging Face, Inc.

{huggingface_hub-0.31.2.dist-info → huggingface_hub-0.31.3.dist-info}/RECORD

@@ -1,4 +1,4 @@
-huggingface_hub/__init__.py,sha256=nacPPu11DpUQ6VaDbTCFwxEYj8my_ix_6-yhRdPpRgs,49368
+huggingface_hub/__init__.py,sha256=q8bSLV5UKfmlItPZqhAmzAZXHcSX1mXQEq2v8IdF1GY,49368
 huggingface_hub/_commit_api.py,sha256=ZbmuIhFdF8B3F_cvGtxorka7MmIQOk8oBkCtYltnCvI,39456
 huggingface_hub/_commit_scheduler.py,sha256=tfIoO1xWHjTJ6qy6VS6HIoymDycFPg0d6pBSZprrU2U,14679
 huggingface_hub/_inference_endpoints.py,sha256=qXR0utAYRaEWTI8EXzAsDpVDcYpp8bJPEBbcOxRS52E,17413
@@ -11,12 +11,13 @@ huggingface_hub/_upload_large_folder.py,sha256=mDKZv7MIieKlTCbTv0jccHIM4smCqK-Y0
 huggingface_hub/_webhooks_payload.py,sha256=Xm3KaK7tCOGBlXkuZvbym6zjHXrT1XCrbUFWuXiBmNY,3617
 huggingface_hub/_webhooks_server.py,sha256=5J63wk9MUGKBNJVsOD9i60mJ-VMp0YYmlf87vQsl-L8,15767
 huggingface_hub/community.py,sha256=4MtcoxEI9_0lmmilBEnvUEi8_O1Ivfa8p6eKxYU5-ts,12198
-huggingface_hub/constants.py,sha256=2EWCQ4UuVn-VlkEm0tpu2KX_YZea55KMeOfDmvzBgTM,9539
-huggingface_hub/errors.py,sha256=cE0bwLHbv8e34tbOdlkl-exjDoFxGgCLYmTYlDkpJgI,10155
+huggingface_hub/constants.py,sha256=ZYu0fEhPhrs12BVCZ_ygCdVvil6Sz4DLq9oMFsDkzNg,9766
+huggingface_hub/dataclasses.py,sha256=gegl8I9N8SbGoCUAVbQejQ6CNImwzYbbDwlua5m-PH8,17170
+huggingface_hub/errors.py,sha256=D7Lw0Jjrf8vfmD0B26LEvg-JWkU8Zq0KDPJOzFY4QLw,11201
 huggingface_hub/fastai_utils.py,sha256=DpeH9d-6ut2k_nCAAwglM51XmRmgfbRe2SPifpVL5Yk,16745
 huggingface_hub/file_download.py,sha256=Kh7Lg7C-Zn2U-zhF_mLw75ifiM28b9lSIODPvO4hGlA,78453
-huggingface_hub/hf_api.py,sha256=o-Y4Alxxy23SjJhX2xRYVvc2qw2DfX2mnyN8XxOuOSU,441239
-huggingface_hub/hf_file_system.py,sha256=m_g7uYLGxTdsBnhvR5835jvYMAuEBsUSFvEbzZKzzoo,47500
+huggingface_hub/hf_api.py,sha256=RB9LjZjncC9Ox1TZPuYUL_X8-YnDhzWdg3gP0oNenb4,441435
+huggingface_hub/hf_file_system.py,sha256=U6IY_QLNzZfvpsbvKEiakOBS2U6cduZw5t0x8wBPUn4,47531
 huggingface_hub/hub_mixin.py,sha256=fdAhdDujpUBZPUB6AfzzMRBeQ_Ua9tgQkhHE_ao5n2k,38062
 huggingface_hub/inference_api.py,sha256=b4-NhPSn9b44nYKV8tDKXodmE4JVdEymMWL4CVGkzlE,8323
 huggingface_hub/keras_mixin.py,sha256=3d2oW35SALXHq-WHoLD_tbq0UrcabGKj3HidtPRx51U,19574
@@ -96,10 +97,10 @@ huggingface_hub/serialization/__init__.py,sha256=kn-Fa-m4FzMnN8lNsF-SwFcfzug4Cuc
 huggingface_hub/serialization/_base.py,sha256=Df3GwGR9NzeK_SD75prXLucJAzPiNPgHbgXSw-_LTk8,8126
 huggingface_hub/serialization/_dduf.py,sha256=s42239rLiHwaJE36QDEmS5GH7DSmQ__BffiHJO5RjIg,15424
 huggingface_hub/serialization/_tensorflow.py,sha256=zHOvEMg-JHC55Fm4roDT3LUCDO5zB9qtXZffG065RAM,3625
-huggingface_hub/serialization/_torch.py,sha256=WoNV_17x99Agx68mNMbi2g8T5CAVIkSb3_OaZx9KrX4,44714
+huggingface_hub/serialization/_torch.py,sha256=hJglq5F56s3k06GfLuYKQV4bSSjXQLuk1CC9l1M3Fmo,45191
 huggingface_hub/templates/datasetcard_template.md,sha256=W-EMqR6wndbrnZorkVv56URWPG49l7MATGeI015kTvs,5503
 huggingface_hub/templates/modelcard_template.md,sha256=4AqArS3cqdtbit5Bo-DhjcnDFR-pza5hErLLTPM4Yuc,6870
-huggingface_hub/utils/__init__.py,sha256=OOcdMwFim7dEajPhetrtySbCAh-djIzQykQx4W2bAR0,3723
+huggingface_hub/utils/__init__.py,sha256=ORfVkn5D0wuLIq12jjhTzn5_c4F8fRPxB7TG-iednuQ,3722
 huggingface_hub/utils/_auth.py,sha256=-9p3SSOtWKMMCDKlsM_-ebsIGX0sSgKTSnC-_O4kTxg,8294
 huggingface_hub/utils/_cache_assets.py,sha256=kai77HPQMfYpROouMBQCr_gdBCaeTm996Sqj0dExbNg,5728
 huggingface_hub/utils/_cache_manager.py,sha256=GhiuVQsEkWU55uYkkgiGJV1_naeciyk8u4qb4WTIVyw,34531
@@ -127,9 +128,9 @@ huggingface_hub/utils/insecure_hashlib.py,sha256=OjxlvtSQHpbLp9PWSrXBDJ0wHjxCBU-
 huggingface_hub/utils/logging.py,sha256=0A8fF1yh3L9Ka_bCDX2ml4U5Ht0tY8Dr3JcbRvWFuwo,4909
 huggingface_hub/utils/sha.py,sha256=OFnNGCba0sNcT2gUwaVCJnldxlltrHHe0DS_PCpV3C4,2134
 huggingface_hub/utils/tqdm.py,sha256=xAKcyfnNHsZ7L09WuEM5Ew5-MDhiahLACbbN2zMmcLs,10671
-huggingface_hub-0.31.2.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-huggingface_hub-0.31.2.dist-info/METADATA,sha256=dOf3OVDqLIFPWIaiLY4GvvNDjGGkQMpyRHsMWtwEhrI,13558
-huggingface_hub-0.31.2.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
-huggingface_hub-0.31.2.dist-info/entry_points.txt,sha256=Y3Z2L02rBG7va_iE6RPXolIgwOdwUFONyRN3kXMxZ0g,131
-huggingface_hub-0.31.2.dist-info/top_level.txt,sha256=8KzlQJAY4miUvjAssOAJodqKOw3harNzuiwGQ9qLSSk,16
-huggingface_hub-0.31.2.dist-info/RECORD,,
+huggingface_hub-0.31.3.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+huggingface_hub-0.31.3.dist-info/METADATA,sha256=_lqS1pB3p0iLof7BjRmnaRyz08gijNYWywrl1lnZzc8,13558
+huggingface_hub-0.31.3.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
+huggingface_hub-0.31.3.dist-info/entry_points.txt,sha256=Y3Z2L02rBG7va_iE6RPXolIgwOdwUFONyRN3kXMxZ0g,131
+huggingface_hub-0.31.3.dist-info/top_level.txt,sha256=8KzlQJAY4miUvjAssOAJodqKOw3harNzuiwGQ9qLSSk,16
+huggingface_hub-0.31.3.dist-info/RECORD,,