# tf.compat.v1.flags.Flag

<br />

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]
> **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.

<br />

<br />

<br />

| ## 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. |

<br />

## Methods

### `flag_type`

    flag_type() -> Text

Returns a str that describes the type of the flag.

> [!NOTE]
> **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.

<br />

<br />

<br />

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

<br />

### `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.