






"""simple docstring"""







import gc
import random
import unittest

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

from diffusers import (
    DiffusionPipeline,
    UnCLIPImageVariationPipeline,
    UnCLIPScheduler,
    UNetaDConditionModel,
    UNetaDModel,
)
from diffusers.pipelines.unclip.text_proj import UnCLIPTextProjModel
from diffusers.utils import floats_tensor, load_numpy, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, load_image, require_torch_gpu, skip_mps

from ..pipeline_params import IMAGE_VARIATION_BATCH_PARAMS, IMAGE_VARIATION_PARAMS
from ..test_pipelines_common import PipelineTesterMixin, assert_mean_pixel_difference


enable_full_determinism()


class      UpperCamelCase		(__snake_case						,						unittest.TestCase     ):
						_SCREAMING_SNAKE_CASE  : str												=		UnCLIPImageVariationPipeline
						_SCREAMING_SNAKE_CASE  : List[Any]												=		IMAGE_VARIATION_PARAMS - {"""height""", """width""", """guidance_scale"""}
						_SCREAMING_SNAKE_CASE  : str												=		IMAGE_VARIATION_BATCH_PARAMS

						_SCREAMING_SNAKE_CASE  : str												=		[
						    """generator""",
						    """return_dict""",
						    """decoder_num_inference_steps""",
						    """super_res_num_inference_steps""",
						]
						_SCREAMING_SNAKE_CASE  : Union[str, Any]												=		False






						@property
						def      __snake_case      (		self  :Optional[Any]				)      ->Dict:
										return 32






						@property
						def      __snake_case      (		self  :Dict				)      ->List[Any]:
										return 32






						@property
						def      __snake_case      (		self  :List[Any]				)      ->int:
										return self.time_input_dim






						@property
						def      __snake_case      (		self  :str				)      ->Union[str, Any]:
										return self.time_input_dim * 4






						@property
						def      __snake_case      (		self  :Dict				)      ->int:
										return 100






						@property
						def      __snake_case      (		self  :int				)      ->int:
										lowercase    :      str       = CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""				)
										return tokenizer






						@property
						def      __snake_case      (		self  :List[str]				)      ->Tuple:
										torch.manual_seed(0				)
										lowercase    :      Optional[int]       = CLIPTextConfig(
										    bos_token_id=0			, eos_token_id=2			, hidden_size=self.text_embedder_hidden_size			, projection_dim=self.text_embedder_hidden_size			, intermediate_size=37			, layer_norm_eps=1E-05			, num_attention_heads=4			, num_hidden_layers=5			, pad_token_id=1			, vocab_size=1_000			, )
										return CLIPTextModelWithProjection(__magic_name__				)






						@property
						def      __snake_case      (		self  :Tuple				)      ->str:
										torch.manual_seed(0				)
										lowercase    :      Union[str, Any]       = CLIPVisionConfig(
										    hidden_size=self.text_embedder_hidden_size			, projection_dim=self.text_embedder_hidden_size			, num_hidden_layers=5			, num_attention_heads=4			, image_size=32			, intermediate_size=37			, patch_size=1			, )
										return CLIPVisionModelWithProjection(__magic_name__				)






						@property
						def      __snake_case      (		self  :List[Any]				)      ->Optional[int]:
										torch.manual_seed(0				)

										lowercase    :      List[str]       = {
										    """clip_embeddings_dim""": self.text_embedder_hidden_size,
										    """time_embed_dim""": self.time_embed_dim,
										    """cross_attention_dim""": self.cross_attention_dim,
										}

										lowercase    :      Optional[Any]       = UnCLIPTextProjModel(**__magic_name__				)
										return model






						@property
						def      __snake_case      (		self  :Optional[Any]				)      ->int:
										torch.manual_seed(0				)

										lowercase    :      Union[str, Any]       = {
										    """sample_size""": 32,
										    # RGB in channels
										    """in_channels""": 3,
										    # Out channels is double in channels because predicts mean and variance
										    """out_channels""": 6,
										    """down_block_types""": ("""ResnetDownsampleBlock2D""", """SimpleCrossAttnDownBlock2D"""),
										    """up_block_types""": ("""SimpleCrossAttnUpBlock2D""", """ResnetUpsampleBlock2D"""),
										    """mid_block_type""": """UNetMidBlock2DSimpleCrossAttn""",
										    """block_out_channels""": (self.block_out_channels_a, self.block_out_channels_a * 2),
										    """layers_per_block""": 1,
										    """cross_attention_dim""": self.cross_attention_dim,
										    """attention_head_dim""": 4,
										    """resnet_time_scale_shift""": """scale_shift""",
										    """class_embed_type""": """identity""",
										}

										lowercase    :      Dict       = UNetaDConditionModel(**__magic_name__				)
										return model






						@property
						def      __snake_case      (		self  :int				)      ->Any:
										return {
										    "sample_size": 64,
										    "layers_per_block": 1,
										    "down_block_types": ("ResnetDownsampleBlock2D", "ResnetDownsampleBlock2D"),
										    "up_block_types": ("ResnetUpsampleBlock2D", "ResnetUpsampleBlock2D"),
										    "block_out_channels": (self.block_out_channels_a, self.block_out_channels_a * 2),
										    "in_channels": 6,
										    "out_channels": 3,
										}






						@property
						def      __snake_case      (		self  :Dict				)      ->Optional[Any]:
										torch.manual_seed(0				)

										lowercase    :      Any       = UNetaDModel(**self.dummy_super_res_kwargs				)
										return model






						@property
						def      __snake_case      (		self  :Any				)      ->Tuple:
										# seeded differently to get different unet than `self.dummy_super_res_first`
										torch.manual_seed(1				)

										lowercase    :      List[Any]       = UNetaDModel(**self.dummy_super_res_kwargs				)
										return model






						def      __snake_case      (		self  :List[str]				)      ->Tuple:
										lowercase    :      Union[str, Any]       = self.dummy_decoder
										lowercase    :      Union[str, Any]       = self.dummy_text_proj
										lowercase    :      Dict       = self.dummy_text_encoder
										lowercase    :      Optional[Any]       = self.dummy_tokenizer
										lowercase    :      Optional[int]       = self.dummy_super_res_first
										lowercase    :      List[str]       = self.dummy_super_res_last

										lowercase    :      Tuple       = UnCLIPScheduler(
										    variance_type="""learned_range"""			, prediction_type="""epsilon"""			, num_train_timesteps=1_000			, )

										lowercase    :      Optional[int]       = UnCLIPScheduler(
										    variance_type="""fixed_small_log"""			, prediction_type="""epsilon"""			, num_train_timesteps=1_000			, )

										lowercase    :      str       = CLIPImageProcessor(crop_size=32			, size=32				)

										lowercase    :      Any       = self.dummy_image_encoder

										return {
										    "decoder": decoder,
										    "text_encoder": text_encoder,
										    "tokenizer": tokenizer,
										    "text_proj": text_proj,
										    "feature_extractor": feature_extractor,
										    "image_encoder": image_encoder,
										    "super_res_first": super_res_first,
										    "super_res_last": super_res_last,
										    "decoder_scheduler": decoder_scheduler,
										    "super_res_scheduler": super_res_scheduler,
										}






						def      __snake_case      (		self  :Optional[Any]			, __magic_name__  :Tuple			, __magic_name__  :Dict=0			, __magic_name__  :Dict=True				)      ->Dict:
										lowercase    :      Dict       = floats_tensor((1, 3, 32, 32)			, rng=random.Random(__magic_name__				)				).to(__magic_name__				)
										if str(__magic_name__				).startswith("""mps"""				):
														lowercase    :      Any       = torch.manual_seed(__magic_name__				)
										else:
														lowercase    :      int       = torch.Generator(device=__magic_name__				).manual_seed(__magic_name__				)

										if pil_image:
														lowercase    :      List[Any]       = input_image * 0.5 + 0.5
														lowercase    :      Union[str, Any]       = input_image.clamp(0			, 1				)
														lowercase    :      str       = input_image.cpu().permute(0			, 2			, 3			, 1				).float().numpy()
														lowercase    :      str       = DiffusionPipeline.numpy_to_pil(__magic_name__				)[0]

										return {
										    "image": input_image,
										    "generator": generator,
										    "decoder_num_inference_steps": 2,
										    "super_res_num_inference_steps": 2,
										    "output_type": "np",
										}






						def      __snake_case      (		self  :Optional[int]				)      ->List[str]:
										lowercase    :      str       = """cpu"""

										lowercase    :      Optional[int]       = self.get_dummy_components()

										lowercase    :      Union[str, Any]       = self.pipeline_class(**__magic_name__				)
										lowercase    :      Optional[int]       = pipe.to(__magic_name__				)

										pipe.set_progress_bar_config(disable=__magic_name__				)

										lowercase    :      Any       = self.get_dummy_inputs(__magic_name__			, pil_image=__magic_name__				)

										lowercase    :      int       = pipe(**__magic_name__				)
										lowercase    :      str       = output.images

										lowercase    :      Optional[Any]       = self.get_dummy_inputs(__magic_name__			, pil_image=__magic_name__				)

										lowercase    :      Dict       = pipe(
										    **__magic_name__			, return_dict=__magic_name__			, )[0]

										lowercase    :      List[str]       = image[0, -3:, -3:, -1]
										lowercase    :      Optional[Any]       = image_from_tuple[0, -3:, -3:, -1]

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

										lowercase    :      str       = np.array(
										    [
										        0.9997,
										        0.0002,
										        0.9997,
										        0.9997,
										        0.9969,
										        0.0023,
										        0.9997,
										        0.9969,
										        0.9970,
										    ]				)

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






						def      __snake_case      (		self  :int				)      ->List[str]:
										lowercase    :      Dict       = """cpu"""

										lowercase    :      Dict       = self.get_dummy_components()

										lowercase    :      Dict       = self.pipeline_class(**__magic_name__				)
										lowercase    :      int       = pipe.to(__magic_name__				)

										pipe.set_progress_bar_config(disable=__magic_name__				)

										lowercase    :      List[Any]       = self.get_dummy_inputs(__magic_name__			, pil_image=__magic_name__				)

										lowercase    :      int       = pipe(**__magic_name__				)
										lowercase    :      Any       = output.images

										lowercase    :      Dict       = self.get_dummy_inputs(__magic_name__			, pil_image=__magic_name__				)

										lowercase    :      Dict       = pipe(
										    **__magic_name__			, return_dict=__magic_name__			, )[0]

										lowercase    :      Any       = image[0, -3:, -3:, -1]
										lowercase    :      List[Any]       = image_from_tuple[0, -3:, -3:, -1]

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

										lowercase    :      Optional[Any]       = np.array([0.9997, 0.0003, 0.9997, 0.9997, 0.9970, 0.0024, 0.9997, 0.9971, 0.9971]				)

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






						def      __snake_case      (		self  :Dict				)      ->Optional[int]:
										lowercase    :      Dict       = """cpu"""

										lowercase    :      int       = self.get_dummy_components()

										lowercase    :      Optional[int]       = self.pipeline_class(**__magic_name__				)
										lowercase    :      int       = pipe.to(__magic_name__				)

										pipe.set_progress_bar_config(disable=__magic_name__				)

										lowercase    :      int       = self.get_dummy_inputs(__magic_name__			, pil_image=__magic_name__				)
										lowercase    :      Optional[int]       = [
										    pipeline_inputs["""image"""],
										    pipeline_inputs["""image"""],
										]

										lowercase    :      int       = pipe(**__magic_name__				)
										lowercase    :      Dict       = output.images

										lowercase    :      int       = self.get_dummy_inputs(__magic_name__			, pil_image=__magic_name__				)
										lowercase    :      Tuple       = [
										    tuple_pipeline_inputs["""image"""],
										    tuple_pipeline_inputs["""image"""],
										]

										lowercase    :      List[Any]       = pipe(
										    **__magic_name__			, return_dict=__magic_name__			, )[0]

										lowercase    :      List[str]       = image[0, -3:, -3:, -1]
										lowercase    :      Optional[int]       = image_from_tuple[0, -3:, -3:, -1]

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

										lowercase    :      str       = np.array(
										    [
										        0.9997,
										        0.9989,
										        0.0008,
										        0.0021,
										        0.9960,
										        0.0018,
										        0.0014,
										        0.0002,
										        0.9933,
										    ]				)

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






						def      __snake_case      (		self  :int				)      ->str:
										lowercase    :      List[Any]       = torch.device("""cpu"""				)


										class      UpperCamelCase		:
																_SCREAMING_SNAKE_CASE  : str												=		1
										lowercase    :      Tuple       = self.get_dummy_components()

										lowercase    :      List[str]       = self.pipeline_class(**__magic_name__				)
										lowercase    :      Optional[Any]       = pipe.to(__magic_name__				)

										pipe.set_progress_bar_config(disable=__magic_name__				)

										lowercase    :      Tuple       = torch.Generator(device=__magic_name__				).manual_seed(0				)
										lowercase    :      Any       = pipe.decoder.dtype
										lowercase    :      List[Any]       = 1

										lowercase    :      int       = (
										    batch_size,
										    pipe.decoder.config.in_channels,
										    pipe.decoder.config.sample_size,
										    pipe.decoder.config.sample_size,
										)
										lowercase    :      List[str]       = pipe.prepare_latents(
										    __magic_name__			, dtype=__magic_name__			, device=__magic_name__			, generator=__magic_name__			, latents=__magic_name__			, scheduler=DummyScheduler()				)

										lowercase    :      Optional[Any]       = (
										    batch_size,
										    pipe.super_res_first.config.in_channels // 2,
										    pipe.super_res_first.config.sample_size,
										    pipe.super_res_first.config.sample_size,
										)
										lowercase    :      List[Any]       = pipe.prepare_latents(
										    __magic_name__			, dtype=__magic_name__			, device=__magic_name__			, generator=__magic_name__			, latents=__magic_name__			, scheduler=DummyScheduler()				)

										lowercase    :      str       = self.get_dummy_inputs(__magic_name__			, pil_image=__magic_name__				)

										lowercase    :      Optional[int]       = pipe(
										    **__magic_name__			, decoder_latents=__magic_name__			, super_res_latents=__magic_name__				).images

										lowercase    :      Optional[int]       = self.get_dummy_inputs(__magic_name__			, pil_image=__magic_name__				)
										# Don't pass image, instead pass embedding
										lowercase    :      Dict       = pipeline_inputs.pop("""image"""				)
										lowercase    :      int       = pipe.image_encoder(__magic_name__				).image_embeds

										lowercase    :      str       = pipe(
										    **__magic_name__			, decoder_latents=__magic_name__			, super_res_latents=__magic_name__			, image_embeddings=__magic_name__			, ).images

										# make sure passing text embeddings manually is identical
										assert np.abs(img_out_a - img_out_a				).max() < 1E-4






						@skip_mps
						def      __snake_case      (		self  :Union[str, Any]				)      ->Optional[int]:
										lowercase    :      List[str]       = torch_device == """cpu"""

										# Check is relaxed because there is not a torch 2.0 sliced attention added kv processor
										lowercase    :      List[Any]       = 1E-2

										self._test_attention_slicing_forward_pass(
										    test_max_difference=__magic_name__			, expected_max_diff=__magic_name__				)






						@skip_mps
						def      __snake_case      (		self  :Optional[int]				)      ->Dict:
										lowercase    :      Optional[int]       = torch_device == """cpu"""
										lowercase    :      List[str]       = True
										lowercase    :      Tuple       = [
										    """decoder_num_inference_steps""",
										    """super_res_num_inference_steps""",
										]

										self._test_inference_batch_single_identical(
										    test_max_difference=__magic_name__			, relax_max_difference=__magic_name__			, additional_params_copy_to_batched_inputs=__magic_name__			, )






						def      __snake_case      (		self  :Optional[int]				)      ->Optional[int]:
										lowercase    :      Dict       = [
										    """decoder_num_inference_steps""",
										    """super_res_num_inference_steps""",
										]

										if torch_device == "mps":
														# TODO: MPS errors with larger batch sizes
														lowercase    :      int       = [2, 3]
														self._test_inference_batch_consistent(
														    batch_sizes=__magic_name__			, additional_params_copy_to_batched_inputs=__magic_name__			, )
										else:
														self._test_inference_batch_consistent(
														    additional_params_copy_to_batched_inputs=__magic_name__				)






						@skip_mps
						def      __snake_case      (		self  :Dict				)      ->Dict:
										return super().test_dict_tuple_outputs_equivalent()






						@skip_mps
						def      __snake_case      (		self  :List[Any]				)      ->Any:
										return super().test_save_load_local()






						@skip_mps
						def      __snake_case      (		self  :Dict				)      ->Any:
										return super().test_save_load_optional_components()


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






						def      __snake_case      (		self  :Tuple				)      ->List[Any]:
										# clean up the VRAM after each test
										super().tearDown()
										gc.collect()
										torch.cuda.empty_cache()






						def      __snake_case      (		self  :List[Any]				)      ->Optional[Any]:
										lowercase    :      str       = load_image(
										    """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/unclip/cat.png"""				)
										lowercase    :      Tuple       = load_numpy(
										    """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"""
										    """/unclip/karlo_v1_alpha_cat_variation_fp16.npy"""				)

										lowercase    :      str       = UnCLIPImageVariationPipeline.from_pretrained(
										    """kakaobrain/karlo-v1-alpha-image-variations"""			, torch_dtype=torch.floataa				)
										lowercase    :      Any       = pipeline.to(__magic_name__				)
										pipeline.set_progress_bar_config(disable=__magic_name__				)

										lowercase    :      Any       = torch.Generator(device="""cpu"""				).manual_seed(0				)
										lowercase    :      List[Any]       = pipeline(
										    __magic_name__			, generator=__magic_name__			, output_type="""np"""			, )

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

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

										assert_mean_pixel_difference(__magic_name__			, __magic_name__			, 15				)








"""simple docstring"""







def      UpperCamelCase       ( _A  ,				_A )     ->       int:
				lowercase    :      int       = 1  # To kept the Calculated Value
				# Since C(n, k) = C(n, n-k)
				if k > (n - k):
								lowercase    :      List[Any]       = n - k
				# Calculate C(n,k)
				for i in range(_A ):
								result *= n - i
								result //= i + 1
				return result


def      UpperCamelCase       ( _A )     ->       int:
				return binomial_coefficient(2 * node_count  ,				_A ) // (node_count + 1)


def      UpperCamelCase       ( _A )     ->       int:
				if n < 0:
								raise ValueError("""factorial() not defined for negative values""" )
				lowercase    :      Union[str, Any]       = 1
				for i in range(1  ,				n + 1 ):
								result *= i
				return result


def      UpperCamelCase       ( _A )     ->       int:
				return catalan_number(_A ) * factorial(_A )


if __name__ == "__main__":
				_lowerCAmelCase            =	int(input('Enter the number of nodes: ').strip() or 0)
				if node_count <= 0:
								raise ValueError('We need some nodes to work with.')
				print(
				    F'Given {node_count} nodes, there are {binary_tree_count(node_count)} '
				    F'binary trees and {catalan_number(node_count)} binary search trees.'
				)
