





'''simple docstring'''

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

    '''simple docstring'''


    @parameterized.expand([(None,), ("""foo.json""",)]       )
    def 			snake_case_(		self ,		A       )		->   Dict:
        _SCREAMING_SNAKE_CASE									=			GenerationConfig(
            do_sample=A ,		temperature=0.7 ,		length_penalty=1.0 ,		bad_words_ids=[[1, 2, 3], [4, 5]] ,		)
        with tempfile.TemporaryDirectory() as tmp_dir:
            config.save_pretrained(A ,		config_name=A       )
            _SCREAMING_SNAKE_CASE									=			GenerationConfig.from_pretrained(A ,		config_name=A       )

        # Checks parameters that were specified
        self.assertEqual(loaded_config.do_sample ,		A       )
        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 ,		A       )


    def 			snake_case_(		self       )		->   List[Any]:
        _SCREAMING_SNAKE_CASE									=			AutoConfig.from_pretrained("""gpt2"""       )
        _SCREAMING_SNAKE_CASE									=			GenerationConfig.from_model_config(A       )
        _SCREAMING_SNAKE_CASE									=			GenerationConfig()

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

        # 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 			snake_case_(		self       )		->   Dict:
        _SCREAMING_SNAKE_CASE									=			GenerationConfig()
        _SCREAMING_SNAKE_CASE									=			{
            """max_new_tokens""": 1024,
            """foo""": """bar""",
        }
        _SCREAMING_SNAKE_CASE									=			copy.deepcopy(A       )
        _SCREAMING_SNAKE_CASE									=			generation_config.update(**A       )

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

        # 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(A ,		{"""foo""": """bar"""}       )


    def 			snake_case_(		self       )		->   str:
        _SCREAMING_SNAKE_CASE									=			GenerationConfig()
        _SCREAMING_SNAKE_CASE									=			"""bar"""

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

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

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





    def 			snake_case_(		self       )		->   List[str]:
        _SCREAMING_SNAKE_CASE									=			GenerationConfig()
        self.assertEqual(default_config.temperature ,		1.0       )
        self.assertEqual(default_config.do_sample ,		A       )
        self.assertEqual(default_config.num_beams ,		1       )

        _SCREAMING_SNAKE_CASE									=			GenerationConfig(
            do_sample=A ,		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 ,		A       )
        self.assertEqual(config.num_beams ,		1       )

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

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




@is_staging_test
class 					a_     (				unittest.TestCase       ):

    '''simple docstring'''


    @classmethod
    def 			snake_case_(		cls       )		->   Optional[int]:
        _SCREAMING_SNAKE_CASE									=			TOKEN
        HfFolder.save_token(A       )


    @classmethod
    def 			snake_case_(		cls       )		->   Optional[Any]:
        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 			snake_case_(		self       )		->   List[Any]:
        _SCREAMING_SNAKE_CASE									=			GenerationConfig(
            do_sample=A ,		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(A ,		getattr(A ,		A       )       )

        # 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(
                A ,		repo_id="""test-generation-config""" ,		push_to_hub=A ,		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(A ,		getattr(A ,		A       )       )





    def 			snake_case_(		self       )		->   Tuple:
        _SCREAMING_SNAKE_CASE									=			GenerationConfig(
            do_sample=A ,		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(A ,		getattr(A ,		A       )       )

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










'''simple docstring'''

from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_sentencepiece_available,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


lowercase_					= {"""configuration_mbart""": ["""MBART_PRETRAINED_CONFIG_ARCHIVE_MAP""", """MBartConfig""", """MBartOnnxConfig"""]}

try:
      if not is_sentencepiece_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      lowercase_					= ["""MBartTokenizer"""]

try:
      if not is_tokenizers_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      lowercase_					= ["""MBartTokenizerFast"""]

try:
      if not is_torch_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      lowercase_					= [
          """MBART_PRETRAINED_MODEL_ARCHIVE_LIST""",
          """MBartForCausalLM""",
          """MBartForConditionalGeneration""",
          """MBartForQuestionAnswering""",
          """MBartForSequenceClassification""",
          """MBartModel""",
          """MBartPreTrainedModel""",
      ]

try:
      if not is_tf_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      lowercase_					= [
          """TFMBartForConditionalGeneration""",
          """TFMBartModel""",
          """TFMBartPreTrainedModel""",
      ]

try:
      if not is_flax_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      lowercase_					= [
          """FlaxMBartForConditionalGeneration""",
          """FlaxMBartForQuestionAnswering""",
          """FlaxMBartForSequenceClassification""",
          """FlaxMBartModel""",
          """FlaxMBartPreTrainedModel""",
      ]


if TYPE_CHECKING:
      from .configuration_mbart import MBART_PRETRAINED_CONFIG_ARCHIVE_MAP, MBartConfig, MBartOnnxConfig

      try:
            if not is_sentencepiece_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .tokenization_mbart import MBartTokenizer

      try:
            if not is_tokenizers_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .tokenization_mbart_fast import MBartTokenizerFast

      try:
            if not is_torch_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .modeling_mbart import (
                MBART_PRETRAINED_MODEL_ARCHIVE_LIST,
                MBartForCausalLM,
                MBartForConditionalGeneration,
                MBartForQuestionAnswering,
                MBartForSequenceClassification,
                MBartModel,
                MBartPreTrainedModel,
            )

      try:
            if not is_tf_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .modeling_tf_mbart import TFMBartForConditionalGeneration, TFMBartModel, TFMBartPreTrainedModel

      try:
            if not is_flax_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .modeling_flax_mbart import (
                FlaxMBartForConditionalGeneration,
                FlaxMBartForQuestionAnswering,
                FlaxMBartForSequenceClassification,
                FlaxMBartModel,
                FlaxMBartPreTrainedModel,
            )

else:
      import sys

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



