code: 
  
  
  
  
  
  from __future__ import annotations
  
  import unittest
  from collections.abc import Iterator
  
  
  
  
  
  
  
  class        __lowerCAmelCase :
  
  
  
  
  
  
  
        def __init__(					self	,   lowerCAmelCase__	,   lowerCAmelCase__							)     ->		None:
  
  
  
          '''simple docstring'''
  
  
  
  
          a__			:      Optional[Any]            =label
          a__			:      List[Any]            =parent
          a__			:      Node | None            =None
          a__			:      Node | None            =None
  
  
  
  
  
  
  
  class        __lowerCAmelCase :
  
  
  
  
  
  
  
        def __init__(					self							)     ->		None:
  
  
  
          '''simple docstring'''
  
  
  
  
          a__			:      Node | None            =None
  
  
  
  
  
  
  
        def      _lowercase						(					self							)     ->		None:
  
  
  
          '''simple docstring'''
  
  
  
  
          a__			:      Any            =None
  
  
  
  
  
  
  
        def      _lowercase						(					self							)     ->		bool:
  
  
  
          '''simple docstring'''
  
  
  
  
          return self.root is None
  
  
  
  
  
  
  
        def      _lowercase						(					self	,   lowerCAmelCase__							)     ->		None:
  
  
  
          '''simple docstring'''
  
  
  
  
          a__			:      Union[str, Any]            =self._put(self.root	,   lowerCAmelCase__							)
  
  
  
  
  
  
  
        def      _lowercase						(					self	,   lowerCAmelCase__	,   lowerCAmelCase__	,   lowerCAmelCase__ = None							)     ->		Node:
  
  
  
          '''simple docstring'''
  
  
  
  
          if node is None:
            a__			:      Tuple            =Node(lowerCAmelCase__	,   lowerCAmelCase__							)
          else:
            if label < node.label:
              a__			:      List[str]            =self._put(node.left	,   lowerCAmelCase__	,   lowerCAmelCase__							)
            elif label > node.label:
              a__			:      Optional[Any]            =self._put(node.right	,   lowerCAmelCase__	,   lowerCAmelCase__							)
            else:
              a__			:      Optional[Any]            =F'''Node with label {label} already exists'''
              raise Exception(lowerCAmelCase__							)
  
          return node
  
  
  
  
  
  
  
        def      _lowercase						(					self	,   lowerCAmelCase__							)     ->		Node:
  
  
  
          '''simple docstring'''
  
  
  
  
          return self._search(self.root	,   lowerCAmelCase__							)
  
  
  
  
  
  
  
        def      _lowercase						(					self	,   lowerCAmelCase__	,   lowerCAmelCase__							)     ->		Node:
  
  
  
          '''simple docstring'''
  
  
  
  
          if node is None:
            a__			:      List[Any]            =F'''Node with label {label} does not exist'''
            raise Exception(lowerCAmelCase__							)
          else:
            if label < node.label:
              a__			:      List[str]            =self._search(node.left	,   lowerCAmelCase__							)
            elif label > node.label:
              a__			:      Tuple            =self._search(node.right	,   lowerCAmelCase__							)
  
          return node
  
  
  
  
  
  
  
        def      _lowercase						(					self	,   lowerCAmelCase__							)     ->		None:
  
  
  
          '''simple docstring'''
  
  
  
  
          a__			:      List[str]            =self.search(lowerCAmelCase__							)
          if node.right and node.left:
            a__			:      int            =self._get_lowest_node(node.right							)
            a__			:      Union[str, Any]            =node.left
            a__			:      List[Any]            =node.right
            a__			:      List[str]            =lowest_node
            if node.right:
              a__			:      List[str]            =lowest_node
            self._reassign_nodes(lowerCAmelCase__	,   lowerCAmelCase__							)
          elif not node.right and node.left:
            self._reassign_nodes(lowerCAmelCase__	,   node.left							)
          elif node.right and not node.left:
            self._reassign_nodes(lowerCAmelCase__	,   node.right							)
          else:
            self._reassign_nodes(lowerCAmelCase__	,   lowerCAmelCase__							)
  
  
  
  
  
  
  
        def      _lowercase						(					self	,   lowerCAmelCase__	,   lowerCAmelCase__							)     ->		None:
  
  
  
          '''simple docstring'''
  
  
  
  
          if new_children:
            a__			:      Dict            =node.parent
  
          if node.parent:
            if node.parent.right == node:
              a__			:      List[Any]            =new_children
            else:
              a__			:      Optional[Any]            =new_children
          else:
            a__			:      Any            =new_children
  
  
  
  
  
  
  
        def      _lowercase						(					self	,   lowerCAmelCase__							)     ->		Node:
  
  
  
          '''simple docstring'''
  
  
  
  
          if node.left:
            a__			:      Tuple            =self._get_lowest_node(node.left							)
          else:
            a__			:      Optional[int]            =node
            self._reassign_nodes(lowerCAmelCase__	,   node.right							)
  
          return lowest_node
  
  
  
  
  
  
  
        def      _lowercase						(					self	,   lowerCAmelCase__							)     ->		bool:
  
  
  
          '''simple docstring'''
  
  
  
  
          try:
            self.search(lowerCAmelCase__							)
            return True
          except Exception:
            return False
  
  
  
  
  
  
  
        def      _lowercase						(					self							)     ->		int:
  
  
  
          '''simple docstring'''
  
  
  
  
          if self.root is None:
            raise Exception("Binary search tree is empty"							)
  
          a__			:      Union[str, Any]            =self.root
          while node.right is not None:
            a__			:      List[str]            =node.right
  
          return node.label
  
  
  
  
  
  
  
        def      _lowercase						(					self							)     ->		int:
  
  
  
          '''simple docstring'''
  
  
  
  
          if self.root is None:
            raise Exception("Binary search tree is empty"							)
  
          a__			:      List[Any]            =self.root
          while node.left is not None:
            a__			:      List[Any]            =node.left
  
          return node.label
  
  
  
  
  
  
  
        def      _lowercase						(					self							)     ->		Iterator[Node]:
  
  
  
          '''simple docstring'''
  
  
  
  
          return self._inorder_traversal(self.root							)
  
  
  
  
  
  
  
        def      _lowercase						(					self	,   lowerCAmelCase__							)     ->		Iterator[Node]:
  
  
  
          '''simple docstring'''
  
  
  
  
          if node is not None:
            yield from self._inorder_traversal(node.left							)
            yield node
            yield from self._inorder_traversal(node.right							)
  
  
  
  
  
  
  
        def      _lowercase						(					self							)     ->		Iterator[Node]:
  
  
  
          '''simple docstring'''
  
  
  
  
          return self._preorder_traversal(self.root							)
  
  
  
  
  
  
  
        def      _lowercase						(					self	,   lowerCAmelCase__							)     ->		Iterator[Node]:
  
  
  
          '''simple docstring'''
  
  
  
  
          if node is not None:
            yield node
            yield from self._preorder_traversal(node.left							)
            yield from self._preorder_traversal(node.right							)
  
  
  
  
  
  
  
  class        __lowerCAmelCase (					unittest.TestCase):
  
  
  
  
  
  
  
        @staticmethod
        def      _lowercase						(					)     ->		BinarySearchTree:
  
  
  
          '''simple docstring'''
  
  
  
  
          a__			:      List[Any]            =BinarySearchTree()
          t.put(8							)
          t.put(3							)
          t.put(6							)
          t.put(1							)
          t.put(1_0							)
          t.put(1_4							)
          t.put(1_3							)
          t.put(4							)
          t.put(7							)
          t.put(5							)
  
          return t
  
  
  
  
  
  
  
        def      _lowercase						(					self							)     ->		None:
  
  
  
          '''simple docstring'''
  
  
  
  
          a__			:      List[Any]            =BinarySearchTree()
          assert t.is_empty()
  
          t.put(8							)
          assert t.root is not None
          assert t.root.parent is None
          assert t.root.label == 8
  
          t.put(1_0							)
          assert t.root.right is not None
          assert t.root.right.parent == t.root
          assert t.root.right.label == 1_0
  
          t.put(3							)
          assert t.root.left is not None
          assert t.root.left.parent == t.root
          assert t.root.left.label == 3
  
          t.put(6							)
          assert t.root.left.right is not None
          assert t.root.left.right.parent == t.root.left
          assert t.root.left.right.label == 6
  
          t.put(1							)
          assert t.root.left.left is not None
          assert t.root.left.left.parent == t.root.left
          assert t.root.left.left.label == 1
  
          with self.assertRaises(lowerCAmelCase__							):  # noqa: B017
            t.put(1							)
  
  
  
  
  
  
  
        def      _lowercase						(					self							)     ->		None:
  
  
  
          '''simple docstring'''
  
  
  
  
          a__			:      List[str]            =self._get_binary_search_tree()
  
          a__			:      Union[str, Any]            =t.search(6							)
          assert node.label == 6
  
          a__			:      Tuple            =t.search(1_3							)
          assert node.label == 1_3
  
          with self.assertRaises(lowerCAmelCase__							):  # noqa: B017
            t.search(2							)
  
  
  
  
  
  
  
        def      _lowercase						(					self							)     ->		None:
  
  
  
          '''simple docstring'''
  
  
  
  
          a__			:      Dict            =self._get_binary_search_tree()
  
          t.remove(1_3							)
          assert t.root is not None
          assert t.root.right is not None
          assert t.root.right.right is not None
          assert t.root.right.right.right is None
          assert t.root.right.right.left is None
  
          t.remove(7							)
          assert t.root.left is not None
          assert t.root.left.right is not None
          assert t.root.left.right.left is not None
          assert t.root.left.right.right is None
          assert t.root.left.right.left.label == 4
  
          t.remove(6							)
          assert t.root.left.left is not None
          assert t.root.left.right.right is not None
          assert t.root.left.left.label == 1
          assert t.root.left.right.label == 4
          assert t.root.left.right.right.label == 5
          assert t.root.left.right.left is None
          assert t.root.left.left.parent == t.root.left
          assert t.root.left.right.parent == t.root.left
  
          t.remove(3							)
          assert t.root is not None
          assert t.root.left.label == 4
          assert t.root.left.right.label == 5
          assert t.root.left.left.label == 1
          assert t.root.left.parent == t.root
          assert t.root.left.left.parent == t.root.left
          assert t.root.left.right.parent == t.root.left
  
          t.remove(4							)
          assert t.root.left is not None
          assert t.root.left.left is not None
          assert t.root.left.label == 5
          assert t.root.left.right is None
          assert t.root.left.left.label == 1
          assert t.root.left.parent == t.root
          assert t.root.left.left.parent == t.root.left
  
  
  
  
  
  
  
        def      _lowercase						(					self							)     ->		None:
  
  
  
          '''simple docstring'''
  
  
  
  
          a__			:      List[str]            =self._get_binary_search_tree()
  
          t.remove(3							)
          assert t.root is not None
          assert t.root.left is not None
          assert t.root.left.left is not None
          assert t.root.left.right is not None
          assert t.root.left.right.left is not None
          assert t.root.left.right.right is not None
          assert t.root.left.label == 4
          assert t.root.left.right.label == 6
          assert t.root.left.left.label == 1
          assert t.root.left.right.right.label == 7
          assert t.root.left.right.left.label == 5
          assert t.root.left.parent == t.root
          assert t.root.left.right.parent == t.root.left
          assert t.root.left.left.parent == t.root.left
          assert t.root.left.right.left.parent == t.root.left.right
  
  
  
  
  
  
  
        def      _lowercase						(					self							)     ->		None:
  
  
  
          '''simple docstring'''
  
  
  
  
          a__			:      int            =self._get_binary_search_tree()
          t.empty()
          assert t.root is None
  
  
  
  
  
  
  
        def      _lowercase						(					self							)     ->		None:
  
  
  
          '''simple docstring'''
  
  
  
  
          a__			:      Union[str, Any]            =self._get_binary_search_tree()
          assert not t.is_empty()
  
          t.empty()
          assert t.is_empty()
  
  
  
  
  
  
  
        def      _lowercase						(					self							)     ->		None:
  
  
  
          '''simple docstring'''
  
  
  
  
          a__			:      str            =self._get_binary_search_tree()
  
          assert t.exists(6							)
          assert not t.exists(-1							)
  
  
  
  
  
  
  
        def      _lowercase						(					self							)     ->		None:
  
  
  
          '''simple docstring'''
  
  
  
  
          a__			:      Any            =self._get_binary_search_tree()
  
          assert t.get_max_label() == 1_4
  
          t.empty()
          with self.assertRaises(lowerCAmelCase__							):  # noqa: B017
            t.get_max_label()
  
  
  
  
  
  
  
        def      _lowercase						(					self							)     ->		None:
  
  
  
          '''simple docstring'''
  
  
  
  
          a__			:      List[Any]            =self._get_binary_search_tree()
  
          assert t.get_min_label() == 1
  
          t.empty()
          with self.assertRaises(lowerCAmelCase__							):  # noqa: B017
            t.get_min_label()
  
  
  
  
  
  
  
        def      _lowercase						(					self							)     ->		None:
  
  
  
          '''simple docstring'''
  
  
  
  
          a__			:      Optional[Any]            =self._get_binary_search_tree()
  
          a__			:      Union[str, Any]            =[i.label for i in t.inorder_traversal()]
          assert inorder_traversal_nodes == [1, 3, 4, 5, 6, 7, 8, 1_0, 1_3, 1_4]
  
  
  
  
  
  
  
        def      _lowercase						(					self							)     ->		None:
  
  
  
          '''simple docstring'''
  
  
  
  
          a__			:      Optional[int]            =self._get_binary_search_tree()
  
          a__			:      Union[str, Any]            =[i.label for i in t.preorder_traversal()]
          assert preorder_traversal_nodes == [8, 3, 1, 6, 4, 5, 7, 1_0, 1_4, 1_3]
  def   _A (	):
  
  
  
  
  
    """simple docstring"""
  
  
  
    a__			:      Optional[Any]            =BinarySearchTree()
    t.put(8		)
    t.put(3		)
    t.put(6		)
    t.put(1		)
    t.put(10		)
    t.put(14		)
    t.put(13		)
    t.put(4		)
    t.put(7		)
    t.put(5		)
  
    print(
        "\n            8\n           / \\\n          3   10\n         / \\    \\\n        1   6    14\n           / \\   /\n          4   7 13\n           \\\n            5\n        "		)
  
    print("Label 6 exists:" , t.exists(6		)		)
    print("Label 13 exists:" , t.exists(13		)		)
    print("Label -1 exists:" , t.exists(-1		)		)
    print("Label 12 exists:" , t.exists(12		)		)
  
    # Prints all the elements of the list in inorder traversal
    a__			:      Dict            =[i.label for i in t.inorder_traversal()]
    print("Inorder traversal:" , SCREAMING_SNAKE_CASE		)
  
    # Prints all the elements of the list in preorder traversal
    a__			:      List[Any]            =[i.label for i in t.preorder_traversal()]
    print("Preorder traversal:" , SCREAMING_SNAKE_CASE		)
  
    print("Max. label:" , t.get_max_label()		)
    print("Min. label:" , t.get_min_label()		)
  
    # Delete elements
    print("\nDeleting elements 13, 10, 8, 3, 6, 14"		)
    print(
        "\n          4\n         / \\\n        1   7\n             \\\n              5\n        "		)
    t.remove(13		)
    t.remove(10		)
    t.remove(8		)
    t.remove(3		)
    t.remove(6		)
    t.remove(14		)
  
    # Prints all the elements of the list in inorder traversal after delete
    a__			:      Optional[Any]            =[i.label for i in t.inorder_traversal()]
    print("Inorder traversal after delete:" , SCREAMING_SNAKE_CASE		)
  
    # Prints all the elements of the list in preorder traversal after delete
    a__			:      Any            =[i.label for i in t.preorder_traversal()]
    print("Preorder traversal after delete:" , SCREAMING_SNAKE_CASE		)
  
    print("Max. label:" , t.get_max_label()		)
    print("Min. label:" , t.get_min_label()		)
  
  
  if __name__ == "__main__":
       binary_search_tree_example()
  
  
  
  
  
  
  
style_context: 
  
  
  
  
  
  import importlib
  import sys
  from argparse import REMAINDER, ArgumentParser
  from pathlib import Path
  
  import torch_xla.distributed.xla_multiprocessing as xmp
  def   _A (	):
  
  
  
  
  
    """simple docstring"""
  
  
  
    a__			:      Optional[int]            =ArgumentParser(
        description=(
            "PyTorch TPU distributed training launch helper utility that will spawn up multiple distributed processes"
        )		)
  
    # Optional arguments for the launch helper
    parser.add_argument("--num_cores" , type=SCREAMING_SNAKE_CASE , default=1 , help="Number of TPU cores to use (1 or 8)."		)
  
    # positional
    parser.add_argument(
        "training_script" , type=SCREAMING_SNAKE_CASE , help=(
            "The full path to the single TPU training "
            "program/script to be launched in parallel, "
            "followed by all the arguments for the "
            "training script"
        ) , )
  
    # rest from the training program
    parser.add_argument("training_script_args" , nargs=SCREAMING_SNAKE_CASE		)
  
    return parser.parse_args()
  def   _A (	):
  
  
  
  
  
    """simple docstring"""
  
  
  
    a__			:      Optional[Any]            =parse_args()
  
    # Import training_script as a module.
    a__			:      Tuple            =Path(args.training_script		)
    sys.path.append(str(script_fpath.parent.resolve()		)		)
    a__			:      Tuple            =script_fpath.stem
    a__			:      Any            =importlib.import_module(SCREAMING_SNAKE_CASE		)
  
    # Patch sys.argv
    a__			:      List[str]            =[args.training_script] + args.training_script_args + ["--tpu_num_cores", str(args.num_cores		)]
  
    xmp.spawn(mod._mp_fn , args=() , nprocs=args.num_cores		)
  
  
  if __name__ == "__main__":
       main()
  
  
  
  
  
  
  