1. callmekatootie
  2. CherryPy


CherryPy / cherrypy / _cpconfig.py

"""Configuration system for CherryPy.

Configuration in CherryPy is implemented via dictionaries. Keys are strings
which name the mapped value, which may be of any type.


CherryPy Requests are part of an Application, which runs in a global context,
and configuration data may apply to any of those three scopes:

    Global: configuration entries which apply everywhere are stored in
    Application: entries which apply to each mounted application are stored
    on the Application object itself, as 'app.config'. This is a two-level
    dict where each key is a path, or "relative URL" (for example, "/" or
    "/path/to/my/page"), and each value is a config dict. Usually, this
    data is provided in the call to cherrypy.tree.mount(root(), config=conf),
    although you may also use app.merge(conf).
    Request: each Request object possesses a single 'Request.config' dict.
    Early in the request process, this dict is populated by merging global
    config entries, Application entries (whose path equals or is a parent
    of Request.path_info), and any config acquired while looking up the
    page handler (see next).


Configuration data may be supplied as a Python dictionary, as a filename,
or as an open file object. When you supply a filename or file, CherryPy
uses Python's builtin ConfigParser; you declare Application config by
writing each path as a section header:

    request.stream = True

To declare global configuration entries, place them in a [global] section.

You may also declare config entries directly on the classes and methods
(page handlers) that make up your CherryPy application via the '_cp_config'
attribute. For example:

    class Demo:
        _cp_config = {'tools.gzip.on': True}
        def index(self):
            raise cherrypy.InternalRedirect("/cuba")
        index.exposed = True
        index._cp_config = {'request.recursive_redirect': True}


Configuration keys are separated into namespaces by the first "." in the key.
Current namespaces:

    engine:     Controls the 'application engine', including autoreload.
                These can only be declared in the global config.
    hooks:      Declares additional request-processing functions.
    log:        Configures the logging for each application.
                These can only be declared in the global or / config.
    request:    Adds attributes to each Request.
    response:   Adds attributes to each Response.
    server:     Controls the default HTTP server via cherrypy.server.
                These can only be declared in the global config.
    tools:      Runs and configures additional request-processing packages.

The only key that does not exist in a namespace is the "environment" entry.
This special entry 'imports' other config entries from a template stored in
cherrypy._cpconfig.environments[environment]. It only applies to the global
config, and only when you use cherrypy.config.update.

import ConfigParser
from warnings import warn

import cherrypy

environments = {
    "staging": {
        'engine.autoreload_on': False,
        'tools.log_headers.on': False,
        'request.show_tracebacks': False,
    "production": {
        'engine.autoreload_on': False,
        'tools.log_headers.on': False,
        'request.show_tracebacks': False,
        'log.screen': False,
    "test_suite": {
        'engine.autoreload_on': False,
        'tools.log_headers.on': False,
        'request.show_tracebacks': True,
        'log.screen': False,

def as_dict(config):
    """Return a dict from 'config' whether it is a dict, file, or filename."""
    if isinstance(config, basestring):
        config = _Parser().dict_from_file(config)
    elif hasattr(config, 'read'):
        config = _Parser().dict_from_file(config)
    return config

def merge(base, other):
    """Merge one app config (from a dict, file, or filename) into another.
    If the given config is a filename, it will be appended to
    cherrypy.engine.reload_files and monitored for changes.
    if isinstance(other, basestring):
        if other not in cherrypy.engine.reload_files:
    # Load other into base
    for section, value_map in as_dict(other).iteritems():
        base.setdefault(section, {}).update(value_map)

class Config(dict):
    """The 'global' configuration data for the entire CherryPy process."""
    defaults = {
        'tools.log_tracebacks.on': True,
        'tools.log_headers.on': True,
        'tools.trailing_slash.on': True,
    namespaces = {"server": lambda k, v: setattr(cherrypy.server, k, v),
                  "engine": lambda k, v: setattr(cherrypy.engine, k, v),
                  "log": lambda k, v: setattr(cherrypy.log, k, v),
    def __init__(self):
    def reset(self):
        """Reset self to default values."""
        dict.update(self, self.defaults)
    def update(self, config):
        """Update self from a dict, file or filename."""
        if isinstance(config, basestring):
            # Filename
            if config not in cherrypy.engine.reload_files:
            config = _Parser().dict_from_file(config)
        elif hasattr(config, 'read'):
            # Open file object
            config = _Parser().dict_from_file(config)
            config = config.copy()
        if isinstance(config.get("global", None), dict):
            config = config["global"]
        if 'environment' in config:
            env = environments[config['environment']]
            for k in env:
                if k not in config:
                    config[k] = env[k]
        if 'tools.staticdir.dir' in config:
            config['tools.staticdir.section'] = "global"
        # Must use this idiom in order to hit our custom __setitem__.
        for k, v in config.iteritems():
            self[k] = v
    def __setitem__(self, k, v):
        dict.__setitem__(self, k, v)
        # Override object properties if specified in config.
        atoms = k.split(".", 1)
        namespace = atoms[0]
        if namespace in self.namespaces:
            self.namespaces[namespace](atoms[1], v)

obsolete = {
    'server.default_content_type': 'tools.response_headers.headers',
    'log_access_file': 'log.access_file',
    'log_config_options': None,
    'log_file': 'log.error_file',
    'log_file_not_found': None,
    'log_request_headers': 'tools.log_headers.on',
    'log_to_screen': 'log.screen',
    'show_tracebacks': 'request.show_tracebacks',
    'throw_errors': 'request.throw_errors',
    'profiler.on': 'cherrypy.tree.mount(profiler.make_app(cherrypy.Application(Root())))',

deprecated = {}

def check_compatibility(config):
    """Process config and warn on each obsolete or deprecated entry."""
    for section, map in as_dict(config).iteritems():
        if isinstance(map, dict):
            for k, v in map.iteritems():
                if k in obsolete:
                    warn("%r is obsolete. Use %r instead." % (k, v))
                elif k in deprecated:
                    warn("%r is deprecated. Use %r instead." % (k, v))
            if section in obsolete:
                warn("%r is obsolete. Use %r instead." % (section, map))
            elif section in deprecated:
                warn("%r is deprecated. Use %r instead." % (section, map))

class _Parser(ConfigParser.ConfigParser):
    """Sub-class of ConfigParser that keeps the case of options and that raises
    an exception if the file cannot be read.
    def optionxform(self, optionstr):
        return optionstr
    def read(self, filenames):
        if isinstance(filenames, basestring):
            filenames = [filenames]
        for filename in filenames:
            # try:
            #     fp = open(filename)
            # except IOError:
            #     continue
            fp = open(filename)
                self._read(fp, filename)
    def as_dict(self, raw=False, vars=None):
        """Convert an INI file to a dictionary"""
        # Load INI file into a dict
        from cherrypy.lib import unrepr
        result = {}
        for section in self.sections():
            if section not in result:
                result[section] = {}
            for option in self.options(section):
                value = self.get(section, option, raw, vars)
                    value = unrepr(value)
                except Exception, x:
                    msg = ("Config error in section: %s, option: %s, value: %s" %
                           (repr(section), repr(option), repr(value)))
                    raise ValueError(msg, x.__class__.__name__, x.args)
                result[section][option] = value
        return result
    def dict_from_file(self, file):
        if hasattr(file, 'read'):
        return self.as_dict()

del ConfigParser