Definición de comandos personalizados para proyectos de Python en Visual Studio

2025-06-12

A medida que desarrolle los proyectos de Python, es posible que cambie a una ventana de comandos para ejecutar scripts o módulos específicos, ejecutar comandos pip o usar otras herramientas con el código. Para mejorar el flujo de trabajo, puede agregar comandos personalizados al menú proyecto Python en Visual Studio. Los comandos personalizados de Python se pueden ejecutar en una ventana de consola o en la ventana salida de Visual Studio. También puede usar expresiones regulares para indicar a Visual Studio cómo analizar los errores y las advertencias de la salida del comando.

Prerrequisitos

Visual Studio en Windows instalado con compatibilidad con cargas de trabajo de Python. Para obtener más información, consulte Instalación de compatibilidad con Python en Visual Studio.

Visual Studio para Mac no es compatible. Para obtener más información, consulte ¿Qué ocurre con Visual Studio para Mac? Visual Studio Code en Windows, Mac y Linux funciona bien con Python a través de extensiones disponibles.

Exploración de comandos personalizados

De forma predeterminada, el menú Python proyecto contiene dos comandos, Ejecutar PyLint y Ejecutar Mypy:

Los comandos personalizados de Python que defina aparecen en este mismo menú. Un comando personalizado puede hacer referencia a un archivo de Python, un módulo de Python, código de Python insertado, un archivo ejecutable arbitrario o un comando pip. También puede especificar cómo y dónde se ejecuta el comando.

Puede agregar comandos personalizados de varias maneras:

Defina comandos personalizados en un archivo de proyecto de Python (.pyproj) directamente. Estos comandos se aplican a ese proyecto específico.
Defina comandos personalizados en un archivo de destino (.targets). Puede importar fácilmente los comandos de este archivo para usarlos con varios proyectos.
Cree un proyecto de Python a partir de una plantilla de proyecto en Visual Studio que defina comandos personalizados de Python.

Algunas plantillas de proyecto de Python en Visual Studio agregan comandos personalizados mediante un archivo de destinos. Las plantillas Proyecto web Bottle y Proyecto web Flask agregan dos comandos, Iniciar servidor y Iniciar servidor de depuración. La plantilla Proyecto web de Django agrega estos comandos y varios más:

Recarga del proyecto para acceder a comandos personalizados

Cuando un proyecto está abierto en Visual Studio, si realiza cambios en el archivo de proyecto correspondiente en un editor, debe volver a cargar el proyecto para aplicar los cambios. De forma similar, después de definir comandos personalizados de Python en un archivo de proyecto de Python, debe volver a cargar el proyecto de Python para que los comandos aparezcan en el menú proyecto de Python. Al modificar comandos personalizados definidos en un archivo de destino, debe recompilar la solución completa de Visual Studio para cualquier proyecto que importe ese archivo de destino.

Un enfoque común es realizar los cambios en el archivo de proyecto de Python directamente en Visual Studio:

Abra el proyecto de Python en Visual Studio. (Cuando se abre un proyecto en Visual Studio, el proyecto se carga de forma predeterminada).
En el Explorador de soluciones, haga clic con el botón derecho en el proyecto de Python y seleccione Descargar el proyecto.

Visual Studio descarga el proyecto y abre el archivo de proyecto de Python correspondiente (.pyproj) en el editor.

Si el archivo del proyecto no se abre, vuelva a hacer clic con el botón derecho en el proyecto de Python y seleccione Editar archivo de proyecto:
Realice los cambios en el archivo del proyecto en el editor de Visual Studio y guarde el trabajo.
En Explorador de soluciones, haga clic con el botón derecho en el proyecto no cargado y seleccione Volver a cargar el proyecto. Si intenta volver a cargar el proyecto sin guardar los cambios en el archivo del proyecto, Visual Studio le pedirá que complete la acción.

El proceso de "descargar-editar-guardar-recargar" puede resultar tedioso al desarrollar comandos personalizados. Un flujo de trabajo más eficaz implica cargar simultáneamente el proyecto en Visual Studio y abrir el archivo de proyecto de Python en un editor independiente. Puede usar cualquier editor, como otra instancia de Visual Studio, Visual Studio Code, bloc de notas, etc. Después de guardar los cambios en el editor y volver a Visual Studio, Visual Studio detecta los cambios del archivo de proyecto para el proyecto abierto y le pide que realice la acción:

Seleccione Volver a cargar o Volver a cargar todas las y Visual Studio aplica inmediatamente los cambios del archivo del proyecto al proyecto abierto.

Adición de comandos personalizados con el archivo de proyecto

En el procedimiento siguiente se muestra cómo crear un comando personalizado agregando la definición en el archivo de proyecto de Python (.pyproj) y recargando el proyecto en Visual Studio. El comando personalizado ejecuta directamente el archivo de inicio de un proyecto utilizando el comando python.exe, que es básicamente lo mismo que usar la opción Depurar>Iniciar sin depurar en la barra de herramientas principal de Visual Studio.

En Visual Studio, cree un nuevo proyecto de Python denominado Python-CustomCommands mediante la plantilla Aplicación de Python. Para obtener instrucciones, consulte Inicio rápido: Creación de un proyecto de Python a partir de una plantilla.

Visual Studio crea el proyecto de Python y lo carga en la sesión. Puede configurar el proyecto a través del archivo del proyecto (.pyproj). Este archivo solo está visible en Visual Studio cuando el proyecto está abierto, pero descargado. El proyecto también tiene un archivo de Python (.py) para el código de la aplicación.
Abra el archivo de aplicación Python_CustomCommands.py en el editor y agregue el código siguiente:
```
print("Hello custom commands")
```
En Explorador de soluciones, haga clic con el botón derecho en el proyecto de Python, seleccione Pythony observe los comandos en el menú contextual. Actualmente, los únicos comandos del menú contextual son Ejecutar pyLint y Ejecutar Mypy. Al definir comandos personalizados, también aparecen en este menú.
Inicie un editor independiente fuera de la sesión de Visual Studio y abra el archivo de proyecto de Python (Python-CustomCommands.pyproj) en el editor. (Asegúrese de abrir el archivo del proyecto (.pyproj) y no el archivo de aplicación de Python (.py).)
En el archivo del proyecto, busque el elemento de cierre </Project> al final del archivo y agregue el siguiente XML inmediatamente antes del elemento de cierre:
```
<PropertyGroup>
  <PythonCommands>
    $(PythonCommands);
  </PythonCommands>
</PropertyGroup>
```
Guarde los cambios del archivo del proyecto y vuelva a Visual Studio. Visual Studio detecta los cambios en el archivo del proyecto y le pide que realice una acción. En el símbolo del sistema, seleccione Volver a cargar para actualizar el proyecto abierto con los cambios del archivo del proyecto.
En Explorador de soluciones, haga clic con el botón derecho en el proyecto de Python, seleccione Pythony compruebe los comandos en el menú contextual.

El menú contextual todavía muestra solo los comandos Ejecutar pyLint y Ejecutar mypy. El código que acaba de agregar al archivo de proyecto simplemente replica el grupo de propiedades de <PythonCommands> predeterminado que contiene el comando PyLint. En el paso siguiente, agregará más código para el comando personalizado.
Cambie al editor donde va a actualizar el archivo del proyecto. Agregue la siguiente definición de elemento <Target> dentro del elemento <Project>. Puede colocar la definición de <Target> antes o después de la definición de <PropertyGroup> descrita anteriormente.

Este elemento <Target> define un comando personalizado para ejecutar el archivo de inicio del proyecto (identificado por la propiedad StartupFile) mediante el comando python.exe en una ventana de consola. La definición de atributo ExecuteIn="consolepause" usa una consola que espera a que seleccione una clave para cerrar la ventana de la 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>
```
Reemplace el grupo de propiedades <PythonCommands> (agregado en paso 5) por el siguiente XML. Esta sintaxis define el atributo Name para el elemento <Target>, que agrega el comando personalizado al menú contextual Python. El comando tiene la etiqueta de menú Ejecutar archivo de inicio.
```
  <PythonCommands>
    $(PythonCommands);
    Example_RunStartupFile
  </PythonCommands>
```
Sugerencia

Si desea que el comando personalizado aparezca en el menú contextual antes de los comandos predeterminados definidos en el token de $(PythonCommands), coloque la sintaxis <Target> para el comando antes de ese token.
Guarde los cambios del archivo del proyecto y vuelva a Visual Studio. Cuando se le indique, vuelva a cargar su proyecto.
En Explorador de soluciones, haga clic con el botón derecho en el proyecto de Python, seleccione Pythony vuelva a comprobar los comandos en el menú contextual.

Ahora el comando Ejecutar archivo de inicio personalizado está en el menú. Si no ve el comando personalizado, confirme que agregó el valor del atributo Name para el elemento <Target> al elemento <PythonCommands> tal como se describe en paso 9. Revise también las consideraciones enumeradas en la sección Solución de problemas más adelante en este artículo.
Seleccione el comando Ejecutar archivo de inicio. Se abre una ventana de consola y muestra el texto Hola comandos personalizados seguido de Pulse cualquier tecla para continuar. Confirme la salida y cierre la ventana de la consola.

Nota

El script de comandos personalizado se ejecuta en el entorno activado para el proyecto de Python.
Cambiar al editor que contiene el archivo del proyecto. En la definición del elemento <Target> (agregado en paso 8), cambie el valor del atributo ExecuteIn a output.
```
  <CreatePythonCommandItem
    ...
    ExecuteIn="output">
    ...
  </CreatePythonCommandItem>
```
Guarde los cambios, vuelva a Visual Studio y vuelva a cargar el proyecto.
Seleccione de nuevo el comando personalizado Ejecutar archivo de inicio en el menú contextual de Python. Ahora la salida del programa aparece en la ventana de Visual Studio Output en lugar de en una ventana de consola.
Para agregar más comandos personalizados, siga este mismo proceso:
1. Defina un elemento <Target> adecuado para el comando personalizado en el archivo del proyecto.
2. Agregue el valor del atributo Name para el elemento <Target> al grupo de propiedades <PythonCommands>.
3. Guarde los cambios en el archivo del proyecto.
4. Vuelva a cargar el proyecto en Visual Studio.

Uso de propiedades del proyecto

Para referirse a las propiedades del proyecto o a las variables de entorno en los valores de atributo del elemento <Target>, utilice el nombre de la propiedad dentro de un token $(), como $(StartupFile) y $(MSBuildProjectDirectory). Para obtener más información, consulte las propiedades de MSBuild .

Si invoca un comando como ($StartupFile) que usa propiedades del proyecto como la propiedad StartupFile y se produce un error en el comando porque el token no está definido, Visual Studio deshabilita el comando hasta que se vuelve a cargar el proyecto. Si realiza cambios en el proyecto que modifica la definición de propiedad, los cambios no actualizan el estado del comando relacionado. En este caso, debe volver a cargar el proyecto.

Comprender la estructura del elemento <Objetivo>

Los detalles de un comando personalizado se definen mediante el elemento <Target>. La forma general del elemento <Target> se muestra en el siguiente 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 de destino

En la tabla siguiente se enumeran los atributos del elemento <Target>.

Atributo	Obligatorio	Descripción
`Name`	Sí	Identificador del comando dentro del proyecto de Visual Studio. Este nombre debe agregarse al grupo de propiedades `<PythonCommands>` para que el comando aparezca en el menú contextual Python.
`Label`	Sí	Nombre para mostrar de la interfaz de usuario que aparece en el menú contextual de Python.
`Returns`	Sí	La información devuelta, que debe contener el token `@(Commands)`, que identifica el objetivo como un comando.

Atributos de CreatePythonCommandItem

El elemento <Target> contiene elementos <CreatePythonCommandItem> y <Output>, que definen el comportamiento detallado del comando personalizado. En la tabla siguiente se enumeran los atributos de elemento <CreatePythonCommandItem> disponibles. Ninguno de los valores de atributo distingue entre mayúsculas y minúsculas.

`Attribute`	Obligatorio	Descripción
`TargetType`	Sí	Especifica qué contiene el atributo `Target` y cómo se usa el valor junto con el atributo `Arguments`: - `executable`: ejecute el archivo ejecutable denominado en el atributo `Target`, anexando el valor en el atributo `Arguments`, como si se especificara directamente en la línea de comandos. El valor debe contener solo un nombre de programa sin argumentos. - `script`: ejecute el comando `python.exe` con el nombre de archivo en el atributo `Target`, seguido del valor del atributo `Arguments`. - `module`: ejecute el comando `python -m` seguido del nombre del módulo en el atributo `Target`, seguido del valor del atributo `Arguments`. - `code`: Ejecuta el código contenido en el atributo `Target`. Omita el valor del atributo `Arguments`. - `pip`: ejecute pip con el comando en el atributo `Target`, seguido del valor del atributo `Arguments`. Si el atributo `ExecuteIn` se establece en `output`, pip supone que la solicitud es ejecutar el comando `install` y usa el atributo `Target` como nombre del paquete.
`Target`	Sí	Especifica el nombre de archivo, el nombre del módulo, el código o el comando pip que se va a usar, según el valor del atributo `TargetType`.
`Arguments`	Opcional	Proporciona una cadena de argumentos (si existe) que se va a usar con el atributo `Target`. - Cuando el valor del atributo `TargetType` es `script`, el valor `Arguments` se proporciona al programa python en lugar del comando `python.exe`. - Cuando el valor del atributo `TargetType` es `code`, se omite el valor de `Arguments`.
`ExecuteIn`	Sí	Especifica el entorno en el que se va a ejecutar el comando: - `console`: (valor predeterminado) Ejecuta el atributo `Target` con el valor de `Arguments` como si se especificaran directamente en la línea de comandos. Mientras se ejecuta el atributo `Target`, aparece una ventana de comandos y se cierra automáticamente. - `consolepause`: El mismo comportamiento que `console`, pero espera a que se presione una tecla antes de cerrar la ventana. - `output`: ejecuta el atributo `Target` y muestra los resultados en la ventana Salida de Visual Studio. Si el atributo `TargetType` es `pip`, Visual Studio usa el atributo `Target` como nombre del paquete y anexa el valor del atributo `Arguments`. - `repl`: ejecuta el atributo `Target` en la ventana interactiva de Python . El nombre opcional para mostrar se usa para el título de la ventana. - `none`: el mismo comportamiento que `console`.
`WorkingDirectory`	Opcional	Identifica la carpeta en la que se va a ejecutar el comando.
`ErrorRegex` `WarningRegEx`	Opcional	Solo se usa cuando el atributo `ExecuteIn` se establece en `output`. Ambos valores de atributo especifican una expresión regular que Visual Studio usa para analizar la salida del comando y mostrar errores y advertencias en la ventana Lista de errores. Si no se especifican estos atributos, el comando no afecta a la ventana Lista de errores. Para más información sobre qué espera Visual Studio, vea Grupos de capturas con nombre.
`RequiredPackages`	Opcional	Proporciona una lista de requisitos de paquete para el comando con el mismo formato que el archivo requirements.txt (pip.readthedocs.io). Por ejemplo, el comando Ejecutar PyLint especifica el formato `pylint>=1.0.0`. Antes de ejecutar el comando, Visual Studio confirma que se instalan todos los paquetes de la lista. Visual Studio usa pip para instalar los paquetes que faltan.
`Environment`	Opcional	Identifica una cadena de variables de entorno que se van a definir antes de ejecutar el comando. Cada variable usa el formulario `\<NAME>=\<VALUE>` con varias variables separadas por punto y coma. Una variable con varios valores debe estar contenida en comillas simples o dobles, como en `'NAME=VALUE1;VALUE2'`.

Grupos de capturas con nombre de expresiones regulares

Cuando Visual Studio analiza los errores y las advertencias de la salida del comando personalizado, espera que las expresiones regulares en los valores de atributo ErrorRegex y WarningRegex deban usar los siguientes nombres de grupos:

(?<message>...): texto del error.
(?<code>...): valor de código de error.
(?<filename>...): nombre del archivo para el que se notifica el error.
(?<line>...): número de línea de la ubicación en el archivo para el que se notifica el error.
(?<column>...): número de columna de la ubicación en el archivo para el que se notifica el error.

Por ejemplo, PyLint genera advertencias del siguiente formato:

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

Para permitir que Visual Studio extraiga la información correcta de estas advertencias y mostrarla en la ventana lista de errores de, el valor del atributo WarningRegex para el comando Ejecutar Pylint es el siguiente:

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

Nota

La sintaxis msg_id del valor del atributo WarningRegex debe ser code, tal como se describe en Incidencia 3680.

Importar comandos personalizados con un archivo de objetivos

Si define comandos personalizados en un archivo de proyecto de Python, los comandos solo están disponibles para ese proyecto específico. Cuando quiera crear comandos personalizados y usarlos en varios proyectos, puede definir el grupo de propiedades <PythonCommands> con todos los elementos <Target> de un archivo de destino (.targets) e importar ese archivo en los proyectos de Python.

El archivo de destinos usa el mismo formato y sintaxis para definir comandos personalizados como se describe para el archivo de proyecto de Python (.pyproj). Los elementos comunes que se van a configurar incluyen <PythonCommands>, <Target>, <CreatePythonCommandItem>y <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 un archivo de destino en el proyecto, agregue un elemento <Import Project="(path)"> en cualquier parte del elemento <Project> del archivo del proyecto.

Por ejemplo, si tiene un archivo de proyecto denominado CustomCommands.targets en una carpeta destinos dentro del proyecto de Python, agregue el código siguiente al archivo de proyecto:
```
<Import Project="targets/CustomCommands.targets"/>
```
Si el archivo del proyecto importa un archivo de objetivos y realiza cambios en el archivo de objetivos mientras el proyecto está abierto en Visual Studio, debe Recompilar la solución de Visual Studio que contiene el proyecto y no solo el proyecto.

Comandos de ejemplo

En las secciones siguientes se proporciona código de ejemplo que puede usar para definir comandos personalizados para los proyectos de Python.

Ejecución de PyLint (destino del módulo)

Aparece el siguiente código en el archivo 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>

Ejecutar pip install con un paquete específico (Target: pip)

El comando siguiente ejecuta el comando pip install my-package en la ventana Salida de Visual Studio. Puede usar un comando como este al desarrollar un paquete y probar su instalación. El elemento <Target> contiene el nombre del paquete en lugar del comando install, que se supone cuando se usa la definición de 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 paquetes de pip obsoletos (Target: pip)

El siguiente comando ejecuta pip con la función list para identificar paquetes pip obsoletos:

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

Ejecutar un archivo ejecutable con consolepause

El siguiente comando ejecuta la función where para mostrar la ubicación de los archivos de Python a partir de la carpeta del proyecto:

<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 Iniciar servidor e Iniciar el servidor de depuración

Para explorar cómo se definen los comandos Iniciar servidor y Iniciar servidor de depuración para proyectos web, examine el repositorio Microsoft.PythonTools.Web.targets en GitHub.

Instalación del paquete para el desarrollo

El código siguiente ejecuta pip para instalar paquetes:

<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 con permiso.

Generar el instalador de Windows

El script siguiente genera un instalador de 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), utilizado con permiso.

Generación de un paquete wheel de Python

El siguiente script genera un paquete wheel de 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), utilizado con permiso.

Solución de problemas de comandos personalizados

Revise las secciones siguientes para ver posibles problemas relacionados con el trabajo con comandos personalizados.

Archivo de proyecto no cargado

Este mensaje de error indica que tiene errores de sintaxis en el archivo del proyecto. El mensaje refleja el error específico con un número de línea y una posición de carácter.

La ventana de consola se cierra después de que se ejecute el comando

Si la ventana de consola se cierra inmediatamente después de ejecutar el comando, use la definición de atributo ExecuteIn="consolepause" en lugar de ExecuteIn="console".

Si no ve el comando personalizado en el menú contextual de Python, compruebe los siguientes elementos:

Confirme que el comando se incluye en el grupo de propiedades <PythonCommands>.
Compruebe que el nombre del comando tal como se define en la lista de comandos coincide con el nombre especificado en el elemento <Target>.

Este es un ejemplo. En el siguiente fragmento XML, el nombre del Example del grupo de propiedades <PythonCommands> no coincide con el nombre de ExampleCommand en la definición del elemento <Target>. Visual Studio no encuentra un comando denominado Example, por lo que no aparece ningún comando. Use ExampleCommand en la lista de comandos o cambie el nombre del destino para que solo sea Example.

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

Error al ejecutar el comando, no se pudo obtener el destino del comando

Este mensaje de error indica que el contenido de los elementos <Target> o <CreatePythonCommandItem> son incorrectos.

Estos son algunos de los motivos posibles de este error:

El atributo de elemento <Target> necesario está vacío.
El atributo TargetType necesario está vacío o contiene un valor no reconocido.
El atributo ExecuteIn necesario está vacío o contiene un valor no reconocido.
El atributo ErrorRegex o WarningRegex se especifica sin establecer la definición de atributo ExecuteIn="output".
Los atributos no reconocidos existen en el elemento . Por ejemplo, la referencia de atributo podría estar mal escrita como Argumnets en lugar de Arguments.

Los valores de atributo pueden estar vacíos si hace referencia a una propiedad que no está definida. Si usa el token $(StartupFile) pero no se define ningún archivo de inicio en el proyecto, el token se resuelve en una cadena vacía. En tales casos, es posible que desee definir un valor predeterminado. Por ejemplo, los comandos Ejecutar servidor y Ejecutar servidor de depuración definidos en las plantillas de proyecto Bottle, Flask y Django usan el archivo manage.py de forma predeterminada (si no se especifica un archivo de inicio del servidor en las propiedades del proyecto).

Visual Studio deja de responder, se bloquea

Si Visual Studio deja de responder y se bloquea al ejecutar el comando personalizado, es probable que intente ejecutar un comando de consola con la definición de atributo ExecuteIn="output". En tales casos, Visual Studio podría bloquearse cuando intenta analizar la salida. Para evitar esta condición, use la definición de atributo ExecuteIn="console" en su lugar. Para obtener más información, vea Incidencia 3681.

Comando no reconocido como programa o archivo por lotes que pueda ejecutarse

Al establecer la definición de atributo TargetType="executable", el valor del atributo Target debe ser solo el nombre del programa sin ningún argumento, solo como python o python.exe. En este caso, mueva los argumentos al atributo Arguments.

Compartir a través de