code: def make_class(name, attrs, bases=(object,), **attributes_arguments):
      
      if isinstance(attrs, dict):
          cls_dict = attrs
      elif isinstance(attrs, (list, tuple)):
          cls_dict = dict((a, attrib()) for a in attrs)
      else:
          raise TypeError("attrs argument must be a dict or a list.")
  
      post_init = cls_dict.pop("__attrs_post_init__", None)
      type_ = type(
          name,
          bases,
          {} if post_init is None else {"__attrs_post_init__": post_init},
      )
      # For pickling to work, the __module__ variable needs to be set to the
      # frame where the class is created.  Bypass this step in environments where
      # sys._getframe is not defined (Jython for example) or sys._getframe is not
      # defined for arguments greater than 0 (IronPython).
      try:
          type_.__module__ = sys._getframe(1).f_globals.get(
              "__name__", "__main__"
          )
      except (AttributeError, ValueError):
          pass
  
      return _attrs(these=cls_dict, **attributes_arguments)(type_)
docs: A quick way to create a new class called *name* with *attrs*.
  
      :param name: The name for the new class.
      :type name: str
  
      :param attrs: A list of names or a dictionary of mappings of names to
          attributes.
  
          If *attrs* is a list or an ordered dict (:class:`dict` on Python 3.6+,
          :class:`collections.OrderedDict` otherwise), the order is deduced from
          the order of the names or attributes inside *attrs*.  Otherwise the
          order of the definition of the attributes is used.
      :type attrs: :class:`list` or :class:`dict`
  
      :param tuple bases: Classes that the new class will subclass.
  
      :param attributes_arguments: Passed unmodified to :func:`attr.s`.
  
      :return: A new class with *attrs*.
      :rtype: type
  
      .. versionadded:: 17.1.0 *bases*
      .. versionchanged:: 18.1.0 If *attrs* is ordered, the order is retained.