
import collections
import inspect
import unittest
from typing import Dict, List, Tuple

from transformers import MaskFormerSwinConfig
from transformers.testing_utils import require_torch, require_torch_multi_gpu, torch_device
from transformers.utils import is_torch_available

from ...test_backbone_common import BackboneTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
   import torch
   from torch import nn

   from transformers import MaskFormerSwinBackbone
   from transformers.models.maskformer import MaskFormerSwinModel






class   UpperCAmelCase		:



   def __init__(self		:					Dict    ,						snake_case__		:					Dict    ,						snake_case__		:					Any=13    ,						snake_case__		:					Any=32    ,						snake_case__		:					Optional[Any]=2    ,						snake_case__		:					Union[str, Any]=3    ,						snake_case__		:					List[Any]=16    ,						snake_case__		:					int=[1, 2, 1]    ,						snake_case__		:					Dict=[2, 2, 4]    ,						snake_case__		:					Dict=2    ,						snake_case__		:					Tuple=2.0    ,						snake_case__		:					Optional[int]=True    ,						snake_case__		:					Union[str, Any]=0.0    ,						snake_case__		:					Any=0.0    ,						snake_case__		:					Union[str, Any]=0.1    ,						snake_case__		:					int="gelu"    ,						snake_case__		:					Optional[int]=False    ,						snake_case__		:					List[Any]=True    ,						snake_case__		:					List[str]=0.02    ,						snake_case__		:					int=1e-5    ,						snake_case__		:					List[str]=True    ,						snake_case__		:					Union[str, Any]=None    ,						snake_case__		:					List[Any]=True    ,						snake_case__		:					Optional[Any]=10    ,						snake_case__		:					Optional[Any]=8    ,						snake_case__		:					Any=["stage1", "stage2", "stage3"]    ,						snake_case__		:					Tuple=[1, 2, 3]    ,						)		->	Union[str, Any]:


          '''simple docstring'''


          snake_case       :   Any							=      parent
          snake_case       :   Optional[int]							=      batch_size
          snake_case       :   Union[str, Any]							=      image_size
          snake_case       :   Dict							=      patch_size
          snake_case       :   Optional[Any]							=      num_channels
          snake_case       :   Union[str, Any]							=      embed_dim
          snake_case       :   int							=      depths
          snake_case       :   List[str]							=      num_heads
          snake_case       :   Union[str, Any]							=      window_size
          snake_case       :   Union[str, Any]							=      mlp_ratio
          snake_case       :   List[Any]							=      qkv_bias
          snake_case       :   List[Any]							=      hidden_dropout_prob
          snake_case       :   Union[str, Any]							=      attention_probs_dropout_prob
          snake_case       :   Union[str, Any]							=      drop_path_rate
          snake_case       :   int							=      hidden_act
          snake_case       :   Optional[int]							=      use_absolute_embeddings
          snake_case       :   int							=      patch_norm
          snake_case       :   Union[str, Any]							=      layer_norm_eps
          snake_case       :   Any							=      initializer_range
          snake_case       :   Optional[Any]							=      is_training
          snake_case       :   Tuple							=      scope
          snake_case       :   Optional[int]							=      use_labels
          snake_case       :   Optional[Any]							=      type_sequence_label_size
          snake_case       :   Union[str, Any]							=      encoder_stride
          snake_case       :   Any							=      out_features
          snake_case       :   Tuple							=      out_indices



   def 				_SCREAMING_SNAKE_CASE   (self		:					Optional[Any] )		->	Dict:


          '''simple docstring'''


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

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

          snake_case       :   Dict							=      self.get_config()

          return config, pixel_values, labels



   def 				_SCREAMING_SNAKE_CASE   (self		:					List[str] )		->	int:


          '''simple docstring'''


          return MaskFormerSwinConfig(
              image_size=self.image_size    ,						patch_size=self.patch_size    ,						num_channels=self.num_channels    ,						embed_dim=self.embed_dim    ,						depths=self.depths    ,						num_heads=self.num_heads    ,						window_size=self.window_size    ,						mlp_ratio=self.mlp_ratio    ,						qkv_bias=self.qkv_bias    ,						hidden_dropout_prob=self.hidden_dropout_prob    ,						attention_probs_dropout_prob=self.attention_probs_dropout_prob    ,						drop_path_rate=self.drop_path_rate    ,						hidden_act=self.hidden_act    ,						use_absolute_embeddings=self.use_absolute_embeddings    ,						path_norm=self.patch_norm    ,						layer_norm_eps=self.layer_norm_eps    ,						initializer_range=self.initializer_range    ,						encoder_stride=self.encoder_stride    ,						out_features=self.out_features    ,						out_indices=self.out_indices    ,						)



   def 				_SCREAMING_SNAKE_CASE   (self		:					Tuple    ,						snake_case__		:					List[Any]    ,						snake_case__		:					List[str]    ,						snake_case__		:					Tuple )		->	Optional[Any]:


          '''simple docstring'''


          snake_case       :   Union[str, Any]							=      MaskFormerSwinModel(config=snake_case__ )
          model.to(snake_case__ )
          model.eval()
          snake_case       :   List[Any]							=      model(snake_case__ )

          snake_case       :   Dict							=      ((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths ) - 1))
          snake_case       :   int							=      int(config.embed_dim * 2 ** (len(config.depths ) - 1) )

          self.parent.assertEqual(result.last_hidden_state.shape    ,						(self.batch_size, expected_seq_len, expected_dim) )



   def 				_SCREAMING_SNAKE_CASE   (self		:					List[str]    ,						snake_case__		:					Union[str, Any]    ,						snake_case__		:					List[Any]    ,						snake_case__		:					Union[str, Any] )		->	str:


          '''simple docstring'''


          snake_case       :   Optional[int]							=      MaskFormerSwinBackbone(config=snake_case__ )
          model.to(snake_case__ )
          model.eval()
          snake_case       :   List[Any]							=      model(snake_case__ )

          # verify feature maps
          self.parent.assertEqual(len(result.feature_maps )    ,						len(config.out_features ) )
          self.parent.assertListEqual(list(result.feature_maps[0].shape )    ,						[13, 16, 16, 16] )

          # verify channels
          self.parent.assertEqual(len(model.channels )    ,						len(config.out_features ) )
          self.parent.assertListEqual(model.channels    ,						[16, 32, 64] )

          # verify ValueError
          with self.parent.assertRaises(snake_case__ ):
                 snake_case       :   Tuple							=      ["stem"]
                 snake_case       :   List[Any]							=      MaskFormerSwinBackbone(config=snake_case__ )



   def 				_SCREAMING_SNAKE_CASE   (self		:					List[Any] )		->	List[Any]:


          '''simple docstring'''


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






@require_torch
class   UpperCAmelCase		(						A_       ,A_       ,unittest.TestCase ):
   A__					:		List[str]						     =     (
       (
           MaskFormerSwinModel,
           MaskFormerSwinBackbone,
       )
       if is_torch_available()
       else ()
   )
   A__					:		str						     =     {"feature-extraction": MaskFormerSwinModel} if is_torch_available() else {}
   A__					:		Optional[Any]						     =     False
   A__					:		List[Any]						     =     False
   A__					:		List[str]						     =     False
   A__					:		List[str]						     =     False
   A__					:		Union[str, Any]						     =     False



   def 				_SCREAMING_SNAKE_CASE   (self		:					Optional[int] )		->	List[str]:


          '''simple docstring'''


          snake_case       :   str							=      MaskFormerSwinModelTester(self )
          snake_case       :   Optional[int]							=      ConfigTester(self    ,						config_class=snake_case__    ,						embed_dim=37 )



   @require_torch_multi_gpu
   @unittest.skip(
       reason=(
           "`MaskFormerSwinModel` outputs `hidden_states_spatial_dimensions` which doesn't work well with"
           " `nn.DataParallel`"
       ) )
   def 				_SCREAMING_SNAKE_CASE   (self		:					str )		->	Optional[Any]:


          '''simple docstring'''


          pass



   def 				_SCREAMING_SNAKE_CASE   (self		:					str )		->	List[str]:


          '''simple docstring'''


          self.create_and_test_config_common_properties()
          self.config_tester.create_and_test_config_to_json_string()
          self.config_tester.create_and_test_config_to_json_file()
          self.config_tester.create_and_test_config_from_and_save_pretrained()
          self.config_tester.create_and_test_config_with_num_labels()
          self.config_tester.check_config_can_be_init_without_params()
          self.config_tester.check_config_arguments_init()



   def 				_SCREAMING_SNAKE_CASE   (self		:					Tuple )		->	List[Any]:


          '''simple docstring'''


          return



   def 				_SCREAMING_SNAKE_CASE   (self		:					Dict )		->	str:


          '''simple docstring'''


          snake_case       :   str							=      self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_model(*snake_case__ )



   def 				_SCREAMING_SNAKE_CASE   (self		:					int )		->	Dict:


          '''simple docstring'''


          snake_case       :   Any							=      self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_backbone(*snake_case__ )



   @unittest.skip("Swin does not use inputs_embeds" )
   def 				_SCREAMING_SNAKE_CASE   (self		:					int )		->	Any:


          '''simple docstring'''


          pass



   @unittest.skip("Swin does not support feedforward chunking" )
   def 				_SCREAMING_SNAKE_CASE   (self		:					List[str] )		->	Dict:


          '''simple docstring'''


          pass



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


          '''simple docstring'''


          snake_case				,					snake_case       :   Any							=      self.model_tester.prepare_config_and_inputs_for_common()

          for model_class in self.all_model_classes:
                 snake_case       :   int							=      model_class(snake_case__ )
                 self.assertIsInstance(model.get_input_embeddings()    ,						(nn.Module) )
                 snake_case       :   List[Any]							=      model.get_output_embeddings()
                 self.assertTrue(x is None or isinstance(snake_case__    ,						nn.Linear ) )



   def 				_SCREAMING_SNAKE_CASE   (self		:					Optional[Any] )		->	Dict:


          '''simple docstring'''


          snake_case				,					snake_case       :   str							=      self.model_tester.prepare_config_and_inputs_for_common()

          for model_class in self.all_model_classes:
                 snake_case       :   str							=      model_class(snake_case__ )
                 snake_case       :   Optional[int]							=      inspect.signature(model.forward )
                 # signature.parameters is an OrderedDict => so arg_names order is deterministic
                 snake_case       :   Optional[Any]							=      [*signature.parameters.keys()]

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



   @unittest.skip(reason="MaskFormerSwin is only used as backbone and doesn't support output_attentions" )
   def 				_SCREAMING_SNAKE_CASE   (self		:					List[Any] )		->	str:


          '''simple docstring'''


          pass



   @unittest.skip(reason="MaskFormerSwin is only used as an internal backbone" )
   def 				_SCREAMING_SNAKE_CASE   (self		:					Tuple )		->	Any:


          '''simple docstring'''


          pass



   def 				_SCREAMING_SNAKE_CASE   (self		:					Optional[Any]    ,						snake_case__		:					List[Any]    ,						snake_case__		:					str    ,						snake_case__		:					List[Any]    ,						snake_case__		:					Tuple )		->	Optional[int]:


          '''simple docstring'''


          snake_case       :   Tuple							=      model_class(snake_case__ )
          model.to(snake_case__ )
          model.eval()

          with torch.no_grad():
                 snake_case       :   Any							=      model(**self._prepare_for_class(snake_case__    ,						snake_case__ ) )

          snake_case       :   int							=      outputs.hidden_states

          snake_case       :   Union[str, Any]							=      getattr(
              self.model_tester    ,						"expected_num_hidden_layers"    ,						len(self.model_tester.depths ) + 1 )
          self.assertEqual(len(snake_case__ )    ,						snake_case__ )

          # Swin has a different seq_length
          snake_case       :   Any							=      (
              config.patch_size
              if isinstance(config.patch_size    ,						collections.abc.Iterable )
              else (config.patch_size, config.patch_size)
          )

          snake_case       :   Tuple							=      (image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0])

          self.assertListEqual(
              list(hidden_states[0].shape[-2:] )    ,						[num_patches, self.model_tester.embed_dim]    ,						)



   def 				_SCREAMING_SNAKE_CASE   (self		:					Dict )		->	Union[str, Any]:


          '''simple docstring'''


          snake_case				,					snake_case       :   List[Any]							=      self.model_tester.prepare_config_and_inputs_for_common()

          snake_case       :   int							=      (
              self.model_tester.image_size
              if isinstance(self.model_tester.image_size    ,						collections.abc.Iterable )
              else (self.model_tester.image_size, self.model_tester.image_size)
          )

          for model_class in self.all_model_classes:
                 snake_case       :   int							=      True
                 self.check_hidden_states_output(snake_case__    ,						snake_case__    ,						snake_case__    ,						snake_case__ )

                 # check that output_hidden_states also work using config
                 del inputs_dict["output_hidden_states"]
                 snake_case       :   Dict							=      True

                 self.check_hidden_states_output(snake_case__    ,						snake_case__    ,						snake_case__    ,						snake_case__ )



   def 				_SCREAMING_SNAKE_CASE   (self		:					int )		->	Any:


          '''simple docstring'''


          snake_case				,					snake_case       :   Union[str, Any]							=      self.model_tester.prepare_config_and_inputs_for_common()
          snake_case       :   Any							=      3

          snake_case       :   List[str]							=      (
              self.model_tester.image_size
              if isinstance(self.model_tester.image_size    ,						collections.abc.Iterable )
              else (self.model_tester.image_size, self.model_tester.image_size)
          )
          snake_case       :   Tuple							=      (
              config.patch_size
              if isinstance(config.patch_size    ,						collections.abc.Iterable )
              else (config.patch_size, config.patch_size)
          )

          snake_case       :   str							=      image_size[0] + patch_size[0] - (image_size[0] % patch_size[0])
          snake_case       :   str							=      image_size[1] + patch_size[1] - (image_size[1] % patch_size[1])

          for model_class in self.all_model_classes:
                 snake_case       :   str							=      True
                 self.check_hidden_states_output(snake_case__    ,						snake_case__    ,						snake_case__    ,						(padded_height, padded_width) )

                 # check that output_hidden_states also work using config
                 del inputs_dict["output_hidden_states"]
                 snake_case       :   Optional[Any]							=      True
                 self.check_hidden_states_output(snake_case__    ,						snake_case__    ,						snake_case__    ,						(padded_height, padded_width) )



   @unittest.skip(reason="MaskFormerSwin doesn't have pretrained checkpoints" )
   def 				_SCREAMING_SNAKE_CASE   (self		:					Optional[int] )		->	str:


          '''simple docstring'''


          pass



   @unittest.skip(reason="This will be fixed once MaskFormerSwin is replaced by native Swin" )
   def 				_SCREAMING_SNAKE_CASE   (self		:					str )		->	int:


          '''simple docstring'''


          pass



   @unittest.skip(reason="This will be fixed once MaskFormerSwin is replaced by native Swin" )
   def 				_SCREAMING_SNAKE_CASE   (self		:					int )		->	str:


          '''simple docstring'''


          pass



   def 				_SCREAMING_SNAKE_CASE   (self		:					Any )		->	Any:


          '''simple docstring'''


          snake_case				,					snake_case       :   List[Any]							=      self.model_tester.prepare_config_and_inputs_for_common()

          def set_nan_tensor_to_zero(snake_case__		:					Union[str, Any] ):
                 snake_case       :   Any							=      0
                 return t

          def check_equivalence(snake_case__		:					Union[str, Any]    ,						snake_case__		:					int    ,						snake_case__		:					List[str]    ,						snake_case__		:					Optional[int]={} ):
                 with torch.no_grad():
                        snake_case       :   Optional[Any]							=      model(**snake_case__    ,						return_dict=snake_case__    ,						**snake_case__ )
                        snake_case       :   Tuple							=      model(**snake_case__    ,						return_dict=snake_case__    ,						**snake_case__ ).to_tuple()

                        def recursive_check(snake_case__		:					List[str]    ,						snake_case__		:					Optional[Any] ):
                               if isinstance(snake_case__    ,						(List, Tuple) ):
                                      for tuple_iterable_value, dict_iterable_value in zip(snake_case__    ,						snake_case__ ):
                                             recursive_check(snake_case__    ,						snake_case__ )
                               elif isinstance(snake_case__    ,						snake_case__ ):
                                      for tuple_iterable_value, dict_iterable_value in zip(
                                          tuple_object.values()    ,						dict_object.values() ):
                                             recursive_check(snake_case__    ,						snake_case__ )
                               elif tuple_object is None:
                                      return
                               else:
                                      self.assertTrue(
                                          torch.allclose(
                                              set_nan_tensor_to_zero(snake_case__ )    ,						set_nan_tensor_to_zero(snake_case__ )    ,						atol=1e-5 )    ,						msg=(
                                              "Tuple and dict output are not equal. Difference:"
                                              f""" {torch.max(torch.abs(tuple_object - dict_object ) )}. Tuple has `nan`:"""
                                              f""" {torch.isnan(snake_case__ ).any()} and `inf`: {torch.isinf(snake_case__ )}. Dict has"""
                                              f""" `nan`: {torch.isnan(snake_case__ ).any()} and `inf`: {torch.isinf(snake_case__ )}."""
                                          )    ,						)

                        recursive_check(snake_case__    ,						snake_case__ )

          for model_class in self.all_model_classes:
                 snake_case       :   Optional[int]							=      model_class(snake_case__ )
                 model.to(snake_case__ )
                 model.eval()

                 snake_case       :   Union[str, Any]							=      self._prepare_for_class(snake_case__    ,						snake_case__ )
                 snake_case       :   Tuple							=      self._prepare_for_class(snake_case__    ,						snake_case__ )
                 check_equivalence(snake_case__    ,						snake_case__    ,						snake_case__ )

                 snake_case       :   Tuple							=      self._prepare_for_class(snake_case__    ,						snake_case__    ,						return_labels=snake_case__ )
                 snake_case       :   Optional[Any]							=      self._prepare_for_class(snake_case__    ,						snake_case__    ,						return_labels=snake_case__ )
                 check_equivalence(snake_case__    ,						snake_case__    ,						snake_case__ )

                 snake_case       :   Dict							=      self._prepare_for_class(snake_case__    ,						snake_case__ )
                 snake_case       :   List[Any]							=      self._prepare_for_class(snake_case__    ,						snake_case__ )
                 check_equivalence(snake_case__    ,						snake_case__    ,						snake_case__    ,						{"output_hidden_states": True} )

                 snake_case       :   Any							=      self._prepare_for_class(snake_case__    ,						snake_case__    ,						return_labels=snake_case__ )
                 snake_case       :   List[str]							=      self._prepare_for_class(snake_case__    ,						snake_case__    ,						return_labels=snake_case__ )
                 check_equivalence(snake_case__    ,						snake_case__    ,						snake_case__    ,						{"output_hidden_states": True} )






@require_torch
class   UpperCAmelCase		(						unittest.TestCase       ,A_ ):
   A__					:		int						     =     (MaskFormerSwinBackbone,) if is_torch_available() else ()
   A__					:		int						     =     MaskFormerSwinConfig



   def 				_SCREAMING_SNAKE_CASE   (self		:					List[Any] )		->	Any:


          '''simple docstring'''


          snake_case       :   Union[str, Any]							=      MaskFormerSwinModelTester(self )



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


          '''simple docstring'''


          snake_case				,					snake_case       :   Dict							=      self.model_tester.prepare_config_and_inputs_for_common()
          snake_case       :   Optional[int]							=      inputs_dict["pixel_values"].shape[0]

          for backbone_class in self.all_model_classes:
                 snake_case       :   Optional[int]							=      backbone_class(snake_case__ )
                 backbone.to(snake_case__ )
                 backbone.eval()

                 snake_case       :   Union[str, Any]							=      backbone(**snake_case__ )

                 # Test default outputs and verify feature maps
                 self.assertIsInstance(outputs.feature_maps    ,						snake_case__ )
                 self.assertTrue(len(outputs.feature_maps ) == len(backbone.channels ) )
                 for feature_map, n_channels in zip(outputs.feature_maps    ,						backbone.channels ):
                        self.assertTrue(feature_map.shape[:2]    ,						(batch_size, n_channels) )
                 self.assertIsNone(outputs.hidden_states )
                 self.assertIsNone(outputs.attentions )

                 # Test output_hidden_states=True
                 snake_case       :   Optional[int]							=      backbone(**snake_case__    ,						output_hidden_states=snake_case__ )
                 self.assertIsNotNone(outputs.hidden_states )
                 self.assertTrue(len(outputs.hidden_states )    ,						len(backbone.stage_names ) )
                 # We skip the stem layer
                 for hidden_states, n_channels in zip(outputs.hidden_states[1:]    ,						backbone.channels ):
                        for hidden_state in hidden_states:
                               # Hidden states are in the format (batch_size, (height * width), n_channels)
                               snake_case				,					snake_case				,					snake_case       :   Dict							=      hidden_state.shape
                               self.assertTrue((h_batch_size, h_n_channels)    ,						(batch_size, n_channels) )

            # Test output_attentions=True
                 if self.has_attentions:
                        snake_case       :   Optional[Any]							=      backbone(**snake_case__    ,						output_attentions=snake_case__ )
                        self.assertIsNotNone(outputs.attentions )












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


snake_case__					:							List[Any]													=     logging.get_logger(__name__)

snake_case__					:							Union[str, Any]													=     {'vocab_file': 'vocab.txt', 'tokenizer_file': 'tokenizer.json'}

snake_case__					:							int													=     {
    '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'
        ),
    },
}

snake_case__					:							int													=     {
    '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,
}

snake_case__					:							str													=     {
    '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 A_					(			_lowerCamelCase   ):
   lowerCAmelCase__        = VOCAB_FILES_NAMES
   lowerCAmelCase__        = PRETRAINED_VOCAB_FILES_MAP
   lowerCAmelCase__        = PRETRAINED_INIT_CONFIGURATION
   lowerCAmelCase__        = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
   lowerCAmelCase__        = BertTokenizer




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

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

         __A          =				do_lower_case




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





