





'''simple docstring'''






import copy
import json
import os
import tempfile

from transformers import is_torch_available

from .test_configuration_utils import config_common_kwargs




class 					UpperCAmelCase	(     _lowercase  ):




      def __init__(     self     :					List[Any]     ,     __snake_case     :					Union[str, Any]     ,     __snake_case     :					Dict=None     ,     __snake_case     :					int=True     ,     __snake_case     :					Any=None     ,     **__snake_case     :					List[str]    )							-> str:
            _lowerCAmelCase					=				parent
            _lowerCAmelCase					=				config_class
            _lowerCAmelCase					=				has_text_modality
            _lowerCAmelCase					=				kwargs
            _lowerCAmelCase					=				common_properties




      def 							lowercase__       (     self     :					Any    )							-> Optional[int]:
            _lowerCAmelCase					=				self.config_class(**self.inputs_dict    )
            _lowerCAmelCase					=				(
                ["""hidden_size""", """num_attention_heads""", """num_hidden_layers"""]
                if self.common_properties is None
                else self.common_properties
            )

            # Add common fields for text models
            if self.has_text_modality:
                  common_properties.extend(["""vocab_size"""]    )

            # Test that config has the common properties as getters
            for prop in common_properties:
                  self.parent.assertTrue(hasattr(_snake_case     ,     _snake_case    )     ,     msg=f"`{prop}` does not exist"    )

            # Test that config has the common properties as setter
            for idx, name in enumerate(_snake_case    ):
                  try:
                        setattr(_snake_case     ,     _snake_case     ,     _snake_case    )
                        self.parent.assertEqual(
                            getattr(_snake_case     ,     _snake_case    )     ,     _snake_case     ,     msg=f"`{name} value {idx} expected, but was {getattr(_snake_case     ,     _snake_case    )}"    )
                  except NotImplementedError:
                        # Some models might not be able to implement setters for common_properties
                        # In that case, a NotImplementedError is raised
                        pass

        # Test if config class can be called with Config(prop_name=..)
            for idx, name in enumerate(_snake_case    ):
                  try:
                        _lowerCAmelCase					=				self.config_class(**{name: idx}    )
                        self.parent.assertEqual(
                            getattr(_snake_case     ,     _snake_case    )     ,     _snake_case     ,     msg=f"`{name} value {idx} expected, but was {getattr(_snake_case     ,     _snake_case    )}"    )
                  except NotImplementedError:
                        # Some models might not be able to implement setters for common_properties
                        # In that case, a NotImplementedError is raised
                        pass




      def 							lowercase__       (     self     :					str    )							-> Union[str, Any]:
            _lowerCAmelCase					=				self.config_class(**self.inputs_dict    )
            _lowerCAmelCase					=				json.loads(config.to_json_string()    )
            for key, value in self.inputs_dict.items():
                  self.parent.assertEqual(obj[key]     ,     _snake_case    )




      def 							lowercase__       (     self     :					Optional[Any]    )							-> Optional[int]:
            _lowerCAmelCase					=				self.config_class(**self.inputs_dict    )

            with tempfile.TemporaryDirectory() as tmpdirname:
                  _lowerCAmelCase					=				os.path.join(_snake_case     ,     """config.json"""    )
                  config_first.to_json_file(_snake_case    )
                  _lowerCAmelCase					=				self.config_class.from_json_file(_snake_case    )

            self.parent.assertEqual(config_second.to_dict()     ,     config_first.to_dict()    )




      def 							lowercase__       (     self     :					List[Any]    )							-> Optional[Any]:
            _lowerCAmelCase					=				self.config_class(**self.inputs_dict    )

            with tempfile.TemporaryDirectory() as tmpdirname:
                  config_first.save_pretrained(_snake_case    )
                  _lowerCAmelCase					=				self.config_class.from_pretrained(_snake_case    )

            self.parent.assertEqual(config_second.to_dict()     ,     config_first.to_dict()    )




      def 							lowercase__       (     self     :					Optional[Any]    )							-> str:
            _lowerCAmelCase					=				self.config_class(**self.inputs_dict    )

            _lowerCAmelCase					=				"""test"""
            with tempfile.TemporaryDirectory() as tmpdirname:
                  _lowerCAmelCase					=				os.path.join(_snake_case     ,     _snake_case    )
                  config_first.save_pretrained(_snake_case    )
                  _lowerCAmelCase					=				self.config_class.from_pretrained(_snake_case     ,     subfolder=_snake_case    )

            self.parent.assertEqual(config_second.to_dict()     ,     config_first.to_dict()    )




      def 							lowercase__       (     self     :					Union[str, Any]    )							-> int:
            _lowerCAmelCase					=				self.config_class(**self.inputs_dict     ,     num_labels=5    )
            self.parent.assertEqual(len(config.idalabel    )     ,     5    )
            self.parent.assertEqual(len(config.labelaid    )     ,     5    )

            _lowerCAmelCase					=				3
            self.parent.assertEqual(len(config.idalabel    )     ,     3    )
            self.parent.assertEqual(len(config.labelaid    )     ,     3    )




      def 							lowercase__       (     self     :					Any    )							-> List[Any]:
            if self.config_class.is_composition:
                  return
            _lowerCAmelCase					=				self.config_class()
            self.parent.assertIsNotNone(_snake_case    )




      def 							lowercase__       (     self     :					Any    )							-> Optional[int]:
            _lowerCAmelCase					=				copy.deepcopy(_snake_case    )
            _lowerCAmelCase					=				self.config_class(**_snake_case    )
            _lowerCAmelCase					=				[]
            for key, value in config_common_kwargs.items():
                  if key == "torch_dtype":
                        if not is_torch_available():
                              continue
                        else:
                              import torch

                              if config.torch_dtype != torch.floataa:
                                    wrong_values.append(("""torch_dtype""", config.torch_dtype, torch.floataa)    )
                  elif getattr(_snake_case     ,     _snake_case    ) != value:
                        wrong_values.append((key, getattr(_snake_case     ,     _snake_case    ), value)    )

            if len(_snake_case    ) > 0:
                  _lowerCAmelCase					=				"""\n""".join([f"- {v[0]}: got {v[1]} instead of {v[2]}" for v in wrong_values]    )
                  raise ValueError(f"The following keys were not properly set in the config:\n{errors}"    )




      def 							lowercase__       (     self     :					Optional[Any]    )							-> List[str]:
            self.create_and_test_config_common_properties()
            self.create_and_test_config_to_json_string()
            self.create_and_test_config_to_json_file()
            self.create_and_test_config_from_and_save_pretrained()
            self.create_and_test_config_from_and_save_pretrained_subfolder()
            self.create_and_test_config_with_num_labels()
            self.check_config_can_be_init_without_params()
            self.check_config_arguments_init()








"""simple docstring"""





import random
import unittest

import numpy as np

import transformers
from transformers import is_flax_available, is_torch_available
from transformers.testing_utils import is_pt_flax_cross_test, require_flax


if is_flax_available():
		import os

		import jax.numpy as jnp
		from jax import jit

		from transformers import AutoTokenizer, FlaxAutoModelForCausalLM
		from transformers.modeling_flax_pytorch_utils import load_flax_weights_in_pytorch_model

		UpperCamelCase_       :    List[Any]						      =			'''0.12'''  # assumed parallelism: 8


if is_torch_available():
		import torch
def 				A_  (__a					, __a					, __a=None					):

					'''simple docstring'''





					if rng is None:
										A_								=    random.Random()

					A_								=    1
					for dim in shape:
										total_dims *= dim

					A_								=    []
					for _ in range(__a					):
										values.append(rng.randint(0					, vocab_size - 1					)					)

					A_								=    np.array(__a					, dtype=jnp.intaa					).reshape(__a					)

					return output
def 				A_  (__a					, __a=None					):

					'''simple docstring'''





					A_								=    ids_tensor(__a					, vocab_size=2					, rng=__a					)
					# make sure that at least one token is attended to for each batch
					A_								=    1
					return attn_mask



@require_flax
class __lowerCAmelCase					:




			"""simple docstring"""







			snake_case						   =					None
			snake_case						   =					()




			def   lowerCamelCase__  (					self    :       Any						)   ->			Tuple:







								"""simple docstring"""
								A_			,     A_								=    self.model_tester.prepare_config_and_inputs_for_common()

								# cut to half length & take max batch_size 3
								A_								=    2
								A_								=    inputs["input_ids"].shape[-1] // 2
								A_								=    inputs["input_ids"][:max_batch_size, :sequence_length]

								A_								=    jnp.ones_like(_snake_case						)
								A_								=    attention_mask[:max_batch_size, :sequence_length]

								# generate max 5 tokens
								A_								=    input_ids.shape[-1] + 5
								if config.eos_token_id is not None and config.pad_token_id is None:
													# hack to allow generate for models such as GPT2 as is done in `generate()`
													A_								=    config.eos_token_id
								return config, input_ids, attention_mask, max_length




			@is_pt_flax_cross_test
			def   lowerCamelCase__  (					self    :       List[Any]						)   ->			List[Any]:







								"""simple docstring"""
								A_			,     A_			,     A_			,     A_								=    self._get_input_ids_and_config()
								A_								=    False
								A_								=    max_length
								A_								=    0

								for model_class in self.all_generative_model_classes:
													A_								=    model_class(_snake_case						)

													A_								=    model_class.__name__[4:]  # Skip the "Flax" at the beginning
													A_								=    getattr(_snake_case							, _snake_case						)
													A_								=    pt_model_class(_snake_case						).eval()
													A_								=    load_flax_weights_in_pytorch_model(_snake_case							, flax_model.params						)

													A_								=    flax_model.generate(_snake_case						).sequences
													A_								=    pt_model.generate(torch.tensor(_snake_case							, dtype=torch.long						)						)

													if flax_generation_outputs.shape[-1] > pt_generation_outputs.shape[-1]:
																		A_								=    flax_generation_outputs[:, : pt_generation_outputs.shape[-1]]

													self.assertListEqual(pt_generation_outputs.numpy().tolist()							, flax_generation_outputs.tolist()						)




			def   lowerCamelCase__  (					self    :       Any						)   ->			Optional[Any]:







								"""simple docstring"""
								A_			,     A_			,     A_			,     A_								=    self._get_input_ids_and_config()
								A_								=    False
								A_								=    max_length

								for model_class in self.all_generative_model_classes:
													A_								=    model_class(_snake_case						)

													A_								=    model.generate(_snake_case						).sequences
													self.assertEqual(generation_outputs.shape[-1]							, _snake_case						)

													A_								=    jit(model.generate						)
													A_								=    jit_generate(_snake_case						).sequences

													self.assertListEqual(generation_outputs.tolist()							, jit_generation_outputs.tolist()						)




			def   lowerCamelCase__  (					self    :       Tuple						)   ->			List[str]:







								"""simple docstring"""
								A_			,     A_			,     A_			,     A_								=    self._get_input_ids_and_config()
								A_								=    True
								A_								=    max_length

								for model_class in self.all_generative_model_classes:
													A_								=    model_class(_snake_case						)

													A_								=    model.generate(_snake_case						).sequences
													self.assertEqual(generation_outputs.shape[-1]							, _snake_case						)

													A_								=    jit(model.generate						)
													A_								=    jit_generate(_snake_case						).sequences

													self.assertListEqual(generation_outputs.tolist()							, jit_generation_outputs.tolist()						)




			def   lowerCamelCase__  (					self    :       Tuple						)   ->			Dict:







								"""simple docstring"""
								A_			,     A_			,     A_			,     A_								=    self._get_input_ids_and_config()
								A_								=    False
								A_								=    max_length
								A_								=    2

								for model_class in self.all_generative_model_classes:
													A_								=    model_class(_snake_case						)

													A_								=    model.generate(_snake_case						).sequences
													self.assertEqual(generation_outputs.shape[-1]							, _snake_case						)

													A_								=    jit(model.generate						)
													A_								=    jit_generate(_snake_case						).sequences

													self.assertListEqual(generation_outputs.tolist()							, jit_generation_outputs.tolist()						)




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







								"""simple docstring"""
								A_			,     A_			,     A_			,     A_								=    self._get_input_ids_and_config()
								A_								=    False
								A_								=    max_length
								A_								=    2
								A_								=    2

								for model_class in self.all_generative_model_classes:
													A_								=    model_class(_snake_case						)

													A_								=    model.generate(_snake_case						).sequences
													self.assertEqual(generation_outputs.shape[0]							, input_ids.shape[0] * config.num_return_sequences						)




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







								"""simple docstring"""
								A_			,     A_			,     A_			,     A_								=    self._get_input_ids_and_config()
								A_								=    True
								A_								=    max_length
								A_								=    0.8
								A_								=    10
								A_								=    0.3
								A_								=    1
								A_								=    8
								A_								=    9

								for model_class in self.all_generative_model_classes:
													A_								=    model_class(_snake_case						)

													A_								=    model.generate(_snake_case						).sequences
													self.assertEqual(generation_outputs.shape[-1]							, _snake_case						)

													A_								=    jit(model.generate						)
													A_								=    jit_generate(_snake_case						).sequences

													self.assertListEqual(generation_outputs.tolist()							, jit_generation_outputs.tolist()						)




			def   lowerCamelCase__  (					self    :       List[str]						)   ->			Any:







								"""simple docstring"""
								A_			,     A_			,     A_			,     A_								=    self._get_input_ids_and_config()
								A_								=    max_length
								A_								=    1
								A_								=    8
								A_								=    9

								for model_class in self.all_generative_model_classes:
													A_								=    model_class(_snake_case						)

													A_								=    model.generate(_snake_case						).sequences
													self.assertEqual(generation_outputs.shape[-1]							, _snake_case						)

													A_								=    jit(model.generate						)
													A_								=    jit_generate(_snake_case						).sequences

													self.assertListEqual(generation_outputs.tolist()							, jit_generation_outputs.tolist()						)




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







								"""simple docstring"""
								A_			,     A_			,     A_			,     A_								=    self._get_input_ids_and_config()
								A_								=    max_length
								A_								=    2
								A_								=    1
								A_								=    8
								A_								=    9

								for model_class in self.all_generative_model_classes:
													A_								=    model_class(_snake_case						)

													A_								=    model.generate(_snake_case						).sequences
													self.assertEqual(generation_outputs.shape[-1]							, _snake_case						)

													A_								=    jit(model.generate						)
													A_								=    jit_generate(_snake_case						).sequences

													self.assertListEqual(generation_outputs.tolist()							, jit_generation_outputs.tolist()						)




			def   lowerCamelCase__  (					self    :       Tuple						)   ->			Any:







								"""simple docstring"""
								A_			,     A_			,     A_			,     A_								=    self._get_input_ids_and_config()

								# pad attention mask on the left
								A_								=    attention_mask.at[(0, 0)].set(0						)

								A_								=    False
								A_								=    max_length

								for model_class in self.all_generative_model_classes:
													A_								=    model_class(_snake_case						)

													A_								=    model.generate(_snake_case							, attention_mask=_snake_case						).sequences
													self.assertEqual(generation_outputs.shape[-1]							, _snake_case						)

													A_								=    jit(model.generate						)
													A_								=    jit_generate(_snake_case							, attention_mask=_snake_case						).sequences

													self.assertListEqual(generation_outputs.tolist()							, jit_generation_outputs.tolist()						)




			def   lowerCamelCase__  (					self    :       List[str]						)   ->			int:







								"""simple docstring"""
								A_			,     A_			,     A_			,     A_								=    self._get_input_ids_and_config()

								# pad attention mask on the left
								A_								=    attention_mask.at[(0, 0)].set(0						)

								A_								=    True
								A_								=    max_length

								for model_class in self.all_generative_model_classes:
													A_								=    model_class(_snake_case						)

													A_								=    model.generate(_snake_case							, attention_mask=_snake_case						).sequences
													self.assertEqual(generation_outputs.shape[-1]							, _snake_case						)

													A_								=    jit(model.generate						)
													A_								=    jit_generate(_snake_case							, attention_mask=_snake_case						).sequences

													self.assertListEqual(generation_outputs.tolist()							, jit_generation_outputs.tolist()						)






			def   lowerCamelCase__  (					self    :       Dict						)   ->			int:







								"""simple docstring"""
								A_			,     A_			,     A_			,     A_								=    self._get_input_ids_and_config()

								# pad attention mask on the left
								A_								=    attention_mask.at[(0, 0)].set(0						)

								A_								=    2
								A_								=    max_length

								for model_class in self.all_generative_model_classes:
													A_								=    model_class(_snake_case						)

													A_								=    model.generate(_snake_case							, attention_mask=_snake_case						).sequences
													self.assertEqual(generation_outputs.shape[-1]							, _snake_case						)

													A_								=    jit(model.generate						)
													A_								=    jit_generate(_snake_case							, attention_mask=_snake_case						).sequences

													self.assertListEqual(generation_outputs.tolist()							, jit_generation_outputs.tolist()						)





@require_flax
class __lowerCAmelCase					(       unittest.TestCase   ):




			"""simple docstring"""







			def   lowerCamelCase__  (					self    :       Optional[Any]						)   ->			Any:







								"""simple docstring"""
								A_								=    AutoTokenizer.from_pretrained("hf-internal-testing/tiny-bert"						)
								A_								=    FlaxAutoModelForCausalLM.from_pretrained("hf-internal-testing/tiny-bert-flax-only"						)

								A_								=    "Hello world"
								A_								=    tokenizer(_snake_case							, return_tensors="np"						).input_ids

								# typos are quickly detected (the correct argument is `do_sample`)
								with self.assertRaisesRegex(_snake_case							, "do_samples"						):
													model.generate(_snake_case							, do_samples=_snake_case						)

								# arbitrary arguments that will not be used anywhere are also not accepted
								with self.assertRaisesRegex(_snake_case							, "foo"						):
													A_								=    {"foo": "bar"}
													model.generate(_snake_case							, **_snake_case						)




