argo_navis: venv/lib/python2.7/site-packages/click/parser.py comparison

comparison venv/lib/python2.7/site-packages/click/parser.py @ 0:d67268158946 draft

planemo upload commit a3f181f5f126803c654b3a66dd4e83a48f7e203b

author	bcclaywell
date	Mon, 12 Oct 2015 17:43:33 -0400
parents
children

comparison

equal deleted inserted replaced

--1:000000000000
+:d67268158946
+# -*- coding: utf-8 -*-
+"""
+click.parser
+~~~~~~~~~~~~
+This module started out as largely a copy paste from the stdlib's
+optparse module with the features removed that we do not need from
+optparse because we implement them in Click on a higher level (for
+instance type handling, help formatting and a lot more).
+The plan is to remove more and more from here over time.
+The reason this is a different module and not optparse from the stdlib
+is that there are differences in 2.x and 3.x about the error messages
+generated and optparse in the stdlib uses gettext for no good reason
+and might cause us issues.
+"""
+import re
+from .exceptions import UsageError, NoSuchOption, BadOptionUsage
+from .utils import unpack_args
+def _error_args(nargs, opt):
+if nargs == 1:
+raise BadOptionUsage(opt, '%s option requires an argument' % opt)
+raise BadOptionUsage(opt, '%s option requires %d arguments' % (opt, nargs))
+def split_opt(opt):
+first = opt[:1]
+if first.isalnum():
+return '', opt
+if opt[1:2] == first:
+return opt[:2], opt[2:]
+return first, opt[1:]
+def normalize_opt(opt, ctx):
+if ctx is None or ctx.token_normalize_func is None:
+return opt
+prefix, opt = split_opt(opt)
+return prefix + ctx.token_normalize_func(opt)
+def split_arg_string(string):
+"""Given an argument string this attempts to split it into small parts."""
+rv = []
+for match in re.finditer(r"('([^'\\]*(?:\\.[^'\\]*)*)'"
+r'|"([^"\\]*(?:\\.[^"\\]*)*)"'
+r'|\S+)\s*', string, re.S):
+arg = match.group().strip()
+if arg[:1] == arg[-1:] and arg[:1] in '"\'':
+arg = arg[1:-1].encode('ascii', 'backslashreplace') \
+.decode('unicode-escape')
+try:
+arg = type(string)(arg)
+except UnicodeError:
+pass
+rv.append(arg)
+return rv
+class Option(object):
+def __init__(self, opts, dest, action=None, nargs=1, const=None, obj=None):
+self._short_opts = []
+self._long_opts = []
+self.prefixes = set()
+for opt in opts:
+prefix, value = split_opt(opt)
+if not prefix:
+raise ValueError('Invalid start character for option (%s)'
+% opt)
+self.prefixes.add(prefix[0])
+if len(prefix) == 1 and len(value) == 1:
+self._short_opts.append(opt)
+else:
+self._long_opts.append(opt)
+self.prefixes.add(prefix)
+if action is None:
+action = 'store'
+self.dest = dest
+self.action = action
+self.nargs = nargs
+self.const = const
+self.obj = obj
+@property
+def takes_value(self):
+return self.action in ('store', 'append')
+def process(self, value, state):
+if self.action == 'store':
+state.opts[self.dest] = value
+elif self.action == 'store_const':
+state.opts[self.dest] = self.const
+elif self.action == 'append':
+state.opts.setdefault(self.dest, []).append(value)
+elif self.action == 'append_const':
+state.opts.setdefault(self.dest, []).append(self.const)
+elif self.action == 'count':
+state.opts[self.dest] = state.opts.get(self.dest, 0) + 1
+else:
+raise ValueError('unknown action %r' % self.action)
+state.order.append(self.obj)
+class Argument(object):
+def __init__(self, dest, nargs=1, obj=None):
+self.dest = dest
+self.nargs = nargs
+self.obj = obj
+def process(self, value, state):
+state.opts[self.dest] = value
+state.order.append(self.obj)
+class ParsingState(object):
+def __init__(self, rargs):
+self.opts = {}
+self.largs = []
+self.rargs = rargs
+self.order = []
+class OptionParser(object):
+"""The option parser is an internal class that is ultimately used to
+parse options and arguments.  It's modelled after optparse and brings
+a similar but vastly simplified API.  It should generally not be used
+directly as the high level Click classes wrap it for you.
+It's not nearly as extensible as optparse or argparse as it does not
+implement features that are implemented on a higher level (such as
+types or defaults).
+:param ctx: optionally the :class:`~click.Context` where this parser
+should go with.
+"""
+def __init__(self, ctx=None):
+#: The :class:`~click.Context` for this parser.  This might be
+#: `None` for some advanced use cases.
+self.ctx = ctx
+#: This controls how the parser deals with interspersed arguments.
+#: If this is set to `False`, the parser will stop on the first
+#: non-option.  Click uses this to implement nested subcommands
+#: safely.
+self.allow_interspersed_args = True
+#: This tells the parser how to deal with unknown options.  By
+#: default it will error out (which is sensible), but there is a
+#: second mode where it will ignore it and continue processing
+#: after shifting all the unknown options into the resulting args.
+self.ignore_unknown_options = False
+if ctx is not None:
+self.allow_interspersed_args = ctx.allow_interspersed_args
+self.ignore_unknown_options = ctx.ignore_unknown_options
+self._short_opt = {}
+self._long_opt = {}
+self._opt_prefixes = set(['-', '--'])
+self._args = []
+def add_option(self, opts, dest, action=None, nargs=1, const=None,
+obj=None):
+"""Adds a new option named `dest` to the parser.  The destination
+is not inferred (unlike with optparse) and needs to be explicitly
+provided.  Action can be any of ``store``, ``store_const``,
+``append``, ``appnd_const`` or ``count``.
+The `obj` can be used to identify the option in the order list
+that is returned from the parser.
+"""
+if obj is None:
+obj = dest
+opts = [normalize_opt(opt, self.ctx) for opt in opts]
+option = Option(opts, dest, action=action, nargs=nargs,
+const=const, obj=obj)
+self._opt_prefixes.update(option.prefixes)
+for opt in option._short_opts:
+self._short_opt[opt] = option
+for opt in option._long_opts:
+self._long_opt[opt] = option
+def add_argument(self, dest, nargs=1, obj=None):
+"""Adds a positional argument named `dest` to the parser.
+The `obj` can be used to identify the option in the order list
+that is returned from the parser.
+"""
+if obj is None:
+obj = dest
+self._args.append(Argument(dest=dest, nargs=nargs, obj=obj))
+def parse_args(self, args):
+"""Parses positional arguments and returns ``(values, args, order)``
+for the parsed options and arguments as well as the leftover
+arguments if there are any.  The order is a list of objects as they
+appear on the command line.  If arguments appear multiple times they
+will be memorized multiple times as well.
+"""
+state = ParsingState(args)
+try:
+self._process_args_for_options(state)
+self._process_args_for_args(state)
+except UsageError:
+if self.ctx is None or not self.ctx.resilient_parsing:
+raise
+return state.opts, state.largs, state.order
+def _process_args_for_args(self, state):
+pargs, args = unpack_args(state.largs + state.rargs,
+[x.nargs for x in self._args])
+for idx, arg in enumerate(self._args):
+arg.process(pargs[idx], state)
+state.largs = args
+state.rargs = []
+def _process_args_for_options(self, state):
+while state.rargs:
+arg = state.rargs.pop(0)
+arglen = len(arg)
+# Double dashes always handled explicitly regardless of what
+# prefixes are valid.
+if arg == '--':
+return
+elif arg[:1] in self._opt_prefixes and arglen > 1:
+self._process_opts(arg, state)
+elif self.allow_interspersed_args:
+state.largs.append(arg)
+else:
+state.rargs.insert(0, arg)
+return
+# Say this is the original argument list:
+# [arg0, arg1, ..., arg(i-1), arg(i), arg(i+1), ..., arg(N-1)]
+#                            ^
+# (we are about to process arg(i)).
+#
+# Then rargs is [arg(i), ..., arg(N-1)] and largs is a *subset* of
+# [arg0, ..., arg(i-1)] (any options and their arguments will have
+# been removed from largs).
+#
+# The while loop will usually consume 1 or more arguments per pass.
+# If it consumes 1 (eg. arg is an option that takes no arguments),
+# then after _process_arg() is done the situation is:
+#
+#   largs = subset of [arg0, ..., arg(i)]
+#   rargs = [arg(i+1), ..., arg(N-1)]
+#
+# If allow_interspersed_args is false, largs will always be
+# *empty* -- still a subset of [arg0, ..., arg(i-1)], but
+# not a very interesting subset!
+def _match_long_opt(self, opt, explicit_value, state):
+if opt not in self._long_opt:
+possibilities = [word for word in self._long_opt
+if word.startswith(opt)]
+raise NoSuchOption(opt, possibilities=possibilities)
+option = self._long_opt[opt]
+if option.takes_value:
+# At this point it's safe to modify rargs by injecting the
+# explicit value, because no exception is raised in this
+# branch.  This means that the inserted value will be fully
+# consumed.
+if explicit_value is not None:
+state.rargs.insert(0, explicit_value)
+nargs = option.nargs
+if len(state.rargs) < nargs:
+_error_args(nargs, opt)
+elif nargs == 1:
+value = state.rargs.pop(0)
+else:
+value = tuple(state.rargs[:nargs])
+del state.rargs[:nargs]
+elif explicit_value is not None:
+raise BadOptionUsage(opt, '%s option does not take a value' % opt)
+else:
+value = None
+option.process(value, state)
+def _match_short_opt(self, arg, state):
+stop = False
+i = 1
+prefix = arg[0]
+unknown_options = []
+for ch in arg[1:]:
+opt = normalize_opt(prefix + ch, self.ctx)
+option = self._short_opt.get(opt)
+i += 1
+if not option:
+if self.ignore_unknown_options:
+unknown_options.append(ch)
+continue
+raise NoSuchOption(opt)
+if option.takes_value:
+# Any characters left in arg?  Pretend they're the
+# next arg, and stop consuming characters of arg.
+if i < len(arg):
+state.rargs.insert(0, arg[i:])
+stop = True
+nargs = option.nargs
+if len(state.rargs) < nargs:
+_error_args(nargs, opt)
+elif nargs == 1:
+value = state.rargs.pop(0)
+else:
+value = tuple(state.rargs[:nargs])
+del state.rargs[:nargs]
+else:
+value = None
+option.process(value, state)
+if stop:
+break
+# If we got any unknown options we re-combinate the string of the
+# remaining options and re-attach the prefix, then report that
+# to the state as new larg.  This way there is basic combinatorics
+# that can be achieved while still ignoring unknown arguments.
+if self.ignore_unknown_options and unknown_options:
+state.largs.append(prefix + ''.join(unknown_options))
+def _process_opts(self, arg, state):
+explicit_value = None
+# Long option handling happens in two parts.  The first part is
+# supporting explicitly attached values.  In any case, we will try
+# to long match the option first.
+if '=' in arg:
+long_opt, explicit_value = arg.split('=', 1)
+else:
+long_opt = arg
+norm_long_opt = normalize_opt(long_opt, self.ctx)
+# At this point we will match the (assumed) long option through
+# the long option matching code.  Note that this allows options
+# like "-foo" to be matched as long options.
+try:
+self._match_long_opt(norm_long_opt, explicit_value, state)
+except NoSuchOption:
+# At this point the long option matching failed, and we need
+# to try with short options.  However there is a special rule
+# which says, that if we have a two character options prefix
+# (applies to "--foo" for instance), we do not dispatch to the
+# short option code and will instead raise the no option
+# error.
+if arg[:2] not in self._opt_prefixes:
+return self._match_short_opt(arg, state)
+if not self.ignore_unknown_options:
+raise
+state.largs.append(arg)

Mercurial > repos > bcclaywell > argo_navis

comparison venv/lib/python2.7/site-packages/click/parser.py @ 0:d67268158946 draft