





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

  """simple docstring"""


  def __init__(				self :		Any					,  lowerCAmelCase_ :		Optional[int]					,  lowerCAmelCase_ :		List[str]=1_2					,  lowerCAmelCase_ :		Dict=7					,  lowerCAmelCase_ :		Union[str, Any]=True					,  lowerCAmelCase_ :		Optional[int]=True					,  lowerCAmelCase_ :		Any=True					,  lowerCAmelCase_ :		List[Any]=9_9					,  lowerCAmelCase_ :		Optional[Any]=3_2					,  lowerCAmelCase_ :		Union[str, Any]=3_2					,  lowerCAmelCase_ :		Optional[Any]=2					,  lowerCAmelCase_ :		Tuple=4					,  lowerCAmelCase_ :		Any=3_7					,  lowerCAmelCase_ :		int=0.1					,  lowerCAmelCase_ :		str=0.1					,  lowerCAmelCase_ :		Optional[Any]=5_1_2					,  lowerCAmelCase_ :		str=0.02					,  lowerCAmelCase_ :		Optional[int]=0					,  lowerCAmelCase_ :		str=None					,  )							->						List[str]:
     __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 				lowercase		(				self :		Tuple     )							->						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]     )

     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(_lowerCAmelCase     ):
           __lowerCAmelCase								=	1
           __lowerCAmelCase								=	0

     __lowerCAmelCase								=	self.get_config()

     return config, input_ids, tf.convert_to_tensor(_lowerCAmelCase     )






  def 				lowercase		(				self :		List[Any]     )							->						Optional[int]:
     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 				lowercase		(				self :		Dict					,  lowerCAmelCase_ :		Any					,  lowerCAmelCase_ :		Any					,  lowerCAmelCase_ :		Optional[int]     )							->						int:
     __lowerCAmelCase								=	TFBlipTextModel(config=_lowerCAmelCase     )
     __lowerCAmelCase								=	model(_lowerCAmelCase					,  attention_mask=_lowerCAmelCase					,  training=_lowerCAmelCase     )
     __lowerCAmelCase								=	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 				lowercase		(				self :		Optional[Any]     )							->						Optional[Any]:
     __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 				_UpperCAmelCase    (    _SCREAMING_SNAKE_CASE		,    unittest.TestCase    ):

  """simple docstring"""


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






  def 				lowercase		(				self :		Any     )							->						List[Any]:
     __lowerCAmelCase								=	BlipTextModelTester(self     )
     __lowerCAmelCase								=	ConfigTester(self					,  config_class=_lowerCAmelCase					,  hidden_size=3_7     )






  def 				lowercase		(				self :		Optional[int]     )							->						int:
     self.config_tester.run_common_tests()






  def 				lowercase		(				self :		List[str]     )							->						Optional[int]:
     __lowerCAmelCase								=	self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_model(*_lowerCAmelCase     )






  def 				lowercase		(				self :		Optional[Any]     )							->						Union[str, Any]:
     pass






  def 				lowercase		(				self :		int     )							->						Any:
     pass






  @unittest.skip(reason='Blip does not use inputs_embeds'     )
  def 				lowercase		(				self :		Optional[int]     )							->						Union[str, Any]:
     pass






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






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






  @slow
  def 				lowercase		(				self :		List[str]     )							->						Any:
     for model_name in TF_BLIP_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
        __lowerCAmelCase								=	TFBlipTextModel.from_pretrained(_lowerCAmelCase     )
        self.assertIsNotNone(_lowerCAmelCase     )






  def 				lowercase		(				self :		Dict					,  lowerCAmelCase_ :		Optional[Any]=True     )							->						Optional[Any]:
     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__)