
import collections
import json
import os
import re
from typing import TYPE_CHECKING, List, Optional, Tuple

import numpy as np

from ...tokenization_utils_fast import PreTrainedTokenizer
from ...utils import logging


if TYPE_CHECKING:
							from transformers.pipelines.conversational import Conversation


lowercase__		:List[str]   =    logging.get_logger(__name__)

lowercase__		:int   =    {"vocab_file": "vocab.txt", "emoji_file": "emoji.json"}

lowercase__		:str   =    {
    "vocab_file": {
        "abeja/gpt-neox-japanese-2.7b": "https://huggingface.co/abeja/gpt-neox-japanese-2.7b/resolve/main/vocab.txt",
    },
    "emoji_file": {
        "abeja/gpt-neox-japanese-2.7b": "https://huggingface.co/abeja/gpt-neox-japanese-2.7b/resolve/main/emoji.json",
    },
}

lowercase__		:Any   =    {
    "abeja/gpt-neox-japanese-2.7b": 2048,
}



def        UpperCamelCase    (							lowerCAmelCase__ ,			lowerCAmelCase__		):
					'''simple docstring'''
					with open(lowerCAmelCase__ ,			'''r''' ,			encoding='''utf-8'''		) as f:
										lowercase							=						json.loads(f.read()		)

					lowercase							=						collections.OrderedDict()
					lowercase							=						collections.OrderedDict()
					lowercase							=						collections.OrderedDict()
					with open(lowerCAmelCase__ ,			'''r''' ,			encoding='''utf-8'''		) as f:
										lowercase							=						f.readlines()
					lowercase							=						[[t.rstrip('''\n'''		)] if (t == ''',''' or ''',''' not in t) else t.rstrip('''\n'''		).split(''','''		) for t in token]
					for idx, b in enumerate(lowerCAmelCase__		):
										lowercase							=						b
										lowercase							=						idx
										for wd in b:
															lowercase							=						idx

					return vocab, raw_vocab, ids_to_tokens, emoji







class 				lowercase		(					SCREAMING_SNAKE_CASE__		):
							lowercase_       :       List[Any]       					=VOCAB_FILES_NAMES
							lowercase_       :       Any       					=PRETRAINED_VOCAB_FILES_MAP
							lowercase_       :       str       					=PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
							lowercase_       :       Union[str, Any]       					=['''input_ids''', '''attention_mask''']




							def __init__(				self   ,A__   ,A__   ,A__="<|endoftext|>"   ,A__="<|endoftext|>"   ,A__="<|startoftext|>"   ,A__="<|endoftext|>"   ,A__=False   ,**A__   ,):
												super().__init__(
												    unk_token=A__   ,pad_token=A__   ,bos_token=A__   ,eos_token=A__   ,do_clean_text=A__   ,**A__   ,)
												if not os.path.isfile(A__):
																	raise ValueError(
																	    f'Can\'t find a vocabulary file at path \'{vocab_file}\'. To load the vocabulary from a Google pretrained'
																	    ''' model use `tokenizer = GPTNeoXJapaneseokenizer.from_pretrained(PRETRAINED_MODEL_NAME)`''')
												if not os.path.isfile(A__):
																	raise ValueError(
																	    f'Can\'t find a emoji file at path \'{emoji_file}\'. To load the emoji information from a Google'
																	    ''' pretrained model use `tokenizer = GPTNeoXJapaneseokenizer.from_pretrained(PRETRAINED_MODEL_NAME)`''')
												lowercase							=						do_clean_text
												lowercase	,						lowercase	,						lowercase	,						lowercase							=						load_vocab_and_emoji(A__   ,A__)
												lowercase							=						SubWordJapaneseTokenizer(
												    vocab=self.vocab   ,ids_to_tokens=self.ids_to_tokens   ,emoji=self.emoji)




							@property
							def  A__      (				self):
												# self.vocab contains support for character fluctuation unique to Japanese, and has a large number of vocab
												return len(self.raw_vocab)




							def  A__      (				self):
												return dict(self.raw_vocab   ,**self.added_tokens_encoder)




							def  A__      (				self   ,A__):
												return self.subword_tokenizer.tokenize(A__   ,clean=self.do_clean_text)




							def  A__      (				self   ,A__):
												return self.vocab.get(A__   ,self.vocab.get(self.unk_token))




							def  A__      (				self   ,A__):
												return self.subword_tokenizer.convert_id_to_token(A__)




							def  A__      (				self   ,A__):
												lowercase							=						''''''.join(A__).strip()
												return out_string




							def  A__      (				self   ,A__):
												lowercase							=						[]
												for is_user, text in conversation.iter_texts():
																	input_ids.extend(self.encode(A__   ,add_special_tokens=A__) + [self.eos_token_id])

												if len(A__) > self.model_max_length:
																	lowercase							=						input_ids[-self.model_max_length :]
												return input_ids





							def  A__      (				self   ,A__   ,A__ = None):
												lowercase							=						0
												if os.path.isdir(A__):
																	lowercase							=						os.path.join(
																	    A__   ,(filename_prefix + '''-''' if filename_prefix else '''''') + VOCAB_FILES_NAMES['''vocab_file'''])
																	lowercase							=						os.path.join(
																	    A__   ,(filename_prefix + '''-''' if filename_prefix else '''''') + VOCAB_FILES_NAMES['''emoji_file'''])
												else:
																	lowercase							=						(
																	    (filename_prefix + '''-''' if filename_prefix else '''''') + save_directory + VOCAB_FILES_NAMES['''vocab_file''']
																	)
																	lowercase							=						(
																	    (filename_prefix + '''-''' if filename_prefix else '''''') + save_directory + VOCAB_FILES_NAMES['''emoji_file''']
																	)
												with open(A__   ,'''w'''   ,encoding='''utf-8''') as writer:
																	for token_index, token in self.ids_to_tokens.items():
																						if index != token_index:
																											logger.warning(
																											    f'Saving vocabulary to {vocab_file}: vocabulary indices are not consecutive.'
																											    ''' Please check that the vocabulary is not corrupted!''')
																											lowercase							=						token_index
																						writer.write(''','''.join(A__) + '''\n''')
																						index += 1
												with open(A__   ,'''w'''   ,encoding='''utf-8''') as writer:
																	json.dump(self.emoji   ,A__)
												return vocab_file, emoji_file







class 				lowercase		(					SCREAMING_SNAKE_CASE__		):




							def __init__(				self   ,A__   ,A__   ,A__):
												lowercase							=						vocab  # same as swe
												lowercase							=						ids_to_tokens  # same as bpe
												lowercase							=						emoji
												lowercase							=						np.max([len(A__) for w in self.vocab.keys()])
												lowercase							=						re.compile(r'''(https?|ftp)(:\/\/[-_\.!~*\'()a-zA-Z0-9;\/?:\@&=\+$,%#]+)''')
												lowercase							=						re.compile(r'''[A-Za-z0-9\._+]*@[\-_0-9A-Za-z]+(\.[A-Za-z]+)*''')
												lowercase							=						re.compile(r'''[\(]{0,1}[0-9]{2,4}[\)\-\(]{0,1}[0-9]{2,4}[\)\-]{0,1}[0-9]{3,4}''')
												lowercase							=						re.compile(
												    r'''([12]\d{3}[/\-年])*(0?[1-9]|1[0-2])[/\-月]((0?[1-9]|[12][0-9]|3[01])日?)*(\d{1,2}|:|\d{1,2}時|\d{1,2}分|\(日\)|\(月\)|\(火\)|\(水\)|\(木\)|\(金\)|\(土\)|㈰|㈪|㈫|㈬|㈭|㈮|㈯)*''')
												lowercase							=						re.compile(
												    r'''(明治|大正|昭和|平成|令和|㍾|㍽|㍼|㍻|\u32ff)\d{1,2}年(0?[1-9]|1[0-2])月(0?[1-9]|[12][0-9]|3[01])日(\d{1,2}|:|\d{1,2}時|\d{1,2}分|\(日\)|\(月\)|\(火\)|\(水\)|\(木\)|\(金\)|\(土\)|㈰|㈪|㈫|㈬|㈭|㈮|㈯)*''')
												lowercase							=						re.compile(
												    r'''((0|[1-9]\d*|[1-9]\d{0,2}(,\d{3})+)*億)*((0|[1-9]\d*|[1-9]\d{0,2}(,\d{3})+)*万)*((0|[1-9]\d*|[1-9]\d{0,2}(,\d{3})+)*千)*(0|[1-9]\d*|[1-9]\d{0,2}(,\d{3})+)*(千円|万円|千万円|円|千ドル|万ドル|千万ドル|ドル|千ユーロ|万ユーロ|千万ユーロ|ユーロ)+(\(税込\)|\(税抜\)|\+tax)*''')
												lowercase							=						'''─━│┃┄┅┆┇┈┉┊┋┌┍┎┏┐┑┒┓└┕┖┗┘┙┚┛├┝┞┟┠┡┢┣┤┥┦┧┨┩┪┫┬┭┮┯┰┱┲┳┴┵┶┷┸┹┺┻┼┽┾┿╀╁╂╃╄╅╆╇╈╉╊╋╌╍╎╏═║╒╓╔╕╖╗╘╙╚╛╜╝╞╟╠╡╢╣╤╥╦╧╨╩╪╫╬╭╮╯╰╱╲╳╴╵╶╷╸╹╺╻╼╽╾╿'''
												lowercase							=						'''▀▁▂▃▄▅▆▇█▉▊▋▌▍▎▏▐░▒▓▔▕▖▗▘▙▚▛▜▝▞▟'''
												lowercase							=						str.maketrans({k: '''<BLOCK>''' for k in keisen + blocks})




							def __len__(				self):
												return len(self.ids_to_tokens)




							def  A__      (				self   ,A__):
												lowercase							=						self.content_repattera.sub('''<URL>'''   ,A__)
												lowercase							=						self.content_repattera.sub('''<EMAIL>'''   ,A__)
												lowercase							=						self.content_repattera.sub('''<TEL>'''   ,A__)
												lowercase							=						self.content_repattera.sub('''<DATE>'''   ,A__)
												lowercase							=						self.content_repattera.sub('''<DATE>'''   ,A__)
												lowercase							=						self.content_repattera.sub('''<PRICE>'''   ,A__)
												lowercase							=						content.translate(self.content_transa)
												while "<BLOCK><BLOCK>" in content:
																	lowercase							=						content.replace('''<BLOCK><BLOCK>'''   ,'''<BLOCK>''')
												return content




							def  A__      (				self   ,A__   ,A__=False):
												lowercase							=						text.replace(''' '''   ,'''<SP>''')
												lowercase							=						text.replace('''　'''   ,'''<SP>''')
												lowercase							=						text.replace('''\r\n'''   ,'''<BR>''')
												lowercase							=						text.replace('''\n'''   ,'''<BR>''')
												lowercase							=						text.replace('''\r'''   ,'''<BR>''')
												lowercase							=						text.replace('''\t'''   ,'''<TAB>''')
												lowercase							=						text.replace('''—'''   ,'''ー''')
												lowercase							=						text.replace('''−'''   ,'''ー''')
												for k, v in self.emoji["emoji"].items():
																	if k in text:
																						lowercase							=						text.replace(A__   ,A__)
												if clean:
																	lowercase							=						self.clean_text(A__)

												def check_simbol(A__):
																	lowercase							=						x.encode()
																	if len(A__) == 1 and len(A__) == 2:
																						lowercase							=						(int(e[0]) << 8) + int(e[1])
																						if (
																						    (c >= 0Xc2_a1 and c <= 0Xc2_bf)
																						    or (c >= 0Xc7_80 and c <= 0Xc7_83)
																						    or (c >= 0Xca_b9 and c <= 0Xcb_bf)
																						    or (c >= 0Xcc_80 and c <= 0Xcd_a2)
																						):
																											return True
																	return False

												def checkuae(A__):
																	lowercase							=						x.encode()
																	if len(A__) == 1 and len(A__) == 3:
																						lowercase							=						(int(e[0]) << 1_6) + (int(e[1]) << 8) + int(e[2])
																						if c >= 0Xe2_80_80 and c <= 0Xe2_b0_7f:
																											return True
																	return False

												lowercase							=						0
												lowercase							=						[]
												while pos < len(A__):
																	lowercase							=						min(len(A__)   ,pos + self.maxlen + 1) if text[pos] == '''<''' else pos + 3
																	lowercase							=						[]  # (token_id, token, pos)
																	for e in range(A__   ,A__   ,-1):
																						lowercase							=						text[pos:e]
																						if wd in self.vocab:
																											if wd[0] == "<" and len(A__) > 2:
																																lowercase							=						[(self.vocab[wd], wd, e)]
																																break
																											else:
																																candidates.append((self.vocab[wd], wd, e))
																	if len(A__) > 0:
																						# the smallest token_id is adopted
																						lowercase	,						lowercase	,						lowercase							=						sorted(A__   ,key=lambda A__: x[0])[0]
																						result.append(A__)
																						lowercase							=						e
																	else:
																						lowercase							=						pos + 1
																						lowercase							=						text[pos:end]
																						if check_simbol(A__):
																											result.append('''<KIGOU>''')
																						elif checkuae(A__):
																											result.append('''<U2000U2BFF>''')
																						else:
																											for i in wd.encode('''utf-8'''):
																																result.append('''<|byte%d|>''' % i)
																						lowercase							=						end
												return result





							def  A__      (				self   ,A__   ,A__="\n"):
												lowercase							=						[]
												lowercase							=						[]
												lowercase							=						self.ids_to_tokens[index][0]
												if word[:6] == "<|byte" and word[-2:] == "|>":
																	byte_tokens.append(int(word[6:-2]))
												else:
																	if len(A__) > 0:
																						words.append(bytearray(A__).decode('''utf-8'''   ,errors='''replace'''))
																						lowercase							=						[]
																	if word[:7] == "<|emoji" and word[-2:] == "|>":
																						words.append(self.emoji['''emoji_inv'''][word])
																	elif word == "<SP>":
																						words.append(''' ''')
																	elif word == "<BR>":
																						words.append(A__)
																	elif word == "<TAB>":
																						words.append('''\t''')
																	elif word == "<BLOCK>":
																						words.append('''▀''')
																	elif word == "<KIGOU>":
																						words.append('''ǀ''')
																	elif word == "<U2000U2BFF>":
																						words.append('''‖''')
																	else:
																						words.append(A__)
												if len(A__) > 0:
																	words.append(bytearray(A__).decode('''utf-8'''   ,errors='''replace'''))
												lowercase							=						''''''.join(A__)
												return text






import inspect
from typing import Callable, List, Optional, Union

import torch
from transformers import CLIPImageProcessor, CLIPTextModel, CLIPTokenizer

from diffusers import DiffusionPipeline
from diffusers.models import AutoencoderKL, UNetaDConditionModel
from diffusers.pipelines.stable_diffusion import StableDiffusionPipelineOutput
from diffusers.pipelines.stable_diffusion.safety_checker import StableDiffusionSafetyChecker
from diffusers.schedulers import DDIMScheduler, LMSDiscreteScheduler, PNDMScheduler
from diffusers.utils import logging


lowercase__		:Optional[int]   =    logging.get_logger(__name__)  # pylint: disable=invalid-name







class 				lowercase		(					SCREAMING_SNAKE_CASE__		):




							def __init__(				self   ,A__   ,A__   ,A__   ,A__   ,A__   ,A__   ,A__   ,):
												super().__init__()
												self.register_modules(
												    vae=A__   ,text_encoder=A__   ,tokenizer=A__   ,unet=A__   ,scheduler=A__   ,safety_checker=A__   ,feature_extractor=A__   ,)




							def  A__      (				self   ,A__ = "auto"):
												if slice_size == "auto":
																	# half the attention head size is usually a good trade-off between
																	# speed and memory
																	lowercase							=						self.unet.config.attention_head_dim // 2
												self.unet.set_attention_slice(A__)




							def  A__      (				self):
												self.enable_attention_slicing(A__)





							@torch.no_grad()
							def __call__(				self   ,A__   ,A__ = 5_1_2   ,A__ = 5_1_2   ,A__ = 5_0   ,A__ = 7.5   ,A__ = None   ,A__ = 1   ,A__ = 0.0   ,A__ = None   ,A__ = None   ,A__ = "pil"   ,A__ = True   ,A__ = None   ,A__ = 1   ,A__ = None   ,**A__   ,):

												if isinstance(A__   ,A__):
																	lowercase							=						1
												elif isinstance(A__   ,A__):
																	lowercase							=						len(A__)
												else:
																	raise ValueError(f'`prompt` has to be of type `str` or `list` but is {type(A__)}')

												if height % 8 != 0 or width % 8 != 0:
																	raise ValueError(f'`height` and `width` have to be divisible by 8 but are {height} and {width}.')

												if (callback_steps is None) or (
												    callback_steps is not None and (not isinstance(A__   ,A__) or callback_steps <= 0)
												):
																	raise ValueError(
																	    f'`callback_steps` has to be a positive integer but is {callback_steps} of type'
																	    f' {type(A__)}.')

												# get prompt text embeddings
												lowercase							=						self.tokenizer(
												    A__   ,padding='''max_length'''   ,max_length=self.tokenizer.model_max_length   ,return_tensors='''pt'''   ,)
												lowercase							=						text_inputs.input_ids

												if text_input_ids.shape[-1] > self.tokenizer.model_max_length:
																	lowercase							=						self.tokenizer.batch_decode(text_input_ids[:, self.tokenizer.model_max_length :])
																	logger.warning(
																	    '''The following part of your input was truncated because CLIP can only handle sequences up to'''
																	    f' {self.tokenizer.model_max_length} tokens: {removed_text}')
																	lowercase							=						text_input_ids[:, : self.tokenizer.model_max_length]

												if text_embeddings is None:
																	lowercase							=						self.text_encoder(text_input_ids.to(self.device))[0]

												# duplicate text embeddings for each generation per prompt, using mps friendly method
												lowercase	,						lowercase	,						lowercase							=						text_embeddings.shape
												lowercase							=						text_embeddings.repeat(1   ,A__   ,1)
												lowercase							=						text_embeddings.view(bs_embed * num_images_per_prompt   ,A__   ,-1)

												# here `guidance_scale` is defined analog to the guidance weight `w` of equation (2)
												# of the Imagen paper: https://arxiv.org/pdf/2205.11487.pdf . `guidance_scale = 1`
												# corresponds to doing no classifier free guidance.
												lowercase							=						guidance_scale > 1.0
												# get unconditional embeddings for classifier free guidance
												if do_classifier_free_guidance:
																	lowercase							=						42
																	if negative_prompt is None:
																						lowercase							=						['''''']
																	elif type(A__) is not type(A__):
																						raise TypeError(
																						    f'`negative_prompt` should be the same type to `prompt`, but got {type(A__)} !='
																						    f' {type(A__)}.')
																	elif isinstance(A__   ,A__):
																						lowercase							=						[negative_prompt]
																	elif batch_size != len(A__):
																						raise ValueError(
																						    f'`negative_prompt`: {negative_prompt} has batch size {len(A__)}, but `prompt`:'
																						    f' {prompt} has batch size {batch_size}. Please make sure that passed `negative_prompt` matches'
																						    ''' the batch size of `prompt`.''')
																	else:
																						lowercase							=						negative_prompt

																	lowercase							=						text_input_ids.shape[-1]
																	lowercase							=						self.tokenizer(
																	    A__   ,padding='''max_length'''   ,max_length=A__   ,truncation=A__   ,return_tensors='''pt'''   ,)
																	lowercase							=						self.text_encoder(uncond_input.input_ids.to(self.device))[0]

																	# duplicate unconditional embeddings for each generation per prompt, using mps friendly method
																	lowercase							=						uncond_embeddings.shape[1]
																	lowercase							=						uncond_embeddings.repeat(A__   ,A__   ,1)
																	lowercase							=						uncond_embeddings.view(batch_size * num_images_per_prompt   ,A__   ,-1)

																	# For classifier free guidance, we need to do two forward passes.
																	# Here we concatenate the unconditional and text embeddings into a single batch
																	# to avoid doing two forward passes
																	lowercase							=						torch.cat([uncond_embeddings, text_embeddings])

												# get the initial random noise unless the user supplied it

												# Unlike in other pipelines, latents need to be generated in the target device
												# for 1-to-1 results reproducibility with the CompVis implementation.
												# However this currently doesn't work in `mps`.
												lowercase							=						(batch_size * num_images_per_prompt, self.unet.config.in_channels, height // 8, width // 8)
												lowercase							=						(batch_size * num_images_per_prompt, self.unet.config.in_channels, 6_4, 6_4)
												lowercase							=						text_embeddings.dtype
												if latents is None:
																	if self.device.type == "mps":
																						# randn does not exist on mps
																						lowercase							=						torch.randn(
																						    A__   ,generator=A__   ,device='''cpu'''   ,dtype=A__).to(self.device)
																						lowercase							=						torch.randn(A__   ,generator=A__   ,device='''cpu'''   ,dtype=A__).to(
																						    self.device)
																	else:
																						lowercase							=						torch.randn(
																						    A__   ,generator=A__   ,device=self.device   ,dtype=A__)
																						lowercase							=						torch.randn(A__   ,generator=A__   ,device=self.device   ,dtype=A__)
												else:
																	if latents_reference.shape != latents_shape:
																						raise ValueError(f'Unexpected latents shape, got {latents.shape}, expected {latents_shape}')
																	lowercase							=						latents_reference.to(self.device)
																	lowercase							=						latents.to(self.device)

												# This is the key part of the pipeline where we
												# try to ensure that the generated images w/ the same seed
												# but different sizes actually result in similar images
												lowercase							=						(latents_shape[3] - latents_shape_reference[3]) // 2
												lowercase							=						(latents_shape[2] - latents_shape_reference[2]) // 2
												lowercase							=						latents_shape_reference[3] if dx >= 0 else latents_shape_reference[3] + 2 * dx
												lowercase							=						latents_shape_reference[2] if dy >= 0 else latents_shape_reference[2] + 2 * dy
												lowercase							=						0 if dx < 0 else dx
												lowercase							=						0 if dy < 0 else dy
												lowercase							=						max(-dx   ,0)
												lowercase							=						max(-dy   ,0)
												# import pdb
												# pdb.set_trace()
												lowercase							=						latents_reference[:, :, dy : dy + h, dx : dx + w]

												# set timesteps
												self.scheduler.set_timesteps(A__)

												# Some schedulers like PNDM have timesteps as arrays
												# It's more optimized to move all timesteps to correct device beforehand
												lowercase							=						self.scheduler.timesteps.to(self.device)

												# scale the initial noise by the standard deviation required by the scheduler
												lowercase							=						latents * self.scheduler.init_noise_sigma

												# prepare extra kwargs for the scheduler step, since not all schedulers have the same signature
												# eta (η) is only used with the DDIMScheduler, it will be ignored for other schedulers.
												# eta corresponds to η in DDIM paper: https://arxiv.org/abs/2010.02502
												# and should be between [0, 1]
												lowercase							=						'''eta''' in set(inspect.signature(self.scheduler.step).parameters.keys())
												lowercase							=						{}
												if accepts_eta:
																	lowercase							=						eta

												for i, t in enumerate(self.progress_bar(A__)):
																	# expand the latents if we are doing classifier free guidance
																	lowercase							=						torch.cat([latents] * 2) if do_classifier_free_guidance else latents
																	lowercase							=						self.scheduler.scale_model_input(A__   ,A__)

																	# predict the noise residual
																	lowercase							=						self.unet(A__   ,A__   ,encoder_hidden_states=A__).sample

																	# perform guidance
																	if do_classifier_free_guidance:
																						lowercase	,						lowercase							=						noise_pred.chunk(2)
																						lowercase							=						noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond)

																	# compute the previous noisy sample x_t -> x_t-1
																	lowercase							=						self.scheduler.step(A__   ,A__   ,A__   ,**A__).prev_sample

																	# call the callback, if provided
																	if callback is not None and i % callback_steps == 0:
																						callback(A__   ,A__   ,A__)

												lowercase							=						1 / 0.18215 * latents
												lowercase							=						self.vae.decode(A__).sample

												lowercase							=						(image / 2 + 0.5).clamp(0   ,1)

												# we always cast to float32 as this does not cause significant overhead and is compatible with bfloat16
												lowercase							=						image.cpu().permute(0   ,2   ,3   ,1).float().numpy()

												if self.safety_checker is not None:
																	lowercase							=						self.feature_extractor(self.numpy_to_pil(A__)   ,return_tensors='''pt''').to(
																	    self.device)
																	lowercase	,						lowercase							=						self.safety_checker(
																	    images=A__   ,clip_input=safety_checker_input.pixel_values.to(text_embeddings.dtype))
												else:
																	lowercase							=						None

												if output_type == "pil":
																	lowercase							=						self.numpy_to_pil(A__)

												if not return_dict:
																	return (image, has_nsfw_concept)

												return StableDiffusionPipelineOutput(images=A__   ,nsfw_content_detected=A__)




