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


__magic_name__								=False



@skip_mps
class     _A   (    __UpperCamelCase	, __UpperCamelCase	, __UpperCamelCase	, unittest.TestCase							):
  SCREAMING_SNAKE_CASE_	:	str						=StableDiffusionAttendAndExcitePipeline
  SCREAMING_SNAKE_CASE_	:	Any						=False
  SCREAMING_SNAKE_CASE_	:	List[str]						=TEXT_TO_IMAGE_PARAMS
  SCREAMING_SNAKE_CASE_	:	Optional[Any]						=TEXT_TO_IMAGE_BATCH_PARAMS.union({"token_indices"}							)
  SCREAMING_SNAKE_CASE_	:	List[str]						=TEXT_TO_IMAGE_IMAGE_PARAMS
  SCREAMING_SNAKE_CASE_	:	Any						=TEXT_TO_IMAGE_IMAGE_PARAMS






  @classmethod
  def 		_a					(cls	)		->      Optional[Any]:





       '''simple docstring'''





       super().setUpClass()
       torch.use_deterministic_algorithms(SCREAMING_SNAKE_CASE_	)






  @classmethod
  def 		_a					(cls	)		->      Tuple:





       '''simple docstring'''





       super().tearDownClass()
       torch.use_deterministic_algorithms(SCREAMING_SNAKE_CASE_	)






  def 		_a					(self	)		->      List[str]:





       '''simple docstring'''





       torch.manual_seed(0	)
       UpperCamelCase__										=      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=SCREAMING_SNAKE_CASE_   ,				)
       UpperCamelCase__										=      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	)
       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   ,				sample_size=128   ,				)
       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   ,				hidden_act='''gelu'''   ,				projection_dim=512   ,				)
       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 		_a					(self   ,				SCREAMING_SNAKE_CASE_   ,				SCREAMING_SNAKE_CASE_=0	)		->      List[Any]:





       '''simple docstring'''





       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__										=      UpperCamelCase__										=      {
           '''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 		_a					(self	)		->      Any:





       '''simple docstring'''





       UpperCamelCase__										=      '''cpu'''

       UpperCamelCase__										=      self.get_dummy_components()
       UpperCamelCase__										=      self.pipeline_class(**SCREAMING_SNAKE_CASE_	)
       pipe.to(SCREAMING_SNAKE_CASE_	)
       pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE_	)

       UpperCamelCase__										=      self.get_dummy_inputs(SCREAMING_SNAKE_CASE_	)
       UpperCamelCase__										=      pipe(**SCREAMING_SNAKE_CASE_	).images
       UpperCamelCase__										=      image[0, -3:, -3:, -1]

       self.assertEqual(image.shape   ,				(1, 64, 64, 3)	)
       UpperCamelCase__										=      np.array(
           [0.63905364, 0.62897307, 0.48599017, 0.5133624, 0.5550048, 0.45769516, 0.50326973, 0.5023139, 0.45384496]	)
       UpperCamelCase__										=      np.abs(image_slice.flatten() - expected_slice	).max()
       self.assertLessEqual(SCREAMING_SNAKE_CASE_   ,				1E-3	)






  def 		_a					(self	)		->      Union[str, Any]:





       '''simple docstring'''





       super().test_cpu_offload_forward_pass(expected_max_diff=5E-4	)






  def 		_a					(self	)		->      List[str]:





       '''simple docstring'''





       self._test_inference_batch_consistent(batch_sizes=[1, 2]	)






  def 		_a					(self	)		->      Union[str, Any]:





       '''simple docstring'''





       self._test_inference_batch_single_identical(batch_size=2   ,				expected_max_diff=7E-4	)






  def 		_a					(self	)		->      Tuple:





       '''simple docstring'''





       super().test_dict_tuple_outputs_equivalent(expected_max_difference=3E-3	)






  def 		_a					(self	)		->      List[Any]:





       '''simple docstring'''





       super().test_pt_np_pil_outputs_equivalent(expected_max_diff=5E-4	)






  def 		_a					(self	)		->      str:





       '''simple docstring'''





       super().test_save_load_local(expected_max_difference=5E-4	)






  def 		_a					(self	)		->      Optional[Any]:





       '''simple docstring'''





       super().test_save_load_optional_components(expected_max_difference=4E-4	)



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






  @classmethod
  def 		_a					(cls	)		->      List[Any]:





       '''simple docstring'''





       super().setUpClass()
       torch.use_deterministic_algorithms(SCREAMING_SNAKE_CASE_	)






  @classmethod
  def 		_a					(cls	)		->      Dict:





       '''simple docstring'''





       super().tearDownClass()
       torch.use_deterministic_algorithms(SCREAMING_SNAKE_CASE_	)






  def 		_a					(self	)		->      Dict:





       '''simple docstring'''





       super().tearDown()
       gc.collect()
       torch.cuda.empty_cache()






  def 		_a					(self	)		->      int:





       '''simple docstring'''





       UpperCamelCase__										=      torch.manual_seed(51	)

       UpperCamelCase__										=      StableDiffusionAttendAndExcitePipeline.from_pretrained(
           '''CompVis/stable-diffusion-v1-4'''   ,				safety_checker=SCREAMING_SNAKE_CASE_   ,				torch_dtype=torch.floataa	)
       pipe.to('''cuda'''	)

       UpperCamelCase__										=      '''a painting of an elephant with glasses'''
       UpperCamelCase__										=      [5, 7]

       UpperCamelCase__										=      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]

       UpperCamelCase__										=      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




def  __UpperCamelCase    (						A = 600851475143							):

     try:
          UpperCamelCase__										=      int(A							)
     except (TypeError, ValueError):
          raise TypeError('''Parameter n must be int or castable to int.'''							)
     if n <= 0:
          raise ValueError('''Parameter n must be greater than or equal to one.'''							)
     UpperCamelCase__										=      1
     UpperCamelCase__										=      2
     while i * i <= n:
          while n % i == 0:
               UpperCamelCase__										=      i
               n //= i
          i += 1
     if n > 1:
          UpperCamelCase__										=      n
     return int(A							)


if __name__ == "__main__":
     print(f"""{solution() = }""")



