

import gc
import random
import unittest

import numpy as np
import torch
from PIL import Image

from diffusers import (
    DDIMScheduler,
    KandinskyVaaImgaImgPipeline,
    KandinskyVaaPriorPipeline,
    UNetaDConditionModel,
    VQModel,
)
from diffusers.utils import floats_tensor, load_image, load_numpy, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

from ..test_pipelines_common import PipelineTesterMixin, assert_mean_pixel_difference


enable_full_determinism()

class 				UpperCAmelCase_		(			__lowercase				,       unittest.TestCase   ):
							"""simple docstring"""







							UpperCAmelCase__       :						Optional[int]	    =    KandinskyVaaImgaImgPipeline
							UpperCAmelCase__       :						Any	    =    ["image_embeds", "negative_image_embeds", "image"]
							UpperCAmelCase__       :						Dict	    =    [
							    "image_embeds",
							    "negative_image_embeds",
							    "image",
							]
							UpperCAmelCase__       :						Tuple	    =    [
							    "generator",
							    "height",
							    "width",
							    "strength",
							    "guidance_scale",
							    "num_inference_steps",
							    "return_dict",
							    "guidance_scale",
							    "num_images_per_prompt",
							    "output_type",
							    "return_dict",
							]
							UpperCAmelCase__       :						Optional[Any]	    =    False


							@property
							def 				__lowercase				(			self       )    ->    int:
												return 3_2


							@property
							def 				__lowercase				(			self       )    ->    List[Any]:
												return 3_2


							@property
							def 				__lowercase				(			self       )    ->    int:
												return self.time_input_dim


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


							@property
							def 				__lowercase				(			self       )    ->    Optional[int]:
												return 1_0_0


							@property
							def 				__lowercase				(			self       )    ->    Union[str, Any]:
												torch.manual_seed(0       )

												_a	:    Tuple         =		{
												    '''in_channels''': 4,
												    # Out channels is double in channels because predicts mean and variance
												    '''out_channels''': 8,
												    '''addition_embed_type''': '''image''',
												    '''down_block_types''': ('''ResnetDownsampleBlock2D''', '''SimpleCrossAttnDownBlock2D'''),
												    '''up_block_types''': ('''SimpleCrossAttnUpBlock2D''', '''ResnetUpsampleBlock2D'''),
												    '''mid_block_type''': '''UNetMidBlock2DSimpleCrossAttn''',
												    '''block_out_channels''': (self.block_out_channels_a, self.block_out_channels_a * 2),
												    '''layers_per_block''': 1,
												    '''encoder_hid_dim''': self.text_embedder_hidden_size,
												    '''encoder_hid_dim_type''': '''image_proj''',
												    '''cross_attention_dim''': self.cross_attention_dim,
												    '''attention_head_dim''': 4,
												    '''resnet_time_scale_shift''': '''scale_shift''',
												    '''class_embed_type''': None,
												}

												_a	:    str         =		UNetaDConditionModel(**_a       )
												return model


							@property
							def 				__lowercase				(			self       )    ->    str:
												return {
												    "block_out_channels": [3_2, 6_4],
												    "down_block_types": ["DownEncoderBlock2D", "AttnDownEncoderBlock2D"],
												    "in_channels": 3,
												    "latent_channels": 4,
												    "layers_per_block": 1,
												    "norm_num_groups": 8,
												    "norm_type": "spatial",
												    "num_vq_embeddings": 1_2,
												    "out_channels": 3,
												    "up_block_types": [
												        "AttnUpDecoderBlock2D",
												        "UpDecoderBlock2D",
												    ],
												    "vq_embed_dim": 4,
												}


							@property
							def 				__lowercase				(			self       )    ->    Optional[Any]:
												torch.manual_seed(0       )
												_a	:    Optional[int]         =		VQModel(**self.dummy_movq_kwargs       )
												return model


							def 				__lowercase				(			self       )    ->    Tuple:
												_a	:    Union[str, Any]         =		self.dummy_unet
												_a	:    Union[str, Any]         =		self.dummy_movq

												_a	:    Any         =		{
												    '''num_train_timesteps''': 1_0_0_0,
												    '''beta_schedule''': '''linear''',
												    '''beta_start''': 0.0_0085,
												    '''beta_end''': 0.012,
												    '''clip_sample''': False,
												    '''set_alpha_to_one''': False,
												    '''steps_offset''': 0,
												    '''prediction_type''': '''epsilon''',
												    '''thresholding''': False,
												}

												_a	:    str         =		DDIMScheduler(**_a       )

												_a	:    List[Any]         =		{
												    '''unet''': unet,
												    '''scheduler''': scheduler,
												    '''movq''': movq,
												}

												return components


							def 				__lowercase				(			self       ,							_a       ,							_a=0       )    ->    Union[str, Any]:
												_a	:    Tuple         =		floats_tensor((1, self.text_embedder_hidden_size)       ,							rng=random.Random(_a       )       ).to(_a       )
												_a	:    Dict         =		floats_tensor((1, self.text_embedder_hidden_size)       ,							rng=random.Random(seed + 1       )       ).to(
												    _a       )
												# create init_image
												_a	:    Tuple         =		floats_tensor((1, 3, 6_4, 6_4)       ,							rng=random.Random(_a       )       ).to(_a       )
												_a	:    Optional[Any]         =		image.cpu().permute(0       ,							2       ,							3       ,							1       )[0]
												_a	:    Any         =		Image.fromarray(np.uinta(_a       )       ).convert('''RGB'''       ).resize((2_5_6, 2_5_6)       )

												if str(_a       ).startswith('''mps'''       ):
																	_a	:    Optional[Any]         =		torch.manual_seed(_a       )
												else:
																	_a	:    int         =		torch.Generator(device=_a       ).manual_seed(_a       )
												_a	:    Any         =		{
												    '''image''': init_image,
												    '''image_embeds''': image_embeds,
												    '''negative_image_embeds''': negative_image_embeds,
												    '''generator''': generator,
												    '''height''': 6_4,
												    '''width''': 6_4,
												    '''num_inference_steps''': 1_0,
												    '''guidance_scale''': 7.0,
												    '''strength''': 0.2,
												    '''output_type''': '''np''',
												}
												return inputs




							def 				__lowercase				(			self       )    ->    Tuple:
												_a	:    int         =		'''cpu'''

												_a	:    Optional[int]         =		self.get_dummy_components()

												_a	:    Any         =		self.pipeline_class(**_a       )
												_a	:    List[str]         =		pipe.to(_a       )

												pipe.set_progress_bar_config(disable=_a       )

												_a	:    Optional[Any]         =		pipe(**self.get_dummy_inputs(_a       )       )
												_a	:    Optional[int]         =		output.images

												_a	:    Dict         =		pipe(
												    **self.get_dummy_inputs(_a       )       ,							return_dict=_a       ,							)[0]

												_a	:    Optional[int]         =		image[0, -3:, -3:, -1]
												_a	:    str         =		image_from_tuple[0, -3:, -3:, -1]

												assert image.shape == (1, 6_4, 6_4, 3)

												_a	:    Union[str, Any]         =		np.array(
												    [0.619_9778, 0.6398_4406, 0.4614_5785, 0.6294_4984, 0.562_2215, 0.4730_6132, 0.4744_1456, 0.460_7606, 0.4871_9263]       )
												assert (
												    np.abs(image_slice.flatten() - expected_slice       ).max() < 1e-2
												), F""" expected_slice {expected_slice}, but got {image_slice.flatten()}"""
												assert (
												    np.abs(image_from_tuple_slice.flatten() - expected_slice       ).max() < 1e-2
												), F""" expected_slice {expected_slice}, but got {image_from_tuple_slice.flatten()}"""



@slow
@require_torch_gpu
class 				UpperCAmelCase_		(			unittest.TestCase   ):
							"""simple docstring"""







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




							def 				__lowercase				(			self       )    ->    Dict:
												_a	:    Optional[int]         =		load_numpy(
												    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'''
												    '''/kandinskyv22/kandinskyv22_img2img_frog.npy'''       )

												_a	:    Optional[int]         =		load_image(
												    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main''' '''/kandinsky/cat.png'''       )
												_a	:    Any         =		'''A red cartoon frog, 4k'''

												_a	:    Any         =		KandinskyVaaPriorPipeline.from_pretrained(
												    '''kandinsky-community/kandinsky-2-2-prior'''       ,							torch_dtype=torch.floataa       )
												pipe_prior.to(_a       )

												_a	:    List[str]         =		KandinskyVaaImgaImgPipeline.from_pretrained(
												    '''kandinsky-community/kandinsky-2-2-decoder'''       ,							torch_dtype=torch.floataa       )
												_a	:    Dict         =		pipeline.to(_a       )

												pipeline.set_progress_bar_config(disable=_a       )

												_a	:    Optional[Any]         =		torch.Generator(device='''cpu'''       ).manual_seed(0       )
												_a      ,					_a	:    Optional[int]         =		pipe_prior(
												    _a       ,							generator=_a       ,							num_inference_steps=5       ,							negative_prompt=''''''       ,							).to_tuple()

												_a	:    List[str]         =		pipeline(
												    image=_a       ,							image_embeds=_a       ,							negative_image_embeds=_a       ,							generator=_a       ,							num_inference_steps=1_0_0       ,							height=7_6_8       ,							width=7_6_8       ,							strength=0.2       ,							output_type='''np'''       ,							)

												_a	:    Optional[int]         =		output.images[0]

												assert image.shape == (7_6_8, 7_6_8, 3)

												assert_mean_pixel_difference(_a       ,							_a       )






import json
import os
import unittest

from transformers import AutoTokenizer, GPTaTokenizer, GPTaTokenizerFast
from transformers.models.gpta.tokenization_gpta import VOCAB_FILES_NAMES
from transformers.testing_utils import require_tokenizers

from ...test_tokenization_common import TokenizerTesterMixin

@require_tokenizers
class 				UpperCAmelCase_		(			__lowercase				,       unittest.TestCase   ):
							"""simple docstring"""







							UpperCAmelCase__       :						int	    =    GPTaTokenizer
							UpperCAmelCase__       :						str	    =    GPTaTokenizerFast
							UpperCAmelCase__       :						Tuple	    =    True
							UpperCAmelCase__       :						List[Any]	    =    {"add_prefix_space": True}
							UpperCAmelCase__       :						int	    =    False


							def 				__lowercase				(			self       )    ->    int:
												super().setUp()

												# Adapted from Sennrich et al. 2015 and https://github.com/rsennrich/subword-nmt
												_a	:    str         =		[
												    '''l''',
												    '''o''',
												    '''w''',
												    '''e''',
												    '''r''',
												    '''s''',
												    '''t''',
												    '''i''',
												    '''d''',
												    '''n''',
												    '''\u0120''',
												    '''\u0120l''',
												    '''\u0120n''',
												    '''\u0120lo''',
												    '''\u0120low''',
												    '''er''',
												    '''\u0120lowest''',
												    '''\u0120newer''',
												    '''\u0120wider''',
												    '''<unk>''',
												    '''<|endoftext|>''',
												]
												_a	:    List[Any]         =		dict(zip(_a       ,							range(len(_a       )       )       )       )
												_a	:    Tuple         =		['''#version: 0.2''', '''\u0120 l''', '''\u0120l o''', '''\u0120lo w''', '''e r''', '''''']
												_a	:    List[str]         =		{'''unk_token''': '''<unk>'''}

												_a	:    List[str]         =		os.path.join(self.tmpdirname       ,							VOCAB_FILES_NAMES['''vocab_file''']       )
												_a	:    Tuple         =		os.path.join(self.tmpdirname       ,							VOCAB_FILES_NAMES['''merges_file''']       )
												with open(self.vocab_file       ,							'''w'''       ,							encoding='''utf-8'''       ) as fp:
																	fp.write(json.dumps(_a       ) + '''\n'''       )
												with open(self.merges_file       ,							'''w'''       ,							encoding='''utf-8'''       ) as fp:
																	fp.write('''\n'''.join(_a       )       )


							def 				__lowercase				(			self       ,							**_a       )    ->    List[str]:
												kwargs.update(self.special_tokens_map       )
												return GPTaTokenizer.from_pretrained(self.tmpdirname       ,							**_a       )


							def 				__lowercase				(			self       ,							**_a       )    ->    List[Any]:
												kwargs.update(self.special_tokens_map       )
												return GPTaTokenizerFast.from_pretrained(self.tmpdirname       ,							**_a       )


							def 				__lowercase				(			self       ,							_a       )    ->    Optional[Any]:
												_a	:    Tuple         =		'''lower newer'''
												_a	:    Tuple         =		'''lower newer'''
												return input_text, output_text


							def 				__lowercase				(			self       )    ->    Any:
												_a	:    Any         =		GPTaTokenizer(self.vocab_file       ,							self.merges_file       ,							**self.special_tokens_map       )
												_a	:    int         =		'''lower newer'''
												_a	:    int         =		['''\u0120low''', '''er''', '''\u0120''', '''n''', '''e''', '''w''', '''er''']
												_a	:    List[str]         =		tokenizer.tokenize(_a       ,							add_prefix_space=_a       )
												self.assertListEqual(_a       ,							_a       )

												_a	:    Optional[int]         =		tokens + [tokenizer.unk_token]
												_a	:    List[Any]         =		[1_4, 1_5, 1_0, 9, 3, 2, 1_5, 1_9]
												self.assertListEqual(tokenizer.convert_tokens_to_ids(_a       )       ,							_a       )


							def 				__lowercase				(			self       )    ->    Optional[int]:
												if not self.test_rust_tokenizer:
																	return

												_a	:    int         =		self.get_tokenizer()
												_a	:    Tuple         =		self.get_rust_tokenizer(add_prefix_space=_a       )

												_a	:    Tuple         =		'''lower newer'''

												# Testing tokenization
												_a	:    List[str]         =		tokenizer.tokenize(_a       ,							add_prefix_space=_a       )
												_a	:    Optional[Any]         =		rust_tokenizer.tokenize(_a       )
												self.assertListEqual(_a       ,							_a       )

												# Testing conversion to ids without special tokens
												_a	:    List[Any]         =		tokenizer.encode(_a       ,							add_special_tokens=_a       ,							add_prefix_space=_a       )
												_a	:    List[Any]         =		rust_tokenizer.encode(_a       ,							add_special_tokens=_a       )
												self.assertListEqual(_a       ,							_a       )

												# Testing conversion to ids with special tokens
												_a	:    List[str]         =		self.get_rust_tokenizer(add_prefix_space=_a       )
												_a	:    List[str]         =		tokenizer.encode(_a       ,							add_prefix_space=_a       )
												_a	:    Tuple         =		rust_tokenizer.encode(_a       )
												self.assertListEqual(_a       ,							_a       )

												# Testing the unknown token
												_a	:    Optional[Any]         =		tokens + [rust_tokenizer.unk_token]
												_a	:    str         =		[1_4, 1_5, 1_0, 9, 3, 2, 1_5, 1_9]
												self.assertListEqual(rust_tokenizer.convert_tokens_to_ids(_a       )       ,							_a       )


							def 				__lowercase				(			self       ,							*_a       ,							**_a       )    ->    int:
												# It's very difficult to mix/test pretokenization with byte-level
												# And get both GPT2 and Roberta to work at the same time (mostly an issue of adding a space before the string)
												pass


							def 				__lowercase				(			self       ,							_a=1_5       )    ->    str:
												for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
																	with self.subTest(F"""{tokenizer.__class__.__name__} ({pretrained_name})"""       ):
																						_a	:    Optional[int]         =		self.rust_tokenizer_class.from_pretrained(_a       ,							**_a       )

																						# Simple input
																						_a	:    List[str]         =		'''This is a simple input'''
																						_a	:    Optional[Any]         =		['''This is a simple input 1''', '''This is a simple input 2''']
																						_a	:    Tuple         =		('''This is a simple input''', '''This is a pair''')
																						_a	:    Optional[Any]         =		[
																						    ('''This is a simple input 1''', '''This is a simple input 2'''),
																						    ('''This is a simple pair 1''', '''This is a simple pair 2'''),
																						]

																						# Simple input tests
																						self.assertRaises(_a       ,							tokenizer_r.encode       ,							_a       ,							max_length=_a       ,							padding='''max_length'''       )

																						# Simple input
																						self.assertRaises(_a       ,							tokenizer_r.encode_plus       ,							_a       ,							max_length=_a       ,							padding='''max_length'''       )

																						# Simple input
																						self.assertRaises(
																						    _a       ,							tokenizer_r.batch_encode_plus       ,							_a       ,							max_length=_a       ,							padding='''max_length'''       ,							)

																						# Pair input
																						self.assertRaises(_a       ,							tokenizer_r.encode       ,							_a       ,							max_length=_a       ,							padding='''max_length'''       )

																						# Pair input
																						self.assertRaises(_a       ,							tokenizer_r.encode_plus       ,							_a       ,							max_length=_a       ,							padding='''max_length'''       )

																						# Pair input
																						self.assertRaises(
																						    _a       ,							tokenizer_r.batch_encode_plus       ,							_a       ,							max_length=_a       ,							padding='''max_length'''       ,							)


							def 				__lowercase				(			self       )    ->    List[Any]:
												_a	:    int         =		GPTaTokenizer.from_pretrained(self.tmpdirname       ,							pad_token='''<pad>'''       )

												# Simple input
												_a	:    int         =		'''This is a simple input'''
												_a	:    int         =		['''This is a simple input looooooooong''', '''This is a simple input''']
												_a	:    Any         =		('''This is a simple input''', '''This is a pair''')
												_a	:    Dict         =		[
												    ('''This is a simple input loooooong''', '''This is a simple input'''),
												    ('''This is a simple pair loooooong''', '''This is a simple pair'''),
												]

												_a	:    Optional[int]         =		tokenizer.pad_token_id

												_a	:    List[Any]         =		tokenizer(_a       ,							padding='''max_length'''       ,							max_length=3_0       ,							return_tensors='''np'''       )
												_a	:    Optional[int]         =		tokenizer(_a       ,							padding=_a       ,							truncate=_a       ,							return_tensors='''np'''       )
												_a	:    int         =		tokenizer(*_a       ,							padding='''max_length'''       ,							max_length=6_0       ,							return_tensors='''np'''       )
												_a	:    Union[str, Any]         =		tokenizer(_a       ,							padding=_a       ,							truncate=_a       ,							return_tensors='''np'''       )

												# s
												# test single string max_length padding
												self.assertEqual(out_s['''input_ids'''].shape[-1]       ,							3_0       )
												self.assertTrue(pad_token_id in out_s['''input_ids''']       )
												self.assertTrue(0 in out_s['''attention_mask''']       )

												# s2
												# test automatic padding
												self.assertEqual(out_sa['''input_ids'''].shape[-1]       ,							3_3       )
												# long slice doesn't have padding
												self.assertFalse(pad_token_id in out_sa['''input_ids'''][0]       )
												self.assertFalse(0 in out_sa['''attention_mask'''][0]       )
												# short slice does have padding
												self.assertTrue(pad_token_id in out_sa['''input_ids'''][1]       )
												self.assertTrue(0 in out_sa['''attention_mask'''][1]       )

												# p
												# test single pair max_length padding
												self.assertEqual(out_p['''input_ids'''].shape[-1]       ,							6_0       )
												self.assertTrue(pad_token_id in out_p['''input_ids''']       )
												self.assertTrue(0 in out_p['''attention_mask''']       )

												# p2
												# test automatic padding pair
												self.assertEqual(out_pa['''input_ids'''].shape[-1]       ,							5_2       )
												# long slice pair doesn't have padding
												self.assertFalse(pad_token_id in out_pa['''input_ids'''][0]       )
												self.assertFalse(0 in out_pa['''attention_mask'''][0]       )
												# short slice pair does have padding
												self.assertTrue(pad_token_id in out_pa['''input_ids'''][1]       )
												self.assertTrue(0 in out_pa['''attention_mask'''][1]       )


							def 				__lowercase				(			self       )    ->    Any:
												_a	:    Union[str, Any]         =		'''$$$'''
												_a	:    List[Any]         =		GPTaTokenizer.from_pretrained(self.tmpdirname       ,							bos_token=_a       ,							add_bos_token=_a       )

												_a	:    Any         =		'''This is a simple input'''
												_a	:    str         =		['''This is a simple input 1''', '''This is a simple input 2''']

												_a	:    Tuple         =		tokenizer.bos_token_id

												_a	:    Optional[Any]         =		tokenizer(_a       )
												_a	:    str         =		tokenizer(_a       )

												self.assertEqual(out_s.input_ids[0]       ,							_a       )
												self.assertTrue(all(o[0] == bos_token_id for o in out_sa.input_ids       )       )

												_a	:    str         =		tokenizer.decode(out_s.input_ids       )
												_a	:    Optional[Any]         =		tokenizer.batch_decode(out_sa.input_ids       )

												self.assertEqual(decode_s.split()[0]       ,							_a       )
												self.assertTrue(all(d.split()[0] == bos_token for d in decode_sa       )       )


							def 				__lowercase				(			self       )    ->    str:
												pass




							def 				__lowercase				(			self       )    ->    Dict:
												# TODO: change to self.get_tokenizers() when the fast version is implemented
												_a	:    Optional[int]         =		[self.get_tokenizer(do_lower_case=_a       ,							add_bos_token=_a       )]
												for tokenizer in tokenizers:
																	with self.subTest(F"""{tokenizer.__class__.__name__}"""       ):
																						_a	:    Tuple         =		'''Encode this.'''
																						_a	:    Optional[Any]         =		'''This one too please.'''
																						_a	:    List[Any]         =		tokenizer.encode(_a       ,							add_special_tokens=_a       )
																						encoded_sequence += tokenizer.encode(_a       ,							add_special_tokens=_a       )
																						_a	:    List[str]         =		tokenizer.encode_plus(
																						    _a       ,							_a       ,							add_special_tokens=_a       ,							return_special_tokens_mask=_a       ,							)
																						_a	:    int         =		encoded_sequence_dict['''input_ids''']
																						_a	:    int         =		encoded_sequence_dict['''special_tokens_mask''']
																						self.assertEqual(len(_a       )       ,							len(_a       )       )

																						_a	:    List[Any]         =		[
																						    (x if not special_tokens_mask[i] else None) for i, x in enumerate(_a       )
																						]
																						_a	:    str         =		[x for x in filtered_sequence if x is not None]
																						self.assertEqual(_a       ,							_a       )



@require_tokenizers
class 				UpperCAmelCase_		(			unittest.TestCase   ):
							"""simple docstring"""







							def 				__lowercase				(			self       )    ->    List[Any]:
												# More context:
												# https://huggingface.co/wjmcat/opt-350m-paddle/discussions/1
												# https://huggingface.slack.com/archives/C01N44FJDHT/p1653511495183519
												# https://github.com/huggingface/transformers/pull/17088#discussion_r871246439

												_a	:    Any         =		AutoTokenizer.from_pretrained('''facebook/opt-350m'''       ,							from_slow=_a       )
												_a	:    int         =		'''A photo of a cat'''

												_a	:    List[Any]         =		tokenizer.encode(
												    _a       ,							)
												self.assertEqual(_a       ,							[2, 2_5_0, 1_3_4_5, 9, 1_0, 4_7_5_8]       )
												tokenizer.save_pretrained('''test_opt'''       )

												_a	:    Union[str, Any]         =		AutoTokenizer.from_pretrained('''./test_opt'''       )
												_a	:    Any         =		tokenizer.encode(
												    _a       ,							)
												self.assertEqual(_a       ,							[2, 2_5_0, 1_3_4_5, 9, 1_0, 4_7_5_8]       )


							def 				__lowercase				(			self       )    ->    int:
												_a	:    Union[str, Any]         =		AutoTokenizer.from_pretrained('''facebook/opt-350m'''       ,							use_slow=_a       )
												_a	:    Any         =		'''A photo of a cat'''

												_a	:    Optional[int]         =		tokenizer.encode(
												    _a       ,							)
												# Same as above
												self.assertEqual(_a       ,							[2, 2_5_0, 1_3_4_5, 9, 1_0, 4_7_5_8]       )




							@unittest.skip('''This test is failing because of a bug in the fast tokenizer'''       )
							def 				__lowercase				(			self       )    ->    Any:
												_a	:    Union[str, Any]         =		AutoTokenizer.from_pretrained('''facebook/opt-350m'''       ,							from_slow=_a       )

												_a	:    Optional[Any]         =		'''bos'''
												_a	:    Optional[Any]         =		tokenizer.get_vocab()['''bos''']

												_a	:    str         =		'''A photo of a cat'''
												_a	:    int         =		tokenizer.encode(
												    _a       ,							)
												# We changed the bos token
												self.assertEqual(_a       ,							[3_1_9_5_7, 2_5_0, 1_3_4_5, 9, 1_0, 4_7_5_8]       )
												tokenizer.save_pretrained('''./tok'''       )
												_a	:    Dict         =		AutoTokenizer.from_pretrained('''./tok'''       )
												self.assertTrue(tokenizer.is_fast       )
												_a	:    Union[str, Any]         =		tokenizer.encode(
												    _a       ,							)
												self.assertEqual(_a       ,							[3_1_9_5_7, 2_5_0, 1_3_4_5, 9, 1_0, 4_7_5_8]       )



