

"""simple docstring"""




import gc
import random
import unittest

import numpy as np
import torch
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTextModelWithProjection, CLIPTokenizer

from diffusers import (
    AutoencoderKL,
    DiffusionPipeline,
    EulerDiscreteScheduler,
    StableDiffusionXLImgaImgPipeline,
    UNetaDConditionModel,
)
from diffusers.utils import floats_tensor, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

from ..pipeline_params import (
    IMAGE_TO_IMAGE_IMAGE_PARAMS,
    TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS,
    TEXT_GUIDED_IMAGE_VARIATION_PARAMS,
)
from ..test_pipelines_common import PipelineLatentTesterMixin, PipelineTesterMixin


enable_full_determinism()


class 				SCREAMING_SNAKE_CASE__ (_SCREAMING_SNAKE_CASE		,	_SCREAMING_SNAKE_CASE		,	unittest.TestCase					):
    __lowerCamelCase						:	Optional[Any]														=					StableDiffusionXLImgaImgPipeline
    __lowerCamelCase						:	Dict														=					TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {"""height""", """width"""}
    __lowerCamelCase						:	Dict														=					PipelineTesterMixin.required_optional_params - {"""latents"""}
    __lowerCamelCase						:	Dict														=					TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS
    __lowerCamelCase						:	Any														=					IMAGE_TO_IMAGE_IMAGE_PARAMS
    __lowerCamelCase						:	int														=					IMAGE_TO_IMAGE_IMAGE_PARAMS





    def 				snake_case_    (				self):
         torch.manual_seed(0)
         lowercase__   :       Tuple				=	UNetaDConditionModel(
             block_out_channels=(32, 64)						,       layers_per_block=2						,       sample_size=32						,       in_channels=4						,       out_channels=4						,       down_block_types=('DownBlock2D', 'CrossAttnDownBlock2D')						,       up_block_types=('CrossAttnUpBlock2D', 'UpBlock2D')						,       attention_head_dim=(2, 4)						,       use_linear_projection=a						,       addition_embed_type='text_time'						,       addition_time_embed_dim=8						,       transformer_layers_per_block=(1, 2)						,       projection_class_embeddings_input_dim=80						,       cross_attention_dim=64						,       )
         lowercase__   :       Tuple				=	EulerDiscreteScheduler(
             beta_start=0.00_085						,       beta_end=0.012						,       steps_offset=1						,       beta_schedule='scaled_linear'						,       timestep_spacing='leading'						,       )
         torch.manual_seed(0)
         lowercase__   :       Optional[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)
         lowercase__   :       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=1000						,       hidden_act='gelu'						,       projection_dim=32						,       )
         lowercase__   :       Optional[int]				=	CLIPTextModel(a)
         lowercase__   :       Any				=	CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'						,       local_files_only=a)

         lowercase__   :       Tuple				=	CLIPTextModelWithProjection(a)
         lowercase__   :       int				=	CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'						,       local_files_only=a)

         lowercase__   :       Union[str, Any]				=	{
             'unet': unet,
             'scheduler': scheduler,
             'vae': vae,
             'text_encoder': text_encoder,
             'tokenizer': tokenizer,
             'text_encoder_2': text_encoder_a,
             'tokenizer_2': tokenizer_a,
             # "safety_checker": None,
             # "feature_extractor": None,
         }
         return components





    def 				snake_case_    (				self						,       a						,       a=0):
         lowercase__   :       int				=	floats_tensor((1, 3, 32, 32)						,       rng=random.Random(a)).to(a)
         lowercase__   :       Union[str, Any]				=	image / 2 + 0.5
         if str(a).startswith('mps'):
              lowercase__   :       List[Any]				=	torch.manual_seed(a)
         else:
              lowercase__   :       Any				=	torch.Generator(device=a).manual_seed(a)
         lowercase__   :       Optional[int]				=	{
             'prompt': 'A painting of a squirrel eating a burger',
             'image': image,
             'generator': generator,
             'num_inference_steps': 2,
             'guidance_scale': 5.0,
             'output_type': 'numpy',
             'strength': 0.75,
         }
         return inputs





    def 				snake_case_    (				self):
         lowercase__   :       List[Any]				=	'cpu'  # ensure determinism for the device-dependent torch.Generator
         lowercase__   :       Dict				=	self.get_dummy_components()
         lowercase__   :       List[Any]				=	StableDiffusionXLImgaImgPipeline(**a)
         lowercase__   :       Dict				=	sd_pipe.to(a)
         sd_pipe.set_progress_bar_config(disable=a)

         lowercase__   :       Optional[Any]				=	self.get_dummy_inputs(a)
         lowercase__   :       Optional[int]				=	sd_pipe(**a).images
         lowercase__   :       List[Any]				=	image[0, -3:, -3:, -1]

         assert image.shape == (1, 32, 32, 3)

         lowercase__   :       Union[str, Any]				=	np.array([0.4_656, 0.4_840, 0.4_439, 0.6_698, 0.5_574, 0.4_524, 0.5_799, 0.5_943, 0.5_165])

         assert np.abs(image_slice.flatten() - expected_slice).max() < 1e-2





    def 				snake_case_    (				self):
         super().test_attention_slicing_forward_pass(expected_max_diff=3e-3)





    def 				snake_case_    (				self):
         super().test_inference_batch_single_identical(expected_max_diff=3e-3)





    def 				snake_case_    (				self):
         pass





    def 				snake_case_    (				self):
         lowercase__   :       Optional[Any]				=	self.get_dummy_components()
         lowercase__   :       Dict				=	StableDiffusionXLImgaImgPipeline(**a)
         lowercase__   :       Dict				=	sd_pipe.to(a)
         lowercase__   :       Tuple				=	sd_pipe.to(a)
         sd_pipe.set_progress_bar_config(disable=a)

         # forward without prompt embeds
         lowercase__   :       Any				=	self.get_dummy_inputs(a)
         lowercase__   :       Union[str, Any]				=	3 * ['this is a negative prompt']
         lowercase__   :       int				=	negative_prompt
         lowercase__   :       List[str]				=	3 * [inputs['prompt']]

         lowercase__   :       str				=	sd_pipe(**a)
         lowercase__   :       Tuple				=	output.images[0, -3:, -3:, -1]

         # forward with prompt embeds
         lowercase__   :       Tuple				=	self.get_dummy_inputs(a)
         lowercase__   :       int				=	3 * ['this is a negative prompt']
         lowercase__   :       List[Any]				=	3 * [inputs.pop('prompt')]

         (
             (
             lowercase__				
         )				,			(
             lowercase__				
         )				,			(
             lowercase__				
         )				,			(
             lowercase__				
         )				,							
         )   :       List[Any]				=	sd_pipe.encode_prompt(a						,       negative_prompt=a)

         lowercase__   :       Dict				=	sd_pipe(
             **a						,       prompt_embeds=a						,       negative_prompt_embeds=a						,       pooled_prompt_embeds=a						,       negative_pooled_prompt_embeds=a						,       )
         lowercase__   :       Any				=	output.images[0, -3:, -3:, -1]

         # make sure that it's equal
         assert np.abs(image_slice_a.flatten() - image_slice_a.flatten()).max() < 1e-4



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





    def 				snake_case_    (				self):
         super().tearDown()
         gc.collect()
         torch.cuda.empty_cache()





    def 				snake_case_    (				self						,       a						,       a="cpu"						,       a=torch.floataa						,       a=0):
         lowercase__   :       Optional[int]				=	torch.Generator(device=a).manual_seed(a)
         lowercase__   :       Optional[Any]				=	np.random.RandomState(a).standard_normal((1, 4, 64, 64))
         lowercase__   :       Optional[Any]				=	torch.from_numpy(a).to(device=a						,       dtype=a)
         lowercase__   :       Any				=	{
             'prompt': 'a photograph of an astronaut riding a horse',
             'latents': latents,
             'generator': generator,
             'num_inference_steps': 3,
             'guidance_scale': 7.5,
             'output_type': 'numpy',
         }
         return inputs





    def 				snake_case_    (				self):
         lowercase__   :       int				=	DiffusionPipeline.from_pretrained('stabilityai/stable-diffusion-2-base')
         pipe.to(a)
         pipe.set_progress_bar_config(disable=a)

         lowercase__   :       str				=	self.get_inputs(a)
         lowercase__   :       int				=	pipe(**a).images
         lowercase__   :       Optional[int]				=	image[0, -3:, -3:, -1].flatten()

         assert image.shape == (1, 512, 512, 3)
         lowercase__   :       Optional[int]				=	np.array([0.49_493, 0.47_896, 0.40_798, 0.54_214, 0.53_212, 0.48_202, 0.47_656, 0.46_329, 0.48_506])
         assert np.abs(image_slice - expected_slice).max() < 7e-3




from __future__ import annotations

import math

def      snake_case__      (   SCREAMING_SNAKE_CASE_		:   int      ):



     '''simple docstring'''





     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(SCREAMING_SNAKE_CASE_      ) + 1      )     ,					6      ):
          if number % i == 0 or number % (i + 2) == 0:
               return False
     return True

def      snake_case__      (   SCREAMING_SNAKE_CASE_		:   int      ):



     '''simple docstring'''





     lowercase__   :       int				=	str(SCREAMING_SNAKE_CASE_      )
     lowercase__   :       Union[str, Any]				=	[n]
     for i in range(1     ,					len(SCREAMING_SNAKE_CASE_      )      ):
          list_nums.append(int(str_num[i:]      )      )
          list_nums.append(int(str_num[:-i]      )      )
     return list_nums

def      snake_case__      (   SCREAMING_SNAKE_CASE_		:   int      ):



     '''simple docstring'''





     if len(str(SCREAMING_SNAKE_CASE_      )      ) > 3:
          if not is_prime(int(str(SCREAMING_SNAKE_CASE_      )[-3:]      )      ) or not is_prime(int(str(SCREAMING_SNAKE_CASE_      )[:3]      )      ):
               return False
     return True

def      snake_case__      (   SCREAMING_SNAKE_CASE_		:   int = 11      ):



     '''simple docstring'''





     lowercase__   :       list[int]				=	[]
     lowercase__   :       Tuple				=	13
     while len(SCREAMING_SNAKE_CASE_      ) != count:
          if validate(SCREAMING_SNAKE_CASE_      ):
               lowercase__   :       Optional[int]				=	list_truncated_nums(SCREAMING_SNAKE_CASE_      )
               if all(is_prime(SCREAMING_SNAKE_CASE_      ) for i in list_nums      ):
                    list_truncated_primes.append(SCREAMING_SNAKE_CASE_      )
          num += 2
     return list_truncated_primes

def      snake_case__      (   ):



     '''simple docstring'''





     return sum(compute_truncated_primes(11      )      )


if __name__ == "__main__":
       print(F'''{sum(compute_truncated_primes(11)) = }''')

