


import argparse
import json

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

from transformers import (
    VideoMAEConfig,
    VideoMAEForPreTraining,
    VideoMAEForVideoClassification,
    VideoMAEImageProcessor,
)

def 						_UpperCAmelCase      (      SCREAMING_SNAKE_CASE__      : List[Any]    ):
     __UpperCamelCase   							=VideoMAEConfig()

     set_architecture_configs(SCREAMING_SNAKE_CASE__      ,					SCREAMING_SNAKE_CASE__    )

     if "finetuned" not in model_name:
          __UpperCamelCase   							=False

     if "finetuned" in model_name:
          __UpperCamelCase   							='huggingface/label-files'
          if "kinetics" in model_name:
               __UpperCamelCase   							=4_00
               __UpperCamelCase   							='kinetics400-id2label.json'
          elif "ssv2" in model_name:
               __UpperCamelCase   							=1_74
               __UpperCamelCase   							='something-something-v2-id2label.json'
          else:
               raise ValueError('Model name should either contain \'kinetics\' or \'ssv2\' in case it\'s fine-tuned.'    )
          __UpperCamelCase   							=json.load(open(hf_hub_download(SCREAMING_SNAKE_CASE__      ,					SCREAMING_SNAKE_CASE__      ,					repo_type='dataset'    )      ,					'r'    )    )
          __UpperCamelCase   							={int(SCREAMING_SNAKE_CASE__    ): v for k, v in idalabel.items()}
          __UpperCamelCase   							=idalabel
          __UpperCamelCase   							={v: k for k, v in idalabel.items()}

     return config

def 						_UpperCAmelCase      (      SCREAMING_SNAKE_CASE__      : Dict      ,					SCREAMING_SNAKE_CASE__      : List[str]    ):
     if "small" in model_name:
          __UpperCamelCase   							=3_84
          __UpperCamelCase   							=15_36
          __UpperCamelCase   							=12
          __UpperCamelCase   							=16
          __UpperCamelCase   							=12
          __UpperCamelCase   							=3
          __UpperCamelCase   							=1_92
          __UpperCamelCase   							=7_68
     elif "large" in model_name:
          __UpperCamelCase   							=10_24
          __UpperCamelCase   							=40_96
          __UpperCamelCase   							=24
          __UpperCamelCase   							=16
          __UpperCamelCase   							=12
          __UpperCamelCase   							=8
          __UpperCamelCase   							=5_12
          __UpperCamelCase   							=20_48
     elif "huge" in model_name:
          __UpperCamelCase   							=12_80
          __UpperCamelCase   							=51_20
          __UpperCamelCase   							=32
          __UpperCamelCase   							=16
          __UpperCamelCase   							=12
          __UpperCamelCase   							=8
          __UpperCamelCase   							=6_40
          __UpperCamelCase   							=25_60
     elif "base" not in model_name:
          raise ValueError('Model name should include either "small", "base", "large", or "huge"'    )

def 						_UpperCAmelCase      (      SCREAMING_SNAKE_CASE__      : Union[str, Any]    ):
     if "encoder." in name:
          __UpperCamelCase   							=name.replace('encoder.'      ,					''    )
     if "cls_token" in name:
          __UpperCamelCase   							=name.replace('cls_token'      ,					'videomae.embeddings.cls_token'    )
     if "decoder_pos_embed" in name:
          __UpperCamelCase   							=name.replace('decoder_pos_embed'      ,					'decoder.decoder_pos_embed'    )
     if "pos_embed" in name and "decoder" not in name:
          __UpperCamelCase   							=name.replace('pos_embed'      ,					'videomae.embeddings.position_embeddings'    )
     if "patch_embed.proj" in name:
          __UpperCamelCase   							=name.replace('patch_embed.proj'      ,					'videomae.embeddings.patch_embeddings.projection'    )
     if "patch_embed.norm" in name:
          __UpperCamelCase   							=name.replace('patch_embed.norm'      ,					'videomae.embeddings.norm'    )
     if "decoder.blocks" in name:
          __UpperCamelCase   							=name.replace('decoder.blocks'      ,					'decoder.decoder_layers'    )
     if "blocks" in name:
          __UpperCamelCase   							=name.replace('blocks'      ,					'videomae.encoder.layer'    )
     if "attn.proj" in name:
          __UpperCamelCase   							=name.replace('attn.proj'      ,					'attention.output.dense'    )
     if "attn" in name and "bias" not in name:
          __UpperCamelCase   							=name.replace('attn'      ,					'attention.self'    )
     if "attn" in name:
          __UpperCamelCase   							=name.replace('attn'      ,					'attention.attention'    )
     if "norm1" in name:
          __UpperCamelCase   							=name.replace('norm1'      ,					'layernorm_before'    )
     if "norm2" in name:
          __UpperCamelCase   							=name.replace('norm2'      ,					'layernorm_after'    )
     if "mlp.fc1" in name:
          __UpperCamelCase   							=name.replace('mlp.fc1'      ,					'intermediate.dense'    )
     if "mlp.fc2" in name:
          __UpperCamelCase   							=name.replace('mlp.fc2'      ,					'output.dense'    )
     if "decoder_embed" in name:
          __UpperCamelCase   							=name.replace('decoder_embed'      ,					'decoder.decoder_embed'    )
     if "decoder_norm" in name:
          __UpperCamelCase   							=name.replace('decoder_norm'      ,					'decoder.decoder_norm'    )
     if "decoder_pred" in name:
          __UpperCamelCase   							=name.replace('decoder_pred'      ,					'decoder.decoder_pred'    )
     if "norm.weight" in name and "decoder" not in name and "fc" not in name:
          __UpperCamelCase   							=name.replace('norm.weight'      ,					'videomae.layernorm.weight'    )
     if "norm.bias" in name and "decoder" not in name and "fc" not in name:
          __UpperCamelCase   							=name.replace('norm.bias'      ,					'videomae.layernorm.bias'    )
     if "head" in name and "decoder" not in name:
          __UpperCamelCase   							=name.replace('head'      ,					'classifier'    )

     return name

def 						_UpperCAmelCase      (      SCREAMING_SNAKE_CASE__      : Any      ,					SCREAMING_SNAKE_CASE__      : Dict    ):
     for key in orig_state_dict.copy().keys():
          __UpperCamelCase   							=orig_state_dict.pop(SCREAMING_SNAKE_CASE__    )

          if key.startswith('encoder.'    ):
               __UpperCamelCase   							=key.replace('encoder.'      ,					''    )

          if "qkv" in key:
               __UpperCamelCase   							=key.split('.'    )
               if key.startswith('decoder.blocks'    ):
                    __UpperCamelCase   							=config.decoder_hidden_size
                    __UpperCamelCase   							=int(key_split[2]    )
                    __UpperCamelCase   							='decoder.decoder_layers.'
                    if "weight" in key:
                         __UpperCamelCase   							=val[:dim, :]
                         __UpperCamelCase   							=val[dim : dim * 2, :]
                         __UpperCamelCase   							=val[-dim:, :]
               else:
                    __UpperCamelCase   							=config.hidden_size
                    __UpperCamelCase   							=int(key_split[1]    )
                    __UpperCamelCase   							='videomae.encoder.layer.'
                    if "weight" in key:
                         __UpperCamelCase   							=val[:dim, :]
                         __UpperCamelCase   							=val[dim : dim * 2, :]
                         __UpperCamelCase   							=val[-dim:, :]
          else:
               __UpperCamelCase   							=val

     return orig_state_dict

def 						_UpperCAmelCase      (      ):
     __UpperCamelCase   							=hf_hub_download(
         repo_id='hf-internal-testing/spaghetti-video'      ,					filename='eating_spaghetti.npy'      ,					repo_type='dataset'    )
     __UpperCamelCase   							=np.load(SCREAMING_SNAKE_CASE__    )
     return list(SCREAMING_SNAKE_CASE__    )

def 						_UpperCAmelCase      (      SCREAMING_SNAKE_CASE__      : str      ,					SCREAMING_SNAKE_CASE__      : Optional[int]      ,					SCREAMING_SNAKE_CASE__      : int      ,					SCREAMING_SNAKE_CASE__      : Tuple    ):
     __UpperCamelCase   							=get_videomae_config(SCREAMING_SNAKE_CASE__    )

     if "finetuned" in model_name:
          __UpperCamelCase   							=VideoMAEForVideoClassification(SCREAMING_SNAKE_CASE__    )
     else:
          __UpperCamelCase   							=VideoMAEForPreTraining(SCREAMING_SNAKE_CASE__    )

     # download original checkpoint, hosted on Google Drive
     __UpperCamelCase   							='pytorch_model.bin'
     gdown.cached_download(SCREAMING_SNAKE_CASE__      ,					SCREAMING_SNAKE_CASE__      ,					quiet=SCREAMING_SNAKE_CASE__    )
     __UpperCamelCase   							=torch.load(SCREAMING_SNAKE_CASE__      ,					map_location='cpu'    )
     if "model" in files:
          __UpperCamelCase   							=files['model']
     else:
          __UpperCamelCase   							=files['module']
     __UpperCamelCase   							=convert_state_dict(SCREAMING_SNAKE_CASE__      ,					SCREAMING_SNAKE_CASE__    )

     model.load_state_dict(SCREAMING_SNAKE_CASE__    )
     model.eval()

     # verify model on basic input
     __UpperCamelCase   							=VideoMAEImageProcessor(image_mean=[0.5, 0.5, 0.5]      ,					image_std=[0.5, 0.5, 0.5]    )
     __UpperCamelCase   							=prepare_video()
     __UpperCamelCase   							=image_processor(SCREAMING_SNAKE_CASE__      ,					return_tensors='pt'    )

     if "finetuned" not in model_name:
          __UpperCamelCase   							=hf_hub_download(repo_id='hf-internal-testing/bool-masked-pos'      ,					filename='bool_masked_pos.pt'    )
          __UpperCamelCase   							=torch.load(SCREAMING_SNAKE_CASE__    )

     __UpperCamelCase   							=model(**SCREAMING_SNAKE_CASE__    )
     __UpperCamelCase   							=outputs.logits

     __UpperCamelCase   							=[
         'videomae-small-finetuned-kinetics',
         'videomae-small-finetuned-ssv2',
         # Kinetics-400 checkpoints (short = pretrained only for 800 epochs instead of 1600)
         'videomae-base-short',
         'videomae-base-short-finetuned-kinetics',
         'videomae-base',
         'videomae-base-finetuned-kinetics',
         'videomae-large',
         'videomae-large-finetuned-kinetics',
         'videomae-huge-finetuned-kinetics',
         # Something-Something-v2 checkpoints (short = pretrained only for 800 epochs instead of 2400)
         'videomae-base-short-ssv2',
         'videomae-base-short-finetuned-ssv2',
         'videomae-base-ssv2',
         'videomae-base-finetuned-ssv2',
     ]

     # NOTE: logits were tested with image_mean and image_std equal to [0.5, 0.5, 0.5] and [0.5, 0.5, 0.5]
     if model_name == "videomae-small-finetuned-kinetics":
          __UpperCamelCase   							=torch.Size([1, 4_00]    )
          __UpperCamelCase   							=torch.tensor([-0.9291, -0.4061, -0.9307]    )
     elif model_name == "videomae-small-finetuned-ssv2":
          __UpperCamelCase   							=torch.Size([1, 1_74]    )
          __UpperCamelCase   							=torch.tensor([0.2671, -0.4689, -0.8235]    )
     elif model_name == "videomae-base":
          __UpperCamelCase   							=torch.Size([1, 14_08, 15_36]    )
          __UpperCamelCase   							=torch.tensor([[0.7739, 0.7968, 0.7089], [0.6701, 0.7487, 0.6209], [0.4287, 0.5158, 0.4773]]    )
     elif model_name == "videomae-base-short":
          __UpperCamelCase   							=torch.Size([1, 14_08, 15_36]    )
          __UpperCamelCase   							=torch.tensor([[0.7994, 0.9612, 0.8508], [0.7401, 0.8958, 0.8302], [0.5862, 0.7468, 0.7325]]    )
          # we verified the loss both for normalized and unnormalized targets for this one
          __UpperCamelCase   							=torch.tensor([0.5142]    ) if config.norm_pix_loss else torch.tensor([0.6469]    )
     elif model_name == "videomae-large":
          __UpperCamelCase   							=torch.Size([1, 14_08, 15_36]    )
          __UpperCamelCase   							=torch.tensor([[0.7149, 0.7997, 0.6966], [0.6768, 0.7869, 0.6948], [0.5139, 0.6221, 0.5605]]    )
     elif model_name == "videomae-large-finetuned-kinetics":
          __UpperCamelCase   							=torch.Size([1, 4_00]    )
          __UpperCamelCase   							=torch.tensor([0.0771, 0.0011, -0.3625]    )
     elif model_name == "videomae-huge-finetuned-kinetics":
          __UpperCamelCase   							=torch.Size([1, 4_00]    )
          __UpperCamelCase   							=torch.tensor([0.2433, 0.1632, -0.4894]    )
     elif model_name == "videomae-base-short-finetuned-kinetics":
          __UpperCamelCase   							=torch.Size([1, 4_00]    )
          __UpperCamelCase   							=torch.tensor([0.6588, 0.0990, -0.2493]    )
     elif model_name == "videomae-base-finetuned-kinetics":
          __UpperCamelCase   							=torch.Size([1, 4_00]    )
          __UpperCamelCase   							=torch.tensor([0.3669, -0.0688, -0.2421]    )
     elif model_name == "videomae-base-short-ssv2":
          __UpperCamelCase   							=torch.Size([1, 14_08, 15_36]    )
          __UpperCamelCase   							=torch.tensor([[0.4712, 0.5296, 0.5786], [0.2278, 0.2729, 0.4026], [0.0352, 0.0730, 0.2506]]    )
     elif model_name == "videomae-base-short-finetuned-ssv2":
          __UpperCamelCase   							=torch.Size([1, 1_74]    )
          __UpperCamelCase   							=torch.tensor([-0.0537, -0.1539, -0.3266]    )
     elif model_name == "videomae-base-ssv2":
          __UpperCamelCase   							=torch.Size([1, 14_08, 15_36]    )
          __UpperCamelCase   							=torch.tensor([[0.8131, 0.8727, 0.8546], [0.7366, 0.9377, 0.8870], [0.5935, 0.8874, 0.8564]]    )
     elif model_name == "videomae-base-finetuned-ssv2":
          __UpperCamelCase   							=torch.Size([1, 1_74]    )
          __UpperCamelCase   							=torch.tensor([0.1961, -0.8337, -0.6389]    )
     else:
          raise ValueError(F'Model name not supported. Should be one of {model_names}'    )

     # verify logits
     assert logits.shape == expected_shape
     if "finetuned" in model_name:
          assert torch.allclose(logits[0, :3]      ,					SCREAMING_SNAKE_CASE__      ,					atol=1E-4    )
     else:
          print('Logits:'      ,					logits[0, :3, :3]    )
          assert torch.allclose(logits[0, :3, :3]      ,					SCREAMING_SNAKE_CASE__      ,					atol=1E-4    )
     print('Logits ok!'    )

     # verify loss, if applicable
     if model_name == "videomae-base-short":
          __UpperCamelCase   							=outputs.loss
          assert torch.allclose(SCREAMING_SNAKE_CASE__      ,					SCREAMING_SNAKE_CASE__      ,					atol=1E-4    )
          print('Loss ok!'    )

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

     if push_to_hub:
          print('Pushing to the hub...'    )
          model.push_to_hub(SCREAMING_SNAKE_CASE__      ,					organization='nielsr'    )


if __name__ == "__main__":
   _A			=						argparse.ArgumentParser()
   # Required parameters
   parser.add_argument(
       '--checkpoint_url',
       default='https://drive.google.com/u/1/uc?id=1tEhLyskjb755TJ65ptsrafUG2llSwQE1&amp;export=download&amp;confirm=t&amp;uuid=aa3276eb-fb7e-482a-adec-dc7171df14c4',
       type=str,
       help=(
           'URL of the original PyTorch checkpoint (on Google Drive) you\'d like to convert. Should be a direct'
           ' download link.'
       ),
   )
   parser.add_argument(
       '--pytorch_dump_folder_path',
       default='/Users/nielsrogge/Documents/VideoMAE/Test',
       type=str,
       help='Path to the output PyTorch model directory.',
   )
   parser.add_argument('--model_name', default='videomae-base', type=str, help='Name of the model.')
   parser.add_argument(
       '--push_to_hub', action='store_true', help='Whether or not to push the converted model to the 🤗 hub.'
   )

   _A			=						parser.parse_args()
   convert_videomae_checkpoint(args.checkpoint_url, args.pytorch_dump_folder_path, args.model_name, args.push_to_hub)









import json
from typing import List, Optional, Tuple

from tokenizers import normalizers

from ...tokenization_utils_fast import PreTrainedTokenizerFast
from ...utils import logging
from .tokenization_bert import BertTokenizer


_A			=						logging.get_logger(__name__)

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

_A			=						{
    'vocab_file': {
        'bert-base-uncased': 'https://huggingface.co/bert-base-uncased/resolve/main/vocab.txt',
        'bert-large-uncased': 'https://huggingface.co/bert-large-uncased/resolve/main/vocab.txt',
        'bert-base-cased': 'https://huggingface.co/bert-base-cased/resolve/main/vocab.txt',
        'bert-large-cased': 'https://huggingface.co/bert-large-cased/resolve/main/vocab.txt',
        'bert-base-multilingual-uncased': (
            'https://huggingface.co/bert-base-multilingual-uncased/resolve/main/vocab.txt'
        ),
        'bert-base-multilingual-cased': 'https://huggingface.co/bert-base-multilingual-cased/resolve/main/vocab.txt',
        'bert-base-chinese': 'https://huggingface.co/bert-base-chinese/resolve/main/vocab.txt',
        'bert-base-german-cased': 'https://huggingface.co/bert-base-german-cased/resolve/main/vocab.txt',
        'bert-large-uncased-whole-word-masking': (
            'https://huggingface.co/bert-large-uncased-whole-word-masking/resolve/main/vocab.txt'
        ),
        'bert-large-cased-whole-word-masking': (
            'https://huggingface.co/bert-large-cased-whole-word-masking/resolve/main/vocab.txt'
        ),
        'bert-large-uncased-whole-word-masking-finetuned-squad': (
            'https://huggingface.co/bert-large-uncased-whole-word-masking-finetuned-squad/resolve/main/vocab.txt'
        ),
        'bert-large-cased-whole-word-masking-finetuned-squad': (
            'https://huggingface.co/bert-large-cased-whole-word-masking-finetuned-squad/resolve/main/vocab.txt'
        ),
        'bert-base-cased-finetuned-mrpc': (
            'https://huggingface.co/bert-base-cased-finetuned-mrpc/resolve/main/vocab.txt'
        ),
        'bert-base-german-dbmdz-cased': 'https://huggingface.co/bert-base-german-dbmdz-cased/resolve/main/vocab.txt',
        'bert-base-german-dbmdz-uncased': (
            'https://huggingface.co/bert-base-german-dbmdz-uncased/resolve/main/vocab.txt'
        ),
        'TurkuNLP/bert-base-finnish-cased-v1': (
            'https://huggingface.co/TurkuNLP/bert-base-finnish-cased-v1/resolve/main/vocab.txt'
        ),
        'TurkuNLP/bert-base-finnish-uncased-v1': (
            'https://huggingface.co/TurkuNLP/bert-base-finnish-uncased-v1/resolve/main/vocab.txt'
        ),
        'wietsedv/bert-base-dutch-cased': (
            'https://huggingface.co/wietsedv/bert-base-dutch-cased/resolve/main/vocab.txt'
        ),
    },
    'tokenizer_file': {
        'bert-base-uncased': 'https://huggingface.co/bert-base-uncased/resolve/main/tokenizer.json',
        'bert-large-uncased': 'https://huggingface.co/bert-large-uncased/resolve/main/tokenizer.json',
        'bert-base-cased': 'https://huggingface.co/bert-base-cased/resolve/main/tokenizer.json',
        'bert-large-cased': 'https://huggingface.co/bert-large-cased/resolve/main/tokenizer.json',
        'bert-base-multilingual-uncased': (
            'https://huggingface.co/bert-base-multilingual-uncased/resolve/main/tokenizer.json'
        ),
        'bert-base-multilingual-cased': (
            'https://huggingface.co/bert-base-multilingual-cased/resolve/main/tokenizer.json'
        ),
        'bert-base-chinese': 'https://huggingface.co/bert-base-chinese/resolve/main/tokenizer.json',
        'bert-base-german-cased': 'https://huggingface.co/bert-base-german-cased/resolve/main/tokenizer.json',
        'bert-large-uncased-whole-word-masking': (
            'https://huggingface.co/bert-large-uncased-whole-word-masking/resolve/main/tokenizer.json'
        ),
        'bert-large-cased-whole-word-masking': (
            'https://huggingface.co/bert-large-cased-whole-word-masking/resolve/main/tokenizer.json'
        ),
        'bert-large-uncased-whole-word-masking-finetuned-squad': (
            'https://huggingface.co/bert-large-uncased-whole-word-masking-finetuned-squad/resolve/main/tokenizer.json'
        ),
        'bert-large-cased-whole-word-masking-finetuned-squad': (
            'https://huggingface.co/bert-large-cased-whole-word-masking-finetuned-squad/resolve/main/tokenizer.json'
        ),
        'bert-base-cased-finetuned-mrpc': (
            'https://huggingface.co/bert-base-cased-finetuned-mrpc/resolve/main/tokenizer.json'
        ),
        'bert-base-german-dbmdz-cased': (
            'https://huggingface.co/bert-base-german-dbmdz-cased/resolve/main/tokenizer.json'
        ),
        'bert-base-german-dbmdz-uncased': (
            'https://huggingface.co/bert-base-german-dbmdz-uncased/resolve/main/tokenizer.json'
        ),
        'TurkuNLP/bert-base-finnish-cased-v1': (
            'https://huggingface.co/TurkuNLP/bert-base-finnish-cased-v1/resolve/main/tokenizer.json'
        ),
        'TurkuNLP/bert-base-finnish-uncased-v1': (
            'https://huggingface.co/TurkuNLP/bert-base-finnish-uncased-v1/resolve/main/tokenizer.json'
        ),
        'wietsedv/bert-base-dutch-cased': (
            'https://huggingface.co/wietsedv/bert-base-dutch-cased/resolve/main/tokenizer.json'
        ),
    },
}

_A			=						{
    'bert-base-uncased': 512,
    'bert-large-uncased': 512,
    'bert-base-cased': 512,
    'bert-large-cased': 512,
    'bert-base-multilingual-uncased': 512,
    'bert-base-multilingual-cased': 512,
    'bert-base-chinese': 512,
    'bert-base-german-cased': 512,
    'bert-large-uncased-whole-word-masking': 512,
    'bert-large-cased-whole-word-masking': 512,
    'bert-large-uncased-whole-word-masking-finetuned-squad': 512,
    'bert-large-cased-whole-word-masking-finetuned-squad': 512,
    'bert-base-cased-finetuned-mrpc': 512,
    'bert-base-german-dbmdz-cased': 512,
    'bert-base-german-dbmdz-uncased': 512,
    'TurkuNLP/bert-base-finnish-cased-v1': 512,
    'TurkuNLP/bert-base-finnish-uncased-v1': 512,
    'wietsedv/bert-base-dutch-cased': 512,
}

_A			=						{
    'bert-base-uncased': {'do_lower_case': True},
    'bert-large-uncased': {'do_lower_case': True},
    'bert-base-cased': {'do_lower_case': False},
    'bert-large-cased': {'do_lower_case': False},
    'bert-base-multilingual-uncased': {'do_lower_case': True},
    'bert-base-multilingual-cased': {'do_lower_case': False},
    'bert-base-chinese': {'do_lower_case': False},
    'bert-base-german-cased': {'do_lower_case': False},
    'bert-large-uncased-whole-word-masking': {'do_lower_case': True},
    'bert-large-cased-whole-word-masking': {'do_lower_case': False},
    'bert-large-uncased-whole-word-masking-finetuned-squad': {'do_lower_case': True},
    'bert-large-cased-whole-word-masking-finetuned-squad': {'do_lower_case': False},
    'bert-base-cased-finetuned-mrpc': {'do_lower_case': False},
    'bert-base-german-dbmdz-cased': {'do_lower_case': False},
    'bert-base-german-dbmdz-uncased': {'do_lower_case': True},
    'TurkuNLP/bert-base-finnish-cased-v1': {'do_lower_case': False},
    'TurkuNLP/bert-base-finnish-uncased-v1': {'do_lower_case': True},
    'wietsedv/bert-base-dutch-cased': {'do_lower_case': False},
}






class    UpperCAmelCase__	( A_		):



    """simple docstring"""






    UpperCAmelCase__						:		Any              =  VOCAB_FILES_NAMES
    UpperCAmelCase__						:		List[str]              =  PRETRAINED_VOCAB_FILES_MAP
    UpperCAmelCase__						:		Optional[int]              =  PRETRAINED_INIT_CONFIGURATION
    UpperCAmelCase__						:		List[str]              =  PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
    UpperCAmelCase__						:		Dict              =  BertTokenizer






    def __init__(      self ,       A_=None ,       A_=None ,       A_=True ,       A_="[UNK]" ,       A_="[SEP]" ,       A_="[PAD]" ,       A_="[CLS]" ,       A_="[MASK]" ,       A_=True ,       A_=None ,       **A_ ,       )  ->	Any:
         super().__init__(
             A_ ,       tokenizer_file=A_ ,       do_lower_case=A_ ,       unk_token=A_ ,       sep_token=A_ ,       pad_token=A_ ,       cls_token=A_ ,       mask_token=A_ ,       tokenize_chinese_chars=A_ ,       strip_accents=A_ ,       **A_ ,       )

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

         __UpperCamelCase   							=do_lower_case






    def _a (      self ,       A_ ,       A_=None   )  ->	List[str]:
         __UpperCamelCase   							=[self.cls_token_id] + token_ids_a + [self.sep_token_id]

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

         return output






    def _a (      self ,       A_ ,       A_ = None   )  ->	List[int]:
         __UpperCamelCase   							=[self.sep_token_id]
         __UpperCamelCase   							=[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 _a (      self ,       A_ ,       A_ = None   )  ->	Tuple[str]:
         __UpperCamelCase   							=self._tokenizer.model.save(A_ ,       name=A_   )
         return tuple(A_   )





