





import copy
import tempfile
import unittest

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

from transformers import AutoConfig, GenerationConfig
from transformers.testing_utils import TOKEN, USER, is_staging_test

class 		UpperCamelCase__			(				unittest.TestCase       ):



     '''simple docstring'''

     @parameterized.expand([(None,), ("""foo.json""",)]	)
     def     SCREAMING_SNAKE_CASE__  (							self						:   int						,lowerCamelCase__						:   int	)					->		Any:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE		=						GenerationConfig(
               do_sample=lowerCamelCase__						,temperature=0.7						,length_penalty=1.0						,bad_words_ids=[[1, 2, 3], [4, 5]]						,)
           with tempfile.TemporaryDirectory() as tmp_dir:
                 config.save_pretrained(lowerCamelCase__						,config_name=lowerCamelCase__	)
                 SCREAMING_SNAKE_CASE		=						GenerationConfig.from_pretrained(lowerCamelCase__						,config_name=lowerCamelCase__	)

           # Checks parameters that were specified
           self.assertEqual(loaded_config.do_sample						,lowerCamelCase__	)
           self.assertEqual(loaded_config.temperature						,0.7	)
           self.assertEqual(loaded_config.length_penalty						,1.0	)
           self.assertEqual(loaded_config.bad_words_ids						,[[1, 2, 3], [4, 5]]	)

           # Checks parameters that were not specified (defaults)
           self.assertEqual(loaded_config.top_k						,50	)
           self.assertEqual(loaded_config.max_length						,20	)
           self.assertEqual(loaded_config.max_time						,lowerCamelCase__	)






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




           '''simple docstring'''


           SCREAMING_SNAKE_CASE		=						AutoConfig.from_pretrained("""gpt2"""	)
           SCREAMING_SNAKE_CASE		=						GenerationConfig.from_model_config(lowerCamelCase__	)
           SCREAMING_SNAKE_CASE		=						GenerationConfig()

           # The generation config has loaded a few non-default parameters from the model config
           self.assertNotEqual(lowerCamelCase__						,lowerCamelCase__	)

           # One of those parameters is eos_token_id -- check if it matches
           self.assertNotEqual(generation_config_from_model.eos_token_id						,default_generation_config.eos_token_id	)
           self.assertEqual(generation_config_from_model.eos_token_id						,model_config.eos_token_id	)






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




           '''simple docstring'''


           SCREAMING_SNAKE_CASE		=						GenerationConfig()
           SCREAMING_SNAKE_CASE		=						{
               """max_new_tokens""": 1024,
               """foo""": """bar""",
           }
           SCREAMING_SNAKE_CASE		=						copy.deepcopy(lowerCamelCase__	)
           SCREAMING_SNAKE_CASE		=						generation_config.update(**lowerCamelCase__	)

           # update_kwargs was not modified (no side effects)
           self.assertEqual(lowerCamelCase__						,lowerCamelCase__	)

           # update_kwargs was used to update the config on valid attributes
           self.assertEqual(generation_config.max_new_tokens						,1024	)

           # `.update()` returns a dictionary of unused kwargs
           self.assertEqual(lowerCamelCase__						,{"""foo""": """bar"""}	)






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




           '''simple docstring'''


           SCREAMING_SNAKE_CASE		=						GenerationConfig()
           SCREAMING_SNAKE_CASE		=						"""bar"""

           with tempfile.TemporaryDirectory("""test-generation-config"""	) as tmp_dir:
                 generation_config.save_pretrained(lowerCamelCase__	)

                 SCREAMING_SNAKE_CASE		=						GenerationConfig.from_pretrained(lowerCamelCase__	)
           # update_kwargs was used to update the config on valid attributes
           self.assertEqual(new_config.foo						,"""bar"""	)

           SCREAMING_SNAKE_CASE		=						GenerationConfig.from_model_config(lowerCamelCase__	)
           assert not hasattr(lowerCamelCase__						,"""foo"""	)  # no new kwargs should be initialized if from config






     def     SCREAMING_SNAKE_CASE__  (							self						:   Tuple	)					->		int:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE		=						GenerationConfig()
           self.assertEqual(default_config.temperature						,1.0	)
           self.assertEqual(default_config.do_sample						,lowerCamelCase__	)
           self.assertEqual(default_config.num_beams						,1	)

           SCREAMING_SNAKE_CASE		=						GenerationConfig(
               do_sample=lowerCamelCase__						,temperature=0.7						,length_penalty=1.0						,bad_words_ids=[[1, 2, 3], [4, 5]]						,)
           self.assertEqual(config.temperature						,0.7	)
           self.assertEqual(config.do_sample						,lowerCamelCase__	)
           self.assertEqual(config.num_beams						,1	)

           with tempfile.TemporaryDirectory() as tmp_dir:
                 config.save_pretrained(lowerCamelCase__	)
                 SCREAMING_SNAKE_CASE		=						GenerationConfig.from_pretrained(lowerCamelCase__						,temperature=1.0	)

           self.assertEqual(loaded_config.temperature						,1.0	)
           self.assertEqual(loaded_config.do_sample						,lowerCamelCase__	)
           self.assertEqual(loaded_config.num_beams						,1	)  # default value

@is_staging_test
class 		UpperCamelCase__			(				unittest.TestCase       ):



     '''simple docstring'''

     @classmethod
     def     SCREAMING_SNAKE_CASE__  (							cls						:   Optional[int]	)					->		List[str]:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE		=						TOKEN
           HfFolder.save_token(lowerCamelCase__	)






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




           '''simple docstring'''


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

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






     def     SCREAMING_SNAKE_CASE__  (							self						:   List[Any]	)					->		Any:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE		=						GenerationConfig(
               do_sample=lowerCamelCase__						,temperature=0.7						,length_penalty=1.0						,)
           config.push_to_hub("""test-generation-config"""						,use_auth_token=self._token	)

           SCREAMING_SNAKE_CASE		=						GenerationConfig.from_pretrained(F"""{USER}/test-generation-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-generation-config"""	)

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

           SCREAMING_SNAKE_CASE		=						GenerationConfig.from_pretrained(F"""{USER}/test-generation-config"""	)
           for k, v in config.to_dict().items():
                 if k != "transformers_version":
                       self.assertEqual(lowerCamelCase__						,getattr(lowerCamelCase__						,lowerCamelCase__	)	)






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




           '''simple docstring'''


           SCREAMING_SNAKE_CASE		=						GenerationConfig(
               do_sample=lowerCamelCase__						,temperature=0.7						,length_penalty=1.0						,)
           config.push_to_hub("""valid_org/test-generation-config-org"""						,use_auth_token=self._token	)

           SCREAMING_SNAKE_CASE		=						GenerationConfig.from_pretrained("""valid_org/test-generation-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-generation-config-org"""	)

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

           SCREAMING_SNAKE_CASE		=						GenerationConfig.from_pretrained("""valid_org/test-generation-config-org"""	)
           for k, v in config.to_dict().items():
                 if k != "transformers_version":
                       self.assertEqual(lowerCamelCase__						,getattr(lowerCamelCase__						,lowerCamelCase__	)	)









from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


SCREAMING_SNAKE_CASE_						       =	{
    """configuration_megatron_bert""": ["""MEGATRON_BERT_PRETRAINED_CONFIG_ARCHIVE_MAP""", """MegatronBertConfig"""],
}

try:
      if not is_torch_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      SCREAMING_SNAKE_CASE_						       =	[
          """MEGATRON_BERT_PRETRAINED_MODEL_ARCHIVE_LIST""",
          """MegatronBertForCausalLM""",
          """MegatronBertForMaskedLM""",
          """MegatronBertForMultipleChoice""",
          """MegatronBertForNextSentencePrediction""",
          """MegatronBertForPreTraining""",
          """MegatronBertForQuestionAnswering""",
          """MegatronBertForSequenceClassification""",
          """MegatronBertForTokenClassification""",
          """MegatronBertModel""",
          """MegatronBertPreTrainedModel""",
      ]

if TYPE_CHECKING:
      from .configuration_megatron_bert import MEGATRON_BERT_PRETRAINED_CONFIG_ARCHIVE_MAP, MegatronBertConfig

      try:
            if not is_torch_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .modeling_megatron_bert import (
                MEGATRON_BERT_PRETRAINED_MODEL_ARCHIVE_LIST,
                MegatronBertForCausalLM,
                MegatronBertForMaskedLM,
                MegatronBertForMultipleChoice,
                MegatronBertForNextSentencePrediction,
                MegatronBertForPreTraining,
                MegatronBertForQuestionAnswering,
                MegatronBertForSequenceClassification,
                MegatronBertForTokenClassification,
                MegatronBertModel,
                MegatronBertPreTrainedModel,
            )

else:
      import sys

      SCREAMING_SNAKE_CASE_						       =	_LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)


