Parametrized module import

[Jacek Generowicz]

I have a module whose behaviour needs to be configurable. The module
needs to decide, the first time it is imported, beteween alternative
interfaces it presents.

Currently, I set some environment variables which select the desired
behaviour, and the module inspects those variables to determine the
mode in which it should set itself up. I would prefer a pure Python
solution, rather than one which depends on external state.

Can you recommend any approaches, or warn against the pitfalls of some
approaches?

[Oliver Fromme]

Jacek Generowicz <ja************ **@cern.ch> wrote:

I have a module whose behaviour needs to be configurable. The module
needs to decide, the first time it is imported, beteween alternative
interfaces it presents.

Currently, I set some environment variables which select the desired
behaviour, and the module inspects those variables to determine the
mode in which it should set itself up. I would prefer a pure Python
solution, rather than one which depends on external state.

Can you recommend any approaches, or warn against the pitfalls of some
approaches?

You could create another module called "config" or "cfg"
which contains some global variables. You import it into
your configurable module as well as into your main program.
Then you can configure the module's behaviour via those
global variables before importing the module.

Something like this:

#--- File config.py: ---
foo_interface_m ode = 0 # default

#--- File your_module.py: ---
import config
if config.foo_inte rface_mode == 0:
... this interface
else:
... that interface

#--- File main_program.py : ---
import config
config.foo_inte rface_mode = 1
import your_module

Best regards
Oliver

--
Oliver Fromme, Konrad-Celtis-Str. 72, 81369 Munich, Germany

``All that we see or seem is just a dream within a dream.''
(E. A. Poe)

[Jacek Generowicz]

Oliver Fromme <ol**@haluter.f romme.com> writes:

You could create another module called "config" or "cfg"
which contains some global variables. You import it into
your configurable module as well as into your main program.
Then you can configure the module's behaviour via those
global variables before importing the module.

Yes, my initial crappy prototype idea was to add configuration
information to the sys module, but this variation is much neater
.... in fact, after the first 2 minutes of thinking about it, it looks
perfect :-)

However, one thing which keeps bothering me about the whole business,
is the possibilty of importing the module (with your chosen
configuration) after it has already been imported, without you knowing
it, with a different configuration. Ideally there should be some
warning about the fact that the configuration you specified is being
ignored as a result of the module already being imported ... and I
don't see how to achieve this.

[Oliver Fromme]

Heather Coppersmith <[e-mail] > wrote:

Jacek Generowicz <ja************ **@cern.ch> wrote:

Oliver Fromme <ol**@haluter.f romme.com> writes:

You could create another module called "config" or "cfg" which
contains some global variables. You import it into your
configurable module as well as into your main program. Then
you can configure the module's behaviour via those global
variables before importing the module.

Yes, my initial crappy prototype idea was to add configuration
information to the sys module, but this variation is much neater
... in fact, after the first 2 minutes of thinking about it, it
looks perfect :-)

However, one thing which keeps bothering me about the whole
business, is the possibilty of importing the module (with your
chosen configuration) after it has already been imported,
without you knowing it, with a different configuration. Ideally
there should be some warning about the fact that the
configuration you specified is being ignored as a result of the
module already being imported ... and I don't see how to achieve
this.

Upon import, a module's "top level" code is executed, so try a
variation on this theme at the top level of your module:

It's only executed when the module is imported for the
_first_ time, so that wouldn't work.

However, the problem can be solved by not modifying a
global variable in the "config" module directly, but by
using a function which allows only one call.

#--- File config.py: ---
foo_interface_m ode = None
def set_foo_interfa ce_mode (mode):
if foo_interface_m ode is None:
foo_interface_m ode = mode
else:
raise "foo_interface_ mode may only be set once"

#--- File your_module.py: ---
import config
if config.foo_inte rface_mode is None:
raise "foo_interface_ mode has not been set"
elif config.foo_inte rface_mode == 0:
... this interface
else:
... that interface

#--- File main_program.py : ---
import config
config.set_foo_ interface_mode (1)
import your_module

Of course, you could use assert instead of raise, or just
print a warning and go on. Whatever you prefer.

Best regards
Oliver

--
Oliver Fromme, Konrad-Celtis-Str. 72, 81369 Munich, Germany

``All that we see or seem is just a dream within a dream.''
(E. A. Poe)

[Jacek Generowicz]

Heather Coppersmith <[e-mail] > writes:

Upon import, a module's "top level" code is executed,
Yes, but only on the _first_ import. On subsequent imports the system
notices that the module has already imported, and doesn't execute
anything in the module, it just binds a name to the already imported
module ...
so try a variation on this theme at the top level of your module:

i_am_configured = False

if i_am_configured :
print 'i am already configured'
else:
import my_configuratio n_module
configure_mysel f( )
i_am_configured = True

.... so the first branch will _never_ get executed.

My question is exactly about this problem: nothing gets executed on
the second import, so there's nowhere for me to put the "already
configured" message.

[Jacek Generowicz]

Oliver Fromme <ol**@haluter.f romme.com> writes:

However, the problem can be solved by not modifying a
global variable in the "config" module directly, but by
using a function which allows only one call.

#--- File config.py: ---
foo_interface_m ode = None
def set_foo_interfa ce_mode (mode):
if foo_interface_m ode is None:
foo_interface_m ode = mode
else:
raise "foo_interface_ mode may only be set once"

But there must be a default configuration, so you can't check for
None. I typically deal with these situations by using functions which
replace themselves when called:

def configure():
print "Configurin g ..."
global configure
def configure():
print "Sorry, already configured."

But this doesn't quite solve the problem I'm trying to solve, which is
to warn, at the time the import statement is executed, that the
configuration which is in place is not being respected.

There's nothing wrong with the user changing the mode twenty times
before the first import. I guess the imported module could block
further configuration changes, and the warning can come when you try
to change the configuration _after_ the first import.

[george young]

On 08 Jul 2004 09:43:31 +0200
Jacek Generowicz <ja************ **@cern.ch> threw this fish to the penguins:

I have a module whose behaviour needs to be configurable. The module
needs to decide, the first time it is imported, beteween alternative
interfaces it presents.

Currently, I set some environment variables which select the desired
behaviour, and the module inspects those variables to determine the
mode in which it should set itself up. I would prefer a pure Python
solution, rather than one which depends on external state.

Can you recommend any approaches, or warn against the pitfalls of some
approaches?

You might look at the way pygtk does it. I haven't peeked inside, but the
api is:

import pygtk
pygtk.require(' 2.0') # or '1.2' or some other version
import gtk # uses state set by require() to load the appropriate version

The pygtk.py file looks quite reusable with hardly any change...

See: http://www.pygtk.org
-- George
--
"Are the gods not just?" "Oh no, child.
What would become of us if they were?" (CSL)

[Jacek Generowicz]

george young <gr*@ll.mit.edu > writes:

You might look at the way pygtk does it. I haven't peeked inside,
Here is the relevant part ...

def require(version ):
global _pygtk_required _version

if _pygtk_required _version != None:
assert _pygtk_required _version == version, \
"a different version of gtk was already required"
return

assert not sys.modules.has _key('gtk'), \
"pygtk.require( ) must be called before importing gtk"

...
but the api is:

import pygtk
pygtk.require(' 2.0') # or '1.2' or some other version
import gtk # uses state set by require() to load the appropriate version

Yup ... but now I'm being put under pressure to make the API thus:

import foo
foo.config....

which doesn't thrill me at all, for a plethora of implementation
detail related reasons which are not interesting here.

Thanks for the poniter, anyway.

[anton muhin]

Jacek Generowicz wrote:

I have a module whose behaviour needs to be configurable. The module
needs to decide, the first time it is imported, beteween alternative
interfaces it presents.

Currently, I set some environment variables which select the desired
behaviour, and the module inspects those variables to determine the
mode in which it should set itself up. I would prefer a pure Python
solution, rather than one which depends on external state.

Can you recommend any approaches, or warn against the pitfalls of some
approaches?

Following `explicit is better than implicit` I'd prefer to have a huge
interface class or object that would be instantiated with parameters.
Something like this:

from myModule import myModule

myModule.tweak( <blah>)

....

myModule.doSome thing()

Of course, this solution might not fit your needs.

regards,
anton.

[Jacek Generowicz]

anton muhin <an********@ram bler.ru> writes:

Of course, this solution might not fit your needs.

In this case, I am afraid that it does not.