"""simple docstring"""


import argparse

import huggingface_hub
import k_diffusion as K
import torch

from diffusers import UNetaDConditionModel


a							='pcuenq/k-upscaler'





def 			lowerCamelCase_ (					__lowerCAmelCase   ,    __lowerCAmelCase   ,    *, __lowerCAmelCase   ,    __lowerCAmelCase				)							->					Dict:




						'''simple docstring'''



						lowerCamelCase__					={
						    # norm1
						    F'''{diffusers_resnet_prefix}.norm1.linear.weight''': checkpoint[F'''{resnet_prefix}.main.0.mapper.weight'''],
						    F'''{diffusers_resnet_prefix}.norm1.linear.bias''': checkpoint[F'''{resnet_prefix}.main.0.mapper.bias'''],
						    # conv1
						    F'''{diffusers_resnet_prefix}.conv1.weight''': checkpoint[F'''{resnet_prefix}.main.2.weight'''],
						    F'''{diffusers_resnet_prefix}.conv1.bias''': checkpoint[F'''{resnet_prefix}.main.2.bias'''],
						    # norm2
						    F'''{diffusers_resnet_prefix}.norm2.linear.weight''': checkpoint[F'''{resnet_prefix}.main.4.mapper.weight'''],
						    F'''{diffusers_resnet_prefix}.norm2.linear.bias''': checkpoint[F'''{resnet_prefix}.main.4.mapper.bias'''],
						    # conv2
						    F'''{diffusers_resnet_prefix}.conv2.weight''': checkpoint[F'''{resnet_prefix}.main.6.weight'''],
						    F'''{diffusers_resnet_prefix}.conv2.bias''': checkpoint[F'''{resnet_prefix}.main.6.bias'''],
						}

						if resnet.conv_shortcut is not None:
												rv.update(
												    {
												        F'''{diffusers_resnet_prefix}.conv_shortcut.weight''': checkpoint[F'''{resnet_prefix}.skip.weight'''],
												    }				)

						return rv





def 			lowerCamelCase_ (					__lowerCAmelCase   ,    *, __lowerCAmelCase   ,    __lowerCAmelCase				)							->					int:




						'''simple docstring'''



						lowerCamelCase__					,      lowerCamelCase__					,      lowerCamelCase__					=checkpoint[F'''{attention_prefix}.qkv_proj.weight'''].chunk(3   ,    dim=0				)
						lowerCamelCase__					,      lowerCamelCase__					,      lowerCamelCase__					=checkpoint[F'''{attention_prefix}.qkv_proj.bias'''].chunk(3   ,    dim=0				)
						lowerCamelCase__					={
						    # norm
						    F'''{diffusers_attention_prefix}.norm1.linear.weight''': checkpoint[F'''{attention_prefix}.norm_in.mapper.weight'''],
						    F'''{diffusers_attention_prefix}.norm1.linear.bias''': checkpoint[F'''{attention_prefix}.norm_in.mapper.bias'''],
						    # to_q
						    F'''{diffusers_attention_prefix}.attn1.to_q.weight''': weight_q.squeeze(-1				).squeeze(-1				),
						    F'''{diffusers_attention_prefix}.attn1.to_q.bias''': bias_q,
						    # to_k
						    F'''{diffusers_attention_prefix}.attn1.to_k.weight''': weight_k.squeeze(-1				).squeeze(-1				),
						    F'''{diffusers_attention_prefix}.attn1.to_k.bias''': bias_k,
						    # to_v
						    F'''{diffusers_attention_prefix}.attn1.to_v.weight''': weight_v.squeeze(-1				).squeeze(-1				),
						    F'''{diffusers_attention_prefix}.attn1.to_v.bias''': bias_v,
						    # to_out
						    F'''{diffusers_attention_prefix}.attn1.to_out.0.weight''': checkpoint[F'''{attention_prefix}.out_proj.weight''']
						    .squeeze(-1				)
						    .squeeze(-1				),
						    F'''{diffusers_attention_prefix}.attn1.to_out.0.bias''': checkpoint[F'''{attention_prefix}.out_proj.bias'''],
						}

						return rv





def 			lowerCamelCase_ (					__lowerCAmelCase   ,    *, __lowerCAmelCase   ,    __lowerCAmelCase   ,    __lowerCAmelCase				)							->					str:




						'''simple docstring'''



						lowerCamelCase__					,      lowerCamelCase__					=checkpoint[F'''{attention_prefix}.kv_proj.weight'''].chunk(2   ,    dim=0				)
						lowerCamelCase__					,      lowerCamelCase__					=checkpoint[F'''{attention_prefix}.kv_proj.bias'''].chunk(2   ,    dim=0				)

						lowerCamelCase__					={
						    # norm2 (ada groupnorm)
						    F'''{diffusers_attention_prefix}.norm{diffusers_attention_index}.linear.weight''': checkpoint[
						        F'''{attention_prefix}.norm_dec.mapper.weight'''
						    ],
						    F'''{diffusers_attention_prefix}.norm{diffusers_attention_index}.linear.bias''': checkpoint[
						        F'''{attention_prefix}.norm_dec.mapper.bias'''
						    ],
						    # layernorm on encoder_hidden_state
						    F'''{diffusers_attention_prefix}.attn{diffusers_attention_index}.norm_cross.weight''': checkpoint[
						        F'''{attention_prefix}.norm_enc.weight'''
						    ],
						    F'''{diffusers_attention_prefix}.attn{diffusers_attention_index}.norm_cross.bias''': checkpoint[
						        F'''{attention_prefix}.norm_enc.bias'''
						    ],
						    # to_q
						    F'''{diffusers_attention_prefix}.attn{diffusers_attention_index}.to_q.weight''': checkpoint[
						        F'''{attention_prefix}.q_proj.weight'''
						    ]
						    .squeeze(-1				)
						    .squeeze(-1				),
						    F'''{diffusers_attention_prefix}.attn{diffusers_attention_index}.to_q.bias''': checkpoint[
						        F'''{attention_prefix}.q_proj.bias'''
						    ],
						    # to_k
						    F'''{diffusers_attention_prefix}.attn{diffusers_attention_index}.to_k.weight''': weight_k.squeeze(-1				).squeeze(-1				),
						    F'''{diffusers_attention_prefix}.attn{diffusers_attention_index}.to_k.bias''': bias_k,
						    # to_v
						    F'''{diffusers_attention_prefix}.attn{diffusers_attention_index}.to_v.weight''': weight_v.squeeze(-1				).squeeze(-1				),
						    F'''{diffusers_attention_prefix}.attn{diffusers_attention_index}.to_v.bias''': bias_v,
						    # to_out
						    F'''{diffusers_attention_prefix}.attn{diffusers_attention_index}.to_out.0.weight''': checkpoint[
						        F'''{attention_prefix}.out_proj.weight'''
						    ]
						    .squeeze(-1				)
						    .squeeze(-1				),
						    F'''{diffusers_attention_prefix}.attn{diffusers_attention_index}.to_out.0.bias''': checkpoint[
						        F'''{attention_prefix}.out_proj.bias'''
						    ],
						}

						return rv





def 			lowerCamelCase_ (					__lowerCAmelCase   ,    __lowerCAmelCase   ,    __lowerCAmelCase   ,    __lowerCAmelCase				)							->					Optional[int]:




						'''simple docstring'''



						lowerCamelCase__					="inner_model.u_net.u_blocks" if block_type == "up" else "inner_model.u_net.d_blocks"
						lowerCamelCase__					=F'''{block_prefix}.{block_idx}'''

						lowerCamelCase__					={}

						if not hasattr(__lowerCAmelCase   ,    "attentions"				):
												lowerCamelCase__					=1  # resnet only
						elif not block.attentions[0].add_self_attention:
												lowerCamelCase__					=2  # resnet -> cross-attention
						else:
												lowerCamelCase__					=3  # resnet -> self-attention -> cross-attention)

						for resnet_idx, resnet in enumerate(block.resnets				):
												# diffusers_resnet_prefix = f"{diffusers_up_block_prefix}.resnets.{resnet_idx}"
												lowerCamelCase__					=F'''{block_type}_blocks.{block_idx}.resnets.{resnet_idx}'''
												lowerCamelCase__					=n * resnet_idx if block_type == "up" else n * resnet_idx + 1
												lowerCamelCase__					=F'''{block_prefix}.{idx}''' if block_type == "up" else F'''{block_prefix}.{idx}'''

												diffusers_checkpoint.update(
												    resnet_to_diffusers_checkpoint(
												        __lowerCAmelCase   ,    __lowerCAmelCase   ,    diffusers_resnet_prefix=__lowerCAmelCase   ,    resnet_prefix=__lowerCAmelCase				)				)

						if hasattr(__lowerCAmelCase   ,    "attentions"				):
												for attention_idx, attention in enumerate(block.attentions				):
																		lowerCamelCase__					=F'''{block_type}_blocks.{block_idx}.attentions.{attention_idx}'''
																		lowerCamelCase__					=n * attention_idx + 1 if block_type == "up" else n * attention_idx + 2
																		lowerCamelCase__					=F'''{block_prefix}.{idx}'''
																		lowerCamelCase__					=F'''{block_prefix}.{idx }'''
																		lowerCamelCase__					=1 if not attention.add_self_attention else 2
																		lowerCamelCase__					=(
																		    n * attention_idx + cross_attention_index
																		    if block_type == "up"
																		    else n * attention_idx + cross_attention_index + 1
																		)
																		lowerCamelCase__					=F'''{block_prefix}.{idx }'''

																		diffusers_checkpoint.update(
																		    cross_attn_to_diffusers_checkpoint(
																		        __lowerCAmelCase   ,    diffusers_attention_prefix=__lowerCAmelCase   ,    diffusers_attention_index=2   ,    attention_prefix=__lowerCAmelCase   ,    )				)

																		if attention.add_self_attention is True:
																								diffusers_checkpoint.update(
																								    self_attn_to_diffusers_checkpoint(
																								        __lowerCAmelCase   ,    diffusers_attention_prefix=__lowerCAmelCase   ,    attention_prefix=__lowerCAmelCase   ,    )				)

						return diffusers_checkpoint





def 			lowerCamelCase_ (					__lowerCAmelCase   ,    __lowerCAmelCase				)							->					Tuple:




						'''simple docstring'''



						lowerCamelCase__					={}

						# pre-processing
						diffusers_checkpoint.update(
						    {
						        "conv_in.weight": checkpoint["inner_model.proj_in.weight"],
						        "conv_in.bias": checkpoint["inner_model.proj_in.bias"],
						    }				)

						# timestep and class embedding
						diffusers_checkpoint.update(
						    {
						        "time_proj.weight": checkpoint["inner_model.timestep_embed.weight"].squeeze(-1				),
						        "time_embedding.linear_1.weight": checkpoint["inner_model.mapping.0.weight"],
						        "time_embedding.linear_1.bias": checkpoint["inner_model.mapping.0.bias"],
						        "time_embedding.linear_2.weight": checkpoint["inner_model.mapping.2.weight"],
						        "time_embedding.linear_2.bias": checkpoint["inner_model.mapping.2.bias"],
						        "time_embedding.cond_proj.weight": checkpoint["inner_model.mapping_cond.weight"],
						    }				)

						# down_blocks
						for down_block_idx, down_block in enumerate(model.down_blocks				):
												diffusers_checkpoint.update(block_to_diffusers_checkpoint(__lowerCAmelCase   ,    __lowerCAmelCase   ,    __lowerCAmelCase   ,    "down"				)				)

						# up_blocks
						for up_block_idx, up_block in enumerate(model.up_blocks				):
												diffusers_checkpoint.update(block_to_diffusers_checkpoint(__lowerCAmelCase   ,    __lowerCAmelCase   ,    __lowerCAmelCase   ,    "up"				)				)

						# post-processing
						diffusers_checkpoint.update(
						    {
						        "conv_out.weight": checkpoint["inner_model.proj_out.weight"],
						        "conv_out.bias": checkpoint["inner_model.proj_out.bias"],
						    }				)

						return diffusers_checkpoint





def 			lowerCamelCase_ (					__lowerCAmelCase				)							->					Optional[int]:




						'''simple docstring'''



						lowerCamelCase__					=original_config["input_channels"] + original_config["unet_cond_dim"]
						lowerCamelCase__					=original_config["input_channels"] + (1 if original_config["has_variance"] else 0)

						lowerCamelCase__					=original_config["channels"]

						assert (
						    len(set(original_config["depths"]				)				) == 1
						), "UNet2DConditionModel currently do not support blocks with different number of layers"
						lowerCamelCase__					=original_config["depths"][0]

						lowerCamelCase__					=original_config["mapping_cond_dim"]
						lowerCamelCase__					=original_config["cross_cond_dim"]

						lowerCamelCase__					=[]
						lowerCamelCase__					=[]
						for s, c in zip(original_config["self_attn_depths"]   ,    original_config["cross_attn_depths"]				):
												if s:
																		lowerCamelCase__					="self"
																		lowerCamelCase__					="cross" if c else None
												elif c:
																		lowerCamelCase__					="cross"
																		lowerCamelCase__					=None
												else:
																		lowerCamelCase__					=None
																		lowerCamelCase__					=None
												attna_types.append(__lowerCAmelCase				)
												attna_types.append(__lowerCAmelCase				)

						lowerCamelCase__					=UNetaDConditionModel(
						    in_channels=__lowerCAmelCase   ,    out_channels=__lowerCAmelCase   ,    down_block_types=("KDownBlock2D", "KCrossAttnDownBlock2D", "KCrossAttnDownBlock2D", "KCrossAttnDownBlock2D")   ,    mid_block_type=__lowerCAmelCase   ,    up_block_types=("KCrossAttnUpBlock2D", "KCrossAttnUpBlock2D", "KCrossAttnUpBlock2D", "KUpBlock2D")   ,    block_out_channels=__lowerCAmelCase   ,    layers_per_block=__lowerCAmelCase   ,    act_fn="gelu"   ,    norm_num_groups=__lowerCAmelCase   ,    cross_attention_dim=__lowerCAmelCase   ,    attention_head_dim=64   ,    time_cond_proj_dim=__lowerCAmelCase   ,    resnet_time_scale_shift="scale_shift"   ,    time_embedding_type="fourier"   ,    timestep_post_act="gelu"   ,    conv_in_kernel=1   ,    conv_out_kernel=1   ,    )

						return unet





def 			lowerCamelCase_ (					__lowerCAmelCase				)							->					int:




						'''simple docstring'''



						lowerCamelCase__					=torch.device("cuda" if torch.cuda.is_available() else "cpu"				)

						lowerCamelCase__					=huggingface_hub.hf_hub_download(__lowerCAmelCase   ,    "config_laion_text_cond_latent_upscaler_2.json"				)
						lowerCamelCase__					=huggingface_hub.hf_hub_download(
						    __lowerCAmelCase   ,    "laion_text_cond_latent_upscaler_2_1_00470000_slim.pth"				)
						print(F'''loading original model configuration from {orig_config_path}'''				)
						print(F'''loading original model checkpoint from {orig_weights_path}'''				)

						print("converting to diffusers unet"				)
						lowerCamelCase__					=K.config.load_config(open(__lowerCAmelCase				)				)["model"]
						lowerCamelCase__					=unet_model_from_original_config(__lowerCAmelCase				)

						lowerCamelCase__					=torch.load(__lowerCAmelCase   ,    map_location=__lowerCAmelCase				)["model_ema"]
						lowerCamelCase__					=unet_to_diffusers_checkpoint(__lowerCAmelCase   ,    __lowerCAmelCase				)

						model.load_state_dict(__lowerCAmelCase   ,    strict=__lowerCAmelCase				)
						model.save_pretrained(args.dump_path				)
						print(F'''saving converted unet model in {args.dump_path}'''				)


if __name__ == "__main__":
	a							=argparse.ArgumentParser()

	parser.add_argument('--dump_path', default=None, type=str, required=True, help='Path to the output model.')
	a							=parser.parse_args()

	main(args)










import os
import re
import unicodedata
from shutil import copyfile
from typing import Any, Dict, List, Optional, Tuple

import sentencepiece as spm

from ...tokenization_utils import AddedToken, PreTrainedTokenizer
from ...utils import logging


lowerCamelCase_						     =  logging.get_logger(__name__)
lowerCamelCase_						     =  {"""vocab_file""": """spiece.model"""}

lowerCamelCase_						     =  {
    """vocab_file""": {
        """google/fnet-base""": """https://huggingface.co/google/fnet-base/resolve/main/spiece.model""",
        """google/fnet-large""": """https://huggingface.co/google/fnet-large/resolve/main/spiece.model""",
    },
}

lowerCamelCase_						     =  {
    """google/fnet-base""": 5_1_2,
    """google/fnet-large""": 5_1_2,
}

lowerCamelCase_						     =  """▁"""




class 							a_ (						a_		):


							'''simple docstring'''






							__a:	Optional[int]     =    VOCAB_FILES_NAMES
							__a:	Union[str, Any]     =    PRETRAINED_VOCAB_FILES_MAP
							__a:	List[Any]     =    PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
							__a:	Any     =    ['''input_ids''', '''token_type_ids''']

							def __init__(		self			,			lowercase_			,			lowercase_=False			,			lowercase_=True			,			lowercase_=True			,			lowercase_="<unk>"			,			lowercase_="[SEP]"			,			lowercase_="<pad>"			,			lowercase_="[CLS]"			,			lowercase_="[MASK]"			,			lowercase_ = None			,			**lowercase_			,			)					->					None:
														'''simple docstring'''

														lowerCAmelCase_										=     (
														    AddedToken(lowercase_			,			lstrip=lowercase_			,			rstrip=lowercase_			,			normalized=lowercase_   )
														    if isinstance(lowercase_			,			lowercase_   )
														    else mask_token
														)

														lowerCAmelCase_										=     {} if sp_model_kwargs is None else sp_model_kwargs

														super().__init__(
														    do_lower_case=lowercase_			,			remove_space=lowercase_			,			keep_accents=lowercase_			,			unk_token=lowercase_			,			sep_token=lowercase_			,			pad_token=lowercase_			,			cls_token=lowercase_			,			mask_token=lowercase_			,			sp_model_kwargs=self.sp_model_kwargs			,			**lowercase_			,			)

														lowerCAmelCase_										=     do_lower_case
														lowerCAmelCase_										=     remove_space
														lowerCAmelCase_										=     keep_accents
														lowerCAmelCase_										=     vocab_file

														lowerCAmelCase_										=     spm.SentencePieceProcessor(**self.sp_model_kwargs   )
														self.sp_model.Load(lowercase_   )

							@property
							def      _lowercase       (		self   )					->					Optional[Any]:
														'''simple docstring'''

														return len(self.sp_model   )

							def      _lowercase       (		self   )					->					Dict:
														'''simple docstring'''

														lowerCAmelCase_										=     {self.convert_ids_to_tokens(lowercase_   ): i for i in range(self.vocab_size   )}
														vocab.update(self.added_tokens_encoder   )
														return vocab

							def __getstate__(		self   )					->					Dict:
														'''simple docstring'''

														lowerCAmelCase_										=     self.__dict__.copy()
														lowerCAmelCase_										=     None
														return state

							def __setstate__(		self			,			lowercase_   )					->					Optional[int]:
														'''simple docstring'''

														lowerCAmelCase_										=     d

														# for backward compatibility
														if not hasattr(self			,			'sp_model_kwargs'   ):
																					lowerCAmelCase_										=     {}

														lowerCAmelCase_										=     spm.SentencePieceProcessor(**self.sp_model_kwargs   )
														self.sp_model.Load(self.vocab_file   )

							def      _lowercase       (		self			,			lowercase_   )					->					str:
														'''simple docstring'''

														if self.remove_space:
																					lowerCAmelCase_										=     ' '.join(inputs.strip().split()   )
														else:
																					lowerCAmelCase_										=     inputs
														lowerCAmelCase_										=     outputs.replace('``'			,			'"'   ).replace('\'\''			,			'"'   )

														if not self.keep_accents:
																					lowerCAmelCase_										=     unicodedata.normalize('NFKD'			,			lowercase_   )
																					lowerCAmelCase_										=     ''.join([c for c in outputs if not unicodedata.combining(lowercase_   )]   )
														if self.do_lower_case:
																					lowerCAmelCase_										=     outputs.lower()

														return outputs

							def      _lowercase       (		self			,			lowercase_   )					->					List[str]:
														'''simple docstring'''

														lowerCAmelCase_										=     self.preprocess_text(lowercase_   )
														lowerCAmelCase_										=     self.sp_model.encode(lowercase_			,			out_type=lowercase_   )
														lowerCAmelCase_										=     []
														for piece in pieces:
																					if len(lowercase_   ) > 1 and piece[-1] == str(','   ) and piece[-2].isdigit():
																												lowerCAmelCase_										=     self.sp_model.EncodeAsPieces(piece[:-1].replace(lowercase_			,			''   )   )
																												if piece[0] != SPIECE_UNDERLINE and cur_pieces[0][0] == SPIECE_UNDERLINE:
																																			if len(cur_pieces[0]   ) == 1:
																																										lowerCAmelCase_										=     cur_pieces[1:]
																																			else:
																																										lowerCAmelCase_										=     cur_pieces[0][1:]
																												cur_pieces.append(piece[-1]   )
																												new_pieces.extend(lowercase_   )
																					else:
																												new_pieces.append(lowercase_   )

														return new_pieces

							def      _lowercase       (		self			,			lowercase_   )					->					Tuple:
														'''simple docstring'''

														return self.sp_model.PieceToId(lowercase_   )

							def      _lowercase       (		self			,			lowercase_   )					->					Union[str, Any]:
														'''simple docstring'''

														return self.sp_model.IdToPiece(lowercase_   )

							def      _lowercase       (		self			,			lowercase_   )					->					Union[str, Any]:
														'''simple docstring'''

														lowerCAmelCase_										=     []
														lowerCAmelCase_										=     ''
														lowerCAmelCase_										=     False
														for token in tokens:
																					# make sure that special tokens are not decoded using sentencepiece model
																					if token in self.all_special_tokens:
																												if not prev_is_special:
																																			out_string += " "
																												out_string += self.sp_model.decode(lowercase_   ) + token
																												lowerCAmelCase_										=     True
																												lowerCAmelCase_										=     []
																					else:
																												current_sub_tokens.append(lowercase_   )
																												lowerCAmelCase_										=     False
														out_string += self.sp_model.decode(lowercase_   )
														return out_string.strip()

							def      _lowercase       (		self			,			lowercase_			,			lowercase_ = False			,			lowercase_ = None			,			lowercase_ = True			,			**lowercase_			,			)					->					str:
														'''simple docstring'''

														lowerCAmelCase_										=     kwargs.pop('use_source_tokenizer'			,			lowercase_   )

														lowerCAmelCase_										=     self.convert_ids_to_tokens(lowercase_			,			skip_special_tokens=lowercase_   )

														# To avoid mixing byte-level and unicode for byte-level BPT
														# we need to build string separately for added tokens and byte-level tokens
														# cf. https://github.com/huggingface/transformers/issues/1133
														lowerCAmelCase_										=     []
														lowerCAmelCase_										=     []
														for token in filtered_tokens:
																					if skip_special_tokens and token in self.all_special_ids:
																												continue
																					if token in self.added_tokens_encoder:
																												if current_sub_text:
																																			sub_texts.append(self.convert_tokens_to_string(lowercase_   )   )
																																			lowerCAmelCase_										=     []
																												sub_texts.append(lowercase_   )
																					else:
																												current_sub_text.append(lowercase_   )
														if current_sub_text:
																					sub_texts.append(self.convert_tokens_to_string(lowercase_   )   )

														# Mimic the behavior of the Rust tokenizer:
														# No space after <unk>
														if spaces_between_special_tokens:
																					lowerCAmelCase_										=     re.sub(R'(<unk>) '			,			R'\1'			,			' '.join(lowercase_   )   )
														else:
																					lowerCAmelCase_										=     ''.join(lowercase_   )

														lowerCAmelCase_										=     (
														    clean_up_tokenization_spaces
														    if clean_up_tokenization_spaces is not None
														    else self.clean_up_tokenization_spaces
														)
														if clean_up_tokenization_spaces:
																					lowerCAmelCase_										=     self.clean_up_tokenization(lowercase_   )
																					return clean_text
														else:
																					return text

							def      _lowercase       (		self			,			lowercase_			,			lowercase_ = None   )					->					List[int]:
														'''simple docstring'''

														lowerCAmelCase_										=     [self.sep_token_id]
														lowerCAmelCase_										=     [self.cls_token_id]
														if token_ids_a is None:
																					return cls + token_ids_a + sep
														return cls + token_ids_a + sep + token_ids_a + sep

							def      _lowercase       (		self			,			lowercase_			,			lowercase_ = None			,			lowercase_ = False   )					->					List[int]:
														'''simple docstring'''

														if already_has_special_tokens:
																					return super().get_special_tokens_mask(
																					    token_ids_a=lowercase_			,			token_ids_a=lowercase_			,			already_has_special_tokens=lowercase_   )

														if token_ids_a is not None:
																					return [1] + ([0] * len(lowercase_   )) + [1] + ([0] * len(lowercase_   )) + [1]
														return [1] + ([0] * len(lowercase_   )) + [1]

							def      _lowercase       (		self			,			lowercase_			,			lowercase_ = None   )					->					List[int]:
														'''simple docstring'''

														lowerCAmelCase_										=     [self.sep_token_id]
														lowerCAmelCase_										=     [self.cls_token_id]

														if token_ids_a is None:
																					return len(cls + token_ids_a + sep   ) * [0]
														return len(cls + token_ids_a + sep   ) * [0] + len(token_ids_a + sep   ) * [1]






							def      _lowercase       (		self			,			lowercase_			,			lowercase_ = None   )					->					Tuple[str]:
														'''simple docstring'''

														if not os.path.isdir(lowercase_   ):
																					logger.error(f'''Vocabulary path ({save_directory}) should be a directory'''   )
																					return
														lowerCAmelCase_										=     os.path.join(
														    lowercase_			,			(filename_prefix + '-' if filename_prefix else '') + VOCAB_FILES_NAMES['vocab_file']   )

														if os.path.abspath(self.vocab_file   ) != os.path.abspath(lowercase_   ) and os.path.isfile(self.vocab_file   ):
																					copyfile(self.vocab_file			,			lowercase_   )
														elif not os.path.isfile(self.vocab_file   ):
																					with open(lowercase_			,			'wb'   ) as fi:
																												lowerCAmelCase_										=     self.sp_model.serialized_model_proto()
																												fi.write(lowercase_   )

														return (out_vocab_file,)



