





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 ,  lowercase ,  )      ->						Dict:







          '''simple docstring'''

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

   def 							__lowercase		( self)      ->						int:







          '''simple docstring'''

          a__						:     Optional[Any]			=    ids_tensor([self.batch_size, self.seq_length] ,  self.vocab_size)
          a__						:     int			=    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__						:     int			=    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 							__lowercase		( self)      ->						Union[str, Any]:







          '''simple docstring'''

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

   def 							__lowercase		( self ,  lowercase ,  lowercase ,  lowercase ,  lowercase)      ->						Any:







          '''simple docstring'''

          a__						:     Optional[int]			=    TFTransfoXLModel(lowercase)

          a__			,							a__						:     Tuple			=    model(lowercase).to_tuple()

          a__						:     str			=    {'input_ids': input_ids_a, 'mems': mems_a}

          a__			,							a__						:     Union[str, Any]			=    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 							__lowercase		( self ,  lowercase ,  lowercase ,  lowercase ,  lowercase)      ->						Tuple:







          '''simple docstring'''

          a__						:     Any			=    TFTransfoXLLMHeadModel(lowercase)

          a__			,							a__						:     Dict			=    model(lowercase).to_tuple()

          a__						:     List[Any]			=    {'input_ids': input_ids_a, 'labels': lm_labels}
          a__			,							a__						:     Tuple			=    model(lowercase).to_tuple()

          a__			,							a__						:     str			=    model([input_ids_a, mems_a]).to_tuple()

          a__						:     Optional[Any]			=    {'input_ids': input_ids_a, 'mems': mems_a, 'labels': lm_labels}

          a__			,							a__						:     Any			=    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 							__lowercase		( self ,  lowercase ,  lowercase ,  lowercase ,  lowercase)      ->						str:







          '''simple docstring'''

          a__						:     Any			=    TFTransfoXLForSequenceClassification(lowercase)
          a__						:     Optional[Any]			=    model(lowercase)
          self.parent.assertEqual(result.logits.shape ,  (self.batch_size, self.num_labels))

   def 							__lowercase		( self)      ->						List[Any]:







          '''simple docstring'''

          a__						:     int			=    self.prepare_config_and_inputs()
          ((a__)			,							(a__)			,							(a__)			,							(a__))						:     Union[str, Any]			=    config_and_inputs
          a__						:     List[str]			=    {'input_ids': input_ids_a}
          return config, inputs_dict





@require_tf
class 			A__   (							__UpperCAmelCase			,  __UpperCAmelCase			,  unittest.TestCase     ):




   """simple docstring"""



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

   def 							__lowercase		( self ,  lowercase ,  lowercase ,  lowercase ,  lowercase ,  lowercase)      ->						str:







          '''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 							__lowercase		( self)      ->						Union[str, Any]:







          '''simple docstring'''

          a__						:     Optional[Any]			=    TFTransfoXLModelTester(self)
          a__						:     Dict			=    ConfigTester(self ,  config_class=lowercase ,  d_embed=37)

   def 							__lowercase		( self)      ->						Dict:







          '''simple docstring'''

          self.config_tester.run_common_tests()

   def 							__lowercase		( self)      ->						int:







          '''simple docstring'''

          self.model_tester.set_seed()
          a__						:     Tuple			=    self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_transfo_xl_model(*lowercase)

   def 							__lowercase		( self)      ->						int:







          '''simple docstring'''

          self.model_tester.set_seed()
          a__						:     Dict			=    self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_transfo_xl_lm_head(*lowercase)

   def 							__lowercase		( self)      ->						int:







          '''simple docstring'''

          a__						:     Any			=    self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_transfo_xl_for_sequence_classification(*lowercase)

   def 							__lowercase		( self)      ->						Tuple:







          '''simple docstring'''

          a__			,							a__						:     Optional[int]			=    self.model_tester.prepare_config_and_inputs_for_common()
          a__						:     Any			=    [TFTransfoXLForSequenceClassification]

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

   def 							__lowercase		( self)      ->						Optional[Any]:







          '''simple docstring'''

          pass

   @slow
   def 							__lowercase		( self)      ->						Optional[Any]:







          '''simple docstring'''

          for model_name in TF_TRANSFO_XL_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                 a__						:     Optional[Any]			=    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 							__lowercase		( self)      ->						List[str]:







          '''simple docstring'''

          pass





@require_tf
class 			A__   (							unittest.TestCase     ):




   """simple docstring"""



   @unittest.skip('Skip test until #12651 is resolved.')
   @slow
   def 							__lowercase		( self)      ->						int:







          '''simple docstring'''

          a__						:     Optional[int]			=    TFTransfoXLLMHeadModel.from_pretrained('transfo-xl-wt103')
          # fmt: off
          a__						:     str			=    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__						:     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__						:     int			=    model.generate(lowercase ,  max_length=200 ,  do_sample=lowercase)
          self.assertListEqual(output_ids[0].numpy().tolist() ,  lowercase)









def A_     (		A__    )  ->		int:

       if not isinstance(A__		,				A__    ):
              raise TypeError('only integers accepted as input'    )
       else:
              a__						:     List[Any]			=    str(abs(A__    )    )
              a__						:     Optional[int]			=    [list(A__    ) for char in range(len(A__    )    )]
              for index in range(len(A__    )    ):
                     num_transpositions[index].pop(A__    )
              return max(
                  int(''.join(list(A__    )    )    ) for transposition in num_transpositions    )


if __name__ == "__main__":
    __import__("""doctest""").testmod()


