


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


__snake_case            =   "CompVis/stable-diffusion-v1-1"
__snake_case            =   "CompVis/stable-diffusion-v1-2"
__snake_case            =   "CompVis/stable-diffusion-v1-3"
__snake_case            =   "CompVis/stable-diffusion-v1-4"




class    UpperCAmelCase					(       __snake_case    ):




			def __init__(						self							:		List[str]       ,       __magic_name__							:		AutoencoderKL       ,       __magic_name__							:		CLIPTextModel       ,       __magic_name__							:		CLIPTokenizer       ,       __magic_name__							:		UNetaDConditionModel       ,       __magic_name__							:		Union[DDIMScheduler, PNDMScheduler, LMSDiscreteScheduler]       ,       __magic_name__							:		StableDiffusionSafetyChecker       ,       __magic_name__							:		CLIPImageProcessor       ,       __magic_name__							:		bool = True       ,       ):







						"""simple docstring"""







						super()._init_()

						UpperCamelCase         =					StableDiffusionPipeline.from_pretrained(__magic_name__						)
						UpperCamelCase         =					StableDiffusionPipeline.from_pretrained(__magic_name__						)
						UpperCamelCase         =					StableDiffusionPipeline.from_pretrained(__magic_name__						)
						UpperCamelCase         =					StableDiffusionPipeline(
						    vae=__magic_name__       ,       text_encoder=__magic_name__       ,       tokenizer=__magic_name__       ,       unet=__magic_name__       ,       scheduler=__magic_name__       ,       safety_checker=__magic_name__       ,       feature_extractor=__magic_name__       ,       requires_safety_checker=__magic_name__       ,       )

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




			@property
			def   lowerCamelCase_					(						self							:		Dict						):







						"""simple docstring"""







						return {k: getattr(self       ,       __magic_name__						) for k in self.config.keys() if not k.startswith("""_"""						)}




			def   lowerCamelCase_					(						self							:		List[str]       ,       __magic_name__							:		Optional[Union[str, int]] = "auto"						):







						"""simple docstring"""







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




			def   lowerCamelCase_					(						self							:		Tuple						):







						"""simple docstring"""







						self.enable_attention_slicing(__magic_name__						)




			@torch.no_grad()
			def   lowerCamelCase_					(						self							:		Dict       ,       __magic_name__							:		Union[str, List[str]]       ,       __magic_name__							:		int = 5_1_2       ,       __magic_name__							:		int = 5_1_2       ,       __magic_name__							:		int = 5_0       ,       __magic_name__							:		float = 7.5       ,       __magic_name__							:		Optional[Union[str, List[str]]] = None       ,       __magic_name__							:		Optional[int] = 1       ,       __magic_name__							:		float = 0.0       ,       __magic_name__							:		Optional[torch.Generator] = None       ,       __magic_name__							:		Optional[torch.FloatTensor] = None       ,       __magic_name__							:		Optional[str] = "pil"       ,       __magic_name__							:		bool = True       ,       __magic_name__							:		Optional[Callable[[int, int, torch.FloatTensor], None]] = None       ,       __magic_name__							:		int = 1       ,       **__magic_name__							:		Tuple       ,       ):







						"""simple docstring"""







						return self.pipea(
						    prompt=__magic_name__       ,       height=__magic_name__       ,       width=__magic_name__       ,       num_inference_steps=__magic_name__       ,       guidance_scale=__magic_name__       ,       negative_prompt=__magic_name__       ,       num_images_per_prompt=__magic_name__       ,       eta=__magic_name__       ,       generator=__magic_name__       ,       latents=__magic_name__       ,       output_type=__magic_name__       ,       return_dict=__magic_name__       ,       callback=__magic_name__       ,       callback_steps=__magic_name__       ,       **__magic_name__       ,       )




			@torch.no_grad()
			def   lowerCamelCase_					(						self							:		Optional[int]       ,       __magic_name__							:		Union[str, List[str]]       ,       __magic_name__							:		int = 5_1_2       ,       __magic_name__							:		int = 5_1_2       ,       __magic_name__							:		int = 5_0       ,       __magic_name__							:		float = 7.5       ,       __magic_name__							:		Optional[Union[str, List[str]]] = None       ,       __magic_name__							:		Optional[int] = 1       ,       __magic_name__							:		float = 0.0       ,       __magic_name__							:		Optional[torch.Generator] = None       ,       __magic_name__							:		Optional[torch.FloatTensor] = None       ,       __magic_name__							:		Optional[str] = "pil"       ,       __magic_name__							:		bool = True       ,       __magic_name__							:		Optional[Callable[[int, int, torch.FloatTensor], None]] = None       ,       __magic_name__							:		int = 1       ,       **__magic_name__							:		Optional[int]       ,       ):







						"""simple docstring"""







						return self.pipea(
						    prompt=__magic_name__       ,       height=__magic_name__       ,       width=__magic_name__       ,       num_inference_steps=__magic_name__       ,       guidance_scale=__magic_name__       ,       negative_prompt=__magic_name__       ,       num_images_per_prompt=__magic_name__       ,       eta=__magic_name__       ,       generator=__magic_name__       ,       latents=__magic_name__       ,       output_type=__magic_name__       ,       return_dict=__magic_name__       ,       callback=__magic_name__       ,       callback_steps=__magic_name__       ,       **__magic_name__       ,       )




			@torch.no_grad()
			def   lowerCamelCase_					(						self							:		Optional[int]       ,       __magic_name__							:		Union[str, List[str]]       ,       __magic_name__							:		int = 5_1_2       ,       __magic_name__							:		int = 5_1_2       ,       __magic_name__							:		int = 5_0       ,       __magic_name__							:		float = 7.5       ,       __magic_name__							:		Optional[Union[str, List[str]]] = None       ,       __magic_name__							:		Optional[int] = 1       ,       __magic_name__							:		float = 0.0       ,       __magic_name__							:		Optional[torch.Generator] = None       ,       __magic_name__							:		Optional[torch.FloatTensor] = None       ,       __magic_name__							:		Optional[str] = "pil"       ,       __magic_name__							:		bool = True       ,       __magic_name__							:		Optional[Callable[[int, int, torch.FloatTensor], None]] = None       ,       __magic_name__							:		int = 1       ,       **__magic_name__							:		Dict       ,       ):







						"""simple docstring"""







						return self.pipea(
						    prompt=__magic_name__       ,       height=__magic_name__       ,       width=__magic_name__       ,       num_inference_steps=__magic_name__       ,       guidance_scale=__magic_name__       ,       negative_prompt=__magic_name__       ,       num_images_per_prompt=__magic_name__       ,       eta=__magic_name__       ,       generator=__magic_name__       ,       latents=__magic_name__       ,       output_type=__magic_name__       ,       return_dict=__magic_name__       ,       callback=__magic_name__       ,       callback_steps=__magic_name__       ,       **__magic_name__       ,       )




			@torch.no_grad()
			def   lowerCamelCase_					(						self							:		int       ,       __magic_name__							:		Union[str, List[str]]       ,       __magic_name__							:		int = 5_1_2       ,       __magic_name__							:		int = 5_1_2       ,       __magic_name__							:		int = 5_0       ,       __magic_name__							:		float = 7.5       ,       __magic_name__							:		Optional[Union[str, List[str]]] = None       ,       __magic_name__							:		Optional[int] = 1       ,       __magic_name__							:		float = 0.0       ,       __magic_name__							:		Optional[torch.Generator] = None       ,       __magic_name__							:		Optional[torch.FloatTensor] = None       ,       __magic_name__							:		Optional[str] = "pil"       ,       __magic_name__							:		bool = True       ,       __magic_name__							:		Optional[Callable[[int, int, torch.FloatTensor], None]] = None       ,       __magic_name__							:		int = 1       ,       **__magic_name__							:		List[str]       ,       ):







						"""simple docstring"""







						return self.pipea(
						    prompt=__magic_name__       ,       height=__magic_name__       ,       width=__magic_name__       ,       num_inference_steps=__magic_name__       ,       guidance_scale=__magic_name__       ,       negative_prompt=__magic_name__       ,       num_images_per_prompt=__magic_name__       ,       eta=__magic_name__       ,       generator=__magic_name__       ,       latents=__magic_name__       ,       output_type=__magic_name__       ,       return_dict=__magic_name__       ,       callback=__magic_name__       ,       callback_steps=__magic_name__       ,       **__magic_name__       ,       )





			@torch.no_grad()
			def   lowerCamelCase_					(						self							:		Optional[int]       ,       __magic_name__							:		Union[str, List[str]]       ,       __magic_name__							:		int = 5_1_2       ,       __magic_name__							:		int = 5_1_2       ,       __magic_name__							:		int = 5_0       ,       __magic_name__							:		float = 7.5       ,       __magic_name__							:		Optional[Union[str, List[str]]] = None       ,       __magic_name__							:		Optional[int] = 1       ,       __magic_name__							:		float = 0.0       ,       __magic_name__							:		Optional[torch.Generator] = None       ,       __magic_name__							:		Optional[torch.FloatTensor] = None       ,       __magic_name__							:		Optional[str] = "pil"       ,       __magic_name__							:		bool = True       ,       __magic_name__							:		Optional[Callable[[int, int, torch.FloatTensor], None]] = None       ,       __magic_name__							:		int = 1       ,       **__magic_name__							:		Dict       ,       ):







						"""simple docstring"""







						UpperCamelCase         =					"""cuda""" if torch.cuda.is_available() else """cpu"""
						self.to(__magic_name__						)

						# 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
						UpperCamelCase         =					self.textaimg_sda_a(
						    prompt=__magic_name__       ,       height=__magic_name__       ,       width=__magic_name__       ,       num_inference_steps=__magic_name__       ,       guidance_scale=__magic_name__       ,       negative_prompt=__magic_name__       ,       num_images_per_prompt=__magic_name__       ,       eta=__magic_name__       ,       generator=__magic_name__       ,       latents=__magic_name__       ,       output_type=__magic_name__       ,       return_dict=__magic_name__       ,       callback=__magic_name__       ,       callback_steps=__magic_name__       ,       **__magic_name__       ,       )

						# Get first result from Stable Diffusion Checkpoint v1.2
						UpperCamelCase         =					self.textaimg_sda_a(
						    prompt=__magic_name__       ,       height=__magic_name__       ,       width=__magic_name__       ,       num_inference_steps=__magic_name__       ,       guidance_scale=__magic_name__       ,       negative_prompt=__magic_name__       ,       num_images_per_prompt=__magic_name__       ,       eta=__magic_name__       ,       generator=__magic_name__       ,       latents=__magic_name__       ,       output_type=__magic_name__       ,       return_dict=__magic_name__       ,       callback=__magic_name__       ,       callback_steps=__magic_name__       ,       **__magic_name__       ,       )

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

						# Get first result from Stable Diffusion Checkpoint v1.4
						UpperCamelCase         =					self.textaimg_sda_a(
						    prompt=__magic_name__       ,       height=__magic_name__       ,       width=__magic_name__       ,       num_inference_steps=__magic_name__       ,       guidance_scale=__magic_name__       ,       negative_prompt=__magic_name__       ,       num_images_per_prompt=__magic_name__       ,       eta=__magic_name__       ,       generator=__magic_name__       ,       latents=__magic_name__       ,       output_type=__magic_name__       ,       return_dict=__magic_name__       ,       callback=__magic_name__       ,       callback_steps=__magic_name__       ,       **__magic_name__       ,       )

						# 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]]						)








import json
import os
import unittest

from transformers.models.xlm.tokenization_xlm import VOCAB_FILES_NAMES, XLMTokenizer
from transformers.testing_utils import slow

from ...test_tokenization_common import TokenizerTesterMixin




class    UpperCAmelCase					(       __snake_case      , unittest.TestCase    ):
			lowercase						= XLMTokenizer
			lowercase						= False




			def   lowerCamelCase_					(						self							:		Optional[int]						):







						"""simple docstring"""







						super().setUp()

						# Adapted from Sennrich et al. 2015 and https://github.com/rsennrich/subword-nmt
						UpperCamelCase         =					[
						    """l""",
						    """o""",
						    """w""",
						    """e""",
						    """r""",
						    """s""",
						    """t""",
						    """i""",
						    """d""",
						    """n""",
						    """w</w>""",
						    """r</w>""",
						    """t</w>""",
						    """lo""",
						    """low""",
						    """er</w>""",
						    """low</w>""",
						    """lowest</w>""",
						    """newer</w>""",
						    """wider</w>""",
						    """<unk>""",
						]
						UpperCamelCase         =					dict(zip(__magic_name__       ,       range(len(__magic_name__						)						)						)						)
						UpperCamelCase         =					["""l o 123""", """lo w 1456""", """e r</w> 1789""", """"""]

						UpperCamelCase         =					os.path.join(self.tmpdirname       ,       VOCAB_FILES_NAMES["""vocab_file"""]						)
						UpperCamelCase         =					os.path.join(self.tmpdirname       ,       VOCAB_FILES_NAMES["""merges_file"""]						)
						with open(self.vocab_file       ,       """w"""						) as fp:
									fp.write(json.dumps(__magic_name__						)						)
						with open(self.merges_file       ,       """w"""						) as fp:
									fp.write("""\n""".join(__magic_name__						)						)




			def   lowerCamelCase_					(						self							:		Any       ,       __magic_name__							:		List[str]						):







						"""simple docstring"""







						UpperCamelCase         =					"""lower newer"""
						UpperCamelCase         =					"""lower newer"""
						return input_text, output_text




			def   lowerCamelCase_					(						self							:		List[str]						):







						"""simple docstring"""







						UpperCamelCase         =					XLMTokenizer(self.vocab_file       ,       self.merges_file						)

						UpperCamelCase         =					"""lower"""
						UpperCamelCase         =					["""low""", """er</w>"""]
						UpperCamelCase         =					tokenizer.tokenize(__magic_name__						)
						self.assertListEqual(__magic_name__       ,       __magic_name__						)

						UpperCamelCase         =					tokens + ["""<unk>"""]
						UpperCamelCase         =					[1_4, 1_5, 2_0]
						self.assertListEqual(tokenizer.convert_tokens_to_ids(__magic_name__						)       ,       __magic_name__						)





			@slow
			def   lowerCamelCase_					(						self							:		Optional[int]						):







						"""simple docstring"""







						UpperCamelCase         =					XLMTokenizer.from_pretrained("""xlm-mlm-en-2048"""						)

						UpperCamelCase         =					tokenizer.encode("""sequence builders"""       ,       add_special_tokens=__magic_name__						)
						UpperCamelCase         =					tokenizer.encode("""multi-sequence build"""       ,       add_special_tokens=__magic_name__						)

						UpperCamelCase         =					tokenizer.build_inputs_with_special_tokens(__magic_name__						)
						UpperCamelCase         =					tokenizer.build_inputs_with_special_tokens(__magic_name__       ,       __magic_name__						)

						assert encoded_sentence == [0] + text + [1]
						assert encoded_pair == [0] + text + [1] + text_a + [1]




