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

16

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 à: entrez la description de l'image ici

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.

Emi
la source
5
Avez-vous envisagé de créer un outil de script et de l' exécuter à partir d'ArcObjects ?
blah238
3
Ne pouvez-vous pas simplement avoir une variable d'environnement PATH définie sur l'exe ArcGIS Python comme une exigence d'installation pour votre complément?
Chad Cooper
Cela dit, la pensée de @ ChadCooper doit être le meilleur moyen. Plutôt que d'essayer de travailler en arrière, définissez-le une fois pour toutes au moment de l'installation.
elrobis
@elrobis: Je sais, définir le chemin dans l'environnement PATH est un bon moyen. Mais je voulais savoir s'il y avait un moyen de trouver le python et de tout faire sans interrompre l'utilisateur.
Emi
@ blah238 merci pour votre suggestion. Je n'ai jamais travaillé avec l'outil de script. Peut-être que je dois en savoir plus
Emi

Réponses:

2

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.

blah238
la source
7

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:

Bouton Messagerie

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();
    }
blah238
la source
2
Mais ce document ne dit pas cela, le programme d'installation d'ArcGIS Desktop configure le chemin d'accès à python.exe vers la variable d'environnement PATH de l'utilisateur. Il peut donc être possible que le chemin de python ne soit pas dans la variable d'environnement PATH. Ensuite, cela créera une erreur. Alors, comment puis-je être sûr que le chemin exécutable python est dans la variable d'environnement PATH de l'utilisateur.
Emi
2
Vous ne pouvez pas, comme la plupart des choses de la vie et de l'informatique, tout ce que vous pouvez faire est de faire des hypothèses et d'espérer que les choses fonctionnent, et d'avoir un plan de secours dans le cas contraire (fournissez des instructions pour l'ajouter à la variable d'environnement PATH). Cela dit, s'il s'agit d'une installation normale, je pense que le programme d'installation d'ArcGIS Desktop ajoute ce chemin à la variable d'environnement PATH.
blah238
2
J'ai vu de nombreuses installations où le python installé sur arcgis n'était pas sur le chemin. Et si deux versions sont installées et que la «mauvaise» est sur le chemin?
blindjesse
J'ai proposé une solution dans mon 3ème paragraphe qui devrait trouver l'installation d'ArcGIS de Python indépendamment de la PATHvariable d'environnement.
blah238
@ blah238 ne crée-t-il pas un outil de script qui rend mon complément moins portable ou rend le processus d'installation du complément sur une autre machine difficile?
Emi
6

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.

KHibma
la source
2
Cette approche est également imparfaite car il peut y avoir plusieurs installations Python et vous n'avez aucun moyen simple de déterminer par programme lequel est celui utilisé par ArcGIS. Si vous n'exécutez pas arcpy, cela peut ne pas avoir d'importance. Pourtant, je pense que la solution la plus robuste impliquerait le registre et pas mal de logique. Je ne vais pas y aller cependant.
blah238
Eh bien, la logique devrait commencer par la dernière version 2.7 et revenir en arrière. Bien sûr, cela pourrait échouer si vous installiez une nouvelle version de Python, puis alliez installer une ancienne version d'ArcGIS qui installerait une ancienne version de Python. Donc oui, je suis d'accord avec ce potentiel, mais ce n'est pas probable (ou vous pouvez simplement construire une recherche d'arc10.1 = py2.7, arc10.0 = py26 ... etc pour être sûr à 100%). Comme je l'ai dit, la meilleure méthode serait probablement de décortiquer à l'invite de commande.
KHibma
@KHibma J'ai cherché dans le registre. Mais je pense que c'est vraiment gênant si je regarde à travers la touche "PYTHON". Dans ma machine, il y a deux versions de python installées et elle renvoie les deux. Je pense que c'est une bonne idée de regarder à travers la clé "ESRI" et s'il y a une sous-clé "Python" avec une vraie valeur, alors je peux prendre la valeur de la sous-clé "PythonDir". Cela fonctionne dans mon cas :)
Emi
Est-ce une mauvaise façon de rechercher le chemin python dans le registre via la clé "ESRI"? Ou existe-t-il une chance que la façon dont esri utilise pour créer des clés et des valeurs dans le registre puisse être modifiée et que le code ne puisse pas le lire
Emi
Quand je dis "rechercher" le registre, je veux dire utiliser les chemins réels que j'ai fournis ci-dessus. À moins que quelqu'un ne sache mieux, l'emplacement de ces clés d'enregistrement (dans le registre) ne changerait pas d'une machine à l'autre. Donc, il vous suffirait de coder en dur les chemins pour voir si les clés existent là, si oui quelle est la valeur ...
KHibma
5

[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;
}
elrobis
la source
1
Ceci est fragile, car l'utilisateur peut personnaliser le répertoire d'installation de Python dans le programme d'installation d'ArcGIS Desktop. De plus, la PYTHONPATHvariable n'est PAS celle que vous souhaitez.
blah238
@ blah238, parfois fragile est tout ce que vous avez. J'ai été en fait surpris de voir que Arc était connecté contre PYTHONPATH. Il s'agit d'une installation 9.2 par défaut. Néanmoins, l'OP a demandé comment accéder par programme à ArcGIS python.exe, et l'approche que j'ai recommandée, fragile ou non, le fait.
elrobis
Je ne peux pas dire que je comprends le vote négatif, cette réponse est-elle vraiment " inutile "? Ce n'est peut-être pas génial , mais c'est certainement une option, cela fonctionnerait probablement pour une installation Arc typique, et à tout le moins, il ajoute quelque chose d'utile au thread - en particulier, il illustre une installation Arc par défaut optant pour lier son python. exe avec une variable d'environnement autre que PATH.
elrobis
Désolé mais vous vous trompez. La variable PYTHONPATH est utilisée par Python pour rechercher des modules, et non par ArcGIS pour trouver Python. Vérifiez le lien.
blah238
@ blah238, je pense que la capture d'écran était écrasante / obscurcissant le point que j'essayais de faire valoir. (Plus précisément, ma suggestion à l'OP n'avait pas l'intention de souligner PYTHONPATH, qui se trouvait être le seul var sur ce système particulier pointant vers python.exe.) Quoi qu'il en soit, j'ai révisé ma réponse pour inclure un exemple de code C # fonctionnel, et j'apprécierais savoir si vous n'êtes toujours pas d'accord avec cette approche. Merci / E.
elrobis
4

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.

Chad Cooper
la source
+1 Je suis entièrement d'accord avec cette recommandation --- où au plus haut niveau, Chad dit "ne pas travailler le problème en arrière pour déduire l'instance python d'Arc, plutôt utiliser un programme d'installation et laisser le SysAdmin pour établir le bon python exemple." @ChadCooper, NSIS vous donne-t-il un contrôle d'interface utilisateur afin que vous puissiez remplacer ces chemins par défaut si vous le souhaitez? Je ne vois pas cela sous-entendu par le code, mais je parie que c'est là.
elrobis
@elrobis - Je parie que vous pouvez remplacer / éditer / changer ceux existants - NSIS est très configurable et peut vous permettre de construire un programme d'installation assez élégant - il vous suffit de trouver le code pour l'écrire.
Chad Cooper
Créer un programme d'installation pour un complément semble juste un peu fou. De plus, quelles modifications devez-vous apporter pour prendre en charge 10.1, 10.2, etc. ainsi que 10.0?
blah238
@ blah238 - oui, cela semble fou, mais mon installateur pour ce projet particulier en fera beaucoup plus, comme on l'a dit. Mon complément est strictement pour 10.0. Je suppose que pour différentes versions d'ArcGIS, vous pouvez vérifier le registre pour voir quelle version est installée, puis agir en conséquence.
Chad Cooper