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.
--
http://mail.python.org/mailman/listinfo/python-list
