

import gc
import unittest

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

from diffusers import (
    AutoencoderKL,
    DDIMParallelScheduler,
    DDPMParallelScheduler,
    StableDiffusionParadigmsPipeline,
    UNetaDConditionModel,
)
from diffusers.utils import slow, torch_device
from diffusers.utils.testing_utils import (
    enable_full_determinism,
    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 PipelineLatentTesterMixin, PipelineTesterMixin


enable_full_determinism()







class 		__magic_name__     (				lowercase_						,			lowercase_						,			unittest.TestCase				):

   '''simple docstring'''




   lowerCamelCase__					:      str        =  StableDiffusionParadigmsPipeline
   lowerCamelCase__					:      Tuple        =  TEXT_TO_IMAGE_PARAMS
   lowerCamelCase__					:      Optional[Any]        =  TEXT_TO_IMAGE_BATCH_PARAMS
   lowerCamelCase__					:      Optional[Any]        =  TEXT_TO_IMAGE_IMAGE_PARAMS
   lowerCamelCase__					:      Optional[Any]        =  TEXT_TO_IMAGE_IMAGE_PARAMS



   def 					_UpperCAmelCase					(							self			)				->       Optional[int]:






     """simple docstring"""






     torch.manual_seed(0			)
     a__    =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'''),       cross_attention_dim=32,       attention_head_dim=(2, 4),       use_linear_projection=SCREAMING_SNAKE_CASE_,       )
     a__    =DDIMParallelScheduler(
         beta_start=0.00085,       beta_end=0.012,       beta_schedule='''scaled_linear''',       clip_sample=SCREAMING_SNAKE_CASE_,       set_alpha_to_one=SCREAMING_SNAKE_CASE_,       )
     torch.manual_seed(0			)
     a__    =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			)
     a__    =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=512,       )
     a__    =CLIPTextModel(SCREAMING_SNAKE_CASE_			)
     a__    =CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''			)

     a__    ={
         'unet': unet,
         'scheduler': scheduler,
         'vae': vae,
         'text_encoder': text_encoder,
         'tokenizer': tokenizer,
         'safety_checker': None,
         'feature_extractor': None,
     }
     return components



   def 					_UpperCAmelCase					(							self,       lowercase_,       lowercase_=0			)				->       Any:






     """simple docstring"""






     if str(SCREAMING_SNAKE_CASE_			).startswith('''mps'''			):
       a__    =torch.manual_seed(SCREAMING_SNAKE_CASE_			)
     else:
       a__    =torch.Generator(device=SCREAMING_SNAKE_CASE_			).manual_seed(SCREAMING_SNAKE_CASE_			)
     a__    ={
         'prompt': 'a photograph of an astronaut riding a horse',
         'generator': generator,
         'num_inference_steps': 10,
         'guidance_scale': 6.0,
         'output_type': 'numpy',
         'parallel': 3,
         'debug': True,
     }
     return inputs



   def 					_UpperCAmelCase					(							self			)				->       Tuple:






     """simple docstring"""






     a__    ='cpu'  # ensure determinism for the device-dependent torch.Generator
     a__    =self.get_dummy_components()
     a__    =StableDiffusionParadigmsPipeline(**SCREAMING_SNAKE_CASE_			)
     a__    =sd_pipe.to(SCREAMING_SNAKE_CASE_			)
     sd_pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE_			)

     a__    =self.get_dummy_inputs(SCREAMING_SNAKE_CASE_			)
     a__    =sd_pipe(**SCREAMING_SNAKE_CASE_			).images
     a__    =image[0, -3:, -3:, -1]
     assert image.shape == (1, 64, 64, 3)

     a__    =np.array([0.4773, 0.5417, 0.4723, 0.4925, 0.5631, 0.4752, 0.5240, 0.4935, 0.5023]			)

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



   def 					_UpperCAmelCase					(							self			)				->       List[Any]:






     """simple docstring"""






     a__    ='cpu'  # ensure determinism for the device-dependent torch.Generator
     a__    =self.get_dummy_components()
     torch.manual_seed(0			)
     a__    =DDPMParallelScheduler()
     torch.manual_seed(0			)
     a__    =StableDiffusionParadigmsPipeline(**SCREAMING_SNAKE_CASE_			)
     a__    =sd_pipe.to(SCREAMING_SNAKE_CASE_			)
     sd_pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE_			)

     a__    =self.get_dummy_inputs(SCREAMING_SNAKE_CASE_			)
     a__    =sd_pipe(**SCREAMING_SNAKE_CASE_			).images
     a__    =image[0, -3:, -3:, -1]
     assert image.shape == (1, 64, 64, 3)

     a__    =np.array([0.3573, 0.4420, 0.4960, 0.4799, 0.3796, 0.3879, 0.4819, 0.4365, 0.4468]			)

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



   def 					_UpperCAmelCase					(							self			)				->       str:






     """simple docstring"""






     super().test_inference_batch_consistent(batch_sizes=[1, 2]			)



   def 					_UpperCAmelCase					(							self			)				->       Union[str, Any]:






     """simple docstring"""






     super().test_inference_batch_single_identical(batch_size=2,       expected_max_diff=3E-3			)



   def 					_UpperCAmelCase					(							self			)				->       Optional[Any]:






     """simple docstring"""






     a__    ='cpu'  # ensure determinism for the device-dependent torch.Generator
     a__    =self.get_dummy_components()
     a__    =StableDiffusionParadigmsPipeline(**SCREAMING_SNAKE_CASE_			)
     a__    =sd_pipe.to(SCREAMING_SNAKE_CASE_			)
     sd_pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE_			)

     a__    =self.get_dummy_inputs(SCREAMING_SNAKE_CASE_			)
     a__    ='french fries'
     a__    =sd_pipe(**SCREAMING_SNAKE_CASE_,       negative_prompt=SCREAMING_SNAKE_CASE_			)
     a__    =output.images
     a__    =image[0, -3:, -3:, -1]

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

     a__    =np.array([0.4771, 0.5420, 0.4683, 0.4918, 0.5636, 0.4725, 0.5230, 0.4923, 0.5015]			)

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







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

   '''simple docstring'''




   def 					_UpperCAmelCase					(							self			)				->       Tuple:






     """simple docstring"""






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



   def 					_UpperCAmelCase					(							self,       lowercase_=0			)				->       Optional[int]:






     """simple docstring"""






     a__    =torch.Generator(device=SCREAMING_SNAKE_CASE_			).manual_seed(SCREAMING_SNAKE_CASE_			)
     a__    ={
         'prompt': 'a photograph of an astronaut riding a horse',
         'generator': generator,
         'num_inference_steps': 10,
         'guidance_scale': 7.5,
         'output_type': 'numpy',
         'parallel': 3,
         'debug': True,
     }
     return inputs



   def 					_UpperCAmelCase					(							self			)				->       Dict:






     """simple docstring"""






     a__    ='stabilityai/stable-diffusion-2-base'
     a__    =DDIMParallelScheduler.from_pretrained(SCREAMING_SNAKE_CASE_,       subfolder='''scheduler'''			)
     a__    =StableDiffusionParadigmsPipeline.from_pretrained(SCREAMING_SNAKE_CASE_,       scheduler=SCREAMING_SNAKE_CASE_,       safety_checker=SCREAMING_SNAKE_CASE_			)
     pipe.to(SCREAMING_SNAKE_CASE_			)
     pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE_			)
     pipe.enable_attention_slicing()

     a__    =self.get_inputs()
     a__    =pipe(**SCREAMING_SNAKE_CASE_			).images
     a__    =image[0, -3:, -3:, -1].flatten()

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

     a__    =np.array([0.9622, 0.9602, 0.9748, 0.9591, 0.9630, 0.9691, 0.9661, 0.9631, 0.9741]			)

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





"""simple docstring"""







def 							UpperCamelCase_       (       lowerCAmelCase__ :							int = 400_0000		)		->  int:

  """simple docstring"""




  if n <= 1:
    return 0
  lowerCAmelCase_  :							Union[str, Any]								=					0
  lowerCAmelCase_  :							Tuple								=					2
  lowerCAmelCase_  :							List[Any]								=					0
  while 4 * b + a <= n:
    lowerCAmelCase_		,lowerCAmelCase_  :							str								=					b, 4 * b + a
    count += a
  return count + b


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





