





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							:







  def __init__(      self  :List[Any]   ,							_lowercase  :List[Any]   ,							_lowercase  :Dict=12   ,							_lowercase  :Optional[int]=7   ,							_lowercase  :Union[str, Any]=True   ,							_lowercase  :List[Any]=True   ,							_lowercase  :str=True   ,							_lowercase  :List[Any]=99   ,							_lowercase  :int=32   ,							_lowercase  :Optional[int]=32   ,							_lowercase  :Dict=2   ,							_lowercase  :str=4   ,							_lowercase  :Dict=37   ,							_lowercase  :List[str]=0.1   ,							_lowercase  :Tuple=0.1   ,							_lowercase  :Union[str, Any]=5_12   ,							_lowercase  :int=0.02   ,							_lowercase  :Tuple=0   ,							_lowercase  :List[Any]=None   ,							):






     '''simple docstring'''





     lowercase__			       =  parent
     lowercase__			       =  batch_size
     lowercase__			       =  seq_length
     lowercase__			       =  is_training
     lowercase__			       =  use_input_mask
     lowercase__			       =  use_labels
     lowercase__			       =  vocab_size
     lowercase__			       =  hidden_size
     lowercase__			       =  projection_dim
     lowercase__			       =  num_hidden_layers
     lowercase__			       =  num_attention_heads
     lowercase__			       =  intermediate_size
     lowercase__			       =  dropout
     lowercase__			       =  attention_dropout
     lowercase__			       =  max_position_embeddings
     lowercase__			       =  initializer_range
     lowercase__			       =  scope
     lowercase__			       =  bos_token_id







  def   UpperCAmelCase					(      self  :Tuple ):






     '''simple docstring'''





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

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

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

     lowercase__			       =  self.get_config()

     return config, input_ids, tf.convert_to_tensor(_lowercase )







  def   UpperCAmelCase					(      self  :int ):






     '''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  :Tuple   ,							_lowercase  :int   ,							_lowercase  :Optional[Any]   ,							_lowercase  :Dict ):






     '''simple docstring'''





     lowercase__			       =  TFBlipTextModel(config=_lowercase )
     lowercase__			       =  model(_lowercase   ,							attention_mask=_lowercase   ,							training=_lowercase )
     lowercase__			       =  model(_lowercase   ,							training=_lowercase )
     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 ):






     '''simple docstring'''





     lowercase__			       =  self.prepare_config_and_inputs()
     lowercase__       ,							lowercase__       ,							lowercase__			       =  config_and_inputs
     lowercase__			       =  {"input_ids": input_ids, "attention_mask": input_mask}
     return config, inputs_dict





@require_tf
class  lowerCAmelCase							(       lowercase_							,							unittest.TestCase ):
  __lowerCamelCase		=      (TFBlipTextModel,) if is_tf_available() else ()
  __lowerCamelCase		=      False
  __lowerCamelCase		=      False
  __lowerCamelCase		=      False







  def   UpperCAmelCase					(      self  :Dict ):






     '''simple docstring'''





     lowercase__			       =  BlipTextModelTester(self )
     lowercase__			       =  ConfigTester(self   ,							config_class=_lowercase   ,							hidden_size=37 )







  def   UpperCAmelCase					(      self  :Optional[Any] ):






     '''simple docstring'''





     self.config_tester.run_common_tests()







  def   UpperCAmelCase					(      self  :Optional[int] ):






     '''simple docstring'''





     lowercase__			       =  self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_model(*_lowercase )







  def   UpperCAmelCase					(      self  :str ):






     '''simple docstring'''





     pass







  def   UpperCAmelCase					(      self  :Optional[int] ):






     '''simple docstring'''





     pass







  @unittest.skip(reason="Blip does not use inputs_embeds" )
  def   UpperCAmelCase					(      self  :Union[str, Any] ):






     '''simple docstring'''





     pass







  @unittest.skip(reason="BlipTextModel has no base class and is not available in MODEL_MAPPING" )
  def   UpperCAmelCase					(      self  :Any ):






     '''simple docstring'''





     pass







  @unittest.skip(reason="BlipTextModel has no base class and is not available in MODEL_MAPPING" )
  def   UpperCAmelCase					(      self  :int ):






     '''simple docstring'''





     pass







  @slow
  def   UpperCAmelCase					(      self  :Optional[int] ):






     '''simple docstring'''





     for model_name in TF_BLIP_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
        lowercase__			       =  TFBlipTextModel.from_pretrained(_lowercase )
        self.assertIsNotNone(_lowercase )







  def   UpperCAmelCase					(      self  :str   ,							_lowercase  :Union[str, Any]=True ):






     '''simple docstring'''





     super().test_pt_tf_model_equivalence(allow_missing_keys=_lowercase )













from itertools import count


def _A       (   __magic_name__ = 50	):
   lowercase__			       =  [1] * min_block_length

   for n in count(__magic_name__	):
      fill_count_functions.append(1	)

      for block_length in range(__magic_name__  , n + 1	):
         for block_start in range(n - block_length	):
            fill_count_functions[n] += fill_count_functions[
                n - block_start - block_length - 1
            ]

         fill_count_functions[n] += 1

      if fill_count_functions[n] > 100_0000:
         break

   return n


if __name__ == "__main__":
  print(F"""{solution() = }""")






