Forcing Python Toolbox tool to break loop and do cleanup when user clicks Cancel?

Question

I am writing a Python tool that perform heavy tasks in a loop. When the user clicks "Close" I want to break the loop, perform some cleanup, and then finish.

Consider this example tool that counts down from ten:

import arcpy
import time

class Tool(object):

   def __init__(self):
      self.label = "Cancel Test"
      self.description = "Tests how the cancel function works."
      self.canRunInBackground = False

   def execute(self, parameters, messages):
      for i in range(10, -1, -1):
         arcpy.AddMessage(i)
         time.sleep(1)
      arcpy.AddMessage("We have lift-off!")
      return

When I click "Close" in the beginning of the execution it does not brake the loop or give me an opportunity to perform any clean up. Instead it loops to the very end and adds the message "We have lift-off!" before it outputs this:

Completed script CancelTest...
Cancelled function
(CancelTest) aborted by User.
Failed at [TIME] (Elapsed Time: 10,01 seconds)

I have found documentation for ArcGIS Pro (that uses Python 3.4) that describes how you can do this there using isCancelled:

import arcpy
import time

#Make sure it does not auto cancel.
arcpy.env.autoCancelling = False

class Tool(object):

   def __init__(self):
      self.label = "Cancel Test"
      self.description = "Tests how the cancel function works."
      self.canRunInBackground = False

   def execute(self, parameters, messages):
      for i in range(10, -1, -1):
         arcpy.AddMessage(i)
         time.sleep(1)
         #Check if the user clicked "Close"
         if arcpy.env.isCancelled:
            arcpy.AddMessage("Launch aborted!")
            return
      arcpy.AddMessage("We have lift-off!")
      return

However, when I run this from ArcCatalog 10.3 (i.e. not using ArcGIS Pro) it gives me the following error:

Traceback (most recent call last):
  File "H:\Mina Dokument\DGD\Python\CancelTest.py", line 19, in execute
    if arcpy.env.isCancelled:
AttributeError: 'GPEnvironment' object has no attribute 'isCancelled'

Is there anyway to mimic the behavior that is available in ArcGIS Pro in an ordinary Python toolbox using Python 2.7?

Answer 1

Farid Cher's answer is partially correct.

You can use the Progressor to 'catch' a cancel event from within a Python script, and you can also do whatever cleanup necessary as well, if you enclose the call within a try ... except clause.

For example, a python toolbox:

import arcpy
import time

class Toolbox(object):
    def __init__(self):
        self.label = "Toolbox"
        self.alias = ""
        self.tools = [Tool]


class Tool(object):
    def __init__(self):
        self.label = "Tool"
        self.description = ""
        self.canRunInBackground = False

    def execute(self, parameters, messages):
        some_stuff = [] # a variable to cleanup later
        max = 1000
        arcpy.SetProgressor('step','Testing ArcPy script cancel',0,max,1)

        # You don't have to be in a for loop, but this is the
        # easiest way to show an example
        for i in range(max):
            try: 
                # only put SetProgressorPosition in this clause
                # otherwise you can catch other errors that aren't
                # the user cancelling
                arcpy.SetProgressorPosition()
            except:
                arcpy.AddWarning('User canceled at i = {0}'.format(i))
                del some_stuff # cleanup
                return
            time.sleep(0.1)
            some_stuff.append(i)
        arcpy.AddMessage('User did not cancel')
        del some_stuff

This allows the user to run the tool:

And then cancel, which is handled gracefully (and still counted as a failed run):

edit: This doesn't appear to work with 10.3 or ArcGIS Pro.

To catch the cancels (tested in ArcGIS Pro), we bring back our good friend arcgisscripting. This is similar to catching the cancel from the progressor, but the entire execute function, or at least the majority of it, needs to be inside the try:

import arcpy
import arcgisscripting
import time

class Toolbox(object):
    def __init__(self):
        self.label = "Toolbox"
        self.alias = ""
        self.tools = [Tool]


class Tool(object):
    def __init__(self):
        self.label = "Tool"
        self.description = ""
        self.canRunInBackground = False

    def execute(self, parameters, messages):
        try:
            some_stuff = []
            max = 1000
            arcpy.SetProgressor('step','Testing ArcPy script cancel',0,max,1)

            for i in range(max):
                arcpy.SetProgressorPosition()
                time.sleep(0.1)
                some_stuff.append(i)
        except arcgisscripting.ExecuteAbort:
            arcpy.AddWarning('User cancelled at i={0}'.format(i))
            del some_stuff
            return
        arcpy.AddMessage('User did not cancel')
        del some_stuff

Answer 2

Your message is clear:

AttributeError: 'GPEnvironment' object has no attribute 'isCancelled'

In fact arcpy.env.autoCancelling and arcpy.env.isCancelled are added in Arcgis Pro 1.1 (planned for ArcGIS 10.4)

Furthermore, if you use Arcgis 10.3, these features are not available.

Answer 3

The closest way that I can think of is the use of Progressor in Arcpy. Using progressor, once the user press the cancel button the loop breaks and the execution terminates. However you can not do any cleanup! Here is a sample code:

def execute(self, parameters, messages):
    import time
    n=10
    p=1
    arcpy.SetProgressor("step",
                        "Step progressor: Counting from 0 to {0}".format(n),
                        0, n, p)
    loopTime=.3
    for i in range(n):
        if (i % p) == 0:
            ## put your custom code here
            ## it will break the loop if the user cancels. and the tool execution terminates
            arcpy.SetProgressorLabel("Iteration: {0}".format(i))
            arcpy.SetProgressorPosition(i)
            time.sleep(loopTime)

    arcpy.AddMessage("You will not get here to do cleanup if the loop terminates prematurelly")
    arcpy.SetProgressorLabel("Iteration finished: {0}".format(i + 1))
    arcpy.SetProgressorPosition(i + 1)

    return

Update (To answer the questions in the comment):

why using a progressor changes how the program behaves, other than adding a nice looking progress bar?

The progressor is a kind of multi-thread processing. each time the progressor steps forward, the GUI (a separate thread) must be updated. While using a progressor, you are running your code in another inline thread. However it is not definitely like Background geo-processing in which you can run multiple thread simultaneously.

Does using a progressor make ArcGIS brake the code when the user press "Cancel"?

Yes, note that the breaking happens in the loop, where you are updating your progress bar (e.g. like the example above)

where does it break? Is it directly after whatever line it happens to be at when the button is pressed?

The breaking happens between any two progress steps that the user clicks the cancel button. In the above code example its:

if (i % p) == 0:
            ## put your custom code here
            ## it will break the loop if the user cancels. and the tool execution terminates
            arcpy.SetProgressorLabel("Iteration: {0}".format(i))

If the user click cancel, your custom code will be executed until it reaches arcpy.SetProgressorLabel("Iteration: {0}".format(i)). This is where the gp tool will get notified of the cancel event (e.g. kill the separate inline thread)