





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 :    Optional[int]  							= {
    '''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''': 1_2_8,
    '''add_cross_attention''': True,
    '''tie_encoder_decoder''': True,
    '''max_length''': 5_0,
    '''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''': 1_0,
    '''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''': 1_0,
    '''exponential_decay_length_penalty''': (5, 1.01),
    '''suppress_tokens''': [0, 1],
    '''begin_suppress_tokens''': 2,
    '''task_specific_params''': {'''translation''': '''some_params'''},
    '''problem_type''': '''regression''',
}


@is_staging_test
class 						lowerCamelCase       (unittest.TestCase      ):







							"""simple docstring"""




							@classmethod
							def  A_     ( cls     :					Optional[int]						)				->			int:





														"""simple docstring"""
														SCREAMING_SNAKE_CASE__       :      List[str]     =						TOKEN
														HfFolder.save_token(lowerCamelCase_						)






							@classmethod
							def  A_     ( cls     :					Dict						)				->			str:





														"""simple docstring"""
														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  A_     ( self     :					Any						)				->			str:





														"""simple docstring"""
														SCREAMING_SNAKE_CASE__       :      List[str]     =						BertConfig(
														    vocab_size=9_9,			hidden_size=3_2,			num_hidden_layers=5,			num_attention_heads=4,			intermediate_size=3_7						)
														config.push_to_hub("test-config",			use_auth_token=self._token						)

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

        # 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(lowerCamelCase_,			repo_id="test-config",			push_to_hub=lowerCamelCase_,			use_auth_token=self._token						)

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






							def  A_     ( self     :					List[str]						)				->			Union[str, Any]:





														"""simple docstring"""
														SCREAMING_SNAKE_CASE__       :      Union[str, Any]     =						BertConfig(
														    vocab_size=9_9,			hidden_size=3_2,			num_hidden_layers=5,			num_attention_heads=4,			intermediate_size=3_7						)
														config.push_to_hub("valid_org/test-config-org",			use_auth_token=self._token						)

														SCREAMING_SNAKE_CASE__       :      Union[str, Any]     =						BertConfig.from_pretrained("valid_org/test-config-org"						)
														for k, v in config.to_dict().items():
																					if k != "transformers_version":
																												self.assertEqual(lowerCamelCase_,			getattr(lowerCamelCase_,			lowerCamelCase_						)						)

        # 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(
																					    lowerCamelCase_,			repo_id="valid_org/test-config-org",			push_to_hub=lowerCamelCase_,			use_auth_token=self._token						)

														SCREAMING_SNAKE_CASE__       :      int     =						BertConfig.from_pretrained("valid_org/test-config-org"						)
														for k, v in config.to_dict().items():
																					if k != "transformers_version":
																												self.assertEqual(lowerCamelCase_,			getattr(lowerCamelCase_,			lowerCamelCase_						)						)






							def  A_     ( self     :					Union[str, Any]						)				->			List[str]:





														"""simple docstring"""
														CustomConfig.register_for_auto_class()
														SCREAMING_SNAKE_CASE__       :      Any     =						CustomConfig(attribute=4_2						)

														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"}						)

														SCREAMING_SNAKE_CASE__       :      str     =						AutoConfig.from_pretrained(F'''{USER}/test-dynamic-config''',			trust_remote_code=lowerCamelCase_						)
														# 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,			4_2						)


class 						lowerCamelCase       (unittest.TestCase      ):







							"""simple docstring"""




							def  A_     ( self     :					str						)				->			Optional[Any]:





														"""simple docstring"""
														SCREAMING_SNAKE_CASE__       :      int     =						GPTaConfig()

														# attempt to modify each of int/float/bool/str config records and verify they were updated
														SCREAMING_SNAKE_CASE__       :      List[str]     =						c.n_embd + 1  # int
														SCREAMING_SNAKE_CASE__       :      Tuple     =						c.resid_pdrop + 1.0  # float
														SCREAMING_SNAKE_CASE__       :      int     =						not c.scale_attn_weights  # bool
														SCREAMING_SNAKE_CASE__       :      Any     =						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(lowerCamelCase_,			c.n_embd,			"mismatch for key: n_embd"						)
														self.assertEqual(lowerCamelCase_,			c.resid_pdrop,			"mismatch for key: resid_pdrop"						)
														self.assertEqual(lowerCamelCase_,			c.scale_attn_weights,			"mismatch for key: scale_attn_weights"						)
														self.assertEqual(lowerCamelCase_,			c.summary_type,			"mismatch for key: summary_type"						)






							def  A_     ( self     :					Any						)				->			Any:





														"""simple docstring"""
														SCREAMING_SNAKE_CASE__       :      Union[str, Any]     =						PretrainedConfig()
														SCREAMING_SNAKE_CASE__       :      Optional[int]     =						[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(
														    lowerCamelCase_,			["is_encoder_decoder", "_name_or_path", "_commit_hash", "transformers_version"]						)
														SCREAMING_SNAKE_CASE__       :      Dict     =						[key for key, value in config_common_kwargs.items() if value == getattr(lowerCamelCase_,			lowerCamelCase_						)]
														if len(lowerCamelCase_						) > 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(lowerCamelCase_						)}.'''						)






							def  A_     ( self     :					Optional[Any]						)				->			Dict:





														"""simple docstring"""
														with self.assertRaises(lowerCamelCase_						):
																					# config is in subfolder, the following should not work without specifying the subfolder
																					SCREAMING_SNAKE_CASE__       :      str     =						BertConfig.from_pretrained("hf-internal-testing/tiny-random-bert-subfolder"						)

														SCREAMING_SNAKE_CASE__       :      Dict     =						BertConfig.from_pretrained("hf-internal-testing/tiny-random-bert-subfolder",			subfolder="bert"						)

														self.assertIsNotNone(lowerCamelCase_						)






							def  A_     ( self     :					int						)				->			List[Any]:





														"""simple docstring"""
														# A mock response for an HTTP head request to emulate server down
														SCREAMING_SNAKE_CASE__       :      int     =						mock.Mock()
														SCREAMING_SNAKE_CASE__       :      str     =						5_0_0
														SCREAMING_SNAKE_CASE__       :      Tuple     =						{}
														SCREAMING_SNAKE_CASE__       :      int     =						HTTPError
														SCREAMING_SNAKE_CASE__       :      List[Any]     =						{}

														# Download this model to make sure it's in the cache.
														SCREAMING_SNAKE_CASE__       :      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=lowerCamelCase_						) as mock_head:
																					SCREAMING_SNAKE_CASE__       :      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  A_     ( self     :					List[str]						)				->			List[str]:





														"""simple docstring"""
														# This test is for deprecated behavior and can be removed in v5
														SCREAMING_SNAKE_CASE__       :      int     =						BertConfig.from_pretrained(
														    "https://huggingface.co/hf-internal-testing/tiny-random-bert/resolve/main/config.json"						)






							def  A_     ( self     :					Optional[Any]						)				->			Union[str, Any]:





														"""simple docstring"""
														SCREAMING_SNAKE_CASE__       :      Optional[Any]     =						AutoConfig.from_pretrained("bert-base-cased"						)
														SCREAMING_SNAKE_CASE__       :      List[Any]     =						["config.4.0.0.json"]

														with tempfile.TemporaryDirectory() as tmp_dir:
																					configuration.save_pretrained(lowerCamelCase_						)
																					SCREAMING_SNAKE_CASE__       :      List[Any]     =						2
																					json.dump(configuration.to_dict(),			open(os.path.join(lowerCamelCase_,			"config.4.0.0.json"						),			"w"						)						)

																					# This should pick the new configuration file as the version of Transformers is > 4.0.0
																					SCREAMING_SNAKE_CASE__       :      Dict     =						AutoConfig.from_pretrained(lowerCamelCase_						)
																					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
																					SCREAMING_SNAKE_CASE__       :      Optional[Any]     =						["config.42.0.0.json"]
																					SCREAMING_SNAKE_CASE__       :      str     =						7_6_8
																					configuration.save_pretrained(lowerCamelCase_						)
																					shutil.move(os.path.join(lowerCamelCase_,			"config.4.0.0.json"						),			os.path.join(lowerCamelCase_,			"config.42.0.0.json"						)						)
																					SCREAMING_SNAKE_CASE__       :      Tuple     =						AutoConfig.from_pretrained(lowerCamelCase_						)
																					self.assertEqual(new_configuration.hidden_size,			7_6_8						)






							def  A_     ( self     :					str						)				->			Optional[Any]:





														"""simple docstring"""
														# This repo has two configuration files, one for v4.0.0 and above with a different hidden size.
														SCREAMING_SNAKE_CASE__       :      List[str]     =						"hf-internal-testing/test-two-configs"

														import transformers as new_transformers

														SCREAMING_SNAKE_CASE__       :      Any     =						"v4.0.0"
														SCREAMING_SNAKE_CASE__   ,SCREAMING_SNAKE_CASE__       :      Any     =						new_transformers.models.auto.AutoConfig.from_pretrained(
														    lowerCamelCase_,			return_unused_kwargs=lowerCamelCase_						)
														self.assertEqual(new_configuration.hidden_size,			2						)
														# This checks `_configuration_file` ia not kept in the kwargs by mistake.
														self.assertDictEqual(lowerCamelCase_,			{}						)

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

														SCREAMING_SNAKE_CASE__       :      Union[str, Any]     =						"v3.0.0"
														SCREAMING_SNAKE_CASE__       :      Any     =						old_transformers.models.auto.AutoConfig.from_pretrained(lowerCamelCase_						)
														self.assertEqual(old_configuration.hidden_size,			7_6_8						)













class 						lowerCamelCase       :







							"""simple docstring"""




							def __init__( self     :					int,			_UpperCAmelCase     :					Dict,			_UpperCAmelCase     :					str						)				->			Optional[Any]:





														"""simple docstring"""
														SCREAMING_SNAKE_CASE__       :      str     =						name
														SCREAMING_SNAKE_CASE__       :      Tuple     =						val






							def __str__( self     :					str						)				->			List[Any]:





														"""simple docstring"""
														return F'''{self.__class__.__name__}({self.name}, {self.val})'''






							def __lt__( self     :					str,			_UpperCAmelCase     :					Dict						)				->			Union[str, Any]:





														"""simple docstring"""
														return self.val < other.val


class 						lowerCamelCase       :







							"""simple docstring"""




							def __init__( self     :					Optional[Any],			_UpperCAmelCase     :					str						)				->			Tuple:





														"""simple docstring"""
														SCREAMING_SNAKE_CASE__       :      Optional[Any]     =						{}
														SCREAMING_SNAKE_CASE__       :      str     =						{}
														SCREAMING_SNAKE_CASE__       :      Union[str, Any]     =						self.build_heap(_UpperCAmelCase						)






							def __getitem__( self     :					Union[str, Any],			_UpperCAmelCase     :					Any						)				->			Dict:





														"""simple docstring"""
														return self.get_value(_UpperCAmelCase						)






							def  A_     ( self     :					int,			_UpperCAmelCase     :					Optional[int]						)				->			Any:





														"""simple docstring"""
														return (idx - 1) // 2






							def  A_     ( self     :					Optional[Any],			_UpperCAmelCase     :					Any						)				->			Dict:





														"""simple docstring"""
														return idx * 2 + 1






							def  A_     ( self     :					str,			_UpperCAmelCase     :					List[str]						)				->			Union[str, Any]:





														"""simple docstring"""
														return idx * 2 + 2






							def  A_     ( self     :					Tuple,			_UpperCAmelCase     :					int						)				->			Optional[int]:





														"""simple docstring"""
														return self.heap_dict[key]






							def  A_     ( self     :					Optional[int],			_UpperCAmelCase     :					Dict						)				->			Optional[Any]:





														"""simple docstring"""
														SCREAMING_SNAKE_CASE__       :      List[str]     =						len(_UpperCAmelCase						) - 1
														SCREAMING_SNAKE_CASE__       :      Optional[int]     =						self.get_parent_idx(_UpperCAmelCase						)

														for idx, i in enumerate(_UpperCAmelCase						):
																					SCREAMING_SNAKE_CASE__       :      Optional[int]     =						idx
																					SCREAMING_SNAKE_CASE__       :      Optional[Any]     =						i.val

														for i in range(_UpperCAmelCase,			-1,			-1						):
																					self.sift_down(_UpperCAmelCase,			_UpperCAmelCase						)
														return array






							def  A_     ( self     :					List[Any],			_UpperCAmelCase     :					Dict,			_UpperCAmelCase     :					Tuple						)				->			Tuple:





														"""simple docstring"""
														while True:
																					SCREAMING_SNAKE_CASE__       :      str     =						self.get_left_child_idx(_UpperCAmelCase						)  # noqa: E741
																					SCREAMING_SNAKE_CASE__       :      Tuple     =						self.get_right_child_idx(_UpperCAmelCase						)

																					SCREAMING_SNAKE_CASE__       :      Tuple     =						idx
																					if l < len(_UpperCAmelCase						) and array[l] < array[idx]:
																												SCREAMING_SNAKE_CASE__       :      List[Any]     =						l
																					if r < len(_UpperCAmelCase						) and array[r] < array[smallest]:
																												SCREAMING_SNAKE_CASE__       :      int     =						r

																					if smallest != idx:
																												SCREAMING_SNAKE_CASE__   ,SCREAMING_SNAKE_CASE__       :      Any     =						array[smallest], array[idx]
																												(
																												    (
																												    SCREAMING_SNAKE_CASE__
																												)   ,(
																												    SCREAMING_SNAKE_CASE__
																												)   ,
																												)       :      Optional[Any]     =						(
																												    self.idx_of_element[array[smallest]],
																												    self.idx_of_element[array[idx]],
																												)
																												SCREAMING_SNAKE_CASE__       :      Optional[Any]     =						smallest
																					else:
																												break






							def  A_     ( self     :					Union[str, Any],			_UpperCAmelCase     :					str						)				->			Any:





														"""simple docstring"""
														SCREAMING_SNAKE_CASE__       :      Any     =						self.get_parent_idx(_UpperCAmelCase						)
														while p >= 0 and self.heap[p] > self.heap[idx]:
																					SCREAMING_SNAKE_CASE__   ,SCREAMING_SNAKE_CASE__       :      Any     =						self.heap[idx], self.heap[p]
																					SCREAMING_SNAKE_CASE__   ,SCREAMING_SNAKE_CASE__       :      int     =						(
																					    self.idx_of_element[self.heap[idx]],
																					    self.idx_of_element[self.heap[p]],
																					)
																					SCREAMING_SNAKE_CASE__       :      Dict     =						p
																					SCREAMING_SNAKE_CASE__       :      List[str]     =						self.get_parent_idx(_UpperCAmelCase						)






							def  A_     ( self     :					str						)				->			List[str]:





														"""simple docstring"""
														return self.heap[0]






							def  A_     ( self     :					Tuple						)				->			List[Any]:





														"""simple docstring"""
														SCREAMING_SNAKE_CASE__   ,SCREAMING_SNAKE_CASE__       :      Optional[int]     =						self.heap[-1], self.heap[0]
														SCREAMING_SNAKE_CASE__   ,SCREAMING_SNAKE_CASE__       :      List[Any]     =						(
														    self.idx_of_element[self.heap[-1]],
														    self.idx_of_element[self.heap[0]],
														)

														SCREAMING_SNAKE_CASE__       :      Any     =						self.heap.pop()
														del self.idx_of_element[x]
														self.sift_down(0,			self.heap						)
														return x






							def  A_     ( self     :					Union[str, Any],			_UpperCAmelCase     :					str						)				->			Optional[Any]:





														"""simple docstring"""
														self.heap.append(_UpperCAmelCase						)
														SCREAMING_SNAKE_CASE__       :      str     =						len(self.heap						) - 1
														SCREAMING_SNAKE_CASE__       :      Optional[Any]     =						node.val
														self.sift_up(len(self.heap						) - 1						)






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





														"""simple docstring"""
														return len(self.heap						) == 0






							def  A_     ( self     :					Any,			_UpperCAmelCase     :					Tuple,			_UpperCAmelCase     :					str						)				->			Dict:





														"""simple docstring"""
														assert (
														    self.heap[self.idx_of_element[node]].val > new_value
														), "newValue must be less that current value"
														SCREAMING_SNAKE_CASE__       :      Tuple     =						new_value
														SCREAMING_SNAKE_CASE__       :      List[Any]     =						new_value
														self.sift_up(self.idx_of_element[node]						)


_lowerCamelCase :    Tuple  							= Node('''R''', -1)
_lowerCamelCase :    int  							= Node('''B''', 6)
_lowerCamelCase :    str  							= Node('''A''', 3)
_lowerCamelCase :    Optional[Any]  							= Node('''X''', 1)
_lowerCamelCase :    str  							= Node('''E''', 4)

# Use one of these two ways to generate Min-Heap

# Generating Min-Heap from array
_lowerCamelCase :    int  							= MinHeap([r, b, a, x, e])

# Generating Min-Heap by Insert method
# myMinHeap.insert(a)
# myMinHeap.insert(b)
# myMinHeap.insert(x)
# myMinHeap.insert(r)
# myMinHeap.insert(e)

# Before
print('''Min Heap - before decrease key''')
for i in my_min_heap.heap:
		print(i)

print('''Min Heap - After decrease key of node [B -> -17]''')
my_min_heap.decrease_key(b, -1_7)

# After
for i in my_min_heap.heap:
		print(i)

if __name__ == "__main__":
		import doctest

		doctest.testmod()






