

def 		UpperCamelCase   (lowercase_:					str       , lowercase_:					list[str]   )	-> str:
	A__				:       Any	  =						""""""
	for word_or_phrase in separated:
		if not isinstance(lowercase_       , lowercase_   ):
			raise Exception("""join() accepts only strings to be joined"""   )
		joined += word_or_phrase + separator
	return joined.strip(lowercase_   )


if __name__ == "__main__":
	from doctest import testmod

	testmod()






import gc
import unittest

import numpy as np
import torch
from transformers import CLIPTextConfig, CLIPTextModel, XLMRobertaTokenizer

from diffusers import AltDiffusionPipeline, AutoencoderKL, DDIMScheduler, PNDMScheduler, UNetaDConditionModel
from diffusers.pipelines.alt_diffusion.modeling_roberta_series import (
    RobertaSeriesConfig,
    RobertaSeriesModelWithTransformation,
)
from diffusers.utils import slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_IMAGE_PARAMS, TEXT_TO_IMAGE_PARAMS
from ..test_pipelines_common import PipelineKarrasSchedulerTesterMixin, PipelineLatentTesterMixin, PipelineTesterMixin


enable_full_determinism()



class        _a		(__magic_name__						,  __magic_name__						,  __magic_name__						,  unittest.TestCase							):


					'''simple docstring'''






					UpperCAmelCase__:  int    				=			AltDiffusionPipeline
					UpperCAmelCase__:  Tuple    				=			TEXT_TO_IMAGE_PARAMS
					UpperCAmelCase__:  List[str]    				=			TEXT_TO_IMAGE_BATCH_PARAMS
					UpperCAmelCase__:  Union[str, Any]    				=			TEXT_TO_IMAGE_IMAGE_PARAMS
					UpperCAmelCase__:  Optional[int]    				=			TEXT_TO_IMAGE_IMAGE_PARAMS






					def     __A     (					self     ):
						torch.manual_seed(0     )
						A__				:       Union[str, Any]	  =						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       ,			)
						A__				:       List[str]	  =						DDIMScheduler(
						    beta_start=0.0_0_0_8_5       ,			beta_end=0.0_1_2       ,			beta_schedule="""scaled_linear"""       ,			clip_sample=A__       ,			set_alpha_to_one=A__       ,			)
						torch.manual_seed(0     )
						A__				:       int	  =						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       ,			)

						# TODO: address the non-deterministic text encoder (fails for save-load tests)
						# torch.manual_seed(0)
						# text_encoder_config = RobertaSeriesConfig(
						#     hidden_size=32,
						#     project_dim=32,
						#     intermediate_size=37,
						#     layer_norm_eps=1e-05,
						#     num_attention_heads=4,
						#     num_hidden_layers=5,
						#     vocab_size=5002,
						# )
						# text_encoder = RobertaSeriesModelWithTransformation(text_encoder_config)

						torch.manual_seed(0     )
						A__				:       int	  =						CLIPTextConfig(
						    bos_token_id=0       ,			eos_token_id=2       ,			hidden_size=32       ,			projection_dim=32       ,			intermediate_size=37       ,			layer_norm_eps=1e-05       ,			num_attention_heads=4       ,			num_hidden_layers=5       ,			pad_token_id=1       ,			vocab_size=5002       ,			)
						A__				:       Tuple	  =						CLIPTextModel(A__     )

						A__				:       Union[str, Any]	  =						XLMRobertaTokenizer.from_pretrained("""hf-internal-testing/tiny-xlm-roberta"""     )
						A__				:       Union[str, Any]	  =						77

						A__				:       Tuple	  =						{
						    """unet""": unet,
						    """scheduler""": scheduler,
						    """vae""": vae,
						    """text_encoder""": text_encoder,
						    """tokenizer""": tokenizer,
						    """safety_checker""": None,
						    """feature_extractor""": None,
						}
						return components






					def     __A     (					self       ,			A__       ,			A__=0     ):
						if str(A__     ).startswith("""mps"""     ):
							A__				:       Dict	  =						torch.manual_seed(A__     )
						else:
							A__				:       str	  =						torch.Generator(device=A__     ).manual_seed(A__     )
						A__				:       int	  =						{
						    """prompt""": """A painting of a squirrel eating a burger""",
						    """generator""": generator,
						    """num_inference_steps""": 2,
						    """guidance_scale""": 6.0,
						    """output_type""": """numpy""",
						}
						return inputs






					def     __A     (					self     ):
						super().test_attention_slicing_forward_pass(expected_max_diff=3e-3     )






					def     __A     (					self     ):
						super().test_inference_batch_single_identical(expected_max_diff=3e-3     )






					def     __A     (					self     ):
						A__				:       Optional[Any]	  =						"""cpu"""  # ensure determinism for the device-dependent torch.Generator

						A__				:       Union[str, Any]	  =						self.get_dummy_components()
						torch.manual_seed(0     )
						A__				:       List[str]	  =						RobertaSeriesConfig(
						    hidden_size=32       ,			project_dim=32       ,			intermediate_size=37       ,			layer_norm_eps=1e-05       ,			num_attention_heads=4       ,			num_hidden_layers=5       ,			vocab_size=5002       ,			)
						# TODO: remove after fixing the non-deterministic text encoder
						A__				:       Tuple	  =						RobertaSeriesModelWithTransformation(A__     )
						A__				:       Optional[int]	  =						text_encoder

						A__				:       Optional[int]	  =						AltDiffusionPipeline(**A__     )
						A__				:       str	  =						alt_pipe.to(A__     )
						alt_pipe.set_progress_bar_config(disable=A__     )

						A__				:       List[str]	  =						self.get_dummy_inputs(A__     )
						A__				:       List[str]	  =						"""A photo of an astronaut"""
						A__				:       Optional[int]	  =						alt_pipe(**A__     )
						A__				:       List[Any]	  =						output.images
						A__				:       int	  =						image[0, -3:, -3:, -1]

						assert image.shape == (1, 64, 64, 3)
						A__				:       Optional[Any]	  =						np.array(
						    [0.5_7_4_8_1_6_2, 0.6_0_4_4_7_1_4_5, 0.4_8_8_2_1_2_1_7, 0.5_0_1_0_0_6_3_6, 0.5_4_3_1_1_8_5, 0.4_5_7_6_3_6_8_3, 0.4_9_6_5_7_6_9_6, 0.4_8_1_3_2_7_3_3, 0.4_7_5_7_3_0_9_3]     )

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






					def     __A     (					self     ):
						A__				:       Dict	  =						"""cpu"""  # ensure determinism for the device-dependent torch.Generator

						A__				:       Union[str, Any]	  =						self.get_dummy_components()
						A__				:       Any	  =						PNDMScheduler(skip_prk_steps=A__     )
						torch.manual_seed(0     )
						A__				:       List[str]	  =						RobertaSeriesConfig(
						    hidden_size=32       ,			project_dim=32       ,			intermediate_size=37       ,			layer_norm_eps=1e-05       ,			num_attention_heads=4       ,			num_hidden_layers=5       ,			vocab_size=5002       ,			)
						# TODO: remove after fixing the non-deterministic text encoder
						A__				:       Optional[Any]	  =						RobertaSeriesModelWithTransformation(A__     )
						A__				:       List[Any]	  =						text_encoder
						A__				:       Optional[Any]	  =						AltDiffusionPipeline(**A__     )
						A__				:       Union[str, Any]	  =						alt_pipe.to(A__     )
						alt_pipe.set_progress_bar_config(disable=A__     )

						A__				:       Optional[Any]	  =						self.get_dummy_inputs(A__     )
						A__				:       Dict	  =						alt_pipe(**A__     )
						A__				:       str	  =						output.images
						A__				:       Optional[int]	  =						image[0, -3:, -3:, -1]

						assert image.shape == (1, 64, 64, 3)
						A__				:       Dict	  =						np.array(
						    [0.5_1_6_0_5_0_9_3, 0.5_7_0_7_2_4_1, 0.4_7_3_6_5_5_0_7, 0.5_0_5_7_8_8_8_6, 0.5_6_3_3_8_7_7, 0.4_6_4_2_5_0_3, 0.5_1_8_2_0_8_1, 0.4_8_7_6_3_4_8_4, 0.4_9_0_8_4_2_3_7]     )

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



@slow
@require_torch_gpu
class        _a		(unittest.TestCase							):


					'''simple docstring'''






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






					def     __A     (					self     ):
						# make sure here that pndm scheduler skips prk
						A__				:       Any	  =						AltDiffusionPipeline.from_pretrained("""BAAI/AltDiffusion"""       ,			safety_checker=A__     )
						A__				:       Union[str, Any]	  =						alt_pipe.to(A__     )
						alt_pipe.set_progress_bar_config(disable=A__     )

						A__				:       int	  =						"""A painting of a squirrel eating a burger"""
						A__				:       Any	  =						torch.manual_seed(0     )
						A__				:       List[Any]	  =						alt_pipe([prompt]       ,			generator=A__       ,			guidance_scale=6.0       ,			num_inference_steps=20       ,			output_type="""np"""     )

						A__				:       List[Any]	  =						output.images

						A__				:       str	  =						image[0, -3:, -3:, -1]

						assert image.shape == (1, 512, 512, 3)
						A__				:       int	  =						np.array([0.1_0_1_0, 0.0_8_0_0, 0.0_7_9_4, 0.0_8_8_5, 0.0_8_4_3, 0.0_7_6_2, 0.0_7_6_9, 0.0_7_2_9, 0.0_5_8_6]     )

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






					def     __A     (					self     ):
						A__				:       Optional[Any]	  =						DDIMScheduler.from_pretrained("""BAAI/AltDiffusion"""       ,			subfolder="""scheduler"""     )

						A__				:       Optional[Any]	  =						AltDiffusionPipeline.from_pretrained("""BAAI/AltDiffusion"""       ,			scheduler=A__       ,			safety_checker=A__     )
						A__				:       Optional[Any]	  =						alt_pipe.to(A__     )
						alt_pipe.set_progress_bar_config(disable=A__     )

						A__				:       Union[str, Any]	  =						"""A painting of a squirrel eating a burger"""
						A__				:       Dict	  =						torch.manual_seed(0     )

						A__				:       List[Any]	  =						alt_pipe([prompt]       ,			generator=A__       ,			num_inference_steps=2       ,			output_type="""numpy"""     )
						A__				:       str	  =						output.images

						A__				:       Union[str, Any]	  =						image[0, -3:, -3:, -1]

						assert image.shape == (1, 512, 512, 3)
						A__				:       List[str]	  =						np.array([0.4_0_1_9, 0.4_0_5_2, 0.3_8_1_0, 0.4_1_1_9, 0.3_9_1_6, 0.3_9_8_2, 0.4_6_5_1, 0.4_1_9_5, 0.5_3_2_3]     )

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



