"""simple docstring"""





import pickle
import shutil
import tempfile
import unittest

from transformers import SPIECE_UNDERLINE, XLMRobertaTokenizer, XLMRobertaTokenizerFast
from transformers.testing_utils import get_tests_dir, require_sentencepiece, require_tokenizers, slow
from transformers.utils import cached_property

from ...test_tokenization_common import TokenizerTesterMixin


__A  =				get_tests_dir('''fixtures/test_sentencepiece.model''')
@require_sentencepiece
@require_tokenizers
class  _snake_case     (					__lowerCAmelCase				, unittest.TestCase		):
						snake_case__			  =			XLMRobertaTokenizer
						snake_case__			  =			XLMRobertaTokenizerFast
						snake_case__			  =			True
						snake_case__			  =			True






						def       lowerCamelCase__     (       self      :			int    ):
													super().setUp()

													# We have a SentencePiece fixture for testing
													__lowerCamelCase					:		Union[str, Any]		   =     XLMRobertaTokenizer(_UpperCamelCase							,					keep_accents=_UpperCamelCase    )
													tokenizer.save_pretrained(self.tmpdirname    )






						def       lowerCamelCase__     (       self      :			List[str]    ):
													__lowerCamelCase					:		Optional[Any]		   =     """<pad>"""
													__lowerCamelCase					:		Optional[int]		   =     1

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






						def       lowerCamelCase__     (       self      :			Tuple    ):
													__lowerCamelCase					:		Union[str, Any]		   =     list(self.get_tokenizer().get_vocab().keys()    )

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






						def       lowerCamelCase__     (       self      :			Any    ):
													self.assertEqual(self.get_tokenizer().vocab_size							,					1002    )






						def       lowerCamelCase__     (       self      :			List[str]    ):
													__lowerCamelCase					:		Tuple		   =     XLMRobertaTokenizer(_UpperCamelCase							,					keep_accents=_UpperCamelCase    )

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

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

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

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






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


													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					:		Tuple		   =     (self.rust_tokenizer_class, """hf-internal-testing/tiny-xlm-roberta""", {})
													for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
																				with self.subTest(F"""{tokenizer.__class__.__name__} ({pretrained_name})"""    ):
																											__lowerCamelCase					:		Dict		   =     self.rust_tokenizer_class.from_pretrained(_UpperCamelCase							,					**_UpperCamelCase    )
																											__lowerCamelCase					:		Optional[Any]		   =     self.tokenizer_class.from_pretrained(_UpperCamelCase							,					**_UpperCamelCase    )

																											__lowerCamelCase					:		str		   =     tempfile.mkdtemp()

																											__lowerCamelCase					:		Optional[int]		   =     tokenizer_r.save_pretrained(_UpperCamelCase    )
																											__lowerCamelCase					:		Optional[int]		   =     tokenizer_p.save_pretrained(_UpperCamelCase    )

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

																											# Checks everything loads correctly in the same way
																											__lowerCamelCase					:		str		   =     tokenizer_r.from_pretrained(_UpperCamelCase    )
																											__lowerCamelCase					:		Union[str, Any]		   =     tokenizer_p.from_pretrained(_UpperCamelCase    )

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

																											shutil.rmtree(_UpperCamelCase    )

																											# Save tokenizer rust, legacy_format=True
																											__lowerCamelCase					:		Union[str, Any]		   =     tempfile.mkdtemp()

																											__lowerCamelCase					:		Dict		   =     tokenizer_r.save_pretrained(_UpperCamelCase							,					legacy_format=_UpperCamelCase    )
																											__lowerCamelCase					:		Union[str, Any]		   =     tokenizer_p.save_pretrained(_UpperCamelCase    )

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

																											# Checks everything loads correctly in the same way
																											__lowerCamelCase					:		Optional[int]		   =     tokenizer_r.from_pretrained(_UpperCamelCase    )
																											__lowerCamelCase					:		Union[str, Any]		   =     tokenizer_p.from_pretrained(_UpperCamelCase    )

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

																											shutil.rmtree(_UpperCamelCase    )

																											# Save tokenizer rust, legacy_format=False
																											__lowerCamelCase					:		Dict		   =     tempfile.mkdtemp()

																											__lowerCamelCase					:		Union[str, Any]		   =     tokenizer_r.save_pretrained(_UpperCamelCase							,					legacy_format=_UpperCamelCase    )
																											__lowerCamelCase					:		Any		   =     tokenizer_p.save_pretrained(_UpperCamelCase    )

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

																											# Checks everything loads correctly in the same way
																											__lowerCamelCase					:		List[str]		   =     tokenizer_r.from_pretrained(_UpperCamelCase    )
																											__lowerCamelCase					:		Dict		   =     tokenizer_p.from_pretrained(_UpperCamelCase    )

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

																											shutil.rmtree(_UpperCamelCase    )






						@cached_property
						def       lowerCamelCase__     (       self      :			List[str]    ):
													return XLMRobertaTokenizer.from_pretrained("xlm-roberta-base"    )






						def       lowerCamelCase__     (       self      :			int    ):


													with tempfile.NamedTemporaryFile() as f:
																				shutil.copyfile(_UpperCamelCase							,					f.name    )
																				__lowerCamelCase					:		Tuple		   =     XLMRobertaTokenizer(f.name							,					keep_accents=_UpperCamelCase    )
																				__lowerCamelCase					:		List[Any]		   =     pickle.dumps(_UpperCamelCase    )
													pickle.loads(_UpperCamelCase    )






						def       lowerCamelCase__     (       self      :			int    ):


													if not self.test_rust_tokenizer:
																				return

													__lowerCamelCase					:		Tuple		   =     self.get_tokenizer()
													__lowerCamelCase					:		int		   =     self.get_rust_tokenizer()

													__lowerCamelCase					:		List[Any]		   =     """I was born in 92000, and this is falsé."""

													__lowerCamelCase					:		List[Any]		   =     tokenizer.tokenize(_UpperCamelCase    )
													__lowerCamelCase					:		Tuple		   =     rust_tokenizer.tokenize(_UpperCamelCase    )
													self.assertListEqual(_UpperCamelCase							,					_UpperCamelCase    )

													__lowerCamelCase					:		Optional[int]		   =     tokenizer.encode(_UpperCamelCase							,					add_special_tokens=_UpperCamelCase    )
													__lowerCamelCase					:		List[Any]		   =     rust_tokenizer.encode(_UpperCamelCase							,					add_special_tokens=_UpperCamelCase    )
													self.assertListEqual(_UpperCamelCase							,					_UpperCamelCase    )

													__lowerCamelCase					:		str		   =     self.get_rust_tokenizer()
													__lowerCamelCase					:		Any		   =     tokenizer.encode(_UpperCamelCase    )
													__lowerCamelCase					:		Any		   =     rust_tokenizer.encode(_UpperCamelCase    )
													self.assertListEqual(_UpperCamelCase							,					_UpperCamelCase    )






						@slow
						def       lowerCamelCase__     (       self      :			Optional[Any]    ):
													__lowerCamelCase					:		Optional[int]		   =     """Hello World!"""
													__lowerCamelCase					:		Tuple		   =     [0, 35378, 6661, 38, 2]
													# xlmr = torch.hub.load('pytorch/fairseq', 'xlmr.base')  # xlmr.large has same tokenizer
													# xlmr.eval()
													# xlmr.encode(symbols)

													self.assertListEqual(_UpperCamelCase							,					self.big_tokenizer.encode(_UpperCamelCase    )    )






						@slow
						def       lowerCamelCase__     (       self      :			Optional[int]    ):
													__lowerCamelCase					:		Any		   =     (
													    """This is a very long text with a lot of weird characters, such as: . , ~ ? ( ) \" [ ] ! : - . Also we will"""
													    """ add words that should not exsist and be tokenized to <unk>, such as saoneuhaoesuth"""
													)
													__lowerCamelCase					:		Optional[int]		   =     [
													    0,
													    3293,
													    83,
													    10,
													    4552,
													    4989,
													    7986,
													    678,
													    10,
													    5915,
													    111,
													    179459,
													    124850,
													    4,
													    6044,
													    237,
													    12,
													    6,
													    5,
													    6,
													    4,
													    6780,
													    705,
													    15,
													    1388,
													    44,
													    378,
													    10114,
													    711,
													    152,
													    20,
													    6,
													    5,
													    22376,
													    642,
													    1221,
													    15190,
													    34153,
													    450,
													    5608,
													    959,
													    1119,
													    57702,
													    136,
													    186,
													    47,
													    1098,
													    29367,
													    47,
													    # 4426, # What fairseq tokenizes from "<unk>": "_<"
													    # 3678, # What fairseq tokenizes from "<unk>": "unk"
													    # 2740, # What fairseq tokenizes from "<unk>": ">"
													    3,  # What we tokenize from "<unk>": "<unk>"
													    6,  # Residue from the tokenization: an extra sentencepiece underline
													    4,
													    6044,
													    237,
													    6284,
													    50901,
													    528,
													    31,
													    90,
													    34,
													    927,
													    2,
													]
													# xlmr = torch.hub.load('pytorch/fairseq', 'xlmr.base')  # xlmr.large has same tokenizer
													# xlmr.eval()
													# xlmr.encode(symbols)

													self.assertListEqual(_UpperCamelCase							,					self.big_tokenizer.encode(_UpperCamelCase    )    )







						@slow
						def       lowerCamelCase__     (       self      :			Tuple    ):
													__lowerCamelCase					:		Tuple		   =     {"""input_ids""": [[0, 11062, 82772, 7, 15, 82772, 538, 51529, 237, 17198, 1290, 206, 9, 215175, 1314, 136, 17198, 1290, 206, 9, 56359, 42, 122009, 9, 16466, 16, 87344, 4537, 9, 4717, 78381, 6, 159958, 7, 15, 24480, 618, 4, 527, 22693, 5428, 4, 2777, 24480, 9874, 4, 43523, 594, 4, 803, 18392, 33189, 18, 4, 43523, 24447, 12399, 100, 24955, 83658, 9626, 144057, 15, 839, 22335, 16, 136, 24955, 83658, 83479, 15, 39102, 724, 16, 678, 645, 2789, 1328, 4589, 42, 122009, 115774, 23, 805, 1328, 46876, 7, 136, 53894, 1940, 42227, 41159, 17721, 823, 425, 4, 27512, 98722, 206, 136, 5531, 4970, 919, 17336, 5, 2], [0, 20080, 618, 83, 82775, 47, 479, 9, 1517, 73, 53894, 333, 80581, 110117, 18811, 5256, 1295, 51, 152526, 297, 7986, 390, 124416, 538, 35431, 214, 98, 15044, 25737, 136, 7108, 43701, 23, 756, 135355, 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], [0, 581, 63773, 119455, 6, 147797, 88203, 7, 645, 70, 21, 3285, 10269, 5, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]], """attention_mask""": [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]}  # noqa: E501
													# fmt: on

													self.tokenizer_integration_test_util(
													    expected_encoding=_UpperCamelCase							,					model_name="xlm-roberta-base"							,					revision="d9d8a8ea5eb94b1c6654ae9249df7793cd2933d3"							,					)
"""simple docstring"""





from typing import Any, Callable, Dict, List, Optional, Union

import torch
from transformers import CLIPImageProcessor, CLIPTextModel, CLIPTokenizer

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    DiffusionPipeline,
    LMSDiscreteScheduler,
    PNDMScheduler,
    StableDiffusionPipeline,
    UNetaDConditionModel,
)
from diffusers.pipelines.stable_diffusion import StableDiffusionPipelineOutput
from diffusers.pipelines.stable_diffusion.safety_checker import StableDiffusionSafetyChecker


__A  =				'''CompVis/stable-diffusion-v1-1'''
__A  =				'''CompVis/stable-diffusion-v1-2'''
__A  =				'''CompVis/stable-diffusion-v1-3'''
__A  =				'''CompVis/stable-diffusion-v1-4'''
class  _snake_case     (					a__		):






						def __init__(       self      :			int							,					UpperCAmelCase      :			AutoencoderKL							,					UpperCAmelCase      :			CLIPTextModel							,					UpperCAmelCase      :			CLIPTokenizer							,					UpperCAmelCase      :			UNetaDConditionModel							,					UpperCAmelCase      :			Union[DDIMScheduler, PNDMScheduler, LMSDiscreteScheduler]							,					UpperCAmelCase      :			StableDiffusionSafetyChecker							,					UpperCAmelCase      :			CLIPImageProcessor							,					UpperCAmelCase      :			bool = True							,					):
													super()._init_()

													__lowerCamelCase					:		Optional[int]		   =     StableDiffusionPipeline.from_pretrained(UpperCAmelCase    )
													__lowerCamelCase					:		Optional[int]		   =     StableDiffusionPipeline.from_pretrained(UpperCAmelCase    )
													__lowerCamelCase					:		Tuple		   =     StableDiffusionPipeline.from_pretrained(UpperCAmelCase    )
													__lowerCamelCase					:		List[str]		   =     StableDiffusionPipeline(
													    vae=UpperCAmelCase							,					text_encoder=UpperCAmelCase							,					tokenizer=UpperCAmelCase							,					unet=UpperCAmelCase							,					scheduler=UpperCAmelCase							,					safety_checker=UpperCAmelCase							,					feature_extractor=UpperCAmelCase							,					requires_safety_checker=UpperCAmelCase							,					)

													self.register_modules(pipelinea=self.pipea							,					pipelinea=self.pipea							,					pipelinea=self.pipea							,					pipelinea=self.pipea    )






						@property
						def       lowerCamelCase__     (       self      :			Dict    ):
													return {k: getattr(self							,					UpperCAmelCase    ) for k in self.config.keys() if not k.startswith("_"    )}






						def       lowerCamelCase__     (       self      :			str							,					UpperCAmelCase      :			Optional[Union[str, int]] = "auto"    ):
													if slice_size == "auto":
																				# half the attention head size is usually a good trade-off between
																				# speed and memory
																				__lowerCamelCase					:		Optional[int]		   =     self.unet.config.attention_head_dim // 2
													self.unet.set_attention_slice(UpperCAmelCase    )






						def       lowerCamelCase__     (       self      :			Tuple    ):
													self.enable_attention_slicing(UpperCAmelCase    )






						@torch.no_grad()
						def       lowerCamelCase__     (       self      :			Dict							,					UpperCAmelCase      :			Union[str, List[str]]							,					UpperCAmelCase      :			int = 512							,					UpperCAmelCase      :			int = 512							,					UpperCAmelCase      :			int = 50							,					UpperCAmelCase      :			float = 7.5							,					UpperCAmelCase      :			Optional[Union[str, List[str]]] = None							,					UpperCAmelCase      :			Optional[int] = 1							,					UpperCAmelCase      :			float = 0.0							,					UpperCAmelCase      :			Optional[torch.Generator] = None							,					UpperCAmelCase      :			Optional[torch.FloatTensor] = None							,					UpperCAmelCase      :			Optional[str] = "pil"							,					UpperCAmelCase      :			bool = True							,					UpperCAmelCase      :			Optional[Callable[[int, int, torch.FloatTensor], None]] = None							,					UpperCAmelCase      :			int = 1							,					**UpperCAmelCase      :			Optional[Any]							,					):
													return self.pipea(
													    prompt=UpperCAmelCase							,					height=UpperCAmelCase							,					width=UpperCAmelCase							,					num_inference_steps=UpperCAmelCase							,					guidance_scale=UpperCAmelCase							,					negative_prompt=UpperCAmelCase							,					num_images_per_prompt=UpperCAmelCase							,					eta=UpperCAmelCase							,					generator=UpperCAmelCase							,					latents=UpperCAmelCase							,					output_type=UpperCAmelCase							,					return_dict=UpperCAmelCase							,					callback=UpperCAmelCase							,					callback_steps=UpperCAmelCase							,					**UpperCAmelCase							,					)






						@torch.no_grad()
						def       lowerCamelCase__     (       self      :			Dict							,					UpperCAmelCase      :			Union[str, List[str]]							,					UpperCAmelCase      :			int = 512							,					UpperCAmelCase      :			int = 512							,					UpperCAmelCase      :			int = 50							,					UpperCAmelCase      :			float = 7.5							,					UpperCAmelCase      :			Optional[Union[str, List[str]]] = None							,					UpperCAmelCase      :			Optional[int] = 1							,					UpperCAmelCase      :			float = 0.0							,					UpperCAmelCase      :			Optional[torch.Generator] = None							,					UpperCAmelCase      :			Optional[torch.FloatTensor] = None							,					UpperCAmelCase      :			Optional[str] = "pil"							,					UpperCAmelCase      :			bool = True							,					UpperCAmelCase      :			Optional[Callable[[int, int, torch.FloatTensor], None]] = None							,					UpperCAmelCase      :			int = 1							,					**UpperCAmelCase      :			Union[str, Any]							,					):
													return self.pipea(
													    prompt=UpperCAmelCase							,					height=UpperCAmelCase							,					width=UpperCAmelCase							,					num_inference_steps=UpperCAmelCase							,					guidance_scale=UpperCAmelCase							,					negative_prompt=UpperCAmelCase							,					num_images_per_prompt=UpperCAmelCase							,					eta=UpperCAmelCase							,					generator=UpperCAmelCase							,					latents=UpperCAmelCase							,					output_type=UpperCAmelCase							,					return_dict=UpperCAmelCase							,					callback=UpperCAmelCase							,					callback_steps=UpperCAmelCase							,					**UpperCAmelCase							,					)






						@torch.no_grad()
						def       lowerCamelCase__     (       self      :			Tuple							,					UpperCAmelCase      :			Union[str, List[str]]							,					UpperCAmelCase      :			int = 512							,					UpperCAmelCase      :			int = 512							,					UpperCAmelCase      :			int = 50							,					UpperCAmelCase      :			float = 7.5							,					UpperCAmelCase      :			Optional[Union[str, List[str]]] = None							,					UpperCAmelCase      :			Optional[int] = 1							,					UpperCAmelCase      :			float = 0.0							,					UpperCAmelCase      :			Optional[torch.Generator] = None							,					UpperCAmelCase      :			Optional[torch.FloatTensor] = None							,					UpperCAmelCase      :			Optional[str] = "pil"							,					UpperCAmelCase      :			bool = True							,					UpperCAmelCase      :			Optional[Callable[[int, int, torch.FloatTensor], None]] = None							,					UpperCAmelCase      :			int = 1							,					**UpperCAmelCase      :			Dict							,					):
													return self.pipea(
													    prompt=UpperCAmelCase							,					height=UpperCAmelCase							,					width=UpperCAmelCase							,					num_inference_steps=UpperCAmelCase							,					guidance_scale=UpperCAmelCase							,					negative_prompt=UpperCAmelCase							,					num_images_per_prompt=UpperCAmelCase							,					eta=UpperCAmelCase							,					generator=UpperCAmelCase							,					latents=UpperCAmelCase							,					output_type=UpperCAmelCase							,					return_dict=UpperCAmelCase							,					callback=UpperCAmelCase							,					callback_steps=UpperCAmelCase							,					**UpperCAmelCase							,					)






						@torch.no_grad()
						def       lowerCamelCase__     (       self      :			Optional[Any]							,					UpperCAmelCase      :			Union[str, List[str]]							,					UpperCAmelCase      :			int = 512							,					UpperCAmelCase      :			int = 512							,					UpperCAmelCase      :			int = 50							,					UpperCAmelCase      :			float = 7.5							,					UpperCAmelCase      :			Optional[Union[str, List[str]]] = None							,					UpperCAmelCase      :			Optional[int] = 1							,					UpperCAmelCase      :			float = 0.0							,					UpperCAmelCase      :			Optional[torch.Generator] = None							,					UpperCAmelCase      :			Optional[torch.FloatTensor] = None							,					UpperCAmelCase      :			Optional[str] = "pil"							,					UpperCAmelCase      :			bool = True							,					UpperCAmelCase      :			Optional[Callable[[int, int, torch.FloatTensor], None]] = None							,					UpperCAmelCase      :			int = 1							,					**UpperCAmelCase      :			List[str]							,					):
													return self.pipea(
													    prompt=UpperCAmelCase							,					height=UpperCAmelCase							,					width=UpperCAmelCase							,					num_inference_steps=UpperCAmelCase							,					guidance_scale=UpperCAmelCase							,					negative_prompt=UpperCAmelCase							,					num_images_per_prompt=UpperCAmelCase							,					eta=UpperCAmelCase							,					generator=UpperCAmelCase							,					latents=UpperCAmelCase							,					output_type=UpperCAmelCase							,					return_dict=UpperCAmelCase							,					callback=UpperCAmelCase							,					callback_steps=UpperCAmelCase							,					**UpperCAmelCase							,					)







						@torch.no_grad()
						def       lowerCamelCase__     (       self      :			str							,					UpperCAmelCase      :			Union[str, List[str]]							,					UpperCAmelCase      :			int = 512							,					UpperCAmelCase      :			int = 512							,					UpperCAmelCase      :			int = 50							,					UpperCAmelCase      :			float = 7.5							,					UpperCAmelCase      :			Optional[Union[str, List[str]]] = None							,					UpperCAmelCase      :			Optional[int] = 1							,					UpperCAmelCase      :			float = 0.0							,					UpperCAmelCase      :			Optional[torch.Generator] = None							,					UpperCAmelCase      :			Optional[torch.FloatTensor] = None							,					UpperCAmelCase      :			Optional[str] = "pil"							,					UpperCAmelCase      :			bool = True							,					UpperCAmelCase      :			Optional[Callable[[int, int, torch.FloatTensor], None]] = None							,					UpperCAmelCase      :			int = 1							,					**UpperCAmelCase      :			Tuple							,					):
													__lowerCamelCase					:		Optional[int]		   =     "cuda" if torch.cuda.is_available() else "cpu"
													self.to(UpperCAmelCase    )

													# Checks if the height and width are divisible by 8 or not
													if height % 8 != 0 or width % 8 != 0:
																				raise ValueError(F"""`height` and `width` must be divisible by 8 but are {height} and {width}."""    )

													# Get first result from Stable Diffusion Checkpoint v1.1
													__lowerCamelCase					:		str		   =     self.textaimg_sda_a(
													    prompt=UpperCAmelCase							,					height=UpperCAmelCase							,					width=UpperCAmelCase							,					num_inference_steps=UpperCAmelCase							,					guidance_scale=UpperCAmelCase							,					negative_prompt=UpperCAmelCase							,					num_images_per_prompt=UpperCAmelCase							,					eta=UpperCAmelCase							,					generator=UpperCAmelCase							,					latents=UpperCAmelCase							,					output_type=UpperCAmelCase							,					return_dict=UpperCAmelCase							,					callback=UpperCAmelCase							,					callback_steps=UpperCAmelCase							,					**UpperCAmelCase							,					)

													# Get first result from Stable Diffusion Checkpoint v1.2
													__lowerCamelCase					:		Optional[int]		   =     self.textaimg_sda_a(
													    prompt=UpperCAmelCase							,					height=UpperCAmelCase							,					width=UpperCAmelCase							,					num_inference_steps=UpperCAmelCase							,					guidance_scale=UpperCAmelCase							,					negative_prompt=UpperCAmelCase							,					num_images_per_prompt=UpperCAmelCase							,					eta=UpperCAmelCase							,					generator=UpperCAmelCase							,					latents=UpperCAmelCase							,					output_type=UpperCAmelCase							,					return_dict=UpperCAmelCase							,					callback=UpperCAmelCase							,					callback_steps=UpperCAmelCase							,					**UpperCAmelCase							,					)

													# Get first result from Stable Diffusion Checkpoint v1.3
													__lowerCamelCase					:		Any		   =     self.textaimg_sda_a(
													    prompt=UpperCAmelCase							,					height=UpperCAmelCase							,					width=UpperCAmelCase							,					num_inference_steps=UpperCAmelCase							,					guidance_scale=UpperCAmelCase							,					negative_prompt=UpperCAmelCase							,					num_images_per_prompt=UpperCAmelCase							,					eta=UpperCAmelCase							,					generator=UpperCAmelCase							,					latents=UpperCAmelCase							,					output_type=UpperCAmelCase							,					return_dict=UpperCAmelCase							,					callback=UpperCAmelCase							,					callback_steps=UpperCAmelCase							,					**UpperCAmelCase							,					)

													# Get first result from Stable Diffusion Checkpoint v1.4
													__lowerCamelCase					:		Optional[Any]		   =     self.textaimg_sda_a(
													    prompt=UpperCAmelCase							,					height=UpperCAmelCase							,					width=UpperCAmelCase							,					num_inference_steps=UpperCAmelCase							,					guidance_scale=UpperCAmelCase							,					negative_prompt=UpperCAmelCase							,					num_images_per_prompt=UpperCAmelCase							,					eta=UpperCAmelCase							,					generator=UpperCAmelCase							,					latents=UpperCAmelCase							,					output_type=UpperCAmelCase							,					return_dict=UpperCAmelCase							,					callback=UpperCAmelCase							,					callback_steps=UpperCAmelCase							,					**UpperCAmelCase							,					)

													# Get all result images into a single list and pass it via StableDiffusionPipelineOutput for final result
													return StableDiffusionPipelineOutput([resa[0], resa[0], resa[0], resa[0]]    )