


"""simple docstring"""
import unittest

from transformers import AutoTokenizer, NystromformerConfig, is_torch_available
from transformers.testing_utils import 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 (
     NystromformerForMaskedLM,
     NystromformerForMultipleChoice,
     NystromformerForQuestionAnswering,
     NystromformerForSequenceClassification,
     NystromformerForTokenClassification,
     NystromformerModel,
 )
 from transformers.models.nystromformer.modeling_nystromformer import NYSTROMFORMER_PRETRAINED_MODEL_ARCHIVE_LIST




class 	lowercase__				:





   def __init__(							self      ,   SCREAMING_SNAKE_CASE      ,   SCREAMING_SNAKE_CASE=13      ,   SCREAMING_SNAKE_CASE=7      ,   SCREAMING_SNAKE_CASE=True      ,   SCREAMING_SNAKE_CASE=True      ,   SCREAMING_SNAKE_CASE=True      ,   SCREAMING_SNAKE_CASE=True      ,   SCREAMING_SNAKE_CASE=99      ,   SCREAMING_SNAKE_CASE=32      ,   SCREAMING_SNAKE_CASE=5      ,   SCREAMING_SNAKE_CASE=4      ,   SCREAMING_SNAKE_CASE=37      ,   SCREAMING_SNAKE_CASE="gelu"      ,   SCREAMING_SNAKE_CASE=0.1      ,   SCREAMING_SNAKE_CASE=0.1      ,   SCREAMING_SNAKE_CASE=512      ,   SCREAMING_SNAKE_CASE=16      ,   SCREAMING_SNAKE_CASE=2      ,   SCREAMING_SNAKE_CASE=0.02      ,   SCREAMING_SNAKE_CASE=3      ,   SCREAMING_SNAKE_CASE=4      ,   SCREAMING_SNAKE_CASE=None      ,   )  ->  List[Any]:
      _lowerCamelCase	:					Union[str, Any]   =		parent
      _lowerCamelCase	:					Optional[Any]   =		batch_size
      _lowerCamelCase	:					Optional[int]   =		seq_length
      _lowerCamelCase	:					Any   =		is_training
      _lowerCamelCase	:					int   =		use_input_mask
      _lowerCamelCase	:					Tuple   =		use_token_type_ids
      _lowerCamelCase	:					List[str]   =		use_labels
      _lowerCamelCase	:					Any   =		vocab_size
      _lowerCamelCase	:					Dict   =		hidden_size
      _lowerCamelCase	:					Any   =		num_hidden_layers
      _lowerCamelCase	:					Dict   =		num_attention_heads
      _lowerCamelCase	:					List[Any]   =		intermediate_size
      _lowerCamelCase	:					str   =		hidden_act
      _lowerCamelCase	:					Tuple   =		hidden_dropout_prob
      _lowerCamelCase	:					List[str]   =		attention_probs_dropout_prob
      _lowerCamelCase	:					Dict   =		max_position_embeddings
      _lowerCamelCase	:					str   =		type_vocab_size
      _lowerCamelCase	:					Any   =		type_sequence_label_size
      _lowerCamelCase	:					List[str]   =		initializer_range
      _lowerCamelCase	:					Optional[Any]   =		num_labels
      _lowerCamelCase	:					List[str]   =		num_choices
      _lowerCamelCase	:					int   =		scope





   def 		UpperCamelCase_  (							self)  ->  int:
      _lowerCamelCase	:					Any   =		ids_tensor([self.batch_size, self.seq_length]      ,   self.vocab_size)

      _lowerCamelCase	:					Union[str, Any]   =		None
      if self.use_input_mask:
         _lowerCamelCase	:					Optional[Any]   =		random_attention_mask([self.batch_size, self.seq_length])

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

      _lowerCamelCase	:					Dict   =		None
      _lowerCamelCase	:					Any   =		None
      _lowerCamelCase	:					List[Any]   =		None
      if self.use_labels:
         _lowerCamelCase	:					List[str]   =		ids_tensor([self.batch_size]      ,   self.type_sequence_label_size)
         _lowerCamelCase	:					List[str]   =		ids_tensor([self.batch_size, self.seq_length]      ,   self.num_labels)
         _lowerCamelCase	:					Dict   =		ids_tensor([self.batch_size]      ,   self.num_choices)

      _lowerCamelCase	:					int   =		self.get_config()

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





   def 		UpperCamelCase_  (							self)  ->  Dict:
      return NystromformerConfig(
          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      ,   is_decoder=SCREAMING_SNAKE_CASE      ,   initializer_range=self.initializer_range      ,   )





   def 		UpperCamelCase_  (							self      ,   SCREAMING_SNAKE_CASE      ,   SCREAMING_SNAKE_CASE      ,   SCREAMING_SNAKE_CASE      ,   SCREAMING_SNAKE_CASE      ,   SCREAMING_SNAKE_CASE      ,   SCREAMING_SNAKE_CASE      ,   SCREAMING_SNAKE_CASE)  ->  List[str]:
      _lowerCamelCase	:					str   =		NystromformerModel(config=SCREAMING_SNAKE_CASE)
      model.to(SCREAMING_SNAKE_CASE)
      model.eval()
      _lowerCamelCase	:					Union[str, Any]   =		model(SCREAMING_SNAKE_CASE      ,   attention_mask=SCREAMING_SNAKE_CASE      ,   token_type_ids=SCREAMING_SNAKE_CASE)
      _lowerCamelCase	:					List[str]   =		model(SCREAMING_SNAKE_CASE      ,   token_type_ids=SCREAMING_SNAKE_CASE)
      _lowerCamelCase	:					List[str]   =		model(SCREAMING_SNAKE_CASE)
      self.parent.assertEqual(result.last_hidden_state.shape      ,   (self.batch_size, self.seq_length, self.hidden_size))





   def 		UpperCamelCase_  (							self      ,   SCREAMING_SNAKE_CASE      ,   SCREAMING_SNAKE_CASE      ,   SCREAMING_SNAKE_CASE      ,   SCREAMING_SNAKE_CASE      ,   SCREAMING_SNAKE_CASE      ,   SCREAMING_SNAKE_CASE      ,   SCREAMING_SNAKE_CASE)  ->  List[Any]:
      _lowerCamelCase	:					Union[str, Any]   =		NystromformerForMaskedLM(config=SCREAMING_SNAKE_CASE)
      model.to(SCREAMING_SNAKE_CASE)
      model.eval()
      _lowerCamelCase	:					Union[str, Any]   =		model(SCREAMING_SNAKE_CASE      ,   attention_mask=SCREAMING_SNAKE_CASE      ,   token_type_ids=SCREAMING_SNAKE_CASE      ,   labels=SCREAMING_SNAKE_CASE)
      self.parent.assertEqual(result.logits.shape      ,   (self.batch_size, self.seq_length, self.vocab_size))





   def 		UpperCamelCase_  (							self      ,   SCREAMING_SNAKE_CASE      ,   SCREAMING_SNAKE_CASE      ,   SCREAMING_SNAKE_CASE      ,   SCREAMING_SNAKE_CASE      ,   SCREAMING_SNAKE_CASE      ,   SCREAMING_SNAKE_CASE      ,   SCREAMING_SNAKE_CASE)  ->  Any:
      _lowerCamelCase	:					List[str]   =		NystromformerForQuestionAnswering(config=SCREAMING_SNAKE_CASE)
      model.to(SCREAMING_SNAKE_CASE)
      model.eval()
      _lowerCamelCase	:					Dict   =		model(
          SCREAMING_SNAKE_CASE      ,   attention_mask=SCREAMING_SNAKE_CASE      ,   token_type_ids=SCREAMING_SNAKE_CASE      ,   start_positions=SCREAMING_SNAKE_CASE      ,   end_positions=SCREAMING_SNAKE_CASE      ,   )
      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      ,   SCREAMING_SNAKE_CASE      ,   SCREAMING_SNAKE_CASE      ,   SCREAMING_SNAKE_CASE      ,   SCREAMING_SNAKE_CASE      ,   SCREAMING_SNAKE_CASE      ,   SCREAMING_SNAKE_CASE      ,   SCREAMING_SNAKE_CASE)  ->  Optional[Any]:
      _lowerCamelCase	:					Union[str, Any]   =		self.num_labels
      _lowerCamelCase	:					int   =		NystromformerForSequenceClassification(SCREAMING_SNAKE_CASE)
      model.to(SCREAMING_SNAKE_CASE)
      model.eval()
      _lowerCamelCase	:					str   =		model(SCREAMING_SNAKE_CASE      ,   attention_mask=SCREAMING_SNAKE_CASE      ,   token_type_ids=SCREAMING_SNAKE_CASE      ,   labels=SCREAMING_SNAKE_CASE)
      self.parent.assertEqual(result.logits.shape      ,   (self.batch_size, self.num_labels))





   def 		UpperCamelCase_  (							self      ,   SCREAMING_SNAKE_CASE      ,   SCREAMING_SNAKE_CASE      ,   SCREAMING_SNAKE_CASE      ,   SCREAMING_SNAKE_CASE      ,   SCREAMING_SNAKE_CASE      ,   SCREAMING_SNAKE_CASE      ,   SCREAMING_SNAKE_CASE)  ->  int:
      _lowerCamelCase	:					Tuple   =		self.num_labels
      _lowerCamelCase	:					int   =		NystromformerForTokenClassification(config=SCREAMING_SNAKE_CASE)
      model.to(SCREAMING_SNAKE_CASE)
      model.eval()
      _lowerCamelCase	:					Union[str, Any]   =		model(SCREAMING_SNAKE_CASE      ,   attention_mask=SCREAMING_SNAKE_CASE      ,   token_type_ids=SCREAMING_SNAKE_CASE      ,   labels=SCREAMING_SNAKE_CASE)
      self.parent.assertEqual(result.logits.shape      ,   (self.batch_size, self.seq_length, self.num_labels))





   def 		UpperCamelCase_  (							self      ,   SCREAMING_SNAKE_CASE      ,   SCREAMING_SNAKE_CASE      ,   SCREAMING_SNAKE_CASE      ,   SCREAMING_SNAKE_CASE      ,   SCREAMING_SNAKE_CASE      ,   SCREAMING_SNAKE_CASE      ,   SCREAMING_SNAKE_CASE)  ->  List[str]:
      _lowerCamelCase	:					int   =		self.num_choices
      _lowerCamelCase	:					Any   =		NystromformerForMultipleChoice(config=SCREAMING_SNAKE_CASE)
      model.to(SCREAMING_SNAKE_CASE)
      model.eval()
      _lowerCamelCase	:					Optional[Any]   =		input_ids.unsqueeze(1).expand(-1      ,   self.num_choices      ,   -1).contiguous()
      _lowerCamelCase	:					List[str]   =		token_type_ids.unsqueeze(1).expand(-1      ,   self.num_choices      ,   -1).contiguous()
      _lowerCamelCase	:					Dict   =		input_mask.unsqueeze(1).expand(-1      ,   self.num_choices      ,   -1).contiguous()
      _lowerCamelCase	:					str   =		model(
          SCREAMING_SNAKE_CASE      ,   attention_mask=SCREAMING_SNAKE_CASE      ,   token_type_ids=SCREAMING_SNAKE_CASE      ,   labels=SCREAMING_SNAKE_CASE      ,   )
      self.parent.assertEqual(result.logits.shape      ,   (self.batch_size, self.num_choices))





   def 		UpperCamelCase_  (							self)  ->  List[Any]:
      _lowerCamelCase	:					Tuple   =		self.prepare_config_and_inputs()
      (
          (
          _lowerCamelCase
      )   ,    (
          _lowerCamelCase
      )   ,    (
          _lowerCamelCase
      )   ,    (
          _lowerCamelCase
      )   ,    (
          _lowerCamelCase
      )   ,    (
          _lowerCamelCase
      )   ,    (
          _lowerCamelCase
      )   ,    
      )	:					Union[str, Any]   =		config_and_inputs
      _lowerCamelCase	:					Optional[int]   =		{"""input_ids""": input_ids, """token_type_ids""": token_type_ids, """attention_mask""": input_mask}
      return config, inputs_dict







@require_torch
class 	lowercase__				(					A_ ,A_ ,unittest.TestCase				):
   __UpperCAmelCase							       =					(
       (
           NystromformerModel,
           NystromformerForMaskedLM,
           NystromformerForMultipleChoice,
           NystromformerForQuestionAnswering,
           NystromformerForSequenceClassification,
           NystromformerForTokenClassification,
       )
       if is_torch_available()
       else ()
   )
   __UpperCAmelCase							       =					(
       {
           '''feature-extraction''': NystromformerModel,
           '''fill-mask''': NystromformerForMaskedLM,
           '''question-answering''': NystromformerForQuestionAnswering,
           '''text-classification''': NystromformerForSequenceClassification,
           '''token-classification''': NystromformerForTokenClassification,
           '''zero-shot''': NystromformerForSequenceClassification,
       }
       if is_torch_available()
       else {}
   )
   __UpperCAmelCase							       =					False
   __UpperCAmelCase							       =					False





   def 		UpperCamelCase_  (							self)  ->  List[str]:
      _lowerCamelCase	:					Union[str, Any]   =		NystromformerModelTester(self)
      _lowerCamelCase	:					List[Any]   =		ConfigTester(self      ,   config_class=SCREAMING_SNAKE_CASE      ,   hidden_size=37)





   def 		UpperCamelCase_  (							self)  ->  str:
      self.config_tester.run_common_tests()





   def 		UpperCamelCase_  (							self)  ->  Any:
      _lowerCamelCase	:					Optional[int]   =		self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_model(*SCREAMING_SNAKE_CASE)





   def 		UpperCamelCase_  (							self)  ->  Tuple:
      _lowerCamelCase	:					List[Any]   =		self.model_tester.prepare_config_and_inputs()
      for type in ["absolute", "relative_key", "relative_key_query"]:
         _lowerCamelCase	:					int   =		type
         self.model_tester.create_and_check_model(*SCREAMING_SNAKE_CASE)





   def 		UpperCamelCase_  (							self)  ->  int:
      _lowerCamelCase	:					List[str]   =		self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_masked_lm(*SCREAMING_SNAKE_CASE)





   def 		UpperCamelCase_  (							self)  ->  Union[str, Any]:
      _lowerCamelCase	:					str   =		self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_multiple_choice(*SCREAMING_SNAKE_CASE)





   def 		UpperCamelCase_  (							self)  ->  Optional[int]:
      _lowerCamelCase	:					List[str]   =		self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_question_answering(*SCREAMING_SNAKE_CASE)





   def 		UpperCamelCase_  (							self)  ->  List[str]:
      _lowerCamelCase	:					str   =		self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_sequence_classification(*SCREAMING_SNAKE_CASE)





   def 		UpperCamelCase_  (							self)  ->  str:
      _lowerCamelCase	:					List[Any]   =		self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_token_classification(*SCREAMING_SNAKE_CASE)





   @slow
   def 		UpperCamelCase_  (							self)  ->  Optional[int]:
      for model_name in NYSTROMFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
         _lowerCamelCase	:					Dict   =		NystromformerModel.from_pretrained(SCREAMING_SNAKE_CASE)
         self.assertIsNotNone(SCREAMING_SNAKE_CASE)







@require_torch
class 	lowercase__				(					unittest.TestCase				):





   @slow
   def 		UpperCamelCase_  (							self)  ->  Optional[Any]:
      _lowerCamelCase	:					Union[str, Any]   =		NystromformerModel.from_pretrained("""uw-madison/nystromformer-512""")
      _lowerCamelCase	:					Union[str, Any]   =		torch.tensor([[0, 1, 2, 3, 4, 5]])

      with torch.no_grad():
         _lowerCamelCase	:					List[Any]   =		model(SCREAMING_SNAKE_CASE)[0]

      _lowerCamelCase	:					Any   =		torch.Size((1, 6, 768))
      self.assertEqual(output.shape      ,   SCREAMING_SNAKE_CASE)

      _lowerCamelCase	:					List[str]   =		torch.tensor(
          [[[-0.45_32, -0.09_36, 0.51_37], [-0.26_76, 0.06_28, 0.61_86], [-0.36_29, -0.17_26, 0.47_16]]])

      self.assertTrue(torch.allclose(output[:, :3, :3]      ,   SCREAMING_SNAKE_CASE      ,   atol=1e-4))





   @slow
   def 		UpperCamelCase_  (							self)  ->  Optional[Any]:
      _lowerCamelCase	:					Optional[Any]   =		"""the [MASK] of Belgium is Brussels"""

      _lowerCamelCase	:					Optional[Any]   =		AutoTokenizer.from_pretrained("""uw-madison/nystromformer-512""")
      _lowerCamelCase	:					List[Any]   =		NystromformerForMaskedLM.from_pretrained("""uw-madison/nystromformer-512""")

      _lowerCamelCase	:					str   =		tokenizer(SCREAMING_SNAKE_CASE      ,   return_tensors="""pt""")

      with torch.no_grad():
         _lowerCamelCase	:					Tuple   =		model(encoding.input_ids).logits

      _lowerCamelCase	:					str   =		token_logits[:, 2, :].argmax(-1)[0]

      self.assertEqual(tokenizer.decode(SCREAMING_SNAKE_CASE)      ,   """capital""")








from typing import List

from .keymap import KEYMAP, get_character
def      A__       (    SCREAMING_SNAKE_CASE_   :      str						)  ->  List[str]:






   """simple docstring"""







   def decorator(SCREAMING_SNAKE_CASE_   :      List[Any]						):
      _UpperCAmelCase           =   getattr(SCREAMING_SNAKE_CASE_				,	'''handle_key'''				,	[]						)
      handle += [key]
      setattr(SCREAMING_SNAKE_CASE_				,	'''handle_key'''				,	SCREAMING_SNAKE_CASE_						)
      return func

   return decorator
def      A__       (    *SCREAMING_SNAKE_CASE_   :      List[str]						)  ->  Dict:






   """simple docstring"""







   def decorator(SCREAMING_SNAKE_CASE_   :      Any						):
      _UpperCAmelCase           =   getattr(SCREAMING_SNAKE_CASE_				,	'''handle_key'''				,	[]						)
      handle += keys
      setattr(SCREAMING_SNAKE_CASE_				,	'''handle_key'''				,	SCREAMING_SNAKE_CASE_						)
      return func

   return decorator




class 			__UpperCamelCase    (							A__    ):





     def __new__(     cls				,							_UpperCamelCase				,							_UpperCamelCase				,							_UpperCamelCase					):
        _UpperCAmelCase           =   super().__new__(cls				,							_UpperCamelCase				,							_UpperCamelCase				,							_UpperCamelCase					)
        if not hasattr(_UpperCamelCase				,							'''key_handler'''					):
           setattr(_UpperCamelCase				,							'''key_handler'''				,							{}					)
        setattr(_UpperCamelCase				,							'''handle_input'''				,							KeyHandler.handle_input					)

        for value in attrs.values():
           _UpperCAmelCase           =   getattr(_UpperCamelCase				,							'''handle_key'''				,							[]					)
           for key in handled_keys:
              _UpperCAmelCase           =   value
        return new_cls





     @staticmethod
     def 		UpperCamelCase(     cls					):
        _UpperCAmelCase           =   get_character()
        if char != KEYMAP["undefined"]:
           _UpperCAmelCase           =   ord(_UpperCamelCase					)
        _UpperCAmelCase           =   cls.key_handler.get(_UpperCamelCase					)
        if handler:
           _UpperCAmelCase           =   char
           return handler(cls					)
        else:
           return None




def      A__       (    cls   :      Union[str, Any]						)  ->  Any:






   """simple docstring"""







   return KeyHandler(cls.__name__				,	cls.__bases__				,	cls.__dict__.copy()						)