+ 
+
+
+Affichons la collection qui a pour slug `"TheBloke/recent-models-64f9a55bb3115b4f513ec026"`:
+
+```py
+>>> from huggingface_hub import get_collection
+>>> collection = get_collection("TheBloke/recent-models-64f9a55bb3115b4f513ec026")
+>>> collection
+Collection(
+ slug='TheBloke/recent-models-64f9a55bb3115b4f513ec026',
+ title='Recent models',
+ owner='TheBloke',
+ items=[...],
+ last_updated=datetime.datetime(2023, 10, 2, 22, 56, 48, 632000, tzinfo=datetime.timezone.utc),
+ position=1,
+ private=False,
+ theme='green',
+ upvotes=90,
+ description="Models I've recently quantized. Please note that currently this list has to be updated manually, and therefore is not guaranteed to be up-to-date."
+)
+>>> collection.items[0]
+CollectionItem(
+ item_object_id='651446103cd773a050bf64c2',
+ item_id='TheBloke/U-Amethyst-20B-AWQ',
+ item_type='model',
+ position=88,
+ note=None
+)
+```
+
+L'objet [`Collection`] retourné par [`get_collection`] contient:
+- Des métadonnées: `slug`, `owner`, `title`, `description`, etc.
+- Une liste d'objets [`CollectionItem`]; chaque objet représente un modèle, un dataset, un space ou un article.
+
+Chaque objet d'une collection aura forcément:
+- Un `item_object_id` unique: c'est l'id de l'objet de la collection dans la base de données
+- Un `item_id`: c'est l'id dans le Hub de l'objet sous-jacent (modèle, dataset, space ou article); il n'est pas nécessairement unique, et seule la paire `item_id`/`item_type` sont uniques
+- Un `item_type`: modèle, dataset, space ou article
+- La `position` de l'objet dans la collection, qui peut-être mise à jour pour réorganiser votre collection (consultez [`update_collection_item`] ci dessous)
+
+Une note peut aussi être attachée à un objet. Cette note permet d'ajouter des informations supplémentaire sur l'objet (un commentaire, un lien vers le post d'un blog, etc.). L'attribut a toujours une valeur `None` si un objet n'a pas de note.
+
+En plus de ces attributs de base, les objets peuvent avoir des attributs supplémentaires en fonction de leur type: `author`, `private`, `lastModified`,`gated`, `title`, `likes`, `upvotes`, etc. Aucun de ces attribut ne sera retourné à coup sûr.
+
+## Lister les collections
+
+Vous pouvez aussi récupérer les collection en utilisant [`list_collections`]. Les collections peuvent être filtrées en utilisant certains paramètres. Listons toutes les collections de l'utilisateur [`teknium`](https://huggingface.co/teknium).
+```py
+>>> from huggingface_hub import list_collections
+
+>>> collections = list_collections(owner="teknium")
+```
+
+Ce code renvoie un itérable d'objets `Collection`. On peut itérer sur ce dernier pour afficher, par exemple, le nombre d'upvote de chaque collection.
+
+```py
+>>> for collection in collections:
+... print("Number of upvotes:", collection.upvotes)
+Number of upvotes: 1
+Number of upvotes: 5
+```
+
+
+_(sauvegarder corromprait le cache)_ | ✅ | ✅ | +| `local_dir="path/to/folder"`
`local_dir_use_symlinks="auto"` | | fichier ou symlink dans un dossier | ✅ | ✅ _(pour les petits fichiers)_
⚠️ _(pour les gros fichiers, ne resolve pas le path avant l'enregistrement)_ | ✅ | ✅ | +| `local_dir="path/to/folder"`
`local_dir_use_symlinks=True` | | symlink dans un dossier | ✅ | ⚠️
_(ne resolve pas le paht avant l'enregistrement)_ | ✅ | ✅ | +| `local_dir="path/to/folder"`
`local_dir_use_symlinks=False` | Non | fichier dans un dossier | ✅ | ✅ | ❌
_(en cas de re-run, le fichier est retéléchargé)_ | ⚠️
(plusieurs copies si lancé dans plusieurs dossiers) | +| `local_dir="path/to/folder"`
`local_dir_use_symlinks=False` | oui | fichier dans un dossier | ✅ | ✅ | ⚠️
_(le fichier doit être mis en cache d'abord)_ | ❌
_(le fichier est dupliqué)_ | + +**Note:** si vous utilisez une machien Windows, vous devez activer le mode développeur ou lancer `huggingface_hub` en tant qu'administrateur pour activer les syymlinks. Consultez la section [limitations du cache](../guides/manage-cache#limitations) + +## Télécharger depuis le CLI + +Vous pouvez utiliser la commande `huggingface-cli download` depuis un terminal pour télécharger directement des +fichiers du Hub. En interne, cette commande utilise les même helpers [`hf_hub_download`] et [`snapshot_download`] +décrits ci-dessus et affiche le chemin renvoyé dans le terminal. + +```bash +>>> huggingface-cli download gpt2 config.json +/home/wauplin/.cache/huggingface/hub/models--gpt2/snapshots/11c5a3d5811f50298f278a704980280950aedb10/config.json +``` + +Vous pouvez télécharger plusieurs fichiers d'un coup, ce qui affiche une barre de chargement et renvoie le chemin de +la snapshot dans lequel les fichiers sont localisés. + +```bash +>>> huggingface-cli download gpt2 config.json model.safetensors +Fetching 2 files: 100%|████████████████████████████████████████████| 2/2 [00:00<00:00, 23831.27it/s] +/home/wauplin/.cache/huggingface/hub/models--gpt2/snapshots/11c5a3d5811f50298f278a704980280950aedb10 +``` + +Pour plus de détails sur la commande download du CLI, veuillez consulter le [guide CLI](./cli#huggingface-cli-download). + +## Téléchargements plus rapides + +Si vous utilisez une machine avec une bande passante plus large, vous pouvez augmenter votre vitesse de téléchargement en utilisant [`hf_transfer`], +une librairie basée sur Rust développée pour accélérer le transfer de fichiers avec le Hub. Pour l'activer, installez le package (`pip install hf_transfer`) et définissez set `HF_HUB_ENABLE_HF_TRANSFER=1` en tant que variable d'environnement + +
`push_to_hub(model, ...)` | `model = MyModel.from_pretrained(...)`
`model.push_to_hub(...)` | +| Flexible | Très flexible.
Vous controllez complètement l'implémentation. | Moins flexible.
Votre framework doit avoir une classe de modèle. | +| Maintenance | Plus de maintenance pour ajouter du support pour la configuration, et de nouvelles fonctionnalités. Peut aussi nécessiter de fixx des problèmes signalés par les utilisateurs.| Moins de maintenance vu que la plupart des intégrations avec le Hub sont implémentés dans `huggingface_hub` | +| Documentation / Anotation de type| A écrire à la main | Géré partiellement par `huggingface_hub`. | \ No newline at end of file diff --git a/docs/source/fr/guides/manage-cache.md b/docs/source/fr/guides/manage-cache.md new file mode 100644 index 0000000000..0e37bbc3ea --- /dev/null +++ b/docs/source/fr/guides/manage-cache.md @@ -0,0 +1,569 @@ + + +# Gérer le cache-system `huggingface_hub` + +## Comprendre le caching + +Le cache-system Hugging Face Hub a été créé pour être le cache central partagé par toutes les +librairies dépendant du Hub. Il a été mis à jour dans la version v0.8.0 pour éviter de +retélécharger les mêmes fichiers entre chaque révisions. + +Le système de cache fonctionne comme suit: + +``` +
+ 
+
+
+Instructions:
+ - Appuyez lsur les flèches `
+
+
diff --git a/docs/source/fr/guides/repository.md b/docs/source/fr/guides/repository.md
new file mode 100644
index 0000000000..db635a310d
--- /dev/null
+++ b/docs/source/fr/guides/repository.md
@@ -0,0 +1,248 @@
+
+
+# Créer et gérer un dépôt
+
+Le Hub Hugging Face est une collection de dépôt git. [Git](https://git-scm.com/) est un outil utilisé par tous les développeurs
+de software, il permet de versionner facilement des projet lors de travaux en équipe. Ce guide vous montrera commen intéragir
+avec les dépôts sur le Hub, ne particulier:
+
+- Créer et supprimer un dépôt.
+- Gérer les branches et les tags.
+- Renommer votre dépôt.
+- Mettre à jour la visibilité de votre dépôt.
+- Gérer une copie local de votre dépôt.
+
+
+
+
+
+
+ Dépôts
+
+ Comment créer un dépôt sur le Hub ? Comment le configurer ? Comment intéragir avec ? +
+ + + +
+ Télécharger des fichiers
+
+ Comment télécharger un fichier du Hub? Comment télécharger un dépôt? +
+ + + +
+ Upload des fichiers
+
+ Comment upload un fichier ou un dossier? Comment modifier un dépôt existant sur le Hub? +
+ + + +
+ Recherche
+
+ Comment faire une recherche efficace parmi les plus de 200 000 modèles, datasets et spaces? +
+ + + +
+ HfFileSystem
+
+ Comment intéragir avec le Hub à travers une interface pratique qui colle parfaitement à l'interface fichier de Python? +
+ + + +
+ Inférence
+
+ Comment faire des prédictions en utilisant l'API d'inférence accélérée? +
+ + + +
+ Community Tab
+
+ Comment intéragir avec la communauté (discussions et pull requests)? +
+ + + +
+ Collections
+
+ Comment construire des collections depuis le code? +
+ + + +
+ Cache
+
+ Comment le système cache fonctionne? Comment l'utiliser à son avantage? +
+ + + +
+ Carte de modèle
+
+ Comment créer et partager une carte de modèle? +
+ + + +
+ Gérez votre space
+
+ Comment gérer le hardware d'un space et sa configuration? +
+ + + +
+ Intégrez une librairie
+
+ Que signifie intégrer une librairie avec le Hub? Et comment le faire? +
+ + + +
+ Serveurs WebHooks
+
+ Comment créer un serveur pour recevoir des webhooks et le déployer en tant que space? +
+ + +
+
+
+
+Et voilà! Vous pouvez maintenant activer cce webhook en mettant à jour le dépôt cible (i.e. push un commit). Consultez
+la table d'activité de votre webhook pour voir les événements passés. Maintenant que vous avez un setup qui fonctionne,
+vous pouvez le tester et itérer rapidement. Si vous modifiez votre code et relancez le serveur, votre URL public pourrait
+changer. Assurez vous de mettre à jour la configuration du webhook dans le Hub si besoin.
+
+## Déployer vers un space
+
+Maintenant que vous avez un serveur webhook fonctionnel, le but est de le déployer sur un space. Allez sur
+https://huggingface.co/new-space pour créer un space. Donnez lui un nom, sélectionnez le SDK Gradio et cliquer sur
+"Créer un space" (ou "Create Space" en anglais). Uploadez votre code dans le space dans un fichier appelé `app.py`.
+Votre space sera lancé automatiquement! Pour plus de détails sur les spaces, consultez ce [guide](https://huggingface.co/docs/hub/spaces-overview).
+
+Votre serveur webhook tourne maintenant sur un space public. Dans la plupart de cas, vous aurez besoin de le sécuriser
+avec un secret. Allez dans les paramètres de votre space > Section "Repository secrets" > "Add a secret". Définissez
+la variable d'environnement `WEBHOOK_SECRET` en choisissant la valeur que vous voulez. Retournez dans les
+[réglages webhooks](https://huggingface.co/settings/webhooks) et définissez le secret dans la configuration du webhook.
+Maintenant, seules les requêtes avec le bon secret seront acceptées par votre serveur.
+
+Et c'est tout! Votre space est maintenant prêt à recevoir des webhooks du Hub. Gardez à l'esprit que si vous faites
+tourner le space sur le hardware gratuit 'cpu-basic', il sera éteint après 48 heures d'inactivité. Si vous avez besoin d'un
+space permanent, vous devriez peut-être considérer l'amélioration vers un [hardware amélioré](https://huggingface.co/docs/hub/spaces-gpus#hardware-specs).
+
+## Utilisation avancée
+
+Le guide ci dessus expliquait la manière la plus rapide d'initialiser un [`WebhookServer`]. Dans cette section, nous verrons
+comment le personnaliser plus en détails.
+
+### Endpoints multilpes
+
+Vous pouvez avoir plusieurs endpoints sur le même serveur. Par exemple, vous aurez peut-être envie d'avoir un endpoint
+qui lance un entrainement de modèle et un autre qui lance une évaluation de modèle. Vous pouvez faire ça en ajoutant
+plusieurs décorateurs `@webhook_endpoint`:
+
+```python
+# app.py
+from huggingface_hub import webhook_endpoint, WebhookPayload
+
+@webhook_endpoint
+async def trigger_training(payload: WebhookPayload) -> None:
+ if payload.repo.type == "dataset" and payload.event.action == "update":
+ # Lance une tâche d'entrainement si votre dataset est mis à jour
+ ...
+
+@webhook_endpoint
+async def trigger_evaluation(payload: WebhookPayload) -> None:
+ if payload.repo.type == "model" and payload.event.action == "update":
+ # Lance un tâche d'évaluation si un modèle est mis à jour
+ ...
+```
+
+Ce qui créera deux endpoints:
+
+```text
+(...)
+Webhooks are correctly setup and ready to use:
+ - POST https://1fadb0f52d8bf825fc.gradio.live/webhooks/trigger_training
+ - POST https://1fadb0f52d8bf825fc.gradio.live/webhooks/trigger_evaluation
+```
+
+### Serveur personnalisé
+
+Pour plus de flexibilité, vous pouvez aussi créer un objet [`WebhooksServer`] directement. C'est utile si vous
+voulez customiser la page d'acceuil de votre serveur. Vous pouvez le faire en passant une [UI Gradio](https://gradio.app/docs/#blocks)
+qui va overwrite linterface par défaut. Par exemple, vous pouvez ajouter des instructions pour vos utilisateurs
+ou ajouter un formulaire pour avtiver les webhooks manuellement. Lors de la création d'un [`WebhooksServer`], vous
+pouvez créer de nouveaux webhooks en utilisant le décorateur [`~WebhooksServer.add_webhook`].
+
+Here is a complete example:
+
+```python
+import gradio as gr
+from fastapi import Request
+from huggingface_hub import WebhooksServer, WebhookPayload
+
+# 1. Déifnition de l'interface
+with gr.Blocks() as ui:
+ ...
+
+# 2. Création d'un WebhooksServer avec une interface personnalisée et un secret
+app = WebhooksServer(ui=ui, webhook_secret="my_secret_key")
+
+# 3. Ajout d'un webhook avec un nom explicite
+@app.add_webhook("/say_hello")
+async def hello(payload: WebhookPayload):
+ return {"message": "hello"}
+
+# 4. Ajout d'un webhook avec un nom implicite
+@app.add_webhook
+async def goodbye(payload: WebhookPayload):
+ return {"message": "goodbye"}
+
+# 5. Lancement du serveur (optionnel)
+app.run()
+```
+
+1. Nous définissons une interface personnalisée en utilisant des block Gradio. Cette interface sera affichée
+sur la page d'accueil du serveur.
+2. Nous créons un objet [`WebhooksServer`] avec une interface personnalisée et un secret. Le secret est optionnel et
+peut être définit avec la variable d'environnement `WEBHOOK_SECRET`.
+3. Nous créons un webhook avec un nom explicite. Ceci créera un endpoint à `/webhooks/say_hello`.
+4. Nous créons un webhook avec un nom implicite. Ceci créera un endpoint à `/webhoojs/goodbye`.
+5. Nous lançons le serveur. C'est optionnel car votre serveur sera automatiquement lancé à la fin du script.
\ No newline at end of file
diff --git a/docs/source/fr/index.md b/docs/source/fr/index.md
new file mode 100644
index 0000000000..0443d38744
--- /dev/null
+++ b/docs/source/fr/index.md
@@ -0,0 +1,59 @@
+
+
+# Un client pour le Hugging Face Hub
+
+La librairie `huggingface_hub` vous permet d'interagir avec le
+[Hugging Face Hub](https://hf.co), une plateforme de machine learning
+pour créer et collaborer. Découvrez des modèles pré-
+entrainés et des datasets pour vos projets ou jouez avec des centraines
+d'applications hébergées sur le Hub. Vous pouvez aussi
+créer et partager vos propres modèles et datasets avec la communauté.
+La librairie `huggingface_hub` offre une manière simple de faire toutes
+ces choses avec Python.
+
+Lisez le [guide d'introduction rapide](quick-start) pour vous lancer avec la librairie
+`huggingface_hub`. Vous apprendrez à télécharger des fichiers depuis le Hub,
+à créer un dépôt et upload des fichiers vers le Hub. Continuez à lire pour
+apprendre le management de dépôt sur le Hub, comment interagir avec les discussions
+ou même comment accéder à l'API d'inférence.
+
+
+
+
+
+
+
+## Contributions
+
+Toutes les contributions au projet `huggingface_hub` sont les bienvenues et valorisées à la même hauteur.
+🤗 En plus de l'ajout ou de la correction de bug dans le code, vous
+pouvez également aider à améliorer la documentation en vérifiant qu'elle est exacte et
+à jour, répondre à des questions sur des issues, et demander de nouvelles fonctionnalités
+qui amélioreront la librairie. Regardez le [guide de contribution](https://github.com/huggingface/huggingface_hub/blob/main/CONTRIBUTING.md)
+pour en savoir plus sur comment commencer à travailler sur une issue, comment faire une pull request et comment tester vos contributions pour
+vérifier que vos modifications fonctionnent comme prévu.
+
+Les contributeurs doivent aussi respecter notre [code de conduite](https://github.com/huggingface/huggingface_hub/blob/main/CODE_OF_CONDUCT.md) (en anglais) pour créer un espace collaboratif inclusif et bienveillant envers tout le monde.
\ No newline at end of file
diff --git a/docs/source/fr/installation.md b/docs/source/fr/installation.md
new file mode 100644
index 0000000000..49e07429a5
--- /dev/null
+++ b/docs/source/fr/installation.md
@@ -0,0 +1,161 @@
+
+
+# Installation
+
+Avant de commmencer, vous allez avoir besoin de préparer votre environnement
+en installant les packages appropriés.
+
+`huggingface_hub` est testée sur **Python 3.8+**.
+
+## Installation avec pip
+
+Il est fortement recommandé d'installer `huggingface_hub` dans un [environnement virtuel](https://docs.python.org/3/library/venv.html).
+Si vous n'êtes pas familier avec les environnements virtuels Python, suivez ce [guide](https://packaging.python.org/en/latest/guides/installing-using-pip-and-virtual-environments/). Un environnement virtuel sera utile lorsque vous devrez gérer des plusieurs projets en parallèle
+afin d'éviter les problèmes de compatibilité entre les différentes dépendances.
+
+Commencez par créer un environnement virtuel à l'emplacement de votre projet:
+
+```bash
+python -m venv .env
+```
+
+Activez l'environnement virtuel sur Linux et macOS:
+
+```bash
+source .env/bin/activate
+```
+
+Activez l'environnement virtuel sur Windows:
+
+```bash
+.env/Scripts/activate
+```
+
+Maintenant, vous êtes prêts à installer `hugginface_hub` [depuis PyPi](https://pypi.org/project/huggingface-hub/):
+
+```bash
+pip install --upgrade huggingface_hub
+```
+
+Une fois l'installation terminée, rendez-vous à la section [vérification](#verification-de-l-installation) pour s'assurer que tout fonctionne correctement.
+
+### Installation des dépendances optionnelles
+
+Certaines dépendances de `huggingface_hub` sont [optionnelles](https://setuptools.pypa.io/en/latest/userguide/dependency_management.html#optional-dependencies) car elles ne sont pas nécessaire pour faire marcher les fonctionnalités principales de `huggingface_hub`.
+Toutefois, certaines fonctionnalités de `huggingface_hub` ne seront pas disponibles si les dépendancces optionnelles ne sont pas installées
+
+Vous pouvez installer des dépendances optionelles via `pip`:
+```bash
+#Installation des dépendances pour les fonctionnalités spécifiques à Tensorflow.
+#/!\ Attention : cette commande n'est pas équivalente à `pip install tensorflow`.
+pip install 'huggingface_hub[tensorflow]'
+
+#Installation des dépendances spécifiques à Pytorch et au CLI.
+pip install 'huggingface_hub[cli,torch]'
+```
+
+Voici une liste des dépendances optionnelles dans `huggingface_hub`:
+- `cli` fournit une interface d'invite de commande plus pratique pour `huggingface_hub`.
+- `fastai`, `torch` et `tensorflow` sont des dépendances pour utiliser des fonctionnalités spécifiques à un framework.
+- `dev` permet de contribuer à la librairie. Cette dépendance inclut `testing` (pour lancer des tests), `typing` (pour lancer le vérifieur de type) et `quality` (pour lancer des linters).
+
+
+
+### Installation depuis le code source
+
+Dans certains cas, il est intéressant d'installer `huggingface_hub` directement depuis le code source.
+Ceci vous permet d'utiliser la version `main`, contenant les dernières mises à jour, plutôt que
+d'utiliser la dernière version stable. La version `main` est utile pour rester à jour sur les
+derniers développements, par exemple si un bug est corrigé depuis la dernière version officielle
+mais que la nouvelle version n'a pas encore été faite.
+
+Toutefois, cela signifie que la version `main` peut ne pas être stable. Nous travaillons
+afin de rendre la version `main` aussi stable que possible, et la plupart des problèmes sont résolus
+en quelques heures ou jours. Si vous avez un problème, ouvrez une issue afin que
+nous puissions la régler au plus vite !
+
+```bash
+pip install git+https://github.com/huggingface/huggingface_hub
+```
+
+Lorsque vous installez depuis le code source, vous pouvez préciser la branche depuis laquelle installer. Cela permet de tester une nouvelle fonctionnalité ou un bug-fix qui n'a pas encore été merge:
+
+```bash
+pip install git+https://github.com/huggingface/huggingface_hub@ma-branche
+```
+
+Une fois l'installation terminée, rendez-vous à la section [vérification](#verification-de-l-installation) pour s'assurer que tout fonctionne correctement.
+
+### Installation éditable
+
+L'installation depuis le code source vous permet de mettre en place une [installation éditable](https://pip.pypa.io/en/stable/topics/local-project-installs/#editable-installs). Cette installation sert surtout si vous comptez contribuer à `huggingface_hub`
+et que vous avez besoin de tester rapidement des changements dans le code. Pour cela, vous devez cloner le projet `huggingface_hub` sur votre machine.
+
+```bash
+# Commencez par cloner le dépôt en local
+git clone https://github.com/huggingface/huggingface_hub.git
+
+# Ensuite, installez-le avec le flag -e
+cd huggingface_hub
+pip install -e .
+```
+
+Python regardera maintenant à l'intérieur du dossier dans lequel vous avez cloné le dépôt en
+plus des chemins de librairie classiques. Par exemple, si vos packages Python sont installés dans
+`./.venv/lib/python3.11/site-packages/`, Python regardera aussi dans le dossier que vous avez
+cloné `./huggingface_hub/`.
+
+## Installation avec conda
+
+Si vous avez plutôt l'habitude d'utiliser conda, vous pouvez installer `huggingface_hub` en utilisant le [channel conda-forge](https://anaconda.org/conda-forge/huggingface_hub):
+
+
+```bash
+conda install -c conda-forge huggingface_hub
+```
+
+Une fois l'installation terminée, rendez-vous à la section [vérification](#verification-de-l-installation) pour s'assurer que tout fonctionne correctement.
+
+## Vérification de l'installation
+
+Une fois installée, vérifiez que `huggingface_hub` marche correctement en lançant la commande suivante:
+
+```bash
+python -c "from huggingface_hub import model_info; print(model_info('gpt2'))"
+```
+
+Cette commande va récupérer des informations sur le modèle [gpt2](https://huggingface.co/gpt2) depuis le Hub.
+La sortie devrait ressembler à ça:
+
+```text
+Model Name: gpt2
+Tags: ['pytorch', 'tf', 'jax', 'tflite', 'rust', 'safetensors', 'gpt2', 'text-generation', 'en', 'doi:10.57967/hf/0039', 'transformers', 'exbert', 'license:mit', 'has_space']
+Task: text-generation
+```
+
+## Les limitations Windows
+
+Afin de démocratiser le machine learning pour tous, nous avons développé `huggingface_hub`
+de manière cross-platform et en particulier, pour qu'elle fonctionne sur un maximum de systèmes d'exploitation différents.
+Toutefois, `huggingface_hub` connaît dans certains cas des limiations sur Windows.
+Nous avons listés ci-dessous les problèmes connus. N'hésitez pas à nous signaler si vous rencontrez un problème
+non documenté en ouvrant une [issue sur Github](https://github.com/huggingface/huggingface_hub/issues/new/choose).
+
+- Le cache de `huggingface_hub` a besoin des symlinks pour mettre en cache les fichiers installé depuis le Hub.
+Sur windows, vous devez activer le mode développeur pour lancer ou lancer votre script en tant qu'administrateur
+afin de faire fonctionner les symlinks. S'ils ne sont pas activés, le système de cache fonctionnera toujours mais
+de manière sous-optimale. Consultez les [limitations du cache](./guides/manage-cache#limitations) pour plus de détails.
+- Les noms de fichiers sur le Hub peuvent avoir des caractères spéciaux (par exemple `"path/to?/my/file"`).
+Windows est plus restrictif sur les [caractères spéciaux](https://learn.microsoft.com/en-us/windows/win32/intl/character-sets-used-in-file-names)
+ce qui rend ces fichiers ininstallables sur Windows. Heureusement c'est un cas assez rare.
+Contactez le propriétaire du dépôt si vous pensez que c'est une erreur ou contactez nous
+pour que nous cherchions une solution.
+
+
+## Prochaines étapes
+
+Une fois que `huggingface_hub` est installé correctement sur votre machine, vous aurez peut-être besoin de
+[configurer les variables d'environnement](package_reference/environment_variables) ou de [lire un de nos guides](guides/overview)
+pour vous lancer.
\ No newline at end of file
diff --git a/docs/source/fr/package_reference/cache.md b/docs/source/fr/package_reference/cache.md
new file mode 100644
index 0000000000..502156ef66
--- /dev/null
+++ b/docs/source/fr/package_reference/cache.md
@@ -0,0 +1,61 @@
+
+
+# Référence au système cache
+
+Le système de caching a été mis à jour dans la version v0.8.0 pour devenir un système
+cache central et partagé par toutes les librairies dépendant du Hub. Consultez le
+[guide système cache](../guides/manage-cache) pour une présentation détaillée du
+cache à HF.
+
+## Les Helpers
+
+### try_to_load_from_cache
+
+[[autodoc]] huggingface_hub.try_to_load_from_cache
+
+### cached_assets_path
+
+[[autodoc]] huggingface_hub.cached_assets_path
+
+### scan_cache_dir
+
+[[autodoc]] huggingface_hub.scan_cache_dir
+
+## Structures de données
+
+Toutes les structures sont construites et retournées par [`scan_cache_dir`]
+et sont immuables.
+
+### HFCacheInfo
+
+[[autodoc]] huggingface_hub.HFCacheInfo
+
+### CachedRepoInfo
+
+[[autodoc]] huggingface_hub.CachedRepoInfo
+ - size_on_disk_str
+ - refs
+
+### CachedRevisionInfo
+
+[[autodoc]] huggingface_hub.CachedRevisionInfo
+ - size_on_disk_str
+ - nb_files
+
+### CachedFileInfo
+
+[[autodoc]] huggingface_hub.CachedFileInfo
+ - size_on_disk_str
+
+### DeleteCacheStrategy
+
+[[autodoc]] huggingface_hub.DeleteCacheStrategy
+ - expected_freed_size_str
+
+## Exceptions
+
+### CorruptedCacheException
+
+[[autodoc]] huggingface_hub.CorruptedCacheException
\ No newline at end of file
diff --git a/docs/source/fr/package_reference/cards.md b/docs/source/fr/package_reference/cards.md
new file mode 100644
index 0000000000..98dfb25a8f
--- /dev/null
+++ b/docs/source/fr/package_reference/cards.md
@@ -0,0 +1,79 @@
+
+
+# Cartes de dépôts
+
+La librairie `huggingface_hub` fournit une interface Python pour créer, partager et mettre à jour les
+cartes de modèles ou de dataset. Consultez la [page de documentation dédiée](https://huggingface.co/docs/hub/models-cards)
+Pour une vue plus profonde de ce que son les cartes de modèle sur le Hub et de comment elles fonctionnent
+en arrière plan. Vous pouvez aussi consulter notre [guide de cartes de modèle](../how-to-model-cards)
+pour avoir une intuition de la manière dont vous pourriez les utiliser dans vos projets.
+
+## Carte de dépôt
+
+L'objet `RepoCard` est la classe parent de [`ModelCard`], [`DatasetCard`] et `SpaceCard`.
+
+[[autodoc]] huggingface_hub.repocard.RepoCard
+ - __init__
+ - all
+
+## Donnée de cartes
+
+L'objet [`CardData`] est la classe parent de [`ModelCardData`] et [`DatasetCardData`].
+
+[[autodoc]] huggingface_hub.repocard_data.CardData
+
+## Cartes de modèles
+
+### ModelCard
+
+[[autodoc]] ModelCard
+
+### ModelCardData
+
+[[autodoc]] ModelCardData
+
+## Dataset Cards
+
+Dataset cards are also known as Data Cards in the ML Community.
+
+### DatasetCard
+
+[[autodoc]] DatasetCard
+
+### DatasetCardData
+
+[[autodoc]] DatasetCardData
+
+## Cartes de Space
+
+### SpaceCard
+
+[[autodoc]] SpaceCard
+
+### SpaceCardData
+
+[[autodoc]] SpaceCardData
+
+## Utilities
+
+### EvalResult
+
+[[autodoc]] EvalResult
+
+### model_index_to_eval_results
+
+[[autodoc]] huggingface_hub.repocard_data.model_index_to_eval_results
+
+### eval_results_to_model_index
+
+[[autodoc]] huggingface_hub.repocard_data.eval_results_to_model_index
+
+### metadata_eval_result
+
+[[autodoc]] huggingface_hub.repocard.metadata_eval_result
+
+### metadata_update
+
+[[autodoc]] huggingface_hub.repocard.metadata_update
\ No newline at end of file
diff --git a/docs/source/fr/package_reference/collections.md b/docs/source/fr/package_reference/collections.md
new file mode 100644
index 0000000000..5745528280
--- /dev/null
+++ b/docs/source/fr/package_reference/collections.md
@@ -0,0 +1,25 @@
+
+
+# Gérer les collections
+
+Consultez la page de documentation [`HfApi`] pour les références des méthodes qui vous permettront
+de gérer votre space sur le Hub.
+
+- Afficher le contenu d'une collection: [`get_collection`]
+- Créer une nouvelle collection: [`create_collection`]
+- Mettre à jour une collection: [`update_collection_metadata`]
+- Supprimer une collection: [`delete_collection`]
+- Ajouter un item à une collection: [`add_collection_item`]
+- Mettre à jour un item dans une collection: [`update_collection_item`]
+- Supprimer un item d'une collection: [`delete_collection_item`]
+
+
+### Collection
+
+[[autodoc]] Collection
+
+### CollectionItem
+
+[[autodoc]] CollectionItem
\ No newline at end of file
diff --git a/docs/source/fr/package_reference/community.md b/docs/source/fr/package_reference/community.md
new file mode 100644
index 0000000000..38e9065ff8
--- /dev/null
+++ b/docs/source/fr/package_reference/community.md
@@ -0,0 +1,34 @@
+
+
+# Interagir avec les dicussions et les pull requests
+
+Consultez la page de documentation [`HfApi`] pour les références des méthodes permettant l'intéraction
+avec des pull requests et des discussions sur le Hub.
+
+- [`get_repo_discussions`]
+- [`get_discussion_details`]
+- [`create_discussion`]
+- [`create_pull_request`]
+- [`rename_discussion`]
+- [`comment_discussion`]
+- [`edit_discussion_comment`]
+- [`change_discussion_status`]
+- [`merge_pull_request`]
+
+## Structure des données
+
+[[autodoc]] Discussion
+
+[[autodoc]] DiscussionWithDetails
+
+[[autodoc]] DiscussionEvent
+
+[[autodoc]] DiscussionComment
+
+[[autodoc]] DiscussionStatusChange
+
+[[autodoc]] DiscussionCommit
+
+[[autodoc]] DiscussionTitleChange
diff --git a/docs/source/fr/package_reference/environment_variables.md b/docs/source/fr/package_reference/environment_variables.md
new file mode 100644
index 0000000000..ad76eeb227
--- /dev/null
+++ b/docs/source/fr/package_reference/environment_variables.md
@@ -0,0 +1,186 @@
+
+
+# Variables d'environnement
+
+`huggingface_hub` peut être configuré en utilisant des variables d'environnement.
+
+Si vous n'êtes pas familier avec le principe de variable d'environnement, voici des
+articles assez générique sur ces dernières [sur macOS et Linux](https://linuxize.com/post/how-to-set-and-list-environment-variables-in-linux/)
+et sur [Windows](https://phoenixnap.com/kb/windows-set-environment-variable).
+
+Cette page vous guidera à travers toutes les variables d'environnement spécifiques à
+`huggingface_hub` et leur signification.
+
+## Les variables génériques
+
+### HF_INFERENCE_ENDPOINT
+
+Pour configurer l'url de base de l'api d'inférence, vous aurez peut-être besoin de définir
+cette variable si votre organisation pointe vers un gateway d'API plutôt que directement vers
+l'API d'inférence.
+
+Par défaut, l'endpoint sera `"https://api-inference.huggingface.com"`.
+
+### HF_HOME
+
+Pour configurer le chemin vers lequel `huggingface_hub` enregistrera de la donnée par
+défaut. En particulier, votre token d'authentification et le cache seront enregistrés
+dans ce dossier.
+
+Par défaut, ce chemin sera `"~/.cache/huggingface"` sauf si [XDG_CACHE_HOME](#xdgcachehome)
+est définie.
+
+### HF_HUB_CACHE
+
+Pour configurer le chemin vers lequels les dépôts du Hub seront mis en cache en local
+(modèles, datasets et spaces).
+
+Par défaut, ce sera `"$HF_HOME/hub"` (i.e. `"~/.cache/huggingface/hub"` par défaut).
+
+### HF_ASSETS_CACHE
+
+Pour configurer le chemin vers lequel les [assets](../guides/manage-cache#caching-assets) créés
+par des librairies seront mis en cache en local. Ces assets peuvent être de la donnée pré-traitée,
+des fichiers téléchargés depuis GitHub, des logs,...
+
+Par défaut, le chemin sera `"$HF_HOME/assets"` (i.e. `"~/.cache/huggingface/assets"` par défaut).
+
+### HF_TOKEN
+
+Pour configurer le token d'authentification qui permet de vous authentifier sur le Hub.
+Si définie, cette valeur écrasera le token enregistré sur la machine (dans `"$HF_HOME/token"`).
+
+Consultez [la référence aux connexions](../package_reference/login) pour plus de détails.
+
+### HF_HUB_VERBOSITY
+
+Définissez le niveau de verbosité du logger `huggingface_hub`. La variable doit
+être choisie parmi `{"debug", "info", "warning", "error", "critical"}`.
+
+Par défaut, la variable sera `"warning"`.
+
+Pour plus de détails, consultez [la référence aux connexions](../package_reference/utilities#huggingface_hub.utils.logging.get_verbosity).
+
+### HF_HUB_LOCAL_DIR_AUTO_SYMLINK_THRESHOLD
+
+Valeur entière définissant en dessous de quelle taille un fichier est considéré comme "petit". Lors du téléchargement
+de fichiers vers un chemin local, les petits fichiers seront dupliqués pour faciliter l'expérience utilisateur là où
+les fichiers plus gros n'auront qu'un symlink vers eux pour conserver de l'espace sur le disque.
+
+Pour plus de détails, consultez le [guide de téléchargement](../guides/download#download-files-to-local-folder).
+
+### HF_HUB_ETAG_TIMEOUT
+
+Valeur entière définissant le nombre de secondes pendant lesquelles il faut attendre la réponse du serveur lors de l'affichage des dernières metadonnées depuis un dépôt avant de télécharger un fichier. En cas de timeout, alors, par défaut, `huggingface_hub` se limitera aux fichiers en cache en local. Définir une valeur plus faible accélère le workflow pour des machines avec une connexion lente qui ont déjà des fichiers en cache. Une plus grande valeur garanti l'appel aux métadonnées pour réussir dans plus de cas. Par défaut, la valeur est de 10s.
+
+### HF_HUB_DOWNLOAD_TIMEOUT
+
+Valeur entière pour définir le nombre de secondes durant lesquelles il faut attendre la réponse du serveur lors du téléchargement d'un fichier. Si la requête tiemout, une TimeoutError sera levée. Définir une valeur grande est bénéfique sur une machine qui a une connexion lente. Une valeur plus faible fait échouer le process plus vite dans le cas d'un réseau complexe. Par défaut, la valeur est de 10s.
+
+## Valeures booléennes
+
+Les variables d'environnement suivantes attendes une valeur booléenne. La variable sera
+considérées comme `True` si sa valeur fait partie de la liste`{"1", "ON", "YES", "TRUE"}`.
+Toute autre valeur (ou undefined) sera considérée comme `False`.
+
+### HF_HUB_OFFLINE
+
+Si définie, aucun appel HTTP ne sera fait lors de l'ajout de fichiers. Seuls les fichiers
+qui sont déjà en cache seront ajoutés. C'est utile si votre réseau est lent et que vous
+vous en fichez d'avoir absolument la dernière version d'un fichier.
+
+**Note:** Même si la dernière version d'un fichier est en cache, l'appel de `hf_hub_download`
+lancera quand même une requête HTTP pour vérifier qu'une nouvelle version est disponible.
+Définir `HF_HUB_OFFLINE=1` évitera cet appel ce qui peut accélérer votre temps de chargement.
+
+### HF_HUB_DISABLE_IMPLICIT_TOKEN
+
+L'authentification n'est pas obligatoire pour toutes les requêtes vers le Hub. Par
+exemple, demander des détails sur le modèle `"gpt2"` ne demande pas nécessairement
+d'être authentifié. Cependant, si un utilisateur est [connecté](../package_reference/login),
+le comportement par défaut sera de toujours envoyer le token pour faciliter l'expérience
+utilisateur (cela évite d'avoir une erreur 401 Unauthorized) lors de l'accès de dépôt
+privés ou protégé. Vous pouvez supprimer ce comportement en définissant `HF_HUB_DISABLE_IMPLICIT_TOKEN=1`.
+Dans ce cas, le token ne sera envoyé que pour des appels de type "write-access" (par exemple, pour créer un commit).
+
+**Note:** supprimer l'envoi implicit de token peut avoir des effets secondaires bizarres.
+Par exemple, si vous voulez lister tous les modèles sur le Hub, vos modèles privés ne
+seront pas listés. Vous auriez besoin d'un argument explicite `token=True` dans votre
+script.
+
+### HF_HUB_DISABLE_PROGRESS_BARS
+
+Pour les tâches longues, `huggingface_hub` affiche une bar de chargement par défaut (en utilisant tqdm).
+Vous pouvez désactiver toutes les barres de progression d'un coup en définissant
+`HF_HUB_DISABLE_PROGRESS_BARS=1`.
+
+### HF_HUB_DISABLE_SYMLINKS_WARNING
+
+Si vous avez une machine Windows, il est recommandé d'activer le mode développeur ou de
+faire tourner `huggingface_hub` en mode admin. Sinon, `huggingface_hub` ne ser pas capable
+de créer des symlinks dans votre système de cache. Vous serez capables d'exécuter n'importe
+quel script, mais votre expérience utilisateur sera moins bonne vu que certains gros fichiers
+pourraient être dupliqués sur votre disque dur. Un message d'avertissement vous préviendra
+de ce type de comportement. Définissez `HF_HUB_DISABLE_SYMLINKS_WARNING=1`, pour désactiver
+cet avertissement.
+
+Pour plus de détails, consultez [les limitations du cache](../guides/manage-cache#limitations).
+
+### HF_HUB_DISABLE_EXPERIMENTAL_WARNING
+
+Certaines fonctionnalités de `huggingface_hub` sont expérimentales, cela signfie que vous pouvez les utliiser mais
+nous ne garantissons pas qu'elles seront maintenues plus tard. En particulier, nous mettrons peut-être à jour les
+API ou le comportement de telles fonctionnalités sans aucun cycle de deprecation. Un message d'avertissement sera
+affiché lorsque vous utilisez une fonctionnalités expérimentale pour vous l'indiquer. Si vous n'êtes pas dérangé par
+le fait de devoir debug toute erreur potentielle liée à l'usage d'une fonctionnalité expérimentale, vous pouvez
+définir `HF_HUB_DISABLE_EXPERIMENTAL_WARNING=1` pour désactiver l'avertissement.
+
+Si vous utilisez une fonctoinnalité expérimental, faites le nous savoir! Votre retour peut nous aider à l'améliorer.
+
+### HF_HUB_DISABLE_TELEMETRY
+
+Par défaut, des données sont collectées par les librairies HF (`transformers`, `datasets`, `gradio`,..) pour gérer l'utilisation et les problèmes de débug et pour aider à définir les fonctionnalités prioritaires. Chaque librairie définit sa propre politique (i.e. les cas d'usage sur lesquels les données eront collectées), mais l'implémentation principale se passe dans `huggingface_hub` (consultez [`send_telemetry`]).
+
+Vous pouvez définir `HF_HUB_DISABLE_TELEMETRY=1` en tant que variable d'environnement pour désactiver la télémétrie.
+
+### HF_HUB_ENABLE_HF_TRANSFER
+
+Définissez cette valeur à `True` pour des upload et des téléchargements plus rapides depuis le Hub en utilisant `hf_transfer`.
+
+Par défaut, `huggingface_hub` utilise les fonctions basées sur Python `requests.get` et `requests.post`. Même si ces fonctions sont fiables et assez versatiles, elle pourrait ne pas être le choix le plus efficace pour les machines avec une bande passante large. [`hf_transfer`](https://github.com/huggingface/hf_transfer) est un package basé sur Rust développé pour maximiser la bande passante utilisée en divisant les gros fichier en des parties plus petites et les transférer toutes simultanément en utilisant plusieurs threads. Cette approche peut potentiellement doubler la vitesse de transfert. Pour utiliser `hf_transfer`, vous devez l'installer séparément [de PyPI](https://pypi.org/project/hf-transfer/) et définir `HF_HUB_ENABLE_HF_TRANSFER=1` en tant que variable d'environnement.
+
+N'oubliez pas que l'utilisation d'`hf_transfer` a certaines limitations. Vu qu'elle n'est pas purement basé sur Python, le debug d'erreurs peut s'avérer plus compliqué. De plus, `hf_transfer` n'est pas totues les fonctionnalités user-friendly telles que le téléchargement reprenables et les proxys. Ces omissions sont intentionnelles et permettent de maintenir la simplicité et la vitesse de la logique Rust. Par conséquent, `hf_transfer` n'est pas activée par défaut dans `huggingface_hub`.
+
+## Variables d'environnement deprecated
+
+Afin de standardiser toutes les variables d'environnement dans l'écosystème Hugging Face, certaines variable ont été marquée comme deprecated. Même si elle fonctionnent toujours, elles ne sont plus prioritaires par rapport à leur remplacements. La table suivante liste les variables d'environnement deprecated et leurs alternatives respectives:
+
+
+| Variable deprecated | Alternative |
+| --- | --- |
+| `HUGGINGFACE_HUB_CACHE` | `HF_HUB_CACHE` |
+| `HUGGINGFACE_ASSETS_CACHE` | `HF_ASSETS_CACHE` |
+| `HUGGING_FACE_HUB_TOKEN` | `HF_TOKEN` |
+| `HUGGINGFACE_HUB_VERBOSITY` | `HF_HUB_VERBOSITY` |
+
+## Depuis un outil extérieur
+
+Certaines variables d'environnement ne sont pas spécifiques à `huggingface_hub` mais sont tout de même prises en compte
+lorsqu'elles sont définies.
+
+### NO_COLOR
+
+Valeur booléenne, lorsque définie à `True`, l'outil `huggingface-cli` n'affichera
+aucune couleur ANSI.
+Consultez [no-color.org](https://no-color.org/).
+
+### XDG_CACHE_HOME
+
+Utilisé uniqueemnt si `HF_HOME` n'est pas défini!
+
+C'est la manière par défaut de configurer l'endroit où [les données en cache non essentielles devraient être écrites](https://wiki.archlinux.org/title/XDG_Base_Directory) sur les machines linux.
+
+Si `HF_HOME` n'est pas définie, le chemin par défaut sera `"$XDG_CACHE_HOME/huggingface"`
+aulieu de `"~/.cache/huggingface"`.
diff --git a/docs/source/fr/package_reference/file_download.md b/docs/source/fr/package_reference/file_download.md
new file mode 100644
index 0000000000..97050065c6
--- /dev/null
+++ b/docs/source/fr/package_reference/file_download.md
@@ -0,0 +1,38 @@
+
+
+# Téléchargement des fichiers
+
+## Télécharger un unique fichier
+
+### hf_hub_download
+
+[[autodoc]] huggingface_hub.hf_hub_download
+
+### hf_hub_url
+
+[[autodoc]] huggingface_hub.hf_hub_url
+
+## Télécharger un instantané du dépôt
+
+[[autodoc]] huggingface_hub.snapshot_download
+
+## Obtenir une métadonnée sur un fichier
+
+### get_hf_file_metadata
+
+[[autodoc]] huggingface_hub.get_hf_file_metadata
+
+### HfFileMetadata
+
+[[autodoc]] huggingface_hub.HfFileMetadata
+
+## Utilisation du cache
+
+Le méthodes affichées ci dessus sont faites pour fonctionner avec un système de cache
+ce qui évite de retélécharger des fichiers. Le système de cache a été mis à jour dans
+la version v0.8.0 afin d'être le système de cache central partagé dans toutes les
+librairies dépendant du Hub.
+
+Consultez le [guide cache-system](../guides/manage-cache) pour une présentation détaillée du caching à HF.
\ No newline at end of file
diff --git a/docs/source/fr/package_reference/hf_api.md b/docs/source/fr/package_reference/hf_api.md
new file mode 100644
index 0000000000..8a90e20500
--- /dev/null
+++ b/docs/source/fr/package_reference/hf_api.md
@@ -0,0 +1,135 @@
+
+
+# HfApi Client
+
+Ci dessous la documentation pour la classe `HfApi`, qui sert de wrapper Python pour l'API Hugging Face Hub.
+
+Toutes les méthodes de `HfApi` sont aussi accessibles depuis la racine du package directement. Les deux approches sont détaillées ci-dessous.
+
+Utiliser la méthode du chemin racine est plus direct mais la classe [`HfApi`] donne plus de flexibilité.
+En particulier, vous pouvez mettre un token qui va être réutilisé dans tous les appels HTTP. C'est
+différent de la commande `huggingface-cli login` ou [`login`] vu que le token n'est pas enregistré
+sur la machine. Il est aussi possible de fournir un endpoint différent ou de configurer un user-agent
+personnalisé.
+
+```python
+from huggingface_hub import HfApi, list_models
+
+# Utilisez la méthode du chemin racine
+models = list_models()
+
+# Ou configurez le client HfApi
+hf_api = HfApi(
+ endpoint="https://huggingface.co", # Vous pouvez mettre un endpoint de Hub privéC.
+ token="hf_xxx", # Le token n'est pas sauvegardé sur la machine.
+)
+models = hf_api.list_models()
+```
+
+## HfApi
+
+[[autodoc]] HfApi
+
+[[autodoc]] plan_multi_commits
+
+## API Dataclasses
+
+### CommitInfo
+
+[[autodoc]] huggingface_hub.hf_api.CommitInfo
+
+### DatasetInfo
+
+[[autodoc]] huggingface_hub.hf_api.DatasetInfo
+
+### GitRefInfo
+
+[[autodoc]] huggingface_hub.hf_api.GitRefInfo
+
+### GitCommitInfo
+
+[[autodoc]] huggingface_hub.hf_api.GitCommitInfo
+
+### GitRefs
+
+[[autodoc]] huggingface_hub.hf_api.GitRefs
+
+### ModelInfo
+
+[[autodoc]] huggingface_hub.hf_api.ModelInfo
+
+### RepoSibling
+
+[[autodoc]] huggingface_hub.hf_api.RepoSibling
+
+### RepoFile
+
+[[autodoc]] huggingface_hub.hf_api.RepoFile
+
+### RepoUrl
+
+[[autodoc]] huggingface_hub.hf_api.RepoUrl
+
+### SafetensorsRepoMetadata
+
+[[autodoc]] huggingface_hub.utils.SafetensorsRepoMetadata
+
+### SafetensorsFileMetadata
+
+[[autodoc]] huggingface_hub.utils.SafetensorsFileMetadata
+
+### SpaceInfo
+
+[[autodoc]] huggingface_hub.hf_api.SpaceInfo
+
+### TensorInfo
+
+[[autodoc]] huggingface_hub.utils.TensorInfo
+
+### User
+
+[[autodoc]] huggingface_hub.hf_api.User
+
+### UserLikes
+
+[[autodoc]] huggingface_hub.hf_api.UserLikes
+
+## CommitOperation
+
+Ci dessous les valeurs supportés pour [`CommitOperation`]:
+
+[[autodoc]] CommitOperationAdd
+
+[[autodoc]] CommitOperationDelete
+
+[[autodoc]] CommitOperationCopy
+
+## CommitScheduler
+
+[[autodoc]] CommitScheduler
+
+## Token helper
+
+`huggingface_hub` garde en mémoire l'information d'authentification en local pour qu'il puisse être réutilisé
+dans les méthodes suivantes.
+
+La librairie fait ceci en utilisant l'utilitaire [`HfFolder`], qui sauvegarde de la donnée
+à la racine de l'utilisateur.
+
+[[autodoc]] HfFolder
+
+## Search helpers
+
+Certains helpers pour filtrer les dépôts sur le Hub sont disponibles dans le package
+`huggingface_hub`.
+
+### DatasetFilter
+
+[[autodoc]] DatasetFilter
+
+### ModelFilter
+
+[[autodoc]] ModelFilter
+
diff --git a/docs/source/fr/package_reference/hf_file_system.md b/docs/source/fr/package_reference/hf_file_system.md
new file mode 100644
index 0000000000..e36c6393fa
--- /dev/null
+++ b/docs/source/fr/package_reference/hf_file_system.md
@@ -0,0 +1,16 @@
+
+
+# L'API FileSystem
+
+La classe `HfFileSystem` offre une interface Python pour le Hub Hugging Face basée sur [`fsspec`](https://filesystem-spec.readthedocs.io/en/latest/).
+
+## HfFileSystem
+
+`HfFileSystem` est basé sur [fsspec](https://filesystem-spec.readthedocs.io/en/latest/), donc cette classe est compatible avec la plupart des API offertes par fsspec. Pour plus de détails, consultez [notre guide](../guides/hf_file_system) et les [Références](https://filesystem-spec.readthedocs.io/en/latest/api.html#fsspec.spec.AbstractFileSystem) de l'API fsspec.
+
+[[autodoc]] HfFileSystem
+ - __init__
+ - resolve_path
+ - ls
diff --git a/docs/source/fr/package_reference/inference_client.md b/docs/source/fr/package_reference/inference_client.md
new file mode 100644
index 0000000000..8932918377
--- /dev/null
+++ b/docs/source/fr/package_reference/inference_client.md
@@ -0,0 +1,112 @@
+
+
+# Inférence
+
+L'inférence est le fait d'utiliser un modèle déjà entrainé pour faire des prédictions sur de nouvelles données. Comme ce
+processus peut demander beaucoup de ressources computationnelles, le lancer sur un serveur dédié peut être une option
+intéressante. La librairie `huggingface_hub` offre une manière facile d'appeler un service qui fait de l'inférence pour
+les modèles hébergés. Il y a plusieurs services auxquels vous pouvez vous connecter:
+- [Inference API](https://huggingface.co/docs/api-inference/index): un service qui vous permet de faire des inférences accélérées
+sur l'infrastructure Hugging Face gratuitement. Ce service est une manière rapide de commencer, tester différents modèles et
+créer des premiers prototypes de produits IA.
+-[Inference Endpoints](https://huggingface.co/inference-endpoints): un produit qui permet de déployer facilement des modèles en production.
+L'inférence est assurée par Hugging Face dans l'infrastructure dédiée d'un cloud provider de votre choix.
+
+Ces services peuvent être appelés avec l'objet [`InferenceClient`]. Consultez [ce guide](../guides/inference) pour plus
+d'informations sur le mode d'utilisation.
+
+## Client d'inférence
+
+[[autodoc]] InferenceClient
+
+## Client d'inférence asynchrone
+
+Une version asychrone du client basée sur `asyncio` et `aihttp` est aussi fournie.
+Pour l'utiliser, vous pouvez soit installer `aiohttp` directement ou utiliser l'extra `[inference]`:
+
+```sh
+pip install --upgrade huggingface_hub[inference]
+# or
+# pip install aiohttp
+```
+
+[[autodoc]] AsyncInferenceClient
+
+## InferenceTimeoutError
+
+[[autodoc]] InferenceTimeoutError
+
+## Types retournés
+
+Pour la plupart des tâches, la valeur retournée a un type intégré (string, list, image...). Voici une liste de types plus complexes.
+
+### ClassificationOutput
+
+[[autodoc]] huggingface_hub.inference._types.ClassificationOutput
+
+### ConversationalOutputConversation
+
+[[autodoc]] huggingface_hub.inference._types.ConversationalOutputConversation
+
+### ConversationalOutput
+
+[[autodoc]] huggingface_hub.inference._types.ConversationalOutput
+
+### ImageSegmentationOutput
+
+[[autodoc]] huggingface_hub.inference._types.ImageSegmentationOutput
+
+### ModelStatus
+
+[[autodoc]] huggingface_hub.inference._common.ModelStatus
+
+### TokenClassificationOutput
+
+[[autodoc]] huggingface_hub.inference._types.TokenClassificationOutput
+
+### Types pour la génération de texte
+
+La tâche [`~InferenceClient.text_generation`] a un meilleur support que d'autres tâches dans `InferenceClient`.
+Les inputs des utilisateurs et les outputs des serveurs sont validés en utilisant [Pydantic](https://docs.pydantic.dev/latest/)
+si ce package est installé. Par conséquent, nous vous recommandons de l'installer (`pip install pydantic`) pour
+une meilleure expérience.
+
+Vous pouvez trouver ci-dessous, les dataclasses utilisées pour valider des données et en particulier
+[`~huggingface_hub.inference._text_generation.TextGenerationParameters`] (input)
+[`~huggingface_hub.inference._text_generation.TextGenerationResponse`] (output) et
+[`~huggingface_hub.inference._text_generation.TextGenerationStreamResponse`] (streaming output).
+
+[[autodoc]] huggingface_hub.inference._text_generation.TextGenerationParameters
+
+[[autodoc]] huggingface_hub.inference._text_generation.TextGenerationResponse
+
+[[autodoc]] huggingface_hub.inference._text_generation.TextGenerationStreamResponse
+
+[[autodoc]] huggingface_hub.inference._text_generation.InputToken
+
+[[autodoc]] huggingface_hub.inference._text_generation.Token
+
+[[autodoc]] huggingface_hub.inference._text_generation.FinishReason
+
+[[autodoc]] huggingface_hub.inference._text_generation.BestOfSequence
+
+[[autodoc]] huggingface_hub.inference._text_generation.Details
+
+[[autodoc]] huggingface_hub.inference._text_generation.StreamDetails
+
+## InferenceAPI
+
+[`InferenceAPI`] est la méthode historique pour appeler l'API d'inférence. L'interface est plus simpliste et
+demande une conaissance des paramètres d'entrées et du format de sortie de chacune des tâches. Cette interface
+ne peut pas se connecter à d'autres services tels que Inference Endpoints or AWS SageMaker. [`InferenceAPI`] sera
+bientôt deprecated, ainsi, nous recommendons l'utilisation de [`InferenceClient`] quand c'est possible.
+Consultez [ce guide](../guides/inference#legacy-inferenceapi-client) pour apprendre comment passer
+d'[`InferenceAPI`] à [`InferenceClient`] dans vos scripts.
+
+[[autodoc]] InferenceApi
+ - __init__
+ - __call__
+ - all
+
diff --git a/docs/source/fr/package_reference/inference_endpoints.md b/docs/source/fr/package_reference/inference_endpoints.md
new file mode 100644
index 0000000000..5dd22808c7
--- /dev/null
+++ b/docs/source/fr/package_reference/inference_endpoints.md
@@ -0,0 +1,45 @@
+# Inference Endpoints
+
+Inference Endpoints est une solution permettant de déployer facilement les modèles en production sur une infrastructure gérée par Hugging Face et capable d'autoscaling . Un Inference Endpoint peut être crée sur un modèle depuis le [Hub](https://huggingface.co/models). Cette page est
+une référence pour l'intégration d'`huggingface_hub` avec Inference Endpoints. Pour plus d'informations à propos du produit Inference Endpoints, consultez la [documentation officielle](https://huggingface.co/docs/inference-endpoints/index).
+
+
+
+
+
+Vue d'ensemble
+ Guides pratiques pour vous aider à atteindre un but en particulier. Lisez ces guides pour apprendre comment utiliser huggingface_hub pour résoudre des problèmes concrets.
+ + + +Références
+ Description exhaustive des classes et méthodes présentes dans huggingface_hub.
+ + + +Guides conceptuels
+ Explications permettant d'avoir une meilleure compréhension de la philosophie derrière huggingface_hub.
+ + +