How to use the jedi.parser.tree function in jedi

'class'
        >>> defs[2].type
        'instance'
        >>> defs[3].type
        'function'

        """
        stripped = self._definition
        if isinstance(stripped, er.InstanceElement):
            stripped = stripped.var

        if isinstance(stripped, compiled.CompiledObject):
            return stripped.api_type()
        elif isinstance(stripped, iterable.Array):
            return 'instance'
        elif isinstance(stripped, tree.Import):
            return 'import'

        string = type(stripped).__name__.lower().replace('wrapper', '')
        if string == 'exprstmt':
            return 'statement'
        else:
            return string

def scan(scope):
            for s in scope.children:
                if s.start_pos <= position <= s.end_pos:
                    if isinstance(s, (tree.Scope, tree.Flow)):
                        return scan(s) or s
                    elif s.type in ('suite', 'decorated'):
                        return scan(s)
            return None

def _name_to_types(evaluator, name, scope):
    types = []
    typ = name.get_definition()
    if typ.isinstance(tree.ForStmt):
        for_types = evaluator.eval_element(typ.children[3])
        for_types = iterable.get_iterator_types(for_types)
        types += check_tuple_assignments(for_types, name)
    elif typ.isinstance(tree.CompFor):
        for_types = evaluator.eval_element(typ.children[3])
        for_types = iterable.get_iterator_types(for_types)
        types += check_tuple_assignments(for_types, name)
    elif isinstance(typ, tree.Param):
        types += _eval_param(evaluator, typ, scope)
    elif typ.isinstance(tree.ExprStmt):
        types += _remove_statements(evaluator, typ, name)
    elif typ.isinstance(tree.WithStmt):
        types += evaluator.eval_element(typ.node_from_name(name))
    elif isinstance(typ, tree.Import):
        types += imports.ImportWrapper(evaluator, name).follow()
    elif isinstance(typ, tree.GlobalStmt):
        # TODO theoretically we shouldn't be using search_global here, it
        # doesn't make sense, because it's a local search (for that name)!
        # However, globals are not that important and resolving them doesn't
        # guarantee correctness in any way, because we don't check for when

types = _eval_param(evaluator, typ, scope)
    elif typ.isinstance(tree.ExprStmt):
        types = _remove_statements(evaluator, typ, name)
    elif typ.isinstance(tree.WithStmt):
        types = evaluator.eval_element(typ.node_from_name(name))
    elif isinstance(typ, tree.Import):
        types = imports.ImportWrapper(evaluator, name).follow()
    elif typ.type == 'global_stmt':
        for s in _get_global_stmt_scopes(evaluator, typ, name):
            finder = NameFinder(evaluator, s, str(name))
            names_dicts = finder.scopes(search_global=True)
            # For global_stmt lookups, we only need the first possible scope,
            # which means the function itself.
            names_dicts = [next(names_dicts)]
            types += finder.find(names_dicts, attribute_lookup=False)
    elif isinstance(typ, tree.TryStmt):
        # TODO an exception can also be a tuple. Check for those.
        # TODO check for types that are not classes and add it to
        # the static analysis report.
        exceptions = evaluator.eval_element(name.get_previous_sibling().get_previous_sibling())
        types = set(chain.from_iterable(evaluator.execute(t) for t in exceptions))
    else:
        if typ.isinstance(er.Function):
            typ = typ.get_decorated_func()
        types = set([typ])
    return types

def get_instance_el(evaluator, instance, var, is_class_var=False):
    """
    Returns an InstanceElement if it makes sense, otherwise leaves the object
    untouched.

    Basically having an InstanceElement is context information. That is needed
    in quite a lot of cases, which includes Nodes like ``power``, that need to
    know where a self name comes from for example.
    """
    if isinstance(var, tree.Name):
        parent = get_instance_el(evaluator, instance, var.parent, is_class_var)
        return InstanceName(var, parent)
    elif var.type != 'funcdef' \
            and isinstance(var, (Instance, compiled.CompiledObject, tree.Leaf,
                           tree.Module, FunctionExecution)):
        return var

    var = evaluator.wrap(var)
    return InstanceElement(evaluator, instance, var, is_class_var)

result = []
    if flow.is_scope():
        # Check for asserts.
        try:
            names = reversed(flow.names_dict[search_name.value])
        except (KeyError, AttributeError):
            names = []

        for name in names:
            ass = name.get_parent_until(tree.AssertStmt)
            if isinstance(ass, tree.AssertStmt) and pos is not None and ass.start_pos < pos:
                result = _check_isinstance_type(evaluator, ass.assertion(), search_name)
                if result:
                    break

    if isinstance(flow, (tree.IfStmt, tree.WhileStmt)):
        element = flow.children[1]
        result = _check_isinstance_type(evaluator, element, search_name)
    return result

def _complete(self, like_name):
        dot = '.' if self._needs_dot else ''
        append = ''
        if settings.add_bracket_after_function \
                and self.type == 'Function':
            append = '('

        if settings.add_dot_after_module:
            if isinstance(self._definition, pr.Module):
                append += '.'
        if isinstance(self._definition, pr.Param):
            append += '='

        name = str(self._name)
        if like_name:
            name = name[self._like_name_length:]
        return dot + name + append

return leaf

    power = trailer.parent
    index = power.children.index(trailer)

    new_power = copy.copy(power)
    new_power.children = list(new_power.children)
    new_power.children[index + 1:] = []

    if power.type == 'error_node':
        start = index
        while True:
            start -= 1
            if power.children[start].type != 'trailer':
                break
        transformed = tree.Node('power', power.children[start:])
        transformed.parent = power.parent
        return transformed

    return power

def get_param(scope, el):
            if isinstance(el.get_parent_until(tree.Param), tree.Param):
                return scope.param_by_name(str(el))
            return el

def wrap(self, element):
        if isinstance(element, tree.Class):
            return er.Class(self, element)
        elif isinstance(element, tree.Function):
            if isinstance(element, tree.Lambda):
                return er.LambdaWrapper(self, element)
            else:
                return er.Function(self, element)
        elif isinstance(element, (tree.Module)) \
                and not isinstance(element, er.ModuleWrapper):
            return er.ModuleWrapper(self, element)
        else:
            return element