

'''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     lowercase_			(lowerCamelCase__       , unittest.TestCase   ):




  """simple docstring"""




  SCREAMING_SNAKE_CASE					:						str           =    ShapEPipeline
  SCREAMING_SNAKE_CASE					:						Optional[Any]           =    ['prompt']
  SCREAMING_SNAKE_CASE					:						Tuple           =    ['prompt']
  SCREAMING_SNAKE_CASE					:						int           =    [
      'num_images_per_prompt',
      'num_inference_steps',
      'generator',
      'latents',
      'guidance_scale',
      'frame_size',
      'output_type',
      'return_dict',
  ]
  SCREAMING_SNAKE_CASE					:						Optional[int]           =    False






  @property
  def       SCREAMING_SNAKE_CASE   (   self     :  Tuple    ):
   return 3_2






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






  @property
  def       SCREAMING_SNAKE_CASE   (   self     :  Optional[int]    ):
   return self.time_input_dim * 4






  @property
  def       SCREAMING_SNAKE_CASE   (   self     :  List[Any]    ):
   return 8






  @property
  def       SCREAMING_SNAKE_CASE   (   self     :  Any    ):
   __lowercase													=				CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''    )
   return tokenizer






  @property
  def       SCREAMING_SNAKE_CASE   (   self     :  List[Any]    ):
   torch.manual_seed(0    )
   __lowercase													=				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-0_5      ,num_attention_heads=4      ,num_hidden_layers=5      ,pad_token_id=1      ,vocab_size=1_0_0_0      ,)
   return CLIPTextModelWithProjection(lowercase__    )






  @property
  def       SCREAMING_SNAKE_CASE   (   self     :  Optional[Any]    ):
   torch.manual_seed(0    )

   __lowercase													=				{
       '''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,
   }

   __lowercase													=				PriorTransformer(**lowercase__    )
   return model






  @property
  def       SCREAMING_SNAKE_CASE   (   self     :  List[str]    ):
   torch.manual_seed(0    )

   __lowercase													=				{
       '''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,
       ),
   }
   __lowercase													=				ShapERenderer(**lowercase__    )
   return model






  def       SCREAMING_SNAKE_CASE   (   self     :  int    ):
   __lowercase													=				self.dummy_prior
   __lowercase													=				self.dummy_text_encoder
   __lowercase													=				self.dummy_tokenizer
   __lowercase													=				self.dummy_renderer

   __lowercase													=				HeunDiscreteScheduler(
       beta_schedule='''exp'''      ,num_train_timesteps=1_0_2_4      ,prediction_type='''sample'''      ,use_karras_sigmas=lowercase__      ,clip_sample=lowercase__      ,clip_sample_range=1.0      ,)
   __lowercase													=				{
       '''prior''': prior,
       '''text_encoder''': text_encoder,
       '''tokenizer''': tokenizer,
       '''renderer''': renderer,
       '''scheduler''': scheduler,
   }

   return components






  def       SCREAMING_SNAKE_CASE   (   self     :  Tuple      ,lowercase__     :  Tuple      ,lowercase__     :  Tuple=0    ):
   if str(lowercase__    ).startswith('''mps'''    ):
    __lowercase													=				torch.manual_seed(lowercase__    )
   else:
    __lowercase													=				torch.Generator(device=lowercase__    ).manual_seed(lowercase__    )
   __lowercase													=				{
       '''prompt''': '''horse''',
       '''generator''': generator,
       '''num_inference_steps''': 1,
       '''frame_size''': 3_2,
       '''output_type''': '''np''',
   }
   return inputs






  def       SCREAMING_SNAKE_CASE   (   self     :  List[Any]    ):
   __lowercase													=				'''cpu'''

   __lowercase													=				self.get_dummy_components()

   __lowercase													=				self.pipeline_class(**lowercase__    )
   __lowercase													=				pipe.to(lowercase__    )

   pipe.set_progress_bar_config(disable=lowercase__    )

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

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

   __lowercase													=				np.array(
       [
           0.0_0_0_3_9_2_1_6,
           0.0_0_0_3_9_2_1_6,
           0.0_0_0_3_9_2_1_6,
           0.0_0_0_3_9_2_1_6,
           0.0_0_0_3_9_2_1_6,
           0.0_0_0_3_9_2_1_6,
           0.0_0_0_3_9_2_1_6,
           0.0_0_0_3_9_2_1_6,
           0.0_0_0_3_9_2_1_6,
       ]    )

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






  def       SCREAMING_SNAKE_CASE   (   self     :  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       SCREAMING_SNAKE_CASE   (   self     :  Dict    ):
   __lowercase													=				torch_device == '''cpu'''
   __lowercase													=				True

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






  def       SCREAMING_SNAKE_CASE   (   self     :  Optional[int]    ):
   __lowercase													=				self.get_dummy_components()
   __lowercase													=				self.pipeline_class(**lowercase__    )
   __lowercase													=				pipe.to(lowercase__    )
   pipe.set_progress_bar_config(disable=lowercase__    )

   __lowercase													=				1
   __lowercase													=				2

   __lowercase													=				self.get_dummy_inputs(lowercase__    )

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

   __lowercase													=				pipe(**lowercase__      ,num_images_per_prompt=lowercase__    )[0]

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






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




  """simple docstring"""




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






  def       SCREAMING_SNAKE_CASE   (   self     :  int    ):
   __lowercase													=				load_numpy(
       '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'''
       '''/shap_e/test_shap_e_np_out.npy'''    )
   __lowercase													=				ShapEPipeline.from_pretrained('''openai/shap-e'''    )
   __lowercase													=				pipe.to(lowercase__    )
   pipe.set_progress_bar_config(disable=lowercase__    )

   __lowercase													=				torch.Generator(device=lowercase__    ).manual_seed(0    )

   __lowercase													=				pipe(
       '''a shark'''      ,generator=lowercase__      ,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(lowercase__      ,lowercase__    )




'''simple docstring'''






import re


def 	_A  (					A__   ):






 """simple docstring"""



 __lowercase													=				re.compile(
     R'''^(?:0|94|\+94|0{2}94)''' R'''7(0|1|2|4|5|6|7|8)''' R'''(-| |)''' R'''\d{7}$'''   )

 return bool(re.search(A__  ,       A__   )   )


if __name__ == "__main__":
 lowerCAmelCase__      		=			'''0094702343221'''

 print(is_sri_lankan_phone_number(phone))

