



'''simple docstring'''



from __future__ import annotations

import os
import tempfile
import unittest

from transformers import ConvBertConfig, is_tf_available
from transformers.testing_utils import require_tf, slow

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
	import tensorflow as tf

	from transformers import (
	    TFConvBertForMaskedLM,
	    TFConvBertForMultipleChoice,
	    TFConvBertForQuestionAnswering,
	    TFConvBertForSequenceClassification,
	    TFConvBertForTokenClassification,
	    TFConvBertModel,
	)






class 					UpperCAmelCase__	:



					def __init__(    self			,				UpperCamelCase			,				UpperCamelCase=13			,				UpperCamelCase=7			,				UpperCamelCase=True			,				UpperCamelCase=True			,				UpperCamelCase=True			,				UpperCamelCase=True			,				UpperCamelCase=99			,				UpperCamelCase=32			,				UpperCamelCase=2			,				UpperCamelCase=4			,				UpperCamelCase=37			,				UpperCamelCase="gelu"			,				UpperCamelCase=0.1			,				UpperCamelCase=0.1			,				UpperCamelCase=512			,				UpperCamelCase=16			,				UpperCamelCase=2			,				UpperCamelCase=0.02			,				UpperCamelCase=3			,				UpperCamelCase=4			,				UpperCamelCase=None			,				)     ->			List[str]:
						__lowerCAmelCase												=  parent
						__lowerCAmelCase												=  13
						__lowerCAmelCase												=  7
						__lowerCAmelCase												=  True
						__lowerCAmelCase												=  True
						__lowerCAmelCase												=  True
						__lowerCAmelCase												=  True
						__lowerCAmelCase												=  99
						__lowerCAmelCase												=  384
						__lowerCAmelCase												=  2
						__lowerCAmelCase												=  4
						__lowerCAmelCase												=  37
						__lowerCAmelCase												=  "gelu"
						__lowerCAmelCase												=  0.1
						__lowerCAmelCase												=  0.1
						__lowerCAmelCase												=  512
						__lowerCAmelCase												=  16
						__lowerCAmelCase												=  2
						__lowerCAmelCase												=  0.02
						__lowerCAmelCase												=  3
						__lowerCAmelCase												=  4
						__lowerCAmelCase												=  128
						__lowerCAmelCase												=  2
						__lowerCAmelCase												=  9
						__lowerCAmelCase												=  1
						__lowerCAmelCase												=  None



					def        UpperCAmelCase_ (    self     )     ->			Optional[Any]:
						__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]     )

						__lowerCAmelCase												=  None
						if self.use_token_type_ids:
							__lowerCAmelCase												=  ids_tensor([self.batch_size, self.seq_length]			,				self.type_vocab_size     )

						__lowerCAmelCase												=  None
						__lowerCAmelCase												=  None
						__lowerCAmelCase												=  None
						if self.use_labels:
							__lowerCAmelCase												=  ids_tensor([self.batch_size]			,				self.type_sequence_label_size     )
							__lowerCAmelCase												=  ids_tensor([self.batch_size, self.seq_length]			,				self.num_labels     )
							__lowerCAmelCase												=  ids_tensor([self.batch_size]			,				self.num_choices     )

						__lowerCAmelCase												=  ConvBertConfig(
						    vocab_size=self.vocab_size			,				hidden_size=self.hidden_size			,				num_hidden_layers=self.num_hidden_layers			,				num_attention_heads=self.num_attention_heads			,				intermediate_size=self.intermediate_size			,				hidden_act=self.hidden_act			,				hidden_dropout_prob=self.hidden_dropout_prob			,				attention_probs_dropout_prob=self.attention_probs_dropout_prob			,				max_position_embeddings=self.max_position_embeddings			,				type_vocab_size=self.type_vocab_size			,				initializer_range=self.initializer_range			,				return_dict=UpperCamelCase			,				)

						return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels



					def        UpperCAmelCase_ (    self			,				UpperCamelCase			,				UpperCamelCase			,				UpperCamelCase			,				UpperCamelCase			,				UpperCamelCase			,				UpperCamelCase			,				UpperCamelCase     )     ->			Union[str, Any]:
						__lowerCAmelCase												=  TFConvBertModel(config=UpperCamelCase     )
						__lowerCAmelCase												=  {"input_ids": input_ids, "attention_mask": input_mask, "token_type_ids": token_type_ids}

						__lowerCAmelCase												=  [input_ids, input_mask]
						__lowerCAmelCase												=  model(UpperCamelCase     )

						__lowerCAmelCase												=  model(UpperCamelCase     )

						self.parent.assertEqual(result.last_hidden_state.shape			,				(self.batch_size, self.seq_length, self.hidden_size)     )



					def        UpperCAmelCase_ (    self			,				UpperCamelCase			,				UpperCamelCase			,				UpperCamelCase			,				UpperCamelCase			,				UpperCamelCase			,				UpperCamelCase			,				UpperCamelCase     )     ->			Tuple:
						__lowerCAmelCase												=  TFConvBertForMaskedLM(config=UpperCamelCase     )
						__lowerCAmelCase												=  {
						    "input_ids": input_ids,
						    "attention_mask": input_mask,
						    "token_type_ids": token_type_ids,
						}
						__lowerCAmelCase												=  model(UpperCamelCase     )
						self.parent.assertEqual(result.logits.shape			,				(self.batch_size, self.seq_length, self.vocab_size)     )



					def        UpperCAmelCase_ (    self			,				UpperCamelCase			,				UpperCamelCase			,				UpperCamelCase			,				UpperCamelCase			,				UpperCamelCase			,				UpperCamelCase			,				UpperCamelCase     )     ->			Dict:
						__lowerCAmelCase												=  self.num_labels
						__lowerCAmelCase												=  TFConvBertForSequenceClassification(config=UpperCamelCase     )
						__lowerCAmelCase												=  {
						    "input_ids": input_ids,
						    "attention_mask": input_mask,
						    "token_type_ids": token_type_ids,
						}

						__lowerCAmelCase												=  model(UpperCamelCase     )
						self.parent.assertEqual(result.logits.shape			,				(self.batch_size, self.num_labels)     )



					def        UpperCAmelCase_ (    self			,				UpperCamelCase			,				UpperCamelCase			,				UpperCamelCase			,				UpperCamelCase			,				UpperCamelCase			,				UpperCamelCase			,				UpperCamelCase     )     ->			Union[str, Any]:
						__lowerCAmelCase												=  self.num_choices
						__lowerCAmelCase												=  TFConvBertForMultipleChoice(config=UpperCamelCase     )
						__lowerCAmelCase												=  tf.tile(tf.expand_dims(UpperCamelCase			,				1     )			,				(1, self.num_choices, 1)     )
						__lowerCAmelCase												=  tf.tile(tf.expand_dims(UpperCamelCase			,				1     )			,				(1, self.num_choices, 1)     )
						__lowerCAmelCase												=  tf.tile(tf.expand_dims(UpperCamelCase			,				1     )			,				(1, self.num_choices, 1)     )
						__lowerCAmelCase												=  {
						    "input_ids": multiple_choice_inputs_ids,
						    "attention_mask": multiple_choice_input_mask,
						    "token_type_ids": multiple_choice_token_type_ids,
						}
						__lowerCAmelCase												=  model(UpperCamelCase     )
						self.parent.assertEqual(result.logits.shape			,				(self.batch_size, self.num_choices)     )



					def        UpperCAmelCase_ (    self			,				UpperCamelCase			,				UpperCamelCase			,				UpperCamelCase			,				UpperCamelCase			,				UpperCamelCase			,				UpperCamelCase			,				UpperCamelCase     )     ->			Tuple:
						__lowerCAmelCase												=  self.num_labels
						__lowerCAmelCase												=  TFConvBertForTokenClassification(config=UpperCamelCase     )
						__lowerCAmelCase												=  {
						    "input_ids": input_ids,
						    "attention_mask": input_mask,
						    "token_type_ids": token_type_ids,
						}
						__lowerCAmelCase												=  model(UpperCamelCase     )
						self.parent.assertEqual(result.logits.shape			,				(self.batch_size, self.seq_length, self.num_labels)     )



					def        UpperCAmelCase_ (    self			,				UpperCamelCase			,				UpperCamelCase			,				UpperCamelCase			,				UpperCamelCase			,				UpperCamelCase			,				UpperCamelCase			,				UpperCamelCase     )     ->			Tuple:
						__lowerCAmelCase												=  TFConvBertForQuestionAnswering(config=UpperCamelCase     )
						__lowerCAmelCase												=  {
						    "input_ids": input_ids,
						    "attention_mask": input_mask,
						    "token_type_ids": token_type_ids,
						}

						__lowerCAmelCase												=  model(UpperCamelCase     )
						self.parent.assertEqual(result.start_logits.shape			,				(self.batch_size, self.seq_length)     )
						self.parent.assertEqual(result.end_logits.shape			,				(self.batch_size, self.seq_length)     )



					def        UpperCAmelCase_ (    self     )     ->			List[str]:
						__lowerCAmelCase												=  self.prepare_config_and_inputs()
						(
						    (
						    __lowerCAmelCase
						)							,       (
						    __lowerCAmelCase
						)							,       (
						    __lowerCAmelCase
						)							,       (
						    __lowerCAmelCase
						)							,       (
						    __lowerCAmelCase
						)							,       (
						    __lowerCAmelCase
						)							,       (
						    __lowerCAmelCase
						)							,       
						)												=  config_and_inputs
						__lowerCAmelCase												=  {"input_ids": input_ids, "token_type_ids": token_type_ids, "attention_mask": input_mask}
						return config, inputs_dict






@require_tf
class 					UpperCAmelCase__	(		UpperCamelCase__							,       UpperCamelCase__							,       unittest.TestCase ):
					a      :     Dict        =							(
					    (
					        TFConvBertModel,
					        TFConvBertForMaskedLM,
					        TFConvBertForQuestionAnswering,
					        TFConvBertForSequenceClassification,
					        TFConvBertForTokenClassification,
					        TFConvBertForMultipleChoice,
					    )
					    if is_tf_available()
					    else ()
					)
					a      :     str        =							(
					    {
					        """feature-extraction""": TFConvBertModel,
					        """fill-mask""": TFConvBertForMaskedLM,
					        """question-answering""": TFConvBertForQuestionAnswering,
					        """text-classification""": TFConvBertForSequenceClassification,
					        """token-classification""": TFConvBertForTokenClassification,
					        """zero-shot""": TFConvBertForSequenceClassification,
					    }
					    if is_tf_available()
					    else {}
					)
					a      :     List[str]        =							False
					a      :     Optional[int]        =							False
					a      :     Optional[int]        =							False



					def        UpperCAmelCase_ (    self     )     ->			Optional[int]:
						__lowerCAmelCase												=  TFConvBertModelTester(self     )
						__lowerCAmelCase												=  ConfigTester(self			,				config_class=UpperCamelCase			,				hidden_size=37     )



					def        UpperCAmelCase_ (    self     )     ->			List[Any]:
						self.config_tester.run_common_tests()



					def        UpperCAmelCase_ (    self     )     ->			Optional[int]:
						__lowerCAmelCase												=  self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_model(*UpperCamelCase     )



					def        UpperCAmelCase_ (    self     )     ->			Optional[int]:
						__lowerCAmelCase												=  self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_masked_lm(*UpperCamelCase     )



					def        UpperCAmelCase_ (    self     )     ->			Union[str, Any]:
						__lowerCAmelCase												=  self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_multiple_choice(*UpperCamelCase     )



					def        UpperCAmelCase_ (    self     )     ->			Optional[Any]:
						__lowerCAmelCase												=  self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_question_answering(*UpperCamelCase     )



					def        UpperCAmelCase_ (    self     )     ->			str:
						__lowerCAmelCase												=  self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_sequence_classification(*UpperCamelCase     )



					def        UpperCAmelCase_ (    self     )     ->			Dict:
						__lowerCAmelCase												=  self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_token_classification(*UpperCamelCase     )



					@slow
					def        UpperCAmelCase_ (    self     )     ->			str:
						__lowerCAmelCase							,       __lowerCAmelCase												=  self.model_tester.prepare_config_and_inputs_for_common()
						__lowerCAmelCase												=  True
						__lowerCAmelCase												=  True

						if hasattr(UpperCamelCase			,				"use_cache"     ):
							__lowerCAmelCase												=  True

						__lowerCAmelCase												=  getattr(self.model_tester			,				"encoder_seq_length"			,				self.model_tester.seq_length     )
						__lowerCAmelCase												=  getattr(self.model_tester			,				"key_length"			,				UpperCamelCase     )

						for model_class in self.all_model_classes:
							__lowerCAmelCase												=  self._prepare_for_class(UpperCamelCase			,				UpperCamelCase     )
							__lowerCAmelCase												=  model_class(UpperCamelCase     )
							__lowerCAmelCase												=  len(model(UpperCamelCase     )     )

							with tempfile.TemporaryDirectory() as tmpdirname:
								model.save_pretrained(UpperCamelCase			,				saved_model=UpperCamelCase     )
								__lowerCAmelCase												=  os.path.join(UpperCamelCase			,				"saved_model"			,				"1"     )
								__lowerCAmelCase												=  tf.keras.models.load_model(UpperCamelCase     )
								__lowerCAmelCase												=  model(UpperCamelCase     )

								if self.is_encoder_decoder:
									__lowerCAmelCase												=  outputs["encoder_hidden_states"]
									__lowerCAmelCase												=  outputs["encoder_attentions"]
								else:
									__lowerCAmelCase												=  outputs["hidden_states"]
									__lowerCAmelCase												=  outputs["attentions"]

								self.assertEqual(len(UpperCamelCase     )			,				UpperCamelCase     )

								__lowerCAmelCase												=  getattr(
								    self.model_tester			,				"expected_num_hidden_layers"			,				self.model_tester.num_hidden_layers + 1     )

								self.assertEqual(len(UpperCamelCase     )			,				UpperCamelCase     )
								self.assertListEqual(
								    list(output_hidden_states[0].shape[-2:]     )			,				[self.model_tester.seq_length, self.model_tester.hidden_size]			,				)

								self.assertEqual(len(UpperCamelCase     )			,				self.model_tester.num_hidden_layers     )
								self.assertListEqual(
								    list(output_attentions[0].shape[-3:]     )			,				[self.model_tester.num_attention_heads / 2, encoder_seq_length, encoder_key_length]			,				)



					@slow
					def        UpperCAmelCase_ (    self     )     ->			str:
						__lowerCAmelCase												=  TFConvBertModel.from_pretrained("YituTech/conv-bert-base"     )
						self.assertIsNotNone(UpperCamelCase     )



					def        UpperCAmelCase_ (    self     )     ->			str:
						__lowerCAmelCase							,       __lowerCAmelCase												=  self.model_tester.prepare_config_and_inputs_for_common()
						__lowerCAmelCase												=  True
						__lowerCAmelCase												=  getattr(self.model_tester			,				"decoder_seq_length"			,				self.model_tester.seq_length     )
						__lowerCAmelCase												=  getattr(self.model_tester			,				"encoder_seq_length"			,				self.model_tester.seq_length     )
						__lowerCAmelCase												=  getattr(self.model_tester			,				"key_length"			,				UpperCamelCase     )
						__lowerCAmelCase												=  getattr(self.model_tester			,				"key_length"			,				UpperCamelCase     )

						def check_decoder_attentions_output(UpperCamelCase     ):
							__lowerCAmelCase												=  len(UpperCamelCase     )
							self.assertEqual(out_len % 2			,				0     )
							__lowerCAmelCase												=  outputs.decoder_attentions
							self.assertEqual(len(UpperCamelCase     )			,				self.model_tester.num_hidden_layers     )
							self.assertListEqual(
							    list(decoder_attentions[0].shape[-3:]     )			,				[self.model_tester.num_attention_heads / 2, decoder_seq_length, decoder_key_length]			,				)

						def check_encoder_attentions_output(UpperCamelCase     ):
							__lowerCAmelCase												=  [
							    t.numpy() for t in (outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions)
							]
							self.assertEqual(len(UpperCamelCase     )			,				self.model_tester.num_hidden_layers     )
							self.assertListEqual(
							    list(attentions[0].shape[-3:]     )			,				[self.model_tester.num_attention_heads / 2, encoder_seq_length, encoder_key_length]			,				)

						for model_class in self.all_model_classes:
							__lowerCAmelCase												=  True
							__lowerCAmelCase												=  False
							__lowerCAmelCase												=  model_class(UpperCamelCase     )
							__lowerCAmelCase												=  model(self._prepare_for_class(UpperCamelCase			,				UpperCamelCase     )     )
							__lowerCAmelCase												=  len(UpperCamelCase     )
							self.assertEqual(config.output_hidden_states			,				UpperCamelCase     )
							check_encoder_attentions_output(UpperCamelCase     )

							if self.is_encoder_decoder:
								__lowerCAmelCase												=  model_class(UpperCamelCase     )
								__lowerCAmelCase												=  model(self._prepare_for_class(UpperCamelCase			,				UpperCamelCase     )     )
								self.assertEqual(config.output_hidden_states			,				UpperCamelCase     )
								check_decoder_attentions_output(UpperCamelCase     )

							# Check that output attentions can also be changed via the config
							del inputs_dict["output_attentions"]
							__lowerCAmelCase												=  True
							__lowerCAmelCase												=  model_class(UpperCamelCase     )
							__lowerCAmelCase												=  model(self._prepare_for_class(UpperCamelCase			,				UpperCamelCase     )     )
							self.assertEqual(config.output_hidden_states			,				UpperCamelCase     )
							check_encoder_attentions_output(UpperCamelCase     )

							# Check attention is always last and order is fine
							__lowerCAmelCase												=  True
							__lowerCAmelCase												=  True
							__lowerCAmelCase												=  model_class(UpperCamelCase     )
							__lowerCAmelCase												=  model(self._prepare_for_class(UpperCamelCase			,				UpperCamelCase     )     )

							self.assertEqual(out_len + (2 if self.is_encoder_decoder else 1)			,				len(UpperCamelCase     )     )
							self.assertEqual(model.config.output_hidden_states			,				UpperCamelCase     )
							check_encoder_attentions_output(UpperCamelCase     )






@require_tf
class 					UpperCAmelCase__	(		unittest.TestCase ):



					@slow
					def        UpperCAmelCase_ (    self     )     ->			int:
						__lowerCAmelCase												=  TFConvBertModel.from_pretrained("YituTech/conv-bert-base"     )
						__lowerCAmelCase												=  tf.constant([[0, 1, 2, 3, 4, 5]]     )
						__lowerCAmelCase												=  model(UpperCamelCase     )[0]

						__lowerCAmelCase												=  [1, 6, 768]
						self.assertEqual(output.shape			,				UpperCamelCase     )

						__lowerCAmelCase												=  tf.constant(
						    [
						        [
						            [-0.03_47_54_93, -0.4_68_60_34, -0.30_63_88_32],
						            [0.22_63_72_48, -0.26_98_86_46, -0.7_42_34_24],
						            [0.10_32_48_68, -0.45_01_35_08, -0.58_28_07_84],
						        ]
						    ]     )
						tf.debugging.assert_near(output[:, :3, :3]			,				UpperCamelCase			,				atol=1E-4     )




'''simple docstring'''



def   __lowerCAmelCase					(							lowerCamelCase   :						Union[str, Any]					):






	'''simple docstring'''




	__lowerCAmelCase												=  1
	__lowerCAmelCase												=  2
	while i * i <= n:
		__lowerCAmelCase												=  0
		while n % i == 0:
			n //= i
			multiplicity += 1
		n_divisors *= multiplicity + 1
		i += 1
	if n > 1:
		n_divisors *= 2
	return n_divisors



def   __lowerCAmelCase					(							):






	'''simple docstring'''




	__lowerCAmelCase												=  1
	__lowerCAmelCase												=  1

	while True:
		i += 1
		t_num += i

		if count_divisors(lowerCamelCase					) > 5_00:
			break

	return t_num


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