AVL tree

class Node:
    def __init__(self, value, left=None, right=None):
        self.value = value
        self.left = left
        self.right = right
        self.hight = 0


class Tree:
    def __init__(self):
        self.root = None
        self.size = 0

    def add(self, node, value):
        if node is None:
            return Node(value)
        else:
            if value < node.value:
                node.left = self.add(node.left, value)
            else:
                node.right = self.add(node.right, value)
        return self.balance(node)

    def build_tree(self, path):
        with open(path, 'r') as f:
            node_list = f.read().strip()

        for value in [int(i) for i in node_list.split()]:
            self.root = self.add(self.root, value)

    def _print_tree(self, node, level, p_level):
        printed = False

        if p_level == level:
            print(f'{node.value}', end=' ')
            printed = True
        else:
            if node.left:
                printed = self._print_tree(node.left, level+1, p_level)
            if node.right:
                printed = (self._print_tree(
                    node.right, level+1, p_level)) or printed

        return printed

    def print_tree(self, node=None):
        if node is None:
            level = 0
            while (self._print_tree(self.root, 0, level)):
                level += 1
                print()
        else:
            level = 0
            while (self._print_tree(node, 0, level)):
                level += 1
                print()

    def update_height(self, node=None):
        if node == None:
            return 0
        else:
            node.height = max(self.update_height(node.left),
                              self.update_height(node.right)) + 1
            return node.height

    def height(self, node):
        if node == None:
            return 0
        else:
            return node.height

    def bfactor(self, node):
        if not node:
            return 0
        return self.height(node.right) - self.height(node.left)

    def right_rotate(self, node):
        if node.left is None:
            raise ValueError
        temp = node.left
        node.left = temp.right
        temp.right = node
        self.update_height(self.root)
        return temp

    def left_rotate(self, node):
        if node.right is None:
            raise ValueError
        temp = node.right
        node.right = temp.left
        temp.left = node
        self.update_height(self.root)
        return temp

    def double_rotate_right(self, node):
        node.right = self.right_rotate(node.right)
        return self.left_rotate(node)

    def double_rotate_left(self, node):
        node.left = self.left_rotate(node.left)
        return self.right_rotate(node)

    def balance(self, node):
        self.update_height(self.root)
        if self.bfactor(node) == 2:
            if self.bfactor(node.right) < 0:
                node.right = self.right_rotate(node.right)
            return self.left_rotate(node)
        elif self.bfactor(node) == -2:
            if self.bfactor(node.left) > 0:
                node.left = self.left_rotate(node.left)
            return self.right_rotate(node)

        return node

    def search(self, value, node):
        res = None
        if node.value == value:
            return node
        if node.right:
            res = self.search(value, node.right)
        if node.left:
            temp = self.search(value, node.left)
            if temp is not None:
                res = temp
        return res

    def delete(self, root, value):

        if not root:
            return root

        elif value < root.value:
            root.left = self.delete(root.left, value)

        elif value > root.value:
            root.right = self.delete(root.right, value)

        else:
            if root.left is None:
                temp = root.right
                root = None
                return temp

            elif root.right is None:
                temp = root.left
                root = None
                return temp

            temp = self.getMinValueNode(root.right)
            root.value = temp.value
            root.right = self.delete(root.right,
                                     temp.value)

        if root is None:
            return root

        root.height = 1 + max(self.height(root.left),
                              self.height(root.right))

        balance = self.bfactor(root)

        if balance > 1 and self.bfactor(root.left) >= 0:
            return self.right_rotate(root)

        if balance < -1 and self.bfactor(root.right) <= 0:
            return self.left_rotate(root)

        if balance > 1 and self.bfactor(root.left) < 0:
            root.left = self.left_rotate(root.left)
            return self.right_rotate(root)

        if balance < -1 and self.bfactor(root.right) > 0:
            root.right = self.right_rotate(root.right)
            return self.left_rotate(root)

        return root

    def getMinValueNode(self, root):
        if root is None or root.left is None:
            return root

        return self.getMinValueNode(root.left)