Definir comandos personalizados para projetos do Python no Visual Studio

Ao desenvolver seus projetos do Python, você pode se encontrar alternando para uma janela de comando para executar scripts ou módulos específicos, executar comandos pip ou usar outras ferramentas com o código. Para melhorar o fluxo de trabalho, você pode adicionar comandos personalizados ao menu de projeto Python no Visual Studio. Os comandos personalizados do Python podem ser executados em uma janela do console ou na janela de saída do Visual Studio . Você também pode usar expressões regulares para instruir o Visual Studio como analisar os erros e avisos da saída do comando.

Pré-requisitos

• Visual Studio no Windows instalado com suporte para cargas de trabalho do Python. Para obter mais informações, confira Instalar o suporte ao Python no Visual Studio.

Não há suporte para o Visual Studio para Mac. Para obter mais informações, confira O que está acontecendo com o Visual Studio para Mac? O Visual Studio Code no Windows, Mac e Linux funciona bem com o Python por meio das extensões disponíveis.

Explorar comandos personalizados

Por padrão, o menu de projeto Python contém dois comandos, Executar PyLint e Executar Mypy:

Todos os comandos personalizados do Python que você definir serão exibidos neste mesmo menu. Um comando personalizado pode se referir a um arquivo Python, um módulo Python, um código Python embutido, um executável qualquer ou um comando de pip. Você também pode especificar como e onde o comando é executado.

Você pode adicionar comandos personalizados de várias maneiras:

• Defina comandos personalizados em um arquivo de projeto do Python (.pyproj) diretamente. Esses comandos se aplicam a esse projeto específico.

• Definir comandos personalizados em um arquivo de destino (.targets). Você pode importar facilmente os comandos neste arquivo para usá-los com vários projetos.

• Crie um projeto do Python a partir de um modelo de projeto no Visual Studio que define comandos personalizados do Python.

  Determinados modelos de projeto do Python no Visual Studio adicionam comandos personalizados usando um arquivo de destino. Os modelos Bottle Web Project e Flask Web Project adicionam dois comandos, Iniciar servidor e Iniciar servidor de depuração. O modelo do Projeto Web do Django adiciona estes comandos e vários outros:

  

Recarregar projeto para acessar comandos personalizados

Quando um projeto é aberto no Visual Studio, se você fizer alterações no arquivo de projeto correspondente em um editor, será necessário recarregar o projeto para aplicar as alterações. Da mesma forma, depois de definir comandos personalizados do Python em um arquivo de projeto do Python, você precisará recarregar o projeto do Python para que os comandos apareçam no menu de projeto do Python. Ao modificar comandos personalizados definidos em um arquivo de destino, você precisará recompilar a solução completa do Visual Studio para projetos que importem o arquivo de destino.

Uma abordagem comum é fazer as alterações no arquivo de projeto do Python diretamente no Visual Studio:

1. Abra o projeto do Python no Visual Studio. (Quando você abre um projeto no Visual Studio, o projeto é carregado por padrão.)

2. No Gerenciador de Soluções, clique com o botão direito do mouse no projeto do Python e selecione Descarregar Projeto.

   O Visual Studio descarrega o projeto e abre o arquivo de projeto do Python correspondente (.pyproj) no editor.

   Se o arquivo de projeto não abrir, clique com o botão direito do mouse no projeto do Python novamente e selecione Editar Arquivo de Projeto:

   

3. Faça as alterações no arquivo de projeto no editor do Visual Studio e salve seu trabalho.

4. No Gerenciador de Soluções, clique com o botão direito do mouse no projeto descarregado e selecione Recarregar Projeto. Se você tentar recarregar o projeto sem salvar as alterações no arquivo de projeto, o Visual Studio solicitará que você conclua a ação.

O processo de descarregar-editar-salvar-recarregar pode se tornar entediante quando você estiver desenvolvendo comandos personalizados. Um fluxo de trabalho mais eficiente envolve o carregamento simultâneo do projeto no Visual Studio e a abertura do arquivo de projeto do Python em um editor separado. Você pode usar qualquer editor, como outra instância do Visual Studio, Visual Studio Code, Bloco de Notas e assim por diante. Depois de salvar as alterações no editor e voltar ao Visual Studio, o Visual Studio detectará as alterações do arquivo de projeto do projeto aberto e solicitará que você execute uma ação:

Selecione Recarregar ou Recarregar Tudo e o Visual Studio aplica imediatamente as alterações do arquivo de projeto ao projeto aberto.

Adicionar comandos personalizados com o arquivo de projeto

O procedimento a seguir mostra como criar um comando personalizado adicionando a definição no arquivo de projeto do Python (.pyproj) e recarregando o projeto no Visual Studio. O comando personalizado executa o arquivo de inicialização de um projeto diretamente usando o comando python.exe, que é basicamente o mesmo que usar a opção Depurar>Iniciar sem Depurar na barra de ferramentas principal do Visual Studio.

1. No Visual Studio, crie um novo projeto do Python chamado Python-CustomCommands usando o modelo do Aplicativo do Python. Para obter instruções, confira Início Rápido: criar um projeto do Python usando um modelo.

   O Visual Studio cria o projeto do Python e o carrega na sessão. Você pode configurar o projeto por meio do arquivo de projeto (.pyproj). Esse arquivo só fica visível no Visual Studio quando o projeto está aberto, mas descarregado. O projeto também tem um arquivo Python (.py) para o código do aplicativo.

2. Abra o arquivo de aplicativo Python_CustomCommands.py no editor e adicione o seguinte código:

   print("Hello custom commands")
   

3. No Gerenciador de Soluções, clique com o botão direito do mouse no projeto do Python, selecione Python e observe os comandos no menu de contexto. No momento, os únicos comandos no menu de contexto são Executar PyLint e Executar Mypy. Quando você define comandos personalizados, eles também são exibidos nesse menu.

4. Inicie um editor separado fora da sessão do Visual Studio e abra o arquivo de projeto do Python (Python-CustomCommands.pyproj) no editor. (Abra o arquivo de projeto (.pyproj) e não o arquivo de aplicativo do Python (.py).)

5. No arquivo de projeto, localize o elemento de fechamento </Project> no final do arquivo e adicione o seguinte XML imediatamente antes do elemento de fechamento:

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

6. Salve as alterações do arquivo de projeto e volte ao Visual Studio. O Visual Studio detecta as alterações do arquivo de projeto e solicita que você execute uma ação. No prompt, selecione Recarregar para atualizar o projeto aberto com as alterações do arquivo de projeto.

7. No Gerenciador de Soluções, clique com o botão direito do mouse no projeto Python, selecione Pythone verifique os comandos no menu de contexto.

   O menu de contexto ainda mostra apenas os comandos Executar PyLint e Executar Mypy. O código que você acabou de adicionar ao arquivo de projeto só replica o grupo de propriedades <PythonCommands> padrão que contém o comando PyLint. Na próxima etapa, você adicionará mais código para o comando personalizado.

8. Mude para o editor em que você está atualizando o arquivo de projeto. Adicione a seguinte definição de elemento <Target> dentro do elemento <Project>. Você pode posicionar a definição de <Target> antes ou depois da definição de <PropertyGroup> descrita anteriormente.

   Esse elemento <Target> define um comando personalizado para executar o arquivo de inicialização do projeto (identificado pela propriedade StartupFile) usando o comando python.exe em uma janela do console. A definição de atributo ExecuteIn="consolepause" usa um console que aguarda que você selecione uma chave para fechar a janela do 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. Substitua o grupo de propriedades <PythonCommands> (adicionado na etapa 5) pelo XML a seguir. Essa sintaxe define o atributo Name para o elemento <Target>, que adiciona o comando personalizado ao menu de contexto do Python. O comando tem o rótulo de menu Executar arquivo de inicialização.

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

   Dica

   Se você quiser que o comando personalizado seja exibido no menu de contexto antes dos comandos padrão definidos no token $(PythonCommands), posicione a sintaxe <Target> para o comando antes desse token.

10. Salve as alterações do arquivo de projeto e volte ao Visual Studio. No prompt, recarregue seu projeto.

11. No Gerenciador de Soluções, clique com o botão direito do mouse no projeto do Python, selecione Python e verifique novamente os comandos no menu de contexto.

    Agora, o comando Executar arquivo de inicialização personalizado está no menu. Se você não vir o comando personalizado, confirme se adicionou o valor do atributo Name para o elemento <Target> ao elemento <PythonCommands>, conforme descrito na etapa 9. Examine também as considerações listadas na seção Solução de problemas posteriormente neste artigo.

    

12. Selecione o comando Executar o arquivo de inicialização. Uma janela do console é aberta e exibe o texto Hello comandos personalizados seguidos por Pressione qualquer tecla para continuar. Confirme a saída e feche a janela do console.

    

    Observação

    O script de comando personalizado é executado no ambiente ativado para o projeto do Python.

13. Alterne para o editor usando o arquivo de projeto. Na definição do elemento <Target> (adicionado na etapa 8), altere o valor do atributo ExecuteIn para output.

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

14. Salve as alterações, volte ao Visual Studio e recarregue o projeto.

15. Selecione o comando personalizado Executar o arquivo de inicialização novamente no menu contextual do Python. Agora, a saída do programa é exibida na janela de saída do Visual Studio em vez de uma janela do console.

    

16. Para adicionar mais comandos personalizados, siga este mesmo processo:

    1. Defina um elemento <Target> adequado para o comando personalizado no arquivo de projeto.

    2. Adicione o valor do atributo Name para o elemento <Target> no grupo de propriedades <PythonCommands>.

    3. Salve as alterações no arquivo de projeto.

    4. Recarregue o projeto no Visual Studio.

Usar propriedades do projeto

Para se referir a propriedades do projeto ou variáveis de ambiente nos valores de atributos do elemento <Target>, use o nome da propriedade dentro de um token $(), como em $(StartupFile) e $(MSBuildProjectDirectory). Para obter mais informações, confira Propriedades do MSBuild.

Se você invocar um comando como ($StartupFile) que use propriedades do projeto como a propriedade StartupFile, e o comando falhar porque o token está indefinido, o Visual Studio desabilitará o comando até que você recarregue o projeto. Se você fizer alterações no projeto que modifiquem a definição de propriedade, as alterações não atualizarão o estado do comando relacionado. Nesse caso, você ainda precisará recarregar o projeto.

Entender a estrutura de elementos de <Destino>

Você define os detalhes de um comando personalizado usando o elemento <Target>. O formato geral do elemento <Target> é mostrado no pseudocódigo a seguir:

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

Atributos de destino

A tabela a seguir lista os atributos do elemento <Target>.

Atributo	Necessário	Descrição
Name	Sim	O identificador do comando dentro do projeto do Visual Studio. Esse nome deve ser adicionado ao grupo de propriedades <PythonCommands> para que o comando seja exibido no menu de contexto do Python.
Label	Sim	O nome de exibição da interface do usuário que aparece no menu contextual do Python.
Returns	Sim	As informações retornadas precisam conter o token @(Commands), que identifica o destino como sendo um comando.

Atributos de CreatePythonCommandItem

O elemento <Target> contém os elementos <CreatePythonCommandItem> e <Output>, que definem o comportamento detalhado do comando personalizado. A tabela a seguir lista os atributos do elemento <CreatePythonCommandItem> disponíveis. Todos os valores de atributo não diferenciam maiúsculas de minúsculas.

Attribute	Necessário	Descrição
TargetType	Sim	Especifica o que o atributo Target contém e como o valor é usado junto com o atributo Arguments: - executable: execute o executável nomeado no atributo Target, acrescentando o valor no atributo Arguments, como se fosse inserido diretamente na linha de comando. O valor deve conter apenas um nome de programa sem argumentos. - script: execute o comando python.exe com o nome do arquivo no atributo Target, seguido pelo valor no atributo Arguments. - module: execute o comando python -m seguido pelo nome do módulo no atributo Target, seguido pelo valor no atributo Arguments. - code: execute o código embutido contido no atributo Target. Ignore o valor do atributo Arguments. - pip: execute pip com o comando no atributo Target, seguido pelo valor no atributo Arguments. Se o atributo ExecuteIn estiver definido como output, o pip presumirá que a solicitação é para executar o comando install e usará o atributo Target como o nome do pacote.
Target	Sim	Especifica o nome do arquivo, o nome do módulo, o código ou o comando pip a ser usado, dependendo do valor do atributo TargetType.
Arguments	Opcional	Fornece uma cadeia de argumentos (se houver) a ser usada com o atributo Target. - Quando o valor do atributo TargetType é script, o valor Arguments é fornecido para o programa Python, em vez do comando python.exe. - Quando o valor do atributo TargetType é code, o valor Arguments é ignorado.
ExecuteIn	Sim	Especifica o ambiente no qual o comando deve ser executado: - console: (Padrão) Executa o atributo Target com o valor Arguments como se fossem inseridos diretamente na linha de comando. Enquanto o atributo Target está em execução, uma janela de comando é exibida e fechada automaticamente. - consolepause: mesmo comportamento que console, mas aguarda uma tecla ser pressionada antes de fechar a janela. - output: executa o atributo Target e exibe os resultados na janela Saída do Visual Studio. Se o atributo TargetType for pip, o Visual Studio usará o atributo Target como o nome do pacote e acrescentará o valor do atributo Arguments. - repl: executa o atributo Target na Janela Interativa do Python . O nome de exibição opcional é usado para o título da janela. - none: o mesmo comportamento que o console.
WorkingDirectory	Opcional	Identifica a pasta na qual o comando deve ser executado.
ErrorRegex WarningRegEx	Opcional	Usado somente quando o atributo ExecuteIn é definido como output. Ambos os valores de atributo especificam uma expressão regular que o Visual Studio usa para analisar a saída do comando e mostrar erros e avisos na janela Lista de Erros. Se esses atributos não forem especificados, o comando não afetará a janela Lista de Erros. Para obter mais informações sobre o que o Visual Studio espera, confira Grupos de captura nomeados.
RequiredPackages	Opcional	Fornece uma lista de requisitos de pacote para o comando usando o mesmo formato que o arquivo requirements.txt (pip.readthedocs.io). Por exemplo, o comando Executar PyLint especifica o formato pylint>=1.0.0. Antes de executar o comando, o Visual Studio confirma se todos os pacotes na lista estão instalados. O Visual Studio usa o pip para instalar todos os pacotes ausentes.
Environment	Opcional	Identifica uma cadeia de caracteres de variáveis de ambiente a ser definida antes da execução do comando. Cada variável usa o formato \<NAME>=\<VALUE> com várias variáveis separadas por ponto e vírgula. Uma variável com vários valores precisa estar entre aspas simples ou duplas, como em 'NAME=VALUE1;VALUE2'.

Grupos de captura nomeados para expressões regulares

Quando o Visual Studio analisa erros e avisos da saída de comando personalizada, ele espera que as expressões regulares nos valores de atributo ErrorRegex e WarningRegex usem os seguintes grupos nomeados:

• (?<message>...): texto do erro.
• (?<code>...): valor do código de erro.
• (?<filename>...): nome do arquivo para o qual o erro é relatado.
• (?<line>...): número da linha no arquivo no qual o erro é relatado.
• (?<column>...): número da coluna do local no arquivo onde o erro é relatado.

Por exemplo, PyLint produz avisos da seguinte forma:

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

Para permitir que o Visual Studio extraia as informações corretas desses avisos e mostre-as na janela Lista de Erros, o valor do atributo WarningRegex para o comando Executar Pylint deve ser o seguinte:

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

Observação

A sintaxe msg_id no valor do atributo WarningRegex na verdade deve ser code, conforme descrito no Problema 3680.

Importar comandos personalizados com o arquivo targets

Se você definir comandos personalizados em um arquivo de projeto do Python, os comandos estarão disponíveis apenas para esse projeto específico. Quando quiser criar comandos personalizados e usá-los em vários projetos, você pode definir o grupo de propriedades <PythonCommands> com todos os elementos <Target> em um arquivo de destino (.targets) e importar esse arquivo para os projetos do Python.

• O arquivo de destino usa o mesmo formato e sintaxe para definir comandos personalizados, conforme descrito para o arquivo de projeto do Python (.pyproj). Os elementos comuns a serem configurados incluem <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>
  

• Para importar um arquivo de destino para o projeto, adicione um elemento <Import Project="(path)"> em qualquer lugar dentro do elemento <Project> no arquivo de projeto.

  Por exemplo, se você tiver um arquivo de projeto chamado CustomCommands.targets em uma pasta targets dentro do seu projeto Python, adicione o seguinte código ao seu arquivo de projeto:

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

• Se o arquivo de projeto importar um arquivo targets e você fizer alterações nesse arquivo enquanto o projeto estiver aberto no Visual Studio, você precisará recompilar a solução do Visual Studio que contém seu projeto, e não apenas seu projeto.

  

Comandos de exemplo

As seções a seguir fornecem um código de exemplo que você pode usar para definir comandos personalizados para os projetos do Python.

Executar PyLint (destino do módulo)

O seguinte código é exibido no arquivo 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>

Executar o pip install com um pacote específico (destino de pip)

O comando a seguir executa o comando pip install my-package na janela Saída do Visual Studio. Você pode usar um comando como este ao desenvolver um pacote e testar a instalação. O elemento <Target> contém o nome do pacote em vez do comando install, que é considerado ao usar a definição do atributo 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>

Mostrar pacotes de pip desatualizados (destino de pip)

O comando a seguir executa o pip com a função list para identificar pacotes pip desatualizados:

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

Executar executável com pausa no console

O comando a seguir executa a função where para mostrar a localização dos arquivos Python na pasta do projeto:

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

Comandos para executar o servidor e executar o servidor de depuração

Para explorar como os comandos Iniciar servidor e Iniciar servidor de depuração para projetos web são definidos, examine o repositório Microsoft.PythonTools.Web.targets no GitHub.

Instalar o pacote para desenvolvimento

O código a seguir executa o pip para instalar pacotes:

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

De fxthomas/Example.pyproj.xml (GitHub), usado com permissão.

Gerar o Windows Installer

O script a seguir gera um instalador do 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>

De fxthomas/Example.pyproj.xml (GitHub), usado com permissão.

Gerar pacote wheel do Python

O seguinte script gera um pacote wheel do 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>

De fxthomas/Example.pyproj.xml (GitHub), usado com permissão.

Solucionar problemas de comandos personalizados

Revise as seções a seguir para verificar possíveis problemas relacionados ao trabalho com comandos personalizados.

Arquivo de projeto não carregado

Esta mensagem de erro indica que você tem erros de sintaxe no arquivo de projeto. A mensagem inclui o erro específico com um número de linha e a posição do caractere.

A janela do console é fechada após a execução do comando

Se a janela do console for fechada imediatamente após a execução do comando, use a definição de atributo ExecuteIn="consolepause", em vez de ExecuteIn="console".

Comando ausente no menu

Se você não vir o comando personalizado no menu de contexto do Python, verifique os seguintes itens:

• Confirme se o comando está incluído no grupo de propriedades <PythonCommands>.
• Verifique se o nome do comando definido na lista de comandos corresponde ao nome especificado no elemento <Target>.

Veja um exemplo. No snippet XML a seguir, o nome do Example no grupo de propriedades <PythonCommands> não corresponde ao nome do ExampleCommand na definição do elemento <Target>. O Visual Studio não encontra um comando chamado Example, portanto, não aparece nenhum comando. Use ExampleCommand na lista de comandos ou altere o nome do destino para que seja apenas Example.

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

Erro ao executar o comando, falha ao obter o destino do comando

Essa mensagem de erro indica que o conteúdo dos elementos <Target> ou <CreatePythonCommandItem> estão incorretos.

Estes são alguns possíveis motivos para esse erro:

• O atributo de elemento <Target> necessário está vazio.
• O atributo TargetType obrigatório está vazio ou contém um valor não reconhecido.
• O atributo ExecuteIn obrigatório está vazio ou contém um valor não reconhecido.
• O atributo ErrorRegex ou WarningRegex é especificado sem a definição de atributo ExecuteIn="output".
• Atributos não reconhecidos existem no elemento. Por exemplo, a referência de atributo pode estar mal escrita como Argumnets em vez de Arguments.

Os valores de atributo poderão ficar vazios se você fizer referência a uma propriedade que não esteja definida. Se você usar o token $(StartupFile), mas nenhum arquivo de inicialização for definido no projeto, o token será resolvido como uma cadeia de caracteres vazia. Nesses casos, talvez você queira definir um valor padrão. Por exemplo, os comandos Executar servidor e Executar servidor de depuração definidos nos modelos de projeto Bottle, Flask e Django usam o arquivo manage.py por padrão (se um arquivo de inicialização do servidor não for especificado nas propriedades do projeto).

O Visual Studio para de responder, falha

Se o Visual Studio parar de responder e falhar ao executar o comando personalizado, provavelmente você está tentando executar um comando de console com a definição de atributo ExecuteIn="output". Nesses casos, o Visual Studio pode falhar ao tentar analisar a saída. Para evitar essa condição, use a definição de atributo ExecuteIn="console". Para obter mais informações, confira Problema 3681.

Comando não reconhecido como programa operável ou arquivo em lote

Quando você estabelece a definição de atributo TargetType="executable", o valor no atributo Target deve ser apenas o nome do programa sem argumentos, como apenas python ou python.exe. Nesse caso, mova todos os argumentos para o atributo Arguments.