


"""simple docstring"""


import unittest

from transformers import AutoTokenizer, NystromformerConfig, is_torch_available
from transformers.testing_utils import require_torch, slow, torch_device

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
   import torch

   from transformers import (
       NystromformerForMaskedLM,
       NystromformerForMultipleChoice,
       NystromformerForQuestionAnswering,
       NystromformerForSequenceClassification,
       NystromformerForTokenClassification,
       NystromformerModel,
   )
   from transformers.models.nystromformer.modeling_nystromformer import NYSTROMFORMER_PRETRAINED_MODEL_ARCHIVE_LIST



class   _a      :
    def __init__( self							:					Dict							,					SCREAMING_SNAKE_CASE__							:					Union[str, Any]							,					SCREAMING_SNAKE_CASE__							:					Tuple=13							,					SCREAMING_SNAKE_CASE__							:					List[str]=7							,					SCREAMING_SNAKE_CASE__							:					Any=True							,					SCREAMING_SNAKE_CASE__							:					Tuple=True							,					SCREAMING_SNAKE_CASE__							:					Any=True							,					SCREAMING_SNAKE_CASE__							:					Union[str, Any]=True							,					SCREAMING_SNAKE_CASE__							:					str=99							,					SCREAMING_SNAKE_CASE__							:					Optional[Any]=32							,					SCREAMING_SNAKE_CASE__							:					List[str]=5							,					SCREAMING_SNAKE_CASE__							:					int=4							,					SCREAMING_SNAKE_CASE__							:					Any=37							,					SCREAMING_SNAKE_CASE__							:					str="gelu"							,					SCREAMING_SNAKE_CASE__							:					Dict=0.1							,					SCREAMING_SNAKE_CASE__							:					str=0.1							,					SCREAMING_SNAKE_CASE__							:					Optional[Any]=5_12							,					SCREAMING_SNAKE_CASE__							:					Any=16							,					SCREAMING_SNAKE_CASE__							:					Dict=2							,					SCREAMING_SNAKE_CASE__							:					Any=0.02							,					SCREAMING_SNAKE_CASE__							:					int=3							,					SCREAMING_SNAKE_CASE__							:					Dict=4							,					SCREAMING_SNAKE_CASE__							:					List[Any]=None							,					):
          lowerCamelCase__           =		parent
          lowerCamelCase__           =		batch_size
          lowerCamelCase__           =		seq_length
          lowerCamelCase__           =		is_training
          lowerCamelCase__           =		use_input_mask
          lowerCamelCase__           =		use_token_type_ids
          lowerCamelCase__           =		use_labels
          lowerCamelCase__           =		vocab_size
          lowerCamelCase__           =		hidden_size
          lowerCamelCase__           =		num_hidden_layers
          lowerCamelCase__           =		num_attention_heads
          lowerCamelCase__           =		intermediate_size
          lowerCamelCase__           =		hidden_act
          lowerCamelCase__           =		hidden_dropout_prob
          lowerCamelCase__           =		attention_probs_dropout_prob
          lowerCamelCase__           =		max_position_embeddings
          lowerCamelCase__           =		type_vocab_size
          lowerCamelCase__           =		type_sequence_label_size
          lowerCamelCase__           =		initializer_range
          lowerCamelCase__           =		num_labels
          lowerCamelCase__           =		num_choices
          lowerCamelCase__           =		scope
    def      _UpperCamelCase       ( self							:					Optional[Any]				):
          lowerCamelCase__           =		ids_tensor([self.batch_size, self.seq_length]							,					self.vocab_size				)

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

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

          lowerCamelCase__           =		None
          lowerCamelCase__           =		None
          lowerCamelCase__           =		None
          if self.use_labels:
                lowerCamelCase__           =		ids_tensor([self.batch_size]							,					self.type_sequence_label_size				)
                lowerCamelCase__           =		ids_tensor([self.batch_size, self.seq_length]							,					self.num_labels				)
                lowerCamelCase__           =		ids_tensor([self.batch_size]							,					self.num_choices				)

          lowerCamelCase__           =		self.get_config()

          return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels
    def      _UpperCamelCase       ( self							:					Dict				):
          return NystromformerConfig(
              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=SCREAMING_SNAKE_CASE__							,					initializer_range=self.initializer_range							,					)
    def      _UpperCamelCase       ( self							:					int							,					SCREAMING_SNAKE_CASE__							:					int							,					SCREAMING_SNAKE_CASE__							:					Any							,					SCREAMING_SNAKE_CASE__							:					Optional[int]							,					SCREAMING_SNAKE_CASE__							:					Any							,					SCREAMING_SNAKE_CASE__							:					Any							,					SCREAMING_SNAKE_CASE__							:					Tuple							,					SCREAMING_SNAKE_CASE__							:					int				):
          lowerCamelCase__           =		NystromformerModel(config=SCREAMING_SNAKE_CASE__				)
          model.to(SCREAMING_SNAKE_CASE__				)
          model.eval()
          lowerCamelCase__           =		model(SCREAMING_SNAKE_CASE__							,					attention_mask=SCREAMING_SNAKE_CASE__							,					token_type_ids=SCREAMING_SNAKE_CASE__				)
          lowerCamelCase__           =		model(SCREAMING_SNAKE_CASE__							,					token_type_ids=SCREAMING_SNAKE_CASE__				)
          lowerCamelCase__           =		model(SCREAMING_SNAKE_CASE__				)
          self.parent.assertEqual(result.last_hidden_state.shape							,					(self.batch_size, self.seq_length, self.hidden_size)				)
    def      _UpperCamelCase       ( self							:					str							,					SCREAMING_SNAKE_CASE__							:					Tuple							,					SCREAMING_SNAKE_CASE__							:					List[Any]							,					SCREAMING_SNAKE_CASE__							:					Union[str, Any]							,					SCREAMING_SNAKE_CASE__							:					Optional[int]							,					SCREAMING_SNAKE_CASE__							:					Tuple							,					SCREAMING_SNAKE_CASE__							:					Optional[int]							,					SCREAMING_SNAKE_CASE__							:					Optional[int]				):
          lowerCamelCase__           =		NystromformerForMaskedLM(config=SCREAMING_SNAKE_CASE__				)
          model.to(SCREAMING_SNAKE_CASE__				)
          model.eval()
          lowerCamelCase__           =		model(SCREAMING_SNAKE_CASE__							,					attention_mask=SCREAMING_SNAKE_CASE__							,					token_type_ids=SCREAMING_SNAKE_CASE__							,					labels=SCREAMING_SNAKE_CASE__				)
          self.parent.assertEqual(result.logits.shape							,					(self.batch_size, self.seq_length, self.vocab_size)				)
    def      _UpperCamelCase       ( self							:					Any							,					SCREAMING_SNAKE_CASE__							:					Dict							,					SCREAMING_SNAKE_CASE__							:					Optional[int]							,					SCREAMING_SNAKE_CASE__							:					str							,					SCREAMING_SNAKE_CASE__							:					int							,					SCREAMING_SNAKE_CASE__							:					Dict							,					SCREAMING_SNAKE_CASE__							:					int							,					SCREAMING_SNAKE_CASE__							:					Tuple				):
          lowerCamelCase__           =		NystromformerForQuestionAnswering(config=SCREAMING_SNAKE_CASE__				)
          model.to(SCREAMING_SNAKE_CASE__				)
          model.eval()
          lowerCamelCase__           =		model(
              SCREAMING_SNAKE_CASE__							,					attention_mask=SCREAMING_SNAKE_CASE__							,					token_type_ids=SCREAMING_SNAKE_CASE__							,					start_positions=SCREAMING_SNAKE_CASE__							,					end_positions=SCREAMING_SNAKE_CASE__							,					)
          self.parent.assertEqual(result.start_logits.shape							,					(self.batch_size, self.seq_length)				)
          self.parent.assertEqual(result.end_logits.shape							,					(self.batch_size, self.seq_length)				)
    def      _UpperCamelCase       ( self							:					Optional[int]							,					SCREAMING_SNAKE_CASE__							:					Dict							,					SCREAMING_SNAKE_CASE__							:					int							,					SCREAMING_SNAKE_CASE__							:					Optional[Any]							,					SCREAMING_SNAKE_CASE__							:					Dict							,					SCREAMING_SNAKE_CASE__							:					List[Any]							,					SCREAMING_SNAKE_CASE__							:					int							,					SCREAMING_SNAKE_CASE__							:					Optional[Any]				):
          lowerCamelCase__           =		self.num_labels
          lowerCamelCase__           =		NystromformerForSequenceClassification(SCREAMING_SNAKE_CASE__				)
          model.to(SCREAMING_SNAKE_CASE__				)
          model.eval()
          lowerCamelCase__           =		model(SCREAMING_SNAKE_CASE__							,					attention_mask=SCREAMING_SNAKE_CASE__							,					token_type_ids=SCREAMING_SNAKE_CASE__							,					labels=SCREAMING_SNAKE_CASE__				)
          self.parent.assertEqual(result.logits.shape							,					(self.batch_size, self.num_labels)				)
    def      _UpperCamelCase       ( self							:					int							,					SCREAMING_SNAKE_CASE__							:					Dict							,					SCREAMING_SNAKE_CASE__							:					List[Any]							,					SCREAMING_SNAKE_CASE__							:					int							,					SCREAMING_SNAKE_CASE__							:					Any							,					SCREAMING_SNAKE_CASE__							:					List[str]							,					SCREAMING_SNAKE_CASE__							:					Union[str, Any]							,					SCREAMING_SNAKE_CASE__							:					Tuple				):
          lowerCamelCase__           =		self.num_labels
          lowerCamelCase__           =		NystromformerForTokenClassification(config=SCREAMING_SNAKE_CASE__				)
          model.to(SCREAMING_SNAKE_CASE__				)
          model.eval()
          lowerCamelCase__           =		model(SCREAMING_SNAKE_CASE__							,					attention_mask=SCREAMING_SNAKE_CASE__							,					token_type_ids=SCREAMING_SNAKE_CASE__							,					labels=SCREAMING_SNAKE_CASE__				)
          self.parent.assertEqual(result.logits.shape							,					(self.batch_size, self.seq_length, self.num_labels)				)
    def      _UpperCamelCase       ( self							:					Optional[int]							,					SCREAMING_SNAKE_CASE__							:					int							,					SCREAMING_SNAKE_CASE__							:					Tuple							,					SCREAMING_SNAKE_CASE__							:					int							,					SCREAMING_SNAKE_CASE__							:					Optional[int]							,					SCREAMING_SNAKE_CASE__							:					List[Any]							,					SCREAMING_SNAKE_CASE__							:					Optional[int]							,					SCREAMING_SNAKE_CASE__							:					Optional[Any]				):
          lowerCamelCase__           =		self.num_choices
          lowerCamelCase__           =		NystromformerForMultipleChoice(config=SCREAMING_SNAKE_CASE__				)
          model.to(SCREAMING_SNAKE_CASE__				)
          model.eval()
          lowerCamelCase__           =		input_ids.unsqueeze(1				).expand(-1							,					self.num_choices							,					-1				).contiguous()
          lowerCamelCase__           =		token_type_ids.unsqueeze(1				).expand(-1							,					self.num_choices							,					-1				).contiguous()
          lowerCamelCase__           =		input_mask.unsqueeze(1				).expand(-1							,					self.num_choices							,					-1				).contiguous()
          lowerCamelCase__           =		model(
              SCREAMING_SNAKE_CASE__							,					attention_mask=SCREAMING_SNAKE_CASE__							,					token_type_ids=SCREAMING_SNAKE_CASE__							,					labels=SCREAMING_SNAKE_CASE__							,					)
          self.parent.assertEqual(result.logits.shape							,					(self.batch_size, self.num_choices)				)


    def      _UpperCamelCase       ( self							:					Dict				):
          lowerCamelCase__           =		self.prepare_config_and_inputs()
          (
              (
              lowerCamelCase__
          )    ,  (
              lowerCamelCase__
          )    ,  (
              lowerCamelCase__
          )    ,  (
              lowerCamelCase__
          )    ,  (
              lowerCamelCase__
          )    ,  (
              lowerCamelCase__
          )    ,  (
              lowerCamelCase__
          )    ,  
          )           =		config_and_inputs
          lowerCamelCase__           =		{'input_ids': input_ids, 'token_type_ids': token_type_ids, 'attention_mask': input_mask}
          return config, inputs_dict





@require_torch
class   _a      (      SCREAMING_SNAKE_CASE_		,		SCREAMING_SNAKE_CASE_		,		unittest.TestCase ):
    a_    :				Optional[Any]             =    (
        (
            NystromformerModel,
            NystromformerForMaskedLM,
            NystromformerForMultipleChoice,
            NystromformerForQuestionAnswering,
            NystromformerForSequenceClassification,
            NystromformerForTokenClassification,
        )
        if is_torch_available()
        else ()
    )
    a_    :				str             =    (
        {
            'feature-extraction': NystromformerModel,
            'fill-mask': NystromformerForMaskedLM,
            'question-answering': NystromformerForQuestionAnswering,
            'text-classification': NystromformerForSequenceClassification,
            'token-classification': NystromformerForTokenClassification,
            'zero-shot': NystromformerForSequenceClassification,
        }
        if is_torch_available()
        else {}
    )
    a_    :				Any             =    False
    a_    :				Union[str, Any]             =    False
    def      _UpperCamelCase       ( self							:					List[Any]				):
          lowerCamelCase__           =		NystromformerModelTester(self				)
          lowerCamelCase__           =		ConfigTester(self							,					config_class=SCREAMING_SNAKE_CASE__							,					hidden_size=37				)
    def      _UpperCamelCase       ( self							:					Tuple				):
          self.config_tester.run_common_tests()
    def      _UpperCamelCase       ( self							:					Any				):
          lowerCamelCase__           =		self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_model(*SCREAMING_SNAKE_CASE__				)
    def      _UpperCamelCase       ( self							:					Dict				):
          lowerCamelCase__           =		self.model_tester.prepare_config_and_inputs()
          for type in ["absolute", "relative_key", "relative_key_query"]:
                lowerCamelCase__           =		type
                self.model_tester.create_and_check_model(*SCREAMING_SNAKE_CASE__				)
    def      _UpperCamelCase       ( self							:					Optional[int]				):
          lowerCamelCase__           =		self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_masked_lm(*SCREAMING_SNAKE_CASE__				)
    def      _UpperCamelCase       ( self							:					Any				):
          lowerCamelCase__           =		self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_multiple_choice(*SCREAMING_SNAKE_CASE__				)
    def      _UpperCamelCase       ( self							:					List[str]				):
          lowerCamelCase__           =		self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_question_answering(*SCREAMING_SNAKE_CASE__				)
    def      _UpperCamelCase       ( self							:					int				):
          lowerCamelCase__           =		self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_sequence_classification(*SCREAMING_SNAKE_CASE__				)
    def      _UpperCamelCase       ( self							:					int				):
          lowerCamelCase__           =		self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_token_classification(*SCREAMING_SNAKE_CASE__				)


    @slow
    def      _UpperCamelCase       ( self							:					Union[str, Any]				):
          for model_name in NYSTROMFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                lowerCamelCase__           =		NystromformerModel.from_pretrained(SCREAMING_SNAKE_CASE__				)
                self.assertIsNotNone(SCREAMING_SNAKE_CASE__				)





@require_torch
class   _a      (      unittest.TestCase ):
    @slow
    def      _UpperCamelCase       ( self							:					List[Any]				):
          lowerCamelCase__           =		NystromformerModel.from_pretrained('uw-madison/nystromformer-512'				)
          lowerCamelCase__           =		torch.tensor([[0, 1, 2, 3, 4, 5]]				)

          with torch.no_grad():
                lowerCamelCase__           =		model(SCREAMING_SNAKE_CASE__				)[0]

          lowerCamelCase__           =		torch.Size((1, 6, 7_68)				)
          self.assertEqual(output.shape							,					SCREAMING_SNAKE_CASE__				)

          lowerCamelCase__           =		torch.tensor(
              [[[-0.45_32, -0.09_36, 0.51_37], [-0.26_76, 0.06_28, 0.61_86], [-0.36_29, -0.17_26, 0.47_16]]]				)

          self.assertTrue(torch.allclose(output[:, :3, :3]							,					SCREAMING_SNAKE_CASE__							,					atol=1e-4				)				)


    @slow
    def      _UpperCamelCase       ( self							:					str				):
          lowerCamelCase__           =		'the [MASK] of Belgium is Brussels'

          lowerCamelCase__           =		AutoTokenizer.from_pretrained('uw-madison/nystromformer-512'				)
          lowerCamelCase__           =		NystromformerForMaskedLM.from_pretrained('uw-madison/nystromformer-512'				)

          lowerCamelCase__           =		tokenizer(SCREAMING_SNAKE_CASE__							,					return_tensors='pt'				)

          with torch.no_grad():
                lowerCamelCase__           =		model(encoding.input_ids				).logits

          lowerCamelCase__           =		token_logits[:, 2, :].argmax(-1				)[0]

          self.assertEqual(tokenizer.decode(SCREAMING_SNAKE_CASE__				)							,					'capital'				)







"""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							:					List[str]							,					SCREAMING_SNAKE_CASE__							:					List[str]							,					SCREAMING_SNAKE_CASE__							:					Union[str, Any]=12							,					SCREAMING_SNAKE_CASE__							:					Union[str, Any]=7							,					SCREAMING_SNAKE_CASE__							:					Union[str, Any]=True							,					SCREAMING_SNAKE_CASE__							:					Optional[Any]=True							,					SCREAMING_SNAKE_CASE__							:					str=True							,					SCREAMING_SNAKE_CASE__							:					Any=99							,					SCREAMING_SNAKE_CASE__							:					Optional[Any]=32							,					SCREAMING_SNAKE_CASE__							:					str=32							,					SCREAMING_SNAKE_CASE__							:					Tuple=2							,					SCREAMING_SNAKE_CASE__							:					str=4							,					SCREAMING_SNAKE_CASE__							:					Optional[Any]=37							,					SCREAMING_SNAKE_CASE__							:					Union[str, Any]=0.1							,					SCREAMING_SNAKE_CASE__							:					Optional[Any]=0.1							,					SCREAMING_SNAKE_CASE__							:					str=5_12							,					SCREAMING_SNAKE_CASE__							:					str=0.02							,					SCREAMING_SNAKE_CASE__							:					Union[str, Any]=0							,					SCREAMING_SNAKE_CASE__							:					Any=None							,					):
          lowerCamelCase__           =		parent
          lowerCamelCase__           =		batch_size
          lowerCamelCase__           =		seq_length
          lowerCamelCase__           =		is_training
          lowerCamelCase__           =		use_input_mask
          lowerCamelCase__           =		use_labels
          lowerCamelCase__           =		vocab_size
          lowerCamelCase__           =		hidden_size
          lowerCamelCase__           =		projection_dim
          lowerCamelCase__           =		num_hidden_layers
          lowerCamelCase__           =		num_attention_heads
          lowerCamelCase__           =		intermediate_size
          lowerCamelCase__           =		dropout
          lowerCamelCase__           =		attention_dropout
          lowerCamelCase__           =		max_position_embeddings
          lowerCamelCase__           =		initializer_range
          lowerCamelCase__           =		scope
          lowerCamelCase__           =		bos_token_id
    def      _UpperCamelCase       ( self							:					int				):
          lowerCamelCase__           =		ids_tensor([self.batch_size, self.seq_length]							,					self.vocab_size				)

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

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

          lowerCamelCase__           =		self.get_config()

          return config, input_ids, tf.convert_to_tensor(SCREAMING_SNAKE_CASE__				)
    def      _UpperCamelCase       ( self							:					Any				):
          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      _UpperCamelCase       ( self							:					Any							,					SCREAMING_SNAKE_CASE__							:					Any							,					SCREAMING_SNAKE_CASE__							:					List[str]							,					SCREAMING_SNAKE_CASE__							:					List[str]				):
          lowerCamelCase__           =		TFBlipTextModel(config=SCREAMING_SNAKE_CASE__				)
          lowerCamelCase__           =		model(SCREAMING_SNAKE_CASE__							,					attention_mask=SCREAMING_SNAKE_CASE__							,					training=SCREAMING_SNAKE_CASE__				)
          lowerCamelCase__           =		model(SCREAMING_SNAKE_CASE__							,					training=SCREAMING_SNAKE_CASE__				)
          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      _UpperCamelCase       ( self							:					Dict				):
          lowerCamelCase__           =		self.prepare_config_and_inputs()
          lowerCamelCase__    ,  lowerCamelCase__    ,  lowerCamelCase__           =		config_and_inputs
          lowerCamelCase__           =		{'input_ids': input_ids, 'attention_mask': input_mask}
          return config, inputs_dict





@require_tf
class   _a      (      SCREAMING_SNAKE_CASE_		,		unittest.TestCase ):
    a_    :				str             =    (TFBlipTextModel,) if is_tf_available() else ()
    a_    :				List[str]             =    False
    a_    :				Optional[Any]             =    False
    a_    :				Union[str, Any]             =    False
    def      _UpperCamelCase       ( self							:					str				):
          lowerCamelCase__           =		BlipTextModelTester(self				)
          lowerCamelCase__           =		ConfigTester(self							,					config_class=SCREAMING_SNAKE_CASE__							,					hidden_size=37				)
    def      _UpperCamelCase       ( self							:					Tuple				):
          self.config_tester.run_common_tests()
    def      _UpperCamelCase       ( self							:					str				):
          lowerCamelCase__           =		self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_model(*SCREAMING_SNAKE_CASE__				)
    def      _UpperCamelCase       ( self							:					Tuple				):
          pass
    def      _UpperCamelCase       ( self							:					Tuple				):
          pass
    @unittest.skip(reason='Blip does not use inputs_embeds'				)
    def      _UpperCamelCase       ( self							:					List[str]				):
          pass
    @unittest.skip(reason='BlipTextModel has no base class and is not available in MODEL_MAPPING'				)
    def      _UpperCamelCase       ( self							:					Dict				):
          pass
    @unittest.skip(reason='BlipTextModel has no base class and is not available in MODEL_MAPPING'				)
    def      _UpperCamelCase       ( self							:					List[Any]				):
          pass
    @slow
    def      _UpperCamelCase       ( self							:					str				):
          for model_name in TF_BLIP_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                lowerCamelCase__           =		TFBlipTextModel.from_pretrained(SCREAMING_SNAKE_CASE__				)
                self.assertIsNotNone(SCREAMING_SNAKE_CASE__				)


    def      _UpperCamelCase       ( self							:					Optional[int]							,					SCREAMING_SNAKE_CASE__							:					List[Any]=True				):
          super().test_pt_tf_model_equivalence(allow_missing_keys=SCREAMING_SNAKE_CASE__				)



