reload the currently running python script

Question

In python ,There is a reload method to reload an imported module , but is there a method to reload the currently running script without restarting it, this would be very helpful in debugging a script and changing the code live while the script is running. In visual basic I remember a similar functionality was called "apply code changes", but I need a similar functionality as a function call like "refresh()" which will apply the code changes instantly.

This would work smoothly when an independent function in the script is modified and we need to immediately apply the code change without restarting the script.

Inshort will:

reload(self) 

work?

Answer 1

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

Answer 2

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

Answer 3

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.

Answer 4

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()

Answer 5

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.

Answer 6

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

Answer 7

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