





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  __UpperCAmelCase			(     self						:						Any    ,__A						:						Any	)    ->       Optional[Any]:
         _lowercase						    =			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	)
           _lowercase						    =			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  __UpperCAmelCase			(     self						:						int	)    ->       List[str]:
         _lowercase						    =			AutoConfig.from_pretrained('gpt2'	)
         _lowercase						    =			GenerationConfig.from_model_config(__A	)
         _lowercase						    =			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  __UpperCAmelCase			(     self						:						Optional[int]	)    ->       Any:
         _lowercase						    =			GenerationConfig()
         _lowercase						    =			{
             'max_new_tokens': 1024,
             'foo': 'bar',
         }
         _lowercase						    =			copy.deepcopy(__A	)
         _lowercase						    =			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  __UpperCAmelCase			(     self						:						List[Any]	)    ->       List[Any]:
         _lowercase						    =			GenerationConfig()
         _lowercase						    =			'bar'

         with tempfile.TemporaryDirectory('test-generation-config'	) as tmp_dir:
           generation_config.save_pretrained(__A	)

           _lowercase						    =			GenerationConfig.from_pretrained(__A	)
         # update_kwargs was used to update the config on valid attributes
         self.assertEqual(new_config.foo    ,'bar'	)

         _lowercase						    =			GenerationConfig.from_model_config(__A	)
         assert not hasattr(__A    ,'foo'	)  # no new kwargs should be initialized if from config







       def  __UpperCAmelCase			(     self						:						List[Any]	)    ->       Dict:
         _lowercase						    =			GenerationConfig()
         self.assertEqual(default_config.temperature    ,1.0	)
         self.assertEqual(default_config.do_sample    ,__A	)
         self.assertEqual(default_config.num_beams    ,1	)

         _lowercase						    =			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	)
           _lowercase						    =			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  __UpperCAmelCase			(     cls						:						Optional[Any]	)    ->       Optional[int]:
         _lowercase						    =			TOKEN
         HfFolder.save_token(__A	)







       @classmethod
       def  __UpperCAmelCase			(     cls						:						List[str]	)    ->       Union[str, 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  __UpperCAmelCase			(     self						:						Tuple	)    ->       List[Any]:
         _lowercase						    =			GenerationConfig(
             do_sample=__A    ,temperature=0.7    ,length_penalty=1.0    ,)
         config.push_to_hub('test-generation-config'    ,use_auth_token=self._token	)

         _lowercase						    =			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	)

         _lowercase						    =			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  __UpperCAmelCase			(     self						:						Optional[int]	)    ->       Tuple:
         _lowercase						    =			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	)

         _lowercase						    =			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	)

         _lowercase						    =			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 __future__ import annotations

import unittest

import numpy as np

from transformers import BlipTextConfig
from transformers.testing_utils import require_tf, slow
from transformers.utils import is_tf_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor, random_attention_mask


if is_tf_available():
      import tensorflow as tf

      from transformers import TFBlipTextModel
      from transformers.models.blip.modeling_tf_blip import TF_BLIP_PRETRAINED_MODEL_ARCHIVE_LIST


class        A__   :



    def __init__(       self		,					UpperCamelCase__		,					UpperCamelCase__=12		,					UpperCamelCase__=7		,					UpperCamelCase__=True		,					UpperCamelCase__=True		,					UpperCamelCase__=True		,					UpperCamelCase__=99		,					UpperCamelCase__=32		,					UpperCamelCase__=32		,					UpperCamelCase__=2		,					UpperCamelCase__=4		,					UpperCamelCase__=37		,					UpperCamelCase__=0.1		,					UpperCamelCase__=0.1		,					UpperCamelCase__=512		,					UpperCamelCase__=0.02		,					UpperCamelCase__=0		,					UpperCamelCase__=None		,					)    ->   Union[str, Any]:





           '''simple docstring'''
           A_						       =   parent
           A_						       =   batch_size
           A_						       =   seq_length
           A_						       =   is_training
           A_						       =   use_input_mask
           A_						       =   use_labels
           A_						       =   vocab_size
           A_						       =   hidden_size
           A_						       =   projection_dim
           A_						       =   num_hidden_layers
           A_						       =   num_attention_heads
           A_						       =   intermediate_size
           A_						       =   dropout
           A_						       =   attention_dropout
           A_						       =   max_position_embeddings
           A_						       =   initializer_range
           A_						       =   scope
           A_						       =   bos_token_id



    def        snake_case_      (       self							)    ->   Dict:





           '''simple docstring'''
           A_						       =   ids_tensor([self.batch_size, self.seq_length]		,					self.vocab_size							)

           A_						       =   None
           if self.use_input_mask:
                  A_						       =   random_attention_mask([self.batch_size, self.seq_length]							)

           if input_mask is not None:
                  A_						       =   input_mask.numpy()
                  A_       ,      A_						       =   input_mask.shape
                  A_						       =   np.random.randint(1		,					seq_length - 1		,					size=(batch_size,)							)
                  for batch_idx, start_index in enumerate(UpperCamelCase__							):
                         A_						       =   1
                         A_						       =   0

           A_						       =   self.get_config()

           return config, input_ids, tf.convert_to_tensor(UpperCamelCase__							)



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





           '''simple docstring'''
           return BlipTextConfig(
               vocab_size=self.vocab_size		,					hidden_size=self.hidden_size		,					projection_dim=self.projection_dim		,					num_hidden_layers=self.num_hidden_layers		,					num_attention_heads=self.num_attention_heads		,					intermediate_size=self.intermediate_size		,					dropout=self.dropout		,					attention_dropout=self.attention_dropout		,					max_position_embeddings=self.max_position_embeddings		,					initializer_range=self.initializer_range		,					bos_token_id=self.bos_token_id		,					)



    def        snake_case_      (       self		,					UpperCamelCase__		,					UpperCamelCase__		,					UpperCamelCase__							)    ->   int:





           '''simple docstring'''
           A_						       =   TFBlipTextModel(config=UpperCamelCase__							)
           A_						       =   model(UpperCamelCase__		,					attention_mask=UpperCamelCase__		,					training=UpperCamelCase__							)
           A_						       =   model(UpperCamelCase__		,					training=UpperCamelCase__							)
           self.parent.assertEqual(result.last_hidden_state.shape		,					(self.batch_size, self.seq_length, self.hidden_size)							)
           self.parent.assertEqual(result.pooler_output.shape		,					(self.batch_size, self.hidden_size)							)







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





           '''simple docstring'''
           A_						       =   self.prepare_config_and_inputs()
           A_       ,      A_       ,      A_						       =   config_and_inputs
           A_						       =   {"""input_ids""": input_ids, """attention_mask""": input_mask}
           return config, inputs_dict


@require_tf
class        A__   (   _snake_case    ,    unittest.TestCase      ):
    lowercase						       =		(TFBlipTextModel,) if is_tf_available() else ()
    lowercase						       =		False
    lowercase						       =		False
    lowercase						       =		False



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





           '''simple docstring'''
           A_						       =   BlipTextModelTester(self							)
           A_						       =   ConfigTester(self		,					config_class=UpperCamelCase__		,					hidden_size=37							)



    def        snake_case_      (       self							)    ->   Tuple:





           '''simple docstring'''
           self.config_tester.run_common_tests()



    def        snake_case_      (       self							)    ->   str:





           '''simple docstring'''
           A_						       =   self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_model(*UpperCamelCase__							)



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





           '''simple docstring'''
           pass



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





           '''simple docstring'''
           pass



    @unittest.skip(reason="""Blip does not use inputs_embeds"""							)
    def        snake_case_      (       self							)    ->   Union[str, Any]:





           '''simple docstring'''
           pass



    @unittest.skip(reason="""BlipTextModel has no base class and is not available in MODEL_MAPPING"""							)
    def        snake_case_      (       self							)    ->   List[Any]:





           '''simple docstring'''
           pass



    @unittest.skip(reason="""BlipTextModel has no base class and is not available in MODEL_MAPPING"""							)
    def        snake_case_      (       self							)    ->   Any:





           '''simple docstring'''
           pass



    @slow
    def        snake_case_      (       self							)    ->   List[Any]:





           '''simple docstring'''
           for model_name in TF_BLIP_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                  A_						       =   TFBlipTextModel.from_pretrained(UpperCamelCase__							)
                  self.assertIsNotNone(UpperCamelCase__							)







    def        snake_case_      (       self		,					UpperCamelCase__=True							)    ->   str:





           '''simple docstring'''
           super().test_pt_tf_model_equivalence(allow_missing_keys=UpperCamelCase__							)
