


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


__UpperCAmelCase      :str			    =       False



@skip_mps
class      a    (		_a     ,  _a     ,  _a     ,  unittest.TestCase	):


     """simple docstring"""






     SCREAMING_SNAKE_CASE	:			Optional[Any]							       =       StableDiffusionAttendAndExcitePipeline
     SCREAMING_SNAKE_CASE	:			str							       =       False
     SCREAMING_SNAKE_CASE	:			Union[str, Any]							       =       TEXT_TO_IMAGE_PARAMS
     SCREAMING_SNAKE_CASE	:			List[Any]							       =       TEXT_TO_IMAGE_BATCH_PARAMS.union({"token_indices"}	)
     SCREAMING_SNAKE_CASE	:			List[str]							       =       TEXT_TO_IMAGE_IMAGE_PARAMS
     SCREAMING_SNAKE_CASE	:			Dict							       =       TEXT_TO_IMAGE_IMAGE_PARAMS

     @classmethod
     def 			lowerCamelCase__			(    cls					:		Dict      )						->							int:
          super().setUpClass()
          torch.use_deterministic_algorithms(snake_case      )

     @classmethod
     def 			lowerCamelCase__			(    cls					:		Any      )						->							Dict:
          super().tearDownClass()
          torch.use_deterministic_algorithms(snake_case      )

     def 			lowerCamelCase__			(    self					:		str      )						->							Union[str, Any]:
          torch.manual_seed(0      )
          __UpperCAmelCase     :			Optional[Any]  							=      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							,			)
          __UpperCAmelCase     :			List[str]  							=      DDIMScheduler(
              beta_start=0.00_085							,			beta_end=0.012							,			beta_schedule='''scaled_linear'''							,			clip_sample=snake_case							,			set_alpha_to_one=snake_case							,			)
          torch.manual_seed(0      )
          __UpperCAmelCase     :			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=128							,			)
          torch.manual_seed(0      )
          __UpperCAmelCase     :			Optional[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							,			)
          __UpperCAmelCase     :			str  							=      CLIPTextModel(snake_case      )
          __UpperCAmelCase     :			Any  							=      CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''      )

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

          return components

     def 			lowerCamelCase__			(    self					:		Optional[int]							,			snake_case					:		Dict							,			snake_case					:		Dict=0      )						->							List[Any]:
          if str(snake_case      ).startswith('''mps'''      ):
               __UpperCAmelCase     :			Any  							=      torch.manual_seed(snake_case      )
          else:
               __UpperCAmelCase     :			Union[str, Any]  							=      torch.Generator(device=snake_case      ).manual_seed(snake_case      )
          __UpperCAmelCase     :			List[Any]  							=      {
              '''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					:		int      )						->							Dict:
          __UpperCAmelCase     :			Union[str, Any]  							=      '''cpu'''

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

          __UpperCAmelCase     :			Dict  							=      self.get_dummy_inputs(snake_case      )
          __UpperCAmelCase     :			Optional[Any]  							=      pipe(**snake_case      ).images
          __UpperCAmelCase     :			int  							=      image[0, -3:, -3:, -1]

          self.assertEqual(image.shape							,			(1, 64, 64, 3)      )
          __UpperCAmelCase     :			Optional[Any]  							=      np.array(
              [0.63_905_364, 0.62_897_307, 0.48_599_017, 0.5_133_624, 0.5_550_048, 0.45_769_516, 0.50_326_973, 0.5_023_139, 0.45_384_496]      )
          __UpperCAmelCase     :			Optional[int]  							=      np.abs(image_slice.flatten() - expected_slice      ).max()
          self.assertLessEqual(snake_case							,			1E-3      )

     def 			lowerCamelCase__			(    self					:		Any      )						->							Optional[int]:
          super().test_cpu_offload_forward_pass(expected_max_diff=5E-4      )

     def 			lowerCamelCase__			(    self					:		Tuple      )						->							List[str]:
          # NOTE: Larger batch sizes cause this test to timeout, only test on smaller batches
          self._test_inference_batch_consistent(batch_sizes=[1, 2]      )

     def 			lowerCamelCase__			(    self					:		List[Any]      )						->							Union[str, Any]:
          self._test_inference_batch_single_identical(batch_size=2							,			expected_max_diff=7E-4      )

     def 			lowerCamelCase__			(    self					:		int      )						->							Dict:
          super().test_dict_tuple_outputs_equivalent(expected_max_difference=3E-3      )

     def 			lowerCamelCase__			(    self					:		str      )						->							Union[str, Any]:
          super().test_pt_np_pil_outputs_equivalent(expected_max_diff=5E-4      )

     def 			lowerCamelCase__			(    self					:		Tuple      )						->							Optional[int]:
          super().test_save_load_local(expected_max_difference=5E-4      )






     def 			lowerCamelCase__			(    self					:		List[str]      )						->							Optional[int]:
          super().test_save_load_optional_components(expected_max_difference=4E-4      )



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


     """simple docstring"""






     @classmethod
     def 			lowerCamelCase__			(    cls					:		str      )						->							str:
          super().setUpClass()
          torch.use_deterministic_algorithms(snake_case      )

     @classmethod
     def 			lowerCamelCase__			(    cls					:		List[str]      )						->							int:
          super().tearDownClass()
          torch.use_deterministic_algorithms(snake_case      )

     def 			lowerCamelCase__			(    self					:		Dict      )						->							Optional[int]:
          super().tearDown()
          gc.collect()
          torch.cuda.empty_cache()






     def 			lowerCamelCase__			(    self					:		Dict      )						->							Dict:
          __UpperCAmelCase     :			Optional[int]  							=      torch.manual_seed(51      )

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

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

          __UpperCAmelCase     :			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]

          __UpperCAmelCase     :			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'''



def      _a     (						_lowercase :     int = 600851475143  ):





     '''simple docstring'''






     try:
          __UpperCAmelCase     :			str  							=      int(_lowercase  )
     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     :			Dict  							=      1
     __UpperCAmelCase     :			List[str]  							=      2
     while i * i <= n:
          while n % i == 0:
               __UpperCAmelCase     :			int  							=      i
               n //= i
          i += 1
     if n > 1:
          __UpperCAmelCase     :			List[str]  							=      n
     return int(_lowercase  )


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