code: 
  import json
  from typing import List, Optional, Tuple
  
  from tokenizers import normalizers
  
  from ...tokenization_utils_fast import PreTrainedTokenizerFast
  from ...utils import logging
  from .tokenization_layoutlm import LayoutLMTokenizer
  
  
  _snake_case			:       Dict      =						logging.get_logger(__name__)
  
  _snake_case			:       Dict      =						{"vocab_file": "vocab.txt", "tokenizer_file": "tokenizer.json"}
  
  _snake_case			:       Optional[int]      =						{
      "vocab_file": {
          "microsoft/layoutlm-base-uncased": (
              "https://huggingface.co/microsoft/layoutlm-base-uncased/resolve/main/vocab.txt"
          ),
          "microsoft/layoutlm-large-uncased": (
              "https://huggingface.co/microsoft/layoutlm-large-uncased/resolve/main/vocab.txt"
          ),
      },
      "tokenizer_file": {
          "microsoft/layoutlm-base-uncased": (
              "https://huggingface.co/microsoft/layoutlm-base-uncased/resolve/main/tokenizer.json"
          ),
          "microsoft/layoutlm-large-uncased": (
              "https://huggingface.co/microsoft/layoutlm-large-uncased/resolve/main/tokenizer.json"
          ),
      },
  }
  
  _snake_case			:       Union[str, Any]      =						{
      "microsoft/layoutlm-base-uncased": 5_12,
      "microsoft/layoutlm-large-uncased": 5_12,
  }
  
  _snake_case			:       Tuple      =						{
      "microsoft/layoutlm-base-uncased": {"do_lower_case": True},
      "microsoft/layoutlm-large-uncased": {"do_lower_case": True},
  }
  
  
  
  
  
  class      UpperCamelCase_			(			__a		):
  
  
  
  
  
  
  
  						'''simple docstring'''
  
  
  
  						UpperCamelCase			:     Union[str, Any]							      =				VOCAB_FILES_NAMES
  						UpperCamelCase			:     Union[str, Any]							      =				PRETRAINED_VOCAB_FILES_MAP
  						UpperCamelCase			:     int							      =				PRETRAINED_INIT_CONFIGURATION
  						UpperCamelCase			:     int							      =				PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
  						UpperCamelCase			:     List[Any]							      =				LayoutLMTokenizer
  
  
  
  
  
  						def __init__( self       :Tuple		,						lowerCAmelCase__       :Dict=None		,						lowerCAmelCase__       :Optional[int]=None		,						lowerCAmelCase__       :Tuple=True		,						lowerCAmelCase__       :Optional[Any]="[UNK]"		,						lowerCAmelCase__       :Optional[Any]="[SEP]"		,						lowerCAmelCase__       :Dict="[PAD]"		,						lowerCAmelCase__       :List[Any]="[CLS]"		,						lowerCAmelCase__       :List[str]="[MASK]"		,						lowerCAmelCase__       :List[str]=True		,						lowerCAmelCase__       :Tuple=None		,						**lowerCAmelCase__       :List[Any]		,						)     ->int:
  										super().__init__(
  										    lowerCAmelCase__		,						tokenizer_file=lowerCAmelCase__		,						do_lower_case=lowerCAmelCase__		,						unk_token=lowerCAmelCase__		,						sep_token=lowerCAmelCase__		,						pad_token=lowerCAmelCase__		,						cls_token=lowerCAmelCase__		,						mask_token=lowerCAmelCase__		,						tokenize_chinese_chars=lowerCAmelCase__		,						strip_accents=lowerCAmelCase__		,						**lowerCAmelCase__		,						)
  
  										lowercase						    =			json.loads(self.backend_tokenizer.normalizer.__getstate__()    )
  										if (
  										    normalizer_state.get("lowercase"		,						lowerCAmelCase__    ) != do_lower_case
  										    or normalizer_state.get("strip_accents"		,						lowerCAmelCase__    ) != strip_accents
  										    or normalizer_state.get("handle_chinese_chars"		,						lowerCAmelCase__    ) != tokenize_chinese_chars
  										):
  														lowercase						    =			getattr(lowerCAmelCase__		,						normalizer_state.pop("type"    )    )
  														lowercase						    =			do_lower_case
  														lowercase						    =			strip_accents
  														lowercase						    =			tokenize_chinese_chars
  														lowercase						    =			normalizer_class(**lowerCAmelCase__    )
  
  										lowercase						    =			do_lower_case
  
  
  
  
  
  						def 					SCREAMING_SNAKE_CASE( self       :List[str]		,						lowerCAmelCase__       :List[str]		,						lowerCAmelCase__       :Dict=None    )     ->List[str]:
  										lowercase						    =			[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 					SCREAMING_SNAKE_CASE( self       :List[Any]		,						lowerCAmelCase__       :List[int]		,						lowerCAmelCase__       :Optional[List[int]] = None    )     ->List[int]:
  										lowercase						    =			[self.sep_token_id]
  										lowercase						    =			[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 					SCREAMING_SNAKE_CASE( self       :Union[str, Any]		,						lowerCAmelCase__       :str		,						lowerCAmelCase__       :Optional[str] = None    )     ->Tuple[str]:
  										lowercase						    =			self._tokenizer.model.save(lowerCAmelCase__		,						name=lowerCAmelCase__    )
  										return tuple(lowerCAmelCase__    )
  
style_context: 
  from ...configuration_utils import PretrainedConfig
  from ...utils import logging
  
  
  _snake_case			:       List[Any]      =						logging.get_logger(__name__)
  
  _snake_case			:       Dict      =						{
      "google/reformer-crime-and-punishment": (
          "https://huggingface.co/google/reformer-crime-and-punishment/resolve/main/config.json"
      ),
      "google/reformer-enwik8": "https://huggingface.co/google/reformer-enwik8/resolve/main/config.json",
  }
  
  
  
  
  
  class      UpperCamelCase_			(			__a		):
  
  
  
  
  
  
  
  						'''simple docstring'''
  
  
  
  						UpperCamelCase			:     Any							      =				'''reformer'''
  						UpperCamelCase			:     List[str]							      =				['''past_buckets_states''']
  						UpperCamelCase			:     Optional[int]							      =				{}
  
  
  
  
  
  						def __init__( self       :Dict		,						lowerCAmelCase__       :Any=64		,						lowerCAmelCase__       :str=["local", "lsh", "local", "lsh", "local", "lsh"]		,						lowerCAmelCase__       :Optional[Any]=1.0		,						lowerCAmelCase__       :List[str]=True		,						lowerCAmelCase__       :Optional[Any]=[64, 64]		,						lowerCAmelCase__       :Tuple=[64, 192]		,						lowerCAmelCase__       :Union[str, Any]=0		,						lowerCAmelCase__       :Optional[Any]=2		,						lowerCAmelCase__       :List[str]=512		,						lowerCAmelCase__       :Any=None		,						lowerCAmelCase__       :int="relu"		,						lowerCAmelCase__       :Tuple=0.05		,						lowerCAmelCase__       :int=256		,						lowerCAmelCase__       :Optional[Any]=0.02		,						lowerCAmelCase__       :Optional[int]=False		,						lowerCAmelCase__       :Optional[Any]=1E-1_2		,						lowerCAmelCase__       :int=1		,						lowerCAmelCase__       :Optional[Any]=0		,						lowerCAmelCase__       :Any=0.05		,						lowerCAmelCase__       :Optional[int]=64		,						lowerCAmelCase__       :List[Any]=64		,						lowerCAmelCase__       :Tuple=0.0		,						lowerCAmelCase__       :Tuple=1		,						lowerCAmelCase__       :List[str]=0		,						lowerCAmelCase__       :Dict=4096		,						lowerCAmelCase__       :Tuple=12		,						lowerCAmelCase__       :Tuple=None		,						lowerCAmelCase__       :Union[str, Any]=1		,						lowerCAmelCase__       :int=0		,						lowerCAmelCase__       :Optional[Any]=320		,						lowerCAmelCase__       :Optional[Any]=False		,						lowerCAmelCase__       :Optional[int]=True		,						lowerCAmelCase__       :str=None		,						**lowerCAmelCase__       :Any		,						)     ->Any:
  										lowercase						    =			hash_seed
  										lowercase						    =			vocab_size
  										lowercase						    =			attention_head_size
  										lowercase						    =			hidden_size
  										lowercase						    =			num_attention_heads
  										lowercase						    =			num_hashes
  										lowercase						    =			len(lowerCAmelCase__    )
  										lowercase						    =			tuple(lowerCAmelCase__    ) if isinstance(lowerCAmelCase__		,						lowerCAmelCase__    ) else num_buckets
  										lowercase						    =			lsh_attn_chunk_length
  										lowercase						    =			local_attn_chunk_length
  										lowercase						    =			lsh_num_chunks_after
  										lowercase						    =			lsh_num_chunks_before
  										lowercase						    =			local_num_chunks_after
  										lowercase						    =			local_num_chunks_before
  										lowercase						    =			hidden_act
  										lowercase						    =			feed_forward_size
  										lowercase						    =			hidden_dropout_prob
  										lowercase						    =			lsh_attention_probs_dropout_prob
  										lowercase						    =			local_attention_probs_dropout_prob
  										lowercase						    =			max_position_embeddings
  										lowercase						    =			initializer_range
  										lowercase						    =			layer_norm_eps
  										lowercase						    =			axial_pos_embds
  										lowercase						    =			tuple(lowerCAmelCase__    )
  										lowercase						    =			tuple(lowerCAmelCase__    )
  										lowercase						    =			axial_norm_std
  										lowercase						    =			chunk_size_lm_head
  										lowercase						    =			attn_layers
  										lowercase						    =			use_cache
  										lowercase						    =			classifier_dropout
  										super().__init__(
  										    pad_token_id=lowerCAmelCase__		,						eos_token_id=lowerCAmelCase__		,						is_decoder=lowerCAmelCase__		,						tie_word_embeddings=lowerCAmelCase__		,						**lowerCAmelCase__		,						)
  