Définir des commandes personnalisées pour les projets Python dans Visual Studio

Article
04/23/2024

Au fur et à mesure que vous développez vos projets Python, vous pouvez être amené à basculer vers une fenêtre de commande pour exécuter des scripts ou des modules spécifiques, lancer des commandes pip ou utiliser d’autres outils avec votre code. Pour améliorer votre flux de travail, vous pouvez ajouter des commandes personnalisées au menu du projet Python dans Visual Studio. Ces commandes Python personnalisées peuvent s’exécuter dans une fenêtre de console ou dans la fenêtre Sortie de Visual Studio. Vous pouvez également utiliser des expressions régulières pour que Visual Studio sache comment analyser les erreurs et les avertissements de la sortie de la commande.

Prérequis

Visual Studio sur Windows installé avec le support pour les charges de travail Python. Pour plus d’informations, veuillez consulter la rubrique Installer le support Python dans Visual Studio.

Visual Studio pour Mac n'est pas pris en charge. Pour plus d’informations, veuillez consulter la rubrique Qu’advient-il de Visual Studio pour Mac ? Visual Studio Code sur Windows, Mac et Linux fonctionne bien avec Python grâce aux extensions disponibles.

Explorer les commandes personnalisées

Par défaut, le menu du projet Python contient deux commandes, Exécuter PyLint et Exécuter Mypy :

Toutes les commandes Python personnalisées que vous définissez apparaissent dans ce même menu. Une commande personnalisée peut faire référence à un fichier Python, un module Python, du code Python inline, un exécutable arbitraire ou une commande pip. Vous pouvez également spécifier comment et où la commande s’exécute.

Vous pouvez ajouter des commandes personnalisées de plusieurs façons :

Définissez des commandes personnalisées dans un fichier projet Python (.pyproj) directement. Ces commandes s’appliquent à ce projet spécifique.
Définissez des commandes personnalisées dans un fichier cible (.targets). Vous pouvez facilement importer les commandes dans ce fichier pour les utiliser avec des projets multiples.
Créez un projet Python à partir d’un modèle de projet dans Visual Studio qui définit des commandes Python personnalisées.

Certains modèles de projet Python dans Visual Studio ajoutent des commandes personnalisées en utilisant un fichier cible. Les modèles Projet Web Bottle et Projet Web Flask ajoutent deux commandes : Démarrer le serveur et Démarrer le serveur de débogage. Le modèle de projet Web Django ajoute les commandes suivantes ainsi que plusieurs autres :

Recharger le projet pour accéder aux commandes personnalisées

Lorsqu’un projet est ouvert dans Visual Studio, si vous apportez des modifications au fichier projet correspondant dans un éditeur, vous devrez recharger le projet pour appliquer les modifications. De la même manière, après avoir défini des commandes Python personnalisées dans un fichier projet Python, vous devez recharger le projet Python pour que les commandes apparaissent dans le menu du projet Python. Lorsque vous modifiez des commandes personnalisées définies dans un fichier cible, vous devez reconstruire la solution Visual Studio complète pour tout projet qui importe ce fichier.

Une approche courante consiste à apporter les modifications au fichier projet Python directement dans Visual Studio :

Ouvrez votre projet Python dans Visual Studio. (Lorsque vous ouvrez un projet dans Visual Studio, le projet est chargé par défaut.)
Dans l’Explorateur de solutions, faites un clic droit sur le projet Python, et sélectionnez Décharger le projet.

Visual Studio décharge le projet et ouvre le fichier projet Python correspondant (.pyproj) dans l’éditeur.

Si le fichier projet ne s’ouvre pas, faites un nouveau clic droit sur le projet Python, puis sélectionnez Modifier le fichier projet :
Apportez vos modifications au fichier projet dans l’éditeur Visual Studio et enregistrez votre travail.
Dans l’Explorateur de solutions, faites un clic droit sur le projet déchargé et choisissez Recharger le projet. Si vous essayez de recharger le projet sans enregistrer vos modifications dans le fichier projet, Visual Studio vous invitera à effectuer cette action.

Le processus décharger-modifier-enregistrer-recharger peut devenir fastidieux lorsque vous développez des commandes personnalisées. Un flux de travail plus efficace implique le chargement simultané du projet dans Visual Studio et l’ouverture du fichier projet Python dans un éditeur distinct. Vous pouvez utiliser n’importe quel éditeur, tel qu’une autre instance de Visual Studio, Visual Studio Code, Bloc-notes Windows, etc. Une fois que vous avez enregistré vos modifications dans l’éditeur et que vous revenez à Visual Studio, Visual Studio détecte les modifications apportées au fichier projet ouvert et vous invite à prendre des mesures :

Sélectionnez Recharger ou Tout recharger et Visual Studio appliquera immédiatement les modifications apportées au fichier projet ouvert.

Ajouter des commandes personnalisées avec un fichier projet

La procédure suivante montre comment créer une commande personnalisée en ajoutant la définition dans le fichier projet Python (.pyproj) et en rechargeant votre projet dans Visual Studio. La commande personnalisée exécute directement le fichier de démarrage d’un projet à l’aide de la commande python.exe, qui est essentiellement identique à l’utilisation de l’option Déboguer>Démarrer sans débogage dans la barre d’outils principale de Visual Studio.

Dans Visual Studio, créez un nouveau projet Python nommé Python-CustomCommands en utilisant le modèle d’application Python. Pour obtenir des instructions, consultez la section Démarrage rapide : Créer un projet Python à partir d’un modèle.

Visual Studio crée le projet Python et le charge dans votre session. Vous pouvez configurer le projet via le fichier projet (.pyproj). Ce fichier est visible uniquement dans Visual Studio lorsque le projet est ouvert, mais déchargé. Le projet dispose également d’un fichier Python (.py) pour le code de l’application.
Ouvrez le fichier d’application Python_CustomCommands.py dans l’éditeur et ajoutez le code suivant :
```
print("Hello custom commands")
```
Dans Explorateur de solutions, faites un clic droit sur le projet Python, sélectionnez Python, puis notez les commandes dans le menu contextuel. Actuellement, les seules commandes du menu contextuel sont Exécuter PyLint et Exécuter Mypy. Lorsque vous définissez des commandes personnalisées, elles apparaissent également dans ce menu.
Lancez un éditeur distinct en dehors de votre session Visual Studio et ouvrez le fichier projet Python (Python-CustomCommands.pyproj) dans l’éditeur. (Veillez à ouvrir le fichier projet (.pyproj) et non le fichier d’application Python (.py).)
Dans le fichier projet, recherchez l’élément fermant </Project> à la fin du fichier et ajoutez le code XML suivant immédiatement avant l’élément fermant :
```
<PropertyGroup>
  <PythonCommands>
    $(PythonCommands);
  </PythonCommands>
</PropertyGroup>
```
Enregistrez les modifications apportées au fichier projet et revenez à Visual Studio. Visual Studio détecte les modifications de votre fichier projet et vous invite à prendre des mesures. À l’invite, sélectionnez Recharger pour mettre à jour votre projet ouvert avec les modifications apportées au fichier projet.
Dans Explorateur de solutions, faites un clic droit sur le projet Python, sélectionnez Python, puis vérifiez les commandes dans le menu contextuel.

Le menu contextuel affiche toujours uniquement les commandes Exécuter PyLint et Exécuter Mypy. Le code que vous venez d’ajouter au fichier projet réplique simplement le groupe de propriétés <PythonCommands> par défaut qui contient la commande PyLint. À l’étape suivante, vous pourrez ajouter du code pour la commande personnalisée.
Basculez vers l’éditeur dans lequel vous mettez à jour le fichier projet. Ajoutez la définition d’élément <Target> suivante dans l’élément <Project>. Vous pouvez positionner la définition <Target> avant ou après la définition <PropertyGroup> décrite précédemment.

Cet élément <Target> définit une commande personnalisée pour exécuter le fichier de démarrage du projet (identifié par la propriété StartupFile) à l’aide de la commande python.exe dans une fenêtre de console. La définition d’attribut ExecuteIn="consolepause" utilise une console qui attend que vous sélectionniez une clé pour fermer la fenêtre de la console.
```
<Target Name="Example_RunStartupFile" Label="Run startup file" Returns="@(Commands)">
  <CreatePythonCommandItem
    TargetType="script"
    Target="$(StartupFile)"
    Arguments=""
    WorkingDirectory="$(MSBuildProjectDirectory)"
    ExecuteIn="consolepause">
    <Output TaskParameter="Command" ItemName="Commands" />
  </CreatePythonCommandItem>
</Target>
```
Remplacez le groupe de propriétés <PythonCommands> (ajouté à l’étape 5) par le code XML suivant. Cette syntaxe définit l’attribut Name de l’élément <Target>, qui ajoute la commande personnalisée au menu contextuel Python. La commande possède l’étiquette de menu Exécuter le fichier de démarrage.
```
  <PythonCommands>
    $(PythonCommands);
    Example_RunStartupFile
  </PythonCommands>
```
Conseil

Si vous souhaitez que votre commande personnalisée apparaisse dans le menu contextuel avant les commandes par défaut définies dans le jeton $(PythonCommands), positionnez la syntaxe <Target> de votre commande avant ce jeton.
Enregistrez les modifications apportées au fichier projet et revenez à Visual Studio. À l’invite, rechargez votre projet.
Dans Explorateur de solutions, faites un clic droit sur le projet Python, sélectionnez Python, puis revérifiez les commandes dans le menu contextuel.

À présent, la commande personnalisée Exécuter le fichier de démarrage se trouve dans le menu. Si vous ne voyez pas la commande personnalisée, confirmez que vous avez ajouté la valeur d’attribut Name de l’élément <Target> à l’élément <PythonCommands> comme décrit à l’étape 9. Passez également en revue les considérations répertoriées dans la section Dépannage plus loin dans cet article.
Sélectionnez la commande Exécuter le fichier de démarrage. Une fenêtre de console s’ouvre et affiche le texte Hello commandes personnalisées suivi de Appuyez sur n’importe quelle touche pour continuer. Confirmez la sortie et fermez la fenêtre de console.

Remarque

Le script de commande personnalisé s’exécute dans l’environnement activé pour votre projet Python.
Passez à l’éditeur contenant le fichier de projet. Dans la définition de l’élément <Target> (ajoutée à l’étape 8), remplacez la valeur d’attribut ExecuteIn par output.
```
  <CreatePythonCommandItem
    ...
    ExecuteIn="output">
    ...
  </CreatePythonCommandItem>
```
Enregistrez vos modifications, revenez à Visual Studio et rechargez votre projet.
Sélectionnez à nouveau la commande personnalisée Exécuter le fichier de démarrage dans le menu contextuel Python. À présent, la sortie du programme apparaît dans la fenêtre Sortie de Visual Studio plutôt que dans une fenêtre de console :
Pour ajouter d’autres commandes personnalisées, suivez ce même processus :
1. Définissez un élément <Target> approprié pour la commande personnalisée dans le fichier projet.
2. Ajoutez la valeur d’attribut Name de l’élément <Target> dans le groupe de propriétés <PythonCommands>.
3. Enregistrez les modifications apportées au fichier projet.
4. Rechargez votre projet dans Visual Studio.

Utiliser les propriétés du projet

Pour faire référence aux propriétés du projet ou aux variables d’environnement dans les valeurs d’attribut d’élément <Target>, utilisez le nom de la propriété au sein d’un jeton $(), tel que $(StartupFile) et $(MSBuildProjectDirectory). Pour plus d’informations, consultez Propriétés MSBuild.

Si vous appelez une commande ($StartupFile) qui utilise des propriétés de projet telles que la propriété StartupFile et que la commande échoue parce que le jeton n’est pas défini, Visual Studio désactive la commande jusqu’à ce que vous rechargiez le projet. Si vous apportez des modifications au projet qui modifient la définition de propriété, vos modifications n’actualiseront pas l’état de la commande associée. Dans ce cas, vous devez toujours recharger le projet.

Comprendre la structure d’élément <Target>

Vous définissez les détails d’une commande personnalisée à l’aide de l’élément <Target>. La forme générale de l’élément <Target> est indiquée dans le pseudo-code suivant :

<Target Name="Name1" Label="Display Name" Returns="@(Commands)">
    <CreatePythonCommandItem Target="filename, module name, or code"
        TargetType="executable/script/module/code/pip"
        Arguments="..."
        ExecuteIn="console/consolepause/output/repl[:Display name]/none"
        WorkingDirectory="..."
        ErrorRegex="..."
        WarningRegex="..."
        RequiredPackages="...;..."
        Environment="...">

      <!-- Output always appears in this form, with these exact attributes -->
      <Output TaskParameter="Command" ItemName="Commands" />
    </CreatePythonCommandItem>
  </Target>

Attributs Target

Le tableau suivant répertorie les attributs de l’élément <Target>.

Attribut	Obligatoire	Description
`Name`	Oui	Identificateur de la commande dans le projet Visual Studio. Ce nom doit être ajouté au groupe de propriétés `<PythonCommands>` pour que la commande apparaisse dans le menu contextuel Python.
`Label`	Oui	Le nom complet de l’IU qui apparaît dans le menu contextuel Python.
`Returns`	Oui	Les informations retournées, qui doivent contenir le jeton `@(Commands)`, qui identifie la cible en tant que commande.

Attributs CreatePythonCommandItem

L’élément <Target> contient des éléments <CreatePythonCommandItem> et <Output>. Ces derniers définissent le comportement détaillé de la commande personnalisée. Le tableau suivant répertorie les attributs de l’élément <CreatePythonCommandItem> disponibles. Toutes les valeurs d’attribut sont insensibles à la casse.

`Attribute`	Requis	Description
`TargetType`	Oui	Spécifie ce que l’attribut `Target` contient et comment la valeur est utilisée avec l’attribut `Arguments` : - `executable` : Exécutez l’exécutable nommé dans l’attribut `Target`, en ajoutant la valeur de l’attribut `Arguments`, comme s’il était saisi directement sur la ligne de commande. La valeur doit contenir uniquement un nom de programme sans arguments. - `script` : Exécutez la commande `python.exe` avec le nom de fichier dans l’attribut `Target`, suivie de la valeur d’attribut `Arguments`. - `module` : Exécutez la commande `python -m` suivie du nom du module dans l’attribut `Target`, suivie de la valeur d’attribut `Arguments`. - `code` : Exécutez le code inline contenu dans l’attribut `Target`. Ignorez la valeur d’attribut `Arguments`. - `pip` : Exécutez pip avec la commande dans l’attribut `Target`, suivie de la valeur dans l’attribut `Arguments`. Si l’attribut `ExecuteIn` est défini sur `output`, pip part du principe que la requête doit exécuter la commande `install` et utilise l’attribut `Target` comme nom de package.
`Target`	Oui	Spécifie le nom de fichier, le nom du module, le code ou la commande pip à utiliser, en fonction de la valeur d’attribut `TargetType`.
`Arguments`	Facultatif	Fournit une chaîne d’arguments (le cas échéant) à utiliser avec l’attribut `Target`. – Lorsque la valeur d’attribut `TargetType` est `script`, la valeur `Arguments` est fournie au programme Python plutôt qu’à la commande `python.exe`. – Lorsque la valeur d’attribut `TargetType` est `code`, la valeur `Arguments` est ignorée.
`ExecuteIn`	Oui	Spécifie l’environnement dans lequel exécuter la commande : - `console` : (Valeur par défaut) Exécute l’attribut `Target` avec la valeur `Arguments` comme s’ils étaient saisis directement sur la ligne de commande. Pendant l’exécution de l’attribut `Target`, une fenêtre de commande apparaît et se ferme automatiquement. - `consolepause` : Même comportement que `console`, mais attend l’appui sur une touche avant de fermer la fenêtre. - `output` : Exécute l’attribut `Target` et affiche les résultats dans la fenêtre Sortie de Visual Studio. Si l’attribut `TargetType` est `pip`, Visual Studio utilise l’attribut `Target` comme nom de package et ajoute la valeur d’attribut `Arguments`. - `repl` : Exécute l’attribut `Target` dans la fenêtre interactive Python. Le nom complet facultatif est utilisé pour le titre de la fenêtre. - `none` : Même comportement que `console`.
`WorkingDirectory`	Facultatif	Identifie le dossier dans lequel la commande doit être exécutée.
`ErrorRegex` `WarningRegEx`	Facultatif	Utilisé uniquement lorsque l’attribut `ExecuteIn` est défini sur `output`. Les deux valeurs d’attribut spécifient une expression régulière que Visual Studio utilise pour analyser la sortie de la commande et afficher les erreurs et les avertissements dans la fenêtre Liste d’erreurs. Si ces attributs ne sont pas spécifiés, la commande n’affecte pas la fenêtre Liste d’erreurs. Pour plus d’informations sur ce que Visual Studio attend, consultez Groupes de capture nommés.
`RequiredPackages`	Facultatif	Fournit une liste de spécifications de package pour la commande en utilisant le même format que le fichier requirements.txt (pip.readthedocs.io). Par exemple, la commande Exécuter PyLint spécifie le format `pylint>=1.0.0`. Avant d’exécuter la commande, Visual Studio confirme que tous les packages de la liste sont installés. Visual Studio utilise pip pour installer les packages manquants.
`Environment`	Facultatif	Identifie une chaîne de variables d’environnement à définir avant d’exécuter la commande. Chaque variable utilise la forme `\<NAME>=\<VALUE>` avec plusieurs variables séparées par des points-virgules. Une variable contenant plusieurs valeurs doit être mise entre guillemets simples ou doubles. Par exemple : `'NAME=VALUE1;VALUE2'`.

Groupes de capture nommés pour les expressions régulières

Lorsque Visual Studio analyse les erreurs et les avertissements de la sortie d’une commande personnalisée, il s’attend à ce que les expressions régulières dans les valeurs d’attribut ErrorRegex et WarningRegex utilisent les groupes nommés suivants :

(?<message>...) :Texte de l’erreur.
(?<code>...) : Valeur du code d’erreur.
(?<filename>...) : Nom du fichier pour lequel l’erreur est signalée.
(?<line>...) : Numéro de ligne de l’emplacement où l’erreur a été signalée dans le fichier.
(?<column>...) : Numéro de colonne de l’emplacement où l’erreur a été signalée dans le fichier.

Par exemple, PyLint produit des avertissements semblables à ce qui suit :

************* Module hello
C:  1, 0: Missing module docstring (missing-docstring)

Pour permettre à Visual Studio d’extraire les bonnes informations à partir de ces avertissements et de les afficher dans la fenêtre Liste d’erreurs, la valeur d’attribut WarningRegex pour la commande Exécuter Pylint est la suivante :

^(?<filename>.+?)\((?<line>\d+),(?<column>\d+)\): warning (?<msg_id>.+?): (?<message>.+?)$]]

Remarque

La syntaxe msg_id de la valeur d’attribut WarningRegex doit être en fait code, comme décrit dans le problème 3680.

Importer des commandes personnalisées avec un fichier de cibles

Si vous définissez des commandes personnalisées dans un fichier projet Python, les commandes sont disponibles uniquement pour ce projet spécifique. Si vous souhaitez créer des commandes personnalisées et les utiliser dans plusieurs projets, vous pouvez définir le groupe de propriétés <PythonCommands> avec tous vos éléments <Target> dans un fichier cible (.targets), puis importer ce fichier dans vos projets Python.

Le fichier cible utilise le même format et la même syntaxe pour définir des commandes personnalisées comme décrit pour le fichier projet Python (.pyproj). Les éléments communs à configurer incluent <PythonCommands>, <Target>, <CreatePythonCommandItem> et <Output> :

<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <PropertyGroup>
     <PythonCommands>
       $(PythonCommands);
       <!-- Additional command names -->
     </PythonCommands>
   </PropertyGroup>

   <Target Name="..." Label="..." Returns="@(Commands)">
     <!-- CreatePythonCommandItem and Output elements... -->
   </Target>

   <!-- Any number of additional Target elements-->
</Project>

Pour importer un fichier cible dans votre projet, ajoutez un élément <Import Project="(path)"> n’importe où dans l’élément <Project> de votre fichier projet.

Par exemple, si vous avez un fichier de projet nommé CustomCommands.targets dans un dossier targets de votre projet Python, ajoutez le code suivant à votre fichier de projet :
```
<Import Project="targets/CustomCommands.targets"/>
```
Si votre fichier projet importe un fichier de cibles et que vous apportez des modifications au fichier de cibles pendant que votre projet est ouvert dans Visual Studio, vous devrez non seulement reconstruire votre projet, mais aussi la solution Visual Studio qui contient votre projet.

Exemple de commandes

Les sections suivantes fournissent un exemple de code que vous pouvez utiliser pour définir des commandes personnalisées pour vos projets Python.

Exécuter PyLint (cible de module)

Le code suivant s’affiche dans le fichier Microsoft.PythonTools.targets :

<PropertyGroup>
  <PythonCommands>$(PythonCommands);PythonRunPyLintCommand</PythonCommands>
  <PyLintWarningRegex>
    <![CDATA[^(?<filename>.+?)\((?<line>\d+),(?<column>\d+)\): warning (?<msg_id>.+?): (?<message>.+?)$]]>
  </PyLintWarningRegex>
</PropertyGroup>

<Target Name="PythonRunPyLintCommand"
        Label="resource:Microsoft.PythonTools.Common;Microsoft.PythonTools.Common.Strings;RunPyLintLabel"
        Returns="@(Commands)">
  <CreatePythonCommandItem Target="pylint.lint"
                           TargetType="module"
                           Arguments="&quot;--msg-template={abspath}({line},{column}): warning {msg_id}: {msg} [{C}:{symbol}]&quot; -r n @(Compile, ' ')"
                           WorkingDirectory="$(MSBuildProjectDirectory)"
                           ExecuteIn="output"
                           RequiredPackages="pylint&gt;=1.0.0"
                           WarningRegex="$(PyLintWarningRegex)">
    <Output TaskParameter="Command" ItemName="Commands" />
  </CreatePythonCommandItem>
</Target>

Exécuter pip install avec un package spécifique (cible pip)

La commande suivante exécute la commande pip install my-package dans la fenêtre Sortie de Visual Studio. Vous pouvez utiliser une commande de ce type lorsque vous développez un package et que vous en testez l’installation. L’élément <Target> contient le nom du package et non la commande install, qui est prise en compte lorsque vous utilisez la définition d’attribut ExecuteIn="output".

<PropertyGroup>
  <PythonCommands>$(PythonCommands);InstallMyPackage</PythonCommands>
</PropertyGroup>

<Target Name="InstallMyPackage" Label="pip install my-package" Returns="@(Commands)">
  <CreatePythonCommandItem Target="my-package" TargetType="pip" Arguments=""
    WorkingDirectory="$(MSBuildProjectDirectory)" ExecuteIn="output">
    <Output TaskParameter="Command" ItemName="Commands" />
  </CreatePythonCommandItem>
</Target>

Afficher les packages pip obsolètes (cible pip)

La commande suivante exécute pip avec la fonction list pour identifier les packages pip obsolètes :

<PropertyGroup>
  <PythonCommands>$(PythonCommands);ShowOutdatedPackages</PythonCommands>
</PropertyGroup>

<Target Name="ShowOutdatedPackages" Label="Show outdated pip packages" Returns="@(Commands)">
  <CreatePythonCommandItem Target="list" TargetType="pip" Arguments="-o --format columns"
    WorkingDirectory="$(MSBuildProjectDirectory)" ExecuteIn="consolepause">
    <Output TaskParameter="Command" ItemName="Commands" />
  </CreatePythonCommandItem>
</Target>

Exécuter un exécutable avec consolepause

La commande suivante exécute la fonction where permettant d’afficher l’emplacement des fichiers Python à partir du dossier du projet :

<PropertyGroup>
  <PythonCommands>$(PythonCommands);ShowAllPythonFilesInProject</PythonCommands>
</PropertyGroup>

<Target Name="ShowAllPythonFilesInProject" Label="Show Python files in project" Returns="@(Commands)">
  <CreatePythonCommandItem Target="where" TargetType="executable" Arguments="/r . *.py"
    WorkingDirectory="$(MSBuildProjectDirectory)" ExecuteIn="output">
    <Output TaskParameter="Command" ItemName="Commands" />
  </CreatePythonCommandItem>
</Target>

Commandes Exécuter le serveur et Exécuter le serveur de débogage

Pour explorer comment les commandes Démarrer le serveur et Démarrer le serveur de débogage sont définies pour les projets Web, consultez le dépôt Microsoft.PythonTools.Web.targets sur GitHub.

Installer un package pour le développement

Le code suivant exécute pip pour installer les packages :

<PropertyGroup>
  <PythonCommands>PipInstallDevCommand;$(PythonCommands);</PythonCommands>
</PropertyGroup>

<Target Name="PipInstallDevCommand" Label="Install package for development" Returns="@(Commands)">
    <CreatePythonCommandItem Target="pip" TargetType="module" Arguments="install --editable $(ProjectDir)"
        WorkingDirectory="$(WorkingDirectory)" ExecuteIn="Repl:Install package for development">
      <Output TaskParameter="Command" ItemName="Commands" />
    </CreatePythonCommandItem>
  </Target>

À partir de fxthomas/Example.pyproj.xml (GitHub), utilisé avec autorisation.

Générer le programme d’installation Windows

Le script suivant génère un programme d’installation Windows :

<PropertyGroup>
  <PythonCommands>$(PythonCommands);BdistWinInstCommand;</PythonCommands>
</PropertyGroup>

<Target Name="BdistWinInstCommand" Label="Generate Windows Installer" Returns="@(Commands)">
    <CreatePythonCommandItem Target="$(ProjectDir)setup.py" TargetType="script"
        Arguments="bdist_wininst --user-access-control=force --title &quot;$(InstallerTitle)&quot; --dist-dir=&quot;$(DistributionOutputDir)&quot;"
        WorkingDirectory="$(WorkingDirectory)" RequiredPackages="setuptools"
        ExecuteIn="Repl:Generate Windows Installer">
      <Output TaskParameter="Command" ItemName="Commands" />
    </CreatePythonCommandItem>
  </Target>

À partir de fxthomas/Example.pyproj.xml (GitHub), utilisé avec autorisation.

Générer un paquet wheel Python

Le script suivant génère un paquet wheel Python :

<PropertyGroup>
  <PythonCommands>$(PythonCommands);BdistWheelCommand;</PythonCommands>
</PropertyGroup>

<Target Name="BdistWheelCommand" Label="Generate Wheel Package" Returns="@(Commands)">

  <CreatePythonCommandItem Target="$(ProjectDir)setup.py" TargetType="script"
      Arguments="bdist_wheel --dist-dir=&quot;$(DistributionOutputDir)&quot;"
      WorkingDirectory="$(WorkingDirectory)" RequiredPackages="wheel;setuptools"
      ExecuteIn="Repl:Generate Wheel Package">
    <Output TaskParameter="Command" ItemName="Commands" />
  </CreatePythonCommandItem>
</Target>

À partir de fxthomas/Example.pyproj.xml (GitHub), utilisé avec autorisation.

Dépannage des commandes personnalisées

Passez en revue les sections suivantes pour connaître les problèmes possibles liés à l’utilisation de commandes personnalisées.

Fichier de projet non chargé

Ce message d’erreur indique que le fichier du projet contient des erreurs de syntaxe. Le message inclut l’erreur spécifique avec un numéro de ligne et la position du caractère.

La fenêtre de la console se ferme après l’exécution de la commande

Si la fenêtre de console se ferme immédiatement après l’exécution de la commande, utilisez la définition d’attribut ExecuteIn="consolepause" au lieu de ExecuteIn="console".

Si vous ne voyez pas la commande personnalisée dans le menu contextuel Python, vérifiez les éléments suivants :

Vérifiez que la commande est incluse dans le groupe de propriétés <PythonCommands>.
Vérifiez que le nom de la commande tel que défini par la liste de commandes correspond au nom spécifié dans l’élément <Target>.

Voici un exemple. Dans l’extrait de code XML suivant, le nom Example du groupe de propriétés <PythonCommands> ne correspond pas au nom ExampleCommand dans la définition d’élément <Target>. Visual Studio ne trouvant pas de commande nommée Example, aucune commande n’apparaît. Vous pouvez soit utiliser ExampleCommand dans la liste des commandes, soit changer le nom de la cible pour qu’elle soit uniquement Example.

  <PropertyGroup>
    <PythonCommands>$(PythonCommands);Example</PythonCommands>
  </PropertyGroup>
  <Target Name="ExampleCommand" Label="Example Command" Returns="@(Commands)">
    <!-- ... -->
  </Target>

Erreur lors de l’exécution de la commande, échec de l’obtention de la cible de commande

Ce message d’erreur indique que le contenu des éléments <Target> ou <CreatePythonCommandItem> est incorrect.

Les raisons possibles de ce problème sont les suivantes :

L’attribut d’élément <Target> requis est vide.
L’attribut TargetType exigé est vide ou contient une valeur non reconnue.
L’attribut ExecuteIn exigé est vide ou contient une valeur non reconnue.
L’attribut ErrorRegex ou WarningRegex est spécifié sans indiquer la définition d’attribut ExecuteIn="output".
Des attributs non reconnus existent dans l’élément. Par exemple, la référence d’attribut peut être mal orthographiée en Argumnets plutôt que Arguments.

Les valeurs d’attribut peuvent être vides si vous faites référence à une propriété qui n’est pas définie. Si vous utilisez le jeton $(StartupFile) mais qu’aucun fichier de démarrage n’a été défini dans le projet, le jeton est résolu en chaîne vide. Dans ce cas, vous souhaiterez sans doute définir la valeur par défaut. Par exemple, les commandes Exécuter le serveur et Exécuter le serveur de débogage définies dans les modèles de projet Bottle, Flask et Django utilisent le fichier manage.py par défaut (si aucun fichier de démarrage de serveur n’a été spécifié dans les propriétés du projet).

Visual Studio cesse de répondre

Si Visual Studio cesse de répondre et se bloque lorsque vous exécutez la commande personnalisée, vous essayez probablement d’exécuter une commande console avec la définition d’attribut ExecuteIn="output". Dans ce cas, Visual Studio peut se bloquer lorsqu’il tente d’analyser la sortie. Pour éviter cette condition, utilisez plutôt la définition d’attribut ExecuteIn="console". Pour plus d’informations, consultez le problème 3681.

Commande non reconnue comme programme opérable ou fichier de commandes

Lorsque vous indiquez la définition d’attribut TargetType="executable", la valeur d’attribut Target doit être uniquement le nom du programme sans arguments, tels que python ou python.exe uniquement. Dans ce cas, déplacez tous les arguments vers l’attribut Arguments.

Partager via

Définir des commandes personnalisées pour les projets Python dans Visual Studio

Prérequis

Explorer les commandes personnalisées

Recharger le projet pour accéder aux commandes personnalisées

Ajouter des commandes personnalisées avec un fichier projet

Utiliser les propriétés du projet

Comprendre la structure d’élément <Target>

Attributs Target

Attributs CreatePythonCommandItem

Groupes de capture nommés pour les expressions régulières

Importer des commandes personnalisées avec un fichier de cibles

Exemple de commandes

Exécuter PyLint (cible de module)

Exécuter pip install avec un package spécifique (cible pip)

Afficher les packages pip obsolètes (cible pip)

Exécuter un exécutable avec consolepause

Commandes Exécuter le serveur et Exécuter le serveur de débogage

Installer un package pour le développement

Générer le programme d’installation Windows

Générer un paquet wheel Python

Dépannage des commandes personnalisées

Fichier de projet non chargé

La fenêtre de la console se ferme après l’exécution de la commande

Commande manquante dans le menu

Erreur lors de l’exécution de la commande, échec de l’obtention de la cible de commande

Visual Studio cesse de répondre

Commande non reconnue comme programme opérable ou fichier de commandes

Commentaires

Ressources supplémentaires