




'''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_				(			UpperCAmelCase__     ,						unittest.TestCase						):
	lowercase_       :     Union[str, Any]			  =      ShapEImgaImgPipeline
	lowercase_       :     Optional[Any]			  =      ['''image''']
	lowercase_       :     List[str]			  =      ['''image''']
	lowercase_       :     Dict			  =      [
	    '''num_images_per_prompt''',
	    '''num_inference_steps''',
	    '''generator''',
	    '''latents''',
	    '''guidance_scale''',
	    '''frame_size''',
	    '''output_type''',
	    '''return_dict''',
	]
	lowercase_       :     Dict			  =      False




	@property
	def   lowercase__   (       self     :  str      ):
							return 3_2




	@property
	def   lowercase__   (       self     :  Any      ):
							return 3_2




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




	@property
	def   lowercase__   (       self     :  str      ):
							return 8




	@property
	def   lowercase__   (       self     :  str      ):
							torch.manual_seed(0      )
							__snake_case						 =   CLIPVisionConfig(
							    hidden_size=self.text_embedder_hidden_size       ,		image_size=6_4       ,		projection_dim=self.text_embedder_hidden_size       ,		intermediate_size=3_7       ,		num_attention_heads=4       ,		num_channels=3       ,		num_hidden_layers=5       ,		patch_size=1       ,		)

							__snake_case						 =   CLIPVisionModel(__lowerCAmelCase      )
							return model




	@property
	def   lowercase__   (       self     :  Tuple      ):
							__snake_case						 =   CLIPImageProcessor(
							    crop_size=2_2_4       ,		do_center_crop=__lowerCAmelCase       ,		do_normalize=__lowerCAmelCase       ,		do_resize=__lowerCAmelCase       ,		image_mean=[0.48145466, 0.4578275, 0.40821073]       ,		image_std=[0.26862954, 0.26130258, 0.27577711]       ,		resample=3       ,		size=2_2_4       ,		)

							return image_processor




	@property
	def   lowercase__   (       self     :  Dict      ):
							torch.manual_seed(0      )

							__snake_case						 =   {
							    'num_attention_heads': 2,
							    'attention_head_dim': 1_6,
							    'embedding_dim': self.time_input_dim,
							    'num_embeddings': 3_2,
							    '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,
							}

							__snake_case						 =   PriorTransformer(**__lowerCAmelCase      )
							return model




	@property
	def   lowercase__   (       self     :  int      ):
							torch.manual_seed(0      )

							__snake_case						 =   {
							    'param_shapes': (
							        (self.renderer_dim, 9_3),
							        (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': 1_2,
							    'background': (
							        0.1,
							        0.1,
							        0.1,
							    ),
							}
							__snake_case						 =   ShapERenderer(**__lowerCAmelCase      )
							return model




	def   lowercase__   (       self     :  List[str]      ):
							__snake_case						 =   self.dummy_prior
							__snake_case						 =   self.dummy_image_encoder
							__snake_case						 =   self.dummy_image_processor
							__snake_case						 =   self.dummy_renderer

							__snake_case						 =   HeunDiscreteScheduler(
							    beta_schedule='exp'       ,		num_train_timesteps=1_0_2_4       ,		prediction_type='sample'       ,		use_karras_sigmas=__lowerCAmelCase       ,		clip_sample=__lowerCAmelCase       ,		clip_sample_range=1.0       ,		)
							__snake_case						 =   {
							    'prior': prior,
							    'image_encoder': image_encoder,
							    'image_processor': image_processor,
							    'renderer': renderer,
							    'scheduler': scheduler,
							}

							return components




	def   lowercase__   (       self     :  Tuple       ,		__lowerCAmelCase     :  List[Any]       ,		__lowerCAmelCase     :  Union[str, Any]=0      ):
							__snake_case						 =   floats_tensor((1, 3, 6_4, 6_4)       ,		rng=random.Random(__lowerCAmelCase      )      ).to(__lowerCAmelCase      )

							if str(__lowerCAmelCase      ).startswith('mps'      ):
													__snake_case						 =   torch.manual_seed(__lowerCAmelCase      )
							else:
													__snake_case						 =   torch.Generator(device=__lowerCAmelCase      ).manual_seed(__lowerCAmelCase      )
							__snake_case						 =   {
							    'image': input_image,
							    'generator': generator,
							    'num_inference_steps': 1,
							    'frame_size': 3_2,
							    'output_type': 'np',
							}
							return inputs




	def   lowercase__   (       self     :  Optional[int]      ):
							__snake_case						 =   'cpu'

							__snake_case						 =   self.get_dummy_components()

							__snake_case						 =   self.pipeline_class(**__lowerCAmelCase      )
							__snake_case						 =   pipe.to(__lowerCAmelCase      )

							pipe.set_progress_bar_config(disable=__lowerCAmelCase      )

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

							assert image.shape == (2_0, 3_2, 3_2, 3)

							__snake_case						 =   np.array(
							    [
							        0.00039216,
							        0.00039216,
							        0.00039216,
							        0.00039216,
							        0.00039216,
							        0.00039216,
							        0.00039216,
							        0.00039216,
							        0.00039216,
							    ]      )

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




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




	def   lowercase__   (       self     :  int      ):
							__snake_case						 =   torch_device == 'cpu'
							__snake_case						 =   True
							self._test_inference_batch_single_identical(
							    batch_size=2       ,		test_max_difference=__lowerCAmelCase       ,		relax_max_difference=__lowerCAmelCase       ,		)




	def   lowercase__   (       self     :  Optional[Any]      ):
							__snake_case						 =   self.get_dummy_components()
							__snake_case						 =   self.pipeline_class(**__lowerCAmelCase      )
							__snake_case						 =   pipe.to(__lowerCAmelCase      )
							pipe.set_progress_bar_config(disable=__lowerCAmelCase      )

							__snake_case						 =   1
							__snake_case						 =   2

							__snake_case						 =   self.get_dummy_inputs(__lowerCAmelCase      )

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

							__snake_case						 =   pipe(**__lowerCAmelCase       ,		num_images_per_prompt=__lowerCAmelCase      )[0]

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





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




	def   lowercase__   (       self     :  List[str]      ):
							# clean up the VRAM after each test
							super().tearDown()
							gc.collect()
							torch.cuda.empty_cache()




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

							__snake_case						 =   torch.Generator(device=__lowerCAmelCase      ).manual_seed(0      )

							__snake_case						 =   pipe(
							    __lowerCAmelCase       ,		generator=__lowerCAmelCase       ,		guidance_scale=3.0       ,		num_inference_steps=6_4       ,		frame_size=6_4       ,		output_type='np'       ,		).images[0]

							assert images.shape == (2_0, 6_4, 6_4, 3)

							assert_mean_pixel_difference(__lowerCAmelCase       ,		__lowerCAmelCase      )







'''simple docstring'''


def 						lowerCamelCase__   (				a							):
						if not all(x.isalpha() for x in string							):
												raise ValueError('String must only contain alphabetic characters.'							)

						__snake_case						 =   sorted(string.lower()							)
						return len(a							) == len(set(a							)							)


if __name__ == "__main__":
	_lowercase  =			input("""Enter a string """).strip()

	_lowercase  =			is_isogram(input_str)
	print(f'''{input_str} is {'an' if isogram else 'not an'} isogram.''')

