Repository: huggingface/huggingface_hub
Pull request #1646 (2023-09-07 08:37:48)

🌐 [i18n-DE] Translate docs to German
References #1645 

**Key features**

- Translates main `README` to German;
- Translates the main landing docs (`index`, `installation`, `quick-start`) to German;
- Translates the How-To-Guides (`./guides`) to German

HuggingFaceDocBuilderDev: The docs for this PR live [here](https://moon-ci-docs.huggingface.co/docs/huggingface_hub/pr_1646). All of your documentation changes will be reflected on that endpoint.
Wauplin: Gently pinging @patrickvonplaten @philschmid if you have time for a German-docs review :hugs: 
BenjaminBossan: Total unwichtig, aber ich finde "der [Hugging Face] Hub" klingt merkwürdig, ich hätte "das Hub" verwendet. "Der Hub" klingt so wie die Substantivierung von "Heben", also wie singular "Hub", plural "Hübe".

Ich hätte auch eher die Du-Form gewählt als die Sie-Form.
martinbrose: > Total unwichtig, aber ich finde "der [Hugging Face] Hub" klingt merkwürdig, ich hätte "das Hub" verwendet. "Der Hub" klingt so wie die Substantivierung von "Heben", also wie singular "Hub", plural "Hübe".
> 
> Ich hätte auch eher die Du-Form gewählt als die Sie-Form.

Hi @BenjaminBossan,

danke für Dein Feedback!

Ich hatte auch erst bei dem richtigen Artikel für Hub gestutzt.
Aber denke "der Hub" stimmt mit dem Duden überein, welcher dies für zwei Varianten so benutzt:
1. [der Hub als der zentrale Umschlagplatz / der Knotenpunkt](https://www.duden.de/rechtschreibung/Hub_Knotenpunkt)
2. [der Hub als der Digital Hub](https://www.duden.de/rechtschreibung/Digital_Hub)

Bei dem "Du" vs "Sie" habe ich mich an der deutschen Übersetzung der Transformers Bibliothek orientiert: https://huggingface.co/docs/transformers/v4.33.0/de/quicktour
Aber ich ändere es auch gerne zu "Du" falls wir zu dem Konsens kommen.

Viele Grüsse
BenjaminBossan: > Bei dem "Du" vs "Sie" habe ich mich an der deutschen Übersetzung der Transformers Bibliothek orientiert: https://huggingface.co/docs/transformers/v4.33.0/de/quicktour
> Aber ich ändere es auch gerne zu "Du" falls wir zu dem Konsens kommen.

So maybe a more general question to the others: Do we prefer the more formal German "Sie" or the informal German "du"? It's like "vous" vs "tu" in French. The transformers docs use "Sie"  and "vous" but IMHO it sounds very old school and incongruent with the general tone we use.

> Ich hatte auch erst bei dem richtigen Artikel für Hub gestutzt.
> Aber denke "der Hub" stimmt mit dem Duden überein, welcher dies für zwei Varianten so benutzt:

TIL!
Wauplin: Thanks for making the changes @martinbrose ! PR looks almost good to merge for me. Last thing to do, could you update the github workflow files to add "de" as a supported language as describe in https://github.com/huggingface/huggingface_hub/pull/1646#pullrequestreview-1622086609? Thanks in advance!


martinbrose: > Thanks for making the changes @martinbrose ! PR looks almost good to merge for me. Last thing to do, could you update the github workflow files to add "de" as a supported language as describe in [#1646 (review)](https://github.com/huggingface/huggingface_hub/pull/1646#pullrequestreview-1622086609)? Thanks in advance!

Done.
martinbrose: > > So maybe a more general question to the others: Do we prefer the more formal German "Sie" or the informal German "du"? It's like "vous" vs "tu" in French. The transformers docs use "Sie" and "vous" but IMHO it sounds very old school and incongruent with the general tone we use.
> 
> So I went to read French docs in `transformers` (and some Google docs) to get an idea. It feels formal but I'm fine with it TBH. It has more or less the same tone as reading a recipe so I was not shocked by it. I'd say both are fine for me, with a slight preference for keeping the same tone as the existing HF 🇩🇪 docs (so "Sie"?). In any case, it's not that much of a big deal IMO. @martinbrose you've done the work, I trust you to chose whichever you feel the most comfortable with.

Ok, I leave it at "Sie" for now. It's an easy change to "Du" if this is decided further along.
BenjaminBossan: > Ok, I leave it at "Sie" for now. It's an easy change to "Du" if this is decided further along.

This is a good job for an LLM ;-)



Patch:
diff --git a/.github/workflows/build_documentation.yaml b/.github/workflows/build_documentation.yaml
index fa3677b4..4d9684d0 100644
--- a/.github/workflows/build_documentation.yaml
+++ b/.github/workflows/build_documentation.yaml
@@ -13,7 +13,7 @@ jobs:
     with:
       commit_sha: ${{ github.sha }}
       package: huggingface_hub
-      languages: en
+      languages: de en
     secrets:
       token: ${{ secrets.HUGGINGFACE_PUSH }}
       hf_token: ${{ secrets.HF_DOC_BUILD_PUSH }}
\ No newline at end of file
diff --git a/.github/workflows/build_pr_documentation.yaml b/.github/workflows/build_pr_documentation.yaml
index fff49118..0fe1aa38 100644
--- a/.github/workflows/build_pr_documentation.yaml
+++ b/.github/workflows/build_pr_documentation.yaml
@@ -14,4 +14,4 @@ jobs:
       commit_sha: ${{ github.event.pull_request.head.sha }}
       pr_number: ${{ github.event.number }}
       package: huggingface_hub
-      languages: en
\ No newline at end of file
+      languages: de en
\ No newline at end of file
diff --git a/README.md b/README.md
index ce27abf5..5a22c8a9 100644
--- a/README.md
+++ b/README.md
@@ -9,13 +9,19 @@
 </p>
 
 <p align="center">
-    <a href="https://huggingface.co/docs/huggingface_hub/index"><img alt="Documentation" src="https://img.shields.io/website/http/huggingface.co/docs/huggingface_hub/index.svg?down_color=red&down_message=offline&up_message=online&label=doc"></a>
+    <a href="https://huggingface.co/docs/huggingface_hub/en/index"><img alt="Documentation" src="https://img.shields.io/website/http/huggingface.co/docs/huggingface_hub/index.svg?down_color=red&down_message=offline&up_message=online&label=doc"></a>
     <a href="https://github.com/huggingface/huggingface_hub/releases"><img alt="GitHub release" src="https://img.shields.io/github/release/huggingface/huggingface_hub.svg"></a>
     <a href="https://github.com/huggingface/huggingface_hub"><img alt="PyPi version" src="https://img.shields.io/pypi/pyversions/huggingface_hub.svg"></a>
     <a href="https://pypi.org/project/huggingface-hub"><img alt="downloads" src="https://static.pepy.tech/badge/huggingface_hub/month"></a>
     <a href="https://codecov.io/gh/huggingface/huggingface_hub"><img alt="Code coverage" src="https://codecov.io/gh/huggingface/huggingface_hub/branch/main/graph/badge.svg?token=RXP95LE2XL"></a>
 </p>
 
+<h4 align="center">
+    <p>
+        <b>English</b> |
+        <a href="https://github.com/huggingface/huggingface_hub/blob/main/README_de.md">Deutsch</a>
+    <p>
+</h4>
 ---
 
 **Documentation**: <a href="https://hf.co/docs/huggingface_hub" target="_blank">https://hf.co/docs/huggingface_hub</a>
@@ -30,13 +36,13 @@ The `huggingface_hub` library allows you to interact with the [Hugging Face Hub]
 
 ## Key features
 
-- [Download files](https://huggingface.co/docs/huggingface_hub/guides/download) from the Hub.
-- [Upload files](https://huggingface.co/docs/huggingface_hub/guides/upload) to the Hub.
-- [Manage your repositories](https://huggingface.co/docs/huggingface_hub/guides/repository).
-- [Run Inference](https://huggingface.co/docs/huggingface_hub/guides/inference) on deployed models.
-- [Search](https://huggingface.co/docs/huggingface_hub/guides/search) for models, datasets and Spaces.
-- [Share Model Cards](https://huggingface.co/docs/huggingface_hub/main/en/guides/model-cards) to document your models.
-- [Engage with the community](https://huggingface.co/docs/huggingface_hub/guides/community) through PRs and comments.
+- [Download files](https://huggingface.co/docs/huggingface_hub/en/guides/download) from the Hub.
+- [Upload files](https://huggingface.co/docs/huggingface_hub/en/guides/upload) to the Hub.
+- [Manage your repositories](https://huggingface.co/docs/huggingface_hub/en/guides/repository).
+- [Run Inference](https://huggingface.co/docs/huggingface_hub/en/guides/inference) on deployed models.
+- [Search](https://huggingface.co/docs/huggingface_hub/en/guides/search) for models, datasets and Spaces.
+- [Share Model Cards](https://huggingface.co/docs/huggingface_hub/en/guides/model-cards) to document your models.
+- [Engage with the community](https://huggingface.co/docs/huggingface_hub/en/guides/community) through PRs and comments.
 
 ## Installation
 
@@ -46,7 +52,7 @@ Install the `huggingface_hub` package with [pip](https://pypi.org/project/huggin
 pip install huggingface_hub
 ```
 
-If you prefer, you can also install it with [conda](https://huggingface.co/docs/huggingface_hub/installation#install-with-conda).
+If you prefer, you can also install it with [conda](https://huggingface.co/docs/huggingface_hub/en/installation#install-with-conda).
 
 In order to keep the package minimal by default, `huggingface_hub` comes with optional dependencies useful for some use cases. For example, if you want have a complete experience for Inference, run:
 
@@ -54,7 +60,7 @@ In order to keep the package minimal by default, `huggingface_hub` comes with op
 pip install huggingface_hub[inference]
 ```
 
-To learn more installation and optional dependencies, check out the [installation guide](https://huggingface.co/docs/huggingface_hub/installation).
+To learn more installation and optional dependencies, check out the [installation guide](https://huggingface.co/docs/huggingface_hub/en/installation).
 
 ## Quick start
 
@@ -76,7 +82,7 @@ from huggingface_hub import snapshot_download
 snapshot_download("stabilityai/stable-diffusion-2-1")
 ```
 
-Files will be downloaded in a local cache folder. More details in [this guide](https://huggingface.co/docs/huggingface_hub/guides/manage-cache).
+Files will be downloaded in a local cache folder. More details in [this guide](https://huggingface.co/docs/huggingface_hub/en/guides/manage-cache).
 
 ### Login
 
@@ -122,7 +128,7 @@ upload_folder(
 )
 ```
 
-For details in the [upload guide](https://huggingface.co/docs/huggingface_hub/guides/upload).
+For details in the [upload guide](https://huggingface.co/docs/huggingface_hub/en/guides/upload).
 
 ## Integrating to the Hub.
 
diff --git a/README_de.md b/README_de.md
new file mode 100644
index 00000000..73cb0021
--- /dev/null
+++ b/README_de.md
@@ -0,0 +1,151 @@
+<p align="center">
+  <br/>
+    <img alt="huggingface_hub library logo" src="https://huggingface.co/datasets/huggingface/documentation-images/raw/main/huggingface_hub.svg" width="376" height="59" style="max-width: 100%;">
+  <br/>
+</p>
+
+<p align="center">
+    <i>Der offizielle Python-Client für den Huggingface Hub.</i>
+</p>
+
+<p align="center">
+    <a href="https://huggingface.co/docs/huggingface_hub/de/index"><img alt="Dokumentation" src="https://img.shields.io/website/http/huggingface.co/docs/huggingface_hub/index.svg?down_color=red&down_message=offline&up_message=online&label=doc"></a>
+    <a href="https://github.com/huggingface/huggingface_hub/releases"><img alt="GitHub release" src="https://img.shields.io/github/release/huggingface/huggingface_hub.svg"></a>
+    <a href="https://github.com/huggingface/huggingface_hub"><img alt="PyPi version" src="https://img.shields.io/pypi/pyversions/huggingface_hub.svg"></a>
+    <a href="https://pypi.org/project/huggingface-hub"><img alt="downloads" src="https://static.pepy.tech/badge/huggingface_hub/month"></a>
+    <a href="https://codecov.io/gh/huggingface/huggingface_hub"><img alt="Code coverage" src="https://codecov.io/gh/huggingface/huggingface_hub/branch/main/graph/badge.svg?token=RXP95LE2XL"></a>
+</p>
+
+<h4 align="center">
+    <p>
+        <a href="https://github.com/huggingface/huggingface_hub/blob/main/README.md">English</a>  |
+        <b>Deutsch</b>
+    <p>
+</h4>
+---
+
+**Dokumentation**: <a href="https://hf.co/docs/huggingface_hub" target="_blank">https://hf.co/docs/huggingface_hub</a>
+
+**Quellcode**: <a href="https://github.com/huggingface/huggingface_hub" target="_blank">https://github.com/huggingface/huggingface_hub</a>
+
+---
+
+## Willkommen bei der huggingface_hub Bibliothek
+
+Die `huggingface_hub` Bibliothek ermöglicht Ihnen die Interaktion mit dem [Hugging Face Hub](https://huggingface.co/), einer Plattform, die Open-Source Machine Learning für Entwickler und Mitwirkende demokratisiert. Entdecken Sie vortrainierte Modelle und Datensätze für Ihre Projekte oder spielen Sie mit den Tausenden von Machine-Learning-Apps, die auf dem Hub gehostet werden. Sie können auch Ihre eigenen Modelle, Datensätze und Demos mit der Community teilen. Die `huggingface_hub` Bibliothek bietet eine einfache Möglichkeit, all dies mit Python zu tun.
+
+## Hauptmerkmale
+
+- Dateien vom Hub [herunterladen](https://huggingface.co/docs/huggingface_hub/de/guides/download).
+- Dateien auf den Hub [hochladen](https://huggingface.co/docs/huggingface_hub/de/guides/upload).
+- [Verwalten Ihrer Repositories](https://huggingface.co/docs/huggingface_hub/de/guides/repository).
+- [Ausführen von Inferenz](https://huggingface.co/docs/huggingface_hub/de/guides/inference) auf bereitgestellten Modellen.
+- [Suche](https://huggingface.co/docs/huggingface_hub/de/guides/search) nach Modellen, Datensätzen und Spaces.
+- [Model Cards teilen](https://huggingface.co/docs/huggingface_hub/de/guides/model-cards), um Ihre Modelle zu dokumentieren.
+- [Mit der Community interagieren](https://huggingface.co/docs/huggingface_hub/de/guides/community), durch PRs und Kommentare.
+
+## Installation
+
+Installieren Sie das `huggingface_hub` Paket mit [pip](https://pypi.org/project/huggingface-hub/):
+
+```bash
+pip install huggingface_hub
+```
+
+Wenn Sie möchten, können Sie es auch mit [conda](https://huggingface.co/docs/huggingface_hub/de/installation#installieren-mit-conda) installieren.
+
+Um das Paket standardmäßig minimal zu halten, kommt `huggingface_hub` mit optionalen Abhängigkeiten, die für einige Anwendungsfälle nützlich sind. Zum Beispiel, wenn Sie ein vollständiges Erlebnis für Inferenz möchten, führen Sie den folgenden Befehl aus:
+
+```bash
+pip install huggingface_hub[inference]
+```
+
+Um mehr über die Installation und optionale Abhängigkeiten zu erfahren, sehen Sie sich bitte den [Installationsleitfaden](https://huggingface.co/docs/huggingface_hub/de/installation) an.
+
+## Schnellstart
+
+### Dateien herunterladen
+
+Eine einzelne Datei herunterladen
+
+```py
+from huggingface_hub import hf_hub_download
+
+hf_hub_download(repo_id="tiiuae/falcon-7b-instruct", filename="config.json")
+```
+
+Oder eine gesamte Repository
+
+```py
+from huggingface_hub import snapshot_download
+
+snapshot_download("stabilityai/stable-diffusion-2-1")
+```
+
+Dateien werden in einen lokalen Cache-Ordner heruntergeladen. Weitere Details finden Sie in diesem [Leitfaden](https://huggingface.co/docs/huggingface_hub/de/guides/manage-cache).
+
+### Anmeldung
+
+Der Hugging Face Hub verwendet Tokens zur Authentifizierung von Anwendungen (siehe [Dokumentation](https://huggingface.co/docs/hub/security-tokens)). Um sich an Ihrem Computer anzumelden, führen Sie das folgende Kommando in der Befehlszeile aus:
+
+```bash
+huggingface-cli login
+# oder mit einer Umgebungsvariablen
+huggingface-cli login --token $HUGGINGFACE_TOKEN
+```
+
+### Eine Repository erstellen
+
+```py
+from huggingface_hub import create_repo
+
+create_repo(repo_id="super-cool-model")
+```
+
+### Dateien hochladen
+
+Eine einzelne Datei hochladen
+
+```py
+from huggingface_hub import upload_file
+
+upload_file(
+    path_or_fileobj="/home/lysandre/dummy-test/README.md",
+    path_in_repo="README.md",
+    repo_id="lysandre/test-model",
+)
+```
+
+Oder einen gesamten Ordner
+
+```py
+from huggingface_hub import upload_folder
+
+upload_folder(
+    folder_path="/path/to/local/space",
+    repo_id="username/my-cool-space",
+    repo_type="space",
+)
+```
+
+Weitere Informationen finden Sie im [Upload-Leitfaden](https://huggingface.co/docs/huggingface_hub/de/guides/upload).
+
+## Integration in den Hub
+
+Wir arbeiten mit coolen Open-Source-ML-Bibliotheken zusammen, um kostenloses Model-Hosting und -Versionierung anzubieten. Die bestehenden Integrationen finden Sie [hier](https://huggingface.co/docs/hub/libraries).
+
+Die Vorteile sind:
+
+- Kostenloses Hosting von Modellen oder Datensätzen für Bibliotheken und deren Benutzer..
+- Eingebaute Dateiversionierung, selbst bei sehr großen Dateien, dank eines git-basierten Ansatzes.
+- Bereitgestellte Inferenz-API für alle öffentlich verfügbaren Modelle.
+- In-Browser-Widgets zum Spielen mit den hochgeladenen Modellen.
+- Jeder kann ein neues Modell für Ihre Bibliothek hochladen, es muss nur das entsprechende Tag hinzugefügt werden, damit das Modell auffindbar ist.
+- Schnelle Downloads! Wir verwenden Cloudfront (ein CDN), um Downloads zu geo-replizieren, sodass sie von überall auf der Welt blitzschnell sind.
+- Nutzungsstatistiken und mehr Funktionen in Kürze.
+
+Wenn Sie Ihre Bibliothek integrieren möchten, öffnen Sie gerne ein Issue, um die Diskussion zu beginnen. Wir haben mit ❤️ einen [schrittweisen Leitfaden](https://huggingface.co/docs/hub/adding-a-library) geschrieben, der zeigt, wie diese Integration durchgeführt wird.
+
+## Beiträge (Feature-Anfragen, Fehler usw.) sind super willkommen 💙💚💛💜🧡❤️
+
+Jeder ist willkommen beizutragen, und wir schätzen den Beitrag jedes Einzelnen. Code zu schreiben ist nicht der einzige Weg, der Community zu helfen. Fragen zu beantworten, anderen zu helfen, sich zu vernetzen und die Dokumentationen zu verbessern, sind für die Gemeinschaft von unschätzbarem Wert. Wir haben einen [Beitrags-Leitfaden](https://github.com/huggingface/huggingface_hub/blob/main/CONTRIBUTING.md) geschrieben, der zusammenfasst, wie Sie beginnen können, zu dieser Repository beizutragen.
\ No newline at end of file
diff --git a/docs/source/de/_toctree.yml b/docs/source/de/_toctree.yml
new file mode 100644
index 00000000..83f91113
--- /dev/null
+++ b/docs/source/de/_toctree.yml
@@ -0,0 +1,36 @@
+- title: "Starten"
+  sections:
+    - local: index
+      title: Home
+    - local: quick-start
+      title: Kurzanleitung
+    - local: installation
+      title: Installation
+- title: "Anleitungen"
+  sections:
+    - local: guides/overview
+      title: Übersicht
+    - local: guides/download
+      title: Dateien herunterladen
+    - local: guides/upload
+      title: Dateien hochladen
+    - local: guides/hf_file_system
+      title: HfFileSystem
+    - local: guides/repository
+      title: Repository
+    - local: guides/search
+      title: Suche
+    - local: guides/inference
+      title: Inferenz
+    - local: guides/community
+      title: Community-Tab
+    - local: guides/manage-cache
+      title: Cache
+    - local: guides/model-cards
+      title: Model Cards
+    - local: guides/manage-spaces
+      title: Verwalten Ihres Spaces
+    - local: guides/integrations
+      title: Integrieren einer Bibliothek
+    - local: guides/webhooks_server
+      title: Webhooks server
\ No newline at end of file
diff --git a/docs/source/de/guides/community.md b/docs/source/de/guides/community.md
new file mode 100644
index 00000000..bfb47164
--- /dev/null
+++ b/docs/source/de/guides/community.md
@@ -0,0 +1,122 @@
+<!--⚠️ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
+rendered properly in your Markdown viewer.
+-->
+
+# Interaktion mit Diskussionen und Pull-Requests
+
+Die `huggingface_hub`-Bibliothek bietet eine Python-Schnittstelle, um mit Pull-Requests und Diskussionen auf dem Hub zu interagieren. Besuchen Sie [die spezielle Dokumentationsseite](https://huggingface.co/docs/hub/repositories-pull-requests-discussions), um einen tieferen Einblick in Diskussionen und Pull-Requests auf dem Hub zu erhalten und zu erfahren, wie sie im Hintergrund funktionieren.
+
+## Diskussionen und Pull-Requests vom Hub abrufen
+
+Die Klasse `HfApi` ermöglicht es Ihnen, Diskussionen und Pull-Requests zu einem gegebenen Repository abzurufen:
+
+```python
+>>> from huggingface_hub import get_repo_discussions
+>>> for discussion in get_repo_discussions(repo_id="bigscience/bloom-1b3"):
+...     print(f"{discussion.num} - {discussion.title}, pr: {discussion.is_pull_request}")
+
+# 11 - Add Flax weights, pr: True
+# 10 - Update README.md, pr: True
+# 9 - Training languages in the model card, pr: True
+# 8 - Update tokenizer_config.json, pr: True
+# 7 - Slurm training script, pr: False
+[...]
+```
+
+`HfApi.get_repo_discussions` gibt einen [Generator](https://docs.python.org/3.7/howto/functional.html#generators) zurück, der [`Diskussion`]-Objekte liefert. Um alle Diskussionen in einer einzelnen Liste zu erhalten, führen Sie den folgenden Befehl aus:
+
+```python
+>>> from huggingface_hub import get_repo_discussions
+>>> discussions_list = list(get_repo_discussions(repo_id="bert-base-uncased"))
+```
+
+Das von [`HfApi.get_repo_discussions`] zurückgegebene [`Diskussion`]-Objekt enthält einen Überblick über die Diskussion oder Pull-Requests. Sie können auch detailliertere Informationen mit [`HfApi.get_discussion_details`] abrufen:
+
+```python
+>>> from huggingface_hub import get_discussion_details
+
+>>> get_discussion_details(
+...     repo_id="bigscience/bloom-1b3",
+...     discussion_num=2
+... )
+DiscussionWithDetails(
+    num=2,
+    author='cakiki',
+    title='Update VRAM memory for the V100s',
+    status='open',
+    is_pull_request=True,
+    events=[
+        DiscussionComment(type='comment', author='cakiki', ...),
+        DiscussionCommit(type='commit', author='cakiki', summary='Update VRAM memory for the V100s', oid='1256f9d9a33fa8887e1c1bf0e09b4713da96773a', ...),
+    ],
+    conflicting_files=[],
+    target_branch='refs/heads/main',
+    merge_commit_oid=None,
+    diff='diff --git a/README.md b/README.md\nindex a6ae3b9294edf8d0eda0d67c7780a10241242a7e..3a1814f212bc3f0d3cc8f74bdbd316de4ae7b9e3 100644\n--- a/README.md\n+++ b/README.md\n@@ -132,7 +132,7 [...]',
+)
+```
+
+[`HfApi.get_discussion_details`] gibt ein [`DiskussionMitDetails`]-Objekt zurück, das eine Unterklasse von [`Diskussion`] mit detaillierteren Informationen über die Diskussion oder Pull-Requests ist. Informationen beinhalten alle Kommentare, Statusänderungen und Umbenennungen der Diskussion mittels [`DiskussionMitDetails.events`].
+
+Im Fall eines Pull-Requests können Sie mit [`DiskussionMitDetails.diff`] den rohen git diff abrufen. Alle Commits des Pull-Requests sind in [`DiskussionMitDetails.events`] aufgelistet.
+
+
+## Diskussion oder Pull-Request programmatisch erstellen und bearbeiten
+
+Die [`HfApi`]-Klasse bietet auch Möglichkeiten, Diskussionen und Pull-Requests zu erstellen und zu bearbeiten. Sie benötigen ein [Access Token](https://huggingface.co/docs/hub/security-tokens), um Diskussionen oder Pull-Requests zu erstellen und zu bearbeiten.
+
+Die einfachste Möglichkeit, Änderungen an einem Repo auf dem Hub vorzuschlagen, ist über die [`create_commit`]-API: Setzen Sie einfach das `create_pr`-Parameter auf `True`. Dieser Parameter ist auch bei anderen Methoden verfügbar, die [`create_commit`] umfassen:
+
+    * [`upload_file`]
+    * [`upload_folder`]
+    * [`delete_file`]
+    * [`delete_folder`]
+    * [`metadata_update`]
+
+```python
+>>> from huggingface_hub import metadata_update
+
+>>> metadata_update(
+...     repo_id="username/repo_name",
+...     metadata={"tags": ["computer-vision", "awesome-model"]},
+...     create_pr=True,
+... )
+```
+
+Sie können auch [`HfApi.create_discussion`] (bzw. [`HfApi.create_pull_request`]) verwenden, um eine Diskussion (bzw. einen Pull-Request) für ein Repository zu erstellen. Das Öffnen eines Pull-Requests auf diese Weise kann nützlich sein, wenn Sie lokal an Änderungen arbeiten müssen. Auf diese Weise geöffnete Pull-Requests befinden sich im `"Entwurfs"`-Modus.
+
+```python
+>>> from huggingface_hub import create_discussion, create_pull_request
+
+>>> create_discussion(
+...     repo_id="username/repo-name",
+...     title="Hi from the huggingface_hub library!",
+...     token="<insert your access token here>",
+... )
+DiscussionWithDetails(...)
+
+>>> create_pull_request(
+...     repo_id="username/repo-name",
+...     title="Hi from the huggingface_hub library!",
+...     token="<insert your access token here>",
+... )
+DiscussionWithDetails(..., is_pull_request=True)
+```
+
+Das Verwalten von Pull-Requests und Diskussionen kann vollständig mit der [`HfApi`]-Klasse durchgeführt werden. Zum Beispiel:
+
+    * [`comment_discussion`] zum Hinzufügen von Kommentaren
+    * [`edit_discussion_comment`] zum Bearbeiten von Kommentaren
+    * [`rename_discussion`] zum Umbenennen einer Diskussion oder eines Pull-Requests 
+    * [`change_discussion_status`] zum Öffnen oder Schließen einer Diskussion / eines Pull-Requests
+    * [`merge_pull_request`] zum Zusammenführen eines Pull-Requests 
+
+Besuchen Sie die [`HfApi`]-Dokumentationsseite für eine vollständige Übersicht aller verfügbaren Methoden.
+
+## Änderungen an einen Pull-Request senden
+
+*Demnächst verfügbar !*
+
+## Siehe auch
+
+Für eine detailliertere Referenz besuchen Sie die [Diskussionen und Pull-Requests](../package_reference/community) und die [hf_api](../package_reference/hf_api)-Dokumentationen.
\ No newline at end of file
diff --git a/docs/source/de/guides/download.md b/docs/source/de/guides/download.md
new file mode 100644
index 00000000..7d47c323
--- /dev/null
+++ b/docs/source/de/guides/download.md
@@ -0,0 +1,195 @@
+<!--⚠️ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
+rendered properly in your Markdown viewer.
+-->
+
+# Dateien aus dem Hub herunterladen
+
+Die `huggingface_hub`-Bibliothek bietet Funktionen zum Herunterladen von Dateien aus den auf dem Hub gespeicherten Repositories. Sie können diese Funktionen unabhängig verwenden oder in Ihre eigene Bibliothek integrieren, um es Ihren Benutzern zu erleichtern, mit dem Hub zu interagieren. In diesem Leitfaden erfahren Sie, wie Sie:
+
+* Einzelne Dateien herunterladen und zwischenspeichern.
+* Ein gesamtes Repository herunterladen und zwischenspeichern.
+* Dateien in einen lokalen Ordner herunterladen.
+
+## Einzelne Dateien herunterladen
+
+Die [`hf_hub_download`]-Funktion ist die Hauptfunktion zum Herunterladen von Dateien aus dem Hub. Sie lädt die Remote-Datei herunter, speichert sie auf der Festplatte (auf eine versionsbewusste Art und Weise) und gibt ihren lokalen Dateipfad zurück.
+
+<Tip>
+
+Der zurückgegebene Dateipfad verweist auf den lokalen Cache von HF. Es ist daher wichtig, die Datei nicht zu ändern, um einen beschädigten Cache zu vermeiden. Wenn Sie mehr darüber erfahren möchten, wie Dateien zwischengespeichert werden, lesen Sie bitte unseren [Caching-Leitfaden](./manage-cache).
+
+</Tip>
+
+### Von der neuesten Version
+
+Wählen Sie die Datei zum Herunterladen anhand der Parameter `repo_id`, `repo_type` und `filename` aus. Standardmäßig wird davon ausgegangen, dass die Datei Teil einer `model`-Repository ist.
+
+```python
+>>> from huggingface_hub import hf_hub_download
+>>> hf_hub_download(repo_id="lysandre/arxiv-nlp", filename="config.json")
+'/root/.cache/huggingface/hub/models--lysandre--arxiv-nlp/snapshots/894a9adde21d9a3e3843e6d5aeaaf01875c7fade/config.json'
+
+# Herunterladen von einem Dataset
+>>> hf_hub_download(repo_id="google/fleurs", filename="fleurs.py", repo_type="dataset")
+'/root/.cache/huggingface/hub/datasets--google--fleurs/snapshots/199e4ae37915137c555b1765c01477c216287d34/fleurs.py'
+```
+
+### Von einer spezifischen Version
+
+Standardmäßig wird die neueste Version vom Hauptzweig `main` heruntergeladen. In einigen Fällen möchten Sie jedoch eine Datei in einer bestimmten Version herunterladen (z. B. aus einem bestimmten Zweig, einem PR, einem Tag oder einem Commit-Hash). Verwenden Sie dazu den Parameter `revision`:
+
+```python
+# Herunterladen vom Tag `v1.0`
+>>> hf_hub_download(repo_id="lysandre/arxiv-nlp", filename="config.json", revision="v1.0")
+
+# Herunterladen vom Zweig `test-branch`
+>>> hf_hub_download(repo_id="lysandre/arxiv-nlp", filename="config.json", revision="test-branch")
+
+# Herunterladen von Pull Request #3
+>>> hf_hub_download(repo_id="lysandre/arxiv-nlp", filename="config.json", revision="refs/pr/3")
+
+# Herunterladen von einem spezifischen Commit-Hash
+>>> hf_hub_download(repo_id="lysandre/arxiv-nlp", filename="config.json", revision="877b84a8f93f2d619faa2a6e514a32beef88ab0a")
+```
+
+**Hinweis:** Bei Verwendung des Commit-Hashs muss der vollständige Hash anstelle eines 7-Zeichen-Commit-Hashs verwendet werden.
+
+### URL zum Herunterladen erstellen
+
+Falls Sie die URL erstellen möchten, die zum Herunterladen einer Datei aus einem Repo verwendet wird, können Sie [`hf_hub_url`] verwenden, das eine URL zurückgibt. Beachten Sie, dass es intern von [`hf_hub_download`] verwendet wird.
+
+## Gesamte Repository herunterladen
+
+[`snapshot_download`] lädt ein gesamtes Repository zu einer bestimmten Revision herunter. Es verwendet intern [`hf_hub_download`], was bedeutet, dass alle heruntergeladenen Dateien auch auf Ihrer lokalen Festplatte zwischengespeichert werden. Die Downloads werden gleichzeitig durchgeführt, um den Prozess zu beschleunigen.
+
+Um ein ganzes Repository herunterzuladen, geben Sie einfach die `repo_id` und `repo_type` an:
+
+```python
+>>> from huggingface_hub import snapshot_download
+>>> snapshot_download(repo_id="lysandre/arxiv-nlp")
+'/home/lysandre/.cache/huggingface/hub/models--lysandre--arxiv-nlp/snapshots/894a9adde21d9a3e3843e6d5aeaaf01875c7fade'
+
+# Oder von einem Dataset
+>>> snapshot_download(repo_id="google/fleurs", repo_type="dataset")
+'/home/lysandre/.cache/huggingface/hub/datasets--google--fleurs/snapshots/199e4ae37915137c555b1765c01477c216287d34'
+```
+
+[`snapshot_download`] lädt standardmäßig die neueste Revision herunter. Wenn Sie eine spezifische Repository-Revision wünschen, verwenden Sie den Parameter `revision`:
+
+```python
+>>> from huggingface_hub import snapshot_download
+>>> snapshot_download(repo_id="lysandre/arxiv-nlp", revision="refs/pr/1")
+```
+
+### Dateien filtern zum Herunterladen
+
+[`snapshot_download`] bietet eine einfache Möglichkeit, ein Repository herunterzuladen. Sie möchten jedoch nicht immer den gesamten Inhalt eines Repositories herunterladen. Beispielsweise möchten Sie möglicherweise verhindern, dass alle `.bin`-Dateien heruntergeladen werden, wenn Sie wissen, dass Sie nur die `.safetensors`-Gewichtungen verwenden werden. Dies können Sie mit den Parametern `allow_patterns` und `ignore_patterns` tun.
+
+Diese Parameter akzeptieren entweder ein einzelnes Muster oder eine Liste von Mustern. Muster sind Standard-Wildcards (globbing patterns) wie [hier](https://tldp.org/LDP/GNU-Linux-Tools-Summary/html/x11655.htm) dokumentiert. Die Mustervergleichung basiert auf [`fnmatch`](https://docs.python.org/3/library/fnmatch.html).
+
+Beispielsweise können Sie `allow_patterns` verwenden, um nur JSON-Konfigurationsdateien herunterzuladen:
+
+```python
+>>> from huggingface_hub import snapshot_download
+>>> snapshot_download(repo_id="lysandre/arxiv-nlp", allow_patterns="*.json")
+```
+
+Andererseits können Sie mit `ignore_patterns` bestimmte Dateien vom Herunterladen ausschließen. Im folgenden Beispiel werden die Dateierweiterungen `.msgpack` und `.h5` ignoriert:
+
+```python
+>>> from huggingface_hub import snapshot_download
+>>> snapshot_download(repo_id="lysandre/arxiv-nlp", ignore_patterns=["*.msgpack", "*.h5"])
+```
+
+Schließlich können Sie beide kombinieren, um Ihren Download genau zu filtern. Hier ist ein Beispiel, wie man alle json- und markdown-Dateien herunterlädt, außer `vocab.json`.
+
+```python
+>>> from huggingface_hub import snapshot_download
+>>> snapshot_download(repo_id="gpt2", allow_patterns=["*.md", "*.json"], ignore_patterns="vocab.json")
+```
+
+## Datei(en) in lokalen Ordner herunterladen
+
+Die empfohlene (und standardmäßige) Methode zum Herunterladen von Dateien aus dem Hub besteht darin, das [Cache-System](./manage-cache) zu verwenden. Sie können Ihren Cache-Ort festlegen, indem Sie den `cache_dir`-Parameter setzen (sowohl in [`hf_hub_download`] als auch in [`snapshot_download`]).
+
+In einigen Fällen möchten Sie jedoch Dateien herunterladen und in einen bestimmten Ordner verschieben. Dies ist nützlich, um einen Workflow zu erhalten, der den `git`-Befehlen ähnelt. Sie können dies mit den Parametern `local_dir` und `local_dir_use_symlinks` tun:
+
+- local_dir muss ein Pfad zu einem Ordner auf Ihrem System sein. Die heruntergeladenen Dateien behalten dieselbe Dateistruktur wie im Repository. Wenn zum Beispiel `filename="data/train.csv"` und `local_dir="pfad/zum/ordner"` ist, wird der zurückgegebene Dateipfad `"pfad/zum/ordner/data/train.csv"` sein.
+- `local_dir_use_symlinks` definiert, wie die Datei in Ihrem lokalen Ordner gespeichert werden muss.
+  - Das Standardverhalten (`"auto"`) besteht darin, kleine Dateien (<5MB) zu duplizieren und für größere Dateien Symlinks zu verwenden. Symlinks ermöglichen 
+    die Optimierung von Bandbreite und Speicherplatz. Das manuelle Bearbeiten einer verlinkten Datei könnte jedoch den Cache beschädigen, daher die Duplizierung für kleine Dateien. Die 5-MB-Schwelle kann mit der `HF_HUB_LOCAL_DIR_AUTO_SYMLINK_THRESHOLD`-Umgebungsvariable konfiguriert werden.
+  - Wenn `local_dir_use_symlinks=True` gesetzt ist, werden alle Dateien verlinkt, um den Speicherplatz optimal zu nutzen. Dies ist zum Beispiel nützlich, wenn ein riesiges Dataset mit Tausenden von kleinen Dateien heruntergeladen wird.
+  - Wenn Sie überhaupt keine Symlinks möchten, können Sie sie deaktivieren (`local_dir_use_symlinks=False`). Das Cache-Verzeichnis wird weiterhin verwendet, um zu überprüfen, ob die Datei bereits im Cache ist oder nicht. Wenn sie bereits im Cache ist, wird die Datei aus dem Cache **dupliziert** (d.h. Bandbreite wird gespart, aber der Speicherplatzverbrauch steigt). Wenn die Datei noch nicht im Cache ist, wird sie heruntergeladen und direkt in das lokale Verzeichnis verschoben. Das bedeutet, dass wenn Sie sie später woanders wiederverwenden müssen, sie **erneut heruntergeladen** wird.
+
+Hier ist eine Tabelle, die die verschiedenen Optionen zusammenfasst, um Ihnen zu helfen, die Parameter zu wählen, die am besten zu Ihrem Anwendungsfall passen.
+
+<!-- Generated with https://www.tablesgenerator.com/markdown_tables -->
+| Parameter | Datei schon im Cache | Zurückgegebener Pfad | Pfad lesbar? | Kann im Pfad speichern? | Optimierter Datendurchsatz | Optimierter Speicherplatz |
+|---|:---:|:---:|:---:|:---:|:---:|:---:|
+| `local_dir=None` |  | Symlink im Cache | ✅ | ❌<br>_(Speichern würde den Cache beschädigen)_ | ✅ | ✅ |
+| `local_dir="path/to/folder"`<br>`local_dir_use_symlinks="auto"` |  | Datei oder Symlink im Ordner | ✅ | ✅ _(für kleine Dateien)_ <br> ⚠️ _(für große Dateien den Pfad nicht auflösen vor dem Speichern)_ | ✅ | ✅ |
+| `local_dir="path/to/folder"`<br>`local_dir_use_symlinks=True` |  | Symlink im Ordner | ✅ | ⚠️<br>_(den Pfad nicht auflösen vor dem Speichern)_ | ✅ | ✅ |
+| `local_dir="path/to/folder"`<br>`local_dir_use_symlinks=False` | Nein | Datei im Ordner | ✅ | ✅ | ❌<br>_(bei erneutem Ausführen wird die Datei erneut heruntergeladen)_ | ⚠️<br>(mehrere Kopien, wenn in mehreren Ordnern ausgeführt) |
+| `local_dir="path/to/folder"`<br>`local_dir_use_symlinks=False` | Ja | Datei im Ordner | ✅ | ✅ | ⚠️<br>_(Datei muss zuerst im Cache gespeichert werden)_ | ❌<br>_(Datei wird dupliziert)_ |
+
+**Hinweis**: Wenn Sie einen Windows-Computer verwenden, müssen Sie den Entwicklermodus aktivieren oder `huggingface_hub` als Administrator ausführen, um Symlinks zu aktivieren. Weitere Details finden Sie im Abschnitt über [Cache-Beschränkungen](../guides/manage-cache#limitations).
+
+## Herunterladen mit dem CLI
+
+Sie können den `huggingface-cli download`-Befehl im Terminal verwenden, um Dateien direkt aus dem Hub herunterzuladen. Intern verwendet es die gleichen [`hf_hub_download`] und [`snapshot_download`] Helfer, die oben beschrieben wurden, und gibt den zurückgegebenen Pfad im Terminal aus:
+
+```bash
+>>> huggingface-cli download gpt2 config.json
+/home/wauplin/.cache/huggingface/hub/models--gpt2/snapshots/11c5a3d5811f50298f278a704980280950aedb10/config.json
+```
+
+Standardmäßig wird das lokal gespeicherte Token (mit `huggingface-cli login`) verwendet. Wenn Sie sich ausdrücklich authentifizieren möchten, verwenden Sie die `--token` Option:
+
+```bash
+>>> huggingface-cli download gpt2 config.json --token=hf_****
+/home/wauplin/.cache/huggingface/hub/models--gpt2/snapshots/11c5a3d5811f50298f278a704980280950aedb10/config.json
+```
+
+Sie können mehrere Dateien gleichzeitig herunterladen, wobei eine Fortschrittsleiste angezeigt wird und der Snapshot-Pfad zurückgegeben wird, in dem sich die Dateien befinden:
+
+```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
+```
+
+Wenn Sie die Fortschrittsleisten und mögliche Warnungen stummschalten möchten, verwenden Sie die Option `--quiet`. Dies kann nützlich sein, wenn Sie die Ausgabe an einen anderen Befehl in einem Skript weitergeben möchten.
+
+```bash
+>>> huggingface-cli download gpt2 config.json model.safetensors
+/home/wauplin/.cache/huggingface/hub/models--gpt2/snapshots/11c5a3d5811f50298f278a704980280950aedb10
+```
+
+Standardmäßig werden Dateien im Cache-Verzeichnis heruntergeladen, das durch die Umgebungsvariable `HF_HOME` definiert ist (oder `~/.cache/huggingface/hub`, wenn nicht angegeben). Sie können dies mit der Option `--cache-dir` überschreiben:
+
+```bash
+>>> huggingface-cli download gpt2 config.json --cache-dir=./cache
+./cache/models--gpt2/snapshots/11c5a3d5811f50298f278a704980280950aedb10/config.json
+```
+
+Wenn Sie Dateien in einen lokalen Ordner herunterladen möchten, ohne die Cache-Verzeichnisstruktur, können Sie `--local-dir` verwenden. Das Herunterladen in einen lokalen Ordner hat seine Einschränkungen, die in dieser [Tabelle](https://huggingface.co/docs/huggingface_hub/guides/download#download-files-to-local-folder) aufgeführt sind.
+
+```bash
+>>> huggingface-cli download gpt2 config.json --local-dir=./models/gpt2
+./models/gpt2/config.json
+```
+
+Es gibt weitere Argumente, die Sie angeben können, um aus verschiedenen Repo-Typen oder Revisionen herunterzuladen und Dateien zum Herunterladen mit Glob-Mustern ein- oder auszuschließen:
+
+```bash
+>>> huggingface-cli download bigcode/the-stack --repo-type=dataset --revision=v1.2 --include="data/python/*" --exclu
+de="*.json" --exclude="*.zip"
+Fetching 206 files:   100%|████████████████████████████████████████████| 206/206 [02:31<2:31, ?it/s]
+/home/wauplin/.cache/huggingface/hub/datasets--bigcode--the-stack/snapshots/9ca8fa6acdbc8ce920a0cb58adcdafc495818ae7
+```
+
+Für eine vollständige Liste der Argumente führen Sie bitte den folgenden Befehl aus:
+
+```bash
+huggingface-cli download --help
+```
\ No newline at end of file
diff --git a/docs/source/de/guides/hf_file_system.md b/docs/source/de/guides/hf_file_system.md
new file mode 100644
index 00000000..d46f7c70
--- /dev/null
+++ b/docs/source/de/guides/hf_file_system.md
@@ -0,0 +1,110 @@
+<!--⚠️ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
+rendered properly in your Markdown viewer.
+-->
+
+# Interagieren mit dem Hub über die Filesystem API
+
+Zusätzlich zur [`HfApi`] bietet die `huggingface_hub` Bibliothek [`HfFileSystem`], eine pythonische, [fsspec-kompatible](https://filesystem-spec.readthedocs.io/en/latest/) Dateischnittstelle zum Hugging Face Hub. Das [`HfFileSystem`] basiert auf der [`HfApi`] und bietet typische Dateisystemoperationen wie `cp`, `mv`, `ls`, `du`, `glob`, `get_file`, und `put_file`.
+
+## Verwendung
+
+```python
+>>> from huggingface_hub import HfFileSystem
+>>> fs = HfFileSystem()
+
+>>> # Alle Dateien in einem Verzeichnis auflisten
+>>> fs.ls("datasets/my-username/my-dataset-repo/data", detail=False)
+['datasets/my-username/my-dataset-repo/data/train.csv', 'datasets/my-username/my-dataset-repo/data/test.csv']
+
+>>> # Alle ".csv"-Dateien in einem Repo auflisten
+>>> fs.glob("datasets/my-username/my-dataset-repo/**.csv")
+['datasets/my-username/my-dataset-repo/data/train.csv', 'datasets/my-username/my-dataset-repo/data/test.csv']
+
+>>> # Eine entfernte Datei lesen
+>>> with fs.open("datasets/my-username/my-dataset-repo/data/train.csv", "r") as f:
+...     train_data = f.readlines()
+
+>>> # Den Inhalt einer entfernten Datei als Zeichenkette / String lesen
+>>> train_data = fs.read_text("datasets/my-username/my-dataset-repo/data/train.csv", revision="dev")
+
+>>> # Eine entfernte Datei schreiben
+>>> with fs.open("datasets/my-username/my-dataset-repo/data/validation.csv", "w") as f:
+...     f.write("text,label")
+...     f.write("Fantastic movie!,good")
+```
+
+Das optionale Argument `revision` kann übergeben werden, um eine Operation von einem spezifischen Commit auszuführen, wie z.B. einem Branch, Tag-Namen oder einem Commit-Hash.
+
+Anders als bei Pythons eingebautem `open`, ist der Standardmodus von `fsspec`'s `open` binär, `"rb"`. Das bedeutet, dass Sie den Modus explizit auf `"r"` zum Lesen und `"w"` zum Schreiben im Textmodus setzen müssen. Das Anhängen an eine Datei (Modi `"a"` und `"ab"`) wird noch nicht unterstützt.
+
+## Integrationen
+
+Das [`HfFileSystem`] kann mit jeder Bibliothek verwendet werden, die `fsspec` integriert, vorausgesetzt die URL folgt dem Schema:
+
+```
+hf://[<repo_type_prefix>]<repo_id>[@<revision>]/<pfad/im/repo>
+```
+
+Der `repo_type_prefix` ist `datasets/` für Datensätze, `spaces/` für Spaces, und Modelle benötigen kein Präfix in der URL.
+
+Einige interessante Integrationen, bei denen [`HfFileSystem`] die Interaktion mit dem Hub vereinfacht, sind unten aufgeführt:
+
+* Lesen/Schreiben eines [Pandas](https://pandas.pydata.org/pandas-docs/stable/user_guide/io.html#reading-writing-remote-files) DataFrame aus/in ein Hub-Repository:
+
+  ```python
+  >>> import pandas as pd
+
+  >>> # Eine entfernte CSV-Datei in einen DataFrame lesen
+  >>> df = pd.read_csv("hf://datasets/my-username/my-dataset-repo/train.csv")
+
+  >>> # Einen DataFrame in eine entfernte CSV-Datei schreiben
+  >>> df.to_csv("hf://datasets/my-username/my-dataset-repo/test.csv")
+  ```
+
+  Der gleiche Arbeitsablauf kann auch für  [Dask](https://docs.dask.org/en/stable/how-to/connect-to-remote-data.html) und [Polars](https://pola-rs.github.io/polars/py-polars/html/reference/io.html) verwendet werden.
+
+* Abfrage von (entfernten) Hub-Dateien mit  [DuckDB](https://duckdb.org/docs/guides/python/filesystems):
+
+  ```python
+  >>> from huggingface_hub import HfFileSystem
+  >>> import duckdb
+
+  >>> fs = HfFileSystem()
+  >>> duckdb.register_filesystem(fs)
+  >>> # Eine entfernte Datei abfragen und das Ergebnis als DataFrame zurückbekommen
+  >>> fs_query_file = "hf://datasets/my-username/my-dataset-repo/data_dir/data.parquet"
+  >>> df = duckdb.query(f"SELECT * FROM '{fs_query_file}' LIMIT 10").df()
+  ```
+
+* Verwendung des Hub als Array-Speicher mit [Zarr](https://zarr.readthedocs.io/en/stable/tutorial.html#io-with-fsspec):
+
+  ```python
+  >>> import numpy as np
+  >>> import zarr
+
+  >>> embeddings = np.random.randn(50000, 1000).astype("float32")
+
+  >>> # Ein Array in ein Repo schreiben
+  >>> with zarr.open_group("hf://my-username/my-model-repo/array-store", mode="w") as root:
+  ...    foo = root.create_group("embeddings")
+  ...    foobar = foo.zeros('experiment_0', shape=(50000, 1000), chunks=(10000, 1000), dtype='f4')
+  ...    foobar[:] = embeddings
+
+  >>> # Ein Array aus einem Repo lesen
+  >>> with zarr.open_group("hf://my-username/my-model-repo/array-store", mode="r") as root:
+  ...    first_row = root["embeddings/experiment_0"][0]
+  ```
+
+## Authentifizierung
+
+In vielen Fällen müssen Sie mit einem Hugging Face-Konto angemeldet sein, um mit dem Hub zu interagieren. Lesen Sie den [Login](../quick-start#login)-Abschnitt der Dokumentation, um mehr über Authentifizierungsmethoden auf dem Hub zu erfahren.
+
+Es ist auch möglich, sich programmatisch anzumelden, indem Sie Ihr `token` als Argument an [`HfFileSystem`] übergeben:
+
+
+```python
+>>> from huggingface_hub import HfFileSystem
+>>> fs = HfFileSystem(token=token)
+```
+
+Wenn Sie sich auf diese Weise anmelden, seien Sie vorsichtig, das Token nicht versehentlich zu veröffentlichen, wenn Sie Ihren Quellcode teilen!
\ No newline at end of file
diff --git a/docs/source/de/guides/inference.md b/docs/source/de/guides/inference.md
new file mode 100644
index 00000000..dc6e3592
--- /dev/null
+++ b/docs/source/de/guides/inference.md
@@ -0,0 +1,294 @@
+<!--⚠️ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
+rendered properly in your Markdown viewer.
+-->
+
+# Inferenz auf Servern ausführen
+
+Inferenz ist der Prozess, bei dem ein trainiertes Modell verwendet wird, um Vorhersagen für neue Daten zu treffen. Da dieser Prozess rechenintensiv sein kann, kann die Ausführung auf einem dedizierten Server eine interessante Option sein. Die `huggingface_hub` Bibliothek bietet eine einfache Möglichkeit, einen Dienst aufzurufen, der die Inferenz für gehostete Modelle durchführt. Es gibt mehrere Dienste, mit denen Sie sich verbinden können:
+- [Inferenz API](https://huggingface.co/docs/api-inference/index): ein Service, der Ihnen ermöglicht, beschleunigte Inferenz auf der Infrastruktur von Hugging Face kostenlos auszuführen. Dieser Service ist eine schnelle Möglichkeit, um anzufangen, verschiedene Modelle zu testen und AI-Produkte zu prototypisieren.
+- [Inferenz Endpunkte](https://huggingface.co/inference-endpoints/index): ein Produkt zur einfachen Bereitstellung von Modellen im Produktivbetrieb. Die Inferenz wird von Hugging Face in einer dedizierten, vollständig verwalteten Infrastruktur auf einem Cloud-Anbieter Ihrer Wahl durchgeführt.
+
+Diese Dienste können mit dem [`InferenceClient`] Objekt aufgerufen werden. Dieser fungiert als Ersatz für den älteren [`InferenceApi`] Client und fügt spezielle Unterstützung für Aufgaben und das Ausführen von Inferenz hinzu, sowohl auf [Inferenz API](https://huggingface.co/docs/api-inference/index) als auch auf [Inferenz Endpunkten](https://huggingface.co/docs/inference-endpoints/index). Im Abschnitt [Legacy InferenceAPI client](#legacy-inferenceapi-client) erfahren Sie, wie Sie zum neuen Client migrieren können.
+
+<Tip>
+
+[`InferenceClient`] ist ein Python-Client, der HTTP-Anfragen an unsere APIs stellt. Wenn Sie die HTTP-Anfragen direkt mit Ihrem bevorzugten Tool (curl, postman,...) durchführen möchten, lesen Sie bitte die Dokumentationsseiten der [Inferenz API](https://huggingface.co/docs/api-inference/index) oder der [Inferenz Endpunkte](https://huggingface.co/docs/inference-endpoints/index).
+
+Für die Webentwicklung wurde ein [JS-Client](https://huggingface.co/docs/huggingface.js/inference/README) veröffentlicht. Wenn Sie sich für die Spieleentwicklung interessieren, sollten Sie einen Blick auf unser [C#-Projekt](https://github.com/huggingface/unity-api) werfen.
+
+</Tip>
+
+## Erste Schritte
+
+Los geht's mit einer Text-zu-Bild-Aufgabe:
+
+```python
+>>> from huggingface_hub import InferenceClient
+>>> client = InferenceClient()
+
+>>> image = client.text_to_image("An astronaut riding a horse on the moon.")
+>>> image.save("astronaut.png")
+```
+
+Wir haben einen [`InferenceClient`] mit den Standardparametern initialisiert. Das Einzige, was Sie wissen müssen, ist die [Aufgabe](#unterstützte-aufgaben), die Sie ausführen möchten. Standardmäßig wird der Client sich mit der Inferenz API verbinden und ein Modell auswählen, um die Aufgabe abzuschließen. In unserem Beispiel haben wir ein Bild aus einem Textprompt generiert. Der zurückgegebene Wert ist ein `PIL.Image`-Objekt, das in eine Datei gespeichert werden kann.
+
+<Tip warning={true}>
+
+Die API ist darauf ausgelegt, einfach zu sein. Nicht alle Parameter und Optionen sind für den Endbenutzer verfügbar oder beschrieben. Schauen Sie auf [dieser Seite](https://huggingface.co/docs/api-inference/detailed_parameters) nach, wenn Sie mehr über alle verfügbaren Parameter für jede Aufgabe erfahren möchten.
+
+</Tip>
+
+### Verwendung eines spezifischen Modells
+
+Was ist, wenn Sie ein bestimmtes Modell verwenden möchten? Sie können es entweder als Parameter angeben oder direkt auf Instanzebene spezifizieren:
+
+```python
+>>> from huggingface_hub import InferenceClient
+# Client für ein spezifisches Modell initialisieren
+>>> client = InferenceClient(model="prompthero/openjourney-v4")
+>>> client.text_to_image(...)
+# Oder nutzen Sie einen generischen Client, geben aber Ihr Modell als Argument an
+>>> client = InferenceClient()
+>>> client.text_to_image(..., model="prompthero/openjourney-v4")
+```
+
+<Tip>
+
+Es gibt mehr als 200k Modelle im Hugging Face Hub! Jede Aufgabe im [`InferenceClient`] kommt mit einem empfohlenen Modell. Beachten Sie, dass die HF-Empfehlung sich im Laufe der Zeit ohne vorherige Ankündigung ändern kann. Daher ist es am besten, ein Modell explizit festzulegen, sobald Sie sich entschieden haben. In den meisten Fällen werden Sie daran interessiert sein, ein Modell zu finden, das speziell auf _Ihre_ Bedürfnisse zugeschnitten ist. Besuchen Sie die [Modelle](https://huggingface.co/models)-Seite im Hub, um Ihre Möglichkeiten zu erkunden.
+
+</Tip>
+
+### Verwendung einer spezifischen URL
+
+Die oben gesehenen Beispiele nutzen die kostenfrei gehostete Inferenz API. Dies erweist sich als sehr nützlich für Prototyping und schnelles Testen. Wenn Sie bereit sind, Ihr Modell in die Produktion zu übernehmen, müssen Sie eine dedizierte Infrastruktur verwenden. Hier kommen [Inferenz Endpunkte](https://huggingface.co/docs/inference-endpoints/index) ins Spiel. Es ermöglicht Ihnen, jedes Modell zu implementieren und als private API freizugeben. Nach der Implementierung erhalten Sie eine URL, zu der Sie mit genau dem gleichen Code wie zuvor eine Verbindung herstellen können, wobei nur der `Modell`-Parameter geändert wird:
+
+```python
+>>> from huggingface_hub import InferenceClient
+>>> client = InferenceClient(model="https://uu149rez6gw9ehej.eu-west-1.aws.endpoints.huggingface.cloud/deepfloyd-if")
+# oder
+>>> client = InferenceClient()
+>>> client.text_to_image(..., model="https://uu149rez6gw9ehej.eu-west-1.aws.endpoints.huggingface.cloud/deepfloyd-if")
+```
+
+### Authentifizierung
+
+Aufrufe, die mit dem [`InferenceClient`] gemacht werden, können mit einem [User Access Token](https://huggingface.co/docs/hub/security-tokens) authentifiziert werden. Standardmäßig wird das auf Ihrem Computer gespeicherte Token verwendet, wenn Sie angemeldet sind (sehen Sie hier, [wie Sie sich anmelden können](https://huggingface.co/docs/huggingface_hub/quick-start#login)). Wenn Sie nicht angemeldet sind, können Sie Ihr Token als Instanzparameter übergeben:
+
+```python
+>>> from huggingface_hub import InferenceClient
+>>> client = InferenceClient(token="hf_***")
+```
+
+<Tip>
+
+Die Authentifizierung ist NICHT zwingend erforderlich, wenn Sie die Inferenz API verwenden. Authentifizierte Benutzer erhalten jedoch ein höheres kostenloses Kontingent, um mit dem Service zu arbeiten. Ein Token ist auch zwingend erforderlich, wenn Sie Inferenz auf Ihren privaten Modellen oder auf privaten Endpunkten ausführen möchten.
+
+</Tip>
+
+## Unterstützte Aufgaben
+
+Das Ziel von [`InferenceClient`] ist es, die einfachste Schnittstelle zum Ausführen von Inferenzen auf Hugging Face-Modellen bereitzustellen. Es verfügt über eine einfache API, die die gebräuchlichsten Aufgaben unterstützt. Hier ist eine Liste der derzeit unterstützten Aufgaben:
+
+| Domäne | Aufgabe                           | Unterstützt   | Dokumentation                             |
+|--------|--------------------------------|--------------|------------------------------------|
+| Audio | [Audio Classification](https://huggingface.co/tasks/audio-classification)           | ✅ | [`~InferenceClient.audio_classification`] |
+| | [Automatic Speech Recognition](https://huggingface.co/tasks/automatic-speech-recognition)   | ✅ | [`~InferenceClient.automatic_speech_recognition`] |
+| | [Text-to-Speech](https://huggingface.co/tasks/text-to-speech)                 | ✅ | [`~InferenceClient.text_to_speech`] |
+| Computer Vision | [Image Classification](https://huggingface.co/tasks/image-classification)           | ✅ | [`~InferenceClient.image_classification`] |
+| | [Image Segmentation](https://huggingface.co/tasks/image-segmentation)             | ✅ | [`~InferenceClient.image_segmentation`] |
+| | [Image-to-Image](https://huggingface.co/tasks/image-to-image)                 | ✅ | [`~InferenceClient.image_to_image`] |
+| | [Image-to-Text](https://huggingface.co/tasks/image-to-text)                  | ✅ | [`~InferenceClient.image_to_text`] |
+| | [Object Detection](https://huggingface.co/tasks/object-detection)            | ✅ | [`~InferenceClient.object_detection`] |
+| | [Text-to-Image](https://huggingface.co/tasks/text-to-image)                  | ✅ | [`~InferenceClient.text_to_image`] |
+| | [Zero-Shot-Image-Classification](https://huggingface.co/tasks/zero-shot-image-classification)                  | ✅ | [`~InferenceClient.zero_shot_image_classification`] |
+| Multimodal | [Documentation Question Answering](https://huggingface.co/tasks/document-question-answering) | ✅ | [`~InferenceClient.document_question_answering`] |
+| | [Visual Question Answering](https://huggingface.co/tasks/visual-question-answering)      | ✅ | [`~InferenceClient.visual_question_answering`] |
+| NLP | [Conversational](https://huggingface.co/tasks/conversational)                 | ✅ | [`~InferenceClient.conversational`] |
+| | [Feature Extraction](https://huggingface.co/tasks/feature-extraction)             | ✅ | [`~InferenceClient.feature_extraction`] |
+| | [Fill Mask](https://huggingface.co/tasks/fill-mask)                      | ✅ | [`~InferenceClient.fill_mask`] |
+| | [Question Answering](https://huggingface.co/tasks/question-answering)             | ✅ | [`~InferenceClient.question_answering`] |
+| | [Sentence Similarity](https://huggingface.co/tasks/sentence-similarity)            | ✅ | [`~InferenceClient.sentence_similarity`] |
+| | [Summarization](https://huggingface.co/tasks/summarization)                  | ✅ | [`~InferenceClient.summarization`] |
+| | [Table Question Answering](https://huggingface.co/tasks/table-question-answering)       | ✅ | [`~InferenceClient.table_question_answering`] |
+| | [Text Classification](https://huggingface.co/tasks/text-classification)            | ✅ | [`~InferenceClient.text_classification`] |
+| | [Text Generation](https://huggingface.co/tasks/text-generation)   | ✅ | [`~InferenceClient.text_generation`] |
+| | [Token Classification](https://huggingface.co/tasks/token-classification)           | ✅ | [`~InferenceClient.token_classification`] |
+| | [Translation](https://huggingface.co/tasks/translation)       | ✅ | [`~InferenceClient.translation`] |
+| | [Zero Shot Classification](https://huggingface.co/tasks/zero-shot-classification)       | ✅ | [`~InferenceClient.zero_shot_classification`] |
+| Tabular | [Tabular Classification](https://huggingface.co/tasks/tabular-classification)         | ✅ | [`~InferenceClient.tabular_classification`] |
+| | [Tabular Regression](https://huggingface.co/tasks/tabular-regression)             | ✅ | [`~InferenceClient.tabular_regression`] |
+
+
+<Tip>
+
+Schauen Sie sich die [Aufgaben](https://huggingface.co/tasks)-Seite an, um mehr über jede Aufgabe zu erfahren, wie man sie verwendet und die beliebtesten Modelle für jede Aufgabe.
+
+</Tip>
+
+## Benutzerdefinierte Anfragen
+
+Es ist jedoch nicht immer möglich, alle Anwendungsfälle abzudecken. Für benutzerdefinierte Anfragen bietet die [`InferenceClient.post`] Methode Ihnen die Flexibilität, jede Anfrage an die Inferenz API zu senden. Zum Beispiel können Sie angeben, wie die Eingaben und Ausgaben geparst werden sollen. Im folgenden Beispiel wird das generierte Bild als Roh-Bytes zurückgegeben, anstatt es als `PIL Image` zu parsen. Dies kann hilfreich sein, wenn Sie `Pillow` in Ihrer Einrichtung nicht installiert haben und Ihnen nur die Binärinhalt des Bildes wichtig ist. [`InferenceClient.post`] ist auch nützlich, um Aufgaben zu behandeln, die noch nicht offiziell unterstützt werden.
+
+```python
+>>> from huggingface_hub import InferenceClient
+>>> client = InferenceClient()
+>>> response = client.post(json={"inputs": "An astronaut riding a horse on the moon."}, model="stabilityai/stable-diffusion-2-1")
+>>> response.content # raw bytes
+b'...'
+```
+
+## Asynchroner Client
+
+Eine asynchrone Version des Clients wird ebenfalls bereitgestellt, basierend auf `asyncio` und `aiohttp`. Sie können entweder `aiohttp` direkt installieren oder das `[inference]` Extra verwenden:
+
+```sh
+pip install aiohttp
+# oder
+pip install --upgrade huggingface_hub[inference]
+```
+
+Nach der Installation sind alle asynchronen API-Endpunkte über [`AsyncInferenceClient`] verfügbar. Seine Initialisierung und APIs sind genau gleich wie die synchronisierte Version.
+
+```py
+# Der Code muss in einem asyncio-konkurrenten Kontext ausgeführt werden.
+# $ python -m asyncio
+>>> from huggingface_hub import AsyncInferenceClient
+>>> client = AsyncInferenceClient()
+
+>>> image = await client.text_to_image("An astronaut riding a horse on the moon.")
+>>> image.save("astronaut.png")
+
+>>> async for token in await client.text_generation("The Huggingface Hub is", stream=True):
+...     print(token, end="")
+ a platform for sharing and discussing ML-related content.
+```
+
+Für weitere Informationen zum `asyncio`-Modul konsultieren Sie bitte die [offizielle Dokumentation](https://docs.python.org/3/library/asyncio.html).
+
+
+## Fortgeschrittene Tipps
+
+Im obigen Abschnitt haben wir die Hauptaspekte von [`InferenceClient`] betrachtet. Lassen Sie uns in einige fortgeschrittene Tipps eintauchen.
+
+### Zeitüberschreitung
+
+Bei der Inferenz gibt es zwei Hauptursachen für eine Zeitüberschreitung:
+- Der Inferenzprozess dauert lange, um abgeschlossen zu werden.
+- Das Modell ist nicht verfügbar, beispielsweise wenn die Inferenz API es zum ersten Mal lädt.
+
+Der [`InferenceClient`] verfügt über einen globalen Zeitüberschreitungsparameter (`timeout`), um diese beiden Aspekte zu behandeln. Standardmäßig ist er auf `None` gesetzt, was bedeutet, dass der Client unendlich lange auf den Abschluss der Inferenz warten wird. Wenn Sie mehr Kontrolle in Ihrem Arbeitsablauf wünschen, können Sie ihn auf einen bestimmten Wert in Sekunden setzen. Wenn die Zeitüberschreitungsverzögerung abläuft, wird ein [`InferenceTimeoutError`] ausgelöst. Sie können diesen Fehler abfangen und in Ihrem Code behandeln:
+
+```python
+>>> from huggingface_hub import InferenceClient, InferenceTimeoutError
+>>> client = InferenceClient(timeout=30)
+>>> try:
+...     client.text_to_image(...)
+... except InferenceTimeoutError:
+...     print("Inference timed out after 30s.")
+```
+
+### Binäre Eingaben
+
+Einige Aufgaben erfordern binäre Eingaben, zum Beispiel bei der Arbeit mit Bildern oder Audiodateien. In diesem Fall versucht der [`InferenceClient] so permissiv wie möglich zu sein und akzeptiert verschiedene Typen:
+- rohe `Bytes`
+- ein Datei-ähnliches Objekt, geöffnet als Binär (`with open("audio.flac", "rb") as f: ...`)
+- ein Pfad (`str` oder `Path`) zu einer lokalen Datei
+- eine URL (`str`) zu einer entfernten Datei (z.B. `https://...`). In diesem Fall wird die Datei lokal heruntergeladen, bevor sie an die Inferenz API gesendet wird.
+
+```py
+>>> from huggingface_hub import InferenceClient
+>>> client = InferenceClient()
+>>> client.image_classification("https://upload.wikimedia.org/wikipedia/commons/thumb/4/43/Cute_dog.jpg/320px-Cute_dog.jpg")
+[{'score': 0.9779096841812134, 'label': 'Blenheim spaniel'}, ...]
+```
+
+## Legacy InferenceAPI client
+
+Der [`InferenceClient`] dient als Ersatz für den veralteten [`InferenceApi`]-Client. Er bietet spezifische Unterstützung für Aufgaben und behandelt Inferenz sowohl auf der [Inferenz API](https://huggingface.co/docs/api-inference/index) als auch auf den [Inferenz Endpunkten](https://huggingface.co/docs/inference-endpoints/index).
+
+Hier finden Sie eine kurze Anleitung, die Ihnen hilft, von [`InferenceApi`] zu [`InferenceClient`] zu migrieren.
+
+### Initialisierung
+
+Ändern Sie von
+
+```python
+>>> from huggingface_hub import InferenceApi
+>>> inference = InferenceApi(repo_id="bert-base-uncased", token=API_TOKEN)
+```
+
+zu
+
+```python
+>>> from huggingface_hub import InferenceClient
+>>> inference = InferenceClient(model="bert-base-uncased", token=API_TOKEN)
+```
+
+### Ausführen einer bestimmten Aufgabe
+
+Ändern Sie von
+
+```python
+>>> from huggingface_hub import InferenceApi
+>>> inference = InferenceApi(repo_id="paraphrase-xlm-r-multilingual-v1", task="feature-extraction")
+>>> inference(...)
+```
+
+zu
+
+```python
+>>> from huggingface_hub import InferenceClient
+>>> inference = InferenceClient()
+>>> inference.feature_extraction(..., model="paraphrase-xlm-r-multilingual-v1")
+```
+
+<Tip>
+
+Dies ist der empfohlene Weg, um Ihren Code an [`InferenceClient`] anzupassen. Dadurch können Sie von den aufgabenspezifischen Methoden wie `feature_extraction` profitieren.
+
+</Tip>
+
+### Eigene Anfragen ausführen
+
+Ändern Sie von
+
+```python
+>>> from huggingface_hub import InferenceApi
+>>> inference = InferenceApi(repo_id="bert-base-uncased")
+>>> inference(inputs="The goal of life is [MASK].")
+[{'sequence': 'the goal of life is life.', 'score': 0.10933292657136917, 'token': 2166, 'token_str': 'life'}]
+```
+zu
+
+```python
+>>> from huggingface_hub import InferenceClient
+>>> client = InferenceClient()
+>>> response = client.post(json={"inputs": "The goal of life is [MASK]."}, model="bert-base-uncased")
+>>> response.json()
+[{'sequence': 'the goal of life is life.', 'score': 0.10933292657136917, 'token': 2166, 'token_str': 'life'}]
+```
+
+### Mit Parametern ausführen
+
+Ändern Sie von
+
+```python
+>>> from huggingface_hub import InferenceApi
+>>> inference = InferenceApi(repo_id="typeform/distilbert-base-uncased-mnli")
+>>> inputs = "Hi, I recently bought a device from your company but it is not working as advertised and I would like to get reimbursed!"
+>>> params = {"candidate_labels":["refund", "legal", "faq"]}
+>>> inference(inputs, params)
+{'sequence': 'Hi, I recently bought a device from your company but it is not working as advertised and I would like to get reimbursed!', 'labels': ['refund', 'faq', 'legal'], 'scores': [0.9378499388694763, 0.04914155602455139, 0.013008488342165947]}
+```
+
+zu
+
+```python
+>>> from huggingface_hub import InferenceClient
+>>> client = InferenceClient()
+>>> inputs = "Hi, I recently bought a device from your company but it is not working as advertised and I would like to get reimbursed!"
+>>> params = {"candidate_labels":["refund", "legal", "faq"]}
+>>> response = client.post(json={"inputs": inputs, "parameters": params}, model="typeform/distilbert-base-uncased-mnli")
+>>> response.json()
+{'sequence': 'Hi, I recently bought a device from your company but it is not working as advertised and I would like to get reimbursed!', 'labels': ['refund', 'faq', 'legal'], 'scores': [0.9378499388694763, 0.04914155602455139, 0.013008488342165947]}
+```
diff --git a/docs/source/de/guides/integrations.md b/docs/source/de/guides/integrations.md
new file mode 100644
index 00000000..26a7d4b4
--- /dev/null
+++ b/docs/source/de/guides/integrations.md
@@ -0,0 +1,251 @@
+<!--⚠️ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
+rendered properly in your Markdown viewer.
+-->
+
+# Integrieren Sie jedes ML-Framework mit dem Hub
+
+Der Hugging Face Hub erleichtert das Hosten und Teilen von Modellen mit der Community. Er unterstützt [Dutzende von Bibliotheken](https://huggingface.co/docs/hub/models-libraries) im Open Source-Ökosystem. Wir arbeiten ständig daran, diese Unterstützung zu erweitern, um kollaboratives Machine Learning voranzutreiben. Die `huggingface_hub`-Bibliothek spielt eine Schlüsselrolle in diesem Prozess und ermöglicht es jedem Python-Skript, Dateien einfach hochzuladen und zu laden.
+
+Es gibt vier Hauptwege, eine Bibliothek mit dem Hub zu integrieren:
+1. **Push to Hub**: Implementieren Sie eine Methode, um ein Modell auf den Hub hochzuladen. 
+   Dies beinhaltet das Modellgewicht sowie [die Modellkarte](https://huggingface.co/docs/huggingface_hub/how-to-model-cards) und alle anderen relevanten Informationen oder Daten, die für den Betrieb des Modells erforderlich sind (zum Beispiel Trainingsprotokolle). Diese Methode wird oft `push_to_hub()` genannt.
+2. **Download from Hub**: Implementieren Sie eine Methode, um ein Modell vom Hub zu laden.
+   Die Methode sollte die Modellkonfiguration/-gewichte herunterladen und das Modell laden. Diese Methode wird oft `from_pretrained` oder `load_from_hub()` genannt.
+3. **Inference API**: Nutzen Sie unsere Server, um Inferenz auf von Ihrer Bibliothek unterstützten Modellen kostenlos auszuführen.
+4. **Widgets**: Zeigen Sie ein Widget auf der Landing Page Ihrer Modelle auf dem Hub an. 
+   Dies ermöglicht es Benutzern, ein Modell schnell aus dem Browser heraus auszuprobieren.
+
+In diesem Leitfaden konzentrieren wir uns auf die ersten beiden Themen. Wir werden die beiden Hauptansätze vorstellen, die Sie zur Integration einer Bibliothek verwenden können, mit ihren Vor- und Nachteilen. Am Ende des Leitfadens ist alles zusammengefasst, um Ihnen bei der Auswahl zwischen den beiden zu helfen. Bitte beachten Sie, dass dies nur Richtlinien sind, die Sie an Ihre Anforderungen anpassen können.
+
+Wenn Sie sich für Inferenz und Widgets interessieren, können Sie [diesem Leitfaden](https://huggingface.co/docs/hub/models-adding-libraries#set-up-the-inference-api) folgen. In beiden Fällen können Sie sich an uns wenden, wenn Sie eine Bibliothek mit dem Hub integrieren und [in unserer Dokumentation](https://huggingface.co/docs/hub/models-libraries) aufgeführt haben möchten.
+
+## Ein flexibler Ansatz: Helfer
+
+Der erste Ansatz zur Integration einer Bibliothek in den Hub besteht tatsächlich darin, die `push_to_hub` und `from_pretrained` Methoden selbst zu implementieren. Dies gibt Ihnen volle Flexibilität hinsichtlich der Dateien, die Sie hoch-/herunterladen möchten, und wie Sie Eingaben, die speziell für Ihr Framework sind, behandeln. Sie können sich die beiden Leitfäden [Dateien hochladen](./upload) und [Dateien herunterladen](./download) ansehen, um mehr darüber zu erfahren, wie dies funktioniert. Dies ist zum Beispiel die Art und Weise, wie die FastAI-Integration implementiert ist (siehe [`push_to_hub_fastai`]
+und [`from_pretrained_fastai`]).
+
+Die Implementierung kann zwischen den Bibliotheken variieren, aber der Workflow ist oft ähnlich.
+
+### from_pretrained
+
+So sieht eine `from_pretrained` Methode normalerweise aus:
+
+```python
+def from_pretrained(model_id: str) -> MyModelClass:
+   # Modell vom Hub herunterladen
+   cached_model = hf_hub_download(
+      repo_id=repo_id,
+      filename="model.pkl",
+      library_name="fastai",
+      library_version=get_fastai_version(),
+   )
+
+   # Modell laden
+    return load_model(cached_model)
+```
+
+### push_to_hub
+
+Die `push_to_hub` Methode erfordert oft etwas mehr Komplexität, um die Repo-Erstellung, die Generierung der Modellkarte und das Speichern von Gewichten zu behandeln. Ein üblicher Ansatz besteht darin, all diese Dateien in einem temporären Ordner zu speichern, ihn hochzuladen und dann zu löschen.
+
+```python
+def push_to_hub(model: MyModelClass, repo_name: str) -> None:
+   api = HfApi()
+
+   # Repo erstellen, wenn noch nicht vorhanden und die zugehörige repo_id erhalten
+   repo_id = api.create_repo(repo_name, exist_ok=True)
+
+   # Modell in temporärem Ordner speichern und in einem enzigen Commit pushen
+   with TemporaryDirectory() as tmpdir:
+      tmpdir = Path(tmpdir)
+
+      # Gewichte speichern
+      save_model(model, tmpdir / "model.safetensors")
+
+      # Modellkarte generieren
+      card = generate_model_card(model)
+      (tmpdir / "README.md").write_text(card)
+
+      # Logs speichern
+      # Diagramme speichern
+      # Evaluationsmetriken speichern
+      # ...
+
+      # Auf den Hub pushen
+      return api.upload_folder(repo_id=repo_id, folder_path=tmpdir)
+```
+
+Dies ist natürlich nur ein Beispiel. Wenn Sie an komplexeren Manipulationen interessiert sind (entfernen von entfernten Dateien, hochladen von Gewichten on-the-fly, lokales Speichern von Gewichten, usw.), beachten Sie bitte den [Dateien hochladen](./upload) Leitfaden.
+
+### Einschränkungen
+
+Obwohl dieser Ansatz flexibel ist, hat er einige Nachteile, insbesondere in Bezug auf die Wartung. Hugging Face-Benutzer sind oft an zusätzliche Funktionen gewöhnt, wenn sie mit `huggingface_hub` arbeiten. Zum Beispiel ist es beim Laden von Dateien aus dem Hub üblich, Parameter wie folgt anzubieten:
+- `token`: zum Herunterladen aus einem privaten Repository
+- `revision`: zum Herunterladen von einem spezifischen Branch
+- `cache_dir`: um Dateien in einem spezifischen Verzeichnis zu cachen
+- `force_download`/`resume_download`/`local_files_only`: um den Cache wieder zu verwenden oder nicht
+- `api_endpoint`/`proxies`: HTTP-Session konfigurieren
+
+Beim Pushen von Modellen werden ähnliche Parameter unterstützt:
+- `commit_message`: benutzerdefinierte Commit-Nachricht
+- `private`: ein privates Repository erstellen, falls nicht vorhanden
+- `create_pr`: erstellen Sie einen PR anstatt auf `main` zu pushen
+- `branch`: auf einen Branch pushen anstatt auf den `main` Branch
+- `allow_patterns`/`ignore_patterns`: filtern, welche Dateien hochgeladen werden sollen
+- `token`
+- `api_endpoint`
+- ...
+
+Alle diese Parameter können den zuvor gesehenen Implementierungen hinzugefügt und an die `huggingface_hub`-Methoden übergeben werden.
+ Wenn sich jedoch ein Parameter ändert oder eine neue Funktion hinzugefügt wird, müssen Sie Ihr Paket aktualisieren. 
+ Die Unterstützung dieser Parameter bedeutet auch mehr Dokumentation, die Sie auf Ihrer Seite pflegen müssen. 
+ Um zu sehen, wie man diese Einschränkungen mildert, springen wir zu unserem nächsten Abschnitt **Klassenvererbung**.
+
+## Ein komplexerer Ansatz: Klassenvererbung
+
+Wie wir oben gesehen haben, gibt es zwei Hauptmethoden, um Ihre Bibliothek mit dem Hub zu integrieren: Dateien hochladen (`push_to_hub`) und Dateien herunterladen (`from_pretrained`). Sie können diese Methoden selbst implementieren, aber das hat seine Tücken. Um dies zu bewältigen, bietet `huggingface_hub` ein Werkzeug an, das Klassenvererbung verwendet. Schauen wir uns an, wie es funktioniert!
+
+In vielen Fällen implementiert eine Bibliothek ihr Modell bereits mit einer Python-Klasse. Die Klasse enthält die Eigenschaften des Modells und Methoden zum Laden, Ausführen, Trainieren und Evaluieren. Unser Ansatz besteht darin, diese Klasse zu erweitern, um Upload- und Download-Funktionen mit Mixins hinzuzufügen. Ein [Mixin](https://stackoverflow.com/a/547714) ist eine Klasse, die dazu bestimmt ist, eine vorhandene Klasse mit einem Satz spezifischer Funktionen durch Mehrfachvererbung zu erweitern. `huggingface_hub` bietet sein eigenes Mixin, das [`ModelHubMixin`]. Der Schlüssel hier ist zu verstehen, wie es funktioniert und wie man es anpassen kann.
+
+Die Klasse [ModelHubMixin] implementiert 3 *öffentliche* Methoden (`push_to_hub`, `save_pretrained` und `from_pretrained`). Dies sind die Methoden, die Ihre Benutzer aufrufen werden, um Modelle mit Ihrer Bibliothek zu laden/speichern. [`ModelHubMixin`] definiert auch 2 private Methoden (`_save_pretrained` und `_from_pretrained`). Diese müssen Sie implementieren. Um Ihre Bibliothek zu integrieren, sollten Sie:
+
+1. Lassen Sie Ihre Modell-Klasse von [`ModelHubMixin`] erben.
+2. Implementieren Sie die privaten Methoden:
+   - [`~ModelHubMixin._save_pretrained`]: Methode, die als Eingabe einen Pfad zu einem Verzeichnis nimmt und das Modell dort speichert. Sie müssen die gesamte Logik zum Speichern Ihres Modells in dieser Methode schreiben: Modellkarte, Modellgewichte, Konfigurationsdateien, Trainingsprotokolle und Diagramme. Alle relevanten Informationen für dieses Modell müssen von dieser Methode behandelt werden. 
+   [Model Cards](https://huggingface.co/docs/hub/model-cards) sind besonders wichtig, um Ihr Modell zu beschreiben. Weitere Details finden Sie in [unserem Implementierungsleitfaden](./model-cards).
+   - [~ModelHubMixin._from_pretrained]: **Klassenmethode**, die als Eingabe eine `model_id` nimmt und ein instanziiertes Modell zurückgibt. Die Methode muss die relevanten Dateien herunterladen und laden.
+3. Sie sind fertig!
+
+Der Vorteil der Verwendung von [`ModelHubMixin`] besteht darin, dass Sie, sobald Sie sich um die Serialisierung/das Laden der Dateien gekümmert haben, bereit sind los zu legen. Sie müssen sich keine Gedanken über Dinge wie Repository-Erstellung, Commits, PRs oder Revisionen machen. All dies wird von dem Mixin gehandhabt und steht Ihren Benutzern zur Verfügung. Das Mixin stellt auch sicher, dass öffentliche Methoden gut dokumentiert und typisiert sind.
+
+### Ein konkretes Beispiel: PyTorch
+
+Ein gutes Beispiel für das, was wir oben gesehen haben, ist [`PyTorchModelHubMixin`], unsere Integration für das PyTorch-Framework. Dies ist eine einsatzbereite Integration.
+
+#### Wie verwendet man es?
+
+Hier ist, wie jeder Benutzer ein PyTorch-Modell vom/auf den Hub laden/speichern kann:
+
+```python
+>>> import torch
+>>> import torch.nn as nn
+>>> from huggingface_hub import PyTorchModelHubMixin
+
+# 1. Definieren Sie Ihr Pytorch-Modell genau so, wie Sie es gewohnt sind
+>>> class MyModel(nn.Module, PyTorchModelHubMixin): # Mehrfachvererbung
+...     def __init__(self):
+...         super().__init__() 
+...         self.param = nn.Parameter(torch.rand(3, 4))
+...         self.linear = nn.Linear(4, 5)
+
+...     def forward(self, x):
+...         return self.linear(x + self.param)
+>>> model = MyModel()
+
+# 2. (optional) Modell in lokales Verzeichnis speichern
+>>> model.save_pretrained("path/to/my-awesome-model")
+
+# 3. Modellgewichte an den Hub übertragen
+>>> model.push_to_hub("my-awesome-model")
+
+# 4. Modell vom Hub initialisieren
+>>> model = MyModel.from_pretrained("username/my-awesome-model")
+```
+
+#### Implementierung
+
+Die Implementierung ist tatsächlich sehr einfach, und die vollständige Implementierung finden Sie [hier](https://github.com/huggingface/huggingface_hub/blob/main/src/huggingface_hub/hub_mixin.py).
+
+1. Zuerst, erben Ihrer Klasse von `ModelHubMixin`:
+
+```python
+from huggingface_hub import ModelHubMixin
+
+class PyTorchModelHubMixin(ModelHubMixin):
+   (...)
+```
+
+2. Implementieren der `_save_pretrained` Methode:
+
+```py
+from huggingface_hub import ModelCard, ModelCardData
+
+class PyTorchModelHubMixin(ModelHubMixin):
+   (...)
+
+   def _save_pretrained(self, save_directory: Path):
+      """Generiere Modellkarte und speichere Gewichte von einem Pytorch-Modell in einem lokalen Verzeichnis."""
+      model_card = ModelCard.from_template(
+         card_data=ModelCardData(
+            license='mit',
+            library_name="pytorch",
+            ...
+         ),
+         model_summary=...,
+         model_type=...,
+         ...
+      )
+      (save_directory / "README.md").write_text(str(model))
+      torch.save(obj=self.module.state_dict(), f=save_directory / "pytorch_model.bin")
+```
+
+3. Implementieren der `_from_pretrained` Methode:
+
+```python
+class PyTorchModelHubMixin(ModelHubMixin):
+   (...)
+
+   @classmethod # Muss eine Klassenmethode sein!
+   def _from_pretrained(
+      cls,
+      *,
+      model_id: str,
+      revision: str,
+      cache_dir: str,
+      force_download: bool,
+      proxies: Optional[Dict],
+      resume_download: bool,
+      local_files_only: bool,
+      token: Union[str, bool, None],
+      map_location: str = "cpu", # zusätzliches Argument
+      strict: bool = False, # zusätzliches Argument
+      **model_kwargs,
+   ):
+      """Load Pytorch pretrained weights and return the loaded model."""
+      if os.path.isdir(model_id): # Kann entweder ein lokales Verzeichnis sein
+         print("Loading weights from local directory")
+         model_file = os.path.join(model_id, "pytorch_model.bin")
+      else: # Oder ein Modell am Hub
+         model_file = hf_hub_download( # Herunterladen vom Hub, gleiche Eingabeargumente
+            repo_id=model_id,
+            filename="pytorch_model.bin",
+            revision=revision,
+            cache_dir=cache_dir,
+            force_download=force_download,
+            proxies=proxies,
+            resume_download=resume_download,
+            token=token,
+            local_files_only=local_files_only,
+         )
+
+      # Modell laden und zurückgeben - benutzerdefinierte Logik je nach Ihrem Framework
+      model = cls(**model_kwargs)
+      state_dict = torch.load(model_file, map_location=torch.device(map_location))
+      model.load_state_dict(state_dict, strict=strict)
+      model.eval()
+      return model
+```
+
+Und das war's! Ihre Bibliothek ermöglicht es Benutzern nun, Dateien vom und zum Hub hoch- und herunterzuladen.
+
+## Kurzer Vergleich
+
+Lassen Sie uns die beiden Ansätze, die wir gesehen haben, schnell mit ihren Vor- und Nachteilen zusammenfassen. Die untenstehende Tabelle ist nur indikativ. Ihr Framework könnte einige Besonderheiten haben, die Sie berücksichtigen müssen. Dieser Leitfaden soll nur Richtlinien und Ideen geben, wie Sie die Integration handhaben können. Kontaktieren Sie uns in jedem Fall, wenn Sie Fragen haben!
+
+<!-- Generated using https://www.tablesgenerator.com/markdown_tables -->
+| Integration | Mit Helfern | Mit [`ModelHubMixin`] |
+|:---:|:---:|:---:|
+| Benutzererfahrung | `model = load_from_hub(...)`<br>`push_to_hub(model, ...)` | `model = MyModel.from_pretrained(...)`<br>`model.push_to_hub(...)` |
+| Flexibilität | Sehr flexibel.<br>Sie haben die volle Kontrolle über die Implementierung. | Weniger flexibel.<br>Ihr Framework muss eine Modellklasse haben. |
+| Wartung | Mehr Wartung, um Unterstützung für Konfiguration und neue Funktionen hinzuzufügen. Könnte auch das Beheben von Benutzerproblemen erfordern. | Weniger Wartung, da die meisten Interaktionen mit dem Hub in `huggingface_hub` implementiert sind. |
+| Dokumentation/Typ-Annotation| Manuell zu schreiben. | Teilweise durch `huggingface_hub` behandelt. |
\ No newline at end of file
diff --git a/docs/source/de/guides/manage-cache.md b/docs/source/de/guides/manage-cache.md
new file mode 100644
index 00000000..b3cc7f8c
--- /dev/null
+++ b/docs/source/de/guides/manage-cache.md
@@ -0,0 +1,545 @@
+<!--⚠️ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
+rendered properly in your Markdown viewer.
+-->
+
+# Verwalten des `huggingface_hub` Cache-Systems
+
+## Caching verstehen
+
+Das Hugging Face Hub Cache-System wurde entwickelt, um der zentrale Cache zu sein, 
+der zwischen Bibliotheken geteilt wird, welche vom Hub abhängen. Es wurde in v0.8.0 aktualisiert, 
+um das erneute Herunterladen von Dateien zwischen Revisionen zu verhindern.
+
+Das Cache-System ist wie folgt aufgebaut:
+
+```
+<CACHE_DIR>
+├─ <MODELS>
+├─ <DATASETS>
+├─ <SPACES>
+```
+
+Der `<CACHE_DIR>` ist normalerweise das Home-Verzeichnis Ihres Benutzers. Es kann jedoch mit dem 
+`cache_dir`-Argument in allen Methoden oder durch Angabe der Umgebungsvariablen 
+`HF_HOME` oder `HUGGINGFACE_HUB_CACHE` angepasst werden.
+
+Modelle, Datensätze und Räume teilen eine gemeinsame Wurzel. 
+Jedes dieser Repositories enthält den Repository-Typ, den Namensraum (Organisation oder Benutzername), 
+falls vorhanden, und den Repository-Namen:
+
+```
+<CACHE_DIR>
+├─ models--julien-c--EsperBERTo-small
+├─ models--lysandrejik--arxiv-nlp
+├─ models--bert-base-cased
+├─ datasets--glue
+├─ datasets--huggingface--DataMeasurementsFiles
+├─ spaces--dalle-mini--dalle-mini
+```
+
+Innerhalb dieser Ordner werden nun alle Dateien vom Hub heruntergeladen. Das Caching stellt sicher, 
+dass eine Datei nicht zweimal heruntergeladen wird, wenn sie bereits existiert und nicht aktualisiert wurde;
+wurde sie jedoch aktualisiert und Sie fordern die neueste Datei an, wird die neueste Datei heruntergeladen 
+(während die vorherige Datei intakt bleibt, falls Sie sie erneut benötigen).
+
+Um dies zu erreichen, enthalten alle Ordner dasselbe Grundgerüst:
+
+```
+<CACHE_DIR>
+├─ datasets--glue
+│  ├─ refs
+│  ├─ blobs
+│  ├─ snapshots
+...
+```
+
+Jeder Ordner ist so gestaltet, dass er das Folgende enthält:
+
+### Refs
+
+Der Ordner `refs` enthält Dateien, die die neueste Revision des gegebenen Verweises anzeigen. 
+Zum Beispiel, wenn wir zuvor eine Datei aus dem `main`-Branch eines Repositories abgerufen haben, 
+wird der Ordner `refs` eine Datei namens `main` enthalten, die selbst den Commit-Identifikator der aktuellen HEAD-Branch enthält.
+
+Wenn der neueste Commit von `main` den Identifikator `aaaaaa` hat, dann enthält er `aaaaaa`.
+
+Wenn derselbe Zweig mit einem neuen Commit aktualisiert wird, der den Identifikator `bbbbbb` hat, 
+wird das erneute Herunterladen einer Datei von diesem Verweis die Datei `refs/main` aktualisieren, um `bbbbbb` zu enthalten.
+
+### Blobs
+
+Der Ordner `blobs` enthält die tatsächlichen Dateien, die wir heruntergeladen haben. Der Name jeder Datei ist ihr Hash.
+
+### Snapshots
+
+Der Ordner `snapshots` enthält Symlinks zu den oben erwähnten Blobs. 
+Er besteht selbst aus mehreren Ordnern: einem pro bekannter Revision!
+
+In der obigen Erklärung hatten wir zunächst eine Datei von der Revision `aaaaaa` abgerufen, bevor wir eine Datei 
+von der Revision `bbbbbb` abgerufen haben. In dieser Situation hätten wir jetzt zwei Ordner im Ordner `snapshots`: `aaaaaa` und `bbbbbb`.
+
+In jedem dieser Ordner leben Symlinks, die die Namen der Dateien haben, die wir heruntergeladen haben. 
+Wenn wir zum Beispiel die Datei `README.md` in der Revision `aaaaaa` heruntergeladen hätten, hätten wir den folgenden Pfad:
+
+```
+<CACHE_DIR>/<REPO_NAME>/snapshots/aaaaaa/README.md
+```
+
+Diese `README.md`-Datei ist tatsächlich ein Symlink, der auf den Blob verweist, der den Hash der Datei hat.
+
+Durch das Erstellen des Grundgerüsts auf diese Weise ermöglichen wir den Mechanismus der Dateifreigabe: 
+Wenn dieselbe Datei in der Revision `bbbbbb` abgerufen wurde, hätte sie denselben Hash und die Datei müsste nicht erneut heruntergeladen werden.
+
+### .no_exist (fortgeschritten)
+
+Zusätzlich zu den Ordnern `blobs`, `refs` und `snapshots` könnten Sie in Ihrem Cache auch einen `.no_exist` Ordner finden. 
+Dieser Ordner hält fest, welche Dateien Sie einmal versucht haben herunterzuladen, die jedoch nicht auf dem Hub vorhanden sind. 
+Seine Struktur ist dieselbe wie der `snapshots` Ordner mit einem Unterordner pro bekannter Revision:
+
+```
+<CACHE_DIR>/<REPO_NAME>/.no_exist/aaaaaa/config_that_does_not_exist.json
+```
+
+Im Gegensatz zum `snapshots` Ordner handelt es sich bei den Dateien um einfache leere Dateien (keine Symlinks). 
+In diesem Beispiel existiert die Datei `"config_that_does_not_exist.json"` nicht auf dem Hub für die Revision `"aaaaaa"`. 
+Da dieser Ordner nur leere Dateien speichert, ist sein Speicherplatzverbrauch vernachlässigbar.
+
+Sie fragen sich jetzt vielleicht, warum diese Information überhaupt relevant ist? 
+In einigen Fällen versucht ein Framework, optionale Dateien für ein Modell zu laden. 
+Das Speichern der Nicht-Existenz optionaler Dateien beschleunigt das Laden eines Modells, da 1 HTTP-Anfrage pro möglicher optionaler Datei gespart wird. 
+Dies ist zum Beispiel bei `transformers` der Fall, wo jeder Tokenizer zusätzliche Dateien unterstützen kann. Beim ersten Laden des Tokenizers 
+auf Ihrem Gerät wird im Cache gespeichert, welche optionalen Dateien vorhanden sind (und welche nicht), um die Ladezeit bei den nächsten Initialisierungen zu beschleunigen.
+
+Um zu testen, ob eine Datei lokal im Cache gespeichert ist (ohne eine HTTP-Anfrage zu senden), können Sie die [`try_to_load_from_cache`] Hilfsfunktion verwenden. 
+Sie gibt entweder den Dateipfad zurück (falls vorhanden und im Cache gespeichert), das Objekt `_CACHED_NO_EXIST` (wenn die Nicht-Existenz im Cache gespeichert ist)
+oder `None` (wenn wir es nicht wissen).
+
+```python
+from huggingface_hub import try_to_load_from_cache, _CACHED_NO_EXIST
+
+filepath = try_to_load_from_cache()
+if isinstance(filepath, str):
+    # file exists and is cached
+    ...
+elif filepath is _CACHED_NO_EXIST:
+    # non-existence of file is cached
+    ...
+else:
+    # file is not cached
+    ...
+```
+
+### In der Praxis
+
+In der Praxis sollte Ihr Cache folgendermaßen aussehen:
+
+```text
+    [  96]  .
+    └── [ 160]  models--julien-c--EsperBERTo-small
+        ├── [ 160]  blobs
+        │   ├── [321M]  403450e234d65943a7dcf7e05a771ce3c92faa84dd07db4ac20f592037a1e4bd
+        │   ├── [ 398]  7cb18dc9bafbfcf74629a4b760af1b160957a83e
+        │   └── [1.4K]  d7edf6bd2a681fb0175f7735299831ee1b22b812
+        ├── [  96]  refs
+        │   └── [  40]  main
+        └── [ 128]  snapshots
+            ├── [ 128]  2439f60ef33a0d46d85da5001d52aeda5b00ce9f
+            │   ├── [  52]  README.md -> ../../blobs/d7edf6bd2a681fb0175f7735299831ee1b22b812
+            │   └── [  76]  pytorch_model.bin -> ../../blobs/403450e234d65943a7dcf7e05a771ce3c92faa84dd07db4ac20f592037a1e4bd
+            └── [ 128]  bbc77c8132af1cc5cf678da3f1ddf2de43606d48
+                ├── [  52]  README.md -> ../../blobs/7cb18dc9bafbfcf74629a4b760af1b160957a83e
+                └── [  76]  pytorch_model.bin -> ../../blobs/403450e234d65943a7dcf7e05a771ce3c92faa84dd07db4ac20f592037a1e4bd
+```
+
+### Einschränkungen
+
+Um ein effizientes Cache-System zu haben, verwendet `huggingface-hub` Symlinks. Allerdings 
+werden Symlinks nicht auf allen Maschinen unterstützt. Dies ist eine bekannte Einschränkung, 
+insbesondere bei Windows. Wenn dies der Fall ist, verwendet `huggingface_hub` nicht das `blobs/` Verzeichnis, 
+sondern speichert die Dateien direkt im `snapshots/` Verzeichnis. Dieser Workaround ermöglicht es den Nutzern, 
+Dateien vom Hub auf genau die gleiche Weise herunterzuladen und zu cachen. 
+Auch Werkzeuge zur Überprüfung und Löschung des Caches (siehe unten) werden unterstützt. 
+Allerdings ist das Cache-System weniger effizient, da eine einzelne Datei möglicherweise mehrmals heruntergeladen wird, 
+wenn mehrere Revisionen des gleichen Repos heruntergeladen werden.
+
+Wenn Sie von dem Symlink-basierten Cache-System auf einem Windows-Gerät profitieren möchten, 
+müssen Sie entweder den [Entwicklermodus aktivieren](https://docs.microsoft.com/en-us/windows/apps/get-started/enable-your-device-for-development) 
+oder Python als Administrator ausführen.
+
+Wenn Symlinks nicht unterstützt werden, wird dem Nutzer eine Warnmeldung angezeigt, um ihn darauf hinzuweisen, 
+dass er eine eingeschränkte Version des Cache-Systems verwendet. Diese Warnung kann durch Setzen der 
+Umgebungsvariable `HF_HUB_DISABLE_SYMLINKS_WARNING` auf true deaktiviert werden.
+
+## Assets zwischenspeichern
+
+Zusätzlich zum Zwischenspeichern von Dateien aus dem Hub benötigen nachgelagerte Bibliotheken
+oft das Zwischenspeichern von anderen Dateien, die in Verbindung mit HF stehen, aber nicht
+direkt von `huggingface_hub` behandelt werden (zum Beispiel: Dateien, die von GitHub heruntergeladen werden,
+vorverarbeitete Daten, Protokolle,...). Um diese Dateien, die als `assets` bezeichnet werden, zwischenzuspeichern,
+kann man [`cached_assets_path`] verwenden. Dieser kleine Helfer generiert Pfade im HF-Cache auf eine einheitliche Weise,
+basierend auf dem Namen der anfragenden Bibliothek und optional auf einem Namensraum und einem Unterordnernamen.
+Das Ziel ist, dass jede nachgelagerte Bibliothek ihre Assets auf ihre eigene Weise verwaltet
+(z.B. keine Regelung über die Struktur), solange sie im richtigen Assets-Ordner bleibt. 
+Diese Bibliotheken können dann die Werkzeuge von `huggingface_hub` nutzen, um den Cache zu verwalten, 
+insbesondere um Teile der Assets über einen CLI-Befehl zu scannen und zu löschen.
+
+```py
+from huggingface_hub import cached_assets_path
+
+assets_path = cached_assets_path(library_name="datasets", namespace="SQuAD", subfolder="download")
+something_path = assets_path / "something.json" # Machen Sie, was Sie möchten, in Ihrem Assets-Ordner!
+```
+
+<Tip>
+
+[`cached_assets_path`] ist der empfohlene Weg, um Assets zu speichern, ist jedoch nicht verpflichtend. 
+Wenn Ihre Bibliothek bereits ihren eigenen Cache verwendet, können Sie diesen gerne nutzen!
+
+</Tip>
+
+### Assets in der Praxis
+
+In der Praxis sollte Ihr Assets-Cache wie der folgende Verzeichnisbaum aussehen:
+
+```text
+    assets/
+    └── datasets/
+    │   ├── SQuAD/
+    │   │   ├── downloaded/
+    │   │   ├── extracted/
+    │   │   └── processed/
+    │   ├── Helsinki-NLP--tatoeba_mt/
+    │       ├── downloaded/
+    │       ├── extracted/
+    │       └── processed/
+    └── transformers/
+        ├── default/
+        │   ├── something/
+        ├── bert-base-cased/
+        │   ├── default/
+        │   └── training/
+    hub/
+    └── models--julien-c--EsperBERTo-small/
+        ├── blobs/
+        │   ├── (...)
+        │   ├── (...)
+        ├── refs/
+        │   └── (...)
+        └── [ 128]  snapshots/
+            ├── 2439f60ef33a0d46d85da5001d52aeda5b00ce9f/
+            │   ├── (...)
+            └── bbc77c8132af1cc5cf678da3f1ddf2de43606d48/
+                └── (...)
+```
+
+## Cache scannen
+
+Derzeit werden zwischengespeicherte Dateien nie aus Ihrem lokalen Verzeichnis gelöscht: 
+Wenn Sie eine neue Revision eines Zweiges herunterladen, werden vorherige Dateien aufbewahrt, 
+falls Sie sie wieder benötigen. Daher kann es nützlich sein, Ihr Cache-Verzeichnis zu scannen, 
+um zu erfahren, welche Repos und Revisionen den meisten Speicherplatz beanspruchen. 
+`huggingface_hub` bietet einen Helfer dafür, der über `huggingface-cli` oder in einem Python-Skript verwendet werden kann.
+
+### Cache vom Terminal aus scannen
+
+Die einfachste Möglichkeit, Ihr HF-Cache-System zu scannen, besteht darin, den Befehl `scan-cache` 
+aus dem `huggingface-cli`-Tool zu verwenden. Dieser Befehl scannt den Cache und gibt einen Bericht 
+mit Informationen wie Repo-ID, Repo-Typ, Speicherverbrauch, Referenzen und vollständigen lokalen Pfad aus.
+
+Im folgenden Ausschnitt wird ein Scan-Bericht in einem Ordner angezeigt, in dem 4 Modelle und 2 Datensätze 
+gecached sind.
+
+
+```text
+➜ huggingface-cli scan-cache
+REPO ID                     REPO TYPE SIZE ON DISK NB FILES LAST_ACCESSED LAST_MODIFIED REFS                LOCAL PATH
+--------------------------- --------- ------------ -------- ------------- ------------- ------------------- -------------------------------------------------------------------------
+glue                        dataset         116.3K       15 4 days ago    4 days ago    2.4.0, main, 1.17.0 /home/wauplin/.cache/huggingface/hub/datasets--glue
+google/fleurs               dataset          64.9M        6 1 week ago    1 week ago    refs/pr/1, main     /home/wauplin/.cache/huggingface/hub/datasets--google--fleurs
+Jean-Baptiste/camembert-ner model           441.0M        7 2 weeks ago   16 hours ago  main                /home/wauplin/.cache/huggingface/hub/models--Jean-Baptiste--camembert-ner
+bert-base-cased             model             1.9G       13 1 week ago    2 years ago                       /home/wauplin/.cache/huggingface/hub/models--bert-base-cased
+t5-base                     model            10.1K        3 3 months ago  3 months ago  main                /home/wauplin/.cache/huggingface/hub/models--t5-base
+t5-small                    model           970.7M       11 3 days ago    3 days ago    refs/pr/1, main     /home/wauplin/.cache/huggingface/hub/models--t5-small
+
+Done in 0.0s. Scanned 6 repo(s) for a total of 3.4G.
+Got 1 warning(s) while scanning. Use -vvv to print details.
+```
+
+Um einen detaillierteren Bericht zu erhalten, verwenden Sie die Option `--verbose`. 
+Für jedes Repository erhalten Sie eine Liste aller heruntergeladenen Revisionen. 
+Wie oben erläutert, werden Dateien, die sich zwischen 2 Revisionen nicht ändern, 
+dank der symbolischen Links geteilt. Das bedeutet, dass die Größe des Repositorys 
+auf der Festplatte voraussichtlich kleiner ist als die Summe der Größe jeder einzelnen Revision. 
+Zum Beispiel hat hier `bert-base-cased` 2 Revisionen von 1,4G und 1,5G, 
+aber der gesamte Festplattenspeicher beträgt nur 1,9G.
+
+```text
+➜ huggingface-cli scan-cache -v
+REPO ID                     REPO TYPE REVISION                                 SIZE ON DISK NB FILES LAST_MODIFIED REFS        LOCAL PATH
+--------------------------- --------- ---------------------------------------- ------------ -------- ------------- ----------- ----------------------------------------------------------------------------------------------------------------------------
+glue                        dataset   9338f7b671827df886678df2bdd7cc7b4f36dffd        97.7K       14 4 days ago    main, 2.4.0 /home/wauplin/.cache/huggingface/hub/datasets--glue/snapshots/9338f7b671827df886678df2bdd7cc7b4f36dffd
+glue                        dataset   f021ae41c879fcabcf823648ec685e3fead91fe7        97.8K       14 1 week ago    1.17.0      /home/wauplin/.cache/huggingface/hub/datasets--glue/snapshots/f021ae41c879fcabcf823648ec685e3fead91fe7
+google/fleurs               dataset   129b6e96cf1967cd5d2b9b6aec75ce6cce7c89e8        25.4K        3 2 weeks ago   refs/pr/1   /home/wauplin/.cache/huggingface/hub/datasets--google--fleurs/snapshots/129b6e96cf1967cd5d2b9b6aec75ce6cce7c89e8
+google/fleurs               dataset   24f85a01eb955224ca3946e70050869c56446805        64.9M        4 1 week ago    main        /home/wauplin/.cache/huggingface/hub/datasets--google--fleurs/snapshots/24f85a01eb955224ca3946e70050869c56446805
+Jean-Baptiste/camembert-ner model     dbec8489a1c44ecad9da8a9185115bccabd799fe       441.0M        7 16 hours ago  main        /home/wauplin/.cache/huggingface/hub/models--Jean-Baptiste--camembert-ner/snapshots/dbec8489a1c44ecad9da8a9185115bccabd799fe
+bert-base-cased             model     378aa1bda6387fd00e824948ebe3488630ad8565         1.5G        9 2 years ago               /home/wauplin/.cache/huggingface/hub/models--bert-base-cased/snapshots/378aa1bda6387fd00e824948ebe3488630ad8565
+bert-base-cased             model     a8d257ba9925ef39f3036bfc338acf5283c512d9         1.4G        9 3 days ago    main        /home/wauplin/.cache/huggingface/hub/models--bert-base-cased/snapshots/a8d257ba9925ef39f3036bfc338acf5283c512d9
+t5-base                     model     23aa4f41cb7c08d4b05c8f327b22bfa0eb8c7ad9        10.1K        3 1 week ago    main        /home/wauplin/.cache/huggingface/hub/models--t5-base/snapshots/23aa4f41cb7c08d4b05c8f327b22bfa0eb8c7ad9
+t5-small                    model     98ffebbb27340ec1b1abd7c45da12c253ee1882a       726.2M        6 1 week ago    refs/pr/1   /home/wauplin/.cache/huggingface/hub/models--t5-small/snapshots/98ffebbb27340ec1b1abd7c45da12c253ee1882a
+t5-small                    model     d0a119eedb3718e34c648e594394474cf95e0617       485.8M        6 4 weeks ago               /home/wauplin/.cache/huggingface/hub/models--t5-small/snapshots/d0a119eedb3718e34c648e594394474cf95e0617
+t5-small                    model     d78aea13fa7ecd06c29e3e46195d6341255065d5       970.7M        9 1 week ago    main        /home/wauplin/.cache/huggingface/hub/models--t5-small/snapshots/d78aea13fa7ecd06c29e3e46195d6341255065d5
+
+Done in 0.0s. Scanned 6 repo(s) for a total of 3.4G.
+Got 1 warning(s) while scanning. Use -vvv to print details.
+```
+
+#### Grep-Beispiel
+
+Da die Ausgabe im Tabellenformat erfolgt, können Sie sie mit `grep`-ähnlichen Tools kombinieren, 
+um die Einträge zu filtern. Hier ein Beispiel, um nur Revisionen vom Modell "t5-small" 
+auf einem Unix-basierten Gerät zu filtern.
+
+```text
+➜ eval "huggingface-cli scan-cache -v" | grep "t5-small"
+t5-small                    model     98ffebbb27340ec1b1abd7c45da12c253ee1882a       726.2M        6 1 week ago    refs/pr/1   /home/wauplin/.cache/huggingface/hub/models--t5-small/snapshots/98ffebbb27340ec1b1abd7c45da12c253ee1882a
+t5-small                    model     d0a119eedb3718e34c648e594394474cf95e0617       485.8M        6 4 weeks ago               /home/wauplin/.cache/huggingface/hub/models--t5-small/snapshots/d0a119eedb3718e34c648e594394474cf95e0617
+t5-small                    model     d78aea13fa7ecd06c29e3e46195d6341255065d5       970.7M        9 1 week ago    main        /home/wauplin/.cache/huggingface/hub/models--t5-small/snapshots/d78aea13fa7ecd06c29e3e46195d6341255065d5
+```
+
+### Den Cache von Python aus scannen
+
+Für eine erweiterte Nutzung verwenden Sie [`scan_cache_dir`], welches das von dem CLI-Tool 
+aufgerufene Python-Dienstprogramm ist.
+
+Sie können es verwenden, um einen detaillierten Bericht zu erhalten, der um 4 Datenklassen herum strukturiert ist:
+
+- [`HFCacheInfo`]: vollständiger Bericht, der von [`scan_cache_dir`] zurückgegeben wird
+- [`CachedRepoInfo`]: Informationen über ein gecachtes Repo
+- [`CachedRevisionInfo`]: Informationen über eine gecachtes Revision (z.B. "snapshot) in einem Repo
+- [`CachedFileInfo`]: Informationen über eine gecachte Datei in einem Snapshot
+
+Hier ist ein einfaches Anwendungs-Beispiel in Python. Siehe Referenz für Details.
+
+```py
+>>> from huggingface_hub import scan_cache_dir
+
+>>> hf_cache_info = scan_cache_dir()
+HFCacheInfo(
+    size_on_disk=3398085269,
+    repos=frozenset({
+        CachedRepoInfo(
+            repo_id='t5-small',
+            repo_type='model',
+            repo_path=PosixPath(...),
+            size_on_disk=970726914,
+            nb_files=11,
+            last_accessed=1662971707.3567169,
+            last_modified=1662971107.3567169,
+            revisions=frozenset({
+                CachedRevisionInfo(
+                    commit_hash='d78aea13fa7ecd06c29e3e46195d6341255065d5',
+                    size_on_disk=970726339,
+                    snapshot_path=PosixPath(...),
+                    # No `last_accessed` as blobs are shared among revisions
+                    last_modified=1662971107.3567169,
+                    files=frozenset({
+                        CachedFileInfo(
+                            file_name='config.json',
+                            size_on_disk=1197
+                            file_path=PosixPath(...),
+                            blob_path=PosixPath(...),
+                            blob_last_accessed=1662971707.3567169,
+                            blob_last_modified=1662971107.3567169,
+                        ),
+                        CachedFileInfo(...),
+                        ...
+                    }),
+                ),
+                CachedRevisionInfo(...),
+                ...
+            }),
+        ),
+        CachedRepoInfo(...),
+        ...
+    }),
+    warnings=[
+        CorruptedCacheException("Snapshots dir doesn't exist in cached repo: ..."),
+        CorruptedCacheException(...),
+        ...
+    ],
+)
+```
+
+## Cache leeren
+
+Das Durchsuchen Ihres Caches ist interessant, aber was Sie normalerweise als Nächstes tun möchten, ist
+einige Teile zu löschen, um etwas Speicherplatz auf Ihrem Laufwerk freizugeben. Dies ist möglich mit dem
+`delete-cache` CLI-Befehl. Man kann auch programmatisch den
+[`~HFCacheInfo.delete_revisions`] Helfer vom [`HFCacheInfo`] Objekt verwenden, das beim
+Durchsuchen des Caches zurückgegeben wird.
+
+### Löschstrategie
+
+Um einige Cache zu löschen, müssen Sie eine Liste von Revisionen übergeben, die gelöscht werden sollen. Das Tool wird
+eine Strategie definieren, um den Speicherplatz auf der Grundlage dieser Liste freizugeben. Es gibt ein
+[`DeleteCacheStrategy`] Objekt zurück, das beschreibt, welche Dateien und Ordner gelöscht werden. Die
+[`DeleteCacheStrategy`] zeigt Ihnen, wie viel Speicherplatz voraussichtlich frei wird.
+Sobald Sie mit der Löschung einverstanden sind, müssen Sie sie ausführen, um die Löschung wirksam zu machen.
+Um Abweichungen zu vermeiden, können Sie ein Strategieobjekt nicht manuell bearbeiten.
+
+Die Strategie zur Löschung von Revisionen ist folgende:
+
+- Der Ordner `snapshot`, der die Revisions-Symlinks enthält, wird gelöscht.
+- Blob-Dateien, die nur von zu löschenden Revisionen verlinkt werden, werden ebenfalls gelöscht.
+- Wenn eine Revision mit 1 oder mehreren `refs` verknüpft ist, werden die Referenzen gelöscht.
+- Werden alle Revisionen aus einem Repo gelöscht, wird das gesamte zwischengespeicherte Repository gelöscht.
+
+<Tip>
+
+Revisions-Hashes sind eindeutig über alle Repositories hinweg. Das bedeutet, dass Sie keine `repo_id` oder `repo_type`
+angeben müssen, wenn Sie Revisionen entfernen.
+
+</Tip>
+
+<Tip warning={true}>
+
+Wenn eine Revision im Cache nicht gefunden wird, wird sie stillschweigend ignoriert. Außerdem wird, wenn eine Datei
+oder ein Ordner beim Versuch, ihn zu löschen, nicht gefunden wird, eine Warnung protokolliert, aber es wird kein
+Fehler ausgelöst. Die Löschung wird für andere Pfade im
+[`DeleteCacheStrategy`] Objekt fortgesetzt.
+
+</Tip>
+
+### Cache vom Terminal aus leeren
+
+Der einfachste Weg, einige Revisionen aus Ihrem HF-Cache-System zu löschen, ist die Verwendung des
+`delete-cache` Befehls vom `huggingface-cli` Tool. Der Befehl hat zwei Modi. Standardmäßig wird dem Benutzer
+eine TUI (Terminal User Interface) angezeigt, um auszuwählen, welche Revisionen gelöscht werden sollen. Diese TUI
+befindet sich derzeit in der Beta-Phase, da sie nicht auf allen Plattformen getestet wurde. Wenn die TUI auf Ihrem
+Gerät nicht funktioniert, können Sie sie mit dem Flag `--disable-tui` deaktivieren.
+
+#### Verwendung der TUI
+
+Dies ist der Standardmodus. Um ihn zu nutzen, müssen Sie zuerst zusätzliche Abhängigkeiten installieren, indem Sie
+den folgenden Befehl ausführen:
+
+```
+pip install huggingface_hub["cli"]
+```
+
+Führen Sie dann den Befehl aus:
+
+```
+huggingface-cli delete-cache
+```
+
+Sie sollten jetzt eine Liste von Revisionen sehen, die Sie auswählen/abwählen können:
+
+<div class="flex justify-center">
+    <img src="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/hub/delete-cache-tui.png"/>
+</div>
+
+Anleitung:
+    - Drücken Sie die Pfeiltasten `Hoch>` und `<Runter>` auf der Tastatur, um den Cursor zu bewegen.
+    - Drücken Sie `<Leertaste>`, um einen Eintrag zu wechseln (auswählen/abwählen).
+    - Wenn eine Revision ausgewählt ist, wird die erste Zeile aktualisiert, um Ihnen anzuzeigen, wie viel Speicherplatz
+      freigegeben wird.
+    - Drücken Sie `<Enter>`, um Ihre Auswahl zu bestätigen.
+    - Wenn Sie den Vorgang abbrechen und beenden möchten, können Sie den ersten Eintrag
+      ("None of the following") auswählen. Wenn dieser Eintrag ausgewählt ist, wird der Löschvorgang abgebrochen,
+      unabhängig davon, welche anderen Einträge ausgewählt sind. Alternativ können Sie auch `<Ctrl+C> `drücken, um die
+      TUI zu verlassen.
+
+Nachdem Sie die Revisionen ausgewählt haben, die Sie löschen möchten, und `<Enter>` gedrückt haben, wird eine
+letzte Bestätigungsnachricht angezeigt. Drücken Sie erneut `<Enter>`, und die Löschung wird wirksam. Wenn Sie
+abbrechen möchten, geben Sie `n` ein.
+
+```txt
+✗ huggingface-cli delete-cache --dir ~/.cache/huggingface/hub
+? Select revisions to delete: 2 revision(s) selected.
+? 2 revisions selected counting for 3.1G. Confirm deletion ? Yes
+Start deletion.
+Done. Deleted 1 repo(s) and 0 revision(s) for a total of 3.1G.
+```
+
+#### Ohne TUI
+
+Wie bereits erwähnt, befindet sich der TUI-Modus derzeit in der Beta-Phase und ist optional. 
+Es könnte sein, dass er auf Ihrem Gerät nicht funktioniert oder dass Sie ihn nicht als praktisch finden.
+
+Ein anderer Ansatz besteht darin, das Flag `--disable-tui` zu verwenden. Der Vorgang ähnelt sehr dem vorherigen, 
+da Sie aufgefordert werden, die Liste der zu löschenden Revisionen manuell zu überprüfen. 
+Dieser manuelle Schritt findet jedoch nicht direkt im Terminal statt, sondern in einer temporären Datei, 
+die ad hoc generiert wird und die Sie manuell bearbeiten können.
+
+Diese Datei enthält alle erforderlichen Anweisungen im Kopfteil. Öffnen Sie sie in Ihrem bevorzugten Texteditor. 
+Um eine Revision auszuwählen/abzuwählen, kommentieren Sie sie einfach mit einem `#` aus oder ein. 
+Sobald die manuelle Überprüfung abgeschlossen ist und die Datei bearbeitet wurde, können Sie sie speichern. 
+Gehen Sie zurück zu Ihrem Terminal und drücken Sie `<Enter>`. Standardmäßig wird berechnet, 
+wie viel Speicherplatz mit der aktualisierten Revisionsliste freigegeben würde. 
+Sie können die Datei weiter bearbeiten oder mit `"y"` bestätigen.
+
+```sh
+huggingface-cli delete-cache --disable-tui
+```
+
+Beispiel für eine Befehlsdatei:
+
+```txt
+# INSTRUCTIONS
+# ------------
+# This is a temporary file created by running `huggingface-cli delete-cache` with the
+# `--disable-tui` option. It contains a set of revisions that can be deleted from your
+# local cache directory.
+#
+# Please manually review the revisions you want to delete:
+#   - Revision hashes can be commented out with '#'.
+#   - Only non-commented revisions in this file will be deleted.
+#   - Revision hashes that are removed from this file are ignored as well.
+#   - If `CANCEL_DELETION` line is uncommented, the all cache deletion is cancelled and
+#     no changes will be applied.
+#
+# Once you've manually reviewed this file, please confirm deletion in the terminal. This
+# file will be automatically removed once done.
+# ------------
+
+# KILL SWITCH
+# ------------
+# Un-comment following line to completely cancel the deletion process
+# CANCEL_DELETION
+# ------------
+
+# REVISIONS
+# ------------
+# Dataset chrisjay/crowd-speech-africa (761.7M, used 5 days ago)
+    ebedcd8c55c90d39fd27126d29d8484566cd27ca # Refs: main # modified 5 days ago
+
+# Dataset oscar (3.3M, used 4 days ago)
+#    916f956518279c5e60c63902ebdf3ddf9fa9d629 # Refs: main # modified 4 days ago
+
+# Dataset wikiann (804.1K, used 2 weeks ago)
+    89d089624b6323d69dcd9e5eb2def0551887a73a # Refs: main # modified 2 weeks ago
+
+# Dataset z-uo/male-LJSpeech-italian (5.5G, used 5 days ago)
+#    9cfa5647b32c0a30d0adfca06bf198d82192a0d1 # Refs: main # modified 5 days ago
+```
+
+### Cache aus Python leeren
+
+Für mehr Flexibilität können Sie auch die Methode [`~HFCacheInfo.delete_revisions`] programmatisch verwenden. 
+Hier ist ein einfaches Beispiel. Siehe Referenz für Details.
+
+```py
+>>> from huggingface_hub import scan_cache_dir
+
+>>> delete_strategy = scan_cache_dir().delete_revisions(
+...     "81fd1d6e7847c99f5862c9fb81387956d99ec7aa"
+...     "e2983b237dccf3ab4937c97fa717319a9ca1a96d",
+...     "6c0e6080953db56375760c0471a8c5f2929baf11",
+... )
+>>> print("Will free " + delete_strategy.expected_freed_size_str)
+Will free 8.6G
+
+>>> delete_strategy.execute()
+Cache deletion done. Saved 8.6G.
+```
diff --git a/docs/source/de/guides/manage-spaces.md b/docs/source/de/guides/manage-spaces.md
new file mode 100644
index 00000000..b1ec65fe
--- /dev/null
+++ b/docs/source/de/guides/manage-spaces.md
@@ -0,0 +1,366 @@
+<!--⚠️ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
+rendered properly in your Markdown viewer.
+-->
+
+# Verwalten Ihres Spaces (Bereiches)
+
+In diesem Leitfaden werden wir sehen, wie man den Laufzeitbereich eines Space 
+([Geheimnisse (Secrets)](https://huggingface.co/docs/hub/spaces-overview#managing-secrets),
+[Hardware](https://huggingface.co/docs/hub/spaces-gpus) und Speicher (Storage)) mit `huggingface_hub` verwaltet.
+
+## Ein einfaches Beispiel: Konfigurieren von Geheimnissen und Hardware
+
+Hier ist ein End-to-End-Beispiel, um einen Space auf dem Hub zu erstellen und einzurichten.
+
+**1. Einen Space auf dem Hub erstellen.**
+
+```py
+>>> from huggingface_hub import HfApi
+>>> repo_id = "Wauplin/my-cool-training-space"
+>>> api = HfApi()
+
+# Zum Beispiel mit einem Gradio SDK
+>>> api.create_repo(repo_id=repo_id, repo_type="space", space_sdk="gradio")
+```
+
+**1. (bis) Duplizieren eines Space.**
+
+Das kann nützlich sein, wenn Sie auf einem bestehenden Space aufbauen möchten, anstatt von Grund auf neu zu beginnen.
+Es ist auch nützlich, wenn Sie die Kontrolle über die Konfiguration/Einstellungen eines öffentlichen Space haben möchten. Siehe [`duplicate_space`] für weitere Details.
+
+```py
+>>> api.duplicate_space("multimodalart/dreambooth-training")
+```
+
+**2. Code mit bevorzugter Lösung hochladen.**
+
+Hier ist ein Beispiel, wie man den lokalen Ordner `src/` von Ihrem Computer in Ihren Space hochlädt:
+
+```py
+>>> api.upload_folder(repo_id=repo_id, repo_type="space", folder_path="src/")
+```
+
+In diesem Schritt sollte Ihre App bereits kostenlos auf dem Hub laufen!
+Möglicherweise möchten Sie sie jedoch weiterhin mit Geheimnissen und aufgerüsteter Hardware konfigurieren.
+
+**3. Konfigurieren von Geheimnissen und Variablen**
+
+Ihr Space könnte einige geheime Schlüssel, Tokens oder Variablen benötigen, um zu funktionieren.
+Siehe [Dokumentation](https://huggingface.co/docs/hub/spaces-overview#managing-secrets) für weitere Details.
+Zum Beispiel ein HF-Token, um einen Bilddatensatz auf den Hub hochzuladen, sobald er aus Ihrem Space generiert wurde.
+
+```py
+>>> api.add_space_secret(repo_id=repo_id, key="HF_TOKEN", value="hf_api_***")
+>>> api.add_space_variable(repo_id=repo_id, key="MODEL_REPO_ID", value="user/repo")
+```
+
+Geheimnisse und Variablen können auch gelöscht werden:
+```py
+>>> api.delete_space_secret(repo_id=repo_id, key="HF_TOKEN")
+>>> api.delete_space_variable(repo_id=repo_id, key="MODEL_REPO_ID")
+```
+
+<Tip>
+Innerhalb Ihres Space sind Geheimnisse als Umgebungsvariablen verfügbar (oder 
+Streamlit Secrets Management, wenn Streamlit verwendet wird). Keine Notwendigkeit, sie über die API abzurufen!
+</Tip>
+
+<Tip warning={true}>
+Jede Änderung in der Konfiguration Ihres Space (Geheimnisse oder Hardware) wird einen Neustart Ihrer App auslösen.
+</Tip>
+
+**Bonus: Geheimnisse und Variablen beim Erstellen oder Duplizieren des Space festlegen!**
+
+Geheimnisse und Variablen können beim Erstellen oder Duplizieren eines Space gesetzt werden:
+
+```py
+>>> api.create_repo(
+...     repo_id=repo_id,
+...     repo_type="space",
+...     space_sdk="gradio",
+...     space_secrets=[{"key"="HF_TOKEN", "value"="hf_api_***"}, ...],
+...     space_variables=[{"key"="MODEL_REPO_ID", "value"="user/repo"}, ...],
+... )
+```
+
+```py
+>>> api.duplicate_space(
+...     from_id=repo_id,
+...     secrets=[{"key"="HF_TOKEN", "value"="hf_api_***"}, ...],
+...     variables=[{"key"="MODEL_REPO_ID", "value"="user/repo"}, ...],
+... )
+```
+
+**4. Konfigurieren von Hardware**
+
+Standardmäßig wird Ihr Space kostenlos in einer CPU-Umgebung ausgeführt. Sie können die Hardware
+aktualisieren, um sie auf GPUs laufen zu lassen. Eine Zahlungskarte oder ein Community-Grant wird benötigt, um Ihren
+Space zu aktualisieren. Siehe [Dokumentation](https://huggingface.co/docs/hub/spaces-gpus) für weitere Details.
+
+```py
+# Verwenden von `SpaceHardware` Enum
+>>> from huggingface_hub import SpaceHardware
+>>> api.request_space_hardware(repo_id=repo_id, hardware=SpaceHardware.T4_MEDIUM)
+
+# Oder einfach einen String-Wert angeben
+>>> api.request_space_hardware(repo_id=repo_id, hardware="t4-medium")
+```
+
+Hardware-Aktualisierungen erfolgen nicht sofort, da Ihr Space auf unseren Servern neu geladen werden muss.
+Jederzeit können Sie überprüfen, auf welcher Hardware Ihr Space läuft, um zu sehen, ob Ihre Anfrage
+erfüllt wurde.
+
+```py
+>>> runtime = api.get_space_runtime(repo_id=repo_id)
+>>> runtime.stage
+"RUNNING_BUILDING"
+>>> runtime.hardware
+"cpu-basic"
+>>> runtime.requested_hardware
+"t4-medium"
+```
+
+Sie verfügen jetzt über einen vollständig konfigurierten Space. Stellen Sie sicher, dass Sie Ihren Space wieder auf "cpu-classic"
+zurückstufen, wenn Sie ihn nicht mehr verwenden.
+
+**Bonus: Hardware beim Erstellen oder Duplizieren des Space anfordern!**
+
+Aktualisierte Hardware wird Ihrem Space automatisch zugewiesen, sobald er erstellt wurde.
+
+```py
+>>> api.create_repo(
+...     repo_id=repo_id,
+...     repo_type="space",
+...     space_sdk="gradio"
+...     space_hardware="cpu-upgrade",
+...     space_storage="small",
+...     space_sleep_time="7200", # 2 hours in secs
+... )
+```
+
+```py
+>>> api.duplicate_space(
+...     from_id=repo_id,
+...     hardware="cpu-upgrade",
+...     storage="small",
+...     sleep_time="7200", # 2 hours in secs
+... )
+```
+
+**5. Pausieren und Neustarten des Spaces**
+
+Standardmäßig, wenn Ihr Space auf augewerteter Hardware läuft, wird er nie angehalten. Um jedoch zu vermeiden, dass Ihnen Gebühren berechnet werden,
+möchten Sie ihn möglicherweise anhalten, wenn Sie ihn nicht verwenden. Dies ist mit [`pause_space`] möglich. Ein pausierter Space bleibt
+inaktiv, bis der Besitzer des Space ihn entweder über die Benutzeroberfläche oder über die API mit [`restart_space`] neu startet.
+Weitere Informationen zum Pausenmodus finden Sie in [diesem Abschnitt](https://huggingface.co/docs/hub/spaces-gpus#pause).
+
+```py
+# Pausieren des Space, um Gebühren zu vermeiden
+>>> api.pause_space(repo_id=repo_id)
+# (...)
+# Erneut starten, wenn benötigt
+>>> api.restart_space(repo_id=repo_id)
+```
+
+Eine weitere Möglichkeit besteht darin, für Ihren Space einen Timeout festzulegen. Wenn Ihr Space länger als die Timeout-Dauer inaktiv ist,
+wird er in den Schlafmodus versetzt. Jeder Besucher, der auf Ihren Space zugreift, wird ihn wieder starten. Sie können ein Timeout mit
+[`set_space_sleep_time`] festlegen. Weitere Informationen zum Schlafmodus finden Sie in [diesem Abschnitt](https://huggingface.co/docs/hub/spaces-gpus#sleep-time).
+
+```py
+# Setzen den Space nach 1h Inaktivität in den Schlafmodus
+>>> api.set_space_sleep_time(repo_id=repo_id, sleep_time=3600)
+```
+
+Hinweis: Wenn Sie eine 'cpu-basic' Hardware verwenden, können Sie keine benutzerdefinierte Schlafzeit konfigurieren. Ihr Space wird automatisch
+nach 48h Inaktivität pausiert.
+
+**Bonus: Schlafzeit festlegen, während der Hardwareanforderung**
+
+Aufgewertete Hardware wird Ihrem Space automatisch zugewiesen, sobald er erstellt wurde.
+
+```py
+>>> api.request_space_hardware(repo_id=repo_id, hardware=SpaceHardware.T4_MEDIUM, sleep_time=3600)
+```
+
+**Bonus: Schlafzeit beim Erstellen oder Duplizieren des Space festlegen!**
+
+```py
+>>> api.create_repo(
+...     repo_id=repo_id,
+...     repo_type="space",
+...     space_sdk="gradio"
+...     space_hardware="t4-medium",
+...     space_sleep_time="3600",
+... )
+```
+
+```py
+>>> api.duplicate_space(
+...     from_id=repo_id,
+...     hardware="t4-medium",
+...     sleep_time="3600",
+... )
+```
+
+**6. Dem Space dauerhaften Speicherplatz hinzufügen**
+
+Sie können den Speicher-Tier Ihrer Wahl auswählen, um auf Festplattenspeicher zuzugreifen, der Neustarts Ihres Space überdauert. Dies bedeutet, dass Sie von der Festplatte lesen und darauf schreiben können, wie Sie es von einer herkömmlichen Festplatte gewöhnt sind. Weitere Informationen finden Sie in der [Dokumentation](https://huggingface.co/docs/hub/spaces-storage#persistent-storage) .
+
+```py
+>>> from huggingface_hub import SpaceStorage
+>>> api.request_space_storage(repo_id=repo_id, storage=SpaceStorage.LARGE)
+```
+
+Sie können auch Ihren Speicher löschen und dabei alle Daten dauerhaft verlieren.
+```py
+>>> api.delete_space_storage(repo_id=repo_id)
+```
+
+Hinweis: Nachdem Ihnen ein Speicher-Tier zugewiesen wurde, können Sie diesen nicht mehr herabsetzen. Um dies zu tun, müssen Sie zuerst den Speicher löschen und dann den gewünschten Tier anfordern.
+
+**Bonus: Speicher beim Erstellen oder Duplizieren des Space anfordern!**
+
+```py
+>>> api.create_repo(
+...     repo_id=repo_id,
+...     repo_type="space",
+...     space_sdk="gradio"
+...     space_storage="large",
+... )
+```
+
+```py
+>>> api.duplicate_space(
+...     from_id=repo_id,
+...     storage="large",
+... )
+```
+
+## Fortgeschritten: Temporäres Space Upgrade
+
+Spaces ermöglichen viele verschiedene Einsatzmöglichkeiten. Manchmal möchten Sie vielleicht einen Space vorübergehend auf einer
+bestimmten Hardware ausführen, etwas tun und ihn dann herunterfahren. In diesem Abschnitt werden wir untersuchen, wie Sie die 
+Vorteile von Spaces nutzen können, um ein Modell auf Abruf zu finetunen. Dies ist nur eine Möglichkeit, dieses spezielle Problem zu 
+lösen. Es sollte als Vorschlag betrachtet und an Ihren Anwendungsfall angepasst werden.
+
+
+Nehmen wir an, wir haben einen Space, um ein Modell zu finetunen. 
+Es handelt sich um eine Gradio-App, die ein Modell-Id und eine Dataset-Id als Eingabe nimmt. Der Ablauf sieht folgendermaßen aus:
+
+0. (Den Benutzer nach einem Modell und einem Datensatz auffordern)
+1. Das Modell aus dem Hub laden.
+2. Den Datensatz aus dem Hub laden.
+3. Das Modell mit dem Datensatz finetunen.
+4. Das neue Modell auf den Hub hochladen.
+
+Schritt 3 erfordert eine spezielle Hardware, aber Sie möchten nicht, dass Ihr Space die ganze Zeit 
+auf einer kostenpflichtigen GPU läuft. Eine Lösung besteht darin, dynamisch Hardware für das Training 
+anzufordern und es anschließend herunterzufahren. Da das Anfordern von Hardware Ihren Space neu startet, 
+muss sich Ihre App irgendwie die aktuelle Aufgabe "merken", die sie ausführt. 
+Es gibt mehrere Möglichkeiten, dies zu tun. In diesem Leitfaden sehen wir eine Lösung, 
+bei der ein Datensatz als "Aufgabenplaner (task scheduler)" verwendet wird.
+
+### App-Grundgerüst
+
+So würde Ihre App aussehen. Beim Start überprüfen, ob eine Aufgabe geplant ist und ob ja, 
+führen Sie sie auf der richtigen Hardware aus. Ist die Aufgabe erledigt, 
+setzen Sie die Hardware zurück auf den kostenlosen CPU-Plan und fordern den Benutzer auf, 
+eine neue Aufgabe anzufordern.
+
+<Tip warning={true}>
+Ein solcher Workflow unterstützt keinen gleichzeitigen Zugriff wie normale Demos. 
+Insbesondere wird die Schnittstelle deaktiviert, wenn das Training stattfindet. 
+Es ist vorzuziehen, Ihr Repo auf privat zu setzen, um sicherzustellen, dass Sie der einzige Benutzer sind.
+</Tip>
+
+```py
+# Für den Space wird Ihr Token benötigt, um Hardware anzufordern: Legen Sie es als Geheimnis fest!
+HF_TOKEN = os.environ.get("HF_TOKEN")
+
+# Eigene repo_id des Space
+TRAINING_SPACE_ID = "Wauplin/dreambooth-training"
+
+from huggingface_hub import HfApi, SpaceHardware
+api = HfApi(token=HF_TOKEN)
+
+# Beim Start des Space überprüfen, ob eine Aufgabe geplant ist. Wenn ja, finetunen Sie das Modell. 
+# Wenn nicht, zeigen Sie eine Schnittstelle an, um eine neue Aufgabe anzufordern.
+task = get_task()
+if task is None:
+    # Starten der Gradio-App
+    def gradio_fn(task):
+        # Bei Benutzeranfrage, Aufgabe hinzufügen und Hardware anfordern
+        add_task(task)
+        api.request_space_hardware(repo_id=TRAINING_SPACE_ID, hardware=SpaceHardware.T4_MEDIUM)
+
+    gr.Interface(fn=gradio_fn, ...).launch()
+else:
+    runtime = api.get_space_runtime(repo_id=TRAINING_SPACE_ID)
+    # Überprüfen, ob der Space mit einer GPU geladen ist.
+    if runtime.hardware == SpaceHardware.T4_MEDIUM:
+        # Wenn ja, finetunen des Basismodells auf den Datensatz!
+        train_and_upload(task)
+
+        # Dann die Aufgabe als "DONE / ERLEDIGT" markieren
+        mark_as_done(task)
+
+        # NICHT VERGESSEN: CPU-Hardware zurück setzen
+        api.request_space_hardware(repo_id=TRAINING_SPACE_ID, hardware=SpaceHardware.CPU_BASIC)
+    else:
+        api.request_space_hardware(repo_id=TRAINING_SPACE_ID, hardware=SpaceHardware.T4_MEDIUM)
+```
+
+### Aufgabenplaner (Task scheduler)
+
+Das Planen von Aufgaben kann auf viele Arten erfolgen. Hier ist ein Beispiel, 
+wie es mit einer einfachen CSV gemacht werden könnte, die als Datensatz gespeichert ist.
+
+```py
+# Dataset-ID, in der eine `tasks.csv` Datei die auszuführenden Aufgaben enthält. 
+# Hier ist ein einfaches Beispiel für `tasks.csv`, das Eingaben (Basis-Modell und Datensatz) 
+# und Status (PENDING / AUSSTEHEND oder DONE / ERLEDIGT) enthält.
+#     multimodalart/sd-fine-tunable,Wauplin/concept-1,DONE
+#     multimodalart/sd-fine-tunable,Wauplin/concept-2,PENDING
+TASK_DATASET_ID = "Wauplin/dreambooth-task-scheduler"
+
+def _get_csv_file():
+    return hf_hub_download(repo_id=TASK_DATASET_ID, filename="tasks.csv", repo_type="dataset", token=HF_TOKEN)
+
+def get_task():
+    with open(_get_csv_file()) as csv_file:
+        csv_reader = csv.reader(csv_file, delimiter=',')
+        for row in csv_reader:
+            if row[2] == "PENDING":
+                return row[0], row[1] # model_id, dataset_id
+
+def add_task(task):
+    model_id, dataset_id = task
+    with open(_get_csv_file()) as csv_file:
+        with open(csv_file, "r") as f:
+            tasks = f.read()
+
+    api.upload_file(
+        repo_id=repo_id,
+        repo_type=repo_type,
+        path_in_repo="tasks.csv",
+        # Schnelle und einfache Möglichkeit, eine Aufgabe hinzuzufügen
+        path_or_fileobj=(tasks + f"\n{model_id},{dataset_id},PENDING").encode()
+    )
+
+def mark_as_done(task):
+    model_id, dataset_id = task
+    with open(_get_csv_file()) as csv_file:
+        with open(csv_file, "r") as f:
+            tasks = f.read()
+
+    api.upload_file(
+        repo_id=repo_id,
+        repo_type=repo_type,
+        path_in_repo="tasks.csv",
+        # Schnelle und einfache Möglichkeit, die Aufgabe als DONE / ERLEDIGT zu markieren
+        path_or_fileobj=tasks.replace(
+            f"{model_id},{dataset_id},PENDING",
+            f"{model_id},{dataset_id},DONE"
+        ).encode()
+    )
+```
\ No newline at end of file
diff --git a/docs/source/de/guides/model-cards.md b/docs/source/de/guides/model-cards.md
new file mode 100644
index 00000000..b6a73417
--- /dev/null
+++ b/docs/source/de/guides/model-cards.md
@@ -0,0 +1,323 @@
+<!--⚠️ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
+rendered properly in your Markdown viewer.
+-->
+
+# Erstellen und Teilen von Model Cards
+
+Die `huggingface_hub`-Bibliothek bietet eine Python-Schnittstelle zum Erstellen, Teilen und Aktualisieren von Model Cards. Besuchen Sie [die spezielle Dokumentationsseite](https://huggingface.co/docs/hub/models-cards) für einen tieferen Einblick in das, was Model Cards im Hub sind und wie sie unter der Haube funktionieren.
+
+<Tip>
+
+[Neu (Beta)! Probieren Sie unsere experimentelle Model Card Creator App aus](https://huggingface.co/spaces/huggingface/Model_Cards_Writing_Tool)
+
+</Tip>
+
+## Eine Model Card vom Hub laden
+
+Um eine bestehende Karte vom Hub zu laden, können Sie die Funktion [`ModelCard.load`] verwenden. Hier laden wir die Karte von [`nateraw/vit-base-beans`](https://huggingface.co/nateraw/vit-base-beans).
+
+```python
+from huggingface_hub import ModelCard
+
+card = ModelCard.load('nateraw/vit-base-beans')
+```
+
+Diese Karte hat einige nützliche Attribute, auf die Sie zugreifen oder die Sie nutzen möchten:
+
+- `card.data`: Gibt eine [`ModelCardData`]-Instanz mit den Metadaten der Model Card zurück. Rufen Sie `.to_dict()` auf diese Instanz auf, um die Darstellung als Wörterbuch zu erhalten.
+- `card.text`: Gibt den Textinhalt der Karte *ohne den Metadatenkopf* zurück.
+- `card.content`: Gibt den Textinhalt der Karte, *einschließlich des Metadatenkopfes*, zurück.
+
+## Model Cards erstellen
+
+### Aus Text
+
+Um eine Model Card aus Text zu initialisieren, übergeben Sie einfach den Textinhalt der Karte an `ModelCard` beim Initialisieren.
+
+```python
+content = """
+---
+language: en
+license: mit
+---
+
+# My Model Card
+"""
+
+card = ModelCard(content)
+card.data.to_dict() == {'language': 'en', 'license': 'mit'}  # True
+```
+
+Eine andere Möglichkeit besteht darin, dies mit f-Strings zu tun. Im folgenden Beispiel:
+
+- Verwenden wir [`ModelCardData.to_yaml`], um die von uns definierten Metadaten in YAML umzuwandeln, damit wir sie in die Model Card einfügen können.
+- Zeigen wir, wie Sie eine Vorlagenvariable über Python f-Strings verwenden könnten.
+
+```python
+card_data = ModelCardData(language='en', license='mit', library='timm')
+
+example_template_var = 'nateraw'
+content = f"""
+---
+{ card_data.to_yaml() }
+---
+
+# My Model Card
+
+This model created by [@{example_template_var}](https://github.com/{example_template_var})
+"""
+
+card = ModelCard(content)
+print(card)
+```
+
+Das obige Beispiel würde uns eine Karte hinterlassen, die so aussieht:
+
+```
+---
+language: en
+license: mit
+library: timm
+---
+
+# My Model Card
+
+This model created by [@nateraw](https://github.com/nateraw)
+```
+
+### Aus einem Jinja-Template
+
+Wenn Sie `Jinja2` installiert haben, können Sie Model Cards aus einer Jinja-Vorlagendatei erstellen. Schauen wir uns ein einfaches Beispiel an:
+
+```python
+from pathlib import Path
+
+from huggingface_hub import ModelCard, ModelCardData
+
+# Definieren Sie Ihre Jinja-Vorlage
+template_text = """
+---
+{{ card_data }}
+---
+
+# Model Card for MyCoolModel
+
+This model does this and that.
+
+This model was created by [@{{ author }}](https://hf.co/{{author}}).
+""".strip()
+
+# Schreiben Sie die Vorlage in eine Datei
+Path('custom_template.md').write_text(template_text)
+
+# Definieren Sie die Metadaten der Karte
+card_data = ModelCardData(language='en', license='mit', library_name='keras')
+
+# Erstellen Sie eine Karte aus der Vorlage und übergeben Sie dabei alle gewünschten Jinja-Vorlagenvariablen.
+# In unserem Fall übergeben wir "author"
+card = ModelCard.from_template(card_data, template_path='custom_template.md', author='nateraw')
+card.save('my_model_card_1.md')
+print(card)
+```
+
+Das resultierende Karten-Markdown sieht so aus:
+
+```
+---
+language: en
+license: mit
+library_name: keras
+---
+
+# Model Card for MyCoolModel
+
+This model does this and that.
+
+This model was created by [@nateraw](https://hf.co/nateraw).
+```
+
+Wenn Sie Daten in card.data aktualisieren, wird dies in der Karte selbst widergespiegelt.
+
+```
+card.data.library_name = 'timm'
+card.data.language = 'fr'
+card.data.license = 'apache-2.0'
+print(card)
+```
+
+Jetzt, wie Sie sehen können, wurde der Metadatenkopf aktualisiert:
+
+```
+---
+language: fr
+license: apache-2.0
+library_name: timm
+---
+
+# Model Card for MyCoolModel
+
+This model does this and that.
+
+This model was created by [@nateraw](https://hf.co/nateraw).
+```
+
+Wenn Sie die Karteninformationen aktualisieren, können Sie durch Aufrufen von [`ModelCard.validate`] überprüfen, ob die Karte immer noch gültig für den Hub ist. Dies stellt sicher, dass die Karte alle Validierungsregeln erfüllt, die im Hugging Face Hub eingerichtet wurden.
+
+### Aus dem Standard-Template
+
+Anstatt Ihr eigenes Template zu verwenden, können Sie auch das [Standard-Template](https://github.com/huggingface/huggingface_hub/blob/main/src/huggingface_hub/templates/modelcard_template.md) verwenden, welches eine vollständig ausgestattete Model Card mit vielen Abschnitten ist, die Sie vielleicht ausfüllen möchten. Unter der Haube verwendet es [Jinja2](https://jinja.palletsprojects.com/en/3.1.x/), um eine Vorlagendatei auszufüllen.
+
+<Tip>
+
+Beachten Sie, dass Sie Jinja2 installiert haben müssen, um `from_template` zu verwenden. Sie können dies mit `pip install Jinja2` tun.
+
+</Tip>
+
+```python
+card_data = ModelCardData(language='en', license='mit', library_name='keras')
+card = ModelCard.from_template(
+    card_data,
+    model_id='my-cool-model',
+    model_description="this model does this and that",
+    developers="Nate Raw",
+    repo="https://github.com/huggingface/huggingface_hub",
+)
+card.save('my_model_card_2.md')
+print(card)
+```
+
+## Model Cards teilen
+
+Wenn Sie mit dem Hugging Face Hub authentifiziert sind (entweder durch Verwendung von `huggingface-cli login` oder [`login`]), können Sie Karten zum Hub hinzufügen, indem Sie einfach [`ModelCard.push_to_hub`] aufrufen. Schauen wir uns an, wie das funktioniert...
+
+Zuerst erstellen wir ein neues Repo namens 'hf-hub-modelcards-pr-test' im Namensraum des authentifizierten Benutzers:
+
+```python
+from huggingface_hub import whoami, create_repo
+
+user = whoami()['name']
+repo_id = f'{user}/hf-hub-modelcards-pr-test'
+url = create_repo(repo_id, exist_ok=True)
+```
+
+Dann erstellen wir eine Karte aus der Standardvorlage (genau wie die oben definierte):
+
+```python
+card_data = ModelCardData(language='en', license='mit', library_name='keras')
+card = ModelCard.from_template(
+    card_data,
+    model_id='my-cool-model',
+    model_description="this model does this and that",
+    developers="Nate Raw",
+    repo="https://github.com/huggingface/huggingface_hub",
+)
+```
+
+Schließlich laden wir das zum Hub hoch:
+
+```python
+card.push_to_hub(repo_id)
+```
+
+Sie können die resultierende Karte [hier](https://huggingface.co/nateraw/hf-hub-modelcards-pr-test/blob/main/README.md) überprüfen.
+
+Wenn Sie eine Karte als Pull-Request hinzufügen möchten, können Sie beim Aufruf von `push_to_hub` einfach `create_pr=True` angeben:
+
+```python
+card.push_to_hub(repo_id, create_pr=True)
+```
+
+Ein PR, der mit diesem Befehl erstellt wurde, kann [hier](https://huggingface.co/nateraw/hf-hub-modelcards-pr-test/discussions/3) aufgerufen werden.
+
+### Evaluierungsergebnisse einbeziehen
+
+Um Evaluierungsergebnisse in den Metadaten `model-index` einzufügen, können Sie ein [`EvalResult`] oder eine Liste von `EvalResult` mit Ihren zugehörigen Evaluierungsergebnissen übergeben. Im Hintergrund wird der `model-index` erstellt, wenn Sie `card.data.to_dict()` aufrufen. Weitere Informationen darüber, wie dies funktioniert, finden Sie in [diesem Abschnitt der Hub-Dokumentation](https://huggingface.co/docs/hub/models-cards#evaluation-results).
+
+<Tip>
+
+Beachten Sie, dass die Verwendung dieser Funktion erfordert, dass Sie das Attribut `model_name` in [`ModelCardData`] einbeziehen.
+
+</Tip>
+
+```python
+card_data = ModelCardData(
+    language='en',
+    license='mit',
+    model_name='my-cool-model',
+    eval_results = EvalResult(
+        task_type='image-classification',
+        dataset_type='beans',
+        dataset_name='Beans',
+        metric_type='accuracy',
+        metric_value=0.7
+    )
+)
+
+card = ModelCard.from_template(card_data)
+print(card.data)
+```
+
+Die resultierende `card.data` sollte so aussehen:
+
+```
+language: en
+license: mit
+model-index:
+- name: my-cool-model
+  results:
+  - task:
+      type: image-classification
+    dataset:
+      name: Beans
+      type: beans
+    metrics:
+    - type: accuracy
+      value: 0.7
+```
+Wenn Sie mehr als ein Evaluierungsergebnis teilen möchten, übergeben Sie einfach eine Liste von `EvalResult`:
+
+```python
+card_data = ModelCardData(
+    language='en',
+    license='mit',
+    model_name='my-cool-model',
+    eval_results = [
+        EvalResult(
+            task_type='image-classification',
+            dataset_type='beans',
+            dataset_name='Beans',
+            metric_type='accuracy',
+            metric_value=0.7
+        ),
+        EvalResult(
+            task_type='image-classification',
+            dataset_type='beans',
+            dataset_name='Beans',
+            metric_type='f1',
+            metric_value=0.65
+        )
+    ]
+)
+card = ModelCard.from_template(card_data)
+card.data
+```
+
+Dies sollte Ihnen die folgenden `card.data` hinterlassen:
+
+```
+language: en
+license: mit
+model-index:
+- name: my-cool-model
+  results:
+  - task:
+      type: image-classification
+    dataset:
+      name: Beans
+      type: beans
+    metrics:
+    - type: accuracy
+      value: 0.7
+    - type: f1
+      value: 0.65
+```
\ No newline at end of file
diff --git a/docs/source/de/guides/overview.md b/docs/source/de/guides/overview.md
new file mode 100644
index 00000000..3d74d20e
--- /dev/null
+++ b/docs/source/de/guides/overview.md
@@ -0,0 +1,121 @@
+<!--⚠️ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
+rendered properly in your Markdown viewer.
+-->
+
+# Anleitungen
+
+In diesem Abschnitt finden Sie praktische Anleitungen, die Ihnen helfen, ein bestimmtes Ziel zu erreichen. Schauen Sie sich diese Anleitungen an, um zu lernen, wie Sie huggingface_hub verwenden, um reale Probleme zu lösen:
+
+<div class="mt-10">
+  <div class="w-full flex flex-col space-y-4 md:space-y-0 md:grid md:grid-cols-3 md:gap-y-4 md:gap-x-5">
+
+    <a class="!no-underline border dark:border-gray-700 p-5 rounded-lg shadow hover:shadow-lg"
+       href="./repository">
+      <div class="w-full text-center bg-gradient-to-br from-indigo-400 to-indigo-500 rounded-lg py-1.5 font-semibold mb-5 text-white text-lg leading-relaxed">
+        Repository
+      </div><p class="text-gray-700">
+        Wie erstelle ich ein Repository im Hub? Wie konfiguriere ich es? Wie interagiere ich damit?
+      </p>
+    </a>
+    
+    <a class="!no-underline border dark:border-gray-700 p-5 rounded-lg shadow hover:shadow-lg"
+       href="./download">
+      <div class="w-full text-center bg-gradient-to-br from-indigo-400 to-indigo-500 rounded-lg py-1.5 font-semibold mb-5 text-white text-lg leading-relaxed">
+        Dateien herunterladen
+      </div><p class="text-gray-700">
+        Wie lade ich eine Datei vom Hub herunter? Wie lade ich ein Repository herunter?
+      </p>
+    </a>
+
+    <a class="!no-underline border dark:border-gray-700 p-5 rounded-lg shadow hover:shadow-lg"
+       href="./upload">
+      <div class="w-full text-center bg-gradient-to-br from-indigo-400 to-indigo-500 rounded-lg py-1.5 font-semibold mb-5 text-white text-lg leading-relaxed">
+        Dateien hochladen
+      </div><p class="text-gray-700">
+        Wie lade ich eine Datei oder einen Ordner hoch? Wie nehme ich Änderungen an einem bestehenden Repository im Hub vor?
+      </p>
+    </a>
+
+    <a class="!no-underline border dark:border-gray-700 p-5 rounded-lg shadow hover:shadow-lg"
+       href="./search">
+      <div class="w-full text-center bg-gradient-to-br from-indigo-400 to-indigo-500 rounded-lg py-1.5 font-semibold mb-5 text-white text-lg leading-relaxed">
+        Suche
+      </div><p class="text-gray-700">
+        Wie suche ich effizient in den über 200k öffentlichen Modellen, Datensätzen und Spaces?
+      </p>
+    </a>
+
+    <a class="!no-underline border dark:border-gray-700 p-5 rounded-lg shadow hover:shadow-lg"
+       href="./hf_file_system">
+      <div class="w-full text-center bg-gradient-to-br from-indigo-400 to-indigo-500 rounded-lg py-1.5 font-semibold mb-5 text-white text-lg leading-relaxed">
+        HfDateiSystem
+      </div><p class="text-gray-700">
+        Wie interagiere ich mit dem Hub über eine benutzerfreundliche Schnittstelle, die Pythons Dateischnittstelle imitiert?
+      </p>
+    </a>
+
+    <a class="!no-underline border dark:border-gray-700 p-5 rounded-lg shadow hover:shadow-lg"
+       href="./inference">
+      <div class="w-full text-center bg-gradient-to-br from-indigo-400 to-indigo-500 rounded-lg py-1.5 font-semibold mb-5 text-white text-lg leading-relaxed">
+        Inferenz
+      </div><p class="text-gray-700">
+        Wie mache ich Vorhersagen mit der beschleunigten Inference-API?
+      </p>
+    </a>
+
+    <a class="!no-underline border dark:border-gray-700 p-5 rounded-lg shadow hover:shadow-lg"
+       href="./community">
+      <div class="w-full text-center bg-gradient-to-br from-indigo-400 to-indigo-500 rounded-lg py-1.5 font-semibold mb-5 text-white text-lg leading-relaxed">
+        Community Tab
+      </div><p class="text-gray-700">
+        Wie interagiere ich mit dem Community-Tab (Diskussionen und Pull-Requests)?
+      </p>
+    </a>
+
+    <a class="!no-underline border dark:border-gray-700 p-5 rounded-lg shadow hover:shadow-lg"
+       href="./manage-cache">
+      <div class="w-full text-center bg-gradient-to-br from-indigo-400 to-indigo-500 rounded-lg py-1.5 font-semibold mb-5 text-white text-lg leading-relaxed">
+        Cache
+      </div><p class="text-gray-700">
+        Wie funktioniert das Cache-System? Wie profitiere ich davon?
+      </p>
+    </a>
+
+    <a class="!no-underline border dark:border-gray-700 p-5 rounded-lg shadow hover:shadow-lg"
+       href="./model-cards">
+      <div class="w-full text-center bg-gradient-to-br from-indigo-400 to-indigo-500 rounded-lg py-1.5 font-semibold mb-5 text-white text-lg leading-relaxed">
+        Model Cards
+      </div><p class="text-gray-700">
+        Wie erstelle und teile ich Model Cards?
+      </p>
+    </a>
+
+    <a class="!no-underline border dark:border-gray-700 p-5 rounded-lg shadow hover:shadow-lg"
+       href="./manage-spaces">
+      <div class="w-full text-center bg-gradient-to-br from-indigo-400 to-indigo-500 rounded-lg py-1.5 font-semibold mb-5 text-white text-lg leading-relaxed">
+        Verwalten meines Spaces
+      </div><p class="text-gray-700">
+        Wie verwalte ich die Hardware und Konfiguration meines Spaces?
+      </p>
+    </a>
+
+    <a class="!no-underline border dark:border-gray-700 p-5 rounded-lg shadow hover:shadow-lg"
+       href="./integrations">
+      <div class="w-full text-center bg-gradient-to-br from-indigo-400 to-indigo-500 rounded-lg py-1.5 font-semibold mb-5 text-white text-lg leading-relaxed">
+        Als Bibliothek integrieren
+      </div><p class="text-gray-700">
+        Was bedeutet es, eine Bibliothek mit dem Hub zu integrieren? Und wie macht man das?
+      </p>
+    </a>
+
+    <a class="!no-underline border dark:border-gray-700 p-5 rounded-lg shadow hover:shadow-lg"
+       href="./webhooks_server">
+      <div class="w-full text-center bg-gradient-to-br from-indigo-400 to-indigo-500 rounded-lg py-1.5 font-semibold mb-5 text-white text-lg leading-relaxed">
+        Webhooks server
+      </div><p class="text-gray-700">
+        Wie erstelle ich einen Server zum Empfangen von Webhooks und setze ihn als Space ein?
+      </p>
+    </a>
+
+  </div>
+</div>
diff --git a/docs/source/de/guides/repository.md b/docs/source/de/guides/repository.md
new file mode 100644
index 00000000..1cbad3a6
--- /dev/null
+++ b/docs/source/de/guides/repository.md
@@ -0,0 +1,219 @@
+<!--⚠️ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
+rendered properly in your Markdown viewer.
+-->
+
+# Ein Repository erstellen und verwalten
+
+Das Hugging Face Hub besteht aus einer Sammlung von Git-Repositories. [Git](https://git-scm.com/) ist ein in der Softwareentwicklung weit verbreitetes Tool, um Projekte bei der Zusammenarbeit einfach zu versionieren. Dieser Leitfaden zeigt Ihnen, wie Sie mit den Repositories auf dem Hub interagieren, insbesondere:
+
+- Ein Repository erstellen und löschen.
+- Zweige (Branches) und Tags verwalten.
+- Ihr Repository umbenennen.
+- Die Sichtbarkeit Ihres Repositories aktualisieren.
+- Eine lokale Kopie Ihres Repositories verwalten.
+
+<Tip warning={true}>
+
+Wenn Sie es gewohnt sind, mit Plattformen wie GitLab/GitHub/Bitbucket zu arbeiten, könnte Ihr erster Instinkt sein, die `git` CLI zu verwenden, um Ihr Repo zu klonen (`git clone`), Änderungen zu übernehmen (`git add`, `git commit`) und diese hochzuladen (`git push`). Dies ist beim Verwenden des Hugging Face Hubs gültig. Softwareentwicklung und maschinelles Lernen haben jedoch nicht dieselben Anforderungen und Arbeitsabläufe. Modell-Repositories könnten große Modellgewichtsdateien für verschiedene Frameworks und Tools beinhalten, sodass das Klonen des Repositories dazu führen kann, dass Sie große lokale Ordner mit massiven Größen pflegen. Daher kann es effizienter sein, unsere benutzerdefinierten HTTP-Methoden zu verwenden. Sie können unsere [Git vs HTTP Paradigma](../concepts/git_vs_http) Erklärungsseite für weitere Details lesen.
+
+</Tip>
+
+Wenn Sie ein Repository auf dem Hub erstellen und verwalten möchten, muss Ihr Computer angemeldet sein. Wenn Sie es nicht sind, beziehen Sie sich bitte auf [diesen Abschnitt](../quick-start#login). Im Rest dieses Leitfadens gehen wir davon aus, dass Ihr Computer angemeldet ist.
+
+## Erstellung und Löschung von Repos
+
+Der erste Schritt besteht darin, zu wissen, wie man Repositories erstellt und löscht. Sie können nur Repositories verwalten, die Ihnen gehören (unter Ihrem Benutzernamensraum) oder von Organisationen, in denen Sie Schreibberechtigungen haben.
+
+### Ein Repository erstellen
+
+Erstellen Sie ein leeres Repository mit [`create_repo`] und geben Sie ihm mit dem Parameter `repo_id` einen Namen. Die `repo_id` ist Ihr Namensraum gefolgt vom Repository-Namen: `username_or_org/repo_name`.
+
+```py
+>>> from huggingface_hub import create_repo
+>>> create_repo("lysandre/test-model")
+'https://huggingface.co/lysandre/test-model'
+```
+
+Standardmäßig erstellt [`create_repo`] ein Modellrepository. Sie können jedoch den Parameter `repo_type` verwenden, um einen anderen Repository-Typ anzugeben. Wenn Sie beispielsweise ein Dataset-Repository erstellen möchten:
+
+```py
+>>> from huggingface_hub import create_repo
+>>> create_repo("lysandre/test-dataset", repo_type="dataset")
+'https://huggingface.co/datasets/lysandre/test-dataset'
+```
+
+Wenn Sie ein Repository erstellen, können Sie mit dem Parameter `private` die Sichtbarkeit Ihres Repositories festlegen.
+
+```py
+>>> from huggingface_hub import create_repo
+>>> create_repo("lysandre/test-private", private=True)
+```
+
+Wenn Sie die Sichtbarkeit des Repositories zu einem späteren Zeitpunkt ändern möchten, können Sie die Funktion [`update_repo_visibility`] verwenden.
+
+### Ein Repository löschen
+
+Löschen Sie ein Repository mit [`delete_repo`]. Stellen Sie sicher, dass Sie ein Repository löschen möchten, da dieser Vorgang unwiderruflich ist!
+
+Geben Sie die `repo_id` des Repositories an, das Sie löschen möchten:
+
+```py
+>>> delete_repo(repo_id="lysandre/my-corrupted-dataset", repo_type="dataset")
+```
+
+### Ein Repository duplizieren (nur für Spaces)
+
+In einigen Fällen möchten Sie möglicherweise das Repo von jemand anderem kopieren, um es an Ihren Anwendungsfall anzupassen. Dies ist für Spaces mit der Methode [`duplicate_space`] möglich. Es wird das gesamte Repository dupliziert. 
+Sie müssen jedoch noch Ihre eigenen Einstellungen konfigurieren (Hardware, Schlafzeit, Speicher, Variablen und Geheimnisse). Weitere Informationen finden Sie in unserem Leitfaden [Verwalten Ihres Spaces](./manage-spaces).
+
+```py
+>>> from huggingface_hub import duplicate_space
+>>> duplicate_space("multimodalart/dreambooth-training", private=False)
+RepoUrl('https://huggingface.co/spaces/nateraw/dreambooth-training',...)
+```
+
+## Dateien hochladen und herunterladen
+
+Jetzt, wo Sie Ihr Repository erstellt haben, möchten Sie Änderungen daran vornehmen und Dateien daraus herunterladen.
+
+Diese 2 Themen verdienen ihre eigenen Leitfäden. Bitte beziehen Sie sich auf die [Hochladen](./upload) und die [Herunterladen](./download) Leitfäden, um zu erfahren, wie Sie Ihr Repository verwenden können.
+
+## Branches und Tags
+
+Git-Repositories verwenden oft Branches, um verschiedene Versionen eines gleichen Repositories zu speichern. 
+Tags können auch verwendet werden, um einen bestimmten Zustand Ihres Repositories zu kennzeichnen, z. B. bei der Veröffentlichung einer Version. 
+Allgemeiner gesagt, werden Branches und Tags als [git-Referenzen](https://git-scm.com/book/en/v2/Git-Internals-Git-References) bezeichnet.
+
+### Branches und Tags erstellen
+
+Sie können neue Branches und Tags mit [`create_branch`] und [`create_tag`] erstellen:
+
+```py
+>>> from huggingface_hub import create_branch, create_tag
+
+# Erstellen Sie einen Branch auf einem Space-Repo vom `main` Branch
+>>> create_branch("Matthijs/speecht5-tts-demo", repo_type="space", branch="handle-dog-speaker")
+
+# Erstellen Sie einen Tag auf einem Dataset-Repo vom `v0.1-release` Branch
+>>> create_branch("bigcode/the-stack", repo_type="dataset", revision="v0.1-release", tag="v0.1.1", tag_message="Bump release version.")
+```
+
+Sie können die Funktionen [`delete_branch`] und [`delete_tag`] auf die gleiche Weise verwenden, um einen Branch oder einen Tag zu löschen.
+
+### Alle Branches und Tags auflisten
+
+Sie können auch die vorhandenen git-Referenzen von einem Repository mit [`list_repo_refs`] auflisten:
+
+```py
+>>> from huggingface_hub import list_repo_refs
+>>> api.list_repo_refs("bigcode/the-stack", repo_type="dataset")
+GitRefs(
+   branches=[
+         GitRefInfo(name='main', ref='refs/heads/main', target_commit='18edc1591d9ce72aa82f56c4431b3c969b210ae3'),
+         GitRefInfo(name='v1.1.a1', ref='refs/heads/v1.1.a1', target_commit='f9826b862d1567f3822d3d25649b0d6d22ace714')
+   ],
+   converts=[],
+   tags=[
+         GitRefInfo(name='v1.0', ref='refs/tags/v1.0', target_commit='c37a8cd1e382064d8aced5e05543c5f7753834da')
+   ]
+)
+``` 
+
+## Repository-Einstellungen ändern
+
+Repositories verfügen über einige Einstellungen, die Sie konfigurieren können. Die meiste Zeit möchten Sie dies manuell auf der Repo-Einstellungsseite in Ihrem Browser tun. Sie müssen Schreibzugriff auf ein Repo haben, um es zu konfigurieren (entweder besitzen oder Teil einer Organisation sein). In diesem Abschnitt werden wir die Einstellungen sehen, die Sie auch programmgesteuert mit `huggingface_hub` konfigurieren können.
+
+Einige Einstellungen sind spezifisch für Spaces (Hardware, Umgebungsvariablen,...). Um diese zu konfigurieren, lesen Sie bitte unseren [Verwalten Ihres Spaces](../guides/manage-spaces) Leitfaden.
+
+### Sichtbarkeit aktualisieren
+
+Ein Repository kann öffentlich oder privat sein. Ein privates Repository ist nur für Sie oder die Mitglieder der Organisation sichtbar, in der das Repository sich befindet. Ändern Sie ein Repository wie im Folgenden gezeigt in ein privates:
+
+```py
+>>> from huggingface_hub import update_repo_visibility
+>>> update_repo_visibility(repo_id=repo_id, private=True)
+```
+
+### Benennen Sie Ihr Repository um
+
+Sie können Ihr Repository auf dem Hub mit [`move_repo] umbenennen. Mit dieser Methode können Sie das Repo auch von einem Benutzer zu einer Organisation verschieben. Dabei gibt es [einige Einschränkungen](https://hf.co/docs/hub/repositories-settings#renaming-or-transferring-a-repo), die Sie beachten sollten. Zum Beispiel können Sie Ihr Repo nicht an einen anderen Benutzer übertragen.
+
+```py
+>>> from huggingface_hub import move_repo
+>>> move_repo(from_id="Wauplin/cool-model", to_id="huggingface/cool-model")
+```
+
+## Verwalten Sie eine lokale Kopie Ihres Repositories
+
+Alle oben beschriebenen Aktionen können mit HTTP-Anfragen durchgeführt werden. In einigen Fällen möchten Sie jedoch vielleicht eine lokale Kopie Ihres Repositories haben und damit interagieren, indem Sie die Git-Befehle verwenden, die Sie kennen.
+
+Die [`Repository`] Klasse ermöglicht es Ihnen, mit Dateien und Repositories auf dem Hub mit Funktionen zu interagieren, die Git-Befehlen ähneln. Es ist ein Wrapper über Git und Git-LFS-Methoden, um die Git-Befehle zu verwenden, die Sie bereits kennen und lieben. Stellen Sie vor dem Start sicher, dass Sie Git-LFS installiert haben (siehe [hier](https://git-lfs.github.com/) für Installationsanweisungen).
+
+### Verwenden eines lokalen Repositories
+
+Instanziieren Sie ein [`Repository`] Objekt mit einem Pfad zu einem lokalen Repository:
+
+```py
+>>> from huggingface_hub import Repository
+>>> repo = Repository(local_dir="<path>/<to>/<folder>")
+```
+
+### Klonen
+
+Der `clone_from` Parameter klont ein Repository von einer Hugging Face Repository-ID in ein lokales Verzeichnis, das durch das Argument `local_dir` angegeben wird:
+
+```py
+>>> from huggingface_hub import Repository
+>>> repo = Repository(local_dir="w2v2", clone_from="facebook/wav2vec2-large-960h-lv60")
+```
+
+`clone_from` kann auch ein Repository mit einer URL klonen:
+
+```py
+>>> repo = Repository(local_dir="huggingface-hub", clone_from="https://huggingface.co/facebook/wav2vec2-large-960h-lv60")
+```
+
+Sie können den `clone_from` Parameter mit [`create_repo`] kombinieren, um ein Repository zu erstellen und zu klonen:
+
+```py
+>>> repo_url = create_repo(repo_id="repo_name")
+>>> repo = Repository(local_dir="repo_local_path", clone_from=repo_url)
+```
+
+Sie können auch einen Git-Benutzernamen und eine E-Mail zu einem geklonten Repository konfigurieren, indem Sie die Parameter `git_user` und `git_email` beim Klonen eines Repositories angeben. Wenn Benutzer Änderungen in diesem Repository committen, wird Git über den Autor des Commits informiert sein.
+
+```py
+>>> repo = Repository(
+...   "my-dataset",
+...   clone_from="<user>/<dataset_id>",
+...   token=True,
+...   repo_type="dataset",
+...   git_user="MyName",
+...   git_email="me@cool.mail"
+... )
+```
+
+### Branch
+
+Branches sind wichtig für die Zusammenarbeit und das Experimentieren, ohne Ihre aktuellen Dateien und Codes zu beeinflussen. Wechseln Sie zwischen den Branches mit [`~Repository.git_checkout`]. Wenn Sie beispielsweise von `branch1` zu `branch2` wechseln möchten:
+
+```py
+>>> from huggingface_hub import Repository
+>>> repo = Repository(local_dir="huggingface-hub", clone_from="<user>/<dataset_id>", revision='branch1')
+>>> repo.git_checkout("branch2")
+```
+
+### Pull
+
+Mit [`~Repository.git_pull`] können Sie eine aktuelle lokale Branch mit Änderungen aus einem Remote-Repository aktualisieren:
+
+```py
+>>> from huggingface_hub import Repository
+>>> repo.git_pull()
+```
+
+Setzen Sie `rebase=True`, wenn Sie möchten, dass Ihre lokalen Commits nach dem Aktualisieren Ihres Zweigs mit den neuen Commits aus dem Remote erfolgen:
+
+```py
+>>> repo.git_pull(rebase=True)
+```
diff --git a/docs/source/de/guides/search.md b/docs/source/de/guides/search.md
new file mode 100644
index 00000000..a5ad07d3
--- /dev/null
+++ b/docs/source/de/guides/search.md
@@ -0,0 +1,223 @@
+<!--⚠️ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
+rendered properly in your Markdown viewer.
+-->
+
+# Den Hub durchsuchen
+
+In diesem Tutorial lernen Sie, wie Sie Modelle, Datensätze und Spaces auf dem Hub mit `huggingface_hub` durchsuchen können.
+
+## Wie listet man Repositories auf?
+
+Die `huggingface_hub`-Bibliothek enthält einen HTTP-Client [`HfApi`], um mit dem Hub zu interagieren. 
+Unter anderem kann er Modelle, Datensätze und Spaces auflisten, die auf dem Hub gespeichert sind:
+
+```py
+>>> from huggingface_hub import HfApi
+>>> api = HfApi()
+>>> models = api.list_models()
+```
+
+Die Ausgabe von [`list_models`] ist ein Iterator über die auf dem Hub gespeicherten Modelle.
+
+Ähnlich können Sie [`list_datasets`] verwenden, um Datensätze aufzulisten und [`list_spaces`], um Spaces aufzulisten.
+
+## Wie filtert man Repositories?
+
+Das Auflisten von Repositories ist großartig, aber jetzt möchten Sie vielleicht Ihre Suche filtern. 
+Die List-Helfer haben mehrere Attribute wie:
+- `filter`
+- `author`
+- `search`
+- ...
+
+Zwei dieser Parameter sind intuitiv (`author` und `search`), aber was ist mit diesem `filter`? 
+`filter` nimmt als Eingabe ein [`ModelFilter`]-Objekt (oder [`DatasetFilter`]) entgegen. 
+Sie können es instanziieren, indem Sie angeben, welche Modelle Sie filtern möchten.
+
+Hier ist ein Beispiel, um alle Modelle auf dem Hub zu erhalten, die Bildklassifizierung durchführen, 
+auf dem Imagenet-Datensatz trainiert wurden und mit PyTorch laufen. 
+Das kann mit einem einzigen [`ModelFilter`] erreicht werden. Attribute werden als "logisches UND" kombiniert.
+
+```py
+models = hf_api.list_models(
+    filter=ModelFilter(
+		task="image-classification",
+		library="pytorch",
+		trained_dataset="imagenet"
+	)
+)
+```
+
+Während des Filterns können Sie auch die Modelle sortieren und nur die Top-Ergebnisse abrufen. 
+Zum Beispiel holt das folgende Beispiel die 5 am häufigsten heruntergeladenen Datensätze auf dem Hub:
+
+```py
+>>> list_datasets(sort="downloads", direction=-1, limit=5)
+[DatasetInfo: {
+        id: glue
+		downloads: 897789
+		(...)
+```
+
+
+## Wie erkundet man Filteroptionen?
+
+Jetzt wissen Sie, wie Sie Ihre Liste von Modellen/Datensätzen/Räumen filtern können. 
+Das Problem könnte sein, dass Sie nicht genau wissen, wonach Sie suchen. Keine Sorge! 
+Wir bieten auch einige Hilfsprogramme an, mit denen Sie entdecken können, welche Argumente Sie in Ihrer Abfrage übergeben können.
+
+[`ModelSearchArguments`] und [`DatasetSearchArguments`] sind geschachtelte Namespace-Objekte, 
+die **jede einzelne Option** auf dem Hub haben und die zurückgeben, was an `filter` übergeben werden sollte. 
+Das Beste von allem ist: Es hat Tab-Vervollständigung 🎊.
+
+```python
+>>> from huggingface_hub import ModelSearchArguments, DatasetSearchArguments
+
+>>> model_args = ModelSearchArguments()
+>>> dataset_args = DatasetSearchArguments()
+```
+
+<Tip warning={true}>
+
+Bevor Sie weitermachen, beachten Sie bitte, dass [`ModelSearchArguments`] und [`DatasetSearchArguments`] 
+veraltete Hilfsprogramme sind, die nur zu Erkundungszwecken gedacht sind. 
+Ihre Initialisierung erfordert das Auflisten aller Modelle und Datensätze auf dem Hub, was sie zunehmend langsamer macht, 
+je mehr Repos auf dem Hub vorhanden sind. Für produktionsbereiten Code sollten Sie in Erwägung ziehen, 
+rohe Zeichenketten (raw strings) zu übergeben, wenn Sie eine gefilterte Suche auf dem Hub durchführen.
+
+</Tip>
+
+Sehen wir uns nun an, was in `model_args` verfügbar ist, indem wir seine Ausgabe überprüfen:
+
+```python
+>>> model_args
+Available Attributes or Keys:
+ * author
+ * dataset
+ * language
+ * library
+ * license
+ * model_name
+ * pipeline_tag
+```
+
+Es stehen Ihnen eine Vielzahl von Attributen oder Schlüsseln zur Verfügung. 
+Dies liegt daran, dass es sowohl ein Objekt als auch ein Wörterbuch ist. 
+Daher können Sie entweder `model_args["author"]` oder `model_args.author` verwenden.
+
+Das erste Kriterium besteht darin, alle PyTorch-Modelle zu erhalten. 
+Dies wäre unter dem Attribut `library` zu finden, schauen wir also, ob es da ist:
+
+```python
+>>> model_args.library
+Available Attributes or Keys:
+ * AdapterTransformers
+ * Asteroid
+ * ESPnet
+ * Fairseq
+ * Flair
+ * JAX
+ * Joblib
+ * Keras
+ * ONNX
+ * PyTorch
+ * Rust
+ * Scikit_learn
+ * SentenceTransformers
+ * Stable_Baselines3 (Key only)
+ * Stanza
+ * TFLite
+ * TensorBoard
+ * TensorFlow
+ * TensorFlowTTS
+ * Timm
+ * Transformers
+ * allenNLP
+ * fastText
+ * fastai
+ * pyannote_audio
+ * spaCy
+ * speechbrain
+```
+
+Es ist da! Der Name PyTorch ist vorhanden, daher müssen Sie `model_args.library.PyTorch` verwenden:
+
+```python
+>>> model_args.library.PyTorch
+'pytorch'
+```
+
+Im Folgenden finden Sie eine Animation, die den Vorgang zur Suche nach den Anforderungen Textklassifizierung (`Text Classification`) and `glue` wiederholt:
+
+![Animation exploring `model_args.pipeline_tag`](https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/search_text_classification.gif)
+
+![Animation exploring `model_args.dataset`](https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/search_glue.gif)
+
+Jetzt, da alle Teile vorhanden sind, besteht der letzte Schritt darin, sie alle für etwas zu kombinieren, 
+das die API über die Klassen [`ModelFilter`] und [`DatasetFilter`] verwenden kann (d.h. Zeichenketten / strings).
+
+
+```python
+>>> from huggingface_hub import ModelFilter, DatasetFilter
+
+>>> filt = ModelFilter(
+...     task=model_args.pipeline_tag.TextClassification, 
+...     trained_dataset=dataset_args.dataset_name.glue, 
+...     library=model_args.library.PyTorch
+... )
+>>> api.list_models(filter=filt)[0]
+ModelInfo: {
+	modelId: Jiva/xlm-roberta-large-it-mnli
+	sha: c6e64469ec4aa17fedbd1b2522256f90a90b5b86
+	lastModified: 2021-12-10T14:56:38.000Z
+	tags: ['pytorch', 'xlm-roberta', 'text-classification', 'it', 'dataset:multi_nli', 'dataset:glue', 'arxiv:1911.02116', 'transformers', 'tensorflow', 'license:mit', 'zero-shot-classification']
+	pipeline_tag: zero-shot-classification
+	siblings: [ModelFile(rfilename='.gitattributes'), ModelFile(rfilename='README.md'), ModelFile(rfilename='config.json'), ModelFile(rfilename='pytorch_model.bin'), ModelFile(rfilename='sentencepiece.bpe.model'), ModelFile(rfilename='special_tokens_map.json'), ModelFile(rfilename='tokenizer.json'), ModelFile(rfilename='tokenizer_config.json')]
+	config: None
+	id: Jiva/xlm-roberta-large-it-mnli
+	private: False
+	downloads: 11061
+	library_name: transformers
+	likes: 1
+}
+```
+
+Wie Sie sehen können, wurden die Modelle gefunden, die allen Kriterien entsprechen. Sie können es sogar noch weiter bringen, 
+indem Sie ein Array für jeden der vorherigen Parameter übergeben. 
+Zum Beispiel, schauen wir uns dieselbe Konfiguration an, aber schließen auch `TensorFlow` in den Filter ein:
+
+```python
+>>> filt = ModelFilter(
+...     task=model_args.pipeline_tag.TextClassification, 
+...     library=[model_args.library.PyTorch, model_args.library.TensorFlow]
+... )
+>>> api.list_models(filter=filt)[0]
+ModelInfo: {
+	modelId: distilbert-base-uncased-finetuned-sst-2-english
+	sha: ada5cc01a40ea664f0a490d0b5f88c97ab460470
+	lastModified: 2022-03-22T19:47:08.000Z
+	tags: ['pytorch', 'tf', 'rust', 'distilbert', 'text-classification', 'en', 'dataset:sst-2', 'transformers', 'license:apache-2.0', 'infinity_compatible']
+	pipeline_tag: text-classification
+	siblings: [ModelFile(rfilename='.gitattributes'), ModelFile(rfilename='README.md'), ModelFile(rfilename='config.json'), ModelFile(rfilename='map.jpeg'), ModelFile(rfilename='pytorch_model.bin'), ModelFile(rfilename='rust_model.ot'), ModelFile(rfilename='tf_model.h5'), ModelFile(rfilename='tokenizer_config.json'), ModelFile(rfilename='vocab.txt')]
+	config: None
+	id: distilbert-base-uncased-finetuned-sst-2-english
+	private: False
+	downloads: 3917525
+	library_name: transformers
+	likes: 49
+}
+```
+
+Diese Abfrage entspricht streng:
+
+```py
+>>> filt = ModelFilter(
+...     task="text-classification", 
+...     library=["pytorch", "tensorflow"],
+... )
+```
+
+Hier war  [`ModelSearchArguments`] ein Helfer, um die auf dem Hub verfügbaren Optionen zu erkunden. 
+Es ist jedoch keine Voraussetzung für eine Suche. Eine andere Möglichkeit, dies zu tun, 
+besteht darin, die [Modelle](https://huggingface.co/models) und [Datensätze](https://huggingface.co/datasets) Seiten 
+in Ihrem Browser zu besuchen, nach einigen Parametern zu suchen und die Werte in der URL anzusehen.
\ No newline at end of file
diff --git a/docs/source/de/guides/upload.md b/docs/source/de/guides/upload.md
new file mode 100644
index 00000000..41782f26
--- /dev/null
+++ b/docs/source/de/guides/upload.md
@@ -0,0 +1,473 @@
+<!--⚠️ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
+rendered properly in your Markdown viewer.
+-->
+
+# Dateien auf den Hub hochladen
+
+Das Teilen Ihrer Dateien und Arbeiten ist ein wichtiger Aspekt des Hubs. Das `huggingface_hub` bietet mehrere Optionen, um Ihre Dateien auf den Hub hochzuladen. Sie können diese Funktionen unabhängig verwenden oder sie in Ihre Bibliothek integrieren, um es Ihren Benutzern zu erleichtern, mit dem Hub zu interagieren. In dieser Anleitung erfahren Sie, wie Sie Dateien hochladen:
+
+- ohne Git zu verwenden.
+- mit [Git LFS](https://git-lfs.github.com/) wenn die Dateien sehr groß sind.
+- mit dem `commit`-Context-Manager.
+- mit der Funktion [`~Repository.push_to_hub`].
+
+Wenn Sie Dateien auf den Hub hochladen möchten, müssen Sie sich bei Ihrem Hugging Face-Konto anmelden:
+
+- Melden Sie sich bei Ihrem Hugging Face-Konto mit dem folgenden Befehl an:
+
+  ```bash
+  huggingface-cli login
+  # oder mit einer Umgebungsvariable
+  huggingface-cli login --token $HUGGINGFACE_TOKEN
+  ```
+
+- Alternativ können Sie sich in einem Notebook oder einem Skript programmatisch mit [`login`] anmelden:
+
+  ```python
+  >>> from huggingface_hub import login
+  >>> login()
+  ```
+
+  Wenn es in einem Jupyter- oder Colaboratory-Notebook ausgeführt wird, startet [`login`] ein Widget, über das Sie Ihren Hugging Face-Zugriffstoken eingeben können. Andernfalls wird eine Meldung im Terminal angezeigt.
+
+  Es ist auch möglich, sich programmatisch ohne das Widget anzumelden, indem Sie den Token direkt an [`login`] übergeben. Seien Sie jedoch vorsichtig, wenn Sie Ihr Notebook teilen. Es ist am Besten, den Token aus einem sicheren Passwortspeicher zu laden, anstatt ihn in Ihrem Colaboratory-Notebook zu speichern.
+
+## Datei hochladen
+
+Sobald Sie ein Repository mit [`create_repo`] erstellt haben, können Sie mit [`upload_file`] eine Datei in Ihr Repository hochladen.
+
+Geben Sie den Pfad der hochzuladenden Datei, den Ort, an den Sie die Datei im Repository hochladen möchten, und den Namen des Repositories an, zu dem Sie die Datei hinzufügen möchten. Abhängig von Ihrem Repository-Typ können Sie optional den Repository-Typ als `dataset`, `model`, oder `space` festlegen.
+
+```py
+>>> from huggingface_hub import HfApi
+>>> api = HfApi()
+>>> api.upload_file(
+...     path_or_fileobj="/path/to/local/folder/README.md",
+...     path_in_repo="README.md",
+...     repo_id="username/test-dataset",
+...     repo_type="dataset",
+... )
+```
+
+## Ordner hochladen
+
+Verwenden Sie die Funktion [`upload_folder`], um einen lokalen Ordner in ein vorhandenes Repository hochzuladen. Geben Sie den Pfad des lokalen Ordners an, den Sie hochladen möchten, an welchem Ort Sie den Ordner im Repository hochladen möchten, und den Namen des Repositories, zu dem Sie den Ordner hinzufügen möchten. Abhängig von Ihrem Repository-Typ können Sie optional den Repository-Typ als `dataset`, `model`, oder `space` festlegen.
+
+```py
+>>> from huggingface_hub import HfApi
+>>> api = HfApi()
+
+# Den gesamten Inhalt aus dem lokalen Ordner in den entfernten Space hoch laden.
+# Standardmäßig werden Dateien im Hauptverzeichnis des Repos hochgeladen
+>>> api.upload_folder(
+...     folder_path="/path/to/local/space",
+...     repo_id="username/my-cool-space",
+...     repo_type="space",
+... )
+```
+
+Verwenden Sie die Argumente `allow_patterns` und `ignore_patterns`, um anzugeben, welche Dateien hochgeladen werden sollen. Diese Parameter akzeptieren entweder ein einzelnes Muster oder eine Liste von Mustern. Muster sind Standard-Wildcards (globbing patterns) wie [hier](https://tldp.org/LDP/GNU-Linux-Tools-Summary/html/x11655.htm) dokumentiert. Wenn sowohl `allow_patterns` als auch `ignore_patterns` angegeben werden, gelten beide Einschränkungen. Standardmäßig werden alle Dateien aus dem Ordner hochgeladen.
+
+Jeder `.git/`-Ordner in einem Unterverzeichnis wird ignoriert. Bitte beachten Sie jedoch, dass die `.gitignore`-Datei nicht berücksichtigt wird. Dies bedeutet, dass Sie `allow_patterns` und `ignore_patterns` verwenden müssen, um anzugeben, welche Dateien stattdessen hochgeladen werden sollen.
+
+```py
+>>> api.upload_folder(
+...     folder_path="/path/to/local/folder",
+...     path_in_repo="my-dataset/train", # Hochladen in einen bestimmten Ordner
+...     repo_id="username/test-dataset",
+...     repo_type="dataset",
+...     ignore_patterns="**/logs/*.txt", # Alle Textprotokolle ignorieren
+... )
+```
+
+Sie können auch das Argument `delete_patterns` verwenden, um Dateien anzugeben, die Sie im selben Commit aus dem Repo löschen möchten. Dies kann nützlich sein, wenn Sie einen entfernten Ordner reinigen möchten, bevor Sie Dateien darin ablegen und nicht wissen, welche Dateien bereits vorhanden sind.
+
+Im folgenden Beispiel wird der lokale Ordner `./logs` in den entfernten Ordner `/experiment/logs/` hochgeladen. Es werden nur txt-Dateien hochgeladen, aber davor werden alle vorherigen Protokolle im Repo gelöscht. All dies in einem einzigen Commit.
+
+```py
+>>> api.upload_folder(
+...     folder_path="/path/to/local/folder/logs",
+...     repo_id="username/trained-model",
+...     path_in_repo="experiment/logs/",
+...     allow_patterns="*.txt", # Alle lokalen Textdateien hochladen
+...     delete_patterns="*.txt", # Vorher alle enfernten Textdateien löschen
+... )
+```
+
+## Erweiterte Funktionen
+
+In den meisten Fällen benötigen Sie nicht mehr als [`upload_file`] und [`upload_folder`], um Ihre Dateien auf den Hub hochzuladen. Das `huggingface_hub` bietet jedoch fortschrittlichere Funktionen, um die Dinge einfacher zu machen. Schauen wir sie uns an!
+
+
+### Nicht blockierende Uploads
+
+In einigen Fällen möchten Sie Daten hochladen, ohne Ihren Hauptthread zu blockieren. Dies ist besonders nützlich, um Protokolle und Artefakte hochzuladen, während Sie weiter trainieren. Um dies zu tun, können Sie das Argument `run_as_future` in beiden [`upload_file`] und [`upload_folder`] verwenden. Dies gibt ein [`concurrent.futures.Future`](https://docs.python.org/3/library/concurrent.futures.html#future-objects)-Objekt zurück, mit dem Sie den Status des Uploads überprüfen können.
+
+```py
+>>> from huggingface_hub import HfApi
+>>> api = HfApi()
+>>> future = api.upload_folder( # Hochladen im Hintergrund (nicht blockierende Aktion)
+...     repo_id="username/my-model",
+...     folder_path="checkpoints-001",
+...     run_as_future=True,
+... )
+>>> future
+Future(...)
+>>> future.done()
+False
+>>> future.result() # Warten bis der Upload abgeschlossen ist (blockierende Aktion)
+...
+```
+
+<Tip>
+
+Hintergrund-Aufgaben werden in die Warteschlange gestellt, wenn `run_as_future=True` verwendet wird. Das bedeutet, dass garantiert wird, dass die Aufgaben in der richtigen Reihenfolge ausgeführt werden.
+
+</Tip>
+
+Auch wenn Hintergrundaufgaben hauptsächlich dazu dienen, Daten hochzuladen/Commits zu erstellen, können Sie jede gewünschte Methode in die Warteschlange stellen, indem Sie [`run_as_future`] verwenden. Sie können es beispielsweise verwenden, um ein Repo zu erstellen und dann Daten im Hintergrund dorthin hochzuladen. Das integrierte Argument `run_as_future` in Upload-Methoden ist lediglich ein Alias dafür.
+
+```py
+>>> from huggingface_hub import HfApi
+>>> api = HfApi()
+>>> api.run_as_future(api.create_repo, "username/my-model", exists_ok=True)
+Future(...)
+>>> api.upload_file(
+...     repo_id="username/my-model",
+...     path_in_repo="file.txt",
+...     path_or_fileobj=b"file content",
+...     run_as_future=True,
+... )
+Future(...)
+```
+
+### Ordner in Teilen hochladen
+
+Mit [`upload_folder`] können Sie ganz einfach einen gesamten Ordner ins Hub hochladen. Bei großen Ordnern (Tausende von Dateien oder Hunderte von GB) kann dies jedoch immer noch herausfordernd sein. Wenn Sie einen Ordner mit vielen Dateien haben, möchten Sie ihn möglicherweise in mehreren Commits hochladen. Wenn während des Uploads ein Fehler oder ein Verbindungsproblem auftritt, müssen Sie den Vorgang nicht von Anfang an wiederholen.
+
+Um einen Ordner in mehreren Commits hochzuladen, übergeben Sie einfach `multi_commits=True` als Argument. Intern wird `huggingface_hub` die hochzuladenden/zu löschenden Dateien auflisten und sie in mehrere Commits aufteilen. Die "Strategie" (d.h. wie die Commits aufgeteilt werden) basiert auf der Anzahl und Größe der hochzuladenden Dateien. Ein PR wird im Hub geöffnet, um alle Commits zu pushen. Sobald der PR bereit ist, werden die Commits zu einem einzigen Commit zusammengefasst. Wenn der Prozess unterbrochen wird, bevor er abgeschlossen ist, können Sie Ihr Skript erneut ausführen, um den Upload fortzusetzen. Der erstellte PR wird automatisch erkannt und der Upload setzt dort fort, wo er gestoppt wurde. Es wird empfohlen, `multi_commits_verbose=True` zu übergeben, um ein besseres Verständnis für den Upload und dessen Fortschritt zu erhalten.
+
+Das untenstehende Beispiel lädt den Ordner "checkpoints" in ein Dataset in mehreren Commits hoch. Ein PR wird im Hub erstellt und automatisch zusammengeführt, sobald der Upload abgeschlossen ist. Wenn Sie möchten, dass der PR offen bleibt und Sie ihn manuell überprüfen können, übergeben Sie `create_pr=True`.
+
+```py
+>>> upload_folder(
+...     folder_path="local/checkpoints",
+...     repo_id="username/my-dataset",
+...     repo_type="dataset",
+...     multi_commits=True,
+...     multi_commits_verbose=True,
+... )
+```
+
+Wenn Sie die Upload-Strategie besser steuern möchten (d.h. die erstellten Commits), können Sie sich die Low-Level-Methoden [`plan_multi_commits`] und [`create_commits_on_pr`] ansehen.
+
+<Tip warning={true}>
+
+`multi_commits` ist noch ein experimentelles Feature. Seine API und sein Verhalten können in Zukunft ohne vorherige Ankündigung geändert werden.
+
+</Tip>
+
+### Geplante Uploads
+
+Das Hugging Face Hub erleichtert das Speichern und Versionieren von Daten. Es gibt jedoch einige Einschränkungen, wenn Sie dieselbe Datei Tausende von Malen aktualisieren möchten. Sie möchten beispielsweise Protokolle eines Trainingsprozesses oder Benutzerfeedback in einem bereitgestellten Space speichern. In diesen Fällen macht es Sinn, die Daten als Dataset im Hub hochzuladen, aber es kann schwierig sein, dies richtig zu machen. Der Hauptgrund ist, dass Sie nicht jede Aktualisierung Ihrer Daten versionieren möchten, da dies das git-Repository unbrauchbar machen würde. Die Klasse [`CommitScheduler`] bietet eine Lösung für dieses Problem.
+
+Die Idee besteht darin, einen Hintergrundjob auszuführen, der regelmäßig einen lokalen Ordner ins Hub schiebt. Nehmen Sie an, Sie haben einen Gradio Space, der als Eingabe einen Text nimmt und zwei Übersetzungen davon generiert. Der Benutzer kann dann seine bevorzugte Übersetzung auswählen. Für jeden Durchlauf möchten Sie die Eingabe, Ausgabe und Benutzerpräferenz speichern, um die Ergebnisse zu analysieren. Dies ist ein perfekter Anwendungsfall für [`CommitScheduler`]; Sie möchten Daten ins Hub speichern (potenziell Millionen von Benutzerfeedbacks), aber Sie müssen nicht in Echtzeit jede Benutzereingabe speichern. Stattdessen können Sie die Daten lokal in einer JSON-Datei speichern und sie alle 10 Minuten hochladen. Zum Beispiel:
+
+```py
+>>> import json
+>>> import uuid
+>>> from pathlib import Path
+>>> import gradio as gr
+>>> from huggingface_hub import CommitScheduler
+
+# Definieren Sie die Datei, in der die Daten gespeichert werden sollen. Verwenden Sie UUID, um sicherzustellen, dass vorhandene Daten aus einem früheren Lauf nicht überschrieben werden.
+>>> feedback_file = Path("user_feedback/") / f"data_{uuid.uuid4()}.json"
+>>> feedback_folder = feedback_file.parent
+
+# Geplante regelmäßige Uploads. Das Remote-Repo und der lokale Ordner werden erstellt, wenn sie noch nicht existieren.
+>>> scheduler = CommitScheduler(
+...     repo_id="report-translation-feedback",
+...     repo_type="dataset",
+...     folder_path=feedback_folder,
+...     path_in_repo="data",
+...     every=10,
+... )
+
+# Eine einfache Gradio-Anwendung, die einen Text als Eingabe nimmt und zwei Übersetzungen generiert. Der Benutzer wählt seine bevorzugte Übersetzung aus.
+>>> def save_feedback(input_text:str, output_1: str, output_2:str, user_choice: int) -> None:
+...     """
+...     Füge Eingabe/Ausgabe und Benutzerfeedback zu einer JSON-Lines-Datei hinzu und verwende ein Thread-Lock, um gleichzeitiges Schreiben von verschiedenen Benutzern zu vermeiden.
+...     """
+...     with scheduler.lock:
+...         with feedback_file.open("a") as f:
+...             f.write(json.dumps({"input": input_text, "output_1": output_1, "output_2": output_2, "user_choice": user_choice}))
+...             f.write("\n")
+
+# Starte Gradio
+>>> with gr.Blocks() as demo:
+>>>     ... # Definiere Gradio Demo + verwende `save_feedback`
+>>> demo.launch()
+```
+
+Und das war's! Benutzereingabe/-ausgaben und Feedback sind als Dataset auf dem Hub verfügbar. Durch die Verwendung eines eindeutigen JSON-Dateinamens können Sie sicher sein, dass Sie keine Daten von einem vorherigen Lauf oder Daten von anderen Spaces/Replikas überschreiben, die gleichzeitig in dasselbe Repository pushen.
+
+Für weitere Details über den [`CommitScheduler`], hier das Wichtigste:
+
+- **append-only / Nur hinzufügen:**
+      Es wird davon ausgegangen, dass Sie nur Inhalte zum Ordner hinzufügen. Sie dürfen nur Daten zu bestehenden Dateien hinzufügen oder neue Dateien erstellen. Das Löschen oder Überschreiben einer Datei könnte Ihr Repository beschädigen.
+- **git history / git Historie**:
+      Der Scheduler wird den Ordner alle every Minuten committen. Um das Git-Repository nicht zu überladen, wird empfohlen, einen minimalen Wert von 5 Minuten festzulegen. Außerdem ist der Scheduler darauf ausgelegt, leere Commits zu vermeiden. Wenn im Ordner kein neuer Inhalt erkannt wird, wird der geplante Commit verworfen.
+- **errors / Fehler**:
+      Der Scheduler läuft als Hintergrund-Thread. Er wird gestartet, wenn Sie die Klasse instanziieren, und stoppt nie. Insbesondere, wenn während des Uploads ein Fehler auftritt (z. B. Verbindungsproblem), wird der Scheduler ihn stillschweigend ignorieren und beim nächsten geplanten Commit erneut versuchen.
+- **thread-safety / Thread-Sicherheit**:
+      In den meisten Fällen können Sie davon ausgehen, dass Sie eine Datei schreiben können, ohne sich um eine Lock-Datei kümmern zu müssen. Der Scheduler wird nicht abstürzen oder beschädigt werden, wenn Sie Inhalte in den Ordner schreiben, während er hochlädt. In der Praxis ist es möglich, dass bei stark ausgelasteten Apps Probleme mit der Parallelität auftreten. In diesem Fall empfehlen wir, das `scheduler.lock` Lock zu verwenden, um die Thread-Sicherheit zu gewährleisten. Das Lock wird nur gesperrt, wenn der Scheduler den Ordner auf Änderungen überprüft, nicht beim Hochladen von Daten. Sie können sicher davon ausgehen, dass dies das Benutzererlebnis in Ihrem Space nicht beeinflusst.
+
+#### Space Persistenz-Demo
+
+Das Speichern von Daten aus einem Space in einem Dataset auf dem Hub ist der Hauptanwendungsfall für den [`CommitScheduler`]. Je nach Anwendungsfall möchten Sie Ihre Daten möglicherweise anders strukturieren. Die Struktur muss robust gegenüber gleichzeitigen Benutzern und Neustarts sein, was oft das Generieren von UUIDs impliziert. Neben der Robustheit sollten Sie Daten in einem Format hochladen, das von der 🤗 Datasets-Bibliothek für die spätere Wiederverwendung gelesen werden kann. Wir haben einen [Space](https://huggingface.co/spaces/Wauplin/space_to_dataset_saver) erstellt, der zeigt, wie man verschiedene Datenformate speichert (dies muss möglicherweise für Ihre speziellen Bedürfnisse angepasst werden).
+
+#### Benutzerdefinierte Uploads
+
+[`CommitScheduler`] geht davon aus, dass Ihre Daten nur hinzugefügt werden und "wie sie sind" hochgeladen werden sollten. Sie möchten jedoch möglicherweise anpassen, wie Daten hochgeladen werden. Dies können Sie tun, indem Sie eine Klasse erstellen, die vom [`CommitScheduler`] erbt und die Methode `push_to_hub` überschreibt (fühlen Sie sich frei, sie nach Belieben zu überschreiben). Es ist garantiert, dass sie alle `every` Minuten in einem Hintergrund-Thread aufgerufen wird. Sie müssen sich keine Gedanken über Parallelität und Fehler machen, aber Sie müssen vorsichtig sein bei anderen Aspekten, wie z. B. dem Pushen von leeren Commits oder doppelten Daten.
+
+Im folgenden (vereinfachten) Beispiel überschreiben wir `push_to_hub`, um alle PNG-Dateien in einem einzigen Archiv zu zippen, um das Repo auf dem Hub nicht zu überladen:
+
+```py
+class ZipScheduler(CommitScheduler):
+    def push_to_hub(self):
+        # 1. Liste PNG-Dateien auf
+          png_files = list(self.folder_path.glob("*.png"))
+          if len(png_files) == 0:
+              return None  # kehre früh zurück, wenn nichts zu committen ist
+
+        # 2. Zippe PNG-Dateien in ein einzelnes Archiv
+        with tempfile.TemporaryDirectory() as tmpdir:
+            archive_path = Path(tmpdir) / "train.zip"
+            with zipfile.ZipFile(archive_path, "w", zipfile.ZIP_DEFLATED) as zip:
+                for png_file in png_files:
+                    zip.write(filename=png_file, arcname=png_file.name)
+
+            # 3. Lade das Archiv hoch
+            self.api.upload_file(..., path_or_fileobj=archive_path)
+
+        # 4. Lösche lokale PNG-Dateien, um späteres erneutes Hochladen zu vermeiden
+        for png_file in png_files:
+            png_file.unlink()
+```
+
+Wenn Sie `push_to_hub` überschreiben, haben Sie Zugriff auf die Attribute vom [`CommitScheduler`] und insbesondere:
+- [`HfApi`] Client: `api`
+- Ordnerparameter: `folder_path` und `path_in_repo`
+- Repo-Parameter: `repo_id`, `repo_type`, `revision`
+- Das Thread-Lock: `lock`
+
+<Tip>
+
+Für weitere Beispiele von benutzerdefinierten Schedulern, schauen Sie sich unseren [Demo Space](https://huggingface.co/spaces/Wauplin/space_to_dataset_saver) an, der verschiedene Implementierungen je nach Ihren Anforderungen enthält.
+
+</Tip>
+
+### create_commit
+
+Die Funktionen [`upload_file`] und [`upload_folder`] sind High-Level-APIs, die im Allgemeinen bequem zu verwenden sind. Wir empfehlen, diese Funktionen zuerst auszuprobieren, wenn Sie nicht auf einer niedrigeren Ebene arbeiten müssen. Wenn Sie jedoch auf Commit-Ebene arbeiten möchten, können Sie die Funktion [`create_commit`] direkt verwenden.
+
+Es gibt drei von [`create_commit`] unterstützte Operationstypen:
+
+- [`CommitOperationAdd`] lädt eine Datei in den Hub hoch. Wenn die Datei bereits existiert, werden die Dateiinhalte überschrieben. Diese Operation akzeptiert zwei Argumente:
+
+  - `path_in_repo`: der Repository-Pfad, um eine Datei hochzuladen.
+  - `path_or_fileobj`: entweder ein Pfad zu einer Datei auf Ihrem Dateisystem oder ein Datei-ähnliches Objekt. Dies ist der Inhalt der Datei, die auf den Hub hochgeladen werden soll.
+- [`CommitOperationDelete`] entfernt eine Datei oder einen Ordner aus einem Repository. Diese Operation akzeptiert path_in_repo als Argument.
+- [`CommitOperationCopy`] kopiert eine Datei innerhalb eines Repositorys. Diese Operation akzeptiert drei Argumente:
+  - `src_path_in_repo`: der Repository-Pfad der zu kopierenden Datei.
+  - `path_in_repo`: der Repository-Pfad, wohin die Datei kopiert werden soll.
+  - `src_revision`: optional - die Revision der zu kopierenden Datei, wenn Sie eine Datei von einem anderen Branch/Revision kopieren möchten.
+
+Zum Beispiel, wenn Sie zwei Dateien hochladen und eine Datei in einem Hub-Repository löschen möchten:
+
+1. Verwenden Sie die entsprechende `CommitOperation`, um eine Datei hinzuzufügen oder zu löschen und einen Ordner zu löschen:
+
+```py
+>>> from huggingface_hub import HfApi, CommitOperationAdd, CommitOperationDelete
+>>> api = HfApi()
+>>> operations = [
+...     CommitOperationAdd(path_in_repo="LICENSE.md", path_or_fileobj="~/repo/LICENSE.md"),
+...     CommitOperationAdd(path_in_repo="weights.h5", path_or_fileobj="~/repo/weights-final.h5"),
+...     CommitOperationDelete(path_in_repo="old-weights.h5"),
+...     CommitOperationDelete(path_in_repo="logs/"),
+...     CommitOperationCopy(src_path_in_repo="image.png", path_in_repo="duplicate_image.png"),
+... ]
+```
+
+2. Übergeben Sie Ihre Operationen an [`create_commit`]:
+
+```py
+>>> api.create_commit(
+...     repo_id="lysandre/test-model",
+...     operations=operations,
+...     commit_message="Hochladen meiner Modell-Gewichte und -Lizenz",
+... )
+```
+
+Zusätzlich zu [`upload_file`] und [`upload_folder`] verwenden auch die folgenden Funktionen [`create_commit`] im Hintergrund:
+
+- [`delete_file`] löscht eine einzelne Datei aus einem Repository auf dem Hub.
+- [`delete_folder`] löscht einen gesamten Ordner aus einem Repository auf dem Hub.
+- [`metadata_update`] aktualisiert die Metadaten eines Repositorys.
+
+Für detailliertere Informationen werfen Sie einen Blick auf die [`HfApi`] Referenz.
+
+## Tipps und Tricks für große Uploads
+
+Bei der Verwaltung einer großen Datenmenge in Ihrem Repo gibt es einige Einschränkungen zu beachten. Angesichts der Zeit, die es dauert, die Daten zu streamen, kann es sehr ärgerlich sein, am Ende des Prozesses einen Upload/Push zu verlieren oder eine degradierte Erfahrung zu machen, sei es auf hf.co oder bei lokalem Arbeiten. Wir haben eine Liste von Tipps und Empfehlungen zusammengestellt, um Ihr Repo zu strukturieren.
+
+| Eigenschaft     | Empfohlen        | Tipps                                                  |
+| ----------------   | ------------------ | ------------------------------------------------------ |
+| Repo-Größe         | -                  | Kontaktieren Sie uns für große Repos (TBs Daten)               |
+| Dateien pro Repo     | <100k              | Daten in weniger Dateien zusammenführen                            |
+| Einträge pro Ordner | <10k               | Unterverzeichnisse im Repo verwenden                             |
+| Dateigröße         | <5GB               | Daten in geteilte Dateien aufteilen                          |
+| Commit-Größe        | <100 files*        | Dateien in mehreren Commits hochladen                       |
+| Commits pro Repo   | -                  | Mehrere Dateien pro Commit hochladen und/oder Historie zusammenführen |
+
+_* Nicht relevant bei direkter Verwendung des `git` CLI_
+
+Bitte lesen Sie den nächsten Abschnitt, um diese Beschränkungen besser zu verstehen und zu erfahren, wie Sie damit umgehen können.
+
+### Hub-Repository Größenbeschränkungen
+
+Was meinen wir, wenn wir von "großen Uploads" sprechen, und welche Einschränkungen sind damit verbunden? Große Uploads können sehr unterschiedlich sein, von Repositories mit einigen riesigen Dateien (z. B. Modellgewichten) bis hin zu Repositories mit Tausenden von kleinen Dateien (z. B. einem Bilddatensatz).
+
+Hinter den Kulissen verwendet der Hub Git zur Versionierung der Daten, was strukturelle Auswirkungen darauf hat, was Sie in Ihrem Repo tun können.
+Wenn Ihr Repo einige der im vorherigen Abschnitt erwähnten Zahlen überschreitet, **empfehlen wir Ihnen dringend, [`git-sizer`](https://github.com/github/git-sizer) zu verwenden**, das eine sehr detaillierte Dokumentation über die verschiedenen Faktoren bietet, die Ihr Erlebnis beeinflussen werden. Hier ist ein TL;DR der zu berücksichtigenden Faktoren:
+
+- **Repository-Größe**: Die Gesamtgröße der Daten, die Sie hochladen möchten. Es gibt keine feste Obergrenze für die Größe eines Hub-Repositories. Wenn Sie jedoch vorhaben, Hunderte von GBs oder sogar TBs an Daten hochzuladen, würden wir es begrüßen, wenn Sie uns dies im Voraus mitteilen könnten, damit wir Ihnen besser helfen können, falls Sie während des Prozesses Fragen haben. Sie können uns unter datasets@huggingface.co oder auf [unserem Discord](http://hf.co/join/discord) kontaktieren.
+- **Anzahl der Dateien**:
+    - Für ein optimales Erlebnis empfehlen wir, die Gesamtzahl der Dateien unter 100k zu halten. Versuchen Sie, die Daten zu weniger Dateien zusammenzuführen, wenn Sie mehr haben.
+      Zum Beispiel können json-Dateien zu einer einzigen jsonl-Datei zusammengeführt oder große Datensätze als Parquet-Dateien exportiert werden.
+    - Die maximale Anzahl von Dateien pro Ordner darf 10k Dateien pro Ordner nicht überschreiten. Eine einfache Lösung besteht darin, eine Repository-Struktur zu erstellen, die Unterverzeichnisse verwendet. Ein Repo mit 1k Ordnern von `000/` bis `999/`, in dem jeweils maximal 1000 Dateien enthalten sind, reicht bereits aus.
+- **Dateigröße**: Bei hochzuladenden großen Dateien (z. B. Modellgewichte) empfehlen wir dringend, sie **in Blöcke von etwa 5GB aufzuteilen**. 
+Es gibt mehrere Gründe dafür:
+    - Das Hoch- und Herunterladen kleinerer Dateien ist sowohl für Sie als auch für andere Benutzer viel einfacher. Bei der Datenübertragung können immer Verbindungsprobleme auftreten, und kleinere Dateien vermeiden das erneute Starten von Anfang an im Falle von Fehlern.
+    - Dateien werden den Benutzern über CloudFront bereitgestellt. Aus unserer Erfahrung werden riesige Dateien von diesem Dienst nicht zwischengespeichert, was zu einer langsameren Downloadgeschwindigkeit führt. 
+In jedem Fall wird keine einzelne LFS-Datei >50GB sein können. D. h. 50GB ist das absolute Limit für die Einzeldateigröße.
+- **Anzahl der Commits**: Es gibt kein festes Limit für die Gesamtzahl der Commits in Ihrer Repo-Historie. Aus unserer Erfahrung heraus beginnt das Benutzererlebnis im Hub jedoch nach einigen Tausend Commits abzunehmen. Wir arbeiten ständig daran, den Service zu verbessern, aber man sollte immer daran denken, dass ein Git-Repository nicht als Datenbank mit vielen Schreibzugriffen gedacht ist. Wenn die Historie Ihres Repos sehr groß wird, können Sie immer alle Commits mit [`super_squash_history`] zusammenfassen, um einen Neuanfang zu erhalten. Dies ist eine nicht rückgängig zu machende Operation.
+- **Anzahl der Operationen pro Commit**: Auch hier gibt es keine feste Obergrenze. Wenn ein Commit im Hub hochgeladen wird, wird jede Git-Operation (Hinzufügen oder Löschen) vom Server überprüft. Wenn hundert LFS-Dateien auf einmal committed werden, wird jede Datei einzeln überprüft, um sicherzustellen, dass sie korrekt hochgeladen wurde. Beim Pushen von Daten über HTTP mit `huggingface_hub` wird ein Timeout von 60s für die Anforderung festgelegt, was bedeutet, dass, wenn der Prozess mehr Zeit in Anspruch nimmt, clientseitig ein Fehler ausgelöst wird. Es kann jedoch (in seltenen Fällen) vorkommen, dass selbst wenn das Timeout clientseitig ausgelöst wird, der Prozess serverseitig dennoch abgeschlossen wird. Dies kann manuell überprüft werden, indem man das Repo im Hub durchsucht. Um dieses Timeout zu vermeiden, empfehlen wir, pro Commit etwa 50-100 Dateien hinzuzufügen.
+
+### Praktische Tipps
+
+Nachdem wir die technischen Aspekte gesehen haben, die Sie bei der Strukturierung Ihres Repositories berücksichtigen müssen, schauen wir uns einige praktische Tipps an, um Ihren Upload-Prozess so reibungslos wie möglich zu gestalten.
+
+- **Fangen Sie klein an**: Wir empfehlen, mit einer kleinen Datenmenge zu beginnen, um Ihr Upload-Skript zu testen. Es ist einfacher, an einem Skript zu arbeiten, wenn ein Fehler nur wenig Zeit kostet.
+- **Rechnen Sie mit Ausfällen**: Das Streamen großer Datenmengen ist eine Herausforderung. Sie wissen nicht, was passieren kann, aber es ist immer am besten anzunehmen, dass etwas mindestens einmal schiefgehen wird - unabhängig davon, ob es an Ihrem Gerät, Ihrer Verbindung oder unseren Servern liegt. Wenn Sie zum Beispiel vorhaben, eine große Anzahl von Dateien hochzuladen, ist es am besten, lokal zu verfolgen, welche Dateien Sie bereits hochgeladen haben, bevor Sie die nächste Batch hochladen. Sie können sicher sein, dass eine LFS-Datei, die bereits committed wurde, niemals zweimal hochgeladen wird, aber es kann clientseitig trotzdem Zeit sparen, dies zu überprüfen.
+- **Verwenden Sie `hf_transfer`**: Dabei handelt es sich um eine auf Rust basierende [Bibliothek](https://github.com/huggingface/hf_transfer), die dazu dient, Uploads auf Maschinen mit sehr hoher Bandbreite zu beschleunigen. Um sie zu verwenden, müssen Sie sie installieren (`pip install hf_transfer`) und sie durch Einstellen von `HF_HUB_ENABLE_HF_TRANSFER=1` als Umgebungsvariable aktivieren. Anschließend können Sie `huggingface_hub` wie gewohnt verwenden. 
+Hinweis: Dies ist ein Tool für Power-User. Es ist getestet und einsatzbereit, verfügt jedoch nicht über benutzerfreundliche Funktionen wie Fortschrittsanzeigen oder erweiterte Fehlerbehandlung.
+
+## (veraltet) Dateien mit Git LFS hochladen
+
+Alle oben beschriebenen Methoden verwenden die Hub-API, um Dateien hochzuladen. Dies ist der empfohlene Weg, Dateien in den Hub hochzuladen. 
+Wir bieten jedoch auch [`Repository`] an, einen Wrapper um das git-Tool, um ein lokales Repository zu verwalten.
+
+<Tip warning={true}>
+
+Obwohl [`Repository`] formell nicht als veraltet gekennzeichnet ist, empfehlen wir stattdessen die Nutzung der HTTP-basierten Methoden, die oben beschrieben sind.
+Für weitere Details zu dieser Empfehlung werfen Sie bitte einen Blick auf diesen [Leitfaden](../concepts/git_vs_http), der die Kernunterschiede zwischen HTTP- und Git-basierten Ansätzen erklärt.
+
+</Tip>
+
+Git LFS verarbeitet automatisch Dateien, die größer als 10MB sind. Für sehr große Dateien (>5GB) müssen Sie jedoch einen benutzerdefinierten Transferagenten für Git LFS installieren:
+
+```bash
+huggingface-cli lfs-enable-largefiles
+```
+
+Sie sollten dies für jedes Repository installieren, das eine sehr große Datei enthält. Einmal installiert, können Sie Dateien hochladen, die größer als 5GB sind.
+
+### commit Kontextmanager
+
+Der `commit` Kontextmanager handhabt vier der gängigsten Git-Befehle: pull, add, commit und push. `git-lfs` beobactet automatisch jede Datei, die größer als 10MB ist. Im folgenden Beispiel handhabt der `commit` Kontextmanager die folgenden Aufgaben:
+
+1. Holt Daten aus dem `text-files` Repository.
+2. Fügt eine Änderung an `file.txt` hinzu.
+3. Committet die Änderung.
+4. Schickt die Änderung an das `text-files` Repository.
+
+```python
+>>> from huggingface_hub import Repository
+>>> with Repository(local_dir="text-files", clone_from="<user>/text-files").commit(commit_message="Mein erste Datei :)"):
+...     with open("file.txt", "w+") as f:
+...         f.write(json.dumps({"hey": 8}))
+```
+
+Hier ist ein weiteres Beispiel, wie man den `commit` Kontextmanager verwendet, um eine Datei in einem Repository zu speichern und hochzuladen:
+
+```python
+>>> import torch
+>>> model = torch.nn.Transformer()
+>>> with Repository("torch-model", clone_from="<user>/torch-model", token=True).commit(commit_message="Mein cooles Model :)"):
+...     torch.save(model.state_dict(), "model.pt")
+```
+
+Setzen Sie `blocking=False`, wenn Sie Ihre Commits asynchron pushen möchten. Das nicht-blockierende Verhalten ist nützlich, wenn Sie Ihr Skript weiterhin ausführen möchten, während Ihre Commits gesendet werden.
+
+```python
+>>> with repo.commit(commit_message="Mein cooles Model :)", blocking=False)
+```
+
+Sie können den Status Ihres Pushs mit der Methode `command_queue` überprüfen:
+
+```python
+>>> last_command = repo.command_queue[-1]
+>>> last_command.status
+```
+
+Beachten Sie die Tabelle mit möglichen Statuscodes:
+
+| Status   | Beschreibung                         |
+| -------- | ------------------------------------ |
+| -1       | Der Push wird ausgeführt.            |
+| 0        | Der Push wurde erfolgreich beendet.  |
+| Non-zero | Ein Fehler ist aufgetreten.          |
+
+Wenn `blocking=False` gesetzt ist, werden Befehle beobachtet und Ihr Skript wird erst beendet, wenn alle Pushs abgeschlossen sind, auch wenn andere Fehler in Ihrem Skript auftreten. Einige zusätzliche nützliche Befehle, um den Status eines Pushs zu überprüfen, sind:
+
+```python
+# Einen Fehler inspizieren.
+>>> last_command.stderr
+
+# Überprüfen, ob ein Push abgeschlossen ist oder noch läuft.
+>>> last_command.is_done
+
+# Überprüfen, ob bei einem Push-Befehl ein Fehler aufgetreten ist.
+>>> last_command.failed
+```
+
+### push_to_hub
+
+Die Klasse [`Repository`] hat eine Funktion [`~Repository.push_to_hub`], um Dateien hinzuzufügen, einen Commit zu machen und diese zu einem Repository zu pushen. Im Gegensatz zum `commit` Kontextmanager müssen Sie zuerst von einem Repository pullen, bevor Sie [`~Repository.push_to_hub`] aufrufen.
+
+Zum Beispiel, wenn Sie bereits ein Repository vom Hub geklont haben, können Sie das `repo` vom lokalen Verzeichnis initialisieren:
+
+```python
+>>> from huggingface_hub import Repository
+>>> repo = Repository(local_dir="pfad/zur/lokalen/repo")
+```
+Aktualisieren Sie Ihren lokalen Klon mit [`~Repository.git_pull`] und dann pushen Sie Ihre Datei zum Hub:
+
+```py
+>>> repo.git_pull()
+>>> repo.push_to_hub(commit_message="Committe meine geniale Datei zum Hub")
+```
+
+Wenn Sie jedoch noch nicht bereit sind, eine Datei zu pushen, können Sie [`~Repository.git_add`] und [`~Repository.git_commit`] verwenden, um nur Ihre Datei hinzuzufügen und zu committen:
+
+```py
+>>> repo.git_add("path/to/file")
+>>> repo.git_commit(commit_message="füge meine erste Modell-Konfigurationsdatei hinzu :)")
+```
+
+Wenn Sie bereit sind, pushen Sie die Datei zu Ihrem Repository mit [`~Repository.git_push`]:
+
+```py
+>>> repo.git_push()
+```
\ No newline at end of file
diff --git a/docs/source/de/guides/webhooks_server.md b/docs/source/de/guides/webhooks_server.md
new file mode 100644
index 00000000..1cede51c
--- /dev/null
+++ b/docs/source/de/guides/webhooks_server.md
@@ -0,0 +1,159 @@
+<!--⚠️ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
+rendered properly in your Markdown viewer.
+-->
+
+# Webhooks Server
+
+Webhooks sind ein Grundpfeiler für MLOps-bezogene Funktionen. Sie ermöglichen es Ihnen, auf neue Änderungen in bestimmten Repos oder auf alle Repos, die bestimmten Benutzern/Organisationen gehören, die Sie interessieren, zu hören. Dieser Leitfaden erklärt, wie Sie den `huggingface_hub` nutzen können, um einen Server zu erstellen, der auf Webhooks hört und ihn in einen Space zu implementieren. Es wird davon ausgegangen, dass Sie mit dem Konzept der Webhooks auf dem Huggingface Hub vertraut sind. Um mehr über Webhooks selbst zu erfahren, können Sie zuerst diesen [Leitfaden](https://huggingface.co/docs/hub/webhooks) lesen.
+
+Die Basis-Klasse, die wir in diesem Leitfaden verwenden werden, ist der [`WebhooksServer`]. Es handelt sich um eine Klasse, mit der sich ein Server leicht konfigurieren lässt, der Webhooks vom Huggingface Hub empfangen kann. Der Server basiert auf einer Gradio-App. Er verfügt über eine Benutzeroberfläche zur Anzeige von Anweisungen für Sie oder Ihre Benutzer und eine API zum Hören auf Webhooks.
+
+<Tip>
+
+Um ein Beispiel eines laufenden Webhook-Servers zu sehen, werfen Sie einen Blick auf den [Spaces CI Bot](https://huggingface.co/spaces/spaces-ci-bot/webhook). Es handelt sich um einen Space, der kurzlebige Umgebungen startet, wenn ein PR in einem Space geöffnet wird.
+
+</Tip>
+
+<Tip warning={true}>
+
+Dies ist ein [experimentelles Feature](../package_reference/environment_variables#hfhubdisableexperimentalwarning). Das bedeutet, dass wir noch daran arbeiten, die API zu verbessern. Es könnten in der Zukunft ohne vorherige Ankündigung Änderungen vorgenommen werden. Stellen Sie sicher, dass Sie die Version des `huggingface_hub` in Ihren Anforderungen festlegen.
+
+</Tip>
+
+
+## Einen Endpunkt erstellen
+
+Das Implementieren eines Webhook-Endpunkts ist so einfach wie das Dekorieren einer Funktion. Lassen Sie uns ein erstes Beispiel betrachten, um die Hauptkonzepte zu erklären:
+
+```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":
+        # Einen Trainingsjob auslösen, wenn ein Datensatz aktualisiert wird
+        ...
+```
+
+Speichern Sie diesen Ausschnitt in einer Datei namens `'app.py'` und führen Sie ihn mit `'python app.py'` aus. Sie sollten eine Nachricht wie diese sehen:
+
+```text
+Webhook secret is not defined. This means your webhook endpoints will be open to everyone.
+To add a secret, set `WEBHOOK_SECRET` as environment variable or pass it at initialization: 
+        `app = WebhooksServer(webhook_secret='my_secret', ...)`
+For more details about webhook secrets, please refer to https://huggingface.co/docs/hub/webhooks#webhook-secret.
+Running on local URL:  http://127.0.0.1:7860
+Running on public URL: https://1fadb0f52d8bf825fc.gradio.live
+
+This share link expires in 72 hours. For free permanent hosting and GPU upgrades (NEW!), check out Spaces: https://huggingface.co/spaces
+
+Webhooks are correctly setup and ready to use:
+  - POST https://1fadb0f52d8bf825fc.gradio.live/webhooks/trigger_training
+Go to https://huggingface.co/settings/webhooks to setup your webhooks.
+```
+
+Gute Arbeit! Sie haben gerade einen Webhook-Server gestartet! Lassen Sie uns genau aufschlüsseln, was passiert ist:
+
+1. Durch das Dekorieren einer Funktion mit [`webhook_endpoint`] wurde im Hintergrund ein [`WebhooksServer`]-Objekt erstellt. Wie Sie sehen können, handelt es sich bei diesem Server um eine Gradio-App, die unter http://127.0.0.1:7860 läuft. Wenn Sie diese URL in Ihrem Browser öffnen, sehen Sie eine Landing Page mit Anweisungen zu den registrierten Webhooks.
+2. Eine Gradio-App ist im Kern ein FastAPI-Server. Eine neue POST-Route `/webhooks/trigger_training` wurde hinzugefügt. Dies ist die Route, die auf Webhooks hört und die Funktion `trigger_training` ausführt, wenn sie ausgelöst wird. FastAPI wird das Payload automatisch parsen und es der Funktion als [`WebhookPayload`]-Objekt übergeben. Dies ist ein `pydantisches` Objekt, das alle Informationen über das Ereignis enthält, das den Webhook ausgelöst hat.
+3. Die Gradio-App hat auch einen Tunnel geöffnet, um Anfragen aus dem Internet zu empfangen. Das Interessante daran ist: Sie können einen Webhook auf https://huggingface.co/settings/webhooks konfigurieren, der auf Ihren lokalen Rechner zeigt. Dies ist nützlich zum Debuggen Ihres Webhook-Servers und zum schnellen Iterieren, bevor Sie ihn in einem Space bereitstellen.
+4. Schließlich teilen Ihnen die Logs auch mit, dass Ihr Server derzeit nicht durch ein Geheimnis gesichert ist. Dies ist für das lokale Debuggen nicht problematisch, sollte aber für später berücksichtigt werden.
+
+<Tip warning={true}>
+
+Standardmäßig wird der Server am Ende Ihres Skripts gestartet. Wenn Sie es in einem Notizbuch ausführen, können Sie den Server manuell starten, indem Sie `decorated_function.run()` aufrufen. Da ein einzigartiger Server verwendet wird, müssen Sie den Server nur einmal starten, auch wenn Sie mehrere Endpunkte haben.
+
+</Tip>
+
+
+## Konfigurieren eines Webhook
+
+Jetzt, da Sie einen Webhook-Server am Laufen haben, möchten Sie einen Webhook konfigurieren, um Nachrichten zu empfangen.
+Gehen Sie zu https://huggingface.co/settings/webhooks, klicken Sie auf "Add a new webhook" und konfigurieren Sie Ihren Webhook. Legen Sie die Ziel-Repositories fest, die Sie beobachten möchten, und die Webhook-URL, hier `https://1fadb0f52d8bf825fc.gradio.live/webhooks/trigger_training`. 
+
+<div class="flex justify-center">
+<img src="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/hub/configure_webhook.png"/>
+</div>
+
+Und das war's! Sie können den Webhook jetzt auslösen, indem Sie das Ziel-Repository aktualisieren (z.B. einen Commit pushen). Überprüfen Sie den Aktivitäts-Tab Ihres Webhooks, um die ausgelösten Ereignisse zu sehen. Jetzt, wo Sie eine funktionierende Einrichtung haben, können Sie sie testen und schnell iterieren. Wenn Sie Ihren Code ändern und den Server neu starten, könnte sich Ihre öffentliche URL ändern. Stellen Sie sicher, dass Sie die Webhook-Konfiguration im Hub bei Bedarf aktualisieren.
+
+## Bereitstellung in einem Space
+
+Jetzt, da Sie einen funktionierenden Webhook-Server haben, ist das Ziel, ihn in einem Space bereitzustellen. Gehen Sie zu https://huggingface.co/new-space, um einen Space zu erstellen. Geben Sie ihm einen Namen, wählen Sie das Gradio SDK und klicken Sie auf "Create Space". Laden Sie Ihren Code in den Space in einer Datei namens `app.py` hoch. Ihr Space wird automatisch gestartet! Für weitere Informationen zu Spaces lesen Sie bitte diesen [Leitfaden](https://huggingface.co/docs/hub/spaces-overview).
+
+Ihr Webhook-Server läuft nun auf einem öffentlichen Space. In den meisten Fällen möchten Sie ihn mit einem Geheimnis absichern. Gehen Sie zu Ihren Space-Einstellungen > Abschnitt "Repository secrets" > "Add a secret". Setzen Sie die Umgebungsvariable `WEBHOOK_SECRET` auf den von Ihnen gewählten Wert. Gehen Sie zurück zu den [Webhook-Einstellungen](https://huggingface.co/settings/webhooks) und setzen Sie das Geheimnis in der Webhook-Konfiguration. Jetzt werden von Ihrem Server nur Anfragen mit dem korrekten Geheimnis akzeptiert.
+
+Und das war's! Ihr Space ist nun bereit, Webhooks vom Hub zu empfangen. Bitte beachten Sie, dass wenn Sie den Space auf einer kostenlosen 'cpu-basic' Hardware ausführen, er nach 48 Stunden Inaktivität heruntergefahren wird. Wenn Sie einen permanenten Space benötigen, sollten Sie in Erwägung ziehen, auf eine [upgraded hardware](https://huggingface.co/docs/hub/spaces-gpus#hardware-specs) umzustellen.
+
+## Erweiterte Nutzung
+
+Der obenstehende Leitfaden erklärte den schnellsten Weg, einen [`WebhooksServer`] einzurichten. In diesem Abschnitt werden wir sehen, wie man ihn weiter anpassen kann.
+
+### Mehrere Endpunkte
+
+Sie können mehrere Endpunkte auf demselben Server registrieren. Beispielsweise möchten Sie vielleicht einen Endpunkt haben, um einen Trainingsjob auszulösen und einen anderen, um eine Modellevaluierung auszulösen. Dies können Sie tun, indem Sie mehrere `@webhook_endpoint`-Dekorateure hinzufügen:
+
+```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":
+        # Einen Trainingsjob auslösen, wenn ein Datensatz aktualisiert wird
+        ...
+
+@webhook_endpoint
+async def trigger_evaluation(payload: WebhookPayload) -> None:
+    if payload.repo.type == "model" and payload.event.action == "update":
+        # Einen Evaluierungsauftrag auslösen, wenn ein Modell aktualisiert wird
+        ...
+```
+
+Dies wird zwei Endpunkte erstellen:
+
+```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
+```
+
+### Benutzerdefinierter Server
+
+Um mehr Flexibilität zu erhalten, können Sie auch direkt ein [`WebhooksServer`] Objekt erstellen. Dies ist nützlich, wenn Sie die Startseite Ihres Servers anpassen möchten. Sie können dies tun, indem Sie eine [Gradio UI](https://gradio.app/docs/#blocks) übergeben, die die Standard-UI überschreibt. Zum Beispiel können Sie Anweisungen für Ihre Benutzer hinzufügen oder ein Formular zur manuellen Auslösung der Webhooks hinzufügen. Bei der Erstellung eines [`WebhooksServer`] können Sie mit dem Dekorateur [`~WebhooksServer.add_webhook`] neue Webhooks registrieren.
+
+Hier ist ein vollständiges Beispiel:
+
+```python
+import gradio as gr
+from fastapi import Request
+from huggingface_hub import WebhooksServer, WebhookPayload
+
+# 1. Benutzerdefinierte UI definieren
+with gr.Blocks() as ui:
+    ...
+
+# 2. Erstellen eines WebhooksServer mit benutzerdefinierter UI und Geheimnis
+app = WebhooksServer(ui=ui, webhook_secret="my_secret_key")
+
+# 3. Webhook mit explizitem Namen registrieren
+@app.add_webhook("/say_hello")
+async def hello(payload: WebhookPayload):
+    return {"message": "hello"}
+
+# 4. Webhook mit implizitem Namen registrierene
+@app.add_webhook
+async def goodbye(payload: WebhookPayload):
+    return {"message": "goodbye"}
+
+# 5. Server starten (optional)
+app.run()
+```
+
+1. Wir definieren eine benutzerdefinierte UI mit Gradio-Blöcken. Diese UI wird auf der Startseite des Servers angezeigt.
+2. Wir erstellen ein [`WebhooksServer`]-Objekt mit einer benutzerdefinierten UI und einem Geheimnis. Das Geheimnis ist optional und kann mit der `WEBHOOK_SECRET` Umgebungsvariable gesetzt werden.
+3. Wir registrieren einen Webhook mit einem expliziten Namen. Dies wird einen Endpunkt unter `/webhooks/say_hello` erstellen.
+4. Wir registrieren einen Webhook mit einem impliziten Namen. Dies wird einen Endpunkt unter `/webhooks/goodbye` erstellen.
+5. Wir starten den Server. Dies ist optional, da Ihr Server automatisch am Ende des Skripts gestartet wird.
\ No newline at end of file
diff --git a/docs/source/de/index.md b/docs/source/de/index.md
new file mode 100644
index 00000000..f02bb0d9
--- /dev/null
+++ b/docs/source/de/index.md
@@ -0,0 +1,42 @@
+<!--⚠️ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
+rendered properly in your Markdown viewer.
+-->
+
+# 🤗 Hub client bibliothek
+
+Die `huggingface_hub` Bibliothek ermöglicht die Interaktion mit dem [Hugging Face Hub](https://hf.co), einer Plattform für maschinelles Lernen, die für Entwickler und Mitwirkende konzipiert ist. Hier können Sie vorab trainierte Modelle und Datensätze entdecken, mit zahlreichen Apps für maschinelles Lernen experimentieren und eigene Modelle sowie Datensätze mit der Community teilen. Die `huggingface_hub` Bibliothek macht es einfach, all das in Python umzusetzen.
+
+In der [Kurzanleitung](quick-start) der `huggingface_hub` Bibliothek erfahren Sie wie Sie Dateien vom Hub herunterladen, Repositories erstellen und Inhalte auf den Hub hochladen können. Weiterführend können Sie sich über Verwaltung von Repositories, die Interaktion in Diskussionen und den Zugriff auf die Inferenz-API auf dem 🤗 Hub informieren.
+
+<div class="mt-10">
+  <div class="w-full flex flex-col space-y-4 md:space-y-0 md:grid md:grid-cols-2 md:gap-y-4 md:gap-x-5">
+
+    <a class="!no-underline border dark:border-gray-700 p-5 rounded-lg shadow hover:shadow-lg" href="./guides/overview">
+      <div class="w-full text-center bg-gradient-to-br from-indigo-400 to-indigo-500 rounded-lg py-1.5 font-semibold mb-5 text-white text-lg leading-relaxed">Schritt-für-Schritt-Anleitungen</div>
+      <p class="text-gray-700">Praktische Leitfäden, um ein bestimmtes Ziel zu erreichen. Durchstöbern Sie diese Anleitungen, um zu erfahren, wie Sie mit huggingface_hub echte Herausforderungen meistern können.</p>
+    </a>
+
+    <a class="!no-underline border dark:border-gray-700 p-5 rounded-lg shadow hover:shadow-lg" href="./package_reference/overview">
+      <div class="w-full text-center bg-gradient-to-br from-purple-400 to-purple-500 rounded-lg py-1.5 font-semibold mb-5 text-white text-lg leading-relaxed">Referenz</div>
+      <p class="text-gray-700">Umfassende und technische Beschreibung der Klassen und Methoden von huggingface_hub.</p>
+    </a>
+
+    <a class="!no-underline border dark:border-gray-700 p-5 rounded-lg shadow hover:shadow-lg" href="./concepts/git_vs_http">
+      <div class="w-full text-center bg-gradient-to-br from-pink-400 to-pink-500 rounded-lg py-1.5 font-semibold mb-5 text-white text-lg leading-relaxed">Konzeptionelle Leitfäden</div>
+      <p class="text-gray-700">Methodische Erklärungen zum Aufbau eines besseren Verständnisses der Huggingface_hub-Philosophie.</p>
+    </a>
+
+  </div>
+</div>
+
+<!-- 
+<a class="!no-underline border dark:border-gray-700 p-5 rounded-lg shadow hover:shadow-lg" href="./tutorials/overview"
+  ><div class="w-full text-center bg-gradient-to-br from-blue-400 to-blue-500 rounded-lg py-1.5 font-semibold mb-5 text-white text-lg leading-relaxed">Tutorials</div>
+  <p class="text-gray-700">Learn the basics and become familiar with using huggingface_hub to programmatically interact with the 🤗 Hub!</p>
+</a> -->
+
+## Beitragen
+
+Alle Beiträge zum `huggingface_hub` sind willkommen und werden gleichermaßen geschätzt! 🤗 Neben dem Hinzufügen neuer Features oder dem Beheben von Problemen können Sie auch zur Verbesserung der Dokumentation beitragen, indem Sie ihre Richtigkeit und Aktualität gewährleisten. Sie können auch bei der Lösung von Fragen mithelfen oder neue Features vorschlagen, um die Bibliothek weiterzuentwickeln. Schauen Sie in die [Beitragsrichtlinien](https://github.com/huggingface/huggingface_hub/blob/main/CONTRIBUTING.md), um mehr zu erfahren über das Melden von Problemen, das Vorschlagen von Features, das Einreichen eines Pull Requests, und das Testen Ihrer Code-Einsendungen, um sicherzustellen dass alles so wie erwartet funktioniert.
+
+Mitwirkende halten sich bitte an unseren [Verhaltenskodex](https://github.com/huggingface/huggingface_hub/blob/main/CODE_OF_CONDUCT.md), um eine inklusive und einladende Umgebung zur Zusammenarbeit für Alle zu gewährleisten.
\ No newline at end of file
diff --git a/docs/source/de/installation.md b/docs/source/de/installation.md
new file mode 100644
index 00000000..32462213
--- /dev/null
+++ b/docs/source/de/installation.md
@@ -0,0 +1,132 @@
+<!--⚠️ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
+rendered properly in your Markdown viewer.
+-->
+
+# Installation
+
+Bevor Sie beginnen, müssen Sie Ihre Umgebung vorbereiten, indem Sie die entsprechenden Pakete installieren.
+
+`huggingface_hub` wurde für **Python 3.8+** getestet.
+
+## Installation mit pip
+
+Es wird dringend empfohlen, `huggingface_hub` in einer [virtuellen Umgebung](https://docs.python.org/3/library/venv.html) zu installieren. Wenn Sie mit virtuellen Umgebungen in Python nicht vertraut sind, werfen Sie einen Blick auf diesen [Leitfaden](https://packaging.python.org/en/latest/guides/installing-using-pip-and-virtual-environments/). Eine virtuelle Umgebung erleichtert die Verwaltung verschiedener Projekte und verhindert Kompatibilitätsprobleme zwischen Abhängigkeiten.
+
+Beginnen Sie damit, eine virtuelle Umgebung in Ihrem Projektverzeichnis zu erstellen:
+
+```bash
+python -m venv .env
+```
+
+Aktivieren Sie die virtuelle Umgebung. Unter Linux und macOS:
+
+```bash
+source .env/bin/activate
+```
+
+Aktivieren der virtuellen Umgebung unter Windows:
+
+```bash
+.env/Scripts/activate
+```
+
+Jetzt können Sie `huggingface_hub` aus dem [PyPi-Register](https://pypi.org/project/huggingface-hub/) installieren:
+
+```bash
+pip install --upgrade huggingface_hub
+```
+
+Überprüfen Sie nach Abschluss, ob die [Installation korrekt funktioniert](#installation-berprfen).
+
+### Installieren optionaler Abhängigkeiten
+
+Einige Abhängigkeiten von `huggingface_hub` sind [optional](https://setuptools.pypa.io/en/latest/userguide/dependency_management.html#optional-dependencies), da sie nicht notwendig sind, um die Kernfunktionen von `huggingface_hub` auszuführen. Allerdings könnten einige Funktionen von `huggingface_hub` nicht verfügbar sein, wenn die optionalen Abhängigkeiten nicht installiert sind.
+
+Sie können optionale Abhängigkeiten über `pip` installieren:
+```bash
+# Abhängigkeiten für spezifische TensorFlow-Funktionen installieren
+# /!\ Achtung: dies entspricht nicht `pip install tensorflow`
+pip install 'huggingface_hub[tensorflow]'
+
+# Abhängigkeiten sowohl für torch-spezifische als auch für CLI-spezifische Funktionen installieren.
+pip install 'huggingface_hub[cli,torch]'
+```
+
+Hier ist die Liste der optionalen Abhängigkeiten in huggingface_hub:
+
+- `cli`: bietet eine komfortablere CLI-Schnittstelle für huggingface_hub.
+- `fastai`, `torch`, `tensorflow`: Abhängigkeiten, um framework-spezifische Funktionen auszuführen.
+- `dev`: Abhängigkeiten, um zur Bibliothek beizutragen. Enthält `testing` (um Tests auszuführen), `typing` (um den Type Checker auszuführen) und `quality` (um Linters auszuführen).
+
+
+### Installieren von der Quelle
+
+In einigen Fällen kann es sinnvoll sein, `huggingface_hub` direkt von der Quelle zu installieren. Dies ermöglicht es Ihnen, die aktuellste `main`-Version anstelle der neuesten stabilen Version zu verwenden. Die `main`-Version ist nützlich, um immer auf dem neuesten Stand der Entwicklungen zu bleiben, zum Beispiel wenn ein Fehler seit der letzten offiziellen Veröffentlichung behoben wurde, aber noch keine neue Version herausgegeben wurde.
+
+Das bedeutet jedoch, dass die `main`-Version nicht immer stabil sein könnte. Wir bemühen uns, die Hauptversion funktionsfähig zu halten, und die meisten Probleme werden in der Regel innerhalb von einigen Stunden oder einem Tag gelöst. Wenn Sie auf ein Problem stoßen, eröffnen Sie bitte ein "Issue", damit wir es noch schneller beheben können!
+
+```bash
+pip install git+https://github.com/huggingface/huggingface_hub
+```
+
+Bei der Installation von der Quelle können Sie auch einen bestimmten Zweig angeben. Dies ist nützlich, wenn Sie ein neues Feature oder einen neuen Fehlerbehebung testen möchten, der noch nicht zusammengeführt wurde:
+
+```bash
+pip install git+https://github.com/huggingface/huggingface_hub@my-feature-branch
+```
+
+Überprüfen Sie nach Abschluss, ob die [Installation korrekt funktioniert](#installation-berprfen).
+
+### Editierbare Installation
+
+Die Installation von der Quelle ermöglicht Ihnen eine [editierbare Installation](https://pip.pypa.io/en/stable/topics/local-project-installs/#editable-installs). Dies ist eine fortgeschrittenere Installation, wenn Sie zur Entwicklung von `huggingface_hub` beitragen und Änderungen im Code testen möchten. Sie müssen eine lokale Kopie von `huggingface_hub` auf Ihrem Computer klonen.
+
+```bash
+# Zuerst die Repository lokal klonen
+git clone https://github.com/huggingface/huggingface_hub.git
+
+# Dann mit dem -e Flag installieren
+cd huggingface_hub
+pip install -e .
+```
+
+Diese Befehle verknüpfen den Ordner, in den Sie das Repository geklont haben, mit Ihren Python-Bibliothekspfaden. Python wird nun zusätzlich zu den normalen Bibliothekspfaden im geklonten Ordner suchen. Wenn Ihre Python-Pakete normalerweise in `./.venv/lib/python3.11/site-packages/` installiert sind, wird Python auch den geklonten Ordner `./huggingface_hub/` durchsuchen.
+
+## Installieren mit conda
+
+Wenn Sie damit vertrauter sind, können Sie `huggingface_hub` über den [conda-forge-Kanal](https://anaconda.org/conda-forge/huggingface_hub) installieren:
+
+```bash
+conda install -c conda-forge huggingface_hub
+```
+
+Überprüfen Sie nach Abschluss, ob die [Installation korrekt funktioniert](#installation-berprfen).
+
+## Installation überprüfen
+
+Nach der Installation überprüfen Sie, ob `huggingface_hub` richtig funktioniert, indem Sie den folgenden Befehl ausführen:
+
+```bash
+python -c "from huggingface_hub import model_info; print(model_info('gpt2'))"
+```
+
+Dieser Befehl ruft Informationen vom Hub über das [gpt2](https://huggingface.co/gpt2)-Modell ab. Die Ausgabe sollte so aussehen:
+
+```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
+```
+
+## Windows-Einschränkungen
+
+Mit unserem Ziel, gutes ML überall zu demokratisieren, haben wir `huggingface_hub` als plattformübergreifende Bibliothek entwickelt, insbesondere um sowohl auf Unix-basierten als auch auf Windows-Systemen korrekt zu funktionieren. Es gibt jedoch einige Fälle, in denen `huggingface_hub` unter Windows gewisse Einschränkungen hat. Hier ist eine ausführliche Liste der bekannten Probleme. Bitte informieren Sie uns, wenn Sie auf ein nicht dokumentiertes Problem stoßen, indem Sie ein [Issue auf Github eröffnen](https://github.com/huggingface/huggingface_hub/issues/new/choose).
+
+
+- Das Cache-System von `huggingface_hub` verwendet Symlinks, um Dateien, die vom Hub heruntergeladen wurden, effizient zu cachen. Unter Windows müssen Sie den Entwicklermodus aktivieren oder Ihr Skript als Admin ausführen, um Symlinks zu aktivieren. Wenn sie nicht aktiviert sind, funktioniert das Cache-System immer noch, aber nicht optimiert. Bitte lesen Sie den Abschnitt über [Cache-Einschränkungen](./guides/manage-cache#limitations) für weitere Details.
+- Dateipfade auf dem Hub können Sonderzeichen enthalten (z.B. `"pfad/zu?/meiner/datei"`). Windows ist bei [Sonderzeichen](https://learn.microsoft.com/en-us/windows/win32/intl/character-sets-used-in-file-names) restriktiver, wodurch es unmöglich ist, diese Dateien unter Windows herunterzuladen. Hoffentlich ist dies ein seltener Fall. Bitte wenden Sie sich an den Repo-Eigentümer, wenn Sie denken, dass dies ein Fehler ist, oder an uns, um eine Lösung zu finden.
+
+
+## Nächste Schritte
+
+Sobald `huggingface_hub`` richtig auf Ihrem Computer installiert ist, möchten Sie vielleicht [Umgebungsvariablen konfigurieren](package_reference/environment_variables) oder [einen unserer Leitfäden durchgehen](guides/overview), um loszulegen.
\ No newline at end of file
diff --git a/docs/source/de/quick-start.md b/docs/source/de/quick-start.md
new file mode 100644
index 00000000..0c5c6717
--- /dev/null
+++ b/docs/source/de/quick-start.md
@@ -0,0 +1,132 @@
+<!--⚠️ Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
+rendered properly in your Markdown viewer.
+-->
+
+# Kurzanleitung
+
+Der [Hugging Face Hub](https://huggingface.co/) ist die erste Anlaufstelle für das Teilen von Maschinenlernmodellen, Demos, Datensätzen und Metriken. Die `huggingface_hub`-Bibliothek hilft Ihnen, mit dem Hub zu interagieren, ohne Ihre Entwicklungs-Umgebung zu verlassen. Sie können Repositories einfach erstellen und verwalten, Dateien herunterladen und hochladen und nützliche Model- und Datensatz-Metadaten vom Hub abrufen.
+
+## Installation
+
+Um loszulegen, installieren Sie die `huggingface_hub`-Bibliothek:
+
+```bash
+pip install --upgrade huggingface_hub
+```
+
+Für weitere Details schauen Sie sich bitte den [Installationsleitfaden](installation) an.
+
+## Dateien herunterladen
+
+Repositories auf dem Hub sind mit git versioniert, und Benutzer können eine einzelne Datei
+oder das gesamte Repository herunterladen. Sie können die Funktion [`hf_hub_download`] verwenden, um Dateien herunterzuladen.
+Diese Funktion lädt eine Datei herunter und speichert sie im Cache auf Ihrer lokalen Festplatte. Das nächste Mal, wenn Sie diese Datei benötigen, wird sie aus Ihrem Cache geladen, sodass Sie sie nicht erneut herunterladen müssen.
+
+Sie benötigen die Repository-ID und den Dateinamen der Datei, die Sie herunterladen möchten. Zum
+Beispiel, um die Konfigurationsdatei des [Pegasus](https://huggingface.co/google/pegasus-xsum) Modells herunterzuladen:
+
+```py
+>>> from huggingface_hub import hf_hub_download
+>>> hf_hub_download(repo_id="google/pegasus-xsum", filename="config.json")
+```
+
+Um eine bestimmte Version der Datei herunterzuladen, verwenden Sie den `revision`-Parameter, um den
+Namen der Branch, des Tags oder des Commit-Hashes anzugeben. Wenn Sie sich für den Commit-Hash
+entscheiden, muss es der vollständige Hash anstelle des kürzeren 7-Zeichen-Commit-Hashes sein:
+
+```py
+>>> from huggingface_hub import hf_hub_download
+>>> hf_hub_download(
+...     repo_id="google/pegasus-xsum", 
+...     filename="config.json", 
+...     revision="4d33b01d79672f27f001f6abade33f22d993b151"
+... )
+```
+
+Für weitere Details und Optionen siehe die API-Referenz für [`hf_hub_download`].
+
+## Anmeldung
+
+In vielen Fällen müssen Sie mit einem Hugging Face-Konto angemeldet sein, um mit dem Hub zu interagieren: private Repos herunterladen, Dateien hochladen, PRs erstellen,... 
+[Erstellen Sie ein Konto](https://huggingface.co/join), wenn Sie noch keines haben, und melden Sie sich dann an, um Ihr ["User Access Token"](https://huggingface.co/docs/hub/security-tokens) von Ihrer [Einstellungsseite](https://huggingface.co/settings/tokens) zu erhalten. Das "User Access Token" wird verwendet, um Ihre Identität gegenüber dem Hub zu authentifizieren.
+
+Sobald Sie Ihr "User Access Token" haben, führen Sie den folgenden Befehl in Ihrem Terminal aus:
+
+```bash
+huggingface-cli login
+# or using an environment variable
+huggingface-cli login --token $HUGGINGFACE_TOKEN
+```
+
+Alternativ können Sie sich auch programmatisch in einem Notebook oder einem Skript mit [`login`] anmelden:
+
+```py
+>>> from huggingface_hub import login
+>>> login()
+```
+
+Es ist auch möglich, sich programmatisch anzumelden, ohne aufgefordert zu werden, Ihr Token einzugeben, indem Sie das Token direkt an [`login`] weitergeben, wie z.B. `login(token="hf_xxx")`. Seien Sie vorsichtig, wenn Sie Ihren Quellcode teilen. Es ist eine bewährte Methode, das Token aus einem sicheren Tresor/Vault zu laden, anstatt es explizit in Ihrer Codebasis/Notebook zu speichern.
+
+Sie können nur auf 1 Konto gleichzeitig angemeldet sein. Wenn Sie Ihren Computer mit einem neuen Konto anmelden, werden Sie vom vorherigen abgemeldet. Mit dem Befehl `huggingface-cli whoami` stellen Sie sicher, dass Sie immer wissen, welches Konto Sie gerade verwenden. Wenn Sie mehrere Konten im selben Skript verwalten möchten, können Sie Ihr Token bereitstellen, wenn Sie jede Methode aufrufen. Dies ist auch nützlich, wenn Sie kein Token auf Ihrem Computer speichern möchten.
+
+<Tip warning={true}>
+
+Sobald Sie angemeldet sind, werden alle Anfragen an den Hub - auch Methoden, die nicht unbedingt eine Authentifizierung erfordern - standardmäßig Ihr Zugriffstoken verwenden. Wenn Sie die implizite Verwendung Ihres Tokens deaktivieren möchten, sollten Sie die Umgebungsvariable `HF_HUB_DISABLE_IMPLICIT_TOKEN` setzen.
+
+</Tip>
+
+## Eine Repository erstellen
+
+Nachdem Sie sich registriert und angemeldet haben, können Sie mit der Funktion [`create_repo`] ein Repository erstellen:
+
+```py
+>>> from huggingface_hub import HfApi
+>>> api = HfApi()
+>>> api.create_repo(repo_id="super-cool-model")
+```
+
+If you want your repository to be private, then:
+
+```py
+>>> from huggingface_hub import HfApi
+>>> api = HfApi()
+>>> api.create_repo(repo_id="super-cool-model", private=True)
+```
+
+Private Repositories sind für niemanden außer Ihnen selbst sichtbar.
+
+<Tip>
+
+Um eine Repository zu erstellen oder Inhalte auf den Hub zu pushen, müssen Sie ein "User Access Token" bereitstellen, das die Schreibberechtigung (`write`) hat. Sie können die Berechtigung auswählen, wenn Sie das Token auf Ihrer [Einstellungsseite](https://huggingface.co/settings/tokens) erstellen.
+
+</Tip>
+
+## Dateien hochladen
+
+Verwenden Sie die [`upload_file`]-Funktion, um eine Datei zu Ihrem neu erstellten Repository hinzuzufügen. Sie müssen dabei das Folgende angeben:
+
+1. Den Pfad der hochzuladenden Datei.
+2. Den Pfad der Datei im Repository.
+3. Die Repository-ID, zu der Sie die Datei hinzufügen möchten.
+
+```py
+>>> from huggingface_hub import HfApi
+>>> api = HfApi()
+>>> api.upload_file(
+...     path_or_fileobj="/home/lysandre/dummy-test/README.md",
+...     path_in_repo="README.md",
+...     repo_id="lysandre/test-model",
+... )
+```
+
+Um mehr als eine Datei gleichzeitig hochzuladen, werfen Sie bitte einen Blick auf den [Upload](./guides/upload)-Leitfaden, der Ihnen verschiedene Methoden zum Hochladen von Dateien vorstellt (mit oder ohne git).
+
+## Nächste Schritte
+
+Die `huggingface_hub`-Bibliothek bietet den Benutzern eine einfache Möglichkeit, mittels Python mit dem Hub zu interagieren. Um mehr darüber zu erfahren, wie Sie Ihre Dateien und Repositories auf dem Hub verwalten können, empfehlen wir, unsere [How-to-Leitfäden](./guides/overview) zu lesen:
+
+- [Verwalten Sie Ihre Repository](./guides/repository).
+- Dateien vom Hub [herunterladen](./guides/download).
+- Dateien auf den Hub [hochladen](./guides/upload).
+- [Durchsuchen Sie den Hub](./guides/search) nach dem gewünschten Modell oder Datensatz.
+- [Greifen Sie auf die Inferenz-API zu](./guides/inference), um schnelle Inferenzen durchzuführen.
\ No newline at end of file
diff --git a/docs/source/en/guides/upload.md b/docs/source/en/guides/upload.md
index 93a5633a..9c8eed87 100644
--- a/docs/source/en/guides/upload.md
+++ b/docs/source/en/guides/upload.md
@@ -382,7 +382,7 @@ The [`upload_file`] and [`upload_folder`] functions are high-level APIs that are
 trying these functions first if you don't need to work at a lower level. However, if you want to work at a commit-level,
 you can use the [`create_commit`] function directly.
 
-There are two types of operations supported by [`create_commit`]:
+There are three types of operations supported by [`create_commit`]:
 
 - [`CommitOperationAdd`] uploads a file to the Hub. If the file already exists, the file contents are overwritten. This operation accepts two arguments:
 
diff --git a/src/huggingface_hub/file_download.py b/src/huggingface_hub/file_download.py
index 0650ffc3..9191f2d8 100644
--- a/src/huggingface_hub/file_download.py
+++ b/src/huggingface_hub/file_download.py
@@ -538,15 +538,15 @@ def http_get(
             displayed_name = match.groupdict()["filename"]
 
     # Truncate filename if too long to display
-    if len(displayed_name) > 22:
-        displayed_name = f"(…){displayed_name[-20:]}"
+    if len(displayed_name) > 40:
+        displayed_name = f"(…){displayed_name[-40:]}"
 
     progress = tqdm(
         unit="B",
         unit_scale=True,
         total=total,
         initial=resume_size,
-        desc=f"Downloading {displayed_name}",
+        desc=displayed_name,
         disable=bool(logger.getEffectiveLevel() == logging.NOTSET),
     )
     for chunk in r.iter_content(chunk_size=10 * 1024 * 1024):
diff --git a/src/huggingface_hub/inference/_generated/_async_client.py b/src/huggingface_hub/inference/_generated/_async_client.py
index 93fe892f..ad068c6a 100644
--- a/src/huggingface_hub/inference/_generated/_async_client.py
+++ b/src/huggingface_hub/inference/_generated/_async_client.py
@@ -18,6 +18,7 @@
 # Any change in InferenceClient will be automatically reflected in AsyncInferenceClient.
 # To re-generate the code, run `make style` or `python ./utils/generate_async_inference_client.py --update`.
 # WARNING
+import asyncio
 import logging
 import time
 import warnings
@@ -227,7 +228,7 @@ class AsyncInferenceClient:
                         content = await response.read()
                         await client.close()
                         return content
-                except TimeoutError as error:
+                except asyncio.TimeoutError as error:
                     await client.close()
                     # Convert any `TimeoutError` to a `InferenceTimeoutError`
                     raise InferenceTimeoutError(f"Inference call timed out: {url}") from error
diff --git a/utils/generate_async_inference_client.py b/utils/generate_async_inference_client.py
index 3288a89d..f24ecc58 100644
--- a/utils/generate_async_inference_client.py
+++ b/utils/generate_async_inference_client.py
@@ -140,7 +140,10 @@ def _add_imports(code: str) -> str:
     code = re.sub(
         r"(\nimport .*?\n)",
         repl=(
-            r"\1" + "from .._common import _async_yield_from, _import_aiohttp\n" + "from typing import AsyncIterable\n"
+            r"\1"
+            + "from .._common import _async_yield_from, _import_aiohttp\n"
+            + "from typing import AsyncIterable\n"
+            + "import asyncio\n"
         ),
         string=code,
         count=1,
@@ -201,7 +204,7 @@ ASYNC_POST_CODE = """
                         content = await response.read()
                         await client.close()
                         return content
-                except TimeoutError as error:
+                except asyncio.TimeoutError as error:
                     await client.close()
                     # Convert any `TimeoutError` to a `InferenceTimeoutError`
                     raise InferenceTimeoutError(f"Inference call timed out: {url}") from error


Test patch:
diff --git a/tests/test_inference_async_client.py b/tests/test_inference_async_client.py
index ec34425a..1d827e5a 100644
--- a/tests/test_inference_async_client.py
+++ b/tests/test_inference_async_client.py
@@ -22,13 +22,14 @@ return types + uses streaming requests on demand). Tests are mostly duplicates f
 For completeness we also run a test on a simple task (`test_async_sentence_similarity`) and assume all other tasks
 work as well.
 """
+import asyncio
 import inspect
 
 import pytest
 from aiohttp import ClientResponseError
 
 import huggingface_hub.inference._common
-from huggingface_hub import AsyncInferenceClient, InferenceClient
+from huggingface_hub import AsyncInferenceClient, InferenceClient, InferenceTimeoutError
 from huggingface_hub.inference._common import _is_tgi_server
 from huggingface_hub.inference._text_generation import FinishReason, InputToken
 from huggingface_hub.inference._text_generation import ValidationError as TextGenerationValidationError
@@ -243,3 +244,13 @@ async def test_list_deployed_models_single_frameworks() -> None:
 
     assert "text-generation" in models_by_task
     assert "bigscience/bloom" in models_by_task["text-generation"]
+
+
+@pytest.mark.asyncio
+async def test_async_generate_timeout_error(monkeypatch: pytest.MonkeyPatch) -> None:
+    def _mock_aiohttp_client_timeout(*args, **kwargs):
+        raise asyncio.TimeoutError
+
+    monkeypatch.setattr("aiohttp.ClientSession.post", _mock_aiohttp_client_timeout)
+    with pytest.raises(InferenceTimeoutError):
+        await AsyncInferenceClient(timeout=1).text_generation("test")