How can I stop a long Cadwork Python script with ESC during execution?

[mankatmalte-dev]

Hi everyone,
I have a long‑ running Cadwork Python script that loops through many elements (clean dims, keep cutters, subtract, delete, etc.). While it works fine, I’d like to stop it at any moment by pressing ESC.
Any recommendations? Thanks in advance !
Here is my current code:

`import cadwork
import attribute_controller as ac
import connector_axis_controller as ca
import element_controller as ec
import utility_controller as uc
import geometry_controller as gc
import visualization_controller as vc

element_ids = ec.get_active_identifiable_element_ids()
total_pieces = len(element_ids)

# define your storage lists
all_kept_cutters = []
kept_cutters_by_main = {}
counter = 0

for element_id in element_ids:
    counter += 1
    uc.print_message(f"{counter} of {total_pieces} pieces have been processed", counter, 0)
    
    # Check if element has already been processed
    try:
        if ac.get_user_attribute([element_id], 9) == "Script Done":
            continue
    except:
        pass
    
    # Check if element is a panel, auxiliary, or beam
    try:
        if not (ac.is_panel(element_id) or ac.is_auxiliary(element_id) or ac.is_beam(element_id)):
            continue
    except:
        pass
    
    try:
        ec.convert_elements_to_auxiliary_elements([element_id])
    except:
        pass

    try:
        ec.convert_auxiliary_to_panel([element_id])
    except:
        pass

    try:
        gc.auto_regenerate_axes([element_id])
    except:
        pass

    # read dims
    try:
        get_length = gc.get_length(element_id)
        get_width  = gc.get_width(element_id)
        get_height = gc.get_height(element_id)
    except:
        pass

    # delete processes & keep cutting bodies
    kept_cutters = []
    try:
        kept_cutters = ec.delete_processes_keep_cutting_bodies([element_id], True)
    except:
        pass

    # ---- INSIDE LOOP ----
    if kept_cutters:
        all_kept_cutters.extend(kept_cutters)
        kept_cutters_by_main[element_id] = kept_cutters

        # process each kept cutter (axes -> read dims -> set real dims)
        for kid in kept_cutters:
            try:
                gc.auto_regenerate_axes([kid])
            except:
                pass

            try:
                kh = gc.get_height(kid)
                kl = gc.get_length(kid)
                kw = gc.get_width(kid)

                try:
                    gc.set_height_real([kid], kh)
                except:
                    pass

                try:
                    gc.set_length_real([kid], kl)
                except:
                    pass

                try:
                    gc.set_width_real([kid], kw)
                except:
                    pass

            except:
                pass

    # commit cleaned real dimensions
    try:
        L = gc.get_length(element_id)
        W = gc.get_width(element_id)
        H = gc.get_height(element_id)

        try:
            gc.set_height_real([element_id], H)
        except:
            pass

        try:
            gc.set_length_real([element_id], L)
        except:
            pass

        try:
            gc.set_width_real([element_id], W)
        except:
            pass

    except:
        pass

    # FINAL TWO STEPS (cutters = HARD)
    if kept_cutters:
        # 1. Cut: kept cutters (hard) cut the main element (soft)
        try:
            result_ids = ec.subtract_elements(kept_cutters, [element_id])
        except:
            pass

        # 2. Delete the cutter bodies
        try:
            ec.delete_elements(kept_cutters)
        except:
            pass

    ac.set_user_attribute([element_id], 9, "Script Done")

# Activate all processed elements
vc.set_active(element_ids)
uc.print_error("Script is finished. All pieces have been processed.")`

[9and3]

Hello @mankatmalte-dev ,

There's no built-in ESC listener in the cadwork Python API out of the box, but since you're on Windows you could use ctypes.windll.user32.GetAsyncKeyState to poll for ESC non-blockingly. Combine it with QApplication.processEvents() so cadwork stays responsive while paused:

import ctypes
import time

VK_ESCAPE = 0x1B  # ESC code on Win

def esc_pressed():
    return ctypes.windll.user32.GetAsyncKeyState(VK_ESCAPE) & 0x8000 != 0

paused = False

for i in range(1, 501):
    if esc_pressed():
        if not paused:
            paused = True
            print(f"Paused at {i}. Press ESC again to resume...")
            time.sleep(0.3)
            while True:
                if esc_pressed():
                    paused = False
                    print("Resumed.")
                    time.sleep(0.3)
                    break
    print(f"Count: {i}/500")

print("Done.")

The time.sleep(0.3) debounces the keypress so one ESC doesn't toggle twice. app.processEvents() in the pause loop keeps cadwork's UI alive, meaning you can still orbit, zoom, etc. while paused.

I just tested it with this vanilla example.