


from __future__ import annotations

import os
import tempfile
import unittest

import numpy as np
from huggingface_hub import hf_hub_download

from transformers import is_tensorflow_text_available, is_tf_available
from transformers.testing_utils import require_tensorflow_text, require_tf, slow

from ..test_modeling_tf_common import floats_tensor
from .test_framework_agnostic import GenerationIntegrationTestsMixin


if is_tf_available():
 import tensorflow as tf

 from transformers import (
     AutoTokenizer,
     TFAutoModelForCausalLM,
     TFAutoModelForSeqaSeqLM,
     TFAutoModelForSpeechSeqaSeq,
     TFAutoModelForVisionaSeq,
     TFBartForConditionalGeneration,
     TFLogitsProcessorList,
     TFMinLengthLogitsProcessor,
     tf_top_k_top_p_filtering,
 )

if is_tensorflow_text_available():
 import tensorflow_text as text






@require_tf
class _lowerCamelCase(		unittest.TestCase     ):
       def     UpperCamelCase  (      self) ->     Optional[int]:




           """simple docstring"""

           _lowercase :							List[Any]   	=	tf.convert_to_tensor(
               [
                   [
                       8.2_2_2_0_9_9_1,  # 3rd highest value; idx. 0
                       -0.5_6_2_0_0_4_4,
                       5.2_3_2_2_9_7_5_2,
                       4.0_3_8_6_3_9_3,
                       -6.8_7_9_8_3_7_8,
                       -0.5_4_7_8_5_8_0_2,
                       -3.2_0_1_2_1_5_3,
                       2.9_2_7_7_7_1_7_6,
                       1.8_8_1_7_1_9_5_3,
                       7.3_5_3_4_1_2_7_6,  # 5th highest value; idx. 9
                       8.4_3_2_0_7_8_3_3,  # 2nd highest value; idx. 10
                       -9.8_5_7_1_1_8_3_6,
                       -5.9_6_2_0_9_2_3_6,
                       -1.1_3_0_3_9_1_6_1,
                       -7.1_1_1_5_2_9_4,
                       -0.8_3_6_9_6_3_3,
                       -5.3_1_8_6_4_0_8,
                       7.0_6_4_2_7_4_0_7,
                       0.8_1_3_6_9_3_4_4,
                       -0.8_2_0_2_3_8_1_7,
                       -5.9_1_7_9_7_9_6,
                       0.5_8_8_1_3_4_4_3,
                       -6.9_9_7_7_8_4_3_8,
                       4.7_1_5_5_1_1_8_9,
                       -0.1_8_7_7_1_6_3_7,
                       7.4_4_0_2_0_7_5_9,  # 4th highest value; idx. 25
                       9.3_8_4_5_0_9_8_7,  # 1st highest value; idx. 26
                       2.1_2_6_6_2_9_4_1,
                       -9.3_2_5_6_2_0_3_8,
                       2.3_5_6_5_2_5_2_2,
                   ],  # cummulative prob of 5 highest values <= 0.6
                   [
                       0.5_8_4_2_5_5_1_8,
                       4.5_3_1_3_9_2_3_8,
                       -5.5_7_5_1_0_4_6_4,
                       -6.2_8_0_3_0_6_9_9,
                       -7.1_9_5_2_9_5_0_3,
                       -4.0_2_1_2_2_5_5_1,
                       1.3_9_3_3_7_0_3_7,
                       -6.0_6_7_0_7_0_5_7,
                       1.5_9_4_8_0_5_1_7,
                       -9.6_4_3_1_1_9,
                       0.0_3_9_0_7_7_9_9,
                       0.6_7_2_3_1_7_6_2,
                       -8.8_8_2_0_6_7_2_6,
                       6.2_7_1_1_5_9_2_2,  # 4th highest value; idx. 13
                       2.2_8_5_2_0_7_2_3,
                       4.8_2_7_6_7_5_0_6,
                       4.3_0_4_2_1_3_6_8,
                       8.8_2_7_5_3_1_3,  # 2nd highest value; idx. 17
                       5.4_4_0_2_9_9_5_8,  # 5th highest value; idx. 18
                       -4.4_7_3_5_7_9_4,
                       7.3_8_5_7_9_5_3_6,  # 3rd highest value; idx. 20
                       -2.9_1_0_5_1_6_6_3,
                       2.6_1_9_4_6_0_7_7,
                       -2.5_6_7_4_7_6_2,
                       -9.4_8_9_5_9_3_0_2,
                       -4.0_2_9_2_2_6_4_5,
                       -1.3_5_4_1_6_9_1_8,
                       9.6_7_7_0_2_3_2_3,  # 1st highest value; idx. 27
                       -5.8_9_4_7_8_5_5_3,
                       1.8_5_3_7_0_4_6_7,
                   ],  # cummulative prob of 5 highest values <= 0.6
               ],   dtype=tf.floataa,   )

           _lowercase :							Dict   	=	tf.convert_to_tensor(
               [[0, 0], [0, 9], [0, 10], [0, 25], [0, 26], [1, 13], [1, 17], [1, 18], [1, 20], [1, 27]],   dtype=tf.intaa,   )  # expected non filtered idx as noted above

           _lowercase :							Optional[Any]   	=	tf.convert_to_tensor(
               [8.2_2_2_0_9_9, 7.3_5_3_4_1_2_6, 8.4_3_2_0_7_8, 7.4_4_0_2_0_7_5, 9.3_8_4_5_1, 6.2_7_1_1_5_9, 8.8_2_7_5_3_1, 5.4_4_0_2_9_9_5, 7.3_8_5_7_9_5_6, 9.6_7_7_0_2_3],   dtype=tf.floataa,   )  # expected non filtered values as noted above

           _lowercase :							Optional[int]   	=	tf_top_k_top_p_filtering(lowerCamelCase,   top_k=10,   top_p=0.6,   min_tokens_to_keep=4)

           _lowercase :							int   	=	output[output != -float('inf')]
           _lowercase :							List[str]   	=	tf.cast(
               tf.where(tf.not_equal(lowerCamelCase,   tf.constant(-float('inf'),   dtype=tf.floataa))),   dtype=tf.intaa,   )

           tf.debugging.assert_near(lowerCamelCase,   lowerCamelCase,   rtol=1E-12)
           tf.debugging.assert_equal(lowerCamelCase,   lowerCamelCase)






@require_tf
class _lowerCamelCase(		unittest.TestCase,				_a     ):
       # setting framework_dependent_parameters needs to be gated, just like its contents' imports
       if is_tf_available():
              lowercase_				:			Optional[Any]									=    {
                  """AutoModelForCausalLM""": TFAutoModelForCausalLM,
                  """AutoModelForSpeechSeq2Seq""": TFAutoModelForSpeechSeqaSeq,
                  """AutoModelForSeq2SeqLM""": TFAutoModelForSeqaSeqLM,
                  """AutoModelForVision2Seq""": TFAutoModelForVisionaSeq,
                  """LogitsProcessorList""": TFLogitsProcessorList,
                  """MinLengthLogitsProcessor""": TFMinLengthLogitsProcessor,
                  """create_tensor_fn""": tf.convert_to_tensor,
                  """floats_tensor""": floats_tensor,
                  """return_tensors""": """tf""",
              }
       @slow
       def     UpperCamelCase  (      self) ->     int:




           """simple docstring"""

           _lowercase :							Union[str, Any]   	=	TFAutoModelForCausalLM.from_pretrained('hf-internal-testing/tiny-random-gpt2')
           _lowercase :							Any   	=	2
           _lowercase :							Tuple   	=	2






           class _lowerCamelCase(		tf.Module     ):
                  def __init__(      self,   lowerCamelCase) ->     int:




                      """simple docstring"""

                      super(lowerCamelCase,   self).__init__()
                      _lowercase :							int   	=	model




                  @tf.function(
                      input_signature=(
                          tf.TensorSpec((None, input_length),   tf.intaa,   name='input_ids'),
                          tf.TensorSpec((None, input_length),   tf.intaa,   name='attention_mask'),
                      ),   jit_compile=lowerCamelCase,   )
                  def     UpperCamelCase  (      self,   lowerCamelCase,   lowerCamelCase) ->     List[str]:




                      """simple docstring"""

                      _lowercase :							List[str]   	=	self.model.generate(
                          input_ids=lowerCamelCase,   attention_mask=lowerCamelCase,   max_new_tokens=lowerCamelCase,   return_dict_in_generate=lowerCamelCase,   )
                      return {"sequences": outputs["sequences"]}


           _lowercase :							List[Any]   	=	[[2, 0], [1_02, 1_03]]
           _lowercase :							Tuple   	=	[[1, 0], [1, 1]]
           _lowercase :							Dict   	=	DummyModel(model=lowerCamelCase)
           with tempfile.TemporaryDirectory() as tmp_dir:
               tf.saved_model.save(lowerCamelCase,   lowerCamelCase,   signatures={'serving_default': dummy_model.serving})
               _lowercase :							Dict   	=	tf.saved_model.load(lowerCamelCase).signatures['serving_default']
               for batch_size in range(1,   len(lowerCamelCase) + 1):
                   _lowercase :							int   	=	{
                       'input_ids': tf.constant(dummy_input_ids[:batch_size]),
                       'attention_mask': tf.constant(dummy_attention_masks[:batch_size]),
                   }
                   _lowercase :							Optional[int]   	=	serving_func(**lowerCamelCase)['sequences']
                   _lowercase :							Optional[Any]   	=	test_model.generate(**lowerCamelCase,   max_new_tokens=lowerCamelCase)
                   tf.debugging.assert_equal(lowerCamelCase,   lowerCamelCase)
       @slow
       def     UpperCamelCase  (      self) ->     Dict:




           """simple docstring"""

           _lowercase :							Union[str, Any]   	=	TFAutoModelForCausalLM.from_pretrained('hf-internal-testing/tiny-random-gpt2')
           _lowercase :							List[str]   	=	1
           _lowercase :							Tuple   	=	2






           class _lowerCamelCase(		tf.Module     ):
                  def __init__(      self,   lowerCamelCase) ->     Any:




                      """simple docstring"""

                      super(lowerCamelCase,   self).__init__()
                      _lowercase :							Optional[int]   	=	model




                  @tf.function(
                      input_signature=(
                          tf.TensorSpec((batch_size, None),   tf.intaa,   name='input_ids'),
                          tf.TensorSpec((batch_size, None),   tf.intaa,   name='attention_mask'),
                      ),   jit_compile=lowerCamelCase,   )
                  def     UpperCamelCase  (      self,   lowerCamelCase,   lowerCamelCase) ->     Dict:




                      """simple docstring"""

                      _lowercase :							Optional[int]   	=	self.model.generate(
                          input_ids=lowerCamelCase,   attention_mask=lowerCamelCase,   max_new_tokens=lowerCamelCase,   return_dict_in_generate=lowerCamelCase,   )
                      return {"sequences": outputs["sequences"]}


           _lowercase :							Optional[int]   	=	[[2], [1_02, 1_03]]
           _lowercase :							List[Any]   	=	[[1], [1, 1]]
           _lowercase :							Tuple   	=	DummyModel(model=lowerCamelCase)
           with tempfile.TemporaryDirectory() as tmp_dir:
               tf.saved_model.save(lowerCamelCase,   lowerCamelCase,   signatures={'serving_default': dummy_model.serving})
               _lowercase :							Optional[int]   	=	tf.saved_model.load(lowerCamelCase).signatures['serving_default']
               for input_row in range(len(lowerCamelCase)):
                   _lowercase :							Dict   	=	{
                       'input_ids': tf.constant([dummy_input_ids[input_row]]),
                       'attention_mask': tf.constant([dummy_attention_masks[input_row]]),
                   }
                   _lowercase :							List[Any]   	=	serving_func(**lowerCamelCase)['sequences']
                   _lowercase :							List[str]   	=	test_model.generate(**lowerCamelCase,   max_new_tokens=lowerCamelCase)
                   tf.debugging.assert_equal(lowerCamelCase,   lowerCamelCase)
       @slow
       @require_tensorflow_text
       def     UpperCamelCase  (      self) ->     Union[str, Any]:




           """simple docstring"""

           with tempfile.TemporaryDirectory() as tmp_dir:
               # file needed to load the TF tokenizer
               hf_hub_download(repo_id='google/flan-t5-small',   filename='spiece.model',   local_dir=lowerCamelCase)






               class _lowerCamelCase(		tf.keras.layers.Layer     ):
                      def __init__(      self) ->     Dict:




                          """simple docstring"""

                          super().__init__()
                          _lowercase :							Union[str, Any]   	=	text.SentencepieceTokenizer(
                              model=tf.io.gfile.GFile(os.path.join(lowerCamelCase,   'spiece.model'),   'rb').read())
                          _lowercase :							Optional[Any]   	=	TFAutoModelForSeqaSeqLM.from_pretrained('hf-internal-testing/tiny-random-t5')




                      def     UpperCamelCase  (      self,   lowerCamelCase,   *lowerCamelCase,   **lowerCamelCase) ->     Optional[int]:




                          """simple docstring"""

                          _lowercase :							Tuple   	=	self.tokenizer.tokenize(lowerCamelCase)
                          _lowercase :							Tuple   	=	text.pad_model_inputs(
                              lowerCamelCase,   max_seq_length=64,   pad_value=self.model.config.pad_token_id)
                          _lowercase :							Tuple   	=	self.model.generate(input_ids=lowerCamelCase,   attention_mask=lowerCamelCase)
                          return self.tokenizer.detokenize(lowerCamelCase)


               _lowercase :							Tuple   	=	CompleteSentenceTransformer()
               _lowercase :							Optional[Any]   	=	tf.keras.layers.Input(shape=(1,),   dtype=tf.string,   name='inputs')
               _lowercase :							Tuple   	=	complete_model(lowerCamelCase)
               _lowercase :							Union[str, Any]   	=	tf.keras.Model(lowerCamelCase,   lowerCamelCase)
               keras_model.save(lowerCamelCase)
       def     UpperCamelCase  (      self) ->     Any:




           """simple docstring"""

           _lowercase :							int   	=	{
               'do_sample': True,
               'num_beams': 1,
               'top_p': 0.7,
               'top_k': 10,
               'temperature': 0.7,
           }
           _lowercase :							Tuple   	=	14

           _lowercase :							Tuple   	=	AutoTokenizer.from_pretrained('hf-internal-testing/tiny-random-gpt2')
           _lowercase :							Any   	=	'Hello, my dog is cute and'
           _lowercase :							List[Any]   	=	tokenizer(lowerCamelCase,   return_tensors='tf')
           _lowercase :							Optional[int]   	=	TFAutoModelForCausalLM.from_pretrained('hf-internal-testing/tiny-random-gpt2')

           _lowercase :							Union[str, Any]   	=	6_38
           # forces the generation to happen on CPU, to avoid GPU-related quirks
           with tf.device(':/CPU:0'):
               tf.random.set_seed(0)
               _lowercase :							Tuple   	=	model.generate(**lowerCamelCase,   eos_token_id=lowerCamelCase,   **lowerCamelCase)
           self.assertTrue(expectation == len(generated_tokens[0]))

           _lowercase :							Tuple   	=	[6_38, 1_98]
           with tf.device(':/CPU:0'):
               tf.random.set_seed(0)
               _lowercase :							Optional[Any]   	=	model.generate(**lowerCamelCase,   eos_token_id=lowerCamelCase,   **lowerCamelCase)
           self.assertTrue(expectation == len(generated_tokens[0]))




       def     UpperCamelCase  (      self) ->     int:




           """simple docstring"""

           _lowercase :							Optional[Any]   	=	AutoTokenizer.from_pretrained('hf-internal-testing/tiny-random-bart')
           _lowercase :							Any   	=	'Hugging Face is a technology company based in New York and Paris.'
           _lowercase :							Optional[int]   	=	bart_tokenizer(lowerCamelCase,   return_tensors='tf').input_ids
           _lowercase :							Union[str, Any]   	=	TFBartForConditionalGeneration.from_pretrained('hf-internal-testing/tiny-random-bart')
           _lowercase :							Union[str, Any]   	=	bart_model.generate(lowerCamelCase).numpy()






           class _lowerCamelCase(		_a     ):
                  def     UpperCamelCase  (      self,   lowerCamelCase,   lowerCamelCase=None,   **lowerCamelCase) ->     int:




                      """simple docstring"""

                      return super().call(lowerCamelCase,   **lowerCamelCase)


           _lowercase :							Any   	=	FakeBart.from_pretrained('hf-internal-testing/tiny-random-bart')
           _lowercase :							Optional[int]   	=	bart_model.generate(lowerCamelCase,   foo='bar').numpy()
           self.assertTrue(np.array_equal(lowerCamelCase,   lowerCamelCase))






           class _lowerCamelCase(		bart_model.model.encoder.__class__     ):
                  def     UpperCamelCase  (      self,   lowerCamelCase,   **lowerCamelCase) ->     Tuple:




                      """simple docstring"""

                      return super().call(lowerCamelCase,   **lowerCamelCase)


           _lowercase :							List[Any]   	=	FakeEncoder(bart_model.config,   bart_model.model.shared)
           _lowercase :							int   	=	fake_encoder

           # Normal generation still works (the output will be different because the encoder weights are different)
           _lowercase :							Dict   	=	bart_model.generate(lowerCamelCase).numpy()
           with self.assertRaises(lowerCamelCase):
               # FakeEncoder.call() accepts **kwargs -> no filtering -> value error due to unexpected input "foo"
               bart_model.generate(lowerCamelCase,   foo='bar')



import unittest

from diffusers.models.unet_ad_blocks import *  # noqa F403
from diffusers.utils import torch_device

from .test_unet_blocks_common import UNetBlockTesterMixin






class _lowerCamelCase(		_a,				unittest.TestCase     ):
       lowercase_				:			str									=    DownBlockaD  # noqa F405
       lowercase_				:			List[str]									=    """down"""
       def     UpperCamelCase  (      self) ->     List[str]:




           """simple docstring"""

           _lowercase :							str   	=	[-0.0_2_3_2, -0.9_8_6_9, 0.8_0_5_4, -0.0_6_3_7, -0.1_6_8_8, -1.4_2_6_4, 0.4_4_7_0, -1.3_3_9_4, 0.0_9_0_4]
           super().test_output(lowerCamelCase)






class _lowerCamelCase(		_a,				unittest.TestCase     ):
       lowercase_				:			Optional[Any]									=    ResnetDownsampleBlockaD  # noqa F405
       lowercase_				:			Optional[Any]									=    """down"""
       def     UpperCamelCase  (      self) ->     Any:




           """simple docstring"""

           _lowercase :							Optional[Any]   	=	[0.0_7_1_0, 0.2_4_1_0, -0.7_3_2_0, -1.0_7_5_7, -1.1_3_4_3, 0.3_5_4_0, -0.0_1_3_3, -0.2_5_7_6, 0.0_9_4_8]
           super().test_output(lowerCamelCase)






class _lowerCamelCase(		_a,				unittest.TestCase     ):
       lowercase_				:			Any									=    AttnDownBlockaD  # noqa F405
       lowercase_				:			Dict									=    """down"""
       def     UpperCamelCase  (      self) ->     Optional[int]:




           """simple docstring"""

           _lowercase :							Optional[int]   	=	[0.0_6_3_6, 0.8_9_6_4, -0.6_2_3_4, -1.0_1_3_1, 0.0_8_4_4, 0.4_9_3_5, 0.3_4_3_7, 0.0_9_1_1, -0.2_9_5_7]
           super().test_output(lowerCamelCase)






class _lowerCamelCase(		_a,				unittest.TestCase     ):
       lowercase_				:			str									=    CrossAttnDownBlockaD  # noqa F405
       lowercase_				:			Optional[int]									=    """down"""
       def     UpperCamelCase  (      self) ->     Dict:




           """simple docstring"""

           _lowercase	,       _lowercase :							int   	=	super().prepare_init_args_and_inputs_for_common()
           _lowercase :							int   	=	32
           return init_dict, inputs_dict




       def     UpperCamelCase  (      self) ->     str:




           """simple docstring"""

           _lowercase :							List[str]   	=	[0.2_2_3_8, -0.7_3_9_6, -0.2_2_5_5, -0.3_8_2_9, 0.1_9_2_5, 1.1_6_6_5, 0.0_6_0_3, -0.7_2_9_5, 0.1_9_8_3]
           super().test_output(lowerCamelCase)






class _lowerCamelCase(		_a,				unittest.TestCase     ):
       lowercase_				:			Dict									=    SimpleCrossAttnDownBlockaD  # noqa F405
       lowercase_				:			Optional[Any]									=    """down"""
       @property
       def     UpperCamelCase  (      self) ->     Optional[int]:




           """simple docstring"""

           return super().get_dummy_input(include_encoder_hidden_states=lowerCamelCase)
       def     UpperCamelCase  (      self) ->     List[Any]:




           """simple docstring"""

           _lowercase	,       _lowercase :							Dict   	=	super().prepare_init_args_and_inputs_for_common()
           _lowercase :							Optional[Any]   	=	32
           return init_dict, inputs_dict




       @unittest.skipIf(torch_device == 'mps',   'MPS result is not consistent')
       def     UpperCamelCase  (      self) ->     int:




           """simple docstring"""

           _lowercase :							Tuple   	=	[0.7_9_2_1, -0.0_9_9_2, -0.1_9_6_2, -0.7_6_9_5, -0.4_2_4_2, 0.7_8_0_4, 0.4_7_3_7, 0.2_7_6_5, 0.3_3_3_8]
           super().test_output(lowerCamelCase)






class _lowerCamelCase(		_a,				unittest.TestCase     ):
       lowercase_				:			str									=    SkipDownBlockaD  # noqa F405
       lowercase_				:			Union[str, Any]									=    """down"""
       @property
       def     UpperCamelCase  (      self) ->     List[str]:




           """simple docstring"""

           return super().get_dummy_input(include_skip_sample=lowerCamelCase)




       def     UpperCamelCase  (      self) ->     Tuple:




           """simple docstring"""

           _lowercase :							int   	=	[-0.0_8_4_5, -0.2_0_8_7, -0.2_4_6_5, 0.0_9_7_1, 0.1_9_0_0, -0.0_4_8_4, 0.2_6_6_4, 0.4_1_7_9, 0.5_0_6_9]
           super().test_output(lowerCamelCase)






class _lowerCamelCase(		_a,				unittest.TestCase     ):
       lowercase_				:			str									=    AttnSkipDownBlockaD  # noqa F405
       lowercase_				:			Optional[Any]									=    """down"""
       @property
       def     UpperCamelCase  (      self) ->     Tuple:




           """simple docstring"""

           return super().get_dummy_input(include_skip_sample=lowerCamelCase)




       def     UpperCamelCase  (      self) ->     List[Any]:




           """simple docstring"""

           _lowercase :							Optional[int]   	=	[0.5_5_3_9, 0.1_6_0_9, 0.4_9_2_4, 0.0_5_3_7, -0.1_9_9_5, 0.4_0_5_0, 0.0_9_7_9, -0.2_7_2_1, -0.0_6_4_2]
           super().test_output(lowerCamelCase)






class _lowerCamelCase(		_a,				unittest.TestCase     ):
       lowercase_				:			str									=    DownEncoderBlockaD  # noqa F405
       lowercase_				:			Optional[Any]									=    """down"""
       @property
       def     UpperCamelCase  (      self) ->     List[str]:




           """simple docstring"""

           return super().get_dummy_input(include_temb=lowerCamelCase)
       def     UpperCamelCase  (      self) ->     int:




           """simple docstring"""

           _lowercase :							Dict   	=	{
               'in_channels': 32,
               'out_channels': 32,
           }
           _lowercase :							int   	=	self.dummy_input
           return init_dict, inputs_dict




       def     UpperCamelCase  (      self) ->     List[str]:




           """simple docstring"""

           _lowercase :							List[str]   	=	[1.1_1_0_2, 0.5_3_0_2, 0.4_8_7_2, -0.0_0_2_3, -0.8_0_4_2, 0.0_4_8_3, -0.3_4_8_9, -0.5_6_3_2, 0.7_6_2_6]
           super().test_output(lowerCamelCase)






class _lowerCamelCase(		_a,				unittest.TestCase     ):
       lowercase_				:			int									=    AttnDownEncoderBlockaD  # noqa F405
       lowercase_				:			Tuple									=    """down"""
       @property
       def     UpperCamelCase  (      self) ->     Tuple:




           """simple docstring"""

           return super().get_dummy_input(include_temb=lowerCamelCase)
       def     UpperCamelCase  (      self) ->     str:




           """simple docstring"""

           _lowercase :							Any   	=	{
               'in_channels': 32,
               'out_channels': 32,
           }
           _lowercase :							Optional[int]   	=	self.dummy_input
           return init_dict, inputs_dict




       def     UpperCamelCase  (      self) ->     Optional[Any]:




           """simple docstring"""

           _lowercase :							Union[str, Any]   	=	[0.8_9_6_6, -0.1_4_8_6, 0.8_5_6_8, 0.8_1_4_1, -0.9_0_4_6, -0.1_3_4_2, -0.0_9_7_2, -0.7_4_1_7, 0.1_5_3_8]
           super().test_output(lowerCamelCase)






class _lowerCamelCase(		_a,				unittest.TestCase     ):
       lowercase_				:			int									=    UNetMidBlockaD  # noqa F405
       lowercase_				:			Optional[int]									=    """mid"""
       def     UpperCamelCase  (      self) ->     Optional[Any]:




           """simple docstring"""

           _lowercase :							int   	=	{
               'in_channels': 32,
               'temb_channels': 1_28,
           }
           _lowercase :							Optional[Any]   	=	self.dummy_input
           return init_dict, inputs_dict




       def     UpperCamelCase  (      self) ->     Dict:




           """simple docstring"""

           _lowercase :							Dict   	=	[-0.1_0_6_2, 1.7_2_4_8, 0.3_4_9_4, 1.4_5_6_9, -0.0_9_1_0, -1.2_4_2_1, -0.9_9_8_4, 0.6_7_3_6, 1.0_0_2_8]
           super().test_output(lowerCamelCase)






class _lowerCamelCase(		_a,				unittest.TestCase     ):
       lowercase_				:			Dict									=    UNetMidBlockaDCrossAttn  # noqa F405
       lowercase_				:			Dict									=    """mid"""
       def     UpperCamelCase  (      self) ->     Optional[int]:




           """simple docstring"""

           _lowercase	,       _lowercase :							Union[str, Any]   	=	super().prepare_init_args_and_inputs_for_common()
           _lowercase :							Any   	=	32
           return init_dict, inputs_dict




       def     UpperCamelCase  (      self) ->     str:




           """simple docstring"""

           _lowercase :							Dict   	=	[0.0_1_8_7, 2.4_2_2_0, 0.4_4_8_4, 1.1_2_0_3, -0.6_1_2_1, -1.5_1_2_2, -0.8_2_7_0, 0.7_8_5_1, 1.8_3_3_5]
           super().test_output(lowerCamelCase)






class _lowerCamelCase(		_a,				unittest.TestCase     ):
       lowercase_				:			List[Any]									=    UNetMidBlockaDSimpleCrossAttn  # noqa F405
       lowercase_				:			Any									=    """mid"""
       @property
       def     UpperCamelCase  (      self) ->     Union[str, Any]:




           """simple docstring"""

           return super().get_dummy_input(include_encoder_hidden_states=lowerCamelCase)
       def     UpperCamelCase  (      self) ->     Dict:




           """simple docstring"""

           _lowercase	,       _lowercase :							str   	=	super().prepare_init_args_and_inputs_for_common()
           _lowercase :							List[str]   	=	32
           return init_dict, inputs_dict




       def     UpperCamelCase  (      self) ->     Optional[int]:




           """simple docstring"""

           _lowercase :							int   	=	[0.7_1_4_3, 1.9_9_7_4, 0.5_4_4_8, 1.3_9_7_7, 0.1_2_8_2, -1.1_2_3_7, -1.4_2_3_8, 0.5_5_3_0, 0.8_8_8_0]
           super().test_output(lowerCamelCase)






class _lowerCamelCase(		_a,				unittest.TestCase     ):
       lowercase_				:			List[Any]									=    UpBlockaD  # noqa F405
       lowercase_				:			List[str]									=    """up"""
       @property
       def     UpperCamelCase  (      self) ->     List[Any]:




           """simple docstring"""

           return super().get_dummy_input(include_res_hidden_states_tuple=lowerCamelCase)




       def     UpperCamelCase  (      self) ->     Dict:




           """simple docstring"""

           _lowercase :							Any   	=	[-0.2_0_4_1, -0.4_1_6_5, -0.3_0_2_2, 0.0_0_4_1, -0.6_6_2_8, -0.7_0_5_3, 0.1_9_2_8, -0.0_3_2_5, 0.0_5_2_3]
           super().test_output(lowerCamelCase)






class _lowerCamelCase(		_a,				unittest.TestCase     ):
       lowercase_				:			List[str]									=    ResnetUpsampleBlockaD  # noqa F405
       lowercase_				:			Optional[int]									=    """up"""
       @property
       def     UpperCamelCase  (      self) ->     List[str]:




           """simple docstring"""

           return super().get_dummy_input(include_res_hidden_states_tuple=lowerCamelCase)




       def     UpperCamelCase  (      self) ->     List[Any]:




           """simple docstring"""

           _lowercase :							List[Any]   	=	[0.2_2_8_7, 0.3_5_4_9, -0.1_3_4_6, 0.4_7_9_7, -0.1_7_1_5, -0.9_6_4_9, 0.7_3_0_5, -0.5_8_6_4, -0.6_2_4_4]
           super().test_output(lowerCamelCase)






class _lowerCamelCase(		_a,				unittest.TestCase     ):
       lowercase_				:			Dict									=    CrossAttnUpBlockaD  # noqa F405
       lowercase_				:			List[str]									=    """up"""
       @property
       def     UpperCamelCase  (      self) ->     int:




           """simple docstring"""

           return super().get_dummy_input(include_res_hidden_states_tuple=lowerCamelCase)
       def     UpperCamelCase  (      self) ->     Union[str, Any]:




           """simple docstring"""

           _lowercase	,       _lowercase :							Union[str, Any]   	=	super().prepare_init_args_and_inputs_for_common()
           _lowercase :							Tuple   	=	32
           return init_dict, inputs_dict




       def     UpperCamelCase  (      self) ->     str:




           """simple docstring"""

           _lowercase :							Dict   	=	[-0.1_4_0_3, -0.3_5_1_5, -0.0_4_2_0, -0.1_4_2_5, 0.3_1_6_7, 0.5_0_9_4, -0.2_1_8_1, 0.5_9_3_1, 0.5_5_8_2]
           super().test_output(lowerCamelCase)






class _lowerCamelCase(		_a,				unittest.TestCase     ):
       lowercase_				:			Optional[int]									=    SimpleCrossAttnUpBlockaD  # noqa F405
       lowercase_				:			List[Any]									=    """up"""
       @property
       def     UpperCamelCase  (      self) ->     Any:




           """simple docstring"""

           return super().get_dummy_input(include_res_hidden_states_tuple=lowerCamelCase,   include_encoder_hidden_states=lowerCamelCase)
       def     UpperCamelCase  (      self) ->     List[str]:




           """simple docstring"""

           _lowercase	,       _lowercase :							int   	=	super().prepare_init_args_and_inputs_for_common()
           _lowercase :							Dict   	=	32
           return init_dict, inputs_dict




       def     UpperCamelCase  (      self) ->     Dict:




           """simple docstring"""

           _lowercase :							List[str]   	=	[0.2_6_4_5, 0.1_4_8_0, 0.0_9_0_9, 0.8_0_4_4, -0.9_7_5_8, -0.9_0_8_3, 0.0_9_9_4, -1.1_4_5_3, -0.7_4_0_2]
           super().test_output(lowerCamelCase)






class _lowerCamelCase(		_a,				unittest.TestCase     ):
       lowercase_				:			List[str]									=    AttnUpBlockaD  # noqa F405
       lowercase_				:			Optional[int]									=    """up"""
       @property
       def     UpperCamelCase  (      self) ->     Optional[int]:




           """simple docstring"""

           return super().get_dummy_input(include_res_hidden_states_tuple=lowerCamelCase)




       @unittest.skipIf(torch_device == 'mps',   'MPS result is not consistent')
       def     UpperCamelCase  (      self) ->     Optional[int]:




           """simple docstring"""

           _lowercase :							Union[str, Any]   	=	[0.0_9_7_9, 0.1_3_2_6, 0.0_0_2_1, 0.0_6_5_9, 0.2_2_4_9, 0.0_0_5_9, 0.1_1_3_2, 0.5_9_5_2, 0.1_0_3_3]
           super().test_output(lowerCamelCase)






class _lowerCamelCase(		_a,				unittest.TestCase     ):
       lowercase_				:			List[str]									=    SkipUpBlockaD  # noqa F405
       lowercase_				:			Optional[Any]									=    """up"""
       @property
       def     UpperCamelCase  (      self) ->     List[str]:




           """simple docstring"""

           return super().get_dummy_input(include_res_hidden_states_tuple=lowerCamelCase)




       def     UpperCamelCase  (      self) ->     List[Any]:




           """simple docstring"""

           _lowercase :							Optional[Any]   	=	[-0.0_8_9_3, -0.1_2_3_4, -0.1_5_0_6, -0.0_3_3_2, 0.0_1_2_3, -0.0_2_1_1, 0.0_5_6_6, 0.0_1_4_3, 0.0_3_6_2]
           super().test_output(lowerCamelCase)






class _lowerCamelCase(		_a,				unittest.TestCase     ):
       lowercase_				:			int									=    AttnSkipUpBlockaD  # noqa F405
       lowercase_				:			Any									=    """up"""
       @property
       def     UpperCamelCase  (      self) ->     int:




           """simple docstring"""

           return super().get_dummy_input(include_res_hidden_states_tuple=lowerCamelCase)




       def     UpperCamelCase  (      self) ->     Optional[int]:




           """simple docstring"""

           _lowercase :							Tuple   	=	[0.0_3_6_1, 0.0_6_1_7, 0.2_7_8_7, -0.0_3_5_0, 0.0_3_4_2, 0.3_4_2_1, -0.0_8_4_3, 0.0_9_1_3, 0.3_0_1_5]
           super().test_output(lowerCamelCase)






class _lowerCamelCase(		_a,				unittest.TestCase     ):
       lowercase_				:			List[str]									=    UpDecoderBlockaD  # noqa F405
       lowercase_				:			int									=    """up"""
       @property
       def     UpperCamelCase  (      self) ->     List[Any]:




           """simple docstring"""

           return super().get_dummy_input(include_temb=lowerCamelCase)
       def     UpperCamelCase  (      self) ->     Optional[int]:




           """simple docstring"""

           _lowercase :							Optional[Any]   	=	{'in_channels': 32, 'out_channels': 32}

           _lowercase :							Optional[Any]   	=	self.dummy_input
           return init_dict, inputs_dict




       def     UpperCamelCase  (      self) ->     int:




           """simple docstring"""

           _lowercase :							List[Any]   	=	[0.4_4_0_4, 0.1_9_9_8, -0.9_8_8_6, -0.3_3_2_0, -0.3_1_2_8, -0.7_0_3_4, -0.6_9_5_5, -0.2_3_3_8, -0.3_1_3_7]
           super().test_output(lowerCamelCase)






class _lowerCamelCase(		_a,				unittest.TestCase     ):
       lowercase_				:			Any									=    AttnUpDecoderBlockaD  # noqa F405
       lowercase_				:			str									=    """up"""
       @property
       def     UpperCamelCase  (      self) ->     int:




           """simple docstring"""

           return super().get_dummy_input(include_temb=lowerCamelCase)
       def     UpperCamelCase  (      self) ->     Any:




           """simple docstring"""

           _lowercase :							Optional[Any]   	=	{'in_channels': 32, 'out_channels': 32}

           _lowercase :							List[Any]   	=	self.dummy_input
           return init_dict, inputs_dict




       def     UpperCamelCase  (      self) ->     str:




           """simple docstring"""

           _lowercase :							Optional[int]   	=	[0.6_7_3_8, 0.4_4_9_1, 0.1_0_5_5, 1.0_7_1_0, 0.7_3_1_6, 0.3_3_3_9, 0.3_3_5_2, 0.1_0_2_3, 0.3_5_6_8]
           super().test_output(lowerCamelCase)


