


import json
import os
import shutil
import sys
import tempfile
import unittest
import unittest.mock as mock
from pathlib import Path

from huggingface_hub import HfFolder, delete_repo
from requests.exceptions import HTTPError

from transformers import AutoConfig, BertConfig, GPTaConfig
from transformers.configuration_utils import PretrainedConfig
from transformers.testing_utils import TOKEN, USER, is_staging_test


sys.path.append(str(Path(__file__).parent.parent / '''utils'''))

from test_module.custom_configuration import CustomConfig  # noqa E402


lowerCamelCase						=		{
    '''return_dict''': False,
    '''output_hidden_states''': True,
    '''output_attentions''': True,
    '''torchscript''': True,
    '''torch_dtype''': '''float16''',
    '''use_bfloat16''': True,
    '''tf_legacy_loss''': True,
    '''pruned_heads''': {'''a''': 1},
    '''tie_word_embeddings''': False,
    '''is_decoder''': True,
    '''cross_attention_hidden_size''': 128,
    '''add_cross_attention''': True,
    '''tie_encoder_decoder''': True,
    '''max_length''': 50,
    '''min_length''': 3,
    '''do_sample''': True,
    '''early_stopping''': True,
    '''num_beams''': 3,
    '''num_beam_groups''': 3,
    '''diversity_penalty''': 0.5,
    '''temperature''': 2.0,
    '''top_k''': 10,
    '''top_p''': 0.7,
    '''typical_p''': 0.2,
    '''repetition_penalty''': 0.8,
    '''length_penalty''': 0.8,
    '''no_repeat_ngram_size''': 5,
    '''encoder_no_repeat_ngram_size''': 5,
    '''bad_words_ids''': [1, 2, 3],
    '''num_return_sequences''': 3,
    '''chunk_size_feed_forward''': 5,
    '''output_scores''': True,
    '''return_dict_in_generate''': True,
    '''forced_bos_token_id''': 2,
    '''forced_eos_token_id''': 3,
    '''remove_invalid_values''': True,
    '''architectures''': ['''BertModel'''],
    '''finetuning_task''': '''translation''',
    '''id2label''': {0: '''label'''},
    '''label2id''': {'''label''': '''0'''},
    '''tokenizer_class''': '''BertTokenizerFast''',
    '''prefix''': '''prefix''',
    '''bos_token_id''': 6,
    '''pad_token_id''': 7,
    '''eos_token_id''': 8,
    '''sep_token_id''': 9,
    '''decoder_start_token_id''': 10,
    '''exponential_decay_length_penalty''': (5, 1.0_1),
    '''suppress_tokens''': [0, 1],
    '''begin_suppress_tokens''': 2,
    '''task_specific_params''': {'''translation''': '''some_params'''},
    '''problem_type''': '''regression''',
}





@is_staging_test
class  _a							(    unittest.TestCase):




 @classmethod
 def 							UpperCAmelCase__( cls						:		Dict		)->	Optional[int]:
   lowerCAmelCase__       :      Any   					= TOKEN
   HfFolder.save_token(snake_case__		)




 @classmethod
 def 							UpperCAmelCase__( cls						:		Dict		)->	Union[str, Any]:


   try:
     delete_repo(token=cls._token		, repo_id='''test-config'''		)
   except HTTPError:
     pass

   try:
     delete_repo(token=cls._token		, repo_id='''valid_org/test-config-org'''		)
   except HTTPError:
     pass

   try:
     delete_repo(token=cls._token		, repo_id='''test-dynamic-config'''		)
   except HTTPError:
     pass




 def 							UpperCAmelCase__( self						:		str		)->	List[str]:
   lowerCAmelCase__       :      Union[str, Any]   					= BertConfig(
       vocab_size=99		, hidden_size=32		, num_hidden_layers=5		, num_attention_heads=4		, intermediate_size=37		)
   config.push_to_hub('''test-config'''		, use_auth_token=self._token		)

   lowerCAmelCase__       :      Union[str, Any]   					= BertConfig.from_pretrained(F'{USER}/test-config'		)
   for k, v in config.to_dict().items():
     if k != "transformers_version":
       self.assertEqual(snake_case__		, getattr(snake_case__		, snake_case__		)		)

        # Reset repo
   delete_repo(token=self._token		, repo_id='''test-config'''		)

   # Push to hub via save_pretrained
   with tempfile.TemporaryDirectory() as tmp_dir:
     config.save_pretrained(snake_case__		, repo_id='''test-config'''		, push_to_hub=snake_case__		, use_auth_token=self._token		)

   lowerCAmelCase__       :      Any   					= BertConfig.from_pretrained(F'{USER}/test-config'		)
   for k, v in config.to_dict().items():
     if k != "transformers_version":
       self.assertEqual(snake_case__		, getattr(snake_case__		, snake_case__		)		)




 def 							UpperCAmelCase__( self						:		Optional[int]		)->	Dict:
   lowerCAmelCase__       :      List[Any]   					= BertConfig(
       vocab_size=99		, hidden_size=32		, num_hidden_layers=5		, num_attention_heads=4		, intermediate_size=37		)
   config.push_to_hub('''valid_org/test-config-org'''		, use_auth_token=self._token		)

   lowerCAmelCase__       :      Optional[int]   					= BertConfig.from_pretrained('''valid_org/test-config-org'''		)
   for k, v in config.to_dict().items():
     if k != "transformers_version":
       self.assertEqual(snake_case__		, getattr(snake_case__		, snake_case__		)		)

        # Reset repo
   delete_repo(token=self._token		, repo_id='''valid_org/test-config-org'''		)

   # Push to hub via save_pretrained
   with tempfile.TemporaryDirectory() as tmp_dir:
     config.save_pretrained(
         snake_case__		, repo_id='''valid_org/test-config-org'''		, push_to_hub=snake_case__		, use_auth_token=self._token		)

   lowerCAmelCase__       :      str   					= BertConfig.from_pretrained('''valid_org/test-config-org'''		)
   for k, v in config.to_dict().items():
     if k != "transformers_version":
       self.assertEqual(snake_case__		, getattr(snake_case__		, snake_case__		)		)




 def 							UpperCAmelCase__( self						:		Tuple		)->	Dict:
   CustomConfig.register_for_auto_class()
   lowerCAmelCase__       :      Union[str, Any]   					= CustomConfig(attribute=42		)

   config.push_to_hub('''test-dynamic-config'''		, use_auth_token=self._token		)

   # This has added the proper auto_map field to the config
   self.assertDictEqual(config.auto_map		, {'''AutoConfig''': '''custom_configuration.CustomConfig'''}		)

   lowerCAmelCase__       :      int   					= AutoConfig.from_pretrained(F'{USER}/test-dynamic-config'		, trust_remote_code=snake_case__		)
   # Can't make an isinstance check because the new_config is from the FakeConfig class of a dynamic module
   self.assertEqual(new_config.__class__.__name__		, '''CustomConfig'''		)
   self.assertEqual(new_config.attribute		, 42		)





class  _a							(    unittest.TestCase):




 def 							UpperCAmelCase__( self						:		Optional[Any]		)->	Dict:
   lowerCAmelCase__       :      Any   					= GPTaConfig()

   # attempt to modify each of int/float/bool/str config records and verify they were updated
   lowerCAmelCase__       :      Tuple   					= c.n_embd + 1  # int
   lowerCAmelCase__       :      str   					= c.resid_pdrop + 1.0  # float
   lowerCAmelCase__       :      Optional[Any]   					= not c.scale_attn_weights  # bool
   lowerCAmelCase__       :      Optional[int]   					= c.summary_type + "foo"  # str
   c.update_from_string(
       F'n_embd={n_embd},resid_pdrop={resid_pdrop},scale_attn_weights={scale_attn_weights},summary_type={summary_type}'		)
   self.assertEqual(snake_case__		, c.n_embd		, '''mismatch for key: n_embd'''		)
   self.assertEqual(snake_case__		, c.resid_pdrop		, '''mismatch for key: resid_pdrop'''		)
   self.assertEqual(snake_case__		, c.scale_attn_weights		, '''mismatch for key: scale_attn_weights'''		)
   self.assertEqual(snake_case__		, c.summary_type		, '''mismatch for key: summary_type'''		)




 def 							UpperCAmelCase__( self						:		int		)->	List[str]:
   lowerCAmelCase__       :      Tuple   					= PretrainedConfig()
   lowerCAmelCase__       :      List[str]   					= [key for key in base_config.__dict__ if key not in config_common_kwargs]
   # If this part of the test fails, you have arguments to addin config_common_kwargs above.
   self.assertListEqual(
       snake_case__		, ['''is_encoder_decoder''', '''_name_or_path''', '''_commit_hash''', '''transformers_version''']		)
   lowerCAmelCase__       :      Dict   					= [key for key, value in config_common_kwargs.items() if value == getattr(snake_case__		, snake_case__		)]
   if len(snake_case__		) > 0:
     raise ValueError(
         '''The following keys are set with the default values in'''
         ''' `test_configuration_common.config_common_kwargs` pick another value for them:'''
         F' {", ".join(snake_case__		)}.'		)




 def 							UpperCAmelCase__( self						:		Optional[int]		)->	Optional[int]:


   with self.assertRaises(snake_case__		):
     # config is in subfolder, the following should not work without specifying the subfolder
     lowerCAmelCase__       :      Optional[Any]   					= BertConfig.from_pretrained('''hf-internal-testing/tiny-random-bert-subfolder'''		)

   lowerCAmelCase__       :      Optional[Any]   					= BertConfig.from_pretrained('''hf-internal-testing/tiny-random-bert-subfolder'''		, subfolder='''bert'''		)

   self.assertIsNotNone(snake_case__		)




 def 							UpperCAmelCase__( self						:		List[str]		)->	Optional[Any]:
   lowerCAmelCase__       :      Tuple   					= mock.Mock()
   lowerCAmelCase__       :      Optional[int]   					= 500
   lowerCAmelCase__       :      Any   					= {}
   lowerCAmelCase__       :      str   					= HTTPError
   lowerCAmelCase__       :      Tuple   					= {}

   # Download this model to make sure it's in the cache.
   lowerCAmelCase__       :      List[Any]   					= BertConfig.from_pretrained('''hf-internal-testing/tiny-random-bert'''		)

   # Under the mock environment we get a 500 error when trying to reach the model.
   with mock.patch('''requests.Session.request'''		, return_value=snake_case__		) as mock_head:
     lowerCAmelCase__       :      List[str]   					= BertConfig.from_pretrained('''hf-internal-testing/tiny-random-bert'''		)
     # This check we did call the fake head request
     mock_head.assert_called()




 def 							UpperCAmelCase__( self						:		Any		)->	List[Any]:
   lowerCAmelCase__       :      Dict   					= BertConfig.from_pretrained(
       '''https://huggingface.co/hf-internal-testing/tiny-random-bert/resolve/main/config.json'''		)




 def 							UpperCAmelCase__( self						:		int		)->	str:
   lowerCAmelCase__       :      Optional[Any]   					= AutoConfig.from_pretrained('''bert-base-cased'''		)
   lowerCAmelCase__       :      int   					= ["config.4.0.0.json"]

   with tempfile.TemporaryDirectory() as tmp_dir:
     configuration.save_pretrained(snake_case__		)
     lowerCAmelCase__       :      str   					= 2
     json.dump(configuration.to_dict()		, open(os.path.join(snake_case__		, '''config.4.0.0.json'''		)		, '''w'''		)		)

     # This should pick the new configuration file as the version of Transformers is > 4.0.0
     lowerCAmelCase__       :      str   					= AutoConfig.from_pretrained(snake_case__		)
     self.assertEqual(new_configuration.hidden_size		, 2		)

     # Will need to be adjusted if we reach v42 and this test is still here.
     # Should pick the old configuration file as the version of Transformers is < 4.42.0
     lowerCAmelCase__       :      List[str]   					= ["config.42.0.0.json"]
     lowerCAmelCase__       :      Optional[int]   					= 768
     configuration.save_pretrained(snake_case__		)
     shutil.move(os.path.join(snake_case__		, '''config.4.0.0.json'''		)		, os.path.join(snake_case__		, '''config.42.0.0.json'''		)		)
     lowerCAmelCase__       :      Union[str, Any]   					= AutoConfig.from_pretrained(snake_case__		)
     self.assertEqual(new_configuration.hidden_size		, 768		)




 def 							UpperCAmelCase__( self						:		List[str]		)->	Tuple:
   lowerCAmelCase__       :      List[Any]   					= "hf-internal-testing/test-two-configs"

   import transformers as new_transformers

   lowerCAmelCase__       :      Optional[int]   					= "v4.0.0"
   lowerCAmelCase__       :      List[str]   					= new_transformers.models.auto.AutoConfig.from_pretrained(
       snake_case__		, return_unused_kwargs=snake_case__		)
   self.assertEqual(new_configuration.hidden_size		, 2		)
   # This checks `_configuration_file` ia not kept in the kwargs by mistake.
   self.assertDictEqual(snake_case__		, {}		)

   # Testing an older version by monkey-patching the version in the module it's used.
   import transformers as old_transformers

   lowerCAmelCase__       :      int   					= "v3.0.0"
   lowerCAmelCase__       :      int   					= old_transformers.models.auto.AutoConfig.from_pretrained(snake_case__		)
   self.assertEqual(old_configuration.hidden_size		, 768		)








from collections.abc import Iterable
from typing import Any





class  _a							:




	def __init__( self						:		Union[str, Any]		, _SCREAMING_SNAKE_CASE						:		int | None = None		)->	Tuple:
			lowerCAmelCase__       :      Union[str, Any]   					= value
			lowerCAmelCase__       :      Node | None   					= None  # Added in order to delete a node easier
			lowerCAmelCase__       :      Node | None   					= None
			lowerCAmelCase__       :      Node | None   					= None




	def __repr__( self						:		List[Any]		)->	str:
			from pprint import pformat

			if self.left is None and self.right is None:
					return str(self.value		)
			return pformat({F'{self.value}': (self.left, self.right)}		, indent=1		)





class  _a							:




	def __init__( self						:		Tuple		, _SCREAMING_SNAKE_CASE						:		Node | None = None		)->	int:
			lowerCAmelCase__       :      Dict   					= root




	def __str__( self						:		Tuple		)->	str:
			return str(self.root		)




	def 							UpperCAmelCase__( self						:		List[str]		, _SCREAMING_SNAKE_CASE						:		Node		, _SCREAMING_SNAKE_CASE						:		Node | None		)->	None:
			if new_children is not None:  # reset its kids
					lowerCAmelCase__       :      Union[str, Any]   					= node.parent
			if node.parent is not None:  # reset its parent
					if self.is_right(_SCREAMING_SNAKE_CASE		):  # If it is the right children
							lowerCAmelCase__       :      List[str]   					= new_children
					else:
							lowerCAmelCase__       :      Any   					= new_children
			else:
					lowerCAmelCase__       :      Optional[Any]   					= new_children




	def 							UpperCAmelCase__( self						:		List[Any]		, _SCREAMING_SNAKE_CASE						:		Node		)->	bool:
			if node.parent and node.parent.right:
					return node == node.parent.right
			return False




	def 							UpperCAmelCase__( self						:		int		)->	bool:
			return self.root is None




	def 							UpperCAmelCase__( self						:		Optional[int]		, _SCREAMING_SNAKE_CASE						:		Optional[int]		)->	None:
			lowerCAmelCase__       :      Any   					= Node(_SCREAMING_SNAKE_CASE		)  # create a new Node
			if self.empty():  # if Tree is empty
					lowerCAmelCase__       :      Optional[Any]   					= new_node  # set its root
			else:  # Tree is not empty
					lowerCAmelCase__       :      str   					= self.root  # from root
					if parent_node is None:
							return
					while True:  # While we don't get to a leaf
							if value < parent_node.value:  # We go left
									if parent_node.left is None:
											lowerCAmelCase__       :      Dict   					= new_node  # We insert the new node in a leaf
											break
									else:
											lowerCAmelCase__       :      List[Any]   					= parent_node.left
							else:
									if parent_node.right is None:
											lowerCAmelCase__       :      Tuple   					= new_node
											break
									else:
											lowerCAmelCase__       :      Union[str, Any]   					= parent_node.right
					lowerCAmelCase__       :      Dict   					= parent_node




	def 							UpperCAmelCase__( self						:		str		, *_SCREAMING_SNAKE_CASE						:		List[Any]		)->	None:
			for value in values:
					self.__insert(_SCREAMING_SNAKE_CASE		)




	def 							UpperCAmelCase__( self						:		Union[str, Any]		, _SCREAMING_SNAKE_CASE						:		Optional[int]		)->	Node | None:
			if self.empty():
					raise IndexError('''Warning: Tree is empty! please use another.'''		)
			else:
					lowerCAmelCase__       :      Union[str, Any]   					= self.root
					# use lazy evaluation here to avoid NoneType Attribute error
					while node is not None and node.value is not value:
							lowerCAmelCase__       :      List[str]   					= node.left if value < node.value else node.right
					return node




	def 							UpperCAmelCase__( self						:		Dict		, _SCREAMING_SNAKE_CASE						:		Node | None = None		)->	Node | None:
			if node is None:
					if self.root is None:
							return None
					lowerCAmelCase__       :      List[Any]   					= self.root

			if not self.empty():
					while node.right is not None:
							lowerCAmelCase__       :      str   					= node.right
			return node




	def 							UpperCAmelCase__( self						:		List[str]		, _SCREAMING_SNAKE_CASE						:		Node | None = None		)->	Node | None:
			if node is None:
					lowerCAmelCase__       :      Any   					= self.root
			if self.root is None:
					return None
			if not self.empty():
					lowerCAmelCase__       :      Dict   					= self.root
					while node.left is not None:
							lowerCAmelCase__       :      Tuple   					= node.left
			return node




	def 							UpperCAmelCase__( self						:		Any		, _SCREAMING_SNAKE_CASE						:		int		)->	None:
			lowerCAmelCase__       :      Optional[Any]   					= self.search(_SCREAMING_SNAKE_CASE		)  # Look for the node with that label
			if node is not None:
					if node.left is None and node.right is None:  # If it has no children
							self.__reassign_nodes(_SCREAMING_SNAKE_CASE		, _SCREAMING_SNAKE_CASE		)
					elif node.left is None:  # Has only right children
							self.__reassign_nodes(_SCREAMING_SNAKE_CASE		, node.right		)
					elif node.right is None:  # Has only left children
							self.__reassign_nodes(_SCREAMING_SNAKE_CASE		, node.left		)
					else:
							lowerCAmelCase__       :      Tuple   					= self.get_max(
							    node.left		)  # Gets the max value of the left branch
							self.remove(tmp_node.value		)  # type: ignore
							lowerCAmelCase__       :      Optional[Any]   					= (
							    tmp_node.value  # type: ignore
							)  # Assigns the value to the node to delete and keep tree structure




	def 							UpperCAmelCase__( self						:		Union[str, Any]		, _SCREAMING_SNAKE_CASE						:		Node | None		)->	Iterable:
			if node is not None:
					yield node  # Preorder Traversal
					yield from self.preorder_traverse(node.left		)
					yield from self.preorder_traverse(node.right		)




	def 							UpperCAmelCase__( self						:		Union[str, Any]		, _SCREAMING_SNAKE_CASE						:		Tuple=None		)->	Any:
			if traversal_function is None:
					return self.preorder_traverse(self.root		)
			else:
					return traversal_function(self.root		)




	def 							UpperCAmelCase__( self						:		Union[str, Any]		, _SCREAMING_SNAKE_CASE						:		list		, _SCREAMING_SNAKE_CASE						:		Node | None		)->	None:
			if node:
					self.inorder(_SCREAMING_SNAKE_CASE		, node.left		)
					arr.append(node.value		)
					self.inorder(_SCREAMING_SNAKE_CASE		, node.right		)




	def 							UpperCAmelCase__( self						:		Optional[Any]		, _SCREAMING_SNAKE_CASE						:		int		, _SCREAMING_SNAKE_CASE						:		Node		)->	int:
			lowerCAmelCase__       :      list[int]   					= []
			self.inorder(_SCREAMING_SNAKE_CASE		, _SCREAMING_SNAKE_CASE		)  # append all values to list using inorder traversal
			return arr[k - 1]






def 					lowerCamelCase_   (	_a	):




		"""simple docstring"""






		lowerCAmelCase__       :      List[str]   					= []
		if curr_node is not None:
				lowerCAmelCase__       :      Optional[int]   					= postorder(curr_node.left	) + postorder(curr_node.right	) + [curr_node]
		return node_list






def 					lowerCamelCase_   (	):




		"""simple docstring"""






		lowerCAmelCase__       :      List[Any]   					= (8, 3, 6, 1, 10, 14, 13, 4, 7)
		lowerCAmelCase__       :      str   					= BinarySearchTree()
		for i in testlist:
				t.insert(_a	)

		# Prints all the elements of the list in order traversal
		print(_a	)

		if t.search(6	) is not None:
				print('''The value 6 exists'''	)
		else:
				print('''The value 6 doesn\'t exist'''	)

		if t.search(-1	) is not None:
				print('''The value -1 exists'''	)
		else:
				print('''The value -1 doesn\'t exist'''	)

		if not t.empty():
				print('''Max Value: '''     ,       t.get_max().value	)  # type: ignore
				print('''Min Value: '''     ,       t.get_min().value	)  # type: ignore

		for i in testlist:
				t.remove(_a	)
				print(_a	)


if __name__ == "__main__":
		import doctest

		doctest.testmod(verbose=True)




