


'''simple docstring'''



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 							__UpperCamelCase				:




	def __init__(   self						,				__a						,				):

						'''simple docstring'''





						__a			:       Any					    =  parent
						__a			:       Any					    =  13
						__a			:       Dict					    =  7
						__a			:       List[str]					    =  30
						__a			:       str					    =  self.seq_length + self.mem_len
						__a			:       int					    =  15
						__a			:       List[Any]					    =  True
						__a			:       List[str]					    =  True
						__a			:       List[str]					    =  99
						__a			:       Optional[int]					    =  [10, 50, 80]
						__a			:       Dict					    =  32
						__a			:       List[Any]					    =  32
						__a			:       Optional[int]					    =  4
						__a			:       Optional[Any]					    =  8
						__a			:       Union[str, Any]					    =  128
						__a			:       Any					    =  2
						__a			:       List[str]					    =  2
						__a			:       Optional[int]					    =  None
						__a			:       Optional[int]					    =  1
						__a			:       int					    =  0
						__a			:       Tuple					    =  3
						__a			:       List[str]					    =  self.vocab_size - 1
						__a			:       Tuple					    =  0.01




	def       __UpperCAmelCase							(   self							):

						'''simple docstring'''





						__a			:       Union[str, Any]					    =  ids_tensor([self.batch_size, self.seq_length]						,				self.vocab_size							)
						__a			:       Union[str, Any]					    =  ids_tensor([self.batch_size, self.seq_length]						,				self.vocab_size							)

						__a			:       Union[str, Any]					    =  None
						if self.use_labels:
											__a			:       Dict					    =  ids_tensor([self.batch_size, self.seq_length]						,				self.vocab_size							)

						__a			:       Tuple					    =  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       __UpperCAmelCase							(   self							):

						'''simple docstring'''





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




	def       __UpperCAmelCase							(   self						,				__a						,				__a						,				__a						,				__a							):

						'''simple docstring'''





						__a			:       Optional[Any]					    =  TFTransfoXLModel(__a							)

						__a    ,				__a			:       Optional[Any]					    =  model(__a							).to_tuple()

						__a			:       Union[str, Any]					    =  {'input_ids': input_ids_a, 'mems': mems_a}

						__a    ,				__a			:       Optional[Any]					    =  model(__a							).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       __UpperCAmelCase							(   self						,				__a						,				__a						,				__a						,				__a							):

						'''simple docstring'''





						__a			:       Tuple					    =  TFTransfoXLLMHeadModel(__a							)

						__a    ,				__a			:       Optional[int]					    =  model(__a							).to_tuple()

						__a			:       Any					    =  {'input_ids': input_ids_a, 'labels': lm_labels}
						__a    ,				__a			:       Any					    =  model(__a							).to_tuple()

						__a    ,				__a			:       List[Any]					    =  model([input_ids_a, mems_a]							).to_tuple()

						__a			:       Dict					    =  {'input_ids': input_ids_a, 'mems': mems_a, 'labels': lm_labels}

						__a    ,				__a			:       Tuple					    =  model(__a							).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       __UpperCAmelCase							(   self						,				__a						,				__a						,				__a						,				__a							):

						'''simple docstring'''





						__a			:       int					    =  TFTransfoXLForSequenceClassification(__a							)
						__a			:       str					    =  model(__a							)
						self.parent.assertEqual(result.logits.shape						,				(self.batch_size, self.num_labels)							)





	def       __UpperCAmelCase							(   self							):

						'''simple docstring'''





						__a			:       int					    =  self.prepare_config_and_inputs()
						((__a)    ,				(__a)    ,				(__a)    ,				(__a))			:       str					    =  config_and_inputs
						__a			:       Optional[int]					    =  {'input_ids': input_ids_a}
						return config, inputs_dict





@require_tf
class 							__UpperCamelCase				(		lowerCAmelCase_		,      lowerCAmelCase_		,      unittest.TestCase					):
	A_				=    (
	    (TFTransfoXLModel, TFTransfoXLLMHeadModel, TFTransfoXLForSequenceClassification) if is_tf_available() else ()
	)
	A_				=    () if is_tf_available() else ()
	A_				=    (
	    {
	        "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
	A_				=    False
	A_				=    False
	A_				=    False
	A_				=    False




	def       __UpperCAmelCase							(   self						,				__a						,				__a						,				__a						,				__a						,				__a							):

						'''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       __UpperCAmelCase							(   self							):

						'''simple docstring'''





						__a			:       List[Any]					    =  TFTransfoXLModelTester(self							)
						__a			:       Optional[Any]					    =  ConfigTester(self						,				config_class=__a						,				d_embed=37							)




	def       __UpperCAmelCase							(   self							):

						'''simple docstring'''





						self.config_tester.run_common_tests()




	def       __UpperCAmelCase							(   self							):

						'''simple docstring'''





						self.model_tester.set_seed()
						__a			:       Any					    =  self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_transfo_xl_model(*__a							)




	def       __UpperCAmelCase							(   self							):

						'''simple docstring'''





						self.model_tester.set_seed()
						__a			:       str					    =  self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_transfo_xl_lm_head(*__a							)




	def       __UpperCAmelCase							(   self							):

						'''simple docstring'''





						__a			:       str					    =  self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_transfo_xl_for_sequence_classification(*__a							)




	def       __UpperCAmelCase							(   self							):

						'''simple docstring'''





						__a    ,				__a			:       Any					    =  self.model_tester.prepare_config_and_inputs_for_common()
						__a			:       str					    =  [TFTransfoXLForSequenceClassification]

						for model_class in self.all_model_classes:
											__a			:       Tuple					    =  model_class(__a							)
											assert isinstance(model.get_input_embeddings()						,				tf.keras.layers.Layer							)
											if model_class in list_other_models_with_output_ebd:
																__a			:       Union[str, Any]					    =  model.get_output_embeddings()
																assert isinstance(__a						,				tf.keras.layers.Layer							)
																__a			:       List[str]					    =  model.get_bias()
																assert name is None
											else:
																__a			:       Any					    =  model.get_output_embeddings()
																assert x is None
																__a			:       str					    =  model.get_bias()
																assert name is None




	def       __UpperCAmelCase							(   self							):

						'''simple docstring'''





						pass




	@slow
	def       __UpperCAmelCase							(   self							):

						'''simple docstring'''





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





	@unittest.skip(reason='This model doesn\'t play well with fit() due to not returning a single loss.'							)
	def       __UpperCAmelCase							(   self							):

						'''simple docstring'''





						pass





@require_tf
class 							__UpperCamelCase				(		unittest.TestCase					):




	@unittest.skip('Skip test until #12651 is resolved.'							)
	@slow
	def       __UpperCAmelCase							(   self							):

						'''simple docstring'''





						__a			:       Dict					    =  TFTransfoXLLMHeadModel.from_pretrained('transfo-xl-wt103'							)
						# fmt: off
						__a			:       List[Any]					    =  tf.convert_to_tensor([[33,1297,2,1,1009,4,1109,1_1739,4762,358,5,25,245,22,1706,17,2_0098,5,3215,21,37,1110,3,13,1041,4,24,603,490,2,7_1477,2_0098,10_4447,2,2_0961,1,2604,4,1,329,3,6224,831,1_6002,2,8,603,7_8967,2_9546,23,803,20,25,416,5,8,232,4,277,6,1855,4601,3,2_9546,54,8,3609,5,5_7211,49,4,1,277,18,8,1755,1_5691,3,341,25,416,693,4_2573,71,17,401,94,31,1_7919,2,2_9546,7873,18,1,435,23,1_1011,755,5,5167,3,7983,98,84,2,2_9546,3267,8,3609,4,1,4865,1075,2,6087,71,6,346,8,5854,3,2_9546,824,1400,1868,2,19,160,2,311,8,5496,2,2_0920,17,25,1_5097,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
						__a			:       List[Any]					    =  [33,1297,2,1,1009,4,1109,1_1739,4762,358,5,25,245,22,1706,17,2_0098,5,3215,21,37,1110,3,13,1041,4,24,603,490,2,7_1477,2_0098,10_4447,2,2_0961,1,2604,4,1,329,3,6224,831,1_6002,2,8,603,7_8967,2_9546,23,803,20,25,416,5,8,232,4,277,6,1855,4601,3,2_9546,54,8,3609,5,5_7211,49,4,1,277,18,8,1755,1_5691,3,341,25,416,693,4_2573,71,17,401,94,31,1_7919,2,2_9546,7873,18,1,435,23,1_1011,755,5,5167,3,7983,98,84,2,2_9546,3267,8,3609,4,1,4865,1075,2,6087,71,6,346,8,5854,3,2_9546,824,1400,1868,2,19,160,2,311,8,5496,2,2_0920,17,25,1_5097,3,24,24,0,33,1,1857,2,1,1009,4,1109,1_1739,4762,358,5,25,245,28,1110,3,13,1041,4,24,603,490,2,7_1477,2_0098,10_4447,2,2_0961,1,2604,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>

						__a			:       Optional[Any]					    =  model.generate(__a						,				max_length=200						,				do_sample=__a							)
						self.assertListEqual(output_ids[0].numpy().tolist()						,				__a							)







'''simple docstring'''



from __future__ import annotations

from fractions import Fraction
from math import gcd, sqrt






def   lowerCamelCase							(_SCREAMING_SNAKE_CASE      :   int   ):
					__a			:       int					    =  int(number**0.5   )
					return number == sq * sq






def   lowerCamelCase							(_SCREAMING_SNAKE_CASE      :   int						,      _SCREAMING_SNAKE_CASE      :   int						,      _SCREAMING_SNAKE_CASE      :   int						,      _SCREAMING_SNAKE_CASE      :   int						,      _SCREAMING_SNAKE_CASE      :   int						,      _SCREAMING_SNAKE_CASE      :   int   ):
					__a			:       int					    =  x_num * y_den * z_den + y_num * x_den * z_den + z_num * x_den * y_den
					__a			:       int					    =  x_den * y_den * z_den
					__a			:       int					    =  gcd(_SCREAMING_SNAKE_CASE						,      _SCREAMING_SNAKE_CASE   )
					top //= hcf
					bottom //= hcf
					return top, bottom






def   lowerCamelCase							(_SCREAMING_SNAKE_CASE      :   int = 35   ):
					__a			:       set					    =  set()
					__a			:       int
					__a			:       Fraction					    =  Fraction(0   )
					__a			:       tuple[int, int]

					for x_num in range(1						,      order + 1   ):
										for x_den in range(x_num + 1						,      order + 1   ):
															for y_num in range(1						,      order + 1   ):
																				for y_den in range(y_num + 1						,      order + 1   ):
																									# n=1
																									__a			:       Union[str, Any]					    =  x_num * y_den + x_den * y_num
																									__a			:       Optional[Any]					    =  x_den * y_den
																									__a			:       int					    =  gcd(_SCREAMING_SNAKE_CASE						,      _SCREAMING_SNAKE_CASE   )
																									z_num //= hcf
																									z_den //= hcf
																									if 0 < z_num < z_den <= order:
																														__a			:       Any					    =  add_three(
																														    _SCREAMING_SNAKE_CASE						,      _SCREAMING_SNAKE_CASE						,      _SCREAMING_SNAKE_CASE						,      _SCREAMING_SNAKE_CASE						,      _SCREAMING_SNAKE_CASE						,      _SCREAMING_SNAKE_CASE   )
																														unique_s.add(_SCREAMING_SNAKE_CASE   )

																									# n=2
																									__a			:       Optional[int]					    =  (
																									    x_num * x_num * y_den * y_den + x_den * x_den * y_num * y_num
																									)
																									__a			:       Union[str, Any]					    =  x_den * x_den * y_den * y_den
																									if is_sq(_SCREAMING_SNAKE_CASE   ) and is_sq(_SCREAMING_SNAKE_CASE   ):
																														__a			:       List[Any]					    =  int(sqrt(_SCREAMING_SNAKE_CASE   )   )
																														__a			:       Any					    =  int(sqrt(_SCREAMING_SNAKE_CASE   )   )
																														__a			:       Optional[int]					    =  gcd(_SCREAMING_SNAKE_CASE						,      _SCREAMING_SNAKE_CASE   )
																														z_num //= hcf
																														z_den //= hcf
																														if 0 < z_num < z_den <= order:
																																			__a			:       List[Any]					    =  add_three(
																																			    _SCREAMING_SNAKE_CASE						,      _SCREAMING_SNAKE_CASE						,      _SCREAMING_SNAKE_CASE						,      _SCREAMING_SNAKE_CASE						,      _SCREAMING_SNAKE_CASE						,      _SCREAMING_SNAKE_CASE   )
																																			unique_s.add(_SCREAMING_SNAKE_CASE   )

                    # n=-1
																									__a			:       int					    =  x_num * y_num
																									__a			:       Optional[Any]					    =  x_den * y_num + x_num * y_den
																									__a			:       Tuple					    =  gcd(_SCREAMING_SNAKE_CASE						,      _SCREAMING_SNAKE_CASE   )
																									z_num //= hcf
																									z_den //= hcf
																									if 0 < z_num < z_den <= order:
																														__a			:       Any					    =  add_three(
																														    _SCREAMING_SNAKE_CASE						,      _SCREAMING_SNAKE_CASE						,      _SCREAMING_SNAKE_CASE						,      _SCREAMING_SNAKE_CASE						,      _SCREAMING_SNAKE_CASE						,      _SCREAMING_SNAKE_CASE   )
																														unique_s.add(_SCREAMING_SNAKE_CASE   )

																									# n=2
																									__a			:       List[Any]					    =  x_num * x_num * y_num * y_num
																									__a			:       List[Any]					    =  (
																									    x_den * x_den * y_num * y_num + x_num * x_num * y_den * y_den
																									)
																									if is_sq(_SCREAMING_SNAKE_CASE   ) and is_sq(_SCREAMING_SNAKE_CASE   ):
																														__a			:       Optional[Any]					    =  int(sqrt(_SCREAMING_SNAKE_CASE   )   )
																														__a			:       Union[str, Any]					    =  int(sqrt(_SCREAMING_SNAKE_CASE   )   )
																														__a			:       int					    =  gcd(_SCREAMING_SNAKE_CASE						,      _SCREAMING_SNAKE_CASE   )
																														z_num //= hcf
																														z_den //= hcf
																														if 0 < z_num < z_den <= order:
																																			__a			:       List[str]					    =  add_three(
																																			    _SCREAMING_SNAKE_CASE						,      _SCREAMING_SNAKE_CASE						,      _SCREAMING_SNAKE_CASE						,      _SCREAMING_SNAKE_CASE						,      _SCREAMING_SNAKE_CASE						,      _SCREAMING_SNAKE_CASE   )
																																			unique_s.add(_SCREAMING_SNAKE_CASE   )

					for num, den in unique_s:
										total += Fraction(_SCREAMING_SNAKE_CASE						,      _SCREAMING_SNAKE_CASE   )

					return total.denominator + total.numerator


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



