Running the ExcelToTable.py GP tool within a DropHandler add-in
I am attempting to run the ExcelToTable.py Geoprocessing script within a C# DropHandler class. The intent here is to allow the user to simply drop an Excel file containing attribute updates onto the map, and have the GP tool automatically handle the table import.
Going through the Geoprocessing samples, I see that since this GP tool is a python script, I cannot use the Geoprocessing.ExecuteToolAsync() method. Rather, I must use the Process.Start() method to run python scripts from within the ProSDK. Using the community samples snippet as a guide, I am able to get the ExcelToTable.py script to run, however I am unable to figure out how to pass the input file and output table parameters to the python script. In the community samples, there are no parameters being passed into the script, so I don't have an example to follow.
The code I have so far within the DropHandler class:
public override async void OnDrop(DropInfo dropInfo)string InputFile = dropInfo.Items[0].Data.ToString();
string OutputTable = @"C:\Test\DropTest.gdb\Test1";
Debug.WriteLine($"File: {InputFile}");
// pro SDK snippet
var pathProExe = System.IO.Path.GetDirectoryName((new Uri(Assembly.GetEntryAssembly().CodeBase)).AbsolutePath)
if (pathProExe == null) return;
pathProExe = Uri.UnescapeDataString(pathProExe);
pathProExe = System.IO.Path.Combine(pathProExe, @"Python\envs\arcgispro-py3");
Debug.WriteLine(pathProExe);
var pathPython = @"C:\Program Files\ArcGIS\Pro\Resources\ArcToolBox\Scripts\ExcelToTable.py";
var myCommand = $@"/c """"{System.IO.Path.Combine(pathProExe, "python.exe")}"" ""{pathPython}""""";
Debug.WriteLine(myCommand);
var procStartInfo = new ProcessStartInfo("cmd", myCommand);
procStartInfo.RedirectStandardOutput = true;
procStartInfo.RedirectStandardError = true;
procStartInfo.UseShellExecute = false;
procStartInfo.CreateNoWindow = true;
Process proc = new Process();
proc.StartInfo = procStartInfo;
proc.Start();
string result = proc.StandardOutput.ReadToEnd();
string error = proc.StandardError.ReadToEnd();
if (!string.IsNullOrEmpty(error)) result += string.Format("{0} Error: {1}", result, error);
System.Windows.MessageBox.Show(result);
The resulting Python error:
Which makes sense, since I never specified the Input file or output table. But at least this tells me that I am getting the script to start, albeit unsuccessfully.
procStartInfo.Arguments = "?"; // Do I pass the parameters here? If so, what is the syntax?
So in other words, what is the correct syntax for running the ExcelToTable.py script, given the string parameters of InputFile, and OutputTable? Do I use the above property of procStartInfo?
Thanks for your assistance!
Accepted Solutions
I haven't tried the ExcelToTable but I have run a number of GP Tools using the Geoprocessing.ExecuteToolAsync() and I'm thinking most of them are actually in python. Here is a method for running the RasterTIN_3d GP Tool
public static async Task<IGPResult> CallRasterToTIN_GPTool(string l_newRaster)
{
string l_outputTIN = Project.Current.HomeFolderPath + @"\Terrain Data\TINs";
// Make the sure the TINs subdirectory exists beneath Terrain Data
if (System.IO.Directory.Exists(l_outputTIN) == false)
{
System.IO.Directory.CreateDirectory(l_outputTIN);
}
l_outputTIN += @"\Range_TIN";
List<object> arguments = new List<object>
{
l_newRaster, // Input Raster
l_outputTIN, // Output TIN
};
var l_returnValue = await Geoprocessing.ExecuteToolAsync("RasterTIN_3d", Geoprocessing.MakeValueArray(arguments.ToArray()), null, null, null, GPExecuteToolFlags.None);
And here is another one for Creating a FeatureClass and optionally adding it to the map using the CreateFeatureclass_managment GP Tool.
public static async Task<IGPResult> CreateFeatureClass(string featureclassName, string featureclassType, SpatialReference a_spatialReference, bool a_addToMap = true)
{
System.Diagnostics.Debug.WriteLine(CoreModule.CurrentProject.DefaultGeodatabasePath);
List<object> arguments = new List<object>
{
CoreModule.CurrentProject.DefaultGeodatabasePath, // use the default geodatabase
featureclassName, // name of the feature class
featureclassType, // type of geometry
"", // no template
"DISABLED", // no m values
"ENABLED", // no z values
a_spatialReference
};
if (a_addToMap)
{
IGPResult l_returnResult = await Geoprocessing.ExecuteToolAsync("CreateFeatureclass_management", Geoprocessing.MakeValueArray(arguments.ToArray()));
if (l_returnResult.IsFailed == false)
{
// Confirm FeatureClass added to map as Layer. The only reason it would not is if user has turned
// on the feature that tells ArcGIS Pro not to add Geoprocessing results to the map
// This logic handles that condition
var l_layerReturned = MapView.Active.Map.FindLayers(featureclassName).FirstOrDefault() as FeatureLayer;
if (l_layerReturned == null)
{
Uri l_layerURI = new Uri(l_returnResult.ReturnValue);
await QueuedTask.Run(()=> LayerFactory.Instance.CreateLayer(l_layerURI, MapView.Active.Map) );
}
}
return l_returnResult;
}
else
{
return await Geoprocessing.ExecuteToolAsync("CreateFeatureclass_management", Geoprocessing.MakeValueArray(arguments.ToArray()),null,null,null,GPExecuteToolFlags.None);
}
}
You'll notice a pattern of passing a List<object> for each GP Tool. That's the trick is knowing what should be in that list. What I've generally done is make sure I can run the GP Tool via the ArcGIS Pro UI first. When successful, I then click the "Details" Link at the bottom of the Geoprocessing Dockpane and review the Parameters list. I then make sure when I implement it in code that the objects in my list align with Parameters list in the Details dialog as shown in attached screenshot. Good luck!
