From 375e9db187e992d9c8bcf02d8abb078842a818fa Mon Sep 17 00:00:00 2001 From: NikhilKalloli <1ms22cs091@msrit.edu> Date: Tue, 22 Oct 2024 22:50:03 +0530 Subject: [PATCH] Add multilingual docs --- docs/en/api.md | 172 ++++++++++++++++++++++++++++++++++ docs/en/contributing.md | 20 ++++ docs/en/faq.md | 12 +++ docs/en/index.md | 19 ++++ docs/en/installation.md | 198 +++++++++++++++++++++++++++++++++++++++ docs/en/usage.md | 145 ++++++++++++++++++++++++++++ docs/fr/api.md | 170 +++++++++++++++++++++++++++++++++ docs/fr/contributing.md | 20 ++++ docs/fr/faq.md | 12 +++ docs/fr/index.md | 19 ++++ docs/fr/installation.md | 203 ++++++++++++++++++++++++++++++++++++++++ docs/fr/usage.md | 145 ++++++++++++++++++++++++++++ mkdocs.yml | 47 ++++++++++ 13 files changed, 1182 insertions(+) create mode 100644 docs/en/api.md create mode 100644 docs/en/contributing.md create mode 100644 docs/en/faq.md create mode 100644 docs/en/index.md create mode 100644 docs/en/installation.md create mode 100644 docs/en/usage.md create mode 100644 docs/fr/api.md create mode 100644 docs/fr/contributing.md create mode 100644 docs/fr/faq.md create mode 100644 docs/fr/index.md create mode 100644 docs/fr/installation.md create mode 100644 docs/fr/usage.md create mode 100644 mkdocs.yml diff --git a/docs/en/api.md b/docs/en/api.md new file mode 100644 index 00000000..207e3e1f --- /dev/null +++ b/docs/en/api.md @@ -0,0 +1,172 @@ +## Configuration + +### Initialization Parameters for `TextToAudioStream` + +When you initialize the `TextToAudioStream` class, you have various options to customize its behavior. Here are the available parameters: + +#### `engine` (BaseEngine) +- **Type**: BaseEngine +- **Required**: Yes +- **Description**: The underlying engine responsible for text-to-audio synthesis. You must provide an instance of `BaseEngine` or its subclass to enable audio synthesis. + +#### `on_text_stream_start` (callable) +- **Type**: Callable function +- **Required**: No +- **Description**: This optional callback function is triggered when the text stream begins. Use it for any setup or logging you may need. + +#### `on_text_stream_stop` (callable) +- **Type**: Callable function +- **Required**: No +- **Description**: This optional callback function is activated when the text stream ends. You can use this for cleanup tasks or logging. + +#### `on_audio_stream_start` (callable) +- **Type**: Callable function +- **Required**: No +- **Description**: This optional callback function is invoked when the audio stream starts. Useful for UI updates or event logging. + +#### `on_audio_stream_stop` (callable) +- **Type**: Callable function +- **Required**: No +- **Description**: This optional callback function is called when the audio stream stops. Ideal for resource cleanup or post-processing tasks. + +#### `on_character` (callable) +- **Type**: Callable function +- **Required**: No +- **Description**: This optional callback function is called when a single character is processed. + +#### `output_device_index` (int) +- **Type**: Integer +- **Required**: No +- **Default**: None +- **Description**: Specifies the output device index to use. None uses the default device. + +#### `tokenizer` (string) +- **Type**: String +- **Required**: No +- **Default**: nltk +- **Description**: Tokenizer to use for sentence splitting (currently "nltk" and "stanza" are supported). + +#### `language` (string) +- **Type**: String +- **Required**: No +- **Default**: en +- **Description**: Language to use for sentence splitting. + +#### `muted` (bool) +- **Type**: Bool +- **Required**: No +- **Default**: False +- **Description**: Global muted parameter. If True, no pyAudio stream will be opened. Disables audio playback via local speakers (in case you want to synthesize to file or process audio chunks) and overrides the play parameters muted setting. + +#### `level` (int) +- **Type**: Integer +- **Required**: No +- **Default**: `logging.WARNING` +- **Description**: Sets the logging level for the internal logger. This can be any integer constant from Python's built-in `logging` module. + +#### Example Usage: + +```python +engine = YourEngine() # Substitute with your engine +stream = TextToAudioStream( + engine=engine, + on_text_stream_start=my_text_start_func, + on_text_stream_stop=my_text_stop_func, + on_audio_stream_start=my_audio_start_func, + on_audio_stream_stop=my_audio_stop_func, + level=logging.INFO +) +``` + +### Methods + +#### `play` and `play_async` + +These methods are responsible for executing the text-to-audio synthesis and playing the audio stream. The difference is that `play` is a blocking function, while `play_async` runs in a separate thread, allowing other operations to proceed. + +##### Parameters: + +###### `fast_sentence_fragment` (bool) +- **Default**: `True` +- **Description**: When set to `True`, the method will prioritize speed, generating and playing sentence fragments faster. This is useful for applications where latency matters. + +###### `fast_sentence_fragment_allsentences` (bool) +- **Default**: `False` +- **Description**: When set to `True`, applies the fast sentence fragment processing to all sentences, not just the first one. + +###### `fast_sentence_fragment_allsentences_multiple` (bool) +- **Default**: `False` +- **Description**: When set to `True`, allows yielding multiple sentence fragments instead of just a single one. + +###### `buffer_threshold_seconds` (float) +- **Default**: `0.0` +- **Description**: Specifies the time in seconds for the buffering threshold, which impacts the smoothness and continuity of audio playback. + + - **How it Works**: Before synthesizing a new sentence, the system checks if there is more audio material left in the buffer than the time specified by `buffer_threshold_seconds`. If so, it retrieves another sentence from the text generator, assuming that it can fetch and synthesize this new sentence within the time window provided by the remaining audio in the buffer. This process allows the text-to-speech engine to have more context for better synthesis, enhancing the user experience. + + A higher value ensures that there's more pre-buffered audio, reducing the likelihood of silence or gaps during playback. If you experience breaks or pauses, consider increasing this value. + +###### `minimum_sentence_length` (int) +- **Default**: `10` +- **Description**: Sets the minimum character length to consider a string as a sentence to be synthesized. This affects how text chunks are processed and played. + +###### `minimum_first_fragment_length` (int) +- **Default**: `10` +- **Description**: The minimum number of characters required for the first sentence fragment before yielding. + +###### `log_synthesized_text` (bool) +- **Default**: `False` +- **Description**: When enabled, logs the text chunks as they are synthesized into audio. Helpful for auditing and debugging. + +###### `reset_generated_text` (bool) +- **Default**: `True` +- **Description**: If True, reset the generated text before processing. + +###### `output_wavfile` (str) +- **Default**: `None` +- **Description**: If set, save the audio to the specified WAV file. + +###### `on_sentence_synthesized` (callable) +- **Default**: `None` +- **Description**: A callback function that gets called after a single sentence fragment was synthesized. + +###### `before_sentence_synthesized` (callable) +- **Default**: `None` +- **Description**: A callback function that gets called before a single sentence fragment gets synthesized. + +###### `on_audio_chunk` (callable) +- **Default**: `None` +- **Description**: Callback function that gets called when a single audio chunk is ready. + +###### `tokenizer` (str) +- **Default**: `"nltk"` +- **Description**: Tokenizer to use for sentence splitting. Currently supports "nltk" and "stanza". + +###### `tokenize_sentences` (callable) +- **Default**: `None` +- **Description**: A custom function that tokenizes sentences from the input text. You can provide your own lightweight tokenizer if you are unhappy with nltk and stanza. It should take text as a string and return split sentences as a list of strings. + +###### `language` (str) +- **Default**: `"en"` +- **Description**: Language to use for sentence splitting. + +###### `context_size` (int) +- **Default**: `12` +- **Description**: The number of characters used to establish context for sentence boundary detection. A larger context improves the accuracy of detecting sentence boundaries. + +###### `context_size_look_overhead` (int) +- **Default**: `12` +- **Description**: Additional context size for looking ahead when detecting sentence boundaries. + +###### `muted` (bool) +- **Default**: `False` +- **Description**: If True, disables audio playback via local speakers. Useful when you want to synthesize to a file or process audio chunks without playing them. + +###### `sentence_fragment_delimiters` (str) +- **Default**: `".?!;:,\n…)]}。-"` +- **Description**: A string of characters that are considered sentence delimiters. + +###### `force_first_fragment_after_words` (int) +- **Default**: `15` +- **Description**: The number of words after which the first sentence fragment is forced to be yielded. + diff --git a/docs/en/contributing.md b/docs/en/contributing.md new file mode 100644 index 00000000..7b4c677b --- /dev/null +++ b/docs/en/contributing.md @@ -0,0 +1,20 @@ +# Contributing to RealtimeTTS + +We welcome contributions to RealtimeTTS! Here are some ways you can contribute: + +1. **Reporting Bugs**: If you find a bug, please open an issue on our [GitHub repository](https://github.com/KoljaB/RealtimeTTS/issues). + +2. **Suggesting Enhancements**: Have ideas for new features or improvements? We'd love to hear them! Open an issue to suggest enhancements. + +3. **Code Contributions**: Want to add a new feature or fix a bug? Great! Please follow these steps: + - Fork the repository + - Create a new branch for your feature + - Make your changes + - Submit a pull request with a clear description of your changes + +4. **Documentation**: Help us improve our documentation by fixing typos, adding examples, or clarifying confusing sections. + +5. **Adding New Engines**: If you want to add support for a new TTS engine, please open an issue first to discuss the implementation. + + +Thank you for helping make RealtimeTTS better! diff --git a/docs/en/faq.md b/docs/en/faq.md new file mode 100644 index 00000000..f5fda4c0 --- /dev/null +++ b/docs/en/faq.md @@ -0,0 +1,12 @@ +# Frequently Asked Questions + +For answers to frequently asked questions about RealtimeTTS, please refer to our [FAQ page on GitHub](https://github.com/KoljaB/RealtimeTTS/blob/main/FAQ.md). + +This page covers various topics including: + +- Usage of different TTS engines +- Handling of multilingual text +- Performance optimization +- Troubleshooting common issues + +For more detailed information, please visit the link above. diff --git a/docs/en/index.md b/docs/en/index.md new file mode 100644 index 00000000..ad4dbb6c --- /dev/null +++ b/docs/en/index.md @@ -0,0 +1,19 @@ +# RealtimeTTS + +[EN](../en/index.md) | [FR](../fr/index.md) + +*Easy to use, low-latency text-to-speech library for realtime applications* + +## About the Project + +RealtimeTTS is a state-of-the-art text-to-speech (TTS) library designed for real-time applications. It stands out in its ability to convert text streams fast into high-quality auditory output with minimal latency. + +## Key Features + +- **Low Latency**: almost instantaneous text-to-speech conversion, compatible with LLM outputs +- **High-Quality Audio**: generates clear and natural-sounding speech +- **Multiple TTS Engine Support**: supports OpenAI TTS, Elevenlabs, Azure Speech Services, Coqui TTS, gTTS and System TTS +- **Multilingual** +- **Robust and Reliable**: ensures continuous operation through a fallback mechanism, switches to alternative engines in case of disruptions guaranteeing consistent performance and reliability + +For installation instructions, usage examples, and API reference, please navigate through the documentation using the sidebar. diff --git a/docs/en/installation.md b/docs/en/installation.md new file mode 100644 index 00000000..2f23de48 --- /dev/null +++ b/docs/en/installation.md @@ -0,0 +1,198 @@ + +> **Note:** Basic Installation with `pip install realtimetts` is not recommended anymore, use `pip install realtimetts[all]` instead. + +The RealtimeTTS library provides installation options for various dependencies for your use case. Here are the different ways you can install RealtimeTTS depending on your needs: + +### Full Installation + +To install RealtimeTTS with support for all TTS engines: + +``` +pip install -U realtimetts[all] +``` + +### Custom Installation + +RealtimeTTS allows for custom installation with minimal library installations. Here are the options available: +- **all**: Full installation with every engine supported. +- **system**: Includes system-specific TTS capabilities (e.g., pyttsx3). +- **azure**: Adds Azure Cognitive Services Speech support. +- **elevenlabs**: Includes integration with ElevenLabs API. +- **openai**: For OpenAI voice services. +- **gtts**: Google Text-to-Speech support. +- **coqui**: Installs the Coqui TTS engine. +- **minimal**: Installs only the base requirements with no engine (only needed if you want to develop an own engine) + + +Say you want to install RealtimeTTS only for local neuronal Coqui TTS usage, then you should use: + +``` +pip install realtimetts[coqui] +``` + +For example, if you want to install RealtimeTTS with only Azure Cognitive Services Speech, ElevenLabs, and OpenAI support: + +``` +pip install realtimetts[azure,elevenlabs,openai] +``` + +### Virtual Environment Installation + +For those who want to perform a full installation within a virtual environment, follow these steps: + +``` +python -m venv env_realtimetts +env_realtimetts\Scripts\activate.bat +python.exe -m pip install --upgrade pip +pip install -U realtimetts[all] +``` + +More information about [CUDA installation](#cuda-installation). + +## Engine Requirements + +Different engines supported by RealtimeTTS have unique requirements. Ensure you fulfill these requirements based on the engine you choose. + +### SystemEngine +The `SystemEngine` works out of the box with your system's built-in TTS capabilities. No additional setup is needed. + +### GTTSEngine +The `GTTSEngine` works out of the box using Google Translate's text-to-speech API. No additional setup is needed. + +### OpenAIEngine +To use the `OpenAIEngine`: +- set environment variable OPENAI_API_KEY +- install ffmpeg (see [CUDA installation](#cuda-installation) point 3) + +### AzureEngine +To use the `AzureEngine`, you will need: +- Microsoft Azure Text-to-Speech API key (provided via AzureEngine constructor parameter "speech_key" or in the environment variable AZURE_SPEECH_KEY) +- Microsoft Azure service region. + +Make sure you have these credentials available and correctly configured when initializing the `AzureEngine`. + +### ElevenlabsEngine +For the `ElevenlabsEngine`, you need: +- Elevenlabs API key (provided via ElevenlabsEngine constructor parameter "api_key" or in the environment variable ELEVENLABS_API_KEY) +- `mpv` installed on your system (essential for streaming mpeg audio, Elevenlabs only delivers mpeg). + + 🔹 **Installing `mpv`:** + - **macOS**: + ``` + brew install mpv + ``` + + - **Linux and Windows**: Visit [mpv.io](https://mpv.io/) for installation instructions. + +### CoquiEngine + +Delivers high quality, local, neural TTS with voice-cloning. + +Downloads a neural TTS model first. In most cases it be fast enough for Realtime using GPU synthesis. Needs around 4-5 GB VRAM. + +- to clone a voice submit the filename of a wave file containing the source voice as "voice" parameter to the CoquiEngine constructor +- voice cloning works best with a 22050 Hz mono 16bit WAV file containing a short (~5-30 sec) sample + +On most systems GPU support will be needed to run fast enough for realtime, otherwise you will experience stuttering. + +### CUDA installation + +These steps are recommended for those who require **better performance** and have a compatible NVIDIA GPU. + +> **Note**: *to check if your NVIDIA GPU supports CUDA, visit the [official CUDA GPUs list](https://developer.nvidia.com/cuda-gpus).* + +To use a torch with support via CUDA please follow these steps: + +> **Note**: *newer pytorch installations [may](https://stackoverflow.com/a/77069523) (unverified) not need Toolkit (and possibly cuDNN) installation anymore.* + +1. **Install NVIDIA CUDA Toolkit**: + For example, to install Toolkit 12.X, please + - Visit [NVIDIA CUDA Downloads](https://developer.nvidia.com/cuda-downloads). + - Select your operating system, system architecture, and os version. + - Download and install the software. + + or to install Toolkit 11.8, please + - Visit [NVIDIA CUDA Toolkit Archive](https://developer.nvidia.com/cuda-11-8-0-download-archive). + - Select your operating system, system architecture, and os version. + - Download and install the software. + +2. **Install NVIDIA cuDNN**: + + For example, to install cuDNN 8.7.0 for CUDA 11.x please + - Visit [NVIDIA cuDNN Archive](https://developer.nvidia.com/rdp/cudnn-archive). + - Click on "Download cuDNN v8.7.0 (November 28th, 2022), for CUDA 11.x". + - Download and install the software. + +3. **Install ffmpeg**: + + You can download an installer for your OS from the [ffmpeg Website](https://ffmpeg.org/download.html). + + Or use a package manager: + + - **On Ubuntu or Debian**: + ``` + sudo apt update && sudo apt install ffmpeg + ``` + + - **On Arch Linux**: + ``` + sudo pacman -S ffmpeg + ``` + + - **On MacOS using Homebrew** ([https://brew.sh/](https://brew.sh/)): + ``` + brew install ffmpeg + ``` + + - **On Windows using Chocolatey** ([https://chocolatey.org/](https://chocolatey.org/)): + ``` + choco install ffmpeg + ``` + + - **On Windows using Scoop** ([https://scoop.sh/](https://scoop.sh/)): + ``` + scoop install ffmpeg + ``` + +4. **Install PyTorch with CUDA support**: + + To upgrade your PyTorch installation to enable GPU support with CUDA, follow these instructions based on your specific CUDA version. This is useful if you wish to enhance the performance of RealtimeSTT with CUDA capabilities. + + - **For CUDA 11.8:** + + To update PyTorch and Torchaudio to support CUDA 11.8, use the following commands: + + ``` + pip install torch==2.3.1+cu118 torchaudio==2.3.1 --index-url https://download.pytorch.org/whl/cu118 + ``` + + - **For CUDA 12.X:** + + + To update PyTorch and Torchaudio to support CUDA 12.X, execute the following: + + ``` + pip install torch==2.3.1+cu121 torchaudio==2.3.1 --index-url https://download.pytorch.org/whl/cu121 + ``` + + Replace `2.3.1` with the version of PyTorch that matches your system and requirements. + +5. **Fix for to resolve compatibility issues**: + If you run into library compatibility issues, try setting these libraries to fixed versions: + + ``` + + pip install networkx==2.8.8 + + pip install typing_extensions==4.8.0 + + pip install fsspec==2023.6.0 + + pip install imageio==2.31.6 + + pip install networkx==2.8.8 + + pip install numpy==1.24.3 + + pip install requests==2.31.0 + ``` \ No newline at end of file diff --git a/docs/en/usage.md b/docs/en/usage.md new file mode 100644 index 00000000..021ade56 --- /dev/null +++ b/docs/en/usage.md @@ -0,0 +1,145 @@ +# Usage + +## Quick Start + +Here's a basic usage example: + +```python +from RealtimeTTS import TextToAudioStream, SystemEngine, AzureEngine, ElevenlabsEngine + +engine = SystemEngine() # replace with your TTS engine +stream = TextToAudioStream(engine) +stream.feed("Hello world! How are you today?") +stream.play_async() +``` + +## Feed Text + +You can feed individual strings: + +```python +stream.feed("Hello, this is a sentence.") +``` + +Or you can feed generators and character iterators for real-time streaming: + +```python +def write(prompt: str): + for chunk in openai.ChatCompletion.create( + model="gpt-3.5-turbo", + messages=[{"role": "user", "content" : prompt}], + stream=True + ): + if (text_chunk := chunk["choices"][0]["delta"].get("content")) is not None: + yield text_chunk + +text_stream = write("A three-sentence relaxing speech.") + +stream.feed(text_stream) +``` + +```python +char_iterator = iter("Streaming this character by character.") +stream.feed(char_iterator) +``` + +## Playback + +Asynchronously: + +```python +stream.play_async() +while stream.is_playing(): + time.sleep(0.1) +``` + +Synchronously: + +```python +stream.play() +``` + +## Testing the Library + +The test subdirectory contains a set of scripts to help you evaluate and understand the capabilities of the RealtimeTTS library. + +Note that most of the tests still rely on the "old" OpenAI API (<1.0.0). Usage of the new OpenAI API is demonstrated in openai_1.0_test.py. + +- **simple_test.py** + - **Description**: A "hello world" styled demonstration of the library's simplest usage. + +- **complex_test.py** + - **Description**: A comprehensive demonstration showcasing most of the features provided by the library. + +- **coqui_test.py** + - **Description**: Test of local coqui TTS engine. + +- **translator.py** + - **Dependencies**: Run `pip install openai realtimestt`. + - **Description**: Real-time translations into six different languages. + +- **openai_voice_interface.py** + - **Dependencies**: Run `pip install openai realtimestt`. + - **Description**: Wake word activated and voice based user interface to the OpenAI API. + +- **advanced_talk.py** + - **Dependencies**: Run `pip install openai keyboard realtimestt`. + - **Description**: Choose TTS engine and voice before starting AI conversation. + +- **minimalistic_talkbot.py** + - **Dependencies**: Run `pip install openai realtimestt`. + - **Description**: A basic talkbot in 20 lines of code. + +- **simple_llm_test.py** + - **Dependencies**: Run `pip install openai`. + - **Description**: Simple demonstration of how to integrate the library with large language models (LLMs). + +- **test_callbacks.py** + - **Dependencies**: Run `pip install openai`. + - **Description**: Showcases the callbacks and lets you check the latency times in a real-world application environment. + +## Pause, Resume & Stop + +Pause the audio stream: + +```python +stream.pause() +``` + +Resume a paused stream: + +```python +stream.resume() +``` + +Stop the stream immediately: + +```python +stream.stop() +``` + +## Requirements Explained + +- **Python Version**: + - **Required**: Python >= 3.9, < 3.13 + - **Reason**: The library depends on the GitHub library "TTS" from coqui, which requires Python versions in this range. + +- **PyAudio**: to create an output audio stream + +- **stream2sentence**: to split the incoming text stream into sentences + +- **pyttsx3**: System text-to-speech conversion engine + +- **pydub**: to convert audio chunk formats + +- **azure-cognitiveservices-speech**: Azure text-to-speech conversion engine + +- **elevenlabs**: Elevenlabs text-to-speech conversion engine + +- **coqui-TTS**: Coqui's XTTS text-to-speech library for high-quality local neural TTS + + Shoutout to [Idiap Research Institute](https://github.com/idiap) for maintaining a [fork of coqui tts](https://github.com/idiap/coqui-ai-TTS). + +- **openai**: to interact with OpenAI's TTS API + +- **gtts**: Google translate text-to-speech conversion diff --git a/docs/fr/api.md b/docs/fr/api.md new file mode 100644 index 00000000..a7fe6855 --- /dev/null +++ b/docs/fr/api.md @@ -0,0 +1,170 @@ +## Configuration + +### Paramètres d'initialisation pour `TextToAudioStream + +Lorsque vous initialisez la classe `TextToAudioStream`, vous disposez de diverses options pour personnaliser son comportement. Voici les paramètres disponibles : + +###`(BaseEngine) +- **Type**: BaseEngine +- **Obligatoire**: Oui +- **Description** : Le moteur sous-jacent responsable de la synthèse texte-audio. Vous devez fournir une instance de `ine` ou sa sous-classe pour permettre la synthèse audio. + +####`_text_stream_start` (appelable) +- **Type**: Fonction appelable +- **Obligatoire**: Non +- **Description** : Cette fonction de rappel optionnelle est déclenchée lorsque le flux de texte commence. Utilisez-le pour toute configuration ou journalisation dont vous pourriez avoir besoin. + +####`_text_stream_stop` (appelable) +- **Type**: Fonction appelable +- **Obligatoire**: Non +- **Description** : Cette fonction de rappel optionnelle est activée à la fin du flux de texte. Vous pouvez l'utiliser pour des tâches de nettoyage ou de journalisation. + +###` `_audio_stream_start` (appelable) +- **Type**: Fonction appelable +- **Obligatoire**: Non +- **Description** : Cette fonction de rappel facultative est invoquée au démarrage du flux audio. Utile pour les mises à jour de l'interface utilisateur ou la journalisation des événements. + +####`_audio_stream_stop` (appelable) +- **Type**: Fonction appelable +- **Obligatoire**: Non +- **Description** : Cette fonction de rappel optionnelle est appelée lorsque le flux audio s'arrête. Idéal pour les tâches de nettoyage des ressources ou de post-traitement. + +###` `on_character` (appelable) +- **Type**: Fonction appelable +- **Obligatoire**: Non +- **Description** : Cette fonction de rappel optionnelle est appelée lorsqu'un seul caractère est traité. + +####`_device_index` (int) +- **Type**: Entier +- **Obligatoire**: Non +- **Par défaut**: Aucun +- **Description** : Spécifie l'index du périphérique de sortie à utiliser. Aucun n'utilise le périphérique par défaut. + +###`(tokenizer`(chaîne) +- **Type**: Chaîne +- **Obligatoire**: Non +- **Par défaut**: nltk +- **Description** : Tokenizer à utiliser pour le fractionnement des phrases (actuellement « nltk » et « stroza » sont pris en charge). + +###`language(chaîne) +- **Type**: Chaîne +- **Obligatoire**: Non +- **Par défaut**: fr +- **Description** : Langue à utiliser pour le fractionnement des phrases. + +###`muted`(bool) +- **Type**: Bool +- **Obligatoire**: Non +- **Par défaut**: Faux +- **Description** : Paramètre global coupé. Si True, aucun flux pyAudio ne sera ouvert. Désactive la lecture audio via des haut-parleurs locaux (au cas où vous souhaitez synthétiser dans un fichier ou traiter des morceaux audio) et remplace le paramètre de mise en sourdine des paramètres de lecture. + +###`level` (int) +- **Type**: Entier +- **Obligatoire**: Non +- **Défaut**:`logging.AVERTISSEMENT` +- **Description** : Définit le niveau de journalisation pour l'enregistreur interne. Cela peut être n'importe quelle constante entière du module `ging` intégré de Python. + +#### Exemple d'utilisation : + +````(`python +moteur = YourEngine () # Remplacez-vous par votre moteur +flux = TextToAudioStream( + moteur=engine, + on_text_stream_start=my_text_start_func, + on_text_stream_stop=my_text_stop_func, + on_audio_stream_start=my_audio_start_func, + on_audio_stream_stop=my_audio_stop_func, + niveau=logging.INFO +) +`` +### Méthodes + +###`play et`play_async` + +Ces méthodes sont responsables de l'exécution de la synthèse texte-audio et de la lecture du flux audio. La différence est que `play` est une fonction de blocage, tandis que `play_async` s'exécute dans un thread séparé, permettant à d'autres opérations de se poursuivre. + +##### Paramètres : + +###### fast`_sentence_fragment` (bool) +- **Par défaut**: `True` +- **Description** : Lorsqu'elle est définie sur `True`, la méthode donnera la priorité à la vitesse, générant et jouant plus rapidement des fragments de phrases. Ceci est utile pour les applications où la latence est importante. + +###### fast`_sentence_fragment_allsentences`(bool) +- **Par défaut**: `False` +- **Description** : Lorsqu'il est défini sur `True`, applique le traitement rapide des fragments de phrase à toutes les phrases, pas seulement à la première. + +###### fast`_sentence_fragment_allsentences_multiple` (bool) +- **Par défaut**: `False` +- **Description** : Lorsqu'il est défini sur `True`, permet de produire plusieurs fragments de phrase au lieu d'un seul. + +###### `_threshold_seconds` (flotteur) +- **Par défaut**: `0.0` +- **Description** : Spécifie le temps en secondes pour le seuil de mise en mémoire tampon, ce qui a un impact sur la douceur et la continuité de la lecture audio. + + - **Comment ça marche** : Avant de synthétiser une nouvelle phrase, le système vérifie s'il reste plus de matériel audio dans le tampon que le temps spécifié par `buffer_threshold_seconds`. Si tel est le cas, il récupère une autre phrase du générateur de texte, en supposant qu'il peut récupérer et synthétiser cette nouvelle phrase dans la fenêtre temporelle fournie par l'audio restant dans le tampon. Ce processus permet au moteur de synthèse vocale d'avoir plus de contexte pour une meilleure synthèse, améliorant ainsi l'expérience utilisateur. + + Une valeur plus élevée garantit qu'il y a plus d'audio pré-tamponné, réduisant ainsi le risque de silence ou de lacunes pendant la lecture. Si vous rencontrez des pauses ou des pauses, envisagez d'augmenter cette valeur. + +###### `_sentence_length` (int) +- **Par défaut**: `10` +- **Description** : Définit la longueur minimale des caractères pour considérer une chaîne comme une phrase à synthétiser. Cela affecte la façon dont les morceaux de texte sont traités et lus. + +###### `_first_fragment_length`(int) +- **Par défaut**: `10` +- **Description** : Le nombre minimum de caractères requis pour le premier fragment de phrase avant de céder. + +###### `_synthesized_text` (bool) +- **Par défaut**: `False` +- **Description** : Lorsqu'il est activé, enregistre les morceaux de texte au fur et à mesure de leur synthèse en audio. Utile pour l'audit et le débogage. + +##### #reset_generated_text` (bool) +- **Par défaut**: `True` +- **Description** : Si Vrai, réinitialisez le texte généré avant le traitement. + +###### `_wavfile` (str) +- **Par défaut**: `None` +- **Description** : Si défini, enregistrez l'audio dans le fichier WAV spécifié. + +###### `_sentence_synthesized (appelable) +- **Par défaut**: `None` +- **Description** : Une fonction de rappel appelée après un seul fragment de phrase a été synthétisée. + +###### before`_sentence_synthesized (appelable) +- **Par défaut**: `None` +- **Description** : Une fonction de rappel qui est appelée avant qu'un seul fragment de phrase ne soit synthétisé. + +###### `_audio_chunk` (appelable) +- **Par défaut**: `None` +- **Description** : Fonction de rappel qui est appelée lorsqu'un seul morceau audio est prêt. + +###### ```(str) +- **Par défaut**:`"nltk"` +- **Description** : Tokenizer à utiliser pour le fractionnement des phrases. Prend actuellement en charge « nltk » et « stroza ». + +###### `_sentences` (appelable) +- **Par défaut**: `None` +- **Description** : Une fonction personnalisée qui tokenise les phrases du texte saisi. Vous pouvez fournir votre propre tokenizer léger si vous n'êtes pas satisfait de nltk et stanza. Il doit prendre du texte comme chaîne et renvoyer des phrases divisées comme liste de chaînes. + +###### `angu`(str) +- **Par défaut**:`"en"` +- **Description** : Langue à utiliser pour le fractionnement des phrases. + +###### `_size`(int) +- **Par défaut**: `12` +- **Description** : Le nombre de caractères utilisés pour établir le contexte pour la détection des limites de phrase. Un contexte plus large améliore la précision de la détection des limites des phrases. + +###### `_size_look_overhead` (int) +- **Par défaut**: `12` +- **Description** : Taille de contexte supplémentaire pour regarder vers l'avenir lors de la détection des limites des phrases. + +###### `mute` (bool) +- **Par défaut**: `False` +- **Description** : Si vrai, désactive la lecture audio via des haut-parleurs locaux. Utile lorsque vous souhaitez synthétiser dans un fichier ou traiter des morceaux audio sans les lire. + +###### `ence_fragment_delimiters` (str) +- **Par défaut**:`"?!;::\n...)]}-` +- **Description** : Une chaîne de caractères qui sont considérés comme des délimiteurs de phrases. + +###### `_first_fragment_after_`words (int) +- **Par défaut**: `15` +- **Description** : Le nombre de mots après lesquels le fragment de la première phrase est forcé d'être donné. \ No newline at end of file diff --git a/docs/fr/contributing.md b/docs/fr/contributing.md new file mode 100644 index 00000000..bac583fe --- /dev/null +++ b/docs/fr/contributing.md @@ -0,0 +1,20 @@ +# Contribuer à RealtimeTTS + +Nous accueillons les contributions à RealtimeTTS ! Voici quelques façons dont vous pouvez contribuer : + +1. **Reporting Bugs** : Si vous trouvez un bug, veuillez ouvrir un problème sur notre [référentiel GitHub](https://github.com/KoljaB/RealtimeTTS/issues). + +2. ** Suggestion d'améliorations** : Vous avez des idées de nouvelles fonctionnalités ou d'améliorations ? Nous serions ravis de les entendre ! Ouvrez un numéro pour suggérer des améliorations. + +3. **Code Contributions** : Vous voulez ajouter une nouvelle fonctionnalité ou corriger un bug ? Super ! Veuillez suivre ces étapes : + - Fourcher le dépôt + - Créez une nouvelle branche pour votre fonctionnalité + - Faites vos changements + - Soumettez une demande pull avec une description claire de vos modifications + +4. **Documentation** : Aidez-nous à améliorer notre documentation en corrigeant les fautes de frappe, en ajoutant des exemples ou en clarifiant les sections déroutantes. + +5. **Ajout de nouveaux moteurs** : Si vous souhaitez ajouter la prise en charge d'un nouveau moteur TTS, veuillez d'abord ouvrir un numéro pour discuter de l'implémentation. + + +Merci d'avoir contribué à rendre RealtimeTTS meilleur ! diff --git a/docs/fr/faq.md b/docs/fr/faq.md new file mode 100644 index 00000000..df12b3af --- /dev/null +++ b/docs/fr/faq.md @@ -0,0 +1,12 @@ +# Foire aux questions + +Pour les réponses aux questions fréquemment posées sur RealtimeTTS, veuillez vous référer à notre [page FAQ sur GitHub](https://github.com/KoljaB/RealtimeTTS/blob/main/FAQ.md). + +Cette page couvre divers sujets dont + +- Utilisation de différents moteurs TTS +- Manipulation de textes multilingues +- Optimisation des performances +- Dépannage des problèmes courants + +Pour des informations plus détaillées, veuillez consulter le lien ci-dessus. diff --git a/docs/fr/index.md b/docs/fr/index.md new file mode 100644 index 00000000..dafc2705 --- /dev/null +++ b/docs/fr/index.md @@ -0,0 +1,19 @@ +# RealtimeTTS + +[EN](../en/index.md) | [FR](../fr/index.md) + +*Bibliothèque de synthèse vocale à faible latence et facile à utiliser pour les applications en temps réel* + +## À propos du projet + +RealtimeTTS est une bibliothèque de synthèse vocale (TTS) de pointe conçue pour les applications en temps réel. Elle se distingue par sa capacité à convertir des flux de texte en sortie auditive de haute qualité avec une latence minimale. + +## Caractéristiques clés + +- **Faible latence** : conversion text-to-speech quasi-instantanée, compatible avec les sorties LLM +- **Audio de haute qualité** : génère un discours clair et naturel +- **Support de plusieurs moteurs TTS** : prend en charge OpenAI TTS, Elevenlabs, Azure Speech Services, Coqui TTS, gTTS et System TTS +- **Multilingue** +- **Robuste et fiable** : garantit une opération continue grâce à un mécanisme de fallback, bascule vers des moteurs alternatifs en cas de perturbations, garantissant une performance et une fiabilité cohérentes + +Pour les instructions d'installation, les exemples d'utilisation et la référence de l'API, veuillez naviguer à travers la documentation à l'aide du sidebar. diff --git a/docs/fr/installation.md b/docs/fr/installation.md new file mode 100644 index 00000000..289ded45 --- /dev/null +++ b/docs/fr/installation.md @@ -0,0 +1,203 @@ + +> **Remarque:** Installation de base avec `pip install realtimetts`s n'est plus recommandé, utilisez `pip install realtimetts[all]` à la place. + +La bibliothèque RealtimeTTS offre des options d'installation pour diverses dépendances pour votre cas d'utilisation. Voici les différentes façons dont vous pouvez installer RealtimeTTS en fonction de vos besoins : + +### Installation complète + +Pour installer RealtimeTTS avec prise en charge de tous les moteurs TTS : + +`` +pip install -U realtimetts [tous] +`` + +### Installation personnalisée + +RealtimeTTS permet une installation personnalisée avec un minimum d'installations de bibliothèque. Voici les options disponibles : +- **all** : Installation complète avec chaque moteur pris en charge. +- ** système** : Inclut les capacités TTS spécifiques au système (par exemple, pyttsx3). +- **azure** : ajoute le support vocal Azure Cognitive Services. +- **elevenlabs** : Comprend l'intégration avec l'API ElevenLabs. +- **openai** : Pour les services vocaux OpenAI. +- **gtts** : Prise en charge de Google Text-to-Speech. +- **coqui** : Installe le moteur Coqui TTS. +- **minimal** : installe uniquement les exigences de base sans moteur (nécessaire uniquement si vous souhaitez développer votre propre moteur) + + +Supposons que vous souhaitiez installer RealtimeTTS uniquement pour l'utilisation neuronale locale de Coqui TTS, vous devez alors utiliser : + +`` +pip installez realtimetts [coqui] +`` + +Par exemple, si vous souhaitez installer RealtimeTTS avec uniquement Azure Cognitive Services Speech, ElevenLabs et la prise en charge d'OpenAI : + +`` +pip installez realtimetts[azure,elevenlabs,openai] +`` + +### Installation de l'environnement virtuel + +Pour ceux qui souhaitent effectuer une installation complète dans un environnement virtuel, procédez comme suit + +`` +python - m venv env_realtimetts +env_realtimetts\Scripts\activate.bat +python.exe - m pip install - upgrade pip +pip install -U realtimetts [tous] +`` + +Plus d'informations sur installation CUDA. + +## Exigences du moteur + +Différents moteurs pris en charge par RealtimeTTS ont des exigences uniques. Assurez-vous de remplir ces exigences en fonction du moteur que vous choisissez. + +### Moteur système +Le `SystemEngine fonctionne dès le départ avec les capacités TTS intégrées de votre système. Aucune configuration supplémentaire n'est nécessaire. + +### GTTSEngine +Le `GTTSEngine` fonctionne dès le départ à l'aide de l'API de synthèse vocale de Google Translate. Aucune configuration supplémentaire n'est nécessaire. + +### OpenAIEngine +Pour utiliser le ``(OpenAIE): +- définir la variable d'environnement OPENAI_API_KEY +- installer ffmpeg (voir installation CUDA point 3) + +### AzureEngine +Pour utiliser le `ine`, vous aurez besoin de : +- Clé API Microsoft Azure Text-to-Speech (fournie via le paramètre constructeur AzureEngine « speech_key » ou dans la variable d'environnement AZURE_SPEECH_KEY) +- Région de service Microsoft Azure. + +Assurez-vous d'avoir ces informations d'identification disponibles et correctement configurées lors de l'initialisation du `AzureEngine`. + +### ElevenlabsEngine +Pour le `ElevenlabsEngine`, vous avez besoin de: +- Clé API Elevenlabs (fournie via le paramètre constructeur ElevenlabsEngine « api_key » ou dans la variable d'environnement ELEVENLABS_API_KEY) +- `mpv` installed on your system (essential for streaming mpeg audio, Elevenlabs ne délivre que mpeg). + +### ElevenlabsEngine +Pour le `ElevenlabsEngine`, vous avez besoin de: +- Clé API Elevenlabs (fournie via le paramètre constructeur ElevenlabsEngine « api_key » ou dans la variable d'environnement ELEVENLABS_API_KEY) +- `mpv` installed on your system (essential for streaming mpeg audio, Elevenlabs ne délivre que mpeg). + + 🔹 **Installation `v`:** + - **macOS**: + `` + infuser installer mpv + `` + + - **Linux et Windows** : Visitez [mpv.io](https://mpv.io/) pour les instructions d'installation. + +### CoquiEngine + +Offre un TTS neuronal local de haute qualité avec clonage vocal. + +Télécharge d'abord un modèle TTS neuronal. Dans la plupart des cas, il est suffisamment rapide pour le temps réel utilisant la synthèse GPU. Nécessite environ 4 à 5 Go de VRAM. + +- pour cloner une voix, soumettez le nom de fichier d'un fichier d'onde contenant la voix source comme paramètre « voix » au constructeur CoquiEngine +- le clonage vocal fonctionne mieux avec un fichier WAV mono 16 bits de 22 050 Hz contenant un échantillon court (~5 à 30 secondes) + +Sur la plupart des systèmes, la prise en charge du GPU sera nécessaire pour fonctionner suffisamment rapidement en temps réel, sinon vous ferez l'expérience du bégaiement. + +### Installation CUDA + +Ces étapes sont recommandées pour ceux qui ont besoin de ** meilleures performances ** et disposent d'un GPU NVIDIA compatible. + +> **Remarque** : *pour vérifier si votre GPU NVIDIA prend en charge CUDA, visitez la [liste officielle des GPU CUDA](https://developer.nvidia.com/cuda-gpus).* + +Pour utiliser une torche avec support via CUDA, veuillez suivre ces étapes : + +> **Remarque** : *les installations de pythorque plus récentes [peuvent](https://stackoverflow.com/a/77069523) (non vérifié) n'ont plus besoin d'installation de Toolkit (et éventuellement de cuDNN).* + +1. **Installer NVIDIA CUDA Toolkit**: + Par exemple, pour installer Toolkit 12.X, s'il te plaît + - Visitez [NVIDIA CUDA Téléchargements](https://developer.nvidia.com/cuda-downloads). + - Sélectionnez votre système d'exploitation, votre architecture système et votre version os. + - Téléchargez et installez le logiciel. + + ou pour installer Toolkit 11.8, s'il vous plaît + - Visitez [Archive de la boîte à outils CUDA NVIDIA](https://developer.nvidia.com/cuda-11-8-0-download-archive). + - Sélectionnez votre système d'exploitation, votre architecture système et votre version os. + - Téléchargez et installez le logiciel. + +2. **Installer NVIDIA cuDNN**: + + Par exemple, pour installer cuDNN 8.7.0 pour CUDA 11. x s'il vous plaît + - Visitez [NVIDIA cuDNN Archive](https://developer.nvidia.com/rdp/cudnn-archive). + - Cliquez sur « Télécharger cuDNN v8.7.0 (28 novembre 2022), pour CUDA 11.x ». + - Téléchargez et installez le logiciel. + +3. **Installer ffmpeg**: + + Vous pouvez télécharger un programme d'installation pour votre système d'exploitation à partir du [site Web deffmpeg](https://ffmpeg.org/download.html). + + Ou utilisez un gestionnaire de packages : + + - **Sur Ubuntu ou Debian**: + `` + sudo apt update & & sudo apt install ffmpeg + `` + + - **Sur Arch Linux**: + `` + sudo pacman -S ffmpeg + `` + + - **Sur MacOS utilisant Homebrew** ([https://brew.sh/](https://brew.sh/)): + `` + infuser installer ffmpeg + `` + + - **Sur Windows utilisant Chocolatey** ([https://chocolatey.org/](https://chocolatey.org/)): + `` + choco installer ffmpeg + `` + + - **Sur Windows utilisant Scoop** ([https://scoop.sh/](https://scoop.sh/)): + `` + scoop installer ffmpeg + `` + +4. **Installez PyTorch avec le support CUDA** : + + Pour mettre à niveau votre installation PyTorch afin d'activer le support GPU avec CUDA, suivez ces instructions en fonction de votre version CUDA spécifique. Ceci est utile si vous souhaitez améliorer les performances de RealtimeSTT avec les capacités CUDA. + + - **Pour CUDA 11.8:** + + Pour mettre à jour PyTorch et Torchaudio afin de prendre en charge CUDA 11.8, utilisez les commandes suivantes : + + `` + pip installe torch==2.3.1+cu118 torchaudio==2.3.1 --index-url https://download.pytorch.org/whl/cu118 + `` + + - **Pour CUDA 12.X:** + + + Pour mettre à jour PyTorch et Torchaudio pour prendre en charge CUDA 12.X, exécutez ce qui suit : + + `` + pip installe torch==2.3.1+cu121 torchaudio==2.3.1 --index-url https://download.pytorch.org/whl/cu121 + `` + + Remplacer ` ` ` of PyTorch that matching your system and requirements. + +5. ** Correction pour résoudre les problèmes de compatibilité** : + Si vous rencontrez des problèmes de compatibilité de bibliothèque, essayez de définir ces bibliothèques sur des versions fixes : + + ``` + + pip install networkx==2.8.8 + + pip install typing_extensions==4.8.0 + + pip install fsspec==2023.6.0 + + pip install imageio==2.31.6 + + pip install networkx==2.8.8 + + pip install numpy==1.24.3 + + pip install requests==2.31.0 + ``` \ No newline at end of file diff --git a/docs/fr/usage.md b/docs/fr/usage.md new file mode 100644 index 00000000..4d6c04ad --- /dev/null +++ b/docs/fr/usage.md @@ -0,0 +1,145 @@ +# Utilisation + +## Démarrage rapide + +Voici un exemple d'utilisation de base : + +````(`python +depuis RealtimeTTS import TextToAudioStream, SystemEngine, AzureEngine, ElevenlabsEngine + +moteur = SystemEngine () # remplacer par votre moteur TTS +flux = TextToAudioStream(moteur) +stream.feed("Bonjour le monde! Comment ça va aujourd'hui ?") +stream.play_async() +`` + +## Flux Texte + +Vous pouvez alimenter des chaînes individuelles : + +````(`python +stream.feed(« Bonjour, c'est une phrase. ») +`` + +Ou vous pouvez alimenter des générateurs et des itérateurs de caractères pour le streaming en temps réel : + +````(`python +def write (prompt : str) : + pour chunk en openai.ChatCompletion.create( + modèle="gpt-3.5-turbo", + messages=[{"role": "utilisateur", "contenu" : prompt}], + stream=True + ): + si (text_chunk := chunk[« choix »][0][« delta »].get(« contenu »)) n'est pas Aucun : + produire du texte_chunk + +text_stream = write (« Un discours relaxant en trois phrases ») + +stream.feed(text_stream) +`` + +````(`python +char_iterator = iter (« Diffusion de ce personnage par personnage ») +stream.feed (char_iterator) +`` + +##Layback + +Asynchrone: + +````(`python +stream.play_async() +pendant que stream.is_playing(): + temps.sommeil(0,1) +`` + +Synchronisé: + +````(`python +stream.play() +`` + +## Tester la bibliothèque + +Le sous-répertoire de test contient un ensemble de scripts pour vous aider à évaluer et comprendre les capacités de la bibliothèque RealtimeTTS. + +Notez que la plupart des tests reposent toujours sur l'« ancienne » API OpenAI (<1.0.0). L'utilisation de la nouvelle API OpenAI est démontrée dans openai_1.0_test.py. + +- **simple_test.py** + - **Description** : Une démonstration de style « hello world » de l'usage le plus simple de la bibliothèque. + +- **complex_test.py** + - **Description** : Une démonstration complète présentant la plupart des fonctionnalités fournies par la bibliothèque. + +- **coqui_test.py** + - **Description** : Test du moteur local coqui TTS. + +- **traducteur.py** + - **Dépendances**: Exécuter `pip install openai realtimestt`. + - **Description** : Traductions en temps réel dans six langues différentes. + +- **openai_voice_interface.py** + - **Dépendances**: Exécuter `pip install openai realtimestt`. + - **Description** : Interface utilisateur activée par mot de réveil et basée sur la voix vers l'API OpenAI. + +- **advanced_talk.py** + - **Dépendances**: Exécuter `pip install openai keyboard realtimestt`. + - **Description** : Choisissez le moteur et la voix TTS avant de démarrer la conversation sur l'IA. + +- **_talkbot.py** minimaliste + - **Dépendances**: Exécuter `pip install openai realtimestt`. + - **Description** : Un talkbot basique en 20 lignes de code. + +- **simple_llm_test.py** + - **Dépendances**: Exécuter `pip install openai`. + - **Description** : Démonstration simple de la façon d'intégrer la bibliothèque avec de grands modèles de langage (LLM). + +- **test_callbacks.py** + - **Dépendances**: Exécuter `pip install openai`. + - **Description** : présente les rappels et vous permet de vérifier les temps de latence dans un environnement d'application réel. + +## Mettre en pause, reprendre et arrêter + +Mettre en pause le flux audio : + +````(`python +stream.pause() +`` + +Reprendre un flux en pause : + +````(`python +stream.reprendre() +`` + +Arrêtez immédiatement le flux : + +````(`python +stream.stop() +`` + +## Exigences expliquées + +- **Version Python**: + - **Obligatoire**: Python >= 3.9, < 3.13 + - **Raison** : La bibliothèque dépend de la bibliothèque GitHub « TTS » de coqui, qui nécessite des versions Python dans cette gamme. + +- **PyAudio** : pour créer un flux audio de sortie + +- **stream2sent** : pour diviser le flux de texte entrant en phrases + +- **pyttsx3** : Moteur de conversion texte-parole du système + +- **pydub** : pour convertir les formats de morceaux audio + +- **azure-cognitiveservices-speech** : Moteur de conversion texte-parole azur + +- **elevenlabs** : Moteur de conversion texte-parole Elevenlabs + +- **coqui-TTS** : Bibliothèque de synthèse vocale XTTS de Coqui pour un TTS neuronal local de haute qualité + + Criez à [Idiap Research Institute](https://github.com/idiap) pour entretenir une [fourche de coqui tts](https://github.com/idiap/coqui-ai-TTS). + +- **openai** : pour interagir avec l'API TTS d'OpenAI + +- **gtts** : Google traduit la conversion texte-parole \ No newline at end of file diff --git a/mkdocs.yml b/mkdocs.yml new file mode 100644 index 00000000..38822f96 --- /dev/null +++ b/mkdocs.yml @@ -0,0 +1,47 @@ +site_name: RealtimeTTS Documentation +theme: + name: material + language: en + features: + - navigation.instant + - navigation.top + - navigation.tabs +plugins: + - search + - i18n: + default_language: en + languages: + - locale: en + name: English + build: true + default: true # Added default: true for English + - locale: fr + name: Français + build: true +nav: + - Home: + - English: en/index.md + - Français: fr/index.md + - Installation: + - English: en/installation.md + - Français: fr/installation.md + - Usage: + - English: en/usage.md + - Français: fr/usage.md + - API Reference: + - English: en/api.md + - Français: fr/api.md + - Contributing: + - English: en/contributing.md + - Français: fr/contributing.md + - FAQ: + - English: en/faq.md + - Français: fr/faq.md +extra: + alternate: + - name: English + link: /en/ + lang: en + - name: Français + link: /fr/ + lang: fr \ No newline at end of file