



import unittest

from parameterized import parameterized

from transformers import OpenLlamaConfig, is_torch_available, set_seed
from transformers.testing_utils import require_torch, torch_device

from ...generation.test_utils import GenerationTesterMixin
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 OpenLlamaForCausalLM, OpenLlamaForSequenceClassification, OpenLlamaModel



class       UpperCAmelCase__:

   '''simple docstring'''




   def __init__(						self  :			int			,				lowerCAmelCase  :			Any			,				lowerCAmelCase  :			Dict=13			,				lowerCAmelCase  :			Optional[Any]=7			,				lowerCAmelCase  :			Union[str, Any]=True			,				lowerCAmelCase  :			str=True			,				lowerCAmelCase  :			int=False			,				lowerCAmelCase  :			Dict=True			,				lowerCAmelCase  :			Dict=99			,				lowerCAmelCase  :			List[str]=32			,				lowerCAmelCase  :			str=5			,				lowerCAmelCase  :			str=4			,				lowerCAmelCase  :			Tuple=37			,				lowerCAmelCase  :			Any="gelu"			,				lowerCAmelCase  :			Union[str, Any]=0.1			,				lowerCAmelCase  :			int=0.1			,				lowerCAmelCase  :			Dict=5_12			,				lowerCAmelCase  :			Optional[int]=16			,				lowerCAmelCase  :			List[Any]=2			,				lowerCAmelCase  :			Dict=0.02			,				lowerCAmelCase  :			Optional[int]=3			,				lowerCAmelCase  :			Dict=4			,				lowerCAmelCase  :			List[Any]=None			,				)	->				Optional[int]:




         """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 			UpperCAmelCase		(						self  :			List[str])	->				Optional[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 			UpperCAmelCase		(						self  :			Optional[int])	->				Tuple:




         """simple docstring"""

         return OpenLlamaConfig(
             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=lowerCAmelCase			,				initializer_range=self.initializer_range			,				use_stable_embedding=lowerCAmelCase			,				)


   def 			UpperCAmelCase		(						self  :			int			,				lowerCAmelCase  :			Tuple			,				lowerCAmelCase  :			Any			,				lowerCAmelCase  :			str			,				lowerCAmelCase  :			Tuple			,				lowerCAmelCase  :			Union[str, Any]			,				lowerCAmelCase  :			Dict			,				lowerCAmelCase  :			Optional[int])	->				Optional[Any]:




         """simple docstring"""

         lowercase__     =  OpenLlamaModel(config=lowerCAmelCase)
         model.to(lowerCAmelCase)
         model.eval()
         lowercase__     =  model(lowerCAmelCase			,				attention_mask=lowerCAmelCase)
         lowercase__     =  model(lowerCAmelCase)
         self.parent.assertEqual(result.last_hidden_state.shape			,				(self.batch_size, self.seq_length, self.hidden_size))


   def 			UpperCAmelCase		(						self  :			Optional[int]			,				lowerCAmelCase  :			str			,				lowerCAmelCase  :			List[Any]			,				lowerCAmelCase  :			List[str]			,				lowerCAmelCase  :			Any			,				lowerCAmelCase  :			Optional[Any]			,				lowerCAmelCase  :			Any			,				lowerCAmelCase  :			Optional[int]			,				lowerCAmelCase  :			List[Any]			,				lowerCAmelCase  :			List[str]			,				)	->				List[Any]:




         """simple docstring"""

         lowercase__     =  True
         lowercase__     =  OpenLlamaModel(lowerCAmelCase)
         model.to(lowerCAmelCase)
         model.eval()
         lowercase__     =  model(
             lowerCAmelCase			,				attention_mask=lowerCAmelCase			,				encoder_hidden_states=lowerCAmelCase			,				encoder_attention_mask=lowerCAmelCase			,				)
         lowercase__     =  model(
             lowerCAmelCase			,				attention_mask=lowerCAmelCase			,				encoder_hidden_states=lowerCAmelCase			,				)
         lowercase__     =  model(lowerCAmelCase			,				attention_mask=lowerCAmelCase)
         self.parent.assertEqual(result.last_hidden_state.shape			,				(self.batch_size, self.seq_length, self.hidden_size))


   def 			UpperCAmelCase		(						self  :			Optional[int]			,				lowerCAmelCase  :			Tuple			,				lowerCAmelCase  :			str			,				lowerCAmelCase  :			int			,				lowerCAmelCase  :			str			,				lowerCAmelCase  :			Optional[int]			,				lowerCAmelCase  :			Optional[int]			,				lowerCAmelCase  :			Optional[Any]			,				lowerCAmelCase  :			int			,				lowerCAmelCase  :			int			,				)	->				List[str]:




         """simple docstring"""

         lowercase__     =  OpenLlamaForCausalLM(config=lowerCAmelCase)
         model.to(lowerCAmelCase)
         model.eval()
         lowercase__     =  model(lowerCAmelCase			,				attention_mask=lowerCAmelCase			,				labels=lowerCAmelCase)
         self.parent.assertEqual(result.logits.shape			,				(self.batch_size, self.seq_length, self.vocab_size))


   def 			UpperCAmelCase		(						self  :			Dict			,				lowerCAmelCase  :			Optional[int]			,				lowerCAmelCase  :			Optional[Any]			,				lowerCAmelCase  :			List[str]			,				lowerCAmelCase  :			Optional[Any]			,				lowerCAmelCase  :			Any			,				lowerCAmelCase  :			Optional[int]			,				lowerCAmelCase  :			Tuple			,				lowerCAmelCase  :			Any			,				lowerCAmelCase  :			Union[str, Any]			,				)	->				Dict:




         """simple docstring"""

         lowercase__     =  True
         lowercase__     =  True
         lowercase__     =  OpenLlamaForCausalLM(config=lowerCAmelCase)
         model.to(lowerCAmelCase)
         model.eval()

         # first forward pass
         lowercase__     =  model(
             lowerCAmelCase			,				attention_mask=lowerCAmelCase			,				encoder_hidden_states=lowerCAmelCase			,				encoder_attention_mask=lowerCAmelCase			,				use_cache=lowerCAmelCase			,				)
         lowercase__     =  outputs.past_key_values

         # create hypothetical multiple next token and extent to next_input_ids
         lowercase__     =  ids_tensor((self.batch_size, 3)			,				config.vocab_size)
         lowercase__     =  ids_tensor((self.batch_size, 3)			,				vocab_size=2)

         # append to next input_ids and
         lowercase__     =  torch.cat([input_ids, next_tokens]			,				dim=-1)
         lowercase__     =  torch.cat([input_mask, next_mask]			,				dim=-1)

         lowercase__     =  model(
             lowerCAmelCase			,				attention_mask=lowerCAmelCase			,				encoder_hidden_states=lowerCAmelCase			,				encoder_attention_mask=lowerCAmelCase			,				output_hidden_states=lowerCAmelCase			,				)['hidden_states'][0]
         lowercase__     =  model(
             lowerCAmelCase			,				attention_mask=lowerCAmelCase			,				encoder_hidden_states=lowerCAmelCase			,				encoder_attention_mask=lowerCAmelCase			,				past_key_values=lowerCAmelCase			,				output_hidden_states=lowerCAmelCase			,				)['hidden_states'][0]

         # select random slice
         lowercase__     =  ids_tensor((1,)			,				output_from_past.shape[-1]).item()
         lowercase__     =  output_from_no_past[:, -3:, random_slice_idx].detach()
         lowercase__     =  output_from_past[:, :, random_slice_idx].detach()

         self.parent.assertTrue(output_from_past_slice.shape[1] == next_tokens.shape[1])

         # test that outputs are equal for slice
         self.parent.assertTrue(torch.allclose(lowerCAmelCase			,				lowerCAmelCase			,				atol=1E-3))



   def 			UpperCAmelCase		(						self  :			int)	->				int:




         """simple docstring"""

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



@require_torch
class       UpperCAmelCase__(							lowerCamelCase     ,							lowerCamelCase     ,							lowerCamelCase     ,							unittest.TestCase	):

   '''simple docstring'''




   A    :  Dict       				=    (
       (OpenLlamaModel, OpenLlamaForCausalLM, OpenLlamaForSequenceClassification) if is_torch_available() else ()
   )
   A    :  int       				=    (OpenLlamaForCausalLM,) if is_torch_available() else ()
   A    :  List[str]       				=    (
       {
           "feature-extraction": OpenLlamaModel,
           "text-classification": OpenLlamaForSequenceClassification,
           "text-generation": OpenLlamaForCausalLM,
           "zero-shot": OpenLlamaForSequenceClassification,
       }
       if is_torch_available()
       else {}
   )
   A    :  str       				=    False
   A    :  Tuple       				=    False


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




         """simple docstring"""

         lowercase__     =  OpenLlamaModelTester(self)
         lowercase__     =  ConfigTester(self			,				config_class=lowerCAmelCase			,				hidden_size=37)


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




         """simple docstring"""

         self.config_tester.run_common_tests()


   def 			UpperCAmelCase		(						self  :			Optional[int])	->				Dict:




         """simple docstring"""

         lowercase__     =  self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_model(*lowerCAmelCase)


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




         """simple docstring"""

         lowercase__     =  self.model_tester.prepare_config_and_inputs()
         for type in ["absolute", "relative_key", "relative_key_query"]:
               lowercase__     =  type
               self.model_tester.create_and_check_model(*lowerCAmelCase)


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




         """simple docstring"""

         lowercase__,	lowercase__     =  self.model_tester.prepare_config_and_inputs_for_common()
         lowercase__     =  3
         lowercase__     =  input_dict['input_ids']
         lowercase__     =  input_ids.ne(1).to(lowerCAmelCase)
         lowercase__     =  ids_tensor([self.model_tester.batch_size]			,				self.model_tester.type_sequence_label_size)
         lowercase__     =  OpenLlamaForSequenceClassification(lowerCAmelCase)
         model.to(lowerCAmelCase)
         model.eval()
         lowercase__     =  model(lowerCAmelCase			,				attention_mask=lowerCAmelCase			,				labels=lowerCAmelCase)
         self.assertEqual(result.logits.shape			,				(self.model_tester.batch_size, self.model_tester.num_labels))


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




         """simple docstring"""

         lowercase__,	lowercase__     =  self.model_tester.prepare_config_and_inputs_for_common()
         lowercase__     =  3
         lowercase__     =  'single_label_classification'
         lowercase__     =  input_dict['input_ids']
         lowercase__     =  input_ids.ne(1).to(lowerCAmelCase)
         lowercase__     =  ids_tensor([self.model_tester.batch_size]			,				self.model_tester.type_sequence_label_size)
         lowercase__     =  OpenLlamaForSequenceClassification(lowerCAmelCase)
         model.to(lowerCAmelCase)
         model.eval()
         lowercase__     =  model(lowerCAmelCase			,				attention_mask=lowerCAmelCase			,				labels=lowerCAmelCase)
         self.assertEqual(result.logits.shape			,				(self.model_tester.batch_size, self.model_tester.num_labels))


   def 			UpperCAmelCase		(						self  :			Dict)	->				int:




         """simple docstring"""

         lowercase__,	lowercase__     =  self.model_tester.prepare_config_and_inputs_for_common()
         lowercase__     =  3
         lowercase__     =  'multi_label_classification'
         lowercase__     =  input_dict['input_ids']
         lowercase__     =  input_ids.ne(1).to(lowerCAmelCase)
         lowercase__     =  ids_tensor(
             [self.model_tester.batch_size, config.num_labels]			,				self.model_tester.type_sequence_label_size).to(torch.float)
         lowercase__     =  OpenLlamaForSequenceClassification(lowerCAmelCase)
         model.to(lowerCAmelCase)
         model.eval()
         lowercase__     =  model(lowerCAmelCase			,				attention_mask=lowerCAmelCase			,				labels=lowerCAmelCase)
         self.assertEqual(result.logits.shape			,				(self.model_tester.batch_size, self.model_tester.num_labels))


   @unittest.skip('Open-Llama buffers include complex numbers, which breaks this test')
   def 			UpperCAmelCase		(						self  :			int)	->				Union[str, Any]:




         """simple docstring"""

         pass



   @parameterized.expand([('linear',), ('dynamic',)])
   def 			UpperCAmelCase		(						self  :			List[str]			,				lowerCAmelCase  :			List[str])	->				List[str]:




         """simple docstring"""

         lowercase__,	lowercase__     =  self.model_tester.prepare_config_and_inputs_for_common()
         lowercase__     =  ids_tensor([1, 10]			,				config.vocab_size)
         lowercase__     =  ids_tensor([1, int(config.max_position_embeddings * 1.5)]			,				config.vocab_size)

         set_seed(42)  # Fixed seed at init time so the two models get the same random weights
         lowercase__     =  OpenLlamaModel(lowerCAmelCase)
         original_model.to(lowerCAmelCase)
         original_model.eval()
         lowercase__     =  original_model(lowerCAmelCase).last_hidden_state
         lowercase__     =  original_model(lowerCAmelCase).last_hidden_state

         set_seed(42)  # Fixed seed at init time so the two models get the same random weights
         lowercase__     =  {'type': scaling_type, 'factor': 10.0}
         lowercase__     =  OpenLlamaModel(lowerCAmelCase)
         scaled_model.to(lowerCAmelCase)
         scaled_model.eval()
         lowercase__     =  scaled_model(lowerCAmelCase).last_hidden_state
         lowercase__     =  scaled_model(lowerCAmelCase).last_hidden_state

         # Dynamic scaling does not change the RoPE embeddings until it receives an input longer than the original
         # maximum sequence length, so the outputs for the short input should match.
         if scaling_type == "dynamic":
               self.assertTrue(torch.allclose(lowerCAmelCase			,				lowerCAmelCase			,				atol=1E-5))
         else:
               self.assertFalse(torch.allclose(lowerCAmelCase			,				lowerCAmelCase			,				atol=1E-5))

         # The output should be different for long inputs
         self.assertFalse(torch.allclose(lowerCAmelCase			,				lowerCAmelCase			,				atol=1E-5))





import argparse
import hashlib  # hashlib is only used inside the Test class
import struct



class       UpperCAmelCase__:

   '''simple docstring'''




   def __init__(						self  :			Optional[Any]			,				lowerCAmelCase  :			str)	->				Optional[int]:




         """simple docstring"""

         lowercase__     =  data
         lowercase__     =  [0X6_7_4_5_2_3_0_1, 0XE_F_C_D_A_B_8_9, 0X9_8_B_A_D_C_F_E, 0X1_0_3_2_5_4_7_6, 0XC_3_D_2_E_1_F_0]


   @staticmethod
   def 			UpperCAmelCase		(						lowerCAmelCase  :			Union[str, Any]			,				lowerCAmelCase  :			Optional[int])	->				str:




         """simple docstring"""

         return ((n << b) | (n >> (32 - b))) & 0XF_F_F_F_F_F_F_F


   def 			UpperCAmelCase		(						self  :			Dict)	->				Dict:




         """simple docstring"""

         lowercase__     =  B'\x80' + B'\x00' * (63 - (len(self.data) + 8) % 64)
         lowercase__     =  self.data + padding + struct.pack('>Q'			,				8 * len(self.data))
         return padded_data


   def 			UpperCAmelCase		(						self  :			int)	->				Tuple:




         """simple docstring"""

         return [
             self.padded_data[i : i + 64] for i in range(0			,				len(self.padded_data)			,				64)
         ]


   def 			UpperCAmelCase		(						self  :			Tuple			,				lowerCAmelCase  :			int)	->				List[Any]:




         """simple docstring"""

         lowercase__     =  list(struct.unpack('>16L'			,				lowerCAmelCase)) + [0] * 64
         for i in range(16			,				80):
               lowercase__     =  self.rotate((w[i - 3] ^ w[i - 8] ^ w[i - 14] ^ w[i - 16])			,				1)
         return w



   def 			UpperCAmelCase		(						self  :			str)	->				Dict:




         """simple docstring"""

         lowercase__     =  self.padding()
         lowercase__     =  self.split_blocks()
         for block in self.blocks:
               lowercase__     =  self.expand_block(lowerCAmelCase)
               lowercase__,	lowercase__,	lowercase__,	lowercase__,	lowercase__     =  self.h
               for i in range(0			,				80):
                     if 0 <= i < 20:
                           lowercase__     =  (b & c) | ((~b) & d)
                           lowercase__     =  0X5_A_8_2_7_9_9_9
                     elif 20 <= i < 40:
                           lowercase__     =  b ^ c ^ d
                           lowercase__     =  0X6_E_D_9_E_B_A_1
                     elif 40 <= i < 60:
                           lowercase__     =  (b & c) | (b & d) | (c & d)
                           lowercase__     =  0X8_F_1_B_B_C_D_C
                     elif 60 <= i < 80:
                           lowercase__     =  b ^ c ^ d
                           lowercase__     =  0XC_A_6_2_C_1_D_6
                     lowercase__,	lowercase__,	lowercase__,	lowercase__,	lowercase__     =  (
                         self.rotate(lowerCAmelCase			,				5) + f + e + k + expanded_block[i] & 0XF_F_F_F_F_F_F_F,
                         a,
                         self.rotate(lowerCAmelCase			,				30),
                         c,
                         d,
                     )
               lowercase__     =  (
                   self.h[0] + a & 0XF_F_F_F_F_F_F_F,
                   self.h[1] + b & 0XF_F_F_F_F_F_F_F,
                   self.h[2] + c & 0XF_F_F_F_F_F_F_F,
                   self.h[3] + d & 0XF_F_F_F_F_F_F_F,
                   self.h[4] + e & 0XF_F_F_F_F_F_F_F,
               )
         return ("{:08x}" * 5).format(*self.h)

def   _lowerCAmelCase   (						):
      lowercase__     =  B'Test String'
      assert SHAaHash(A__	).final_hash() == hashlib.shaa(A__	).hexdigest()  # noqa: S324

def   _lowerCAmelCase   (						):
      lowercase__     =  argparse.ArgumentParser(description='Process some strings or files'	)
      parser.add_argument(
          '--string'						,  dest='input_string'						,  default='Hello World!! Welcome to Cryptography'						,  help='Hash the string'						,  )
      parser.add_argument('--file'						,  dest='input_file'						,  help='Hash contents of a file'	)
      lowercase__     =  parser.parse_args()
      lowercase__     =  args.input_string
      # In any case hash input should be a bytestring
      if args.input_file:
            with open(args.input_file						,  'rb'	) as f:
                  lowercase__     =  f.read()
      else:
            lowercase__     =  bytes(A__						,  'utf-8'	)
      print(SHAaHash(A__	).final_hash()	)


if __name__ == "__main__":
       main()
       import doctest

       doctest.testmod()
