


import gc
import unittest

import torch
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTextModelWithProjection, CLIPTokenizer

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    DDPMScheduler,
    PriorTransformer,
    StableUnCLIPPipeline,
    UNetaDConditionModel,
)
from diffusers.pipelines.stable_diffusion.stable_unclip_image_normalizer import StableUnCLIPImageNormalizer
from diffusers.utils.testing_utils import enable_full_determinism, load_numpy, require_torch_gpu, slow, torch_device

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,
    assert_mean_pixel_difference,
)


enable_full_determinism()



class 						_UpperCAmelCase      (     _SCREAMING_SNAKE_CASE		,		_SCREAMING_SNAKE_CASE		,		_SCREAMING_SNAKE_CASE		,		unittest.TestCase							):
		lowerCamelCase_	:			str       			=  StableUnCLIPPipeline
		lowerCamelCase_	:			Any       			=  TEXT_TO_IMAGE_PARAMS
		lowerCamelCase_	:			Any       			=  TEXT_TO_IMAGE_BATCH_PARAMS
		lowerCamelCase_	:			Tuple       			=  TEXT_TO_IMAGE_IMAGE_PARAMS
		lowerCamelCase_	:			List[Any]       			=  TEXT_TO_IMAGE_IMAGE_PARAMS

		# TODO(will) Expected attn_bias.stride(1) == 0 to be true, but got false
		lowerCamelCase_	:			Optional[int]       			=  False






		def _snake_case		(						self				:     Optional[Any]):
				SCREAMING_SNAKE_CASE_				:List[str]				     =						32
				SCREAMING_SNAKE_CASE_				:Any				     =						embedder_hidden_size

				# prior components

				torch.manual_seed(0)
				SCREAMING_SNAKE_CASE_				:Union[str, Any]				     =						CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip")

				torch.manual_seed(0)
				SCREAMING_SNAKE_CASE_				:Any				     =						CLIPTextModelWithProjection(
				    CLIPTextConfig(
				        bos_token_id=0   ,  eos_token_id=2   ,  hidden_size=UpperCAmelCase   ,  projection_dim=UpperCAmelCase   ,  intermediate_size=37   ,  layer_norm_eps=1E-05   ,  num_attention_heads=4   ,  num_hidden_layers=5   ,  pad_token_id=1   ,  vocab_size=10_00   ,  ))

				torch.manual_seed(0)
				SCREAMING_SNAKE_CASE_				:Dict				     =						PriorTransformer(
				    num_attention_heads=2   ,  attention_head_dim=12   ,  embedding_dim=UpperCAmelCase   ,  num_layers=1   ,  )

				torch.manual_seed(0)
				SCREAMING_SNAKE_CASE_				:Optional[int]				     =						DDPMScheduler(
				    variance_type="fixed_small_log"   ,  prediction_type="sample"   ,  num_train_timesteps=10_00   ,  clip_sample=UpperCAmelCase   ,  clip_sample_range=5.0   ,  beta_schedule="squaredcos_cap_v2"   ,  )

				# regular denoising components

				torch.manual_seed(0)
				SCREAMING_SNAKE_CASE_				:List[Any]				     =						StableUnCLIPImageNormalizer(embedding_dim=UpperCAmelCase)
				SCREAMING_SNAKE_CASE_				:Any				     =						DDPMScheduler(beta_schedule="squaredcos_cap_v2")

				torch.manual_seed(0)
				SCREAMING_SNAKE_CASE_				:Optional[int]				     =						CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip")

				torch.manual_seed(0)
				SCREAMING_SNAKE_CASE_				:Optional[int]				     =						CLIPTextModel(
				    CLIPTextConfig(
				        bos_token_id=0   ,  eos_token_id=2   ,  hidden_size=UpperCAmelCase   ,  projection_dim=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   ,  ))

				torch.manual_seed(0)
				SCREAMING_SNAKE_CASE_				:List[Any]				     =						UNetaDConditionModel(
				    sample_size=32   ,  in_channels=4   ,  out_channels=4   ,  down_block_types=("CrossAttnDownBlock2D", "DownBlock2D")   ,  up_block_types=("UpBlock2D", "CrossAttnUpBlock2D")   ,  block_out_channels=(32, 64)   ,  attention_head_dim=(2, 4)   ,  class_embed_type="projection"   ,  projection_class_embeddings_input_dim=embedder_projection_dim * 2   ,  cross_attention_dim=UpperCAmelCase   ,  layers_per_block=1   ,  upcast_attention=UpperCAmelCase   ,  use_linear_projection=UpperCAmelCase   ,  )

				torch.manual_seed(0)
				SCREAMING_SNAKE_CASE_				:Union[str, Any]				     =						DDIMScheduler(
				    beta_schedule="scaled_linear"   ,  beta_start=0.00085   ,  beta_end=0.012   ,  prediction_type="v_prediction"   ,  set_alpha_to_one=UpperCAmelCase   ,  steps_offset=1   ,  )

				torch.manual_seed(0)
				SCREAMING_SNAKE_CASE_				:Tuple				     =						AutoencoderKL()

				SCREAMING_SNAKE_CASE_				:Dict				     =						{
				    # prior components
				    """prior_tokenizer""": prior_tokenizer,
				    """prior_text_encoder""": prior_text_encoder,
				    """prior""": prior,
				    """prior_scheduler""": prior_scheduler,
				    # image noising components
				    """image_normalizer""": image_normalizer,
				    """image_noising_scheduler""": image_noising_scheduler,
				    # regular denoising components
				    """tokenizer""": tokenizer,
				    """text_encoder""": text_encoder,
				    """unet""": unet,
				    """scheduler""": scheduler,
				    """vae""": vae,
				}

				return components






		def _snake_case		(						self				:     Optional[int]   ,  UpperCAmelCase				:     Optional[Any]   ,  UpperCAmelCase				:     Dict=0):
				if str(UpperCAmelCase).startswith("mps"):
						SCREAMING_SNAKE_CASE_				:int				     =						torch.manual_seed(UpperCAmelCase)
				else:
						SCREAMING_SNAKE_CASE_				:Optional[int]				     =						torch.Generator(device=UpperCAmelCase).manual_seed(UpperCAmelCase)
				SCREAMING_SNAKE_CASE_				:List[str]				     =						{
				    """prompt""": """A painting of a squirrel eating a burger""",
				    """generator""": generator,
				    """num_inference_steps""": 2,
				    """prior_num_inference_steps""": 2,
				    """output_type""": """numpy""",
				}
				return inputs






		def _snake_case		(						self				:     List[Any]):
				SCREAMING_SNAKE_CASE_				:Optional[int]				     =						torch_device == """cpu"""

				self._test_attention_slicing_forward_pass(test_max_difference=UpperCAmelCase)







		def _snake_case		(						self				:     Dict):
				SCREAMING_SNAKE_CASE_				:Optional[int]				     =						torch_device in ["""cpu""", """mps"""]

				self._test_inference_batch_single_identical(test_max_difference=UpperCAmelCase)




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






		def _snake_case		(						self				:     Optional[Any]):
				# clean up the VRAM after each test
				super().tearDown()
				gc.collect()
				torch.cuda.empty_cache()






		def _snake_case		(						self				:     Tuple):
				SCREAMING_SNAKE_CASE_				:Union[str, Any]				     =						load_numpy(
				    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/stable_unclip/stable_unclip_2_1_l_anime_turtle_fp16.npy")

				SCREAMING_SNAKE_CASE_				:Dict				     =						StableUnCLIPPipeline.from_pretrained("fusing/stable-unclip-2-1-l"   ,  torch_dtype=torch.floataa)
				pipe.to(UpperCAmelCase)
				pipe.set_progress_bar_config(disable=UpperCAmelCase)
				# stable unclip will oom when integration tests are run on a V100,
				# so turn on memory savings
				pipe.enable_attention_slicing()
				pipe.enable_sequential_cpu_offload()

				SCREAMING_SNAKE_CASE_				:Dict				     =						torch.Generator(device="cpu").manual_seed(0)
				SCREAMING_SNAKE_CASE_				:Union[str, Any]				     =						pipe("anime turle"   ,  generator=UpperCAmelCase   ,  output_type="np")

				SCREAMING_SNAKE_CASE_				:Tuple				     =						output.images[0]

				assert image.shape == (7_68, 7_68, 3)

				assert_mean_pixel_difference(UpperCAmelCase   ,  UpperCAmelCase)







		def _snake_case		(						self				:     int):
				torch.cuda.empty_cache()
				torch.cuda.reset_max_memory_allocated()
				torch.cuda.reset_peak_memory_stats()

				SCREAMING_SNAKE_CASE_				:Dict				     =						StableUnCLIPPipeline.from_pretrained("fusing/stable-unclip-2-1-l"   ,  torch_dtype=torch.floataa)
				SCREAMING_SNAKE_CASE_				:Any				     =						pipe.to(UpperCAmelCase)
				pipe.set_progress_bar_config(disable=UpperCAmelCase)
				pipe.enable_attention_slicing()
				pipe.enable_sequential_cpu_offload()

				SCREAMING_SNAKE_CASE_				:str				     =						pipe(
				    "anime turtle"   ,  prior_num_inference_steps=2   ,  num_inference_steps=2   ,  output_type="np"   ,  )

				SCREAMING_SNAKE_CASE_				:Any				     =						torch.cuda.max_memory_allocated()
				# make sure that less than 7 GB is allocated
				assert mem_bytes < 7 * 10**9










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



