





import argparse

import requests
import torch
from PIL import Image
from torchvision.transforms import Compose, Normalize, Resize, ToTensor

from transformers import SwinaSRConfig, SwinaSRForImageSuperResolution, SwinaSRImageProcessor




def _a (  SCREAMING_SNAKE_CASE__      :  Any       )	->    Dict:

       '''simple docstring'''






       SCREAMING_SNAKE_CASE__       :      Optional[int]     =						SwinaSRConfig()

       if "Swin2SR_ClassicalSR_X4_64" in checkpoint_url:
              SCREAMING_SNAKE_CASE__       :      Any     =						4
       elif "Swin2SR_CompressedSR_X4_48" in checkpoint_url:
              SCREAMING_SNAKE_CASE__       :      str     =						4
              SCREAMING_SNAKE_CASE__       :      str     =						48
              SCREAMING_SNAKE_CASE__       :      Dict     =						"pixelshuffle_aux"
       elif "Swin2SR_Lightweight_X2_64" in checkpoint_url:
              SCREAMING_SNAKE_CASE__       :      List[str]     =						[6, 6, 6, 6]
              SCREAMING_SNAKE_CASE__       :      int     =						60
              SCREAMING_SNAKE_CASE__       :      List[Any]     =						[6, 6, 6, 6]
              SCREAMING_SNAKE_CASE__       :      Any     =						"pixelshuffledirect"
       elif "Swin2SR_RealworldSR_X4_64_BSRGAN_PSNR" in checkpoint_url:
              SCREAMING_SNAKE_CASE__       :      List[str]     =						4
              SCREAMING_SNAKE_CASE__       :      Optional[int]     =						"nearest+conv"
       elif "Swin2SR_Jpeg_dynamic" in checkpoint_url:
              SCREAMING_SNAKE_CASE__       :      Union[str, Any]     =						1
              SCREAMING_SNAKE_CASE__       :      Union[str, Any]     =						1
              SCREAMING_SNAKE_CASE__       :      Union[str, Any]     =						1_26
              SCREAMING_SNAKE_CASE__       :      Optional[Any]     =						7
              SCREAMING_SNAKE_CASE__       :      Tuple     =						2_55.0
              SCREAMING_SNAKE_CASE__       :      str     =						""

       return config




def _a (  SCREAMING_SNAKE_CASE__      :  Optional[int]			,				SCREAMING_SNAKE_CASE__      :  Any       )	->    List[str]:

       '''simple docstring'''






       if "patch_embed.proj" in name and "layers" not in name:
              SCREAMING_SNAKE_CASE__       :      Tuple     =						name.replace("patch_embed.proj"			,				"embeddings.patch_embeddings.projection"       )
       if "patch_embed.norm" in name:
              SCREAMING_SNAKE_CASE__       :      str     =						name.replace("patch_embed.norm"			,				"embeddings.patch_embeddings.layernorm"       )
       if "layers" in name:
              SCREAMING_SNAKE_CASE__       :      Tuple     =						name.replace("layers"			,				"encoder.stages"       )
       if "residual_group.blocks" in name:
              SCREAMING_SNAKE_CASE__       :      List[str]     =						name.replace("residual_group.blocks"			,				"layers"       )
       if "attn.proj" in name:
              SCREAMING_SNAKE_CASE__       :      Optional[Any]     =						name.replace("attn.proj"			,				"attention.output.dense"       )
       if "attn" in name:
              SCREAMING_SNAKE_CASE__       :      Optional[int]     =						name.replace("attn"			,				"attention.self"       )
       if "norm1" in name:
              SCREAMING_SNAKE_CASE__       :      str     =						name.replace("norm1"			,				"layernorm_before"       )
       if "norm2" in name:
              SCREAMING_SNAKE_CASE__       :      int     =						name.replace("norm2"			,				"layernorm_after"       )
       if "mlp.fc1" in name:
              SCREAMING_SNAKE_CASE__       :      Optional[int]     =						name.replace("mlp.fc1"			,				"intermediate.dense"       )
       if "mlp.fc2" in name:
              SCREAMING_SNAKE_CASE__       :      int     =						name.replace("mlp.fc2"			,				"output.dense"       )
       if "q_bias" in name:
              SCREAMING_SNAKE_CASE__       :      str     =						name.replace("q_bias"			,				"query.bias"       )
       if "k_bias" in name:
              SCREAMING_SNAKE_CASE__       :      int     =						name.replace("k_bias"			,				"key.bias"       )
       if "v_bias" in name:
              SCREAMING_SNAKE_CASE__       :      Optional[Any]     =						name.replace("v_bias"			,				"value.bias"       )
       if "cpb_mlp" in name:
              SCREAMING_SNAKE_CASE__       :      List[str]     =						name.replace("cpb_mlp"			,				"continuous_position_bias_mlp"       )
       if "patch_embed.proj" in name:
              SCREAMING_SNAKE_CASE__       :      List[Any]     =						name.replace("patch_embed.proj"			,				"patch_embed.projection"       )

       if name == "norm.weight":
              SCREAMING_SNAKE_CASE__       :      List[Any]     =						"layernorm.weight"
       if name == "norm.bias":
              SCREAMING_SNAKE_CASE__       :      int     =						"layernorm.bias"

       if "conv_first" in name:
              SCREAMING_SNAKE_CASE__       :      Optional[Any]     =						name.replace("conv_first"			,				"first_convolution"       )

       if (
           "upsample" in name
           or "conv_before_upsample" in name
           or "conv_bicubic" in name
           or "conv_up" in name
           or "conv_hr" in name
           or "conv_last" in name
           or "aux" in name
       ):
              # heads
              if "conv_last" in name:
                     SCREAMING_SNAKE_CASE__       :      Any     =						name.replace("conv_last"			,				"final_convolution"       )
              if config.upsampler in ["pixelshuffle", "pixelshuffle_aux", "nearest+conv"]:
                     if "conv_before_upsample.0" in name:
                            SCREAMING_SNAKE_CASE__       :      int     =						name.replace("conv_before_upsample.0"			,				"conv_before_upsample"       )
                     if "upsample.0" in name:
                            SCREAMING_SNAKE_CASE__       :      Optional[Any]     =						name.replace("upsample.0"			,				"upsample.convolution_0"       )
                     if "upsample.2" in name:
                            SCREAMING_SNAKE_CASE__       :      Optional[Any]     =						name.replace("upsample.2"			,				"upsample.convolution_1"       )
                     SCREAMING_SNAKE_CASE__       :      Tuple     =						"upsample." + name
              elif config.upsampler == "pixelshuffledirect":
                     SCREAMING_SNAKE_CASE__       :      Optional[Any]     =						name.replace("upsample.0.weight"			,				"upsample.conv.weight"       )
                     SCREAMING_SNAKE_CASE__       :      List[Any]     =						name.replace("upsample.0.bias"			,				"upsample.conv.bias"       )
              else:
                     pass
       else:
              SCREAMING_SNAKE_CASE__       :      Dict     =						"swin2sr." + name

       return name




def _a (  SCREAMING_SNAKE_CASE__      :  Tuple			,				SCREAMING_SNAKE_CASE__      :  str       )	->    Optional[int]:

       '''simple docstring'''






       for key in orig_state_dict.copy().keys():
              SCREAMING_SNAKE_CASE__       :      int     =						orig_state_dict.pop(SCREAMING_SNAKE_CASE__       )

              if "qkv" in key:
                     SCREAMING_SNAKE_CASE__       :      Union[str, Any]     =						key.split("."       )
                     SCREAMING_SNAKE_CASE__       :      int     =						int(key_split[1]       )
                     SCREAMING_SNAKE_CASE__       :      Any     =						int(key_split[4]       )
                     SCREAMING_SNAKE_CASE__       :      int     =						config.embed_dim

                     if "weight" in key:
                            SCREAMING_SNAKE_CASE__       :      Dict     =						val[:dim, :]
                            SCREAMING_SNAKE_CASE__       :      str     =						val[dim : dim * 2, :]
                            SCREAMING_SNAKE_CASE__       :      int     =						val[-dim:, :]
                     else:
                            SCREAMING_SNAKE_CASE__       :      Optional[Any]     =						val[:dim]
                            SCREAMING_SNAKE_CASE__       :      int     =						val[dim : dim * 2]
                            SCREAMING_SNAKE_CASE__       :      Optional[int]     =						val[-dim:]
                     pass
              else:
                     SCREAMING_SNAKE_CASE__       :      List[Any]     =						val

       return orig_state_dict




def _a (  SCREAMING_SNAKE_CASE__      :  List[Any]			,				SCREAMING_SNAKE_CASE__      :  int			,				SCREAMING_SNAKE_CASE__      :  Union[str, Any]       )	->    Optional[Any]:

       '''simple docstring'''






       SCREAMING_SNAKE_CASE__       :      Union[str, Any]     =						get_config(SCREAMING_SNAKE_CASE__       )
       SCREAMING_SNAKE_CASE__       :      List[str]     =						SwinaSRForImageSuperResolution(SCREAMING_SNAKE_CASE__       )
       model.eval()

       SCREAMING_SNAKE_CASE__       :      Union[str, Any]     =						torch.hub.load_state_dict_from_url(SCREAMING_SNAKE_CASE__			,				map_location="cpu"       )
       SCREAMING_SNAKE_CASE__       :      Optional[int]     =						convert_state_dict(SCREAMING_SNAKE_CASE__			,				SCREAMING_SNAKE_CASE__       )
       SCREAMING_SNAKE_CASE__       :      Tuple     =						model.load_state_dict(SCREAMING_SNAKE_CASE__			,				strict=SCREAMING_SNAKE_CASE__       )

       if len(SCREAMING_SNAKE_CASE__       ) > 0:
              raise ValueError("Missing keys when converting: {}".format(SCREAMING_SNAKE_CASE__       )       )
       for key in unexpected_keys:
              if not ("relative_position_index" in key or "relative_coords_table" in key or "self_mask" in key):
                     raise ValueError(f'''Unexpected key {key} in state_dict'''       )

    # verify values
       SCREAMING_SNAKE_CASE__       :      Union[str, Any]     =						"https://github.com/mv-lab/swin2sr/blob/main/testsets/real-inputs/shanghai.jpg?raw=true"
       SCREAMING_SNAKE_CASE__       :      List[Any]     =						Image.open(requests.get(SCREAMING_SNAKE_CASE__			,				stream=SCREAMING_SNAKE_CASE__       ).raw       ).convert("RGB"       )
       SCREAMING_SNAKE_CASE__       :      Tuple     =						SwinaSRImageProcessor()
       # pixel_values = processor(image, return_tensors="pt").pixel_values

       SCREAMING_SNAKE_CASE__       :      Optional[Any]     =						1_26 if "Jpeg" in checkpoint_url else 2_56
       SCREAMING_SNAKE_CASE__       :      List[str]     =						Compose(
           [
               Resize((image_size, image_size)       ),
               ToTensor(),
               Normalize(mean=[0.4_8_5, 0.4_5_6, 0.4_0_6]			,				std=[0.2_2_9, 0.2_2_4, 0.2_2_5]       ),
           ]       )
       SCREAMING_SNAKE_CASE__       :      List[Any]     =						transforms(SCREAMING_SNAKE_CASE__       ).unsqueeze(0       )

       if config.num_channels == 1:
              SCREAMING_SNAKE_CASE__       :      List[str]     =						pixel_values[:, 0, :, :].unsqueeze(1       )

       SCREAMING_SNAKE_CASE__       :      Union[str, Any]     =						model(SCREAMING_SNAKE_CASE__       )

       # assert values
       if "Swin2SR_ClassicalSR_X2_64" in checkpoint_url:
              SCREAMING_SNAKE_CASE__       :      Dict     =						torch.Size([1, 3, 5_12, 5_12]       )
              SCREAMING_SNAKE_CASE__       :      Optional[int]     =						torch.tensor(
                  [[-0.7_0_8_7, -0.7_1_3_8, -0.6_7_2_1], [-0.8_3_4_0, -0.8_0_9_5, -0.7_2_9_8], [-0.9_1_4_9, -0.8_4_1_4, -0.7_9_4_0]]       )
       elif "Swin2SR_ClassicalSR_X4_64" in checkpoint_url:
              SCREAMING_SNAKE_CASE__       :      Dict     =						torch.Size([1, 3, 10_24, 10_24]       )
              SCREAMING_SNAKE_CASE__       :      List[Any]     =						torch.tensor(
                  [[-0.7_7_7_5, -0.8_1_0_5, -0.8_9_3_3], [-0.7_7_6_4, -0.8_3_5_6, -0.9_2_2_5], [-0.7_9_7_6, -0.8_6_8_6, -0.9_5_7_9]]       )
       elif "Swin2SR_CompressedSR_X4_48" in checkpoint_url:
              # TODO values didn't match exactly here
              SCREAMING_SNAKE_CASE__       :      str     =						torch.Size([1, 3, 10_24, 10_24]       )
              SCREAMING_SNAKE_CASE__       :      List[str]     =						torch.tensor(
                  [[-0.8_0_3_5, -0.7_5_0_4, -0.7_4_9_1], [-0.8_5_3_8, -0.8_1_2_4, -0.7_7_8_2], [-0.8_8_0_4, -0.8_6_5_1, -0.8_4_9_3]]       )
       elif "Swin2SR_Lightweight_X2_64" in checkpoint_url:
              SCREAMING_SNAKE_CASE__       :      Union[str, Any]     =						torch.Size([1, 3, 5_12, 5_12]       )
              SCREAMING_SNAKE_CASE__       :      Tuple     =						torch.tensor(
                  [[-0.7_6_6_9, -0.8_6_6_2, -0.8_7_6_7], [-0.8_8_1_0, -0.9_9_6_2, -0.9_8_2_0], [-0.9_3_4_0, -1.0_3_2_2, -1.1_1_4_9]]       )
       elif "Swin2SR_RealworldSR_X4_64_BSRGAN_PSNR" in checkpoint_url:
              SCREAMING_SNAKE_CASE__       :      List[Any]     =						torch.Size([1, 3, 10_24, 10_24]       )
              SCREAMING_SNAKE_CASE__       :      List[str]     =						torch.tensor(
                  [[-0.5_2_3_8, -0.5_5_5_7, -0.6_3_2_1], [-0.6_0_1_6, -0.5_9_0_3, -0.6_3_9_1], [-0.6_2_4_4, -0.6_3_3_4, -0.6_8_8_9]]       )

       assert (
           outputs.reconstruction.shape == expected_shape
       ), f'''Shape of reconstruction should be {expected_shape}, but is {outputs.reconstruction.shape}'''
       assert torch.allclose(outputs.reconstruction[0, 0, :3, :3]			,				SCREAMING_SNAKE_CASE__			,				atol=1E-3       )
       print("Looks ok!"       )

       SCREAMING_SNAKE_CASE__       :      Dict     =						{
           "https://github.com/mv-lab/swin2sr/releases/download/v0.0.1/Swin2SR_ClassicalSR_X2_64.pth": (
               "swin2SR-classical-sr-x2-64"
           ),
           "https://github.com/mv-lab/swin2sr/releases/download/v0.0.1/Swin2SR_ClassicalSR_X4_64.pth": (
               "swin2SR-classical-sr-x4-64"
           ),
           "https://github.com/mv-lab/swin2sr/releases/download/v0.0.1/Swin2SR_CompressedSR_X4_48.pth": (
               "swin2SR-compressed-sr-x4-48"
           ),
           "https://github.com/mv-lab/swin2sr/releases/download/v0.0.1/Swin2SR_Lightweight_X2_64.pth": (
               "swin2SR-lightweight-x2-64"
           ),
           "https://github.com/mv-lab/swin2sr/releases/download/v0.0.1/Swin2SR_RealworldSR_X4_64_BSRGAN_PSNR.pth": (
               "swin2SR-realworld-sr-x4-64-bsrgan-psnr"
           ),
       }
       SCREAMING_SNAKE_CASE__       :      str     =						url_to_name[checkpoint_url]

       if pytorch_dump_folder_path is not None:
              print(f'''Saving model {model_name} to {pytorch_dump_folder_path}'''       )
              model.save_pretrained(SCREAMING_SNAKE_CASE__       )
              print(f'''Saving image processor to {pytorch_dump_folder_path}'''       )
              processor.save_pretrained(SCREAMING_SNAKE_CASE__       )

       if push_to_hub:
              model.push_to_hub(f'''caidas/{model_name}'''       )
              processor.push_to_hub(f'''caidas/{model_name}'''       )


if __name__ == "__main__":
  _lowerCamelCase :    Dict  							= argparse.ArgumentParser()
  # Required parameters
  parser.add_argument(
      '''--checkpoint_url''',
      default='''https://github.com/mv-lab/swin2sr/releases/download/v0.0.1/Swin2SR_ClassicalSR_X2_64.pth''',
      type=str,
      help='''URL of the original Swin2SR checkpoint you\'d like to convert.''',
  )
  parser.add_argument(
      '''--pytorch_dump_folder_path''', default=None, type=str, help='''Path to the output PyTorch model directory.'''
  )
  parser.add_argument('''--push_to_hub''', action='''store_true''', help='''Whether to push the converted model to the hub.''')

  _lowerCamelCase :    Tuple  							= parser.parse_args()
  convert_swinasr_checkpoint(args.checkpoint_url, args.pytorch_dump_folder_path, args.push_to_hub)













import os
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 :    int  							= logging.get_logger(__name__)

_lowerCamelCase :    Optional[Any]  							= '''▁'''

_lowerCamelCase :    Dict  							= {'''vocab_file''': '''sentencepiece.bpe.model'''}

_lowerCamelCase :    int  							= {
    '''vocab_file''': {
        '''xlm-roberta-base''': '''https://huggingface.co/xlm-roberta-base/resolve/main/sentencepiece.bpe.model''',
        '''xlm-roberta-large''': '''https://huggingface.co/xlm-roberta-large/resolve/main/sentencepiece.bpe.model''',
        '''xlm-roberta-large-finetuned-conll02-dutch''': (
            '''https://huggingface.co/xlm-roberta-large-finetuned-conll02-dutch/resolve/main/sentencepiece.bpe.model'''
        ),
        '''xlm-roberta-large-finetuned-conll02-spanish''': (
            '''https://huggingface.co/xlm-roberta-large-finetuned-conll02-spanish/resolve/main/sentencepiece.bpe.model'''
        ),
        '''xlm-roberta-large-finetuned-conll03-english''': (
            '''https://huggingface.co/xlm-roberta-large-finetuned-conll03-english/resolve/main/sentencepiece.bpe.model'''
        ),
        '''xlm-roberta-large-finetuned-conll03-german''': (
            '''https://huggingface.co/xlm-roberta-large-finetuned-conll03-german/resolve/main/sentencepiece.bpe.model'''
        ),
    }
}

_lowerCamelCase :    Optional[Any]  							= {
    '''xlm-roberta-base''': 5_1_2,
    '''xlm-roberta-large''': 5_1_2,
    '''xlm-roberta-large-finetuned-conll02-dutch''': 5_1_2,
    '''xlm-roberta-large-finetuned-conll02-spanish''': 5_1_2,
    '''xlm-roberta-large-finetuned-conll03-english''': 5_1_2,
    '''xlm-roberta-large-finetuned-conll03-german''': 5_1_2,
}


class 						lowerCamelCase       (__lowerCamelCase      ):







							"""simple docstring"""




							UpperCAmelCase_      						=   VOCAB_FILES_NAMES
							UpperCAmelCase_      						=   PRETRAINED_VOCAB_FILES_MAP
							UpperCAmelCase_      						=   PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
							UpperCAmelCase_      						=   ["input_ids", "attention_mask"]






							def __init__( self     :					Dict,			_UpperCAmelCase     :					str,			_UpperCAmelCase     :					Optional[int]="<s>",			_UpperCAmelCase     :					Optional[int]="</s>",			_UpperCAmelCase     :					Dict="</s>",			_UpperCAmelCase     :					List[Any]="<s>",			_UpperCAmelCase     :					Union[str, Any]="<unk>",			_UpperCAmelCase     :					List[Any]="<pad>",			_UpperCAmelCase     :					str="<mask>",			_UpperCAmelCase     :					Optional[Dict[str, Any]] = None,			**_UpperCAmelCase     :					List[Any],			)				->			None:





														"""simple docstring"""
														# Mask token behave like a normal word, i.e. include the space before it
														SCREAMING_SNAKE_CASE__       :      int     =						AddedToken(_UpperCAmelCase,			lstrip=_UpperCAmelCase,			rstrip=_UpperCAmelCase						) if isinstance(_UpperCAmelCase,			_UpperCAmelCase						) else mask_token

														SCREAMING_SNAKE_CASE__       :      List[str]     =						{} if sp_model_kwargs is None else sp_model_kwargs

														super().__init__(
														    bos_token=_UpperCAmelCase,			eos_token=_UpperCAmelCase,			unk_token=_UpperCAmelCase,			sep_token=_UpperCAmelCase,			cls_token=_UpperCAmelCase,			pad_token=_UpperCAmelCase,			mask_token=_UpperCAmelCase,			sp_model_kwargs=self.sp_model_kwargs,			**_UpperCAmelCase,			)

														SCREAMING_SNAKE_CASE__       :      str     =						spm.SentencePieceProcessor(**self.sp_model_kwargs						)
														self.sp_model.Load(str(_UpperCAmelCase						)						)
														SCREAMING_SNAKE_CASE__       :      Tuple     =						vocab_file

														# Original fairseq vocab and spm vocab must be "aligned":
														# Vocab    |    0    |    1    |   2    |    3    |  4  |  5  |  6  |   7   |   8   |  9
														# -------- | ------- | ------- | ------ | ------- | --- | --- | --- | ----- | ----- | ----
														# fairseq  | '<s>'   | '<pad>' | '</s>' | '<unk>' | ',' | '.' | '▁' | 's'   | '▁de' | '-'
														# spm      | '<unk>' | '<s>'   | '</s>' | ','     | '.' | '▁' | 's' | '▁de' | '-'   | '▁a'

														# Mimic fairseq token-to-id alignment for the first 4 token
														SCREAMING_SNAKE_CASE__       :      List[str]     =						{"<s>": 0, "<pad>": 1, "</s>": 2, "<unk>": 3}

														# The first "real" token "," has position 4 in the original fairseq vocab and position 3 in the spm vocab
														SCREAMING_SNAKE_CASE__       :      Dict     =						1

														SCREAMING_SNAKE_CASE__       :      int     =						len(self.sp_model						) + self.fairseq_offset
														SCREAMING_SNAKE_CASE__       :      Optional[int]     =						{v: k for k, v in self.fairseq_tokens_to_ids.items()}






							def __getstate__( self     :					str						)				->			Optional[Any]:





														"""simple docstring"""
														SCREAMING_SNAKE_CASE__       :      List[Any]     =						self.__dict__.copy()
														SCREAMING_SNAKE_CASE__       :      List[Any]     =						None
														SCREAMING_SNAKE_CASE__       :      Dict     =						self.sp_model.serialized_model_proto()
														return state






							def __setstate__( self     :					int,			_UpperCAmelCase     :					List[Any]						)				->			Any:





														"""simple docstring"""
														SCREAMING_SNAKE_CASE__       :      Tuple     =						d

														# for backward compatibility
														if not hasattr(self,			"sp_model_kwargs"						):
																					SCREAMING_SNAKE_CASE__       :      Dict     =						{}

														SCREAMING_SNAKE_CASE__       :      Union[str, Any]     =						spm.SentencePieceProcessor(**self.sp_model_kwargs						)
														self.sp_model.LoadFromSerializedProto(self.sp_model_proto						)






							def  A_     ( self     :					Any,			_UpperCAmelCase     :					List[int],			_UpperCAmelCase     :					Optional[List[int]] = None						)				->			List[int]:





														"""simple docstring"""

														if token_ids_a is None:
																					return [self.cls_token_id] + token_ids_a + [self.sep_token_id]
														SCREAMING_SNAKE_CASE__       :      List[str]     =						[self.cls_token_id]
														SCREAMING_SNAKE_CASE__       :      Union[str, Any]     =						[self.sep_token_id]
														return cls + token_ids_a + sep + sep + token_ids_a + sep






							def  A_     ( self     :					List[Any],			_UpperCAmelCase     :					List[int],			_UpperCAmelCase     :					Optional[List[int]] = None,			_UpperCAmelCase     :					bool = False						)				->			List[int]:





														"""simple docstring"""

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

														if token_ids_a is None:
																					return [1] + ([0] * len(_UpperCAmelCase						)) + [1]
														return [1] + ([0] * len(_UpperCAmelCase						)) + [1, 1] + ([0] * len(_UpperCAmelCase						)) + [1]






							def  A_     ( self     :					Union[str, Any],			_UpperCAmelCase     :					List[int],			_UpperCAmelCase     :					Optional[List[int]] = None						)				->			List[int]:





														"""simple docstring"""
														SCREAMING_SNAKE_CASE__       :      str     =						[self.sep_token_id]
														SCREAMING_SNAKE_CASE__       :      Optional[int]     =						[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 + sep + token_ids_a + sep						) * [0]






							@property
							def  A_     ( self     :					List[str]						)				->			List[str]:





														"""simple docstring"""
														return len(self.sp_model						) + self.fairseq_offset + 1  # Add the <mask> token






							def  A_     ( self     :					List[Any]						)				->			Optional[int]:





														"""simple docstring"""
														SCREAMING_SNAKE_CASE__       :      str     =						{self.convert_ids_to_tokens(_UpperCAmelCase						): i for i in range(self.vocab_size						)}
														vocab.update(self.added_tokens_encoder						)
														return vocab






							def  A_     ( self     :					List[str],			_UpperCAmelCase     :					str						)				->			List[str]:





														"""simple docstring"""
														return self.sp_model.encode(_UpperCAmelCase,			out_type=_UpperCAmelCase						)






							def  A_     ( self     :					Optional[Any],			_UpperCAmelCase     :					Union[str, Any]						)				->			Union[str, Any]:





														"""simple docstring"""
														if token in self.fairseq_tokens_to_ids:
																					return self.fairseq_tokens_to_ids[token]
														SCREAMING_SNAKE_CASE__       :      Union[str, Any]     =						self.sp_model.PieceToId(_UpperCAmelCase						)

														# Need to return unknown token if the SP model returned 0
														return spm_id + self.fairseq_offset if spm_id else self.unk_token_id






							def  A_     ( self     :					Tuple,			_UpperCAmelCase     :					List[str]						)				->			List[str]:





														"""simple docstring"""
														if index in self.fairseq_ids_to_tokens:
																					return self.fairseq_ids_to_tokens[index]
														return self.sp_model.IdToPiece(index - self.fairseq_offset						)






							def  A_     ( self     :					Any,			_UpperCAmelCase     :					int						)				->			List[Any]:





														"""simple docstring"""
														SCREAMING_SNAKE_CASE__       :      int     =						"".join(_UpperCAmelCase						).replace(_UpperCAmelCase,			" "						).strip()
														return out_string






							def  A_     ( self     :					Union[str, Any],			_UpperCAmelCase     :					str,			_UpperCAmelCase     :					Optional[str] = None						)				->			Tuple[str]:





														"""simple docstring"""
														if not os.path.isdir(_UpperCAmelCase						):
																					logger.error(F'''Vocabulary path ({save_directory}) should be a directory'''						)
																					return
														SCREAMING_SNAKE_CASE__       :      Optional[Any]     =						os.path.join(
														    _UpperCAmelCase,			(filename_prefix + "-" if filename_prefix else "") + VOCAB_FILES_NAMES["vocab_file"]						)

														if os.path.abspath(self.vocab_file						) != os.path.abspath(_UpperCAmelCase						) and os.path.isfile(self.vocab_file						):
																					copyfile(self.vocab_file,			_UpperCAmelCase						)
														elif not os.path.isfile(self.vocab_file						):
																					with open(_UpperCAmelCase,			"wb"						) as fi:
																												SCREAMING_SNAKE_CASE__       :      Any     =						self.sp_model.serialized_model_proto()
																												fi.write(_UpperCAmelCase						)

														return (out_vocab_file,)






