



from __future__ import annotations

import random
import unittest

from transformers import TransfoXLConfig, 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
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
			import tensorflow as tf

			from transformers import (
			    TF_TRANSFO_XL_PRETRAINED_MODEL_ARCHIVE_LIST,
			    TFTransfoXLForSequenceClassification,
			    TFTransfoXLLMHeadModel,
			    TFTransfoXLModel,
			)
class 			_lowerCAmelCase   :






			"""simple docstring"""





			def __init__(				self	:       Optional[Any]			,     lowercase	:       str			,     )						->					Any:
									"""simple docstring"""







									__lowercase					=				parent
									__lowercase					=				13
									__lowercase					=				7
									__lowercase					=				30
									__lowercase					=				self.seq_length + self.mem_len
									__lowercase					=				15
									__lowercase					=				True
									__lowercase					=				True
									__lowercase					=				99
									__lowercase					=				[10, 50, 80]
									__lowercase					=				32
									__lowercase					=				32
									__lowercase					=				4
									__lowercase					=				8
									__lowercase					=				128
									__lowercase					=				2
									__lowercase					=				2
									__lowercase					=				None
									__lowercase					=				1
									__lowercase					=				0
									__lowercase					=				3
									__lowercase					=				self.vocab_size - 1
									__lowercase					=				0.01





			def 		snake_case__			(				self	:       Union[str, Any]   )						->					int:
									"""simple docstring"""







									__lowercase					=				ids_tensor([self.batch_size, self.seq_length]			,     self.vocab_size   )
									__lowercase					=				ids_tensor([self.batch_size, self.seq_length]			,     self.vocab_size   )

									__lowercase					=				None
									if self.use_labels:
															__lowercase					=				ids_tensor([self.batch_size, self.seq_length]			,     self.vocab_size   )

									__lowercase					=				TransfoXLConfig(
									    vocab_size=self.vocab_size			,     mem_len=self.mem_len			,     clamp_len=self.clamp_len			,     cutoffs=self.cutoffs			,     d_model=self.hidden_size			,     d_embed=self.d_embed			,     n_head=self.num_attention_heads			,     d_head=self.d_head			,     d_inner=self.d_inner			,     div_val=self.div_val			,     n_layer=self.num_hidden_layers			,     eos_token_id=self.eos_token_id			,     pad_token_id=self.vocab_size - 1			,     init_range=self.init_range			,     num_labels=self.num_labels			,     )

									return (config, input_ids_a, input_ids_a, lm_labels)





			def 		snake_case__			(				self	:       str   )						->					int:
									"""simple docstring"""







									random.seed(self.seed   )
									tf.random.set_seed(self.seed   )





			def 		snake_case__			(				self	:       str			,     lowercase	:       Tuple			,     lowercase	:       Tuple			,     lowercase	:       Optional[int]			,     lowercase	:       List[Any]   )						->					str:
									"""simple docstring"""







									__lowercase					=				TFTransfoXLModel(lowercase   )

									__lowercase	,			__lowercase					=				model(lowercase   ).to_tuple()

									__lowercase					=				{"""input_ids""": input_ids_a, """mems""": mems_a}

									__lowercase	,			__lowercase					=				model(lowercase   ).to_tuple()

									self.parent.assertEqual(hidden_states_a.shape			,     (self.batch_size, self.seq_length, self.hidden_size)   )
									self.parent.assertEqual(hidden_states_a.shape			,     (self.batch_size, self.seq_length, self.hidden_size)   )
									self.parent.assertListEqual(
									    [mem.shape for mem in mems_a]			,     [(self.mem_len, self.batch_size, self.hidden_size)] * self.num_hidden_layers			,     )
									self.parent.assertListEqual(
									    [mem.shape for mem in mems_a]			,     [(self.mem_len, self.batch_size, self.hidden_size)] * self.num_hidden_layers			,     )





			def 		snake_case__			(				self	:       List[str]			,     lowercase	:       Optional[int]			,     lowercase	:       int			,     lowercase	:       Optional[int]			,     lowercase	:       Dict   )						->					str:
									"""simple docstring"""







									__lowercase					=				TFTransfoXLLMHeadModel(lowercase   )

									__lowercase	,			__lowercase					=				model(lowercase   ).to_tuple()

									__lowercase					=				{"""input_ids""": input_ids_a, """labels""": lm_labels}
									__lowercase	,			__lowercase					=				model(lowercase   ).to_tuple()

									__lowercase	,			__lowercase					=				model([input_ids_a, mems_a]   ).to_tuple()

									__lowercase					=				{"""input_ids""": input_ids_a, """mems""": mems_a, """labels""": lm_labels}

									__lowercase	,			__lowercase					=				model(lowercase   ).to_tuple()

									self.parent.assertEqual(lm_logits_a.shape			,     (self.batch_size, self.seq_length, self.vocab_size)   )
									self.parent.assertListEqual(
									    [mem.shape for mem in mems_a]			,     [(self.mem_len, self.batch_size, self.hidden_size)] * self.num_hidden_layers			,     )

									self.parent.assertEqual(lm_logits_a.shape			,     (self.batch_size, self.seq_length, self.vocab_size)   )
									self.parent.assertListEqual(
									    [mem.shape for mem in mems_a]			,     [(self.mem_len, self.batch_size, self.hidden_size)] * self.num_hidden_layers			,     )





			def 		snake_case__			(				self	:       Dict			,     lowercase	:       Dict			,     lowercase	:       Dict			,     lowercase	:       List[Any]			,     lowercase	:       Optional[int]   )						->					Optional[int]:
									"""simple docstring"""







									__lowercase					=				TFTransfoXLForSequenceClassification(lowercase   )
									__lowercase					=				model(lowercase   )
									self.parent.assertEqual(result.logits.shape			,     (self.batch_size, self.num_labels)   )







			def 		snake_case__			(				self	:       List[str]   )						->					Tuple:
									"""simple docstring"""







									__lowercase					=				self.prepare_config_and_inputs()
									((__lowercase)	,			(__lowercase)	,			(__lowercase)	,			(__lowercase))					=				config_and_inputs
									__lowercase					=				{"""input_ids""": input_ids_a}
									return config, inputs_dict





@require_tf
class 			_lowerCAmelCase   ( _UpperCAmelCase    ,					_UpperCAmelCase    ,					unittest.TestCase			):






			"""simple docstring"""





			lowercase__      :  List[Any]      =			(
			    (TFTransfoXLModel, TFTransfoXLLMHeadModel, TFTransfoXLForSequenceClassification) if is_tf_available() else ()
			)
			lowercase__      :  Tuple      =			() if is_tf_available() else ()
			lowercase__      :  Union[str, Any]      =			(
			    {
			        """feature-extraction""": TFTransfoXLModel,
			        """text-classification""": TFTransfoXLForSequenceClassification,
			        """text-generation""": TFTransfoXLLMHeadModel,
			        """zero-shot""": TFTransfoXLForSequenceClassification,
			    }
			    if is_tf_available()
			    else {}
			)
			# TODO: add this test when TFTransfoXLLMHead has a linear output layer implemented
			lowercase__      :  Optional[Any]      =			False
			lowercase__      :  Union[str, Any]      =			False
			lowercase__      :  Dict      =			False
			lowercase__      :  List[str]      =			False





			def 		snake_case__			(				self	:       Dict			,     lowercase	:       Tuple			,     lowercase	:       Optional[int]			,     lowercase	:       Union[str, Any]			,     lowercase	:       Dict			,     lowercase	:       List[str]   )						->					Dict:
									"""simple docstring"""







									if pipeline_test_casse_name == "TextGenerationPipelineTests":
															# Get `ValueError: AttributeError: 'NoneType' object has no attribute 'new_ones'` or `AssertionError`.
															# `TransfoXLConfig` was never used in pipeline tests: cannot create a simple
															# tokenizer.
															return True

									return False





			def 		snake_case__			(				self	:       str   )						->					str:
									"""simple docstring"""







									__lowercase					=				TFTransfoXLModelTester(self   )
									__lowercase					=				ConfigTester(self			,     config_class=lowercase			,     d_embed=37   )





			def 		snake_case__			(				self	:       int   )						->					Any:
									"""simple docstring"""







									self.config_tester.run_common_tests()





			def 		snake_case__			(				self	:       Dict   )						->					Union[str, Any]:
									"""simple docstring"""







									self.model_tester.set_seed()
									__lowercase					=				self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_transfo_xl_model(*lowercase   )





			def 		snake_case__			(				self	:       Optional[int]   )						->					str:
									"""simple docstring"""







									self.model_tester.set_seed()
									__lowercase					=				self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_transfo_xl_lm_head(*lowercase   )





			def 		snake_case__			(				self	:       List[Any]   )						->					int:
									"""simple docstring"""







									__lowercase					=				self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_transfo_xl_for_sequence_classification(*lowercase   )





			def 		snake_case__			(				self	:       Union[str, Any]   )						->					Tuple:
									"""simple docstring"""







									__lowercase	,			__lowercase					=				self.model_tester.prepare_config_and_inputs_for_common()
									__lowercase					=				[TFTransfoXLForSequenceClassification]

									for model_class in self.all_model_classes:
															__lowercase					=				model_class(lowercase   )
															assert isinstance(model.get_input_embeddings()			,     tf.keras.layers.Layer   )
															if model_class in list_other_models_with_output_ebd:
																					__lowercase					=				model.get_output_embeddings()
																					assert isinstance(lowercase			,     tf.keras.layers.Layer   )
																					__lowercase					=				model.get_bias()
																					assert name is None
															else:
																					__lowercase					=				model.get_output_embeddings()
																					assert x is None
																					__lowercase					=				model.get_bias()
																					assert name is None





			def 		snake_case__			(				self	:       Any   )						->					Dict:
									"""simple docstring"""







									pass





			@slow
			def 		snake_case__			(				self	:       List[str]   )						->					List[str]:
									"""simple docstring"""







									for model_name in TF_TRANSFO_XL_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
															__lowercase					=				TFTransfoXLModel.from_pretrained(lowercase   )
															self.assertIsNotNone(lowercase   )







			@unittest.skip(reason="""This model doesn't play well with fit() due to not returning a single loss."""   )
			def 		snake_case__			(				self	:       List[Any]   )						->					Dict:
									"""simple docstring"""







									pass





@require_tf
class 			_lowerCAmelCase   ( unittest.TestCase			):






			"""simple docstring"""





			@unittest.skip("""Skip test until #12651 is resolved."""   )
			@slow
			def 		snake_case__			(				self	:       Optional[int]   )						->					Dict:
									"""simple docstring"""







									__lowercase					=				TFTransfoXLLMHeadModel.from_pretrained("""transfo-xl-wt103"""   )
									# fmt: off
									__lowercase					=				tf.convert_to_tensor([[33,1_297,2,1,1_009,4,1_109,11_739,4_762,358,5,25,245,22,1_706,17,20_098,5,3_215,21,37,1_110,3,13,1_041,4,24,603,490,2,71_477,20_098,104_447,2,20_961,1,2_604,4,1,329,3,6_224,831,16_002,2,8,603,78_967,29_546,23,803,20,25,416,5,8,232,4,277,6,1_855,4_601,3,29_546,54,8,3_609,5,57_211,49,4,1,277,18,8,1_755,15_691,3,341,25,416,693,42_573,71,17,401,94,31,17_919,2,29_546,7_873,18,1,435,23,11_011,755,5,5_167,3,7_983,98,84,2,29_546,3_267,8,3_609,4,1,4_865,1_075,2,6_087,71,6,346,8,5_854,3,29_546,824,1_400,1_868,2,19,160,2,311,8,5_496,2,20_920,17,25,15_097,3,24,24,0]]			,     dtype=tf.intaa   )  # noqa: E231
									# fmt: on
									#  In 1991 , the remains of Russian Tsar Nicholas II and his family
									#  ( except for Alexei and Maria ) are discovered .
									#  The voice of Nicholas's young son , Tsarevich Alexei Nikolaevich , narrates the
									#  remainder of the story . 1883 Western Siberia ,
									#  a young Grigori Rasputin is asked by his father and a group of men to perform magic .
									#  Rasputin has a vision and denounces one of the men as a horse thief . Although his
									#  father initially slaps him for making such an accusation , Rasputin watches as the
									#  man is chased outside and beaten . Twenty years later , Rasputin sees a vision of
									#  the Virgin Mary , prompting him to become a priest . Rasputin quickly becomes famous ,
									#  with people , even a bishop , begging for his blessing . <eod> </s> <eos>

									# fmt: off
									__lowercase					=				[33,1_297,2,1,1_009,4,1_109,11_739,4_762,358,5,25,245,22,1_706,17,20_098,5,3_215,21,37,1_110,3,13,1_041,4,24,603,490,2,71_477,20_098,104_447,2,20_961,1,2_604,4,1,329,3,6_224,831,16_002,2,8,603,78_967,29_546,23,803,20,25,416,5,8,232,4,277,6,1_855,4_601,3,29_546,54,8,3_609,5,57_211,49,4,1,277,18,8,1_755,15_691,3,341,25,416,693,42_573,71,17,401,94,31,17_919,2,29_546,7_873,18,1,435,23,11_011,755,5,5_167,3,7_983,98,84,2,29_546,3_267,8,3_609,4,1,4_865,1_075,2,6_087,71,6,346,8,5_854,3,29_546,824,1_400,1_868,2,19,160,2,311,8,5_496,2,20_920,17,25,15_097,3,24,24,0,33,1,1_857,2,1,1_009,4,1_109,11_739,4_762,358,5,25,245,28,1_110,3,13,1_041,4,24,603,490,2,71_477,20_098,104_447,2,20_961,1,2_604,4,1,329,3,0]  # noqa: E231
									# fmt: on
									#  In 1991, the remains of Russian Tsar Nicholas II and his family (
									#  except for Alexei and Maria ) are discovered. The voice of young son,
									#  Tsarevich Alexei Nikolaevich, narrates the remainder of the story.
									#  1883 Western Siberia, a young Grigori Rasputin is asked by his father
									#  and a group of men to perform magic. Rasputin has a vision and
									#  denounces one of the men as a horse thief. Although his father initially
									#  slaps him for making such an accusation, Rasputin watches as the man
									#  is chased outside and beaten. Twenty years later, Rasputin sees a vision
									#  of the Virgin Mary, prompting him to become a priest.
									#  Rasputin quickly becomes famous, with people, even a bishop, begging for
									#  his blessing. <unk> <unk> <eos> In the 1990s, the remains of Russian Tsar
									# Nicholas II and his family were discovered. The voice of <unk> young son,
									# Tsarevich Alexei Nikolaevich, narrates the remainder of the story.<eos>

									__lowercase					=				model.generate(lowercase			,     max_length=200			,     do_sample=lowercase   )
									self.assertListEqual(output_ids[0].numpy().tolist()			,     lowercase   )










def  UpperCAmelCase__    (    lowercase__						,       lowercase__						,       lowercase__   ) ->      float:
						__lowercase					=				(num_of_terms / 2) * (2 * first_term + (num_of_terms - 1) * common_diff)
						# formula for sum of series
						return total






def  UpperCAmelCase__    (    ) ->      List[str]:
						print(sum_of_series(1						,       1						,       10   )   )


if __name__ == "__main__":
			import doctest

			doctest.testmod()





