Comment puis-je obtenir par programme le chemin de «Python.exe» utilisé par ArcMap

Je travaille avec un complément d'ArcMap en C #. A partir du code C #, j'ai exécuté quelques scripts Python. Maintenant, pour exécuter ces scripts, j'ai un chemin python codé en dur. Mais ce n'est pas portable. Donc, je veux obtenir le chemin de l'exécutable Python à partir du code et l'utiliser.

Question:

Comment puis-je obtenir le chemin de l'exécutable Python utilisé par ArcMap à partir du code C #?

ÉDITER :

D'après vos suggestions, pour l'instant j'utilise "environnement de chemin" pour obtenir le chemin Python.

//get python path from environtment variable
string GetPythonPath()
{
    IDictionary environmentVariables = Environment.GetEnvironmentVariables();
    string pathVariable = environmentVariables["Path"] as string;
    if (pathVariable != null)
    {
        string[] allPaths = pathVariable.Split(';');
        foreach (var path in allPaths)
        {
            string pythonPathFromEnv = path + "\\python.exe";
            if (File.Exists(pythonPathFromEnv))
                return pythonPathFromEnv;
        }
    }
}

Mais il y a un problème:

Lorsque différentes versions de python sont installées sur ma machine, rien ne garantit que le "python.exe" que j'utilise, ArcGIS l'utilise également.

Je n'apprécie pas d'utiliser un autre outil pour obtenir le chemin "python.exe" . Donc, je pense vraiment qu'il existe un moyen d'obtenir le chemin d'accès à partir de la clé de registre. Pour le registre "ArcGIS10.0" ressemble à:

Et pour cela, je pense à suivre le chemin pour obtenir le chemin:

//get python path from registry key
string GetPythonPath()
{
    const string regKey = "Python";
    string pythonPath = null;
    try
    {
        RegistryKey registryKey = Registry.LocalMachine;
        RegistryKey subKey = registryKey.OpenSubKey("SOFTWARE");
        if (subKey == null)
            return null;

        RegistryKey esriKey = subKey.OpenSubKey("ESRI");
        if (esriKey == null)
            return null;

        string[] subkeyNames = esriKey.GetSubKeyNames();//get all keys under "ESRI" key
        int index = -1;
     /*"Python" key contains arcgis version no in its name. So, the key name may be 
     varied version to version. For ArcGIS10.0, key name is: "Python10.0". So, from
     here I can get ArcGIS version also*/
        for (int i = 0; i < subkeyNames.Length; i++)
        {
            if (subkeyNames[i].Contains("Python"))
            {
                index = i;
                break;
            }
        }
        if(index < 0)
            return null;
        RegistryKey pythonKey = esriKey.OpenSubKey(subkeyNames[index]);

        string arcgisVersion = subkeyNames[index].Remove(0, 6); //remove "python" and get the version
        var pythonValue = pythonKey.GetValue("Python") as string;
        if (pythonValue != "True")//I guessed the true value for python says python is installed with ArcGIS.
            return;

        var pythonDirectory = pythonKey.GetValue("PythonDir") as string;
        if (pythonDirectory != null && Directory.Exists(pythonDirectory))
        {
            string pythonPathFromReg = pythonDirectory + "ArcGIS" + arcgisVersion + "\\python.exe";
            if (File.Exists(pythonPathFromReg))
                pythonPath = pythonPathFromReg;
        }  
    }
    catch (Exception e)
    {
        MessageBox.Show(e + "\r\nReading registry " + regKey.ToUpper());
        pythonPath = null;
    }
    return pythonPath ;
}

Mais avant d'utiliser la deuxième procédure, je dois être sûr de mes suppositions. Les suppositions sont:

1. le "vrai" associé à python signifie que python est installé avec ArcGIS
2. ArcGIS 10.0 et la clé de registre de la version supérieure seront écrits dans le même processus.

Veuillez m'aider à obtenir des éclaircissements sur mes suppositions.

J'ai pris votre deuxième exemple de code, je l'ai fait fonctionner sur les systèmes d'exploitation 64 et 32 ​​bits et je l'ai simplifié un peu. Fonctionne pour moi à la version 10.1 sur Windows 7 64 bits, mais vous devez évidemment le tester sur autant d'environnements que possible et ajouter à nouveau les vérifications de programmation défensive que vous jugez nécessaires.

Après avoir testé une installation propre d'ArcGIS Desktop 10.1 sans Python, j'ai constaté qu'il n'inclut pas la sous-clé Python10.x, sans parler de la valeur "Python" Vrai / Faux (toujours pas sûr de ce à quoi cela sert, contactez peut-être le support ESRI si vous devez savoir).

string GetPythonPath()
{
    string pythonPath = null;
    var localmachineKey = Registry.LocalMachine;
    // Check whether we are on a 64-bit OS by checking for the Wow6432Node key (32-bit version of the Software registry key)
    var softwareKey = localmachineKey.OpenSubKey(@"SOFTWARE\Wow6432Node"); // This is the correct key for 64-bit OS's
    if (softwareKey == null) {
        softwareKey = localmachineKey.OpenSubKey("SOFTWARE"); // This is the correct key for 32-bit OS's
    }
    var esriKey = softwareKey.OpenSubKey("ESRI");
    var realVersion = (string)esriKey.OpenSubKey("ArcGIS").GetValue("RealVersion"); // Get the "real", canonical version of ArcGIS
    var shortVersion = String.Join(".", realVersion.Split('.').Take(2).ToArray()); // Get just the Major.Minor part of the version number, e.g. 10.1
    var pythonKey = esriKey.OpenSubKey("Python" + shortVersion); // Open the Python10.x sub-key
    if (pythonKey == null) {
        throw new InvalidOperationException("Python not installed with ArcGIS!");
    }
    var pythonDirectory = (string)pythonKey.GetValue("PythonDir");
    if (Directory.Exists(pythonDirectory))
    {
        // Build path to python.exe
        string pythonPathFromReg = Path.Combine(Path.Combine(pythonDirectory, "ArcGIS" + shortVersion), "python.exe");
        if (File.Exists(pythonPathFromReg)) {
            pythonPath = pythonPathFromReg;
        }
    }
    return pythonPath;
}

Sur une machine Desktop 10.1 avec Python, cela revient C:\Python27\ArcGIS10.1\python.exe. Sur une machine Desktop 10.1 sans Python, cela déclenche une InvalidOperationException car la clé Python10.x n'est pas présente.

J'espère que cela vous aidera avec tout ce que vous essayez d'accomplir réellement, ce qui - étonnamment - n'est toujours pas clair pour moi.

Au lieu de rechercher l'exécutable Python, cette rubrique d'aide suggère de décortiquer cmd.exeet d'exécuter python.exesans qualifier son emplacement. Notez cependant que cela devrait fonctionner car le programme d'installation d'ArcGIS Desktop s'installe (modification: récemment testé à la version 10.1, il ne fonctionne pas) dépend du chemin à python.exeajouter à la PATHvariable d'environnement de l'utilisateur .

Une autre approche consiste à créer un outil de script et à l' exécuter à partir d'ArcObjects .

Si vous êtes vraiment après le chemin vers la version d'ArcGIS de python.exe, par extension de l'approche de l'outil de script ArcObjects +, vous pouvez créer un outil de script Python dont la seule sortie est la valeur de sys.exec_prefix. Il s'agit du chemin du dossier contenant la version d'ArcGIS de Python, par exemple C:\Python27\ArcGIS10.1.

Note latérale : sys.executablerenvoie le chemin vers ArcMap.exeet NON python.exelors de l'exécution en cours de processus, c'est pourquoi je ne suggère pas d'utiliser cette variable.

Appelez l'outil de script à partir d'ArcObjects et obtenez la sortie de l' IGeoProcessorResultobjet renvoyé .

Mise à jour: voici un exemple de projet de complément ArcMap (VS2010, .NET 3.5) qui utilise un outil de script intégré au complément qui affiche simplement le chemin d'accès à celui python.exeutilisé par ArcMap: http://wfurl.com/cbd5091

C'est juste un bouton sur lequel vous cliquez et une boîte de message apparaît avec le chemin:

Les morceaux de code intéressants:

• Script Python:

  import sys
  import os
  import arcpy
  
  def getPythonPath():
      pydir = sys.exec_prefix
      pyexe = os.path.join(pydir, "python.exe")
      if os.path.exists(pyexe):
          return pyexe
      else:
          raise RuntimeError("No python.exe found in {0}".format(pydir))
  
  if __name__ == "__main__":
      pyexe = getPythonPath()
      arcpy.AddMessage("Python Path: {0}".format(pyexe))
      arcpy.SetParameterAsText(0, pyexe)

• Fonction C #:

  public string GetPythonPath()
  {
      // Build the path to the PythonPathToolbox
      string toolboxPath = Path.Combine(Path.GetDirectoryName(this.GetType().Assembly.Location), "PythonPath.tbx");
  
      // Initialize the geoprocessor.
      IGeoProcessor2 gp = new ESRI.ArcGIS.Geoprocessing.GeoProcessorClass();
  
      // Add the PythonPath toolbox.
      gp.AddToolbox(toolboxPath);
  
      // Need an empty array even though we have no input parameters
      IVariantArray parameters = new VarArrayClass();
  
      // Execute the model tool by name.
      var result = gp.Execute("GetPythonPath", parameters, null);
      return result.GetOutput(0).GetAsText();
  }

Aurez-vous accès au registre?

Lors de l'installation d'ArcMap, il installera Python s'il ne le trouve pas. Il regarde dans le registre pour voir si Python est déjà installé. Je crois que l'emplacement de registre standard pour cela est: computer \ HKEY_LOCAL_MACHINE \ SOFTWARE \ PYTHON \ PythonCore \ 2.7 \ InstallPath Avec une clé par défaut de l'emplacement du chemin (2.7 étant 10.1, 2.6 étant 10.0)

Je ne peux pas penser à une raison pour laquelle / pourquoi la valeur de cette clé serait incorrecte, mais vous pouvez toujours procéder de cette façon: à l'intérieur de la ruche Esri \ Desktop du registre se trouve un emplacement Python. C'est le chemin simple que vous pouvez obtenir, puis créez d'autres chemins pour vous assurer qu'il existe un Python.exe. Par exemple, la clé sur une machine 64 bits est installée sur: ordinateur \ HKEY_LOCAL_MACHINE \ SOFTWARE \ Wow6432Node \ ESRI \ Python10.1 avec une clé PythonDir et la valeur de chemin d'accès associée

Mais j'aime la réponse @ blah238. Ouvrez simplement une invite depuis votre programme et exécutez-la. Je ne vois pas pourquoi cela ne fonctionnerait pas.

[Modifier] Bien que l'exécution par setprogramme (barrée ci-dessous) ait fait ce que je voulais, cela peut être accompli plus facilement et avec un code plus propre en utilisant Environment.GetEnvironmentVariables () .

Une option consisterait à analyser chaque variable d'environnement sur le système et à essayer de prouver ce qui suit:

1) La valeur de la variable d'environnement est-elle un répertoire? (et si oui ..)

2) Ce répertoire contient-il python.exe?

J'ai pu le faire par programme en exécutant la setcommande via l' API de processus .Net . leset commande, lorsqu'elle est utilisée sans paramètre, renvoie TOUTES les variables d'environnement utilisées par le système. Je pourrais donc parase, puis organiser les résultats de STDOUT émis par set, et les écran pour voir si quoi que ce soit (et je veux dire RIEN ) disponible à travers le système envionment finalement pointé python.exe.

De cette page discutant de la setcommande:

Tapez SET sans paramètres pour afficher toutes les variables d'environnement actuelles.

Pour illustrer, j'ai écrit une combinaison de méthodes (et une classe d'assistance ) qui fait ce que j'ai discuté ci-dessus. Ceux-ci peuvent être optimisés, et ils pourraient utiliser une protection contre les balles (Try..Catch, etc.), mais si l'ordinateur a n'importe quelle variable d'environnement pointant verspython.exe , cette approche devrait le trouver! Je me fiche que la var soit appelée PATH, ABBRACADABBRAou quoi que ce soit .. si elle pointe python.exe, cela devrait la trouver.

// C#, you'll need these using statements:
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Text.RegularExpressions;

Voici termsun tableau de chaînes que vous transmettez à la routine pour rechercher soit le nom de la variable d'environnement, soit sonn valeurs (c'est PATH-à- dire peuvent avoir plusieurs valeurs, mais la plupart des autres variables n'en auront qu'une). Assurez-vous que toutes les chaînes termssont en MAJUSCULE!

(Quand j'ai testé cela, j'ai utilisé simplement "PYTHON", qui a trouvé C:\Python27\python.exe sur mon système domestique. Mais vous pouvez facilement l'étendre pour inclure une autre chaîne [] de termes si vous souhaitez inspecter davantage le chemin des python.execandidats retournés --- pour exemple, pour voir s'ils étaient dans la corbeille ArcGIS, etc.)

// Top-level method that organizes everything below..
private void scrapeEnvironmentVariables(string[] terms)
{
    // !! ValueObject !! This is a Helper Class, find it at the bottom..
    List<ValueObject> voList = buildListOfEnvironmentObjects();

    foreach (ValueObject vo in voList)
    {
        bool candidateFound = ObjectMatchesSearchTerms(vo, terms);

        if (candidateFound)
        {    
            string exeCandidate = "";
            foreach (string unlikelyPath in vo.values)
            {
                if (Directory.Exists(unlikelyPath))
                {
                    string unlikelyExe = unlikelyPath + "\\python.exe";
                    if(File.Exists(unlikelyExe))
                        exeCandidate = unlikelyExe;
                }

                if (exeCandidate != "")
                {
                    break;
                    // At this point, exeCandidate is a fully-qualified
                    // path to python.exe..
                }
            }

            // If you only want the first hit, break here..
            // As-is, the code will look for even more matches.
            //if (breakOnFirstHit)
            //    break;
        }
    }
}


// Execute Environment.GetEnvironmentVariables() and organize the 
// key..value pairs into 1:n ValueObjects (see Helper Class below).
private List<ValueObject> buildListOfEnvironmentObjects()
{
    // Return a List of 1:n key..value objects.
    List<ValueObject> voList = new List<ValueObject>();

    IDictionary variableDictionary = Environment.GetEnvironmentVariables();
    foreach (DictionaryEntry entry in variableDictionary)
    {
        // Explode multi-values into a List of values (n).
        List<string> values = new List<string>();
        string[] rawValues = ((string)entry.Value).Split(';');
        foreach (string value in rawValues)
            if (value != "") values.Add(value.ToUpper());

        ValueObject valueObject = new ValueObject();
        valueObject.key = ((string)entry.Key).ToUpper();
        valueObject.values = values.ToArray();

        voList.Add(valueObject);
    }
    return voList;
}


// Compare the key and any value(s) in a ValueObject with all the
// terms submitted to the top-level method. If **ALL** the terms
// match (against any combination of key..value), it returns true.
private bool ObjectMatchesSearchTerms(ValueObject vo, string[] terms)
{
    int matchCount = 0;

    foreach (string term in terms)
    {
        if (vo.key.Contains(term))              // screen the key
            matchCount++;

        foreach (string value in vo.values)     // screen N values
        {
            if (value.Contains(term))
                matchCount++;
        }
    }

    // Test against >= because it's possible the match count could
    // exceed the terms length, like if a match occurred in both the
    // key and the value(s). So >= avoids omiting that possibility.
    return (matchCount >= terms.Length) ? true : false;
}    

Et au bas de ma classe principale, j'ai inclus la classe d'assistance suivante :

class ValueObject : Object
{
    public ValueObject() { } // default constructor

    public string key;
    public string[] values;
}

Je voudrais proposer une solution alternative, basée sur mon commentaire dans la question ci-dessus. Pour un projet en cours, je fais quelque chose de très similaire; J'ai un complément .NET qui, lorsque l'utilisateur clique sur un bouton dans l'interface utilisateur d'ArcMap, un script Python s'exécute. J'ai rendu obligatoire la définition d'une variable d'environnement PATH sur l'exécutable ArcGIS Python, de cette façon, je n'ai pas vraiment à me soucier d'inclure le chemin d'accès à l'exe Python dans mon code .NET.

Maintenant, pendant le développement, les testeurs configurent simplement la variable PATH manuellement. Mais je finirai par avoir un programme d'installation Windows (exe) créé qui installera le complément, installera toutes les dépendances Python et définira toutes les variables PATH nécessaires. Pour cela, j'utilise le système d'installation scriptable Nullsoft (NSIS) , un système open source pour créer des programmes d'installation Windows. Voici un code que j'ai travaillé jusqu'à présent, ce qui est assez approximatif. Fondamentalement, il regarde dans le registre pour voir si les variables PATH d'intérêt sont là, et si elles ne le sont pas, il les ajoute. Doit être exécuté en tant qu'administrateur, bien sûr.

include "StrFunc.nsh"
!include "LogicLib.nsh"

/*
  Name: VIESORE_Installer.nsi
  Author: Chad Cooper, CAST
  Date: 7/16/2012
  Purpose: NSIS installer script for .exe creation by NSIS. Installs VIESORE components and sets up environment.
*/

Name "VIESORE"
Caption "VIESORE Installer"
Outfile "VIESOREInstaller.exe"

RequestExecutionLevel admin

# Initialize functions
${StrLoc}
# Initialize user variables
Var path

Section "Set SYSTEM PATH environmental variables"
    ReadRegStr $0 HKLM "SYSTEM\CurrentControlSet\Control\Session Manager\Environment" "Path"
    ${StrLoc} $1 $0 "C:\Python26\ArcGIS10.0" ">"
    ${StrLoc} $2 $0 "C:\Python26\ArcGIS10.0\Scripts" ">"
        ${StrLoc} $3 $0 "C:\Python26\ArcGIS10.0\Lib\site-packages" ">"
        ${StrLoc} $4 $0 "C:\Program Files\e-on software\Vue 10 Infinite\Application" ">"
        # Test to see if env vars exist in current system PATH, if not add them to $path variable
        ${If} $3 == ""
                StrCpy $path "C:\Python26\ArcGIS10.0\Lib\site-packages"
        ${EndIf}
        ${If} $2 == ""
                StrCpy $path "C:\Python26\ArcGIS10.0\Scripts;$path"
        ${EndIf}
        ${If} $1 == ""
                StrCpy $path "C:\Python26\ArcGIS10.0;$path"
        ${EndIf}
        ${If} $4 == ""
                StrCpy $path "C:\Program Files\e-on software\Vue 10 Infinite\Application;$path"
        ${EndIf}
        DetailPrint "$path written to system PATH"
    WriteRegStr HKLM "SYSTEM\CurrentControlSet\Control\Session Manager\Environment" "Path" "$0;$path"
    ReadRegStr $5 HKLM "SYSTEM\CurrentControlSet\Control\Session Manager\Environment" "Path"
    DetailPrint "New Path: $5"
SectionEnd

Donc, encore une fois, cela ne trouve pas le chemin vers l'exe ArcGIS Python, mais cela vous permet de donner à votre utilisateur final le pouvoir de le configurer correctement et facilement.