






from __future__ import annotations

import unittest

import numpy as np

from transformers import LayoutLMConfig, 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, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
		import tensorflow as tf

		from transformers.models.layoutlm.modeling_tf_layoutlm import (
		    TF_LAYOUTLM_PRETRAINED_MODEL_ARCHIVE_LIST,
		    TFLayoutLMForMaskedLM,
		    TFLayoutLMForQuestionAnswering,
		    TFLayoutLMForSequenceClassification,
		    TFLayoutLMForTokenClassification,
		    TFLayoutLMModel,
		)



class   lowerCamelCase      :







		'''simple docstring'''



		def __init__(							self				,		_UpperCamelCase				,		_UpperCamelCase=1_3				,		_UpperCamelCase=7				,		_UpperCamelCase=True				,		_UpperCamelCase=True				,		_UpperCamelCase=True				,		_UpperCamelCase=True				,		_UpperCamelCase=9_9				,		_UpperCamelCase=3_2				,		_UpperCamelCase=2				,		_UpperCamelCase=4				,		_UpperCamelCase=3_7				,		_UpperCamelCase="gelu"				,		_UpperCamelCase=0.1				,		_UpperCamelCase=0.1				,		_UpperCamelCase=5_1_2				,		_UpperCamelCase=1_6				,		_UpperCamelCase=2				,		_UpperCamelCase=0.02				,		_UpperCamelCase=3				,		_UpperCamelCase=4				,		_UpperCamelCase=None				,		_UpperCamelCase=1_0_0_0				,		)	->							Any:
							UpperCAmelCase_    :      Union[str, Any]            =						parent
							UpperCAmelCase_    :      Tuple            =						batch_size
							UpperCAmelCase_    :      int            =						seq_length
							UpperCAmelCase_    :      Dict            =						is_training
							UpperCAmelCase_    :      str            =						use_input_mask
							UpperCAmelCase_    :      List[Any]            =						use_token_type_ids
							UpperCAmelCase_    :      Any            =						use_labels
							UpperCAmelCase_    :      Optional[Any]            =						vocab_size
							UpperCAmelCase_    :      Dict            =						hidden_size
							UpperCAmelCase_    :      str            =						num_hidden_layers
							UpperCAmelCase_    :      Optional[int]            =						num_attention_heads
							UpperCAmelCase_    :      int            =						intermediate_size
							UpperCAmelCase_    :      List[Any]            =						hidden_act
							UpperCAmelCase_    :      Dict            =						hidden_dropout_prob
							UpperCAmelCase_    :      str            =						attention_probs_dropout_prob
							UpperCAmelCase_    :      Tuple            =						max_position_embeddings
							UpperCAmelCase_    :      Optional[int]            =						type_vocab_size
							UpperCAmelCase_    :      Optional[Any]            =						type_sequence_label_size
							UpperCAmelCase_    :      List[str]            =						initializer_range
							UpperCAmelCase_    :      str            =						num_labels
							UpperCAmelCase_    :      Tuple            =						num_choices
							UpperCAmelCase_    :      List[Any]            =						scope
							UpperCAmelCase_    :      Union[str, Any]            =						range_bbox



		def 					__UpperCAmelCase			(							self   )	->							Optional[int]:
							UpperCAmelCase_    :      Optional[Any]            =						ids_tensor([self.batch_size, self.seq_length]				,		self.vocab_size   )

							# convert bbox to numpy since TF does not support item assignment
							UpperCAmelCase_    :      Optional[int]            =						ids_tensor([self.batch_size, self.seq_length, 4]				,		self.range_bbox   ).numpy()
							# Ensure that bbox is legal
							for i in range(bbox.shape[0]   ):
												for j in range(bbox.shape[1]   ):
																	if bbox[i, j, 3] < bbox[i, j, 1]:
																						UpperCAmelCase_    :      Optional[int]            =						bbox[i, j, 3]
																						UpperCAmelCase_    :      Tuple            =						bbox[i, j, 1]
																						UpperCAmelCase_    :      Union[str, Any]            =						t
																	if bbox[i, j, 2] < bbox[i, j, 0]:
																						UpperCAmelCase_    :      List[str]            =						bbox[i, j, 2]
																						UpperCAmelCase_    :      Tuple            =						bbox[i, j, 0]
																						UpperCAmelCase_    :      Tuple            =						t
							UpperCAmelCase_    :      Optional[Any]            =						tf.convert_to_tensor(_UpperCamelCase   )

							UpperCAmelCase_    :      str            =						None
							if self.use_input_mask:
												UpperCAmelCase_    :      Dict            =						random_attention_mask([self.batch_size, self.seq_length]   )

							UpperCAmelCase_    :      Union[str, Any]            =						None
							if self.use_token_type_ids:
												UpperCAmelCase_    :      str            =						ids_tensor([self.batch_size, self.seq_length]				,		self.type_vocab_size   )

							UpperCAmelCase_    :      str            =						None
							UpperCAmelCase_    :      Any            =						None
							UpperCAmelCase_    :      Optional[Any]            =						None
							if self.use_labels:
												UpperCAmelCase_    :      Optional[Any]            =						ids_tensor([self.batch_size]				,		self.type_sequence_label_size   )
												UpperCAmelCase_    :      List[Any]            =						ids_tensor([self.batch_size, self.seq_length]				,		self.num_labels   )
												UpperCAmelCase_    :      List[str]            =						ids_tensor([self.batch_size]				,		self.num_choices   )

							UpperCAmelCase_    :      Tuple            =						LayoutLMConfig(
							    vocab_size=self.vocab_size				,		hidden_size=self.hidden_size				,		num_hidden_layers=self.num_hidden_layers				,		num_attention_heads=self.num_attention_heads				,		intermediate_size=self.intermediate_size				,		hidden_act=self.hidden_act				,		hidden_dropout_prob=self.hidden_dropout_prob				,		attention_probs_dropout_prob=self.attention_probs_dropout_prob				,		max_position_embeddings=self.max_position_embeddings				,		type_vocab_size=self.type_vocab_size				,		initializer_range=self.initializer_range				,		)

							return config, input_ids, bbox, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels



		def 					__UpperCAmelCase			(							self				,		_UpperCamelCase				,		_UpperCamelCase				,		_UpperCamelCase				,		_UpperCamelCase				,		_UpperCamelCase				,		_UpperCamelCase				,		_UpperCamelCase				,		_UpperCamelCase   )	->							Optional[int]:
							UpperCAmelCase_    :      Any            =						TFLayoutLMModel(config=_UpperCamelCase   )

							UpperCAmelCase_    :      List[Any]            =						model(_UpperCamelCase				,		_UpperCamelCase				,		attention_mask=_UpperCamelCase				,		token_type_ids=_UpperCamelCase   )
							UpperCAmelCase_    :      Union[str, Any]            =						model(_UpperCamelCase				,		_UpperCamelCase				,		token_type_ids=_UpperCamelCase   )
							UpperCAmelCase_    :      Tuple            =						model(_UpperCamelCase				,		_UpperCamelCase   )
							self.parent.assertEqual(result.last_hidden_state.shape				,		(self.batch_size, self.seq_length, self.hidden_size)   )
							self.parent.assertEqual(result.pooler_output.shape				,		(self.batch_size, self.hidden_size)   )



		def 					__UpperCAmelCase			(							self				,		_UpperCamelCase				,		_UpperCamelCase				,		_UpperCamelCase				,		_UpperCamelCase				,		_UpperCamelCase				,		_UpperCamelCase				,		_UpperCamelCase				,		_UpperCamelCase   )	->							Optional[Any]:
							UpperCAmelCase_    :      List[Any]            =						TFLayoutLMForMaskedLM(config=_UpperCamelCase   )

							UpperCAmelCase_    :      Optional[Any]            =						model(_UpperCamelCase				,		_UpperCamelCase				,		attention_mask=_UpperCamelCase				,		token_type_ids=_UpperCamelCase				,		labels=_UpperCamelCase   )
							self.parent.assertEqual(result.logits.shape				,		(self.batch_size, self.seq_length, self.vocab_size)   )



		def 					__UpperCAmelCase			(							self				,		_UpperCamelCase				,		_UpperCamelCase				,		_UpperCamelCase				,		_UpperCamelCase				,		_UpperCamelCase				,		_UpperCamelCase				,		_UpperCamelCase				,		_UpperCamelCase   )	->							int:
							UpperCAmelCase_    :      List[Any]            =						self.num_labels
							UpperCAmelCase_    :      Union[str, Any]            =						TFLayoutLMForSequenceClassification(config=_UpperCamelCase   )

							UpperCAmelCase_    :      Dict            =						model(_UpperCamelCase				,		_UpperCamelCase				,		attention_mask=_UpperCamelCase				,		token_type_ids=_UpperCamelCase   )
							self.parent.assertEqual(result.logits.shape				,		(self.batch_size, self.num_labels)   )



		def 					__UpperCAmelCase			(							self				,		_UpperCamelCase				,		_UpperCamelCase				,		_UpperCamelCase				,		_UpperCamelCase				,		_UpperCamelCase				,		_UpperCamelCase				,		_UpperCamelCase				,		_UpperCamelCase   )	->							Optional[int]:
							UpperCAmelCase_    :      List[Any]            =						self.num_labels
							UpperCAmelCase_    :      int            =						TFLayoutLMForTokenClassification(config=_UpperCamelCase   )

							UpperCAmelCase_    :      Optional[Any]            =						model(_UpperCamelCase				,		_UpperCamelCase				,		attention_mask=_UpperCamelCase				,		token_type_ids=_UpperCamelCase				,		labels=_UpperCamelCase   )
							self.parent.assertEqual(result.logits.shape				,		(self.batch_size, self.seq_length, self.num_labels)   )



		def 					__UpperCAmelCase			(							self				,		_UpperCamelCase				,		_UpperCamelCase				,		_UpperCamelCase				,		_UpperCamelCase				,		_UpperCamelCase				,		_UpperCamelCase				,		_UpperCamelCase				,		_UpperCamelCase   )	->							Any:
							UpperCAmelCase_    :      List[str]            =						TFLayoutLMForQuestionAnswering(config=_UpperCamelCase   )

							UpperCAmelCase_    :      Union[str, Any]            =						model(_UpperCamelCase				,		_UpperCamelCase				,		attention_mask=_UpperCamelCase				,		token_type_ids=_UpperCamelCase   )
							self.parent.assertEqual(result.start_logits.shape				,		(self.batch_size, self.seq_length)   )
							self.parent.assertEqual(result.end_logits.shape				,		(self.batch_size, self.seq_length)   )



		def 					__UpperCAmelCase			(							self   )	->							List[Any]:
							UpperCAmelCase_    :      Dict            =						self.prepare_config_and_inputs()
							(
							    (
							    UpperCAmelCase_
							)       ,  (
							    UpperCAmelCase_
							)       ,  (
							    UpperCAmelCase_
							)       ,  (
							    UpperCAmelCase_
							)       ,  (
							    UpperCAmelCase_
							)       ,  (
							    UpperCAmelCase_
							)       ,  (
							    UpperCAmelCase_
							)       ,  (
							    UpperCAmelCase_
							)       ,  
							)    :      Tuple            =						config_and_inputs
							UpperCAmelCase_    :      List[Any]            =						{
							    'input_ids': input_ids,
							    'bbox': bbox,
							    'token_type_ids': token_type_ids,
							    'attention_mask': input_mask,
							}
							return config, inputs_dict





@require_tf
class   lowerCamelCase      (_snake_case ,  _snake_case ,  unittest.TestCase			):







		'''simple docstring'''



		_snake_case    :    int       						=  (
		    (
		        TFLayoutLMModel,
		        TFLayoutLMForMaskedLM,
		        TFLayoutLMForTokenClassification,
		        TFLayoutLMForSequenceClassification,
		        TFLayoutLMForQuestionAnswering,
		    )
		    if is_tf_available()
		    else ()
		)
		_snake_case    :    List[Any]       						=  (
		    {
		        '''feature-extraction''': TFLayoutLMModel,
		        '''fill-mask''': TFLayoutLMForMaskedLM,
		        '''text-classification''': TFLayoutLMForSequenceClassification,
		        '''token-classification''': TFLayoutLMForTokenClassification,
		        '''zero-shot''': TFLayoutLMForSequenceClassification,
		    }
		    if is_tf_available()
		    else {}
		)
		_snake_case    :    Optional[int]       						=  False
		_snake_case    :    Dict       						=  True
		_snake_case    :    Dict       						=  1_0



		def 					__UpperCAmelCase			(							self   )	->							List[str]:
							UpperCAmelCase_    :      Tuple            =						TFLayoutLMModelTester(self   )
							UpperCAmelCase_    :      Any            =						ConfigTester(self				,		config_class=_UpperCamelCase				,		hidden_size=3_7   )



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



		def 					__UpperCAmelCase			(							self   )	->							List[Any]:
							UpperCAmelCase_    :      Union[str, Any]            =						self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_model(*_UpperCamelCase   )



		def 					__UpperCAmelCase			(							self   )	->							str:
							UpperCAmelCase_    :      int            =						self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_masked_lm(*_UpperCamelCase   )



		def 					__UpperCAmelCase			(							self   )	->							Optional[int]:
							UpperCAmelCase_    :      Tuple            =						self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_sequence_classification(*_UpperCamelCase   )



		def 					__UpperCAmelCase			(							self   )	->							Optional[Any]:
							UpperCAmelCase_    :      Optional[Any]            =						self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_token_classification(*_UpperCamelCase   )



		def 					__UpperCAmelCase			(							self   )	->							Union[str, Any]:
							UpperCAmelCase_    :      Optional[Any]            =						self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_question_answering(*_UpperCamelCase   )



		@slow
		def 					__UpperCAmelCase			(							self   )	->							List[str]:
							for model_name in TF_LAYOUTLM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
												UpperCAmelCase_    :      List[Any]            =						TFLayoutLMModel.from_pretrained(_UpperCamelCase   )
												self.assertIsNotNone(_UpperCamelCase   )



		@unittest.skip('Onnx compliancy broke with TF 2.10'   )
		def 					__UpperCAmelCase			(							self   )	->							Tuple:
							pass





def      lowercase__      (     ):


					'''simple docstring'''


					UpperCAmelCase_    :      Dict            =						tf.convert_to_tensor([[101,1_019,1_014,1_016,1_037,12_849,4_747,1_004,14_246,2_278,5_439,4_524,5_002,2_930,2_193,2_930,4_341,3_208,1_005,1_055,2_171,2_848,11_300,3_531,102],[101,4_070,4_034,7_020,1_024,3_058,1_015,1_013,2_861,1_013,6_070,19_274,2_772,6_205,27_814,16_147,16_147,4_343,2_047,10_283,10_969,14_389,1_012,2_338,102]]  )  # noqa: E231
					UpperCAmelCase_    :      Any            =						tf.convert_to_tensor([[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],]  )  # noqa: E231
					UpperCAmelCase_    :      str            =						tf.convert_to_tensor([[[0,0,0,0],[423,237,440,251],[427,272,441,287],[419,115,437,129],[961,885,992,912],[256,38,330,58],[256,38,330,58],[336,42,353,57],[360,39,401,56],[360,39,401,56],[411,39,471,59],[479,41,528,59],[533,39,630,60],[67,113,134,131],[141,115,209,132],[68,149,133,166],[141,149,187,164],[195,148,287,165],[195,148,287,165],[195,148,287,165],[295,148,349,165],[441,149,492,166],[497,149,546,164],[64,201,125,218],[1_000,1_000,1_000,1_000]],[[0,0,0,0],[662,150,754,166],[665,199,742,211],[519,213,554,228],[519,213,554,228],[134,433,187,454],[130,467,204,480],[130,467,204,480],[130,467,204,480],[130,467,204,480],[130,467,204,480],[314,469,376,482],[504,684,582,706],[941,825,973,900],[941,825,973,900],[941,825,973,900],[941,825,973,900],[610,749,652,765],[130,659,168,672],[176,657,237,672],[238,657,312,672],[443,653,628,672],[443,653,628,672],[716,301,825,317],[1_000,1_000,1_000,1_000]]]  )  # noqa: E231
					UpperCAmelCase_    :      Any            =						tf.convert_to_tensor([[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]]  )  # noqa: E231
					# these are sequence labels (i.e. at the token level)
					UpperCAmelCase_    :      int            =						tf.convert_to_tensor([[-100,10,10,10,9,1,-100,7,7,-100,7,7,4,2,5,2,8,8,-100,-100,5,0,3,2,-100],[-100,12,12,12,-100,12,10,-100,-100,-100,-100,10,12,9,-100,-100,-100,10,10,10,9,12,-100,10,-100]]  )  # noqa: E231
					# fmt: on

					return input_ids, attention_mask, bbox, token_type_ids, labels






@require_tf
class   lowerCamelCase      (unittest.TestCase			):







		'''simple docstring'''



		@slow
		def 					__UpperCAmelCase			(							self   )	->							Tuple:
							UpperCAmelCase_    :      List[Any]            =						TFLayoutLMModel.from_pretrained('microsoft/layoutlm-base-uncased'   )

							UpperCAmelCase_       ,  UpperCAmelCase_       ,  UpperCAmelCase_       ,  UpperCAmelCase_       ,  UpperCAmelCase_    :      Any            =						prepare_layoutlm_batch_inputs()

							# forward pass
							UpperCAmelCase_    :      Union[str, Any]            =						model(input_ids=_UpperCamelCase				,		bbox=_UpperCamelCase				,		attention_mask=_UpperCamelCase				,		token_type_ids=_UpperCamelCase   )

							# test the sequence output on [0, :3, :3]
							UpperCAmelCase_    :      Any            =						tf.convert_to_tensor(
							    [[0.17_85, -0.19_47, -0.04_25], [-0.32_54, -0.28_07, 0.25_53], [-0.53_91, -0.33_22, 0.33_64]]				,		)

							self.assertTrue(np.allclose(outputs.last_hidden_state[0, :3, :3]				,		_UpperCamelCase				,		atol=1E-3   )   )

							# test the pooled output on [1, :3]
							UpperCAmelCase_    :      Tuple            =						tf.convert_to_tensor([-0.65_80, -0.02_14, 0.85_52]   )

							self.assertTrue(np.allclose(outputs.pooler_output[1, :3]				,		_UpperCamelCase				,		atol=1E-3   )   )



		@slow
		def 					__UpperCAmelCase			(							self   )	->							str:
							# initialize model with randomly initialized sequence classification head
							UpperCAmelCase_    :      Union[str, Any]            =						TFLayoutLMForSequenceClassification.from_pretrained('microsoft/layoutlm-base-uncased'				,		num_labels=2   )

							UpperCAmelCase_       ,  UpperCAmelCase_       ,  UpperCAmelCase_       ,  UpperCAmelCase_       ,  UpperCAmelCase_    :      List[str]            =						prepare_layoutlm_batch_inputs()

							# forward pass
							UpperCAmelCase_    :      str            =						model(
							    input_ids=_UpperCamelCase				,		bbox=_UpperCamelCase				,		attention_mask=_UpperCamelCase				,		token_type_ids=_UpperCamelCase				,		labels=tf.convert_to_tensor([1, 1]   )				,		)

							# test whether we get a loss as a scalar
							UpperCAmelCase_    :      List[str]            =						outputs.loss
							UpperCAmelCase_    :      Tuple            =						(2,)
							self.assertEqual(loss.shape				,		_UpperCamelCase   )

							# test the shape of the logits
							UpperCAmelCase_    :      Dict            =						outputs.logits
							UpperCAmelCase_    :      List[str]            =						(2, 2)
							self.assertEqual(logits.shape				,		_UpperCamelCase   )



		@slow
		def 					__UpperCAmelCase			(							self   )	->							List[Any]:
							# initialize model with randomly initialized token classification head
							UpperCAmelCase_    :      int            =						TFLayoutLMForTokenClassification.from_pretrained('microsoft/layoutlm-base-uncased'				,		num_labels=1_3   )

							UpperCAmelCase_       ,  UpperCAmelCase_       ,  UpperCAmelCase_       ,  UpperCAmelCase_       ,  UpperCAmelCase_    :      str            =						prepare_layoutlm_batch_inputs()

							# forward pass
							UpperCAmelCase_    :      str            =						model(
							    input_ids=_UpperCamelCase				,		bbox=_UpperCamelCase				,		attention_mask=_UpperCamelCase				,		token_type_ids=_UpperCamelCase				,		labels=_UpperCamelCase   )

							# test the shape of the logits
							UpperCAmelCase_    :      int            =						outputs.logits
							UpperCAmelCase_    :      str            =						tf.convert_to_tensor((2, 2_5, 1_3)   )
							self.assertEqual(logits.shape				,		_UpperCamelCase   )



		@slow
		def 					__UpperCAmelCase			(							self   )	->							List[str]:
							# initialize model with randomly initialized token classification head
							UpperCAmelCase_    :      Tuple            =						TFLayoutLMForQuestionAnswering.from_pretrained('microsoft/layoutlm-base-uncased'   )

							UpperCAmelCase_       ,  UpperCAmelCase_       ,  UpperCAmelCase_       ,  UpperCAmelCase_       ,  UpperCAmelCase_    :      int            =						prepare_layoutlm_batch_inputs()

							# forward pass
							UpperCAmelCase_    :      Tuple            =						model(input_ids=_UpperCamelCase				,		bbox=_UpperCamelCase				,		attention_mask=_UpperCamelCase				,		token_type_ids=_UpperCamelCase   )

							# test the shape of the logits
							UpperCAmelCase_    :      Tuple            =						tf.convert_to_tensor((2, 2_5)   )
							self.assertEqual(outputs.start_logits.shape				,		_UpperCamelCase   )
							self.assertEqual(outputs.end_logits.shape				,		_UpperCamelCase   )














import random
import unittest

import torch

from diffusers import IFImgaImgSuperResolutionPipeline
from diffusers.utils import floats_tensor
from diffusers.utils.import_utils import is_xformers_available
from diffusers.utils.testing_utils import skip_mps, torch_device

from ..pipeline_params import TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS, TEXT_GUIDED_IMAGE_VARIATION_PARAMS
from ..test_pipelines_common import PipelineTesterMixin
from . import IFPipelineTesterMixin



@skip_mps
class   lowerCamelCase      (_snake_case ,  _snake_case ,  unittest.TestCase			):







		'''simple docstring'''



		_snake_case    :    Union[str, Any]       						=  IFImgaImgSuperResolutionPipeline
		_snake_case    :    Union[str, Any]       						=  TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {'''width''', '''height'''}
		_snake_case    :    List[Any]       						=  TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS.union({'''original_image'''}			)
		_snake_case    :    List[str]       						=  PipelineTesterMixin.required_optional_params - {'''latents'''}



		def 					__UpperCAmelCase			(							self   )	->							Optional[Any]:
							return self._get_superresolution_dummy_components()



		def 					__UpperCAmelCase			(							self				,		_UpperCamelCase				,		_UpperCamelCase=0   )	->							Any:
							if str(_UpperCamelCase   ).startswith('mps'   ):
												UpperCAmelCase_    :      List[Any]            =						torch.manual_seed(_UpperCamelCase   )
							else:
												UpperCAmelCase_    :      int            =						torch.Generator(device=_UpperCamelCase   ).manual_seed(_UpperCamelCase   )

							UpperCAmelCase_    :      List[Any]            =						floats_tensor((1, 3, 3_2, 3_2)				,		rng=random.Random(_UpperCamelCase   )   ).to(_UpperCamelCase   )
							UpperCAmelCase_    :      Dict            =						floats_tensor((1, 3, 1_6, 1_6)				,		rng=random.Random(_UpperCamelCase   )   ).to(_UpperCamelCase   )

							UpperCAmelCase_    :      Tuple            =						{
							    'prompt': 'A painting of a squirrel eating a burger',
							    'image': image,
							    'original_image': original_image,
							    'generator': generator,
							    'num_inference_steps': 2,
							    'output_type': 'numpy',
							}

							return inputs



		@unittest.skipIf(
		    torch_device != 'cuda' or not is_xformers_available()				,		reason='XFormers attention is only available with CUDA and `xformers` installed'				,		)
		def 					__UpperCAmelCase			(							self   )	->							Any:
							self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1E-3   )



		def 					__UpperCAmelCase			(							self   )	->							Dict:
							self._test_save_load_optional_components()



		@unittest.skipIf(torch_device != 'cuda'				,		reason='float16 requires CUDA'   )
		def 					__UpperCAmelCase			(							self   )	->							str:
							# Due to non-determinism in save load of the hf-internal-testing/tiny-random-t5 text encoder
							super().test_save_load_floataa(expected_max_diff=1E-1   )



		def 					__UpperCAmelCase			(							self   )	->							List[Any]:
							self._test_attention_slicing_forward_pass(expected_max_diff=1E-2   )



		def 					__UpperCAmelCase			(							self   )	->							Union[str, Any]:
							self._test_save_load_local()



		def 					__UpperCAmelCase			(							self   )	->							Dict:
							self._test_inference_batch_single_identical(
							    expected_max_diff=1E-2				,		)






