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. Další informace najdete v tématu Co se děje s Visual Studio pro Mac? 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, 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:

1. Otevřete projekt Pythonu v sadě Visual Studio. (Když otevřete projekt v sadě Visual Studio, projekt se ve výchozím nastavení načte .)

2. V Průzkumník ř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:

   

3. Proveďte změny v souboru projektu v editoru sady Visual Studio a uložte svoji práci.

4. V Průzkumník řešení klikněte pravým tlačítkem myši 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 při vývoji vlastních příkazů může stát zdlouhavým. 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í python.exe příkazu, který je v podstatě stejný jako použití možnosti Spustit ladění>bez ladění na hlavním panelu nástrojů sady Visual Studio.

1. 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ý jenom v sadě Visual Studio, když je projekt otevřený, ale uvolněný. Projekt má také soubor Pythonu (.py) pro kód aplikace.

2. Otevřete soubor Python_CustomCommands.py aplikace v editoru a přidejte následující kód:

   print("Hello custom commands")
   

3. V Průzkumník ř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.

4. Spusťte samostatný editor mimo relaci 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).)

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

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

7. V Průzkumník ř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.

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

9. <PythonCommands> Nahraďte skupinu vlastností (přidanou v kroku 5) následujícím kódem XML. Tato syntaxe definuje atribut pro <Target> element, který přidá vlastní příkaz do místní nabídky Pythonu.Name Příkaz obsahuje popisek nabídky Spustit spouštěcí soubor.

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

   Tip

   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.

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

11. V Průzkumník ř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 do elementu přidali Name hodnotu atributu<PythonCommands>, jak je popsáno v kroku 9<Target>. Projděte si také aspekty uvedené v části Řešení potíží dále v tomto článku.

    

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

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

14. Uložte změny, přepněte zpět do sady Visual Studio a znovu načtěte projekt.

15. 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:

    

16. 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 MSBuild vlastnosti.

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.

Principy <struktury elementů Target>

Pomocí elementu definujete podrobnosti vlastního <Target> příkazu. 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> .

Atribut	Požadováno	Popis
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	Zobrazovaný název uživatelského rozhraní, který se zobrazí v místní nabídce Pythonu.
Returns	Ano	Vrácené informace, které musí obsahovat @(Commands) token, který identifikuje 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. Všechny hodnoty atributů nerozlišují malá a velká písmena.

Attribute	Požadováno	Popis
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 . – Pokud je scripthodnota atributu TargetType , Arguments je hodnota zadána do programu Pythonu místo python.exe příkazu. - Pokud je codehodnota atributu TargetTypeArguments , hodnota 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. TargetType Pokud je pipatribut , Visual Studio použije Target atribut jako název balíčku a připojí hodnotu atributuArguments. - repl: Spustí Target atribut v interaktivním okně Pythonu. Volitelný zobrazovaný název 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 outputhodnotu . 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 Sada Visual Studio očekává, najdete v tématu Pojmenované skupiny zachycení.
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á formulář \<NAME>=\<VALUE> s více proměnnými oddělenými 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 umístění v souboru, pro které je chyba hlášena.
• (?<column>...): Číslo sloupce umístění v souboru, pro které je chyba hlášena.

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

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

Pokud chcete sadě Visual Studio povolit extrahování správných informací z těchto upozornění a jejich zobrazení v okně Seznam chyb, WarningRegex hodnota atributu pro příkaz Run Pylint je 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í instalace pip s konkrétním balíčkem (cíl pip)

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>

Zobrazení zastaralých balíčků pip (cíl pip)

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 pomocí konzoly

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í služby 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 kol Pythonu:

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

V nabídce chybí příkaz

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 fragmentu kódu Example XML se název ve <PythonCommands> skupině vlastností neshoduje s ExampleCommand názvem 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 je WarningRegex zadán bez nastavení 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 ve výchozím nastavení používají soubor manage.py (pokud spouštěcí soubor serveru není zadaný ve vlastnostech projektu).

Visual Studio přestane reagovat, dojde k chybovému ukončení

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 může Visual Studio při pokusu o analýzu výstupu dojít k chybovému ukončení. 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 .