code: 
  
  
  '''simple docstring'''
  
  from .hash_table import HashTable
  from .number_theory.prime_numbers import is_prime, next_prime
  
  
  
  
  
  
  
  class  UpperCAmelCase (       SCREAMING_SNAKE_CASE__):
  
   def __init__( self :	Dict,					*a_ :	int,					**a_ :	Union[str, Any]					):
  
  
  
  
  
      """simple docstring"""
  
  
  
      super().__init__(*a_,					**a_					)
  
   def 		lowercase_						( self :	List[Any],					a_ :	Optional[Any],					a_ :	str					):
  
  
  
  
  
      """simple docstring"""
  
  
  
      UpperCamelCase__ 						=						(
          next_prime(value % self.size_table					)
          if not is_prime(value % self.size_table					)
          else value % self.size_table
      )  # gt = bigger than
      return next_prime_gt - (data % next_prime_gt)
  
   def 		lowercase_						( self :	List[Any],					a_ :	Tuple,					a_ :	Union[str, Any],					a_ :	List[str]					):
  
  
  
  
  
      """simple docstring"""
  
  
  
      return (increment * self.__hash_function_a(a_,					a_					)) % self.size_table
  
   def 		lowercase_						( self :	Tuple,					a_ :	str,					a_ :	List[str]=None					):
  
  
  
  
  
      """simple docstring"""
  
  
  
      UpperCamelCase__ 						=						1
      UpperCamelCase__ 						=						self.hash_function(a_					)
  
      while self.values[new_key] is not None and self.values[new_key] != key:
         UpperCamelCase__ 						=						(
             self.__hash_double_function(a_,					a_,					a_					)
             if self.balanced_factor() >= self.lim_charge
             else None
         )
         if new_key is None:
            break
         else:
            i += 1
  
      return new_key
style_context: 
  
  
  '''simple docstring'''
  
  from transformers import SqueezeBertTokenizer, SqueezeBertTokenizerFast
  from transformers.testing_utils import require_tokenizers, slow
  
  from ..bert.test_tokenization_bert import BertTokenizationTest
  
  
  
  
  
  
  
  @require_tokenizers
  class  UpperCAmelCase (       SCREAMING_SNAKE_CASE__):
   _lowerCamelCase :					Optional[int]    					=					SqueezeBertTokenizer
   _lowerCamelCase :					List[Any]    					=					SqueezeBertTokenizerFast
   _lowerCamelCase :					int    					=					True
  
   def 		lowercase_						( self :	List[str],					**a_ :	str					):
  
  
  
  
  
      """simple docstring"""
  
  
  
      return SqueezeBertTokenizerFast.from_pretrained(self.tmpdirname,					**a_					)
  
   @slow
   def 		lowercase_						( self :	int					):
  
  
  
  
  
      """simple docstring"""
  
  
  
      UpperCamelCase__ 						=						SqueezeBertTokenizer.from_pretrained("squeezebert/squeezebert-mnli-headless"					)
  
      UpperCamelCase__ 						=						tokenizer.encode("sequence builders",					add_special_tokens=a_					)
      UpperCamelCase__ 						=						tokenizer.encode("multi-sequence build",					add_special_tokens=a_					)
  
      UpperCamelCase__ 						=						tokenizer.build_inputs_with_special_tokens(a_					)
      UpperCamelCase__ 						=						tokenizer.build_inputs_with_special_tokens(a_,					a_					)
  
      assert encoded_sentence == [tokenizer.cls_token_id] + text + [tokenizer.sep_token_id]
      assert encoded_pair == [tokenizer.cls_token_id] + text + [tokenizer.sep_token_id] + text_a + [
          tokenizer.sep_token_id
      ]