provide an indirection layer that routes callbacks from registered objects to modules so that reloads have impact for examplethe script in example - goes the extra mile to indirectly dispatch callbacks to functions in an explicitly reloaded module the callback handlers registered with tkinter are method objects that do nothing but reload and dispatch again because the true callback handler functions are fetched through module objectreloading that module makes the latest versions of the functions accessible example - pp \gui\tools\rad py reload callback handlers dynamically from tkinter import import radactions from imp import reload get initial callback handlers moved to module in python class hello(frame)def __init__(selfmaster=none)frame __init__(selfmasterself pack(self make_widgets(def make_widgets(self)button(selftext='message 'command=self message pack(side=leftbutton(selftext='message 'command=self message pack(side=rightdef message (self)reload(radactionsradactions message (need to reload actions module before calling now new version triggered by pressing button def message (self)reload(radactionsradactions message (selfchanges to radactions py picked up by reload call the most recent versionpass self def method (self)print('exposed method 'called from radactions function hello(mainloop(when runthis script makes two-button window that triggers the message and message methods example - contains the actual callback handler code its functions receive self argument that gives access back to the hello class objectas though these were real methods you can change this file any number of times while the rad script' gui is activeeach time you do soyou'll change the behavior of the gui when button press occurs example - pp \gui\tools\radactions py callback handlersreloaded each time triggered def message ()change me reloading callback handlers dynamically