Hybrid behavior doesn't work when maybe_cls=None and no annotations

[euresti]

The doc says:

    :param Optional[bool] auto_attribs: If set to `True` or `False`, it behaves
       exactly like `attr.s`. If left `None`, `attr.s` will try to guess:

       1. If all attributes are annotated and no `attr.ib` is found, it assumes
          *auto_attribs=True*.
       2. Otherwise it assumes *auto_attribs=False* and tries to collect
          `attr.ib`\ s.

Sadly it doesn't exactly work.

import attr

@attr.define()
class Trigger:
    a = attr.field()

The code does this:

    try:
        return do_it(True)
    except UnannotatedAttributeError:
        return do_it(False)

But do_it itself won't raise UnannotatedAttributeError until the decorator is applied to the class.

[hynek]

Ah yikes it’s about the (). I’m afk for now but any ideas how to make it work? 🤔

[euresti]

This seems to work but is not fully tested:

def define(
    maybe_cls=None,
    *,
   ...
):
    def wrap(cls):
        def do_it(auto_attribs):
            return attrs(
                maybe_cls=cls,
                these=these,
                repr=repr,
                hash=hash,
                init=init,
                slots=slots,
                frozen=frozen,
                weakref_slot=weakref_slot,
                str=str,
                auto_attribs=auto_attribs,
                kw_only=kw_only,
                cache_hash=cache_hash,
                auto_exc=auto_exc,
                eq=eq,
                order=order,
                auto_detect=auto_detect,
                collect_by_mro=True,
                getstate_setstate=getstate_setstate,
                on_setattr=on_setattr,
            )

        if auto_attribs is not None:
            return do_it(auto_attribs)

        try:
            return do_it(True)
        except UnannotatedAttributeError:
            return do_it(False)

    # maybe_cls's type depends on the usage of the decorator.  It's a class
    # if it's used as `@attrs` but ``None`` if used as `@attrs()`.
    if maybe_cls is None:
        return wrap
    else:
        return wrap(maybe_cls)

Edit: Fixed the code a bit.