


'''simple docstring'''

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    :    Optional[int]   ,						UpperCamelCase    :    Optional[Any]   ,						UpperCamelCase    :    Tuple=12   ,						UpperCamelCase    :    Tuple=7   ,						UpperCamelCase    :    List[str]=True   ,						UpperCamelCase    :    Dict=True   ,						UpperCamelCase    :    int=True   ,						UpperCamelCase    :    str=99   ,						UpperCamelCase    :    Tuple=32   ,						UpperCamelCase    :    Dict=32   ,						UpperCamelCase    :    List[str]=2   ,						UpperCamelCase    :    int=4   ,						UpperCamelCase    :    Optional[int]=37   ,						UpperCamelCase    :    Optional[Any]=0.1   ,						UpperCamelCase    :    str=0.1   ,						UpperCamelCase    :    List[str]=512   ,						UpperCamelCase    :    Optional[int]=0.02   ,						UpperCamelCase    :    List[Any]=0   ,						UpperCamelCase    :    Union[str, 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    :    Optional[Any] ):

             '''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(UpperCamelCase ):
                           lowercase__      			= 1
                           lowercase__      			= 0

             lowercase__      			= self.get_config()

             return config, input_ids, tf.convert_to_tensor(UpperCamelCase )



      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    :    List[str]   ,						UpperCamelCase    :    Optional[int]   ,						UpperCamelCase    :    List[Any]   ,						UpperCamelCase    :    List[str] ):

             '''simple docstring'''







             lowercase__      			= TFBlipTextModel(config=UpperCamelCase )
             lowercase__      			= model(UpperCamelCase   ,						attention_mask=UpperCamelCase   ,						training=UpperCamelCase )
             lowercase__      			= model(UpperCamelCase   ,						training=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[int] ):

             '''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     ):





      '''simple docstring'''






      lowerCAmelCase__					:     str  					=							(TFBlipTextModel,) if is_tf_available() else ()
      lowerCAmelCase__					:     Union[str, Any]  					=							False
      lowerCAmelCase__					:     int  					=							False
      lowerCAmelCase__					:     Tuple  					=							False



      def       UpperCamelCase__		(self    :    Any ):

             '''simple docstring'''







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



      def       UpperCamelCase__		(self    :    int ):

             '''simple docstring'''







             self.config_tester.run_common_tests()



      def       UpperCamelCase__		(self    :    str ):

             '''simple docstring'''







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



      def       UpperCamelCase__		(self    :    Optional[int] ):

             '''simple docstring'''







             pass



      def       UpperCamelCase__		(self    :    List[str] ):

             '''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    :    Dict ):

             '''simple docstring'''







             pass



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

             '''simple docstring'''







             pass



      @slow
      def       UpperCamelCase__		(self    :    List[Any] ):

             '''simple docstring'''







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






      def       UpperCamelCase__		(self    :    Optional[Any]   ,						UpperCamelCase    :    Any=True ):

             '''simple docstring'''







             super().test_pt_tf_model_equivalence(allow_missing_keys=UpperCamelCase )






'''simple docstring'''







def 				SCREAMING_SNAKE_CASE__	(   __A = 1_000_000	)       ->	int:
	_snake_case   						=		limit + 1
	_snake_case   						=		[0] * limit
	for first_term in range(1			,				__A	):
		for n in range(__A			,				__A			,				__A	):
			_snake_case   						=		first_term + n / first_term
			if common_difference % 4:  # d must be divisble by 4
				continue
			else:
				common_difference /= 4
				if (
				    first_term > common_difference
				    and first_term < 4 * common_difference
				):  # since x,y,z are positive integers
					frequency[n] += 1  # so z>0 and a>d ,also 4d<a

	_snake_case   						=		sum(1 for x in frequency[1:limit] if x == 10	)

	return count


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

