At the Spatial Analysis and Geoprocessing island at this year’s user conference, several folks asked us about running a Python script or ModelBuilder model at a prescribed time — usually in the early morning when their computers are bored and just waiting for something to do. We thought it would be good to make a post about this and to share some tips.
The first place to start is with the help topic Scheduling a Python script to run at prescribed times. This topic is kind of buried in the help system so it’s easy to miss. The meat of this topic shows you how to launch Window’s Task Scheduler on various operating systems (Windows 7, XP, and so on). The screenshot below shows the Task Scheduler on Windows 7. There’s a lot stuff you can do with the task scheduler and you’ll just have to play around with it and read the Windows help. The Actions pane, on the right, has the Create Basic Task action, and this is the place to start.
Clicking on Create Basic Task opens a wizard where you define the name of your task, the trigger (when it runs), and the action (what program to run). The screenshot below shows the Action tab where you specify the name of your Python script to run as well as any arguments to the script.
The Action tab is where we have a few tips, as follows.
Run the Python executable with arguments
To ensure that your Python script will run regardless of the login account that the schedule task uses, and to avoid any confusion about which version of Python is used in mixed environments (64bit or 32bit), we recommend that you run the Python executable with the name of your Python file as an argument to the executable.
Suppose location; copy and paste the following code into a new Python script then execute the script. The script will print the location of
python.exe as well as other information about your Python environment.
[sourcecode language=”Python”]
import sys
import platform
import imp
print("Python EXE : " + sys.executable)
print("Architecture : " + platform.architecture()[0])
print("Path to arcpy : " + imp.find_module("arcpy")[1])
raw_input("nnPress ENTER to quit")[/sourcecode]
After determining the location of
python.exe, this is what is entered in the Action panel of the task scheduler:
If there are additional arguments (parameters) to your script, provide them after the path to your script. For example, the following command line executes a Python script that takes two arguments; the path to a feature class and an integer.
[sourcecode]C:Python27ArcGIS10.2python.exe "E:My ScriptsDoConversion.py" c:gisWorkgdb.mdbcounties 10[/sourcecode]
We typically recommend writing scripts so that they take arguments like the above example rather the hard-coding dataset paths or values within the script. However, this is one case where hard-coding paths and values in your script works to your advantage; rather than changing argument values in the task scheduler, it’s easier to just edit your script to use different paths or values.
If you’re familiar with
.bat files in Windows, you can have the task scheduler run a
.bat file that in turn runs your script with arguments. The contents of the
.bat is the single command line shown above.
Remember that if any of your arguments contain spaces, you need to enclose the argument in double quotes. In the above example,
E:My ScriptsDoConversion.py contains a space, so double quotes are required.
Running models at a prescribed time
A common misconception is that in order to run a model as a Python script, you must first export the model to a Python script. Geoprocessing is designed so that models are tools, just like all the tools delivered with the ArcGIS. That means you can run your model within Python just like any other geoprocessing tool. All you need to do is import the toolbox containing your model using the ImportToolbox function, then run your model within Python.
For example, the model to the left imports a
.gpx file to a geodatabase, adds a field, calculates it to the current date and time, then appends all those features into a “master” feature class.
To run this model on a schedule, all that’s needed is to execute the model within a script. Here’s the Python script to run the model:
[sourcecode language=”Python”]
import arcpy
import os
from datetime import datetime
# Import the toolbox containing the model. This toolbox
# has an alias of "gpxtools"
#
arcpy.ImportToolbox(r"c:importgpxmyGPXstuff.tbx")
# Run the model. The model has two parameters, the input
# .gpx file and the feature class to update
#
arcpy.ImportGPX_gpxtools(r"c:ftpinboxdatadrop.gpx",
r"c:ftpserver.sdegpx_tracks")
# Now that the input gpx file has been processed, rename it
# to have the date and time.
#
os.rename(r"c:ftpinboxdatadrop.gpx",
r"c:ftpinboxdatadrop{}.gpx".format(datetime.strftime(datetime.now(), "%Y%m%d"))
[/sourcecode]
Advanced options
The Create Basic Task wizard allows you to set basic properties of the task. Once the task is created, you can examine its properties and refine its triggers and actions. For example, you can have your task run every five minutes for three hours. You can set up a task with advanced options using the Create Task action.
Start simple
When I started writing this blog, it had been a long time since I messed around with scheduled tasks, so I started with a simple script that wrote information to a log file. I scheduled it to run every minute for ten minutes so I could test changes to the script soon after I made them. It was a great way to test and understand how scheduling worked before committing to running the “real” script. Here’s my simple script:
[sourcecode language=”Python”]
import sys
import platform
import imp
print "Importing arcpy… this may take a momentn"
import arcpy
# Open a log file to write to
#
f = open(r’E:schedule.log’,’w’)
# Write date/time
#
f.write(time.strftime(‘%x %X’))
f.write(‘n’)
# Test receiving of arguments/parameters via arcpy
#
f.write("Parameter 0 : " + arcpy.GetParameterAsText(0) + "n")
# Python info
#
f.write("Python EXE : " + sys.executable + "n")
f.write("Architecture : " + platform.architecture()[0] + "n")
f.write("Path to arcpy : " + imp.find_module("arcpy")[1] + "n")
f.close()
[/sourcecode]
Ghislain Prince contributed to this post