
from __future__ import annotations

import unittest
from collections.abc import Iterator







class 	A_       :




	'''simple docstring'''


	def __init__(	self		,   snake_case		,   snake_case	):
		lowercase					  =   label
		lowercase					  =   parent
		lowercase					  =   None
		lowercase					  =   None







class 	A_       :




	'''simple docstring'''


	def __init__(	self	):
		lowercase					  =   None





	def      SCREAMING_SNAKE_CASE__						(	self	):
		lowercase					  =   None





	def      SCREAMING_SNAKE_CASE__						(	self	):
		return self.root is None





	def      SCREAMING_SNAKE_CASE__						(	self		,   snake_case	):
		lowercase					  =   self._put(self.root		,   snake_case	)





	def      SCREAMING_SNAKE_CASE__						(	self		,   snake_case		,   snake_case		,   snake_case = None	):
		if node is None:
			lowercase					  =   Node(snake_case		,   snake_case	)
		else:
			if label < node.label:
				lowercase					  =   self._put(node.left		,   snake_case		,   snake_case	)
			elif label > node.label:
				lowercase					  =   self._put(node.right		,   snake_case		,   snake_case	)
			else:
				lowercase					  =   F'''Node with label {label} already exists'''
				raise Exception(snake_case	)

		return node





	def      SCREAMING_SNAKE_CASE__						(	self		,   snake_case	):
		return self._search(self.root		,   snake_case	)





	def      SCREAMING_SNAKE_CASE__						(	self		,   snake_case		,   snake_case	):
		if node is None:
			lowercase					  =   F'''Node with label {label} does not exist'''
			raise Exception(snake_case	)
		else:
			if label < node.label:
				lowercase					  =   self._search(node.left		,   snake_case	)
			elif label > node.label:
				lowercase					  =   self._search(node.right		,   snake_case	)

		return node





	def      SCREAMING_SNAKE_CASE__						(	self		,   snake_case	):
		lowercase					  =   self.search(snake_case	)
		if node.right and node.left:
			lowercase					  =   self._get_lowest_node(node.right	)
			lowercase					  =   node.left
			lowercase					  =   node.right
			lowercase					  =   lowest_node
			if node.right:
				lowercase					  =   lowest_node
			self._reassign_nodes(snake_case		,   snake_case	)
		elif not node.right and node.left:
			self._reassign_nodes(snake_case		,   node.left	)
		elif node.right and not node.left:
			self._reassign_nodes(snake_case		,   node.right	)
		else:
			self._reassign_nodes(snake_case		,   snake_case	)





	def      SCREAMING_SNAKE_CASE__						(	self		,   snake_case		,   snake_case	):
		if new_children:
			lowercase					  =   node.parent

		if node.parent:
			if node.parent.right == node:
				lowercase					  =   new_children
			else:
				lowercase					  =   new_children
		else:
			lowercase					  =   new_children





	def      SCREAMING_SNAKE_CASE__						(	self		,   snake_case	):
		if node.left:
			lowercase					  =   self._get_lowest_node(node.left	)
		else:
			lowercase					  =   node
			self._reassign_nodes(snake_case		,   node.right	)

		return lowest_node





	def      SCREAMING_SNAKE_CASE__						(	self		,   snake_case	):
		try:
			self.search(snake_case	)
			return True
		except Exception:
			return False





	def      SCREAMING_SNAKE_CASE__						(	self	):
		if self.root is None:
			raise Exception('Binary search tree is empty'	)

		lowercase					  =   self.root
		while node.right is not None:
			lowercase					  =   node.right

		return node.label





	def      SCREAMING_SNAKE_CASE__						(	self	):
		if self.root is None:
			raise Exception('Binary search tree is empty'	)

		lowercase					  =   self.root
		while node.left is not None:
			lowercase					  =   node.left

		return node.label





	def      SCREAMING_SNAKE_CASE__						(	self	):
		return self._inorder_traversal(self.root	)





	def      SCREAMING_SNAKE_CASE__						(	self		,   snake_case	):
		if node is not None:
			yield from self._inorder_traversal(node.left	)
			yield node
			yield from self._inorder_traversal(node.right	)





	def      SCREAMING_SNAKE_CASE__						(	self	):
		return self._preorder_traversal(self.root	)





	def      SCREAMING_SNAKE_CASE__						(	self		,   snake_case	):
		if node is not None:
			yield node
			yield from self._preorder_traversal(node.left	)
			yield from self._preorder_traversal(node.right	)







class 	A_       (      unittest.TestCase       ):




	'''simple docstring'''


	@staticmethod
	def      SCREAMING_SNAKE_CASE__						(	):
		lowercase					  =   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	)

		return t





	def      SCREAMING_SNAKE_CASE__						(	self	):
		lowercase					  =   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(10	)
		assert t.root.right is not None
		assert t.root.right.parent == t.root
		assert t.root.right.label == 10

		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(snake_case	):  # noqa: B017
			t.put(1	)





	def      SCREAMING_SNAKE_CASE__						(	self	):
		lowercase					  =   self._get_binary_search_tree()

		lowercase					  =   t.search(6	)
		assert node.label == 6

		lowercase					  =   t.search(13	)
		assert node.label == 13

		with self.assertRaises(snake_case	):  # noqa: B017
			t.search(2	)





	def      SCREAMING_SNAKE_CASE__						(	self	):
		lowercase					  =   self._get_binary_search_tree()

		t.remove(13	)
		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      SCREAMING_SNAKE_CASE__						(	self	):
		lowercase					  =   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      SCREAMING_SNAKE_CASE__						(	self	):
		lowercase					  =   self._get_binary_search_tree()
		t.empty()
		assert t.root is None





	def      SCREAMING_SNAKE_CASE__						(	self	):
		lowercase					  =   self._get_binary_search_tree()
		assert not t.is_empty()

		t.empty()
		assert t.is_empty()





	def      SCREAMING_SNAKE_CASE__						(	self	):
		lowercase					  =   self._get_binary_search_tree()

		assert t.exists(6	)
		assert not t.exists(-1	)





	def      SCREAMING_SNAKE_CASE__						(	self	):
		lowercase					  =   self._get_binary_search_tree()

		assert t.get_max_label() == 14

		t.empty()
		with self.assertRaises(snake_case	):  # noqa: B017
			t.get_max_label()





	def      SCREAMING_SNAKE_CASE__						(	self	):
		lowercase					  =   self._get_binary_search_tree()

		assert t.get_min_label() == 1

		t.empty()
		with self.assertRaises(snake_case	):  # noqa: B017
			t.get_min_label()





	def      SCREAMING_SNAKE_CASE__						(	self	):
		lowercase					  =   self._get_binary_search_tree()

		lowercase					  =   [i.label for i in t.inorder_traversal()]
		assert inorder_traversal_nodes == [1, 3, 4, 5, 6, 7, 8, 10, 13, 14]





	def      SCREAMING_SNAKE_CASE__						(	self	):
		lowercase					  =   self._get_binary_search_tree()

		lowercase					  =   [i.label for i in t.preorder_traversal()]
		assert preorder_traversal_nodes == [8, 3, 1, 6, 4, 5, 7, 10, 14, 13]






def 							UpperCAmelCase_		(							):
	lowercase					  =   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
	lowercase					  =   [i.label for i in t.inorder_traversal()]
	print('Inorder traversal:'			,							__SCREAMING_SNAKE_CASE							)

	# Prints all the elements of the list in preorder traversal
	lowercase					  =   [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
	lowercase					  =   [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
	lowercase					  =   [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()



# This test is meant to be run in on an instance with TPUs like this:
#
#   python examples/pytorch/xla_spawn.py --num_cores=8 tests/test_trainer_tpu.py
#
# Replace 8 with the number of TPU cores you have.
#

import sys
from typing import Dict

from transformers import EvalPrediction, HfArgumentParser, TrainingArguments, is_torch_available
from transformers.utils import logging


UpperCAmelCase     				=			logging.get_logger(__name__)


if is_torch_available():
	import torch
	from torch import nn
	from torch.utils.data import Dataset

	from transformers import Trainer







	class 	A_       (      __lowerCamelCase       ):




		'''simple docstring'''


		def __init__(	self		,   snake_case = 101	):
			lowercase					  =   length





		def __len__(	self	):
			return self.length





		def __getitem__(	self		,   snake_case	):
			return i







	class 	A_       :




		'''simple docstring'''


		def __call__(	self		,   snake_case	):
			return {"input_ids": torch.tensor(snake_case	), "labels": torch.tensor(snake_case	)}







	class 	A_       (      nn.Module       ):




		'''simple docstring'''


		def __init__(	self	):
			super().__init__()
			# Add some (unused) params otherwise DDP will complain.
			lowercase					  =   nn.Linear(120		,   80	)





		def      SCREAMING_SNAKE_CASE__						(	self		,   snake_case		,   snake_case=None	):
			if labels is not None:
				return torch.tensor(0.0		,   device=input_ids.device	), input_ids
			else:
				return input_ids






def 							UpperCAmelCase_		(							):
	lowercase					  =   HfArgumentParser((TrainingArguments,)							)
	sys.argv += ["--output_dir", "./examples"]
	lowercase					  =   parser.parse_args_into_dataclasses()[0]

	logger.warning(
	    F'''Process rank: {training_args.local_rank}, device: {training_args.device}, '''
	    F'''tpu_num_cores: {training_args.tpu_num_cores}'''			,							)

	# Essentially, what we want to verify in the distributed case is
	# that we get all samples back, in the right order.
	# (this is crucial for prediction for instance)
	for dataset_length in [1001, 256, 15]:
		lowercase					  =   DummyDataset(__SCREAMING_SNAKE_CASE							)

		def compute_metrics(__SCREAMING_SNAKE_CASE							) -> Dict:
			lowercase					  =   list(range(len(__SCREAMING_SNAKE_CASE							)							)							)
			lowercase					  =   p.predictions.tolist() == sequential and p.label_ids.tolist() == sequential
			return {"success": success}

		lowercase					  =   Trainer(
		    model=DummyModel()			,							args=__SCREAMING_SNAKE_CASE			,							data_collator=DummyDataCollator()			,							eval_dataset=__SCREAMING_SNAKE_CASE			,							compute_metrics=__SCREAMING_SNAKE_CASE			,							)
		lowercase					  =   trainer.evaluate()
		logger.info(__SCREAMING_SNAKE_CASE							)
		if metrics["eval_success"] is not True:
			logger.error(__SCREAMING_SNAKE_CASE							)
			exit(1							)

		lowercase					  =   trainer.predict(__SCREAMING_SNAKE_CASE							)
		logger.info(p.metrics							)
		if p.metrics["test_success"] is not True:
			logger.error(p.metrics							)
			exit(1							)

		lowercase					  =   2

		lowercase					  =   trainer.evaluate()
		logger.info(__SCREAMING_SNAKE_CASE							)
		if metrics["eval_success"] is not True:
			logger.error(__SCREAMING_SNAKE_CASE							)
			exit(1							)

		lowercase					  =   trainer.predict(__SCREAMING_SNAKE_CASE							)
		logger.info(p.metrics							)
		if p.metrics["test_success"] is not True:
			logger.error(p.metrics							)
			exit(1							)

		lowercase					  =   None

	logger.info('🔥 All distributed tests successful'							)






def 							UpperCAmelCase_		(							__SCREAMING_SNAKE_CASE							):
	# For xla_spawn (TPUs)
	main()


if __name__ == "__main__":
	main()

