def __call__(self, parser, namespace, values, option_string=None):
try:
value = {
'2m': '256KB',
'4m': '512KB',
'8m': '1MB',
'16m': '2MB',
'32m': '4MB',
'16m-c1': '2MB-c1',
'32m-c1': '4MB-c1',
'32m-c2': '4MB-c2'
}[values[0]]
print("WARNING: Flash size arguments in megabits like '%s' are deprecated." % (values[0]))
print("Please use the equivalent size '%s'." % (value))
print("Megabit arguments may be removed in a future release.")
except KeyError:
value = values[0]
known_sizes = dict(ESP8266ROM.FLASH_SIZES)
known_sizes.update(ESP32ROM.FLASH_SIZES)
if self._auto_detect:
known_sizes['detect'] = 'detect'
if value not in known_sizes:
raise argparse.ArgumentError(self, '%s is not a known flash size. Known sizes: %s' % (value, ", ".join(known_sizes.keys())))
setattr(namespace, self.dest, value)
python类ArgumentError()的实例源码
def __call__(self, parser, namespace, values, option_string=None):
# validate pair arguments
pairs = []
for i in range(0,len(values),2):
try:
address = int(values[i],0)
except ValueError as e:
raise argparse.ArgumentError(self,'Address "%s" must be a number' % values[i])
try:
argfile = open(values[i + 1], 'rb')
except IOError as e:
raise argparse.ArgumentError(self, e)
except IndexError:
raise argparse.ArgumentError(self,'Must be pairs of an address and the binary filename to write there')
pairs.append((address, argfile))
setattr(namespace, self.dest, pairs)
# Binary stub code (see flasher_stub dir for source & details)
def __call__(self, parser, namespace, values, option_string=None):
# validate pair arguments
pairs = []
for i in range(0,len(values),2):
try:
address = int(values[i],0)
except ValueError as e:
raise argparse.ArgumentError(self,'Address "%s" must be a number' % values[i])
try:
argfile = open(values[i + 1], 'rb')
except IOError as e:
raise argparse.ArgumentError(self, e)
except IndexError:
raise argparse.ArgumentError(self,'Must be pairs of an address and the binary filename to write there')
pairs.append((address, argfile))
setattr(namespace, self.dest, pairs)
# This is "wrapped" stub_flasher.c, to be loaded using run_stub.
def _parse(self, args):
'''
'''
self.pre_parse(args)
self.parser.parse_args(args[1:], self.params)
try:
self.post_parse()
except argparse.ArgumentError, e:
self.parser.error(str(e))
def __call__(self, parser, namespace, values, option_string=None):
try:
value = {
'2m': '256KB',
'4m': '512KB',
'8m': '1MB',
'16m': '2MB',
'32m': '4MB',
'16m-c1': '2MB-c1',
'32m-c1': '4MB-c1',
}[values[0]]
print("WARNING: Flash size arguments in megabits like '%s' are deprecated." % (values[0]))
print("Please use the equivalent size '%s'." % (value))
print("Megabit arguments may be removed in a future release.")
except KeyError:
value = values[0]
known_sizes = dict(ESP8266ROM.FLASH_SIZES)
known_sizes.update(ESP32ROM.FLASH_SIZES)
if self._auto_detect:
known_sizes['detect'] = 'detect'
if value not in known_sizes:
raise argparse.ArgumentError(self, '%s is not a known flash size. Known sizes: %s' % (value, ", ".join(known_sizes.keys())))
setattr(namespace, self.dest, value)
def __call__(self, parser, namespace, value, option_string=None):
if value.upper() == "SPI":
value = 0
elif value.upper() == "HSPI":
value = 1
elif "," in value:
values = value.split(",")
if len(values) != 5:
raise argparse.ArgumentError(self, '%s is not a valid list of comma-separate pin numbers. Must be 5 numbers - CLK,Q,D,HD,CS.' % value)
try:
values = tuple(int(v,0) for v in values)
except ValueError:
raise argparse.ArgumentError(self, '%s is not a valid argument. All pins must be numeric values' % values)
if any([v for v in values if v > 33 or v < 0]):
raise argparse.ArgumentError(self, 'Pin numbers must be in the range 0-33.')
# encode the pin numbers as a 32-bit integer with packed 6-bit values, the same way ESP32 ROM takes them
# TODO: make this less ESP32 ROM specific somehow...
clk,q,d,hd,cs = values
value = (hd << 24) | (cs << 18) | (d << 12) | (q << 6) | clk
else:
raise argparse.ArgumentError(self, '%s is not a valid spi-connection value. ' +
'Values are SPI, HSPI, or a sequence of 5 pin numbers CLK,Q,D,HD,CS).' % value)
setattr(namespace, self.dest, value)
def main(argv):
parser = argparse.ArgumentParser(description='Prototype 2 of the Autonomous self-replicating code.')
try:
parser.add_argument('-t', '--usetestserver', help='circumvent dna and use testserver defined in settings.json')
parser.add_argument('-x', '--exitnode', help='Enable the agents\' Tribler Exit Node functionality')
parser.add_help = True
args = parser.parse_args(argv)
except argparse.ArgumentError:
parser.print_help()
sys.exit(2)
#return whether -as boolean- the set value, return default if not set
#defaults are development mode equivalent
usetestserver = False if args.usetestserver in ['False', 'false'] else True
exitnode = True if args.exitnode in ['True', 'true'] else False
Prototype2(exitnode, usetestserver)
def __call__(self, parser, namespace, values, option_string=None):
range = values.split(':')
if len(range) == 0:
# Nothing passed, return a zero default
setattr(namespace, self.dest, (0, 0))
elif len(range) == 1:
# Only a single value is present
setattr(namespace, self.dest, (int(range[0]), int(range[0])))
elif len(range) == 2:
# Range of two values
if int(range[0]) <= int(range[1]):
setattr(namespace, self.dest, (int(range[0]), int(range[1])))
else:
msg = _("Invalid range, %(min)s is not less than %(max)s")
raise argparse.ArgumentError(self, msg % {
'min': range[0],
'max': range[1],
})
else:
# Too many values
msg = _("Invalid range, too many values")
raise argparse.ArgumentError(self, msg)
def _check_value(self, action, value):
"""
It's probably not a great idea to override a "hidden" method
but the default behavior is pretty ugly and there doesn't
seem to be any other way to change it.
"""
# converted value must be one of the choices (if specified)
if action.choices is not None and value not in action.choices:
msg = ['Invalid choice, valid choices are:\n']
for i in range(len(action.choices))[::self.ChoicesPerLine]:
current = []
for choice in action.choices[i:i+self.ChoicesPerLine]:
current.append('%-40s' % choice)
msg.append(' | '.join(current))
possible = get_close_matches(value, action.choices, cutoff=0.8)
if possible:
extra = ['\n\nInvalid choice: %r, maybe you meant:\n' % value]
for word in possible:
extra.append(' * %s' % word)
msg.extend(extra)
raise argparse.ArgumentError(action, '\n'.join(msg))
def __call__(self, parser, namespace, value, option_string=None):
pieces = value.split('-')
if not (0 < len(pieces) <= 3):
raise argparse.ArgumentError("wrong syntax in IntsRange with {}"
.format(value))
try:
if len(pieces) == 1:
self.result.append(int(pieces[0]))
elif len(pieces) == 2:
a, b = (int(x) for x in pieces)
self.result += list(range(a, b+1))
else:
a, b, c = (int(x) for x in pieces)
self.result += list(range(a, b+1, c))
self.result = sorted(set(self.result))
except ValueError as e:
raise argparse.ArgumentTypeError(value, "IntsRange requires integers")
setattr(namespace, self.dest, self.result)
#################### unit test
def __call__(self, parser, namespace, values, option_string=None):
# validate pair arguments
pairs = []
for i in range(0,len(values),2):
try:
address = int(values[i],0)
except ValueError as e:
raise argparse.ArgumentError(self,'Address "%s" must be a number' % values[i])
try:
argfile = open(values[i + 1], 'rb')
except IOError as e:
raise argparse.ArgumentError(self, e)
except IndexError:
raise argparse.ArgumentError(self,'Must be pairs of an address and the binary filename to write there')
pairs.append((address, argfile))
setattr(namespace, self.dest, pairs)
# This is "wrapped" stub_flasher.c, to be loaded using run_stub.
def parse_command_line(self, parser):
try:
if parser is not None:
mutually_exclusive_group = parser.add_mutually_exclusive_group()
mutually_exclusive_group.add_argument('--rude', '-rude', action='store_true', default=False, dest='rude',
help='Return something rude')
results = parser.parse_args()
if results.rude is True:
ACLogger.log_and_print("ACBase ... print rude words")
except argparse.ArgumentError as e:
s = 'ACBase: During processing, caught an unknown exception. type: %s ; args: %s ; message: %s' % (
type(e), repr(e.args), e.message)
ACLogger.log_and_print_error(s)
self.set_container_status(CONTAINER_STATUS_ERROR)
return False
except Exception as e:
s = 'ACBase: During processing, caught an unknown exception: %s %s' % (type(e), e.args)
ACLogger.log_and_print_error(s)
self.set_container_status(CONTAINER_STATUS_ERROR)
return False
return True
def _do_call(
self, string, delim=",", data_type=None, choices=None,
min_len=None, max_len=None):
if isinstance(string, str):
vals = string.split(delim) if delim else (string,)
else:
vals = string
if vals[0] == "*" and choices is not None:
vals = choices
if data_type:
vals = [data_type(v) for v in vals]
if min_len and len(vals) < min_len:
raise ArgumentError(
self, "there must be at least {} values".format(min_len))
if max_len and len(vals) > max_len:
raise ArgumentError(
self, "there can be at most {} values".format(max_len))
return vals
def __call__(self, parser, namespace, values, option_string=None):
try:
value = {
'2m': '256KB',
'4m': '512KB',
'8m': '1MB',
'16m': '2MB',
'32m': '4MB',
'16m-c1': '2MB-c1',
'32m-c1': '4MB-c1',
'32m-c2': '4MB-c2'
}[values[0]]
print("WARNING: Flash size arguments in megabits like '%s' are deprecated." % (values[0]))
print("Please use the equivalent size '%s'." % (value))
print("Megabit arguments may be removed in a future release.")
except KeyError:
value = values[0]
known_sizes = dict(ESP8266ROM.FLASH_SIZES)
known_sizes.update(ESP32ROM.FLASH_SIZES)
if self._auto_detect:
known_sizes['detect'] = 'detect'
if value not in known_sizes:
raise argparse.ArgumentError(self, '%s is not a known flash size. Known sizes: %s' % (value, ", ".join(known_sizes.keys())))
setattr(namespace, self.dest, value)
def __call__(self, parser, namespace, values, option_string=None):
# validate pair arguments
pairs = []
for i in range(0,len(values),2):
try:
address = int(values[i],0)
except ValueError as e:
raise argparse.ArgumentError(self,'Address "%s" must be a number' % values[i])
try:
argfile = open(values[i + 1], 'rb')
except IOError as e:
raise argparse.ArgumentError(self, e)
except IndexError:
raise argparse.ArgumentError(self,'Must be pairs of an address and the binary filename to write there')
pairs.append((address, argfile))
setattr(namespace, self.dest, pairs)
# Binary stub code (see flasher_stub dir for source & details)
def __call__(self, parser, namespace, values, option_string=None):
range = values.split(':')
if len(range) == 0:
# Nothing passed, return a zero default
setattr(namespace, self.dest, (0, 0))
elif len(range) == 1:
# Only a single value is present
setattr(namespace, self.dest, (int(range[0]), int(range[0])))
elif len(range) == 2:
# Range of two values
if int(range[0]) <= int(range[1]):
setattr(namespace, self.dest, (int(range[0]), int(range[1])))
else:
msg = "Invalid range, %s is not less than %s" % \
(range[0], range[1])
raise argparse.ArgumentError(self, msg)
else:
# Too many values
msg = "Invalid range, too many values"
raise argparse.ArgumentError(self, msg)
def validate_cert(namespace):
params = [namespace.cert_data, namespace.cert_password]
if all([not x for x in params]):
# no cert supplied -- use HTTP
if not namespace.frontend_port:
namespace.frontend_port = 80
else:
# cert supplied -- use HTTPS
if not all(params):
raise argparse.ArgumentError(
None, 'To use SSL certificate, you must specify both the filename and password')
# extract the certificate data from the provided file
namespace.cert_data = read_base_64_file(namespace.cert_data)
try:
# change default to frontend port 443 for https
if not namespace.frontend_port:
namespace.frontend_port = 443
except AttributeError:
# app-gateway ssl-cert create does not have these fields and that is okay
pass
def __call__(self, parser, namespace, values, option_string=None):
stagename = values[0]
f = os.path.abspath(values[1])
d = os.path.abspath(values[2])
if stagename not in self.stagenames:
raise argparse.ArgumentError(self,
"%s not a valid stage, must be one of %s" %
(stagename, str(self.stagenames)))
if self.dest == 'importpolicy':
setattr(namespace, "doimport", True)
for s in self.stagenames:
if s == stagename:
getattr(namespace, self.dest)[s] = (f, d)
else:
if s not in getattr(namespace, self.dest).iterkeys():
getattr(namespace, self.dest)[s] = self.sdefaults[s]
def __init__(self, option_strings, nargs=1, dest='vmnames', help=None,
**kwargs):
if help is None:
if nargs == argparse.OPTIONAL:
help = 'at most one domain name'
elif nargs == 1:
help = 'a domain name'
elif nargs == argparse.ZERO_OR_MORE:
help = 'zero or more domain names'
elif nargs == argparse.ONE_OR_MORE:
help = 'one or more domain names'
elif nargs > 1:
help = '%s domain names' % nargs
else:
raise argparse.ArgumentError(
nargs, "Passed unexpected value {!s} as {!s} nargs ".format(
nargs, dest))
super(VmNameAction, self).__init__(option_strings, dest=dest, help=help,
nargs=nargs, **kwargs)
def __init__(self, option_strings, nargs=1, dest='vmnames', help=None,
**kwargs):
# pylint: disable=redefined-builtin
if help is None:
if nargs == argparse.OPTIONAL:
help = 'at most one running domain'
elif nargs == 1:
help = 'running domain name'
elif nargs == argparse.ZERO_OR_MORE:
help = 'zero or more running domains'
elif nargs == argparse.ONE_OR_MORE:
help = 'one or more running domains'
elif nargs > 1:
help = '%s running domains' % nargs
else:
raise argparse.ArgumentError(
nargs, "Passed unexpected value {!s} as {!s} nargs ".format(
nargs, dest))
super(RunningVmNameAction, self).__init__(
option_strings, dest=dest, help=help, nargs=nargs, **kwargs)
def __call__(self, parser, namespace, values, option_string=None):
# validate pair arguments
pairs = []
for i in range(0,len(values),2):
try:
address = int(values[i],0)
except ValueError as e:
raise argparse.ArgumentError(self,'Address "%s" must be a number' % values[i])
try:
argfile = open(values[i + 1], 'rb')
except IOError as e:
raise argparse.ArgumentError(self, e)
except IndexError:
raise argparse.ArgumentError(self,'Must be pairs of an address and the binary filename to write there')
pairs.append((address, argfile))
setattr(namespace, self.dest, pairs)
# This is "wrapped" stub_flasher.c, to be loaded using run_stub.
def parse_int(self, value):
# Support suffixes
multiplier = 1
m = re.search("(.*)(Mb|mb|kb|m|M|k|g|G|Gb)", value)
if m:
value = m.group(1)
suffix = m.group(2).lower()
if suffix in ("gb", "g"):
multiplier = 1024 * 1024 * 1024
elif suffix in ("mb", "m"):
multiplier = 1024 * 1024
elif suffix in ("kb", "k"):
multiplier = 1024
try:
if value.startswith("0x"):
value = int(value, 16) * multiplier
else:
value = int(value) * multiplier
except ValueError:
raise argparse.ArgumentError(self, "Invalid integer value")
return value
def __call__(self, parser, namespace, values, option_string=None):
values = values.split(':')
level, logger = values if len(values) > 1 else (values[0],
self.main_logger)
logger = logging.getLogger(logger)
try:
logger.setLevel(logging._levelNames[level.upper()])
except KeyError:
msg = "invalid level choice: %s (choose from %s)" % \
(level, parser.log_levels)
raise argparse.ArgumentError(self, msg)
super(LoggingAction, self).__call__(parser, namespace, values,
option_string)
def __call__(self, parser, namespace, values, option_string=None):
try:
value = {
'2m': '256KB',
'4m': '512KB',
'8m': '1MB',
'16m': '2MB',
'32m': '4MB',
'16m-c1': '2MB-c1',
'32m-c1': '4MB-c1',
}[values[0]]
print("WARNING: Flash size arguments in megabits like '%s' are deprecated." % (values[0]))
print("Please use the equivalent size '%s'." % (value))
print("Megabit arguments may be removed in a future release.")
except KeyError:
value = values[0]
known_sizes = dict(ESP8266ROM.FLASH_SIZES)
known_sizes.update(ESP32ROM.FLASH_SIZES)
if self._auto_detect:
known_sizes['detect'] = 'detect'
if value not in known_sizes:
raise argparse.ArgumentError(self, '%s is not a known flash size. Known sizes: %s' % (value, ", ".join(known_sizes.keys())))
setattr(namespace, self.dest, value)
def __call__(self, parser, namespace, value, option_string=None):
if value.upper() == "SPI":
value = 0
elif value.upper() == "HSPI":
value = 1
elif "," in value:
values = value.split(",")
if len(values) != 5:
raise argparse.ArgumentError(self, '%s is not a valid list of comma-separate pin numbers. Must be 5 numbers - CLK,Q,D,HD,CS.' % value)
try:
values = tuple(int(v,0) for v in values)
except ValueError:
raise argparse.ArgumentError(self, '%s is not a valid argument. All pins must be numeric values' % values)
if any([v for v in values if v > 33 or v < 0]):
raise argparse.ArgumentError(self, 'Pin numbers must be in the range 0-33.')
# encode the pin numbers as a 32-bit integer with packed 6-bit values, the same way ESP32 ROM takes them
# TODO: make this less ESP32 ROM specific somehow...
clk,q,d,hd,cs = values
value = (hd << 24) | (cs << 18) | (d << 12) | (q << 6) | clk
else:
raise argparse.ArgumentError(self, '%s is not a valid spi-connection value. ' +
'Values are SPI, HSPI, or a sequence of 5 pin numbers CLK,Q,D,HD,CS).' % values)
setattr(namespace, self.dest, value)
def cli():
try:
parser = get_parser(all_commands())
unknown = None
args, unknown = parser.parse_known_args()
set_cmd_env(args.env)
if args.parse_unknown:
args.func(args, unknown)
else:
args = parser.parse_args()
args.func(args)
except (argparse.ArgumentTypeError, argparse.ArgumentError) as exc:
if os.getenv("APPR_DEBUG", "false") == "true":
raise
else:
parser.error(exc.message)
def __call__(self, parser, namespace, values, option_string=None):
# extract the path to our data, and the label for the legend
datapath = os.path.abspath(os.path.expanduser(values[0]))
label = values[1]
# check the path exists
if not os.path.exists(datapath): raise argparse.ArgumentError(self, "The supplied path to the plot data does not exist: '{0}'".format(datapath))
# remove the default
if "_didremovedefault" not in namespace:
setattr(namespace, self.dest, [])
setattr(namespace, "_didremovedefault", True)
# append out new experiment path
dest = getattr(namespace, self.dest)
dest.append((datapath, label))
def __call__(self, parser, namespace, values, option_string=None):
if not hasattr(namespace, 'props'):
namespace.props = []
try:
obj_id, prop_name, value = values.split(':')
except:
raise argparse.ArgumentError(self, "could not parse '%s'" % values)
try:
obj_id = int(obj_id)
except ValueError:
raise argparse.ArgumentError(self, "obj_id=%s is not an int" % obj_id)
namespace.props.append([obj_id, prop_name, value])
def add_cmdline_args(argparser):
RemoteAgentAgent.add_cmdline_args(argparser)
try:
ParsedRemoteAgent.dictionary_class().add_cmdline_args(argparser)
except argparse.ArgumentError:
# don't freak out if the dictionary has already been added
pass
def __call__(self, parser, namespace, values, option_string=None):
values = values.split(':')
level, logger = values if len(values) > 1 else (values[0],
self.main_logger)
logger = logging.getLogger(logger)
try:
logger.setLevel(logging._nameToLevel[level.upper()])
except KeyError:
msg = "invalid level choice: %s (choose from %s)" % \
(level, parser.log_levels)
raise argparse.ArgumentError(self, msg)
super(LoggingAction, self).__call__(parser, namespace, values,
option_string)
