


'''simple docstring'''



from __future__ import annotations

import unittest

from transformers import RoFormerConfig, 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 (
		    TFRoFormerForCausalLM,
		    TFRoFormerForMaskedLM,
		    TFRoFormerForMultipleChoice,
		    TFRoFormerForQuestionAnswering,
		    TFRoFormerForSequenceClassification,
		    TFRoFormerForTokenClassification,
		    TFRoFormerModel,
		)
		from transformers.models.roformer.modeling_tf_roformer import (
		    TFRoFormerSelfAttention,
		    TFRoFormerSinusoidalPositionalEmbedding,
		)


class 		_snake_case					:




					def __init__(      self							,							_lowerCamelCase							,							_lowerCamelCase=13							,							_lowerCamelCase=7							,							_lowerCamelCase=True							,							_lowerCamelCase=True							,							_lowerCamelCase=True							,							_lowerCamelCase=True							,							_lowerCamelCase=99							,							_lowerCamelCase=32							,							_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=None							,							):
								UpperCAmelCase__  :					Any        =     parent
								UpperCAmelCase__  :					int        =     13
								UpperCAmelCase__  :					Union[str, Any]        =     7
								UpperCAmelCase__  :					int        =     True
								UpperCAmelCase__  :					int        =     True
								UpperCAmelCase__  :					Union[str, Any]        =     True
								UpperCAmelCase__  :					Any        =     True
								UpperCAmelCase__  :					Optional[Any]        =     99
								UpperCAmelCase__  :					List[str]        =     32
								UpperCAmelCase__  :					List[Any]        =     2
								UpperCAmelCase__  :					Any        =     4
								UpperCAmelCase__  :					List[Any]        =     37
								UpperCAmelCase__  :					List[Any]        =     """gelu"""
								UpperCAmelCase__  :					Tuple        =     0.1
								UpperCAmelCase__  :					Tuple        =     0.1
								UpperCAmelCase__  :					int        =     512
								UpperCAmelCase__  :					int        =     16
								UpperCAmelCase__  :					List[Any]        =     2
								UpperCAmelCase__  :					Dict        =     0.02
								UpperCAmelCase__  :					int        =     3
								UpperCAmelCase__  :					Optional[int]        =     4
								UpperCAmelCase__  :					List[str]        =     None




					def 				snake_case__						(      self):
								UpperCAmelCase__  :					int        =     ids_tensor([self.batch_size, self.seq_length]							,							self.vocab_size)

								UpperCAmelCase__  :					Any        =     None
								if self.use_input_mask:
											UpperCAmelCase__  :					Union[str, Any]        =     random_attention_mask([self.batch_size, self.seq_length])

								UpperCAmelCase__  :					List[str]        =     None
								if self.use_token_type_ids:
											UpperCAmelCase__  :					Optional[Any]        =     ids_tensor([self.batch_size, self.seq_length]							,							self.type_vocab_size)

								UpperCAmelCase__  :					Any        =     None
								UpperCAmelCase__  :					Tuple        =     None
								UpperCAmelCase__  :					str        =     None
								if self.use_labels:
											UpperCAmelCase__  :					Dict        =     ids_tensor([self.batch_size]							,							self.type_sequence_label_size)
											UpperCAmelCase__  :					Dict        =     ids_tensor([self.batch_size, self.seq_length]							,							self.num_labels)
											UpperCAmelCase__  :					Union[str, Any]        =     ids_tensor([self.batch_size]							,							self.num_choices)

								UpperCAmelCase__  :					Optional[Any]        =     RoFormerConfig(
								    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=_lowerCamelCase							,							)

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




					def 				snake_case__						(      self							,							_lowerCamelCase							,							_lowerCamelCase							,							_lowerCamelCase							,							_lowerCamelCase							,							_lowerCamelCase							,							_lowerCamelCase							,							_lowerCamelCase):
								UpperCAmelCase__  :					Union[str, Any]        =     TFRoFormerModel(config=_lowerCamelCase)
								UpperCAmelCase__  :					Optional[int]        =     {"""input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids}

								UpperCAmelCase__  :					List[Any]        =     [input_ids, input_mask]
								UpperCAmelCase__  :					Tuple        =     model(_lowerCamelCase)

								UpperCAmelCase__  :					Dict        =     model(_lowerCamelCase)

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




					def 				snake_case__						(      self							,							_lowerCamelCase							,							_lowerCamelCase							,							_lowerCamelCase							,							_lowerCamelCase							,							_lowerCamelCase							,							_lowerCamelCase							,							_lowerCamelCase):
								UpperCAmelCase__  :					Any        =     True
								UpperCAmelCase__  :					Optional[int]        =     TFRoFormerForCausalLM(config=_lowerCamelCase)
								UpperCAmelCase__  :					str        =     {
								    """input_ids""": input_ids,
								    """attention_mask""": input_mask,
								    """token_type_ids""": token_type_ids,
								}
								UpperCAmelCase__  :					Union[str, Any]        =     model(_lowerCamelCase)["""logits"""]
								self.parent.assertListEqual(
								    list(prediction_scores.numpy().shape)							,							[self.batch_size, self.seq_length, self.vocab_size])




					def 				snake_case__						(      self							,							_lowerCamelCase							,							_lowerCamelCase							,							_lowerCamelCase							,							_lowerCamelCase							,							_lowerCamelCase							,							_lowerCamelCase							,							_lowerCamelCase):
								UpperCAmelCase__  :					Optional[int]        =     TFRoFormerForMaskedLM(config=_lowerCamelCase)
								UpperCAmelCase__  :					Optional[int]        =     {
								    """input_ids""": input_ids,
								    """attention_mask""": input_mask,
								    """token_type_ids""": token_type_ids,
								}
								UpperCAmelCase__  :					int        =     model(_lowerCamelCase)
								self.parent.assertEqual(result.logits.shape							,							(self.batch_size, self.seq_length, self.vocab_size))




					def 				snake_case__						(      self							,							_lowerCamelCase							,							_lowerCamelCase							,							_lowerCamelCase							,							_lowerCamelCase							,							_lowerCamelCase							,							_lowerCamelCase							,							_lowerCamelCase):
								UpperCAmelCase__  :					Dict        =     self.num_labels
								UpperCAmelCase__  :					Tuple        =     TFRoFormerForSequenceClassification(config=_lowerCamelCase)
								UpperCAmelCase__  :					int        =     {
								    """input_ids""": input_ids,
								    """attention_mask""": input_mask,
								    """token_type_ids""": token_type_ids,
								}

								UpperCAmelCase__  :					Any        =     model(_lowerCamelCase)
								self.parent.assertEqual(result.logits.shape							,							(self.batch_size, self.num_labels))




					def 				snake_case__						(      self							,							_lowerCamelCase							,							_lowerCamelCase							,							_lowerCamelCase							,							_lowerCamelCase							,							_lowerCamelCase							,							_lowerCamelCase							,							_lowerCamelCase):
								UpperCAmelCase__  :					int        =     self.num_choices
								UpperCAmelCase__  :					int        =     TFRoFormerForMultipleChoice(config=_lowerCamelCase)
								UpperCAmelCase__  :					Any        =     tf.tile(tf.expand_dims(_lowerCamelCase							,							1)							,							(1, self.num_choices, 1))
								UpperCAmelCase__  :					Optional[int]        =     tf.tile(tf.expand_dims(_lowerCamelCase							,							1)							,							(1, self.num_choices, 1))
								UpperCAmelCase__  :					Dict        =     tf.tile(tf.expand_dims(_lowerCamelCase							,							1)							,							(1, self.num_choices, 1))
								UpperCAmelCase__  :					Optional[Any]        =     {
								    """input_ids""": multiple_choice_inputs_ids,
								    """attention_mask""": multiple_choice_input_mask,
								    """token_type_ids""": multiple_choice_token_type_ids,
								}
								UpperCAmelCase__  :					Optional[Any]        =     model(_lowerCamelCase)
								self.parent.assertEqual(result.logits.shape							,							(self.batch_size, self.num_choices))




					def 				snake_case__						(      self							,							_lowerCamelCase							,							_lowerCamelCase							,							_lowerCamelCase							,							_lowerCamelCase							,							_lowerCamelCase							,							_lowerCamelCase							,							_lowerCamelCase):
								UpperCAmelCase__  :					Any        =     self.num_labels
								UpperCAmelCase__  :					List[Any]        =     TFRoFormerForTokenClassification(config=_lowerCamelCase)
								UpperCAmelCase__  :					Optional[Any]        =     {
								    """input_ids""": input_ids,
								    """attention_mask""": input_mask,
								    """token_type_ids""": token_type_ids,
								}
								UpperCAmelCase__  :					List[Any]        =     model(_lowerCamelCase)
								self.parent.assertEqual(result.logits.shape							,							(self.batch_size, self.seq_length, self.num_labels))




					def 				snake_case__						(      self							,							_lowerCamelCase							,							_lowerCamelCase							,							_lowerCamelCase							,							_lowerCamelCase							,							_lowerCamelCase							,							_lowerCamelCase							,							_lowerCamelCase):
								UpperCAmelCase__  :					int        =     TFRoFormerForQuestionAnswering(config=_lowerCamelCase)
								UpperCAmelCase__  :					List[str]        =     {
								    """input_ids""": input_ids,
								    """attention_mask""": input_mask,
								    """token_type_ids""": token_type_ids,
								}

								UpperCAmelCase__  :					str        =     model(_lowerCamelCase)
								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 				snake_case__						(      self):
								UpperCAmelCase__  :					Any        =     self.prepare_config_and_inputs()
								(
								    (
								    UpperCAmelCase__
								)   ,       (
								    UpperCAmelCase__
								)   ,       (
								    UpperCAmelCase__
								)   ,       (
								    UpperCAmelCase__
								)   ,       (
								    UpperCAmelCase__
								)   ,       (
								    UpperCAmelCase__
								)   ,       (
								    UpperCAmelCase__
								)   ,       
								)  :					List[Any]        =     config_and_inputs
								UpperCAmelCase__  :					Tuple        =     {"""input_ids""": input_ids, """token_type_ids""": token_type_ids, """attention_mask""": input_mask}
								return config, inputs_dict


@require_tf
class 		_snake_case					(     a__       ,   a__       ,   unittest.TestCase	):
					lowerCAmelCase      :str   =					(
					    (
					        TFRoFormerModel,
					        TFRoFormerForCausalLM,
					        TFRoFormerForMaskedLM,
					        TFRoFormerForQuestionAnswering,
					        TFRoFormerForSequenceClassification,
					        TFRoFormerForTokenClassification,
					        TFRoFormerForMultipleChoice,
					    )
					    if is_tf_available()
					    else ()
					)
					lowerCAmelCase      :List[Any]   =					(
					    {
					        '''feature-extraction''': TFRoFormerModel,
					        '''fill-mask''': TFRoFormerForMaskedLM,
					        '''question-answering''': TFRoFormerForQuestionAnswering,
					        '''text-classification''': TFRoFormerForSequenceClassification,
					        '''text-generation''': TFRoFormerForCausalLM,
					        '''token-classification''': TFRoFormerForTokenClassification,
					        '''zero-shot''': TFRoFormerForSequenceClassification,
					    }
					    if is_tf_available()
					    else {}
					)

					lowerCAmelCase      :Any   =					False
					lowerCAmelCase      :Union[str, Any]   =					False




					def 				snake_case__						(      self							,							_lowerCamelCase							,							_lowerCamelCase							,							_lowerCamelCase							,							_lowerCamelCase							,							_lowerCamelCase):
								if pipeline_test_casse_name == "TextGenerationPipelineTests":
											return True

								return False




					def 				snake_case__						(      self):
								UpperCAmelCase__  :					Tuple        =     TFRoFormerModelTester(self)
								UpperCAmelCase__  :					List[Any]        =     ConfigTester(self							,							config_class=_lowerCamelCase							,							hidden_size=37)




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




					def 				snake_case__						(      self):
								UpperCAmelCase__  :					Optional[Any]        =     self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_model(*_lowerCamelCase)




					def 				snake_case__						(      self):
								UpperCAmelCase__  :					Any        =     self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_masked_lm(*_lowerCamelCase)




					def 				snake_case__						(      self):
								UpperCAmelCase__  :					Optional[Any]        =     self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_lm_head(*_lowerCamelCase)




					def 				snake_case__						(      self):
								UpperCAmelCase__  :					List[str]        =     self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_multiple_choice(*_lowerCamelCase)




					def 				snake_case__						(      self):
								UpperCAmelCase__  :					Union[str, Any]        =     self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_question_answering(*_lowerCamelCase)




					def 				snake_case__						(      self):
								UpperCAmelCase__  :					Optional[int]        =     self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_sequence_classification(*_lowerCamelCase)




					def 				snake_case__						(      self):
								UpperCAmelCase__  :					Any        =     self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_token_classification(*_lowerCamelCase)




					@slow
					def 				snake_case__						(      self):
								UpperCAmelCase__  :					Any        =     TFRoFormerModel.from_pretrained("""junnyu/roformer_chinese_base""")
								self.assertIsNotNone(_lowerCamelCase)


@require_tf
class 		_snake_case					(     unittest.TestCase	):




					@slow
					def 				snake_case__						(      self):
								UpperCAmelCase__  :					int        =     TFRoFormerForMaskedLM.from_pretrained("""junnyu/roformer_chinese_base""")
								UpperCAmelCase__  :					int        =     tf.constant([[0, 1, 2, 3, 4, 5]])
								UpperCAmelCase__  :					str        =     model(_lowerCamelCase)[0]

								# TODO Replace vocab size
								UpperCAmelCase__  :					Optional[Any]        =     5_0000

								UpperCAmelCase__  :					List[str]        =     [1, 6, vocab_size]
								self.assertEqual(output.shape							,							_lowerCamelCase)

								print(output[:, :3, :3])

								# TODO Replace values below with what was printed above.
								UpperCAmelCase__  :					Union[str, Any]        =     tf.constant(
								    [
								        [
								            [-0.12053341, -1.0264901, 0.29221946],
								            [-1.5133783, 0.197433, 0.15190607],
								            [-5.0135403, -3.900256, -0.84038764],
								        ]
								    ])
								tf.debugging.assert_near(output[:, :3, :3]							,							_lowerCamelCase							,							atol=1e-4)


@require_tf
class 		_snake_case					(     unittest.TestCase	):
					lowerCAmelCase      :Dict   =					1e-4




					def 				snake_case__						(      self):
								UpperCAmelCase__  :					int        =     tf.constant([[4, 10]])
								UpperCAmelCase__  :					Any        =     TFRoFormerSinusoidalPositionalEmbedding(num_positions=6							,							embedding_dim=6)

								UpperCAmelCase__  :					List[str]        =     emba(input_ids.shape)
								UpperCAmelCase__  :					Optional[int]        =     tf.constant(
								    [[0.0000, 0.0000, 0.0000, 1.0000, 1.0000, 1.0000], [0.8415, 0.0464, 0.0022, 0.5403, 0.9989, 1.0000]])

								tf.debugging.assert_near(_lowerCamelCase							,							_lowerCamelCase							,							atol=self.tolerance)




					def 				snake_case__						(      self):
								UpperCAmelCase__  :					Optional[int]        =     tf.constant(
								    [
								        [0.0000, 0.0000, 0.0000, 0.0000, 0.0000],
								        [0.8415, 0.8219, 0.8020, 0.7819, 0.7617],
								        [0.9093, 0.9364, 0.9581, 0.9749, 0.9870],
								    ])
								UpperCAmelCase__  :					List[Any]        =     TFRoFormerSinusoidalPositionalEmbedding(num_positions=512							,							embedding_dim=512)
								emba([2, 16, 512])
								UpperCAmelCase__  :					str        =     emba.weight[:3, :5]

								tf.debugging.assert_near(_lowerCamelCase							,							_lowerCamelCase							,							atol=self.tolerance)


@require_tf
class 		_snake_case					(     unittest.TestCase	):
					lowerCAmelCase      :Union[str, Any]   =					1e-4




					def 				snake_case__						(      self):
								# 2,12,16,64
								UpperCAmelCase__  :					Any        =     tf.reshape(tf.range(2 * 12 * 16 * 64							,							dtype=tf.floataa)							,							shape=(2, 12, 16, 64)) / 100

								UpperCAmelCase__  :					List[Any]        =     -tf.reshape(tf.range(2 * 12 * 16 * 64							,							dtype=tf.floataa)							,							shape=(2, 12, 16, 64)) / 100

								UpperCAmelCase__  :					List[Any]        =     TFRoFormerSinusoidalPositionalEmbedding(num_positions=32							,							embedding_dim=64)
								UpperCAmelCase__  :					str        =     embed_positions([2, 16, 768])[None, None, :, :]

								UpperCAmelCase__   ,       UpperCAmelCase__  :					Tuple        =     TFRoFormerSelfAttention.apply_rotary_position_embeddings(
								    _lowerCamelCase							,							_lowerCamelCase							,							_lowerCamelCase)

								UpperCAmelCase__  :					List[Any]        =     tf.constant(
								    [
								        [0.0000, 0.0100, 0.0200, 0.0300, 0.0400, 0.0500, 0.0600, 0.0700],
								        [-0.2012, 0.8897, 0.0263, 0.9401, 0.2074, 0.9463, 0.3481, 0.9343],
								        [-1.7057, 0.6271, -1.2145, 1.3897, -0.6303, 1.7647, -0.1173, 1.8985],
								        [-2.1731, -1.6397, -2.7358, 0.2854, -2.1840, 1.7183, -1.3018, 2.4871],
								        [0.2717, -3.6173, -2.9206, -2.1988, -3.6638, 0.3858, -2.9155, 2.2980],
								        [3.9859, -2.1580, -0.7984, -4.4904, -4.1181, -2.0252, -4.4782, 1.1253],
								    ])
								UpperCAmelCase__  :					str        =     tf.constant(
								    [
								        [0.0000, -0.0100, -0.0200, -0.0300, -0.0400, -0.0500, -0.0600, -0.0700],
								        [0.2012, -0.8897, -0.0263, -0.9401, -0.2074, -0.9463, -0.3481, -0.9343],
								        [1.7057, -0.6271, 1.2145, -1.3897, 0.6303, -1.7647, 0.1173, -1.8985],
								        [2.1731, 1.6397, 2.7358, -0.2854, 2.1840, -1.7183, 1.3018, -2.4871],
								        [-0.2717, 3.6173, 2.9206, 2.1988, 3.6638, -0.3858, 2.9155, -2.2980],
								        [-3.9859, 2.1580, 0.7984, 4.4904, 4.1181, 2.0252, 4.4782, -1.1253],
								    ])

								tf.debugging.assert_near(query_layer[0, 0, :6, :8]							,							_lowerCamelCase							,							atol=self.tolerance)
								tf.debugging.assert_near(key_layer[0, 0, :6, :8]							,							_lowerCamelCase							,							atol=self.tolerance)



'''simple docstring'''



from itertools import permutations







def     _UpperCamelCase      (		UpperCamelCase__					):
			if num[3] % 2 != 0:
						return False

			if (num[2] + num[3] + num[4]) % 3 != 0:
						return False

			if num[5] % 5 != 0:
						return False

			UpperCAmelCase__  :					Optional[int]        =     [7, 1_1, 1_3, 1_7]
			for i, test in enumerate(UpperCamelCase__					):
						if (num[i + 4] * 1_0_0 + num[i + 5] * 1_0 + num[i + 6]) % test != 0:
									return False
			return True







def     _UpperCamelCase      (		UpperCamelCase__ = 1_0					):
			return sum(
			    int("""""".join(map(UpperCamelCase__ ,      UpperCamelCase__					)					)					)
			    for num in permutations(range(UpperCamelCase__					)					)
			    if is_substring_divisible(UpperCamelCase__					)					)


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