






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        a       (					lowercase__				,			lowercase__				,			unittest.TestCase  ):



      """simple docstring"""


      a    :					str							=      StableDiffusionXLImgaImgPipeline
      a    :					Union[str, Any]							=      TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {'height', 'width'}
      a    :					Optional[int]							=      PipelineTesterMixin.required_optional_params - {'latents'}
      a    :					str							=      TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS
      a    :					Dict							=      IMAGE_TO_IMAGE_IMAGE_PARAMS
      a    :					Optional[int]							=      IMAGE_TO_IMAGE_IMAGE_PARAMS
      def       UpperCAmelCase ( self   :     int   )				-> List[str]:
        torch.manual_seed(0   )
        __UpperCAmelCase				:      List[str]	 =    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=__lowercase						, 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						, )
        __UpperCAmelCase				:      Optional[Any]	 =    EulerDiscreteScheduler(
            beta_start=0.00_085						, beta_end=0.012						, steps_offset=1						, beta_schedule="""scaled_linear"""						, timestep_spacing="""leading"""						, )
        torch.manual_seed(0   )
        __UpperCAmelCase				:      Optional[int]	 =    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				:      str	 =    CLIPTextConfig(
            bos_token_id=0						, eos_token_id=2						, hidden_size=32						, intermediate_size=37						, layer_norm_eps=1e-0_5						, num_attention_heads=4						, num_hidden_layers=5						, pad_token_id=1						, vocab_size=1000						, hidden_act="""gelu"""						, projection_dim=32						, )
        __UpperCAmelCase				:      Optional[int]	 =    CLIPTextModel(__lowercase   )
        __UpperCAmelCase				:      Dict	 =    CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""						, local_files_only=__lowercase   )

        __UpperCAmelCase				:      List[str]	 =    CLIPTextModelWithProjection(__lowercase   )
        __UpperCAmelCase				:      Optional[Any]	 =    CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""						, local_files_only=__lowercase   )

        __UpperCAmelCase				:      List[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       UpperCAmelCase ( self   :     Tuple						, __lowercase   :     List[str]						, __lowercase   :     Union[str, Any]=0   )				-> str:
        __UpperCAmelCase				:      List[Any]	 =    floats_tensor((1, 3, 32, 32)						, rng=random.Random(__lowercase   )   ).to(__lowercase   )
        __UpperCAmelCase				:      List[Any]	 =    image / 2 + 0.5
        if str(__lowercase   ).startswith("""mps"""   ):
          __UpperCAmelCase				:      Tuple	 =    torch.manual_seed(__lowercase   )
        else:
          __UpperCAmelCase				:      Any	 =    torch.Generator(device=__lowercase   ).manual_seed(__lowercase   )
        __UpperCAmelCase				:      Union[str, Any]	 =    {
            """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       UpperCAmelCase ( self   :     Any   )				-> Optional[Any]:
        __UpperCAmelCase				:      str	 =    """cpu"""  # ensure determinism for the device-dependent torch.Generator
        __UpperCAmelCase				:      Union[str, Any]	 =    self.get_dummy_components()
        __UpperCAmelCase				:      Tuple	 =    StableDiffusionXLImgaImgPipeline(**__lowercase   )
        __UpperCAmelCase				:      Dict	 =    sd_pipe.to(__lowercase   )
        sd_pipe.set_progress_bar_config(disable=__lowercase   )

        __UpperCAmelCase				:      Optional[int]	 =    self.get_dummy_inputs(__lowercase   )
        __UpperCAmelCase				:      Union[str, Any]	 =    sd_pipe(**__lowercase   ).images
        __UpperCAmelCase				:      str	 =    image[0, -3:, -3:, -1]

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

        __UpperCAmelCase				:      str	 =    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       UpperCAmelCase ( self   :     List[Any]   )				-> Union[str, Any]:
        super().test_attention_slicing_forward_pass(expected_max_diff=3e-3   )
      def       UpperCAmelCase ( self   :     Optional[Any]   )				-> Tuple:
        super().test_inference_batch_single_identical(expected_max_diff=3e-3   )
      def       UpperCAmelCase ( self   :     List[Any]   )				-> Optional[int]:
        pass




      def       UpperCAmelCase ( self   :     Dict   )				-> Dict:
        __UpperCAmelCase				:      Optional[int]	 =    self.get_dummy_components()
        __UpperCAmelCase				:      List[str]	 =    StableDiffusionXLImgaImgPipeline(**__lowercase   )
        __UpperCAmelCase				:      List[str]	 =    sd_pipe.to(__lowercase   )
        __UpperCAmelCase				:      str	 =    sd_pipe.to(__lowercase   )
        sd_pipe.set_progress_bar_config(disable=__lowercase   )

        # forward without prompt embeds
        __UpperCAmelCase				:      List[str]	 =    self.get_dummy_inputs(__lowercase   )
        __UpperCAmelCase				:      Tuple	 =    3 * ["""this is a negative prompt"""]
        __UpperCAmelCase				:      Union[str, Any]	 =    negative_prompt
        __UpperCAmelCase				:      Dict	 =    3 * [inputs["""prompt"""]]

        __UpperCAmelCase				:      Union[str, Any]	 =    sd_pipe(**__lowercase   )
        __UpperCAmelCase				:      Dict	 =    output.images[0, -3:, -3:, -1]

        # forward with prompt embeds
        __UpperCAmelCase				:      int	 =    self.get_dummy_inputs(__lowercase   )
        __UpperCAmelCase				:      Optional[Any]	 =    3 * ["""this is a negative prompt"""]
        __UpperCAmelCase				:      Union[str, Any]	 =    3 * [inputs.pop("""prompt"""   )]

        (
            (
            __UpperCAmelCase
        ) ,					(
            __UpperCAmelCase
        ) ,					(
            __UpperCAmelCase
        ) ,					(
            __UpperCAmelCase
        ) ,					
        )				:      List[Any]	 =    sd_pipe.encode_prompt(__lowercase						, negative_prompt=__lowercase   )

        __UpperCAmelCase				:      Optional[Any]	 =    sd_pipe(
            **__lowercase						, prompt_embeds=__lowercase						, negative_prompt_embeds=__lowercase						, pooled_prompt_embeds=__lowercase						, negative_pooled_prompt_embeds=__lowercase						, )
        __UpperCAmelCase				:      Optional[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        a       (					unittest.TestCase  ):



      """simple docstring"""


      def       UpperCAmelCase ( self   :     Union[str, Any]   )				-> Optional[Any]:
        super().tearDown()
        gc.collect()
        torch.cuda.empty_cache()
      def       UpperCAmelCase ( self   :     Any						, __lowercase   :     Dict						, __lowercase   :     Union[str, Any]="cpu"						, __lowercase   :     List[str]=torch.floataa						, __lowercase   :     List[str]=0   )				-> Any:
        __UpperCAmelCase				:      int	 =    torch.Generator(device=__lowercase   ).manual_seed(__lowercase   )
        __UpperCAmelCase				:      Tuple	 =    np.random.RandomState(__lowercase   ).standard_normal((1, 4, 64, 64)   )
        __UpperCAmelCase				:      str	 =    torch.from_numpy(__lowercase   ).to(device=__lowercase						, dtype=__lowercase   )
        __UpperCAmelCase				:      Tuple	 =    {
            """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       UpperCAmelCase ( self   :     Dict   )				-> Dict:
        __UpperCAmelCase				:      Optional[Any]	 =    DiffusionPipeline.from_pretrained("""stabilityai/stable-diffusion-2-base"""   )
        pipe.to(__lowercase   )
        pipe.set_progress_bar_config(disable=__lowercase   )

        __UpperCAmelCase				:      int	 =    self.get_inputs(__lowercase   )
        __UpperCAmelCase				:      Tuple	 =    pipe(**__lowercase   ).images
        __UpperCAmelCase				:      Optional[Any]	 =    image[0, -3:, -3:, -1].flatten()

        assert image.shape == (1, 512, 512, 3)
        __UpperCAmelCase				:      Tuple	 =    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 math import isqrt
def 		snake_case__	(		lowercase					):
   lowerCAmelCase_:							List[str]       =	[True] * max_number
   for i in range(2							,				isqrt(max_number - 1					) + 1					):
      if is_prime[i]:
         for j in range(i**2							,				lowercase							,				lowercase					):
            lowerCAmelCase_:							Dict       =	False

   return [i for i in range(2							,				lowercase					) if is_prime[i]]
def 		snake_case__	(		lowercase = 10**8					):
   lowerCAmelCase_:							Union[str, Any]       =	calculate_prime_numbers(max_number // 2					)

   lowerCAmelCase_:							Tuple       =	0
   lowerCAmelCase_:							List[Any]       =	0
   lowerCAmelCase_:							Dict       =	len(lowercase					) - 1
   while left <= right:
      while prime_numbers[left] * prime_numbers[right] >= max_number:
         right -= 1
      semiprimes_count += right - left + 1
      left += 1

   return semiprimes_count


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