




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    :						Tuple							,							_lowerCAmelCase    :						Tuple							,							_lowerCAmelCase    :						Optional[Any]=12							,							_lowerCAmelCase    :						Dict=7							,							_lowerCAmelCase    :						Optional[Any]=True							,							_lowerCAmelCase    :						Dict=True							,							_lowerCAmelCase    :						Optional[int]=True							,							_lowerCAmelCase    :						str=99							,							_lowerCAmelCase    :						List[str]=32							,							_lowerCAmelCase    :						int=32							,							_lowerCAmelCase    :						List[Any]=2							,							_lowerCAmelCase    :						List[Any]=4							,							_lowerCAmelCase    :						Optional[Any]=37							,							_lowerCAmelCase    :						int=0.1							,							_lowerCAmelCase    :						List[Any]=0.1							,							_lowerCAmelCase    :						List[Any]=512							,							_lowerCAmelCase    :						List[Any]=0.02							,							_lowerCAmelCase    :						List[Any]=0							,							_lowerCAmelCase    :						Optional[Any]=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    :						Dict		):
       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    :						str		):
       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    :						Union[str, Any]							,							_lowerCAmelCase    :						Any							,							_lowerCAmelCase    :						int							,							_lowerCAmelCase    :						Any		):
       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    :						Dict		):
       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    :						List[str]		):
       SCREAMING_SNAKE_CASE_      		=     BlipTextModelTester(self		)
       SCREAMING_SNAKE_CASE_      		=     ConfigTester(self							,							config_class=_lowerCAmelCase							,							hidden_size=37		)



 def  lowerCAmelCase_    (				self    :						Union[str, Any]		):
       self.config_tester.run_common_tests()



 def  lowerCAmelCase_    (				self    :						int		):
       SCREAMING_SNAKE_CASE_      		=     self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_model(*_lowerCAmelCase		)



 def  lowerCAmelCase_    (				self    :						int		):
       pass



 def  lowerCAmelCase_    (				self    :						List[str]		):
       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    :						str		):
       pass



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




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





from __future__ import annotations

from collections.abc import Generator

def    UpperCAmelCase_				( )   ->					Generator[int, None, None]:
      SCREAMING_SNAKE_CASE_      		=     {}
      SCREAMING_SNAKE_CASE_      		=     2
      while True:
            SCREAMING_SNAKE_CASE_      		=     factor_map.pop(__UpperCAmelCase     ,     __UpperCAmelCase				)
            if factor:
                  SCREAMING_SNAKE_CASE_      		=     factor + prime
                  while x in factor_map:
                        x += factor
                  SCREAMING_SNAKE_CASE_      		=     factor
            else:
                  SCREAMING_SNAKE_CASE_      		=     prime
                  yield prime
            prime += 1

def    UpperCAmelCase_				( __UpperCAmelCase		:      float = 1E10				)   ->					int:
      SCREAMING_SNAKE_CASE_      		=     sieve()

      SCREAMING_SNAKE_CASE_      		=     1
      while True:
            SCREAMING_SNAKE_CASE_      		=     next(__UpperCAmelCase				)
            if (2 * prime * n) > limit:
                  return n
            # Ignore the next prime as the reminder will be 2.
            next(__UpperCAmelCase				)
            n += 2


if __name__ == "__main__":
   print(solution())