






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




		'''simple docstring'''





		def __init__(      self   ,_lowerCAmelCase   ,_lowerCAmelCase=12   ,_lowerCAmelCase=7   ,_lowerCAmelCase=True   ,_lowerCAmelCase=True   ,_lowerCAmelCase=True   ,_lowerCAmelCase=99   ,_lowerCAmelCase=32   ,_lowerCAmelCase=32   ,_lowerCAmelCase=2   ,_lowerCAmelCase=4   ,_lowerCAmelCase=37   ,_lowerCAmelCase=0.1   ,_lowerCAmelCase=0.1   ,_lowerCAmelCase=5_12   ,_lowerCAmelCase=0.02   ,_lowerCAmelCase=0   ,_lowerCAmelCase=None   ,):
								lowerCamelCase__         =  parent
								lowerCamelCase__         =  batch_size
								lowerCamelCase__         =  seq_length
								lowerCamelCase__         =  is_training
								lowerCamelCase__         =  use_input_mask
								lowerCamelCase__         =  use_labels
								lowerCamelCase__         =  vocab_size
								lowerCamelCase__         =  hidden_size
								lowerCamelCase__         =  projection_dim
								lowerCamelCase__         =  num_hidden_layers
								lowerCamelCase__         =  num_attention_heads
								lowerCamelCase__         =  intermediate_size
								lowerCamelCase__         =  dropout
								lowerCamelCase__         =  attention_dropout
								lowerCamelCase__         =  max_position_embeddings
								lowerCamelCase__         =  initializer_range
								lowerCamelCase__         =  scope
								lowerCamelCase__         =  bos_token_id






		def 			UpperCamelCase_					(      self       ):
								lowerCamelCase__         =  ids_tensor([self.batch_size, self.seq_length]   ,self.vocab_size       )

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

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

								lowerCamelCase__         =  self.get_config()

								return config, input_ids, tf.convert_to_tensor(_lowerCAmelCase       )






		def 			UpperCamelCase_					(      self       ):
								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       ):
								lowerCamelCase__         =  TFBlipTextModel(config=_lowerCAmelCase       )
								lowerCamelCase__         =  model(_lowerCAmelCase   ,attention_mask=_lowerCAmelCase   ,training=_lowerCAmelCase       )
								lowerCamelCase__         =  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 			UpperCamelCase_					(      self       ):
								lowerCamelCase__         =  self.prepare_config_and_inputs()
								lowerCamelCase__       ,			lowerCamelCase__       ,			lowerCamelCase__         =  config_and_inputs
								lowerCamelCase__         =  {"""input_ids""": input_ids, """attention_mask""": input_mask}
								return config, inputs_dict




@require_tf
class 		UpperCamelCase__    (a   ,unittest.TestCase			):




		'''simple docstring'''





		_UpperCamelCase				  =					(TFBlipTextModel,) if is_tf_available() else ()
		_UpperCamelCase				  =					False
		_UpperCamelCase				  =					False
		_UpperCamelCase				  =					False






		def 			UpperCamelCase_					(      self       ):
								lowerCamelCase__         =  BlipTextModelTester(self       )
								lowerCamelCase__         =  ConfigTester(self   ,config_class=_lowerCAmelCase   ,hidden_size=37       )






		def 			UpperCamelCase_					(      self       ):
								self.config_tester.run_common_tests()






		def 			UpperCamelCase_					(      self       ):
								lowerCamelCase__         =  self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_model(*_lowerCAmelCase       )






		def 			UpperCamelCase_					(      self       ):
								pass






		def 			UpperCamelCase_					(      self       ):
								pass






		@unittest.skip(reason="""Blip does not use inputs_embeds"""       )
		def 			UpperCamelCase_					(      self       ):
								pass






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






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






		@slow
		def 			UpperCamelCase_					(      self       ):
								for model_name in TF_BLIP_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
														lowerCamelCase__         =  TFBlipTextModel.from_pretrained(_lowerCAmelCase       )
														self.assertIsNotNone(_lowerCAmelCase       )






		def 			UpperCamelCase_					(      self   ,_lowerCAmelCase=True       ):
								super().test_pt_tf_model_equivalence(allow_missing_keys=_lowerCAmelCase       )









'''simple docstring'''







UpperCamelCase    :      Tuple  			=		[sum(int(c, 10) ** 2 for c in i.__str__()) for i in range(10_00_00)]
def 						A__			(				__lowerCAmelCase		:			int						):
						lowerCamelCase__         =  0
						while number:
												# Increased Speed Slightly by checking every 5 digits together.
												sum_of_digits_squared += DIGITS_SQUARED[number % 10_0000]
												number //= 10_0000

						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
UpperCamelCase    :      list[bool | None]  			=		[None] * 10_00_00_00
UpperCamelCase    :      Tuple  			=		True
UpperCamelCase    :      Optional[int]  			=		False
def 						A__			(				__lowerCAmelCase		:			int						):

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

						lowerCamelCase__         =  chain(next_number(__lowerCAmelCase						)						)
						lowerCamelCase__         =  number_chain

						while number < 1000_0000:
												lowerCamelCase__         =  number_chain
												number *= 10

						return number_chain
def 						A__			(				__lowerCAmelCase		:			int = 1000_0000						):
						for i in range(1   ,    __lowerCAmelCase						):
												if CHAINS[i] is None:
																		chain(i + 1						)

						return CHAINS[:number].count(__lowerCAmelCase						)


if __name__ == "__main__":
							import doctest

							doctest.testmod()
							print(F'{solution() = }')

