



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






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

														_snake_case       =  """mbcs"""
														# Flush the keyboard buffer
														while msvcrt.kbhit():
																					msvcrt.getch()
														if len(SCREAMING_SNAKE_CASE_				) == 0:
																					# Read the keystroke
																					_snake_case       =  msvcrt.getch()

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

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






def  __SCREAMING_SNAKE_CASE				(  ):
							_snake_case       =  get_raw_chars()
							if ord(SCREAMING_SNAKE_CASE_				) in [KEYMAP["interrupt"], KEYMAP["newline"]]:
														return char

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

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

'''simple docstring'''
import unittest

from transformers import DebertaConfig, 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
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
				import torch

				from transformers import (
				    DebertaForMaskedLM,
				    DebertaForQuestionAnswering,
				    DebertaForSequenceClassification,
				    DebertaForTokenClassification,
				    DebertaModel,
				)
				from transformers.models.deberta.modeling_deberta import DEBERTA_PRETRAINED_MODEL_ARCHIVE_LIST


class       _lowerCAmelCase   (   __snake_case				):







							'''simple docstring'''

							def __init__(self  ,  UpperCAmelCase  ,  UpperCAmelCase=13  ,  UpperCAmelCase=7  ,  UpperCAmelCase=True  ,  UpperCAmelCase=True  ,  UpperCAmelCase=True  ,  UpperCAmelCase=True  ,  UpperCAmelCase=99  ,  UpperCAmelCase=32  ,  UpperCAmelCase=5  ,  UpperCAmelCase=4  ,  UpperCAmelCase=37  ,  UpperCAmelCase="gelu"  ,  UpperCAmelCase=0.1  ,  UpperCAmelCase=0.1  ,  UpperCAmelCase=512  ,  UpperCAmelCase=16  ,  UpperCAmelCase=2  ,  UpperCAmelCase=0.02  ,  UpperCAmelCase=False  ,  UpperCAmelCase=True  ,  UpperCAmelCase="None"  ,  UpperCAmelCase=3  ,  UpperCAmelCase=4  ,  UpperCAmelCase=None  ,  )					->       Optional[Any]:
														_snake_case       =  parent
														_snake_case       =  batch_size
														_snake_case       =  seq_length
														_snake_case       =  is_training
														_snake_case       =  use_input_mask
														_snake_case       =  use_token_type_ids
														_snake_case       =  use_labels
														_snake_case       =  vocab_size
														_snake_case       =  hidden_size
														_snake_case       =  num_hidden_layers
														_snake_case       =  num_attention_heads
														_snake_case       =  intermediate_size
														_snake_case       =  hidden_act
														_snake_case       =  hidden_dropout_prob
														_snake_case       =  attention_probs_dropout_prob
														_snake_case       =  max_position_embeddings
														_snake_case       =  type_vocab_size
														_snake_case       =  type_sequence_label_size
														_snake_case       =  initializer_range
														_snake_case       =  num_labels
														_snake_case       =  num_choices
														_snake_case       =  relative_attention
														_snake_case       =  position_biased_input
														_snake_case       =  pos_att_type
														_snake_case       =  scope

							def 	lowercase							(self  )					->       List[Any]:
														_snake_case       =  ids_tensor([self.batch_size, self.seq_length]  ,  self.vocab_size  )

														_snake_case       =  None
														if self.use_input_mask:
																					_snake_case       =  ids_tensor([self.batch_size, self.seq_length]  ,  vocab_size=2  )

														_snake_case       =  None
														if self.use_token_type_ids:
																					_snake_case       =  ids_tensor([self.batch_size, self.seq_length]  ,  self.type_vocab_size  )

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

														_snake_case       =  self.get_config()

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

							def 	lowercase							(self  )					->       int:
														return DebertaConfig(
														    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  ,  hidden_dropout_prob=self.hidden_dropout_prob  ,  attention_probs_dropout_prob=self.attention_probs_dropout_prob  ,  max_position_embeddings=self.max_position_embeddings  ,  type_vocab_size=self.type_vocab_size  ,  initializer_range=self.initializer_range  ,  relative_attention=self.relative_attention  ,  position_biased_input=self.position_biased_input  ,  pos_att_type=self.pos_att_type  ,  )

							def 	lowercase							(self  )					->       int:
														_snake_case       =  self.get_config()
														_snake_case       =  300
														return config

							def 	lowercase							(self  ,  UpperCAmelCase  )					->       Dict:
														self.parent.assertListEqual(list(result.loss.size()  )  ,  []  )

							def 	lowercase							(self  ,  UpperCAmelCase  ,  UpperCAmelCase  ,  UpperCAmelCase  ,  UpperCAmelCase  ,  UpperCAmelCase  ,  UpperCAmelCase  ,  UpperCAmelCase  )					->       Optional[Any]:
														_snake_case       =  DebertaModel(config=UpperCAmelCase  )
														model.to(UpperCAmelCase  )
														model.eval()
														_snake_case       =  model(UpperCAmelCase  ,  attention_mask=UpperCAmelCase  ,  token_type_ids=UpperCAmelCase  )[0]
														_snake_case       =  model(UpperCAmelCase  ,  token_type_ids=UpperCAmelCase  )[0]
														_snake_case       =  model(UpperCAmelCase  )[0]

														self.parent.assertListEqual(list(sequence_output.size()  )  ,  [self.batch_size, self.seq_length, self.hidden_size]  )

							def 	lowercase							(self  ,  UpperCAmelCase  ,  UpperCAmelCase  ,  UpperCAmelCase  ,  UpperCAmelCase  ,  UpperCAmelCase  ,  UpperCAmelCase  ,  UpperCAmelCase  )					->       str:
														_snake_case       =  DebertaForMaskedLM(config=UpperCAmelCase  )
														model.to(UpperCAmelCase  )
														model.eval()
														_snake_case       =  model(UpperCAmelCase  ,  attention_mask=UpperCAmelCase  ,  token_type_ids=UpperCAmelCase  ,  labels=UpperCAmelCase  )

														self.parent.assertEqual(result.logits.shape  ,  (self.batch_size, self.seq_length, self.vocab_size)  )

							def 	lowercase							(self  ,  UpperCAmelCase  ,  UpperCAmelCase  ,  UpperCAmelCase  ,  UpperCAmelCase  ,  UpperCAmelCase  ,  UpperCAmelCase  ,  UpperCAmelCase  )					->       List[str]:
														_snake_case       =  self.num_labels
														_snake_case       =  DebertaForSequenceClassification(UpperCAmelCase  )
														model.to(UpperCAmelCase  )
														model.eval()
														_snake_case       =  model(UpperCAmelCase  ,  attention_mask=UpperCAmelCase  ,  token_type_ids=UpperCAmelCase  ,  labels=UpperCAmelCase  )
														self.parent.assertListEqual(list(result.logits.size()  )  ,  [self.batch_size, self.num_labels]  )
														self.check_loss_output(UpperCAmelCase  )

							def 	lowercase							(self  ,  UpperCAmelCase  ,  UpperCAmelCase  ,  UpperCAmelCase  ,  UpperCAmelCase  ,  UpperCAmelCase  ,  UpperCAmelCase  ,  UpperCAmelCase  )					->       Any:
														_snake_case       =  self.num_labels
														_snake_case       =  DebertaForTokenClassification(config=UpperCAmelCase  )
														model.to(UpperCAmelCase  )
														model.eval()
														_snake_case       =  model(UpperCAmelCase  ,  attention_mask=UpperCAmelCase  ,  token_type_ids=UpperCAmelCase  ,  labels=UpperCAmelCase  )
														self.parent.assertEqual(result.logits.shape  ,  (self.batch_size, self.seq_length, self.num_labels)  )

							def 	lowercase							(self  ,  UpperCAmelCase  ,  UpperCAmelCase  ,  UpperCAmelCase  ,  UpperCAmelCase  ,  UpperCAmelCase  ,  UpperCAmelCase  ,  UpperCAmelCase  )					->       Any:
														_snake_case       =  DebertaForQuestionAnswering(config=UpperCAmelCase  )
														model.to(UpperCAmelCase  )
														model.eval()
														_snake_case       =  model(
														    UpperCAmelCase  ,  attention_mask=UpperCAmelCase  ,  token_type_ids=UpperCAmelCase  ,  start_positions=UpperCAmelCase  ,  end_positions=UpperCAmelCase  ,  )
														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 	lowercase							(self  )					->       Tuple:
														_snake_case       =  self.prepare_config_and_inputs()
														(
														    (
														    _snake_case
														),							(
														    _snake_case
														),							(
														    _snake_case
														),							(
														    _snake_case
														),							(
														    _snake_case
														),							(
														    _snake_case
														),							(
														    _snake_case
														),							
														)       =  config_and_inputs
														_snake_case       =  {"""input_ids""": input_ids, """token_type_ids""": token_type_ids, """attention_mask""": input_mask}
														return config, inputs_dict


@require_torch
class       _lowerCAmelCase   (   __snake_case					,							__snake_case					,							unittest.TestCase				):







							'''simple docstring'''

							lowerCAmelCase_ 						=						(
							    (
							        DebertaModel,
							        DebertaForMaskedLM,
							        DebertaForSequenceClassification,
							        DebertaForTokenClassification,
							        DebertaForQuestionAnswering,
							    )
							    if is_torch_available()
							    else ()
							)
							lowerCAmelCase_ 						=						(
							    {
							        "feature-extraction": DebertaModel,
							        "fill-mask": DebertaForMaskedLM,
							        "question-answering": DebertaForQuestionAnswering,
							        "text-classification": DebertaForSequenceClassification,
							        "token-classification": DebertaForTokenClassification,
							        "zero-shot": DebertaForSequenceClassification,
							    }
							    if is_torch_available()
							    else {}
							)

							lowerCAmelCase_ 						=						True
							lowerCAmelCase_ 						=						False
							lowerCAmelCase_ 						=						False
							lowerCAmelCase_ 						=						False
							lowerCAmelCase_ 						=						False

							def 	lowercase							(self  )					->       Any:
														_snake_case       =  DebertaModelTester(self  )
														_snake_case       =  ConfigTester(self  ,  config_class=UpperCAmelCase  ,  hidden_size=37  )

							def 	lowercase							(self  )					->       List[str]:
														self.config_tester.run_common_tests()

							def 	lowercase							(self  )					->       Tuple:
														_snake_case       =  self.model_tester.prepare_config_and_inputs()
														self.model_tester.create_and_check_deberta_model(*UpperCAmelCase  )

							def 	lowercase							(self  )					->       str:
														_snake_case       =  self.model_tester.prepare_config_and_inputs()
														self.model_tester.create_and_check_deberta_for_sequence_classification(*UpperCAmelCase  )

							def 	lowercase							(self  )					->       int:
														_snake_case       =  self.model_tester.prepare_config_and_inputs()
														self.model_tester.create_and_check_deberta_for_masked_lm(*UpperCAmelCase  )

							def 	lowercase							(self  )					->       Any:
														_snake_case       =  self.model_tester.prepare_config_and_inputs()
														self.model_tester.create_and_check_deberta_for_question_answering(*UpperCAmelCase  )

							def 	lowercase							(self  )					->       str:
														_snake_case       =  self.model_tester.prepare_config_and_inputs()
														self.model_tester.create_and_check_deberta_for_token_classification(*UpperCAmelCase  )





							@slow
							def 	lowercase							(self  )					->       Tuple:
														for model_name in DEBERTA_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																					_snake_case       =  DebertaModel.from_pretrained(UpperCAmelCase  )
																					self.assertIsNotNone(UpperCAmelCase  )


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







							'''simple docstring'''

							@unittest.skip(reason="""Model not available yet"""  )
							def 	lowercase							(self  )					->       Any:
														pass





							@slow
							def 	lowercase							(self  )					->       Dict:
														_snake_case       =  DebertaModel.from_pretrained("""microsoft/deberta-base"""  )

														_snake_case       =  torch.tensor([[0, 31414, 232, 328, 740, 1140, 12695, 69, 46078, 1588, 2]]  )
														_snake_case       =  torch.tensor([[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]  )
														with torch.no_grad():
																					_snake_case       =  model(UpperCAmelCase  ,  attention_mask=UpperCAmelCase  )[0]
														# compare the actual values for a slice.
														_snake_case       =  torch.tensor(
														    [[[-0.5986, -0.8055, -0.8462], [1.4484, -0.9348, -0.8059], [0.3123, 0.0032, -1.4131]]]  )
														self.assertTrue(torch.allclose(output[:, 1:4, 1:4]  ,  UpperCAmelCase  ,  atol=1e-4  )  ,  f"""{output[:, 1:4, 1:4]}"""  )