Come posso ottenere a livello di codice il percorso di "Python.exe" utilizzato da ArcMap


16

Sto lavorando con un componente aggiuntivo di ArcMap in C #. Dal codice C #, ho eseguito alcuni script Python. Ora, per eseguire quelle sceneggiature, ho un percorso python codificato. Ma questo non è portatile. Quindi, voglio ottenere il percorso dell'eseguibile Python dal codice e usarlo.

Domanda:

Come posso ottenere il percorso dell'eseguibile Python usato da ArcMap dal codice C #?

MODIFICARE :

Dai tuoi suggerimenti, per ora sto usando "path environment" per ottenere il percorso 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;
        }
    }
}

Ma c'è un problema:

Quando nella mia macchina è installata una versione diversa di python, non c'è alcuna garanzia che, il "python.exe" che sto usando, ArcGIS lo usi anche.

Non apprezzo l'uso di un altro strumento per ottenere il percorso "python.exe" . Quindi, penso davvero se esiste un modo per ottenere il percorso dalla chiave di registro. Per il registro "ArcGIS10.0" appare come: inserisci qui la descrizione dell'immagine

E per questo, sto pensando di seguire il modo di ottenere il percorso:

//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 ;
}

Ma prima di utilizzare la seconda procedura, devo essere sicuro delle mie ipotesi. Le ipotesi sono:

  1. il "Vero" associato a Python significa che Python è installato con ArcGIS
  2. ArcGIS 10.0 e la chiave di registro della versione superiore verranno scritti nello stesso processo.

Ti prego, aiutami a ottenere qualsiasi chiarimento sulle mie ipotesi.


5
Hai mai pensato di creare uno strumento di script ed eseguirlo da ArcObjects ?
blah238,

3
È possibile non solo avere una variabile ambientale PATH impostata su ArcGIS Python exe come requisito di installazione per il componente aggiuntivo?
Chad Cooper,

Detto questo, il pensiero di @ ChadCooper deve essere il modo migliore. Invece di provare a lavorare all'indietro, impostalo una volta per tutte al momento dell'installazione.
elrobis,

@elrobis: lo so, impostare il percorso nell'ambiente PATH è un buon modo. Ma volevo sapere se esiste un modo per trovare il pitone e fare tutto senza interrompere l'utente.
Emi,

@ blah238 grazie per il tuo suggerimento. Non ho mai lavorato con lo strumento di script. Potrebbe essere che ho bisogno di conoscerlo
Emi il

Risposte:


2

Ho preso il tuo secondo esempio di codice, l'ho fatto funzionare su sistemi operativi a 64 e 32 bit e l'ho semplificato un po '. Funziona per me a 10.1 su Windows 7 a 64 bit, ma ovviamente dovresti testarlo su quanti più ambienti possibile e aggiungere di nuovo in qualsiasi controllo di programmazione difensiva che ritieni necessario.

Dopo aver testato l'installazione pulita di ArcGIS Desktop 10.1 senza Python, ho scoperto che non include la sottochiave Python10.x, men che meno il valore True / False "Python" (ancora non sono sicuro di cosa sia, forse contattare il supporto ESRI se è necessario conoscere).

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

Su un computer Desktop 10.1 con Python, questo ritorna C:\Python27\ArcGIS10.1\python.exe. Su un computer Desktop 10.1 senza Python, viene generato un InvalidOperationException a causa della mancata presenza della chiave Python10.x.

Spero che questo ti aiuti con qualsiasi cosa tu stia cercando di realizzare, il che - sorprendentemente - non mi è ancora chiaro.


7

Invece di cercare l'eseguibile Python, questo argomento della guida suggerisce di eseguire lo sbandamento cmd.exee l'esecuzione python.exesenza qualificarne la posizione. Si noti tuttavia che questo dovrebbe funzionare perché il programma di installazione di ArcGIS Desktop impostato (modifica: recentemente testato alla 10.1, non funziona) si basa sul percorso da python.exeaggiungere alla PATHvariabile d'ambiente dell'utente .

Un altro approccio è quello di creare uno strumento di script ed eseguirlo da ArcObjects .

Se stai davvero python.exeseguendo il percorso della versione di ArcGIS di , per estensione dell'approccio dello strumento di script ArcObjects +, potresti creare uno strumento di script Python il cui unico output è il valore di sys.exec_prefix. Questo è il percorso della cartella contenente la versione di Python di ArcGIS, ad es C:\Python27\ArcGIS10.1.

Nota a margine : sys.executablerestituisce il percorso a ArcMap.exee NON python.exequando eseguito in-process, motivo per cui non suggerisco di usare quella variabile.

Chiama lo strumento di script da ArcObjects e ottieni l'output dall'oggetto restituito IGeoProcessorResult.

Aggiornamento: ecco un progetto di componente aggiuntivo ArcMap di esempio (VS2010, .NET 3.5) che utilizza uno strumento di script impacchettato all'interno del componente aggiuntivo che visualizza semplicemente il percorso python.exeutilizzato da ArcMap: http://wfurl.com/cbd5091

È solo un pulsante su cui fai clic e apre una finestra di messaggio con il percorso:

Pulsante Casella dei messaggi

I pezzi interessanti di codice:

  • 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)
  • Funzione 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();
    }

2
Ma questo documento non dice che, il programma di installazione di ArcGIS Desktop imposta il percorso di python.exe sulla variabile d'ambiente PATH dell'utente. Quindi può essere possibile che il percorso di Python non si trovi nella variabile d'ambiente PATH. Quindi creerà un errore. Quindi, come posso essere sicuro che il percorso dell'eseguibile python sia nella variabile d'ambiente PATH dell'utente.
Emi,

2
Non puoi, come la maggior parte delle cose nella vita e nell'informatica, tutto ciò che puoi fare è fare in modo che le ipotesi funzionino e sperare che le cose funzionino e avere un piano di fallback quando non lo fanno (fornire istruzioni su come aggiungerlo alla variabile d'ambiente PATH). Detto questo, se si tratta di un'installazione normale, credo che il programma di installazione di ArcGIS Desktop aggiunga quel percorso alla variabile d'ambiente PATH.
blah238,

2
Ho visto molte installazioni in cui il pitone installato da arcgis non era sul percorso. E se ci fossero due versioni installate e quella "sbagliata" fosse nel percorso?
blindjesse il

Ho offerto una soluzione nel mio terzo paragrafo che dovrebbe trovare l'installazione di Python di ArcGIS indipendentemente dalla PATHvariabile d'ambiente.
blah238,

@ blah238 la creazione di uno strumento di script non rende il mio componente aggiuntivo meno portatile o rende difficile il processo di installazione del componente aggiuntivo su altre macchine?
Emi,

6

Avrai accesso al registro?

Quando installa ArcMap installerà Python se non lo trova. Cerca nel registro per vedere se Python è già installato. Credo che la posizione del registro standard sia: computer \ HKEY_LOCAL_MACHINE \ SOFTWARE \ PYTHON \ PythonCore \ 2.7 \ InstallPath Con una chiave predefinita della posizione del percorso (2.7 è 10.1, 2.6 è 10.0)

Non riesco a pensare a un motivo per cui / perché il valore di questa chiave sarebbe errato, ma potresti sempre andare in questo modo: All'interno dell'hive Esri \ Desktop del registro si trova una posizione Python. È il semplice percorso che è possibile ottenere e quindi creare ulteriori percorsi per assicurarsi che esista un Python.exe. Ad esempio, la chiave su un computer a 64 bit viene installata su: computer \ HKEY_LOCAL_MACHINE \ SOFTWARE \ Wow6432Node \ ESRI \ Python10.1 con una chiave PythonDir e il valore Path associato

Ma mi piace la risposta di @ blah238. Basta aprire un prompt dal programma ed eseguirlo lì. Non riesco a vedere un motivo per cui questo non funzionerebbe.


2
Questo approccio è anche imperfetto perché potrebbero esserci più installazioni Python e non hai un modo semplice per determinare a livello di programmazione quale è quello utilizzato da ArcGIS. Se non stai eseguendo arcpy questo potrebbe non importare però. Tuttavia, penso che la soluzione più solida coinvolgerebbe il registro e un po 'di logica. Non ci andrò comunque.
blah238,

Bene, la logica dovrebbe iniziare con l'ultima versione 2.7 e tornare indietro. Ciò ovviamente potrebbe non riuscire se si installava una nuova versione di Python, quindi si installava una versione precedente di ArcGIS che installava una versione precedente di Python. Quindi sì, sono d'accordo su questo potenziale, ma non è probabile (o potresti semplicemente costruire una ricerca di arc10.1 = py2.7, arc10.0 = py26 ... ecc per essere sicuro al 100%). Come ho detto, il metodo migliore sarebbe probabilmente quello di sborsare al prompt dei comandi.
KHibma,

@KHibma Ho cercato nel registro. Ma penso che sia davvero fastidioso se guardo il tasto "PYTHON". Nella mia macchina, ci sono due versioni di Python installate e restituisce entrambe. Penso che sia una buona idea esaminare la chiave "ESRI" e se esiste una sottochiave "Python" con valore vero, allora posso prendere il valore della sottochiave "PythonDir". Funziona nel mio caso :)
Emi,

È un modo sbagliato di cercare il percorso Python nel registro tramite la chiave "ESRI"? O c'è qualche possibilità che, il modo in cui esri usa per creare chiavi e valori nel registro possa essere cambiato e il codice forse non può leggerlo
Emi,

Quando dico "cerca" nel registro, intendo usare i percorsi effettivi che ho fornito sopra. A meno che qualcuno non lo sappia meglio, la posizione di queste chiavi reg (nel registro) non cambierebbe da una macchina all'altra. Quindi dovresti semplicemente codificare i percorsi per vedere se esistono le chiavi lì, in caso affermativo qual è il valore ...
KHibma

5

[Modifica] Durante l'esecuzione a livello di setcodice (cancellato, di seguito) ha fatto quello che volevo, può essere realizzato più facilmente e con un codice più pulito usando Environment.GetEnvironmentVariables () .

Un'opzione sarebbe quella di scansionare ogni variabile d'ambiente sul sistema e provare a provare quanto segue:

1) Il valore della variabile di ambiente è una directory? (e se così fosse..)

2) Questa directory contiene python.exe?

Sono stato in grado di farlo a livello di codice eseguendo il setcomando tramite l' API di processo .Net . Il setcomando, se utilizzato senza un parametro, restituisce TUTTE le variabili di ambiente in uso dal sistema. Così ho potuto parassitare, quindi organizzare i risultati di STDOUT emessi sete selezionarli per vedere se qualcosa (e intendo QUALCOSA ) disponibile attraverso l'ambiente del sistema alla fine ha indicato python.exe.

Da questa pagina si discute il setcomando:

Digitare SET senza parametri per visualizzare tutte le variabili di ambiente correnti.

Per illustrare ho scritto una combinazione di metodi (e una classe di supporto ) che fa ciò di cui ho discusso sopra. Questi possono essere ottimizzati e potrebbero usare alcune prove antiproiettile (Try..Catch, ecc.), Ma se il computer ha QUALSIASI variabile ambientale che punta a python.exe, questo approccio dovrebbe trovarlo! Non mi interessa se il var è chiamato PATH, ABBRACADABBRAo qualsiasi altra cosa .. se punta a python.exe, questo dovrebbe trovarlo.

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

Ecco termsuna matrice di stringhe che passi alla routine da cercare nel nome della variabile d'ambiente o nei suoi nvalori (cioè PATHpuò avere diversi valori, ma la maggior parte degli altri var ne avrà solo uno). Assicurati che tutte le stringhe termssiano IN MAIUSCOLO!

(Quando ho provato questo, ho usato semplicemente "PYTHON", che C:\Python27\python.exeho trovato sul mio sistema di casa. Ma potresti facilmente estenderlo per includere un'altra stringa [] di termini se volessi ispezionare ulteriormente il percorso di tutti i python.execandidati restituiti --- per esempio, per vedere se fossero nel cestino ArcGIS, ecc.)

// 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;
}    

E alla fine della mia classe principale, ho incluso la seguente classe Helper :

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

    public string key;
    public string[] values;
}

1
Ciò è fragile, poiché l'utente può personalizzare la directory di installazione di Python nel programma di installazione di ArcGIS Desktop. Inoltre, la PYTHONPATHvariabile NON è quella desiderata.
blah238,

@ blah238, a volte fragile è tutto ciò che hai. Sono stato davvero sorpreso di vedere quell'Arco collegato contro PYTHONPATH. Questa è un'installazione 9.2 predefinita. Tuttavia, l'OP ha chiesto come raggiungere programmaticamente ArcGIS python.exe e l'approccio che ho raccomandato, fragile o no, lo fa.
elrobis,

Non posso dire di aver capito il voto negativo, questa risposta è davvero " non utile "? Potrebbe non essere eccezionale , ma è certamente un'opzione, probabilmente funzionerebbe per una tipica installazione Arc e, per lo meno, aggiunge qualcosa di utile al thread - in particolare, illustra un'installazione Arc predefinita che opta per collegare il suo python. exe con una variabile di ambiente diversa da PATH.
elrobis,

Scusa ma non sei corretto. La variabile PYTHONPATH viene utilizzata da Python per trovare i moduli, non da ArcGIS per trovare Python. Controlla il link.
blah238,

@ blah238, penso che lo screenshot sia stato travolgente / oscurando il punto che stavo cercando di fare. (In particolare, il mio suggerimento all'OP non intendeva enfatizzare PYTHONPATH, che era solo l' unica variante di quel particolare sistema che puntava indietro python.exe.) Comunque, ho revisionato la mia risposta per includere un esempio di codice C # funzionante, e apprezzerei sapendo se non sei ancora d'accordo con questo approccio. Grazie / E.
elrobis,

4

Vorrei offrire una soluzione alternativa, basata sul mio commento nella domanda sopra. Per un progetto attuale, sto facendo qualcosa di molto simile; Ho un componente aggiuntivo .NET che, quando l'utente fa clic su un pulsante nell'interfaccia utente di ArcMap, viene eseguito uno script Python. Ho reso obbligatorio avere una variabile ambientale PATH impostata sull'eseguibile ArcGIS Python, in questo modo non devo preoccuparmi di includere il percorso dell'exe Python nel mio codice .NET.

Ora, durante lo sviluppo, i tester stanno semplicemente impostando manualmente la variabile PATH. Ma alla fine avrò un programma di installazione di Windows (exe) che installerà il componente aggiuntivo, installerà eventuali dipendenze di Python e imposterà tutte le variabili PATH necessarie. Per questo, sto usando Nullsoft Scriptable Install System (NSIS) , un sistema open source per la creazione di programmi di installazione di Windows. Ecco alcuni dei codici che ho elaborato finora, il che è piuttosto approssimativo. Fondamentalmente, cerca nel registro per vedere se ci sono le variabili PATH di interesse e se non lo sono le aggiunge. Deve essere eseguito come amministratore, ovviamente.

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

Quindi, ancora una volta, questo non trova il percorso di ArcGIS Python exe, ma ti consente di dare all'utente finale il potere di impostarlo correttamente e facilmente.


+1 Sono completamente d'accordo con questa raccomandazione --- dove ad alto livello, Chad sta dicendo "non risolvere il problema all'indietro per dedurre l'istanza python di Arc, piuttosto usare un programma di installazione e lasciarlo a SysAdmin per stabilire il pitone corretto esempio." @ChadCooper, NSIS ti offre alcun controllo dell'interfaccia utente in modo da poter sovrascrivere quei percorsi predefiniti se lo desideri? Non lo vedo implicito nel codice ma scommetto che è lì.
elrobis,

@elrobis - Scommetto che puoi sovrascrivere / modificare / cambiare quelli esistenti - NSIS è molto configurabile e può permetterti di creare un programma di installazione piuttosto fluido - devi solo capire il codice per scriverlo.
Chad Cooper,

La creazione di un programma di installazione per un componente aggiuntivo sembra un po 'folle. Inoltre, quali modifiche dovresti apportare per supportare 10.1, 10.2, ecc. E 10.0?
blah238,

@ blah238 - sì, sembra folle, ma il mio installatore per questo particolare progetto farà molto di più, come si è detto. Il mio componente aggiuntivo è rigorosamente per 10.0. Suppongo che per diverse versioni di ArcGIS potresti controllare il registro per vedere quale versione è installata, quindi agire di conseguenza.
Chad Cooper,
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.