Reload All

[Emmanuel]

Hi,


I use a 'reload all' feature in my app, that allow to reload every
module.

I first try this version :

import sys
def Reload():
    for a in sys.modules.values():
        if ( type(a) == type(sys) ):            # I can't remember why
            if ( '__file__' in dir ( a ) ):        # to avoid reload of
extending C module
                try:
##                    print a.__name__
                    reload ( a )
                except ImportError:
                    Log ("Reload", "error importing module" +
a.__name__)


but there are some cases where the order of the reload is important.
I came into this one :

CODE :
===============
Base.py
----------
class Base:
    def __init__(self):
        print "Base Init"

Derived.py
------------
import Base
class Derived( Base.Base):
    def __init__(self):
        Base.Base.__init__(self)
        print "Derived additional init"

In order to reload all to work, Base _MUST_ be reloaded before Derived.

So I continue with this code, modified from something I get on the forum
:
----------------------------------------------------
import inspect

def reload_from_root(root):
    if(not inspect.ismodule(root)):
        print 'root is not a module!!  Failing.'
        print type(root)

    #Keeping lists of pairs where pairs are (parent, child)
    #to establish module relationships and prevent
    #circular reloads
    reload_me = [(None, root)]
    reloaded = []

    while(len(reload_me) > 0):
        tmp = reload_me.pop()

        for x in inspect.getmembers(tmp[1]):
          if(inspect.ismodule(x[1])):
              if ( '__file__' in dir ( x[1] ) ):
                  if((tmp[1], getattr(tmp[1], x[0])) not in reloaded):
                      reload_me.append((tmp[1], getattr(tmp[1], x[0])))


##        reload(tmp[1])            # If I use reload here, the child is
always reloaded before the parent
        reloaded.append((tmp[0], tmp[1]))

    reloaded.reverse()
    TheReloaded = []
    for pair in reloaded:
        if (pair[1] not in TheReloaded ):        # Don't reload twice
the Base, else it can reload in this order :
                                                                # Base -
Derived1 - Base- Derived2
                                                                # and
Derived1 init will fails
            reload (pair[1])
            TheReloaded.append( pair[1])
----------------------------------------------------


This code solves my current problems, but I can imagine some possible
issue with two levels hierarchies.

So is there a perfect solution ?

Thanks by advance,

Emmanuel