


import os
import sys
import unittest


snake_case    :   Optional[int]	    =					os.path.abspath(os.path.dirname(os.path.dirname(os.path.dirname(__file__))))
sys.path.append(os.path.join(git_repo_path, '''utils'''))

import check_dummies  # noqa: E402
from check_dummies import create_dummy_files, create_dummy_object, find_backend, read_init  # noqa: E402


# Align TRANSFORMERS_PATH in check_dummies with the current path
snake_case    :   Tuple	    =					os.path.join(git_repo_path, '''src''', '''diffusers''')







class 		_snake_case  (				unittest.TestCase							):




 def 	SCREAMING_SNAKE_CASE__    (		self   ):
       a						:Dict										=	find_backend('''    if not is_torch_available():'''   )
       self.assertEqual(_lowerCamelCase ,  '''torch'''   )

       # backend_with_underscore = find_backend("    if not is_tensorflow_text_available():")
       # self.assertEqual(backend_with_underscore, "tensorflow_text")

       a						:Union[str, Any]										=	find_backend('''    if not (is_torch_available() and is_transformers_available()):'''   )
       self.assertEqual(_lowerCamelCase ,  '''torch_and_transformers'''   )

       # double_backend_with_underscore = find_backend(
       #    "    if not (is_sentencepiece_available() and is_tensorflow_text_available()):"
       # )
       # self.assertEqual(double_backend_with_underscore, "sentencepiece_and_tensorflow_text")

       a						:int										=	find_backend(
           '''    if not (is_torch_available() and is_transformers_available() and is_onnx_available()):'''   )
       self.assertEqual(_lowerCamelCase ,  '''torch_and_transformers_and_onnx'''   )




 def 	SCREAMING_SNAKE_CASE__    (		self   ):
       a						:List[str]										=	read_init()
       # We don't assert on the exact list of keys to allow for smooth grow of backend-specific objects
       self.assertIn('''torch''' ,  _lowerCamelCase   )
       self.assertIn('''torch_and_transformers''' ,  _lowerCamelCase   )
       self.assertIn('''flax_and_transformers''' ,  _lowerCamelCase   )
       self.assertIn('''torch_and_transformers_and_onnx''' ,  _lowerCamelCase   )

       # Likewise, we can't assert on the exact content of a key
       self.assertIn('''UNet2DModel''' ,  objects['''torch''']   )
       self.assertIn('''FlaxUNet2DConditionModel''' ,  objects['''flax''']   )
       self.assertIn('''StableDiffusionPipeline''' ,  objects['''torch_and_transformers''']   )
       self.assertIn('''FlaxStableDiffusionPipeline''' ,  objects['''flax_and_transformers''']   )
       self.assertIn('''LMSDiscreteScheduler''' ,  objects['''torch_and_scipy''']   )
       self.assertIn('''OnnxStableDiffusionPipeline''' ,  objects['''torch_and_transformers_and_onnx''']   )




 def 	SCREAMING_SNAKE_CASE__    (		self   ):
       a						:Any										=	create_dummy_object('''CONSTANT''' ,  '''\'torch\''''   )
       self.assertEqual(_lowerCamelCase ,  '''\nCONSTANT = None\n'''   )

       a						:Dict										=	create_dummy_object('''function''' ,  '''\'torch\''''   )
       self.assertEqual(
           _lowerCamelCase ,  '''\ndef function(*args, **kwargs):\n    requires_backends(function, \'torch\')\n'''   )

       a						:List[Any]										=	'''
class FakeClass(metaclass=DummyObject):
    _backends = \'torch\'

    def __init__(self, *args, **kwargs):
        requires_backends(self, \'torch\')

    @classmethod
    def from_config(cls, *args, **kwargs):
        requires_backends(cls, \'torch\')

    @classmethod
    def from_pretrained(cls, *args, **kwargs):
        requires_backends(cls, \'torch\')
'''
       a						:Union[str, Any]										=	create_dummy_object('''FakeClass''' ,  '''\'torch\''''   )
       self.assertEqual(_lowerCamelCase ,  _lowerCamelCase   )




 def 	SCREAMING_SNAKE_CASE__    (		self   ):
       a						:str										=	'''# This file is autogenerated by the command `make fix-copies`, do not edit.
from ..utils import DummyObject, requires_backends


CONSTANT = None


def function(*args, **kwargs):
    requires_backends(function, ["torch"])


class FakeClass(metaclass=DummyObject):
    _backends = ["torch"]

    def __init__(self, *args, **kwargs):
        requires_backends(self, ["torch"])

    @classmethod
    def from_config(cls, *args, **kwargs):
        requires_backends(cls, ["torch"])

    @classmethod
    def from_pretrained(cls, *args, **kwargs):
        requires_backends(cls, ["torch"])
'''
       a						:Union[str, Any]										=	create_dummy_files({'''torch''': ['''CONSTANT''', '''function''', '''FakeClass''']}   )
       self.assertEqual(dummy_files['''torch'''] ,  _lowerCamelCase   )









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  :




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




 def 	SCREAMING_SNAKE_CASE__    (		self   ):
       a						:Dict										=	ids_tensor([self.batch_size, self.seq_length] ,  self.vocab_size   )
       a						:Optional[Any]										=	ids_tensor([self.batch_size, self.seq_length] ,  self.vocab_size   )

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

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




 def 	SCREAMING_SNAKE_CASE__    (		self ,  _lowerCamelCase ,  _lowerCamelCase ,  _lowerCamelCase ,  _lowerCamelCase   ):
       a						:int										=	TFTransfoXLModel(_lowerCamelCase   )

       a							,    a						:List[Any]										=	model(_lowerCamelCase   ).to_tuple()

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

       a							,    a						:Optional[int]										=	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 	SCREAMING_SNAKE_CASE__    (		self ,  _lowerCamelCase ,  _lowerCamelCase ,  _lowerCamelCase ,  _lowerCamelCase   ):
       a						:str										=	TFTransfoXLLMHeadModel(_lowerCamelCase   )

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

       a						:Any										=	{'''input_ids''': input_ids_a, '''labels''': lm_labels}
       a							,    a						:Dict										=	model(_lowerCamelCase   ).to_tuple()

       a							,    a						:Dict										=	model([input_ids_a, mems_a]   ).to_tuple()

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

       a							,    a						:Any										=	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 	SCREAMING_SNAKE_CASE__    (		self ,  _lowerCamelCase ,  _lowerCamelCase ,  _lowerCamelCase ,  _lowerCamelCase   ):
       a						:Optional[Any]										=	TFTransfoXLForSequenceClassification(_lowerCamelCase   )
       a						:Any										=	model(_lowerCamelCase   )
       self.parent.assertEqual(result.logits.shape ,  (self.batch_size, self.num_labels)   )




 def 	SCREAMING_SNAKE_CASE__    (		self   ):
       a						:str										=	self.prepare_config_and_inputs()
       ((a)							,    (a)							,    (a)							,    (a))						:Optional[int]										=	config_and_inputs
       a						:Union[str, Any]										=	{'''input_ids''': input_ids_a}
       return config, inputs_dict







@require_tf
class 		_snake_case  (				_snake_case						,   _snake_case						,   unittest.TestCase							):
 SCREAMING_SNAKE_CASE__				=	(
     (TFTransfoXLModel, TFTransfoXLLMHeadModel, TFTransfoXLForSequenceClassification) if is_tf_available() else ()
 )
 SCREAMING_SNAKE_CASE__				=	() if is_tf_available() else ()
 SCREAMING_SNAKE_CASE__				=	(
     {
         '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
 SCREAMING_SNAKE_CASE__				=	False
 SCREAMING_SNAKE_CASE__				=	False
 SCREAMING_SNAKE_CASE__				=	False
 SCREAMING_SNAKE_CASE__				=	False




 def 	SCREAMING_SNAKE_CASE__    (		self ,  _lowerCamelCase ,  _lowerCamelCase ,  _lowerCamelCase ,  _lowerCamelCase ,  _lowerCamelCase   ):
       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 	SCREAMING_SNAKE_CASE__    (		self   ):
       a						:str										=	TFTransfoXLModelTester(self   )
       a						:str										=	ConfigTester(self ,  config_class=_lowerCamelCase ,  d_embed=37   )




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




 def 	SCREAMING_SNAKE_CASE__    (		self   ):
       self.model_tester.set_seed()
       a						:str										=	self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_transfo_xl_model(*_lowerCamelCase   )




 def 	SCREAMING_SNAKE_CASE__    (		self   ):
       self.model_tester.set_seed()
       a						:Dict										=	self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_transfo_xl_lm_head(*_lowerCamelCase   )




 def 	SCREAMING_SNAKE_CASE__    (		self   ):
       a						:List[Any]										=	self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_transfo_xl_for_sequence_classification(*_lowerCamelCase   )




 def 	SCREAMING_SNAKE_CASE__    (		self   ):
       a							,    a						:Any										=	self.model_tester.prepare_config_and_inputs_for_common()
       a						:int										=	[TFTransfoXLForSequenceClassification]

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




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




 @slow
 def 	SCREAMING_SNAKE_CASE__    (		self   ):
       for model_name in TF_TRANSFO_XL_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
             a						:List[Any]										=	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 	SCREAMING_SNAKE_CASE__    (		self   ):
       pass







@require_tf
class 		_snake_case  (				unittest.TestCase							):




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

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





