huggingface-hub 0.33.5__py3-none-any.whl → 0.35.0rc0__py3-none-any.whl

huggingface_hub/inference/_providers/fal_ai.py

@@ -6,7 +6,7 @@ from urllib.parse import urlparse
 
 from huggingface_hub import constants
 from huggingface_hub.hf_api import InferenceProviderMapping
-from huggingface_hub.inference._common import RequestParameters, _as_dict
+from huggingface_hub.inference._common import RequestParameters, _as_dict, _as_url
 from huggingface_hub.inference._providers._common import TaskProviderHelper, filter_none
 from huggingface_hub.utils import get_session, hf_raise_for_status
 from huggingface_hub.utils.logging import get_logger
@@ -32,6 +32,60 @@ class FalAITask(TaskProviderHelper, ABC):
         return f"/{mapped_model}"
 
 
+class FalAIQueueTask(TaskProviderHelper, ABC):
+    def __init__(self, task: str):
+        super().__init__(provider="fal-ai", base_url="https://queue.fal.run", task=task)
+
+    def _prepare_headers(self, headers: Dict, api_key: str) -> Dict:
+        headers = super()._prepare_headers(headers, api_key)
+        if not api_key.startswith("hf_"):
+            headers["authorization"] = f"Key {api_key}"
+        return headers
+
+    def _prepare_route(self, mapped_model: str, api_key: str) -> str:
+        if api_key.startswith("hf_"):
+            # Use the queue subdomain for HF routing
+            return f"/{mapped_model}?_subdomain=queue"
+        return f"/{mapped_model}"
+
+    def get_response(
+        self,
+        response: Union[bytes, Dict],
+        request_params: Optional[RequestParameters] = None,
+    ) -> Any:
+        response_dict = _as_dict(response)
+
+        request_id = response_dict.get("request_id")
+        if not request_id:
+            raise ValueError("No request ID found in the response")
+        if request_params is None:
+            raise ValueError(
+                f"A `RequestParameters` object should be provided to get {self.task} responses with Fal AI."
+            )
+
+        # extract the base url and query params
+        parsed_url = urlparse(request_params.url)
+        # a bit hacky way to concatenate the provider name without parsing `parsed_url.path`
+        base_url = f"{parsed_url.scheme}://{parsed_url.netloc}{'/fal-ai' if parsed_url.netloc == 'router.huggingface.co' else ''}"
+        query_param = f"?{parsed_url.query}" if parsed_url.query else ""
+
+        # extracting the provider model id for status and result urls
+        # from the response as it might be different from the mapped model in `request_params.url`
+        model_id = urlparse(response_dict.get("response_url")).path
+        status_url = f"{base_url}{str(model_id)}/status{query_param}"
+        result_url = f"{base_url}{str(model_id)}{query_param}"
+
+        status = response_dict.get("status")
+        logger.info("Generating the output.. this can take several minutes.")
+        while status != "COMPLETED":
+            time.sleep(_POLLING_INTERVAL)
+            status_response = get_session().get(status_url, headers=request_params.headers)
+            hf_raise_for_status(status_response)
+            status = status_response.json().get("status")
+
+        return get_session().get(result_url, headers=request_params.headers).json()
+
+
 class FalAIAutomaticSpeechRecognitionTask(FalAITask):
     def __init__(self):
         super().__init__("automatic-speech-recognition")
@@ -110,23 +164,10 @@ class FalAITextToSpeechTask(FalAITask):
         return get_session().get(url).content
 
 
-class FalAITextToVideoTask(FalAITask):
+class FalAITextToVideoTask(FalAIQueueTask):
     def __init__(self):
         super().__init__("text-to-video")
 
-    def _prepare_base_url(self, api_key: str) -> str:
-        if api_key.startswith("hf_"):
-            return super()._prepare_base_url(api_key)
-        else:
-            logger.info(f"Calling '{self.provider}' provider directly.")
-            return "https://queue.fal.run"
-
-    def _prepare_route(self, mapped_model: str, api_key: str) -> str:
-        if api_key.startswith("hf_"):
-            # Use the queue subdomain for HF routing
-            return f"/{mapped_model}?_subdomain=queue"
-        return f"/{mapped_model}"
-
     def _prepare_payload_as_dict(
         self, inputs: Any, parameters: Dict, provider_mapping_info: InferenceProviderMapping
     ) -> Optional[Dict]:
@@ -137,36 +178,38 @@ class FalAITextToVideoTask(FalAITask):
         response: Union[bytes, Dict],
         request_params: Optional[RequestParameters] = None,
     ) -> Any:
-        response_dict = _as_dict(response)
+        output = super().get_response(response, request_params)
+        url = _as_dict(output)["video"]["url"]
+        return get_session().get(url).content
 
-        request_id = response_dict.get("request_id")
-        if not request_id:
-            raise ValueError("No request ID found in the response")
-        if request_params is None:
-            raise ValueError(
-                "A `RequestParameters` object should be provided to get text-to-video responses with Fal AI."
-            )
 
-        # extract the base url and query params
-        parsed_url = urlparse(request_params.url)
-        # a bit hacky way to concatenate the provider name without parsing `parsed_url.path`
-        base_url = f"{parsed_url.scheme}://{parsed_url.netloc}{'/fal-ai' if parsed_url.netloc == 'router.huggingface.co' else ''}"
-        query_param = f"?{parsed_url.query}" if parsed_url.query else ""
+class FalAIImageToImageTask(FalAIQueueTask):
+    def __init__(self):
+        super().__init__("image-to-image")
 
-        # extracting the provider model id for status and result urls
-        # from the response as it might be different from the mapped model in `request_params.url`
-        model_id = urlparse(response_dict.get("response_url")).path
-        status_url = f"{base_url}{str(model_id)}/status{query_param}"
-        result_url = f"{base_url}{str(model_id)}{query_param}"
+    def _prepare_payload_as_dict(
+        self, inputs: Any, parameters: Dict, provider_mapping_info: InferenceProviderMapping
+    ) -> Optional[Dict]:
+        image_url = _as_url(inputs, default_mime_type="image/jpeg")
+        payload: Dict[str, Any] = {
+            "image_url": image_url,
+            **filter_none(parameters),
+        }
+        if provider_mapping_info.adapter_weights_path is not None:
+            lora_path = constants.HUGGINGFACE_CO_URL_TEMPLATE.format(
+                repo_id=provider_mapping_info.hf_model_id,
+                revision="main",
+                filename=provider_mapping_info.adapter_weights_path,
+            )
+            payload["loras"] = [{"path": lora_path, "scale": 1}]
 
-        status = response_dict.get("status")
-        logger.info("Generating the video.. this can take several minutes.")
-        while status != "COMPLETED":
-            time.sleep(_POLLING_INTERVAL)
-            status_response = get_session().get(status_url, headers=request_params.headers)
-            hf_raise_for_status(status_response)
-            status = status_response.json().get("status")
+        return payload
 
-        response = get_session().get(result_url, headers=request_params.headers).json()
-        url = _as_dict(response)["video"]["url"]
+    def get_response(
+        self,
+        response: Union[bytes, Dict],
+        request_params: Optional[RequestParameters] = None,
+    ) -> Any:
+        output = super().get_response(response, request_params)
+        url = _as_dict(output)["images"][0]["url"]
         return get_session().get(url).content

huggingface_hub/inference/_providers/hf_inference.py

@@ -2,6 +2,7 @@ import json
 from functools import lru_cache
 from pathlib import Path
 from typing import Any, Dict, Optional, Union
+from urllib.parse import urlparse, urlunparse
 
 from huggingface_hub import constants
 from huggingface_hub.hf_api import InferenceProviderMapping
@@ -59,7 +60,7 @@ class HFInferenceTask(TaskProviderHelper):
             raise ValueError(f"Unexpected binary input for task {self.task}.")
         if isinstance(inputs, Path):
             raise ValueError(f"Unexpected path input for task {self.task} (got {inputs})")
-        return {"inputs": inputs, "parameters": filter_none(parameters)}
+        return filter_none({"inputs": inputs, "parameters": parameters})
 
 
 class HFInferenceBinaryInputTask(HFInferenceTask):
@@ -125,18 +126,25 @@ class HFInferenceConversational(HFInferenceTask):
 
 
 def _build_chat_completion_url(model_url: str) -> str:
-    # Strip trailing /
-    model_url = model_url.rstrip("/")
+    parsed = urlparse(model_url)
+    path = parsed.path.rstrip("/")
 
-    # Append /chat/completions if not already present
-    if model_url.endswith("/v1"):
-        model_url += "/chat/completions"
+    # If the path already ends with /chat/completions, we're done!
+    if path.endswith("/chat/completions"):
+        return model_url
 
+    # Append /chat/completions if not already present
+    if path.endswith("/v1"):
+        new_path = path + "/chat/completions"
+    # If path was empty or just "/", set the full path
+    elif not path:
+        new_path = "/v1/chat/completions"
     # Append /v1/chat/completions if not already present
-    if not model_url.endswith("/chat/completions"):
-        model_url += "/v1/chat/completions"
+    else:
+        new_path = path + "/v1/chat/completions"
 
-    return model_url
+    # Reconstruct the URL with the new path and original query parameters.
+    return urlunparse(parsed._replace(path=new_path))
 
 
 @lru_cache(maxsize=1)

huggingface_hub/inference/_providers/replicate.py

@@ -1,7 +1,7 @@
 from typing import Any, Dict, Optional, Union
 
 from huggingface_hub.hf_api import InferenceProviderMapping
-from huggingface_hub.inference._common import RequestParameters, _as_dict
+from huggingface_hub.inference._common import RequestParameters, _as_dict, _as_url
 from huggingface_hub.inference._providers._common import TaskProviderHelper, filter_none
 from huggingface_hub.utils import get_session
 
@@ -70,3 +70,21 @@ class ReplicateTextToSpeechTask(ReplicateTask):
         payload: Dict = super()._prepare_payload_as_dict(inputs, parameters, provider_mapping_info)  # type: ignore[assignment]
         payload["input"]["text"] = payload["input"].pop("prompt")  # rename "prompt" to "text" for TTS
         return payload
+
+
+class ReplicateImageToImageTask(ReplicateTask):
+    def __init__(self):
+        super().__init__("image-to-image")
+
+    def _prepare_payload_as_dict(
+        self, inputs: Any, parameters: Dict, provider_mapping_info: InferenceProviderMapping
+    ) -> Optional[Dict]:
+        image_url = _as_url(inputs, default_mime_type="image/jpeg")
+
+        payload: Dict[str, Any] = {"input": {"input_image": image_url, **filter_none(parameters)}}
+
+        mapped_model = provider_mapping_info.provider_id
+        if ":" in mapped_model:
+            version = mapped_model.split(":", 1)[1]
+            payload["version"] = version
+        return payload

huggingface_hub/keras_mixin.py

@@ -45,7 +45,7 @@ def _requires_keras_2_model(fn: CallableT) -> CallableT:
         if not hasattr(model, "history"):  # hacky way to check if model is Keras 2.x
             raise NotImplementedError(
                 f"Cannot use '{fn.__name__}': Keras 3.x is not supported."
-                " Please save models manually and upload them using `upload_folder` or `huggingface-cli upload`."
+                " Please save models manually and upload them using `upload_folder` or `hf upload`."
             )
         return fn(model, *args, **kwargs)
 
@@ -338,7 +338,7 @@ def push_to_hub_keras(
         token (`str`, *optional*):
             The token to use as HTTP bearer authorization for remote files. If
             not set, will use the token set when logging in with
-            `huggingface-cli login` (stored in `~/.huggingface`).
+            `hf auth login` (stored in `~/.huggingface`).
         branch (`str`, *optional*):
             The git branch on which to push the model. This defaults to
             the default branch as specified in your repository, which

huggingface_hub/repocard.py

@@ -276,7 +276,7 @@ class RepoCard:
 
         with SoftTemporaryDirectory() as tmpdir:
             tmp_path = Path(tmpdir) / constants.REPOCARD_NAME
-            tmp_path.write_text(str(self))
+            tmp_path.write_text(str(self), encoding="utf-8")
             url = upload_file(
                 path_or_fileobj=str(tmp_path),
                 path_in_repo=constants.REPOCARD_NAME,

huggingface_hub/repository.py

@@ -487,7 +487,7 @@ class Repository:
                 To set when cloning a repo from a repo_id. Default is model.
             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`
+                If `None` or `True` and machine is logged in (through `hf auth login`
                 or [`~huggingface_hub.login`]), token will be retrieved from the cache.
                 If `False`, token is not sent in the request header.
             git_user (`str`, *optional*):
@@ -878,7 +878,7 @@ class Repository:
         """
         try:
             lfs_config = "git config lfs.customtransfer.multipart"
-            run_subprocess(f"{lfs_config}.path huggingface-cli", self.local_dir)
+            run_subprocess(f"{lfs_config}.path hf", self.local_dir)
             run_subprocess(
                 f"{lfs_config}.args {LFS_MULTIPART_UPLOAD_COMMAND}",
                 self.local_dir,

huggingface_hub/utils/_auth.py

@@ -41,7 +41,7 @@ def get_token() -> Optional[str]:
 
     Token is retrieved in priority from the `HF_TOKEN` environment variable. Otherwise, we read the token file located
     in the Hugging Face home folder. Returns None if user is not logged in. To log in, use [`login`] or
-    `huggingface-cli login`.
+    `hf auth login`.
 
     Returns:
         `str` or `None`: The token, `None` if it doesn't exist.

huggingface_hub/utils/_cache_manager.py

@@ -632,9 +632,9 @@ def scan_cache_dir(cache_dir: Optional[Union[str, Path]] = None) -> HFCacheInfo:
     )
     ```
 
-    You can also print a detailed report directly from the `huggingface-cli` using:
+    You can also print a detailed report directly from the `hf` command line using:
     ```text
-    > huggingface-cli scan-cache
+    > hf cache scan
     REPO ID                     REPO TYPE SIZE ON DISK NB FILES REFS                LOCAL PATH
     --------------------------- --------- ------------ -------- ------------------- -------------------------------------------------------------------------
     glue                        dataset         116.3K       15 1.17.0, main, 2.4.0 /Users/lucain/.cache/huggingface/hub/datasets--glue

huggingface_hub/utils/_dotenv.py

@@ -0,0 +1,51 @@
+# AI-generated module (ChatGPT)
+import re
+from typing import Dict
+
+
+def load_dotenv(dotenv_str: str) -> Dict[str, str]:
+    """
+    Parse a DOTENV-format string and return a dictionary of key-value pairs.
+    Handles quoted values, comments, export keyword, and blank lines.
+    """
+    env: Dict[str, str] = {}
+    line_pattern = re.compile(
+        r"""
+        ^\s*
+        (?:export\s+)?                    # optional export
+        ([A-Za-z_][A-Za-z0-9_]*)          # key
+        \s*=\s*
+        (                                 # value group
+            (?:
+                '(?:\\'|[^'])*'           # single-quoted value
+                | "(?:\\"|[^"])*"         # double-quoted value
+                | [^#\n\r]+?              # unquoted value
+            )
+        )?
+        \s*(?:\#.*)?$                     # optional inline comment
+    """,
+        re.VERBOSE,
+    )
+
+    for line in dotenv_str.splitlines():
+        line = line.strip()
+        if not line or line.startswith("#"):
+            continue  # Skip comments and empty lines
+
+        match = line_pattern.match(line)
+        if not match:
+            continue  # Skip malformed lines
+
+        key, raw_val = match.group(1), match.group(2) or ""
+        val = raw_val.strip()
+
+        # Remove surrounding quotes if quoted
+        if (val.startswith('"') and val.endswith('"')) or (val.startswith("'") and val.endswith("'")):
+            val = val[1:-1]
+            val = val.replace(r"\n", "\n").replace(r"\t", "\t").replace(r"\"", '"').replace(r"\\", "\\")
+            if raw_val.startswith('"'):
+                val = val.replace(r"\$", "$")  # only in double quotes
+
+        env[key] = val
+
+    return env

huggingface_hub/utils/_headers.py

@@ -159,7 +159,7 @@ def get_token_to_send(token: Optional[Union[bool, str]]) -> Optional[str]:
             raise LocalTokenNotFoundError(
                 "Token is required (`token=True`), but no token found. You"
                 " need to provide a token or be logged in to Hugging Face with"
-                " `huggingface-cli login` or `huggingface_hub.login`. See"
+                " `hf auth login` or `huggingface_hub.login`. See"
                 " https://huggingface.co/settings/tokens."
             )
         return cached_token

huggingface_hub/utils/_runtime.py

@@ -155,7 +155,7 @@ def get_hf_transfer_version() -> str:
 # xet
 def is_xet_available() -> bool:
     # since hf_xet is automatically used if available, allow explicit disabling via environment variable
-    if constants._is_true(os.environ.get("HF_HUB_DISABLE_XET")):  # type: ignore
+    if constants.HF_HUB_DISABLE_XET:
         return False
 
     return is_package_available("hf_xet")

huggingface_hub/utils/_xet.py

@@ -26,7 +26,9 @@ class XetConnectionInfo:
     endpoint: str
 
 
-def parse_xet_file_data_from_response(response: requests.Response) -> Optional[XetFileData]:
+def parse_xet_file_data_from_response(
+    response: requests.Response, endpoint: Optional[str] = None
+) -> Optional[XetFileData]:
     """
     Parse XET file metadata from an HTTP response.
 
@@ -52,7 +54,9 @@ def parse_xet_file_data_from_response(response: requests.Response) -> Optional[X
             refresh_route = response.headers[constants.HUGGINGFACE_HEADER_X_XET_REFRESH_ROUTE]
     except KeyError:
         return None
-
+    endpoint = endpoint if endpoint is not None else constants.ENDPOINT
+    if refresh_route.startswith(constants.HUGGINGFACE_CO_URL_HOME):
+        refresh_route = refresh_route.replace(constants.HUGGINGFACE_CO_URL_HOME.rstrip("/"), endpoint.rstrip("/"))
     return XetFileData(
         file_hash=file_hash,
         refresh_route=refresh_route,

huggingface_hub/utils/_xet_progress_reporting.py

@@ -0,0 +1,141 @@
+from collections import OrderedDict
+from typing import List
+
+from hf_xet import PyItemProgressUpdate, PyTotalProgressUpdate
+
+from .tqdm import tqdm
+
+
+class XetProgressReporter:
+    def __init__(self, n_lines: int = 10, description_width: int = 40):
+        self.n_lines = n_lines
+        self.description_width = description_width
+
+        self.tqdm_settings = {
+            "unit": "B",
+            "unit_scale": True,
+            "leave": True,
+            "unit_divisor": 1000,
+            "nrows": n_lines + 3,
+            "miniters": 1,
+            "bar_format": "{l_bar}{bar}| {n_fmt:>5}B / {total_fmt:>5}B{postfix:>12}",
+        }
+
+        # Overall progress bars
+        self.data_processing_bar = tqdm(
+            total=0, desc=self.format_desc("Processing Files (0 / 0)", False), position=0, **self.tqdm_settings
+        )
+
+        self.upload_bar = tqdm(
+            total=0, desc=self.format_desc("New Data Upload", False), position=1, **self.tqdm_settings
+        )
+
+        self.known_items: set[str] = set()
+        self.completed_items: set[str] = set()
+
+        # Item bars (scrolling view)
+        self.item_state: OrderedDict[str, PyItemProgressUpdate] = OrderedDict()
+        self.current_bars: List = [None] * self.n_lines
+
+    def format_desc(self, name: str, indent: bool) -> str:
+        """
+        if name is longer than width characters, prints ... at the start and then the last width-3 characters of the name, otherwise
+        the whole name right justified into 20 characters.  Also adds some padding.
+        """
+        padding = "  " if indent else ""
+        width = self.description_width - len(padding)
+
+        if len(name) > width:
+            name = f"...{name[-(width - 3) :]}"
+
+        return f"{padding}{name.ljust(width)}"
+
+    def update_progress(self, total_update: PyTotalProgressUpdate, item_updates: List[PyItemProgressUpdate]):
+        # Update all the per-item values.
+        for item in item_updates:
+            item_name = item.item_name
+
+            self.known_items.add(item_name)
+
+            # Only care about items where the processing has already started.
+            if item.bytes_completed == 0:
+                continue
+
+            # Overwrite the existing value in there.
+            self.item_state[item_name] = item
+
+        bar_idx = 0
+        new_completed = []
+
+        # Now, go through and update all the bars
+        for name, item in self.item_state.items():
+            # Is this ready to be removed on the next update?
+            if item.bytes_completed == item.total_bytes:
+                self.completed_items.add(name)
+                new_completed.append(name)
+
+            # If we've run out of bars to use, then collapse the last ones together.
+            if bar_idx >= len(self.current_bars):
+                bar = self.current_bars[-1]
+                in_final_bar_mode = True
+                final_bar_aggregation_count = bar_idx + 1 - len(self.current_bars)
+            else:
+                bar = self.current_bars[bar_idx]
+                in_final_bar_mode = False
+
+            if bar is None:
+                self.current_bars[bar_idx] = tqdm(
+                    desc=self.format_desc(name, True),
+                    position=2 + bar_idx,  # Set to the position past the initial bars.
+                    total=item.total_bytes,
+                    initial=item.bytes_completed,
+                    **self.tqdm_settings,
+                )
+
+            elif in_final_bar_mode:
+                bar.n += item.bytes_completed
+                bar.total += item.total_bytes
+                bar.set_description(self.format_desc(f"[+ {final_bar_aggregation_count} files]", True), refresh=False)
+            else:
+                bar.set_description(self.format_desc(name, True), refresh=False)
+                bar.n = item.bytes_completed
+                bar.total = item.total_bytes
+
+            bar_idx += 1
+
+        # Remove all the completed ones from the ordered dictionary
+        for name in new_completed:
+            # Only remove ones from consideration to make room for more items coming in.
+            if len(self.item_state) <= self.n_lines:
+                break
+
+            del self.item_state[name]
+
+        # Now manually refresh each of the bars
+        for bar in self.current_bars:
+            if bar:
+                bar.refresh()
+
+        # Update overall bars
+        def postfix(speed):
+            s = tqdm.format_sizeof(speed) if speed is not None else "???"
+            return f"{s}B/s  ".rjust(10, " ")
+
+        self.data_processing_bar.total = total_update.total_bytes
+        self.data_processing_bar.set_description(
+            self.format_desc(f"Processing Files ({len(self.completed_items)} / {len(self.known_items)})", False),
+            refresh=False,
+        )
+        self.data_processing_bar.set_postfix_str(postfix(total_update.total_bytes_completion_rate), refresh=False)
+        self.data_processing_bar.update(total_update.total_bytes_completion_increment)
+
+        self.upload_bar.total = total_update.total_transfer_bytes
+        self.upload_bar.set_postfix_str(postfix(total_update.total_transfer_bytes_completion_rate), refresh=False)
+        self.upload_bar.update(total_update.total_transfer_bytes_completion_increment)
+
+    def close(self, _success):
+        self.data_processing_bar.close()
+        self.upload_bar.close()
+        for bar in self.current_bars:
+            if bar:
+                bar.close()

{huggingface_hub-0.33.5.dist-info → huggingface_hub-0.35.0rc0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: huggingface-hub
-Version: 0.33.5
+Version: 0.35.0rc0
 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.
@@ -32,7 +32,7 @@ Requires-Dist: pyyaml>=5.1
 Requires-Dist: requests
 Requires-Dist: tqdm>=4.42.1
 Requires-Dist: typing-extensions>=3.7.4.3
-Requires-Dist: hf-xet<2.0.0,>=1.1.2; platform_machine == "x86_64" or platform_machine == "amd64" or platform_machine == "arm64" or platform_machine == "aarch64"
+Requires-Dist: hf-xet<2.0.0,>=1.1.3; platform_machine == "x86_64" or platform_machine == "amd64" or platform_machine == "arm64" or platform_machine == "aarch64"
 Provides-Extra: all
 Requires-Dist: InquirerPy==0.3.4; extra == "all"
 Requires-Dist: aiohttp; extra == "all"
@@ -56,7 +56,7 @@ Requires-Dist: Pillow; extra == "all"
 Requires-Dist: gradio>=4.0.0; extra == "all"
 Requires-Dist: numpy; extra == "all"
 Requires-Dist: ruff>=0.9.0; extra == "all"
-Requires-Dist: libcst==1.4.0; extra == "all"
+Requires-Dist: libcst>=1.4.0; extra == "all"
 Requires-Dist: typing-extensions>=4.8.0; extra == "all"
 Requires-Dist: types-PyYAML; extra == "all"
 Requires-Dist: types-requests; extra == "all"
@@ -91,7 +91,7 @@ Requires-Dist: Pillow; extra == "dev"
 Requires-Dist: gradio>=4.0.0; extra == "dev"
 Requires-Dist: numpy; extra == "dev"
 Requires-Dist: ruff>=0.9.0; extra == "dev"
-Requires-Dist: libcst==1.4.0; extra == "dev"
+Requires-Dist: libcst>=1.4.0; extra == "dev"
 Requires-Dist: typing-extensions>=4.8.0; extra == "dev"
 Requires-Dist: types-PyYAML; extra == "dev"
 Requires-Dist: types-requests; extra == "dev"
@@ -122,7 +122,7 @@ Requires-Dist: httpx; extra == "oauth"
 Requires-Dist: itsdangerous; extra == "oauth"
 Provides-Extra: quality
 Requires-Dist: ruff>=0.9.0; extra == "quality"
-Requires-Dist: libcst==1.4.0; extra == "quality"
+Requires-Dist: libcst>=1.4.0; extra == "quality"
 Requires-Dist: mypy<1.15.0,>=1.14.1; python_version == "3.8" and extra == "quality"
 Requires-Dist: mypy==1.15.0; python_version >= "3.9" and extra == "quality"
 Provides-Extra: tensorflow
@@ -265,9 +265,9 @@ Files will be downloaded in a local cache folder. More details in [this guide](h
 The Hugging Face Hub uses tokens to authenticate applications (see [docs](https://huggingface.co/docs/hub/security-tokens)). To log in your machine, run the following CLI:
 
 ```bash
-huggingface-cli login
+hf auth login
 # or using an environment variable
-huggingface-cli login --token $HUGGINGFACE_TOKEN
+hf auth login --token $HUGGINGFACE_TOKEN
 ```
 
 ### Create a repository
@@ -314,7 +314,6 @@ The advantages are:
 
 - Free model or dataset hosting for libraries and their users.
 - Built-in file versioning, even with very large files, thanks to a git-based approach.
-- Serverless inference API for all models publicly available.
 - In-browser widgets to play with the uploaded models.
 - Anyone can upload a new model for your library, they just need to add the corresponding tag for the model to be discoverable.
 - Fast downloads! We use Cloudfront (a CDN) to geo-replicate downloads so they're blazing fast from anywhere on the globe.