"""simple docstring"""



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							:     Dict	,      A_							:     Any	,      )    ->       List[Any]:
         __snake_case				=							parent
         __snake_case				=							13
         __snake_case				=							7
         __snake_case				=							30
         __snake_case				=							self.seq_length + self.mem_len
         __snake_case				=							15
         __snake_case				=							True
         __snake_case				=							True
         __snake_case				=							99
         __snake_case				=							[10, 50, 80]
         __snake_case				=							32
         __snake_case				=							32
         __snake_case				=							4
         __snake_case				=							8
         __snake_case				=							128
         __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  lowercase					(		self							:     Optional[Any]    )    ->       Optional[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  lowercase					(		self							:     Optional[Any]    )    ->       int:
         random.seed(self.seed    )
         tf.random.set_seed(self.seed    )
    def  lowercase					(		self							:     Any	,      A_							:     str	,      A_							:     Tuple	,      A_							:     Union[str, Any]	,      A_							:     List[str]    )    ->       List[str]:
         __snake_case				=							TFTransfoXLModel(A_    )

         __snake_case		,	__snake_case				=							model(A_    ).to_tuple()

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

         __snake_case		,	__snake_case				=							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  lowercase					(		self							:     Union[str, Any]	,      A_							:     Optional[Any]	,      A_							:     str	,      A_							:     Optional[Any]	,      A_							:     Union[str, Any]    )    ->       List[str]:
         __snake_case				=							TFTransfoXLLMHeadModel(A_    )

         __snake_case		,	__snake_case				=							model(A_    ).to_tuple()

         __snake_case				=							{'''input_ids''': input_ids_a, '''labels''': lm_labels}
         __snake_case		,	__snake_case				=							model(A_    ).to_tuple()

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







    def  lowercase					(		self							:     int    )    ->       int:
         __snake_case				=							self.prepare_config_and_inputs()
         ((__snake_case)		,	(__snake_case)		,	(__snake_case)		,	(__snake_case))				=							config_and_inputs
         __snake_case				=							{'''input_ids''': input_ids_a}
         return config, inputs_dict






@require_tf
class      _A	(						_UpperCAmelCase							, _UpperCAmelCase							, unittest.TestCase					):




    """simple docstring"""




    UpperCamelCase_	:					Union[str, Any]							=					(
        (TFTransfoXLModel, TFTransfoXLLMHeadModel, TFTransfoXLForSequenceClassification) if is_tf_available() else ()
    )
    UpperCamelCase_	:					Optional[Any]							=					() if is_tf_available() else ()
    UpperCamelCase_	:					int							=					(
        {
            '''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[str]							=					False
    UpperCamelCase_	:					str							=					False
    UpperCamelCase_	:					Any							=					False
    def  lowercase					(		self							:     int	,      A_							:     Union[str, Any]	,      A_							:     Optional[int]	,      A_							:     Dict	,      A_							:     Optional[Any]	,      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  lowercase					(		self							:     int    )    ->       Any:
         __snake_case				=							TFTransfoXLModelTester(self    )
         __snake_case				=							ConfigTester(self	,      config_class=A_	,      d_embed=37    )
    def  lowercase					(		self							:     str    )    ->       Any:
         self.config_tester.run_common_tests()
    def  lowercase					(		self							:     Optional[Any]    )    ->       int:
         self.model_tester.set_seed()
         __snake_case				=							self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_transfo_xl_model(*A_    )
    def  lowercase					(		self							:     List[str]    )    ->       Optional[int]:
         self.model_tester.set_seed()
         __snake_case				=							self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_transfo_xl_lm_head(*A_    )
    def  lowercase					(		self							:     Tuple    )    ->       int:
         __snake_case				=							self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_transfo_xl_for_sequence_classification(*A_    )
    def  lowercase					(		self							:     str    )    ->       List[Any]:
         __snake_case		,	__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(A_    )
              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(A_	,      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  lowercase					(		self							:     Optional[int]    )    ->       Tuple:
         # TODO JP: Make TransfoXL XLA compliant
         pass
    @slow
    def  lowercase					(		self							:     str    )    ->       List[Any]:
         for model_name in TF_TRANSFO_XL_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
              __snake_case				=							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  lowercase					(		self							:     List[str]    )    ->       List[str]:
         pass






@require_tf
class      _A	(						unittest.TestCase					):




    """simple docstring"""




    @unittest.skip('''Skip test until #12651 is resolved.'''    )
    @slow
    def  lowercase					(		self							:     Optional[Any]    )    ->       Any:
         __snake_case				=							TFTransfoXLLMHeadModel.from_pretrained('''transfo-xl-wt103'''    )
         # fmt: off
         __snake_case				=							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				=							[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				=							model.generate(A_	,      max_length=200	,      do_sample=A_    )
         self.assertListEqual(output_ids[0].numpy().tolist()	,      A_    )
"""simple docstring"""



import json
import os
import shutil
import tempfile
import unittest

import numpy as np
import pytest

from transformers import BertTokenizer, BertTokenizerFast
from transformers.models.bert.tokenization_bert import VOCAB_FILES_NAMES
from transformers.testing_utils import require_vision
from transformers.utils import FEATURE_EXTRACTOR_NAME, is_vision_available


if is_vision_available():
       from PIL import Image

       from transformers import ChineseCLIPImageProcessor, ChineseCLIPProcessor



@require_vision
class      _A	(						unittest.TestCase					):




    """simple docstring"""




    def  lowercase					(		self							:     Optional[Any]    )    ->       Optional[Any]:
         __snake_case				=							tempfile.mkdtemp()

         __snake_case				=							[
             '''[UNK]''',
             '''[CLS]''',
             '''[SEP]''',
             '''[PAD]''',
             '''[MASK]''',
             '''的''',
             '''价''',
             '''格''',
             '''是''',
             '''15''',
             '''便''',
             '''alex''',
             '''##andra''',
             '''，''',
             '''。''',
             '''-''',
             '''t''',
             '''shirt''',
         ]
         __snake_case				=							os.path.join(self.tmpdirname	,      VOCAB_FILES_NAMES['''vocab_file''']    )
         with open(self.vocab_file	,      '''w'''	,      encoding='''utf-8'''    ) as vocab_writer:
              vocab_writer.write(''''''.join([x + '''\n''' for x in vocab_tokens]    )    )

         __snake_case				=							{
             '''do_resize''': True,
             '''size''': {'''height''': 224, '''width''': 224},
             '''do_center_crop''': True,
             '''crop_size''': {'''height''': 18, '''width''': 18},
             '''do_normalize''': True,
             '''image_mean''': [0.48_14_54_66, 0.4_57_82_75, 0.40_82_10_73],
             '''image_std''': [0.26_86_29_54, 0.26_13_02_58, 0.27_57_77_11],
             '''do_convert_rgb''': True,
         }
         __snake_case				=							os.path.join(self.tmpdirname	,      A_    )
         with open(self.image_processor_file	,      '''w'''	,      encoding='''utf-8'''    ) as fp:
              json.dump(A_	,      A_    )
    def  lowercase					(		self							:     str	,      **A_							:     str    )    ->       Dict:
         return BertTokenizer.from_pretrained(self.tmpdirname	,      **A_    )
    def  lowercase					(		self							:     Optional[int]	,      **A_							:     Optional[int]    )    ->       Tuple:
         return BertTokenizerFast.from_pretrained(self.tmpdirname	,      **A_    )
    def  lowercase					(		self							:     Tuple	,      **A_							:     Any    )    ->       Any:
         return ChineseCLIPImageProcessor.from_pretrained(self.tmpdirname	,      **A_    )
    def  lowercase					(		self							:     Optional[Any]    )    ->       int:
         shutil.rmtree(self.tmpdirname    )
    def  lowercase					(		self							:     Dict    )    ->       Dict:
         __snake_case				=							[np.random.randint(255	,      size=(3, 30, 400)	,      dtype=np.uinta    )]

         __snake_case				=							[Image.fromarray(np.moveaxis(A_	,      0	,      -1    )    ) for x in image_inputs]

         return image_inputs
    def  lowercase					(		self							:     Tuple    )    ->       Any:
         __snake_case				=							self.get_tokenizer()
         __snake_case				=							self.get_rust_tokenizer()
         __snake_case				=							self.get_image_processor()

         __snake_case				=							ChineseCLIPProcessor(tokenizer=A_	,      image_processor=A_    )
         processor_slow.save_pretrained(self.tmpdirname    )
         __snake_case				=							ChineseCLIPProcessor.from_pretrained(self.tmpdirname	,      use_fast=A_    )

         __snake_case				=							ChineseCLIPProcessor(tokenizer=A_	,      image_processor=A_    )
         processor_fast.save_pretrained(self.tmpdirname    )
         __snake_case				=							ChineseCLIPProcessor.from_pretrained(self.tmpdirname    )

         self.assertEqual(processor_slow.tokenizer.get_vocab()	,      tokenizer_slow.get_vocab()    )
         self.assertEqual(processor_fast.tokenizer.get_vocab()	,      tokenizer_fast.get_vocab()    )
         self.assertEqual(tokenizer_slow.get_vocab()	,      tokenizer_fast.get_vocab()    )
         self.assertIsInstance(processor_slow.tokenizer	,      A_    )
         self.assertIsInstance(processor_fast.tokenizer	,      A_    )

         self.assertEqual(processor_slow.image_processor.to_json_string()	,      image_processor.to_json_string()    )
         self.assertEqual(processor_fast.image_processor.to_json_string()	,      image_processor.to_json_string()    )
         self.assertIsInstance(processor_slow.image_processor	,      A_    )
         self.assertIsInstance(processor_fast.image_processor	,      A_    )
    def  lowercase					(		self							:     int    )    ->       Union[str, Any]:
         __snake_case				=							ChineseCLIPProcessor(tokenizer=self.get_tokenizer()	,      image_processor=self.get_image_processor()    )
         processor.save_pretrained(self.tmpdirname    )

         __snake_case				=							self.get_tokenizer(cls_token='''(CLS)'''	,      sep_token='''(SEP)'''    )
         __snake_case				=							self.get_image_processor(do_normalize=A_    )

         __snake_case				=							ChineseCLIPProcessor.from_pretrained(
             self.tmpdirname	,      cls_token='''(CLS)'''	,      sep_token='''(SEP)'''	,      do_normalize=A_    )

         self.assertEqual(processor.tokenizer.get_vocab()	,      tokenizer_add_kwargs.get_vocab()    )
         self.assertIsInstance(processor.tokenizer	,      A_    )

         self.assertEqual(processor.image_processor.to_json_string()	,      image_processor_add_kwargs.to_json_string()    )
         self.assertIsInstance(processor.image_processor	,      A_    )
    def  lowercase					(		self							:     Optional[int]    )    ->       int:
         __snake_case				=							self.get_image_processor()
         __snake_case				=							self.get_tokenizer()

         __snake_case				=							ChineseCLIPProcessor(tokenizer=A_	,      image_processor=A_    )

         __snake_case				=							self.prepare_image_inputs()

         __snake_case				=							image_processor(A_	,      return_tensors='''np'''    )
         __snake_case				=							processor(images=A_	,      return_tensors='''np'''    )

         for key in input_feat_extract.keys():
              self.assertAlmostEqual(input_feat_extract[key].sum()	,      input_processor[key].sum()	,      delta=1E-2    )
    def  lowercase					(		self							:     str    )    ->       str:
         __snake_case				=							self.get_image_processor()
         __snake_case				=							self.get_tokenizer()

         __snake_case				=							ChineseCLIPProcessor(tokenizer=A_	,      image_processor=A_    )

         __snake_case				=							'''Alexandra，T-shirt的价格是15便士。'''

         __snake_case				=							processor(text=A_    )

         __snake_case				=							tokenizer(A_    )

         for key in encoded_tok.keys():
              self.assertListEqual(encoded_tok[key]	,      encoded_processor[key]    )
    def  lowercase					(		self							:     Optional[int]    )    ->       Dict:
         __snake_case				=							self.get_image_processor()
         __snake_case				=							self.get_tokenizer()

         __snake_case				=							ChineseCLIPProcessor(tokenizer=A_	,      image_processor=A_    )

         __snake_case				=							'''Alexandra，T-shirt的价格是15便士。'''
         __snake_case				=							self.prepare_image_inputs()

         __snake_case				=							processor(text=A_	,      images=A_    )

         self.assertListEqual(list(inputs.keys()    )	,      ['''input_ids''', '''token_type_ids''', '''attention_mask''', '''pixel_values''']    )

         # test if it raises when no input is passed
         with pytest.raises(A_    ):
              processor()
    def  lowercase					(		self							:     str    )    ->       int:
         __snake_case				=							self.get_image_processor()
         __snake_case				=							self.get_tokenizer()

         __snake_case				=							ChineseCLIPProcessor(tokenizer=A_	,      image_processor=A_    )

         __snake_case				=							[[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]

         __snake_case				=							processor.batch_decode(A_    )
         __snake_case				=							tokenizer.batch_decode(A_    )

         self.assertListEqual(A_	,      A_    )







    def  lowercase					(		self							:     int    )    ->       Optional[Any]:
         __snake_case				=							self.get_image_processor()
         __snake_case				=							self.get_tokenizer()

         __snake_case				=							ChineseCLIPProcessor(tokenizer=A_	,      image_processor=A_    )

         __snake_case				=							'''Alexandra，T-shirt的价格是15便士。'''
         __snake_case				=							self.prepare_image_inputs()

         __snake_case				=							processor(text=A_	,      images=A_    )

         self.assertListEqual(list(inputs.keys()    )	,      processor.model_input_names    )