




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        lowerCamelCase_							:


 '''simple docstring'''







 def __init__(							self  :		Any				,				_lowerCAmelCase  :		Optional[int]				,				_lowerCAmelCase  :		List[str]=12				,				_lowerCAmelCase  :		Dict=7				,				_lowerCAmelCase  :		Union[str, Any]=True				,				_lowerCAmelCase  :		Optional[int]=True				,				_lowerCAmelCase  :		Any=True				,				_lowerCAmelCase  :		List[Any]=99				,				_lowerCAmelCase  :		Optional[Any]=32				,				_lowerCAmelCase  :		Union[str, Any]=32				,				_lowerCAmelCase  :		Optional[Any]=2				,				_lowerCAmelCase  :		Tuple=4				,				_lowerCAmelCase  :		Any=37				,				_lowerCAmelCase  :		int=0.1				,				_lowerCAmelCase  :		str=0.1				,				_lowerCAmelCase  :		Optional[Any]=512				,				_lowerCAmelCase  :		str=0.02				,				_lowerCAmelCase  :		Optional[int]=0				,				_lowerCAmelCase  :		str=None				,				):
       SCREAMING_SNAKE_CASE_							=			parent
       SCREAMING_SNAKE_CASE_							=			batch_size
       SCREAMING_SNAKE_CASE_							=			seq_length
       SCREAMING_SNAKE_CASE_							=			is_training
       SCREAMING_SNAKE_CASE_							=			use_input_mask
       SCREAMING_SNAKE_CASE_							=			use_labels
       SCREAMING_SNAKE_CASE_							=			vocab_size
       SCREAMING_SNAKE_CASE_							=			hidden_size
       SCREAMING_SNAKE_CASE_							=			projection_dim
       SCREAMING_SNAKE_CASE_							=			num_hidden_layers
       SCREAMING_SNAKE_CASE_							=			num_attention_heads
       SCREAMING_SNAKE_CASE_							=			intermediate_size
       SCREAMING_SNAKE_CASE_							=			dropout
       SCREAMING_SNAKE_CASE_							=			attention_dropout
       SCREAMING_SNAKE_CASE_							=			max_position_embeddings
       SCREAMING_SNAKE_CASE_							=			initializer_range
       SCREAMING_SNAKE_CASE_							=			scope
       SCREAMING_SNAKE_CASE_							=			bos_token_id



 def       lowerCAmelCase_  (							self  :		Tuple						):
       SCREAMING_SNAKE_CASE_							=			ids_tensor([self.batch_size, self.seq_length]				,				self.vocab_size						)

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

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

       SCREAMING_SNAKE_CASE_							=			self.get_config()

       return config, input_ids, tf.convert_to_tensor(_lowerCAmelCase						)



 def       lowerCAmelCase_  (							self  :		List[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       lowerCAmelCase_  (							self  :		Dict				,				_lowerCAmelCase  :		Any				,				_lowerCAmelCase  :		Any				,				_lowerCAmelCase  :		Optional[int]						):
       SCREAMING_SNAKE_CASE_							=			TFBlipTextModel(config=_lowerCAmelCase						)
       SCREAMING_SNAKE_CASE_							=			model(_lowerCAmelCase				,				attention_mask=_lowerCAmelCase				,				training=_lowerCAmelCase						)
       SCREAMING_SNAKE_CASE_							=			model(_lowerCAmelCase				,				training=_lowerCAmelCase						)
       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       lowerCAmelCase_  (							self  :		Optional[Any]						):
       SCREAMING_SNAKE_CASE_							=			self.prepare_config_and_inputs()
       SCREAMING_SNAKE_CASE_						, SCREAMING_SNAKE_CASE_						, SCREAMING_SNAKE_CASE_							=			config_and_inputs
       SCREAMING_SNAKE_CASE_							=			{'input_ids': input_ids, 'attention_mask': input_mask}
       return config, inputs_dict





@require_tf
class        lowerCamelCase_							(      _SCREAMING_SNAKE_CASE       ,   unittest.TestCase					):


 '''simple docstring'''







 lowercase_				    =    (TFBlipTextModel,) if is_tf_available() else ()
 lowercase_				    =    False
 lowercase_				    =    False
 lowercase_				    =    False



 def       lowerCAmelCase_  (							self  :		Any						):
       SCREAMING_SNAKE_CASE_							=			BlipTextModelTester(self						)
       SCREAMING_SNAKE_CASE_							=			ConfigTester(self				,				config_class=_lowerCAmelCase				,				hidden_size=37						)



 def       lowerCAmelCase_  (							self  :		Optional[int]						):
       self.config_tester.run_common_tests()



 def       lowerCAmelCase_  (							self  :		List[str]						):
       SCREAMING_SNAKE_CASE_							=			self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_model(*_lowerCAmelCase						)



 def       lowerCAmelCase_  (							self  :		Optional[Any]						):
       pass



 def       lowerCAmelCase_  (							self  :		int						):
       pass



 @unittest.skip(reason='Blip does not use inputs_embeds'						)
 def       lowerCAmelCase_  (							self  :		Optional[int]						):
       pass



 @unittest.skip(reason='BlipTextModel has no base class and is not available in MODEL_MAPPING'						)
 def       lowerCAmelCase_  (							self  :		Optional[int]						):
       pass



 @unittest.skip(reason='BlipTextModel has no base class and is not available in MODEL_MAPPING'						)
 def       lowerCAmelCase_  (							self  :		List[str]						):
       pass



 @slow
 def       lowerCAmelCase_  (							self  :		List[str]						):
       for model_name in TF_BLIP_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
             SCREAMING_SNAKE_CASE_							=			TFBlipTextModel.from_pretrained(_lowerCAmelCase						)
             self.assertIsNotNone(_lowerCAmelCase						)




 def       lowerCAmelCase_  (							self  :		Dict				,				_lowerCAmelCase  :		Optional[Any]=True						):
       super().test_pt_tf_model_equivalence(allow_missing_keys=_lowerCAmelCase						)





from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_tokenizers_available,
    is_torch_available,
    is_vision_available,
)


lowerCamelCase__ :   Union[str, Any]					=							{
    'configuration_layoutlmv2': ['LAYOUTLMV2_PRETRAINED_CONFIG_ARCHIVE_MAP', 'LayoutLMv2Config'],
    'processing_layoutlmv2': ['LayoutLMv2Processor'],
    'tokenization_layoutlmv2': ['LayoutLMv2Tokenizer'],
}

try:
   if not is_tokenizers_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   lowerCamelCase__ :   Any					=							['LayoutLMv2TokenizerFast']

try:
   if not is_vision_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   lowerCamelCase__ :   Dict					=							['LayoutLMv2FeatureExtractor']
   lowerCamelCase__ :   Dict					=							['LayoutLMv2ImageProcessor']

try:
   if not is_torch_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   lowerCamelCase__ :   Union[str, Any]					=							[
       'LAYOUTLMV2_PRETRAINED_MODEL_ARCHIVE_LIST',
       'LayoutLMv2ForQuestionAnswering',
       'LayoutLMv2ForSequenceClassification',
       'LayoutLMv2ForTokenClassification',
       'LayoutLMv2Layer',
       'LayoutLMv2Model',
       'LayoutLMv2PreTrainedModel',
   ]

if TYPE_CHECKING:
   from .configuration_layoutlmva import LAYOUTLMV2_PRETRAINED_CONFIG_ARCHIVE_MAP, LayoutLMvaConfig
   from .processing_layoutlmva import LayoutLMvaProcessor
   from .tokenization_layoutlmva import LayoutLMvaTokenizer

   try:
      if not is_tokenizers_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .tokenization_layoutlmva_fast import LayoutLMvaTokenizerFast

   try:
      if not is_vision_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .feature_extraction_layoutlmva import LayoutLMvaFeatureExtractor, LayoutLMvaImageProcessor

   try:
      if not is_torch_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .modeling_layoutlmva import (
          LAYOUTLMV2_PRETRAINED_MODEL_ARCHIVE_LIST,
          LayoutLMvaForQuestionAnswering,
          LayoutLMvaForSequenceClassification,
          LayoutLMvaForTokenClassification,
          LayoutLMvaLayer,
          LayoutLMvaModel,
          LayoutLMvaPreTrainedModel,
      )
else:
   import sys

   lowerCamelCase__ :   Any					=							_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)