



"""simple docstring"""







import os
import unittest

from transformers import BertTokenizerFast
from transformers.models.bert.tokenization_bert import (
    VOCAB_FILES_NAMES,
    BasicTokenizer,
    BertTokenizer,
    WordpieceTokenizer,
    _is_control,
    _is_punctuation,
    _is_whitespace,
)
from transformers.testing_utils import require_tokenizers, slow

from ...test_tokenization_common import TokenizerTesterMixin, filter_non_english

@require_tokenizers
class       _a  ( SCREAMING_SNAKE_CASE__     ,	unittest.TestCase):
			__magic_name__     					=     BertTokenizer
			__magic_name__     					=     BertTokenizerFast
			__magic_name__     					=     True
			__magic_name__     					=     True
			__magic_name__     					=     filter_non_english



			def 				__lowercase					(			self							:				List[str]		)							->					Union[str, Any]:
									super().setUp()

									snake_case   :			int						    = [
									    "[UNK]",
									    "[CLS]",
									    "[SEP]",
									    "[PAD]",
									    "[MASK]",
									    "want",
									    "##want",
									    "##ed",
									    "wa",
									    "un",
									    "runn",
									    "##ing",
									    ",",
									    "low",
									    "lowest",
									]
									snake_case   :			Any						    = os.path.join(self.tmpdirname   ,	VOCAB_FILES_NAMES["vocab_file"]		)
									with open(self.vocab_file   ,	"w"   ,	encoding="utf-8"		) as vocab_writer:
															vocab_writer.write("".join([x + "\n" for x in vocab_tokens]		)		)



			def 				__lowercase					(			self							:				Union[str, Any]   ,	_lowercase							:				List[str]		)							->					int:
									snake_case   :			Any						    = "UNwant\u00E9d,running"
									snake_case   :			Union[str, Any]						    = "unwanted, running"
									return input_text, output_text



			def 				__lowercase					(			self							:				List[Any]		)							->					Optional[Any]:
									snake_case   :			Union[str, Any]						    = self.tokenizer_class(self.vocab_file		)

									snake_case   :			int						    = tokenizer.tokenize("UNwant\u00E9d,running"		)
									self.assertListEqual(_lowercase   ,	["un", "##want", "##ed", ",", "runn", "##ing"]		)
									self.assertListEqual(tokenizer.convert_tokens_to_ids(_lowercase		)   ,	[9, 6, 7, 12, 10, 11]		)



			def 				__lowercase					(			self							:				List[Any]		)							->					str:
									if not self.test_rust_tokenizer:
															return

									snake_case   :			Any						    = self.get_tokenizer()
									snake_case   :			Dict						    = self.get_rust_tokenizer()

									snake_case   :			Union[str, Any]						    = "UNwant\u00E9d,running"

									snake_case   :			Optional[int]						    = tokenizer.tokenize(_lowercase		)
									snake_case   :			List[Any]						    = rust_tokenizer.tokenize(_lowercase		)
									self.assertListEqual(_lowercase   ,	_lowercase		)

									snake_case   :			int						    = tokenizer.encode(_lowercase   ,	add_special_tokens=_lowercase		)
									snake_case   :			str						    = rust_tokenizer.encode(_lowercase   ,	add_special_tokens=_lowercase		)
									self.assertListEqual(_lowercase   ,	_lowercase		)

									snake_case   :			int						    = self.get_rust_tokenizer()
									snake_case   :			Optional[Any]						    = tokenizer.encode(_lowercase		)
									snake_case   :			Tuple						    = rust_tokenizer.encode(_lowercase		)
									self.assertListEqual(_lowercase   ,	_lowercase		)

									# With lower casing
									snake_case   :			List[str]						    = self.get_tokenizer(do_lower_case=_lowercase		)
									snake_case   :			List[Any]						    = self.get_rust_tokenizer(do_lower_case=_lowercase		)

									snake_case   :			int						    = "UNwant\u00E9d,running"

									snake_case   :			Optional[int]						    = tokenizer.tokenize(_lowercase		)
									snake_case   :			str						    = rust_tokenizer.tokenize(_lowercase		)
									self.assertListEqual(_lowercase   ,	_lowercase		)

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

									snake_case   :			Dict						    = self.get_rust_tokenizer()
									snake_case   :			Optional[int]						    = tokenizer.encode(_lowercase		)
									snake_case   :			List[Any]						    = rust_tokenizer.encode(_lowercase		)
									self.assertListEqual(_lowercase   ,	_lowercase		)



			def 				__lowercase					(			self							:				Tuple		)							->					Any:
									snake_case   :			Optional[Any]						    = BasicTokenizer()

									self.assertListEqual(tokenizer.tokenize("ah\u535A\u63A8zz"		)   ,	["ah", "\u535A", "\u63A8", "zz"]		)



			def 				__lowercase					(			self							:				Optional[int]		)							->					str:
									snake_case   :			Tuple						    = BasicTokenizer(do_lower_case=_lowercase		)

									self.assertListEqual(
									    tokenizer.tokenize(" \tHeLLo!how  \n Are yoU?  "		)   ,	["hello", "!", "how", "are", "you", "?"]		)
									self.assertListEqual(tokenizer.tokenize("H\u00E9llo"		)   ,	["hello"]		)



			def 				__lowercase					(			self							:				int		)							->					str:
									snake_case   :			Dict						    = BasicTokenizer(do_lower_case=_lowercase   ,	strip_accents=_lowercase		)

									self.assertListEqual(
									    tokenizer.tokenize(" \tHäLLo!how  \n Are yoU?  "		)   ,	["hällo", "!", "how", "are", "you", "?"]		)
									self.assertListEqual(tokenizer.tokenize("H\u00E9llo"		)   ,	["h\u00E9llo"]		)



			def 				__lowercase					(			self							:				List[Any]		)							->					Tuple:
									snake_case   :			List[Any]						    = BasicTokenizer(do_lower_case=_lowercase   ,	strip_accents=_lowercase		)

									self.assertListEqual(
									    tokenizer.tokenize(" \tHäLLo!how  \n Are yoU?  "		)   ,	["hallo", "!", "how", "are", "you", "?"]		)
									self.assertListEqual(tokenizer.tokenize("H\u00E9llo"		)   ,	["hello"]		)



			def 				__lowercase					(			self							:				str		)							->					Tuple:
									snake_case   :			List[str]						    = BasicTokenizer(do_lower_case=_lowercase		)

									self.assertListEqual(
									    tokenizer.tokenize(" \tHäLLo!how  \n Are yoU?  "		)   ,	["hallo", "!", "how", "are", "you", "?"]		)
									self.assertListEqual(tokenizer.tokenize("H\u00E9llo"		)   ,	["hello"]		)



			def 				__lowercase					(			self							:				List[str]		)							->					Any:
									snake_case   :			Dict						    = BasicTokenizer(do_lower_case=_lowercase		)

									self.assertListEqual(
									    tokenizer.tokenize(" \tHeLLo!how  \n Are yoU?  "		)   ,	["HeLLo", "!", "how", "Are", "yoU", "?"]		)



			def 				__lowercase					(			self							:				int		)							->					Optional[int]:
									snake_case   :			Optional[int]						    = BasicTokenizer(do_lower_case=_lowercase   ,	strip_accents=_lowercase		)

									self.assertListEqual(
									    tokenizer.tokenize(" \tHäLLo!how  \n Are yoU?  "		)   ,	["HäLLo", "!", "how", "Are", "yoU", "?"]		)



			def 				__lowercase					(			self							:				Dict		)							->					Union[str, Any]:
									snake_case   :			str						    = BasicTokenizer(do_lower_case=_lowercase   ,	strip_accents=_lowercase		)

									self.assertListEqual(
									    tokenizer.tokenize(" \tHäLLo!how  \n Are yoU?  "		)   ,	["HaLLo", "!", "how", "Are", "yoU", "?"]		)



			def 				__lowercase					(			self							:				List[Any]		)							->					Any:
									snake_case   :			int						    = BasicTokenizer(do_lower_case=_lowercase   ,	never_split=["[UNK]"]		)

									self.assertListEqual(
									    tokenizer.tokenize(" \tHeLLo!how  \n Are yoU? [UNK]"		)   ,	["HeLLo", "!", "how", "Are", "yoU", "?", "[UNK]"]		)



			def 				__lowercase					(			self							:				Tuple		)							->					List[Any]:
									snake_case   :			int						    = BasicTokenizer()
									snake_case   :			int						    = "a\n'll !!to?'d of, can't."
									snake_case   :			Any						    = ["a", "'", "ll", "!", "!", "to", "?", "'", "d", "of", ",", "can", "'", "t", "."]
									self.assertListEqual(tokenizer.tokenize(_lowercase		)   ,	_lowercase		)



			def 				__lowercase					(			self							:				str		)							->					Tuple:
									snake_case   :			int						    = ["[UNK]", "[CLS]", "[SEP]", "want", "##want", "##ed", "wa", "un", "runn", "##ing"]

									snake_case   :			Dict						    = {}
									for i, token in enumerate(_lowercase		):
															snake_case   :			Tuple						    = i
									snake_case   :			List[Any]						    = WordpieceTokenizer(vocab=_lowercase   ,	unk_token="[UNK]"		)

									self.assertListEqual(tokenizer.tokenize(""		)   ,	[]		)

									self.assertListEqual(tokenizer.tokenize("unwanted running"		)   ,	["un", "##want", "##ed", "runn", "##ing"]		)

									self.assertListEqual(tokenizer.tokenize("unwantedX running"		)   ,	["[UNK]", "runn", "##ing"]		)



			def 				__lowercase					(			self							:				List[Any]		)							->					Union[str, Any]:
									self.assertTrue(_is_whitespace(" "		)		)
									self.assertTrue(_is_whitespace("\t"		)		)
									self.assertTrue(_is_whitespace("\r"		)		)
									self.assertTrue(_is_whitespace("\n"		)		)
									self.assertTrue(_is_whitespace("\u00A0"		)		)

									self.assertFalse(_is_whitespace("A"		)		)
									self.assertFalse(_is_whitespace("-"		)		)



			def 				__lowercase					(			self							:				str		)							->					List[Any]:
									self.assertTrue(_is_control("\u0005"		)		)

									self.assertFalse(_is_control("A"		)		)
									self.assertFalse(_is_control(" "		)		)
									self.assertFalse(_is_control("\t"		)		)
									self.assertFalse(_is_control("\r"		)		)



			def 				__lowercase					(			self							:				Any		)							->					Tuple:
									self.assertTrue(_is_punctuation("-"		)		)
									self.assertTrue(_is_punctuation("$"		)		)
									self.assertTrue(_is_punctuation("`"		)		)
									self.assertTrue(_is_punctuation("."		)		)

									self.assertFalse(_is_punctuation("A"		)		)
									self.assertFalse(_is_punctuation(" "		)		)



			def 				__lowercase					(			self							:				Tuple		)							->					List[str]:
									snake_case   :			str						    = self.get_tokenizer()
									snake_case   :			int						    = self.get_rust_tokenizer()

									# Example taken from the issue https://github.com/huggingface/tokenizers/issues/340
									self.assertListEqual([tokenizer.tokenize(_lowercase		) for t in ["Test", "\xad", "test"]]   ,	[["[UNK]"], [], ["[UNK]"]]		)

									self.assertListEqual(
									    [rust_tokenizer.tokenize(_lowercase		) for t in ["Test", "\xad", "test"]]   ,	[["[UNK]"], [], ["[UNK]"]]		)



			@slow
			def 				__lowercase					(			self							:				str		)							->					str:
									snake_case   :			str						    = self.tokenizer_class.from_pretrained("bert-base-uncased"		)

									snake_case   :			List[Any]						    = tokenizer.encode("sequence builders"   ,	add_special_tokens=_lowercase		)
									snake_case   :			Any						    = tokenizer.encode("multi-sequence build"   ,	add_special_tokens=_lowercase		)

									snake_case   :			Optional[int]						    = tokenizer.build_inputs_with_special_tokens(_lowercase		)
									snake_case   :			Tuple						    = tokenizer.build_inputs_with_special_tokens(_lowercase   ,	_lowercase		)

									assert encoded_sentence == [101] + text + [102]
									assert encoded_pair == [101] + text + [102] + text_a + [102]



			def 				__lowercase					(			self							:				List[str]		)							->					List[str]:
									for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
															with self.subTest(F'''{tokenizer.__class__.__name__} ({pretrained_name})'''		):
																					snake_case   :			str						    = self.rust_tokenizer_class.from_pretrained(_lowercase   ,	**_lowercase		)

																					snake_case   :			str						    = F'''A, naïve {tokenizer_r.mask_token} AllenNLP sentence.'''
																					snake_case   :			int						    = tokenizer_r.encode_plus(
																					    _lowercase   ,	return_attention_mask=_lowercase   ,	return_token_type_ids=_lowercase   ,	return_offsets_mapping=_lowercase   ,	add_special_tokens=_lowercase   ,	)

																					snake_case   :			Tuple						    = tokenizer_r.do_lower_case if hasattr(_lowercase   ,	"do_lower_case"		) else False
																					snake_case   :			Union[str, Any]						    = (
																					    [
																					        ((0, 0), tokenizer_r.cls_token),
																					        ((0, 1), "A"),
																					        ((1, 2), ","),
																					        ((3, 5), "na"),
																					        ((5, 6), "##ï"),
																					        ((6, 8), "##ve"),
																					        ((9, 15), tokenizer_r.mask_token),
																					        ((16, 21), "Allen"),
																					        ((21, 23), "##NL"),
																					        ((23, 24), "##P"),
																					        ((25, 33), "sentence"),
																					        ((33, 34), "."),
																					        ((0, 0), tokenizer_r.sep_token),
																					    ]
																					    if not do_lower_case
																					    else [
																					        ((0, 0), tokenizer_r.cls_token),
																					        ((0, 1), "a"),
																					        ((1, 2), ","),
																					        ((3, 8), "naive"),
																					        ((9, 15), tokenizer_r.mask_token),
																					        ((16, 21), "allen"),
																					        ((21, 23), "##nl"),
																					        ((23, 24), "##p"),
																					        ((25, 33), "sentence"),
																					        ((33, 34), "."),
																					        ((0, 0), tokenizer_r.sep_token),
																					    ]
																					)

																					self.assertEqual(
																					    [e[1] for e in expected_results]   ,	tokenizer_r.convert_ids_to_tokens(tokens["input_ids"]		)		)
																					self.assertEqual([e[0] for e in expected_results]   ,	tokens["offset_mapping"]		)



			def 				__lowercase					(			self							:				Union[str, Any]		)							->					Any:
									snake_case   :			Dict						    = ["的", "人", "有"]
									snake_case   :			Any						    = "".join(_lowercase		)
									for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
															with self.subTest(F'''{tokenizer.__class__.__name__} ({pretrained_name})'''		):
																					snake_case   :			List[Any]						    = True
																					snake_case   :			Tuple						    = self.tokenizer_class.from_pretrained(_lowercase   ,	**_lowercase		)
																					snake_case   :			Dict						    = self.rust_tokenizer_class.from_pretrained(_lowercase   ,	**_lowercase		)

																					snake_case   :			Tuple						    = tokenizer_p.encode(_lowercase   ,	add_special_tokens=_lowercase		)
																					snake_case   :			Dict						    = tokenizer_r.encode(_lowercase   ,	add_special_tokens=_lowercase		)

																					snake_case   :			Optional[Any]						    = tokenizer_r.convert_ids_to_tokens(_lowercase		)
																					snake_case   :			Any						    = tokenizer_p.convert_ids_to_tokens(_lowercase		)

																					# it is expected that each Chinese character is not preceded by "##"
																					self.assertListEqual(_lowercase   ,	_lowercase		)
																					self.assertListEqual(_lowercase   ,	_lowercase		)

																					snake_case   :			Optional[int]						    = False
																					snake_case   :			int						    = self.rust_tokenizer_class.from_pretrained(_lowercase   ,	**_lowercase		)
																					snake_case   :			Optional[Any]						    = self.tokenizer_class.from_pretrained(_lowercase   ,	**_lowercase		)

																					snake_case   :			List[Any]						    = tokenizer_r.encode(_lowercase   ,	add_special_tokens=_lowercase		)
																					snake_case   :			Optional[int]						    = tokenizer_p.encode(_lowercase   ,	add_special_tokens=_lowercase		)

																					snake_case   :			Optional[Any]						    = tokenizer_r.convert_ids_to_tokens(_lowercase		)
																					snake_case   :			Optional[int]						    = tokenizer_p.convert_ids_to_tokens(_lowercase		)

																					# it is expected that only the first Chinese character is not preceded by "##".
																					snake_case   :			Optional[Any]						    = [
																					    F'''##{token}''' if idx != 0 else token for idx, token in enumerate(_lowercase		)
																					]
																					self.assertListEqual(_lowercase   ,	_lowercase		)
																					self.assertListEqual(_lowercase   ,	_lowercase		)








"""simple docstring"""







import gc
import unittest

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

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    EulerAncestralDiscreteScheduler,
    LMSDiscreteScheduler,
    PNDMScheduler,
    StableDiffusionPanoramaPipeline,
    UNetaDConditionModel,
)
from diffusers.utils import slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu, skip_mps

from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_IMAGE_PARAMS, TEXT_TO_IMAGE_PARAMS
from ..test_pipelines_common import PipelineLatentTesterMixin, PipelineTesterMixin


enable_full_determinism()

@skip_mps
class       _a  ( SCREAMING_SNAKE_CASE__     ,	SCREAMING_SNAKE_CASE__     ,	unittest.TestCase):
			__magic_name__     					=     StableDiffusionPanoramaPipeline
			__magic_name__     					=     TEXT_TO_IMAGE_PARAMS
			__magic_name__     					=     TEXT_TO_IMAGE_BATCH_PARAMS
			__magic_name__     					=     TEXT_TO_IMAGE_IMAGE_PARAMS
			__magic_name__     					=     TEXT_TO_IMAGE_IMAGE_PARAMS



			def 				__lowercase					(			self							:				Optional[int]		)							->					int:
									torch.manual_seed(0		)
									snake_case   :			Optional[Any]						    = UNetaDConditionModel(
									    block_out_channels=(32, 64)   ,	layers_per_block=1   ,	sample_size=32   ,	in_channels=4   ,	out_channels=4   ,	down_block_types=("DownBlock2D", "CrossAttnDownBlock2D")   ,	up_block_types=("CrossAttnUpBlock2D", "UpBlock2D")   ,	cross_attention_dim=32   ,	)
									snake_case   :			Tuple						    = DDIMScheduler()
									torch.manual_seed(0		)
									snake_case   :			List[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   ,	)
									torch.manual_seed(0		)
									snake_case   :			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=1000   ,	)
									snake_case   :			int						    = CLIPTextModel(_lowercase		)
									snake_case   :			Union[str, Any]						    = CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"		)

									snake_case   :			Any						    = {
									    "unet": unet,
									    "scheduler": scheduler,
									    "vae": vae,
									    "text_encoder": text_encoder,
									    "tokenizer": tokenizer,
									    "safety_checker": None,
									    "feature_extractor": None,
									}
									return components



			def 				__lowercase					(			self							:				List[str]   ,	_lowercase							:				int   ,	_lowercase							:				Dict=0		)							->					Optional[int]:
									snake_case   :			Union[str, Any]						    = torch.manual_seed(_lowercase		)
									snake_case   :			str						    = {
									    "prompt": "a photo of the dolomites",
									    "generator": generator,
									    # Setting height and width to None to prevent OOMs on CPU.
									    "height": None,
									    "width": None,
									    "num_inference_steps": 1,
									    "guidance_scale": 6.0,
									    "output_type": "numpy",
									}
									return inputs



			def 				__lowercase					(			self							:				str		)							->					List[str]:
									snake_case   :			Any						    = "cpu"  # ensure determinism for the device-dependent torch.Generator
									snake_case   :			Dict						    = self.get_dummy_components()
									snake_case   :			Any						    = StableDiffusionPanoramaPipeline(**_lowercase		)
									snake_case   :			List[Any]						    = sd_pipe.to(_lowercase		)
									sd_pipe.set_progress_bar_config(disable=_lowercase		)

									snake_case   :			Optional[Any]						    = self.get_dummy_inputs(_lowercase		)
									snake_case   :			Union[str, Any]						    = sd_pipe(**_lowercase		).images
									snake_case   :			List[Any]						    = image[0, -3:, -3:, -1]
									assert image.shape == (1, 64, 64, 3)

									snake_case   :			List[Any]						    = np.array([0.6186, 0.5374, 0.4915, 0.4135, 0.4114, 0.4563, 0.5128, 0.4977, 0.4757]		)

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



			def 				__lowercase					(			self							:				int		)							->					Union[str, Any]:
									super().test_inference_batch_consistent(batch_sizes=[1, 2]		)



			def 				__lowercase					(			self							:				Tuple		)							->					Tuple:
									super().test_inference_batch_single_identical(batch_size=2   ,	expected_max_diff=3.25E-3		)



			def 				__lowercase					(			self							:				Any		)							->					List[Any]:
									snake_case   :			Any						    = "cpu"  # ensure determinism for the device-dependent torch.Generator
									snake_case   :			Union[str, Any]						    = self.get_dummy_components()
									snake_case   :			Tuple						    = StableDiffusionPanoramaPipeline(**_lowercase		)
									snake_case   :			Tuple						    = sd_pipe.to(_lowercase		)
									sd_pipe.set_progress_bar_config(disable=_lowercase		)

									snake_case   :			List[str]						    = self.get_dummy_inputs(_lowercase		)
									snake_case   :			int						    = "french fries"
									snake_case   :			Union[str, Any]						    = sd_pipe(**_lowercase   ,	negative_prompt=_lowercase		)
									snake_case   :			str						    = output.images
									snake_case   :			Optional[Any]						    = image[0, -3:, -3:, -1]

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

									snake_case   :			Union[str, Any]						    = np.array([0.6187, 0.5375, 0.4915, 0.4136, 0.4114, 0.4563, 0.5128, 0.4976, 0.4757]		)

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



			def 				__lowercase					(			self							:				str		)							->					Any:
									snake_case   :			Optional[Any]						    = "cpu"  # ensure determinism for the device-dependent torch.Generator
									snake_case   :			List[Any]						    = self.get_dummy_components()
									snake_case   :			List[Any]						    = StableDiffusionPanoramaPipeline(**_lowercase		)
									snake_case   :			int						    = sd_pipe.to(_lowercase		)
									sd_pipe.set_progress_bar_config(disable=_lowercase		)

									snake_case   :			Tuple						    = self.get_dummy_inputs(_lowercase		)
									snake_case   :			str						    = sd_pipe(**_lowercase   ,	view_batch_size=2		)
									snake_case   :			Optional[Any]						    = output.images
									snake_case   :			int						    = image[0, -3:, -3:, -1]

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

									snake_case   :			str						    = np.array([0.6187, 0.5375, 0.4915, 0.4136, 0.4114, 0.4563, 0.5128, 0.4976, 0.4757]		)

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



			def 				__lowercase					(			self							:				int		)							->					Optional[Any]:
									snake_case   :			Dict						    = "cpu"  # ensure determinism for the device-dependent torch.Generator
									snake_case   :			List[str]						    = self.get_dummy_components()
									snake_case   :			Any						    = EulerAncestralDiscreteScheduler(
									    beta_start=0.00085   ,	beta_end=0.012   ,	beta_schedule="scaled_linear"		)
									snake_case   :			List[str]						    = StableDiffusionPanoramaPipeline(**_lowercase		)
									snake_case   :			List[str]						    = sd_pipe.to(_lowercase		)
									sd_pipe.set_progress_bar_config(disable=_lowercase		)

									snake_case   :			List[Any]						    = self.get_dummy_inputs(_lowercase		)
									snake_case   :			Optional[Any]						    = sd_pipe(**_lowercase		).images
									snake_case   :			int						    = image[0, -3:, -3:, -1]

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

									snake_case   :			Tuple						    = np.array([0.4024, 0.6510, 0.4901, 0.5378, 0.5813, 0.5622, 0.4795, 0.4467, 0.4952]		)

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



			def 				__lowercase					(			self							:				Tuple		)							->					Union[str, Any]:
									snake_case   :			str						    = "cpu"  # ensure determinism for the device-dependent torch.Generator
									snake_case   :			str						    = self.get_dummy_components()
									snake_case   :			Optional[int]						    = PNDMScheduler(
									    beta_start=0.00085   ,	beta_end=0.012   ,	beta_schedule="scaled_linear"   ,	skip_prk_steps=_lowercase		)
									snake_case   :			Dict						    = StableDiffusionPanoramaPipeline(**_lowercase		)
									snake_case   :			Dict						    = sd_pipe.to(_lowercase		)
									sd_pipe.set_progress_bar_config(disable=_lowercase		)

									snake_case   :			Dict						    = self.get_dummy_inputs(_lowercase		)
									snake_case   :			Optional[int]						    = sd_pipe(**_lowercase		).images
									snake_case   :			str						    = image[0, -3:, -3:, -1]

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

									snake_case   :			Optional[int]						    = np.array([0.6391, 0.6291, 0.4861, 0.5134, 0.5552, 0.4578, 0.5032, 0.5023, 0.4539]		)

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



@slow
@require_torch_gpu
class       _a  ( unittest.TestCase):



			def 				__lowercase					(			self							:				Union[str, Any]		)							->					str:
									super().tearDown()
									gc.collect()
									torch.cuda.empty_cache()



			def 				__lowercase					(			self							:				Dict   ,	_lowercase							:				Any=0		)							->					Optional[Any]:
									snake_case   :			Any						    = torch.manual_seed(_lowercase		)
									snake_case   :			Any						    = {
									    "prompt": "a photo of the dolomites",
									    "generator": generator,
									    "num_inference_steps": 3,
									    "guidance_scale": 7.5,
									    "output_type": "numpy",
									}
									return inputs



			def 				__lowercase					(			self							:				Optional[Any]		)							->					Union[str, Any]:
									snake_case   :			List[Any]						    = "stabilityai/stable-diffusion-2-base"
									snake_case   :			Dict						    = DDIMScheduler.from_pretrained(_lowercase   ,	subfolder="scheduler"		)
									snake_case   :			Any						    = StableDiffusionPanoramaPipeline.from_pretrained(_lowercase   ,	scheduler=_lowercase   ,	safety_checker=_lowercase		)
									pipe.to(_lowercase		)
									pipe.set_progress_bar_config(disable=_lowercase		)
									pipe.enable_attention_slicing()

									snake_case   :			str						    = self.get_inputs()
									snake_case   :			List[Any]						    = pipe(**_lowercase		).images
									snake_case   :			Optional[int]						    = image[0, -3:, -3:, -1].flatten()

									assert image.shape == (1, 512, 2048, 3)

									snake_case   :			List[str]						    = np.array(
									    [
									        0.36968392,
									        0.27025372,
									        0.32446766,
									        0.28379387,
									        0.36363274,
									        0.30733347,
									        0.27100027,
									        0.27054125,
									        0.25536096,
									    ]		)

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



			def 				__lowercase					(			self							:				Tuple		)							->					List[str]:
									snake_case   :			List[str]						    = StableDiffusionPanoramaPipeline.from_pretrained(
									    "stabilityai/stable-diffusion-2-base"   ,	safety_checker=_lowercase		)
									snake_case   :			int						    = LMSDiscreteScheduler.from_config(pipe.scheduler.config		)
									pipe.to(_lowercase		)
									pipe.set_progress_bar_config(disable=_lowercase		)
									pipe.enable_attention_slicing()

									snake_case   :			Dict						    = self.get_inputs()
									snake_case   :			int						    = pipe(**_lowercase		).images
									snake_case   :			Optional[Any]						    = image[0, -3:, -3:, -1].flatten()

									assert image.shape == (1, 512, 2048, 3)

									snake_case   :			List[str]						    = np.array(
									    [
									        [
									            0.0,
									            0.0,
									            0.0,
									            0.0,
									            0.0,
									            0.0,
									            0.0,
									            0.0,
									            0.0,
									        ]
									    ]		)

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



			def 				__lowercase					(			self							:				str		)							->					Any:
									snake_case   :			Any						    = 0

									def callback_fn(_lowercase							:				int   ,	_lowercase							:				int   ,	_lowercase							:				torch.FloatTensor		) -> None:
															snake_case   :			List[Any]						    = True
															nonlocal number_of_steps
															number_of_steps += 1
															if step == 1:
																					snake_case   :			List[Any]						    = latents.detach().cpu().numpy()
																					assert latents.shape == (1, 4, 64, 256)
																					snake_case   :			int						    = latents[0, -3:, -3:, -1]

																					snake_case   :			Tuple						    = np.array(
																					    [
																					        0.18681869,
																					        0.33907816,
																					        0.5361276,
																					        0.14432865,
																					        -0.02856611,
																					        -0.73941123,
																					        0.23397987,
																					        0.47322682,
																					        -0.37823164,
																					    ]		)
																					assert np.abs(latents_slice.flatten() - expected_slice		).max() < 5E-2
															elif step == 2:
																					snake_case   :			Union[str, Any]						    = latents.detach().cpu().numpy()
																					assert latents.shape == (1, 4, 64, 256)
																					snake_case   :			Tuple						    = latents[0, -3:, -3:, -1]

																					snake_case   :			Tuple						    = np.array(
																					    [
																					        0.18539645,
																					        0.33987248,
																					        0.5378559,
																					        0.14437142,
																					        -0.02455261,
																					        -0.7338317,
																					        0.23990755,
																					        0.47356272,
																					        -0.3786505,
																					    ]		)

																					assert np.abs(latents_slice.flatten() - expected_slice		).max() < 5E-2

									snake_case   :			Dict						    = False

									snake_case   :			List[Any]						    = "stabilityai/stable-diffusion-2-base"
									snake_case   :			List[str]						    = DDIMScheduler.from_pretrained(_lowercase   ,	subfolder="scheduler"		)
									snake_case   :			Optional[Any]						    = StableDiffusionPanoramaPipeline.from_pretrained(_lowercase   ,	scheduler=_lowercase   ,	safety_checker=_lowercase		)
									snake_case   :			Any						    = pipe.to(_lowercase		)
									pipe.set_progress_bar_config(disable=_lowercase		)
									pipe.enable_attention_slicing()

									snake_case   :			Tuple						    = self.get_inputs()
									pipe(**_lowercase   ,	callback=_lowercase   ,	callback_steps=1		)
									assert callback_fn.has_been_called
									assert number_of_steps == 3



			def 				__lowercase					(			self							:				Any		)							->					Tuple:
									torch.cuda.empty_cache()
									torch.cuda.reset_max_memory_allocated()
									torch.cuda.reset_peak_memory_stats()

									snake_case   :			Optional[int]						    = "stabilityai/stable-diffusion-2-base"
									snake_case   :			Tuple						    = DDIMScheduler.from_pretrained(_lowercase   ,	subfolder="scheduler"		)
									snake_case   :			Any						    = StableDiffusionPanoramaPipeline.from_pretrained(_lowercase   ,	scheduler=_lowercase   ,	safety_checker=_lowercase		)
									snake_case   :			Tuple						    = pipe.to(_lowercase		)
									pipe.set_progress_bar_config(disable=_lowercase		)
									pipe.enable_attention_slicing(1		)
									pipe.enable_sequential_cpu_offload()

									snake_case   :			Any						    = self.get_inputs()
									snake_case   :			Optional[int]						    = pipe(**_lowercase		)

									snake_case   :			int						    = torch.cuda.max_memory_allocated()
									# make sure that less than 5.2 GB is allocated
									assert mem_bytes < 5.5 * 10**9



