



import json
import os
from functools import lru_cache
from typing import Dict, List, Optional, Tuple, Union

import regex as re

from ...tokenization_utils import AddedToken, PreTrainedTokenizer
from ...tokenization_utils_base import BatchEncoding, EncodedInput
from ...utils import PaddingStrategy, logging


lowerCamelCase__			= logging.get_logger(__name__)


lowerCamelCase__			= {"""vocab_file""": """vocab.json""", """merges_file""": """merges.txt"""}

# See all LED models at https://huggingface.co/models?filter=LED
lowerCamelCase__			= {
    """vocab_file""": {
        """allenai/led-base-16384""": """https://huggingface.co/allenai/led-base-16384/resolve/main/vocab.json""",
    },
    """merges_file""": {
        """allenai/led-base-16384""": """https://huggingface.co/allenai/led-base-16384/resolve/main/merges.txt""",
    },
    """tokenizer_file""": {
        """allenai/led-base-16384""": """https://huggingface.co/allenai/led-base-16384/resolve/main/tokenizer.json""",
    },
}

lowerCamelCase__			= {
    """allenai/led-base-16384""": 1_6384,
}

@lru_cache()
# Copied from transformers.models.bart.tokenization_bart.bytes_to_unicode
def   lowerCAmelCase__						(							):
				"""simple docstring"""







				__a       =		(
				    list(range(ord("""!"""    )				,     ord("""~"""    ) + 1    )    ) + list(range(ord("""¡"""    )				,     ord("""¬"""    ) + 1    )    ) + list(range(ord("""®"""    )				,     ord("""ÿ"""    ) + 1    )    )
				)
				__a       =		bs[:]
				__a       =		0
				for b in range(2**8    ):
								if b not in bs:
												bs.append(_SCREAMING_SNAKE_CASE    )
												cs.append(2**8 + n    )
												n += 1
				__a       =		[chr(_SCREAMING_SNAKE_CASE    ) for n in cs]
				return dict(zip(_SCREAMING_SNAKE_CASE				,     _SCREAMING_SNAKE_CASE    )    )

def   lowerCAmelCase__						(							_SCREAMING_SNAKE_CASE       :			Union[str, Any]    ):
				"""simple docstring"""







				__a       =		set()
				__a       =		word[0]
				for char in word[1:]:
								pairs.add((prev_char, char)    )
								__a       =		char
				return pairs






class    SCREAMING_SNAKE_CASE			(							lowerCamelCase__					):
							__lowerCamelCase	:	int    =VOCAB_FILES_NAMES
							__lowerCamelCase	:	Any    =PRETRAINED_VOCAB_FILES_MAP
							__lowerCamelCase	:	List[str]    =PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
							__lowerCamelCase	:	List[Any]    =['input_ids', 'attention_mask']





							def __init__(   self		:		Optional[Any]      ,				__lowercase		:		Dict      ,				__lowercase		:		Any      ,				__lowercase		:		Tuple="replace"      ,				__lowercase		:		str="<s>"      ,				__lowercase		:		Optional[Any]="</s>"      ,				__lowercase		:		Dict="</s>"      ,				__lowercase		:		Any="<s>"      ,				__lowercase		:		Optional[Any]="<unk>"      ,				__lowercase		:		List[str]="<pad>"      ,				__lowercase		:		int="<mask>"      ,				__lowercase		:		Optional[Any]=False      ,				**__lowercase		:		Tuple      ,				):

											'''simple docstring'''
											__a       =		AddedToken(__lowercase      ,				lstrip=__lowercase      ,				rstrip=__lowercase	) if isinstance(__lowercase      ,				__lowercase	) else bos_token
											__a       =		AddedToken(__lowercase      ,				lstrip=__lowercase      ,				rstrip=__lowercase	) if isinstance(__lowercase      ,				__lowercase	) else eos_token
											__a       =		AddedToken(__lowercase      ,				lstrip=__lowercase      ,				rstrip=__lowercase	) if isinstance(__lowercase      ,				__lowercase	) else sep_token
											__a       =		AddedToken(__lowercase      ,				lstrip=__lowercase      ,				rstrip=__lowercase	) if isinstance(__lowercase      ,				__lowercase	) else cls_token
											__a       =		AddedToken(__lowercase      ,				lstrip=__lowercase      ,				rstrip=__lowercase	) if isinstance(__lowercase      ,				__lowercase	) else unk_token
											__a       =		AddedToken(__lowercase      ,				lstrip=__lowercase      ,				rstrip=__lowercase	) if isinstance(__lowercase      ,				__lowercase	) else pad_token

											# Mask token behave like a normal word, i.e. include the space before it
											__a       =		AddedToken(__lowercase      ,				lstrip=__lowercase      ,				rstrip=__lowercase	) if isinstance(__lowercase      ,				__lowercase	) else mask_token

											super().__init__(
											    errors=__lowercase      ,				bos_token=__lowercase      ,				eos_token=__lowercase      ,				unk_token=__lowercase      ,				sep_token=__lowercase      ,				cls_token=__lowercase      ,				pad_token=__lowercase      ,				mask_token=__lowercase      ,				add_prefix_space=__lowercase      ,				**__lowercase      ,				)

											with open(__lowercase      ,				encoding="""utf-8"""	) as vocab_handle:
															__a       =		json.load(__lowercase	)
											__a       =		{v: k for k, v in self.encoder.items()}
											__a       =		errors  # how to handle errors in decoding
											__a       =		bytes_to_unicode()
											__a       =		{v: k for k, v in self.byte_encoder.items()}
											with open(__lowercase      ,				encoding="""utf-8"""	) as merges_handle:
															__a       =		merges_handle.read().split("""\n"""	)[1:-1]
											__a       =		[tuple(merge.split()	) for merge in bpe_merges]
											__a       =		dict(zip(__lowercase      ,				range(len(__lowercase	)	)	)	)
											__a       =		{}
											__a       =		add_prefix_space

											# Should have added re.IGNORECASE so BPE merges can happen for capitalized versions of contractions
											__a       =		re.compile(r"""'s|'t|'re|'ve|'m|'ll|'d| ?\p{L}+| ?\p{N}+| ?[^\s\p{L}\p{N}]+|\s+(?!\S)|\s+"""	)





							@property
							# Copied from transformers.models.bart.tokenization_bart.BartTokenizer.vocab_size
							def 						UpperCamelCase_					(   self		:		int	):

											'''simple docstring'''
											return len(self.encoder	)





							def 						UpperCamelCase_					(   self		:		str	):

											'''simple docstring'''
											return dict(self.encoder      ,				**self.added_tokens_encoder	)





							def 						UpperCamelCase_					(   self		:		Union[str, Any]      ,				__lowercase		:		Any	):

											'''simple docstring'''
											if token in self.cache:
															return self.cache[token]
											__a       =		tuple(__lowercase	)
											__a       =		get_pairs(__lowercase	)

											if not pairs:
															return token

											while True:
															__a       =		min(__lowercase      ,				key=lambda __lowercase	: self.bpe_ranks.get(__lowercase      ,				float("""inf"""	)	)	)
															if bigram not in self.bpe_ranks:
																			break
															__a     ,					__a       =		bigram
															__a       =		[]
															__a       =		0
															while i < len(__lowercase	):
																			try:
																							__a       =		word.index(__lowercase      ,				__lowercase	)
																			except ValueError:
																							new_word.extend(word[i:]	)
																							break
																			else:
																							new_word.extend(word[i:j]	)
																							__a       =		j

																			if word[i] == first and i < len(__lowercase	) - 1 and word[i + 1] == second:
																							new_word.append(first + second	)
																							i += 2
																			else:
																							new_word.append(word[i]	)
																							i += 1
															__a       =		tuple(__lowercase	)
															__a       =		new_word
															if len(__lowercase	) == 1:
																			break
															else:
																			__a       =		get_pairs(__lowercase	)
											__a       =		""" """.join(__lowercase	)
											__a       =		word
											return word





							def 						UpperCamelCase_					(   self		:		str      ,				__lowercase		:		List[str]	):

											'''simple docstring'''
											__a       =		[]
											for token in re.findall(self.pat      ,				__lowercase	):
															__a       =		"""""".join(
															    self.byte_encoder[b] for b in token.encode("""utf-8"""	)	)  # Maps all our bytes to unicode strings, avoiding control tokens of the BPE (spaces in our case)
															bpe_tokens.extend(bpe_token for bpe_token in self.bpe(__lowercase	).split(""" """	)	)
											return bpe_tokens





							def 						UpperCamelCase_					(   self		:		Dict      ,				__lowercase		:		Any	):

											'''simple docstring'''
											return self.encoder.get(__lowercase      ,				self.encoder.get(self.unk_token	)	)





							def 						UpperCamelCase_					(   self		:		Tuple      ,				__lowercase		:		int	):

											'''simple docstring'''
											return self.decoder.get(__lowercase	)





							def 						UpperCamelCase_					(   self		:		Any      ,				__lowercase		:		Optional[int]	):

											'''simple docstring'''
											__a       =		"""""".join(__lowercase	)
											__a       =		bytearray([self.byte_decoder[c] for c in text]	).decode("""utf-8"""      ,				errors=self.errors	)
											return text





							def 						UpperCamelCase_					(   self		:		Tuple      ,				__lowercase		:		str      ,				__lowercase		:		Optional[str] = None	):

											'''simple docstring'''
											if not os.path.isdir(__lowercase	):
															logger.error(F"Vocabulary path ({save_directory}) should be a directory"	)
															return
											__a       =		os.path.join(
											    __lowercase      ,				(filename_prefix + """-""" if filename_prefix else """""") + VOCAB_FILES_NAMES["""vocab_file"""]	)
											__a       =		os.path.join(
											    __lowercase      ,				(filename_prefix + """-""" if filename_prefix else """""") + VOCAB_FILES_NAMES["""merges_file"""]	)

											with open(__lowercase      ,				"""w"""      ,				encoding="""utf-8"""	) as f:
															f.write(json.dumps(self.encoder      ,				indent=2      ,				sort_keys=__lowercase      ,				ensure_ascii=__lowercase	) + """\n"""	)

											__a       =		0
											with open(__lowercase      ,				"""w"""      ,				encoding="""utf-8"""	) as writer:
															writer.write("""#version: 0.2\n"""	)
															for bpe_tokens, token_index in sorted(self.bpe_ranks.items()      ,				key=lambda __lowercase	: kv[1]	):
																			if index != token_index:
																							logger.warning(
																							    F"Saving vocabulary to {merge_file}: BPE merge indices are not consecutive."
																							    """ Please check that the tokenizer is not corrupted!"""	)
																							__a       =		token_index
																			writer.write(""" """.join(__lowercase	) + """\n"""	)
																			index += 1

											return vocab_file, merge_file





							def 						UpperCamelCase_					(   self		:		List[str]      ,				__lowercase		:		List[int]      ,				__lowercase		:		Optional[List[int]] = None	):

											'''simple docstring'''
											if token_ids_a is None:
															return [self.cls_token_id] + token_ids_a + [self.sep_token_id]
											__a       =		[self.cls_token_id]
											__a       =		[self.sep_token_id]
											return cls + token_ids_a + sep + sep + token_ids_a + sep





							def 						UpperCamelCase_					(   self		:		Union[str, Any]      ,				__lowercase		:		List[int]      ,				__lowercase		:		Optional[List[int]] = None      ,				__lowercase		:		bool = False	):

											'''simple docstring'''
											if already_has_special_tokens:
															return super().get_special_tokens_mask(
															    token_ids_a=__lowercase      ,				token_ids_a=__lowercase      ,				already_has_special_tokens=__lowercase	)

											if token_ids_a is None:
															return [1] + ([0] * len(__lowercase	)) + [1]
											return [1] + ([0] * len(__lowercase	)) + [1, 1] + ([0] * len(__lowercase	)) + [1]





							def 						UpperCamelCase_					(   self		:		List[str]      ,				__lowercase		:		List[int]      ,				__lowercase		:		Optional[List[int]] = None	):

											'''simple docstring'''
											__a       =		[self.sep_token_id]
											__a       =		[self.cls_token_id]

											if token_ids_a is None:
															return len(cls + token_ids_a + sep	) * [0]
											return len(cls + token_ids_a + sep + sep + token_ids_a + sep	) * [0]





							def 						UpperCamelCase_					(   self		:		Optional[Any]      ,				__lowercase		:		List[Any]      ,				__lowercase		:		Dict=False      ,				**__lowercase		:		Tuple	):

											'''simple docstring'''
											__a       =		kwargs.pop("""add_prefix_space"""      ,				self.add_prefix_space	)
											if (is_split_into_words or add_prefix_space) and (len(__lowercase	) > 0 and not text[0].isspace()):
															__a       =		""" """ + text
											return (text, kwargs)







							def 						UpperCamelCase_					(   self		:		Optional[int]      ,				__lowercase		:		Union[Dict[str, EncodedInput], BatchEncoding]      ,				__lowercase		:		Optional[int] = None      ,				__lowercase		:		PaddingStrategy = PaddingStrategy.DO_NOT_PAD      ,				__lowercase		:		Optional[int] = None      ,				__lowercase		:		Optional[bool] = None      ,				):

											'''simple docstring'''
											__a       =		super()._pad(
											    encoded_inputs=__lowercase      ,				max_length=__lowercase      ,				padding_strategy=__lowercase      ,				pad_to_multiple_of=__lowercase      ,				return_attention_mask=__lowercase      ,				)

											# Load from model defaults
											if return_attention_mask is None:
															__a       =		"""attention_mask""" in self.model_input_names

											if return_attention_mask and "global_attention_mask" in encoded_inputs:
															__a       =		encoded_inputs[self.model_input_names[0]]
															# `global_attention_mask` need to have the same length as other (sequential) inputs.
															__a       =		len(encoded_inputs["""global_attention_mask"""]	) != len(__lowercase	)

															if needs_to_be_padded:
																			__a       =		len(__lowercase	) - len(encoded_inputs["""global_attention_mask"""]	)

																			if self.padding_side == "right":
																							# Use `-1` since `0` in `global_attention_mask` means `local attention` instead of `not to attend`
																							__a       =		(
																							    encoded_inputs["""global_attention_mask"""] + [-1] * difference
																							)
																			elif self.padding_side == "left":
																							__a       =		[-1] * difference + encoded_inputs[
																							    """global_attention_mask"""
																							]
																			else:
																							raise ValueError("""Invalid padding strategy:""" + str(self.padding_side	)	)

											return encoded_inputs





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    SCREAMING_SNAKE_CASE			(							unittest.TestCase					):





							def 						UpperCamelCase_					(   self		:		Optional[Any]	):

											'''simple docstring'''
											# clean up the VRAM after each test
											super().tearDown()
											gc.collect()
											torch.cuda.empty_cache()





							@property
							def 						UpperCamelCase_					(   self		:		Dict	):

											'''simple docstring'''
											__a       =		1
											__a       =		3
											__a       =		(32, 32)

											__a       =		floats_tensor((batch_size, num_channels) + sizes      ,				rng=random.Random(0	)	).to(__lowercase	)
											return image





							@property
							def 						UpperCamelCase_					(   self		:		Tuple	):

											'''simple docstring'''
											torch.manual_seed(0	)
											__a       =		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		:		List[Any]	):

											'''simple docstring'''
											torch.manual_seed(0	)
											__a       =		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		:		int	):

											'''simple docstring'''
											torch.manual_seed(0	)
											__a       =		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      ,				)
											return CLIPTextModel(__lowercase	)





							@property
							def 						UpperCamelCase_					(   self		:		Tuple	):

											'''simple docstring'''
											def extract(*__lowercase		:		Tuple      ,				**__lowercase		:		Dict	):






															class    SCREAMING_SNAKE_CASE			:





																						def __init__(   self		:		List[str]	):

																										'''simple docstring'''
																										__a       =		torch.ones([0]	)







																						def 						UpperCamelCase_					(   self		:		Optional[Any]      ,				__lowercase		:		str	):

																										'''simple docstring'''
																										self.pixel_values.to(__lowercase	)
																										return self



															return Out()

											return extract





							def 						UpperCamelCase_					(   self		:		Dict	):

											'''simple docstring'''
											__a       =		"""cpu"""  # ensure determinism for the device-dependent torch.Generator
											__a       =		self.dummy_cond_unet
											__a       =		DDIMScheduler(
											    beta_start=0.00085      ,				beta_end=0.012      ,				beta_schedule="""scaled_linear"""      ,				clip_sample=__lowercase      ,				set_alpha_to_one=__lowercase      ,				)

											__a       =		self.dummy_vae
											__a       =		self.dummy_text_encoder
											__a       =		CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""	)

											# make sure here that pndm scheduler skips prk
											__a       =		StableDiffusionPipeline(
											    unet=__lowercase      ,				scheduler=__lowercase      ,				vae=__lowercase      ,				text_encoder=__lowercase      ,				tokenizer=__lowercase      ,				safety_checker=__lowercase      ,				feature_extractor=self.dummy_extractor      ,				)
											__a       =		sd_pipe.to(__lowercase	)
											sd_pipe.set_progress_bar_config(disable=__lowercase	)

											__a       =		"""A painting of a squirrel eating a burger"""

											__a       =		torch.Generator(device=__lowercase	).manual_seed(0	)
											__a       =		sd_pipe([prompt]      ,				generator=__lowercase      ,				guidance_scale=6.0      ,				num_inference_steps=2      ,				output_type="""np"""	)
											__a       =		output.images

											__a       =		torch.Generator(device=__lowercase	).manual_seed(0	)
											__a       =		sd_pipe(
											    [prompt]      ,				generator=__lowercase      ,				guidance_scale=6.0      ,				num_inference_steps=2      ,				output_type="""np"""      ,				return_dict=__lowercase      ,				)[0]

											__a       =		image[0, -3:, -3:, -1]
											__a       =		image_from_tuple[0, -3:, -3:, -1]

											assert image.shape == (1, 64, 64, 3)
											__a       =		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		:		Tuple	):

											'''simple docstring'''
											__a       =		"""cpu"""  # ensure determinism for the device-dependent torch.Generator
											__a       =		self.dummy_cond_unet
											__a       =		PNDMScheduler(skip_prk_steps=__lowercase	)
											__a       =		self.dummy_vae
											__a       =		self.dummy_text_encoder
											__a       =		CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""	)

											# make sure here that pndm scheduler skips prk
											__a       =		StableDiffusionPipeline(
											    unet=__lowercase      ,				scheduler=__lowercase      ,				vae=__lowercase      ,				text_encoder=__lowercase      ,				tokenizer=__lowercase      ,				safety_checker=__lowercase      ,				feature_extractor=self.dummy_extractor      ,				)
											__a       =		sd_pipe.to(__lowercase	)
											sd_pipe.set_progress_bar_config(disable=__lowercase	)

											__a       =		"""A painting of a squirrel eating a burger"""
											__a       =		torch.Generator(device=__lowercase	).manual_seed(0	)
											__a       =		sd_pipe([prompt]      ,				generator=__lowercase      ,				guidance_scale=6.0      ,				num_inference_steps=2      ,				output_type="""np"""	)

											__a       =		output.images

											__a       =		torch.Generator(device=__lowercase	).manual_seed(0	)
											__a       =		sd_pipe(
											    [prompt]      ,				generator=__lowercase      ,				guidance_scale=6.0      ,				num_inference_steps=2      ,				output_type="""np"""      ,				return_dict=__lowercase      ,				)[0]

											__a       =		image[0, -3:, -3:, -1]
											__a       =		image_from_tuple[0, -3:, -3:, -1]

											assert image.shape == (1, 64, 64, 3)
											__a       =		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		:		str	):

											'''simple docstring'''
											__a       =		StableDiffusionPipeline.from_pretrained(
											    """hf-internal-testing/tiny-stable-diffusion-lms-pipe"""      ,				safety_checker=__lowercase	)
											assert isinstance(__lowercase      ,				__lowercase	)
											assert isinstance(pipe.scheduler      ,				__lowercase	)
											assert pipe.safety_checker is None

											__a       =		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(__lowercase	)
															__a       =		StableDiffusionPipeline.from_pretrained(__lowercase	)

											# sanity check that the pipeline still works
											assert pipe.safety_checker is None
											__a       =		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		:		Tuple	):

											'''simple docstring'''
											__a       =		self.dummy_cond_unet
											__a       =		PNDMScheduler(skip_prk_steps=__lowercase	)
											__a       =		self.dummy_vae
											__a       =		self.dummy_text_encoder
											__a       =		CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""	)

											# put models in fp16
											__a       =		unet.half()
											__a       =		vae.half()
											__a       =		bert.half()

											# make sure here that pndm scheduler skips prk
											__a       =		StableDiffusionPipeline(
											    unet=__lowercase      ,				scheduler=__lowercase      ,				vae=__lowercase      ,				text_encoder=__lowercase      ,				tokenizer=__lowercase      ,				safety_checker=__lowercase      ,				feature_extractor=self.dummy_extractor      ,				)
											__a       =		sd_pipe.to(__lowercase	)
											sd_pipe.set_progress_bar_config(disable=__lowercase	)

											__a       =		"""A painting of a squirrel eating a burger"""
											__a       =		sd_pipe([prompt]      ,				num_inference_steps=2      ,				output_type="""np"""	).images

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






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





							def 						UpperCamelCase_					(   self		:		str	):

											'''simple docstring'''
											# clean up the VRAM after each test
											super().tearDown()
											gc.collect()
											torch.cuda.empty_cache()





							def 						UpperCamelCase_					(   self		:		int	):

											'''simple docstring'''
											__a       =		StableDiffusionPipeline.from_pretrained("""runwayml/stable-diffusion-v1-5"""      ,				safety_checker=__lowercase	)
											__a       =		LMSDiscreteScheduler.from_config(sd_pipe.scheduler.config	)
											__a       =		sd_pipe.to(__lowercase	)
											sd_pipe.set_progress_bar_config(disable=__lowercase	)

											__a       =		(
											    """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 """
											)
											__a       =		4003660346
											__a       =		7

											# without safety guidance (sld_guidance_scale = 0)
											__a       =		torch.manual_seed(__lowercase	)
											__a       =		sd_pipe(
											    [prompt]      ,				generator=__lowercase      ,				guidance_scale=__lowercase      ,				num_inference_steps=50      ,				output_type="""np"""      ,				width=512      ,				height=512      ,				sld_guidance_scale=0      ,				)

											__a       =		output.images
											__a       =		image[0, -3:, -3:, -1]
											__a       =		[0.2278, 0.2231, 0.2249, 0.2333, 0.2303, 0.1885, 0.2273, 0.2144, 0.2176]

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

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

											# without safety guidance (strong configuration)
											__a       =		torch.manual_seed(__lowercase	)
											__a       =		sd_pipe(
											    [prompt]      ,				generator=__lowercase      ,				guidance_scale=__lowercase      ,				num_inference_steps=50      ,				output_type="""np"""      ,				width=512      ,				height=512      ,				sld_guidance_scale=2000      ,				sld_warmup_steps=7      ,				sld_threshold=0.025      ,				sld_momentum_scale=0.5      ,				sld_mom_beta=0.7      ,				)

											__a       =		output.images
											__a       =		image[0, -3:, -3:, -1]
											__a       =		[0.2383, 0.2276, 0.236, 0.2192, 0.2186, 0.2053, 0.1971, 0.1901, 0.1719]

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

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





							def 						UpperCamelCase_					(   self		:		Optional[Any]	):

											'''simple docstring'''
											__a       =		StableDiffusionPipeline.from_pretrained("""runwayml/stable-diffusion-v1-5"""      ,				safety_checker=__lowercase	)
											__a       =		LMSDiscreteScheduler.from_config(sd_pipe.scheduler.config	)
											__a       =		sd_pipe.to(__lowercase	)
											sd_pipe.set_progress_bar_config(disable=__lowercase	)

											__a       =		"""padme amidala taking a bath artwork, safe for work, no nudity"""
											__a       =		2734971755
											__a       =		7

											__a       =		torch.manual_seed(__lowercase	)
											__a       =		sd_pipe(
											    [prompt]      ,				generator=__lowercase      ,				guidance_scale=__lowercase      ,				num_inference_steps=50      ,				output_type="""np"""      ,				width=512      ,				height=512      ,				sld_guidance_scale=0      ,				)

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

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

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

											__a       =		torch.manual_seed(__lowercase	)
											__a       =		sd_pipe(
											    [prompt]      ,				generator=__lowercase      ,				guidance_scale=__lowercase      ,				num_inference_steps=50      ,				output_type="""np"""      ,				width=512      ,				height=512      ,				sld_guidance_scale=2000      ,				sld_warmup_steps=7      ,				sld_threshold=0.025      ,				sld_momentum_scale=0.5      ,				sld_mom_beta=0.7      ,				)

											__a       =		output.images
											__a       =		image[0, -3:, -3:, -1]
											__a       =		[0.5531, 0.5206, 0.4895, 0.5156, 0.5182, 0.4751, 0.4802, 0.4803, 0.4443]

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

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







							def 						UpperCamelCase_					(   self		:		List[Any]	):

											'''simple docstring'''
											__a       =		StableDiffusionPipeline.from_pretrained("""runwayml/stable-diffusion-v1-5"""	)
											__a       =		sd_pipe.to(__lowercase	)
											sd_pipe.set_progress_bar_config(disable=__lowercase	)

											__a       =		(
											    """the four horsewomen of the apocalypse, painting by tom of finland, gaston bussiere, craig mullins, j. c."""
											    """ leyendecker"""
											)
											__a       =		1044355234
											__a       =		12

											__a       =		torch.manual_seed(__lowercase	)
											__a       =		sd_pipe(
											    [prompt]      ,				generator=__lowercase      ,				guidance_scale=__lowercase      ,				num_inference_steps=50      ,				output_type="""np"""      ,				width=512      ,				height=512      ,				sld_guidance_scale=0      ,				)

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

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

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

											__a       =		torch.manual_seed(__lowercase	)
											__a       =		sd_pipe(
											    [prompt]      ,				generator=__lowercase      ,				guidance_scale=__lowercase      ,				num_inference_steps=50      ,				output_type="""np"""      ,				width=512      ,				height=512      ,				sld_guidance_scale=2000      ,				sld_warmup_steps=7      ,				sld_threshold=0.025      ,				sld_momentum_scale=0.5      ,				sld_mom_beta=0.7      ,				)

											__a       =		output.images
											__a       =		image[0, -3:, -3:, -1]
											__a       =		np.array([0.5818, 0.6285, 0.6835, 0.6019, 0.625, 0.6754, 0.6096, 0.6334, 0.6561]	)
											assert image.shape == (1, 512, 512, 3)

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