def _SetToArg(action, suffix, arg_r, out):
# type: (SetToArgAction, Optional[str], Reader, _Attributes) -> bool
"""
Perform the action.
"""
if suffix: # for the ',' in -d,
arg = suffix
else:
arg_r.Next()
arg = arg_r.Peek()
if arg is None:
e_usage('expected argument to %r' % ('-' + action.name),
span_id=arg_r.SpanId())
# e.g. spec.LongFlag('--format', ['text', 'html'])
# Should change to arg.Enum([...])
with tagswitch(action.flag_type) as case:
if case(flag_type_e.Enum):
alts = cast(flag_type__Enum, action.flag_type).alts
if arg not in alts:
e_usage('got invalid argument %r to %r, expected one of: %s' %
(arg, ('-' + action.name), ', '.join(alts)),
span_id=arg_r.SpanId())
val = value.Str(arg) # type: value_t
elif case(flag_type_e.Str):
val = value.Str(arg)
elif case(flag_type_e.Int):
try:
i = int(arg)
except ValueError:
e_usage('expected integer after %s, got %r' %
('-' + action.name, arg),
span_id=arg_r.SpanId())
# So far all our int values are > 0, so use -1 as the 'unset' value
if i < 0:
e_usage('got invalid integer for %s: %s' %
('-' + action.name, arg),
span_id=arg_r.SpanId())
val = value.Int(i)
elif case(flag_type_e.Float):
try:
val = value.Float(float(arg))
except ValueError:
e_usage('expected number after %r, got %r' %
('-' + action.name, arg),
span_id=arg_r.SpanId())
else:
raise AssertionError()
out.Set(action.name, val)
return action.quit_parsing_flags
def _Value(self, arg, span_id):
# type: (str, int) -> value_t
try:
f = float(arg)
except ValueError:
e_usage('expected number after %r, got %r' %
('-' + self.name, arg),
span_id=span_id)
# So far all our float values are > 0, so use -1.0 as the 'unset' value
# corner case: this treats -0.0 as 0.0!
if f < 0:
e_usage('got invalid float for %s: %s' % ('-' + self.name, arg),
span_id=span_id)
return value.Float(f)
def OnMatch(self, prefix, suffix, arg_r, out):
# type: (Optional[str], Optional[str], Reader, _Attributes) -> bool
"""Called when the flag matches."""
if suffix: # for the ',' in -d,
arg = suffix
else:
arg_r.Next()
arg = arg_r.Peek()
if arg is None:
e_usage('expected argument to %r' % ('-' + self.name),
span_id=arg_r.SpanId())
# e.g. spec.LongFlag('--format', ['text', 'html'])
# Should change to arg.Enum([...])
with tagswitch(self.flag_type) as case:
if case(flag_type_e.Enum):
alts = cast(flag_type__Enum, self.flag_type).alts
if arg not in alts:
e_usage(
'got invalid argument %r to %r, expected one of: %s' %
(arg, ('-' + self.name), ', '.join(alts)),
span_id=arg_r.SpanId())
val = value.Str(arg) # type: value_t
elif case(flag_type_e.Str):
val = value.Str(arg)
elif case(flag_type_e.Int):
try:
val = value.Int(int(arg))
except ValueError:
e_usage('expected integer after %r, got %r' %
('-' + self.name, arg),
span_id=arg_r.SpanId())
elif case(flag_type_e.Float):
try:
val = value.Float(float(arg))
except ValueError:
e_usage('expected number after %r, got %r' %
('-' + self.name, arg),
span_id=arg_r.SpanId())
else:
raise AssertionError()
out.Set(self.name, val)
return self.quit_parsing_flags
def PyToValue(py_val):
# type: (Any) -> value_t
if py_val is None:
val = value.Undef() # type: value_t
elif isinstance(py_val, bool):
val = value.Bool(py_val)
elif isinstance(py_val, int):
val = value.Int(py_val)
elif isinstance(py_val, float):
val = value.Float() # TODO: ASDL needs float primitive
elif isinstance(py_val, str):
val = value.Str(py_val)
else:
raise AssertionError(py_val)
return val
def ShortFlag(self, short_name, arg_type=None, help=None):
# type: (str, Optional[int], Optional[str]) -> None
"""
This is very similar to ShortFlag for FlagSpecAndMore, except we have
separate arity0 and arity1 dicts.
"""
assert short_name.startswith('-'), short_name
assert len(short_name) == 2, short_name
char = short_name[1]
if arg_type is None:
self.arity0[char] = True
else:
self.arity1[char] = args.SetToArg(char, _FlagType(arg_type))
# TODO: callers should pass flag_type
if arg_type is None:
typ = flag_type.Bool() # type: flag_type_t
default = value.Bool(False) # type: value_t
elif arg_type == args.Int:
typ = flag_type.Int()
default = value.Int(-1)
elif arg_type == args.Float:
typ = flag_type.Float()
default = value.Float(0.0)
elif arg_type == args.String:
typ = flag_type.Str()
default = value.Str('')
elif isinstance(arg_type, list):
typ = flag_type.Enum(arg_type)
default = value.Str('') # This isn't valid
else:
raise AssertionError(arg_type)
if self.typed:
self.defaults[char] = default
else:
# TODO: remove when all builtins converted
self.defaults[char] = value.Undef()
self.fields[char] = typ
def _Default(arg_type, arg_default=None):
# type: (Union[None, int, List[str]], Optional[str]) -> value_t
# for enum or string
# note: not using this for integers yet
if arg_default is not None:
return value.Str(arg_default) # early return
if arg_type is None:
default = value.Bool(False) # type: value_t
elif arg_type == args.Int:
default = value.Int(-1) # positive values aren't allowed now
elif arg_type == args.Float:
default = value.Float(0.0)
elif arg_type == args.String:
default = value.Undef() # e.g. read -d '' is NOT the default
elif isinstance(arg_type, list):
default = value.Str('') # This isn't valid
else:
raise AssertionError(arg_type)
return default