# General Translation Python SDKs: initialize_gt
URL: https://generaltranslation.com/fr/docs/python/reference/functions/initialize-gt.mdx
---

title: initialize_gt
description: Configurez le SDK Python de General Translation une seule fois pour une application Flask ou FastAPI. Référence API pour initialize_gt.

---

Configure General Translation pour une application Flask ou FastAPI. Appelez `initialize_gt` une seule fois au démarrage — avant toute autre fonction de traduction — pour créer le gestionnaire de traduction, enregistrer la détection du paramètre régional pour chaque requête et configurer la livraison des traductions.

## Vue d’ensemble [#overview]

Appelez `initialize_gt` avec votre application. Les paramètres sont chargés à partir de `gt.config.json` dans le répertoire de travail courant, et tout argument nommé remplace les valeurs du fichier. La fonction renvoie l’[`I18nManager`](/docs/python/reference/classes/i18n-manager) configuré et l’enregistre comme gestionnaire actif, afin que les appels ultérieurs à [`t`](/docs/python/reference/functions/t) et aux fonctions utilitaires liées au paramètre régional fonctionnent automatiquement.

```python
from flask import Flask
from gt_flask import initialize_gt

app = Flask(__name__)
initialize_gt(app)
```

Signature :

```python
initialize_gt(
    app,
    *,
    default_locale: str | None = None,
    locales: list[str] | None = None,
    custom_mapping: CustomMapping | None = None,
    project_id: str | None = None,
    cache_url: str | None = None,
    version_id: str | None = None,
    get_locale: Callable[..., str] | None = None,
    load_translations: Callable[[str], dict[str, str]] | None = None,
    eager_loading: bool = True,
    config_path: str | None = None,
    load_config: Callable[[str | None], GTConfig] | None = None,
) -> I18nManager
```

Importez `initialize_gt` depuis `gt_flask` ou `gt_fastapi`, selon votre framework. La signature est identique dans les deux cas. Il n’existe pas de `initialize_gt` dans la bibliothèque principale ; sans framework, créez un [`I18nManager`](/docs/python/reference/classes/i18n-manager) et appelez plutôt [`set_i18n_manager`](/docs/python/reference/functions/set-i18n-manager).

*Remarque : il n’existe pas de paramètre `api_key`. La livraison via CDN repose sur `project_id` et `cache_url`.*

## Fonctionnement [#how-it-works]

* **Résolution de la configuration.** Charge la configuration (via `load_config`, un `config_path` explicite ou le `gt.config.json` par défaut), puis résout chaque paramètre dans l’ordre suivant : d’abord l’argument nommé, puis la valeur de la configuration, puis la valeur par défaut de la bibliothèque.
* **Initialisation du gestionnaire.** Construit un `I18nManager` à partir des paramètres résolus, puis l’enregistre avec `set_i18n_manager`.
* **Détection du paramètre régional.** Avec Flask, enregistre un hook `before_request` ; avec FastAPI, ajoute un middleware HTTP et encapsule le cycle de vie de l’application. Pour chaque requête, le paramètre régional est défini à partir de [`get_locale`](/docs/python/reference/functions/get-locale) si cette fonction est fournie, sinon à partir de l’en-tête `Accept-Language`.
* **Chargement anticipé.** Lorsque `eager_loading` vaut `true` et que les locales cibles sont connues, charge toutes les traductions à l’avance. Avec Flask, cela utilise l’argument `locales` que vous passez directement (et non les locales définies uniquement dans la configuration) ; avec FastAPI, cela s’exécute dans le cycle de vie encapsulé à partir des locales résolues.

## Paramètres [#parameters]

| Paramètre                                 | Description                                                               | Type                                                                  | Facultatif | Par défaut          |
| ----------------------------------------- | ------------------------------------------------------------------------- | --------------------------------------------------------------------- | ---------- | ------------------- |
| [`app`](#app)                             | L'instance d'application Flask ou FastAPI.                        | `Flask \| FastAPI`                                                    | Non        | —                   |
| [`default_locale`](#default-locale)       | Paramètre régional source et de secours.                                  | `str`                                                                 | Oui        | Config, puis `"en"` |
| [`locales`](#locales)                     | Locales cibles prises en charge.                                          | `list[str]`                                                           | Oui        | Config              |
| [`custom_mapping`](#custom-mapping)       | Codes de langue personnalisés et surcharges de propriétés.                | [`CustomMapping`](/docs/platform/core/reference/types/custom-mapping) | Oui        | Config              |
| [`project_id`](#project-id)               | ID de projet ; active le loader CDN lorsqu'il est défini.             | `str`                                                                 | Oui        | Config              |
| [`cache_url`](#cache-url)                 | Surcharge de l'URL de base du CDN.                                    | `str`                                                                 | Oui        | Config              |
| [`version_id`](#version-id)               | Version de traduction épinglée.                                           | `str`                                                                 | Oui        | Config              |
| [`get_locale`](#get-locale)               | callback personnalisée de détection du paramètre régional.                | `(request) -> str`                                                    | Oui        | `Accept-Language`   |
| [`load_translations`](#load-translations) | loader personnalisé renvoyant les traductions pour un paramètre régional. | `(locale: str) -> dict[str, str]`                                     | Oui        | —                   |
| [`eager_loading`](#eager-loading)         | Précharge toutes les traductions au démarrage.                            | `bool`                                                                | Oui        | `True`              |
| [`config_path`](#config-path)             | Chemin vers un fichier `gt.config.json`.                                  | `str`                                                                 | Oui        | `gt.config.json`    |
| [`load_config`](#load-config)             | loader de configuration personnalisé qui remplace celui par défaut.       | `(path: str \| None) -> GTConfig`                                     | Oui        | —                   |

### `app` [#app]

**Type** `Flask | FastAPI` · **Obligatoire**

L’instance d’application à configurer. Elle est passée en argument positionnel ; tous les autres paramètres doivent être fournis sous forme d’arguments nommés.

### `default_locale` [#default-locale]

**Type** `str` · **Facultatif** · **Par défaut** valeur de configuration, puis `"en"`

Le paramètre régional source dans lequel votre contenu est rédigé, ainsi que le contenu de secours lorsqu’aucune traduction n’est trouvée. Correspond d’abord à l’argument, puis à `defaultLocale` dans `gt.config.json`, puis à `"en"`.

### `locales` [#locales]

**Type** `list[str]` · **Facultatif** · **Valeur de configuration par défaut**

Les locales cibles à prendre en charge. Prend la valeur de l’argument, ou, à défaut, celle du tableau `locales` dans `gt.config.json`. Le paramètre régional par défaut est toujours inclus dans l’ensemble des locales du gestionnaire.

### `custom_mapping` [#custom-mapping]

**Type** `CustomMapping` · **Facultatif** · **Valeur de configuration par défaut**

Une correspondance entre des codes de langue personnalisés et des codes standard, ou des surcharges de propriétés. Voir [`customMapping`](/docs/python/reference/config#custom-mapping).

### `project_id` [#project-id]

**Type** `str` · **Facultatif** · **Valeur de configuration par défaut**

L’identifiant de votre projet General Translation. Lorsqu’il est défini (et qu’aucun `load_translations` n’est fourni), il active le chargement des traductions depuis le CDN à l’adresse `{cache_url}/{project_id}/{locale}`.

### `cache_url` [#cache-url]

**Type** `str` · **Facultatif** · **Valeur de configuration par défaut**

Permet de remplacer l’URL de base du CDN utilisée pour charger les traductions. Le CDN de General Translation est `https://cdn.gtx.dev`.

### `version_id` [#version-id]

**Type** `str` · **Facultatif** · **Valeur de configuration par défaut**

Version de traduction épinglée à charger. Correspond à la clé de configuration `_versionId` et est renvoyée par [`get_version_id`](/docs/python/reference/functions/get-version-id).

### `get_locale` [#get-locale]

**Type** `(request) -> str` · **Facultatif** · **Par défaut** analyse de `Accept-Language`

Un callback personnalisé de détection du paramètre régional. Il reçoit la requête et renvoie un code de langue, remplaçant entièrement la détection `Accept-Language` intégrée. Si la valeur de retour est falsy, le paramètre régional par défaut est utilisé.

```python
def get_locale(request):
    return request.args.get("lang") or "en"

initialize_gt(app, get_locale=get_locale)
```

### `load_translations` [#load-translations]

**Type** `(locale: str) -> dict[str, str]` · **Facultatif**

Une fonction personnalisée qui charge les traductions d’un paramètre régional depuis votre propre source plutôt que depuis le CDN. Lorsqu’elle est définie, elle remplace le loader du CDN. Elle peut être synchrone ou renvoyer un objet awaitable.

```python
def load_translations(locale: str) -> dict[str, str]:
    # Charger les traductions depuis votre propre source
    ...

initialize_gt(app, load_translations=load_translations)
```

### `eager_loading` [#eager-loading]

**Type** `bool` · **Facultatif** · **Par défaut** `True`

Lorsqu’elle est activée, toutes les traductions sont chargées au démarrage plutôt qu’à la première utilisation. Consultez la note [Fonctionnement](#how-it-works) sur la différence entre Flask et FastAPI quant à la source du paramètre régional.

### `config_path` [#config-path]

**Type** `str` · **Facultatif** · **Par défaut** `gt.config.json`

Le chemin d’accès vers un fichier `gt.config.json`. Par défaut, `gt.config.json` est recherché dans le répertoire de travail courant. Un chemin explicite qui n’existe pas lève `FileNotFoundError`.

### `load_config` [#load-config]

**Type** `(path: str | None) -> GTConfig` · **Facultatif**

Un loader de configuration personnalisé qui remplace le loader de fichier par défaut. Elle reçoit `config_path` et renvoie un dictionnaire `GTConfig`.

## Renvoie [#returns]

**Type** `I18nManager`

L’[`I18nManager`](/docs/python/reference/classes/i18n-manager) configuré, déjà enregistré en tant que gestionnaire actif.

## Exemples [#examples]

```python
# Configuration minimale, lecture de gt.config.json
from flask import Flask
from gt_flask import initialize_gt

app = Flask(__name__)
initialize_gt(app)
```

```python
# Locales explicites avec un translation loader personnalisé
from fastapi import FastAPI
from gt_fastapi import initialize_gt

app = FastAPI()

def load_translations(locale: str) -> dict[str, str]:
    # Charger les traductions depuis votre propre source
    ...

initialize_gt(app, default_locale="en", locales=["es", "fr"], load_translations=load_translations)
```