



import unittest

import numpy as np

from transformers import BertConfig, is_flax_available
from transformers.testing_utils import require_flax, slow

from ...test_modeling_flax_common import FlaxModelTesterMixin, floats_tensor, ids_tensor, random_attention_mask


if is_flax_available():
    from transformers.models.bert.modeling_flax_bert import (
        FlaxBertForMaskedLM,
        FlaxBertForMultipleChoice,
        FlaxBertForNextSentencePrediction,
        FlaxBertForPreTraining,
        FlaxBertForQuestionAnswering,
        FlaxBertForSequenceClassification,
        FlaxBertForTokenClassification,
        FlaxBertModel,
    )



class 		_snake_case   (      unittest.TestCase					):





 """simple docstring"""



 def __init__(    self						,     a						,     a=1_3						,     a=7						,     a=True						,     a=True						,     a=True						,     a=True						,     a=9_9						,     a=3_2						,     a=5						,     a=4						,     a=3_7						,     a="gelu"						,     a=0.1						,     a=0.1						,     a=5_1_2						,     a=1_6						,     a=2						,     a=0.02						,     a=4						,     )						->				List[Any]:




   """simple docstring"""







   _A							     =     parent
   _A							     =     batch_size
   _A							     =     seq_length
   _A							     =     is_training
   _A							     =     use_attention_mask
   _A							     =     use_token_type_ids
   _A							     =     use_labels
   _A							     =     vocab_size
   _A							     =     hidden_size
   _A							     =     num_hidden_layers
   _A							     =     num_attention_heads
   _A							     =     intermediate_size
   _A							     =     hidden_act
   _A							     =     hidden_dropout_prob
   _A							     =     attention_probs_dropout_prob
   _A							     =     max_position_embeddings
   _A							     =     type_vocab_size
   _A							     =     type_sequence_label_size
   _A							     =     initializer_range
   _A							     =     num_choices
 def lowercase_		(    self       )						->				Optional[int]:




   """simple docstring"""







   _A							     =     ids_tensor([self.batch_size, self.seq_length]						,     self.vocab_size       )

   _A							     =     None
   if self.use_attention_mask:
     _A							     =     random_attention_mask([self.batch_size, self.seq_length]       )

   _A							     =     None
   if self.use_token_type_ids:
     _A							     =     ids_tensor([self.batch_size, self.seq_length]						,     self.type_vocab_size       )

   _A							     =     BertConfig(
       vocab_size=self.vocab_size						,     hidden_size=self.hidden_size						,     num_hidden_layers=self.num_hidden_layers						,     num_attention_heads=self.num_attention_heads						,     intermediate_size=self.intermediate_size						,     hidden_act=self.hidden_act						,     hidden_dropout_prob=self.hidden_dropout_prob						,     attention_probs_dropout_prob=self.attention_probs_dropout_prob						,     max_position_embeddings=self.max_position_embeddings						,     type_vocab_size=self.type_vocab_size						,     is_decoder=a						,     initializer_range=self.initializer_range						,     )

   return config, input_ids, token_type_ids, attention_mask
 def lowercase_		(    self       )						->				Tuple:




   """simple docstring"""







   _A							     =     self.prepare_config_and_inputs()
   _A     , _A     , _A     , _A							     =     config_and_inputs
   _A							     =     {'''input_ids''': input_ids, '''token_type_ids''': token_type_ids, '''attention_mask''': attention_mask}
   return config, inputs_dict



 def lowercase_		(    self       )						->				Dict:




   """simple docstring"""







   _A							     =     self.prepare_config_and_inputs()
   _A     , _A     , _A     , _A							     =     config_and_inputs

   _A							     =     True
   _A							     =     floats_tensor([self.batch_size, self.seq_length, self.hidden_size]       )
   _A							     =     ids_tensor([self.batch_size, self.seq_length]						,     vocab_size=2       )

   return (
       config,
       input_ids,
       attention_mask,
       encoder_hidden_states,
       encoder_attention_mask,
   )







@require_flax
class 		_snake_case   (      _snake_case       ,unittest.TestCase					):





 """simple docstring"""



 lowerCamelCase_        =      True

 lowerCamelCase_        =      (
     (
         FlaxBertModel,
         FlaxBertForPreTraining,
         FlaxBertForMaskedLM,
         FlaxBertForMultipleChoice,
         FlaxBertForQuestionAnswering,
         FlaxBertForNextSentencePrediction,
         FlaxBertForSequenceClassification,
         FlaxBertForTokenClassification,
         FlaxBertForQuestionAnswering,
     )
     if is_flax_available()
     else ()
 )
 def lowercase_		(    self       )						->				Union[str, Any]:




   """simple docstring"""







   _A							     =     FlaxBertModelTester(self       )



 @slow
 def lowercase_		(    self       )						->				int:




   """simple docstring"""







   _A							     =     FlaxBertModel.from_pretrained('''bert-base-cased'''       )
   _A							     =     model(np.ones((1, 1)       )       )
   self.assertIsNotNone(a       )






'''simple docstring'''

import json
import sys
import tempfile
import unittest
from pathlib import Path

import transformers
from transformers import (
    CONFIG_MAPPING,
    IMAGE_PROCESSOR_MAPPING,
    AutoConfig,
    AutoImageProcessor,
    CLIPConfig,
    CLIPImageProcessor,
)
from transformers.testing_utils import DUMMY_UNKNOWN_IDENTIFIER


sys.path.append(str(Path(__file__).parent.parent.parent.parent / "utils"))

from test_module.custom_configuration import CustomConfig  # noqa E402
from test_module.custom_image_processing import CustomImageProcessor  # noqa E402







class __a			( unittest.TestCase      ):





   def   UpperCAmelCase__  (       self					:      Any     ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE   				=							0





   def   UpperCAmelCase__  (       self					:      str     ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE   				=							AutoImageProcessor.from_pretrained("""openai/clip-vit-base-patch32"""     )
      self.assertIsInstance(lowerCamelCase					,lowerCamelCase     )





   def   UpperCAmelCase__  (       self					:      Dict     ):

      '''simple docstring'''

      with tempfile.TemporaryDirectory() as tmpdirname:
         __SCREAMING_SNAKE_CASE   				=							Path(lowerCamelCase     ) / """preprocessor_config.json"""
         __SCREAMING_SNAKE_CASE   				=							Path(lowerCamelCase     ) / """config.json"""
         json.dump(
             {"""image_processor_type""": """CLIPImageProcessor""", """processor_class""": """CLIPProcessor"""}					,open(lowerCamelCase					,"""w"""     )					,)
         json.dump({"""model_type""": """clip"""}					,open(lowerCamelCase					,"""w"""     )     )

         __SCREAMING_SNAKE_CASE   				=							AutoImageProcessor.from_pretrained(lowerCamelCase     )
         self.assertIsInstance(lowerCamelCase					,lowerCamelCase     )





   def   UpperCAmelCase__  (       self					:      Optional[Any]     ):

      '''simple docstring'''

      with tempfile.TemporaryDirectory() as tmpdirname:
         __SCREAMING_SNAKE_CASE   				=							Path(lowerCamelCase     ) / """preprocessor_config.json"""
         __SCREAMING_SNAKE_CASE   				=							Path(lowerCamelCase     ) / """config.json"""
         json.dump(
             {"""feature_extractor_type""": """CLIPFeatureExtractor""", """processor_class""": """CLIPProcessor"""}					,open(lowerCamelCase					,"""w"""     )					,)
         json.dump({"""model_type""": """clip"""}					,open(lowerCamelCase					,"""w"""     )     )

         __SCREAMING_SNAKE_CASE   				=							AutoImageProcessor.from_pretrained(lowerCamelCase     )
         self.assertIsInstance(lowerCamelCase					,lowerCamelCase     )





   def   UpperCAmelCase__  (       self					:      List[str]     ):

      '''simple docstring'''

      with tempfile.TemporaryDirectory() as tmpdirname:
         __SCREAMING_SNAKE_CASE   				=							CLIPConfig()

         # Create a dummy config file with image_proceesor_type
         __SCREAMING_SNAKE_CASE   				=							Path(lowerCamelCase     ) / """preprocessor_config.json"""
         __SCREAMING_SNAKE_CASE   				=							Path(lowerCamelCase     ) / """config.json"""
         json.dump(
             {"""image_processor_type""": """CLIPImageProcessor""", """processor_class""": """CLIPProcessor"""}					,open(lowerCamelCase					,"""w"""     )					,)
         json.dump({"""model_type""": """clip"""}					,open(lowerCamelCase					,"""w"""     )     )

         # remove image_processor_type to make sure config.json alone is enough to load image processor locally
         __SCREAMING_SNAKE_CASE   				=							AutoImageProcessor.from_pretrained(lowerCamelCase     ).to_dict()

         config_dict.pop("""image_processor_type"""     )
         __SCREAMING_SNAKE_CASE   				=							CLIPImageProcessor(**lowerCamelCase     )

         # save in new folder
         model_config.save_pretrained(lowerCamelCase     )
         config.save_pretrained(lowerCamelCase     )

         __SCREAMING_SNAKE_CASE   				=							AutoImageProcessor.from_pretrained(lowerCamelCase     )

         # make sure private variable is not incorrectly saved
         __SCREAMING_SNAKE_CASE   				=							json.loads(config.to_json_string()     )
         self.assertTrue("""_processor_class""" not in dict_as_saved     )

      self.assertIsInstance(lowerCamelCase					,lowerCamelCase     )





   def   UpperCAmelCase__  (       self					:      Union[str, Any]     ):

      '''simple docstring'''

      with tempfile.TemporaryDirectory() as tmpdirname:
         __SCREAMING_SNAKE_CASE   				=							Path(lowerCamelCase     ) / """preprocessor_config.json"""
         json.dump(
             {"""image_processor_type""": """CLIPImageProcessor""", """processor_class""": """CLIPProcessor"""}					,open(lowerCamelCase					,"""w"""     )					,)

         __SCREAMING_SNAKE_CASE   				=							AutoImageProcessor.from_pretrained(lowerCamelCase     )
         self.assertIsInstance(lowerCamelCase					,lowerCamelCase     )





   def   UpperCAmelCase__  (       self					:      Dict     ):

      '''simple docstring'''

      with self.assertRaisesRegex(
          lowerCamelCase					,"""clip-base is not a local folder and is not a valid model identifier"""     ):
         __SCREAMING_SNAKE_CASE   				=							AutoImageProcessor.from_pretrained("""clip-base"""     )





   def   UpperCAmelCase__  (       self					:      Any     ):

      '''simple docstring'''

      with self.assertRaisesRegex(
          lowerCamelCase					,r"""aaaaaa is not a valid git identifier \(branch name, tag name or commit id\)"""     ):
         __SCREAMING_SNAKE_CASE   				=							AutoImageProcessor.from_pretrained(lowerCamelCase					,revision="""aaaaaa"""     )





   def   UpperCAmelCase__  (       self					:      List[Any]     ):

      '''simple docstring'''

      with self.assertRaisesRegex(
          lowerCamelCase					,"""hf-internal-testing/config-no-model does not appear to have a file named preprocessor_config.json."""					,):
         __SCREAMING_SNAKE_CASE   				=							AutoImageProcessor.from_pretrained("""hf-internal-testing/config-no-model"""     )





   def   UpperCAmelCase__  (       self					:      Any     ):

      '''simple docstring'''

      with self.assertRaises(lowerCamelCase     ):
         __SCREAMING_SNAKE_CASE   				=							AutoImageProcessor.from_pretrained("""hf-internal-testing/test_dynamic_image_processor"""     )
      # If remote code is disabled, we can't load this config.
      with self.assertRaises(lowerCamelCase     ):
         __SCREAMING_SNAKE_CASE   				=							AutoImageProcessor.from_pretrained(
             """hf-internal-testing/test_dynamic_image_processor"""					,trust_remote_code=lowerCamelCase     )

      __SCREAMING_SNAKE_CASE   				=							AutoImageProcessor.from_pretrained(
          """hf-internal-testing/test_dynamic_image_processor"""					,trust_remote_code=lowerCamelCase     )
      self.assertEqual(image_processor.__class__.__name__					,"""NewImageProcessor"""     )

      # Test image processor can be reloaded.
      with tempfile.TemporaryDirectory() as tmp_dir:
         image_processor.save_pretrained(lowerCamelCase     )
         __SCREAMING_SNAKE_CASE   				=							AutoImageProcessor.from_pretrained(lowerCamelCase					,trust_remote_code=lowerCamelCase     )
      self.assertEqual(reloaded_image_processor.__class__.__name__					,"""NewImageProcessor"""     )





   def   UpperCAmelCase__  (       self					:      str     ):

      '''simple docstring'''

      try:
         AutoConfig.register("""custom"""					,lowerCamelCase     )
         AutoImageProcessor.register(lowerCamelCase					,lowerCamelCase     )
         # Trying to register something existing in the Transformers library will raise an error
         with self.assertRaises(lowerCamelCase     ):
            AutoImageProcessor.register(lowerCamelCase					,lowerCamelCase     )

         with tempfile.TemporaryDirectory() as tmpdirname:
            __SCREAMING_SNAKE_CASE   				=							Path(lowerCamelCase     ) / """preprocessor_config.json"""
            __SCREAMING_SNAKE_CASE   				=							Path(lowerCamelCase     ) / """config.json"""
            json.dump(
                {"""feature_extractor_type""": """CLIPFeatureExtractor""", """processor_class""": """CLIPProcessor"""}					,open(lowerCamelCase					,"""w"""     )					,)
            json.dump({"""model_type""": """clip"""}					,open(lowerCamelCase					,"""w"""     )     )

            __SCREAMING_SNAKE_CASE   				=							CustomImageProcessor.from_pretrained(lowerCamelCase     )

         # Now that the config is registered, it can be used as any other config with the auto-API
         with tempfile.TemporaryDirectory() as tmp_dir:
            image_processor.save_pretrained(lowerCamelCase     )
            __SCREAMING_SNAKE_CASE   				=							AutoImageProcessor.from_pretrained(lowerCamelCase     )
            self.assertIsInstance(lowerCamelCase					,lowerCamelCase     )

      finally:
         if "custom" in CONFIG_MAPPING._extra_content:
            del CONFIG_MAPPING._extra_content["custom"]
         if CustomConfig in IMAGE_PROCESSOR_MAPPING._extra_content:
            del IMAGE_PROCESSOR_MAPPING._extra_content[CustomConfig]





   def   UpperCAmelCase__  (       self					:      str     ):

      '''simple docstring'''

      class __a			( _snake_case      ):
         __UpperCamelCase :			int						   =						True

      try:
         AutoConfig.register("""custom"""					,lowerCamelCase     )
         AutoImageProcessor.register(lowerCamelCase					,lowerCamelCase     )
         # If remote code is not set, the default is to use local
         __SCREAMING_SNAKE_CASE   				=							AutoImageProcessor.from_pretrained("""hf-internal-testing/test_dynamic_image_processor"""     )
         self.assertEqual(image_processor.__class__.__name__					,"""NewImageProcessor"""     )
         self.assertTrue(image_processor.is_local     )

         # If remote code is disabled, we load the local one.
         __SCREAMING_SNAKE_CASE   				=							AutoImageProcessor.from_pretrained(
             """hf-internal-testing/test_dynamic_image_processor"""					,trust_remote_code=lowerCamelCase     )
         self.assertEqual(image_processor.__class__.__name__					,"""NewImageProcessor"""     )
         self.assertTrue(image_processor.is_local     )

         # If remote is enabled, we load from the Hub
         __SCREAMING_SNAKE_CASE   				=							AutoImageProcessor.from_pretrained(
             """hf-internal-testing/test_dynamic_image_processor"""					,trust_remote_code=lowerCamelCase     )
         self.assertEqual(image_processor.__class__.__name__					,"""NewImageProcessor"""     )
         self.assertTrue(not hasattr(lowerCamelCase					,"""is_local"""     )     )

      finally:
         if "custom" in CONFIG_MAPPING._extra_content:
            del CONFIG_MAPPING._extra_content["custom"]
         if CustomConfig in IMAGE_PROCESSOR_MAPPING._extra_content:
            del IMAGE_PROCESSOR_MAPPING._extra_content[CustomConfig]





