Using "external" vars on module load time

[Marco Aschwanden]

Hi

I have a script that looks for modules and tries to load them. After
loading I attach the "server"-API function to it.

module = __import__(modu le_name, globals(), locals(), [])
module.server = server.server_a pi

Now, some modules need the "server" functionality on load/init. I tried to
modify the globals():

my_globals = globals().copy( )
my_globals['server'] = server.server_a pi
module = __import__(modu le_name, my_globals, locals(), [])
module.server = server.server_a pi

This did not work as intended the module to be imported did not get the
"server" from my_globals. The solution I have, is to add __init_module__ ()
method that is called after the module was imported:

module = __import__(modu le_name, globals(), locals(), [])
module.server = server.server_a pi
if module.__dict__ .has_key('__ini t_module__'):
module.__init_m odule__()

This is not really satisfying. I would like:

Load a module and hand in already the server_api. How can I achieve this?

Thanks for any suggestions,
Marco

[Peter Otten]

Marco Aschwanden wrote:

Load a module and hand in already the server_api. How can I achieve this?

Using execfile() is the simplest approach:

import imp
import sys

def import_preloade d(name, path=None, variables={}):
if path is None:
file, path, description = imp.find_module (name)
module = imp.new_module( name)
module.__dict__ .update(variabl es)
execfile(path, module.__dict__ )
sys.modules[name] = module
return module

if __name__ == "__main__":
demo = import_preloade d("demo", variables=dict( whatever=42))

I think you should consider a class instead of a module, though.

Peter

[Marco Aschwanden]

Marvelous that was the solution I was looking for.

I think you should consider a class instead of a module, though.

What I don't get: Why should I consider using a class?

Greetings from sunny Switzerland,
Marco

[Diez B. Roggisch]

Marco Aschwanden schrieb:

Marvelous that was the solution I was looking for.

I think you should consider a class instead of a module, though.

What I don't get: Why should I consider using a class?

Because sharing state in such a way that several functions need to
access some later bound globals cries for a class that gets that very
state passed on instantiation.

Diez