



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


_UpperCamelCase											=		{
    '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    lowerCamelCase_       (							unittest.TestCase	):
  """simple docstring"""




  @classmethod
  def 		_lowercase	(					cls :      int  )   ->   Union[str, Any]:
    __lowerCamelCase			:			Union[str, Any]       			=					TOKEN
    HfFolder.save_token(_a  )




  @classmethod
  def 		_lowercase	(					cls :      str  )   ->   str:
    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 		_lowercase	(					self :      Optional[int]  )   ->   Dict:
    __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			:			Tuple       			=					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  )

    __lowerCamelCase			:			str       			=					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 		_lowercase	(					self :      str  )   ->   int:
    __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			:			str       			=					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  )

    __lowerCamelCase			:			Optional[Any]       			=					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 		_lowercase	(					self :      str  )   ->   Any:
    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			:			Union[str, Any]       			=					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 		_lowercase	(					self :      Optional[Any]  )   ->   Tuple:
    __lowerCamelCase			:			List[Any]       			=					GPTaConfig()

    # attempt to modify each of int/float/bool/str config records and verify they were updated
    __lowerCamelCase			:			Optional[Any]       			=					c.n_embd + 1  # int
    __lowerCamelCase			:			List[Any]       			=					c.resid_pdrop + 1.0  # float
    __lowerCamelCase			:			Optional[Any]       			=					not c.scale_attn_weights  # bool
    __lowerCamelCase			:			List[str]       			=					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 		_lowercase	(					self :      Dict  )   ->   Dict:
    __lowerCamelCase			:			int       			=					PretrainedConfig()
    __lowerCamelCase			:			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(
        _a     ,      ['is_encoder_decoder', '_name_or_path', '_commit_hash', 'transformers_version']  )
    __lowerCamelCase			:			Union[str, Any]       			=					[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 		_lowercase	(					self :      Any  )   ->   Optional[int]:
    with self.assertRaises(_a  ):
      # config is in subfolder, the following should not work without specifying the subfolder
      __lowerCamelCase			:			Union[str, Any]       			=					BertConfig.from_pretrained('hf-internal-testing/tiny-random-bert-subfolder'  )

    __lowerCamelCase			:			int       			=					BertConfig.from_pretrained('hf-internal-testing/tiny-random-bert-subfolder'     ,      subfolder='bert'  )

    self.assertIsNotNone(_a  )




  def 		_lowercase	(					self :      Dict  )   ->   List[str]:
    # A mock response for an HTTP head request to emulate server down
    __lowerCamelCase			:			Optional[Any]       			=					mock.Mock()
    __lowerCamelCase			:			str       			=					500
    __lowerCamelCase			:			List[str]       			=					{}
    __lowerCamelCase			:			Tuple       			=					HTTPError
    __lowerCamelCase			:			str       			=					{}

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




  def 		_lowercase	(					self :      List[str]  )   ->   Union[str, Any]:
    # This test is for deprecated behavior and can be removed in v5
    __lowerCamelCase			:			List[Any]       			=					BertConfig.from_pretrained(
        'https://huggingface.co/hf-internal-testing/tiny-random-bert/resolve/main/config.json'  )




  def 		_lowercase	(					self :      Optional[Any]  )   ->   List[str]:
    __lowerCamelCase			:			Dict       			=					AutoConfig.from_pretrained('bert-base-cased'  )
    __lowerCamelCase			:			List[Any]       			=					['config.4.0.0.json']

    with tempfile.TemporaryDirectory() as tmp_dir:
      configuration.save_pretrained(_a  )
      __lowerCamelCase			:			Dict       			=					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
      __lowerCamelCase			:			Optional[int]       			=					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
      __lowerCamelCase			:			int       			=					['config.42.0.0.json']
      __lowerCamelCase			:			Optional[int]       			=					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'  )  )
      __lowerCamelCase			:			Any       			=					AutoConfig.from_pretrained(_a  )
      self.assertEqual(new_configuration.hidden_size     ,      768  )




  def 		_lowercase	(					self :      Tuple  )   ->   Union[str, Any]:
    # This repo has two configuration files, one for v4.0.0 and above with a different hidden size.
    __lowerCamelCase			:			List[Any]       			=					'hf-internal-testing/test-two-configs'

    import transformers as new_transformers

    __lowerCamelCase			:			Tuple       			=					'v4.0.0'
    __lowerCamelCase			,__lowerCamelCase			:			Optional[int]       			=					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

    __lowerCamelCase			:			Tuple       			=					'v3.0.0'
    __lowerCamelCase			:			int       			=					old_transformers.models.auto.AutoConfig.from_pretrained(_a  )
    self.assertEqual(old_configuration.hidden_size     ,      768  )











'''simple docstring'''





# Algorithm for the pigeonhole sorting



def 			a_	(				_lowerCAmelCase			) -> List[str]:
  __lowerCamelCase			:			int       			=					min(_lowerCAmelCase			)  # min() finds the minimum value
  __lowerCamelCase			:			List[Any]       			=					max(_lowerCAmelCase			)  # max() finds the maximum value

  __lowerCamelCase			:			List[Any]       			=					max_val - min_val + 1  # size is difference of max and min values plus one

  # list of pigeonholes of size equal to the variable size
  __lowerCamelCase			:			List[Any]       			=					[0] * size

  # Populate the pigeonholes.
  for x in a:
    assert isinstance(_lowerCAmelCase			,_lowerCAmelCase			), "integers only please"
    holes[x - min_val] += 1

  # Putting the elements back into the array in an order.
  __lowerCamelCase			:			Tuple       			=					0
  for count in range(_lowerCAmelCase			):
    while holes[count] > 0:
      holes[count] -= 1
      __lowerCamelCase			:			List[Any]       			=					count + min_val
      i += 1

def 			a_	(				) -> str:
  __lowerCamelCase			:			Optional[Any]       			=					[8, 3, 2, 7, 4, 6, 8]
  pigeonhole_sort(_lowerCAmelCase			)
  print('Sorted order is:'			,' '.join(_lowerCAmelCase			)			)


if __name__ == "__main__":
   main()






