def _set_unknown_flag(self, name, value): """Returns value if setting flag |name| to |value| returned True. Args: name: str, name of the flag to set. value: Value to set. Returns: Flag value on successful call. Raises: UnrecognizedFlagError IllegalFlagValueError """ setter = self.__dict__['__set_unknown'] if setter: try: setter(name, value) return value except (TypeError, ValueError): # Flag value is not valid. raise _exceptions.IllegalFlagValueError( '"{1}" is not valid for --{0}' .format(name, value)) except NameError: # Flag name is not valid. pass raise _exceptions.UnrecognizedFlagError(name, value)
def DEFINE_alias( # pylint: disable=invalid-name name, original_name, flag_values=_flagvalues.FLAGS, module_name=None): """Defines an alias flag for an existing one. Args: name: str, the flag name. original_name: str, the original flag name. flag_values: FlagValues, the FlagValues instance with which the flag will be registered. This should almost never need to be overridden. module_name: A string, the name of the module that defines this flag. Returns: a handle to defined flag. Raises: flags.FlagError: UnrecognizedFlagError: if the referenced flag doesn't exist. DuplicateFlagError: if the alias name has been used by some existing flag. """ if original_name not in flag_values: raise _exceptions.UnrecognizedFlagError(original_name) flag = flag_values[original_name] class _FlagAlias(_flag.Flag): """Overrides Flag class so alias value is copy of original flag value.""" def parse(self, argument): flag.parse(argument) self.present += 1 def _parse_from_default(self, value): # The value was already parsed by the aliased flag, so there is no # need to call the parser on it a second time. # Additionally, because of how MultiFlag parses and merges values, # it isn't possible to delegate to the aliased flag and still get # the correct values. return value @property def value(self): return flag.value @value.setter def value(self, value): flag.value = value help_msg = 'Alias for --%s.' % flag.name # If alias_name has been used, flags.DuplicatedFlag will be raised. return DEFINE_flag( _FlagAlias(flag.parser, flag.serializer, name, flag.default, help_msg, boolean=flag.boolean), flag_values, module_name)
def DEFINE_alias( name, original_name, flag_values=_flagvalues.FLAGS, # pylint: disable=invalid-name module_name=None): """Defines an alias flag for an existing one. Args: name: str, the flag name. original_name: str, the original flag name. flag_values: FlagValues, the FlagValues instance with which the flag will be registered. This should almost never need to be overridden. module_name: A string, the name of the module that defines this flag. Raises: flags.FlagError: UnrecognizedFlagError: if the referenced flag doesn't exist. DuplicateFlagError: if the alias name has been used by some existing flag. """ if original_name not in flag_values: raise _exceptions.UnrecognizedFlagError(original_name) flag = flag_values[original_name] class _Parser(_argument_parser.ArgumentParser): """The parser for the alias flag calls the original flag parser.""" def parse(self, argument): flag.parse(argument) return flag.value class _FlagAlias(_flag.Flag): """Overrides Flag class so alias value is copy of original flag value.""" @property def value(self): return flag.value @value.setter def value(self, value): flag.value = value help_msg = 'Alias for --%s.' % flag.name # If alias_name has been used, flags.DuplicatedFlag will be raised. DEFINE_flag( _FlagAlias(_Parser(), flag.serializer, name, flag.default, help_msg, boolean=flag.boolean), flag_values, module_name)
def __call__(self, argv, known_only=False): """Parses flags from argv; stores parsed flags into this FlagValues object. All unparsed arguments are returned. Args: argv: a tuple/list of strings. known_only: bool, if True, parse and remove known flags; return the rest untouched. Unknown flags specified by --undefok are not returned. Returns: The list of arguments not parsed as options, including argv[0]. Raises: Error: Raised on any parsing error. TypeError: Raised on passing wrong type of arguments. ValueError: Raised on flag value parsing error. """ if _helpers.is_bytes_or_string(argv): raise TypeError( 'argv should be a tuple/list of strings, not bytes or string.') if not argv: raise ValueError( 'argv cannot be an empty list, and must contain the program name as ' 'the first element.') # This pre parses the argv list for --flagfile=<> options. program_name = argv[0] args = self.read_flags_from_files(argv[1:], force_gnu=False) # Parse the arguments. unknown_flags, unparsed_args = self._parse_args(args, known_only) # Handle unknown flags by raising UnrecognizedFlagError. # Note some users depend on us raising this particular error. for name, value in unknown_flags: suggestions = _helpers.get_flag_suggestions(name, list(self)) raise _exceptions.UnrecognizedFlagError(name, value, suggestions=suggestions) self.mark_as_parsed() self._assert_all_validators() return [program_name] + unparsed_args