code: def define(
      maybe_cls=None,
      *,
      these=None,
      repr=None,
      unsafe_hash=None,
      hash=None,
      init=None,
      slots=True,
      frozen=False,
      weakref_slot=True,
      str=False,
      auto_attribs=None,
      kw_only=False,
      cache_hash=False,
      auto_exc=True,
      eq=None,
      order=False,
      auto_detect=True,
      getstate_setstate=None,
      on_setattr=None,
      field_transformer=None,
      match_args=True,
  ):
      r"""
      Define an *attrs* class.
  
      Differences to the classic `attr.s` that it uses underneath:
  
      - Automatically detect whether or not *auto_attribs* should be `True` (c.f.
        *auto_attribs* parameter).
      - Converters and validators run when attributes are set by default -- if
        *frozen* is `False`.
      - *slots=True*
  
        .. caution::
  
           Usually this has only upsides and few visible effects in everyday
           programming. But it *can* lead to some surprising behaviors, so please
           make sure to read :term:`slotted classes`.
      - *auto_exc=True*
      - *auto_detect=True*
      - *order=False*
      - Some options that were only relevant on Python 2 or were kept around for
        backwards-compatibility have been removed.
  
      Please note that these are all defaults and you can change them as you
      wish.
  
      :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 any attributes are annotated and no unannotated `attrs.fields`\ s
            are found, it assumes *auto_attribs=True*.
         2. Otherwise it assumes *auto_attribs=False* and tries to collect
            `attrs.fields`\ s.
  
      For now, please refer to `attr.s` for the rest of the parameters.
  
      .. versionadded:: 20.1.0
      .. versionchanged:: 21.3.0 Converters are also run ``on_setattr``.
      .. versionadded:: 22.2.0
         *unsafe_hash* as an alias for *hash* (for :pep:`681` compliance).
      """
  
      def do_it(cls, auto_attribs):
          return attrs(
              maybe_cls=cls,
              these=these,
              repr=repr,
              hash=hash,
              unsafe_hash=unsafe_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,
              field_transformer=field_transformer,
              match_args=match_args,
          )
  
      def wrap(cls):
          """
          Making this a wrapper ensures this code runs during class creation.
  
          We also ensure that frozen-ness of classes is inherited.
          """
          nonlocal frozen, on_setattr
  
          had_on_setattr = on_setattr not in (None, setters.NO_OP)
  
          # By default, mutable classes convert & validate on setattr.
          if frozen is False and on_setattr is None:
              on_setattr = _ng_default_on_setattr
  
          # However, if we subclass a frozen class, we inherit the immutability
          # and disable on_setattr.
          for base_cls in cls.__bases__:
              if base_cls.__setattr__ is _frozen_setattrs:
                  if had_on_setattr:
                      msg = "Frozen classes can't use on_setattr (frozen-ness was inherited)."
                      raise ValueError(msg)
  
                  on_setattr = setters.NO_OP
                  break
  
          if auto_attribs is not None:
              return do_it(cls, auto_attribs)
  
          try:
              return do_it(cls, True)
          except UnannotatedAttributeError:
              return do_it(cls, 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
  
      return wrap(maybe_cls)
  
file_path: catboost/contrib/python/attrs/py3/attr/_next_gen.py
imports: from functools import partial
  from .None import setters
  from ._funcs import asdict
  from ._funcs import astuple
  from ._make import NOTHING, _frozen_setattrs, _ng_default_on_setattr, attrib, attrs
  from .exceptions import UnannotatedAttributeError
label_desc: Use image node_id 1 for calling a global function with example usage: define(maybe_cls) and returns: wrap, attrs, wrap, do_it, do_it, do_it