> ## Documentation Index
> Fetch the complete documentation index at: https://docs.wandb.ai/llms.txt
> Use this file to discover all available pages before exploring further.
> Importer des données depuis MLFlow, exporter ou mettre à jour les données que vous avez enregistrées sur W&B
# Importer et exporter des données
Exportez ou importez des données à l’aide des API publiques de W\&B.
Cette fonctionnalité nécessite python>=3.8
## Importer des données depuis MLFlow
W\&B vous permet d'importer des données depuis MLFlow, y compris les experiments, les runs, les artefacts, les métriques et d'autres métadonnées.
Installez les dépendances :
```shell theme={null}
# remarque : nécessite py38+
pip install wandb[importers]
```
Connectez-vous à W\&B. Si c’est votre première connexion, suivez les instructions affichées.
```shell theme={null}
wandb login
```
Importez toutes les exécutions à partir d’un serveur MLFlow existant :
```py theme={null}
from wandb.apis.importers.mlflow import MlflowImporter
importer = MlflowImporter(mlflow_tracking_uri="...")
runs = importer.collect_runs()
importer.import_runs(runs)
```
Par défaut, `importer.collect_runs()` collecte toutes les exécutions du serveur MLFlow. Si vous préférez téléverser uniquement un sous-ensemble particulier, vous pouvez créer votre propre itérable de runs et le passer à l’importateur.
```py theme={null}
import mlflow
from wandb.apis.importers.mlflow import MlflowRun
client = mlflow.tracking.MlflowClient(mlflow_tracking_uri)
runs: Iterable[MlflowRun] = []
for run in mlflow_client.search_runs(...):
runs.append(MlflowRun(run, client))
importer.import_runs(runs)
```
Vous devrez peut-être [configurer d’abord le Databricks CLI](https://docs.databricks.com/dev-tools/cli/index.html) si vous importez depuis Databricks MLflow.
Lors de l’étape précédente, définissez `mlflow-tracking-uri="databricks"`.
Pour ignorer l’import des artefacts, vous pouvez passer `artifacts=False` :
```py theme={null}
importer.import_runs(runs, artifacts=False)
```
Pour importer dans une entité et un projet W\&B spécifiques, vous pouvez fournir un `Namespace` :
```py theme={null}
from wandb.apis.importers import Namespace
importer.import_runs(runs, namespace=Namespace(entity, project))
```
## Exporter des données
Utilisez l’API publique pour exporter ou mettre à jour les données que vous avez enregistrées dans W\&B. Avant d’utiliser cette API, enregistrez des données à partir de votre script. Consultez le [Démarrage rapide](/fr/models/quickstart/) pour plus de détails.
**Cas d’utilisation de l’API publique**
* **Exporter des données** : récupérez un dataframe pour effectuer une analyse personnalisée dans un notebook Jupyter. Une fois les données explorées, vous pouvez synchroniser vos résultats en créant un nouveau run d’analyse et en enregistrant les résultats, par exemple : `wandb.init(job_type="analysis")`
* **Mettre à jour des Runs existants** : vous pouvez mettre à jour les données enregistrées pour un run W\&B. Par exemple, vous pouvez vouloir mettre à jour la configuration d’un ensemble de runs afin d’y inclure des informations supplémentaires, comme l’architecture ou un hyperparamètre qui n’avait pas été enregistré à l’origine.
Voir la [documentation de référence générée](/fr/models/ref/python/public-api/) pour plus de détails sur les fonctions disponibles.
### Créer une clé API
Une clé API permet d’authentifier votre machine auprès de W\&B.
Pour créer une clé API, sélectionnez l’onglet **Clé API personnelle** ou **Clé API de compte de service** pour en savoir plus.
Pour créer une clé API personnelle liée à votre ID utilisateur :
1. Connectez-vous à W\&B, puis cliquez sur l’icône de votre profil **> Paramètres utilisateur**.
2. Cliquez sur **Create new API key**.
3. Saisissez un nom descriptif pour votre clé API.
4. Cliquez sur **Create**.
5. Copiez immédiatement la clé API affichée et stockez-la de manière sécurisée.
Pour créer une clé API associée à un compte de service :
1. Dans les paramètres de votre équipe ou de votre organisation, accédez à l’onglet **Service Accounts**.
2. Recherchez le compte de service dans la liste.
3. Cliquez sur le menu **d’action ()**, puis sur **Create API key**.
4. Saisissez un nom pour la clé API, puis cliquez sur **Create**.
5. Copiez immédiatement la clé API affichée et stockez-la en lieu sûr.
6. Cliquez sur **Done**.
Vous pouvez créer plusieurs clés API pour un même compte de service afin de prendre en charge différents environnements ou flux de travail.
W\&B affiche la clé API complète une seule fois, au moment où vous la créez. Une fois la boîte de dialogue fermée, vous ne pourrez plus voir la clé API complète. Vos paramètres n’affichent que l’ID de la clé (la première partie de la clé). Si vous perdez la clé API complète, vous devrez créer une nouvelle clé API.
Pour connaître les options de stockage sécurisé, voir [Stocker les clés API en toute sécurité](/fr/platform/app/settings-page/user-settings/#store-and-handle-api-keys-securely).
## Stockez et manipulez les clés API en toute sécurité
Les clés API donnent accès à votre compte W\&B et doivent être protégées comme des mots de passe. Les sections suivantes décrivent les méthodes de stockage recommandées, les pratiques à éviter, la façon de transmettre les clés à votre code et les exigences de version du SDK pour les clés plus récentes.
### Méthodes de stockage recommandées
Utilisez l’une des méthodes suivantes pour stocker votre clé API en toute sécurité.
* **Gestionnaire de secrets** : Utilisez un système dédié de gestion des secrets, tel que [AWS Secrets Manager](https://aws.amazon.com/secrets-manager/), [HashiCorp Vault](https://developer.hashicorp.com/vault), [Azure Key Vault](https://azure.microsoft.com/en-us/products/key-vault) ou [Google Secret Manager](https://cloud.google.com/security/products/secret-manager).
* **Gestionnaire de mots de passe** : Utilisez une application de gestion de mots de passe fiable.
* **Trousseaux du système d’exploitation** : Stockez les clés dans le Trousseau macOS, le Gestionnaire d’identifiants Windows ou le service de secrets Linux. Déconseillé en production.
### Ce qu’il faut éviter
Évitez les pratiques suivantes, qui peuvent exposer votre clé API :
* N’enregistrez jamais de clés API dans un système de gestion de versions comme Git.
* Ne stockez pas de clés API dans des fichiers de configuration en texte brut.
* Ne transmettez pas de clés API en ligne de commande, car elles seront visibles dans la sortie de commandes du système d’exploitation telles que `ps`.
* Évitez de partager des clés API par e-mail, via le chat ou par d’autres canaux non chiffrés.
* N’intégrez pas de clés API en dur dans votre code source.
Si une clé API est exposée, supprimez-la immédiatement de votre compte W\&B et contactez l’[assistance](mailto:support@wandb.ai) ou votre AISE.
### Variables d’environnement
Lorsque vous utilisez des clés API dans votre code, transmettez-les via des variables d’environnement :
```bash theme={null}
export WANDB_API_KEY="[YOUR-API-KEY]"
```
Cette approche évite d’exposer les clés dans votre code source et facilite leur renouvellement si nécessaire.
Évitez de définir la variable d’environnement sur la même ligne que la commande, car elle est visible dans la sortie de commandes système comme `ps` :
```bash theme={null}
# Évitez cette pratique, qui peut exposer la clé API dans les gestionnaires de processus
export WANDB_API_KEY="[YOUR-API-KEY]" ./my-script.sh
```
### Compatibilité des versions du SDK
Si vous utilisez une clé API plus récente, vérifiez que votre version du SDK la prend en charge. Les nouvelles clés API sont plus longues que les clés héritées. Lors de l’authentification avec des versions antérieures des SDK `wandb` ou `weave`, vous pouvez rencontrer une erreur liée à la longueur de la clé API.
**Solution** : mettez à jour vers une version plus récente du SDK :
* `wandb` SDK v0.22.3+
```bash theme={null}
pip install --upgrade wandb==0.22.3
```
* `weave` SDK v0.52.17+
```bash theme={null}
pip install --upgrade weave==0.52.17
```
Si vous ne pouvez pas mettre à jour le SDK immédiatement, utilisez la variable d’environnement `WANDB_API_KEY` pour définir la clé API en guise de solution de contournement.
### Trouver le chemin du run
Pour utiliser l’API publique, vous aurez souvent besoin du chemin du run, au format `//`. Dans l’interface de l’application, ouvrez la page d’un run et cliquez sur l’[onglet Vue d’ensemble ](/fr/models/track/public-api-guide/#overview-tab)pour obtenir le chemin du run.
### Exporter les données d’un run
Téléchargez les données d’un run terminé ou en cours. Les cas d’usage courants incluent le téléchargement d’un dataframe pour une analyse personnalisée dans un notebook Jupyter, ou l’utilisation d’une logique personnalisée dans un environnement automatisé.
```python theme={null}
import wandb
api = wandb.Api()
run = api.run("//")
```
Les attributs les plus couramment utilisés d'un objet run sont :
| Attribute | Meaning |
| --------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `run.config` | Un dictionnaire contenant les informations de configuration du run, telles que les hyperparamètres d'un run d'entraînement ou les méthodes de prétraitement d'un run qui crée un Artifact de jeu de données. Considérez-les comme les entrées du run. |
| `run.history()` | Une liste de dictionnaires destinée à stocker les valeurs qui changent pendant l'entraînement du modèle, comme la perte. La commande `run.log()` ajoute des éléments à cet objet. |
| `run.summary` | Un dictionnaire d'informations qui résume les résultats du run. Il peut s'agir de scalaires comme la précision et la perte, ou de fichiers volumineux. Par défaut, `run.log()` définit le summary sur la dernière valeur d'une série temporelle enregistrée. Le contenu du summary peut aussi être défini directement. Considérez le summary comme les sorties du run. |
Vous pouvez également modifier ou mettre à jour les données de runs passés. Par défaut, une seule instance d'un objet API met en cache toutes les requêtes réseau. Si votre cas d'utilisation nécessite des informations en temps réel dans un script en cours d'exécution, appelez `api.flush()` pour obtenir des valeurs mises à jour.
### Comprendre les différents attributs d’un run
L’extrait de code suivant montre comment créer un run, consigner des données, puis accéder aux attributs du run :
```python theme={null}
import wandb
import random
with wandb.init(project="public-api-example") as run:
n_epochs = 5
config = {"n_epochs": n_epochs}
run.config.update(config)
for n in range(run.config.get("n_epochs")):
run.log(
{"val": random.randint(0, 1000), "loss": (random.randint(0, 1000) / 1000.00)}
)
```
Les sections suivantes décrivent les différentes sorties associées aux attributs de l’objet run ci-dessus
##### `run.config`
```python theme={null}
{"n_epochs": 5}
```
#### `run.summary`
```python theme={null}
{
"_step": 4,
"_timestamp": 1644345412,
"_wandb": {"runtime": 3},
"loss": 0.041,
"val": 525,
}
```
### Échantillonnage
La méthode history par défaut échantillonne les métriques pour n’en conserver qu’un nombre fixe (500 par défaut ; vous pouvez le modifier avec l’argument `samples` \_\_). Si vous souhaitez exporter toutes les données d’un run de grande taille, vous pouvez utiliser la méthode `run.scan_history()`. Pour en savoir plus, voir la [Référence de l’API](/fr/models/ref/python/public-api).
### Interroger plusieurs runs
Ce script d’exemple recherche un projet et génère un CSV des runs avec leur nom, leur configuration et leurs statistiques de synthèse. Remplacez `` et `` par votre entité W\&B et le nom de votre projet, respectivement.
```python theme={null}
import pandas as pd
import wandb
api = wandb.Api()
entity, project = "", ""
runs = api.runs(entity + "/" + project)
summary_list, config_list, name_list = [], [], []
for run in runs:
# .summary contient les clés/valeurs de sortie pour
# des métriques telles que la précision.
# Nous appelons ._json_dict pour omettre les fichiers volumineux
summary_list.append(run.summary._json_dict)
# .config contient les hyperparamètres.
# Nous supprimons les valeurs spéciales qui commencent par _.
config_list.append({k: v for k, v in run.config.items() if not k.startswith("_")})
# .name est le nom du run lisible par l’utilisateur.
name_list.append(run.name)
runs_df = pd.DataFrame(
{"summary": summary_list, "config": config_list, "name": name_list}
)
runs_df.to_csv("project.csv")
run.finish()
```
L’API W\&B vous permet également d’effectuer des requêtes sur les runs d’un projet avec api.runs(). Le cas d’usage le plus courant consiste à exporter les données de runs pour une analyse personnalisée. L’interface de requête est la même que celle [utilisée par MongoDB](https://www.mongodb.com/docs/manual/reference/mql/query-predicates/).
```python theme={null}
runs = api.runs(
"username/project",
{"$or": [{"config.experiment_name": "foo"}, {"config.experiment_name": "bar"}]},
)
print(f"Found {len(runs)} runs")
```
L’appel à `api.runs` renvoie un objet `Runs` itérable qui se comporte comme une liste. Par défaut, l’objet charge 50 runs à la fois, séquentiellement et selon les besoins, mais vous pouvez modifier le nombre chargé par page avec l’argument nommé `per_page`.
`api.runs` accepte également un argument nommé `order`. L’ordre par défaut est `-created_at`. Pour trier les résultats par ordre croissant, indiquez `+created_at`. Vous pouvez également trier par des valeurs de config ou de synthèse. Par exemple, `summary.val_acc` ou `config.experiment_name`.
### Gestion des erreurs
Si des erreurs surviennent lors de la communication avec les serveurs W\&B, une exception `wandb.CommError` est levée. Vous pouvez examiner l’exception d’origine via l’attribut `exc`.
### Obtenir le dernier commit git via l’API
Dans l’UI, cliquez sur un run, puis sur l’onglet Vue d’ensemble de la page du run pour afficher le dernier commit git. Il figure également dans le fichier `wandb-metadata.json` . Avec l’API publique, vous pouvez obtenir le hachage git avec `run.commit`.
### Obtenir le nom et l’ID d’un run en cours d’exécution
Après avoir appelé `wandb.init()`, vous pouvez accéder depuis votre script à l’ID aléatoire du run ou à son nom lisible, comme ceci :
* ID unique du run (hachage de 8 caractères) : `run.id`
* Nom aléatoire du run (lisible) : `run.name`
Si vous cherchez un bon moyen de définir des identifiants utiles pour vos runs, voici ce que nous recommandons :
* **ID du run** : laissez le hachage généré tel quel. Il doit être unique parmi les runs de votre projet.
* **Nom du run** : il doit être court, lisible et de préférence unique, afin que vous puissiez distinguer les différentes lignes sur vos graphiques.
* **Notes du run** : c’est l’endroit idéal pour ajouter une brève description de ce que vous faites dans ce run. Vous pouvez les définir avec `wandb.init(notes="your notes here")`
* **Tags du run** : utilisez les tags du run pour suivre des éléments de manière dynamique, puis utilisez des filtres dans l’UI pour n’afficher dans votre tableau que les runs qui vous intéressent. Vous pouvez définir les tags depuis votre script, puis les modifier dans l’UI, à la fois dans le tableau des Runs et dans l’onglet Vue d’ensemble de la page du run. Voir les instructions détaillées [ici](/fr/models/runs/tags/).
## Exemples d’utilisation de l’API publique
### Exporter des données pour les visualiser dans matplotlib ou seaborn
Consultez nos [exemples d’API](/fr/models/ref/python/public-api/) pour voir quelques méthodes d’export courantes. Vous pouvez aussi cliquer sur le bouton de téléchargement d’un graphique personnalisé ou de la vue développée du tableau Runs pour télécharger un fichier CSV depuis votre navigateur.
### Lire les métriques d’un run
Cet exemple affiche le timestamp et la précision enregistrés avec `run.log({"accuracy": acc})` pour un run enregistré sous `"//"`.
```python theme={null}
import wandb
api = wandb.Api()
run = api.run("//")
if run.state == "finished":
for i, row in run.history().iterrows():
print(row["_timestamp"], row["accuracy"])
```
### Filtrer les runs
Vous pouvez filtrer à l’aide du langage de requête MongoDB.
#### Date
```python theme={null}
runs = api.runs(
"/",
{"$and": [{"created_at": {"$lt": "YYYY-MM-DDT##", "$gt": "YYYY-MM-DDT##"}}]},
)
```
### Lire des métriques spécifiques d’un run
Pour récupérer des métriques spécifiques d’un run, utilisez l’argument `keys`. Le nombre d’échantillons par défaut lors de l’utilisation de `run.history()` est de 500. Les étapes enregistrées qui n’incluent pas de métrique spécifique apparaîtront dans le dataframe de sortie sous la forme de `NaN`. L’argument `keys` fera en sorte que l’API échantillonne plus fréquemment les étapes qui incluent les clés de métrique listées.
```python theme={null}
import wandb
api = wandb.Api()
run = api.run("//")
if run.state == "finished":
for i, row in run.history(keys=["accuracy"]).iterrows():
print(row["_timestamp"], row["accuracy"])
```
### Comparer deux runs
Cette commande affiche les paramètres de configuration qui diffèrent entre `run1` et `run2`.
```python theme={null}
import pandas as pd
import wandb
api = wandb.Api()
# remplacez par votre , et
run1 = api.run("//")
run2 = api.run("//")
df = pd.DataFrame([run1.config, run2.config]).transpose()
df.columns = [run1.name, run2.name]
print(df[df[run1.name] != df[run2.name]])
```
Sorties :
```
c_10_sgd_0.025_0.01_long_switch base_adam_4_conv_2fc
batch_size 32 16
n_conv_layers 5 4
optimizer rmsprop adam
```
### Mettre à jour les métriques d’un run après la fin du run
Cet exemple définit `accuracy` d’un run précédent à `0.9`. Il modifie également l’histogramme de `accuracy` d’un run précédent pour qu’il devienne l’histogramme de `numpy_array`.
```python theme={null}
import wandb
api = wandb.Api()
run = api.run("//")
run.summary["accuracy"] = 0.9
run.summary["accuracy_histogram"] = wandb.Histogram(numpy_array)
run.summary.update()
```
### Renommer une métrique dans un run terminé
Cet exemple renomme une colonne « summary » dans vos tableaux.
```python theme={null}
import wandb
api = wandb.Api()
run = api.run("//")
run.summary["new_name"] = run.summary["old_name"]
del run.summary["old_name"]
run.summary.update()
```
Le changement de nom d’une colonne s’applique uniquement aux tableaux. Les graphiques continueront d’utiliser les noms d’origine des métriques.
### Mettre à jour la configuration d’un run existant
Cet exemple met à jour un de vos paramètres de configuration.
```python theme={null}
import wandb
api = wandb.Api()
run = api.run("//")
run.config["key"] = updated_value
run.update()
```
### Exporter l’utilisation des ressources système vers un fichier CSV
L’extrait ci-dessous permet de trouver l’utilisation des ressources système, puis de l’enregistrer dans un fichier CSV.
```python theme={null}
import wandb
with wandb.Api().run("//") as run:
system_metrics = run.history(stream="events")
system_metrics.to_csv("sys_metrics.csv")
```
### Obtenir des données de métriques non échantillonnées
Lorsque vous récupérez des données depuis l’historique, elles sont, par défaut, échantillonnées à 500 points. Récupérez tous les points de données enregistrés avec `run.scan_history()`. Voici un exemple qui télécharge tous les points de données `loss` enregistrés dans l’historique.
```python theme={null}
import wandb
api = wandb.Api()
run = api.run("//")
history = run.scan_history()
losses = [row["loss"] for row in history]
```
### Obtenir des données paginées à partir de l’historique
Si les métriques sont récupérées lentement par notre backend ou si les requêtes d’API expirent, vous pouvez essayer de réduire la taille de page dans `scan_history` afin d’éviter que les requêtes individuelles n’expirent. La taille de page par défaut est de 500, vous pouvez donc tester différentes valeurs pour voir ce qui fonctionne le mieux :
```python theme={null}
import wandb
api = wandb.Api()
run = api.run("//")
run.scan_history(keys=sorted(cols), page_size=100)
```
### Exporter les métriques de tous les runs d’un projet dans un fichier CSV
Ce script récupère les runs d’un projet et génère un dataframe ainsi qu’un fichier CSV contenant leurs noms, leurs configurations et leurs statistiques de synthèse. Remplacez `` et `` par votre entité W\&B et le nom de votre projet, respectivement.
```python theme={null}
import pandas as pd
import wandb
api = wandb.Api()
entity, project = "", ""
runs = api.runs(entity + "/" + project)
summary_list, config_list, name_list = [], [], []
for run in runs:
# .summary contient les clés/valeurs de sortie
# pour les métriques telles que la précision.
# Nous appelons ._json_dict pour omettre les fichiers volumineux
summary_list.append(run.summary._json_dict)
# .config contient les hyperparamètres.
# Nous supprimons les valeurs spéciales qui commencent par _.
config_list.append({k: v for k, v in run.config.items() if not k.startswith("_")})
# .name est le nom lisible par l'homme du run.
name_list.append(run.name)
runs_df = pd.DataFrame(
{"summary": summary_list, "config": config_list, "name": name_list}
)
runs_df.to_csv("project.csv")
```
### Obtenir l’heure de début d’un run
Cet extrait de code récupère l’heure de création du run.
```python theme={null}
import wandb
api = wandb.Api()
run = api.run("entity/project/run_id")
start_time = run.created_at
```
### Importer des fichiers dans un run terminé
L’extrait de code ci-dessous importe un fichier sélectionné dans un run terminé.
```python theme={null}
import wandb
api = wandb.Api()
run = api.run("entity/project/run_id")
run.upload_file("file_name.extension")
```
### Télécharger un fichier d’un run
Cet exemple localise le fichier "model-best.h5" associé au run ID uxte44z7 dans le projet cifar et l’enregistre localement.
```python theme={null}
import wandb
api = wandb.Api()
run = api.run("//")
run.file("model-best.h5").download()
```
### Télécharger tous les fichiers d’un run
Cette commande récupère tous les fichiers associés à un run et les enregistre localement.
```python theme={null}
import wandb
api = wandb.Api()
run = api.run("//")
for file in run.files():
file.download()
```
### Obtenir les runs d’un balayage spécifique
Cet extrait télécharge tous les runs associés à un balayage donné.
```python theme={null}
import wandb
api = wandb.Api()
sweep = api.sweep("//")
sweep_runs = sweep.runs
```
### Obtenir le meilleur run d’un balayage
L’extrait suivant récupère le meilleur run d’un balayage donné.
```python theme={null}
import wandb
api = wandb.Api()
sweep = api.sweep("//")
best_run = sweep.best_run()
```
Le `best_run` correspond au run présentant la meilleure métrique, telle que définie par le paramètre `metric` dans la configuration du balayage.
### Télécharger le fichier du meilleur modèle depuis un balayage
Cet extrait télécharge le fichier de modèle avec la meilleure précision de validation depuis un balayage contenant des runs qui ont enregistré des fichiers de modèle sous `model.h5`.
```python theme={null}
import wandb
api = wandb.Api()
sweep = api.sweep("//")
runs = sorted(sweep.runs, key=lambda run: run.summary.get("val_acc", 0), reverse=True)
val_acc = runs[0].summary.get("val_acc", 0)
print(f"Best run {runs[0].name} with {val_acc}% val accuracy")
runs[0].file("model.h5").download(replace=True)
print("Best model saved to model-best.h5")
```
### Supprimer d’un run tous les fichiers ayant une extension donnée
Cet extrait supprime d’un run les fichiers ayant une extension donnée.
```python theme={null}
import wandb
api = wandb.Api()
run = api.run("//")
extension = ".png"
files = run.files()
for file in files:
if file.name.endswith(extension):
file.delete()
```
### Télécharger les données des métriques système
Cet extrait génère un dataframe contenant toutes les métriques de consommation des ressources système d’un run, puis l’enregistre dans un fichier CSV.
```python theme={null}
import wandb
api = wandb.Api()
run = api.run("//")
system_metrics = run.history(stream="events")
system_metrics.to_csv("sys_metrics.csv")
```
### Mettre à jour les métriques du summary
Vous pouvez transmettre un dictionnaire pour mettre à jour les métriques du summary.
```python theme={null}
summary.update({"key": val})
```
### Obtenir la commande qui a lancé le run
Chaque run enregistre la commande qui l’a lancé sur la page d’aperçu du run. Pour récupérer cette commande depuis l’API, vous pouvez exécuter :
```python theme={null}
import wandb
api = wandb.Api()
run = api.run("//")
meta = json.load(run.file("wandb-metadata.json").download())
program = ["python"] + [meta["program"]] + meta["args"]
```