Lancer les commandes uv depuis l'éditeur

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214

# Lancer les commandes uv depuis l'éditeur

Ce guide montre comment formater, vérifier, compiler, tester et exécuter votre projet sans quitter Turbo Python. Il suppose l'éditeur installé et un projet Python sous la main.

## Obtenir un fichier de départ

Lancez l'éditeur **depuis le dossier du projet**, puis choisissez **Python ▸ Create tools file** (`Alt-P`, puis `C`).

Cela écrit `.turbo-python/tools.toml` avec les cinq commandes qu'un projet Python passe avant de commiter, et l'ouvre :

```toml
[[tool]]
name = "~F~ormat"
command = "uv run ruff format ."
output = "popup"

[[tool]]
name = "~T~est"
command = "uv run pytest"
output = "popup"

[[tool]]
name = "~R~un"
command = "uv run"
# Un terminal, pas une popup : un programme qui lit le clavier doit pouvoir
# recevoir une réponse, et un programme long doit pouvoir être interrompu.
output = "terminal"
```

Chaque `[[tool]]` devient une ligne du menu **Python**, dans l'ordre du fichier — sauf s'il nomme un `menu` à lui, ce que couvre la section suivante mais une. Le fichier est relu à **chaque ouverture du menu** : une modification prend effet immédiatement.

## En lancer une

`Alt-P`, puis la lettre entre les tildes — `F` pour formater, `T` pour tester.

Une **popup** s'ouvre aussitôt et se remplit à mesure. Son titre porte la commande et, une fois terminée, son issue :

```
┌──────────── uv run ruff check . — exit 1 ────────────┐
│  main.py:6:2: unreachable code                │
│                                               │
│                   [ Close ]                   │
└───────────────────────────────────────────────┘
```

| Touche | Effet |
| --- | --- |
| `↑` `↓` `Page↑` `Page↓` `Début` `Fin` | Parcourir la sortie |
| `Échap` | Fermer — et **arrêter la commande** si elle tourne encore |
| `Entrée` | Fermer |

Une commande qui a réussi sans rien dire affiche `(no output)` plutôt qu'une boîte vide : on la distingue ainsi d'une commande qui n'a pas démarré.

La popup suit la sortie tant que vous n'avez pas remonté ; ensuite elle vous laisse où vous êtes.

## Choisir où va la sortie

Posez `output` sur un outil :

| `output` | Ce que vous obtenez |
| --- | --- |
| `popup` | Un dialogue qui se remplit pendant l'exécution. Le défaut. |
| `terminal` | Une fenêtre terminal : couleurs, `Ctrl-C`, et le clavier atteint le programme |
| `editor` | Une fenêtre d'édition une fois terminé, à fouiller avec `Ctrl-F` |

`Run` est en `terminal` dans le fichier de départ, et c'est l'exemple même de pourquoi la clé existe : une popup ne peut pas répondre à un programme qui lit le clavier, ni être interrompue par `Ctrl-C`.

Prenez `editor` quand la sortie est quelque chose à éplucher — un long `go test -v`, ou un rapport de couverture à parcourir.

## Une commande longue immobilise l'éditeur

Une popup est modale : pendant que `go build` tourne, vous ne pouvez taper nulle part ailleurs. `Échap` la ferme et arrête la commande.

Si cela gêne pour une commande précise, donnez-lui `output = "terminal"` — la fenêtre est ordinaire et vous continuez à travailler à côté. C'est précisément l'intérêt d'avoir rendu la clé configurable.

## Ce qui arrive à vos fichiers ouverts

`Format` réécrit les fichiers sur le disque — y compris celui que vous regardez. À la fin d'une commande, l'éditeur **relit tout fichier ouvert n'ayant aucune modification non enregistrée** : la version formatée apparaît sans que vous ayez rien à faire. La barre d'état dit combien.

Un fichier ayant des modifications non enregistrées est **laissé tel quel**, et la barre d'état le dit aussi :

```
Reloaded 2 files; 1 file with unsaved changes left alone
```

C'est délibéré : votre modification et le formateur sont réellement en désaccord, et l'éditeur n'est pas celui qui doit trancher. Enregistrez d'abord (`F2`) puis relancez la commande, ou continuez à éditer et formatez plus tard.

## Ajouter vos propres commandes

Éditez `.turbo-python/tools.toml`. Une commande passe par `sh -c`, donc une seule entrée peut être toute une séquence :

```toml
[[tool]]
name = "~C~heck"
command = "uv run ruff format . && uv run ruff check . && uv run pytest"
output = "popup"

[[tool]]
name = "~M~ettre à jour"
command = "uv lock --upgrade"
output = "popup"

[[tool]]
name = "Cover~a~ge"
command = "uv run pytest --cov --cov-report=term-missing"
output = "editor"
```

Donnez à chacune une touche d'accès avec des tildes, et gardez-les distinctes — le menu répond à la première correspondance trouvée.

## Mettre un outil dans un menu à lui

Un outil qui n'a rien à voir avec Python n'a rien à faire dans le menu Python. Donnez-lui un `menu` :

```toml
[[tool]]
name = "~E~cho"
command = "echo TADA"
output = "terminal"
menu = "Tools"

[[tool]]
name = "~U~p"
command = "docker compose up -d"
menu = "Docker"

[[tool]]
name = "~D~own"
command = "docker compose down"
menu = "Docker"
```

Vous obtenez un menu **Tools** et un menu **Docker** sur la barre, entre Python et Help, dans l'ordre où les noms apparaissent pour la première fois dans le fichier. Docker contient ses deux outils. Rien à redémarrer : enregistrez le fichier et la barre suit.

Le nom vous appartient — il n'y a pas de liste où piocher. Omettez `menu` et l'outil reste dans Python, où sont les cinq commandes de départ.

### La touche d'accès est choisie pour vous

Vous ne pouvez pas savoir, en écrivant le fichier, quelles lettres les menus de l'éditeur occupent déjà. Il s'en charge : la première lettre du nom que rien d'autre ne revendique reçoit les tildes.

`Tools` obtient `Alt-T`, parce que `T` est libre. Un menu nommé `Format` obtiendrait `Alt-A`, parce que `F` est à File, `o` à Options et `r` à Run.

Écrivez les tildes vous-même — `menu = "Doc~k~er"` — et une lettre libre est conservée. Une lettre prise ne l'est pas : la barre répond au *premier* menu correspondant à une touche, donc honorer votre choix rendrait l'un des deux menus inatteignable. Elle en choisit une autre, sans rien dire.

## Variantes

- **Vous préférez `black` et `flake8` à `ruff`.** Changez les commandes `Format` et `Lint`. `ruff` est le défaut parce qu'il fait les deux métiers à lui seul et qu'`uv run` va le chercher tout seul ; tout autre choix tient également en une ligne.
- **Vous avez lancé l'éditeur depuis un sous-dossier.** Les commandes s'y exécutent, donc `ruff check .` ne couvre que ce sous-arbre — et `uv` y cherche aussi le `pyproject.toml`. Lancez depuis la racine du projet.
- **Le fichier contient une erreur.** Le menu affiche un `Cannot read tools` grisé à la place des commandes, et **Create tools file** reste là.
- **Une commande n'est pas installée.** La popup affiche `command not found` et `— exit 127`, ce qu'un shell aurait dit.
- **Vous voulez un menu portant le nom d'un menu existant.** `menu = "File"` vous donne un second menu File, plus loin sur la barre, avec une autre touche d'accès. Rien ne l'empêche ; rien ne le recommande non plus.
- **Votre menu n'a pas de touche d'accès.** Toutes les lettres de son nom étaient déjà prises. `F10` et les flèches y accèdent, la souris aussi. Renommez-le avec une lettre libre.
- **Vous avez mal orthographié la valeur d'`output`.** Tout le fichier est refusé et le menu affiche `Cannot read tools`, en nommant l'outil et en listant les valeurs possibles. Un repli silencieux aurait envoyé la sortie ailleurs que là où vous l'aviez demandée.

## Demander une valeur au lancement

Certaines commandes ont besoin de quelque chose de saisi à chaque fois : un chemin de module, un nom de projet, un test à filtrer. Mettez un `{{libellé}}` à l'endroit où la valeur va :

```toml
[[tool]]
name = "~I~nit module"
command = "uv init --app {{nom du projet}}"
output = "popup"
```

Choisir cette entrée ouvre une boîte intitulée **Init module** avec un champ, libellé `module path`. Tapez la valeur et appuyez sur Entrée ; la commande se lance avec. Échap, et rien ne se lance.

La valeur est protégée, si bien qu'un chemin contenant une espace reste un seul argument.

### Plusieurs valeurs à la fois

Un champ chacune, dans l'ordre où elles apparaissent :

```toml
[[tool]]
name = "~C~opy"
command = "cp {{from}} {{to}}"
```

**Tab** passe d'un champ à l'autre, **Entrée** lance.

### Un champ valant plusieurs arguments

La protection est le mauvais choix quand on veut dire « ajoute ces options à la fin ». Ajoutez `...` à l'intérieur des accolades et la valeur passe telle quelle :

```toml
[[tool]]
name = "Test ~o~ne"
command = "uv run pytest {{extra flags...}}"
```

Tapez `--release parse` et le tout atteint la commande sous forme d'arguments séparés.

### La même valeur deux fois

Écrivez le libellé deux fois ; on ne vous le demande qu'une :

```toml
[[tool]]
name = "~N~ew directory"
command = "mkdir {{name}} && cd {{name}}"
```

### Variantes

- **La valeur est souvent la même.** Lancez-le une fois et la boîte retient ce que vous avez tapé, pour le reste de la session. Rien n'est écrit sur le disque.
- **Votre commande contient déjà des accolades.** `awk '{print $1}'` et `find . -exec rm {} +` sont laissés tranquilles : seules les doubles accolades demandent quelque chose.
- **La commande demande plus de valeurs que l'écran n'en contient.** L'éditeur le dit plutôt que d'ouvrir une boîte dont le bouton OK est sous le bas du terminal. Agrandissez le terminal, ou coupez la commande en deux outils.

## Voir aussi

- Toutes les clés du fichier et toutes les règles : [Référence des outils go](../reference/python-tools.md)
- Pourquoi chaque commande a sa fenêtre terminal, et pourquoi un fichier non modifié se recharge : [Outils Python](../explanation/python-tools.md)
- Les fenêtres dans lesquelles les commandes tournent : [Fenêtres terminal](../reference/terminal.md)