



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



	def 					__A				(  self						):
							# clean up the VRAM after each test
							super().tearDown()
							gc.collect()
							torch.cuda.empty_cache()



	@property
	def 					__A				(  self						):
							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 					__A				(  self						):
							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 					__A				(  self						):
							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 					__A				(  self						):
							torch.manual_seed(0						)
							A__					=  CLIPTextConfig(
							    bos_token_id=0					,			eos_token_id=2					,			hidden_size=32					,			intermediate_size=37					,			layer_norm_eps=1e-0_5					,			num_attention_heads=4					,			num_hidden_layers=5					,			pad_token_id=1					,			vocab_size=1_000					,			)
							return CLIPTextModel(__lowercase						)



	@property
	def 					__A				(  self						):
							def extract(*UpperCAmelCase__					,			**UpperCAmelCase__						):






													class       UpperCamelCase							:



														def __init__(  self						):
																				A__					=  torch.ones([0]						)



														def 					__A				(  self					,			UpperCAmelCase__						):
																				self.pixel_values.to(__lowercase						)
																				return self





													return Out()

							return extract



	def 					__A				(  self						):
							A__					=  '''cpu'''  # ensure determinism for the device-dependent torch.Generator
							A__					=  self.dummy_cond_unet
							A__					=  DDIMScheduler(
							    beta_start=0.00_085					,			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.5_756, 0.6_118, 0.5_005, 0.5_041, 0.5_471, 0.4_726, 0.4_976, 0.4_865, 0.4_864]						)

							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 					__A				(  self						):
							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.5_125, 0.5_716, 0.4_828, 0.5_060, 0.5_650, 0.4_768, 0.5_185, 0.4_895, 0.4_993]						)

							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 					__A				(  self						):
							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 					__A				(  self						):
							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       UpperCamelCase							(		unittest.TestCase      ):



	def 					__A				(  self						):
							# clean up the VRAM after each test
							super().tearDown()
							gc.collect()
							torch.cuda.empty_cache()



	def 					__A				(  self						):
							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__					=  4_003_660_346
							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.2_278, 0.2_231, 0.2_249, 0.2_333, 0.2_303, 0.1_885, 0.2_273, 0.2_144, 0.2_176]

							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=2_000					,			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.2_383, 0.2_276, 0.236, 0.2_192, 0.2_186, 0.2_053, 0.1_971, 0.1_901, 0.1_719]

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

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



	def 					__A				(  self						):
							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__					=  2_734_971_755
							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.3_502, 0.3_622, 0.3_396, 0.3_642, 0.3_478, 0.3_318, 0.35, 0.3_348, 0.3_297]

							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=2_000					,			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.5_531, 0.5_206, 0.4_895, 0.5_156, 0.5_182, 0.4_751, 0.4_802, 0.4_803, 0.4_443]

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

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



	def 					__A				(  self						):
							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__					=  1_044_355_234
							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=2_000					,			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.5_818, 0.6_285, 0.6_835, 0.6_019, 0.625, 0.6_754, 0.6_096, 0.6_334, 0.6_561]						)
							assert image.shape == (1, 512, 512, 3)

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












"""simple docstring"""





import contextlib
import importlib
import io
import unittest

import transformers

# Try to import everything from transformers to ensure every object can be loaded.
from transformers import *  # noqa F406
from transformers.testing_utils import DUMMY_UNKNOWN_IDENTIFIER, require_flax, require_tf, require_torch
from transformers.utils import ContextManagers, find_labels, is_flax_available, is_tf_available, is_torch_available


if is_torch_available():
							from transformers import BertForPreTraining, BertForQuestionAnswering, BertForSequenceClassification

if is_tf_available():
							from transformers import TFBertForPreTraining, TFBertForQuestionAnswering, TFBertForSequenceClassification

if is_flax_available():
							from transformers import FlaxBertForPreTraining, FlaxBertForQuestionAnswering, FlaxBertForSequenceClassification


_UpperCamelCase					      =   DUMMY_UNKNOWN_IDENTIFIER
# An actual model hosted on huggingface.co

_UpperCamelCase					      =   'main'
# Default branch name
_UpperCamelCase					      =   'f2c752cfc5c0ab6f4bdec59acea69eefbee381c2'
# One particular commit (not the top of `main`)
_UpperCamelCase					      =   'aaaaaaa'
# This commit does not exist, so we should 404.

_UpperCamelCase					      =   'd9e9f15bc825e4b2c9249e9578f884bbcb5e3684'
# Sha-1 of config.json on the top of `main`, for checking purposes
_UpperCamelCase					      =   '4b243c475af8d0a7754e87d7d096c92e5199ec2fe168a2ee7998e3b8e9bcb1d3'



@contextlib.contextmanager
def 					lowerCAmelCase_      (   ):


							'''simple docstring'''







							print('''Welcome!''' )
							yield
							print('''Bye!''' )



@contextlib.contextmanager
def 					lowerCAmelCase_      (   ):


							'''simple docstring'''







							print('''Bonjour!''' )
							yield
							print('''Au revoir!''' )
class 		SCREAMING_SNAKE_CASE_				(     unittest.TestCase ):
				"""simple docstring"""




				def        __lowercase	(  self	:str      ):
											# If the spec is missing, importlib would not be able to import the module dynamically.
											assert transformers.__spec__ is not None
											assert importlib.util.find_spec('''transformers'''      ) is not None

class 		SCREAMING_SNAKE_CASE_				(     unittest.TestCase ):
				"""simple docstring"""




				@unittest.mock.patch('''sys.stdout'''    ,     new_callable=io.StringIO      )
				def        __lowercase	(  self	:str    ,     __lowercase	:str      ):
											with ContextManagers([]      ):
																		print('''Transformers are awesome!'''      )
											# The print statement adds a new line at the end of the output
											self.assertEqual(mock_stdout.getvalue()    ,     '''Transformers are awesome!\n'''      )




				@unittest.mock.patch('''sys.stdout'''    ,     new_callable=io.StringIO      )
				def        __lowercase	(  self	:Any    ,     __lowercase	:Tuple      ):
											with ContextManagers([context_en()]      ):
																		print('''Transformers are awesome!'''      )
											# The output should be wrapped with an English welcome and goodbye
											self.assertEqual(mock_stdout.getvalue()    ,     '''Welcome!\nTransformers are awesome!\nBye!\n'''      )




				@unittest.mock.patch('''sys.stdout'''    ,     new_callable=io.StringIO      )
				def        __lowercase	(  self	:List[Any]    ,     __lowercase	:Optional[Any]      ):
											with ContextManagers([context_fr(), context_en()]      ):
																		print('''Transformers are awesome!'''      )
											# The output should be wrapped with an English and French welcome and goodbye
											self.assertEqual(mock_stdout.getvalue()    ,     '''Bonjour!\nWelcome!\nTransformers are awesome!\nBye!\nAu revoir!\n'''      )




				@require_torch
				def        __lowercase	(  self	:Tuple      ):
											self.assertEqual(find_labels(__lowercase      )    ,     ['''labels''']      )
											self.assertEqual(find_labels(__lowercase      )    ,     ['''labels''', '''next_sentence_label''']      )
											self.assertEqual(find_labels(__lowercase      )    ,     ['''start_positions''', '''end_positions''']      )
											class 		SCREAMING_SNAKE_CASE_				(     snake_case__ ):
															"""simple docstring"""
															pass

											self.assertEqual(find_labels(__lowercase      )    ,     ['''labels''']      )




				@require_tf
				def        __lowercase	(  self	:str      ):
											self.assertEqual(find_labels(__lowercase      )    ,     ['''labels''']      )
											self.assertEqual(find_labels(__lowercase      )    ,     ['''labels''', '''next_sentence_label''']      )
											self.assertEqual(find_labels(__lowercase      )    ,     ['''start_positions''', '''end_positions''']      )
											class 		SCREAMING_SNAKE_CASE_				(     snake_case__ ):
															"""simple docstring"""
															pass

											self.assertEqual(find_labels(__lowercase      )    ,     ['''labels''']      )




				@require_flax
				def        __lowercase	(  self	:str      ):
											# Flax models don't have labels
											self.assertEqual(find_labels(__lowercase      )    ,     []      )
											self.assertEqual(find_labels(__lowercase      )    ,     []      )
											self.assertEqual(find_labels(__lowercase      )    ,     []      )
											class 		SCREAMING_SNAKE_CASE_				(     snake_case__ ):
															"""simple docstring"""
															pass

											self.assertEqual(find_labels(__lowercase      )    ,     []      )




