




'''simple docstring'''







import os
import unittest

from transformers import MobileBertTokenizer, MobileBertTokenizerFast
from transformers.models.bert.tokenization_bert import (
    VOCAB_FILES_NAMES,
    BasicTokenizer,
    WordpieceTokenizer,
    _is_control,
    _is_punctuation,
    _is_whitespace,
)
from transformers.testing_utils import require_tokenizers, slow

from ...test_tokenization_common import TokenizerTesterMixin, filter_non_english


@require_tokenizers
class     _a						(			__a							,							unittest.TestCase				):
       __a       :  Dict            =      MobileBertTokenizer
       __a       :  Tuple            =      MobileBertTokenizerFast
       __a       :  List[Any]            =      True
       __a       :  int            =      True
       __a       :  List[str]            =      filter_non_english
       __a       :  Tuple            =      """google/mobilebert-uncased"""
       def 					A   (			self		:			int       ):



           '''simple docstring'''

           super().setUp()

           UpperCAmelCase     =	[
               '''[UNK]''',
               '''[CLS]''',
               '''[SEP]''',
               '''[PAD]''',
               '''[MASK]''',
               '''want''',
               '''##want''',
               '''##ed''',
               '''wa''',
               '''un''',
               '''runn''',
               '''##ing''',
               ''',''',
               '''low''',
               '''lowest''',
           ]
           UpperCAmelCase     =	os.path.join(self.tmpdirname     ,       VOCAB_FILES_NAMES['''vocab_file''']       )
           with open(self.vocab_file     ,       '''w'''     ,       encoding='''utf-8'''       ) as vocab_writer:
               vocab_writer.write(''''''.join([x + '''\n''' for x in vocab_tokens]       )       )

           UpperCAmelCase     =	[
               (tokenizer_def[0], self.pre_trained_model_path, tokenizer_def[2])  # else the 'google/' prefix is stripped
               for tokenizer_def in self.tokenizers_list
           ]
       def 					A   (			self		:			Any     ,       lowercase		:			List[str]       ):



           '''simple docstring'''

           UpperCAmelCase     =	'''UNwant\u00E9d,running'''
           UpperCAmelCase     =	'''unwanted, running'''
           return input_text, output_text
       def 					A   (			self		:			Tuple       ):



           '''simple docstring'''

           UpperCAmelCase     =	self.tokenizer_class(self.vocab_file       )

           UpperCAmelCase     =	tokenizer.tokenize('''UNwant\u00E9d,running'''       )
           self.assertListEqual(lowercase     ,       ['''un''', '''##want''', '''##ed''', ''',''', '''runn''', '''##ing''']       )
           self.assertListEqual(tokenizer.convert_tokens_to_ids(lowercase       )     ,       [9, 6, 7, 12, 10, 11]       )
       def 					A   (			self		:			str       ):



           '''simple docstring'''

           if not self.test_rust_tokenizer:
               return

           UpperCAmelCase     =	self.get_tokenizer()
           UpperCAmelCase     =	self.get_rust_tokenizer()

           UpperCAmelCase     =	'''UNwant\u00E9d,running'''

           UpperCAmelCase     =	tokenizer.tokenize(lowercase       )
           UpperCAmelCase     =	rust_tokenizer.tokenize(lowercase       )
           self.assertListEqual(lowercase     ,       lowercase       )

           UpperCAmelCase     =	tokenizer.encode(lowercase     ,       add_special_tokens=lowercase       )
           UpperCAmelCase     =	rust_tokenizer.encode(lowercase     ,       add_special_tokens=lowercase       )
           self.assertListEqual(lowercase     ,       lowercase       )

           UpperCAmelCase     =	self.get_rust_tokenizer()
           UpperCAmelCase     =	tokenizer.encode(lowercase       )
           UpperCAmelCase     =	rust_tokenizer.encode(lowercase       )
           self.assertListEqual(lowercase     ,       lowercase       )

           # With lower casing
           UpperCAmelCase     =	self.get_tokenizer(do_lower_case=lowercase       )
           UpperCAmelCase     =	self.get_rust_tokenizer(do_lower_case=lowercase       )

           UpperCAmelCase     =	'''UNwant\u00E9d,running'''

           UpperCAmelCase     =	tokenizer.tokenize(lowercase       )
           UpperCAmelCase     =	rust_tokenizer.tokenize(lowercase       )
           self.assertListEqual(lowercase     ,       lowercase       )

           UpperCAmelCase     =	tokenizer.encode(lowercase     ,       add_special_tokens=lowercase       )
           UpperCAmelCase     =	rust_tokenizer.encode(lowercase     ,       add_special_tokens=lowercase       )
           self.assertListEqual(lowercase     ,       lowercase       )

           UpperCAmelCase     =	self.get_rust_tokenizer()
           UpperCAmelCase     =	tokenizer.encode(lowercase       )
           UpperCAmelCase     =	rust_tokenizer.encode(lowercase       )
           self.assertListEqual(lowercase     ,       lowercase       )
       def 					A   (			self		:			Tuple       ):



           '''simple docstring'''

           UpperCAmelCase     =	BasicTokenizer()

           self.assertListEqual(tokenizer.tokenize('''ah\u535A\u63A8zz'''       )     ,       ['''ah''', '''\u535A''', '''\u63A8''', '''zz''']       )
       def 					A   (			self		:			Optional[int]       ):



           '''simple docstring'''

           UpperCAmelCase     =	BasicTokenizer(do_lower_case=lowercase       )

           self.assertListEqual(
               tokenizer.tokenize(''' \tHeLLo!how  \n Are yoU?  '''       )     ,       ['''hello''', '''!''', '''how''', '''are''', '''you''', '''?''']       )
           self.assertListEqual(tokenizer.tokenize('''H\u00E9llo'''       )     ,       ['''hello''']       )
       def 					A   (			self		:			Any       ):



           '''simple docstring'''

           UpperCAmelCase     =	BasicTokenizer(do_lower_case=lowercase     ,       strip_accents=lowercase       )

           self.assertListEqual(
               tokenizer.tokenize(''' \tHäLLo!how  \n Are yoU?  '''       )     ,       ['''hällo''', '''!''', '''how''', '''are''', '''you''', '''?''']       )
           self.assertListEqual(tokenizer.tokenize('''H\u00E9llo'''       )     ,       ['''h\u00E9llo''']       )
       def 					A   (			self		:			Dict       ):



           '''simple docstring'''

           UpperCAmelCase     =	BasicTokenizer(do_lower_case=lowercase     ,       strip_accents=lowercase       )

           self.assertListEqual(
               tokenizer.tokenize(''' \tHäLLo!how  \n Are yoU?  '''       )     ,       ['''hallo''', '''!''', '''how''', '''are''', '''you''', '''?''']       )
           self.assertListEqual(tokenizer.tokenize('''H\u00E9llo'''       )     ,       ['''hello''']       )
       def 					A   (			self		:			List[Any]       ):



           '''simple docstring'''

           UpperCAmelCase     =	BasicTokenizer(do_lower_case=lowercase       )

           self.assertListEqual(
               tokenizer.tokenize(''' \tHäLLo!how  \n Are yoU?  '''       )     ,       ['''hallo''', '''!''', '''how''', '''are''', '''you''', '''?''']       )
           self.assertListEqual(tokenizer.tokenize('''H\u00E9llo'''       )     ,       ['''hello''']       )
       def 					A   (			self		:			Union[str, Any]       ):



           '''simple docstring'''

           UpperCAmelCase     =	BasicTokenizer(do_lower_case=lowercase       )

           self.assertListEqual(
               tokenizer.tokenize(''' \tHeLLo!how  \n Are yoU?  '''       )     ,       ['''HeLLo''', '''!''', '''how''', '''Are''', '''yoU''', '''?''']       )
       def 					A   (			self		:			List[str]       ):



           '''simple docstring'''

           UpperCAmelCase     =	BasicTokenizer(do_lower_case=lowercase     ,       strip_accents=lowercase       )

           self.assertListEqual(
               tokenizer.tokenize(''' \tHäLLo!how  \n Are yoU?  '''       )     ,       ['''HäLLo''', '''!''', '''how''', '''Are''', '''yoU''', '''?''']       )
       def 					A   (			self		:			Union[str, Any]       ):



           '''simple docstring'''

           UpperCAmelCase     =	BasicTokenizer(do_lower_case=lowercase     ,       strip_accents=lowercase       )

           self.assertListEqual(
               tokenizer.tokenize(''' \tHäLLo!how  \n Are yoU?  '''       )     ,       ['''HaLLo''', '''!''', '''how''', '''Are''', '''yoU''', '''?''']       )
       def 					A   (			self		:			Optional[Any]       ):



           '''simple docstring'''

           UpperCAmelCase     =	BasicTokenizer(do_lower_case=lowercase     ,       never_split=['''[UNK]''']       )

           self.assertListEqual(
               tokenizer.tokenize(''' \tHeLLo!how  \n Are yoU? [UNK]'''       )     ,       ['''HeLLo''', '''!''', '''how''', '''Are''', '''yoU''', '''?''', '''[UNK]''']       )
       def 					A   (			self		:			Union[str, Any]       ):



           '''simple docstring'''

           UpperCAmelCase     =	['''[UNK]''', '''[CLS]''', '''[SEP]''', '''want''', '''##want''', '''##ed''', '''wa''', '''un''', '''runn''', '''##ing''']

           UpperCAmelCase     =	{}
           for i, token in enumerate(lowercase       ):
               UpperCAmelCase     =	i
           UpperCAmelCase     =	WordpieceTokenizer(vocab=lowercase     ,       unk_token='''[UNK]'''       )

           self.assertListEqual(tokenizer.tokenize(''''''       )     ,       []       )

           self.assertListEqual(tokenizer.tokenize('''unwanted running'''       )     ,       ['''un''', '''##want''', '''##ed''', '''runn''', '''##ing''']       )

           self.assertListEqual(tokenizer.tokenize('''unwantedX running'''       )     ,       ['''[UNK]''', '''runn''', '''##ing''']       )
       def 					A   (			self		:			Optional[int]       ):



           '''simple docstring'''

           self.assertTrue(_is_whitespace(''' '''       )       )
           self.assertTrue(_is_whitespace('''\t'''       )       )
           self.assertTrue(_is_whitespace('''\r'''       )       )
           self.assertTrue(_is_whitespace('''\n'''       )       )
           self.assertTrue(_is_whitespace('''\u00A0'''       )       )

           self.assertFalse(_is_whitespace('''A'''       )       )
           self.assertFalse(_is_whitespace('''-'''       )       )
       def 					A   (			self		:			str       ):



           '''simple docstring'''

           self.assertTrue(_is_control('''\u0005'''       )       )

           self.assertFalse(_is_control('''A'''       )       )
           self.assertFalse(_is_control(''' '''       )       )
           self.assertFalse(_is_control('''\t'''       )       )
           self.assertFalse(_is_control('''\r'''       )       )
       def 					A   (			self		:			Any       ):



           '''simple docstring'''

           self.assertTrue(_is_punctuation('''-'''       )       )
           self.assertTrue(_is_punctuation('''$'''       )       )
           self.assertTrue(_is_punctuation('''`'''       )       )
           self.assertTrue(_is_punctuation('''.'''       )       )

           self.assertFalse(_is_punctuation('''A'''       )       )
           self.assertFalse(_is_punctuation(''' '''       )       )
       def 					A   (			self		:			List[Any]       ):



           '''simple docstring'''

           UpperCAmelCase     =	self.get_tokenizer()
           UpperCAmelCase     =	self.get_rust_tokenizer()

           # Example taken from the issue https://github.com/huggingface/tokenizers/issues/340
           self.assertListEqual([tokenizer.tokenize(lowercase       ) for t in ['''Test''', '''\xad''', '''test''']]     ,       [['''[UNK]'''], [], ['''[UNK]''']]       )

           self.assertListEqual(
               [rust_tokenizer.tokenize(lowercase       ) for t in ['''Test''', '''\xad''', '''test''']]     ,       [['''[UNK]'''], [], ['''[UNK]''']]       )
       @slow
       def 					A   (			self		:			List[Any]       ):



           '''simple docstring'''

           UpperCAmelCase     =	self.tokenizer_class.from_pretrained('''google/mobilebert-uncased'''       )

           UpperCAmelCase     =	tokenizer.encode('''sequence builders'''     ,       add_special_tokens=lowercase       )
           UpperCAmelCase     =	tokenizer.encode('''multi-sequence build'''     ,       add_special_tokens=lowercase       )

           UpperCAmelCase     =	tokenizer.build_inputs_with_special_tokens(lowercase       )
           UpperCAmelCase     =	tokenizer.build_inputs_with_special_tokens(lowercase     ,       lowercase       )

           assert encoded_sentence == [101] + text + [102]
           assert encoded_pair == [101] + text + [102] + text_a + [102]
       def 					A   (			self		:			Union[str, Any]       ):



           '''simple docstring'''

           for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
               with self.subTest(f"{tokenizer.__class__.__name__} ({pretrained_name})"       ):
                   UpperCAmelCase     =	self.rust_tokenizer_class.from_pretrained(lowercase     ,       **lowercase       )

                   UpperCAmelCase     =	f"A, naïve {tokenizer_r.mask_token} AllenNLP sentence."
                   UpperCAmelCase     =	tokenizer_r.encode_plus(
                       lowercase     ,       return_attention_mask=lowercase     ,       return_token_type_ids=lowercase     ,       return_offsets_mapping=lowercase     ,       add_special_tokens=lowercase     ,       )

                   UpperCAmelCase     =	tokenizer_r.do_lower_case if hasattr(lowercase     ,       '''do_lower_case'''       ) else False
                   UpperCAmelCase     =	(
                       [
                           ((0, 0), tokenizer_r.cls_token),
                           ((0, 1), '''A'''),
                           ((1, 2), ''','''),
                           ((3, 5), '''na'''),
                           ((5, 6), '''##ï'''),
                           ((6, 8), '''##ve'''),
                           ((9, 15), tokenizer_r.mask_token),
                           ((16, 21), '''Allen'''),
                           ((21, 23), '''##NL'''),
                           ((23, 24), '''##P'''),
                           ((25, 33), '''sentence'''),
                           ((33, 34), '''.'''),
                           ((0, 0), tokenizer_r.sep_token),
                       ]
                       if not do_lower_case
                       else [
                           ((0, 0), tokenizer_r.cls_token),
                           ((0, 1), '''a'''),
                           ((1, 2), ''','''),
                           ((3, 8), '''naive'''),
                           ((9, 15), tokenizer_r.mask_token),
                           ((16, 21), '''allen'''),
                           ((21, 23), '''##nl'''),
                           ((23, 24), '''##p'''),
                           ((25, 33), '''sentence'''),
                           ((33, 34), '''.'''),
                           ((0, 0), tokenizer_r.sep_token),
                       ]
                   )

                   self.assertEqual(
                       [e[1] for e in expected_results]     ,       tokenizer_r.convert_ids_to_tokens(tokens['''input_ids''']       )       )
                   self.assertEqual([e[0] for e in expected_results]     ,       tokens['''offset_mapping''']       )







       def 					A   (			self		:			Any       ):



           '''simple docstring'''

           UpperCAmelCase     =	['''的''', '''人''', '''有''']
           UpperCAmelCase     =	''''''.join(lowercase       )
           for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
               with self.subTest(f"{tokenizer.__class__.__name__} ({pretrained_name})"       ):
                   UpperCAmelCase     =	True
                   UpperCAmelCase     =	self.tokenizer_class.from_pretrained(lowercase     ,       **lowercase       )
                   UpperCAmelCase     =	self.rust_tokenizer_class.from_pretrained(lowercase     ,       **lowercase       )

                   UpperCAmelCase     =	tokenizer_p.encode(lowercase     ,       add_special_tokens=lowercase       )
                   UpperCAmelCase     =	tokenizer_r.encode(lowercase     ,       add_special_tokens=lowercase       )

                   UpperCAmelCase     =	tokenizer_r.convert_ids_to_tokens(lowercase       )
                   UpperCAmelCase     =	tokenizer_p.convert_ids_to_tokens(lowercase       )

                   # it is expected that each Chinese character is not preceded by "##"
                   self.assertListEqual(lowercase     ,       lowercase       )
                   self.assertListEqual(lowercase     ,       lowercase       )

                   UpperCAmelCase     =	False
                   UpperCAmelCase     =	self.rust_tokenizer_class.from_pretrained(lowercase     ,       **lowercase       )
                   UpperCAmelCase     =	self.tokenizer_class.from_pretrained(lowercase     ,       **lowercase       )

                   UpperCAmelCase     =	tokenizer_r.encode(lowercase     ,       add_special_tokens=lowercase       )
                   UpperCAmelCase     =	tokenizer_p.encode(lowercase     ,       add_special_tokens=lowercase       )

                   UpperCAmelCase     =	tokenizer_r.convert_ids_to_tokens(lowercase       )
                   UpperCAmelCase     =	tokenizer_p.convert_ids_to_tokens(lowercase       )

                   # it is expected that only the first Chinese character is not preceded by "##".
                   UpperCAmelCase     =	[
                       f"##{token}" if idx != 0 else token for idx, token in enumerate(lowercase       )
                   ]
                   self.assertListEqual(lowercase     ,       lowercase       )
                   self.assertListEqual(lowercase     ,       lowercase       )










'''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     _a						(			__a							,							unittest.TestCase				):
       __a       :  Tuple            =      ShapEPipeline
       __a       :  Tuple            =      ["""prompt"""]
       __a       :  Tuple            =      ["""prompt"""]
       __a       :  str            =      [
           """num_images_per_prompt""",
           """num_inference_steps""",
           """generator""",
           """latents""",
           """guidance_scale""",
           """frame_size""",
           """output_type""",
           """return_dict""",
       ]
       __a       :  Union[str, Any]            =      False
       @property
       def 					A   (			self		:			Optional[Any]       ):



           '''simple docstring'''

           return 32
       @property
       def 					A   (			self		:			List[Any]       ):



           '''simple docstring'''

           return 32
       @property
       def 					A   (			self		:			Union[str, Any]       ):



           '''simple docstring'''

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



           '''simple docstring'''

           return 8
       @property
       def 					A   (			self		:			Optional[Any]       ):



           '''simple docstring'''

           UpperCAmelCase     =	CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''       )
           return tokenizer
       @property
       def 					A   (			self		:			Union[str, Any]       ):



           '''simple docstring'''

           torch.manual_seed(0       )
           UpperCAmelCase     =	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(lowercase       )
       @property
       def 					A   (			self		:			Union[str, Any]       ):



           '''simple docstring'''

           torch.manual_seed(0       )

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

           UpperCAmelCase     =	PriorTransformer(**lowercase       )
           return model
       @property
       def 					A   (			self		:			List[Any]       ):



           '''simple docstring'''

           torch.manual_seed(0       )

           UpperCAmelCase     =	{
               '''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,
               ),
           }
           UpperCAmelCase     =	ShapERenderer(**lowercase       )
           return model
       def 					A   (			self		:			Tuple       ):



           '''simple docstring'''

           UpperCAmelCase     =	self.dummy_prior
           UpperCAmelCase     =	self.dummy_text_encoder
           UpperCAmelCase     =	self.dummy_tokenizer
           UpperCAmelCase     =	self.dummy_renderer

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

           return components
       def 					A   (			self		:			Dict     ,       lowercase		:			Optional[int]     ,       lowercase		:			Optional[int]=0       ):



           '''simple docstring'''

           if str(lowercase       ).startswith('''mps'''       ):
               UpperCAmelCase     =	torch.manual_seed(lowercase       )
           else:
               UpperCAmelCase     =	torch.Generator(device=lowercase       ).manual_seed(lowercase       )
           UpperCAmelCase     =	{
               '''prompt''': '''horse''',
               '''generator''': generator,
               '''num_inference_steps''': 1,
               '''frame_size''': 32,
               '''output_type''': '''np''',
           }
           return inputs
       def 					A   (			self		:			str       ):



           '''simple docstring'''

           UpperCAmelCase     =	'''cpu'''

           UpperCAmelCase     =	self.get_dummy_components()

           UpperCAmelCase     =	self.pipeline_class(**lowercase       )
           UpperCAmelCase     =	pipe.to(lowercase       )

           pipe.set_progress_bar_config(disable=lowercase       )

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

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

           UpperCAmelCase     =	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 					A   (			self		:			int       ):



           '''simple docstring'''

           self._test_inference_batch_consistent(batch_sizes=[1, 2]       )
       def 					A   (			self		:			Dict       ):



           '''simple docstring'''

           UpperCAmelCase     =	torch_device == '''cpu'''
           UpperCAmelCase     =	True

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







       def 					A   (			self		:			Any       ):



           '''simple docstring'''

           UpperCAmelCase     =	self.get_dummy_components()
           UpperCAmelCase     =	self.pipeline_class(**lowercase       )
           UpperCAmelCase     =	pipe.to(lowercase       )
           pipe.set_progress_bar_config(disable=lowercase       )

           UpperCAmelCase     =	1
           UpperCAmelCase     =	2

           UpperCAmelCase     =	self.get_dummy_inputs(lowercase       )

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

           UpperCAmelCase     =	pipe(**lowercase     ,       num_images_per_prompt=lowercase       )[0]

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






@slow
@require_torch_gpu
class     _a						(			unittest.TestCase				):
       def 					A   (			self		:			str       ):



           '''simple docstring'''

           super().tearDown()
           gc.collect()
           torch.cuda.empty_cache()







       def 					A   (			self		:			int       ):



           '''simple docstring'''

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

           UpperCAmelCase     =	torch.Generator(device=lowercase       ).manual_seed(0       )

           UpperCAmelCase     =	pipe(
               '''a shark'''     ,       generator=lowercase     ,       guidance_scale=15.0     ,       num_inference_steps=64     ,       frame_size=64     ,       output_type='''np'''     ,       ).images[0]

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

           assert_mean_pixel_difference(lowercase     ,       lowercase       )




