human
I wrote the below code

    def resolve_names(definition_names):
        for name in definition_names:
            if (name.api_type == 'module'):
                found = False
                for context in name.infer():
                    if isinstance(context, ModuleContext):
                        found = True
                        (yield context.name)
                if (not found):
                    (yield name)
            else:
                (yield name)
    def compare_array(definition_names):
        "    `definitions`    are    being    compared    by    module/start_pos,    because\n                                sometimes    the    id's    of    the    objects    change    (e.g.    executions).\n                                "
        return [(name.get_root_context(), name.start_pos) for name in resolve_names(definition_names)]
    search_name = list(definition_names)[0].string_name
    compare_definitions = compare_array(definition_names)
    mods = (mods | set([d.get_root_context() for d in definition_names]))
    definition_names = set(resolve_names(definition_names))
    for m in imports.get_modules_containing_name(evaluator, mods, search_name):
        if isinstance(m, ModuleContext):
            for name_node in m.tree_node.get_used_names().get(search_name, []):
                context = evaluator.create_context(m, name_node)
                result = evaluator.goto(context, name_node)
                if any((compare_contexts(c1, c2) for c1 in compare_array(result) for c2 in compare_definitions)):
                    name = TreeNameDefinition(context, name_node)
                    definition_names.add(name)
                    compare_definitions += compare_array([name])
        else:
            definition_names.add(m.name)
    return [classes.Definition(evaluator, n) for n in definition_names]

What's a good function header?

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

def usages(evaluator, definition_names, mods):