



import argparse

import fairseq
import torch
from torch import nn

from transformers import (
    MBartaaTokenizer,
    MBartConfig,
    MBartForCausalLM,
    SpeechEncoderDecoderConfig,
    SpeechEncoderDecoderModel,
    WavaVecaConfig,
    WavaVecaFeatureExtractor,
    WavaVecaModel,
    logging,
)


logging.set_verbosity_info()
a_			=					logging.get_logger(__name__)

a_			=					{
    """post_extract_proj""": """feature_projection.projection""",
    """encoder.pos_conv.0""": """encoder.pos_conv_embed.conv""",
    """self_attn.k_proj""": """encoder.layers.*.attention.k_proj""",
    """self_attn.v_proj""": """encoder.layers.*.attention.v_proj""",
    """self_attn.q_proj""": """encoder.layers.*.attention.q_proj""",
    """self_attn.out_proj""": """encoder.layers.*.attention.out_proj""",
    """self_attn_layer_norm""": """encoder.layers.*.layer_norm""",
    """fc1""": """encoder.layers.*.feed_forward.intermediate_dense""",
    """fc2""": """encoder.layers.*.feed_forward.output_dense""",
    """final_layer_norm""": """encoder.layers.*.final_layer_norm""",
    """encoder.layer_norm""": """encoder.layer_norm""",
    """w2v_model.layer_norm""": """feature_projection.layer_norm""",
    """quantizer.weight_proj""": """quantizer.weight_proj""",
    """quantizer.vars""": """quantizer.codevectors""",
    """project_q""": """project_q""",
    """final_proj""": """project_hid""",
    """w2v_encoder.proj""": """lm_head""",
    """mask_emb""": """masked_spec_embed""",
}
a_			=					[
    """lm_head""",
    """quantizer.weight_proj""",
    """quantizer.codevectors""",
    """project_q""",
    """project_hid""",
]





def 		a__			(		_UpperCamelCase			: int ,_UpperCamelCase			: Any ,_UpperCamelCase			: Optional[Any] ,_UpperCamelCase			: Union[str, Any] ,_UpperCamelCase			: str							):
   for attribute in key.split('''.'''							):
      __lowerCamelCase													=     getattr(_lowerCamelCase ,_lowerCamelCase							)

   if weight_type is not None:
      __lowerCamelCase													=     getattr(_lowerCamelCase ,_lowerCamelCase							).shape
   else:
      __lowerCamelCase													=     hf_pointer.shape

   assert hf_shape == value.shape, (
       F"""Shape of hf {key + "." + weight_type if weight_type is not None else ""} is {hf_shape}, but should be"""
       F""" {value.shape} for {full_name}"""
   )

   if weight_type == "weight":
      __lowerCamelCase													=     value
   elif weight_type == "weight_g":
      __lowerCamelCase													=     value
   elif weight_type == "weight_v":
      __lowerCamelCase													=     value
   elif weight_type == "bias":
      __lowerCamelCase													=     value
   else:
      __lowerCamelCase													=     value

   logger.info(F"""{key + "." + weight_type if weight_type is not None else ""} was initialized from {full_name}."""							)





def 		a__			(		_UpperCamelCase			: Dict ,_UpperCamelCase			: Optional[int]							):
   __lowerCamelCase													=     []
   __lowerCamelCase													=     fairseq_model.state_dict()

   __lowerCamelCase													=     hf_model.feature_extractor
   __lowerCamelCase													=     hf_model.adapter

   for name, value in fairseq_dict.items():
      __lowerCamelCase													=     False
      if "conv_layers" in name:
         load_conv_layer(
             _lowerCamelCase ,_lowerCamelCase ,_lowerCamelCase ,_lowerCamelCase ,hf_model.config.feat_extract_norm == '''group''' ,)
         __lowerCamelCase													=     True
      elif any(x in name for x in ['''adaptor''', '''w2v_encoder.proj.''', '''w2v_proj_ln.''']							):
         load_adapter(_lowerCamelCase ,_lowerCamelCase ,_lowerCamelCase ,_lowerCamelCase							)
         __lowerCamelCase													=     True
      else:
         for key, mapped_key in MAPPING.items():
            if key in name or key.split('''w2v_model.'''							)[-1] == name.split('''.'''							)[0]:
               __lowerCamelCase													=     True
               if "*" in mapped_key:
                  __lowerCamelCase													=     name.split(_lowerCamelCase							)[0].split('''.'''							)[-2]
                  __lowerCamelCase													=     mapped_key.replace('''*''' ,_lowerCamelCase							)
               if "weight_g" in name:
                  __lowerCamelCase													=     '''weight_g'''
               elif "weight_v" in name:
                  __lowerCamelCase													=     '''weight_v'''
               elif "bias" in name:
                  __lowerCamelCase													=     '''bias'''
               elif "weight" in name:
                  __lowerCamelCase													=     '''weight'''
               else:
                  __lowerCamelCase													=     None
               set_recursively(_lowerCamelCase ,_lowerCamelCase ,_lowerCamelCase ,_lowerCamelCase ,_lowerCamelCase							)
            continue
      if not is_used:
         unused_weights.append(_lowerCamelCase							)

   logger.warning(F"""Unused weights: {unused_weights}"""							)





def 		a__			(		_UpperCamelCase			: List[str] ,_UpperCamelCase			: Optional[Any] ,_UpperCamelCase			: int ,_UpperCamelCase			: Union[str, Any] ,_UpperCamelCase			: str							):
   __lowerCamelCase													=     full_name.split('''conv_layers.'''							)[-1]
   __lowerCamelCase													=     name.split('''.'''							)
   __lowerCamelCase													=     int(items[0]							)
   __lowerCamelCase													=     int(items[1]							)

   if type_id == 0:
      if "bias" in name:
         assert value.shape == feature_extractor.conv_layers[layer_id].conv.bias.data.shape, (
             F"""{full_name} has size {value.shape}, but"""
             F""" {feature_extractor.conv_layers[layer_id].conv.bias.data.shape} was found."""
         )
         __lowerCamelCase													=     value
         logger.info(F"""Feat extract conv layer {layer_id} was initialized from {full_name}."""							)
      elif "weight" in name:
         assert value.shape == feature_extractor.conv_layers[layer_id].conv.weight.data.shape, (
             F"""{full_name} has size {value.shape}, but"""
             F""" {feature_extractor.conv_layers[layer_id].conv.weight.data.shape} was found."""
         )
         __lowerCamelCase													=     value
         logger.info(F"""Feat extract conv layer {layer_id} was initialized from {full_name}."""							)
   elif (type_id == 2 and not use_group_norm) or (type_id == 2 and layer_id == 0 and use_group_norm):
      if "bias" in name:
         assert value.shape == feature_extractor.conv_layers[layer_id].layer_norm.bias.data.shape, (
             F"""{full_name} has size {value.shape}, but {feature_extractor[layer_id].layer_norm.bias.data.shape} was"""
             " found."
         )
         __lowerCamelCase													=     value
         logger.info(F"""Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}."""							)
      elif "weight" in name:
         assert value.shape == feature_extractor.conv_layers[layer_id].layer_norm.weight.data.shape, (
             F"""{full_name} has size {value.shape}, but"""
             F""" {feature_extractor[layer_id].layer_norm.weight.data.shape} was found."""
         )
         __lowerCamelCase													=     value
         logger.info(F"""Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}."""							)
   else:
      unused_weights.append(_lowerCamelCase							)





def 		a__			(		_UpperCamelCase			: Any ,_UpperCamelCase			: str ,_UpperCamelCase			: Dict ,_UpperCamelCase			: Any							):
   __lowerCamelCase													=     full_name.split('''adaptor.'''							)[-1]
   __lowerCamelCase													=     name.split('''.'''							)

   if items[1].isdigit():
      __lowerCamelCase													=     int(items[1]							)
   else:
      __lowerCamelCase													=     None

   if "adaptor" not in full_name:
      if "proj_ln" in full_name:
         # has to be layer norm
         if "bias" in name:
            assert (
                value.shape == adapter.proj_layer_norm.bias.data.shape
            ), F"""{full_name} has size {value.shape}, but {adapter.proj_layer_norm.bias.data.shape} was found."""
            __lowerCamelCase													=     value
            logger.info(F"""Adapter proj layer norm bias was initialized from {full_name}."""							)
         if "weight" in name:
            assert (
                value.shape == adapter.proj_layer_norm.weight.data.shape
            ), F"""{full_name} has size {value.shape}, but {adapter.proj_layer_norm.weight.data.shape} was found."""
            __lowerCamelCase													=     value
      else:
         # has to be projection layer
         if "bias" in name:
            assert (
                value.shape == adapter.proj.bias.data.shape
            ), F"""{full_name} has size {value.shape}, but {adapter.proj.bias.data.shape} was found."""
            __lowerCamelCase													=     value
            logger.info(F"""Adapter proj layer bias was initialized from {full_name}."""							)
         if "weight" in name:
            assert (
                value.shape == adapter.proj.weight.data.shape
            ), F"""{full_name} has size {value.shape}, but {adapter.proj.weight.data.shape} was found."""
            __lowerCamelCase													=     value
            logger.info(F"""Adapter proj layer weight was initialized from {full_name}."""							)
   elif isinstance(_lowerCamelCase ,_lowerCamelCase							):
      if "bias" in name:
         assert (
             value.shape == adapter.layers[layer_id].conv.bias.data.shape
         ), F"""{full_name} has size {value.shape}, but {adapter.layers[layer_id].conv.bias.data.shape} was found."""
         __lowerCamelCase													=     value
         logger.info(F"""Adapter layer {layer_id} bias was initialized from {full_name}."""							)
      elif "weight" in name:
         assert (
             value.shape == adapter.layers[layer_id].conv.weight.data.shape
         ), F"""{full_name} has size {value.shape}, but {adapter.layers[layer_id].conv.weight.data.shape} was found."""
         __lowerCamelCase													=     value
         logger.info(F"""Adapter layer {layer_id} bias was initialized from {full_name}."""							)
   else:
      unused_weights.append(_lowerCamelCase							)





def 		a__			(		_UpperCamelCase			: List[str]							):
   __lowerCamelCase							,__lowerCamelCase													=     emb.weight.shape
   __lowerCamelCase													=     nn.Linear(_lowerCamelCase ,_lowerCamelCase ,bias=_lowerCamelCase							)
   __lowerCamelCase													=     emb.weight.data
   return lin_layer





@torch.no_grad()
def 		a__			(		_UpperCamelCase			: Optional[int] ,_UpperCamelCase			: str ,_UpperCamelCase			: Optional[Any] ,_UpperCamelCase			: Union[str, Any] ,_UpperCamelCase			: int ,_UpperCamelCase			: str ,_UpperCamelCase			: Optional[int] ,_UpperCamelCase			: str ,_UpperCamelCase			: Tuple ,_UpperCamelCase			: Optional[Any] ,_UpperCamelCase			: Union[str, Any] ,):
   __lowerCamelCase													=     WavaVecaConfig.from_pretrained(
       _lowerCamelCase ,add_adapter=_lowerCamelCase ,adapter_stride=_lowerCamelCase ,adapter_kernel_size=_lowerCamelCase ,use_auth_token=_lowerCamelCase ,output_hidden_size=_lowerCamelCase ,)
   __lowerCamelCase													=     MBartConfig.from_pretrained(_lowerCamelCase							)

   # load model
   __lowerCamelCase							,__lowerCamelCase							,__lowerCamelCase													=     fairseq.checkpoint_utils.load_model_ensemble_and_task(
       [checkpoint_path] ,arg_overrides={
           '''config_yaml''': config_yaml_path,
           '''data''': '''/'''.join(dict_path.split('''/'''							)[:-1]							),
           '''w2v_path''': checkpoint_path,
           '''load_pretrained_decoder_from''': None,
       } ,)
   __lowerCamelCase													=     model[0].eval()

   # load feature extractor
   __lowerCamelCase													=     WavaVecaFeatureExtractor.from_pretrained(_lowerCamelCase ,use_auth_token=_lowerCamelCase							)

   # set weights for wav2vec2 encoder
   __lowerCamelCase													=     WavaVecaModel(_lowerCamelCase							)

   recursively_load_weights_wavaveca(model.encoder ,_lowerCamelCase							)

   # load decoder weights
   __lowerCamelCase													=     MBartForCausalLM(_lowerCamelCase							)
   __lowerCamelCase							,__lowerCamelCase													=     hf_decoder.model.decoder.load_state_dict(model.decoder.state_dict() ,strict=_lowerCamelCase							)
   logger.warning(F"""The following keys are missing when loading the decoder weights: {missing_keys}"""							)
   logger.warning(F"""The following keys are unexpected when loading the decoder weights: {unexpected_keys}"""							)

   __lowerCamelCase													=     SpeechEncoderDecoderModel(encoder=_lowerCamelCase ,decoder=_lowerCamelCase							)
   __lowerCamelCase													=     False

   __lowerCamelCase													=     MBartaaTokenizer(_lowerCamelCase							)
   tokenizer.save_pretrained(_lowerCamelCase							)

   __lowerCamelCase													=     hf_wavavec.config.to_dict()
   __lowerCamelCase													=     tokenizer.pad_token_id
   __lowerCamelCase													=     tokenizer.bos_token_id
   __lowerCamelCase													=     tokenizer.eos_token_id
   __lowerCamelCase													=     '''mbart50'''
   __lowerCamelCase													=     '''wav2vec2'''

   __lowerCamelCase													=     tokenizer.eos_token_id
   __lowerCamelCase													=     25_00_04
   __lowerCamelCase													=     tokenizer.eos_token_id

   __lowerCamelCase													=     SpeechEncoderDecoderConfig.from_dict(_lowerCamelCase							)

   hf_wavavec.save_pretrained(_lowerCamelCase							)
   feature_extractor.save_pretrained(_lowerCamelCase							)


if __name__ == "__main__":
  a_			=					argparse.ArgumentParser()
  parser.add_argument("""--pytorch_dump_folder_path""", default=None, type=str, help="""Path to the output PyTorch model.""")
  parser.add_argument("""--checkpoint_path""", default=None, type=str, help="""Path to fairseq checkpoint""")
  parser.add_argument("""--dict_path""", default=None, type=str, help="""Path to dict of fine-tuned model""")
  parser.add_argument("""--config_yaml_path""", default=None, type=str, help="""Path to yaml file of fine-tuned model""")
  parser.add_argument(
      """--encoder_config_path""",
      default="""facebook/wav2vec2-xls-r-1b""",
      type=str,
      help="""Path to hf encoder wav2vec2 checkpoint config""",
  )
  parser.add_argument(
      """--decoder_config_path""",
      default="""facebook/mbart-large-50-one-to-many-mmt""",
      type=str,
      help="""Path to hf decoder checkpoint config""",
  )
  parser.add_argument("""--add_adapter""", default=True, type=bool, help="""whethere to add model adapter layers""")
  parser.add_argument("""--adapter_stride""", default=2, type=int, help="""stride of adapter layers""")
  parser.add_argument("""--adapter_kernel_size""", default=3, type=int, help="""kernel size of adapter layers""")
  parser.add_argument("""--encoder_output_dim""", default=1_024, type=int, help="""encoder output dim""")
  parser.add_argument("""--start_token_id""", default=250_004, type=int, help="""`decoder_start_token_id` of model config""")

  a_			=					parser.parse_args()
  convert_wavaveca_checkpoint(
      args.checkpoint_path,
      args.pytorch_dump_folder_path,
      args.dict_path,
      args.config_yaml_path,
      encoder_config_path=args.encoder_config_path,
      decoder_config_path=args.decoder_config_path,
      add_adapter=args.add_adapter,
      adapter_kernel_size=args.adapter_kernel_size,
      adapter_stride=args.adapter_stride,
      decoder_start_token_id=args.start_token_id,
      encoder_output_dim=args.encoder_output_dim,
  )











import os
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


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

a_			=					{
    """vocab_file""": {
        """albert-base-v1""": """https://huggingface.co/albert-base-v1/resolve/main/spiece.model""",
        """albert-large-v1""": """https://huggingface.co/albert-large-v1/resolve/main/spiece.model""",
        """albert-xlarge-v1""": """https://huggingface.co/albert-xlarge-v1/resolve/main/spiece.model""",
        """albert-xxlarge-v1""": """https://huggingface.co/albert-xxlarge-v1/resolve/main/spiece.model""",
        """albert-base-v2""": """https://huggingface.co/albert-base-v2/resolve/main/spiece.model""",
        """albert-large-v2""": """https://huggingface.co/albert-large-v2/resolve/main/spiece.model""",
        """albert-xlarge-v2""": """https://huggingface.co/albert-xlarge-v2/resolve/main/spiece.model""",
        """albert-xxlarge-v2""": """https://huggingface.co/albert-xxlarge-v2/resolve/main/spiece.model""",
    }
}

a_			=					{
    """albert-base-v1""": 512,
    """albert-large-v1""": 512,
    """albert-xlarge-v1""": 512,
    """albert-xxlarge-v1""": 512,
    """albert-base-v2""": 512,
    """albert-large-v2""": 512,
    """albert-xlarge-v2""": 512,
    """albert-xxlarge-v2""": 512,
}

a_			=					"""▁"""



class  __lowerCAmelCase     (	lowerCAmelCase__   ):
 lowerCAmelCase__       					=  VOCAB_FILES_NAMES
 lowerCAmelCase__       					=  PRETRAINED_VOCAB_FILES_MAP
 lowerCAmelCase__       					=  PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES




 def __init__(						self	,				__UpperCAmelCase	,				__UpperCAmelCase=True	,				__UpperCAmelCase=True	,				__UpperCAmelCase=False	,				__UpperCAmelCase="[CLS]"	,				__UpperCAmelCase="[SEP]"	,				__UpperCAmelCase="<unk>"	,				__UpperCAmelCase="[SEP]"	,				__UpperCAmelCase="<pad>"	,				__UpperCAmelCase="[CLS]"	,				__UpperCAmelCase="[MASK]"	,				__UpperCAmelCase = None	,				**__UpperCAmelCase	,				):



    '''simple docstring'''
    # Mask token behave like a normal word, i.e. include the space before it and
    # is included in the raw text, there should be a match in a non-normalized sentence.
    __lowerCamelCase													=    (
        AddedToken(__UpperCAmelCase	,				lstrip=__UpperCAmelCase	,				rstrip=__UpperCAmelCase	,				normalized=__UpperCAmelCase				)
        if isinstance(__UpperCAmelCase	,				__UpperCAmelCase				)
        else mask_token
    )

    __lowerCamelCase													=    {} if sp_model_kwargs is None else sp_model_kwargs

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

    __lowerCamelCase													=    do_lower_case
    __lowerCamelCase													=    remove_space
    __lowerCamelCase													=    keep_accents
    __lowerCamelCase													=    vocab_file

    __lowerCamelCase													=    spm.SentencePieceProcessor(**self.sp_model_kwargs				)
    self.sp_model.Load(__UpperCAmelCase				)




 @property
 def        lowerCamelCase      (						self				):



    '''simple docstring'''
    return len(self.sp_model				)




 def        lowerCamelCase      (						self				):



    '''simple docstring'''
    __lowerCamelCase													=    {self.convert_ids_to_tokens(__UpperCAmelCase				): i for i in range(self.vocab_size				)}
    vocab.update(self.added_tokens_encoder				)
    return vocab




 def __getstate__(						self				):



    '''simple docstring'''
    __lowerCamelCase													=    self.__dict__.copy()
    __lowerCamelCase													=    None
    return state




 def __setstate__(						self	,				__UpperCAmelCase				):



    '''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        lowerCamelCase      (						self	,				__UpperCAmelCase				):



    '''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'''	,				__UpperCAmelCase				)
       __lowerCamelCase													=    ''''''.join([c for c in outputs if not unicodedata.combining(__UpperCAmelCase				)]				)
    if self.do_lower_case:
       __lowerCamelCase													=    outputs.lower()

    return outputs




 def        lowerCamelCase      (						self	,				__UpperCAmelCase				):



    '''simple docstring'''
    __lowerCamelCase													=    self.preprocess_text(__UpperCAmelCase				)
    __lowerCamelCase													=    self.sp_model.encode(__UpperCAmelCase	,				out_type=__UpperCAmelCase				)
    __lowerCamelCase													=    []
    for piece in pieces:
       if len(__UpperCAmelCase				) > 1 and piece[-1] == str(''','''				) and piece[-2].isdigit():
          __lowerCamelCase													=    self.sp_model.EncodeAsPieces(piece[:-1].replace(__UpperCAmelCase	,				''''''				)				)
          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(__UpperCAmelCase				)
       else:
          new_pieces.append(__UpperCAmelCase				)

    return new_pieces




 def        lowerCamelCase      (						self	,				__UpperCAmelCase				):



    '''simple docstring'''
    return self.sp_model.PieceToId(__UpperCAmelCase				)




 def        lowerCamelCase      (						self	,				__UpperCAmelCase				):



    '''simple docstring'''
    return self.sp_model.IdToPiece(__UpperCAmelCase				)




 def        lowerCamelCase      (						self	,				__UpperCAmelCase				):



    '''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(__UpperCAmelCase				) + token
          __lowerCamelCase													=    True
          __lowerCamelCase													=    []
       else:
          current_sub_tokens.append(__UpperCAmelCase				)
          __lowerCamelCase													=    False
    out_string += self.sp_model.decode(__UpperCAmelCase				)
    return out_string.strip()




 def        lowerCamelCase      (						self	,				__UpperCAmelCase	,				__UpperCAmelCase = None				):



    '''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        lowerCamelCase      (						self	,				__UpperCAmelCase	,				__UpperCAmelCase = None	,				__UpperCAmelCase = False				):



    '''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 not None:
       return [1] + ([0] * len(__UpperCAmelCase				)) + [1] + ([0] * len(__UpperCAmelCase				)) + [1]
    return [1] + ([0] * len(__UpperCAmelCase				)) + [1]




 def        lowerCamelCase      (						self	,				__UpperCAmelCase	,				__UpperCAmelCase = None				):



    '''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        lowerCamelCase      (						self	,				__UpperCAmelCase	,				__UpperCAmelCase = None				):



    '''simple docstring'''
    if not os.path.isdir(__UpperCAmelCase				):
       logger.error(F"""Vocabulary path ({save_directory}) should be a directory"""				)
       return
    __lowerCamelCase													=    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:
          __lowerCamelCase													=    self.sp_model.serialized_model_proto()
          fi.write(__UpperCAmelCase				)

    return (out_vocab_file,)






