human
I wrote the below code

    def infer_first(node):
        if (node is util.Uninferable):
            raise UseInferenceDefault
        try:
            value = next(node.infer(context=context))
            if (value is util.Uninferable):
                raise UseInferenceDefault()
            else:
                return value
        except StopIteration:
            raise InferenceError()
    if (len(node.args) != 2):
        raise UseInferenceDefault()
    try:
        name = infer_first(node.args[0]).value
        names = infer_first(node.args[1])
        try:
            attributes = names.value.replace(',', '    ').split()
        except AttributeError:
            if (not enum):
                attributes = [infer_first(const).value for const in names.elts]
            else:
                if (hasattr(names, 'items') and isinstance(names.items, list)):
                    attributes = [infer_first(const[0]).value for const in names.items if isinstance(const[0], nodes.Const)]
                elif hasattr(names, 'elts'):
                    if all((isinstance(const, nodes.Tuple) for const in names.elts)):
                        attributes = [infer_first(const.elts[0]).value for const in names.elts if isinstance(const, nodes.Tuple)]
                    else:
                        attributes = [infer_first(const).value for const in names.elts]
                else:
                    raise AttributeError
                if (not attributes):
                    raise AttributeError
    except (AttributeError, exceptions.InferenceError):
        raise UseInferenceDefault()
    name = (name or 'Uninferable')
    class_node = nodes.ClassDef(name, 'docstring')
    class_node.parent = node.parent
    class_node.bases.append(base_type)
    for attr in attributes:
        fake_node = nodes.EmptyNode()
        fake_node.parent = class_node
        fake_node.attrname = attr
        class_node.instance_attrs[attr] = [fake_node]
    return (class_node, name, attributes)

What's a good function header?
 Here's a good function header?
assistant
#Here's a good function header.

def infer_func_form(node, base_type, context=None, enum=False):