


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


__A   :    str											= False






@skip_mps
class   __snake_case			(  _SCREAMING_SNAKE_CASE      ,_SCREAMING_SNAKE_CASE      ,_SCREAMING_SNAKE_CASE      ,unittest.TestCase):







    """simple docstring"""



    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						)  ->    Optional[int]:
      super().setUpClass()
      torch.use_deterministic_algorithms(lowerCamelCase						)

    @classmethod
    def __lowercase  (  cls       :    Union[str, Any]						)  ->    Optional[int]:
      super().tearDownClass()
      torch.use_deterministic_algorithms(lowerCamelCase						)

    def __lowercase  (  self       :    str						)  ->    str:
      torch.manual_seed(0						)
      lowerCAmelCase_     : List[str]     =  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=lowerCamelCase       ,		)
      lowerCAmelCase_     : List[Any]     =  DDIMScheduler(
          beta_start=0.00_085       ,		beta_end=0.012       ,		beta_schedule="""scaled_linear"""       ,		clip_sample=lowerCamelCase       ,		set_alpha_to_one=lowerCamelCase       ,		)
      torch.manual_seed(0						)
      lowerCAmelCase_     : List[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						)
      lowerCAmelCase_     : str     =  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=10_00       ,		hidden_act="""gelu"""       ,		projection_dim=5_12       ,		)
      lowerCAmelCase_     : str     =  CLIPTextModel(lowerCamelCase						)
      lowerCAmelCase_     : Union[str, Any]     =  CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""						)

      lowerCAmelCase_     : 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       ,		lowerCamelCase       :    str       ,		lowerCamelCase       :    Dict=0						)  ->    Optional[Any]:
      if str(lowerCamelCase						).startswith("""mps"""						):
        lowerCAmelCase_     : Optional[Any]     =  torch.manual_seed(lowerCamelCase						)
      else:
        lowerCAmelCase_     : Any     =  torch.Generator(device=lowerCamelCase						).manual_seed(lowerCamelCase						)
      lowerCAmelCase_     : 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 __lowercase  (  self       :    int						)  ->    List[Any]:
      lowerCAmelCase_     : Optional[Any]     =  """cpu"""

      lowerCAmelCase_     : Dict     =  self.get_dummy_components()
      lowerCAmelCase_     : List[str]     =  self.pipeline_class(**lowerCamelCase						)
      pipe.to(lowerCamelCase						)
      pipe.set_progress_bar_config(disable=lowerCamelCase						)

      lowerCAmelCase_     : Any     =  self.get_dummy_inputs(lowerCamelCase						)
      lowerCAmelCase_     : Union[str, Any]     =  pipe(**lowerCamelCase						).images
      lowerCAmelCase_     : Dict     =  image[0, -3:, -3:, -1]

      self.assertEqual(image.shape       ,		(1, 64, 64, 3)						)
      lowerCAmelCase_     : Optional[int]     =  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]						)
      lowerCAmelCase_     : Optional[Any]     =  np.abs(image_slice.flatten() - expected_slice						).max()
      self.assertLessEqual(lowerCamelCase       ,		1E-3						)

    def __lowercase  (  self       :    Any						)  ->    List[Any]:
      super().test_cpu_offload_forward_pass(expected_max_diff=5E-4						)

    def __lowercase  (  self       :    List[Any]						)  ->    Dict:
      # 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       :    int						)  ->    Any:
      self._test_inference_batch_single_identical(batch_size=2       ,		expected_max_diff=7E-4						)

    def __lowercase  (  self       :    Union[str, Any]						)  ->    int:
      super().test_dict_tuple_outputs_equivalent(expected_max_difference=3E-3						)

    def __lowercase  (  self       :    Optional[Any]						)  ->    Dict:
      super().test_pt_np_pil_outputs_equivalent(expected_max_diff=5E-4						)

    def __lowercase  (  self       :    str						)  ->    int:
      super().test_save_load_local(expected_max_difference=5E-4						)





    def __lowercase  (  self       :    List[str]						)  ->    Dict:
      super().test_save_load_optional_components(expected_max_difference=4E-4						)







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







    """simple docstring"""



    @classmethod
    def __lowercase  (  cls       :    Optional[Any]						)  ->    Tuple:
      super().setUpClass()
      torch.use_deterministic_algorithms(lowerCamelCase						)

    @classmethod
    def __lowercase  (  cls       :    Optional[int]						)  ->    int:
      super().tearDownClass()
      torch.use_deterministic_algorithms(lowerCamelCase						)

    def __lowercase  (  self       :    List[str]						)  ->    str:
      super().tearDown()
      gc.collect()
      torch.cuda.empty_cache()





    def __lowercase  (  self       :    int						)  ->    int:
      lowerCAmelCase_     : int     =  torch.manual_seed(51						)

      lowerCAmelCase_     : int     =  StableDiffusionAttendAndExcitePipeline.from_pretrained(
          """CompVis/stable-diffusion-v1-4"""       ,		safety_checker=lowerCamelCase       ,		torch_dtype=torch.floataa						)
      pipe.to("""cuda"""						)

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

      lowerCAmelCase_     : Union[str, Any]     =  pipe(
          prompt=lowerCamelCase       ,		token_indices=lowerCamelCase       ,		guidance_scale=7.5       ,		generator=lowerCamelCase       ,		num_inference_steps=5       ,		max_iter_to_alter=5       ,		output_type="""numpy"""       ,		).images[0]

      lowerCAmelCase_     : Union[str, 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'''






from maths.is_square_free import is_square_free
from maths.prime_factors import prime_factors







def 							UpperCamelCase_     (       A__   :  int   ):
  '''simple docstring'''





  lowerCAmelCase_     : Any     =  prime_factors(A__   )
  if is_square_free(A__   ):
    return -1 if len(A__   ) % 2 else 1
  return 0


if __name__ == "__main__":
  import doctest

  doctest.testmod()



