


import gc
import unittest

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

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    StableDiffusionAttendAndExcitePipeline,
    UNetaDConditionModel,
)
from diffusers.utils import load_numpy, skip_mps, slow
from diffusers.utils.testing_utils import 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


UpperCAmelCase_      : Optional[Any]  					=       False
@skip_mps
class  SCREAMING_SNAKE_CASE__  (				lowercase__						,    lowercase__						,    lowercase__						,    unittest.TestCase			):
      snake_case__				:     str        =						StableDiffusionAttendAndExcitePipeline
      snake_case__				:     Tuple        =						False
      snake_case__				:     Dict        =						TEXT_TO_IMAGE_PARAMS
      snake_case__				:     str        =						TEXT_TO_IMAGE_BATCH_PARAMS.union({'''token_indices'''}			)
      snake_case__				:     int        =						TEXT_TO_IMAGE_IMAGE_PARAMS
      snake_case__				:     List[Any]        =						TEXT_TO_IMAGE_IMAGE_PARAMS
      @classmethod
      def        SCREAMING_SNAKE_CASE							(       cls				:       str     )		->			Optional[Any]:
             super().setUpClass()
             torch.use_deterministic_algorithms(SCREAMING_SNAKE_CASE__     )
      @classmethod
      def        SCREAMING_SNAKE_CASE							(       cls				:       Optional[int]     )		->			List[str]:
             super().tearDownClass()
             torch.use_deterministic_algorithms(SCREAMING_SNAKE_CASE__     )
      def        SCREAMING_SNAKE_CASE							(       self				:       int     )		->			Union[str, Any]:
             torch.manual_seed(0     )
             a_					:		List[str]							=  UNetaDConditionModel(
                 block_out_channels=(3_2, 6_4)     ,							layers_per_block=1     ,							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     ,							attention_head_dim=(2, 4)     ,							use_linear_projection=SCREAMING_SNAKE_CASE__     ,							)
             a_					:		str							=  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__     ,							)
             torch.manual_seed(0     )
             a_					:		Union[str, Any]							=  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     ,							sample_size=1_2_8     ,							)
             torch.manual_seed(0     )
             a_					:		Any							=  CLIPTextConfig(
                 bos_token_id=0     ,							eos_token_id=2     ,							hidden_size=3_2     ,							intermediate_size=3_7     ,							layer_norm_eps=1E-05     ,							num_attention_heads=4     ,							num_hidden_layers=5     ,							pad_token_id=1     ,							vocab_size=1_0_0_0     ,							hidden_act='gelu'     ,							projection_dim=5_1_2     ,							)
             a_					:		Optional[int]							=  CLIPTextModel(SCREAMING_SNAKE_CASE__     )
             a_					:		List[str]							=  CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'     )

             a_					:		Dict							=  {
                 'unet': unet,
                 'scheduler': scheduler,
                 'vae': vae,
                 'text_encoder': text_encoder,
                 'tokenizer': tokenizer,
                 'safety_checker': None,
                 'feature_extractor': None,
             }

             return components
      def        SCREAMING_SNAKE_CASE							(       self				:       Tuple     ,							SCREAMING_SNAKE_CASE__				:       List[str]     ,							SCREAMING_SNAKE_CASE__				:       Any=0     )		->			Any:
             if str(SCREAMING_SNAKE_CASE__     ).startswith('mps'     ):
                    a_					:		Any							=  torch.manual_seed(SCREAMING_SNAKE_CASE__     )
             else:
                    a_					:		List[Any]							=  torch.Generator(device=SCREAMING_SNAKE_CASE__     ).manual_seed(SCREAMING_SNAKE_CASE__     )
             a_					:		List[str]							=  {
                 'prompt': 'a cat and a frog',
                 'token_indices': [2, 5],
                 'generator': generator,
                 'num_inference_steps': 1,
                 'guidance_scale': 6.0,
                 'output_type': 'numpy',
                 'max_iter_to_alter': 2,
                 'thresholds': {0: 0.7},
             }
             return inputs
      def        SCREAMING_SNAKE_CASE							(       self				:       Tuple     )		->			Optional[Any]:
             a_					:		List[str]							=  'cpu'

             a_					:		Optional[Any]							=  self.get_dummy_components()
             a_					:		Any							=  self.pipeline_class(**SCREAMING_SNAKE_CASE__     )
             pipe.to(SCREAMING_SNAKE_CASE__     )
             pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE__     )

             a_					:		str							=  self.get_dummy_inputs(SCREAMING_SNAKE_CASE__     )
             a_					:		str							=  pipe(**SCREAMING_SNAKE_CASE__     ).images
             a_					:		List[Any]							=  image[0, -3:, -3:, -1]

             self.assertEqual(image.shape     ,							(1, 6_4, 6_4, 3)     )
             a_					:		Any							=  np.array(
                 [0.63905364, 0.62897307, 0.48599017, 0.5133624, 0.5550048, 0.45769516, 0.50326973, 0.5023139, 0.45384496]     )
             a_					:		Union[str, Any]							=  np.abs(image_slice.flatten() - expected_slice     ).max()
             self.assertLessEqual(SCREAMING_SNAKE_CASE__     ,							1E-3     )
      def        SCREAMING_SNAKE_CASE							(       self				:       int     )		->			int:
             super().test_cpu_offload_forward_pass(expected_max_diff=5E-4     )
      def        SCREAMING_SNAKE_CASE							(       self				:       str     )		->			int:
             # NOTE: Larger batch sizes cause this test to timeout, only test on smaller batches
             self._test_inference_batch_consistent(batch_sizes=[1, 2]     )
      def        SCREAMING_SNAKE_CASE							(       self				:       Tuple     )		->			Union[str, Any]:
             self._test_inference_batch_single_identical(batch_size=2     ,							expected_max_diff=7E-4     )
      def        SCREAMING_SNAKE_CASE							(       self				:       List[str]     )		->			List[Any]:
             super().test_dict_tuple_outputs_equivalent(expected_max_difference=3E-3     )
      def        SCREAMING_SNAKE_CASE							(       self				:       Union[str, Any]     )		->			str:
             super().test_pt_np_pil_outputs_equivalent(expected_max_diff=5E-4     )
      def        SCREAMING_SNAKE_CASE							(       self				:       List[str]     )		->			Any:
             super().test_save_load_local(expected_max_difference=5E-4     )

      def        SCREAMING_SNAKE_CASE							(       self				:       str     )		->			Tuple:
             super().test_save_load_optional_components(expected_max_difference=4E-4     )
@require_torch_gpu
@slow
class  SCREAMING_SNAKE_CASE__  (				unittest.TestCase			):
      @classmethod
      def        SCREAMING_SNAKE_CASE							(       cls				:       Dict     )		->			Union[str, Any]:
             super().setUpClass()
             torch.use_deterministic_algorithms(SCREAMING_SNAKE_CASE__     )
      @classmethod
      def        SCREAMING_SNAKE_CASE							(       cls				:       List[str]     )		->			Tuple:
             super().tearDownClass()
             torch.use_deterministic_algorithms(SCREAMING_SNAKE_CASE__     )
      def        SCREAMING_SNAKE_CASE							(       self				:       int     )		->			Optional[int]:
             super().tearDown()
             gc.collect()
             torch.cuda.empty_cache()

      def        SCREAMING_SNAKE_CASE							(       self				:       Optional[int]     )		->			Optional[int]:
             a_					:		str							=  torch.manual_seed(5_1     )

             a_					:		Tuple							=  StableDiffusionAttendAndExcitePipeline.from_pretrained(
                 'CompVis/stable-diffusion-v1-4'     ,							safety_checker=SCREAMING_SNAKE_CASE__     ,							torch_dtype=torch.floataa     )
             pipe.to('cuda'     )

             a_					:		Any							=  'a painting of an elephant with glasses'
             a_					:		str							=  [5, 7]

             a_					:		Dict							=  pipe(
                 prompt=SCREAMING_SNAKE_CASE__     ,							token_indices=SCREAMING_SNAKE_CASE__     ,							guidance_scale=7.5     ,							generator=SCREAMING_SNAKE_CASE__     ,							num_inference_steps=5     ,							max_iter_to_alter=5     ,							output_type='numpy'     ,							).images[0]

             a_					:		int							=  load_numpy(
                 'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/attend-and-excite/elephant_glasses.npy'     )
             assert np.abs((expected_image - image).max()     ) < 5E-1






import jax.numpy as jnp

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


UpperCAmelCase_      : Optional[Any]  					=       logging.get_logger(__name__)

UpperCAmelCase_      : str  					=       'T5Config'







def        SCREAMING_SNAKE_CASE_						(			__A :			jnp.array  ,    __A :			int  ,    __A :			int				)	->		jnp.ndarray:

       """simple docstring"""

       a_					:		Dict							=  jnp.zeros_like(__A				)
       a_					:		Dict							=  shifted_input_ids.at[:, 1:].set(input_ids[:, :-1]				)
       a_					:		str							=  shifted_input_ids.at[:, 0].set(__A				)

       a_					:		int							=  jnp.where(shifted_input_ids == -1_00  ,    __A  ,    __A				)
       return shifted_input_ids
class  SCREAMING_SNAKE_CASE__  (				lowercase__			):
      snake_case__				:     str        =						'''mt5'''
      snake_case__				:     List[Any]        =						MTaConfig
class  SCREAMING_SNAKE_CASE__  (				lowercase__			):
      snake_case__				:     str        =						'''mt5'''
      snake_case__				:     List[str]        =						MTaConfig
class  SCREAMING_SNAKE_CASE__  (				lowercase__			):
      snake_case__				:     Any        =						'''mt5'''
      snake_case__				:     Union[str, Any]        =						MTaConfig


