



'''simple docstring'''






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


lowerCAmelCase:   str					=		False

@skip_mps
class 				a__(   lowerCamelCase__						,					lowerCamelCase__						,					lowerCamelCase__						,					unittest.TestCase      ):
    lowercase__					=       StableDiffusionAttendAndExcitePipeline
    lowercase__					=       False
    lowercase__					=       TEXT_TO_IMAGE_PARAMS
    lowercase__					=       TEXT_TO_IMAGE_BATCH_PARAMS.union({"""token_indices"""}      )
    lowercase__					=       TEXT_TO_IMAGE_IMAGE_PARAMS
    lowercase__					=       TEXT_TO_IMAGE_IMAGE_PARAMS







    @classmethod
    def      lowercase_			( cls					:    str      ):
      super().setUpClass()
      torch.use_deterministic_algorithms(__snake_case      )







    @classmethod
    def      lowercase_			( cls					:    int      ):
      super().tearDownClass()
      torch.use_deterministic_algorithms(__snake_case      )







    def      lowercase_			( self					:    List[Any]      ):
      torch.manual_seed(0      )
      a		:   Dict	  =	UNetaDConditionModel(
          block_out_channels=(32, 64)		,     layers_per_block=1		,     sample_size=32		,     in_channels=4		,     out_channels=4		,     down_block_types=('DownBlock2D', 'CrossAttnDownBlock2D')		,     up_block_types=('CrossAttnUpBlock2D', 'UpBlock2D')		,     cross_attention_dim=32		,     attention_head_dim=(2, 4)		,     use_linear_projection=__snake_case		,     )
      a		:   List[Any]	  =	DDIMScheduler(
          beta_start=0.00085		,     beta_end=0.012		,     beta_schedule='scaled_linear'		,     clip_sample=__snake_case		,     set_alpha_to_one=__snake_case		,     )
      torch.manual_seed(0      )
      a		:   Union[str, Any]	  =	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		,     sample_size=1_28		,     )
      torch.manual_seed(0      )
      a		:   Optional[Any]	  =	CLIPTextConfig(
          bos_token_id=0		,     eos_token_id=2		,     hidden_size=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		,     hidden_act='gelu'		,     projection_dim=5_12		,     )
      a		:   Union[str, Any]	  =	CLIPTextModel(__snake_case      )
      a		:   Union[str, Any]	  =	CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'      )

      a		:   List[str]	  =	{
          'unet': unet,
          'scheduler': scheduler,
          'vae': vae,
          'text_encoder': text_encoder,
          'tokenizer': tokenizer,
          'safety_checker': None,
          'feature_extractor': None,
      }

      return components







    def      lowercase_			( self					:    Any		,     __snake_case					:    Tuple		,     __snake_case					:    int=0      ):
      if str(__snake_case      ).startswith('mps'      ):
        a		:   Any	  =	torch.manual_seed(__snake_case      )
      else:
        a		:   str	  =	torch.Generator(device=__snake_case      ).manual_seed(__snake_case      )
      a		:   int	  =	{
          '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      lowercase_			( self					:    Optional[Any]      ):
      a		:   Optional[Any]	  =	'cpu'

      a		:   Optional[int]	  =	self.get_dummy_components()
      a		:   Union[str, Any]	  =	self.pipeline_class(**__snake_case      )
      pipe.to(__snake_case      )
      pipe.set_progress_bar_config(disable=__snake_case      )

      a		:   List[str]	  =	self.get_dummy_inputs(__snake_case      )
      a		:   int	  =	pipe(**__snake_case      ).images
      a		:   Dict	  =	image[0, -3:, -3:, -1]

      self.assertEqual(image.shape		,     (1, 64, 64, 3)      )
      a		:   Union[str, Any]	  =	np.array(
          [0.63905364, 0.62897307, 0.48599017, 0.5133624, 0.5550048, 0.45769516, 0.50326973, 0.5023139, 0.45384496]      )
      a		:   Dict	  =	np.abs(image_slice.flatten() - expected_slice      ).max()
      self.assertLessEqual(__snake_case		,     1e-3      )







    def      lowercase_			( self					:    Dict      ):
      super().test_cpu_offload_forward_pass(expected_max_diff=5e-4      )







    def      lowercase_			( self					:    Optional[Any]      ):
      # NOTE: Larger batch sizes cause this test to timeout, only test on smaller batches
      self._test_inference_batch_consistent(batch_sizes=[1, 2]      )







    def      lowercase_			( self					:    List[Any]      ):
      self._test_inference_batch_single_identical(batch_size=2		,     expected_max_diff=7e-4      )







    def      lowercase_			( self					:    Optional[int]      ):
      super().test_dict_tuple_outputs_equivalent(expected_max_difference=3e-3      )







    def      lowercase_			( self					:    Any      ):
      super().test_pt_np_pil_outputs_equivalent(expected_max_diff=5e-4      )







    def      lowercase_			( self					:    Optional[Any]      ):
      super().test_save_load_local(expected_max_difference=5e-4      )







    def      lowercase_			( self					:    List[str]      ):
      super().test_save_load_optional_components(expected_max_difference=4e-4      )

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







    @classmethod
    def      lowercase_			( cls					:    Optional[int]      ):
      super().setUpClass()
      torch.use_deterministic_algorithms(__snake_case      )







    @classmethod
    def      lowercase_			( cls					:    Dict      ):
      super().tearDownClass()
      torch.use_deterministic_algorithms(__snake_case      )







    def      lowercase_			( self					:    Union[str, Any]      ):
      super().tearDown()
      gc.collect()
      torch.cuda.empty_cache()







    def      lowercase_			( self					:    int      ):
      a		:   List[str]	  =	torch.manual_seed(51      )

      a		:   List[Any]	  =	StableDiffusionAttendAndExcitePipeline.from_pretrained(
          'CompVis/stable-diffusion-v1-4'		,     safety_checker=__snake_case		,     torch_dtype=torch.floataa      )
      pipe.to('cuda'      )

      a		:   Optional[int]	  =	'a painting of an elephant with glasses'
      a		:   int	  =	[5, 7]

      a		:   Optional[int]	  =	pipe(
          prompt=__snake_case		,     token_indices=__snake_case		,     guidance_scale=7.5		,     generator=__snake_case		,     num_inference_steps=5		,     max_iter_to_alter=5		,     output_type='numpy'		,     ).images[0]

      a		:   Optional[Any]	  =	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




'''simple docstring'''






import os

try:
     from .build_directory_md import good_file_paths
except ImportError:
     from build_directory_md import good_file_paths  # type: ignore

lowerCAmelCase:   Optional[int]					=		list(good_file_paths())
assert filepaths, "good_file_paths() failed!"

lowerCAmelCase:   Optional[Any]					=		[file for file in filepaths if file != file.lower()]
if upper_files:
     print(F"{len(upper_files)} files contain uppercase characters:")
     print('\n'.join(upper_files) + '\n')

lowerCAmelCase:   int					=		[file for file in filepaths if ' ' in file]
if space_files:
     print(F"{len(space_files)} files contain space characters:")
     print('\n'.join(space_files) + '\n')

lowerCAmelCase:   Union[str, Any]					=		[file for file in filepaths if '-' in file]
if hyphen_files:
     print(F"{len(hyphen_files)} files contain hyphen characters:")
     print('\n'.join(hyphen_files) + '\n')

lowerCAmelCase:   Union[str, Any]					=		[file for file in filepaths if os.sep not in file]
if nodir_files:
     print(F"{len(nodir_files)} files are not in a directory:")
     print('\n'.join(nodir_files) + '\n')

lowerCAmelCase:   int					=		len(upper_files + space_files + hyphen_files + nodir_files)
if bad_files:
     import sys

     sys.exit(bad_files)