Definire comandi personalizzati per i progetti Python in Visual Studio

Durante lo sviluppo dei progetti Python, è possibile passare a una finestra di comando per eseguire script o moduli specifici, eseguire comandi pip o usare altri strumenti con il codice. Per migliorare il flusso di lavoro, è possibile aggiungere comandi personalizzati al menu del progetto Python in Visual Studio. I comandi Python personalizzati possono essere eseguiti in una finestra della console o nella finestra Output di Visual Studio. È anche possibile usare espressioni regolari per indicare a Visual Studio come analizzare gli errori e gli avvisi dall'output del comando.

Prerequisiti

• Visual Studio in Windows installato con il supporto per i carichi di lavoro Python. Per altre informazioni, vedere Installare il supporto python in Visual Studio.

Visual Studio per Mac non è supportato. Visual Studio Code in Windows, Mac e Linux funziona bene con Python tramite le estensioni disponibili.

Esplorare i comandi personalizzati

Per impostazione predefinita, il menu del progetto Python contiene due comandi, Esegui PyLint ed Esegui Mypy:

Tutti i comandi Python personalizzati definiti vengono visualizzati nello stesso menu. Un comando personalizzato può fare riferimento a un file Python, a un modulo Python, a codice Python inline, a un eseguibile arbitrario o a un comando pip. È anche possibile specificare come e dove viene eseguito il comando.

È possibile aggiungere comandi personalizzati in diversi modi:

• Definire direttamente i comandi personalizzati in un file di progetto Python (con estensione pyproj). Questi comandi si applicano a tale progetto specifico.

• Definire comandi personalizzati in un file targets (.targets). È possibile importare facilmente i comandi in questo file per usarli con più progetti.

• Creare un progetto Python da un modello di progetto in Visual Studio che definisce comandi Python personalizzati.

  Alcuni modelli di progetto Python in Visual Studio aggiungono comandi personalizzati usando un file di destinazioni. I modelli Progetto Web Bottle e Progetto Web Flask aggiungono due comandi, Avvia server e Avvia server di debug. Il modello Progetto Web Django aggiunge questi comandi e molti altri:

  

Ricaricare il progetto per accedere ai comandi personalizzati

Quando un progetto è aperto in Visual Studio, se si apportano modifiche al file di progetto corrispondente in un editor, è necessario ricaricare il progetto per applicare le modifiche. In modo simile, dopo aver definito comandi Python personalizzati in un file di progetto Python, è necessario ricaricare il progetto Python per visualizzare i comandi nel menu del progetto Python . Quando si modificano i comandi personalizzati definiti in un file di destinazioni, è necessario ricompilare la soluzione completa di Visual Studio per qualsiasi progetto che importa il file di destinazione.

Un approccio comune consiste nell'apportare le modifiche al file di progetto Python direttamente in Visual Studio:

1. Aprire il progetto Python in Visual Studio. Quando si apre un progetto in Visual Studio, il progetto viene caricato per impostazione predefinita.

2. In Esplora soluzioni fare clic con il pulsante destro del mouse sul progetto Python e scegliere Scarica progetto.

   Visual Studio scarica il progetto e apre il file di progetto Python corrispondente (con estensione pyproj) nell'editor.

   Se il file di progetto non viene aperto, fare di nuovo clic con il pulsante destro del mouse sul progetto Python e scegliere Modifica file di progetto:

   

3. Apportare le modifiche al file di progetto nell'editor di Visual Studio e salvare il lavoro.

4. In Esplora soluzioni fare clic con il pulsante destro del mouse sul progetto scaricato e scegliere Ricarica progetto. Se si tenta di ricaricare il progetto senza salvare le modifiche apportate al file di progetto, Visual Studio richiede di completare l'azione.

Il processo di scaricamento-modifica-salva-ricarica può risultare tedioso quando si sviluppano comandi personalizzati. Un flusso di lavoro più efficiente comporta il caricamento simultaneo del progetto in Visual Studio e l'apertura del file di progetto Python in un editor separato. È possibile usare qualsiasi editor, ad esempio un'altra istanza di Visual Studio, Visual Studio Code, Blocco note e così via. Dopo aver salvato le modifiche nell'editor e tornare a Visual Studio, Visual Studio rileva le modifiche apportate al file di progetto per il progetto aperto e richiede di intervenire:

Selezionare Ricarica o Ricarica tutto e Visual Studio applica immediatamente le modifiche apportate al file di progetto al progetto aperto.

Aggiungere comandi personalizzati con il file di progetto

La procedura seguente illustra come creare un comando personalizzato aggiungendo la definizione nel file di progetto Python (con estensione pyproj) e ricaricando il progetto in Visual Studio. Il comando personalizzato avvia direttamente il file di avvio di un progetto utilizzando il comando , che è sostanzialmente lo stesso che utilizzare l'opzione Avvia senza Debug sulla barra degli strumenti principale di Visual Studio.

1. In Visual Studio creare un nuovo progetto Python denominato Python-CustomCommands usando il modello Applicazione Python . Per istruzioni, vedere Avvio rapido: Creare un progetto Python da un modello.

   Visual Studio crea il progetto Python e lo carica nella sessione. È possibile configurare il progetto tramite il file di progetto (con estensione pyproj). Questo file è visibile solo in Visual Studio quando il progetto è aperto, ma non caricato. Il progetto include anche un file Python (.py) per il codice dell'applicazione.

2. Aprire il file dell'applicazione Python_CustomCommands.py nell'editor e aggiungere il codice seguente:

   print("Hello custom commands")
   

3. In Esplora soluzioni fare clic con il pulsante destro del mouse sul progetto Python, scegliere Python e notare i comandi nel menu di scelta rapida. Attualmente, gli unici comandi del menu di scelta rapida sono Esegui PyLint ed Esegui Mypy. Quando si definiscono comandi personalizzati, vengono visualizzati anche in questo menu.

4. Avviare un editor separato all'esterno della sessione di Visual Studio e aprire il file di progetto Python (Python-CustomCommands.pyproj) nell'editor. Assicurarsi di aprire il file di progetto (con estensione pyproj) e non il file dell'applicazione Python (.py).)

5. Nel file di progetto individuare l'elemento di chiusura </Project> alla fine del file e aggiungere il codice XML seguente immediatamente prima dell'elemento di chiusura:

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

6. Salvare le modifiche al file di progetto e tornare a Visual Studio. Visual Studio rileva le modifiche apportate al file di progetto e chiede di intervenire. Al prompt selezionare Ricarica per aggiornare il progetto aperto con le modifiche apportate al file di progetto.

7. In Esplora soluzioni fare clic con il pulsante destro del mouse sul progetto Python, scegliere Python e controllare i comandi nel menu di scelta rapida.

   Il menu di scelta rapida mostra ancora solo i comandi Esegui PyLint ed Esegui Mypy . Il codice appena aggiunto al file di progetto replica semplicemente il gruppo di proprietà predefinito <PythonCommands> che contiene il comando PyLint . Nel passaggio successivo si aggiunge altro codice per il comando personalizzato.

8. Passare all'editor in cui si sta aggiornando il file di progetto. Aggiungere la definizione di elemento seguente <Target> all'interno dell'elemento <Project> . È possibile posizionare la <Target> definizione prima o dopo la <PropertyGroup> definizione descritta in precedenza.

   Questo <Target> elemento definisce un comando personalizzato per eseguire il file di avvio per il progetto (identificato dalla proprietà StartupFile ) usando il python.exe comando in una finestra della console. La definizione ExecuteIn="consolepause" dell'attributo usa una console che attende di selezionare una chiave per chiudere la finestra della 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>
   

9. Sostituire il <PythonCommands> gruppo di proprietà (aggiunto nel passaggio 5) con il codice XML seguente. Questa sintassi definisce l'attributo Name per l'elemento <Target> , che aggiunge il comando personalizzato al menu di scelta rapida python . Il comando ha l'etichetta di menu Esegui file di avvio.

     <PythonCommands>
       $(PythonCommands);
       Example_RunStartupFile
     </PythonCommands>
   

   Suggerimento

   Se si vuole che il comando personalizzato venga visualizzato nel menu di scelta rapida prima dei comandi predefiniti definiti nel $(PythonCommands) token, posizionare la <Target> sintassi per il comando prima di tale token.

10. Salvare le modifiche al file di progetto e tornare a Visual Studio. Al prompt, ricarica il progetto.

11. In Esplora soluzioni fare clic con il pulsante destro del mouse sul progetto Python, scegliere Python e ricontrollare i comandi nel menu di scelta rapida.

    Il comando Esegui file di avvio personalizzato è ora disponibile nel menu. Se il comando personalizzato non viene visualizzato, verificare di aver aggiunto il valore dell'attributo Name per l'elemento <Target> all'elemento <PythonCommands> come descritto nel passaggio 9. Esaminare anche le considerazioni elencate nella sezione Risoluzione dei problemi più avanti in questo articolo.

    

12. Selezionare il comando Esegui file di avvio . Viene visualizzata una finestra della console e viene visualizzato il testo Hello custom commands seguito da Press any key to continue (Premi qualsiasi tasto per continuare). Confermare l'output e chiudere la finestra della console.

    

    Annotazioni

    Lo script di comando personalizzato viene eseguito nell'ambiente attivato per il progetto Python.

13. Passare all'editor con il file di progetto. Nella definizione dell'elemento <Target> (aggiunta nel passaggio 8) modificare il valore dell'attributo ExecuteIn in output.

      <CreatePythonCommandItem
        ...
        ExecuteIn="output">
        ...
      </CreatePythonCommandItem>
    

14. Salvare le modifiche, tornare a Visual Studio e ricaricare il progetto.

15. Selezionare di nuovo il comando Esegui file di avvio personalizzato dal menu di scelta rapida Python. Ora l'output del programma viene visualizzato nella finestra Output di Visual Studio anziché in una finestra della console:

    

16. Per aggiungere altri comandi personalizzati, seguire questo stesso processo:

    1. Definire un elemento appropriato <Target> per il comando personalizzato nel file di progetto.

    2. Aggiungere il valore dell'attributo Name per l'elemento <Target> nel <PythonCommands> gruppo di proprietà.

    3. Salvare le modifiche apportate al file di progetto.

    4. Ricaricare il progetto in Visual Studio.

Usare le proprietà del progetto

Per fare riferimento alle proprietà del progetto o alle variabili di ambiente nei <Target> valori degli attributi degli elementi, usare il nome della proprietà all'interno di un $() token, ad esempio $(StartupFile) e $(MSBuildProjectDirectory). Per altre informazioni, vedere proprietà di MSBuild.

Se si richiama un comando simile ($StartupFile) a quello che usa proprietà di progetto come la proprietà StartupFile e il comando ha esito negativo perché il token non è definito, Visual Studio disabilita il comando finché non si ricarica il progetto. Se si apportano modifiche al progetto che modificano la definizione della proprietà, le modifiche non aggiornano lo stato del comando correlato. In questo caso, è comunque necessario ricaricare il progetto.

Comprendere la struttura dell'elemento <Target>

Per definire i dettagli di un comando personalizzato, usare l'elemento <Target> . La forma generale dell'elemento <Target> è illustrata nello pseudo-codice seguente:

<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>

Attributi di destinazione

Nella tabella seguente sono elencati gli attributi dell'elemento <Target> .

Attribute	Obbligatorio	Description
Name	Yes	Identificatore del comando all'interno del progetto di Visual Studio. Questo nome deve essere aggiunto al <PythonCommands> gruppo di proprietà per visualizzare il comando nel menu contestuale Python.
Label	Yes	Nome visualizzato dell'interfaccia utente che appare nel menu contestuale di Python.
Returns	Yes	Le informazioni restituite devono contenere il token @(Commands), che identifica la destinazione come un comando.

Attributi CreatePythonCommandItem

L'elemento <Target> contiene <CreatePythonCommandItem> elementi e <Output> che definiscono il comportamento dettagliato per il comando personalizzato. Nella tabella seguente sono elencati gli attributi degli elementi disponibili <CreatePythonCommandItem> . Tutti i valori degli attributi sono indipendenti dalle maiuscole e minuscole.

Attribute	Obbligatorio	Description
TargetType	Yes	Specifica il contenuto dell'attributo Target e la modalità di utilizzo del valore insieme all'attributo Arguments : - executable: eseguire l'eseguibile denominato nell'attributo Target , aggiungendo il valore nell'attributo Arguments , come se immesso direttamente nella riga di comando. Il valore deve contenere solo un nome di programma senza argomenti. - script: eseguire il python.exe comando con il nome file nell'attributo Target , seguito dal valore nell'attributo Arguments . - module: eseguire il python -m comando seguito dal nome del modulo nell'attributo Target , seguito dal valore nell'attributo Arguments . - code: eseguire il codice inline contenuto nell'attributo Target . Ignorare il valore dell'attributo Arguments . - pip: eseguire pip con il comando nell'attributo Target , seguito dal valore nell'attributo Arguments . Se l'attributo ExecuteIn è impostato su output, pip presuppone che la richiesta sia eseguire il install comando e usi l'attributo Target come nome del pacchetto.
Target	Yes	Specifica il nome del file, il nome del modulo, il codice o il comando pip da usare, a seconda del valore dell'attributo TargetType .
Arguments	Opzionale	Fornisce una stringa di argomenti (se presenti) da utilizzare con l'attributo Target . - Quando il valore dell'attributo TargetType è script, il Arguments valore viene fornito al programma Python anziché al python.exe comando . - Quando il valore dell'attributo TargetType è code, il Arguments valore viene ignorato.
ExecuteIn	Yes	Specifica l'ambiente in cui eseguire il comando: - console: (Impostazione predefinita) Esegue l'attributo Target con il valore Arguments come se fosse immesso direttamente nella riga di comando. Mentre l'attributo Target è in esecuzione, viene visualizzata e chiusa automaticamente una finestra di comando. - consolepause: lo stesso comportamento di console, ma attende la pressione di un tasto prima di chiudere la finestra. - output: esegue l'attributo Target e visualizza i risultati nella finestra Output di Visual Studio. Se l'attributo TargetType è pip, Visual Studio usa l'attributo Target come nome del pacchetto e aggiunge il valore dell'attributo Arguments . - repl: esegue l'attributo Target nella finestra interattiva di Python. Il nome di visualizzazione opzionale viene usato per il titolo della finestra. - none: stesso comportamento di console.
WorkingDirectory	Opzionale	Identifica la cartella in cui eseguire il comando.
ErrorRegex WarningRegEx	Opzionale	Utilizzato solo quando l'attributo ExecuteIn è impostato su output. Entrambi i valori degli attributi specificano un'espressione regolare usata da Visual Studio per analizzare l'output dei comandi e visualizzare errori e avvisi nella finestra Elenco errori . Se questi attributi non vengono specificati, il comando non influisce sulla finestra Elenco errori . Per altre informazioni sulle aspettative di Visual Studio, vedere Gruppi di acquisizione denominati.
RequiredPackages	Opzionale	Fornisce un elenco dei requisiti del pacchetto per il comando usando lo stesso formato del file requirements.txt (pip.readthedocs.io). Ad esempio, il comando Esegui PyLint specifica il formato pylint>=1.0.0. Prima di eseguire il comando, Visual Studio conferma che tutti i pacchetti nell'elenco sono installati. Visual Studio usa pip per installare eventuali pacchetti mancanti.
Environment	Opzionale	Identifica una stringa di variabili di ambiente da definire prima di eseguire il comando. Ogni variabile usa il form \<NAME>=\<VALUE> con più variabili separate da punto e virgola. Una variabile con più valori deve essere contenuta tra virgolette singole o doppie, come in 'NAME=VALUE1;VALUE2'.

Gruppi di acquisizione denominati per le espressioni regolari

Quando Visual Studio analizza gli errori e gli avvisi dall'output dei comandi personalizzati, prevede che le espressioni regolari nei valori degli ErrorRegex attributi e WarningRegex usino i gruppi denominati seguenti:

• (?<message>...): testo dell'errore.
• (?<code>...): valore del codice di errore.
• (?<filename>...): nome del file per cui viene segnalato l'errore.
• (?<line>...): numero di riga della posizione nel file per la quale viene segnalato l'errore.
• (?<column>...): Numero di colonna della posizione nel file cui viene segnalato l'errore.

Ad esempio, PyLint genera avvisi del formato seguente:

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

Per consentire a Visual Studio di estrarre le informazioni corrette da questi avvisi e visualizzarle nella finestra Elenco errori, il valore dell'attributo WarningRegex per il comando Esegui Pylint è il seguente:

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

Annotazioni

La sintassi msg_id nel valore dell'attributo WarningRegex deve essere code effettivamente, come descritto in Issue 3680.

Importare comandi personalizzati con il file di destinazione

Se si definiscono comandi personalizzati in un file di progetto Python, i comandi sono disponibili solo per tale progetto specifico. Per creare comandi personalizzati e usarli in più progetti, è possibile definire un gruppo di proprietà che includa tutti gli elementi in un file .targets e quindi importare quel file nei tuoi progetti Python.

• Il file di destinazione usa lo stesso formato e la stessa sintassi per definire comandi personalizzati come descritto per il file di progetto Python (con estensione pyproj). Gli elementi comuni da configurare includono <PythonCommands>, <Target><CreatePythonCommandItem>, e <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>
  

• Per importare un file di destinazioni nel progetto, aggiungere un <Import Project="(path)"> elemento in qualsiasi punto all'interno dell'elemento <Project> nel file di progetto.

  Ad esempio, se si dispone di un file di progetto denominato CustomCommands.targets in una cartella targets all'interno del progetto Python, aggiungere il codice seguente al file di progetto:

  <Import Project="targets/CustomCommands.targets"/>
  

• Se il file di progetto importa un file di destinazione e si apportano modifiche al file di destinazione mentre il progetto è aperto in Visual Studio, è necessario ricompilare la soluzione di Visual Studio che contiene il progetto e non solo il progetto.

  

Comandi di esempio

Le sezioni seguenti forniscono codice di esempio che è possibile usare per definire comandi personalizzati per i progetti Python.

Eseguire PyLint (destinazione del modulo)

Il codice seguente viene visualizzato nel file 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>

Eseguire l'installazione pip con un pacchetto specifico (destinazione pip)

Il comando seguente esegue il pip install my-package comando nella finestra Output di Visual Studio. È possibile usare un comando simile a questo quando si sviluppa un pacchetto e si testa l'installazione. L'elemento <Target> contiene il nome del pacchetto anziché il install comando , che si presuppone quando si usa la definizione dell'attributo 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>

Mostra pacchetti pip obsoleti (destinazione pip)

Il comando seguente esegue pip con la list funzione per identificare i pacchetti pip obsoleti:

<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>

Eseguire il file eseguibile con consolepause

Il comando seguente esegue la where funzione per visualizzare il percorso dei file Python a partire dalla cartella del progetto:

<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>

Eseguire il server ed eseguire i comandi del server di debug

Per scoprire come vengono definiti i comandi del server Start e Avvia debug server per i progetti Web, esaminare il repository Microsoft.PythonTools.Web.targets in GitHub.

Installare il pacchetto per lo sviluppo

Il codice seguente esegue pip per installare i pacchetti:

<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>

Da fxthomas/Example.pyproj.xml (GitHub), usato con l'autorizzazione.

Generare Windows Installer

Lo script seguente genera un programma di installazione di 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>

Da fxthomas/Example.pyproj.xml (GitHub), usato con l'autorizzazione.

Generare un pacchetto wheel Python

Lo script seguente genera un pacchetto 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>

Da fxthomas/Example.pyproj.xml (GitHub), usato con l'autorizzazione.

Risolvere i problemi relativi ai comandi personalizzati

Esaminare le sezioni seguenti per individuare i possibili problemi relativi all'uso di comandi personalizzati.

File di progetto non caricato

Questo messaggio di errore indica che sono presenti errori di sintassi nel file di progetto. Il messaggio include l'errore specifico con un numero di riga e una posizione del carattere.

La finestra della console si chiude dopo l'esecuzione del comando

Se la finestra della console viene chiusa immediatamente dopo l'esecuzione del comando, usare la definizione dell'attributo ExecuteIn="consolepause"ExecuteIn="console"anziché .

Comando mancante dal menu

Se il comando personalizzato non viene visualizzato nel menu di scelta rapida python , controllare gli elementi seguenti:

• Verificare che il comando sia incluso nel <PythonCommands> gruppo di proprietà.
• Verificare che il nome del comando definito dall'elenco di comandi corrisponda al nome specificato nell'elemento <Target> .

Ecco un esempio. Nel seguente frammento di codice XML, il nome Example nel gruppo di proprietà <PythonCommands> non corrisponde al nome ExampleCommand nella definizione dell'elemento <Target>. Visual Studio non trova un comando denominato Example, quindi non viene visualizzato alcun comando. Usare ExampleCommand nell'elenco dei comandi o modificare il nome della destinazione in modo che sia solo Example.

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

Errore durante l'esecuzione del comando, non è stato possibile ottenere la destinazione del comando

Questo messaggio di errore indica che il contenuto degli <Target> elementi o <CreatePythonCommandItem> non è corretto.

Ecco alcuni possibili motivi per questo errore:

• L'attributo dell'elemento obbligatorio <Target> è vuoto.
• L'attributo obbligatorio TargetType è vuoto o contiene un valore non riconosciuto.
• L'attributo obbligatorio ExecuteIn è vuoto o contiene un valore non riconosciuto.
• L'attributo ErrorRegex o WarningRegex viene specificato senza impostare la definizione dell'attributo ExecuteIn="output" .
• Gli attributi non riconosciuti esistono nell'elemento . Ad esempio, il riferimento all'attributo potrebbe essere scritto in modo errato come Argumnets anziché Arguments.

I valori degli attributi possono essere vuoti se si fa riferimento a una proprietà non definita. Se si usa il token $(StartupFile) ma non viene definito alcun file di avvio nel progetto, il token viene risolto in una stringa vuota. In questi casi, potrebbe essere necessario definire un valore predefinito. Ad esempio, i comandi Esegui server ed Esegui server di debug definiti nei modelli di progetto Bottle, Flask e Django usano il file manage.py per impostazione predefinita (se non è specificato un file di avvio del server nelle proprietà del progetto).

Visual Studio smette di rispondere e si arresta in modo anomalo

Se Visual Studio smette di rispondere e si arresta in modo anomalo quando si esegue il comando personalizzato, è probabile che si stia tentando di eseguire un comando della console con la definizione dell'attributo ExecuteIn="output" . In questi casi, Visual Studio potrebbe arrestarsi in modo anomalo quando tenta di analizzare l'output. Per evitare questa condizione, usare invece la definizione dell'attributo ExecuteIn="console" . Per altre informazioni, vedere Problema 3681.

Comando non riconosciuto come programma eseguibile o file batch

Quando si imposta la definizione dell'attributoTargetType="executable", il valore nell'attributo deve essere Target il nome del programma senza argomenti, ad esempio python o python.exe solo. In questo caso, spostare tutti gli argomenti nell'attributo Arguments .