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





     def __init__(self   :					Tuple       ,					_A   :					Optional[Any]       ,					)		->		List[str]:
         snake_case				  =      parent
         snake_case				  =      1_3
         snake_case				  =      7
         snake_case				  =      3_0
         snake_case				  =      self.seq_length + self.mem_len
         snake_case				  =      1_5
         snake_case				  =      True
         snake_case				  =      True
         snake_case				  =      9_9
         snake_case				  =      [1_0, 5_0, 8_0]
         snake_case				  =      3_2
         snake_case				  =      3_2
         snake_case				  =      4
         snake_case				  =      8
         snake_case				  =      1_2_8
         snake_case				  =      2
         snake_case				  =      2
         snake_case				  =      None
         snake_case				  =      1
         snake_case				  =      0
         snake_case				  =      3
         snake_case				  =      self.vocab_size - 1
         snake_case				  =      0.01





     def 	UpperCAmelCase(self   :					List[str]     )		->		int:
         snake_case				  =      ids_tensor([self.batch_size, self.seq_length]       ,					self.vocab_size     )
         snake_case				  =      ids_tensor([self.batch_size, self.seq_length]       ,					self.vocab_size     )

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

         snake_case				  =      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   :					Tuple     )		->		Optional[int]:
         random.seed(self.seed     )
         tf.random.set_seed(self.seed     )





     def 	UpperCAmelCase(self   :					str       ,					_A   :					List[str]       ,					_A   :					str       ,					_A   :					str       ,					_A   :					List[Any]     )		->		Optional[Any]:
         snake_case				  =      TFTransfoXLModel(lowercase__     )

         snake_case				  =      model(lowercase__     ).to_tuple()

         snake_case				  =      {'''input_ids''': input_ids_a, '''mems''': mems_a}

         snake_case				  =      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 	UpperCAmelCase(self   :					Tuple       ,					_A   :					str       ,					_A   :					List[Any]       ,					_A   :					Tuple       ,					_A   :					Dict     )		->		Optional[Any]:
         snake_case				  =      TFTransfoXLLMHeadModel(lowercase__     )

         snake_case				  =      model(lowercase__     ).to_tuple()

         snake_case				  =      {'''input_ids''': input_ids_a, '''labels''': lm_labels}
         snake_case				  =      model(lowercase__     ).to_tuple()

         snake_case				  =      model([input_ids_a, mems_a]     ).to_tuple()

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

         snake_case				  =      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 	UpperCAmelCase(self   :					Optional[int]       ,					_A   :					Optional[int]       ,					_A   :					Any       ,					_A   :					List[str]       ,					_A   :					Any     )		->		Tuple:
         snake_case				  =      TFTransfoXLForSequenceClassification(lowercase__     )
         snake_case				  =      model(lowercase__     )
         self.parent.assertEqual(result.logits.shape       ,					(self.batch_size, self.num_labels)     )





     def 	UpperCAmelCase(self   :					Dict     )		->		Dict:
         snake_case				  =      self.prepare_config_and_inputs()
         (snake_case)				  =      config_and_inputs
         snake_case				  =      {'''input_ids''': input_ids_a}
         return config, inputs_dict







@require_tf
class   lowerCamelCase	(						a__							,				a__							,				unittest.TestCase						):
     UpperCAmelCase__       :							List[str]     =	(
         (TFTransfoXLModel, TFTransfoXLLMHeadModel, TFTransfoXLForSequenceClassification) if is_tf_available() else ()
     )
     UpperCAmelCase__       :							Tuple     =	() if is_tf_available() else ()
     UpperCAmelCase__       :							Union[str, Any]     =	(
         {
             """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__       :							Optional[Any]     =	False
     UpperCAmelCase__       :							Tuple     =	False
     UpperCAmelCase__       :							Optional[int]     =	False
     UpperCAmelCase__       :							List[str]     =	False





     def 	UpperCAmelCase(self   :					List[Any]       ,					_A   :					str       ,					_A   :					int       ,					_A   :					List[str]       ,					_A   :					Dict       ,					_A   :					Optional[int]     )		->		Optional[Any]:





         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     )		->		Tuple:
         snake_case				  =      TFTransfoXLModelTester(self     )
         snake_case				  =      ConfigTester(self       ,					config_class=lowercase__       ,					d_embed=3_7     )





     def 	UpperCAmelCase(self   :					Any     )		->		List[str]:
         self.config_tester.run_common_tests()





     def 	UpperCAmelCase(self   :					List[Any]     )		->		List[Any]:
         self.model_tester.set_seed()
         snake_case				  =      self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_transfo_xl_model(*lowercase__     )





     def 	UpperCAmelCase(self   :					Optional[Any]     )		->		Union[str, Any]:
         self.model_tester.set_seed()
         snake_case				  =      self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_transfo_xl_lm_head(*lowercase__     )





     def 	UpperCAmelCase(self   :					List[str]     )		->		str:
         snake_case				  =      self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_transfo_xl_for_sequence_classification(*lowercase__     )





     def 	UpperCAmelCase(self   :					Any     )		->		List[Any]:
         snake_case				  =      self.model_tester.prepare_config_and_inputs_for_common()
         snake_case				  =      [TFTransfoXLForSequenceClassification]

         for model_class in self.all_model_classes:
             snake_case				  =      model_class(lowercase__     )
             assert isinstance(model.get_input_embeddings()       ,					tf.keras.layers.Layer     )
             if model_class in list_other_models_with_output_ebd:
                 snake_case				  =      model.get_output_embeddings()
                 assert isinstance(lowercase__       ,					tf.keras.layers.Layer     )
                 snake_case				  =      model.get_bias()
                 assert name is None
             else:
                 snake_case				  =      model.get_output_embeddings()
                 assert x is None
                 snake_case				  =      model.get_bias()
                 assert name is None





     def 	UpperCAmelCase(self   :					Any     )		->		Optional[int]:
         pass





     @slow
     def 	UpperCAmelCase(self   :					List[Any]     )		->		Optional[int]:





         for model_name in TF_TRANSFO_XL_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
             snake_case				  =      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 	UpperCAmelCase(self   :					Any     )		->		List[str]:
         pass







@require_tf
class   lowerCamelCase	(						unittest.TestCase						):





     @unittest.skip("Skip test until #12651 is resolved."     )
     @slow
     def 	UpperCAmelCase(self   :					Union[str, Any]     )		->		Any:
         snake_case				  =      TFTransfoXLLMHeadModel.from_pretrained("transfo-xl-wt103"     )
         # fmt: off
         snake_case				  =      tf.convert_to_tensor([[3_3,1_2_9_7,2,1,1_0_0_9,4,1_1_0_9,1_1_7_3_9,4_7_6_2,3_5_8,5,2_5,2_4_5,2_2,1_7_0_6,1_7,2_0_0_9_8,5,3_2_1_5,2_1,3_7,1_1_1_0,3,1_3,1_0_4_1,4,2_4,6_0_3,4_9_0,2,7_1_4_7_7,2_0_0_9_8,1_0_4_4_4_7,2,2_0_9_6_1,1,2_6_0_4,4,1,3_2_9,3,6_2_2_4,8_3_1,1_6_0_0_2,2,8,6_0_3,7_8_9_6_7,2_9_5_4_6,2_3,8_0_3,2_0,2_5,4_1_6,5,8,2_3_2,4,2_7_7,6,1_8_5_5,4_6_0_1,3,2_9_5_4_6,5_4,8,3_6_0_9,5,5_7_2_1_1,4_9,4,1,2_7_7,1_8,8,1_7_5_5,1_5_6_9_1,3,3_4_1,2_5,4_1_6,6_9_3,4_2_5_7_3,7_1,1_7,4_0_1,9_4,3_1,1_7_9_1_9,2,2_9_5_4_6,7_8_7_3,1_8,1,4_3_5,2_3,1_1_0_1_1,7_5_5,5,5_1_6_7,3,7_9_8_3,9_8,8_4,2,2_9_5_4_6,3_2_6_7,8,3_6_0_9,4,1,4_8_6_5,1_0_7_5,2,6_0_8_7,7_1,6,3_4_6,8,5_8_5_4,3,2_9_5_4_6,8_2_4,1_4_0_0,1_8_6_8,2,1_9,1_6_0,2,3_1_1,8,5_4_9_6,2,2_0_9_2_0,1_7,2_5,1_5_0_9_7,3,2_4,2_4,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				  =      [3_3,1_2_9_7,2,1,1_0_0_9,4,1_1_0_9,1_1_7_3_9,4_7_6_2,3_5_8,5,2_5,2_4_5,2_2,1_7_0_6,1_7,2_0_0_9_8,5,3_2_1_5,2_1,3_7,1_1_1_0,3,1_3,1_0_4_1,4,2_4,6_0_3,4_9_0,2,7_1_4_7_7,2_0_0_9_8,1_0_4_4_4_7,2,2_0_9_6_1,1,2_6_0_4,4,1,3_2_9,3,6_2_2_4,8_3_1,1_6_0_0_2,2,8,6_0_3,7_8_9_6_7,2_9_5_4_6,2_3,8_0_3,2_0,2_5,4_1_6,5,8,2_3_2,4,2_7_7,6,1_8_5_5,4_6_0_1,3,2_9_5_4_6,5_4,8,3_6_0_9,5,5_7_2_1_1,4_9,4,1,2_7_7,1_8,8,1_7_5_5,1_5_6_9_1,3,3_4_1,2_5,4_1_6,6_9_3,4_2_5_7_3,7_1,1_7,4_0_1,9_4,3_1,1_7_9_1_9,2,2_9_5_4_6,7_8_7_3,1_8,1,4_3_5,2_3,1_1_0_1_1,7_5_5,5,5_1_6_7,3,7_9_8_3,9_8,8_4,2,2_9_5_4_6,3_2_6_7,8,3_6_0_9,4,1,4_8_6_5,1_0_7_5,2,6_0_8_7,7_1,6,3_4_6,8,5_8_5_4,3,2_9_5_4_6,8_2_4,1_4_0_0,1_8_6_8,2,1_9,1_6_0,2,3_1_1,8,5_4_9_6,2,2_0_9_2_0,1_7,2_5,1_5_0_9_7,3,2_4,2_4,0,3_3,1,1_8_5_7,2,1,1_0_0_9,4,1_1_0_9,1_1_7_3_9,4_7_6_2,3_5_8,5,2_5,2_4_5,2_8,1_1_1_0,3,1_3,1_0_4_1,4,2_4,6_0_3,4_9_0,2,7_1_4_7_7,2_0_0_9_8,1_0_4_4_4_7,2,2_0_9_6_1,1,2_6_0_4,4,1,3_2_9,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				  =      model.generate(lowercase__       ,					max_length=2_0_0       ,					do_sample=lowercase__     )
         self.assertListEqual(output_ids[0].numpy().tolist()       ,					lowercase__     )



import unittest

import numpy as np

from transformers.testing_utils import require_torch, require_vision
from transformers.utils import is_torch_available, is_vision_available

from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs


if is_torch_available():
   import torch

if is_vision_available():
   from PIL import Image

   from transformers import MobileNetVaImageProcessor







class   lowerCamelCase	(						unittest.TestCase						):





     def __init__(self   :					Optional[int]       ,					_A   :					Dict       ,					_A   :					Optional[int]=7       ,					_A   :					Union[str, Any]=3       ,					_A   :					Tuple=1_8       ,					_A   :					str=3_0       ,					_A   :					Union[str, Any]=4_0_0       ,					_A   :					Optional[Any]=True       ,					_A   :					Union[str, Any]=None       ,					_A   :					str=True       ,					_A   :					Optional[int]=None       ,					)		->		int:
         snake_case				  =      size if size is not None else {"shortest_edge": 2_0}
         snake_case				  =      crop_size if crop_size is not None else {"height": 1_8, "width": 1_8}
         snake_case				  =      parent
         snake_case				  =      batch_size
         snake_case				  =      num_channels
         snake_case				  =      image_size
         snake_case				  =      min_resolution
         snake_case				  =      max_resolution
         snake_case				  =      do_resize
         snake_case				  =      size
         snake_case				  =      do_center_crop
         snake_case				  =      crop_size





     def 	UpperCAmelCase(self   :					str     )		->		int:
         return {
             "do_resize": self.do_resize,
             "size": self.size,
             "do_center_crop": self.do_center_crop,
             "crop_size": self.crop_size,
         }







@require_torch
@require_vision
class   lowerCamelCase	(						A_							,				unittest.TestCase						):
     UpperCAmelCase__       :							Optional[int]     =	MobileNetVaImageProcessor if is_vision_available() else None





     def 	UpperCAmelCase(self   :					Dict     )		->		List[Any]:
         snake_case				  =      MobileNetVaImageProcessingTester(self     )





     @property
     def 	UpperCAmelCase(self   :					Union[str, Any]     )		->		Tuple:
         return self.image_processor_tester.prepare_image_processor_dict()





     def 	UpperCAmelCase(self   :					Tuple     )		->		Tuple:
         snake_case				  =      self.image_processing_class(**self.image_processor_dict     )
         self.assertTrue(hasattr(_A       ,					"do_resize"     )     )
         self.assertTrue(hasattr(_A       ,					"size"     )     )
         self.assertTrue(hasattr(_A       ,					"do_center_crop"     )     )
         self.assertTrue(hasattr(_A       ,					"crop_size"     )     )





     def 	UpperCAmelCase(self   :					int     )		->		List[Any]:
         snake_case				  =      self.image_processing_class.from_dict(self.image_processor_dict     )
         self.assertEqual(image_processor.size       ,					{"shortest_edge": 2_0}     )
         self.assertEqual(image_processor.crop_size       ,					{"height": 1_8, "width": 1_8}     )

         snake_case				  =      self.image_processing_class.from_dict(self.image_processor_dict       ,					size=4_2       ,					crop_size=8_4     )
         self.assertEqual(image_processor.size       ,					{"shortest_edge": 4_2}     )
         self.assertEqual(image_processor.crop_size       ,					{"height": 8_4, "width": 8_4}     )





     def 	UpperCAmelCase(self   :					Any     )		->		Tuple:
         pass





     def 	UpperCAmelCase(self   :					Tuple     )		->		Tuple:
         # Initialize image_processing
         snake_case				  =      self.image_processing_class(**self.image_processor_dict     )
         # create random PIL images
         snake_case				  =      prepare_image_inputs(self.image_processor_tester       ,					equal_resolution=_A     )
         for image in image_inputs:
             self.assertIsInstance(_A       ,					Image.Image     )

         # Test not batched input
         snake_case				  =      image_processing(image_inputs[0]       ,					return_tensors="pt"     ).pixel_values
         self.assertEqual(
             encoded_images.shape       ,					(
                 1,
                 self.image_processor_tester.num_channels,
                 self.image_processor_tester.crop_size["height"],
                 self.image_processor_tester.crop_size["width"],
             )       ,					)

         # Test batched
         snake_case				  =      image_processing(_A       ,					return_tensors="pt"     ).pixel_values
         self.assertEqual(
             encoded_images.shape       ,					(
                 self.image_processor_tester.batch_size,
                 self.image_processor_tester.num_channels,
                 self.image_processor_tester.crop_size["height"],
                 self.image_processor_tester.crop_size["width"],
             )       ,					)





     def 	UpperCAmelCase(self   :					Tuple     )		->		List[Any]:
         # Initialize image_processing
         snake_case				  =      self.image_processing_class(**self.image_processor_dict     )
         # create random numpy tensors
         snake_case				  =      prepare_image_inputs(self.image_processor_tester       ,					equal_resolution=_A       ,					numpify=_A     )
         for image in image_inputs:
             self.assertIsInstance(_A       ,					np.ndarray     )

         # Test not batched input
         snake_case				  =      image_processing(image_inputs[0]       ,					return_tensors="pt"     ).pixel_values
         self.assertEqual(
             encoded_images.shape       ,					(
                 1,
                 self.image_processor_tester.num_channels,
                 self.image_processor_tester.crop_size["height"],
                 self.image_processor_tester.crop_size["width"],
             )       ,					)

         # Test batched
         snake_case				  =      image_processing(_A       ,					return_tensors="pt"     ).pixel_values
         self.assertEqual(
             encoded_images.shape       ,					(
                 self.image_processor_tester.batch_size,
                 self.image_processor_tester.num_channels,
                 self.image_processor_tester.crop_size["height"],
                 self.image_processor_tester.crop_size["width"],
             )       ,					)





     def 	UpperCAmelCase(self   :					List[str]     )		->		List[str]:
         # Initialize image_processing
         snake_case				  =      self.image_processing_class(**self.image_processor_dict     )
         # create random PyTorch tensors
         snake_case				  =      prepare_image_inputs(self.image_processor_tester       ,					equal_resolution=_A       ,					torchify=_A     )
         for image in image_inputs:
             self.assertIsInstance(_A       ,					torch.Tensor     )

         # Test not batched input
         snake_case				  =      image_processing(image_inputs[0]       ,					return_tensors="pt"     ).pixel_values
         self.assertEqual(
             encoded_images.shape       ,					(
                 1,
                 self.image_processor_tester.num_channels,
                 self.image_processor_tester.crop_size["height"],
                 self.image_processor_tester.crop_size["width"],
             )       ,					)

         # Test batched
         snake_case				  =      image_processing(_A       ,					return_tensors="pt"     ).pixel_values
         self.assertEqual(
             encoded_images.shape       ,					(
                 self.image_processor_tester.batch_size,
                 self.image_processor_tester.num_channels,
                 self.image_processor_tester.crop_size["height"],
                 self.image_processor_tester.crop_size["width"],
             )       ,					)

