






import collections
import importlib.util
import os
import re
from pathlib import Path


__magic_name__:					str							=     '''src/transformers'''


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

def    UpperCamelCase						(	_A			):






						"""simple docstring"""







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

def    UpperCamelCase						(	_A			):






						"""simple docstring"""







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

						__magic_name__      :       Optional[int]       						= 0
						while line_index < len(_UpperCAmelCase			) and not lines[line_index].startswith("""_import_structure = {"""			):
												line_index += 1

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

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

						__magic_name__      :       Union[str, Any]       						= {'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.
												__magic_name__      :       Tuple       						= 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:
																		__magic_name__      :       List[str]       						= 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

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

																		__magic_name__      :       Tuple       						= objects
												else:
																		line_index += 1

    # At this stage we are in the TYPE_CHECKING part, first grab the objects without a specific backend
						__magic_name__      :       str       						= []
						while (
						    line_index < len(_UpperCAmelCase			)
						    and find_backend(lines[line_index]			) is None
						    and not lines[line_index].startswith("""else"""			)
						):
												__magic_name__      :       Any       						= lines[line_index]
												__magic_name__      :       Tuple       						= _re_import.search(_UpperCAmelCase			)
												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

						__magic_name__      :       List[str]       						= {'none': objects}
						# Let's continue with backend-specific objects
						while line_index < len(_UpperCAmelCase			):
												# If the line is an if is_backend_available, we grab all objects associated.
												__magic_name__      :       List[Any]       						= 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:
																		__magic_name__      :       Dict       						= 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

																		__magic_name__      :       Optional[Any]       						= []
																		# Until we unindent, add backend objects to the list
																		while len(lines[line_index]			) <= 1 or lines[line_index].startswith(""" """ * 8			):
																								__magic_name__      :       Optional[int]       						= lines[line_index]
																								__magic_name__      :       Optional[int]       						= _re_import.search(_UpperCAmelCase			)
																								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

																		__magic_name__      :       Optional[Any]       						= objects
												else:
																		line_index += 1

						return import_dict_objects, type_hint_objects

def    UpperCamelCase						(	_A,   _A			):






						"""simple docstring"""







						def find_duplicates(_A			):
												return [k for k, v in collections.Counter(_UpperCAmelCase			).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!"]

						__magic_name__      :       Optional[Any]       						= []
						for key in import_dict_objects.keys():
												__magic_name__      :       List[Any]       						= find_duplicates(import_dict_objects[key]			)
												if duplicate_imports:
																		errors.append(f'Duplicate _import_structure definitions for: {duplicate_imports}'			)
												__magic_name__      :       Optional[int]       						= 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]			)			):
																		__magic_name__      :       Tuple       						= '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    UpperCamelCase						(	):






						"""simple docstring"""







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

def    UpperCamelCase						(	):






						"""simple docstring"""







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


__magic_name__:					Tuple							=     [
    '''convert_pytorch_checkpoint_to_tf2''',
    '''modeling_flax_pytorch_utils''',
]

def    UpperCamelCase						(	):






						"""simple docstring"""







						__magic_name__      :       Any       						= importlib.util.spec_from_file_location(
						    """transformers""",   os.path.join(_UpperCAmelCase,   """__init__.py"""			),   submodule_search_locations=[PATH_TO_TRANSFORMERS],   )
						__magic_name__      :       Tuple       						= spec.loader.load_module()

						__magic_name__      :       Optional[int]       						= [
						    module
						    for module in get_transformers_submodules()
						    if module not in IGNORE_SUBMODULES and module not in transformers._import_structure.keys()
						]
						if len(_UpperCAmelCase			) > 0:
												__magic_name__      :       Any       						= '\n'.join(f'- {module}' for module in module_not_registered			)
												raise ValueError(
												    """The following submodules are not properly registered 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 unittest

import numpy as np
import torch
from transformers import (
    CLIPImageProcessor,
    CLIPTextConfig,
    CLIPTextModel,
    CLIPTokenizer,
    CLIPVisionConfig,
    CLIPVisionModelWithProjection,
)

from diffusers import AutoencoderKL, DDIMScheduler, DDPMScheduler, StableUnCLIPImgaImgPipeline, UNetaDConditionModel
from diffusers.pipelines.pipeline_utils import DiffusionPipeline
from diffusers.pipelines.stable_diffusion.stable_unclip_image_normalizer import StableUnCLIPImageNormalizer
from diffusers.utils.import_utils import is_xformers_available
from diffusers.utils.testing_utils import (
    enable_full_determinism,
    floats_tensor,
    load_image,
    load_numpy,
    require_torch_gpu,
    skip_mps,
    slow,
    torch_device,
)

from ..pipeline_params import TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS, TEXT_GUIDED_IMAGE_VARIATION_PARAMS
from ..test_pipelines_common import (
    PipelineKarrasSchedulerTesterMixin,
    PipelineLatentTesterMixin,
    PipelineTesterMixin,
    assert_mean_pixel_difference,
)


enable_full_determinism()





class 	snake_case__ (							_lowerCAmelCase						,  _lowerCAmelCase						,  _lowerCAmelCase						,  unittest.TestCase				):
	lowercase__						:					str											=   StableUnCLIPImgaImgPipeline
	lowercase__						:					Any											=   TEXT_GUIDED_IMAGE_VARIATION_PARAMS
	lowercase__						:					Tuple											=   TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS
	lowercase__						:					Union[str, Any]											=   frozenset(
	    []				)  # TO-DO: update image_params once pipeline is refactored with VaeImageProcessor.preprocess
	lowercase__						:					Union[str, Any]											=   frozenset([]				)
	def       __magic_name__    (    self			)							->				Tuple:
							__magic_name__      :       Any       						= 32
							__magic_name__      :       Union[str, Any]       						= embedder_hidden_size

							# image encoding components

							__magic_name__      :       Optional[int]       						= CLIPImageProcessor(crop_size=32      ,       size=32			)

							torch.manual_seed(0			)
							__magic_name__      :       Optional[Any]       						= CLIPVisionModelWithProjection(
							    CLIPVisionConfig(
							        hidden_size=lowerCAmelCase__      ,       projection_dim=lowerCAmelCase__      ,       num_hidden_layers=5      ,       num_attention_heads=4      ,       image_size=32      ,       intermediate_size=37      ,       patch_size=1      ,       )			)

							# regular denoising components

							torch.manual_seed(0			)
							__magic_name__      :       Any       						= StableUnCLIPImageNormalizer(embedding_dim=lowerCAmelCase__			)
							__magic_name__      :       int       						= DDPMScheduler(beta_schedule="""squaredcos_cap_v2"""			)

							torch.manual_seed(0			)
							__magic_name__      :       Tuple       						= CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""			)

							torch.manual_seed(0			)
							__magic_name__      :       Optional[Any]       						= CLIPTextModel(
							    CLIPTextConfig(
							        bos_token_id=0      ,       eos_token_id=2      ,       hidden_size=lowerCAmelCase__      ,       projection_dim=32      ,       intermediate_size=37      ,       layer_norm_eps=1e-0_5      ,       num_attention_heads=4      ,       num_hidden_layers=5      ,       pad_token_id=1      ,       vocab_size=10_00      ,       )			)

							torch.manual_seed(0			)
							__magic_name__      :       str       						= UNetaDConditionModel(
							    sample_size=32      ,       in_channels=4      ,       out_channels=4      ,       down_block_types=("""CrossAttnDownBlock2D""", """DownBlock2D""")      ,       up_block_types=("""UpBlock2D""", """CrossAttnUpBlock2D""")      ,       block_out_channels=(32, 64)      ,       attention_head_dim=(2, 4)      ,       class_embed_type="""projection"""      ,       projection_class_embeddings_input_dim=embedder_projection_dim * 2      ,       cross_attention_dim=lowerCAmelCase__      ,       layers_per_block=1      ,       upcast_attention=lowerCAmelCase__      ,       use_linear_projection=lowerCAmelCase__      ,       )

							torch.manual_seed(0			)
							__magic_name__      :       Optional[Any]       						= DDIMScheduler(
							    beta_schedule="""scaled_linear"""      ,       beta_start=0.0_0_0_8_5      ,       beta_end=0.0_1_2      ,       prediction_type="""v_prediction"""      ,       set_alpha_to_one=lowerCAmelCase__      ,       steps_offset=1      ,       )

							torch.manual_seed(0			)
							__magic_name__      :       List[str]       						= AutoencoderKL()

							__magic_name__      :       List[str]       						= {
							    # image encoding components
							    """feature_extractor""": feature_extractor,
							    """image_encoder""": image_encoder.eval(),
							    # image noising components
							    """image_normalizer""": image_normalizer.eval(),
							    """image_noising_scheduler""": image_noising_scheduler,
							    # regular denoising components
							    """tokenizer""": tokenizer,
							    """text_encoder""": text_encoder.eval(),
							    """unet""": unet.eval(),
							    """scheduler""": scheduler,
							    """vae""": vae.eval(),
							}

							return components
	def       __magic_name__    (    self      ,       lowerCAmelCase__      ,       lowerCAmelCase__=0      ,       lowerCAmelCase__=True			)							->				List[Any]:
							if str(lowerCAmelCase__			).startswith("""mps"""			):
													__magic_name__      :       Optional[int]       						= torch.manual_seed(lowerCAmelCase__			)
							else:
													__magic_name__      :       Optional[int]       						= torch.Generator(device=lowerCAmelCase__			).manual_seed(lowerCAmelCase__			)

							__magic_name__      :       Any       						= floats_tensor((1, 3, 32, 32)      ,       rng=random.Random(lowerCAmelCase__			)			).to(lowerCAmelCase__			)

							if pil_image:
													__magic_name__      :       Optional[Any]       						= input_image * 0.5 + 0.5
													__magic_name__      :       int       						= input_image.clamp(0      ,       1			)
													__magic_name__      :       Union[str, Any]       						= input_image.cpu().permute(0      ,       2      ,       3      ,       1			).float().numpy()
													__magic_name__      :       Optional[int]       						= DiffusionPipeline.numpy_to_pil(lowerCAmelCase__			)[0]

							return {
							    "prompt": "An anime racoon running a marathon",
							    "image": input_image,
							    "generator": generator,
							    "num_inference_steps": 2,
							    "output_type": "np",
							}
	@skip_mps
	def       __magic_name__    (    self			)							->				List[Any]:
							__magic_name__      :       Optional[Any]       						= """cpu"""  # ensure determinism for the device-dependent torch.Generator
							__magic_name__      :       List[str]       						= self.get_dummy_components()
							__magic_name__      :       int       						= StableUnCLIPImgaImgPipeline(**lowerCAmelCase__			)
							__magic_name__      :       List[str]       						= sd_pipe.to(lowerCAmelCase__			)
							sd_pipe.set_progress_bar_config(disable=lowerCAmelCase__			)

							__magic_name__      :       Any       						= self.get_dummy_inputs(lowerCAmelCase__			)
							inputs.update({"""image_embeds""": None}			)
							__magic_name__      :       List[str]       						= sd_pipe(**lowerCAmelCase__			).images
							__magic_name__      :       Dict       						= image[0, -3:, -3:, -1]

							assert image.shape == (1, 32, 32, 3)
							__magic_name__      :       int       						= np.array([0.3_8_7_2, 0.7_2_2_4, 0.5_6_0_1, 0.4_7_4_1, 0.6_8_7_2, 0.5_8_1_4, 0.4_6_3_6, 0.3_8_6_7, 0.5_0_7_8]			)

							assert np.abs(image_slice.flatten() - expected_slice			).max() < 1e-3
	def       __magic_name__    (    self			)							->				Dict:
							__magic_name__      :       int       						= torch_device in ["""cpu""", """mps"""]

							self._test_attention_slicing_forward_pass(test_max_difference=lowerCAmelCase__			)
	def       __magic_name__    (    self			)							->				Union[str, Any]:
							__magic_name__      :       Tuple       						= torch_device in ["""cpu""", """mps"""]

							self._test_inference_batch_single_identical(test_max_difference=lowerCAmelCase__			)







	@unittest.skipIf(
	    torch_device != """cuda""" or not is_xformers_available()      ,       reason="""XFormers attention is only available with CUDA and `xformers` installed"""      ,       )
	def       __magic_name__    (    self			)							->				str:
							self._test_xformers_attention_forwardGenerator_pass(test_max_difference=lowerCAmelCase__			)





@slow
@require_torch_gpu
class 	snake_case__ (							unittest.TestCase				):
	def       __magic_name__    (    self			)							->				int:
							# clean up the VRAM after each test
							super().tearDown()
							gc.collect()
							torch.cuda.empty_cache()
	def       __magic_name__    (    self			)							->				List[Any]:
							__magic_name__      :       Optional[Any]       						= load_image(
							    """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/stable_unclip/turtle.png"""			)

							__magic_name__      :       int       						= load_numpy(
							    """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/stable_unclip/stable_unclip_2_1_l_img2img_anime_turtle_fp16.npy"""			)

							__magic_name__      :       List[Any]       						= StableUnCLIPImgaImgPipeline.from_pretrained(
							    """fusing/stable-unclip-2-1-l-img2img"""      ,       torch_dtype=torch.floataa			)
							pipe.to(lowerCAmelCase__			)
							pipe.set_progress_bar_config(disable=lowerCAmelCase__			)
							# stable unclip will oom when integration tests are run on a V100,
							# so turn on memory savings
							pipe.enable_attention_slicing()
							pipe.enable_sequential_cpu_offload()

							__magic_name__      :       Union[str, Any]       						= torch.Generator(device="""cpu"""			).manual_seed(0			)
							__magic_name__      :       Union[str, Any]       						= pipe(lowerCAmelCase__      ,       """anime turle"""      ,       generator=lowerCAmelCase__      ,       output_type="""np"""			)

							__magic_name__      :       Optional[Any]       						= output.images[0]

							assert image.shape == (7_68, 7_68, 3)

							assert_mean_pixel_difference(lowerCAmelCase__      ,       lowerCAmelCase__			)
	def       __magic_name__    (    self			)							->				List[Any]:
							__magic_name__      :       Union[str, Any]       						= load_image(
							    """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/stable_unclip/turtle.png"""			)

							__magic_name__      :       Dict       						= load_numpy(
							    """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/stable_unclip/stable_unclip_2_1_h_img2img_anime_turtle_fp16.npy"""			)

							__magic_name__      :       Union[str, Any]       						= StableUnCLIPImgaImgPipeline.from_pretrained(
							    """fusing/stable-unclip-2-1-h-img2img"""      ,       torch_dtype=torch.floataa			)
							pipe.to(lowerCAmelCase__			)
							pipe.set_progress_bar_config(disable=lowerCAmelCase__			)
							# stable unclip will oom when integration tests are run on a V100,
							# so turn on memory savings
							pipe.enable_attention_slicing()
							pipe.enable_sequential_cpu_offload()

							__magic_name__      :       List[str]       						= torch.Generator(device="""cpu"""			).manual_seed(0			)
							__magic_name__      :       Any       						= pipe(lowerCAmelCase__      ,       """anime turle"""      ,       generator=lowerCAmelCase__      ,       output_type="""np"""			)

							__magic_name__      :       Any       						= output.images[0]

							assert image.shape == (7_68, 7_68, 3)

							assert_mean_pixel_difference(lowerCAmelCase__      ,       lowerCAmelCase__			)







	def       __magic_name__    (    self			)							->				str:
							__magic_name__      :       Any       						= load_image(
							    """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/stable_unclip/turtle.png"""			)

							torch.cuda.empty_cache()
							torch.cuda.reset_max_memory_allocated()
							torch.cuda.reset_peak_memory_stats()

							__magic_name__      :       Union[str, Any]       						= StableUnCLIPImgaImgPipeline.from_pretrained(
							    """fusing/stable-unclip-2-1-h-img2img"""      ,       torch_dtype=torch.floataa			)
							__magic_name__      :       int       						= pipe.to(lowerCAmelCase__			)
							pipe.set_progress_bar_config(disable=lowerCAmelCase__			)
							pipe.enable_attention_slicing()
							pipe.enable_sequential_cpu_offload()

							__magic_name__      :       List[Any]       						= pipe(
							    lowerCAmelCase__      ,       """anime turtle"""      ,       num_inference_steps=2      ,       output_type="""np"""      ,       )

							__magic_name__      :       List[str]       						= torch.cuda.max_memory_allocated()
							# make sure that less than 7 GB is allocated
							assert mem_bytes < 7 * 10**9
