Definování vlastních příkazů pro projekty Pythonu v sadě Visual Studio

Při vývoji projektů Pythonu můžete přejít do příkazového okna, kde můžete spouštět konkrétní skripty nebo moduly, spouštět příkazy pip nebo používat jiné nástroje s vaším kódem. Pokud chcete vylepšit pracovní postup, můžete do nabídky projektu Pythonu v sadě Visual Studio přidat vlastní příkazy. Vlastní příkazy Pythonu se můžou spouštět v okně konzoly nebo v okně Výstup sady Visual Studio. Pomocí regulárních výrazů také můžete sadě Visual Studio dát pokyn, jak analyzovat chyby a upozornění z výstupu příkazu.

Požadavky

Visual Studio ve Windows nainstalované s podporou úloh Pythonu Další informace najdete v tématu Instalace podpory Pythonu v sadě Visual Studio.

Visual Studio pro Mac se nepodporuje. Visual Studio Code ve Windows, Mac a Linuxu funguje dobře s Pythonem prostřednictvím dostupných rozšíření.

Prozkoumání vlastních příkazů

Ve výchozím nastavení obsahuje nabídka projektu Pythonu dva příkazy: Spustit PyLint a Spustit Mypy:

Všechny vlastní příkazy Pythonu, které definujete, se zobrazí ve stejné nabídce. Vlastní příkaz může odkazovat na soubor Pythonu, modul Pythonu, vložený kód Pythonu, libovolný spustitelný soubor nebo příkaz pip. Můžete také určit, jak a kde se příkaz spouští.

Vlastní příkazy můžete přidat několika způsoby:

Definujte vlastní příkazy přímo v souboru projektu Pythonu (.pyproj). Tyto příkazy platí pro tento konkrétní projekt.
Definujte vlastní příkazy v souboru cílů (.targets). Příkazy v tomto souboru můžete snadno importovat, abyste je mohli použít s více projekty.
Vytvořte projekt Pythonu ze šablony projektu v sadě Visual Studio, který definuje vlastní příkazy Pythonu.

Některé šablony projektů Pythonu v sadě Visual Studio přidávají vlastní příkazy pomocí souboru cílů. Šablony webového projektu Bottle a Flask Web Projectu přidávají dva příkazy: Start server a Spustit ladicí server. Šablona webového projektu Django přidá tyto příkazy a několik dalších:

Opětovné načtení projektu pro přístup k vlastním příkazům

Pokud je projekt otevřený v sadě Visual Studio a provedete změny v odpovídajícím souboru projektu v editoru, musíte projekt znovu načíst, aby se změny použily. Podobně je potřeba po definování vlastních příkazů Pythonu v souboru projektu Pythonu znovu načíst projekt Pythonu, aby se příkazy zobrazily v nabídce projektu Pythonu . Při úpravě vlastních příkazů definovaných v souboru cílů je nutné znovu sestavit úplné řešení sady Visual Studio pro všechny projekty, které importuje soubor cíle.

Běžným přístupem je provést změny souboru projektu Pythonu přímo v sadě Visual Studio:

Otevřete projekt Python v prostředí Visual Studio. (Když otevřete projekt v sadě Visual Studio, projekt se ve výchozím nastavení načte.)
V Průzkumníku řešení klikněte pravým tlačítkem na projekt Pythonu a vyberte Uvolnit projekt.

Visual Studio rozbalí projekt a otevře odpovídající soubor projektu Pythonu (.pyproj) v editoru.

Pokud se soubor projektu neotevře, znovu klikněte pravým tlačítkem myši na projekt Pythonu a vyberte Upravit soubor projektu:
Proveďte změny v souboru projektu v editoru sady Visual Studio a uložte svoji práci.
V Průzkumníku řešení klikněte pravým tlačítkem na uvolněný projekt a vyberte Znovu načíst projekt. Pokud se pokusíte projekt znovu načíst bez uložení změn v souboru projektu, Visual Studio vás vyzve k dokončení akce.

Proces unload-edit-save-reload se může stát zdlouhavým při vývoji vlastních příkazů. Efektivnější pracovní postup zahrnuje souběžné načítání projektu v sadě Visual Studio a otevření souboru projektu Pythonu v samostatném editoru. Můžete použít libovolný editor, například jinou instanci sady Visual Studio, Visual Studio Code, Poznámkový blok atd. Po uložení změn v editoru a přepnutí zpět do sady Visual Studio sada Visual Studio rozpozná změny souboru projektu pro otevřený projekt a vyzve vás k provedení akce:

Vyberte Znovu načíst nebo Znovu načíst vše a Visual Studio okamžitě použije změny souboru projektu na otevřený projekt.

Přidání vlastních příkazů se souborem projektu

Následující postup ukazuje, jak vytvořit vlastní příkaz přidáním definice do souboru projektu Pythonu (.pyproj) a opětovným načtením projektu v sadě Visual Studio. Vlastní příkaz spustí spouštěcí soubor projektu přímo pomocí příkazu python.exe, což je v podstatě totéž jako použití možnosti Ladění>bez ladění na hlavním panelu sady nástrojů Visual Studio.

V sadě Visual Studio vytvořte nový projekt Pythonu s názvem Python-CustomCommands pomocí šablony aplikace Pythonu . Pokyny najdete v tématu Rychlý start: Vytvoření projektu Pythonu ze šablony.

Visual Studio vytvoří projekt Pythonu a načte ho do vaší relace. Projekt můžete nakonfigurovat prostřednictvím souboru projektu (.pyproj). Tento soubor je viditelný v sadě Visual Studio pouze tehdy, když je projekt otevřený, ale neaktivní. Projekt má také soubor Pythonu (.py) pro kód aplikace.
Otevřete soubor Python_CustomCommands.py aplikace v editoru a přidejte následující kód:
```
print("Hello custom commands")
```
V Průzkumníku řešení klikněte pravým tlačítkem na projekt Pythonu, vyberte Python a všimněte si příkazů v místní nabídce. V současné době jsou jedinými příkazy v místní nabídce Spustit PyLint a Spustit Mypy. Když definujete vlastní příkazy, zobrazí se také v této nabídce.
Spusťte samostatný editor mimo instanci sady Visual Studio a v editoru otevřete soubor projektu Pythonu (Python-CustomCommands.pyproj). (Nezapomeňte otevřít soubor projektu (.pyproj) a ne soubor aplikace Pythonu (.py).)
V souboru projektu vyhledejte koncový </Project> prvek na konci souboru a přidejte následující XML bezprostředně před uzavírací prvek:
```
<PropertyGroup>
  <PythonCommands>
    $(PythonCommands);
  </PythonCommands>
</PropertyGroup>
```
Uložte změny souboru projektu a přepněte zpět do sady Visual Studio. Visual Studio zjistí změny souboru projektu a vyzve vás k provedení akce. Na příkazovém řádku vyberte Znovu načíst a aktualizujte otevřený projekt se změnami souboru projektu.
V Průzkumníku řešení klikněte pravým tlačítkem na projekt Pythonu, vyberte Python a zkontrolujte příkazy v místní nabídce.

V místní nabídce se stále zobrazují pouze příkazy Spustit PyLint a Spustit mypy . Kód, který jste právě přidali do souboru projektu, jednoduše replikuje výchozí <PythonCommands> skupinu vlastností, která obsahuje příkaz PyLint . V dalším kroku přidáte další kód pro vlastní příkaz.
Přepněte do editoru, do kterého aktualizujete soubor projektu. Do elementu přidejte následující <Target> definici elementu <Project> . Definici <Target> můžete umístit před definici popsanou <PropertyGroup> výše nebo za ji.

Tento <Target> element definuje vlastní příkaz pro spuštění souboru pro projekt (identifikovaný vlastností StartupFile ) pomocí python.exe příkazu v okně konzoly. Definice ExecuteIn="consolepause" atributu používá konzolu, která počká, až vyberete klíč pro zavření okna konzoly.
```
<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>
```
<PythonCommands> Nahraďte skupinu vlastností (přidanou v kroku 5) následujícím kódem XML. Tato syntaxe definuje Name atribut pro <Target> element, který přidá vlastní příkaz do kontextové nabídky Python. Příkaz má štítek nabídky Spustit spouštěcí soubor.
```
  <PythonCommands>
    $(PythonCommands);
    Example_RunStartupFile
  </PythonCommands>
```
Návod

Pokud chcete, aby se váš vlastní příkaz zobrazoval v místní nabídce před výchozími příkazy definovanými v tokenu $(PythonCommands) , umístěte <Target> před tento token syntaxi příkazu.
Uložte změny souboru projektu a přepněte zpět do sady Visual Studio. Na příkazovém řádku znovu načtěte projekt.
V Průzkumníku řešení klikněte pravým tlačítkem na projekt Pythonu, vyberte Python a znovu zkontrolujte příkazy v místní nabídce.

Teď je v nabídce vlastní příkaz Spustit spouštěcí soubor . Pokud vlastní příkaz nevidíte, potvrďte, že jste přidali hodnotu atributu Name elementu <Target> do elementu <PythonCommands>, jak je popsáno v kroku 9. Projděte si také aspekty uvedené v části Řešení potíží dále v tomto článku.
Vyberte příkaz Spustit spouštěcí soubor . Otevře se okno konzoly a zobrazí text Hello custom commands následovaný stisknutím libovolné klávesy. Potvrďte výstup a zavřete okno konzoly.

Poznámka:

Vlastní příkazový skript se spustí v aktivovaném prostředí pro váš projekt Pythonu.
Přepněte do editoru se souborem projektu. V definici elementu <Target> (přidáno v kroku 8) změňte hodnotu atributu ExecuteIn na output.
```
  <CreatePythonCommandItem
    ...
    ExecuteIn="output">
    ...
  </CreatePythonCommandItem>
```
Uložte změny, přepněte zpět do sady Visual Studio a znovu načtěte projekt.
V místní nabídce Pythonu znovu vyberte vlastní příkaz Spustit spouštěcí soubor. Teď se výstup programu zobrazí v okně Výstup sady Visual Studio místo okna konzoly:
Pokud chcete přidat další vlastní příkazy, postupujte stejným způsobem:
1. Definujte vhodný <Target> prvek pro vlastní příkaz v souboru projektu.
2. Přidejte hodnotu atributu Name<Target> prvku do <PythonCommands> skupiny vlastností.
3. Uložte změny do souboru projektu.
4. Znovu načtěte projekt v sadě Visual Studio.

Použití vlastností projektu

Chcete-li odkazovat na vlastnosti projektu nebo proměnné prostředí v <Target> hodnotách atributů elementu, použijte název vlastnosti v tokenu $() , například $(StartupFile) a $(MSBuildProjectDirectory). Další informace naleznete v tématu vlastnosti nástroje MSBuild.

Pokud vyvoláte příkaz podobný ($StartupFile) tomu, který používá vlastnosti projektu, jako je vlastnost StartupFile , a příkaz selže, protože token není definován, Visual Studio příkaz zakáže, dokud projekt znovu nenačtete. Pokud v projektu provedete změny, které upravují definici vlastnosti, změny neaktualizuje stav souvisejícího příkazu. V takovém případě stále potřebujete projekt znovu načíst.

Pochopit strukturu elementu <Target>

Podrobnosti pro vlastní příkaz definujete pomocí elementu <Target>. Obecná forma elementu je zobrazena v následujícím pseudokódu <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>

Cílové atributy

Následující tabulka uvádí atributy elementu <Target> .

Vlastnost	Povinné	Description
`Name`	Ano	Identifikátor příkazu v projektu sady Visual Studio. Tento název musí být přidán do `<PythonCommands>` skupiny vlastností, aby se příkaz zobrazil v místní nabídce Pythonu .
`Label`	Ano	Název UI, který se zobrazí v místní nabídce Pythonu.
`Returns`	Ano	Vrácené informace musí obsahovat token `@(Commands)`, který označuje cíl jako příkaz.

Atributy CreatePythonCommandItem

Element <Target> obsahuje <CreatePythonCommandItem> a <Output> elementy, které definují podrobné chování vlastního příkazu. Následující tabulka uvádí dostupné <CreatePythonCommandItem> atributy elementu. Hodnoty všech atributů jsou nezávislé na velikosti písmen.

`Attribute`	Povinné	Description
`TargetType`	Ano	Určuje, co `Target` atribut obsahuje a jak se hodnota používá spolu s atributem `Arguments` : - `executable`: Spusťte spustitelný soubor pojmenovaný v atributu `Target` a připojte hodnotu v atributu `Arguments` , jako by byl zadán přímo na příkazovém řádku. Hodnota musí obsahovat pouze název programu bez argumentů. - `script`: Spusťte `python.exe` příkaz s názvem souboru v atributu `Target` a za ním hodnotu v atributu `Arguments` . - `module`: Spusťte `python -m` příkaz následovaný názvem modulu v atributu `Target` , za nímž následuje hodnota v atributu `Arguments` . - `code`: Spusťte vložený kód obsažený v atributu `Target` . Ignorujte hodnotu atributu `Arguments` . - `pip`: Spusťte pip s příkazem v atributu `Target` , za kterým následuje hodnota v atributu `Arguments` . `ExecuteIn` Pokud je atribut nastaven na `output`, pip předpokládá, že požadavek je spustit `install` příkaz a použije `Target` atribut jako název balíčku.
`Target`	Ano	Určuje název souboru, název modulu, kód nebo příkaz pip, který se má použít v závislosti na hodnotě atributu `TargetType` .
`Arguments`	Volitelný	Poskytuje řetězec argumentů (pokud existuje) pro použití s atributem `Target` . – Když je hodnota atributu \`TargetType` \`script`, je \`Arguments` hodnota použita v programu Python místo příkazu \`python.exe`. - Pokud je hodnota atributu `TargetTypecode`, hodnota `Arguments` je ignorována.
`ExecuteIn`	Ano	Určuje prostředí, ve kterém se má příkaz spustit: - `console`: (Výchozí) Spustí `Target` atribut s `Arguments` hodnotou, jako by byly zadány přímo na příkazovém řádku. `Target` Když je atribut spuštěný, zobrazí se příkazové okno a automaticky se zavře. - `consolepause`: Stejné chování jako `console`, ale čeká na stisknutí klávesy před zavřením okna. - `output`: Spustí `Target` atribut a zobrazí výsledky v okně Výstup sady Visual Studio. Pokud je atribut `TargetType`, Visual Studio použije atribut `pip` jako název balíčku a připojí hodnotu atributu `Target`. - `repl`: Spustí `Target` atribut v interaktivním okně Pythonu. Zobrazovaný název, pokud je volitelný, se používá pro název okna. - `none`: Stejné chování jako `console`.
`WorkingDirectory`	Volitelný	Identifikuje složku, ve které se má příkaz spustit.
`ErrorRegex` `WarningRegEx`	Volitelný	Používá se pouze v případech `ExecuteIn`, kdy je atribut nastaven na `output`. Obě hodnoty atributů určují regulární výraz, který Visual Studio používá k analýze výstupu příkazu a zobrazení chyb a upozornění v okně Seznam chyb . Pokud tyto atributy nejsou zadané, příkaz nemá vliv na okno Seznam chyb . Další informace o tom, co Visual Studio očekává, najdete v tématu Pojmenované zachytávací skupiny.
`RequiredPackages`	Volitelný	Poskytuje seznam požadavků na balíček pro příkaz pomocí stejného formátu jako soubor requirements.txt (pip.readthedocs.io). Například příkaz Spustit PyLint určuje formát `pylint>=1.0.0`. Před spuštěním příkazu sada Visual Studio potvrdí, že jsou nainstalované všechny balíčky v seznamu. Visual Studio k instalaci chybějících balíčků používá pip.
`Environment`	Volitelný	Identifikuje řetězec proměnných prostředí, který se má definovat před spuštěním příkazu. Každá proměnná používá formát `\<NAME>=\<VALUE>`, přičemž více proměnných je odděleno středníky. Proměnná s více hodnotami musí být obsažena v jednoduchých nebo dvojitých uvozovkách, jako v `'NAME=VALUE1;VALUE2'`.

Pojmenované skupiny zachycení pro regulární výrazy

Když Visual Studio analyzuje chyby a upozornění z výstupu vlastního příkazu, očekává, že regulární výrazy v ErrorRegex hodnotách atributů WarningRegex budou používat následující pojmenované skupiny:

(?<message>...): Text chyby.
(?<code>...): Hodnota kódu chyby.
(?<filename>...): Název souboru, pro který je chyba hlášena.
(?<line>...): Číslo řádku v souboru, na kterém je hlášena chyba.
(?<column>...): Číslo sloupce v souboru, pro který je hlášena chyba.

PyLint například generuje upozornění na následující formulář:

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

Aby Visual Studio mohlo extrahovat správné informace z těchto upozornění a zobrazit je v okně Seznam chyb, je hodnota atributu pro příkaz WarningRegex následující:

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

Poznámka:

Syntaxe msg_id v hodnotě atributu WarningRegex by měla být codeve skutečnosti , jak je popsáno v problému 3680.

Import vlastních příkazů se souborem cílů

Pokud definujete vlastní příkazy v souboru projektu Pythonu, jsou příkazy k dispozici pouze pro tento konkrétní projekt. Pokud chcete vytvořit vlastní příkazy a použít je ve více projektech, můžete definovat <PythonCommands> skupinu vlastností se všemi prvky <Target> v cílovém souboru (.targets) a pak tento soubor importovat do projektů Pythonu.

Soubor cílů používá stejný formát a syntaxi k definování vlastních příkazů, jak je popsáno pro soubor projektu Pythonu (.pyproj). Mezi běžné prvky, které se mají konfigurovat, patří <PythonCommands>, <Target>, <CreatePythonCommandItem>a <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>

Pokud chcete do projektu importovat cílový soubor, přidejte prvek <Import Project="(path)"> kamkoli do elementu <Project> v souboru projektu.

Pokud máte například soubor projektu s názvem CustomCommands.targets ve složce cílů v projektu Pythonu, přidejte do souboru projektu následující kód:
```
<Import Project="targets/CustomCommands.targets"/>
```
Pokud soubor projektu naimportuje cílový soubor a v době, kdy je projekt otevřený v sadě Visual Studio, musíte znovu sestavitřešení sady Visual Studio, které obsahuje váš projekt, a ne jenom projekt.

Příklady příkazů

Následující části obsahují ukázkový kód, který můžete použít k definování vlastních příkazů pro projekty Pythonu.

Spuštění PyLintu (cíl modulu)

V souboru Microsoft.PythonTools.targets se zobrazí následující kód:

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

Spuštění příkazu pip install s konkrétní knihovnou (--target)

Následující příkaz spustí pip install my-package příkaz v okně Výstup sady Visual Studio. Tento příkaz můžete použít při vývoji balíčku a otestování jeho instalace. Element <Target> obsahuje název balíčku místo install příkazu, který se předpokládá při použití definice atributu 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>

Zobrazit zastaralé balíčky pip (pip target)

Následující příkaz spustí pip s list funkcí k identifikaci zastaralých balíčků pip:

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

Spuštění spustitelného souboru s pauzou v konzoli

Následující příkaz spustí where funkci, která zobrazí umístění souborů Pythonu počínaje složkou projektu:

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

Spuštění serveru a spuštění příkazů ladicího serveru

Pokud chcete zjistit, jak jsou definovány příkazy Start serveru a Start debug serveru pro webové projekty, projděte si úložiště Microsoft.PythonTools.Web.targets na GitHubu.

Instalace balíčku pro vývoj

Následující kód spustí pip pro instalaci balíčků:

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

Z fxthomas/Example.pyproj.xml (GitHub) se používá s oprávněním.

Generování instalačního programu systému Windows

Následující skript vygeneruje instalační službu systému 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>

Z fxthomas/Example.pyproj.xml (GitHub) se používá s oprávněním.

Vygenerování balíčku kolečka Pythonu

Následující skript vygeneruje balíček Python wheel:

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

Z fxthomas/Example.pyproj.xml (GitHub) se používá s oprávněním.

Řešení potíží s vlastními příkazy

V následujících částech najdete možné problémy související s prací s vlastními příkazy.

Soubor projektu nebyl načten.

Tato chybová zpráva značí, že v souboru projektu máte chyby syntaxe. Zpráva obsahuje konkrétní chybu s číslem řádku a umístěním znaku.

Okno konzoly se zavře po spuštění příkazu.

Pokud se okno konzoly okamžitě po spuštění příkazu zavře, použijte definici atributu ExecuteIn="consolepause" místo ExecuteIn="console".

Pokud v místní nabídce Pythonu nevidíte vlastní příkaz, zkontrolujte následující položky:

Potvrďte, že příkaz je součástí <PythonCommands> skupiny vlastností.
Ověřte, že název příkazu definovaný v seznamu příkazů odpovídá názvu zadanému v elementu <Target> .

Následuje příklad. V následujícím Example XML fragmentu se název <PythonCommands> ve skupině vlastností neshoduje s názvem ExampleCommand v definici elementu <Target>. Visual Studio nenajde příkaz s názvem Example, takže se nezobrazí žádný příkaz. Buď použijte ExampleCommand v seznamu příkazů, nebo změňte název cíle tak, aby byl pouze Example.

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

Chyba při spuštění příkazu, nepodařilo se získat cíl příkazu

Tato chybová zpráva označuje, že obsah <Target> nebo <CreatePythonCommandItem> prvky jsou nesprávné.

Tady je několik možných důvodů této chyby:

Požadovaný <Target> atribut elementu je prázdný.
Požadovaný TargetType atribut je prázdný nebo obsahuje nerozpoznanou hodnotu.
Požadovaný ExecuteIn atribut je prázdný nebo obsahuje nerozpoznanou hodnotu.
Atribut ErrorRegex nebo WarningRegex je zadán bez určení definice atributu ExecuteIn="output".
Nerozpoznané atributy existují v elementu. Například odkaz na atribut může být nesprávně napsaný jako Argumnets místo Arguments.

Hodnoty atributů můžou být prázdné, pokud odkazujete na vlastnost, která není definována. Pokud použijete token $(StartupFile) , ale v projektu není definován žádný spouštěcí soubor, token se přeloží na prázdný řetězec. V takových případech můžete chtít definovat výchozí hodnotu. Například příkazy Spustit server a Spustit ladicí server definované v šablonách projektů Bottle, Flask a Django používají ve výchozím nastavení soubor manage.py (pokud spouštěcí soubor serveru není zadaný ve vlastnostech projektu).

Visual Studio přestane reagovat, spadne

Pokud Visual Studio přestane reagovat a při spuštění vlastního příkazu dojde k chybovému ukončení, pravděpodobně se pokoušíte spustit příkaz konzoly s definicí atributu ExecuteIn="output" . V takových případech se může Visual Studio při pokusu o analýzu výstupu zhroutit. Pokud se chcete této podmínce vyhnout, použijte místo toho definici atributu ExecuteIn="console" . Další informace najdete v tématu Problém 3681.

Příkaz není rozpoznán jako operovatelný program nebo dávkový soubor.

Při nastavování definice atributu TargetType="executable" musí být hodnota v Target atributu pouze název programu bez argumentů, například python nebo python.exe pouze. V tomto případě přesuňte všechny argumenty do atributu Arguments .

Váš názor

Byla tato stránka užitečná?

Last updated on 2025-12-12

Sdílet prostřednictvím

Definování vlastních příkazů pro projekty Pythonu v sadě Visual Studio

Požadavky

Prozkoumání vlastních příkazů

Opětovné načtení projektu pro přístup k vlastním příkazům

Přidání vlastních příkazů se souborem projektu

Použití vlastností projektu

Pochopit strukturu elementu <Target>

Cílové atributy

Atributy CreatePythonCommandItem

Pojmenované skupiny zachycení pro regulární výrazy

Import vlastních příkazů se souborem cílů

Příklady příkazů

Spuštění PyLintu (cíl modulu)

Spuštění příkazu pip install s konkrétní knihovnou (--target)

Zobrazit zastaralé balíčky pip (pip target)

Spuštění spustitelného souboru s pauzou v konzoli

Spuštění serveru a spuštění příkazů ladicího serveru

Instalace balíčku pro vývoj

Generování instalačního programu systému Windows

Vygenerování balíčku kolečka Pythonu

Řešení potíží s vlastními příkazy

Soubor projektu nebyl načten.

Okno konzoly se zavře po spuštění příkazu.

V nabídce chybí příkaz

Chyba při spuštění příkazu, nepodařilo se získat cíl příkazu

Visual Studio přestane reagovat, spadne

Příkaz není rozpoznán jako operovatelný program nebo dávkový soubor.

Váš názor

Další materiály