restructe:
authorJens Kasten <jens@kasten-edv.de>
Tue, 27 Mar 2012 02:52:37 +0200
changeset 105 938d696a213e
parent 104 4dff8ac982bc
child 106 c0c9e51ce567
restructe:
bin/kvm-admin
kvmtools/argparse.py
kvmtools/config/argparse.py
kvmtools/config/build_command.py
kvmtools/config/build_config.py
kvmtools/config/configtest.py
kvmtools/config/create_dialog.py
kvmtools/config/domain.py
kvmtools/config/kvm_config.py
kvmtools/config/kvm_parser.py
kvmtools/config/parser.py
kvmtools/config/set_config.py
kvmtools/functions.py
kvmtools/generate_options.py
kvmtools/generator_helper.py
kvmtools/header.py
kvmtools/kvm/action.py
kvmtools/kvm/build_command.py
kvmtools/kvm/build_config.py
kvmtools/kvm/check_kvm.py
kvmtools/kvm/configtest.py
kvmtools/kvm/create_dialog.py
kvmtools/kvm/dialog.py
kvmtools/kvm/domain.py
setup.py
--- a/bin/kvm-admin	Fri Mar 23 02:49:17 2012 +0100
+++ b/bin/kvm-admin	Tue Mar 27 02:52:37 2012 +0200
@@ -1,6 +1,6 @@
 #!/usr/bin/env python
 #
-# Comamandline tool to manage a kvm guest with monitor.
+# Comamandline tool to manage a qemu-kvm domain.
 #
 # Usage: kvm-admin guest_name action [arguments]
 #
@@ -23,7 +23,7 @@
 #
 
 """
-(c) 2007-2011 Jens Kasten <jens@kasten-edv.de> 
+(c) 2007-2012 Jens Kasten <jens@kasten-edv.de> 
 """
 
 import os
@@ -33,7 +33,7 @@
 try:
     import argparse
 except ImportError:
-    import kvmtools.config.argparse as argparse
+    import kvmtools.argparse as argparse
 import gettext
 
 from kvmtools.kvm.action import Action
@@ -45,11 +45,17 @@
 
 
 class KvmAdmin(Action):
-    """ Class for commandline usage for a qemu-kvm guest."""
+    """ Class for commandline usage for a qemu-kvm domain.
+    Its offers methods for to start and stop the domain.
+    A special method is the commandline monitor.
+    In default configuration its create a socketfile for each domain and
+    is it can use like the standard monitor.
+    """
 
     def __init__(self):
+        # load the methods which are available for doamin
         Action.__init__(self)
-        self._args_value = None
+        self.value = None
         self.debug = False
 
     def run(self):
@@ -77,20 +83,20 @@
                 print error
             return True
 
-    def _set(self, args_value):
-        self._args_value = args_value
+    def _set(self, value):
+        self.value = value
 
     def _get(self):
-        return self._args_value
+        return self.value
 
 
 def main():
     """Handle the commandline arguments."""
     kvm_admin = KvmAdmin()
     actions = kvm_admin.available_actions()
-    domains = kvm_admin.kvm_domain_name_all
-   
-    # manage the arguments
+    domains = kvm_admin.available_domains()
+
+    # manage the commandline arguments
     parser = argparse.ArgumentParser(
         epilog="Available domains: %s" % ", ".join(domains))
     parser.add_argument("--debug", default=False, action="store_true",
@@ -113,9 +119,11 @@
         kvm_admin.kvm_domain_name = args.domain
     else:
         parser.error(_("Available domains: %s") % domains)
+
     kvm_admin.action = args.action
     kvm_admin.monitor = args.monitor
     kvm_admin.debug = args.debug
+
     if not args.action == "modify" and kvm_admin.show_error() :
         sys.exit(1)
     if args.debug:
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/kvmtools/argparse.py	Tue Mar 27 02:52:37 2012 +0200
@@ -0,0 +1,2353 @@
+# -*- coding: utf-8 -*-
+
+# Copyright © 2006-2009 Steven J. Bethard <steven.bethard@gmail.com>.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may not
+# use this file except in compliance with the License. You may obtain a copy
+# of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations
+# under the License.
+
+"""Command-line parsing library
+
+This module is an optparse-inspired command-line parsing library that:
+
+    - handles both optional and positional arguments
+    - produces highly informative usage messages
+    - supports parsers that dispatch to sub-parsers
+
+The following is a simple usage example that sums integers from the
+command-line and writes the result to a file::
+
+    parser = argparse.ArgumentParser(
+        description='sum the integers at the command line')
+    parser.add_argument(
+        'integers', metavar='int', nargs='+', type=int,
+        help='an integer to be summed')
+    parser.add_argument(
+        '--log', default=sys.stdout, type=argparse.FileType('w'),
+        help='the file where the sum should be written')
+    args = parser.parse_args()
+    args.log.write('%s' % sum(args.integers))
+    args.log.close()
+
+The module contains the following public classes:
+
+    - ArgumentParser -- The main entry point for command-line parsing. As the
+        example above shows, the add_argument() method is used to populate
+        the parser with actions for optional and positional arguments. Then
+        the parse_args() method is invoked to convert the args at the
+        command-line into an object with attributes.
+
+    - ArgumentError -- The exception raised by ArgumentParser objects when
+        there are errors with the parser's actions. Errors raised while
+        parsing the command-line are caught by ArgumentParser and emitted
+        as command-line messages.
+
+    - FileType -- A factory for defining types of files to be created. As the
+        example above shows, instances of FileType are typically passed as
+        the type= argument of add_argument() calls.
+
+    - Action -- The base class for parser actions. Typically actions are
+        selected by passing strings like 'store_true' or 'append_const' to
+        the action= argument of add_argument(). However, for greater
+        customization of ArgumentParser actions, subclasses of Action may
+        be defined and passed as the action= argument.
+
+    - HelpFormatter, RawDescriptionHelpFormatter, RawTextHelpFormatter,
+        ArgumentDefaultsHelpFormatter -- Formatter classes which
+        may be passed as the formatter_class= argument to the
+        ArgumentParser constructor. HelpFormatter is the default,
+        RawDescriptionHelpFormatter and RawTextHelpFormatter tell the parser
+        not to change the formatting for help text, and
+        ArgumentDefaultsHelpFormatter adds information about argument defaults
+        to the help.
+
+All other classes in this module are considered implementation details.
+(Also note that HelpFormatter and RawDescriptionHelpFormatter are only
+considered public as object names -- the API of the formatter objects is
+still considered an implementation detail.)
+"""
+
+__version__ = '1.1'
+__all__ = [
+    'ArgumentParser',
+    'ArgumentError',
+    'Namespace',
+    'Action',
+    'FileType',
+    'HelpFormatter',
+    'RawDescriptionHelpFormatter',
+    'RawTextHelpFormatter',
+    'ArgumentDefaultsHelpFormatter',
+]
+
+
+import copy as _copy
+import os as _os
+import re as _re
+import sys as _sys
+import textwrap as _textwrap
+
+from gettext import gettext as _
+
+try:
+    _set = set
+except NameError:
+    from sets import Set as _set
+
+try:
+    _basestring = basestring
+except NameError:
+    _basestring = str
+
+try:
+    _sorted = sorted
+except NameError:
+
+    def _sorted(iterable, reverse=False):
+        result = list(iterable)
+        result.sort()
+        if reverse:
+            result.reverse()
+        return result
+
+
+def _callable(obj):
+    return hasattr(obj, '__call__') or hasattr(obj, '__bases__')
+
+# silence Python 2.6 buggy warnings about Exception.message
+if _sys.version_info[:2] == (2, 6):
+    import warnings
+    warnings.filterwarnings(
+        action='ignore',
+        message='BaseException.message has been deprecated as of Python 2.6',
+        category=DeprecationWarning,
+        module='argparse')
+
+
+SUPPRESS = '==SUPPRESS=='
+
+OPTIONAL = '?'
+ZERO_OR_MORE = '*'
+ONE_OR_MORE = '+'
+PARSER = 'A...'
+REMAINDER = '...'
+
+# =============================
+# Utility functions and classes
+# =============================
+
+class _AttributeHolder(object):
+    """Abstract base class that provides __repr__.
+
+    The __repr__ method returns a string in the format::
+        ClassName(attr=name, attr=name, ...)
+    The attributes are determined either by a class-level attribute,
+    '_kwarg_names', or by inspecting the instance __dict__.
+    """
+
+    def __repr__(self):
+        type_name = type(self).__name__
+        arg_strings = []
+        for arg in self._get_args():
+            arg_strings.append(repr(arg))
+        for name, value in self._get_kwargs():
+            arg_strings.append('%s=%r' % (name, value))
+        return '%s(%s)' % (type_name, ', '.join(arg_strings))
+
+    def _get_kwargs(self):
+        return _sorted(self.__dict__.items())
+
+    def _get_args(self):
+        return []
+
+
+def _ensure_value(namespace, name, value):
+    if getattr(namespace, name, None) is None:
+        setattr(namespace, name, value)
+    return getattr(namespace, name)
+
+
+# ===============
+# Formatting Help
+# ===============
+
+class HelpFormatter(object):
+    """Formatter for generating usage messages and argument help strings.
+
+    Only the name of this class is considered a public API. All the methods
+    provided by the class are considered an implementation detail.
+    """
+
+    def __init__(self,
+                 prog,
+                 indent_increment=2,
+                 max_help_position=24,
+                 width=None):
+
+        # default setting for width
+        if width is None:
+            try:
+                width = int(_os.environ['COLUMNS'])
+            except (KeyError, ValueError):
+                width = 80
+            width -= 2
+
+        self._prog = prog
+        self._indent_increment = indent_increment
+        self._max_help_position = max_help_position
+        self._width = width
+
+        self._current_indent = 0
+        self._level = 0
+        self._action_max_length = 0
+
+        self._root_section = self._Section(self, None)
+        self._current_section = self._root_section
+
+        self._whitespace_matcher = _re.compile(r'\s+')
+        self._long_break_matcher = _re.compile(r'\n\n\n+')
+
+    # ===============================
+    # Section and indentation methods
+    # ===============================
+    def _indent(self):
+        self._current_indent += self._indent_increment
+        self._level += 1
+
+    def _dedent(self):
+        self._current_indent -= self._indent_increment
+        assert self._current_indent >= 0, 'Indent decreased below 0.'
+        self._level -= 1
+
+    class _Section(object):
+
+        def __init__(self, formatter, parent, heading=None):
+            self.formatter = formatter
+            self.parent = parent
+            self.heading = heading
+            self.items = []
+
+        def format_help(self):
+            # format the indented section
+            if self.parent is not None:
+                self.formatter._indent()
+            join = self.formatter._join_parts
+            for func, args in self.items:
+                func(*args)
+            item_help = join([func(*args) for func, args in self.items])
+            if self.parent is not None:
+                self.formatter._dedent()
+
+            # return nothing if the section was empty
+            if not item_help:
+                return ''
+
+            # add the heading if the section was non-empty
+            if self.heading is not SUPPRESS and self.heading is not None:
+                current_indent = self.formatter._current_indent
+                heading = '%*s%s:\n' % (current_indent, '', self.heading)
+            else:
+                heading = ''
+
+            # join the section-initial newline, the heading and the help
+            return join(['\n', heading, item_help, '\n'])
+
+    def _add_item(self, func, args):
+        self._current_section.items.append((func, args))
+
+    # ========================
+    # Message building methods
+    # ========================
+    def start_section(self, heading):
+        self._indent()
+        section = self._Section(self, self._current_section, heading)
+        self._add_item(section.format_help, [])
+        self._current_section = section
+
+    def end_section(self):
+        self._current_section = self._current_section.parent
+        self._dedent()
+
+    def add_text(self, text):
+        if text is not SUPPRESS and text is not None:
+            self._add_item(self._format_text, [text])
+
+    def add_usage(self, usage, actions, groups, prefix=None):
+        if usage is not SUPPRESS:
+            args = usage, actions, groups, prefix
+            self._add_item(self._format_usage, args)
+
+    def add_argument(self, action):
+        if action.help is not SUPPRESS:
+
+            # find all invocations
+            get_invocation = self._format_action_invocation
+            invocations = [get_invocation(action)]
+            for subaction in self._iter_indented_subactions(action):
+                invocations.append(get_invocation(subaction))
+
+            # update the maximum item length
+            invocation_length = max([len(s) for s in invocations])
+            action_length = invocation_length + self._current_indent
+            self._action_max_length = max(self._action_max_length,
+                                          action_length)
+
+            # add the item to the list
+            self._add_item(self._format_action, [action])
+
+    def add_arguments(self, actions):
+        for action in actions:
+            self.add_argument(action)
+
+    # =======================
+    # Help-formatting methods
+    # =======================
+    def format_help(self):
+        help = self._root_section.format_help()
+        if help:
+            help = self._long_break_matcher.sub('\n\n', help)
+            help = help.strip('\n') + '\n'
+        return help
+
+    def _join_parts(self, part_strings):
+        return ''.join([part
+                        for part in part_strings
+                        if part and part is not SUPPRESS])
+
+    def _format_usage(self, usage, actions, groups, prefix):
+        if prefix is None:
+            prefix = _('usage: ')
+
+        # if usage is specified, use that
+        if usage is not None:
+            usage = usage % dict(prog=self._prog)
+
+        # if no optionals or positionals are available, usage is just prog
+        elif usage is None and not actions:
+            usage = '%(prog)s' % dict(prog=self._prog)
+
+        # if optionals and positionals are available, calculate usage
+        elif usage is None:
+            prog = '%(prog)s' % dict(prog=self._prog)
+
+            # split optionals from positionals
+            optionals = []
+            positionals = []
+            for action in actions:
+                if action.option_strings:
+                    optionals.append(action)
+                else:
+                    positionals.append(action)
+
+            # build full usage string
+            format = self._format_actions_usage
+            action_usage = format(optionals + positionals, groups)
+            usage = ' '.join([s for s in [prog, action_usage] if s])
+
+            # wrap the usage parts if it's too long
+            text_width = self._width - self._current_indent
+            if len(prefix) + len(usage) > text_width:
+
+                # break usage into wrappable parts
+                part_regexp = r'\(.*?\)+|\[.*?\]+|\S+'
+                opt_usage = format(optionals, groups)
+                pos_usage = format(positionals, groups)
+                opt_parts = _re.findall(part_regexp, opt_usage)
+                pos_parts = _re.findall(part_regexp, pos_usage)
+                assert ' '.join(opt_parts) == opt_usage
+                assert ' '.join(pos_parts) == pos_usage
+
+                # helper for wrapping lines
+                def get_lines(parts, indent, prefix=None):
+                    lines = []
+                    line = []
+                    if prefix is not None:
+                        line_len = len(prefix) - 1
+                    else:
+                        line_len = len(indent) - 1
+                    for part in parts:
+                        if line_len + 1 + len(part) > text_width:
+                            lines.append(indent + ' '.join(line))
+                            line = []
+                            line_len = len(indent) - 1
+                        line.append(part)
+                        line_len += len(part) + 1
+                    if line:
+                        lines.append(indent + ' '.join(line))
+                    if prefix is not None:
+                        lines[0] = lines[0][len(indent):]
+                    return lines
+
+                # if prog is short, follow it with optionals or positionals
+                if len(prefix) + len(prog) <= 0.75 * text_width:
+                    indent = ' ' * (len(prefix) + len(prog) + 1)
+                    if opt_parts:
+                        lines = get_lines([prog] + opt_parts, indent, prefix)
+                        lines.extend(get_lines(pos_parts, indent))
+                    elif pos_parts:
+                        lines = get_lines([prog] + pos_parts, indent, prefix)
+                    else:
+                        lines = [prog]
+
+                # if prog is long, put it on its own line
+                else:
+                    indent = ' ' * len(prefix)
+                    parts = opt_parts + pos_parts
+                    lines = get_lines(parts, indent)
+                    if len(lines) > 1:
+                        lines = []
+                        lines.extend(get_lines(opt_parts, indent))
+                        lines.extend(get_lines(pos_parts, indent))
+                    lines = [prog] + lines
+
+                # join lines into usage
+                usage = '\n'.join(lines)
+
+        # prefix with 'usage:'
+        return '%s%s\n\n' % (prefix, usage)
+
+    def _format_actions_usage(self, actions, groups):
+        # find group indices and identify actions in groups
+        group_actions = _set()
+        inserts = {}
+        for group in groups:
+            try:
+                start = actions.index(group._group_actions[0])
+            except ValueError:
+                continue
+            else:
+                end = start + len(group._group_actions)
+                if actions[start:end] == group._group_actions:
+                    for action in group._group_actions:
+                        group_actions.add(action)
+                    if not group.required:
+                        inserts[start] = '['
+                        inserts[end] = ']'
+                    else:
+                        inserts[start] = '('
+                        inserts[end] = ')'
+                    for i in range(start + 1, end):
+                        inserts[i] = '|'
+
+        # collect all actions format strings
+        parts = []
+        for i, action in enumerate(actions):
+
+            # suppressed arguments are marked with None
+            # remove | separators for suppressed arguments
+            if action.help is SUPPRESS:
+                parts.append(None)
+                if inserts.get(i) == '|':
+                    inserts.pop(i)
+                elif inserts.get(i + 1) == '|':
+                    inserts.pop(i + 1)
+
+            # produce all arg strings
+            elif not action.option_strings:
+                part = self._format_args(action, action.dest)
+
+                # if it's in a group, strip the outer []
+                if action in group_actions:
+                    if part[0] == '[' and part[-1] == ']':
+                        part = part[1:-1]
+
+                # add the action string to the list
+                parts.append(part)
+
+            # produce the first way to invoke the option in brackets
+            else:
+                option_string = action.option_strings[0]
+
+                # if the Optional doesn't take a value, format is:
+                #    -s or --long
+                if action.nargs == 0:
+                    part = '%s' % option_string
+
+                # if the Optional takes a value, format is:
+                #    -s ARGS or --long ARGS
+                else:
+                    default = action.dest.upper()
+                    args_string = self._format_args(action, default)
+                    part = '%s %s' % (option_string, args_string)
+
+                # make it look optional if it's not required or in a group
+                if not action.required and action not in group_actions:
+                    part = '[%s]' % part
+
+                # add the action string to the list
+                parts.append(part)
+
+        # insert things at the necessary indices
+        for i in _sorted(inserts, reverse=True):
+            parts[i:i] = [inserts[i]]
+
+        # join all the action items with spaces
+        text = ' '.join([item for item in parts if item is not None])
+
+        # clean up separators for mutually exclusive groups
+        open = r'[\[(]'
+        close = r'[\])]'
+        text = _re.sub(r'(%s) ' % open, r'\1', text)
+        text = _re.sub(r' (%s)' % close, r'\1', text)
+        text = _re.sub(r'%s *%s' % (open, close), r'', text)
+        text = _re.sub(r'\(([^|]*)\)', r'\1', text)
+        text = text.strip()
+
+        # return the text
+        return text
+
+    def _format_text(self, text):
+        if '%(prog)' in text:
+            text = text % dict(prog=self._prog)
+        text_width = self._width - self._current_indent
+        indent = ' ' * self._current_indent
+        return self._fill_text(text, text_width, indent) + '\n\n'
+
+    def _format_action(self, action):
+        # determine the required width and the entry label
+        help_position = min(self._action_max_length + 2,
+                            self._max_help_position)
+        help_width = self._width - help_position
+        action_width = help_position - self._current_indent - 2
+        action_header = self._format_action_invocation(action)
+
+        # ho nelp; start on same line and add a final newline
+        if not action.help:
+            tup = self._current_indent, '', action_header
+            action_header = '%*s%s\n' % tup
+
+        # short action name; start on the same line and pad two spaces
+        elif len(action_header) <= action_width:
+            tup = self._current_indent, '', action_width, action_header
+            action_header = '%*s%-*s  ' % tup
+            indent_first = 0
+
+        # long action name; start on the next line
+        else:
+            tup = self._current_indent, '', action_header
+            action_header = '%*s%s\n' % tup
+            indent_first = help_position
+
+        # collect the pieces of the action help
+        parts = [action_header]
+
+        # if there was help for the action, add lines of help text
+        if action.help:
+            help_text = self._expand_help(action)
+            help_lines = self._split_lines(help_text, help_width)
+            parts.append('%*s%s\n' % (indent_first, '', help_lines[0]))
+            for line in help_lines[1:]:
+                parts.append('%*s%s\n' % (help_position, '', line))
+
+        # or add a newline if the description doesn't end with one
+        elif not action_header.endswith('\n'):
+            parts.append('\n')
+
+        # if there are any sub-actions, add their help as well
+        for subaction in self._iter_indented_subactions(action):
+            parts.append(self._format_action(subaction))
+
+        # return a single string
+        return self._join_parts(parts)
+
+    def _format_action_invocation(self, action):
+        if not action.option_strings:
+            metavar, = self._metavar_formatter(action, action.dest)(1)
+            return metavar
+
+        else:
+            parts = []
+
+            # if the Optional doesn't take a value, format is:
+            #    -s, --long
+            if action.nargs == 0:
+                parts.extend(action.option_strings)
+
+            # if the Optional takes a value, format is:
+            #    -s ARGS, --long ARGS
+            else:
+                default = action.dest.upper()
+                args_string = self._format_args(action, default)
+                for option_string in action.option_strings:
+                    parts.append('%s %s' % (option_string, args_string))
+
+            return ', '.join(parts)
+
+    def _metavar_formatter(self, action, default_metavar):
+        if action.metavar is not None:
+            result = action.metavar
+        elif action.choices is not None:
+            choice_strs = [str(choice) for choice in action.choices]
+            result = '{%s}' % ','.join(choice_strs)
+        else:
+            result = default_metavar
+
+        def format(tuple_size):
+            if isinstance(result, tuple):
+                return result
+            else:
+                return (result, ) * tuple_size
+        return format
+
+    def _format_args(self, action, default_metavar):
+        get_metavar = self._metavar_formatter(action, default_metavar)
+        if action.nargs is None:
+            result = '%s' % get_metavar(1)
+        elif action.nargs == OPTIONAL:
+            result = '[%s]' % get_metavar(1)
+        elif action.nargs == ZERO_OR_MORE:
+            result = '[%s [%s ...]]' % get_metavar(2)
+        elif action.nargs == ONE_OR_MORE:
+            result = '%s [%s ...]' % get_metavar(2)
+        elif action.nargs == REMAINDER:
+            result = '...'
+        elif action.nargs == PARSER:
+            result = '%s ...' % get_metavar(1)
+        else:
+            formats = ['%s' for _ in range(action.nargs)]
+            result = ' '.join(formats) % get_metavar(action.nargs)
+        return result
+
+    def _expand_help(self, action):
+        params = dict(vars(action), prog=self._prog)
+        for name in list(params):
+            if params[name] is SUPPRESS:
+                del params[name]
+        for name in list(params):
+            if hasattr(params[name], '__name__'):
+                params[name] = params[name].__name__
+        if params.get('choices') is not None:
+            choices_str = ', '.join([str(c) for c in params['choices']])
+            params['choices'] = choices_str
+        return self._get_help_string(action) % params
+
+    def _iter_indented_subactions(self, action):
+        try:
+            get_subactions = action._get_subactions
+        except AttributeError:
+            pass
+        else:
+            self._indent()
+            for subaction in get_subactions():
+                yield subaction
+            self._dedent()
+
+    def _split_lines(self, text, width):
+        text = self._whitespace_matcher.sub(' ', text).strip()
+        return _textwrap.wrap(text, width)
+
+    def _fill_text(self, text, width, indent):
+        text = self._whitespace_matcher.sub(' ', text).strip()
+        return _textwrap.fill(text, width, initial_indent=indent,
+                                           subsequent_indent=indent)
+
+    def _get_help_string(self, action):
+        return action.help
+
+
+class RawDescriptionHelpFormatter(HelpFormatter):
+    """Help message formatter which retains any formatting in descriptions.
+
+    Only the name of this class is considered a public API. All the methods
+    provided by the class are considered an implementation detail.
+    """
+
+    def _fill_text(self, text, width, indent):
+        return ''.join([indent + line for line in text.splitlines(True)])
+
+
+class RawTextHelpFormatter(RawDescriptionHelpFormatter):
+    """Help message formatter which retains formatting of all help text.
+
+    Only the name of this class is considered a public API. All the methods
+    provided by the class are considered an implementation detail.
+    """
+
+    def _split_lines(self, text, width):
+        return text.splitlines()
+
+
+class ArgumentDefaultsHelpFormatter(HelpFormatter):
+    """Help message formatter which adds default values to argument help.
+
+    Only the name of this class is considered a public API. All the methods
+    provided by the class are considered an implementation detail.
+    """
+
+    def _get_help_string(self, action):
+        help = action.help
+        if '%(default)' not in action.help:
+            if action.default is not SUPPRESS:
+                defaulting_nargs = [OPTIONAL, ZERO_OR_MORE]
+                if action.option_strings or action.nargs in defaulting_nargs:
+                    help += ' (default: %(default)s)'
+        return help
+
+
+# =====================
+# Options and Arguments
+# =====================
+
+def _get_action_name(argument):
+    if argument is None:
+        return None
+    elif argument.option_strings:
+        return  '/'.join(argument.option_strings)
+    elif argument.metavar not in (None, SUPPRESS):
+        return argument.metavar
+    elif argument.dest not in (None, SUPPRESS):
+        return argument.dest
+    else:
+        return None
+
+
+class ArgumentError(Exception):
+    """An error from creating or using an argument (optional or positional).
+
+    The string value of this exception is the message, augmented with
+    information about the argument that caused it.
+    """
+
+    def __init__(self, argument, message):
+        self.argument_name = _get_action_name(argument)
+        self.message = message
+
+    def __str__(self):
+        if self.argument_name is None:
+            format = '%(message)s'
+        else:
+            format = 'argument %(argument_name)s: %(message)s'
+        return format % dict(message=self.message,
+                             argument_name=self.argument_name)
+
+
+class ArgumentTypeError(Exception):
+    """An error from trying to convert a command line string to a type."""
+    pass
+
+
+# ==============
+# Action classes
+# ==============
+
+class Action(_AttributeHolder):
+    """Information about how to convert command line strings to Python objects.
+
+    Action objects are used by an ArgumentParser to represent the information
+    needed to parse a single argument from one or more strings from the
+    command line. The keyword arguments to the Action constructor are also
+    all attributes of Action instances.
+
+    Keyword Arguments:
+
+        - option_strings -- A list of command-line option strings which
+            should be associated with this action.
+
+        - dest -- The name of the attribute to hold the created object(s)
+
+        - nargs -- The number of command-line arguments that should be
+            consumed. By default, one argument will be consumed and a single
+            value will be produced.  Other values include:
+                - N (an integer) consumes N arguments (and produces a list)
+                - '?' consumes zero or one arguments
+                - '*' consumes zero or more arguments (and produces a list)
+                - '+' consumes one or more arguments (and produces a list)
+            Note that the difference between the default and nargs=1 is that
+            with the default, a single value will be produced, while with
+            nargs=1, a list containing a single value will be produced.
+
+        - const -- The value to be produced if the option is specified and the
+            option uses an action that takes no values.
+
+        - default -- The value to be produced if the option is not specified.
+
+        - type -- The type which the command-line arguments should be converted
+            to, should be one of 'string', 'int', 'float', 'complex' or a
+            callable object that accepts a single string argument. If None,
+            'string' is assumed.
+
+        - choices -- A container of values that should be allowed. If not None,
+            after a command-line argument has been converted to the appropriate
+            type, an exception will be raised if it is not a member of this
+            collection.
+
+        - required -- True if the action must always be specified at the
+            command line. This is only meaningful for optional command-line
+            arguments.
+
+        - help -- The help string describing the argument.
+
+        - metavar -- The name to be used for the option's argument with the
+            help string. If None, the 'dest' value will be used as the name.
+    """
+
+    def __init__(self,
+                 option_strings,
+                 dest,
+                 nargs=None,
+                 const=None,
+                 default=None,
+                 type=None,
+                 choices=None,
+                 required=False,
+                 help=None,
+                 metavar=None):
+        self.option_strings = option_strings
+        self.dest = dest
+        self.nargs = nargs
+        self.const = const
+        self.default = default
+        self.type = type
+        self.choices = choices
+        self.required = required
+        self.help = help
+        self.metavar = metavar
+
+    def _get_kwargs(self):
+        names = [
+            'option_strings',
+            'dest',
+            'nargs',
+            'const',
+            'default',
+            'type',
+            'choices',
+            'help',
+            'metavar',
+        ]
+        return [(name, getattr(self, name)) for name in names]
+
+    def __call__(self, parser, namespace, values, option_string=None):
+        raise NotImplementedError(_('.__call__() not defined'))
+
+
+class _StoreAction(Action):
+
+    def __init__(self,
+                 option_strings,
+                 dest,
+                 nargs=None,
+                 const=None,
+                 default=None,
+                 type=None,
+                 choices=None,
+                 required=False,
+                 help=None,
+                 metavar=None):
+        if nargs == 0:
+            raise ValueError('nargs for store actions must be > 0; if you '
+                             'have nothing to store, actions such as store '
+                             'true or store const may be more appropriate')
+        if const is not None and nargs != OPTIONAL:
+            raise ValueError('nargs must be %r to supply const' % OPTIONAL)
+        super(_StoreAction, self).__init__(
+            option_strings=option_strings,
+            dest=dest,
+            nargs=nargs,
+            const=const,
+            default=default,
+            type=type,
+            choices=choices,
+            required=required,
+            help=help,
+            metavar=metavar)
+
+    def __call__(self, parser, namespace, values, option_string=None):
+        setattr(namespace, self.dest, values)
+
+
+class _StoreConstAction(Action):
+
+    def __init__(self,
+                 option_strings,
+                 dest,
+                 const,
+                 default=None,
+                 required=False,
+                 help=None,
+                 metavar=None):
+        super(_StoreConstAction, self).__init__(
+            option_strings=option_strings,
+            dest=dest,
+            nargs=0,
+            const=const,
+            default=default,
+            required=required,
+            help=help)
+
+    def __call__(self, parser, namespace, values, option_string=None):
+        setattr(namespace, self.dest, self.const)
+
+
+class _StoreTrueAction(_StoreConstAction):
+
+    def __init__(self,
+                 option_strings,
+                 dest,
+                 default=False,
+                 required=False,
+                 help=None):
+        super(_StoreTrueAction, self).__init__(
+            option_strings=option_strings,
+            dest=dest,
+            const=True,
+            default=default,
+            required=required,
+            help=help)
+
+
+class _StoreFalseAction(_StoreConstAction):
+
+    def __init__(self,
+                 option_strings,
+                 dest,
+                 default=True,
+                 required=False,
+                 help=None):
+        super(_StoreFalseAction, self).__init__(
+            option_strings=option_strings,
+            dest=dest,
+            const=False,
+            default=default,
+            required=required,
+            help=help)
+
+
+class _AppendAction(Action):
+
+    def __init__(self,
+                 option_strings,
+                 dest,
+                 nargs=None,
+                 const=None,
+                 default=None,
+                 type=None,
+                 choices=None,
+                 required=False,
+                 help=None,
+                 metavar=None):
+        if nargs == 0:
+            raise ValueError('nargs for append actions must be > 0; if arg '
+                             'strings are not supplying the value to append, '
+                             'the append const action may be more appropriate')
+        if const is not None and nargs != OPTIONAL:
+            raise ValueError('nargs must be %r to supply const' % OPTIONAL)
+        super(_AppendAction, self).__init__(
+            option_strings=option_strings,
+            dest=dest,
+            nargs=nargs,
+            const=const,
+            default=default,
+            type=type,
+            choices=choices,
+            required=required,
+            help=help,
+            metavar=metavar)
+
+    def __call__(self, parser, namespace, values, option_string=None):
+        items = _copy.copy(_ensure_value(namespace, self.dest, []))
+        items.append(values)
+        setattr(namespace, self.dest, items)
+
+
+class _AppendConstAction(Action):
+
+    def __init__(self,
+                 option_strings,
+                 dest,
+                 const,
+                 default=None,
+                 required=False,
+                 help=None,
+                 metavar=None):
+        super(_AppendConstAction, self).__init__(
+            option_strings=option_strings,
+            dest=dest,
+            nargs=0,
+            const=const,
+            default=default,
+            required=required,
+            help=help,
+            metavar=metavar)
+
+    def __call__(self, parser, namespace, values, option_string=None):
+        items = _copy.copy(_ensure_value(namespace, self.dest, []))
+        items.append(self.const)
+        setattr(namespace, self.dest, items)
+
+
+class _CountAction(Action):
+
+    def __init__(self,
+                 option_strings,
+                 dest,
+                 default=None,
+                 required=False,
+                 help=None):
+        super(_CountAction, self).__init__(
+            option_strings=option_strings,
+            dest=dest,
+            nargs=0,
+            default=default,
+            required=required,
+            help=help)
+
+    def __call__(self, parser, namespace, values, option_string=None):
+        new_count = _ensure_value(namespace, self.dest, 0) + 1
+        setattr(namespace, self.dest, new_count)
+
+
+class _HelpAction(Action):
+
+    def __init__(self,
+                 option_strings,
+                 dest=SUPPRESS,
+                 default=SUPPRESS,
+                 help=None):
+        super(_HelpAction, self).__init__(
+            option_strings=option_strings,
+            dest=dest,
+            default=default,
+            nargs=0,
+            help=help)
+
+    def __call__(self, parser, namespace, values, option_string=None):
+        parser.print_help()
+        parser.exit()
+
+
+class _VersionAction(Action):
+
+    def __init__(self,
+                 option_strings,
+                 version=None,
+                 dest=SUPPRESS,
+                 default=SUPPRESS,
+                 help=None):
+        super(_VersionAction, self).__init__(
+            option_strings=option_strings,
+            dest=dest,
+            default=default,
+            nargs=0,
+            help=help)
+        self.version = version
+
+    def __call__(self, parser, namespace, values, option_string=None):
+        version = self.version
+        if version is None:
+            version = parser.version
+        formatter = parser._get_formatter()
+        formatter.add_text(version)
+        parser.exit(message=formatter.format_help())
+
+
+class _SubParsersAction(Action):
+
+    class _ChoicesPseudoAction(Action):
+
+        def __init__(self, name, help):
+            sup = super(_SubParsersAction._ChoicesPseudoAction, self)
+            sup.__init__(option_strings=[], dest=name, help=help)
+
+    def __init__(self,
+                 option_strings,
+                 prog,
+                 parser_class,
+                 dest=SUPPRESS,
+                 help=None,
+                 metavar=None):
+
+        self._prog_prefix = prog
+        self._parser_class = parser_class
+        self._name_parser_map = {}
+        self._choices_actions = []
+
+        super(_SubParsersAction, self).__init__(
+            option_strings=option_strings,
+            dest=dest,
+            nargs=PARSER,
+            choices=self._name_parser_map,
+            help=help,
+            metavar=metavar)
+
+    def add_parser(self, name, **kwargs):
+        # set prog from the existing prefix
+        if kwargs.get('prog') is None:
+            kwargs['prog'] = '%s %s' % (self._prog_prefix, name)
+
+        # create a pseudo-action to hold the choice help
+        if 'help' in kwargs:
+            help = kwargs.pop('help')
+            choice_action = self._ChoicesPseudoAction(name, help)
+            self._choices_actions.append(choice_action)
+
+        # create the parser and add it to the map
+        parser = self._parser_class(**kwargs)
+        self._name_parser_map[name] = parser
+        return parser
+
+    def _get_subactions(self):
+        return self._choices_actions
+
+    def __call__(self, parser, namespace, values, option_string=None):
+        parser_name = values[0]
+        arg_strings = values[1:]
+
+        # set the parser name if requested
+        if self.dest is not SUPPRESS:
+            setattr(namespace, self.dest, parser_name)
+
+        # select the parser
+        try:
+            parser = self._name_parser_map[parser_name]
+        except KeyError:
+            tup = parser_name, ', '.join(self._name_parser_map)
+            msg = _('unknown parser %r (choices: %s)' % tup)
+            raise ArgumentError(self, msg)
+
+        # parse all the remaining options into the namespace
+        parser.parse_args(arg_strings, namespace)
+
+
+# ==============
+# Type classes
+# ==============
+
+class FileType(object):
+    """Factory for creating file object types
+
+    Instances of FileType are typically passed as type= arguments to the
+    ArgumentParser add_argument() method.
+
+    Keyword Arguments:
+        - mode -- A string indicating how the file is to be opened. Accepts the
+            same values as the builtin open() function.
+        - bufsize -- The file's desired buffer size. Accepts the same values as
+            the builtin open() function.
+    """
+
+    def __init__(self, mode='r', bufsize=None):
+        self._mode = mode
+        self._bufsize = bufsize
+
+    def __call__(self, string):
+        # the special argument "-" means sys.std{in,out}
+        if string == '-':
+            if 'r' in self._mode:
+                return _sys.stdin
+            elif 'w' in self._mode:
+                return _sys.stdout
+            else:
+                msg = _('argument "-" with mode %r' % self._mode)
+                raise ValueError(msg)
+
+        # all other arguments are used as file names
+        if self._bufsize:
+            return open(string, self._mode, self._bufsize)
+        else:
+            return open(string, self._mode)
+
+    def __repr__(self):
+        args = [self._mode, self._bufsize]
+        args_str = ', '.join([repr(arg) for arg in args if arg is not None])
+        return '%s(%s)' % (type(self).__name__, args_str)
+
+# ===========================
+# Optional and Positional Parsing
+# ===========================
+
+class Namespace(_AttributeHolder):
+    """Simple object for storing attributes.
+
+    Implements equality by attribute names and values, and provides a simple
+    string representation.
+    """
+
+    def __init__(self, **kwargs):
+        for name in kwargs:
+            setattr(self, name, kwargs[name])
+
+    def __eq__(self, other):
+        return vars(self) == vars(other)
+
+    def __ne__(self, other):
+        return not (self == other)
+
+    def __contains__(self, key):
+        return key in self.__dict__
+
+
+class _ActionsContainer(object):
+
+    def __init__(self,
+                 description,
+                 prefix_chars,
+                 argument_default,
+                 conflict_handler):
+        super(_ActionsContainer, self).__init__()
+
+        self.description = description
+        self.argument_default = argument_default
+        self.prefix_chars = prefix_chars
+        self.conflict_handler = conflict_handler
+
+        # set up registries
+        self._registries = {}
+
+        # register actions
+        self.register('action', None, _StoreAction)
+        self.register('action', 'store', _StoreAction)
+        self.register('action', 'store_const', _StoreConstAction)
+        self.register('action', 'store_true', _StoreTrueAction)
+        self.register('action', 'store_false', _StoreFalseAction)
+        self.register('action', 'append', _AppendAction)
+        self.register('action', 'append_const', _AppendConstAction)
+        self.register('action', 'count', _CountAction)
+        self.register('action', 'help', _HelpAction)
+        self.register('action', 'version', _VersionAction)
+        self.register('action', 'parsers', _SubParsersAction)
+
+        # raise an exception if the conflict handler is invalid
+        self._get_handler()
+
+        # action storage
+        self._actions = []
+        self._option_string_actions = {}
+
+        # groups
+        self._action_groups = []
+        self._mutually_exclusive_groups = []
+
+        # defaults storage
+        self._defaults = {}
+
+        # determines whether an "option" looks like a negative number
+        self._negative_number_matcher = _re.compile(r'^-\d+$|^-\d*\.\d+$')
+
+        # whether or not there are any optionals that look like negative
+        # numbers -- uses a list so it can be shared and edited
+        self._has_negative_number_optionals = []
+
+    # ====================
+    # Registration methods
+    # ====================
+    def register(self, registry_name, value, object):
+        registry = self._registries.setdefault(registry_name, {})
+        registry[value] = object
+
+    def _registry_get(self, registry_name, value, default=None):
+        return self._registries[registry_name].get(value, default)
+
+    # ==================================
+    # Namespace default accessor methods
+    # ==================================
+    def set_defaults(self, **kwargs):
+        self._defaults.update(kwargs)
+
+        # if these defaults match any existing arguments, replace
+        # the previous default on the object with the new one
+        for action in self._actions:
+            if action.dest in kwargs:
+                action.default = kwargs[action.dest]
+
+    def get_default(self, dest):
+        for action in self._actions:
+            if action.dest == dest and action.default is not None:
+                return action.default
+        return self._defaults.get(dest, None)
+
+
+    # =======================
+    # Adding argument actions
+    # =======================
+    def add_argument(self, *args, **kwargs):
+        """
+        add_argument(dest, ..., name=value, ...)
+        add_argument(option_string, option_string, ..., name=value, ...)
+        """
+
+        # if no positional args are supplied or only one is supplied and
+        # it doesn't look like an option string, parse a positional
+        # argument
+        chars = self.prefix_chars
+        if not args or len(args) == 1 and args[0][0] not in chars:
+            if args and 'dest' in kwargs:
+                raise ValueError('dest supplied twice for positional argument')
+            kwargs = self._get_positional_kwargs(*args, **kwargs)
+
+        # otherwise, we're adding an optional argument
+        else:
+            kwargs = self._get_optional_kwargs(*args, **kwargs)
+
+        # if no default was supplied, use the parser-level default
+        if 'default' not in kwargs:
+            dest = kwargs['dest']
+            if dest in self._defaults:
+                kwargs['default'] = self._defaults[dest]
+            elif self.argument_default is not None:
+                kwargs['default'] = self.argument_default
+
+        # create the action object, and add it to the parser
+        action_class = self._pop_action_class(kwargs)
+        if not _callable(action_class):
+            raise ValueError('unknown action "%s"' % action_class)
+        action = action_class(**kwargs)
+
+        # raise an error if the action type is not callable
+        type_func = self._registry_get('type', action.type, action.type)
+        if not _callable(type_func):
+            raise ValueError('%r is not callable' % type_func)
+
+        return self._add_action(action)
+
+    def add_argument_group(self, *args, **kwargs):
+        group = _ArgumentGroup(self, *args, **kwargs)
+        self._action_groups.append(group)
+        return group
+
+    def add_mutually_exclusive_group(self, **kwargs):
+        group = _MutuallyExclusiveGroup(self, **kwargs)
+        self._mutually_exclusive_groups.append(group)
+        return group
+
+    def _add_action(self, action):
+        # resolve any conflicts
+        self._check_conflict(action)
+
+        # add to actions list
+        self._actions.append(action)
+        action.container = self
+
+        # index the action by any option strings it has
+        for option_string in action.option_strings:
+            self._option_string_actions[option_string] = action
+
+        # set the flag if any option strings look like negative numbers
+        for option_string in action.option_strings:
+            if self._negative_number_matcher.match(option_string):
+                if not self._has_negative_number_optionals:
+                    self._has_negative_number_optionals.append(True)
+
+        # return the created action
+        return action
+
+    def _remove_action(self, action):
+        self._actions.remove(action)
+
+    def _add_container_actions(self, container):
+        # collect groups by titles
+        title_group_map = {}
+        for group in self._action_groups:
+            if group.title in title_group_map:
+                msg = _('cannot merge actions - two groups are named %r')
+                raise ValueError(msg % (group.title))
+            title_group_map[group.title] = group
+
+        # map each action to its group
+        group_map = {}
+        for group in container._action_groups:
+
+            # if a group with the title exists, use that, otherwise
+            # create a new group matching the container's group
+            if group.title not in title_group_map:
+                title_group_map[group.title] = self.add_argument_group(
+                    title=group.title,
+                    description=group.description,
+                    conflict_handler=group.conflict_handler)
+
+            # map the actions to their new group
+            for action in group._group_actions:
+                group_map[action] = title_group_map[group.title]
+
+        # add container's mutually exclusive groups
+        # NOTE: if add_mutually_exclusive_group ever gains title= and
+        # description= then this code will need to be expanded as above
+        for group in container._mutually_exclusive_groups:
+            mutex_group = self.add_mutually_exclusive_group(
+                required=group.required)
+
+            # map the actions to their new mutex group
+            for action in group._group_actions:
+                group_map[action] = mutex_group
+
+        # add all actions to this container or their group
+        for action in container._actions:
+            group_map.get(action, self)._add_action(action)
+
+    def _get_positional_kwargs(self, dest, **kwargs):
+        # make sure required is not specified
+        if 'required' in kwargs:
+            msg = _("'required' is an invalid argument for positionals")
+            raise TypeError(msg)
+
+        # mark positional arguments as required if at least one is
+        # always required
+        if kwargs.get('nargs') not in [OPTIONAL, ZERO_OR_MORE]:
+            kwargs['required'] = True
+        if kwargs.get('nargs') == ZERO_OR_MORE and 'default' not in kwargs:
+            kwargs['required'] = True
+
+        # return the keyword arguments with no option strings
+        return dict(kwargs, dest=dest, option_strings=[])
+
+    def _get_optional_kwargs(self, *args, **kwargs):
+        # determine short and long option strings
+        option_strings = []
+        long_option_strings = []
+        for option_string in args:
+            # error on strings that don't start with an appropriate prefix
+            if not option_string[0] in self.prefix_chars:
+                msg = _('invalid option string %r: '
+                        'must start with a character %r')
+                tup = option_string, self.prefix_chars
+                raise ValueError(msg % tup)
+
+            # strings starting with two prefix characters are long options
+            option_strings.append(option_string)
+            if option_string[0] in self.prefix_chars:
+                if len(option_string) > 1:
+                    if option_string[1] in self.prefix_chars:
+                        long_option_strings.append(option_string)
+
+        # infer destination, '--foo-bar' -> 'foo_bar' and '-x' -> 'x'
+        dest = kwargs.pop('dest', None)
+        if dest is None:
+            if long_option_strings:
+                dest_option_string = long_option_strings[0]
+            else:
+                dest_option_string = option_strings[0]
+            dest = dest_option_string.lstrip(self.prefix_chars)
+            if not dest:
+                msg = _('dest= is required for options like %r')
+                raise ValueError(msg % option_string)
+            dest = dest.replace('-', '_')
+
+        # return the updated keyword arguments
+        return dict(kwargs, dest=dest, option_strings=option_strings)
+
+    def _pop_action_class(self, kwargs, default=None):
+        action = kwargs.pop('action', default)
+        return self._registry_get('action', action, action)
+
+    def _get_handler(self):
+        # determine function from conflict handler string
+        handler_func_name = '_handle_conflict_%s' % self.conflict_handler
+        try:
+            return getattr(self, handler_func_name)
+        except AttributeError:
+            msg = _('invalid conflict_resolution value: %r')
+            raise ValueError(msg % self.conflict_handler)
+
+    def _check_conflict(self, action):
+
+        # find all options that conflict with this option
+        confl_optionals = []
+        for option_string in action.option_strings:
+            if option_string in self._option_string_actions:
+                confl_optional = self._option_string_actions[option_string]
+                confl_optionals.append((option_string, confl_optional))
+
+        # resolve any conflicts
+        if confl_optionals:
+            conflict_handler = self._get_handler()
+            conflict_handler(action, confl_optionals)
+
+    def _handle_conflict_error(self, action, conflicting_actions):
+        message = _('conflicting option string(s): %s')
+        conflict_string = ', '.join([option_string
+                                     for option_string, action
+                                     in conflicting_actions])
+        raise ArgumentError(action, message % conflict_string)
+
+    def _handle_conflict_resolve(self, action, conflicting_actions):
+
+        # remove all conflicting options
+        for option_string, action in conflicting_actions:
+
+            # remove the conflicting option
+            action.option_strings.remove(option_string)
+            self._option_string_actions.pop(option_string, None)
+
+            # if the option now has no option string, remove it from the
+            # container holding it
+            if not action.option_strings:
+                action.container._remove_action(action)
+
+
+class _ArgumentGroup(_ActionsContainer):
+
+    def __init__(self, container, title=None, description=None, **kwargs):
+        # add any missing keyword arguments by checking the container
+        update = kwargs.setdefault
+        update('conflict_handler', container.conflict_handler)
+        update('prefix_chars', container.prefix_chars)
+        update('argument_default', container.argument_default)
+        super_init = super(_ArgumentGroup, self).__init__
+        super_init(description=description, **kwargs)
+
+        # group attributes
+        self.title = title
+        self._group_actions = []
+
+        # share most attributes with the container
+        self._registries = container._registries
+        self._actions = container._actions
+        self._option_string_actions = container._option_string_actions
+        self._defaults = container._defaults
+        self._has_negative_number_optionals = \
+            container._has_negative_number_optionals
+
+    def _add_action(self, action):
+        action = super(_ArgumentGroup, self)._add_action(action)
+        self._group_actions.append(action)
+        return action
+
+    def _remove_action(self, action):
+        super(_ArgumentGroup, self)._remove_action(action)
+        self._group_actions.remove(action)
+
+
+class _MutuallyExclusiveGroup(_ArgumentGroup):
+
+    def __init__(self, container, required=False):
+        super(_MutuallyExclusiveGroup, self).__init__(container)
+        self.required = required
+        self._container = container
+
+    def _add_action(self, action):
+        if action.required:
+            msg = _('mutually exclusive arguments must be optional')
+            raise ValueError(msg)
+        action = self._container._add_action(action)
+        self._group_actions.append(action)
+        return action
+
+    def _remove_action(self, action):
+        self._container._remove_action(action)
+        self._group_actions.remove(action)
+
+
+class ArgumentParser(_AttributeHolder, _ActionsContainer):
+    """Object for parsing command line strings into Python objects.
+
+    Keyword Arguments:
+        - prog -- The name of the program (default: sys.argv[0])
+        - usage -- A usage message (default: auto-generated from arguments)
+        - description -- A description of what the program does
+        - epilog -- Text following the argument descriptions
+        - parents -- Parsers whose arguments should be copied into this one
+        - formatter_class -- HelpFormatter class for printing help messages
+        - prefix_chars -- Characters that prefix optional arguments
+        - fromfile_prefix_chars -- Characters that prefix files containing
+            additional arguments
+        - argument_default -- The default value for all arguments
+        - conflict_handler -- String indicating how to handle conflicts
+        - add_help -- Add a -h/-help option
+    """
+
+    def __init__(self,
+                 prog=None,
+                 usage=None,
+                 description=None,
+                 epilog=None,
+                 version=None,
+                 parents=[],
+                 formatter_class=HelpFormatter,
+                 prefix_chars='-',
+                 fromfile_prefix_chars=None,
+                 argument_default=None,
+                 conflict_handler='error',
+                 add_help=True):
+
+        if version is not None:
+            import warnings
+            warnings.warn(
+                """The "version" argument to ArgumentParser is deprecated. """
+                """Please use """
+                """"add_argument(..., action='version', version="N", ...)" """
+                """instead""", DeprecationWarning)
+
+        superinit = super(ArgumentParser, self).__init__
+        superinit(description=description,
+                  prefix_chars=prefix_chars,
+                  argument_default=argument_default,
+                  conflict_handler=conflict_handler)
+
+        # default setting for prog
+        if prog is None:
+            prog = _os.path.basename(_sys.argv[0])
+
+        self.prog = prog
+        self.usage = usage
+        self.epilog = epilog
+        self.version = version
+        self.formatter_class = formatter_class
+        self.fromfile_prefix_chars = fromfile_prefix_chars
+        self.add_help = add_help
+
+        add_group = self.add_argument_group
+        self._positionals = add_group(_('positional arguments'))
+        self._optionals = add_group(_('optional arguments'))
+        self._subparsers = None
+
+        # register types
+        def identity(string):
+            return string
+        self.register('type', None, identity)
+
+        # add help and version arguments if necessary
+        # (using explicit default to override global argument_default)
+        if self.add_help:
+            self.add_argument(
+                '-h', '--help', action='help', default=SUPPRESS,
+                help=_('show this help message and exit'))
+        if self.version:
+            self.add_argument(
+                '-v', '--version', action='version', default=SUPPRESS,
+                version=self.version,
+                help=_("show program's version number and exit"))
+
+        # add parent arguments and defaults
+        for parent in parents:
+            self._add_container_actions(parent)
+            try:
+                defaults = parent._defaults
+            except AttributeError:
+                pass
+            else:
+                self._defaults.update(defaults)
+
+    # =======================
+    # Pretty __repr__ methods
+    # =======================
+    def _get_kwargs(self):
+        names = [
+            'prog',
+            'usage',
+            'description',
+            'version',
+            'formatter_class',
+            'conflict_handler',
+            'add_help',
+        ]
+        return [(name, getattr(self, name)) for name in names]
+
+    # ==================================
+    # Optional/Positional adding methods
+    # ==================================
+    def add_subparsers(self, **kwargs):
+        if self._subparsers is not None:
+            self.error(_('cannot have multiple subparser arguments'))
+
+        # add the parser class to the arguments if it's not present
+        kwargs.setdefault('parser_class', type(self))
+
+        if 'title' in kwargs or 'description' in kwargs:
+            title = _(kwargs.pop('title', 'subcommands'))
+            description = _(kwargs.pop('description', None))
+            self._subparsers = self.add_argument_group(title, description)
+        else:
+            self._subparsers = self._positionals
+
+        # prog defaults to the usage message of this parser, skipping
+        # optional arguments and with no "usage:" prefix
+        if kwargs.get('prog') is None:
+            formatter = self._get_formatter()
+            positionals = self._get_positional_actions()
+            groups = self._mutually_exclusive_groups
+            formatter.add_usage(self.usage, positionals, groups, '')
+            kwargs['prog'] = formatter.format_help().strip()
+
+        # create the parsers action and add it to the positionals list
+        parsers_class = self._pop_action_class(kwargs, 'parsers')
+        action = parsers_class(option_strings=[], **kwargs)
+        self._subparsers._add_action(action)
+
+        # return the created parsers action
+        return action
+
+    def _add_action(self, action):
+        if action.option_strings:
+            self._optionals._add_action(action)
+        else:
+            self._positionals._add_action(action)
+        return action
+
+    def _get_optional_actions(self):
+        return [action
+                for action in self._actions
+                if action.option_strings]
+
+    def _get_positional_actions(self):
+        return [action
+                for action in self._actions
+                if not action.option_strings]
+
+    # =====================================
+    # Command line argument parsing methods
+    # =====================================
+    def parse_args(self, args=None, namespace=None):
+        args, argv = self.parse_known_args(args, namespace)
+        if argv:
+            msg = _('unrecognized arguments: %s')
+            self.error(msg % ' '.join(argv))
+        return args
+
+    def parse_known_args(self, args=None, namespace=None):
+        # args default to the system args
+        if args is None:
+            args = _sys.argv[1:]
+
+        # default Namespace built from parser defaults
+        if namespace is None:
+            namespace = Namespace()
+
+        # add any action defaults that aren't present
+        for action in self._actions:
+            if action.dest is not SUPPRESS:
+                if not hasattr(namespace, action.dest):
+                    if action.default is not SUPPRESS:
+                        default = action.default
+                        if isinstance(action.default, _basestring):
+                            default = self._get_value(action, default)
+                        setattr(namespace, action.dest, default)
+
+        # add any parser defaults that aren't present
+        for dest in self._defaults:
+            if not hasattr(namespace, dest):
+                setattr(namespace, dest, self._defaults[dest])
+
+        # parse the arguments and exit if there are any errors
+        try:
+            return self._parse_known_args(args, namespace)
+        except ArgumentError:
+            err = _sys.exc_info()[1]
+            self.error(str(err))
+
+    def _parse_known_args(self, arg_strings, namespace):
+        # replace arg strings that are file references
+        if self.fromfile_prefix_chars is not None:
+            arg_strings = self._read_args_from_files(arg_strings)
+
+        # map all mutually exclusive arguments to the other arguments
+        # they can't occur with
+        action_conflicts = {}
+        for mutex_group in self._mutually_exclusive_groups:
+            group_actions = mutex_group._group_actions
+            for i, mutex_action in enumerate(mutex_group._group_actions):
+                conflicts = action_conflicts.setdefault(mutex_action, [])
+                conflicts.extend(group_actions[:i])
+                conflicts.extend(group_actions[i + 1:])
+
+        # find all option indices, and determine the arg_string_pattern
+        # which has an 'O' if there is an option at an index,
+        # an 'A' if there is an argument, or a '-' if there is a '--'
+        option_string_indices = {}
+        arg_string_pattern_parts = []
+        arg_strings_iter = iter(arg_strings)
+        for i, arg_string in enumerate(arg_strings_iter):
+
+            # all args after -- are non-options
+            if arg_string == '--':
+                arg_string_pattern_parts.append('-')
+                for arg_string in arg_strings_iter:
+                    arg_string_pattern_parts.append('A')
+
+            # otherwise, add the arg to the arg strings
+            # and note the index if it was an option
+            else:
+                option_tuple = self._parse_optional(arg_string)
+                if option_tuple is None:
+                    pattern = 'A'
+                else:
+                    option_string_indices[i] = option_tuple
+                    pattern = 'O'
+                arg_string_pattern_parts.append(pattern)
+
+        # join the pieces together to form the pattern
+        arg_strings_pattern = ''.join(arg_string_pattern_parts)
+
+        # converts arg strings to the appropriate and then takes the action
+        seen_actions = _set()
+        seen_non_default_actions = _set()
+
+        def take_action(action, argument_strings, option_string=None):
+            seen_actions.add(action)
+            argument_values = self._get_values(action, argument_strings)
+
+            # error if this argument is not allowed with other previously
+            # seen arguments, assuming that actions that use the default
+            # value don't really count as "present"
+            if argument_values is not action.default:
+                seen_non_default_actions.add(action)
+                for conflict_action in action_conflicts.get(action, []):
+                    if conflict_action in seen_non_default_actions:
+                        msg = _('not allowed with argument %s')
+                        action_name = _get_action_name(conflict_action)
+                        raise ArgumentError(action, msg % action_name)
+
+            # take the action if we didn't receive a SUPPRESS value
+            # (e.g. from a default)
+            if argument_values is not SUPPRESS:
+                action(self, namespace, argument_values, option_string)
+
+        # function to convert arg_strings into an optional action
+        def consume_optional(start_index):
+
+            # get the optional identified at this index
+            option_tuple = option_string_indices[start_index]
+            action, option_string, explicit_arg = option_tuple
+
+            # identify additional optionals in the same arg string
+            # (e.g. -xyz is the same as -x -y -z if no args are required)
+            match_argument = self._match_argument
+            action_tuples = []
+            while True:
+
+                # if we found no optional action, skip it
+                if action is None:
+                    extras.append(arg_strings[start_index])
+                    return start_index + 1
+
+                # if there is an explicit argument, try to match the
+                # optional's string arguments to only this
+                if explicit_arg is not None:
+                    arg_count = match_argument(action, 'A')
+
+                    # if the action is a single-dash option and takes no
+                    # arguments, try to parse more single-dash options out
+                    # of the tail of the option string
+                    chars = self.prefix_chars
+                    if arg_count == 0 and option_string[1] not in chars:
+                        action_tuples.append((action, [], option_string))
+                        for char in self.prefix_chars:
+                            option_string = char + explicit_arg[0]
+                            explicit_arg = explicit_arg[1:] or None
+                            optionals_map = self._option_string_actions
+                            if option_string in optionals_map:
+                                action = optionals_map[option_string]
+                                break
+                        else:
+                            msg = _('ignored explicit argument %r')
+                            raise ArgumentError(action, msg % explicit_arg)
+
+                    # if the action expect exactly one argument, we've
+                    # successfully matched the option; exit the loop
+                    elif arg_count == 1:
+                        stop = start_index + 1
+                        args = [explicit_arg]
+                        action_tuples.append((action, args, option_string))
+                        break
+
+                    # error if a double-dash option did not use the
+                    # explicit argument
+                    else:
+                        msg = _('ignored explicit argument %r')
+                        raise ArgumentError(action, msg % explicit_arg)
+
+                # if there is no explicit argument, try to match the
+                # optional's string arguments with the following strings
+                # if successful, exit the loop
+                else:
+                    start = start_index + 1
+                    selected_patterns = arg_strings_pattern[start:]
+                    arg_count = match_argument(action, selected_patterns)
+                    stop = start + arg_count
+                    args = arg_strings[start:stop]
+                    action_tuples.append((action, args, option_string))
+                    break
+
+            # add the Optional to the list and return the index at which
+            # the Optional's string args stopped
+            assert action_tuples
+            for action, args, option_string in action_tuples:
+                take_action(action, args, option_string)
+            return stop
+
+        # the list of Positionals left to be parsed; this is modified
+        # by consume_positionals()
+        positionals = self._get_positional_actions()
+
+        # function to convert arg_strings into positional actions
+        def consume_positionals(start_index):
+            # match as many Positionals as possible
+            match_partial = self._match_arguments_partial
+            selected_pattern = arg_strings_pattern[start_index:]
+            arg_counts = match_partial(positionals, selected_pattern)
+
+            # slice off the appropriate arg strings for each Positional
+            # and add the Positional and its args to the list
+            for action, arg_count in zip(positionals, arg_counts):
+                args = arg_strings[start_index: start_index + arg_count]
+                start_index += arg_count
+                take_action(action, args)
+
+            # slice off the Positionals that we just parsed and return the
+            # index at which the Positionals' string args stopped
+            positionals[:] = positionals[len(arg_counts):]
+            return start_index
+
+        # consume Positionals and Optionals alternately, until we have
+        # passed the last option string
+        extras = []
+        start_index = 0
+        if option_string_indices:
+            max_option_string_index = max(option_string_indices)
+        else:
+            max_option_string_index = -1
+        while start_index <= max_option_string_index:
+
+            # consume any Positionals preceding the next option
+            next_option_string_index = min([
+                index
+                for index in option_string_indices
+                if index >= start_index])
+            if start_index != next_option_string_index:
+                positionals_end_index = consume_positionals(start_index)
+
+                # only try to parse the next optional if we didn't consume
+                # the option string during the positionals parsing
+                if positionals_end_index > start_index:
+                    start_index = positionals_end_index
+                    continue
+                else:
+                    start_index = positionals_end_index
+
+            # if we consumed all the positionals we could and we're not
+            # at the index of an option string, there were extra arguments
+            if start_index not in option_string_indices:
+                strings = arg_strings[start_index:next_option_string_index]
+                extras.extend(strings)
+                start_index = next_option_string_index
+
+            # consume the next optional and any arguments for it
+            start_index = consume_optional(start_index)
+
+        # consume any positionals following the last Optional
+        stop_index = consume_positionals(start_index)
+
+        # if we didn't consume all the argument strings, there were extras
+        extras.extend(arg_strings[stop_index:])
+
+        # if we didn't use all the Positional objects, there were too few
+        # arg strings supplied.
+        if positionals:
+            self.error(_('too few arguments'))
+
+        # make sure all required actions were present
+        for action in self._actions:
+            if action.required:
+                if action not in seen_actions:
+                    name = _get_action_name(action)
+                    self.error(_('argument %s is required') % name)
+
+        # make sure all required groups had one option present
+        for group in self._mutually_exclusive_groups:
+            if group.required:
+                for action in group._group_actions:
+                    if action in seen_non_default_actions:
+                        break
+
+                # if no actions were used, report the error
+                else:
+                    names = [_get_action_name(action)
+                             for action in group._group_actions
+                             if action.help is not SUPPRESS]
+                    msg = _('one of the arguments %s is required')
+                    self.error(msg % ' '.join(names))
+
+        # return the updated namespace and the extra arguments
+        return namespace, extras
+
+    def _read_args_from_files(self, arg_strings):
+        # expand arguments referencing files
+        new_arg_strings = []
+        for arg_string in arg_strings:
+
+            # for regular arguments, just add them back into the list
+            if arg_string[0] not in self.fromfile_prefix_chars:
+                new_arg_strings.append(arg_string)
+
+            # replace arguments referencing files with the file content
+            else:
+                try:
+                    args_file = open(arg_string[1:])
+                    try:
+                        arg_strings = []
+                        for arg_line in args_file.read().splitlines():
+                            for arg in self.convert_arg_line_to_args(arg_line):
+                                arg_strings.append(arg)
+                        arg_strings = self._read_args_from_files(arg_strings)
+                        new_arg_strings.extend(arg_strings)
+                    finally:
+                        args_file.close()
+                except IOError:
+                    err = _sys.exc_info()[1]
+                    self.error(str(err))
+
+        # return the modified argument list
+        return new_arg_strings
+
+    def convert_arg_line_to_args(self, arg_line):
+        return [arg_line]
+
+    def _match_argument(self, action, arg_strings_pattern):
+        # match the pattern for this action to the arg strings
+        nargs_pattern = self._get_nargs_pattern(action)
+        match = _re.match(nargs_pattern, arg_strings_pattern)
+
+        # raise an exception if we weren't able to find a match
+        if match is None:
+            nargs_errors = {
+                None: _('expected one argument'),
+                OPTIONAL: _('expected at most one argument'),
+                ONE_OR_MORE: _('expected at least one argument'),
+            }
+            default = _('expected %s argument(s)') % action.nargs
+            msg = nargs_errors.get(action.nargs, default)
+            raise ArgumentError(action, msg)
+
+        # return the number of arguments matched
+        return len(match.group(1))
+
+    def _match_arguments_partial(self, actions, arg_strings_pattern):
+        # progressively shorten the actions list by slicing off the
+        # final actions until we find a match
+        result = []
+        for i in range(len(actions), 0, -1):
+            actions_slice = actions[:i]
+            pattern = ''.join([self._get_nargs_pattern(action)
+                               for action in actions_slice])
+            match = _re.match(pattern, arg_strings_pattern)
+            if match is not None:
+                result.extend([len(string) for string in match.groups()])
+                break
+
+        # return the list of arg string counts
+        return result
+
+    def _parse_optional(self, arg_string):
+        # if it's an empty string, it was meant to be a positional
+        if not arg_string:
+            return None
+
+        # if it doesn't start with a prefix, it was meant to be positional
+        if not arg_string[0] in self.prefix_chars:
+            return None
+
+        # if the option string is present in the parser, return the action
+        if arg_string in self._option_string_actions:
+            action = self._option_string_actions[arg_string]
+            return action, arg_string, None
+
+        # if it's just a single character, it was meant to be positional
+        if len(arg_string) == 1:
+            return None
+
+        # if the option string before the "=" is present, return the action
+        if '=' in arg_string:
+            option_string, explicit_arg = arg_string.split('=', 1)
+            if option_string in self._option_string_actions:
+                action = self._option_string_actions[option_string]
+                return action, option_string, explicit_arg
+
+        # search through all possible prefixes of the option string
+        # and all actions in the parser for possible interpretations
+        option_tuples = self._get_option_tuples(arg_string)
+
+        # if multiple actions match, the option string was ambiguous
+        if len(option_tuples) > 1:
+            options = ', '.join([option_string
+                for action, option_string, explicit_arg in option_tuples])
+            tup = arg_string, options
+            self.error(_('ambiguous option: %s could match %s') % tup)
+
+        # if exactly one action matched, this segmentation is good,
+        # so return the parsed action
+        elif len(option_tuples) == 1:
+            option_tuple, = option_tuples
+            return option_tuple
+
+        # if it was not found as an option, but it looks like a negative
+        # number, it was meant to be positional
+        # unless there are negative-number-like options
+        if self._negative_number_matcher.match(arg_string):
+            if not self._has_negative_number_optionals:
+                return None
+
+        # if it contains a space, it was meant to be a positional
+        if ' ' in arg_string:
+            return None
+
+        # it was meant to be an optional but there is no such option
+        # in this parser (though it might be a valid option in a subparser)
+        return None, arg_string, None
+
+    def _get_option_tuples(self, option_string):
+        result = []
+
+        # option strings starting with two prefix characters are only
+        # split at the '='
+        chars = self.prefix_chars
+        if option_string[0] in chars and option_string[1] in chars:
+            if '=' in option_string:
+                option_prefix, explicit_arg = option_string.split('=', 1)
+            else:
+                option_prefix = option_string
+                explicit_arg = None
+            for option_string in self._option_string_actions:
+                if option_string.startswith(option_prefix):
+                    action = self._option_string_actions[option_string]
+                    tup = action, option_string, explicit_arg
+                    result.append(tup)
+
+        # single character options can be concatenated with their arguments
+        # but multiple character options always have to have their argument
+        # separate
+        elif option_string[0] in chars and option_string[1] not in chars:
+            option_prefix = option_string
+            explicit_arg = None
+            short_option_prefix = option_string[:2]
+            short_explicit_arg = option_string[2:]
+
+            for option_string in self._option_string_actions:
+                if option_string == short_option_prefix:
+                    action = self._option_string_actions[option_string]
+                    tup = action, option_string, short_explicit_arg
+                    result.append(tup)
+                elif option_string.startswith(option_prefix):
+                    action = self._option_string_actions[option_string]
+                    tup = action, option_string, explicit_arg
+                    result.append(tup)
+
+        # shouldn't ever get here
+        else:
+            self.error(_('unexpected option string: %s') % option_string)
+
+        # return the collected option tuples
+        return result
+
+    def _get_nargs_pattern(self, action):
+        # in all examples below, we have to allow for '--' args
+        # which are represented as '-' in the pattern
+        nargs = action.nargs
+
+        # the default (None) is assumed to be a single argument
+        if nargs is None:
+            nargs_pattern = '(-*A-*)'
+
+        # allow zero or one arguments
+        elif nargs == OPTIONAL:
+            nargs_pattern = '(-*A?-*)'
+
+        # allow zero or more arguments
+        elif nargs == ZERO_OR_MORE:
+            nargs_pattern = '(-*[A-]*)'
+
+        # allow one or more arguments
+        elif nargs == ONE_OR_MORE:
+            nargs_pattern = '(-*A[A-]*)'
+
+        # allow any number of options or arguments
+        elif nargs == REMAINDER:
+            nargs_pattern = '([-AO]*)'
+
+        # allow one argument followed by any number of options or arguments
+        elif nargs == PARSER:
+            nargs_pattern = '(-*A[-AO]*)'
+
+        # all others should be integers
+        else:
+            nargs_pattern = '(-*%s-*)' % '-*'.join('A' * nargs)
+
+        # if this is an optional action, -- is not allowed
+        if action.option_strings:
+            nargs_pattern = nargs_pattern.replace('-*', '')
+            nargs_pattern = nargs_pattern.replace('-', '')
+
+        # return the pattern
+        return nargs_pattern
+
+    # ========================
+    # Value conversion methods
+    # ========================
+    def _get_values(self, action, arg_strings):
+        # for everything but PARSER args, strip out '--'
+        if action.nargs not in [PARSER, REMAINDER]:
+            arg_strings = [s for s in arg_strings if s != '--']
+
+        # optional argument produces a default when not present
+        if not arg_strings and action.nargs == OPTIONAL:
+            if action.option_strings:
+                value = action.const
+            else:
+                value = action.default
+            if isinstance(value, _basestring):
+                value = self._get_value(action, value)
+                self._check_value(action, value)
+
+        # when nargs='*' on a positional, if there were no command-line
+        # args, use the default if it is anything other than None
+        elif (not arg_strings and action.nargs == ZERO_OR_MORE and
+              not action.option_strings):
+            if action.default is not None:
+                value = action.default
+            else:
+                value = arg_strings
+            self._check_value(action, value)
+
+        # single argument or optional argument produces a single value
+        elif len(arg_strings) == 1 and action.nargs in [None, OPTIONAL]:
+            arg_string, = arg_strings
+            value = self._get_value(action, arg_string)
+            self._check_value(action, value)
+
+        # REMAINDER arguments convert all values, checking none
+        elif action.nargs == REMAINDER:
+            value = [self._get_value(action, v) for v in arg_strings]
+
+        # PARSER arguments convert all values, but check only the first
+        elif action.nargs == PARSER:
+            value = [self._get_value(action, v) for v in arg_strings]
+            self._check_value(action, value[0])
+
+        # all other types of nargs produce a list
+        else:
+            value = [self._get_value(action, v) for v in arg_strings]
+            for v in value:
+                self._check_value(action, v)
+
+        # return the converted value
+        return value
+
+    def _get_value(self, action, arg_string):
+        type_func = self._registry_get('type', action.type, action.type)
+        if not _callable(type_func):
+            msg = _('%r is not callable')
+            raise ArgumentError(action, msg % type_func)
+
+        # convert the value to the appropriate type
+        try:
+            result = type_func(arg_string)
+
+        # ArgumentTypeErrors indicate errors
+        except ArgumentTypeError:
+            name = getattr(action.type, '__name__', repr(action.type))
+            msg = str(_sys.exc_info()[1])
+            raise ArgumentError(action, msg)
+
+        # TypeErrors or ValueErrors also indicate errors
+        except (TypeError, ValueError):
+            name = getattr(action.type, '__name__', repr(action.type))
+            msg = _('invalid %s value: %r')
+            raise ArgumentError(action, msg % (name, arg_string))
+
+        # return the converted value
+        return result
+
+    def _check_value(self, action, value):
+        # converted value must be one of the choices (if specified)
+        if action.choices is not None and value not in action.choices:
+            tup = value, ', '.join(map(repr, action.choices))
+            msg = _('invalid choice: %r (choose from %s)') % tup
+            raise ArgumentError(action, msg)
+
+    # =======================
+    # Help-formatting methods
+    # =======================
+    def format_usage(self):
+        formatter = self._get_formatter()
+        formatter.add_usage(self.usage, self._actions,
+                            self._mutually_exclusive_groups)
+        return formatter.format_help()
+
+    def format_help(self):
+        formatter = self._get_formatter()
+
+        # usage
+        formatter.add_usage(self.usage, self._actions,
+                            self._mutually_exclusive_groups)
+
+        # description
+        formatter.add_text(self.description)
+
+        # positionals, optionals and user-defined groups
+        for action_group in self._action_groups:
+            formatter.start_section(action_group.title)
+            formatter.add_text(action_group.description)
+            formatter.add_arguments(action_group._group_actions)
+            formatter.end_section()
+
+        # epilog
+        formatter.add_text(self.epilog)
+
+        # determine help from format above
+        return formatter.format_help()
+
+    def format_version(self):
+        import warnings
+        warnings.warn(
+            'The format_version method is deprecated -- the "version" '
+            'argument to ArgumentParser is no longer supported.',
+            DeprecationWarning)
+        formatter = self._get_formatter()
+        formatter.add_text(self.version)
+        return formatter.format_help()
+
+    def _get_formatter(self):
+        return self.formatter_class(prog=self.prog)
+
+    # =====================
+    # Help-printing methods
+    # =====================
+    def print_usage(self, file=None):
+        if file is None:
+            file = _sys.stdout
+        self._print_message(self.format_usage(), file)
+
+    def print_help(self, file=None):
+        if file is None:
+            file = _sys.stdout
+        self._print_message(self.format_help(), file)
+
+    def print_version(self, file=None):
+        import warnings
+        warnings.warn(
+            'The print_version method is deprecated -- the "version" '
+            'argument to ArgumentParser is no longer supported.',
+            DeprecationWarning)
+        self._print_message(self.format_version(), file)
+
+    def _print_message(self, message, file=None):
+        if message:
+            if file is None:
+                file = _sys.stderr
+            file.write(message)
+
+    # ===============
+    # Exiting methods
+    # ===============
+    def exit(self, status=0, message=None):
+        if message:
+            self._print_message(message, _sys.stderr)
+        _sys.exit(status)
+
+    def error(self, message):
+        """error(message: string)
+
+        Prints a usage message incorporating the message to stderr and
+        exits.
+
+        If you override this in a subclass, it should not return -- it
+        should either exit or raise an exception.
+        """
+        self.print_usage(_sys.stderr)
+        self.exit(2, _('%s: error: %s\n') % (self.prog, message))
--- a/kvmtools/config/argparse.py	Fri Mar 23 02:49:17 2012 +0100
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,2353 +0,0 @@
-# -*- coding: utf-8 -*-
-
-# Copyright © 2006-2009 Steven J. Bethard <steven.bethard@gmail.com>.
-#
-# Licensed under the Apache License, Version 2.0 (the "License"); you may not
-# use this file except in compliance with the License. You may obtain a copy
-# of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-# License for the specific language governing permissions and limitations
-# under the License.
-
-"""Command-line parsing library
-
-This module is an optparse-inspired command-line parsing library that:
-
-    - handles both optional and positional arguments
-    - produces highly informative usage messages
-    - supports parsers that dispatch to sub-parsers
-
-The following is a simple usage example that sums integers from the
-command-line and writes the result to a file::
-
-    parser = argparse.ArgumentParser(
-        description='sum the integers at the command line')
-    parser.add_argument(
-        'integers', metavar='int', nargs='+', type=int,
-        help='an integer to be summed')
-    parser.add_argument(
-        '--log', default=sys.stdout, type=argparse.FileType('w'),
-        help='the file where the sum should be written')
-    args = parser.parse_args()
-    args.log.write('%s' % sum(args.integers))
-    args.log.close()
-
-The module contains the following public classes:
-
-    - ArgumentParser -- The main entry point for command-line parsing. As the
-        example above shows, the add_argument() method is used to populate
-        the parser with actions for optional and positional arguments. Then
-        the parse_args() method is invoked to convert the args at the
-        command-line into an object with attributes.
-
-    - ArgumentError -- The exception raised by ArgumentParser objects when
-        there are errors with the parser's actions. Errors raised while
-        parsing the command-line are caught by ArgumentParser and emitted
-        as command-line messages.
-
-    - FileType -- A factory for defining types of files to be created. As the
-        example above shows, instances of FileType are typically passed as
-        the type= argument of add_argument() calls.
-
-    - Action -- The base class for parser actions. Typically actions are
-        selected by passing strings like 'store_true' or 'append_const' to
-        the action= argument of add_argument(). However, for greater
-        customization of ArgumentParser actions, subclasses of Action may
-        be defined and passed as the action= argument.
-
-    - HelpFormatter, RawDescriptionHelpFormatter, RawTextHelpFormatter,
-        ArgumentDefaultsHelpFormatter -- Formatter classes which
-        may be passed as the formatter_class= argument to the
-        ArgumentParser constructor. HelpFormatter is the default,
-        RawDescriptionHelpFormatter and RawTextHelpFormatter tell the parser
-        not to change the formatting for help text, and
-        ArgumentDefaultsHelpFormatter adds information about argument defaults
-        to the help.
-
-All other classes in this module are considered implementation details.
-(Also note that HelpFormatter and RawDescriptionHelpFormatter are only
-considered public as object names -- the API of the formatter objects is
-still considered an implementation detail.)
-"""
-
-__version__ = '1.1'
-__all__ = [
-    'ArgumentParser',
-    'ArgumentError',
-    'Namespace',
-    'Action',
-    'FileType',
-    'HelpFormatter',
-    'RawDescriptionHelpFormatter',
-    'RawTextHelpFormatter',
-    'ArgumentDefaultsHelpFormatter',
-]
-
-
-import copy as _copy
-import os as _os
-import re as _re
-import sys as _sys
-import textwrap as _textwrap
-
-from gettext import gettext as _
-
-try:
-    _set = set
-except NameError:
-    from sets import Set as _set
-
-try:
-    _basestring = basestring
-except NameError:
-    _basestring = str
-
-try:
-    _sorted = sorted
-except NameError:
-
-    def _sorted(iterable, reverse=False):
-        result = list(iterable)
-        result.sort()
-        if reverse:
-            result.reverse()
-        return result
-
-
-def _callable(obj):
-    return hasattr(obj, '__call__') or hasattr(obj, '__bases__')
-
-# silence Python 2.6 buggy warnings about Exception.message
-if _sys.version_info[:2] == (2, 6):
-    import warnings
-    warnings.filterwarnings(
-        action='ignore',
-        message='BaseException.message has been deprecated as of Python 2.6',
-        category=DeprecationWarning,
-        module='argparse')
-
-
-SUPPRESS = '==SUPPRESS=='
-
-OPTIONAL = '?'
-ZERO_OR_MORE = '*'
-ONE_OR_MORE = '+'
-PARSER = 'A...'
-REMAINDER = '...'
-
-# =============================
-# Utility functions and classes
-# =============================
-
-class _AttributeHolder(object):
-    """Abstract base class that provides __repr__.
-
-    The __repr__ method returns a string in the format::
-        ClassName(attr=name, attr=name, ...)
-    The attributes are determined either by a class-level attribute,
-    '_kwarg_names', or by inspecting the instance __dict__.
-    """
-
-    def __repr__(self):
-        type_name = type(self).__name__
-        arg_strings = []
-        for arg in self._get_args():
-            arg_strings.append(repr(arg))
-        for name, value in self._get_kwargs():
-            arg_strings.append('%s=%r' % (name, value))
-        return '%s(%s)' % (type_name, ', '.join(arg_strings))
-
-    def _get_kwargs(self):
-        return _sorted(self.__dict__.items())
-
-    def _get_args(self):
-        return []
-
-
-def _ensure_value(namespace, name, value):
-    if getattr(namespace, name, None) is None:
-        setattr(namespace, name, value)
-    return getattr(namespace, name)
-
-
-# ===============
-# Formatting Help
-# ===============
-
-class HelpFormatter(object):
-    """Formatter for generating usage messages and argument help strings.
-
-    Only the name of this class is considered a public API. All the methods
-    provided by the class are considered an implementation detail.
-    """
-
-    def __init__(self,
-                 prog,
-                 indent_increment=2,
-                 max_help_position=24,
-                 width=None):
-
-        # default setting for width
-        if width is None:
-            try:
-                width = int(_os.environ['COLUMNS'])
-            except (KeyError, ValueError):
-                width = 80
-            width -= 2
-
-        self._prog = prog
-        self._indent_increment = indent_increment
-        self._max_help_position = max_help_position
-        self._width = width
-
-        self._current_indent = 0
-        self._level = 0
-        self._action_max_length = 0
-
-        self._root_section = self._Section(self, None)
-        self._current_section = self._root_section
-
-        self._whitespace_matcher = _re.compile(r'\s+')
-        self._long_break_matcher = _re.compile(r'\n\n\n+')
-
-    # ===============================
-    # Section and indentation methods
-    # ===============================
-    def _indent(self):
-        self._current_indent += self._indent_increment
-        self._level += 1
-
-    def _dedent(self):
-        self._current_indent -= self._indent_increment
-        assert self._current_indent >= 0, 'Indent decreased below 0.'
-        self._level -= 1
-
-    class _Section(object):
-
-        def __init__(self, formatter, parent, heading=None):
-            self.formatter = formatter
-            self.parent = parent
-            self.heading = heading
-            self.items = []
-
-        def format_help(self):
-            # format the indented section
-            if self.parent is not None:
-                self.formatter._indent()
-            join = self.formatter._join_parts
-            for func, args in self.items:
-                func(*args)
-            item_help = join([func(*args) for func, args in self.items])
-            if self.parent is not None:
-                self.formatter._dedent()
-
-            # return nothing if the section was empty
-            if not item_help:
-                return ''
-
-            # add the heading if the section was non-empty
-            if self.heading is not SUPPRESS and self.heading is not None:
-                current_indent = self.formatter._current_indent
-                heading = '%*s%s:\n' % (current_indent, '', self.heading)
-            else:
-                heading = ''
-
-            # join the section-initial newline, the heading and the help
-            return join(['\n', heading, item_help, '\n'])
-
-    def _add_item(self, func, args):
-        self._current_section.items.append((func, args))
-
-    # ========================
-    # Message building methods
-    # ========================
-    def start_section(self, heading):
-        self._indent()
-        section = self._Section(self, self._current_section, heading)
-        self._add_item(section.format_help, [])
-        self._current_section = section
-
-    def end_section(self):
-        self._current_section = self._current_section.parent
-        self._dedent()
-
-    def add_text(self, text):
-        if text is not SUPPRESS and text is not None:
-            self._add_item(self._format_text, [text])
-
-    def add_usage(self, usage, actions, groups, prefix=None):
-        if usage is not SUPPRESS:
-            args = usage, actions, groups, prefix
-            self._add_item(self._format_usage, args)
-
-    def add_argument(self, action):
-        if action.help is not SUPPRESS:
-
-            # find all invocations
-            get_invocation = self._format_action_invocation
-            invocations = [get_invocation(action)]
-            for subaction in self._iter_indented_subactions(action):
-                invocations.append(get_invocation(subaction))
-
-            # update the maximum item length
-            invocation_length = max([len(s) for s in invocations])
-            action_length = invocation_length + self._current_indent
-            self._action_max_length = max(self._action_max_length,
-                                          action_length)
-
-            # add the item to the list
-            self._add_item(self._format_action, [action])
-
-    def add_arguments(self, actions):
-        for action in actions:
-            self.add_argument(action)
-
-    # =======================
-    # Help-formatting methods
-    # =======================
-    def format_help(self):
-        help = self._root_section.format_help()
-        if help:
-            help = self._long_break_matcher.sub('\n\n', help)
-            help = help.strip('\n') + '\n'
-        return help
-
-    def _join_parts(self, part_strings):
-        return ''.join([part
-                        for part in part_strings
-                        if part and part is not SUPPRESS])
-
-    def _format_usage(self, usage, actions, groups, prefix):
-        if prefix is None:
-            prefix = _('usage: ')
-
-        # if usage is specified, use that
-        if usage is not None:
-            usage = usage % dict(prog=self._prog)
-
-        # if no optionals or positionals are available, usage is just prog
-        elif usage is None and not actions:
-            usage = '%(prog)s' % dict(prog=self._prog)
-
-        # if optionals and positionals are available, calculate usage
-        elif usage is None:
-            prog = '%(prog)s' % dict(prog=self._prog)
-
-            # split optionals from positionals
-            optionals = []
-            positionals = []
-            for action in actions:
-                if action.option_strings:
-                    optionals.append(action)
-                else:
-                    positionals.append(action)
-
-            # build full usage string
-            format = self._format_actions_usage
-            action_usage = format(optionals + positionals, groups)
-            usage = ' '.join([s for s in [prog, action_usage] if s])
-
-            # wrap the usage parts if it's too long
-            text_width = self._width - self._current_indent
-            if len(prefix) + len(usage) > text_width:
-
-                # break usage into wrappable parts
-                part_regexp = r'\(.*?\)+|\[.*?\]+|\S+'
-                opt_usage = format(optionals, groups)
-                pos_usage = format(positionals, groups)
-                opt_parts = _re.findall(part_regexp, opt_usage)
-                pos_parts = _re.findall(part_regexp, pos_usage)
-                assert ' '.join(opt_parts) == opt_usage
-                assert ' '.join(pos_parts) == pos_usage
-
-                # helper for wrapping lines
-                def get_lines(parts, indent, prefix=None):
-                    lines = []
-                    line = []
-                    if prefix is not None:
-                        line_len = len(prefix) - 1
-                    else:
-                        line_len = len(indent) - 1
-                    for part in parts:
-                        if line_len + 1 + len(part) > text_width:
-                            lines.append(indent + ' '.join(line))
-                            line = []
-                            line_len = len(indent) - 1
-                        line.append(part)
-                        line_len += len(part) + 1
-                    if line:
-                        lines.append(indent + ' '.join(line))
-                    if prefix is not None:
-                        lines[0] = lines[0][len(indent):]
-                    return lines
-
-                # if prog is short, follow it with optionals or positionals
-                if len(prefix) + len(prog) <= 0.75 * text_width:
-                    indent = ' ' * (len(prefix) + len(prog) + 1)
-                    if opt_parts:
-                        lines = get_lines([prog] + opt_parts, indent, prefix)
-                        lines.extend(get_lines(pos_parts, indent))
-                    elif pos_parts:
-                        lines = get_lines([prog] + pos_parts, indent, prefix)
-                    else:
-                        lines = [prog]
-
-                # if prog is long, put it on its own line
-                else:
-                    indent = ' ' * len(prefix)
-                    parts = opt_parts + pos_parts
-                    lines = get_lines(parts, indent)
-                    if len(lines) > 1:
-                        lines = []
-                        lines.extend(get_lines(opt_parts, indent))
-                        lines.extend(get_lines(pos_parts, indent))
-                    lines = [prog] + lines
-
-                # join lines into usage
-                usage = '\n'.join(lines)
-
-        # prefix with 'usage:'
-        return '%s%s\n\n' % (prefix, usage)
-
-    def _format_actions_usage(self, actions, groups):
-        # find group indices and identify actions in groups
-        group_actions = _set()
-        inserts = {}
-        for group in groups:
-            try:
-                start = actions.index(group._group_actions[0])
-            except ValueError:
-                continue
-            else:
-                end = start + len(group._group_actions)
-                if actions[start:end] == group._group_actions:
-                    for action in group._group_actions:
-                        group_actions.add(action)
-                    if not group.required:
-                        inserts[start] = '['
-                        inserts[end] = ']'
-                    else:
-                        inserts[start] = '('
-                        inserts[end] = ')'
-                    for i in range(start + 1, end):
-                        inserts[i] = '|'
-
-        # collect all actions format strings
-        parts = []
-        for i, action in enumerate(actions):
-
-            # suppressed arguments are marked with None
-            # remove | separators for suppressed arguments
-            if action.help is SUPPRESS:
-                parts.append(None)
-                if inserts.get(i) == '|':
-                    inserts.pop(i)
-                elif inserts.get(i + 1) == '|':
-                    inserts.pop(i + 1)
-
-            # produce all arg strings
-            elif not action.option_strings:
-                part = self._format_args(action, action.dest)
-
-                # if it's in a group, strip the outer []
-                if action in group_actions:
-                    if part[0] == '[' and part[-1] == ']':
-                        part = part[1:-1]
-
-                # add the action string to the list
-                parts.append(part)
-
-            # produce the first way to invoke the option in brackets
-            else:
-                option_string = action.option_strings[0]
-
-                # if the Optional doesn't take a value, format is:
-                #    -s or --long
-                if action.nargs == 0:
-                    part = '%s' % option_string
-
-                # if the Optional takes a value, format is:
-                #    -s ARGS or --long ARGS
-                else:
-                    default = action.dest.upper()
-                    args_string = self._format_args(action, default)
-                    part = '%s %s' % (option_string, args_string)
-
-                # make it look optional if it's not required or in a group
-                if not action.required and action not in group_actions:
-                    part = '[%s]' % part
-
-                # add the action string to the list
-                parts.append(part)
-
-        # insert things at the necessary indices
-        for i in _sorted(inserts, reverse=True):
-            parts[i:i] = [inserts[i]]
-
-        # join all the action items with spaces
-        text = ' '.join([item for item in parts if item is not None])
-
-        # clean up separators for mutually exclusive groups
-        open = r'[\[(]'
-        close = r'[\])]'
-        text = _re.sub(r'(%s) ' % open, r'\1', text)
-        text = _re.sub(r' (%s)' % close, r'\1', text)
-        text = _re.sub(r'%s *%s' % (open, close), r'', text)
-        text = _re.sub(r'\(([^|]*)\)', r'\1', text)
-        text = text.strip()
-
-        # return the text
-        return text
-
-    def _format_text(self, text):
-        if '%(prog)' in text:
-            text = text % dict(prog=self._prog)
-        text_width = self._width - self._current_indent
-        indent = ' ' * self._current_indent
-        return self._fill_text(text, text_width, indent) + '\n\n'
-
-    def _format_action(self, action):
-        # determine the required width and the entry label
-        help_position = min(self._action_max_length + 2,
-                            self._max_help_position)
-        help_width = self._width - help_position
-        action_width = help_position - self._current_indent - 2
-        action_header = self._format_action_invocation(action)
-
-        # ho nelp; start on same line and add a final newline
-        if not action.help:
-            tup = self._current_indent, '', action_header
-            action_header = '%*s%s\n' % tup
-
-        # short action name; start on the same line and pad two spaces
-        elif len(action_header) <= action_width:
-            tup = self._current_indent, '', action_width, action_header
-            action_header = '%*s%-*s  ' % tup
-            indent_first = 0
-
-        # long action name; start on the next line
-        else:
-            tup = self._current_indent, '', action_header
-            action_header = '%*s%s\n' % tup
-            indent_first = help_position
-
-        # collect the pieces of the action help
-        parts = [action_header]
-
-        # if there was help for the action, add lines of help text
-        if action.help:
-            help_text = self._expand_help(action)
-            help_lines = self._split_lines(help_text, help_width)
-            parts.append('%*s%s\n' % (indent_first, '', help_lines[0]))
-            for line in help_lines[1:]:
-                parts.append('%*s%s\n' % (help_position, '', line))
-
-        # or add a newline if the description doesn't end with one
-        elif not action_header.endswith('\n'):
-            parts.append('\n')
-
-        # if there are any sub-actions, add their help as well
-        for subaction in self._iter_indented_subactions(action):
-            parts.append(self._format_action(subaction))
-
-        # return a single string
-        return self._join_parts(parts)
-
-    def _format_action_invocation(self, action):
-        if not action.option_strings:
-            metavar, = self._metavar_formatter(action, action.dest)(1)
-            return metavar
-
-        else:
-            parts = []
-
-            # if the Optional doesn't take a value, format is:
-            #    -s, --long
-            if action.nargs == 0:
-                parts.extend(action.option_strings)
-
-            # if the Optional takes a value, format is:
-            #    -s ARGS, --long ARGS
-            else:
-                default = action.dest.upper()
-                args_string = self._format_args(action, default)
-                for option_string in action.option_strings:
-                    parts.append('%s %s' % (option_string, args_string))
-
-            return ', '.join(parts)
-
-    def _metavar_formatter(self, action, default_metavar):
-        if action.metavar is not None:
-            result = action.metavar
-        elif action.choices is not None:
-            choice_strs = [str(choice) for choice in action.choices]
-            result = '{%s}' % ','.join(choice_strs)
-        else:
-            result = default_metavar
-
-        def format(tuple_size):
-            if isinstance(result, tuple):
-                return result
-            else:
-                return (result, ) * tuple_size
-        return format
-
-    def _format_args(self, action, default_metavar):
-        get_metavar = self._metavar_formatter(action, default_metavar)
-        if action.nargs is None:
-            result = '%s' % get_metavar(1)
-        elif action.nargs == OPTIONAL:
-            result = '[%s]' % get_metavar(1)
-        elif action.nargs == ZERO_OR_MORE:
-            result = '[%s [%s ...]]' % get_metavar(2)
-        elif action.nargs == ONE_OR_MORE:
-            result = '%s [%s ...]' % get_metavar(2)
-        elif action.nargs == REMAINDER:
-            result = '...'
-        elif action.nargs == PARSER:
-            result = '%s ...' % get_metavar(1)
-        else:
-            formats = ['%s' for _ in range(action.nargs)]
-            result = ' '.join(formats) % get_metavar(action.nargs)
-        return result
-
-    def _expand_help(self, action):
-        params = dict(vars(action), prog=self._prog)
-        for name in list(params):
-            if params[name] is SUPPRESS:
-                del params[name]
-        for name in list(params):
-            if hasattr(params[name], '__name__'):
-                params[name] = params[name].__name__
-        if params.get('choices') is not None:
-            choices_str = ', '.join([str(c) for c in params['choices']])
-            params['choices'] = choices_str
-        return self._get_help_string(action) % params
-
-    def _iter_indented_subactions(self, action):
-        try:
-            get_subactions = action._get_subactions
-        except AttributeError:
-            pass
-        else:
-            self._indent()
-            for subaction in get_subactions():
-                yield subaction
-            self._dedent()
-
-    def _split_lines(self, text, width):
-        text = self._whitespace_matcher.sub(' ', text).strip()
-        return _textwrap.wrap(text, width)
-
-    def _fill_text(self, text, width, indent):
-        text = self._whitespace_matcher.sub(' ', text).strip()
-        return _textwrap.fill(text, width, initial_indent=indent,
-                                           subsequent_indent=indent)
-
-    def _get_help_string(self, action):
-        return action.help
-
-
-class RawDescriptionHelpFormatter(HelpFormatter):
-    """Help message formatter which retains any formatting in descriptions.
-
-    Only the name of this class is considered a public API. All the methods
-    provided by the class are considered an implementation detail.
-    """
-
-    def _fill_text(self, text, width, indent):
-        return ''.join([indent + line for line in text.splitlines(True)])
-
-
-class RawTextHelpFormatter(RawDescriptionHelpFormatter):
-    """Help message formatter which retains formatting of all help text.
-
-    Only the name of this class is considered a public API. All the methods
-    provided by the class are considered an implementation detail.
-    """
-
-    def _split_lines(self, text, width):
-        return text.splitlines()
-
-
-class ArgumentDefaultsHelpFormatter(HelpFormatter):
-    """Help message formatter which adds default values to argument help.
-
-    Only the name of this class is considered a public API. All the methods
-    provided by the class are considered an implementation detail.
-    """
-
-    def _get_help_string(self, action):
-        help = action.help
-        if '%(default)' not in action.help:
-            if action.default is not SUPPRESS:
-                defaulting_nargs = [OPTIONAL, ZERO_OR_MORE]
-                if action.option_strings or action.nargs in defaulting_nargs:
-                    help += ' (default: %(default)s)'
-        return help
-
-
-# =====================
-# Options and Arguments
-# =====================
-
-def _get_action_name(argument):
-    if argument is None:
-        return None
-    elif argument.option_strings:
-        return  '/'.join(argument.option_strings)
-    elif argument.metavar not in (None, SUPPRESS):
-        return argument.metavar
-    elif argument.dest not in (None, SUPPRESS):
-        return argument.dest
-    else:
-        return None
-
-
-class ArgumentError(Exception):
-    """An error from creating or using an argument (optional or positional).
-
-    The string value of this exception is the message, augmented with
-    information about the argument that caused it.
-    """
-
-    def __init__(self, argument, message):
-        self.argument_name = _get_action_name(argument)
-        self.message = message
-
-    def __str__(self):
-        if self.argument_name is None:
-            format = '%(message)s'
-        else:
-            format = 'argument %(argument_name)s: %(message)s'
-        return format % dict(message=self.message,
-                             argument_name=self.argument_name)
-
-
-class ArgumentTypeError(Exception):
-    """An error from trying to convert a command line string to a type."""
-    pass
-
-
-# ==============
-# Action classes
-# ==============
-
-class Action(_AttributeHolder):
-    """Information about how to convert command line strings to Python objects.
-
-    Action objects are used by an ArgumentParser to represent the information
-    needed to parse a single argument from one or more strings from the
-    command line. The keyword arguments to the Action constructor are also
-    all attributes of Action instances.
-
-    Keyword Arguments:
-
-        - option_strings -- A list of command-line option strings which
-            should be associated with this action.
-
-        - dest -- The name of the attribute to hold the created object(s)
-
-        - nargs -- The number of command-line arguments that should be
-            consumed. By default, one argument will be consumed and a single
-            value will be produced.  Other values include:
-                - N (an integer) consumes N arguments (and produces a list)
-                - '?' consumes zero or one arguments
-                - '*' consumes zero or more arguments (and produces a list)
-                - '+' consumes one or more arguments (and produces a list)
-            Note that the difference between the default and nargs=1 is that
-            with the default, a single value will be produced, while with
-            nargs=1, a list containing a single value will be produced.
-
-        - const -- The value to be produced if the option is specified and the
-            option uses an action that takes no values.
-
-        - default -- The value to be produced if the option is not specified.
-
-        - type -- The type which the command-line arguments should be converted
-            to, should be one of 'string', 'int', 'float', 'complex' or a
-            callable object that accepts a single string argument. If None,
-            'string' is assumed.
-
-        - choices -- A container of values that should be allowed. If not None,
-            after a command-line argument has been converted to the appropriate
-            type, an exception will be raised if it is not a member of this
-            collection.
-
-        - required -- True if the action must always be specified at the
-            command line. This is only meaningful for optional command-line
-            arguments.
-
-        - help -- The help string describing the argument.
-
-        - metavar -- The name to be used for the option's argument with the
-            help string. If None, the 'dest' value will be used as the name.
-    """
-
-    def __init__(self,
-                 option_strings,
-                 dest,
-                 nargs=None,
-                 const=None,
-                 default=None,
-                 type=None,
-                 choices=None,
-                 required=False,
-                 help=None,
-                 metavar=None):
-        self.option_strings = option_strings
-        self.dest = dest
-        self.nargs = nargs
-        self.const = const
-        self.default = default
-        self.type = type
-        self.choices = choices
-        self.required = required
-        self.help = help
-        self.metavar = metavar
-
-    def _get_kwargs(self):
-        names = [
-            'option_strings',
-            'dest',
-            'nargs',
-            'const',
-            'default',
-            'type',
-            'choices',
-            'help',
-            'metavar',
-        ]
-        return [(name, getattr(self, name)) for name in names]
-
-    def __call__(self, parser, namespace, values, option_string=None):
-        raise NotImplementedError(_('.__call__() not defined'))
-
-
-class _StoreAction(Action):
-
-    def __init__(self,
-                 option_strings,
-                 dest,
-                 nargs=None,
-                 const=None,
-                 default=None,
-                 type=None,
-                 choices=None,
-                 required=False,
-                 help=None,
-                 metavar=None):
-        if nargs == 0:
-            raise ValueError('nargs for store actions must be > 0; if you '
-                             'have nothing to store, actions such as store '
-                             'true or store const may be more appropriate')
-        if const is not None and nargs != OPTIONAL:
-            raise ValueError('nargs must be %r to supply const' % OPTIONAL)
-        super(_StoreAction, self).__init__(
-            option_strings=option_strings,
-            dest=dest,
-            nargs=nargs,
-            const=const,
-            default=default,
-            type=type,
-            choices=choices,
-            required=required,
-            help=help,
-            metavar=metavar)
-
-    def __call__(self, parser, namespace, values, option_string=None):
-        setattr(namespace, self.dest, values)
-
-
-class _StoreConstAction(Action):
-
-    def __init__(self,
-                 option_strings,
-                 dest,
-                 const,
-                 default=None,
-                 required=False,
-                 help=None,
-                 metavar=None):
-        super(_StoreConstAction, self).__init__(
-            option_strings=option_strings,
-            dest=dest,
-            nargs=0,
-            const=const,
-            default=default,
-            required=required,
-            help=help)
-
-    def __call__(self, parser, namespace, values, option_string=None):
-        setattr(namespace, self.dest, self.const)
-
-
-class _StoreTrueAction(_StoreConstAction):
-
-    def __init__(self,
-                 option_strings,
-                 dest,
-                 default=False,
-                 required=False,
-                 help=None):
-        super(_StoreTrueAction, self).__init__(
-            option_strings=option_strings,
-            dest=dest,
-            const=True,
-            default=default,
-            required=required,
-            help=help)
-
-
-class _StoreFalseAction(_StoreConstAction):
-
-    def __init__(self,
-                 option_strings,
-                 dest,
-                 default=True,
-                 required=False,
-                 help=None):
-        super(_StoreFalseAction, self).__init__(
-            option_strings=option_strings,
-            dest=dest,
-            const=False,
-            default=default,
-            required=required,
-            help=help)
-
-
-class _AppendAction(Action):
-
-    def __init__(self,
-                 option_strings,
-                 dest,
-                 nargs=None,
-                 const=None,
-                 default=None,
-                 type=None,
-                 choices=None,
-                 required=False,
-                 help=None,
-                 metavar=None):
-        if nargs == 0:
-            raise ValueError('nargs for append actions must be > 0; if arg '
-                             'strings are not supplying the value to append, '
-                             'the append const action may be more appropriate')
-        if const is not None and nargs != OPTIONAL:
-            raise ValueError('nargs must be %r to supply const' % OPTIONAL)
-        super(_AppendAction, self).__init__(
-            option_strings=option_strings,
-            dest=dest,
-            nargs=nargs,
-            const=const,
-            default=default,
-            type=type,
-            choices=choices,
-            required=required,
-            help=help,
-            metavar=metavar)
-
-    def __call__(self, parser, namespace, values, option_string=None):
-        items = _copy.copy(_ensure_value(namespace, self.dest, []))
-        items.append(values)
-        setattr(namespace, self.dest, items)
-
-
-class _AppendConstAction(Action):
-
-    def __init__(self,
-                 option_strings,
-                 dest,
-                 const,
-                 default=None,
-                 required=False,
-                 help=None,
-                 metavar=None):
-        super(_AppendConstAction, self).__init__(
-            option_strings=option_strings,
-            dest=dest,
-            nargs=0,
-            const=const,
-            default=default,
-            required=required,
-            help=help,
-            metavar=metavar)
-
-    def __call__(self, parser, namespace, values, option_string=None):
-        items = _copy.copy(_ensure_value(namespace, self.dest, []))
-        items.append(self.const)
-        setattr(namespace, self.dest, items)
-
-
-class _CountAction(Action):
-
-    def __init__(self,
-                 option_strings,
-                 dest,
-                 default=None,
-                 required=False,
-                 help=None):
-        super(_CountAction, self).__init__(
-            option_strings=option_strings,
-            dest=dest,
-            nargs=0,
-            default=default,
-            required=required,
-            help=help)
-
-    def __call__(self, parser, namespace, values, option_string=None):
-        new_count = _ensure_value(namespace, self.dest, 0) + 1
-        setattr(namespace, self.dest, new_count)
-
-
-class _HelpAction(Action):
-
-    def __init__(self,
-                 option_strings,
-                 dest=SUPPRESS,
-                 default=SUPPRESS,
-                 help=None):
-        super(_HelpAction, self).__init__(
-            option_strings=option_strings,
-            dest=dest,
-            default=default,
-            nargs=0,
-            help=help)
-
-    def __call__(self, parser, namespace, values, option_string=None):
-        parser.print_help()
-        parser.exit()
-
-
-class _VersionAction(Action):
-
-    def __init__(self,
-                 option_strings,
-                 version=None,
-                 dest=SUPPRESS,
-                 default=SUPPRESS,
-                 help=None):
-        super(_VersionAction, self).__init__(
-            option_strings=option_strings,
-            dest=dest,
-            default=default,
-            nargs=0,
-            help=help)
-        self.version = version
-
-    def __call__(self, parser, namespace, values, option_string=None):
-        version = self.version
-        if version is None:
-            version = parser.version
-        formatter = parser._get_formatter()
-        formatter.add_text(version)
-        parser.exit(message=formatter.format_help())
-
-
-class _SubParsersAction(Action):
-
-    class _ChoicesPseudoAction(Action):
-
-        def __init__(self, name, help):
-            sup = super(_SubParsersAction._ChoicesPseudoAction, self)
-            sup.__init__(option_strings=[], dest=name, help=help)
-
-    def __init__(self,
-                 option_strings,
-                 prog,
-                 parser_class,
-                 dest=SUPPRESS,
-                 help=None,
-                 metavar=None):
-
-        self._prog_prefix = prog
-        self._parser_class = parser_class
-        self._name_parser_map = {}
-        self._choices_actions = []
-
-        super(_SubParsersAction, self).__init__(
-            option_strings=option_strings,
-            dest=dest,
-            nargs=PARSER,
-            choices=self._name_parser_map,
-            help=help,
-            metavar=metavar)
-
-    def add_parser(self, name, **kwargs):
-        # set prog from the existing prefix
-        if kwargs.get('prog') is None:
-            kwargs['prog'] = '%s %s' % (self._prog_prefix, name)
-
-        # create a pseudo-action to hold the choice help
-        if 'help' in kwargs:
-            help = kwargs.pop('help')
-            choice_action = self._ChoicesPseudoAction(name, help)
-            self._choices_actions.append(choice_action)
-
-        # create the parser and add it to the map
-        parser = self._parser_class(**kwargs)
-        self._name_parser_map[name] = parser
-        return parser
-
-    def _get_subactions(self):
-        return self._choices_actions
-
-    def __call__(self, parser, namespace, values, option_string=None):
-        parser_name = values[0]
-        arg_strings = values[1:]
-
-        # set the parser name if requested
-        if self.dest is not SUPPRESS:
-            setattr(namespace, self.dest, parser_name)
-
-        # select the parser
-        try:
-            parser = self._name_parser_map[parser_name]
-        except KeyError:
-            tup = parser_name, ', '.join(self._name_parser_map)
-            msg = _('unknown parser %r (choices: %s)' % tup)
-            raise ArgumentError(self, msg)
-
-        # parse all the remaining options into the namespace
-        parser.parse_args(arg_strings, namespace)
-
-
-# ==============
-# Type classes
-# ==============
-
-class FileType(object):
-    """Factory for creating file object types
-
-    Instances of FileType are typically passed as type= arguments to the
-    ArgumentParser add_argument() method.
-
-    Keyword Arguments:
-        - mode -- A string indicating how the file is to be opened. Accepts the
-            same values as the builtin open() function.
-        - bufsize -- The file's desired buffer size. Accepts the same values as
-            the builtin open() function.
-    """
-
-    def __init__(self, mode='r', bufsize=None):
-        self._mode = mode
-        self._bufsize = bufsize
-
-    def __call__(self, string):
-        # the special argument "-" means sys.std{in,out}
-        if string == '-':
-            if 'r' in self._mode:
-                return _sys.stdin
-            elif 'w' in self._mode:
-                return _sys.stdout
-            else:
-                msg = _('argument "-" with mode %r' % self._mode)
-                raise ValueError(msg)
-
-        # all other arguments are used as file names
-        if self._bufsize:
-            return open(string, self._mode, self._bufsize)
-        else:
-            return open(string, self._mode)
-
-    def __repr__(self):
-        args = [self._mode, self._bufsize]
-        args_str = ', '.join([repr(arg) for arg in args if arg is not None])
-        return '%s(%s)' % (type(self).__name__, args_str)
-
-# ===========================
-# Optional and Positional Parsing
-# ===========================
-
-class Namespace(_AttributeHolder):
-    """Simple object for storing attributes.
-
-    Implements equality by attribute names and values, and provides a simple
-    string representation.
-    """
-
-    def __init__(self, **kwargs):
-        for name in kwargs:
-            setattr(self, name, kwargs[name])
-
-    def __eq__(self, other):
-        return vars(self) == vars(other)
-
-    def __ne__(self, other):
-        return not (self == other)
-
-    def __contains__(self, key):
-        return key in self.__dict__
-
-
-class _ActionsContainer(object):
-
-    def __init__(self,
-                 description,
-                 prefix_chars,
-                 argument_default,
-                 conflict_handler):
-        super(_ActionsContainer, self).__init__()
-
-        self.description = description
-        self.argument_default = argument_default
-        self.prefix_chars = prefix_chars
-        self.conflict_handler = conflict_handler
-
-        # set up registries
-        self._registries = {}
-
-        # register actions
-        self.register('action', None, _StoreAction)
-        self.register('action', 'store', _StoreAction)
-        self.register('action', 'store_const', _StoreConstAction)
-        self.register('action', 'store_true', _StoreTrueAction)
-        self.register('action', 'store_false', _StoreFalseAction)
-        self.register('action', 'append', _AppendAction)
-        self.register('action', 'append_const', _AppendConstAction)
-        self.register('action', 'count', _CountAction)
-        self.register('action', 'help', _HelpAction)
-        self.register('action', 'version', _VersionAction)
-        self.register('action', 'parsers', _SubParsersAction)
-
-        # raise an exception if the conflict handler is invalid
-        self._get_handler()
-
-        # action storage
-        self._actions = []
-        self._option_string_actions = {}
-
-        # groups
-        self._action_groups = []
-        self._mutually_exclusive_groups = []
-
-        # defaults storage
-        self._defaults = {}
-
-        # determines whether an "option" looks like a negative number
-        self._negative_number_matcher = _re.compile(r'^-\d+$|^-\d*\.\d+$')
-
-        # whether or not there are any optionals that look like negative
-        # numbers -- uses a list so it can be shared and edited
-        self._has_negative_number_optionals = []
-
-    # ====================
-    # Registration methods
-    # ====================
-    def register(self, registry_name, value, object):
-        registry = self._registries.setdefault(registry_name, {})
-        registry[value] = object
-
-    def _registry_get(self, registry_name, value, default=None):
-        return self._registries[registry_name].get(value, default)
-
-    # ==================================
-    # Namespace default accessor methods
-    # ==================================
-    def set_defaults(self, **kwargs):
-        self._defaults.update(kwargs)
-
-        # if these defaults match any existing arguments, replace
-        # the previous default on the object with the new one
-        for action in self._actions:
-            if action.dest in kwargs:
-                action.default = kwargs[action.dest]
-
-    def get_default(self, dest):
-        for action in self._actions:
-            if action.dest == dest and action.default is not None:
-                return action.default
-        return self._defaults.get(dest, None)
-
-
-    # =======================
-    # Adding argument actions
-    # =======================
-    def add_argument(self, *args, **kwargs):
-        """
-        add_argument(dest, ..., name=value, ...)
-        add_argument(option_string, option_string, ..., name=value, ...)
-        """
-
-        # if no positional args are supplied or only one is supplied and
-        # it doesn't look like an option string, parse a positional
-        # argument
-        chars = self.prefix_chars
-        if not args or len(args) == 1 and args[0][0] not in chars:
-            if args and 'dest' in kwargs:
-                raise ValueError('dest supplied twice for positional argument')
-            kwargs = self._get_positional_kwargs(*args, **kwargs)
-
-        # otherwise, we're adding an optional argument
-        else:
-            kwargs = self._get_optional_kwargs(*args, **kwargs)
-
-        # if no default was supplied, use the parser-level default
-        if 'default' not in kwargs:
-            dest = kwargs['dest']
-            if dest in self._defaults:
-                kwargs['default'] = self._defaults[dest]
-            elif self.argument_default is not None:
-                kwargs['default'] = self.argument_default
-
-        # create the action object, and add it to the parser
-        action_class = self._pop_action_class(kwargs)
-        if not _callable(action_class):
-            raise ValueError('unknown action "%s"' % action_class)
-        action = action_class(**kwargs)
-
-        # raise an error if the action type is not callable
-        type_func = self._registry_get('type', action.type, action.type)
-        if not _callable(type_func):
-            raise ValueError('%r is not callable' % type_func)
-
-        return self._add_action(action)
-
-    def add_argument_group(self, *args, **kwargs):
-        group = _ArgumentGroup(self, *args, **kwargs)
-        self._action_groups.append(group)
-        return group
-
-    def add_mutually_exclusive_group(self, **kwargs):
-        group = _MutuallyExclusiveGroup(self, **kwargs)
-        self._mutually_exclusive_groups.append(group)
-        return group
-
-    def _add_action(self, action):
-        # resolve any conflicts
-        self._check_conflict(action)
-
-        # add to actions list
-        self._actions.append(action)
-        action.container = self
-
-        # index the action by any option strings it has
-        for option_string in action.option_strings:
-            self._option_string_actions[option_string] = action
-
-        # set the flag if any option strings look like negative numbers
-        for option_string in action.option_strings:
-            if self._negative_number_matcher.match(option_string):
-                if not self._has_negative_number_optionals:
-                    self._has_negative_number_optionals.append(True)
-
-        # return the created action
-        return action
-
-    def _remove_action(self, action):
-        self._actions.remove(action)
-
-    def _add_container_actions(self, container):
-        # collect groups by titles
-        title_group_map = {}
-        for group in self._action_groups:
-            if group.title in title_group_map:
-                msg = _('cannot merge actions - two groups are named %r')
-                raise ValueError(msg % (group.title))
-            title_group_map[group.title] = group
-
-        # map each action to its group
-        group_map = {}
-        for group in container._action_groups:
-
-            # if a group with the title exists, use that, otherwise
-            # create a new group matching the container's group
-            if group.title not in title_group_map:
-                title_group_map[group.title] = self.add_argument_group(
-                    title=group.title,
-                    description=group.description,
-                    conflict_handler=group.conflict_handler)
-
-            # map the actions to their new group
-            for action in group._group_actions:
-                group_map[action] = title_group_map[group.title]
-
-        # add container's mutually exclusive groups
-        # NOTE: if add_mutually_exclusive_group ever gains title= and
-        # description= then this code will need to be expanded as above
-        for group in container._mutually_exclusive_groups:
-            mutex_group = self.add_mutually_exclusive_group(
-                required=group.required)
-
-            # map the actions to their new mutex group
-            for action in group._group_actions:
-                group_map[action] = mutex_group
-
-        # add all actions to this container or their group
-        for action in container._actions:
-            group_map.get(action, self)._add_action(action)
-
-    def _get_positional_kwargs(self, dest, **kwargs):
-        # make sure required is not specified
-        if 'required' in kwargs:
-            msg = _("'required' is an invalid argument for positionals")
-            raise TypeError(msg)
-
-        # mark positional arguments as required if at least one is
-        # always required
-        if kwargs.get('nargs') not in [OPTIONAL, ZERO_OR_MORE]:
-            kwargs['required'] = True
-        if kwargs.get('nargs') == ZERO_OR_MORE and 'default' not in kwargs:
-            kwargs['required'] = True
-
-        # return the keyword arguments with no option strings
-        return dict(kwargs, dest=dest, option_strings=[])
-
-    def _get_optional_kwargs(self, *args, **kwargs):
-        # determine short and long option strings
-        option_strings = []
-        long_option_strings = []
-        for option_string in args:
-            # error on strings that don't start with an appropriate prefix
-            if not option_string[0] in self.prefix_chars:
-                msg = _('invalid option string %r: '
-                        'must start with a character %r')
-                tup = option_string, self.prefix_chars
-                raise ValueError(msg % tup)
-
-            # strings starting with two prefix characters are long options
-            option_strings.append(option_string)
-            if option_string[0] in self.prefix_chars:
-                if len(option_string) > 1:
-                    if option_string[1] in self.prefix_chars:
-                        long_option_strings.append(option_string)
-
-        # infer destination, '--foo-bar' -> 'foo_bar' and '-x' -> 'x'
-        dest = kwargs.pop('dest', None)
-        if dest is None:
-            if long_option_strings:
-                dest_option_string = long_option_strings[0]
-            else:
-                dest_option_string = option_strings[0]
-            dest = dest_option_string.lstrip(self.prefix_chars)
-            if not dest:
-                msg = _('dest= is required for options like %r')
-                raise ValueError(msg % option_string)
-            dest = dest.replace('-', '_')
-
-        # return the updated keyword arguments
-        return dict(kwargs, dest=dest, option_strings=option_strings)
-
-    def _pop_action_class(self, kwargs, default=None):
-        action = kwargs.pop('action', default)
-        return self._registry_get('action', action, action)
-
-    def _get_handler(self):
-        # determine function from conflict handler string
-        handler_func_name = '_handle_conflict_%s' % self.conflict_handler
-        try:
-            return getattr(self, handler_func_name)
-        except AttributeError:
-            msg = _('invalid conflict_resolution value: %r')
-            raise ValueError(msg % self.conflict_handler)
-
-    def _check_conflict(self, action):
-
-        # find all options that conflict with this option
-        confl_optionals = []
-        for option_string in action.option_strings:
-            if option_string in self._option_string_actions:
-                confl_optional = self._option_string_actions[option_string]
-                confl_optionals.append((option_string, confl_optional))
-
-        # resolve any conflicts
-        if confl_optionals:
-            conflict_handler = self._get_handler()
-            conflict_handler(action, confl_optionals)
-
-    def _handle_conflict_error(self, action, conflicting_actions):
-        message = _('conflicting option string(s): %s')
-        conflict_string = ', '.join([option_string
-                                     for option_string, action
-                                     in conflicting_actions])
-        raise ArgumentError(action, message % conflict_string)
-
-    def _handle_conflict_resolve(self, action, conflicting_actions):
-
-        # remove all conflicting options
-        for option_string, action in conflicting_actions:
-
-            # remove the conflicting option
-            action.option_strings.remove(option_string)
-            self._option_string_actions.pop(option_string, None)
-
-            # if the option now has no option string, remove it from the
-            # container holding it
-            if not action.option_strings:
-                action.container._remove_action(action)
-
-
-class _ArgumentGroup(_ActionsContainer):
-
-    def __init__(self, container, title=None, description=None, **kwargs):
-        # add any missing keyword arguments by checking the container
-        update = kwargs.setdefault
-        update('conflict_handler', container.conflict_handler)
-        update('prefix_chars', container.prefix_chars)
-        update('argument_default', container.argument_default)
-        super_init = super(_ArgumentGroup, self).__init__
-        super_init(description=description, **kwargs)
-
-        # group attributes
-        self.title = title
-        self._group_actions = []
-
-        # share most attributes with the container
-        self._registries = container._registries
-        self._actions = container._actions
-        self._option_string_actions = container._option_string_actions
-        self._defaults = container._defaults
-        self._has_negative_number_optionals = \
-            container._has_negative_number_optionals
-
-    def _add_action(self, action):
-        action = super(_ArgumentGroup, self)._add_action(action)
-        self._group_actions.append(action)
-        return action
-
-    def _remove_action(self, action):
-        super(_ArgumentGroup, self)._remove_action(action)
-        self._group_actions.remove(action)
-
-
-class _MutuallyExclusiveGroup(_ArgumentGroup):
-
-    def __init__(self, container, required=False):
-        super(_MutuallyExclusiveGroup, self).__init__(container)
-        self.required = required
-        self._container = container
-
-    def _add_action(self, action):
-        if action.required:
-            msg = _('mutually exclusive arguments must be optional')
-            raise ValueError(msg)
-        action = self._container._add_action(action)
-        self._group_actions.append(action)
-        return action
-
-    def _remove_action(self, action):
-        self._container._remove_action(action)
-        self._group_actions.remove(action)
-
-
-class ArgumentParser(_AttributeHolder, _ActionsContainer):
-    """Object for parsing command line strings into Python objects.
-
-    Keyword Arguments:
-        - prog -- The name of the program (default: sys.argv[0])
-        - usage -- A usage message (default: auto-generated from arguments)
-        - description -- A description of what the program does
-        - epilog -- Text following the argument descriptions
-        - parents -- Parsers whose arguments should be copied into this one
-        - formatter_class -- HelpFormatter class for printing help messages
-        - prefix_chars -- Characters that prefix optional arguments
-        - fromfile_prefix_chars -- Characters that prefix files containing
-            additional arguments
-        - argument_default -- The default value for all arguments
-        - conflict_handler -- String indicating how to handle conflicts
-        - add_help -- Add a -h/-help option
-    """
-
-    def __init__(self,
-                 prog=None,
-                 usage=None,
-                 description=None,
-                 epilog=None,
-                 version=None,
-                 parents=[],
-                 formatter_class=HelpFormatter,
-                 prefix_chars='-',
-                 fromfile_prefix_chars=None,
-                 argument_default=None,
-                 conflict_handler='error',
-                 add_help=True):
-
-        if version is not None:
-            import warnings
-            warnings.warn(
-                """The "version" argument to ArgumentParser is deprecated. """
-                """Please use """
-                """"add_argument(..., action='version', version="N", ...)" """
-                """instead""", DeprecationWarning)
-
-        superinit = super(ArgumentParser, self).__init__
-        superinit(description=description,
-                  prefix_chars=prefix_chars,
-                  argument_default=argument_default,
-                  conflict_handler=conflict_handler)
-
-        # default setting for prog
-        if prog is None:
-            prog = _os.path.basename(_sys.argv[0])
-
-        self.prog = prog
-        self.usage = usage
-        self.epilog = epilog
-        self.version = version
-        self.formatter_class = formatter_class
-        self.fromfile_prefix_chars = fromfile_prefix_chars
-        self.add_help = add_help
-
-        add_group = self.add_argument_group
-        self._positionals = add_group(_('positional arguments'))
-        self._optionals = add_group(_('optional arguments'))
-        self._subparsers = None
-
-        # register types
-        def identity(string):
-            return string
-        self.register('type', None, identity)
-
-        # add help and version arguments if necessary
-        # (using explicit default to override global argument_default)
-        if self.add_help:
-            self.add_argument(
-                '-h', '--help', action='help', default=SUPPRESS,
-                help=_('show this help message and exit'))
-        if self.version:
-            self.add_argument(
-                '-v', '--version', action='version', default=SUPPRESS,
-                version=self.version,
-                help=_("show program's version number and exit"))
-
-        # add parent arguments and defaults
-        for parent in parents:
-            self._add_container_actions(parent)
-            try:
-                defaults = parent._defaults
-            except AttributeError:
-                pass
-            else:
-                self._defaults.update(defaults)
-
-    # =======================
-    # Pretty __repr__ methods
-    # =======================
-    def _get_kwargs(self):
-        names = [
-            'prog',
-            'usage',
-            'description',
-            'version',
-            'formatter_class',
-            'conflict_handler',
-            'add_help',
-        ]
-        return [(name, getattr(self, name)) for name in names]
-
-    # ==================================
-    # Optional/Positional adding methods
-    # ==================================
-    def add_subparsers(self, **kwargs):
-        if self._subparsers is not None:
-            self.error(_('cannot have multiple subparser arguments'))
-
-        # add the parser class to the arguments if it's not present
-        kwargs.setdefault('parser_class', type(self))
-
-        if 'title' in kwargs or 'description' in kwargs:
-            title = _(kwargs.pop('title', 'subcommands'))
-            description = _(kwargs.pop('description', None))
-            self._subparsers = self.add_argument_group(title, description)
-        else:
-            self._subparsers = self._positionals
-
-        # prog defaults to the usage message of this parser, skipping
-        # optional arguments and with no "usage:" prefix
-        if kwargs.get('prog') is None:
-            formatter = self._get_formatter()
-            positionals = self._get_positional_actions()
-            groups = self._mutually_exclusive_groups
-            formatter.add_usage(self.usage, positionals, groups, '')
-            kwargs['prog'] = formatter.format_help().strip()
-
-        # create the parsers action and add it to the positionals list
-        parsers_class = self._pop_action_class(kwargs, 'parsers')
-        action = parsers_class(option_strings=[], **kwargs)
-        self._subparsers._add_action(action)
-
-        # return the created parsers action
-        return action
-
-    def _add_action(self, action):
-        if action.option_strings:
-            self._optionals._add_action(action)
-        else:
-            self._positionals._add_action(action)
-        return action
-
-    def _get_optional_actions(self):
-        return [action
-                for action in self._actions
-                if action.option_strings]
-
-    def _get_positional_actions(self):
-        return [action
-                for action in self._actions
-                if not action.option_strings]
-
-    # =====================================
-    # Command line argument parsing methods
-    # =====================================
-    def parse_args(self, args=None, namespace=None):
-        args, argv = self.parse_known_args(args, namespace)
-        if argv:
-            msg = _('unrecognized arguments: %s')
-            self.error(msg % ' '.join(argv))
-        return args
-
-    def parse_known_args(self, args=None, namespace=None):
-        # args default to the system args
-        if args is None:
-            args = _sys.argv[1:]
-
-        # default Namespace built from parser defaults
-        if namespace is None:
-            namespace = Namespace()
-
-        # add any action defaults that aren't present
-        for action in self._actions:
-            if action.dest is not SUPPRESS:
-                if not hasattr(namespace, action.dest):
-                    if action.default is not SUPPRESS:
-                        default = action.default
-                        if isinstance(action.default, _basestring):
-                            default = self._get_value(action, default)
-                        setattr(namespace, action.dest, default)
-
-        # add any parser defaults that aren't present
-        for dest in self._defaults:
-            if not hasattr(namespace, dest):
-                setattr(namespace, dest, self._defaults[dest])
-
-        # parse the arguments and exit if there are any errors
-        try:
-            return self._parse_known_args(args, namespace)
-        except ArgumentError:
-            err = _sys.exc_info()[1]
-            self.error(str(err))
-
-    def _parse_known_args(self, arg_strings, namespace):
-        # replace arg strings that are file references
-        if self.fromfile_prefix_chars is not None:
-            arg_strings = self._read_args_from_files(arg_strings)
-
-        # map all mutually exclusive arguments to the other arguments
-        # they can't occur with
-        action_conflicts = {}
-        for mutex_group in self._mutually_exclusive_groups:
-            group_actions = mutex_group._group_actions
-            for i, mutex_action in enumerate(mutex_group._group_actions):
-                conflicts = action_conflicts.setdefault(mutex_action, [])
-                conflicts.extend(group_actions[:i])
-                conflicts.extend(group_actions[i + 1:])
-
-        # find all option indices, and determine the arg_string_pattern
-        # which has an 'O' if there is an option at an index,
-        # an 'A' if there is an argument, or a '-' if there is a '--'
-        option_string_indices = {}
-        arg_string_pattern_parts = []
-        arg_strings_iter = iter(arg_strings)
-        for i, arg_string in enumerate(arg_strings_iter):
-
-            # all args after -- are non-options
-            if arg_string == '--':
-                arg_string_pattern_parts.append('-')
-                for arg_string in arg_strings_iter:
-                    arg_string_pattern_parts.append('A')
-
-            # otherwise, add the arg to the arg strings
-            # and note the index if it was an option
-            else:
-                option_tuple = self._parse_optional(arg_string)
-                if option_tuple is None:
-                    pattern = 'A'
-                else:
-                    option_string_indices[i] = option_tuple
-                    pattern = 'O'
-                arg_string_pattern_parts.append(pattern)
-
-        # join the pieces together to form the pattern
-        arg_strings_pattern = ''.join(arg_string_pattern_parts)
-
-        # converts arg strings to the appropriate and then takes the action
-        seen_actions = _set()
-        seen_non_default_actions = _set()
-
-        def take_action(action, argument_strings, option_string=None):
-            seen_actions.add(action)
-            argument_values = self._get_values(action, argument_strings)
-
-            # error if this argument is not allowed with other previously
-            # seen arguments, assuming that actions that use the default
-            # value don't really count as "present"
-            if argument_values is not action.default:
-                seen_non_default_actions.add(action)
-                for conflict_action in action_conflicts.get(action, []):
-                    if conflict_action in seen_non_default_actions:
-                        msg = _('not allowed with argument %s')
-                        action_name = _get_action_name(conflict_action)
-                        raise ArgumentError(action, msg % action_name)
-
-            # take the action if we didn't receive a SUPPRESS value
-            # (e.g. from a default)
-            if argument_values is not SUPPRESS:
-                action(self, namespace, argument_values, option_string)
-
-        # function to convert arg_strings into an optional action
-        def consume_optional(start_index):
-
-            # get the optional identified at this index
-            option_tuple = option_string_indices[start_index]
-            action, option_string, explicit_arg = option_tuple
-
-            # identify additional optionals in the same arg string
-            # (e.g. -xyz is the same as -x -y -z if no args are required)
-            match_argument = self._match_argument
-            action_tuples = []
-            while True:
-
-                # if we found no optional action, skip it
-                if action is None:
-                    extras.append(arg_strings[start_index])
-                    return start_index + 1
-
-                # if there is an explicit argument, try to match the
-                # optional's string arguments to only this
-                if explicit_arg is not None:
-                    arg_count = match_argument(action, 'A')
-
-                    # if the action is a single-dash option and takes no
-                    # arguments, try to parse more single-dash options out
-                    # of the tail of the option string
-                    chars = self.prefix_chars
-                    if arg_count == 0 and option_string[1] not in chars:
-                        action_tuples.append((action, [], option_string))
-                        for char in self.prefix_chars:
-                            option_string = char + explicit_arg[0]
-                            explicit_arg = explicit_arg[1:] or None
-                            optionals_map = self._option_string_actions
-                            if option_string in optionals_map:
-                                action = optionals_map[option_string]
-                                break
-                        else:
-                            msg = _('ignored explicit argument %r')
-                            raise ArgumentError(action, msg % explicit_arg)
-
-                    # if the action expect exactly one argument, we've
-                    # successfully matched the option; exit the loop
-                    elif arg_count == 1:
-                        stop = start_index + 1
-                        args = [explicit_arg]
-                        action_tuples.append((action, args, option_string))
-                        break
-
-                    # error if a double-dash option did not use the
-                    # explicit argument
-                    else:
-                        msg = _('ignored explicit argument %r')
-                        raise ArgumentError(action, msg % explicit_arg)
-
-                # if there is no explicit argument, try to match the
-                # optional's string arguments with the following strings
-                # if successful, exit the loop
-                else:
-                    start = start_index + 1
-                    selected_patterns = arg_strings_pattern[start:]
-                    arg_count = match_argument(action, selected_patterns)
-                    stop = start + arg_count
-                    args = arg_strings[start:stop]
-                    action_tuples.append((action, args, option_string))
-                    break
-
-            # add the Optional to the list and return the index at which
-            # the Optional's string args stopped
-            assert action_tuples
-            for action, args, option_string in action_tuples:
-                take_action(action, args, option_string)
-            return stop
-
-        # the list of Positionals left to be parsed; this is modified
-        # by consume_positionals()
-        positionals = self._get_positional_actions()
-
-        # function to convert arg_strings into positional actions
-        def consume_positionals(start_index):
-            # match as many Positionals as possible
-            match_partial = self._match_arguments_partial
-            selected_pattern = arg_strings_pattern[start_index:]
-            arg_counts = match_partial(positionals, selected_pattern)
-
-            # slice off the appropriate arg strings for each Positional
-            # and add the Positional and its args to the list
-            for action, arg_count in zip(positionals, arg_counts):
-                args = arg_strings[start_index: start_index + arg_count]
-                start_index += arg_count
-                take_action(action, args)
-
-            # slice off the Positionals that we just parsed and return the
-            # index at which the Positionals' string args stopped
-            positionals[:] = positionals[len(arg_counts):]
-            return start_index
-
-        # consume Positionals and Optionals alternately, until we have
-        # passed the last option string
-        extras = []
-        start_index = 0
-        if option_string_indices:
-            max_option_string_index = max(option_string_indices)
-        else:
-            max_option_string_index = -1
-        while start_index <= max_option_string_index:
-
-            # consume any Positionals preceding the next option
-            next_option_string_index = min([
-                index
-                for index in option_string_indices
-                if index >= start_index])
-            if start_index != next_option_string_index:
-                positionals_end_index = consume_positionals(start_index)
-
-                # only try to parse the next optional if we didn't consume
-                # the option string during the positionals parsing
-                if positionals_end_index > start_index:
-                    start_index = positionals_end_index
-                    continue
-                else:
-                    start_index = positionals_end_index
-
-            # if we consumed all the positionals we could and we're not
-            # at the index of an option string, there were extra arguments
-            if start_index not in option_string_indices:
-                strings = arg_strings[start_index:next_option_string_index]
-                extras.extend(strings)
-                start_index = next_option_string_index
-
-            # consume the next optional and any arguments for it
-            start_index = consume_optional(start_index)
-
-        # consume any positionals following the last Optional
-        stop_index = consume_positionals(start_index)
-
-        # if we didn't consume all the argument strings, there were extras
-        extras.extend(arg_strings[stop_index:])
-
-        # if we didn't use all the Positional objects, there were too few
-        # arg strings supplied.
-        if positionals:
-            self.error(_('too few arguments'))
-
-        # make sure all required actions were present
-        for action in self._actions:
-            if action.required:
-                if action not in seen_actions:
-                    name = _get_action_name(action)
-                    self.error(_('argument %s is required') % name)
-
-        # make sure all required groups had one option present
-        for group in self._mutually_exclusive_groups:
-            if group.required:
-                for action in group._group_actions:
-                    if action in seen_non_default_actions:
-                        break
-
-                # if no actions were used, report the error
-                else:
-                    names = [_get_action_name(action)
-                             for action in group._group_actions
-                             if action.help is not SUPPRESS]
-                    msg = _('one of the arguments %s is required')
-                    self.error(msg % ' '.join(names))
-
-        # return the updated namespace and the extra arguments
-        return namespace, extras
-
-    def _read_args_from_files(self, arg_strings):
-        # expand arguments referencing files
-        new_arg_strings = []
-        for arg_string in arg_strings:
-
-            # for regular arguments, just add them back into the list
-            if arg_string[0] not in self.fromfile_prefix_chars:
-                new_arg_strings.append(arg_string)
-
-            # replace arguments referencing files with the file content
-            else:
-                try:
-                    args_file = open(arg_string[1:])
-                    try:
-                        arg_strings = []
-                        for arg_line in args_file.read().splitlines():
-                            for arg in self.convert_arg_line_to_args(arg_line):
-                                arg_strings.append(arg)
-                        arg_strings = self._read_args_from_files(arg_strings)
-                        new_arg_strings.extend(arg_strings)
-                    finally:
-                        args_file.close()
-                except IOError:
-                    err = _sys.exc_info()[1]
-                    self.error(str(err))
-
-        # return the modified argument list
-        return new_arg_strings
-
-    def convert_arg_line_to_args(self, arg_line):
-        return [arg_line]
-
-    def _match_argument(self, action, arg_strings_pattern):
-        # match the pattern for this action to the arg strings
-        nargs_pattern = self._get_nargs_pattern(action)
-        match = _re.match(nargs_pattern, arg_strings_pattern)
-
-        # raise an exception if we weren't able to find a match
-        if match is None:
-            nargs_errors = {
-                None: _('expected one argument'),
-                OPTIONAL: _('expected at most one argument'),
-                ONE_OR_MORE: _('expected at least one argument'),
-            }
-            default = _('expected %s argument(s)') % action.nargs
-            msg = nargs_errors.get(action.nargs, default)
-            raise ArgumentError(action, msg)
-
-        # return the number of arguments matched
-        return len(match.group(1))
-
-    def _match_arguments_partial(self, actions, arg_strings_pattern):
-        # progressively shorten the actions list by slicing off the
-        # final actions until we find a match
-        result = []
-        for i in range(len(actions), 0, -1):
-            actions_slice = actions[:i]
-            pattern = ''.join([self._get_nargs_pattern(action)
-                               for action in actions_slice])
-            match = _re.match(pattern, arg_strings_pattern)
-            if match is not None:
-                result.extend([len(string) for string in match.groups()])
-                break
-
-        # return the list of arg string counts
-        return result
-
-    def _parse_optional(self, arg_string):
-        # if it's an empty string, it was meant to be a positional
-        if not arg_string:
-            return None
-
-        # if it doesn't start with a prefix, it was meant to be positional
-        if not arg_string[0] in self.prefix_chars:
-            return None
-
-        # if the option string is present in the parser, return the action
-        if arg_string in self._option_string_actions:
-            action = self._option_string_actions[arg_string]
-            return action, arg_string, None
-
-        # if it's just a single character, it was meant to be positional
-        if len(arg_string) == 1:
-            return None
-
-        # if the option string before the "=" is present, return the action
-        if '=' in arg_string:
-            option_string, explicit_arg = arg_string.split('=', 1)
-            if option_string in self._option_string_actions:
-                action = self._option_string_actions[option_string]
-                return action, option_string, explicit_arg
-
-        # search through all possible prefixes of the option string
-        # and all actions in the parser for possible interpretations
-        option_tuples = self._get_option_tuples(arg_string)
-
-        # if multiple actions match, the option string was ambiguous
-        if len(option_tuples) > 1:
-            options = ', '.join([option_string
-                for action, option_string, explicit_arg in option_tuples])
-            tup = arg_string, options
-            self.error(_('ambiguous option: %s could match %s') % tup)
-
-        # if exactly one action matched, this segmentation is good,
-        # so return the parsed action
-        elif len(option_tuples) == 1:
-            option_tuple, = option_tuples
-            return option_tuple
-
-        # if it was not found as an option, but it looks like a negative
-        # number, it was meant to be positional
-        # unless there are negative-number-like options
-        if self._negative_number_matcher.match(arg_string):
-            if not self._has_negative_number_optionals:
-                return None
-
-        # if it contains a space, it was meant to be a positional
-        if ' ' in arg_string:
-            return None
-
-        # it was meant to be an optional but there is no such option
-        # in this parser (though it might be a valid option in a subparser)
-        return None, arg_string, None
-
-    def _get_option_tuples(self, option_string):
-        result = []
-
-        # option strings starting with two prefix characters are only
-        # split at the '='
-        chars = self.prefix_chars
-        if option_string[0] in chars and option_string[1] in chars:
-            if '=' in option_string:
-                option_prefix, explicit_arg = option_string.split('=', 1)
-            else:
-                option_prefix = option_string
-                explicit_arg = None
-            for option_string in self._option_string_actions:
-                if option_string.startswith(option_prefix):
-                    action = self._option_string_actions[option_string]
-                    tup = action, option_string, explicit_arg
-                    result.append(tup)
-
-        # single character options can be concatenated with their arguments
-        # but multiple character options always have to have their argument
-        # separate
-        elif option_string[0] in chars and option_string[1] not in chars:
-            option_prefix = option_string
-            explicit_arg = None
-            short_option_prefix = option_string[:2]
-            short_explicit_arg = option_string[2:]
-
-            for option_string in self._option_string_actions:
-                if option_string == short_option_prefix:
-                    action = self._option_string_actions[option_string]
-                    tup = action, option_string, short_explicit_arg
-                    result.append(tup)
-                elif option_string.startswith(option_prefix):
-                    action = self._option_string_actions[option_string]
-                    tup = action, option_string, explicit_arg
-                    result.append(tup)
-
-        # shouldn't ever get here
-        else:
-            self.error(_('unexpected option string: %s') % option_string)
-
-        # return the collected option tuples
-        return result
-
-    def _get_nargs_pattern(self, action):
-        # in all examples below, we have to allow for '--' args
-        # which are represented as '-' in the pattern
-        nargs = action.nargs
-
-        # the default (None) is assumed to be a single argument
-        if nargs is None:
-            nargs_pattern = '(-*A-*)'
-
-        # allow zero or one arguments
-        elif nargs == OPTIONAL:
-            nargs_pattern = '(-*A?-*)'
-
-        # allow zero or more arguments
-        elif nargs == ZERO_OR_MORE:
-            nargs_pattern = '(-*[A-]*)'
-
-        # allow one or more arguments
-        elif nargs == ONE_OR_MORE:
-            nargs_pattern = '(-*A[A-]*)'
-
-        # allow any number of options or arguments
-        elif nargs == REMAINDER:
-            nargs_pattern = '([-AO]*)'
-
-        # allow one argument followed by any number of options or arguments
-        elif nargs == PARSER:
-            nargs_pattern = '(-*A[-AO]*)'
-
-        # all others should be integers
-        else:
-            nargs_pattern = '(-*%s-*)' % '-*'.join('A' * nargs)
-
-        # if this is an optional action, -- is not allowed
-        if action.option_strings:
-            nargs_pattern = nargs_pattern.replace('-*', '')
-            nargs_pattern = nargs_pattern.replace('-', '')
-
-        # return the pattern
-        return nargs_pattern
-
-    # ========================
-    # Value conversion methods
-    # ========================
-    def _get_values(self, action, arg_strings):
-        # for everything but PARSER args, strip out '--'
-        if action.nargs not in [PARSER, REMAINDER]:
-            arg_strings = [s for s in arg_strings if s != '--']
-
-        # optional argument produces a default when not present
-        if not arg_strings and action.nargs == OPTIONAL:
-            if action.option_strings:
-                value = action.const
-            else:
-                value = action.default
-            if isinstance(value, _basestring):
-                value = self._get_value(action, value)
-                self._check_value(action, value)
-
-        # when nargs='*' on a positional, if there were no command-line
-        # args, use the default if it is anything other than None
-        elif (not arg_strings and action.nargs == ZERO_OR_MORE and
-              not action.option_strings):
-            if action.default is not None:
-                value = action.default
-            else:
-                value = arg_strings
-            self._check_value(action, value)
-
-        # single argument or optional argument produces a single value
-        elif len(arg_strings) == 1 and action.nargs in [None, OPTIONAL]:
-            arg_string, = arg_strings
-            value = self._get_value(action, arg_string)
-            self._check_value(action, value)
-
-        # REMAINDER arguments convert all values, checking none
-        elif action.nargs == REMAINDER:
-            value = [self._get_value(action, v) for v in arg_strings]
-
-        # PARSER arguments convert all values, but check only the first
-        elif action.nargs == PARSER:
-            value = [self._get_value(action, v) for v in arg_strings]
-            self._check_value(action, value[0])
-
-        # all other types of nargs produce a list
-        else:
-            value = [self._get_value(action, v) for v in arg_strings]
-            for v in value:
-                self._check_value(action, v)
-
-        # return the converted value
-        return value
-
-    def _get_value(self, action, arg_string):
-        type_func = self._registry_get('type', action.type, action.type)
-        if not _callable(type_func):
-            msg = _('%r is not callable')
-            raise ArgumentError(action, msg % type_func)
-
-        # convert the value to the appropriate type
-        try:
-            result = type_func(arg_string)
-
-        # ArgumentTypeErrors indicate errors
-        except ArgumentTypeError:
-            name = getattr(action.type, '__name__', repr(action.type))
-            msg = str(_sys.exc_info()[1])
-            raise ArgumentError(action, msg)
-
-        # TypeErrors or ValueErrors also indicate errors
-        except (TypeError, ValueError):
-            name = getattr(action.type, '__name__', repr(action.type))
-            msg = _('invalid %s value: %r')
-            raise ArgumentError(action, msg % (name, arg_string))
-
-        # return the converted value
-        return result
-
-    def _check_value(self, action, value):
-        # converted value must be one of the choices (if specified)
-        if action.choices is not None and value not in action.choices:
-            tup = value, ', '.join(map(repr, action.choices))
-            msg = _('invalid choice: %r (choose from %s)') % tup
-            raise ArgumentError(action, msg)
-
-    # =======================
-    # Help-formatting methods
-    # =======================
-    def format_usage(self):
-        formatter = self._get_formatter()
-        formatter.add_usage(self.usage, self._actions,
-                            self._mutually_exclusive_groups)
-        return formatter.format_help()
-
-    def format_help(self):
-        formatter = self._get_formatter()
-
-        # usage
-        formatter.add_usage(self.usage, self._actions,
-                            self._mutually_exclusive_groups)
-
-        # description
-        formatter.add_text(self.description)
-
-        # positionals, optionals and user-defined groups
-        for action_group in self._action_groups:
-            formatter.start_section(action_group.title)
-            formatter.add_text(action_group.description)
-            formatter.add_arguments(action_group._group_actions)
-            formatter.end_section()
-
-        # epilog
-        formatter.add_text(self.epilog)
-
-        # determine help from format above
-        return formatter.format_help()
-
-    def format_version(self):
-        import warnings
-        warnings.warn(
-            'The format_version method is deprecated -- the "version" '
-            'argument to ArgumentParser is no longer supported.',
-            DeprecationWarning)
-        formatter = self._get_formatter()
-        formatter.add_text(self.version)
-        return formatter.format_help()
-
-    def _get_formatter(self):
-        return self.formatter_class(prog=self.prog)
-
-    # =====================
-    # Help-printing methods
-    # =====================
-    def print_usage(self, file=None):
-        if file is None:
-            file = _sys.stdout
-        self._print_message(self.format_usage(), file)
-
-    def print_help(self, file=None):
-        if file is None:
-            file = _sys.stdout
-        self._print_message(self.format_help(), file)
-
-    def print_version(self, file=None):
-        import warnings
-        warnings.warn(
-            'The print_version method is deprecated -- the "version" '
-            'argument to ArgumentParser is no longer supported.',
-            DeprecationWarning)
-        self._print_message(self.format_version(), file)
-
-    def _print_message(self, message, file=None):
-        if message:
-            if file is None:
-                file = _sys.stderr
-            file.write(message)
-
-    # ===============
-    # Exiting methods
-    # ===============
-    def exit(self, status=0, message=None):
-        if message:
-            self._print_message(message, _sys.stderr)
-        _sys.exit(status)
-
-    def error(self, message):
-        """error(message: string)
-
-        Prints a usage message incorporating the message to stderr and
-        exits.
-
-        If you override this in a subclass, it should not return -- it
-        should either exit or raise an exception.
-        """
-        self.print_usage(_sys.stderr)
-        self.exit(2, _('%s: error: %s\n') % (self.prog, message))
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/kvmtools/config/build_command.py	Tue Mar 27 02:52:37 2012 +0200
@@ -0,0 +1,50 @@
+#
+# Module build command.
+#
+
+"""
+(c) 2011 Jens Kasten <jens@kasten-edv.de>
+"""
+
+
+class BuildCommand(object):
+    """Build a command for executing ad a string to show the command."""
+    
+    def __init__(self):
+        self.command = ()
+
+    def build_command(self):
+        """Create a tuple command. 
+        First entry is a list that is executed via subprocess
+        and the second is a string to display the command.
+        """
+        cmd_execute = []
+        cmd_string = ""
+        # Start to build a list
+        # first add the qemu-kvm binary path
+        cmd_execute.append(self.config["qemu-kvm"])
+        # delete the helper parameter from config
+        for key in self.exclude_options:
+            if key in self.config:
+                del self.config[key]
+        # iterate over the config and build a list
+        for key, value in self.config.iteritems():
+            # ignore disabled values
+            if self.is_disabled == value:
+                continue
+            # this check search for more option like -drive -drive etc.
+            elif isinstance(value, dict):
+                for i in value.itervalues():
+                    cmd_execute.append(''.join(['-', key]))
+                    cmd_execute.append(i)
+            elif self.is_enabled != value:
+                # this qemu-kvm option have an option, so add -key value
+                cmd_execute.append(''.join(['-', key]))
+                cmd_execute.append(value)
+            else:
+                # this qemu-kvm option don't have any option 
+                # so only add -key as argument
+                cmd_execute.append(''.join(['-', key]))
+        # build a string for to display on terminal output
+        cmd_string = " ".join([value for value in cmd_execute])
+        self.command = (cmd_execute, cmd_string)
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/kvmtools/config/build_config.py	Tue Mar 27 02:52:37 2012 +0200
@@ -0,0 +1,167 @@
+#
+# Module BuildConfig collect all data to create a command qemu-kvm command.
+# 
+
+"""
+(c) 2011 Jens Kasten <jens@kasten-edv.de>
+"""
+
+import os
+import sys
+import random
+import string
+import re
+
+from kvmtools.config.kvm_parser import Parser
+
+
+class BuildConfig(object):
+    
+    def __init__(self):
+        self.config = {}
+        self.monitor_options = {}
+        self.bridge = {}
+
+    def build_config(self):
+        """Load domain and global config and then merge them."""
+        parser = Parser()
+        self.config = parser.merge_configs(
+            parser.parse_config(self.kvm_config_file),
+            parser.parse_config(self.kvm_domain_file))
+        self._add_name()
+        self._add_uuid()
+        self._add_pidfile()
+        self._add_monitor()
+        self._add_net()
+
+    def _add_pidfile(self):
+        """Add the pidfile to the config dictionary 
+        and if the domain has a pidfile set it for kvm_pidfile attribute.
+        """
+        if "pidfile" not in self.config:
+            self.config["pidfile"] = self.kvm_pidfile 
+        else:
+            self.kvm_pidfile = self.config["pidfile"]
+
+    def _add_uuid(self):
+        """Append an unique uuid to the config dictionary."""
+        if "uuid" in self.config:
+            check_uid = re.match(r"([a-f,A-F,0-9]{8})-([a-f,A-F,0-9]{4})-([a-f,A-F,0-9]{4})-([a-f,A-F,0-9]{4})-([a-f,A-F,0-9]{12})", self.config["uuid"])
+            if not check_uid:
+                print "Your uuid has wrong format: %s" % self.config["uuid"]
+                print "You can delete it, the script does generate a new one."
+                sys.exit(1)
+            return 
+        random.seed(os.urandom(8))
+        charset = string.digits + "abcdef"
+        eight = "".join(random.sample(charset, 8))
+        four_first = "".join(random.sample(charset, 4))
+        four_second = "".join(random.sample(charset, 4))
+        four_third = "".join(random.sample(charset, 4))
+        twelve =  "".join(random.sample(charset, 12))
+        uuid = "-".join([eight, four_first, four_second, four_third, twelve])
+        # insterit the uuid into domain config file if it not exists
+        if os.path.isfile(self.kvm_domain_file) and os.access(self.kvm_domain_file, os.W_OK):
+            try:
+                fd = open(self.kvm_domain_file, "a+")
+                fd.write("\n# autogenerated (uuid)\nuuid = %s" % uuid)
+            except IOError, e:
+                print "Operation failed: %s" % e
+            finally:
+                if fd:
+                    fd.close()
+        self.config["uuid"] = uuid
+
+    def _add_name(self):
+        """Append a name for window title and process name (on linux only)."""
+        if "name" in self.config:
+            name = self.config["name"].split(" ")[0]
+            process_name = "=kvm_".join(["process", name])
+            self.config["name"] = ",".join([name, process_name])
+        else:
+            process_name = "=".join(["process", self.kvm_domain_name])
+            self.config["name"] = ",".join([self.kvm_domain_name, process_name])
+
+    def _add_monitor(self):
+        """Add a dictionry with type and the path to the socket file or
+        the host and port.
+        """
+        if "monitor" in self.config:
+            monitor = self.config["monitor"]
+            # get the string befor the first comma 
+            # and then split this string by colon
+            monitor_type = monitor.split(',')[0].split(':')
+            if len(monitor_type) == 3:
+                # this is usally for tcp
+                self.monitor_options['Type'] = monitor_type[0] 
+                self.monitor_options['Host'] = monitor_type[1]
+                self.monitor_options['Port'] = int(monitor_type[2])
+            elif len(monitor_type) == 2:
+                # this is for telnet, when no port is given
+                self.monitor_options['Type'] = monitor_type[0]
+                if monitor_type[0] == 'unix':
+                    self.monitor_options['SocketFile'] = monitor_type[1]
+                self.monitor_options['Host'] = monitor_type[1]
+                self.monitor_options['Port'] = self.telnet_port
+        else:
+            # set unix socket as default monitor access
+            monitor = "unix:%s,server,nowait" % self.kvm_socketfile
+            self.monitor_options["Type"] = "unix"
+            self.monitor_options['SocketFile'] = self.kvm_socketfile
+        self.config["monitor"] = monitor 
+
+    def _add_net(self):
+        """Examine the -net tap option for ifname and additional scripts and 
+        bridge strings, if not -tap option don't touch the values.
+        """
+        temp = {} 
+        counter = 0
+        if "net" not in self.config:
+            return False
+        for key, value in self.config["net"].iteritems():
+            if value.startswith("tap"):
+                # search for ifname otherwise set it from domain_name name
+                if re.search("ifname", value):
+                    ifname = re.search("ifname=([a-zA-Z0-9]+)", value)
+                    bridge_if = ifname.group(1)
+                else:
+                    ifname = "=".join(["ifname", 
+                        self.kvm_domain_name + str(counter)])
+                    bridge_if = self.kvm_domain_name + str(counter)
+                    if re.match("tap,", value):
+                        value = re.sub("tap,", "tap,%s,", value) % ifname
+                    else:
+                        value = re.sub("tap", "tap,%s", value) % ifname
+                    counter += 1
+                assert type(bridge_if) is str, "ifname is not a string %s" % ifname
+                # build the bridge key for exporting to the environ   
+                bridge_key = "_".join(["kvm_bridge", bridge_if])
+                assert type(bridge_key) is str, "bridge_key is not a str: %s" % \
+                    bridge_key
+                # search for bridge value
+                if re.search("bridge", value):
+                    bridge = re.search("(,|)bridge=([a-zA-Z0-9]+)", value)
+                    # remove the bridge from string
+                    value = value.replace(bridge.group(0), "")
+                    # assign bridge for exporting the bridge name
+                    self.bridge[bridge_key] = bridge.group(2)
+                else:
+                    msg = "Missing second Value for bridge.\n"
+                    msg += "Syntax example: bridge=br0"
+                    raise Exception(msg)
+                # search for script 
+                if not re.search("script", value):
+                    ifup = "=".join(["script",
+                        os.path.join(self.kvm_scripts_dir, 'kvm-ifup')])
+                    value = ",".join([value, ifup])
+                # search for downscript
+                if not re.search("downscript", value):
+                    ifdown = "=".join(["downscript",
+                        os.path.join(self.kvm_scripts_dir, 'kvm-ifdown')])
+                    value = ",".join([value, ifdown])
+                # add the cleaned value to temporary dictionary
+                temp[key] = value
+            else:                    
+                temp[key] = value
+        # add the cleand temp dictionary back to config        
+        self.config["net"] = temp
--- a/kvmtools/config/configtest.py	Fri Mar 23 02:49:17 2012 +0100
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,47 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-#
-# Test for kvm guest config file
-#
-
-"""
-(c) 2007-2012 Jens Kasten <jens@kasten-edv.de>
-"""
-
-import os
-try:
-    import argparse
-except ImportError:
-    import kvmtools.config.argsparse as argsparse
-from kvmtools.config.parser import Parser
-
-
-class TestConfig(object):
-    """kvm guest test config parser"""
-    
-    def show_result(self, config_file):
-        """Print the parsed config file."""
-        if not os.path.isfile(config_file):
-            print "Configfile does not exists: ", config_file
-            return
-        result = Parser().parse_config(config_file)
-        for key, value in result.iteritems():
-            print "% s= %s" % (key, value)
-
-
-def main():
-    """commandline usage"""
-    parser = argparse.ArgumentParser()
-    parser.add_argument("-c", "--config", metavar="kvm guest config file",
-        help="Absolute path for kvm guest config file.")
-    args = parser.parse_args()
-
-    if not args.config:
-        parser.print_usage()
-        return
-    config = TestConfig()
-    config.show_result(args.config)
-
-
-if __name__ == "__main__":
-    main()
--- a/kvmtools/config/create_dialog.py	Fri Mar 23 02:49:17 2012 +0100
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,183 +0,0 @@
-#
-# Module to create an initial kvm-admin domain configuration file
-#
-
-"""
-(c) 2011-2012 Jens Kasten <jens@kasten-edv.de>
-"""
-
-
-class CreateDialogConsole(object):
-    """Console dialog to create inital config file."""
-
-    def __init__(self):
-        self.fd = None    
-        self._is_cdrom = False
-
-    def create_dialog(self):
-        """Methode to create a dialog for creating a domain config"""
-        try:
-            # If the write somehow failed, it could lead to an endless loop
-            self.fd = open(self.kvm_domain_file, "w")
-            self._write(self.name_input())
-            self._write(self.memory_input())
-            self._write(self.cdrom_input())
-            if self._is_cdrom:
-                self._write(self.boot_order_input())
-            self._write(self.drive_input())
-        except IOError, e:
-            RuntimeError("Operation failed: %s, %s" % e.message, 
-                self.kvm_domain_file)
-        finally:
-            if self.fd:
-                self.fd.close()
-    
-    def _write(self, content):
-        self.fd.write(content + "\n")
-
-    def name_input(self):
-        name = raw_input("Name [%s]: " % self.kvm_domain_name)
-        if len(name) == 0:
-            return "# name of window title (name)\nname = %s" % self.kvm_domain_name
-        else:
-            return "# name of window title (name)\nname = %s" % name
-
-    def memory_input(self):         
-        comment = "# system memory in megabyte (m)\n"
-        print "Total memory of the machine: %s" % self.total_memory()
-        while True:
-            memory = raw_input("Memory in MB [%d]: " % 128)
-            if len(memory) == 0 or memory == "q":
-                return comment + "m = 128"
-            try:
-                memory = int(memory)
-                if memory > self.total_memory():
-                    print "Machine has not that much memory %sMB." % \
-                        self.avail_memory()
-                    accept = raw_input("Should this value used? [Y/n]:").lower()
-                    if len(accept) == 0 or accept == "y":
-                        return comment + "m = %d" % memory
-                elif memory > self.avail_memory():
-                    print "Memory in the moment available %sMB." % \
-                        self.avail_memory()
-                    accept = raw_input("Should this value used? [Y/n]:").lower()
-                    if len(accept) == 0 or accept == "y":
-                        return comment + "m = %d" % memory
-                else:
-                    return comment + "m = %d" % memory
-            except ValueError:
-                print "Memory must give as a positive digit or press enter."
-                    
-    def cdrom_input(self):                    
-        cdrom = raw_input("Would you like use a cdrom [Y/n]: ").lower()
-        if len(cdrom) == 0 or cdrom == "y":
-            if self.get_cdrom():
-                cdrom_path = raw_input("Path to cdrom device [%s]: " \
-                    % self.get_cdrom())
-                # use default cdrom which was found
-                self._is_cdrom = True
-                if len(cdrom_path) == 0:
-                    return "# path to cdrom (cdrom)\ncdrom = %s" % self.get_cdrom()
-                else:
-                    return "# path to cdrom (cdrom)\ncdrom = %s" % cdrom_path
-            else:
-                print "No default cdrom available."
-                while True:
-                    cdrom_path = raw_input("Path to iso image: ")
-                    if len(cdrom_path) == 0:
-                        print "Type q to continue."
-                    elif cdrom_path == "q":
-                        return "" 
-                    else:
-                        self._is_cdrom = True
-                        return "# path to iso image\ncdrom = %s" % cdrom_path
-        return ""
-
-    def boot_order_input(self):
-        print "\tIs for fresh installation a good order 'cd'."
-        print "\tBecause if not a bootable harddrive availablen"
-        print "\tthan is booting from installation cdrom."
-        print "\tAfter successfully installation its booting after reboot in correct order."
-        boot = raw_input("Would you like to boot the qemu-kvm guest from cdrom? [Y/n]")
-        while True:
-            if boot.lower() == "y" or len(boot) == 0:
-                return "# boot order: first cdrom and second harddrive\nboot = cd"
-            else:
-               return "# boot order: first harddrive, no other option\nboot = c"
-        return ""
-
-    def drive_input(self):
-        drives = {}
-        while True:
-            print "Available qemu-kvm device driver [ide,scsi,virtio]."
-            print "Type q to continue without harddrive."
-            driver = raw_input("default qemu-kvm device driver [virtio]: ")
-            if driver == "q":
-                return ""
-            if driver in ["ide", "scsi", "virtio"]:
-                break
-            elif len(driver) == 0:
-                driver = "virtio"
-                break
-        while True:
-            print "Type q to quit."
-            drive_amount = raw_input("How many harddrives you are like to use [1]: ")
-            try:
-                if drive_amount == "q":
-                   return "" 
-                elif len(drive_amount) == 0:
-                    drive_amount = 1
-                    break
-                else:
-                    drive_amount = int(drive_amount)
-                    if drive_amount > 4:
-                        print "Its initial configuration. Max 4 devices cat set."
-                    else:
-                        break
-            except ValueError:
-                print "Amount of drive must a positive digit greater the null."
-                print "Type q to continue without harddrive."
-        while True:
-            for i in range(1, drive_amount + 1):
-                while True:
-                    drive = raw_input("Path to hardrive %d: " % i)
-                    if len(drive) > 0:
-                        drives[i] = {
-                            "file": drive, 
-                            "if": driver, 
-                            "index": i-1,
-                            "boot": "off",
-                            "cache": "none",
-                            "media": "disk",
-                        }
-                        break
-            break
-        while True:
-            if len(drives) > 1:
-                print  "From which device should boot: "
-            if len(drives) == 1:
-                drives[1]["boot"] = "on"
-                break
-            else:
-                for key in drives.iterkeys():
-                    print "[%d] %s" % (key, drives[key]["file"])
-                boot = raw_input("Index: ")
-                if boot == "q":
-                     break
-            try:
-                boot = int(boot)
-                drives[boot]["boot"] = "on"
-                break
-            except ValueError:
-                print "Index have to a digit from list above."
-                print "Type q to continue without set boot on for a harddrive."
-            except KeyError:
-                print "Index not in list."
-        drive_list = ["# harddive (drive)"]
-        for key, value in drives.iteritems():
-            to_write = "drive = file=%s,index=%d,media=%s,cache=%s,boot=%s" % \
-               (value["file"], value["index"], value["media"], 
-                value["cache"], value["boot"])
-            drive_list.append(to_write)
-        return "\n".join(drive_list)
-
--- a/kvmtools/config/domain.py	Fri Mar 23 02:49:17 2012 +0100
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,59 +0,0 @@
-# 
-# Module which handle the domain configuration.
-# Its uses to collect information from different modules.
-#
-
-"""
-(c) 2011-2012 Jens Kasten <jens@kasten-edv.de>
-"""
-
-import os
-
-from kvmtools.config.set_config import SetConfig
-from kvmtools.config.create_dialog import CreateDialogConsole
-from kvmtools.kvm.build_command import BuildCommand
-from kvmtools.kvm.monitor import Monitor
-from kvmtools.kvm.system import System
-
-
-class Domain(SetConfig, CreateDialogConsole, BuildCommand, Monitor, System):
-    """Class domain handle the domain(guest) configuration."""
-
-    def __init__(self):
-        SetConfig.__init__(self)
-        CreateDialogConsole.__init__(self)
-        BuildCommand.__init__(self)
-        Monitor.__init__(self)
-        System.__init__(self)
-
-    def create(self):
-        """Create a minimalistic domain config file."""
-        print "Creating the domain config file: %s" % self.kvm_domain_file
-        self.create_dialog()
-        self.modify()
-
-    def modify(self):
-        """Edit a domain config file."""
-        # TODO: check on different distribution and find a better way
-        if os.path.isfile(self.kvm_domain_file):
-            if os.access(self.kvm_domain_file, os.W_OK):
-                try:
-                    # for debian 
-                    os.execl("/usr/bin/editor", "", self.kvm_domain_file)
-                except OSError, e:
-                    editor = os.environ["EDITOR"]
-                    try:
-                        # for gentoo
-                        os.execl(editor, "", self.kvm_domain_file)
-                    except OSError, e:
-                        try:
-                            # for unknown 
-                            os.execl("/usr/bin/vi", "", self.kvm_domain_file)
-                        except:
-                            print "Operation failed: Editor is not set correct."
-            else:
-                print "Permission denied: No write access for %s." % \
-                    self.kvm_domain_file
-        else:
-            self.create()
-
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/kvmtools/config/kvm_config.py	Tue Mar 27 02:52:37 2012 +0200
@@ -0,0 +1,78 @@
+#
+# Module to set the absolute paths for domain_name 
+# pidfile and socketfile
+# 
+#
+
+"""
+(c) 2011-2012 Jens Kasten <jens@kasten-edv.de>
+"""
+
+import os
+
+from kvmtools.header import Header
+from kvmtools.config.build_config import BuildConfig
+from kvmtools.config.build_command import BuildCommand
+
+
+class KvmConfig(Header, BuildConfig, BuildCommand):
+    """Set when the kvm_domain_name get assigned a value 
+    the pidfile and socketfile otherwise set kvm_domain_names 
+    as a list with all files wich found in domains directory.
+    """
+
+    def __init__(self):
+        Header.__init__(self)
+        BuildConfig.__init__(self)
+        BuildCommand.__init__(self)
+        self.kvm_domain_names = []
+        self.kvm_domain_file = None
+        self.kvm_pidfile = None
+        self.kvm_socketfile = None
+        self._value = None
+
+    def _set(self, value):
+        """Property to set kvm_domain_file and based on this
+        the pidfile and socketfile.
+        """
+        assert type(value) is str, "kvm_domain_name is not a string"
+        self._value = value
+        self.kvm_domain_file = os.path.join(self.kvm_domains_dir, value)
+        kvm_pidfile = "".join([self.kvm_domain_name, ".pid"])
+        self.kvm_pidfile = os.path.join(self.kvm_run_dir, kvm_pidfile)
+        kvm_socketfile = "".join([self.kvm_domain_name, ".socket"])
+        self.kvm_socketfile = os.path.join(self.kvm_run_dir, kvm_socketfile)
+        # load config and build command, its depends on kvm_domain_name
+        self.build_config()
+        self.build_command()
+        # call get_pid() from module system
+        self.get_pid()
+
+    def _get(self):
+        """Property to get the kvm_domain_name."""
+        return self._value
+
+    kvm_domain_name = property(_get, _set)
+
+
+if __name__ == "__main__":
+    import sys
+    conf = KvmConfig()
+    if len(sys.argv) > 1:
+        conf.kvm_domain_name = sys.argv[1]
+    print "kvm_domain_name:", conf.kvm_domain_name
+    print "kvm_pidfile:", conf.kvm_pidfile
+    print "kvm_socketfile:", conf.kvm_socketfile
+    print "kvm_domain_names:", conf.kvm_domain_names
+    print "*" * 80
+    print "call build_config()"
+    conf.build_config()
+    print "cleaned config dictionary"
+    print conf.config
+    print "*" * 80
+    print "call build_command()"
+    conf.build_command()
+    print "print command as list:"
+    print conf.command[0]
+    print "print command as string:"
+    print conf.command[1]
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/kvmtools/config/kvm_parser.py	Tue Mar 27 02:52:37 2012 +0200
@@ -0,0 +1,122 @@
+#!/usr/bin/env python
+#
+# Parser to get content from a configfile.
+#
+# config file syntax:
+#       key = value
+#       #key = value    <- commented 
+#       key = value  # comment
+#
+
+"""
+(c) 2007-2012 Jens Kasten <jens@kasten-edv.de>
+"""
+
+import os
+import sys
+import re
+
+IS_QEMU_KVM_OPTION = False
+try:
+    from kvmtools.kvm_options import kvm_options
+    IS_QEMU_KVM_OPTION = True
+except ImportError, e:
+    kvm_options = {}
+from kvmtools.header import Header
+
+class Parser(object):
+    """Simple config parser for kvm guest config file."""
+    
+    def _check_config_syntax(self, config_file):
+        """Return a dictionary from given config file."""
+        assert type(config_file) is str, "No config file is set"
+        if not os.path.isfile(config_file):
+            print "Configfile does not exist: %s" % config_file
+            sys.exit(1)
+        else:
+            counter = 1
+            config = []
+            fd = None
+            try:
+                fd = open(config_file)
+                lines = fd.readlines()
+                # remove withespace but not and arguments 
+                for line in lines:
+                    if len(line) > 1 and not line.startswith('#'):
+                        # split only the first equal sign form left side
+                        temp = line.strip().split("=", 1)
+                        # check for sign '=' 
+                        if len(temp) == 1:
+                            msg = "Missing sign '=' in %s on line %s" % \
+                                (config_file, counter)
+                            raise RuntimeError(msg)
+                        # remove all withespace from string
+                        key = re.sub(r'\s', '', temp[0])
+                        if key not in Header().exclude_options \
+                            and key not in kvm_options:
+                            print "Not a qemu-kvm command: '%s' in %s on line %s" % \
+                                 (key, config_file, counter)
+                            sys.exit(1)
+                        # remove comments
+                        if len(temp) == 1:
+                            msg = "Missing value in %s on line %s" % \
+                                (config_file, counter)
+                            raise RuntimeError(msg)
+                        else:
+                            value = temp[1].split("#")[0].strip()
+                        content = "=".join([key, value])
+                        config.append(content)
+                    counter += 1
+            finally:
+                if fd:
+                    fd.close()
+            return config
+
+    def parse_config(self, config_file):
+        """Return a dictionary"""
+        lines = self._check_config_syntax(config_file)
+        if not lines:
+            return False
+        config = {}
+        drive = {}
+        drive_counter = 0
+        net = {}
+        net_counter = 0
+        chardev = {}
+        chardev_counter = 0
+        for line in lines:
+            if len(line) > 0:
+                line = line.split("=", 1)
+                # check for drive, net and char keys and 
+                # add them im a separate dict to avoid overriding
+                if line[0] == "drive":
+                    drive[drive_counter] = line[1]
+                    config['drive'] = drive
+                    drive_counter += 1
+                elif line[0] == "net":
+                    net[net_counter] = line[1]
+                    config['net'] = net
+                    net_counter += 1
+                elif line[0] == "chardev":
+                    chardev[chardev_counter] = line[1]
+                    config['chardev'] = chardev
+                    chardev_counter += 1
+                else:
+                    config[line[0]] = line[1]
+        return config
+
+    def merge_configs(self, config_one, config_two):
+        """Merge two configs into a single one without duplications."""
+        config = {}
+        if not config_one and not config_two:
+            return {}
+        if config_one and not config_two:
+            return config_one
+        if not config_one and config_two:
+            return config_two
+        for key, value in config_one.iteritems():
+            config[key] = value
+        for key in config_two.keys():
+            if key not in config_one:
+                config[key] = config_two[key]
+        return config
--- a/kvmtools/config/parser.py	Fri Mar 23 02:49:17 2012 +0100
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,120 +0,0 @@
-#!/usr/bin/env python
-#
-# Parser to get content from a configfile.
-#
-# config file syntax:
-#       key = value
-#       #key = value    <- commented 
-#       key = value  # comment
-#
-
-"""
-(c) 2007-2011 Jens Kasten <jens@kasten-edv.de>
-"""
-
-import os
-import sys
-import re
-
-try:
-    from kvmtools.qemu_kvm_options import qemu_kvm_options
-except ImportError:
-    # if the file qemu_kvm_options.py does not exists as first run
-    # just create an empty dictionary
-    qemu_kvm_options = {}
-from kvmtools.functions import qemu_kvm_error_message
-
-
-class Parser(object):
-    """Simple config parser for kvm guest config file."""
-    
-    def _check_config_syntax(self, config_name):
-        """Return a cleaned dictionary from a befor readed config file."""
-        if not os.path.isfile(config_name):
-            return False
-        else:
-            counter = 1
-            config = []
-            fd = None
-            try:
-                fd = open(config_name)
-                lines = fd.readlines()
-                # remove withespace but not and arguments 
-                for line in lines:
-                    if len(line) > 1 and not line.startswith('#'):
-                        # split only the first equal sign form left side
-                        temp = line.strip().split("=", 1)
-                        # check for sign '=' 
-                        if len(temp) == 1:
-                            msg = "Missing sign '=' in %s on line %s" % \
-                                (config_name, counter)
-                            qemu_kvm_error(msg)
-                        # remove all withespace from string
-                        key = re.sub(r'\s', '', temp[0])
-                        if key not in self.exclude_options and key not in qemu_kvm_options:
-                            msg = "Not a qemu-kvm command: '%s' in %s on line %s" % \
-                                (key, config_name, counter)
-                            qemu_kvm_error(msg)
-                        # remove comments
-                        if len(temp) == 1:
-                            msg = "Missing value in %s on line %s" % \
-                                (config_name, counter)
-                            qemu_kvm_error(msg)
-                        else:
-                            value = temp[1].split("#")[0].strip()
-                        content = "=".join([key, value])
-                        config.append(content)
-                    counter += 1
-            finally:
-                if fd:
-                    fd.close()
-            return config
-
-    def parse_config(self, config_name):
-        """Return a dictionary"""
-        lines = self._check_config_syntax(config_name)
-        if not lines:
-            return 
-        config = {}
-        drive = {}
-        drive_counter = 0
-        net = {}
-        net_counter = 0
-        chardev = {}
-        chardev_counter = 0
-        for line in lines:
-            if len(line) > 0:
-                line = line.split("=", 1)
-                # check for drive, net and char keys and 
-                # add them im a separate dict to avoid overriding
-                if line[0] == "drive":
-                    drive[drive_counter] = line[1]
-                    config['drive'] = drive
-                    drive_counter += 1
-                elif line[0] == "net":
-                    net[net_counter] = line[1]
-                    config['net'] = net
-                    net_counter += 1
-                elif line[0] == "chardev":
-                    chardev[chardev_counter] = line[1]
-                    config['chardev'] = chardev
-                    chardev_counter += 1
-                else:
-                    config[line[0]] = line[1]
-        return config
-
-    def merge_configs(self, config_one, config_two):
-        """Merge two configs into a single one without duplications."""
-        config = {}
-        if not config_one and not config_two:
-            return {}
-        if config_one and not config_two:
-            return config_one
-        if not config_one and config_two:
-            return config_two
-        for key, value in config_one.iteritems():
-            config[key] = value
-        for key in config_two.keys():
-            if key not in config_one:
-                config[key] = config_two[key]
-        return config
--- a/kvmtools/config/set_config.py	Fri Mar 23 02:49:17 2012 +0100
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,113 +0,0 @@
-#
-# Module to set the basics paths and files
-#
-#       The values come from header.py
-#       This value surrounded by {}
-#       self.kvm_base_config_dir = {/etc/kvm}
-#       self.kvm_conf_dir = self.kvm_base_config_dir/{conf}
-#       self.kvm_domain_dir = self.kvm_base_config_dir/{domains}
-#       self.kvm_domain_name = sys.argv[1]
-#       self.kvm_domain_file = self.kvm_domain_dir/self.kvm_domain_name
-#       self.kvm_script_dir = self.kvm_base_config_dir/{scripts}
-#       self.kvm_conf_file = self.kvm_conf_dir/{kvm.cfg}
-
-"""
-(c) 2011 Jens Kasten <jens@kasten-edv.de>
-"""
-
-import os
-
-from kvmtools.header import Header
-
-
-class SetConfig(Header):
-
-    def __init__(self):
-        Header.__init__(self)
-        # initialize attribute
-        # keep all file name which are found in dir domains
-        self.kvm_domain_name_all = []
-        # keep the on the fly create values
-        self.kvm_domain_file = None
-        self.kvm_pidfile = None
-        self.kvm_socketfile = None
-        self.kvm_conf_file = None
-        self._value = None
-        self.config()
-
-    def config(self):
-        """Methode to call from other modules. 
-        Set all nesessary attribute."""
-        self._set_kvm_script_dir()
-        self._set_kvm_conf_dir()
-        self._set_kvm_conf_file()
-        self._set_kvm_domain_dir()
-        self._set_kvm_domain_name_all()
-
-    def _set_kvm_pid_file(self):
-        """Set the absolute path for the pidfile."""
-        kvm_pidfile = "".join([self.kvm_domain_name, ".pid"])
-        self.kvm_pidfile = os.path.join(self.kvm_run_path, kvm_pidfile)
-        assert type(self.kvm_pidfile) is str, "pidfile is None"
-    
-    def _set_kvm_socket_file(self):
-        """Set the absolute path for the socketfile."""
-        kvm_socketfile = "".join([self.kvm_domain_name, ".socket"])
-        self.kvm_socketfile = os.path.join(self.kvm_run_path, kvm_socketfile)
-        assert type(self.kvm_socketfile) is str, "socketfile is None"
-
-    def _set_kvm_script_dir(self):
-        """Set the absolute path for global configuration directory."""
-        kvm_script_dir = os.path.join(self.kvm_base_config_dir,
-            self._kvm_script_dir)
-        if os.path.isdir(kvm_script_dir):
-            self.kvm_script_dir = kvm_script_dir
-        assert type(self.kvm_script_dir) is str, "kvm_script_dir is None"
-
-    def _set_kvm_conf_dir(self):
-        """Set the absolute path for global configuration directory."""
-        kvm_conf_dir = os.path.join(self.kvm_base_config_dir,
-            self._kvm_conf_dir)
-        if os.path.isdir(kvm_conf_dir):
-            self.kvm_conf_dir = kvm_conf_dir
-        assert type(self.kvm_conf_dir) is str, "kvm_conf_dir is None"
-
-    def _set_kvm_conf_file(self):
-        """Set the global config file."""
-        kvm_conf_file = os.path.join(self.kvm_conf_dir, self._kvm_conf_name)
-        if os.path.isfile(kvm_conf_file):
-            self.kvm_conf_file = kvm_conf_file
-        assert type(self.kvm_conf_file) is str, "kvm_conf_file is None"
-
-    def _set_kvm_domain_dir(self):
-        """Set the absolute path for domain configuration directory."""
-        kvm_domain_dir = os.path.join(self.kvm_base_config_dir,
-            self._kvm_domain_dir)
-        if os.path.isdir(kvm_domain_dir):
-            self.kvm_domain_dir = kvm_domain_dir
-        assert type(self.kvm_domain_dir) is str, "kvm_domain_dir is None"
-
-    def _set_kvm_domain_name_all(self):
-        """Set all available guests as an dictionary."""
-        for domain_name in os.listdir(self.kvm_domain_dir):
-            if os.path.isfile(os.path.join(self.kvm_domain_dir, domain_name)):
-                self.kvm_domain_name_all.append(domain_name)
-
-    # property to set, get, and delte the domain_conf_file
-    def _set(self, value):
-        """Set property."""
-        if value:
-            self._value = value
-            self.kvm_domain_file = os.path.join(self.kvm_domain_dir, value)
-            assert type(self.kvm_domain_file) is str, \
-                "kvm_domain_file is None"
-            self._set_kvm_pid_file()
-            self._set_kvm_socket_file()
-            self.build_command()
-            self.get_pid()
-
-    def _get(self):
-        """Get property."""
-        return self._value
-
-    kvm_domain_name = property(_get, _set)
--- a/kvmtools/functions.py	Fri Mar 23 02:49:17 2012 +0100
+++ b/kvmtools/functions.py	Tue Mar 27 02:52:37 2012 +0200
@@ -20,7 +20,7 @@
             return service
     return False
 
-qemu_kvm_error_message = []
-def qemu_kvm_error(self, message):
+kvm_error_message = []
+def kvm_error(message):
     """Just a collection of errors in a list."""
-    qemu_kvm_error_message.append(message)   
+    kvm_error_message.append(message)   
--- a/kvmtools/generate_options.py	Fri Mar 23 02:49:17 2012 +0100
+++ b/kvmtools/generate_options.py	Tue Mar 27 02:52:37 2012 +0200
@@ -9,15 +9,15 @@
 
 import re
 
-from kvmtools.kvm.check_kvm import CheckKvm
+from kvmtools.generator_helper import GeneratorHelper
 
 
-class Generator(CheckKvm):
+class Generator(GeneratorHelper):
     """Generate qemu-kvm options and write them into file
-    qemu_kvm_options.py.
+    kvm_options.py.
     """
     def __init__(self):
-        CheckKvm.__init__(self)
+        GeneratorHelper.__init__(self)
         self.prepare_generator()
 
     def generate(self):
@@ -29,12 +29,12 @@
         try:
             header = "#!/usr/bin/env python\n"
             header += "# Autogenerated dictionary. Don't edit this file!\n#\n"
-            header += "# Generated for: %s\n#\n\n" % self.qemu_kvm_options[0]
-            header += "qemu_kvm_options = {\n"
+            header += "# Generated for: %s\n#\n\n" % self.kvm_options[0]
+            header += "kvm_options = {\n"
             footer = "}\n"
     
             # extract options from qemu-kvm --help and put them into a dict
-            for line in self.qemu_kvm_options:
+            for line in self.kvm_options:
                 if line.startswith('-'):
                     # split options from help text
                     options = line.split(' ', 1)
@@ -57,7 +57,7 @@
                             line_counter += 1 
             
             # write output to file
-            fd = open(self.qemu_kvm_options_file, 'w')
+            fd = open(self.kvm_options_file, 'w')
             fd.write(header)
             for index, value in output.iteritems():
                 if index == 0:
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/kvmtools/generator_helper.py	Tue Mar 27 02:52:37 2012 +0200
@@ -0,0 +1,147 @@
+# 
+#  Helper Module to do some checks.
+#
+
+"""
+(c) 2012 Jens Kasten <jens@kasten-edv.de>
+"""
+
+import os
+import sys
+from subprocess import Popen, PIPE
+
+from kvmtools.functions import which
+from kvmtools.header import Header
+from kvmtools.config.kvm_parser import Parser
+
+
+class GeneratorHelper(Header):
+
+    def __init__(self):
+        Header.__init__(self)
+        self.kvm_help = []
+        self.kvm_options = []
+        self.qemu_kvm = False
+
+    def prepare_generator(self):
+        """Collect all what is need to run.
+        Even if the qemu-kvm is not installed on the system.
+        """
+        if self.get_kvm_path_from_file():
+            if not self.get_kvm_help():
+                print "This is not a qemu-kvm binary."
+                print "Edit %s to correct it." % self.kvm_config_file
+                sys.exit(1)
+            else:
+                self.update_kvm_conf()
+        elif self.get_kvm_path_from_input():
+            if not self.get_kvm_help():
+                print "This is not a qemu-kvm binary."
+                print "You have to call the command below again."
+                print "Execute: generate-kvm-options -g"
+                sys.exit(1)
+            else:
+                self.update_kvm_conf()
+        else:
+            print "You have to update the config file manually." 
+            print "You have set the correct path for qemu-kvm in %s" % \
+                self.kvm_config_file
+            sys.exit(1)
+    
+   
+    def get_kvm_path_from_file(self):
+        """Try to find the absolute path for key "qemu-kvm" value 
+        in kvm_config_file.
+        """
+        kvm_config = Parser().parse_config(self.kvm_config_file)
+        if "qemu-kvm" in kvm_config:
+            kvm_name = kvm_config["qemu-kvm"]
+            for i in kvm_name.split(","):
+                self.qemu_kvm = which(i.strip())
+                if self.qemu_kvm:
+                    return True
+
+    def get_kvm_path_from_input(self):
+        """Try with the user input to set the absolute path."""
+        print "Enter the qemu-kvm binary name or absolute path."
+        print "When done press enter or just q to quit."
+        while True:
+            result = raw_input("Name: ")
+            if result == "q":
+                break 
+            elif len(result) == 0:
+                continue
+            else:
+                self.qemu_kvm = which(result)
+                if self.qemu_kvm:
+                    return True
+                else:
+                    print "Could not found '%s' in your PATH" % result
+
+    def update_kvm_conf(self):
+        """Replace the qemu-kvm default value in the global config file."""
+        print "Update %s" % self.kvm_config_file
+        if os.access(self.kvm_config_file, os.W_OK):
+            fd = None
+            try:
+                fd = open(self.kvm_config_file, "r")
+                lines = fd.readlines()
+                new_lines = []
+                for line in lines:
+                    if line.lstrip().startswith("qemu-kvm"): 
+                        qemu_kvm = "qemu-kvm = %s\n" % self.qemu_kvm
+                        new_lines.append(qemu_kvm)
+                    else:
+                        new_lines.append(line)
+            except IOError, e:
+                print "Operation failed: %s on %s" % (e, self.kvm_confg_file)
+            finally:
+                if fd:
+                    fd.close()
+                    if len(new_lines) > 0:
+                        try:
+                            fd = open(self.kvm_config_file, "w")
+                            for line in new_lines:
+                                fd.write(line)
+                        except IOError, e:
+                            print "Operation failed: %s on %s" % (e, 
+                                self.kvm_config_file)
+                        finally:
+                            if fd:
+                                print "Done"
+                                fd.close()
+        else:
+            print "No write permission to %s." % self.kvm_config_file
+            sys.exit(1)
+
+    def get_kvm_help(self):
+        """This call the give qemu-kvm name
+        and check if the help if in the first line the qemu name.
+        This check have to be done, because it will write in the config file.
+        Its return the help 
+        """
+        self.kvm_options = []
+        process = Popen([self.qemu_kvm, "-h"], stdout=PIPE, stderr=PIPE)
+        result = process.communicate()[0]
+        kvm_help = result.split("\n")
+        if "QEMU" in kvm_help[0]:
+           self.kvm_options = kvm_help
+           return True
+        else:
+            return False
+        
+
+    def check_qemu_kvm_path(self):
+        """The qemu-kvm is not a valid parameter.
+        This can have a single value or comma separated values.
+        """
+        config = Parser().parse_config(self.kvm_config_file)
+        print config
+        if "qemu-kvm" not in config:
+            print "Copy this example:"
+            print "\tqemu-kvm = qemu-kvm, kvm"
+            sys.exit(1)
+        else:
+            if not self.check_qemu_kvm_options_file():
+                self.prepare_generator()
+
--- a/kvmtools/header.py	Fri Mar 23 02:49:17 2012 +0100
+++ b/kvmtools/header.py	Tue Mar 27 02:52:37 2012 +0200
@@ -1,45 +1,68 @@
 #
-# header file
-# try to collect all attribute which can be changed
+# Kvm header file does collect all paths and stuff.
 #
 
 """
-(c) 2011 Jens Kasten <jens@kasten-edv.de>
+(C) 2011-2012 Jens Kasten <jens@kasten-edv.de>
 """
 
+import os
+
+# need to get the absolute path
+import kvmtools
+
+
 class Header(object):
     """Contain all attribute to store filename or paths and some other stuff.
-    """
-    
+    """ 
+
     def __init__(self):
-        # base direcotry configs, and scripts 
-        self.kvm_base_config_dir = "/etc/kvm"
-        # subdirecotories from self.base_dir
+        #########
+        # Paths #
+        #########
+        # base direcotry for configs, and scripts, and domain configs
+        self.kvm_base_dir = "/etc/kvm"
         # directory name to store the ifdown and ifup scripts
-        self._kvm_script_dir = 'scripts'
-        # directory name to store the guest configuration files
-        self._kvm_domain_dir = 'domains'
+        self.kvm_scripts_dir = os.path.join(self.kvm_base_dir, 'scripts')
+        # directory name to store the domain configuration files
+        self.kvm_domains_dir = os.path.join(self.kvm_base_dir, 'domains')
         # directory name to store the global configuration file
-        self._kvm_conf_dir = 'config'
+        self.kvm_config_dir = os.path.join(self.kvm_base_dir, 'config')
+        # directory for auto start kvm domain
+        # TODO: not implement 
+        self.kvm_auto_dir = os.path.join(self.kvm_base_dir, "auto")
         # name for global configuration file
-        self._kvm_conf_name = 'kvm.cfg'
-        # default telnet port 23, can only use once at time in one guest
-        # otherwise each guest have to set expliciet a different port
-        self.telnet_port = 23
-        # default directory for pidfile,and socketfile
-        self.kvm_run_path = '/var/run/kvm'
-        # this exclude_options are using internal only
-        self.exclude_options = ['qemu-kvm', 'python-debug', "h", "version"]
-        # file name for qemu kvm options
-        self.qemu_kvm_options_file_name = "qemu_kvm_options.py"
+        self.kvm_config_name = 'kvm.cfg'
+        # the absolute path for kvm_conf_file
+        self.kvm_config_file = os.path.join(self.kvm_config_dir,
+                                            self.kvm_config_name)
+        # directory for pidfiles and socketfiles
+        self.kvm_run_dir = '/var/run/kvm'
+        # module path, it can placed on different directories
+        # so use the imported kvmtools to get the absolute path
+        self.module_path = os.path.abspath(os.path.dirname(kvmtools.__file__))
+        # file name for kvm options, this file is an autogenerated
+        self.kvm_options_file_name = "kvm_options.py"
+        # absolute path
+        self.kvm_options_file = os.path.join(self.module_path, 
+                                             self.kvm_options_file_name)
         # search path's
         self.search_paths = ["/bin", "/sbin", 
                              "/usr/bin", "/usr/sbin", 
                              "/usr/local/sbin", "/usr/local/bin"]
-        # setting for qemu-kvm 
+        ###########
+        # Options #
+        ###########
+        # default telnet port 23, can only use once at time in one guest
+        # otherwise each guest have to set explicit a different port
+        self.telnet_port = 23
+        # this options are using internal only
+        self.exclude_options = ['qemu-kvm', 'python-debug', "h", "version"]
+        # this settings help to customize the configuration files
+        # is_disabled => kvm options is not using
         self.is_disabled = "disabled"
-        # setting for qemu-kvm options
+        # is_enabled => kvm option is using and have no value
         self.is_enabled = "enabled"
-        self.qemu_kvm_error_message = []
+        # files which should not interpreted as domain config file
+        self.exclude_backup_files = [".swp", ]
 
-
--- a/kvmtools/kvm/action.py	Fri Mar 23 02:49:17 2012 +0100
+++ b/kvmtools/kvm/action.py	Tue Mar 27 02:52:37 2012 +0200
@@ -3,7 +3,7 @@
 #
 
 """
-(c) 2011 Jens Kasten <jens@kasten-edv.de>
+(c) 2011-2012 Jens Kasten <jens@kasten-edv.de>
 """
 
 import os
@@ -11,11 +11,11 @@
 from subprocess import Popen, PIPE
 from time import sleep
 
-from kvmtools.config.domain import Domain
+from kvmtools.kvm.domain import Domain
 
 
 class Action(Domain):
-    
+
     def __init__(self):
         Domain.__init__(self)
         self.kvm_errors = []
@@ -32,7 +32,7 @@
                 methode = action.replace("kvm_", "").replace("_action", "")
                 actions.append(methode)
         return actions
-   
+
     def kvm_show_action(self):
         """show the command as string"""
         print self.command[1]
--- a/kvmtools/kvm/build_command.py	Fri Mar 23 02:49:17 2012 +0100
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,56 +0,0 @@
-#
-# build command to executing
-#
-
-"""
-(c) 2011 Jens Kasten <jens@kasten-edv.de>
-"""
-
-from kvmtools.kvm.build_config import BuildConfig
-
-
-class BuildCommand(BuildConfig):
-    """Build command"""
-    
-    def __init__(self):
-        BuildConfig.__init__(self)
-        self.commmand = ()
-
-    def build_command(self):
-        """Create a tuple command. 
-        First entry is a list that is executed via subprocess
-        and the second is a string to display the command.
-        """
-        self.build_config()
-        if self.config is None:
-            return None 
-        cmd_execute = []
-        cmd_string = ""
-        # Start to build a list
-        # first add the qemu-kvm binary path
-        cmd_execute.append(self.config["qemu-kvm"])
-        # delete the helper parameter from config
-        for key in self.exclude_options:
-            if key in self.config:
-                del self.config[key]
-        # iterate over the config and build a list
-        for key, value in self.config.iteritems():
-            # ignore disabled values
-            if self.is_disabled == value:
-                continue
-            # this check search for more option like -drive -drive etc.
-            elif isinstance(value, dict):
-                for i in value.itervalues():
-                    cmd_execute.append(''.join(['-', key]))
-                    cmd_execute.append(i)
-            elif self.is_enabled != value:
-                # this qemu-kvm option have an option, so add -key value
-                cmd_execute.append(''.join(['-', key]))
-                cmd_execute.append(value)
-            else:
-                # this qemu-kvm option don't have any option 
-                # so only add -key as argument
-                cmd_execute.append(''.join(['-', key]))
-        # build a string for to display on terminal output
-        cmd_string = " ".join([value for value in cmd_execute])
-        self.command = (cmd_execute, cmd_string)
--- a/kvmtools/kvm/build_config.py	Fri Mar 23 02:49:17 2012 +0100
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,164 +0,0 @@
-#
-# Module BuildConfig collect all data to create a command qemu-kvm command.
-# 
-
-"""
-(c) 2011 Jens Kasten <jens@kasten-edv.de>
-"""
-
-import os
-import random
-import string
-import re
-
-from kvmtools.config.parser import Parser
-
-
-class BuildConfig(Parser):
-    
-    def __init__(self):
-        self.config = {}
-        self.monitor_options = {}
-        self.bridge = {}
-
-    def build_config(self):
-        """Load domain and global config and then merge them."""
-        kvm_conf_file = self.parse_config(self.kvm_conf_file)
-        kvm_domain_file = self.parse_config(self.kvm_domain_file)
-        self.config = self.merge_configs(kvm_conf_file, kvm_domain_file)
-        self._add_name()
-        self._add_uuid()
-        self._add_pidfile()
-        self._add_monitor()
-        self._add_net()
-
-    def _add_pidfile(self):
-        """Append the pidfile option to the config dictionary or reverse."""
-        if "pidfile" not in self.config:
-            pidfile = os.path.join(self.kvm_run_path, self.kvm_pidfile)
-            self.config["pidfile"] = pidfile
-        else:
-            self.kvm_pidfile = self.config["pidfile"]
-
-    def _add_uuid(self):
-        """Append an unique uuid to the config dictionary."""
-        if "uuid" in self.config:
-            check_uid = re.match(r"([a-f,A-F,0-9]{8})-([a-f,A-F,0-9]{4})-([a-f,A-F,0-9]{4})-([a-f,A-F,0-9]{4})-([a-f,A-F,0-9]{12})", self.config["uuid"])
-            if not check_uid:
-                msg = "Your uuid has wrong format, you can delete it, the script does generate a correct new one."
-                self.kvm_error(msg)
-                self.kvm_error(self.config["uuid"])
-            return
-        random.seed(os.urandom(8))
-        charset = string.digits + "abcdef"
-        eight = "".join(random.sample(charset, 8))
-        four_first = "".join(random.sample(charset, 4))
-        four_second = "".join(random.sample(charset, 4))
-        four_third = "".join(random.sample(charset, 4))
-        twelve =  "".join(random.sample(charset, 12))
-        uuid = "-".join([eight, four_first, four_second, four_third, twelve])
-        # inster the uuid into domain config file if it not exists
-        if os.path.isfile(self.kvm_domain_file) and os.access(self.kvm_domain_file, os.W_OK):
-            try:
-                fd = open(self.kvm_domain_file, "a+")
-                fd.write("# autogenerated (uuid)\nuuid = %s" % uuid)
-            except IOError, e:
-                print "Operation failed: %s" % e
-            finally:
-                if fd:
-                    fd.close()
-        self.config["uuid"] = uuid
-
-    def _add_name(self):
-        """Append a name for window title and process name (on linux only)."""
-        if "name" in self.config:
-            name = self.config["name"].split(" ")[0]
-            process_name = "=kvm_".join(["process", name])
-            self.config["name"] = ",".join([name, process_name])
-        else:
-            process_name = "=".join(["process", self.kvm_domain_name])
-            self.config["name"] = ",".join([self.kvm_domain_name, process_name])
-
-    def _add_monitor(self):
-        """Add a dictionry with type and the path to the socket file or
-        the host and port.
-        """
-        if "monitor" in self.config:
-            monitor = self.config["monitor"]
-            # get the string befor the first comma 
-            # and then split this string by colon
-            monitor_type = monitor.split(',')[0].split(':')
-            if len(monitor_type) == 3:
-                # this is usally for tcp
-                self.monitor_options['Type'] = monitor_type[0] 
-                self.monitor_options['Host'] = monitor_type[1]
-                self.monitor_options['Port'] = int(monitor_type[2])
-            elif len(monitor_type) == 2:
-                # this is for telnet, when no port is given
-                self.monitor_options['Type'] = monitor_type[0]
-                if monitor_type[0] == 'unix':
-                    self.monitor_options['SocketFile'] = monitor_type[1]
-                self.monitor_options['Host'] = monitor_type[1]
-                self.monitor_options['Port'] = self.telnet_port
-        else:
-            # set unix socket as default monitor access
-            monitor = "unix:%s,server,nowait" % self.kvm_socketfile
-            self.monitor_options["Type"] = "unix"
-            self.monitor_options['SocketFile'] = self.kvm_socketfile
-        self.config["monitor"] = monitor 
-
-    def _add_net(self):
-        """Examine the -net tap option for ifname and additional scripts and 
-        bridge strings, if not -tap option don't touch the values.
-        """
-        temp = {} 
-        counter = 0
-        if "net" not in self.config:
-            return False
-        for key, value in self.config["net"].iteritems():
-            if value.startswith("tap"):
-                # search for ifname otherwise set it from domain_name name
-                if re.search("ifname", value):
-                    ifname = re.search("ifname=([a-zA-Z0-9]+)", value)
-                    bridge_if = ifname.group(1)
-                else:
-                    ifname = "=".join(["ifname", 
-                        self.kvm_domain_name + str(counter)])
-                    bridge_if = self.kvm_domain_name + str(counter)
-                    if re.match("tap,", value):
-                        value = re.sub("tap,", "tap,%s,", value) % ifname
-                    else:
-                        value = re.sub("tap", "tap,%s", value) % ifname
-                    counter += 1
-                assert type(bridge_if) is str, "ifname is not a string %s" % ifname
-                # build the bridge key for exporting to the environ   
-                bridge_key = "_".join(["kvm_bridge", bridge_if])
-                assert type(bridge_key) is str, "bridge_key is not a str: %s" % \
-                    bridge_key
-                # search for bridge value
-                if re.search("bridge", value):
-                    bridge = re.search("(,|)bridge=([a-zA-Z0-9]+)", value)
-                    # remove the bridge from string
-                    value = value.replace(bridge.group(0), "")
-                    # assign bridge for exporting the bridge name
-                    self.bridge[bridge_key] = bridge.group(2)
-                else:
-                    msg = "Missing second Value for bridge.\n"
-                    msg += "Syntax example: bridge=br0"
-                    raise Exception(msg)
-                # search for script 
-                if not re.search("script", value):
-                    ifup = "=".join(["script",
-                        os.path.join(self.kvm_script_dir, 'kvm-ifup')])
-                    value = ",".join([value, ifup])
-                # search for downscript
-                if not re.search("downscript", value):
-                    ifdown = "=".join(["downscript",
-                        os.path.join(self.kvm_script_dir, 'kvm-ifdown')])
-                    value = ",".join([value, ifdown])
-                # add the cleaned value to temporary dictionary
-                temp[key] = value
-            else:                    
-                temp[key] = value
-        # add the cleand temp dictionary back to config        
-        self.config["net"] = temp
--- a/kvmtools/kvm/check_kvm.py	Fri Mar 23 02:49:17 2012 +0100
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,145 +0,0 @@
-"""
-(c) 2012 Jens Kasten <jens@kasten-edv.de>
-"""
-
-import os
-import sys
-from subprocess import Popen, PIPE
-
-# need to import kvmtools to get absolute path
-import kvmtools
-from kvmtools.functions import which
-from kvmtools.header import Header 
-from kvmtools.config.parser import Parser
-
-
-class CheckKvm(Parser, Header):
-
-    def __init__(self):
-        self.qemu_kvm_help = []
-        self.qemu_kvm_options = []
-        self.qemu_kvm = False
-        Header.__init__(self)
-
-    def prepare_generator(self):
-        """Collect all what is need to run.
-        Even if the qemu-kvm is not installed on the system.
-        """
-        self.get_module_path()
-        if self.get_kvm_path_from_file():
-            self.update_kvm_global_config()
-            if not self.get_qemu_kvm_help():
-                print "This is not a qemu-kvm binary."
-                print "Edit %s to correct it." % self.get_abs_path_kvm_config()
-                sys.exit(1)
-        elif self.get_kvm_path_from_input():
-            if not self.get_qemu_kvm_help():
-                print "This is not a qemu-kvm binary."
-                print "You have to call the command below again."
-                print "Execute: generate-kvm-options -g"
-                sys.exit(1)
-        else:
-            print "You have to update the config file manually." 
-            print "You have set the correct path in for qemu-kvm in %s" % \
-                self.get_abs_path_kvm_config()
-
-    def get_abs_path_kvm_config(self):
-        """Build and return the absolute path for global config."""
-        kvm_config = os.path.join(self.kvm_base_config_dir, 
-                                  self._kvm_conf_dir, 
-                                  self._kvm_conf_name)
-        if os.path.isfile(kvm_config):
-            return kvm_config
-        else:
-            return False
-    
-    def get_module_path(self):
-        """Get absolute path to kvmtools."""
-        self.module_path = os.path.abspath(os.path.dirname(kvmtools.__file__))
-        self.qemu_kvm_options_file = os.path.join(self.module_path,
-                                     self.qemu_kvm_options_file_name)
-
-    def get_kvm_path_from_file(self):
-        """Try to find the absolute path.
-        First from default kvm.cfg.
-        If its failed then give the user the possibility 
-        to give the absolute path or name to the qemu-kvm binary.
-        """
-        kvm_config = self.parse_config(self.get_abs_path_kvm_config())
-        if "qemu-kvm" in kvm_config:
-            kvm_name = kvm_config["qemu-kvm"]
-            for i in kvm_name.split(","):
-                self.qemu_kvm = which(i.strip())
-                if self.qemu_kvm:
-                    return True
-
-    def get_kvm_path_from_input(self):
-        """Try with the user input to set the absolute path."""
-        print "Enter the qemu-kvm binary name or absolute path."
-        print "When done press enter or just q to quit."
-        while True:
-            result = raw_input("Name: ")
-            if result == "q":
-                break 
-            elif len(result) == 0:
-                continue
-            else:
-                self.qemu_kvm = which(result)
-                if self.qemu_kvm:
-                    return True
-                else:
-                    print "Could not found '%s' in your PATH" % result
-
-    def update_kvm_global_config(self):
-        """Replace the qemu-kvm default value in the global config file."""
-        kvm_config = self.get_abs_path_kvm_config() 
-        print "Update %s" % kvm_config
-        if os.access(kvm_config, os.W_OK):
-            fd = None
-            try:
-                fd = open(kvm_config, "r")
-                lines = fd.readlines()
-                new_lines = []
-                for line in lines:
-                    if line.lstrip().startswith("qemu-kvm"): 
-                        qemu_kvm = "qemu-kvm = %s\n" % self.qemu_kvm
-                        new_lines.append(qemu_kvm)
-                    else:
-                        new_lines.append(line)
-            except IOError, e:
-                print "Operation failed: %s on %s" % (e, kvm_confg)
-            finally:
-                if fd:
-                    fd.close()
-                    if len(new_lines) > 0:
-                        try:
-                            fd = open(kvm_config, "w")
-                            for line in new_lines:
-                                fd.write(line)
-                        except IOError, e:
-                            print "Operation failed: %s on %s" % (e, 
-                                kvm_config)
-                        finally:
-                            if fd:
-                                print "Done"
-                                fd.close()
-        else:
-            print "No write permission to %s." % kvm_config
-            sys.exit(1)
-
-    def get_qemu_kvm_help(self):
-        """This call the give qemu-kvm name
-        and check if the help if in the first line the qemu name.
-        This check have to be done, because it will write in the config file.
-        Its return the help 
-        """
-        self.qemu_kvm_options = []
-        process = Popen([self.qemu_kvm, "-h"], stdout=PIPE, stderr=PIPE)
-        result = process.communicate()[0]
-        qemu_kvm_help = result.split("\n")
-        if "QEMU" in qemu_kvm_help[0]:
-           self.qemu_kvm_options = qemu_kvm_help
-           return True
-        else:
-            return False
-
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/kvmtools/kvm/configtest.py	Tue Mar 27 02:52:37 2012 +0200
@@ -0,0 +1,47 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+#
+# Test for kvm guest config file
+#
+
+"""
+(c) 2007-2012 Jens Kasten <jens@kasten-edv.de>
+"""
+
+import os
+try:
+    import argparse
+except ImportError:
+    import kvmtools.argsparse as argsparse
+from kvmtools.config.kvm_parser import Parser
+
+
+class TestConfig(object):
+    """kvm guest test config parser"""
+    
+    def show_result(self, config_file):
+        """Print the parsed config file."""
+        if not os.path.isfile(config_file):
+            print "Configfile does not exists: ", config_file
+            return
+        result = Parser().parse_config(config_file)
+        for key, value in result.iteritems():
+            print "% s= %s" % (key, value)
+
+
+def main():
+    """commandline usage"""
+    parser = argparse.ArgumentParser()
+    parser.add_argument("-c", "--config", metavar="kvm guest config file",
+        help="Absolute path for kvm guest config file.")
+    args = parser.parse_args()
+
+    if not args.config:
+        parser.print_usage()
+        return
+    config = TestConfig()
+    config.show_result(args.config)
+
+
+if __name__ == "__main__":
+    main()
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/kvmtools/kvm/create_dialog.py	Tue Mar 27 02:52:37 2012 +0200
@@ -0,0 +1,183 @@
+#
+# Module to create an initial kvm-admin domain configuration file
+#
+
+"""
+(c) 2011-2012 Jens Kasten <jens@kasten-edv.de>
+"""
+
+
+class CreateDialogConsole(object):
+    """Console dialog to create inital config file."""
+
+    def __init__(self):
+        self.fd = None    
+        self._is_cdrom = False
+
+    def create_dialog(self):
+        """Methode to create a dialog for creating a domain config"""
+        try:
+            # If the write somehow failed, it could lead to an endless loop
+            self.fd = open(self.kvm_domain_file, "w")
+            self._write(self.name_input())
+            self._write(self.memory_input())
+            self._write(self.cdrom_input())
+            if self._is_cdrom:
+                self._write(self.boot_order_input())
+            self._write(self.drive_input())
+        except IOError, e:
+            RuntimeError("Operation failed: %s, %s" % e.message, 
+                self.kvm_domain_file)
+        finally:
+            if self.fd:
+                self.fd.close()
+    
+    def _write(self, content):
+        self.fd.write(content + "\n")
+
+    def name_input(self):
+        name = raw_input("Name [%s]: " % self.kvm_domain_name)
+        if len(name) == 0:
+            return "# name of window title (name)\nname = %s" % self.kvm_domain_name
+        else:
+            return "# name of window title (name)\nname = %s" % name
+
+    def memory_input(self):         
+        comment = "# system memory in megabyte (m)\n"
+        print "Total memory of the machine: %s" % self.total_memory()
+        while True:
+            memory = raw_input("Memory in MB [%d]: " % 128)
+            if len(memory) == 0 or memory == "q":
+                return comment + "m = 128"
+            try:
+                memory = int(memory)
+                if memory > self.total_memory():
+                    print "Machine has not that much memory %sMB." % \
+                        self.avail_memory()
+                    accept = raw_input("Should this value used? [Y/n]:").lower()
+                    if len(accept) == 0 or accept == "y":
+                        return comment + "m = %d" % memory
+                elif memory > self.avail_memory():
+                    print "Memory in the moment available %sMB." % \
+                        self.avail_memory()
+                    accept = raw_input("Should this value used? [Y/n]:").lower()
+                    if len(accept) == 0 or accept == "y":
+                        return comment + "m = %d" % memory
+                else:
+                    return comment + "m = %d" % memory
+            except ValueError:
+                print "Memory must give as a positive digit or press enter."
+                    
+    def cdrom_input(self):                    
+        cdrom = raw_input("Would you like use a cdrom [Y/n]: ").lower()
+        if len(cdrom) == 0 or cdrom == "y":
+            if self.get_cdrom():
+                cdrom_path = raw_input("Path to cdrom device [%s]: " \
+                    % self.get_cdrom())
+                # use default cdrom which was found
+                self._is_cdrom = True
+                if len(cdrom_path) == 0:
+                    return "# path to cdrom (cdrom)\ncdrom = %s" % self.get_cdrom()
+                else:
+                    return "# path to cdrom (cdrom)\ncdrom = %s" % cdrom_path
+            else:
+                print "No default cdrom available."
+                while True:
+                    cdrom_path = raw_input("Path to iso image: ")
+                    if len(cdrom_path) == 0:
+                        print "Type q to continue."
+                    elif cdrom_path == "q":
+                        return "" 
+                    else:
+                        self._is_cdrom = True
+                        return "# path to iso image\ncdrom = %s" % cdrom_path
+        return ""
+
+    def boot_order_input(self):
+        print "\tIs for fresh installation a good order 'cd'."
+        print "\tBecause if not a bootable harddrive availablen"
+        print "\tthan is booting from installation cdrom."
+        print "\tAfter successfully installation its booting after reboot in correct order."
+        boot = raw_input("Would you like to boot the qemu-kvm guest from cdrom? [Y/n]")
+        while True:
+            if boot.lower() == "y" or len(boot) == 0:
+                return "# boot order: first cdrom and second harddrive\nboot = cd"
+            else:
+               return "# boot order: first harddrive, no other option\nboot = c"
+        return ""
+
+    def drive_input(self):
+        drives = {}
+        while True:
+            print "Available qemu-kvm device driver [ide,scsi,virtio]."
+            print "Type q to continue without harddrive."
+            driver = raw_input("default qemu-kvm device driver [virtio]: ")
+            if driver == "q":
+                return ""
+            if driver in ["ide", "scsi", "virtio"]:
+                break
+            elif len(driver) == 0:
+                driver = "virtio"
+                break
+        while True:
+            print "Type q to quit."
+            drive_amount = raw_input("How many harddrives you are like to use [1]: ")
+            try:
+                if drive_amount == "q":
+                   return "" 
+                elif len(drive_amount) == 0:
+                    drive_amount = 1
+                    break
+                else:
+                    drive_amount = int(drive_amount)
+                    if drive_amount > 4:
+                        print "Its initial configuration. Max 4 devices cat set."
+                    else:
+                        break
+            except ValueError:
+                print "Amount of drive must a positive digit greater the null."
+                print "Type q to continue without harddrive."
+        while True:
+            for i in range(1, drive_amount + 1):
+                while True:
+                    drive = raw_input("Path to hardrive %d: " % i)
+                    if len(drive) > 0:
+                        drives[i] = {
+                            "file": drive, 
+                            "if": driver, 
+                            "index": i-1,
+                            "boot": "off",
+                            "cache": "none",
+                            "media": "disk",
+                        }
+                        break
+            break
+        while True:
+            if len(drives) > 1:
+                print  "From which device should boot: "
+            if len(drives) == 1:
+                drives[1]["boot"] = "on"
+                break
+            else:
+                for key in drives.iterkeys():
+                    print "[%d] %s" % (key, drives[key]["file"])
+                boot = raw_input("Index: ")
+                if boot == "q":
+                     break
+            try:
+                boot = int(boot)
+                drives[boot]["boot"] = "on"
+                break
+            except ValueError:
+                print "Index have to a digit from list above."
+                print "Type q to continue without set boot on for a harddrive."
+            except KeyError:
+                print "Index not in list."
+        drive_list = ["# harddive (drive)"]
+        for key, value in drives.iteritems():
+            to_write = "drive = file=%s,index=%d,media=%s,cache=%s,boot=%s" % \
+               (value["file"], value["index"], value["media"], 
+                value["cache"], value["boot"])
+            drive_list.append(to_write)
+        return "\n".join(drive_list)
+
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/kvmtools/kvm/dialog.py	Tue Mar 27 02:52:37 2012 +0200
@@ -0,0 +1,27 @@
+#
+
+"""
+(c) 2011 Jens Kasten <jens@kasten-edv.de>
+"""
+
+import sys
+try:
+    import curses
+except ImportError, error_msg:
+    print error_msg
+    sys.exit(1)
+
+
+class KvmDialog(object):
+
+    def __init__(self):
+        self.dialog = curses.initscr()
+        self.dialog.border(0)
+        self.dialog.addstr(12, 26, "python curses")
+        self.dialog.refresh()
+        self.a = self.dialog.getch()
+        curses.endwin()
+
+d = KvmDialog()
+print d.a
+
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/kvmtools/kvm/domain.py	Tue Mar 27 02:52:37 2012 +0200
@@ -0,0 +1,71 @@
+# 
+# Module which handle the domain configuration.
+# Its uses to collect information from different modules.
+# The loaded module just keep the code in different placed 
+# for better maintance.
+#
+
+"""
+(c) 2011-2012 Jens Kasten <jens@kasten-edv.de>
+"""
+
+import os
+
+from kvmtools.config.kvm_config import KvmConfig
+from kvmtools.kvm.create_dialog import CreateDialogConsole
+from kvmtools.kvm.monitor import Monitor
+from kvmtools.kvm.system import System
+
+
+class Domain(KvmConfig,  Monitor, System, CreateDialogConsole):
+    """Class domain handle the domain(guest) configuration."""
+
+    def __init__(self):
+        KvmConfig.__init__(self)
+        Monitor.__init__(self)
+        System.__init__(self)
+        CreateDialogConsole.__init__(self)
+
+
+    def available_domains(self):
+        """Fill up the kvm_domain_names list"""
+        for domain_name in os.listdir(self.kvm_domains_dir):
+            # only add files
+            if os.path.isfile(os.path.join(self.kvm_domains_dir, domain_name)):
+                # exclude backup files
+                for i in self.exclude_backup_files:
+                   if not domain_name.endswith(i):
+                        self.kvm_domain_names.append(domain_name)
+        return self.kvm_domain_names
+    
+    def create(self):
+        """Create a minimalistic domain config file."""
+        print "Creating the domain config file: %s" % self.kvm_domain_file
+        self.create_dialog()
+        self.modify()
+
+    def modify(self):
+        """Edit a domain config file."""
+        # TODO: check on different distribution and find a better way
+        if os.path.isfile(self.kvm_domain_file):
+            if os.access(self.kvm_domain_file, os.W_OK):
+                try:
+                    # for debian 
+                    os.execl("/usr/bin/editor", "", self.kvm_domain_file)
+                except OSError, e:
+                    editor = os.environ["EDITOR"]
+                    try:
+                        # for gentoo
+                        os.execl(editor, "", self.kvm_domain_file)
+                    except OSError, e:
+                        try:
+                            # for unknown 
+                            os.execl("/usr/bin/vi", "", self.kvm_domain_file)
+                        except:
+                            print "Operation failed: Editor is not set correct."
+            else:
+                print "Permission denied: No write access for %s." % \
+                    self.kvm_domain_file
+        else:
+            self.create()
+
--- a/setup.py	Fri Mar 23 02:49:17 2012 +0100
+++ b/setup.py	Tue Mar 27 02:52:37 2012 +0200
@@ -7,47 +7,44 @@
 (c) 2011-2012 Jens Kasten <jens@kasten-edv.de>
 """
 
+from distutils.core import setup
 import os
 import sys
-from distutils.core import setup
-from os.path import join, isdir, isfile
-from os import listdir, mkdir, chmod
 from shutil import copytree, copy, rmtree
 from subprocess import call
 
 from kvmtools.header import Header
 
+
 def copy_configs():
-    header = Header()
-    base_dir = header.kvm_base_config_dir
-    scripts = join(base_dir, header._kvm_script_dir)
-    configs = join(base_dir, header._kvm_conf_dir)
-    domains = join(base_dir, header._kvm_domain_dir)
-    example = join(domains, "example")
-    auto = join(base_dir, "auto")
-    if isdir(scripts):
-        rmtree(scripts)
-    copytree("scripts", scripts)
+    path = Header()
+    example = os.path.join(path.kvm_domains_dir, "example")
+    if os.path.isdir(path.kvm_scripts_dir):
+        rmtree(path.kvm_scripts_dir)
+    copytree("scripts", path.kvm_scripts_dir)
     # make the network script executable
-    for i in listdir(scripts):
-        if isfile(join(scripts, i)):
-            chmod(join(scripts, i), 0755)
-    if isdir(configs):
-        rmtree(configs)
-    copytree("config", configs)
-    if not isdir(domains):
-        mkdir(domains)
+    for i in os.listdir(path.kvm_scripts_dir):
+        if os.path.isfile(os.path.join(path.kvm_scripts_dir, i)):
+            os.chmod(os.path.join(path.kvm_scripts_dir, i), 0755)
+    if os.path.isdir(path.kvm_config_dir):
+        rmtree(path.kvm_config_dir)
+    copytree("config", path.kvm_config_dir)
+    os.chmod(path.kvm_config_dir, 0755)
+    if not os.path.isdir(path.kvm_domains_dir):
+        os.mkdir(self.kvm_domains_dir)
+    os.chmod(path.kvm_domains_dir, 0755)
     copy("domains/example", example)
-    if not isdir(auto):
-        mkdir(auto)
+    if not os.path.isdir(path.kvm_auto_dir):
+        os.mkdir(path.kvm_auto_dir)
+    os.chmod(path.kvm_auto_dir, 0755)
 
 if os.getuid() != 0:
     print "Script need root user rights to install."
     print "Change user to root user or use sudo."
     sys.exit(1)
 
-files = [join("bin", i) for i in listdir("bin")]
-dirs = [join("kvmtools", i) for i in listdir("kvmtools") if isdir(join("kvmtools",i))]
+files = [os.path.join("bin", i) for i in os.listdir("bin")]
+dirs = [os.path.join("kvmtools", i) for i in os.listdir("kvmtools") if os.path.isdir(os.path.join("kvmtools",i))]
 dirs.append("kvmtools")
 
 setup(