



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


lowerCAmelCase__		:					Dict							='''CompVis/stable-diffusion-v1-1'''
lowerCAmelCase__		:					Optional[int]							='''CompVis/stable-diffusion-v1-2'''
lowerCAmelCase__		:					Tuple							='''CompVis/stable-diffusion-v1-3'''
lowerCAmelCase__		:					List[str]							='''CompVis/stable-diffusion-v1-4'''

class        UpperCAmelCase_  (       UpperCamelCase_	):

						'''simple docstring'''




						def __init__(   self				,							_A				,							_A				,							_A				,							_A				,							_A				,							_A				,							_A				,							_A = True				,							):







													'''simple docstring'''

													super()._init_()

													__SCREAMING_SNAKE_CASE									= StableDiffusionPipeline.from_pretrained(_A		)
													__SCREAMING_SNAKE_CASE									= StableDiffusionPipeline.from_pretrained(_A		)
													__SCREAMING_SNAKE_CASE									= StableDiffusionPipeline.from_pretrained(_A		)
													__SCREAMING_SNAKE_CASE									= StableDiffusionPipeline(
													    vae=_A				,							text_encoder=_A				,							tokenizer=_A				,							unet=_A				,							scheduler=_A				,							safety_checker=_A				,							feature_extractor=_A				,							requires_safety_checker=_A				,							)

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






						@property
						def 	_A     (   self		):







													'''simple docstring'''

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






						def 	_A     (   self				,							_A = "auto"		):







													'''simple docstring'''

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






						def 	_A     (   self		):







													'''simple docstring'''

													self.enable_attention_slicing(_A		)






						@torch.no_grad()
						def 	_A     (   self				,							_A				,							_A = 512				,							_A = 512				,							_A = 50				,							_A = 7.5				,							_A = None				,							_A = 1				,							_A = 0.0				,							_A = None				,							_A = None				,							_A = "pil"				,							_A = True				,							_A = None				,							_A = 1				,							**_A				,							):







													'''simple docstring'''

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






						@torch.no_grad()
						def 	_A     (   self				,							_A				,							_A = 512				,							_A = 512				,							_A = 50				,							_A = 7.5				,							_A = None				,							_A = 1				,							_A = 0.0				,							_A = None				,							_A = None				,							_A = "pil"				,							_A = True				,							_A = None				,							_A = 1				,							**_A				,							):







													'''simple docstring'''

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






						@torch.no_grad()
						def 	_A     (   self				,							_A				,							_A = 512				,							_A = 512				,							_A = 50				,							_A = 7.5				,							_A = None				,							_A = 1				,							_A = 0.0				,							_A = None				,							_A = None				,							_A = "pil"				,							_A = True				,							_A = None				,							_A = 1				,							**_A				,							):







													'''simple docstring'''

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






						@torch.no_grad()
						def 	_A     (   self				,							_A				,							_A = 512				,							_A = 512				,							_A = 50				,							_A = 7.5				,							_A = None				,							_A = 1				,							_A = 0.0				,							_A = None				,							_A = None				,							_A = "pil"				,							_A = True				,							_A = None				,							_A = 1				,							**_A				,							):







													'''simple docstring'''

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






						@torch.no_grad()
						def 	_A     (   self				,							_A				,							_A = 512				,							_A = 512				,							_A = 50				,							_A = 7.5				,							_A = None				,							_A = 1				,							_A = 0.0				,							_A = None				,							_A = None				,							_A = "pil"				,							_A = True				,							_A = None				,							_A = 1				,							**_A				,							):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE									= 'cuda' if torch.cuda.is_available() else 'cpu'
													self.to(_A		)

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

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

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

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

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











from dataclasses import dataclass, field
from typing import Optional

from transformers import AutoConfig, AutoImageProcessor, AutoTokenizer, FlaxVisionEncoderDecoderModel, HfArgumentParser

@dataclass
class        UpperCAmelCase_  :

						'''simple docstring'''




						UpperCamelCase__      :			str      =  field(
						    metadata={'''help''': '''The output directory where the model will be written.'''}   ,   )
						UpperCamelCase__      :			str      =  field(
						    metadata={
						        '''help''': (
						            '''The encoder model checkpoint for weights initialization.'''
						            '''Don\'t set if you want to train an encoder model from scratch.'''
						        )
						    }   ,   )
						UpperCamelCase__      :			str      =  field(
						    metadata={
						        '''help''': (
						            '''The decoder model checkpoint for weights initialization.'''
						            '''Don\'t set if you want to train a decoder model from scratch.'''
						        )
						    }   ,   )
						UpperCamelCase__      :			Optional[str]      =  field(
						    default=UpperCamelCase_   ,   metadata={'''help''': '''Pretrained encoder config name or path if not the same as encoder_model_name'''}	)
						UpperCamelCase__      :			Optional[str]      =  field(
						    default=UpperCamelCase_   ,   metadata={'''help''': '''Pretrained decoder config name or path if not the same as decoder_model_name'''}	)







def      __lowercase       (			)    ->			Union[str, Any]:
							__SCREAMING_SNAKE_CASE									= HfArgumentParser((ModelArguments,)       )
							((__SCREAMING_SNAKE_CASE)							,	)									= parser.parse_args_into_dataclasses()

							# Load pretrained model and tokenizer

							# Use explicit specified encoder config
							if model_args.encoder_config_name:
														__SCREAMING_SNAKE_CASE									= AutoConfig.from_pretrained(model_args.encoder_config_name       )
							# Use pretrained encoder model's config
							else:
														__SCREAMING_SNAKE_CASE									= AutoConfig.from_pretrained(model_args.encoder_model_name_or_path       )

							# Use explicit specified decoder config
							if model_args.decoder_config_name:
														__SCREAMING_SNAKE_CASE									= AutoConfig.from_pretrained(model_args.decoder_config_name       )
							# Use pretrained decoder model's config
							else:
														__SCREAMING_SNAKE_CASE									= AutoConfig.from_pretrained(model_args.decoder_model_name_or_path       )

							# necessary for `from_encoder_decoder_pretrained` when `decoder_config` is passed
							__SCREAMING_SNAKE_CASE									= True
							__SCREAMING_SNAKE_CASE									= True

							__SCREAMING_SNAKE_CASE									= FlaxVisionEncoderDecoderModel.from_encoder_decoder_pretrained(
							    encoder_pretrained_model_name_or_path=model_args.encoder_model_name_or_path							,       decoder_pretrained_model_name_or_path=model_args.decoder_model_name_or_path							,       encoder_config=a__							,       decoder_config=a__							,       )

							# GPT2 only has bos/eos tokens but not decoder_start/pad tokens
							__SCREAMING_SNAKE_CASE									= decoder_config.decoder_start_token_id
							__SCREAMING_SNAKE_CASE									= decoder_config.pad_token_id
							if decoder_start_token_id is None:
														__SCREAMING_SNAKE_CASE									= decoder_config.bos_token_id
							if pad_token_id is None:
														__SCREAMING_SNAKE_CASE									= decoder_config.eos_token_id

							# This is necessary to make Flax's generate() work
							__SCREAMING_SNAKE_CASE									= decoder_config.eos_token_id
							__SCREAMING_SNAKE_CASE									= decoder_start_token_id
							__SCREAMING_SNAKE_CASE									= pad_token_id

							__SCREAMING_SNAKE_CASE									= AutoImageProcessor.from_pretrained(model_args.encoder_model_name_or_path       )

							__SCREAMING_SNAKE_CASE									= AutoTokenizer.from_pretrained(model_args.decoder_model_name_or_path       )
							__SCREAMING_SNAKE_CASE									= tokenizer.convert_ids_to_tokens(model.config.pad_token_id       )

							model.save_pretrained(model_args.output_dir       )
							image_processor.save_pretrained(model_args.output_dir       )
							tokenizer.save_pretrained(model_args.output_dir       )


if __name__ == "__main__":
			main()






