reload(self) will not work, because reload() works on modules, not live instances of classes. What you want is some logic external to your main application, which checks whether it has to be reloaded. You have to think about what is needed to re-create your application state upon reload.

Some hints in this direction: Guido van Rossum wrote once this: xreload.py; it does a bit more than reload() You would need a loop, which checks for changes every x seconds and applies this.

Also have a look at livecoding which basically does this. EDIT: I mistook this project for something else (which I didn't find now), sorry.

perhaps this SO question will help you

Intro

reload is for imported modules. Documentation for reload advises against reloading __main__.

Reloading sys, __main__, builtins and other key modules is not recommended.

To achieve similar behavior on your script you will need to re-execute the script. This will - for normal scripts - also reset the the global state. I propose a solution.

NOTE

The solution I propose is very powerful and should only be used for code you trust. Automatically executing code from unknown sources can lead to a world of pain. Python is not a good environment for soapboxing unsafe code.

Solution

To programmatically execute a python script from another script you only need the built-in functions open, compile and exec.

Here is an example function that will re-execute the script it is in:

def refresh(): with open(__file__) as fo: source_code = fo.read() byte_code = compile(source_code, __file__, "exec") exec(byte_code) 

The above will in normal circumstances also re-set any global variables you might have. If you wish to keep these variables you should check weather or not those variables have already been set. This can be done with a try-except block covering NameError exceptions. But that can be tedious so I propose using a flag variable.

Here is an example using the flag variable:

in_main = __name__ == "__main__" first_run = "flag" not in globals() if in_main and first_run: flag = True 

Take a look at reload. You just need to install the plugin an use reload ./myscript.py, voilà

Perhaps you mean something like this:

import pdb import importlib from os.path import basename def function(): print("hello world") if __name__ == "__main__": # import this module, but not as __main__ so everything other than this # if statement is executed mainmodname = basename(__file__)[:-3] module = importlib.import_module(mainmodname) while True: # reload the module to check for changes importlib.reload(module) # update the globals of __main__ with the any new or changed # functions or classes in the reloaded module globals().update(vars(module)) function() pdb.set_trace() 

Run the code, then change the contents of function and enter c at the prompt to run the next iteration of the loop.

test.py

class Test(object): def getTest(self): return 'test1' 

testReload.py

from test import Test t = Test() print t.getTest() # change return value (test.py) import importlib module = importlib.import_module(Test.__module__) reload(module) from test import Test t = Test() print t.getTest() 

None of these answers did the job properly for me, so I put together something very messy and very non-pythonic to do the job myself. Even after running it for several weeks, I am finding small issues and fixing them. One issue will be if your PWD/CWD changes.

Warning this is very ugly code. Perhaps someone will make it pretty, but it does work.

Not only does it create a refresh() function that properly reloads your script in a manner such that any Exceptions will properly display, but it creates refresh_<scriptname> functions for previously loaded scripts just-in-case you need to reload those.

Next I would probably add a require portion, so that scripts can reload other scripts -- but I'm not trying to make node.js here.

First, the "one-liner" that you need to insert in any script you want to refresh.

with open(os.path.dirname(__file__) + os.sep + 'refresh.py', 'r') as f: \ exec(compile(f.read().replace('__BASE__', \ os.path.basename(__file__).replace('.py', '')).replace('__FILE__', \ __file__), __file__, 'exec')) 

And second, the actual refresh function which should be saved to refresh.py in the same directory. (See, room for improvement already).

def refresh(filepath = __file__, _globals = None, _locals = None): print("Reading {}...".format(filepath)) if _globals is None: _globals = globals() _globals.update({ "__file__": filepath, "__name__": "__main__", }) with open(filepath, 'rb') as file: exec(compile(file.read(), filepath, 'exec'), _globals, _locals) def refresh___BASE__(): refresh("__FILE__") 

Tested with Python 2.7 and 3.

If you are running in an interactive session you could use ipython autoreload

autoreload reloads modules automatically before entering the execution of code typed at the IPython prompt.

Of course this also works on module level, so you would do something like:

>>>import myscript >>>myscript.main() *do some changes in myscript.py* >>>myscript.main() #is now changed