


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

							def __init__(							self:     str   ,						UpperCamelCase_:     int   ,						UpperCamelCase_:     List[str]=12   ,						UpperCamelCase_:     Optional[int]=7   ,						UpperCamelCase_:     List[Any]=True   ,						UpperCamelCase_:     Optional[int]=True   ,						UpperCamelCase_:     Dict=True   ,						UpperCamelCase_:     Any=99   ,						UpperCamelCase_:     List[str]=32   ,						UpperCamelCase_:     Union[str, Any]=32   ,						UpperCamelCase_:     Optional[int]=2   ,						UpperCamelCase_:     Union[str, Any]=4   ,						UpperCamelCase_:     Any=37   ,						UpperCamelCase_:     Dict=0.1   ,						UpperCamelCase_:     str=0.1   ,						UpperCamelCase_:     Optional[int]=512   ,						UpperCamelCase_:     Union[str, Any]=0.02   ,						UpperCamelCase_:     Optional[Any]=0   ,						UpperCamelCase_:     Union[str, Any]=None   ,						)      ->       Optional[int]:





									"""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 				lowerCamelCase_			(							self:     List[Any]							)      ->       int:





									"""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__						=				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 				lowerCamelCase_			(							self:     List[str]							)      ->       List[str]:





									"""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 				lowerCamelCase_			(							self:     List[str]   ,						UpperCamelCase_:     Any   ,						UpperCamelCase_:     List[Any]   ,						UpperCamelCase_:     Union[str, Any]							)      ->       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 				lowerCamelCase_			(							self:     Optional[Any]							)      ->       Dict:





									"""simple docstring"""







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


@require_tf
class 	_a							(      _UpperCAmelCase					,     unittest.TestCase      ):
							_lowercase     :      Tuple  				=			(TFBlipTextModel,) if is_tf_available() else ()
							_lowercase     :      Optional[Any]  				=			False
							_lowercase     :      str  				=			False
							_lowercase     :      List[str]  				=			False

							def 				lowerCamelCase_			(							self:     List[str]							)      ->       int:





									"""simple docstring"""







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

							def 				lowerCamelCase_			(							self:     Optional[int]							)      ->       Any:





									"""simple docstring"""







									self.config_tester.run_common_tests()

							def 				lowerCamelCase_			(							self:     List[str]							)      ->       Tuple:





									"""simple docstring"""







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

							def 				lowerCamelCase_			(							self:     List[Any]							)      ->       Optional[Any]:





									"""simple docstring"""







									pass

							def 				lowerCamelCase_			(							self:     Dict							)      ->       int:





									"""simple docstring"""







									pass

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





									"""simple docstring"""







									pass

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





									"""simple docstring"""







									pass

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





									"""simple docstring"""







									pass

							@slow
							def 				lowerCamelCase_			(							self:     Optional[Any]							)      ->       Optional[int]:





									"""simple docstring"""







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


							def 				lowerCamelCase_			(							self:     Tuple   ,						UpperCamelCase_:     Union[str, Any]=True							)      ->       str:





									"""simple docstring"""







									super().test_pt_tf_model_equivalence(allow_missing_keys=_UpperCAmelCase							)






lowerCAmelCase	=							[sum(int(c, 10) ** 2 for c in i.__str__()) for i in range(10_0000)]
def       _a			(				SCREAMING_SNAKE_CASE					):


		"""simple docstring"""




		lowercase__						=				0
		while number:
				# Increased Speed Slightly by checking every 5 digits together.
				sum_of_digits_squared += DIGITS_SQUARED[number % 10_00_00]
				number //= 10_00_00

		return sum_of_digits_squared


# There are 2 Chains made,
# One ends with 89 with the chain member 58 being the one which when declared first,
# there will be the least number of iterations for all the members to be checked.

# The other one ends with 1 and has only one element 1.

# So 58 and 1 are chosen to be declared at the starting.

# Changed dictionary to an array to quicken the solution
lowerCAmelCase	=							[None] * 1000_0000
lowerCAmelCase	=							True
lowerCAmelCase	=							False
def       _a			(				SCREAMING_SNAKE_CASE					):


		"""simple docstring"""




		if CHAINS[number - 1] is not None:
				return CHAINS[number - 1]  # type: ignore

		lowercase__						=				chain(next_number(SCREAMING_SNAKE_CASE					)					)
		lowercase__						=				number_chain

		while number < 10_00_00_00:
				lowercase__						=				number_chain
				number *= 10

		return number_chain
def       _a			(				SCREAMING_SNAKE_CASE = 10_00_00_00					):


		"""simple docstring"""




		for i in range(1						,    SCREAMING_SNAKE_CASE					):
				if CHAINS[i] is None:
						chain(i + 1					)

		return CHAINS[:number].count(SCREAMING_SNAKE_CASE					)


if __name__ == "__main__":
			import doctest

			doctest.testmod()
			print(f"""{solution() = }""")


