tf.compat.v1.flags.Flag

Information about a command-line flag.

tf.compat.v1.flags.Flag(
    parser: _argument_parser.ArgumentParser[_T],
    serializer: Optional[_argument_parser.ArgumentSerializer[_T]],
    name: Text,
    default: Union[Optional[_T], Text],
    help_string: Optional[Text],
    short_name: Optional[Text] = None,
    boolean: bool = False,
    allow_override: bool = False,
    allow_override_cpp: bool = False,
    allow_hide_cpp: bool = False,
    allow_overwrite: bool = True,
    allow_using_method_names: bool = False
) -> None

The only public method of a Flag object is :meth:parse, but it is typically only called by a :class:~absl.flags.FlagValues object. The :meth:parse method is a thin wrapper around the :meth:ArgumentParser.parse()<absl.flags.ArgumentParser.parse> method. The parsed value is saved in .value, and the .present attribute is updated. If this flag was already present, an Error is raised.

:meth:parse is also called during __init__ to parse the default value and initialize the .value attribute. This enables other python modules to safely use flags even if the __main__ module neglects to parse the command line arguments. The .present attribute is cleared after __init__ parsing. If the default value is set to None, then the __init__ parsing step is skipped and the .value attribute is initialized to None.

Note: The default value is also presented to the user in the help string, so it is important that it be a legal value for this flag.

Attributes
name	the name for this flag
default	the default value for this flag
default_unparsed	the unparsed default value for this flag.
default_as_str	default value as repr'd string, e.g., "'true'" (or None)
value	the most recent parsed value of this flag set by :meth:parse
help	a help string or None if no help is available
short_name	the single letter alias for this flag (or None)
boolean	if 'true', this flag does not accept arguments
present	true if this flag was parsed from command line flags
parser	an :class:~absl.flags.ArgumentParser object
serializer	an ArgumentSerializer object
allow_override	the flag may be redefined without raising an error, and newly defined flag overrides the old one.
allow_override_cpp	use the flag from C++ if available the flag definition is replaced by the C++ flag after init
allow_hide_cpp	use the Python flag despite having a C++ flag with the same name (ignore the C++ flag)
using_default_value	the flag value has not been set by user
allow_overwrite	the flag may be parsed more than once without raising an error, the last set value will be used
allow_using_method_names	whether this flag can be defined even if it has a name that conflicts with a FlagValues method.
validators	list of the flag validators.

Methods

flag_type

flag_type() -> Text

Returns a str that describes the type of the flag.

Note: we use strings, and not the types.*Type constants because our flags can have more exotic types, e.g., 'comma separated list of strings', 'whitespace separated list of strings', etc.

parse

parse(
    argument: Union[Text, Optional[_T]]
) -> None

Parses string and sets flag value.

Args
argument	str or the correct flag value type, argument to be parsed.

serialize

serialize() -> Text

Serializes the flag.

unparse

unparse() -> None

__bool__

__bool__()

__eq__

__eq__(
    other
)

Return self==value.

__ge__

__ge__(
    other, NotImplemented=NotImplemented
)

Return a >= b. Computed by @total_ordering from (not a < b).

__gt__

__gt__(
    other, NotImplemented=NotImplemented
)

Return a > b. Computed by @total_ordering from (not a < b) and (a != b).

__le__

__le__(
    other, NotImplemented=NotImplemented
)

Return a <= b. Computed by @total_ordering from (a < b) or (a == b).

__lt__

__lt__(
    other
)

Return self<value.