
"""simple docstring"""







import gc
import random
import unittest

import numpy as np
import torch
from transformers import CLIPImageProcessor, CLIPVisionConfig, CLIPVisionModel

from diffusers import HeunDiscreteScheduler, PriorTransformer, ShapEImgaImgPipeline
from diffusers.pipelines.shap_e import ShapERenderer
from diffusers.utils import floats_tensor, load_image, load_numpy, slow
from diffusers.utils.testing_utils import require_torch_gpu, torch_device

from ..test_pipelines_common import PipelineTesterMixin, assert_mean_pixel_difference




class  A__       (	_lowerCamelCase       ,     unittest.TestCase):
		A_						:       str				   =	ShapEImgaImgPipeline
		A_						:       str				   =	['image']
		A_						:       int				   =	['image']
		A_						:       Tuple				   =	[
		    'num_images_per_prompt',
		    'num_inference_steps',
		    'generator',
		    'latents',
		    'guidance_scale',
		    'frame_size',
		    'output_type',
		    'return_dict',
		]
		A_						:       Tuple				   =	False

		@property
		def 							__lowerCamelCase							(      self ):
			return 32

		@property
		def 							__lowerCamelCase							(      self ):
			return 32

		@property
		def 							__lowerCamelCase							(      self ):
			return self.time_input_dim * 4

		@property
		def 							__lowerCamelCase							(      self ):
			return 8

		@property
		def 							__lowerCamelCase							(      self ):
			torch.manual_seed(0 )
			__lowerCAmelCase			:						Any									=      CLIPVisionConfig(
			    hidden_size=self.text_embedder_hidden_size       ,		image_size=64       ,		projection_dim=self.text_embedder_hidden_size       ,		intermediate_size=37       ,		num_attention_heads=4       ,		num_channels=3       ,		num_hidden_layers=5       ,		patch_size=1       ,		)

			__lowerCAmelCase			:						Tuple									=      CLIPVisionModel(_SCREAMING_SNAKE_CASE )
			return model

		@property
		def 							__lowerCamelCase							(      self ):
			__lowerCAmelCase			:						Any									=      CLIPImageProcessor(
			    crop_size=2_24       ,		do_center_crop=_SCREAMING_SNAKE_CASE       ,		do_normalize=_SCREAMING_SNAKE_CASE       ,		do_resize=_SCREAMING_SNAKE_CASE       ,		image_mean=[0.4814_5466, 0.457_8275, 0.4082_1073]       ,		image_std=[0.2686_2954, 0.2613_0258, 0.2757_7711]       ,		resample=3       ,		size=2_24       ,		)

			return image_processor

		@property
		def 							__lowerCamelCase							(      self ):
			torch.manual_seed(0 )

			__lowerCAmelCase			:						Optional[Any]									=      {
			    'num_attention_heads': 2,
			    'attention_head_dim': 16,
			    'embedding_dim': self.time_input_dim,
			    'num_embeddings': 32,
			    'embedding_proj_dim': self.text_embedder_hidden_size,
			    'time_embed_dim': self.time_embed_dim,
			    'num_layers': 1,
			    'clip_embed_dim': self.time_input_dim * 2,
			    'additional_embeddings': 0,
			    'time_embed_act_fn': 'gelu',
			    'norm_in_type': 'layer',
			    'embedding_proj_norm_type': 'layer',
			    'encoder_hid_proj_type': None,
			    'added_emb_type': None,
			}

			__lowerCAmelCase			:						List[Any]									=      PriorTransformer(**_SCREAMING_SNAKE_CASE )
			return model

		@property
		def 							__lowerCamelCase							(      self ):
			torch.manual_seed(0 )

			__lowerCAmelCase			:						Dict									=      {
			    'param_shapes': (
			        (self.renderer_dim, 93),
			        (self.renderer_dim, 8),
			        (self.renderer_dim, 8),
			        (self.renderer_dim, 8),
			    ),
			    'd_latent': self.time_input_dim,
			    'd_hidden': self.renderer_dim,
			    'n_output': 12,
			    'background': (
			        0.1,
			        0.1,
			        0.1,
			    ),
			}
			__lowerCAmelCase			:						int									=      ShapERenderer(**_SCREAMING_SNAKE_CASE )
			return model

		def 							__lowerCamelCase							(      self ):
			__lowerCAmelCase			:						Any									=      self.dummy_prior
			__lowerCAmelCase			:						List[Any]									=      self.dummy_image_encoder
			__lowerCAmelCase			:						int									=      self.dummy_image_processor
			__lowerCAmelCase			:						Any									=      self.dummy_renderer

			__lowerCAmelCase			:						Any									=      HeunDiscreteScheduler(
			    beta_schedule='exp'       ,		num_train_timesteps=10_24       ,		prediction_type='sample'       ,		use_karras_sigmas=_SCREAMING_SNAKE_CASE       ,		clip_sample=_SCREAMING_SNAKE_CASE       ,		clip_sample_range=1.0       ,		)
			__lowerCAmelCase			:						Tuple									=      {
			    'prior': prior,
			    'image_encoder': image_encoder,
			    'image_processor': image_processor,
			    'renderer': renderer,
			    'scheduler': scheduler,
			}

			return components

		def 							__lowerCamelCase							(      self       ,		_SCREAMING_SNAKE_CASE       ,		_SCREAMING_SNAKE_CASE=0 ):
			__lowerCAmelCase			:						Optional[Any]									=      floats_tensor((1, 3, 64, 64)       ,		rng=random.Random(_SCREAMING_SNAKE_CASE ) ).to(_SCREAMING_SNAKE_CASE )

			if str(_SCREAMING_SNAKE_CASE ).startswith('mps' ):
				__lowerCAmelCase			:						int									=      torch.manual_seed(_SCREAMING_SNAKE_CASE )
			else:
				__lowerCAmelCase			:						str									=      torch.Generator(device=_SCREAMING_SNAKE_CASE ).manual_seed(_SCREAMING_SNAKE_CASE )
			__lowerCAmelCase			:						Optional[Any]									=      {
			    'image': input_image,
			    'generator': generator,
			    'num_inference_steps': 1,
			    'frame_size': 32,
			    'output_type': 'np',
			}
			return inputs

		def 							__lowerCamelCase							(      self ):
			__lowerCAmelCase			:						str									=      'cpu'

			__lowerCAmelCase			:						Dict									=      self.get_dummy_components()

			__lowerCAmelCase			:						Optional[int]									=      self.pipeline_class(**_SCREAMING_SNAKE_CASE )
			__lowerCAmelCase			:						List[Any]									=      pipe.to(_SCREAMING_SNAKE_CASE )

			pipe.set_progress_bar_config(disable=_SCREAMING_SNAKE_CASE )

			__lowerCAmelCase			:						List[Any]									=      pipe(**self.get_dummy_inputs(_SCREAMING_SNAKE_CASE ) )
			__lowerCAmelCase			:						Any									=      output.images[0]
			__lowerCAmelCase			:						Optional[Any]									=      image[0, -3:, -3:, -1]

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

			__lowerCAmelCase			:						List[Any]									=      np.array(
			    [
			        0.0003_9216,
			        0.0003_9216,
			        0.0003_9216,
			        0.0003_9216,
			        0.0003_9216,
			        0.0003_9216,
			        0.0003_9216,
			        0.0003_9216,
			        0.0003_9216,
			    ] )

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

		def 							__lowerCamelCase							(      self ):
			# NOTE: Larger batch sizes cause this test to timeout, only test on smaller batches
			self._test_inference_batch_consistent(batch_sizes=[1, 2] )

		def 							__lowerCamelCase							(      self ):
			__lowerCAmelCase			:						str									=      torch_device == 'cpu'
			__lowerCAmelCase			:						Optional[Any]									=      True
			self._test_inference_batch_single_identical(
			    batch_size=2       ,		test_max_difference=_SCREAMING_SNAKE_CASE       ,		relax_max_difference=_SCREAMING_SNAKE_CASE       ,		)







		def 							__lowerCamelCase							(      self ):
			__lowerCAmelCase			:						str									=      self.get_dummy_components()
			__lowerCAmelCase			:						List[str]									=      self.pipeline_class(**_SCREAMING_SNAKE_CASE )
			__lowerCAmelCase			:						Optional[int]									=      pipe.to(_SCREAMING_SNAKE_CASE )
			pipe.set_progress_bar_config(disable=_SCREAMING_SNAKE_CASE )

			__lowerCAmelCase			:						List[str]									=      1
			__lowerCAmelCase			:						List[str]									=      2

			__lowerCAmelCase			:						Union[str, Any]									=      self.get_dummy_inputs(_SCREAMING_SNAKE_CASE )

			for key in inputs.keys():
				if key in self.batch_params:
					__lowerCAmelCase			:						Optional[Any]									=      batch_size * [inputs[key]]

			__lowerCAmelCase			:						List[str]									=      pipe(**_SCREAMING_SNAKE_CASE       ,		num_images_per_prompt=_SCREAMING_SNAKE_CASE )[0]

			assert images.shape[0] == batch_size * num_images_per_prompt




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

		def 							__lowerCamelCase							(      self ):
			# clean up the VRAM after each test
			super().tearDown()
			gc.collect()
			torch.cuda.empty_cache()







		def 							__lowerCamelCase							(      self ):
			__lowerCAmelCase			:						int									=      load_image(
			    'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main' '/shap_e/corgi.png' )
			__lowerCAmelCase			:						Any									=      load_numpy(
			    'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'
			    '/shap_e/test_shap_e_img2img_out.npy' )
			__lowerCAmelCase			:						Union[str, Any]									=      ShapEImgaImgPipeline.from_pretrained('openai/shap-e-img2img' )
			__lowerCAmelCase			:						Dict									=      pipe.to(_SCREAMING_SNAKE_CASE )
			pipe.set_progress_bar_config(disable=_SCREAMING_SNAKE_CASE )

			__lowerCAmelCase			:						Tuple									=      torch.Generator(device=_SCREAMING_SNAKE_CASE ).manual_seed(0 )

			__lowerCAmelCase			:						int									=      pipe(
			    _SCREAMING_SNAKE_CASE       ,		generator=_SCREAMING_SNAKE_CASE       ,		guidance_scale=3.0       ,		num_inference_steps=64       ,		frame_size=64       ,		output_type='np'       ,		).images[0]

			assert images.shape == (20, 64, 64, 3)

			assert_mean_pixel_difference(_SCREAMING_SNAKE_CASE       ,		_SCREAMING_SNAKE_CASE )







"""simple docstring"""






from math import factorial



def 					_A			(__a = 20							) ->       int:
    """simple docstring"""






    SCREAMING_SNAKE_CASE_      :  Dict    						=		2 * n  # middle entry of odd rows starting at row 3 is the solution for n = 1,
    # 2, 3,...
    SCREAMING_SNAKE_CASE_      :  List[str]    						=		n // 2

    return int(factorial(__a							) / (factorial(__a							) * factorial(n - k							))							)


if __name__ == "__main__":
  import sys

  if len(sys.argv) == 1:
    print(solution(20))
  else:
    try:
      UpperCAmelCase_   : List[str]   			= int(sys.argv[1])
      print(solution(n))
    except ValueError:
      print("""Invalid entry - please enter a number.""")


