Python pattern for sharing configuration throughout application

Question

I have an application consisting of a base app that brings in several modules. The base app reads a parameter file into a configuration hash, and I want to share it across all my modules.

Currently, I am passing a ‘parent’ object down to modules, and then those modules are doing stuff like self.parent.config to obtain the configuration.

However, as there are several levels to the module hierarchy, I find myself doing things like self.parent.parent.config, which is starting to look bad.

What are some better patterns for sharing a config object across an application and it’s modules? I am thinking about having a ‘config’ module which basically creates a global config variable that can be set by the base app, then imported and accessed by other modules, but I am not sure if using globals like that is a bad practice for other reasons.

I am reasonably new to Python so be nice =)

Asked By: aaa90210

||

Source

Answer 1

You could just:

import config

and have a global config module

excerpts from my comments:

You can always add special rules for odd situations by just saying oddValue if isOddSituation() else config.normalValue.

If you want to have configuration modules be hierarchically subclassable (like my other answer describes), then you can represent a config as a class, or you can use the copy module and make a shallow copy and modify it, or you can use a “config dictionary”, e.g.:

import config as baseConfig
config = dict(baseConfig, overriddenValue=etc)

It doesn’t really matter too much which scope you’re in.

Answered By: ninjagecko

Answer 2

I think by ‘module’, you are actually referring to a ‘class/object’. An object is an instance of a class, for example:

class MyClass(object):
    def __init__(self, ...):
        ...
    ...

myObject = MyClass()

A module is a .py file you import, like so:

import mymodule

It seems unlikely that all the classes you instantiate would want to have access to a global configuration. However if you really need everything in your application to have access to some global parameters, you can put them in your own config module:

myParam1 = 1
myParam2 = 2

and then from any module or any object or anywhere really, as long as you did import config, you could just say print(config.myParam1)

Alternatively if you want a large hierarchy of objects to all share access to the same property, you don’t need to refer to it via manually setting a self.parent. As long as you use inheritance, you can do stuff like:

class Parent(object):
    def __init__(self, theConfig):
        self.theConfig = theConfig

class Child(Parent):
    ...
    def method(self,...):
        print(self.theConfig)

Answered By: ninjagecko

Answer 3

Answering old question:

Just use dependency injection as suggested by @Reed Copsey here. E.g.

class MyClass:
    def __init__(myConfig):
        self.myConfig = myConfig
        ...

    def foo():
        self.myConfig.getConfig(key)
        ...
        self.myConfig.setConfig(key,val)
        ...

...
# myConfig is your configuration management Module/Class
obj = SomeClass(myConfig)

Answered By: Basel Shishani

Answer 4

Take a look at this. It could help you:
https://gist.github.com/dgarana/c052a3287629dd7c0b0c9d7921081e9d

Answered By: David Garaña

Python pattern for sharing configuration throughout application

Question:

Answers: