Skip to main content

load a configuration dictionary for a large application

Project description


yet another config management library, or a yak on a fig

Yakonfig parses a YAML configuration file at application startup, and makes parts of that configuration available to modules within the application. It is intended for multi-module applications where each module needs a separate configuration. The Yakonfig library merges application-provided default configuration, a user-provided configuration file, and command-line options to produce a unified global configuration.

yakonfig API

Applications using Yakonfig generally create an ``argparse.ArgumentParser`` object and call ``yakonfig.parse_args()``, giving it a list of configurable modules or other items. A typical application setup looks like:

import argparse
import dblogger
import kvlayer
import yakonfig

def main():
parser = argparse.ArgumentParser()
yakonfig.parse_args(parser, [yakonfig, dblogger, kvlayer])

if __name__ == '__main__':

The application will include ``--help``, ``--config FILE``, and ``--dump-config MODE`` flags by default; modules can provide additional command-line arguments.

The module list passed to ``parse_args()`` is a list of objects that look similar to ``yakonfig.Configurable`` objects. They can be actual objects, typically factories, or they can be classes or even Python modules that happen to include the same names. A top-level Python module might look like:

import a_package.submodule

#: Name of this module in the config file
config_name = 'a_package'
#: Inner blocks within this configuration
sub_modules = [a_package.submodule]
#: Default configuration
default_config = {'random_number': 17}

The objects contained in the ``sub_modules`` list have the same format. Running ``./ --dump-config=default`` would print out a YAML file:

random_number: 17
submodule: ...

A typical pattern is to create a factory object that has many configurable objects within it, such as stages in a data-processing pipeline. The ``yakonfig.factory.AutoFactory`` class supports this pattern. Objects built by the factory do not declare any of the configuration metadata; instead, Yakonfig determines the configuration name and default configuration by inspecting the object's constructor, or the function's argument list. The factory class itself needs to include the standard configuration metadata.

class a_stage(object):
def __init__(self, random_number=17):
self.random_number = random_number
def __call__(self):
print self.random_number

class StageFactory(yakonfig.factory.AutoFactory):
def __call__(self):
stage = self.create(a_stage)

The corresponding default YAML configuration:

random_number: 17

See [tests](src/tests/yakonfig/ for further illustrations.

Project details

Download files

Download the file for your platform. If you're not sure which to choose, learn more about installing packages.

Source Distribution

yakonfig-0.7.7.tar.gz (28.0 kB view hashes)

Uploaded source

Built Distribution

yakonfig-0.7.7-py2.7.egg (73.4 kB view hashes)

Uploaded 2 7

Supported by

AWS AWS Cloud computing and Security Sponsor Datadog Datadog Monitoring Fastly Fastly CDN Google Google Download Analytics Microsoft Microsoft PSF Sponsor Pingdom Pingdom Monitoring Sentry Sentry Error logging StatusPage StatusPage Status page