


"""simple docstring"""





import gc
import unittest

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

from diffusers import HeunDiscreteScheduler, PriorTransformer, ShapEPipeline
from diffusers.pipelines.shap_e import ShapERenderer
from diffusers.utils import 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 		snake_case_(       snake_case__							,					unittest.TestCase			):
     __UpperCamelCase  =					ShapEPipeline
     __UpperCamelCase  =					['''prompt''']
     __UpperCamelCase  =					['''prompt''']
     __UpperCamelCase  =					[
         '''num_images_per_prompt''',
         '''num_inference_steps''',
         '''generator''',
         '''latents''',
         '''guidance_scale''',
         '''frame_size''',
         '''output_type''',
         '''return_dict''',
     ]
     __UpperCamelCase  =					False






     @property
     def      lowerCamelCase__     (	self  :					int				):
           return 3_2






     @property
     def      lowerCamelCase__     (	self  :					Optional[int]				):
           return 3_2






     @property
     def      lowerCamelCase__     (	self  :					List[Any]				):
           return self.time_input_dim * 4






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






     @property
     def      lowerCamelCase__     (	self  :					Any				):
           lowerCAmelCase					:	List[Any]       =   CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''				)
           return tokenizer






     @property
     def      lowerCamelCase__     (	self  :					Dict				):
           torch.manual_seed(0				)
           lowerCAmelCase					:	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=3_7					,				layer_norm_eps=1E-05					,				num_attention_heads=4					,				num_hidden_layers=5					,				pad_token_id=1					,				vocab_size=1_0_0_0					,				)
           return CLIPTextModelWithProjection(_A				)






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

           lowerCAmelCase					:	int       =   {
               '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',
               'encoder_hid_proj_type': None,
               'added_emb_type': None,
           }

           lowerCAmelCase					:	Optional[Any]       =   PriorTransformer(**_A				)
           return model






     @property
     def      lowerCamelCase__     (	self  :					Tuple				):
           torch.manual_seed(0				)

           lowerCAmelCase					:	List[str]       =   {
               '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,
               ),
           }
           lowerCAmelCase					:	List[Any]       =   ShapERenderer(**_A				)
           return model






     def      lowerCamelCase__     (	self  :					Dict				):
           lowerCAmelCase					:	List[str]       =   self.dummy_prior
           lowerCAmelCase					:	Optional[int]       =   self.dummy_text_encoder
           lowerCAmelCase					:	List[Any]       =   self.dummy_tokenizer
           lowerCAmelCase					:	str       =   self.dummy_renderer

           lowerCAmelCase					:	List[Any]       =   HeunDiscreteScheduler(
               beta_schedule='''exp'''					,				num_train_timesteps=1_0_2_4					,				prediction_type='''sample'''					,				use_karras_sigmas=_A					,				clip_sample=_A					,				clip_sample_range=1.0					,				)
           lowerCAmelCase					:	Any       =   {
               'prior': prior,
               'text_encoder': text_encoder,
               'tokenizer': tokenizer,
               'renderer': renderer,
               'scheduler': scheduler,
           }

           return components






     def      lowerCamelCase__     (	self  :					int					,				UpperCamelCase_  :					str					,				UpperCamelCase_  :					List[Any]=0				):
           if str(_A				).startswith('''mps'''				):
                 lowerCAmelCase					:	List[Any]       =   torch.manual_seed(_A				)
           else:
                 lowerCAmelCase					:	Dict       =   torch.Generator(device=_A				).manual_seed(_A				)
           lowerCAmelCase					:	int       =   {
               'prompt': 'horse',
               'generator': generator,
               'num_inference_steps': 1,
               'frame_size': 3_2,
               'output_type': 'np',
           }
           return inputs






     def      lowerCamelCase__     (	self  :					List[str]				):
           lowerCAmelCase					:	Tuple       =   'cpu'

           lowerCAmelCase					:	Any       =   self.get_dummy_components()

           lowerCAmelCase					:	Tuple       =   self.pipeline_class(**_A				)
           lowerCAmelCase					:	List[str]       =   pipe.to(_A				)

           pipe.set_progress_bar_config(disable=_A				)

           lowerCAmelCase					:	Tuple       =   pipe(**self.get_dummy_inputs(_A				)				)
           lowerCAmelCase					:	int       =   output.images[0]
           lowerCAmelCase					:	str       =   image[0, -3:, -3:, -1]

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

           lowerCAmelCase					:	Any       =   np.array(
               [
                   0.00_039_216,
                   0.00_039_216,
                   0.00_039_216,
                   0.00_039_216,
                   0.00_039_216,
                   0.00_039_216,
                   0.00_039_216,
                   0.00_039_216,
                   0.00_039_216,
               ]				)

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






     def      lowerCamelCase__     (	self  :					int				):
           # 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  :					List[str]				):
           lowerCAmelCase					:	List[str]       =   torch_device == 'cpu'
           lowerCAmelCase					:	Any       =   True

           self._test_inference_batch_single_identical(
               batch_size=2					,				test_max_difference=_A					,				relax_max_difference=_A					,				)






     def      lowerCamelCase__     (	self  :					List[str]				):
           lowerCAmelCase					:	Any       =   self.get_dummy_components()
           lowerCAmelCase					:	Any       =   self.pipeline_class(**_A				)
           lowerCAmelCase					:	Dict       =   pipe.to(_A				)
           pipe.set_progress_bar_config(disable=_A				)

           lowerCAmelCase					:	Any       =   1
           lowerCAmelCase					:	Dict       =   2

           lowerCAmelCase					:	Tuple       =   self.get_dummy_inputs(_A				)

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

           lowerCAmelCase					:	Optional[int]       =   pipe(**_A					,				num_images_per_prompt=_A				)[0]

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



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






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






     def      lowerCamelCase__     (	self  :					str				):
           lowerCAmelCase					:	List[str]       =   load_numpy(
               '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'''
               '''/shap_e/test_shap_e_np_out.npy'''				)
           lowerCAmelCase					:	Dict       =   ShapEPipeline.from_pretrained('''openai/shap-e'''				)
           lowerCAmelCase					:	int       =   pipe.to(_A				)
           pipe.set_progress_bar_config(disable=_A				)

           lowerCAmelCase					:	str       =   torch.Generator(device=_A				).manual_seed(0				)

           lowerCAmelCase					:	Tuple       =   pipe(
               '''a shark'''					,				generator=_A					,				guidance_scale=1_5.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(_A					,				_A				)






"""simple docstring"""





snake_case__		:     List[Any]    				=				'''Tobias Carryer'''

from time import time



class 		snake_case_:






     def __init__(	self  :					Optional[Any]					,				UpperCamelCase_  :					Optional[Any]					,				UpperCamelCase_  :					Tuple					,				UpperCamelCase_  :					Optional[int]					,				UpperCamelCase_  :					Dict=int(time()				)				):  # noqa: B008
           lowerCAmelCase					:	str       =   multiplier
           lowerCAmelCase					:	Optional[int]       =   increment
           lowerCAmelCase					:	Optional[Any]       =   modulo
           lowerCAmelCase					:	Optional[Any]       =   seed






     def      lowerCamelCase__     (	self  :					Union[str, Any]				):
           lowerCAmelCase					:	Optional[int]       =   (self.multiplier * self.seed + self.increment) % self.modulo
           return self.seed


if __name__ == "__main__":
 # Show the LCG in action.
 snake_case__		:     int    				=				LinearCongruentialGenerator(1_664_525, 1_013_904_223, 2 << 31)
 while True:
  print(lcg.next_number())


