






"""simple docstring"""




import gc
import random
import unittest

import numpy as np
import torch
from transformers import (
    CLIPImageProcessor,
    CLIPTextConfig,
    CLIPTextModel,
    CLIPTokenizer,
    CLIPVisionConfig,
    CLIPVisionModelWithProjection,
)

from diffusers import AutoencoderKL, DDIMScheduler, DDPMScheduler, StableUnCLIPImgaImgPipeline, UNetaDConditionModel
from diffusers.pipelines.pipeline_utils import DiffusionPipeline
from diffusers.pipelines.stable_diffusion.stable_unclip_image_normalizer import StableUnCLIPImageNormalizer
from diffusers.utils.import_utils import is_xformers_available
from diffusers.utils.testing_utils import (
    enable_full_determinism,
    floats_tensor,
    load_image,
    load_numpy,
    require_torch_gpu,
    skip_mps,
    slow,
    torch_device,
)

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


enable_full_determinism()






class        UpperCamelCase			(	snake_case_		,     snake_case_		,     snake_case_		,     unittest.TestCase      ):
 UpperCamelCase					:       List[str]			=					StableUnCLIPImgaImgPipeline
 UpperCamelCase					:       Optional[int]			=					TEXT_GUIDED_IMAGE_VARIATION_PARAMS
 UpperCamelCase					:       Dict			=					TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS
 UpperCamelCase					:       List[str]			=					frozenset(
     []      )  # TO-DO: update image_params once pipeline is refactored with VaeImageProcessor.preprocess
 UpperCamelCase					:       int			=					frozenset([]      )


 def _lowercase	(     self		:						Any							)					->       Any:
   _a  :       Any             =	32
   _a  :       Optional[Any]             =	embedder_hidden_size

   # image encoding components

   _a  :       Any             =	CLIPImageProcessor(crop_size=32							,						size=32							)

   torch.manual_seed(0							)
   _a  :       Dict             =	CLIPVisionModelWithProjection(
       CLIPVisionConfig(
           hidden_size=UpperCAmelCase__							,						projection_dim=UpperCAmelCase__							,						num_hidden_layers=5							,						num_attention_heads=4							,						image_size=32							,						intermediate_size=37							,						patch_size=1							,						)							)

   # regular denoising components

   torch.manual_seed(0							)
   _a  :       Dict             =	StableUnCLIPImageNormalizer(embedding_dim=UpperCAmelCase__							)
   _a  :       int             =	DDPMScheduler(beta_schedule="""squaredcos_cap_v2"""							)

   torch.manual_seed(0							)
   _a  :       Any             =	CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""							)

   torch.manual_seed(0							)
   _a  :       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=1000							,						)							)

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

   torch.manual_seed(0							)
   _a  :       Dict             =	DDIMScheduler(
       beta_schedule="""scaled_linear"""							,						beta_start=0.0_0_0_8_5							,						beta_end=0.0_1_2							,						prediction_type="""v_prediction"""							,						set_alpha_to_one=UpperCAmelCase__							,						steps_offset=1							,						)

   torch.manual_seed(0							)
   _a  :       List[Any]             =	AutoencoderKL()

   _a  :       Optional[Any]             =	{
       # image encoding components
       """feature_extractor""": feature_extractor,
       """image_encoder""": image_encoder.eval(),
       # image noising components
       """image_normalizer""": image_normalizer.eval(),
       """image_noising_scheduler""": image_noising_scheduler,
       # regular denoising components
       """tokenizer""": tokenizer,
       """text_encoder""": text_encoder.eval(),
       """unet""": unet.eval(),
       """scheduler""": scheduler,
       """vae""": vae.eval(),
   }

   return components


 def _lowercase	(     self		:						Optional[Any]							,						UpperCAmelCase__		:						Dict							,						UpperCAmelCase__		:						List[str]=0							,						UpperCAmelCase__		:						str=True							)					->       str:
   if str(UpperCAmelCase__							).startswith("""mps"""							):
     _a  :       Union[str, Any]             =	torch.manual_seed(UpperCAmelCase__							)
   else:
     _a  :       Dict             =	torch.Generator(device=UpperCAmelCase__							).manual_seed(UpperCAmelCase__							)

   _a  :       Any             =	floats_tensor((1, 3, 32, 32)							,						rng=random.Random(UpperCAmelCase__							)							).to(UpperCAmelCase__							)

   if pil_image:
     _a  :       int             =	input_image * 0.5 + 0.5
     _a  :       Optional[Any]             =	input_image.clamp(0							,						1							)
     _a  :       Any             =	input_image.cpu().permute(0							,						2							,						3							,						1							).float().numpy()
     _a  :       List[Any]             =	DiffusionPipeline.numpy_to_pil(UpperCAmelCase__							)[0]

   return {
       "prompt": "An anime racoon running a marathon",
       "image": input_image,
       "generator": generator,
       "num_inference_steps": 2,
       "output_type": "np",
   }


 @skip_mps
 def _lowercase	(     self		:						int							)					->       Any:
   _a  :       List[Any]             =	"""cpu"""  # ensure determinism for the device-dependent torch.Generator
   _a  :       List[str]             =	self.get_dummy_components()
   _a  :       Any             =	StableUnCLIPImgaImgPipeline(**UpperCAmelCase__							)
   _a  :       Tuple             =	sd_pipe.to(UpperCAmelCase__							)
   sd_pipe.set_progress_bar_config(disable=UpperCAmelCase__							)

   _a  :       Tuple             =	self.get_dummy_inputs(UpperCAmelCase__							)
   inputs.update({"""image_embeds""": None}							)
   _a  :       List[str]             =	sd_pipe(**UpperCAmelCase__							).images
   _a  :       Dict             =	image[0, -3:, -3:, -1]

   assert image.shape == (1, 32, 32, 3)
   _a  :       Dict             =	np.array([0.3_8_7_2, 0.7_2_2_4, 0.5_6_0_1, 0.4_7_4_1, 0.6_8_7_2, 0.5_8_1_4, 0.4_6_3_6, 0.3_8_6_7, 0.5_0_7_8]							)

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


 def _lowercase	(     self		:						List[str]							)					->       Dict:
   _a  :       str             =	torch_device in ["""cpu""", """mps"""]

   self._test_attention_slicing_forward_pass(test_max_difference=UpperCAmelCase__							)


 def _lowercase	(     self		:						Optional[int]							)					->       str:
   _a  :       str             =	torch_device in ["""cpu""", """mps"""]

   self._test_inference_batch_single_identical(test_max_difference=UpperCAmelCase__							)







 @unittest.skipIf(
     torch_device != """cuda""" or not is_xformers_available()							,						reason="""XFormers attention is only available with CUDA and `xformers` installed"""							,						)
 def _lowercase	(     self		:						str							)					->       Union[str, Any]:
   self._test_xformers_attention_forwardGenerator_pass(test_max_difference=UpperCAmelCase__							)







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


 def _lowercase	(     self		:						Union[str, Any]							)					->       Union[str, Any]:
   # clean up the VRAM after each test
   super().tearDown()
   gc.collect()
   torch.cuda.empty_cache()


 def _lowercase	(     self		:						Dict							)					->       str:
   _a  :       List[str]             =	load_image(
       """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/stable_unclip/turtle.png"""							)

   _a  :       Optional[Any]             =	load_numpy(
       """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/stable_unclip/stable_unclip_2_1_l_img2img_anime_turtle_fp16.npy"""							)

   _a  :       int             =	StableUnCLIPImgaImgPipeline.from_pretrained(
       """fusing/stable-unclip-2-1-l-img2img"""							,						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()

   _a  :       Tuple             =	torch.Generator(device="""cpu"""							).manual_seed(0							)
   _a  :       Optional[Any]             =	pipe(UpperCAmelCase__							,						"""anime turle"""							,						generator=UpperCAmelCase__							,						output_type="""np"""							)

   _a  :       Union[str, Any]             =	output.images[0]

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

   assert_mean_pixel_difference(UpperCAmelCase__							,						UpperCAmelCase__							)


 def _lowercase	(     self		:						Union[str, Any]							)					->       str:
   _a  :       int             =	load_image(
       """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/stable_unclip/turtle.png"""							)

   _a  :       str             =	load_numpy(
       """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/stable_unclip/stable_unclip_2_1_h_img2img_anime_turtle_fp16.npy"""							)

   _a  :       List[Any]             =	StableUnCLIPImgaImgPipeline.from_pretrained(
       """fusing/stable-unclip-2-1-h-img2img"""							,						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()

   _a  :       Optional[int]             =	torch.Generator(device="""cpu"""							).manual_seed(0							)
   _a  :       Any             =	pipe(UpperCAmelCase__							,						"""anime turle"""							,						generator=UpperCAmelCase__							,						output_type="""np"""							)

   _a  :       Union[str, Any]             =	output.images[0]

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

   assert_mean_pixel_difference(UpperCAmelCase__							,						UpperCAmelCase__							)







 def _lowercase	(     self		:						List[Any]							)					->       Union[str, Any]:
   _a  :       Tuple             =	load_image(
       """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/stable_unclip/turtle.png"""							)

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

   _a  :       List[str]             =	StableUnCLIPImgaImgPipeline.from_pretrained(
       """fusing/stable-unclip-2-1-h-img2img"""							,						torch_dtype=torch.floataa							)
   _a  :       List[str]             =	pipe.to(UpperCAmelCase__							)
   pipe.set_progress_bar_config(disable=UpperCAmelCase__							)
   pipe.enable_attention_slicing()
   pipe.enable_sequential_cpu_offload()

   _a  :       int             =	pipe(
       UpperCAmelCase__							,						"""anime turtle"""							,						num_inference_steps=2							,						output_type="""np"""							,						)

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









"""simple docstring"""




def 			lowerCAmelCase__     (     UpperCamelCase__     ,   UpperCamelCase__     ,   UpperCamelCase__     ,   UpperCamelCase__     ,   UpperCamelCase__     ,   ):



  '''simple docstring'''
  _a  :       Optional[Any]             =	[redshift, radiation_density, matter_density, dark_energy]
  if any(p < 0 for p in parameters				):
    raise ValueError("""All input parameters must be positive"""				)

  if any(p > 1 for p in parameters[1:4]				):
    raise ValueError("""Relative densities cannot be greater than one"""				)
  else:
    _a  :       Tuple             =	1 - (matter_density + radiation_density + dark_energy)

    _a  :       int             =	(
        radiation_density * (redshift + 1) ** 4
        + matter_density * (redshift + 1) ** 3
        + curvature * (redshift + 1) ** 2
        + dark_energy
    )

    _a  :       List[str]             =	hubble_constant * e_a ** (1 / 2)
    return hubble


if __name__ == "__main__":
 import doctest

 # run doctest
 doctest.testmod()

 # demo LCDM approximation
 _snake_case          =   0.3

 print(
     hubble_parameter(
         hubble_constant=68.3,
         radiation_density=1e-4,
         matter_density=matter_density,
         dark_energy=1 - matter_density,
         redshift=0,
     )
 )

