Get importer module from imported module

[dody suria wijaya]

Thank you for such a quick reply. There were some details I
had left behind related to my case that I guess would now
need to be told to better illustrate the problem.

I have many different module of "a", let's called it a1, a2 ...
a100, and there is only one module "b". Here's a better
example (and using some of your tips):

#Module a1
import b
class Main(b.Basic): pass

#Module a2
import b
class Main(b.Basic): pass

#Module a3
import b
class Main(b.Basic): pass

.
.
.

#Module b
class Basic: pass
class SaltyMixIn: pass
class SugaryMixIn: pass
def Salty():
    class Food(SaltyMixIn,module_importing_me.Main): pass
    return Food()
def Sweet():
    class Food(SugaryMixIn,module_importing_me.Main): pass
    return Food()

#Module c
import sys
food_no = sys.argv[1]
m = __import__(food_no)
goodie = m.Salty()


"import a" inside b would not solve the problem, since there
are many "module a" and module b does not know beforehand
which module had imported it. I could, say, put these
additional lines on all "module a" (which I previously had
and worked):

#Module a1
import b
class Main(b.Basic): pass
class Salty(SaltyMixIn,Main): pass      # new
class Sweet(SaltyMixIn,Main): pass      # new


but dislike it for personal taste; code dupes (there could
be a lot of food flavouring), and sheer messiness.


-- 
  dody suria wijaya
  YahooMsgr ID: dody

Monday, February 7, 2005, 6:10:14 PM, you wrote:

DB> dody suria wijaya wrote:

>> 
>> I found this problem when trying to split a module into two.
>> Here's an example:
>> 
>>==============
>> #Module a (a.py):
>> from b import *
>> class Main: pass
>>==============
>> 
>>==============
>> #Module b (b.py)
>> def How():
>>     Main_instance = module_a.Main()
>>     return Main_instance
>>==============
>> 
>>> import a
>>> a.How()
>> 
>> 
>> the problem would show at How() function. I have been unable
>> to get variable pointing to module a from inside module b.
>> In short, I need to have a variable pointing to the module
>> whose importing me.
>> 
>> 

DB> 'import a' will let you reference module 'a',
DB> unless 'a' was invoked as a 
DB> script in which case you would need 'import __main__'.

DB> #Module b (b.py)
DB> import a
DB> def How():
DB>     Main_instance = a.Main()
DB>     return Main_instance

DB> But: keep in mind that all statements (except
DB> 'global') are executable in 
DB> Python, so you must not call How() until after the Main class has actually
DB> been created. This is one reason why it is
DB> generally safer to import a 
DB> module and do the lookup when you need it instead of using 'from
DB> amodule import *' which can only get at the names which exist at the time
DB> it is executed.

DB> A better solution  would be to structure your code so that your modules
DB> don't have any mutual dependencies. If your
DB> function 'How()' is in module b 
DB> then just call 'b.How()' wherever you use it and lose the import of 'b'
DB> from 'a' altogether.