
from __future__ import annotations

import copy
import inspect
import json
import math
import os
import tempfile
import unittest
from importlib import import_module

import numpy as np

from transformers import ViTMAEConfig
from transformers.file_utils import cached_property, is_tf_available, is_vision_available
from transformers.testing_utils import require_tf, require_vision, slow

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
			import tensorflow as tf

			from transformers import TFViTMAEForPreTraining, TFViTMAEModel


if is_vision_available():
			from PIL import Image

			from transformers import ViTImageProcessor







class 					lowerCamelCase		:





					def __init__(self				:   List[str]    ,   _A				:   Tuple    ,   _A				:   Union[str, Any]=1_3    ,   _A				:   int=3_0    ,   _A				:   Dict=2    ,   _A				:   Dict=3    ,   _A				:   Union[str, Any]=True    ,   _A				:   Optional[int]=True    ,   _A				:   List[str]=3_2    ,   _A				:   Any=2    ,   _A				:   int=4    ,   _A				:   List[Any]=3_7    ,   _A				:   int="gelu"    ,   _A				:   Dict=0.1    ,   _A				:   Optional[int]=0.1    ,   _A				:   Optional[Any]=1_0    ,   _A				:   Any=0.02    ,   _A				:   int=3    ,   _A				:   str=0.6    ,   _A				:   Optional[int]=None    ,   )						->						str:
									snake_case								= parent
									snake_case								= batch_size
									snake_case								= image_size
									snake_case								= patch_size
									snake_case								= num_channels
									snake_case								= is_training
									snake_case								= use_labels
									snake_case								= hidden_size
									snake_case								= num_hidden_layers
									snake_case								= num_attention_heads
									snake_case								= intermediate_size
									snake_case								= hidden_act
									snake_case								= hidden_dropout_prob
									snake_case								= attention_probs_dropout_prob
									snake_case								= type_sequence_label_size
									snake_case								= initializer_range
									snake_case								= mask_ratio
									snake_case								= scope

									# in ViTMAE, the expected sequence length = (num_patches + 1) * (1 - config.mask_ratio), rounded above
									# (we add 1 for the [CLS] token)
									snake_case								= (image_size // patch_size) ** 2
									snake_case								= int(math.ceil((1 - mask_ratio) * (num_patches + 1)       )       )





					def 		UpperCAmelCase(self				:   Any       )						->						Optional[Any]:
									snake_case								= floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]       )

									snake_case								= None
									if self.use_labels:
													snake_case								= ids_tensor([self.batch_size]    ,   self.type_sequence_label_size       )

									snake_case								= self.get_config()

									return config, pixel_values, labels





					def 		UpperCAmelCase(self				:   Tuple       )						->						str:
									return ViTMAEConfig(
									    image_size=self.image_size    ,   patch_size=self.patch_size    ,   num_channels=self.num_channels    ,   hidden_size=self.hidden_size    ,   num_hidden_layers=self.num_hidden_layers    ,   num_attention_heads=self.num_attention_heads    ,   intermediate_size=self.intermediate_size    ,   decoder_hidden_size=self.hidden_size    ,   decoder_num_hidden_layers=self.num_hidden_layers    ,   decoder_num_attention_heads=self.num_attention_heads    ,   decoder_intermediate_size=self.intermediate_size    ,   hidden_act=self.hidden_act    ,   hidden_dropout_prob=self.hidden_dropout_prob    ,   attention_probs_dropout_prob=self.attention_probs_dropout_prob    ,   is_decoder=_A    ,   initializer_range=self.initializer_range    ,   mask_ratio=self.mask_ratio    ,   )





					def 		UpperCAmelCase(self				:   Any    ,   _A				:   Optional[Any]    ,   _A				:   str    ,   _A				:   str       )						->						Union[str, Any]:
									snake_case								= TFViTMAEModel(config=_A       )
									snake_case								= model(_A    ,   training=_A       )
									self.parent.assertEqual(result.last_hidden_state.shape    ,   (self.batch_size, self.seq_length, self.hidden_size)       )





					def 		UpperCAmelCase(self				:   Any    ,   _A				:   Optional[int]    ,   _A				:   int    ,   _A				:   str       )						->						Any:
									snake_case								= TFViTMAEForPreTraining(_A       )
									snake_case								= model(_A    ,   training=_A       )
									# expected sequence length = num_patches
									snake_case								= (self.image_size // self.patch_size) ** 2
									snake_case								= self.patch_size**2 * self.num_channels
									self.parent.assertEqual(result.logits.shape    ,   (self.batch_size, num_patches, expected_num_channels)       )

									# test greyscale images
									snake_case								= 1
									snake_case								= TFViTMAEForPreTraining(_A       )

									snake_case								= floats_tensor([self.batch_size, 1, self.image_size, self.image_size]       )
									snake_case								= model(_A    ,   training=_A       )
									snake_case								= self.patch_size**2
									self.parent.assertEqual(result.logits.shape    ,   (self.batch_size, num_patches, expected_num_channels)       )





					def 		UpperCAmelCase(self				:   int       )						->						Union[str, Any]:
									snake_case								= self.prepare_config_and_inputs()
									((snake_case)					,							(snake_case)					,							(snake_case))								= config_and_inputs
									snake_case								= {"pixel_values": pixel_values}
									return config, inputs_dict







@require_tf
class 					lowerCamelCase		(  A_							,			A_							,			unittest.TestCase  ):
					UpperCAmelCase__    :							Union[str, Any]									=		(TFViTMAEModel, TFViTMAEForPreTraining) if is_tf_available() else ()
					UpperCAmelCase__    :							Tuple									=		{"feature-extraction": TFViTMAEModel} if is_tf_available() else {}

					UpperCAmelCase__    :							List[str]									=		False
					UpperCAmelCase__    :							int									=		False
					UpperCAmelCase__    :							List[Any]									=		False
					UpperCAmelCase__    :							Optional[int]									=		False





					def 		UpperCAmelCase(self				:   str       )						->						List[str]:
									snake_case								= TFViTMAEModelTester(self       )
									snake_case								= ConfigTester(self    ,   config_class=_A    ,   has_text_modality=_A    ,   hidden_size=3_7       )





					def 		UpperCAmelCase(self				:   List[str]       )						->						List[Any]:
									self.config_tester.run_common_tests()





					@unittest.skip(reason="ViTMAE does not use inputs_embeds"       )
					def 		UpperCAmelCase(self				:   Optional[Any]       )						->						Tuple:
									pass





					def 		UpperCAmelCase(self				:   List[Any]       )						->						Dict:
									snake_case					,							snake_case								= self.model_tester.prepare_config_and_inputs_for_common()

									for model_class in self.all_model_classes:
													snake_case								= model_class(_A       )
													self.assertIsInstance(model.get_input_embeddings()    ,   (tf.keras.layers.Layer)       )
													snake_case								= model.get_output_embeddings()
													self.assertTrue(x is None or isinstance(_A    ,   tf.keras.layers.Layer       )       )





					def 		UpperCAmelCase(self				:   Optional[Any]       )						->						Any:
									snake_case					,							snake_case								= self.model_tester.prepare_config_and_inputs_for_common()

									for model_class in self.all_model_classes:
													snake_case								= model_class(_A       )
													snake_case								= inspect.signature(model.call       )
													# signature.parameters is an OrderedDict => so arg_names order is deterministic
													snake_case								= [*signature.parameters.keys()]

													snake_case								= ["pixel_values"]
													self.assertListEqual(arg_names[:1]    ,   _A       )





					def 		UpperCAmelCase(self				:   Union[str, Any]       )						->						int:
									snake_case								= self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_model(*_A       )





					def 		UpperCAmelCase(self				:   Any       )						->						str:
									snake_case								= self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_pretraining(*_A       )





					def 		UpperCAmelCase(self				:   Union[str, Any]       )						->						Dict:
									# make the mask reproducible
									np.random.seed(2       )

									snake_case					,							snake_case								= self.model_tester.prepare_config_and_inputs_for_common()

									snake_case								= int((config.image_size // config.patch_size) ** 2       )
									snake_case								= np.random.uniform(size=(self.model_tester.batch_size, num_patches)       )

									for model_class in self.all_model_classes:
													snake_case								= model_class(_A       )
													snake_case								= self._prepare_for_class(_A    ,   _A       )

													snake_case								= model(_A    ,   noise=_A       )

													snake_case								= copy.deepcopy(self._prepare_for_class(_A    ,   _A       )       )
													snake_case								= model(**_A    ,   noise=_A       )
													snake_case								= outputs_dict[0].numpy()
													snake_case								= outputs_keywords[0].numpy()

													self.assertLess(np.sum(np.abs(output_dict - output_keywords       )       )    ,   1E-6       )





					def 		UpperCAmelCase(self				:   str       )						->						List[Any]:
									# make the mask reproducible
									np.random.seed(2       )

									snake_case					,							snake_case								= self.model_tester.prepare_config_and_inputs_for_common()

									snake_case								= int((config.image_size // config.patch_size) ** 2       )
									snake_case								= np.random.uniform(size=(self.model_tester.batch_size, num_patches)       )

									def prepare_numpy_arrays(_A				:   Tuple       ):
													snake_case								= {}
													for k, v in inputs_dict.items():
																	if tf.is_tensor(_A       ):
																					snake_case								= v.numpy()
																	else:
																					snake_case								= np.array(_A       )

													return inputs_np_dict

									for model_class in self.all_model_classes:
													snake_case								= model_class(_A       )

													snake_case								= self._prepare_for_class(_A    ,   _A       )
													snake_case								= prepare_numpy_arrays(_A       )

													snake_case								= model(_A    ,   noise=_A       )
													snake_case								= model(**_A    ,   noise=_A       )
													self.assert_outputs_same(_A    ,   _A       )





					def 		UpperCAmelCase(self				:   str    ,   _A				:   List[Any]    ,   _A				:   List[str]    ,   _A				:   Optional[int]       )						->						Optional[int]:
									# make masks reproducible
									np.random.seed(2       )

									snake_case								= int((tf_model.config.image_size // tf_model.config.patch_size) ** 2       )
									snake_case								= np.random.uniform(size=(self.model_tester.batch_size, num_patches)       )
									snake_case								= tf.constant(_A       )

									# Add `noise` argument.
									# PT inputs will be prepared in `super().check_pt_tf_models()` with this added `noise` argument
									snake_case								= tf_noise

									super().check_pt_tf_models(_A    ,   _A    ,   _A       )





					def 		UpperCAmelCase(self				:   int       )						->						int:
									# make mask reproducible
									np.random.seed(2       )

									snake_case					,							snake_case								= self.model_tester.prepare_config_and_inputs_for_common()

									snake_case								= {
									    module_member
									    for model_class in self.all_model_classes
									    for module in (import_module(model_class.__module__       ),)
									    for module_member_name in dir(_A       )
									    if module_member_name.endswith("MainLayer"       )
									    # This condition is required, since `modeling_tf_clip.py` has 3 classes whose names end with `MainLayer`.
									    and module_member_name[: -len("MainLayer"       )] == model_class.__name__[: -len("Model"       )]
									    for module_member in (getattr(_A    ,   _A       ),)
									    if isinstance(_A    ,   _A       )
									    and tf.keras.layers.Layer in module_member.__bases__
									    and getattr(_A    ,   "_keras_serializable"    ,   _A       )
									}

									snake_case								= int((config.image_size // config.patch_size) ** 2       )
									snake_case								= np.random.uniform(size=(self.model_tester.batch_size, num_patches)       )
									snake_case								= tf.convert_to_tensor(_A       )
									inputs_dict.update({"noise": noise}       )

									for main_layer_class in tf_main_layer_classes:
													snake_case								= main_layer_class(_A       )

													snake_case								= {
													    name: tf.keras.Input(tensor.shape[1:]    ,   dtype=tensor.dtype       ) for name, tensor in inputs_dict.items()
													}

													snake_case								= tf.keras.Model(_A    ,   outputs=main_layer(_A       )       )
													snake_case								= model(_A       )

													with tempfile.TemporaryDirectory() as tmpdirname:
																	snake_case								= os.path.join(_A    ,   "keras_model.h5"       )
																	model.save(_A       )
																	snake_case								= tf.keras.models.load_model(
																	    _A    ,   custom_objects={main_layer_class.__name__: main_layer_class}       )
																	assert isinstance(_A    ,   tf.keras.Model       )
																	snake_case								= model(_A       )
																	self.assert_outputs_same(_A    ,   _A       )





					@slow
					def 		UpperCAmelCase(self				:   Any       )						->						Optional[int]:
									# make mask reproducible
									np.random.seed(2       )

									snake_case					,							snake_case								= self.model_tester.prepare_config_and_inputs_for_common()

									snake_case								= int((config.image_size // config.patch_size) ** 2       )
									snake_case								= np.random.uniform(size=(self.model_tester.batch_size, num_patches)       )

									for model_class in self.all_model_classes:
													snake_case								= model_class(_A       )
													snake_case								= self._prepare_for_class(_A    ,   _A       )
													snake_case								= model(_A    ,   noise=_A       )

													if model_class.__name__ == "TFViTMAEModel":
																	snake_case								= outputs.last_hidden_state.numpy()
																	snake_case								= 0
													else:
																	snake_case								= outputs.logits.numpy()
																	snake_case								= 0

													with tempfile.TemporaryDirectory() as tmpdirname:
																	model.save_pretrained(_A    ,   saved_model=_A       )
																	snake_case								= model_class.from_pretrained(_A       )
																	snake_case								= model(_A    ,   noise=_A       )

																	if model_class.__name__ == "TFViTMAEModel":
																					snake_case								= after_outputs["last_hidden_state"].numpy()
																					snake_case								= 0
																	else:
																					snake_case								= after_outputs["logits"].numpy()
																					snake_case								= 0

																	snake_case								= np.amax(np.abs(out_a - out_a       )       )
																	self.assertLessEqual(_A    ,   1E-5       )





					def 		UpperCAmelCase(self				:   int       )						->						int:
									# make mask reproducible
									np.random.seed(2       )

									snake_case					,							snake_case								= self.model_tester.prepare_config_and_inputs_for_common()

									snake_case								= int((config.image_size // config.patch_size) ** 2       )
									snake_case								= np.random.uniform(size=(self.model_tester.batch_size, num_patches)       )

									for model_class in self.all_model_classes:
													snake_case								= model_class(_A       )
													snake_case								= self._prepare_for_class(_A    ,   _A       )

													snake_case								= model(_A    ,   noise=_A       )
													snake_case								= model.get_config()
													# make sure that returned config is jsonifiable, which is required by keras
													json.dumps(_A       )
													snake_case								= model_class.from_config(model.get_config()       )
													# make sure it also accepts a normal config
													snake_case								= model_class.from_config(model.config       )
													snake_case								= new_model(_A       )  # Build model
													new_model.set_weights(model.get_weights()       )
													snake_case								= new_model(_A    ,   noise=_A       )

													self.assert_outputs_same(_A    ,   _A       )





					@unittest.skip(
					    reason="ViTMAE returns a random mask + ids_restore in each forward pass. See test_save_load\n    to get deterministic results."       )
					def 		UpperCAmelCase(self				:   Dict       )						->						Any:
									pass





					@unittest.skip(reason="ViTMAE returns a random mask + ids_restore in each forward pass. See test_save_load"       )
					def 		UpperCAmelCase(self				:   int       )						->						List[Any]:
									pass





					@slow
					def 		UpperCAmelCase(self				:   Any       )						->						List[Any]:
									snake_case								= TFViTMAEModel.from_pretrained("google/vit-base-patch16-224"       )
									self.assertIsNotNone(_A       )



def 						lowercase_      (       )							->							Optional[Any]:
				"""simple docstring"""

				snake_case								= Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"		)
				return image







@require_tf
@require_vision
class 					lowerCamelCase		(  unittest.TestCase  ):





					@cached_property
					def 		UpperCAmelCase(self				:   Any       )						->						Union[str, Any]:
									return ViTImageProcessor.from_pretrained("facebook/vit-mae-base"       ) if is_vision_available() else None





					@slow
					def 		UpperCAmelCase(self				:   List[Any]       )						->						List[Any]:
									# make random mask reproducible across the PT and TF model
									np.random.seed(2       )

									snake_case								= TFViTMAEForPreTraining.from_pretrained("facebook/vit-mae-base"       )

									snake_case								= self.default_image_processor
									snake_case								= prepare_img()
									snake_case								= image_processor(images=_A    ,   return_tensors="tf"       )

									# prepare a noise vector that will be also used for testing the TF model
									# (this way we can ensure that the PT and TF models operate on the same inputs)
									snake_case								= ViTMAEConfig()
									snake_case								= int((vit_mae_config.image_size // vit_mae_config.patch_size) ** 2       )
									snake_case								= np.random.uniform(size=(1, num_patches)       )

									# forward pass
									snake_case								= model(**_A    ,   noise=_A       )

									# verify the logits
									snake_case								= tf.convert_to_tensor([1, 1_9_6, 7_6_8]       )
									self.assertEqual(outputs.logits.shape    ,   _A       )

									snake_case								= tf.convert_to_tensor(
									    [[-0.05_48, -1.70_23, -0.93_25], [0.37_21, -0.56_70, -0.22_33], [0.82_35, -1.38_78, -0.35_24]]       )

									tf.debugging.assert_near(outputs.logits[0, :3, :3]    ,   _A    ,   atol=1E-4       )



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": 5_12,
    "bert-large-uncased": 5_12,
    "bert-base-cased": 5_12,
    "bert-large-cased": 5_12,
    "bert-base-multilingual-uncased": 5_12,
    "bert-base-multilingual-cased": 5_12,
    "bert-base-chinese": 5_12,
    "bert-base-german-cased": 5_12,
    "bert-large-uncased-whole-word-masking": 5_12,
    "bert-large-cased-whole-word-masking": 5_12,
    "bert-large-uncased-whole-word-masking-finetuned-squad": 5_12,
    "bert-large-cased-whole-word-masking-finetuned-squad": 5_12,
    "bert-base-cased-finetuned-mrpc": 5_12,
    "bert-base-german-dbmdz-cased": 5_12,
    "bert-base-german-dbmdz-uncased": 5_12,
    "TurkuNLP/bert-base-finnish-cased-v1": 5_12,
    "TurkuNLP/bert-base-finnish-uncased-v1": 5_12,
    "wietsedv/bert-base-dutch-cased": 5_12,
}

_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 					lowerCamelCase		(  A_  ):
     UpperCAmelCase__    :							Optional[Any]									=		VOCAB_FILES_NAMES
     UpperCAmelCase__    :							Union[str, Any]									=		PRETRAINED_VOCAB_FILES_MAP
     UpperCAmelCase__    :							Union[str, Any]									=		PRETRAINED_INIT_CONFIGURATION
     UpperCAmelCase__    :							Any									=		PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
     UpperCAmelCase__    :							int									=		BertTokenizer





     def __init__(self				:   Union[str, Any]    ,   _A				:   Union[str, Any]=None    ,   _A				:   Optional[int]=None    ,   _A				:   List[str]=True    ,   _A				:   List[Any]="[UNK]"    ,   _A				:   Union[str, Any]="[SEP]"    ,   _A				:   List[Any]="[PAD]"    ,   _A				:   List[Any]="[CLS]"    ,   _A				:   Union[str, Any]="[MASK]"    ,   _A				:   int=True    ,   _A				:   Tuple=None    ,   **_A				:   Optional[int]    ,   )						->						int:
         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    ,   )

         snake_case								= 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
         ):
             snake_case								= getattr(_A    ,   normalizer_state.pop("type"       )       )
             snake_case								= do_lower_case
             snake_case								= strip_accents
             snake_case								= tokenize_chinese_chars
             snake_case								= normalizer_class(**_A       )

         snake_case								= do_lower_case





     def 		UpperCAmelCase(self				:   str    ,   _A				:   Union[str, Any]    ,   _A				:   int=None       )						->						Any:
         snake_case								= [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 		UpperCAmelCase(self				:   Optional[Any]    ,   _A				:   List[int]    ,   _A				:   Optional[List[int]] = None       )						->						List[int]:
         snake_case								= [self.sep_token_id]
         snake_case								= [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 		UpperCAmelCase(self				:   Union[str, Any]    ,   _A				:   str    ,   _A				:   Optional[str] = None       )						->						Tuple[str]:
         snake_case								= self._tokenizer.model.save(_A    ,   name=_A       )
         return tuple(_A       )

