
'''simple docstring'''


import argparse

import gdown
import numpy as np
import torch
from huggingface_hub import hf_hub_download

from transformers import (
    CLIPTokenizer,
    CLIPTokenizerFast,
    VideoMAEImageProcessor,
    XCLIPConfig,
    XCLIPModel,
    XCLIPProcessor,
    XCLIPTextConfig,
    XCLIPVisionConfig,
)



def  __snake_case     (    _UpperCAmelCase					:       List[Any],      _UpperCAmelCase					:       Union[str, Any]):
   UpperCamelCase       =  XCLIPTextConfig()

   # derive patch size from model name
   UpperCamelCase       =  model_name.find('''patch''')
   UpperCamelCase       =  int(model_name[start_idx + len('''patch''') : start_idx + len('''patch''') + 2])
   UpperCamelCase       =  XCLIPVisionConfig(patch_size=lowercase_,      num_frames=lowercase_)

   if "large" in model_name:
      UpperCamelCase       =  768
      UpperCamelCase       =  3072
      UpperCamelCase       =  12

      UpperCamelCase       =  1024
      UpperCamelCase       =  4096
      UpperCamelCase       =  16
      UpperCamelCase       =  24
      UpperCamelCase       =  768
      UpperCamelCase       =  3072

   if model_name == "xclip-large-patch14-16-frames":
      UpperCamelCase       =  336

   UpperCamelCase       =  XCLIPConfig.from_text_vision_configs(lowercase_,      lowercase_)

   if "large" in model_name:
      UpperCamelCase       =  768

   return config



def  __snake_case     (    _UpperCAmelCase					:       Dict):
   # text encoder
   if name == "token_embedding.weight":
      UpperCamelCase       =  name.replace('''token_embedding.weight''',      '''text_model.embeddings.token_embedding.weight''')
   if name == "positional_embedding":
      UpperCamelCase       =  name.replace('''positional_embedding''',      '''text_model.embeddings.position_embedding.weight''')
   if "ln_1" in name:
      UpperCamelCase       =  name.replace('''ln_1''',      '''layer_norm1''')
   if "ln_2" in name:
      UpperCamelCase       =  name.replace('''ln_2''',      '''layer_norm2''')
   if "c_fc" in name:
      UpperCamelCase       =  name.replace('''c_fc''',      '''fc1''')
   if "c_proj" in name:
      UpperCamelCase       =  name.replace('''c_proj''',      '''fc2''')
   if name.startswith('''transformer.resblocks'''):
      UpperCamelCase       =  name.replace('''transformer.resblocks''',      '''text_model.encoder.layers''')
   if "attn.out_proj" in name and "message" not in name:
      UpperCamelCase       =  name.replace('''attn.out_proj''',      '''self_attn.out_proj''')
   if "ln_final" in name:
      UpperCamelCase       =  name.replace('''ln_final''',      '''text_model.final_layer_norm''')
   # visual encoder
   if name == "visual.class_embedding":
      UpperCamelCase       =  name.replace('''visual.class_embedding''',      '''vision_model.embeddings.class_embedding''')
   if name == "visual.positional_embedding":
      UpperCamelCase       =  name.replace('''visual.positional_embedding''',      '''vision_model.embeddings.position_embedding.weight''')
   if name.startswith('''visual.transformer.resblocks'''):
      UpperCamelCase       =  name.replace('''visual.transformer.resblocks''',      '''vision_model.encoder.layers''')
   if "visual.conv1" in name:
      UpperCamelCase       =  name.replace('''visual.conv1''',      '''vision_model.embeddings.patch_embedding''')
   if "visual.ln_pre" in name:
      UpperCamelCase       =  name.replace('''visual.ln_pre''',      '''vision_model.pre_layernorm''')
   if "visual.ln_post" in name:
      UpperCamelCase       =  name.replace('''visual.ln_post''',      '''vision_model.post_layernorm''')
   if "visual.proj" in name:
      UpperCamelCase       =  name.replace('''visual.proj''',      '''visual_projection.weight''')
   if "text_projection" in name:
      UpperCamelCase       =  name.replace('''text_projection''',      '''text_projection.weight''')
   # things on top
   if "prompts_visual_proj" in name:
      UpperCamelCase       =  name.replace('''prompts_visual_proj''',      '''prompts_visual_projection''')
   if "prompts_visual_ln" in name:
      UpperCamelCase       =  name.replace('''prompts_visual_ln''',      '''prompts_visual_layernorm''')
   # mit
   if name == "mit.positional_embedding":
      UpperCamelCase       =  name.replace('''positional''',      '''position''')
   if name.startswith('''mit.resblocks'''):
      UpperCamelCase       =  name.replace('''mit.resblocks''',      '''mit.encoder.layers''')
   # prompts generator
   if name.startswith('''prompts_generator.norm'''):
      UpperCamelCase       =  name.replace('''prompts_generator.norm''',      '''prompts_generator.layernorm''')

   return name



def  __snake_case     (    _UpperCAmelCase					:       str,      _UpperCAmelCase					:       int):
   for key in orig_state_dict.copy().keys():
      UpperCamelCase       =  orig_state_dict.pop(lowercase_)

      if "attn.in_proj" in key:
         UpperCamelCase       =  key.split('''.''')
         if key.startswith('''visual'''):
            UpperCamelCase       =  key_split[3]
            UpperCamelCase       =  config.vision_config.hidden_size
            if "message_attn" in key:
               if "weight" in key:
                  UpperCamelCase       =  val[
                      :dim, :
                  ]
                  UpperCamelCase       =  val[
                      dim : dim * 2, :
                  ]
                  UpperCamelCase       =  val[
                      -dim:, :
                  ]
               else:
                  UpperCamelCase       =  val[
                      :dim
                  ]
                  UpperCamelCase       =  val[
                      dim : dim * 2
                  ]
                  UpperCamelCase       =  val[
                      -dim:
                  ]
            else:
               if "weight" in key:
                  UpperCamelCase       =  val[
                      :dim, :
                  ]
                  UpperCamelCase       =  val[
                      dim : dim * 2, :
                  ]
                  UpperCamelCase       =  val[
                      -dim:, :
                  ]
               else:
                  UpperCamelCase       =  val[:dim]
                  UpperCamelCase       =  val[
                      dim : dim * 2
                  ]
                  UpperCamelCase       =  val[-dim:]
         elif key.startswith('''mit'''):
            UpperCamelCase       =  key_split[2]
            UpperCamelCase       =  config.vision_config.mit_hidden_size
            if "weight" in key:
               UpperCamelCase       =  val[:dim, :]
               UpperCamelCase       =  val[dim : dim * 2, :]
               UpperCamelCase       =  val[-dim:, :]
            else:
               UpperCamelCase       =  val[:dim]
               UpperCamelCase       =  val[dim : dim * 2]
               UpperCamelCase       =  val[-dim:]
         else:
            UpperCamelCase       =  key_split[2]
            UpperCamelCase       =  config.text_config.hidden_size
            if "weight" in key:
               UpperCamelCase       =  val[:dim, :]
               UpperCamelCase       =  val[
                   dim : dim * 2, :
               ]
               UpperCamelCase       =  val[-dim:, :]
            else:
               UpperCamelCase       =  val[:dim]
               UpperCamelCase       =  val[
                   dim : dim * 2
               ]
               UpperCamelCase       =  val[-dim:]
      else:
         UpperCamelCase       =  rename_key(lowercase_)
         if new_key_name in ["visual_projection.weight", "text_projection.weight"]:
            UpperCamelCase       =  val.T
         UpperCamelCase       =  val

   return orig_state_dict



def  __snake_case     (    _UpperCAmelCase					:       Optional[int]):
   if num_frames == 8:
      UpperCamelCase       =  """eating_spaghetti_8_frames.npy"""
   elif num_frames == 16:
      UpperCamelCase       =  """eating_spaghetti.npy"""
   elif num_frames == 32:
      UpperCamelCase       =  """eating_spaghetti_32_frames.npy"""
   UpperCamelCase       =  hf_hub_download(
       repo_id='''hf-internal-testing/spaghetti-video''',      filename=lowercase_,      repo_type='''dataset''',      )
   UpperCamelCase       =  np.load(lowercase_)
   return list(lowercase_)



def  __snake_case     (    _UpperCAmelCase					:       Union[str, Any],      _UpperCAmelCase					:       Dict=None,      _UpperCAmelCase					:       Optional[Any]=False):
   UpperCamelCase       =  {
       # fully supervised kinetics-400 checkpoints
       """xclip-base-patch32""": """https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/k400_32_8.pth""",
       """xclip-base-patch32-16-frames""": (
           """https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/k400_32_16.pth"""
       ),
       """xclip-base-patch16""": """https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/k400_16_8.pth""",
       """xclip-base-patch16-16-frames""": (
           """https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/k400_16_16.pth"""
       ),
       """xclip-large-patch14""": """https://drive.google.com/u/0/uc?id=1NUOImq0o5DlQTST17iIP3vG7DgmHQuCx&amp;export=download&amp;confirm=t&amp;uuid=b26caedc-88e2-473e-830a-9d158b653cdb""",
       """xclip-large-patch14-16-frames""": """https://drive.google.com/u/0/uc?id=1FOYgnJc097OJ4lGwtRCCydQyVPJEOH7d&amp;export=download&amp;confirm=t&amp;uuid=538fa810-e671-4050-b385-9a623f89804f""",
       # fully supervised kinetics-600 checkpoints
       """xclip-base-patch16-kinetics-600""": (
           """https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/k600_16_8.pth"""
       ),
       """xclip-base-patch16-kinetics-600-16-frames""": (
           """https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/k600_16_16.pth"""
       ),
       """xclip-large-patch14-kinetics-600""": """https://drive.google.com/u/0/uc?id=1FV8C1INuM91sLAN4ImjzePLIlpMSihwV&amp;export=download&amp;confirm=t&amp;uuid=141d4977-4a65-44ae-864f-4b0c19f838be""",
       # few shot
       """xclip-base-patch16-hmdb-2-shot""": (
           """https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/few_hmdb_2.pth"""
       ),
       """xclip-base-patch16-hmdb-4-shot""": (
           """https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/few_hmdb_4.pth"""
       ),
       """xclip-base-patch16-hmdb-8-shot""": (
           """https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/few_hmdb_8.pth"""
       ),
       """xclip-base-patch16-hmdb-16-shot""": (
           """https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/few_hmdb_16.pth"""
       ),
       """xclip-base-patch16-ucf-2-shot""": (
           """https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/few_ucf_2.pth"""
       ),
       """xclip-base-patch16-ucf-4-shot""": (
           """https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/few_ucf_4.pth"""
       ),
       """xclip-base-patch16-ucf-8-shot""": (
           """https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/few_ucf_8.pth"""
       ),
       """xclip-base-patch16-ucf-16-shot""": (
           """https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/few_ucf_16.pth"""
       ),
       # zero shot
       """xclip-base-patch16-zero-shot""": """https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/zero.pth""",
   }

   UpperCamelCase       =  model_to_url[model_name]
   UpperCamelCase       =  8
   if "16-frames" in model_name:
      UpperCamelCase       =  16
   elif "shot" in model_name:
      UpperCamelCase       =  32

   UpperCamelCase       =  get_xclip_config(lowercase_,      lowercase_)
   UpperCamelCase       =  XCLIPModel(lowercase_)
   model.eval()

   if "drive" in checkpoint_url:
      UpperCamelCase       =  """pytorch_model.bin"""
      gdown.cached_download(lowercase_,      lowercase_,      quiet=lowercase_)
      UpperCamelCase       =  torch.load(lowercase_,      map_location='''cpu''')["""model"""]
   else:
      UpperCamelCase       =  torch.hub.load_state_dict_from_url(lowercase_)["""model"""]

   UpperCamelCase       =  convert_state_dict(lowercase_,      lowercase_)

   UpperCamelCase       =  XCLIPModel(lowercase_)
   UpperCamelCase       =  model.load_state_dict(lowercase_,      strict=lowercase_)
   assert missing_keys == ["text_model.embeddings.position_ids", "vision_model.embeddings.position_ids"]
   model.eval()

   UpperCamelCase       =  336 if model_name == """xclip-large-patch14-16-frames""" else 224
   UpperCamelCase       =  VideoMAEImageProcessor(size=lowercase_)
   UpperCamelCase       =  CLIPTokenizer.from_pretrained('''openai/clip-vit-base-patch32''')
   UpperCamelCase       =  CLIPTokenizerFast.from_pretrained('''openai/clip-vit-base-patch32''')
   UpperCamelCase       =  XCLIPProcessor(image_processor=lowercase_,      tokenizer=lowercase_)

   UpperCamelCase       =  prepare_video(lowercase_)
   UpperCamelCase       =  processor(
       text=['''playing sports''', '''eating spaghetti''', '''go shopping'''],      videos=lowercase_,      return_tensors='''pt''',      padding=lowercase_)

   print('''Shape of pixel values:''',      inputs.pixel_values.shape)

   with torch.no_grad():
      UpperCamelCase       =  model(**lowercase_)

   # Verify outputs
   UpperCamelCase       =  outputs.logits_per_video
   UpperCamelCase       =  logits_per_video.softmax(dim=1)
   print('''Probs:''',      lowercase_)
   # kinetics-400
   if model_name == "xclip-base-patch32":
      UpperCamelCase       =  torch.tensor([[0.0_0_1_9, 0.9_9_5_1, 0.0_0_3_0]])
   elif model_name == "xclip-base-patch32-16-frames":
      UpperCamelCase       =  torch.tensor([[7.0_9_9_9E-0_4, 9.9_8_8_3E-0_1, 4.5_5_8_0E-0_4]])
   elif model_name == "xclip-base-patch16":
      UpperCamelCase       =  torch.tensor([[0.0_0_8_3, 0.9_6_8_1, 0.0_2_3_6]])
   elif model_name == "xclip-base-patch16-16-frames":
      UpperCamelCase       =  torch.tensor([[7.6_9_3_7E-0_4, 9.9_7_2_8E-0_1, 1.9_4_7_3E-0_3]])
   elif model_name == "xclip-large-patch14":
      UpperCamelCase       =  torch.tensor([[0.0_0_6_2, 0.9_8_6_4, 0.0_0_7_5]])
   elif model_name == "xclip-large-patch14-16-frames":
      UpperCamelCase       =  torch.tensor([[3.3_8_7_7E-0_4, 9.9_9_3_7E-0_1, 2.8_8_8_8E-0_4]])
   # kinetics-600
   elif model_name == "xclip-base-patch16-kinetics-600":
      UpperCamelCase       =  torch.tensor([[0.0_5_5_5, 0.8_9_1_4, 0.0_5_3_1]])
   elif model_name == "xclip-base-patch16-kinetics-600-16-frames":
      UpperCamelCase       =  torch.tensor([[3.8_5_5_4E-0_4, 9.9_9_2_9E-0_1, 3.2_7_5_4E-0_4]])
   elif model_name == "xclip-large-patch14-kinetics-600":
      UpperCamelCase       =  torch.tensor([[0.0_0_3_6, 0.9_9_2_0, 0.0_0_4_5]])
   # few shot
   elif model_name == "xclip-base-patch16-hmdb-2-shot":
      UpperCamelCase       =  torch.tensor([[7.1_8_9_0E-0_6, 9.9_9_9_4E-0_1, 5.6_5_5_9E-0_5]])
   elif model_name == "xclip-base-patch16-hmdb-4-shot":
      UpperCamelCase       =  torch.tensor([[1.0_3_2_0E-0_5, 9.9_9_9_3E-0_1, 6.2_4_3_5E-0_5]])
   elif model_name == "xclip-base-patch16-hmdb-8-shot":
      UpperCamelCase       =  torch.tensor([[4.1_3_7_7E-0_6, 9.9_9_9_0E-0_1, 9.8_3_8_6E-0_5]])
   elif model_name == "xclip-base-patch16-hmdb-16-shot":
      UpperCamelCase       =  torch.tensor([[4.1_3_4_7E-0_5, 9.9_9_6_2E-0_1, 3.3_4_1_1E-0_4]])
   elif model_name == "xclip-base-patch16-ucf-2-shot":
      UpperCamelCase       =  torch.tensor([[8.5_8_5_7E-0_5, 9.9_9_2_8E-0_1, 6.3_2_9_1E-0_4]])
   elif model_name == "xclip-base-patch16-ucf-4-shot":
      UpperCamelCase       =  torch.tensor([[8.5_8_5_7E-0_5, 9.9_9_2_8E-0_1, 6.3_2_9_1E-0_4]])
   elif model_name == "xclip-base-patch16-ucf-8-shot":
      UpperCamelCase       =  torch.tensor([[0.0_0_2_7, 0.9_9_0_4, 0.0_0_7_0]])
   elif model_name == "xclip-base-patch16-ucf-16-shot":
      UpperCamelCase       =  torch.tensor([[9.8_2_1_9E-0_4, 9.9_5_9_3E-0_1, 3.0_8_6_3E-0_3]])
   # zero shot
   elif model_name == "xclip-base-patch16-zero-shot":
      UpperCamelCase       =  torch.tensor([[3.5_0_8_2E-0_4, 9.9_7_8_5E-0_1, 1.7_9_6_6E-0_3]])
   else:
      raise ValueError(f'Model name {model_name} not supported')
   assert torch.allclose(lowercase_,      lowercase_,      atol=1E-3)
   print('''Looks ok!''')

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

   if push_to_hub:
      print('''Pushing model, processor and slow tokenizer files to the hub...''')
      model.push_to_hub(lowercase_,      organization='''nielsr''')
      processor.push_to_hub(lowercase_,      organization='''nielsr''')
      slow_tokenizer.push_to_hub(lowercase_,      organization='''nielsr''')


if __name__ == "__main__":
      snake_case_ :  List[str]     =					argparse.ArgumentParser()
      # Required parameters
      parser.add_argument(
          '--model_name',
          default='xclip-base-patch32',
          type=str,
          help='Name of the model.',
      )
      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 or not to push the converted model to the 🤗 hub.'
      )

      snake_case_ :  str     =					parser.parse_args()
      convert_xclip_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)







'''simple docstring'''


import os
from shutil import copyfile
from typing import List, Optional, Tuple

from ...tokenization_utils_fast import PreTrainedTokenizerFast
from ...utils import is_sentencepiece_available, logging


if is_sentencepiece_available():
   from .tokenization_pegasus import PegasusTokenizer
else:
   snake_case_ :  Dict     =					None


snake_case_ :  int     =					logging.get_logger(__name__)


snake_case_ :  int     =					'▁'

snake_case_ :  Optional[int]     =					{'vocab_file': 'spiece.model', 'tokenizer_file': 'tokenizer.json'}

snake_case_ :  List[Any]     =					{
    'vocab_file': {'google/pegasus-xsum': 'https://huggingface.co/google/pegasus-xsum/resolve/main/spiece.model'},
    'tokenizer_file': {
        'google/pegasus-xsum': 'https://huggingface.co/google/pegasus-xsum/resolve/main/tokenizer.json'
    },
}

snake_case_ :  Tuple     =					{
    'google/pegasus-xsum': 512,
}


class 						lowercase__	(  snake_case_   ):






   '''simple docstring'''







   _snake_case		   =							VOCAB_FILES_NAMES
   _snake_case		   =							PRETRAINED_VOCAB_FILES_MAP
   _snake_case		   =							PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
   _snake_case		   =							PegasusTokenizer
   _snake_case		   =							['''input_ids''', '''attention_mask''']







   def __init__(			self ,   lowerCamelCase__=None ,   lowerCamelCase__=None ,   lowerCamelCase__="<pad>" ,   lowerCamelCase__="</s>" ,   lowerCamelCase__="<unk>" ,   lowerCamelCase__="<mask_2>" ,   lowerCamelCase__="<mask_1>" ,   lowerCamelCase__=None ,   lowerCamelCase__=1_0_3 ,   **lowerCamelCase__ ,   ):

      '''simple docstring'''







      UpperCamelCase       =  offset

      if additional_special_tokens is not None:
         if not isinstance(lowerCamelCase__ ,   lowerCamelCase__   ):
            raise TypeError(
                f'additional_special_tokens should be of type {type(lowerCamelCase__   )}, but is'
                f' {type(lowerCamelCase__   )}'   )

         UpperCamelCase       =  (
             ([mask_token_sent] + additional_special_tokens)
             if mask_token_sent not in additional_special_tokens and mask_token_sent is not None
             else additional_special_tokens
         )
         # fill additional tokens with ..., <unk_token_102> in case not all additional tokens are already taken
         additional_special_tokens_extended += [
             f'<unk_{i}>' for i in range(len(lowerCamelCase__   ) ,   self.offset - 1   )
         ]

         if len(set(lowerCamelCase__   )   ) != len(lowerCamelCase__   ):
            raise ValueError(
                '''Please make sure that the provided additional_special_tokens do not contain an incorrectly'''
                f' shifted list of <unk_x> tokens. Found {additional_special_tokens_extended}.'   )
         UpperCamelCase       =  additional_special_tokens_extended
      else:
         UpperCamelCase       =  [mask_token_sent] if mask_token_sent is not None else []
         additional_special_tokens += [f'<unk_{i}>' for i in range(2 ,   self.offset   )]

      super().__init__(
          lowerCamelCase__ ,   tokenizer_file=lowerCamelCase__ ,   pad_token=lowerCamelCase__ ,   eos_token=lowerCamelCase__ ,   unk_token=lowerCamelCase__ ,   mask_token=lowerCamelCase__ ,   mask_token_sent=lowerCamelCase__ ,   offset=lowerCamelCase__ ,   additional_special_tokens=lowerCamelCase__ ,   **lowerCamelCase__ ,   )
      UpperCamelCase       =  vocab_file
      UpperCamelCase       =  False if not self.vocab_file else True







   def       UpperCAmelCase				(			self ,   lowerCamelCase__   ):

      '''simple docstring'''







      UpperCamelCase       =  set(self.all_special_ids   )  # call it once instead of inside list comp
      all_special_ids.remove(self.unk_token_id   )  # <unk> is only sometimes special

      if all_special_ids != set(range(len(self.additional_special_tokens   ) + 3   )   ):
         raise ValueError(
             '''There should be 3 special tokens: mask_token, pad_token, and eos_token +'''
             f' {len(self.additional_special_tokens   )} additional_special_tokens, but got {all_special_ids}'   )

      return [1 if x in all_special_ids else 0 for x in seq]







   def       UpperCAmelCase				(			self ,   lowerCamelCase__ ,   lowerCamelCase__ = None ,   lowerCamelCase__ = False   ):

      '''simple docstring'''







      if already_has_special_tokens:
         return self._special_token_mask(lowerCamelCase__   )
      elif token_ids_a is None:
         return self._special_token_mask(lowerCamelCase__   ) + [1]
      else:
         return self._special_token_mask(token_ids_a + token_ids_a   ) + [1]







   def       UpperCAmelCase				(			self ,   lowerCamelCase__ ,   lowerCamelCase__=None   ):

      '''simple docstring'''







      if token_ids_a is None:
         return token_ids_a + [self.eos_token_id]
      # We don't expect to process pairs, but leave the pair logic for API consistency
      return token_ids_a + token_ids_a + [self.eos_token_id]







   def       UpperCAmelCase				(			self ,   lowerCamelCase__ ,   lowerCamelCase__ = None   ):

      '''simple docstring'''







      if not self.can_save_slow_tokenizer:
         raise ValueError(
             '''Your fast tokenizer does not have the necessary information to save the vocabulary for a slow '''
             '''tokenizer.'''   )

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

      if os.path.abspath(self.vocab_file   ) != os.path.abspath(lowerCamelCase__   ):
         copyfile(self.vocab_file ,   lowerCamelCase__   )

      return (out_vocab_file,)





