

'''simple docstring'''

import os
import tempfile
import unittest

from transformers import NezhaConfig, is_torch_available
from transformers.models.auto import get_values
from transformers.testing_utils import require_torch, require_torch_gpu, slow, torch_device

from ...generation.test_utils import GenerationTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
       import torch

       from transformers import (
           MODEL_FOR_PRETRAINING_MAPPING,
           NezhaForMaskedLM,
           NezhaForMultipleChoice,
           NezhaForNextSentencePrediction,
           NezhaForPreTraining,
           NezhaForQuestionAnswering,
           NezhaForSequenceClassification,
           NezhaForTokenClassification,
           NezhaModel,
       )
       from transformers.models.nezha.modeling_nezha import NEZHA_PRETRAINED_MODEL_ARCHIVE_LIST


class 	lowerCAmelCase  :







       def __init__(				self      :			Dict    ,   __lowercase      :			Dict    ,   __lowercase      :			Optional[Any]=13    ,   __lowercase      :			Any=7    ,   __lowercase      :			Tuple=True    ,   __lowercase      :			Dict=True    ,   __lowercase      :			Any=True    ,   __lowercase      :			Any=True    ,   __lowercase      :			Optional[Any]=99    ,   __lowercase      :			Optional[Any]=32    ,   __lowercase      :			List[Any]=5    ,   __lowercase      :			Optional[int]=4    ,   __lowercase      :			List[Any]=37    ,   __lowercase      :			str="gelu"    ,   __lowercase      :			Dict=0.1    ,   __lowercase      :			int=0.1    ,   __lowercase      :			Tuple=128    ,   __lowercase      :			Any=32    ,   __lowercase      :			Any=16    ,   __lowercase      :			List[Any]=2    ,   __lowercase      :			int=0.0_2    ,   __lowercase      :			Tuple=3    ,   __lowercase      :			Tuple=4    ,   __lowercase      :			str=None    ,   ):







            """simple docstring"""







            __lowercase      		=parent
            __lowercase      		=batch_size
            __lowercase      		=seq_length
            __lowercase      		=is_training
            __lowercase      		=use_input_mask
            __lowercase      		=use_token_type_ids
            __lowercase      		=use_labels
            __lowercase      		=vocab_size
            __lowercase      		=hidden_size
            __lowercase      		=num_hidden_layers
            __lowercase      		=num_attention_heads
            __lowercase      		=intermediate_size
            __lowercase      		=hidden_act
            __lowercase      		=hidden_dropout_prob
            __lowercase      		=attention_probs_dropout_prob
            __lowercase      		=max_position_embeddings
            __lowercase      		=type_vocab_size
            __lowercase      		=type_sequence_label_size
            __lowercase      		=initializer_range
            __lowercase      		=num_labels
            __lowercase      		=num_choices
            __lowercase      		=scope







       def       snake_case (				self      :			Any   ):







            """simple docstring"""







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

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

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

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

            __lowercase      		=self.get_config()

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







       def       snake_case (				self      :			int   ):







            """simple docstring"""







            return NezhaConfig(
                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=__lowercase    ,   initializer_range=self.initializer_range    ,   )







       def       snake_case (				self      :			Optional[int]   ):







            """simple docstring"""







            (
                (
                __lowercase
            )		,  (
                __lowercase
            )		,  (
                __lowercase
            )		,  (
                __lowercase
            )		,  (
                __lowercase
            )		,  (
                __lowercase
            )		,  (
                __lowercase
            )		,  
            )      		=self.prepare_config_and_inputs()

            __lowercase      		=True
            __lowercase      		=floats_tensor([self.batch_size, self.seq_length, self.hidden_size]   )
            __lowercase      		=ids_tensor([self.batch_size, self.seq_length]    ,   vocab_size=2   )

            return (
                config,
                input_ids,
                token_type_ids,
                input_mask,
                sequence_labels,
                token_labels,
                choice_labels,
                encoder_hidden_states,
                encoder_attention_mask,
            )







       def       snake_case (				self      :			int    ,   __lowercase      :			Dict    ,   __lowercase      :			Dict    ,   __lowercase      :			Tuple    ,   __lowercase      :			Dict    ,   __lowercase      :			Optional[Any]    ,   __lowercase      :			List[str]    ,   __lowercase      :			str   ):







            """simple docstring"""







            __lowercase      		=NezhaModel(config=__lowercase   )
            model.to(__lowercase   )
            model.eval()
            __lowercase      		=model(__lowercase    ,   attention_mask=__lowercase    ,   token_type_ids=__lowercase   )
            __lowercase      		=model(__lowercase    ,   token_type_ids=__lowercase   )
            __lowercase      		=model(__lowercase   )
            self.parent.assertEqual(result.last_hidden_state.shape    ,   (self.batch_size, self.seq_length, self.hidden_size)   )
            self.parent.assertEqual(result.pooler_output.shape    ,   (self.batch_size, self.hidden_size)   )







       def       snake_case (				self      :			List[str]    ,   __lowercase      :			Optional[int]    ,   __lowercase      :			str    ,   __lowercase      :			Union[str, Any]    ,   __lowercase      :			Union[str, Any]    ,   __lowercase      :			Any    ,   __lowercase      :			int    ,   __lowercase      :			Any    ,   __lowercase      :			Union[str, Any]    ,   __lowercase      :			int    ,   ):







            """simple docstring"""







            __lowercase      		=True
            __lowercase      		=NezhaModel(__lowercase   )
            model.to(__lowercase   )
            model.eval()
            __lowercase      		=model(
                __lowercase    ,   attention_mask=__lowercase    ,   token_type_ids=__lowercase    ,   encoder_hidden_states=__lowercase    ,   encoder_attention_mask=__lowercase    ,   )
            __lowercase      		=model(
                __lowercase    ,   attention_mask=__lowercase    ,   token_type_ids=__lowercase    ,   encoder_hidden_states=__lowercase    ,   )
            __lowercase      		=model(__lowercase    ,   attention_mask=__lowercase    ,   token_type_ids=__lowercase   )
            self.parent.assertEqual(result.last_hidden_state.shape    ,   (self.batch_size, self.seq_length, self.hidden_size)   )
            self.parent.assertEqual(result.pooler_output.shape    ,   (self.batch_size, self.hidden_size)   )







       def       snake_case (				self      :			Any    ,   __lowercase      :			List[str]    ,   __lowercase      :			int    ,   __lowercase      :			int    ,   __lowercase      :			Dict    ,   __lowercase      :			Union[str, Any]    ,   __lowercase      :			Tuple    ,   __lowercase      :			Union[str, Any]   ):







            """simple docstring"""







            __lowercase      		=NezhaForMaskedLM(config=__lowercase   )
            model.to(__lowercase   )
            model.eval()
            __lowercase      		=model(__lowercase    ,   attention_mask=__lowercase    ,   token_type_ids=__lowercase    ,   labels=__lowercase   )
            self.parent.assertEqual(result.logits.shape    ,   (self.batch_size, self.seq_length, self.vocab_size)   )







       def       snake_case (				self      :			Tuple    ,   __lowercase      :			Dict    ,   __lowercase      :			Any    ,   __lowercase      :			Tuple    ,   __lowercase      :			List[Any]    ,   __lowercase      :			List[Any]    ,   __lowercase      :			Optional[Any]    ,   __lowercase      :			List[str]   ):







            """simple docstring"""







            __lowercase      		=NezhaForNextSentencePrediction(config=__lowercase   )
            model.to(__lowercase   )
            model.eval()
            __lowercase      		=model(
                __lowercase    ,   attention_mask=__lowercase    ,   token_type_ids=__lowercase    ,   labels=__lowercase    ,   )
            self.parent.assertEqual(result.logits.shape    ,   (self.batch_size, 2)   )







       def       snake_case (				self      :			List[str]    ,   __lowercase      :			int    ,   __lowercase      :			Tuple    ,   __lowercase      :			List[str]    ,   __lowercase      :			Optional[int]    ,   __lowercase      :			List[Any]    ,   __lowercase      :			Any    ,   __lowercase      :			str   ):







            """simple docstring"""







            __lowercase      		=NezhaForPreTraining(config=__lowercase   )
            model.to(__lowercase   )
            model.eval()
            __lowercase      		=model(
                __lowercase    ,   attention_mask=__lowercase    ,   token_type_ids=__lowercase    ,   labels=__lowercase    ,   next_sentence_label=__lowercase    ,   )
            self.parent.assertEqual(result.prediction_logits.shape    ,   (self.batch_size, self.seq_length, self.vocab_size)   )
            self.parent.assertEqual(result.seq_relationship_logits.shape    ,   (self.batch_size, 2)   )







       def       snake_case (				self      :			Optional[int]    ,   __lowercase      :			Union[str, Any]    ,   __lowercase      :			int    ,   __lowercase      :			Dict    ,   __lowercase      :			Union[str, Any]    ,   __lowercase      :			Dict    ,   __lowercase      :			Optional[Any]    ,   __lowercase      :			Any   ):







            """simple docstring"""







            __lowercase      		=NezhaForQuestionAnswering(config=__lowercase   )
            model.to(__lowercase   )
            model.eval()
            __lowercase      		=model(
                __lowercase    ,   attention_mask=__lowercase    ,   token_type_ids=__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       snake_case (				self      :			str    ,   __lowercase      :			List[str]    ,   __lowercase      :			str    ,   __lowercase      :			Optional[Any]    ,   __lowercase      :			List[str]    ,   __lowercase      :			Union[str, Any]    ,   __lowercase      :			int    ,   __lowercase      :			str   ):







            """simple docstring"""







            __lowercase      		=self.num_labels
            __lowercase      		=NezhaForSequenceClassification(__lowercase   )
            model.to(__lowercase   )
            model.eval()
            __lowercase      		=model(__lowercase    ,   attention_mask=__lowercase    ,   token_type_ids=__lowercase    ,   labels=__lowercase   )
            self.parent.assertEqual(result.logits.shape    ,   (self.batch_size, self.num_labels)   )







       def       snake_case (				self      :			Optional[Any]    ,   __lowercase      :			List[str]    ,   __lowercase      :			Tuple    ,   __lowercase      :			Optional[Any]    ,   __lowercase      :			Union[str, Any]    ,   __lowercase      :			Dict    ,   __lowercase      :			Dict    ,   __lowercase      :			Any   ):







            """simple docstring"""







            __lowercase      		=self.num_labels
            __lowercase      		=NezhaForTokenClassification(config=__lowercase   )
            model.to(__lowercase   )
            model.eval()
            __lowercase      		=model(__lowercase    ,   attention_mask=__lowercase    ,   token_type_ids=__lowercase    ,   labels=__lowercase   )
            self.parent.assertEqual(result.logits.shape    ,   (self.batch_size, self.seq_length, self.num_labels)   )







       def       snake_case (				self      :			Optional[Any]    ,   __lowercase      :			int    ,   __lowercase      :			List[Any]    ,   __lowercase      :			Any    ,   __lowercase      :			str    ,   __lowercase      :			List[Any]    ,   __lowercase      :			Optional[int]    ,   __lowercase      :			str   ):







            """simple docstring"""







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







       def       snake_case (				self      :			List[Any]   ):







            """simple docstring"""







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






@require_torch
class 	lowerCAmelCase  (   A ,      A ,      A ,      unittest.TestCase ):
       lowerCAmelCase_												=			(
           (
               NezhaModel,
               NezhaForMaskedLM,
               NezhaForMultipleChoice,
               NezhaForNextSentencePrediction,
               NezhaForPreTraining,
               NezhaForQuestionAnswering,
               NezhaForSequenceClassification,
               NezhaForTokenClassification,
           )
           if is_torch_available()
           else ()
       )
       lowerCAmelCase_												=			(
           {
               "feature-extraction": NezhaModel,
               "fill-mask": NezhaForMaskedLM,
               "question-answering": NezhaForQuestionAnswering,
               "text-classification": NezhaForSequenceClassification,
               "token-classification": NezhaForTokenClassification,
               "zero-shot": NezhaForSequenceClassification,
           }
           if is_torch_available()
           else {}
       )
       lowerCAmelCase_												=			True







       def       snake_case (				self      :			List[Any]    ,   __lowercase      :			int    ,   __lowercase      :			Optional[Any]    ,   __lowercase      :			Tuple=False   ):







            """simple docstring"""







            __lowercase      		=super()._prepare_for_class(__lowercase    ,   __lowercase    ,   return_labels=__lowercase   )

            if return_labels:
                 if model_class in get_values(__lowercase   ):
                      __lowercase      		=torch.zeros(
                          (self.model_tester.batch_size, self.model_tester.seq_length)    ,   dtype=torch.long    ,   device=__lowercase   )
                      __lowercase      		=torch.zeros(
                          self.model_tester.batch_size    ,   dtype=torch.long    ,   device=__lowercase   )
            return inputs_dict







       def       snake_case (				self      :			List[str]   ):







            """simple docstring"""







            __lowercase      		=NezhaModelTester(self   )
            __lowercase      		=ConfigTester(self    ,   config_class=__lowercase    ,   hidden_size=37   )







       def       snake_case (				self      :			List[str]   ):







            """simple docstring"""







            self.config_tester.run_common_tests()







       def       snake_case (				self      :			Dict   ):







            """simple docstring"""







            __lowercase      		=self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_model(*__lowercase   )







       def       snake_case (				self      :			Union[str, Any]   ):







            """simple docstring"""







            __lowercase      		=self.model_tester.prepare_config_and_inputs_for_decoder()
            self.model_tester.create_and_check_model_as_decoder(*__lowercase   )







       def       snake_case (				self      :			int   ):







            """simple docstring"""







            (
                (
                __lowercase
            )		,  (
                __lowercase
            )		,  (
                __lowercase
            )		,  (
                __lowercase
            )		,  (
                __lowercase
            )		,  (
                __lowercase
            )		,  (
                __lowercase
            )		,  (
                __lowercase
            )		,  (
                __lowercase
            )		,  
            )      		=self.model_tester.prepare_config_and_inputs_for_decoder()

            __lowercase      		=None

            self.model_tester.create_and_check_model_as_decoder(
                __lowercase    ,   __lowercase    ,   __lowercase    ,   __lowercase    ,   __lowercase    ,   __lowercase    ,   __lowercase    ,   __lowercase    ,   __lowercase    ,   )







       def       snake_case (				self      :			List[str]   ):







            """simple docstring"""







            __lowercase      		=self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_for_masked_lm(*__lowercase   )







       def       snake_case (				self      :			Any   ):







            """simple docstring"""







            __lowercase      		=self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_for_multiple_choice(*__lowercase   )







       def       snake_case (				self      :			int   ):







            """simple docstring"""







            __lowercase      		=self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_for_next_sequence_prediction(*__lowercase   )







       def       snake_case (				self      :			Dict   ):







            """simple docstring"""







            __lowercase      		=self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_for_pretraining(*__lowercase   )







       def       snake_case (				self      :			Union[str, Any]   ):







            """simple docstring"""







            __lowercase      		=self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_for_question_answering(*__lowercase   )







       def       snake_case (				self      :			Optional[int]   ):







            """simple docstring"""







            __lowercase      		=self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_for_sequence_classification(*__lowercase   )







       def       snake_case (				self      :			Optional[int]   ):







            """simple docstring"""







            __lowercase      		=self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_for_token_classification(*__lowercase   )







       @slow
       def       snake_case (				self      :			List[Any]   ):







            """simple docstring"""







            for model_name in NEZHA_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                 __lowercase      		=NezhaModel.from_pretrained(__lowercase   )
                 self.assertIsNotNone(__lowercase   )







       @slow
       @require_torch_gpu
       def       snake_case (				self      :			int   ):







            """simple docstring"""







            __lowercase		,  __lowercase      		=self.model_tester.prepare_config_and_inputs_for_common()
            for model_class in self.all_model_classes:
                 # NezhaForMultipleChoice behaves incorrectly in JIT environments.
                 if model_class == NezhaForMultipleChoice:
                      return

                 __lowercase      		=True
                 __lowercase      		=model_class(config=__lowercase   )

                 __lowercase      		=self._prepare_for_class(__lowercase    ,   __lowercase   )
                 __lowercase      		=torch.jit.trace(
                     __lowercase    ,   (inputs_dict['input_ids'].to('cpu'   ), inputs_dict['attention_mask'].to('cpu'   ))   )

                 with tempfile.TemporaryDirectory() as tmp:
                      torch.jit.save(__lowercase    ,   os.path.join(__lowercase    ,   'bert.pt'   )   )
                      __lowercase      		=torch.jit.load(os.path.join(__lowercase    ,   'bert.pt'   )    ,   map_location=__lowercase   )
                      loaded(inputs_dict['input_ids'].to(__lowercase   )    ,   inputs_dict['attention_mask'].to(__lowercase   )   )






@require_torch
class 	lowerCAmelCase  (   unittest.TestCase ):







       @slow
       def       snake_case (				self      :			int   ):







            """simple docstring"""







            __lowercase      		=NezhaModel.from_pretrained('sijunhe/nezha-cn-base'   )
            __lowercase      		=torch.tensor([[0, 1, 2, 3, 4, 5]]   )
            __lowercase      		=torch.tensor([[0, 1, 1, 1, 1, 1]]   )
            with torch.no_grad():
                 __lowercase      		=model(__lowercase    ,   attention_mask=__lowercase   )[0]
            __lowercase      		=torch.Size((1, 6, 768)   )
            self.assertEqual(output.shape    ,   __lowercase   )
            __lowercase      		=torch.tensor([[[0.0_6_8_5, 0.2_4_4_1, 0.1_1_0_2], [0.0_6_0_0, 0.1_9_0_6, 0.1_3_4_9], [0.0_2_2_1, 0.0_8_1_9, 0.0_5_8_6]]]   )

            self.assertTrue(torch.allclose(output[:, 1:4, 1:4]    ,   __lowercase    ,   atol=1E-4   )   )







       @slow
       def       snake_case (				self      :			List[Any]   ):







            """simple docstring"""







            __lowercase      		=NezhaForMaskedLM.from_pretrained('sijunhe/nezha-cn-base'   )
            __lowercase      		=torch.tensor([[0, 1, 2, 3, 4, 5]]   )
            __lowercase      		=torch.tensor([[1, 1, 1, 1, 1, 1]]   )
            with torch.no_grad():
                 __lowercase      		=model(__lowercase    ,   attention_mask=__lowercase   )[0]
            __lowercase      		=torch.Size((1, 6, 21128)   )
            self.assertEqual(output.shape    ,   __lowercase   )
            __lowercase      		=torch.tensor(
                [[-2.7_9_3_9, -1.7_9_0_2, -2.2_1_8_9], [-2.8_5_8_5, -1.8_9_0_8, -2.3_7_2_3], [-2.6_4_9_9, -1.7_7_5_0, -2.2_5_5_8]]   )

            self.assertTrue(torch.allclose(output[:, 1:4, 1:4]    ,   __lowercase    ,   atol=1E-4   )   )





'''simple docstring'''

import string

def 					__UpperCamelCase				(						lowercase__    :	str			):






     '''simple docstring'''





     for key in range(len(string.ascii_uppercase			)			):
          __lowercase      		=''
          for symbol in message:
               if symbol in string.ascii_uppercase:
                    __lowercase      		=string.ascii_uppercase.find(lowercase__			)
                    __lowercase      		=num - key
                    if num < 0:
                         __lowercase      		=num + len(string.ascii_uppercase			)
                    __lowercase      		=translated + string.ascii_uppercase[num]
               else:
                    __lowercase      		=translated + symbol
          print(F'''Decryption using Key #{key}: {translated}'''			)

def 					__UpperCamelCase				(						):






     '''simple docstring'''





     __lowercase      		=input('Encrypted message: '			)
     __lowercase      		=message.upper()
     decrypt(lowercase__			)


if __name__ == "__main__":
       import doctest

       doctest.testmod()
       main()


