
"""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 					lowerCAmelCase_					(   unittest.TestCase     ):



						'''simple docstring'''


						@classmethod
						def     _SCREAMING_SNAKE_CASE   (			cls  :   Optional[Any]   )  -> str:
							A     = TOKEN
							HfFolder.save_token(A_   )


						@classmethod
						def     _SCREAMING_SNAKE_CASE   (			cls  :   int   )  -> Optional[int]:
							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     _SCREAMING_SNAKE_CASE   (			self  :   Tuple   )  -> Optional[Any]:
							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(A_	,getattr(A_	,A_   )   )

        # 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(A_	,repo_id='test-config'	,push_to_hub=A_	,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(A_	,getattr(A_	,A_   )   )


						def     _SCREAMING_SNAKE_CASE   (			self  :   Any   )  -> Optional[int]:
							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(A_	,getattr(A_	,A_   )   )

        # 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(
								    A_	,repo_id='valid_org/test-config-org'	,push_to_hub=A_	,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(A_	,getattr(A_	,A_   )   )




						def     _SCREAMING_SNAKE_CASE   (			self  :   int   )  -> int:
							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=A_   )
							# 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 					lowerCAmelCase_					(   unittest.TestCase     ):



						'''simple docstring'''


						def     _SCREAMING_SNAKE_CASE   (			self  :   Dict   )  -> Dict:
							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(A_	,c.n_embd	,'mismatch for key: n_embd'   )
							self.assertEqual(A_	,c.resid_pdrop	,'mismatch for key: resid_pdrop'   )
							self.assertEqual(A_	,c.scale_attn_weights	,'mismatch for key: scale_attn_weights'   )
							self.assertEqual(A_	,c.summary_type	,'mismatch for key: summary_type'   )


						def     _SCREAMING_SNAKE_CASE   (			self  :   Tuple   )  -> List[str]:
							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(
							    A_	,['is_encoder_decoder', '_name_or_path', '_commit_hash', 'transformers_version']   )
							A     = [key for key, value in config_common_kwargs.items() if value == getattr(A_	,A_   )]
							if len(A_   ) > 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(A_   )}.'   )


						def     _SCREAMING_SNAKE_CASE   (			self  :   List[Any]   )  -> str:
							with self.assertRaises(A_   ):
								# 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(A_   )


						def     _SCREAMING_SNAKE_CASE   (			self  :   Optional[Any]   )  -> Optional[Any]:
							# A mock response for an HTTP head request to emulate server down
							A     = mock.Mock()
							A     = 500
							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=A_   ) 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     _SCREAMING_SNAKE_CASE   (			self  :   Optional[int]   )  -> List[Any]:
							# 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     _SCREAMING_SNAKE_CASE   (			self  :   str   )  -> Union[str, Any]:
							A     = AutoConfig.from_pretrained('bert-base-cased'   )
							A     = ['config.4.0.0.json']

							with tempfile.TemporaryDirectory() as tmp_dir:
								configuration.save_pretrained(A_   )
								A     = 2
								json.dump(configuration.to_dict()	,open(os.path.join(A_	,'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(A_   )
								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     = 768
								configuration.save_pretrained(A_   )
								shutil.move(os.path.join(A_	,'config.4.0.0.json'   )	,os.path.join(A_	,'config.42.0.0.json'   )   )
								A     = AutoConfig.from_pretrained(A_   )
								self.assertEqual(new_configuration.hidden_size	,768   )




						def     _SCREAMING_SNAKE_CASE   (			self  :   Optional[Any]   )  -> int:
							# 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(
							    A_	,return_unused_kwargs=A_   )
							self.assertEqual(new_configuration.hidden_size	,2   )
							# This checks `_configuration_file` ia not kept in the kwargs by mistake.
							self.assertDictEqual(A_	,{}   )

							# 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(A_   )
							self.assertEqual(old_configuration.hidden_size	,768   )



from __future__ import annotations




def    a__    (		snake_case__					:							list[int]     ):
  if len(snake_case__     ) == 0:
    return array

  _UpperCAmelCase,_UpperCAmelCase		:							List[str]							=     min(snake_case__     ), max(snake_case__     )

  # Compute the variables
  _UpperCAmelCase		:							Tuple							=     _max - _min + 1
  _UpperCAmelCase,_UpperCAmelCase		:							Union[str, Any]							=     [0] * holes_range, [0] * holes_range

  # Make the sorting.
  for i in array:
    _UpperCAmelCase		:							Optional[int]							=     i - _min
    _UpperCAmelCase		:							Any							=     i
    holes_repeat[index] += 1

  # Makes the array back by replacing the numbers.
  _UpperCAmelCase		:							List[Any]							=     0
  for i in range(snake_case__     ):
    while holes_repeat[i] > 0:
      _UpperCAmelCase		:							Optional[Any]							=     holes[i]
      index += 1
      holes_repeat[i] -= 1

    # Returns the sorted array.
  return array


if __name__ == "__main__":
 import doctest

 doctest.testmod()
 SCREAMING_SNAKE_CASE__					:     Dict       =     input('Enter numbers separated by comma:\n')
 SCREAMING_SNAKE_CASE__					:     Optional[int]       =     [int(x) for x in user_input.split(',')]
 print(pigeon_sort(unsorted))





