
'''simple docstring'''
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


lowercase__											={
    '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_28,
    '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.01),
    '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 					lowerCAmelCase__					(       cls	):
				a_      				=						TOKEN
				HfFolder.save_token(UpperCAmelCase	)




			@classmethod
			def 					lowerCAmelCase__					(       cls	):
				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 					lowerCAmelCase__					(       self	):
				a_      				=						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	)

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

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

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




			def 					lowerCAmelCase__					(       self	):
				a_      				=						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	)

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

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

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






			def 					lowerCAmelCase__					(       self	):
				CustomConfig.register_for_auto_class()
				a_      				=						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"""}	)

				a_      				=						AutoConfig.from_pretrained(f'''{USER}/test-dynamic-config'''					,   trust_remote_code=UpperCAmelCase	)
				# 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 					lowerCAmelCase__					(       self	):
				a_      				=						GPTaConfig()

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




			def 					lowerCAmelCase__					(       self	):
				a_      				=						PretrainedConfig()
				a_      				=						[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(
				    UpperCAmelCase					,   ["""is_encoder_decoder""", """_name_or_path""", """_commit_hash""", """transformers_version"""]	)
				a_      				=						[key for key, value in config_common_kwargs.items() if value == getattr(UpperCAmelCase					,   UpperCAmelCase	)]
				if len(UpperCAmelCase	) > 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(UpperCAmelCase	)}.'''	)




			def 					lowerCAmelCase__					(       self	):
				with self.assertRaises(UpperCAmelCase	):
					# config is in subfolder, the following should not work without specifying the subfolder
					a_      				=						BertConfig.from_pretrained("""hf-internal-testing/tiny-random-bert-subfolder"""	)

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

				self.assertIsNotNone(UpperCAmelCase	)




			def 					lowerCAmelCase__					(       self	):
				# A mock response for an HTTP head request to emulate server down
				a_      				=						mock.Mock()
				a_      				=						5_00
				a_      				=						{}
				a_      				=						HTTPError
				a_      				=						{}

				# Download this model to make sure it's in the cache.
				a_      				=						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=UpperCAmelCase	) as mock_head:
					a_      				=						BertConfig.from_pretrained("""hf-internal-testing/tiny-random-bert"""	)
					# This check we did call the fake head request
					mock_head.assert_called()




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




			def 					lowerCAmelCase__					(       self	):
				a_      				=						AutoConfig.from_pretrained("""bert-base-cased"""	)
				a_      				=						["""config.4.0.0.json"""]

				with tempfile.TemporaryDirectory() as tmp_dir:
					configuration.save_pretrained(UpperCAmelCase	)
					a_      				=						2
					json.dump(configuration.to_dict()					,   open(os.path.join(UpperCAmelCase					,   """config.4.0.0.json"""	)					,   """w"""	)	)

					# This should pick the new configuration file as the version of Transformers is > 4.0.0
					a_      				=						AutoConfig.from_pretrained(UpperCAmelCase	)
					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
					a_      				=						["""config.42.0.0.json"""]
					a_      				=						7_68
					configuration.save_pretrained(UpperCAmelCase	)
					shutil.move(os.path.join(UpperCAmelCase					,   """config.4.0.0.json"""	)					,   os.path.join(UpperCAmelCase					,   """config.42.0.0.json"""	)	)
					a_      				=						AutoConfig.from_pretrained(UpperCAmelCase	)
					self.assertEqual(new_configuration.hidden_size					,   7_68	)






			def 					lowerCAmelCase__					(       self	):
				# This repo has two configuration files, one for v4.0.0 and above with a different hidden size.
				a_      				=						"""hf-internal-testing/test-two-configs"""

				import transformers as new_transformers

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

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

				a_      				=						"""v3.0.0"""
				a_      				=						old_transformers.models.auto.AutoConfig.from_pretrained(UpperCAmelCase	)
				self.assertEqual(old_configuration.hidden_size					,   7_68	)


'''simple docstring'''
from typing import Any







class   a_ :




			def __init__(       self					,   UpperCAmelCase	):
				a_      				=						data
				a_      				=						None







class   a_ :




			def __init__(       self	):
				a_      				=						None




			def 					lowerCAmelCase__					(       self	):
				a_      				=						self.head
				while temp is not None:
					print(temp.data					,   end=""" """	)
					a_      				=						temp.next
				print()




			def 					lowerCAmelCase__					(       self					,   UpperCAmelCase	):
				a_      				=						Node(UpperCAmelCase	)
				a_      				=						self.head
				a_      				=						new_node






			def 					lowerCAmelCase__					(       self					,   UpperCAmelCase					,   UpperCAmelCase	):
				if node_data_a == node_data_a:
					return
				else:
					a_      				=						self.head
					while node_a is not None and node_a.data != node_data_a:
						a_      				=						node_a.next

					a_      				=						self.head
					while node_a is not None and node_a.data != node_data_a:
						a_      				=						node_a.next

					if node_a is None or node_a is None:
						return

					a_				,  a_      				=						node_a.data, node_a.data


if __name__ == "__main__":
		lowercase__											=LinkedList()
		for i in range(5, 0, -1):
				ll.push(i)

		ll.print_list()

		ll.swap_nodes(1, 4)
		print('After swapping')
		ll.print_list()
