It should reload dependants instead of dependencies.

[Vanuan]

Consider this example:

Module dependant depends on module dependency. (each module prints __name__)

If we reload dependant:

import dependency
reload(dependency)

the dependant module won't be reloaded. It will print:

dependency
dependant
dependant

but it should print:

dependency
dependant
dependency
dependant

In your blog post http://www.indelible.org/ink/python-reloading/:
dependency is A
dependant is B

Quoting:

The solution to this problem is to also reload module B. [dependant]

But your code clearly doesn't do that.

Is there something I misunderstood?

[Vanuan]

I hope you don't mind if I used portions of your code in my similar project: https://github.com/Vanuan/module_reloader

Here are the changes I've made to also reload dependants:

Vanuan/module_reloader@a7dfb6a

The differences of my project from yours are:

• added reloadModifiedModules() function.
• supports only Jython
• uses nailgun (http://www.martiansoftware.com/nailgun/) for tests

[jparise]

I think I must be missing some import detail, but I believe the code is working as you suggest it should. To borrow your example:

# dependent.py
print __name__

# dependency.py
import dependency
print __name___

And then at the top-level scope:

import reloader
reloader.enable()

import dependency
reloader.reload(dependency)

... which prints:

dependent
dependency
dependent
dependency

[Vanuan]

I think you confused dependant and dependency. Dependant is something that
depends on (imports) other modules. Dependency is something other modules
(dependants) depend on (import).
So if we reload dependency, dependant should be reloaded after dependency.
As you showed yourself dependant is reloaded before dependency (print
statement executed before dependency imported).

Recheck your example please. Make sure that modules are properly named.
Your example just can't work (or you're not posting the complete code). As
far as you import only dependency, reloader has no way to know that
dependant depends on it (and it shouldn't have reloaded dependant).

[Vanuan]

Probably I wasn't clear enough. Sorry about that.
The correct example would be this:

# dependency.py
print __name__

# dependant.py
import dependency
print __name__

And then at the top-level scope:

import reloader
reloader.enable()

import dependant
import dependency

reloader.reload(dependency)

Expected behavior (notice that dependency should be reloaded first):

dependency
dependant
dependency
dependant

Actual behavior (dependant is not reloaded at all):

dependency
dependant
dependency

[ianepperson]

I expanded this a bit to see if I could sort it out (I couldn't). Here's a
more verbose test that defines a list called d in the dependency which is
modified by main.py as well as dependent.py, then rechecked by main.py
after the reload.

# dependency.py
print name

d = []

def add_to_d(item):
d.append(item)
print "d is %s" % d

# dependent.py
print "starting %s..." % name
from dependency import add_to_d, d
add_to_d('added by %s' % name)
print "finished %s." % name

# main.py
import reloader
reloader.enable()

import dependent
import dependency

dependency.add_to_d('added by Main')

print "Reloading..."
reloader.reload(dependency)
dependency.add_to_d('added my Main')
print "Reload done."

print 'dependency.d = %s' % dependency.d
print 'dependent.d = %s' % dependent.d

My result is (OSX, Python 2.7):

$ python main.py
starting dependent...
dependency
d is ['added by dependent']
finished dependent.
d is ['added by dependent', 'added by Main']
Reloading...
dependency
d is ['added my Main']
Reload done.
dependency.d = ['added my Main']
dependent.d = ['added by dependent', 'added by Main']

It seems clear that dependent.py never reloaded and subsequently has an old
reference to d.

Ian E.

On Tue, Nov 13, 2012 at 3:52 AM, John Yani notifications@github.com wrote:

Probably I wasn't clear enough. Sorry about that.
The correct example would be this:

dependency.py

print name

dependant.py

import dependency
print name

And then at the top-level scope:

import reloader
reloader.enable()

import dependant
import dependency

reloader.reload(dependency)

Expected behavior (notice that dependency should be reloaded first):

dependency
dependant
dependency
dependant

Actual behavior (dependant is not reloaded at all):

dependency
dependant
dependency

—
Reply to this email directly or view it on GitHubhttps://github.com//issues/14#issuecomment-10323730.

This email is intended for the use of the individual addressee(s) named
above and may contain information that is confidential, privileged or
unsuitable for overly sensitive persons with low self-esteem, no sense of
humor or irrational religious beliefs. If you are not the intended
recipient, any dissemination, distribution or copying of this email is not
authorized (either explicitly or implicitly) and constitutes an irritating
social faux pas. Unless the word absquatulation has been used in its
correct context somewhere other than in this warning, it does not have any
legal or grammatical use and may be ignored. No animals were harmed in the
transmission of this email, although the yorkshire terrier next door is
living on borrowed time, let me tell you. Those of you with an overwhelming
fear of the unknown will be gratified to learn that there is no hidden
message revealed by reading this warning backwards, so just ignore that
Alert Notice from Microsoft: However, by pouring a complete circle of salt
around yourself and your computer you can ensure that no harm befalls you
and your pets. If you have received this email in error, please add some
nutmeg and egg whites and place it in a warm oven for 40 minutes. Whisk
briefly and let it stand for 2 hours before icing.

[Vanuan]

So, do you agree that dependant should be reloaded?
Now check what happens if we reload only dependant. You'll see that
reloading dependency is not necessary.

[ianepperson]

Yes absolutely. I expected dependent.py to be reloaded - I thought that's
what the reloader library did. At this point, either I have a
misunderstanding of this library or there's a bug. If I change the code to
reload(dependent), it functions correctly - dependency reloads, then
dependent reloads and all the references are correct. However, that seems a
bit backwards because if I need to reload the dependency, I reload
dependent?

Regardless, reload() is performing exactly as its docstring indicates:
Reload an existing module.

Any known dependencies of the module will also be reloaded.

I suppose we're thinking of a complementary function that reloads any
dependents of the module for a proper reload.

Ian E.

On Tue, Nov 13, 2012 at 11:59 PM, John Yani notifications@github.comwrote:

So, do you agree that dependant should be reloaded?
Now check what happens if we reload only dependant. You'll see that
reloading dependency is not necessary.

—
Reply to this email directly or view it on GitHubhttps://github.com//issues/14#issuecomment-10357969.

This email is intended for the use of the individual addressee(s) named
above and may contain information that is confidential, privileged or
unsuitable for overly sensitive persons with low self-esteem, no sense of
humor or irrational religious beliefs. If you are not the intended
recipient, any dissemination, distribution or copying of this email is not
authorized (either explicitly or implicitly) and constitutes an irritating
social faux pas. Unless the word absquatulation has been used in its
correct context somewhere other than in this warning, it does not have any
legal or grammatical use and may be ignored. No animals were harmed in the
transmission of this email, although the yorkshire terrier next door is
living on borrowed time, let me tell you. Those of you with an overwhelming
fear of the unknown will be gratified to learn that there is no hidden
message revealed by reading this warning backwards, so just ignore that
Alert Notice from Microsoft: However, by pouring a complete circle of salt
around yourself and your computer you can ensure that no harm befalls you
and your pets. If you have received this email in error, please add some
nutmeg and egg whites and place it in a warm oven for 40 minutes. Whisk
briefly and let it stand for 2 hours before icing.

[Vanuan]

@ianepperson I'm sorry, I was thinking I'm talking to @jparise

At this point, either I have a misunderstanding of this library or there's a bug

Yeap, there's a huge bug. Library does the reverse of what you expect it to do.

Regardless, reload() is performing exactly as its docstring indicates:
Reload an existing module. Any known dependencies of the module will also be reloaded.

Yes, this library's reload function reloads a module and its dependencies.

But if you think about it a bit, you'll see that if you change a module, you don't have to reload its dependencies.

The modules that depend on it should be reloaded.

If you reload dependencies and dependants, you'll eventually reload ALL the modules.

So the library should be changed to reload only dependants.

[Vanuan]

Say, your module imports os, why the hell do you need to reload os module?

[micramm]

I think there's just a mismatch between your expectation of what this library does and its intention. The scenario that the library addresses is that your code imports some module which, in turn, imports a submodule. If you then do some work on the submodule, your code is able to get those changes by running reload(module).

If you could only reload dependents and not dependencies, then you would have to call reload(module.submodule) from your code. But then you have to know exactly what's been changed. Reloading all the dependencies accounts for arbitrary changes in the submodules.

Being able to reload all the dependants makes sense, but I would call this an extension rather than a bug.

For your os example. there's a blacklist command that prevents reloader from reloading it.

[jparise]

This is a valuable dialogue. Thanks to all of you who are participating!

I agree with @micramm's summary of the situation, but I also acknowledge that my article makes reference to this "missing" feature. If I recall correctly, that particular point is an addition to my original draft of the article upon which the code is based.

I am totally open to supporting this new use case (i.e. reloading dependents), although I've been a bit short on time recently. So please continue to discuss and propose specific changes, and know that I'll continue to follow this discussion and respond as soon as I'm able.

[Vanuan]

The real problem comes with from package import module statement.

http://docs.python.org/2/library/functions.html#__import__

the statement from package import dependant results in

_temp = __import__('package', globals(), locals(), ['dependant'], -1)
module = _temp.module

I.e. in our import routine, we don't know what dependency's "real" parent module is.

As result our dependency tree looks like this:

 { "package" : [module 'package.dependency'] }

So that when we reload dependant:

reloader.reload(dependant)

dependency is not reloaded. But now our dependency looks like this:

 { "package" : [module 'package.dependency'] }
 { "package.dependant" : [module 'package.dependency'] }

So the second time it is reloaded as it's supposed to.

Probably it's a separate bug.

[Vanuan]

If you then do some work on the submodule, your code is able to get those changes by running reload(module).

From that point of view, yes.

But (for me) the real use-case is to run the reloader thread in the background and track which modules have been modified to reload only those and its dependants.

[Vanuan]

I think there's just a mismatch between your expectation of what this library does and its intention.

According to you, README is lying:

this reloader will reload the requested module and all other modules that are dependent on that module.

There's no mention of dependencies.