'''simple docstring'''

import unittest

import numpy as np

from transformers import BlipTextConfig
from transformers.testing_utils import require_torch, slow, torch_device
from transformers.utils import is_torch_available

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


if is_torch_available():
      import torch

      from transformers import BlipTextModel
      from transformers.models.blip.modeling_blip import BLIP_PRETRAINED_MODEL_ARCHIVE_LIST




class    lowerCamelCase__  :



   def __init__(    self					,      lowerCAmelCase__					,      lowerCAmelCase__=12					,      lowerCAmelCase__=7					,      lowerCAmelCase__=True					,      lowerCAmelCase__=True					,      lowerCAmelCase__=True					,      lowerCAmelCase__=99					,      lowerCAmelCase__=32					,      lowerCAmelCase__=32					,      lowerCAmelCase__=5					,      lowerCAmelCase__=4					,      lowerCAmelCase__=37					,      lowerCAmelCase__=0.1					,      lowerCAmelCase__=0.1					,      lowerCAmelCase__=512					,      lowerCAmelCase__=0.02					,      lowerCAmelCase__=0					,      lowerCAmelCase__=None					,      )				->     Tuple:
        """simple docstring"""





        _UpperCamelCase  :int       =parent
        _UpperCamelCase  :str       =batch_size
        _UpperCamelCase  :List[str]       =seq_length
        _UpperCamelCase  :Optional[Any]       =is_training
        _UpperCamelCase  :List[str]       =use_input_mask
        _UpperCamelCase  :Tuple       =use_labels
        _UpperCamelCase  :Union[str, Any]       =vocab_size
        _UpperCamelCase  :Union[str, Any]       =hidden_size
        _UpperCamelCase  :Union[str, Any]       =projection_dim
        _UpperCamelCase  :List[str]       =num_hidden_layers
        _UpperCamelCase  :Optional[int]       =num_attention_heads
        _UpperCamelCase  :List[Any]       =intermediate_size
        _UpperCamelCase  :Optional[int]       =dropout
        _UpperCamelCase  :str       =attention_dropout
        _UpperCamelCase  :Optional[int]       =max_position_embeddings
        _UpperCamelCase  :Union[str, Any]       =initializer_range
        _UpperCamelCase  :str       =scope
        _UpperCamelCase  :Dict       =bos_token_id



   def  _UpperCamelCase		(    self     )				->     Union[str, Any]:
        """simple docstring"""





        _UpperCamelCase  :int       =ids_tensor([self.batch_size, self.seq_length]					,      self.vocab_size     )

        _UpperCamelCase  :str       =None
        if self.use_input_mask:
             _UpperCamelCase  :Optional[int]       =random_attention_mask([self.batch_size, self.seq_length]     )

        if input_mask is not None:
             _UpperCamelCase       ,      _UpperCamelCase  :str       =input_mask.shape
             _UpperCamelCase  :Optional[int]       =np.random.randint(1					,      seq_length - 1					,      size=(batch_size,)     )
             for batch_idx, start_index in enumerate(__UpperCAmelCase     ):
                  _UpperCamelCase  :Optional[Any]       =1
                  _UpperCamelCase  :int       =0

        _UpperCamelCase  :List[Any]       =self.get_config()

        return config, input_ids, input_mask



   def  _UpperCamelCase		(    self     )				->     Any:
        """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  _UpperCamelCase		(    self					,      lowerCAmelCase__					,      lowerCAmelCase__					,      lowerCAmelCase__     )				->     Dict:
        """simple docstring"""





        _UpperCamelCase  :Optional[int]       =BlipTextModel(config=__UpperCAmelCase     )
        model.to(__UpperCAmelCase     )
        model.eval()
        with torch.no_grad():
             _UpperCamelCase  :Optional[Any]       =model(__UpperCAmelCase					,      attention_mask=__UpperCAmelCase     )
             _UpperCamelCase  :List[Any]       =model(__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  _UpperCamelCase		(    self     )				->     Optional[Any]:
        """simple docstring"""





        _UpperCamelCase  :List[str]       =self.prepare_config_and_inputs()
        _UpperCamelCase       ,      _UpperCamelCase       ,      _UpperCamelCase  :Dict       =config_and_inputs
        _UpperCamelCase  :Union[str, Any]       ={"""input_ids""": input_ids, """attention_mask""": input_mask}
        return config, inputs_dict




@require_torch
class    lowerCamelCase__  (   SCREAMING_SNAKE_CASE_       ,				unittest.TestCase     ):
   __UpperCAmelCase           =						(BlipTextModel,) if is_torch_available() else ()
   __UpperCAmelCase           =						False
   __UpperCAmelCase           =						False
   __UpperCAmelCase           =						False



   def  _UpperCamelCase		(    self     )				->     Optional[int]:
        """simple docstring"""





        _UpperCamelCase  :Tuple       =BlipTextModelTester(self     )
        _UpperCamelCase  :str       =ConfigTester(self					,      config_class=__UpperCAmelCase					,      hidden_size=37     )



   def  _UpperCamelCase		(    self     )				->     Union[str, Any]:
        """simple docstring"""





        self.config_tester.run_common_tests()



   def  _UpperCamelCase		(    self     )				->     List[Any]:
        """simple docstring"""





        _UpperCamelCase  :Tuple       =self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_model(*__UpperCAmelCase     )



   def  _UpperCamelCase		(    self     )				->     List[Any]:
        """simple docstring"""





        pass



   def  _UpperCamelCase		(    self     )				->     str:
        """simple docstring"""





        pass



   @unittest.skip(reason="""Blip does not use inputs_embeds"""     )
   def  _UpperCamelCase		(    self     )				->     Optional[Any]:
        """simple docstring"""





        pass



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





        pass



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





        pass



   @slow
   def  _UpperCamelCase		(    self     )				->     List[Any]:
        """simple docstring"""





        for model_name in BLIP_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
             _UpperCamelCase  :Dict       =BlipTextModel.from_pretrained(__UpperCAmelCase     )
             self.assertIsNotNone(__UpperCAmelCase     )




   def  _UpperCamelCase		(    self     )				->     str:
        """simple docstring"""





        super().test_pt_tf_model_equivalence(allow_missing_keys=__UpperCAmelCase     )

"""simple docstring"""






import unittest

import numpy as np

from transformers.testing_utils import require_torch, require_vision
from transformers.utils import is_torch_available, is_vision_available

from ...test_image_processing_common import ImageProcessingSavingTestMixin


if is_torch_available():
      import torch

if is_vision_available():
      from PIL import Image

      from transformers import TvltImageProcessor
def    UpperCamelCase						(					UpperCAmelCase ,   UpperCAmelCase=10 ,   UpperCAmelCase=10 ,   UpperCAmelCase=False ,   UpperCAmelCase=False     )						->Union[str, Any]:

   """simple docstring"""



   a_						   =     []
   for i in range(image_processor_tester.num_frames     ):
      video.append(np.random.randint(255 ,   size=(image_processor_tester.num_channels, width, height) ,   dtype=np.uinta     )     )

   if not numpify and not torchify:
      # PIL expects the channel dimension as last dimension
      a_						   =     [Image.fromarray(np.moveaxis(UpperCAmelCase ,   0 ,   -1     )     ) for frame in video]

   if torchify:
      a_						   =     [torch.from_numpy(UpperCAmelCase     ) for frame in video]

   return video
def    UpperCamelCase						(					UpperCAmelCase ,   UpperCAmelCase=False ,   UpperCAmelCase=False ,   UpperCAmelCase=False     )						->Optional[Any]:

   """simple docstring"""



   assert not (numpify and torchify), "You cannot specify both numpy and PyTorch tensors at the same time"

   a_						   =     []
   for i in range(image_processor_tester.batch_size     ):
      if equal_resolution:
         a_						   =     a_						   =     image_processor_tester.max_resolution
      else:
         a_   ,			a_						   =     np.random.choice(
             np.arange(image_processor_tester.min_resolution ,   image_processor_tester.max_resolution     ) ,   2     )
         a_						   =     prepare_video(
             image_processor_tester=UpperCAmelCase ,   width=UpperCAmelCase ,   height=UpperCAmelCase ,   numpify=UpperCAmelCase ,   torchify=UpperCAmelCase ,   )
      video_inputs.append(UpperCAmelCase     )

   return video_inputs





class 							snake_case       (     unittest.TestCase		):







   def __init__( self       ,							__UpperCAmelCase       ,							__UpperCAmelCase=7       ,							__UpperCAmelCase=3       ,							__UpperCAmelCase=4       ,							__UpperCAmelCase=18       ,							__UpperCAmelCase=30       ,							__UpperCAmelCase=4_00       ,							__UpperCAmelCase=True       ,							__UpperCAmelCase=None       ,							__UpperCAmelCase=True       ,							__UpperCAmelCase=[0.5, 0.5, 0.5]       ,							__UpperCAmelCase=[0.5, 0.5, 0.5]       ,							__UpperCAmelCase=True       ,							__UpperCAmelCase=None       ,							)   ->str:
      a_						   =     size if size is not None else {"shortest_edge": 18}
      a_						   =     crop_size if crop_size is not None else {"height": 18, "width": 18}

      a_						   =     parent
      a_						   =     batch_size
      a_						   =     num_channels
      a_						   =     num_frames
      a_						   =     image_size
      a_						   =     min_resolution
      a_						   =     max_resolution
      a_						   =     do_resize
      a_						   =     size
      a_						   =     do_normalize
      a_						   =     image_mean
      a_						   =     image_std
      a_						   =     do_center_crop
      a_						   =     crop_size







   def    UpperCAmelCase__	( self)   ->Tuple:
      return {
          "image_mean": self.image_mean,
          "image_std": self.image_std,
          "do_normalize": self.do_normalize,
          "do_resize": self.do_resize,
          "size": self.size,
          "do_center_crop": self.do_center_crop,
          "crop_size": self.crop_size,
      }






@require_torch
@require_vision
class 							snake_case       (     SCREAMING_SNAKE_CASE_							,       unittest.TestCase		):
   a_					:		int     					=     TvltImageProcessor if is_vision_available() else None







   def    UpperCAmelCase__	( self)   ->Optional[Any]:
      a_						   =     TvltImageProcessorTester(self)







   @property
   def    UpperCAmelCase__	( self)   ->int:
      return self.image_processor_tester.prepare_image_processor_dict()







   def    UpperCAmelCase__	( self)   ->int:
      a_						   =     self.image_processing_class(**self.image_processor_dict)
      self.assertTrue(hasattr(__UpperCAmelCase       ,							"image_mean"))
      self.assertTrue(hasattr(__UpperCAmelCase       ,							"image_std"))
      self.assertTrue(hasattr(__UpperCAmelCase       ,							"do_normalize"))
      self.assertTrue(hasattr(__UpperCAmelCase       ,							"do_resize"))
      self.assertTrue(hasattr(__UpperCAmelCase       ,							"do_center_crop"))
      self.assertTrue(hasattr(__UpperCAmelCase       ,							"size"))







   def    UpperCAmelCase__	( self)   ->Any:
      # Initialize image_processor
      a_						   =     self.image_processing_class(**self.image_processor_dict)
      # create random PIL videos
      a_						   =     prepare_video_inputs(self.image_processor_tester       ,							equal_resolution=__UpperCAmelCase)
      for video in video_inputs:
         self.assertIsInstance(__UpperCAmelCase       ,							__UpperCAmelCase)
         self.assertIsInstance(video[0]       ,							Image.Image)

      # Test not batched input
      a_						   =     image_processor(video_inputs[0]       ,							return_tensors="pt").pixel_values
      self.assertEqual(
          encoded_videos.shape       ,							(
              1,
              self.image_processor_tester.num_frames,
              self.image_processor_tester.num_channels,
              self.image_processor_tester.crop_size["height"],
              self.image_processor_tester.crop_size["width"],
          )       ,							)

      # Test batched
      a_						   =     image_processor(__UpperCAmelCase       ,							return_tensors="pt").pixel_values
      self.assertEqual(
          encoded_videos.shape       ,							(
              self.image_processor_tester.batch_size,
              self.image_processor_tester.num_frames,
              self.image_processor_tester.num_channels,
              self.image_processor_tester.crop_size["height"],
              self.image_processor_tester.crop_size["width"],
          )       ,							)







   def    UpperCAmelCase__	( self)   ->int:
      # Initialize image_processor
      a_						   =     self.image_processing_class(**self.image_processor_dict)
      # create random numpy tensors
      a_						   =     prepare_video_inputs(self.image_processor_tester       ,							equal_resolution=__UpperCAmelCase       ,							numpify=__UpperCAmelCase)
      for video in video_inputs:
         self.assertIsInstance(__UpperCAmelCase       ,							__UpperCAmelCase)
         self.assertIsInstance(video[0]       ,							np.ndarray)

      # Test not batched input
      a_						   =     image_processor(video_inputs[0]       ,							return_tensors="pt").pixel_values
      self.assertEqual(
          encoded_videos.shape       ,							(
              1,
              self.image_processor_tester.num_frames,
              self.image_processor_tester.num_channels,
              self.image_processor_tester.crop_size["height"],
              self.image_processor_tester.crop_size["width"],
          )       ,							)

      # Test batched
      a_						   =     image_processor(__UpperCAmelCase       ,							return_tensors="pt").pixel_values
      self.assertEqual(
          encoded_videos.shape       ,							(
              self.image_processor_tester.batch_size,
              self.image_processor_tester.num_frames,
              self.image_processor_tester.num_channels,
              self.image_processor_tester.crop_size["height"],
              self.image_processor_tester.crop_size["width"],
          )       ,							)







   def    UpperCAmelCase__	( self)   ->Tuple:
      # Initialize image_processor
      a_						   =     self.image_processing_class(**self.image_processor_dict)
      # create random PyTorch tensors
      a_						   =     prepare_video_inputs(self.image_processor_tester       ,							equal_resolution=__UpperCAmelCase       ,							torchify=__UpperCAmelCase)
      for video in video_inputs:
         self.assertIsInstance(__UpperCAmelCase       ,							__UpperCAmelCase)
         self.assertIsInstance(video[0]       ,							torch.Tensor)

      # Test not batched input
      a_						   =     image_processor(video_inputs[0]       ,							return_tensors="pt").pixel_values
      self.assertEqual(
          encoded_videos.shape       ,							(
              1,
              self.image_processor_tester.num_frames,
              self.image_processor_tester.num_channels,
              self.image_processor_tester.crop_size["height"],
              self.image_processor_tester.crop_size["width"],
          )       ,							)

      # Test batched
      a_						   =     image_processor(__UpperCAmelCase       ,							return_tensors="pt").pixel_values
      self.assertEqual(
          encoded_videos.shape       ,							(
              self.image_processor_tester.batch_size,
              self.image_processor_tester.num_frames,
              self.image_processor_tester.num_channels,
              self.image_processor_tester.crop_size["height"],
              self.image_processor_tester.crop_size["width"],
          )       ,							)