Definir comandos personalizados para proyectos de Python en Visual Studio

Artículo
04/23/2024

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

Requisitos previos

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

Visual Studio para Mac no se admite. Para obtener más información, consulte ¿Qué sucede 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ú del proyecto de Python 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, a un módulo de Python, a código de Python en línea, a un archivo ejecutable al azar o a un comando de 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 destinos (.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 de Bottle y Proyecto web de Flask agregan dos comandos, Iniciar servidor e Iniciar el servidor de depuración. La plantilla Proyecto web de Django agrega esos comandos y unos cuantos más:

Volver a cargar el 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 destinos, 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 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 de proyecto en el editor de Visual Studio y guarde el trabajo.
En el Explorador de soluciones, haga clic con el botón derecho en el proyecto descargado y seleccione Volver a cargar el proyecto. Si intenta volver a cargar el proyecto sin guardar los cambios en el archivo de proyecto, Visual Studio le pedirá que complete la acción.

El proceso unload-edit-save-reload 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 todo 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 volviendo a cargar el proyecto en Visual Studio. El comando personalizado ejecuta directamente el archivo de inicio de un proyecto mediante el comandopython.exe, que es básicamente lo mismo que usar la opción Depurar>Iniciar sin depuración en la barra de herramientas principal de Visual Studio.

En Visual Studio, cree un nuevo proyecto de Python con el nombre Python-CustomCommands con la plantilla Aplicación de Python. Para obtener instrucciones, consulte la Guía de inicio rápido: Crear 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 de 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 el Explorador de soluciones, haga clic con el botón derecho en el proyecto de Python, seleccione Python y 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 de proyecto (.pyproj) y no el archivo de aplicación de Python (.py).)
En el archivo del proyecto, busque el elemento </Project> de cierre 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 de proyecto y le solicita 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 de proyecto.
En el Explorador de soluciones, haga clic con el botón derecho en el proyecto de Python, seleccione Python y 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 predeterminado <PythonCommands> 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 del 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 el paso 5) por el siguiente XML. Esta sintaxis define el atributo Name para el elemento <Target>, y esto agrega el comando personalizado al menú contextual de 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 $(PythonCommands), coloque la sintaxis <Target> del comando antes de ese token.
Guarde los cambios del archivo del proyecto y vuelva a Visual Studio. En el símbolo del sistema, vuelva a cargar el proyecto.
En el Explorador de soluciones, haga clic con el botón derecho en el proyecto de Python, seleccione Python y vuelva a comprobar los comandos en el menú contextual.

Ahora el comando personalizado Ejecutar archivo de inicio 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 el 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 se muestra el texto Hello custom commands (Hola comandos personalizados) seguido de Press any key to continue (Presionar 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.
Cambie al editor con el archivo del proyecto. En la definición del elemento <Target> (agregado en el 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 Salida de Visual Studio 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 de atributo Name del elemento <Target> al grupo de propiedades <PythonCommands>.
3. Guarde los cambios realizados en el archivo del proyecto.
4. Vuelva a cargar el proyecto en Visual Studio.

Usar las propiedades del proyecto

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

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

Descripción de la estructura del elemento <Target>

Los detalles de un comando personalizado se definen mediante el elemento <Target>. En el siguiente pseudocódigose muestra la forma general del elemento <Target>:

<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 de Python.
`Label`	Sí	Nombre para mostrar de 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 destino como un comando.

Atributos CreatePythonCommandItem

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

`Attribute`	Obligatorio	Descripción
`TargetType`	Sí	Especifica lo que el atributo `Target` contiene y cómo se usa el valor junto con el atributo `Arguments`: - `executable`: se ejecuta el archivo ejecutable mencionado en el atributo `Target`, lo que anexa el valor en el atributo `Arguments`, como si se insertara directamente en la línea de comandos. El valor debe contener solo un nombre de programa, sin argumentos. - `script`: se ejecuta el comando `python.exe` con el nombre de archivo en el atributo `Target`, seguido del valor del atributo `Arguments`. - `module`: se ejecuta el comando `python -m` seguido del nombre del módulo en el atributo `Target`, seguido del valor del atributo `Arguments`. - `code`: se ejecuta el código insertado incluido en el atributo `Target`. Omita el valor del atributo `Arguments`. - `pip`: se ejecuta 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, en función del valor del atributo `TargetType`.
`Arguments`	Opcionales	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 de Python en lugar del comando `python.exe`. - Cuando el valor del atributo `TargetType` es `code`, se omite el valor `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 `Arguments` como si se escribiera 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 se espera a que se presione una tecla para cerrar la ventana. - `output`: ejecuta el atributo `Target` y muestra los resultados en la ventana Resultados 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 para mostrar opcional se usa para el título de la ventana. - `none`: el mismo comportamiento que `console`.
`WorkingDirectory`	Opcionales	Identifica la carpeta en la que se va a ejecutar el comando.
`ErrorRegex` `WarningRegEx`	Opcionales	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 los resultados del comando y mostrar los errores y las 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`	Opcionales	Proporciona una lista de requisitos de paquete del comando con el uso del mismo formato que en el archivo requirements.txt (pip.readthedocs.io). Por ejemplo, el comando Ejecutar PyLint especifica `pylint>=1.0.0`. Antes de ejecutar el comando, Visual Studio confirma que todos los paquetes que figuran en la lista están instalados. Visual Studio usa pip para instalar los paquetes que faltan.
`Environment`	Opcionales	Identifica una cadena de variables de entorno que hay que definir antes de ejecutar el comando. Cada variable usa el formato `\<NAME>=\<VALUE>` con varias variables separadas por punto y coma. Una variable con varios valores debe incluirlos entre comillas simples o dobles, por ejemplo, `'NAME=VALUE1;VALUE2'`.

Grupos de capturas con nombre de expresiones regulares

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

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

Por ejemplo, PyLint muestra advertencias de la siguiente forma:

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

Para permitir que Visual Studio extraiga la información correcta de esas advertencias y las muestre en la ventana Lista de errores, el valor de atributo WarningRegex en 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 en realidad code, como se describe en el problema 3680.

Importar comandos personalizados con archivos de destinos

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) y, a continuación, importar ese archivo en los proyectos de Python.

El archivo de destinos usa el mismo formato y sintaxis para definir comandos personalizados que 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 destinos en el proyecto, agregue un elemento <Import Project="(path)"> en cualquier parte del elemento del archivo del proyecto <Project>.

Por ejemplo, si tiene un archivo de proyecto denominado CustomCommands.targets en una carpeta targets del proyecto de Python, agregue el siguiente código al archivo del proyecto:
```
<Import Project="targets/CustomCommands.targets"/>
```
Si el archivo del proyecto importa un archivo de destino y realiza cambios en el archivo de destinos 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.

Ejecutar PyLint (Target: module)

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 (pip target)

El comando siguiente ejecuta el comando pip install my-package en la ventana Salida de Visual Studio. Puede usar un comando de este tipo 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, empezando por 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 saber cómo se definen los comandos Iniciar servidor e Iniciar el servidor de depuración en los proyectos web, eche un vistazo al repositorio Microsoft.PythonTools.Web.targets de GitHub.

Instalar el paquete para desarrollo

El siguiente código 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), usado con permiso.

Generar un paquete Wheel de Python

El script siguiente 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), usado con permiso.

Solución 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 hay errores de sintaxis en el archivo de 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 la consola se cierra después de que el comando se ejecute

Si la ventana de consola se cierra inmediatamente después de ejecutar el comando, use la definición de atributoExecuteIn="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 Example del grupo de propiedades <PythonCommands> no coincide con el nombre ExampleCommand de la definición del elemento <Target>. Visual Studio no encuentra un comando llamado Example, así que no se muestra ningún comando. Use ExampleCommand en la lista de comandos, o bien cambie el nombre del destino a sencillamente 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> es incorrecto.

Estos son algunos de los posibles motivos de este error:

El atributo del 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".
Existen atributos no reconocidos 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 se hace referencia a una propiedad que no está definida. Si usa el token $(StartupFile), pero no se ha definido ningún archivo de inicio en el proyecto, el token se resuelve como una cadena vacía. En tales casos, conviene definir un valor predeterminado. Por ejemplo, los comandos Iniciar servidor e Iniciar el servidor de depuración definidos en las plantillas de proyecto de Bottle, Flask y Django usan forma predeterminada el archivo manage.py (si no se ha especificado un archivo de inicio del servidor en las propiedades del proyecto).

Visual Studio deja de responder y 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", alternativamente. Para obtener más información, consulte el problema 3681.

Comando no reconocido como archivo por lotes o programa operable

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

Compartir a través de

Definir comandos personalizados para proyectos de Python en Visual Studio

Requisitos previos

Exploración de comandos personalizados

Volver a cargar el proyecto para acceder a comandos personalizados

Adición de comandos personalizados con el archivo de proyecto

Usar las propiedades del proyecto

Descripción de la estructura del elemento <Target>

Atributos de destino

Atributos CreatePythonCommandItem

Grupos de capturas con nombre de expresiones regulares

Importar comandos personalizados con archivos de destinos

Comandos de ejemplo

Ejecutar PyLint (Target: module)

Ejecutar pip install con un paquete específico (pip target)

Mostrar paquetes de pip obsoletos (Target: pip)

Ejecutar un archivo ejecutable con consolepause

Comandos Iniciar servidor e Iniciar el servidor de depuración

Instalar el paquete para desarrollo

Generar el instalador de Windows

Generar un paquete Wheel de Python

Solución de comandos personalizados

Archivo de proyecto no cargado

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

Falta el comando en el menú

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

Visual Studio deja de responder y se bloquea

Comando no reconocido como archivo por lotes o programa operable

Comentarios

Comentarios

Recursos adicionales