import
checks to see if the module is in sys.modules
, and if it is, it returns it. If you want import to load the module fresh from disk, you can delete the appropriate key in sys.modules
first.
There is the reload
builtin function which will, given a module object, reload it from disk and that will get placed in sys.modules
. Edit -- actually, it will recompile the code from the file on the disk, and then re-evalute it in the existing module's __dict__
. Something potentially very different than making a new module object.
Mike Graham is right though; getting reloading right if you have even a few live objects that reference the contents of the module you don't want anymore is hard. Existing objects will still reference the classes they were instantiated from is an obvious issue, but also all references created by means of from module import symbol
will still point to whatever object from the old version of the module. Many subtly wrong things are possible.
Edit: I agree with the consensus that restarting the interpreter is by far the most reliable thing. But for debugging purposes, I guess you could try something like the following. I'm certain that there are corner cases for which this wouldn't work, but if you aren't doing anything too crazy (otherwise) with module loading in your package, it might be useful.
def reload_package(root_module):
package_name = root_module.__name__
# get a reference to each loaded module
loaded_package_modules = dict([
(key, value) for key, value in sys.modules.items()
if key.startswith(package_name) and isinstance(value, types.ModuleType)])
# delete references to these loaded modules from sys.modules
for key in loaded_package_modules:
del sys.modules[key]
# load each of the modules again;
# make old modules share state with new modules
for key in loaded_package_modules:
print 'loading %s' % key
newmodule = __import__(key)
oldmodule = loaded_package_modules[key]
oldmodule.__dict__.clear()
oldmodule.__dict__.update(newmodule.__dict__)
Which I very briefly tested like so:
import email, email.mime, email.mime.application
reload_package(email)
printing:
reloading email.iterators
reloading email.mime
reloading email.quoprimime
reloading email.encoders
reloading email.errors
reloading email
reloading email.charset
reloading email.mime.application
reloading email._parseaddr
reloading email.utils
reloading email.mime.base
reloading email.message
reloading email.mime.nonmultipart
reloading email.base64mime
I eventually figured it out. Place:
import warnings
warnings.filterwarnings('ignore')
inside ~/.ipython/profile_default/startup/disable-warnings.py
. I'm leaving this question and answer for the record in case anyone else comes across the same issue.
Quite often it is useful to see a warning once. This can be set by:
warnings.filterwarnings(action='once')
Best Answer
IPython comes with some automatic reloading magic:
It will reload all changed modules every time before executing a new line. The way this works is slightly different than
dreload
. Some caveats apply, type%autoreload?
to see what can go wrong.If you want to always enable this settings, modify your IPython configuration file
~/.ipython/profile_default/ipython_config.py
[1] and appending:Credit to @Kos via a comment below.
[1] If you don't have the file
~/.ipython/profile_default/ipython_config.py
, you need to callipython profile create
first. Or the file may be located at$IPYTHONDIR
.