Since script tools share the application, you have control of the progressor. You can control the appearance of the progressor by choosing either the default progressor or the step progressor.
To learn more about the progress dialog box, see Understanding the progress dialog box in script tools
The code below demonstrates full use of the default and step progressor. Copy this code into your Python editor, save it, then create a script tool for it. The script tool has two Long integer parameters as described in the code comments. Then run the script tool, providing different values for the parameters (start with n = 10 and p = 1, then try n = 101 and p = 3).
'''
Demonstration script showing examples of using the progressor
Parameters:
n - number to count to (a good first choice is 10)
p - interval to count by (a good first choice is 1)
The various time.sleep() calls are just to slow the dialog down
so you can view messages and progressor labels.
'''
import arcpy
import time
n = arcpy.GetParameter(0)
p = arcpy.GetParameter(1)
readTime = 2.5 # Pause to read what's written on dialog
loopTime = 0.3 # Loop iteration delay
arcpy.AddMessage("Running demo with: {0} by {1}\n".format(n, p))
# Start by showing the default progress dialog, where the
# progress bar goes back and forth. Note how the progress label
# mimics working through some "phases", or chunks of work that
# a script may perform.
#
arcpy.SetProgressor("default", "This is the default progressor")
time.sleep(readTime)
for i in range(1, 4):
arcpy.SetProgressorLabel("Working on 'phase' {0}".format(i))
arcpy.AddMessage("Messages for phase {0}".format(i))
time.sleep(readTime)
# Setup the progressor with its initial label, min, max, and interval
#
arcpy.SetProgressor("step",
"Step progressor: Counting from 0 to {0}".format(n),
0, n, p)
time.sleep(readTime)
# Loop issuing a new label when the increment is divisible by the
# value of countBy (p). The "%" is python's modulus operator - we
# only update the position every p'th iteration
#
for i in range(n):
if (i % p) == 0:
arcpy.SetProgressorLabel("Iteration: {0}".format(i))
arcpy.SetProgressorPosition(i)
time.sleep(loopTime)
# Update the remainder that may be left over due to modulus operation
#
arcpy.SetProgressorLabel("Iteration: {0}".format(i + 1))
arcpy.SetProgressorPosition(i + 1)
arcpy.AddMessage("Done counting up\n")
time.sleep(readTime)
# Just for fun, make the progressor go backwards.
#
arcpy.SetProgressor("default", "Default progressor: Now we'll do a countdown")
time.sleep(readTime)
arcpy.AddMessage("Here comes the countdown...")
arcpy.SetProgressor("step",
"Step progressor: Counting backwards from {0}".format(n),
0, n, p)
time.sleep(readTime)
arcpy.AddMessage("Counting down now...\n")
for i in range(n, 0, -1):
if (i % p) == 0:
arcpy.SetProgressorLabel("Iteration: {0}".format(i))
arcpy.SetProgressorPosition(i)
time.sleep(loopTime)
# Update for remainder
#
arcpy.SetProgressorLabel("Iteration: {0}".format(i - 1))
arcpy.SetProgressorPosition(i - 1)
time.sleep(readTime)
arcpy.AddMessage("All done")
arcpy.ResetProgressor()Choosing a good increment when maximum is potentially large
It's not at all uncommon to write scripts that will iterate an unknown number of times. For example, your script may use a SearchCursor to iterate over all rows in a table, and you don't know the number of rows beforehand—your script may be used with tables of any size, from a few thousand rows to millions of rows. Incrementing a step progressor for every row in a large table is a performance bottleneck, and you may want to guard against such performance bottlenecks.
To demonstrate and assess performance issues with step progressors, copy the code below into your Python editor, save it, then create a script tool for it. The tool has two inputs: a table parameter and a field parameter. Run the script tool with a variety of table sizes, but be sure to try a table or feature class containing 10,000 or more rows to see performance differences.
The script executes three separate loops, and each loop fetches all the rows in the table. The loops differ in how they update the step progressor. The first and second loops update the step progressor in large increments, and the last loop increments the step progressor once for each row. When you run the tool, you see that this last loop takes longer to run.
You may want to employ the techniques found in this code for your script tools.
'''
Demonstrates a step progressor by looping through records
on a table. Use a table with 10,000 or so rows - smaller tables
will finish too quickly to assess.
1 = table name
2 = field on the table
'''
import arcpy
import time
import math
try:
inTable = arcpy.GetParameterAsText(0)
inField = arcpy.GetParameterAsText(1)
# Determine number of records in table
#
record_count = int(arcpy.GetCount_management(inTable).getOutput(0))
if record_count == 0:
raise ValueError("{0} has no records to count".format(inTable))
arcpy.AddMessage("Number of rows = {0}\n".format(record_count))
# Method 1: Calculate and use a suitable base 10 increment
# ===================================
p = int(math.log10(record_count))
if not p:
p = 1
increment = int(math.pow(10, p - 1))
arcpy.SetProgressor(
"step", "Incrementing by {0} on {1}".format(increment, inTable),
0, record_count, increment)
beginTime = time.clock()
with arcpy.da.SearchCursor(inTable, [inField]) as cursor:
for i, row in enumerate(cursor, 0):
if (i % increment) == 0:
arcpy.SetProgressorPosition(i)
fieldValue = row[0]
arcpy.SetProgressorPosition(i)
arcpy.AddMessage("Method 1")
arcpy.AddMessage("\tIncrement = {0}".format(increment))
arcpy.AddMessage("\tElapsed time: {0}\n".format(time.clock() - beginTime))
# Method 2: let's just move in 10 percent increments
# ===================================
increment = int(record_count / 10.0)
arcpy.SetProgressor(
"step", "Incrementing by {0} on {1}".format(increment, inTable),
0, record_count, increment)
beginTime = time.clock()
with arcpy.da.SearchCursor(inTable, [inField]) as cursor:
for i, row in enumerate(cursor, 0):
if (i % increment) == 0:
arcpy.SetProgressorPosition(i)
fieldValue = row[0]
arcpy.SetProgressorPosition(i)
arcpy.AddMessage("Method 2")
arcpy.AddMessage("\tIncrement = {0}".format(increment))
arcpy.AddMessage("\tElapsed time: {0}\n".format(time.clock() - beginTime))
# Method 3: use increment of 1
# ===================================
increment = 1
arcpy.SetProgressor("step",
"Incrementing by 1 on {0}".format(inTable),
0, record_count, increment)
beginTime = time.clock()
with arcpy.da.SearchCursor(inTable, [inField]) as cursor:
for row in cursor:
arcpy.SetProgressorPosition()
fieldValue = row[0]
arcpy.SetProgressorPosition(record_count)
arcpy.ResetProgressor()
arcpy.AddMessage("Method 3")
arcpy.AddMessage("\tIncrement = {0}".format(increment))
arcpy.AddMessage("\tElapsed time: {0}\n".format(time.clock() - beginTime))
arcpy.AddMessage("Pausing for a moment to allow viewing...")
time.sleep(2.0) # Allow viewing of the finished progressor
except Exception as e:
arcpy.AddError(e[0])