





import unittest

from transformers import DebertaVaTokenizer, DebertaVaTokenizerFast
from transformers.testing_utils import get_tests_dir, require_sentencepiece, require_tokenizers, slow

from ...test_tokenization_common import TokenizerTesterMixin


lowercase_		:				Tuple				=						get_tests_dir('''fixtures/spiece.model''')


@require_sentencepiece
@require_tokenizers
class 			lowercase				(							a_		,			unittest.TestCase     ):



						"""simple docstring"""

						_UpperCamelCase  :	Optional[Any]								=	DebertaVaTokenizer
						_UpperCamelCase  :	List[str]								=	DebertaVaTokenizerFast
						_UpperCamelCase  :	Dict								=	True
						_UpperCamelCase  :	Tuple								=	True







						def 		__UpperCAmelCase       (    self			:		str					):





										'''simple docstring'''







										super().setUp()

										# We have a SentencePiece fixture for testing
										_snake_case :			str  						=   DebertaVaTokenizer(lowerCamelCase_ ,				unk_token='<unk>'					)
										tokenizer.save_pretrained(self.tmpdirname					)







						def 		__UpperCAmelCase       (    self			:		Union[str, Any] ,				lowerCamelCase_			:		str					):





										'''simple docstring'''







										_snake_case :			Optional[Any]  						=   'this is a test'
										_snake_case :			str  						=   'this is a test'
										return input_text, output_text







						def 		__UpperCAmelCase       (    self			:		Tuple					):





										'''simple docstring'''







										_snake_case :			int  						=   '<pad>'
										_snake_case :			Optional[Any]  						=   0

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







						def 		__UpperCAmelCase       (    self			:		List[str]					):





										'''simple docstring'''







										_snake_case :			Any  						=   list(self.get_tokenizer().get_vocab().keys()					)
										self.assertEqual(vocab_keys[0] ,				'<pad>'					)
										self.assertEqual(vocab_keys[1] ,				'<unk>'					)
										self.assertEqual(vocab_keys[-1] ,				'[PAD]'					)
										self.assertEqual(len(lowerCamelCase_					) ,				3_00_01					)







						def 		__UpperCAmelCase       (    self			:		str					):





										'''simple docstring'''







										self.assertEqual(self.get_tokenizer().vocab_size ,				3_00_00					)







						def 		__UpperCAmelCase       (    self			:		List[Any]					):





										'''simple docstring'''







										_snake_case :			List[str]  						=   ' \tHeLLo!how  \n Are yoU?  '
										_snake_case :			Dict  						=   ['▁hello', '!', 'how', '▁are', '▁you', '?']
										# fmt: on

										_snake_case :			Dict  						=   DebertaVaTokenizer(lowerCamelCase_ ,				do_lower_case=lowerCamelCase_					)
										_snake_case :			Tuple  						=   tokenizer.convert_ids_to_tokens(tokenizer.encode(lowerCamelCase_ ,				add_special_tokens=lowerCamelCase_					)					)

										self.assertListEqual(lowerCamelCase_ ,				lowerCamelCase_					)

										_snake_case :			List[Any]  						=   DebertaVaTokenizerFast(lowerCamelCase_ ,				do_lower_case=lowerCamelCase_					)
										_snake_case :			int  						=   rust_tokenizer.convert_ids_to_tokens(rust_tokenizer.encode(lowerCamelCase_ ,				add_special_tokens=lowerCamelCase_					)					)

										self.assertListEqual(lowerCamelCase_ ,				lowerCamelCase_					)







						@unittest.skip('There is an inconsistency between slow and fast tokenizer due to a bug in the fast one.'					)
						def 		__UpperCAmelCase       (    self			:		int					):





										'''simple docstring'''







										pass







						@unittest.skip('There is an inconsistency between slow and fast tokenizer due to a bug in the fast one.'					)
						def 		__UpperCAmelCase       (    self			:		Any					):





										'''simple docstring'''







										pass







						def 		__UpperCAmelCase       (    self			:		Union[str, Any]					):





										'''simple docstring'''







										_snake_case :			Dict  						=   'I was born in 92000, and this is falsé.'
										_snake_case :			Dict  						=   ['▁', '<unk>', '▁was', '▁born', '▁in', '▁9', '2000', '▁', ',', '▁and', '▁this', '▁is', '▁fal', 's', '<unk>', '▁', '.', ]
										# fmt: on

										_snake_case :			Dict  						=   DebertaVaTokenizer(lowerCamelCase_ ,				split_by_punct=lowerCamelCase_					)
										_snake_case :			Union[str, Any]  						=   tokenizer.convert_ids_to_tokens(tokenizer.encode(lowerCamelCase_ ,				add_special_tokens=lowerCamelCase_					)					)

										self.assertListEqual(lowerCamelCase_ ,				lowerCamelCase_					)

										_snake_case :			List[str]  						=   DebertaVaTokenizerFast(lowerCamelCase_ ,				split_by_punct=lowerCamelCase_					)
										_snake_case :			Union[str, Any]  						=   rust_tokenizer.convert_ids_to_tokens(rust_tokenizer.encode(lowerCamelCase_ ,				add_special_tokens=lowerCamelCase_					)					)

										self.assertListEqual(lowerCamelCase_ ,				lowerCamelCase_					)







						def 		__UpperCAmelCase       (    self			:		Optional[int]					):





										'''simple docstring'''







										_snake_case :			int  						=   'I was born in 92000, and this is falsé.'
										_snake_case :			Dict  						=   ['▁i', '▁was', '▁born', '▁in', '▁9', '2000', '▁', ',', '▁and', '▁this', '▁is', '▁fal', 's', '<unk>', '▁', '.', ]
										# fmt: on

										_snake_case :			Any  						=   DebertaVaTokenizer(lowerCamelCase_ ,				do_lower_case=lowerCamelCase_ ,				split_by_punct=lowerCamelCase_					)
										_snake_case :			Any  						=   tokenizer.convert_ids_to_tokens(tokenizer.encode(lowerCamelCase_ ,				add_special_tokens=lowerCamelCase_					)					)
										self.assertListEqual(lowerCamelCase_ ,				lowerCamelCase_					)

										_snake_case :			Any  						=   DebertaVaTokenizerFast(lowerCamelCase_ ,				do_lower_case=lowerCamelCase_ ,				split_by_punct=lowerCamelCase_					)
										_snake_case :			str  						=   rust_tokenizer.convert_ids_to_tokens(rust_tokenizer.encode(lowerCamelCase_ ,				add_special_tokens=lowerCamelCase_					)					)
										self.assertListEqual(lowerCamelCase_ ,				lowerCamelCase_					)







						def 		__UpperCAmelCase       (    self			:		Optional[int]					):





										'''simple docstring'''







										_snake_case :			Dict  						=   'I was born in 92000, and this is falsé.'
										_snake_case :			str  						=   ['▁i', '▁was', '▁born', '▁in', '▁9', '2000', ',', '▁and', '▁this', '▁is', '▁fal', 's', '<unk>', '.', ]
										# fmt: on

										_snake_case :			Union[str, Any]  						=   DebertaVaTokenizer(lowerCamelCase_ ,				do_lower_case=lowerCamelCase_ ,				split_by_punct=lowerCamelCase_					)
										_snake_case :			List[str]  						=   tokenizer.convert_ids_to_tokens(tokenizer.encode(lowerCamelCase_ ,				add_special_tokens=lowerCamelCase_					)					)

										self.assertListEqual(lowerCamelCase_ ,				lowerCamelCase_					)

										_snake_case :			List[Any]  						=   DebertaVaTokenizerFast(lowerCamelCase_ ,				do_lower_case=lowerCamelCase_ ,				split_by_punct=lowerCamelCase_					)
										_snake_case :			Union[str, Any]  						=   rust_tokenizer.convert_ids_to_tokens(rust_tokenizer.encode(lowerCamelCase_ ,				add_special_tokens=lowerCamelCase_					)					)

										self.assertListEqual(lowerCamelCase_ ,				lowerCamelCase_					)







						def 		__UpperCAmelCase       (    self			:		List[str]					):





										'''simple docstring'''







										_snake_case :			str  						=   'I was born in 92000, and this is falsé.'
										_snake_case :			Optional[int]  						=   ['▁', '<unk>', '▁was', '▁born', '▁in', '▁9', '2000', '▁', ',', '▁and', '▁this', '▁is', '▁fal', 's', '<unk>', '▁', '.', ]
										# fmt: on

										_snake_case :			int  						=   DebertaVaTokenizer(lowerCamelCase_ ,				do_lower_case=lowerCamelCase_ ,				split_by_punct=lowerCamelCase_					)
										_snake_case :			Dict  						=   tokenizer.convert_ids_to_tokens(tokenizer.encode(lowerCamelCase_ ,				add_special_tokens=lowerCamelCase_					)					)

										self.assertListEqual(lowerCamelCase_ ,				lowerCamelCase_					)

										_snake_case :			Optional[int]  						=   DebertaVaTokenizerFast(lowerCamelCase_ ,				do_lower_case=lowerCamelCase_ ,				split_by_punct=lowerCamelCase_					)
										_snake_case :			List[str]  						=   rust_tokenizer.convert_ids_to_tokens(rust_tokenizer.encode(lowerCamelCase_ ,				add_special_tokens=lowerCamelCase_					)					)

										self.assertListEqual(lowerCamelCase_ ,				lowerCamelCase_					)







						def 		__UpperCAmelCase       (    self			:		List[Any]					):





										'''simple docstring'''







										_snake_case :			str  						=   ' \tHeLLo!how  \n Are yoU?  '
										_snake_case :			Any  						=   ['▁', '<unk>', 'e', '<unk>', 'o', '!', 'how', '▁', '<unk>', 're', '▁yo', '<unk>', '?']
										# fmt: on

										_snake_case :			Any  						=   DebertaVaTokenizer(lowerCamelCase_ ,				do_lower_case=lowerCamelCase_ ,				split_by_punct=lowerCamelCase_					)
										_snake_case :			Any  						=   tokenizer.convert_ids_to_tokens(tokenizer.encode(lowerCamelCase_ ,				add_special_tokens=lowerCamelCase_					)					)

										self.assertListEqual(lowerCamelCase_ ,				lowerCamelCase_					)

										_snake_case :			Dict  						=   DebertaVaTokenizerFast(lowerCamelCase_ ,				do_lower_case=lowerCamelCase_ ,				split_by_punct=lowerCamelCase_					)
										_snake_case :			List[str]  						=   rust_tokenizer.convert_ids_to_tokens(rust_tokenizer.encode(lowerCamelCase_ ,				add_special_tokens=lowerCamelCase_					)					)

										self.assertListEqual(lowerCamelCase_ ,				lowerCamelCase_					)







						def 		__UpperCAmelCase       (    self			:		int					):





										'''simple docstring'''







										_snake_case :			List[str]  						=   self.get_tokenizer()
										_snake_case :			int  						=   self.get_rust_tokenizer()

										_snake_case :			int  						=   'I was born in 92000, and this is falsé.'

										_snake_case :			str  						=   tokenizer.convert_ids_to_tokens(tokenizer.encode(lowerCamelCase_ ,				add_special_tokens=lowerCamelCase_					)					)
										_snake_case :			Optional[Any]  						=   rust_tokenizer.convert_ids_to_tokens(rust_tokenizer.encode(lowerCamelCase_ ,				add_special_tokens=lowerCamelCase_					)					)
										self.assertListEqual(lowerCamelCase_ ,				lowerCamelCase_					)

										_snake_case :			Optional[int]  						=   tokenizer.encode(lowerCamelCase_ ,				add_special_tokens=lowerCamelCase_					)
										_snake_case :			Optional[Any]  						=   rust_tokenizer.encode(lowerCamelCase_ ,				add_special_tokens=lowerCamelCase_					)
										self.assertListEqual(lowerCamelCase_ ,				lowerCamelCase_					)

										_snake_case :			Tuple  						=   self.get_rust_tokenizer()
										_snake_case :			Optional[Any]  						=   tokenizer.encode(lowerCamelCase_					)
										_snake_case :			List[Any]  						=   rust_tokenizer.encode(lowerCamelCase_					)
										self.assertListEqual(lowerCamelCase_ ,				lowerCamelCase_					)







						def 		__UpperCAmelCase       (    self			:		Tuple					):





										'''simple docstring'''







										_snake_case :			Optional[int]  						=   'This is a test'
										_snake_case :			Optional[Any]  						=   [13, 1, 43_98, 25, 21, 12_89]
										_snake_case :			Union[str, Any]  						=   ['▁', 'T', 'his', '▁is', '▁a', '▁test']
										_snake_case :			str  						=   ['▁', '<unk>', 'his', '▁is', '▁a', '▁test']

										_snake_case :			List[Any]  						=   DebertaVaTokenizer(lowerCamelCase_ ,				keep_accents=lowerCamelCase_					)
										_snake_case :			List[Any]  						=   DebertaVaTokenizerFast(lowerCamelCase_ ,				keep_accents=lowerCamelCase_					)

										_snake_case :			str  						=   tokenizer.encode(lowerCamelCase_ ,				add_special_tokens=lowerCamelCase_					)
										self.assertListEqual(lowerCamelCase_ ,				lowerCamelCase_					)
										_snake_case :			Tuple  						=   tokenizer.tokenize(lowerCamelCase_					)
										self.assertListEqual(lowerCamelCase_ ,				lowerCamelCase_					)
										_snake_case :			List[Any]  						=   tokenizer.convert_ids_to_tokens(lowerCamelCase_					)
										self.assertListEqual(lowerCamelCase_ ,				lowerCamelCase_					)

										_snake_case :			List[Any]  						=   rust_tokenizer.encode(lowerCamelCase_ ,				add_special_tokens=lowerCamelCase_					)
										self.assertListEqual(lowerCamelCase_ ,				lowerCamelCase_					)
										_snake_case :			Any  						=   rust_tokenizer.tokenize(lowerCamelCase_					)
										self.assertListEqual(lowerCamelCase_ ,				lowerCamelCase_					)
										_snake_case :			Any  						=   rust_tokenizer.convert_ids_to_tokens(lowerCamelCase_					)
										self.assertListEqual(lowerCamelCase_ ,				lowerCamelCase_					)

										# fmt: off
										_snake_case :			Optional[Any]  						=   'I was born in 92000, and this is falsé.'
										_snake_case :			Tuple  						=   [13, 1, 23, 3_86, 19, 5_61, 30_50, 15, 17, 48, 25, 82_56, 18, 1, 9]
										_snake_case :			List[str]  						=   ['▁', 'I', '▁was', '▁born', '▁in', '▁9', '2000', ',', '▁and', '▁this', '▁is', '▁fal', 's', 'é', '.', ]
										_snake_case :			Dict  						=   ['▁', '<unk>', '▁was', '▁born', '▁in', '▁9', '2000', ',', '▁and', '▁this', '▁is', '▁fal', 's', '<unk>', '.', ]
										# fmt: on

										_snake_case :			Any  						=   tokenizer.encode(lowerCamelCase_ ,				add_special_tokens=lowerCamelCase_					)
										self.assertListEqual(lowerCamelCase_ ,				lowerCamelCase_					)
										_snake_case :			List[str]  						=   tokenizer.tokenize(lowerCamelCase_					)
										self.assertListEqual(lowerCamelCase_ ,				lowerCamelCase_					)
										_snake_case :			List[str]  						=   tokenizer.convert_ids_to_tokens(lowerCamelCase_					)
										self.assertListEqual(lowerCamelCase_ ,				lowerCamelCase_					)

										_snake_case :			Optional[Any]  						=   rust_tokenizer.encode(lowerCamelCase_ ,				add_special_tokens=lowerCamelCase_					)
										self.assertListEqual(lowerCamelCase_ ,				lowerCamelCase_					)
										_snake_case :			Optional[Any]  						=   rust_tokenizer.tokenize(lowerCamelCase_					)
										self.assertListEqual(lowerCamelCase_ ,				lowerCamelCase_					)
										_snake_case :			List[str]  						=   rust_tokenizer.convert_ids_to_tokens(lowerCamelCase_					)
										self.assertListEqual(lowerCamelCase_ ,				lowerCamelCase_					)







						def 		__UpperCAmelCase       (    self			:		List[Any]					):





										'''simple docstring'''







										_snake_case :			Tuple  						=   DebertaVaTokenizer(lowerCamelCase_					)

										_snake_case :			Dict  						=   tokenizer.encode('sequence builders'					)
										_snake_case :			Union[str, Any]  						=   tokenizer.encode('multi-sequence build'					)

										_snake_case :			int  						=   tokenizer.build_inputs_with_special_tokens(lowerCamelCase_					)
										_snake_case :			int  						=   tokenizer.build_inputs_with_special_tokens(lowerCamelCase_ ,				lowerCamelCase_					)

										self.assertEqual([tokenizer.cls_token_id] + text + [tokenizer.sep_token_id] ,				lowerCamelCase_					)
										self.assertEqual(
										    [tokenizer.cls_token_id] + text + [tokenizer.sep_token_id] + text_a + [tokenizer.sep_token_id] ,				lowerCamelCase_ ,				)







						@slow
						def 		__UpperCAmelCase       (    self			:		Tuple					):





										'''simple docstring'''







										_snake_case :			List[Any]  						=   {'input_ids': [[1, 3_98_67, 36, 1_93_90, 4_86, 27, 3_50_52, 8_14_36, 18, 6_06_85, 12_25, 7, 3_50_52, 8_14_36, 18, 93_67, 1_68_99, 18, 1_59_37, 53, 5_94, 7_73, 18, 1_62_87, 3_04_65, 36, 1_59_37, 6, 4_11_39, 38, 3_69_79, 6_07_63, 1_91, 6, 3_41_32, 99, 6, 5_05_38, 3_90, 4_32_30, 6, 3_41_32, 27_79, 2_08_50, 14, 6_99, 10_72, 11_94, 36, 3_82, 1_09_01, 53, 7, 6_99, 10_72, 20_84, 36, 2_04_22, 6_30, 53, 19, 1_05, 30_49, 18_96, 10_53, 1_68_99, 15_06, 11, 3_79_78, 42_43, 7, 12_37, 3_18_69, 2_00, 1_65_66, 6_54, 6, 3_50_52, 8_14_36, 7, 5_56_30, 1_35_93, 4, 2], [1, 26, 1_50_11, 13, 6_67, 8, 10_53, 18, 2_36_11, 12_37, 7_23_56, 1_28_20, 34, 10_41_34, 12_09, 35, 1_33_13, 66_27, 21, 2_02, 3_47, 7, 1_64, 23_99, 11, 46, 44_85, 4, 2, 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, 5, 12_32, 28_64, 1_57_85, 1_49_51, 1_05, 5, 85_81, 12_50, 4, 2, 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]], 'token_type_ids': [[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, 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, 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]], '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, 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, 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='microsoft/deberta-v2-xlarge' ,				revision='ad6e42c1532ddf3a15c39246b63f5559d558b670' ,				)













import gc
import random
import tempfile
import unittest

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

from diffusers import AutoencoderKL, DDIMScheduler, LMSDiscreteScheduler, PNDMScheduler, UNetaDConditionModel
from diffusers.pipelines.stable_diffusion_safe import StableDiffusionPipelineSafe as StableDiffusionPipeline
from diffusers.utils import floats_tensor, nightly, torch_device
from diffusers.utils.testing_utils import require_torch_gpu


class 			lowercase				(							unittest.TestCase     ):



						"""simple docstring"""

						def 		__UpperCAmelCase       (    self			:		Optional[Any]					):





										'''simple docstring'''







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







						@property
						def 		__UpperCAmelCase       (    self			:		Optional[int]					):





										'''simple docstring'''







										_snake_case :			Tuple  						=   1
										_snake_case :			str  						=   3
										_snake_case :			List[str]  						=   (32, 32)

										_snake_case :			int  						=   floats_tensor((batch_size, num_channels) + sizes ,				rng=random.Random(0					)					).to(lowerCamelCase_					)
										return image







						@property
						def 		__UpperCAmelCase       (    self			:		str					):





										'''simple docstring'''







										torch.manual_seed(0					)
										_snake_case :			Union[str, Any]  						=   UNetaDConditionModel(
										    block_out_channels=(32, 64) ,				layers_per_block=2 ,				sample_size=32 ,				in_channels=4 ,				out_channels=4 ,				down_block_types=('DownBlock2D', 'CrossAttnDownBlock2D') ,				up_block_types=('CrossAttnUpBlock2D', 'UpBlock2D') ,				cross_attention_dim=32 ,				)
										return model







						@property
						def 		__UpperCAmelCase       (    self			:		Dict					):





										'''simple docstring'''







										torch.manual_seed(0					)
										_snake_case :			Optional[Any]  						=   AutoencoderKL(
										    block_out_channels=[32, 64] ,				in_channels=3 ,				out_channels=3 ,				down_block_types=['DownEncoderBlock2D', 'DownEncoderBlock2D'] ,				up_block_types=['UpDecoderBlock2D', 'UpDecoderBlock2D'] ,				latent_channels=4 ,				)
										return model







						@property
						def 		__UpperCAmelCase       (    self			:		Tuple					):





										'''simple docstring'''







										torch.manual_seed(0					)
										_snake_case :			List[str]  						=   CLIPTextConfig(
										    bos_token_id=0 ,				eos_token_id=2 ,				hidden_size=32 ,				intermediate_size=37 ,				layer_norm_eps=1e-05 ,				num_attention_heads=4 ,				num_hidden_layers=5 ,				pad_token_id=1 ,				vocab_size=10_00 ,				)
										return CLIPTextModel(lowerCamelCase_					)







						@property
						def 		__UpperCAmelCase       (    self			:		Optional[Any]					):





										'''simple docstring'''







										def extract(*lowerCamelCase_			:		Optional[int] ,				**lowerCamelCase_			:		str					):


														class 			lowercase				:



																				"""simple docstring"""

																				def __init__(    self			:		Tuple					):





																								'''simple docstring'''







																								_snake_case :			List[str]  						=   torch.ones([0]					)







																				def 		__UpperCAmelCase       (    self			:		int ,				lowerCamelCase_			:		Tuple					):





																								'''simple docstring'''







																								self.pixel_values.to(lowerCamelCase_					)
																								return self



														return Out()

										return extract







						def 		__UpperCAmelCase       (    self			:		int					):





										'''simple docstring'''







										_snake_case :			Optional[int]  						=   'cpu'  # ensure determinism for the device-dependent torch.Generator
										_snake_case :			int  						=   self.dummy_cond_unet
										_snake_case :			str  						=   DDIMScheduler(
										    beta_start=0.0_0085 ,				beta_end=0.012 ,				beta_schedule='scaled_linear' ,				clip_sample=lowerCamelCase_ ,				set_alpha_to_one=lowerCamelCase_ ,				)

										_snake_case :			Union[str, Any]  						=   self.dummy_vae
										_snake_case :			Optional[Any]  						=   self.dummy_text_encoder
										_snake_case :			Optional[Any]  						=   CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'					)

										# make sure here that pndm scheduler skips prk
										_snake_case :			Union[str, Any]  						=   StableDiffusionPipeline(
										    unet=lowerCamelCase_ ,				scheduler=lowerCamelCase_ ,				vae=lowerCamelCase_ ,				text_encoder=lowerCamelCase_ ,				tokenizer=lowerCamelCase_ ,				safety_checker=lowerCamelCase_ ,				feature_extractor=self.dummy_extractor ,				)
										_snake_case :			str  						=   sd_pipe.to(lowerCamelCase_					)
										sd_pipe.set_progress_bar_config(disable=lowerCamelCase_					)

										_snake_case :			List[str]  						=   'A painting of a squirrel eating a burger'

										_snake_case :			Optional[int]  						=   torch.Generator(device=lowerCamelCase_					).manual_seed(0					)
										_snake_case :			Optional[int]  						=   sd_pipe([prompt] ,				generator=lowerCamelCase_ ,				guidance_scale=6.0 ,				num_inference_steps=2 ,				output_type='np'					)
										_snake_case :			Union[str, Any]  						=   output.images

										_snake_case :			List[str]  						=   torch.Generator(device=lowerCamelCase_					).manual_seed(0					)
										_snake_case :			Any  						=   sd_pipe(
										    [prompt] ,				generator=lowerCamelCase_ ,				guidance_scale=6.0 ,				num_inference_steps=2 ,				output_type='np' ,				return_dict=lowerCamelCase_ ,				)[0]

										_snake_case :			Tuple  						=   image[0, -3:, -3:, -1]
										_snake_case :			List[Any]  						=   image_from_tuple[0, -3:, -3:, -1]

										assert image.shape == (1, 64, 64, 3)
										_snake_case :			Optional[int]  						=   np.array([0.5756, 0.6118, 0.5005, 0.5041, 0.5471, 0.4726, 0.4976, 0.4865, 0.4864]					)

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







						def 		__UpperCAmelCase       (    self			:		List[str]					):





										'''simple docstring'''







										_snake_case :			Tuple  						=   'cpu'  # ensure determinism for the device-dependent torch.Generator
										_snake_case :			List[str]  						=   self.dummy_cond_unet
										_snake_case :			List[str]  						=   PNDMScheduler(skip_prk_steps=lowerCamelCase_					)
										_snake_case :			int  						=   self.dummy_vae
										_snake_case :			List[Any]  						=   self.dummy_text_encoder
										_snake_case :			Optional[int]  						=   CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'					)

										# make sure here that pndm scheduler skips prk
										_snake_case :			Any  						=   StableDiffusionPipeline(
										    unet=lowerCamelCase_ ,				scheduler=lowerCamelCase_ ,				vae=lowerCamelCase_ ,				text_encoder=lowerCamelCase_ ,				tokenizer=lowerCamelCase_ ,				safety_checker=lowerCamelCase_ ,				feature_extractor=self.dummy_extractor ,				)
										_snake_case :			Union[str, Any]  						=   sd_pipe.to(lowerCamelCase_					)
										sd_pipe.set_progress_bar_config(disable=lowerCamelCase_					)

										_snake_case :			str  						=   'A painting of a squirrel eating a burger'
										_snake_case :			Optional[int]  						=   torch.Generator(device=lowerCamelCase_					).manual_seed(0					)
										_snake_case :			Tuple  						=   sd_pipe([prompt] ,				generator=lowerCamelCase_ ,				guidance_scale=6.0 ,				num_inference_steps=2 ,				output_type='np'					)

										_snake_case :			Optional[Any]  						=   output.images

										_snake_case :			Optional[Any]  						=   torch.Generator(device=lowerCamelCase_					).manual_seed(0					)
										_snake_case :			Tuple  						=   sd_pipe(
										    [prompt] ,				generator=lowerCamelCase_ ,				guidance_scale=6.0 ,				num_inference_steps=2 ,				output_type='np' ,				return_dict=lowerCamelCase_ ,				)[0]

										_snake_case :			Dict  						=   image[0, -3:, -3:, -1]
										_snake_case :			Any  						=   image_from_tuple[0, -3:, -3:, -1]

										assert image.shape == (1, 64, 64, 3)
										_snake_case :			str  						=   np.array([0.5125, 0.5716, 0.4828, 0.5060, 0.5650, 0.4768, 0.5185, 0.4895, 0.4993]					)

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







						def 		__UpperCAmelCase       (    self			:		int					):





										'''simple docstring'''







										_snake_case :			Union[str, Any]  						=   StableDiffusionPipeline.from_pretrained(
										    'hf-internal-testing/tiny-stable-diffusion-lms-pipe' ,				safety_checker=lowerCamelCase_					)
										assert isinstance(lowerCamelCase_ ,				lowerCamelCase_					)
										assert isinstance(pipe.scheduler ,				lowerCamelCase_					)
										assert pipe.safety_checker is None

										_snake_case :			Dict  						=   pipe('example prompt' ,				num_inference_steps=2					).images[0]
										assert image is not None

										# check that there's no error when saving a pipeline with one of the models being None
										with tempfile.TemporaryDirectory() as tmpdirname:
														pipe.save_pretrained(lowerCamelCase_					)
														_snake_case :			Any  						=   StableDiffusionPipeline.from_pretrained(lowerCamelCase_					)

										# sanity check that the pipeline still works
										assert pipe.safety_checker is None
										_snake_case :			Union[str, Any]  						=   pipe('example prompt' ,				num_inference_steps=2					).images[0]
										assert image is not None







						@unittest.skipIf(torch_device != 'cuda' ,				'This test requires a GPU'					)
						def 		__UpperCAmelCase       (    self			:		Optional[Any]					):





										'''simple docstring'''







										_snake_case :			Union[str, Any]  						=   self.dummy_cond_unet
										_snake_case :			Optional[Any]  						=   PNDMScheduler(skip_prk_steps=lowerCamelCase_					)
										_snake_case :			Any  						=   self.dummy_vae
										_snake_case :			Optional[Any]  						=   self.dummy_text_encoder
										_snake_case :			Optional[int]  						=   CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'					)

										# put models in fp16
										_snake_case :			str  						=   unet.half()
										_snake_case :			Union[str, Any]  						=   vae.half()
										_snake_case :			Dict  						=   bert.half()

										# make sure here that pndm scheduler skips prk
										_snake_case :			List[str]  						=   StableDiffusionPipeline(
										    unet=lowerCamelCase_ ,				scheduler=lowerCamelCase_ ,				vae=lowerCamelCase_ ,				text_encoder=lowerCamelCase_ ,				tokenizer=lowerCamelCase_ ,				safety_checker=lowerCamelCase_ ,				feature_extractor=self.dummy_extractor ,				)
										_snake_case :			List[str]  						=   sd_pipe.to(lowerCamelCase_					)
										sd_pipe.set_progress_bar_config(disable=lowerCamelCase_					)

										_snake_case :			Tuple  						=   'A painting of a squirrel eating a burger'
										_snake_case :			Optional[int]  						=   sd_pipe([prompt] ,				num_inference_steps=2 ,				output_type='np'					).images

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



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



						"""simple docstring"""

						def 		__UpperCAmelCase       (    self			:		Tuple					):





										'''simple docstring'''







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







						def 		__UpperCAmelCase       (    self			:		List[str]					):





										'''simple docstring'''







										_snake_case :			Optional[int]  						=   StableDiffusionPipeline.from_pretrained('runwayml/stable-diffusion-v1-5' ,				safety_checker=lowerCamelCase_					)
										_snake_case :			List[str]  						=   LMSDiscreteScheduler.from_config(sd_pipe.scheduler.config					)
										_snake_case :			Any  						=   sd_pipe.to(lowerCamelCase_					)
										sd_pipe.set_progress_bar_config(disable=lowerCamelCase_					)

										_snake_case :			Optional[int]  						=   (
										    'portrait of girl with smokey eyes makeup in abandoned hotel, grange clothes, redshift, wide high angle'
										    ' coloured polaroid photograph with flash, kodak film, hyper real, stunning moody cinematography, with'
										    ' anamorphic lenses, by maripol, fallen angels by wong kar - wai, style of suspiria and neon demon and'
										    ' children from bahnhof zoo, detailed '
										)
										_snake_case :			List[str]  						=   40_03_66_03_46
										_snake_case :			int  						=   7

										# without safety guidance (sld_guidance_scale = 0)
										_snake_case :			Union[str, Any]  						=   torch.manual_seed(lowerCamelCase_					)
										_snake_case :			Union[str, Any]  						=   sd_pipe(
										    [prompt] ,				generator=lowerCamelCase_ ,				guidance_scale=lowerCamelCase_ ,				num_inference_steps=50 ,				output_type='np' ,				width=5_12 ,				height=5_12 ,				sld_guidance_scale=0 ,				)

										_snake_case :			str  						=   output.images
										_snake_case :			Dict  						=   image[0, -3:, -3:, -1]
										_snake_case :			Optional[int]  						=   [0.2278, 0.2231, 0.2249, 0.2333, 0.2303, 0.1885, 0.2273, 0.2144, 0.2176]

										assert image.shape == (1, 5_12, 5_12, 3)

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

										# without safety guidance (strong configuration)
										_snake_case :			Tuple  						=   torch.manual_seed(lowerCamelCase_					)
										_snake_case :			int  						=   sd_pipe(
										    [prompt] ,				generator=lowerCamelCase_ ,				guidance_scale=lowerCamelCase_ ,				num_inference_steps=50 ,				output_type='np' ,				width=5_12 ,				height=5_12 ,				sld_guidance_scale=20_00 ,				sld_warmup_steps=7 ,				sld_threshold=0.025 ,				sld_momentum_scale=0.5 ,				sld_mom_beta=0.7 ,				)

										_snake_case :			Tuple  						=   output.images
										_snake_case :			int  						=   image[0, -3:, -3:, -1]
										_snake_case :			List[Any]  						=   [0.2383, 0.2276, 0.236, 0.2192, 0.2186, 0.2053, 0.1971, 0.1901, 0.1719]

										assert image.shape == (1, 5_12, 5_12, 3)

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







						def 		__UpperCAmelCase       (    self			:		int					):





										'''simple docstring'''







										_snake_case :			str  						=   StableDiffusionPipeline.from_pretrained('runwayml/stable-diffusion-v1-5' ,				safety_checker=lowerCamelCase_					)
										_snake_case :			Tuple  						=   LMSDiscreteScheduler.from_config(sd_pipe.scheduler.config					)
										_snake_case :			Any  						=   sd_pipe.to(lowerCamelCase_					)
										sd_pipe.set_progress_bar_config(disable=lowerCamelCase_					)

										_snake_case :			Union[str, Any]  						=   'padme amidala taking a bath artwork, safe for work, no nudity'
										_snake_case :			Optional[Any]  						=   27_34_97_17_55
										_snake_case :			Union[str, Any]  						=   7

										_snake_case :			Dict  						=   torch.manual_seed(lowerCamelCase_					)
										_snake_case :			Tuple  						=   sd_pipe(
										    [prompt] ,				generator=lowerCamelCase_ ,				guidance_scale=lowerCamelCase_ ,				num_inference_steps=50 ,				output_type='np' ,				width=5_12 ,				height=5_12 ,				sld_guidance_scale=0 ,				)

										_snake_case :			Any  						=   output.images
										_snake_case :			int  						=   image[0, -3:, -3:, -1]
										_snake_case :			str  						=   [0.3502, 0.3622, 0.3396, 0.3642, 0.3478, 0.3318, 0.35, 0.3348, 0.3297]

										assert image.shape == (1, 5_12, 5_12, 3)

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

										_snake_case :			Optional[Any]  						=   torch.manual_seed(lowerCamelCase_					)
										_snake_case :			Any  						=   sd_pipe(
										    [prompt] ,				generator=lowerCamelCase_ ,				guidance_scale=lowerCamelCase_ ,				num_inference_steps=50 ,				output_type='np' ,				width=5_12 ,				height=5_12 ,				sld_guidance_scale=20_00 ,				sld_warmup_steps=7 ,				sld_threshold=0.025 ,				sld_momentum_scale=0.5 ,				sld_mom_beta=0.7 ,				)

										_snake_case :			str  						=   output.images
										_snake_case :			List[str]  						=   image[0, -3:, -3:, -1]
										_snake_case :			Union[str, Any]  						=   [0.5531, 0.5206, 0.4895, 0.5156, 0.5182, 0.4751, 0.4802, 0.4803, 0.4443]

										assert image.shape == (1, 5_12, 5_12, 3)

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







						def 		__UpperCAmelCase       (    self			:		Tuple					):





										'''simple docstring'''







										_snake_case :			Optional[int]  						=   StableDiffusionPipeline.from_pretrained('runwayml/stable-diffusion-v1-5'					)
										_snake_case :			Optional[int]  						=   sd_pipe.to(lowerCamelCase_					)
										sd_pipe.set_progress_bar_config(disable=lowerCamelCase_					)

										_snake_case :			List[Any]  						=   (
										    'the four horsewomen of the apocalypse, painting by tom of finland, gaston bussiere, craig mullins, j. c.'
										    ' leyendecker'
										)
										_snake_case :			Union[str, Any]  						=   10_44_35_52_34
										_snake_case :			Dict  						=   12

										_snake_case :			Optional[int]  						=   torch.manual_seed(lowerCamelCase_					)
										_snake_case :			Any  						=   sd_pipe(
										    [prompt] ,				generator=lowerCamelCase_ ,				guidance_scale=lowerCamelCase_ ,				num_inference_steps=50 ,				output_type='np' ,				width=5_12 ,				height=5_12 ,				sld_guidance_scale=0 ,				)

										_snake_case :			Optional[int]  						=   output.images
										_snake_case :			int  						=   image[0, -3:, -3:, -1]
										_snake_case :			Optional[int]  						=   np.array([0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]					)

										assert image.shape == (1, 5_12, 5_12, 3)

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

										_snake_case :			List[Any]  						=   torch.manual_seed(lowerCamelCase_					)
										_snake_case :			Optional[int]  						=   sd_pipe(
										    [prompt] ,				generator=lowerCamelCase_ ,				guidance_scale=lowerCamelCase_ ,				num_inference_steps=50 ,				output_type='np' ,				width=5_12 ,				height=5_12 ,				sld_guidance_scale=20_00 ,				sld_warmup_steps=7 ,				sld_threshold=0.025 ,				sld_momentum_scale=0.5 ,				sld_mom_beta=0.7 ,				)

										_snake_case :			str  						=   output.images
										_snake_case :			List[str]  						=   image[0, -3:, -3:, -1]
										_snake_case :			int  						=   np.array([0.5818, 0.6285, 0.6835, 0.6019, 0.625, 0.6754, 0.6096, 0.6334, 0.6561]					)
										assert image.shape == (1, 5_12, 5_12, 3)

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






