


"""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


__snake_case       =       False







@skip_mps
class _lowerCAmelCase							( snake_case__       ,				snake_case__       ,				snake_case__       ,				unittest.TestCase      ):
   __UpperCAmelCase					:			Optional[int]				    =    StableDiffusionAttendAndExcitePipeline
   __UpperCAmelCase					:			Union[str, Any]				    =    False
   __UpperCAmelCase					:			Dict				    =    TEXT_TO_IMAGE_PARAMS
   __UpperCAmelCase					:			List[str]				    =    TEXT_TO_IMAGE_BATCH_PARAMS.union({'''token_indices'''}      )
   __UpperCAmelCase					:			Optional[int]				    =    TEXT_TO_IMAGE_IMAGE_PARAMS
   __UpperCAmelCase					:			List[Any]				    =    TEXT_TO_IMAGE_IMAGE_PARAMS







   @classmethod
   def 					lowerCamelCase						(      cls		)      ->						int:

       '''simple docstring'''




       super().setUpClass()
       torch.use_deterministic_algorithms(UpperCamelCase__		)







   @classmethod
   def 					lowerCamelCase						(      cls		)      ->						Any:

       '''simple docstring'''




       super().tearDownClass()
       torch.use_deterministic_algorithms(UpperCamelCase__		)







   def 					lowerCamelCase						(      self		)      ->						str:

       '''simple docstring'''




       torch.manual_seed(0		)
       snake_case       : int    =       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=UpperCamelCase__		,      )
       snake_case       : Dict    =       DDIMScheduler(
           beta_start=0.00085		,      beta_end=0.012		,      beta_schedule="scaled_linear"		,      clip_sample=UpperCamelCase__		,      set_alpha_to_one=UpperCamelCase__		,      )
       torch.manual_seed(0		)
       snake_case       : 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		,      sample_size=128		,      )
       torch.manual_seed(0		)
       snake_case       : List[Any]    =       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		,      )
       snake_case       : Any    =       CLIPTextModel(UpperCamelCase__		)
       snake_case       : int    =       CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"		)

       snake_case       : Optional[Any]    =       {
           'unet': unet,
           'scheduler': scheduler,
           'vae': vae,
           'text_encoder': text_encoder,
           'tokenizer': tokenizer,
           'safety_checker': None,
           'feature_extractor': None,
       }

       return components







   def 					lowerCamelCase						(      self		,      UpperCamelCase__		,      UpperCamelCase__=0		)      ->						str:

       '''simple docstring'''




       if str(UpperCamelCase__		).startswith("mps"		):
           snake_case       : Union[str, Any]    =       torch.manual_seed(UpperCamelCase__		)
       else:
           snake_case       : Optional[Any]    =       torch.Generator(device=UpperCamelCase__		).manual_seed(UpperCamelCase__		)
       snake_case       : Dict    =       {
           '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 					lowerCamelCase						(      self		)      ->						Any:

       '''simple docstring'''




       snake_case       : List[Any]    =       'cpu'

       snake_case       : List[Any]    =       self.get_dummy_components()
       snake_case       : List[str]    =       self.pipeline_class(**UpperCamelCase__		)
       pipe.to(UpperCamelCase__		)
       pipe.set_progress_bar_config(disable=UpperCamelCase__		)

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

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







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

       '''simple docstring'''




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







   def 					lowerCamelCase						(      self		)      ->						str:

       '''simple docstring'''




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







   def 					lowerCamelCase						(      self		)      ->						int:

       '''simple docstring'''




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







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

       '''simple docstring'''




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







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

       '''simple docstring'''




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







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

       '''simple docstring'''




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







   def 					lowerCamelCase						(      self		)      ->						Dict:

       '''simple docstring'''




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







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







   @classmethod
   def 					lowerCamelCase						(      cls		)      ->						Any:

       '''simple docstring'''




       super().setUpClass()
       torch.use_deterministic_algorithms(UpperCamelCase__		)







   @classmethod
   def 					lowerCamelCase						(      cls		)      ->						Tuple:

       '''simple docstring'''




       super().tearDownClass()
       torch.use_deterministic_algorithms(UpperCamelCase__		)







   def 					lowerCamelCase						(      self		)      ->						Optional[int]:

       '''simple docstring'''




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







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

       '''simple docstring'''




       snake_case       : Optional[Any]    =       torch.manual_seed(51		)

       snake_case       : Any    =       StableDiffusionAttendAndExcitePipeline.from_pretrained(
           "CompVis/stable-diffusion-v1-4"		,      safety_checker=UpperCamelCase__		,      torch_dtype=torch.floataa		)
       pipe.to("cuda"		)

       snake_case       : List[Any]    =       'a painting of an elephant with glasses'
       snake_case       : Tuple    =       [5, 7]

       snake_case       : List[str]    =       pipe(
           prompt=UpperCamelCase__		,      token_indices=UpperCamelCase__		,      guidance_scale=7.5		,      generator=UpperCamelCase__		,      num_inference_steps=5		,      max_iter_to_alter=5		,      output_type="numpy"		,      ).images[0]

       snake_case       : 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












def 		_SCREAMING_SNAKE_CASE     ( lowerCAmelCase__=2_81_23						):
		lowerCamelCase_	:     Any 						=      [1] * (limit + 1)

		for i in range(2							,int(limit**0.5						) + 1						):
				sum_divs[i * i] += i
				for k in range(i + 1							,limit // i + 1						):
						sum_divs[k * i] += k + i

		lowerCamelCase_	:     List[str] 						=      set()
		lowerCamelCase_	:     List[str] 						=      0

		for n in range(1							,limit + 1						):
				if sum_divs[n] > n:
						abundants.add(lowerCAmelCase__						)

				if not any((n - a in abundants) for a in abundants						):
						res += n

		return res


if __name__ == "__main__":
		print(solution())
