


"""simple docstring"""




import gc
import unittest

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

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    PNDMScheduler,
    StableDiffusionLDMaDPipeline,
    UNetaDConditionModel,
)
from diffusers.utils import nightly, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_IMAGE_PARAMS, TEXT_TO_IMAGE_PARAMS


enable_full_determinism()
class 					lowerCAmelCase	(					unittest.TestCase    ):




		'''simple docstring'''







		SCREAMING_SNAKE_CASE_						:     Union[str, Any]								=     StableDiffusionLDMaDPipeline
		SCREAMING_SNAKE_CASE_						:     Union[str, Any]								=     TEXT_TO_IMAGE_PARAMS
		SCREAMING_SNAKE_CASE_						:     List[str]								=     TEXT_TO_IMAGE_BATCH_PARAMS
		SCREAMING_SNAKE_CASE_						:     Union[str, Any]								=     TEXT_TO_IMAGE_IMAGE_PARAMS







		def 							__A						(	self				)     ->							Tuple:
								torch.manual_seed(0				)
								SCREAMING_SNAKE_CASE													=					UNetaDConditionModel(
								    block_out_channels=(32, 64)						,       layers_per_block=2						,       sample_size=32						,       in_channels=4						,       out_channels=4						,       down_block_types=('DownBlock2D', 'CrossAttnDownBlock2D')						,       up_block_types=('CrossAttnUpBlock2D', 'UpBlock2D')						,       cross_attention_dim=32						,       )
								SCREAMING_SNAKE_CASE													=					DDIMScheduler(
								    beta_start=0.0_00_85						,       beta_end=0.0_12						,       beta_schedule='scaled_linear'						,       clip_sample=lowerCAmelCase__						,       set_alpha_to_one=lowerCAmelCase__						,       )
								torch.manual_seed(0				)
								SCREAMING_SNAKE_CASE													=					AutoencoderKL(
								    block_out_channels=[32, 64]						,       in_channels=6						,       out_channels=6						,       down_block_types=['DownEncoderBlock2D', 'DownEncoderBlock2D']						,       up_block_types=['UpDecoderBlock2D', 'UpDecoderBlock2D']						,       latent_channels=4						,       )
								torch.manual_seed(0				)
								SCREAMING_SNAKE_CASE													=					CLIPTextConfig(
								    bos_token_id=0						,       eos_token_id=2						,       hidden_size=32						,       intermediate_size=37						,       layer_norm_eps=1e-05						,       num_attention_heads=4						,       num_hidden_layers=5						,       pad_token_id=1						,       vocab_size=1_000						,       )
								SCREAMING_SNAKE_CASE													=					CLIPTextModel(lowerCAmelCase__				)
								SCREAMING_SNAKE_CASE													=					CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'				)

								SCREAMING_SNAKE_CASE													=					{
								    'unet': unet,
								    'scheduler': scheduler,
								    'vae': vae,
								    'text_encoder': text_encoder,
								    'tokenizer': tokenizer,
								    'safety_checker': None,
								    'feature_extractor': None,
								}
								return components







		def 							__A						(	self						,       lowerCAmelCase__						,       lowerCAmelCase__=0				)     ->							int:
								if str(lowerCAmelCase__				).startswith('mps'				):
														SCREAMING_SNAKE_CASE													=					torch.manual_seed(lowerCAmelCase__				)
								else:
														SCREAMING_SNAKE_CASE													=					torch.Generator(device=lowerCAmelCase__				).manual_seed(lowerCAmelCase__				)
								SCREAMING_SNAKE_CASE													=					{
								    'prompt': 'A painting of a squirrel eating a burger',
								    'generator': generator,
								    'num_inference_steps': 2,
								    'guidance_scale': 6.0,
								    'output_type': 'numpy',
								}
								return inputs







		def 							__A						(	self				)     ->							int:
								SCREAMING_SNAKE_CASE													=					'cpu'  # ensure determinism for the device-dependent torch.Generator

								SCREAMING_SNAKE_CASE													=					self.get_dummy_components()
								SCREAMING_SNAKE_CASE													=					StableDiffusionLDMaDPipeline(**lowerCAmelCase__				)
								SCREAMING_SNAKE_CASE													=					ldmad_pipe.to(lowerCAmelCase__				)
								ldmad_pipe.set_progress_bar_config(disable=lowerCAmelCase__				)

								SCREAMING_SNAKE_CASE													=					self.get_dummy_inputs(lowerCAmelCase__				)
								SCREAMING_SNAKE_CASE													=					ldmad_pipe(**lowerCAmelCase__				)
								SCREAMING_SNAKE_CASE							,				SCREAMING_SNAKE_CASE													=					output.rgb, output.depth

								SCREAMING_SNAKE_CASE													=					rgb[0, -3:, -3:, -1]
								SCREAMING_SNAKE_CASE													=					depth[0, -3:, -1]

								assert rgb.shape == (1, 64, 64, 3)
								assert depth.shape == (1, 64, 64)

								SCREAMING_SNAKE_CASE													=					np.array(
								    [0.37_33_81_76, 0.7_02_47, 0.74_20_31_93, 0.51_64_36_04, 0.58_25_67_93, 0.60_93_21_36, 0.4_18_10_95, 0.48_35_58_77, 0.46_53_52_62]				)
								SCREAMING_SNAKE_CASE													=					np.array([1_03.4_67_27, 85.81_20_04, 87.84_92_36]				)

								assert np.abs(image_slice_rgb.flatten() - expected_slice_rgb				).max() < 1e-2
								assert np.abs(image_slice_depth.flatten() - expected_slice_depth				).max() < 1e-2







		def 							__A						(	self				)     ->							Tuple:
								SCREAMING_SNAKE_CASE													=					self.get_dummy_components()
								SCREAMING_SNAKE_CASE													=					StableDiffusionLDMaDPipeline(**lowerCAmelCase__				)
								SCREAMING_SNAKE_CASE													=					ldmad_pipe.to(lowerCAmelCase__				)
								ldmad_pipe.set_progress_bar_config(disable=lowerCAmelCase__				)

								SCREAMING_SNAKE_CASE													=					self.get_dummy_inputs(lowerCAmelCase__				)
								SCREAMING_SNAKE_CASE													=					3 * [inputs['prompt']]

								# forward
								SCREAMING_SNAKE_CASE													=					ldmad_pipe(**lowerCAmelCase__				)
								SCREAMING_SNAKE_CASE							,				SCREAMING_SNAKE_CASE													=					output.rgb, output.depth
								SCREAMING_SNAKE_CASE													=					rgb_slice_a[0, -3:, -3:, -1]
								SCREAMING_SNAKE_CASE													=					depth_slice_a[0, -3:, -1]

								SCREAMING_SNAKE_CASE													=					self.get_dummy_inputs(lowerCAmelCase__				)
								SCREAMING_SNAKE_CASE													=					3 * [inputs.pop('prompt'				)]

								SCREAMING_SNAKE_CASE													=					ldmad_pipe.tokenizer(
								    lowerCAmelCase__						,       padding='max_length'						,       max_length=ldmad_pipe.tokenizer.model_max_length						,       truncation=lowerCAmelCase__						,       return_tensors='pt'						,       )
								SCREAMING_SNAKE_CASE													=					text_inputs['input_ids'].to(lowerCAmelCase__				)

								SCREAMING_SNAKE_CASE													=					ldmad_pipe.text_encoder(lowerCAmelCase__				)[0]

								SCREAMING_SNAKE_CASE													=					prompt_embeds

								# forward
								SCREAMING_SNAKE_CASE													=					ldmad_pipe(**lowerCAmelCase__				)
								SCREAMING_SNAKE_CASE							,				SCREAMING_SNAKE_CASE													=					output.rgb, output.depth
								SCREAMING_SNAKE_CASE													=					rgb_slice_a[0, -3:, -3:, -1]
								SCREAMING_SNAKE_CASE													=					depth_slice_a[0, -3:, -1]

								assert np.abs(rgb_slice_a.flatten() - rgb_slice_a.flatten()				).max() < 1e-4
								assert np.abs(depth_slice_a.flatten() - depth_slice_a.flatten()				).max() < 1e-4







		def 							__A						(	self				)     ->							Dict:
								SCREAMING_SNAKE_CASE													=					'cpu'  # ensure determinism for the device-dependent torch.Generator
								SCREAMING_SNAKE_CASE													=					self.get_dummy_components()
								SCREAMING_SNAKE_CASE													=					PNDMScheduler(skip_prk_steps=lowerCAmelCase__				)
								SCREAMING_SNAKE_CASE													=					StableDiffusionLDMaDPipeline(**lowerCAmelCase__				)
								SCREAMING_SNAKE_CASE													=					ldmad_pipe.to(lowerCAmelCase__				)
								ldmad_pipe.set_progress_bar_config(disable=lowerCAmelCase__				)

								SCREAMING_SNAKE_CASE													=					self.get_dummy_inputs(lowerCAmelCase__				)
								SCREAMING_SNAKE_CASE													=					'french fries'
								SCREAMING_SNAKE_CASE													=					ldmad_pipe(**lowerCAmelCase__						,       negative_prompt=lowerCAmelCase__				)

								SCREAMING_SNAKE_CASE							,				SCREAMING_SNAKE_CASE													=					output.rgb, output.depth
								SCREAMING_SNAKE_CASE													=					rgb[0, -3:, -3:, -1]
								SCREAMING_SNAKE_CASE													=					depth[0, -3:, -1]

								assert rgb.shape == (1, 64, 64, 3)
								assert depth.shape == (1, 64, 64)

								SCREAMING_SNAKE_CASE													=					np.array(
								    [0.3_70_44, 0.71_81_15_03, 0.7_22_32_51, 0.48_60_36_75, 0.5_63_83_91, 0.6_36_49_48, 0.42_83_37_04, 0.4_90_13_15, 0.47_92_62_17]				)
								SCREAMING_SNAKE_CASE													=					np.array([1_07.8_47_38, 84.6_28_02, 89.96_21_35]				)
								assert np.abs(rgb_slice.flatten() - expected_slice_rgb				).max() < 1e-2
								assert np.abs(depth_slice.flatten() - expected_slice_depth				).max() < 1e-2





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




		'''simple docstring'''







		def 							__A						(	self				)     ->							Optional[Any]:
								super().tearDown()
								gc.collect()
								torch.cuda.empty_cache()







		def 							__A						(	self						,       lowerCAmelCase__						,       lowerCAmelCase__="cpu"						,       lowerCAmelCase__=torch.floataa						,       lowerCAmelCase__=0				)     ->							Tuple:
								SCREAMING_SNAKE_CASE													=					torch.Generator(device=lowerCAmelCase__				).manual_seed(lowerCAmelCase__				)
								SCREAMING_SNAKE_CASE													=					np.random.RandomState(lowerCAmelCase__				).standard_normal((1, 4, 64, 64)				)
								SCREAMING_SNAKE_CASE													=					torch.from_numpy(lowerCAmelCase__				).to(device=lowerCAmelCase__						,       dtype=lowerCAmelCase__				)
								SCREAMING_SNAKE_CASE													=					{
								    'prompt': 'a photograph of an astronaut riding a horse',
								    'latents': latents,
								    'generator': generator,
								    'num_inference_steps': 3,
								    'guidance_scale': 7.5,
								    'output_type': 'numpy',
								}
								return inputs







		def 							__A						(	self				)     ->							Tuple:
								SCREAMING_SNAKE_CASE													=					StableDiffusionLDMaDPipeline.from_pretrained('Intel/ldm3d'				)
								SCREAMING_SNAKE_CASE													=					ldmad_pipe.to(lowerCAmelCase__				)
								ldmad_pipe.set_progress_bar_config(disable=lowerCAmelCase__				)

								SCREAMING_SNAKE_CASE													=					self.get_inputs(lowerCAmelCase__				)
								SCREAMING_SNAKE_CASE													=					ldmad_pipe(**lowerCAmelCase__				)
								SCREAMING_SNAKE_CASE							,				SCREAMING_SNAKE_CASE													=					output.rgb, output.depth
								SCREAMING_SNAKE_CASE													=					rgb[0, -3:, -3:, -1].flatten()
								SCREAMING_SNAKE_CASE													=					rgb[0, -3:, -1].flatten()

								assert rgb.shape == (1, 512, 512, 3)
								assert depth.shape == (1, 512, 512)

								SCREAMING_SNAKE_CASE													=					np.array(
								    [0.53_80_54_65, 0.56_70_73_05, 0.5_48_65_15, 0.57_01_22_36, 0.5_81_45_11, 0.56_25_34_87, 0.54_84_30_14, 0.55_09_22_63, 0.6_45_97_06]				)
								SCREAMING_SNAKE_CASE													=					np.array(
								    [0.9_26_37_81, 0.6_67_86_72, 0.5_48_65_15, 0.92_20_21_45, 0.67_83_11_35, 0.56_25_34_87, 0.9_24_16_94, 0.7_55_14_78, 0.6_45_97_06]				)
								assert np.abs(rgb_slice - expected_slice_rgb				).max() < 3e-3
								assert np.abs(depth_slice - expected_slice_depth				).max() < 3e-3





@nightly
@require_torch_gpu
class 					lowerCAmelCase	(					unittest.TestCase    ):




		'''simple docstring'''







		def 							__A						(	self				)     ->							Union[str, Any]:
								super().tearDown()
								gc.collect()
								torch.cuda.empty_cache()







		def 							__A						(	self						,       lowerCAmelCase__						,       lowerCAmelCase__="cpu"						,       lowerCAmelCase__=torch.floataa						,       lowerCAmelCase__=0				)     ->							int:
								SCREAMING_SNAKE_CASE													=					torch.Generator(device=lowerCAmelCase__				).manual_seed(lowerCAmelCase__				)
								SCREAMING_SNAKE_CASE													=					np.random.RandomState(lowerCAmelCase__				).standard_normal((1, 4, 64, 64)				)
								SCREAMING_SNAKE_CASE													=					torch.from_numpy(lowerCAmelCase__				).to(device=lowerCAmelCase__						,       dtype=lowerCAmelCase__				)
								SCREAMING_SNAKE_CASE													=					{
								    'prompt': 'a photograph of an astronaut riding a horse',
								    'latents': latents,
								    'generator': generator,
								    'num_inference_steps': 50,
								    'guidance_scale': 7.5,
								    'output_type': 'numpy',
								}
								return inputs







		def 							__A						(	self				)     ->							Union[str, Any]:
								SCREAMING_SNAKE_CASE													=					StableDiffusionLDMaDPipeline.from_pretrained('Intel/ldm3d'				).to(lowerCAmelCase__				)
								ldmad_pipe.set_progress_bar_config(disable=lowerCAmelCase__				)

								SCREAMING_SNAKE_CASE													=					self.get_inputs(lowerCAmelCase__				)
								SCREAMING_SNAKE_CASE													=					ldmad_pipe(**lowerCAmelCase__				)
								SCREAMING_SNAKE_CASE							,				SCREAMING_SNAKE_CASE													=					output.rgb, output.depth

								SCREAMING_SNAKE_CASE													=					0.49_55_86
								SCREAMING_SNAKE_CASE													=					0.33_79_55_15
								SCREAMING_SNAKE_CASE													=					1_12.4_85_18
								SCREAMING_SNAKE_CASE													=					98.48_97_46
								assert np.abs(expected_rgb_mean - rgb.mean()				) < 1e-3
								assert np.abs(expected_rgb_std - rgb.std()				) < 1e-3
								assert np.abs(expected_depth_mean - depth.mean()				) < 1e-3
								assert np.abs(expected_depth_std - depth.std()				) < 1e-3







		def 							__A						(	self				)     ->							str:
								SCREAMING_SNAKE_CASE													=					StableDiffusionLDMaDPipeline.from_pretrained('Intel/ldm3d-4c'				).to(lowerCAmelCase__				)
								ldmad_pipe.set_progress_bar_config(disable=lowerCAmelCase__				)

								SCREAMING_SNAKE_CASE													=					self.get_inputs(lowerCAmelCase__				)
								SCREAMING_SNAKE_CASE													=					ldmad_pipe(**lowerCAmelCase__				)
								SCREAMING_SNAKE_CASE							,				SCREAMING_SNAKE_CASE													=					output.rgb, output.depth

								SCREAMING_SNAKE_CASE													=					0.4_19_41_27
								SCREAMING_SNAKE_CASE													=					0.35_37_55_86
								SCREAMING_SNAKE_CASE													=					0.5_63_85_02
								SCREAMING_SNAKE_CASE													=					0.34_68_61_03

								assert rgb.shape == (1, 512, 512, 3)
								assert depth.shape == (1, 512, 512, 1)
								assert np.abs(expected_rgb_mean - rgb.mean()				) < 1e-3
								assert np.abs(expected_rgb_std - rgb.std()				) < 1e-3
								assert np.abs(expected_depth_mean - depth.mean()				) < 1e-3
								assert np.abs(expected_depth_std - depth.std()				) < 1e-3






"""simple docstring"""




import json
from typing import List, Optional, Tuple

from tokenizers import normalizers

from ...tokenization_utils_fast import PreTrainedTokenizerFast
from ...utils import logging
from .tokenization_funnel import FunnelTokenizer


__UpperCamelCase						=      logging.get_logger(__name__)

__UpperCamelCase						=      {'''vocab_file''': '''vocab.txt''', '''tokenizer_file''': '''tokenizer.json'''}

__UpperCamelCase						=      [
    '''small''',
    '''small-base''',
    '''medium''',
    '''medium-base''',
    '''intermediate''',
    '''intermediate-base''',
    '''large''',
    '''large-base''',
    '''xlarge''',
    '''xlarge-base''',
]

__UpperCamelCase						=      {
    '''vocab_file''': {
        '''funnel-transformer/small''': '''https://huggingface.co/funnel-transformer/small/resolve/main/vocab.txt''',
        '''funnel-transformer/small-base''': '''https://huggingface.co/funnel-transformer/small-base/resolve/main/vocab.txt''',
        '''funnel-transformer/medium''': '''https://huggingface.co/funnel-transformer/medium/resolve/main/vocab.txt''',
        '''funnel-transformer/medium-base''': (
            '''https://huggingface.co/funnel-transformer/medium-base/resolve/main/vocab.txt'''
        ),
        '''funnel-transformer/intermediate''': (
            '''https://huggingface.co/funnel-transformer/intermediate/resolve/main/vocab.txt'''
        ),
        '''funnel-transformer/intermediate-base''': (
            '''https://huggingface.co/funnel-transformer/intermediate-base/resolve/main/vocab.txt'''
        ),
        '''funnel-transformer/large''': '''https://huggingface.co/funnel-transformer/large/resolve/main/vocab.txt''',
        '''funnel-transformer/large-base''': '''https://huggingface.co/funnel-transformer/large-base/resolve/main/vocab.txt''',
        '''funnel-transformer/xlarge''': '''https://huggingface.co/funnel-transformer/xlarge/resolve/main/vocab.txt''',
        '''funnel-transformer/xlarge-base''': (
            '''https://huggingface.co/funnel-transformer/xlarge-base/resolve/main/vocab.txt'''
        ),
    },
    '''tokenizer_file''': {
        '''funnel-transformer/small''': '''https://huggingface.co/funnel-transformer/small/resolve/main/tokenizer.json''',
        '''funnel-transformer/small-base''': (
            '''https://huggingface.co/funnel-transformer/small-base/resolve/main/tokenizer.json'''
        ),
        '''funnel-transformer/medium''': '''https://huggingface.co/funnel-transformer/medium/resolve/main/tokenizer.json''',
        '''funnel-transformer/medium-base''': (
            '''https://huggingface.co/funnel-transformer/medium-base/resolve/main/tokenizer.json'''
        ),
        '''funnel-transformer/intermediate''': (
            '''https://huggingface.co/funnel-transformer/intermediate/resolve/main/tokenizer.json'''
        ),
        '''funnel-transformer/intermediate-base''': (
            '''https://huggingface.co/funnel-transformer/intermediate-base/resolve/main/tokenizer.json'''
        ),
        '''funnel-transformer/large''': '''https://huggingface.co/funnel-transformer/large/resolve/main/tokenizer.json''',
        '''funnel-transformer/large-base''': (
            '''https://huggingface.co/funnel-transformer/large-base/resolve/main/tokenizer.json'''
        ),
        '''funnel-transformer/xlarge''': '''https://huggingface.co/funnel-transformer/xlarge/resolve/main/tokenizer.json''',
        '''funnel-transformer/xlarge-base''': (
            '''https://huggingface.co/funnel-transformer/xlarge-base/resolve/main/tokenizer.json'''
        ),
    },
}
__UpperCamelCase						=      {f'''funnel-transformer/{name}''': 512 for name in _model_names}
__UpperCamelCase						=      {f'''funnel-transformer/{name}''': {'''do_lower_case''': True} for name in _model_names}
class 					lowerCAmelCase	(					lowerCamelCase_    ):




		'''simple docstring'''







		SCREAMING_SNAKE_CASE_						:     int								=     VOCAB_FILES_NAMES
		SCREAMING_SNAKE_CASE_						:     List[str]								=     PRETRAINED_VOCAB_FILES_MAP
		SCREAMING_SNAKE_CASE_						:     List[Any]								=     PRETRAINED_INIT_CONFIGURATION
		SCREAMING_SNAKE_CASE_						:     str								=     FunnelTokenizer
		SCREAMING_SNAKE_CASE_						:     Dict								=     PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
		SCREAMING_SNAKE_CASE_						:     int								=     2







		def __init__(	self						,       lowerCAmelCase__=None						,       lowerCAmelCase__=None						,       lowerCAmelCase__=True						,       lowerCAmelCase__="<unk>"						,       lowerCAmelCase__="<sep>"						,       lowerCAmelCase__="<pad>"						,       lowerCAmelCase__="<cls>"						,       lowerCAmelCase__="<mask>"						,       lowerCAmelCase__="<s>"						,       lowerCAmelCase__="</s>"						,       lowerCAmelCase__=True						,       lowerCAmelCase__=True						,       lowerCAmelCase__=None						,       lowerCAmelCase__="##"						,       **lowerCAmelCase__						,       )     ->							Tuple:
								super().__init__(
								    lowerCAmelCase__						,       tokenizer_file=lowerCAmelCase__						,       do_lower_case=lowerCAmelCase__						,       unk_token=lowerCAmelCase__						,       sep_token=lowerCAmelCase__						,       pad_token=lowerCAmelCase__						,       cls_token=lowerCAmelCase__						,       mask_token=lowerCAmelCase__						,       bos_token=lowerCAmelCase__						,       eos_token=lowerCAmelCase__						,       clean_text=lowerCAmelCase__						,       tokenize_chinese_chars=lowerCAmelCase__						,       strip_accents=lowerCAmelCase__						,       wordpieces_prefix=lowerCAmelCase__						,       **lowerCAmelCase__						,       )

								SCREAMING_SNAKE_CASE													=					json.loads(self.backend_tokenizer.normalizer.__getstate__()				)
								if (
								    normalizer_state.get('lowercase'						,       lowerCAmelCase__				) != do_lower_case
								    or normalizer_state.get('strip_accents'						,       lowerCAmelCase__				) != strip_accents
								    or normalizer_state.get('handle_chinese_chars'						,       lowerCAmelCase__				) != tokenize_chinese_chars
								):
														SCREAMING_SNAKE_CASE													=					getattr(lowerCAmelCase__						,       normalizer_state.pop('type'				)				)
														SCREAMING_SNAKE_CASE													=					do_lower_case
														SCREAMING_SNAKE_CASE													=					strip_accents
														SCREAMING_SNAKE_CASE													=					tokenize_chinese_chars
														SCREAMING_SNAKE_CASE													=					normalizer_class(**lowerCAmelCase__				)

								SCREAMING_SNAKE_CASE													=					do_lower_case







		def 							__A						(	self						,       lowerCAmelCase__						,       lowerCAmelCase__=None				)     ->							Optional[Any]:
								SCREAMING_SNAKE_CASE													=					[self.cls_token_id] + token_ids_a + [self.sep_token_id]

								if token_ids_a:
														output += token_ids_a + [self.sep_token_id]

								return output







		def 							__A						(	self						,       lowerCAmelCase__						,       lowerCAmelCase__ = None				)     ->							List[int]:
								SCREAMING_SNAKE_CASE													=					[self.sep_token_id]
								SCREAMING_SNAKE_CASE													=					[self.cls_token_id]
								if token_ids_a is None:
														return len(cls				) * [self.cls_token_type_id] + len(token_ids_a + sep				) * [0]
								return len(cls				) * [self.cls_token_type_id] + len(token_ids_a + sep				) * [0] + len(token_ids_a + sep				) * [1]







		def 							__A						(	self						,       lowerCAmelCase__						,       lowerCAmelCase__ = None				)     ->							Tuple[str]:
								SCREAMING_SNAKE_CASE													=					self._tokenizer.model.save(lowerCAmelCase__						,       name=lowerCAmelCase__				)
								return tuple(lowerCAmelCase__				)


