




import gc
import unittest

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

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    StableDiffusionSAGPipeline,
    UNetaDConditionModel,
)
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 PipelineLatentTesterMixin, PipelineTesterMixin


enable_full_determinism()




class       _A				(		__lowercase       ,     __lowercase       ,     unittest.TestCase     ):
		__a					    =       StableDiffusionSAGPipeline
		__a					    =       TEXT_TO_IMAGE_PARAMS
		__a					    =       TEXT_TO_IMAGE_BATCH_PARAMS
		__a					    =       TEXT_TO_IMAGE_IMAGE_PARAMS
		__a					    =       TEXT_TO_IMAGE_IMAGE_PARAMS
		__a					    =       False






		def 				UpperCAmelCase (    self			):
								torch.manual_seed(0			)
								_UpperCAmelCase      =			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						,		)
								_UpperCAmelCase      =			DDIMScheduler(
								    beta_start=0.0_0085						,		beta_end=0.012						,		beta_schedule="""scaled_linear"""						,		clip_sample=_SCREAMING_SNAKE_CASE						,		set_alpha_to_one=_SCREAMING_SNAKE_CASE						,		)
								torch.manual_seed(0			)
								_UpperCAmelCase      =			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						,		)
								torch.manual_seed(0			)
								_UpperCAmelCase      =			CLIPTextConfig(
								    bos_token_id=0						,		eos_token_id=2						,		hidden_size=32						,		intermediate_size=37						,		layer_norm_eps=1e-05						,		num_attention_heads=4						,		num_hidden_layers=5						,		pad_token_id=1						,		vocab_size=1000						,		)
								_UpperCAmelCase      =			CLIPTextModel(_SCREAMING_SNAKE_CASE			)
								_UpperCAmelCase      =			CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""			)

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






		def 				UpperCAmelCase (    self						,		_SCREAMING_SNAKE_CASE						,		_SCREAMING_SNAKE_CASE=0			):
								if str(_SCREAMING_SNAKE_CASE			).startswith("""mps"""			):
														_UpperCAmelCase      =			torch.manual_seed(_SCREAMING_SNAKE_CASE			)
								else:
														_UpperCAmelCase      =			torch.Generator(device=_SCREAMING_SNAKE_CASE			).manual_seed(_SCREAMING_SNAKE_CASE			)
								_UpperCAmelCase      =			{
								    """prompt""": """.""",
								    """generator""": generator,
								    """num_inference_steps""": 2,
								    """guidance_scale""": 1.0,
								    """sag_scale""": 1.0,
								    """output_type""": """numpy""",
								}
								return inputs






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




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






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






		def 				UpperCAmelCase (    self			):
								_UpperCAmelCase      =			StableDiffusionSAGPipeline.from_pretrained("""CompVis/stable-diffusion-v1-4"""			)
								_UpperCAmelCase      =			sag_pipe.to(_SCREAMING_SNAKE_CASE			)
								sag_pipe.set_progress_bar_config(disable=_SCREAMING_SNAKE_CASE			)

								_UpperCAmelCase      =			"""."""
								_UpperCAmelCase      =			torch.manual_seed(0			)
								_UpperCAmelCase      =			sag_pipe(
								    [prompt]						,		generator=_SCREAMING_SNAKE_CASE						,		guidance_scale=7.5						,		sag_scale=1.0						,		num_inference_steps=20						,		output_type="""np"""			)

								_UpperCAmelCase      =			output.images

								_UpperCAmelCase      =			image[0, -3:, -3:, -1]

								assert image.shape == (1, 512, 512, 3)
								_UpperCAmelCase      =			np.array([0.1568, 0.1738, 0.1695, 0.1693, 0.1507, 0.1705, 0.1547, 0.1751, 0.1949]			)

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






		def 				UpperCAmelCase (    self			):
								_UpperCAmelCase      =			StableDiffusionSAGPipeline.from_pretrained("""stabilityai/stable-diffusion-2-1-base"""			)
								_UpperCAmelCase      =			sag_pipe.to(_SCREAMING_SNAKE_CASE			)
								sag_pipe.set_progress_bar_config(disable=_SCREAMING_SNAKE_CASE			)

								_UpperCAmelCase      =			"""."""
								_UpperCAmelCase      =			torch.manual_seed(0			)
								_UpperCAmelCase      =			sag_pipe(
								    [prompt]						,		generator=_SCREAMING_SNAKE_CASE						,		guidance_scale=7.5						,		sag_scale=1.0						,		num_inference_steps=20						,		output_type="""np"""			)

								_UpperCAmelCase      =			output.images

								_UpperCAmelCase      =			image[0, -3:, -3:, -1]

								assert image.shape == (1, 512, 512, 3)
								_UpperCAmelCase      =			np.array([0.3459, 0.2876, 0.2537, 0.3002, 0.2671, 0.2160, 0.3026, 0.2262, 0.2371]			)

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






		def 				UpperCAmelCase (    self			):
								_UpperCAmelCase      =			StableDiffusionSAGPipeline.from_pretrained("""stabilityai/stable-diffusion-2-1-base"""			)
								_UpperCAmelCase      =			sag_pipe.to(_SCREAMING_SNAKE_CASE			)
								sag_pipe.set_progress_bar_config(disable=_SCREAMING_SNAKE_CASE			)

								_UpperCAmelCase      =			"""."""
								_UpperCAmelCase      =			torch.manual_seed(0			)
								_UpperCAmelCase      =			sag_pipe(
								    [prompt]						,		width=768						,		height=512						,		generator=_SCREAMING_SNAKE_CASE						,		guidance_scale=7.5						,		sag_scale=1.0						,		num_inference_steps=20						,		output_type="""np"""						,		)

								_UpperCAmelCase      =			output.images

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





import jax.numpy as jnp

from ...utils import logging
from ..ta.modeling_flax_ta import FlaxTaEncoderModel, FlaxTaForConditionalGeneration, FlaxTaModel
from .configuration_mta import MTaConfig


a													=			logging.get_logger(__name__)

a													=			"T5Config"




def        _SCREAMING_SNAKE_CASE      (		snake_case			,     snake_case			,     snake_case       )						->				jnp.ndarray:
						_UpperCAmelCase      =			jnp.zeros_like(snake_case       )
						_UpperCAmelCase      =			shifted_input_ids.at[:, 1:].set(input_ids[:, :-1]       )
						_UpperCAmelCase      =			shifted_input_ids.at[:, 0].set(snake_case       )

						_UpperCAmelCase      =			jnp.where(shifted_input_ids == -1_0_0			,     snake_case			,     snake_case       )
						return shifted_input_ids




class       _A				(		__lowercase     ):
		__a					    =       """mt5"""
		__a					    =       MTaConfig




class       _A				(		__lowercase     ):
		__a					    =       """mt5"""
		__a					    =       MTaConfig




class       _A				(		__lowercase     ):
		__a					    =       """mt5"""
		__a					    =       MTaConfig