





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 					A     (__UpperCAmelCase							,__UpperCAmelCase							,__UpperCAmelCase							,unittest.TestCase					):
      _SCREAMING_SNAKE_CASE       =				StableUnCLIPPipeline
      _SCREAMING_SNAKE_CASE       =				TEXT_TO_IMAGE_PARAMS
      _SCREAMING_SNAKE_CASE       =				TEXT_TO_IMAGE_BATCH_PARAMS
      _SCREAMING_SNAKE_CASE       =				TEXT_TO_IMAGE_IMAGE_PARAMS
      _SCREAMING_SNAKE_CASE       =				TEXT_TO_IMAGE_IMAGE_PARAMS

      # TODO(will) Expected attn_bias.stride(1) == 0 to be true, but got false
      _SCREAMING_SNAKE_CASE       =				False



      def  __a			(       self       )   -> Dict:



             '''simple docstring'''

             _snake_case   :				int  					=    32
             _snake_case   :				Tuple  					=    embedder_hidden_size

             # prior components

             torch.manual_seed(0       )
             _snake_case   :				int  					=    CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''       )

             torch.manual_seed(0       )
             _snake_case   :				str  					=    CLIPTextModelWithProjection(
                 CLIPTextConfig(
                     bos_token_id=0  ,	eos_token_id=2  ,	hidden_size=snake_case__  ,	projection_dim=snake_case__  ,	intermediate_size=37  ,	layer_norm_eps=1E-05  ,	num_attention_heads=4  ,	num_hidden_layers=5  ,	pad_token_id=1  ,	vocab_size=1000  ,	)       )

             torch.manual_seed(0       )
             _snake_case   :				int  					=    PriorTransformer(
                 num_attention_heads=2  ,	attention_head_dim=12  ,	embedding_dim=snake_case__  ,	num_layers=1  ,	)

             torch.manual_seed(0       )
             _snake_case   :				Any  					=    DDPMScheduler(
                 variance_type='''fixed_small_log'''  ,	prediction_type='''sample'''  ,	num_train_timesteps=1000  ,	clip_sample=snake_case__  ,	clip_sample_range=5.0  ,	beta_schedule='''squaredcos_cap_v2'''  ,	)

             # regular denoising components

             torch.manual_seed(0       )
             _snake_case   :				Optional[Any]  					=    StableUnCLIPImageNormalizer(embedding_dim=snake_case__       )
             _snake_case   :				List[Any]  					=    DDPMScheduler(beta_schedule='''squaredcos_cap_v2'''       )

             torch.manual_seed(0       )
             _snake_case   :				List[str]  					=    CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''       )

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

             torch.manual_seed(0       )
             _snake_case   :				str  					=    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=snake_case__  ,	layers_per_block=1  ,	upcast_attention=snake_case__  ,	use_linear_projection=snake_case__  ,	)

             torch.manual_seed(0       )
             _snake_case   :				Tuple  					=    DDIMScheduler(
                 beta_schedule='''scaled_linear'''  ,	beta_start=0.0_0085  ,	beta_end=0.012  ,	prediction_type='''v_prediction'''  ,	set_alpha_to_one=snake_case__  ,	steps_offset=1  ,	)

             torch.manual_seed(0       )
             _snake_case   :				Optional[int]  					=    AutoencoderKL()

             _snake_case   :				Optional[int]  					=    {
                 # 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  __a			(       self  ,	lowercase_  ,	lowercase_=0       )   -> int:



             '''simple docstring'''

             if str(snake_case__       ).startswith('''mps'''       ):
                    _snake_case   :				Any  					=    torch.manual_seed(snake_case__       )
             else:
                    _snake_case   :				List[Any]  					=    torch.Generator(device=snake_case__       ).manual_seed(snake_case__       )
             _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  __a			(       self       )   -> Tuple:



             '''simple docstring'''

             _snake_case   :				Union[str, Any]  					=    torch_device == "cpu"

             self._test_attention_slicing_forward_pass(test_max_difference=snake_case__       )



      def  __a			(       self       )   -> int:



             '''simple docstring'''

             _snake_case   :				Union[str, Any]  					=    torch_device in ["cpu", "mps"]

             self._test_inference_batch_single_identical(test_max_difference=snake_case__       )


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



      def  __a			(       self       )   -> Dict:



             '''simple docstring'''

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



      def  __a			(       self       )   -> Any:



             '''simple docstring'''

             _snake_case   :				int  					=    load_numpy(
                 '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/stable_unclip/stable_unclip_2_1_l_anime_turtle_fp16.npy'''       )

             _snake_case   :				List[Any]  					=    StableUnCLIPPipeline.from_pretrained('''fusing/stable-unclip-2-1-l'''  ,	torch_dtype=torch.floataa       )
             pipe.to(snake_case__       )
             pipe.set_progress_bar_config(disable=snake_case__       )
             # 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()

             _snake_case   :				str  					=    torch.Generator(device='''cpu'''       ).manual_seed(0       )
             _snake_case   :				int  					=    pipe('''anime turle'''  ,	generator=snake_case__  ,	output_type='''np'''       )

             _snake_case   :				List[Any]  					=    output.images[0]

             assert image.shape == (768, 768, 3)

             assert_mean_pixel_difference(snake_case__  ,	snake_case__       )



      def  __a			(       self       )   -> int:



             '''simple docstring'''

             torch.cuda.empty_cache()
             torch.cuda.reset_max_memory_allocated()
             torch.cuda.reset_peak_memory_stats()

             _snake_case   :				List[Any]  					=    StableUnCLIPPipeline.from_pretrained('''fusing/stable-unclip-2-1-l'''  ,	torch_dtype=torch.floataa       )
             _snake_case   :				Optional[Any]  					=    pipe.to(snake_case__       )
             pipe.set_progress_bar_config(disable=snake_case__       )
             pipe.enable_attention_slicing()
             pipe.enable_sequential_cpu_offload()

             _snake_case   :				Any  					=    pipe(
                 '''anime turtle'''  ,	prior_num_inference_steps=2  ,	num_inference_steps=2  ,	output_type='''np'''  ,	)

             _snake_case   :				Union[str, Any]  					=    torch.cuda.max_memory_allocated()
             # make sure that less than 7 GB is allocated
             assert mem_bytes < 7 * 10**9








'''simple docstring'''





import math







def snake_case_     (					lowercase__		):

  if 1 < number < 4:
    # 2 and 3 are primes
    return True
  elif number < 2 or number % 2 == 0 or number % 3 == 0:
    # Negatives, 0, 1, all even numbers, all multiples of 3 are not primes
    return False

  # All primes number are in format of 6k +/- 1
  for i in range(5   ,       int(math.sqrt(lowercase__		) + 1		)   ,       6		):
    if number % i == 0 or number % (i + 2) == 0:
      return False
  return True







def snake_case_     (					lowercase__ = 0.1		):
  UpperCAmelCase__      :					Dict				       =							3
  UpperCAmelCase__      :					Tuple				       =							3

  while primes / (2 * j - 1) >= ratio:
    for i in range(j * j + j + 1   ,       (j + 2) * (j + 2)   ,       j + 1		):
      primes += is_prime(lowercase__		)
    j += 2
  return j


if __name__ == "__main__":
      import doctest

      doctest.testmod()



