Reload All

[Emmanuel]

Emmanuel a écrit :

> 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.

euh... Can I ???