





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





       '''simple docstring'''







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




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

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

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




       def 							UpperCAmelCase__ (  self :    Any							,				A :    int							,				A :    str							,				A :    List[Any]							,				A :    int		):
         __snake_case:						List[Any]   =						TFTransfoXLModel(lowerCAmelCase__		)

         __snake_case:						Dict   =						model(lowerCAmelCase__		).to_tuple()

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

         __snake_case:						str   =						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 							UpperCAmelCase__ (  self :    int							,				A :    List[str]							,				A :    List[Any]							,				A :    Optional[Any]							,				A :    List[str]		):
         __snake_case:						Union[str, Any]   =						TFTransfoXLLMHeadModel(lowerCAmelCase__		)

         __snake_case:						Optional[Any]   =						model(lowerCAmelCase__		).to_tuple()

         __snake_case:						Optional[int]   =						{"input_ids": input_ids_a, "labels": lm_labels}
         __snake_case:						Optional[int]   =						model(lowerCAmelCase__		).to_tuple()

         __snake_case:						int   =						model([input_ids_a, mems_a]		).to_tuple()

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

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






       def 							UpperCAmelCase__ (  self :    Any		):
         __snake_case:						int   =						self.prepare_config_and_inputs()
         (__snake_case):						List[Any]   =						config_and_inputs
         __snake_case:						List[str]   =						{"input_ids": input_ids_a}
         return config, inputs_dict







@require_tf
class     __snake_case       (							UpperCamelCase__   ,			UpperCamelCase__   ,			unittest.TestCase			):





       '''simple docstring'''







       lowerCAmelCase__      		=     (
           (TFTransfoXLModel, TFTransfoXLLMHeadModel, TFTransfoXLForSequenceClassification) if is_tf_available() else ()
       )
       lowerCAmelCase__      		=     () if is_tf_available() else ()
       lowerCAmelCase__      		=     (
           {
               """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
       lowerCAmelCase__      		=     False
       lowerCAmelCase__      		=     False
       lowerCAmelCase__      		=     False
       lowerCAmelCase__      		=     False




       def 							UpperCAmelCase__ (  self :    List[str]							,				A :    str							,				A :    List[Any]							,				A :    int							,				A :    List[str]							,				A :    str		):




         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 :    Dict		):
         __snake_case:						Tuple   =						TFTransfoXLModelTester(self		)
         __snake_case:						List[Any]   =						ConfigTester(self							,				config_class=lowerCAmelCase__							,				d_embed=37		)




       def 							UpperCAmelCase__ (  self :    List[Any]		):
         self.config_tester.run_common_tests()




       def 							UpperCAmelCase__ (  self :    List[Any]		):
         self.model_tester.set_seed()
         __snake_case:						List[Any]   =						self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_transfo_xl_model(*lowerCAmelCase__		)




       def 							UpperCAmelCase__ (  self :    str		):
         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_lm_head(*lowerCAmelCase__		)




       def 							UpperCAmelCase__ (  self :    Optional[int]		):
         __snake_case:						int   =						self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_transfo_xl_for_sequence_classification(*lowerCAmelCase__		)




       def 							UpperCAmelCase__ (  self :    str		):
         __snake_case:						List[str]   =						self.model_tester.prepare_config_and_inputs_for_common()
         __snake_case:						str   =						[TFTransfoXLForSequenceClassification]

         for model_class in self.all_model_classes:
           __snake_case:						Dict   =						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:						Union[str, Any]   =						model.get_output_embeddings()
             assert isinstance(lowerCAmelCase__							,				tf.keras.layers.Layer		)
             __snake_case:						str   =						model.get_bias()
             assert name is None
           else:
             __snake_case:						Dict   =						model.get_output_embeddings()
             assert x is None
             __snake_case:						Dict   =						model.get_bias()
             assert name is None




       def 							UpperCAmelCase__ (  self :    Union[str, Any]		):
         pass




       @slow
       def 							UpperCAmelCase__ (  self :    str		):




         for model_name in TF_TRANSFO_XL_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
           __snake_case:						str   =						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 							UpperCAmelCase__ (  self :    Union[str, Any]		):
         pass







@require_tf
class     __snake_case       (							unittest.TestCase			):





       '''simple docstring'''







       @unittest.skip("""Skip test until #12651 is resolved."""		)
       @slow
       def 							UpperCAmelCase__ (  self :    Tuple		):
         __snake_case:						str   =						TFTransfoXLLMHeadModel.from_pretrained("""transfo-xl-wt103"""		)
         # fmt: off
         __snake_case:						Tuple   =						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
         __snake_case:						Union[str, Any]   =						[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>

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













from ...configuration_utils import PretrainedConfig
from ...utils import logging


UpperCAmelCase	:	Optional[Any]		     =       logging.get_logger(__name__)

UpperCAmelCase	:	Optional[int]		     =       {
    """google/canine-s""": """https://huggingface.co/google/canine-s/resolve/main/config.json""",
    # See all CANINE models at https://huggingface.co/models?filter=canine
}







class 				__lowerCAmelCase       (    UpperCamelCase__):
      _lowercase				:					List[Any]						=			"""canine"""







      def __init__(    self		,      lowerCAmelCase__=7_6_8		,      lowerCAmelCase__=1_2		,      lowerCAmelCase__=1_2		,      lowerCAmelCase__=3_0_7_2		,      lowerCAmelCase__="gelu"		,      lowerCAmelCase__=0.1		,      lowerCAmelCase__=0.1		,      lowerCAmelCase__=1_6_3_8_4		,      lowerCAmelCase__=1_6		,      lowerCAmelCase__=0.02		,      lowerCAmelCase__=1E-12		,      lowerCAmelCase__=0		,      lowerCAmelCase__=0XE0_00		,      lowerCAmelCase__=0XE0_01		,      lowerCAmelCase__=4		,      lowerCAmelCase__=4		,      lowerCAmelCase__=8		,      lowerCAmelCase__=1_6_3_8_4		,      lowerCAmelCase__=1_2_8		,      **lowerCAmelCase__		,      )   ->						Dict:



        '''simple docstring'''




        super().__init__(pad_token_id=lowerCAmelCase__		,      bos_token_id=lowerCAmelCase__		,      eos_token_id=lowerCAmelCase__		,      **lowerCAmelCase__							)

        a__	:					Optional[int]										=max_position_embeddings
        a__	:					str										=hidden_size
        a__	:					Optional[Any]										=num_hidden_layers
        a__	:					Tuple										=num_attention_heads
        a__	:					Optional[Any]										=intermediate_size
        a__	:					Optional[int]										=hidden_act
        a__	:					List[Any]										=hidden_dropout_prob
        a__	:					Union[str, Any]										=attention_probs_dropout_prob
        a__	:					Optional[Any]										=initializer_range
        a__	:					Union[str, Any]										=type_vocab_size
        a__	:					Optional[int]										=layer_norm_eps

        # Character config:
        a__	:					int										=downsampling_rate
        a__	:					Optional[Any]										=upsampling_kernel_size
        a__	:					Union[str, Any]										=num_hash_functions
        a__	:					Any										=num_hash_buckets
        a__	:					int										=local_transformer_stride






