


'''simple docstring'''





import collections
import os
import re
from pathlib import Path


A							:					Union[str, Any]     						=     'src/transformers'


# Matches is_xxx_available()
A							:					Union[str, Any]     						=     re.compile(r'is\_([a-z_]*)_available()')
# Catches a one-line _import_struct = {xxx}
A							:					Optional[Any]     						=     re.compile(r'^_import_structure\s+=\s+\{([^\}]+)\}')
# Catches a line with a key-values pattern: "bla": ["foo", "bar"]
A							:					str     						=     re.compile(r'\s+"\S*":\s+\[([^\]]*)\]')
# Catches a line if not is_foo_available
A							:					Optional[int]     						=     re.compile(r'^\s*if\s+not\s+is\_[a-z_]*\_available\(\)')
# Catches a line _import_struct["bla"].append("foo")
A							:					Tuple     						=     re.compile(r'^\s*_import_structure\["\S*"\]\.append\("(\S*)"\)')
# Catches a line _import_struct["bla"].extend(["foo", "bar"]) or _import_struct["bla"] = ["foo", "bar"]
A							:					int     						=     re.compile(r'^\s*_import_structure\[\S*\](?:\.extend\(|\s*=\s+)\[([^\]]*)\]')
# Catches a line with an object between quotes and a comma:     "MyModel",
A							:					Any     						=     re.compile(r'^\s+"([^"]+)",')
# Catches a line with objects between brackets only:    ["foo", "bar"],
A							:					List[str]     						=     re.compile(r'^\s+\[([^\]]+)\]')
# Catches a line with from foo import bar, bla, boo
A							:					List[str]     						=     re.compile(r'\s+from\s+\S*\s+import\s+([^\(\s].*)\n')
# Catches a line with try:
A							:					Optional[Any]     						=     re.compile(r'^\s*try:')
# Catches a line with else:
A							:					List[str]     						=     re.compile(r'^\s*else:')





def 	_lowerCAmelCase       (    _lowerCAmelCase )						->	List[str]:


						'''simple docstring'''






						if _re_test_backend.search(_lowerCAmelCase ) is None:
												return None
						__snake_case				=		[b[0] for b in _re_backend.findall(_lowerCAmelCase )]
						backends.sort()
						return "_and_".join(_lowerCAmelCase )





def 	_lowerCAmelCase       (    _lowerCAmelCase )						->	str:


						'''simple docstring'''






						with open(_lowerCAmelCase      ,	"r"      ,	encoding="utf-8"      ,	newline="\n" ) as f:
												__snake_case				=		f.readlines()

						__snake_case				=		0
						while line_index < len(_lowerCAmelCase ) and not lines[line_index].startswith("_import_structure = {" ):
												line_index += 1

						# If this is a traditional init, just return.
						if line_index >= len(_lowerCAmelCase ):
												return None

						# First grab the objects without a specific backend in _import_structure
						__snake_case				=		[]
						while not lines[line_index].startswith("if TYPE_CHECKING" ) and find_backend(lines[line_index] ) is None:
												__snake_case				=		lines[line_index]
												# If we have everything on a single line, let's deal with it.
												if _re_one_line_import_struct.search(_lowerCAmelCase ):
																		__snake_case				=		_re_one_line_import_struct.search(_lowerCAmelCase ).groups()[0]
																		__snake_case				=		re.findall(r"\[([^\]]+)\]"      ,	_lowerCAmelCase )
																		for imp in imports:
																								objects.extend([obj[1:-1] for obj in imp.split(", " )] )
																		line_index += 1
																		continue
												__snake_case				=		_re_import_struct_key_value.search(_lowerCAmelCase )
												if single_line_import_search is not None:
																		__snake_case				=		[obj[1:-1] for obj in single_line_import_search.groups()[0].split(", " ) if len(_lowerCAmelCase ) > 0]
																		objects.extend(_lowerCAmelCase )
												elif line.startswith(" " * 8 + "\"" ):
																		objects.append(line[9:-3] )
												line_index += 1

						__snake_case				=		{'''none''': objects}
						# Let's continue with backend-specific objects in _import_structure
						while not lines[line_index].startswith("if TYPE_CHECKING" ):
												# If the line is an if not is_backend_available, we grab all objects associated.
												__snake_case				=		find_backend(lines[line_index] )
												# Check if the backend declaration is inside a try block:
												if _re_try.search(lines[line_index - 1] ) is None:
																		__snake_case				=		None

												if backend is not None:
																		line_index += 1

																		# Scroll until we hit the else block of try-except-else
																		while _re_else.search(lines[line_index] ) is None:
																								line_index += 1

																		line_index += 1

																		__snake_case				=		[]
																		# Until we unindent, add backend objects to the list
																		while len(lines[line_index] ) <= 1 or lines[line_index].startswith(" " * 4 ):
																								__snake_case				=		lines[line_index]
																								if _re_import_struct_add_one.search(_lowerCAmelCase ) is not None:
																														objects.append(_re_import_struct_add_one.search(_lowerCAmelCase ).groups()[0] )
																								elif _re_import_struct_add_many.search(_lowerCAmelCase ) is not None:
																														__snake_case				=		_re_import_struct_add_many.search(_lowerCAmelCase ).groups()[0].split(", " )
																														__snake_case				=		[obj[1:-1] for obj in imports if len(_lowerCAmelCase ) > 0]
																														objects.extend(_lowerCAmelCase )
																								elif _re_between_brackets.search(_lowerCAmelCase ) is not None:
																														__snake_case				=		_re_between_brackets.search(_lowerCAmelCase ).groups()[0].split(", " )
																														__snake_case				=		[obj[1:-1] for obj in imports if len(_lowerCAmelCase ) > 0]
																														objects.extend(_lowerCAmelCase )
																								elif _re_quote_object.search(_lowerCAmelCase ) is not None:
																														objects.append(_re_quote_object.search(_lowerCAmelCase ).groups()[0] )
																								elif line.startswith(" " * 8 + "\"" ):
																														objects.append(line[9:-3] )
																								elif line.startswith(" " * 12 + "\"" ):
																														objects.append(line[13:-3] )
																								line_index += 1

																		__snake_case				=		objects
												else:
																		line_index += 1

    # At this stage we are in the TYPE_CHECKING part, first grab the objects without a specific backend
						__snake_case				=		[]
						while (
						    line_index < len(_lowerCAmelCase )
						    and find_backend(lines[line_index] ) is None
						    and not lines[line_index].startswith("else" )
						):
												__snake_case				=		lines[line_index]
												__snake_case				=		_re_import.search(_lowerCAmelCase )
												if single_line_import_search is not None:
																		objects.extend(single_line_import_search.groups()[0].split(", " ) )
												elif line.startswith(" " * 8 ):
																		objects.append(line[8:-2] )
												line_index += 1

						__snake_case				=		{'''none''': objects}
						# Let's continue with backend-specific objects
						while line_index < len(_lowerCAmelCase ):
												# If the line is an if is_backend_available, we grab all objects associated.
												__snake_case				=		find_backend(lines[line_index] )
												# Check if the backend declaration is inside a try block:
												if _re_try.search(lines[line_index - 1] ) is None:
																		__snake_case				=		None

												if backend is not None:
																		line_index += 1

																		# Scroll until we hit the else block of try-except-else
																		while _re_else.search(lines[line_index] ) is None:
																								line_index += 1

																		line_index += 1

																		__snake_case				=		[]
																		# Until we unindent, add backend objects to the list
																		while len(lines[line_index] ) <= 1 or lines[line_index].startswith(" " * 8 ):
																								__snake_case				=		lines[line_index]
																								__snake_case				=		_re_import.search(_lowerCAmelCase )
																								if single_line_import_search is not None:
																														objects.extend(single_line_import_search.groups()[0].split(", " ) )
																								elif line.startswith(" " * 12 ):
																														objects.append(line[12:-2] )
																								line_index += 1

																		__snake_case				=		objects
												else:
																		line_index += 1

						return import_dict_objects, type_hint_objects





def 	_lowerCAmelCase       (    _lowerCAmelCase      ,	_lowerCAmelCase )						->	List[Any]:


						'''simple docstring'''






						def find_duplicates(_lowerCAmelCase ):
												return [k for k, v in collections.Counter(_lowerCAmelCase ).items() if v > 1]

						if list(import_dict_objects.keys() ) != list(type_hint_objects.keys() ):
												return ["Both sides of the init do not have the same backends!"]

						__snake_case				=		[]
						for key in import_dict_objects.keys():
												__snake_case				=		find_duplicates(import_dict_objects[key] )
												if duplicate_imports:
																		errors.append(F'''Duplicate _import_structure definitions for: {duplicate_imports}''' )
												__snake_case				=		find_duplicates(type_hint_objects[key] )
												if duplicate_type_hints:
																		errors.append(F'''Duplicate TYPE_CHECKING objects for: {duplicate_type_hints}''' )

												if sorted(set(import_dict_objects[key] ) ) != sorted(set(type_hint_objects[key] ) ):
																		__snake_case				=		'''base imports''' if key == '''none''' else F'''{key} backend'''
																		errors.append(F'''Differences for {name}:''' )
																		for a in type_hint_objects[key]:
																								if a not in import_dict_objects[key]:
																														errors.append(F'''  {a} in TYPE_HINT but not in _import_structure.''' )
																		for a in import_dict_objects[key]:
																								if a not in type_hint_objects[key]:
																														errors.append(F'''  {a} in _import_structure but not in TYPE_HINT.''' )
						return errors





def 	_lowerCAmelCase       (    )						->	int:


						'''simple docstring'''






						__snake_case				=		[]
						for root, _, files in os.walk(_lowerCAmelCase ):
												if "__init__.py" in files:
																		__snake_case				=		os.path.join(_lowerCAmelCase      ,	"__init__.py" )
																		__snake_case				=		parse_init(_lowerCAmelCase )
																		if objects is not None:
																								__snake_case				=		analyze_results(*_lowerCAmelCase )
																								if len(_lowerCAmelCase ) > 0:
																														__snake_case				=		F'''Problem in {fname}, both halves do not define the same objects.\n{errors[0]}'''
																														failures.append("\n".join(_lowerCAmelCase ) )
						if len(_lowerCAmelCase ) > 0:
												raise ValueError("\n\n".join(_lowerCAmelCase ) )





def 	_lowerCAmelCase       (    )						->	str:


						'''simple docstring'''






						__snake_case				=		[]
						for path, directories, files in os.walk(_lowerCAmelCase ):
												for folder in directories:
																		# Ignore private modules
																		if folder.startswith("_" ):
																								directories.remove(_lowerCAmelCase )
																								continue
																		# Ignore leftovers from branches (empty folders apart from pycache)
																		if len(list((Path(_lowerCAmelCase ) / folder).glob("*.py" ) ) ) == 0:
																								continue
																		__snake_case				=		str((Path(_lowerCAmelCase ) / folder).relative_to(_lowerCAmelCase ) )
																		__snake_case				=		short_path.replace(os.path.sep      ,	"." )
																		submodules.append(_lowerCAmelCase )
												for fname in files:
																		if fname == "__init__.py":
																								continue
																		__snake_case				=		str((Path(_lowerCAmelCase ) / fname).relative_to(_lowerCAmelCase ) )
																		__snake_case				=		short_path.replace(".py"      ,	"" ).replace(os.path.sep      ,	"." )
																		if len(submodule.split("." ) ) == 1:
																								submodules.append(_lowerCAmelCase )
						return submodules


A							:					int     						=     [
    'convert_pytorch_checkpoint_to_tf2',
    'modeling_flax_pytorch_utils',
    'models.esm.openfold_utils',
]





def 	_lowerCAmelCase       (    )						->	List[Any]:


						'''simple docstring'''






						from transformers.utils import direct_transformers_import

						__snake_case				=		direct_transformers_import(_lowerCAmelCase )

						__snake_case				=		set(transformers._import_structure.keys() )
						# This contains all the base keys of the _import_structure object defined in the init, but if the user is missing
						# some optional dependencies, they may not have all of them. Thus we read the init to read all additions and
						# (potentiall re-) add them.
						with open(os.path.join(_lowerCAmelCase      ,	"__init__.py" )      ,	"r" ) as f:
												__snake_case				=		f.read()
						import_structure_keys.update(set(re.findall(r"import_structure\[\"([^\"]*)\"\]"      ,	_lowerCAmelCase ) ) )

						__snake_case				=		[
						    module
						    for module in get_transformers_submodules()
						    if module not in IGNORE_SUBMODULES and module not in import_structure_keys
						]

						if len(_lowerCAmelCase ) > 0:
												__snake_case				=		'''\n'''.join(F'''- {module}''' for module in module_not_registered )
												raise ValueError(
												    "The following submodules are not properly registed in the main init of Transformers:\n"
												    F'''{list_of_modules}\n'''
												    "Make sure they appear somewhere in the keys of `_import_structure` with an empty list as value." )


if __name__ == "__main__":
	check_all_inits()
	check_submodules()









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 							SCREAMING_SNAKE_CASE_  (						self	:		str						)			->	Dict:




											'''simple docstring'''

											super().tearDown()
											gc.collect()
											torch.cuda.empty_cache()


					@property
					def 							SCREAMING_SNAKE_CASE_  (						self	:		Tuple						)			->	Optional[Any]:




											'''simple docstring'''

											__snake_case				=		1
											__snake_case				=		3
											__snake_case				=		(3_2, 3_2)

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


					@property
					def 							SCREAMING_SNAKE_CASE_  (						self	:		int						)			->	Any:




											'''simple docstring'''

											torch.manual_seed(0						)
											__snake_case				=		UNetaDConditionModel(
											    block_out_channels=(3_2, 6_4)     ,    layers_per_block=2     ,    sample_size=3_2     ,    in_channels=4     ,    out_channels=4     ,    down_block_types=("DownBlock2D", "CrossAttnDownBlock2D")     ,    up_block_types=("CrossAttnUpBlock2D", "UpBlock2D")     ,    cross_attention_dim=3_2     ,    )
											return model


					@property
					def 							SCREAMING_SNAKE_CASE_  (						self	:		Any						)			->	str:




											'''simple docstring'''

											torch.manual_seed(0						)
											__snake_case				=		AutoencoderKL(
											    block_out_channels=[3_2, 6_4]     ,    in_channels=3     ,    out_channels=3     ,    down_block_types=["DownEncoderBlock2D", "DownEncoderBlock2D"]     ,    up_block_types=["UpDecoderBlock2D", "UpDecoderBlock2D"]     ,    latent_channels=4     ,    )
											return model


					@property
					def 							SCREAMING_SNAKE_CASE_  (						self	:		List[str]						)			->	int:




											'''simple docstring'''

											torch.manual_seed(0						)
											__snake_case				=		CLIPTextConfig(
											    bos_token_id=0     ,    eos_token_id=2     ,    hidden_size=3_2     ,    intermediate_size=3_7     ,    layer_norm_eps=1e-0_5     ,    num_attention_heads=4     ,    num_hidden_layers=5     ,    pad_token_id=1     ,    vocab_size=1_0_0_0     ,    )
											return CLIPTextModel(SCREAMING_SNAKE_CASE						)


					@property
					def 							SCREAMING_SNAKE_CASE_  (						self	:		Optional[Any]						)			->	str:




											'''simple docstring'''

											def extract(*SCREAMING_SNAKE_CASE	:		List[str]     ,    **SCREAMING_SNAKE_CASE	:		List[Any]						):






																	class     UpperCamelCase:


																						def __init__(						self	:		Dict						)			->	Union[str, Any]:




																												'''simple docstring'''

																												__snake_case				=		torch.ones([0]						)






																						def 							SCREAMING_SNAKE_CASE_  (						self	:		Optional[Any]     ,    SCREAMING_SNAKE_CASE	:		Optional[Any]						)			->	List[Any]:




																												'''simple docstring'''

																												self.pixel_values.to(SCREAMING_SNAKE_CASE						)
																												return self




																	return Out()

											return extract


					def 							SCREAMING_SNAKE_CASE_  (						self	:		Dict						)			->	Dict:




											'''simple docstring'''

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

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

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

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

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

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

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

											assert image.shape == (1, 6_4, 6_4, 3)
											__snake_case				=		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 							SCREAMING_SNAKE_CASE_  (						self	:		Any						)			->	Tuple:




											'''simple docstring'''

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

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

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

											__snake_case				=		output.images

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

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

											assert image.shape == (1, 6_4, 6_4, 3)
											__snake_case				=		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 							SCREAMING_SNAKE_CASE_  (						self	:		List[str]						)			->	List[Any]:




											'''simple docstring'''

											__snake_case				=		StableDiffusionPipeline.from_pretrained(
											    "hf-internal-testing/tiny-stable-diffusion-lms-pipe"     ,    safety_checker=SCREAMING_SNAKE_CASE						)
											assert isinstance(SCREAMING_SNAKE_CASE     ,    SCREAMING_SNAKE_CASE						)
											assert isinstance(pipe.scheduler     ,    SCREAMING_SNAKE_CASE						)
											assert pipe.safety_checker is None

											__snake_case				=		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(SCREAMING_SNAKE_CASE						)
																	__snake_case				=		StableDiffusionPipeline.from_pretrained(SCREAMING_SNAKE_CASE						)

											# sanity check that the pipeline still works
											assert pipe.safety_checker is None
											__snake_case				=		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 							SCREAMING_SNAKE_CASE_  (						self	:		Union[str, Any]						)			->	int:




											'''simple docstring'''

											__snake_case				=		self.dummy_cond_unet
											__snake_case				=		PNDMScheduler(skip_prk_steps=SCREAMING_SNAKE_CASE						)
											__snake_case				=		self.dummy_vae
											__snake_case				=		self.dummy_text_encoder
											__snake_case				=		CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"						)

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

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

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

											assert image.shape == (1, 6_4, 6_4, 3)






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


					def 							SCREAMING_SNAKE_CASE_  (						self	:		List[str]						)			->	Tuple:




											'''simple docstring'''

											super().tearDown()
											gc.collect()
											torch.cuda.empty_cache()


					def 							SCREAMING_SNAKE_CASE_  (						self	:		List[Any]						)			->	Optional[Any]:




											'''simple docstring'''

											__snake_case				=		StableDiffusionPipeline.from_pretrained("runwayml/stable-diffusion-v1-5"     ,    safety_checker=SCREAMING_SNAKE_CASE						)
											__snake_case				=		LMSDiscreteScheduler.from_config(sd_pipe.scheduler.config						)
											__snake_case				=		sd_pipe.to(SCREAMING_SNAKE_CASE						)
											sd_pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE						)

											__snake_case				=		(
											    "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 "
											)
											__snake_case				=		4_0_0_3_6_6_0_3_4_6
											__snake_case				=		7

											# without safety guidance (sld_guidance_scale = 0)
											__snake_case				=		torch.manual_seed(SCREAMING_SNAKE_CASE						)
											__snake_case				=		sd_pipe(
											    [prompt]     ,    generator=SCREAMING_SNAKE_CASE     ,    guidance_scale=SCREAMING_SNAKE_CASE     ,    num_inference_steps=5_0     ,    output_type="np"     ,    width=5_1_2     ,    height=5_1_2     ,    sld_guidance_scale=0     ,    )

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

											assert image.shape == (1, 5_1_2, 5_1_2, 3)

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

											# without safety guidance (strong configuration)
											__snake_case				=		torch.manual_seed(SCREAMING_SNAKE_CASE						)
											__snake_case				=		sd_pipe(
											    [prompt]     ,    generator=SCREAMING_SNAKE_CASE     ,    guidance_scale=SCREAMING_SNAKE_CASE     ,    num_inference_steps=5_0     ,    output_type="np"     ,    width=5_1_2     ,    height=5_1_2     ,    sld_guidance_scale=2_0_0_0     ,    sld_warmup_steps=7     ,    sld_threshold=0.025     ,    sld_momentum_scale=0.5     ,    sld_mom_beta=0.7     ,    )

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

											assert image.shape == (1, 5_1_2, 5_1_2, 3)

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


					def 							SCREAMING_SNAKE_CASE_  (						self	:		Tuple						)			->	List[str]:




											'''simple docstring'''

											__snake_case				=		StableDiffusionPipeline.from_pretrained("runwayml/stable-diffusion-v1-5"     ,    safety_checker=SCREAMING_SNAKE_CASE						)
											__snake_case				=		LMSDiscreteScheduler.from_config(sd_pipe.scheduler.config						)
											__snake_case				=		sd_pipe.to(SCREAMING_SNAKE_CASE						)
											sd_pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE						)

											__snake_case				=		"padme amidala taking a bath artwork, safe for work, no nudity"
											__snake_case				=		2_7_3_4_9_7_1_7_5_5
											__snake_case				=		7

											__snake_case				=		torch.manual_seed(SCREAMING_SNAKE_CASE						)
											__snake_case				=		sd_pipe(
											    [prompt]     ,    generator=SCREAMING_SNAKE_CASE     ,    guidance_scale=SCREAMING_SNAKE_CASE     ,    num_inference_steps=5_0     ,    output_type="np"     ,    width=5_1_2     ,    height=5_1_2     ,    sld_guidance_scale=0     ,    )

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

											assert image.shape == (1, 5_1_2, 5_1_2, 3)

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

											__snake_case				=		torch.manual_seed(SCREAMING_SNAKE_CASE						)
											__snake_case				=		sd_pipe(
											    [prompt]     ,    generator=SCREAMING_SNAKE_CASE     ,    guidance_scale=SCREAMING_SNAKE_CASE     ,    num_inference_steps=5_0     ,    output_type="np"     ,    width=5_1_2     ,    height=5_1_2     ,    sld_guidance_scale=2_0_0_0     ,    sld_warmup_steps=7     ,    sld_threshold=0.025     ,    sld_momentum_scale=0.5     ,    sld_mom_beta=0.7     ,    )

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

											assert image.shape == (1, 5_1_2, 5_1_2, 3)

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






					def 							SCREAMING_SNAKE_CASE_  (						self	:		Dict						)			->	int:




											'''simple docstring'''

											__snake_case				=		StableDiffusionPipeline.from_pretrained("runwayml/stable-diffusion-v1-5"						)
											__snake_case				=		sd_pipe.to(SCREAMING_SNAKE_CASE						)
											sd_pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE						)

											__snake_case				=		(
											    "the four horsewomen of the apocalypse, painting by tom of finland, gaston bussiere, craig mullins, j. c."
											    " leyendecker"
											)
											__snake_case				=		1_0_4_4_3_5_5_2_3_4
											__snake_case				=		1_2

											__snake_case				=		torch.manual_seed(SCREAMING_SNAKE_CASE						)
											__snake_case				=		sd_pipe(
											    [prompt]     ,    generator=SCREAMING_SNAKE_CASE     ,    guidance_scale=SCREAMING_SNAKE_CASE     ,    num_inference_steps=5_0     ,    output_type="np"     ,    width=5_1_2     ,    height=5_1_2     ,    sld_guidance_scale=0     ,    )

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

											assert image.shape == (1, 5_1_2, 5_1_2, 3)

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

											__snake_case				=		torch.manual_seed(SCREAMING_SNAKE_CASE						)
											__snake_case				=		sd_pipe(
											    [prompt]     ,    generator=SCREAMING_SNAKE_CASE     ,    guidance_scale=SCREAMING_SNAKE_CASE     ,    num_inference_steps=5_0     ,    output_type="np"     ,    width=5_1_2     ,    height=5_1_2     ,    sld_guidance_scale=2_0_0_0     ,    sld_warmup_steps=7     ,    sld_threshold=0.025     ,    sld_momentum_scale=0.5     ,    sld_mom_beta=0.7     ,    )

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

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





