How do you reload a Django model module using the interactive interpreter via “manage.py shell”?

Question

I know how to reload a regular Python module within a regular Python interpreter session. This question documents how to do that pretty well:

How do I unload (reload

Answer 1

Enable IPython autoreload extension before importing any code:

%load_ext autoreload
%autoreload 2

I use it with the regular django shell and it works perfectly, although it does have some limitations:

*Caveats:

Reloading Python modules in a reliable way is in general difficult, and unexpected things may occur. %autoreload tries to work around common pitfalls by replacing function code objects and parts of classes previously in the module with new versions. This makes the following things to work:

• Functions and classes imported via ‘from xxx import foo’ are upgraded to new versions when ‘xxx’ is reloaded.
• Methods and properties of classes are upgraded on reload, so that calling ‘c.foo()’ on an object ‘c’ created before the reload causes the new code for ‘foo’ to be executed.

Some of the known remaining caveats are:

• Replacing code objects does not always succeed: changing a @property in a class to an ordinary method or a method to a member variable can cause problems (but in old objects only).
• Functions that are removed (eg. via monkey-patching) from a module before it is reloaded are not upgraded.
• C extension modules cannot be reloaded, and so cannot be autoreloaded.*

source: https://ipython.org/ipython-doc/3/config/extensions/autoreload.html#caveats

Another great option is to write your code in a separate script and send it to django shell, like this:

manage.py shell < my_script.py

Answer 2

You can also use django-extensions project with the following command:

manage.py shell_plus --notebook

This will open a IPython notebook on your web browser instead of the IPython shell interpreter. Write your code there, and run it.

When you change your modules, just click on the web page menu item 'Kernel->Restart'

Re-running the code now uses your modified modules.

Answer 3

My solution on 2016 (in future it may be changed)

1.Install django_extension

2.Add next settings:

SHELL_PLUS = 'ipython'

IPYTHON_ARGUMENTS = [
    '--ext', 'autoreload',
]

3.Run shell

./manage.py shell_plus

See results:

model example

class Notification(models.Model):

    ........

    @classmethod
    def get_something(self):

        return 'I am programmer'

In shell

In [1]: Notification.get_something()
Out[1]: 'I am programmer'

Made changes on model

@classmethod
    def get_something(self):

        return 'I am Python programmer'

In shell

# shell does not display changes
In [2]: Notification.get_something()
Out[2]: 'I am programmer'

In shell. This is a magic

# configure extension of ipython
In [3]: %autoreload 2

In shell

# try again - all worked
In [4]: Notification.get_something()
Out[4]: 'I am Python programmer'

Made changes again

    @classmethod
    def get_something(self):

        return 'I am full-stack Python programmer'

In shell

# all worked again
In [5]: Notification.get_something()
Out[5]: 'I am full-stack Python programmer'

Drawback: 1. Need manually run code

%autoreload 2

since django_extension 1.7 has not support for run arbitrary code. May be in future release it has this feature.

Notes:

1. Django 1.10
2. Python 3.4
3. django_extension 1.7.4
4. Based (primary) on https://django-extensions.readthedocs.io/en/latest/shell_plus.html and http://ipython.readthedocs.io/en/stable/config/extensions/autoreload.html
5. Caution. It is may be produce an error, if you try change a code where used super().

Answer 4

Well, I think I have to answer to this. The problem is that Django caches its models in a singleton (singleton like structure) called AppCache. Basically, to reload Django models you need to first reload and re-import all the model modules stored in the AppCache. Then you need to wipe out the AppCache. Here's the code for it:

import os
from django.db.models.loading import AppCache
cache = AppCache()

curdir = os.getcwd()

for app in cache.get_apps():
    f = app.__file__
    if f.startswith(curdir) and f.endswith('.pyc'):
        os.remove(f)
    __import__(app.__name__)
    reload(app)

from django.utils.datastructures import SortedDict
cache.app_store = SortedDict()
cache.app_models = SortedDict()
cache.app_errors = {}
cache.handled = {}
cache.loaded = False

I've put all of this in a separate file called reloadmodels.py in the root directory of my Django site. Using IPython I can reload everything by running:

%run ~/mysite/reloadmodels.py

Answer 5

As far as I'm concerned, none of the above solutions worked on their own, also this thread didn't help much on its own, but after combining the approaches I managed to reload my models in shell_plus:

1. Make changes to the model (MyModel)
2. remove models.pyc

3. Clean Django model cache (like here):

    from django.db.models.loading import AppCache
    cache = AppCache()
    from django.utils.datastructures import SortedDict
    cache.app_store = SortedDict()
    cache.app_models = SortedDict()
    cache.app_errors = {}
    cache.handled = {}
    cache.loaded = False
   

4. Reload model like here

   reload(project.app.models)
   from project.app.models import MyModel
   

Answer 6

From the answers of Seti Volkylany and pv

1. Install IPython: pip install ipython
2. Run python manage.py shell : the symbol at the beginning of a line should now be In [1]: (in cmd it was >>>)
3. Run ipython profile create

4. Go in ~/.ipython/profile_default/ipython_config.py and open it in a text editor and add these two lines at the end:

   c.InteractiveShellApp.extensions = ['autoreload']
   c.InteractiveShellApp.exec_lines = ['%autoreload 2']

You can now run python manage.py shell, edit your models without having to write %autoreload 2