 also decorated with `attr.s`
        / `attrs.define` / and so on!

    Please consider using `attrs.field` in new code (``attr.ib`` will *never*
    go away, though).

    :param default: A value that is used if an *attrs*-generated ``__init__``
        is used and no value is passed while instantiating or the attribute is
        excluded using ``init=False``.

        If the value is an instance of `attrs.Factory`, its callable will be
        used to construct a new value (useful for mutable data types like lists
        or dicts).

        If a default is not set (or set manually to `attrs.NOTHING`), a value
        *must* be supplied when instantiating; otherwise a `TypeError` will be
        raised.

        The default can also be set using decorator notation as shown below.

        .. seealso:: `defaults`

    :param callable factory: Syntactic sugar for
        ``default=attr.Factory(factory)``.

    :param validator: `callable` that is called by *attrs*-generated
        ``__init__`` methods after the instance has been initialized.  They
        receive the initialized instance, the :func:`~attrs.Attribute`, and the
        passed value.

        The return value is *not* inspected so the validator has to throw an
        exception itself.

        If a `list` is passed, its items are treated as validators and must all
        pass.

        Validators can be globally disabled and re-enabled using
        `attrs.validators.get_disabled` / `attrs.validators.set_disabled`.

        The validator can also be set using decorator notation as shown below.

        .. seealso:: :ref:`validators`

    :type validator: `callable` or a `list` of `callable`\ s.

    :param repr: Include this attribute in the generated ``__repr__`` method.
        If ``True``, include the attribute; if ``False``, omit it. By default,
        the built-in ``repr()`` function is used. To override how the attribute
        value is formatted, pass a ``callable`` that takes a single value and
        returns a string. Note that the resulting string is used as-is, i.e. it
        will be used directly *instead* of calling ``repr()`` (the default).
    :type repr: a `bool` or a `callable` to use a custom function.

    :param eq: If ``True`` (default), include this attribute in the generated
        ``__eq__`` and ``__ne__`` methods that check two instances for
        equality. To override how the attribute value is compared, pass a
        ``callable`` that takes a single value and returns the value to be
        compared.

        .. seealso:: `comparison`
    :type eq: a `bool` or a `callable`.

    :param order: If ``True`` (default), include this attributes in the
        generated ``__lt__``, ``__le__``, ``__gt__`` and ``__ge__`` methods. To
        override how the attribute value is ordered, pass a ``callable`` that
        takes a single value and returns the value to be ordered.

        .. seealso:: `comparison`
    :type order: a `bool` or a `callable`.

    :param cmp: Setting *cmp* is equivalent to setting *eq* and *order* to the
        same value. Must not be mixed with *eq* or *order*.

        .. seealso:: `comparison`
    :type cmp: a `bool` or a `callable`.

    :param bool | None hash: Include this attribute in the generated
        ``__hash__`` method.  If ``None`` (default), mirror *eq*'s value.  This
        is the correct behavior according the Python spec.  Setting this value
        to anything else than ``None`` is *discouraged*.

        .. seealso:: `hashing`
    :param bool init: Include this attribute in the generated ``__init__``
        method.  It is possible to set this to ``False`` and set a default
        value.  In that case this attributed is unconditionally initialized
        with the specified default value or factory.

        .. seealso:: `init`
    :param callable converter: `callable` that is called by *attrs*-generated
        ``__init__`` methods to convert attribute's value to the desired
        format.  It is given the passed-in value, and the returned value will
        be used as the new value of the attribute.  The value is converted
        before being passed to the validator, if any.

        .. seealso:: :ref:`converters`
    :param dict | None metadata: An arbitrary mapping, to be used by
        third-party components.  See `extending-metadata`.

    :param type: The type of the attribute. Nowadays, the preferred method to
        specify the type is using a variable annotation (see :pep:`526`). This
        argument is provided for backward compatibility. Regardless of the
        approach used, the type will be stored on ``Attribute.type``.

        Please note that *attrs* doesn't do anything with this metadata by
        itself. You can use it as part of your own code or for `static type
        checking <types>`.
    :param bool kw_only: Make this attribute keyword-only in the generated
        ``__init__`` (if ``init`` is ``False``, this parameter is ignored).
    :param on_setattr: Allows to overwrite the *on_setattr* setting from
        `attr.s`. If left `None`, the *on_setattr* value from `attr.s` is used.
        Set to `attrs.setters.NO_OP` to run **no** `setattr` hooks for this
        attribute -- regardless of the setting in `attr.s`.
    :type on_setattr: `callable`, or a list of callables, or `None`, or
        `attrs.setters.NO_OP`
    :param str | None alias: Override this attribute's parameter name in the
        generated ``__init__`` method. If left `None`, default to ``name``
        stripped of leading underscores. See `private-attributes`.

    .. versionadded:: 15.2.0 *convert*
    .. versionadded:: 16.3.0 *metadata*
    .. versionchanged:: 17.1.0 *validator* can be a ``list`` now.
    .. versionchanged:: 17.1.0
       *hash* is ``None`` and therefore mirrors *eq* by default.
    .. versionadded:: 17.3.0 *type*
    .. deprecated:: 17.4.0 *convert*
    .. versionadded:: 17.4.0 *converter* as a replacement for the deprecated
       *convert* to achieve consistency with other noun-based arguments.
    .. versionadded:: 18.1.0
       ``factory=f`` is syntactic sugar for ``default=attr.Factory(f)``.
    .. versionadded:: 18.2.0 *kw_only*
    .. versionchanged:: 19.2.0 *convert* keyword argument removed.
    .. versionchanged:: 19.2.0 *repr* also accepts a custom callable.
    .. deprecated:: 19.2.0 *cmp* Removal on or after 2021-06-01.
    .. versionadded:: 19.2.0 *eq* and *order*
    .. versionadded:: 20.1.0 *on_setattr*
    .. versionchanged:: 20.3.0 *kw_only* backported to Python 2
    .. versionchanged:: 21.1.0
       *eq*, *order*, and *cmp* also accept a custom callable
    .. versionchanged:: 21.1.0 *cmp* undeprecated
    .. versionadded:: 22.2.0 *alias*
    TNFú6Invalid value for hash.  Must be True, False, or None.z=The `default` and `factory` arguments are mutually exclusive.z*The `factory` argument must be a callable.Ú