



'''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       __magic_name__		(       _UpperCamelCase     ,		unittest.TestCase  ):
							lowerCAmelCase			:       Optional[int]  							=   ShapEPipeline
							lowerCAmelCase			:       Union[str, Any]  							=   ['prompt']
							lowerCAmelCase			:       List[Any]  							=   ['prompt']
							lowerCAmelCase			:       Dict  							=   [
							    'num_images_per_prompt',
							    'num_inference_steps',
							    'generator',
							    'latents',
							    'guidance_scale',
							    'frame_size',
							    'output_type',
							    'return_dict',
							]
							lowerCAmelCase			:       Dict  							=   False







							@property
							def 				__lowercase     (				self   :			Optional[int]						):
									return 32







							@property
							def 				__lowercase     (				self   :			Optional[int]						):
									return 32







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







							@property
							def 				__lowercase     (				self   :			Optional[int]						):
									return 8







							@property
							def 				__lowercase     (				self   :			Optional[int]						):
									_a	: Optional[int]								=				CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'						)
									return tokenizer







							@property
							def 				__lowercase     (				self   :			List[Any]						):
									torch.manual_seed(0						)
									_a	: str								=				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=1000      ,)
									return CLIPTextModelWithProjection(_UpperCAmelCase						)







							@property
							def 				__lowercase     (				self   :			Optional[int]						):
									torch.manual_seed(0						)

									_a	: Tuple								=				{
									    '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,
									}

									_a	: Tuple								=				PriorTransformer(**_UpperCAmelCase						)
									return model







							@property
							def 				__lowercase     (				self   :			List[Any]						):
									torch.manual_seed(0						)

									_a	: Any								=				{
									    '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,
									    ),
									}
									_a	: Optional[Any]								=				ShapERenderer(**_UpperCAmelCase						)
									return model







							def 				__lowercase     (				self   :			List[str]						):
									_a	: Union[str, Any]								=				self.dummy_prior
									_a	: int								=				self.dummy_text_encoder
									_a	: Dict								=				self.dummy_tokenizer
									_a	: Dict								=				self.dummy_renderer

									_a	: Optional[int]								=				HeunDiscreteScheduler(
									    beta_schedule='exp'      ,num_train_timesteps=1024      ,prediction_type='sample'      ,use_karras_sigmas=_UpperCAmelCase      ,clip_sample=_UpperCAmelCase      ,clip_sample_range=1.0      ,)
									_a	: List[Any]								=				{
									    'prior': prior,
									    'text_encoder': text_encoder,
									    'tokenizer': tokenizer,
									    'renderer': renderer,
									    'scheduler': scheduler,
									}

									return components







							def 				__lowercase     (				self   :			Union[str, Any]      ,_UpperCAmelCase   :			List[str]      ,_UpperCAmelCase   :			Union[str, Any]=0						):
									if str(_UpperCAmelCase						).startswith('mps'						):
											_a	: Union[str, Any]								=				torch.manual_seed(_UpperCAmelCase						)
									else:
											_a	: Dict								=				torch.Generator(device=_UpperCAmelCase						).manual_seed(_UpperCAmelCase						)
									_a	: Optional[Any]								=				{
									    'prompt': 'horse',
									    'generator': generator,
									    'num_inference_steps': 1,
									    'frame_size': 32,
									    'output_type': 'np',
									}
									return inputs







							def 				__lowercase     (				self   :			Optional[int]						):
									_a	: Dict								=				'cpu'

									_a	: List[str]								=				self.get_dummy_components()

									_a	: Dict								=				self.pipeline_class(**_UpperCAmelCase						)
									_a	: Union[str, Any]								=				pipe.to(_UpperCAmelCase						)

									pipe.set_progress_bar_config(disable=_UpperCAmelCase						)

									_a	: Optional[int]								=				pipe(**self.get_dummy_inputs(_UpperCAmelCase						)						)
									_a	: List[Any]								=				output.images[0]
									_a	: str								=				image[0, -3:, -3:, -1]

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

									_a	: Union[str, Any]								=				np.array(
									    [
									        0.00_03_92_16,
									        0.00_03_92_16,
									        0.00_03_92_16,
									        0.00_03_92_16,
									        0.00_03_92_16,
									        0.00_03_92_16,
									        0.00_03_92_16,
									        0.00_03_92_16,
									        0.00_03_92_16,
									    ]						)

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







							def 				__lowercase     (				self   :			Tuple						):
									# 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   :			Any						):
									_a	: Union[str, Any]								=				torch_device == 'cpu'
									_a	: Optional[int]								=				True

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







							def 				__lowercase     (				self   :			List[str]						):
									_a	: Any								=				self.get_dummy_components()
									_a	: Optional[int]								=				self.pipeline_class(**_UpperCAmelCase						)
									_a	: List[Any]								=				pipe.to(_UpperCAmelCase						)
									pipe.set_progress_bar_config(disable=_UpperCAmelCase						)

									_a	: int								=				1
									_a	: str								=				2

									_a	: Dict								=				self.get_dummy_inputs(_UpperCAmelCase						)

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

									_a	: List[str]								=				pipe(**_UpperCAmelCase      ,num_images_per_prompt=_UpperCAmelCase						)[0]

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

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







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







							def 				__lowercase     (				self   :			int						):
									_a	: int								=				load_numpy(
									    'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'
									    '/shap_e/test_shap_e_np_out.npy'						)
									_a	: Union[str, Any]								=				ShapEPipeline.from_pretrained('openai/shap-e'						)
									_a	: str								=				pipe.to(_UpperCAmelCase						)
									pipe.set_progress_bar_config(disable=_UpperCAmelCase						)

									_a	: int								=				torch.Generator(device=_UpperCAmelCase						).manual_seed(0						)

									_a	: Dict								=				pipe(
									    'a shark'      ,generator=_UpperCAmelCase      ,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(_UpperCAmelCase      ,_UpperCAmelCase						)









'''simple docstring'''

import unittest

from transformers import GPTSwaTokenizer
from transformers.testing_utils import get_tests_dir, require_sentencepiece, require_tokenizers, slow

from ...test_tokenization_common import TokenizerTesterMixin


__lowerCAmelCase		     =  get_tests_dir('''fixtures/test_sentencepiece_with_bytefallback.model''')

@require_sentencepiece
@require_tokenizers
class       __magic_name__		(       _UpperCamelCase     ,		unittest.TestCase  ):
							lowerCAmelCase			:       Tuple  							=   GPTSwaTokenizer
							lowerCAmelCase			:       Tuple  							=   False
							lowerCAmelCase			:       Optional[Any]  							=   True
							lowerCAmelCase			:       Any  							=   False







							def 				__lowercase     (				self   :			Any						):
									super().setUp()

									# We have a SentencePiece fixture for testing
									_a	: int								=				GPTSwaTokenizer(_UpperCAmelCase      ,eos_token='<unk>'      ,bos_token='<unk>'      ,pad_token='<unk>'						)

									tokenizer.save_pretrained(self.tmpdirname						)







							def 				__lowercase     (				self   :			Optional[Any]      ,_UpperCAmelCase   :			int						):
									_a	: Any								=				'This is a test'
									_a	: Any								=				'This is a test'
									return input_text, output_text







							def 				__lowercase     (				self   :			str						):
									_a	: Optional[Any]								=				'<s>'
									_a	: str								=				1

									self.assertEqual(self.get_tokenizer()._convert_token_to_id(_UpperCAmelCase						)      ,_UpperCAmelCase						)
									self.assertEqual(self.get_tokenizer()._convert_id_to_token(_UpperCAmelCase						)      ,_UpperCAmelCase						)







							def 				__lowercase     (				self   :			Union[str, Any]						):
									_a	: Dict								=				list(self.get_tokenizer().get_vocab().keys()						)

									self.assertEqual(vocab_keys[0]      ,'<unk>'						)
									self.assertEqual(vocab_keys[1]      ,'<s>'						)
									self.assertEqual(vocab_keys[-1]      ,'j'						)
									self.assertEqual(len(_UpperCAmelCase						)      ,2000						)







							def 				__lowercase     (				self   :			Optional[int]						):
									self.assertEqual(self.get_tokenizer().vocab_size      ,2000						)







							def 				__lowercase     (				self   :			List[Any]						):
									_a	: Union[str, Any]								=				GPTSwaTokenizer(_UpperCAmelCase						)

									_a	: str								=				tokenizer.tokenize('This is a test'						)
									self.assertListEqual(_UpperCAmelCase      ,['▁This', '▁is', '▁a', '▁t', 'est']						)

									self.assertListEqual(tokenizer.convert_tokens_to_ids(_UpperCAmelCase						)      ,[465, 287, 265, 631, 842]						)

									_a	: Any								=				tokenizer.tokenize('I was born in 92000, and this is falsé.'						)
									# fmt: off
									self.assertListEqual(
									    _UpperCAmelCase      ,['▁I', '▁was', '▁bor', 'n', '▁in', '▁', '<0x39>', '2', '0', '0', '0', ',', '▁and', '▁this', '▁is', '▁f', 'al', 's', '<0xC3>', '<0xA9>', '.']      ,)
									# fmt: on

									_a	: Optional[Any]								=				tokenizer.convert_tokens_to_ids(_UpperCAmelCase						)
									self.assertListEqual(
									    _UpperCAmelCase      ,[262, 272, 1525, 286, 271, 268, 60, 916, 633, 633, 633, 259, 266, 301, 287, 384, 367, 263, 198, 172, 260]      ,)

									_a	: List[str]								=				tokenizer.convert_ids_to_tokens(_UpperCAmelCase						)
									# fmt: off
									self.assertListEqual(
									    _UpperCAmelCase      ,['▁I', '▁was', '▁bor', 'n', '▁in', '▁', '<0x39>', '2', '0', '0', '0', ',', '▁and', '▁this', '▁is', '▁f', 'al', 's', '<0xC3>', '<0xA9>', '.']						)
									# fmt: on







							def 				__lowercase     (				self   :			str						):
									_a	: List[Any]								=				GPTSwaTokenizer(_UpperCAmelCase						)
									_a	: Optional[Any]								=				['This is a test', 'I was born in 92000, and this is falsé.']
									_a	: Dict								=				[
									    [465, 287, 265, 631, 842],
									    [262, 272, 1525, 286, 271, 268, 60, 916, 633, 633, 633, 259, 266, 301, 287, 384, 367, 263, 198, 172, 260],
									]

									# Test that encode_fast returns the same as tokenize + convert_tokens_to_ids
									for text, expected_ids in zip(_UpperCAmelCase      ,_UpperCAmelCase						):
											self.assertListEqual(tokenizer.encode_fast(_UpperCAmelCase						)      ,_UpperCAmelCase						)

									# Test that decode_fast returns the input text
									for text, token_ids in zip(_UpperCAmelCase      ,_UpperCAmelCase						):
											self.assertEqual(tokenizer.decode_fast(_UpperCAmelCase						)      ,_UpperCAmelCase						)







							@slow
							def 				__lowercase     (				self   :			Optional[Any]						):
									_a	: Optional[int]								=				[
									    '<|python|>def fibonacci(n)\n    if n < 0:\n        print(\'Incorrect input\')',
									    'Hey there, how are you doing this fine day?',
									    'This is a text with a trailing spaces followed by a dot     .',
									    'Häj sväjs lillebrör! =)',
									    'Det är inget fel på Mr. Cool',
									]

									# fmt: off
									_a	: Tuple								=				{'input_ids': [[63423, 5, 6811, 14954, 282, 816, 3821, 63466, 63425, 63462, 18, 63978, 678, 301, 1320, 63423, 63455, 63458, 18, 63982, 4246, 3940, 1901, 47789, 5547, 18994], [19630, 1100, 63446, 1342, 633, 544, 4488, 593, 5102, 2416, 63495, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1652, 428, 268, 1936, 515, 268, 58593, 22413, 9106, 546, 268, 33213, 63979, 698, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [55130, 63450, 924, 63449, 2249, 4062, 1558, 318, 63504, 21498, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [509, 377, 2827, 2559, 332, 6575, 63443, 26801, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], 'token_type_ids': [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], 'attention_mask': [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]}
									# fmt: on
									self.tokenizer_integration_test_util(
									    expected_encoding=_UpperCAmelCase      ,model_name='AI-Sweden/gpt-sw3-126m'      ,sequences=_UpperCAmelCase      ,)




