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

huggingface_hub/hf_file_system.py

@@ -15,23 +15,13 @@ from fsspec.callbacks import _DEFAULT_CALLBACK, NoOpCallback, TqdmCallback
 from fsspec.utils import isfilelike
 from requests import Response
 
+from . import constants
 from ._commit_api import CommitOperationCopy, CommitOperationDelete
-from .constants import (
-    DEFAULT_REVISION,
-    ENDPOINT,
-    HF_HUB_DOWNLOAD_TIMEOUT,
-    HF_HUB_ETAG_TIMEOUT,
-    REPO_TYPE_MODEL,
-    REPO_TYPES_MAPPING,
-    REPO_TYPES_URL_PREFIXES,
-)
+from .errors import EntryNotFoundError, RepositoryNotFoundError, RevisionNotFoundError
 from .file_download import hf_hub_url, http_get
 from .hf_api import HfApi, LastCommitInfo, RepoFile
 from .utils import (
-    EntryNotFoundError,
     HFValidationError,
-    RepositoryNotFoundError,
-    RevisionNotFoundError,
     hf_raise_for_status,
     http_backoff,
 )
@@ -61,10 +51,10 @@ class HfFileSystemResolvedPath:
     _raw_revision: Optional[str] = field(default=None, repr=False)
 
     def unresolve(self) -> str:
-        repo_path = REPO_TYPES_URL_PREFIXES.get(self.repo_type, "") + self.repo_id
+        repo_path = constants.REPO_TYPES_URL_PREFIXES.get(self.repo_type, "") + self.repo_id
         if self._raw_revision:
             return f"{repo_path}@{self._raw_revision}/{self.path_in_repo}".rstrip("/")
-        elif self.revision != DEFAULT_REVISION:
+        elif self.revision != constants.DEFAULT_REVISION:
             return f"{repo_path}@{safe_revision(self.revision)}/{self.path_in_repo}".rstrip("/")
         else:
             return f"{repo_path}/{self.path_in_repo}".rstrip("/")
@@ -113,7 +103,7 @@ class HfFileSystem(fsspec.AbstractFileSystem):
         **storage_options,
     ):
         super().__init__(*args, **storage_options)
-        self.endpoint = endpoint or ENDPOINT
+        self.endpoint = endpoint or constants.ENDPOINT
         self.token = token
         self._api = HfApi(endpoint=endpoint, token=token)
         # Maps (repo_type, repo_id, revision) to a 2-tuple with:
@@ -128,7 +118,9 @@ class HfFileSystem(fsspec.AbstractFileSystem):
     ) -> Tuple[bool, Optional[Exception]]:
         if (repo_type, repo_id, revision) not in self._repo_and_revision_exists_cache:
             try:
-                self._api.repo_info(repo_id, revision=revision, repo_type=repo_type, timeout=HF_HUB_ETAG_TIMEOUT)
+                self._api.repo_info(
+                    repo_id, revision=revision, repo_type=repo_type, timeout=constants.HF_HUB_ETAG_TIMEOUT
+                )
             except (RepositoryNotFoundError, HFValidationError) as e:
                 self._repo_and_revision_exists_cache[(repo_type, repo_id, revision)] = False, e
                 self._repo_and_revision_exists_cache[(repo_type, repo_id, None)] = False, e
@@ -158,14 +150,14 @@ class HfFileSystem(fsspec.AbstractFileSystem):
         if not path:
             # can't list repositories at root
             raise NotImplementedError("Access to repositories lists is not implemented.")
-        elif path.split("/")[0] + "/" in REPO_TYPES_URL_PREFIXES.values():
+        elif path.split("/")[0] + "/" in constants.REPO_TYPES_URL_PREFIXES.values():
             if "/" not in path:
                 # can't list repositories at the repository type level
                 raise NotImplementedError("Access to repositories lists is not implemented.")
             repo_type, path = path.split("/", 1)
-            repo_type = REPO_TYPES_MAPPING[repo_type]
+            repo_type = constants.REPO_TYPES_MAPPING[repo_type]
         else:
-            repo_type = REPO_TYPE_MODEL
+            repo_type = constants.REPO_TYPE_MODEL
         if path.count("/") > 0:
             if "@" in path:
                 repo_id, revision_in_path = path.split("@", 1)
@@ -213,7 +205,7 @@ class HfFileSystem(fsspec.AbstractFileSystem):
             if not repo_and_revision_exist:
                 raise NotImplementedError("Access to repositories lists is not implemented.")
 
-        revision = revision if revision is not None else DEFAULT_REVISION
+        revision = revision if revision is not None else constants.DEFAULT_REVISION
         return HfFileSystemResolvedPath(repo_type, repo_id, revision, path_in_repo, _raw_revision=revision_in_path)
 
     def invalidate_cache(self, path: Optional[str] = None) -> None:
@@ -723,7 +715,7 @@ class HfFileSystemFile(fsspec.spec.AbstractBufferedFile):
             url,
             headers=headers,
             retry_on_status_codes=(502, 503, 504),
-            timeout=HF_HUB_DOWNLOAD_TIMEOUT,
+            timeout=constants.HF_HUB_DOWNLOAD_TIMEOUT,
         )
         hf_raise_for_status(r)
         return r.content
@@ -823,7 +815,7 @@ class HfFileSystemStreamFile(fsspec.spec.AbstractBufferedFile):
                 headers=self.fs._api._build_hf_headers(),
                 retry_on_status_codes=(502, 503, 504),
                 stream=True,
-                timeout=HF_HUB_DOWNLOAD_TIMEOUT,
+                timeout=constants.HF_HUB_DOWNLOAD_TIMEOUT,
             )
             hf_raise_for_status(self.response)
         try:
@@ -845,7 +837,7 @@ class HfFileSystemStreamFile(fsspec.spec.AbstractBufferedFile):
                 headers={"Range": "bytes=%d-" % self.loc, **self.fs._api._build_hf_headers()},
                 retry_on_status_codes=(502, 503, 504),
                 stream=True,
-                timeout=HF_HUB_DOWNLOAD_TIMEOUT,
+                timeout=constants.HF_HUB_DOWNLOAD_TIMEOUT,
             )
             hf_raise_for_status(self.response)
             try:

huggingface_hub/hub_mixin.py

@@ -17,13 +17,12 @@ from typing import (
     Union,
 )
 
-from .constants import CONFIG_NAME, PYTORCH_WEIGHTS_NAME, SAFETENSORS_SINGLE_FILE
+from . import constants
+from .errors import EntryNotFoundError, HfHubHTTPError
 from .file_download import hf_hub_download
 from .hf_api import HfApi
 from .repocard import ModelCard, ModelCardData
 from .utils import (
-    EntryNotFoundError,
-    HfHubHTTPError,
     SoftTemporaryDirectory,
     is_jsonable,
     is_safetensors_available,
@@ -42,6 +41,8 @@ if is_torch_available():
     import torch  # type: ignore
 
 if is_safetensors_available():
+    import packaging.version
+    import safetensors
     from safetensors.torch import load_model as load_model_as_safetensor
     from safetensors.torch import save_model as save_model_as_safetensor
 
@@ -417,7 +418,7 @@ class ModelHubMixin:
         # Remove config.json if already exists. After `_save_pretrained` we don't want to overwrite config.json
         # as it might have been saved by the custom `_save_pretrained` already. However we do want to overwrite
         # an existing config.json if it was not saved by `_save_pretrained`.
-        config_path = save_directory / CONFIG_NAME
+        config_path = save_directory / constants.CONFIG_NAME
         config_path.unlink(missing_ok=True)
 
         # save model weights/files (framework-specific)
@@ -505,15 +506,15 @@ class ModelHubMixin:
         model_id = str(pretrained_model_name_or_path)
         config_file: Optional[str] = None
         if os.path.isdir(model_id):
-            if CONFIG_NAME in os.listdir(model_id):
-                config_file = os.path.join(model_id, CONFIG_NAME)
+            if constants.CONFIG_NAME in os.listdir(model_id):
+                config_file = os.path.join(model_id, constants.CONFIG_NAME)
             else:
-                logger.warning(f"{CONFIG_NAME} not found in {Path(model_id).resolve()}")
+                logger.warning(f"{constants.CONFIG_NAME} not found in {Path(model_id).resolve()}")
         else:
             try:
                 config_file = hf_hub_download(
                     repo_id=model_id,
-                    filename=CONFIG_NAME,
+                    filename=constants.CONFIG_NAME,
                     revision=revision,
                     cache_dir=cache_dir,
                     force_download=force_download,
@@ -523,7 +524,7 @@ class ModelHubMixin:
                     local_files_only=local_files_only,
                 )
             except HfHubHTTPError as e:
-                logger.info(f"{CONFIG_NAME} not found on the HuggingFace Hub: {str(e)}")
+                logger.info(f"{constants.CONFIG_NAME} not found on the HuggingFace Hub: {str(e)}")
 
         # Read config
         config = None
@@ -767,7 +768,7 @@ class PyTorchModelHubMixin(ModelHubMixin):
     def _save_pretrained(self, save_directory: Path) -> None:
         """Save weights from a Pytorch model to a local directory."""
         model_to_save = self.module if hasattr(self, "module") else self  # type: ignore
-        save_model_as_safetensor(model_to_save, str(save_directory / SAFETENSORS_SINGLE_FILE))
+        save_model_as_safetensor(model_to_save, str(save_directory / constants.SAFETENSORS_SINGLE_FILE))
 
     @classmethod
     def _from_pretrained(
@@ -789,13 +790,13 @@ class PyTorchModelHubMixin(ModelHubMixin):
         model = cls(**model_kwargs)
         if os.path.isdir(model_id):
             print("Loading weights from local directory")
-            model_file = os.path.join(model_id, SAFETENSORS_SINGLE_FILE)
+            model_file = os.path.join(model_id, constants.SAFETENSORS_SINGLE_FILE)
             return cls._load_as_safetensor(model, model_file, map_location, strict)
         else:
             try:
                 model_file = hf_hub_download(
                     repo_id=model_id,
-                    filename=SAFETENSORS_SINGLE_FILE,
+                    filename=constants.SAFETENSORS_SINGLE_FILE,
                     revision=revision,
                     cache_dir=cache_dir,
                     force_download=force_download,
@@ -808,7 +809,7 @@ class PyTorchModelHubMixin(ModelHubMixin):
             except EntryNotFoundError:
                 model_file = hf_hub_download(
                     repo_id=model_id,
-                    filename=PYTORCH_WEIGHTS_NAME,
+                    filename=constants.PYTORCH_WEIGHTS_NAME,
                     revision=revision,
                     cache_dir=cache_dir,
                     force_download=force_download,
@@ -821,24 +822,25 @@ class PyTorchModelHubMixin(ModelHubMixin):
 
     @classmethod
     def _load_as_pickle(cls, model: T, model_file: str, map_location: str, strict: bool) -> T:
-        state_dict = torch.load(model_file, map_location=torch.device(map_location))
+        state_dict = torch.load(model_file, map_location=torch.device(map_location), weights_only=True)
         model.load_state_dict(state_dict, strict=strict)  # type: ignore
         model.eval()  # type: ignore
         return model
 
     @classmethod
     def _load_as_safetensor(cls, model: T, model_file: str, map_location: str, strict: bool) -> T:
-        load_model_as_safetensor(model, model_file, strict=strict)  # type: ignore [arg-type]
-        if map_location != "cpu":
-            # TODO: remove this once https://github.com/huggingface/safetensors/pull/449 is merged.
-            logger.warning(
-                "Loading model weights on other devices than 'cpu' is not supported natively."
-                " This means that the model is loaded on 'cpu' first and then copied to the device."
-                " This leads to a slower loading time."
-                " Support for loading directly on other devices is planned to be added in future releases."
-                " See https://github.com/huggingface/huggingface_hub/pull/2086 for more details."
-            )
-            model.to(map_location)  # type: ignore [attr-defined]
+        if packaging.version.parse(safetensors.__version__) < packaging.version.parse("0.4.3"):  # type: ignore [attr-defined]
+            load_model_as_safetensor(model, model_file, strict=strict)  # type: ignore [arg-type]
+            if map_location != "cpu":
+                logger.warning(
+                    "Loading model weights on other devices than 'cpu' is not supported natively in your version of safetensors."
+                    " This means that the model is loaded on 'cpu' first and then copied to the device."
+                    " This leads to a slower loading time."
+                    " Please update safetensors to version 0.4.3 or above for improved performance."
+                )
+                model.to(map_location)  # type: ignore [attr-defined]
+        else:
+            safetensors.torch.load_model(model, model_file, strict=strict, device=map_location)  # type: ignore [arg-type]
         return model
 
 

huggingface_hub/inference/_client.py

@@ -53,7 +53,7 @@ from requests import HTTPError
 from requests.structures import CaseInsensitiveDict
 
 from huggingface_hub.constants import ALL_INFERENCE_API_FRAMEWORKS, INFERENCE_ENDPOINT, MAIN_INFERENCE_API_FRAMEWORKS
-from huggingface_hub.errors import InferenceTimeoutError
+from huggingface_hub.errors import BadRequestError, InferenceTimeoutError
 from huggingface_hub.inference._common import (
     TASKS_EXPECTING_IMAGES,
     ContentT,
@@ -100,11 +100,7 @@ from huggingface_hub.inference._generated.types import (
     ZeroShotClassificationOutputElement,
     ZeroShotImageClassificationOutputElement,
 )
-from huggingface_hub.inference._types import (
-    ConversationalOutput,  # soon to be removed
-)
 from huggingface_hub.utils import (
-    BadRequestError,
     build_hf_headers,
     get_session,
     hf_raise_for_status,
@@ -135,7 +131,9 @@ class InferenceClient:
             or a URL to a deployed Inference Endpoint. Defaults to None, in which case a recommended model is
             automatically selected for the task.
             Note: for better compatibility with OpenAI's client, `model` has been aliased as `base_url`. Those 2
-            arguments are mutually exclusive and have the exact same behavior.
+            arguments are mutually exclusive. If using `base_url` for chat completion, the `/chat/completions` suffix
+            path will be appended to the base URL (see the [TGI Messages API](https://huggingface.co/docs/text-generation-inference/en/messages_api)
+            documentation for details). When passing a URL as `model`, the client will not append any suffix path to it.
         token (`str` or `bool`, *optional*):
             Hugging Face token. Will default to the locally saved token if not provided.
             Pass `token=False` if you don't want to send your token to the server.
@@ -149,6 +147,8 @@ class InferenceClient:
             Values in this dictionary will override the default values.
         cookies (`Dict[str, str]`, `optional`):
             Additional cookies to send to the server.
+        proxies (`Any`, `optional`):
+            Proxies to use for the request.
         base_url (`str`, `optional`):
             Base URL to run inference. This is a duplicated argument from `model` to make [`InferenceClient`]
             follow the same pattern as `openai.OpenAI` client. Cannot be used if `model` is set. Defaults to None.
@@ -175,7 +175,8 @@ class InferenceClient:
             raise ValueError(
                 "Received both `model` and `base_url` arguments. Please provide only one of them."
                 " `base_url` is an alias for `model` to make the API compatible with OpenAI's client."
-                " It has the exact same behavior as `model`."
+                " If using `base_url` for chat completion, the `/chat/completions` suffix path will be appended to the base url."
+                " When passing a URL as `model`, the client will not append any suffix path to it."
             )
         if token is not None and api_key is not None:
             raise ValueError(
@@ -809,133 +810,66 @@ class InferenceClient:
         '{\n\n"activity": "bike ride",\n"animals": ["puppy", "cat", "raccoon"],\n"animals_seen": 3,\n"location": "park"}'
         ```
         """
-        # Determine model
-        # `self.xxx` takes precedence over the method argument only in `chat_completion`
-        # since `chat_completion(..., model=xxx)` is also a payload parameter for the
-        # server, we need to handle it differently
-        model = self.base_url or self.model or model or self.get_recommended_model("text-generation")
-        is_url = model.startswith(("http://", "https://"))
-
-        # First, resolve the model chat completions URL
-        if model == self.base_url:
-            # base_url passed => add server route
-            model_url = model.rstrip("/")
-            if not model_url.endswith("/v1"):
-                model_url += "/v1"
-            model_url += "/chat/completions"
-        elif is_url:
-            # model is a URL => use it directly
-            model_url = model
-        else:
-            # model is a model ID => resolve it + add server route
-            model_url = self._resolve_url(model).rstrip("/") + "/v1/chat/completions"
+        model_url = self._resolve_chat_completion_url(model)
 
         # `model` is sent in the payload. Not used by the server but can be useful for debugging/routing.
         # If it's a ID on the Hub => use it. Otherwise, we use a random string.
-        model_id = model if not is_url and model.count("/") == 1 else "tgi"
-
-        data = self.post(
-            model=model_url,
-            json=dict(
-                model=model_id,
-                messages=messages,
-                frequency_penalty=frequency_penalty,
-                logit_bias=logit_bias,
-                logprobs=logprobs,
-                max_tokens=max_tokens,
-                n=n,
-                presence_penalty=presence_penalty,
-                response_format=response_format,
-                seed=seed,
-                stop=stop,
-                temperature=temperature,
-                tool_choice=tool_choice,
-                tool_prompt=tool_prompt,
-                tools=tools,
-                top_logprobs=top_logprobs,
-                top_p=top_p,
-                stream=stream,
-            ),
+        model_id = model or self.model or "tgi"
+        if model_id.startswith(("http://", "https://")):
+            model_id = "tgi"  # dummy value
+
+        payload = dict(
+            model=model_id,
+            messages=messages,
+            frequency_penalty=frequency_penalty,
+            logit_bias=logit_bias,
+            logprobs=logprobs,
+            max_tokens=max_tokens,
+            n=n,
+            presence_penalty=presence_penalty,
+            response_format=response_format,
+            seed=seed,
+            stop=stop,
+            temperature=temperature,
+            tool_choice=tool_choice,
+            tool_prompt=tool_prompt,
+            tools=tools,
+            top_logprobs=top_logprobs,
+            top_p=top_p,
             stream=stream,
         )
+        payload = {key: value for key, value in payload.items() if value is not None}
+        data = self.post(model=model_url, json=payload, stream=stream)
 
         if stream:
             return _stream_chat_completion_response(data)  # type: ignore[arg-type]
 
         return ChatCompletionOutput.parse_obj_as_instance(data)  # type: ignore[arg-type]
 
-    def conversational(
-        self,
-        text: str,
-        generated_responses: Optional[List[str]] = None,
-        past_user_inputs: Optional[List[str]] = None,
-        *,
-        parameters: Optional[Dict[str, Any]] = None,
-        model: Optional[str] = None,
-    ) -> ConversationalOutput:
-        """
-        Generate conversational responses based on the given input text (i.e. chat with the API).
+    def _resolve_chat_completion_url(self, model: Optional[str] = None) -> str:
+        # Since `chat_completion(..., model=xxx)` is also a payload parameter for the server, we need to handle 'model' differently.
+        # `self.base_url` and `self.model` takes precedence over 'model' argument only in `chat_completion`.
+        model_id_or_url = self.base_url or self.model or model or self.get_recommended_model("text-generation")
 
-        <Tip warning={true}>
+        # Resolve URL if it's a model ID
+        model_url = (
+            model_id_or_url
+            if model_id_or_url.startswith(("http://", "https://"))
+            else self._resolve_url(model_id_or_url, task="text-generation")
+        )
 
-        [`InferenceClient.conversational`] API is deprecated and will be removed in a future release. Please use
-        [`InferenceClient.chat_completion`] instead.
+        # Strip trailing /
+        model_url = model_url.rstrip("/")
 
-        </Tip>
+        # Append /chat/completions if not already present
+        if model_url.endswith("/v1"):
+            model_url += "/chat/completions"
 
-        Args:
-            text (`str`):
-                The last input from the user in the conversation.
-            generated_responses (`List[str]`, *optional*):
-                A list of strings corresponding to the earlier replies from the model. Defaults to None.
-            past_user_inputs (`List[str]`, *optional*):
-                A list of strings corresponding to the earlier replies from the user. Should be the same length as
-                `generated_responses`. Defaults to None.
-            parameters (`Dict[str, Any]`, *optional*):
-                Additional parameters for the conversational task. Defaults to None. For more details about the available
-                parameters, please refer to [this page](https://huggingface.co/docs/api-inference/detailed_parameters#conversational-task)
-            model (`str`, *optional*):
-                The model to use for the conversational task. Can be a model ID hosted on the Hugging Face Hub or a URL to
-                a deployed Inference Endpoint. If not provided, the default recommended conversational model will be used.
-                Defaults to None.
+        # Append /v1/chat/completions if not already present
+        if not model_url.endswith("/chat/completions"):
+            model_url += "/v1/chat/completions"
 
-        Returns:
-            `Dict`: The generated conversational output.
-
-        Raises:
-            [`InferenceTimeoutError`]:
-                If the model is unavailable or the request times out.
-            `HTTPError`:
-                If the request fails with an HTTP error status code other than HTTP 503.
-
-        Example:
-        ```py
-        >>> from huggingface_hub import InferenceClient
-        >>> client = InferenceClient()
-        >>> output = client.conversational("Hi, who are you?")
-        >>> output
-        {'generated_text': 'I am the one who knocks.', 'conversation': {'generated_responses': ['I am the one who knocks.'], 'past_user_inputs': ['Hi, who are you?']}, 'warnings': ['Setting `pad_token_id` to `eos_token_id`:50256 for open-end generation.']}
-        >>> client.conversational(
-        ...     "Wow, that's scary!",
-        ...     generated_responses=output["conversation"]["generated_responses"],
-        ...     past_user_inputs=output["conversation"]["past_user_inputs"],
-        ... )
-        ```
-        """
-        warnings.warn(
-            "'InferenceClient.conversational' is deprecated and will be removed starting from huggingface_hub>=0.25. "
-            "Please use the more appropriate 'InferenceClient.chat_completion' API instead.",
-            FutureWarning,
-        )
-        payload: Dict[str, Any] = {"inputs": {"text": text}}
-        if generated_responses is not None:
-            payload["inputs"]["generated_responses"] = generated_responses
-        if past_user_inputs is not None:
-            payload["inputs"]["past_user_inputs"] = past_user_inputs
-        if parameters is not None:
-            payload["parameters"] = parameters
-        response = self.post(json=payload, model=model, task="conversational")
-        return _bytes_to_dict(response)  # type: ignore
+        return model_url
 
     def document_question_answering(
         self,
@@ -1727,7 +1661,8 @@ class InferenceClient:
         repetition_penalty: Optional[float] = None,
         return_full_text: Optional[bool] = False,  # Manual default value
         seed: Optional[int] = None,
-        stop_sequences: Optional[List[str]] = None,  # Same as `stop`
+        stop: Optional[List[str]] = None,
+        stop_sequences: Optional[List[str]] = None,  # Deprecated, use `stop` instead
         temperature: Optional[float] = None,
         top_k: Optional[int] = None,
         top_n_tokens: Optional[int] = None,
@@ -1756,7 +1691,8 @@ class InferenceClient:
         repetition_penalty: Optional[float] = None,
         return_full_text: Optional[bool] = False,  # Manual default value
         seed: Optional[int] = None,
-        stop_sequences: Optional[List[str]] = None,  # Same as `stop`
+        stop: Optional[List[str]] = None,
+        stop_sequences: Optional[List[str]] = None,  # Deprecated, use `stop` instead
         temperature: Optional[float] = None,
         top_k: Optional[int] = None,
         top_n_tokens: Optional[int] = None,
@@ -1785,7 +1721,8 @@ class InferenceClient:
         repetition_penalty: Optional[float] = None,
         return_full_text: Optional[bool] = False,  # Manual default value
         seed: Optional[int] = None,
-        stop_sequences: Optional[List[str]] = None,  # Same as `stop`
+        stop: Optional[List[str]] = None,
+        stop_sequences: Optional[List[str]] = None,  # Deprecated, use `stop` instead
         temperature: Optional[float] = None,
         top_k: Optional[int] = None,
         top_n_tokens: Optional[int] = None,
@@ -1814,7 +1751,8 @@ class InferenceClient:
         repetition_penalty: Optional[float] = None,
         return_full_text: Optional[bool] = False,  # Manual default value
         seed: Optional[int] = None,
-        stop_sequences: Optional[List[str]] = None,  # Same as `stop`
+        stop: Optional[List[str]] = None,
+        stop_sequences: Optional[List[str]] = None,  # Deprecated, use `stop` instead
         temperature: Optional[float] = None,
         top_k: Optional[int] = None,
         top_n_tokens: Optional[int] = None,
@@ -1843,7 +1781,8 @@ class InferenceClient:
         repetition_penalty: Optional[float] = None,
         return_full_text: Optional[bool] = False,  # Manual default value
         seed: Optional[int] = None,
-        stop_sequences: Optional[List[str]] = None,  # Same as `stop`
+        stop: Optional[List[str]] = None,
+        stop_sequences: Optional[List[str]] = None,  # Deprecated, use `stop` instead
         temperature: Optional[float] = None,
         top_k: Optional[int] = None,
         top_n_tokens: Optional[int] = None,
@@ -1871,7 +1810,8 @@ class InferenceClient:
         repetition_penalty: Optional[float] = None,
         return_full_text: Optional[bool] = False,  # Manual default value
         seed: Optional[int] = None,
-        stop_sequences: Optional[List[str]] = None,  # Same as `stop`
+        stop: Optional[List[str]] = None,
+        stop_sequences: Optional[List[str]] = None,  # Deprecated, use `stop` instead
         temperature: Optional[float] = None,
         top_k: Optional[int] = None,
         top_n_tokens: Optional[int] = None,
@@ -1936,8 +1876,10 @@ class InferenceClient:
                 Whether to prepend the prompt to the generated text
             seed (`int`, *optional*):
                 Random sampling seed
+            stop (`List[str]`, *optional*):
+                Stop generating tokens if a member of `stop` is generated.
             stop_sequences (`List[str]`, *optional*):
-                Stop generating tokens if a member of `stop_sequences` is generated
+                Deprecated argument. Use `stop` instead.
             temperature (`float`, *optional*):
                 The value used to module the logits distribution.
             top_n_tokens (`int`, *optional*):
@@ -2081,6 +2023,15 @@ class InferenceClient:
             )
             decoder_input_details = False
 
+        if stop_sequences is not None:
+            warnings.warn(
+                "`stop_sequences` is a deprecated argument for `text_generation` task"
+                " and will be removed in version '0.28.0'. Use `stop` instead.",
+                FutureWarning,
+            )
+        if stop is None:
+            stop = stop_sequences  # use deprecated arg if provided
+
         # Build payload
         parameters = {
             "adapter_id": adapter_id,
@@ -2094,7 +2045,7 @@ class InferenceClient:
             "repetition_penalty": repetition_penalty,
             "return_full_text": return_full_text,
             "seed": seed,
-            "stop": stop_sequences if stop_sequences is not None else [],
+            "stop": stop if stop is not None else [],
             "temperature": temperature,
             "top_k": top_k,
             "top_n_tokens": top_n_tokens,
@@ -2164,7 +2115,7 @@ class InferenceClient:
                     repetition_penalty=repetition_penalty,
                     return_full_text=return_full_text,
                     seed=seed,
-                    stop_sequences=stop_sequences,
+                    stop=stop,
                     temperature=temperature,
                     top_k=top_k,
                     top_n_tokens=top_n_tokens,