



"""simple docstring"""
import shutil
import tempfile
import unittest

from transformers import SPIECE_UNDERLINE, BatchEncoding, MBartaaTokenizer, MBartaaTokenizerFast, is_torch_available
from transformers.testing_utils import (
    get_tests_dir,
    nested_simplify,
    require_sentencepiece,
    require_tokenizers,
    require_torch,
    slow,
)

from ...test_tokenization_common import TokenizerTesterMixin


__a      =				get_tests_dir("fixtures/test_sentencepiece.model")

if is_torch_available():
						from transformers.models.mbart.modeling_mbart import shift_tokens_right

__a      =				25_00_04
__a      =				25_00_20
@require_sentencepiece
@require_tokenizers
class 				lowerCamelCase  (			_lowerCAmelCase    ,						unittest.TestCase				):






					'''simple docstring'''





					_A		:			Optional[int]						=     MBartaaTokenizer
					_A		:			List[Any]						=     MBartaaTokenizerFast
					_A		:			str						=     True
					_A		:			int						=     True






					def    lowerCAmelCase_				(       self:							Dict						)   ->	List[str]:
											super().setUp()

											# We have a SentencePiece fixture for testing
											snake_case_ :str						=			MBartaaTokenizer(__UpperCAmelCase						,     src_lang="""en_XX"""						,     tgt_lang="""ro_RO"""						,     keep_accents=__UpperCAmelCase						)
											tokenizer.save_pretrained(self.tmpdirname						)






					def    lowerCAmelCase_				(       self:							Any						)   ->	Union[str, Any]:
											snake_case_ :Tuple						=			'<s>'
											snake_case_ :Optional[Any]						=			0

											self.assertEqual(self.get_tokenizer()._convert_token_to_id(__UpperCAmelCase						)						,     __UpperCAmelCase						)
											self.assertEqual(self.get_tokenizer()._convert_id_to_token(__UpperCAmelCase						)						,     __UpperCAmelCase						)






					def    lowerCAmelCase_				(       self:							Optional[Any]						)   ->	Tuple:
											snake_case_ :int						=			list(self.get_tokenizer().get_vocab().keys()						)

											self.assertEqual(vocab_keys[0]						,     """<s>"""						)
											self.assertEqual(vocab_keys[1]						,     """<pad>"""						)
											self.assertEqual(vocab_keys[-1]						,     """<mask>"""						)
											self.assertEqual(len(__UpperCAmelCase						)						,     1_054						)






					def    lowerCAmelCase_				(       self:							Tuple						)   ->	List[str]:
											self.assertEqual(self.get_tokenizer().vocab_size						,     1_054						)






					def    lowerCAmelCase_				(       self:							Any						)   ->	Optional[int]:
											snake_case_ :Tuple						=			MBartaaTokenizer(__UpperCAmelCase						,     src_lang="""en_XX"""						,     tgt_lang="""ro_RO"""						,     keep_accents=__UpperCAmelCase						)

											snake_case_ :Any						=			tokenizer.tokenize("""This is a test"""						)
											self.assertListEqual(__UpperCAmelCase						,     ["""▁This""", """▁is""", """▁a""", """▁t""", """est"""]						)

											self.assertListEqual(
											    tokenizer.convert_tokens_to_ids(__UpperCAmelCase						)						,     [value + tokenizer.fairseq_offset for value in [285, 46, 10, 170, 382]]						,     )

											snake_case_ :List[str]						=			tokenizer.tokenize("""I was born in 92000, and this is falsé."""						)
											self.assertListEqual(
											    __UpperCAmelCase						,     [SPIECE_UNDERLINE + """I""", SPIECE_UNDERLINE + """was""", SPIECE_UNDERLINE + """b""", """or""", """n""", SPIECE_UNDERLINE + """in""", SPIECE_UNDERLINE + """""", """9""", """2""", """0""", """0""", """0""", """,""", SPIECE_UNDERLINE + """and""", SPIECE_UNDERLINE + """this""", SPIECE_UNDERLINE + """is""", SPIECE_UNDERLINE + """f""", """al""", """s""", """é""", """."""]						,     )
											snake_case_ :List[Any]						=			tokenizer.convert_tokens_to_ids(__UpperCAmelCase						)
											self.assertListEqual(
											    __UpperCAmelCase						,     [
											        value + tokenizer.fairseq_offset
											        for value in [8, 21, 84, 55, 24, 19, 7, 2, 602, 347, 347, 347, 3, 12, 66, 46, 72, 80, 6, 2, 4]
											    ]						,     )

											snake_case_ :str						=			tokenizer.convert_ids_to_tokens(__UpperCAmelCase						)
											self.assertListEqual(
											    __UpperCAmelCase						,     [SPIECE_UNDERLINE + """I""", SPIECE_UNDERLINE + """was""", SPIECE_UNDERLINE + """b""", """or""", """n""", SPIECE_UNDERLINE + """in""", SPIECE_UNDERLINE + """""", """<unk>""", """2""", """0""", """0""", """0""", """,""", SPIECE_UNDERLINE + """and""", SPIECE_UNDERLINE + """this""", SPIECE_UNDERLINE + """is""", SPIECE_UNDERLINE + """f""", """al""", """s""", """<unk>""", """."""]						,     )






					@slow
					def    lowerCAmelCase_				(       self:							Optional[Any]						)   ->	Dict:
											snake_case_ :Any						=			{'input_ids': [[250_004, 11_062, 82_772, 7, 15, 82_772, 538, 51_529, 237, 17_198, 1_290, 206, 9, 215_175, 1_314, 136, 17_198, 1_290, 206, 9, 56_359, 42, 122_009, 9, 16_466, 16, 87_344, 4_537, 9, 4_717, 78_381, 6, 159_958, 7, 15, 24_480, 618, 4, 527, 22_693, 5_428, 4, 2_777, 24_480, 9_874, 4, 43_523, 594, 4, 803, 18_392, 33_189, 18, 4, 43_523, 24_447, 12_399, 100, 24_955, 83_658, 9_626, 144_057, 15, 839, 22_335, 16, 136, 24_955, 83_658, 83_479, 15, 39_102, 724, 16, 678, 645, 2_789, 1_328, 4_589, 42, 122_009, 115_774, 23, 805, 1_328, 46_876, 7, 136, 53_894, 1_940, 42_227, 41_159, 17_721, 823, 425, 4, 27_512, 98_722, 206, 136, 5_531, 4_970, 919, 17_336, 5, 2], [250_004, 20_080, 618, 83, 82_775, 47, 479, 9, 1_517, 73, 53_894, 333, 80_581, 110_117, 18_811, 5_256, 1_295, 51, 152_526, 297, 7_986, 390, 124_416, 538, 35_431, 214, 98, 15_044, 25_737, 136, 7_108, 43_701, 23, 756, 135_355, 7, 5, 2, 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, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [250_004, 581, 63_773, 119_455, 6, 147_797, 88_203, 7, 645, 70, 21, 3_285, 10_269, 5, 2, 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, 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]], 'attention_mask': [[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, 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, 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, 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 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, 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: E501
											# fmt: on

											self.tokenizer_integration_test_util(
											    expected_encoding=__UpperCAmelCase						,     model_name="""facebook/mbart-large-50"""						,     revision="""d3913889c59cd5c9e456b269c376325eabad57e2"""						,     )






					def    lowerCAmelCase_				(       self:							List[str]						)   ->	Dict:

											if not self.test_slow_tokenizer:
																	# as we don't have a slow version, we can't compare the outputs between slow and fast versions
																	return

											snake_case_ :Optional[Any]						=			(self.rust_tokenizer_class, 'hf-internal-testing/tiny-random-mbart50', {})
											for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
																	with self.subTest(f"""{tokenizer.__class__.__name__} ({pretrained_name})"""						):
																							snake_case_ :Union[str, Any]						=			self.rust_tokenizer_class.from_pretrained(__UpperCAmelCase						,     **__UpperCAmelCase						)
																							snake_case_ :Optional[Any]						=			self.tokenizer_class.from_pretrained(__UpperCAmelCase						,     **__UpperCAmelCase						)

																							snake_case_ :List[str]						=			tempfile.mkdtemp()

																							snake_case_ :int						=			tokenizer_r.save_pretrained(__UpperCAmelCase						)
																							snake_case_ :List[Any]						=			tokenizer_p.save_pretrained(__UpperCAmelCase						)

																							# Checks it save with the same files + the tokenizer.json file for the fast one
																							self.assertTrue(any("""tokenizer.json""" in f for f in tokenizer_r_files						)						)
																							snake_case_ :List[Any]						=			tuple(f for f in tokenizer_r_files if """tokenizer.json""" not in f						)
																							self.assertSequenceEqual(__UpperCAmelCase						,     __UpperCAmelCase						)

																							# Checks everything loads correctly in the same way
																							snake_case_ :Any						=			tokenizer_r.from_pretrained(__UpperCAmelCase						)
																							snake_case_ :Optional[Any]						=			tokenizer_p.from_pretrained(__UpperCAmelCase						)

																							# Check special tokens are set accordingly on Rust and Python
																							for key in tokenizer_pp.special_tokens_map:
																													self.assertTrue(hasattr(__UpperCAmelCase						,     __UpperCAmelCase						)						)
																													# self.assertEqual(getattr(tokenizer_rp, key), getattr(tokenizer_pp, key))
																													# self.assertEqual(getattr(tokenizer_rp, key + "_id"), getattr(tokenizer_pp, key + "_id"))

																							shutil.rmtree(__UpperCAmelCase						)

																							# Save tokenizer rust, legacy_format=True
																							snake_case_ :Any						=			tempfile.mkdtemp()

																							snake_case_ :str						=			tokenizer_r.save_pretrained(__UpperCAmelCase						,     legacy_format=__UpperCAmelCase						)
																							snake_case_ :List[Any]						=			tokenizer_p.save_pretrained(__UpperCAmelCase						)

																							# Checks it save with the same files
																							self.assertSequenceEqual(__UpperCAmelCase						,     __UpperCAmelCase						)

																							# Checks everything loads correctly in the same way
																							snake_case_ :int						=			tokenizer_r.from_pretrained(__UpperCAmelCase						)
																							snake_case_ :int						=			tokenizer_p.from_pretrained(__UpperCAmelCase						)

																							# Check special tokens are set accordingly on Rust and Python
																							for key in tokenizer_pp.special_tokens_map:
																													self.assertTrue(hasattr(__UpperCAmelCase						,     __UpperCAmelCase						)						)

																							shutil.rmtree(__UpperCAmelCase						)

																							# Save tokenizer rust, legacy_format=False
																							snake_case_ :str						=			tempfile.mkdtemp()

																							snake_case_ :str						=			tokenizer_r.save_pretrained(__UpperCAmelCase						,     legacy_format=__UpperCAmelCase						)
																							snake_case_ :List[str]						=			tokenizer_p.save_pretrained(__UpperCAmelCase						)

																							# Checks it saved the tokenizer.json file
																							self.assertTrue(any("""tokenizer.json""" in f for f in tokenizer_r_files						)						)

																							# Checks everything loads correctly in the same way
																							snake_case_ :Optional[int]						=			tokenizer_r.from_pretrained(__UpperCAmelCase						)
																							snake_case_ :Optional[int]						=			tokenizer_p.from_pretrained(__UpperCAmelCase						)

																							# Check special tokens are set accordingly on Rust and Python
																							for key in tokenizer_pp.special_tokens_map:
																													self.assertTrue(hasattr(__UpperCAmelCase						,     __UpperCAmelCase						)						)

																							shutil.rmtree(__UpperCAmelCase						)

@require_torch
@require_sentencepiece
@require_tokenizers
class 				lowerCamelCase  (			unittest.TestCase				):






					'''simple docstring'''





					_A		:			List[str]						=     """facebook/mbart-large-50-one-to-many-mmt"""
					_A		:			Dict						=     [
					    """ UN Chief Says There Is No Military Solution in Syria""",
					    """ Secretary-General Ban Ki-moon says his response to Russia's stepped up military support for Syria is that \"there is no military solution\" to the nearly five-year conflict and more weapons will only worsen the violence and misery for millions of people.""",
					]
					_A		:			str						=     [
					    """Şeful ONU declară că nu există o soluţie militară în Siria""",
					    """Secretarul General Ban Ki-moon declară că răspunsul său la intensificarea sprijinului militar al Rusiei"""
					    """ pentru Siria este că \"nu există o soluţie militară\" la conflictul de aproape cinci ani şi că noi arme nu vor"""
					    """ face decât să înrăutăţească violenţele şi mizeria pentru milioane de oameni.""",
					]
					_A		:			Union[str, Any]						=     [EN_CODE, 8_2_7_4, 1_2_7_8_7_3, 2_5_9_1_6, 7, 8_6_2_2, 2_0_7_1, 4_3_8, 6_7_4_8_5, 5_3, 1_8_7_8_9_5, 2_3, 5_1_7_1_2, 2]






					@classmethod
					def    lowerCAmelCase_				(       cls:							List[Any]						)   ->	Optional[Any]:
											snake_case_ :MBartaaTokenizer						=			MBartaaTokenizer.from_pretrained(
											    cls.checkpoint_name						,     src_lang="""en_XX"""						,     tgt_lang="""ro_RO"""						)
											snake_case_ :List[Any]						=			1
											return cls






					def    lowerCAmelCase_				(       self:							Tuple						)   ->	List[Any]:
											self.assertEqual(self.tokenizer.fairseq_tokens_to_ids["""ar_AR"""]						,     250_001						)
											self.assertEqual(self.tokenizer.fairseq_tokens_to_ids["""en_EN"""]						,     250_004						)
											self.assertEqual(self.tokenizer.fairseq_tokens_to_ids["""ro_RO"""]						,     250_020						)
											self.assertEqual(self.tokenizer.fairseq_tokens_to_ids["""mr_IN"""]						,     250_038						)






					def    lowerCAmelCase_				(       self:							List[str]						)   ->	Optional[Any]:
											snake_case_ :Optional[int]						=			self.tokenizer.batch_encode_plus(self.src_text						).input_ids[0]
											self.assertListEqual(self.expected_src_tokens						,     __UpperCAmelCase						)






					def    lowerCAmelCase_				(       self:							List[Any]						)   ->	Union[str, Any]:
											self.assertIn(__UpperCAmelCase						,     self.tokenizer.all_special_ids						)
											snake_case_ :Dict						=			[RO_CODE, 884, 9_019, 96, 9, 916, 86_792, 36, 18_743, 15_596, 5, 2]
											snake_case_ :str						=			self.tokenizer.decode(__UpperCAmelCase						,     skip_special_tokens=__UpperCAmelCase						)
											snake_case_ :Dict						=			self.tokenizer.decode(generated_ids[1:]						,     skip_special_tokens=__UpperCAmelCase						)
											self.assertEqual(__UpperCAmelCase						,     __UpperCAmelCase						)
											self.assertNotIn(self.tokenizer.eos_token						,     __UpperCAmelCase						)






					def    lowerCAmelCase_				(       self:							int						)   ->	List[str]:
											snake_case_ :str						=			['this is gunna be a long sentence ' * 20]
											assert isinstance(src_text[0]						,     __UpperCAmelCase						)
											snake_case_ :Dict						=			10
											snake_case_ :List[str]						=			self.tokenizer(__UpperCAmelCase						,     max_length=__UpperCAmelCase						,     truncation=__UpperCAmelCase						).input_ids[0]
											self.assertEqual(ids[0]						,     __UpperCAmelCase						)
											self.assertEqual(ids[-1]						,     2						)
											self.assertEqual(len(__UpperCAmelCase						)						,     __UpperCAmelCase						)






					def    lowerCAmelCase_				(       self:							Union[str, Any]						)   ->	Any:
											self.assertListEqual(self.tokenizer.convert_tokens_to_ids(["""<mask>""", """ar_AR"""]						)						,     [250_053, 250_001]						)






					def    lowerCAmelCase_				(       self:							Dict						)   ->	Tuple:
											snake_case_ :Optional[int]						=			tempfile.mkdtemp()
											snake_case_ :List[str]						=			self.tokenizer.fairseq_tokens_to_ids
											self.tokenizer.save_pretrained(__UpperCAmelCase						)
											snake_case_ :Optional[int]						=			MBartaaTokenizer.from_pretrained(__UpperCAmelCase						)
											self.assertDictEqual(new_tok.fairseq_tokens_to_ids						,     __UpperCAmelCase						)






					@require_torch
					def    lowerCAmelCase_				(       self:							str						)   ->	Tuple:
											snake_case_ :List[str]						=			self.tokenizer(self.src_text						,     text_target=self.tgt_text						,     padding=__UpperCAmelCase						,     return_tensors="""pt"""						)
											snake_case_ :Dict						=			shift_tokens_right(batch["""labels"""]						,     self.tokenizer.pad_token_id						)

											# fairseq batch: https://gist.github.com/sshleifer/cba08bc2109361a74ac3760a7e30e4f4
											assert batch.input_ids[1][0] == EN_CODE
											assert batch.input_ids[1][-1] == 2
											assert batch.labels[1][0] == RO_CODE
											assert batch.labels[1][-1] == 2
											assert batch.decoder_input_ids[1][:2].tolist() == [2, RO_CODE]






					@require_torch
					def    lowerCAmelCase_				(       self:							Dict						)   ->	List[str]:
											snake_case_ :Any						=			self.tokenizer(
											    self.src_text						,     text_target=self.tgt_text						,     padding=__UpperCAmelCase						,     truncation=__UpperCAmelCase						,     max_length=len(self.expected_src_tokens						)						,     return_tensors="""pt"""						,     )
											snake_case_ :List[Any]						=			shift_tokens_right(batch["""labels"""]						,     self.tokenizer.pad_token_id						)

											self.assertIsInstance(__UpperCAmelCase						,     __UpperCAmelCase						)

											self.assertEqual((2, 14)						,     batch.input_ids.shape						)
											self.assertEqual((2, 14)						,     batch.attention_mask.shape						)
											snake_case_ :Dict						=			batch.input_ids.tolist()[0]
											self.assertListEqual(self.expected_src_tokens						,     __UpperCAmelCase						)
											self.assertEqual(2						,     batch.decoder_input_ids[0, 0]						)  # decoder_start_token_id
											# Test that special tokens are reset
											self.assertEqual(self.tokenizer.prefix_tokens						,     [EN_CODE]						)
											self.assertEqual(self.tokenizer.suffix_tokens						,     [self.tokenizer.eos_token_id]						)






					def    lowerCAmelCase_				(       self:							List[Any]						)   ->	Union[str, Any]:
											snake_case_ :Any						=			self.tokenizer(self.src_text						,     padding=__UpperCAmelCase						,     truncation=__UpperCAmelCase						,     max_length=3						,     return_tensors="""pt"""						)
											snake_case_ :Optional[Any]						=			self.tokenizer(
											    text_target=self.tgt_text						,     padding=__UpperCAmelCase						,     truncation=__UpperCAmelCase						,     max_length=10						,     return_tensors="""pt"""						)
											snake_case_ :str						=			targets['input_ids']
											snake_case_ :Union[str, Any]						=			shift_tokens_right(__UpperCAmelCase						,     self.tokenizer.pad_token_id						)

											self.assertEqual(batch.input_ids.shape[1]						,     3						)
											self.assertEqual(batch.decoder_input_ids.shape[1]						,     10						)






					@require_torch
					def    lowerCAmelCase_				(       self:							str						)   ->	Optional[int]:
											snake_case_ :Dict						=			self.tokenizer._build_translation_inputs(
											    """A test"""						,     return_tensors="""pt"""						,     src_lang="""en_XX"""						,     tgt_lang="""ar_AR"""						)

											self.assertEqual(
											    nested_simplify(__UpperCAmelCase						)						,     {
											        # en_XX, A, test, EOS
											        """input_ids""": [[250_004, 62, 3_034, 2]],
											        """attention_mask""": [[1, 1, 1, 1]],
											        # ar_AR
											        """forced_bos_token_id""": 250_001,
											    }						,     )







"""simple docstring"""





import gc
import random
import unittest

import numpy as np
import torch
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTextModelWithProjection, CLIPTokenizer

from diffusers import (
    AutoencoderKL,
    DiffusionPipeline,
    EulerDiscreteScheduler,
    StableDiffusionXLImgaImgPipeline,
    UNetaDConditionModel,
)
from diffusers.utils import floats_tensor, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

from ..pipeline_params import (
    IMAGE_TO_IMAGE_IMAGE_PARAMS,
    TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS,
    TEXT_GUIDED_IMAGE_VARIATION_PARAMS,
)
from ..test_pipelines_common import PipelineLatentTesterMixin, PipelineTesterMixin


enable_full_determinism()






class 					_lowerCAmelCase   (     a  ,   a  ,   unittest.TestCase       ):
       """simple docstring"""




       __magic_name__     :Tuple		  =					StableDiffusionXLImgaImgPipeline
       __magic_name__     :List[Any]		  =					TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {"""height""", """width"""}
       __magic_name__     :Optional[Any]		  =					PipelineTesterMixin.required_optional_params - {"""latents"""}
       __magic_name__     :Optional[Any]		  =					TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS
       __magic_name__     :str		  =					IMAGE_TO_IMAGE_IMAGE_PARAMS
       __magic_name__     :Any		  =					IMAGE_TO_IMAGE_IMAGE_PARAMS






       def      snake_case						(    self      ):



         '''simple docstring'''

         torch.manual_seed(0      )
         lowerCAmelCase__			:Optional[Any]											=							UNetaDConditionModel(
             block_out_channels=(3_2, 6_4)    , layers_per_block=2    , sample_size=3_2    , in_channels=4    , out_channels=4    , down_block_types=('DownBlock2D', 'CrossAttnDownBlock2D')    , up_block_types=('CrossAttnUpBlock2D', 'UpBlock2D')    , attention_head_dim=(2, 4)    , use_linear_projection=__UpperCAmelCase    , addition_embed_type='text_time'    , addition_time_embed_dim=8    , transformer_layers_per_block=(1, 2)    , projection_class_embeddings_input_dim=8_0    , cross_attention_dim=6_4    , )
         lowerCAmelCase__			:str											=							EulerDiscreteScheduler(
             beta_start=0.0_00_85    , beta_end=0.0_12    , steps_offset=1    , beta_schedule='scaled_linear'    , timestep_spacing='leading'    , )
         torch.manual_seed(0      )
         lowerCAmelCase__			:str											=							AutoencoderKL(
             block_out_channels=[3_2, 6_4]    , in_channels=3    , out_channels=3    , down_block_types=['DownEncoderBlock2D', 'DownEncoderBlock2D']    , up_block_types=['UpDecoderBlock2D', 'UpDecoderBlock2D']    , latent_channels=4    , sample_size=1_2_8    , )
         torch.manual_seed(0      )
         lowerCAmelCase__			:str											=							CLIPTextConfig(
             bos_token_id=0    , eos_token_id=2    , hidden_size=3_2    , intermediate_size=3_7    , layer_norm_eps=1E-05    , num_attention_heads=4    , num_hidden_layers=5    , pad_token_id=1    , vocab_size=1_0_0_0    , hidden_act='gelu'    , projection_dim=3_2    , )
         lowerCAmelCase__			:int											=							CLIPTextModel(__UpperCAmelCase      )
         lowerCAmelCase__			:Tuple											=							CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'    , local_files_only=__UpperCAmelCase      )

         lowerCAmelCase__			:Any											=							CLIPTextModelWithProjection(__UpperCAmelCase      )
         lowerCAmelCase__			:Optional[Any]											=							CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'    , local_files_only=__UpperCAmelCase      )

         lowerCAmelCase__			:str											=							{
             'unet': unet,
             'scheduler': scheduler,
             'vae': vae,
             'text_encoder': text_encoder,
             'tokenizer': tokenizer,
             'text_encoder_2': text_encoder_a,
             'tokenizer_2': tokenizer_a,
             # "safety_checker": None,
             # "feature_extractor": None,
         }
         return components






       def      snake_case						(    self    , __UpperCAmelCase    , __UpperCAmelCase=0      ):



         '''simple docstring'''

         lowerCAmelCase__			:Dict											=							floats_tensor((1, 3, 3_2, 3_2)    , rng=random.Random(__UpperCAmelCase      )      ).to(__UpperCAmelCase      )
         lowerCAmelCase__			:Optional[int]											=							image / 2 + 0.5
         if str(__UpperCAmelCase      ).startswith('mps'      ):
           lowerCAmelCase__			:Optional[int]											=							torch.manual_seed(__UpperCAmelCase      )
         else:
           lowerCAmelCase__			:Optional[Any]											=							torch.Generator(device=__UpperCAmelCase      ).manual_seed(__UpperCAmelCase      )
         lowerCAmelCase__			:Dict											=							{
             'prompt': 'A painting of a squirrel eating a burger',
             'image': image,
             'generator': generator,
             'num_inference_steps': 2,
             'guidance_scale': 5.0,
             'output_type': 'numpy',
             'strength': 0.75,
         }
         return inputs






       def      snake_case						(    self      ):



         '''simple docstring'''

         lowerCAmelCase__			:List[Any]											=							'cpu'  # ensure determinism for the device-dependent torch.Generator
         lowerCAmelCase__			:int											=							self.get_dummy_components()
         lowerCAmelCase__			:List[str]											=							StableDiffusionXLImgaImgPipeline(**__UpperCAmelCase      )
         lowerCAmelCase__			:str											=							sd_pipe.to(__UpperCAmelCase      )
         sd_pipe.set_progress_bar_config(disable=__UpperCAmelCase      )

         lowerCAmelCase__			:str											=							self.get_dummy_inputs(__UpperCAmelCase      )
         lowerCAmelCase__			:int											=							sd_pipe(**__UpperCAmelCase      ).images
         lowerCAmelCase__			:int											=							image[0, -3:, -3:, -1]

         assert image.shape == (1, 3_2, 3_2, 3)

         lowerCAmelCase__			:List[str]											=							np.array([0.46_56, 0.48_40, 0.44_39, 0.66_98, 0.55_74, 0.45_24, 0.57_99, 0.59_43, 0.51_65]      )

         assert np.abs(image_slice.flatten() - expected_slice      ).max() < 1E-2






       def      snake_case						(    self      ):



         '''simple docstring'''

         super().test_attention_slicing_forward_pass(expected_max_diff=3E-3      )






       def      snake_case						(    self      ):



         '''simple docstring'''

         super().test_inference_batch_single_identical(expected_max_diff=3E-3      )






       def      snake_case						(    self      ):



         '''simple docstring'''

         pass






       def      snake_case						(    self      ):



         '''simple docstring'''

         lowerCAmelCase__			:Tuple											=							self.get_dummy_components()
         lowerCAmelCase__			:str											=							StableDiffusionXLImgaImgPipeline(**__UpperCAmelCase      )
         lowerCAmelCase__			:str											=							sd_pipe.to(__UpperCAmelCase      )
         lowerCAmelCase__			:List[str]											=							sd_pipe.to(__UpperCAmelCase      )
         sd_pipe.set_progress_bar_config(disable=__UpperCAmelCase      )

         # forward without prompt embeds
         lowerCAmelCase__			:int											=							self.get_dummy_inputs(__UpperCAmelCase      )
         lowerCAmelCase__			:Optional[int]											=							3 * ['this is a negative prompt']
         lowerCAmelCase__			:Tuple											=							negative_prompt
         lowerCAmelCase__			:str											=							3 * [inputs['prompt']]

         lowerCAmelCase__			:Optional[Any]											=							sd_pipe(**__UpperCAmelCase      )
         lowerCAmelCase__			:List[Any]											=							output.images[0, -3:, -3:, -1]

         # forward with prompt embeds
         lowerCAmelCase__			:Optional[Any]											=							self.get_dummy_inputs(__UpperCAmelCase      )
         lowerCAmelCase__			:Tuple											=							3 * ['this is a negative prompt']
         lowerCAmelCase__			:str											=							3 * [inputs.pop('prompt'      )]

         (
             (
             lowerCAmelCase__
         )							,				(
             lowerCAmelCase__
         )							,				(
             lowerCAmelCase__
         )							,				(
             lowerCAmelCase__
         )							,				
         )			:List[str]											=							sd_pipe.encode_prompt(__UpperCAmelCase    , negative_prompt=__UpperCAmelCase      )

         lowerCAmelCase__			:str											=							sd_pipe(
             **__UpperCAmelCase    , prompt_embeds=__UpperCAmelCase    , negative_prompt_embeds=__UpperCAmelCase    , pooled_prompt_embeds=__UpperCAmelCase    , negative_pooled_prompt_embeds=__UpperCAmelCase    , )
         lowerCAmelCase__			:Optional[Any]											=							output.images[0, -3:, -3:, -1]

         # make sure that it's equal
         assert np.abs(image_slice_a.flatten() - image_slice_a.flatten()      ).max() < 1E-4






@slow
@require_torch_gpu
class 					_lowerCAmelCase   (     unittest.TestCase       ):
       """simple docstring"""




       def      snake_case						(    self      ):



         '''simple docstring'''

         super().tearDown()
         gc.collect()
         torch.cuda.empty_cache()






       def      snake_case						(    self    , __UpperCAmelCase    , __UpperCAmelCase="cpu"    , __UpperCAmelCase=torch.floataa    , __UpperCAmelCase=0      ):



         '''simple docstring'''

         lowerCAmelCase__			:Any											=							torch.Generator(device=__UpperCAmelCase      ).manual_seed(__UpperCAmelCase      )
         lowerCAmelCase__			:Dict											=							np.random.RandomState(__UpperCAmelCase      ).standard_normal((1, 4, 6_4, 6_4)      )
         lowerCAmelCase__			:Optional[int]											=							torch.from_numpy(__UpperCAmelCase      ).to(device=__UpperCAmelCase    , dtype=__UpperCAmelCase      )
         lowerCAmelCase__			:int											=							{
             'prompt': 'a photograph of an astronaut riding a horse',
             'latents': latents,
             'generator': generator,
             'num_inference_steps': 3,
             'guidance_scale': 7.5,
             'output_type': 'numpy',
         }
         return inputs






       def      snake_case						(    self      ):



         '''simple docstring'''

         lowerCAmelCase__			:List[Any]											=							DiffusionPipeline.from_pretrained('stabilityai/stable-diffusion-2-base'      )
         pipe.to(__UpperCAmelCase      )
         pipe.set_progress_bar_config(disable=__UpperCAmelCase      )

         lowerCAmelCase__			:Tuple											=							self.get_inputs(__UpperCAmelCase      )
         lowerCAmelCase__			:int											=							pipe(**__UpperCAmelCase      ).images
         lowerCAmelCase__			:Union[str, Any]											=							image[0, -3:, -3:, -1].flatten()

         assert image.shape == (1, 5_1_2, 5_1_2, 3)
         lowerCAmelCase__			:List[str]											=							np.array([0.4_94_93, 0.4_78_96, 0.4_07_98, 0.5_42_14, 0.5_32_12, 0.4_82_02, 0.4_76_56, 0.4_63_29, 0.4_85_06]      )
         assert np.abs(image_slice - expected_slice      ).max() < 7E-3
