






'''simple docstring'''







from __future__ import annotations

import random
import unittest

from transformers import TransfoXLConfig, is_tf_available
from transformers.testing_utils import require_tf, slow

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
							import tensorflow as tf

							from transformers import (
							    TF_TRANSFO_XL_PRETRAINED_MODEL_ARCHIVE_LIST,
							    TFTransfoXLForSequenceClassification,
							    TFTransfoXLLMHeadModel,
							    TFTransfoXLModel,
							)




class 		UpperCamelCase__    :




		'''simple docstring'''





		def __init__(      self   ,_lowerCAmelCase   ,):
								lowerCamelCase__         =  parent
								lowerCamelCase__         =  13
								lowerCamelCase__         =  7
								lowerCamelCase__         =  30
								lowerCamelCase__         =  self.seq_length + self.mem_len
								lowerCamelCase__         =  15
								lowerCamelCase__         =  True
								lowerCamelCase__         =  True
								lowerCamelCase__         =  99
								lowerCamelCase__         =  [10, 50, 80]
								lowerCamelCase__         =  32
								lowerCamelCase__         =  32
								lowerCamelCase__         =  4
								lowerCamelCase__         =  8
								lowerCamelCase__         =  1_28
								lowerCamelCase__         =  2
								lowerCamelCase__         =  2
								lowerCamelCase__         =  None
								lowerCamelCase__         =  1
								lowerCamelCase__         =  0
								lowerCamelCase__         =  3
								lowerCamelCase__         =  self.vocab_size - 1
								lowerCamelCase__         =  0.01






		def 			UpperCamelCase_					(      self       ):
								lowerCamelCase__         =  ids_tensor([self.batch_size, self.seq_length]   ,self.vocab_size       )
								lowerCamelCase__         =  ids_tensor([self.batch_size, self.seq_length]   ,self.vocab_size       )

								lowerCamelCase__         =  None
								if self.use_labels:
														lowerCamelCase__         =  ids_tensor([self.batch_size, self.seq_length]   ,self.vocab_size       )

								lowerCamelCase__         =  TransfoXLConfig(
								    vocab_size=self.vocab_size   ,mem_len=self.mem_len   ,clamp_len=self.clamp_len   ,cutoffs=self.cutoffs   ,d_model=self.hidden_size   ,d_embed=self.d_embed   ,n_head=self.num_attention_heads   ,d_head=self.d_head   ,d_inner=self.d_inner   ,div_val=self.div_val   ,n_layer=self.num_hidden_layers   ,eos_token_id=self.eos_token_id   ,pad_token_id=self.vocab_size - 1   ,init_range=self.init_range   ,num_labels=self.num_labels   ,)

								return (config, input_ids_a, input_ids_a, lm_labels)






		def 			UpperCamelCase_					(      self       ):
								random.seed(self.seed       )
								tf.random.set_seed(self.seed       )






		def 			UpperCamelCase_					(      self   ,_lowerCAmelCase   ,_lowerCAmelCase   ,_lowerCAmelCase   ,_lowerCAmelCase       ):
								lowerCamelCase__         =  TFTransfoXLModel(_lowerCAmelCase       )

								lowerCamelCase__       ,			lowerCamelCase__         =  model(_lowerCAmelCase       ).to_tuple()

								lowerCamelCase__         =  {"""input_ids""": input_ids_a, """mems""": mems_a}

								lowerCamelCase__       ,			lowerCamelCase__         =  model(_lowerCAmelCase       ).to_tuple()

								self.parent.assertEqual(hidden_states_a.shape   ,(self.batch_size, self.seq_length, self.hidden_size)       )
								self.parent.assertEqual(hidden_states_a.shape   ,(self.batch_size, self.seq_length, self.hidden_size)       )
								self.parent.assertListEqual(
								    [mem.shape for mem in mems_a]   ,[(self.mem_len, self.batch_size, self.hidden_size)] * self.num_hidden_layers   ,)
								self.parent.assertListEqual(
								    [mem.shape for mem in mems_a]   ,[(self.mem_len, self.batch_size, self.hidden_size)] * self.num_hidden_layers   ,)






		def 			UpperCamelCase_					(      self   ,_lowerCAmelCase   ,_lowerCAmelCase   ,_lowerCAmelCase   ,_lowerCAmelCase       ):
								lowerCamelCase__         =  TFTransfoXLLMHeadModel(_lowerCAmelCase       )

								lowerCamelCase__       ,			lowerCamelCase__         =  model(_lowerCAmelCase       ).to_tuple()

								lowerCamelCase__         =  {"""input_ids""": input_ids_a, """labels""": lm_labels}
								lowerCamelCase__       ,			lowerCamelCase__         =  model(_lowerCAmelCase       ).to_tuple()

								lowerCamelCase__       ,			lowerCamelCase__         =  model([input_ids_a, mems_a]       ).to_tuple()

								lowerCamelCase__         =  {"""input_ids""": input_ids_a, """mems""": mems_a, """labels""": lm_labels}

								lowerCamelCase__       ,			lowerCamelCase__         =  model(_lowerCAmelCase       ).to_tuple()

								self.parent.assertEqual(lm_logits_a.shape   ,(self.batch_size, self.seq_length, self.vocab_size)       )
								self.parent.assertListEqual(
								    [mem.shape for mem in mems_a]   ,[(self.mem_len, self.batch_size, self.hidden_size)] * self.num_hidden_layers   ,)

								self.parent.assertEqual(lm_logits_a.shape   ,(self.batch_size, self.seq_length, self.vocab_size)       )
								self.parent.assertListEqual(
								    [mem.shape for mem in mems_a]   ,[(self.mem_len, self.batch_size, self.hidden_size)] * self.num_hidden_layers   ,)






		def 			UpperCamelCase_					(      self   ,_lowerCAmelCase   ,_lowerCAmelCase   ,_lowerCAmelCase   ,_lowerCAmelCase       ):
								lowerCamelCase__         =  TFTransfoXLForSequenceClassification(_lowerCAmelCase       )
								lowerCamelCase__         =  model(_lowerCAmelCase       )
								self.parent.assertEqual(result.logits.shape   ,(self.batch_size, self.num_labels)       )






		def 			UpperCamelCase_					(      self       ):
								lowerCamelCase__         =  self.prepare_config_and_inputs()
								((lowerCamelCase__)       ,			(lowerCamelCase__)       ,			(lowerCamelCase__)       ,			(lowerCamelCase__))         =  config_and_inputs
								lowerCamelCase__         =  {"""input_ids""": input_ids_a}
								return config, inputs_dict




@require_tf
class 		UpperCamelCase__    (a   ,a   ,unittest.TestCase			):




		'''simple docstring'''





		_UpperCamelCase				  =					(
		    (TFTransfoXLModel, TFTransfoXLLMHeadModel, TFTransfoXLForSequenceClassification) if is_tf_available() else ()
		)
		_UpperCamelCase				  =					() if is_tf_available() else ()
		_UpperCamelCase				  =					(
		    {
		        'feature-extraction': TFTransfoXLModel,
		        'text-classification': TFTransfoXLForSequenceClassification,
		        'text-generation': TFTransfoXLLMHeadModel,
		        'zero-shot': TFTransfoXLForSequenceClassification,
		    }
		    if is_tf_available()
		    else {}
		)
		# TODO: add this test when TFTransfoXLLMHead has a linear output layer implemented
		_UpperCamelCase				  =					False
		_UpperCamelCase				  =					False
		_UpperCamelCase				  =					False
		_UpperCamelCase				  =					False






		def 			UpperCamelCase_					(      self   ,_lowerCAmelCase   ,_lowerCAmelCase   ,_lowerCAmelCase   ,_lowerCAmelCase   ,_lowerCAmelCase       ):
								if pipeline_test_casse_name == "TextGenerationPipelineTests":
														# Get `ValueError: AttributeError: 'NoneType' object has no attribute 'new_ones'` or `AssertionError`.
														# `TransfoXLConfig` was never used in pipeline tests: cannot create a simple
														# tokenizer.
														return True

								return False






		def 			UpperCamelCase_					(      self       ):
								lowerCamelCase__         =  TFTransfoXLModelTester(self       )
								lowerCamelCase__         =  ConfigTester(self   ,config_class=_lowerCAmelCase   ,d_embed=37       )






		def 			UpperCamelCase_					(      self       ):
								self.config_tester.run_common_tests()






		def 			UpperCamelCase_					(      self       ):
								self.model_tester.set_seed()
								lowerCamelCase__         =  self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_transfo_xl_model(*_lowerCAmelCase       )






		def 			UpperCamelCase_					(      self       ):
								self.model_tester.set_seed()
								lowerCamelCase__         =  self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_transfo_xl_lm_head(*_lowerCAmelCase       )






		def 			UpperCamelCase_					(      self       ):
								lowerCamelCase__         =  self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_transfo_xl_for_sequence_classification(*_lowerCAmelCase       )






		def 			UpperCamelCase_					(      self       ):
								lowerCamelCase__       ,			lowerCamelCase__         =  self.model_tester.prepare_config_and_inputs_for_common()
								lowerCamelCase__         =  [TFTransfoXLForSequenceClassification]

								for model_class in self.all_model_classes:
														lowerCamelCase__         =  model_class(_lowerCAmelCase       )
														assert isinstance(model.get_input_embeddings()   ,tf.keras.layers.Layer       )
														if model_class in list_other_models_with_output_ebd:
																				lowerCamelCase__         =  model.get_output_embeddings()
																				assert isinstance(_lowerCAmelCase   ,tf.keras.layers.Layer       )
																				lowerCamelCase__         =  model.get_bias()
																				assert name is None
														else:
																				lowerCamelCase__         =  model.get_output_embeddings()
																				assert x is None
																				lowerCamelCase__         =  model.get_bias()
																				assert name is None






		def 			UpperCamelCase_					(      self       ):
								# TODO JP: Make TransfoXL XLA compliant
								pass






		@slow
		def 			UpperCamelCase_					(      self       ):
								for model_name in TF_TRANSFO_XL_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
														lowerCamelCase__         =  TFTransfoXLModel.from_pretrained(_lowerCAmelCase       )
														self.assertIsNotNone(_lowerCAmelCase       )






		@unittest.skip(reason="""This model doesn't play well with fit() due to not returning a single loss."""       )
		def 			UpperCamelCase_					(      self       ):
								pass




@require_tf
class 		UpperCamelCase__    (unittest.TestCase			):




		'''simple docstring'''





		@unittest.skip("""Skip test until #12651 is resolved."""       )
		@slow
		def 			UpperCamelCase_					(      self       ):
								lowerCamelCase__         =  TFTransfoXLLMHeadModel.from_pretrained("""transfo-xl-wt103"""       )
								# fmt: off
								lowerCamelCase__         =  tf.convert_to_tensor([[33,12_97,2,1,10_09,4,11_09,1_17_39,47_62,3_58,5,25,2_45,22,17_06,17,2_00_98,5,32_15,21,37,11_10,3,13,10_41,4,24,6_03,4_90,2,7_14_77,2_00_98,10_44_47,2,2_09_61,1,26_04,4,1,3_29,3,62_24,8_31,1_60_02,2,8,6_03,7_89_67,2_95_46,23,8_03,20,25,4_16,5,8,2_32,4,2_77,6,18_55,46_01,3,2_95_46,54,8,36_09,5,5_72_11,49,4,1,2_77,18,8,17_55,1_56_91,3,3_41,25,4_16,6_93,4_25_73,71,17,4_01,94,31,1_79_19,2,2_95_46,78_73,18,1,4_35,23,1_10_11,7_55,5,51_67,3,79_83,98,84,2,2_95_46,32_67,8,36_09,4,1,48_65,10_75,2,60_87,71,6,3_46,8,58_54,3,2_95_46,8_24,14_00,18_68,2,19,1_60,2,3_11,8,54_96,2,2_09_20,17,25,1_50_97,3,24,24,0]]   ,dtype=tf.intaa       )  # noqa: E231
								# fmt: on
								#  In 1991 , the remains of Russian Tsar Nicholas II and his family
								#  ( except for Alexei and Maria ) are discovered .
								#  The voice of Nicholas's young son , Tsarevich Alexei Nikolaevich , narrates the
								#  remainder of the story . 1883 Western Siberia ,
								#  a young Grigori Rasputin is asked by his father and a group of men to perform magic .
								#  Rasputin has a vision and denounces one of the men as a horse thief . Although his
								#  father initially slaps him for making such an accusation , Rasputin watches as the
								#  man is chased outside and beaten . Twenty years later , Rasputin sees a vision of
								#  the Virgin Mary , prompting him to become a priest . Rasputin quickly becomes famous ,
								#  with people , even a bishop , begging for his blessing . <eod> </s> <eos>

								# fmt: off
								lowerCamelCase__         =  [33,12_97,2,1,10_09,4,11_09,1_17_39,47_62,3_58,5,25,2_45,22,17_06,17,2_00_98,5,32_15,21,37,11_10,3,13,10_41,4,24,6_03,4_90,2,7_14_77,2_00_98,10_44_47,2,2_09_61,1,26_04,4,1,3_29,3,62_24,8_31,1_60_02,2,8,6_03,7_89_67,2_95_46,23,8_03,20,25,4_16,5,8,2_32,4,2_77,6,18_55,46_01,3,2_95_46,54,8,36_09,5,5_72_11,49,4,1,2_77,18,8,17_55,1_56_91,3,3_41,25,4_16,6_93,4_25_73,71,17,4_01,94,31,1_79_19,2,2_95_46,78_73,18,1,4_35,23,1_10_11,7_55,5,51_67,3,79_83,98,84,2,2_95_46,32_67,8,36_09,4,1,48_65,10_75,2,60_87,71,6,3_46,8,58_54,3,2_95_46,8_24,14_00,18_68,2,19,1_60,2,3_11,8,54_96,2,2_09_20,17,25,1_50_97,3,24,24,0,33,1,18_57,2,1,10_09,4,11_09,1_17_39,47_62,3_58,5,25,2_45,28,11_10,3,13,10_41,4,24,6_03,4_90,2,7_14_77,2_00_98,10_44_47,2,2_09_61,1,26_04,4,1,3_29,3,0]  # noqa: E231
								# fmt: on
								#  In 1991, the remains of Russian Tsar Nicholas II and his family (
								#  except for Alexei and Maria ) are discovered. The voice of young son,
								#  Tsarevich Alexei Nikolaevich, narrates the remainder of the story.
								#  1883 Western Siberia, a young Grigori Rasputin is asked by his father
								#  and a group of men to perform magic. Rasputin has a vision and
								#  denounces one of the men as a horse thief. Although his father initially
								#  slaps him for making such an accusation, Rasputin watches as the man
								#  is chased outside and beaten. Twenty years later, Rasputin sees a vision
								#  of the Virgin Mary, prompting him to become a priest.
								#  Rasputin quickly becomes famous, with people, even a bishop, begging for
								#  his blessing. <unk> <unk> <eos> In the 1990s, the remains of Russian Tsar
								# Nicholas II and his family were discovered. The voice of <unk> young son,
								# Tsarevich Alexei Nikolaevich, narrates the remainder of the story.<eos>

								lowerCamelCase__         =  model.generate(_lowerCAmelCase   ,max_length=2_00   ,do_sample=_lowerCAmelCase       )
								self.assertListEqual(output_ids[0].numpy().tolist()   ,_lowerCAmelCase       )









'''simple docstring'''







import argparse
import struct
import unittest




class 		UpperCamelCase__    :




		'''simple docstring'''





		def __init__(      self   ,_lowerCAmelCase       ):
								lowerCamelCase__         =  data

								# Initialize hash values
								lowerCamelCase__         =  [
								    0x6a_09_e6_67,
								    0xbb_67_ae_85,
								    0x3c_6e_f3_72,
								    0xa5_4f_f5_3a,
								    0x51_0e_52_7f,
								    0x9b_05_68_8c,
								    0x1f_83_d9_ab,
								    0x5b_e0_cd_19,
								]

								# Initialize round constants
								lowerCamelCase__         =  [
								    0x42_8a_2f_98,
								    0x71_37_44_91,
								    0xb5_c0_fb_cf,
								    0xe9_b5_db_a5,
								    0x39_56_c2_5b,
								    0x59_f1_11_f1,
								    0x92_3f_82_a4,
								    0xab_1c_5e_d5,
								    0xd8_07_aa_98,
								    0x12_83_5b_01,
								    0x24_31_85_be,
								    0x55_0c_7d_c3,
								    0x72_be_5d_74,
								    0x80_de_b1_fe,
								    0x9b_dc_06_a7,
								    0xc1_9b_f1_74,
								    0xe4_9b_69_c1,
								    0xef_be_47_86,
								    0x0f_c1_9d_c6,
								    0x24_0c_a1_cc,
								    0x2d_e9_2c_6f,
								    0x4a_74_84_aa,
								    0x5c_b0_a9_dc,
								    0x76_f9_88_da,
								    0x98_3e_51_52,
								    0xa8_31_c6_6d,
								    0xb0_03_27_c8,
								    0xbf_59_7f_c7,
								    0xc6_e0_0b_f3,
								    0xd5_a7_91_47,
								    0x06_ca_63_51,
								    0x14_29_29_67,
								    0x27_b7_0a_85,
								    0x2e_1b_21_38,
								    0x4d_2c_6d_fc,
								    0x53_38_0d_13,
								    0x65_0a_73_54,
								    0x76_6a_0a_bb,
								    0x81_c2_c9_2e,
								    0x92_72_2c_85,
								    0xa2_bf_e8_a1,
								    0xa8_1a_66_4b,
								    0xc2_4b_8b_70,
								    0xc7_6c_51_a3,
								    0xd1_92_e8_19,
								    0xd6_99_06_24,
								    0xf4_0e_35_85,
								    0x10_6a_a0_70,
								    0x19_a4_c1_16,
								    0x1e_37_6c_08,
								    0x27_48_77_4c,
								    0x34_b0_bc_b5,
								    0x39_1c_0c_b3,
								    0x4e_d8_aa_4a,
								    0x5b_9c_ca_4f,
								    0x68_2e_6f_f3,
								    0x74_8f_82_ee,
								    0x78_a5_63_6f,
								    0x84_c8_78_14,
								    0x8c_c7_02_08,
								    0x90_be_ff_fa,
								    0xa4_50_6c_eb,
								    0xbe_f9_a3_f7,
								    0xc6_71_78_f2,
								]

								lowerCamelCase__         =  self.preprocessing(self.data       )
								self.final_hash()






		@staticmethod
		def 			UpperCamelCase_					(      _lowerCAmelCase       ):
								lowerCamelCase__         =  B"""\x80""" + (B"""\x00""" * (63 - (len(_lowerCAmelCase       ) + 8) % 64))
								lowerCamelCase__         =  struct.pack(""">Q"""   ,(len(_lowerCAmelCase       ) * 8)       )
								return data + padding + big_endian_integer






		def 			UpperCamelCase_					(      self       ):
								# Convert into blocks of 64 bytes
								lowerCamelCase__         =  [
								    self.preprocessed_data[x : x + 64]
								    for x in range(0   ,len(self.preprocessed_data       )   ,64       )
								]

								for block in self.blocks:
														# Convert the given block into a list of 4 byte integers
														lowerCamelCase__         =  list(struct.unpack(""">16L"""   ,_lowerCAmelCase       )       )
														# add 48 0-ed integers
														words += [0] * 48

														lowerCamelCase__       ,			lowerCamelCase__       ,			lowerCamelCase__       ,			lowerCamelCase__       ,			lowerCamelCase__       ,			lowerCamelCase__       ,			lowerCamelCase__       ,			lowerCamelCase__         =  self.hashes

														for index in range(0   ,64       ):
																				if index > 15:
																										# modify the zero-ed indexes at the end of the array
																										lowerCamelCase__         =  (
																										    self.ror(words[index - 15]   ,7       )
																										    ^ self.ror(words[index - 15]   ,18       )
																										    ^ (words[index - 15] >> 3)
																										)
																										lowerCamelCase__         =  (
																										    self.ror(words[index - 2]   ,17       )
																										    ^ self.ror(words[index - 2]   ,19       )
																										    ^ (words[index - 2] >> 10)
																										)

																										lowerCamelCase__         =  (
																										    words[index - 16] + sa + words[index - 7] + sa
																										) % 0x1_00_00_00_00

																				# Compression
																				lowerCamelCase__         =  self.ror(_lowerCAmelCase   ,6       ) ^ self.ror(_lowerCAmelCase   ,11       ) ^ self.ror(_lowerCAmelCase   ,25       )
																				lowerCamelCase__         =  (e & f) ^ ((~e & 0xff_ff_ff_ff) & g)
																				lowerCamelCase__         =  (
																				    h + sa + ch + self.round_constants[index] + words[index]
																				) % 0x1_00_00_00_00
																				lowerCamelCase__         =  self.ror(_lowerCAmelCase   ,2       ) ^ self.ror(_lowerCAmelCase   ,13       ) ^ self.ror(_lowerCAmelCase   ,22       )
																				lowerCamelCase__         =  (a & b) ^ (a & c) ^ (b & c)
																				lowerCamelCase__         =  (sa + maj) % 0x1_00_00_00_00

																				lowerCamelCase__       ,			lowerCamelCase__       ,			lowerCamelCase__       ,			lowerCamelCase__       ,			lowerCamelCase__       ,			lowerCamelCase__       ,			lowerCamelCase__       ,			lowerCamelCase__         =  (
																				    g,
																				    f,
																				    e,
																				    ((d + tempa) % 0x1_00_00_00_00),
																				    c,
																				    b,
																				    a,
																				    ((tempa + tempa) % 0x1_00_00_00_00),
																				)

														lowerCamelCase__         =  [a, b, c, d, e, f, g, h]

														# Modify final values
														lowerCamelCase__         =  [
														    ((element + mutated_hash_values[index]) % 0x1_00_00_00_00)
														    for index, element in enumerate(self.hashes       )
														]

								lowerCamelCase__         =  """""".join([hex(_lowerCAmelCase       )[2:].zfill(8       ) for value in self.hashes]       )






		def 			UpperCamelCase_					(      self   ,_lowerCAmelCase   ,_lowerCAmelCase       ):
								return 0xff_ff_ff_ff & (value << (32 - rotations)) | (value >> rotations)




class 		UpperCamelCase__    (unittest.TestCase			):




		'''simple docstring'''





		def 			UpperCamelCase_					(      self       ):
								import hashlib

								lowerCamelCase__         =  bytes("""Test String"""   ,"""utf-8"""       )
								self.assertEqual(SHAaaa(_lowerCAmelCase       ).hash   ,hashlib.shaaaa(_lowerCAmelCase       ).hexdigest()       )



def 						A__			(				):
						import doctest

						doctest.testmod()

						lowerCamelCase__         =  argparse.ArgumentParser()
						parser.add_argument(
						    """-s"""   ,    """--string"""   ,    dest="""input_string"""   ,    default="""Hello World!! Welcome to Cryptography"""   ,    help="""Hash the string"""   ,    )
						parser.add_argument(
						    """-f"""   ,    """--file"""   ,    dest="""input_file"""   ,    help="""Hash contents of a file"""						)

						lowerCamelCase__         =  parser.parse_args()

						lowerCamelCase__         =  args.input_string

						# hash input should be a bytestring
						if args.input_file:
												with open(args.input_file   ,    """rb"""						) as f:
																		lowerCamelCase__         =  f.read()
						else:
												lowerCamelCase__         =  bytes(__lowerCAmelCase   ,    """utf-8"""						)

						print(SHAaaa(__lowerCAmelCase						).hash						)


if __name__ == "__main__":
							main()

