Definir comandos personalizados para projetos Python no Visual Studio

À medida que desenvolves os teus projetos em Python, podes acabar por mudar para uma janela de comandos para executar scripts ou módulos específicos, executar comandos pip ou usar outras ferramentas com o teu código. Para melhorar o seu fluxo de trabalho, pode adicionar comandos personalizados ao menu do projeto Python no Visual Studio. Os comandos Python personalizados podem ser executados numa janela de consola ou na janela de Saída do Visual Studio. Também pode usar expressões regulares para instruir o Visual Studio como analisar erros e avisos a partir da saída do comando.

Pré-requisitos

Visual Studio no Windows instalado com suporte para cargas de trabalho em Python. Para obter mais informações, consulte Instalar suporte a Python no Visual Studio.

O Visual Studio para Mac não é suportado. O Visual Studio Code no Windows, Mac e Linux funciona bem com Python através das extensões disponíveis.

Explorar comandos personalizados

Por defeito, o menu do projeto Python contém dois comandos, Run PyLint e Run Mypy:

Quaisquer comandos Python personalizados que definas aparecem neste mesmo menu. Um comando personalizado pode referir-se a um ficheiro Python, um módulo Python, código Python inline, um executável arbitrário ou um comando pip. Também pode especificar como e onde o comando é executado.

Podes adicionar comandos personalizados de várias formas:

Defina comandos personalizados diretamente num ficheiro de projeto Python (.pyproj). Estes comandos aplicam-se a esse projeto específico.
Defina comandos personalizados num ficheiro targets (.targets). Podes facilmente importar os comandos deste ficheiro para os usar com vários projetos.
Crie um projeto Python a partir de um modelo de projeto no Visual Studio que defina comandos Python personalizados.

Certos modelos de projeto Python no Visual Studio adicionam comandos personalizados usando um ficheiro de destino. Os modelos Bottle Web Project e Flask Web Project adicionam dois comandos, Start server e Start debug server. O modelo Django Web Project adiciona estes comandos e vários mais:

Recarregar o projeto para aceder a comandos personalizados

Quando um projeto está aberto no Visual Studio, se fizer alterações ao ficheiro correspondente num editor, deve recarregar o projeto para aplicar as alterações. De forma semelhante, depois de definir comandos Python personalizados num ficheiro de projeto Python, precisa de recarregar o projeto Python para que os comandos apareçam no menu do projeto Python . Quando modificas comandos personalizados definidos num ficheiro de destino, precisas de reconstruir toda a solução Visual Studio para qualquer projeto que importe esse ficheiro de destino.

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

Abra o seu projeto Python no Visual Studio. (Quando abres um projeto no Visual Studio, o projeto é carregado por defeito.)
No Explorador de Soluções, clique com o botão direito no projeto Python e selecione Descarregar o Projeto.

O Visual Studio descarrega o projeto e abre o ficheiro correspondente em Python (.pyproj) no editor.

Se o ficheiro do projeto não abrir, clique novamente com o botão direito no projeto Python e selecione Editar Ficheiro do Projeto:
Faz as tuas alterações ao ficheiro do projeto no editor Visual Studio e guarda o teu trabalho.
No Explorador de Soluções, clique com o botão direito no projeto descarregado e selecione Recarregar Projeto. Se tentar recarregar o projeto sem guardar as alterações no ficheiro do projeto, o Visual Studio pede-lhe para completar a ação.

O processo de descarregar-editar-guardar-recarregar pode tornar-se aborrecido quando se desenvolvem comandos personalizados. Um fluxo de trabalho mais eficiente envolve simultaneamente carregar o projeto no Visual Studio e abrir o ficheiro Python num editor separado. Pode usar qualquer editor, como outra instância do Visual Studio, Visual Studio Code, Notepad, e assim por diante. Depois de guardar as alterações no editor e voltar para o Visual Studio, o Visual Studio deteta as alterações no ficheiro do projeto aberto e pede-lhe para agir:

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

Adicionar comandos personalizados com ficheiro de projeto

O procedimento seguinte mostra como criar um comando personalizado adicionando a definição no ficheiro de projeto Python (.pyproj) e recarregando o seu projeto no Visual Studio. O comando personalizado executa diretamente o ficheiro de arranque do projeto usando o python.exe comando, que é basicamente o mesmo que usar a opção Debug>Start without Debugging na barra principal do Visual Studio.

No Visual Studio, crie um novo projeto Python chamado Python-CustomCommands usando o modelo de aplicação Python . Para instruções, veja Quickstart: Criar um projeto Python a partir de um template.

O Visual Studio cria o projeto Python e carrega-o na tua sessão. Podes configurar o projeto através do ficheiro do projeto (.pyproj). Este ficheiro só é visível no Visual Studio quando o projeto está aberto, mas não carregado. O projeto também tem um ficheiro Python (.py) para o código da aplicação.
Abra o ficheiro de aplicação Python_CustomCommands.py no editor e adicione o seguinte código:
```
print("Hello custom commands")
```
No Explorador de Soluções, clique com o botão direito no projeto Python, selecione Python e repare nos comandos no menu contextual. Atualmente, os únicos comandos no menu de contexto são Executar PyLint e Executar Mypy. Quando defines comandos personalizados, eles também aparecem neste menu.
Inicia um editor separado fora da tua sessão do Visual Studio e abre o ficheiro do projeto Python (Python-CustomCommands.pyproj) no editor. (Certifique-se de abrir o ficheiro do projeto (.pyproj) e não o ficheiro da aplicação Python (.py).)
No ficheiro do projeto, localize o elemento de encerramento </Project> no final do ficheiro e adicione o seguinte XML imediatamente antes do elemento de fecho:
```
<PropertyGroup>
  <PythonCommands>
    $(PythonCommands);
  </PythonCommands>
</PropertyGroup>
```
Guarde as alterações no ficheiro do projeto e volte ao Visual Studio. O Visual Studio deteta alterações no ficheiro do seu projeto e solicita-o para agir. No prompt, selecione Recarregar para atualizar o seu projeto aberto com as alterações ao ficheiro do projeto.
No Explorador de Soluções, clique com o botão direito no projeto Python, selecione Python e verifique os comandos no menu contextual.

O menu de contexto ainda mostra apenas os comandos Run PyLint e Run Mypy . O código que acabaste de adicionar ao ficheiro do projeto simplesmente replica o grupo de propriedades padrão <PythonCommands> que contém o comando PyLint. No passo seguinte, adicionas mais código para o comando personalizado.
Muda para o editor onde estás a atualizar o ficheiro do projeto. Adicione a seguinte <Target> definição de elemento dentro do <Project> elemento. Pode posicionar a <Target> definição antes ou depois da <PropertyGroup> definição descrita anteriormente.

Este <Target> elemento define um comando personalizado para executar o ficheiro de arranque do projeto (identificado pela propriedade Ficheiro de Arranque ) usando o python.exe comando numa janela de consola. A definição ExecuteIn="consolepause" de atributos usa uma consola que espera que seleciones uma tecla para fechar a janela da consola.
```
<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>
```
Substitua o <PythonCommands> grupo de propriedades (adicionado no passo 5) pelo seguinte XML. Esta sintaxe define o Name atributo do <Target> elemento, que adiciona o comando personalizado ao menu contextual em Python . O comando tem o rótulo de menu Executar ficheiro de arranque.
```
  <PythonCommands>
    $(PythonCommands);
    Example_RunStartupFile
  </PythonCommands>
```
Sugestão

Se quiseres que o teu comando personalizado apareça no menu de contexto antes dos comandos padrão definidos no $(PythonCommands) token, posiciona a <Target> sintaxe do teu comando antes desse token.
Guarde as alterações no ficheiro do projeto e volte ao Visual Studio. No prompt, recarregue o seu projeto.
No Explorador de Soluções, clique com o botão direito no projeto Python, selecione Python e volte a verificar os comandos no menu contextual.

Agora o comando personalizado Executar ficheiro de arranque está no menu. Se não vires o comando personalizado, confirma que adicionaste o Name valor do atributo do <Target> elemento ao <PythonCommands> elemento conforme descrito no passo 9. Consulte também as considerações listadas na secção de Resolução de Problemas mais adiante neste artigo.
Selecione o comando Executar ficheiro de arranque . Uma janela da consola abre-se e mostra o texto Olá comandos personalizados seguido de Pressione qualquer tecla para continuar. Confirma a saída e fecha a janela do console.

Observação

O script de comando personalizado corre no ambiente ativado do teu projeto Python.
Muda para o editor com o arquivo do projeto. Na definição do <Target> elemento (adicionada no passo 8), altere o valor do ExecuteIn atributo para output.
```
  <CreatePythonCommandItem
    ...
    ExecuteIn="output">
    ...
  </CreatePythonCommandItem>
```
Guarda as tuas alterações, volta ao Visual Studio e carrega o teu projeto.
Selecione novamente o comando Executar ficheiro de arranque personalizado no menu contextual em Python . Agora, a saída do programa aparece na janela de Saída do Visual Studio em vez de uma janela de consola:
Para adicionar mais comandos personalizados, siga este mesmo processo:
1. Defina um elemento adequado <Target> para o comando personalizado no ficheiro do projeto.
2. Adicione o valor do atributo Name para o elemento <Target> no grupo de propriedades <PythonCommands>.
3. Guarda as tuas alterações no ficheiro do projeto.
4. Recarregue o seu projeto no Visual Studio.

Utilização das propriedades do projeto

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

Ao invocar um comando como ($StartupFile) que use propriedades do projeto, como a propriedade Ficheiro de Inicialização, e o comando falhar porque o token está indefinido, o Visual Studio desativa o comando até que recarregue o projeto. Se fizeres alterações ao projeto que modificam a definição de propriedade, as tuas alterações não atualizam o estado do comando relacionado. Neste caso, ainda precisas de recarregar o projeto.

Compreender <a estrutura do elemento alvo>

Defines os detalhes de um comando personalizado usando o <Target> elemento. A forma geral do <Target> elemento é mostrada no seguinte pseudocódigo:

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

A tabela seguinte lista os <Target> atributos dos elementos.

Attribute	Obrigatório	Description
`Name`	Yes	O identificador do comando dentro do projeto Visual Studio. Este nome deve ser adicionado ao `<PythonCommands>` grupo de propriedades para que o comando apareça no menu contextual em Python .
`Label`	Yes	O nome de visualização da interface que aparece no menu de contexto Python.
`Returns`	Yes	A informação devolvida, que deve conter o `@(Commands)` token, identifica o alvo como um comando.

Atributos CreatePythonCommandItem

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

`Attribute`	Obrigatório	Description
`TargetType`	Yes	Especifica o que o `Target` atributo contém e como o valor é usado juntamente com o `Arguments` atributo: - `executable`: Execute o executável nomeado no `Target` atributo, acrescentando o valor no `Arguments` atributo, como se fosse introduzido diretamente na linha de comandos. O valor deve conter apenas um nome de programa sem argumentos. - `script`: Execute o `python.exe` comando com o nome do ficheiro no `Target` atributo, seguido do valor no `Arguments` atributo. - `module`: Execute o `python -m` comando seguido do nome do módulo no `Target` atributo, seguido do valor no `Arguments` atributo. - `code`: Executar o código inline contido no `Target` atributo. Ignora o valor do `Arguments` atributo. - `pip`: Execute pip com o comando no atributo `Target`, seguido pelo valor no atributo `Arguments`. Se o `ExecuteIn` atributo for definido para `output`, o pip assume que o pedido é para executar o `install` comando e usa o `Target` atributo como nome do pacote.
`Target`	Yes	Especifica o nome do ficheiro, nome do módulo, código ou comando pip a usar, dependendo do valor do `TargetType` atributo.
`Arguments`	Opcional	Fornece uma sequência de argumentos (se houver) para usar com o `Target` atributo. - Quando o `TargetType` valor do atributo é `script`, o `Arguments` valor é fornecido ao programa Python em vez do `python.exe` comando. - Quando o `TargetType` valor do atributo é `code`, o `Arguments` valor é ignorado.
`ExecuteIn`	Yes	Especifica o ambiente em que executar o comando: - `console`: (Padrão) Executa o `Target` atributo com o `Arguments` valor como se estivesse inserido diretamente na linha de comandos. Enquanto o `Target` atributo está a funcionar, uma janela de comandos aparece e fecha automaticamente. - `consolepause`: Mesmo comportamento que `console`, mas espera por um toque de tecla antes de fechar a janela. - `output`: Executa o `Target` atributo e apresenta os resultados na janela de Saída do Visual Studio. Se `TargetType` for um atributo `pip`, o Visual Studio utiliza o atributo `Target` como nome do pacote e acrescenta o valor do atributo `Arguments`. - `repl`: Executa o `Target` atributo na Janela Interativa em Python. O nome de exibição opcional é usado para o título da janela. - `none`: Mesmo comportamento que `console`.
`WorkingDirectory`	Opcional	Identifica a pasta onde executar o comando.
`ErrorRegex` `WarningRegEx`	Opcional	Usado apenas quando o `ExecuteIn` atributo está definido como `output`. Ambos os valores de atributos especificam uma expressão regular que o Visual Studio usa para analisar a saída dos comandos e mostrar erros e avisos na janela da Lista de Erros . Se estes atributos não forem especificados, o comando não afeta a janela da Lista de Erros . Para mais informações sobre o que o Visual Studio espera, consulte Grupos de captura nomeados.
`RequiredPackages`	Opcional	Fornece uma lista dos requisitos do pacote para o comando usando o mesmo formato do ficheiro requirements.txt (pip.readthedocs.io). Por exemplo, o comando Run PyLint especifica o formato `pylint>=1.0.0`. Antes de executares o comando, o Visual Studio confirma que todos os pacotes da lista estão instalados. O Visual Studio usa pip para instalar quaisquer pacotes em falta.
`Environment`	Opcional	Identifica uma cadeia de variáveis de ambiente a definir antes de executar o comando. Cada variável utiliza a forma `\<NAME>=\<VALUE>` com múltiplas variáveis separadas por ponto e vírgula. Uma variável com múltiplos valores deve estar contida 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 a partir da saída de comandos personalizados, espera que expressões regulares nos ErrorRegex valores do atributo e WarningRegex usem os seguintes grupos nomeados:

(?<message>...): Texto do erro.
(?<code>...): Valor do código de erro.
(?<filename>...): Nome do ficheiro para o qual o erro é reportado.
(?<line>...): Número de linha da localização no ficheiro para a qual o erro é reportado.
(?<column>...): Número da coluna da localização no ficheiro para a qual o erro é reportado.

Por exemplo, o PyLint produz avisos da seguinte forma:

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

Para permitir que o Visual Studio extraia a informação correta destes avisos e os mostre na janela da Lista de Erros , o WarningRegex valor do atributo para o comando Run Pylint é o seguinte:

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

Observação

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

Importar comandos personalizados com ficheiro de targets

Se defines comandos personalizados num ficheiro de projeto Python, os comandos estão disponíveis apenas para esse projeto específico. Quando quiseres criar comandos personalizados e usá-los em vários projetos, podes definir o <PythonCommands> grupo de propriedades com todos os teus <Target> elementos num ficheiro targets (.targets) e depois importar esse ficheiro para os teus projetos Python.

O ficheiro targets utiliza o mesmo formato e sintaxe para definir comandos personalizados conforme descrito para o ficheiro de projeto Python (.pyproj). Os elementos comuns para configurar 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 ficheiro de destinos para o seu projeto, adicione um <Import Project="(path)"> elemento em qualquer parte dentro do <Project> elemento no ficheiro do seu projeto.

Por exemplo, se tiver um ficheiro de projeto chamado CustomCommands.targets numa pasta targets dentro do seu projeto Python, adicione o seguinte código ao ficheiro do projeto:
```
<Import Project="targets/CustomCommands.targets"/>
```
Se o seu ficheiro de projeto importar um ficheiro de destinos e fizer alterações ao ficheiro de alvos enquanto o seu projeto está aberto no Visual Studio, precisa de reconstruir a solução Visual Studio que contém o seu projeto, e não apenas o seu projeto.

Comandos de exemplo

As secções seguintes fornecem código de exemplo que pode usar para definir comandos personalizados para os seus projetos em Python.

Executar PyLint (destino do módulo)

O seguinte código aparece no ficheiro 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 pip install com um pacote específico (pip como alvo)

O comando seguinte executa o pip install my-package comando na janela de Saída do Visual Studio. Podes usar um comando assim quando desenvolves um pacote e testas a sua instalação. O <Target> elemento contém o nome do pacote em vez do install comando, que é assumido quando se usa a definição de ExecuteIn="output" atributo.

<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 pip desatualizados (alvo pip)

O seguinte comando executa pip com a list função 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 ficheiro executável com consolepause

O comando seguinte executa a where função para mostrar a localização dos ficheiros Python a partir da 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>

Executar o servidor e executar comandos de depuração do servidor

Para explorar como os comandos Start server e Start debug server são definidos para projetos web, consulte o repositório Microsoft.PythonTools.Web.targets no GitHub.

Pacote de instalação para desenvolvimento

O seguinte código executa 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 instalador do Windows

O script seguinte gera um instalador 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 Python

O script seguinte 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.

Resolver problemas de comandos personalizados

Revise as secções seguintes para possíveis problemas relacionados com o trabalho com comandos personalizados.

ficheiro de projeto não carregado

Esta mensagem de erro indica que tens erros de sintaxe no ficheiro do projeto. A mensagem inclui o erro específico com o número da linha e a posição do caractere.

Janela da consola fecha após a execução do comando

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

Se não vires o comando personalizado no menu contextual em Python , verifica os seguintes itens:

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

Eis um exemplo. No excerto XML seguinte, o Example nome no <PythonCommands> grupo de propriedades não corresponde ao ExampleCommand nome na <Target> definição do elemento. O Visual Studio não encontra um comando com nome Example, por isso não aparece nenhum comando. Ou use ExampleCommand na lista de comandos, ou altere o nome do alvo para apenas Example.

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

Erro ao executar o comando, falhou a obtenção do alvo do comando

Esta mensagem de erro indica que o conteúdo dos <Target> elementos ou <CreatePythonCommandItem> está incorreto.

Aqui estão algumas possíveis razões para este erro:

O atributo de elemento requerido <Target> está vazio.
O atributo requerido TargetType é vazio ou contém um valor não reconhecido.
O atributo requerido ExecuteIn é vazio ou contém um valor não reconhecido.
O atributo ErrorRegex ou WarningRegex é especificado sem a definição do atributo ExecuteIn="output".
Atributos não reconhecidos existem no elemento. Por exemplo, a referência ao atributo pode ser grafada incorretamente como Argumnets em vez de Arguments.

Os valores dos atributos podem estar vazios se te referires a uma propriedade indefinida. Se utilizar o token $(StartupFile), mas nenhum ficheiro de arranque estiver definido no projeto, o token traduz-se para uma string vazia. Nesses casos, pode querer definir um valor padrão. Por exemplo, os comandos Run server e Run debug server definidos nos templates de projeto Bottle, Flask e Django usam o ficheiro manage.py por defeito (se um ficheiro de arranque de servidor não estiver especificado nas propriedades do projeto).

O Visual Studio deixa de responder, crasha

Se o Visual Studio deixar de responder e crashar quando executas o comando personalizado, provavelmente estás a tentar executar um comando de consola com a ExecuteIn="output" definição de atributo. Nesses casos, o Visual Studio pode crashar ao tentar analisar a saída. Para evitar esta condição, use antes a ExecuteIn="console" definição de atributo. Para mais informações, consulte a Edição 3681.

Comando não reconhecido como programa operável ou ficheiro batch

Quando defines a TargetType="executable" definição do atributo, o valor no Target atributo deve ser apenas o nome do programa sem quaisquer argumentos, como python ou python.exe apenas. Neste caso, mova quaisquer argumentos para o Arguments atributo.

Feedback

Esta página foi útil?

Last updated on 2025-12-12

Partilhar via

Definir comandos personalizados para projetos Python no Visual Studio

Pré-requisitos

Explorar comandos personalizados

Recarregar o projeto para aceder a comandos personalizados

Adicionar comandos personalizados com ficheiro de projeto

Utilização das propriedades do projeto

Compreender <a estrutura do elemento alvo>

Atributos alvo

Atributos CreatePythonCommandItem

Grupos de captura nomeados para expressões regulares

Importar comandos personalizados com ficheiro de targets

Comandos de exemplo

Executar PyLint (destino do módulo)

Executar pip install com um pacote específico (pip como alvo)

Mostrar pacotes pip desatualizados (alvo pip)

Executar ficheiro executável com consolepause

Executar o servidor e executar comandos de depuração do servidor

Pacote de instalação para desenvolvimento

Gerar o instalador do Windows

Gerar pacote Wheel Python

Resolver problemas de comandos personalizados

ficheiro de projeto não carregado

Janela da consola fecha após a execução do comando

Comando em falta no menu

Erro ao executar o comando, falhou a obtenção do alvo do comando

O Visual Studio deixa de responder, crasha

Comando não reconhecido como programa operável ou ficheiro batch

Feedback

Recursos adicionais