You can nest multiple interruptable operations. For example:

# Start the overall, long operation.
with hou.InterruptableOperation("Beginning operation",
                                "Performing a Long Operation",
                                open_interrupt_dialog=True) as iop:
    for i in range(num_tasks):
        # Update overall progress
        operation.updateLongProgress(i / num_tasks)

        # Start the sub-operation
        with hou.InterruptableOperation(f"Performing Task {i + 1}") as sub_iop:
            for j in range(num_subtasks):
                # Update sub-operation progress
                sub_iop.updateProgress(j / num_subtasks)

                #
                # PERFORM SUBTASK HERE.
                #

You can use the timeout_ms argument when you create the context object to limit the amount of time an operation can take.

• Hitting the time limit raises hou.OperationInterrupted, just like the user pressing ⎋ Esc.

• Just like the user pressing ⎋ Esc, the timeout is usually only checked when you call the updateProgress() method, so you need to call the method regularly inside the block.

  Some HOM functions may internally update progress, which can also trigger a check of the timeout. For example, you can wrap a call to LopNode.stagePrimStats() in a hou.InterruptableOperation block with a timeout, and the timeout will interrupt stagePrimStats() because internally stagePrimStats() updates Houdini as it works.

For example, this modified version of the example would normally run for 10 seconds, but will display Interrupted after 1 second because of the timeout_ms=1000 argument:

import time
import hou

try:
    with hou.InterruptableOperation("Waiting around doing nothing",
                                    timeout_ms=1000) as iop:
        for i in range(100):
            # Real work would go here, instead we'll just go to sleep
            time.sleep(0.1)
            iop.updateProgress(i / 100)
except hou.OperationInterrupted:
    # The user pressed Esc (or the operation timed out if you used the
    # timeout_ms argument)
    hou.ui.displayMessage("Interrupted")
else:
    # The operation finished without interruption
    hou.ui.displayMessage("Completed")

• By default, Houdini only shows the progress as text in the status line. If you pass open_interrupt_dialog=True when you create the object, Houdini will open a progress dialog that shows progress using a progress bar. You should generally open a dialog if the operation could take more than one or two seconds.

• The call to updateProgress() takes a small amount of time that can add up. Inside tight loops you may want to only call it, for example, every 10th iteration instead of every iteration.

• hou.InterruptableOperation` does not work in the Python Shell. If you just want to try it out, use a shelf tool.

• Houdini may not display every progress update in the status bar. It updates the status bar on its own schedule for performance reasons.

• Trying to create this object outside of a with statement will raise hou.OperationFailed.