

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





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





    def 				snake_case_    (				self):
         lowercase__   :       Dict				=	ids_tensor([self.batch_size, self.seq_length]						,       self.vocab_size)
         lowercase__   :       int				=	ids_tensor([self.batch_size, self.seq_length]						,       self.vocab_size)

         lowercase__   :       Dict				=	None
         if self.use_labels:
              lowercase__   :       List[Any]				=	ids_tensor([self.batch_size, self.seq_length]						,       self.vocab_size)

         lowercase__   :       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 				snake_case_    (				self):
         random.seed(self.seed)
         tf.random.set_seed(self.seed)





    def 				snake_case_    (				self						,       a						,       a						,       a						,       a):
         lowercase__   :       int				=	TFTransfoXLModel(a)

         lowercase__				,			lowercase__   :       int				=	model(a).to_tuple()

         lowercase__   :       List[str]				=	{'input_ids': input_ids_a, 'mems': mems_a}

         lowercase__				,			lowercase__   :       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 				snake_case_    (				self						,       a						,       a						,       a						,       a):
         lowercase__   :       Optional[Any]				=	TFTransfoXLLMHeadModel(a)

         lowercase__				,			lowercase__   :       Tuple				=	model(a).to_tuple()

         lowercase__   :       Optional[Any]				=	{'input_ids': input_ids_a, 'labels': lm_labels}
         lowercase__				,			lowercase__   :       Dict				=	model(a).to_tuple()

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

         lowercase__   :       List[Any]				=	{'input_ids': input_ids_a, 'mems': mems_a, 'labels': lm_labels}

         lowercase__				,			lowercase__   :       int				=	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 				snake_case_    (				self						,       a						,       a						,       a						,       a):
         lowercase__   :       Dict				=	TFTransfoXLForSequenceClassification(a)
         lowercase__   :       Dict				=	model(a)
         self.parent.assertEqual(result.logits.shape						,       (self.batch_size, self.num_labels))





    def 				snake_case_    (				self):
         lowercase__   :       List[Any]				=	self.prepare_config_and_inputs()
         ((lowercase__)				,			(lowercase__)				,			(lowercase__)				,			(lowercase__))   :       Dict				=	config_and_inputs
         lowercase__   :       List[str]				=	{'input_ids': input_ids_a}
         return config, inputs_dict



@require_tf
class 				SCREAMING_SNAKE_CASE__ (__snake_case		,	__snake_case		,	unittest.TestCase					):
    __lowerCamelCase						:	Any														=					(
        (TFTransfoXLModel, TFTransfoXLLMHeadModel, TFTransfoXLForSequenceClassification) if is_tf_available() else ()
    )
    __lowerCamelCase						:	int														=					() if is_tf_available() else ()
    __lowerCamelCase						:	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
    __lowerCamelCase						:	Optional[Any]														=					False
    __lowerCamelCase						:	str														=					False
    __lowerCamelCase						:	int														=					False
    __lowerCamelCase						:	Any														=					False





    def 				snake_case_    (				self						,       a						,       a						,       a						,       a						,       a):
         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):
         lowercase__   :       Tuple				=	TFTransfoXLModelTester(self)
         lowercase__   :       List[str]				=	ConfigTester(self						,       config_class=a						,       d_embed=37)





    def 				snake_case_    (				self):
         self.config_tester.run_common_tests()





    def 				snake_case_    (				self):
         self.model_tester.set_seed()
         lowercase__   :       int				=	self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_transfo_xl_model(*a)





    def 				snake_case_    (				self):
         self.model_tester.set_seed()
         lowercase__   :       List[Any]				=	self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_transfo_xl_lm_head(*a)





    def 				snake_case_    (				self):
         lowercase__   :       int				=	self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_transfo_xl_for_sequence_classification(*a)





    def 				snake_case_    (				self):
         lowercase__				,			lowercase__   :       Optional[Any]				=	self.model_tester.prepare_config_and_inputs_for_common()
         lowercase__   :       Optional[Any]				=	[TFTransfoXLForSequenceClassification]

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





    def 				snake_case_    (				self):
         # TODO JP: Make TransfoXL XLA compliant
         pass





    @slow
    def 				snake_case_    (				self):
         for model_name in TF_TRANSFO_XL_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
              lowercase__   :       Union[str, Any]				=	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 				snake_case_    (				self):
         pass



@require_tf
class 				SCREAMING_SNAKE_CASE__ (unittest.TestCase					):





    @unittest.skip('Skip test until #12651 is resolved.')
    @slow
    def 				snake_case_    (				self):
         lowercase__   :       Tuple				=	TFTransfoXLLMHeadModel.from_pretrained('transfo-xl-wt103')
         # fmt: off
         lowercase__   :       Optional[int]				=	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
         lowercase__   :       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>

         lowercase__   :       Tuple				=	model.generate(a						,       max_length=200						,       do_sample=a)
         self.assertListEqual(output_ids[0].numpy().tolist()						,       a)




import warnings
from typing import List, Optional, Union

from ...processing_utils import ProcessorMixin
from ...tokenization_utils_base import BatchEncoding, PaddingStrategy, PreTokenizedInput, TextInput, TruncationStrategy
from ...utils import TensorType


class 				SCREAMING_SNAKE_CASE__ (__snake_case					):
    __lowerCamelCase						:	Tuple														=					["""image_processor""", """tokenizer"""]
    __lowerCamelCase						:	int														=					"""ViltImageProcessor"""
    __lowerCamelCase						:	Union[str, Any]														=					("""BertTokenizer""", """BertTokenizerFast""")





    def __init__(				self						,       a=None						,       a=None						,       **a):
         lowercase__   :       Any				=	None
         if "feature_extractor" in kwargs:
              warnings.warn(
                  'The `feature_extractor` argument is deprecated and will be removed in v5, use `image_processor`'
                  ' instead.'						,       a						,       )
              lowercase__   :       Union[str, Any]				=	kwargs.pop('feature_extractor')

         lowercase__   :       List[Any]				=	image_processor if image_processor is not None else feature_extractor
         if image_processor is None:
              raise ValueError('You need to specify an `image_processor`.')
         if tokenizer is None:
              raise ValueError('You need to specify a `tokenizer`.')

         super().__init__(a						,       a)
         lowercase__   :       str				=	self.image_processor





    def __call__(				self						,       a						,       a = None						,       a = True						,       a = False						,       a = None						,       a = None						,       a = 0						,       a = None						,       a = None						,       a = None						,       a = False						,       a = False						,       a = False						,       a = False						,       a = True						,       a = None						,       **a						,       ):
         lowercase__   :       Optional[Any]				=	self.tokenizer(
             text=a						,       add_special_tokens=a						,       padding=a						,       truncation=a						,       max_length=a						,       stride=a						,       pad_to_multiple_of=a						,       return_token_type_ids=a						,       return_attention_mask=a						,       return_overflowing_tokens=a						,       return_special_tokens_mask=a						,       return_offsets_mapping=a						,       return_length=a						,       verbose=a						,       return_tensors=a						,       **a						,       )
         # add pixel_values + pixel_mask
         lowercase__   :       str				=	self.image_processor(a						,       return_tensors=a)
         encoding.update(a)

         return encoding





    def 				snake_case_    (				self						,       *a						,       **a):
         return self.tokenizer.batch_decode(*a						,       **a)





    def 				snake_case_    (				self						,       *a						,       **a):
         return self.tokenizer.decode(*a						,       **a)





    @property
    def 				snake_case_    (				self):
         lowercase__   :       int				=	self.tokenizer.model_input_names
         lowercase__   :       List[str]				=	self.image_processor.model_input_names
         return list(dict.fromkeys(tokenizer_input_names + image_processor_input_names))





    @property
    def 				snake_case_    (				self):
         warnings.warn(
             '`feature_extractor_class` is deprecated and will be removed in v5. Use `image_processor_class` instead.'						,       a						,       )
         return self.image_processor_class





    @property
    def 				snake_case_    (				self):
         warnings.warn(
             '`feature_extractor` is deprecated and will be removed in v5. Use `image_processor` instead.'						,       a						,       )
         return self.image_processor

