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

 

[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])

euh... Can I ???