"""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       a_      :




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




					def 						_SCREAMING_SNAKE_CASE						(	self						:     List[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__        =   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=snake_case__  ,						)

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




					def 						_SCREAMING_SNAKE_CASE						(	self						:     List[Any]  ,						snake_case__						:     List[Any]  ,						snake_case__						:     Dict  ,						snake_case__						:     int  ,						snake_case__						:     Dict  ,						snake_case__						:     Union[str, Any]  ,						snake_case__						:     int  ,						snake_case__						:     str     ):
							lowerCAmelCase__        =   TFRoFormerModel(config=snake_case__     )
							lowerCAmelCase__        =   {"""input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids}

							lowerCAmelCase__        =   [input_ids, input_mask]
							lowerCAmelCase__        =   model(snake_case__     )

							lowerCAmelCase__        =   model(snake_case__     )

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




					def 						_SCREAMING_SNAKE_CASE						(	self						:     Optional[Any]  ,						snake_case__						:     List[Any]  ,						snake_case__						:     Tuple  ,						snake_case__						:     int  ,						snake_case__						:     Dict  ,						snake_case__						:     Tuple  ,						snake_case__						:     int  ,						snake_case__						:     int     ):
							lowerCAmelCase__        =   True
							lowerCAmelCase__        =   TFRoFormerForCausalLM(config=snake_case__     )
							lowerCAmelCase__        =   {
							    """input_ids""": input_ids,
							    """attention_mask""": input_mask,
							    """token_type_ids""": token_type_ids,
							}
							lowerCAmelCase__        =   model(snake_case__     )["""logits"""]
							self.parent.assertListEqual(
							    list(prediction_scores.numpy().shape     )  ,						[self.batch_size, self.seq_length, self.vocab_size]     )




					def 						_SCREAMING_SNAKE_CASE						(	self						:     List[Any]  ,						snake_case__						:     str  ,						snake_case__						:     Optional[Any]  ,						snake_case__						:     List[str]  ,						snake_case__						:     Tuple  ,						snake_case__						:     int  ,						snake_case__						:     List[Any]  ,						snake_case__						:     Tuple     ):
							lowerCAmelCase__        =   TFRoFormerForMaskedLM(config=snake_case__     )
							lowerCAmelCase__        =   {
							    """input_ids""": input_ids,
							    """attention_mask""": input_mask,
							    """token_type_ids""": token_type_ids,
							}
							lowerCAmelCase__        =   model(snake_case__     )
							self.parent.assertEqual(result.logits.shape  ,						(self.batch_size, self.seq_length, self.vocab_size)     )




					def 						_SCREAMING_SNAKE_CASE						(	self						:     Any  ,						snake_case__						:     Dict  ,						snake_case__						:     List[Any]  ,						snake_case__						:     Optional[Any]  ,						snake_case__						:     Tuple  ,						snake_case__						:     Dict  ,						snake_case__						:     Any  ,						snake_case__						:     Tuple     ):
							lowerCAmelCase__        =   self.num_labels
							lowerCAmelCase__        =   TFRoFormerForSequenceClassification(config=snake_case__     )
							lowerCAmelCase__        =   {
							    """input_ids""": input_ids,
							    """attention_mask""": input_mask,
							    """token_type_ids""": token_type_ids,
							}

							lowerCAmelCase__        =   model(snake_case__     )
							self.parent.assertEqual(result.logits.shape  ,						(self.batch_size, self.num_labels)     )




					def 						_SCREAMING_SNAKE_CASE						(	self						:     Tuple  ,						snake_case__						:     Any  ,						snake_case__						:     Optional[int]  ,						snake_case__						:     List[str]  ,						snake_case__						:     List[str]  ,						snake_case__						:     List[Any]  ,						snake_case__						:     Tuple  ,						snake_case__						:     Dict     ):
							lowerCAmelCase__        =   self.num_choices
							lowerCAmelCase__        =   TFRoFormerForMultipleChoice(config=snake_case__     )
							lowerCAmelCase__        =   tf.tile(tf.expand_dims(snake_case__  ,						1     )  ,						(1, self.num_choices, 1)     )
							lowerCAmelCase__        =   tf.tile(tf.expand_dims(snake_case__  ,						1     )  ,						(1, self.num_choices, 1)     )
							lowerCAmelCase__        =   tf.tile(tf.expand_dims(snake_case__  ,						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(snake_case__     )
							self.parent.assertEqual(result.logits.shape  ,						(self.batch_size, self.num_choices)     )




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




					def 						_SCREAMING_SNAKE_CASE						(	self						:     List[str]  ,						snake_case__						:     Union[str, Any]  ,						snake_case__						:     str  ,						snake_case__						:     Union[str, Any]  ,						snake_case__						:     Union[str, Any]  ,						snake_case__						:     str  ,						snake_case__						:     int  ,						snake_case__						:     Tuple     ):
							lowerCAmelCase__        =   TFRoFormerForQuestionAnswering(config=snake_case__     )
							lowerCAmelCase__        =   {
							    """input_ids""": input_ids,
							    """attention_mask""": input_mask,
							    """token_type_ids""": token_type_ids,
							}

							lowerCAmelCase__        =   model(snake_case__     )
							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 						_SCREAMING_SNAKE_CASE						(	self						:     int     ):
							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       a_      (  __UpperCamelCase ,		__UpperCamelCase ,		unittest.TestCase			):
					UpperCamelCase_ :	Any			=    (
					    (
					        TFRoFormerModel,
					        TFRoFormerForCausalLM,
					        TFRoFormerForMaskedLM,
					        TFRoFormerForQuestionAnswering,
					        TFRoFormerForSequenceClassification,
					        TFRoFormerForTokenClassification,
					        TFRoFormerForMultipleChoice,
					    )
					    if is_tf_available()
					    else ()
					)
					UpperCamelCase_ :	List[str]			=    (
					    {
					        "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 {}
					)

					UpperCamelCase_ :	Tuple			=    False
					UpperCamelCase_ :	Tuple			=    False




					def 						_SCREAMING_SNAKE_CASE						(	self						:     Tuple  ,						snake_case__						:     List[Any]  ,						snake_case__						:     Tuple  ,						snake_case__						:     Optional[Any]  ,						snake_case__						:     List[Any]  ,						snake_case__						:     Any     ):
							if pipeline_test_casse_name == "TextGenerationPipelineTests":
									return True

							return False




					def 						_SCREAMING_SNAKE_CASE						(	self						:     Optional[int]     ):
							lowerCAmelCase__        =   TFRoFormerModelTester(self     )
							lowerCAmelCase__        =   ConfigTester(self  ,						config_class=snake_case__  ,						hidden_size=37     )




					def 						_SCREAMING_SNAKE_CASE						(	self						:     Dict     ):
							self.config_tester.run_common_tests()




					def 						_SCREAMING_SNAKE_CASE						(	self						:     Union[str, Any]     ):
							lowerCAmelCase__        =   self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_model(*snake_case__     )




					def 						_SCREAMING_SNAKE_CASE						(	self						:     List[str]     ):
							lowerCAmelCase__        =   self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_masked_lm(*snake_case__     )




					def 						_SCREAMING_SNAKE_CASE						(	self						:     str     ):
							lowerCAmelCase__        =   self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_lm_head(*snake_case__     )




					def 						_SCREAMING_SNAKE_CASE						(	self						:     List[Any]     ):
							lowerCAmelCase__        =   self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_multiple_choice(*snake_case__     )




					def 						_SCREAMING_SNAKE_CASE						(	self						:     List[Any]     ):
							lowerCAmelCase__        =   self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_question_answering(*snake_case__     )




					def 						_SCREAMING_SNAKE_CASE						(	self						:     Tuple     ):
							lowerCAmelCase__        =   self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_sequence_classification(*snake_case__     )




					def 						_SCREAMING_SNAKE_CASE						(	self						:     Optional[Any]     ):
							lowerCAmelCase__        =   self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_token_classification(*snake_case__     )




					@slow
					def 						_SCREAMING_SNAKE_CASE						(	self						:     int     ):
							lowerCAmelCase__        =   TFRoFormerModel.from_pretrained("""junnyu/roformer_chinese_base"""     )
							self.assertIsNotNone(snake_case__     )

@require_tf
class       a_      (  unittest.TestCase			):




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

							# TODO Replace vocab size
							lowerCAmelCase__        =   50000

							lowerCAmelCase__        =   [1, 6, vocab_size]
							self.assertEqual(output.shape  ,						snake_case__     )

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

							# TODO Replace values below with what was printed above.
							lowerCAmelCase__        =   tf.constant(
							    [
							        [
							            [-0.1205_3341, -1.026_4901, 0.2922_1946],
							            [-1.513_3783, 0.19_7433, 0.1519_0607],
							            [-5.013_5403, -3.90_0256, -0.8403_8764],
							        ]
							    ]     )
							tf.debugging.assert_near(output[:, :3, :3]  ,						snake_case__  ,						atol=1E-4     )

@require_tf
class       a_      (  unittest.TestCase			):
					UpperCamelCase_ :	str			=    1e-4




					def 						_SCREAMING_SNAKE_CASE						(	self						:     Tuple     ):
							lowerCAmelCase__        =   tf.constant([[4, 10]]     )
							lowerCAmelCase__        =   TFRoFormerSinusoidalPositionalEmbedding(num_positions=6  ,						embedding_dim=6     )

							lowerCAmelCase__        =   emba(input_ids.shape     )
							lowerCAmelCase__        =   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(snake_case__  ,						snake_case__  ,						atol=self.tolerance     )




					def 						_SCREAMING_SNAKE_CASE						(	self						:     Any     ):
							lowerCAmelCase__        =   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],
							    ]     )
							lowerCAmelCase__        =   TFRoFormerSinusoidalPositionalEmbedding(num_positions=512  ,						embedding_dim=512     )
							emba([2, 16, 512]     )
							lowerCAmelCase__        =   emba.weight[:3, :5]

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

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




					def 						_SCREAMING_SNAKE_CASE						(	self						:     Optional[int]     ):
							# 2,12,16,64
							lowerCAmelCase__        =   tf.reshape(tf.range(2 * 12 * 16 * 64  ,						dtype=tf.floataa     )  ,						shape=(2, 12, 16, 64)     ) / 100

							lowerCAmelCase__        =   -tf.reshape(tf.range(2 * 12 * 16 * 64  ,						dtype=tf.floataa     )  ,						shape=(2, 12, 16, 64)     ) / 100

							lowerCAmelCase__        =   TFRoFormerSinusoidalPositionalEmbedding(num_positions=32  ,						embedding_dim=64     )
							lowerCAmelCase__        =   embed_positions([2, 16, 768]     )[None, None, :, :]

							lowerCAmelCase__   ,					lowerCAmelCase__        =   TFRoFormerSelfAttention.apply_rotary_position_embeddings(
							    snake_case__  ,						snake_case__  ,						snake_case__     )

							lowerCAmelCase__        =   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],
							    ]     )
							lowerCAmelCase__        =   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]  ,						snake_case__  ,						atol=self.tolerance     )
							tf.debugging.assert_near(key_layer[0, 0, :6, :8]  ,						snake_case__  ,						atol=self.tolerance     )





"""simple docstring"""




import pprint

import requests

__lowerCAmelCase    :							Union[str, Any]													=						"https://zenquotes.io/api"







def 							_UpperCAmelCase		(       ):





		"""simple docstring"""




		return requests.get(API_ENDPOINT_URL + """/today"""     ).json()







def 							_UpperCAmelCase		(       ):





		"""simple docstring"""




		return requests.get(API_ENDPOINT_URL + """/random"""     ).json()


if __name__ == "__main__":
			__lowerCAmelCase    :							Union[str, Any]													=						random_quotes()
			pprint.pprint(response)




