


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




							"""simple docstring"""


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

							def        __snake_case   (				self			:    Optional[int]							)      ->       Optional[int]:
														__snake_case						:     Tuple									=  ids_tensor([self.batch_size, self.seq_length]       ,      self.vocab_size							)
														__snake_case						:     Optional[int]									=  ids_tensor([self.batch_size, self.seq_length]       ,      self.vocab_size							)

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

														__snake_case						:     Dict									=  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			:    Any							)      ->       Union[str, Any]:
														random.seed(self.seed							)
														tf.random.set_seed(self.seed							)

							def        __snake_case   (				self			:    str       ,      lowerCamelCase			:    Tuple       ,      lowerCamelCase			:    Union[str, Any]       ,      lowerCamelCase			:    Optional[Any]       ,      lowerCamelCase			:    str							)      ->       Optional[Any]:
														__snake_case						:     List[str]									=  TFTransfoXLModel(lowerCamelCase							)

														__snake_case					,     __snake_case						:     str									=  model(lowerCamelCase							).to_tuple()

														__snake_case						:     Optional[Any]									=  {"input_ids": input_ids_a, "mems": mems_a}

														__snake_case					,     __snake_case						:     List[Any]									=  model(lowerCamelCase							).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]       ,      lowerCamelCase			:    Optional[int]       ,      lowerCamelCase			:    Tuple       ,      lowerCamelCase			:    List[Any]       ,      lowerCamelCase			:    int							)      ->       Dict:
														__snake_case						:     int									=  TFTransfoXLLMHeadModel(lowerCamelCase							)

														__snake_case					,     __snake_case						:     str									=  model(lowerCamelCase							).to_tuple()

														__snake_case						:     Tuple									=  {"input_ids": input_ids_a, "labels": lm_labels}
														__snake_case					,     __snake_case						:     List[Any]									=  model(lowerCamelCase							).to_tuple()

														__snake_case					,     __snake_case						:     Union[str, Any]									=  model([input_ids_a, mems_a]							).to_tuple()

														__snake_case						:     List[str]									=  {"input_ids": input_ids_a, "mems": mems_a, "labels": lm_labels}

														__snake_case					,     __snake_case						:     List[Any]									=  model(lowerCamelCase							).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			:    Union[str, Any]       ,      lowerCamelCase			:    str       ,      lowerCamelCase			:    Optional[int]       ,      lowerCamelCase			:    str       ,      lowerCamelCase			:    Optional[int]							)      ->       List[str]:
														__snake_case						:     str									=  TFTransfoXLForSequenceClassification(lowerCamelCase							)
														__snake_case						:     Optional[int]									=  model(lowerCamelCase							)
														self.parent.assertEqual(result.logits.shape       ,      (self.batch_size, self.num_labels)							)






							def        __snake_case   (				self			:    List[Any]							)      ->       Any:
														__snake_case						:     Union[str, Any]									=  self.prepare_config_and_inputs()
														((__snake_case)					,     (__snake_case)					,     (__snake_case)					,     (__snake_case))						:     Tuple									=  config_and_inputs
														__snake_case						:     Dict									=  {"input_ids": input_ids_a}
														return config, inputs_dict

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




							"""simple docstring"""


							__UpperCAmelCase       :				Any	    =    (
							    (TFTransfoXLModel, TFTransfoXLLMHeadModel, TFTransfoXLForSequenceClassification) if is_tf_available() else ()
							)
							__UpperCAmelCase       :				List[Any]	    =    () if is_tf_available() else ()
							__UpperCAmelCase       :				Dict	    =    (
							    {
							        "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
							__UpperCAmelCase       :				Union[str, Any]	    =    False
							__UpperCAmelCase       :				List[Any]	    =    False
							__UpperCAmelCase       :				Optional[Any]	    =    False
							__UpperCAmelCase       :				int	    =    False

							def        __snake_case   (				self			:    Optional[int]       ,      lowerCamelCase			:    int       ,      lowerCamelCase			:    List[str]       ,      lowerCamelCase			:    List[str]       ,      lowerCamelCase			:    str       ,      lowerCamelCase			:    Any							)      ->       Optional[int]:
														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			:    int							)      ->       int:
														__snake_case						:     List[Any]									=  TFTransfoXLModelTester(self							)
														__snake_case						:     List[str]									=  ConfigTester(self       ,      config_class=lowerCamelCase       ,      d_embed=37							)

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

							def        __snake_case   (				self			:    List[Any]							)      ->       Dict:
														self.model_tester.set_seed()
														__snake_case						:     Union[str, Any]									=  self.model_tester.prepare_config_and_inputs()
														self.model_tester.create_and_check_transfo_xl_model(*lowerCamelCase							)

							def        __snake_case   (				self			:    Optional[int]							)      ->       Optional[Any]:
														self.model_tester.set_seed()
														__snake_case						:     List[str]									=  self.model_tester.prepare_config_and_inputs()
														self.model_tester.create_and_check_transfo_xl_lm_head(*lowerCamelCase							)

							def        __snake_case   (				self			:    Optional[Any]							)      ->       Tuple:
														__snake_case						:     str									=  self.model_tester.prepare_config_and_inputs()
														self.model_tester.create_and_check_transfo_xl_for_sequence_classification(*lowerCamelCase							)

							def        __snake_case   (				self			:    List[Any]							)      ->       Any:
														__snake_case					,     __snake_case						:     int									=  self.model_tester.prepare_config_and_inputs_for_common()
														__snake_case						:     int									=  [TFTransfoXLForSequenceClassification]

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

							def        __snake_case   (				self			:    List[Any]							)      ->       List[Any]:
														# TODO JP: Make TransfoXL XLA compliant
														pass

							@slow
							def        __snake_case   (				self			:    Optional[int]							)      ->       Dict:
														for model_name in TF_TRANSFO_XL_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																					__snake_case						:     Union[str, Any]									=  TFTransfoXLModel.from_pretrained(lowerCamelCase							)
																					self.assertIsNotNone(lowerCamelCase							)






							@unittest.skip(reason="This model doesn't play well with fit() due to not returning a single loss."							)
							def        __snake_case   (				self			:    str							)      ->       Optional[int]:
														pass

@require_tf
class 							a						(unittest.TestCase ):




							"""simple docstring"""


							@unittest.skip("Skip test until #12651 is resolved."							)
							@slow
							def        __snake_case   (				self			:    List[Any]							)      ->       Tuple:
														__snake_case						:     Dict									=  TFTransfoXLLMHeadModel.from_pretrained("transfo-xl-wt103"							)
														# fmt: off
														__snake_case						:     Union[str, Any]									=  tf.convert_to_tensor([[33,1297,2,1,1009,4,1109,11739,4762,358,5,25,245,22,1706,17,20098,5,3215,21,37,1110,3,13,1041,4,24,603,490,2,71477,20098,104447,2,20961,1,2604,4,1,329,3,6224,831,16002,2,8,603,78967,29546,23,803,20,25,416,5,8,232,4,277,6,1855,4601,3,29546,54,8,3609,5,57211,49,4,1,277,18,8,1755,15691,3,341,25,416,693,42573,71,17,401,94,31,17919,2,29546,7873,18,1,435,23,11011,755,5,5167,3,7983,98,84,2,29546,3267,8,3609,4,1,4865,1075,2,6087,71,6,346,8,5854,3,29546,824,1400,1868,2,19,160,2,311,8,5496,2,20920,17,25,15097,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
														__snake_case						:     List[str]									=  [33,1297,2,1,1009,4,1109,11739,4762,358,5,25,245,22,1706,17,20098,5,3215,21,37,1110,3,13,1041,4,24,603,490,2,71477,20098,104447,2,20961,1,2604,4,1,329,3,6224,831,16002,2,8,603,78967,29546,23,803,20,25,416,5,8,232,4,277,6,1855,4601,3,29546,54,8,3609,5,57211,49,4,1,277,18,8,1755,15691,3,341,25,416,693,42573,71,17,401,94,31,17919,2,29546,7873,18,1,435,23,11011,755,5,5167,3,7983,98,84,2,29546,3267,8,3609,4,1,4865,1075,2,6087,71,6,346,8,5854,3,29546,824,1400,1868,2,19,160,2,311,8,5496,2,20920,17,25,15097,3,24,24,0,33,1,1857,2,1,1009,4,1109,11739,4762,358,5,25,245,28,1110,3,13,1041,4,24,603,490,2,71477,20098,104447,2,20961,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>

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





import unittest

from transformers.utils.backbone_utils import (
    BackboneMixin,
    get_aligned_output_features_output_indices,
    verify_out_features_out_indices,
)



class 						_UpperCAmelCase      (     unittest.TestCase							):






		def _snake_case		(						self				:     Union[str, Any]):
				SCREAMING_SNAKE_CASE_				:Optional[int]				     =						["a", "b", "c"]

				# Defaults to last layer if both are None
				SCREAMING_SNAKE_CASE_     ,				SCREAMING_SNAKE_CASE_				:Dict				     =						get_aligned_output_features_output_indices(UpperCAmelCase   ,  UpperCAmelCase   ,  UpperCAmelCase)
				self.assertEqual(UpperCAmelCase   ,  ["c"])
				self.assertEqual(UpperCAmelCase   ,  [2])

				# Out indices set to match out features
				SCREAMING_SNAKE_CASE_     ,				SCREAMING_SNAKE_CASE_				:Tuple				     =						get_aligned_output_features_output_indices(["a", "c"]   ,  UpperCAmelCase   ,  UpperCAmelCase)
				self.assertEqual(UpperCAmelCase   ,  ["a", "c"])
				self.assertEqual(UpperCAmelCase   ,  [0, 2])

				# Out features set to match out indices
				SCREAMING_SNAKE_CASE_     ,				SCREAMING_SNAKE_CASE_				:int				     =						get_aligned_output_features_output_indices(UpperCAmelCase   ,  [0, 2]   ,  UpperCAmelCase)
				self.assertEqual(UpperCAmelCase   ,  ["a", "c"])
				self.assertEqual(UpperCAmelCase   ,  [0, 2])

				# Out features selected from negative indices
				SCREAMING_SNAKE_CASE_     ,				SCREAMING_SNAKE_CASE_				:Any				     =						get_aligned_output_features_output_indices(UpperCAmelCase   ,  [-3, -1]   ,  UpperCAmelCase)
				self.assertEqual(UpperCAmelCase   ,  ["a", "c"])
				self.assertEqual(UpperCAmelCase   ,  [-3, -1])






		def _snake_case		(						self				:     str):
				# Stage names must be set
				with self.assertRaises(UpperCAmelCase):
						verify_out_features_out_indices(["a", "b"]   ,  (0, 1)   ,  UpperCAmelCase)

				# Out features must be a list
				with self.assertRaises(UpperCAmelCase):
						verify_out_features_out_indices(("a", "b")   ,  (0, 1)   ,  ["a", "b"])

				# Out features must be a subset of stage names
				with self.assertRaises(UpperCAmelCase):
						verify_out_features_out_indices(["a", "b"]   ,  (0, 1)   ,  ["a"])

				# Out indices must be a list or tuple
				with self.assertRaises(UpperCAmelCase):
						verify_out_features_out_indices(UpperCAmelCase   ,  0   ,  ["a", "b"])

				# Out indices must be a subset of stage names
				with self.assertRaises(UpperCAmelCase):
						verify_out_features_out_indices(UpperCAmelCase   ,  (0, 1)   ,  ["a"])

				# Out features and out indices must be the same length
				with self.assertRaises(UpperCAmelCase):
						verify_out_features_out_indices(["a", "b"]   ,  (0,)   ,  ["a", "b", "c"])

				# Out features should match out indices
				with self.assertRaises(UpperCAmelCase):
						verify_out_features_out_indices(["a", "b"]   ,  (0, 2)   ,  ["a", "b", "c"])

				# Out features and out indices should be in order
				with self.assertRaises(UpperCAmelCase):
						verify_out_features_out_indices(["b", "a"]   ,  (0, 1)   ,  ["a", "b"])

				# Check passes with valid inputs
				verify_out_features_out_indices(["a", "b", "d"]   ,  (0, 1, -1)   ,  ["a", "b", "c", "d"])







		def _snake_case		(						self				:     Tuple):
				SCREAMING_SNAKE_CASE_				:int				     =						BackboneMixin()

				SCREAMING_SNAKE_CASE_				:List[str]				     =						["a", "b", "c"]
				SCREAMING_SNAKE_CASE_				:str				     =						["a", "c"]
				SCREAMING_SNAKE_CASE_				:Union[str, Any]				     =						[0, 2]

				# Check that the output features and indices are set correctly
				self.assertEqual(backbone.out_features   ,  ["a", "c"])
				self.assertEqual(backbone.out_indices   ,  [0, 2])

				# Check out features and indices are updated correctly
				SCREAMING_SNAKE_CASE_				:Tuple				     =						["a", "b"]
				self.assertEqual(backbone.out_features   ,  ["a", "b"])
				self.assertEqual(backbone.out_indices   ,  [0, 1])

				SCREAMING_SNAKE_CASE_				:List[str]				     =						[-3, -1]
				self.assertEqual(backbone.out_features   ,  ["a", "c"])
				self.assertEqual(backbone.out_indices   ,  [-3, -1])






