"""Base class for cfg exceptions."""

def __init__(self, msg=None):

self.msg = msg

def __str__(self):

"""Raised if a CLI opt is registered after parsing."""

def __str__(self):

ret = "arguments already parsed"

if self.msg:

ret += ": " + self.msg

"""Raised if an opt which doesn't exist is referenced."""

def __init__(self, opt_name, group=None):

self.opt_name = opt_name

self.group = group

def __str__(self):

if self.group is None:

return "no such option: %s" % self.opt_name

else:

return "no such option in group %s: %s" % (self.group.name,

"""Raised if a group which doesn't exist is referenced."""

def __init__(self, group_name):

self.group_name = group_name

def __str__(self):

"""Raised if multiple opts with the same name are registered."""

def __init__(self, opt_name):

self.opt_name = opt_name

def __str__(self):

"""Raised if an option is required but no value is supplied by the user."""

def __init__(self, opt_name, group=None):

self.opt_name = opt_name

self.group = group

def __str__(self):

if self.group is None:

return "value required for option: %s" % self.opt_name

else:

return "value required for option: %s.%s" % (self.group.name,

"""Raised if an error occurs substituting a variable in an opt value."""

def __str__(self):

"""Raised if one or more config files are not found."""

def __init__(self, config_files):

self.config_files = config_files

def __str__(self):

return ('Failed to read some config files: %s' %

"""Raised if there is an error parsing a config file."""

def __init__(self, config_file, msg):

self.config_file = config_file

self.msg = msg

def __str__(self):

"""Return a list of directors where config files may be located.

cfg_dirs = [

_fixpath(os.path.join('~', '.' + project)) if project else None,

_fixpath('~'),

os.path.join('/etc', project) if project else None,

'/etc'

]

"""Search a list of directories for a given filename.

for d in dirs:

path = os.path.join(d, '%s%s' % (basename, extension))

if os.path.exists(path):

"""Return a list of default configuration files.

if prog is None:

prog = os.path.basename(sys.argv[0])

cfg_dirs = _get_config_dirs(project)

config_files = []

if project:

config_files.append(_search_dirs(cfg_dirs, project, extension))

config_files.append(_search_dirs(cfg_dirs, prog, extension))

"""Check whether an opt with the same name is already registered.

if opt.dest in opts:

if opts[opt.dest]['opt'] != opt:

raise DuplicateOptError(opt.name)

return True

else:

for opt in opts:

if opt.dest in kwargs:

opt.default = kwargs[opt.dest]

"""Base class for all configuration options.

multi = False

def __init__(self, name, dest=None, short=None, default=None,

positional=False, metavar=None, help=None,

secret=False, required=False, deprecated_name=None):

"""Construct an Opt object.

self.name = name

if dest is None:

self.dest = self.name.replace('-', '_')

else:

self.dest = dest

self.short = short

self.default = default

self.positional = positional

self.metavar = metavar

self.help = help

self.secret = secret

self.required = required

if deprecated_name is not None:

self.deprecated_name = deprecated_name.replace('-', '_')

else:

self.deprecated_name = None

def __ne__(self, another):

return vars(self) != vars(another)

def _get_from_config_parser(self, cparser, section):

"""Retrieves the option value from a MultiConfigParser object.

return self._cparser_get_with_deprecated(cparser, section)

def _cparser_get_with_deprecated(self, cparser, section):

"""If cannot find option as dest try deprecated_name alias."""

if self.deprecated_name is not None:

return cparser.get(section, [self.dest, self.deprecated_name])

return cparser.get(section, [self.dest])

def _add_to_cli(self, parser, group=None):

"""Makes the option available in the command line interface.

container = self._get_argparse_container(parser, group)

kwargs = self._get_argparse_kwargs(group)

prefix = self._get_argparse_prefix('', group)

self._add_to_argparse(container, self.name, self.short, kwargs, prefix,

self.positional, self.deprecated_name)

def _add_to_argparse(self, container, name, short, kwargs, prefix='',

positional=False, deprecated_name=None):

"""Add an option to an argparse parser or group.

def hyphen(arg):

return arg if not positional else ''

args = [hyphen('--') + prefix + name]

if short:

args.append(hyphen('-') + short)

if deprecated_name:

args.append(hyphen('--') + prefix + deprecated_name)

try:

container.add_argument(*args, **kwargs)

except argparse.ArgumentError as e:

raise DuplicateOptError(e)

def _get_argparse_container(self, parser, group):

"""Returns an argparse._ArgumentGroup.

if group is not None:

return group._get_argparse_group(parser)

else:

return parser

def _get_argparse_kwargs(self, group, **kwargs):

"""Build a dict of keyword arguments for argparse's add_argument().

if not self.positional:

dest = self.dest

if group is not None:

dest = group.name + '_' + dest

kwargs['dest'] = dest

else:

kwargs['nargs'] = '?'

kwargs.update({'default': None,

'metavar': self.metavar,

'help': self.help, })

return kwargs

def _get_argparse_prefix(self, prefix, group):

"""Build a prefix for the CLI option name, if required.

if group is not None:

return group.name + '-' + prefix

else:

"""

"""

_boolean_states = {'1': True, 'yes': True, 'true': True, 'on': True,

'0': False, 'no': False, 'false': False, 'off': False}

def __init__(self, *args, **kwargs):

if 'positional' in kwargs:

raise ValueError('positional boolean args not supported')

super(BoolOpt, self).__init__(*args, **kwargs)

def _get_from_config_parser(self, cparser, section):

"""Retrieve the opt value as a boolean from ConfigParser."""

def convert_bool(v):

value = self._boolean_states.get(v.lower())

if value is None:

raise ValueError('Unexpected boolean value %r' % v)

return value

return [convert_bool(v) for v in

self._cparser_get_with_deprecated(cparser, section)]

def _add_to_cli(self, parser, group=None):

"""Extends the base class method to add the --nooptname option."""

super(BoolOpt, self)._add_to_cli(parser, group)

self._add_inverse_to_argparse(parser, group)

def _add_inverse_to_argparse(self, parser, group):

"""Add the --nooptname option to the option parser."""

container = self._get_argparse_container(parser, group)

kwargs = self._get_argparse_kwargs(group, action='store_false')

prefix = self._get_argparse_prefix('no', group)

kwargs["help"] = "The inverse of --" + self.name

self._add_to_argparse(container, self.name, None, kwargs, prefix,

self.positional, self.deprecated_name)

def _get_argparse_kwargs(self, group, action='store_true', **kwargs):

"""Extends the base argparse keyword dict for boolean options."""

kwargs = super(BoolOpt, self)._get_argparse_kwargs(group, **kwargs)

# metavar has no effect for BoolOpt

if 'metavar' in kwargs:

del kwargs['metavar']

if action != 'store_true':

action = 'store_false'

kwargs['action'] = action

"""Int opt values are converted to integers using the int() builtin."""

def _get_from_config_parser(self, cparser, section):

"""Retrieve the opt value as a integer from ConfigParser."""

return [int(v) for v in self._cparser_get_with_deprecated(cparser,

section)]

def _get_argparse_kwargs(self, group, **kwargs):

"""Extends the base argparse keyword dict for integer options."""

return super(IntOpt,

"""Float opt values are converted to floats using the float() builtin."""

def _get_from_config_parser(self, cparser, section):

"""Retrieve the opt value as a float from ConfigParser."""

return [float(v) for v in

self._cparser_get_with_deprecated(cparser, section)]

def _get_argparse_kwargs(self, group, **kwargs):

"""Extends the base argparse keyword dict for float options."""

return super(FloatOpt, self)._get_argparse_kwargs(group,

"""

class _StoreListAction(argparse.Action):

"""

def __call__(self, parser, namespace, values, option_string=None):

if values is not None:

values = [a.strip() for a in values.split(',')]

setattr(namespace, self.dest, values)

def _get_from_config_parser(self, cparser, section):

"""Retrieve the opt value as a list from ConfigParser."""

return [[a.strip() for a in v.split(',')] for v in

self._cparser_get_with_deprecated(cparser, section)]

def _get_argparse_kwargs(self, group, **kwargs):

"""Extends the base argparse keyword dict for list options."""

return Opt._get_argparse_kwargs(self,

group,

action=ListOpt._StoreListAction,

"""

multi = True

def _get_argparse_kwargs(self, group, **kwargs):

"""Extends the base argparse keyword dict for multi str options."""

kwargs = super(MultiStrOpt, self)._get_argparse_kwargs(group)

if not self.positional:

kwargs['action'] = 'append'

else:

kwargs['nargs'] = '*'

return kwargs

def _cparser_get_with_deprecated(self, cparser, section):

"""If cannot find option as dest try deprecated_name alias."""

if self.deprecated_name is not None:

return cparser.get(section, [self.dest, self.deprecated_name],

multi=True)

"""

def __init__(self, name, dest=None, handler=None,

title=None, description=None, help=None):

"""Construct an sub-command parsing option.

super(SubCommandOpt, self).__init__(name, dest=dest, help=help)

self.handler = handler

self.title = title

self.description = description

def _add_to_cli(self, parser, group=None):

"""Add argparse sub-parsers and invoke the handler method."""

dest = self.dest

if group is not None:

dest = group.name + '_' + dest

subparsers = parser.add_subparsers(dest=dest,

title=self.title,

description=self.description,

help=self.help)

if self.handler is not None:

"""

def __init__(self, name, title=None, help=None):

"""Constructs an OptGroup object.

self.name = name

if title is None:

self.title = "%s options" % title

else:

self.title = title

self.help = help

self._opts = {} # dict of dicts of (opt:, override:, default:)

self._argparse_group = None

def _register_opt(self, opt, cli=False):

"""Add an opt to this group.

if _is_opt_registered(self._opts, opt):

return False

self._opts[opt.dest] = {'opt': opt, 'cli': cli}

return True

def _unregister_opt(self, opt):

"""Remove an opt from this group.

if opt.dest in self._opts:

del self._opts[opt.dest]

def _get_argparse_group(self, parser):

if self._argparse_group is None:

"""Build an argparse._ArgumentGroup for this group."""

self._argparse_group = parser.add_argument_group(self.title,

self.help)

return self._argparse_group

def _clear(self):

"""Clear this group's option parsing state."""

def __init__(self, msg, lineno, line, filename):

super(ParseError, self).__init__(msg, lineno, line)

self.filename = filename

def __str__(self):

return 'at %s:%d, %s: %r' % (self.filename, self.lineno,

def __init__(self, filename, sections):

super(ConfigParser, self).__init__()

self.filename = filename

self.sections = sections

self.section = None

def parse(self):

with open(self.filename) as f:

return super(ConfigParser, self).parse(f)

def new_section(self, section):

self.section = section

self.sections.setdefault(self.section, {})

def assignment(self, key, value):

if not self.section:

raise self.error_no_section()

self.sections[self.section].setdefault(key, [])

self.sections[self.section][key].append('\n'.join(value))

def parse_exc(self, msg, lineno, line=None):

return ParseError(msg, lineno, line, self.filename)

def error_no_section(self):

return self.parse_exc('Section must be started before assignment',

def __init__(self):

self.parsed = []

def read(self, config_files):

read_ok = []

for filename in config_files:

sections = {}

parser = ConfigParser(filename, sections)

try:

parser.parse()

except IOError:

continue

self.parsed.insert(0, sections)

read_ok.append(filename)

return read_ok