

import unittest

from transformers import SqueezeBertConfig, is_torch_available
from transformers.testing_utils import require_sentencepiece, require_tokenizers, require_torch, slow, torch_device

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
       import torch

       from transformers import (
           SQUEEZEBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
           SqueezeBertForMaskedLM,
           SqueezeBertForMultipleChoice,
           SqueezeBertForQuestionAnswering,
           SqueezeBertForSequenceClassification,
           SqueezeBertForTokenClassification,
           SqueezeBertModel,
       )







class 						__magic_name__			(							lowerCamelCase__							):

   '''simple docstring'''




   def __init__(				self,    lowercase_,    lowercase_=13,    lowercase_=7,    lowercase_=True,    lowercase_=True,    lowercase_=False,    lowercase_=True,    lowercase_=99,    lowercase_=32,    lowercase_=5,    lowercase_=4,    lowercase_=64,    lowercase_="gelu",    lowercase_=0.1,    lowercase_=0.1,    lowercase_=512,    lowercase_=16,    lowercase_=2,    lowercase_=0.02,    lowercase_=3,    lowercase_=4,    lowercase_=None,    lowercase_=2,    lowercase_=2,    lowercase_=2,    lowercase_=2,    lowercase_=4,    lowercase_=1,    )							->    Any:






     """simple docstring"""






     a__  =parent
     a__  =batch_size
     a__  =seq_length
     a__  =is_training
     a__  =use_input_mask
     a__  =use_token_type_ids
     a__  =use_labels
     a__  =vocab_size
     a__  =hidden_size
     a__  =num_hidden_layers
     a__  =num_attention_heads
     a__  =intermediate_size
     a__  =hidden_act
     a__  =hidden_dropout_prob
     a__  =attention_probs_dropout_prob
     a__  =max_position_embeddings
     a__  =type_vocab_size
     a__  =type_sequence_label_size
     a__  =initializer_range
     a__  =num_labels
     a__  =num_choices
     a__  =scope
     a__  =q_groups
     a__  =k_groups
     a__  =v_groups
     a__  =post_attention_groups
     a__  =intermediate_groups
     a__  =output_groups



   def  _UpperCAmelCase (				self       )							->    str:






     """simple docstring"""






     a__  =ids_tensor([self.batch_size, self.seq_length],    self.vocab_size       )

     a__  =None
     if self.use_input_mask:
       a__  =random_attention_mask([self.batch_size, self.seq_length]       )

     a__  =None
     a__  =None
     a__  =None
     if self.use_labels:
       a__  =ids_tensor([self.batch_size],    self.type_sequence_label_size       )
       a__  =ids_tensor([self.batch_size, self.seq_length],    self.num_labels       )
       a__  =ids_tensor([self.batch_size],    self.num_choices       )

     a__  =self.get_config()

     return config, input_ids, input_mask, sequence_labels, token_labels, choice_labels



   def  _UpperCAmelCase (				self       )							->    Optional[int]:






     """simple docstring"""






     return SqueezeBertConfig(
         embedding_size=self.hidden_size,    vocab_size=self.vocab_size,    hidden_size=self.hidden_size,    num_hidden_layers=self.num_hidden_layers,    num_attention_heads=self.num_attention_heads,    intermediate_size=self.intermediate_size,    hidden_act=self.hidden_act,    attention_probs_dropout_prob=self.hidden_dropout_prob,    attention_dropout=self.attention_probs_dropout_prob,    max_position_embeddings=self.max_position_embeddings,    initializer_range=self.initializer_range,    q_groups=self.q_groups,    k_groups=self.k_groups,    v_groups=self.v_groups,    post_attention_groups=self.post_attention_groups,    intermediate_groups=self.intermediate_groups,    output_groups=self.output_groups,    )



   def  _UpperCAmelCase (				self,    lowercase_,    lowercase_,    lowercase_,    lowercase_,    lowercase_,    lowercase_       )							->    Optional[int]:






     """simple docstring"""






     a__  =SqueezeBertModel(config=lowercase_       )
     model.to(lowercase_       )
     model.eval()
     a__  =model(lowercase_,    lowercase_       )
     a__  =model(lowercase_       )
     self.parent.assertEqual(result.last_hidden_state.shape,    (self.batch_size, self.seq_length, self.hidden_size)       )



   def  _UpperCAmelCase (				self,    lowercase_,    lowercase_,    lowercase_,    lowercase_,    lowercase_,    lowercase_       )							->    List[Any]:






     """simple docstring"""






     a__  =SqueezeBertForMaskedLM(config=lowercase_       )
     model.to(lowercase_       )
     model.eval()
     a__  =model(lowercase_,    attention_mask=lowercase_,    labels=lowercase_       )
     self.parent.assertEqual(result.logits.shape,    (self.batch_size, self.seq_length, self.vocab_size)       )



   def  _UpperCAmelCase (				self,    lowercase_,    lowercase_,    lowercase_,    lowercase_,    lowercase_,    lowercase_       )							->    Optional[int]:






     """simple docstring"""






     a__  =SqueezeBertForQuestionAnswering(config=lowercase_       )
     model.to(lowercase_       )
     model.eval()
     a__  =model(
         lowercase_,    attention_mask=lowercase_,    start_positions=lowercase_,    end_positions=lowercase_       )
     self.parent.assertEqual(result.start_logits.shape,    (self.batch_size, self.seq_length)       )
     self.parent.assertEqual(result.end_logits.shape,    (self.batch_size, self.seq_length)       )



   def  _UpperCAmelCase (				self,    lowercase_,    lowercase_,    lowercase_,    lowercase_,    lowercase_,    lowercase_       )							->    Any:






     """simple docstring"""






     a__  =self.num_labels
     a__  =SqueezeBertForSequenceClassification(lowercase_       )
     model.to(lowercase_       )
     model.eval()
     a__  =model(lowercase_,    attention_mask=lowercase_,    labels=lowercase_       )
     self.parent.assertEqual(result.logits.shape,    (self.batch_size, self.num_labels)       )



   def  _UpperCAmelCase (				self,    lowercase_,    lowercase_,    lowercase_,    lowercase_,    lowercase_,    lowercase_       )							->    int:






     """simple docstring"""






     a__  =self.num_labels
     a__  =SqueezeBertForTokenClassification(config=lowercase_       )
     model.to(lowercase_       )
     model.eval()

     a__  =model(lowercase_,    attention_mask=lowercase_,    labels=lowercase_       )
     self.parent.assertEqual(result.logits.shape,    (self.batch_size, self.seq_length, self.num_labels)       )



   def  _UpperCAmelCase (				self,    lowercase_,    lowercase_,    lowercase_,    lowercase_,    lowercase_,    lowercase_       )							->    List[Any]:






     """simple docstring"""






     a__  =self.num_choices
     a__  =SqueezeBertForMultipleChoice(config=lowercase_       )
     model.to(lowercase_       )
     model.eval()
     a__  =input_ids.unsqueeze(1       ).expand(-1,    self.num_choices,    -1       ).contiguous()
     a__  =input_mask.unsqueeze(1       ).expand(-1,    self.num_choices,    -1       ).contiguous()
     a__  =model(
         lowercase_,    attention_mask=lowercase_,    labels=lowercase_,    )
     self.parent.assertEqual(result.logits.shape,    (self.batch_size, self.num_choices)       )



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






     """simple docstring"""






     a__  =self.prepare_config_and_inputs()
     ((a__),      (a__),      (a__),      (a__),      (a__),      (a__))  =config_and_inputs
     a__  ={'''input_ids''': input_ids, '''attention_mask''': input_mask}
     return config, inputs_dict







@require_torch
class 						__magic_name__			(							lowerCamelCase__		,       lowerCamelCase__		,       unittest.TestCase							):

   '''simple docstring'''




   lowerCamelCase__ :	Any    =   (
       (
           SqueezeBertModel,
           SqueezeBertForMaskedLM,
           SqueezeBertForMultipleChoice,
           SqueezeBertForQuestionAnswering,
           SqueezeBertForSequenceClassification,
           SqueezeBertForTokenClassification,
       )
       if is_torch_available()
       else None
   )
   lowerCamelCase__ :	Union[str, Any]    =   (
       {
           'feature-extraction': SqueezeBertModel,
           'fill-mask': SqueezeBertForMaskedLM,
           'question-answering': SqueezeBertForQuestionAnswering,
           'text-classification': SqueezeBertForSequenceClassification,
           'token-classification': SqueezeBertForTokenClassification,
           'zero-shot': SqueezeBertForSequenceClassification,
       }
       if is_torch_available()
       else {}
   )
   lowerCamelCase__ :	Optional[Any]    =   False
   lowerCamelCase__ :	Dict    =   True
   lowerCamelCase__ :	Optional[int]    =   False



   def  _UpperCAmelCase (				self       )							->    Optional[Any]:






     """simple docstring"""






     a__  =SqueezeBertModelTester(self       )
     a__  =ConfigTester(self,    config_class=lowercase_,    dim=37       )



   def  _UpperCAmelCase (				self       )							->    Tuple:






     """simple docstring"""






     self.config_tester.run_common_tests()



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






     """simple docstring"""






     a__  =self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_squeezebert_model(*lowercase_       )



   def  _UpperCAmelCase (				self       )							->    Any:






     """simple docstring"""






     a__  =self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_squeezebert_for_masked_lm(*lowercase_       )



   def  _UpperCAmelCase (				self       )							->    Tuple:






     """simple docstring"""






     a__  =self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_squeezebert_for_question_answering(*lowercase_       )



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






     """simple docstring"""






     a__  =self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_squeezebert_for_sequence_classification(*lowercase_       )



   def  _UpperCAmelCase (				self       )							->    str:






     """simple docstring"""






     a__  =self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_squeezebert_for_token_classification(*lowercase_       )



   def  _UpperCAmelCase (				self       )							->    str:






     """simple docstring"""






     a__  =self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_squeezebert_for_multiple_choice(*lowercase_       )



   @slow
   def  _UpperCAmelCase (				self       )							->    Optional[int]:






     """simple docstring"""






     for model_name in SQUEEZEBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
       a__  =SqueezeBertModel.from_pretrained(lowercase_       )
       self.assertIsNotNone(lowercase_       )







@require_sentencepiece
@require_tokenizers
@require_torch
class 						__magic_name__			(							unittest.TestCase							):

   '''simple docstring'''




   @slow
   def  _UpperCAmelCase (				self       )							->    int:






     """simple docstring"""






     a__  =SqueezeBertForSequenceClassification.from_pretrained('''squeezebert/squeezebert-mnli'''       )

     a__  =torch.tensor([[1, 29414, 232, 328, 740, 1140, 12695, 69, 13, 1588, 2]]       )
     a__  =model(lowercase_       )[0]
     a__  =torch.Size((1, 3)       )
     self.assertEqual(output.shape,    lowercase_       )
     a__  =torch.tensor([[0.6401, -0.0349, -0.6041]]       )
     self.assertTrue(torch.allclose(lowercase_,    lowercase_,    atol=1E-4       )       )



import os
import string
import sys


lowerCamelCase           =					1 << 8

lowerCamelCase           =					{
    '''tab''': ord('''\t'''),
    '''newline''': ord('''\r'''),
    '''esc''': 27,
    '''up''': 65 + ARROW_KEY_FLAG,
    '''down''': 66 + ARROW_KEY_FLAG,
    '''right''': 67 + ARROW_KEY_FLAG,
    '''left''': 68 + ARROW_KEY_FLAG,
    '''mod_int''': 91,
    '''undefined''': sys.maxsize,
    '''interrupt''': 3,
    '''insert''': 50,
    '''delete''': 51,
    '''pg_up''': 53,
    '''pg_down''': 54,
}

lowerCamelCase           =					KEYMAP['''up''']
lowerCamelCase           =					KEYMAP['''left''']

if sys.platform == "win32":
       lowerCamelCase           =					[]
       lowerCamelCase           =					{
           b'''\xe0H''': KEYMAP['''up'''] - ARROW_KEY_FLAG,
           b'''\x00H''': KEYMAP['''up'''] - ARROW_KEY_FLAG,
           b'''\xe0P''': KEYMAP['''down'''] - ARROW_KEY_FLAG,
           b'''\x00P''': KEYMAP['''down'''] - ARROW_KEY_FLAG,
           b'''\xe0M''': KEYMAP['''right'''] - ARROW_KEY_FLAG,
           b'''\x00M''': KEYMAP['''right'''] - ARROW_KEY_FLAG,
           b'''\xe0K''': KEYMAP['''left'''] - ARROW_KEY_FLAG,
           b'''\x00K''': KEYMAP['''left'''] - ARROW_KEY_FLAG,
       }

for i in range(10):
       lowerCamelCase           =					ord(str(i))




def 			UpperCAmelCase__				(			):





  '''simple docstring'''







  if os.name == "nt":
    import msvcrt

    a__  ='''mbcs'''
    # Flush the keyboard buffer
    while msvcrt.kbhit():
      msvcrt.getch()
    if len(_A							) == 0:
      # Read the keystroke
      a__  =msvcrt.getch()

      # If it is a prefix char, get second part
      if ch in (b"\x00", b"\xe0"):
        a__  =ch + msvcrt.getch()
        # Translate actual Win chars to bullet char types
        try:
          a__  =chr(WIN_KEYMAP[cha]							)
          WIN_CH_BUFFER.append(chr(KEYMAP['''mod_int''']							)							)
          WIN_CH_BUFFER.append(_A							)
          if ord(_A							) in (
              KEYMAP["insert"] - 1 << 9,
              KEYMAP["delete"] - 1 << 9,
              KEYMAP["pg_up"] - 1 << 9,
              KEYMAP["pg_down"] - 1 << 9,
          ):
            WIN_CH_BUFFER.append(chr(1_26							)							)
          a__  =chr(KEYMAP['''esc''']							)
        except KeyError:
          a__  =cha[1]
      else:
        a__  =ch.decode(_A							)
    else:
      a__  =WIN_CH_BUFFER.pop(0							)
  elif os.name == "posix":
    import termios
    import tty

    a__  =sys.stdin.fileno()
    a__  =termios.tcgetattr(_A							)
    try:
      tty.setraw(_A							)
      a__  =sys.stdin.read(1							)
    finally:
      termios.tcsetattr(_A	,      termios.TCSADRAIN	,      _A							)
  return ch




def 			UpperCAmelCase__				(			):





  '''simple docstring'''







  a__  =get_raw_chars()
  if ord(_A							) in [KEYMAP["interrupt"], KEYMAP["newline"]]:
    return char

  elif ord(_A							) == KEYMAP["esc"]:
    a__  =get_raw_chars()
    if ord(_A							) == KEYMAP["mod_int"]:
      a__  =get_raw_chars()
      if ord(_A							) >= KEYMAP["arrow_begin"] - ARROW_KEY_FLAG and ord(_A							) <= KEYMAP["arrow_end"] - ARROW_KEY_FLAG:
        return chr(ord(_A							) + ARROW_KEY_FLAG							)
      else:
        return KEYMAP["undefined"]
    else:
      return get_raw_chars()

  else:
    if char in string.printable:
      return char
    else:
      return KEYMAP["undefined"]
