

import unittest

from transformers.testing_utils import is_torch_available, require_torch, tooslow

from ...generation.test_utils import 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 (
     CpmAntConfig,
     CpmAntForCausalLM,
     CpmAntModel,
     CpmAntTokenizer,
 )



@require_torch
class 		a_	:



      """simple docstring"""







      def __init__(				self					:							Tuple      ,snake_case					:							Tuple      ,snake_case					:							str=2      ,snake_case					:							Tuple=8      ,snake_case					:							Optional[Any]=True      ,snake_case					:							Optional[int]=False      ,snake_case					:							Union[str, Any]=False      ,snake_case					:							Tuple=False      ,snake_case					:							List[str]=False      ,snake_case					:							Tuple=99      ,snake_case					:							int=32      ,snake_case					:							str=3      ,snake_case					:							Any=4      ,snake_case					:							List[Any]=37      ,snake_case					:							Optional[int]=32      ,snake_case					:							str=128      ,snake_case					:							List[Any]=8      ,snake_case					:							Tuple=8      ,snake_case					:							Tuple=8      ,snake_case					:							str=1.0      ,snake_case					:							Tuple=True      ,):
           SCREAMING_SNAKE_CASE										=parent
           SCREAMING_SNAKE_CASE										=batch_size
           SCREAMING_SNAKE_CASE										=seq_length
           SCREAMING_SNAKE_CASE										=is_training
           SCREAMING_SNAKE_CASE										=use_token_type_ids
           SCREAMING_SNAKE_CASE										=use_input_mask
           SCREAMING_SNAKE_CASE										=use_labels
           SCREAMING_SNAKE_CASE										=use_mc_token_ids
           SCREAMING_SNAKE_CASE										=vocab_size
           SCREAMING_SNAKE_CASE										=hidden_size
           SCREAMING_SNAKE_CASE										=num_hidden_layers
           SCREAMING_SNAKE_CASE										=num_attention_heads
           SCREAMING_SNAKE_CASE										=intermediate_size
           SCREAMING_SNAKE_CASE										=num_buckets
           SCREAMING_SNAKE_CASE										=max_distance
           SCREAMING_SNAKE_CASE										=prompt_length
           SCREAMING_SNAKE_CASE										=prompt_types
           SCREAMING_SNAKE_CASE										=segment_types
           SCREAMING_SNAKE_CASE										=init_std
           SCREAMING_SNAKE_CASE										=return_dict
      def 	_lowerCAmelCase					(				self					:							Union[str, Any]    ):
           SCREAMING_SNAKE_CASE										={}
           SCREAMING_SNAKE_CASE										=ids_tensor([self.batch_size, self.seq_length]      ,self.vocab_size    ).type(torch.intaa    )
           SCREAMING_SNAKE_CASE										=False

           SCREAMING_SNAKE_CASE										=self.get_config()

           return (config, input_ids)
      def 	_lowerCAmelCase					(				self					:							List[str]    ):
           return CpmAntConfig(
               vocab_size=self.vocab_size      ,hidden_size=self.hidden_size      ,num_hidden_layers=self.num_hidden_layers      ,num_attention_heads=self.num_attention_heads      ,dim_ff=self.intermediate_size      ,position_bias_num_buckets=self.num_buckets      ,position_bias_max_distance=self.max_distance      ,prompt_types=self.prompt_types      ,prompt_length=self.prompt_length      ,segment_types=self.segment_types      ,use_cache=snake_case      ,init_std=self.init_std      ,return_dict=self.return_dict      ,)
      def 	_lowerCAmelCase					(				self					:							List[Any]      ,snake_case					:							List[str]      ,snake_case					:							Any      ,*snake_case					:							Tuple    ):
           SCREAMING_SNAKE_CASE										=CpmAntModel(config=snake_case    )
           model.to(snake_case    )
           model.eval()

           SCREAMING_SNAKE_CASE										=model(**snake_case    ).last_hidden_state

           self.parent.assertEqual(hidden_states.shape      ,(self.batch_size, self.seq_length, config.hidden_size)    )
      def 	_lowerCAmelCase					(				self					:							List[str]      ,snake_case					:							Tuple      ,snake_case					:							int      ,*snake_case					:							Union[str, Any]    ):
           SCREAMING_SNAKE_CASE										=CpmAntForCausalLM(snake_case    )
           model.to(snake_case    )
           SCREAMING_SNAKE_CASE										=input_ids['input_ids'].to(snake_case    )
           model.eval()

           SCREAMING_SNAKE_CASE										=model(**snake_case    )
           self.parent.assertEqual(
               model_output.logits.shape      ,(self.batch_size, self.seq_length, config.vocab_size + config.prompt_types * config.prompt_length)      ,)


      def 	_lowerCAmelCase					(				self					:							Any    ):
           SCREAMING_SNAKE_CASE						,  SCREAMING_SNAKE_CASE										=self.prepare_config_and_inputs()
           return config, inputs_dict







@require_torch
class 		a_	(							lowerCamelCase_			,      lowerCamelCase_			,      unittest.TestCase					):



      """simple docstring"""







      __UpperCAmelCase      		=				(CpmAntModel, CpmAntForCausalLM) if is_torch_available() else ()
      __UpperCAmelCase      		=				(
          {'feature-extraction': CpmAntModel, 'text-generation': CpmAntForCausalLM} if is_torch_available() else {}
      )

      __UpperCAmelCase      		=				False
      __UpperCAmelCase      		=				False
      __UpperCAmelCase      		=				False
      __UpperCAmelCase      		=				False
      __UpperCAmelCase      		=				False
      def 	_lowerCAmelCase					(				self					:							int    ):
           SCREAMING_SNAKE_CASE										=CpmAntModelTester(self    )
           SCREAMING_SNAKE_CASE										=ConfigTester(self      ,config_class=snake_case    )
      def 	_lowerCAmelCase					(				self					:							List[Any]    ):
           self.config_tester.create_and_test_config_common_properties()
           self.config_tester.create_and_test_config_to_json_string()
           self.config_tester.create_and_test_config_to_json_file()
           self.config_tester.create_and_test_config_from_and_save_pretrained()
           self.config_tester.check_config_can_be_init_without_params()
           self.config_tester.check_config_arguments_init()
      def 	_lowerCAmelCase					(				self					:							Dict    ):
           unittest.skip('CPMAnt doesn\'t support input_embeds.'    )(self.test_inputs_embeds    )
      def 	_lowerCAmelCase					(				self					:							Union[str, Any]    ):
           unittest.skip(
               'CPMAnt doesn\'t support retain grad in hidden_states or attentions, because prompt management will peel off the output.hidden_states from graph.\
                 So is attentions. We strongly recommand you use loss to tune model.'    )(self.test_retain_grad_hidden_states_attentions    )
      def 	_lowerCAmelCase					(				self					:							Optional[int]    ):
           SCREAMING_SNAKE_CASE						,  SCREAMING_SNAKE_CASE										=self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_cpmant_model(snake_case      ,snake_case    )


      def 	_lowerCAmelCase					(				self					:							List[Any]    ):
           SCREAMING_SNAKE_CASE						,  SCREAMING_SNAKE_CASE										=self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_lm_head_model(snake_case      ,snake_case    )







@require_torch
class 		a_	(							unittest.TestCase					):



      """simple docstring"""







      @tooslow
      def 	_lowerCAmelCase					(				self					:							int    ):
           SCREAMING_SNAKE_CASE										='今天天气真好！'
           SCREAMING_SNAKE_CASE										='openbmb/cpm-ant-10b'
           SCREAMING_SNAKE_CASE										=CpmAntModel.from_pretrained(snake_case    )
           SCREAMING_SNAKE_CASE										=CpmAntTokenizer.from_pretrained(snake_case    )
           SCREAMING_SNAKE_CASE										=tokenizer(snake_case      ,return_tensors='pt'    )
           SCREAMING_SNAKE_CASE										=model(**snake_case    ).last_hidden_state

           SCREAMING_SNAKE_CASE										=torch.tensor(
               [[[6.1_708, 5.9_244, 1.0_835], [6.5_207, 6.2_893, -11.3_324], [-1.0_107, -0.0_576, -5.9_577]]]      ,)
           self.assertTrue(torch.allclose(hidden_states[:, :3, :3]      ,snake_case      ,atol=1e-2    )    )







@require_torch
class 		a_	(							unittest.TestCase					):



      """simple docstring"""







      @tooslow
      def 	_lowerCAmelCase					(				self					:							Any    ):
           SCREAMING_SNAKE_CASE										='今天天气真好！'
           SCREAMING_SNAKE_CASE										='openbmb/cpm-ant-10b'
           SCREAMING_SNAKE_CASE										=CpmAntForCausalLM.from_pretrained(snake_case    )
           SCREAMING_SNAKE_CASE										=CpmAntTokenizer.from_pretrained(snake_case    )
           SCREAMING_SNAKE_CASE										=tokenizer(snake_case      ,return_tensors='pt'    )
           SCREAMING_SNAKE_CASE										=model(**snake_case    ).logits

           SCREAMING_SNAKE_CASE										=torch.tensor(
               [[[-6.4_267, -6.4_083, -6.3_958], [-5.8_802, -5.9_447, -5.7_811], [-5.3_896, -5.4_820, -5.4_295]]]      ,)
           self.assertTrue(torch.allclose(hidden_states[:, :3, :3]      ,snake_case      ,atol=1e-2    )    )
      @tooslow
      def 	_lowerCAmelCase					(				self					:							Union[str, Any]    ):
           SCREAMING_SNAKE_CASE										='openbmb/cpm-ant-10b'
           SCREAMING_SNAKE_CASE										=CpmAntForCausalLM.from_pretrained(snake_case    )
           SCREAMING_SNAKE_CASE										=CpmAntTokenizer.from_pretrained(snake_case    )
           SCREAMING_SNAKE_CASE										='今天天气不错，'
           SCREAMING_SNAKE_CASE										='今天天气不错，阳光明媚，我和妈妈一起去超市买东西。\n在超市里，我看到了一个很好玩的玩具，它的名字叫“机器人”。它有一个圆圆的脑袋，两只圆圆的眼睛，还有一个圆圆的'
           SCREAMING_SNAKE_CASE										=tokenizer(snake_case      ,return_tensors='pt'    )
           SCREAMING_SNAKE_CASE										=model.generate(**snake_case    )
           SCREAMING_SNAKE_CASE										=tokenizer.batch_decode(snake_case    )
           self.assertEqual(snake_case      ,snake_case    )


      @tooslow
      def 	_lowerCAmelCase					(				self					:							Dict    ):
           SCREAMING_SNAKE_CASE										='openbmb/cpm-ant-10b'
           SCREAMING_SNAKE_CASE										=CpmAntForCausalLM.from_pretrained(snake_case    )
           SCREAMING_SNAKE_CASE										=CpmAntTokenizer.from_pretrained(snake_case    )
           SCREAMING_SNAKE_CASE										=['今天天气不错，', '新年快乐，万事如意！']
           SCREAMING_SNAKE_CASE										=[
               '今天天气不错，阳光明媚，我和妈妈一起去超市买东西。\n在超市里，我看到了一个很好玩的玩具，它的名字叫“机器人”。它有一个圆圆的脑袋，两只圆圆的眼睛，还有一个圆圆的',
               '新年快乐，万事如意！在这辞旧迎新的美好时刻，我谨代表《农村新技术》杂志社全体同仁，向一直以来关心、支持《农村新技术》杂志发展的各级领导、各界朋友和广大读者致以最诚挚的',
           ]
           SCREAMING_SNAKE_CASE										=tokenizer(snake_case      ,return_tensors='pt'      ,padding=snake_case    )
           SCREAMING_SNAKE_CASE										=model.generate(**snake_case    )
           SCREAMING_SNAKE_CASE										=tokenizer.batch_decode(snake_case    )
           self.assertEqual(snake_case      ,snake_case    )




import random
import sys

_lowerCamelCase								="ABCDEFGHIJKLMNOPQRSTUVWXYZ"







def       snake_case__    (       ):





     """simple docstring"""







     SCREAMING_SNAKE_CASE										=input('Enter message: '      )
     SCREAMING_SNAKE_CASE										='LFWOAYUISVKMNXPBDCRJTQEGHZ'
     SCREAMING_SNAKE_CASE										=input('Encrypt/Decrypt [e/d]: '      )

     check_valid_key(lowerCAmelCase_      )

     if resp.lower().startswith('e'      ):
          SCREAMING_SNAKE_CASE										='encrypt'
          SCREAMING_SNAKE_CASE										=encrypt_message(lowerCAmelCase_,   lowerCAmelCase_      )
     elif resp.lower().startswith('d'      ):
          SCREAMING_SNAKE_CASE										='decrypt'
          SCREAMING_SNAKE_CASE										=decrypt_message(lowerCAmelCase_,   lowerCAmelCase_      )

     print(F'\n{mode.title()}ion: \n{translated}'      )







def       snake_case__    (       lowerCAmelCase_      ):





     """simple docstring"""







     SCREAMING_SNAKE_CASE										=list(lowerCAmelCase_      )
     SCREAMING_SNAKE_CASE										=list(lowerCAmelCase_      )
     key_list.sort()
     letters_list.sort()

     if key_list != letters_list:
          sys.exit('Error in the key or symbol set.'      )







def       snake_case__    (       lowerCAmelCase_,   lowerCAmelCase_      ):





     """simple docstring"""







     return translate_message(lowerCAmelCase_,   lowerCAmelCase_,   'encrypt'      )







def       snake_case__    (       lowerCAmelCase_,   lowerCAmelCase_      ):





     """simple docstring"""







     return translate_message(lowerCAmelCase_,   lowerCAmelCase_,   'decrypt'      )







def       snake_case__    (       lowerCAmelCase_,   lowerCAmelCase_,   lowerCAmelCase_      ):





     """simple docstring"""







     SCREAMING_SNAKE_CASE										=''
     SCREAMING_SNAKE_CASE										=LETTERS
     SCREAMING_SNAKE_CASE										=key

     if mode == "decrypt":
          SCREAMING_SNAKE_CASE						,  SCREAMING_SNAKE_CASE										=chars_b, chars_a

     for symbol in message:
          if symbol.upper() in chars_a:
               SCREAMING_SNAKE_CASE										=chars_a.find(symbol.upper()      )
               if symbol.isupper():
                    translated += chars_b[sym_index].upper()
               else:
                    translated += chars_b[sym_index].lower()
          else:
               translated += symbol

     return translated







def       snake_case__    (       ):





     """simple docstring"""







     SCREAMING_SNAKE_CASE										=list(lowerCAmelCase_      )
     random.shuffle(lowerCAmelCase_      )
     return "".join(lowerCAmelCase_      )


if __name__ == "__main__":
 main()

