


'''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


__UpperCAmelCase       							=				get_tests_dir('''fixtures/test_sentencepiece.model''')

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

__UpperCAmelCase       							=				250_004
__UpperCAmelCase       							=				250_020




@require_sentencepiece
@require_tokenizers
class 						a__							(				a__							,							unittest.TestCase    ):





							'''simple docstring'''






							lowercase__     :  List[str]      		= MBartaaTokenizer
							lowercase__     :  Union[str, Any]      		= MBartaaTokenizerFast
							lowercase__     :  Tuple      		= True
							lowercase__     :  Optional[Any]      		= True







							def     __SCREAMING_SNAKE_CASE				(						self  )			->				Any:
														super().setUp()

														# We have a SentencePiece fixture for testing
														lowerCAmelCase__			  =      MBartaaTokenizer(lowerCamelCase_   ,       src_lang='''en_XX'''   ,       tgt_lang='''ro_RO'''   ,       keep_accents=lowerCamelCase_  )
														tokenizer.save_pretrained(self.tmpdirname  )







							def     __SCREAMING_SNAKE_CASE				(						self  )			->				Optional[Any]:
														lowerCAmelCase__			  =      '''<s>'''
														lowerCAmelCase__			  =      0

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







							def     __SCREAMING_SNAKE_CASE				(						self  )			->				Union[str, Any]:
														lowerCAmelCase__			  =      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(lowerCamelCase_  )   ,       10_54  )







							def     __SCREAMING_SNAKE_CASE				(						self  )			->				Any:
														self.assertEqual(self.get_tokenizer().vocab_size   ,       10_54  )







							def     __SCREAMING_SNAKE_CASE				(						self  )			->				Optional[int]:
														lowerCAmelCase__			  =      MBartaaTokenizer(lowerCamelCase_   ,       src_lang='''en_XX'''   ,       tgt_lang='''ro_RO'''   ,       keep_accents=lowerCamelCase_  )

														lowerCAmelCase__			  =      tokenizer.tokenize('''This is a test'''  )
														self.assertListEqual(lowerCamelCase_   ,       ['''▁This''', '''▁is''', '''▁a''', '''▁t''', '''est''']  )

														self.assertListEqual(
														    tokenizer.convert_tokens_to_ids(lowerCamelCase_  )   ,       [value + tokenizer.fairseq_offset for value in [2_85, 46, 10, 1_70, 3_82]]   ,       )

														lowerCAmelCase__			  =      tokenizer.tokenize('''I was born in 92000, and this is falsé.'''  )
														self.assertListEqual(
														    lowerCamelCase_   ,       [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''', '''é''', '''.''']   ,       )
														lowerCAmelCase__			  =      tokenizer.convert_tokens_to_ids(lowerCamelCase_  )
														self.assertListEqual(
														    lowerCamelCase_   ,       [
														        value + tokenizer.fairseq_offset
														        for value in [8, 21, 84, 55, 24, 19, 7, 2, 6_02, 3_47, 3_47, 3_47, 3, 12, 66, 46, 72, 80, 6, 2, 4]
														    ]   ,       )

														lowerCAmelCase__			  =      tokenizer.convert_ids_to_tokens(lowerCamelCase_  )
														self.assertListEqual(
														    lowerCamelCase_   ,       [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     __SCREAMING_SNAKE_CASE				(						self  )			->				int:
														# fmt: off
														lowerCAmelCase__			  =      {'''input_ids''': [[25_00_04, 1_10_62, 8_27_72, 7, 15, 8_27_72, 5_38, 5_15_29, 2_37, 1_71_98, 12_90, 2_06, 9, 21_51_75, 13_14, 1_36, 1_71_98, 12_90, 2_06, 9, 5_63_59, 42, 12_20_09, 9, 1_64_66, 16, 8_73_44, 45_37, 9, 47_17, 7_83_81, 6, 15_99_58, 7, 15, 2_44_80, 6_18, 4, 5_27, 2_26_93, 54_28, 4, 27_77, 2_44_80, 98_74, 4, 4_35_23, 5_94, 4, 8_03, 1_83_92, 3_31_89, 18, 4, 4_35_23, 2_44_47, 1_23_99, 1_00, 2_49_55, 8_36_58, 96_26, 14_40_57, 15, 8_39, 2_23_35, 16, 1_36, 2_49_55, 8_36_58, 8_34_79, 15, 3_91_02, 7_24, 16, 6_78, 6_45, 27_89, 13_28, 45_89, 42, 12_20_09, 11_57_74, 23, 8_05, 13_28, 4_68_76, 7, 1_36, 5_38_94, 19_40, 4_22_27, 4_11_59, 1_77_21, 8_23, 4_25, 4, 2_75_12, 9_87_22, 2_06, 1_36, 55_31, 49_70, 9_19, 1_73_36, 5, 2], [25_00_04, 2_00_80, 6_18, 83, 8_27_75, 47, 4_79, 9, 15_17, 73, 5_38_94, 3_33, 8_05_81, 11_01_17, 1_88_11, 52_56, 12_95, 51, 15_25_26, 2_97, 79_86, 3_90, 12_44_16, 5_38, 3_54_31, 2_14, 98, 1_50_44, 2_57_37, 1_36, 71_08, 4_37_01, 23, 7_56, 13_53_55, 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], [25_00_04, 5_81, 6_37_73, 11_94_55, 6, 14_77_97, 8_82_03, 7, 6_45, 70, 21, 32_85, 1_02_69, 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=lowerCamelCase_   ,       model_name='''facebook/mbart-large-50'''   ,       revision='''d3913889c59cd5c9e456b269c376325eabad57e2'''   ,       )







							def     __SCREAMING_SNAKE_CASE				(						self  )			->				str:
														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

														lowerCAmelCase__			  =      (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})"""  ):
																												lowerCAmelCase__			  =      self.rust_tokenizer_class.from_pretrained(lowerCamelCase_   ,       **lowerCamelCase_  )
																												lowerCAmelCase__			  =      self.tokenizer_class.from_pretrained(lowerCamelCase_   ,       **lowerCamelCase_  )

																												lowerCAmelCase__			  =      tempfile.mkdtemp()

																												lowerCAmelCase__			  =      tokenizer_r.save_pretrained(lowerCamelCase_  )
																												lowerCAmelCase__			  =      tokenizer_p.save_pretrained(lowerCamelCase_  )

																												# 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  )  )
																												lowerCAmelCase__			  =      tuple(f for f in tokenizer_r_files if '''tokenizer.json''' not in f  )
																												self.assertSequenceEqual(lowerCamelCase_   ,       lowerCamelCase_  )

																												# Checks everything loads correctly in the same way
																												lowerCAmelCase__			  =      tokenizer_r.from_pretrained(lowerCamelCase_  )
																												lowerCAmelCase__			  =      tokenizer_p.from_pretrained(lowerCamelCase_  )

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

																												shutil.rmtree(lowerCamelCase_  )

																												# Save tokenizer rust, legacy_format=True
																												lowerCAmelCase__			  =      tempfile.mkdtemp()

																												lowerCAmelCase__			  =      tokenizer_r.save_pretrained(lowerCamelCase_   ,       legacy_format=lowerCamelCase_  )
																												lowerCAmelCase__			  =      tokenizer_p.save_pretrained(lowerCamelCase_  )

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

																												# Checks everything loads correctly in the same way
																												lowerCAmelCase__			  =      tokenizer_r.from_pretrained(lowerCamelCase_  )
																												lowerCAmelCase__			  =      tokenizer_p.from_pretrained(lowerCamelCase_  )

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

																												shutil.rmtree(lowerCamelCase_  )

																												# Save tokenizer rust, legacy_format=False
																												lowerCAmelCase__			  =      tempfile.mkdtemp()

																												lowerCAmelCase__			  =      tokenizer_r.save_pretrained(lowerCamelCase_   ,       legacy_format=lowerCamelCase_  )
																												lowerCAmelCase__			  =      tokenizer_p.save_pretrained(lowerCamelCase_  )

																												# 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
																												lowerCAmelCase__			  =      tokenizer_r.from_pretrained(lowerCamelCase_  )
																												lowerCAmelCase__			  =      tokenizer_p.from_pretrained(lowerCamelCase_  )

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

																												shutil.rmtree(lowerCamelCase_  )




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





							'''simple docstring'''






							lowercase__     :  Union[str, Any]      		= "facebook/mbart-large-50-one-to-many-mmt"
							lowercase__     :  List[Any]      		= [
							    " 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.",
							]
							lowercase__     :  int      		= [
							    "Ş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.",
							]
							lowercase__     :  Tuple      		= [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     __SCREAMING_SNAKE_CASE				(						cls  )			->				int:
														lowerCAmelCase__			  =      MBartaaTokenizer.from_pretrained(
														    cls.checkpoint_name   ,       src_lang='''en_XX'''   ,       tgt_lang='''ro_RO'''  )
														lowerCAmelCase__			  =      1
														return cls







							def     __SCREAMING_SNAKE_CASE				(						self  )			->				Optional[Any]:
														self.assertEqual(self.tokenizer.fairseq_tokens_to_ids['''ar_AR''']   ,       25_00_01  )
														self.assertEqual(self.tokenizer.fairseq_tokens_to_ids['''en_EN''']   ,       25_00_04  )
														self.assertEqual(self.tokenizer.fairseq_tokens_to_ids['''ro_RO''']   ,       25_00_20  )
														self.assertEqual(self.tokenizer.fairseq_tokens_to_ids['''mr_IN''']   ,       25_00_38  )







							def     __SCREAMING_SNAKE_CASE				(						self  )			->				int:
														lowerCAmelCase__			  =      self.tokenizer.batch_encode_plus(self.src_text  ).input_ids[0]
														self.assertListEqual(self.expected_src_tokens   ,       lowerCamelCase_  )







							def     __SCREAMING_SNAKE_CASE				(						self  )			->				List[str]:
														self.assertIn(lowerCamelCase_   ,       self.tokenizer.all_special_ids  )
														lowerCAmelCase__			  =      [RO_CODE, 8_84, 90_19, 96, 9, 9_16, 8_67_92, 36, 1_87_43, 1_55_96, 5, 2]
														lowerCAmelCase__			  =      self.tokenizer.decode(lowerCamelCase_   ,       skip_special_tokens=lowerCamelCase_  )
														lowerCAmelCase__			  =      self.tokenizer.decode(generated_ids[1:]   ,       skip_special_tokens=lowerCamelCase_  )
														self.assertEqual(lowerCamelCase_   ,       lowerCamelCase_  )
														self.assertNotIn(self.tokenizer.eos_token   ,       lowerCamelCase_  )







							def     __SCREAMING_SNAKE_CASE				(						self  )			->				Optional[int]:
														lowerCAmelCase__			  =      ['''this is gunna be a long sentence ''' * 20]
														assert isinstance(src_text[0]   ,       lowerCamelCase_  )
														lowerCAmelCase__			  =      10
														lowerCAmelCase__			  =      self.tokenizer(lowerCamelCase_   ,       max_length=lowerCamelCase_   ,       truncation=lowerCamelCase_  ).input_ids[0]
														self.assertEqual(ids[0]   ,       lowerCamelCase_  )
														self.assertEqual(ids[-1]   ,       2  )
														self.assertEqual(len(lowerCamelCase_  )   ,       lowerCamelCase_  )







							def     __SCREAMING_SNAKE_CASE				(						self  )			->				Any:
														self.assertListEqual(self.tokenizer.convert_tokens_to_ids(['''<mask>''', '''ar_AR''']  )   ,       [25_00_53, 25_00_01]  )







							def     __SCREAMING_SNAKE_CASE				(						self  )			->				Optional[Any]:
														lowerCAmelCase__			  =      tempfile.mkdtemp()
														lowerCAmelCase__			  =      self.tokenizer.fairseq_tokens_to_ids
														self.tokenizer.save_pretrained(lowerCamelCase_  )
														lowerCAmelCase__			  =      MBartaaTokenizer.from_pretrained(lowerCamelCase_  )
														self.assertDictEqual(new_tok.fairseq_tokens_to_ids   ,       lowerCamelCase_  )







							@require_torch
							def     __SCREAMING_SNAKE_CASE				(						self  )			->				Union[str, Any]:
														lowerCAmelCase__			  =      self.tokenizer(self.src_text   ,       text_target=self.tgt_text   ,       padding=lowerCamelCase_   ,       return_tensors='''pt'''  )
														lowerCAmelCase__			  =      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     __SCREAMING_SNAKE_CASE				(						self  )			->				List[str]:
														lowerCAmelCase__			  =      self.tokenizer(
														    self.src_text   ,       text_target=self.tgt_text   ,       padding=lowerCamelCase_   ,       truncation=lowerCamelCase_   ,       max_length=len(self.expected_src_tokens  )   ,       return_tensors='''pt'''   ,       )
														lowerCAmelCase__			  =      shift_tokens_right(batch['''labels''']   ,       self.tokenizer.pad_token_id  )

														self.assertIsInstance(lowerCamelCase_   ,       lowerCamelCase_  )

														self.assertEqual((2, 14)   ,       batch.input_ids.shape  )
														self.assertEqual((2, 14)   ,       batch.attention_mask.shape  )
														lowerCAmelCase__			  =      batch.input_ids.tolist()[0]
														self.assertListEqual(self.expected_src_tokens   ,       lowerCamelCase_  )
														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     __SCREAMING_SNAKE_CASE				(						self  )			->				List[str]:
														lowerCAmelCase__			  =      self.tokenizer(self.src_text   ,       padding=lowerCamelCase_   ,       truncation=lowerCamelCase_   ,       max_length=3   ,       return_tensors='''pt'''  )
														lowerCAmelCase__			  =      self.tokenizer(
														    text_target=self.tgt_text   ,       padding=lowerCamelCase_   ,       truncation=lowerCamelCase_   ,       max_length=10   ,       return_tensors='''pt'''  )
														lowerCAmelCase__			  =      targets['''input_ids''']
														lowerCAmelCase__			  =      shift_tokens_right(lowerCamelCase_   ,       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     __SCREAMING_SNAKE_CASE				(						self  )			->				Union[str, Any]:
														lowerCAmelCase__			  =      self.tokenizer._build_translation_inputs(
														    '''A test'''   ,       return_tensors='''pt'''   ,       src_lang='''en_XX'''   ,       tgt_lang='''ar_AR'''  )

														self.assertEqual(
														    nested_simplify(lowerCamelCase_  )   ,       {
														        # en_XX, A, test, EOS
														        '''input_ids''': [[25_00_04, 62, 30_34, 2]],
														        '''attention_mask''': [[1, 1, 1, 1]],
														        # ar_AR
														        '''forced_bos_token_id''': 25_00_01,
														    }   ,       )



'''simple docstring'''






import gc
import tempfile
import unittest

import numpy as np
import torch

from diffusers import VersatileDiffusionPipeline
from diffusers.utils.testing_utils import load_image, nightly, require_torch_gpu, torch_device


__UpperCAmelCase       							=				False




class 						a__							(				unittest.TestCase    ):





							'''simple docstring'''






							pass




@nightly
@require_torch_gpu
class 						a__							(				unittest.TestCase    ):





							'''simple docstring'''






							def     __SCREAMING_SNAKE_CASE				(						self  )			->				List[Any]:
														# clean up the VRAM after each test
														super().tearDown()
														gc.collect()
														torch.cuda.empty_cache()







							def     __SCREAMING_SNAKE_CASE				(						self  )			->				Optional[int]:
														lowerCAmelCase__			  =      VersatileDiffusionPipeline.from_pretrained('''shi-labs/versatile-diffusion'''   ,       torch_dtype=torch.floataa  )
														pipe.to(lowerCamelCase_  )
														pipe.set_progress_bar_config(disable=lowerCamelCase_  )

														lowerCAmelCase__			  =      load_image(
														    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/versatile_diffusion/benz.jpg'''  )

														lowerCAmelCase__			  =      torch.manual_seed(0  )
														lowerCAmelCase__			  =      pipe.dual_guided(
														    prompt='''first prompt'''   ,       image=lowerCamelCase_   ,       text_to_image_strength=0.75   ,       generator=lowerCamelCase_   ,       guidance_scale=7.5   ,       num_inference_steps=2   ,       output_type='''numpy'''   ,       ).images

														with tempfile.TemporaryDirectory() as tmpdirname:
																					pipe.save_pretrained(lowerCamelCase_  )
																					lowerCAmelCase__			  =      VersatileDiffusionPipeline.from_pretrained(lowerCamelCase_   ,       torch_dtype=torch.floataa  )
														pipe.to(lowerCamelCase_  )
														pipe.set_progress_bar_config(disable=lowerCamelCase_  )

														lowerCAmelCase__			  =      generator.manual_seed(0  )
														lowerCAmelCase__			  =      pipe.dual_guided(
														    prompt='''first prompt'''   ,       image=lowerCamelCase_   ,       text_to_image_strength=0.75   ,       generator=lowerCamelCase_   ,       guidance_scale=7.5   ,       num_inference_steps=2   ,       output_type='''numpy'''   ,       ).images

														assert np.abs(image - new_image  ).sum() < 1e-5, "Models don't have the same forward pass"







							def     __SCREAMING_SNAKE_CASE				(						self  )			->				Optional[Any]:
														lowerCAmelCase__			  =      VersatileDiffusionPipeline.from_pretrained('''shi-labs/versatile-diffusion'''   ,       torch_dtype=torch.floataa  )
														pipe.to(lowerCamelCase_  )
														pipe.set_progress_bar_config(disable=lowerCamelCase_  )

														lowerCAmelCase__			  =      '''cyberpunk 2077'''
														lowerCAmelCase__			  =      load_image(
														    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/versatile_diffusion/benz.jpg'''  )
														lowerCAmelCase__			  =      torch.manual_seed(0  )
														lowerCAmelCase__			  =      pipe.dual_guided(
														    prompt=lowerCamelCase_   ,       image=lowerCamelCase_   ,       text_to_image_strength=0.75   ,       generator=lowerCamelCase_   ,       guidance_scale=7.5   ,       num_inference_steps=50   ,       output_type='''numpy'''   ,       ).images

														lowerCAmelCase__			  =      image[0, 2_53:2_56, 2_53:2_56, -1]

														assert image.shape == (1, 5_12, 5_12, 3)
														lowerCAmelCase__			  =      np.array([0.1_448, 0.1_619, 0.1_741, 0.1_086, 0.1_147, 0.1_128, 0.1_199, 0.1_165, 0.1_001]  )

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

														lowerCAmelCase__			  =      '''A painting of a squirrel eating a burger '''
														lowerCAmelCase__			  =      torch.manual_seed(0  )
														lowerCAmelCase__			  =      pipe.text_to_image(
														    prompt=lowerCamelCase_   ,       generator=lowerCamelCase_   ,       guidance_scale=7.5   ,       num_inference_steps=50   ,       output_type='''numpy'''  ).images

														lowerCAmelCase__			  =      image[0, 2_53:2_56, 2_53:2_56, -1]

														assert image.shape == (1, 5_12, 5_12, 3)
														lowerCAmelCase__			  =      np.array([0.3_367, 0.3_169, 0.2_656, 0.3_870, 0.4_790, 0.3_796, 0.4_009, 0.4_878, 0.4_778]  )

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

														lowerCAmelCase__			  =      pipe.image_variation(lowerCamelCase_   ,       generator=lowerCamelCase_   ,       output_type='''numpy'''  ).images

														lowerCAmelCase__			  =      image[0, 2_53:2_56, 2_53:2_56, -1]

														assert image.shape == (1, 5_12, 5_12, 3)
														lowerCAmelCase__			  =      np.array([0.3_076, 0.3_123, 0.3_284, 0.3_782, 0.3_770, 0.3_894, 0.4_297, 0.4_331, 0.4_456]  )

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