'''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 	__SCREAMING_SNAKE_CASE		(			lowerCamelCase_			):







  '''simple docstring'''






  lowerCamelCase_						:List[Any]		       =						SqueezeBertTokenizer
  lowerCamelCase_						:Dict		       =						SqueezeBertTokenizerFast
  lowerCamelCase_						:Optional[Any]		       =						True


  def _UpperCamelCase	(					self ,						**snake_case_		):




       '''simple docstring'''

       return SqueezeBertTokenizerFast.from_pretrained(self.tmpdirname ,						**snake_case_		)






  @slow
  def _UpperCamelCase	(					self		):




       '''simple docstring'''

       UpperCAmelCase_				:  Union[str, Any]  = SqueezeBertTokenizer.from_pretrained('squeezebert/squeezebert-mnli-headless'		)

       UpperCAmelCase_				:  Optional[Any]  = tokenizer.encode('sequence builders' ,						add_special_tokens=snake_case_		)
       UpperCAmelCase_				:  int  = tokenizer.encode('multi-sequence build' ,						add_special_tokens=snake_case_		)

       UpperCAmelCase_				:  str  = tokenizer.build_inputs_with_special_tokens(snake_case_		)
       UpperCAmelCase_				:  int  = tokenizer.build_inputs_with_special_tokens(snake_case_ ,						snake_case_		)

       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
       ]







'''simple docstring'''


def    _lowerCamelCase       ( lowerCamelCase_   :				list  ):



     """simple docstring"""





     UpperCAmelCase_				:  Optional[int]  = len(lowerCamelCase_  )

     # Set the gap value to be decreased by a factor of 1.3
     # after each iteration
     UpperCAmelCase_				:  Optional[Any]  = 1.3

     # Continue sorting until the gap is 1
     while gap > 1:
          # Decrease the gap value
          UpperCAmelCase_				:  Optional[Any]  = int(gap / shrink  )

          # Sort the elements using insertion sort
          for i in range(lowerCamelCase_      ,	len(lowerCamelCase_  )  ):
               UpperCAmelCase_				:  Optional[int]  = collection[i]
               UpperCAmelCase_				:  Tuple  = i
               while j >= gap and collection[j - gap] > temp:
                    UpperCAmelCase_				:  Tuple  = collection[j - gap]
                    j -= gap
               UpperCAmelCase_				:  Optional[int]  = temp

     return collection


if __name__ == "__main__":
 import doctest

 doctest.testmod()






